RE/RE_Shader.h

Go to the documentation of this file.

/*
 * PROPRIETARY INFORMATION.  This software is proprietary to
 * Side Effects Software Inc., and is not to be reproduced,
 * transmitted, or disclosed in any way without written permission.
 *
 * Produced by:
 *      Mark Elendt
 *      Side Effects
 *      477 Richmond Street West
 *      Toronto, Ontario
 *      Canada   M5V 3E7
 *      416-504-9876
 *
 * NAME:        Render Library (C++)
 *
 * COMMENTS:
 *     OpenGL GLSL/Cg Shader base definition. Abstracts the difference
 *     between the two.
 *
 */
#ifndef __RE_Shader__
#define __RE_Shader__

#include "RE_API.h"

#include <UT/UT_HashTable.h>
#include <UT/UT_IntArray.h>
#include <UT/UT_String.h>
#include <UT/UT_PtrArray.h>
#include "RE_Uniform.h"

class RE_Render;

class RE_API RE_Shader
{
public:
                 RE_Shader();
    virtual     ~RE_Shader();

    const char  *getName()              { return myShaderName; }
    int          getProgram() const     { return myProgramObject; }
    
    virtual void  applyShader() const = 0;
    virtual void  removeShader() =  0;

    // loadPrograms() loads the frag & vertex shaders from ASCII files.
    // setPrograms() is used when the source is already available.
    // 'messages' returns the warnings & errors (if any) from shader
    // compilation.
    bool         loadPrograms(const char *english_name,
                              const char *vtxFile,
                              const char *fragFile,
                              UT_String *messages = NULL);
    
    virtual bool setPrograms(const char *english_name,
                             const char *vtxShader,
                             const char *fragShader,
                             UT_String *messages = NULL) = 0;
    virtual void clearPrograms() = 0; 

    // Bind a texture map using named textures in TIL_TextureMap. You can also
    // bind a texture with its raw OpenGL ID using bindVariableInt().
    virtual int  bindTextureMap(const char *name,
                                const char *tmap,
                                const char *relativeTo) = 0;
    virtual bool bindTextureMap(const char *name, int tex_id, int tex_unit) = 0;

    // You can bind arrays if array_size > 1. Note that you need to define the
    // uniform as 'uniform <type> <name>[];'.

    // Integer scalar & vectors.
    virtual bool         bindVariableInt(const char *name, const int *val,
                                         int array_size=1)=0;
    virtual bool         bindVariableInt2(const char *name, const int *val,
                                          int array_size=1)=0;
    virtual bool         bindVariableInt3(const char *name, const int *val,
                                          int array_size=1)=0;
    virtual bool         bindVariableInt4(const char *name, const int *val,
                                          int array_size=1)=0;

    // Floating point scalar & vectors
    virtual bool         bindVariable1(const char *name, const float *val,
                                       int array_size=1)=0;
    virtual bool         bindVariable2(const char *name, const float *val,
                                       int array_size=1)=0;
    virtual bool         bindVariable3(const char *name, const float *val,
                                       int array_size=1)=0;
    virtual bool         bindVariable4(const char *name, const float *val,
                                       int array_size=1)=0;

    // Matrices.
    virtual bool         bindMatrix2(const char *name, const float *val,
                                     int array_size=1)=0;
    virtual bool         bindMatrix3(const char *name, const float *val,
                                     int array_size=1)=0;
    virtual bool         bindMatrix4(const char *name, const float *val,
                                     int array_size=1) =0;

    // Bind an RE_Uniform to this shader.  If 'uniform' is an array uniform
    // then 'index' specifies which array element to bind.  'index' must be
    // less than uniform->getSize().  Pass -1 for 'index' (the default) to
    // bind all elements of an array; passing -1 for non-arrays is safe and
    // is equivalent to passing 0.
    virtual bool         bindUniform(const RE_Uniform *uniform, int index = -1);

    bool                 hasShaderAttribs() const
                           { return myAttribNames.entries() > 0; }
    const UT_StringList &getShaderAttribNames() const
                           { return myAttribNames; }
    const UT_IntArray   &getShaderAttribLocations() const
                           { return myAttribLocations; }
    const UT_IntArray   &getShaderAttribSizes() const
                           { return myAttribSizes; }

    virtual void         loadShaderTexMaps(RE_Render *) = 0;

    // Returns true if this shader has the specified built-in uniform.
    // 'uniform' must be an RE_UniformBuiltIn.  Note that certain
    // built-in uniforms may only be supported for certain languages.
    virtual bool         hasBuiltInUniform(RE_UniformBuiltIn uniform) const;

    // Returns the RE_Shader object with the specified program object if it
    // exists; otherwise, returns NULL.
    static RE_Shader    *getShader(int program_object);
    
protected:
    // Get the index of an attribute or uniform based on its name.  The
    // returned index can be used to look up corresponding elements in
    // the myAttrib*s arrays or the myUniform*s arrays, respectively.
    virtual int          getAttributeIndex(const char *name);
    virtual int          getUniformIndex(const char *name);

    virtual bool         loadShaderAttribNames() = 0;
    virtual bool         loadShaderUniformNames() = 0;
    
    // Creates/destroys a mapping from the specified program id to this shader
    // in the shader table.
    virtual void         registerProgram(int program_object);
    virtual void         unregisterProgram(int program_object);

    // Store program object -> RE_Shader* mappings.
    static UT_HashTable  theShaderTable;

    UT_String            myShaderName;
    int                  myProgramObject;
    
    int                  myVertexShaderObject, myFragmentShaderObject;
    UT_String            myVertexShaderSource, myFragmentShaderSource;

    UT_StringList        myAttribNames;
    UT_IntArray          myAttribLocations;
    UT_IntArray          myAttribSizes;
    UT_StringList        myUniformNames;
    UT_IntArray          myUniformArraySizes;
    UT_IntArray          myUniformTypes;
    UT_IntArray          myBuiltInUniforms;
};
#endif

---