source: GTP/trunk/App/Demos/Vis/FriendlyCulling/src/ShaderProgram.h @ 3113

#ifndef _SHADERPROGRAM_H__
#define _SHADERPROGRAM_H__

#include "common.h"
#include "glInterface.h"
#include "Matrix4x4.h"
#include <Cg/cg.h>
#include <Cg/cgGL.h>
#include <string>
#include <map>


namespace CHCDemoEngine 
{ 

class FrameBufferObject;
class Vector3;
class Camera;
class ShadowMap;
class DirectionalLight;
class ShaderProgram;


typedef std::map<std::string, int> CGParameterMap;
typedef std::vector<CGparameter> CGParameterArray;


/** This class represents the parameter values for a given GPU program.
*/
class GPUProgramParameters
{
public:
        /** Default construction.
        */
        GPUProgramParameters();

        /** Constructor which initialized this parameter set for a given program.
        */
        GPUProgramParameters(ShaderProgram *p);

        void SetProgram(ShaderProgram *p) { mProgram = p; }
        /** Resets this parameter set.
        */
        void Reset();


        ///////////
        //-- set parameters by index

        void SetValue1f(int idx, float value);
        void SetValue2f(int idx, float val1, float val2);
        void SetValue3f(int idx, float val1, float val, float val3);

        void SetArray1f(int idx, float *vals, int numElements);
        void SetArray2f(int idx, float *vals, int numElements);
        void SetArray3f(int idx, float *vals, int numElements);
        /** Sets a texture parameter.
        */
        void SetTexture(int idx, unsigned int tex);
        /** Sets a matrix parameter.
        */
        void SetMatrix(int idx, const Matrix4x4 &mat);
        /** Sets an array of matrices
        */
        void SetMatrixArray(int idx, float *vals, int numElements);


        ////////////
        //-- The following parameters are updated and set automatically once per frame.

        /** This parameter is connected to a timer that is updated once per frame.
        */
        void SetTimerParam(int idx);
        /** This parameter is connected to the current view matrix
                that is updated once per frame.
        */
        void SetViewMatrixParam(int idx);
        /** This parameter is connected to the current view direction 
                that is updated once per frame.
        */
        void SetViewDirParam(int idx);
        /** This parameter is connected to the current light direction 
                that is updated once per frame.
        */
        void SetLightDirParam(int idx);

        

        ///////////
        //-- set parameters by name (slower!)


        void SetValue1f(const std::string &name, float value);
        void SetValue2f(const std::string &name, float val1, float val2);
        void SetValue3f(const std::string &name, float val1, float val, float val3);

        void SetArray1f(const std::string &name, float *vals, int numElements);
        void SetArray2f(const std::string &name, float *vals, int numElements);
        void SetArray3f(const std::string &name, float *vals, int numElements);

        /** Sets the texture parameter.
        */
        void SetTexture(const std::string &name, unsigned int tex);
        /** Sets the matrix parameter.
        */
        void SetMatrix(const std::string &name, const Matrix4x4 &mat);
        /** Sets an array of matrices
        */
        void SetMatrixArray(const std::string &name, float *vals, int numElements);
        /** Feeds the shader program with the parameter values.
        */
        void UpdateParameters();
        /** Function should be called once per frame to update frame related parameters.
        */
        static void InitFrame(Camera *cam, DirectionalLight *light);


protected:

        struct FloatParam
        {
                FloatParam(): mValid(false), mNumComponents(0) {}

                FloatParam(float *val, int comp): 
                mNumComponents(comp), mValid(true)
                {
                        for (int i = 0; i < mNumComponents; ++ i)
                                mValues[i] = val[i];
                }

                bool mValid;
                float mValues[4];
                int mNumComponents;
        };

        struct IntParam
        {
                IntParam(): mValid(false) {}
                IntParam(float val): mValue(val), mValid(true) {}

                bool mValid;
                float mValue;
        };

        struct MatrixParam
        {
                MatrixParam(): mValue(IdentityMatrix()), mValid(false) {}

                MatrixParam(const Matrix4x4 &mat): mValue(mat), mValid(true)
                {}

