OgreShaderParameter.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-2011 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 _ShaderParameter_
#define _ShaderParameter_

#include "OgreShaderPrerequisites.h"
#include "OgreGpuProgram.h"
#include "OgreVector2.h"
#include "OgreVector3.h"
#include "OgreVector4.h"
#include "OgreMatrix4.h"

namespace Ogre {
namespace RTShader {

class _OgreRTSSExport Parameter : public RTShaderSystemAlloc
{
public:
    // Shader parameter semantic.
    enum Semantic
    {
        SPS_UNKNOWN = 0,
        SPS_POSITION = 1,
        SPS_BLEND_WEIGHTS = 2,
        SPS_BLEND_INDICES = 3,
        SPS_NORMAL = 4,
        SPS_COLOR = 5,      
        SPS_TEXTURE_COORDINATES = 7,
        SPS_BINORMAL = 8,
        SPS_TANGENT = 9     
    };

    // Shader parameter content.
    enum Content
    {
        SPC_UNKNOWN,

        SPC_POSITION_OBJECT_SPACE,

        SPC_POSITION_WORLD_SPACE,

        SPC_POSITION_VIEW_SPACE,

        SPC_POSITION_PROJECTIVE_SPACE,

        SPC_POSITION_LIGHT_SPACE0,
        SPC_POSITION_LIGHT_SPACE1,
        SPC_POSITION_LIGHT_SPACE2,
        SPC_POSITION_LIGHT_SPACE3,
        SPC_POSITION_LIGHT_SPACE4,
        SPC_POSITION_LIGHT_SPACE5,
        SPC_POSITION_LIGHT_SPACE6,
        SPC_POSITION_LIGHT_SPACE7,

        SPC_NORMAL_OBJECT_SPACE,

        SPC_NORMAL_WORLD_SPACE,

        SPC_NORMAL_VIEW_SPACE,

        SPC_NORMAL_TANGENT_SPACE,

        SPC_POSTOCAMERA_OBJECT_SPACE,

        SPC_POSTOCAMERA_WORLD_SPACE,

        SPC_POSTOCAMERA_VIEW_SPACE,

        SPC_POSTOCAMERA_TANGENT_SPACE,

        SPC_POSTOLIGHT_OBJECT_SPACE0,
        SPC_POSTOLIGHT_OBJECT_SPACE1,
        SPC_POSTOLIGHT_OBJECT_SPACE2,
        SPC_POSTOLIGHT_OBJECT_SPACE3,
        SPC_POSTOLIGHT_OBJECT_SPACE4,
        SPC_POSTOLIGHT_OBJECT_SPACE5,
        SPC_POSTOLIGHT_OBJECT_SPACE6,
        SPC_POSTOLIGHT_OBJECT_SPACE7,

        SPC_POSTOLIGHT_WORLD_SPACE0,
        SPC_POSTOLIGHT_WORLD_SPACE1,
        SPC_POSTOLIGHT_WORLD_SPACE2,
        SPC_POSTOLIGHT_WORLD_SPACE3,
        SPC_POSTOLIGHT_WORLD_SPACE4,
        SPC_POSTOLIGHT_WORLD_SPACE5,
        SPC_POSTOLIGHT_WORLD_SPACE6,
        SPC_POSTOLIGHT_WORLD_SPACE7,

        SPC_POSTOLIGHT_VIEW_SPACE0,
        SPC_POSTOLIGHT_VIEW_SPACE1,
        SPC_POSTOLIGHT_VIEW_SPACE2,
        SPC_POSTOLIGHT_VIEW_SPACE3,
        SPC_POSTOLIGHT_VIEW_SPACE4,
        SPC_POSTOLIGHT_VIEW_SPACE5,
        SPC_POSTOLIGHT_VIEW_SPACE6,
        SPC_POSTOLIGHT_VIEW_SPACE7,

        SPC_POSTOLIGHT_TANGENT_SPACE0,
        SPC_POSTOLIGHT_TANGENT_SPACE1,
        SPC_POSTOLIGHT_TANGENT_SPACE2,
        SPC_POSTOLIGHT_TANGENT_SPACE3,
        SPC_POSTOLIGHT_TANGENT_SPACE4,
        SPC_POSTOLIGHT_TANGENT_SPACE5,
        SPC_POSTOLIGHT_TANGENT_SPACE6,
        SPC_POSTOLIGHT_TANGENT_SPACE7,



