#include "GrColor.h"
#include "GrEffect.h"
#include "SkTypes.h"
+#include "gl/GrGLProgramDesc.h"
#include "gl/GrGLProgramEffects.h"
#include "gl/GrGLSL.h"
-#include "gl/GrGLUniformManager.h"
+#include "gl/GrGLProgramDataManager.h"
#include <stdarg.h>
class GrGLShaderBuilder {
public:
typedef GrTAllocator<GrGLShaderVar> VarArray;
- typedef GrBackendEffectFactory::EffectKey EffectKey;
typedef GrGLProgramEffects::TextureSampler TextureSampler;
typedef GrGLProgramEffects::TransformedCoordsArray TransformedCoordsArray;
- typedef GrGLUniformManager::BuilderUniform BuilderUniform;
enum ShaderVisibility {
kVertex_Visibility = 0x1,
kFragment_Visibility = 0x4,
};
- typedef GrGLUniformManager::UniformHandle UniformHandle;
+ typedef GrGLProgramDataManager::UniformHandle UniformHandle;
// Handles for program uniforms (other than per-effect uniforms)
- struct UniformHandles {
+ struct BuiltinUniformHandles {
UniformHandle fViewMatrixUni;
UniformHandle fRTAdjustmentUni;
UniformHandle fColorUni;
UniformHandle fDstCopySamplerUni;
};
- struct GenProgramOutput {
- GenProgramOutput()
- : fColorEffects(NULL)
- , fCoverageEffects(NULL)
- , fHasVertexShader(false)
- , fTexCoordSetCnt(0)
- , fProgramID(0) {}
+ struct UniformInfo {
+ GrGLShaderVar fVariable;
+ uint32_t fVisibility;
+ GrGLint fLocation;
+ };
- GenProgramOutput(const GenProgramOutput& other) {
- *this = other;
- }
+ // This uses an allocator rather than array so that the GrGLShaderVars don't move in memory
+ // after they are inserted. Users of GrGLShaderBuilder get refs to the vars and ptrs to their
+ // name strings. Otherwise, we'd have to hand out copies.
+ typedef GrTAllocator<UniformInfo> UniformInfoArray;
- GenProgramOutput& operator=(const GenProgramOutput& other) {
- fColorEffects.reset(SkRef(other.fColorEffects.get()));
- fCoverageEffects.reset(SkRef(other.fCoverageEffects.get()));
- fUniformHandles = other.fUniformHandles;
- fHasVertexShader = other.fHasVertexShader;
- fTexCoordSetCnt = other.fTexCoordSetCnt;
- fProgramID = other.fProgramID;
- return *this;
- }
+ /** Generates a shader program.
+ *
+ * The program implements what is specified in the stages given as input.
+ * After successful generation, the builder result objects are available
+ * to be used.
+ * @return true if generation was successful.
+ */
+ bool genProgram(const GrEffectStage* inColorStages[],
+ const GrEffectStage* inCoverageStages[]);
- SkAutoTUnref<GrGLProgramEffects> fColorEffects;
- SkAutoTUnref<GrGLProgramEffects> fCoverageEffects;
- UniformHandles fUniformHandles;
- bool fHasVertexShader;
- int fTexCoordSetCnt;
- GrGLuint fProgramID;
- };
+ // Below are the results of the shader generation.
- static bool GenProgram(GrGpuGL* gpu,
- GrGLUniformManager* uman,
- const GrGLProgramDesc& desc,
- const GrEffectStage* inColorStages[],
- const GrEffectStage* inCoverageStages[],
- GenProgramOutput* output);
+ GrGLProgramEffects* getColorEffects() const { SkASSERT(fProgramID); return fColorEffects.get(); }
+ GrGLProgramEffects* getCoverageEffects() const { SkASSERT(fProgramID); return fCoverageEffects.get(); }
+ const BuiltinUniformHandles& getBuiltinUniformHandles() const {
+ SkASSERT(fProgramID);
+ return fUniformHandles;
+ }
+ GrGLuint getProgramID() const { SkASSERT(fProgramID); return fProgramID; }
+ bool hasVertexShader() const { SkASSERT(fProgramID); return fHasVertexShader; }
+ int getTexCoordSetCount() const { SkASSERT(fProgramID); return fTexCoordSetCnt; }
+ const UniformInfoArray& getUniformInfos() const { return fUniforms; }
virtual ~GrGLShaderBuilder() {}
supported at this time. The actual uniform name will be mangled. If outName is not NULL then
it will refer to the final uniform name after return. Use the addUniformArray variant to add
an array of uniforms. */
- GrGLUniformManager::UniformHandle addUniform(uint32_t visibility,
- GrSLType type,
- const char* name,
- const char** outName = NULL) {
+ GrGLProgramDataManager::UniformHandle addUniform(uint32_t visibility,
+ GrSLType type,
+ const char* name,
+ const char** outName = NULL) {
return this->addUniformArray(visibility, type, name, GrGLShaderVar::kNonArray, outName);
}
- GrGLUniformManager::UniformHandle addUniformArray(uint32_t visibility,
- GrSLType type,
- const char* name,
- int arrayCount,
- const char** outName = NULL);
-
- const GrGLShaderVar& getUniformVariable(GrGLUniformManager::UniformHandle u) const {
- return fUniformManager->getBuilderUniform(fUniforms, u).fVariable;
+ GrGLProgramDataManager::UniformHandle addUniformArray(uint32_t visibility,
+ GrSLType type,
+ const char* name,
+ int arrayCount,
+ const char** outName = NULL);
+
+ const GrGLShaderVar& getUniformVariable(GrGLProgramDataManager::UniformHandle u) const {
+ return fUniforms[u.toShaderBuilderIndex()].fVariable;
}
/**
* Shortcut for getUniformVariable(u).c_str()
*/
- const char* getUniformCStr(GrGLUniformManager::UniformHandle u) const {
+ const char* getUniformCStr(GrGLProgramDataManager::UniformHandle u) const {
return this->getUniformVariable(u).c_str();
}
};
protected:
- GrGLShaderBuilder(GrGpuGL*, GrGLUniformManager*, const GrGLProgramDesc&);
+ GrGLShaderBuilder(GrGpuGL*, const GrGLProgramDesc&);
GrGpuGL* gpu() const { return fGpu; }
// Helper for emitEffects().
void createAndEmitEffects(GrGLProgramEffectsBuilder*,
const GrEffectStage* effectStages[],
- const EffectKey effectKeys[],
int effectCnt,
+ const GrGLProgramDesc::EffectKeyProvider&,
GrGLSLExpr4* inOutFSColor);
// Generates a name for a variable. The generated string will be name prefixed by the prefix
virtual bool compileAndAttachShaders(GrGLuint programId, SkTDArray<GrGLuint>* shaderIds) const;
- virtual void bindProgramLocations(GrGLuint programId) const;
+ virtual void bindProgramLocations(GrGLuint programId);
+ void resolveProgramLocations(GrGLuint programId);
void appendDecls(const VarArray&, SkString*) const;
void appendUniformDecls(ShaderVisibility, SkString*) const;
- const GenProgramOutput& getOutput() const { return fOutput; }
-
- GenProgramOutput fOutput;
-
+ SkAutoTUnref<GrGLProgramEffects> fColorEffects;
+ SkAutoTUnref<GrGLProgramEffects> fCoverageEffects;
+ BuiltinUniformHandles fUniformHandles;
+ bool fHasVertexShader;
+ int fTexCoordSetCnt;
+ GrGLuint fProgramID;
private:
class CodeStage : SkNoncopyable {
public:
const GrEffectStage* fEffectStage;
} fCodeStage;
- bool genProgram(const GrEffectStage* colorStages[], const GrEffectStage* coverageStages[]);
-
/**
* The base class will emit the fragment code that precedes the per-effect code and then call
* this function. The subclass can use it to insert additional fragment code that should
/**
* Adds code for effects and returns a GrGLProgramEffects* object. The caller is responsible for
- * deleting it when finished. effectStages contains the effects to add. effectKeys[i] is the key
- * generated from effectStages[i]. inOutFSColor specifies the input color to the first stage and
- * is updated to be the output color of the last stage.
- * The handles to texture samplers for effectStage[i] are added to
+ * deleting it when finished. effectStages contains the effects to add. The effect key provider
+ * is used to communicate the key each effect created in its GenKey function. inOutFSColor
+ * specifies the input color to the first stage and is updated to be the output color of the
+ * last stage. The handles to texture samplers for effectStage[i] are added to
* effectSamplerHandles[i].
*/
virtual GrGLProgramEffects* createAndEmitEffects(const GrEffectStage* effectStages[],
- const EffectKey effectKeys[],
int effectCnt,
+ const GrGLProgramDesc::EffectKeyProvider&,
GrGLSLExpr4* inOutFSColor) = 0;
/**
*/
enum GLSLPrivateFeature {
kFragCoordConventions_GLSLPrivateFeature = kLastGLSLFeature + 1,
- kEXTShaderFramebufferFetch_GLSLPrivateFeature,
- kNVShaderFramebufferFetch_GLSLPrivateFeature,
+ kLastGLSLPrivateFeature = kFragCoordConventions_GLSLPrivateFeature
};
bool enablePrivateFeature(GLSLPrivateFeature);
const GrGLProgramDesc& fDesc;
GrGpuGL* fGpu;
- SkAutoTUnref<GrGLUniformManager> fUniformManager;
uint32_t fFSFeaturesAddedMask;
SkString fFSFunctions;
SkString fFSExtensions;
VarArray fFSInputs;
VarArray fFSOutputs;
- GrGLUniformManager::BuilderUniformArray fUniforms;
+ UniformInfoArray fUniforms;
SkString fFSCode;
class GrGLFullShaderBuilder : public GrGLShaderBuilder {
public:
- GrGLFullShaderBuilder(GrGpuGL*, GrGLUniformManager*, const GrGLProgramDesc&);
+ GrGLFullShaderBuilder(GrGpuGL*, const GrGLProgramDesc&);
/**
* Called by GrGLEffects to add code to one of the shaders.
virtual void emitCodeBeforeEffects(GrGLSLExpr4* color, GrGLSLExpr4* coverage) SK_OVERRIDE;
virtual GrGLProgramEffects* createAndEmitEffects(const GrEffectStage* effectStages[],
- const EffectKey effectKeys[],
int effectCnt,
+ const GrGLProgramDesc::EffectKeyProvider&,
GrGLSLExpr4* inOutFSColor) SK_OVERRIDE;
virtual void emitCodeAfterEffects() SK_OVERRIDE;
virtual bool compileAndAttachShaders(GrGLuint programId,
SkTDArray<GrGLuint>* shaderIds) const SK_OVERRIDE;
- virtual void bindProgramLocations(GrGLuint programId) const SK_OVERRIDE;
+ virtual void bindProgramLocations(GrGLuint programId) SK_OVERRIDE;
VarArray fVSAttrs;
VarArray fVSOutputs;
class GrGLFragmentOnlyShaderBuilder : public GrGLShaderBuilder {
public:
- GrGLFragmentOnlyShaderBuilder(GrGpuGL*, GrGLUniformManager*, const GrGLProgramDesc&);
+ GrGLFragmentOnlyShaderBuilder(GrGpuGL*, const GrGLProgramDesc&);
int addTexCoordSets(int count);
virtual void emitCodeBeforeEffects(GrGLSLExpr4* color, GrGLSLExpr4* coverage) SK_OVERRIDE {}
virtual GrGLProgramEffects* createAndEmitEffects(const GrEffectStage* effectStages[],
- const EffectKey effectKeys[],
int effectCnt,
+ const GrGLProgramDesc::EffectKeyProvider&,
GrGLSLExpr4* inOutFSColor) SK_OVERRIDE;
virtual void emitCodeAfterEffects() SK_OVERRIDE {}
projects / platform / framework / web / crosswalk.git / blobdiff