OgreGpuProgramParams.h

Go to the documentation of this file.

/*
-----------------------------------------------------------------------------
This source file is part of OGRE
(Object-oriented Graphics Rendering Engine)
For the latest info, see http://www.ogre3d.org

Copyright (c) 2000-2014 Torus Knot Software Ltd

Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in
all copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
THE SOFTWARE.
-----------------------------------------------------------------------------
*/
#ifndef __GpuProgramParams_H_
#define __GpuProgramParams_H_

// Precompiler options
#include "OgrePrerequisites.h"
#include "OgreSharedPtr.h"
#include "OgreIteratorWrappers.h"
#include "OgreSerializer.h"
#include "OgreRenderOperation.h"
#include "OgreAny.h"
#include "Threading/OgreThreadHeaders.h"
#include "OgreHeaderPrefix.h"

namespace Ogre {

    enum GpuConstantType
    {
        GCT_FLOAT1 = 1,
        GCT_FLOAT2 = 2,
        GCT_FLOAT3 = 3,
        GCT_FLOAT4 = 4,
        GCT_SAMPLER1D = 5,
        GCT_SAMPLER2D = 6,
        GCT_SAMPLER3D = 7,
        GCT_SAMPLERCUBE = 8,
        GCT_SAMPLERRECT = 9,
        GCT_SAMPLER1DSHADOW = 10,
        GCT_SAMPLER2DSHADOW = 11,
        GCT_SAMPLER2DARRAY = 12,
        GCT_MATRIX_2X2 = 13,
        GCT_MATRIX_2X3 = 14,
        GCT_MATRIX_2X4 = 15,
        GCT_MATRIX_3X2 = 16,
        GCT_MATRIX_3X3 = 17,
        GCT_MATRIX_3X4 = 18,
        GCT_MATRIX_4X2 = 19,
        GCT_MATRIX_4X3 = 20,
        GCT_MATRIX_4X4 = 21,
        GCT_INT1 = 22,
        GCT_INT2 = 23,
        GCT_INT3 = 24,
        GCT_INT4 = 25,
        GCT_SUBROUTINE = 26,
        GCT_DOUBLE1 = 27,
        GCT_DOUBLE2 = 28,
        GCT_DOUBLE3 = 29,
        GCT_DOUBLE4 = 30,
        GCT_MATRIX_DOUBLE_2X2 = 31,
        GCT_MATRIX_DOUBLE_2X3 = 32,
        GCT_MATRIX_DOUBLE_2X4 = 33,
        GCT_MATRIX_DOUBLE_3X2 = 34,
        GCT_MATRIX_DOUBLE_3X3 = 35,
        GCT_MATRIX_DOUBLE_3X4 = 36,
        GCT_MATRIX_DOUBLE_4X2 = 37,
        GCT_MATRIX_DOUBLE_4X3 = 38,
        GCT_MATRIX_DOUBLE_4X4 = 39,
        GCT_UNKNOWN = 99
    };

    enum GpuParamVariability
    {
        GPV_GLOBAL = 1, 
        GPV_PER_OBJECT = 2, 
        GPV_LIGHTS = 4, 
        GPV_PASS_ITERATION_NUMBER = 8,


        GPV_ALL = 0xFFFF

    };

    struct _OgreExport GpuConstantDefinition
    {
        GpuConstantType constType;
        size_t physicalIndex;
        size_t logicalIndex;
        size_t elementSize;
        size_t arraySize;
        mutable uint16 variability;

        bool isFloat() const
        {
            return isFloat(constType);
        }

        static bool isFloat(GpuConstantType c)
        {
            switch(c)
            {
            case GCT_INT1:
            case GCT_INT2:
            case GCT_INT3:
            case GCT_INT4:
            case GCT_SAMPLER1D:
            case GCT_SAMPLER2D:
            case GCT_SAMPLER2DARRAY:
            case GCT_SAMPLER3D:
            case GCT_SAMPLERCUBE:
            case GCT_SAMPLER1DSHADOW:
            case GCT_SAMPLER2DSHADOW:
                return false;
            default:
                return true;
            };

        }

        bool isDouble() const
        {
            return isDouble(constType);
        }

        static bool isDouble(GpuConstantType c)
        {
            switch(c)
            {
                case GCT_INT1:
                case GCT_INT2:
                case GCT_INT3:
                case GCT_INT4:
                case GCT_FLOAT1:
                case GCT_FLOAT2:
                case GCT_FLOAT3:
                case GCT_FLOAT4:
                case GCT_SAMPLER1D:
                case GCT_SAMPLER2D:
                case GCT_SAMPLER2DARRAY:
                case GCT_SAMPLER3D:
                case GCT_SAMPLERCUBE:
                case GCT_SAMPLER1DSHADOW:
                case GCT_SAMPLER2DSHADOW:
                    return false;
                default:
                    return true;
            };
            
        }

