GrDrawState()
: fRenderTarget(NULL) {
- for (int i = 0; i < kNumStages; ++i) {
- fTextures[i] = NULL;
- }
-
this->reset();
}
GrDrawState(const GrDrawState& state)
: fRenderTarget(NULL) {
- for (int i = 0; i < kNumStages; ++i) {
- fTextures[i] = NULL;
- }
-
*this = state;
}
// are tightly packed
GrAssert(this->memsetSize() + sizeof(fColor) + sizeof(fCoverage) +
sizeof(fFirstCoverageStage) + sizeof(fColorFilterMode) +
- sizeof(fSrcBlend) + sizeof(fDstBlend) + sizeof(fTextures) +
- sizeof(fRenderTarget) == this->podSize());
+ sizeof(fSrcBlend) + sizeof(fDstBlend) + sizeof(fRenderTarget) ==
+ this->podSize());
}
///////////////////////////////////////////////////////////////////////////
////
/**
- * Sets the texture used at the next drawing call
- *
- * @param stage The texture stage for which the texture will be set
- *
- * @param texture The texture to set. Can be NULL though there is no
- * advantage to settings a NULL texture if doing non-textured drawing
- *
- * @deprecated
- */
- void setTexture(int stage, GrTexture* texture) {
- GrAssert((unsigned)stage < kNumStages);
-
- GrSafeAssign(fTextures[stage], texture);
- }
-
- /**
* Creates a GrSingleTextureEffect.
- *
- * Replacement for setTexture.
*/
void createTextureEffect(int stage, GrTexture* texture) {
GrAssert(!this->getSampler(stage).getCustomStage());
SkNEW_ARGS(GrSingleTextureEffect, (texture)))->unref();
}
- /**
- * Retrieves the currently set texture.
- *
- * @return The currently set texture. The return value will be NULL if no
- * texture has been set, NULL was most recently passed to
- * setTexture, or the last setTexture was destroyed.
- */
- const GrTexture* getTexture(int stage) const {
- GrAssert((unsigned)stage < kNumStages);
- GrAssert(!this->getSampler(stage).getCustomStage() ||
- !fTextures[stage] ||
- fTextures[stage] == this->getSampler(stage).getCustomStage()->texture(0));
- if (this->getSampler(stage).getCustomStage()) {
- return this->getSampler(stage).getCustomStage()->texture(0);
- }
- return fTextures[stage];
- }
- GrTexture* getTexture(int stage) {
- GrAssert((unsigned)stage < kNumStages);
- GrAssert(!this->getSampler(stage).getCustomStage() ||
- !fTextures[stage] ||
- fTextures[stage] == this->getSampler(stage).getCustomStage()->texture(0));
- if (this->getSampler(stage).getCustomStage()) {
- return this->getSampler(stage).getCustomStage()->texture(0);
- }
- return fTextures[stage];
- }
-
bool stagesDisabled() {
for (int i = 0; i < kNumStages; ++i) {
- if (NULL != fTextures[i] ||
- NULL != fSamplerStates[i].getCustomStage()) {
+ if (NULL != fSamplerStates[i].getCustomStage()) {
return false;
}
}
}
void disableStage(int index) {
- GrSafeSetNull(fTextures[index]);
fSamplerStates[index].setCustomStage(NULL);
}
bool isStageEnabled(int s) const {
GrAssert((unsigned)s < kNumStages);
- return (NULL != fTextures[s]) ||
- (NULL != fSamplerStates[s].getCustomStage());
+ return (NULL != fSamplerStates[s].getCustomStage());
}
// Most stages are usually not used, so conditionals here
fViewMatrix = s.fViewMatrix;
for (int i = 0; i < kNumStages; i++) {
- SkSafeRef(fTextures[i]); // already copied by memcpy
if (s.isStageEnabled(i)) {
this->fSamplerStates[i] = s.fSamplerStates[i];
}
// @{ Initialized to values other than zero, but memcmp'ed in operator==
// and memcpy'ed in operator=.
- GrTexture* fTextures[kNumStages];
GrRenderTarget* fRenderTarget;
int fFirstCoverageStage;
bool GrDrawTarget::checkDraw(GrPrimitiveType type, int startVertex,
int startIndex, int vertexCount,
int indexCount) const {
+ const GrDrawState& drawState = this->getDrawState();
#if GR_DEBUG
const GeometrySrcState& geoSrc = fGeoSrcStateStack.back();
int maxVertex = startVertex + vertexCount;
}
}
- GrAssert(NULL != this->getDrawState().getRenderTarget());
- for (int i = 0; i < GrDrawState::kNumStages; ++i) {
- if (this->getDrawState().getTexture(i)) {
- GrAssert(this->getDrawState().getTexture(i)->asRenderTarget() !=
- this->getDrawState().getRenderTarget());
+ GrAssert(NULL != drawState.getRenderTarget());
+ for (int s = 0; s < GrDrawState::kNumStages; ++s) {
+ if (drawState.isStageEnabled(s)) {
+ const GrCustomStage* stage = drawState.getSampler(s).getCustomStage();
+ int numTextures = stage->numTextures();
+ for (int t = 0; t < numTextures; ++t) {
+ GrTexture* texture = stage->texture(t);
+ GrAssert(texture->asRenderTarget() != drawState.getRenderTarget());
+ }
}
}
#endif
- const GrDrawState& drawState = this->getDrawState();
if (NULL == drawState.getRenderTarget()) {
return false;
}
return false;
}
}
+ // We don't support using unpremultiplied textures with bilerp. Alpha-multiplication is not
+ // distributive with respect to filtering. We'd have to alpha-mul each texel before filtering.
+ // Until Skia itself supports unpremultiplied configs there is no pressure to implement this.
for (int s = 0; s < GrDrawState::kNumStages; ++s) {
- // We don't support using unpremultiplied textures with bilerp. Alpha-multiplication is not
- // distributive with respect to filtering. We'd have to alpha-mul each texel before
- // filtering. Until Skia itself supports unpremultiplied configs there is no pressure to
- // implement this.
- if (drawState.getTexture(s) &&
- GrPixelConfigIsUnpremultiplied(drawState.getTexture(s)->config()) &&
- drawState.getSampler(s).getTextureParams().isBilerp()) {
- return false;
+ if (drawState.isStageEnabled(s)) {
+ const GrCustomStage* stage = drawState.getSampler(s).getCustomStage();
+ int numTextures = stage->numTextures();
+ for (int t = 0; t < numTextures; ++t) {
+ GrTexture* texture = stage->texture(t);
+ GrAssert(NULL != texture);
+ if (GrPixelConfigIsUnpremultiplied(texture->config()) &&
+ drawState.getSampler(s).getTextureParams().isBilerp()) {
+ return false;
+ }
+ }
}
}
return true;
// Check if a color stage could create a partial alpha
for (int s = 0; s < drawState.getFirstCoverageStage(); ++s) {
if (this->isStageEnabled(s)) {
- GrAssert(NULL != drawState.getTexture(s));
- GrPixelConfig config = drawState.getTexture(s)->config();
- if (!GrPixelConfigIsOpaque(config)) {
+ const GrCustomStage* stage = drawState.getSampler(s).getCustomStage();
+ // FIXME: The param indicates whether the texture is opaque or not. However, the stage
+ // already controls its textures. It really needs to know whether the incoming color
+ // (from a uni, per-vertex colors, or previous stage) is opaque or not.
+ if (!stage->isOpaque(true)) {
return false;
}
}
fCount = 0;
}
-GrGLProgram* GrGpuGL::ProgramCache::getProgram(const ProgramDesc& desc, GrCustomStage** stages) {
+GrGLProgram* GrGpuGL::ProgramCache::getProgram(const ProgramDesc& desc,
+ const GrCustomStage** stages) {
Entry newEntry;
newEntry.fKey.setKeyData(desc.asKey());
void GrGpuGL::flushTextureMatrix(int s) {
const GrDrawState& drawState = this->getDrawState();
- const GrGLTexture* texture =
- static_cast<const GrGLTexture*>(drawState.getTexture(s));
+
+ // FIXME: Still assuming only a single texture per custom stage
+ const GrCustomStage* stage = drawState.getSampler(s).getCustomStage();
+ const GrGLTexture* texture = static_cast<const GrGLTexture*>(stage->texture(0));
if (NULL != texture) {
bool orientationChange = fCurrentProgram->fTextureOrientation[s] !=
return false;
}
- GrCustomStage* customStages [GrDrawState::kNumStages];
+ const GrCustomStage* customStages [GrDrawState::kNumStages];
GrGLProgram::Desc desc;
this->buildProgram(kDrawPoints_DrawType == type, blendOpts, dstCoeff, customStages, &desc);
for (int s = 0; s < GrDrawState::kNumStages; ++s) {
if (this->isStageEnabled(s)) {
-#if GR_DEBUG
- // check for circular rendering
- GrAssert(NULL == drawState.getRenderTarget() ||
- NULL == drawState.getTexture(s) ||
- drawState.getTexture(s)->asRenderTarget() !=
- drawState.getRenderTarget());
-#endif
this->flushBoundTextureAndParams(s);
this->flushTextureMatrix(s);
if (NULL != fCurrentProgram->fProgramStage[s]) {
const GrSamplerState& sampler = this->getDrawState().getSampler(s);
- const GrGLTexture* texture = static_cast<const GrGLTexture*>(
- this->getDrawState().getTexture(s));
fCurrentProgram->fProgramStage[s]->setData(fCurrentProgram->fUniformManager,
*sampler.getCustomStage(),
drawState.getRenderTarget(), s);
void setup_custom_stage(GrGLProgram::Desc::StageDesc* stage,
const GrSamplerState& sampler,
- GrCustomStage** customStages,
+ const GrCustomStage** customStages,
GrGLProgram* program, int index) {
- GrCustomStage* customStage = sampler.getCustomStage();
+ const GrCustomStage* customStage = sampler.getCustomStage();
if (customStage) {
const GrProgramStageFactory& factory = customStage->getFactory();
stage->fCustomStageKey = factory.glStageKey(*customStage);
void GrGpuGL::buildProgram(bool isPoints,
BlendOptFlags blendOpts,
GrBlendCoeff dstCoeff,
- GrCustomStage** customStages,
+ const GrCustomStage** customStages,
ProgramDesc* desc) {
const GrDrawState& drawState = this->getDrawState();
desc->fEmitsPointSize = isPoints;
- bool requiresAttributeColors =
- !skipColor && SkToBool(desc->fVertexLayout & kColor_VertexLayoutBit);
- bool requiresAttributeCoverage =
- !skipCoverage && SkToBool(desc->fVertexLayout &
- kCoverage_VertexLayoutBit);
+ bool requiresAttributeColors = !skipColor &&
+ SkToBool(desc->fVertexLayout & kColor_VertexLayoutBit);
+ bool requiresAttributeCoverage = !skipCoverage &&
+ SkToBool(desc->fVertexLayout & kCoverage_VertexLayoutBit);
// fColorInput/fCoverageInput records how colors are specified for the.
// program. So we strip the bits from the layout to avoid false negatives
// no reason to do edge aa or look at per-vertex coverage if coverage is
// ignored
if (skipCoverage) {
- desc->fVertexLayout &= ~(kEdge_VertexLayoutBit |
- kCoverage_VertexLayoutBit);
+ desc->fVertexLayout &= ~(kEdge_VertexLayoutBit | kCoverage_VertexLayoutBit);
}
bool colorIsTransBlack = SkToBool(blendOpts & kEmitTransBlack_BlendOptFlag);
bool colorIsSolidWhite = (blendOpts & kEmitCoverage_BlendOptFlag) ||
- (!requiresAttributeColors &&
- 0xffffffff == drawState.getColor());
+ (!requiresAttributeColors && 0xffffffff == drawState.getColor());
if (GR_AGGRESSIVE_SHADER_OPTS && colorIsTransBlack) {
desc->fColorInput = ProgramDesc::kTransBlack_ColorInput;
} else if (GR_AGGRESSIVE_SHADER_OPTS && colorIsSolidWhite) {
desc->fColorInput = ProgramDesc::kAttribute_ColorInput;
}
- bool covIsSolidWhite = !requiresAttributeCoverage &&
- 0xffffffff == drawState.getCoverage();
+ bool covIsSolidWhite = !requiresAttributeCoverage && 0xffffffff == drawState.getCoverage();
if (skipCoverage) {
desc->fCoverageInput = ProgramDesc::kTransBlack_ColorInput;
int lastEnabledStage = -1;
- if (!skipCoverage && (desc->fVertexLayout &
- GrDrawTarget::kEdge_VertexLayoutBit)) {
+ if (!skipCoverage && (desc->fVertexLayout &GrDrawTarget::kEdge_VertexLayoutBit)) {
desc->fVertexEdgeType = drawState.getVertexEdgeType();
} else {
// use canonical value when not set to avoid cache misses
stage.setEnabled(this->isStageEnabled(s));
bool skip = s < drawState.getFirstCoverageStage() ? skipColor :
- skipCoverage;
+ skipCoverage;
if (!skip && stage.isEnabled()) {
lastEnabledStage = s;
- const GrGLTexture* texture =
- static_cast<const GrGLTexture*>(drawState.getTexture(s));
- GrAssert(NULL != texture);
const GrSamplerState& sampler = drawState.getSampler(s);
- // we matrix to invert when orientation is TopDown, so make sure
- // we aren't in that case before flagging as identity.
- if (TextureMatrixIsIdentity(texture, sampler)) {
- stage.fOptFlags |= StageDesc::kIdentityMatrix_OptFlagBit;
- } else if (!sampler.getMatrix().hasPerspective()) {
- stage.fOptFlags |= StageDesc::kNoPerspective_OptFlagBit;
- }
-
+ // FIXME: Still assuming one texture per custom stage
+ const GrCustomStage* customStage = drawState.getSampler(s).getCustomStage();
+ const GrGLTexture* texture = static_cast<const GrGLTexture*>(customStage->texture(0));
stage.fInConfigFlags = 0;
- if (!this->glCaps().textureSwizzleSupport()) {
- if (GrPixelConfigIsAlphaOnly(texture->config())) {
- // if we don't have texture swizzle support then
- // the shader must smear the single channel after
- // reading the texture
- if (this->glCaps().textureRedSupport()) {
- // we can use R8 textures so use kSmearRed
- stage.fInConfigFlags |=
- StageDesc::kSmearRed_InConfigFlag;
- } else {
- // we can use A8 textures so use kSmearAlpha
- stage.fInConfigFlags |=
- StageDesc::kSmearAlpha_InConfigFlag;
+ if (NULL != texture) {
+ // We call this helper function rather then simply checking the client-specified
+ // texture matrix. This is because we may have to concat a y-inversion to account
+ // for texture orientation.
+ if (TextureMatrixIsIdentity(texture, sampler)) {
+ stage.fOptFlags |= StageDesc::kIdentityMatrix_OptFlagBit;
+ } else if (!sampler.getMatrix().hasPerspective()) {
+ stage.fOptFlags |= StageDesc::kNoPerspective_OptFlagBit;
+ }
+ if (!this->glCaps().textureSwizzleSupport()) {
+ if (GrPixelConfigIsAlphaOnly(texture->config())) {
+ // If we don't have texture swizzle support then the shader must smear the
+ // single channel after reading the texture.
+ if (this->glCaps().textureRedSupport()) {
+ // We can use R8 textures so use kSmearRed.
+ stage.fInConfigFlags |= StageDesc::kSmearRed_InConfigFlag;
+ } else {
+ // We can use A8 textures so use kSmearAlpha.
+ stage.fInConfigFlags |= StageDesc::kSmearAlpha_InConfigFlag;
+ }
+ } else if (sampler.swapsRAndB()) {
+ stage.fInConfigFlags |= StageDesc::kSwapRAndB_InConfigFlag;
}
- } else if (sampler.swapsRAndB()) {
- stage.fInConfigFlags |= StageDesc::kSwapRAndB_InConfigFlag;
}
- }
- if (GrPixelConfigIsUnpremultiplied(texture->config())) {
- // The shader generator assumes that color channels are bytes
- // when rounding.
- GrAssert(4 == GrBytesPerPixel(texture->config()));
- if (kUpOnWrite_DownOnRead_UnpremulConversion ==
- fUnpremulConversion) {
- stage.fInConfigFlags |=
- StageDesc::kMulRGBByAlpha_RoundDown_InConfigFlag;
- } else {
- stage.fInConfigFlags |=
- StageDesc::kMulRGBByAlpha_RoundUp_InConfigFlag;
+ if (GrPixelConfigIsUnpremultiplied(texture->config())) {
+ // Assert that if we're doing a premul conversion that the texture is 1 byte
+ // per color component. The rounding performed by the shader generator (in
+ // normalized float color space) assumes this.
+ GrAssert(4 == GrBytesPerPixel(texture->config()));
+ if (kUpOnWrite_DownOnRead_UnpremulConversion ==
+ fUnpremulConversion) {
+ stage.fInConfigFlags |= StageDesc::kMulRGBByAlpha_RoundDown_InConfigFlag;
+ } else {
+ stage.fInConfigFlags |= StageDesc::kMulRGBByAlpha_RoundUp_InConfigFlag;
+ }
}
}
// when rounding.
GrAssert(4 == GrBytesPerPixel(drawState.getRenderTarget()->config()));
if (kUpOnWrite_DownOnRead_UnpremulConversion == fUnpremulConversion) {
- desc->fOutputConfig =
- ProgramDesc::kUnpremultiplied_RoundUp_OutputConfig;
+ desc->fOutputConfig = ProgramDesc::kUnpremultiplied_RoundUp_OutputConfig;
} else {
- desc->fOutputConfig =
- ProgramDesc::kUnpremultiplied_RoundDown_OutputConfig;
+ desc->fOutputConfig = ProgramDesc::kUnpremultiplied_RoundDown_OutputConfig;
}
} else {
desc->fOutputConfig = ProgramDesc::kPremultiplied_OutputConfig;
desc->fDualSrcOutput = ProgramDesc::kNone_DualSrcOutput;
- // currently the experimental GS will only work with triangle prims
- // (and it doesn't do anything other than pass through values from
- // the VS to the FS anyway).
+ // Currently the experimental GS will only work with triangle prims (and it doesn't do anything
+ // other than pass through values fromthe VS to the FS anyway).
#if 0 && GR_GL_EXPERIMENTAL_GS
desc->fExperimentalGS = this->getCaps().fGeometryShaderSupport;
#endif
- // we want to avoid generating programs with different "first cov stage"
- // values when they would compute the same result.
- // We set field in the desc to kNumStages when either there are no
- // coverage stages or the distinction between coverage and color is
- // immaterial.
+ // We want to avoid generating programs with different "first cov stage" values when they would
+ // compute the same result. We set field in the desc to kNumStages when either there are no
+ // coverage stages or the distinction between coverage and color is immaterial.
int firstCoverageStage = GrDrawState::kNumStages;
desc->fFirstCoverageStage = GrDrawState::kNumStages;
bool hasCoverage = drawState.getFirstCoverageStage() <= lastEnabledStage;
// other coverage inputs
if (!hasCoverage) {
- hasCoverage =
- requiresAttributeCoverage ||
- (desc->fVertexLayout & GrDrawTarget::kEdge_VertexLayoutBit);
+ hasCoverage = requiresAttributeCoverage ||
+ (desc->fVertexLayout & GrDrawTarget::kEdge_VertexLayoutBit);
}
if (hasCoverage) {
}
if (this->getCaps().fDualSourceBlendingSupport &&
- !(blendOpts & (kEmitCoverage_BlendOptFlag |
- kCoverageAsAlpha_BlendOptFlag))) {
+ !(blendOpts & (kEmitCoverage_BlendOptFlag | kCoverageAsAlpha_BlendOptFlag))) {
if (kZero_GrBlendCoeff == dstCoeff) {
// write the coverage value to second color
desc->fDualSrcOutput = ProgramDesc::kCoverage_DualSrcOutput;
desc->fFirstCoverageStage = firstCoverageStage;
} else if (kSA_GrBlendCoeff == dstCoeff) {
- // SA dst coeff becomes 1-(1-SA)*coverage when dst is partially
- // cover
+ // SA dst coeff becomes 1-(1-SA)*coverage when dst is partially covered.
desc->fDualSrcOutput = ProgramDesc::kCoverageISA_DualSrcOutput;
desc->fFirstCoverageStage = firstCoverageStage;
} else if (kSC_GrBlendCoeff == dstCoeff) {
- // SA dst coeff becomes 1-(1-SA)*coverage when dst is partially
- // cover
+ // SA dst coeff becomes 1-(1-SA)*coverage when dst is partially covered.
desc->fDualSrcOutput = ProgramDesc::kCoverageISC_DualSrcOutput;
desc->fFirstCoverageStage = firstCoverageStage;
}
projects / platform / upstream / libSkiaSharp.git / commitdiff