SkCanvas interface for drawing a patch.

src/core/SkPatch.cpp

 /*
  * Copyright 2014 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SkPatch.h"
 
 #include "SkGeometry.h"
@@ skipping 102 matching lines @@
     fCornerColors[2] = SkPreMultiplyColor(colors[2]);
     fCornerColors[3] = SkPreMultiplyColor(colors[3]);
 }
 
 uint8_t bilinear(SkScalar tx, SkScalar ty, SkScalar c00, SkScalar c10, SkScalar c01, SkScalar c11) {
     SkScalar a = c00 * (1.f - tx) + c10 * tx;
     SkScalar b = c01 * (1.f - tx) + c11 * tx;
     return uint8_t(a * (1.f - ty) + b * ty);
 }
 
-bool SkPatch::getVertexData(SkPatch::VertexData* data, int divisions) {
+bool SkPatch::getVertexData(SkPatch::VertexData* data, int lodX, int lodY) const {
     
-    if (divisions < 1) {
+    if (lodX < 1 || lodY < 1) {
         return false;
     }
     
-    int divX = divisions, divY = divisions;
-    
-    data->fVertexCount = (divX + 1) * (divY + 1);
-    data->fIndexCount = divX * divY * 6;
+    data->fVertexCount = (lodX + 1) * (lodY + 1);
+    data->fIndexCount = lodX * lodY * 6;
 
     data->fPoints = SkNEW_ARRAY(SkPoint, data->fVertexCount);
     data->fColors = SkNEW_ARRAY(uint32_t, data->fVertexCount);
     data->fTexCoords = SkNEW_ARRAY(SkPoint, data->fVertexCount);
     data->fIndices = SkNEW_ARRAY(uint16_t, data->fIndexCount);
     
     FwDCubicEvaluator fBottom(fCtrlPoints[kBottomP0_CubicCtrlPts],
                               fCtrlPoints[kBottomP1_CubicCtrlPts],
                               fCtrlPoints[kBottomP2_CubicCtrlPts],
                               fCtrlPoints[kBottomP3_CubicCtrlPts]),
                         fTop(fCtrlPoints[kTopP0_CubicCtrlPts],
                              fCtrlPoints[kTopP1_CubicCtrlPts],
                              fCtrlPoints[kTopP2_CubicCtrlPts],
                              fCtrlPoints[kTopP2_CubicCtrlPts]),
                         fLeft(fCtrlPoints[kLeftP0_CubicCtrlPts],
                               fCtrlPoints[kLeftP1_CubicCtrlPts],
                               fCtrlPoints[kLeftP2_CubicCtrlPts],
                               fCtrlPoints[kLeftP3_CubicCtrlPts]),
                         fRight(fCtrlPoints[kRightP0_CubicCtrlPts],
                                fCtrlPoints[kRightP1_CubicCtrlPts],
                                fCtrlPoints[kRightP2_CubicCtrlPts],
                                fCtrlPoints[kRightP3_CubicCtrlPts]);
 
-    fBottom.restart(divX);
-    fTop.restart(divX);
+    fBottom.restart(lodX);
+    fTop.restart(lodX);
 
     SkScalar u = 0.0f;
-    int stride = divY + 1;
-    for (int x = 0; x <= divX; x++) {
+    int stride = lodY + 1;
+    for (int x = 0; x <= lodX; x++) {
         SkPoint bottom = fBottom.next(), top = fTop.next();
-        fLeft.restart(divY);
-        fRight.restart(divY);
+        fLeft.restart(lodY);
+        fRight.restart(lodY);
         SkScalar v = 0.f;
-        for (int y = 0; y <= divY; y++) {
-            int dataIndex = x * (divX + 1) + y;
+        for (int y = 0; y <= lodY; y++) {
+            int dataIndex = x * (lodY + 1) + y;
 
             SkPoint left = fLeft.next(), right = fRight.next();
 
             SkPoint s0 = SkPoint::Make((1.0f - v) * top.x() + v * bottom.x(),
                                        (1.0f - v) * top.y() + v * bottom.y());
             SkPoint s1 = SkPoint::Make((1.0f - u) * left.x() + u * right.x(),
                                        (1.0f - u) * left.y() + u * right.y());
             SkPoint s2 = SkPoint::Make(
                                        (1.0f - v) * ((1.0f - u) * fTop.getCtrlPoints()[0].x()
                                         + u * fTop.getCtrlPoints()[3].x())
@@ skipping 22 matching lines @@
                             SkScalar(SkColorGetG(fCornerColors[3])));
             uint8_t b = bilinear(u, v, 
                             SkScalar(SkColorGetB(fCornerColors[0])), 
                             SkScalar(SkColorGetB(fCornerColors[1])), 
                             SkScalar(SkColorGetB(fCornerColors[2])), 
                             SkScalar(SkColorGetB(fCornerColors[3])));
             data->fColors[dataIndex] = SkPackARGB32(a,r,g,b);
             
             data->fTexCoords[dataIndex] = SkPoint::Make(u, v);
 
-            if(x < divX && y < divY) {
-                int i = 6 * (x * divY + y);
+            if(x < lodX && y < lodY) {
+                int i = 6 * (x * lodY + y);
                 data->fIndices[i] = x * stride + y;
                 data->fIndices[i + 1] = x * stride + 1 + y;
                 data->fIndices[i + 2] = (x + 1) * stride + 1 + y;
                 data->fIndices[i + 3] = data->fIndices[i];
                 data->fIndices[i + 4] = data->fIndices[i + 2];
                 data->fIndices[i + 5] = (x + 1) * stride + y;
             }
-            v += 1.f / divY;
+            v += 1.f / lodY;
         }
-        u += 1.f / divX;
+        u += 1.f / lodX;
     }
     return true;
 }