Move RectBatch to GrRectBatch

src/gpu/GrRectBatch.cpp

 /*
- * Copyright 2011 Google Inc.
+ * Copyright 2015 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 "GrRectBatch.h"
 
+#include "GrBatch.h"
+#include "GrBatchTarget.h"
 #include "GrDefaultGeoProcFactory.h"
+#include "GrPrimitiveProcessor.h"
 #include "GrTemplates.h"
 
-GrInOrderDrawBuffer::GrInOrderDrawBuffer(GrContext* context,
-                                         GrVertexBufferAllocPool* vertexPool,
-                                         GrIndexBufferAllocPool* indexPool)
-    : INHERITED(context, vertexPool, indexPool)
-    , fCommands(SkNEW_ARGS(GrCommandBuilder, (context->getGpu(), vertexPool, indexPool)))
-    , fPathIndexBuffer(kPathIdxBufferMinReserve * sizeof(char)/4)
-    , fPathTransformBuffer(kPathXformBufferMinReserve * sizeof(float)/4)
-    , fPipelineBuffer(kPipelineBufferMinReserve)
-    , fDrawID(0) {
-
-    SkASSERT(vertexPool);
-    SkASSERT(indexPool);
-}
-
-GrInOrderDrawBuffer::~GrInOrderDrawBuffer() {
-    this->reset();
-}
-
-////////////////////////////////////////////////////////////////////////////////
-
 /** We always use per-vertex colors so that rects can be batched across color changes. Sometimes we
     have explicit local coords and sometimes not. We *could* always provide explicit local coords
     and just duplicate the positions when the caller hasn't provided a local coord rect, but we
     haven't seen a use case which frequently switches between local rect and no local rect draws.
 
     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].
  */
@@ skipping 186 matching lines @@
         GrColor fColor;
         bool fUsesLocalCoords;
         bool fColorIgnored;
         bool fCoverageIgnored;
     };
 
     BatchTracker fBatch;
     SkSTArray<1, Geometry, true> fGeoData;
 };
 
