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