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 #include "GrGLProgramEffects.h" 9 #include "GrDrawEffect.h" 10 #include "gl/GrGLEffect.h" 11 #include "gl/GrGLShaderBuilder.h" 12 #include "gl/GrGLVertexEffect.h" 13 #include "gl/GrGpuGL.h" 14 15 typedef GrGLProgramEffects::EffectKey EffectKey; 16 typedef GrGLProgramEffects::TransformedCoords TransformedCoords; 17 typedef GrGLProgramEffects::TransformedCoordsArray TransformedCoordsArray; 18 typedef GrGLProgramEffects::TextureSampler TextureSampler; 19 typedef GrGLProgramEffects::TextureSamplerArray TextureSamplerArray; 20 21 /** 22 * We specialize the vertex code for each of these matrix types. 23 */ 24 enum MatrixType { 25 kIdentity_MatrixType = 0, 26 kTrans_MatrixType = 1, 27 kNoPersp_MatrixType = 2, 28 kGeneral_MatrixType = 3, 29 }; 30 31 /** 32 * The key for an individual coord transform is made up of a matrix type and a bit that 33 * indicates the source of the input coords. 34 */ 35 enum { 36 kMatrixTypeKeyBits = 2, 37 kMatrixTypeKeyMask = (1 << kMatrixTypeKeyBits) - 1, 38 kPositionCoords_Flag = (1 << kMatrixTypeKeyBits), 39 kTransformKeyBits = kMatrixTypeKeyBits + 1, 40 }; 41 42 namespace { 43 44 /** 45 * Do we need to either map r,g,b->a or a->r. configComponentMask indicates which channels are 46 * present in the texture's config. swizzleComponentMask indicates the channels present in the 47 * shader swizzle. 48 */ 49 inline bool swizzle_requires_alpha_remapping(const GrGLCaps& caps, 50 uint32_t configComponentMask, 51 uint32_t swizzleComponentMask) { 52 if (caps.textureSwizzleSupport()) { 53 // Any remapping is handled using texture swizzling not shader modifications. 54 return false; 55 } 56 // check if the texture is alpha-only 57 if (kA_GrColorComponentFlag == configComponentMask) { 58 if (caps.textureRedSupport() && (kA_GrColorComponentFlag & swizzleComponentMask)) { 59 // we must map the swizzle 'a's to 'r'. 60 return true; 61 } 62 if (kRGB_GrColorComponentFlags & swizzleComponentMask) { 63 // The 'r', 'g', and/or 'b's must be mapped to 'a' according to our semantics that 64 // alpha-only textures smear alpha across all four channels when read. 65 return true; 66 } 67 } 68 return false; 69 } 70 71 /** 72 * Retrieves the matrix type from transformKey for the transform at transformIdx. 73 */ 74 MatrixType get_matrix_type(EffectKey transformKey, int transformIdx) { 75 return static_cast<MatrixType>( 76 (transformKey >> (kTransformKeyBits * transformIdx)) & kMatrixTypeKeyMask); 77 } 78 79 /** 80 * Retrieves the source coords from transformKey for the transform at transformIdx. It may not be 81 * the same coordinate set as the original GrCoordTransform if the position and local coords are 82 * identical for this program. 83 */ 84 GrCoordSet get_source_coords(EffectKey transformKey, int transformIdx) { 85 return (transformKey >> (kTransformKeyBits * transformIdx)) & kPositionCoords_Flag ? 86 kPosition_GrCoordSet : 87 kLocal_GrCoordSet; 88 } 89 90 /** 91 * Retrieves the final translation that a transform needs to apply to its source coords (and 92 * verifies that a translation is all it needs). 93 */ 94 void get_transform_translation(const GrDrawEffect& drawEffect, 95 int transformIdx, 96 GrGLfloat* tx, 97 GrGLfloat* ty) { 98 const GrCoordTransform& coordTransform = (*drawEffect.effect())->coordTransform(transformIdx); 99 SkASSERT(!coordTransform.reverseY()); 100 const SkMatrix& matrix = coordTransform.getMatrix(); 101 if (kLocal_GrCoordSet == coordTransform.sourceCoords() && 102 !drawEffect.programHasExplicitLocalCoords()) { 103 const SkMatrix& coordChangeMatrix = drawEffect.getCoordChangeMatrix(); 104 SkASSERT(SkMatrix::kTranslate_Mask == (matrix.getType() | coordChangeMatrix.getType())); 105 *tx = SkScalarToFloat(matrix[SkMatrix::kMTransX] + coordChangeMatrix[SkMatrix::kMTransX]); 106 *ty = SkScalarToFloat(matrix[SkMatrix::kMTransY] + coordChangeMatrix[SkMatrix::kMTransY]); 107 } else { 108 SkASSERT(SkMatrix::kTranslate_Mask == matrix.getType()); 109 *tx = SkScalarToFloat(matrix[SkMatrix::kMTransX]); 110 *ty = SkScalarToFloat(matrix[SkMatrix::kMTransY]); 111 } 112 } 113 114 /** 115 * Retrieves the final matrix that a transform needs to apply to its source coords. 116 */ 117 SkMatrix get_transform_matrix(const GrDrawEffect& drawEffect, int transformIdx) { 118 const GrCoordTransform& coordTransform = (*drawEffect.effect())->coordTransform(transformIdx); 119 SkMatrix combined; 120 if (kLocal_GrCoordSet == coordTransform.sourceCoords() && 121 !drawEffect.programHasExplicitLocalCoords()) { 122 combined.setConcat(coordTransform.getMatrix(), drawEffect.getCoordChangeMatrix()); 123 } else { 124 combined = coordTransform.getMatrix(); 125 } 126 if (coordTransform.reverseY()) { 127 // combined.postScale(1,-1); 128 // combined.postTranslate(0,1); 129 combined.set(SkMatrix::kMSkewY, 130 combined[SkMatrix::kMPersp0] - combined[SkMatrix::kMSkewY]); 131 combined.set(SkMatrix::kMScaleY, 132 combined[SkMatrix::kMPersp1] - combined[SkMatrix::kMScaleY]); 133 combined.set(SkMatrix::kMTransY, 134 combined[SkMatrix::kMPersp2] - combined[SkMatrix::kMTransY]); 135 } 136 return combined; 137 } 138 139 } 140 141 //////////////////////////////////////////////////////////////////////////////// 142 143 EffectKey GrGLProgramEffects::GenAttribKey(const GrDrawEffect& drawEffect) { 144 EffectKey key = 0; 145 int numAttributes = drawEffect.getVertexAttribIndexCount(); 146 SkASSERT(numAttributes <= 2); 147 const int* attributeIndices = drawEffect.getVertexAttribIndices(); 148 for (int a = 0; a < numAttributes; ++a) { 149 EffectKey value = attributeIndices[a] << 3 * a; 150 SkASSERT(0 == (value & key)); // keys for each attribute ought not to overlap 151 key |= value; 152 } 153 return key; 154 } 155 156 EffectKey GrGLProgramEffects::GenTransformKey(const GrDrawEffect& drawEffect) { 157 EffectKey totalKey = 0; 158 int numTransforms = (*drawEffect.effect())->numTransforms(); 159 for (int t = 0; t < numTransforms; ++t) { 160 EffectKey key = 0; 161 const GrCoordTransform& coordTransform = (*drawEffect.effect())->coordTransform(t); 162 SkMatrix::TypeMask type0 = coordTransform.getMatrix().getType(); 163 SkMatrix::TypeMask type1; 164 if (kLocal_GrCoordSet == coordTransform.sourceCoords()) { 165 type1 = drawEffect.getCoordChangeMatrix().getType(); 166 } else { 167 if (drawEffect.programHasExplicitLocalCoords()) { 168 // We only make the key indicate that device coords are referenced when the local coords 169 // are not actually determined by positions. Otherwise the local coords var and position 170 // var are identical. 171 key |= kPositionCoords_Flag; 172 } 173 type1 = SkMatrix::kIdentity_Mask; 174 } 175 176 int combinedTypes = type0 | type1; 177 178 bool reverseY = coordTransform.reverseY(); 179 180 if (SkMatrix::kPerspective_Mask & combinedTypes) { 181 key |= kGeneral_MatrixType; 182 } else if (((SkMatrix::kAffine_Mask | SkMatrix::kScale_Mask) & combinedTypes) || reverseY) { 183 key |= kNoPersp_MatrixType; 184 } else if (SkMatrix::kTranslate_Mask & combinedTypes) { 185 key |= kTrans_MatrixType; 186 } else { 187 key |= kIdentity_MatrixType; 188 } 189 key <<= kTransformKeyBits * t; 190 SkASSERT(0 == (totalKey & key)); // keys for each transform ought not to overlap 191 totalKey |= key; 192 } 193 return totalKey; 194 } 195 196 EffectKey GrGLProgramEffects::GenTextureKey(const GrDrawEffect& drawEffect, const GrGLCaps& caps) { 197 EffectKey key = 0; 198 int numTextures = (*drawEffect.effect())->numTextures(); 199 for (int t = 0; t < numTextures; ++t) { 200 const GrTextureAccess& access = (*drawEffect.effect())->textureAccess(t); 201 uint32_t configComponentMask = GrPixelConfigComponentMask(access.getTexture()->config()); 202 if (swizzle_requires_alpha_remapping(caps, configComponentMask, access.swizzleMask())) { 203 key |= 1 << t; 204 } 205 } 206 return key; 207 } 208 209 GrGLProgramEffects::~GrGLProgramEffects() { 210 int numEffects = fGLEffects.count(); 211 for (int e = 0; e < numEffects; ++e) { 212 SkDELETE(fGLEffects[e]); 213 } 214 } 215 216 void GrGLProgramEffects::emitSamplers(GrGLShaderBuilder* builder, 217 const GrEffectRef& effect, 218 TextureSamplerArray* outSamplers) { 219 SkTArray<Sampler, true>& samplers = fSamplers.push_back(); 220 int numTextures = effect->numTextures(); 221 samplers.push_back_n(numTextures); 222 SkString name; 223 for (int t = 0; t < numTextures; ++t) { 224 name.printf("Sampler%d", t); 225 samplers[t].fUniform = builder->addUniform(GrGLShaderBuilder::kFragment_Visibility, 226 kSampler2D_GrSLType, 227 name.c_str()); 228 SkNEW_APPEND_TO_TARRAY(outSamplers, TextureSampler, 229 (samplers[t].fUniform, effect->textureAccess(t))); 230 } 231 } 232 233 void GrGLProgramEffects::initSamplers(const GrGLUniformManager& uniformManager, int* texUnitIdx) { 234 int numEffects = fGLEffects.count(); 235 SkASSERT(numEffects == fSamplers.count()); 236 for (int e = 0; e < numEffects; ++e) { 237 SkTArray<Sampler, true>& samplers = fSamplers[e]; 238 int numSamplers = samplers.count(); 239 for (int s = 0; s < numSamplers; ++s) { 240 SkASSERT(samplers[s].fUniform.isValid()); 241 uniformManager.setSampler(samplers[s].fUniform, *texUnitIdx); 242 samplers[s].fTextureUnit = (*texUnitIdx)++; 243 } 244 } 245 } 246 247 void GrGLProgramEffects::bindTextures(GrGpuGL* gpu, const GrEffectRef& effect, int effectIdx) { 248 const SkTArray<Sampler, true>& samplers = fSamplers[effectIdx]; 249 int numSamplers = samplers.count(); 250 SkASSERT(numSamplers == effect->numTextures()); 251 for (int s = 0; s < numSamplers; ++s) { 252 SkASSERT(samplers[s].fTextureUnit >= 0); 253 const GrTextureAccess& textureAccess = effect->textureAccess(s); 254 gpu->bindTexture(samplers[s].fTextureUnit, 255 textureAccess.getParams(), 256 static_cast<GrGLTexture*>(textureAccess.getTexture())); 257 } 258 } 259 260 //////////////////////////////////////////////////////////////////////////////// 261 262 void GrGLVertexProgramEffects::emitEffect(GrGLFullShaderBuilder* builder, 263 const GrEffectStage& stage, 264 EffectKey key, 265 const char* outColor, 266 const char* inColor, 267 int stageIndex) { 268 GrDrawEffect drawEffect(stage, fHasExplicitLocalCoords); 269 const GrEffectRef& effect = *stage.getEffect(); 270 SkSTArray<2, TransformedCoords> coords(effect->numTransforms()); 271 SkSTArray<4, TextureSampler> samplers(effect->numTextures()); 272 273 this->emitAttributes(builder, stage); 274 this->emitTransforms(builder, effect, key, &coords); 275 this->emitSamplers(builder, effect, &samplers); 276 277 GrGLEffect* glEffect = effect->getFactory().createGLInstance(drawEffect); 278 fGLEffects.push_back(glEffect); 279 280 // Enclose custom code in a block to avoid namespace conflicts 281 SkString openBrace; 282 openBrace.printf("\t{ // Stage %d: %s\n", stageIndex, glEffect->name()); 283 builder->vsCodeAppend(openBrace.c_str()); 284 builder->fsCodeAppend(openBrace.c_str()); 285 286 if (glEffect->isVertexEffect()) { 287 GrGLVertexEffect* vertexEffect = static_cast<GrGLVertexEffect*>(glEffect); 288 vertexEffect->emitCode(builder, drawEffect, key, outColor, inColor, coords, samplers); 289 } else { 290 glEffect->emitCode(builder, drawEffect, key, outColor, inColor, coords, samplers); 291 } 292 293 builder->vsCodeAppend("\t}\n"); 294 builder->fsCodeAppend("\t}\n"); 295 } 296 297 void GrGLVertexProgramEffects::emitAttributes(GrGLFullShaderBuilder* builder, 298 const GrEffectStage& stage) { 299 int numAttributes = stage.getVertexAttribIndexCount(); 300 const int* attributeIndices = stage.getVertexAttribIndices(); 301 for (int a = 0; a < numAttributes; ++a) { 302 // TODO: Make addAttribute mangle the name. 303 SkString attributeName("aAttr"); 304 attributeName.appendS32(attributeIndices[a]); 305 builder->addEffectAttribute(attributeIndices[a], 306 (*stage.getEffect())->vertexAttribType(a), 307 attributeName); 308 } 309 } 310 311 void GrGLVertexProgramEffects::emitTransforms(GrGLFullShaderBuilder* builder, 312 const GrEffectRef& effect, 313 EffectKey effectKey, 314 TransformedCoordsArray* outCoords) { 315 SkTArray<Transform, true>& transforms = fTransforms.push_back(); 316 EffectKey totalKey = GrBackendEffectFactory::GetTransformKey(effectKey); 317 int numTransforms = effect->numTransforms(); 318 transforms.push_back_n(numTransforms); 319 for (int t = 0; t < numTransforms; t++) { 320 GrSLType varyingType = kVoid_GrSLType; 321 const char* uniName; 322 switch (get_matrix_type(totalKey, t)) { 323 case kIdentity_MatrixType: 324 transforms[t].fType = kVoid_GrSLType; 325 uniName = NULL; 326 varyingType = kVec2f_GrSLType; 327 break; 328 case kTrans_MatrixType: 329 transforms[t].fType = kVec2f_GrSLType; 330 uniName = "StageTranslate"; 331 varyingType = kVec2f_GrSLType; 332 break; 333 case kNoPersp_MatrixType: 334 transforms[t].fType = kMat33f_GrSLType; 335 uniName = "StageMatrix"; 336 varyingType = kVec2f_GrSLType; 337 break; 338 case kGeneral_MatrixType: 339 transforms[t].fType = kMat33f_GrSLType; 340 uniName = "StageMatrix"; 341 varyingType = kVec3f_GrSLType; 342 break; 343 default: 344 SkFAIL("Unexpected key."); 345 } 346 SkString suffixedUniName; 347 if (kVoid_GrSLType != transforms[t].fType) { 348 if (0 != t) { 349 suffixedUniName.append(uniName); 350 suffixedUniName.appendf("_%i", t); 351 uniName = suffixedUniName.c_str(); 352 } 353 transforms[t].fHandle = builder->addUniform(GrGLShaderBuilder::kVertex_Visibility, 354 transforms[t].fType, 355 uniName, 356 &uniName); 357 } 358 359 const char* varyingName = "MatrixCoord"; 360 SkString suffixedVaryingName; 361 if (0 != t) { 362 suffixedVaryingName.append(varyingName); 363 suffixedVaryingName.appendf("_%i", t); 364 varyingName = suffixedVaryingName.c_str(); 365 } 366 const char* vsVaryingName; 367 const char* fsVaryingName; 368 builder->addVarying(varyingType, varyingName, &vsVaryingName, &fsVaryingName); 369 370 const GrGLShaderVar& coords = kPosition_GrCoordSet == get_source_coords(totalKey, t) ? 371 builder->positionAttribute() : 372 builder->localCoordsAttribute(); 373 // varying = matrix * coords (logically) 374 switch (transforms[t].fType) { 375 case kVoid_GrSLType: 376 SkASSERT(kVec2f_GrSLType == varyingType); 377 builder->vsCodeAppendf("\t%s = %s;\n", vsVaryingName, coords.c_str()); 378 break; 379 case kVec2f_GrSLType: 380 SkASSERT(kVec2f_GrSLType == varyingType); 381 builder->vsCodeAppendf("\t%s = %s + %s;\n", 382 vsVaryingName, uniName, coords.c_str()); 383 break; 384 case kMat33f_GrSLType: { 385 SkASSERT(kVec2f_GrSLType == varyingType || kVec3f_GrSLType == varyingType); 386 if (kVec2f_GrSLType == varyingType) { 387 builder->vsCodeAppendf("\t%s = (%s * vec3(%s, 1)).xy;\n", 388 vsVaryingName, uniName, coords.c_str()); 389 } else { 390 builder->vsCodeAppendf("\t%s = %s * vec3(%s, 1);\n", 391 vsVaryingName, uniName, coords.c_str()); 392 } 393 break; 394 } 395 default: 396 SkFAIL("Unexpected uniform type."); 397 } 398 SkNEW_APPEND_TO_TARRAY(outCoords, TransformedCoords, 399 (SkString(fsVaryingName), varyingType)); 400 } 401 } 402 403 void GrGLVertexProgramEffects::setData(GrGpuGL* gpu, 404 const GrGLUniformManager& uniformManager, 405 const GrEffectStage* effectStages[]) { 406 int numEffects = fGLEffects.count(); 407 SkASSERT(numEffects == fTransforms.count()); 408 SkASSERT(numEffects == fSamplers.count()); 409 for (int e = 0; e < numEffects; ++e) { 410 GrDrawEffect drawEffect(*effectStages[e], fHasExplicitLocalCoords); 411 fGLEffects[e]->setData(uniformManager, drawEffect); 412 this->setTransformData(uniformManager, drawEffect, e); 413 this->bindTextures(gpu, *drawEffect.effect(), e); 414 } 415 } 416 417 void GrGLVertexProgramEffects::setTransformData(const GrGLUniformManager& uniformManager, 418 const GrDrawEffect& drawEffect, 419 int effectIdx) { 420 SkTArray<Transform, true>& transforms = fTransforms[effectIdx]; 421 int numTransforms = transforms.count(); 422 SkASSERT(numTransforms == (*drawEffect.effect())->numTransforms()); 423 for (int t = 0; t < numTransforms; ++t) { 424 SkASSERT(transforms[t].fHandle.isValid() != (kVoid_GrSLType == transforms[t].fType)); 425 switch (transforms[t].fType) { 426 case kVoid_GrSLType: 427 SkASSERT(get_transform_matrix(drawEffect, t).isIdentity()); 428 break; 429 case kVec2f_GrSLType: { 430 GrGLfloat tx, ty; 431 get_transform_translation(drawEffect, t, &tx, &ty); 432 if (transforms[t].fCurrentValue.get(SkMatrix::kMTransX) != tx || 433 transforms[t].fCurrentValue.get(SkMatrix::kMTransY) != ty) { 434 uniformManager.set2f(transforms[t].fHandle, tx, ty); 435 transforms[t].fCurrentValue.set(SkMatrix::kMTransX, tx); 436 transforms[t].fCurrentValue.set(SkMatrix::kMTransY, ty); 437 } 438 break; 439 } 440 case kMat33f_GrSLType: { 441 const SkMatrix& matrix = get_transform_matrix(drawEffect, t); 442 if (!transforms[t].fCurrentValue.cheapEqualTo(matrix)) { 443 uniformManager.setSkMatrix(transforms[t].fHandle, matrix); 444 transforms[t].fCurrentValue = matrix; 445 } 446 break; 447 } 448 default: 449 SkFAIL("Unexpected uniform type."); 450 } 451 } 452 } 453 454 GrGLVertexProgramEffectsBuilder::GrGLVertexProgramEffectsBuilder(GrGLFullShaderBuilder* builder, 455 int reserveCount) 456 : fBuilder(builder) 457 , fProgramEffects(SkNEW_ARGS(GrGLVertexProgramEffects, 458 (reserveCount, fBuilder->hasExplicitLocalCoords()))) { 459 } 460 461 void GrGLVertexProgramEffectsBuilder::emitEffect(const GrEffectStage& stage, 462 GrGLProgramEffects::EffectKey key, 463 const char* outColor, 464 const char* inColor, 465 int stageIndex) { 466 SkASSERT(NULL != fProgramEffects.get()); 467 fProgramEffects->emitEffect(fBuilder, stage, key, outColor, inColor, stageIndex); 468 } 469 470 //////////////////////////////////////////////////////////////////////////////// 471 472 void GrGLPathTexGenProgramEffects::emitEffect(GrGLFragmentOnlyShaderBuilder* builder, 473 const GrEffectStage& stage, 474 EffectKey key, 475 const char* outColor, 476 const char* inColor, 477 int stageIndex) { 478 GrDrawEffect drawEffect(stage, false); 479 const GrEffectRef& effect = *stage.getEffect(); 480 SkSTArray<2, TransformedCoords> coords(effect->numTransforms()); 481 SkSTArray<4, TextureSampler> samplers(effect->numTextures()); 482 483 SkASSERT(0 == stage.getVertexAttribIndexCount()); 484 this->setupPathTexGen(builder, effect, key, &coords); 485 this->emitSamplers(builder, effect, &samplers); 486 487 GrGLEffect* glEffect = effect->getFactory().createGLInstance(drawEffect); 488 fGLEffects.push_back(glEffect); 489 490 // Enclose custom code in a block to avoid namespace conflicts 491 SkString openBrace; 492 openBrace.printf("\t{ // Stage %d: %s\n", stageIndex, glEffect->name()); 493 builder->fsCodeAppend(openBrace.c_str()); 494 495 SkASSERT(!glEffect->isVertexEffect()); 496 glEffect->emitCode(builder, drawEffect, key, outColor, inColor, coords, samplers); 497 498 builder->fsCodeAppend("\t}\n"); 499 } 500 501 void GrGLPathTexGenProgramEffects::setupPathTexGen(GrGLFragmentOnlyShaderBuilder* builder, 502 const GrEffectRef& effect, 503 EffectKey effectKey, 504 TransformedCoordsArray* outCoords) { 505 int numTransforms = effect->numTransforms(); 506 EffectKey totalKey = GrBackendEffectFactory::GetTransformKey(effectKey); 507 int texCoordIndex = builder->addTexCoordSets(numTransforms); 508 SkNEW_APPEND_TO_TARRAY(&fTransforms, Transforms, (totalKey, texCoordIndex)); 509 SkString name; 510 for (int t = 0; t < numTransforms; ++t) { 511 GrSLType type = kGeneral_MatrixType == get_matrix_type(totalKey, t) ? 512 kVec3f_GrSLType : 513 kVec2f_GrSLType; 514 name.printf("%s(gl_TexCoord[%i])", GrGLSLTypeString(type), texCoordIndex++); 515 SkNEW_APPEND_TO_TARRAY(outCoords, TransformedCoords, (name, type)); 516 } 517 } 518 519 void GrGLPathTexGenProgramEffects::setData(GrGpuGL* gpu, 520 const GrGLUniformManager& uniformManager, 521 const GrEffectStage* effectStages[]) { 522 int numEffects = fGLEffects.count(); 523 SkASSERT(numEffects == fTransforms.count()); 524 SkASSERT(numEffects == fSamplers.count()); 525 for (int e = 0; e < numEffects; ++e) { 526 GrDrawEffect drawEffect(*effectStages[e], false); 527 fGLEffects[e]->setData(uniformManager, drawEffect); 528 this->setPathTexGenState(gpu, drawEffect, e); 529 this->bindTextures(gpu, *drawEffect.effect(), e); 530 } 531 } 532 533 void GrGLPathTexGenProgramEffects::setPathTexGenState(GrGpuGL* gpu, 534 const GrDrawEffect& drawEffect, 535 int effectIdx) { 536 EffectKey totalKey = fTransforms[effectIdx].fTransformKey; 537 int texCoordIndex = fTransforms[effectIdx].fTexCoordIndex; 538 int numTransforms = (*drawEffect.effect())->numTransforms(); 539 for (int t = 0; t < numTransforms; ++t) { 540 switch (get_matrix_type(totalKey, t)) { 541 case kIdentity_MatrixType: { 542 SkASSERT(get_transform_matrix(drawEffect, t).isIdentity()); 543 GrGLfloat identity[] = {1, 0, 0, 544 0, 1, 0}; 545 gpu->enablePathTexGen(texCoordIndex++, 546 GrGpuGL::kST_PathTexGenComponents, 547 identity); 548 break; 549 } 550 case kTrans_MatrixType: { 551 GrGLfloat tx, ty; 552 get_transform_translation(drawEffect, t, &tx, &ty); 553 GrGLfloat translate[] = {1, 0, tx, 554 0, 1, ty}; 555 gpu->enablePathTexGen(texCoordIndex++, 556 GrGpuGL::kST_PathTexGenComponents, 557 translate); 558 break; 559 } 560 case kNoPersp_MatrixType: { 561 const SkMatrix& transform = get_transform_matrix(drawEffect, t); 562 gpu->enablePathTexGen(texCoordIndex++, 563 GrGpuGL::kST_PathTexGenComponents, 564 transform); 565 break; 566 } 567 case kGeneral_MatrixType: { 568 const SkMatrix& transform = get_transform_matrix(drawEffect, t); 569 gpu->enablePathTexGen(texCoordIndex++, 570 GrGpuGL::kSTR_PathTexGenComponents, 571 transform); 572 break; 573 } 574 default: 575 SkFAIL("Unexpected matrixs type."); 576 } 577 } 578 } 579 580 GrGLPathTexGenProgramEffectsBuilder::GrGLPathTexGenProgramEffectsBuilder( 581 GrGLFragmentOnlyShaderBuilder* builder, 582 int reserveCount) 583 : fBuilder(builder) 584 , fProgramEffects(SkNEW_ARGS(GrGLPathTexGenProgramEffects, (reserveCount))) { 585 } 586 587 void GrGLPathTexGenProgramEffectsBuilder::emitEffect(const GrEffectStage& stage, 588 GrGLProgramEffects::EffectKey key, 589 const char* outColor, 590 const char* inColor, 591 int stageIndex) { 592 SkASSERT(NULL != fProgramEffects.get()); 593 fProgramEffects->emitEffect(fBuilder, stage, key, outColor, inColor, stageIndex); 594 } 595
