Initial CL to move color / coverage off of drawstate

src/gpu/GrInOrderDrawBuffer.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 "GrInOrderDrawBuffer.h"
 
 #include "GrDefaultGeoProcFactory.h"
@@ skipping 48 matching lines @@
 
     The color param is used to determine whether the opaque hint can be set on the draw state.
     The caller must populate the vertex colors itself.
 
     The vertex attrib order is always pos, color, [local coords].
  */
 static void set_vertex_attributes(GrDrawState* drawState, bool hasLocalCoords, GrColor color) {
     uint32_t flags = GrDefaultGeoProcFactory::kPosition_GPType |
                      GrDefaultGeoProcFactory::kColor_GPType;
     flags |= hasLocalCoords ? GrDefaultGeoProcFactory::kLocalCoord_GPType : 0;
-    drawState->setGeometryProcessor(GrDefaultGeoProcFactory::Create(flags))->unref();
+    drawState->setGeometryProcessor(GrDefaultGeoProcFactory::Create(color, flags))->unref();
     if (0xFF == GrColorUnpackA(color)) {
         drawState->setHint(GrDrawState::kVertexColorsAreOpaque_Hint, true);
     }
 }
 
 static bool path_fill_type_is_winding(const GrStencilSettings& pathStencilSettings) {
     static const GrStencilSettings::Face pathFace = GrStencilSettings::kFront_Face;
     bool isWinding = kInvert_StencilOp != pathStencilSettings.passOp(pathFace);
     if (isWinding) {
         // Double check that it is in fact winding.
@@ skipping 23 matching lines @@
     kCmdMask = 0x7f,
 };
 
 static inline uint8_t add_trace_bit(uint8_t cmd) { return cmd | kTraceCmdBit; }
 
 static inline uint8_t strip_trace_bit(uint8_t cmd) { return cmd & kCmdMask; }
 
 static inline bool cmd_has_trace_marker(uint8_t cmd) { return SkToBool(cmd & kTraceCmdBit); }
 
 void GrInOrderDrawBuffer::onDrawRect(GrDrawState* ds,
+                                     GrColor color,
                                      const SkRect& rect,
                                      const SkRect* localRect,
                                      const SkMatrix* localMatrix) {
     GrDrawState::AutoRestoreEffects are(ds);
 
-    GrColor color = ds->getColor();
     set_vertex_attributes(ds, SkToBool(localRect),  color);
 
     size_t vstride = ds->getGeometryProcessor()->getVertexStride();
     SkASSERT(vstride == sizeof(SkPoint) + sizeof(GrColor) + (SkToBool(localRect) ? sizeof(SkPoint) :
                                                                                    0));
     AutoReleaseGeometry geo(this, 4, vstride, 0);
     if (!geo.succeeded()) {
         SkDebugf("Failed to get space for vertices!\n");
         return;
     }
@@ skipping 90 matching lines @@
 
     return instancesToConcat;
 }
 
 void GrInOrderDrawBuffer::onDraw(const GrDrawState& ds,
                                  const DrawInfo& info,
                                  const ScissorState& scissorState,
                                  const GrDeviceCoordTexture* dstCopy) {
     SkASSERT(info.vertexBuffer() && (!info.isIndexed() || info.indexBuffer()));
 
-    if (!this->recordStateAndShouldDraw(ds, GrGpu::PrimTypeToDrawType(info.primitiveType()),
+    const GrGeometryProcessor* gp = ds.getGeometryProcessor();
+    if (!this->recordStateAndShouldDraw(ds, gp->getColor(), gp->getCoverage(),
+                                        GrGpu::PrimTypeToDrawType(info.primitiveType()),
                                         scissorState, dstCopy)) {
         return;
     }
 
     Draw* draw;
     if (info.isInstanced()) {
         int instancesConcated = this->concatInstancedDraw(ds, info);
         if (info.instanceCount() > instancesConcated) {
             draw = GrNEW_APPEND_TO_RECORDER(fCmdBuffer, Draw, (info));
             draw->fInfo.adjustInstanceCount(-instancesConcated);
         } else {
             return;
         }
     } else {
         draw = GrNEW_APPEND_TO_RECORDER(fCmdBuffer, Draw, (info));
     }
     this->recordTraceMarkersIfNecessary();
 }
 
 void GrInOrderDrawBuffer::onStencilPath(const GrDrawState& ds,
                                         const GrPath* path,
                                         const GrClipMaskManager::ScissorState& scissorState,
                                         const GrStencilSettings& stencilSettings) {
     // Only compare the subset of GrDrawState relevant to path stenciling?
-    if (!this->recordStateAndShouldDraw(ds, GrGpu::kStencilPath_DrawType, scissorState, NULL)) {
+    if (!this->recordStateAndShouldDraw(ds, GrColor_WHITE, 0xff, GrGpu::kStencilPath_DrawType,
+                                        scissorState, NULL)) {
         return;
     }
     StencilPath* sp = GrNEW_APPEND_TO_RECORDER(fCmdBuffer, StencilPath, (path));
     sp->fStencilSettings = stencilSettings;
     this->recordTraceMarkersIfNecessary();
 }
 
 void GrInOrderDrawBuffer::onDrawPath(const GrDrawState& ds,
+                                     GrColor color,
                                      const GrPath* path,
                                      const GrClipMaskManager::ScissorState& scissorState,
                                      const GrStencilSettings& stencilSettings,
                                      const GrDeviceCoordTexture* dstCopy) {
     // TODO: Only compare the subset of GrDrawState relevant to path covering?
-    if (!this->recordStateAndShouldDraw(ds, GrGpu::kDrawPath_DrawType, scissorState, dstCopy)) {
+    if (!this->recordStateAndShouldDraw(ds, color, 0xff, GrGpu::kDrawPath_DrawType, scissorState,
+                                        dstCopy)) {
         return;
     }
     DrawPath* dp = GrNEW_APPEND_TO_RECORDER(fCmdBuffer, DrawPath, (path));
     dp->fStencilSettings = stencilSettings;
     this->recordTraceMarkersIfNecessary();
 }
 
 void GrInOrderDrawBuffer::onDrawPaths(const GrDrawState& ds,
+                                      GrColor color,
                                       const GrPathRange* pathRange,
                                       const void* indices,
                                       PathIndexType indexType,
                                       const float transformValues[],
                                       PathTransformType transformType,
                                       int count,
                                       const GrClipMaskManager::ScissorState& scissorState,
                                       const GrStencilSettings& stencilSettings,
                                       const GrDeviceCoordTexture* dstCopy) {
     SkASSERT(pathRange);
     SkASSERT(indices);
     SkASSERT(transformValues);
 
-    if (!this->recordStateAndShouldDraw(ds, GrGpu::kDrawPath_DrawType, scissorState, dstCopy)) {
+    if (!this->recordStateAndShouldDraw(ds, color, 0xff, GrGpu::kDrawPath_DrawType, scissorState,
+                                        dstCopy)) {
         return;
     }
 
     int indexBytes = GrPathRange::PathIndexSizeInBytes(indexType);
     if (int misalign = fPathIndexBuffer.count() % indexBytes) {
         // Add padding to the index buffer so the indices are aligned properly.
         fPathIndexBuffer.append(indexBytes - misalign);
     }
 
     char* savedIndices = fPathIndexBuffer.append(count * indexBytes,
                                                  reinterpret_cast<const char*>(indices));
     float* savedTransforms = fPathTransformBuffer.append(
                                  count * GrPathRendering::PathTransformSize(transformType),
                                  transformValues);
 
     if (kDrawPaths_Cmd == strip_trace_bit(fCmdBuffer.back().fType)) {
         // The previous command was also DrawPaths. Try to collapse this call into the one
         // before. Note that stenciling all the paths at once, then covering, may not be
         // equivalent to two separate draw calls if there is overlap. Blending won't work,
         // and the combined calls may also cancel each other's winding numbers in some
         // places. For now the winding numbers are only an issue if the fill is even/odd,
         // because DrawPaths is currently only used for glyphs, and glyphs in the same
         // font tend to all wind in the same direction.
         DrawPaths* previous = static_cast<DrawPaths*>(&fCmdBuffer.back());
         if (pathRange == previous->pathRange() &&
             indexType == previous->fIndexType &&
             transformType == previous->fTransformType &&
             stencilSettings == previous->fStencilSettings &&
             path_fill_type_is_winding(stencilSettings) &&
-            !ds.willBlendWithDst()) {
+            !ds.willBlendWithDst(color, GrColor_WHITE)) {
             // Fold this DrawPaths call into the one previous.
             previous->fCount += count;
             return;
         }
     }
 
     DrawPaths* dp = GrNEW_APPEND_TO_RECORDER(fCmdBuffer, DrawPaths, (pathRange));
     dp->fIndicesLocation = savedIndices - fPathIndexBuffer.begin();
     dp->fIndexType = indexType;
     dp->fTransformsLocation = savedTransforms - fPathTransformBuffer.begin();
@@ skipping 145 matching lines @@
         CopySurface* cs = GrNEW_APPEND_TO_RECORDER(fCmdBuffer, CopySurface, (dst, src));
         cs->fSrcRect = srcRect;
         cs->fDstPoint = dstPoint;
         this->recordTraceMarkersIfNecessary();
         return true;
     }
     return false;
 }
 
 bool GrInOrderDrawBuffer::recordStateAndShouldDraw(const GrDrawState& ds,
+                                                   GrColor color,
+                                                   uint8_t coverage,
                                                    GrGpu::DrawType drawType,
                                                    const GrClipMaskManager::ScissorState& scissor,
                                                    const GrDeviceCoordTexture* dstCopy) {
     SetState* ss = GrNEW_APPEND_TO_RECORDER(fCmdBuffer, SetState,
-                                            (ds, *this->getGpu()->caps(), scissor, dstCopy,
-                                             drawType));
+                                            (ds, color, coverage, *this->getGpu()->caps(), scissor,
+                                             dstCopy, drawType));
     if (ss->fState.mustSkip()) {
         fCmdBuffer.pop_back();
         return false;
     }
     if (fPrevState && *fPrevState == ss->fState) {
         fCmdBuffer.pop_back();
     } else {
         fPrevState = &ss->fState;
         this->recordTraceMarkersIfNecessary();
     }
     return true;
 }
 
 void GrInOrderDrawBuffer::recordTraceMarkersIfNecessary() {
     SkASSERT(!fCmdBuffer.empty());
     SkASSERT(!cmd_has_trace_marker(fCmdBuffer.back().fType));
     const GrTraceMarkerSet& activeTraceMarkers = this->getActiveTraceMarkers();
     if (activeTraceMarkers.count() > 0) {
         fCmdBuffer.back().fType = add_trace_bit(fCmdBuffer.back().fType);
         fGpuCmdMarkers.push_back(activeTraceMarkers);
     }
 }