GrShaderVar.h

/*
 * Copyright 2014 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 "GrTypesPriv.h"
#include "SkString.h"

class GrShaderVar {
public:
    enum TypeModifier {
        kNone_TypeModifier,
        kOut_TypeModifier,
        kIn_TypeModifier,
        kInOut_TypeModifier,
        kUniform_TypeModifier,
        // GL Specific types below
        kAttribute_TypeModifier,
        kVaryingIn_TypeModifier,
        kVaryingOut_TypeModifier
    };

    GrShaderVar()
        : fType(kFloat_GrSLType)
        , fTypeModifier(kNone_TypeModifier)
        , fCount(kNonArray)
        , fPrecision(kDefault_GrSLPrecision) {
    }

    GrShaderVar(const SkString& name, GrSLType type, int arrayCount = kNonArray,
                GrSLPrecision precision = kDefault_GrSLPrecision)
        : fType(type)
        , fTypeModifier(kNone_TypeModifier)
        , fName(name)
        , fCount(arrayCount)
        , fPrecision(precision) {
        SkASSERT(kVoid_GrSLType != type);
    }

    GrShaderVar(const char* name, GrSLType type, int arrayCount = kNonArray,
                GrSLPrecision precision = kDefault_GrSLPrecision)
        : fType(type)
        , fTypeModifier(kNone_TypeModifier)
        , fName(name)
        , fCount(arrayCount)
        , fPrecision(precision) {
        SkASSERT(kVoid_GrSLType != type);
    }

    GrShaderVar(const char* name, GrSLType type, TypeModifier typeModifier,
                int arrayCount = kNonArray, GrSLPrecision precision = kDefault_GrSLPrecision)
        : fType(type)
        , fTypeModifier(typeModifier)
        , fName(name)
        , fCount(arrayCount)
        , fPrecision(precision) {
        SkASSERT(kVoid_GrSLType != type);
    }

    enum {
        kNonArray     =  0, // not an array
        kUnsizedArray = -1, // an unsized array (declared with [])
    };

    void set(GrSLType type,
             const SkString& name,
             TypeModifier typeModifier = kNone_TypeModifier,
             GrSLPrecision precision = kDefault_GrSLPrecision,
             int count = kNonArray) {
        SkASSERT(kVoid_GrSLType != type);
        fType = type;
        fTypeModifier = typeModifier;
        fName = name;
        fCount = count;
        fPrecision = precision;
    }

    void set(GrSLType type,
             const char* name,
             TypeModifier typeModifier = kNone_TypeModifier,
             GrSLPrecision precision = kDefault_GrSLPrecision,
             int count = kNonArray) {
        SkASSERT(kVoid_GrSLType != type);
        fType = type;
        fTypeModifier = typeModifier;
        fName = name;
        fCount = count;
        fPrecision = precision;
    }

    bool isArray() const { return kNonArray != fCount; }
    bool isUnsizedArray() const { return kUnsizedArray == fCount; }
    int getArrayCount() const { return fCount; }
    void setArrayCount(int count) { fCount = count; }
    void setNonArray() { fCount = kNonArray; }
    void setUnsizedArray() { fCount = kUnsizedArray; }

    SkString* accessName() { return &fName; }
    void setName(const SkString& n) { fName = n; }
    void setName(const char* n) { fName = n; }

    const SkString& getName() const { return fName; }

    const char* c_str() const { return this->getName().c_str(); }

    GrSLType getType() const { return fType; }
    void setType(GrSLType type) { fType = type; }

    TypeModifier getTypeModifier() const { return fTypeModifier; }
    void setTypeModifier(TypeModifier type) { fTypeModifier = type; }

    GrSLPrecision getPrecision() const { return fPrecision; }

    void setPrecision(GrSLPrecision p) { fPrecision = p; }

protected:
    GrSLType        fType;
    TypeModifier    fTypeModifier;
    SkString        fName;
    int             fCount;
    GrSLPrecision   fPrecision;
};

#endif