Refactor DrawTarget and GPU to be independent

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"
@@ skipping 10 matching lines @@
 static const int VERTEX_POOL_VB_COUNT = 4;
 static const size_t INDEX_POOL_IB_SIZE = 1 << 16;
 static const int INDEX_POOL_IB_COUNT = 4;
 
 ////////////////////////////////////////////////////////////////////////////////
 
 #define DEBUG_INVAL_BUFFER    0xdeadcafe
 #define DEBUG_INVAL_START_IDX -1
 
 GrGpu::GrGpu(GrContext* context)
-    : INHERITED(context)
-    , fResetTimestamp(kExpiredTimestamp+1)
+    : fResetTimestamp(kExpiredTimestamp+1)
     , fResetBits(kAll_GrBackendState)
     , fVertexPool(NULL)
     , fIndexPool(NULL)
     , fVertexPoolUseCnt(0)
     , fIndexPoolUseCnt(0)
-    , fQuadIndexBuffer(NULL) {
+    , fQuadIndexBuffer(NULL)
+    , fContext(context) {
     fGeomPoolStateStack.push_back();
+    fDrawState = &fDefaultDrawState;
+    // We assume that fDrawState always owns a ref to the object it points at.
+    fDefaultDrawState.ref();
 #ifdef SK_DEBUG
     GeometryPoolState& poolState = fGeomPoolStateStack.back();
     poolState.fPoolVertexBuffer = (GrVertexBuffer*)DEBUG_INVAL_BUFFER;
     poolState.fPoolStartVertex = DEBUG_INVAL_START_IDX;
     poolState.fPoolIndexBuffer = (GrIndexBuffer*)DEBUG_INVAL_BUFFER;
     poolState.fPoolStartIndex = DEBUG_INVAL_START_IDX;
 #endif
+
+    GrDrawTarget::GeometrySrcState& geoSrc = fGeoSrcStateStack.push_back();
+#ifdef SK_DEBUG
+    geoSrc.fVertexCount = DEBUG_INVAL_START_IDX;
+    geoSrc.fVertexBuffer = (GrVertexBuffer*)DEBUG_INVAL_BUFFER;
+    geoSrc.fIndexCount = DEBUG_INVAL_START_IDX;
+    geoSrc.fIndexBuffer = (GrIndexBuffer*)DEBUG_INVAL_BUFFER;
+#endif
+    geoSrc.fVertexSrc = GrDrawTarget::kNone_GeometrySrcType;
+    geoSrc.fIndexSrc  = GrDrawTarget::kNone_GeometrySrcType;
 }
 
 GrGpu::~GrGpu() {
     SkSafeSetNull(fQuadIndexBuffer);
     delete fVertexPool;
     fVertexPool = NULL;
     delete fIndexPool;
     fIndexPool = NULL;
+    SkASSERT(1 == fGeoSrcStateStack.count());
+    SkDEBUGCODE(GrDrawTarget::GeometrySrcState& geoSrc = fGeoSrcStateStack.back());
+    SkASSERT(GrDrawTarget::kNone_GeometrySrcType == geoSrc.fIndexSrc);
+    SkASSERT(GrDrawTarget::kNone_GeometrySrcType == geoSrc.fVertexSrc);
+    SkSafeUnref(fDrawState);
 }
 
 void GrGpu::contextAbandoned() {}
 
 ////////////////////////////////////////////////////////////////////////////////
 
 GrTexture* GrGpu::createTexture(const GrSurfaceDesc& desc,
                                 const void* srcData, size_t rowBytes) {
     if (!this->caps()->isConfigTexturable(desc.fConfig)) {
         return NULL;
@@ skipping 122 matching lines @@
                 SkFAIL("Can't get indices into buffer!");
             }
             SkDELETE_ARRAY(data);
         } else {
             buffer->unmap();
         }
     }
     return buffer;
 }
 
