OgreShaderFFPTexturing.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 _ShaderFFPTextureStage_
#define _ShaderFFPTextureStage_

#include "OgreShaderPrerequisites.h"
#ifdef RTSHADER_SYSTEM_BUILD_CORE_SHADERS
#include "OgreShaderSubRenderState.h"
#include "OgreShaderParameter.h"
#include "OgreRenderSystem.h"

namespace Ogre {
namespace RTShader {


class _OgreRTSSExport FFPTexturing : public SubRenderState
{

// Interface.
public:

    FFPTexturing();

    virtual const String&   getType                 () const;

    virtual int             getExecutionOrder       () const;

    virtual void            updateGpuProgramsParams (Renderable* rend, Pass* pass, const AutoParamDataSource* source, const LightList* pLightList);

    virtual void            copyFrom                (const SubRenderState& rhs);

    virtual bool            preAddToRenderState     (RenderState* renderState, Pass* srcPass, Pass* dstPass);

    static String Type;

// Protected types:
protected:

    // Per texture unit parameters.
    struct _OgreRTSSExport TextureUnitParams
    {
        TextureUnitState*       mTextureUnitState;              // Texture unit state.
        const Frustum*          mTextureProjector;              // Texture projector.
        unsigned short          mTextureSamplerIndex;           // Texture sampler index.
        GpuConstantType         mTextureSamplerType;            // Texture sampler index.
        GpuConstantType         mVSInTextureCoordinateType;     // Vertex shader input texture coordinate type.
        GpuConstantType         mVSOutTextureCoordinateType;    // Vertex shader output texture coordinates type.       
        TexCoordCalcMethod      mTexCoordCalcMethod;            // Texture coordinates calculation method.
        UniformParameterPtr     mTextureMatrix;                 // Texture matrix parameter.
        UniformParameterPtr     mTextureViewProjImageMatrix;    // Texture View Projection Image space matrix parameter.
        UniformParameterPtr     mTextureSampler;                // Texture sampler parameter.
        ParameterPtr            mVSInputTexCoord;               // Vertex shader input texture coordinates parameter.
        ParameterPtr            mVSOutputTexCoord;              // Vertex shader output texture coordinates parameter.
        ParameterPtr            mPSInputTexCoord;               // Pixel shader input texture coordinates parameter.
    };

    typedef vector<TextureUnitParams>::type         TextureUnitParamsList;
    typedef TextureUnitParamsList::iterator         TextureUnitParamsIterator;
    typedef TextureUnitParamsList::const_iterator   TextureUnitParamsConstIterator;

// Protected methods
protected:

    void                    setTextureUnitCount     (size_t count);

    size_t                  getTextureUnitCount     () const { return mTextureUnitParamsList.size(); }

    void                    setTextureUnit          (unsigned short index, TextureUnitState* textureUnitState);

    virtual bool            resolveParameters       (ProgramSet* programSet);

            bool            resolveUniformParams    (TextureUnitParams* textureUnitParams, ProgramSet* programSet);

            bool            resolveFunctionsParams  (TextureUnitParams* textureUnitParams, ProgramSet* programSet);

    virtual bool            resolveDependencies     (ProgramSet* programSet);

    virtual bool            addFunctionInvocations  (ProgramSet* programSet);


    bool                    addVSFunctionInvocations(TextureUnitParams* textureUnitParams, Function* vsMain);

    bool                    addPSFunctionInvocations(TextureUnitParams* textureUnitParams, Function* psMain, int& internalCounter);

    void                    addPSArgumentInvocations(Function* psMain, 
                                                     ParameterPtr arg,
                                                     ParameterPtr texel,
                                                     int samplerIndex,
                                                     LayerBlendSource blendSrc,
                                                     const ColourValue& colourValue,
                                                     Real alphaValue,
                                                     bool isAlphaArgument,
                                                     const int groupOrder, 
                                                     int& internalCounter);

    void                    addPSBlendInvocations(Function* psMain, 
                                                ParameterPtr arg1,
                                                ParameterPtr arg2,
                                                ParameterPtr texel,
                                                int samplerIndex,
                                                const LayerBlendModeEx& blendMode,
                                                const int groupOrder, 
                                                int& internalCounter,
                                                int targetChannels);
    
    TexCoordCalcMethod      getTexCalcMethod        (TextureUnitState* textureUnitState);

    bool                    needsTextureMatrix      (TextureUnitState* textureUnitState);

// Attributes.
protected:
    TextureUnitParamsList   mTextureUnitParamsList;     // Texture units list.      
    UniformParameterPtr     mWorldMatrix;               // World matrix parameter.
    UniformParameterPtr     mWorldITMatrix;             // World inverse transpose matrix parameter.
    UniformParameterPtr     mViewMatrix;                // View matrix parameter.           
    ParameterPtr            mVSInputNormal;             // Vertex shader input normal parameter.
    ParameterPtr            mVSInputPos;                // Vertex shader input position parameter.      
    ParameterPtr            mPSOutDiffuse;              // Pixel shader output colour.
    ParameterPtr            mPSDiffuse;                 // Pixel shader diffuse colour.
    ParameterPtr            mPSSpecular;                // Pixel shader specular colour.
};


class _OgreRTSSExport FFPTexturingFactory : public SubRenderStateFactory
{
public:

    virtual const String&   getType             () const;

    virtual SubRenderState* createInstance      (ScriptCompiler* compiler, PropertyAbstractNode* prop, Pass* pass);

    virtual void            writeInstance       (MaterialSerializer* ser, SubRenderState* subRenderState, Pass* srcPass, Pass* dstPass);

    
protected:

    virtual SubRenderState* createInstanceImpl  ();


};

}
}

#endif
#endif