        bool isSampler() const
        {
            return isSampler(constType);
        }

        static bool isSampler(GpuConstantType c)
        {
            switch(c)
            {
            case GCT_SAMPLER1D:
            case GCT_SAMPLER2D:
            case GCT_SAMPLER2DARRAY:
            case GCT_SAMPLER3D:
            case GCT_SAMPLERCUBE:
            case GCT_SAMPLER1DSHADOW:
            case GCT_SAMPLER2DSHADOW:
                return true;
            default:
                return false;
            };

        }

        bool isSubroutine() const
        {
            return isSubroutine(constType);
        }

        static bool isSubroutine(GpuConstantType c)
        {
            return c == GCT_SUBROUTINE;
        }

        static size_t getElementSize(GpuConstantType ctype, bool padToMultiplesOf4)
        {
            if (padToMultiplesOf4)
            {
                switch(ctype)
                {
                case GCT_FLOAT1:
                case GCT_INT1:
                case GCT_SAMPLER1D:
                case GCT_SAMPLER2D:
                case GCT_SAMPLER2DARRAY:
                case GCT_SAMPLER3D:
                case GCT_SAMPLERCUBE:
                case GCT_SAMPLER1DSHADOW:
                case GCT_SAMPLER2DSHADOW:
                case GCT_FLOAT2:
                case GCT_INT2:
                case GCT_FLOAT3:
                case GCT_INT3:
                case GCT_FLOAT4:
                case GCT_INT4:
                    return 4;
                case GCT_MATRIX_2X2:
                case GCT_MATRIX_2X3:
                case GCT_MATRIX_2X4:
                case GCT_DOUBLE1:
                case GCT_DOUBLE2:
                case GCT_DOUBLE3:
                case GCT_DOUBLE4:
                    return 8; // 2 float4s
                case GCT_MATRIX_3X2:
                case GCT_MATRIX_3X3:
                case GCT_MATRIX_3X4:
                    return 12; // 3 float4s
                case GCT_MATRIX_4X2:
                case GCT_MATRIX_4X3:
                case GCT_MATRIX_4X4:
                case GCT_MATRIX_DOUBLE_2X2:
                case GCT_MATRIX_DOUBLE_2X3:
                case GCT_MATRIX_DOUBLE_2X4:
                    return 16; // 4 float4s
                case GCT_MATRIX_DOUBLE_3X2:
                case GCT_MATRIX_DOUBLE_3X3:
                case GCT_MATRIX_DOUBLE_3X4:
                    return 24;
                case GCT_MATRIX_DOUBLE_4X2:
                case GCT_MATRIX_DOUBLE_4X3:
                case GCT_MATRIX_DOUBLE_4X4:
                    return 32;
                default:
                    return 4;
                };
            }
            else
            {
                switch(ctype)
                {
                case GCT_FLOAT1:
                case GCT_DOUBLE1:
                case GCT_INT1:
                case GCT_SAMPLER1D:
                case GCT_SAMPLER2D:
                case GCT_SAMPLER2DARRAY:
                case GCT_SAMPLER3D:
                case GCT_SAMPLERCUBE:
                case GCT_SAMPLER1DSHADOW:
                case GCT_SAMPLER2DSHADOW:
                    return 1;
                case GCT_FLOAT2:
                case GCT_INT2:
                case GCT_DOUBLE2:
                    return 2;
                case GCT_FLOAT3:
                case GCT_INT3:
                case GCT_DOUBLE3:
                    return 3;
                case GCT_FLOAT4:
                case GCT_INT4:
                case GCT_DOUBLE4:
                    return 4;
                case GCT_MATRIX_2X2:
                case GCT_MATRIX_DOUBLE_2X2:
                    return 4;
                case GCT_MATRIX_2X3:
                case GCT_MATRIX_3X2:
                case GCT_MATRIX_DOUBLE_2X3:
                case GCT_MATRIX_DOUBLE_3X2:
                    return 6;
                case GCT_MATRIX_2X4:
                case GCT_MATRIX_4X2:
                case GCT_MATRIX_DOUBLE_2X4:
                case GCT_MATRIX_DOUBLE_4X2:
                    return 8;
                case GCT_MATRIX_3X3:
                case GCT_MATRIX_DOUBLE_3X3:
                    return 9;
                case GCT_MATRIX_3X4:
                case GCT_MATRIX_4X3:
                case GCT_MATRIX_DOUBLE_3X4:
                case GCT_MATRIX_DOUBLE_4X3:
                    return 12;
                case GCT_MATRIX_4X4:
                case GCT_MATRIX_DOUBLE_4X4:
                    return 16;
                default:
                    return 4;
                };

            }
        }

