Main Page   Namespace List   Class Hierarchy   Alphabetical List   Compound List   File List   Namespace Members   Compound Members   File Members   Related Pages  

OgreTextureUnitState.cpp

Go to the documentation of this file.
00001 /*
00002 -----------------------------------------------------------------------------
00003 This source file is part of OGRE
00004     (Object-oriented Graphics Rendering Engine)
00005 For the latest info, see http://ogre.sourceforge.net/
00006 
00007 Copyright © 2000-2003 The OGRE Team
00008 Also see acknowledgements in Readme.html
00009 
00010 This program is free software; you can redistribute it and/or modify it under
00011 the terms of the GNU Lesser General Public License as published by the Free Software
00012 Foundation; either version 2 of the License, or (at your option) any later
00013 version.
00014 
00015 This program is distributed in the hope that it will be useful, but WITHOUT
00016 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
00017 FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details.
00018 
00019 You should have received a copy of the GNU Lesser General Public License along with
00020 this program; if not, write to the Free Software Foundation, Inc., 59 Temple
00021 Place - Suite 330, Boston, MA 02111-1307, USA, or go to
00022 http://www.gnu.org/copyleft/lesser.txt.
00023 -----------------------------------------------------------------------------
00024 */
00025 #include "OgreStableHeaders.h"
00026 
00027 #include "OgreTextureUnitState.h"
00028 #include "OgrePass.h"
00029 #include "OgreMaterialManager.h"
00030 #include "OgreControllerManager.h"
00031 #include "OgreLogManager.h"
00032 #include "OgreException.h"
00033 #include "OgreTextureManager.h"
00034 
00035 namespace Ogre {
00036 
00037     //-----------------------------------------------------------------------
00038     TextureUnitState::TextureUnitState(Pass* parent)
00039         : mParent(parent)
00040     {
00041         mIsBlank = true;
00042         colourBlendMode.blendType = LBT_COLOUR;
00043         setColourOperation(LBO_MODULATE);
00044         setTextureAddressingMode(TAM_WRAP);
00045 
00046         alphaBlendMode.operation = LBX_MODULATE;
00047         alphaBlendMode.blendType = LBT_ALPHA;
00048         alphaBlendMode.source1 = LBS_TEXTURE;
00049         alphaBlendMode.source2 = LBS_CURRENT;
00050         
00051         //default filtering
00052         mMinFilter = FO_LINEAR;
00053         mMagFilter = FO_LINEAR;
00054         mMipFilter = FO_POINT;
00055         mMaxAniso = MaterialManager::getSingleton().getDefaultAnisotropy();
00056         mIsDefaultAniso = true;
00057         mIsDefaultFiltering = true;
00058 
00059         mUMod = mVMod = 0;
00060         mUScale = mVScale = 1;
00061         mRotate = 0;
00062         mTexModMatrix = Matrix4::IDENTITY;
00063         mRecalcTexMatrix = false;
00064         mAlphaRejectFunc = CMPF_ALWAYS_PASS;
00065         mAlphaRejectVal = 0;
00066 
00067         mNumFrames = 0;
00068         mAnimDuration = 0;
00069         mAnimController = 0;
00070         mCubic = false;
00071         mTextureType = TEX_TYPE_2D;
00072         mTextureCoordSetIndex = 0;
00073 
00074         mFrames[0] = StringUtil::BLANK;
00075         mCurrentFrame = 0;
00076 
00077         mParent->_dirtyHash();
00078 
00079     }
00080 
00081     //-----------------------------------------------------------------------
00082     TextureUnitState::TextureUnitState(Pass* parent, const TextureUnitState& oth )
00083     {
00084         mParent = parent;
00085         *this = oth;
00086     }
00087 
00088     //-----------------------------------------------------------------------
00089     TextureUnitState::TextureUnitState( Pass* parent, const String& texName, unsigned int texCoordSet)
00090         :mParent(parent)
00091     {
00092         mIsBlank = true;
00093         colourBlendMode.blendType = LBT_COLOUR;
00094         setColourOperation(LBO_MODULATE);
00095         setTextureAddressingMode(TAM_WRAP);
00096 
00097         alphaBlendMode.operation = LBX_MODULATE;
00098         alphaBlendMode.blendType = LBT_ALPHA;
00099         alphaBlendMode.source1 = LBS_TEXTURE;
00100         alphaBlendMode.source2 = LBS_CURRENT;
00101 
00102         //default filtering && anisotropy
00103         mMinFilter = FO_LINEAR;
00104         mMagFilter = FO_LINEAR;
00105         mMipFilter = FO_POINT;
00106         mMaxAniso = MaterialManager::getSingleton().getDefaultAnisotropy();
00107         mIsDefaultAniso = true;
00108         mIsDefaultFiltering = true;
00109 
00110         mUMod = mVMod = 0;
00111         mUScale = mVScale = 1;
00112         mRotate = 0;
00113         mAnimDuration = 0;
00114         mAnimController = 0;
00115         mTexModMatrix = Matrix4::IDENTITY;
00116         mRecalcTexMatrix = false;
00117         mAlphaRejectFunc = CMPF_ALWAYS_PASS;
00118         mAlphaRejectVal = 0;
00119 
00120         mCubic = false;
00121         mTextureType = TEX_TYPE_2D;
00122         mTextureCoordSetIndex = 0;
00123 
00124         setTextureName(texName);
00125         setTextureCoordSet(texCoordSet);
00126 
00127         mParent->_dirtyHash();
00128 
00129     }
00130     //-----------------------------------------------------------------------
00131     TextureUnitState::~TextureUnitState()
00132     {
00133         // Destroy controllers
00134         if (mAnimController)
00135         {
00136             ControllerManager::getSingleton().destroyController(mAnimController);
00137         }
00138         // Destroy effect controllers
00139         for (EffectMap::iterator i = mEffects.begin(); i != mEffects.end(); ++i)
00140         {
00141             if (i->second.controller)
00142             {
00143                 ControllerManager::getSingleton().destroyController(i->second.controller);
00144             }
00145 
00146         }
00147         // Don't unload textures. may be used elsewhere
00148 
00149     }
00150     //-----------------------------------------------------------------------
00151     TextureUnitState & TextureUnitState::operator = ( 
00152         const TextureUnitState &oth )
00153     {
00154         // copy basic members (int's, real's)
00155         memcpy( this, &oth, (uchar *)(&oth.mFrames[0]) - (uchar *)(&oth) );
00156 
00157         // copy complex members
00158         for( ushort i = 0; i<mNumFrames; i++ )
00159             mFrames[i] = oth.mFrames[i];
00160 
00161         mEffects = oth.mEffects;
00162 
00163         mParent->_dirtyHash();
00164 
00165         return *this;
00166     }
00167     //-----------------------------------------------------------------------
00168     const String& TextureUnitState::getTextureName(void) const
00169     {
00170         // Return name of current frame
00171         return mFrames[mCurrentFrame];
00172     }
00173     //-----------------------------------------------------------------------
00174     void TextureUnitState::setTextureName( const String& name, TextureType texType)
00175     {
00176         if (texType == TEX_TYPE_CUBE_MAP)
00177         {
00178             // delegate to cubic texture implementation
00179             setCubicTextureName(name, true);
00180         }
00181         else
00182         {
00183             mFrames[0] = name;
00184             mNumFrames = 1;
00185             mCurrentFrame = 0;
00186             mCubic = false;
00187             mTextureType = texType;
00188 
00189             if (name == "")
00190             {
00191                 mIsBlank = true;
00192                 return;
00193             }
00194             
00195             // Load immediately ?
00196             if (isLoaded())
00197             {
00198                 _load(); // reload
00199                 // Tell parent to recalculate hash
00200                 mParent->_dirtyHash();
00201             }
00202         }
00203 
00204     }
00205     //-----------------------------------------------------------------------
00206     void TextureUnitState::setCubicTextureName( const String& name, bool forUVW)
00207     {
00208         if (forUVW)
00209         {
00210             setCubicTextureName(&name, forUVW);
00211         }
00212         else
00213         {
00214             String ext;
00215             String suffixes[6] = {"_fr", "_bk", "_lf", "_rt", "_up", "_dn"};
00216             String baseName;
00217             String fullNames[6];
00218 
00219 
00220             size_t pos = name.find_last_of(".");
00221             baseName = name.substr(0, pos);
00222             ext = name.substr(pos);
00223 
00224             for (int i = 0; i < 6; ++i)
00225             {
00226                 fullNames[i] = baseName + suffixes[i] + ext;
00227             }
00228 
00229             setCubicTextureName(fullNames, forUVW);
00230         }
00231     }
00232     //-----------------------------------------------------------------------
00233     void TextureUnitState::setCubicTextureName(const String* const names, bool forUVW)
00234     {
00235         mNumFrames = forUVW ? 1 : 6;
00236         mCurrentFrame = 0;
00237         mCubic = true;
00238         mTextureType = forUVW ? TEX_TYPE_CUBE_MAP : TEX_TYPE_2D;
00239 
00240         for (unsigned int i = 0; i < mNumFrames; ++i)
00241         {
00242             mFrames[i] = names[i];
00243         }
00244         // Tell parent we need recompiling, will cause reload too
00245         mParent->_notifyNeedsRecompile();
00246     }
00247     //-----------------------------------------------------------------------
00248     bool TextureUnitState::isCubic(void) const
00249     {
00250         return mCubic;
00251     }
00252     //-----------------------------------------------------------------------
00253     bool TextureUnitState::is3D(void) const
00254     {
00255         return mTextureType == TEX_TYPE_CUBE_MAP;
00256     }
00257     //-----------------------------------------------------------------------
00258     TextureType TextureUnitState::getTextureType(void) const
00259     {
00260         return mTextureType;
00261 
00262     }
00263     //-----------------------------------------------------------------------
00264     void TextureUnitState::setAnimatedTextureName( const String& name, unsigned int numFrames, Real duration)
00265     {
00266         String ext;
00267         String baseName;
00268 
00269         size_t pos = name.find_last_of(".");
00270         baseName = name.substr(0, pos);
00271         ext = name.substr(pos);
00272 
00273         if (numFrames > MAX_FRAMES)
00274         {
00275             char cmsg[128];
00276             sprintf(cmsg, "Maximum number of frames is %d.", MAX_FRAMES);
00277             Except(Exception::ERR_INVALIDPARAMS, cmsg, "TextureUnitState::setAnimatedTextureName");
00278         }
00279         mNumFrames = numFrames;
00280         mAnimDuration = duration;
00281         mCurrentFrame = 0;
00282         mCubic = false;
00283 
00284         for (unsigned int i = 0; i < mNumFrames; ++i)
00285         {
00286             char suffix[5];
00287             sprintf(suffix, "_%d", i);
00288 
00289             mFrames[i] = baseName + suffix + ext;
00290         }
00291 
00292         // Load immediately if Material loaded
00293         if (isLoaded())
00294         {
00295             _load();
00296             // Tell parent to recalculate hash
00297             mParent->_dirtyHash();
00298         }
00299 
00300     }
00301     //-----------------------------------------------------------------------
00302     void TextureUnitState::setAnimatedTextureName(const String* const names, unsigned int numFrames, Real duration)
00303     {
00304         if (numFrames > MAX_FRAMES)
00305         {
00306             char cmsg[128];
00307             sprintf(cmsg, "Maximum number of frames is %d.", MAX_FRAMES);
00308             Except(Exception::ERR_INVALIDPARAMS, cmsg, "TextureUnitState::setAnimatedTextureName");
00309         }
00310         mNumFrames = numFrames;
00311         mAnimDuration = duration;
00312         mCurrentFrame = 0;
00313         mCubic = false;
00314 
00315         for (unsigned int i = 0; i < mNumFrames; ++i)
00316         {
00317             mFrames[i] = names[i];
00318         }
00319 
00320         // Load immediately if Material loaded
00321         if (isLoaded())
00322         {
00323             _load();
00324             // Tell parent to recalculate hash
00325             mParent->_dirtyHash();
00326         }
00327     }
00328     //-----------------------------------------------------------------------
00329     std::pair< uint, uint > TextureUnitState::getTextureDimensions( unsigned int frame ) const
00330     {
00331         Texture *tex = (Texture *)TextureManager::getSingleton().getByName( mFrames[ frame ] );
00332         if (!tex)
00333             Except( Exception::ERR_ITEM_NOT_FOUND, "Could not find texture " + mFrames[ frame ],
00334                 "TextureUnitState::getTextureDimensions" );
00335         return std::pair< uint, uint >( tex->getWidth(), tex->getHeight() );
00336     }
00337     //-----------------------------------------------------------------------
00338     void TextureUnitState::setCurrentFrame(unsigned int frameNumber)
00339     {
00340         assert(frameNumber < mNumFrames);
00341         mCurrentFrame = frameNumber;
00342         // this will affect the hash
00343         mParent->_dirtyHash();
00344 
00345     }
00346     //-----------------------------------------------------------------------
00347     unsigned int TextureUnitState::getCurrentFrame(void) const
00348     {
00349         return mCurrentFrame;
00350     }
00351     //-----------------------------------------------------------------------
00352     unsigned int TextureUnitState::getNumFrames(void) const
00353     {
00354         return mNumFrames;
00355     }
00356     //-----------------------------------------------------------------------
00357     const String& TextureUnitState::getFrameTextureName(unsigned int frameNumber) const
00358     {
00359         assert(frameNumber < mNumFrames);
00360         return mFrames[frameNumber];
00361     }
00362     //-----------------------------------------------------------------------
00363     unsigned int TextureUnitState::getTextureCoordSet(void) const
00364     {
00365         return mTextureCoordSetIndex;
00366     }
00367     //-----------------------------------------------------------------------
00368     void TextureUnitState::setTextureCoordSet(unsigned int set)
00369     {
00370         mTextureCoordSetIndex = set;
00371     }
00372     //-----------------------------------------------------------------------
00373     void TextureUnitState::setColourOperationEx(LayerBlendOperationEx op,
00374         LayerBlendSource source1,
00375         LayerBlendSource source2,
00376         const ColourValue& arg1,
00377         const ColourValue& arg2,
00378         Real manualBlend)
00379     {
00380         colourBlendMode.operation = op;
00381         colourBlendMode.source1 = source1;
00382         colourBlendMode.source2 = source2;
00383         colourBlendMode.colourArg1 = arg1;
00384         colourBlendMode.colourArg2 = arg2;
00385         colourBlendMode.factor = manualBlend;
00386     }
00387     //-----------------------------------------------------------------------
00388     void TextureUnitState::setColourOperation(LayerBlendOperation op)
00389     {
00390         // Set up the multitexture and multipass blending operations
00391         switch (op)
00392         {
00393         case LBO_REPLACE:
00394             setColourOperationEx(LBX_SOURCE1, LBS_TEXTURE, LBS_CURRENT);
00395             setColourOpMultipassFallback(SBF_ONE, SBF_ZERO);
00396             break;
00397         case LBO_ADD:
00398             setColourOperationEx(LBX_ADD, LBS_TEXTURE, LBS_CURRENT);
00399             setColourOpMultipassFallback(SBF_ONE, SBF_ONE);
00400             break;
00401         case LBO_MODULATE:
00402             setColourOperationEx(LBX_MODULATE, LBS_TEXTURE, LBS_CURRENT);
00403             setColourOpMultipassFallback(SBF_DEST_COLOUR, SBF_ZERO);
00404             break;
00405         case LBO_ALPHA_BLEND:
00406             setColourOperationEx(LBX_BLEND_TEXTURE_ALPHA, LBS_TEXTURE, LBS_CURRENT);
00407             setColourOpMultipassFallback(SBF_SOURCE_ALPHA, SBF_ONE_MINUS_SOURCE_ALPHA);
00408             break;
00409         }
00410 
00411 
00412     }
00413     //-----------------------------------------------------------------------
00414     void TextureUnitState::setColourOpMultipassFallback(SceneBlendFactor sourceFactor, SceneBlendFactor destFactor)
00415     {
00416         colourBlendFallbackSrc = sourceFactor;
00417         colourBlendFallbackDest = destFactor;
00418     }
00419     //-----------------------------------------------------------------------
00420     void TextureUnitState::setAlphaOperation(LayerBlendOperationEx op,
00421         LayerBlendSource source1,
00422         LayerBlendSource source2,
00423         Real arg1,
00424         Real arg2,
00425         Real manualBlend)
00426     {
00427         alphaBlendMode.operation = op;
00428         alphaBlendMode.source1 = source1;
00429         alphaBlendMode.source2 = source2;
00430         alphaBlendMode.alphaArg1 = arg1;
00431         alphaBlendMode.alphaArg2 = arg2;
00432         alphaBlendMode.factor = manualBlend;
00433     }
00434     //-----------------------------------------------------------------------
00435     void TextureUnitState::addEffect(TextureEffect& effect)
00436     {
00437         // Ensure controller pointer is null
00438         effect.controller = 0;
00439 
00440         if (effect.type == ET_ENVIRONMENT_MAP || effect.type == ET_SCROLL || effect.type == ET_ROTATE
00441             || effect.type == ET_PROJECTIVE_TEXTURE)
00442         {
00443             // Replace - must be unique
00444             // Search for existing effect of this type
00445             EffectMap::iterator i = mEffects.find(effect.type);
00446             if (i != mEffects.end())
00447             {
00448                 mEffects.erase(i);
00449             }
00450         }
00451 
00452         if (isLoaded())
00453         {
00454             // Create controller
00455             createEffectController(effect);
00456         }
00457 
00458         // Record new effect
00459         mEffects.insert(EffectMap::value_type(effect.type, effect));
00460 
00461     }
00462     //-----------------------------------------------------------------------
00463     void TextureUnitState::removeAllEffects(void)
00464     {
00465         // Iterate over effects to remove controllers
00466         EffectMap::iterator i, iend;
00467         iend = mEffects.end();
00468         for (i = mEffects.begin(); i != iend; ++i)
00469         {
00470             if (i->second.controller)
00471             {
00472                 ControllerManager::getSingleton().destroyController(i->second.controller);
00473             }
00474         }
00475 
00476         mEffects.clear();
00477     }
00478 
00479     //-----------------------------------------------------------------------
00480     bool TextureUnitState::isBlank(void) const
00481     {
00482         return mIsBlank;
00483     }
00484 
00485     //-----------------------------------------------------------------------
00486     SceneBlendFactor TextureUnitState::getColourBlendFallbackSrc(void) const
00487     {
00488         return colourBlendFallbackSrc;
00489     }
00490     //-----------------------------------------------------------------------
00491     SceneBlendFactor TextureUnitState::getColourBlendFallbackDest(void) const
00492     {
00493         return colourBlendFallbackDest;
00494     }
00495     //-----------------------------------------------------------------------
00496     const LayerBlendModeEx& TextureUnitState::getColourBlendMode(void) const
00497     {
00498         return colourBlendMode;
00499     }
00500     //-----------------------------------------------------------------------
00501     const LayerBlendModeEx& TextureUnitState::getAlphaBlendMode(void) const
00502     {
00503         return alphaBlendMode;
00504     }
00505     //-----------------------------------------------------------------------
00506     TextureUnitState::TextureAddressingMode TextureUnitState::getTextureAddressingMode(void) const
00507     {
00508         return mAddressMode;
00509     }
00510     //-----------------------------------------------------------------------
00511     void TextureUnitState::setTextureAddressingMode(TextureUnitState::TextureAddressingMode tam)
00512     {
00513         mAddressMode = tam;
00514     }
00515     //-----------------------------------------------------------------------
00516     void TextureUnitState::setEnvironmentMap(bool enable, EnvMapType envMapType)
00517     {
00518         if (enable)
00519         {
00520             TextureEffect eff;
00521             eff.type = ET_ENVIRONMENT_MAP;
00522 
00523             eff.subtype = envMapType;
00524             addEffect(eff);
00525         }
00526         else
00527         {
00528             removeEffect(ET_ENVIRONMENT_MAP);
00529         }
00530     }
00531     //-----------------------------------------------------------------------
00532     void TextureUnitState::removeEffect(TextureEffectType type)
00533     {
00534         // Get range of items matching this effect
00535         std::pair< EffectMap::iterator, EffectMap::iterator > remPair = 
00536             mEffects.equal_range( type );
00537         // Remove controllers
00538         for (EffectMap::iterator i = remPair.first; i != remPair.second; ++i)
00539         {
00540             if (i->second.controller)
00541             {
00542                 ControllerManager::getSingleton().destroyController(i->second.controller);
00543             }
00544         }
00545         // Erase         
00546         mEffects.erase( remPair.first, remPair.second );
00547     }
00548     //-----------------------------------------------------------------------
00549     void TextureUnitState::setBlank(void)
00550     {
00551         mIsBlank = true;
00552     }
00553     //-----------------------------------------------------------------------
00554     void TextureUnitState::setTextureTransform(const Matrix4& xform)
00555     {
00556         mTexModMatrix = xform;
00557         mRecalcTexMatrix = false;
00558     }
00559     //-----------------------------------------------------------------------
00560     void TextureUnitState::setTextureScroll(Real u, Real v)
00561     {
00562         mUMod = u;
00563         mVMod = v;
00564         mRecalcTexMatrix = true;
00565     }
00566     //-----------------------------------------------------------------------
00567     void TextureUnitState::setTextureScale(Real uScale, Real vScale)
00568     {
00569         mUScale = uScale;
00570         mVScale = vScale;
00571         mRecalcTexMatrix = true;
00572     }
00573     //-----------------------------------------------------------------------
00574     void TextureUnitState::setTextureRotate(const Radian& angle)
00575     {
00576         mRotate = angle;
00577         mRecalcTexMatrix = true;
00578     }
00579     //-----------------------------------------------------------------------
00580     const Matrix4& TextureUnitState::getTextureTransform()
00581     {
00582         if (mRecalcTexMatrix)
00583             recalcTextureMatrix();
00584         return mTexModMatrix;
00585 
00586     }
00587     //-----------------------------------------------------------------------
00588     void TextureUnitState::recalcTextureMatrix()
00589     {
00590         // Assumption: 2D texture coords
00591         Matrix3 xform, rot;
00592 
00593         xform = Matrix3::IDENTITY;
00594         if (mUScale || mVScale)
00595         {
00596             // Offset to center of texture
00597             xform[0][0] = 1/mUScale;
00598             xform[1][1] = 1/mVScale;
00599             // Skip matrix concat since first matrix update
00600             xform[0][2] = (-0.5 * xform[0][0]) + 0.5;
00601             xform[1][2] = (-0.5 * xform[1][1]) + 0.5;
00602 
00603         }
00604 
00605         if (mUMod || mVMod)
00606         {
00607             Matrix3 xlate = Matrix3::IDENTITY;
00608 
00609             xlate[0][2] = mUMod;
00610             xlate[1][2] = mVMod;
00611 
00612             xform = xlate * xform;
00613         }
00614 
00615         if (mRotate != Radian(0))
00616         {
00617             rot = Matrix3::IDENTITY;
00618             Radian theta ( mRotate );
00619             Real cosTheta = Math::Cos(theta);
00620             Real sinTheta = Math::Sin(theta);
00621 
00622             rot[0][0] = cosTheta;
00623             rot[0][1] = -sinTheta;
00624             rot[1][0] = sinTheta;
00625             rot[1][1] = cosTheta;
00626             // Offset center of rotation to center of texture
00627             rot[0][2] = 0.5 + ( (-0.5 * cosTheta) - (-0.5 * sinTheta) );
00628             rot[1][2] = 0.5 + ( (-0.5 * sinTheta) + (-0.5 * cosTheta) );
00629 
00630 
00631             xform = rot * xform;
00632         }
00633 
00634         mTexModMatrix = xform;
00635 
00636     }
00637     //-----------------------------------------------------------------------
00638     void TextureUnitState::setTextureUScroll(Real value)
00639     {
00640         mUMod = value;
00641         mRecalcTexMatrix = true;
00642     }
00643     //-----------------------------------------------------------------------
00644     void TextureUnitState::setTextureVScroll(Real value)
00645     {
00646         mVMod = value;
00647         mRecalcTexMatrix = true;
00648     }
00649     //-----------------------------------------------------------------------
00650     void TextureUnitState::setTextureUScale(Real value)
00651     {
00652         mUScale = value;
00653         mRecalcTexMatrix = true;
00654     }
00655     //-----------------------------------------------------------------------
00656     void TextureUnitState::setTextureVScale(Real value)
00657     {
00658         mVScale = value;
00659         mRecalcTexMatrix = true;
00660     }
00661     //-----------------------------------------------------------------------
00662     void TextureUnitState::setAlphaRejectSettings(CompareFunction func, unsigned char value)
00663     {
00664         mAlphaRejectFunc = func;
00665         mAlphaRejectVal = value;
00666     }
00667     //-----------------------------------------------------------------------
00668     CompareFunction TextureUnitState::getAlphaRejectFunction(void) const
00669     {
00670         return mAlphaRejectFunc;
00671     }
00672     //-----------------------------------------------------------------------
00673     unsigned char TextureUnitState::getAlphaRejectValue(void) const
00674     {
00675         return mAlphaRejectVal;
00676     }
00677     //-----------------------------------------------------------------------
00678     void TextureUnitState::setScrollAnimation(Real uSpeed, Real vSpeed)
00679     {
00680         // Remove existing effect
00681         removeEffect(ET_SCROLL);
00682         // Create new effect
00683         TextureEffect eff;
00684         eff.type = ET_SCROLL;
00685         eff.arg1 = uSpeed;
00686         eff.arg2 = vSpeed;
00687         addEffect(eff);
00688     }
00689     //-----------------------------------------------------------------------
00690     void TextureUnitState::setRotateAnimation(Real speed)
00691     {
00692         // Remove existing effect
00693         removeEffect(ET_ROTATE);
00694         // Create new effect
00695         TextureEffect eff;
00696         eff.type = ET_ROTATE;
00697         eff.arg1 = speed;
00698         addEffect(eff);
00699     }
00700     //-----------------------------------------------------------------------
00701     void TextureUnitState::setTransformAnimation(TextureTransformType ttype,
00702         WaveformType waveType, Real base, Real frequency, Real phase, Real amplitude)
00703     {
00704         // Remove existing effect
00705         removeEffect(ET_TRANSFORM);
00706         // Create new effect
00707         TextureEffect eff;
00708         eff.type = ET_TRANSFORM;
00709         eff.subtype = ttype;
00710         eff.waveType = waveType;
00711         eff.base = base;
00712         eff.frequency = frequency;
00713         eff.phase = phase;
00714         eff.amplitude = amplitude;
00715         addEffect(eff);
00716     }
00717     //-----------------------------------------------------------------------
00718     void TextureUnitState::_load(void)
00719     {
00720         // Load textures
00721         for (unsigned int i = 0; i < mNumFrames; ++i)
00722         {
00723             if (mFrames[i] != "")
00724             {
00725                 // Ensure texture is loaded, default MipMaps and priority
00726                 try {
00727 
00728                     TextureManager::getSingleton().load(mFrames[i], mTextureType);
00729                     mIsBlank = false;
00730                 }
00731                 catch (...) {
00732                     String msg;
00733                     msg = msg + "Error loading texture " + mFrames[i]  + ". Texture layer will be blank.";
00734                     LogManager::getSingleton().logMessage(msg);
00735                     mIsBlank = true;
00736                 }
00737             }
00738         }
00739         // Animation controller
00740         if (mAnimDuration != 0)
00741         {
00742             createAnimController();
00743         }
00744         // Effect controllers
00745         for (EffectMap::iterator it = mEffects.begin(); it != mEffects.end(); ++it)
00746         {
00747             createEffectController(it->second);
00748         }
00749 
00750     }
00751     //-----------------------------------------------------------------------
00752     void TextureUnitState::createAnimController(void)
00753     {
00754         mAnimController = ControllerManager::getSingleton().createTextureAnimator(this, mAnimDuration);
00755 
00756     }
00757     //-----------------------------------------------------------------------
00758     void TextureUnitState::createEffectController(TextureEffect& effect)
00759     {
00760         effect.controller = 0;
00761         ControllerManager& cMgr = ControllerManager::getSingleton();
00762         switch (effect.type)
00763         {
00764         case ET_SCROLL:
00765             effect.controller = cMgr.createTextureScroller(this, effect.arg1, effect.arg2);
00766             break;
00767         case ET_ROTATE:
00768             effect.controller = cMgr.createTextureRotater(this, effect.arg1);
00769             break;
00770         case ET_TRANSFORM:
00771             effect.controller = cMgr.createTextureWaveTransformer(this, (TextureUnitState::TextureTransformType)effect.subtype, effect.waveType, effect.base,
00772                 effect.frequency, effect.phase, effect.amplitude);
00773             break;
00774         case ET_ENVIRONMENT_MAP:
00775             break;
00776         default:
00777             break;
00778         }
00779     }
00780     //-----------------------------------------------------------------------
00781     Real TextureUnitState::getTextureUScroll(void) const
00782     {
00783         return mUMod;
00784     }
00785 
00786     //-----------------------------------------------------------------------
00787     Real TextureUnitState::getTextureVScroll(void) const
00788     {
00789         return mVMod;
00790     }
00791 
00792     //-----------------------------------------------------------------------
00793     Real TextureUnitState::getTextureUScale(void) const
00794     {
00795         return mUScale;
00796     }
00797 
00798     //-----------------------------------------------------------------------
00799     Real TextureUnitState::getTextureVScale(void) const
00800     {
00801         return mVScale;
00802     }
00803 
00804     //-----------------------------------------------------------------------
00805     const Radian& TextureUnitState::getTextureRotate(void) const
00806     {
00807         return mRotate;
00808     }
00809     
00810     //-----------------------------------------------------------------------
00811     Real TextureUnitState::getAnimationDuration(void) const
00812     {
00813         return mAnimDuration;
00814     }
00815 
00816     //-----------------------------------------------------------------------
00817     std::multimap<TextureUnitState::TextureEffectType, TextureUnitState::TextureEffect> TextureUnitState::getEffects(void) const
00818     {
00819         return mEffects;
00820     }
00821 
00822     //-----------------------------------------------------------------------
00823     void TextureUnitState::setTextureFiltering(TextureFilterOptions filterType)
00824     {
00825         switch (filterType)
00826         {
00827         case TFO_NONE:
00828             setTextureFiltering(FO_POINT, FO_POINT, FO_NONE);
00829             break;
00830         case TFO_BILINEAR:
00831             setTextureFiltering(FO_LINEAR, FO_LINEAR, FO_POINT);
00832             break;
00833         case TFO_TRILINEAR:
00834             setTextureFiltering(FO_LINEAR, FO_LINEAR, FO_LINEAR);
00835             break;
00836         case TFO_ANISOTROPIC:
00837             setTextureFiltering(FO_ANISOTROPIC, FO_ANISOTROPIC, FO_LINEAR);
00838             break;
00839         }
00840         mIsDefaultFiltering = false;
00841     }
00842     //-----------------------------------------------------------------------
00843     void TextureUnitState::setTextureFiltering(FilterType ft, FilterOptions fo)
00844     {
00845         switch (ft)
00846         {
00847         case FT_MIN:
00848             mMinFilter = fo;
00849             break;
00850         case FT_MAG:
00851             mMagFilter = fo;
00852             break;
00853         case FT_MIP:
00854             mMipFilter = fo;
00855             break;
00856         }
00857         mIsDefaultFiltering = false;
00858     }
00859     //-----------------------------------------------------------------------
00860     void TextureUnitState::setTextureFiltering(FilterOptions minFilter, 
00861         FilterOptions magFilter, FilterOptions mipFilter)
00862     {
00863         mMinFilter = minFilter;
00864         mMagFilter = magFilter;
00865         mMipFilter = mipFilter;
00866         mIsDefaultFiltering = false;
00867     }
00868     //-----------------------------------------------------------------------
00869     FilterOptions TextureUnitState::getTextureFiltering(FilterType ft) const
00870     {
00871 
00872         switch (ft)
00873         {
00874         case FT_MIN:
00875             return mIsDefaultFiltering ? 
00876                 MaterialManager::getSingleton().getDefaultTextureFiltering(FT_MIN) : mMinFilter;
00877         case FT_MAG:
00878             return mIsDefaultFiltering ? 
00879                 MaterialManager::getSingleton().getDefaultTextureFiltering(FT_MAG) : mMagFilter;
00880         case FT_MIP:
00881             return mIsDefaultFiltering ? 
00882                 MaterialManager::getSingleton().getDefaultTextureFiltering(FT_MIP) : mMipFilter;
00883         }
00884         // to keep compiler happy
00885         return mMinFilter;
00886     }
00887 
00888     //-----------------------------------------------------------------------
00889     void TextureUnitState::setTextureAnisotropy(unsigned int maxAniso)
00890     {
00891         mMaxAniso = maxAniso;
00892         mIsDefaultAniso = false;
00893     }
00894     //-----------------------------------------------------------------------
00895     unsigned int TextureUnitState::getTextureAnisotropy() const
00896     {
00897         return mIsDefaultAniso? MaterialManager::getSingleton().getDefaultAnisotropy() : mMaxAniso;
00898     }
00899 
00900     //-----------------------------------------------------------------------
00901     void TextureUnitState::_unload(void)
00902     {
00903         // TODO
00904     }
00905     //-----------------------------------------------------------------------------
00906     bool TextureUnitState::isLoaded(void)
00907     {
00908         return mParent->isLoaded();
00909     }
00910     //-----------------------------------------------------------------------
00911     void TextureUnitState::_notifyNeedsRecompile(void)
00912     {
00913         mParent->_notifyNeedsRecompile();
00914     }
00915     //-----------------------------------------------------------------------
00916     bool TextureUnitState::hasViewRelativeTextureCoordinateGeneration(void)
00917     {
00918         // Right now this only returns true for reflection maps
00919 
00920         EffectMap::const_iterator i, iend;
00921         iend = mEffects.end();
00922         
00923         for(i = mEffects.find(ET_ENVIRONMENT_MAP); i != iend; ++i)
00924         {
00925             if (i->second.subtype == ENV_REFLECTION)
00926                 return true;
00927         }
00928         for(i = mEffects.find(ET_PROJECTIVE_TEXTURE); i != iend; ++i)
00929         {
00930             return true;
00931         }
00932 
00933         return false;
00934     }
00935     //-----------------------------------------------------------------------
00936     void TextureUnitState::setProjectiveTexturing(bool enable, 
00937         const Frustum* projectionSettings)
00938     {
00939         if (enable)
00940         {
00941             TextureEffect eff;
00942             eff.type = ET_PROJECTIVE_TEXTURE;
00943             eff.frustum = projectionSettings;
00944             addEffect(eff);
00945         }
00946         else
00947         {
00948             removeEffect(ET_PROJECTIVE_TEXTURE);
00949         }
00950 
00951     }
00952 
00953 }

Copyright © 2002-2003 by The OGRE Team
Last modified Sun Nov 28 19:48:50 2004