Remove two more gpu headers from include/*

This is probably it until GrTexture.h can be hidden.

TBR=bsalomon@google.com

Change-Id: Ie743c937f72aa0dc9f5e84def572f655f0abe041
Reviewed-on: https://skia-review.googlesource.com/14143
Reviewed-by: Brian Osman <brianosman@google.com>
Commit-Queue: Robert Phillips <robertphillips@google.com>

1 files changed, 334 insertions, 0 deletions

diff --git a/src/gpu/GrShaderVar.h b/src/gpu/GrShaderVar.h
new file mode 100644
index 0000000000..7f09f8cbf7
--- /dev/null
+++ b/src/gpu/GrShaderVar.h
@@ -0,0 +1,334 @@
+/*
+ * Copyright 2016 Google Inc.
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#ifndef GrShaderVar_DEFINED
+#define GrShaderVar_DEFINED
+
+#include "SkString.h"
+#include "GrTypesPriv.h"
+
+class GrShaderCaps;
+
+#define USE_UNIFORM_FLOAT_ARRAYS true
+
+/**
+ * Represents a variable in a shader
+ */
+class GrShaderVar {
+public:
+    enum TypeModifier {
+        kNone_TypeModifier,
+        kOut_TypeModifier,
+        kIn_TypeModifier,
+        kInOut_TypeModifier,
+        kUniform_TypeModifier,
+    };
+
+    /**
+     * Values for array count that have special meaning. We allow 1-sized arrays.git 
+     */
+    enum {
+        kNonArray     =  0, // not an array
+        kUnsizedArray = -1, // an unsized array (declared with [])
+    };
+
+    /**
+     * Defaults to a non-arry float with no precision specifier, type modifier, or layout qualifier.
+     */
+    GrShaderVar()
+        : fType(kFloat_GrSLType)
+        , fTypeModifier(kNone_TypeModifier)
+        , fCount(kNonArray)
+        , fPrecision(kDefault_GrSLPrecision)
+        , fUseUniformFloatArrays(USE_UNIFORM_FLOAT_ARRAYS) {
+    }
+
+    GrShaderVar(const SkString& name, GrSLType type, int arrayCount = kNonArray,
+                GrSLPrecision precision = kDefault_GrSLPrecision)
+        : fType(type)
+        , fTypeModifier(kNone_TypeModifier)
+        , fCount(arrayCount)
+        , fPrecision(precision)
+        , fUseUniformFloatArrays(USE_UNIFORM_FLOAT_ARRAYS)
+        , fName(name) {
+        SkASSERT(kVoid_GrSLType != type);
+        fUseUniformFloatArrays = USE_UNIFORM_FLOAT_ARRAYS;
+    }
+
+    GrShaderVar(const char* name, GrSLType type, int arrayCount = kNonArray,
+                GrSLPrecision precision = kDefault_GrSLPrecision)
+        : fType(type)
+        , fTypeModifier(kNone_TypeModifier)
+        , fCount(arrayCount)
+        , fPrecision(precision)
+        , fUseUniformFloatArrays(USE_UNIFORM_FLOAT_ARRAYS)
+        , fName(name) {
+        SkASSERT(kVoid_GrSLType != type);
+        fUseUniformFloatArrays = USE_UNIFORM_FLOAT_ARRAYS;
+    }
+
+    GrShaderVar(const char* name, GrSLType type, TypeModifier typeModifier,
+                GrSLPrecision precision = kDefault_GrSLPrecision)
+        : fType(type)
+        , fTypeModifier(typeModifier)
+        , fCount(kNonArray)
+        , fPrecision(precision)
+        , fUseUniformFloatArrays(USE_UNIFORM_FLOAT_ARRAYS)
+        , fName(name) {
+        SkASSERT(kVoid_GrSLType != type);
+    }
+
+    GrShaderVar(const char* name, GrSLType type, TypeModifier typeModifier,
+                int arrayCount, GrSLPrecision precision = kDefault_GrSLPrecision)
+        : fType(type)
+        , fTypeModifier(typeModifier)
+        , fCount(arrayCount)
+        , fPrecision(precision)
+        , fUseUniformFloatArrays(USE_UNIFORM_FLOAT_ARRAYS)
+        , fName(name) {
+        SkASSERT(kVoid_GrSLType != type);
+    }
+
+    GrShaderVar(const GrShaderVar& that)
+        : fType(that.fType)
+        , fTypeModifier(that.fTypeModifier)
+        , fCount(that.fCount)
+        , fPrecision(that.fPrecision)
+        , fUseUniformFloatArrays(USE_UNIFORM_FLOAT_ARRAYS)
+        , fName(that.fName)
+        , fLayoutQualifier(that.fLayoutQualifier)
+        , fExtraModifiers(that.fExtraModifiers) {
+        SkASSERT(kVoid_GrSLType != that.getType());
+    }
+
+    /**
+     * Sets as a non-array.
+     */
+    void set(GrSLType type,
+             const SkString& name,
+             TypeModifier typeModifier = kNone_TypeModifier,
+             GrSLPrecision precision = kDefault_GrSLPrecision,
+             const char* layoutQualifier = nullptr,
+             const char* extraModifiers = nullptr,
+             bool useUniformFloatArrays = USE_UNIFORM_FLOAT_ARRAYS) {
+        SkASSERT(kVoid_GrSLType != type);
+        SkASSERT(kDefault_GrSLPrecision == precision || GrSLTypeAcceptsPrecision(type));
+        fType = type;
+        fTypeModifier = typeModifier;
+        fName = name;
+        fCount = kNonArray;
+        fPrecision = precision;
+        fLayoutQualifier = layoutQualifier;
+        if (extraModifiers) {
+            fExtraModifiers.printf("%s ", extraModifiers);
+        }
+        fUseUniformFloatArrays = useUniformFloatArrays;
+    }
+
+    /**
+     * Sets as a non-array.
+     */
+    void set(GrSLType type,
+             const char* name,
+             TypeModifier typeModifier = kNone_TypeModifier,
+             GrSLPrecision precision = kDefault_GrSLPrecision,
+             const char* layoutQualifier = nullptr,
+             const char* extraModifiers = nullptr,
+             bool useUniformFloatArrays = USE_UNIFORM_FLOAT_ARRAYS) {
+        SkASSERT(kVoid_GrSLType != type);
+        SkASSERT(kDefault_GrSLPrecision == precision || GrSLTypeAcceptsPrecision(type));
+        fType = type;
+        fTypeModifier = typeModifier;
+        fName = name;
+        fCount = kNonArray;
+        fPrecision = precision;
+        fLayoutQualifier = layoutQualifier;
+        if (extraModifiers) {
+            fExtraModifiers.printf("%s ", extraModifiers);
+        }
+        fUseUniformFloatArrays = useUniformFloatArrays;
+    }
+
+    /**
+     * Set all var options
+     */
+    void set(GrSLType type,
+             const SkString& name,
+             int count,
+             TypeModifier typeModifier,
+             GrSLPrecision precision = kDefault_GrSLPrecision,
+             const char* layoutQualifier = nullptr,
+             const char* extraModifiers = nullptr,
+             bool useUniformFloatArrays = USE_UNIFORM_FLOAT_ARRAYS) {
+        SkASSERT(kVoid_GrSLType != type);
+        SkASSERT(kDefault_GrSLPrecision == precision || GrSLTypeAcceptsPrecision(type));
+        fType = type;
+        fTypeModifier = typeModifier;
+        fName = name;
+        fCount = count;
+        fPrecision = precision;
+        fLayoutQualifier = layoutQualifier;
+        if (extraModifiers) {
+            fExtraModifiers.printf("%s ", extraModifiers);
+        }
+        fUseUniformFloatArrays = useUniformFloatArrays;
+    }
+
+    /**
+     * Set all var options
+     */
+    void set(GrSLType type,
+             const char* name,
+             int count,
+             TypeModifier typeModifier,
+             GrSLPrecision precision = kDefault_GrSLPrecision,
+             const char* layoutQualifier = nullptr,
+             const char* extraModifiers = nullptr,
+             bool useUniformFloatArrays = USE_UNIFORM_FLOAT_ARRAYS) {
+        SkASSERT(kVoid_GrSLType != type);
+        SkASSERT(kDefault_GrSLPrecision == precision || GrSLTypeAcceptsPrecision(type));
+        fType = type;
+        fTypeModifier = typeModifier;
+        fName = name;
+        fCount = count;
+        fPrecision = precision;
+        fLayoutQualifier = layoutQualifier;
+        if (extraModifiers) {
+            fExtraModifiers.printf("%s ", extraModifiers);
+        }
+        fUseUniformFloatArrays = useUniformFloatArrays;
+    }
+
+    /**
+     * Is the var an array.
+     */
+    bool isArray() const { return kNonArray != fCount; }
+    /**
+     * Is this an unsized array, (i.e. declared with []).
+     */
+    bool isUnsizedArray() const { return kUnsizedArray == fCount; }
+    /**
+     * Get the array length of the var.
+     */
+    int getArrayCount() const { return fCount; }
+    /**
+     * Set the array length of the var
+     */
+    void setArrayCount(int count) { fCount = count; }
+    /**
+     * Set to be a non-array.
+     */
+    void setNonArray() { fCount = kNonArray; }
+    /**
+     * Set to be an unsized array.
+     */
+    void setUnsizedArray() { fCount = kUnsizedArray; }
+
+    /**
+     * Access the var name as a writable string
+     */
+    SkString* accessName() { return &fName; }
+    /**
+     * Set the var name
+     */
+    void setName(const SkString& n) { fName = n; }
+    void setName(const char* n) { fName = n; }
+
+    /**
+     * Get the var name.
+     */
+    const SkString& getName() const { return fName; }
+
+    /**
+     * Shortcut for this->getName().c_str();
+     */
+    const char* c_str() const { return this->getName().c_str(); }
+
+    /**
+     * Get the type of the var
+     */
+    GrSLType getType() const { return fType; }
+    /**
+     * Set the type of the var
+     */
+    void setType(GrSLType type) { fType = type; }
+
+    TypeModifier getTypeModifier() const { return fTypeModifier; }
+    void setTypeModifier(TypeModifier type) { fTypeModifier = type; }
+
+    /**
+     * Get the precision of the var
+     */
+    GrSLPrecision getPrecision() const { return fPrecision; }
+
+    /**
+     * Set the precision of the var
+     */
+    void setPrecision(GrSLPrecision p) { fPrecision = p; }
+
+    /**
+     * Appends to the layout qualifier
+     */
+    void addLayoutQualifier(const char* layoutQualifier) {
+        if (!layoutQualifier || !strlen(layoutQualifier)) {
+            return;
+        }
+        if (fLayoutQualifier.isEmpty()) {
+            fLayoutQualifier = layoutQualifier;
+        } else {
+            fLayoutQualifier.appendf(", %s", layoutQualifier);
+        }
+    }
+
+    void setImageStorageFormat(GrImageStorageFormat format);
+
+    void setMemoryModel(GrSLMemoryModel);
+
+    void setRestrict(GrSLRestrict);
+
+    void setIOType(GrIOType);
+
+    void addModifier(const char* modifier) {
+        if (modifier) {
+            fExtraModifiers.appendf("%s ", modifier);
+        }
+    }
+
+    /**
+     * Write a declaration of this variable to out.
+     */
+    void appendDecl(const GrShaderCaps*, SkString* out) const;
+
+    void appendArrayAccess(int index, SkString* out) const {
+        out->appendf("%s[%d]%s",
+                     this->getName().c_str(),
+                     index,
+                     fUseUniformFloatArrays ? "" : ".x");
+    }
+
+    void appendArrayAccess(const char* indexName, SkString* out) const {
+        out->appendf("%s[%s]%s",
+                     this->getName().c_str(),
+                     indexName,
+                     fUseUniformFloatArrays ? "" : ".x");
+    }
+
+private:
+    GrSLType        fType;
+    TypeModifier    fTypeModifier;
+    int             fCount;
+    GrSLPrecision   fPrecision;
+    /// Work around driver bugs on some hardware that don't correctly
+    /// support uniform float []
+    bool            fUseUniformFloatArrays;
+
+    SkString        fName;
+    SkString        fLayoutQualifier;
+    SkString        fExtraModifiers;
+};
+
+#endif