Make GPU coord transforms automatic

src/gpu/gl/GrGLShaderBuilder.h

 /*
  * Copyright 2012 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #ifndef GrGLShaderBuilder_DEFINED
 #define GrGLShaderBuilder_DEFINED
 
 #include "GrAllocator.h"
 #include "GrBackendEffectFactory.h"
 #include "GrColor.h"
 #include "GrEffect.h"
 #include "SkTypes.h"
+#include "gl/GrGLCoordTransform.h"
 #include "gl/GrGLSL.h"
 #include "gl/GrGLUniformManager.h"
 
 #include <stdarg.h>
 
 class GrGLContextInfo;
 class GrEffectStage;
 class GrGLProgramDesc;
 
 /**
@@ skipping 63 matching lines @@
                        idx);
         }
 
         uint32_t                          fConfigComponentMask;
         char                              fSwizzle[5];
         GrGLUniformManager::UniformHandle fSamplerUniform;
 
         friend class GrGLShaderBuilder; // to call init().
     };
 
+    typedef SkTArray<GrGLCoordTransform::TransformedCoords> TransformedCoordsArray;
     typedef SkTArray<TextureSampler> TextureSamplerArray;
     typedef GrTAllocator<GrGLShaderVar> VarArray;
+    typedef GrBackendEffectFactory::EffectKey EffectKey;
 
     enum ShaderVisibility {
         kVertex_Visibility   = 0x1,
         kGeometry_Visibility = 0x2,
         kFragment_Visibility = 0x4,
     };
 
     GrGLShaderBuilder(GrGpuGL*,
                       GrGLUniformManager&,
                       const GrGLProgramDesc&,
@@ skipping 57 matching lines @@
                         const GrGLShaderVar* args,
                         const char* body,
                         SkString* outName);
 
     /** Add input/output variable declarations (i.e. 'varying') to the fragment shader. */
     GrGLShaderVar& fsInputAppend() { return fFSInputs.push_back(); }
 
     /** Generates a EffectKey for the shader code based on the texture access parameters and the
         capabilities of the GL context.  This is useful for keying the shader programs that may
         have multiple representations, based on the type/format of textures used. */
-    static GrBackendEffectFactory::EffectKey KeyForTextureAccess(const GrTextureAccess&,
-                                                                 const GrGLCaps&);
+    static EffectKey KeyForTextureAccess(const GrTextureAccess&, const GrGLCaps&);
 
     typedef uint8_t DstReadKey;
     typedef uint8_t FragPosKey;
 
     /**  Returns a key for adding code to read the copy-of-dst color in service of effects that
          require reading the dst. It must not return 0 because 0 indicates that there is no dst
          copy read at all (in which case this function should not be called). */
     static DstReadKey KeyForDstRead(const GrTexture* dstCopy, const GrGLCaps&);
 
     /** Returns a key for reading the fragment location. This should only be called if there is an
@@ skipping 28 matching lines @@
         return fUniformManager.getBuilderUniform(fUniforms, u).fVariable;
     }
 
     /**
      * Shortcut for getUniformVariable(u).c_str()
      */
     const char* getUniformCStr(GrGLUniformManager::UniformHandle u) const {
         return this->getUniformVariable(u).c_str();
     }
 
+    /**
+     * This returns a variable name to access the 2D, perspective correct version of the coords in
+     * the fragment shader. If the coordinates at index are 3-dimensional, it emits a perspective
+     * divide (xy / z) to convert them to 2D.
+     */
+    SkString ensureFSCoords2D(const TransformedCoordsArray&, int index);

[bsalomon, 2013/09/27 20:04:25]

Might want to document that this may emit code into the FS so some unknowning
caller doesn't invoke it when they've emitted a half-finished line of code.

[Chris Dalton, 2013/09/27 23:33:45]

Done.

+
     /** Returns a variable name that represents the position of the fragment in the FS. The position
         is in device space (e.g. 0,0 is the top left and pixel centers are at half-integers). */
     const char* fragmentPosition();
 
     /** Returns the color of the destination pixel. This may be NULL if no effect advertised
         that it will read the destination. */
     const char* dstColor();
 
     /**
      * Interfaces used by GrGLProgram.
@@ skipping 10 matching lines @@
      * generated from effectStages[i]. An entry in effectStages can be NULL, in which case it is
      * skipped. Moreover, if the corresponding key is GrGLEffect::NoEffectKey then it is skipped.
      * inOutFSColor specifies the input color to the first stage and is updated to be the
      * output color of the last stage. fsInOutColorKnownValue specifies whether the input color
      * has a known constant value and is updated to refer to the status of the output color.
      * The handles to texture samplers for effectStage[i] are added to effectSamplerHandles[i]. The
      * glEffects array is updated to contain the GrGLEffect generated for each entry in
      * effectStages.
      */
     void emitEffects(const GrEffectStage* effectStages[],
-                     const GrBackendEffectFactory::EffectKey effectKeys[],
+                     const EffectKey effectKeys[],
                      int effectCnt,
                      SkString*  inOutFSColor,
                      GrSLConstantVec* fsInOutColorKnownValue,
+                     SkTArray<GrGLCoordTransform, false>* effectCoordTransformArrays[],
                      SkTArray<GrGLUniformManager::UniformHandle, true>* effectSamplerHandles[],
                      GrGLEffect* glEffects[]);
 
     const char* getColorOutputName() const;
     const char* enableSecondaryOutput();
 
     GrGLUniformManager::UniformHandle getRTHeightUniform() const { return fRTHeightUniform; }
     GrGLUniformManager::UniformHandle getDstCopyTopLeftUniform() const {
         return fDstCopyTopLeftUniform;
     }
@@ skipping 217 matching lines @@
     GrGLUniformManager::UniformHandle   fDstCopyScaleUniform;
     GrGLUniformManager::UniformHandle   fColorUniform;
     GrGLUniformManager::UniformHandle   fCoverageUniform;
 
     bool                                fTopLeftFragPosRead;
 
     SkAutoTDelete<VertexBuilder>        fVertexBuilder;
 };
 
 #endif