SkCanvas::drawPatch param SkPoint[12]

include/core/SkPatch.h

 /*
  * Copyright 2014 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #ifndef SkPatch_DEFINED
 #define SkPatch_DEFINED
 
 #include "SkColor.h"
 #include "SkPreConfig.h"
 #include "SkPoint.h"
+#include "SkRect.h"
 
 /**
  * Class that represents a coons patch.
  */
 class SK_API SkPatch {
 
 public:
     /**
      * Structure that holds the vertex data related to the tessellation of a SkPatch. It is passed 
      * as a parameter to the function getVertexData which sets the points, colors and texture 
@@ skipping 38 matching lines @@
         kBottomP1_CubicCtrlPts = 8,
         kBottomP2_CubicCtrlPts = 7,
         kBottomP3_CubicCtrlPts = 6,
         
         kLeftP0_CubicCtrlPts = 0,
         kLeftP1_CubicCtrlPts = 11,
         kLeftP2_CubicCtrlPts = 10,
         kLeftP3_CubicCtrlPts = 9,
     };
     
-    // Enum for corner colors also clockwise.
-    enum CornerColors {
-        kTopLeft_CornerColors = 0,
-        kTopRight_CornerColors,
-        kBottomRight_CornerColors,
-        kBottomLeft_CornerColors
+    // Enum for corner also clockwise.
+    enum Corner {
+        kTopLeft_Corner = 0,
+        kTopRight_Corner,
+        kBottomRight_Corner,
+        kBottomLeft_Corner
     };
     
     enum {
         kNumCtrlPts = 12,
-        kNumColors = 4,
+        kNumCorners = 4,
         kNumPtsCubic = 4
     };
     
     /**
      * Points are in the following order:
      *              (top curve)
      *                0 1 2 3
      * (left curve)  11     4   (right curve)
      *               10     5
      *                9 8 7 6
      *              (bottom curve)
      */
     SkPatch() { }
-    SkPatch(const SkPoint points[12], const SkColor colors[4]);
+    SkPatch(const SkPoint points[12]);
 
     /**
      * Function that evaluates the coons patch interpolation.
      * data refers to the pointer of the PatchData struct in which the tessellation data is set.
      * lod refers the level of detail for each axis.
      */
-    bool getVertexData(SkPatch::VertexData* data, int lodX, int lodY) const;
+    bool getVertexData(SkPatch::VertexData* data, const SkColor colors[4],
+                       const SkPoint texCoords[4], int lodX, int lodY) const;
 
     void getTopPoints(SkPoint points[4]) const {
+        if (NULL == points) {
+            return;
+        }
         points[0] = fCtrlPoints[kTopP0_CubicCtrlPts];
         points[1] = fCtrlPoints[kTopP1_CubicCtrlPts];
         points[2] = fCtrlPoints[kTopP2_CubicCtrlPts];
         points[3] = fCtrlPoints[kTopP3_CubicCtrlPts];
     }
     
     void getBottomPoints(SkPoint points[4]) const {
+        if (NULL == points) {
+            return;
+        }
         points[0] = fCtrlPoints[kBottomP0_CubicCtrlPts];
         points[1] = fCtrlPoints[kBottomP1_CubicCtrlPts];
         points[2] = fCtrlPoints[kBottomP2_CubicCtrlPts];
         points[3] = fCtrlPoints[kBottomP3_CubicCtrlPts];
     }
 
     void getLeftPoints(SkPoint points[4]) const {
+        if (NULL == points) {
+            return;
+        }
         points[0] = fCtrlPoints[kLeftP0_CubicCtrlPts];
         points[1] = fCtrlPoints[kLeftP1_CubicCtrlPts];
         points[2] = fCtrlPoints[kLeftP2_CubicCtrlPts];
         points[3] = fCtrlPoints[kLeftP3_CubicCtrlPts];
     }
 
     void getRightPoints(SkPoint points[4]) const {
+        if (NULL == points) {
+            return;
+        }
         points[0] = fCtrlPoints[kRightP0_CubicCtrlPts];
         points[1] = fCtrlPoints[kRightP1_CubicCtrlPts];
         points[2] = fCtrlPoints[kRightP2_CubicCtrlPts];
         points[3] = fCtrlPoints[kRightP3_CubicCtrlPts];
     }
     
     void getCornerPoints(SkPoint points[4]) const {
+        if (NULL == points) {
+            return;
+        }
         points[0] = fCtrlPoints[kTopP0_CubicCtrlPts];
         points[1] = fCtrlPoints[kTopP3_CubicCtrlPts];
         points[2] = fCtrlPoints[kBottomP3_CubicCtrlPts];
         points[3] = fCtrlPoints[kBottomP0_CubicCtrlPts];
     }
     
+    const SkRect getBounds() const;
+    
     const SkPoint* getControlPoints() const {
         return fCtrlPoints;
     }
-    
-    const SkColor* getColors() const {
-        return fCornerColors;
-    }
-    
-    void setPoints(const SkPoint points[12]) {
+
+    void reset(const SkPoint points[12]) {
         memcpy(fCtrlPoints, points, kNumCtrlPts * sizeof(SkPoint));
     }
-    
-    void setColors(const SkColor colors[4]) {
-        memcpy(fCornerColors, colors, kNumColors * sizeof(SkColor));
-    }
-
-    void reset(const SkPoint points[12], const SkColor colors[4]) {
-        this->setPoints(points);
-        this->setColors(colors);
-    }
 
     /**
      *  Write the patch to the buffer, and return the number of bytes written.
      *  If buffer is NULL, it still returns the number of bytes.
      */
     size_t writeToMemory(void* buffer) const;
     
     /**
      * Initializes the patch from the buffer
      *
      * buffer Memory to read from
      * length Amount of memory available in the buffer
      * returns the number of bytes read (must be a multiple of 4) or
      *         0 if there was not enough memory available
      */
     size_t readFromMemory(const void* buffer, size_t length);
     
 private:
     SkPoint fCtrlPoints[kNumCtrlPts];
-    SkColor fCornerColors[kNumColors];
+};
+
+/**
+ * Evaluator to sample the values of a cubic bezier using forward differences.
+ * Forward differences is a method for evaluating a nth degree polynomial at a uniform step by only
+ * adding precalculated values.
+ * For a linear example we have the function f(t) = m*t+b, then the value of that function at t+h
+ * would be f(t+h) = m*(t+h)+b. If we want to know the uniform step that we must add to the first
+ * evaluation f(t) then we need to substract f(t+h) - f(t) = m*t + m*h + b - m*t + b = mh. After
+ * obtaining this value (mh) we could just add this constant step to our first sampled point
+ * to compute the next one.
+ *
+ * For the cubic case the first difference gives as a result a quadratic polynomial to which we can
+ * apply again forward differences and get linear function to which we can apply again forward
+ * differences to get a constant difference. This is why we keep an array of size 4, the 0th
+ * position keeps the sampled value while the next ones keep the quadratic, linear and constant
+ * difference values.
+ */
+
+class FwDCubicEvaluator {
+    
+public:
+    FwDCubicEvaluator();
+    
+    /**
+     * Receives the 4 control points of the cubic bezier.
+     */
+    FwDCubicEvaluator(SkPoint a, SkPoint b, SkPoint c, SkPoint d);
+    
+    explicit FwDCubicEvaluator(const SkPoint points[4]);
+    
+    /**
+     * Restarts the forward differences evaluator to the first value of t = 0.
+     */
+    void restart(int divisions);
+    
+    /**
+     * Check if the evaluator is still within the range of 0<=t<=1
+     */
+    bool done() const {
+        return fCurrent > fMax;
+    }
+    
+    /**
+     * Call next to obtain the SkPoint sampled and move to the next one.
+     */
+    SkPoint next() {
+        SkPoint point = fFwDiff[0];
+        fFwDiff[0]    += fFwDiff[1];
+        fFwDiff[1]    += fFwDiff[2];
+        fFwDiff[2]    += fFwDiff[3];
+        fCurrent++;
+        return point;
+    }
+    
+    const SkPoint* getCtrlPoints() const {
+        return fPoints;
+    }
+    
+private:
+    int fMax, fCurrent, fDivisions;
+    SkPoint fFwDiff[4], fCoefs[4], fPoints[4];
 };
 
 #endif