-void GrInOrderDrawBuffer::onDrawRect(GrPipelineBuilder* pipelineBuilder,
-                                     GrColor color,
-                                     const SkMatrix& viewMatrix,
-                                     const SkRect& rect,
-                                     const SkRect* localRect,
-                                     const SkMatrix* localMatrix) {
+namespace GrRectBatch {
+
+GrBatch* Create(GrColor color,
+                const SkMatrix& viewMatrix,
+                const SkRect& rect,
+                const SkRect* localRect,
+                const SkMatrix* localMatrix) {
     RectBatch::Geometry geometry;
     geometry.fColor = color;
     geometry.fViewMatrix = viewMatrix;
     geometry.fRect = rect;
 
     if (localRect) {
         geometry.fHasLocalRect = true;
         geometry.fLocalRect = *localRect;
     } else {
         geometry.fHasLocalRect = false;
     }
 
     if (localMatrix) {
         geometry.fHasLocalMatrix = true;
         geometry.fLocalMatrix = *localMatrix;
     } else {
         geometry.fHasLocalMatrix = false;
     }
 
-    SkAutoTUnref<GrBatch> batch(RectBatch::Create(geometry));
-    this->drawBatch(pipelineBuilder, batch);
+    return RectBatch::Create(geometry);
 }
 
-void GrInOrderDrawBuffer::onDrawBatch(GrBatch* batch,
-                                      const PipelineInfo& pipelineInfo) {
-    State* state = this->setupPipelineAndShouldDraw(batch, pipelineInfo);
-    if (!state) {
-        return;
-    }
-
-    GrTargetCommands::Cmd* cmd = fCommands->recordDrawBatch(state, batch);
-    this->recordTraceMarkersIfNecessary(cmd);
-}
-
-void GrInOrderDrawBuffer::onStencilPath(const GrPipelineBuilder& pipelineBuilder,
-                                        const GrPathProcessor* pathProc,
-                                        const GrPath* path,
-                                        const GrScissorState& scissorState,
-                                        const GrStencilSettings& stencilSettings) {
-    GrTargetCommands::Cmd* cmd = fCommands->recordStencilPath(pipelineBuilder,
-                                                              pathProc, path, scissorState,
-                                                              stencilSettings);
-    this->recordTraceMarkersIfNecessary(cmd);
-}
-
-void GrInOrderDrawBuffer::onDrawPath(const GrPathProcessor* pathProc,
-                                     const GrPath* path,
-                                     const GrStencilSettings& stencilSettings,
-                                     const PipelineInfo& pipelineInfo) {
-    State* state = this->setupPipelineAndShouldDraw(pathProc, pipelineInfo);
-    if (!state) {
-        return;
-    }
-    GrTargetCommands::Cmd* cmd = fCommands->recordDrawPath(state, pathProc, path, stencilSettings);
-    this->recordTraceMarkersIfNecessary(cmd);
-}
-
-void GrInOrderDrawBuffer::onDrawPaths(const GrPathProcessor* pathProc,
-                                      const GrPathRange* pathRange,
-                                      const void* indices,
-                                      PathIndexType indexType,
-                                      const float transformValues[],
-                                      PathTransformType transformType,
-                                      int count,
-                                      const GrStencilSettings& stencilSettings,
-                                      const PipelineInfo& pipelineInfo) {
-    State* state = this->setupPipelineAndShouldDraw(pathProc, pipelineInfo);
-    if (!state) {
-        return;
-    }
-    GrTargetCommands::Cmd* cmd = fCommands->recordDrawPaths(state, this, pathProc, pathRange,
-                                                            indices, indexType, transformValues,
-                                                            transformType, count,
-                                                            stencilSettings, pipelineInfo);
-    this->recordTraceMarkersIfNecessary(cmd);
-}
-
-void GrInOrderDrawBuffer::onClear(const SkIRect* rect, GrColor color,
-                                  bool canIgnoreRect, GrRenderTarget* renderTarget) {
-    GrTargetCommands::Cmd* cmd = fCommands->recordClear(rect, color, canIgnoreRect, renderTarget);
-    this->recordTraceMarkersIfNecessary(cmd);
-}
-
-void GrInOrderDrawBuffer::clearStencilClip(const SkIRect& rect,
-                                           bool insideClip,
-                                           GrRenderTarget* renderTarget) {
-    GrTargetCommands::Cmd* cmd = fCommands->recordClearStencilClip(rect, insideClip, renderTarget);
-    this->recordTraceMarkersIfNecessary(cmd);
-}
-
-void GrInOrderDrawBuffer::discard(GrRenderTarget* renderTarget) {
-    if (!this->caps()->discardRenderTargetSupport()) {
-        return;
-    }
-
-    GrTargetCommands::Cmd* cmd = fCommands->recordDiscard(renderTarget);
-    this->recordTraceMarkersIfNecessary(cmd);
-}
-
-void GrInOrderDrawBuffer::onReset() {
-    fCommands->reset();
-    fPathIndexBuffer.rewind();
-    fPathTransformBuffer.rewind();
-    fGpuCmdMarkers.reset();
-
-    fPrevState.reset(NULL);
-    // Note, fPrevState points into fPipelineBuffer's allocation, so we have to reset first.
-    // Furthermore, we have to reset fCommands before fPipelineBuffer too.
-    if (fDrawID % kPipelineBufferHighWaterMark) {
-        fPipelineBuffer.rewind();
-    } else {
-        fPipelineBuffer.reset();
-    }
-}
-
-void GrInOrderDrawBuffer::onFlush() {
-    fCommands->flush(this);
-    ++fDrawID;
-}
-
-void GrInOrderDrawBuffer::onCopySurface(GrSurface* dst,
-                                        GrSurface* src,
-                                        const SkIRect& srcRect,
-                                        const SkIPoint& dstPoint) {
-    SkASSERT(this->getGpu()->canCopySurface(dst, src, srcRect, dstPoint));
-    GrTargetCommands::Cmd* cmd = fCommands->recordCopySurface(dst, src, srcRect, dstPoint);
-    this->recordTraceMarkersIfNecessary(cmd);
-}
-
-void GrInOrderDrawBuffer::recordTraceMarkersIfNecessary(GrTargetCommands::Cmd* cmd) {
-    if (!cmd) {
-        return;
-    }
-    const GrTraceMarkerSet& activeTraceMarkers = this->getActiveTraceMarkers();
-    if (activeTraceMarkers.count() > 0) {
-        if (cmd->isTraced()) {
-            fGpuCmdMarkers[cmd->markerID()].addSet(activeTraceMarkers);
-        } else {
-            cmd->setMarkerID(fGpuCmdMarkers.count());
-            fGpuCmdMarkers.push_back(activeTraceMarkers);
-        }
-    }
-}
-
-GrTargetCommands::State*
-GrInOrderDrawBuffer::setupPipelineAndShouldDraw(const GrPrimitiveProcessor* primProc,
-                                                const GrDrawTarget::PipelineInfo& pipelineInfo) {
-    State* state = this->allocState(primProc);
-    this->setupPipeline(pipelineInfo, state->pipelineLocation());
-
-    if (state->getPipeline()->mustSkip()) {
-        this->unallocState(state);
-        return NULL;
-    }
-
-    state->fPrimitiveProcessor->initBatchTracker(&state->fBatchTracker,
-                                                 state->getPipeline()->getInitBatchTracker());
-
-    if (fPrevState && fPrevState->fPrimitiveProcessor.get() &&
-        fPrevState->fPrimitiveProcessor->canMakeEqual(fPrevState->fBatchTracker,
-                                                      *state->fPrimitiveProcessor,
-                                                      state->fBatchTracker) &&
-        fPrevState->getPipeline()->isEqual(*state->getPipeline())) {
-        this->unallocState(state);
-    } else {
-        fPrevState.reset(state);
-    }
-
-    this->recordTraceMarkersIfNecessary(
-            fCommands->recordXferBarrierIfNecessary(*fPrevState->getPipeline(), *this->caps()));
-    return fPrevState;
-}
-
-GrTargetCommands::State*
-GrInOrderDrawBuffer::setupPipelineAndShouldDraw(GrBatch* batch,
-                                                const GrDrawTarget::PipelineInfo& pipelineInfo) {
-    State* state = this->allocState();
-    this->setupPipeline(pipelineInfo, state->pipelineLocation());
-
-    if (state->getPipeline()->mustSkip()) {
-        this->unallocState(state);
-        return NULL;
-    }
-
-    batch->initBatchTracker(state->getPipeline()->getInitBatchTracker());
-
-    if (fPrevState && !fPrevState->fPrimitiveProcessor.get() &&
-        fPrevState->getPipeline()->isEqual(*state->getPipeline())) {
-        this->unallocState(state);
-    } else {
-        fPrevState.reset(state);
-    }
-
-    this->recordTraceMarkersIfNecessary(
-            fCommands->recordXferBarrierIfNecessary(*fPrevState->getPipeline(), *this->caps()));
-    return fPrevState;
-}
+};