OLD | NEW |
(Empty) | |
| 1 /* |
| 2 * Copyright 2013 Google Inc. |
| 3 * |
| 4 * Use of this source code is governed by a BSD-style license that can be |
| 5 * found in the LICENSE file. |
| 6 */ |
| 7 |
| 8 #ifndef GrGLProgramEffects_DEFINED |
| 9 #define GrGLProgramEffects_DEFINED |
| 10 |
| 11 #include "GrBackendProcessorFactory.h" |
| 12 #include "GrGLProgramDataManager.h" |
| 13 #include "GrGpu.h" |
| 14 #include "GrTexture.h" |
| 15 #include "GrTextureAccess.h" |
| 16 |
| 17 class GrProcessor; |
| 18 class GrProcessorStage; |
| 19 class GrGLVertexProgramEffectsBuilder; |
| 20 class GrGLProgramBuilder; |
| 21 class GrGLFullProgramBuilder; |
| 22 class GrGLFragmentOnlyProgramBuilder; |
| 23 |
| 24 /** |
| 25 * This class encapsulates an array of GrGLProcessors and their supporting data
(coord transforms |
| 26 * and textures). It is built with GrGLProgramEffectsBuilder, then used to manag
e the necessary GL |
| 27 * state and shader uniforms. |
| 28 */ |
| 29 class GrGLProgramEffects : public SkRefCnt { |
| 30 public: |
| 31 typedef GrGLProgramDataManager::UniformHandle UniformHandle; |
| 32 typedef GrGLProgramDataManager::VaryingHandle VaryingHandle; |
| 33 virtual ~GrGLProgramEffects(); |
| 34 |
| 35 /** |
| 36 * Assigns a texture unit to each sampler. It starts on *texUnitIdx and writ
es the next |
| 37 * available unit to *texUnitIdx when it returns. |
| 38 */ |
| 39 void initSamplers(const GrGLProgramDataManager&, int* texUnitIdx); |
| 40 |
| 41 /** |
| 42 * Calls setData() on each effect, and sets their transformation matrices an
d texture bindings. |
| 43 */ |
| 44 virtual void setData(GrGpuGL*, |
| 45 GrGpu::DrawType, |
| 46 const GrGLProgramDataManager&, |
| 47 const GrGeometryStage* effectStages) { |
| 48 SkFAIL("For geometry processor only"); |
| 49 } |
| 50 |
| 51 virtual void setData(GrGpuGL*, |
| 52 GrGpu::DrawType, |
| 53 const GrGLProgramDataManager&, |
| 54 const GrFragmentStage* effectStages[]) = 0; |
| 55 |
| 56 protected: |
| 57 GrGLProgramEffects(int reserveCount) |
| 58 : fGLProcessors(reserveCount) |
| 59 , fSamplers(reserveCount) { |
| 60 } |
| 61 |
| 62 /** |
| 63 * Helper for setData(). Binds all the textures for an effect. |
| 64 */ |
| 65 void bindTextures(GrGpuGL*, const GrProcessor&, int effectIdx); |
| 66 |
| 67 struct Sampler { |
| 68 SkDEBUGCODE(Sampler() : fTextureUnit(-1) {}) |
| 69 UniformHandle fUniform; |
| 70 int fTextureUnit; |
| 71 }; |
| 72 |
| 73 /* |
| 74 * Helpers for shader builders to build up program effects objects alongside
shader code |
| 75 */ |
| 76 void addEffect(GrGLProcessor* effect) { fGLProcessors.push_back(effect); } |
| 77 SkTArray<Sampler, true>& addSamplers() { return fSamplers.push_back(); } |
| 78 |
| 79 SkTArray<GrGLProcessor*> fGLProcessors; |
| 80 SkTArray<SkSTArray<4, Sampler, true> > fSamplers; |
| 81 |
| 82 private: |
| 83 friend class GrGLProgramBuilder; |
| 84 friend class GrGLFullProgramBuilder; |
| 85 friend class GrGLFragmentOnlyShaderBuilder; |
| 86 |
| 87 typedef SkRefCnt INHERITED; |
| 88 }; |
| 89 |
| 90 //////////////////////////////////////////////////////////////////////////////// |
| 91 |
| 92 /** |
| 93 * This is a GrGLProgramEffects implementation that does coord transforms with t
he vertex shader. |
| 94 */ |
| 95 class GrGLVertexProgramEffects : public GrGLProgramEffects { |
| 96 public: |
| 97 virtual void setData(GrGpuGL*, |
| 98 GrGpu::DrawType, |
| 99 const GrGLProgramDataManager&, |
| 100 const GrGeometryStage* effectStages) SK_OVERRIDE; |
| 101 |
| 102 virtual void setData(GrGpuGL*, |
| 103 GrGpu::DrawType, |
| 104 const GrGLProgramDataManager&, |
| 105 const GrFragmentStage* effectStages[]) SK_OVERRIDE; |
| 106 |
| 107 private: |
| 108 GrGLVertexProgramEffects(int reserveCount, bool explicitLocalCoords) |
| 109 : INHERITED(reserveCount) |
| 110 , fTransforms(reserveCount) |
| 111 , fHasExplicitLocalCoords(explicitLocalCoords) { |
| 112 } |
| 113 |
| 114 struct Transform { |
| 115 Transform() { fCurrentValue = SkMatrix::InvalidMatrix(); } |
| 116 UniformHandle fHandle; |
| 117 SkMatrix fCurrentValue; |
| 118 }; |
| 119 |
| 120 struct PathTransform { |
| 121 PathTransform() { fCurrentValue = SkMatrix::InvalidMatrix(); } |
| 122 VaryingHandle fHandle; |
| 123 SkMatrix fCurrentValue; |
| 124 GrSLType fType; |
| 125 }; |
| 126 |
| 127 /* |
| 128 * These functions are used by the builders to build up program effects alon
g side the shader |
| 129 * code itself |
| 130 */ |
| 131 SkSTArray<2, Transform, true>& addTransforms() { return fTransforms.push_bac
k(); } |
| 132 SkTArray<PathTransform, true>& addPathTransforms() { return fPathTransforms.
push_back(); } |
| 133 |
| 134 /** |
| 135 * Helper for setData(). Sets all the transform matrices for an effect. |
| 136 */ |
| 137 void setDataInternal(GrGpuGL* gpu, |
| 138 GrGpu::DrawType drawType, |
| 139 const GrGLProgramDataManager& programDataManager, |
| 140 const GrProcessorStage& effectStage, |
| 141 int index); |
| 142 void setTransformData(GrGpuGL* gpu, const GrGLProgramDataManager&, const GrP
rocessorStage&, |
| 143 int effectIdx); |
| 144 void setPathTransformData(GrGpuGL* gpu, const GrGLProgramDataManager&, |
| 145 const GrProcessorStage&, int effectIdx); |
| 146 |
| 147 |
| 148 SkTArray<SkSTArray<2, Transform, true> > fTransforms; |
| 149 SkTArray<SkTArray<PathTransform, true> > fPathTransforms; |
| 150 bool fHasExplicitLocalCoords; |
| 151 |
| 152 friend class GrGLFullProgramBuilder; |
| 153 |
| 154 typedef GrGLProgramEffects INHERITED; |
| 155 }; |
| 156 |
| 157 //////////////////////////////////////////////////////////////////////////////// |
| 158 |
| 159 /** |
| 160 * This is a GrGLProgramEffects implementation that does coord transforms with |
| 161 * the the NV_path_rendering PathTexGen functionality. |
| 162 */ |
| 163 class GrGLPathTexGenProgramEffects : public GrGLProgramEffects { |
| 164 public: |
| 165 virtual void setData(GrGpuGL*, |
| 166 GrGpu::DrawType, |
| 167 const GrGLProgramDataManager&, |
| 168 const GrFragmentStage* effectStages[]) SK_OVERRIDE; |
| 169 |
| 170 private: |
| 171 GrGLPathTexGenProgramEffects(int reserveCount) |
| 172 : INHERITED(reserveCount) |
| 173 , fTransforms(reserveCount) { |
| 174 } |
| 175 |
| 176 /** |
| 177 * Helper for setData(). Sets the PathTexGen state for each transform in an
effect. |
| 178 */ |
| 179 void setPathTexGenState(GrGpuGL*, const GrProcessorStage&, int effectIdx); |
| 180 |
| 181 struct Transforms { |
| 182 Transforms(int texCoordIndex) |
| 183 : fTexCoordIndex(texCoordIndex) {} |
| 184 int fTexCoordIndex; |
| 185 }; |
| 186 |
| 187 /* |
| 188 * Helper for fragment only shader builder to build up the program effects a
longside the shader |
| 189 */ |
| 190 void addTransforms(int coordIndex) { |
| 191 fTransforms.push_back(Transforms(coordIndex)); |
| 192 } |
| 193 |
| 194 SkTArray<Transforms> fTransforms; |
| 195 |
| 196 friend class GrGLFragmentOnlyProgramBuilder; |
| 197 |
| 198 typedef GrGLProgramEffects INHERITED; |
| 199 }; |
| 200 |
| 201 #endif |
OLD | NEW |