#include <SkMatrix.h>

Inheritance diagram for SkMatrix:

Public Types
enum	ScaleToFit { kFill_ScaleToFit , kStart_ScaleToFit , kCenter_ScaleToFit , kEnd_ScaleToFit }

enum	TypeMask { kIdentity_Mask = 0 , kTranslate_Mask = 0x01 , kScale_Mask = 0x02 , kAffine_Mask = 0x04 , kPerspective_Mask = 0x08 }

Public Member Functions
constexpr	SkMatrix ()

TypeMask	getType () const

bool	isIdentity () const

bool	isScaleTranslate () const

bool	isTranslate () const

bool	rectStaysRect () const

bool	preservesAxisAlignment () const

bool	hasPerspective () const

bool	isSimilarity (SkScalar tol=SK_ScalarNearlyZero) const

bool	preservesRightAngles (SkScalar tol=SK_ScalarNearlyZero) const

SkScalar	operator[] (int index) const

SkScalar	get (int index) const

SkScalar	rc (int r, int c) const

SkScalar	getScaleX () const

SkScalar	getScaleY () const

SkScalar	getSkewY () const

SkScalar	getSkewX () const

SkScalar	getTranslateX () const

SkScalar	getTranslateY () const

SkScalar	getPerspX () const

SkScalar	getPerspY () const

SkScalar &	operator[] (int index)

SkMatrix &	set (int index, SkScalar value)

SkMatrix &	setScaleX (SkScalar v)

SkMatrix &	setScaleY (SkScalar v)

SkMatrix &	setSkewY (SkScalar v)

SkMatrix &	setSkewX (SkScalar v)

SkMatrix &	setTranslateX (SkScalar v)

SkMatrix &	setTranslateY (SkScalar v)

SkMatrix &	setPerspX (SkScalar v)

SkMatrix &	setPerspY (SkScalar v)

SkMatrix &	setAll (SkScalar scaleX, SkScalar skewX, SkScalar transX, SkScalar skewY, SkScalar scaleY, SkScalar transY, SkScalar persp0, SkScalar persp1, SkScalar persp2)

void	get9 (SkScalar buffer[9]) const

SkMatrix &	set9 (const SkScalar buffer[9])

SkMatrix &	reset ()

SkMatrix &	setIdentity ()

SkMatrix &	setTranslate (SkScalar dx, SkScalar dy)

SkMatrix &	setTranslate (const SkVector &v)

SkMatrix &	setScale (SkScalar sx, SkScalar sy, SkScalar px, SkScalar py)

SkMatrix &	setScale (SkScalar sx, SkScalar sy)

SkMatrix &	setRotate (SkScalar degrees, SkScalar px, SkScalar py)

SkMatrix &	setRotate (SkScalar degrees)

SkMatrix &	setSinCos (SkScalar sinValue, SkScalar cosValue, SkScalar px, SkScalar py)

SkMatrix &	setSinCos (SkScalar sinValue, SkScalar cosValue)

SkMatrix &	setRSXform (const SkRSXform &rsxForm)

SkMatrix &	setSkew (SkScalar kx, SkScalar ky, SkScalar px, SkScalar py)

SkMatrix &	setSkew (SkScalar kx, SkScalar ky)

SkMatrix &	setConcat (const SkMatrix &a, const SkMatrix &b)

SkMatrix &	preTranslate (SkScalar dx, SkScalar dy)

SkMatrix &	preScale (SkScalar sx, SkScalar sy, SkScalar px, SkScalar py)

SkMatrix &	preScale (SkScalar sx, SkScalar sy)

SkMatrix &	preRotate (SkScalar degrees, SkScalar px, SkScalar py)

SkMatrix &	preRotate (SkScalar degrees)

SkMatrix &	preSkew (SkScalar kx, SkScalar ky, SkScalar px, SkScalar py)

SkMatrix &	preSkew (SkScalar kx, SkScalar ky)

SkMatrix &	preConcat (const SkMatrix &other)

SkMatrix &	postTranslate (SkScalar dx, SkScalar dy)

SkMatrix &	postScale (SkScalar sx, SkScalar sy, SkScalar px, SkScalar py)

SkMatrix &	postScale (SkScalar sx, SkScalar sy)

SkMatrix &	postRotate (SkScalar degrees, SkScalar px, SkScalar py)

SkMatrix &	postRotate (SkScalar degrees)

SkMatrix &	postSkew (SkScalar kx, SkScalar ky, SkScalar px, SkScalar py)

SkMatrix &	postSkew (SkScalar kx, SkScalar ky)

SkMatrix &	postConcat (const SkMatrix &other)

bool	setRectToRect (const SkRect &src, const SkRect &dst, ScaleToFit stf)

bool	setPolyToPoly (const SkPoint src[], const SkPoint dst[], int count)

bool	invert (SkMatrix *inverse) const

bool	asAffine (SkScalar affine[6]) const

SkMatrix &	setAffine (const SkScalar affine[6])

void	normalizePerspective ()

void	mapPoints (SkPoint dst[], const SkPoint src[], int count) const

void	mapPoints (SkPoint pts[], int count) const

void	mapHomogeneousPoints (SkPoint3 dst[], const SkPoint3 src[], int count) const

void	mapHomogeneousPoints (SkPoint3 dst[], const SkPoint src[], int count) const

SkPoint	mapPoint (SkPoint pt) const

void	mapXY (SkScalar x, SkScalar y, SkPoint *result) const

SkPoint	mapXY (SkScalar x, SkScalar y) const

SkPoint	mapOrigin () const

void	mapVectors (SkVector dst[], const SkVector src[], int count) const

void	mapVectors (SkVector vecs[], int count) const

void	mapVector (SkScalar dx, SkScalar dy, SkVector *result) const

SkVector	mapVector (SkScalar dx, SkScalar dy) const

bool	mapRect (SkRect *dst, const SkRect &src, SkApplyPerspectiveClip pc=SkApplyPerspectiveClip::kYes) const

bool	mapRect (SkRect *rect, SkApplyPerspectiveClip pc=SkApplyPerspectiveClip::kYes) const

SkRect	mapRect (const SkRect &src, SkApplyPerspectiveClip pc=SkApplyPerspectiveClip::kYes) const

void	mapRectToQuad (SkPoint dst[4], const SkRect &rect) const

void	mapRectScaleTranslate (SkRect *dst, const SkRect &src) const

SkScalar	mapRadius (SkScalar radius) const

void	dump () const

SkScalar	getMinScale () const

SkScalar	getMaxScale () const

bool	getMinMaxScales (SkScalar scaleFactors[2]) const

bool	decomposeScale (SkSize scale, SkMatrix remaining=nullptr) const

void	dirtyMatrixTypeCache ()

void	setScaleTranslate (SkScalar sx, SkScalar sy, SkScalar tx, SkScalar ty)

bool	isFinite () const

Static Public Member Functions
static SkMatrix	Scale (SkScalar sx, SkScalar sy)

static SkMatrix	Translate (SkScalar dx, SkScalar dy)

static SkMatrix	Translate (SkVector t)

static SkMatrix	Translate (SkIVector t)

static SkMatrix	RotateDeg (SkScalar deg)

static SkMatrix	RotateDeg (SkScalar deg, SkPoint pt)

static SkMatrix	RotateRad (SkScalar rad)

static SkMatrix	Skew (SkScalar kx, SkScalar ky)

static SkMatrix	RectToRect (const SkRect &src, const SkRect &dst, ScaleToFit mode=kFill_ScaleToFit)

static SkMatrix	MakeAll (SkScalar scaleX, SkScalar skewX, SkScalar transX, SkScalar skewY, SkScalar scaleY, SkScalar transY, SkScalar pers0, SkScalar pers1, SkScalar pers2)

static SkMatrix	MakeRectToRect (const SkRect &src, const SkRect &dst, ScaleToFit stf)

static void	SetAffineIdentity (SkScalar affine[6])

static const SkMatrix &	I ()

static const SkMatrix &	InvalidMatrix ()

static SkMatrix	Concat (const SkMatrix &a, const SkMatrix &b)

Static Public Attributes
static constexpr int	kMScaleX = 0
	horizontal scale factor

static constexpr int	kMSkewX = 1
	horizontal skew factor

static constexpr int	kMTransX = 2
	horizontal translation

static constexpr int	kMSkewY = 3
	vertical skew factor

static constexpr int	kMScaleY = 4
	vertical scale factor

static constexpr int	kMTransY = 5
	vertical translation

static constexpr int	kMPersp0 = 6
	input x perspective factor

static constexpr int	kMPersp1 = 7
	input y perspective factor

static constexpr int	kMPersp2 = 8
	perspective bias

static constexpr int	kAScaleX = 0
	horizontal scale factor

static constexpr int	kASkewY = 1
	vertical skew factor

static constexpr int	kASkewX = 2
	horizontal skew factor

static constexpr int	kAScaleY = 3
	vertical scale factor

static constexpr int	kATransX = 4
	horizontal translation

static constexpr int	kATransY = 5
	vertical translation

Friends
class	SkPerspIter

class	SkMatrixPriv

class	SerializationTest

SK_API bool	operator== (const SkMatrix &a, const SkMatrix &b)

SK_API bool	operator!= (const SkMatrix &a, const SkMatrix &b)

SkMatrix	operator* (const SkMatrix &a, const SkMatrix &b)

Detailed Description

SkMatrix holds a 3x3 matrix for transforming coordinates. This allows mapping SkPoint and vectors with translation, scaling, skewing, rotation, and perspective.

SkMatrix elements are in row major order. SkMatrix constexpr default constructs to identity.

SkMatrix includes a hidden variable that classifies the type of matrix to improve performance. SkMatrix is not thread safe unless getType() is called first.

example: https://fiddle.skia.org/c/@Matrix_063

Definition at line 54 of file SkMatrix.h.

Member Enumeration Documentation

◆ ScaleToFit

enum SkMatrix::ScaleToFit

Enumerator
kFill_ScaleToFit	scales in x and y to fill destination SkRect
kStart_ScaleToFit	scales and aligns to left and top
kCenter_ScaleToFit	scales and aligns to center
kEnd_ScaleToFit	scales and aligns to right and bottom

Definition at line 136 of file SkMatrix.h.

                    {
        kFill_ScaleToFit,   //!< scales in x and y to fill destination SkRect
        kStart_ScaleToFit,  //!< scales and aligns to left and top
        kCenter_ScaleToFit, //!< scales and aligns to center
        kEnd_ScaleToFit,    //!< scales and aligns to right and bottom
    };

◆ TypeMask

enum SkMatrix::TypeMask

Enumerator
kIdentity_Mask	identity SkMatrix; all bits clear
kTranslate_Mask	translation SkMatrix
kScale_Mask	scale SkMatrix
kAffine_Mask	skew or rotate SkMatrix
kPerspective_Mask	perspective SkMatrix

Definition at line 191 of file SkMatrix.h.

                  {
        kIdentity_Mask    = 0,    //!< identity SkMatrix; all bits clear
        kTranslate_Mask   = 0x01, //!< translation SkMatrix
        kScale_Mask       = 0x02, //!< scale SkMatrix
        kAffine_Mask      = 0x04, //!< skew or rotate SkMatrix
        kPerspective_Mask = 0x08, //!< perspective SkMatrix
    };

Constructor & Destructor Documentation

◆ SkMatrix()

constexpr SkMatrix::SkMatrix ( )

inlineconstexpr

Creates an identity SkMatrix:

| 1 0 0 |
| 0 1 0 |
| 0 0 1 |

Definition at line 63 of file SkMatrix.h.

63: SkMatrix(1,0,0, 0,1,0, 0,0,1, kIdentity_Mask | kRectStaysRect_Mask) {}

SkMatrix::SkMatrix

constexpr SkMatrix()

Definition SkMatrix.h:63

Member Function Documentation

◆ asAffine()

bool SkMatrix::asAffine ( SkScalar affine[6] ) const

Fills affine in column major order. Sets affine to:

| scale-x  skew-x translate-x |
| skew-y  scale-y translate-y |

If SkMatrix contains perspective, returns false and leaves affine unchanged.

Parameters

affine storage for 3 by 2 affine matrix; may be nullptr

Returns: true if SkMatrix does not contain perspective

Definition at line 755 of file SkMatrix.cpp.

                                                {
    if (this->hasPerspective()) {
        return false;
    }
    if (affine) {
        affine[kAScaleX] = this->fMat[kMScaleX];
        affine[kASkewY] = this->fMat[kMSkewY];
        affine[kASkewX] = this->fMat[kMSkewX];
        affine[kAScaleY] = this->fMat[kMScaleY];
        affine[kATransX] = this->fMat[kMTransX];
        affine[kATransY] = this->fMat[kMTransY];
    }
    return true;
}

◆ Concat()

static SkMatrix SkMatrix::Concat	(	const SkMatrix &	a,
		const SkMatrix &	b
	)

inlinestatic

Returns SkMatrix a multiplied by SkMatrix b.

Given:

    | A B C |      | J K L |
a = | D E F |, b = | M N O |
    | G H I |      | P Q R |

sets SkMatrix to:

        | A B C |   | J K L |   | AJ+BM+CP AK+BN+CQ AL+BO+CR |
a * b = | D E F | * | M N O | = | DJ+EM+FP DK+EN+FQ DL+EO+FR |
        | G H I |   | P Q R |   | GJ+HM+IP GK+HN+IQ GL+HO+IR |

Parameters

a	SkMatrix on left side of multiply expression
b	SkMatrix on right side of multiply expression

Returns: SkMatrix computed from a times b

Definition at line 1775 of file SkMatrix.h.

                                                                 {
        SkMatrix result;
        result.setConcat(a, b);
        return result;
    }

◆ decomposeScale()

bool SkMatrix::decomposeScale	(	SkSize *	scale,
		SkMatrix *	remaining = `nullptr`
	)		const

Decomposes SkMatrix into scale components and whatever remains. Returns false if SkMatrix could not be decomposed.

Sets scale to portion of SkMatrix that scale axes. Sets remaining to SkMatrix with scaling factored out. remaining may be passed as nullptr to determine if SkMatrix can be decomposed without computing remainder.

Returns true if scale components are found. scale and remaining are unchanged if SkMatrix contains perspective; scale factors are not finite, or are nearly zero.

