void GrContext::initCommon() {
fDrawState = SkNEW(GrDrawState);
- fGpu->setDrawState(fDrawState);
fResourceCache = SkNEW_ARGS(GrResourceCache, (fGpu->caps(),
MAX_RESOURCE_CACHE_COUNT,
, 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::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);
}
}
}
-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) {
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;
////////////////////////////////////////////////////////////////////////////////
-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;
}
}
-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;
}
*/
const GrDrawTargetCaps* caps() const { return fCaps.get(); }
- /**
- * Sets the draw state object for the gpu. Note that this does not
- * make a copy. The GrGpu will take a reference to passed object.
- * Passing NULL will cause the GrGpu to use its own internal draw
- * state object rather than an externally provided one.
- */
- void setDrawState(GrDrawState* drawState);
-
- /**
- * Read-only access to the GrGpu current draw state.
- */
- const GrDrawState& getDrawState() const { return *fDrawState; }
-
- /**
- * Read-write access to the GrGpu current draw state. Note that
- * this doesn't ref.
- */
- GrDrawState* drawState() { return fDrawState; }
-
GrPathRendering* pathRendering() {
return fPathRendering.get();
}
void clearStencilClip(const SkIRect& rect,
bool insideClip,
- GrRenderTarget* renderTarget = NULL);
+ GrRenderTarget* renderTarget);
/**
* Discards the contents render target. NULL indicates that the current render target should
* unlocked before draw call. Vertex size is queried
* from current GrDrawState.
*/
- void setVertexSourceToBuffer(const GrVertexBuffer* buffer);
+ void setVertexSourceToBuffer(const GrVertexBuffer* buffer, size_t vertexStride);
/**
* Sets source of index data for the next indexed draw. Data does not have
*/
void setIndexSourceToBuffer(const GrIndexBuffer* buffer);
- virtual void draw(const GrDrawTarget::DrawInfo&,
+ virtual void draw(const GrOptDrawState&,
+ const GrDrawTarget::DrawInfo&,
const GrClipMaskManager::ScissorState&);
- virtual void stencilPath(const GrPath*,
+ virtual void stencilPath(const GrOptDrawState&,
+ const GrPath*,
const GrClipMaskManager::ScissorState&,
const GrStencilSettings&);
- virtual void drawPath(const GrPath*,
+ virtual void drawPath(const GrOptDrawState&,
+ const GrPath*,
const GrClipMaskManager::ScissorState&,
const GrStencilSettings&,
const GrDeviceCoordTexture* dstCopy);
- virtual void drawPaths(const GrPathRange*,
+ virtual void drawPaths(const GrOptDrawState&,
+ const GrPathRange*,
const uint32_t indices[],
int count,
const float transforms[],
const GrStencilSettings&,
const GrDeviceCoordTexture*);
-protected:
- DrawType PrimTypeToDrawType(GrPrimitiveType type) {
+ static DrawType PrimTypeToDrawType(GrPrimitiveType type) {
switch (type) {
case kTriangles_GrPrimitiveType:
case kTriangleStrip_GrPrimitiveType:
}
}
+protected:
// Functions used to map clip-respecting stencil tests into normal
// stencil funcs supported by GPUs.
static GrStencilFunc ConvertStencilFunc(bool stencilInClip,
bool insideClip) = 0;
// overridden by backend-specific derived class to perform the draw call.
- virtual void onDraw(const GrDrawTarget::DrawInfo&) = 0;
+ virtual void onDraw(const GrOptDrawState&, const GrDrawTarget::DrawInfo&) = 0;
// overridden by backend-specific derived class to perform the read pixels.
virtual bool onReadPixels(GrRenderTarget* target,
// deltas from previous state at draw time. This function does the
// backend-specific flush of the state.
// returns false if current state is unsupported.
- virtual bool flushGraphicsState(DrawType,
+ virtual bool flushGraphicsState(const GrOptDrawState&,
+ DrawType,
const GrClipMaskManager::ScissorState&,
const GrDeviceCoordTexture* dstCopy) = 0;
uint32_t fResetBits;
// these are mutable so they can be created on-demand
mutable GrIndexBuffer* fQuadIndexBuffer;
- GrDrawState fDefaultDrawState;
- GrDrawState* fDrawState;
// To keep track that we always have at least as many debug marker adds as removes
int fGpuTraceMarkerCount;
GrTraceMarkerSet fActiveTraceMarkers;
#include "GrBufferAllocPool.h"
#include "GrDrawTargetCaps.h"
-#include "GrTextStrike.h"
#include "GrGpu.h"
+#include "GrOptDrawState.h"
#include "GrTemplates.h"
+#include "GrTextStrike.h"
#include "GrTexture.h"
GrInOrderDrawBuffer::GrInOrderDrawBuffer(GrGpu* gpu,
GeometryPoolState& poolState = fGeoPoolStateStack.back();
const GrDrawState& drawState = this->getDrawState();
- this->recordStateIfNecessary();
+ this->recordStateIfNecessary(GrGpu::PrimTypeToDrawType(info.primitiveType()),
+ info.getDstCopy());
const GrVertexBuffer* vb;
if (kBuffer_GeometrySrcType == this->getGeomSrc().fVertexSrc) {
const GrClipMaskManager::ScissorState& scissorState,
const GrStencilSettings& stencilSettings) {
// Only compare the subset of GrDrawState relevant to path stenciling?
- this->recordStateIfNecessary();
+ this->recordStateIfNecessary(GrGpu::kStencilPath_DrawType, NULL);
StencilPath* sp = GrNEW_APPEND_TO_RECORDER(fCmdBuffer, StencilPath, (path));
sp->fScissorState = scissorState;
sp->fStencilSettings = stencilSettings;
const GrStencilSettings& stencilSettings,
const GrDeviceCoordTexture* dstCopy) {
// TODO: Only compare the subset of GrDrawState relevant to path covering?
- this->recordStateIfNecessary();
+ this->recordStateIfNecessary(GrGpu::kDrawPath_DrawType, dstCopy);
DrawPath* dp = GrNEW_APPEND_TO_RECORDER(fCmdBuffer, DrawPath, (path));
if (dstCopy) {
dp->fDstCopy = *dstCopy;
SkASSERT(indices);
SkASSERT(transforms);
- this->recordStateIfNecessary();
+ this->recordStateIfNecessary(GrGpu::kDrawPaths_DrawType, dstCopy);
int sizeOfIndices = sizeof(uint32_t) * count;
int sizeOfTransforms = sizeof(float) * count *
fVertexPool.unmap();
fIndexPool.unmap();
- GrDrawState* prevDrawState = SkRef(fDstGpu->drawState());
-
CmdBuffer::Iter iter(fCmdBuffer);
int currCmdMarker = 0;
fDstGpu->saveActiveTraceMarkers();
+ // Gpu no longer maintains the current drawstate, so we track the setstate calls below.
+ // NOTE: we always record a new drawstate at flush boundaries
+ SkAutoTUnref<const GrOptDrawState> currentOptState;
+
while (iter.next()) {
GrGpuTraceMarker newMarker("", -1);
SkString traceString;
++currCmdMarker;
}
- SkDEBUGCODE(bool isDraw = kDraw_Cmd == strip_trace_bit(iter->fType) ||
- kStencilPath_Cmd == strip_trace_bit(iter->fType) ||
- kDrawPath_Cmd == strip_trace_bit(iter->fType) ||
- kDrawPaths_Cmd == strip_trace_bit(iter->fType));
- SkASSERT(!isDraw || fDstGpu->drawState() != prevDrawState);
-
- iter->execute(fDstGpu);
+ if (kSetState_Cmd == strip_trace_bit(iter->fType)) {
+ const SetState* ss = reinterpret_cast<const SetState*>(iter.get());
+ currentOptState.reset(GrOptDrawState::Create(ss->fState,
+ fDstGpu,
+ &ss->fDstCopy,
+ ss->fDrawType));
+ } else {
+ iter->execute(fDstGpu, currentOptState.get());
+ }
if (cmd_has_trace_marker(iter->fType)) {
fDstGpu->removeGpuTraceMarker(&newMarker);
fDstGpu->restoreActiveTraceMarkers();
SkASSERT(fGpuCmdMarkers.count() == currCmdMarker);
- fDstGpu->setDrawState(prevDrawState);
- prevDrawState->unref();
this->reset();
++fDrawID;
}
-void GrInOrderDrawBuffer::Draw::execute(GrGpu* gpu) {
- gpu->setVertexSourceToBuffer(this->vertexBuffer());
+void GrInOrderDrawBuffer::Draw::execute(GrGpu* gpu, const GrOptDrawState* optState) {
+ if (!optState) {
+ return;
+ }
+ gpu->setVertexSourceToBuffer(this->vertexBuffer(), optState->getVertexStride());
if (fInfo.isIndexed()) {
gpu->setIndexSourceToBuffer(this->indexBuffer());
}
- gpu->draw(fInfo, fScissorState);
+ gpu->draw(*optState, fInfo, fScissorState);
}
-void GrInOrderDrawBuffer::StencilPath::execute(GrGpu* gpu) {
- gpu->stencilPath(this->path(), fScissorState, fStencilSettings);
+void GrInOrderDrawBuffer::StencilPath::execute(GrGpu* gpu, const GrOptDrawState* optState) {
+ if (!optState) {
+ return;
+ }
+ gpu->stencilPath(*optState, this->path(), fScissorState, fStencilSettings);
}
-void GrInOrderDrawBuffer::DrawPath::execute(GrGpu* gpu) {
- gpu->drawPath(this->path(), fScissorState, fStencilSettings,
- fDstCopy.texture() ? &fDstCopy : NULL);
+void GrInOrderDrawBuffer::DrawPath::execute(GrGpu* gpu, const GrOptDrawState* optState) {
+ if (!optState) {
+ return;
+ }
+ gpu->drawPath(*optState, this->path(), fScissorState, fStencilSettings,
+ fDstCopy.texture() ? &fDstCopy : NULL);
}
-void GrInOrderDrawBuffer::DrawPaths::execute(GrGpu* gpu) {
- gpu->drawPaths(this->pathRange(), this->indices(), fCount, this->transforms(),
- fTransformsType, fScissorState, fStencilSettings,
- fDstCopy.texture() ? &fDstCopy : NULL);
+void GrInOrderDrawBuffer::DrawPaths::execute(GrGpu* gpu, const GrOptDrawState* optState) {
+ if (!optState) {
+ return;
+ }
+ gpu->drawPaths(*optState, this->pathRange(), this->indices(), fCount, this->transforms(),
+ fTransformsType, fScissorState, fStencilSettings,
+ fDstCopy.texture() ? &fDstCopy : NULL);
}
-void GrInOrderDrawBuffer::SetState::execute(GrGpu* gpu) {
- gpu->setDrawState(&fState);
+void GrInOrderDrawBuffer::SetState::execute(GrGpu* gpu, const GrOptDrawState*) {
}
-void GrInOrderDrawBuffer::Clear::execute(GrGpu* gpu) {
+void GrInOrderDrawBuffer::Clear::execute(GrGpu* gpu, const GrOptDrawState*) {
if (GrColor_ILLEGAL == fColor) {
gpu->discard(this->renderTarget());
} else {
}
}
-void GrInOrderDrawBuffer::ClearStencilClip::execute(GrGpu* gpu) {
- gpu->clearStencilClip(fRect, fInsideClip, this->renderTarget());
+void GrInOrderDrawBuffer::ClearStencilClip::execute(GrGpu* gpu, const GrOptDrawState*) {
+ gpu->clearStencilClip(fRect, fInsideClip, this->renderTarget());
}
-void GrInOrderDrawBuffer::CopySurface::execute(GrGpu* gpu) {
+void GrInOrderDrawBuffer::CopySurface::execute(GrGpu* gpu, const GrOptDrawState*){
gpu->copySurface(this->dst(), this->src(), fSrcRect, fDstPoint);
}
// offset into the pool's pointer that was referenced. Now we return to the
// pool any portion at the tail of the allocation that no draw referenced.
size_t reservedVertexBytes = geoSrc.fVertexSize * geoSrc.fVertexCount;
- fVertexPool.putBack(reservedVertexBytes -
- poolState.fUsedPoolVertexBytes);
+ fVertexPool.putBack(reservedVertexBytes - poolState.fUsedPoolVertexBytes);
poolState.fUsedPoolVertexBytes = 0;
poolState.fPoolVertexBuffer = NULL;
poolState.fPoolStartVertex = 0;
poolState.fUsedPoolVertexBytes = restoredState.fVertexSize * restoredState.fVertexCount;
}
if (kReserved_GeometrySrcType == restoredState.fIndexSrc) {
- poolState.fUsedPoolIndexBytes = sizeof(uint16_t) *
- restoredState.fIndexCount;
+ poolState.fUsedPoolIndexBytes = sizeof(uint16_t) * restoredState.fIndexCount;
}
}
-void GrInOrderDrawBuffer::recordStateIfNecessary() {
+void GrInOrderDrawBuffer::recordStateIfNecessary(GrGpu::DrawType drawType,
+ const GrDeviceCoordTexture* dstCopy) {
if (!fLastState) {
SetState* ss = GrNEW_APPEND_TO_RECORDER(fCmdBuffer, SetState, (this->getDrawState()));
fLastState = &ss->fState;
+ if (dstCopy) {
+ ss->fDstCopy = *dstCopy;
+ }
+ ss->fDrawType = drawType;
this->convertDrawStateToPendingExec(fLastState);
this->recordTraceMarkersIfNecessary();
return;
}
const GrDrawState& curr = this->getDrawState();
switch (GrDrawState::CombineIfPossible(*fLastState, curr, *this->caps())) {
- case GrDrawState::kIncompatible_CombinedState:
- fLastState = &GrNEW_APPEND_TO_RECORDER(fCmdBuffer, SetState, (curr))->fState;
+ case GrDrawState::kIncompatible_CombinedState: {
+ SetState* ss = GrNEW_APPEND_TO_RECORDER(fCmdBuffer, SetState, (curr));
+ fLastState = &ss->fState;
+ if (dstCopy) {
+ ss->fDstCopy = *dstCopy;
+ }
+ ss->fDrawType = drawType;
this->convertDrawStateToPendingExec(fLastState);
this->recordTraceMarkersIfNecessary();
break;
+ }
case GrDrawState::kA_CombinedState:
case GrDrawState::kAOrB_CombinedState: // Treat the same as kA.
break;
#include "GrDrawTarget.h"
#include "GrAllocPool.h"
#include "GrAllocator.h"
+#include "GrGpu.h"
#include "GrIndexBuffer.h"
#include "GrRenderTarget.h"
#include "GrPath.h"
#include "SkTemplates.h"
#include "SkTypes.h"
-class GrGpu;
class GrIndexBufferAllocPool;
class GrVertexBufferAllocPool;
Cmd(uint8_t type) : fType(type) {}
virtual ~Cmd() {}
- virtual void execute(GrGpu*) = 0;
+ virtual void execute(GrGpu*, const GrOptDrawState*) = 0;
uint8_t fType;
};
const GrVertexBuffer* vertexBuffer() const { return fVertexBuffer.get(); }
const GrIndexBuffer* indexBuffer() const { return fIndexBuffer.get(); }
- virtual void execute(GrGpu*);
+ virtual void execute(GrGpu*, const GrOptDrawState*);
DrawInfo fInfo;
ScissorState fScissorState;
const GrPath* path() const { return fPath.get(); }
- virtual void execute(GrGpu*);
+ virtual void execute(GrGpu*, const GrOptDrawState*);
ScissorState fScissorState;
GrStencilSettings fStencilSettings;
const GrPath* path() const { return fPath.get(); }
- virtual void execute(GrGpu*);
+ virtual void execute(GrGpu*, const GrOptDrawState*);
GrDeviceCoordTexture fDstCopy;
ScissorState fScissorState;
uint32_t* indices() { return reinterpret_cast<uint32_t*>(CmdBuffer::GetDataForItem(this)); }
float* transforms() { return reinterpret_cast<float*>(&this->indices()[fCount]); }
- virtual void execute(GrGpu*);
+ virtual void execute(GrGpu*, const GrOptDrawState*);
size_t fCount;
PathTransformType fTransformsType;
GrRenderTarget* renderTarget() const { return fRenderTarget.get(); }
- virtual void execute(GrGpu*);
+ virtual void execute(GrGpu*, const GrOptDrawState*);
SkIRect fRect;
GrColor fColor;
GrRenderTarget* renderTarget() const { return fRenderTarget.get(); }
- virtual void execute(GrGpu*);
+ virtual void execute(GrGpu*, const GrOptDrawState*);
SkIRect fRect;
bool fInsideClip;
GrSurface* dst() const { return fDst.get(); }
GrSurface* src() const { return fSrc.get(); }
- virtual void execute(GrGpu*);
+ virtual void execute(GrGpu*, const GrOptDrawState*);
SkIPoint fDstPoint;
SkIRect fSrcRect;
struct SetState : public Cmd {
SetState(const GrDrawState& state) : Cmd(kSetState_Cmd), fState(state) {}
- virtual void execute(GrGpu*);
+ virtual void execute(GrGpu*, const GrOptDrawState*);
GrDrawState fState;
+ GrGpu::DrawType fDrawType;
+ GrDeviceCoordTexture fDstCopy;
};
typedef void* TCmdAlign; // This wouldn't be enough align if a command used long double.
int concatInstancedDraw(const DrawInfo& info, const GrClipMaskManager::ScissorState&);
// Determines whether the current draw operation requieres a new drawstate and if so records it.
- void recordStateIfNecessary();
+ void recordStateIfNecessary(GrGpu::DrawType, const GrDeviceCoordTexture*);
// We lazily record clip changes in order to skip clips that have no effect.
void recordClipIfNecessary();
// Records any trace markers for a command after adding it to the buffer.
#include "GrInOrderDrawBuffer.h"
#include "GrGpu.h"
+class GrOptDrawState;
+
class MockGpu : public GrGpu {
public:
MockGpu(GrContext* context) : INHERITED(context) { fCaps.reset(SkNEW(GrDrawTargetCaps)); }
const SkIRect& rect,
bool insideClip) SK_OVERRIDE { }
- virtual void onDraw(const GrDrawTarget::DrawInfo&) SK_OVERRIDE { }
+ virtual void onDraw(const GrOptDrawState&, const GrDrawTarget::DrawInfo&) SK_OVERRIDE { }
virtual bool onReadPixels(GrRenderTarget* target,
int left, int top, int width, int height,
GrPixelConfig,
return false;
}
- virtual bool flushGraphicsState(DrawType,
+ virtual bool flushGraphicsState(const GrOptDrawState&,
+ DrawType,
const GrClipMaskManager::ScissorState&,
const GrDeviceCoordTexture* dstCopy) SK_OVERRIDE {
return false;
void GrGLPathRendering::stencilPath(const GrPath* path, const GrStencilSettings& stencilSettings) {
GrGLuint id = static_cast<const GrGLPath*>(path)->pathID();
- SkASSERT(fGpu->drawState()->getRenderTarget());
- SkASSERT(fGpu->drawState()->getRenderTarget()->getStencilBuffer());
this->flushPathStencilSettings(stencilSettings);
SkASSERT(!fHWPathStencilSettings.isTwoSided());
void GrGLPathRendering::drawPath(const GrPath* path, const GrStencilSettings& stencilSettings) {
GrGLuint id = static_cast<const GrGLPath*>(path)->pathID();
- SkASSERT(fGpu->drawState()->getRenderTarget());
- SkASSERT(fGpu->drawState()->getRenderTarget()->getStencilBuffer());
this->flushPathStencilSettings(stencilSettings);
SkASSERT(!fHWPathStencilSettings.isTwoSided());
const float transforms[], PathTransformType transformsType,
const GrStencilSettings& stencilSettings) {
SkASSERT(fGpu->caps()->pathRenderingSupport());
- SkASSERT(fGpu->drawState()->getRenderTarget());
- SkASSERT(fGpu->drawState()->getRenderTarget()->getStencilBuffer());
GrGLuint baseID = static_cast<const GrGLPathRange*>(pathRange)->basePathID();
#endif
#endif
-void GrGpuGL::onDraw(const GrDrawTarget::DrawInfo& info) {
+void GrGpuGL::onDraw(const GrOptDrawState& ds, const GrDrawTarget::DrawInfo& info) {
size_t indexOffsetInBytes;
- this->setupGeometry(info, &indexOffsetInBytes);
+ this->setupGeometry(ds, info, &indexOffsetInBytes);
SkASSERT((size_t)info.primitiveType() < SK_ARRAY_COUNT(gPrimitiveType2GLMode));
virtual void onResolveRenderTarget(GrRenderTarget* target) SK_OVERRIDE;
- virtual void onDraw(const GrDrawTarget::DrawInfo&) SK_OVERRIDE;
+ virtual void onDraw(const GrOptDrawState&, const GrDrawTarget::DrawInfo&) SK_OVERRIDE;
virtual void clearStencil(GrRenderTarget*) SK_OVERRIDE;
- virtual bool flushGraphicsState(DrawType,
+ virtual bool flushGraphicsState(const GrOptDrawState&,
+ DrawType,
const GrClipMaskManager::ScissorState&,
const GrDeviceCoordTexture* dstCopy) SK_OVERRIDE;
// Sets up vertex attribute pointers and strides. On return indexOffsetInBytes gives the offset
// an into the index buffer. It does not account for drawInfo.startIndex() but rather the start
// index is relative to the returned offset.
- void setupGeometry(const GrDrawTarget::DrawInfo& info, size_t* indexOffsetInBytes);
+ void setupGeometry(const GrOptDrawState&,
+ const GrDrawTarget::DrawInfo& info,
+ size_t* indexOffsetInBytes);
// Subclasses should call this to flush the blend state.
// The params should be the final coefficients to apply
#define GL_CALL(X) GR_GL_CALL(this->glInterface(), X)
-bool GrGpuGL::flushGraphicsState(DrawType type,
+bool GrGpuGL::flushGraphicsState(const GrOptDrawState& optState,
+ DrawType type,
const GrClipMaskManager::ScissorState& scissorState,
const GrDeviceCoordTexture* dstCopy) {
- SkAutoTUnref<GrOptDrawState> optState(GrOptDrawState::Create(this->getDrawState(),
- this,
- dstCopy,
- type));
-
- if (!optState) {
- return false;
- }
-
// GrGpu::setupClipAndFlushState should have already checked this and bailed if not true.
- SkASSERT(optState->getRenderTarget());
+ SkASSERT(optState.getRenderTarget());
if (kStencilPath_DrawType == type) {
- const GrRenderTarget* rt = optState->getRenderTarget();
+ const GrRenderTarget* rt = optState.getRenderTarget();
SkISize size;
size.set(rt->width(), rt->height());
- this->glPathRendering()->setProjectionMatrix(optState->getViewMatrix(), size, rt->origin());
+ this->glPathRendering()->setProjectionMatrix(optState.getViewMatrix(), size, rt->origin());
} else {
- this->flushMiscFixedFunctionState(*optState.get());
+ this->flushMiscFixedFunctionState(optState);
- GrBlendCoeff srcCoeff = optState->getSrcBlendCoeff();
- GrBlendCoeff dstCoeff = optState->getDstBlendCoeff();
+ 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()) {
+ !optState.getStencil().doesWrite()) {
return false;
}
- fCurrentProgram.reset(fProgramCache->getProgram(*optState.get(), type));
+ fCurrentProgram.reset(fProgramCache->getProgram(optState, type));
if (NULL == fCurrentProgram.get()) {
SkDEBUGFAIL("Failed to create program!");
return false;
fHWProgramID = programID;
}
- this->flushBlend(*optState.get(), kDrawLines_DrawType == type, srcCoeff, dstCoeff);
+ this->flushBlend(optState, kDrawLines_DrawType == type, srcCoeff, dstCoeff);
- fCurrentProgram->setData(*optState.get(), type, dstCopy);
+ fCurrentProgram->setData(optState, type, dstCopy);
}
- GrGLRenderTarget* glRT = static_cast<GrGLRenderTarget*>(optState->getRenderTarget());
- this->flushStencil(optState->getStencil(), type);
+ GrGLRenderTarget* glRT = static_cast<GrGLRenderTarget*>(optState.getRenderTarget());
+ this->flushStencil(optState.getStencil(), type);
this->flushScissor(scissorState, glRT->getViewport(), glRT->origin());
- this->flushAAState(*optState.get(), type);
+ this->flushAAState(optState, type);
// This must come after textures are flushed because a texture may need
// to be msaa-resolved (which will modify bound FBO state).
return true;
}
-void GrGpuGL::setupGeometry(const GrDrawTarget::DrawInfo& info, size_t* indexOffsetInBytes) {
- SkAutoTUnref<GrOptDrawState> optState(
- GrOptDrawState::Create(this->getDrawState(), this, info.getDstCopy(),
- PrimTypeToDrawType(info.primitiveType())));
-
- // If the optState would is NULL it should have been caught in flushGraphicsState before getting
- // here.
- SkASSERT(optState);
-
- GrGLsizei stride = static_cast<GrGLsizei>(optState->getVertexStride());
+void GrGpuGL::setupGeometry(const GrOptDrawState& optState,
+ const GrDrawTarget::DrawInfo& info,
+ size_t* indexOffsetInBytes) {
+ GrGLsizei stride = static_cast<GrGLsizei>(optState.getVertexStride());
size_t vertexOffsetInBytes = stride * info.startVertex();
fHWGeometryState.bindArrayAndBuffersToDraw(this, vbuf, ibuf);
if (fCurrentProgram->hasVertexShader()) {
- int vertexAttribCount = optState->getVertexAttribCount();
+ int vertexAttribCount = optState.getVertexAttribCount();
uint32_t usedAttribArraysMask = 0;
- const GrVertexAttrib* vertexAttrib = optState->getVertexAttribs();
+ const GrVertexAttrib* vertexAttrib = optState.getVertexAttribs();
for (int vertexAttribIndex = 0; vertexAttribIndex < vertexAttribCount;
++vertexAttribIndex, ++vertexAttrib) {
projects / platform / upstream / libSkiaSharp.git / commitdiff