skgpu::graphite::Transform Class Reference

#include <Transform_graphite.h>

Public Types
enum class	Type : unsigned {   kIdentity , kSimpleRectStaysRect , kRectStaysRect , kAffine ,   kPerspective , kInvalid }

Public Member Functions
	Transform (const SkM44 &m)
	Transform (const Transform &t)=default
Transform &	operator= (const Transform &t)=default
	operator const SkM44 & () const
	operator SkMatrix () const
bool	operator!= (const Transform &t) const
bool	operator== (const Transform &t) const
const SkM44 &	matrix () const
const SkM44 &	inverse () const
Type	type () const
bool	valid () const
std::pair< float, float >	scaleFactors (const SkV2 &p) const
float	maxScaleFactor () const
float	localAARadius (const Rect &bounds) const
Rect	mapRect (const Rect &rect) const
Rect	inverseMapRect (const Rect &rect) const
void	mapPoints (const Rect &localRect, SkV4 deviceOut[4]) const
void	mapPoints (const SkV2 *localIn, SkV4 *deviceOut, int count) const
void	mapPoints (const SkV4 *localIn, SkV4 *deviceOut, int count) const
void	inverseMapPoints (const SkV4 *deviceIn, SkV4 *localOut, int count) const
Transform	preTranslate (float x, float y) const
Transform	postTranslate (float x, float y) const
Transform	concat (const Transform &t) const
Transform	concat (const SkM44 &t) const
Transform	concatInverse (const Transform &t) const
Transform	concatInverse (const SkM44 &t) const

Static Public Member Functions
static constexpr Transform	Identity ()
static constexpr Transform	Invalid ()
static Transform	Translate (float x, float y)
static Transform	Inverse (const Transform &t)

Detailed Description

Definition at line 19 of file Transform_graphite.h.

Member Enumeration Documentation

Type

enum class skgpu::graphite::Transform::Type : unsigned

strong

Enumerator
kIdentity
kSimpleRectStaysRect
kRectStaysRect
kAffine
kPerspective
kInvalid

Definition at line 23 of file Transform_graphite.h.

                    : unsigned {
        // Applying the matrix to a vector or point is a no-op, so could be skipped entirely.
        kIdentity,
        // The matrix transforms a rect to another rect, without mirrors or rotations, so both
        // pre-and-post transform coordinates can be exactly represented as rects.
        kSimpleRectStaysRect,
        // The matrix transforms a rect to another rect, but may mirror or rotate the corners
        // relative to each other. This means that the post-transformed rect completely fills
        // that space.
        kRectStaysRect,
        // The matrix transform may have skew or rotation, so a mapped rect does not fill space,
        // but there is no need to perform perspective division or w-plane clipping. This also
        // includes orthographic projections.
        kAffine,
        // The matrix includes perspective and requires further projection to 2D, so care must be
        // taken when w is less than or near 0, and homogeneous division and perspective-correct
        // interpolation are needed when rendering.
        kPerspective,
        // The matrix is not invertible or not finite, so should not be used to draw.
        kInvalid,
    };

Constructor & Destructor Documentation

Transform() [1/2]

skgpu::graphite::Transform::Transform ( const SkM44 &  m )

explicit

