Remove uniform color for GrDistanceFieldGeoProc

src/gpu/batches/GrAADistanceFieldPathRenderer.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 "GrAADistanceFieldPathRenderer.h"
 
@@ skipping 124 matching lines @@
                 if (fStroke.getWidth() < 0) {
                     fStroke.setStrokeStyle(-1.0f);
                 }
             }
         }
         SkPath fPath;
         // The unique ID of the path involved in this draw. This may be different than the ID
         // in fPath since that path may have resulted from a SkStrokeRec::applyToPath call.
         uint32_t fGenID;
         SkStrokeRec fStroke;
+        GrColor fColor;
         bool fAntiAlias;
     };
 
-    static GrDrawBatch* Create(const Geometry& geometry, GrColor color, const SkMatrix& viewMatrix,
+    static GrDrawBatch* Create(const Geometry& geometry, const SkMatrix& viewMatrix,
                                GrBatchAtlas* atlas, PathCache* pathCache, PathDataList* pathList) {
-        return new AADistanceFieldPathBatch(geometry, color, viewMatrix, atlas, pathCache,
-                                            pathList);
+        return new AADistanceFieldPathBatch(geometry, viewMatrix, atlas, pathCache, pathList);
     }
 
     const char* name() const override { return "AADistanceFieldPathBatch"; }
 
     void computePipelineOptimizations(GrInitInvariantOutput* color, 
                                       GrInitInvariantOutput* coverage,
                                       GrBatchToXPOverrides* overrides) const override {
-        color->setKnownFourComponents(fBatch.fColor);
+        color->setKnownFourComponents(fGeoData[0].fColor);
         coverage->setUnknownSingleComponent();
         overrides->fUsePLSDstRead = false;
     }
 
 private:
     void initBatchTracker(const GrXPOverridesForBatch& overrides) override {
         // Handle any color overrides
         if (!overrides.readsColor()) {
-            fBatch.fColor = GrColor_ILLEGAL;
+            fGeoData[0].fColor = GrColor_ILLEGAL;
         }
-        overrides.getOverrideColorIfSet(&fBatch.fColor);
+        overrides.getOverrideColorIfSet(&fGeoData[0].fColor);
 
         // setup batch properties
         fBatch.fColorIgnored = !overrides.readsColor();
         fBatch.fUsesLocalCoords = overrides.readsLocalCoords();
         fBatch.fCoverageIgnored = !overrides.readsCoverage();
     }
 
     struct FlushInfo {
         SkAutoTUnref<const GrVertexBuffer> fVertexBuffer;
         SkAutoTUnref<const GrIndexBuffer>  fIndexBuffer;
@@ skipping 24 matching lines @@
                                                    params,
                                                    flags,
                                                    this->usesLocalCoords()));
 
         target->initDraw(dfProcessor, this->pipeline());
 
         FlushInfo flushInfo;
 
         // allocate vertices
         size_t vertexStride = dfProcessor->getVertexStride();
-        SkASSERT(vertexStride == 2 * sizeof(SkPoint));
+        SkASSERT(vertexStride == 2 * sizeof(SkPoint) + sizeof(GrColor));
 
         const GrVertexBuffer* vertexBuffer;
         void* vertices = target->makeVertexSpace(vertexStride,
                                                  kVerticesPerQuad * instanceCount,
                                                  &vertexBuffer,
                                                  &flushInfo.fVertexOffset);
         flushInfo.fVertexBuffer.reset(SkRef(vertexBuffer));
         flushInfo.fIndexBuffer.reset(target->resourceProvider()->refQuadIndexBuffer());
         if (!vertices || !flushInfo.fIndexBuffer) {
             SkDebugf("Could not allocate vertices\n");
@@ skipping 45 matching lines @@
                     SkDebugf("Can't rasterize path\n");
                     return;
                 }
             }
 
             atlas->setLastUseToken(pathData->fID, target->currentToken());
 
             // Now set vertices
             intptr_t offset = reinterpret_cast<intptr_t>(vertices);
             offset += i * kVerticesPerQuad * vertexStride;
