nevrax.org : docs

00001 
+00007 /* Copyright, 2001 Nevrax Ltd.
+00008  *
+00009  * This file is part of NEVRAX NEL.
+00010  * NEVRAX NEL is free software; you can redistribute it and/or modify
+00011  * it under the terms of the GNU General Public License as published by
+00012  * the Free Software Foundation; either version 2, or (at your option)
+00013  * any later version.
+00014 
+00015  * NEVRAX NEL is distributed in the hope that it will be useful, but
+00016  * WITHOUT ANY WARRANTY; without even the implied warranty of
+00017  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+00018  * General Public License for more details.
+00019 
+00020  * You should have received a copy of the GNU General Public License
+00021  * along with NEVRAX NEL; see the file COPYING. If not, write to the
+00022  * Free Software Foundation, Inc., 59 Temple Place - Suite 330, Boston,
+00023  * MA 02111-1307, USA.
+00024  */
+00025 
+00026 #include "std3d.h"
+00027 
+00028 #include "3d/texture_grouped.h"
+00029 #include "3d/texture_file.h"
+00030 #include "nel/misc/common.h"
+00031 #include "nel/misc/path.h"
+00032 
+00033 #include <algorithm>
+00034 
+00035 namespace NL3D {
+00036 
+00039 static inline void GetTextureSize(ITexture *tex, uint &width, uint &height)
+00040 {       
+00041         if (tex->getClassName() == "CTextureFile")
+00042         {
+00043                 CTextureFile *tf = static_cast<CTextureFile *>(tex);                                                            
+00044                 uint32 srcWidth, srcHeight;
+00045                 if (!tf->getFileName().empty())
+00046                 {
+00047                         try
+00048                         {
+00049                                 CBitmap::loadSize(NLMISC::CPath::lookup(tf->getFileName()), srcWidth, srcHeight);
+00050                                 if (srcWidth == 0 || srcHeight == 0)
+00051                                 {
+00052                                         nlinfo("Unable to get size of texture : %s", tf->getFileName().c_str());
+00053                                         width = height = 0;
+00054                                         return;
+00055                                 }
+00056                                 width = srcWidth;
+00057                                 height = srcHeight;
+00058                         }
+00059                         catch (NLMISC::EPathNotFound &e)
+00060                         {
+00061                                 nlinfo("%s", e.what());
+00062                                 width = height = 0;
+00063                         }
+00064                         catch (NLMISC::EStream &e)
+00065                         {
+00066                                 nlinfo("unable to load size from a bitmap ! name = %s", tf->getFileName().c_str());
+00067                                 nlinfo("reason = %s", e.what());
+00068                                 width = height = 0;
+00069                         }
+00070                 }
+00071                 else
+00072                 {
+00073                         width = height = 0;
+00074                 }               
+00075         }
+00076         else // we must generate the texture to get its size
+00077         {
+00078                 tex->generate();
+00079                 width = tex->getWidth();
+00080                 height = tex->getHeight();
+00081                 if (tex->getReleasable())
+00082                 {
+00083                         tex->release();
+00084                 }
+00085         }
+00086 }
+00087 
+00089 CTextureGrouped::CTextureGrouped() : _NbTex(0)
+00090 {
+00091         setFilterMode(Linear, LinearMipMapOff);
+00092 }
+00093 
+00095 CTextureGrouped::CTextureGrouped(const CTextureGrouped &src) : ITexture(src)
+00096 {
+00097         // copy the part associated with us;
+00098         duplicate(src);
+00099 }
+00100 
+00102 void CTextureGrouped::duplicate(const CTextureGrouped &src)
+00103 {       
+00104         _NbTex = src._NbTex;
+00105         TTexList texCopy(src._Textures.begin(), src._Textures.end());
+00106         _Textures.swap(texCopy);
+00107         TFourUVList     uvCopy(_TexUVs.begin(), _TexUVs.end());
+00108         _TexUVs.swap(uvCopy);
+00109 }
+00110 
+00112 CTextureGrouped &CTextureGrouped::operator=(const CTextureGrouped &src)
+00113 {
+00114         ITexture::operator=(src); // copy parent part
+00115         duplicate(src);
+00116         return *this;
+00117 }
+00118 
+00120 bool CTextureGrouped::areValid(CSmartPtr<ITexture> *textureTab, uint nbTex)
+00121 {               
+00122         bool result = true;     
+00123         uint k;
+00124         for(k = 0; k < nbTex; ++k)
+00125         {
+00126                 textureTab[k]->generate();              
+00127                 if (textureTab[k]->getWidth() != textureTab[0]->getWidth()
+00128                         || textureTab[k]->getHeight() != textureTab[0]->getHeight()
+00129                         || textureTab[k]->getPixelFormat() != textureTab[0]->getPixelFormat()
+00130                    )
+00131                 { 
+00132                         result = false; 
+00133                         break; 
+00134                 }               
+00135         }
+00136 
+00137 
+00138         for (k = 0; k < nbTex; ++k)
+00139         {
+00140                 if (textureTab[k]->getReleasable()) textureTab[k]->release();
+00141         }
+00142         return result;
+00143 }
+00144 
+00146 void CTextureGrouped::setTextures(CSmartPtr<ITexture> *textureTab, uint nbTex)
+00147 {
+00148         nlassert(nbTex > 0);    
+00149         
+00150         
+00151         if (!areValid(textureTab, nbTex))
+00152         {
+00153                 displayIncompatibleTextureWarning(textureTab, nbTex);           
+00154                 makeDummies(textureTab, nbTex);
+00155         }
+00156         
+00157         
+00158         // Generate the first texture to get the size   
+00159         uint width, height;
+00160         GetTextureSize(textureTab[0], width, height);
+00161 
+00162         const uint totalHeight = height * nbTex;
+00163         const uint realHeight  = totalHeight ? NLMISC::raiseToNextPowerOf2(totalHeight) : 0;    
+00164         
+00165         _TexUVs.clear();
+00166         _Textures.clear();      
+00167         
+00168         const float deltaV = realHeight ? (float(totalHeight) / float(realHeight)) * (1.0f / nbTex)
+00169                                                                         : 0.f;
+00170         _DeltaUV = CUV(1,  deltaV);
+00171         CUV currentUV(0, 0);
+00172         
+00173         _Textures.reserve(nbTex);
+00174         _TexUVs.reserve(nbTex);
+00175 
+00176         for(uint k = 0; k < nbTex; ++k)
+00177         {       
+00178                 TFourUV uvs;
+00179                 _Textures.push_back(textureTab[k]);
+00180 
+00181                 uvs.uv0 = currentUV;
+00182                 uvs.uv1 = currentUV + CUV(1, 0);
+00183                 uvs.uv2 = currentUV + _DeltaUV;
+00184                 uvs.uv3 = currentUV + CUV(0, deltaV);
+00185                 currentUV.V += deltaV;
+00186                 _TexUVs.push_back(uvs);
+00187         }       
+00188         _NbTex = nbTex;
+00189         touch(); // the texture need regeneration
+00190 
+00191         nlassert(_NbTex == _Textures.size());
+00192 }
+00193 
+00195 void CTextureGrouped::doGenerate()
+00196 {
+00197         nlassert(_NbTex == _Textures.size());
+00198         if (_NbTex == 0)
+00199         {
+00200                 makeDummy();
+00201         }
+00202         else
+00203         {                               
+00204                 // Generate the first texture to get the size   
+00205                 _Textures[0]->generate();
+00206                 const uint width = _Textures[0]->getWidth(), height = _Textures[0]->getHeight();                
+00207                 const uint totalHeight = height * _NbTex;
+00208                 const uint realHeight  = NLMISC::raiseToNextPowerOf2(totalHeight);      
+00209 
+00210                 resize(width, realHeight, _Textures[0]->getPixelFormat());
+00211                 
+00212                 uint k;
+00213                 sint32 currY =  0;
+00214                 for(k = 0; k < _NbTex; ++k)
+00215                 {                       
+00216                         _Textures[k]->generate();
+00217                         if (_Textures[k]->getWidth() != width
+00218                                 || _Textures[k]->getHeight() != height
+00219                                 || _Textures[k]->getPixelFormat() != _Textures[0]->getPixelFormat())
+00220                         {
+00221                                 makeDummy();
+00222                                 break;
+00223                         }                                               
+00224                         this->blit(_Textures[k], 0, currY);
+00225                         currY += height;                        
+00226                 }
+00227 
+00228                 for(k = 0; k < _NbTex; ++k)
+00229                 {
+00230                         if ( _Textures[k]->getReleasable())
+00231                         {
+00232                                 _Textures[k]->release();
+00233                         }
+00234                 }
+00235         }       
+00236 }
+00237 
+00239 void CTextureGrouped::getTextures(CSmartPtr<ITexture> *textureTab) const
+00240 {
+00241         CSmartPtr<ITexture> *dest = textureTab;
+00242 
+00243         for(TTexList::const_iterator it = _Textures.begin(); it != _Textures.end(); ++it, ++dest)
+00244         {
+00245                 *dest = *it;
+00246         }
+00247 }
+00248 
+00250 bool    CTextureGrouped::supportSharing() const
+00251 {
+00252         // all textures in this group must support sharing for this one to support it
+00253         for(TTexList::const_iterator it = _Textures.begin(); it != _Textures.end(); ++it)
+00254         {
+00255                 if (!(*it)->supportSharing()) return false;
+00256         }
+00257 
+00258         return true;
+00259 }
+00260 
+00262 std::string             CTextureGrouped::getShareName() const
+00263 {
+00264         nlassert(supportSharing());
+00265 
+00266         std::string shareName("groupedTex:");
+00267         for(TTexList::const_iterator it = _Textures.begin(); it != _Textures.end(); ++it)
+00268         {
+00269                 shareName += (*it)->getShareName() + std::string("|");
+00270         }
+00271         return shareName;
+00272 }
+00273 
+00275 void CTextureGrouped::serial(NLMISC::IStream &f) throw(NLMISC::EStream)
+00276 {
+00277         f.serialVersion(1);
+00278         
+00279         if (f.isReading())
+00280         {
+00281                 TTexList texList;
+00282 
+00284                 uint32 nbTex;
+00285                 f.serial(nbTex);
+00286 
+00288                 ITexture *ptTex = NULL;         
+00289                 texList.reserve(nbTex);
+00290                 for (uint k = 0; k < nbTex; ++k)
+00291                 {
+00292                         f.serialPolyPtr(ptTex);
+00293                         texList.push_back(ptTex);
+00294                 }               
+00295                 
+00296                 // setup the textures
+00297                 setTextures(&texList[0], nbTex);
+00298                 touch();
+00299         }
+00300         else
+00301         {               
+00302                 f.serial(_NbTex);
+00303                 ITexture *ptTex;
+00304                 for (TTexList::iterator it = _Textures.begin(); it != _Textures.end(); ++it)
+00305                 {
+00306                         ptTex = *it;
+00307                         f.serialPolyPtr(ptTex);
+00308                 }               
+00309         }       
+00310 }
+00311 
+00313 void CTextureGrouped::release()
+00314 {
+00315         ITexture::release();
+00316         for(uint k = 0; k < _NbTex; ++k)
+00317         {
+00318                 if ( _Textures[k]->getReleasable())
+00319                 {
+00320                         _Textures[k]->release();
+00321                 }
+00322         }
+00323 }
+00324 
+00326 void CTextureGrouped::makeDummies(CSmartPtr<ITexture> *textureTab,uint nbTex)
+00327 {
+00328         for(uint k = 0; k < nbTex; ++k)
+00329         {
+00330                 textureTab[k] = new CTextureFile("DummyTex"); // well this shouldn't exist..
+00331         }       
+00332 }
+00333 
+00335 void CTextureGrouped::displayIncompatibleTextureWarning(CSmartPtr<ITexture> *textureTab,uint nbTex)
+00336 {
+00337         nlwarning("=======================================================");
+00338         nlwarning("CTextureGrouped : found incompatible textures, that differs by size or format :"     );
+00339         for(uint k = 0; k < nbTex; ++k)
+00340         {
+00341                 if (textureTab[k])
+00342                 {               
+00343                         nlwarning((textureTab[k]->getShareName()).c_str());
+00344                 }
+00345                 else
+00346                 {
+00347                         nlwarning("NULL Texture found");
+00348                 }
+00349         }
+00350         nlwarning("=======================================================");
+00351 }
+00352 
+00353 
+00354 } // NL3D
+
texture_grouped.cpp
