Index: src/gpu/gl/builders/GrGLFullProgramBuilder.h |
diff --git a/src/gpu/gl/builders/GrGLFullProgramBuilder.h b/src/gpu/gl/builders/GrGLFullProgramBuilder.h |
new file mode 100644 |
index 0000000000000000000000000000000000000000..0f3834187b9dbdf1ef0d9c77d8d8d584866ceb1a |
--- /dev/null |
+++ b/src/gpu/gl/builders/GrGLFullProgramBuilder.h |
@@ -0,0 +1,130 @@ |
+/* |
+ * Copyright 2014 Google Inc. |
+ * |
+ * Use of this source code is governed by a BSD-style license that can be |
+ * found in the LICENSE file. |
+ */ |
+ |
+#ifndef GrGLFullProgramBuilder_DEFINED |
+#define GrGLFullProgramBuilder_DEFINED |
+ |
+#include "GrGLProgramBuilder.h" |
+#include "../GrGLGeometryProcessor.h" |
+ |
+class GrGLVertexProgramEffects; |
+ |
+class GrGLFullProgramBuilder : public GrGLProgramBuilder { |
+public: |
+ GrGLFullProgramBuilder(GrGpuGL*, const GrOptDrawState&, const GrGLProgramDesc&); |
+ |
+ /** Add a varying variable to the current program to pass values between vertex and fragment |
+ shaders. If the last two parameters are non-NULL, they are filled in with the name |
+ generated. */ |
+ void addVarying(GrSLType type, |
+ const char* name, |
+ const char** vsOutName = NULL, |
+ const char** fsInName = NULL, |
+ GrGLShaderVar::Precision fsPrecision=GrGLShaderVar::kDefault_Precision); |
+ |
+ /** Add a separable varying input variable to the current program. |
+ * A separable varying (fragment shader input) is a varying that can be used also when vertex |
+ * shaders are not used. With a vertex shader, the operation is same as with other |
+ * varyings. Without a vertex shader, such as with NV_path_rendering, GL APIs are used to |
+ * populate the variable. The APIs can refer to the variable through the returned handle. |
+ */ |
+ VaryingHandle addSeparableVarying(GrSLType type, |
+ const char* name, |
+ const char** vsOutName, |
+ const char** fsInName); |
+ |
+ GrGLVertexShaderBuilder* getVertexShaderBuilder() { return &fVS; } |
+ |
+ /* |
+ * This non-virtual call will hide the parent call to prevent GPs from accessing fragment shader |
+ * functionality they shouldn't be using |
+ */ |
+ GrGLProcessorFragmentShaderBuilder* getFragmentShaderBuilder() { return &fFS; } |
+ |
+private: |
+ virtual void createAndEmitEffects(const GrGeometryStage* geometryProcessor, |
+ const GrFragmentStage* colorStages[], |
+ const GrFragmentStage* coverageStages[], |
+ GrGLSLExpr4* inputColor, |
+ GrGLSLExpr4* inputCoverage) SK_OVERRIDE; |
+ |
+ GrGLProgramEffects* onCreateAndEmitEffects(const GrFragmentStage* effectStages[], |
+ int effectCnt, |
+ const GrGLProgramDesc::EffectKeyProvider&, |
+ GrGLSLExpr4* inOutFSColor); |
+ |
+ class GrGLGeometryProcessorEmitter : public GrGLProgramBuilder::GrGLProcessorEmitterInterface { |
+ public: |
+ GrGLGeometryProcessorEmitter(GrGLFullProgramBuilder* builder) |
+ : fBuilder(builder) |
+ , fGeometryProcessor(NULL) |
+ , fGLGeometryProcessor(NULL) {} |
+ virtual ~GrGLGeometryProcessorEmitter() {} |
+ void set(const GrGeometryProcessor* gp) { |
+ SkASSERT(NULL == fGeometryProcessor); |
+ fGeometryProcessor = gp; |
+ } |
+ virtual GrGLProcessor* createGLInstance() { |
+ SkASSERT(fGeometryProcessor); |
+ SkASSERT(NULL == fGLGeometryProcessor); |
+ fGLGeometryProcessor = |
+ fGeometryProcessor->getFactory().createGLInstance(*fGeometryProcessor); |
+ return fGLGeometryProcessor; |
+ } |
+ virtual void emit(const GrProcessorKey& key, |
+ const char* outColor, |
+ const char* inColor, |
+ const GrGLProcessor::TransformedCoordsArray& coords, |
+ const GrGLProcessor::TextureSamplerArray& samplers) { |
+ SkASSERT(fGeometryProcessor); |
+ SkASSERT(fGLGeometryProcessor); |
+ fGLGeometryProcessor->emitCode(fBuilder, *fGeometryProcessor, key, outColor, |
+ inColor, coords, samplers); |
+ // this will not leak because it has already been used by createGLInstance |
+ fGLGeometryProcessor = NULL; |
+ fGeometryProcessor = NULL; |
+ } |
+ private: |
+ GrGLFullProgramBuilder* fBuilder; |
+ const GrGeometryProcessor* fGeometryProcessor; |
+ GrGLGeometryProcessor* fGLGeometryProcessor; |
+ }; |
+ |
+ virtual void emitEffect(const GrProcessorStage& stage, |
+ const GrProcessorKey& key, |
+ const char* outColor, |
+ const char* inColor, |
+ int stageIndex) SK_OVERRIDE; |
+ |
+ /** |
+ * Helper for emitEffect(). Emits code to implement an effect's coord transforms in the VS. |
+ * Varyings are added as an outputs of the VS and inputs to the FS. The varyings may be either a |
+ * vec2f or vec3f depending upon whether perspective interpolation is required or not. The names |
+ * of the varyings in the VS and FS as well their types are appended to the |
+ * TransformedCoordsArray* object, which is in turn passed to the effect's emitCode() function. |
+ */ |
+ void emitTransforms(const GrProcessorStage& effectStage, |
+ GrGLProcessor::TransformedCoordsArray* outCoords); |
+ |
+ virtual bool compileAndAttachShaders(GrGLuint programId, |
+ SkTDArray<GrGLuint>* shaderIds) const SK_OVERRIDE; |
+ |
+ virtual void bindProgramLocations(GrGLuint programId) SK_OVERRIDE; |
+ |
+ virtual GrGLProgramEffects* getProgramEffects() SK_OVERRIDE { return fProgramEffects.get(); } |
+ |
+ typedef GrGLProgramDesc::EffectKeyProvider EffectKeyProvider; |
+ |
+ GrGLGeometryProcessorEmitter fGLGeometryProcessorEmitter; |
+ GrGLGeometryShaderBuilder fGS; |
+ GrGLVertexShaderBuilder fVS; |
+ SkAutoTDelete<GrGLVertexProgramEffects> fProgramEffects; |
+ |
+ typedef GrGLProgramBuilder INHERITED; |
+}; |
+ |
+#endif |