-            SkPoint* positions = reinterpret_cast<SkPoint*>(offset);
             this->writePathVertices(target,
                                     atlas,
                                     this->pipeline(),
                                     dfProcessor,
-                                    positions,
+                                    offset,
+                                    args.fColor,
                                     vertexStride,
                                     this->viewMatrix(),
                                     args.fPath,
                                     pathData);
             flushInfo.fInstancesToFlush++;
         }
 
         this->flush(target, &flushInfo);
     }
 
     SkSTArray<1, Geometry, true>* geoData() { return &fGeoData; }
 
-    AADistanceFieldPathBatch(const Geometry& geometry, GrColor color, const SkMatrix& viewMatrix,
+    AADistanceFieldPathBatch(const Geometry& geometry,
+                             const SkMatrix& viewMatrix,
                              GrBatchAtlas* atlas,
                              PathCache* pathCache, PathDataList* pathList)
         : INHERITED(ClassID()) {
-        fBatch.fColor = color;
         fBatch.fViewMatrix = viewMatrix;
         fGeoData.push_back(geometry);
 
         fAtlas = atlas;
         fPathCache = pathCache;
         fPathList = pathList;
 
         // Compute bounds
         fBounds = geometry.fPath.getBounds();
         viewMatrix.mapRect(&fBounds);
@@ skipping 116 matching lines @@
 #ifdef DF_PATH_TRACKING
         ++g_NumCachedPaths;
 #endif
         return true;
     }
 
     void writePathVertices(GrDrawBatch::Target* target,
                            GrBatchAtlas* atlas,
                            const GrPipeline* pipeline,
                            const GrGeometryProcessor* gp,
-                           SkPoint* positions,
+                           intptr_t offset,
+                           GrColor color,
                            size_t vertexStride,
                            const SkMatrix& viewMatrix,
                            const SkPath& path,
                            const PathData* pathData) const {
         GrTexture* texture = atlas->getTexture();
 
         SkScalar dx = pathData->fBounds.fLeft;
         SkScalar dy = pathData->fBounds.fTop;
         SkScalar width = pathData->fBounds.width();
         SkScalar height = pathData->fBounds.height();
 
         SkScalar invScale = 1.0f / pathData->fScale;
         dx *= invScale;
         dy *= invScale;
         width *= invScale;
         height *= invScale;
 
         SkFixed tx = SkIntToFixed(pathData->fAtlasLocation.fX);
         SkFixed ty = SkIntToFixed(pathData->fAtlasLocation.fY);
         SkFixed tw = SkScalarToFixed(pathData->fBounds.width());
         SkFixed th = SkScalarToFixed(pathData->fBounds.height());
 
+        SkPoint* positions = reinterpret_cast<SkPoint*>(offset);
+
         // vertex positions
         // TODO make the vertex attributes a struct
         SkRect r = SkRect::MakeXYWH(dx, dy, width, height);
         positions->setRectFan(r.left(), r.top(), r.right(), r.bottom(), vertexStride);
 
+        // colors
+        for (int i = 0; i < kVerticesPerQuad; i++) {
+            GrColor* colorPtr = (GrColor*)(offset + sizeof(SkPoint) + i * vertexStride);
+            *colorPtr = color;
+        }
+
         // vertex texture coords
-        SkPoint* textureCoords = positions + 1;
+        SkPoint* textureCoords = (SkPoint*)(offset + sizeof(SkPoint) + sizeof(GrColor));
         textureCoords->setRectFan(SkFixedToFloat(texture->texturePriv().normalizeFixedX(tx)),
                                   SkFixedToFloat(texture->texturePriv().normalizeFixedY(ty)),
                                   SkFixedToFloat(texture->texturePriv().normalizeFixedX(tx + tw)),
                                   SkFixedToFloat(texture->texturePriv().normalizeFixedY(ty + th)),
                                   vertexStride);
     }
 
     void flush(GrVertexBatch::Target* target, FlushInfo* flushInfo) const {
         GrVertices vertices;
         int maxInstancesPerDraw = flushInfo->fIndexBuffer->maxQuads();
         vertices.initInstanced(kTriangles_GrPrimitiveType, flushInfo->fVertexBuffer,
             flushInfo->fIndexBuffer, flushInfo->fVertexOffset, kVerticesPerQuad,
             kIndicesPerQuad, flushInfo->fInstancesToFlush, maxInstancesPerDraw);
         target->draw(vertices);
         flushInfo->fVertexOffset += kVerticesPerQuad * flushInfo->fInstancesToFlush;
         flushInfo->fInstancesToFlush = 0;
     }
 
-    GrColor color() const { return fBatch.fColor; }
+    GrColor color() const { return fGeoData[0].fColor; }
     const SkMatrix& viewMatrix() const { return fBatch.fViewMatrix; }
     bool usesLocalCoords() const { return fBatch.fUsesLocalCoords; }
 
     bool onCombineIfPossible(GrBatch* t, const GrCaps& caps) override {
         AADistanceFieldPathBatch* that = t->cast<AADistanceFieldPathBatch>();
         if (!GrPipeline::CanCombine(*this->pipeline(), this->bounds(), *that->pipeline(),
                                     that->bounds(), caps)) {
             return false;
         }
 
-        // TODO we could actually probably do a bunch of this work on the CPU, ie map viewMatrix,
-        // maybe upload color via attribute
-        if (this->color() != that->color()) {
-            return false;
-        }
-
+        // TODO We can position on the cpu
         if (!this->viewMatrix().cheapEqualTo(that->viewMatrix())) {
             return false;
         }
 
         fGeoData.push_back_n(that->geoData()->count(), that->geoData()->begin());
         this->joinBounds(that->bounds());
         return true;
     }
 
     struct BatchTracker {
-        GrColor fColor;
         SkMatrix fViewMatrix;
         bool fUsesLocalCoords;
         bool fColorIgnored;
         bool fCoverageIgnored;
     };
 
     BatchTracker fBatch;
     SkSTArray<1, Geometry, true> fGeoData;
     GrBatchAtlas* fAtlas;
     PathCache* fPathCache;
@@ skipping 18 matching lines @@
             return false;
         }
     }
 
     AADistanceFieldPathBatch::Geometry geometry(*args.fStroke);
     if (SkStrokeRec::kFill_Style == args.fStroke->getStyle()) {
         geometry.fPath = *args.fPath;
     } else {
         args.fStroke->applyToPath(&geometry.fPath, *args.fPath);
     }
