OLD | NEW |
1 /* | 1 /* |
2 * Copyright 2013 Google Inc. | 2 * Copyright 2013 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 "GrGLEffectArray.h" | 8 #include "GrGLEffectArray.h" |
9 #include "GrDrawEffect.h" | 9 #include "GrDrawEffect.h" |
10 #include "gl/GrGLEffect.h" | 10 #include "gl/GrGLEffect.h" |
(...skipping 132 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
143 SkTArray<Sampler, true>& samplers = fSamplers[e]; | 143 SkTArray<Sampler, true>& samplers = fSamplers[e]; |
144 int numSamplers = samplers.count(); | 144 int numSamplers = samplers.count(); |
145 for (int s = 0; s < numSamplers; ++s) { | 145 for (int s = 0; s < numSamplers; ++s) { |
146 SkASSERT(samplers[s].fUniform.isValid()); | 146 SkASSERT(samplers[s].fUniform.isValid()); |
147 uniformManager.setSampler(samplers[s].fUniform, *texUnitIdx); | 147 uniformManager.setSampler(samplers[s].fUniform, *texUnitIdx); |
148 samplers[s].fTextureUnit = (*texUnitIdx)++; | 148 samplers[s].fTextureUnit = (*texUnitIdx)++; |
149 } | 149 } |
150 } | 150 } |
151 } | 151 } |
152 | 152 |
153 void GrGLEffectArray::setData(GrGpuGL* gpu, | 153 void GrGLVertexEffectArray::setData(GrGpuGL* gpu, |
154 const GrGLUniformManager& uniformManager, | 154 const GrGLUniformManager& uniformManager, |
155 const GrEffectStage* effectStages[]) { | 155 const GrEffectStage* effectStages[]) { |
156 int numEffects = fGLEffects.count(); | 156 int numEffects = fGLEffects.count(); |
157 SkASSERT(numEffects == fTransforms.count()); | 157 SkASSERT(numEffects == fTransforms.count()); |
158 SkASSERT(numEffects == fSamplers.count()); | 158 SkASSERT(numEffects == fSamplers.count()); |
159 for (int e = 0; e < numEffects; ++e) { | 159 for (int e = 0; e < numEffects; ++e) { |
160 GrDrawEffect drawEffect(*effectStages[e], fHasExplicitLocalCoords); | 160 GrDrawEffect drawEffect(*effectStages[e], fHasExplicitLocalCoords); |
161 fGLEffects[e]->setData(uniformManager, drawEffect); | 161 fGLEffects[e]->setData(uniformManager, drawEffect); |
162 this->setTransformData(uniformManager, drawEffect, e); | 162 this->setTransformData(uniformManager, drawEffect, e); |
163 this->bindTextures(gpu, *drawEffect.effect(), e); | 163 this->bindTextures(gpu, *drawEffect.effect(), e); |
164 } | 164 } |
165 } | 165 } |
166 | 166 |
167 void GrGLEffectArray::setTransformData(const GrGLUniformManager& uniformManager, | 167 void GrGLVertexEffectArray::setTransformData(const GrGLUniformManager& uniformMa
nager, |
168 const GrDrawEffect& drawEffect, | 168 const GrDrawEffect& drawEffect, |
169 int effectIdx) { | 169 int effectIdx) { |
170 SkTArray<Transform, true>& transforms = fTransforms[effectIdx]; | 170 SkTArray<Transform, true>& transforms = fTransforms[effectIdx]; |
171 int numTransforms = transforms.count(); | 171 int numTransforms = transforms.count(); |
172 SkASSERT(numTransforms == (*drawEffect.effect())->numTransforms()); | 172 SkASSERT(numTransforms == (*drawEffect.effect())->numTransforms()); |
173 for (int t = 0; t < numTransforms; ++t) { | 173 for (int t = 0; t < numTransforms; ++t) { |
174 const GrCoordTransform& coordTransform = (*drawEffect.effect())->coordTr
ansform(t); | 174 const GrCoordTransform& coordTransform = (*drawEffect.effect())->coordTr
ansform(t); |
175 const SkMatrix& matrix = coordTransform.getMatrix(); | 175 const SkMatrix& matrix = coordTransform.getMatrix(); |
176 const SkMatrix& coordChangeMatrix = kLocal_GrCoordSet == coordTransform.
sourceCoords() ? | 176 const SkMatrix& coordChangeMatrix = kLocal_GrCoordSet == coordTransform.
sourceCoords() ? |
177 drawEffect.getCoordChangeMatrix(
) : | 177 drawEffect.getCoordChangeMatrix(
) : |
178 SkMatrix::I(); | 178 SkMatrix::I(); |
179 SkASSERT(transforms[t].fHandle.isValid() != (kVoid_GrSLType == transform
s[t].fType)); | 179 SkASSERT(transforms[t].fHandle.isValid() != (kVoid_GrSLType == transform
s[t].fType)); |
(...skipping 49 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
229 SkASSERT(samplers[s].fTextureUnit >= 0); | 229 SkASSERT(samplers[s].fTextureUnit >= 0); |
230 const GrTextureAccess& textureAccess = effect->textureAccess(s); | 230 const GrTextureAccess& textureAccess = effect->textureAccess(s); |
231 gpu->bindTexture(samplers[s].fTextureUnit, | 231 gpu->bindTexture(samplers[s].fTextureUnit, |
232 textureAccess.getParams(), | 232 textureAccess.getParams(), |
233 static_cast<GrGLTexture*>(textureAccess.getTexture())); | 233 static_cast<GrGLTexture*>(textureAccess.getTexture())); |
234 } | 234 } |
235 } | 235 } |
236 | 236 |
237 //////////////////////////////////////////////////////////////////////////////// | 237 //////////////////////////////////////////////////////////////////////////////// |
238 | 238 |
239 GrGLEffectArrayBuilder::GrGLEffectArrayBuilder(GrGLShaderBuilder* builder, int r
eserveCount) | 239 GrGLVertexEffectArrayBuilder::GrGLVertexEffectArrayBuilder(GrGLFullShaderBuilder
* builder, |
240 : fBuilder(builder) { | 240 int reserveCount) |
241 GrGLShaderBuilder::VertexBuilder* vertexBuilder = fBuilder->getVertexBuilder
(); | 241 : fBuilder(builder) |
242 SkASSERT(NULL != vertexBuilder); | 242 , fEffectArray(SkNEW_ARGS(GrGLVertexEffectArray, |
243 fEffectArray.reset(SkNEW_ARGS(GrGLEffectArray, | 243 (reserveCount, fBuilder->hasExplicitLocalCoords())
)) { |
244 (reserveCount, vertexBuilder->hasExplicitLocal
Coords()))); | |
245 } | 244 } |
246 | 245 |
247 void GrGLEffectArrayBuilder::emitEffect(const GrEffectStage& stage, | 246 void GrGLVertexEffectArrayBuilder::emitEffect(const GrEffectStage& stage, |
248 EffectKey key, | 247 EffectKey key, |
249 const char* outColor, | 248 const char* outColor, |
250 const char* inColor, | 249 const char* inColor, |
251 int stageIndex) { | 250 int stageIndex) { |
252 GrGLShaderBuilder::VertexBuilder* vertexBuilder = fBuilder->getVertexBuilder
(); | |
253 SkASSERT(NULL != vertexBuilder); | |
254 SkASSERT(NULL != fEffectArray.get()); | 251 SkASSERT(NULL != fEffectArray.get()); |
255 | 252 |
256 GrDrawEffect drawEffect(stage, fEffectArray->fHasExplicitLocalCoords); | 253 GrDrawEffect drawEffect(stage, fEffectArray->fHasExplicitLocalCoords); |
257 const GrEffectRef& effect = *stage.getEffect(); | 254 const GrEffectRef& effect = *stage.getEffect(); |
258 SkSTArray<2, TransformedCoords> coords(effect->numTransforms()); | 255 SkSTArray<2, TransformedCoords> coords(effect->numTransforms()); |
259 SkSTArray<4, TextureSampler> samplers(effect->numTextures()); | 256 SkSTArray<4, TextureSampler> samplers(effect->numTextures()); |
260 | 257 |
261 this->emitAttributes(stage); | 258 this->emitAttributes(stage); |
262 this->emitTransforms(effect, key, &coords); | 259 this->emitTransforms(effect, key, &coords); |
263 this->emitSamplers(effect, &samplers); | 260 INHERITED::emitSamplers(fBuilder, fEffectArray.get(), effect, &samplers); |
264 | 261 |
265 GrGLEffect* glEffect = effect->getFactory().createGLInstance(drawEffect); | 262 GrGLEffect* glEffect = effect->getFactory().createGLInstance(drawEffect); |
266 *fEffectArray->fGLEffects.append() = glEffect; | 263 *fEffectArray->fGLEffects.append() = glEffect; |
267 | 264 |
268 // Enclose custom code in a block to avoid namespace conflicts | 265 // Enclose custom code in a block to avoid namespace conflicts |
269 SkString openBrace; | 266 SkString openBrace; |
270 openBrace.printf("\t{ // Stage %d: %s\n", stageIndex, glEffect->name()); | 267 openBrace.printf("\t{ // Stage %d: %s\n", stageIndex, glEffect->name()); |
271 vertexBuilder->vsCodeAppend(openBrace.c_str()); | 268 fBuilder->vsCodeAppend(openBrace.c_str()); |
272 fBuilder->fsCodeAppend(openBrace.c_str()); | 269 fBuilder->fsCodeAppend(openBrace.c_str()); |
273 | 270 |
274 glEffect->emitCode(fBuilder, drawEffect, key, outColor, inColor, coords, sam
plers); | 271 glEffect->emitCode(fBuilder, drawEffect, key, outColor, inColor, coords, sam
plers); |
275 | 272 |
276 vertexBuilder->vsCodeAppend("\t}\n"); | 273 fBuilder->vsCodeAppend("\t}\n"); |
277 fBuilder->fsCodeAppend("\t}\n"); | 274 fBuilder->fsCodeAppend("\t}\n"); |
278 } | 275 } |
279 | 276 |
280 void GrGLEffectArrayBuilder::emitAttributes(const GrEffectStage& stage) { | 277 void GrGLVertexEffectArrayBuilder::emitAttributes(const GrEffectStage& stage) { |
281 GrGLShaderBuilder::VertexBuilder* vertexBuilder = fBuilder->getVertexBuilder
(); | |
282 SkASSERT(NULL != vertexBuilder); | |
283 | |
284 int numAttributes = stage.getVertexAttribIndexCount(); | 278 int numAttributes = stage.getVertexAttribIndexCount(); |
285 const int* attributeIndices = stage.getVertexAttribIndices(); | 279 const int* attributeIndices = stage.getVertexAttribIndices(); |
286 for (int a = 0; a < numAttributes; ++a) { | 280 for (int a = 0; a < numAttributes; ++a) { |
287 // TODO: Make addAttribute mangle the name. | 281 // TODO: Make addAttribute mangle the name. |
288 SkString attributeName("aAttr"); | 282 SkString attributeName("aAttr"); |
289 attributeName.appendS32(attributeIndices[a]); | 283 attributeName.appendS32(attributeIndices[a]); |
290 vertexBuilder->addEffectAttribute(attributeIndices[a], | 284 fBuilder->addEffectAttribute(attributeIndices[a], |
291 (*stage.getEffect())->vertexAttribType
(a), | 285 (*stage.getEffect())->vertexAttribType(a), |
292 attributeName); | 286 attributeName); |
293 } | 287 } |
294 } | 288 } |
295 | 289 |
296 void GrGLEffectArrayBuilder::emitTransforms(const GrEffectRef& effect, | 290 void GrGLVertexEffectArrayBuilder::emitTransforms(const GrEffectRef& effect, |
297 EffectKey effectKey, | 291 EffectKey effectKey, |
298 TransformedCoordsArray* outCoords) { | 292 TransformedCoordsArray* outCoo
rds) { |
299 GrGLShaderBuilder::VertexBuilder* vertexBuilder = fBuilder->getVertexBuilder
(); | 293 typedef GrGLVertexEffectArray::Transform Transform; |
300 SkASSERT(NULL != vertexBuilder); | |
301 | |
302 typedef GrGLEffectArray::Transform Transform; | |
303 SkTArray<Transform, true>& transforms = fEffectArray->fTransforms.push_back(
); | 294 SkTArray<Transform, true>& transforms = fEffectArray->fTransforms.push_back(
); |
304 EffectKey totalKey = GrBackendEffectFactory::GetTransformKey(effectKey); | 295 EffectKey totalKey = GrBackendEffectFactory::GetTransformKey(effectKey); |
305 int numTransforms = effect->numTransforms(); | 296 int numTransforms = effect->numTransforms(); |
306 transforms.push_back_n(numTransforms); | 297 transforms.push_back_n(numTransforms); |
307 for (int t = 0; t < numTransforms; t++) { | 298 for (int t = 0; t < numTransforms; t++) { |
308 EffectKey key = (totalKey >> (kTransformKeyBits * t)) & kTransformKeyMas
k; | 299 EffectKey key = (totalKey >> (kTransformKeyBits * t)) & kTransformKeyMas
k; |
309 GrSLType varyingType = kVoid_GrSLType; | 300 GrSLType varyingType = kVoid_GrSLType; |
310 const char* uniName; | 301 const char* uniName; |
311 switch (key & kMatrixTypeKeyMask) { | 302 switch (key & kMatrixTypeKeyMask) { |
312 case kIdentity_MatrixType: | 303 case kIdentity_MatrixType: |
(...skipping 34 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
347 | 338 |
348 const char* varyingName = "MatrixCoord"; | 339 const char* varyingName = "MatrixCoord"; |
349 SkString suffixedVaryingName; | 340 SkString suffixedVaryingName; |
350 if (0 != t) { | 341 if (0 != t) { |
351 suffixedVaryingName.append(varyingName); | 342 suffixedVaryingName.append(varyingName); |
352 suffixedVaryingName.appendf("_%i", t); | 343 suffixedVaryingName.appendf("_%i", t); |
353 varyingName = suffixedVaryingName.c_str(); | 344 varyingName = suffixedVaryingName.c_str(); |
354 } | 345 } |
355 const char* vsVaryingName; | 346 const char* vsVaryingName; |
356 const char* fsVaryingName; | 347 const char* fsVaryingName; |
357 vertexBuilder->addVarying(varyingType, varyingName, &vsVaryingName, &fsV
aryingName); | 348 fBuilder->addVarying(varyingType, varyingName, &vsVaryingName, &fsVaryin
gName); |
358 | 349 |
359 const GrGLShaderVar& coords = (kPositionCoords_Flag & key) ? | 350 const GrGLShaderVar& coords = (kPositionCoords_Flag & key) ? |
360 vertexBuilder->positionAttribute() : | 351 fBuilder->positionAttribute() : |
361 vertexBuilder->localCoordsAttribute(); | 352 fBuilder->localCoordsAttribute(); |
362 // varying = matrix * coords (logically) | 353 // varying = matrix * coords (logically) |
363 switch (transforms[t].fType) { | 354 switch (transforms[t].fType) { |
364 case kVoid_GrSLType: | 355 case kVoid_GrSLType: |
365 SkASSERT(kVec2f_GrSLType == varyingType); | 356 SkASSERT(kVec2f_GrSLType == varyingType); |
366 vertexBuilder->vsCodeAppendf("\t%s = %s;\n", vsVaryingName, coor
ds.c_str()); | 357 fBuilder->vsCodeAppendf("\t%s = %s;\n", vsVaryingName, coords.c_
str()); |
367 break; | 358 break; |
368 case kVec2f_GrSLType: | 359 case kVec2f_GrSLType: |
369 SkASSERT(kVec2f_GrSLType == varyingType); | 360 SkASSERT(kVec2f_GrSLType == varyingType); |
370 vertexBuilder->vsCodeAppendf("\t%s = %s + %s;\n", | 361 fBuilder->vsCodeAppendf("\t%s = %s + %s;\n", |
371 vsVaryingName, uniName, coords.c_st
r()); | 362 vsVaryingName, uniName, coords.c_str()); |
372 break; | 363 break; |
373 case kMat33f_GrSLType: { | 364 case kMat33f_GrSLType: { |
374 SkASSERT(kVec2f_GrSLType == varyingType || kVec3f_GrSLType == va
ryingType); | 365 SkASSERT(kVec2f_GrSLType == varyingType || kVec3f_GrSLType == va
ryingType); |
375 if (kVec2f_GrSLType == varyingType) { | 366 if (kVec2f_GrSLType == varyingType) { |
376 vertexBuilder->vsCodeAppendf("\t%s = (%s * vec3(%s, 1)).xy;\
n", | 367 fBuilder->vsCodeAppendf("\t%s = (%s * vec3(%s, 1)).xy;\n", |
377 vsVaryingName, uniName, coords.
c_str()); | 368 vsVaryingName, uniName, coords.c_str
()); |
378 } else { | 369 } else { |
379 vertexBuilder->vsCodeAppendf("\t%s = %s * vec3(%s, 1);\n", | 370 fBuilder->vsCodeAppendf("\t%s = %s * vec3(%s, 1);\n", |
380 vsVaryingName, uniName, coords.
c_str()); | 371 vsVaryingName, uniName, coords.c_str
()); |
381 } | 372 } |
382 break; | 373 break; |
383 } | 374 } |
384 default: | 375 default: |
385 GrCrash("Unexpected uniform type."); | 376 GrCrash("Unexpected uniform type."); |
386 } | 377 } |
387 SkNEW_APPEND_TO_TARRAY(outCoords, TransformedCoords, | 378 SkNEW_APPEND_TO_TARRAY(outCoords, TransformedCoords, |
388 (fsVaryingName, varyingType, vsVaryingName)); | 379 (fsVaryingName, varyingType, vsVaryingName)); |
389 } | 380 } |
390 } | 381 } |
391 | 382 |
392 void GrGLEffectArrayBuilder::emitSamplers(const GrEffectRef& effect, | 383 void GrGLEffectArrayBuilder::emitSamplers(GrGLShaderBuilder* builder, |
| 384 GrGLEffectArray* effectArray, |
| 385 const GrEffectRef& effect, |
393 TextureSamplerArray* outSamplers) { | 386 TextureSamplerArray* outSamplers) { |
394 typedef GrGLEffectArray::Sampler Sampler; | 387 typedef GrGLEffectArray::Sampler Sampler; |
395 SkTArray<Sampler, true>& samplers = fEffectArray->fSamplers.push_back(); | 388 SkTArray<Sampler, true>& samplers = effectArray->fSamplers.push_back(); |
396 int numTextures = effect->numTextures(); | 389 int numTextures = effect->numTextures(); |
397 samplers.push_back_n(numTextures); | 390 samplers.push_back_n(numTextures); |
398 SkString name; | 391 SkString name; |
399 for (int t = 0; t < numTextures; ++t) { | 392 for (int t = 0; t < numTextures; ++t) { |
400 name.printf("Sampler%d", t); | 393 name.printf("Sampler%d", t); |
401 samplers[t].fUniform = fBuilder->addUniform(GrGLShaderBuilder::kFragment
_Visibility, | 394 samplers[t].fUniform = builder->addUniform(GrGLShaderBuilder::kFragment_
Visibility, |
402 kSampler2D_GrSLType, | 395 kSampler2D_GrSLType, |
403 name.c_str()); | 396 name.c_str()); |
404 SkNEW_APPEND_TO_TARRAY(outSamplers, TextureSampler, | 397 SkNEW_APPEND_TO_TARRAY(outSamplers, TextureSampler, |
405 (samplers[t].fUniform, effect->textureAccess(t)))
; | 398 (samplers[t].fUniform, effect->textureAccess(t)))
; |
406 } | 399 } |
407 } | 400 } |
OLD | NEW |