OgreTextureUnitState.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 __TextureUnitState_H__
#define __TextureUnitState_H__

#include "OgrePrerequisites.h"
#include "OgreCommon.h"
#include "OgreBlendMode.h"
#include "OgreMatrix4.h"
#include "OgreIteratorWrappers.h"
#include "OgreString.h"
#include "OgreTexture.h"
#include "OgreHeaderPrefix.h"

namespace Ogre {
    class _OgreExport TextureUnitState : public TextureUnitStateAlloc
    {
        friend class RenderSystem;
    public:
        enum TextureEffectType
        {
            ET_ENVIRONMENT_MAP,
            ET_PROJECTIVE_TEXTURE,
            ET_UVSCROLL,
            ET_USCROLL,
            ET_VSCROLL,
            ET_ROTATE,
            ET_TRANSFORM

        };

        enum EnvMapType
        {
            ENV_PLANAR,
            ENV_CURVED,
            ENV_REFLECTION,
            ENV_NORMAL
        };

        enum TextureTransformType
        {
            TT_TRANSLATE_U,
            TT_TRANSLATE_V,
            TT_SCALE_U,
            TT_SCALE_V,
            TT_ROTATE
        };

        enum TextureAddressingMode
        {
            TAM_WRAP,
            TAM_MIRROR,
            TAM_CLAMP,
            TAM_BORDER,
            TAM_UNKNOWN = 99
        };

        struct UVWAddressingMode
        {
            TextureAddressingMode u, v, w;
        };

        enum TextureCubeFace
        {
            CUBE_FRONT = 0,
            CUBE_BACK = 1,
            CUBE_LEFT = 2,
            CUBE_RIGHT = 3,
            CUBE_UP = 4,
            CUBE_DOWN = 5
        };

        struct TextureEffect {
            TextureEffectType type;
            int subtype;
            Real arg1, arg2;
            WaveformType waveType;
            Real base;
            Real frequency;
            Real phase;
            Real amplitude;
            Controller<Real>* controller;
            const Frustum* frustum;
        };

        typedef multimap<TextureEffectType, TextureEffect>::type EffectMap;

        TextureUnitState(Pass* parent);

        TextureUnitState(Pass* parent, const TextureUnitState& oth );

        TextureUnitState & operator = ( const TextureUnitState& oth );

        ~TextureUnitState();

        TextureUnitState( Pass* parent, const String& texName, unsigned int texCoordSet = 0);

        const String& getTextureName(void) const;

        void setTextureName( const String& name, TextureType ttype = TEX_TYPE_2D);

        void setTexture( const TexturePtr& texPtr);

        void setCubicTextureName( const String& name, bool forUVW = false );

        void setCubicTextureName( const String* const names, bool forUVW = false );

        void setCubicTexture( const TexturePtr* const texPtrs, bool forUVW = false );

        void setAnimatedTextureName( const String& name, unsigned int numFrames, Real duration = 0 );

        void setAnimatedTextureName( const String* const names, unsigned int numFrames, Real duration = 0 );

        std::pair< size_t, size_t > getTextureDimensions( unsigned int frame = 0 ) const;

        void setCurrentFrame( unsigned int frameNumber );

        unsigned int getCurrentFrame(void) const;

        const String& getFrameTextureName(unsigned int frameNumber) const;

        void setFrameTextureName(const String& name, unsigned int frameNumber);

        void addFrameTextureName(const String& name);
        void deleteFrameTextureName(const size_t frameNumber);
        unsigned int getNumFrames(void) const;


        enum BindingType
        {
            BT_FRAGMENT = 0,
            BT_VERTEX = 1,          
            BT_GEOMETRY = 2,
            BT_TESSELATION_HULL = 3,
            BT_TESSELATION_DOMAIN = 4,
            BT_COMPUTE = 5
        };
        enum ContentType
        {
            CONTENT_NAMED = 0,
            CONTENT_SHADOW = 1,
            CONTENT_COMPOSITOR = 2
        };

        void setBindingType(BindingType bt);

        BindingType getBindingType(void) const;

        void setContentType(ContentType ct);
        ContentType getContentType(void) const;

        bool isCubic(void) const;

