AARectBatch can transform coords on cpu

src/gpu/GrAARectRenderer.cpp

 /*
  * Copyright 2012 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "GrAARectRenderer.h"
 #include "GrBatch.h"
 #include "GrBatchTarget.h"
@@ skipping 14 matching lines @@
 
 ///////////////////////////////////////////////////////////////////////////////
 
 static void set_inset_fan(SkPoint* pts, size_t stride,
                           const SkRect& r, SkScalar dx, SkScalar dy) {
     pts->setRectFan(r.fLeft + dx, r.fTop + dy,
                     r.fRight - dx, r.fBottom - dy, stride);
 }
 
 static const GrGeometryProcessor* create_fill_rect_gp(bool tweakAlphaForCoverage,
-                                                      const SkMatrix& viewMatrix,
+                                                      const SkMatrix& localMatrix,
                                                       bool usesLocalCoords,
-                                                      bool coverageIgnored) {
+                                                      bool coverageIgnored,
+                                                      bool transformCoords) {
     using namespace GrDefaultGeoProcFactory;
 
     Color color(Color::kAttribute_Type);
     Coverage::Type coverageType;
     // TODO remove coverage if coverage is ignored
     /*if (coverageIgnored) {
         coverageType = Coverage::kNone_Type;
     } else*/ if (tweakAlphaForCoverage) {
         coverageType = Coverage::kSolid_Type;
     } else {
         coverageType = Coverage::kAttribute_Type;
     }
     Coverage coverage(coverageType);
