technique.h

Go to the documentation of this file.

#ifndef __TECHNIQUE_H__INCLUDED__
#define __TECHNIQUE_H__INCLUDED__

#include <string>
#include <vector>

#include <boost/smart_ptr.hpp>

class Texture;
class Technique;

typedef boost::shared_ptr< Technique >TechniquePtr;

class Technique
{
    std::string name;
    std::string fallback;
    bool compiled;
    int programVersion;
    
public:
    class Pass
    {
        int program;
        
        int programVersion;
        
        std::string vertexProgram;
        
        std::string fragmentProgram;
        
public:
        enum Tristate
        {
            False=0,
            True =1,
            Auto =2
        };

        enum Type
        {
            FixedPass,
            
            ShaderPass
        };

        enum BlendMode
        {
            Default,
            
            Add,
            
            Multiply,
            
            AlphaBlend,
            
            Decal,
            
            PremultAlphaBlend,
            
            MultiAlphaBlend
        };

        enum DepthFunction
        {
            Less,
            LEqual,
            Greater,
            GEqual,
            Equal,
            Always,
            Never
        };

        enum Face
        {
            None,
            Front,
            Back,
            FrontAndBack,
            DefaultFace
        };

        enum PolyMode
        {
            Point,
            Line,
            Fill
        };

        struct TextureUnit
        {
            enum SourceType
            {
                None,
                
                Decal,
                
                File,
                
                Environment,
                
                Detail
            };

            enum Kind
            {
                TexDefault,
                
                Tex2D,
                
                Tex3D,
                
                TexCube,
                
                TexSepCube
            };
            
            SourceType sourceType;
            SourceType defaultType;

            Kind texKind;

            int  sourceIndex;
            int  defaultIndex;
            int  targetIndex;
            
            // Backup of mutable fields for shader reloading
            int  origTargetIndex;

            std::string targetParamName;
            int targetParamId;

            std::string sourcePath;
            std::string defaultPath;

            boost::shared_ptr< Texture >texture;
        };

        struct ShaderParam
        {
            enum Semantic
            {
                EnvColor,

                CloakingPhase,

                Damage,

                Damage4,

                DetailPlane0,

                DetailPlane1,

                NumLights,

                ActiveLightsArray,

                GameTime,

                Constant,
                
                ApparentLightSizeArray
            };

            std::string name;
            int id;
            Semantic    semantic;
            bool optional;
            float value[4];
        };

private:
        typedef std::vector< TextureUnit >TextureUnitList;
        typedef std::vector< ShaderParam >ShaderParamList;

        TextureUnitList textureUnits;
        ShaderParamList shaderParams;

public:
        Type type;

        bool sRGBAware;
        
        bool colorWrite;

        Tristate zWrite;

        unsigned int  perLightIteration;

        unsigned int  maxIterations;

        BlendMode     blendMode;

        DepthFunction depthFunction;

        Face          cullMode;

        PolyMode      polyMode;

        float         offsetFactor;

        float         offsetUnits;

        float         lineWidth;

        int sequence;

        Pass();

        ~Pass();

        void setProgram( const std::string &vertex, const std::string &fragment );

        int getCompiledProgram() const
        {
            return program;
        }

        void addTextureUnit( const std::string &source,
                             int target,
                             const std::string &deflt,
                             const std::string &paramName,
                             Technique::Pass::TextureUnit::Kind texKind );

        void addShaderParam( const std::string&name, float value[4], bool optional );

        void addShaderParam( const std::string &name, ShaderParam::Semantic semantic, bool optional );

        size_t getNumTextureUnits() const
        {
            return textureUnits.size();
        }

        const TextureUnit& getTextureUnit( int index ) const
        {
            return textureUnits[index];
        }

        TextureUnit& getTextureUnit( int index )
        {
            return textureUnits[index];
        }

        size_t getNumShaderParams() const
        {
            return shaderParams.size();
        }

        const ShaderParam& getShaderParam( int index ) const
        {
            return shaderParams[index];
        }

        ShaderParam& getShaderParam( int index )
        {
            return shaderParams[index];
        }

        void compile();

        bool isCompiled() const;

        bool isCompiled(int programVersion) const;
    };

protected:
    typedef std::vector< Pass > PassList;
    PassList passes;

public:
    explicit Technique( const std::string &name );

    explicit Technique( const Technique &src );
    
    ~Technique();

    const std::string& getName() const
    {
        return name;
    }
    const std::string& getFallback() const
    {
        return fallback;
    }
    
    bool isCompiled() const
    {
        return compiled;
    }
    
    bool isCompiled(int programVersion) const
    {
        return compiled && this->programVersion == programVersion;
    }

    void compile(); //Throws on error

    int getNumPasses() const
    {
        return passes.size();
    }
    const Pass& getPass( int idx ) const
    {
        return passes[idx];
    }
    Pass& getPass( int idx )
    {
        return passes[idx];
    }

    static TechniquePtr getTechnique( const std::string &name );
};

#endif //__TECHNIQUE_H__INCLUDED__