Definition at line 69 of file Transform.cpp.

                                   : fM(m) {
    static constexpr SkV4 kNoPerspective = {0.f, 0.f, 0.f, 1.f};
    static constexpr SkV4 kNoZ           = {0.f, 0.f, 1.f, 0.f};
    if (m.row(3) != kNoPerspective) {
        // Perspective matrices will have per-location scale factors calculated, so cached scale
        // factors will not be used.
        if (m.invert(&fInvM)) {
            fType = Type::kPerspective;
        } else {
            fType = Type::kInvalid;
        }
        return;
    } else if (m.col(2) != kNoZ || m.row(2) != kNoZ) {
        // Orthographic matrices are lumped into the kAffine type although we use SkM44::invert()
        // instead of taking short cuts.
        if (m.invert(&fInvM)) {
            fType = Type::kAffine;
            // These scale factors are valid for the case where Z=0, which is the case for all
            // local geometry that's drawn.
            std::tie(fMinScaleFactor, fMaxScaleFactor) = compute_svd(m.rc(0,0), m.rc(0,1),
                                                                     m.rc(1,0), m.rc(1,1));
        } else {
            fType = Type::kInvalid;
        }
        return;
    }
 
    //                                              [sx kx 0 tx]
    // At this point, we know that m is of the form [ky sy 0 ty]
    //                                              [0  0  1 0 ]
    //                                              [0  0  0 1 ]
    // Other than kIdentity, none of the types depend on (tx, ty). The remaining types are
    // identified by considering the upper 2x2 (tx and ty are still used to compute the inverse).
    const float sx = m.rc(0, 0);
    const float sy = m.rc(1, 1);
    const float kx = m.rc(0, 1);
    const float ky = m.rc(1, 0);
    const float tx = m.rc(0, 3);
    const float ty = m.rc(1, 3);
    if (kx == 0.f && ky == 0.f) {
        // 2x2 is a diagonal matrix
        if (sx == 0.f || sy == 0.f) {
            // Not invertible
            fType = Type::kInvalid;
        } else if (sx == 1.f && sy == 1.f && tx == 0.f && ty == 0.f) {
            fType = Type::kIdentity;
            fInvM.setIdentity();
        } else {
            const float ix = 1.f / sx;
            const float iy = 1.f / sy;
            fType = sx > 0.f && sy > 0.f ? Type::kSimpleRectStaysRect
                                         : Type::kRectStaysRect;
            fInvM = SkM44(ix, 0.f, 0.f, -ix*tx,
                          0.f, iy, 0.f, -iy*ty,
                          0.f, 0.f, 1.f, 0.f,
                          0.f, 0.f, 0.f, 1.f);
            std::tie(fMinScaleFactor, fMaxScaleFactor) = sort_scale(sx, sy);
        }
    } else if (sx == 0.f && sy == 0.f) {
        // 2x2 is an anti-diagonal matrix and represents a 90 or 270 degree rotation plus optional
        // scale and translate.
        if (kx == 0.f || ky == 0.f) {
            // Not invertible
            fType = Type::kInvalid;
        } else {
            const float ix = 1.f / kx;
            const float iy = 1.f / ky;
            fType = Type::kRectStaysRect;
            fInvM = SkM44(0.f, iy, 0.f, -iy*ty,
                          ix, 0.f, 0.f, -ix*tx,
                          0.f, 0.f, 1.f, 0.f,
                          0.f, 0.f, 0.f, 1.f);
            std::tie(fMinScaleFactor, fMaxScaleFactor) = sort_scale(kx, ky);
        }
    } else {
        // Invert just the upper 2x2 and derive inverse translation from that
        float upper[4] = {sx, ky, kx, sy}; // col-major
        float invUpper[4];
        if (SkInvert2x2Matrix(upper, invUpper) == 0.f) {
            // 2x2 was not invertible, so the original matrix won't be invertible either
            fType = Type::kInvalid;
        } else {
            fType = Type::kAffine;
            fInvM = SkM44(invUpper[0], invUpper[2], 0.f, -invUpper[0]*tx - invUpper[2]*ty,
                          invUpper[1], invUpper[3], 0.f, -invUpper[1]*tx - invUpper[3]*ty,
                          0.f, 0.f, 1.f, 0.f,
                          0.f, 0.f, 0.f, 1.f);
            std::tie(fMinScaleFactor, fMaxScaleFactor) = compute_svd(sx, kx, ky, sy);
        }
    }
}

Transform() [2/2]

skgpu::graphite::Transform::Transform ( const Transform &  t )

default

Member Function Documentation

concat() [1/2]

Transform skgpu::graphite::Transform::concat ( const SkM44 &  t ) const

inline

Definition at line 129 of file Transform_graphite.h.

                                           {
        SkASSERT(this->valid());
        return Transform(fM * t);
    }

concat() [2/2]

Transform skgpu::graphite::Transform::concat ( const Transform &  t ) const

