'<(skia_src_path)/gpu/gl/GrGLPath.h',
'<(skia_src_path)/gpu/gl/GrGLProgram.cpp',
'<(skia_src_path)/gpu/gl/GrGLProgram.h',
+ '<(skia_src_path)/gpu/gl/GrGLProgramDesc.h',
'<(skia_src_path)/gpu/gl/GrGLRenderTarget.cpp',
'<(skia_src_path)/gpu/gl/GrGLRenderTarget.h',
'<(skia_src_path)/gpu/gl/GrGLShaderBuilder.cpp',
#ifndef GrTypesPriv_DEFINED
#define GrTypesPriv_DEFINED
+#include "SkTArray.h"
+
/**
* Types of shader-language-specific boxed variables we can create.
* (Currently only GrGLShaderVars, but should be applicable to other shader
kSampler2D_GrSLType
};
+/**
+ * Types used to describe format of vertices in arrays
+ */
+enum GrVertexAttribType {
+ kFloat_GrVertexAttribType = 0,
+ kVec2f_GrVertexAttribType,
+ kVec3f_GrVertexAttribType,
+ kVec4f_GrVertexAttribType,
+ kVec4ub_GrVertexAttribType, // vector of 4 unsigned bytes, e.g. colors
+
+ kLast_GrVertexAttribType = kVec4ub_GrVertexAttribType
+};
+static const int kGrVertexAttribTypeCount = kLast_GrVertexAttribType + 1;
+
+struct GrVertexAttrib {
+ inline void set(GrVertexAttribType type, size_t offset) {
+ fType = type; fOffset = offset;
+ }
+ bool operator==(const GrVertexAttrib& other) const {
+ return fType == other.fType && fOffset == other.fOffset;
+ };
+ bool operator!=(const GrVertexAttrib& other) const { return !(*this == other); }
+
+ GrVertexAttribType fType;
+ size_t fOffset;
+};
+
+template <int N>
+class GrVertexAttribArray : public SkSTArray<N, GrVertexAttrib, true> {};
+
#endif
#include "GrStencil.h"
#include "GrTemplates.h"
#include "GrTexture.h"
+#include "GrTypesPriv.h"
#include "effects/GrSimpleTextureEffect.h"
#include "SkMatrix.h"
class GrPaint;
-/**
- * Types used to describe format of vertices in arrays
- */
-enum GrVertexAttribType {
- kFloat_GrVertexAttribType = 0,
- kVec2f_GrVertexAttribType,
- kVec3f_GrVertexAttribType,
- kVec4f_GrVertexAttribType,
- kVec4ub_GrVertexAttribType, // vector of 4 unsigned bytes, e.g. colors
-
- kLast_GrVertexAttribType = kVec4ub_GrVertexAttribType
-};
-static const int kGrVertexAttribTypeCount = kLast_GrVertexAttribType + 1;
-
-struct GrVertexAttrib {
- inline void set(GrVertexAttribType type, size_t offset) {
- fType = type; fOffset = offset;
- }
- bool operator==(const GrVertexAttrib& other) const {
- return fType == other.fType && fOffset == other.fOffset;
- };
- bool operator!=(const GrVertexAttrib& other) const { return !(*this == other); }
-
- GrVertexAttribType fType;
- size_t fOffset;
-};
-
-template <int N>
-class GrVertexAttribArray : public SkSTArray<N, GrVertexAttrib, true> {};
-
/**
* Type used to describe how attributes bind to program usage
*/
inline const char* dual_source_output_name() { return "dualSourceOut"; }
}
-const GrGLProgram::AttribLayout GrGLProgram::kAttribLayouts[kGrVertexAttribTypeCount] = {
- {1, GR_GL_FLOAT, false}, // kFloat_GrVertexAttribType
- {2, GR_GL_FLOAT, false}, // kVec2f_GrVertexAttribType
- {3, GR_GL_FLOAT, false}, // kVec3f_GrVertexAttribType
- {4, GR_GL_FLOAT, false}, // kVec4f_GrVertexAttribType
- {4, GR_GL_UNSIGNED_BYTE, true}, // kVec4ub_GrVertexAttribType
-};
-
-void GrGLProgram::BuildDesc(const GrDrawState& drawState,
+void GrGLProgramDesc::Build(const GrDrawState& drawState,
bool isPoints,
GrDrawState::BlendOptFlags blendOpts,
GrBlendCoeff srcCoeff,
GrBlendCoeff dstCoeff,
const GrGpuGL* gpu,
- Desc* desc) {
+ GrGLProgramDesc* desc) {
// This should already have been caught
GrAssert(!(GrDrawState::kSkipDraw_BlendOptFlag & blendOpts));
bool colorIsSolidWhite = (blendOpts & GrDrawState::kEmitCoverage_BlendOptFlag) ||
(!requiresAttributeColors && 0xffffffff == drawState.getColor());
if (colorIsTransBlack) {
- desc->fColorInput = Desc::kTransBlack_ColorInput;
+ desc->fColorInput = kTransBlack_ColorInput;
} else if (colorIsSolidWhite) {
- desc->fColorInput = Desc::kSolidWhite_ColorInput;
+ desc->fColorInput = kSolidWhite_ColorInput;
} else if (GR_GL_NO_CONSTANT_ATTRIBUTES && !requiresAttributeColors) {
- desc->fColorInput = Desc::kUniform_ColorInput;
+ desc->fColorInput = kUniform_ColorInput;
} else {
- desc->fColorInput = Desc::kAttribute_ColorInput;
+ desc->fColorInput = kAttribute_ColorInput;
}
bool covIsSolidWhite = !requiresAttributeCoverage && 0xffffffff == drawState.getCoverage();
if (skipCoverage) {
- desc->fCoverageInput = Desc::kTransBlack_ColorInput;
+ desc->fCoverageInput = kTransBlack_ColorInput;
} else if (covIsSolidWhite) {
- desc->fCoverageInput = Desc::kSolidWhite_ColorInput;
+ desc->fCoverageInput = kSolidWhite_ColorInput;
} else if (GR_GL_NO_CONSTANT_ATTRIBUTES && !requiresAttributeCoverage) {
- desc->fCoverageInput = Desc::kUniform_ColorInput;
+ desc->fCoverageInput = kUniform_ColorInput;
} else {
- desc->fCoverageInput = Desc::kAttribute_ColorInput;
+ desc->fCoverageInput = kAttribute_ColorInput;
}
int lastEnabledStage = -1;
}
}
- desc->fDualSrcOutput = Desc::kNone_DualSrcOutput;
+ desc->fDualSrcOutput = 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).
GrDrawState::kCoverageAsAlpha_BlendOptFlag))) {
if (kZero_GrBlendCoeff == dstCoeff) {
// write the coverage value to second color
- desc->fDualSrcOutput = Desc::kCoverage_DualSrcOutput;
+ desc->fDualSrcOutput = kCoverage_DualSrcOutput;
desc->fFirstCoverageStage = firstCoverageStage;
} else if (kSA_GrBlendCoeff == dstCoeff) {
// SA dst coeff becomes 1-(1-SA)*coverage when dst is partially covered.
- desc->fDualSrcOutput = Desc::kCoverageISA_DualSrcOutput;
+ desc->fDualSrcOutput = kCoverageISA_DualSrcOutput;
desc->fFirstCoverageStage = firstCoverageStage;
} else if (kSC_GrBlendCoeff == dstCoeff) {
// SA dst coeff becomes 1-(1-SA)*coverage when dst is partially covered.
- desc->fDualSrcOutput = Desc::kCoverageISC_DualSrcOutput;
+ desc->fDualSrcOutput = kCoverageISC_DualSrcOutput;
desc->fFirstCoverageStage = firstCoverageStage;
}
}
}
#if GR_DEBUG
- // verify valid vertex attribute state
+ // Verify valid vertex attribute state. These assertions should probably be done somewhere
+ // higher up the callstack
const GrVertexAttrib* vertexAttribs = drawState.getVertexAttribs();
GrAssert(desc->fPositionAttributeIndex < GrDrawState::kVertexAttribCnt);
- GrAssert(kAttribLayouts[vertexAttribs[desc->fPositionAttributeIndex].fType].fCount == 2);
+ GrAssert(GrGLAttribTypeToLayout(vertexAttribs[desc->fPositionAttributeIndex].fType).fCount == 2);
if (requiresAttributeColors) {
GrAssert(desc->fColorAttributeIndex < GrDrawState::kVertexAttribCnt);
- GrAssert(kAttribLayouts[vertexAttribs[desc->fColorAttributeIndex].fType].fCount == 4);
+ GrAssert(GrGLAttribTypeToLayout(vertexAttribs[desc->fColorAttributeIndex].fType).fCount == 4);
}
if (requiresAttributeCoverage) {
GrAssert(desc->fCoverageAttributeIndex < GrDrawState::kVertexAttribCnt);
- GrAssert(kAttribLayouts[vertexAttribs[desc->fCoverageAttributeIndex].fType].fCount == 4);
+ GrAssert(GrGLAttribTypeToLayout(vertexAttribs[desc->fCoverageAttributeIndex].fType).fCount == 4);
}
if (desc->fAttribBindings & GrDrawState::kLocalCoords_AttribBindingsBit) {
GrAssert(desc->fLocalCoordsAttributeIndex < GrDrawState::kVertexAttribCnt);
- GrAssert(kAttribLayouts[vertexAttribs[desc->fLocalCoordsAttributeIndex].fType].fCount == 2);
+ GrAssert(GrGLAttribTypeToLayout(vertexAttribs[desc->fLocalCoordsAttributeIndex].fType).fCount == 2);
}
#endif
}
GrGLProgram* GrGLProgram::Create(const GrGLContext& gl,
- const Desc& desc,
+ const GrGLProgramDesc& desc,
const GrEffectStage* stages[]) {
GrGLProgram* program = SkNEW_ARGS(GrGLProgram, (gl, desc, stages));
if (!program->succeeded()) {
}
GrGLProgram::GrGLProgram(const GrGLContext& gl,
- const Desc& desc,
+ const GrGLProgramDesc& desc,
const GrEffectStage* stages[])
: fContext(gl)
, fUniformManager(gl) {
void GrGLProgram::overrideBlend(GrBlendCoeff* srcCoeff,
GrBlendCoeff* dstCoeff) const {
switch (fDesc.fDualSrcOutput) {
- case Desc::kNone_DualSrcOutput:
+ case GrGLProgramDesc::kNone_DualSrcOutput:
break;
// the prog will write a coverage value to the secondary
// output and the dst is blended by one minus that value.
- case Desc::kCoverage_DualSrcOutput:
- case Desc::kCoverageISA_DualSrcOutput:
- case Desc::kCoverageISC_DualSrcOutput:
+ case GrGLProgramDesc::kCoverage_DualSrcOutput:
+ case GrGLProgramDesc::kCoverageISA_DualSrcOutput:
+ case GrGLProgramDesc::kCoverageISC_DualSrcOutput:
*dstCoeff = (GrBlendCoeff)GrGpu::kIS2C_GrBlendCoeff;
break;
default:
void GrGLProgram::genInputColor(GrGLShaderBuilder* builder, SkString* inColor) {
switch (fDesc.fColorInput) {
- case GrGLProgram::Desc::kAttribute_ColorInput: {
+ case GrGLProgramDesc::kAttribute_ColorInput: {
builder->addAttribute(kVec4f_GrSLType, COL_ATTR_NAME);
const char *vsName, *fsName;
builder->addVarying(kVec4f_GrSLType, "Color", &vsName, &fsName);
builder->vsCodeAppendf("\t%s = " COL_ATTR_NAME ";\n", vsName);
*inColor = fsName;
} break;
- case GrGLProgram::Desc::kUniform_ColorInput: {
+ case GrGLProgramDesc::kUniform_ColorInput: {
const char* name;
fUniformHandles.fColorUni = builder->addUniform(GrGLShaderBuilder::kFragment_ShaderType,
kVec4f_GrSLType, "Color", &name);
*inColor = name;
break;
}
- case GrGLProgram::Desc::kTransBlack_ColorInput:
+ case GrGLProgramDesc::kTransBlack_ColorInput:
GrAssert(!"needComputedColor should be false.");
break;
- case GrGLProgram::Desc::kSolidWhite_ColorInput:
+ case GrGLProgramDesc::kSolidWhite_ColorInput:
break;
default:
GrCrash("Unknown color type.");
if (inColor.size()) {
return inColor.c_str();
} else {
- if (Desc::kSolidWhite_ColorInput == fDesc.fColorInput) {
+ if (GrGLProgramDesc::kSolidWhite_ColorInput == fDesc.fColorInput) {
return GrGLSLOnesVecf(4);
} else {
return GrGLSLZerosVecf(4);
// no need to do the color filter if coverage is 0. The output color is scaled by the coverage.
// All the dual source outputs are scaled by the coverage as well.
- if (Desc::kTransBlack_ColorInput == fDesc.fCoverageInput) {
+ if (GrGLProgramDesc::kTransBlack_ColorInput == fDesc.fCoverageInput) {
colorCoeff = SkXfermode::kZero_Coeff;
uniformCoeff = SkXfermode::kZero_Coeff;
}
// If we know the final color is going to be all zeros then we can
// simplify the color filter coefficients. needComputedColor will then
// come out false below.
- if (Desc::kTransBlack_ColorInput == fDesc.fColorInput) {
+ if (GrGLProgramDesc::kTransBlack_ColorInput == fDesc.fColorInput) {
colorCoeff = SkXfermode::kZero_Coeff;
if (SkXfermode::kDC_Coeff == uniformCoeff ||
SkXfermode::kDA_Coeff == uniformCoeff) {
// if have all ones or zeros for the "dst" input to the color filter then we
// may be able to make additional optimizations.
if (needColorFilterUniform && needComputedColor && !inColor.size()) {
- GrAssert(Desc::kSolidWhite_ColorInput == fDesc.fColorInput);
+ GrAssert(GrGLProgramDesc::kSolidWhite_ColorInput == fDesc.fColorInput);
bool uniformCoeffIsZero = SkXfermode::kIDC_Coeff == uniformCoeff ||
SkXfermode::kIDA_Coeff == uniformCoeff;
if (uniformCoeffIsZero) {
// compute the partial coverage (coverage stages and edge aa)
SkString inCoverage;
- bool coverageIsZero = Desc::kTransBlack_ColorInput == fDesc.fCoverageInput;
+ bool coverageIsZero = GrGLProgramDesc::kTransBlack_ColorInput == fDesc.fCoverageInput;
// we don't need to compute coverage at all if we know the final shader
// output will be zero and we don't have a dual src blend output.
- if (!wroteFragColorZero || Desc::kNone_DualSrcOutput != fDesc.fDualSrcOutput) {
+ if (!wroteFragColorZero || GrGLProgramDesc::kNone_DualSrcOutput != fDesc.fDualSrcOutput) {
if (!coverageIsZero) {
switch (fDesc.fCoverageInput) {
- case Desc::kSolidWhite_ColorInput:
+ case GrGLProgramDesc::kSolidWhite_ColorInput:
// empty string implies solid white
break;
- case Desc::kAttribute_ColorInput:
+ case GrGLProgramDesc::kAttribute_ColorInput:
gen_attribute_coverage(&builder, &inCoverage);
break;
- case Desc::kUniform_ColorInput:
+ case GrGLProgramDesc::kUniform_ColorInput:
this->genUniformCoverage(&builder, &inCoverage);
break;
default:
}
}
- if (Desc::kNone_DualSrcOutput != fDesc.fDualSrcOutput) {
+ if (GrGLProgramDesc::kNone_DualSrcOutput != fDesc.fDualSrcOutput) {
builder.fFSOutputs.push_back().set(kVec4f_GrSLType,
GrGLShaderVar::kOut_TypeModifier,
dual_source_output_name());
bool outputIsZero = coverageIsZero;
SkString coeff;
if (!outputIsZero &&
- Desc::kCoverage_DualSrcOutput != fDesc.fDualSrcOutput && !wroteFragColorZero) {
+ GrGLProgramDesc::kCoverage_DualSrcOutput != fDesc.fDualSrcOutput && !wroteFragColorZero) {
if (!inColor.size()) {
outputIsZero = true;
} else {
- if (Desc::kCoverageISA_DualSrcOutput == fDesc.fDualSrcOutput) {
+ if (GrGLProgramDesc::kCoverageISA_DualSrcOutput == fDesc.fDualSrcOutput) {
coeff.printf("(1 - %s.a)", inColor.c_str());
} else {
coeff.printf("(vec4(1,1,1,1) - %s)", inColor.c_str());
SharedGLState* sharedState) {
if (!(drawState.getAttribBindings() & GrDrawState::kColor_AttribBindingsBit)) {
switch (fDesc.fColorInput) {
- case GrGLProgram::Desc::kAttribute_ColorInput:
+ case GrGLProgramDesc::kAttribute_ColorInput:
if (sharedState->fConstAttribColor != color) {
// OpenGL ES only supports the float varieties of glVertexAttrib
GrGLfloat c[4];
sharedState->fConstAttribColor = color;
}
break;
- case GrGLProgram::Desc::kUniform_ColorInput:
+ case GrGLProgramDesc::kUniform_ColorInput:
if (fColor != color) {
// OpenGL ES doesn't support unsigned byte varieties of glUniform
GrGLfloat c[4];
fColor = color;
}
break;
- case GrGLProgram::Desc::kSolidWhite_ColorInput:
- case GrGLProgram::Desc::kTransBlack_ColorInput:
+ case GrGLProgramDesc::kSolidWhite_ColorInput:
+ case GrGLProgramDesc::kTransBlack_ColorInput:
break;
default:
GrCrash("Unknown color type.");
SharedGLState* sharedState) {
if (!(drawState.getAttribBindings() & GrDrawState::kCoverage_AttribBindingsBit)) {
switch (fDesc.fCoverageInput) {
- case Desc::kAttribute_ColorInput:
+ case GrGLProgramDesc::kAttribute_ColorInput:
if (sharedState->fConstAttribCoverage != coverage) {
// OpenGL ES only supports the float varieties of glVertexAttrib
GrGLfloat c[4];
sharedState->fConstAttribCoverage = coverage;
}
break;
- case Desc::kUniform_ColorInput:
+ case GrGLProgramDesc::kUniform_ColorInput:
if (fCoverage != coverage) {
// OpenGL ES doesn't support unsigned byte varieties of glUniform
GrGLfloat c[4];
fCoverage = coverage;
}
break;
- case Desc::kSolidWhite_ColorInput:
- case Desc::kTransBlack_ColorInput:
+ case GrGLProgramDesc::kSolidWhite_ColorInput:
+ case GrGLProgramDesc::kTransBlack_ColorInput:
break;
default:
GrCrash("Unknown coverage type.");
#define GrGLProgram_DEFINED
#include "GrDrawState.h"
-#include "GrGLEffect.h"
#include "GrGLContext.h"
+#include "GrGLProgramDesc.h"
#include "GrGLSL.h"
#include "GrGLTexture.h"
#include "GrGLUniformManager.h"
class GrGLShaderBuilder;
class SkMWCRandom;
-// optionally compile the experimental GS code. Set to GR_DEBUG
-// so that debug build bots will execute the code.
-#define GR_GL_EXPERIMENTAL_GS GR_DEBUG
-
/**
* This class manages a GPU program and records per-program information.
* We can specify the attribute locations so that they are constant
public:
SK_DECLARE_INST_COUNT(GrGLProgram)
- class Desc;
-
- /**
- * Builds a program descriptor from a GrDrawState. Whether the primitive type is points, the
- * output of GrDrawState::getBlendOpts, and the caps of the GrGpuGL are also inputs.
- */
- static void BuildDesc(const GrDrawState&,
- bool isPoints,
- GrDrawState::BlendOptFlags,
- GrBlendCoeff srcCoeff,
- GrBlendCoeff dstCoeff,
- const GrGpuGL* gpu,
- Desc* outDesc);
-
static GrGLProgram* Create(const GrGLContext& gl,
- const Desc& desc,
+ const GrGLProgramDesc& desc,
const GrEffectStage* stages[]);
virtual ~GrGLProgram();
*/
void overrideBlend(GrBlendCoeff* srcCoeff, GrBlendCoeff* dstCoeff) const;
- const Desc& getDesc() { return fDesc; }
+ const GrGLProgramDesc& getDesc() { return fDesc; }
/**
* Gets the GL program ID for this program.
*/
void setData(GrGpuGL*, GrColor color, GrColor coverage, SharedGLState*);
- // Parameters that affect code generation
- // This structs should be kept compact; it is input to an expensive hash key generator.
- class Desc {
- public:
- Desc() {
- // since we use this as part of a key we can't have any uninitialized
- // padding
- memset(this, 0, sizeof(Desc));
- }
-
- // returns this as a uint32_t array to be used as a key in the program cache
- const uint32_t* asKey() const {
- return reinterpret_cast<const uint32_t*>(this);
- }
-
- // For unit testing.
- void setRandom(SkMWCRandom*,
- const GrGpuGL* gpu,
- const GrEffectStage stages[GrDrawState::kNumStages]);
-
- private:
- // Specifies where the initial color comes from before the stages are applied.
- enum ColorInput {
- kSolidWhite_ColorInput,
- kTransBlack_ColorInput,
- kAttribute_ColorInput,
- kUniform_ColorInput,
-
- kColorInputCnt
- };
- // Dual-src blending makes use of a secondary output color that can be
- // used as a per-pixel blend coefficient. This controls whether a
- // secondary source is output and what value it holds.
- enum DualSrcOutput {
- kNone_DualSrcOutput,
- kCoverage_DualSrcOutput,
- kCoverageISA_DualSrcOutput,
- kCoverageISC_DualSrcOutput,
-
- kDualSrcOutputCnt
- };
-
- // should the FS discard if the coverage is zero (to avoid stencil manipulation)
- bool fDiscardIfZeroCoverage;
-
- // stripped of bits that don't affect program generation
- GrAttribBindings fAttribBindings;
-
- /** Non-zero if this stage has an effect */
- GrGLEffect::EffectKey fEffectKeys[GrDrawState::kNumStages];
-
- // To enable experimental geometry shader code (not for use in
- // production)
-#if GR_GL_EXPERIMENTAL_GS
- bool fExperimentalGS;
-#endif
- uint8_t fColorInput; // casts to enum ColorInput
- uint8_t fCoverageInput; // casts to enum ColorInput
- uint8_t fDualSrcOutput; // casts to enum DualSrcOutput
- int8_t fFirstCoverageStage;
- SkBool8 fEmitsPointSize;
- uint8_t fColorFilterXfermode; // casts to enum SkXfermode::Mode
-
- int8_t fPositionAttributeIndex;
- int8_t fColorAttributeIndex;
- int8_t fCoverageAttributeIndex;
- int8_t fLocalCoordsAttributeIndex;
-
- friend class GrGLProgram;
- };
-
- // Layout information for OpenGL vertex attributes
- struct AttribLayout {
- GrGLint fCount;
- GrGLenum fType;
- GrGLboolean fNormalized;
- };
- static const AttribLayout kAttribLayouts[kGrVertexAttribTypeCount];
-
private:
GrGLProgram(const GrGLContext& gl,
- const Desc& desc,
+ const GrGLProgramDesc& desc,
const GrEffectStage* stages[]);
bool succeeded() const { return 0 != fProgramID; }
GrGLEffect* fEffects[GrDrawState::kNumStages];
- Desc fDesc;
+ GrGLProgramDesc fDesc;
const GrGLContext& fContext;
GrGLUniformManager fUniformManager;
--- /dev/null
+/*
+ * Copyright 2013 Google Inc.
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#ifndef GrGLProgramDesc_DEFINED
+#define GrGLProgramDesc_DEFINED
+
+#include "GrGLEffect.h"
+
+class GrGpuGL;
+
+// optionally compile the experimental GS code. Set to GR_DEBUG so that debug build bots will
+// execute the code.
+#define GR_GL_EXPERIMENTAL_GS GR_DEBUG
+
+
+/** This class describes a program to generate. It also serves as a program cache key. The only
+ thing GL-specific about this is the generation of GrGLEffect::EffectKeys. With some refactoring
+ it could be made backend-neutral. */
+class GrGLProgramDesc {
+public:
+ GrGLProgramDesc() {
+ // since we use this as part of a key we can't have any uninitialized padding
+ memset(this, 0, sizeof(GrGLProgramDesc));
+ }
+
+ // Returns this as a uint32_t array to be used as a key in the program cache
+ const uint32_t* asKey() const {
+ return reinterpret_cast<const uint32_t*>(this);
+ }
+
+ // For unit testing.
+ void setRandom(SkMWCRandom*,
+ const GrGpuGL* gpu,
+ const GrEffectStage stages[GrDrawState::kNumStages]);
+
+ /**
+ * Builds a program descriptor from a GrDrawState. Whether the primitive type is points, the
+ * output of GrDrawState::getBlendOpts, and the caps of the GrGpuGL are also inputs.
+ */
+ static void Build(const GrDrawState&,
+ bool isPoints,
+ GrDrawState::BlendOptFlags,
+ GrBlendCoeff srcCoeff,
+ GrBlendCoeff dstCoeff,
+ const GrGpuGL* gpu,
+ GrGLProgramDesc* outDesc);
+
+private:
+ // Specifies where the initial color comes from before the stages are applied.
+ enum ColorInput {
+ kSolidWhite_ColorInput,
+ kTransBlack_ColorInput,
+ kAttribute_ColorInput,
+ kUniform_ColorInput,
+
+ kColorInputCnt
+ };
+ // Dual-src blending makes use of a secondary output color that can be
+ // used as a per-pixel blend coefficient. This controls whether a
+ // secondary source is output and what value it holds.
+ enum DualSrcOutput {
+ kNone_DualSrcOutput,
+ kCoverage_DualSrcOutput,
+ kCoverageISA_DualSrcOutput,
+ kCoverageISC_DualSrcOutput,
+
+ kDualSrcOutputCnt
+ };
+
+ // should the FS discard if the coverage is zero (to avoid stencil manipulation)
+ bool fDiscardIfZeroCoverage;
+
+ // stripped of bits that don't affect program generation
+ GrAttribBindings fAttribBindings;
+
+ /** Non-zero if this stage has an effect */
+ GrGLEffect::EffectKey fEffectKeys[GrDrawState::kNumStages];
+
+ // To enable experimental geometry shader code (not for use in
+ // production)
+#if GR_GL_EXPERIMENTAL_GS
+ bool fExperimentalGS;
+#endif
+ uint8_t fColorInput; // casts to enum ColorInput
+ uint8_t fCoverageInput; // casts to enum ColorInput
+ uint8_t fDualSrcOutput; // casts to enum DualSrcOutput
+ int8_t fFirstCoverageStage;
+ SkBool8 fEmitsPointSize;
+ uint8_t fColorFilterXfermode; // casts to enum SkXfermode::Mode
+
+ int8_t fPositionAttributeIndex;
+ int8_t fColorAttributeIndex;
+ int8_t fCoverageAttributeIndex;
+ int8_t fLocalCoordsAttributeIndex;
+
+ // GrGLProgram reads the private fields to generate code.
+ friend class GrGLProgram;
+};
+
+#endif
#define GrGLVertexArray_DEFINED
#include "GrResource.h"
+#include "GrTypesPriv.h"
+#include "gl/GrGLDefines.h"
#include "gl/GrGLFunctions.h"
#include "SkTArray.h"
class GrGLIndexBuffer;
class GrGpuGL;
+struct GrGLAttribLayout {
+ GrGLint fCount;
+ GrGLenum fType;
+ GrGLboolean fNormalized;
+};
+
+static inline const GrGLAttribLayout& GrGLAttribTypeToLayout(GrVertexAttribType type) {
+ GrAssert(type >= 0 && type < kGrVertexAttribTypeCount);
+ static const GrGLAttribLayout kLayouts[kGrVertexAttribTypeCount] = {
+ {1, GR_GL_FLOAT, false}, // kFloat_GrVertexAttribType
+ {2, GR_GL_FLOAT, false}, // kVec2f_GrVertexAttribType
+ {3, GR_GL_FLOAT, false}, // kVec3f_GrVertexAttribType
+ {4, GR_GL_FLOAT, false}, // kVec4f_GrVertexAttribType
+ {4, GR_GL_UNSIGNED_BYTE, true}, // kVec4ub_GrVertexAttribType
+ };
+ GR_STATIC_ASSERT(0 == kFloat_GrVertexAttribType);
+ GR_STATIC_ASSERT(1 == kVec2f_GrVertexAttribType);
+ GR_STATIC_ASSERT(2 == kVec3f_GrVertexAttribType);
+ GR_STATIC_ASSERT(3 == kVec4f_GrVertexAttribType);
+ GR_STATIC_ASSERT(4 == kVec4ub_GrVertexAttribType);
+ GR_STATIC_ASSERT(SK_ARRAY_COUNT(kLayouts) == kGrVertexAttribTypeCount);
+ return kLayouts[type];
+}
+
/**
* This sets and tracks the vertex attribute array state. It is used internally by GrGLVertexArray
* (below) but is separate because it is also used to track the state of vertex array object 0.
~ProgramCache();
void abandon();
- GrGLProgram* getProgram(const GrGLProgram::Desc& desc, const GrEffectStage* stages[]);
+ GrGLProgram* getProgram(const GrGLProgramDesc& desc, const GrEffectStage* stages[]);
private:
enum {
- kKeySize = sizeof(GrGLProgram::Desc),
+ kKeySize = sizeof(GrGLProgramDesc),
// We may actually have kMaxEntries+1 shaders in the GL context because we create a new
// shader before evicting from the cache.
kMaxEntries = 32
fCount = 0;
}
-GrGLProgram* GrGpuGL::ProgramCache::getProgram(const GrGLProgram::Desc& desc,
+GrGLProgram* GrGpuGL::ProgramCache::getProgram(const GrGLProgramDesc& desc,
const GrEffectStage* stages[]) {
Entry newEntry;
newEntry.fKey.setKeyData(desc.asKey());
for (int i = 0; i < GrDrawState::kNumStages; ++i) {
stages[i] = drawState.isStageEnabled(i) ? &drawState.getStage(i) : NULL;
}
- GrGLProgram::Desc desc;
- GrGLProgram::BuildDesc(this->getDrawState(),
+ GrGLProgramDesc desc;
+ GrGLProgramDesc::Build(this->getDrawState(),
kDrawPoints_DrawType == type,
blendOpts,
srcCoeff,
attribState->set(this,
vertexAttribIndex,
vbuf,
- GrGLProgram::kAttribLayouts[attribType].fCount,
- GrGLProgram::kAttribLayouts[attribType].fType,
- GrGLProgram::kAttribLayouts[attribType].fNormalized,
+ GrGLAttribTypeToLayout(attribType).fCount,
+ GrGLAttribTypeToLayout(attribType).fType,
+ GrGLAttribTypeToLayout(attribType).fNormalized,
stride,
reinterpret_cast<GrGLvoid*>(
vertexOffsetInBytes + vertexAttrib->fOffset));
#include "SkRandom.h"
#include "Test.h"
-void GrGLProgram::Desc::setRandom(SkMWCRandom* random,
- const GrGpuGL* gpu,
- const GrEffectStage stages[GrDrawState::kNumStages]) {
+void GrGLProgramDesc::setRandom(SkMWCRandom* random,
+ const GrGpuGL* gpu,
+ const GrEffectStage stages[GrDrawState::kNumStages]) {
fAttribBindings = 0;
fEmitsPointSize = random->nextBool();
fColorInput = random->nextULessThan(kColorInputCnt);
}
#endif
- GrGLProgram::Desc pdesc;
+ GrGLProgramDesc pdesc;
GrEffectStage stages[GrDrawState::kNumStages];
int currAttribIndex = GrDrawState::kAttribIndexCount;
projects / platform / upstream / libSkiaSharp.git / commitdiff