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

#ifndef _SHADERPROGRAM_H__
#define _SHADERPROGRAM_H__

#include "common.h"
#include "glInterface.h"

#include <Cg/cg.h>
#include <Cg/cgGL.h>
#include <string>
#include <map>


namespace CHCDemoEngine 
{ 

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


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

struct ParameterPair1f
{
        unsigned int mParameterIdx;
        float mValue;
};

class GPUProgramParameters
{
public:

        /** 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 the texture parameter.
        */
        void SetTexture(int idx, unsigned int tex);
        /** Sets the matrix parameter.
        */
        void SetMatrix(int idx, Matrix4x4 *mat);


        ///////////
        //-- 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, Matrix4x4 *mat);
        /** Feeds the shader program with the parameter values.
        */
        void UpdateParameters();
        

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(NULL), mValid(false) {}

                MatrixParam(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;
        };


        ShaderProgram *mProgram;

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



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); }

        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 SetTexture(int idx, unsigned int tex);

        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 matrix parameter.
        */
        void SetMatrix(const std::string &name, const Matrix4x4 &mat);
        /** Sets the texture parameter.
        */
        void SetTexture(const std::string &name, unsigned int tex);

        CGparameter AddParameter(const std::string &name, int idx);
        /** Binds the program.
        */
        void Bind();
        /** Returns true if this program is valid.
        */
        inline bool IsValid() const { return mProgram != NULL; }
        /** Enable / disable a texture parameter.
        */
        //void EnableTexture(const std::string &name);
        //void DisableTexture(const std::string &name);



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;
};


typedef  std::vector<ShaderProgram *> ShaderContainer;

} // namespace 

#endif // _ShaderProgram_H__