-    LocalCoords localCoords(usesLocalCoords ? LocalCoords::kUsePosition_Type :
-                                              LocalCoords::kUnused_Type);
-    return CreateForDeviceSpace(color, coverage, localCoords, viewMatrix);
+    LocalCoords::Type localCoordsType;
+    if (usesLocalCoords) {
+        localCoordsType = transformCoords ? LocalCoords::kHasTransformed_Type :
+                                            LocalCoords::kUsePosition_Type;
+    } else {
+        localCoordsType = LocalCoords::kUnused_Type;
+    }
+    LocalCoords localCoords(localCoordsType);
+    if (usesLocalCoords && !transformCoords) {
+        localCoords.fMatrix = &localMatrix;
+    }
+    return Create(color, coverage, localCoords, SkMatrix::I());
 }
 
 GR_DECLARE_STATIC_UNIQUE_KEY(gAAFillRectIndexBufferKey);
 
 class AAFillRectBatch : public GrBatch {
 public:
     struct Geometry {
         GrColor fColor;
         SkMatrix fViewMatrix;
         SkRect fRect;
         SkRect fDevRect;
+        const SkTArray<const GrCoordTransform*, true>* fCoordTransforms;
     };
 
     static GrBatch* Create(const Geometry& geometry) {
         return SkNEW_ARGS(AAFillRectBatch, (geometry));
     }
 
     const char* name() const override { return "AAFillRectBatch"; }
 
     void getInvariantOutputColor(GrInitInvariantOutput* out) const override {
         // When this is called on a batch, there is only one geometry bundle
@@ skipping 15 matching lines @@
         fBatch.fColorIgnored = !init.readsColor();
         fBatch.fColor = fGeoData[0].fColor;
         fBatch.fUsesLocalCoords = init.readsLocalCoords();
         fBatch.fCoverageIgnored = !init.readsCoverage();
         fBatch.fCanTweakAlphaForCoverage = init.canTweakAlphaForCoverage();
     }
 
     void generateGeometry(GrBatchTarget* batchTarget, const GrPipeline* pipeline) override {
         bool canTweakAlphaForCoverage = this->canTweakAlphaForCoverage();
 
-        SkAutoTUnref<const GrGeometryProcessor> gp(create_fill_rect_gp(canTweakAlphaForCoverage,
-                                                                       this->viewMatrix(),
-                                                                       this->usesLocalCoords(),
-                                                                       this->coverageIgnored()));
-        if (!gp) {
-            SkDebugf("Couldn't create GrGeometryProcessor\n");
+        SkMatrix localMatrix;
+        if (this->usesLocalCoords() && !this->viewMatrix().invert(&localMatrix)) {
+            SkDebugf("could not invert viewmatrix\n");
             return;
         }
 
+        SkAutoTUnref<const GrGeometryProcessor> gp(create_fill_rect_gp(canTweakAlphaForCoverage,
+                                                                       localMatrix,
+                                                                       this->usesLocalCoords(),
+                                                                       this->coverageIgnored(),
+                                                                       fTransformLocalCoords));
+
         batchTarget->initDraw(gp, pipeline);
 
         size_t vertexStride = gp->getVertexStride();
-        SkASSERT(canTweakAlphaForCoverage ?
-                 vertexStride == sizeof(GrDefaultGeoProcFactory::PositionColorAttr) :
-                 vertexStride == sizeof(GrDefaultGeoProcFactory::PositionColorCoverageAttr));
+#ifdef SK_DEBUG
+        size_t testStride = sizeof(SkPoint) + sizeof(GrColor);
+        testStride += canTweakAlphaForCoverage ? 0 : sizeof(GrColor);
+        testStride += fTransformLocalCoords ? sizeof(SkPoint) : 0;
+        SkASSERT(testStride == vertexStride);
+#endif
         int instanceCount = fGeoData.count();
 
         SkAutoTUnref<const GrIndexBuffer> indexBuffer(this->getIndexBuffer(
             batchTarget->resourceProvider()));
         InstancedHelper helper;
         void* vertices = helper.init(batchTarget, kTriangles_GrPrimitiveType, vertexStride,
                                      indexBuffer, kVertsPerAAFillRect, kIndicesPerAAFillRect,
                                      instanceCount);
         if (!vertices || !indexBuffer) {
             SkDebugf("Could not allocate vertices\n");
             return;
         }
 
         for (int i = 0; i < instanceCount; i++) {
             const Geometry& args = fGeoData[i];
             this->generateAAFillRectGeometry(vertices,
                                              i * kVertsPerAAFillRect * vertexStride,
                                              vertexStride,
                                              args.fColor,
                                              args.fViewMatrix,
+                                             localMatrix,
                                              args.fRect,
                                              args.fDevRect,
+                                             *args.fCoordTransforms,
                                              canTweakAlphaForCoverage);
         }
 
         helper.issueDraw(batchTarget);
     }
 
     SkSTArray<1, Geometry, true>* geoData() { return &fGeoData; }
 
 private:
     AAFillRectBatch(const Geometry& geometry) {
         this->initClassID<AAFillRectBatch>();
         fGeoData.push_back(geometry);
 
         this->setBounds(geometry.fDevRect);
     }
 
+    void onSetPipeline() override {
+        fTransformLocalCoords = this->pipeline()->coordTransforms().count() == 1 &&
+                                this->usesLocalCoords();
+        fGeoData[0].fCoordTransforms = &this->pipeline()->coordTransforms();
+    }
+
     static const int kNumAAFillRectsInIndexBuffer = 256;
     static const int kVertsPerAAFillRect = 8;
     static const int kIndicesPerAAFillRect = 30;
 
     const GrIndexBuffer* getIndexBuffer(GrResourceProvider* resourceProvider) {
         GR_DEFINE_STATIC_UNIQUE_KEY(gAAFillRectIndexBufferKey);
 
         static const uint16_t gFillAARectIdx[] = {
             0, 1, 5, 5, 4, 0,
             1, 2, 6, 6, 5, 1,
             2, 3, 7, 7, 6, 2,
             3, 0, 4, 4, 7, 3,
             4, 5, 6, 6, 7, 4,
         };
         GR_STATIC_ASSERT(SK_ARRAY_COUNT(gFillAARectIdx) == kIndicesPerAAFillRect);
         return resourceProvider->findOrCreateInstancedIndexBuffer(gFillAARectIdx,
             kIndicesPerAAFillRect, kNumAAFillRectsInIndexBuffer, kVertsPerAAFillRect,
             gAAFillRectIndexBufferKey);
     }
 
     GrColor color() const { return fBatch.fColor; }
     bool usesLocalCoords() const { return fBatch.fUsesLocalCoords; }
     bool canTweakAlphaForCoverage() const { return fBatch.fCanTweakAlphaForCoverage; }
     bool colorIgnored() const { return fBatch.fColorIgnored; }
     const SkMatrix& viewMatrix() const { return fGeoData[0].fViewMatrix; }
     bool coverageIgnored() const { return fBatch.fCoverageIgnored; }
 
     bool onCombineIfPossible(GrBatch* t) override {
-        if (!this->pipeline()->isEqual(*t->pipeline())) {
+        // If we have one coord transform then we will transform on the cpu
+        if (!this->pipeline()->isEqual(*t->pipeline(), fTransformLocalCoords)) {
             return false;
         }
 
         AAFillRectBatch* that = t->cast<AAFillRectBatch>();
 
         SkASSERT(this->usesLocalCoords() == that->usesLocalCoords());
         // We apply the viewmatrix to the rect points on the cpu.  However, if the pipeline uses
         // local coords then we won't be able to batch.  We could actually upload the viewmatrix
         // using vertex attributes in these cases, but haven't investigated that
         if (this->usesLocalCoords() && !this->viewMatrix().cheapEqualTo(that->viewMatrix())) {
@@ skipping 13 matching lines @@
         fGeoData.push_back_n(that->geoData()->count(), that->geoData()->begin());
         this->joinBounds(that->bounds());
         return true;
     }
 
     void generateAAFillRectGeometry(void* vertices,
                                     size_t offset,
                                     size_t vertexStride,
                                     GrColor color,
                                     const SkMatrix& viewMatrix,
+                                    const SkMatrix& localMatrix,
                                     const SkRect& rect,
                                     const SkRect& devRect,
+                                    const SkTArray<const GrCoordTransform*, true>& coordTransforms,
                                     bool tweakAlphaForCoverage) const {
         intptr_t verts = reinterpret_cast<intptr_t>(vertices) + offset;
 
         SkPoint* fan0Pos = reinterpret_cast<SkPoint*>(verts);
         SkPoint* fan1Pos = reinterpret_cast<SkPoint*>(verts + 4 * vertexStride);
 
         SkScalar inset = SkMinScalar(devRect.width(), SK_Scalar1);
         inset = SK_ScalarHalf * SkMinScalar(inset, devRect.height());
 
         if (viewMatrix.rectStaysRect()) {
@@ skipping 30 matching lines @@
             // BR
             *((SkPoint*)((intptr_t)fan1Pos + 2 * vertexStride)) =
                 *((SkPoint*)((intptr_t)fan0Pos + 2 * vertexStride)) - vec[0] - vec[1];
             *((SkPoint*)((intptr_t)fan0Pos + 2 * vertexStride)) += vec[0] + vec[1];
             // TR
             *((SkPoint*)((intptr_t)fan1Pos + 3 * vertexStride)) =
                 *((SkPoint*)((intptr_t)fan0Pos + 3 * vertexStride)) - vec[0] + vec[1];
             *((SkPoint*)((intptr_t)fan0Pos + 3 * vertexStride)) += vec[0] - vec[1];
         }
 
+        if (fTransformLocalCoords) {
+            SkASSERT(coordTransforms.count() == 1);
+            SkMatrix localCoordMatrix =
+                    GrGLPrimitiveProcessor::GetTransformMatrix(localMatrix,
+                                                               *coordTransforms[0]);
+            SkPoint* fan0Loc = reinterpret_cast<SkPoint*>(verts + vertexStride - sizeof(SkPoint));
+            localCoordMatrix.mapPointsWithStride(fan0Loc, fan0Pos, vertexStride, 8);
+        }
+
         // Make verts point to vertex color and then set all the color and coverage vertex attrs
         // values.
         verts += sizeof(SkPoint);
         for (int i = 0; i < 4; ++i) {
             if (tweakAlphaForCoverage) {
                 *reinterpret_cast<GrColor*>(verts + i * vertexStride) = 0;
             } else {
                 *reinterpret_cast<GrColor*>(verts + i * vertexStride) = color;
                 *reinterpret_cast<float*>(verts + i * vertexStride + sizeof(GrColor)) = 0;
             }
@@ skipping 24 matching lines @@
     }
 
     struct BatchTracker {
         GrColor fColor;
         bool fUsesLocalCoords;
         bool fColorIgnored;
         bool fCoverageIgnored;
         bool fCanTweakAlphaForCoverage;
     };
 
+    bool fTransformLocalCoords;
     BatchTracker fBatch;
     SkSTArray<1, Geometry, true> fGeoData;
 };
 
 namespace {
 // Should the coverage be multiplied into the color attrib or use a separate attrib.
 enum CoverageAttribType {
     kUseColor_CoverageAttribType,
     kUseCoverage_CoverageAttribType,
 };
@@ skipping 74 matching lines @@
         devOutsideAssist.outset(0, ry);
     }
 
     GeometryStrokeAARect(target, pipelineBuilder, color, viewMatrix, devOutside,
                          devOutsideAssist, devInside, miterStroke);
 }
 
 GR_DECLARE_STATIC_UNIQUE_KEY(gMiterIndexBufferKey);
 GR_DECLARE_STATIC_UNIQUE_KEY(gBevelIndexBufferKey);
 
+static const GrGeometryProcessor* create_stroke_rect_gp(bool tweakAlphaForCoverage,
+                                                        const SkMatrix& viewMatrix,
+                                                        bool usesLocalCoords,
+                                                        bool coverageIgnored) {
+    using namespace GrDefaultGeoProcFactory;
+
+    Color color(Color::kAttribute_Type);
+    Coverage::Type coverageType;
+    // TODO remove coverage if coverage is ignored
+    /*if (coverageIgnored) {
+        coverageType = Coverage::kNone_Type;
+    } else*/ if (tweakAlphaForCoverage) {
+        coverageType = Coverage::kSolid_Type;
+    } else {
+        coverageType = Coverage::kAttribute_Type;
+    }
+    Coverage coverage(coverageType);
+    LocalCoords localCoords(usesLocalCoords ? LocalCoords::kUsePosition_Type :
+                                              LocalCoords::kUnused_Type);
+    return CreateForDeviceSpace(color, coverage, localCoords, viewMatrix);
+}
+
+
 class AAStrokeRectBatch : public GrBatch {
 public:
     // TODO support AA rotated stroke rects by copying around view matrices
     struct Geometry {
         GrColor fColor;
         SkRect fDevOutside;
         SkRect fDevOutsideAssist;
         SkRect fDevInside;
         bool fMiterStroke;
     };
@@ skipping 25 matching lines @@
         fBatch.fColor = fGeoData[0].fColor;
         fBatch.fUsesLocalCoords = init.readsLocalCoords();
         fBatch.fCoverageIgnored = !init.readsCoverage();
         fBatch.fMiterStroke = fGeoData[0].fMiterStroke;
         fBatch.fCanTweakAlphaForCoverage = init.canTweakAlphaForCoverage();
     }
 
     void generateGeometry(GrBatchTarget* batchTarget, const GrPipeline* pipeline) override {
         bool canTweakAlphaForCoverage = this->canTweakAlphaForCoverage();
 
-        SkAutoTUnref<const GrGeometryProcessor> gp(create_fill_rect_gp(canTweakAlphaForCoverage,
-                                                                       this->viewMatrix(),
-                                                                       this->usesLocalCoords(),
-                                                                       this->coverageIgnored()));
+        SkAutoTUnref<const GrGeometryProcessor> gp(create_stroke_rect_gp(canTweakAlphaForCoverage,
+                                                                         this->viewMatrix(),
+                                                                         this->usesLocalCoords(),
+                                                                         this->coverageIgnored()));
         if (!gp) {
             SkDebugf("Couldn't create GrGeometryProcessor\n");
             return;
         }
 
         batchTarget->initDraw(gp, pipeline);
 
         size_t vertexStride = gp->getVertexStride();
 
         SkASSERT(canTweakAlphaForCoverage ?
@@ skipping 384 matching lines @@
     geo.fColor = GrRandomColor(random);
     geo.fDevOutside = outside;
     geo.fDevOutsideAssist = outsideAssist;
     geo.fDevInside = inside;
     geo.fMiterStroke = miterStroke;
 
     return AAStrokeRectBatch::Create(geo, GrTest::TestMatrix(random));
 }
 
 #endif