        GpuConstantDefinition()
            : constType(GCT_UNKNOWN)
            , physicalIndex((std::numeric_limits<size_t>::max)())
            , logicalIndex(0)
            , elementSize(0)
            , arraySize(1)
            , variability(GPV_GLOBAL) {}
    };
    typedef map<String, GpuConstantDefinition>::type GpuConstantDefinitionMap;
    typedef ConstMapIterator<GpuConstantDefinitionMap> GpuConstantDefinitionIterator;

    struct _OgreExport GpuNamedConstants : public GpuParamsAlloc
    {
        size_t floatBufferSize;
        size_t doubleBufferSize;
        size_t intBufferSize;
        GpuConstantDefinitionMap map;

        GpuNamedConstants() : floatBufferSize(0), doubleBufferSize(0), intBufferSize(0) {}

        void generateConstantDefinitionArrayEntries(const String& paramName, 
            const GpuConstantDefinition& baseDef);

        static bool getGenerateAllConstantDefinitionArrayEntries();

        static void setGenerateAllConstantDefinitionArrayEntries(bool generateAll);

        void save(const String& filename) const;
        void load(DataStreamPtr& stream);

        size_t calculateSize(void) const;

    protected:
        static bool msGenerateAllConstantDefinitionArrayEntries;
    };
    typedef SharedPtr<GpuNamedConstants> GpuNamedConstantsPtr;

    class _OgreExport GpuNamedConstantsSerializer : public Serializer
    {
    public:
        GpuNamedConstantsSerializer();
        virtual ~GpuNamedConstantsSerializer();
        void exportNamedConstants(const GpuNamedConstants* pConsts, const String& filename,
            Endian endianMode = ENDIAN_NATIVE);
        void exportNamedConstants(const GpuNamedConstants* pConsts, DataStreamPtr stream,
            Endian endianMode = ENDIAN_NATIVE);
        void importNamedConstants(DataStreamPtr& stream, GpuNamedConstants* pDest);
    };

    struct _OgreExport GpuLogicalIndexUse
    {
        size_t physicalIndex;
        size_t currentSize;
        mutable uint16 variability;

        GpuLogicalIndexUse() 
            : physicalIndex(99999), currentSize(0), variability(GPV_GLOBAL) {}
        GpuLogicalIndexUse(size_t bufIdx, size_t curSz, uint16 v) 
            : physicalIndex(bufIdx), currentSize(curSz), variability(v) {}
    };
    typedef map<size_t, GpuLogicalIndexUse>::type GpuLogicalIndexUseMap;
    struct _OgreExport GpuLogicalBufferStruct : public GpuParamsAlloc
    {
            OGRE_MUTEX(mutex);
            
            GpuLogicalIndexUseMap map;
            size_t bufferSize;
            GpuLogicalBufferStruct() : bufferSize(0) {}
    };
    typedef SharedPtr<GpuLogicalBufferStruct> GpuLogicalBufferStructPtr;

    typedef vector<float>::type FloatConstantList;
    typedef vector<double>::type DoubleConstantList;
    typedef vector<int>::type IntConstantList;

    class _OgreExport GpuSharedParameters : public GpuParamsAlloc
    {
    protected:
        GpuNamedConstants mNamedConstants;
        FloatConstantList mFloatConstants;
        DoubleConstantList mDoubleConstants;
        IntConstantList mIntConstants;
        String mName;

        // Optional data the rendersystem might want to store
        mutable Any mRenderSystemData;

        size_t mFrameLastUpdated;

        unsigned long mVersion; 

    public:
        GpuSharedParameters(const String& name);
        virtual ~GpuSharedParameters();

        const String& getName() { return mName; }

        void addConstantDefinition(const String& name, GpuConstantType constType, size_t arraySize = 1);

        void removeConstantDefinition(const String& name);

        void removeAllConstantDefinitions();

        unsigned long getVersion() const { return mVersion; }

        size_t calculateSize(void) const;

        void _markDirty();
        size_t getFrameLastUpdated() const { return mFrameLastUpdated; }

        GpuConstantDefinitionIterator getConstantDefinitionIterator(void) const;

        const GpuConstantDefinition& getConstantDefinition(const String& name) const;

        const GpuNamedConstants& getConstantDefinitions() const;
    
        void setNamedConstant(const String& name, Real val);
        void setNamedConstant(const String& name, int val);
        void setNamedConstant(const String& name, const Vector4& vec);
        void setNamedConstant(const String& name, const Vector3& vec);
        void setNamedConstant(const String& name, const Vector2& vec);
        void setNamedConstant(const String& name, const Matrix4& m);
        void setNamedConstant(const String& name, const Matrix4* m, size_t numEntries);
        void setNamedConstant(const String& name, const float *val, size_t count);
        void setNamedConstant(const String& name, const double *val, size_t count);
        void setNamedConstant(const String& name, const ColourValue& colour);
        void setNamedConstant(const String& name, const int *val, size_t count);

