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

#include "gl/GrGLInterface.h"
#include "GrColor.h"
#include "GrTypesPriv.h"

class GrGLContextInfo;
class GrGLShaderVar;
class SkString;

// Limited set of GLSL versions we build shaders for. Caller should round
// down the GLSL version to one of these enums.
enum GrGLSLGeneration {
    /**
     * Desktop GLSL 1.10 and ES2 shading language (based on desktop GLSL 1.20)
     */
    k110_GrGLSLGeneration,
    /**
     * Desktop GLSL 1.30
     */
    k130_GrGLSLGeneration,
    /**
     * Desktop GLSL 1.40
     */
    k140_GrGLSLGeneration,
    /**
     * Desktop GLSL 1.50
     */
    k150_GrGLSLGeneration,
};

enum GrSLConstantVec {
    kZeros_GrSLConstantVec,
    kOnes_GrSLConstantVec,
    kNone_GrSLConstantVec,
};

namespace {
static inline int GrSLTypeToVecLength(GrSLType type) {
    static const int kVecLengths[] = {
        0, // kVoid_GrSLType
        1, // kFloat_GrSLType
        2, // kVec2f_GrSLType
        3, // kVec3f_GrSLType
        4, // kVec4f_GrSLType
        1, // kMat33f_GrSLType
        1, // kMat44f_GrSLType
        1, // kSampler2D_GrSLType
    };
    GR_STATIC_ASSERT(kGrSLTypeCount == GR_ARRAY_COUNT(kVecLengths));
    return kVecLengths[type];
}

static inline const char* GrGLSLOnesVecf(int count) {
    static const char* kONESVEC[] = {"ERROR", "1.0", "vec2(1,1)",
                                     "vec3(1,1,1)", "vec4(1,1,1,1)"};
    SkASSERT(count >= 1 && count < (int)GR_ARRAY_COUNT(kONESVEC));
    return kONESVEC[count];
}

static inline const char* GrGLSLZerosVecf(int count) {
    static const char* kZEROSVEC[] = {"ERROR", "0.0", "vec2(0,0)",
                                      "vec3(0,0,0)", "vec4(0,0,0,0)"};
    SkASSERT(count >= 1 && count < (int)GR_ARRAY_COUNT(kZEROSVEC));
    return kZEROSVEC[count];
}
}

/**
 * Gets the most recent GLSL Generation compatible with the OpenGL context.
 */
GrGLSLGeneration GrGetGLSLGeneration(GrGLBinding binding,
                                     const GrGLInterface* gl);

/**
 * Returns a string to include at the beginning of a shader to declare the GLSL
 * version.
 */
const char* GrGetGLSLVersionDecl(const GrGLContextInfo&);

/**
 * Depending on the GLSL version being emitted there may be an assumed output
 * variable from the fragment shader for the color. Otherwise, the shader must
 * declare an output variable for the color. If this function returns true:
 *    * Parameter var's name will be set to nameIfDeclared
 *    * The variable must be declared in the fragment shader
 *    * The variable has to be bound as the color output
 *      (using glBindFragDataLocation)
 *    If the function returns false:
 *    * Parameter var's name will be set to the GLSL built-in color output name.
 *    * Do not declare the variable in the shader.
 *    * Do not use glBindFragDataLocation to bind the variable
 * In either case var is initialized to represent the color output in the
 * shader.
 */
bool GrGLSLSetupFSColorOuput(GrGLSLGeneration gen,
                             const char* nameIfDeclared,
                             GrGLShaderVar* var);
/**
 * Converts a GrSLType to a string containing the name of the equivalent GLSL type.
 */
static const char* GrGLSLTypeString(GrSLType t) {
    switch (t) {
        case kVoid_GrSLType:
            return "void";
        case kFloat_GrSLType:
            return "float";
        case kVec2f_GrSLType:
            return "vec2";
        case kVec3f_GrSLType:
            return "vec3";
        case kVec4f_GrSLType:
            return "vec4";
        case kMat33f_GrSLType:
            return "mat3";
        case kMat44f_GrSLType:
            return "mat4";
        case kSampler2D_GrSLType:
            return "sampler2D";
        default:
            GrCrash("Unknown shader var type.");
            return ""; // suppress warning
    }
}

/** Return the type enum for a vector of floats of length n (1..4),
    e.g. 1 -> "float", 2 -> "vec2", ... */
static inline const char* GrGLSLFloatVectorTypeString(int n) {
    return GrGLSLTypeString(GrSLFloatVectorType(n));
}

/** Return the GLSL swizzle operator for a homogenous component of a vector
    with the given number of coordinates, e.g. 2 -> ".y", 3 -> ".z" */