On success: Matrix = Remaining * scale.

Parameters

scale	axes scaling factors; may be nullptr
remaining	SkMatrix without scaling; may be nullptr

Returns: true if scale can be computed

example: https://fiddle.skia.org/c/@Matrix_decomposeScale

Definition at line 1559 of file SkMatrix.cpp.

                                                                      {
    if (this->hasPerspective()) {
        return false;
    }
 
    const SkScalar sx = SkVector::Length(this->getScaleX(), this->getSkewY());
    const SkScalar sy = SkVector::Length(this->getSkewX(), this->getScaleY());
    if (!SkIsFinite(sx, sy) ||
        SkScalarNearlyZero(sx) || SkScalarNearlyZero(sy)) {
        return false;
    }
 
    if (scale) {
        scale->set(sx, sy);
    }
    if (remaining) {
        *remaining = *this;
        remaining->preScale(SkScalarInvert(sx), SkScalarInvert(sy));
    }
    return true;
}

◆ dirtyMatrixTypeCache()

void SkMatrix::dirtyMatrixTypeCache ( )

inline

Sets internal cache to unknown state. Use to force update after repeated modifications to SkMatrix element reference returned by operator[](int index).

Definition at line 1788 of file SkMatrix.h.

                                {
        this->setTypeMask(kUnknown_Mask);
    }

◆ dump()

void SkMatrix::dump ( ) const

Writes text representation of SkMatrix to standard output. Floating point values are written with limited precision; it may not be possible to reconstruct original SkMatrix from output.

example: https://fiddle.skia.org/c/@Matrix_dump

Definition at line 1604 of file SkMatrix.cpp.

                          {
    SkString str;
    str.appendf("[%8.4f %8.4f %8.4f][%8.4f %8.4f %8.4f][%8.4f %8.4f %8.4f]",
             fMat[0], fMat[1], fMat[2], fMat[3], fMat[4], fMat[5],
             fMat[6], fMat[7], fMat[8]);
    SkDebugf("%s\n", str.c_str());
}

◆ get()

SkScalar SkMatrix::get ( int index ) const

inline

Returns one matrix value. Asserts if index is out of range and SK_DEBUG is defined.

Parameters

index one of: kMScaleX, kMSkewX, kMTransX, kMSkewY, kMScaleY, kMTransY, kMPersp0, kMPersp1, kMPersp2

Returns: value corresponding to index

Definition at line 392 of file SkMatrix.h.

                                  {
        SkASSERT((unsigned)index < 9);
        return fMat[index];
    }

◆ get9()

void SkMatrix::get9 ( SkScalar buffer[9] ) const

inline

Copies nine scalar values contained by SkMatrix into buffer, in member value ascending order: kMScaleX, kMSkewX, kMTransX, kMSkewY, kMScaleY, kMTransY, kMPersp0, kMPersp1, kMPersp2.

Parameters

buffer storage for nine scalar values

Definition at line 584 of file SkMatrix.h.

                                        {
        memcpy(buffer, fMat, 9 * sizeof(SkScalar));
    }

◆ getMaxScale()

SkScalar SkMatrix::getMaxScale ( ) const

Returns the maximum scaling factor of SkMatrix by decomposing the scaling and skewing elements. Returns -1 if scale factor overflows or SkMatrix contains perspective.

Returns: maximum scale factor

example: https://fiddle.skia.org/c/@Matrix_getMaxScale

Definition at line 1531 of file SkMatrix.cpp.

                                     {
    SkScalar factor;
    if (get_scale_factor<kMax_MinMaxOrBoth>(this->getType(), fMat, &factor)) {
        return factor;
    } else {
        return -1;
    }
}

◆ getMinMaxScales()

bool SkMatrix::getMinMaxScales ( SkScalar scaleFactors[2] ) const

Sets scaleFactors[0] to the minimum scaling factor, and scaleFactors[1] to the maximum scaling factor. Scaling factors are computed by decomposing the SkMatrix scaling and skewing elements.

Returns true if scaleFactors are found; otherwise, returns false and sets scaleFactors to undefined values.

Parameters

scaleFactors storage for minimum and maximum scale factors

Returns: true if scale factors were computed correctly

Definition at line 1540 of file SkMatrix.cpp.

                                                             {
    return get_scale_factor<kBoth_MinMaxOrBoth>(this->getType(), fMat, scaleFactors);
}

◆ getMinScale()

SkScalar SkMatrix::getMinScale ( ) const

Returns the minimum scaling factor of SkMatrix by decomposing the scaling and skewing elements. Returns -1 if scale factor overflows or SkMatrix contains perspective.

Returns: minimum scale factor

example: https://fiddle.skia.org/c/@Matrix_getMinScale

Definition at line 1522 of file SkMatrix.cpp.

                                     {
    SkScalar factor;
    if (get_scale_factor<kMin_MinMaxOrBoth>(this->getType(), fMat, &factor)) {
        return factor;
    } else {
        return -1;
    }
}

◆ getPerspX()

SkScalar SkMatrix::getPerspX ( ) const

inline

Returns factor scaling input x-axis relative to input y-axis.

Returns: input x-axis perspective factor

Definition at line 458 of file SkMatrix.h.

458{ return fMat[kMPersp0]; }

SkMatrix::kMPersp0

static constexpr int kMPersp0

input x perspective factor

Definition SkMatrix.h:359

◆ getPerspY()

SkScalar SkMatrix::getPerspY ( ) const

inline

Returns factor scaling input y-axis relative to input x-axis.

Returns: input y-axis perspective factor

Definition at line 464 of file SkMatrix.h.

464{ return fMat[kMPersp1]; }

SkMatrix::kMPersp1

static constexpr int kMPersp1

input y perspective factor

Definition SkMatrix.h:360

◆ getScaleX()

SkScalar SkMatrix::getScaleX ( ) const

inline

Returns scale factor multiplied by x-axis input, contributing to x-axis output. With mapPoints(), scales SkPoint along the x-axis.

Returns: horizontal scale factor

Definition at line 415 of file SkMatrix.h.

415{ return fMat[kMScaleX]; }

◆ getScaleY()

SkScalar SkMatrix::getScaleY ( ) const

inline

Returns scale factor multiplied by y-axis input, contributing to y-axis output. With mapPoints(), scales SkPoint along the y-axis.

Returns: vertical scale factor

Definition at line 422 of file SkMatrix.h.

422{ return fMat[kMScaleY]; }

◆ getSkewX()

SkScalar SkMatrix::getSkewX ( ) const

inline

Returns scale factor multiplied by y-axis input, contributing to x-axis output. With mapPoints(), skews SkPoint along the x-axis. Skewing both axes can rotate SkPoint.

Returns: horizontal scale factor

Definition at line 438 of file SkMatrix.h.

438{ return fMat[kMSkewX]; }

◆ getSkewY()

SkScalar SkMatrix::getSkewY ( ) const

inline

Returns scale factor multiplied by x-axis input, contributing to y-axis output. With mapPoints(), skews SkPoint along the y-axis. Skewing both axes can rotate SkPoint.

Returns: vertical skew factor

Definition at line 430 of file SkMatrix.h.

430{ return fMat[kMSkewY]; }

◆ getTranslateX()

SkScalar SkMatrix::getTranslateX ( ) const

inline

Returns translation contributing to x-axis output. With mapPoints(), moves SkPoint along the x-axis.

Returns: horizontal translation factor

Definition at line 445 of file SkMatrix.h.

445{ return fMat[kMTransX]; }

◆ getTranslateY()

SkScalar SkMatrix::getTranslateY ( ) const

inline

Returns translation contributing to y-axis output. With mapPoints(), moves SkPoint along the y-axis.

Returns: vertical translation factor

Definition at line 452 of file SkMatrix.h.

452{ return fMat[kMTransY]; }

◆ getType()

TypeMask SkMatrix::getType ( ) const

inline

Returns a bit field describing the transformations the matrix may perform. The bit field is computed conservatively, so it may include false positives. For example, when kPerspective_Mask is set, all other bits are set.

Returns: kIdentity_Mask, or combinations of: kTranslate_Mask, kScale_Mask, kAffine_Mask, kPerspective_Mask

Definition at line 207 of file SkMatrix.h.

                             {
        if (fTypeMask & kUnknown_Mask) {
            fTypeMask = this->computeTypeMask();
        }
        // only return the public masks
        return (TypeMask)(fTypeMask & 0xF);
    }

◆ hasPerspective()

bool SkMatrix::hasPerspective ( ) const

inline

Returns true if the matrix contains perspective elements. SkMatrix form is:

|       --            --              --          |
|       --            --              --          |
| perspective-x  perspective-y  perspective-scale |

where perspective-x or perspective-y is non-zero, or perspective-scale is not one. All other elements may have any value.

Returns: true if SkMatrix is in most general form

Definition at line 312 of file SkMatrix.h.

                                {
        return SkToBool(this->getPerspectiveTypeMaskOnly() &
                        kPerspective_Mask);
    }

◆ I()

const SkMatrix & SkMatrix::I ( )

static

Returns reference to const identity SkMatrix. Returned SkMatrix is set to:

| 1 0 0 |
| 0 1 0 |
| 0 0 1 |

Returns: const identity SkMatrix

example: https://fiddle.skia.org/c/@Matrix_I

Definition at line 1544 of file SkMatrix.cpp.

                            {
    static constexpr SkMatrix identity;
    SkASSERT(identity.isIdentity());
    return identity;
}

◆ InvalidMatrix()

const SkMatrix & SkMatrix::InvalidMatrix ( )

static

Returns reference to a const SkMatrix with invalid values. Returned SkMatrix is set to:

| SK_ScalarMax SK_ScalarMax SK_ScalarMax |
| SK_ScalarMax SK_ScalarMax SK_ScalarMax |
| SK_ScalarMax SK_ScalarMax SK_ScalarMax |

Returns: const invalid SkMatrix

example: https://fiddle.skia.org/c/@Matrix_InvalidMatrix

Definition at line 1550 of file SkMatrix.cpp.

                                        {
    static constexpr SkMatrix invalid(SK_ScalarMax, SK_ScalarMax, SK_ScalarMax,
                                      SK_ScalarMax, SK_ScalarMax, SK_ScalarMax,
                                      SK_ScalarMax, SK_ScalarMax, SK_ScalarMax,
                                      kTranslate_Mask | kScale_Mask |
                                      kAffine_Mask | kPerspective_Mask);
    return invalid;
}

◆ invert()

bool SkMatrix::invert ( SkMatrix * inverse ) const

inline

Sets inverse to reciprocal matrix, returning true if SkMatrix can be inverted. Geometrically, if SkMatrix maps from source to destination, inverse SkMatrix maps from destination to source. If SkMatrix can not be inverted, inverse is unchanged.

Parameters

inverse storage for inverted SkMatrix; may be nullptr

Returns: true if SkMatrix can be inverted

Definition at line 1206 of file SkMatrix.h.

                                                       {
        // Allow the trivial case to be inlined.
        if (this->isIdentity()) {
            if (inverse) {
                inverse->reset();
            }
            return true;
        }
        return this->invertNonIdentity(inverse);
    }

◆ isFinite()

bool SkMatrix::isFinite ( ) const

inline

Returns true if all elements of the matrix are finite. Returns false if any element is infinity, or NaN.

Returns: true if matrix has only finite elements

Definition at line 1834 of file SkMatrix.h.

1834{ return SkIsFinite(fMat, 9); }

◆ isIdentity()

bool SkMatrix::isIdentity ( ) const

inline

Returns true if SkMatrix is identity. Identity matrix is:

| 1 0 0 |
| 0 1 0 |
| 0 0 1 |

Returns: true if SkMatrix has no effect

Definition at line 223 of file SkMatrix.h.

                            {
        return this->getType() == 0;
    }

◆ isScaleTranslate()

bool SkMatrix::isScaleTranslate ( ) const

inline

Returns true if SkMatrix at most scales and translates. SkMatrix may be identity, contain only scale elements, only translate elements, or both. SkMatrix form is:

| scale-x    0    translate-x |
|    0    scale-y translate-y |
|    0       0         1      |

Returns: true if SkMatrix is identity; or scales, translates, or both

Definition at line 236 of file SkMatrix.h.

                                  {
        return !(this->getType() & ~(kScale_Mask | kTranslate_Mask));
    }

◆ isSimilarity()

bool SkMatrix::isSimilarity ( SkScalar tol = SK_ScalarNearlyZero ) const

Returns true if SkMatrix contains only translation, rotation, reflection, and uniform scale. Returns false if SkMatrix contains different scales, skewing, perspective, or degenerate forms that collapse to a line or point.

Describes that the SkMatrix makes rendering with and without the matrix are visually alike; a transformed circle remains a circle. Mathematically, this is referred to as similarity of a Euclidean space, or a similarity transformation.

Preserves right angles, keeping the arms of the angle equal lengths.

Parameters

tol	to be deprecated

Returns: true if SkMatrix only rotates, uniformly scales, translates

example: https://fiddle.skia.org/c/@Matrix_isSimilarity

Definition at line 180 of file SkMatrix.cpp.

                                              {
    // if identity or translate matrix
    TypeMask mask = this->getType();
    if (mask <= kTranslate_Mask) {
        return true;
    }
    if (mask & kPerspective_Mask) {
        return false;
    }
 
    SkScalar mx = fMat[kMScaleX];
    SkScalar my = fMat[kMScaleY];
    // if no skew, can just compare scale factors
    if (!(mask & kAffine_Mask)) {
        return !SkScalarNearlyZero(mx) && SkScalarNearlyEqual(SkScalarAbs(mx), SkScalarAbs(my));
    }
    SkScalar sx = fMat[kMSkewX];
    SkScalar sy = fMat[kMSkewY];
 
    if (is_degenerate_2x2(mx, sx, sy, my)) {
        return false;
    }
 
    // upper 2x2 is rotation/reflection + uniform scale if basis vectors
    // are 90 degree rotations of each other
    return (SkScalarNearlyEqual(mx, my, tol) && SkScalarNearlyEqual(sx, -sy, tol))
        || (SkScalarNearlyEqual(mx, -my, tol) && SkScalarNearlyEqual(sx, sy, tol));
}

◆ isTranslate()