        float* getFloatPointer(size_t pos) { _markDirty(); return &mFloatConstants[pos]; }
        const float* getFloatPointer(size_t pos) const { return &mFloatConstants[pos]; }
        double* getDoublePointer(size_t pos) { _markDirty(); return &mDoubleConstants[pos]; }
        const double* getDoublePointer(size_t pos) const { return &mDoubleConstants[pos]; }
        int* getIntPointer(size_t pos) { _markDirty(); return &mIntConstants[pos]; }
        const int* getIntPointer(size_t pos) const { return &mIntConstants[pos]; }

        const FloatConstantList& getFloatConstantList() const { return mFloatConstants; }
        const DoubleConstantList& getDoubleConstantList() const { return mDoubleConstants; }
        const IntConstantList& getIntConstantList() const { return mIntConstants; }

        void _setRenderSystemData(const Any& data) const { mRenderSystemData = data; }
        const Any& _getRenderSystemData() const { return mRenderSystemData; }

    };

    typedef SharedPtr<GpuSharedParameters> GpuSharedParametersPtr;

    class GpuProgramParameters;

    class _OgreExport GpuSharedParametersUsage : public GpuParamsAlloc
    {
    protected:
        GpuSharedParametersPtr mSharedParams;
        // Not a shared pointer since this is also parent
        GpuProgramParameters* mParams;
        // list of physical mappings that we are going to bring in
        struct CopyDataEntry
        {
            const GpuConstantDefinition* srcDefinition;
            const GpuConstantDefinition* dstDefinition;
        };
        typedef vector<CopyDataEntry>::type CopyDataList;

        CopyDataList mCopyDataList;

        // Optional data the rendersystem might want to store
        mutable Any mRenderSystemData;

        unsigned long mCopyDataVersion;

        void initCopyData();


    public:
        GpuSharedParametersUsage(GpuSharedParametersPtr sharedParams, 
            GpuProgramParameters* params);

        void _copySharedParamsToTargetParams();

        const String& getName() const { return mSharedParams->getName(); }

        GpuSharedParametersPtr getSharedParams() const { return mSharedParams; }
        GpuProgramParameters* getTargetParams() const { return mParams; }

        void _setRenderSystemData(const Any& data) const { mRenderSystemData = data; }
        const Any& _getRenderSystemData() const { return mRenderSystemData; }


    };

    class _OgreExport GpuProgramParameters : public GpuParamsAlloc
    {
    public:
        enum AutoConstantType
        {
            ACT_WORLD_MATRIX,
            ACT_INVERSE_WORLD_MATRIX,
            ACT_TRANSPOSE_WORLD_MATRIX,
            ACT_INVERSE_TRANSPOSE_WORLD_MATRIX,

            ACT_WORLD_MATRIX_ARRAY_3x4,
            ACT_WORLD_MATRIX_ARRAY,
            ACT_WORLD_DUALQUATERNION_ARRAY_2x4,
            ACT_WORLD_SCALE_SHEAR_MATRIX_ARRAY_3x4,
            
            ACT_VIEW_MATRIX,
            ACT_INVERSE_VIEW_MATRIX,
            ACT_TRANSPOSE_VIEW_MATRIX,
            ACT_INVERSE_TRANSPOSE_VIEW_MATRIX,


            ACT_PROJECTION_MATRIX,
            ACT_INVERSE_PROJECTION_MATRIX,
            ACT_TRANSPOSE_PROJECTION_MATRIX,
            ACT_INVERSE_TRANSPOSE_PROJECTION_MATRIX,


            ACT_VIEWPROJ_MATRIX,
            ACT_INVERSE_VIEWPROJ_MATRIX,
            ACT_TRANSPOSE_VIEWPROJ_MATRIX,
            ACT_INVERSE_TRANSPOSE_VIEWPROJ_MATRIX,


            ACT_WORLDVIEW_MATRIX,
            ACT_INVERSE_WORLDVIEW_MATRIX,
            ACT_TRANSPOSE_WORLDVIEW_MATRIX,
            ACT_INVERSE_TRANSPOSE_WORLDVIEW_MATRIX,


            ACT_WORLDVIEWPROJ_MATRIX,
            ACT_INVERSE_WORLDVIEWPROJ_MATRIX,
            ACT_TRANSPOSE_WORLDVIEWPROJ_MATRIX,
            ACT_INVERSE_TRANSPOSE_WORLDVIEWPROJ_MATRIX,



            ACT_RENDER_TARGET_FLIPPING,

            ACT_VERTEX_WINDING,

            ACT_FOG_COLOUR,
            ACT_FOG_PARAMS,