        SPC_LIGHTDIRECTION_OBJECT_SPACE0,
        SPC_LIGHTDIRECTION_OBJECT_SPACE1,
        SPC_LIGHTDIRECTION_OBJECT_SPACE2,
        SPC_LIGHTDIRECTION_OBJECT_SPACE3,
        SPC_LIGHTDIRECTION_OBJECT_SPACE4,
        SPC_LIGHTDIRECTION_OBJECT_SPACE5,
        SPC_LIGHTDIRECTION_OBJECT_SPACE6,
        SPC_LIGHTDIRECTION_OBJECT_SPACE7,

        SPC_LIGHTDIRECTION_WORLD_SPACE0,
        SPC_LIGHTDIRECTION_WORLD_SPACE1,
        SPC_LIGHTDIRECTION_WORLD_SPACE2,
        SPC_LIGHTDIRECTION_WORLD_SPACE3,
        SPC_LIGHTDIRECTION_WORLD_SPACE4,
        SPC_LIGHTDIRECTION_WORLD_SPACE5,
        SPC_LIGHTDIRECTION_WORLD_SPACE6,
        SPC_LIGHTDIRECTION_WORLD_SPACE7,

        SPC_LIGHTDIRECTION_VIEW_SPACE0,
        SPC_LIGHTDIRECTION_VIEW_SPACE1,
        SPC_LIGHTDIRECTION_VIEW_SPACE2,
        SPC_LIGHTDIRECTION_VIEW_SPACE3,
        SPC_LIGHTDIRECTION_VIEW_SPACE4,
        SPC_LIGHTDIRECTION_VIEW_SPACE5,
        SPC_LIGHTDIRECTION_VIEW_SPACE6,
        SPC_LIGHTDIRECTION_VIEW_SPACE7,

        SPC_LIGHTDIRECTION_TANGENT_SPACE0,
        SPC_LIGHTDIRECTION_TANGENT_SPACE1,
        SPC_LIGHTDIRECTION_TANGENT_SPACE2,
        SPC_LIGHTDIRECTION_TANGENT_SPACE3,
        SPC_LIGHTDIRECTION_TANGENT_SPACE4,
        SPC_LIGHTDIRECTION_TANGENT_SPACE5,
        SPC_LIGHTDIRECTION_TANGENT_SPACE6,
        SPC_LIGHTDIRECTION_TANGENT_SPACE7,

        SPC_LIGHTPOSITION_OBJECT_SPACE0,
        SPC_LIGHTPOSITION_OBJECT_SPACE1,
        SPC_LIGHTPOSITION_OBJECT_SPACE2,
        SPC_LIGHTPOSITION_OBJECT_SPACE3,
        SPC_LIGHTPOSITION_OBJECT_SPACE4,
        SPC_LIGHTPOSITION_OBJECT_SPACE5,
        SPC_LIGHTPOSITION_OBJECT_SPACE6,
        SPC_LIGHTPOSITION_OBJECT_SPACE7,

        SPC_LIGHTPOSITION_WORLD_SPACE0,
        SPC_LIGHTPOSITION_WORLD_SPACE1,
        SPC_LIGHTPOSITION_WORLD_SPACE2,
        SPC_LIGHTPOSITION_WORLD_SPACE3,
        SPC_LIGHTPOSITION_WORLD_SPACE4,
        SPC_LIGHTPOSITION_WORLD_SPACE5,
        SPC_LIGHTPOSITION_WORLD_SPACE6,
        SPC_LIGHTPOSITION_WORLD_SPACE7,

        SPC_LIGHTPOSITIONVIEW_SPACE0,
        SPC_LIGHTPOSITIONVIEW_SPACE1,
        SPC_LIGHTPOSITIONVIEW_SPACE2,
        SPC_LIGHTPOSITIONVIEW_SPACE3,
        SPC_LIGHTPOSITIONVIEW_SPACE4,
        SPC_LIGHTPOSITIONVIEW_SPACE5,
        SPC_LIGHTPOSITIONVIEW_SPACE6,
        SPC_LIGHTPOSITIONVIEW_SPACE7,

        SPC_LIGHTPOSITION_TANGENT_SPACE,

