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://ogre.sourceforge.net/

Copyright (c) 2000-2005 The OGRE Team
Also see acknowledgements in Readme.html

This program is free software; you can redistribute it and/or modify it under
the terms of the GNU Lesser General Public License as published by the Free Software
Foundation; either version 2 of the License, or (at your option) any later
version.

This program is distributed in the hope that it will be useful, but WITHOUT
ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details.

You should have received a copy of the GNU Lesser General Public License along with
this program; if not, write to the Free Software Foundation, Inc., 59 Temple
Place - Suite 330, Boston, MA 02111-1307, USA, or go to
http://www.gnu.org/copyleft/lesser.txt.
-----------------------------------------------------------------------------
*/
#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"

namespace Ogre {
    class _OgreExport TextureUnitState
    {
        friend class RenderSystem;
    public:
        enum TextureEffectType
        {
            ET_ENVIRONMENT_MAP,
            ET_PROJECTIVE_TEXTURE,
            ET_SCROLL,
            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
        };

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


        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, int mipmaps = -1 );

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

        void setCubicTextureName( const String* const names, 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< uint, uint > getTextureDimensions( unsigned int frame = 0 ) const;

        void setCurrentFrame( unsigned int frameNumber );

        unsigned int getCurrentFrame(void) const;

        const String& getFrameTextureName(unsigned int frameNumber) const;

        unsigned int getNumFrames(void) const;

        bool isCubic(void) const;

        bool is3D(void) const;

        TextureType getTextureType(void) 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);
        // get texture uscroll value
        Real getTextureUScroll(void) const;

        void setTextureVScroll(Real value);
        // get texture vscroll value
        Real getTextureVScroll(void) const;

        void setTextureUScale(Real value);
        // get texture uscale value
        Real getTextureUScale(void) const;

        void setTextureVScale(Real value);
        // get texture vscale value
        Real getTextureVScale(void) const;

        void setTextureScale(Real uScale, Real vScale);

        void setTextureRotate(const Radian& angle);
#ifndef OGRE_FORCE_ANGLE_TYPES
        inline void setTextureRotate(Real angle) {
            setTextureRotate ( Degree(angle) );
        }
#endif//OGRE_FORCE_ANGLE_TYPES
        // get texture rotation effects angle value
        const Radian& getTextureRotate(void) const;

        TextureAddressingMode getTextureAddressingMode(void) const;

        void setTextureAddressingMode( TextureAddressingMode tam);

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

        // get texture effects in a multimap paired array
        std::multimap<TextureEffectType, TextureEffect> getEffects(void) const;
        // get the animated-texture animation duration
        Real getAnimationDuration(void) const;

        void setTextureFiltering(TextureFilterOptions filterType);
        void setTextureFiltering(FilterType ftype, FilterOptions opts);
        void setTextureFiltering(FilterOptions minFilter, FilterOptions magFilter, FilterOptions mipFilter);
        // get the texture filtering for the given type
        FilterOptions getTextureFiltering(FilterType ftpye) const;

        void setTextureAnisotropy(unsigned int maxAniso);
        // get this layer texture anisotropy level
        unsigned int getTextureAnisotropy() const;

        Pass* getParent(void) { return mParent; }

        void _load(void);
        void _unload(void);
        bool hasViewRelativeTextureCoordinateGeneration(void);

        // Is this loaded?
        bool isLoaded(void);
        void _notifyNeedsRecompile(void);

        void _notifyParent(Pass* parent);


    
protected:
        // State
#define OGRE_MAX_TEXTURE_FRAMES 32

        unsigned int mNumFrames;        
        unsigned int mCurrentFrame;
        // String mFrames[OGRE_MAX_TEXTURE_FRAMES] is at the end of the class                

        Real mAnimDuration;            
        bool mCubic; // is this a series of 6 2D textures to make up a cube?
        
        TextureType mTextureType; 
        int mTextureSrcMipmaps; // Request number of mipmaps

        unsigned int mTextureCoordSetIndex;
        TextureAddressingMode mAddressMode;                

        LayerBlendModeEx colourBlendMode;
        SceneBlendFactor colourBlendFallbackSrc;
        SceneBlendFactor colourBlendFallbackDest;

        LayerBlendModeEx alphaBlendMode;
        bool mIsBlank;

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

        // Animation, will be set up as Controllers
        Real mUScrollAnim, mVScrollAnim;
        Real mRotateAnim;

        FilterOptions mMinFilter;
        FilterOptions mMagFilter;
        FilterOptions mMipFilter;
        unsigned int mMaxAniso;

        bool mIsDefaultAniso;
        bool mIsDefaultFiltering;


        //-----------------------------------------------------------------------------
        // Complex members (those that can't be copied using memcpy) are at the end to 
        // allow for fast copying of the basic members.
        //
        String mFrames[OGRE_MAX_TEXTURE_FRAMES]; // Names of frames

        typedef std::multimap<TextureEffectType, TextureEffect> EffectMap;
        EffectMap mEffects;
        //-----------------------------------------------------------------------------

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


    };


}

#endif

---

Copyright © 2000-2005 by The OGRE Team

This work is licensed under a Creative Commons Attribution-ShareAlike 2.5 License.
Last modified Sun Feb 12 12:59:54 2006