SkCanvas interface for drawing a patch.

src/core/SkDevice.cpp

 /*
  * Copyright 2011 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SkDevice.h"
+#include "SkDraw.h"
 #include "SkMetaData.h"
 
 SkBaseDevice::SkBaseDevice()
     : fLeakyProperties(SkDeviceProperties::MakeDefault())
 #ifdef SK_DEBUG
     , fAttachedToCanvas(false)
 #endif
 {
     fOrigin.setZero();
     fMetaData = NULL;
@@ skipping 51 matching lines @@
     SkPath path;
     path.addRRect(outer);
     path.addRRect(inner);
     path.setFillType(SkPath::kEvenOdd_FillType);
 
     const SkMatrix* preMatrix = NULL;
     const bool pathIsMutable = true;
     this->drawPath(draw, path, paint, preMatrix, pathIsMutable);
 }
 
+void SkBaseDevice::drawPatch(const SkDraw& draw, const SkPatch& patch, const SkPaint& paint) {
+    SkPatch::VertexData data;
+    
+    SkPoint mapPts[12];
+    draw.fMatrix->mapPoints(mapPts, patch.getControlPoints(), 12);
+    
+    // Approximate length of each cubic.
+    int topLength = SkSqrt32(mapPts[SkPatch::kTopP0_CubicCtrlPts]

[egdaniel, 2014/08/01 13:28:52]

This may be a good place for a function that calcs the length given 4 control
points.

Also since this is already used for an approximation of arc length, what are
other people's thoughts on calculating the total square dist between all points
and doing one sqrt at end when getting lodX/Y? Drops us from 12->2 sqrts but
less accurate? Then again maybe its best to keep the over-estimation (where as
my suggestion would under estimate) since not having enough subdivides would
probably be worse that being slower. Thoughts?

[dandov, 2014/08/01 15:11:14]

Created a function in SkGeometry that calculates an approximate arc length using
the control points of a bezier curve. 
I also tried to use the distanceToSqd only but it overestimated a lot and I had
to adjust the partition size kind of arbitrarily, so I will try to come up with
a way to get the level of detail using the squared distances.  

+                             .distanceToSqd(mapPts[SkPatch::kTopP1_CubicCtrlPts])) +

[bsalomon, 2014/08/01 13:30:27]

I'd just give up on trying to reduce sqrts and call distanceTo(). Summing and
then sqrt'ing seems like an unnecessary shortcut.

+                    SkSqrt32(mapPts[SkPatch::kTopP1_CubicCtrlPts]
+                             .distanceToSqd(mapPts[SkPatch::kTopP2_CubicCtrlPts])) +
+                    SkSqrt32(mapPts[SkPatch::kTopP2_CubicCtrlPts]
+                             .distanceToSqd(mapPts[SkPatch::kTopP3_CubicCtrlPts]));
+    int bottomLength = SkSqrt32(mapPts[SkPatch::kBottomP0_CubicCtrlPts]
+                             .distanceToSqd(mapPts[SkPatch::kBottomP1_CubicCtrlPts])) +
+                        SkSqrt32(mapPts[SkPatch::kBottomP1_CubicCtrlPts]
+                                 .distanceToSqd(mapPts[SkPatch::kBottomP2_CubicCtrlPts])) +
+                        SkSqrt32(mapPts[SkPatch::kBottomP2_CubicCtrlPts]
+                                 .distanceToSqd(mapPts[SkPatch::kBottomP3_CubicCtrlPts]));
+    int leftLength = SkSqrt32(mapPts[SkPatch::kLeftP0_CubicCtrlPts]
+                             .distanceToSqd(mapPts[SkPatch::kLeftP1_CubicCtrlPts])) +
+                        SkSqrt32(mapPts[SkPatch::kLeftP1_CubicCtrlPts]
+                                 .distanceToSqd(mapPts[SkPatch::kLeftP2_CubicCtrlPts])) +
+                        SkSqrt32(mapPts[SkPatch::kLeftP2_CubicCtrlPts]
+                                 .distanceToSqd(mapPts[SkPatch::kLeftP3_CubicCtrlPts]));
+    int rightLength = SkSqrt32(mapPts[SkPatch::kRightP0_CubicCtrlPts]
+                             .distanceToSqd(mapPts[SkPatch::kRightP1_CubicCtrlPts])) +
+                        SkSqrt32(mapPts[SkPatch::kRightP1_CubicCtrlPts]
+                                 .distanceToSqd(mapPts[SkPatch::kRightP2_CubicCtrlPts])) +
+                        SkSqrt32(mapPts[SkPatch::kRightP2_CubicCtrlPts]
+                                 .distanceToSqd(mapPts[SkPatch::kRightP3_CubicCtrlPts]));
+    
+    // Level of detail per axis, based on the larger side between top and bottom or left and right
+    int lodX = SkMaxScalar(topLength, bottomLength) / SkPatch::kPartitionSize;
+    int lodY = SkMaxScalar(leftLength, rightLength) / SkPatch::kPartitionSize;
+
+    // It automatically adjusts lodX and lodY in case it exceeds the number of indices.
+    patch.getVertexData(&data, SkMax32(2, lodX), SkMax32(2, lodY));
+    this->drawVertices(draw, SkCanvas::kTriangles_VertexMode, data.fVertexCount, data.fPoints,
+                       data.fTexCoords, data.fColors, NULL, data.fIndices, data.fIndexCount, paint);
+}
+
 bool SkBaseDevice::readPixels(const SkImageInfo& info, void* dstP, size_t rowBytes, int x, int y) {
 #ifdef SK_DEBUG
     SkASSERT(info.width() > 0 && info.height() > 0);
     SkASSERT(dstP);
     SkASSERT(rowBytes >= info.minRowBytes());
     SkASSERT(x >= 0 && y >= 0);
 
     const SkImageInfo& srcInfo = this->imageInfo();
     SkASSERT(x + info.width() <= srcInfo.width());
     SkASSERT(y + info.height() <= srcInfo.height());
@@ skipping 41 matching lines @@
 }
 
 void SkBaseDevice::EXPERIMENTAL_optimize(const SkPicture* picture) {
     // The base class doesn't perform any analysis but derived classes may
 }
 
 bool SkBaseDevice::EXPERIMENTAL_drawPicture(SkCanvas* canvas, const SkPicture* picture) {
     // The base class doesn't perform any accelerated picture rendering
     return false;
 }