OLD | NEW |
1 /* | 1 /* |
2 * Copyright 2014 Google Inc. | 2 * Copyright 2014 Google Inc. |
3 * | 3 * |
4 * Use of this source code is governed by a BSD-style license that can be | 4 * Use of this source code is governed by a BSD-style license that can be |
5 * found in the LICENSE file. | 5 * found in the LICENSE file. |
6 */ | 6 */ |
7 | 7 |
8 #include "GrGLFullProgramBuilder.h" | 8 #include "GrGLFullProgramBuilder.h" |
9 #include "../GrGLGeometryProcessor.h" | 9 #include "../GrGLGeometryProcessor.h" |
10 #include "../GrGpuGL.h" | 10 #include "../GrGpuGL.h" |
11 | 11 |
12 GrGLFullProgramBuilder::GrGLFullProgramBuilder(GrGpuGL* gpu, | 12 GrGLFullProgramBuilder::GrGLFullProgramBuilder(GrGpuGL* gpu, |
13 const GrGLProgramDesc& desc) | 13 const GrGLProgramDesc& desc) |
14 : INHERITED(gpu, desc) | 14 : INHERITED(gpu, desc) |
| 15 , fGLGeometryProcessorEmitter(this) |
15 , fGS(this) | 16 , fGS(this) |
16 , fVS(this) { | 17 , fVS(this) { |
17 } | 18 } |
18 | 19 |
19 void | 20 void |
20 GrGLFullProgramBuilder::createAndEmitEffects(const GrEffectStage* geometryProces
sor, | 21 GrGLFullProgramBuilder::createAndEmitEffects(const GrGeometryStage* geometryProc
essor, |
21 const GrEffectStage* colorStages[], | 22 const GrFragmentStage* colorStages[
], |
22 const GrEffectStage* coverageStages
[], | 23 const GrFragmentStage* coverageStag
es[], |
23 GrGLSLExpr4* inputColor, | 24 GrGLSLExpr4* inputColor, |
24 GrGLSLExpr4* inputCoverage) { | 25 GrGLSLExpr4* inputCoverage) { |
25 fVS.emitCodeBeforeEffects(inputColor, inputCoverage); | 26 fVS.emitCodeBeforeEffects(inputColor, inputCoverage); |
26 | 27 |
27 /////////////////////////////////////////////////////////////////////////// | 28 /////////////////////////////////////////////////////////////////////////// |
28 // emit the per-effect code for both color and coverage effects | 29 // emit the per-effect code for both color and coverage effects |
29 | 30 |
30 bool useLocalCoords = this->getVertexShaderBuilder()->hasExplicitLocalCoords
(); | |
31 EffectKeyProvider colorKeyProvider(&this->desc(), EffectKeyProvider::kColor_
EffectType); | 31 EffectKeyProvider colorKeyProvider(&this->desc(), EffectKeyProvider::kColor_
EffectType); |
32 fColorEffects.reset(this->onCreateAndEmitEffects(colorStages, | 32 fColorEffects.reset(this->onCreateAndEmitEffects(colorStages, |
33 this->desc().numColorEffect
s(), | 33 this->desc().numColorEffect
s(), |
34 colorKeyProvider, | 34 colorKeyProvider, |
35 inputColor)); | 35 inputColor)); |
36 | 36 |
37 if (geometryProcessor) { | 37 if (geometryProcessor) { |
| 38 const GrGeometryProcessor& gp = *geometryProcessor->getGeometryProcessor
(); |
| 39 fGLGeometryProcessorEmitter.set(&gp); |
| 40 fEffectEmitter = &fGLGeometryProcessorEmitter; |
| 41 fVS.emitAttributes(gp); |
38 GrGLSLExpr4 gpInputCoverage = *inputCoverage; | 42 GrGLSLExpr4 gpInputCoverage = *inputCoverage; |
39 GrGLSLExpr4 gpOutputCoverage; | 43 GrGLSLExpr4 gpOutputCoverage; |
40 EffectKeyProvider gpKeyProvider(&this->desc(), | 44 EffectKeyProvider gpKeyProvider(&this->desc(), |
41 EffectKeyProvider::kGeometryProcessor_EffectType); | 45 EffectKeyProvider::kGeometryProcessor_EffectType); |
| 46 bool useLocalCoords = this->getVertexShaderBuilder()->hasExplicitLocalCo
ords(); |
42 fProgramEffects.reset(SkNEW_ARGS(GrGLVertexProgramEffects, (1, useLocalC
oords))); | 47 fProgramEffects.reset(SkNEW_ARGS(GrGLVertexProgramEffects, (1, useLocalC
oords))); |
43 this->INHERITED::emitEffect(*geometryProcessor, 0, gpKeyProvider, &gpInp
utCoverage, | 48 this->INHERITED::emitEffect(*geometryProcessor, 0, gpKeyProvider, &gpInp
utCoverage, |
44 &gpOutputCoverage); | 49 &gpOutputCoverage); |
45 fGeometryProcessor.reset(fProgramEffects.detach()); | 50 fGeometryProcessor.reset(fProgramEffects.detach()); |
46 *inputCoverage = gpOutputCoverage; | 51 *inputCoverage = gpOutputCoverage; |
47 } | 52 } |
48 | 53 |
49 EffectKeyProvider coverageKeyProvider(&this->desc(), EffectKeyProvider::kCov
erage_EffectType); | 54 EffectKeyProvider coverageKeyProvider(&this->desc(), EffectKeyProvider::kCov
erage_EffectType); |
50 fCoverageEffects.reset(this->onCreateAndEmitEffects(coverageStages, | 55 fCoverageEffects.reset(this->onCreateAndEmitEffects(coverageStages, |
51 this->desc().numCoverage
Effects(), | 56 this->desc().numCoverage
Effects(), |
(...skipping 27 matching lines...) Expand all Loading... |
79 const char* name, | 84 const char* name, |
80 const char** vsOutName, | 85 const char** vsOutName, |
81 const char** fsInName) { | 86 const char** fsInName) { |
82 addVarying(type, name, vsOutName, fsInName); | 87 addVarying(type, name, vsOutName, fsInName); |
83 SeparableVaryingInfo& varying = fSeparableVaryingInfos.push_back(); | 88 SeparableVaryingInfo& varying = fSeparableVaryingInfos.push_back(); |
84 varying.fVariable = fFS.fInputs.back(); | 89 varying.fVariable = fFS.fInputs.back(); |
85 return VaryingHandle::CreateFromSeparableVaryingIndex(fSeparableVaryingInfos
.count() - 1); | 90 return VaryingHandle::CreateFromSeparableVaryingIndex(fSeparableVaryingInfos
.count() - 1); |
86 } | 91 } |
87 | 92 |
88 GrGLProgramEffects* GrGLFullProgramBuilder::onCreateAndEmitEffects( | 93 GrGLProgramEffects* GrGLFullProgramBuilder::onCreateAndEmitEffects( |
89 const GrEffectStage* effectStages[], | 94 const GrFragmentStage* effectStages[], |
90 int effectCnt, | 95 int effectCnt, |
91 const GrGLProgramDesc::EffectKeyProvider& keyProvider, | 96 const GrGLProgramDesc::EffectKeyProvider& keyProvider, |
92 GrGLSLExpr4* inOutFSColor) { | 97 GrGLSLExpr4* inOutFSColor) { |
93 fProgramEffects.reset(SkNEW_ARGS(GrGLVertexProgramEffects, | 98 fProgramEffects.reset(SkNEW_ARGS(GrGLVertexProgramEffects, |
94 (effectCnt, | 99 (effectCnt, |
95 this->getVertexShaderBuilder()->hasExplicitLoc
alCoords()))); | 100 this->getVertexShaderBuilder()->hasExplicitLoc
alCoords()))); |
96 this->INHERITED::createAndEmitEffects(effectStages, | 101 this->INHERITED::createAndEmitEffects(effectStages, |
97 effectCnt, | 102 effectCnt, |
98 keyProvider, | 103 keyProvider, |
99 inOutFSColor); | 104 inOutFSColor); |
100 return fProgramEffects.detach(); | 105 return fProgramEffects.detach(); |
101 } | 106 } |
102 | 107 |
103 void GrGLFullProgramBuilder::emitEffect(const GrEffectStage& stage, | 108 void GrGLFullProgramBuilder::emitEffect(const GrProcessorStage& stage, |
104 const GrEffectKey& key, | 109 const GrProcessorKey& key, |
105 const char* outColor, | 110 const char* outColor, |
106 const char* inColor, | 111 const char* inColor, |
107 int stageIndex) { | 112 int stageIndex) { |
108 SkASSERT(fProgramEffects.get()); | 113 SkASSERT(fProgramEffects.get()); |
109 const GrEffect& effect = *stage.getEffect(); | 114 const GrProcessor& effect = *stage.getProcessor(); |
110 SkSTArray<2, GrGLEffect::TransformedCoords> coords(effect.numTransforms()); | 115 SkSTArray<2, GrGLProcessor::TransformedCoords> coords(effect.numTransforms()
); |
111 SkSTArray<4, GrGLEffect::TextureSampler> samplers(effect.numTextures()); | 116 SkSTArray<4, GrGLProcessor::TextureSampler> samplers(effect.numTextures()); |
112 | 117 |
113 fVS.emitAttributes(stage); | |
114 this->emitTransforms(stage, &coords); | 118 this->emitTransforms(stage, &coords); |
115 this->emitSamplers(effect, &samplers); | 119 this->emitSamplers(effect, &samplers); |
116 | 120 |
117 GrGLEffect* glEffect = effect.getFactory().createGLInstance(effect); | 121 SkASSERT(fEffectEmitter); |
| 122 GrGLProcessor* glEffect = fEffectEmitter->createGLInstance(); |
118 fProgramEffects->addEffect(glEffect); | 123 fProgramEffects->addEffect(glEffect); |
119 | 124 |
120 // Enclose custom code in a block to avoid namespace conflicts | 125 // Enclose custom code in a block to avoid namespace conflicts |
121 SkString openBrace; | 126 SkString openBrace; |
122 openBrace.printf("{ // Stage %d: %s\n", stageIndex, glEffect->name()); | 127 openBrace.printf("{ // Stage %d: %s\n", stageIndex, glEffect->name()); |
123 fFS.codeAppend(openBrace.c_str()); | 128 fFS.codeAppend(openBrace.c_str()); |
124 fVS.codeAppend(openBrace.c_str()); | 129 fVS.codeAppend(openBrace.c_str()); |
125 | 130 |
126 if (glEffect->isVertexEffect()) { | 131 fEffectEmitter->emit(key, outColor, inColor, coords, samplers); |
127 GrGLGeometryProcessor* vertexEffect = static_cast<GrGLGeometryProcessor*
>(glEffect); | |
128 vertexEffect->emitCode(this, effect, key, outColor, inColor, coords, sam
plers); | |
129 } else { | |
130 glEffect->emitCode(this, effect, key, outColor, inColor, coords, sampler
s); | |
131 } | |
132 | 132 |
133 fVS.codeAppend("\t}\n"); | 133 fVS.codeAppend("\t}\n"); |
134 fFS.codeAppend("\t}\n"); | 134 fFS.codeAppend("\t}\n"); |
135 } | 135 } |
136 | 136 |
137 void GrGLFullProgramBuilder::emitTransforms(const GrEffectStage& effectStage, | 137 void GrGLFullProgramBuilder::emitTransforms(const GrProcessorStage& effectStage, |
138 GrGLEffect::TransformedCoordsArray*
outCoords) { | 138 GrGLProcessor::TransformedCoordsArra
y* outCoords) { |
139 SkTArray<GrGLVertexProgramEffects::Transform, true>& transforms = | 139 SkTArray<GrGLVertexProgramEffects::Transform, true>& transforms = |
140 fProgramEffects->addTransforms(); | 140 fProgramEffects->addTransforms(); |
141 const GrEffect* effect = effectStage.getEffect(); | 141 const GrProcessor* effect = effectStage.getProcessor(); |
142 int numTransforms = effect->numTransforms(); | 142 int numTransforms = effect->numTransforms(); |
143 transforms.push_back_n(numTransforms); | 143 transforms.push_back_n(numTransforms); |
144 | 144 |
145 SkTArray<GrGLVertexProgramEffects::PathTransform, true>* pathTransforms = NU
LL; | 145 SkTArray<GrGLVertexProgramEffects::PathTransform, true>* pathTransforms = NU
LL; |
146 const GrGLCaps* glCaps = this->ctxInfo().caps(); | 146 const GrGLCaps* glCaps = this->ctxInfo().caps(); |
147 if (glCaps->pathRenderingSupport() && | 147 if (glCaps->pathRenderingSupport() && |
148 this->gpu()->glPathRendering()->texturingMode() == | 148 this->gpu()->glPathRendering()->texturingMode() == |
149 GrGLPathRendering::SeparableShaders_TexturingMode) { | 149 GrGLPathRendering::SeparableShaders_TexturingMode) { |
150 pathTransforms = &fProgramEffects->addPathTransforms(); | 150 pathTransforms = &fProgramEffects->addPathTransforms(); |
151 pathTransforms->push_back_n(numTransforms); | 151 pathTransforms->push_back_n(numTransforms); |
(...skipping 40 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
192 fVS.localCoordsAttribute(); | 192 fVS.localCoordsAttribute(); |
193 // varying = matrix * coords (logically) | 193 // varying = matrix * coords (logically) |
194 SkASSERT(kVec2f_GrSLType == varyingType || kVec3f_GrSLType == varyingTyp
e); | 194 SkASSERT(kVec2f_GrSLType == varyingType || kVec3f_GrSLType == varyingTyp
e); |
195 if (kVec2f_GrSLType == varyingType) { | 195 if (kVec2f_GrSLType == varyingType) { |
196 fVS.codeAppendf("%s = (%s * vec3(%s, 1)).xy;", | 196 fVS.codeAppendf("%s = (%s * vec3(%s, 1)).xy;", |
197 vsVaryingName, uniName, coords.c_str()); | 197 vsVaryingName, uniName, coords.c_str()); |
198 } else { | 198 } else { |
199 fVS.codeAppendf("%s = %s * vec3(%s, 1);", | 199 fVS.codeAppendf("%s = %s * vec3(%s, 1);", |
200 vsVaryingName, uniName, coords.c_str()); | 200 vsVaryingName, uniName, coords.c_str()); |
201 } | 201 } |
202 SkNEW_APPEND_TO_TARRAY(outCoords, GrGLEffect::TransformedCoords, | 202 SkNEW_APPEND_TO_TARRAY(outCoords, GrGLProcessor::TransformedCoords, |
203 (SkString(fsVaryingName), varyingType)); | 203 (SkString(fsVaryingName), varyingType)); |
204 } | 204 } |
205 } | 205 } |
206 | 206 |
207 bool GrGLFullProgramBuilder::compileAndAttachShaders(GrGLuint programId, | 207 bool GrGLFullProgramBuilder::compileAndAttachShaders(GrGLuint programId, |
208 SkTDArray<GrGLuint>* shader
Ids) const { | 208 SkTDArray<GrGLuint>* shader
Ids) const { |
209 return INHERITED::compileAndAttachShaders(programId, shaderIds) | 209 return INHERITED::compileAndAttachShaders(programId, shaderIds) |
210 && fVS.compileAndAttachShaders(programId, shaderIds) | 210 && fVS.compileAndAttachShaders(programId, shaderIds) |
211 #if GR_GL_EXPERIMENTAL_GS | 211 #if GR_GL_EXPERIMENTAL_GS |
212 && (!desc().getHeader().fExperimentalGS | 212 && (!desc().getHeader().fExperimentalGS |
213 || fGS.compileAndAttachShaders(programId, shaderIds)) | 213 || fGS.compileAndAttachShaders(programId, shaderIds)) |
214 #endif | 214 #endif |
215 ; | 215 ; |
216 } | 216 } |
217 | 217 |
218 void GrGLFullProgramBuilder::bindProgramLocations(GrGLuint programId) { | 218 void GrGLFullProgramBuilder::bindProgramLocations(GrGLuint programId) { |
219 fVS.bindProgramLocations(programId); | 219 fVS.bindProgramLocations(programId); |
220 INHERITED::bindProgramLocations(programId); | 220 INHERITED::bindProgramLocations(programId); |
221 } | 221 } |
OLD | NEW |