bool SkMatrix::isTranslate ( ) const

inline

Returns true if SkMatrix is identity, or translates. SkMatrix form is:

| 1 0 translate-x |
| 0 1 translate-y |
| 0 0      1      |

Returns: true if SkMatrix is identity, or translates

Definition at line 248 of file SkMatrix.h.

248{ return !(this->getType() & ~(kTranslate_Mask)); }

◆ MakeAll()

static SkMatrix SkMatrix::MakeAll	(	SkScalar	scaleX,
		SkScalar	skewX,
		SkScalar	transX,
		SkScalar	skewY,
		SkScalar	scaleY,
		SkScalar	transY,
		SkScalar	pers0,
		SkScalar	pers1,
		SkScalar	pers2
	)

inlinestatic

Sets SkMatrix to:

| scaleX  skewX transX |
|  skewY scaleY transY |
|  pers0  pers1  pers2 |

Parameters

scaleX	horizontal scale factor
skewX	horizontal skew factor
transX	horizontal translation
skewY	vertical skew factor
scaleY	vertical scale factor
transY	vertical translation
pers0	input x-axis perspective factor
pers1	input y-axis perspective factor
pers2	perspective scale factor

Returns: SkMatrix constructed from parameters

Definition at line 179 of file SkMatrix.h.

                                                                                          {
        SkMatrix m;
        m.setAll(scaleX, skewX, transX, skewY, scaleY, transY, pers0, pers1, pers2);
        return m;
    }

◆ MakeRectToRect()

static SkMatrix SkMatrix::MakeRectToRect	(	const SkRect &	src,
		const SkRect &	dst,
		ScaleToFit	stf
	)

inlinestatic

Returns SkMatrix set to scale and translate src SkRect to dst SkRect. stf selects whether mapping completely fills dst or preserves the aspect ratio, and how to align src within dst. Returns the identity SkMatrix if src is empty. If dst is empty, returns SkMatrix set to:

| 0 0 0 |
| 0 0 0 |
| 0 0 1 |

Parameters

src	SkRect to map from
dst	SkRect to map to

Returns: SkMatrix mapping src to dst

Definition at line 1172 of file SkMatrix.h.

                                                                                         {
        SkMatrix m;
        m.setRectToRect(src, dst, stf);
        return m;
    }

◆ mapHomogeneousPoints() [1/2]

void SkMatrix::mapHomogeneousPoints	(	SkPoint3	dst[],
		const SkPoint	src[],
		int	count
	)		const

Returns homogeneous points, starting with 2D src points (with implied w = 1).

Definition at line 1071 of file SkMatrix.cpp.

                                                                                        {
    if (this->isIdentity()) {
        for (int i = 0; i < count; ++i) {
            dst[i] = { src[i].fX, src[i].fY, 1 };
        }
    } else if (this->hasPerspective()) {
        for (int i = 0; i < count; ++i) {
            dst[i] = {
                fMat[0] * src[i].fX + fMat[1] * src[i].fY + fMat[2],
                fMat[3] * src[i].fX + fMat[4] * src[i].fY + fMat[5],
                fMat[6] * src[i].fX + fMat[7] * src[i].fY + fMat[8],
            };
        }
    } else {    // affine
        for (int i = 0; i < count; ++i) {
            dst[i] = {
                fMat[0] * src[i].fX + fMat[1] * src[i].fY + fMat[2],
                fMat[3] * src[i].fX + fMat[4] * src[i].fY + fMat[5],
                1,
            };
        }
    }
}

◆ mapHomogeneousPoints() [2/2]

void SkMatrix::mapHomogeneousPoints	(	SkPoint3	dst[],
		const SkPoint3	src[],
		int	count
	)		const

Maps src SkPoint3 array of length count to dst SkPoint3 array, which must of length count or greater. SkPoint3 array is mapped by multiplying each SkPoint3 by SkMatrix. Given:

         | A B C |         | x |
Matrix = | D E F |,  src = | y |
         | G H I |         | z |

each resulting dst SkPoint is computed as:

               |A B C| |x|
Matrix * src = |D E F| |y| = |Ax+By+Cz Dx+Ey+Fz Gx+Hy+Iz|
               |G H I| |z|

Parameters

dst	storage for mapped SkPoint3 array
src	SkPoint3 array to transform
count	items in SkPoint3 array to transform

example: https://fiddle.skia.org/c/@Matrix_mapHomogeneousPoints

Definition at line 1066 of file SkMatrix.cpp.

                                                                                         {
    SkMatrixPriv::MapHomogeneousPointsWithStride(*this, dst, sizeof(SkPoint3), src,
                                                 sizeof(SkPoint3), count);
}

◆ mapOrigin()

SkPoint SkMatrix::mapOrigin ( ) const

inline

Returns (0, 0) multiplied by SkMatrix. Given:

         | A B C |        | 0 |
Matrix = | D E F |,  pt = | 0 |
         | G H I |        | 1 |

result is computed as:

              |A B C| |0|             C    F
Matrix * pt = |D E F| |0| = |C F I| = -  , -
              |G H I| |1|             I    I

Returns: mapped (0, 0)

Definition at line 1437 of file SkMatrix.h.

                              {
        SkScalar x = this->getTranslateX(),
                 y = this->getTranslateY();
        if (this->hasPerspective()) {
            SkScalar w = fMat[kMPersp2];
            if (w) { w = 1 / w; }
            x *= w;
            y *= w;
        }
        return {x, y};
    }

◆ mapPoint()

SkPoint SkMatrix::mapPoint ( SkPoint pt ) const

inline

Returns SkPoint pt multiplied by SkMatrix. Given:

         | A B C |        | x |
Matrix = | D E F |,  pt = | y |
         | G H I |        | 1 |

result is computed as:

              |A B C| |x|                               Ax+By+C   Dx+Ey+F
Matrix * pt = |D E F| |y| = |Ax+By+C Dx+Ey+F Gx+Hy+I| = ------- , -------
              |G H I| |1|                               Gx+Hy+I   Gx+Hy+I

Parameters

p	SkPoint to map

Returns: mapped SkPoint

Definition at line 1374 of file SkMatrix.h.

                                       {
        SkPoint result;
        this->mapXY(pt.x(), pt.y(), &result);
        return result;
    }

◆ mapPoints() [1/2]

void SkMatrix::mapPoints	(	SkPoint	dst[],
		const SkPoint	src[],
		int	count
	)		const

Maps src SkPoint array of length count to dst SkPoint array of equal or greater length. SkPoint are mapped by multiplying each SkPoint by SkMatrix. Given:

         | A B C |        | x |
Matrix = | D E F |,  pt = | y |
         | G H I |        | 1 |

where

for (i = 0; i < count; ++i) {
    x = src[i].fX
    y = src[i].fY
}

each dst SkPoint is computed as:

              |A B C| |x|                               Ax+By+C   Dx+Ey+F
Matrix * pt = |D E F| |y| = |Ax+By+C Dx+Ey+F Gx+Hy+I| = ------- , -------
              |G H I| |1|                               Gx+Hy+I   Gx+Hy+I

src and dst may point to the same storage.

Parameters

dst	storage for mapped SkPoint
src	SkPoint to transform
count	number of SkPoint to transform

example: https://fiddle.skia.org/c/@Matrix_mapPoints

Definition at line 770 of file SkMatrix.cpp.

                                                                            {
    SkASSERT((dst && src && count > 0) || 0 == count);
    // no partial overlap
    SkASSERT(src == dst || &dst[count] <= &src[0] || &src[count] <= &dst[0]);
    this->getMapPtsProc()(*this, dst, src, count);
}

◆ mapPoints() [2/2]

void SkMatrix::mapPoints	(	SkPoint	pts[],
		int	count
	)		const

inline

Maps pts SkPoint array of length count in place. SkPoint are mapped by multiplying each SkPoint by SkMatrix. Given:

         | A B C |        | x |
Matrix = | D E F |,  pt = | y |
         | G H I |        | 1 |

where

for (i = 0; i < count; ++i) {
    x = pts[i].fX
    y = pts[i].fY
}

each resulting pts SkPoint is computed as:

              |A B C| |x|                               Ax+By+C   Dx+Ey+F
Matrix * pt = |D E F| |y| = |Ax+By+C Dx+Ey+F Gx+Hy+I| = ------- , -------
              |G H I| |1|                               Gx+Hy+I   Gx+Hy+I

Parameters

pts	storage for mapped SkPoint
count	number of SkPoint to transform

Definition at line 1329 of file SkMatrix.h.

                                                   {
        this->mapPoints(pts, pts, count);
    }

◆ mapRadius()

SkScalar SkMatrix::mapRadius ( SkScalar radius ) const

Returns geometric mean radius of ellipse formed by constructing circle of size radius, and mapping constructed circle with SkMatrix. The result squared is equal to the major axis length times the minor axis length. Result is not meaningful if SkMatrix contains perspective elements.

Parameters

radius circle size to map

Returns: average mapped radius

example: https://fiddle.skia.org/c/@Matrix_mapRadius

Definition at line 1170 of file SkMatrix.cpp.

                                                  {
    SkVector    vec[2];
 
    vec[0].set(radius, 0);
    vec[1].set(0, radius);
    this->mapVectors(vec, 2);
 
    SkScalar d0 = vec[0].length();
    SkScalar d1 = vec[1].length();
 
    // return geometric mean
    return SkScalarSqrt(d0 * d1);
}

◆ mapRect() [1/3]

SkRect SkMatrix::mapRect	(	const SkRect &	src,
		SkApplyPerspectiveClip	pc = `SkApplyPerspectiveClip::kYes`
	)		const

inline

Returns bounds of src corners mapped by SkMatrix.

Parameters

src	rectangle to map

Returns: mapped bounds

Definition at line 1585 of file SkMatrix.h.

                                                                                 {
        SkRect dst;
        (void)this->mapRect(&dst, src, pc);
        return dst;
    }

◆ mapRect() [2/3]

bool SkMatrix::mapRect	(	SkRect *	dst,
		const SkRect &	src,
		SkApplyPerspectiveClip	pc = `SkApplyPerspectiveClip::kYes`
	)		const

Sets dst to bounds of src corners mapped by SkMatrix. Returns true if mapped corners are dst corners.

Returned value is the same as calling rectStaysRect().

Parameters

dst	storage for bounds of mapped SkPoint
src	SkRect to map
pc	whether to apply perspective clipping

Returns: true if dst is equivalent to mapped src

example: https://fiddle.skia.org/c/@Matrix_mapRect

Definition at line 1141 of file SkMatrix.cpp.

                                                                                      {
    SkASSERT(dst);
 
    if (this->getType() <= kTranslate_Mask) {
        SkScalar tx = fMat[kMTransX];
        SkScalar ty = fMat[kMTransY];
        skvx::float4 trans(tx, ty, tx, ty);
        sort_as_rect(skvx::float4::Load(&src.fLeft) + trans).store(&dst->fLeft);
        return true;
    }
    if (this->isScaleTranslate()) {
        this->mapRectScaleTranslate(dst, src);
        return true;
    } else if (pc == SkApplyPerspectiveClip::kYes && this->hasPerspective()) {
        SkPath path;
        path.addRect(src);
        path.transform(*this);
        *dst = path.getBounds();
        return false;
    } else {
        SkPoint quad[4];
 
        src.toQuad(quad);
        this->mapPoints(quad, quad, 4);
        dst->setBoundsNoCheck(quad, 4);
        return this->rectStaysRect();   // might still return true if rotated by 90, etc.
    }
}

◆ mapRect() [3/3]

bool SkMatrix::mapRect	(	SkRect *	rect,
		SkApplyPerspectiveClip	pc = `SkApplyPerspectiveClip::kYes`
	)		const

inline

Sets rect to bounds of rect corners mapped by SkMatrix. Returns true if mapped corners are computed rect corners.

Returned value is the same as calling rectStaysRect().

Parameters

rect	rectangle to map, and storage for bounds of mapped corners
pc	whether to apply perspective clipping

Returns: true if result is equivalent to mapped rect

Definition at line 1576 of file SkMatrix.h.

                                                                                             {
        return this->mapRect(rect, *rect, pc);
    }

◆ mapRectScaleTranslate()

void SkMatrix::mapRectScaleTranslate	(	SkRect *	dst,
		const SkRect &	src
	)		const

Sets dst to bounds of src corners mapped by SkMatrix. If matrix contains elements other than scale or translate: asserts if SK_DEBUG is defined; otherwise, results are undefined.

Parameters

dst	storage for bounds of mapped SkPoint
src	SkRect to map

example: https://fiddle.skia.org/c/@Matrix_mapRectScaleTranslate

Definition at line 1128 of file SkMatrix.cpp.

                                                                         {
    SkASSERT(dst);
    SkASSERT(this->isScaleTranslate());
 
    SkScalar sx = fMat[kMScaleX];
    SkScalar sy = fMat[kMScaleY];
    SkScalar tx = fMat[kMTransX];
    SkScalar ty = fMat[kMTransY];
    skvx::float4 scale(sx, sy, sx, sy);
    skvx::float4 trans(tx, ty, tx, ty);
    sort_as_rect(skvx::float4::Load(&src.fLeft) * scale + trans).store(&dst->fLeft);
}

◆ mapRectToQuad()

void SkMatrix::mapRectToQuad	(	SkPoint	dst[4],
		const SkRect &	rect
	)		const

inline

Maps four corners of rect to dst. SkPoint are mapped by multiplying each rect corner by SkMatrix. rect corner is processed in this order: (rect.fLeft, rect.fTop), (rect.fRight, rect.fTop), (rect.fRight, rect.fBottom), (rect.fLeft, rect.fBottom).

rect may be empty: rect.fLeft may be greater than or equal to rect.fRight; rect.fTop may be greater than or equal to rect.fBottom.

Given:

         | A B C |        | x |
Matrix = | D E F |,  pt = | y |
         | G H I |        | 1 |

where pt is initialized from each of (rect.fLeft, rect.fTop), (rect.fRight, rect.fTop), (rect.fRight, rect.fBottom), (rect.fLeft, rect.fBottom), each dst SkPoint is computed as:

              |A B C| |x|                               Ax+By+C   Dx+Ey+F