        bool is3D(void) const;

        TextureType getTextureType(void) const;

        void setDesiredFormat(PixelFormat desiredFormat);

        PixelFormat getDesiredFormat(void) const;

        void setNumMipmaps(int numMipmaps);

        int getNumMipmaps(void) const;

        void setIsAlpha(bool isAlpha);

        bool getIsAlpha(void) const;

        Real getGamma() const { return mGamma; }
        void setGamma(Real gamma) { mGamma = gamma; }

        void setHardwareGammaEnabled(bool enabled);
        bool isHardwareGammaEnabled() const;

        unsigned int getTextureCoordSet(void) const;

        void setTextureCoordSet(unsigned int set);

        void setTextureTransform(const Matrix4& xform);

        const Matrix4& getTextureTransform(void) const;

        void setTextureScroll(Real u, Real v);

        void setTextureUScroll(Real value);
        Real getTextureUScroll(void) const;

        void setTextureVScroll(Real value);
        Real getTextureVScroll(void) const;

        void setTextureUScale(Real value);
        Real getTextureUScale(void) const;

        void setTextureVScale(Real value);
        Real getTextureVScale(void) const;

        void setTextureScale(Real uScale, Real vScale);

        void setTextureRotate(const Radian& angle);
        const Radian& getTextureRotate(void) const;

        const UVWAddressingMode& getTextureAddressingMode(void) const;

        void setTextureAddressingMode( TextureAddressingMode tam);

        void setTextureAddressingMode( TextureAddressingMode u, 
            TextureAddressingMode v, TextureAddressingMode w);

        void setTextureAddressingMode( const UVWAddressingMode& uvw);

        void setTextureBorderColour(const ColourValue& colour);

        const ColourValue& getTextureBorderColour(void) const;

        void setColourOperationEx(
            LayerBlendOperationEx op,
            LayerBlendSource source1 = LBS_TEXTURE,
            LayerBlendSource source2 = LBS_CURRENT,

            const ColourValue& arg1 = ColourValue::White,
            const ColourValue& arg2 = ColourValue::White,

            Real manualBlend = 0.0);

        void setColourOperation( const LayerBlendOperation op);

        void setColourOpMultipassFallback( const SceneBlendFactor sourceFactor, const SceneBlendFactor destFactor);

        const LayerBlendModeEx& getColourBlendMode(void) const;

        const LayerBlendModeEx& getAlphaBlendMode(void) const;

        SceneBlendFactor getColourBlendFallbackSrc(void) const;

        SceneBlendFactor getColourBlendFallbackDest(void) const;

        void setAlphaOperation(LayerBlendOperationEx op,
            LayerBlendSource source1 = LBS_TEXTURE,
            LayerBlendSource source2 = LBS_CURRENT,
            Real arg1 = 1.0,
            Real arg2 = 1.0,
            Real manualBlend = 0.0);

        void addEffect(TextureEffect& effect);

        void setEnvironmentMap(bool enable, EnvMapType envMapType = ENV_CURVED);

        void setScrollAnimation(Real uSpeed, Real vSpeed);

        void setRotateAnimation(Real speed);

        void setTransformAnimation( const TextureTransformType ttype,
            const WaveformType waveType, Real base = 0, Real frequency = 1, Real phase = 0, Real amplitude = 1 );


        void setProjectiveTexturing(bool enabled, const Frustum* projectionSettings = 0);

        void removeAllEffects(void);

        void removeEffect( const TextureEffectType type );

        bool isBlank(void) const;

        void setBlank(void);

        bool isTextureLoadFailing() const { return mTextureLoadFailed; }

        void retryTextureLoad() { mTextureLoadFailed = false; }

        const EffectMap& getEffects(void) const;
        Real getAnimationDuration(void) const;

        void setTextureFiltering(TextureFilterOptions filterType);
        void setTextureFiltering(FilterType ftype, FilterOptions opts);
        void setTextureFiltering(FilterOptions minFilter, FilterOptions magFilter, FilterOptions mipFilter);
        FilterOptions getTextureFiltering(FilterType ftpye) const;

        void setTextureCompareEnabled(bool enabled);
        bool getTextureCompareEnabled() const;
    