inline

Definition at line 125 of file Transform_graphite.h.

                                               {
        SkASSERT(this->valid());
        return Transform(fM * t.fM);
    }

concatInverse() [1/2]

Transform skgpu::graphite::Transform::concatInverse ( const SkM44 &  t ) const

inline

Definition at line 139 of file Transform_graphite.h.

                                                  {
        SkASSERT(this->valid());
        // Saves a multiply compared to inverting just 't' and calculating both fM*t^-1 and t*fInvM
        // (t * this^-1)^-1 = this * t^-1
        return Inverse(Transform(t * fInvM));
    }

concatInverse() [2/2]

Transform skgpu::graphite::Transform::concatInverse ( const Transform &  t ) const

inline

Definition at line 135 of file Transform_graphite.h.

                                                      {
        SkASSERT(this->valid());
        return Transform(fM * t.fInvM);
    }

Identity()

static constexpr Transform skgpu::graphite::Transform::Identity ( )

inlinestaticconstexpr

Definition at line 48 of file Transform_graphite.h.

                                          {
        return Transform(SkM44(), SkM44(), Type::kIdentity, 1.f, 1.f);
    }

Invalid()

static constexpr Transform skgpu::graphite::Transform::Invalid ( )

inlinestaticconstexpr

Definition at line 51 of file Transform_graphite.h.

                                         {
        return Transform(SkM44(SkM44::kNaN_Constructor), SkM44(SkM44::kNaN_Constructor),
                         Type::kInvalid, 1.f, 1.f);
    }

inverse()

const SkM44 & skgpu::graphite::Transform::inverse ( ) const

inline

Definition at line 82 of file Transform_graphite.h.

{ return fInvM; }

Inverse()

static Transform skgpu::graphite::Transform::Inverse ( const Transform &  t )

inlinestatic

Definition at line 67 of file Transform_graphite.h.

                                                        {
        return Transform(t.fInvM, t.fM, t.fType, 1.f / t.fMaxScaleFactor, 1.f / t.fMinScaleFactor);
    }

inverseMapPoints()

void skgpu::graphite::Transform::inverseMapPoints	(	const SkV4 *	deviceIn,
		SkV4 *	localOut,
		int	count
	)		const

Definition at line 278 of file Transform.cpp.

                                                                                      {
    SkASSERT(this->valid());
    return map_points(fInvM, deviceIn, localOut, count);
}

inverseMapRect()

Rect skgpu::graphite::Transform::inverseMapRect

(

const Rect &

rect

)

const

Definition at line 245 of file Transform.cpp.

                                                     {
    SkASSERT(this->valid());
    return map_rect(fInvM, rect);
}

localAARadius()

float skgpu::graphite::Transform::localAARadius

(

const Rect &

bounds

)

const

Definition at line 213 of file Transform.cpp.

                                                       {
    SkASSERT(this->valid());
 
    float min;
    if (fType < Type::kPerspective) {
        // The scale factor is constant
        min = fMinScaleFactor;
    } else {
        // Calculate the minimum scale factor over the 4 corners of the bounding box
        float tl = std::get<0>(this->scaleFactors(SkV2{bounds.left(), bounds.top()}));
        float tr = std::get<0>(this->scaleFactors(SkV2{bounds.right(), bounds.top()}));
        float br = std::get<0>(this->scaleFactors(SkV2{bounds.right(), bounds.bot()}));
        float bl = std::get<0>(this->scaleFactors(SkV2{bounds.left(), bounds.bot()}));
        min = std::min(std::min(tl, tr), std::min(br, bl));
    }
 
    // Moving 1 from 'p' before transforming will move at least 'min' and at most 'max' from
    // the transformed point. Thus moving between [1/max, 1/min] pre-transformation means post
    // transformation moves between [1,max/min] so using 1/min as the local AA radius ensures that
    // the post-transformed point is at least 1px away from the original.
    float aaRadius = sk_ieee_float_divide(1.f, min);
    if (SkIsFinite(aaRadius)) {
        return aaRadius;
    } else {
        return SK_FloatInfinity;
    }
}

