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-2013 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_BLEND_WEIGHTS,

        SPC_BLEND_INDICES,
        
        SPC_TANGENT_OBJECT_SPACE,

        SPC_TANGENT_WORLD_SPACE,

        SPC_TANGENT_VIEW_SPACE,

        SPC_TANGENT_TANGENT_SPACE,

        SPC_BINORMAL_OBJECT_SPACE,

        SPC_BINORMAL_WORLD_SPACE,

        SPC_BINORMAL_VIEW_SPACE,

        SPC_BINORMAL_TANGENT_SPACE,

        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, size_t size = 0);

    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; }
    
    bool isArray() const { return mSize > 0; }

    size_t getSize() const { return mSize; }
    
    void setSize(size_t size) { mSize = size; }

// Attributes.
protected:
    // Name of this parameter.
    String mName;
    // Type of this parameter.
    GpuConstantType mType;
    // Semantic of this parameter.
    Semantic mSemantic;
    // Index of this parameter.
    int mIndex;
    // The content of this parameter.
    Content mContent;
    // Number of elements in the parameter (for arrays)
    size_t mSize;
    
};

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, size_t size);

    UniformParameter(GpuProgramParameters::AutoConstantType autoType, Real fAutoConstantData, size_t size);
    
    UniformParameter(GpuProgramParameters::AutoConstantType autoType, Real fAutoConstantData, size_t size, GpuConstantType type);

    UniformParameter(GpuProgramParameters::AutoConstantType autoType, size_t nAutoConstantData, size_t size);
    
    UniformParameter(GpuProgramParameters::AutoConstantType autoType, size_t nAutoConstantData, size_t size, GpuConstantType type);

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

    void setGpuParameter(const float *val, size_t count, size_t multiple = 4)  
    { 
        if (mParamsPtr != NULL)
        {
            mParamsPtr->_writeRawConstants(mPhysicalIndex, val, count * multiple);
        }
    }

    void setGpuParameter(const double *val, size_t count, size_t multiple = 4)  
    { 
        if (mParamsPtr != NULL)
        {
            mParamsPtr->_writeRawConstants(mPhysicalIndex, val, count * multiple);
        }
    }

    void setGpuParameter(const int *val, size_t count, size_t multiple = 4)  
    { 
        if (mParamsPtr != NULL)
        {
            mParamsPtr->_writeRawConstants(mPhysicalIndex, val, count * multiple);
        }
    }

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

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 createInWeights(int index);
    static ParameterPtr createInIndices(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 createSampler2DArray(int index);
    static UniformParameterPtr createSampler3D(int index);
    static UniformParameterPtr createSamplerCUBE(int index);    

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



}
}

#endif