Use vertexless shaders when NVpr is available

src/gpu/gl/GrGLProgramEffects.h

 /*
  * Copyright 2013 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #ifndef GrGLProgramEffects_DEFINED
 #define GrGLProgramEffects_DEFINED
 
 #include "GrBackendEffectFactory.h"
 #include "GrTexture.h"
 #include "GrTextureAccess.h"
 #include "GrGLUniformManager.h"
 
 class GrEffectStage;
 class GrGLProgramEffectsBuilder;
 class GrGLVertexProgramEffectsBuilder;
 class GrGLShaderBuilder;
 class GrGLFullShaderBuilder;
+class GrGLFragmentOnlyShaderBuilder;
 
 /**
  * This class encapsulates an array of GrGLEffects and their supporting data (coord transforms
  * and textures). It is built with GrGLProgramEffectsBuilder, then used to manage the necessary GL
  * state and shader uniforms.
  */
 class GrGLProgramEffects {
 public:
     typedef GrBackendEffectFactory::EffectKey EffectKey;
     typedef GrGLUniformManager::UniformHandle UniformHandle;
@@ skipping 18 matching lines @@
      */
     virtual void setData(GrGpuGL*,
                          const GrGLUniformManager&,
                          const GrEffectStage* effectStages[]) = 0;
 
     /**
      * Passed to GrGLEffects so they can add transformed coordinates to their shader code.
      */
     class TransformedCoords {
     public:
-        TransformedCoords(const char* name, GrSLType type)
+        TransformedCoords(const SkString& name, GrSLType type)
             : fName(name), fType(type) {
         }
 
         const char* c_str() const { return fName.c_str(); }
         GrSLType type() const { return fType; }
         const SkString& getName() const { return fName; }
 
     private:
         SkString fName;
         GrSLType fType;
@@ skipping 78 matching lines @@
         GrSLType      fType;
         SkMatrix      fCurrentValue;
     };
 
     SkTArray<SkSTArray<2, Transform, true> > fTransforms;
     bool                                     fHasExplicitLocalCoords;
 
     typedef GrGLProgramEffects INHERITED;
 };
 
+/**
+ * This is a GrGLProgramEffects implementation that does coord transforms with the the built-in GL
+ * TexGen functionality.
+ */
+class GrGLTexGenProgramEffects : public GrGLProgramEffects {
+public:
+    virtual void setData(GrGpuGL*,
+                         const GrGLUniformManager&,
+                         const GrEffectStage* effectStages[]) SK_OVERRIDE;
+
+private:
+    friend class GrGLTexGenProgramEffectsBuilder;
+
+    GrGLTexGenProgramEffects(int reserveCount)
+        : INHERITED(reserveCount)
+#ifdef SK_DEBUG
+        , fFirstTexCoordIdx(0)

[Kimmo Kinnunen, 2013/10/04 11:02:33]

This variable is never set in release mode. Causes crashes.

+        , fNumTexCoordSets(0)
+#endif
+        , fTransformKeys(reserveCount) {
+    }
+
+    /**
+     * Helper for setData(). Sets the TexGen state for each transform in an effect. The transforms
+     * use adjacent texture units, starting with *texCoordIdx. Increments *texCoordIdx by the number
+     * of transforms before returning.
+     */
+    void setTexGenState(GrGpuGL*, const GrDrawEffect&, int* texCoordIdx, int effectIdx);
+
+    int                       fFirstTexCoordIdx;
+    SkDEBUGCODE(int           fNumTexCoordSets;)
+    SkTArray<EffectKey, true> fTransformKeys;
+
+    typedef GrGLProgramEffects INHERITED;
+};
+
+
 ////////////////////////////////////////////////////////////////////////////////
 
 /**
  * This is an abstract base class for constructing different types of GrGLProgramEffects objects.
  */
 class GrGLProgramEffectsBuilder {
 public:
     /**
      * Emits the effect's shader code, and stores the necessary uniforms internally.
      */
@@ skipping 49 matching lines @@
     void emitTransforms(const GrEffectRef&,
                         GrGLProgramEffects::EffectKey,
                         GrGLProgramEffects::TransformedCoordsArray*);
 
     GrGLFullShaderBuilder*                  fBuilder;
     SkAutoTDelete<GrGLVertexProgramEffects> fProgramEffects;
 
     typedef GrGLProgramEffectsBuilder INHERITED;
 };
 
+/**
+ * This class is used by GrGLFragmentOnlyBuilder to construct a GrGLTexGenProgramEffects.
+ */
+class GrGLTexGenProgramEffectsBuilder : public GrGLProgramEffectsBuilder {
+public:
+    GrGLTexGenProgramEffectsBuilder(GrGLFragmentOnlyShaderBuilder*, int reserveCount);
+
+    virtual void emitEffect(const GrEffectStage&,
+                            GrGLProgramEffects::EffectKey,
+                            const char* outColor,
+                            const char* inColor,
+                            int stageIndex) SK_OVERRIDE;
+
+    /**
+     * Finalizes the building process and returns the effect array. After this call, the builder
+     * becomes invalid.
+     */
+    GrGLProgramEffects* finish() { return fProgramEffects.detach(); }
+
+private:
+    /**
+     * Helper for emitEffect(). Allocates texture units from the builder for each transform in an
+     * effect. The transforms all use adjacent texture units. They either use two or three of the
+     * coordinates at a given texture unit, depending on if they need perspective interpolation.
+     * The expressions to access the transformed coords (i.e. 'vec2(gl_TexCoord[0])') as well as the
+     * types are appended to the TransformedCoordsArray* object, which is in turn passed to the
+     * effect's emitCode() function.
+     */
+    void setupTexGen(const GrEffectRef&,
+                     GrGLProgramEffects::EffectKey,
+                     GrGLProgramEffects::TransformedCoordsArray*);
+
+    GrGLFragmentOnlyShaderBuilder*          fBuilder;
+    SkAutoTDelete<GrGLTexGenProgramEffects> fProgramEffects;
+
+    typedef GrGLProgramEffectsBuilder INHERITED;
+};
+
 #endif