Attach GrOptDrawState into shader building pipeline

src/gpu/gl/GrGpuGL_program.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 "GrGpuGL.h"
 
 #include "GrEffect.h"
 #include "GrGLEffect.h"
+#include "GrGLPathRendering.h"
+#include "GrOptDrawState.h"
 #include "SkRTConf.h"
-#include "GrGLPathRendering.h"
 #include "SkTSearch.h"
 
 #ifdef PROGRAM_CACHE_STATS
 SK_CONF_DECLARE(bool, c_DisplayCache, "gpu.displayCache", false,
                 "Display program cache usage.");
 #endif
 
 typedef GrGLProgramDataManager::UniformHandle UniformHandle;
 
 struct GrGpuGL::ProgramCache::Entry {
@@ skipping 173 matching lines @@
     }
     ++fCurrLRUStamp;
     return entry->fProgram;
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 
 #define GL_CALL(X) GR_GL_CALL(this->glInterface(), X)
 
 bool GrGpuGL::flushGraphicsState(DrawType type, const GrDeviceCoordTexture* dstCopy) {
-    const GrDrawState& drawState = this->getDrawState();
+    SkAutoTUnref<GrOptDrawState> optState(this->getDrawState().createOptState());
 
     // GrGpu::setupClipAndFlushState should have already checked this and bailed if not true.
-    SkASSERT(drawState.getRenderTarget());
+    SkASSERT(optState->getRenderTarget());
 
     if (kStencilPath_DrawType == type) {
-        const GrRenderTarget* rt = this->getDrawState().getRenderTarget();
+        const GrRenderTarget* rt = optState->getRenderTarget();
         SkISize size;
         size.set(rt->width(), rt->height());
-        this->glPathRendering()->setProjectionMatrix(drawState.getViewMatrix(), size, rt->origin());
+        this->glPathRendering()->setProjectionMatrix(optState->getViewMatrix(), size, rt->origin());
     } else {
         this->flushMiscFixedFunctionState();
 
-        GrBlendCoeff srcCoeff;
-        GrBlendCoeff dstCoeff;
-        GrDrawState::BlendOptFlags blendOpts = drawState.getBlendOpts(false, &srcCoeff, &dstCoeff);
-        if (GrDrawState::kSkipDraw_BlendOptFlag & blendOpts) {
+        GrBlendCoeff srcCoeff = optState->getSrcBlendCoeff();
+        GrBlendCoeff dstCoeff = optState->getDstBlendCoeff();
+
+        // In these blend coeff's we end up drawing nothing so we can skip draw all together
+        if (kZero_GrBlendCoeff == srcCoeff && kOne_GrBlendCoeff == dstCoeff &&
+            !optState->getStencil().doesWrite()) {
             return false;
         }
 
         const GrEffectStage* geometryProcessor = NULL;
         SkSTArray<8, const GrEffectStage*, true> colorStages;
         SkSTArray<8, const GrEffectStage*, true> coverageStages;
         GrGLProgramDesc desc;
-        if (!GrGLProgramDesc::Build(this->getDrawState(),
+        if (!GrGLProgramDesc::Build(*optState.get(),
                                type,
-                               blendOpts,
                                srcCoeff,
                                dstCoeff,
                                this,
                                dstCopy,
                                &geometryProcessor,
                                &colorStages,
                                &coverageStages,
                                &desc)) {
             SkDEBUGFAIL("Failed to generate GL program descriptor");
             return false;
@@ skipping 12 matching lines @@
 
         GrGLuint programID = fCurrentProgram->programID();
         if (fHWProgramID != programID) {
             GL_CALL(UseProgram(programID));
             fHWProgramID = programID;
         }
 
         fCurrentProgram->overrideBlend(&srcCoeff, &dstCoeff);
         this->flushBlend(kDrawLines_DrawType == type, srcCoeff, dstCoeff);
 
-        fCurrentProgram->setData(type,
-                                 blendOpts,
+        fCurrentProgram->setData(*optState.get(),
+                                 type,
                                  geometryProcessor,
                                  colorStages.begin(),
                                  coverageStages.begin(),
                                  dstCopy,
                                  &fSharedGLProgramState);
     }
 
-    GrGLRenderTarget* glRT = static_cast<GrGLRenderTarget*>(drawState.getRenderTarget());
+    GrGLRenderTarget* glRT = static_cast<GrGLRenderTarget*>(optState->getRenderTarget());
     this->flushStencil(type);
     this->flushScissor(glRT->getViewport(), glRT->origin());
     this->flushAAState(type);
 
     SkIRect* devRect = NULL;
     SkIRect devClipBounds;
-    if (drawState.isClipState()) {
-        this->getClip()->getConservativeBounds(drawState.getRenderTarget(), &devClipBounds);
+    if (optState->isClipState()) {
+        this->getClip()->getConservativeBounds(optState->getRenderTarget(), &devClipBounds);
         devRect = &devClipBounds;
     }
     // This must come after textures are flushed because a texture may need
     // to be msaa-resolved (which will modify bound FBO state).
     this->flushRenderTarget(glRT, devRect);
 
     return true;
 }
 
 void GrGpuGL::setupGeometry(const DrawInfo& info, size_t* indexOffsetInBytes) {
+    SkAutoTUnref<GrOptDrawState> optState(this->getDrawState().createOptState());
 
-    GrGLsizei stride = static_cast<GrGLsizei>(this->getDrawState().getVertexStride());
+    GrGLsizei stride = static_cast<GrGLsizei>(optState->getVertexStride());
 
     size_t vertexOffsetInBytes = stride * info.startVertex();
 
     const GeometryPoolState& geoPoolState = this->getGeomPoolState();
 
     GrGLVertexBuffer* vbuf;
     switch (this->getGeomSrc().fVertexSrc) {
         case kBuffer_GeometrySrcType:
             vbuf = (GrGLVertexBuffer*) this->getGeomSrc().fVertexBuffer;
             break;
@@ skipping 33 matching lines @@
         }
 
         SkASSERT(ibuf);
         SkASSERT(!ibuf->isMapped());
         *indexOffsetInBytes += ibuf->baseOffset();
     }
     GrGLAttribArrayState* attribState =
         fHWGeometryState.bindArrayAndBuffersToDraw(this, vbuf, ibuf);
 
     if (fCurrentProgram->hasVertexShader()) {
-        int vertexAttribCount = this->getDrawState().getVertexAttribCount();
+        int vertexAttribCount = optState->getVertexAttribCount();
         uint32_t usedAttribArraysMask = 0;
-        const GrVertexAttrib* vertexAttrib = this->getDrawState().getVertexAttribs();
-
-        bool canIgnoreColorAttrib = this->getDrawState().canIgnoreColorAttribute();
+        const GrVertexAttrib* vertexAttrib = optState->getVertexAttribs();
 
         for (int vertexAttribIndex = 0; vertexAttribIndex < vertexAttribCount;
              ++vertexAttribIndex, ++vertexAttrib) {
-
-            if (kColor_GrVertexAttribBinding != vertexAttrib->fBinding || !canIgnoreColorAttrib) {
             usedAttribArraysMask |= (1 << vertexAttribIndex);
             GrVertexAttribType attribType = vertexAttrib->fType;
             attribState->set(this,
                              vertexAttribIndex,
                              vbuf,
                              GrGLAttribTypeToLayout(attribType).fCount,
                              GrGLAttribTypeToLayout(attribType).fType,
                              GrGLAttribTypeToLayout(attribType).fNormalized,
                              stride,
                              reinterpret_cast<GrGLvoid*>(
                                  vertexOffsetInBytes + vertexAttrib->fOffset));
-            }
         }
         attribState->disableUnusedArrays(this, usedAttribArraysMask);
     }
 }