Potentially optimize some GrGLEffects for known input color values

src/gpu/gl/GrGLSL.h

 /*
  * Copyright 2011 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #ifndef GrGLSL_DEFINED
 #define GrGLSL_DEFINED
 
@@ skipping 105 matching lines @@
         } else if (v == 1) {
             fType = kOnes_ExprType;
         } else {
             fType = kFullExpr_ExprType;
             fExpr.appendf(Self::CastIntStr(), v);
         }
     }
 
     /** Constructs an expression from a string.
      * Argument expr is a simple expression or a parenthesized expression. */
-    // TODO: make explicit once effects input Exprs.
-    GrGLSLExpr(const char expr[]) {
-        if (NULL == expr) {  // TODO: remove this once effects input Exprs.
-            fType = kOnes_ExprType;
-        } else {
-            fType = kFullExpr_ExprType;
-            fExpr = expr;
-        }
-        SkASSERT(this->isValid());
+    explicit GrGLSLExpr(const char expr[]) {
+        fType = kFullExpr_ExprType;
+        fExpr = expr;
+        SkASSERT(NULL != expr);
     }
 
     /** Constructs an expression from a string.
      * Argument expr is a simple expression or a parenthesized expression. */
-    // TODO: make explicit once effects input Exprs.
-    GrGLSLExpr(const SkString& expr) {
-        if (expr.isEmpty()) {  // TODO: remove this once effects input Exprs.
-            fType = kOnes_ExprType;
-        } else {
-            fType = kFullExpr_ExprType;
-            fExpr = expr;
-        }
-        SkASSERT(this->isValid());
+    explicit GrGLSLExpr(const SkString& expr) {
+        fType = kFullExpr_ExprType;
+        fExpr = expr;
+        SkASSERT(!expr.isEmpty());
     }
 
     /** Constructs an expression from a string with one substitution. */
     GrGLSLExpr(const char format[], const char in0[])
         : fType(kFullExpr_ExprType) {
         fExpr.appendf(format, in0);
     }
 
     /** Constructs an expression from a string with two substitutions. */
     GrGLSLExpr(const char format[], const char in0[], const char in1[])
@@ skipping 47 matching lines @@
     enum ExprType {
         kZeros_ExprType,
         kOnes_ExprType,
         kFullExpr_ExprType,
     };
     ExprType fType;
     SkString fExpr;
 };
 
 class GrGLSLExpr1;
+class GrGLSLExpr3;
 class GrGLSLExpr4;
 
+namespace GrGLSL {
+GrGLSLExpr1 max(const GrGLSLExpr1& a, float b);
+
+template<typename T>
+T min(const T& a, const T& b);
+
+template<typename T>
+T max(const T& a, const T& b);
+}
+
 /** Class representing a float GLSL expression. */
 class GrGLSLExpr1 : public GrGLSLExpr<GrGLSLExpr1> {
 public:
     GrGLSLExpr1()
         : INHERITED() {
     }
     explicit GrGLSLExpr1(int v)
         : INHERITED(v) {
     }
-    GrGLSLExpr1(const char* expr)
+    explicit GrGLSLExpr1(const char* expr)
         : INHERITED(expr) {
     }
-    GrGLSLExpr1(const SkString& expr)
+    explicit GrGLSLExpr1(const SkString& expr)
         : INHERITED(expr) {
     }
 
     static GrGLSLExpr1 VectorCast(const GrGLSLExpr1& expr);
 
 private:
     GrGLSLExpr1(const char format[], const char in0[])
         : INHERITED(format, in0) {
     }
     GrGLSLExpr1(const char format[], const char in0[], const char in1[])
         : INHERITED(format, in0, in1) {
     }
 
     static const char* ZerosStr();
     static const char* OnesStr();
     static const char* CastStr();
     static const char* CastIntStr();
 
     friend GrGLSLExpr1 operator*(const GrGLSLExpr1& in0, const GrGLSLExpr1&in1);
     friend GrGLSLExpr1 operator+(const GrGLSLExpr1& in0, const GrGLSLExpr1&in1);
     friend GrGLSLExpr1 operator-(const GrGLSLExpr1& in0, const GrGLSLExpr1&in1);
 
+    template<typename T> friend T GrGLSL::min(const T& a, const T& b);
+    template<typename T> friend T GrGLSL::max(const T& a, const T& b);
+
     friend class GrGLSLExpr<GrGLSLExpr1>;
+    friend class GrGLSLExpr<GrGLSLExpr3>;
+    friend class GrGLSLExpr<GrGLSLExpr4>;
+    typedef GrGLSLExpr<GrGLSLExpr1> INHERITED;
+};
+
+class GrGLSLExpr3 : public GrGLSLExpr<GrGLSLExpr3> {
+public:
+    GrGLSLExpr3()
+        : INHERITED() {
+    }
+    explicit GrGLSLExpr3(int v)
+        : INHERITED(v) {
+    }
+    explicit GrGLSLExpr3(const char* expr)
+        : INHERITED(expr) {
+    }
+    explicit GrGLSLExpr3(const SkString& expr)
+        : INHERITED(expr) {
+    }
+
+    /** GLSL vec3 cast / constructor, eg vec3(floatv) -> vec3(floatv, floatv, floatv) */
+    static GrGLSLExpr3 VectorCast(const GrGLSLExpr1& expr);
+    static GrGLSLExpr3 VectorCast(const GrGLSLExpr3& expr);
+
+    GrGLSLExpr1 x() const;
+    GrGLSLExpr1 y() const;
+    GrGLSLExpr1 z() const;
+    GrGLSLExpr1 r() const;
+    GrGLSLExpr1 g() const;
+    GrGLSLExpr1 b() const;
+
+private:
+    GrGLSLExpr3(const char format[], const char in0[]) : INHERITED(format, in0) { }
+    GrGLSLExpr3(const char format[], const char in0[], const char in1[]): INHERITED(format, in0, in1) { }
+
+    static const char* ZerosStr();
+    static const char* OnesStr();
+    static const char* CastStr();
+    static const char* CastIntStr();
+
+    // The vector-by-scalar and scalar-by-vector binary operations.
+    friend GrGLSLExpr3 operator*(const GrGLSLExpr1& in0, const GrGLSLExpr3&in1);
+    friend GrGLSLExpr3 operator+(const GrGLSLExpr1& in0, const GrGLSLExpr3&in1);
+    friend GrGLSLExpr3 operator-(const GrGLSLExpr1& in0, const GrGLSLExpr3&in1);
+    friend GrGLSLExpr3 operator*(const GrGLSLExpr3& in0, const GrGLSLExpr1&in1);
+    friend GrGLSLExpr3 operator+(const GrGLSLExpr3& in0, const GrGLSLExpr1&in1);
+    friend GrGLSLExpr3 operator-(const GrGLSLExpr3& in0, const GrGLSLExpr1&in1);
+
+    // The vector-by-vector, i.e. component-wise, binary operations.
+    friend GrGLSLExpr3 operator*(const GrGLSLExpr3& in0, const GrGLSLExpr3&in1);
+    friend GrGLSLExpr3 operator+(const GrGLSLExpr3& in0, const GrGLSLExpr3&in1);
+    friend GrGLSLExpr3 operator-(const GrGLSLExpr3& in0, const GrGLSLExpr3&in1);
+
+    template<typename T> friend T GrGLSL::min(const T& a, const T& b);
+    template<typename T> friend T GrGLSL::max(const T& a, const T& b);
+
+    friend class GrGLSLExpr<GrGLSLExpr3>;
     friend class GrGLSLExpr<GrGLSLExpr4>;
 
-    typedef GrGLSLExpr<GrGLSLExpr1> INHERITED;
+    typedef GrGLSLExpr<GrGLSLExpr3> INHERITED;
 };
 
 /** Class representing a float vector (vec4) GLSL expression. */
 class GrGLSLExpr4 : public GrGLSLExpr<GrGLSLExpr4> {
 public:
     GrGLSLExpr4()
         : INHERITED() {
     }
     explicit GrGLSLExpr4(int v)
         : INHERITED(v) {
     }
-    GrGLSLExpr4(const char* expr)
+    explicit GrGLSLExpr4(const char* expr)
         : INHERITED(expr) {
     }
-    GrGLSLExpr4(const SkString& expr)
+    explicit GrGLSLExpr4(const SkString& expr)
         : INHERITED(expr) {
     }
 
+    GrGLSLExpr1 x() const;
+    GrGLSLExpr1 y() const;
+    GrGLSLExpr1 z() const;
+    GrGLSLExpr1 w() const;
+    GrGLSLExpr1 r() const;
+    GrGLSLExpr1 g() const;
+    GrGLSLExpr1 b() const;
     typedef GrGLSLExpr1 AExpr;
     AExpr a() const;
 
+    GrGLSLExpr3 xyz() const;
+    GrGLSLExpr3 rgb() const;
+
     /** GLSL vec4 cast / constructor, eg vec4(floatv) -> vec4(floatv, floatv, floatv, floatv) */
     static GrGLSLExpr4 VectorCast(const GrGLSLExpr1& expr);
     static GrGLSLExpr4 VectorCast(const GrGLSLExpr4& expr);
 
 private:
     GrGLSLExpr4(const char format[], const char in0[])
         : INHERITED(format, in0) {
     }
     GrGLSLExpr4(const char format[], const char in0[], const char in1[])
         : INHERITED(format, in0, in1) {
@@ skipping 10 matching lines @@
     friend GrGLSLExpr4 operator-(const GrGLSLExpr1& in0, const GrGLSLExpr4&in1);
     friend GrGLSLExpr4 operator*(const GrGLSLExpr4& in0, const GrGLSLExpr1&in1);
     friend GrGLSLExpr4 operator+(const GrGLSLExpr4& in0, const GrGLSLExpr1&in1);
     friend GrGLSLExpr4 operator-(const GrGLSLExpr4& in0, const GrGLSLExpr1&in1);
 
     // The vector-by-vector, i.e. component-wise, binary operations.
     friend GrGLSLExpr4 operator*(const GrGLSLExpr4& in0, const GrGLSLExpr4&in1);
     friend GrGLSLExpr4 operator+(const GrGLSLExpr4& in0, const GrGLSLExpr4&in1);
     friend GrGLSLExpr4 operator-(const GrGLSLExpr4& in0, const GrGLSLExpr4&in1);
 
+    template<typename T> friend T GrGLSL::min(const T& a, const T& b);
+    template<typename T> friend T GrGLSL::max(const T& a, const T& b);
+
     friend class GrGLSLExpr<GrGLSLExpr4>;
-
     typedef GrGLSLExpr<GrGLSLExpr4> INHERITED;
 };
 
+
 /**
  * Does an inplace mul, *=, of vec4VarName by mulFactor.
  * A semicolon and newline are added after the assignment.
  */
 void GrGLSLMulVarBy4f(SkString* outAppend, unsigned tabCnt,
                       const char* vec4VarName, const GrGLSLExpr4& mulFactor);
 
 #include "GrGLSL_impl.h"
 
 #endif