            ACT_SURFACE_AMBIENT_COLOUR,
            ACT_SURFACE_DIFFUSE_COLOUR,
            ACT_SURFACE_SPECULAR_COLOUR,
            ACT_SURFACE_EMISSIVE_COLOUR,
            ACT_SURFACE_SHININESS,
            ACT_SURFACE_ALPHA_REJECTION_VALUE,


            ACT_LIGHT_COUNT,


            ACT_AMBIENT_LIGHT_COLOUR, 

            ACT_LIGHT_DIFFUSE_COLOUR,
            ACT_LIGHT_SPECULAR_COLOUR,
            ACT_LIGHT_ATTENUATION,
            ACT_SPOTLIGHT_PARAMS,
            ACT_LIGHT_POSITION,
            ACT_LIGHT_POSITION_OBJECT_SPACE,
            ACT_LIGHT_POSITION_VIEW_SPACE,
            ACT_LIGHT_DIRECTION,
            ACT_LIGHT_DIRECTION_OBJECT_SPACE,
            ACT_LIGHT_DIRECTION_VIEW_SPACE,
            ACT_LIGHT_DISTANCE_OBJECT_SPACE,
            ACT_LIGHT_POWER_SCALE,
            ACT_LIGHT_DIFFUSE_COLOUR_POWER_SCALED,
            ACT_LIGHT_SPECULAR_COLOUR_POWER_SCALED,
            ACT_LIGHT_DIFFUSE_COLOUR_ARRAY,
            ACT_LIGHT_SPECULAR_COLOUR_ARRAY,
            ACT_LIGHT_DIFFUSE_COLOUR_POWER_SCALED_ARRAY,
            ACT_LIGHT_SPECULAR_COLOUR_POWER_SCALED_ARRAY,
            ACT_LIGHT_ATTENUATION_ARRAY,
            ACT_LIGHT_POSITION_ARRAY,
            ACT_LIGHT_POSITION_OBJECT_SPACE_ARRAY,
            ACT_LIGHT_POSITION_VIEW_SPACE_ARRAY,
            ACT_LIGHT_DIRECTION_ARRAY,
            ACT_LIGHT_DIRECTION_OBJECT_SPACE_ARRAY,
            ACT_LIGHT_DIRECTION_VIEW_SPACE_ARRAY,
            ACT_LIGHT_DISTANCE_OBJECT_SPACE_ARRAY,
            ACT_LIGHT_POWER_SCALE_ARRAY,
            ACT_SPOTLIGHT_PARAMS_ARRAY,

            ACT_DERIVED_AMBIENT_LIGHT_COLOUR,
            ACT_DERIVED_SCENE_COLOUR,

            ACT_DERIVED_LIGHT_DIFFUSE_COLOUR,
            ACT_DERIVED_LIGHT_SPECULAR_COLOUR,

            ACT_DERIVED_LIGHT_DIFFUSE_COLOUR_ARRAY,
            ACT_DERIVED_LIGHT_SPECULAR_COLOUR_ARRAY,
            ACT_LIGHT_NUMBER,
            ACT_LIGHT_CASTS_SHADOWS,
            ACT_LIGHT_CASTS_SHADOWS_ARRAY,


            ACT_SHADOW_EXTRUSION_DISTANCE,
            ACT_CAMERA_POSITION,
            ACT_CAMERA_POSITION_OBJECT_SPACE,
            ACT_TEXTURE_VIEWPROJ_MATRIX,
            ACT_TEXTURE_VIEWPROJ_MATRIX_ARRAY,
            ACT_TEXTURE_WORLDVIEWPROJ_MATRIX,
            ACT_TEXTURE_WORLDVIEWPROJ_MATRIX_ARRAY,
            ACT_SPOTLIGHT_VIEWPROJ_MATRIX,
            ACT_SPOTLIGHT_VIEWPROJ_MATRIX_ARRAY,
            ACT_SPOTLIGHT_WORLDVIEWPROJ_MATRIX,
            ACT_SPOTLIGHT_WORLDVIEWPROJ_MATRIX_ARRAY,
            ACT_CUSTOM,
            ACT_TIME,
            ACT_TIME_0_X,
            ACT_COSTIME_0_X,
            ACT_SINTIME_0_X,
            ACT_TANTIME_0_X,
            ACT_TIME_0_X_PACKED,
            ACT_TIME_0_1,
            ACT_COSTIME_0_1,
            ACT_SINTIME_0_1,
            ACT_TANTIME_0_1,
            ACT_TIME_0_1_PACKED,
            ACT_TIME_0_2PI,
            ACT_COSTIME_0_2PI,
            ACT_SINTIME_0_2PI,
            ACT_TANTIME_0_2PI,
            ACT_TIME_0_2PI_PACKED,
            ACT_FRAME_TIME,
            ACT_FPS,

