Line data    Source code

       1             : /*
       2             :  * Copyright 2012 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             : #ifndef GrGLProgramDataManager_DEFINED
       9             : #define GrGLProgramDataManager_DEFINED
      10             : 
      11             : #include "GrAllocator.h"
      12             : #include "GrShaderVar.h"
      13             : #include "gl/GrGLTypes.h"
      14             : #include "glsl/GrGLSLProgramDataManager.h"
      15             : 
      16             : #include "SkTArray.h"
      17             : 
      18             : class GrGLGpu;
      19             : class SkMatrix;
      20             : class GrGLProgram;
      21             : 
      22             : /** Manages the resources used by a shader program.
      23             :  * The resources are objects the program uses to communicate with the
      24             :  * application code.
      25             :  */
      26           0 : class GrGLProgramDataManager : public GrGLSLProgramDataManager {
      27             : public:
      28           0 :     struct UniformInfo {
      29             :         GrShaderVar fVariable;
      30             :         uint32_t        fVisibility;
      31             :         GrGLint         fLocation;
      32             :     };
      33             : 
      34           0 :     struct VaryingInfo {
      35             :         GrShaderVar fVariable;
      36             :         GrGLint         fLocation;
      37             :     };
      38             : 
      39             :     // This uses an allocator rather than array so that the GrShaderVars don't move in memory
      40             :     // after they are inserted. Users of GrGLShaderBuilder get refs to the vars and ptrs to their
      41             :     // name strings. Otherwise, we'd have to hand out copies.
      42             :     typedef GrTAllocator<UniformInfo> UniformInfoArray;
      43             :     typedef GrTAllocator<VaryingInfo> VaryingInfoArray;
      44             : 
      45             :     GrGLProgramDataManager(GrGLGpu*, GrGLuint programID, const UniformInfoArray&,
      46             :                            const VaryingInfoArray&);
      47             : 
      48             : 
      49             :     void setSamplers(const UniformInfoArray& samplers) const;
      50             :     void setImageStorages(const UniformInfoArray &images) const;
      51             : 
      52             :     /** Functions for uploading uniform values. The varities ending in v can be used to upload to an
      53             :     *  array of uniforms. arrayCount must be <= the array count of the uniform.
      54             :     */
      55             :     void set1i(UniformHandle, int32_t) const override;
      56             :     void set1iv(UniformHandle, int arrayCount, const int v[]) const override;
      57             :     void set1f(UniformHandle, float v0) const override;
      58             :     void set1fv(UniformHandle, int arrayCount, const float v[]) const override;
      59             :     void set2f(UniformHandle, float, float) const override;
      60             :     void set2fv(UniformHandle, int arrayCount, const float v[]) const override;
      61             :     void set3f(UniformHandle, float, float, float) const override;
      62             :     void set3fv(UniformHandle, int arrayCount, const float v[]) const override;
      63             :     void set4f(UniformHandle, float, float, float, float) const override;
      64             :     void set4fv(UniformHandle, int arrayCount, const float v[]) const override;
      65             :     // matrices are column-major, the first three upload a single matrix, the latter three upload
      66             :     // arrayCount matrices into a uniform array.
      67             :     void setMatrix2f(UniformHandle, const float matrix[]) const override;
      68             :     void setMatrix3f(UniformHandle, const float matrix[]) const override;
      69             :     void setMatrix4f(UniformHandle, const float matrix[]) const override;
      70             :     void setMatrix2fv(UniformHandle, int arrayCount, const float matrices[]) const override;
      71             :     void setMatrix3fv(UniformHandle, int arrayCount, const float matrices[]) const override;
      72             :     void setMatrix4fv(UniformHandle, int arrayCount, const float matrices[]) const override;
      73             : 
      74             :     // for nvpr only
      75             :     void setPathFragmentInputTransform(VaryingHandle u, int components,
      76             :                                        const SkMatrix& matrix) const override;
      77             : 
      78             : private:
      79             :     enum {
      80             :         kUnusedUniform = -1,
      81             :     };
      82             : 
      83             :     struct Uniform {
      84             :         GrGLint     fLocation;
      85             : #ifdef SK_DEBUG
      86             :         GrSLType    fType;
      87             :         int         fArrayCount;
      88             : #endif
      89             :     };
      90             : 
      91             :     enum {
      92             :         kUnusedPathProcVarying = -1,
      93             :     };
      94             :     struct PathProcVarying {
      95             :         GrGLint     fLocation;
      96             :         SkDEBUGCODE(
      97             :             GrSLType    fType;
      98             :             int         fArrayCount;
      99             :         );
     100             :     };
     101             : 
     102             :     template<int N> inline void setMatrices(UniformHandle, int arrayCount,
     103             :                                             const float matrices[]) const;
     104             : 
     105             :     SkTArray<Uniform, true> fUniforms;
     106             :     SkTArray<PathProcVarying, true> fPathProcVaryings;
     107             :     GrGLGpu* fGpu;
     108             :     GrGLuint fProgramID;
     109             : 
     110             :     typedef GrGLSLProgramDataManager INHERITED;
     111             : };
     112             : 
     113             : #endif