const char* GrGLSLVectorHomogCoord(int count);
const char* GrGLSLVectorHomogCoord(GrSLType type);

/** Return the GLSL swizzle operator for a nonhomogenous components of a vector
    with the given number of coordinates, e.g. 2 -> ".x", 3 -> ".xy" */
const char* GrGLSLVectorNonhomogCoords(int count);
const char* GrGLSLVectorNonhomogCoords(GrSLType type);

/**
  * Produces a string that is the result of modulating two inputs. The inputs must be vecN or
  * float. The result is always a vecN. The inputs may be expressions, not just identifier names.
  * Either can be NULL or "" in which case the default params control whether a vector of ones or
  * zeros. It is an error to pass kNone for default<i> if in<i> is NULL or "". Note that when the
  * function determines that the result is a zeros or ones vec then any expression represented by
  * or in1 will not be emitted (side effects won't occur). The return value indicates whether a
  * known zeros or ones vector resulted. The output can be suppressed when known vector is produced
  * by passing true for omitIfConstVec.
  */
template <int N>
GrSLConstantVec GrGLSLModulatef(SkString* outAppend,
                                const char* in0,
                                const char* in1,
                                GrSLConstantVec default0 = kOnes_GrSLConstantVec,
                                GrSLConstantVec default1 = kOnes_GrSLConstantVec,
                                bool omitIfConstVec = false);

/**
 * Produces a string that is the result of adding two inputs. The inputs must be vecN or
 * float. The result is always a vecN. The inputs may be expressions, not just identifier names.
 * Either can be NULL or "" in which case the default params control whether a vector of ones or
 * zeros. It is an error to pass kNone for default<i> if in<i> is NULL or "". Note that when the
 * function determines that the result is a zeros or ones vec then any expression represented by
 * or in1 will not be emitted (side effects won't occur). The return value indicates whether a
 * known zeros or ones vector resulted. The output can be suppressed when known vector is produced
 * by passing true for omitIfConstVec.
 */
template <int N>
GrSLConstantVec GrGLSLAddf(SkString* outAppend,
                           const char* in0,
                           const char* in1,
                           GrSLConstantVec default0 = kZeros_GrSLConstantVec,
                           GrSLConstantVec default1 = kZeros_GrSLConstantVec,
                           bool omitIfConstVec = false);

/**
 * Produces a string that is the result of subtracting two inputs. The inputs must be vecN or
 * float. The result is always a vecN. The inputs may be expressions, not just identifier names.
 * Either can be NULL or "" in which case the default params control whether a vector of ones or
 * zeros. It is an error to pass kNone for default<i> if in<i> is NULL or "". Note that when the
 * function determines that the result is a zeros or ones vec then any expression represented by
 * or in1 will not be emitted (side effects won't occur). The return value indicates whether a
 * known zeros or ones vector resulted. The output can be suppressed when known vector is produced
 * by passing true for omitIfConstVec.
 */
template <int N>
GrSLConstantVec GrGLSLSubtractf(SkString* outAppend,
                                const char* in0,
                                const char* in1,
                                GrSLConstantVec default0 = kZeros_GrSLConstantVec,
                                GrSLConstantVec default1 = kZeros_GrSLConstantVec,
                                bool omitIfConstVec = false);

/**
 * Does an inplace mul, *=, of vec4VarName by mulFactor. If mulFactorDefault is not kNone then
 * mulFactor may be either "" or NULL. In this case either nothing will be appended (kOnes) or an
 * assignment of vec(0,0,0,0) will be appended (kZeros). The assignment is prepended by tabCnt tabs.
 * A semicolon and newline are added after the assignment. (TODO: Remove tabCnt when we auto-insert
 * tabs to GrGLEffect-generated lines.) If a zeros vec is assigned then the return value is
 * kZeros, otherwise kNone.
 */
GrSLConstantVec GrGLSLMulVarBy4f(SkString* outAppend,
                                 int tabCnt,
                                 const char* vec4VarName,
                                 const char* mulFactor,
                                 GrSLConstantVec mulFactorDefault = kOnes_GrSLConstantVec);

/**
 * Given an expression that evaluates to a GLSL vec4, extract a component. If expr is NULL or ""
 * the value of defaultExpr is used. It is an error to pass an empty expr and have set defaultExpr
 * to kNone. The return value indicates whether the value is known to be 0 or 1. If omitIfConst is
 * set then nothing is appended when the return is not kNone.
 */
GrSLConstantVec GrGLSLGetComponent4f(SkString* outAppend,
                                     const char* expr,
                                     GrColorComponentFlags component,
                                     GrSLConstantVec defaultExpr = kNone_GrSLConstantVec,
                                     bool omitIfConst = false);

#include "GrGLSL_impl.h"

#endif