Matrix * pt = |D E F| |y| = |Ax+By+C Dx+Ey+F Gx+Hy+I| = ------- , -------
              |G H I| |1|                               Gx+Hy+I   Gx+Hy+I

Parameters

dst	storage for mapped corner SkPoint
rect	SkRect to map

Note: this does not perform perspective clipping (as that might result in more than 4 points, so results are suspect if the matrix contains perspective.

Definition at line 1620 of file SkMatrix.h.

                                                                 {
        // This could potentially be faster if we only transformed each x and y of the rect once.
        rect.toQuad(dst);
        this->mapPoints(dst, 4);
    }

◆ mapVector() [1/2]

SkVector SkMatrix::mapVector	(	SkScalar	dx,
		SkScalar	dy
	)		const

inline

Returns vector (dx, dy) multiplied by SkMatrix, treating SkMatrix translation as zero. Given:

         | A B 0 |         | dx |
Matrix = | D E 0 |,  vec = | dy |
         | G H I |         |  1 |

each result vector is computed as:

           |A B 0| |dx|                                        A*dx+B*dy     D*dx+E*dy

Matrix * vec = |D E 0| |dy| = |A*dx+B*dy D*dx+E*dy G*dx+H*dy+I| = --------— , --------— |G H I| | 1| G*dx+H*dy+I G*dx+*dHy+I

Parameters

dx	x-axis value of vector to map
dy	y-axis value of vector to map

Returns: mapped vector

Definition at line 1546 of file SkMatrix.h.

                                                       {
        SkVector vec = { dx, dy };
        this->mapVectors(&vec, &vec, 1);
        return vec;
    }

◆ mapVector() [2/2]

void SkMatrix::mapVector	(	SkScalar	dx,
		SkScalar	dy,
		SkVector *	result
	)		const

inline

Maps vector (dx, dy) to result. Vector is mapped by multiplying by SkMatrix, treating SkMatrix translation as zero. Given:

         | A B 0 |         | dx |
Matrix = | D E 0 |,  vec = | dy |
         | G H I |         |  1 |

each result vector is computed as:

           |A B 0| |dx|                                        A*dx+B*dy     D*dx+E*dy

Matrix * vec = |D E 0| |dy| = |A*dx+B*dy D*dx+E*dy G*dx+H*dy+I| = --------— , --------— |G H I| | 1| G*dx+H*dy+I G*dx+*dHy+I

Parameters

dx	x-axis value of vector to map
dy	y-axis value of vector to map
result	storage for mapped vector

Definition at line 1524 of file SkMatrix.h.

                                                                     {
        SkVector vec = { dx, dy };
        this->mapVectors(result, &vec, 1);
    }

◆ mapVectors() [1/2]

void SkMatrix::mapVectors	(	SkVector	dst[],
		const SkVector	src[],
		int	count
	)		const

Maps src vector array of length count to vector SkPoint array of equal or greater length. Vectors are mapped by multiplying each vector by SkMatrix, treating SkMatrix translation as zero. Given:

         | A B 0 |         | x |
Matrix = | D E 0 |,  src = | y |
         | G H I |         | 1 |

where

for (i = 0; i < count; ++i) {
    x = src[i].fX
    y = src[i].fY
}

each dst vector is computed as:

               |A B 0| |x|                            Ax+By     Dx+Ey
Matrix * src = |D E 0| |y| = |Ax+By Dx+Ey Gx+Hy+I| = ------- , -------
               |G H I| |1|                           Gx+Hy+I   Gx+Hy+I

src and dst may point to the same storage.

Parameters

dst	storage for mapped vectors
src	vectors to transform
count	number of vectors to transform

example: https://fiddle.skia.org/c/@Matrix_mapVectors

Definition at line 1097 of file SkMatrix.cpp.

                                                                             {
    if (this->hasPerspective()) {
        SkPoint origin;
 
        MapXYProc proc = this->getMapXYProc();
        proc(*this, 0, 0, &origin);
 
        for (int i = count - 1; i >= 0; --i) {
            SkPoint tmp;
 
            proc(*this, src[i].fX, src[i].fY, &tmp);
            dst[i].set(tmp.fX - origin.fX, tmp.fY - origin.fY);
        }
    } else {
        SkMatrix tmp = *this;
 
        tmp.fMat[kMTransX] = tmp.fMat[kMTransY] = 0;
        tmp.clearTypeMask(kTranslate_Mask);
        tmp.mapPoints(dst, src, count);
    }
}

◆ mapVectors() [2/2]

void SkMatrix::mapVectors	(	SkVector	vecs[],
		int	count
	)		const

inline

Maps vecs vector array of length count in place, multiplying each vector by SkMatrix, treating SkMatrix translation as zero. Given:

         | A B 0 |         | x |
Matrix = | D E 0 |,  vec = | y |
         | G H I |         | 1 |

where

for (i = 0; i < count; ++i) {
    x = vecs[i].fX
    y = vecs[i].fY
}

each result vector is computed as:

               |A B 0| |x|                            Ax+By     Dx+Ey
Matrix * vec = |D E 0| |y| = |Ax+By Dx+Ey Gx+Hy+I| = ------- , -------
               |G H I| |1|                           Gx+Hy+I   Gx+Hy+I

Parameters

vecs	vectors to transform, and storage for mapped vectors
count	number of vectors to transform

Definition at line 1503 of file SkMatrix.h.

                                                      {
        this->mapVectors(vecs, vecs, count);
    }

◆ mapXY() [1/2]

SkPoint SkMatrix::mapXY	(	SkScalar	x,
		SkScalar	y
	)		const

inline

Returns SkPoint (x, y) multiplied by SkMatrix. Given:

         | A B C |        | x |
Matrix = | D E F |,  pt = | y |
         | G H I |        | 1 |

result is computed as:

              |A B C| |x|                               Ax+By+C   Dx+Ey+F
Matrix * pt = |D E F| |y| = |Ax+By+C Dx+Ey+F Gx+Hy+I| = ------- , -------
              |G H I| |1|                               Gx+Hy+I   Gx+Hy+I

Parameters

x	x-axis value of SkPoint to map
y	y-axis value of SkPoint to map

Returns: mapped SkPoint

Definition at line 1416 of file SkMatrix.h.

                                                {
        SkPoint result;
        this->mapXY(x,y, &result);
        return result;
    }

◆ mapXY() [2/2]

void SkMatrix::mapXY	(	SkScalar	x,
		SkScalar	y,
		SkPoint *	result
	)		const

Maps SkPoint (x, y) to result. SkPoint is mapped by multiplying by SkMatrix. Given:

         | A B C |        | x |
Matrix = | D E F |,  pt = | y |
         | G H I |        | 1 |

result is computed as:

              |A B C| |x|                               Ax+By+C   Dx+Ey+F
Matrix * pt = |D E F| |y| = |Ax+By+C Dx+Ey+F Gx+Hy+I| = ------- , -------
              |G H I| |1|                               Gx+Hy+I   Gx+Hy+I

Parameters

x	x-axis value of SkPoint to map
y	y-axis value of SkPoint to map
result	storage for mapped SkPoint

example: https://fiddle.skia.org/c/@Matrix_mapXY

Definition at line 777 of file SkMatrix.cpp.

                                                                  {
    SkASSERT(result);
    this->getMapXYProc()(*this, x, y, result);
}

◆ normalizePerspective()

void SkMatrix::normalizePerspective ( )

inline

A matrix is categorized as 'perspective' if the bottom row is not [0, 0, 1]. However, for most uses (e.g. mapPoints) a bottom row of [0, 0, X] behaves like a non-perspective matrix, though it will be categorized as perspective. Calling normalizePerspective() will change the matrix such that, if its bottom row was [0, 0, X], it will be changed to [0, 0, 1] by scaling the rest of the matrix by 1/X.

| A B C | | A/X B/X C/X | | D E F | -> | D/X E/X F/X | for X != 0 | 0 0 X | | 0 0 1 |

Definition at line 1270 of file SkMatrix.h.

                                {
        if (fMat[8] != 1) {
            this->doNormalizePerspective();
        }
    }

◆ operator[]() [1/2]

SkScalar & SkMatrix::operator[] ( int index )

inline

Returns writable SkMatrix value. Asserts if index is out of range and SK_DEBUG is defined. Clears internal cache anticipating that caller will change SkMatrix value.

Next call to read SkMatrix state may recompute cache; subsequent writes to SkMatrix value must be followed by dirtyMatrixTypeCache().

Parameters

index one of: kMScaleX, kMSkewX, kMTransX, kMSkewY, kMScaleY, kMTransY, kMPersp0, kMPersp1, kMPersp2

Returns: writable value corresponding to index

Definition at line 476 of file SkMatrix.h.

                                    {
        SkASSERT((unsigned)index < 9);
        this->setTypeMask(kUnknown_Mask);
        return fMat[index];
    }

◆ operator[]() [2/2]

SkScalar SkMatrix::operator[] ( int index ) const

inline

Returns one matrix value. Asserts if index is out of range and SK_DEBUG is defined.

Parameters

index one of: kMScaleX, kMSkewX, kMTransX, kMSkewY, kMScaleY, kMTransY, kMPersp0, kMPersp1, kMPersp2

Returns: value corresponding to index

Definition at line 380 of file SkMatrix.h.

                                         {
        SkASSERT((unsigned)index < 9);
        return fMat[index];
    }

◆ postConcat()

SkMatrix & SkMatrix::postConcat ( const SkMatrix & other )

Sets SkMatrix to SkMatrix other multiplied by SkMatrix. This can be thought of mapping by other after applying SkMatrix.

Given:

         | J K L |           | A B C |
Matrix = | M N O |,  other = | D E F |
         | P Q R |           | G H I |

sets SkMatrix to:

                 | A B C |   | J K L |   | AJ+BM+CP AK+BN+CQ AL+BO+CR |
other * Matrix = | D E F | * | M N O | = | DJ+EM+FP DK+EN+FQ DL+EO+FR |
                 | G H I |   | P Q R |   | GJ+HM+IP GK+HN+IQ GL+HO+IR |

Parameters

other SkMatrix on left side of multiply expression

Definition at line 683 of file SkMatrix.cpp.

                                                  {
    // check for identity first, so we don't do a needless copy of ourselves
    // to ourselves inside setConcat()
    if (!mat.isIdentity()) {
        this->setConcat(mat, *this);
    }
    return *this;
}

◆ postRotate() [1/2]

SkMatrix & SkMatrix::postRotate ( SkScalar degrees )

Sets SkMatrix to SkMatrix constructed from rotating by degrees about pivot point (0, 0), multiplied by SkMatrix. This can be thought of as rotating about the origin after applying SkMatrix.

Positive degrees rotates clockwise.

Given:

         | J K L |                        | c -s 0 |
Matrix = | M N O |,  R(degrees, px, py) = | s  c 0 |
         | P Q R |                        | 0  0 1 |

where

c  = cos(degrees)
s  = sin(degrees)

sets SkMatrix to:

                              | c -s dx | | J K L |   | cJ-sM cK-sN cL-sO |
R(degrees, px, py) * Matrix = | s  c dy | | M N O | = | sJ+cM sK+cN sL+cO |
                              | 0  0  1 | | P Q R |   |     P     Q     R |

Parameters

degrees angle of axes relative to upright axes

Definition at line 480 of file SkMatrix.cpp.

                                               {
    SkMatrix    m;
    m.setRotate(degrees);
    return this->postConcat(m);
}

◆ postRotate() [2/2]

SkMatrix & SkMatrix::postRotate	(	SkScalar	degrees,
		SkScalar	px,
		SkScalar	py
	)

Sets SkMatrix to SkMatrix constructed from rotating by degrees about pivot point (px, py), multiplied by SkMatrix. This can be thought of as rotating about a pivot point after applying SkMatrix.

Positive degrees rotates clockwise.

Given:

         | J K L |                        | c -s dx |
Matrix = | M N O |,  R(degrees, px, py) = | s  c dy |
         | P Q R |                        | 0  0  1 |

where

c  = cos(degrees)
s  = sin(degrees)
dx =  s * py + (1 - c) * px
dy = -s * px + (1 - c) * py

sets SkMatrix to:

                              |c -s dx| |J K L|   |cJ-sM+dx*P cK-sN+dx*Q cL-sO+dx+R|
R(degrees, px, py) * Matrix = |s  c dy| |M N O| = |sJ+cM+dy*P sK+cN+dy*Q sL+cO+dy*R|
                              |0  0  1| |P Q R|   |         P          Q          R|

Parameters

degrees	angle of axes relative to upright axes
px	pivot on x-axis
py	pivot on y-axis

Definition at line 474 of file SkMatrix.cpp.

                                                                         {
    SkMatrix    m;
    m.setRotate(degrees, px, py);
    return this->postConcat(m);
}

◆ postScale() [1/2]

SkMatrix & SkMatrix::postScale	(	SkScalar	sx,
		SkScalar	sy
	)

Sets SkMatrix to SkMatrix constructed from scaling by (sx, sy) about pivot point (0, 0), multiplied by SkMatrix. This can be thought of as scaling about the origin after applying SkMatrix.

Given:

         | J K L |               | sx  0  0 |
Matrix = | M N O |,  S(sx, sy) = |  0 sy  0 |
         | P Q R |               |  0  0  1 |

sets SkMatrix to:

                     | sx  0  0 | | J K L |   | sx*J sx*K sx*L |
S(sx, sy) * Matrix = |  0 sy  0 | | M N O | = | sy*M sy*N sy*O |
                     |  0  0  1 | | P Q R |   |    P    Q    R |

Parameters

sx	horizontal scale factor
sy	vertical scale factor

Definition at line 369 of file SkMatrix.cpp.

                                                      {
    if (1 == sx && 1 == sy) {
        return *this;
    }
    SkMatrix    m;
    m.setScale(sx, sy);
    return this->postConcat(m);
}

◆ postScale() [2/2]

SkMatrix & SkMatrix::postScale	(	SkScalar	sx,
		SkScalar	sy,
		SkScalar	px,
		SkScalar	py
	)

Sets SkMatrix to SkMatrix constructed from scaling by (sx, sy) about pivot point (px, py), multiplied by SkMatrix. This can be thought of as scaling about a pivot point after applying SkMatrix.

Given:

         | J K L |                       | sx  0 dx |
Matrix = | M N O |,  S(sx, sy, px, py) = |  0 sy dy |
         | P Q R |                       |  0  0  1 |

where

dx = px - sx * px
dy = py - sy * py

sets SkMatrix to:

                             | sx  0 dx | | J K L |   | sx*J+dx*P sx*K+dx*Q sx*L+dx+R |
S(sx, sy, px, py) * Matrix = |  0 sy dy | | M N O | = | sy*M+dy*P sy*N+dy*Q sy*O+dy*R |
                             |  0  0  1 | | P Q R |   |         P         Q         R |

Parameters

sx	horizontal scale factor
sy	vertical scale factor
px	pivot on x-axis
py	pivot on y-axis

Definition at line 360 of file SkMatrix.cpp.

                                                                                {
    if (1 == sx && 1 == sy) {
        return *this;
    }
    SkMatrix    m;
    m.setScale(sx, sy, px, py);
    return this->postConcat(m);
}

◆ postSkew() [1/2]

SkMatrix & SkMatrix::postSkew	(	SkScalar	kx,
		SkScalar	ky
	)

Sets SkMatrix to SkMatrix constructed from skewing by (kx, ky) about pivot point (0, 0), multiplied by SkMatrix. This can be thought of as skewing about the origin after applying SkMatrix.

Given:

         | J K L |               |  1 kx 0 |
Matrix = | M N O |,  K(kx, ky) = | ky  1 0 |
         | P Q R |               |  0  0 1 |

sets SkMatrix to:

                     |  1 kx 0 | | J K L |   | J+kx*M K+kx*N L+kx*O |
K(kx, ky) * Matrix = | ky  1 0 | | M N O | = | ky*J+M ky*K+N ky*L+O |
                     |  0  0 1 | | P Q R |   |      P      Q      R |

Parameters

kx	horizontal skew factor
ky	vertical skew factor

Definition at line 530 of file SkMatrix.cpp.

                                                     {
    SkMatrix    m;
    m.setSkew(sx, sy);
    return this->postConcat(m);
}

◆ postSkew() [2/2]

SkMatrix & SkMatrix::postSkew	(	SkScalar	kx,
		SkScalar	ky,
		SkScalar	px,
		SkScalar	py
	)

Sets SkMatrix to SkMatrix constructed from skewing by (kx, ky) about pivot point (px, py), multiplied by SkMatrix. This can be thought of as skewing about a pivot point after applying SkMatrix.

Given:

         | J K L |                       |  1 kx dx |
Matrix = | M N O |,  K(kx, ky, px, py) = | ky  1 dy |
         | P Q R |                       |  0  0  1 |

where

dx = -kx * py
dy = -ky * px

sets SkMatrix to:

                             | 1 kx dx| |J K L|   |J+kx*M+dx*P K+kx*N+dx*Q L+kx*O+dx+R|
K(kx, ky, px, py) * Matrix = |ky  1 dy| |M N O| = |ky*J+M+dy*P ky*K+N+dy*Q ky*L+O+dy*R|
                             | 0  0  1| |P Q R|   |          P           Q           R|

Parameters

kx	horizontal skew factor
ky	vertical skew factor
px	pivot on x-axis
py	pivot on y-axis

Definition at line 524 of file SkMatrix.cpp.

                                                                               {
    SkMatrix    m;
    m.setSkew(sx, sy, px, py);
    return this->postConcat(m);
}

◆ postTranslate()

SkMatrix & SkMatrix::postTranslate	(	SkScalar	dx,
		SkScalar	dy
	)

Sets SkMatrix to SkMatrix constructed from translation (dx, dy) multiplied by SkMatrix. This can be thought of as moving the point to be mapped after applying SkMatrix.

Given:

         | J K L |               | 1 0 dx |
Matrix = | M N O |,  T(dx, dy) = | 0 1 dy |
         | P Q R |               | 0 0  1 |

sets SkMatrix to:

                     | 1 0 dx | | J K L |   | J+dx*P K+dx*Q L+dx*R |
T(dx, dy) * Matrix = | 0 1 dy | | M N O | = | M+dy*P N+dy*Q O+dy*R |
                     | 0 0  1 | | P Q R |   |      P      Q      R |

Parameters

dx	x-axis translation after applying SkMatrix
dy	y-axis translation after applying SkMatrix

Definition at line 281 of file SkMatrix.cpp.

                                                          {
    if (this->hasPerspective()) {
        SkMatrix    m;
        m.setTranslate(dx, dy);
        this->postConcat(m);
    } else {
        fMat[kMTransX] += dx;
        fMat[kMTransY] += dy;
        this->updateTranslateMask();
    }
    return *this;
}

◆ preConcat()

SkMatrix & SkMatrix::preConcat ( const SkMatrix & other )

Sets SkMatrix to SkMatrix multiplied by SkMatrix other. This can be thought of mapping by other before applying SkMatrix.

Given:

         | A B C |          | J K L |
Matrix = | D E F |, other = | M N O |
         | G H I |          | P Q R |

sets SkMatrix to:

                 | A B C |   | J K L |   | AJ+BM+CP AK+BN+CQ AL+BO+CR |
Matrix * other = | D E F | * | M N O | = | DJ+EM+FP DK+EN+FQ DL+EO+FR |
                 | G H I |   | P Q R |   | GJ+HM+IP GK+HN+IQ GL+HO+IR |

Parameters

other SkMatrix on right side of multiply expression

Definition at line 674 of file SkMatrix.cpp.

                                                 {
    // check for identity first, so we don't do a needless copy of ourselves
    // to ourselves inside setConcat()
    if(!mat.isIdentity()) {
        this->setConcat(*this, mat);
    }
    return *this;
}

◆ preRotate() [1/2]

SkMatrix & SkMatrix::preRotate ( SkScalar degrees )

Sets SkMatrix to SkMatrix multiplied by SkMatrix constructed from rotating by degrees about pivot point (0, 0). This can be thought of as rotating about the origin before applying SkMatrix.

Positive degrees rotates clockwise.

Given:

         | A B C |                        | c -s 0 |
Matrix = | D E F |,  R(degrees, px, py) = | s  c 0 |
         | G H I |                        | 0  0 1 |

where

c  = cos(degrees)
s  = sin(degrees)

sets SkMatrix to:

                              | A B C | | c -s 0 |   | Ac+Bs -As+Bc C |
Matrix * R(degrees, px, py) = | D E F | | s  c 0 | = | Dc+Es -Ds+Ec F |
                              | G H I | | 0  0 1 |   | Gc+Hs -Gs+Hc I |

Parameters

degrees angle of axes relative to upright axes

Definition at line 468 of file SkMatrix.cpp.

                                              {
    SkMatrix    m;
    m.setRotate(degrees);
    return this->preConcat(m);
}

◆ preRotate() [2/2]

SkMatrix & SkMatrix::preRotate	(	SkScalar	degrees,
		SkScalar	px,
		SkScalar	py
	)

Sets SkMatrix to SkMatrix multiplied by SkMatrix constructed from rotating by degrees about pivot point (px, py). This can be thought of as rotating about a pivot point before applying SkMatrix.

Positive degrees rotates clockwise.

Given:

         | A B C |                        | c -s dx |
Matrix = | D E F |,  R(degrees, px, py) = | s  c dy |
         | G H I |                        | 0  0  1 |

where

c  = cos(degrees)
s  = sin(degrees)
dx =  s * py + (1 - c) * px
dy = -s * px + (1 - c) * py

sets SkMatrix to:

                              | A B C | | c -s dx |   | Ac+Bs -As+Bc A*dx+B*dy+C |
Matrix * R(degrees, px, py) = | D E F | | s  c dy | = | Dc+Es -Ds+Ec D*dx+E*dy+F |
                              | G H I | | 0  0  1 |   | Gc+Hs -Gs+Hc G*dx+H*dy+I |

Parameters

degrees	angle of axes relative to upright axes
px	pivot on x-axis
py	pivot on y-axis

Definition at line 462 of file SkMatrix.cpp.

                                                                        {
    SkMatrix    m;
    m.setRotate(degrees, px, py);
    return this->preConcat(m);
}

◆ preScale() [1/2]

SkMatrix & SkMatrix::preScale	(	SkScalar	sx,
		SkScalar	sy
	)

Sets SkMatrix to SkMatrix multiplied by SkMatrix constructed from scaling by (sx, sy) about pivot point (0, 0). This can be thought of as scaling about the origin before applying SkMatrix.

Given:

         | A B C |               | sx  0  0 |
Matrix = | D E F |,  S(sx, sy) = |  0 sy  0 |
         | G H I |               |  0  0  1 |

sets SkMatrix to:

                     | A B C | | sx  0  0 |   | A*sx B*sy C |
Matrix * S(sx, sy) = | D E F | |  0 sy  0 | = | D*sx E*sy F |
                     | G H I | |  0  0  1 |   | G*sx H*sy I |

Parameters

sx	horizontal scale factor
sy	vertical scale factor

Definition at line 325 of file SkMatrix.cpp.

                                                     {
    if (1 == sx && 1 == sy) {
        return *this;
    }
 
    // the assumption is that these multiplies are very cheap, and that
    // a full concat and/or just computing the matrix type is more expensive.
    // Also, the fixed-point case checks for overflow, but the float doesn't,
    // so we can get away with these blind multiplies.
 
    fMat[kMScaleX] *= sx;
    fMat[kMSkewY]  *= sx;
    fMat[kMPersp0] *= sx;
 
    fMat[kMSkewX]  *= sy;
    fMat[kMScaleY] *= sy;
    fMat[kMPersp1] *= sy;
 
    // Attempt to simplify our type when applying an inverse scale.
    // TODO: The persp/affine preconditions are in place to keep the mask consistent with
    //       what computeTypeMask() would produce (persp/skew always implies kScale).
    //       We should investigate whether these flag dependencies are truly needed.
    if (fMat[kMScaleX] == 1 && fMat[kMScaleY] == 1
        && !(fTypeMask & (kPerspective_Mask | kAffine_Mask))) {
        this->clearTypeMask(kScale_Mask);
    } else {
        this->orTypeMask(kScale_Mask);
        // Remove kRectStaysRect if the preScale factors were 0
        if (!sx || !sy) {
            this->clearTypeMask(kRectStaysRect_Mask);
        }
    }
    return *this;
}

◆ preScale() [2/2]

SkMatrix & SkMatrix::preScale	(	SkScalar	sx,
		SkScalar	sy,
		SkScalar	px,
		SkScalar	py
	)

Sets SkMatrix to SkMatrix multiplied by SkMatrix constructed from scaling by (sx, sy) about pivot point (px, py). This can be thought of as scaling about a pivot point before applying SkMatrix.

Given:

         | A B C |                       | sx  0 dx |
Matrix = | D E F |,  S(sx, sy, px, py) = |  0 sy dy |
         | G H I |                       |  0  0  1 |

where

dx = px - sx * px
dy = py - sy * py

sets SkMatrix to:

                             | A B C | | sx  0 dx |   | A*sx B*sy A*dx+B*dy+C |
Matrix * S(sx, sy, px, py) = | D E F | |  0 sy dy | = | D*sx E*sy D*dx+E*dy+F |
                             | G H I | |  0  0  1 |   | G*sx H*sy G*dx+H*dy+I |

Parameters

sx	horizontal scale factor
sy	vertical scale factor
px	pivot on x-axis
py	pivot on y-axis

Definition at line 315 of file SkMatrix.cpp.

                                                                               {
    if (1 == sx && 1 == sy) {
        return *this;
    }
 
    SkMatrix    m;
    m.setScale(sx, sy, px, py);
    return this->preConcat(m);
}

◆ preservesAxisAlignment()

bool SkMatrix::preservesAxisAlignment ( ) const

inline

Returns true SkMatrix maps SkRect to another SkRect. If true, SkMatrix is identity, or scales, or rotates a multiple of 90 degrees, or mirrors on axes. In all cases, SkMatrix may also have translation. SkMatrix form is either:

| scale-x    0    translate-x |
|    0    scale-y translate-y |
|    0       0         1      |

or

|    0     rotate-x translate-x |
| rotate-y    0     translate-y |
|    0        0          1      |

for non-zero values of scale-x, scale-y, rotate-x, and rotate-y.

Also called rectStaysRect(); use the one that provides better inline documentation.

Returns: true if SkMatrix maps one SkRect into another

Definition at line 299 of file SkMatrix.h.

299{ return this->rectStaysRect(); }

◆ preservesRightAngles()

bool SkMatrix::preservesRightAngles ( SkScalar tol = SK_ScalarNearlyZero ) const

Returns true if SkMatrix contains only translation, rotation, reflection, and scale. Scale may differ along rotated axes. Returns false if SkMatrix skewing, perspective, or degenerate forms that collapse to a line or point.

Preserves right angles, but not requiring that the arms of the angle retain equal lengths.

Parameters

tol	to be deprecated

Returns: true if SkMatrix only rotates, scales, translates

example: https://fiddle.skia.org/c/@Matrix_preservesRightAngles

Definition at line 209 of file SkMatrix.cpp.

                                                      {
    TypeMask mask = this->getType();
 
    if (mask <= kTranslate_Mask) {
        // identity, translate and/or scale
        return true;
    }
    if (mask & kPerspective_Mask) {
        return false;
    }
 
    SkASSERT(mask & (kAffine_Mask | kScale_Mask));
 
    SkScalar mx = fMat[kMScaleX];
    SkScalar my = fMat[kMScaleY];
    SkScalar sx = fMat[kMSkewX];
    SkScalar sy = fMat[kMSkewY];
 
    if (is_degenerate_2x2(mx, sx, sy, my)) {
        return false;
    }
 
    // upper 2x2 is scale + rotation/reflection if basis vectors are orthogonal
    SkVector vec[2];
    vec[0].set(mx, sy);
    vec[1].set(sx, my);
 
    return SkScalarNearlyZero(vec[0].dot(vec[1]), SkScalarSquare(tol));
}

◆ preSkew() [1/2]

SkMatrix & SkMatrix::preSkew	(	SkScalar	kx,
		SkScalar	ky
	)

Sets SkMatrix to SkMatrix multiplied by SkMatrix constructed from skewing by (kx, ky) about pivot point (0, 0). This can be thought of as skewing about the origin before applying SkMatrix.

Given:

         | A B C |               |  1 kx 0 |
Matrix = | D E F |,  K(kx, ky) = | ky  1 0 |
         | G H I |               |  0  0 1 |

sets SkMatrix to:

                     | A B C | |  1 kx 0 |   | A+B*ky A*kx+B C |
Matrix * K(kx, ky) = | D E F | | ky  1 0 | = | D+E*ky D*kx+E F |
                     | G H I | |  0  0 1 |   | G+H*ky G*kx+H I |

Parameters

kx	horizontal skew factor
ky	vertical skew factor

Definition at line 518 of file SkMatrix.cpp.

                                                    {
    SkMatrix    m;
    m.setSkew(sx, sy);
    return this->preConcat(m);
}

◆ preSkew() [2/2]

SkMatrix & SkMatrix::preSkew	(	SkScalar	kx,
		SkScalar	ky,
		SkScalar	px,
		SkScalar	py
	)

Sets SkMatrix to SkMatrix multiplied by SkMatrix constructed from skewing by (kx, ky) about pivot point (px, py). This can be thought of as skewing about a pivot point before applying SkMatrix.

Given:

         | A B C |                       |  1 kx dx |
Matrix = | D E F |,  K(kx, ky, px, py) = | ky  1 dy |
         | G H I |                       |  0  0  1 |

where

dx = -kx * py
dy = -ky * px

sets SkMatrix to:

                             | A B C | |  1 kx dx |   | A+B*ky A*kx+B A*dx+B*dy+C |
Matrix * K(kx, ky, px, py) = | D E F | | ky  1 dy | = | D+E*ky D*kx+E D*dx+E*dy+F |
                             | G H I | |  0  0  1 |   | G+H*ky G*kx+H G*dx+H*dy+I |

Parameters

kx	horizontal skew factor
ky	vertical skew factor
px	pivot on x-axis
py	pivot on y-axis

Definition at line 512 of file SkMatrix.cpp.

                                                                              {
    SkMatrix    m;
    m.setSkew(sx, sy, px, py);
    return this->preConcat(m);
}

◆ preTranslate()

SkMatrix & SkMatrix::preTranslate	(	SkScalar	dx,
		SkScalar	dy
	)

Sets SkMatrix to SkMatrix multiplied by SkMatrix constructed from translation (dx, dy). This can be thought of as moving the point to be mapped before applying SkMatrix.

Given:

         | A B C |               | 1 0 dx |
Matrix = | D E F |,  T(dx, dy) = | 0 1 dy |
         | G H I |               | 0 0  1 |

sets SkMatrix to:

                     | A B C | | 1 0 dx |   | A B A*dx+B*dy+C |
Matrix * T(dx, dy) = | D E F | | 0 1 dy | = | D E D*dx+E*dy+F |
                     | G H I | | 0 0  1 |   | G H G*dx+H*dy+I |

Parameters

dx	x-axis translation before applying SkMatrix
dy	y-axis translation before applying SkMatrix

Definition at line 263 of file SkMatrix.cpp.

                                                         {
    const unsigned mask = this->getType();
 
    if (mask <= kTranslate_Mask) {
        fMat[kMTransX] += dx;
        fMat[kMTransY] += dy;
    } else if (mask & kPerspective_Mask) {
        SkMatrix    m;
        m.setTranslate(dx, dy);
        return this->preConcat(m);
    } else {
        fMat[kMTransX] += sdot(fMat[kMScaleX], dx, fMat[kMSkewX], dy);
        fMat[kMTransY] += sdot(fMat[kMSkewY], dx, fMat[kMScaleY], dy);
    }
    this->updateTranslateMask();
    return *this;
}

◆ rc()

SkScalar SkMatrix::rc	(	int	r,
		int	c
	)		const

inline

Returns one matrix value from a particular row/column. Asserts if index is out of range and SK_DEBUG is defined.

Parameters

r	matrix row to fetch
c	matrix column to fetch

Returns: value at the given matrix position

Definition at line 404 of file SkMatrix.h.

                                    {
        SkASSERT(r >= 0 && r <= 2);
        SkASSERT(c >= 0 && c <= 2);
        return fMat[r*3 + c];
    }

◆ rectStaysRect()

bool SkMatrix::rectStaysRect ( ) const

inline

Returns true SkMatrix maps SkRect to another SkRect. If true, SkMatrix is identity, or scales, or rotates a multiple of 90 degrees, or mirrors on axes. In all cases, SkMatrix may also have translation. SkMatrix form is either:

| scale-x    0    translate-x |
|    0    scale-y translate-y |
|    0       0         1      |

or

|    0     rotate-x translate-x |
| rotate-y    0     translate-y |
|    0        0          1      |

for non-zero values of scale-x, scale-y, rotate-x, and rotate-y.

Also called preservesAxisAlignment(); use the one that provides better inline documentation.

Returns: true if SkMatrix maps one SkRect into another

Definition at line 271 of file SkMatrix.h.

                               {
        if (fTypeMask & kUnknown_Mask) {
            fTypeMask = this->computeTypeMask();
        }
        return (fTypeMask & kRectStaysRect_Mask) != 0;
    }

◆ RectToRect()

static SkMatrix SkMatrix::RectToRect	(	const SkRect &	src,
		const SkRect &	dst,
		ScaleToFit	mode = `kFill_ScaleToFit`
	)

inlinestatic

Returns SkMatrix set to scale and translate src to dst. ScaleToFit selects whether mapping completely fills dst or preserves the aspect ratio, and how to align src within dst. Returns the identity SkMatrix if src is empty. If dst is empty, returns SkMatrix set to:

| 0 0 0 |
| 0 0 0 |
| 0 0 1 |

Parameters

src	SkRect to map from
dst	SkRect to map to
mode	How to handle the mapping

Returns: SkMatrix mapping src to dst

Definition at line 157 of file SkMatrix.h.

                                                                                 {
        return MakeRectToRect(src, dst, mode);
    }

◆ reset()

SkMatrix & SkMatrix::reset ( )

Sets SkMatrix to identity; which has no effect on mapped SkPoint. Sets SkMatrix to:

| 1 0 0 |
| 0 1 0 |
| 0 0 1 |

Also called setIdentity(); use the one that provides better inline documentation.

Definition at line 49 of file SkMatrix.cpp.

49{ *this = SkMatrix(); return *this; }

◆ RotateDeg() [1/2]

static SkMatrix SkMatrix::RotateDeg ( SkScalar deg )

inlinestatic

Sets SkMatrix to rotate by |deg| about a pivot point at (0, 0).

Parameters

deg	rotation angle in degrees (positive rotates clockwise)

Returns: SkMatrix with rotation

Definition at line 104 of file SkMatrix.h.

                                                          {
        SkMatrix m;
        m.setRotate(deg);
        return m;
    }

◆ RotateDeg() [2/2]

static SkMatrix SkMatrix::RotateDeg	(	SkScalar	deg,
		SkPoint	pt
	)

inlinestatic

Definition at line 109 of file SkMatrix.h.

                                                                      {
        SkMatrix m;
        m.setRotate(deg, pt.x(), pt.y());
        return m;
    }

◆ RotateRad()

static SkMatrix SkMatrix::RotateRad ( SkScalar rad )

inlinestatic

Definition at line 114 of file SkMatrix.h.

                                                          {
        return RotateDeg(SkRadiansToDegrees(rad));
    }

◆ Scale()

SkMatrix::Scale	(	SkScalar	sx,
		SkScalar	sy
	)

inlinestatic

Sets SkMatrix to scale by (sx, sy). Returned matrix is:

| sx  0  0 |
|  0 sy  0 |
|  0  0  1 |

Parameters

sx	horizontal scale factor
sy	vertical scale factor

Returns: SkMatrix with scale

Definition at line 75 of file SkMatrix.h.

                                                                  {
        SkMatrix m;
        m.setScale(sx, sy);
        return m;
    }

◆ set()

SkMatrix & SkMatrix::set	(	int	index,
		SkScalar	value
	)

inline

Sets SkMatrix value. Asserts if index is out of range and SK_DEBUG is defined. Safer than operator[]; internal cache is always maintained.

Parameters

index	one of: kMScaleX, kMSkewX, kMTransX, kMSkewY, kMScaleY, kMTransY, kMPersp0, kMPersp1, kMPersp2
value	scalar to store in SkMatrix

Definition at line 489 of file SkMatrix.h.

                                             {
        SkASSERT((unsigned)index < 9);
        fMat[index] = value;
        this->setTypeMask(kUnknown_Mask);
        return *this;
    }

◆ set9()

SkMatrix & SkMatrix::set9 ( const SkScalar buffer[9] )

Sets SkMatrix to nine scalar values in buffer, in member value ascending order: kMScaleX, kMSkewX, kMTransX, kMSkewY, kMScaleY, kMTransY, kMPersp0, kMPersp1, kMPersp2.

Sets matrix to:

| buffer[0] buffer[1] buffer[2] |
| buffer[3] buffer[4] buffer[5] |
| buffer[6] buffer[7] buffer[8] |

In the future, set9 followed by get9 may not return the same values. Since SkMatrix maps non-homogeneous coordinates, scaling all nine values produces an equivalent transformation, possibly improving precision.

Parameters

buffer nine scalar values

Definition at line 51 of file SkMatrix.cpp.

                                                 {
    memcpy(fMat, buffer, 9 * sizeof(SkScalar));
    this->setTypeMask(kUnknown_Mask);
    return *this;
}

◆ setAffine()

SkMatrix & SkMatrix::setAffine ( const SkScalar affine[6] )

Sets SkMatrix to affine values, passed in column major order. Given affine, column, then row, as:

| scale-x  skew-x translate-x |
|  skew-y scale-y translate-y |

SkMatrix is set, row, then column, to:

| scale-x  skew-x translate-x |
|  skew-y scale-y translate-y |
|       0       0           1 |

Parameters

affine 3 by 2 affine matrix

Definition at line 57 of file SkMatrix.cpp.

                                                      {
    fMat[kMScaleX] = buffer[kAScaleX];
    fMat[kMSkewX]  = buffer[kASkewX];
    fMat[kMTransX] = buffer[kATransX];
    fMat[kMSkewY]  = buffer[kASkewY];
    fMat[kMScaleY] = buffer[kAScaleY];
    fMat[kMTransY] = buffer[kATransY];
    fMat[kMPersp0] = 0;
    fMat[kMPersp1] = 0;
    fMat[kMPersp2] = 1;
    this->setTypeMask(kUnknown_Mask);
    return *this;
}

◆ SetAffineIdentity()

void SkMatrix::SetAffineIdentity ( SkScalar affine[6] )

static

Fills affine with identity values in column major order. Sets affine to:

| 1 0 0 |
| 0 1 0 |

Affine 3 by 2 matrices in column major order are used by OpenGL and XPS.

Parameters

affine storage for 3 by 2 affine matrix

example: https://fiddle.skia.org/c/@Matrix_SetAffineIdentity

Definition at line 746 of file SkMatrix.cpp.

                                                   {
    affine[kAScaleX] = 1;
    affine[kASkewY] = 0;
    affine[kASkewX] = 0;
    affine[kAScaleY] = 1;
    affine[kATransX] = 0;
    affine[kATransY] = 0;
}

◆ setAll()

SkMatrix & SkMatrix::setAll	(	SkScalar	scaleX,
		SkScalar	skewX,
		SkScalar	transX,
		SkScalar	skewY,
		SkScalar	scaleY,
		SkScalar	transY,
		SkScalar	persp0,
		SkScalar	persp1,
		SkScalar	persp2
	)

inline

Sets all values from parameters. Sets matrix to:

| scaleX  skewX transX |
|  skewY scaleY transY |
| persp0 persp1 persp2 |

Parameters

scaleX	horizontal scale factor to store
skewX	horizontal skew factor to store
transX	horizontal translation to store
skewY	vertical skew factor to store
scaleY	vertical scale factor to store
transY	vertical translation to store
persp0	input x-axis values perspective factor to store
persp1	input y-axis values perspective factor to store
persp2	perspective scale factor to store

Definition at line 562 of file SkMatrix.h.

                                                                        {
        fMat[kMScaleX] = scaleX;
        fMat[kMSkewX]  = skewX;
        fMat[kMTransX] = transX;
        fMat[kMSkewY]  = skewY;
        fMat[kMScaleY] = scaleY;
        fMat[kMTransY] = transY;
        fMat[kMPersp0] = persp0;
        fMat[kMPersp1] = persp1;
        fMat[kMPersp2] = persp2;
        this->setTypeMask(kUnknown_Mask);
        return *this;
    }

◆ setConcat()

SkMatrix & SkMatrix::setConcat	(	const SkMatrix &	a,
		const SkMatrix &	b
	)

Sets SkMatrix to SkMatrix a multiplied by SkMatrix b. Either a or b may be this.

Given:

    | A B C |      | J K L |
a = | D E F |, b = | M N O |
    | G H I |      | P Q R |

sets SkMatrix to:

        | A B C |   | J K L |   | AJ+BM+CP AK+BN+CQ AL+BO+CR |
a * b = | D E F | * | M N O | = | DJ+EM+FP DK+EN+FQ DL+EO+FR |
        | G H I |   | P Q R |   | GJ+HM+IP GK+HN+IQ GL+HO+IR |

Parameters

a	SkMatrix on left side of multiply expression
b	SkMatrix on right side of multiply expression

Definition at line 603 of file SkMatrix.cpp.

                                                                  {
    TypeMask aType = a.getType();
    TypeMask bType = b.getType();
 
    if (a.isTriviallyIdentity()) {
        *this = b;
    } else if (b.isTriviallyIdentity()) {
        *this = a;
    } else if (only_scale_and_translate(aType | bType)) {
        this->setScaleTranslate(a.fMat[kMScaleX] * b.fMat[kMScaleX],
                                a.fMat[kMScaleY] * b.fMat[kMScaleY],
                                a.fMat[kMScaleX] * b.fMat[kMTransX] + a.fMat[kMTransX],
                                a.fMat[kMScaleY] * b.fMat[kMTransY] + a.fMat[kMTransY]);
    } else {
        SkMatrix tmp;
 
        if ((aType | bType) & kPerspective_Mask) {
            tmp.fMat[kMScaleX] = rowcol3(&a.fMat[0], &b.fMat[0]);
            tmp.fMat[kMSkewX]  = rowcol3(&a.fMat[0], &b.fMat[1]);
            tmp.fMat[kMTransX] = rowcol3(&a.fMat[0], &b.fMat[2]);
            tmp.fMat[kMSkewY]  = rowcol3(&a.fMat[3], &b.fMat[0]);
            tmp.fMat[kMScaleY] = rowcol3(&a.fMat[3], &b.fMat[1]);
            tmp.fMat[kMTransY] = rowcol3(&a.fMat[3], &b.fMat[2]);
            tmp.fMat[kMPersp0] = rowcol3(&a.fMat[6], &b.fMat[0]);
            tmp.fMat[kMPersp1] = rowcol3(&a.fMat[6], &b.fMat[1]);
            tmp.fMat[kMPersp2] = rowcol3(&a.fMat[6], &b.fMat[2]);
 
            tmp.setTypeMask(kUnknown_Mask);
        } else {
            tmp.fMat[kMScaleX] = muladdmul(a.fMat[kMScaleX],
                                           b.fMat[kMScaleX],
                                           a.fMat[kMSkewX],
                                           b.fMat[kMSkewY]);
 
            tmp.fMat[kMSkewX]  = muladdmul(a.fMat[kMScaleX],
                                           b.fMat[kMSkewX],
                                           a.fMat[kMSkewX],
                                           b.fMat[kMScaleY]);
 
            tmp.fMat[kMTransX] = muladdmul(a.fMat[kMScaleX],
                                           b.fMat[kMTransX],
                                           a.fMat[kMSkewX],
                                           b.fMat[kMTransY]) + a.fMat[kMTransX];
 
            tmp.fMat[kMSkewY]  = muladdmul(a.fMat[kMSkewY],
                                           b.fMat[kMScaleX],
                                           a.fMat[kMScaleY],
                                           b.fMat[kMSkewY]);
 
            tmp.fMat[kMScaleY] = muladdmul(a.fMat[kMSkewY],
                                           b.fMat[kMSkewX],
                                           a.fMat[kMScaleY],
                                           b.fMat[kMScaleY]);
 
            tmp.fMat[kMTransY] = muladdmul(a.fMat[kMSkewY],
                                           b.fMat[kMTransX],
                                           a.fMat[kMScaleY],
                                           b.fMat[kMTransY]) + a.fMat[kMTransY];
 
            tmp.fMat[kMPersp0] = 0;
            tmp.fMat[kMPersp1] = 0;
            tmp.fMat[kMPersp2] = 1;
            //SkDebugf("Concat mat non-persp type: %d\n", tmp.getType());
            //SkASSERT(!(tmp.getType() & kPerspective_Mask));
            tmp.setTypeMask(kUnknown_Mask | kOnlyPerspectiveValid_Mask);
        }
        *this = tmp;
    }
    return *this;
}

◆ setIdentity()

SkMatrix & SkMatrix::setIdentity ( )

inline

Sets SkMatrix to identity; which has no effect on mapped SkPoint. Sets SkMatrix to:

| 1 0 0 |
| 0 1 0 |
| 0 0 1 |

Also called reset(); use the one that provides better inline documentation.

Definition at line 626 of file SkMatrix.h.

626{ return this->reset(); }

◆ setPerspX()

SkMatrix & SkMatrix::setPerspX ( SkScalar v )

inline

Sets input x-axis perspective factor, which causes mapXY() to vary input x-axis values inversely proportional to input y-axis values.

Parameters

v	perspective factor

Definition at line 537 of file SkMatrix.h.

537{ return this->set(kMPersp0, v); }

SkMatrix::set

SkMatrix & set(int index, SkScalar value)

Definition SkMatrix.h:489

◆ setPerspY()

SkMatrix & SkMatrix::setPerspY ( SkScalar v )

inline

Sets input y-axis perspective factor, which causes mapXY() to vary input y-axis values inversely proportional to input x-axis values.

Parameters

v	perspective factor

Definition at line 544 of file SkMatrix.h.

544{ return this->set(kMPersp1, v); }

◆ setPolyToPoly()

bool SkMatrix::setPolyToPoly	(	const SkPoint	src[],
		const SkPoint	dst[],
		int	count
	)

Sets SkMatrix to map src to dst. count must be zero or greater, and four or less.

If count is zero, sets SkMatrix to identity and returns true. If count is one, sets SkMatrix to translate and returns true. If count is two or more, sets SkMatrix to map SkPoint if possible; returns false if SkMatrix cannot be constructed. If count is four, SkMatrix may include perspective.

Parameters

src	SkPoint to map from
dst	SkPoint to map to
count	number of SkPoint in src and dst

Returns: true if SkMatrix was constructed successfully

example: https://fiddle.skia.org/c/@Matrix_setPolyToPoly

Definition at line 1385 of file SkMatrix.cpp.

                                                                                {
    if ((unsigned)count > 4) {
        SkDebugf("--- SkMatrix::setPolyToPoly count out of range %d\n", count);
        return false;
    }
 
    if (0 == count) {
        this->reset();
        return true;
    }
    if (1 == count) {
        this->setTranslate(dst[0].fX - src[0].fX, dst[0].fY - src[0].fY);
        return true;
    }
 
    const PolyMapProc gPolyMapProcs[] = {
        SkMatrix::Poly2Proc, SkMatrix::Poly3Proc, SkMatrix::Poly4Proc
    };
    PolyMapProc proc = gPolyMapProcs[count - 2];
 
    SkMatrix tempMap, result;
 
    if (!proc(src, &tempMap)) {
        return false;
    }
    if (!tempMap.invert(&result)) {
        return false;
    }
    if (!proc(dst, &tempMap)) {
        return false;
    }
    this->setConcat(tempMap, result);
    return true;
}

◆ setRectToRect()

bool SkMatrix::setRectToRect	(	const SkRect &	src,
		const SkRect &	dst,
		ScaleToFit	stf
	)

Sets SkMatrix to scale and translate src SkRect to dst SkRect. stf selects whether mapping completely fills dst or preserves the aspect ratio, and how to align src within dst. Returns false if src is empty, and sets SkMatrix to identity. Returns true if dst is empty, and sets SkMatrix to:

| 0 0 0 |
| 0 0 0 |
| 0 0 1 |

Parameters

src	SkRect to map from
dst	SkRect to map to

Returns: true if SkMatrix can represent SkRect mapping

example: https://fiddle.skia.org/c/@Matrix_setRectToRect

Definition at line 538 of file SkMatrix.cpp.

                                                                                   {
    if (src.isEmpty()) {
        this->reset();
        return false;
    }
 
    if (dst.isEmpty()) {
        sk_bzero(fMat, 8 * sizeof(SkScalar));
        fMat[kMPersp2] = 1;
        this->setTypeMask(kScale_Mask);
    } else {
        SkScalar    tx, sx = sk_ieee_float_divide(dst.width(), src.width());
        SkScalar    ty, sy = sk_ieee_float_divide(dst.height(), src.height());
        bool        xLarger = false;
 
        if (align != kFill_ScaleToFit) {
            if (sx > sy) {
                xLarger = true;
                sx = sy;
            } else {
                sy = sx;
            }
        }
 
        tx = dst.fLeft - src.fLeft * sx;
        ty = dst.fTop - src.fTop * sy;
        if (align == kCenter_ScaleToFit || align == kEnd_ScaleToFit) {
            SkScalar diff;
 
            if (xLarger) {
                diff = dst.width() - src.width() * sy;
            } else {
                diff = dst.height() - src.height() * sy;
            }
 
            if (align == kCenter_ScaleToFit) {
                diff = SkScalarHalf(diff);
            }
 
            if (xLarger) {
                tx += diff;
            } else {
                ty += diff;
            }
        }
 
        this->setScaleTranslate(sx, sy, tx, ty);
    }
    return true;
}

◆ setRotate() [1/2]

SkMatrix & SkMatrix::setRotate ( SkScalar degrees )

Sets SkMatrix to rotate by degrees about a pivot point at (0, 0). Positive degrees rotates clockwise.

Parameters

degrees angle of axes relative to upright axes

Definition at line 457 of file SkMatrix.cpp.

                                              {
    SkScalar rad = SkDegreesToRadians(degrees);
    return this->setSinCos(SkScalarSinSnapToZero(rad), SkScalarCosSnapToZero(rad));
}

◆ setRotate() [2/2]

SkMatrix & SkMatrix::setRotate	(	SkScalar	degrees,
		SkScalar	px,
		SkScalar	py
	)

Sets SkMatrix to rotate by degrees about a pivot point at (px, py). The pivot point is unchanged when mapped with SkMatrix.

Positive degrees rotates clockwise.

Parameters

degrees	angle of axes relative to upright axes
px	pivot on x-axis
py	pivot on y-axis

Definition at line 452 of file SkMatrix.cpp.

                                                                        {
    SkScalar rad = SkDegreesToRadians(degrees);
    return this->setSinCos(SkScalarSinSnapToZero(rad), SkScalarCosSnapToZero(rad), px, py);
}

◆ setRSXform()

SkMatrix & SkMatrix::setRSXform ( const SkRSXform & rsxForm )

Sets SkMatrix to rotate, scale, and translate using a compressed matrix form.

Vector (rsxForm.fSSin, rsxForm.fSCos) describes the angle of rotation relative to (0, 1). Vector length specifies scale. Mapped point is rotated and scaled by vector, then translated by (rsxForm.fTx, rsxForm.fTy).

Parameters

rsxForm compressed SkRSXform matrix

Returns: reference to SkMatrix

example: https://fiddle.skia.org/c/@Matrix_setRSXform

Definition at line 420 of file SkMatrix.cpp.

                                                     {
    fMat[kMScaleX]  = xform.fSCos;
    fMat[kMSkewX]   = -xform.fSSin;
    fMat[kMTransX]  = xform.fTx;
 
    fMat[kMSkewY]   = xform.fSSin;
    fMat[kMScaleY]  = xform.fSCos;
    fMat[kMTransY]  = xform.fTy;
 
    fMat[kMPersp0] = fMat[kMPersp1] = 0;
    fMat[kMPersp2] = 1;
 
    this->setTypeMask(kUnknown_Mask | kOnlyPerspectiveValid_Mask);
    return *this;
}

◆ setScale() [1/2]

SkMatrix & SkMatrix::setScale	(	SkScalar	sx,
		SkScalar	sy
	)

Sets SkMatrix to scale by sx and sy about at pivot point at (0, 0).

Parameters

sx	horizontal scale factor
sy	vertical scale factor

Definition at line 305 of file SkMatrix.cpp.

                                                     {
    auto rectMask = (sx == 0 || sy == 0) ? 0 : kRectStaysRect_Mask;
    *this = SkMatrix(sx, 0,  0,
                     0,  sy, 0,
                     0,  0,  1,
                     (sx == 1 && sy == 1) ? kIdentity_Mask | rectMask
                                          : kScale_Mask    | rectMask);
    return *this;
}

◆ setScale() [2/2]

SkMatrix & SkMatrix::setScale	(	SkScalar	sx,
		SkScalar	sy,
		SkScalar	px,
		SkScalar	py
	)

Sets SkMatrix to scale by sx and sy, about a pivot point at (px, py). The pivot point is unchanged when mapped with SkMatrix.

Parameters

sx	horizontal scale factor
sy	vertical scale factor
px	pivot on x-axis
py	pivot on y-axis

Definition at line 296 of file SkMatrix.cpp.

                                                                               {
    if (1 == sx && 1 == sy) {
        this->reset();
    } else {
        this->setScaleTranslate(sx, sy, px - sx * px, py - sy * py);
    }
    return *this;
}

◆ setScaleTranslate()

void SkMatrix::setScaleTranslate	(	SkScalar	sx,
		SkScalar	sy,
		SkScalar	tx,
		SkScalar	ty
	)

inline

Initializes SkMatrix with scale and translate elements.

| sx  0 tx |
|  0 sy ty |
|  0  0  1 |

Parameters

sx	horizontal scale factor to store
sy	vertical scale factor to store
tx	horizontal translation to store
ty	vertical translation to store

Definition at line 1803 of file SkMatrix.h.

                                                                               {
        fMat[kMScaleX] = sx;
        fMat[kMSkewX]  = 0;
        fMat[kMTransX] = tx;
 
        fMat[kMSkewY]  = 0;
        fMat[kMScaleY] = sy;
        fMat[kMTransY] = ty;
 
        fMat[kMPersp0] = 0;
        fMat[kMPersp1] = 0;
        fMat[kMPersp2] = 1;
 
        int mask = 0;
        if (sx != 1 || sy != 1) {
            mask |= kScale_Mask;
        }
        if (tx != 0.0f || ty != 0.0f) {
            mask |= kTranslate_Mask;
        }
        if (sx != 0 && sy != 0) {
            mask |= kRectStaysRect_Mask;
        }
        this->setTypeMask(mask);
    }

◆ setScaleX()

SkMatrix & SkMatrix::setScaleX ( SkScalar v )

inline

Sets horizontal scale factor.

Parameters

v	horizontal scale factor to store

Definition at line 500 of file SkMatrix.h.

500{ return this->set(kMScaleX, v); }

◆ setScaleY()

SkMatrix & SkMatrix::setScaleY ( SkScalar v )

inline

Sets vertical scale factor.

Parameters

v	vertical scale factor to store

Definition at line 506 of file SkMatrix.h.

506{ return this->set(kMScaleY, v); }

◆ setSinCos() [1/2]

SkMatrix & SkMatrix::setSinCos	(	SkScalar	sinValue,
		SkScalar	cosValue
	)

Sets SkMatrix to rotate by sinValue and cosValue, about a pivot point at (0, 0).

Vector (sinValue, cosValue) describes the angle of rotation relative to (0, 1). Vector length specifies scale.

Parameters

sinValue	rotation vector x-axis component
cosValue	rotation vector y-axis component

Definition at line 436 of file SkMatrix.cpp.

                                                          {
    fMat[kMScaleX]  = cosV;
    fMat[kMSkewX]   = -sinV;
    fMat[kMTransX]  = 0;
 
    fMat[kMSkewY]   = sinV;
    fMat[kMScaleY]  = cosV;
    fMat[kMTransY]  = 0;
 
    fMat[kMPersp0] = fMat[kMPersp1] = 0;
    fMat[kMPersp2] = 1;
 
    this->setTypeMask(kUnknown_Mask | kOnlyPerspectiveValid_Mask);
    return *this;
}

◆ setSinCos() [2/2]

SkMatrix & SkMatrix::setSinCos	(	SkScalar	sinValue,
		SkScalar	cosValue,
		SkScalar	px,
		SkScalar	py
	)

Sets SkMatrix to rotate by sinValue and cosValue, about a pivot point at (px, py). The pivot point is unchanged when mapped with SkMatrix.

Vector (sinValue, cosValue) describes the angle of rotation relative to (0, 1). Vector length specifies scale.

Parameters

sinValue	rotation vector x-axis component
cosValue	rotation vector y-axis component
px	pivot on x-axis
py	pivot on y-axis

Definition at line 402 of file SkMatrix.cpp.

                                                                                    {
    const SkScalar oneMinusCosV = 1 - cosV;
 
    fMat[kMScaleX]  = cosV;
    fMat[kMSkewX]   = -sinV;
    fMat[kMTransX]  = sdot(sinV, py, oneMinusCosV, px);
 
    fMat[kMSkewY]   = sinV;
    fMat[kMScaleY]  = cosV;
    fMat[kMTransY]  = sdot(-sinV, px, oneMinusCosV, py);
 
    fMat[kMPersp0] = fMat[kMPersp1] = 0;
    fMat[kMPersp2] = 1;
 
    this->setTypeMask(kUnknown_Mask | kOnlyPerspectiveValid_Mask);
    return *this;
}

◆ setSkew() [1/2]

SkMatrix & SkMatrix::setSkew	(	SkScalar	kx,
		SkScalar	ky
	)

Sets SkMatrix to skew by kx and ky, about a pivot point at (0, 0).

Parameters

kx	horizontal skew factor
ky	vertical skew factor

Definition at line 496 of file SkMatrix.cpp.

                                                    {
    fMat[kMScaleX]  = 1;
    fMat[kMSkewX]   = sx;
    fMat[kMTransX]  = 0;
 
    fMat[kMSkewY]   = sy;
    fMat[kMScaleY]  = 1;
    fMat[kMTransY]  = 0;
 
    fMat[kMPersp0] = fMat[kMPersp1] = 0;
    fMat[kMPersp2] = 1;
 
    this->setTypeMask(kUnknown_Mask | kOnlyPerspectiveValid_Mask);
    return *this;
}

◆ setSkew() [2/2]

SkMatrix & SkMatrix::setSkew	(	SkScalar	kx,
		SkScalar	ky,
		SkScalar	px,
		SkScalar	py
	)

Sets SkMatrix to skew by kx and ky, about a pivot point at (px, py). The pivot point is unchanged when mapped with SkMatrix.

Parameters

kx	horizontal skew factor
ky	vertical skew factor
px	pivot on x-axis
py	pivot on y-axis

Definition at line 488 of file SkMatrix.cpp.

                                                                              {
    *this = SkMatrix(1,  sx, -sx * py,
                     sy, 1,  -sy * px,
                     0,  0,  1,
                     kUnknown_Mask | kOnlyPerspectiveValid_Mask);
    return *this;
}

◆ setSkewX()

SkMatrix & SkMatrix::setSkewX ( SkScalar v )

inline

Sets horizontal skew factor.

Parameters

v	horizontal skew factor to store

Definition at line 518 of file SkMatrix.h.

518{ return this->set(kMSkewX, v); }

◆ setSkewY()

SkMatrix & SkMatrix::setSkewY ( SkScalar v )

inline

Sets vertical skew factor.

Parameters

v	vertical skew factor to store

Definition at line 512 of file SkMatrix.h.

512{ return this->set(kMSkewY, v); }

◆ setTranslate() [1/2]

SkMatrix & SkMatrix::setTranslate ( const SkVector & v )

inline

Sets SkMatrix to translate by (v.fX, v.fY).

Parameters

v	vector containing horizontal and vertical translation

Definition at line 639 of file SkMatrix.h.

639{ return this->setTranslate(v.fX, v.fY); }

◆ setTranslate() [2/2]

SkMatrix & SkMatrix::setTranslate	(	SkScalar	dx,
		SkScalar	dy
	)

Sets SkMatrix to translate by (dx, dy).

Parameters

dx	horizontal translation
dy	vertical translation

Definition at line 254 of file SkMatrix.cpp.

                                                         {
    *this = SkMatrix(1, 0, dx,
                     0, 1, dy,
                     0, 0, 1,
                     (dx != 0 || dy != 0) ? kTranslate_Mask | kRectStaysRect_Mask
                                          : kIdentity_Mask  | kRectStaysRect_Mask);
    return *this;
}

◆ setTranslateX()

SkMatrix & SkMatrix::setTranslateX ( SkScalar v )

inline

Sets horizontal translation.

Parameters

v	horizontal translation to store

Definition at line 524 of file SkMatrix.h.

524{ return this->set(kMTransX, v); }

◆ setTranslateY()

SkMatrix & SkMatrix::setTranslateY ( SkScalar v )

inline

Sets vertical translation.

Parameters

v	vertical translation to store

Definition at line 530 of file SkMatrix.h.

530{ return this->set(kMTransY, v); }

◆ Skew()

static SkMatrix SkMatrix::Skew	(	SkScalar	kx,
		SkScalar	ky
	)

inlinestatic

Sets SkMatrix to skew by (kx, ky) about pivot point (0, 0).

Parameters

kx	horizontal skew factor
ky	vertical skew factor

Returns: SkMatrix with skew

Definition at line 124 of file SkMatrix.h.

                                                                 {
        SkMatrix m;
        m.setSkew(kx, ky);
        return m;
    }

◆ Translate() [1/3]

static SkMatrix SkMatrix::Translate ( SkIVector t )

inlinestatic

Definition at line 97 of file SkMatrix.h.

97{ return Translate(t.x(), t.y()); }

SkMatrix::Translate

static SkMatrix Translate(SkScalar dx, SkScalar dy)

Definition SkMatrix.h:91

SkIPoint::y

constexpr int32_t y() const

Definition SkPoint_impl.h:52

SkIPoint::x

constexpr int32_t x() const

Definition SkPoint_impl.h:46

◆ Translate() [2/3]

static SkMatrix SkMatrix::Translate	(	SkScalar	dx,
		SkScalar	dy
	)

inlinestatic

Sets SkMatrix to translate by (dx, dy). Returned matrix is:

| 1 0 dx |
| 0 1 dy |
| 0 0  1 |

Parameters

dx	horizontal translation
dy	vertical translation

Returns: SkMatrix with translation

Definition at line 91 of file SkMatrix.h.

                                                                      {
        SkMatrix m;
        m.setTranslate(dx, dy);
        return m;
    }

◆ Translate() [3/3]

static SkMatrix SkMatrix::Translate ( SkVector t )

inlinestatic

Definition at line 96 of file SkMatrix.h.

96{ return Translate(t.x(), t.y()); }

Friends And Related Symbol Documentation

◆ operator!=

SK_API bool operator!=	(	const SkMatrix &	a,
		const SkMatrix &	b
	)

friend

Compares a and b; returns true if a and b are not numerically equal. Returns false even if sign of zero values are different. Returns true if either SkMatrix contains NaN, even if the other SkMatrix also contains NaN.

Parameters

a	SkMatrix to compare
b	SkMatrix to compare

Returns: true if SkMatrix a and SkMatrix b are numerically not equal

Definition at line 1667 of file SkMatrix.h.

                                                                        {
        return !(a == b);
    }

◆ operator*

SkMatrix operator*	(	const SkMatrix &	a,
		const SkMatrix &	b
	)

friend

Definition at line 1781 of file SkMatrix.h.

                                                                    {
        return Concat(a, b);
    }

◆ operator==

SK_API bool operator==	(	const SkMatrix &	a,
		const SkMatrix &	b
	)

friend

Compares a and b; returns true if a and b are numerically equal. Returns true even if sign of zero values are different. Returns false if either SkMatrix contains NaN, even if the other SkMatrix also contains NaN.

Parameters

a	SkMatrix to compare
b	SkMatrix to compare

Returns: true if SkMatrix a and SkMatrix b are numerically equal

Definition at line 160 of file SkMatrix.cpp.

                                                      {
    const SkScalar* SK_RESTRICT ma = a.fMat;
    const SkScalar* SK_RESTRICT mb = b.fMat;
 
    return  ma[0] == mb[0] && ma[1] == mb[1] && ma[2] == mb[2] &&
            ma[3] == mb[3] && ma[4] == mb[4] && ma[5] == mb[5] &&
            ma[6] == mb[6] && ma[7] == mb[7] && ma[8] == mb[8];
}

◆ SerializationTest

friend class SerializationTest

friend

Definition at line 1993 of file SkMatrix.h.

◆ SkMatrixPriv

friend class SkMatrixPriv

friend

Definition at line 1992 of file SkMatrix.h.

◆ SkPerspIter

friend class SkPerspIter

friend

Definition at line 1991 of file SkMatrix.h.

Member Data Documentation

◆ kAScaleX

constexpr int SkMatrix::kAScaleX = 0

staticconstexpr

horizontal scale factor

Affine arrays are in column-major order to match the matrix used by PDF and XPS.

Definition at line 366 of file SkMatrix.h.

◆ kAScaleY

constexpr int SkMatrix::kAScaleY = 3

staticconstexpr

vertical scale factor

Definition at line 369 of file SkMatrix.h.

◆ kASkewX

constexpr int SkMatrix::kASkewX = 2

staticconstexpr

horizontal skew factor

Definition at line 368 of file SkMatrix.h.

◆ kASkewY

constexpr int SkMatrix::kASkewY = 1

staticconstexpr

vertical skew factor

Definition at line 367 of file SkMatrix.h.

◆ kATransX

constexpr int SkMatrix::kATransX = 4

staticconstexpr

horizontal translation

Definition at line 370 of file SkMatrix.h.

◆ kATransY

constexpr int SkMatrix::kATransY = 5

staticconstexpr

vertical translation

Definition at line 371 of file SkMatrix.h.

◆ kMPersp0

constexpr int SkMatrix::kMPersp0 = 6

staticconstexpr

input x perspective factor

Definition at line 359 of file SkMatrix.h.

◆ kMPersp1

constexpr int SkMatrix::kMPersp1 = 7

staticconstexpr

input y perspective factor

Definition at line 360 of file SkMatrix.h.

◆ kMPersp2

constexpr int SkMatrix::kMPersp2 = 8

staticconstexpr

perspective bias

Definition at line 361 of file SkMatrix.h.

◆ kMScaleX

constexpr int SkMatrix::kMScaleX = 0

staticconstexpr

horizontal scale factor

SkMatrix organizes its values in row-major order. These members correspond to each value in SkMatrix.

Definition at line 353 of file SkMatrix.h.

◆ kMScaleY

constexpr int SkMatrix::kMScaleY = 4

staticconstexpr

vertical scale factor

Definition at line 357 of file SkMatrix.h.

◆ kMSkewX

constexpr int SkMatrix::kMSkewX = 1

staticconstexpr

horizontal skew factor

Definition at line 354 of file SkMatrix.h.

◆ kMSkewY

constexpr int SkMatrix::kMSkewY = 3

staticconstexpr

vertical skew factor

Definition at line 356 of file SkMatrix.h.

◆ kMTransX

constexpr int SkMatrix::kMTransX = 2

staticconstexpr

horizontal translation

Definition at line 355 of file SkMatrix.h.

◆ kMTransY

constexpr int SkMatrix::kMTransY = 5

staticconstexpr

vertical translation

Definition at line 358 of file SkMatrix.h.

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

third_party/skia/include/core/SkMatrix.h
third_party/skia/bench/DrawBitmapAABench.cpp
third_party/skia/src/core/SkMatrix.cpp

Public Types

Public Member Functions

Static Public Member Functions

Static Public Attributes

Friends

Detailed Description

Member Enumeration Documentation

◆ ScaleToFit

◆ TypeMask

Constructor & Destructor Documentation

◆ SkMatrix()

Member Function Documentation

◆ asAffine()

◆ Concat()

◆ decomposeScale()

◆ dirtyMatrixTypeCache()

◆ dump()

◆ get()

◆ get9()

◆ getMaxScale()

◆ getMinMaxScales()

◆ getMinScale()

◆ getPerspX()

◆ getPerspY()

◆ getScaleX()

◆ getScaleY()

◆ getSkewX()

◆ getSkewY()

◆ getTranslateX()

◆ getTranslateY()

◆ getType()

◆ hasPerspective()

◆ I()

◆ InvalidMatrix()

◆ invert()

◆ isFinite()

◆ isIdentity()

◆ isScaleTranslate()

◆ isSimilarity()

◆ isTranslate()

◆ MakeAll()

◆ MakeRectToRect()

◆ mapHomogeneousPoints() [1/2]

◆ mapHomogeneousPoints() [2/2]

◆ mapOrigin()

◆ mapPoint()

◆ mapPoints() [1/2]

◆ mapPoints() [2/2]

◆ mapRadius()

◆ mapRect() [1/3]

◆ mapRect() [2/3]

◆ mapRect() [3/3]

◆ mapRectScaleTranslate()

◆ mapRectToQuad()

◆ mapVector() [1/2]

◆ mapVector() [2/2]

◆ mapVectors() [1/2]

◆ mapVectors() [2/2]

◆ mapXY() [1/2]

◆ mapXY() [2/2]

◆ normalizePerspective()

◆ operator[]() [1/2]

◆ operator[]() [2/2]

◆ postConcat()

◆ postRotate() [1/2]

◆ postRotate() [2/2]

◆ postScale() [1/2]

◆ postScale() [2/2]

◆ postSkew() [1/2]

◆ postSkew() [2/2]

◆ postTranslate()

◆ preConcat()

◆ preRotate() [1/2]

◆ preRotate() [2/2]

◆ preScale() [1/2]

◆ preScale() [2/2]

◆ preservesAxisAlignment()

◆ preservesRightAngles()

◆ preSkew() [1/2]

◆ preSkew() [2/2]