+    geometry.fColor = args.fColor;
     geometry.fAntiAlias = args.fAntiAlias;
     // Note: this is the generation ID of the _original_ path. When a new path is
     // generated due to stroking it is important that the original path's id is used
     // for caching.
     geometry.fGenID = args.fPath->getGenerationID();
  
-    SkAutoTUnref<GrDrawBatch> batch(AADistanceFieldPathBatch::Create(geometry, args.fColor,
+    SkAutoTUnref<GrDrawBatch> batch(AADistanceFieldPathBatch::Create(geometry,
                                                                      *args.fViewMatrix, fAtlas,
                                                                      &fPathCache, &fPathList));
     args.fTarget->drawBatch(*args.fPipelineBuilder, batch);
 
     return true;
 }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
 #ifdef GR_TEST_UTILS
@@ skipping 51 matching lines @@
                                                      ATLAS_TEXTURE_WIDTH, ATLAS_TEXTURE_HEIGHT,
                                                      NUM_PLOTS_X, NUM_PLOTS_Y,
                                                      &PathTestStruct::HandleEviction,
                                                      (void*)&gTestStruct);
     }
 
     SkMatrix viewMatrix = GrTest::TestMatrix(random);
     GrColor color = GrRandomColor(random);
 
     AADistanceFieldPathBatch::Geometry geometry(GrTest::TestStrokeRec(random));
+    geometry.fColor = color;
     geometry.fPath = GrTest::TestPath(random);
     geometry.fAntiAlias = random->nextBool();
     geometry.fGenID = random->nextU();
 
-    return AADistanceFieldPathBatch::Create(geometry, color, viewMatrix,
+    return AADistanceFieldPathBatch::Create(geometry, viewMatrix,
                                             gTestStruct.fAtlas,
                                             &gTestStruct.fPathCache,
                                             &gTestStruct.fPathList);
 }
 
 #endif