Snap optdrawstate in inorder draw buffer and pass into gpu

src/gpu/GrGpu.cpp

 
 /*
  * Copyright 2010 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 
 #include "GrGpu.h"
 
 #include "GrBufferAllocPool.h"
 #include "GrContext.h"
 #include "GrDrawTargetCaps.h"
 #include "GrIndexBuffer.h"
 #include "GrStencilBuffer.h"
 #include "GrVertexBuffer.h"
 
 ////////////////////////////////////////////////////////////////////////////////
 
 #define DEBUG_INVAL_BUFFER    0xdeadcafe
 #define DEBUG_INVAL_START_IDX -1
 
 GrGpu::GrGpu(GrContext* context)
     : fResetTimestamp(kExpiredTimestamp+1)
     , fResetBits(kAll_GrBackendState)
     , fQuadIndexBuffer(NULL)
     , fContext(context) {
-    fDrawState = &fDefaultDrawState;
-    // We assume that fDrawState always owns a ref to the object it points at.
-    fDefaultDrawState.ref();
 }
 
 GrGpu::~GrGpu() {
     SkSafeSetNull(fQuadIndexBuffer);
-    SkSafeUnref(fDrawState);
     SkSafeUnref(fGeoSrcState.fVertexBuffer);
     SkSafeUnref(fGeoSrcState.fIndexBuffer);
 }
 
 void GrGpu::contextAbandoned() {}
 
 ////////////////////////////////////////////////////////////////////////////////
 
 GrTexture* GrGpu::createTexture(const GrSurfaceDesc& desc,
                                 const void* srcData, size_t rowBytes) {
@@ skipping 136 matching lines @@
                   bool canIgnoreRect,
                   GrRenderTarget* renderTarget) {
     SkASSERT(renderTarget);
     this->handleDirtyContext();
     this->onClear(renderTarget, rect, color, canIgnoreRect);
 }
 
 void GrGpu::clearStencilClip(const SkIRect& rect,
                              bool insideClip,
                              GrRenderTarget* renderTarget) {
-    if (NULL == renderTarget) {
-        renderTarget = this->getDrawState().getRenderTarget();
-    }
-    if (NULL == renderTarget) {
-        SkASSERT(0);
-        return;
-    }
+    SkASSERT(renderTarget);
     this->handleDirtyContext();
     this->onClearStencilClip(renderTarget, rect, insideClip);
 }
 
 bool GrGpu::readPixels(GrRenderTarget* target,
                        int left, int top, int width, int height,
                        GrPixelConfig config, void* buffer,
                        size_t rowBytes) {
     this->handleDirtyContext();
     return this->onReadPixels(target, left, top, width, height,
@@ skipping 56 matching lines @@
 
 void GrGpu::removeGpuTraceMarker(const GrGpuTraceMarker* marker) {
     if (this->caps()->gpuTracingSupport()) {
         SkASSERT(fGpuTraceMarkerCount >= 1);
         this->fActiveTraceMarkers.remove(*marker);
         this->didRemoveGpuTraceMarker();
         --fGpuTraceMarkerCount;
     }
 }
 
-void GrGpu::setVertexSourceToBuffer(const GrVertexBuffer* buffer) {
+void GrGpu::setVertexSourceToBuffer(const GrVertexBuffer* buffer, size_t vertexStride) {
     SkSafeUnref(fGeoSrcState.fVertexBuffer);
     fGeoSrcState.fVertexBuffer = buffer;
     buffer->ref();
-    fGeoSrcState.fVertexSize = this->drawState()->getVertexStride();
+    fGeoSrcState.fVertexSize = vertexStride;
 }
 
 void GrGpu::setIndexSourceToBuffer(const GrIndexBuffer* buffer) {
     SkSafeUnref(fGeoSrcState.fIndexBuffer);
     fGeoSrcState.fIndexBuffer = buffer;
     buffer->ref();
 }
 
-void GrGpu::setDrawState(GrDrawState*  drawState) {
-    SkASSERT(fDrawState);
-    if (NULL == drawState) {
-        drawState = &fDefaultDrawState;
-    }
-    if (fDrawState != drawState) {
-        fDrawState->unref();
-        drawState->ref();
-        fDrawState = drawState;
-    }
-}
-
 ////////////////////////////////////////////////////////////////////////////////
 
 static const int MAX_QUADS = 1 << 12; // max possible: (1 << 14) - 1;
 
 GR_STATIC_ASSERT(4 * MAX_QUADS <= 65535);
 
 static const uint16_t gQuadIndexPattern[] = {
   0, 1, 2, 0, 2, 3
 };
 
 const GrIndexBuffer* GrGpu::getQuadIndexBuffer() const {
     if (NULL == fQuadIndexBuffer || fQuadIndexBuffer->wasDestroyed()) {
         SkSafeUnref(fQuadIndexBuffer);
         GrGpu* me = const_cast<GrGpu*>(this);
         fQuadIndexBuffer = me->createInstancedIndexBuffer(gQuadIndexPattern,
                                                           6,
                                                           MAX_QUADS,
                                                           4);
     }
 
     return fQuadIndexBuffer;
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 
-void GrGpu::draw(const GrDrawTarget::DrawInfo& info,
-                   const GrClipMaskManager::ScissorState& scissorState) {
+void GrGpu::draw(const GrOptDrawState& ds,
+                 const GrDrawTarget::DrawInfo& info,
+                 const GrClipMaskManager::ScissorState& scissorState) {
     this->handleDirtyContext();
-    if (!this->flushGraphicsState(PrimTypeToDrawType(info.primitiveType()),
+    if (!this->flushGraphicsState(ds,
+                                  PrimTypeToDrawType(info.primitiveType()),
                                   scissorState,
                                   info.getDstCopy())) {
         return;
     }
-    this->onDraw(info);
+    this->onDraw(ds, info);
 }
 
-void GrGpu::stencilPath(const GrPath* path,
-                          const GrClipMaskManager::ScissorState& scissorState,
-                          const GrStencilSettings& stencilSettings) {
+void GrGpu::stencilPath(const GrOptDrawState& ds,
+                        const GrPath* path,
+                        const GrClipMaskManager::ScissorState& scissorState,
+                        const GrStencilSettings& stencilSettings) {
     this->handleDirtyContext();
 
-    if (!this->flushGraphicsState(kStencilPath_DrawType, scissorState, NULL)) {
+    if (!this->flushGraphicsState(ds, kStencilPath_DrawType, scissorState, NULL)) {
         return;
     }
 
     this->pathRendering()->stencilPath(path, stencilSettings);
 }
 
 
-void GrGpu::drawPath(const GrPath* path,
-                       const GrClipMaskManager::ScissorState& scissorState,
-                       const GrStencilSettings& stencilSettings,
-                       const GrDeviceCoordTexture* dstCopy) {
+void GrGpu::drawPath(const GrOptDrawState& ds,
+                     const GrPath* path,
+                     const GrClipMaskManager::ScissorState& scissorState,
+                     const GrStencilSettings& stencilSettings,
+                     const GrDeviceCoordTexture* dstCopy) {
     this->handleDirtyContext();
 
-    if (!this->flushGraphicsState(kDrawPath_DrawType, scissorState, dstCopy)) {
+    if (!this->flushGraphicsState(ds, kDrawPath_DrawType, scissorState, dstCopy)) {
         return;
     }
 
     this->pathRendering()->drawPath(path, stencilSettings);
 }
 
-void GrGpu::drawPaths(const GrPathRange* pathRange,
-                        const uint32_t indices[],
-                        int count,
-                        const float transforms[],
-                        GrDrawTarget::PathTransformType transformsType,
-                        const GrClipMaskManager::ScissorState& scissorState,
-                        const GrStencilSettings& stencilSettings,
-                        const GrDeviceCoordTexture* dstCopy) {
+void GrGpu::drawPaths(const GrOptDrawState& ds,
+                      const GrPathRange* pathRange,
+                      const uint32_t indices[],
+                      int count,
+                      const float transforms[],
+                      GrDrawTarget::PathTransformType transformsType,
+                      const GrClipMaskManager::ScissorState& scissorState,
+                      const GrStencilSettings& stencilSettings,
+                      const GrDeviceCoordTexture* dstCopy) {
     this->handleDirtyContext();
 
-    if (!this->flushGraphicsState(kDrawPaths_DrawType, scissorState, dstCopy)) {
+    if (!this->flushGraphicsState(ds, kDrawPaths_DrawType, scissorState, dstCopy)) {
         return;
     }
 
     pathRange->willDrawPaths(indices, count);
     this->pathRendering()->drawPaths(pathRange, indices, count, transforms, transformsType,
                                      stencilSettings);
 }