mapPoints() [1/3]

void skgpu::graphite::Transform::mapPoints	(	const Rect &	localRect,
		SkV4	deviceOut[4]
	)		const

Definition at line 250 of file Transform.cpp.

                                                                        {
    SkASSERT(this->valid());
    SkV2 localCorners[4] = {{localRect.left(),  localRect.top()},
                            {localRect.right(), localRect.top()},
                            {localRect.right(), localRect.bot()},
                            {localRect.left(),  localRect.bot()}};
    this->mapPoints(localCorners, deviceOut, 4);
}

mapPoints() [2/3]

void skgpu::graphite::Transform::mapPoints	(	const SkV2 *	localIn,
		SkV4 *	deviceOut,
		int	count
	)		const

Definition at line 259 of file Transform.cpp.

                                                                               {
    SkASSERT(this->valid());
    // TODO: These maybe should go into SkM44, since bulk point mapping seems generally useful
    auto c0 = skvx::float4::Load(SkMatrixPriv::M44ColMajor(fM) + 0);
    auto c1 = skvx::float4::Load(SkMatrixPriv::M44ColMajor(fM) + 4);
    // skip c2 since localIn's z is assumed to be 0
    auto c3 = skvx::float4::Load(SkMatrixPriv::M44ColMajor(fM) + 12);
 
    for (int i = 0; i < count; ++i) {
        auto p = c0 * localIn[i].x + c1 * localIn[i].y /* + c2*0.f */ + c3 /* *1.f */;
        p.store(deviceOut + i);
    }
}

mapPoints() [3/3]

void skgpu::graphite::Transform::mapPoints	(	const SkV4 *	localIn,
		SkV4 *	deviceOut,
		int	count
	)		const

Definition at line 273 of file Transform.cpp.

                                                                               {
    SkASSERT(this->valid());
    return map_points(fM, localIn, deviceOut, count);
}

mapRect()

Rect skgpu::graphite::Transform::mapRect

(

const Rect &

rect

)

const

Definition at line 241 of file Transform.cpp.

                                              {
    SkASSERT(this->valid());
    return map_rect(fM, rect);
}

matrix()

const SkM44 & skgpu::graphite::Transform::matrix ( ) const

inline

Definition at line 81 of file Transform_graphite.h.

{ return fM; }

maxScaleFactor()

float skgpu::graphite::Transform::maxScaleFactor ( ) const

inline

Definition at line 93 of file Transform_graphite.h.

                                 {
        SkASSERT(this->valid());
        return fMaxScaleFactor;
    }

operator const SkM44 &()

skgpu::graphite::Transform::operator const SkM44 & ( ) const

inline

Definition at line 73 of file Transform_graphite.h.

{ return fM; }

operator SkMatrix()

skgpu::graphite::Transform::operator SkMatrix ( ) const

inline

Definition at line 74 of file Transform_graphite.h.

{ return fM.asM33(); }

operator!=()

bool skgpu::graphite::Transform::operator!= ( const Transform &  t ) const

inline

Definition at line 76 of file Transform_graphite.h.

{ return !(*this == t); }

operator=()

Transform & skgpu::graphite::Transform::operator= ( const Transform &  t )

default

operator==()

bool skgpu::graphite::Transform::operator== ( const Transform &  t ) const

inline

Definition at line 77 of file Transform_graphite.h.

                                              {
        return this->valid() == t.valid() && (!this->valid() || fM == t.fM);
    }

postTranslate()

Transform skgpu::graphite::Transform::postTranslate ( float  x, float  y  ) const

inline

Definition at line 120 of file Transform_graphite.h.

                                                    {
        return Translate(x, y).concat(*this);
    }

preTranslate()

Transform skgpu::graphite::Transform::preTranslate ( float  x, float  y  ) const

inline

Definition at line 117 of file Transform_graphite.h.

                                                   {
        return this->concat(SkM44::Translate(x, y));
    }

scaleFactors()

std::pair< float, float > skgpu::graphite::Transform::scaleFactors

(

const SkV2 &

p

)

const