        void setTextureCompareFunction(CompareFunction function);
        CompareFunction getTextureCompareFunction() const;

        void setTextureAnisotropy(unsigned int maxAniso);
        unsigned int getTextureAnisotropy() const;

        void setTextureMipmapBias(float bias) { mMipmapBias = bias; }
        float getTextureMipmapBias(void) const { return mMipmapBias; }

        void setCompositorReference(const String& compositorName, const String& textureName, size_t mrtIndex = 0);

        const String& getReferencedCompositorName() const { return mCompositorRefName; }
        const String& getReferencedTextureName() const { return mCompositorRefTexName; }
        size_t getReferencedMRTIndex() const { return mCompositorRefMrtIndex; }
    
        Pass* getParent(void) const { return mParent; }

        void _prepare(void);
        void _unprepare(void);
        void _load(void);
        void _unload(void);
        bool hasViewRelativeTextureCoordinateGeneration(void) const;

        bool isLoaded(void) const;
        void _notifyNeedsRecompile(void);

        void setName(const String& name);
        const String& getName(void) const { return mName; }

        void setTextureNameAlias(const String& name);
        const String& getTextureNameAlias(void) const { return mTextureNameAlias;}

        bool applyTextureAliases(const AliasTextureNamePairList& aliasList, const bool apply = true);

        void _notifyParent(Pass* parent);

        const TexturePtr& _getTexturePtr(void) const;
        const TexturePtr& _getTexturePtr(size_t frame) const;
    
        void _setTexturePtr(const TexturePtr& texptr);
        void _setTexturePtr(const TexturePtr& texptr, size_t frame);

        size_t calculateSize(void) const;

        Controller<Real>* _getAnimController() const { return mAnimController; }
protected:
        // State
        unsigned int mCurrentFrame;

        Real mAnimDuration;
        bool mCubic; 
        
        TextureType mTextureType; 
        PixelFormat mDesiredFormat;
        int mTextureSrcMipmaps; 

        unsigned int mTextureCoordSetIndex;
        UVWAddressingMode mAddressMode;
        ColourValue mBorderColour;

        LayerBlendModeEx mColourBlendMode;
        SceneBlendFactor mColourBlendFallbackSrc;
        SceneBlendFactor mColourBlendFallbackDest;

        LayerBlendModeEx mAlphaBlendMode;
        mutable bool mTextureLoadFailed;
        bool mIsAlpha;
        bool mHwGamma;
        Real mGamma;

        mutable bool mRecalcTexMatrix;
        Real mUMod, mVMod;
        Real mUScale, mVScale;
        Radian mRotate;
        mutable Matrix4 mTexModMatrix;

        FilterOptions mMinFilter;
        FilterOptions mMagFilter;
        FilterOptions mMipFilter;

        bool mCompareEnabled;
        CompareFunction mCompareFunc;

        unsigned int mMaxAniso;
        float mMipmapBias;

        bool mIsDefaultAniso;
        bool mIsDefaultFiltering;
        BindingType mBindingType;
        ContentType mContentType;
        size_t mCompositorRefMrtIndex;

        //-----------------------------------------------------------------------------
        // Complex members (those that can't be copied using memcpy) are at the end to 
        // allow for fast copying of the basic members.
        //
        vector<String>::type mFrames;
        mutable vector<TexturePtr>::type mFramePtrs;
        String mName;               
        String mTextureNameAlias;   
        EffectMap mEffects;
        String mCompositorRefName;
        String mCompositorRefTexName;
        //-----------------------------------------------------------------------------

        //-----------------------------------------------------------------------------
        // Pointer members (those that can't be copied using memcpy), and MUST
        // preserving even if assign from others
        //
        Pass* mParent;
        Controller<Real>* mAnimController;
        //-----------------------------------------------------------------------------


        void recalcTextureMatrix(void) const;

        void createAnimController(void);

        void createEffectController(TextureEffect& effect);

        void ensurePrepared(size_t frame) const;
        void ensureLoaded(size_t frame) const;


    };

} // namespace Ogre

#include "OgreHeaderSuffix.h"

#endif // __TextureUnitState_H__