                bool mValid;
                Matrix4x4 mValue;
        };

        struct ArrayParam
        {
                ArrayParam(): mValues(NULL), mNumEntries(0), mNumComponents(0), mValid(false) {}
                ArrayParam(float *val, int comp, int numEntries): 
                mValues(val), mNumComponents(comp), mNumEntries(numEntries), mValid(true)
                {}

                bool mValid;
                float *mValues;

                int mNumEntries;
                int mNumComponents;
        };


        struct MatrixArrayParam
        {
                MatrixArrayParam(): mValues(NULL), mNumEntries(0), mValid(false) {}
                MatrixArrayParam(float *mats, int numEntries): 
                mValues(mats), mNumEntries(numEntries), mValid(true)
                {}

                bool mValid;
                float *mValues;

                int mNumEntries;
        };


        /// the program this parameter set is connected to
        ShaderProgram *mProgram;

        int mTimerParam;
        int mViewDirParam;
        int mLightDirParam;
        int mViewMatrixParam;

        std::vector<FloatParam> mFloats;
        std::vector<IntParam> mTextures;
        std::vector<MatrixParam> mMatrices;
        std::vector<ArrayParam> mArrays;
        std::vector<MatrixArrayParam> mMatrixArrays;
};


/** This class represents a wrapper for a GPU shader program (vertex or fragment).
*/
class ShaderProgram
{
        friend class GPUProgramParameters;

public:

        ShaderProgram(CGprogram program): mProgram(program) {}

        ShaderProgram(CGcontext context, 
                          const std::string &filename, 
                                  CGprofile profile,
                                  const std::string &functionName);

        ~ShaderProgram() { if (mProgram != NULL) cgDestroyProgram(mProgram); }

        /** Assigns a parameter to the specified index.
        */
        CGparameter AddParameter(const std::string &name, int idx);
        /** Comvenience method that adds an array of parameters beginning with
                index i of size numElements
        */
        void AddParameters(std::string params[], int startIdx, int numElements);

        //////////////
        //-- set shader parameters per index 

        void SetValue1f(int idx, float value);
        void SetValue2f(int idx, float val1, float val2);
        void SetValue3f(int idx, float val1, float val, float val3);

        void SetArray1f(int idx, float *vals, int numElements);
        void SetArray2f(int idx, float *vals, int numElements);
        void SetArray3f(int idx, float *vals, int numElements);
        void SetMatrix(int idx, const Matrix4x4 &mat);
        void SetMatrixArray(int idx, float *mats, int numElements);

        void SetTexture(int idx, unsigned int tex);


        ////////////
        //-- set shader parameters per parameter name (slow!)

        /// Float parameters
        void SetValue1f(const std::string &name, float value);
        void SetValue2f(const std::string &name, float val1, float val2);
        void SetValue3f(const std::string &name, float val1, float val, float val3);
        /// Array parameters
        void SetArray1f(const std::string &name, float *vals, int numElements);
        void SetArray2f(const std::string &name, float *vals, int numElements);
        void SetArray3f(const std::string &name, float *vals, int numElements);
        /** Sets a matrix parameter
        */
        void SetMatrix(const std::string &name, const Matrix4x4 &mat);
        /** Sets array of matrices
        */
        void SetMatrixArray(const std::string &name, float *mats, int numElements);
        /** Sets the texture parameter.
        */
        void SetTexture(const std::string &name, unsigned int tex);
        /** Binds the program.
        */
        void Bind();
        /** Returns true if this program is valid.
        */
        inline bool IsValid() const { return mProgram != NULL; }
        /** Releases all texture resources.
        */
        void Release();


protected:

        inline int GetParamIdxByName(const std::string &name) const;

        inline CGparameter GetParameter(int idx) const;

        CGparameter GetOrCreateParameter(const std::string &name);


        ///////////////

        CGParameterMap mParamHash;
        
        CGprogram mProgram;

        CGParameterArray mTextureParams;
        CGParameterArray mParameters;
};



} // namespace 

#endif // _ShaderProgram_H__