            ACT_VIEWPORT_WIDTH,
            ACT_VIEWPORT_HEIGHT,
            ACT_INVERSE_VIEWPORT_WIDTH,
            ACT_INVERSE_VIEWPORT_HEIGHT,
            ACT_VIEWPORT_SIZE,


            ACT_VIEW_DIRECTION,
            ACT_VIEW_SIDE_VECTOR,
            ACT_VIEW_UP_VECTOR,
            ACT_FOV,
            ACT_NEAR_CLIP_DISTANCE,
            ACT_FAR_CLIP_DISTANCE,

            ACT_PASS_NUMBER,

            ACT_PASS_ITERATION_NUMBER,


            ACT_ANIMATION_PARAMETRIC,

            ACT_TEXEL_OFFSETS,

            ACT_SCENE_DEPTH_RANGE,

            ACT_SHADOW_SCENE_DEPTH_RANGE,

            ACT_SHADOW_SCENE_DEPTH_RANGE_ARRAY,

            ACT_SHADOW_COLOUR,
            ACT_TEXTURE_SIZE,
            ACT_INVERSE_TEXTURE_SIZE,
            ACT_PACKED_TEXTURE_SIZE,

            ACT_TEXTURE_MATRIX, 

            ACT_LOD_CAMERA_POSITION, 
            ACT_LOD_CAMERA_POSITION_OBJECT_SPACE, 
            ACT_LIGHT_CUSTOM,

            ACT_UNKNOWN = 999
        };

        enum ACDataType {
            ACDT_NONE,
            ACDT_INT,
            ACDT_REAL
        };

        enum ElementType {
            ET_INT,
            ET_REAL
        };

        struct AutoConstantDefinition
        {
            AutoConstantType acType;
            String name;
            size_t elementCount;
            ElementType elementType;
            ACDataType dataType;

            AutoConstantDefinition(AutoConstantType _acType, const String& _name, 
                size_t _elementCount, ElementType _elementType, 
                ACDataType _dataType)
                :acType(_acType), name(_name), elementCount(_elementCount), 
                elementType(_elementType), dataType(_dataType)
            {

            }
        };

        class AutoConstantEntry
        {
        public:
            AutoConstantType paramType;
            size_t physicalIndex;
            size_t elementCount;
            union{
                size_t data;
                Real fData;
            };
            uint16 variability;

            AutoConstantEntry(AutoConstantType theType, size_t theIndex, size_t theData, 
                uint16 theVariability, size_t theElemCount = 4)
                : paramType(theType), physicalIndex(theIndex), elementCount(theElemCount), 
                data(theData), variability(theVariability) {}

            AutoConstantEntry(AutoConstantType theType, size_t theIndex, Real theData, 
                uint16 theVariability, size_t theElemCount = 4)
                : paramType(theType), physicalIndex(theIndex), elementCount(theElemCount), 
                fData(theData), variability(theVariability) {}

        };
        // Auto parameter storage
        typedef vector<AutoConstantEntry>::type AutoConstantList;

        typedef vector<GpuSharedParametersUsage>::type GpuSharedParamUsageList;

        // Map that store subroutines associated with slots
        typedef HashMap<unsigned int, String> SubroutineMap;
        typedef HashMap<unsigned int, String>::const_iterator SubroutineIterator;

    protected:
        SubroutineMap mSubroutineMap;

        static AutoConstantDefinition AutoConstantDictionary[];
        FloatConstantList mFloatConstants;
        DoubleConstantList mDoubleConstants;
        IntConstantList mIntConstants;
        GpuLogicalBufferStructPtr mFloatLogicalToPhysical;
        GpuLogicalBufferStructPtr mDoubleLogicalToPhysical;
        GpuLogicalBufferStructPtr mIntLogicalToPhysical;
        GpuNamedConstantsPtr mNamedConstants;
        AutoConstantList mAutoConstants;
        uint16 mCombinedVariability;
        bool mTransposeMatrices;
        bool mIgnoreMissingParams;
        size_t mActivePassIterationIndex;

        GpuLogicalIndexUse* _getFloatConstantLogicalIndexUse(size_t logicalIndex, size_t requestedSize, uint16 variability);
        GpuLogicalIndexUse* _getDoubleConstantLogicalIndexUse(size_t logicalIndex, size_t requestedSize, uint16 variability);
        GpuLogicalIndexUse* _getIntConstantLogicalIndexUse(size_t logicalIndex, size_t requestedSize, uint16 variability);

        uint16 deriveVariability(AutoConstantType act);

        void copySharedParamSetUsage(const GpuSharedParamUsageList& srcList);

        GpuSharedParamUsageList mSharedParamSets;

        // Optional data the rendersystem might want to store
        mutable Any mRenderSystemData;



    public:
        GpuProgramParameters();
        ~GpuProgramParameters() {}