        SPC_TANGENT,

        SPC_BINORMAL,

        SPC_COLOR_DIFFUSE,

        SPC_COLOR_SPECULAR,

        SPC_DEPTH_OBJECT_SPACE,

        SPC_DEPTH_WORLD_SPACE,

        SPC_DEPTH_VIEW_SPACE,

        SPC_DEPTH_PROJECTIVE_SPACE,

        SPC_TEXTURE_COORDINATE0,        
        SPC_TEXTURE_COORDINATE1,        
        SPC_TEXTURE_COORDINATE2,        
        SPC_TEXTURE_COORDINATE3,    
        SPC_TEXTURE_COORDINATE4,
        SPC_TEXTURE_COORDINATE5,
        SPC_TEXTURE_COORDINATE6,
        SPC_TEXTURE_COORDINATE7,

        SPC_CUSTOM_CONTENT_BEGIN    = 1000,
        SPC_CUSTOM_CONTENT_END      = 2000
    };

// Interface.
public:
    Parameter() {}

    Parameter(GpuConstantType type, const String& name, 
        const Semantic& semantic, int index, 
        const Content& content);

    virtual ~Parameter() {};

    const String&           getName                         () const { return mName; }

    GpuConstantType         getType                         () const { return mType; }

    const Semantic&         getSemantic                     () const { return mSemantic; }

    int                     getIndex                        () const { return mIndex; } 

    Content                 getContent                          () const { return mContent; }

    virtual bool            isConstParameter                    () const { return false; }

    virtual String          toString                            () const { return mName; }

// Attributes.
protected:
    String                                  mName;                  // Name of this parameter.
    GpuConstantType                         mType;                  // Type of this parameter.
    Semantic                                mSemantic;              // Semantic of this parameter.
    int                                     mIndex;                 // Index of this parameter.
    Content                                 mContent;               // The content of this parameter.
    
};

typedef SharedPtr<Parameter>                    ParameterPtr; 
typedef vector<ParameterPtr>::type              ShaderParameterList;
typedef ShaderParameterList::iterator           ShaderParameterIterator;
typedef ShaderParameterList::const_iterator     ShaderParameterConstIterator;

class UniformParameter : public Parameter
{
public:

    UniformParameter(GpuConstantType type, const String& name, 
        const Semantic& semantic, int index, 
        const Content& content,
        uint16 variability);

    UniformParameter(GpuProgramParameters::AutoConstantType autoType, Real fAutoConstantData);

    UniformParameter(GpuProgramParameters::AutoConstantType autoType, size_t nAutoConstantData);

    
    size_t                  getAutoConstantIntData          () const { return mAutoConstantIntData; }   

    Real                    getAutoConstantRealData         () const { return mAutoConstantRealData; }  

    bool                    isFloat                         () const;

    bool                    isSampler                       () const;

    bool                    isAutoConstantParameter             () const { return mIsAutoConstantReal || mIsAutoConstantInt; }

    bool                    isAutoConstantIntParameter          () const { return mIsAutoConstantInt; }

    bool                    isAutoConstantRealParameter         () const { return mIsAutoConstantReal; }

    GpuProgramParameters::AutoConstantType getAutoConstantType  () const { return mAutoConstantType; }

    uint16                  getVariability                      () const { return mVariability; }


    void                    bind                                (GpuProgramParametersSharedPtr paramsPtr);
    
public:

    void setGpuParameter(int val)
    { 
        if (mParamsPtr != NULL)
        {
            mParamsPtr->_writeRawConstant(mPhysicalIndex, val);
        }
    }

    void setGpuParameter(Real val)  
    { 
        if (mParamsPtr != NULL)
        {
            mParamsPtr->_writeRawConstant(mPhysicalIndex, val);
        }
    }

    void setGpuParameter(const ColourValue& val)  
    { 
        if (mParamsPtr != NULL)
        {
            mParamsPtr->_writeRawConstant(mPhysicalIndex, val);
        }
    }

    void setGpuParameter(const Vector2& val)  
    { 
        if (mParamsPtr != NULL)
        {
            mParamsPtr->_writeRawConstants(mPhysicalIndex, val.ptr(), 2);
        }
    }
    
