Category

Development Platform
Home > SourceCode/Document > Game Program > Other Riddle games > View Code
SkMatrix.cpp
Package: XSDYM.rar　[view]
Upload User: micun2005
Upload Date: 2020-11-27
Package Size: 11738k
Code Size: 54k
Category:

Other Riddle games

Development Platform:

Visual C++

SkMatrix.cpp：Code Content
  1. /* libs/corecg/SkMatrix.cpp
  2. **
  3. ** Copyright 2006, Google Inc.
  4. **
  5. ** Licensed under the Apache License, Version 2.0 (the "License"); 
  6. ** you may not use this file except in compliance with the License. 
  7. ** You may obtain a copy of the License at 
  8. **
  9. **     http://www.apache.org/licenses/LICENSE-2.0 
  10. **
  11. ** Unless required by applicable law or agreed to in writing, software 
  12. ** distributed under the License is distributed on an "AS IS" BASIS, 
  13. ** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 
  14. ** See the License for the specific language governing permissions and 
  15. ** limitations under the License.
  16. */
  18. #include "SkMatrix.h"
  19. #include "Sk64.h"
  20. #include "SkFloatBits.h"
  22. #ifdef SK_SCALAR_IS_FLOAT
  23.     #define kMatrix22Elem   SK_Scalar1
  24. #else
  25.     #define kMatrix22Elem   SK_Fract1
  26. #endif
  28. /*      [scale-x    skew-x      trans-x]   [X]   [X']
  29.         [skew-y     scale-y     trans-y] * [Y] = [Y']
  30.         [persp-0    persp-1     persp-2]   [1]   [1 ]
  31. */
  33. void SkMatrix::reset() {
  34.     fMat[kMScaleX] = fMat[kMScaleY] = SK_Scalar1;
  35.     fMat[kMSkewX]  = fMat[kMSkewY] = 
  36.     fMat[kMTransX] = fMat[kMTransY] =
  37.     fMat[kMPersp0] = fMat[kMPersp1] = 0;
  38.     fMat[kMPersp2] = kMatrix22Elem;
  40.     this->setTypeMask(kIdentity_Mask | kRectStaysRect_Mask);
  41. }
  43. static inline int has_perspective(const SkMatrix& matrix) {
  44.     return matrix.getType() & SkMatrix::kPerspective_Mask;
  45. }
  47. // this guy aligns with the masks, so we can compute a mask from a varaible 0/1
  48. enum {
  49.     kTranslate_Shift,
  50.     kScale_Shift,
  51.     kAffine_Shift,
  52.     kPerspective_Shift,
  53.     kRectStaysRect_Shift
  54. };
  56. #ifdef SK_SCALAR_IS_FLOAT
  57.     static const int32_t kScalar1Int = 0x3f800000;
  58.     static const int32_t kPersp1Int  = 0x3f800000;
  59. #else
  60.     #define scalarAsInt(x)  (x)
  61.     static const int32_t kScalar1Int = (1 << 16);
  62.     static const int32_t kPersp1Int  = (1 << 30);
  63. #endif
  65. uint8_t SkMatrix::computeTypeMask() const {
  66.     unsigned mask = 0;
  68.     if (SkScalarAsInt(fMat[kMPersp0]) | SkScalarAsInt(fMat[kMPersp1]) |
  69.             (SkScalarAsInt(fMat[kMPersp2]) - kPersp1Int)) {
  70.         mask |= kPerspective_Mask;
  71.     }
  72.     
  73.     if (SkScalarAsInt(fMat[kMTransX]) | SkScalarAsInt(fMat[kMTransY])) {
  74.         mask |= kTranslate_Mask;
  75.     }
  77.     int m00 = SkScalarAsInt(fMat[SkMatrix::kMScaleX]);
  78.     int m01 = SkScalarAsInt(fMat[SkMatrix::kMSkewX]);
  79.     int m10 = SkScalarAsInt(fMat[SkMatrix::kMSkewY]);
  80.     int m11 = SkScalarAsInt(fMat[SkMatrix::kMScaleY]);
  81.     
  82.     if (m01 | m10) {
  83.         mask |= kAffine_Mask;
  84.     }
  86.     if ((m00 - kScalar1Int) | (m11 - kScalar1Int)) {
  87.         mask |= kScale_Mask;
  88.     }
  89.     
  90.     if ((mask & kPerspective_Mask) == 0) {
  91.         // map non-zero to 1
  92.         m00 = m00 != 0;
  93.         m01 = m01 != 0;
  94.         m10 = m10 != 0;
  95.         m11 = m11 != 0;
  96.         
  97.         // record if the (p)rimary and (s)econdary diagonals are all 0 or
  98.         // all non-zero (answer is 0 or 1)
  99.         int dp0 = (m00 | m11) ^ 1;  // true if both are 0
  100.         int dp1 = m00 & m11;        // true if both are 1
  101.         int ds0 = (m01 | m10) ^ 1;  // true if both are 0
  102.         int ds1 = m01 & m10;        // true if both are 1
  103.         
  104.         // return 1 if primary is 1 and secondary is 0 or
  105.         // primary is 0 and secondary is 1
  106.         mask |= ((dp0 & ds1) | (dp1 & ds0)) << kRectStaysRect_Shift;
  107.     }
  109.     return SkToU8(mask);
  110. }
  112. ///////////////////////////////////////////////////////////////////////////////
  114. void SkMatrix::setTranslate(SkScalar dx, SkScalar dy) {
  115.     if (SkScalarAsInt(dx) | SkScalarAsInt(dy)) {
  116.         fMat[kMTransX] = dx;
  117.         fMat[kMTransY] = dy;
  119.         fMat[kMScaleX] = fMat[kMScaleY] = SK_Scalar1;
  120.         fMat[kMSkewX]  = fMat[kMSkewY] = 
  121.         fMat[kMPersp0] = fMat[kMPersp1] = 0;
  122.         fMat[kMPersp2] = kMatrix22Elem;
  124.         this->setTypeMask(kTranslate_Mask | kRectStaysRect_Mask);
  125.     } else {
  126.         this->reset();
  127.     }
  128. }
  130. bool SkMatrix::preTranslate(SkScalar dx, SkScalar dy) {
  131.     if (has_perspective(*this)) {
  132.         SkMatrix    m;
  133.         m.setTranslate(dx, dy);
  134.         return this->preConcat(m);
  135.     }
  136.     
  137.     if (SkScalarAsInt(dx) | SkScalarAsInt(dy)) {
  138.         fMat[kMTransX] += SkScalarMul(fMat[kMScaleX], dx) +
  139.                           SkScalarMul(fMat[kMSkewX], dy);
  140.         fMat[kMTransY] += SkScalarMul(fMat[kMSkewY], dx) +
  141.                           SkScalarMul(fMat[kMScaleY], dy);
  143.         this->setTypeMask(kUnknown_Mask);
  144.     }
  145.     return true;
  146. }
  148. bool SkMatrix::postTranslate(SkScalar dx, SkScalar dy) {
  149.     if (has_perspective(*this)) {
  150.         SkMatrix    m;
  151.         m.setTranslate(dx, dy);
  152.         return this->postConcat(m);
  153.     }
  154.     
  155.     if (SkScalarAsInt(dx) | SkScalarAsInt(dy)) {
  156.         fMat[kMTransX] += dx;
  157.         fMat[kMTransY] += dy;
  158.         this->setTypeMask(kUnknown_Mask);
  159.     }
  160.     return true;
  161. }
  163. ///////////////////////////////////////////////////////////////////////////////
  165. void SkMatrix::setScale(SkScalar sx, SkScalar sy, SkScalar px, SkScalar py) {
  166.     fMat[kMScaleX] = sx;
  167.     fMat[kMScaleY] = sy;
  168.     fMat[kMTransX] = px - SkScalarMul(sx, px);
  169.     fMat[kMTransY] = py - SkScalarMul(sy, py);
  170.     fMat[kMPersp2] = kMatrix22Elem;
  172.     fMat[kMSkewX]  = fMat[kMSkewY] = 
  173.     fMat[kMPersp0] = fMat[kMPersp1] = 0;
  174.     
  175.     this->setTypeMask(kScale_Mask | kTranslate_Mask | kRectStaysRect_Mask);
  176. }
  178. void SkMatrix::setScale(SkScalar sx, SkScalar sy) {
  179.     fMat[kMScaleX] = sx;
  180.     fMat[kMScaleY] = sy;
  181.     fMat[kMPersp2] = kMatrix22Elem;
  183.     fMat[kMTransX] = fMat[kMTransY] =
  184.     fMat[kMSkewX]  = fMat[kMSkewY] = 
  185.     fMat[kMPersp0] = fMat[kMPersp1] = 0;
  187.     this->setTypeMask(kScale_Mask | kRectStaysRect_Mask);
  188. }
  190. bool SkMatrix::preScale(SkScalar sx, SkScalar sy, SkScalar px, SkScalar py) {
  191.     SkMatrix    m;
  192.     m.setScale(sx, sy, px, py);
  193.     return this->preConcat(m);
  194. }
  196. bool SkMatrix::preScale(SkScalar sx, SkScalar sy) {
  197.     SkMatrix    m;
  198.     m.setScale(sx, sy);
  199.     return this->preConcat(m);
  200. }
  202. bool SkMatrix::postScale(SkScalar sx, SkScalar sy, SkScalar px, SkScalar py) {
  203.     SkMatrix    m;
  204.     m.setScale(sx, sy, px, py);
  205.     return this->postConcat(m);
  206. }
  208. bool SkMatrix::postScale(SkScalar sx, SkScalar sy) {
  209.     SkMatrix    m;
  210.     m.setScale(sx, sy);
  211.     return this->postConcat(m);
  212. }
  214. #ifdef SK_SCALAR_IS_FIXED
  215.     static inline SkFixed roundidiv(SkFixed numer, int denom) {
  216.         int ns = numer >> 31;
  217.         int ds = denom >> 31;
  218.         numer = (numer ^ ns) - ns;
  219.         denom = (denom ^ ds) - ds;
  220.         
  221.         SkFixed answer = (numer + (denom >> 1)) / denom;
  222.         int as = ns ^ ds;
  223.         return (answer ^ as) - as;
  224.     }
  225. #endif
  227. // this guy perhaps can go away, if we have a fract/high-precision way to
  228. // scale matrices
  229. bool SkMatrix::postIDiv(int divx, int divy) {
  230.     if (divx == 0 || divy == 0) {
  231.         return false;
  232.     }
  234. #ifdef SK_SCALAR_IS_FIXED
  235.     fMat[kMScaleX] = roundidiv(fMat[kMScaleX], divx);
  236.     fMat[kMSkewX]  = roundidiv(fMat[kMSkewX],  divx);
  237.     fMat[kMTransX] = roundidiv(fMat[kMTransX], divx);
  239.     fMat[kMScaleY] = roundidiv(fMat[kMScaleY], divy);
  240.     fMat[kMSkewY]  = roundidiv(fMat[kMSkewY],  divy);
  241.     fMat[kMTransY] = roundidiv(fMat[kMTransY], divy);
  242. #else
  243.     const float invX = 1.f / divx;
  244.     const float invY = 1.f / divy;
  246.     fMat[kMScaleX] *= invX;
  247.     fMat[kMSkewX]  *= invX;
  248.     fMat[kMTransX] *= invX;
  249.     
  250.     fMat[kMScaleY] *= invY;
  251.     fMat[kMSkewY]  *= invY;
  252.     fMat[kMTransY] *= invY;
  253. #endif
  255.     this->setTypeMask(kUnknown_Mask);
  256.     return true;
  257. }
  259. ////////////////////////////////////////////////////////////////////////////////////
  261. void SkMatrix::setSinCos(SkScalar sinV, SkScalar cosV,
  262.                          SkScalar px, SkScalar py) {
  263.     const SkScalar oneMinusCosV = SK_Scalar1 - cosV;
  265.     fMat[kMScaleX]  = cosV;
  266.     fMat[kMSkewX]   = -sinV;
  267.     fMat[kMTransX]  = SkScalarMul(sinV, py) + SkScalarMul(oneMinusCosV, px);
  269.     fMat[kMSkewY]   = sinV;
  270.     fMat[kMScaleY]  = cosV;
  271.     fMat[kMTransY]  = SkScalarMul(-sinV, px) + SkScalarMul(oneMinusCosV, py);
  273.     fMat[kMPersp0] = fMat[kMPersp1] = 0;
  274.     fMat[kMPersp2] = kMatrix22Elem;
  275.     
  276.     this->setTypeMask(kUnknown_Mask);
  277. }
  279. void SkMatrix::setSinCos(SkScalar sinV, SkScalar cosV) {
  280.     fMat[kMScaleX]  = cosV;
  281.     fMat[kMSkewX]   = -sinV;
  282.     fMat[kMTransX]  = 0;
  284.     fMat[kMSkewY]   = sinV;
  285.     fMat[kMScaleY]  = cosV;
  286.     fMat[kMTransY]  = 0;
  288.     fMat[kMPersp0] = fMat[kMPersp1] = 0;
  289.     fMat[kMPersp2] = kMatrix22Elem;
  291.     this->setTypeMask(kUnknown_Mask);
  292. }
  294. void SkMatrix::setRotate(SkScalar degrees, SkScalar px, SkScalar py) {
  295.     SkScalar sinV, cosV;
  296.     sinV = SkScalarSinCos(SkDegreesToRadians(degrees), &cosV);
  297.     this->setSinCos(sinV, cosV, px, py);
  298. }
  300. void SkMatrix::setRotate(SkScalar degrees) {
  301.     SkScalar sinV, cosV;
  302.     sinV = SkScalarSinCos(SkDegreesToRadians(degrees), &cosV);
  303.     this->setSinCos(sinV, cosV);
  304. }
  306. bool SkMatrix::preRotate(SkScalar degrees, SkScalar px, SkScalar py) {
  307.     SkMatrix    m;
  308.     m.setRotate(degrees, px, py);
  309.     return this->preConcat(m);
  310. }
  312. bool SkMatrix::preRotate(SkScalar degrees) {
  313.     SkMatrix    m;
  314.     m.setRotate(degrees);
  315.     return this->preConcat(m);
  316. }
  318. bool SkMatrix::postRotate(SkScalar degrees, SkScalar px, SkScalar py) {
  319.     SkMatrix    m;
  320.     m.setRotate(degrees, px, py);
  321.     return this->postConcat(m);
  322. }
  324. bool SkMatrix::postRotate(SkScalar degrees) {
  325.     SkMatrix    m;
  326.     m.setRotate(degrees);
  327.     return this->postConcat(m);
  328. }
  330. ////////////////////////////////////////////////////////////////////////////////////
  332. void SkMatrix::setSkew(SkScalar sx, SkScalar sy, SkScalar px, SkScalar py) {
  333.     fMat[kMScaleX]  = SK_Scalar1;
  334.     fMat[kMSkewX]   = sx;
  335.     fMat[kMTransX]  = SkScalarMul(-sx, py);
  337.     fMat[kMSkewY]   = sy;
  338.     fMat[kMScaleY]  = SK_Scalar1;
  339.     fMat[kMTransY]  = SkScalarMul(-sy, px);
  341.     fMat[kMPersp0] = fMat[kMPersp1] = 0;
  342.     fMat[kMPersp2] = kMatrix22Elem;
  344.     this->setTypeMask(kUnknown_Mask);
  345. }
  347. void SkMatrix::setSkew(SkScalar sx, SkScalar sy) {
  348.     fMat[kMScaleX]  = SK_Scalar1;
  349.     fMat[kMSkewX]   = sx;
  350.     fMat[kMTransX]  = 0;
  352.     fMat[kMSkewY]   = sy;
  353.     fMat[kMScaleY]  = SK_Scalar1;
  354.     fMat[kMTransY]  = 0;
  356.     fMat[kMPersp0] = fMat[kMPersp1] = 0;
  357.     fMat[kMPersp2] = kMatrix22Elem;
  359.     this->setTypeMask(kUnknown_Mask);
  360. }
  362. bool SkMatrix::preSkew(SkScalar sx, SkScalar sy, SkScalar px, SkScalar py) {
  363.     SkMatrix    m;
  364.     m.setSkew(sx, sy, px, py);
  365.     return this->preConcat(m);
  366. }
  368. bool SkMatrix::preSkew(SkScalar sx, SkScalar sy) {
  369.     SkMatrix    m;
  370.     m.setSkew(sx, sy);
  371.     return this->preConcat(m);
  372. }
  374. bool SkMatrix::postSkew(SkScalar sx, SkScalar sy, SkScalar px, SkScalar py) {
  375.     SkMatrix    m;
  376.     m.setSkew(sx, sy, px, py);
  377.     return this->postConcat(m);
  378. }
  380. bool SkMatrix::postSkew(SkScalar sx, SkScalar sy) {
  381.     SkMatrix    m;
  382.     m.setSkew(sx, sy);
  383.     return this->postConcat(m);
  384. }
  386. ///////////////////////////////////////////////////////////////////////////////
  388. bool SkMatrix::setRectToRect(const SkRect& src, const SkRect& dst,
  389.                              ScaleToFit align)
  390. {
  391.     if (src.isEmpty()) {
  392.         this->reset();
  393.         return false;
  394.     }
  396.     if (dst.isEmpty()) {
  397.         bzero(fMat, 8 * sizeof(SkScalar));
  398.         this->setTypeMask(kScale_Mask | kRectStaysRect_Mask);
  399.     } else {
  400.         SkScalar    tx, sx = SkScalarDiv(dst.width(), src.width());
  401.         SkScalar    ty, sy = SkScalarDiv(dst.height(), src.height());
  402.         bool        xLarger = false;
  404.         if (align != kFill_ScaleToFit) {
  405.             if (sx > sy) {
  406.                 xLarger = true;
  407.                 sx = sy;
  408.             } else {
  409.                 sy = sx;
  410.             }
  411.         }
  413.         tx = dst.fLeft - SkScalarMul(src.fLeft, sx);
  414.         ty = dst.fTop - SkScalarMul(src.fTop, sy);
  415.         if (align == kCenter_ScaleToFit || align == kEnd_ScaleToFit) {
  416.             SkScalar diff;
  418.             if (xLarger) {
  419.                 diff = dst.width() - SkScalarMul(src.width(), sy);
  420.             } else {
  421.                 diff = dst.height() - SkScalarMul(src.height(), sy);
  422.             }
  423.             
  424.             if (align == kCenter_ScaleToFit) {
  425.                 diff = SkScalarHalf(diff);
  426.             }
  428.             if (xLarger) {
  429.                 tx += diff;
  430.             } else {
  431.                 ty += diff;
  432.             }
  433.         }
  435.         fMat[kMScaleX] = sx;
  436.         fMat[kMScaleY] = sy;
  437.         fMat[kMTransX] = tx;
  438.         fMat[kMTransY] = ty;
  439.         fMat[kMSkewX]  = fMat[kMSkewY] = 
  440.         fMat[kMPersp0] = fMat[kMPersp1] = 0;
  442.         this->setTypeMask(kScale_Mask | kTranslate_Mask | kRectStaysRect_Mask);
  443.     }
  444.     // shared cleanup
  445.     fMat[kMPersp2] = kMatrix22Elem;
  446.     return true;
  447. }
  449. ///////////////////////////////////////////////////////////////////////////////
  451. #ifdef SK_SCALAR_IS_FLOAT
  452.     static inline int fixmuladdmul(float a, float b, float c, float d,
  453.                                    float* result) {
  454.         *result = a * b + c * d;
  455.         return true;
  456.     }
  458.     static inline int fixmuladdmulshiftmul(float a, float b, float c, float d,
  459.                            int /*shift not used*/, float scale, float* result) {
  460.         *result = (a * b + c * d) * scale;
  461.         return true;
  462.     }
  464.     static inline bool rowcol3(const float row[], const float col[],
  465.                                float* result) {
  466.         *result = row[0] * col[0] + row[1] * col[3] + row[2] * col[6];
  467.         return true;
  468.     }
  470.     static inline int negifaddoverflows(float& result, float a, float b) {
  471.         result = a + b;
  472.         return 0;
  473.     }
  474. #else
  475.     static inline bool fixmuladdmul(SkFixed a, SkFixed b, SkFixed c, SkFixed d,
  476.                                     SkFixed* result) {
  477.         Sk64    tmp1, tmp2;
  478.         tmp1.setMul(a, b);
  479.         tmp2.setMul(c, d);
  480.         tmp1.add(tmp2);
  481.         if (tmp1.isFixed()) {
  482.             *result = tmp1.getFixed();
  483.             return true;
  484.         }
  485.         return false;
  486.     }
  488.     static inline bool fixmuladdmulshiftmul(SkFixed a, SkFixed b, SkFixed c,
  489.                         SkFixed d, int shift, SkFixed scale, SkFixed* result) {
  490.         Sk64    tmp1, tmp2;
  491.         tmp1.setMul(a, b);
  492.         tmp2.setMul(c, d);
  493.         tmp1.add(tmp2);
  495.         int32_t hi = SkAbs32(tmp1.fHi);
  496.         int afterShift = 16;
  497.         if (hi >> 15) {
  498.             int clz = 17 - SkCLZ(hi);
  499.             SkASSERT(clz > 0 && clz <= 16);
  500.             afterShift -= clz;
  501.             shift += clz;
  502.         }
  504.         tmp1.roundRight(shift + 16);
  505.         SkASSERT(tmp1.is32());
  507.         tmp1.setMul(tmp1.get32(), scale);
  508.         tmp1.roundRight(afterShift);
  509.         if (tmp1.is32()) {
  510.             *result = tmp1.get32();
  511.             return true;
  512.         }
  513.         return false;
  514.     }
  516.     static inline SkFixed fracmuladdmul(SkFixed a, SkFract b, SkFixed c,
  517.                                         SkFract d) {
  518.         Sk64 tmp1, tmp2;
  519.         tmp1.setMul(a, b);
  520.         tmp2.setMul(c, d);
  521.         tmp1.add(tmp2);
  522.         return tmp1.getFract();
  523.     }
  525.     static inline bool rowcol3(const SkFixed row[], const SkFixed col[],
  526.                                SkFixed* result) {
  527.         Sk64 tmp1, tmp2;
  529.         tmp1.setMul(row[0], col[0]);    // N * fixed
  530.         tmp2.setMul(row[1], col[3]);    // N * fixed
  531.         tmp1.add(tmp2);
  533.         tmp2.setMul(row[2], col[6]);    // N * fract
  534.         tmp2.roundRight(14);            // make it fixed
  535.         tmp1.add(tmp2);
  537.         if (tmp1.isFixed()) {
  538.             *result = tmp1.getFixed();
  539.             return true;
  540.         }
  541.         return false;
  542.     }
  544.     static inline int negifaddoverflows(SkFixed& result, SkFixed a, SkFixed b) {
  545.         SkFixed c = a + b;
  546.         result = c;
  547.         return (c ^ a) & (c ^ b);
  548.     }
  549. #endif
  551. static void normalize_perspective(SkScalar mat[9]) {
  552.     if (SkScalarAbs(mat[SkMatrix::kMPersp2]) > kMatrix22Elem) {
  553.         for (int i = 0; i < 9; i++)
  554.             mat[i] = SkScalarHalf(mat[i]);
  555.     }
  556. }
  558. bool SkMatrix::setConcat(const SkMatrix& a, const SkMatrix& b) {
  559.     TypeMask aType = a.getType();
  560.     TypeMask bType = b.getType();
  562.     if (0 == aType) {
  563.         *this = b;
  564.     } else if (0 == bType) {
  565.         *this = a;
  566.     } else {
  567.         SkMatrix tmp;
  569.         if ((aType | bType) & kPerspective_Mask) {
  570.             if (!rowcol3(&a.fMat[0], &b.fMat[0], &tmp.fMat[kMScaleX])) {
  571.                 return false;
  572.             }
  573.             if (!rowcol3(&a.fMat[0], &b.fMat[1], &tmp.fMat[kMSkewX])) {
  574.                 return false;
  575.             }
  576.             if (!rowcol3(&a.fMat[0], &b.fMat[2], &tmp.fMat[kMTransX])) {
  577.                 return false;
  578.             }
  580.             if (!rowcol3(&a.fMat[3], &b.fMat[0], &tmp.fMat[kMSkewY])) {
  581.                 return false;
  582.             }
  583.             if (!rowcol3(&a.fMat[3], &b.fMat[1], &tmp.fMat[kMScaleY])) {
  584.                 return false;
  585.             }
  586.             if (!rowcol3(&a.fMat[3], &b.fMat[2], &tmp.fMat[kMTransY])) {
  587.                 return false;
  588.             }
  590.             if (!rowcol3(&a.fMat[6], &b.fMat[0], &tmp.fMat[kMPersp0])) {
  591.                 return false;
  592.             }
  593.             if (!rowcol3(&a.fMat[6], &b.fMat[1], &tmp.fMat[kMPersp1])) {
  594.                 return false;
  595.             }
  596.             if (!rowcol3(&a.fMat[6], &b.fMat[2], &tmp.fMat[kMPersp2])) {
  597.                 return false;
  598.             }
  600.             normalize_perspective(tmp.fMat);
  601.         } else {    // not perspective
  602.             if (!fixmuladdmul(a.fMat[kMScaleX], b.fMat[kMScaleX],
  603.                     a.fMat[kMSkewX], b.fMat[kMSkewY], &tmp.fMat[kMScaleX])) {
  604.                 return false;
  605.             }
  606.             if (!fixmuladdmul(a.fMat[kMScaleX], b.fMat[kMSkewX],
  607.                       a.fMat[kMSkewX], b.fMat[kMScaleY], &tmp.fMat[kMSkewX])) {
  608.                 return false;
  609.             }
  610.             if (!fixmuladdmul(a.fMat[kMScaleX], b.fMat[kMTransX],
  611.                       a.fMat[kMSkewX], b.fMat[kMTransY], &tmp.fMat[kMTransX])) {
  612.                 return false;
  613.             }
  614.             if (negifaddoverflows(tmp.fMat[kMTransX], tmp.fMat[kMTransX],
  615.                                   a.fMat[kMTransX]) < 0) {
  616.                 return false;
  617.             }
  619.             if (!fixmuladdmul(a.fMat[kMSkewY], b.fMat[kMScaleX],
  620.                       a.fMat[kMScaleY], b.fMat[kMSkewY], &tmp.fMat[kMSkewY])) {
  621.                 return false;
  622.             }
  623.             if (!fixmuladdmul(a.fMat[kMSkewY], b.fMat[kMSkewX],
  624.                     a.fMat[kMScaleY], b.fMat[kMScaleY], &tmp.fMat[kMScaleY])) {
  625.                 return false;
  626.             }
  627.             if (!fixmuladdmul(a.fMat[kMSkewY], b.fMat[kMTransX],
  628.                      a.fMat[kMScaleY], b.fMat[kMTransY], &tmp.fMat[kMTransY])) {
  629.                 return false;
  630.             }
  631.             if (negifaddoverflows(tmp.fMat[kMTransY], tmp.fMat[kMTransY],
  632.                                   a.fMat[kMTransY]) < 0) {
  633.                 return false;
  634.             }
  636.             tmp.fMat[kMPersp0] = tmp.fMat[kMPersp1] = 0;
  637.             tmp.fMat[kMPersp2] = kMatrix22Elem;
  638.         }
  639.         *this = tmp;
  640.     }
  641.     this->setTypeMask(kUnknown_Mask);
  642.     return true;
  643. }
  645. bool SkMatrix::preConcat(const SkMatrix& mat) {
  646.     return this->setConcat(*this, mat);
  647. }
  649. bool SkMatrix::postConcat(const SkMatrix& mat) {
  650.     return this->setConcat(mat, *this);
  651. }
  653. ///////////////////////////////////////////////////////////////////////////////
  655. #ifdef SK_SCALAR_IS_FLOAT
  656.     #define SkPerspMul(a, b)            SkScalarMul(a, b)
  657.     #define SkScalarMulShift(a, b, s)   SkScalarMul(a, b)
  658.     static float sk_inv_determinant(const float mat[9], int isPerspective,
  659.                                     int* /* (only used in Fixed case) */) {
  660.         double det;
  662.         if (isPerspective) {
  663.             det =   mat[SkMatrix::kMScaleX] * ((double)mat[SkMatrix::kMScaleY] * mat[SkMatrix::kMPersp2] - (double)mat[SkMatrix::kMTransY] * mat[SkMatrix::kMPersp1]) +
  664.                     mat[SkMatrix::kMSkewX] * ((double)mat[SkMatrix::kMTransY] * mat[SkMatrix::kMPersp0] - (double)mat[SkMatrix::kMSkewY] * mat[SkMatrix::kMPersp2]) +
  665.                     mat[SkMatrix::kMTransX] * ((double)mat[SkMatrix::kMSkewY] * mat[SkMatrix::kMPersp1] - (double)mat[SkMatrix::kMScaleY] * mat[SkMatrix::kMPersp0]);
  666.         } else {
  667.             det =   (double)mat[SkMatrix::kMScaleX] * mat[SkMatrix::kMScaleY] - (double)mat[SkMatrix::kMSkewX] * mat[SkMatrix::kMSkewY];
  668.         }
  670.         // Since the determinant is on the order of the square of the matrix members,
  671.         // compare to the square of the default nearly-zero constant
  672.         if (SkScalarNearlyZero((float)det, SK_ScalarNearlyZero * SK_ScalarNearlyZero)) {
  673.             return 0;
  674.         }
  676.         return (float)(1.0 / det);
  677.     }
  678. #else
  679.     #define SkPerspMul(a, b)            SkFractMul(a, b)
  680.     #define SkScalarMulShift(a, b, s)   SkMulShift(a, b, s)
  681.     static void set_muladdmul(Sk64* dst, int32_t a, int32_t b, int32_t c,
  682.                               int32_t d) {
  683.         Sk64 tmp;
  684.         dst->setMul(a, b);
  685.         tmp.setMul(c, d);
  686.         dst->add(tmp);
  687.     }
  689.     static SkFixed sk_inv_determinant(const SkFixed mat[9], int isPerspective,
  690.                                       int* shift) {
  691.         Sk64    tmp1, tmp2;
  693.         if (isPerspective) {
  694.             tmp1.setMul(mat[SkMatrix::kMScaleX], fracmuladdmul(mat[SkMatrix::kMScaleY], mat[SkMatrix::kMPersp2], -mat[SkMatrix::kMTransY], mat[SkMatrix::kMPersp1]));
  695.             tmp2.setMul(mat[SkMatrix::kMSkewX], fracmuladdmul(mat[SkMatrix::kMTransY], mat[SkMatrix::kMPersp0], -mat[SkMatrix::kMSkewY], mat[SkMatrix::kMPersp2]));
  696.             tmp1.add(tmp2);
  697.             tmp2.setMul(mat[SkMatrix::kMTransX], fracmuladdmul(mat[SkMatrix::kMSkewY], mat[SkMatrix::kMPersp1], -mat[SkMatrix::kMScaleY], mat[SkMatrix::kMPersp0]));
  698.             tmp1.add(tmp2);
  699.         } else {
  700.             tmp1.setMul(mat[SkMatrix::kMScaleX], mat[SkMatrix::kMScaleY]);
  701.             tmp2.setMul(mat[SkMatrix::kMSkewX], mat[SkMatrix::kMSkewY]);
  702.             tmp1.sub(tmp2);
  703.         }
  705.         int s = tmp1.getClzAbs();
  706.         *shift = s;
  708.         SkFixed denom;
  709.         if (s <= 32) {
  710.             denom = tmp1.getShiftRight(33 - s);
  711.         } else {
  712.             denom = (int32_t)tmp1.fLo << (s - 33);
  713.         }
  715.         if (denom == 0) {
  716.             return 0;
  717.         }
  718.         /** This could perhaps be a special fractdiv function, since both of its
  719.             arguments are known to have bit 31 clear and bit 30 set (when they
  720.             are made positive), thus eliminating the need for calling clz()
  721.         */
  722.         return SkFractDiv(SK_Fract1, denom);
  723.     }
  724. #endif
  726. bool SkMatrix::invert(SkMatrix* inv) const {
  727.     int         isPersp = has_perspective(*this);
  728.     int         shift;
  729.     SkScalar    scale = sk_inv_determinant(fMat, isPersp, &shift);
  731.     if (scale == 0) { // underflow
  732.         return false;
  733.     }
  735.     if (inv) {
  736.         SkMatrix tmp;
  737.         if (inv == this)
  738.             inv = &tmp;
  740.         if (isPersp) {
  741.             shift = 61 - shift;
  742.             inv->fMat[kMScaleX] = SkScalarMulShift(SkPerspMul(fMat[kMScaleY], fMat[kMPersp2]) - SkPerspMul(fMat[kMTransY], fMat[kMPersp1]), scale, shift);
  743.             inv->fMat[kMSkewX]  = SkScalarMulShift(SkPerspMul(fMat[kMTransX], fMat[kMPersp1]) - SkPerspMul(fMat[kMSkewX],  fMat[kMPersp2]), scale, shift);
  744.             inv->fMat[kMTransX] = SkScalarMulShift(SkScalarMul(fMat[kMSkewX], fMat[kMTransY]) - SkScalarMul(fMat[kMTransX], fMat[kMScaleY]), scale, shift);
  746.             inv->fMat[kMSkewY]  = SkScalarMulShift(SkPerspMul(fMat[kMTransY], fMat[kMPersp0]) - SkPerspMul(fMat[kMSkewY],   fMat[kMPersp2]), scale, shift);
  747.             inv->fMat[kMScaleY] = SkScalarMulShift(SkPerspMul(fMat[kMScaleX], fMat[kMPersp2]) - SkPerspMul(fMat[kMTransX],  fMat[kMPersp0]), scale, shift);
  748.             inv->fMat[kMTransY] = SkScalarMulShift(SkScalarMul(fMat[kMTransX], fMat[kMSkewY]) - SkScalarMul(fMat[kMScaleX], fMat[kMTransY]), scale, shift);
  750.             inv->fMat[kMPersp0] = SkScalarMulShift(SkScalarMul(fMat[kMSkewY], fMat[kMPersp1]) - SkScalarMul(fMat[kMScaleY], fMat[kMPersp0]), scale, shift);             
  751.             inv->fMat[kMPersp1] = SkScalarMulShift(SkScalarMul(fMat[kMSkewX], fMat[kMPersp0]) - SkScalarMul(fMat[kMScaleX], fMat[kMPersp1]), scale, shift);
  752.             inv->fMat[kMPersp2] = SkScalarMulShift(SkScalarMul(fMat[kMScaleX], fMat[kMScaleY]) - SkScalarMul(fMat[kMSkewX], fMat[kMSkewY]), scale, shift);
  753. #ifdef SK_SCALAR_IS_FIXED
  754.             if (SkAbs32(inv->fMat[kMPersp2]) > SK_Fixed1) {
  755.                 Sk64    tmp;
  757.                 tmp.set(SK_Fract1);
  758.                 tmp.shiftLeft(16);
  759.                 tmp.div(inv->fMat[kMPersp2], Sk64::kRound_DivOption);
  761.                 SkFract scale = tmp.get32();
  763.                 for (int i = 0; i < 9; i++) {
  764.                     inv->fMat[i] = SkFractMul(inv->fMat[i], scale);
  765.                 }
  766.             }
  767.             inv->fMat[kMPersp2] = SkFixedToFract(inv->fMat[kMPersp2]);
  768. #endif
  769.         } else {   // not perspective
  770. #ifdef SK_SCALAR_IS_FIXED
  771.             Sk64    tx, ty;
  772.             int     clzNumer;
  774.             // check the 2x2 for overflow
  775.             {
  776.                 int32_t value = SkAbs32(fMat[kMScaleY]);
  777.                 value |= SkAbs32(fMat[kMSkewX]);
  778.                 value |= SkAbs32(fMat[kMScaleX]);
  779.                 value |= SkAbs32(fMat[kMSkewY]);
  780.                 clzNumer = SkCLZ(value);
  781.                 if (shift - clzNumer > 31)
  782.                     return false;   // overflow
  783.             }
  785.             set_muladdmul(&tx, fMat[kMSkewX], fMat[kMTransY], -fMat[kMScaleY], fMat[kMTransX]);
  786.             set_muladdmul(&ty, fMat[kMSkewY], fMat[kMTransX], -fMat[kMScaleX], fMat[kMTransY]);
  787.             // check tx,ty for overflow
  788.             clzNumer = SkCLZ(SkAbs32(tx.fHi) | SkAbs32(ty.fHi));
  789.             if (shift - clzNumer > 14) {
  790.                 return false;   // overflow
  791.             }
  793.             int fixedShift = 61 - shift;
  794.             int sk64shift = 44 - shift + clzNumer;
  796.             inv->fMat[kMScaleX] = SkMulShift(fMat[kMScaleY], scale, fixedShift);
  797.             inv->fMat[kMSkewX]  = SkMulShift(-fMat[kMSkewX], scale, fixedShift);
  798.             inv->fMat[kMTransX] = SkMulShift(tx.getShiftRight(33 - clzNumer), scale, sk64shift);
  799.                 
  800.             inv->fMat[kMSkewY]  = SkMulShift(-fMat[kMSkewY], scale, fixedShift);
  801.             inv->fMat[kMScaleY] = SkMulShift(fMat[kMScaleX], scale, fixedShift);
  802.             inv->fMat[kMTransY] = SkMulShift(ty.getShiftRight(33 - clzNumer), scale, sk64shift);
  803. #else
  804.             inv->fMat[kMScaleX] = SkScalarMul(fMat[kMScaleY], scale);
  805.             inv->fMat[kMSkewX] = SkScalarMul(-fMat[kMSkewX], scale);
  806.             if (!fixmuladdmulshiftmul(fMat[kMSkewX], fMat[kMTransY], -fMat[kMScaleY], fMat[kMTransX], shift, scale, &inv->fMat[kMTransX])) {
  807.                 return false;
  808.             }
  809.                 
  810.             inv->fMat[kMSkewY] = SkScalarMul(-fMat[kMSkewY], scale);
  811.             inv->fMat[kMScaleY] = SkScalarMul(fMat[kMScaleX], scale);
  812.             if (!fixmuladdmulshiftmul(fMat[kMSkewY], fMat[kMTransX], -fMat[kMScaleX], fMat[kMTransY], shift, scale, &inv->fMat[kMTransY])) {
  813.                 return false;
  814.             }
  815. #endif
  816.             inv->fMat[kMPersp0] = 0;
  817.             inv->fMat[kMPersp1] = 0;
  818.             inv->fMat[kMPersp2] = kMatrix22Elem;
  819.         }
  821.         if (inv == &tmp) {
  822.             *(SkMatrix*)this = tmp;
  823.         }
  824.         inv->setTypeMask(kUnknown_Mask);
  825.     }
  826.     return true;
  827. }
  829. ///////////////////////////////////////////////////////////////////////////////
  831. void SkMatrix::Identity_pts(const SkMatrix& m, SkPoint dst[],
  832.                             const SkPoint src[], int count) {
  833.     SkASSERT(m.getType() == 0);
  835.     if (dst != src && count > 0)
  836.         memcpy(dst, src, count * sizeof(SkPoint));
  837. }
  839. void SkMatrix::Trans_pts(const SkMatrix& m, SkPoint dst[],
  840.                          const SkPoint src[], int count) {
  841.     SkASSERT(m.getType() == kTranslate_Mask);
  843.     if (count > 0) {
  844.         SkScalar tx = m.fMat[kMTransX];
  845.         SkScalar ty = m.fMat[kMTransY];
  846.         do {
  847.             dst->fY = src->fY + ty;
  848.             dst->fX = src->fX + tx;
  849.             src += 1;
  850.             dst += 1;
  851.         } while (--count);
  852.     }
  853. }
  855. void SkMatrix::Scale_pts(const SkMatrix& m, SkPoint dst[],
  856.                          const SkPoint src[], int count) {
  857.     SkASSERT(m.getType() == kScale_Mask);
  859.     if (count > 0) {
  860.         SkScalar mx = m.fMat[kMScaleX];
  861.         SkScalar my = m.fMat[kMScaleY];
  862.         do {
  863.             dst->fY = SkScalarMul(src->fY, my);
  864.             dst->fX = SkScalarMul(src->fX, mx);
  865.             src += 1;
  866.             dst += 1;
  867.         } while (--count);
  868.     }
  869. }
  871. void SkMatrix::ScaleTrans_pts(const SkMatrix& m, SkPoint dst[],
  872.                               const SkPoint src[], int count) {
  873.     SkASSERT(m.getType() == (kScale_Mask | kTranslate_Mask));
  875.     if (count > 0) {
  876.         SkScalar mx = m.fMat[kMScaleX];
  877.         SkScalar my = m.fMat[kMScaleY];
  878.         SkScalar tx = m.fMat[kMTransX];
  879.         SkScalar ty = m.fMat[kMTransY];
  880.         do {
  881.             dst->fY = SkScalarMulAdd(src->fY, my, ty);
  882.             dst->fX = SkScalarMulAdd(src->fX, mx, tx);
  883.             src += 1;
  884.             dst += 1;
  885.         } while (--count);
  886.     }
  887. }
  889. void SkMatrix::Rot_pts(const SkMatrix& m, SkPoint dst[],
  890.                        const SkPoint src[], int count) {
  891.     SkASSERT((m.getType() & (kPerspective_Mask | kTranslate_Mask)) == 0);
  893.     if (count > 0) {
  894.         SkScalar mx = m.fMat[kMScaleX];
  895.         SkScalar my = m.fMat[kMScaleY];
  896.         SkScalar kx = m.fMat[kMSkewX];
  897.         SkScalar ky = m.fMat[kMSkewY];
  898.         do {
  899.             SkScalar sy = src->fY;
  900.             SkScalar sx = src->fX;
  901.             src += 1;
  902.             dst->fY = SkScalarMul(sx, ky) + SkScalarMul(sy, my);
  903.             dst->fX = SkScalarMul(sx, mx) + SkScalarMul(sy, kx);
  904.             dst += 1;
  905.         } while (--count);
  906.     }
  907. }
  909. void SkMatrix::RotTrans_pts(const SkMatrix& m, SkPoint dst[],
  910.                             const SkPoint src[], int count) {
  911.     SkASSERT((m.getType() & kPerspective_Mask) == 0);
  913.     if (count > 0) {
  914.         SkScalar mx = m.fMat[kMScaleX];
  915.         SkScalar my = m.fMat[kMScaleY];
  916.         SkScalar kx = m.fMat[kMSkewX];
  917.         SkScalar ky = m.fMat[kMSkewY];
  918.         SkScalar tx = m.fMat[kMTransX];
  919.         SkScalar ty = m.fMat[kMTransY];
  920.         do {
  921.             SkScalar sy = src->fY;
  922.             SkScalar sx = src->fX;
  923.             src += 1;
  924.             dst->fY = SkScalarMul(sx, ky) + SkScalarMulAdd(sy, my, ty);
  925.             dst->fX = SkScalarMul(sx, mx) + SkScalarMulAdd(sy, kx, tx);
  926.             dst += 1;
  927.         } while (--count);
  928.     }
  929. }
  931. void SkMatrix::Persp_pts(const SkMatrix& m, SkPoint dst[],
  932.                          const SkPoint src[], int count) {
  933.     SkASSERT(m.getType() & kPerspective_Mask);
  935. #ifdef SK_SCALAR_IS_FIXED
  936.     SkFixed persp2 = SkFractToFixed(m.fMat[kMPersp2]);
  937. #endif
  939.     if (count > 0) {
  940.         do {
  941.             SkScalar sy = src->fY;
  942.             SkScalar sx = src->fX;
  943.             src += 1;
  945.             SkScalar x = SkScalarMul(sx, m.fMat[kMScaleX]) +
  946.                          SkScalarMul(sy, m.fMat[kMSkewX]) + m.fMat[kMTransX];
  947.             SkScalar y = SkScalarMul(sx, m.fMat[kMSkewY]) +
  948.                          SkScalarMul(sy, m.fMat[kMScaleY]) + m.fMat[kMTransY];
  949. #ifdef SK_SCALAR_IS_FIXED
  950.             SkFixed z = SkFractMul(sx, m.fMat[kMPersp0]) +
  951.                         SkFractMul(sy, m.fMat[kMPersp1]) + persp2;
  952. #else
  953.             float z = SkScalarMul(sx, m.fMat[kMPersp0]) +
  954.                       SkScalarMulAdd(sy, m.fMat[kMPersp1], m.fMat[kMPersp2]);
  955. #endif
  956.             if (z) {
  957.                 z = SkScalarFastInvert(z);
  958.             }
  960.             dst->fY = SkScalarMul(y, z);
  961.             dst->fX = SkScalarMul(x, z);
  962.             dst += 1;
  963.         } while (--count);
  964.     }
  965. }
  967. const SkMatrix::MapPtsProc SkMatrix::gMapPtsProcs[] = {
  968.     SkMatrix::Identity_pts, SkMatrix::Trans_pts,
  969.     SkMatrix::Scale_pts,    SkMatrix::ScaleTrans_pts,
  970.     SkMatrix::Rot_pts,      SkMatrix::RotTrans_pts,
  971.     SkMatrix::Rot_pts,      SkMatrix::RotTrans_pts,
  972.     // repeat the persp proc 8 times
  973.     SkMatrix::Persp_pts,    SkMatrix::Persp_pts,
  974.     SkMatrix::Persp_pts,    SkMatrix::Persp_pts,
  975.     SkMatrix::Persp_pts,    SkMatrix::Persp_pts,
  976.     SkMatrix::Persp_pts,    SkMatrix::Persp_pts
  977. };
  979. void SkMatrix::mapPoints(SkPoint dst[], const SkPoint src[], int count) const {
  980.     SkASSERT((dst && src && count > 0) || count == 0);
  981.     // no partial overlap
  982.     SkASSERT(src == dst || SkAbs32((int32_t)(src - dst)) >= count);
  984.     this->getMapPtsProc()(*this, dst, src, count);
  985. }
  987. ///////////////////////////////////////////////////////////////////////////////
  989. void SkMatrix::mapVectors(SkPoint dst[], const SkPoint src[], int count) const {
  990.     if (this->getType() & kPerspective_Mask) {
  991.         SkPoint origin;
  993.         MapXYProc proc = this->getMapXYProc();
  994.         proc(*this, 0, 0, &origin);
  996.         for (int i = count - 1; i >= 0; --i) {
  997.             SkPoint tmp;
  999.             proc(*this, src[i].fX, src[i].fY, &tmp);
  1000.             dst[i].set(tmp.fX - origin.fX, tmp.fY - origin.fY);
  1001.         }
  1002.     } else {
  1003.         SkMatrix tmp = *this;
  1005.         tmp.fMat[kMTransX] = tmp.fMat[kMTransY] = 0;
  1006.         tmp.clearTypeMask(kTranslate_Mask);
  1007.         tmp.mapPoints(dst, src, count);
  1008.     }
  1009. }
  1011. bool SkMatrix::mapRect(SkRect* dst, const SkRect& src) const {
  1012.     SkASSERT(dst && &src);
  1014.     if (this->rectStaysRect()) {
  1015.         this->mapPoints((SkPoint*)dst, (const SkPoint*)&src, 2);
  1016.         dst->sort();
  1017.         return true;
  1018.     } else {
  1019.         SkPoint quad[4];
  1021.         src.toQuad(quad);
  1022.         this->mapPoints(quad, quad, 4);
  1023.         dst->set(quad, 4);
  1024.         return false;
  1025.     }
  1026. }
  1028. SkScalar SkMatrix::mapRadius(SkScalar radius) const {
  1029.     SkVector    vec[2];
  1031.     vec[0].set(radius, 0);
  1032.     vec[1].set(0, radius);
  1033.     this->mapVectors(vec, 2);
  1035.     SkScalar d0 = vec[0].length();
  1036.     SkScalar d1 = vec[1].length();
  1038.     return SkScalarMean(d0, d1);
  1039. }
  1041. ///////////////////////////////////////////////////////////////////////////////
  1043. void SkMatrix::Persp_xy(const SkMatrix& m, SkScalar sx, SkScalar sy,
  1044.                         SkPoint* pt) {
  1045.     SkASSERT(m.getType() & kPerspective_Mask);
  1047.     SkScalar x = SkScalarMul(sx, m.fMat[kMScaleX]) +
  1048.                  SkScalarMul(sy, m.fMat[kMSkewX]) + m.fMat[kMTransX];
  1049.     SkScalar y = SkScalarMul(sx, m.fMat[kMSkewY]) +
  1050.                  SkScalarMul(sy, m.fMat[kMScaleY]) + m.fMat[kMTransY];
  1051. #ifdef SK_SCALAR_IS_FIXED
  1052.     SkFixed z = SkFractMul(sx, m.fMat[kMPersp0]) +
  1053.                 SkFractMul(sy, m.fMat[kMPersp1]) +
  1054.                 SkFractToFixed(m.fMat[kMPersp2]);
  1055. #else
  1056.     float z = SkScalarMul(sx, m.fMat[kMPersp0]) +
  1057.               SkScalarMul(sy, m.fMat[kMPersp1]) + m.fMat[kMPersp2];
  1058. #endif
  1059.     if (z) {
  1060.         z = SkScalarFastInvert(z);
  1061.     }
  1062.     pt->fX = SkScalarMul(x, z);
  1063.     pt->fY = SkScalarMul(y, z);
  1064. }
  1066. #ifdef SK_SCALAR_IS_FIXED
  1067. static SkFixed fixmuladdmul(SkFixed a, SkFixed b, SkFixed c, SkFixed d) {
  1068.     Sk64    tmp, tmp1;
  1070.     tmp.setMul(a, b);
  1071.     tmp1.setMul(c, d);
  1072.     return tmp.addGetFixed(tmp1);
  1073. //  tmp.add(tmp1);
  1074. //  return tmp.getFixed();
  1075. }
  1076. #endif
  1078. void SkMatrix::RotTrans_xy(const SkMatrix& m, SkScalar sx, SkScalar sy,
  1079.                            SkPoint* pt) {
  1080.     SkASSERT((m.getType() & (kAffine_Mask | kPerspective_Mask)) == kAffine_Mask);
  1081.     
  1082. #ifdef SK_SCALAR_IS_FIXED
  1083.     pt->fX = fixmuladdmul(sx, m.fMat[kMScaleX], sy, m.fMat[kMSkewX]) +
  1084.              m.fMat[kMTransX];
  1085.     pt->fY = fixmuladdmul(sx, m.fMat[kMSkewY], sy, m.fMat[kMScaleY]) +
  1086.              m.fMat[kMTransY];
  1087. #else
  1088.     pt->fX = SkScalarMul(sx, m.fMat[kMScaleX]) +
  1089.              SkScalarMulAdd(sy, m.fMat[kMSkewX], m.fMat[kMTransX]);
  1090.     pt->fY = SkScalarMul(sx, m.fMat[kMSkewY]) +
  1091.              SkScalarMulAdd(sy, m.fMat[kMScaleY], m.fMat[kMTransY]);
  1092. #endif
  1093. }
  1095. void SkMatrix::Rot_xy(const SkMatrix& m, SkScalar sx, SkScalar sy,
  1096.                       SkPoint* pt) {
  1097.     SkASSERT((m.getType() & (kAffine_Mask | kPerspective_Mask))== kAffine_Mask);
  1098.     SkASSERT(0 == m.fMat[kMTransX]);
  1099.     SkASSERT(0 == m.fMat[kMTransY]);
  1101. #ifdef SK_SCALAR_IS_FIXED
  1102.     pt->fX = fixmuladdmul(sx, m.fMat[kMScaleX], sy, m.fMat[kMSkewX]);
  1103.     pt->fY = fixmuladdmul(sx, m.fMat[kMSkewY], sy, m.fMat[kMScaleY]);
  1104. #else
  1105.     pt->fX = SkScalarMul(sx, m.fMat[kMScaleX]) +
  1106.              SkScalarMulAdd(sy, m.fMat[kMSkewX], m.fMat[kMTransX]);
  1107.     pt->fY = SkScalarMul(sx, m.fMat[kMSkewY]) +
  1108.              SkScalarMulAdd(sy, m.fMat[kMScaleY], m.fMat[kMTransY]);
  1109. #endif
  1110. }
  1112. void SkMatrix::ScaleTrans_xy(const SkMatrix& m, SkScalar sx, SkScalar sy,
  1113.                              SkPoint* pt) {
  1114.     SkASSERT((m.getType() & (kScale_Mask | kAffine_Mask | kPerspective_Mask))
  1115.              == kScale_Mask);
  1116.     
  1117.     pt->fX = SkScalarMulAdd(sx, m.fMat[kMScaleX], m.fMat[kMTransX]);
  1118.     pt->fY = SkScalarMulAdd(sy, m.fMat[kMScaleY], m.fMat[kMTransY]);
  1119. }
  1121. void SkMatrix::Scale_xy(const SkMatrix& m, SkScalar sx, SkScalar sy,
  1122.                         SkPoint* pt) {
  1123.     SkASSERT((m.getType() & (kScale_Mask | kAffine_Mask | kPerspective_Mask))
  1124.              == kScale_Mask);
  1125.     SkASSERT(0 == m.fMat[kMTransX]);
  1126.     SkASSERT(0 == m.fMat[kMTransY]);
  1128.     pt->fX = SkScalarMul(sx, m.fMat[kMScaleX]);
  1129.     pt->fY = SkScalarMul(sy, m.fMat[kMScaleY]);
  1130. }
  1132. void SkMatrix::Trans_xy(const SkMatrix& m, SkScalar sx, SkScalar sy,
  1133.                         SkPoint* pt) {
  1134.     SkASSERT(m.getType() == kTranslate_Mask);
  1136.     pt->fX = sx + m.fMat[kMTransX];
  1137.     pt->fY = sy + m.fMat[kMTransY];
  1138. }
  1140. void SkMatrix::Identity_xy(const SkMatrix& m, SkScalar sx, SkScalar sy,
  1141.                            SkPoint* pt) {
  1142.     SkASSERT(0 == m.getType());
  1144.     pt->fX = sx;
  1145.     pt->fY = sy;
  1146. }
  1148. const SkMatrix::MapXYProc SkMatrix::gMapXYProcs[] = {
  1149.     SkMatrix::Identity_xy, SkMatrix::Trans_xy,
  1150.     SkMatrix::Scale_xy,    SkMatrix::ScaleTrans_xy,
  1151.     SkMatrix::Rot_xy,      SkMatrix::RotTrans_xy,
  1152.     SkMatrix::Rot_xy,      SkMatrix::RotTrans_xy,
  1153.     // repeat the persp proc 8 times
  1154.     SkMatrix::Persp_xy,    SkMatrix::Persp_xy,
  1155.     SkMatrix::Persp_xy,    SkMatrix::Persp_xy,
  1156.     SkMatrix::Persp_xy,    SkMatrix::Persp_xy,
  1157.     SkMatrix::Persp_xy,    SkMatrix::Persp_xy
  1158. };
  1160. ///////////////////////////////////////////////////////////////////////////////
  1162. // if its nearly zero (just made up 26, perhaps it should be bigger or smaller)
  1163. #ifdef SK_SCALAR_IS_FIXED
  1164.     typedef SkFract             SkPerspElemType;
  1165.     #define PerspNearlyZero(x)  (SkAbs32(x) < (SK_Fract1 >> 26))
  1166. #else
  1167.     typedef float               SkPerspElemType;
  1168.     #define PerspNearlyZero(x)  SkScalarNearlyZero(x, (1.0f / (1 << 26)))
  1169. #endif
  1171. bool SkMatrix::fixedStepInX(SkScalar y, SkFixed* stepX, SkFixed* stepY) const {
  1172.     if (PerspNearlyZero(fMat[kMPersp0])) {
  1173.         if (stepX || stepY) {
  1174.             if (PerspNearlyZero(fMat[kMPersp1]) &&
  1175.                     PerspNearlyZero(fMat[kMPersp2] - kMatrix22Elem)) {
  1176.                 if (stepX) {
  1177.                     *stepX = SkScalarToFixed(fMat[kMScaleX]);
  1178.                 }
  1179.                 if (stepY) {
  1180.                     *stepY = SkScalarToFixed(fMat[kMSkewY]);
  1181.                 }
  1182.             } else {
  1183. #ifdef SK_SCALAR_IS_FIXED
  1184.                 SkFixed z = SkFractMul(y, fMat[kMPersp1]) +
  1185.                             SkFractToFixed(fMat[kMPersp2]);
  1186. #else
  1187.                 float z = y * fMat[kMPersp1] + fMat[kMPersp2];
  1188. #endif
  1189.                 if (stepX) {
  1190.                     *stepX = SkScalarToFixed(SkScalarDiv(fMat[kMScaleX], z));
  1191.                 }
  1192.                 if (stepY) {
  1193.                     *stepY = SkScalarToFixed(SkScalarDiv(fMat[kMSkewY], z));
  1194.                 }
  1195.             }
  1196.         }
  1197.         return true;
  1198.     }
  1199.     return false;
  1200. }
  1202. ///////////////////////////////////////////////////////////////////////////////
  1204. #include "SkPerspIter.h"
  1206. SkPerspIter::SkPerspIter(const SkMatrix& m, SkScalar x0, SkScalar y0, int count)
  1207.         : fMatrix(m), fSX(x0), fSY(y0), fCount(count) {
  1208.     SkPoint pt;
  1210.     SkMatrix::Persp_xy(m, x0, y0, &pt);
  1211.     fX = SkScalarToFixed(pt.fX);
  1212.     fY = SkScalarToFixed(pt.fY);
  1213. }
  1215. int SkPerspIter::next() {
  1216.     int n = fCount;
  1217.     
  1218.     if (0 == n) {
  1219.         return 0;
  1220.     }
  1221.     SkPoint pt;
  1222.     SkFixed x = fX;
  1223.     SkFixed y = fY;
  1224.     SkFixed dx, dy;
  1226.     if (n >= kCount) {
  1227.         n = kCount;
  1228.         fSX += SkIntToScalar(kCount);
  1229.         SkMatrix::Persp_xy(fMatrix, fSX, fSY, &pt);
  1230.         fX = SkScalarToFixed(pt.fX);
  1231.         fY = SkScalarToFixed(pt.fY);
  1232.         dx = (fX - x) >> kShift;
  1233.         dy = (fY - y) >> kShift;
  1234.     } else {
  1235.         fSX += SkIntToScalar(n);
  1236.         SkMatrix::Persp_xy(fMatrix, fSX, fSY, &pt);
  1237.         fX = SkScalarToFixed(pt.fX);
  1238.         fY = SkScalarToFixed(pt.fY);
  1239.         dx = (fX - x) / n;
  1240.         dy = (fY - y) / n;
  1241.     }
  1243.     SkFixed* p = fStorage;
  1244.     for (int i = 0; i < n; i++) {
  1245.         *p++ = x; x += dx;
  1246.         *p++ = y; y += dy;
  1247.     }
  1248.     
  1249.     fCount -= n;
  1250.     return n;
  1251. }
  1253. ///////////////////////////////////////////////////////////////////////////////
  1255. #ifdef SK_SCALAR_IS_FIXED
  1257. static inline bool poly_to_point(SkPoint* pt, const SkPoint poly[], int count) {
  1258.     SkFixed x = SK_Fixed1, y = SK_Fixed1;
  1259.     SkPoint pt1, pt2;
  1260.     Sk64    w1, w2;
  1262.     if (count > 1) {
  1263.         pt1.fX = poly[1].fX - poly[0].fX;
  1264.         pt1.fY = poly[1].fY - poly[0].fY;
  1265.         y = SkPoint::Length(pt1.fX, pt1.fY);
  1266.         if (y == 0) {
  1267.             return false;
  1268.         }
  1269.         switch (count) {
  1270.             case 2:
  1271.                 break;
  1272.             case 3:
  1273.                 pt2.fX = poly[0].fY - poly[2].fY;
  1274.                 pt2.fY = poly[2].fX - poly[0].fX;
  1275.                 goto CALC_X;
  1276.             default:
  1277.                 pt2.fX = poly[0].fY - poly[3].fY;
  1278.                 pt2.fY = poly[3].fX - poly[0].fX;
  1279.             CALC_X:
  1280.                 w1.setMul(pt1.fX, pt2.fX);
  1281.                 w2.setMul(pt1.fY, pt2.fY);
  1282.                 w1.add(w2);
  1283.                 w1.div(y, Sk64::kRound_DivOption);
  1284.                 if (!w1.is32()) {
  1285.                     return false;
  1286.                 }
  1287.                 x = w1.get32();
  1288.                 break;
  1289.         }
  1290.     }
  1291.     pt->set(x, y);
  1292.     return true;
  1293. }
  1295. bool SkMatrix::Poly2Proc(const SkPoint srcPt[], SkMatrix* dst,
  1296.                          const SkPoint& scalePt) {
  1297.     // need to check if SkFixedDiv overflows...
  1299.     const SkFixed scale = scalePt.fY;
  1300.     dst->fMat[kMScaleX] = SkFixedDiv(srcPt[1].fY - srcPt[0].fY, scale);
  1301.     dst->fMat[kMSkewY]  = SkFixedDiv(srcPt[0].fX - srcPt[1].fX, scale);
  1302.     dst->fMat[kMPersp0] = 0;
  1303.     dst->fMat[kMSkewX]  = SkFixedDiv(srcPt[1].fX - srcPt[0].fX, scale);
  1304.     dst->fMat[kMScaleY] = SkFixedDiv(srcPt[1].fY - srcPt[0].fY, scale);
  1305.     dst->fMat[kMPersp1] = 0;
  1306.     dst->fMat[kMTransX] = srcPt[0].fX;
  1307.     dst->fMat[kMTransY] = srcPt[0].fY;
  1308.     dst->fMat[kMPersp2] = SK_Fract1;
  1309.     dst->setTypeMask(kUnknown_Mask);
  1310.     return true;
  1311. }
  1313. bool SkMatrix::Poly3Proc(const SkPoint srcPt[], SkMatrix* dst,
  1314.                          const SkPoint& scale) {
  1315.     // really, need to check if SkFixedDiv overflow'd
  1317.     dst->fMat[kMScaleX] = SkFixedDiv(srcPt[2].fX - srcPt[0].fX, scale.fX);
  1318.     dst->fMat[kMSkewY]  = SkFixedDiv(srcPt[2].fY - srcPt[0].fY, scale.fX);
  1319.     dst->fMat[kMPersp0] = 0;
  1320.     dst->fMat[kMSkewX]  = SkFixedDiv(srcPt[1].fX - srcPt[0].fX, scale.fY);
  1321.     dst->fMat[kMScaleY] = SkFixedDiv(srcPt[1].fY - srcPt[0].fY, scale.fY);
  1322.     dst->fMat[kMPersp1] = 0;
  1323.     dst->fMat[kMTransX] = srcPt[0].fX;
  1324.     dst->fMat[kMTransY] = srcPt[0].fY;
  1325.     dst->fMat[kMPersp2] = SK_Fract1;
  1326.     dst->setTypeMask(kUnknown_Mask);
  1327.     return true;
  1328. }
  1330. bool SkMatrix::Poly4Proc(const SkPoint srcPt[], SkMatrix* dst,
  1331.                          const SkPoint& scale) {
  1332.     SkFract a1, a2;
  1333.     SkFixed x0, y0, x1, y1, x2, y2;
  1335.     x0 = srcPt[2].fX - srcPt[0].fX;
  1336.     y0 = srcPt[2].fY - srcPt[0].fY;
  1337.     x1 = srcPt[2].fX - srcPt[1].fX;
  1338.     y1 = srcPt[2].fY - srcPt[1].fY;
  1339.     x2 = srcPt[2].fX - srcPt[3].fX;
  1340.     y2 = srcPt[2].fY - srcPt[3].fY;
  1342.     /* check if abs(x2) > abs(y2) */
  1343.     if ( x2 > 0 ? y2 > 0 ? x2 > y2 : x2 > -y2 : y2 > 0 ? -x2 > y2 : x2 < y2) {
  1344.         SkFixed denom = SkMulDiv(x1, y2, x2) - y1;
  1345.         if (0 == denom) {
  1346.             return false;
  1347.         }
  1348.         a1 = SkFractDiv(SkMulDiv(x0 - x1, y2, x2) - y0 + y1, denom);
  1349.     } else {
  1350.         SkFixed denom = x1 - SkMulDiv(y1, x2, y2);
  1351.         if (0 == denom) {
  1352.             return false;
  1353.         }
  1354.         a1 = SkFractDiv(x0 - x1 - SkMulDiv(y0 - y1, x2, y2), denom);
  1355.     }
  1357.     /* check if abs(x1) > abs(y1) */
  1358.     if ( x1 > 0 ? y1 > 0 ? x1 > y1 : x1 > -y1 : y1 > 0 ? -x1 > y1 : x1 < y1) {
  1359.         SkFixed denom = y2 - SkMulDiv(x2, y1, x1);
  1360.         if (0 == denom) {
  1361.             return false;
  1362.         }
  1363.         a2 = SkFractDiv(y0 - y2 - SkMulDiv(x0 - x2, y1, x1), denom);
  1364.     } else {
  1365.         SkFixed denom = SkMulDiv(y2, x1, y1) - x2;
  1366.         if (0 == denom) {
  1367.             return false;
  1368.         }
  1369.         a2 = SkFractDiv(SkMulDiv(y0 - y2, x1, y1) - x0 + x2, denom);
  1370.     }
  1372.     // need to check if SkFixedDiv overflows...
  1373.     dst->fMat[kMScaleX] = SkFixedDiv(SkFractMul(a2, srcPt[3].fX) +
  1374.                                      srcPt[3].fX - srcPt[0].fX, scale.fX);
  1375.     dst->fMat[kMSkewY]  = SkFixedDiv(SkFractMul(a2, srcPt[3].fY) +
  1376.                                      srcPt[3].fY - srcPt[0].fY, scale.fX);
  1377.     dst->fMat[kMPersp0] = SkFixedDiv(a2, scale.fX);
  1378.     dst->fMat[kMSkewX]  = SkFixedDiv(SkFractMul(a1, srcPt[1].fX) +
  1379.                                      srcPt[1].fX - srcPt[0].fX, scale.fY);
  1380.     dst->fMat[kMScaleY] = SkFixedDiv(SkFractMul(a1, srcPt[1].fY) +
  1381.                                      srcPt[1].fY - srcPt[0].fY, scale.fY);
  1382.     dst->fMat[kMPersp1] = SkFixedDiv(a1, scale.fY);
  1383.     dst->fMat[kMTransX] = srcPt[0].fX;
  1384.     dst->fMat[kMTransY] = srcPt[0].fY;
  1385.     dst->fMat[kMPersp2] = SK_Fract1;
  1386.     dst->setTypeMask(kUnknown_Mask);
  1387.     return true;
  1388. }
  1390. #else   /* Scalar is float */
  1392. static inline bool checkForZero(float x) {
  1393.     return x*x == 0;
  1394. }
  1396. static inline bool poly_to_point(SkPoint* pt, const SkPoint poly[], int count) {
  1397.     float   x = 1, y = 1;
  1398.     SkPoint pt1, pt2;
  1400.     if (count > 1) {
  1401.         pt1.fX = poly[1].fX - poly[0].fX;
  1402.         pt1.fY = poly[1].fY - poly[0].fY;
  1403.         y = SkPoint::Length(pt1.fX, pt1.fY);
  1404.         if (checkForZero(y)) {
  1405.             return false;
  1406.         }
  1407.         switch (count) {
  1408.             case 2:
  1409.                 break;
  1410.             case 3:
  1411.                 pt2.fX = poly[0].fY - poly[2].fY;
  1412.                 pt2.fY = poly[2].fX - poly[0].fX;
  1413.                 goto CALC_X;
  1414.             default:
  1415.                 pt2.fX = poly[0].fY - poly[3].fY;
  1416.                 pt2.fY = poly[3].fX - poly[0].fX;
  1417.             CALC_X:
  1418.                 x = SkScalarDiv(SkScalarMul(pt1.fX, pt2.fX) +
  1419.                                 SkScalarMul(pt1.fY, pt2.fY), y);
  1420.                 break;
  1421.         }
  1422.     }
  1423.     pt->set(x, y);
  1424.     return true;
  1425. }
  1427. bool SkMatrix::Poly2Proc(const SkPoint srcPt[], SkMatrix* dst,
  1428.                          const SkPoint& scale) {
  1429.     float invScale = 1 / scale.fY;
  1431.     dst->fMat[kMScaleX] = (srcPt[1].fY - srcPt[0].fY) * invScale;
  1432.     dst->fMat[kMSkewY] = (srcPt[0].fX - srcPt[1].fX) * invScale;
  1433.     dst->fMat[kMPersp0] = 0;
  1434.     dst->fMat[kMSkewX] = (srcPt[1].fX - srcPt[0].fX) * invScale;
  1435.     dst->fMat[kMScaleY] = (srcPt[1].fY - srcPt[0].fY) * invScale;
  1436.     dst->fMat[kMPersp1] = 0;
  1437.     dst->fMat[kMTransX] = srcPt[0].fX;
  1438.     dst->fMat[kMTransY] = srcPt[0].fY;
  1439.     dst->fMat[kMPersp2] = 1;
  1440.     dst->setTypeMask(kUnknown_Mask);
  1441.     return true;
  1442. }
  1444. bool SkMatrix::Poly3Proc(const SkPoint srcPt[], SkMatrix* dst,
  1445.                          const SkPoint& scale) {
  1446.     float invScale = 1 / scale.fX;
  1447.     dst->fMat[kMScaleX] = (srcPt[2].fX - srcPt[0].fX) * invScale;
  1448.     dst->fMat[kMSkewY] = (srcPt[2].fY - srcPt[0].fY) * invScale;
  1449.     dst->fMat[kMPersp0] = 0;
  1451.     invScale = 1 / scale.fY;
  1452.     dst->fMat[kMSkewX] = (srcPt[1].fX - srcPt[0].fX) * invScale;
  1453.     dst->fMat[kMScaleY] = (srcPt[1].fY - srcPt[0].fY) * invScale;
  1454.     dst->fMat[kMPersp1] = 0;
  1456.     dst->fMat[kMTransX] = srcPt[0].fX;
  1457.     dst->fMat[kMTransY] = srcPt[0].fY;
  1458.     dst->fMat[kMPersp2] = 1;
  1459.     dst->setTypeMask(kUnknown_Mask);
  1460.     return true;
  1461. }
  1463. bool SkMatrix::Poly4Proc(const SkPoint srcPt[], SkMatrix* dst,
  1464.                          const SkPoint& scale) {
  1465.     float   a1, a2;
  1466.     float   x0, y0, x1, y1, x2, y2;
  1468.     x0 = srcPt[2].fX - srcPt[0].fX;
  1469.     y0 = srcPt[2].fY - srcPt[0].fY;
  1470.     x1 = srcPt[2].fX - srcPt[1].fX;
  1471.     y1 = srcPt[2].fY - srcPt[1].fY;
  1472.     x2 = srcPt[2].fX - srcPt[3].fX;
  1473.     y2 = srcPt[2].fY - srcPt[3].fY;
  1475.     /* check if abs(x2) > abs(y2) */
  1476.     if ( x2 > 0 ? y2 > 0 ? x2 > y2 : x2 > -y2 : y2 > 0 ? -x2 > y2 : x2 < y2) {
  1477.         float denom = SkScalarMulDiv(x1, y2, x2) - y1;
  1478.         if (checkForZero(denom)) {
  1479.             return false;
  1480.         }
  1481.         a1 = SkScalarDiv(SkScalarMulDiv(x0 - x1, y2, x2) - y0 + y1, denom);
  1482.     } else {
  1483.         float denom = x1 - SkScalarMulDiv(y1, x2, y2);
  1484.         if (checkForZero(denom)) {
  1485.             return false;
  1486.         }
  1487.         a1 = SkScalarDiv(x0 - x1 - SkScalarMulDiv(y0 - y1, x2, y2), denom);
  1488.     }
  1490.     /* check if abs(x1) > abs(y1) */
  1491.     if ( x1 > 0 ? y1 > 0 ? x1 > y1 : x1 > -y1 : y1 > 0 ? -x1 > y1 : x1 < y1) {
  1492.         float denom = y2 - SkScalarMulDiv(x2, y1, x1);
  1493.         if (checkForZero(denom)) {
  1494.             return false;
  1495.         }
  1496.         a2 = SkScalarDiv(y0 - y2 - SkScalarMulDiv(x0 - x2, y1, x1), denom);
  1497.     } else {
  1498.         float denom = SkScalarMulDiv(y2, x1, y1) - x2;
  1499.         if (checkForZero(denom)) {
  1500.             return false;
  1501.         }
  1502.         a2 = SkScalarDiv(SkScalarMulDiv(y0 - y2, x1, y1) - x0 + x2, denom);
  1503.     }
  1505.     float invScale = 1 / scale.fX;
  1506.     dst->fMat[kMScaleX] = SkScalarMul(SkScalarMul(a2, srcPt[3].fX) +
  1507.                                       srcPt[3].fX - srcPt[0].fX, invScale);
  1508.     dst->fMat[kMSkewY] = SkScalarMul(SkScalarMul(a2, srcPt[3].fY) +
  1509.                                      srcPt[3].fY - srcPt[0].fY, invScale);
  1510.     dst->fMat[kMPersp0] = SkScalarMul(a2, invScale);
  1511.     invScale = 1 / scale.fY;
  1512.     dst->fMat[kMSkewX] = SkScalarMul(SkScalarMul(a1, srcPt[1].fX) +
  1513.                                      srcPt[1].fX - srcPt[0].fX, invScale);
  1514.     dst->fMat[kMScaleY] = SkScalarMul(SkScalarMul(a1, srcPt[1].fY) +
  1515.                                       srcPt[1].fY - srcPt[0].fY, invScale);
  1516.     dst->fMat[kMPersp1] = SkScalarMul(a1, invScale);
  1517.     dst->fMat[kMTransX] = srcPt[0].fX;
  1518.     dst->fMat[kMTransY] = srcPt[0].fY;
  1519.     dst->fMat[kMPersp2] = 1;
  1520.     dst->setTypeMask(kUnknown_Mask);
  1521.     return true;
  1522. }
  1524. #endif
  1526. typedef bool (*PolyMapProc)(const SkPoint[], SkMatrix*, const SkPoint&);
  1528. /*  Taken from Rob Johnson's original sample code in QuickDraw GX
  1529. */
  1530. bool SkMatrix::setPolyToPoly(const SkPoint src[], const SkPoint dst[],
  1531.                              int count) {
  1532.     if ((unsigned)count > 4) {
  1533.         SkDebugf("--- SkMatrix::setPolyToPoly count out of range %dn", count);
  1534.         return false;
  1535.     }
  1537.     if (0 == count) {
  1538.         this->reset();
  1539.         return true;
  1540.     }
  1541.     if (1 == count) {
  1542.         this->setTranslate(dst[0].fX - src[0].fX, dst[0].fY - src[0].fY);
  1543.         return true;
  1544.     }
  1546.     SkPoint scale;
  1547.     if (!poly_to_point(&scale, src, count) ||
  1548.             SkScalarNearlyZero(scale.fX) ||
  1549.             SkScalarNearlyZero(scale.fY)) {
  1550.         return false;
  1551.     }
  1553.     static const PolyMapProc gPolyMapProcs[] = {
  1554.         SkMatrix::Poly2Proc, SkMatrix::Poly3Proc, SkMatrix::Poly4Proc
  1555.     };
  1556.     PolyMapProc proc = gPolyMapProcs[count - 2];
  1558.     SkMatrix tempMap, result;
  1559.     tempMap.setTypeMask(kUnknown_Mask);
  1561.     if (!proc(src, &tempMap, scale)) {
  1562.         return false;
  1563.     }
  1564.     if (!tempMap.invert(&result)) {
  1565.         return false;
  1566.     }
  1567.     if (!proc(dst, &tempMap, scale)) {
  1568.         return false;
  1569.     }
  1570.     if (!result.setConcat(tempMap, result)) {
  1571.         return false;
  1572.     }
  1573.     *this = result;
  1574.     return true;
  1575. }
  1577. ///////////////////////////////////////////////////////////////////////////////
  1579. void SkMatrix::dump() const {
  1580. // Note: We don't use this so it's #if 0'd out. If turned back on, there
  1581. // is an #ifdef parsing difference between gcc and msvc where msvc incorrectly
  1582. // allows a missing #endif. Attempts to reconcile proved unfruitful thus we
  1583. // just turned it off.
  1584. #if 0
  1585.     // ensure the fTypeMask is up2date
  1586.     (void)this->getType();
  1587. #ifdef SK_DEBUG
  1588.     int mask = this->computeTypeMask();
  1589.     SkASSERT(mask == fTypeMask);
  1590. #endif
  1592. #ifdef SK_CAN_USE_FLOAT
  1593.     SkDebugf("[%8.4f %8.4f %8.4f] [%8.4f %8.4f %8.4f] [%8.4f %8.4f %8.4f] %xn",
  1594. #ifdef SK_SCALAR_IS_FLOAT
  1595.              fMat[0], fMat[1], fMat[2], fMat[3], fMat[4], fMat[5],
  1596.              fMat[6], fMat[7], fMat[8], fTypeMask);
  1597. #else
  1598.     SkFixedToFloat(fMat[0]), SkFixedToFloat(fMat[1]), SkFixedToFloat(fMat[2]),
  1599.     SkFixedToFloat(fMat[3]), SkFixedToFloat(fMat[4]), SkFixedToFloat(fMat[5]),
  1600.     SkFractToFloat(fMat[6]), SkFractToFloat(fMat[7]), SkFractToFloat(fMat[8]),
  1601.     fTypeMask);
  1602. #endif
  1603. #endif
  1604. #endif
  1605. }
  1607. ///////////////////////////////////////////////////////////////////////////////
  1609. #ifdef SK_DEBUG
  1611. void SkMatrix::UnitTest() {
  1612. #ifdef SK_SUPPORT_UNITTEST
  1613.     SkMatrix    mat, inverse, iden1, iden2;
  1615.     mat.reset();
  1616.     mat.setTranslate(SK_Scalar1, SK_Scalar1);
  1617.     mat.invert(&inverse);
  1618.     inverse.dump();
  1619.     iden1.setConcat(mat, inverse);
  1620.     iden1.dump();
  1622.     mat.setScale(SkIntToScalar(2), SkIntToScalar(2));
  1623.     mat.invert(&inverse);
  1624.     inverse.dump();
  1625.     iden1.setConcat(mat, inverse);
  1626.     iden1.dump();
  1628.     mat.setScale(SK_Scalar1/2, SK_Scalar1/2);
  1629.     mat.invert(&inverse);
  1630.     inverse.dump();
  1631.     iden1.setConcat(mat, inverse);
  1632.     iden1.dump();
  1633.     SkASSERT(iden1.isIdentity());
  1635.     mat.setScale(SkIntToScalar(3), SkIntToScalar(5), SkIntToScalar(20), 0);
  1636.     mat.postRotate(SkIntToScalar(25));
  1638.     SkASSERT(mat.invert(NULL));
  1639.     mat.invert(&inverse);
  1641.     iden1.setConcat(mat, inverse);
  1642.     iden2.setConcat(inverse, mat);
  1644.     iden1.dump();
  1645. //    SkASSERT(iden1.isIdentity());
  1646.     iden2.dump();
  1647. //    SkASSERT(iden2.isIdentity());
  1648.     
  1649.     // rectStaysRect test
  1650.     {
  1651.         static const struct {
  1652.             SkScalar    m00, m01, m10, m11;
  1653.             bool        mStaysRect;
  1654.         }
  1655.         gRectStaysRectSamples[] = {
  1656.             {          0,          0,          0,           0, false },
  1657.             {          0,          0,          0,  SK_Scalar1, false },
  1658.             {          0,          0, SK_Scalar1,           0, false },
  1659.             {          0,          0, SK_Scalar1,  SK_Scalar1, false },
  1660.             {          0, SK_Scalar1,          0,           0, false },
  1661.             {          0, SK_Scalar1,          0,  SK_Scalar1, false },
  1662.             {          0, SK_Scalar1, SK_Scalar1,           0, true },
  1663.             {          0, SK_Scalar1, SK_Scalar1,  SK_Scalar1, false },
  1664.             { SK_Scalar1,          0,          0,           0, false },
  1665.             { SK_Scalar1,          0,          0,  SK_Scalar1, true },
  1666.             { SK_Scalar1,          0, SK_Scalar1,           0, false },
  1667.             { SK_Scalar1,          0, SK_Scalar1,  SK_Scalar1, false },
  1668.             { SK_Scalar1, SK_Scalar1,          0,           0, false },
  1669.             { SK_Scalar1, SK_Scalar1,          0,  SK_Scalar1, false },
  1670.             { SK_Scalar1, SK_Scalar1, SK_Scalar1,           0, false },
  1671.             { SK_Scalar1, SK_Scalar1, SK_Scalar1,  SK_Scalar1, false }
  1672.         };
  1673.         
  1674.         for (size_t i = 0; i < SK_ARRAY_COUNT(gRectStaysRectSamples); i++) {
  1675.             SkMatrix    m;
  1676.             
  1677.             m.reset();
  1678.             m.set(SkMatrix::kMScaleX, gRectStaysRectSamples[i].m00);
  1679.             m.set(SkMatrix::kMSkewX,  gRectStaysRectSamples[i].m01);
  1680.             m.set(SkMatrix::kMSkewY,  gRectStaysRectSamples[i].m10);
  1681.             m.set(SkMatrix::kMScaleY, gRectStaysRectSamples[i].m11);
  1682.             SkASSERT(m.rectStaysRect() == gRectStaysRectSamples[i].mStaysRect);
  1683.         }
  1684.     }
  1685. #endif
  1686. }
  1688. #endif