aboutsummaryrefslogtreecommitdiffhomepage
diff options
context:
space:
mode:
Diffstat
-rw-r--r--src/gpu/GrGpu.cpp8
-rw-r--r--src/gpu/GrGpu.h2
-rw-r--r--src/gpu/GrInOrderDrawBuffer.cpp6
-rw-r--r--src/gpu/GrInOrderDrawBuffer.h10
-rw-r--r--src/gpu/GrOptDrawState.cpp104
-rw-r--r--src/gpu/GrOptDrawState.h35
-rw-r--r--src/gpu/GrProgramDesc.h2
-rw-r--r--src/gpu/GrTest.cpp2
-rw-r--r--src/gpu/gl/GrGLProgram.cpp19
-rw-r--r--src/gpu/gl/GrGLProgram.h8
-rw-r--r--src/gpu/gl/GrGLProgramDesc.cpp2
-rw-r--r--src/gpu/gl/GrGpuGL.cpp4
-rw-r--r--src/gpu/gl/GrGpuGL.h6
-rw-r--r--src/gpu/gl/GrGpuGL_program.cpp18
-rw-r--r--src/gpu/gl/builders/GrGLGeometryShaderBuilder.cpp4
-rw-r--r--src/gpu/gl/builders/GrGLProgramBuilder.cpp10
-rw-r--r--src/gpu/gl/builders/GrGLProgramBuilder.h3
-rw-r--r--tests/GLProgramsTest.cpp5
18 files changed, 113 insertions, 135 deletions
diff --git a/src/gpu/GrGpu.cpp b/src/gpu/GrGpu.cpp
index d97809f952..ac76e1503c 100644
--- a/src/gpu/GrGpu.cpp
+++ b/src/gpu/GrGpu.cpp
@@ -277,7 +277,7 @@ const GrIndexBuffer* GrGpu::getQuadIndexBuffer() const {
void GrGpu::draw(const GrOptDrawState& ds, const GrDrawTarget::DrawInfo& info) {
this->handleDirtyContext();
- if (!this->flushGraphicsState(ds, PrimTypeToDrawType(info.primitiveType()))) {
+ if (!this->flushGraphicsState(ds)) {
return;
}
this->onDraw(ds, info);
@@ -288,7 +288,7 @@ void GrGpu::stencilPath(const GrOptDrawState& ds,
const GrStencilSettings& stencilSettings) {
this->handleDirtyContext();
- if (!this->flushGraphicsState(ds, kStencilPath_DrawType)) {
+ if (!this->flushGraphicsState(ds)) {
return;
}
@@ -301,7 +301,7 @@ void GrGpu::drawPath(const GrOptDrawState& ds,
const GrStencilSettings& stencilSettings) {
this->handleDirtyContext();
- if (!this->flushGraphicsState(ds, kDrawPath_DrawType)) {
+ if (!this->flushGraphicsState(ds)) {
return;
}
@@ -318,7 +318,7 @@ void GrGpu::drawPaths(const GrOptDrawState& ds,
const GrStencilSettings& stencilSettings) {
this->handleDirtyContext();
- if (!this->flushGraphicsState(ds, kDrawPaths_DrawType)) {
+ if (!this->flushGraphicsState(ds)) {
return;
}
diff --git a/src/gpu/GrGpu.h b/src/gpu/GrGpu.h
index d0bff30262..c88e1c85d0 100644
--- a/src/gpu/GrGpu.h
+++ b/src/gpu/GrGpu.h
@@ -469,7 +469,7 @@ private:
// 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(const GrOptDrawState&, DrawType) = 0;
+ virtual bool flushGraphicsState(const GrOptDrawState&) = 0;
// clears target's entire stencil buffer to 0
virtual void clearStencil(GrRenderTarget* target) = 0;
diff --git a/src/gpu/GrInOrderDrawBuffer.cpp b/src/gpu/GrInOrderDrawBuffer.cpp
index 5533174853..83b9701f09 100644
--- a/src/gpu/GrInOrderDrawBuffer.cpp
+++ b/src/gpu/GrInOrderDrawBuffer.cpp
@@ -394,7 +394,7 @@ void GrInOrderDrawBuffer::onFlush() {
// Updated every time we find a set state cmd to reflect the current state in the playback
// stream.
- const GrOptDrawState* currentOptState = NULL;
+ GrOptDrawState* currentOptState = NULL;
while (iter.next()) {
GrGpuTraceMarker newMarker("", -1);
@@ -409,6 +409,7 @@ void GrInOrderDrawBuffer::onFlush() {
if (kSetState_Cmd == strip_trace_bit(iter->fType)) {
SetState* ss = reinterpret_cast<SetState*>(iter.get());
currentOptState = &ss->fState;
+ currentOptState->finalize(this->getGpu());
} else {
iter->execute(this, currentOptState);
}
@@ -486,7 +487,8 @@ bool GrInOrderDrawBuffer::recordStateAndShouldDraw(const GrDrawState& ds,
const GrClipMaskManager::ScissorState& scissor,
const GrDeviceCoordTexture* dstCopy) {
SetState* ss = GrNEW_APPEND_TO_RECORDER(fCmdBuffer, SetState,
- (ds, this->getGpu(), scissor, dstCopy, drawType));
+ (ds, *this->getGpu()->caps(), scissor, dstCopy,
+ drawType));
if (ss->fState.mustSkip()) {
fCmdBuffer.pop_back();
return false;
diff --git a/src/gpu/GrInOrderDrawBuffer.h b/src/gpu/GrInOrderDrawBuffer.h
index 532842a3b4..01e560ac08 100644
--- a/src/gpu/GrInOrderDrawBuffer.h
+++ b/src/gpu/GrInOrderDrawBuffer.h
@@ -171,15 +171,15 @@ private:
};
struct SetState : public Cmd {
- SetState(const GrDrawState& drawState, GrGpu* gpu, const ScissorState& scissor,
- const GrDeviceCoordTexture* dstCopy, GrGpu::DrawType drawType)
+ SetState(const GrDrawState& drawState, const GrDrawTargetCaps& caps,
+ const ScissorState& scissor, const GrDeviceCoordTexture* dstCopy,
+ GrGpu::DrawType drawType)
: Cmd(kSetState_Cmd)
- , fState(drawState, gpu, scissor, dstCopy, drawType) {}
+ , fState(drawState, caps, scissor, dstCopy, drawType) {}
void execute(GrInOrderDrawBuffer*, const GrOptDrawState*) SK_OVERRIDE;
- const GrOptDrawState fState;
- GrGpu::DrawType fDrawType;
+ GrOptDrawState fState;
};
typedef void* TCmdAlign; // This wouldn't be enough align if a command used long double.
diff --git a/src/gpu/GrOptDrawState.cpp b/src/gpu/GrOptDrawState.cpp
index 6f6f0af888..6eee0c25a3 100644
--- a/src/gpu/GrOptDrawState.cpp
+++ b/src/gpu/GrOptDrawState.cpp
@@ -13,11 +13,12 @@
#include "GrProcOptInfo.h"
GrOptDrawState::GrOptDrawState(const GrDrawState& drawState,
- GrGpu* gpu,
+ const GrDrawTargetCaps& caps,
const ScissorState& scissorState,
const GrDeviceCoordTexture* dstCopy,
- GrGpu::DrawType drawType) {
-
+ GrGpu::DrawType drawType)
+ : fFinalized(false) {
+ fDrawType = drawType;
GrBlendCoeff optSrcCoeff;
GrBlendCoeff optDstCoeff;
GrDrawState::BlendOpt blendOpt = drawState.getBlendOpt(false, &optSrcCoeff, &optDstCoeff);
@@ -52,8 +53,6 @@ GrOptDrawState::GrOptDrawState(const GrDrawState& drawState,
fDstCopy = *dstCopy;
}
- GrProgramDesc::DescInfo descInfo;
-
fFlags = 0;
if (drawState.isHWAntialias()) {
fFlags |= kHWAA_Flag;
@@ -65,34 +64,33 @@ GrOptDrawState::GrOptDrawState(const GrDrawState& drawState,
fFlags |= kDither_Flag;
}
- descInfo.fHasVertexColor = drawState.hasGeometryProcessor() &&
- drawState.getGeometryProcessor()->hasVertexColor();
+ fDescInfo.fHasVertexColor = drawState.hasGeometryProcessor() &&
+ drawState.getGeometryProcessor()->hasVertexColor();
- descInfo.fHasVertexCoverage = drawState.hasGeometryProcessor() &&
- drawState.getGeometryProcessor()->hasVertexCoverage();
+ fDescInfo.fHasVertexCoverage = drawState.hasGeometryProcessor() &&
+ drawState.getGeometryProcessor()->hasVertexCoverage();
bool hasLocalCoords = drawState.hasGeometryProcessor() &&
drawState.getGeometryProcessor()->hasLocalCoords();
const GrProcOptInfo& colorPOI = drawState.colorProcInfo();
int firstColorStageIdx = colorPOI.firstEffectiveStageIndex();
- descInfo.fInputColorIsUsed = colorPOI.inputColorIsUsed();
+ fDescInfo.fInputColorIsUsed = colorPOI.inputColorIsUsed();
fColor = colorPOI.inputColorToEffectiveStage();
if (colorPOI.removeVertexAttrib()) {
- descInfo.fHasVertexColor = false;
+ fDescInfo.fHasVertexColor = false;
}
// TODO: Once we can handle single or four channel input into coverage stages then we can use
// drawState's coverageProcInfo (like color above) to set this initial information.
int firstCoverageStageIdx = 0;
- descInfo.fInputCoverageIsUsed = true;
+ fDescInfo.fInputCoverageIsUsed = true;
fCoverage = drawState.getCoverage();
- this->adjustProgramForBlendOpt(drawState, blendOpt, &descInfo, &firstColorStageIdx,
+ this->adjustProgramForBlendOpt(drawState, blendOpt, &firstColorStageIdx,
&firstCoverageStageIdx);
- this->getStageStats(drawState, firstColorStageIdx, firstCoverageStageIdx, hasLocalCoords,
- &descInfo);
+ this->getStageStats(drawState, firstColorStageIdx, firstCoverageStageIdx, hasLocalCoords);
// Copy GeometryProcesssor from DS or ODS
SkASSERT(GrGpu::IsPathRenderingDrawType(drawType) ||
@@ -118,19 +116,15 @@ GrOptDrawState::GrOptDrawState(const GrDrawState& drawState,
(drawState.fCoverageStages[i], hasLocalCoords));
}
- this->setOutputStateInfo(drawState, blendOpt, *gpu->caps(), &descInfo);
-
- // now create a key
- gpu->buildProgramDesc(*this, descInfo, drawType, &fDesc);
+ this->setOutputStateInfo(drawState, blendOpt, caps);
};
void GrOptDrawState::setOutputStateInfo(const GrDrawState& ds,
GrDrawState::BlendOpt blendOpt,
- const GrDrawTargetCaps& caps,
- GrProgramDesc::DescInfo* descInfo) {
+ const GrDrawTargetCaps& caps) {
// Set this default and then possibly change our mind if there is coverage.
- descInfo->fPrimaryOutputType = GrProgramDesc::kModulate_PrimaryOutputType;
- descInfo->fSecondaryOutputType = GrProgramDesc::kNone_SecondaryOutputType;
+ fDescInfo.fPrimaryOutputType = GrProgramDesc::kModulate_PrimaryOutputType;
+ fDescInfo.fSecondaryOutputType = GrProgramDesc::kNone_SecondaryOutputType;
// Determine whether we should use dual source blending or shader code to keep coverage
// separate from color.
@@ -140,28 +134,27 @@ void GrOptDrawState::setOutputStateInfo(const GrDrawState& ds,
if (caps.dualSourceBlendingSupport()) {
if (kZero_GrBlendCoeff == fDstBlend) {
// write the coverage value to second color
- descInfo->fSecondaryOutputType = GrProgramDesc::kCoverage_SecondaryOutputType;
+ fDescInfo.fSecondaryOutputType = GrProgramDesc::kCoverage_SecondaryOutputType;
fDstBlend = (GrBlendCoeff)GrGpu::kIS2C_GrBlendCoeff;
} else if (kSA_GrBlendCoeff == fDstBlend) {
// SA dst coeff becomes 1-(1-SA)*coverage when dst is partially covered.
- descInfo->fSecondaryOutputType = GrProgramDesc::kCoverageISA_SecondaryOutputType;
+ fDescInfo.fSecondaryOutputType = GrProgramDesc::kCoverageISA_SecondaryOutputType;
fDstBlend = (GrBlendCoeff)GrGpu::kIS2C_GrBlendCoeff;
} else if (kSC_GrBlendCoeff == fDstBlend) {
// SA dst coeff becomes 1-(1-SA)*coverage when dst is partially covered.
- descInfo->fSecondaryOutputType = GrProgramDesc::kCoverageISC_SecondaryOutputType;
+ fDescInfo.fSecondaryOutputType = GrProgramDesc::kCoverageISC_SecondaryOutputType;
fDstBlend = (GrBlendCoeff)GrGpu::kIS2C_GrBlendCoeff;
}
- } else if (descInfo->fReadsDst &&
+ } else if (fDescInfo.fReadsDst &&
kOne_GrBlendCoeff == fSrcBlend &&
kZero_GrBlendCoeff == fDstBlend) {
- descInfo->fPrimaryOutputType = GrProgramDesc::kCombineWithDst_PrimaryOutputType;
+ fDescInfo.fPrimaryOutputType = GrProgramDesc::kCombineWithDst_PrimaryOutputType;
}
}
}
void GrOptDrawState::adjustProgramForBlendOpt(const GrDrawState& ds,
GrDrawState::BlendOpt blendOpt,
- GrProgramDesc::DescInfo* descInfo,
int* firstColorStageIdx,
int* firstCoverageStageIdx) {
switch (blendOpt) {
@@ -171,19 +164,19 @@ void GrOptDrawState::adjustProgramForBlendOpt(const GrDrawState& ds,
break;
case GrDrawState::kEmitCoverage_BlendOpt:
fColor = 0xffffffff;
- descInfo->fInputColorIsUsed = true;
+ fDescInfo.fInputColorIsUsed = true;
*firstColorStageIdx = ds.numColorStages();
- descInfo->fHasVertexColor = false;
+ fDescInfo.fHasVertexColor = false;
break;
case GrDrawState::kEmitTransBlack_BlendOpt:
fColor = 0;
fCoverage = 0xff;
- descInfo->fInputColorIsUsed = true;
- descInfo->fInputCoverageIsUsed = true;
+ fDescInfo.fInputColorIsUsed = true;
+ fDescInfo.fInputCoverageIsUsed = true;
*firstColorStageIdx = ds.numColorStages();
*firstCoverageStageIdx = ds.numCoverageStages();
- descInfo->fHasVertexColor = false;
- descInfo->fHasVertexCoverage = false;
+ fDescInfo.fHasVertexColor = false;
+ fDescInfo.fHasVertexCoverage = false;
break;
}
}
@@ -198,46 +191,57 @@ static void get_stage_stats(const GrFragmentStage& stage, bool* readsDst, bool*
}
void GrOptDrawState::getStageStats(const GrDrawState& ds, int firstColorStageIdx,
- int firstCoverageStageIdx, bool hasLocalCoords,
- GrProgramDesc::DescInfo* descInfo) {
+ int firstCoverageStageIdx, bool hasLocalCoords) {
// We will need a local coord attrib if there is one currently set on the optState and we are
// actually generating some effect code
- descInfo->fRequiresLocalCoordAttrib = hasLocalCoords &&
+ fDescInfo.fRequiresLocalCoordAttrib = hasLocalCoords &&
ds.numTotalStages() - firstColorStageIdx - firstCoverageStageIdx > 0;
- descInfo->fReadsDst = false;
- descInfo->fReadsFragPosition = false;
+ fDescInfo.fReadsDst = false;
+ fDescInfo.fReadsFragPosition = false;
for (int s = firstColorStageIdx; s < ds.numColorStages(); ++s) {
const GrFragmentStage& stage = ds.getColorStage(s);
- get_stage_stats(stage, &descInfo->fReadsDst, &descInfo->fReadsFragPosition);
+ get_stage_stats(stage, &fDescInfo.fReadsDst, &fDescInfo.fReadsFragPosition);
}
for (int s = firstCoverageStageIdx; s < ds.numCoverageStages(); ++s) {
const GrFragmentStage& stage = ds.getCoverageStage(s);
- get_stage_stats(stage, &descInfo->fReadsDst, &descInfo->fReadsFragPosition);
+ get_stage_stats(stage, &fDescInfo.fReadsDst, &fDescInfo.fReadsFragPosition);
}
if (ds.hasGeometryProcessor()) {
const GrGeometryProcessor& gp = *ds.getGeometryProcessor();
- descInfo->fReadsFragPosition = descInfo->fReadsFragPosition || gp.willReadFragmentPosition();
+ fDescInfo.fReadsFragPosition = fDescInfo.fReadsFragPosition || gp.willReadFragmentPosition();
}
}
+void GrOptDrawState::finalize(GrGpu* gpu) {
+ gpu->buildProgramDesc(*this, fDescInfo, fDrawType, &fDesc);
+ fFinalized = true;
+}
+
////////////////////////////////////////////////////////////////////////////////
bool GrOptDrawState::operator== (const GrOptDrawState& that) const {
- if (this->fDesc != that.fDesc) {
- return false;
- }
- bool hasVertexColors = this->fDesc.header().fColorInput == GrProgramDesc::kAttribute_ColorInput;
- if (!hasVertexColors && this->fColor != that.fColor) {
+ if (!fDescInfo.fHasVertexColor && this->fColor != that.fColor) {
return false;
}
if (this->getRenderTarget() != that.getRenderTarget() ||
+ this->fFragmentStages.count() != that.fFragmentStages.count() ||
+ this->fNumColorStages != that.fNumColorStages ||
this->fScissorState != that.fScissorState ||
!this->fViewMatrix.cheapEqualTo(that.fViewMatrix) ||
this->fSrcBlend != that.fSrcBlend ||
this->fDstBlend != that.fDstBlend ||
+ this->fDrawType != that.fDrawType ||
+ fDescInfo.fInputColorIsUsed != that.fDescInfo.fInputColorIsUsed ||
+ fDescInfo.fInputCoverageIsUsed != that.fDescInfo.fInputCoverageIsUsed ||
+ fDescInfo.fReadsDst != that.fDescInfo.fReadsDst ||
+ fDescInfo.fReadsFragPosition != that.fDescInfo.fReadsFragPosition ||
+ fDescInfo.fRequiresLocalCoordAttrib != that.fDescInfo.fRequiresLocalCoordAttrib ||
+ fDescInfo.fPrimaryOutputType != that.fDescInfo.fPrimaryOutputType ||
+ fDescInfo.fSecondaryOutputType != that.fDescInfo.fSecondaryOutputType ||
+ this->fScissorState != that.fScissorState ||
this->fBlendConstant != that.fBlendConstant ||
this->fFlags != that.fFlags ||
this->fStencilSettings != that.fStencilSettings ||
@@ -246,9 +250,7 @@ bool GrOptDrawState::operator== (const GrOptDrawState& that) const {
return false;
}
- bool hasVertexCoverage =
- this->fDesc.header().fCoverageInput == GrProgramDesc::kAttribute_ColorInput;
- if (!hasVertexCoverage && this->fCoverage != that.fCoverage) {
+ if (!fDescInfo.fHasVertexCoverage && this->fCoverage != that.fCoverage) {
return false;
}
diff --git a/src/gpu/GrOptDrawState.h b/src/gpu/GrOptDrawState.h
index ac7ec16402..25a3a49995 100644
--- a/src/gpu/GrOptDrawState.h
+++ b/src/gpu/GrOptDrawState.h
@@ -30,7 +30,7 @@ public:
typedef GrClipMaskManager::ScissorState ScissorState;
- GrOptDrawState(const GrDrawState& drawState, GrGpu*, const ScissorState&,
+ GrOptDrawState(const GrDrawState& drawState, const GrDrawTargetCaps&, const ScissorState&,
const GrDeviceCoordTexture* dstCopy, GrGpu::DrawType);
bool operator== (const GrOptDrawState& that) const;
@@ -180,33 +180,20 @@ public:
///////////////////////////////////////////////////////////////////////////
- const GrDeviceCoordTexture* getDstCopy() const { return fDstCopy.texture() ? &fDstCopy : NULL; }
+ GrGpu::DrawType drawType() const { return fDrawType; }
- const GrProgramDesc& programDesc() const { return fDesc; }
+ const GrDeviceCoordTexture* getDstCopy() const { return fDstCopy.texture() ? &fDstCopy : NULL; }
-private:
- /**
- * Loops through all the color stage effects to check if the stage will ignore color input or
- * always output a constant color. In the ignore color input case we can ignore all previous
- * stages. In the constant color case, we can ignore all previous stages and
- * the current one and set the state color to the constant color.
- */
- void computeEffectiveColorStages(const GrDrawState& ds, GrProgramDesc::DescInfo*,
- int* firstColorStageIdx, uint8_t* fixFunctionVAToRemove);
+ // Finalize *MUST* be called before programDesc()
+ void finalize(GrGpu*);
- /**
- * Loops through all the coverage stage effects to check if the stage will ignore color input.
- * If a coverage stage will ignore input, then we can ignore all coverage stages before it. We
- * loop to determine the first effective coverage stage.
- */
- void computeEffectiveCoverageStages(const GrDrawState& ds, GrProgramDesc::DescInfo* descInfo,
- int* firstCoverageStageIdx);
+ const GrProgramDesc& programDesc() const { SkASSERT(fFinalized); return fDesc; }
+private:
/**
* Alter the program desc and inputs (attribs and processors) based on the blend optimization.
*/
void adjustProgramForBlendOpt(const GrDrawState& ds, GrDrawState::BlendOpt,
- GrProgramDesc::DescInfo*,
int* firstColorStageIdx, int* firstCoverageStageIdx);
/**
@@ -214,15 +201,14 @@ private:
* shaders they require.
*/
void getStageStats(const GrDrawState& ds, int firstColorStageIdx, int firstCoverageStageIdx,
- bool hasLocalCoords, GrProgramDesc::DescInfo*);
+ bool hasLocalCoords);
/**
* Calculates the primary and secondary output types of the shader. For certain output types
* the function may adjust the blend coefficients. After this function is called the src and dst
* blend coeffs will represent those used by backend API.
*/
- void setOutputStateInfo(const GrDrawState& ds, GrDrawState::BlendOpt, const GrDrawTargetCaps&,
- GrProgramDesc::DescInfo*);
+ void setOutputStateInfo(const GrDrawState& ds, GrDrawState::BlendOpt, const GrDrawTargetCaps&);
enum Flags {
kDither_Flag = 0x1,
@@ -249,6 +235,9 @@ private:
ProgramGeometryProcessor fGeometryProcessor;
ProgramXferProcessor fXferProcessor;
FragmentStageArray fFragmentStages;
+ GrGpu::DrawType fDrawType;
+ GrProgramDesc::DescInfo fDescInfo;
+ bool fFinalized;
// This function is equivalent to the offset into fFragmentStages where coverage stages begin.
int fNumColorStages;
diff --git a/src/gpu/GrProgramDesc.h b/src/gpu/GrProgramDesc.h
index 655254f892..b51da04658 100644
--- a/src/gpu/GrProgramDesc.h
+++ b/src/gpu/GrProgramDesc.h
@@ -103,8 +103,6 @@ public:
// effects that read the fragment position.
// Otherwise, 0.
- SkBool8 fEmitsPointSize;
-
ColorInput fColorInput : 8;
ColorInput fCoverageInput : 8;
diff --git a/src/gpu/GrTest.cpp b/src/gpu/GrTest.cpp
index 48f72a7e4c..7038c10966 100644
--- a/src/gpu/GrTest.cpp
+++ b/src/gpu/GrTest.cpp
@@ -140,7 +140,7 @@ private:
return false;
}
- bool flushGraphicsState(const GrOptDrawState&, DrawType) SK_OVERRIDE { return false; }
+ bool flushGraphicsState(const GrOptDrawState&) SK_OVERRIDE { return false; }
void clearStencil(GrRenderTarget* target) SK_OVERRIDE {}
diff --git a/src/gpu/gl/GrGLProgram.cpp b/src/gpu/gl/GrGLProgram.cpp
index 63cb9da20b..3b04edb8c8 100644
--- a/src/gpu/gl/GrGLProgram.cpp
+++ b/src/gpu/gl/GrGLProgram.cpp
@@ -123,13 +123,13 @@ void GrGLProgram::bindTextures(const GrGLInstalledProc* ip, const GrProcessor& p
///////////////////////////////////////////////////////////////////////////////
-void GrGLProgram::setData(const GrOptDrawState& optState, GrGpu::DrawType drawType) {
+void GrGLProgram::setData(const GrOptDrawState& optState) {
GrColor color = optState.getColor();
uint8_t coverage = optState.getCoverage();
this->setColor(optState, color);
this->setCoverage(optState, coverage);
- this->setMatrixAndRenderTargetHeight(drawType, optState);
+ this->setMatrixAndRenderTargetHeight(optState);
const GrDeviceCoordTexture* dstCopy = optState.getDstCopy();
if (dstCopy) {
@@ -164,7 +164,7 @@ void GrGLProgram::setData(const GrOptDrawState& optState, GrGpu::DrawType drawTy
this->setFragmentData(optState);
// Some of GrGLProgram subclasses need to update state here
- this->didSetData(drawType);
+ this->didSetData(optState.drawType());
}
void GrGLProgram::setFragmentData(const GrOptDrawState& optState) {
@@ -241,8 +241,7 @@ void GrGLProgram::setCoverage(const GrOptDrawState& optState, uint8_t coverage)
}
}
-void GrGLProgram::setMatrixAndRenderTargetHeight(GrGpu::DrawType drawType,
- const GrOptDrawState& optState) {
+void GrGLProgram::setMatrixAndRenderTargetHeight(const GrOptDrawState& optState) {
// Load the RT height uniform if it is needed to y-flip gl_FragCoord.
if (fBuiltinUniformHandles.fRTHeightUni.isValid() &&
fMatrixState.fRenderTargetSize.fHeight != optState.getRenderTarget()->height()) {
@@ -251,11 +250,10 @@ void GrGLProgram::setMatrixAndRenderTargetHeight(GrGpu::DrawType drawType,
}
// call subclasses to set the actual view matrix
- this->onSetMatrixAndRenderTargetHeight(drawType, optState);
+ this->onSetMatrixAndRenderTargetHeight(optState);
}
-void GrGLProgram::onSetMatrixAndRenderTargetHeight(GrGpu::DrawType drawType,
- const GrOptDrawState& optState) {
+void GrGLProgram::onSetMatrixAndRenderTargetHeight(const GrOptDrawState& optState) {
const GrRenderTarget* rt = optState.getRenderTarget();
SkISize size;
size.set(rt->width(), rt->height());
@@ -289,9 +287,8 @@ GrGLNvprProgramBase::GrGLNvprProgramBase(GrGpuGL* gpu,
: INHERITED(gpu, desc, builtinUniforms, programID, uniforms, NULL, fragmentProcessors) {
}
-void GrGLNvprProgramBase::onSetMatrixAndRenderTargetHeight(GrGpu::DrawType drawType,
- const GrOptDrawState& optState) {
- SkASSERT(GrGpu::IsPathRenderingDrawType(drawType));
+void GrGLNvprProgramBase::onSetMatrixAndRenderTargetHeight(const GrOptDrawState& optState) {
+ SkASSERT(GrGpu::IsPathRenderingDrawType(optState.drawType()));
const GrRenderTarget* rt = optState.getRenderTarget();
SkISize size;
size.set(rt->width(), rt->height());
diff --git a/src/gpu/gl/GrGLProgram.h b/src/gpu/gl/GrGLProgram.h
index a273a0381e..36bf860233 100644
--- a/src/gpu/gl/GrGLProgram.h
+++ b/src/gpu/gl/GrGLProgram.h
@@ -129,7 +129,7 @@ public:
* GrGpuGL object to bind the textures required by the GrGLProcessors. The color and coverage
* stages come from GrGLProgramDesc::Build().
*/
- void setData(const GrOptDrawState&, GrGpu::DrawType);
+ void setData(const GrOptDrawState&);
protected:
typedef GrGLProgramDataManager::UniformHandle UniformHandle;
@@ -167,8 +167,8 @@ protected:
virtual void didSetData(GrGpu::DrawType);
// Helper for setData() that sets the view matrix and loads the render target height uniform
- void setMatrixAndRenderTargetHeight(GrGpu::DrawType, const GrOptDrawState&);
- virtual void onSetMatrixAndRenderTargetHeight(GrGpu::DrawType, const GrOptDrawState&);
+ void setMatrixAndRenderTargetHeight(const GrOptDrawState&);
+ virtual void onSetMatrixAndRenderTargetHeight(const GrOptDrawState&);
// these reflect the current values of uniforms (GL uniform values travel with program)
MatrixState fMatrixState;
@@ -206,7 +206,7 @@ protected:
GrGLuint programID,
const UniformInfoArray&,
GrGLInstalledFragProcs* fragmentProcessors);
- virtual void onSetMatrixAndRenderTargetHeight(GrGpu::DrawType, const GrOptDrawState&);
+ virtual void onSetMatrixAndRenderTargetHeight(const GrOptDrawState&);
typedef GrGLProgram INHERITED;
};
diff --git a/src/gpu/gl/GrGLProgramDesc.cpp b/src/gpu/gl/GrGLProgramDesc.cpp
index 74f669f2e3..f8dbbc26f9 100644
--- a/src/gpu/gl/GrGLProgramDesc.cpp
+++ b/src/gpu/gl/GrGLProgramDesc.cpp
@@ -196,8 +196,6 @@ bool GrGLProgramDescBuilder::Build(const GrOptDrawState& optState,
header->fHasGeometryProcessor = optState.hasGeometryProcessor();
- header->fEmitsPointSize = GrGpu::kDrawPoints_DrawType == drawType;
-
bool isPathRendering = GrGpu::IsPathRenderingDrawType(drawType);
if (gpu->caps()->pathRenderingSupport() && isPathRendering) {
header->fUseNvpr = true;
diff --git a/src/gpu/gl/GrGpuGL.cpp b/src/gpu/gl/GrGpuGL.cpp
index df35d2c78c..383427d9c2 100644
--- a/src/gpu/gl/GrGpuGL.cpp
+++ b/src/gpu/gl/GrGpuGL.cpp
@@ -1894,14 +1894,14 @@ void GrGpuGL::flushStencil(const GrStencilSettings& stencilSettings, DrawType ty
}
}
-void GrGpuGL::flushAAState(const GrOptDrawState& optState, DrawType type) {
+void GrGpuGL::flushAAState(const GrOptDrawState& optState) {
// At least some ATI linux drivers will render GL_LINES incorrectly when MSAA state is enabled but
// the target is not multisampled. Single pixel wide lines are rendered thicker than 1 pixel wide.
#if 0
// Replace RT_HAS_MSAA with this definition once this driver bug is no longer a relevant concern
#define RT_HAS_MSAA rt->isMultisampled()
#else
- #define RT_HAS_MSAA (rt->isMultisampled() || kDrawLines_DrawType == type)
+ #define RT_HAS_MSAA (rt->isMultisampled() || kDrawLines_DrawType == optState.drawType())
#endif
const GrRenderTarget* rt = optState.getRenderTarget();
diff --git a/src/gpu/gl/GrGpuGL.h b/src/gpu/gl/GrGpuGL.h
index 4224ba64fd..8a609884e1 100644
--- a/src/gpu/gl/GrGpuGL.h
+++ b/src/gpu/gl/GrGpuGL.h
@@ -155,7 +155,7 @@ private:
virtual void clearStencil(GrRenderTarget*) SK_OVERRIDE;
- virtual bool flushGraphicsState(const GrOptDrawState&, DrawType) SK_OVERRIDE;
+ virtual bool flushGraphicsState(const GrOptDrawState&) SK_OVERRIDE;
// GrDrawTarget overrides
virtual void didAddGpuTraceMarker() SK_OVERRIDE;
@@ -188,7 +188,7 @@ private:
~ProgramCache();
void abandon();
- GrGLProgram* getProgram(const GrOptDrawState&, DrawType);
+ GrGLProgram* getProgram(const GrOptDrawState&);
private:
enum {
@@ -248,7 +248,7 @@ private:
void flushRenderTarget(GrGLRenderTarget*, const SkIRect* bounds);
void flushStencil(const GrStencilSettings&, DrawType);
- void flushAAState(const GrOptDrawState&, DrawType);
+ void flushAAState(const GrOptDrawState&);
bool configToGLFormats(GrPixelConfig config,
bool getSizedInternal,
diff --git a/src/gpu/gl/GrGpuGL_program.cpp b/src/gpu/gl/GrGpuGL_program.cpp
index cb8810cc79..a808aa8dda 100644
--- a/src/gpu/gl/GrGpuGL_program.cpp
+++ b/src/gpu/gl/GrGpuGL_program.cpp
@@ -91,7 +91,7 @@ int GrGpuGL::ProgramCache::search(const GrProgramDesc& desc) const {
return SkTSearch(fEntries, fCount, desc, sizeof(Entry*), less);
}
-GrGLProgram* GrGpuGL::ProgramCache::getProgram(const GrOptDrawState& optState, DrawType type) {
+GrGLProgram* GrGpuGL::ProgramCache::getProgram(const GrOptDrawState& optState) {
#ifdef PROGRAM_CACHE_STATS
++fTotalRequests;
#endif
@@ -126,7 +126,7 @@ GrGLProgram* GrGpuGL::ProgramCache::getProgram(const GrOptDrawState& optState, D
#ifdef PROGRAM_CACHE_STATS
++fCacheMisses;
#endif
- GrGLProgram* program = GrGLProgramBuilder::CreateProgram(optState, type, fGpu);
+ GrGLProgram* program = GrGLProgramBuilder::CreateProgram(optState, fGpu);
if (NULL == program) {
return NULL;
}
@@ -201,11 +201,11 @@ GrGLProgram* GrGpuGL::ProgramCache::getProgram(const GrOptDrawState& optState, D
#define GL_CALL(X) GR_GL_CALL(this->glInterface(), X)
-bool GrGpuGL::flushGraphicsState(const GrOptDrawState& optState, DrawType type) {
+bool GrGpuGL::flushGraphicsState(const GrOptDrawState& optState) {
// GrGpu::setupClipAndFlushState should have already checked this and bailed if not true.
SkASSERT(optState.getRenderTarget());
- if (kStencilPath_DrawType == type) {
+ if (kStencilPath_DrawType == optState.drawType()) {
const GrRenderTarget* rt = optState.getRenderTarget();
SkISize size;
size.set(rt->width(), rt->height());
@@ -216,7 +216,7 @@ bool GrGpuGL::flushGraphicsState(const GrOptDrawState& optState, DrawType type)
GrBlendCoeff srcCoeff = optState.getSrcBlendCoeff();
GrBlendCoeff dstCoeff = optState.getDstBlendCoeff();
- fCurrentProgram.reset(fProgramCache->getProgram(optState, type));
+ fCurrentProgram.reset(fProgramCache->getProgram(optState));
if (NULL == fCurrentProgram.get()) {
SkDEBUGFAIL("Failed to create program!");
return false;
@@ -230,15 +230,15 @@ bool GrGpuGL::flushGraphicsState(const GrOptDrawState& optState, DrawType type)
fHWProgramID = programID;
}
- this->flushBlend(optState, kDrawLines_DrawType == type, srcCoeff, dstCoeff);
+ this->flushBlend(optState, kDrawLines_DrawType == optState.drawType(), srcCoeff, dstCoeff);
- fCurrentProgram->setData(optState, type);
+ fCurrentProgram->setData(optState);
}
GrGLRenderTarget* glRT = static_cast<GrGLRenderTarget*>(optState.getRenderTarget());
- this->flushStencil(optState.getStencil(), type);
+ this->flushStencil(optState.getStencil(), optState.drawType());
this->flushScissor(optState.getScissorState(), glRT->getViewport(), glRT->origin());
- this->flushAAState(optState, type);
+ this->flushAAState(optState);
// This must come after textures are flushed because a texture may need
// to be msaa-resolved (which will modify bound FBO state).
diff --git a/src/gpu/gl/builders/GrGLGeometryShaderBuilder.cpp b/src/gpu/gl/builders/GrGLGeometryShaderBuilder.cpp
index f35c9ba910..ef8d1a2a35 100644
--- a/src/gpu/gl/builders/GrGLGeometryShaderBuilder.cpp
+++ b/src/gpu/gl/builders/GrGLGeometryShaderBuilder.cpp
@@ -48,9 +48,7 @@ bool GrGLGeometryBuilder::compileAndAttachShaders(GrGLuint programId,
geomShaderSrc.append("void main() {\n");
geomShaderSrc.append("\tfor (int i = 0; i < 3; ++i) {\n"
"\t\tgl_Position = gl_in[i].gl_Position;\n");
- if (fProgramBuilder->desc().header().fEmitsPointSize) {
- geomShaderSrc.append("\t\tgl_PointSize = 1.0;\n");
- }
+ geomShaderSrc.append("\t\tgl_PointSize = 1.0;\n");
SkASSERT(fInputs.count() == fOutputs.count());
for (int i = 0; i < fInputs.count(); ++i) {
geomShaderSrc.appendf("\t\t%s = %s[i];\n",
diff --git a/src/gpu/gl/builders/GrGLProgramBuilder.cpp b/src/gpu/gl/builders/GrGLProgramBuilder.cpp
index 64150a4fda..aa9e40c3f2 100644
--- a/src/gpu/gl/builders/GrGLProgramBuilder.cpp
+++ b/src/gpu/gl/builders/GrGLProgramBuilder.cpp
@@ -28,13 +28,10 @@ static const GrGLShaderVar::Precision kDefaultFragmentPrecision = GrGLShaderVar:
const int GrGLProgramBuilder::kVarsPerBlock = 8;
-GrGLProgram* GrGLProgramBuilder::CreateProgram(const GrOptDrawState& optState,
- GrGpu::DrawType drawType,
- GrGpuGL* gpu) {
+GrGLProgram* GrGLProgramBuilder::CreateProgram(const GrOptDrawState& optState, GrGpuGL* gpu) {
// create a builder. This will be handed off to effects so they can use it to add
// uniforms, varyings, textures, etc
SkAutoTDelete<GrGLProgramBuilder> builder(CreateProgramBuilder(optState,
- drawType,
optState.hasGeometryProcessor(),
gpu));
@@ -73,7 +70,6 @@ GrGLProgram* GrGLProgramBuilder::CreateProgram(const GrOptDrawState& optState,
GrGLProgramBuilder*
GrGLProgramBuilder::CreateProgramBuilder(const GrOptDrawState& optState,
- GrGpu::DrawType drawType,
bool hasGeometryProcessor,
GrGpuGL* gpu) {
const GrProgramDesc& desc = optState.programDesc();
@@ -234,9 +230,7 @@ void GrGLProgramBuilder::emitAndInstallProcs(GrGLSLExpr4* inputColor, GrGLSLExpr
fVS.setupUniformViewMatrix();
const GrProgramDesc::KeyHeader& header = this->header();
- if (header.fEmitsPointSize) {
- fVS.codeAppend("gl_PointSize = 1.0;");
- }
+ fVS.codeAppend("gl_PointSize = 1.0;");
// Setup position
// TODO it'd be possible to remove these from the vertexshader builder and have them
diff --git a/src/gpu/gl/builders/GrGLProgramBuilder.h b/src/gpu/gl/builders/GrGLProgramBuilder.h
index 76f7ae97c3..973ae5e078 100644
--- a/src/gpu/gl/builders/GrGLProgramBuilder.h
+++ b/src/gpu/gl/builders/GrGLProgramBuilder.h
@@ -186,7 +186,7 @@ public:
* to be used.
* @return true if generation was successful.
*/
- static GrGLProgram* CreateProgram(const GrOptDrawState&, GrGpu::DrawType, GrGpuGL*);
+ static GrGLProgram* CreateProgram(const GrOptDrawState&, GrGpuGL*);
virtual UniformHandle addUniform(uint32_t visibility,
GrSLType type,
@@ -246,7 +246,6 @@ protected:
typedef GrGLProgramDataManager::UniformInfoArray UniformInfoArray;
static GrGLProgramBuilder* CreateProgramBuilder(const GrOptDrawState&,
- GrGpu::DrawType,
bool hasGeometryProcessor,
GrGpuGL*);
diff --git a/tests/GLProgramsTest.cpp b/tests/GLProgramsTest.cpp
index aa8359d5e5..7b73fdc510 100644
--- a/tests/GLProgramsTest.cpp
+++ b/tests/GLProgramsTest.cpp
@@ -384,11 +384,12 @@ bool GrDrawTarget::programUnitTest(int maxStages) {
// create optimized draw state, setup readDst texture if required, and build a descriptor
// and program. ODS creation can fail, so we have to check
- GrOptDrawState ods(ds, gpu, scissor, &dstCopy, drawType);
+ GrOptDrawState ods(ds, *gpu->caps(), scissor, &dstCopy, drawType);
if (ods.mustSkip()) {
continue;
}
- SkAutoTUnref<GrGLProgram> program(GrGLProgramBuilder::CreateProgram(ods, drawType, gpu));
+ ods.finalize(gpu);
+ SkAutoTUnref<GrGLProgram> program(GrGLProgramBuilder::CreateProgram(ods, gpu));
if (NULL == program.get()) {
SkDebugf("Failed to create program!");
return false;
generated by cgit v1.2.3 (git 2.39.1) at 2024-12-14 19:49:40 +0000