-void GrGpu::onClear(const SkIRect* rect,
-                    GrColor color,
-                    bool canIgnoreRect,
-                    GrRenderTarget* renderTarget) {
+void GrGpu::clear(const SkIRect* rect,
+                  GrColor color,
+                  bool canIgnoreRect,
+                  GrRenderTarget* renderTarget) {
     SkASSERT(renderTarget);
     this->handleDirtyContext();
     this->onGpuClear(renderTarget, rect, color, canIgnoreRect);
 }
 
 void GrGpu::clearStencilClip(const SkIRect& rect,
                              bool insideClip,
                              GrRenderTarget* renderTarget) {
     if (NULL == renderTarget) {
         renderTarget = this->getDrawState().getRenderTarget();
@@ skipping 23 matching lines @@
     return this->onWriteTexturePixels(texture, left, top, width, height,
                                       config, buffer, rowBytes);
 }
 
 void GrGpu::resolveRenderTarget(GrRenderTarget* target) {
     SkASSERT(target);
     this->handleDirtyContext();
     this->onResolveRenderTarget(target);
 }
 
+void GrGpu::initCopySurfaceDstDesc(const GrSurface* src, GrSurfaceDesc* desc) {
+    // Make the dst of the copy be a render target because the default copySurface draws to the dst.
+    desc->fOrigin = kDefault_GrSurfaceOrigin;
+    desc->fFlags = kRenderTarget_GrSurfaceFlag | kNoStencil_GrSurfaceFlag;
+    desc->fConfig = src->config();
+}
+
+typedef GrTraceMarkerSet::Iter TMIter;
+void GrGpu::saveActiveTraceMarkers() {
+    if (this->caps()->gpuTracingSupport()) {
+        SkASSERT(0 == fStoredTraceMarkers.count());
+        fStoredTraceMarkers.addSet(fActiveTraceMarkers);
+        for (TMIter iter = fStoredTraceMarkers.begin(); iter != fStoredTraceMarkers.end(); ++iter) {
+            this->removeGpuTraceMarker(&(*iter));
+        }
+    }
+}
+
+void GrGpu::restoreActiveTraceMarkers() {
+    if (this->caps()->gpuTracingSupport()) {
+        SkASSERT(0 == fActiveTraceMarkers.count());
+        for (TMIter iter = fStoredTraceMarkers.begin(); iter != fStoredTraceMarkers.end(); ++iter) {
+            this->addGpuTraceMarker(&(*iter));
+        }
+        for (TMIter iter = fActiveTraceMarkers.begin(); iter != fActiveTraceMarkers.end(); ++iter) {
+            this->fStoredTraceMarkers.remove(*iter);
+        }
+    }
+}
+
+void GrGpu::addGpuTraceMarker(const GrGpuTraceMarker* marker) {
+    if (this->caps()->gpuTracingSupport()) {
+        SkASSERT(fGpuTraceMarkerCount >= 0);
+        this->fActiveTraceMarkers.add(*marker);
+        this->didAddGpuTraceMarker();
+        ++fGpuTraceMarkerCount;
+    }
+}
+
+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) {
+    this->releasePreviousVertexSource();
+    GrDrawTarget::GeometrySrcState& geoSrc = fGeoSrcStateStack.back();
+    geoSrc.fVertexSrc    = GrDrawTarget::kBuffer_GeometrySrcType;
+    geoSrc.fVertexBuffer = buffer;
+    buffer->ref();
+    geoSrc.fVertexSize = this->drawState()->getVertexStride();
+}
+
+void GrGpu::setIndexSourceToBuffer(const GrIndexBuffer* buffer) {
+    this->releasePreviousIndexSource();
+    GrDrawTarget::GeometrySrcState& geoSrc = fGeoSrcStateStack.back();
+    geoSrc.fIndexSrc     = GrDrawTarget::kBuffer_GeometrySrcType;
+    geoSrc.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;
+    }
+}
+
+void GrGpu::resetVertexSource() {
+    this->releasePreviousVertexSource();
+    GrDrawTarget::GeometrySrcState& geoSrc = fGeoSrcStateStack.back();
+    geoSrc.fVertexSrc = GrDrawTarget::kNone_GeometrySrcType;
+}
+
+void GrGpu::resetIndexSource() {
+    this->releasePreviousIndexSource();
+    GrDrawTarget::GeometrySrcState& geoSrc = fGeoSrcStateStack.back();
+    geoSrc.fIndexSrc = GrDrawTarget::kNone_GeometrySrcType;
+}
+
+void GrGpu::pushGeometrySource() {
+    this->geometrySourceWillPush();
+    GrDrawTarget::GeometrySrcState& newState = fGeoSrcStateStack.push_back();
+    newState.fIndexSrc = GrDrawTarget::kNone_GeometrySrcType;
+    newState.fVertexSrc = GrDrawTarget::kNone_GeometrySrcType;
+#ifdef SK_DEBUG
+    newState.fVertexCount  = ~0;
+    newState.fVertexBuffer = (GrVertexBuffer*)~0;
+    newState.fIndexCount   = ~0;
+    newState.fIndexBuffer = (GrIndexBuffer*)~0;
+#endif
+}
+
+void GrGpu::popGeometrySource() {
+    // if popping last element then pops are unbalanced with pushes
+    SkASSERT(fGeoSrcStateStack.count() > 1);
+
+    this->geometrySourceWillPop(fGeoSrcStateStack.fromBack(1));
+    this->releasePreviousVertexSource();
+    this->releasePreviousIndexSource();
+    fGeoSrcStateStack.pop_back();
+}
+
 ////////////////////////////////////////////////////////////////////////////////
 
 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::geometrySourceWillPush() {
-    const GeometrySrcState& geoSrc = this->getGeomSrc();
-    if (kReserved_GeometrySrcType == geoSrc.fVertexSrc) {
+    const GrDrawTarget::GeometrySrcState& geoSrc = this->getGeomSrc();
+    if (GrDrawTarget::kReserved_GeometrySrcType == geoSrc.fVertexSrc) {
         this->finalizeReservedVertices();
     }
-    if (kReserved_GeometrySrcType == geoSrc.fIndexSrc) {
+    if (GrDrawTarget::kReserved_GeometrySrcType == geoSrc.fIndexSrc) {
         this->finalizeReservedIndices();
     }
     GeometryPoolState& newState = fGeomPoolStateStack.push_back();
 #ifdef SK_DEBUG
     newState.fPoolVertexBuffer = (GrVertexBuffer*)DEBUG_INVAL_BUFFER;
     newState.fPoolStartVertex = DEBUG_INVAL_START_IDX;
     newState.fPoolIndexBuffer = (GrIndexBuffer*)DEBUG_INVAL_BUFFER;
     newState.fPoolStartIndex = DEBUG_INVAL_START_IDX;
 #else
     (void) newState; // silence compiler warning
 #endif
 }
 
-void GrGpu::geometrySourceWillPop(const GeometrySrcState& restoredState) {
+void GrGpu::geometrySourceWillPop(const GrDrawTarget::GeometrySrcState& restoredState) {
     // if popping last entry then pops are unbalanced with pushes
     SkASSERT(fGeomPoolStateStack.count() > 1);
     fGeomPoolStateStack.pop_back();
 }
 
-void GrGpu::onDraw(const DrawInfo& info, const GrClipMaskManager::ScissorState& scissorState) {
+void GrGpu::onDraw(const GrDrawTarget::DrawInfo& info,
+                   const GrClipMaskManager::ScissorState& scissorState) {
     this->handleDirtyContext();
     if (!this->flushGraphicsState(PrimTypeToDrawType(info.primitiveType()),
                                   scissorState,
                                   info.getDstCopy())) {
         return;
     }
     this->onGpuDraw(info);
 }
 
 void GrGpu::onStencilPath(const GrPath* path,
                           const GrClipMaskManager::ScissorState& scissorState,
                           const GrStencilSettings& stencilSettings) {
     this->handleDirtyContext();
 
     if (!this->flushGraphicsState(kStencilPath_DrawType, scissorState, NULL)) {
         return;
     }
 
     this->pathRendering()->stencilPath(path, stencilSettings);
 }
 
 
 void GrGpu::onDrawPath(const GrPath* path,
                        const GrClipMaskManager::ScissorState& scissorState,
                        const GrStencilSettings& stencilSettings,
                        const GrDeviceCoordTexture* dstCopy) {
     this->handleDirtyContext();
 
-    drawState()->setDefaultVertexAttribs();
-
     if (!this->flushGraphicsState(kDrawPath_DrawType, scissorState, dstCopy)) {
         return;
     }
 
     this->pathRendering()->drawPath(path, stencilSettings);
 }
 
 void GrGpu::onDrawPaths(const GrPathRange* pathRange,
                         const uint32_t indices[],
                         int count,
                         const float transforms[],
-                        PathTransformType transformsType,
+                        GrDrawTarget::PathTransformType transformsType,
                         const GrClipMaskManager::ScissorState& scissorState,
                         const GrStencilSettings& stencilSettings,
                         const GrDeviceCoordTexture* dstCopy) {
     this->handleDirtyContext();
 
-    drawState()->setDefaultVertexAttribs();
-
     if (!this->flushGraphicsState(kDrawPaths_DrawType, scissorState, dstCopy)) {
         return;
     }
 
     pathRange->willDrawPaths(indices, count);
     this->pathRendering()->drawPaths(pathRange, indices, count, transforms, transformsType,
                                      stencilSettings);
 }
 
 void GrGpu::finalizeReservedVertices() {
@@ skipping 65 matching lines @@
                                      &geomPoolState.fPoolIndexBuffer,
                                      &geomPoolState.fPoolStartIndex);
     if (NULL == *indices) {
         return false;
     }
     ++fIndexPoolUseCnt;
     return true;
 }
 
 void GrGpu::releaseReservedVertexSpace() {
-    const GeometrySrcState& geoSrc = this->getGeomSrc();
-    SkASSERT(kReserved_GeometrySrcType == geoSrc.fVertexSrc);
+    const GrDrawTarget::GeometrySrcState& geoSrc = this->getGeomSrc();
+    SkASSERT(GrDrawTarget::kReserved_GeometrySrcType == geoSrc.fVertexSrc);
     size_t bytes = geoSrc.fVertexCount * geoSrc.fVertexSize;
     fVertexPool->putBack(bytes);
     --fVertexPoolUseCnt;
 }
 
 void GrGpu::releaseReservedIndexSpace() {
-    const GeometrySrcState& geoSrc = this->getGeomSrc();
-    SkASSERT(kReserved_GeometrySrcType == geoSrc.fIndexSrc);
+    const GrDrawTarget::GeometrySrcState& geoSrc = this->getGeomSrc();
+    SkASSERT(GrDrawTarget::kReserved_GeometrySrcType == geoSrc.fIndexSrc);
     size_t bytes = geoSrc.fIndexCount * sizeof(uint16_t);
     fIndexPool->putBack(bytes);
     --fIndexPoolUseCnt;
 }
+
+void GrGpu::releasePreviousVertexSource() {
+    GrDrawTarget::GeometrySrcState& geoSrc = fGeoSrcStateStack.back();
+    switch (geoSrc.fVertexSrc) {
+        case GrDrawTarget::kNone_GeometrySrcType:
+            break;
+        case GrDrawTarget::kReserved_GeometrySrcType:
+            this->releaseReservedVertexSpace();
+            break;
+        case GrDrawTarget::kBuffer_GeometrySrcType:
+            geoSrc.fVertexBuffer->unref();
+#ifdef SK_DEBUG
+            geoSrc.fVertexBuffer = (GrVertexBuffer*)DEBUG_INVAL_BUFFER;
+#endif
+            break;
+        default:
+            SkFAIL("Unknown Vertex Source Type.");
+            break;
+    }
+}
+
+void GrGpu::releasePreviousIndexSource() {
+    GrDrawTarget::GeometrySrcState& geoSrc = fGeoSrcStateStack.back();
+    switch (geoSrc.fIndexSrc) {
+        case GrDrawTarget::kNone_GeometrySrcType:   // these two don't require
+            break;
+        case GrDrawTarget::kReserved_GeometrySrcType:
+            this->releaseReservedIndexSpace();
+            break;
+        case GrDrawTarget::kBuffer_GeometrySrcType:
+            geoSrc.fIndexBuffer->unref();
+#ifdef SK_DEBUG
+            geoSrc.fIndexBuffer = (GrIndexBuffer*)DEBUG_INVAL_BUFFER;
+#endif
+            break;
+        default:
+            SkFAIL("Unknown Index Source Type.");
+            break;
+    }
+}
+
+void GrGpu::releaseGeometry() {
+    int popCnt = fGeoSrcStateStack.count() - 1;
+    while (popCnt) {
+        this->popGeometrySource();
+        --popCnt;
+    }
+    this->resetVertexSource();
+    this->resetIndexSource();
+}