Home | History | Annotate | Download | only in gl 
      1 /*
      2  * Copyright 2011 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 GrGLSL_DEFINED
      9 #define GrGLSL_DEFINED
     10 
     11 #include "gl/GrGLInterface.h"
     12 #include "GrColor.h"
     13 #include "GrTypesPriv.h"
     14 #include "SkString.h"
     15 
     16 class GrGLContextInfo;
     17 class GrGLShaderVar;
     18 
     19 // Limited set of GLSL versions we build shaders for. Caller should round
     20 // down the GLSL version to one of these enums.
     21 enum GrGLSLGeneration {
     22     /**
     23      * Desktop GLSL 1.10 and ES2 shading language (based on desktop GLSL 1.20)
     24      */
     25     k110_GrGLSLGeneration,
     26     /**
     27      * Desktop GLSL 1.30
     28      */
     29     k130_GrGLSLGeneration,
     30     /**
     31      * Desktop GLSL 1.40
     32      */
     33     k140_GrGLSLGeneration,
     34     /**
     35      * Desktop GLSL 1.50
     36      */
     37     k150_GrGLSLGeneration,
     38     /**
     39      * Desktop GLSL 3.30, and ES GLSL 3.00
     40      */
     41     k330_GrGLSLGeneration,
     42     /**
     43      * ES GLSL 3.10 only TODO Make GLSLCap objects to make this more granular
     44      */
     45     k310es_GrGLSLGeneration,
     46 };
     47 
     48 /**
     49  * Gets the most recent GLSL Generation compatible with the OpenGL context.
     50  */
     51 bool GrGetGLSLGeneration(const GrGLInterface* gl, GrGLSLGeneration* generation);
     52 
     53 /**
     54  * Returns a string to include at the beginning of a shader to declare the GLSL
     55  * version.
     56  */
     57 const char* GrGetGLSLVersionDecl(const GrGLContextInfo&);
     58 
     59 /**
     60  * Converts a GrSLType to a string containing the name of the equivalent GLSL type.
     61  */
     62 static inline const char* GrGLSLTypeString(GrSLType t) {
     63     switch (t) {
     64         case kVoid_GrSLType:
     65             return "void";
     66         case kFloat_GrSLType:
     67             return "float";
     68         case kVec2f_GrSLType:
     69             return "vec2";
     70         case kVec3f_GrSLType:
     71             return "vec3";
     72         case kVec4f_GrSLType:
     73             return "vec4";
     74         case kMat33f_GrSLType:
     75             return "mat3";
     76         case kMat44f_GrSLType:
     77             return "mat4";
     78         case kSampler2D_GrSLType:
     79             return "sampler2D";
     80         default:
     81             SkFAIL("Unknown shader var type.");
     82             return ""; // suppress warning
     83     }
     84 }
     85 
     86 /** A generic base-class representing a GLSL expression.
     87  * The instance can be a variable name, expression or vecN(0) or vecN(1). Does simple constant
     88  * folding with help of 1 and 0.
     89  *
     90  * Clients should not use this class, rather the specific instantiations defined
     91  * later, for example GrGLSLExpr4.
     92  */
     93 template <typename Self>
     94 class GrGLSLExpr {
     95 public:
     96     bool isOnes() const { return kOnes_ExprType == fType; }
     97     bool isZeros() const { return kZeros_ExprType == fType; }
     98 
     99     const char* c_str() const {
    100         if (kZeros_ExprType == fType) {
    101             return Self::ZerosStr();
    102         } else if (kOnes_ExprType == fType) {
    103             return Self::OnesStr();
    104         }
    105         SkASSERT(!fExpr.isEmpty()); // Empty expressions should not be used.
    106         return fExpr.c_str();
    107     }
    108 
    109     bool isValid() const {
    110         return kFullExpr_ExprType != fType || !fExpr.isEmpty();
    111     }
    112 
    113 protected:
    114     /** Constructs an invalid expression.
    115      * Useful only as a return value from functions that never actually return
    116      * this and instances that will be assigned to later. */
    117     GrGLSLExpr()
    118         : fType(kFullExpr_ExprType) {
    119         // The only constructor that is allowed to build an empty expression.
    120         SkASSERT(!this->isValid());
    121     }
    122 
    123     /** Constructs an expression with all components as value v */
    124     explicit GrGLSLExpr(int v) {
    125         if (v == 0) {
    126             fType = kZeros_ExprType;
    127         } else if (v == 1) {
    128             fType = kOnes_ExprType;
    129         } else {
    130             fType = kFullExpr_ExprType;
    131             fExpr.appendf(Self::CastIntStr(), v);
    132         }
    133     }
    134 
    135     /** Constructs an expression from a string.
    136      * Argument expr is a simple expression or a parenthesized expression. */
    137     // TODO: make explicit once effects input Exprs.
    138     GrGLSLExpr(const char expr[]) {
    139         if (NULL == expr) {  // TODO: remove this once effects input Exprs.
    140             fType = kOnes_ExprType;
    141         } else {
    142             fType = kFullExpr_ExprType;
    143             fExpr = expr;
    144         }
    145         SkASSERT(this->isValid());
    146     }
    147 
    148     /** Constructs an expression from a string.
    149      * Argument expr is a simple expression or a parenthesized expression. */
    150     // TODO: make explicit once effects input Exprs.
    151     GrGLSLExpr(const SkString& expr) {
    152         if (expr.isEmpty()) {  // TODO: remove this once effects input Exprs.
    153             fType = kOnes_ExprType;
    154         } else {
    155             fType = kFullExpr_ExprType;
    156             fExpr = expr;
    157         }
    158         SkASSERT(this->isValid());
    159     }
    160 
    161     /** Constructs an expression from a string with one substitution. */
    162     GrGLSLExpr(const char format[], const char in0[])
    163         : fType(kFullExpr_ExprType) {
    164         fExpr.appendf(format, in0);
    165     }
    166 
    167     /** Constructs an expression from a string with two substitutions. */
    168     GrGLSLExpr(const char format[], const char in0[], const char in1[])
    169         : fType(kFullExpr_ExprType) {
    170         fExpr.appendf(format, in0, in1);
    171     }
    172 
    173     /** Returns expression casted to another type.
    174      * Generic implementation that is called for non-trivial cases of casts. */
    175     template <typename T>
    176     static Self VectorCastImpl(const T& other);
    177 
    178     /** Returns a GLSL multiplication: component-wise or component-by-scalar.
    179      * The multiplication will be component-wise or multiply each component by a scalar.
    180      *
    181      * The returned expression will compute the value of:
    182      *    vecN(in0.x * in1.x, ...) if dim(T0) == dim(T1) (component-wise)
    183      *    vecN(in0.x * in1, ...) if dim(T1) == 1 (vector by scalar)
    184      *    vecN(in0 * in1.x, ...) if dim(T0) == 1 (scalar by vector)
    185      */
    186     template <typename T0, typename T1>
    187     static Self Mul(T0 in0, T1 in1);
    188 
    189     /** Returns a GLSL addition: component-wise or add a scalar to each component.
    190      * Return value computes:
    191      *   vecN(in0.x + in1.x, ...) or vecN(in0.x + in1, ...) or vecN(in0 + in1.x, ...).
    192      */
    193     template <typename T0, typename T1>
    194     static Self Add(T0 in0, T1 in1);
    195 
    196     /** Returns a GLSL subtraction: component-wise or subtract compoments by a scalar.
    197      * Return value computes
    198      *   vecN(in0.x - in1.x, ...) or vecN(in0.x - in1, ...) or vecN(in0 - in1.x, ...).
    199      */
    200     template <typename T0, typename T1>
    201     static Self Sub(T0 in0, T1 in1);
    202 
    203     /** Returns expression that accesses component(s) of the expression.
    204      * format should be the form "%s.x" where 'x' is the component(s) to access.
    205      * Caller is responsible for making sure the amount of components in the
    206      * format string is equal to dim(T).
    207      */
    208     template <typename T>
    209     T extractComponents(const char format[]) const;
    210 
    211 private:
    212     enum ExprType {
    213         kZeros_ExprType,
    214         kOnes_ExprType,
    215         kFullExpr_ExprType,
    216     };
    217     ExprType fType;
    218     SkString fExpr;
    219 };
    220 
    221 class GrGLSLExpr1;
    222 class GrGLSLExpr4;
    223 
    224 /** Class representing a float GLSL expression. */
    225 class GrGLSLExpr1 : public GrGLSLExpr<GrGLSLExpr1> {
    226 public:
    227     GrGLSLExpr1()
    228         : INHERITED() {
    229     }
    230     explicit GrGLSLExpr1(int v)
    231         : INHERITED(v) {
    232     }
    233     GrGLSLExpr1(const char* expr)
    234         : INHERITED(expr) {
    235     }
    236     GrGLSLExpr1(const SkString& expr)
    237         : INHERITED(expr) {
    238     }
    239 
    240     static GrGLSLExpr1 VectorCast(const GrGLSLExpr1& expr);
    241 
    242 private:
    243     GrGLSLExpr1(const char format[], const char in0[])
    244         : INHERITED(format, in0) {
    245     }
    246     GrGLSLExpr1(const char format[], const char in0[], const char in1[])
    247         : INHERITED(format, in0, in1) {
    248     }
    249 
    250     static const char* ZerosStr();
    251     static const char* OnesStr();
    252     static const char* CastStr();
    253     static const char* CastIntStr();
    254 
    255     friend GrGLSLExpr1 operator*(const GrGLSLExpr1& in0, const GrGLSLExpr1&in1);
    256     friend GrGLSLExpr1 operator+(const GrGLSLExpr1& in0, const GrGLSLExpr1&in1);
    257     friend GrGLSLExpr1 operator-(const GrGLSLExpr1& in0, const GrGLSLExpr1&in1);
    258 
    259     friend class GrGLSLExpr<GrGLSLExpr1>;
    260     friend class GrGLSLExpr<GrGLSLExpr4>;
    261 
    262     typedef GrGLSLExpr<GrGLSLExpr1> INHERITED;
    263 };
    264 
    265 /** Class representing a float vector (vec4) GLSL expression. */
    266 class GrGLSLExpr4 : public GrGLSLExpr<GrGLSLExpr4> {
    267 public:
    268     GrGLSLExpr4()
    269         : INHERITED() {
    270     }
    271     explicit GrGLSLExpr4(int v)
    272         : INHERITED(v) {
    273     }
    274     GrGLSLExpr4(const char* expr)
    275         : INHERITED(expr) {
    276     }
    277     GrGLSLExpr4(const SkString& expr)
    278         : INHERITED(expr) {
    279     }
    280 
    281     typedef GrGLSLExpr1 AExpr;
    282     AExpr a() const;
    283 
    284     /** GLSL vec4 cast / constructor, eg vec4(floatv) -> vec4(floatv, floatv, floatv, floatv) */
    285     static GrGLSLExpr4 VectorCast(const GrGLSLExpr1& expr);
    286     static GrGLSLExpr4 VectorCast(const GrGLSLExpr4& expr);
    287 
    288 private:
    289     GrGLSLExpr4(const char format[], const char in0[])
    290         : INHERITED(format, in0) {
    291     }
    292     GrGLSLExpr4(const char format[], const char in0[], const char in1[])
    293         : INHERITED(format, in0, in1) {
    294     }
    295 
    296     static const char* ZerosStr();
    297     static const char* OnesStr();
    298     static const char* CastStr();
    299     static const char* CastIntStr();
    300 
    301     // The vector-by-scalar and scalar-by-vector binary operations.
    302     friend GrGLSLExpr4 operator*(const GrGLSLExpr1& in0, const GrGLSLExpr4&in1);
    303     friend GrGLSLExpr4 operator+(const GrGLSLExpr1& in0, const GrGLSLExpr4&in1);
    304     friend GrGLSLExpr4 operator-(const GrGLSLExpr1& in0, const GrGLSLExpr4&in1);
    305     friend GrGLSLExpr4 operator*(const GrGLSLExpr4& in0, const GrGLSLExpr1&in1);
    306     friend GrGLSLExpr4 operator+(const GrGLSLExpr4& in0, const GrGLSLExpr1&in1);
    307     friend GrGLSLExpr4 operator-(const GrGLSLExpr4& in0, const GrGLSLExpr1&in1);
    308 
    309     // The vector-by-vector, i.e. component-wise, binary operations.
    310     friend GrGLSLExpr4 operator*(const GrGLSLExpr4& in0, const GrGLSLExpr4&in1);
    311     friend GrGLSLExpr4 operator+(const GrGLSLExpr4& in0, const GrGLSLExpr4&in1);
    312     friend GrGLSLExpr4 operator-(const GrGLSLExpr4& in0, const GrGLSLExpr4&in1);
    313 
    314     friend class GrGLSLExpr<GrGLSLExpr4>;
    315 
    316     typedef GrGLSLExpr<GrGLSLExpr4> INHERITED;
    317 };
    318 
    319 /**
    320  * Does an inplace mul, *=, of vec4VarName by mulFactor.
    321  * A semicolon is added after the assignment.
    322  */
    323 void GrGLSLMulVarBy4f(SkString* outAppend, const char* vec4VarName, const GrGLSLExpr4& mulFactor);
    324 
    325 #include "GrGLSL_impl.h"
    326 
    327 #endif
    328