        GpuProgramParameters(const GpuProgramParameters& oth);
        GpuProgramParameters& operator=(const GpuProgramParameters& oth);

        void _setNamedConstants(const GpuNamedConstantsPtr& constantmap);

        void _setLogicalIndexes(const GpuLogicalBufferStructPtr& floatIndexMap, const GpuLogicalBufferStructPtr& doubleIndexMap,
            const GpuLogicalBufferStructPtr&  intIndexMap);


        bool hasNamedParameters() const { return !mNamedConstants.isNull(); }
        bool hasLogicalIndexedParameters() const { return !mFloatLogicalToPhysical.isNull(); }

        void setConstant(size_t index, const Vector4& vec);
        void setConstant(size_t index, Real val);
        void setConstant(size_t index, const Vector3& vec);
        void setConstant(size_t index, const Vector2& vec);
        void setConstant(size_t index, const Matrix4& m);
        void setConstant(size_t index, const Matrix4* m, size_t numEntries);
        void setConstant(size_t index, const float *val, size_t count);
        void setConstant(size_t index, const double *val, size_t count);
        void setConstant(size_t index, const ColourValue& colour);

        void setConstant(size_t index, const int *val, size_t count);

        void _writeRawConstants(size_t physicalIndex, const float* val, size_t count);
        void _writeRawConstants(size_t physicalIndex, const double* val, size_t count);
        void _writeRawConstants(size_t physicalIndex, const int* val, size_t count);
        void _readRawConstants(size_t physicalIndex, size_t count, float* dest);
        void _readRawConstants(size_t physicalIndex, size_t count, int* dest);

        void _writeRawConstant(size_t physicalIndex, const Vector4& vec, 
            size_t count = 4);
        void _writeRawConstant(size_t physicalIndex, Real val);
        void _writeRawConstant(size_t physicalIndex, Real val, size_t count);
        void _writeRawConstant(size_t physicalIndex, int val);
        void _writeRawConstant(size_t physicalIndex, const Vector3& vec);
        void _writeRawConstant(size_t physicalIndex, const Vector2& vec);
        void _writeRawConstant(size_t physicalIndex, const Matrix4& m, size_t elementCount);
        void _writeRawConstant(size_t physicalIndex, const Matrix4* m, size_t numEntries);
        void _writeRawConstant(size_t physicalIndex, const ColourValue& colour, 
            size_t count = 4);


        GpuConstantDefinitionIterator getConstantDefinitionIterator(void) const;

        const GpuConstantDefinition& getConstantDefinition(const String& name) const;

        const GpuNamedConstants& getConstantDefinitions() const;

        const GpuLogicalBufferStructPtr& getFloatLogicalBufferStruct() const { return mFloatLogicalToPhysical; }

        size_t getFloatLogicalIndexForPhysicalIndex(size_t physicalIndex);
        const GpuLogicalBufferStructPtr& getDoubleLogicalBufferStruct() const { return mDoubleLogicalToPhysical; }

        size_t getDoubleLogicalIndexForPhysicalIndex(size_t physicalIndex);
        size_t getIntLogicalIndexForPhysicalIndex(size_t physicalIndex);

        const GpuLogicalBufferStructPtr& getIntLogicalBufferStruct() const { return mIntLogicalToPhysical; }
        const FloatConstantList& getFloatConstantList() const { return mFloatConstants; }
        float* getFloatPointer(size_t pos) { return &mFloatConstants[pos]; }
        const float* getFloatPointer(size_t pos) const { return &mFloatConstants[pos]; }
        const DoubleConstantList& getDoubleConstantList() const { return mDoubleConstants; }
        double* getDoublePointer(size_t pos) { return &mDoubleConstants[pos]; }
        const double* getDoublePointer(size_t pos) const { return &mDoubleConstants[pos]; }
        const IntConstantList& getIntConstantList() const { return mIntConstants; }
        int* getIntPointer(size_t pos) { return &mIntConstants[pos]; }
        const int* getIntPointer(size_t pos) const { return &mIntConstants[pos]; }
        const AutoConstantList& getAutoConstantList() const { return mAutoConstants; }

        void setAutoConstant(size_t index, AutoConstantType acType, size_t extraInfo = 0);
        void setAutoConstantReal(size_t index, AutoConstantType acType, Real rData);

        void setAutoConstant(size_t index, AutoConstantType acType, uint16 extraInfo1, uint16 extraInfo2);

        void _setRawAutoConstant(size_t physicalIndex, AutoConstantType acType, size_t extraInfo, 
            uint16 variability, size_t elementSize = 4);
        void _setRawAutoConstantReal(size_t physicalIndex, AutoConstantType acType, Real rData, 
            uint16 variability, size_t elementSize = 4);


        void clearAutoConstant(size_t index);