Definition at line 161 of file Transform.cpp.

                                                                 {
    SkASSERT(this->valid());
    if (fType < Type::kPerspective) {
        return {fMinScaleFactor, fMaxScaleFactor};
    }
 
    //              [m00 m01 * m03]                                 [f(u,v)]
    // Assuming M = [m10 m11 * m13], define the projected p'(u,v) = [g(u,v)] where
    //              [ *   *  *  * ]
    //              [m30 m31 * m33]
    //                                                        [x]     [u]
    // f(u,v) = x(u,v) / w(u,v), g(u,v) = y(u,v) / w(u,v) and [y] = M*[v]
    //                                                        [*] =   [0]
    //                                                        [w]     [1]
    //
    // x(u,v) = m00*u + m01*v + m03
    // y(u,v) = m10*u + m11*v + m13
    // w(u,v) = m30*u + m31*v + m33
    //
    // dx/du = m00, dx/dv = m01,
    // dy/du = m10, dy/dv = m11
    // dw/du = m30, dw/dv = m31
    //
    // df/du = (dx/du*w - x*dw/du)/w^2 = (m00*w - m30*x)/w^2 = (m00 - m30*f)/w
    // df/dv = (dx/dv*w - x*dw/dv)/w^2 = (m01*w - m31*x)/w^2 = (m01 - m31*f)/w
    // dg/du = (dy/du*w - y*dw/du)/w^2 = (m10*w - m30*y)/w^2 = (m10 - m30*g)/w
    // dg/dv = (dy/dv*w - y*dw/du)/w^2 = (m11*w - m31*y)/w^2 = (m11 - m31*g)/w
    //
    // Singular values of [df/du df/dv] define perspective correct minimum and maximum scale factors
    //                    [dg/du dg/dv]
    // for M evaluated at  (u,v)
    SkV4 devP = fM.map(p.x, p.y, 0.f, 1.f);
 
    const float dxdu = fM.rc(0,0);
    const float dxdv = fM.rc(0,1);
    const float dydu = fM.rc(1,0);
    const float dydv = fM.rc(1,1);
    const float dwdu = fM.rc(3,0);
    const float dwdv = fM.rc(3,1);
 
    float invW2 = sk_ieee_float_divide(1.f, (devP.w * devP.w));
    // non-persp has invW2 = 1, devP.w = 1, dwdu = 0, dwdv = 0
    float dfdu = (devP.w*dxdu - devP.x*dwdu) * invW2; // non-persp -> dxdu -> m00
    float dfdv = (devP.w*dxdv - devP.x*dwdv) * invW2; // non-persp -> dxdv -> m01
    float dgdu = (devP.w*dydu - devP.y*dwdu) * invW2; // non-persp -> dydu -> m10
    float dgdv = (devP.w*dydv - devP.y*dwdv) * invW2; // non-persp -> dydv -> m11
 
    // no-persp, these are the singular values of [m00,m01][m10,m11], which was already calculated
    // in get_matrix_info.
    return compute_svd(dfdu, dfdv, dgdu, dgdv);
}

Translate()

static Transform skgpu::graphite::Transform::Translate ( float  x, float  y  )

inlinestatic

Definition at line 56 of file Transform_graphite.h.

                                                        {
        if (x == 0.f && y == 0.f) {
            return Identity();
        } else if (SkIsFinite(x, y)) {
            return Transform(SkM44::Translate(x, y), SkM44::Translate(-x, -y),
                             Type::kSimpleRectStaysRect, 1.f, 1.f);
        } else {
            return Invalid();
        }
    }

type()

Type skgpu::graphite::Transform::type ( ) const

inline

Definition at line 84 of file Transform_graphite.h.

{ return fType; }

valid()

bool skgpu::graphite::Transform::valid ( ) const

inline

Definition at line 85 of file Transform_graphite.h.

{ return fType != Type::kInvalid; }

---

The documentation for this class was generated from the following files:

• third_party/skia/src/gpu/graphite/geom/Transform_graphite.h
• third_party/skia/src/gpu/graphite/geom/Transform.cpp