RE/RE_Uniform.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:
 * Ian Kerr
 *      Side Effects Software Inc
 *      123 Front Street West, Suite 1401
 *      Toronto, Ontario
 *      Canada   M5J 2M2
 *      416-504-9876
 *
 * NAME:        RE_Uniform.h (Library, C++)
 *
 * COMMENTS:
 */

#ifndef __RE_Uniform__
#define __RE_Uniform__

#include "RE_API.h"

#include <UT/UT_HashTable.h>
#include <UT/UT_String.h>

class RE_Render;

enum RE_UniformLanguage
{
    RE_UNIFORM_CG               = 1,
    RE_UNIFORM_GLSL             = 1 << 1,
    RE_UNIFORM_ALL_LANGUAGES    = ~0
};

// The members of this enumeration are used as indices into
// re_BuiltInUniform::theUniforms.  Thus, changing this enumeration requires
// updating re_BuiltInUniform::theUniforms.
enum RE_UniformBuiltIn
{
    RE_UNIFORM_EMISSION = 0,
    RE_UNIFORM_SPECULAR,
    RE_UNIFORM_DIFFUSE,
    RE_UNIFORM_AMBIENT,
    RE_UNIFORM_MATERIAL_PASS,
    RE_UNIFORM_MAT_GHOST,
    RE_UNIFORM_LIGHT_ENABLED,
    RE_UNIFORM_LIGHT_MASK,
    RE_UNIFORM_INV_VIEW_MATRIX,
    RE_UNIFORM_VIEW_MATRIX,
    RE_UNIFORM_OBJECT_MATRIX,
    RE_UNIFORM_SCREEN_SIZE,
    RE_UNIFORM_DEPTH_PEEL_ENABLE,
    RE_UNIFORM_DEPTH_PEEL_MAP,
    RE_UNIFORM_ALPHA_PASS,
    RE_UNIFORM_BUILT_IN__count
};

// For RE_Render::bindBuiltInUniforms().
enum RE_UniformBinding
{
    RE_UNIFORM_BIND_ALL,
    RE_UNIFORM_BIND_DISPLAY_LIST_INDEPENDENT,
    RE_UNIFORM_BIND_DISPLAY_LIST_DEPENDENT
};

// RE_Uniform::typeTypeSizes expects this ordering.  If you modify this
// enumeration, make sure that you also modify 'theTypeSizes' initialization.
enum RE_UniformType
{
    RE_UNIFORM_FLOAT,
    RE_UNIFORM_FLOAT_VEC2,
    RE_UNIFORM_FLOAT_VEC3,
    RE_UNIFORM_FLOAT_VEC4,
    RE_UNIFORM_DOUBLE,
    RE_UNIFORM_DOUBLE_VEC2,
    RE_UNIFORM_DOUBLE_VEC3,
    RE_UNIFORM_DOUBLE_VEC4,
    RE_UNIFORM_INT,
    RE_UNIFORM_INT_VEC2,
    RE_UNIFORM_INT_VEC3,
    RE_UNIFORM_INT_VEC4,
    RE_UNIFORM_FLOAT_MAT2,
    RE_UNIFORM_FLOAT_MAT3,
    RE_UNIFORM_FLOAT_MAT4,
    RE_UNIFORM_DOUBLE_MAT2,
    RE_UNIFORM_DOUBLE_MAT3,
    RE_UNIFORM_DOUBLE_MAT4,
    RE_UNIFORM_SAMPLER_1D,
    RE_UNIFORM_SAMPLER_2D,
    RE_UNIFORM_SAMPLER_3D,
    RE_UNIFORM_SAMPLER_CUBE,
    RE_UNIFORM_SAMPLER_RECTANGLE,
    RE_UNIFORM_SAMPLER_1D_ARRAY,
    RE_UNIFORM_SAMPLER_2D_ARRAY,
    RE_UNIFORM_SAMPLER_2D_MULTISAMPLE,
    RE_UNIFORM_SAMPLER_2D_SHADOW,
    RE_UNIFORM_TYPE__count
};

class RE_API RE_Uniform
{
public:
    // 'size' is the array size.
    RE_Uniform(const UT_String &name, RE_UniformType type, int size);
    RE_Uniform(RE_UniformBuiltIn built_in, int size);
    virtual ~RE_Uniform();

    // Removes the array subscript "[]" from the end of 'name' if there is one
    // and stores the result in 'out'.
    static void                  getArrayNameAndIndex(const char *str,
                                                      UT_String &name_out,
                                                      int *index_out);

    // Appends an array subscript to the name of this uniform and stores the
    // result in 'out'.  Only call this method for array uniforms.
    virtual void                 getIndexedName(int index, UT_String &out)const;

    virtual const UT_String     &getName() const { return myName; }

    // getSize() returns the array size or 1 if this uniform is not an array.
    // Note that GLSL allows arrays of size 1 so this method cannot be used
    // to determine whether or not this uniform is an array.
    virtual int                  getSize() const { return mySize; }
    virtual RE_UniformType       getType() const { return myType; }

    // Get/set the value of this uniform.  If this uniform is an array
    // then 'index' specifies which array element value to return/set;
    // otherwise, its ignored.
    virtual const void          *getValue(int index=0) const;
    virtual void                 setValue(const void *value, int index=0);

    // The version is incremented whenever the value of this uniform is
    // changed.  The version starts at 0.
    virtual int                  getVersion() const { return myVersion; }

    // Returns an element of RE_UniformBuiltIn if the specified uniform's
    // type, size, and name match the RE_UniformBuiltIn's type, size, and
    // name and the uniform is supported for the specified language; otherwise,
    // returns -1.
    static int                   getBuiltIn(const RE_Uniform *uniform,
                                            int languages =
                                                RE_UNIFORM_ALL_LANGUAGES);
    static int                   getBuiltIn(const UT_String &name,
                                            RE_UniformType type,
                                            int languages =
                                                RE_UNIFORM_ALL_LANGUAGES);

    // Static member functions for retrieving information about built-in
    // uniforms.
    static const char           *getBuiltInName(RE_UniformBuiltIn built_in);
    static RE_UniformType        getBuiltInType(RE_UniformBuiltIn built_in);
    static int                   isDisplayListDependent(RE_UniformBuiltIn  built_in);

    // Specify that a given uniform object should represent a given built-in
    // uniform.  After a built-in has been registered, calling getBuiltIn(int)
    // returns the registered uniform object.  By specifying a uniform object
    // when calling unregisterBuilInt(), the built-in will only be unregistered
    // if the currently registered uniform object matches the specified object.
    static void                  registerBuiltIn(RE_Render *r,
                                                 RE_UniformBuiltIn  built_in,
                                                 const RE_Uniform *uniform);

    // A convenience version for single-index variables. 'data' must match the
    // uniform's data type.
    static void                  assignBuiltIn(RE_Render *r,
                                               RE_UniformBuiltIn built_in,
                                               const void *data);

    // Remove the uniform. If registerBuiltIn was called, the unform is unbound
    // only. If assignBuiltIn was called, the uniform is unbound and deleted.
    static void                  unregisterBuiltIn(RE_Render *r,
                                                   RE_UniformBuiltIn built_in,
                                                   const RE_Uniform *uniform =
                                                        NULL);

    void                         print();
    
private:
    static const int             theTypeSizes[RE_UNIFORM_TYPE__count];
    static UT_HashTable          theBuiltIns;
    UT_String                    myName;
    RE_UniformType               myType;
    int                          mySize;
    int                          myVersion;
    char                        *myValues;
};

#endif

---