        void setConstantFromTime(size_t index, Real factor);

        void clearAutoConstants(void);
        typedef ConstVectorIterator<AutoConstantList> AutoConstantIterator;
        AutoConstantIterator getAutoConstantIterator(void) const;
        size_t getAutoConstantCount(void) const { return mAutoConstants.size(); }
        AutoConstantEntry* getAutoConstantEntry(const size_t index);
        bool hasAutoConstants(void) const { return !(mAutoConstants.empty()); }
        const AutoConstantEntry* findFloatAutoConstantEntry(size_t logicalIndex);
        const AutoConstantEntry* findDoubleAutoConstantEntry(size_t logicalIndex);
        const AutoConstantEntry* findIntAutoConstantEntry(size_t logicalIndex);
        const AutoConstantEntry* findAutoConstantEntry(const String& paramName);
        const AutoConstantEntry* _findRawAutoConstantEntryFloat(size_t physicalIndex);
        const AutoConstantEntry* _findRawAutoConstantEntryDouble(size_t physicalIndex);
        const AutoConstantEntry* _findRawAutoConstantEntryInt(size_t physicalIndex);

        void _updateAutoParams(const AutoParamDataSource* source, uint16 variabilityMask);

        void setIgnoreMissingParams(bool state) { mIgnoreMissingParams = state; }

        void setNamedConstant(const String& name, Real val);
        void setNamedConstant(const String& name, int val);
        void setNamedConstant(const String& name, const Vector4& vec);
        void setNamedConstant(const String& name, const Vector3& vec);
        void setNamedConstant(const String& name, const Vector2& vec);
        void setNamedConstant(const String& name, const Matrix4& m);
        void setNamedConstant(const String& name, const Matrix4* m, size_t numEntries);
        void setNamedConstant(const String& name, const float *val, size_t count, 
            size_t multiple = 4);
        void setNamedConstant(const String& name, const double *val, size_t count, 
            size_t multiple = 4);
        void setNamedConstant(const String& name, const ColourValue& colour);

        void setNamedConstant(const String& name, const int *val, size_t count, 
            size_t multiple = 4);

        void setNamedAutoConstant(const String& name, AutoConstantType acType, size_t extraInfo = 0);
        void setNamedAutoConstantReal(const String& name, AutoConstantType acType, Real rData);

        void setNamedAutoConstant(const String& name, AutoConstantType acType, uint16 extraInfo1, uint16 extraInfo2);

        void setNamedConstantFromTime(const String& name, Real factor);

        void clearNamedAutoConstant(const String& name);

        const GpuConstantDefinition* _findNamedConstantDefinition(
            const String& name, bool throwExceptionIfMissing = false) const;
        size_t _getFloatConstantPhysicalIndex(size_t logicalIndex, size_t requestedSize, uint16 variability);
        size_t _getDoubleConstantPhysicalIndex(size_t logicalIndex, size_t requestedSize, uint16 variability);
        size_t _getIntConstantPhysicalIndex(size_t logicalIndex, size_t requestedSize, uint16 variability);

        void setTransposeMatrices(bool val) { mTransposeMatrices = val; } 
        bool getTransposeMatrices(void) const { return mTransposeMatrices; } 

        void copyConstantsFrom(const GpuProgramParameters& source);

        void copyMatchingNamedConstantsFrom(const GpuProgramParameters& source);

        static const AutoConstantDefinition* getAutoConstantDefinition(const String& name);
        static const AutoConstantDefinition* getAutoConstantDefinition(const size_t idx);
        static size_t getNumAutoConstantDefinitions(void);


        void incPassIterationNumber(void);
        bool hasPassIterationNumber() const 
        { return mActivePassIterationIndex != (std::numeric_limits<size_t>::max)(); }
        size_t getPassIterationNumberIndex() const 
        { return mActivePassIterationIndex; }


        void addSharedParameters(GpuSharedParametersPtr sharedParams);

        void addSharedParameters(const String& sharedParamsName);

        bool isUsingSharedParameters(const String& sharedParamsName) const;

        void removeSharedParameters(const String& sharedParamsName);

        void removeAllSharedParameters();

        const GpuSharedParamUsageList& getSharedParameters() const;

        void _setRenderSystemData(const Any& data) const { mRenderSystemData = data; }
        const Any& _getRenderSystemData() const { return mRenderSystemData; }

        void _copySharedParams();

        size_t calculateSize(void) const;

        void setNamedSubroutine(const String& subroutineSlot, const String& subroutine);
        
        void setSubroutine(size_t index, const String& subroutine);

        const SubroutineMap& getSubroutineMap() const { return mSubroutineMap; }
    };

    typedef SharedPtr<GpuProgramParameters> GpuProgramParametersSharedPtr;

}

#include "OgreHeaderSuffix.h"

#endif