    void setGpuParameter(const Vector3& val)  
    { 
        if (mParamsPtr != NULL)
        {
            mParamsPtr->_writeRawConstant(mPhysicalIndex, val);
        }
    }

    void setGpuParameter(const Vector4& val)  
    { 
        if (mParamsPtr != NULL)
        {
            mParamsPtr->_writeRawConstant(mPhysicalIndex, val);     
        }
    }

    void setGpuParameter(const Matrix4& val)  
    { 
        if (mParamsPtr != NULL)
        {
            mParamsPtr->_writeRawConstant(mPhysicalIndex, val, 16);
        }
    }

protected:
    bool                                    mIsAutoConstantReal;    // Is it auto constant real based parameter.
    bool                                    mIsAutoConstantInt;     // Is it auto constant int based parameter.
    GpuProgramParameters::AutoConstantType  mAutoConstantType;      // The auto constant type of this parameter.
    union
    {
        size_t  mAutoConstantIntData;                               // Auto constant int data.
        Real    mAutoConstantRealData;                              // Auto constant real data.
    };      
    uint16                                  mVariability;           // How this parameter varies (bitwise combination of GpuProgramVariability).
    GpuProgramParameters*                   mParamsPtr;             // The actual GPU parameters pointer.
    size_t                                  mPhysicalIndex;         // The physical index of this parameter in the GPU program.

};

typedef SharedPtr<UniformParameter>             UniformParameterPtr; 
typedef vector<UniformParameterPtr>::type       UniformParameterList;
typedef UniformParameterList::iterator          UniformParameterIterator;
typedef UniformParameterList::const_iterator    UniformParameterConstIterator;

template <class valueType>
class ConstParameter : public Parameter
{
public:

    ConstParameter( valueType val, 
        GpuConstantType type, 
        const Semantic& semantic,  
        const Content& content) 
        : Parameter(type, "Constant", semantic, 0, content)
    {
        mValue = val;
    }

    virtual             ~ConstParameter     () {}

    const valueType&    getValue            () const { return mValue; }

    virtual bool        isConstParameter    () const { return true; }

    virtual String      toString            () const = 0;

protected:
    valueType mValue;
};

class _OgreRTSSExport ParameterFactory
{

    // Interface.
public:

    static ParameterPtr createInPosition        (int index);    
    static ParameterPtr createOutPosition       (int index);

    static ParameterPtr createInNormal          (int index);
    static ParameterPtr createOutNormal         (int index);
    static ParameterPtr createInBiNormal        (int index);
    static ParameterPtr createOutBiNormal       (int index);
    static ParameterPtr createInTangent         (int index);
    static ParameterPtr createOutTangent        (int index);
    static ParameterPtr createInColor           (int index);
    static ParameterPtr createOutColor          (int index);

    static ParameterPtr createInTexcoord        (GpuConstantType type, int index, Parameter::Content content);
    static ParameterPtr createOutTexcoord       (GpuConstantType type, int index, Parameter::Content content);
    static ParameterPtr createInTexcoord1       (int index, Parameter::Content content);
    static ParameterPtr createOutTexcoord1      (int index, Parameter::Content content);
    static ParameterPtr createInTexcoord2       (int index, Parameter::Content content);
    static ParameterPtr createOutTexcoord2      (int index, Parameter::Content content);
    static ParameterPtr createInTexcoord3       (int index, Parameter::Content content);
    static ParameterPtr createOutTexcoord3      (int index, Parameter::Content content);
    static ParameterPtr createInTexcoord4       (int index, Parameter::Content content);            
    static ParameterPtr createOutTexcoord4      (int index, Parameter::Content content);

    static ParameterPtr createConstParamVector2 (Vector2 val);
    static ParameterPtr createConstParamVector3 (Vector3 val);
    static ParameterPtr createConstParamVector4 (Vector4 val);
    static ParameterPtr createConstParamFloat   (float val);    

    static UniformParameterPtr  createSampler           (GpuConstantType type, int index);
    static UniformParameterPtr  createSampler1D         (int index);
    static UniformParameterPtr  createSampler2D         (int index);
    static UniformParameterPtr  createSampler3D         (int index);
    static UniformParameterPtr  createSamplerCUBE       (int index);    

    static UniformParameterPtr  createUniform           (GpuConstantType type,  int index, uint16 variability, const String& suggestedName);
};



}
}

#endif