| #Topic Matrix |
| #Alias Matrix_Reference |
| |
| #Class SkMatrix |
| |
| Matrix holds a 3x3 matrix for transforming coordinates. |
| Matrix elements are in column major order. |
| |
| SkMatrix does not have a constructor, so it must be explicitly initialized |
| using either reset() - to construct an identity matrix, or one of the set |
| functions (e.g. setTranslate, setRotate, etc.). |
| |
| SkMatrix is not thread safe unless getType is called first. |
| |
| #Topic Overview |
| |
| #Subtopic Subtopics |
| #ToDo manually add subtopics ## |
| #Table |
| #Legend |
| # topics # description ## |
| #Legend ## |
| #Table ## |
| ## |
| |
| #Subtopic Operators |
| #Table |
| #Legend |
| # description # function ## |
| #Legend ## |
| # friend SK_API bool operator!=(const SkMatrix& a, const SkMatrix& b) # Returns true if members are unequal. ## |
| # friend SK_API bool operator==(const SkMatrix& a, const SkMatrix& b) # Returns true if members are equal. ## |
| # SkScalar operator[](int index) const # Returns one of nine Matrix values. ## |
| # SkScalar& operator[](int index) # Returns a writable reference to one of nine Matrix values. ## |
| #Table ## |
| #Subtopic ## |
| |
| #Subtopic Member_Functions |
| #Table |
| #Legend |
| # description # function ## |
| #Legend ## |
| # Concat # Returns the concatenation of Matrix pair. ## |
| # GetMapPtsProc # Returns optimal function to map Point array. ## |
| # GetMapXYProc # Returns optimal function to map one Point. ## |
| # I # Returns a reference to a const identity Matrix. ## |
| # InvalidMatrix # Returns a reference to a const invalid Matrix. ## |
| # MakeRectToRect # Constructs from source Rect to destination Rect. ## |
| # MakeScale # Constructs from scale in x and y. ## |
| # MakeTrans # Constructs from translate in x and y. ## |
| # SetAffineIdentity # Sets 2x3 array to identity. ## |
| # asAffine # Copies to 2x3 array. ## |
| # cheapEqualTo # Compares Matrix pair using memcmp(). ## |
| # decomposeScale # Separates scale if possible. ## |
| # dirtyMatrixTypeCache # Private; used by testing. ## |
| # dump # Sends text representation using floats to standard output. ## |
| # fixedStepInX # Returns step in x for a position in y. ## |
| # get # Returns one of nine Matrix values. ## |
| # get9 # Returns all nine Matrix values. ## |
| # getMapPtsProc # Returns optimal function to map Point array. ## |
| # getMapXYProc # Returns optimal function to map one Point. ## |
| # getMaxScale # Returns maximum scaling, if possible. ## |
| # getMinMaxScales # Returns minimum and maximum scaling, if possible. ## |
| # getMinScale # Returns minimum scaling, if possible. ## |
| # getPerspX # Returns horizontal perspective factor. ## |
| # getPerspY # Returns vertical perspective factor. ## |
| # getScaleX # Returns horizontal scale factor. ## |
| # getScaleY # Returns vertical scale factor.## |
| # getSkewX # Returns horizontal skew factor. ## |
| # getSkewY # Returns vertical skew factor. ## |
| # getTranslateX # Returns horizontal translation factor. ## |
| # getTranslateY # Returns vertical translation factor. ## |
| # getType # Returns transform complexity. ## |
| # hasPerspective # Returns if transform includes perspective. ## |
| # invert # Returns inverse, if possible. ## |
| # isFinite # Returns if all Matrix values are not infinity, NaN. ## |
| # isFixedStepInX # Returns if transformation supports fixed step in x. ## |
| # isIdentity # Returns if matrix equals the identity Matrix .## |
| # isScaleTranslate # Returns if transform is limited to scale and translate. ## |
| # isSimilarity # Returns if transform is limited to square scale and rotation. ## |
| # isTranslate # Returns if transform is limited to translate. ## |
| # mapHomogeneousPoints # ## |
| # mapPoints # ## |
| # mapPointsWithStride # ## |
| # mapRadius # ## |
| # mapRect # ## |
| # mapRectScaleTranslate # ## |
| # mapRectToQuad # ## |
| # mapVector # ## |
| # mapVectors # ## |
| # mapXY # ## |
| # postConcat # ## |
| # postIDiv # ## |
| # postRotate # ## |
| # postScale # ## |
| # postSkew # ## |
| # postTranslate # ## |
| # preConcat # ## |
| # preRotate # ## |
| # preScale # ## |
| # preSkew # ## |
| # preTranslate # ## |
| # preservesAxisAlignment # ## |
| # preservesRightAngles # ## |
| # readFromMemory # ## |
| # rectStaysRect # ## |
| # reset # ## |
| # set # ## |
| # set9 # ## |
| # setAffine # ## |
| # setAll # ## |
| # setConcat # ## |
| # setIDiv # ## |
| # setIdentity # ## |
| # setPerspX # ## |
| # setPerspY # ## |
| # setPolyToPoly # ## |
| # setRSXform # ## |
| # setRectToRect # ## |
| # setRotate # ## |
| # setScale # ## |
| # setScaleTranslate # ## |
| # setScaleX # ## |
| # setScaleY # ## |
| # setSinCos # ## |
| # setSkew # ## |
| # setSkewX # ## |
| # setSkewY # ## |
| # setTranslate # ## |
| # setTranslateX # ## |
| # setTranslateY # ## |
| # toString # ## |
| # writeToMemory # ## |
| #Table ## |
| #Subtopic ## |
| |
| #Topic ## |
| |
| # ------------------------------------------------------------------------------ |
| |
| #Method static SkMatrix SK_WARN_UNUSED_RESULT MakeScale(SkScalar sx, SkScalar sy) |
| |
| #Param sx incomplete ## |
| #Param sy incomplete ## |
| |
| #Return incomplete ## |
| |
| #Example |
| // incomplete |
| ## |
| |
| #ToDo incomplete ## |
| |
| ## |
| |
| # ------------------------------------------------------------------------------ |
| |
| #Method static SkMatrix SK_WARN_UNUSED_RESULT MakeScale(SkScalar scale) |
| |
| #Param scale incomplete ## |
| |
| #Return incomplete ## |
| |
| #Example |
| // incomplete |
| ## |
| |
| #ToDo incomplete ## |
| |
| ## |
| |
| # ------------------------------------------------------------------------------ |
| |
| #Method static SkMatrix SK_WARN_UNUSED_RESULT MakeTrans(SkScalar dx, SkScalar dy) |
| |
| #Param dx incomplete ## |
| #Param dy incomplete ## |
| |
| #Return incomplete ## |
| |
| #Example |
| // incomplete |
| ## |
| |
| #ToDo incomplete ## |
| |
| ## |
| |
| # ------------------------------------------------------------------------------ |
| |
| #Enum TypeMask |
| |
| #Code |
| enum TypeMask { |
| kIdentity_Mask = 0, |
| kTranslate_Mask = 0x01, |
| kScale_Mask = 0x02, |
| kAffine_Mask = 0x04, |
| kPerspective_Mask = 0x08, |
| }; |
| ## |
| |
| Enum of bit fields for the mask return by getType(). |
| Use this to identify the complexity of the matrix. |
| |
| #Const kIdentity_Mask = 0 |
| ## |
| #Const kTranslate_Mask = 0x01 |
| set if the matrix has translation |
| ## |
| #Const kScale_Mask = 0x02 |
| set if the matrix has x or y scale |
| ## |
| #Const kAffine_Mask = 0x04 |
| set if the matrix skews or rotates |
| ## |
| #Const kPerspective_Mask = 0x08 |
| set if the matrix is in perspective |
| ## |
| |
| #Example |
| // incomplete |
| ## |
| |
| #ToDo incomplete ## |
| |
| ## |
| |
| # ------------------------------------------------------------------------------ |
| |
| #Method TypeMask getType() const |
| |
| 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 true, all |
| other bits may be set to true even in the case of a pure perspective |
| transform. |
| |
| #Return incomplete ## |
| |
| #Example |
| // incomplete |
| ## |
| |
| #ToDo incomplete ## |
| |
| ## |
| |
| # ------------------------------------------------------------------------------ |
| |
| #Method bool isIdentity() const |
| |
| Returns true if the matrix is identity. |
| |
| #Return incomplete ## |
| |
| #Example |
| // incomplete |
| ## |
| |
| #ToDo incomplete ## |
| |
| ## |
| |
| # ------------------------------------------------------------------------------ |
| |
| #Method bool isScaleTranslate() const |
| |
| #Return incomplete ## |
| |
| #Example |
| // incomplete |
| ## |
| |
| #ToDo incomplete ## |
| |
| ## |
| |
| # ------------------------------------------------------------------------------ |
| |
| #Method bool isTranslate() const |
| |
| #Return incomplete ## |
| |
| #Example |
| // incomplete |
| ## |
| |
| #ToDo incomplete ## |
| |
| ## |
| |
| # ------------------------------------------------------------------------------ |
| |
| #Method bool rectStaysRect() const |
| |
| Returns true if will map a rectangle to another rectangle. This can be |
| true if the matrix is identity, scale-only, or rotates a multiple of |
| 90 degrees, or mirrors in x or y. |
| |
| #Return incomplete ## |
| |
| #Example |
| // incomplete |
| ## |
| |
| #ToDo incomplete ## |
| |
| ## |
| |
| # ------------------------------------------------------------------------------ |
| |
| #Method bool preservesAxisAlignment() const |
| |
| alias for rectStaysRect() |
| |
| #Return incomplete ## |
| |
| #Example |
| // incomplete |
| ## |
| |
| #ToDo incomplete ## |
| |
| ## |
| |
| # ------------------------------------------------------------------------------ |
| |
| #Method bool hasPerspective() const |
| |
| Returns true if the matrix contains perspective elements. |
| |
| #Return incomplete ## |
| |
| #Example |
| // incomplete |
| ## |
| |
| #ToDo incomplete ## |
| |
| ## |
| |
| # ------------------------------------------------------------------------------ |
| |
| #Method bool isSimilarity(SkScalar tol = SK_ScalarNearlyZero) const |
| |
| Returns true if the matrix contains only translation, rotation/reflection or uniform scale. |
| Returns false if other transformation types are included or is degenerate |
| |
| #Param tol incomplete ## |
| |
| #Return incomplete ## |
| |
| #Example |
| // incomplete |
| ## |
| |
| #ToDo incomplete ## |
| |
| ## |
| |
| # ------------------------------------------------------------------------------ |
| |
| #Method bool preservesRightAngles(SkScalar tol = SK_ScalarNearlyZero) const |
| |
| Returns true if the matrix contains only translation, rotation/reflection or scale |
| (non-uniform scale is allowed). |
| Returns false if other transformation types are included or is degenerate |
| |
| #Param tol incomplete ## |
| |
| #Return incomplete ## |
| |
| #Example |
| // incomplete |
| ## |
| |
| #ToDo incomplete ## |
| |
| ## |
| |
| # ------------------------------------------------------------------------------ |
| |
| #Enum _anonymous |
| |
| #Code |
| enum { |
| kMScaleX, |
| kMSkewX, |
| kMTransX, |
| kMSkewY, |
| kMScaleY, |
| kMTransY, |
| kMPersp0, |
| kMPersp1, |
| kMPersp2, |
| }; |
| ## |
| |
| #Const kMScaleX 0 |
| ## |
| #Const kMSkewX 1 |
| ## |
| #Const kMTransX 2 |
| ## |
| #Const kMSkewY 3 |
| ## |
| #Const kMScaleY 4 |
| ## |
| #Const kMTransY 5 |
| ## |
| #Const kMPersp0 6 |
| ## |
| #Const kMPersp1 7 |
| ## |
| #Const kMPersp2 8 |
| ## |
| |
| #Example |
| // incomplete |
| ## |
| |
| #ToDo incomplete ## |
| |
| ## |
| |
| # ------------------------------------------------------------------------------ |
| |
| #Enum _anonymous_2 |
| |
| #Code |
| enum { |
| kAScaleX, |
| kASkewY, |
| kASkewX, |
| kAScaleY, |
| kATransX, |
| kATransY, |
| }; |
| ## |
| |
| Affine arrays are in column major order |
| because that is how PDF and XPS like it. |
| |
| #Const kAScaleX 0 |
| ## |
| #Const kASkewY 1 |
| ## |
| #Const kASkewX 2 |
| ## |
| #Const kAScaleY 3 |
| ## |
| #Const kATransX 4 |
| ## |
| #Const kATransY 5 |
| ## |
| |
| #Example |
| // incomplete |
| ## |
| |
| #ToDo incomplete ## |
| |
| ## |
| |
| # ------------------------------------------------------------------------------ |
| |
| #Method SkScalar operator[](int index) const |
| |
| #Param index incomplete ## |
| |
| #Return incomplete ## |
| |
| #Example |
| // incomplete |
| ## |
| |
| #ToDo incomplete ## |
| |
| ## |
| |
| # ------------------------------------------------------------------------------ |
| |
| #Method SkScalar get(int index) const |
| |
| #Param index incomplete ## |
| |
| #Return incomplete ## |
| |
| #Example |
| // incomplete |
| ## |
| |
| #ToDo incomplete ## |
| |
| ## |
| |
| # ------------------------------------------------------------------------------ |
| |
| #Method SkScalar getScaleX() const |
| |
| #Return incomplete ## |
| |
| #Example |
| // incomplete |
| ## |
| |
| #ToDo incomplete ## |
| |
| ## |
| |
| # ------------------------------------------------------------------------------ |
| |
| #Method SkScalar getScaleY() const |
| |
| #Return incomplete ## |
| |
| #Example |
| // incomplete |
| ## |
| |
| #ToDo incomplete ## |
| |
| ## |
| |
| # ------------------------------------------------------------------------------ |
| |
| #Method SkScalar getSkewY() const |
| |
| #Return incomplete ## |
| |
| #Example |
| // incomplete |
| ## |
| |
| #ToDo incomplete ## |
| |
| ## |
| |
| # ------------------------------------------------------------------------------ |
| |
| #Method SkScalar getSkewX() const |
| |
| #Return incomplete ## |
| |
| #Example |
| // incomplete |
| ## |
| |
| #ToDo incomplete ## |
| |
| ## |
| |
| # ------------------------------------------------------------------------------ |
| |
| #Method SkScalar getTranslateX() const |
| |
| #Return incomplete ## |
| |
| #Example |
| // incomplete |
| ## |
| |
| #ToDo incomplete ## |
| |
| ## |
| |
| # ------------------------------------------------------------------------------ |
| |
| #Method SkScalar getTranslateY() const |
| |
| #Return incomplete ## |
| |
| #Example |
| // incomplete |
| ## |
| |
| #ToDo incomplete ## |
| |
| ## |
| |
| # ------------------------------------------------------------------------------ |
| |
| #Method SkScalar getPerspX() const |
| |
| #Return incomplete ## |
| |
| #Example |
| // incomplete |
| ## |
| |
| #ToDo incomplete ## |
| |
| ## |
| |
| # ------------------------------------------------------------------------------ |
| |
| #Method SkScalar getPerspY() const |
| |
| #Return incomplete ## |
| |
| #Example |
| // incomplete |
| ## |
| |
| #ToDo incomplete ## |
| |
| ## |
| |
| # ------------------------------------------------------------------------------ |
| |
| #Method SkScalar operator[](int index) |
| |
| #Param index incomplete ## |
| |
| #Return incomplete ## |
| |
| #Example |
| // incomplete |
| ## |
| |
| #ToDo incomplete ## |
| |
| ## |
| |
| # ------------------------------------------------------------------------------ |
| |
| #Method void set(int index, SkScalar value) |
| |
| #Param index incomplete ## |
| #Param value incomplete ## |
| |
| #Example |
| // incomplete |
| ## |
| |
| #ToDo incomplete ## |
| |
| ## |
| |
| # ------------------------------------------------------------------------------ |
| |
| #Method void setScaleX(SkScalar v) |
| |
| #Param v incomplete ## |
| |
| #Example |
| // incomplete |
| ## |
| |
| #ToDo incomplete ## |
| |
| ## |
| |
| # ------------------------------------------------------------------------------ |
| |
| #Method void setScaleY(SkScalar v) |
| |
| #Param v incomplete ## |
| |
| #Example |
| // incomplete |
| ## |
| |
| #ToDo incomplete ## |
| |
| ## |
| |
| # ------------------------------------------------------------------------------ |
| |
| #Method void setSkewY(SkScalar v) |
| |
| #Param v incomplete ## |
| |
| #Example |
| // incomplete |
| ## |
| |
| #ToDo incomplete ## |
| |
| ## |
| |
| # ------------------------------------------------------------------------------ |
| |
| #Method void setSkewX(SkScalar v) |
| |
| #Param v incomplete ## |
| |
| #Example |
| // incomplete |
| ## |
| |
| #ToDo incomplete ## |
| |
| ## |
| |
| # ------------------------------------------------------------------------------ |
| |
| #Method void setTranslateX(SkScalar v) |
| |
| #Param v incomplete ## |
| |
| #Example |
| // incomplete |
| ## |
| |
| #ToDo incomplete ## |
| |
| ## |
| |
| # ------------------------------------------------------------------------------ |
| |
| #Method void setTranslateY(SkScalar v) |
| |
| #Param v incomplete ## |
| |
| #Example |
| // incomplete |
| ## |
| |
| #ToDo incomplete ## |
| |
| ## |
| |
| # ------------------------------------------------------------------------------ |
| |
| #Method void setPerspX(SkScalar v) |
| |
| #Param v incomplete ## |
| |
| #Example |
| // incomplete |
| ## |
| |
| #ToDo incomplete ## |
| |
| ## |
| |
| # ------------------------------------------------------------------------------ |
| |
| #Method void setPerspY(SkScalar v) |
| |
| #Param v incomplete ## |
| |
| #Example |
| // incomplete |
| ## |
| |
| #ToDo incomplete ## |
| |
| ## |
| |
| # ------------------------------------------------------------------------------ |
| |
| #Method void setAll(SkScalar scaleX, SkScalar skewX, SkScalar transX, |
| SkScalar skewY, SkScalar scaleY, SkScalar transY, |
| SkScalar persp0, SkScalar persp1, SkScalar persp2) |
| |
| #Param scaleX incomplete ## |
| #Param skewX incomplete ## |
| #Param transX incomplete ## |
| #Param skewY incomplete ## |
| #Param scaleY incomplete ## |
| #Param transY incomplete ## |
| #Param persp0 incomplete ## |
| #Param persp1 incomplete ## |
| #Param persp2 incomplete ## |
| |
| #Example |
| // incomplete |
| ## |
| |
| #ToDo incomplete ## |
| |
| ## |
| |
| # ------------------------------------------------------------------------------ |
| |
| #Method void get9(SkScalar buffer[9]) const |
| |
| Copy the 9 scalars for this matrix into buffer, in member value ascending order: |
| kMScaleX, kMSkewX, kMTransX, kMSkewY, kMScaleY, kMTransY, kMPersp0, kMPersp1, kMPersp2. |
| |
| #Param buffer incomplete ## |
| |
| #Example |
| // incomplete |
| ## |
| |
| #ToDo incomplete ## |
| |
| ## |
| |
| # ------------------------------------------------------------------------------ |
| |
| #Method void set9(const SkScalar buffer[9]) |
| |
| Set this matrix to the 9 scalars from the buffer, in member value ascending order: |
| kMScaleX, kMSkewX, kMTransX, kMSkewY, kMScaleY, kMTransY, kMPersp0, kMPersp1, kMPersp2. |
| |
| Note: calling set9 followed by get9 may not return the exact same values. Since the matrix |
| is used to map non-homogeneous coordinates, it is free to scale the 9 values as needed. |
| |
| #Param buffer incomplete ## |
| |
| #Example |
| // incomplete |
| ## |
| |
| #ToDo incomplete ## |
| |
| ## |
| |
| # ------------------------------------------------------------------------------ |
| |
| #Method void reset() |
| |
| Set the matrix to identity |
| |
| #Example |
| // incomplete |
| ## |
| |
| #ToDo incomplete ## |
| |
| ## |
| |
| # ------------------------------------------------------------------------------ |
| |
| #Method void setIdentity() |
| |
| alias for reset() |
| |
| #Example |
| // incomplete |
| ## |
| |
| #ToDo incomplete ## |
| |
| ## |
| |
| # ------------------------------------------------------------------------------ |
| |
| #Method void setTranslate(SkScalar dx, SkScalar dy) |
| |
| Set the matrix to translate by (dx, dy). |
| |
| #Param dx incomplete ## |
| #Param dy incomplete ## |
| |
| #Example |
| // incomplete |
| ## |
| |
| #ToDo incomplete ## |
| |
| ## |
| |
| # ------------------------------------------------------------------------------ |
| |
| #Method void setTranslate(const SkVector& v) |
| |
| #Param v incomplete ## |
| |
| #Example |
| // incomplete |
| ## |
| |
| #ToDo incomplete ## |
| |
| ## |
| |
| # ------------------------------------------------------------------------------ |
| |
| #Method void setScale(SkScalar sx, SkScalar sy, SkScalar px, SkScalar py) |
| |
| Set the matrix to scale by sx and sy, with a pivot point at (px, py). |
| The pivot point is the coordinate that should remain unchanged by the |
| specified transformation. |
| |
| #Param sx incomplete ## |
| #Param sy incomplete ## |
| #Param px incomplete ## |
| #Param py incomplete ## |
| |
| #Example |
| // incomplete |
| ## |
| |
| #ToDo incomplete ## |
| |
| ## |
| |
| # ------------------------------------------------------------------------------ |
| |
| #Method void setScale(SkScalar sx, SkScalar sy) |
| |
| Set the matrix to scale by sx and sy. |
| |
| #Param sx incomplete ## |
| #Param sy incomplete ## |
| |
| #Example |
| // incomplete |
| ## |
| |
| #ToDo incomplete ## |
| |
| ## |
| |
| # ------------------------------------------------------------------------------ |
| |
| #Method bool setIDiv(int divx, int divy) |
| |
| Set the matrix to scale by 1/divx and 1/divy. Returns false and does not |
| touch the matrix if either divx or divy is zero. |
| |
| #Param divx incomplete ## |
| #Param divy incomplete ## |
| |
| #Return incomplete ## |
| |
| #Example |
| // incomplete |
| ## |
| |
| #ToDo incomplete ## |
| |
| ## |
| |
| # ------------------------------------------------------------------------------ |
| |
| #Method void setRotate(SkScalar degrees, SkScalar px, SkScalar py) |
| |
| Set the matrix to rotate by the specified number of degrees, with a |
| pivot point at (px, py). The pivot point is the coordinate that should |
| remain unchanged by the specified transformation. |
| |
| #Param degrees incomplete ## |
| #Param px incomplete ## |
| #Param py incomplete ## |
| |
| #Example |
| // incomplete |
| ## |
| |
| #ToDo incomplete ## |
| |
| ## |
| |
| # ------------------------------------------------------------------------------ |
| |
| #Method void setRotate(SkScalar degrees) |
| |
| Set the matrix to rotate about (0,0) by the specified number of degrees. |
| |
| #Param degrees incomplete ## |
| |
| #Example |
| // incomplete |
| ## |
| |
| #ToDo incomplete ## |
| |
| ## |
| |
| # ------------------------------------------------------------------------------ |
| |
| #Method void setSinCos(SkScalar sinValue, SkScalar cosValue, |
| SkScalar px, SkScalar py) |
| |
| Set the matrix to rotate by the specified sine and cosine values, with |
| a pivot point at (px, py). The pivot point is the coordinate that |
| should remain unchanged by the specified transformation. |
| |
| #Param sinValue incomplete ## |
| #Param cosValue incomplete ## |
| #Param px incomplete ## |
| #Param py incomplete ## |
| |
| #Example |
| // incomplete |
| ## |
| |
| #ToDo incomplete ## |
| |
| ## |
| |
| # ------------------------------------------------------------------------------ |
| |
| #Method void setSinCos(SkScalar sinValue, SkScalar cosValue) |
| |
| Set the matrix to rotate by the specified sine and cosine values. |
| |
| #Param sinValue incomplete ## |
| #Param cosValue incomplete ## |
| |
| #Example |
| // incomplete |
| ## |
| |
| #ToDo incomplete ## |
| |
| ## |
| |
| # ------------------------------------------------------------------------------ |
| |
| #Method SkMatrix& setRSXform(const SkRSXform& rsxForm) |
| |
| #Param rsxForm incomplete ## |
| |
| #Return incomplete ## |
| |
| #Example |
| // incomplete |
| ## |
| |
| #ToDo incomplete ## |
| |
| ## |
| |
| # ------------------------------------------------------------------------------ |
| |
| #Method void setSkew(SkScalar kx, SkScalar ky, SkScalar px, SkScalar py) |
| |
| Set the matrix to skew by kx and ky, with a pivot point at (px, py). |
| The pivot point is the coordinate that should remain unchanged by the |
| specified transformation. |
| |
| #Param kx incomplete ## |
| #Param ky incomplete ## |
| #Param px incomplete ## |
| #Param py incomplete ## |
| |
| #Example |
| // incomplete |
| ## |
| |
| #ToDo incomplete ## |
| |
| ## |
| |
| # ------------------------------------------------------------------------------ |
| |
| #Method void setSkew(SkScalar kx, SkScalar ky) |
| |
| Set the matrix to skew by kx and ky. |
| |
| #Param kx incomplete ## |
| #Param ky incomplete ## |
| |
| #Example |
| // incomplete |
| ## |
| |
| #ToDo incomplete ## |
| |
| ## |
| |
| # ------------------------------------------------------------------------------ |
| |
| #Method void setConcat(const SkMatrix& a, const SkMatrix& b) |
| |
| Set the matrix to the concatenation of the two specified matrices. |
| Either of the two matrices may also be the target matrix. |
| this = a * b; |
| |
| #Param a incomplete ## |
| #Param b incomplete ## |
| |
| #Example |
| // incomplete |
| ## |
| |
| #ToDo incomplete ## |
| |
| ## |
| |
| # ------------------------------------------------------------------------------ |
| |
| #Method void preTranslate(SkScalar dx, SkScalar dy) |
| |
| Preconcats the matrix with the specified translation. |
| #Formula |
| M' = M * T(dx, dy) |
| ## |
| |
| #Param dx incomplete ## |
| #Param dy incomplete ## |
| |
| #Example |
| // incomplete |
| ## |
| |
| #ToDo incomplete ## |
| |
| ## |
| |
| # ------------------------------------------------------------------------------ |
| |
| #Method void preScale(SkScalar sx, SkScalar sy, SkScalar px, SkScalar py) |
| |
| Preconcats the matrix with the specified scale. |
| #Formula |
| M' = M * S(sx, sy, px, py) |
| ## |
| |
| #Param sx incomplete ## |
| #Param sy incomplete ## |
| #Param px incomplete ## |
| #Param py incomplete ## |
| |
| #Example |
| // incomplete |
| ## |
| |
| #ToDo incomplete ## |
| |
| ## |
| |
| # ------------------------------------------------------------------------------ |
| |
| #Method void preScale(SkScalar sx, SkScalar sy) |
| |
| Preconcats the matrix with the specified scale. |
| #Formula |
| M' = M * S(sx, sy) |
| ## |
| |
| #Param sx incomplete ## |
| #Param sy incomplete ## |
| |
| #Example |
| // incomplete |
| ## |
| |
| #ToDo incomplete ## |
| |
| ## |
| |
| # ------------------------------------------------------------------------------ |
| |
| #Method void preRotate(SkScalar degrees, SkScalar px, SkScalar py) |
| |
| Preconcats the matrix with the specified rotation. |
| #Formula |
| M' = M * R(degrees, px, py) |
| ## |
| |
| #Param degrees incomplete ## |
| #Param px incomplete ## |
| #Param py incomplete ## |
| |
| #Example |
| // incomplete |
| ## |
| |
| #ToDo incomplete ## |
| |
| ## |
| |
| # ------------------------------------------------------------------------------ |
| |
| #Method void preRotate(SkScalar degrees) |
| |
| Preconcats the matrix with the specified rotation. |
| #Formula |
| M' = M * R(degrees) |
| ## |
| |
| #Param degrees incomplete ## |
| |
| #Example |
| // incomplete |
| ## |
| |
| #ToDo incomplete ## |
| |
| ## |
| |
| # ------------------------------------------------------------------------------ |
| |
| #Method void preSkew(SkScalar kx, SkScalar ky, SkScalar px, SkScalar py) |
| |
| Preconcats the matrix with the specified skew. |
| #Formula |
| M' = M * K(kx, ky, px, py) |
| ## |
| |
| #Param kx incomplete ## |
| #Param ky incomplete ## |
| #Param px incomplete ## |
| #Param py incomplete ## |
| |
| #Example |
| // incomplete |
| ## |
| |
| #ToDo incomplete ## |
| |
| ## |
| |
| # ------------------------------------------------------------------------------ |
| |
| #Method void preSkew(SkScalar kx, SkScalar ky) |
| |
| Preconcats the matrix with the specified skew. |
| #Formula |
| M' = M * K(kx, ky) |
| ## |
| |
| #Param kx incomplete ## |
| #Param ky incomplete ## |
| |
| #Example |
| // incomplete |
| ## |
| |
| #ToDo incomplete ## |
| |
| ## |
| |
| # ------------------------------------------------------------------------------ |
| |
| #Method void preConcat(const SkMatrix& other) |
| |
| Preconcats the matrix with the specified matrix. |
| #Formula |
| M' = M * other |
| ## |
| |
| #Param other incomplete ## |
| |
| #Example |
| // incomplete |
| ## |
| |
| #ToDo incomplete ## |
| |
| ## |
| |
| # ------------------------------------------------------------------------------ |
| |
| #Method void postTranslate(SkScalar dx, SkScalar dy) |
| |
| Postconcats the matrix with the specified translation. |
| #Formula |
| M' = T(dx, dy) * M |
| ## |
| |
| #Param dx incomplete ## |
| #Param dy incomplete ## |
| |
| #Example |
| // incomplete |
| ## |
| |
| #ToDo incomplete ## |
| |
| ## |
| |
| # ------------------------------------------------------------------------------ |
| |
| #Method void postScale(SkScalar sx, SkScalar sy, SkScalar px, SkScalar py) |
| |
| Postconcats the matrix with the specified scale. |
| #Formula |
| M' = S(sx, sy, px, py) * M |
| ## |
| |
| #Param sx incomplete ## |
| #Param sy incomplete ## |
| #Param px incomplete ## |
| #Param py incomplete ## |
| |
| #Example |
| // incomplete |
| ## |
| |
| #ToDo incomplete ## |
| |
| ## |
| |
| # ------------------------------------------------------------------------------ |
| |
| #Method void postScale(SkScalar sx, SkScalar sy) |
| |
| Postconcats the matrix with the specified scale. |
| #Formula |
| M' = S(sx, sy) * M |
| ## |
| |
| #Param sx incomplete ## |
| #Param sy incomplete ## |
| |
| #Example |
| // incomplete |
| ## |
| |
| #ToDo incomplete ## |
| |
| ## |
| |
| # ------------------------------------------------------------------------------ |
| |
| #Method bool postIDiv(int divx, int divy) |
| |
| Postconcats the matrix by dividing it by the specified integers. |
| #Formula |
| M' = S(1/divx, 1/divy, 0, 0) * M |
| ## |
| |
| #Param divx incomplete ## |
| #Param divy incomplete ## |
| |
| #Return incomplete ## |
| |
| #Example |
| // incomplete |
| ## |
| |
| #ToDo incomplete ## |
| |
| ## |
| |
| # ------------------------------------------------------------------------------ |
| |
| #Method void postRotate(SkScalar degrees, SkScalar px, SkScalar py) |
| |
| Postconcats the matrix with the specified rotation. |
| #Formula |
| M' = R(degrees, px, py) * M |
| ## |
| |
| #Param degrees incomplete ## |
| #Param px incomplete ## |
| #Param py incomplete ## |
| |
| #Example |
| // incomplete |
| ## |
| |
| #ToDo incomplete ## |
| |
| ## |
| |
| # ------------------------------------------------------------------------------ |
| |
| #Method void postRotate(SkScalar degrees) |
| |
| Postconcats the matrix with the specified rotation. |
| #Formula |
| M' = R(degrees) * M |
| ## |
| |
| #Param degrees incomplete ## |
| |
| #Example |
| // incomplete |
| ## |
| |
| #ToDo incomplete ## |
| |
| ## |
| |
| # ------------------------------------------------------------------------------ |
| |
| #Method void postSkew(SkScalar kx, SkScalar ky, SkScalar px, SkScalar py) |
| |
| Postconcats the matrix with the specified skew. |
| #Formula |
| M' = K(kx, ky, px, py) * M |
| ## |
| |
| #Param kx incomplete ## |
| #Param ky incomplete ## |
| #Param px incomplete ## |
| #Param py incomplete ## |
| |
| #Example |
| // incomplete |
| ## |
| |
| #ToDo incomplete ## |
| |
| ## |
| |
| # ------------------------------------------------------------------------------ |
| |
| #Method void postSkew(SkScalar kx, SkScalar ky) |
| |
| Postconcats the matrix with the specified skew. |
| #Formula |
| M' = K(kx, ky) * M |
| ## |
| |
| #Param kx incomplete ## |
| #Param ky incomplete ## |
| |
| #Example |
| // incomplete |
| ## |
| |
| #ToDo incomplete ## |
| |
| ## |
| |
| # ------------------------------------------------------------------------------ |
| |
| #Method void postConcat(const SkMatrix& other) |
| |
| Postconcats the matrix with the specified matrix. |
| #Formula |
| M' = other * M |
| ## |
| |
| #Param other incomplete ## |
| |
| #Example |
| // incomplete |
| ## |
| |
| #ToDo incomplete ## |
| |
| ## |
| |
| # ------------------------------------------------------------------------------ |
| |
| #Enum ScaleToFit |
| |
| #Code |
| enum ScaleToFit { |
| kFill_ScaleToFit, |
| kStart_ScaleToFit, |
| kCenter_ScaleToFit, |
| kEnd_ScaleToFit, |
| }; |
| ## |
| |
| #Const kFill_ScaleToFit |
| Scale in X and Y independently, so that src matches dst exactly. |
| This may change the aspect ratio of the src. |
| ## |
| #Const kStart_ScaleToFit |
| Compute a scale that will maintain the original src aspect ratio, |
| but will also ensure that src fits entirely inside dst. At least one |
| axis (x or y) will fit exactly. Aligns the result to the |
| left and top edges of dst. |
| ## |
| #Const kCenter_ScaleToFit |
| Compute a scale that will maintain the original src aspect ratio, |
| but will also ensure that src fits entirely inside dst. At least one |
| axis (x or y) will fit exactly. The result is centered inside dst. |
| ## |
| #Const kEnd_ScaleToFit |
| Compute a scale that will maintain the original src aspect ratio, |
| but will also ensure that src fits entirely inside dst. At least one |
| axis (x or y) will fit exactly. Aligns the result to the |
| right and bottom edges of dst. |
| ## |
| |
| #Example |
| // incomplete |
| ## |
| |
| #ToDo incomplete ## |
| |
| ## |
| |
| # ------------------------------------------------------------------------------ |
| |
| #Method bool setRectToRect(const SkRect& src, const SkRect& dst, ScaleToFit stf) |
| |
| Set the matrix to the scale and translate values that map the source |
| rectangle to the destination rectangle, returning true if the the result |
| can be represented. |
| |
| #Param src the source rectangle to map from |
| ## |
| #Param dst the destination rectangle to map to |
| ## |
| #Param stf the ScaleToFit option |
| ## |
| |
| #Return true if the matrix can be represented by the rectangle mapping |
| ## |
| |
| #Example |
| // incomplete |
| ## |
| |
| #ToDo incomplete ## |
| |
| ## |
| |
| # ------------------------------------------------------------------------------ |
| |
| #Method static SkMatrix MakeRectToRect(const SkRect& src, const SkRect& dst, ScaleToFit stf) |
| |
| #Param src incomplete ## |
| #Param dst incomplete ## |
| #Param stf incomplete ## |
| |
| #Return incomplete ## |
| |
| #Example |
| // incomplete |
| ## |
| |
| #ToDo incomplete ## |
| |
| ## |
| |
| # ------------------------------------------------------------------------------ |
| |
| #Method bool setPolyToPoly(const SkPoint src[], const SkPoint dst[], int count) |
| |
| Set the matrix such that the specified src points would map to the |
| specified dst points. count must be within [0..4]. |
| |
| #Param src array of src points |
| ## |
| #Param dst array of dst points |
| ## |
| #Param count number of points to use for the transformation |
| ## |
| |
| #Return true if the matrix was set to the specified transformation |
| ## |
| |
| #Example |
| // incomplete |
| ## |
| |
| #ToDo incomplete ## |
| |
| ## |
| |
| # ------------------------------------------------------------------------------ |
| |
| #Method bool SK_WARN_UNUSED_RESULT invert(SkMatrix* inverse) const |
| |
| If this matrix can be inverted, return true and if inverse is not null, |
| set inverse to be the inverse of this matrix. If this matrix cannot be |
| inverted, ignore inverse and return false |
| |
| #Param inverse incomplete ## |
| |
| #Return incomplete ## |
| |
| #Example |
| // incomplete |
| ## |
| |
| #ToDo incomplete ## |
| |
| ## |
| |
| # ------------------------------------------------------------------------------ |
| |
| #Method static void SetAffineIdentity(SkScalar affine[6]) |
| |
| Fills the passed array with affine identity values |
| in column major order. |
| |
| #Param affine array to fill with affine identity values; must not be nullptr |
| ## |
| |
| #Return incomplete ## |
| |
| #Example |
| // incomplete |
| ## |
| |
| #ToDo incomplete ## |
| |
| ## |
| |
| # ------------------------------------------------------------------------------ |
| |
| #Method bool SK_WARN_UNUSED_RESULT asAffine(SkScalar affine[6]) const |
| |
| Fills the passed array with the affine values in column major order. |
| If the matrix is a perspective transform, returns false |
| and does not change the passed array. |
| |
| #Param affine array to fill with affine values; ignored if nullptr |
| ## |
| |
| #Return incomplete ## |
| |
| #Example |
| // incomplete |
| ## |
| |
| #ToDo incomplete ## |
| |
| ## |
| |
| # ------------------------------------------------------------------------------ |
| |
| #Method void setAffine(const SkScalar affine[6]) |
| |
| Set the matrix to the specified affine values. |
| Note: these are passed in column major order. |
| |
| #Param affine incomplete ## |
| |
| #Example |
| // incomplete |
| ## |
| |
| #ToDo incomplete ## |
| |
| ## |
| |
| # ------------------------------------------------------------------------------ |
| |
| #Method void mapPoints(SkPoint dst[], const SkPoint src[], int count) const |
| |
| Apply this matrix to the array of points specified by src, and write |
| the transformed points into the array of points specified by dst. |
| #Formula |
| dst[] = M * src[] |
| ## |
| |
| #Param dst storage for transformed coordinates; must |
| allow count entries |
| ## |
| #Param src original coordinates that are to be transformed; |
| must allow count entries |
| ## |
| #Param count number of points in src to read, and then transform |
| into dst |
| ## |
| |
| #Example |
| // incomplete |
| ## |
| |
| #ToDo incomplete ## |
| |
| ## |
| |
| # ------------------------------------------------------------------------------ |
| |
| #Method void mapPoints(SkPoint pts[], int count) const |
| |
| Apply this matrix to the array of points, overwriting it with the |
| transformed values. |
| #Formula |
| dst[] = M * pts[] |
| ## |
| |
| #Param pts storage for transformed points; must allow count entries |
| ## |
| #Param count number of points in pts |
| ## |
| |
| #Example |
| // incomplete |
| ## |
| |
| #ToDo incomplete ## |
| |
| ## |
| |
| # ------------------------------------------------------------------------------ |
| |
| #Method void mapPointsWithStride(SkPoint pts[], size_t stride, int count) const |
| |
| Like mapPoints but with custom byte stride between the points. Stride |
| should be a multiple of |
| #Formula |
| sizeof(SkScalar) |
| ## |
| . |
| |
| #Param pts incomplete ## |
| #Param stride incomplete ## |
| #Param count incomplete ## |
| |
| #Example |
| // incomplete |
| ## |
| |
| #ToDo incomplete ## |
| |
| ## |
| |
| # ------------------------------------------------------------------------------ |
| |
| #Method void mapPointsWithStride(SkPoint dst[], const SkPoint src[], size_t stride, int count) const |
| |
| Like mapPoints but with custom byte stride between the points. |
| |
| #Param dst incomplete ## |
| #Param src incomplete ## |
| #Param stride incomplete ## |
| #Param count incomplete ## |
| |
| #Example |
| // incomplete |
| ## |
| |
| #ToDo incomplete ## |
| |
| ## |
| |
| # ------------------------------------------------------------------------------ |
| |
| #Method void mapHomogeneousPoints(SkScalar dst[], const SkScalar src[], int count) const |
| |
| Apply this matrix to the array of homogeneous points, specified by src, |
| where a homogeneous point is defined by 3 contiguous scalar values, |
| and write the transformed points into the array of scalars specified by dst. |
| #Formula |
| dst[] = M * src[] |
| ## |
| |
| #Param dst storage for transformed coordinates; must |
| allow 3 * count entries |
| ## |
| #Param src original coordinates to be transformed; |
| must contain at least 3 * count entries |
| ## |
| #Param count number of triples (homogeneous points) in src to read, |
| and then transform into dst |
| ## |
| |
| #Example |
| // incomplete |
| ## |
| |
| #ToDo incomplete ## |
| |
| ## |
| |
| # ------------------------------------------------------------------------------ |
| |
| #Method void mapXY(SkScalar x, SkScalar y, SkPoint* result) const |
| |
| #Param x incomplete ## |
| #Param y incomplete ## |
| #Param result incomplete ## |
| |
| #Example |
| // incomplete |
| ## |
| |
| #ToDo incomplete ## |
| |
| ## |
| |
| # ------------------------------------------------------------------------------ |
| |
| #Method SkPoint mapXY(SkScalar x, SkScalar y) const |
| |
| #Param x incomplete ## |
| #Param y incomplete ## |
| |
| #Return incomplete ## |
| |
| #Example |
| // incomplete |
| ## |
| |
| #ToDo incomplete ## |
| |
| ## |
| |
| # ------------------------------------------------------------------------------ |
| |
| #Method void mapVectors(SkVector dst[], const SkVector src[], int count) const |
| |
| Apply this matrix to the array of vectors specified by src, and write |
| the transformed vectors into the array of vectors specified by dst. |
| This is similar to mapPoints, but ignores any translation in the matrix. |
| |
| #Param dst storage for transformed coordinates; must |
| allow count entries |
| ## |
| #Param src coordinates to be transformed; |
| must contain at least count entries |
| ## |
| #Param count number of vectors in src to read and transform |
| into dst |
| ## |
| |
| #Example |
| // incomplete |
| ## |
| |
| #ToDo incomplete ## |
| |
| ## |
| |
| # ------------------------------------------------------------------------------ |
| |
| #Method void mapVectors(SkVector vecs[], int count) const |
| |
| Apply this matrix to count vectors in array vecs. |
| This is similar to mapPoints, but ignores any translation in the matrix. |
| |
| #Param vecs vectors to transform; must contain at least |
| count entries |
| ## |
| #Param count number of vectors in vecs |
| ## |
| |
| #Example |
| // incomplete |
| ## |
| |
| #ToDo incomplete ## |
| |
| ## |
| |
| # ------------------------------------------------------------------------------ |
| |
| #Method void mapVector(SkScalar dx, SkScalar dy, SkVector* result) const |
| |
| #Param dx incomplete ## |
| #Param dy incomplete ## |
| #Param result incomplete ## |
| |
| #Example |
| // incomplete |
| ## |
| |
| #ToDo incomplete ## |
| |
| ## |
| |
| # ------------------------------------------------------------------------------ |
| |
| #Method SkVector mapVector(SkScalar dx, SkScalar dy) const |
| |
| #Param dx incomplete ## |
| #Param dy incomplete ## |
| |
| #Return incomplete ## |
| |
| #Example |
| // incomplete |
| ## |
| |
| #ToDo incomplete ## |
| |
| ## |
| |
| # ------------------------------------------------------------------------------ |
| |
| #Method bool mapRect(SkRect* dst, const SkRect& src) const |
| |
| Apply this matrix to the src rectangle, and write the transformed |
| rectangle into dst. This is accomplished by transforming the 4 corners |
| of src, and then setting dst to the bounds of those points. |
| |
| #Param dst storage for transformed rectangle ## |
| #Param src rectangle to transform ## |
| |
| #Return result of calling rectStaysRect |
| ## |
| |
| #Example |
| // incomplete |
| ## |
| |
| #ToDo incomplete ## |
| |
| ## |
| |
| # ------------------------------------------------------------------------------ |
| |
| #Method bool mapRect(SkRect* rect) const |
| |
| Apply this matrix to the rectangle, and write the transformed rectangle |
| back into it. This is accomplished by transforming the 4 corners of |
| rect, and then setting it to the bounds of those points |
| |
| #Param rect rectangle to transform |
| ## |
| |
| #Return the result of calling rectStaysRect |
| ## |
| |
| #Example |
| // incomplete |
| ## |
| |
| #ToDo incomplete ## |
| |
| ## |
| |
| # ------------------------------------------------------------------------------ |
| |
| #Method void mapRectToQuad(SkPoint dst[4], const SkRect& rect) const |
| |
| Applies Matrix to rect, and write the four transformed |
| points into dst. The points written to dst will be the original top-left, top-right, |
| bottom-right, and bottom-left points transformed by Matrix. |
| |
| #Param dst storage for transformed quad |
| ## |
| #Param rect rectangle to transform |
| ## |
| |
| #Example |
| // incomplete |
| ## |
| |
| #ToDo incomplete ## |
| |
| ## |
| |
| # ------------------------------------------------------------------------------ |
| |
| #Method void mapRectScaleTranslate(SkRect* dst, const SkRect& src) const |
| |
| Maps a rectangle to another rectangle, asserting (in debug mode) that the matrix only contains |
| scale and translate elements. If it contains other elements, the results are undefined. |
| |
| #Param dst incomplete ## |
| #Param src incomplete ## |
| |
| #Example |
| // incomplete |
| ## |
| |
| #ToDo incomplete ## |
| |
| ## |
| |
| # ------------------------------------------------------------------------------ |
| |
| #Method SkScalar mapRadius(SkScalar radius) const |
| |
| Return the mean radius of a circle after it has been mapped by |
| this matrix. NOTE: in perspective this value assumes the circle |
| has its center at the origin. |
| |
| #Param radius incomplete ## |
| |
| #Return incomplete ## |
| |
| #Example |
| // incomplete |
| ## |
| |
| #ToDo incomplete ## |
| |
| ## |
| |
| # ------------------------------------------------------------------------------ |
| |
| #Method static MapXYProc GetMapXYProc(TypeMask mask) |
| |
| #Param mask incomplete ## |
| |
| #Return incomplete ## |
| |
| #Example |
| // incomplete |
| ## |
| |
| #ToDo incomplete ## |
| |
| ## |
| |
| # ------------------------------------------------------------------------------ |
| |
| #Method MapXYProc getMapXYProc() const |
| |
| #Return incomplete ## |
| |
| #Example |
| // incomplete |
| ## |
| |
| #ToDo incomplete ## |
| |
| ## |
| |
| # ------------------------------------------------------------------------------ |
| |
| #Method static MapPtsProc GetMapPtsProc(TypeMask mask) |
| |
| #Param mask incomplete ## |
| |
| #Return incomplete ## |
| |
| #Example |
| // incomplete |
| ## |
| |
| #ToDo incomplete ## |
| |
| ## |
| |
| # ------------------------------------------------------------------------------ |
| |
| #Method MapPtsProc getMapPtsProc() const |
| |
| #Return incomplete ## |
| |
| #Example |
| // incomplete |
| ## |
| |
| #ToDo incomplete ## |
| |
| ## |
| |
| # ------------------------------------------------------------------------------ |
| |
| #Method bool isFixedStepInX() const |
| |
| Returns true if the matrix can be stepped in x (not complex |
| perspective). |
| |
| #Return incomplete ## |
| |
| #Example |
| // incomplete |
| ## |
| |
| #ToDo incomplete ## |
| |
| ## |
| |
| # ------------------------------------------------------------------------------ |
| |
| #Method SkVector fixedStepInX(SkScalar y) const |
| |
| If the matrix can be stepped in x (not complex perspective) |
| then return the step value. |
| If it cannot, behavior is undefined. |
| |
| #Param y incomplete ## |
| |
| #Return incomplete ## |
| |
| #Example |
| // incomplete |
| ## |
| |
| #ToDo incomplete ## |
| |
| ## |
| |
| # ------------------------------------------------------------------------------ |
| |
| #Method bool cheapEqualTo(const SkMatrix& m) const |
| |
| Returns true if Matrix equals m, using an efficient comparison. |
| |
| Return false when the sign of zero values is the different, that is, one |
| matrix has positive zero value and the other has negative zero value. |
| |
| Normally, comparing NaN prevents the value from equaling any other value, |
| including itself. To improve performance, NaN values are treated as bit patterns |
| that are equal if their bit patterns are equal. |
| |
| #Param m incomplete ## |
| |
| #Return incomplete ## |
| |
| #Example |
| // incomplete |
| ## |
| |
| #ToDo incomplete ## |
| |
| ## |
| |
| # ------------------------------------------------------------------------------ |
| |
| #Method friend SK_API bool operator==(const SkMatrix& a, const SkMatrix& b) |
| |
| mac chromium debug build requires SK_API to make operator== visible |
| |
| #Param a incomplete ## |
| #Param b incomplete ## |
| |
| #Return incomplete ## |
| |
| #Example |
| // incomplete |
| ## |
| |
| #ToDo incomplete ## |
| |
| ## |
| |
| # ------------------------------------------------------------------------------ |
| |
| #Method friend SK_API bool operator!=(const SkMatrix& a, const SkMatrix& b) |
| |
| #Param a incomplete ## |
| #Param b incomplete ## |
| |
| #Return incomplete ## |
| |
| #Example |
| // incomplete |
| ## |
| |
| #ToDo incomplete ## |
| |
| ## |
| |
| # ------------------------------------------------------------------------------ |
| |
| #Enum _anonymous_3 |
| |
| #Code |
| enum { |
| kMaxFlattenSize = 9 * sizeof(SkScalar) + sizeof(uint32_t), |
| }; |
| ## |
| |
| #Const kMaxFlattenSize = 9 * sizeof(SkScalar) + sizeof(uint32_t) |
| writeToMemory and readFromMemory will never return a value larger than this |
| ## |
| |
| #Example |
| // incomplete |
| ## |
| |
| #ToDo incomplete ## |
| |
| ## |
| |
| # ------------------------------------------------------------------------------ |
| |
| #Method size_t writeToMemory(void* buffer) const |
| |
| return the number of bytes written, whether or not buffer is null |
| |
| #Param buffer incomplete ## |
| |
| #Return incomplete ## |
| |
| #Example |
| // incomplete |
| ## |
| |
| #ToDo incomplete ## |
| |
| ## |
| |
| # ------------------------------------------------------------------------------ |
| |
| #Method size_t readFromMemory(const void* buffer, size_t length) |
| |
| Reads data from the buffer parameter |
| |
| #Param buffer memory to read from |
| ## |
| #Param length amount of memory available in the buffer |
| ## |
| |
| #Return number of bytes read (must be a multiple of 4) or |
| 0 if there was not enough memory available |
| ## |
| |
| #Example |
| // incomplete |
| ## |
| |
| #ToDo incomplete ## |
| |
| ## |
| |
| # ------------------------------------------------------------------------------ |
| |
| #Method void dump() const |
| |
| #Example |
| // incomplete |
| ## |
| |
| #ToDo incomplete ## |
| |
| ## |
| |
| # ------------------------------------------------------------------------------ |
| |
| #Method void toString(SkString* str) const |
| |
| #Param str incomplete ## |
| |
| #Example |
| // incomplete |
| ## |
| |
| #ToDo incomplete ## |
| |
| ## |
| |
| # ------------------------------------------------------------------------------ |
| |
| #Method SkScalar getMinScale() const |
| |
| Calculates the minimum scaling factor of the matrix as computed from the |
| singular value decomposition of the upper |
| left 2x2. If the max scale factor cannot be computed (for example overflow or perspective) |
| -1 is returned. |
| |
| #Return minimum scale factor |
| ## |
| |
| #Example |
| // incomplete |
| ## |
| |
| #ToDo incomplete ## |
| |
| ## |
| |
| # ------------------------------------------------------------------------------ |
| |
| #Method SkScalar getMaxScale() const |
| |
| Calculates the maximum scaling factor of the matrix as computed from the |
| singular value decomposition of the upper |
| left 2x2. If the max scale factor cannot be computed (for example overflow or perspective) |
| -1 is returned. |
| |
| #Return maximum scale factor |
| ## |
| |
| #Example |
| // incomplete |
| ## |
| |
| #ToDo incomplete ## |
| |
| ## |
| |
| # ------------------------------------------------------------------------------ |
| |
| #Method bool SK_WARN_UNUSED_RESULT getMinMaxScales(SkScalar scaleFactors[2]) const |
| |
| Gets both the min and max scale factors. The min scale factor is scaleFactors[0] and the max |
| is scaleFactors[1]. If the min/max scale factors cannot be computed false is returned and the |
| values of scaleFactors[] are undefined. |
| |
| #Param scaleFactors incomplete ## |
| |
| #Return incomplete ## |
| |
| #Example |
| // incomplete |
| ## |
| |
| #ToDo incomplete ## |
| |
| ## |
| |
| # ------------------------------------------------------------------------------ |
| |
| #Method bool decomposeScale(SkSize* scale, SkMatrix* remaining = nullptr) const |
| |
| Attempt to decompose this matrix into a scale-only component and whatever remains, where |
| the scale component is to be applied first. |
| #Formula |
| M -> Remaining * Scale |
| ## |
| On success, return true and assign the scale and remaining components (assuming their |
| respective parameters are not null). On failure return false and ignore the parameters. |
| Possible reasons to fail: perspective, one or more scale factors are zero. |
| |
| #Param scale incomplete ## |
| #Param remaining incomplete ## |
| |
| #Return incomplete ## |
| |
| #Example |
| // incomplete |
| ## |
| |
| #ToDo incomplete ## |
| |
| ## |
| |
| # ------------------------------------------------------------------------------ |
| |
| #Method static const SkMatrix& I() |
| |
| Return a reference to a const identity matrix |
| |
| #Return incomplete ## |
| |
| #Example |
| // incomplete |
| ## |
| |
| #ToDo incomplete ## |
| |
| ## |
| |
| # ------------------------------------------------------------------------------ |
| |
| #Method static const SkMatrix& InvalidMatrix() |
| |
| Return a reference to a const matrix that is "invalid", one that could |
| never be used. |
| |
| #Return incomplete ## |
| |
| #Example |
| // incomplete |
| ## |
| |
| #ToDo incomplete ## |
| |
| ## |
| |
| # ------------------------------------------------------------------------------ |
| |
| #Method static SkMatrix Concat(const SkMatrix& a, const SkMatrix& b) |
| |
| Return the concatenation of two matrices, a * b. |
| |
| #Param a incomplete ## |
| #Param b incomplete ## |
| |
| #Return incomplete ## |
| |
| #Example |
| // incomplete |
| ## |
| |
| #ToDo incomplete ## |
| |
| ## |
| |
| # ------------------------------------------------------------------------------ |
| |
| #Method void dirtyMatrixTypeCache() |
| |
| Testing routine; the matrix type cache should never need to be |
| manually invalidated during normal use. |
| |
| #Example |
| // incomplete |
| ## |
| |
| #ToDo incomplete ## |
| |
| ## |
| |
| # ------------------------------------------------------------------------------ |
| |
| #Method void setScaleTranslate(SkScalar sx, SkScalar sy, SkScalar tx, SkScalar ty) |
| |
| Initialize the matrix to be scale + post-translate. |
| |
| #Param sx incomplete ## |
| #Param sy incomplete ## |
| #Param tx incomplete ## |
| #Param ty incomplete ## |
| |
| #Example |
| // incomplete |
| ## |
| |
| #ToDo incomplete ## |
| |
| ## |
| |
| # ------------------------------------------------------------------------------ |
| |
| #Method bool isFinite() const |
| |
| Are all elements of the matrix finite? |
| |
| #Return incomplete ## |
| |
| #Example |
| // incomplete |
| ## |
| |
| #ToDo incomplete ## |
| |
| ## |
| |
| #Class SkMatrix ## |
| |
| #Topic Matrix ## |
