'<(skia_src_path)/gpu/GrBlurUtils.h',
'<(skia_src_path)/gpu/GrBufferAllocPool.cpp',
'<(skia_src_path)/gpu/GrBufferAllocPool.h',
+ '<(skia_src_path)/gpu/GrBufferedDrawTarget.cpp',
+ '<(skia_src_path)/gpu/GrBufferedDrawTarget.h',
'<(skia_src_path)/gpu/GrCaps.cpp',
'<(skia_src_path)/gpu/GrClip.cpp',
'<(skia_src_path)/gpu/GrClipMaskCache.h',
'<(skia_src_path)/gpu/GrInvariantOutput.cpp',
'<(skia_src_path)/gpu/GrInOrderCommandBuilder.cpp',
'<(skia_src_path)/gpu/GrInOrderCommandBuilder.h',
- '<(skia_src_path)/gpu/GrInOrderDrawBuffer.cpp',
- '<(skia_src_path)/gpu/GrInOrderDrawBuffer.h',
'<(skia_src_path)/gpu/GrLayerCache.cpp',
'<(skia_src_path)/gpu/GrLayerCache.h',
'<(skia_src_path)/gpu/GrLayerHoister.cpp',
#include "SkView.h"
/**
- * Animated sample used to develop batched rect implementation in GrInOrderDrawBuffer.
+ * Animated sample used to develop batched rect implementation in GrBufferedDrawTarget.
*/
class ManyRectsView : public SampleView {
private:
--- /dev/null
+/*
+ * 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 "GrBufferedDrawTarget.h"
+
+// We will use the reordering buffer, unless we have NVPR.
+// TODO move NVPR to batch so we can reorder
+static inline bool allow_reordering(const GrCaps* caps) {
+ return caps && caps->shaderCaps() && !caps->shaderCaps()->pathRenderingSupport();
+}
+
+GrBufferedDrawTarget::GrBufferedDrawTarget(GrContext* context)
+ : INHERITED(context)
+ , fCommands(GrCommandBuilder::Create(context->getGpu(), allow_reordering(context->caps())))
+ , fPathIndexBuffer(kPathIdxBufferMinReserve * sizeof(char)/4)
+ , fPathTransformBuffer(kPathXformBufferMinReserve * sizeof(float)/4)
+ , fPipelineBuffer(kPipelineBufferMinReserve)
+ , fDrawID(0) {
+}
+
+GrBufferedDrawTarget::~GrBufferedDrawTarget() {
+ this->reset();
+}
+
+void GrBufferedDrawTarget::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 GrBufferedDrawTarget::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 GrBufferedDrawTarget::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 GrBufferedDrawTarget::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 GrBufferedDrawTarget::onClear(const SkIRect* rect, GrColor color,
+ bool canIgnoreRect, GrRenderTarget* renderTarget) {
+ GrTargetCommands::Cmd* cmd = fCommands->recordClear(rect, color, canIgnoreRect, renderTarget);
+ this->recordTraceMarkersIfNecessary(cmd);
+}
+
+void GrBufferedDrawTarget::clearStencilClip(const SkIRect& rect,
+ bool insideClip,
+ GrRenderTarget* renderTarget) {
+ GrTargetCommands::Cmd* cmd = fCommands->recordClearStencilClip(rect, insideClip, renderTarget);
+ this->recordTraceMarkersIfNecessary(cmd);
+}
+
+void GrBufferedDrawTarget::discard(GrRenderTarget* renderTarget) {
+ if (!this->caps()->discardRenderTargetSupport()) {
+ return;
+ }
+
+ GrTargetCommands::Cmd* cmd = fCommands->recordDiscard(renderTarget);
+ this->recordTraceMarkersIfNecessary(cmd);
+}
+
+void GrBufferedDrawTarget::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 GrBufferedDrawTarget::onFlush() {
+ fCommands->flush(this);
+ ++fDrawID;
+}
+
+void GrBufferedDrawTarget::onCopySurface(GrSurface* dst,
+ GrSurface* src,
+ const SkIRect& srcRect,
+ const SkIPoint& dstPoint) {
+ GrTargetCommands::Cmd* cmd = fCommands->recordCopySurface(dst, src, srcRect, dstPoint);
+ this->recordTraceMarkersIfNecessary(cmd);
+}
+
+void GrBufferedDrawTarget::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*
+GrBufferedDrawTarget::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()->infoForPrimitiveProcessor());
+
+ 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*
+GrBufferedDrawTarget::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()->infoForPrimitiveProcessor());
+
+ 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;
+}
--- /dev/null
+/*
+ * Copyright 2011 Google Inc.
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#ifndef GrBufferedDrawTarget_DEFINED
+#define GrBufferedDrawTarget_DEFINED
+
+#include "GrDrawTarget.h"
+#include "GrCommandBuilder.h"
+#include "SkChunkAlloc.h"
+
+/**
+ * GrBufferedDrawTarget is an implementation of GrDrawTarget that queues up draws for eventual
+ * playback into a GrGpu. In theory one draw buffer could playback into another. Similarly, it is
+ * the caller's responsibility to ensure that all referenced textures, buffers, and render-targets
+ * are associated in the GrGpu object that the buffer is played back into.
+ */
+class GrBufferedDrawTarget : public GrClipTarget {
+public:
+
+ /**
+ * Creates a GrBufferedDrawTarget
+ *
+ * @param context the context object that owns this draw buffer.
+ */
+ GrBufferedDrawTarget(GrContext* context);
+
+ ~GrBufferedDrawTarget() override;
+
+ void clearStencilClip(const SkIRect& rect,
+ bool insideClip,
+ GrRenderTarget* renderTarget) override;
+
+ void discard(GrRenderTarget*) override;
+
+protected:
+ void appendIndicesAndTransforms(const void* indexValues, PathIndexType indexType,
+ const float* transformValues, PathTransformType transformType,
+ int count, char** indicesLocation, float** xformsLocation) {
+ int indexBytes = GrPathRange::PathIndexSizeInBytes(indexType);
+ *indicesLocation = (char*) fPathIndexBuffer.alloc(count * indexBytes,
+ SkChunkAlloc::kThrow_AllocFailType);
+ SkASSERT(SkIsAlign4((uintptr_t)*indicesLocation));
+ memcpy(*indicesLocation, reinterpret_cast<const char*>(indexValues), count * indexBytes);
+
+ const int xformBytes = GrPathRendering::PathTransformSize(transformType) * sizeof(float);
+ *xformsLocation = NULL;
+
+ if (0 != xformBytes) {
+ *xformsLocation = (float*) fPathTransformBuffer.alloc(count * xformBytes,
+ SkChunkAlloc::kThrow_AllocFailType);
+ SkASSERT(SkIsAlign4((uintptr_t)*xformsLocation));
+ memcpy(*xformsLocation, transformValues, count * xformBytes);
+ }
+ }
+
+private:
+ friend class GrInOrderCommandBuilder;
+ friend class GrTargetCommands;
+
+ typedef GrTargetCommands::State State;
+
+ State* allocState(const GrPrimitiveProcessor* primProc = NULL) {
+ void* allocation = fPipelineBuffer.alloc(sizeof(State), SkChunkAlloc::kThrow_AllocFailType);
+ return SkNEW_PLACEMENT_ARGS(allocation, State, (primProc));
+ }
+
+ void unallocState(State* state) {
+ state->unref();
+ fPipelineBuffer.unalloc(state);
+ }
+
+ void onReset() override;
+ void onFlush() override;
+
+ // overrides from GrDrawTarget
+ void onDrawBatch(GrBatch*, const PipelineInfo&) override;
+ void onStencilPath(const GrPipelineBuilder&,
+ const GrPathProcessor*,
+ const GrPath*,
+ const GrScissorState&,
+ const GrStencilSettings&) override;
+ void onDrawPath(const GrPathProcessor*,
+ const GrPath*,
+ const GrStencilSettings&,
+ const PipelineInfo&) override;
+ void onDrawPaths(const GrPathProcessor*,
+ const GrPathRange*,
+ const void* indices,
+ PathIndexType,
+ const float transformValues[],
+ PathTransformType,
+ int count,
+ const GrStencilSettings&,
+ const PipelineInfo&) override;
+ void onClear(const SkIRect* rect,
+ GrColor color,
+ bool canIgnoreRect,
+ GrRenderTarget* renderTarget) override;
+ void onCopySurface(GrSurface* dst,
+ GrSurface* src,
+ const SkIRect& srcRect,
+ const SkIPoint& dstPoint) override;
+
+ // Records any trace markers for a command
+ void recordTraceMarkersIfNecessary(GrTargetCommands::Cmd*);
+ SkString getCmdString(int index) const {
+ SkASSERT(index < fGpuCmdMarkers.count());
+ return fGpuCmdMarkers[index].toString();
+ }
+ bool isIssued(uint32_t drawID) override { return drawID != fDrawID; }
+
+ State* SK_WARN_UNUSED_RESULT setupPipelineAndShouldDraw(const GrPrimitiveProcessor*,
+ const GrDrawTarget::PipelineInfo&);
+ State* SK_WARN_UNUSED_RESULT setupPipelineAndShouldDraw(GrBatch*,
+ const GrDrawTarget::PipelineInfo&);
+
+ // TODO: Use a single allocator for commands and records
+ enum {
+ kPathIdxBufferMinReserve = 2 * 64, // 64 uint16_t's
+ kPathXformBufferMinReserve = 2 * 64, // 64 two-float transforms
+ kPipelineBufferMinReserve = 32 * sizeof(State),
+ };
+
+ // every 100 flushes we should reset our fPipelineBuffer to prevent us from holding at a
+ // highwater mark
+ static const int kPipelineBufferHighWaterMark = 100;
+
+ SkAutoTDelete<GrCommandBuilder> fCommands;
+ SkTArray<GrTraceMarkerSet, false> fGpuCmdMarkers;
+ SkChunkAlloc fPathIndexBuffer;
+ SkChunkAlloc fPathTransformBuffer;
+ SkChunkAlloc fPipelineBuffer;
+ uint32_t fDrawID;
+ SkAutoTUnref<State> fPrevState;
+
+ typedef GrClipTarget INHERITED;
+};
+
+#endif
// Either a hard (stencil buffer) clip was explicitly requested or an anti-aliased clip couldn't
// be created. In either case, free up the texture in the anti-aliased mask cache.
// TODO: this may require more investigation. Ganesh performs a lot of utility draws (e.g.,
- // clears, InOrderDrawBuffer playbacks) that hit the stencil buffer path. These may be
+ // clears, GrBufferedDrawTarget playbacks) that hit the stencil buffer path. These may be
// "incorrectly" clearing the AA cache.
fAACache.reset();
#include "GrTargetCommands.h"
-class GrInOrderDrawBuffer;
+class GrBufferedDrawTarget;
class GrCommandBuilder : ::SkNoncopyable {
public:
virtual ~GrCommandBuilder() {}
void reset() { fCommands.reset(); }
- void flush(GrInOrderDrawBuffer* iodb) { fCommands.flush(iodb); }
+ void flush(GrBufferedDrawTarget* bufferedDrawTarget) { fCommands.flush(bufferedDrawTarget); }
virtual Cmd* recordClearStencilClip(const SkIRect& rect,
bool insideClip,
const GrPath*,
const GrStencilSettings&) = 0;
virtual Cmd* recordDrawPaths(State*,
- GrInOrderDrawBuffer*,
+ GrBufferedDrawTarget*,
const GrPathProcessor*,
const GrPathRange*,
const void*,
#include "GrBatchFontCache.h"
#include "GrBatchTarget.h"
#include "GrBatchTest.h"
+#include "GrBufferedDrawTarget.h"
#include "GrCaps.h"
#include "GrContextOptions.h"
#include "GrDefaultGeoProcFactory.h"
#include "GrGpu.h"
#include "GrImmediateDrawTarget.h"
#include "GrIndexBuffer.h"
-#include "GrInOrderDrawBuffer.h"
#include "GrLayerCache.h"
#include "GrOvalRenderer.h"
#include "GrPathRenderer.h"
#ifdef IMMEDIATE_MODE
fDrawTarget = SkNEW_ARGS(GrImmediateDrawTarget, (context));
#else
- fDrawTarget = SkNEW_ARGS(GrInOrderDrawBuffer, (context));
+ fDrawTarget = SkNEW_ARGS(GrBufferedDrawTarget, (context));
#endif
}
GrContext* context = reinterpret_cast<GrContext*>(data);
- // Flush the InOrderDrawBuffer to possibly free up some textures
+ // Flush the GrBufferedDrawTarget to possibly free up some textures
context->fFlushToReduceCacheSize = true;
}
#include "GrInOrderCommandBuilder.h"
+#include "GrBufferedDrawTarget.h"
+
#include "GrColor.h"
-#include "GrInOrderDrawBuffer.h"
#include "SkPoint.h"
static bool path_fill_type_is_winding(const GrStencilSettings& pathStencilSettings) {
GrTargetCommands::Cmd*
GrInOrderCommandBuilder::recordDrawPaths(State* state,
- GrInOrderDrawBuffer* iodb,
+ GrBufferedDrawTarget* bufferedDrawTarget,
const GrPathProcessor* pathProc,
const GrPathRange* pathRange,
const void* indexValues,
char* savedIndices;
float* savedTransforms;
- iodb->appendIndicesAndTransforms(indexValues, indexType,
- transformValues, transformType,
- count, &savedIndices, &savedTransforms);
+ bufferedDrawTarget->appendIndicesAndTransforms(indexValues, indexType,
+ transformValues, transformType,
+ count, &savedIndices, &savedTransforms);
if (!this->cmdBuffer()->empty() &&
Cmd::kDrawPaths_CmdType == this->cmdBuffer()->back().type()) {
const GrPath*,
const GrStencilSettings&) override;
Cmd* recordDrawPaths(State*,
- GrInOrderDrawBuffer*,
+ GrBufferedDrawTarget*,
const GrPathProcessor*,
const GrPathRange*,
const void*,
+++ /dev/null
-/*
- * 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"
-
-// We will use the reordering buffer, unless we have NVPR.
-// TODO move NVPR to batch so we can reorder
-static inline bool allow_reordering(const GrCaps* caps) {
- return caps && caps->shaderCaps() && !caps->shaderCaps()->pathRenderingSupport();
-}
-
-GrInOrderDrawBuffer::GrInOrderDrawBuffer(GrContext* context)
- : INHERITED(context)
- , fCommands(GrCommandBuilder::Create(context->getGpu(), allow_reordering(context->caps())))
- , fPathIndexBuffer(kPathIdxBufferMinReserve * sizeof(char)/4)
- , fPathTransformBuffer(kPathXformBufferMinReserve * sizeof(float)/4)
- , fPipelineBuffer(kPipelineBufferMinReserve)
- , fDrawID(0) {
-}
-
-GrInOrderDrawBuffer::~GrInOrderDrawBuffer() {
- this->reset();
-}
-
-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) {
- 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()->infoForPrimitiveProcessor());
-
- 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()->infoForPrimitiveProcessor());
-
- 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;
-}
+++ /dev/null
-/*
- * Copyright 2011 Google Inc.
- *
- * Use of this source code is governed by a BSD-style license that can be
- * found in the LICENSE file.
- */
-
-#ifndef GrInOrderDrawBuffer_DEFINED
-#define GrInOrderDrawBuffer_DEFINED
-
-#include "GrDrawTarget.h"
-#include "GrCommandBuilder.h"
-#include "SkChunkAlloc.h"
-
-/**
- * GrInOrderDrawBuffer is an implementation of GrDrawTarget that queues up draws for eventual
- * playback into a GrGpu. In theory one draw buffer could playback into another. When index or
- * vertex buffers are used as geometry sources it is the callers the draw buffer only holds
- * references to the buffers. It is the callers responsibility to ensure that the data is still
- * valid when the draw buffer is played back into a GrGpu. Similarly, it is the caller's
- * responsibility to ensure that all referenced textures, buffers, and render-targets are associated
- * in the GrGpu object that the buffer is played back into. The buffer requires VB and IB pools to
- * store geometry.
- */
-class GrInOrderDrawBuffer : public GrClipTarget {
-public:
-
- /**
- * Creates a GrInOrderDrawBuffer
- *
- * @param context the context object that owns this draw buffer.
- */
- GrInOrderDrawBuffer(GrContext* context);
-
- ~GrInOrderDrawBuffer() override;
-
- void clearStencilClip(const SkIRect& rect,
- bool insideClip,
- GrRenderTarget* renderTarget) override;
-
- void discard(GrRenderTarget*) override;
-
-protected:
- void appendIndicesAndTransforms(const void* indexValues, PathIndexType indexType,
- const float* transformValues, PathTransformType transformType,
- int count, char** indicesLocation, float** xformsLocation) {
- int indexBytes = GrPathRange::PathIndexSizeInBytes(indexType);
- *indicesLocation = (char*) fPathIndexBuffer.alloc(count * indexBytes,
- SkChunkAlloc::kThrow_AllocFailType);
- SkASSERT(SkIsAlign4((uintptr_t)*indicesLocation));
- memcpy(*indicesLocation, reinterpret_cast<const char*>(indexValues), count * indexBytes);
-
- const int xformBytes = GrPathRendering::PathTransformSize(transformType) * sizeof(float);
- *xformsLocation = NULL;
-
- if (0 != xformBytes) {
- *xformsLocation = (float*) fPathTransformBuffer.alloc(count * xformBytes,
- SkChunkAlloc::kThrow_AllocFailType);
- SkASSERT(SkIsAlign4((uintptr_t)*xformsLocation));
- memcpy(*xformsLocation, transformValues, count * xformBytes);
- }
- }
-
-private:
- friend class GrInOrderCommandBuilder;
- friend class GrTargetCommands;
-
- typedef GrTargetCommands::State State;
-
- State* allocState(const GrPrimitiveProcessor* primProc = NULL) {
- void* allocation = fPipelineBuffer.alloc(sizeof(State), SkChunkAlloc::kThrow_AllocFailType);
- return SkNEW_PLACEMENT_ARGS(allocation, State, (primProc));
- }
-
- void unallocState(State* state) {
- state->unref();
- fPipelineBuffer.unalloc(state);
- }
-
- void onReset() override;
- void onFlush() override;
-
- // overrides from GrDrawTarget
- void onDrawBatch(GrBatch*, const PipelineInfo&) override;
- void onStencilPath(const GrPipelineBuilder&,
- const GrPathProcessor*,
- const GrPath*,
- const GrScissorState&,
- const GrStencilSettings&) override;
- void onDrawPath(const GrPathProcessor*,
- const GrPath*,
- const GrStencilSettings&,
- const PipelineInfo&) override;
- void onDrawPaths(const GrPathProcessor*,
- const GrPathRange*,
- const void* indices,
- PathIndexType,
- const float transformValues[],
- PathTransformType,
- int count,
- const GrStencilSettings&,
- const PipelineInfo&) override;
- void onClear(const SkIRect* rect,
- GrColor color,
- bool canIgnoreRect,
- GrRenderTarget* renderTarget) override;
- void onCopySurface(GrSurface* dst,
- GrSurface* src,
- const SkIRect& srcRect,
- const SkIPoint& dstPoint) override;
-
- // Records any trace markers for a command
- void recordTraceMarkersIfNecessary(GrTargetCommands::Cmd*);
- SkString getCmdString(int index) const {
- SkASSERT(index < fGpuCmdMarkers.count());
- return fGpuCmdMarkers[index].toString();
- }
- bool isIssued(uint32_t drawID) override { return drawID != fDrawID; }
-
- State* SK_WARN_UNUSED_RESULT setupPipelineAndShouldDraw(const GrPrimitiveProcessor*,
- const GrDrawTarget::PipelineInfo&);
- State* SK_WARN_UNUSED_RESULT setupPipelineAndShouldDraw(GrBatch*,
- const GrDrawTarget::PipelineInfo&);
-
- // TODO: Use a single allocator for commands and records
- enum {
- kPathIdxBufferMinReserve = 2 * 64, // 64 uint16_t's
- kPathXformBufferMinReserve = 2 * 64, // 64 two-float transforms
- kPipelineBufferMinReserve = 32 * sizeof(State),
- };
-
- // every 100 flushes we should reset our fPipelineBuffer to prevent us from holding at a
- // highwater mark
- static const int kPipelineBufferHighWaterMark = 100;
-
- SkAutoTDelete<GrCommandBuilder> fCommands;
- SkTArray<GrTraceMarkerSet, false> fGpuCmdMarkers;
- SkChunkAlloc fPathIndexBuffer;
- SkChunkAlloc fPathTransformBuffer;
- SkChunkAlloc fPipelineBuffer;
- uint32_t fDrawID;
- SkAutoTUnref<State> fPrevState;
-
- typedef GrClipTarget INHERITED;
-};
-
-#endif
}
Cmd* recordDrawPaths(State*,
- GrInOrderDrawBuffer*,
+ GrBufferedDrawTarget*,
const GrPathProcessor*,
const GrPathRange*,
const void*,
#include "GrTargetCommands.h"
-#include "GrInOrderDrawBuffer.h"
+#include "GrBufferedDrawTarget.h"
void GrTargetCommands::reset() {
fCmdBuffer.reset();
fBatchTarget.reset();
}
-void GrTargetCommands::flush(GrInOrderDrawBuffer* iodb) {
+void GrTargetCommands::flush(GrBufferedDrawTarget* bufferedDrawTarget) {
if (fCmdBuffer.empty()) {
return;
}
- GrGpu* gpu = iodb->getGpu();
+ GrGpu* gpu = bufferedDrawTarget->getGpu();
// Loop over all batches and generate geometry
CmdBuffer::Iter genIter(fCmdBuffer);
GrGpuTraceMarker newMarker("", -1);
SkString traceString;
if (iter->isTraced()) {
- traceString = iodb->getCmdString(iter->markerID());
+ traceString = bufferedDrawTarget->getCmdString(iter->markerID());
newMarker.fMarker = traceString.c_str();
gpu->addGpuTraceMarker(&newMarker);
}
#include "SkRect.h"
#include "SkTypes.h"
-class GrInOrderDrawBuffer;
+class GrBufferedDrawTarget;
class GrTargetCommands : ::SkNoncopyable {
};
void reset();
- void flush(GrInOrderDrawBuffer*);
+ void flush(GrBufferedDrawTarget*);
private:
friend class GrCommandBuilder;
- friend class GrInOrderDrawBuffer; // This goes away when State becomes just a pipeline
+ friend class GrBufferedDrawTarget; // This goes away when State becomes just a pipeline
friend class GrReorderCommandBuilder;
typedef GrGpu::DrawArgs DrawArgs;
- void recordXferBarrierIfNecessary(const GrPipeline&, GrInOrderDrawBuffer*);
+ void recordXferBarrierIfNecessary(const GrPipeline&, GrBufferedDrawTarget*);
// TODO: This can be just a pipeline once paths are in batch, and it should live elsewhere
struct State : public SkNVRefCnt<State> {
*/
#include "GrTest.h"
+
+#include "GrBufferedDrawTarget.h"
#include "GrContextOptions.h"
#include "GrGpuResourceCacheAccess.h"
-#include "GrInOrderDrawBuffer.h"
#include "GrResourceCache.h"
#include "SkString.h"
// Code for the mock context. It's built on a mock GrGpu class that does nothing.
////
-#include "GrInOrderDrawBuffer.h"
#include "GrGpu.h"
class GrPipeline;
#ifndef GrTracing_DEFINED
#define GrTracing_DEFINED
+#include "GrBufferedDrawTarget.h"
#include "GrDrawTarget.h"
#include "GrGpu.h"
-#include "GrInOrderDrawBuffer.h"
#include "GrTraceMarker.h"
#include "SkTraceEvent.h"
projects / platform / upstream / libSkiaSharp.git / commitdiff