Make GPU coord transforms automatic

src/gpu/gl/GrGLShaderBuilder.cpp

 /*
  * Copyright 2012 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "gl/GrGLShaderBuilder.h"
 #include "gl/GrGLProgram.h"
 #include "gl/GrGLUniformHandle.h"
+#include "GrCoordTransform.h"
 #include "GrDrawEffect.h"
 #include "GrGpuGL.h"
 #include "GrTexture.h"
 #include "SkRTConf.h"
 #include "SkTrace.h"
 
 #define GL_CALL(X) GR_GL_CALL(fGpu->glInterface(), X)
 #define GL_CALL_RET(R, X) GR_GL_CALL_RET(fGpu->glInterface(), R, X)
 
 // number of each input/output type in a single allocation block
@@ skipping 319 matching lines @@
 void GrGLShaderBuilder::fsAppendTextureLookupAndModulate(
                                             const char* modulation,
                                             const GrGLShaderBuilder::TextureSampler& sampler,
                                             const char* coordName,
                                             GrSLType varyingType) {
     SkString lookup;
     this->appendTextureLookup(&lookup, sampler, coordName, varyingType);
     GrGLSLModulatef<4>(&fFSCode, modulation, lookup.c_str());
 }
 
-GrBackendEffectFactory::EffectKey GrGLShaderBuilder::KeyForTextureAccess(
-                                                            const GrTextureAccess& access,
-                                                            const GrGLCaps& caps) {
+GrGLShaderBuilder::EffectKey GrGLShaderBuilder::KeyForTextureAccess(const GrTextureAccess& access,
+                                                                    const GrGLCaps& caps) {
     uint32_t configComponentMask = GrPixelConfigComponentMask(access.getTexture()->config());
     if (swizzle_requires_alpha_remapping(caps, configComponentMask, access.swizzleMask())) {
         return 1;
     } else {
         return 0;
     }
 }
 
 GrGLShaderBuilder::DstReadKey GrGLShaderBuilder::KeyForDstRead(const GrTexture* dstCopy,
                                                                const GrGLCaps& caps) {
@@ skipping 70 matching lines @@
         uni.fVariable.setPrecision(kDefaultFragmentPrecision);
     }
 
     if (NULL != outName) {
         *outName = uni.fVariable.c_str();
     }
 
     return h;
 }
 
+SkString GrGLShaderBuilder::ensureFSCoords2D(const TransformedCoordsArray& coords, int index) {
+    if (kVec3f_GrSLType != coords[index].type()) {
+        SkASSERT(kVec2f_GrSLType == coords[index].type());
+        return coords[index].getName();
+    }
+
+    SkString coords2D("coords2D");
+    if (0 != index) {
+        coords2D.appendf("_%i", index);
+    }
+    this->fsCodeAppendf("\tvec2 %s = %s.xy / %s.z;",
+                        coords2D.c_str(), coords[index].c_str(), coords[index].c_str());
+    return coords2D;
+}
+
 const char* GrGLShaderBuilder::fragmentPosition() {
     if (fCodeStage.inStageCode()) {
         const GrEffectRef& effect = *fCodeStage.effectStage()->getEffect();
         if (!effect->willReadFragmentPosition()) {
             GrDebugCrash("GrGLEffect asked for frag position but its generating GrEffect "
                          "did not request access.");
             return "";
         }
     }
     if (fTopLeftFragPosRead) {
@@ skipping 99 matching lines @@
     for (int i = 0; i < fUniforms.count(); ++i) {
         if (fUniforms[i].fVisibility & visibility) {
             fUniforms[i].fVariable.appendDecl(this->ctxInfo(), out);
             out->append(";\n");
         }
     }
 }
 
 void GrGLShaderBuilder::emitEffects(
                         const GrEffectStage* effectStages[],
-                        const GrBackendEffectFactory::EffectKey effectKeys[],
+                        const EffectKey effectKeys[],
                         int effectCnt,
                         SkString* fsInOutColor,
                         GrSLConstantVec* fsInOutColorKnownValue,
+                        SkTArray<GrGLCoordTransform, false>* effectCoordTransformArrays[],
                         SkTArray<GrGLUniformManager::UniformHandle, true>* effectSamplerHandles[],
                         GrGLEffect* glEffects[]) {
     bool effectEmitted = false;
 
     SkString inColor = *fsInOutColor;
     SkString outColor;
 
     for (int e = 0; e < effectCnt; ++e) {
         SkASSERT(NULL != effectStages[e] && NULL != effectStages[e]->getEffect());
         const GrEffectStage& stage = *effectStages[e];
         const GrEffectRef& effect = *stage.getEffect();
 
         CodeStage::AutoStageRestore csar(&fCodeStage, &stage);
 
+        int numTransforms = effect->numTransforms();
+        SkSTArray<8, GrGLCoordTransform::TransformedCoords> transformedCoords;
+        transformedCoords.push_back_n(numTransforms);
+        EffectKey transformKey = GrBackendEffectFactory::GetTransformKey(effectKeys[e]);
+        for (int c = 0; c < numTransforms; ++c) {
+            GrGLCoordTransform& ct = effectCoordTransformArrays[e]->push_back();
+            EffectKey key = (transformKey >> (c * GrGLCoordTransform::kKeyBits)) &
+                            (GrGLCoordTransform::kKeyMask);
+            ct.emitCode(this, key, &transformedCoords[c], c);
+        }
+
         int numTextures = effect->numTextures();
         SkSTArray<8, GrGLShaderBuilder::TextureSampler> textureSamplers;
         textureSamplers.push_back_n(numTextures);
         for (int t = 0; t < numTextures; ++t) {
             textureSamplers[t].init(this, &effect->textureAccess(t), t);
             effectSamplerHandles[e]->push_back(textureSamplers[t].fSamplerUniform);
         }
+
         GrDrawEffect drawEffect(stage, NULL != fVertexBuilder.get()
                                        && fVertexBuilder->hasExplicitLocalCoords());
 
         int numAttributes = stage.getVertexAttribIndexCount();
         const int* attributeIndices = stage.getVertexAttribIndices();
         SkSTArray<GrEffect::kMaxVertexAttribs, SkString> attributeNames;
         for (int a = 0; a < numAttributes; ++a) {
             // TODO: Make addAttribute mangle the name.
             SkASSERT(NULL != fVertexBuilder.get());
             SkString attributeName("aAttr");
@@ skipping 21 matching lines @@
         if (NULL != fVertexBuilder.get()) {
             fVertexBuilder->vsCodeAppend(openBrace.c_str());
         }
         this->fsCodeAppend(openBrace.c_str());
 
         glEffects[e]->emitCode(this,
                                drawEffect,
                                effectKeys[e],
                                outColor.c_str(),
                                inColor.isEmpty() ? NULL : inColor.c_str(),
+                               transformedCoords,
                                textureSamplers);
 
         if (NULL != fVertexBuilder.get()) {
             fVertexBuilder->vsCodeAppend("\t}\n");
         }
         this->fsCodeAppend("\t}\n");
 
         inColor = outColor;
         *fsInOutColorKnownValue = kNone_GrSLConstantVec;
         effectEmitted = true;
@@ skipping 344 matching lines @@
         GL_CALL(BindAttribLocation(programId,
                                    header.fCoverageAttributeIndex,
                                    coverage_attribute_name()));
     }
 
     const AttributePair* attribEnd = fEffectAttributes.end();
     for (const AttributePair* attrib = fEffectAttributes.begin(); attrib != attribEnd; ++attrib) {
          GL_CALL(BindAttribLocation(programId, attrib->fIndex, attrib->fName.c_str()));
     }
 }