/*
-----------------------------------------------------------------------------
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 __CgFxScriptLoader_H__
#define __CgFxScriptLoader_H__

#include "OgrePrerequisites.h"
#include "OgreSingleton.h"
#include "OgreStringVector.h"
#include "OgreScriptLoader.h"
#include "OgreCgPrerequisites.h"
#include "OgreTexture.h"
#include "OgreTextureUnitState.h"
#include "OgreGpuProgram.h"

namespace Ogre {

    /** Manages Overlay objects, parsing them from .overlay files and
        storing a lookup library of them. Alo manages the creation of 
        OverlayContainers and OverlayElements, used for non-interactive 2D 
        elements such as HUDs.
    */
    class CgFxScriptLoader : public Singleton<CgFxScriptLoader>, public ScriptLoader, public ScriptCompilerAlloc
    {
    public:
    protected:
        /** We want to comply to FXCompositor - this list is the enum FXComposer.Core.FXSemanticID
            that existing in C:\\Program Files\\NVIDIA Corporation\\FX Composer 2.5\\FXComposer.Core.dll
            if you reference if from managed project you can see the list.
            description is from C:\\Program Files\\NVIDIA Corporation\\FX Composer 2.5\\Plugins\\scene\\render\\Data\\fxmapping.xml (open with a text editor and not with the browser)
            and from C:\\Program Files\\NVIDIA Corporation\\FX Composer 2.5\\FXComposer.Core.xml
            */
        enum FXSemanticID
        {
            FXS_NONE,
            FXS_UNKNOWN,
            FXS_POSITION, // desc="A position vector." datatypes="float3"
            FXS_DIRECTION, // desc="A direction vector." datatypes="float3"
            FXS_COLOR, 
            FXS_DIFFUSE, // desc="Color value to be used as the diffuse color.  The fourth channel represents diffuse alpha." datatypes="float4,float3,texture"
            FXS_SPECULAR, // desc="Color value to be used as the specular color.  The fourth channel represents specular alpha." datatypes="float4,float3,texture"
            FXS_AMBIENT, // desc="Color value to be used as the ambient color. The fourth channel represents ambient alpha." datatypes="float4,float3,texture"
            FXS_EMISSION,
            FXS_EMISSIVE, // desc="Color value to be used as the emissive color.  The fourth channel represents emissive alpha." datatypes="float4,float3,texture"
            FXS_SPECULARPOWER, // desc="Power to use for the specular exponent." datatypes="float,float3,float4"
            FXS_REFRACTION, // desc="A refraction map that give the coefficents to determine the norma for an environment map lookup" datatypes="texture"
            FXS_OPACITY, // desc="Opacity of the object." datatypes="texture"
            FXS_ENVIRONMENT, // desc="An environment map." datatypes="texture"
            FXS_ENVIRONMENTNORMAL, // name="environmentnormal" desc="An environment normal map." datatypes="texture"
            FXS_NORMAL, // desc="Normal for the element or texture" datatypes="texture"
            FXS_HEIGHT, // desc="Height for the element when using bump mapping." datatypes="texture"
            FXS_ATTENUATION, // desc="Light attenuation." datatypes="float3"
            FXS_RENDERCOLORTARGET, // desc="Defines the texture as the render target of a pass in the effect." datatypes="texture"
            FXS_RENDERDEPTHSTENCILTARGET, // desc="Defines the texture as the render target of a pass in the effect." datatypes="texture"
            FXS_VIEWPORTPIXELSIZE, // desc="Size of the viewport in pixels" datatypes="float2"
            FXS_CAMERAPOSITION, // desc="Viewer position in world space (replaced by position with space=view annotation)." datatypes="float3"
            FXS_TIME, // desc="The current time (see units annotation for scale)." datatypes="float"
            FXS_ELAPSEDTIME, // desc="The time between adjacent frames (see units annotation for scale)." datatypes="float"
            FXS_ANIMATIONTIME,
            FXS_ANIMATIONTICK,
            FXS_MOUSEPOSITION, // desc="The mouse position on screen (x,y,time)" datatypes="float3"
            FXS_LEFTMOUSEDOWN, // desc="The left mouse down state, and its position at that time ( x, y, isdown, timedown)" datatypes="float4"
            FXS_WORLD, // desc="world-inverse matrix." datatypes="matrix"
            FXS_VIEW, // desc="view matrix." datatypes="matrix"
            FXS_PROJECTION, // desc="projection matrix." datatypes="matrix"
            FXS_WORLDTRANSPOSE, // desc="world-transpose matrix." datatypes="matrix"
            FXS_VIEWTRANSPOSE, // name="worldviewtranspose" desc="world-view-transpose matrix." datatypes="matrix"
            FXS_PROJECTIONTRANSPOSE, // name="viewprojectiontranspose" desc="view-projection-transpose matrix." datatypes="matrix"
            FXS_WORLDVIEW, // desc="world-view matrix." datatypes="matrix"
            FXS_WORLDVIEWPROJECTION, // desc="world-view-projection matrix." datatypes="matrix"
            FXS_WORLDINVERSE, //desc="world-inverse matrix." datatypes="matrix"
            FXS_VIEWINVERSE, // desc="view-inverse matrix." datatypes="matrix"
            FXS_PROJECTIONINVERSE, // desc="projection-inverse matrix." datatypes="matrix"
            FXS_WORLDINVERSETRANSPOSE, // desc="world-inverse-transpose matrix." datatypes="matrix"
            FXS_VIEWINVERSETRANSPOSE, // desc="view-inverse-transpose matrix." datatypes="matrix"
            FXS_PROJECTIONINVERSETRANSPOSE, // desc="projection-inverse-transpose matrix." datatypes="matrix"
            FXS_WORLDVIEWINVERSE, // desc="world-view-inverse matrix." datatypes="matrix"
            FXS_WORLDVIEWTRANSPOSE, // desc="world-view-transpose matrix." datatypes="matrix"
            FXS_WORLDVIEWINVERSETRANSPOSE, // desc="world-view-inverse-transpose matrix." datatypes="matrix"
            FXS_WORLDVIEWPROJECTIONINVERSE, // desc="world-view-projection-inverse matrix." datatypes="matrix"
            FXS_WORLDVIEWPROJECTIONTRANSPOSE,
            FXS_WORLDVIEWPROJECTIONINVERSETRANSPOSE, // name="worldviewprojectioninversetranspose" desc="world-view-projection-inverse-transpose matrix." datatypes="matrix"
            FXS_VIEWPROJECTION, // desc="view-projection matrix." datatypes="matrix"
            FXS_VIEWPROJECTIONTRANSPOSE, // desc="view-projection-transpose matrix." datatypes="matrix"
            FXS_VIEWPROJECTIONINVERSE, // desc="world-view-projection-inverse matrix." datatypes="matrix"
            FXS_VIEWPROJECTIONINVERSETRANSPOSE, // desc="world-view-projection-inverse-transpose matrix." datatypes="matrix"
            FXS_FXCOMPOSER_RESETPULSE, // desc="A pulsed boolean, reset on window resize or from the FX Composer user interface." datatypes="bool"
            FXS_STANDARDSGLOBAL, // desc="Standards version and global annotations" datatypes="float"
            FXS_UNITSSCALE, // desc="Defines the modeling proportions to the current unit/space." datatypes="float"
            FXS_POWER, // Power factor
            FXS_DIFFUSEMAP, // A diffuse texture map
            FXS_SPECULARMAP, // A specular texture map
            FXS_ENVMAP, // An env map
            FXS_LIGHTPOSITION, // light position
            FXS_TRANSFORM, // A transform
            FXS_USER, // User Semantics - Semantics Remapper Special
            FXS_CONSTANTATTENUATION,
            FXS_LINEARATTENUATION,
            FXS_QUADRATICATTENUATION,
            FXS_FALLOFFANGLE,
            FXS_FALLOFFEXPONENT,
            FXS_BOUNDINGRADIUS
        };

        enum GlobalStateType
        {
            GST_UNKNOWN,
            GST_ALPHABLENDENABLE,  //AlphaBlendEnable
            GST_ALPHAFUNC,  //AlphaFunc
            GST_ALPHAREF,  //AlphaRef
            GST_BLENDOP,  //BlendOp
            GST_BLENDEQUATION,  //BlendEquation
            GST_BLENDFUNC,  //BlendFunc
            GST_BLENDFUNCSEPARATE,  //BlendFuncSeparate
            GST_BLENDEQUATIONSEPARATE,  //BlendEquationSeparate
            GST_BLENDCOLOR,  //BlendColor
            GST_CLEARCOLOR,  //ClearColor
            GST_CLEARSTENCIL,  //ClearStencil
            GST_CLEARDEPTH,  //ClearDepth
            GST_CLIPPLANE,  //ClipPlane
            GST_CLIPPLANEENABLE,  //ClipPlaneEnable
            GST_COLORWRITEENABLE,  //ColorWriteEnable
            GST_COLORMASK,  //ColorMask
            GST_COLORVERTEX,  //ColorVertex
            GST_COLORMATERIAL,  //ColorMaterial
            GST_COLORMATRIX,  //ColorMatrix
            GST_COLORTRANSFORM,  //ColorTransform
            GST_CULLFACE,  //CullFace
            GST_CULLMODE,  //CullMode
            GST_DEPTHBOUNDS,  //DepthBounds
            GST_DEPTHBIAS,  //DepthBias
            GST_DESTBLEND,  //DestBlend
            GST_DEPTHFUNC,  //DepthFunc
            GST_ZFUNC,  //ZFunc
            GST_DEPTHMASK,  //DepthMask
            GST_ZWRITEENABLE,  //ZWriteEnable
            GST_DEPTHRANGE,  //DepthRange
            GST_FOGDISTANCEMODE,  //FogDistanceMode
            GST_FOGMODE,  //FogMode
            GST_FOGTABLEMODE,  //FogTableMode
            GST_INDEXEDVERTEXBLENDENABLE,  //IndexedVertexBlendEnable
            GST_FOGDENSITY,  //FogDensity
            GST_FOGSTART,  //FogStart
            GST_FOGEND,  //FogEnd
            GST_FOGCOLOR,  //FogColor
            GST_FRAGMENTENVPARAMETER,  //FragmentEnvParameter
            GST_FRAGMENTLOCALPARAMETER,  //FragmentLocalParameter
            GST_FOGCOORDSRC,  //FogCoordSrc
            GST_FOGVERTEXMODE,  //FogVertexMode
            GST_FRONTFACE,  //FrontFace
            GST_LIGHTMODELAMBIENT,  //LightModelAmbient
            GST_AMBIENT,  //Ambient
            GST_LIGHTINGENABLE,  //LightingEnable
            GST_LIGHTENABLE,  //LightEnable
            GST_LIGHTAMBIENT,  //LightAmbient
            GST_LIGHTCONSTANTATTENUATION,  //LightConstantAttenuation
            GST_LIGHTATTENUATION0,  //LightAttenuation0
            GST_LIGHTDIFFUSE,  //LightDiffuse
            GST_LIGHTLINEARATTENUATION,  //LightLinearAttenuation
            GST_LIGHTATTENUATION1,  //LightAttenuation1
            GST_LIGHTPOSITION,  //LightPosition
            GST_LIGHTQUADRATICATTENUATION,  //LightQuadraticAttenuation
            GST_LIGHTATTENUATION2,  //LightAttenuation2
            GST_LIGHTSPECULAR,  //LightSpecular
            GST_LIGHTSPOTCUTOFF,  //LightSpotCutoff
            GST_LIGHTFALLOFF,  //LightFalloff
            GST_LIGHTSPOTDIRECTION,  //LightSpotDirection
            GST_LIGHTDIRECTION,  //LightDirection
            GST_LIGHTSPOTEXPONENT,  //LightSpotExponent
            GST_LIGHTPHI,  //LightPhi
            GST_LIGHTRANGE,  //LightRange
            GST_LIGHTTHETA,  //LightTheta
            GST_LIGHTTYPE,  //LightType
            GST_LOCALVIEWER,  //LocalViewer
            GST_MULTISAMPLEANTIALIAS,  //MultiSampleAntialias
            GST_MULTISAMPLEMASK,  //MultiSampleMask
            GST_PATCHSEGMENTS,  //PatchSegments
            GST_POINTSCALE_A,  //PointScale_A
            GST_POINTSCALE_B,  //PointScale_B
            GST_POINTSCALE_C,  //PointScale_C
            GST_POINTSCALEENABLE,  //PointScaleEnable
            GST_RANGEFOGENABLE,  //RangeFogEnable
            GST_SPECULARENABLE,  //SpecularEnable
            GST_TWEENFACTOR,  //TweenFactor
            GST_VERTEXBLEND,  //VertexBlend
            GST_AMBIENTMATERIALSOURCE,  //AmbientMaterialSource
            GST_DIFFUSEMATERIALSOURCE,  //DiffuseMaterialSource
            GST_EMISSIVEMATERIALSOURCE,  //EmissiveMaterialSource
            GST_SPECULARMATERIALSOURCE,  //SpecularMaterialSource
            GST_CLIPPING,  //Clipping
            GST_LIGHTMODELCOLORCONTROL,  //LightModelColorControl
            GST_LINESTIPPLE,  //LineStipple
            GST_LINEWIDTH,  //LineWidth
            GST_LOGICOP,  //LogicOp
            GST_MATERIALAMBIENT,  //MaterialAmbient
            GST_MATERIALDIFFUSE,  //MaterialDiffuse
            GST_MATERIALEMISSION,  //MaterialEmission
            GST_MATERIALEMISSIVE,  //MaterialEmissive
            GST_MATERIALSHININESS,  //MaterialShininess
            GST_MATERIALPOWER,  //MaterialPower
            GST_MATERIALSPECULAR,  //MaterialSpecular
            GST_MODELVIEWMATRIX,  //ModelViewMatrix
            GST_MODELVIEWTRANSFORM,  //ModelViewTransform
            GST_VIEWTRANSFORM,  //ViewTransform
            GST_WORLDTRANSFORM,  //WorldTransform
            GST_POINTDISTANCEATTENUATION,  //PointDistanceAttenuation
            GST_POINTFADETHRESHOLDSIZE,  //PointFadeThresholdSize
            GST_POINTSIZE,  //PointSize
            GST_POINTSIZEMIN,  //PointSizeMin
            GST_POINTSIZEMAX,  //PointSizeMax
            GST_POINTSPRITECOORDORIGIN,  //PointSpriteCoordOrigin
            GST_POINTSPRITECOORDREPLACE,  //PointSpriteCoordReplace
            GST_POINTSPRITERMODE,  //PointSpriteRMode
            GST_POLYGONMODE,  //PolygonMode
            GST_FILLMODE,  //FillMode
            GST_LASTPIXEL,  //LastPixel
            GST_POLYGONOFFSET,  //PolygonOffset
            GST_PROJECTIONMATRIX,  //ProjectionMatrix
            GST_PROJECTIONTRANSFORM,  //ProjectionTransform
            GST_SCISSOR,  //Scissor
            GST_SHADEMODEL,  //ShadeModel
            GST_SHADEMODE,  //ShadeMode
            GST_SLOPSCALEDEPTHBIAS,  //SlopScaleDepthBias
            GST_SRCBLEND,  //SrcBlend
            GST_STENCILFUNC,  //StencilFunc
            GST_STENCILMASK,  //StencilMask
            GST_STENCILPASS,  //StencilPass
            GST_STENCILREF,  //StencilRef
            GST_STENCILWRITEMASK,  //StencilWriteMask
            GST_STENCILZFAIL,  //StencilZFail
            GST_TEXTUREFACTOR,  //TextureFactor
            GST_STENCILOP,  //StencilOp
            GST_STENCILFUNCSEPARATE,  //StencilFuncSeparate
            GST_STENCILMASKSEPARATE,  //StencilMaskSeparate
            GST_STENCILOPSEPARATE,  //StencilOpSeparate
            GST_TEXGENSMODE,  //TexGenSMode
            GST_TEXGENSOBJECTPLANE,  //TexGenSObjectPlane
            GST_TEXGENSEYEPLANE,  //TexGenSEyePlane
            GST_TEXGENTMODE,  //TexGenTMode
            GST_TEXGENTOBJECTPLANE,  //TexGenTObjectPlane
            GST_TEXGENTEYEPLANE,  //TexGenTEyePlane
            GST_TEXGENRMODE,  //TexGenRMode
            GST_TEXGENROBJECTPLANE,  //TexGenRObjectPlane
            GST_TEXGENREYEPLANE,  //TexGenREyePlane
            GST_TEXGENQMODE,  //TexGenQMode
            GST_TEXGENQOBJECTPLANE,  //TexGenQObjectPlane
            GST_TEXGENQEYEPLANE,  //TexGenQEyePlane
            GST_TEXTUREENVCOLOR,  //TextureEnvColor
            GST_TEXTUREENVMODE,  //TextureEnvMode
            GST_TEXTURE1D,  //Texture1D
            GST_TEXTURE2D,  //Texture2D
            GST_TEXTURE3D,  //Texture3D
            GST_TEXTURERECTANGLE,  //TextureRectangle
            GST_TEXTURECUBEMAP,  //TextureCubeMap
            GST_TEXTURE1DENABLE,  //Texture1DEnable
            GST_TEXTURE2DENABLE,  //Texture2DEnable
            GST_TEXTURE3DENABLE,  //Texture3DEnable
            GST_TEXTURERECTANGLEENABLE,  //TextureRectangleEnable
            GST_TEXTURECUBEMAPENABLE,  //TextureCubeMapEnable
            GST_TEXTURETRANSFORM,  //TextureTransform
            GST_TEXTUREMATRIX,  //TextureMatrix
            GST_VERTEXENVPARAMETER,  //VertexEnvParameter
            GST_VERTEXLOCALPARAMETER,  //VertexLocalParameter
            GST_ALPHATESTENABLE,  //AlphaTestEnable
            GST_AUTONORMALENABLE,  //AutoNormalEnable
            GST_BLENDENABLE,  //BlendEnable
            GST_COLORLOGICOPENABLE,  //ColorLogicOpEnable
            GST_CULLFACEENABLE,  //CullFaceEnable
            GST_DEPTHBOUNDSENABLE,  //DepthBoundsEnable
            GST_DEPTHCLAMPENABLE,  //DepthClampEnable
            GST_DEPTHTESTENABLE,  //DepthTestEnable
            GST_ZENABLE,  //ZEnable
            GST_DITHERENABLE,  //DitherEnable
            GST_FOGENABLE,  //FogEnable
            GST_LIGHTMODELLOCALVIEWERENABLE,  //LightModelLocalViewerEnable
            GST_LIGHTMODELTWOSIDEENABLE,  //LightModelTwoSideEnable
            GST_LINESMOOTHENABLE,  //LineSmoothEnable
            GST_LINESTIPPLEENABLE,  //LineStippleEnable
            GST_LOGICOPENABLE,  //LogicOpEnable
            GST_MULTISAMPLEENABLE,  //MultisampleEnable
            GST_NORMALIZEENABLE,  //NormalizeEnable
            GST_POINTSMOOTHENABLE,  //PointSmoothEnable
            GST_POINTSPRITEENABLE,  //PointSpriteEnable
            GST_POLYGONOFFSETFILLENABLE,  //PolygonOffsetFillEnable
            GST_POLYGONOFFSETLINEENABLE,  //PolygonOffsetLineEnable
            GST_POLYGONOFFSETPOINTENABLE,  //PolygonOffsetPointEnable
            GST_POLYGONSMOOTHENABLE,  //PolygonSmoothEnable
            GST_POLYGONSTIPPLEENABLE,  //PolygonStippleEnable
            GST_RESCALENORMALENABLE,  //RescaleNormalEnable
            GST_SAMPLEALPHATOCOVERAGEENABLE,  //SampleAlphaToCoverageEnable
            GST_SAMPLEALPHATOONEENABLE,  //SampleAlphaToOneEnable
            GST_SAMPLECOVERAGEENABLE,  //SampleCoverageEnable
            GST_SCISSORTESTENABLE,  //ScissorTestEnable
            GST_STENCILTESTENABLE,  //StencilTestEnable
            GST_STENCILENABLE,  //StencilEnable
            GST_STENCILTESTTWOSIDEENABLE,  //StencilTestTwoSideEnable
            GST_STENCILFAIL,  //StencilFail
            GST_TEXGENSENABLE,  //TexGenSEnable
            GST_TEXGENTENABLE,  //TexGenTEnable
            GST_TEXGENRENABLE,  //TexGenREnable
            GST_TEXGENQENABLE,  //TexGenQEnable
            GST_WRAP0,  //Wrap0
            GST_WRAP1,  //Wrap1
            GST_WRAP2,  //Wrap2
            GST_WRAP3,  //Wrap3
            GST_WRAP4,  //Wrap4
            GST_WRAP5,  //Wrap5
            GST_WRAP6,  //Wrap6
            GST_WRAP7,  //Wrap7
            GST_WRAP8,  //Wrap8
            GST_WRAP9,  //Wrap9
            GST_WRAP10,  //Wrap10
            GST_WRAP11,  //Wrap11
            GST_WRAP12,  //Wrap12
            GST_WRAP13,  //Wrap13
            GST_WRAP14,  //Wrap14
            GST_WRAP15,  //Wrap15
            GST_VERTEXPROGRAMPOINTSIZEENABLE,  //VertexProgramPointSizeEnable
            GST_VERTEXPROGRAMTWOSIDEENABLE,  //VertexProgramTwoSideEnable
            GST_GEOMETRYPROGRAM,  //GeometryProgram
            GST_VERTEXPROGRAM,  //VertexProgram
            GST_FRAGMENTPROGRAM,  //FragmentProgram
            GST_VERTEXSHADER,  //VertexShader
            GST_PIXELSHADER,  //PixelShader
            GST_ALPHAOP,  //AlphaOp
            GST_ALPHAARG0,  //AlphaArg0
            GST_ALPHAARG1,  //AlphaArg1
            GST_ALPHAARG2,  //AlphaArg2
            GST_COLORARG0,  //ColorArg0
            GST_COLORARG1,  //ColorArg1
            GST_COLORARG2,  //ColorArg2
            GST_COLOROP,  //ColorOp
            GST_BUMPENVLSCALE,  //BumpEnvLScale
            GST_BUMPENVLOFFSET,  //BumpEnvLOffset
            GST_BUMPENVMAT00,  //BumpEnvMat00
            GST_BUMPENVMAT01,  //BumpEnvMat01
            GST_BUMPENVMAT10,  //BumpEnvMat10
            GST_BUMPENVMAT11,  //BumpEnvMat11
            GST_RESULTARG,  //ResultArg
            GST_TEXCOORDINDEX,  //TexCoordIndex
            GST_TEXTURETRANSFORMFLAGS,  //TextureTransformFlags
            GST_TWOSIDEDSTENCILMODE, // TwoSidedStencilMode
            GST_SEPARATEALPHABLENDENABLE, // SeparateAlphaBlendEnable
            GST_NORMALIZENORMALS, // NormalizeNormals
            GST_LIGHTING, // Lighting
            GST_PIXELSHADERCONSTANTB, // PixelShaderConstantB
            GST_VERTEXSHADERCONSTANTB, // VertexShaderConstantB
            GST_COLORWRITEENABLE1, // ColorWriteEnable1
            GST_COLORWRITEENABLE2, // ColorWriteEnable2
            GST_COLORWRITEENABLE3, // ColorWriteEnable3
            GST_PIXELSHADERCONSTANT1, // PixelShaderConstant1
            GST_VERTEXSHADERCONSTANT1, // VertexShaderConstant1
            GST_PIXELSHADERCONSTANTF, // PixelShaderConstantF
            GST_VERTEXSHADERCONSTANTF, // VertexShaderConstantF
            GST_PIXELSHADERCONSTANT2, // PixelShaderConstant2
            GST_VERTEXSHADERCONSTANT2, // VertexShaderConstant2
            GST_PIXELSHADERCONSTANT3, // PixelShaderConstant3
            GST_VERTEXSHADERCONSTANT3, // VertexShaderConstant3
            GST_PIXELSHADERCONSTANT, // PixelShaderConstant
            GST_VERTEXSHADERCONSTANT, // VertexShaderConstant
            GST_PIXELSHADERCONSTANT4, // PixelShaderConstant4
            GST_VERTEXSHADERCONSTANT4, // VertexShaderConstant4
            GST_PIXELSHADERCONSTANTI, // PixelShaderConstantI
            GST_VERTEXSHADERCONSTANTI, // VertexShaderConstantI
            GST_SAMPLER,  // Sampler
            GST_TEXTURE, // Texture

            GST_ADDRESSU, // AddressU
            GST_ADDRESSV, // AddressV
            GST_ADDRESSW, // AddressW
            GST_BORDERCOLOR, // BorderColor
            GST_MAXANISOTROPY, // MaxAnisotropy
            GST_MAXMIPLEVEL, // MaxMipLevel
            GST_MINFILTER, // MinFilter
            GST_MAGFILTER, // MagFilter
            GST_MIPFILTER, // MipFilter
            GST_MIPMAPLODBIAS, // MipMapLodBias
            GST_BLENDOPALPHA, // BlendOpAlpha
            GST_SRCBLENDALPHA, // SrcBlendAlpha
            GST_DESTBLENDALPHA, // DestBlendAlpha


            GST_COUNT
        };
#define GST_FIRST (GlobalStateType) (GST_UNKNOWN + (GlobalStateType)1)

        enum SamplerStateType
        {
            SST_UNKNOWN,
            SST_TEXTURE, // Texture
            SST_ADDRESSU, // AddressU
            SST_ADDRESSV, // AddressV
            SST_ADDRESSW, // AddressW
            SST_WRAPS, // WrapS
            SST_WRAPT, // WrapT
            SST_WRAPR, // WrapR
            SST_MIPFILTER, // MipFilter
            SST_MIPMAPLODBIAS, // MipMapLodBias
            SST_LODBIAS, // LODBias
            SST_SRGBTEXTURE, // SRGBTexture
            SST_MINFILTER, // MinFilter
            SST_MAGFILTER, // MagFilter
            SST_BORDERCOLOR, // BorderColor
            SST_MINMIPLEVEL, // MinMipLevel
            SST_MAXMIPLEVEL, // MaxMipLevel
            SST_MAXANISOTROPY, // MaxAnisotropy
            SST_DEPTHMODE, // DepthMode
            SST_COMPAREMODE, // CompareMode
            SST_COMPAREFUNC, // CompareFunc
            SST_GENERATEMIPMAP, // GenerateMipmap
            SST_COUNT
        };

#define SST_FIRST (SamplerStateType) (SST_UNKNOWN + (SamplerStateType)1)

        // some simple types to make working with CGstateassignment easier

        struct Vector1b
        {
            bool x;
            Vector1b();
            Vector1b( bool iX );
            Vector1b( CGstateassignment cgStateAssignment );
            operator bool() const;
        };

        struct Vector2b
        {
            bool x, y;
            Vector2b();
            Vector2b( bool iX, bool iY , bool iZ, bool iW );
            Vector2b( CGstateassignment cgStateAssignment );
        };

        struct Vector3b
        {
            bool x, y, z;
            Vector3b();
            Vector3b( bool iX, bool iY , bool iZ, bool iW );
            Vector3b( CGstateassignment cgStateAssignment );
        };

        struct Vector4b
        {
            bool x, y, z, w;
            Vector4b();
            Vector4b( bool iX, bool iY , bool iZ, bool iW );
            Vector4b( CGstateassignment cgStateAssignment );
        };

        struct Vector1i
        {
            int x;
            Vector1i();
            Vector1i( int iX );
            Vector1i( CGstateassignment cgStateAssignment );
            operator int() const;

        };

        struct Vector2i
        {
            int x, y;
            Vector2i();
            Vector2i( int iX, int iY );
            Vector2i( CGstateassignment cgStateAssignment );
        };

        struct Vector3i
        {
            int x, y, z;
            Vector3i();
            Vector3i( int iX, int iY, int iZ );
            Vector3i( CGstateassignment cgStateAssignment );
        };


        struct Vector4i
        {
            int x, y, z, w;
            Vector4i();
            Vector4i( int iX, int iY, int iZ, int iW );
            Vector4i( CGstateassignment cgStateAssignment );
        };


        struct Vector1f
        {
            float x;
            Vector1f();
            Vector1f( float iX, float iY, float iZ );
            Vector1f( CGstateassignment cgStateAssignment );
            operator float() const;
        };


        struct Vector2f
        {
            float x, y;
            Vector2f();
            Vector2f( float iX, float iY, float iZ );
            Vector2f( CGstateassignment cgStateAssignment );
        };


        struct Vector3f
        {
            float x, y, z;
            Vector3f();
            Vector3f( float iX, float iY, float iZ );
            Vector3f( CGstateassignment cgStateAssignment );
        };

        struct Vector4f
        {
            float x, y, z, w;
            Vector4f();
            Vector4f( float iX, float iY, float iZ, float iW );
            Vector4f( CGstateassignment cgStateAssignment );
        };



        // simple types end


        class CgStateListener : public GeneralAllocatedObject
        {
        protected:
            CGstate mCgState;
            CGtype mCgType;
            CGcontext mCgContext;

            static CGbool cgCallBackSet( CGstateassignment cgStateAssignment );
            static CGbool cgCallBackReset( CGstateassignment cgStateAssignment );
            static CGbool cgCallBackValidate( CGstateassignment cgStateAssignment );

            virtual CGstatecallback getCgCallBackSet();
            virtual CGstatecallback getCgCallBackReset();
            virtual CGstatecallback getCgCallBackValidate();

            virtual void createState() = 0;
            void addStateEnumerant( int value, const char *name );

            CGparameter getCgParameter( CGstateassignment cgStateAssignment );


        public:
            CgStateListener( CGtype cgType );
            virtual ~CgStateListener();
            virtual void init();
            CGstate getCgState() const;
        };

        typedef vector<CgStateListener *>::type CgStateListenerVector;

        class CgGlobalStateListener : public CgStateListener
        {
        protected:
            const GlobalStateType mGlobalStateType;
            virtual void createState();
        public:
            CgGlobalStateListener( const GlobalStateType globalStateType, CGtype cgType );
            virtual ~CgGlobalStateListener();

            virtual void updatePass( Pass * ogrePass, CGstateassignment cgStateAssignment );
        };
        /// Bool
        class CgBoolGlobalStateListener : public CgGlobalStateListener
        {
        protected:
            const Vector1b getValue( CGstateassignment cgStateAssignment );
        public:
            CgBoolGlobalStateListener( const GlobalStateType globalStateType );
            virtual void updatePass( Pass * ogrePass, CGstateassignment cgStateAssignment );
        };
        /// Bool4
        class CgBool4GlobalStateListener : public CgGlobalStateListener
        {
        protected:
            const Vector4b getValue( CGstateassignment cgStateAssignment );
        public:
            CgBool4GlobalStateListener( const GlobalStateType globalStateType );
            virtual void updatePass( Pass * ogrePass, CGstateassignment cgStateAssignment );
        };
        /// Float
        class CgFloatGlobalStateListener : public CgGlobalStateListener
        {
        protected:
            const Vector1f getValue( CGstateassignment cgStateAssignment );
        public:
            CgFloatGlobalStateListener( const GlobalStateType globalStateType );
            virtual void updatePass( Pass * ogrePass, CGstateassignment cgStateAssignment );
        };
        /// Float2
        class CgFloat2GlobalStateListener : public CgGlobalStateListener
        {
        protected:
            const Vector2f getValue( CGstateassignment cgStateAssignment );
        public:
            CgFloat2GlobalStateListener( const GlobalStateType globalStateType );
            virtual void updatePass( Pass * ogrePass, CGstateassignment cgStateAssignment );
        };
        /// Float3
        class CgFloat3GlobalStateListener : public CgGlobalStateListener
        {
        protected:
            const Vector3f getValue( CGstateassignment cgStateAssignment );
        public:
            CgFloat3GlobalStateListener( const GlobalStateType globalStateType );
            virtual void updatePass( Pass * ogrePass, CGstateassignment cgStateAssignment );
        };
        /// Float4
        class CgFloat4GlobalStateListener : public CgGlobalStateListener
        {
        protected:
            const Vector4f getValue( CGstateassignment cgStateAssignment );
        public:
            CgFloat4GlobalStateListener( const GlobalStateType globalStateType );
            virtual void updatePass( Pass * ogrePass, CGstateassignment cgStateAssignment );
        };
        /// Float4x2
        class CgFloat4x2GlobalStateListener : public CgGlobalStateListener
        {
        public:
            CgFloat4x2GlobalStateListener( const GlobalStateType globalStateType );
            virtual void updatePass( Pass * ogrePass, CGstateassignment cgStateAssignment );
        };
        /// Float4x3
        class CgFloat4x3GlobalStateListener : public CgGlobalStateListener
        {
        public:
            CgFloat4x3GlobalStateListener( const GlobalStateType globalStateType );
            virtual void updatePass( Pass * ogrePass, CGstateassignment cgStateAssignment );
        };
        /// Float4x4
        class CgFloat4x4GlobalStateListener : public CgGlobalStateListener
        {
        public:
            CgFloat4x4GlobalStateListener( const GlobalStateType globalStateType );
            virtual void updatePass( Pass * ogrePass, CGstateassignment cgStateAssignment );
        };
        /// Int
        class CgIntGlobalStateListener : public CgGlobalStateListener
        {
        protected:
            const Vector1i getValue( CGstateassignment cgStateAssignment );
        public:
            CgIntGlobalStateListener( const GlobalStateType globalStateType );
            virtual void updatePass( Pass * ogrePass, CGstateassignment cgStateAssignment );
        };
        /// Int2
        class CgInt2GlobalStateListener : public CgGlobalStateListener
        {
        protected:
            const Vector2i getValue( CGstateassignment cgStateAssignment );
        public:
            CgInt2GlobalStateListener( const GlobalStateType globalStateType );
            virtual void updatePass( Pass * ogrePass, CGstateassignment cgStateAssignment );
        };
        /// Int3
        class CgInt3GlobalStateListener : public CgGlobalStateListener
        {
        protected:
            const Vector3i getValue( CGstateassignment cgStateAssignment );
        public:
            CgInt3GlobalStateListener( const GlobalStateType globalStateType );
            virtual void updatePass( Pass * ogrePass, CGstateassignment cgStateAssignment );
        };
        /// Int4
        class CgInt4GlobalStateListener : public CgGlobalStateListener
        {
        protected:
            const Vector4i getValue( CGstateassignment cgStateAssignment );
        public:
            CgInt4GlobalStateListener( const GlobalStateType globalStateType );
            virtual void updatePass( Pass * ogrePass, CGstateassignment cgStateAssignment );
        };
        /// Sampler
        class CgSamplerGlobalStateListener : public CgGlobalStateListener
        {
        public:
            CgSamplerGlobalStateListener( const GlobalStateType globalStateType );
            virtual void updatePass( Pass * ogrePass, CGstateassignment cgStateAssignment );
        };
        /// Sampler2
        class CgSampler2GlobalStateListener : public CgGlobalStateListener
        {
        public:
            CgSampler2GlobalStateListener( const GlobalStateType globalStateType );
            virtual void updatePass( Pass * ogrePass, CGstateassignment cgStateAssignment );
        };
        /// Sampler3
        class CgSampler3GlobalStateListener : public CgGlobalStateListener
        {
        public:
            CgSampler3GlobalStateListener( const GlobalStateType globalStateType );
            virtual void updatePass( Pass * ogrePass, CGstateassignment cgStateAssignment );
        };
        /// SamplerCube
        class CgSamplerCubeGlobalStateListener : public CgGlobalStateListener
        {
        public:
            CgSamplerCubeGlobalStateListener( const GlobalStateType globalStateType );
            virtual void updatePass( Pass * ogrePass, CGstateassignment cgStateAssignment );
        };
        /// SamplerRect
        class CgSamplerRectGlobalStateListener : public CgGlobalStateListener
        {
        public:
            CgSamplerRectGlobalStateListener( const GlobalStateType globalStateType );
            virtual void updatePass( Pass * ogrePass, CGstateassignment cgStateAssignment );
        };
        /// Texture
        class CgTextureGlobalStateListener : public CgGlobalStateListener
        {
        public:
            CgTextureGlobalStateListener( const GlobalStateType globalStateType );
            virtual void updatePass( Pass * ogrePass, CGstateassignment cgStateAssignment );
        };
        /// Program
        class CgProgramGlobalStateListener : public CgGlobalStateListener
        {
        public:
            CgProgramGlobalStateListener( const GlobalStateType globalStateType );
            virtual void updatePass( Pass * ogrePass, CGstateassignment cgStateAssignment );
        };

        /// BlendEquation
        class CgBlendEquationGlobalStateListener : public CgIntGlobalStateListener
        {
        protected:
            enum BlendEquationType
            {
                BET_FUNCADD, // FuncAdd
                BET_FUNCSUBTRACT,  // FuncSubtract
                BET_MIN, // Min
                BET_MAX,  // Max
                BET_LOGICOP // LogicOp
            };
            virtual void createState();
        public:
            CgBlendEquationGlobalStateListener();
            virtual void updatePass( Pass * ogrePass, CGstateassignment cgStateAssignment );
        };
        /// DepthFunc
        class CgDepthFuncGlobalStateListener : public CgIntGlobalStateListener
        {
        protected:
            enum DepthFuncType
            {
                DFT_NEVER,  // Never
                DFT_LESS, // Less
                DFT_LEQUAL,  // LEqual
                DFT_EQUAL, // Equal
                DFT_GREATER,  // Greater
                DFT_NOTEQUAL, // NotEqual
                DFT_GEQUAL,  // GEqual
                DFT_ALWAYS // Always
            };
            virtual void createState();
        public:
            CgDepthFuncGlobalStateListener();
            virtual void updatePass( Pass * ogrePass, CGstateassignment cgStateAssignment );
        };
        /// FogDistanceMode
        class CgFogDistanceModeGlobalStateListener : public CgIntGlobalStateListener
        {
        protected:
            enum FogDistanceModeType
            {
                FDMT_EYERADIAL, // EyeRadial
                FDMT_EYEPLANE, // EyePlane
                FDMT_EYEPLANEABSOLUTE // EyePlaneAbsolute
            };
            virtual void createState();
        public:
            CgFogDistanceModeGlobalStateListener();
            virtual void updatePass( Pass * ogrePass, CGstateassignment cgStateAssignment );
        };
        /// FogMode
        class CgFogModeGlobalStateListener : public CgIntGlobalStateListener
        {
        protected:
            enum FogModeType
            {
                FMT_LINEAR, // Linear
                FMT_EXP,  // Exp
                FMT_EXP2 // Exp2
            };
            virtual void createState();
        public:
            CgFogModeGlobalStateListener();
            virtual void updatePass( Pass * ogrePass, CGstateassignment cgStateAssignment );
        };      
        
        /// LightModelColorControl
        class CgLightModelColorControlGlobalStateListener : public CgIntGlobalStateListener
        {
        protected:
            enum LightModelColorControlType
            {
                LMCCT_SINGLECOLOR, // SingleColor
                LMCCT_SEPARATESPECULAR // SeparateSpecular
            };
            virtual void createState();
        public:
            CgLightModelColorControlGlobalStateListener();
            virtual void updatePass( Pass * ogrePass, CGstateassignment cgStateAssignment );
        };      
        /// LogicOp
        class CgLogicOpGlobalStateListener : public CgIntGlobalStateListener
        {
        protected:
            enum LogicOpType
            {
                LOT_CLEAR,  // Clear
                LOT_AND, // And
                LOT_ANDREVERSE,  // AndReverse
                LOT_COPY, // Copy
                LOT_ANDINVERTED,  // AndInverted
                LOT_NOOP, // Noop
                LOT_XOR,  // Xor
                LOT_OR,  // Or,
                LOT_NOR, // Nor
                LOT_EQUIV,  // Equiv
                LOT_INVERT, // Invert
                LOT_ORREVERSE, // OrReverse
                LOT_COPYINVERTED, // CopyInverted
                LOT_NAND,  // Nand
                LOT_SET // Set
            };
            virtual void createState();
        public:
            CgLogicOpGlobalStateListener();
            virtual void updatePass( Pass * ogrePass, CGstateassignment cgStateAssignment );
        };      
        /// PointSpriteCoordOrigin
        class CgPointSpriteCoordOriginGlobalStateListener : public CgIntGlobalStateListener
        {
        protected:
            enum PointSpriteCoordOriginType
            {
                PSCOT_LOWERLEFT, // LowerLeft
                PSCOT_UPPERLEFT // UpperLeft
            };
            virtual void createState();
        public:
            CgPointSpriteCoordOriginGlobalStateListener();
            virtual void updatePass( Pass * ogrePass, CGstateassignment cgStateAssignment );
        };      
        /// PointSpriteRMode
        class CgPointSpriteRModeGlobalStateListener : public CgIntGlobalStateListener
        {
        protected:
            enum PointSpriteRModeType
            {
                PSRMT_ZERO,  // Zero
                PSRMT_R,  // R
                PSRMT_S // S
            };
            virtual void createState();
        public:
            CgPointSpriteRModeGlobalStateListener();
            virtual void updatePass( Pass * ogrePass, CGstateassignment cgStateAssignment );
        };  
        /// ShadeModel
        class CgShadeModelGlobalStateListener : public CgIntGlobalStateListener
        {
        protected:
            enum ShadeModelType
            {
                SMT_FLAT,  // Flat
                SMT_SMOOTH // Smooth
            };
            virtual void createState();
            virtual void updatePass( Pass * ogrePass, CGstateassignment cgStateAssignment );
        public:
            CgShadeModelGlobalStateListener();
        };  
        /// TexGenMode
        class CgTexGenModeGlobalStateListener : public CgIntGlobalStateListener
        {
        protected:
            enum TexGenModeType
            {
                TGMT_OBJECTLINEAR, // ObjectLinear
                TGMT_EYELINEAR, // EyeLinear
                TGMT_SPHEREMAP, // SphereMap
                TGMT_REFLECTIONMAP, // ReflectionMap
                TGMT_NORMALMAP // NormalMap
            };
            virtual void createState();
        public:
            CgTexGenModeGlobalStateListener( const GlobalStateType globalStateType );
            virtual void updatePass( Pass * ogrePass, CGstateassignment cgStateAssignment );
        };  
        /// TextureEnvMode
        class CgTextureEnvModeGlobalStateListener : public CgIntGlobalStateListener
        {
        protected:
            enum TextureEnvModeType
            {
                BET_MODULATE,  // Modulate
                BET_DECAL, // Decal
                BET_BLEND,  // Blend
                BET_REPLACE, // Replace
                BET_ADD // Add
            };
            virtual void createState();
        public:
            CgTextureEnvModeGlobalStateListener();
            virtual void updatePass( Pass * ogrePass, CGstateassignment cgStateAssignment );
        };  
            /// MinFilter
            class CgMinFilterGlobalStateListener : public CgIntGlobalStateListener
        {
        protected:
            enum MinFilterType
            {
                MFT_NEAREST,  // Nearest
                MFT_LINEAR, // Linear
                MFT_LINEARMIPMAPNEAREST, // LinearMipMapNearest
                MFT_NEARESTMIPMAPNEAREST, // NearestMipMapNearest
                MFT_NEARESTMIPMAPLINEAR, // NearestMipMapLinear
                MFT_LINEARMIPMAPLINEAR // LinearMipMapLinear
            };
            virtual void createState();
        public:
            CgMinFilterGlobalStateListener();
            virtual void updatePass( Pass * ogrePass, CGstateassignment cgStateAssignment );
        };  
        /// MagFilter
        class CgMagFilterGlobalStateListener : public CgIntGlobalStateListener
        {
        protected:
            enum MagFilterType
            {
                MFT_NEAREST,  // Nearest
                MFT_LINEAR // Linear
            };
            virtual void createState();
        public:
            CgMagFilterGlobalStateListener();
            virtual void updatePass( Pass * ogrePass, CGstateassignment cgStateAssignment );
        };      
            /// FrontFace
        class CgFrontFaceGlobalStateListener : public CgIntGlobalStateListener
        {
        protected:
            enum FrontFaceType
            {
                FFT_CW, // CW
                FFT_CCW // CCW
            };
            virtual void createState();
        public:
            CgFrontFaceGlobalStateListener();
            virtual void updatePass( Pass * ogrePass, CGstateassignment cgStateAssignment );
        };  
        /// CullFaceGlobal - CullFace
        class CgCullFaceGlobalStateListener : public CgIntGlobalStateListener
        {
        protected:
            enum CullFaceType
            {
                CFT_FRONT,  // Front
                CFT_BACK, // Back
                CFT_FRONTANDBACK // FrontAndBack
            };
            virtual void createState();
        public:
            CgCullFaceGlobalStateListener();
            virtual void updatePass( Pass * ogrePass, CGstateassignment cgStateAssignment );
        };  
        /// FogCoordSrcGlobal - FogCoordSrc
        class CgFogCoordSrcGlobalStateListener : public CgIntGlobalStateListener
        {
        protected:
            enum FogCoordSrcType
            {
                FCST_FRAGMENTDEPTH, // FragmentDepth
                FCST_FOGCOORD // FogCoord
            };
            virtual void createState();
        public:
            CgFogCoordSrcGlobalStateListener();
            virtual void updatePass( Pass * ogrePass, CGstateassignment cgStateAssignment );
        };  

        // AlphaFuncGlobal - float2 - reference then value
        class CgAlphaFuncGlobalStateListener : public CgFloat2GlobalStateListener
        {
        protected:
            enum AlphaFuncType
            {
                AFT_NEVER,  // Never
                AFT_LESS, // Less
                AFT_LEQUAL,  // LEqual
                AFT_EQUAL, // Equal
                AFT_GREATER,  // Greater
                AFT_NOTEQUAL, // NotEqual
                AFT_GEQUAL,  // GEqual
                AFT_ALWAYS // Always
            };
            virtual void createState();
        public:
            CgAlphaFuncGlobalStateListener();
            virtual void updatePass( Pass * ogrePass, CGstateassignment cgStateAssignment );
        };  
    
        // BlendFuncGlobal - Int2 - src_factor, dst_factor
        class CgBlendFuncGlobalStateListener : public CgInt2GlobalStateListener
        {
        protected:
            enum BlendFuncType
            {
                BF_ZERO,  // Zero
                BF_ONE, // One
                BF_DESTCOLOR, // DestColor
                BF_ONEMINUSDESTCOLOR, // OneMinusDestColor
                BF_SRCALPHA, // SrcAlpha
                BF_ONEMINUSSRCALPHA, // OneMinusSrcAlpha
                BF_DSTALPHA, // DstAlpha
                BF_ONEMINUSDSTALPHA, // OneMinusDstAlpha
                BF_SRCALPHASATURATE, // SrcAlphaSaturate
                BF_SRCCOLOR, // SrcColor
                BF_ONEMINUSSRCCOLOR, // OneMinusSrcColor
                BF_CONSTANTCOLOR, // ConstantColor
                BF_ONEMINUSCONSTANTCOLOR, // OneMinusConstantColor
                BF_CONSTANTALPHA, // ConstantAlpha
                BF_ONEMINUSCONSTANTALPHA // OneMinusConstantAlpha
            };
            virtual void createState();
        public:
            CgBlendFuncGlobalStateListener();
            virtual void updatePass( Pass * ogrePass, CGstateassignment cgStateAssignment );
        };
    

        // BlendFuncSeparate - int4 (rgb_src, rgb_dst, a_src, a_dst)
        class CgBlendFuncSeparateGlobalStateListener : public CgInt4GlobalStateListener
        {
        protected:
            enum BlendFuncSeparateType
            {
                BFST_ZERO,  // Zero
                BFST_ONE, // One
                BFST_DESTCOLOR, // DestColor
                BFST_ONEMINUSDESTCOLOR, // OneMinusDestColor
                BFST_SRCALPHA, // SrcAlpha
                BFST_ONEMINUSSRCALPHA, // OneMinusSrcAlpha
                BFST_DSTALPHA, // DstAlpha
                BFST_ONEMINUSDSTALPHA, // OneMinusDstAlpha
                BFST_SRCALPHASATURATE, // SrcAlphaSaturate
                BFST_SRCCOLOR, // SrcColor
                BFST_ONEMINUSSRCCOLOR, // OneMinusSrcColor
                BFST_CONSTANTCOLOR, // ConstantColor
                BFST_ONEMINUSCONSTANTCOLOR, // OneMinusConstantColor
                BFST_CONSTANTALPHA, // ConstantAlpha
                BFST_ONEMINUSCONSTANTALPHA // OneMinusConstantAlpha
            };
            virtual void createState();
        public:
            CgBlendFuncSeparateGlobalStateListener();
            virtual void updatePass( Pass * ogrePass, CGstateassignment cgStateAssignment );
        };

        // BlendEquationSeparate - int2 (rgb,alpha)
        class CgBlendEquationSeparateGlobalStateListener : public CgInt2GlobalStateListener
        {
        protected:
            enum BlendEquationSeparateType
            {
                BEST_FUNCADD, // FuncAdd
                BEST_FUNCSUBTRACT,  // FuncSubtract
                BEST_MIN, // Min
                BEST_MAX,  // Max
                BEST_LOGICOP // LogicOp
            };
            virtual void createState();
        public:
            CgBlendEquationSeparateGlobalStateListener();
            virtual void updatePass( Pass * ogrePass, CGstateassignment cgStateAssignment );
        };


        // int2 
        class CgColorMaterialGlobalStateListener : public CgInt2GlobalStateListener
        {
        protected:
            enum ColorMaterialType
            {
                CMT_FRONT,  // Front
                CMT_BACK, // Back
                CMT_FRONTANDBACK, // FrontAndBack
                CMT_EMISSION,  // Emission
                CMT_AMBIENT, // Ambient
                CMT_DIFFUSE, // Diffuse
                CMT_SPECULAR, // Specular
                CMT_AMBIENTANDDIFFUSE // AmbientAndDiffuse
            };
            virtual void createState();
        public:
            CgColorMaterialGlobalStateListener();
            virtual void updatePass( Pass * ogrePass, CGstateassignment cgStateAssignment );
        };              
    
        // int2 
        class CgPolygonModeGlobalStateListener : public CgInt2GlobalStateListener
        {
        protected:
            enum PolygonModeType
            {
                PMT_FRONT,  // Front
                PMT_BACK, // Back
                PMT_FRONTANDBACK, // FrontAndBack
                PMT_POINT,  // Point
                PMT_LINE,  // Line
                PMT_FILL // Fill
            };
            virtual void createState();
        public:
            CgPolygonModeGlobalStateListener();
            virtual void updatePass( Pass * ogrePass, CGstateassignment cgStateAssignment );
        };  

        // int3
        class CgStencilFuncGlobalStateListener : public CgInt3GlobalStateListener
        {
        protected:
            enum StencilFuncType
            {
                SFT_NEVER,  // Never
                SFT_LESS, // Less
                SFT_LEQUAL,  // LEqual
                SFT_EQUAL, // Equal
                SFT_GREATER, // Greater
                SFT_NOTEQUAL, // NotEqual
                SFT_GEQUAL,  // GEqual
                SFT_ALWAYS // Always
            };
            virtual void createState();
        public:
            CgStencilFuncGlobalStateListener();
            virtual void updatePass( Pass * ogrePass, CGstateassignment cgStateAssignment );
        };  

        // int3
        class CgStencilOpGlobalStateListener : public CgInt3GlobalStateListener
        {
        protected:
            enum StencilOpType
            {
                SOT_KEEP,  // Keep
                SOT_ZERO, // Zero
                SOT_REPLACE,  // Replace
                SOT_INCR, // Incr
                SOT_DECR,  // Decr
                SOT_INVERT, // Invert
                SOT_INCRWRAP,  // IncrWrap
                SOT_DECRWRAP // DecrWrap
            };
            virtual void createState();
        public:
            CgStencilOpGlobalStateListener();
            virtual void updatePass( Pass * ogrePass, CGstateassignment cgStateAssignment );
        };  

        // int4
        class CgStencilFuncSeparateGlobalStateListener : public CgInt4GlobalStateListener
        {
        protected:
            enum StencilFuncSeparateType
            {
                SFST_FRONT,  // Front
                SFST_BACK, // Back
                SFST_FRONTANDBACK, // FrontAndBack
                SFST_NEVER,  // Never
                SFST_LESS, // Less
                SFST_LEQUAL, // LEqual
                SFST_EQUAL, // Equal
                SFST_GREATER,  // Greater
                SFST_NOTEQUAL, // NotEqual
                SFST_GEQUAL,  // GEqual
                SFST_ALWAYS // Always
            };
            virtual void createState();
        public:
            CgStencilFuncSeparateGlobalStateListener();
            virtual void updatePass( Pass * ogrePass, CGstateassignment cgStateAssignment );
        };  

        // int2
        class CgStencilMaskSeparateGlobalStateListener : public CgInt2GlobalStateListener
        {
        protected:
            enum StencilMaskSeparateType
            {
                BET_FRONT,  // Front
                BET_BACK,  // Back
                BET_FRONTANDBACK // FrontAndBack
            };
            virtual void createState();
        public:
            CgStencilMaskSeparateGlobalStateListener();
            virtual void updatePass( Pass * ogrePass, CGstateassignment cgStateAssignment );
        };  

        // int4
        class CgStencilOpSeparateGlobalStateListener : public CgInt4GlobalStateListener
        {
        protected:
            enum StencilOpSeparateType
            {
                BET_KEEP, // Keep
                BET_ZERO, // Zero
                BET_REPLACE, // Replace
                BET_INCR, // Incr
                BET_DECR, // Decr
                BET_INVERT, // Invert
                BET_INCRWRAP,  // IncrWrap
                BET_DECRWRAP // DecrWrap
            };
            virtual void createState();
        public:
            CgStencilOpSeparateGlobalStateListener();
            virtual void updatePass( Pass * ogrePass, CGstateassignment cgStateAssignment );
        };  


        class CgSamplerStateListener : public CgStateListener
        {
        protected:
            SamplerStateType mSamplerStateType;
            virtual void createState();
        public:
            CgSamplerStateListener( const SamplerStateType samplerStateType, CGtype cgType );
            virtual ~CgSamplerStateListener();

            virtual void upateTextureUnitState( TextureUnitState * ogreTextureUnitState, CGstateassignment cgStateAssignment );
        };
        /// Int
        class CgIntSamplerStateListener : public CgSamplerStateListener
        {
        protected:
            const Vector1i getValue( CGstateassignment cgStateAssignment );
        public:
            CgIntSamplerStateListener( const SamplerStateType samplerStateType );
            virtual void upateTextureUnitState( TextureUnitState * ogreTextureUnitState, CGstateassignment cgStateAssignment );
        };
        /// Bool
        class CgBoolSamplerStateListener : public CgSamplerStateListener
        {
        public:
            CgBoolSamplerStateListener( const SamplerStateType samplerStateType );
            virtual void upateTextureUnitState( TextureUnitState * ogreTextureUnitState, CGstateassignment cgStateAssignment );
        };
        /// Float
        class CgFloatSamplerStateListener : public CgSamplerStateListener
        {
        public:
            CgFloatSamplerStateListener( const SamplerStateType samplerStateType );
            virtual void upateTextureUnitState( TextureUnitState * ogreTextureUnitState, CGstateassignment cgStateAssignment );
        };
        /// Float4
        class CgFloat4SamplerStateListener : public CgSamplerStateListener
        {
        public:
            CgFloat4SamplerStateListener( const SamplerStateType samplerStateType );
            virtual void upateTextureUnitState( TextureUnitState * ogreTextureUnitState, CGstateassignment cgStateAssignment );
        };
        /// Texture
        class CgTextureSamplerStateListener : public CgSamplerStateListener
        {
        protected:
            TextureType parseTextureType( CGparameter cgParameter, TextureUnitState * ogreTextureUnitState );
            void parseTextureName( CGparameter cgParameter, TextureUnitState * ogreTextureUnitState );
        public:
            CgTextureSamplerStateListener(const SamplerStateType samplerStateType);
            virtual void upateTextureUnitState( TextureUnitState * ogreTextureUnitState, CGstateassignment cgStateAssignment );

        };

        // Wrap = TextureAddressingMode
        class CgWrapSamplerStateListener : public CgIntSamplerStateListener
        {
        protected:
            enum WarpType
            {
                WT_REPEAT, // Repeat
                WT_CLAMP, // Clamp
                WT_CLAMPTOEDGE, // ClampToEdge
                WT_CLAMPTOBORDER, // ClampToBorder
                WT_MIRROREDREPEAT, // MirroredRepeat
                WT_MIRRORCLAMP, // MirrorClamp
                WT_MIRRORCLAMPTOEDGE, // MirrorClampToEdge
                WT_MIRRORCLAMPTOBORDER // MirrorClampToBorder
            };
            virtual void createState();
            TextureUnitState::TextureAddressingMode getOgreTextureAddressingMode( CGstateassignment cgStateAssignment );
        public:
            CgWrapSamplerStateListener(const SamplerStateType samplerStateType);
            virtual void upateTextureUnitState( TextureUnitState * ogreTextureUnitState, CGstateassignment cgStateAssignment );
        };
        /// CompareMode
        class CgCompareModeSamplerStateListener : public CgIntSamplerStateListener
        {
        protected:
            enum CompareModeType
            {
                CMT_NONE, // None
                CMT_COMPARERTOTEXTURE // CompareRToTexture
            };
            virtual void createState();
        public:
            CgCompareModeSamplerStateListener();
            virtual void upateTextureUnitState( TextureUnitState * ogreTextureUnitState, CGstateassignment cgStateAssignment );
        };
        /// CompareFunc
        class CgCompareFuncSamplerStateListener : public CgIntSamplerStateListener
        {
        protected:
            enum CompareFuncType
            {
                CFT_NEVER,  // Never
                CFT_LESS,  // Less
                CFT_LEQUAL, // LEqual
                CFT_EQUAL,  // Equal
                CFT_GREATER, // Greater
                CFT_NOTEQUAL // NotEqual
            };
            virtual void createState();
        public:
            CgCompareFuncSamplerStateListener();
            virtual void upateTextureUnitState( TextureUnitState * ogreTextureUnitState, CGstateassignment cgStateAssignment );
        };
        /// DepthMode
        class CgDepthModeSamplerStateListener : public CgIntSamplerStateListener
        {
        protected:
            enum DepthModeType
            {
                DMT_ALPHA,   // Alpha
                DMT_INTENSITY,  // Intensity
                DMT_LUMINANCE   // Luminance
            };
            virtual void createState();
        public:
            CgDepthModeSamplerStateListener();
            virtual void upateTextureUnitState( TextureUnitState * ogreTextureUnitState, CGstateassignment cgStateAssignment );
        };
        /// MinFilter
        class CgMinFilterSamplerStateListener : public CgIntSamplerStateListener
        {
        protected:
            enum MinFilterType
            {
                MINFT_NEAREST, // Nearest
                MINFT_LINEAR, // Linear
                MINFT_LINEARMIPMAPNEAREST, // LinearMipMapNearest
                MINFT_NEARESTMIPMAPNEAREST, // NearestMipMapNearest
                MINFT_NEARESTMIPMAPLINEAR, // NearestMipMapLinear
                MINFT_LINEARMIPMAPLINEAR // LinearMipMapLinear
            };

            virtual void createState();
        public:
            CgMinFilterSamplerStateListener();
            virtual void upateTextureUnitState( TextureUnitState * ogreTextureUnitState, CGstateassignment cgStateAssignment );
        };
        /// MagFilter
        class CgMagFilterSamplerStateListener : public CgIntSamplerStateListener
        {
        protected:
            enum MagFilterType
            {
                MAGFT_NEAREST, // Nearest
                MAGFT_LINEAR // Linear

            };

            virtual void createState();
        public:
            CgMagFilterSamplerStateListener();
            virtual void upateTextureUnitState( TextureUnitState * ogreTextureUnitState, CGstateassignment cgStateAssignment );
        };
        /// MipFilter
        class CgMipFilterSamplerStateListener : public CgIntSamplerStateListener
        {
        protected:
            enum MipFilterType
            {
                MIPFT_NONE            = 0,    // filtering disabled (valid for mip filter only)
                MIPFT_POINT           = 1,    // nearest
                MIPFT_LINEAR          = 2,    // linear interpolation
                MIPFT_ANISOTROPIC     = 3,    // anisotropic
                MIPFT_PYRAMIDALQUAD   = 6,    // 4-sample tent
                MIPFT_GAUSSIANQUAD    = 7     // 4-sample gaussian

            };

            virtual void createState();
        public:
            CgMipFilterSamplerStateListener();
            virtual void upateTextureUnitState( TextureUnitState * ogreTextureUnitState, CGstateassignment cgStateAssignment );
        };
        /// TextureAddress
        class CgTextureAddressSamplerStateListener : public CgIntSamplerStateListener
        {
        protected:
            enum TextureAddressType
            {
                TAT_WRAP = 1, // Wrap
                TAT_MIRROR, // Mirror
                TAT_CLAMP, // Clamp
                TAT_BORDER, // Border
                TAT_MIRRORONCE // MirrorOnce
            };

            virtual void createState();
        public:
            CgTextureAddressSamplerStateListener( const SamplerStateType samplerStateType );
            virtual void upateTextureUnitState( TextureUnitState * ogreTextureUnitState, CGstateassignment cgStateAssignment );
        };

        typedef map<CGstate, CgGlobalStateListener *>::type CgGlobalStateToListenerMap;
        typedef map<CGstate, CgSamplerStateListener *>::type CgSamplerStateToListenerMap;

        CgGlobalStateToListenerMap mCgGlobalStateToListenerMap;
        CgSamplerStateToListenerMap mCgSamplerStateToListenerMap;
        CgStateListenerVector mCgStateListenerVector;
        CgStateListenerVector mCgSamplerStateListenerVector;

        StringVector mScriptPatterns; // for getScriptPatterns(void)

        CGcontext mCgContext;
        CGcontext getCgContext() const;


        void parseCgEffect( CGeffect cgEffect, MaterialPtr ogreMaterial );
        void parseCgEffectTechniques( CGeffect cgEffect, MaterialPtr ogreMaterial );
        void parseCgTechnique( CGtechnique cgTechnique, Technique * ogreTechnique );
        void parseCgPass( CGpass cgPass, Pass * ogrePass );
        void parseSamplerParameters(CGpass cgPass, Pass * ogrePass);

        void parsePassStateAssignments( CGpass cgPass, Pass * ogrePass );
        void parseCgProgram( CGpass cgPass, Pass * ogrePass, const GpuProgramType ogreProgramType );
        void parseCgProgramParameters( CGpass cgPass, GpuProgramParametersSharedPtr ogreProgramParameters );
        void parseCgProgramParameter( CGparameter cgParameter, GpuProgramParametersSharedPtr ogreProgramParameters, const String& ogreParamName );
        void parseTextureUnitState( CGstateassignment cgStateAssignment, TextureUnitState * ogreTextureUnitState );

        void parseFloatCgProgramParameter( CGtype cgParamType, CGparameter cgParameter, GpuProgramParametersSharedPtr ogreProgramParameters, const String& ogreParamName );
        void parseIntCgProgramParameter( CGtype cgParamType, CGparameter cgParameter, GpuProgramParametersSharedPtr ogreProgramParameters, const String& ogreParamName );
        bool parseAutoConstantParam( CGparameter cgParameter, GpuProgramParametersSharedPtr ogreProgramParameters, const String& ogreParamName );
        bool cgSemanticToOgreAutoConstantType( const char * cgParamSemantic, const char * uiNameValue, GpuProgramParameters::AutoConstantType & ogreAutoConstantType, size_t & extraInfo );
        FXSemanticID cgSemanticStringToType( const char * cgParamSemantic );

        void buildStateNameStringToTypeMap();

        const char * getGlobalStateNameTypeToString( const GlobalStateType cgStateName );
        const char * getSamplerStateNameTypeToString( const SamplerStateType cgStateName );
        CgGlobalStateListener * createCgGlobalStateListener( const GlobalStateType type );
        CgSamplerStateListener * createCgSamplerStateListener( const SamplerStateType type );

    public:
        CgFxScriptLoader();
        virtual ~CgFxScriptLoader();

        /// @copydoc ScriptLoader::getScriptPatterns
        const StringVector& getScriptPatterns(void) const;
        /// @copydoc ScriptLoader::parseScript
        void parseScript( DataStreamPtr& stream, const String& groupName );

        /// @copydoc ScriptLoader::getLoadingOrder
        Real getLoadingOrder(void) const;

        /** Override standard Singleton retrieval.
        @remarks
        Why do we do this? Well, it's because the Singleton
        implementation is in a .h file, which means it gets compiled
        into anybody who includes it. This is needed for the
        Singleton template to work, but we actually only want it
        compiled into the implementation of the class based on the
        Singleton, not all of them. If we don't change this, we get
        link errors when trying to use the Singleton-based class from
        an outside dll.
        @par
        This method just delegates to the template version anyway,
        but the implementation stays in this single compilation unit,
        preventing link errors.
        */
        static CgFxScriptLoader& getSingleton(void);
        /** Override standard Singleton retrieval.
        @remarks
        Why do we do this? Well, it's because the Singleton
        implementation is in a .h file, which means it gets compiled
        into anybody who includes it. This is needed for the
        Singleton template to work, but we actually only want it
        compiled into the implementation of the class based on the
        Singleton, not all of them. If we don't change this, we get
        link errors when trying to use the Singleton-based class from
        an outside dll.
        @par
        This method just delegates to the template version anyway,
        but the implementation stays in this single compilation unit,
        preventing link errors.
        */
        static CgFxScriptLoader* getSingletonPtr(void);
    private:

    };

} // namespace Ogre

#endif 
