nevrax.org : docs

00001 
00007 /* Copyright, 2000 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/tile_bank.h"
00029 #include "3d/texture_file.h"
00030 #include "3d/tile_noise_map.h"
00031 
00032 #include "nel/misc/stream.h"
00033 #include "nel/misc/common.h"
00034 #include "nel/misc/path.h"
00035 #include "nel/misc/file.h"
00036 #include <string>
00037 
00038 using namespace NLMISC;
00039 using namespace std;
00040 
00041 namespace       NL3D
00042 {
00043 
00044 
00045 // ***************************************************************************
00046 // ***************************************************************************
00047 // TileBankLand.
00048 // ***************************************************************************
00049 // ***************************************************************************
00050 
00051 
00052 // ***************************************************************************
00053 const sint CTileLand::_Version=0;
00054 // ***************************************************************************
00055 void CTileLand::serial(IStream &f) throw(EStream)
00056 {
00057         (void)f.serialVersion(_Version);
00058 
00059         f.serial (_Name);
00060         f.serialCont (_TileSet);
00061 }
00062 // ***************************************************************************
00063 void CTileLand::addTileSet (const std::string& name)
00064 {
00065         _TileSet.insert (name);
00066 }
00067 // ***************************************************************************
00068 void CTileLand::removeTileSet (const std::string& name)
00069 {
00070         _TileSet.erase (name);
00071 }
00072 // ***************************************************************************
00073 void CTileLand::setName (const std::string& name)
00074 { 
00075         _Name=name;
00076 };
00077 // ***************************************************************************
00078 
00079 
00080 // ***************************************************************************
00081 // ***************************************************************************
00082 // CTileBank.
00083 // ***************************************************************************
00084 // ***************************************************************************
00085 
00086 
00087 // ***************************************************************************
00088 const sint CTileBank::_Version=4;
00089 // ***************************************************************************
00090 CTileBank::CTileBank ()
00091 {
00092         // Default _DisplacementMap
00093         _DisplacementMap.resize (1);
00094 
00095         // Fill it with 0
00096         _DisplacementMap[0].setEmpty ();
00097 }
00098 // ***************************************************************************
00099 void    CTileBank::serial(IStream &f) throw(EStream)
00100 {
00101         f.serialCheck (std::string ("BANK"));
00102 
00103         sint streamver = f.serialVersion(_Version);
00104         
00105         // Version 1 not compatible
00106         if (f.isReading())
00107         {
00108                 if (streamver<2)
00109                         throw EOlderStream(f);
00110         }
00111 
00112         switch (streamver)
00113         {
00114         case 4:
00115                 // Displacement map array
00116                 f.serialCont (_DisplacementMap);
00117                 if (f.isReading())
00118                 {
00119                         // Checks
00120                         nlassert (_DisplacementMap.size()>0);
00121 
00122                         // Set first empty
00123                         _DisplacementMap[0].setEmpty ();
00124                 }
00125         case 3:
00126                 // Absolute path
00127                 f.serial (_AbsPath);
00128         case 2:
00129                 // Serial all containers
00130                 f.serialCont (_LandVector);
00131                 f.serialCont (_TileSetVector);
00132                 f.serialCont (_TileVector);
00133         }
00134 
00135         // Compute XRef in read mode
00136         if (f.isReading())
00137                 computeXRef ();
00138 
00139         // If Version<=2, remove diffuse and alpha tiles in transitions
00140         if (streamver<=2)
00141         {
00142                 // Must be reading
00143                 nlassert (f.isReading());
00144 
00145                 // Reset _AbsPath
00146                 _AbsPath="";
00147 
00148                 // Remove diffuse and additive in transition
00149                 uint tileCount=(uint)getTileCount ();
00150                 for (uint i=0; i<tileCount; i++)
00151                 {
00152                         int tileSet;
00153                         int number;
00154                         TTileType type;
00155 
00156                         // Get xref
00157                         getTileXRef (i, tileSet, number, type);
00158 
00159                         // Transition ?
00160                         if (type==transition)
00161                         {
00162                                 // Remove diffuse bitmap
00163                                 getTileSet(tileSet)->clearTransition ((CTileSet::TTransition)number, CTile::diffuse, *this);
00164                                 
00165                                 // Remove alpha bitmap
00166                                 getTileSet(tileSet)->clearTransition ((CTileSet::TTransition)number, CTile::alpha, *this);
00167                         }
00168                 }
00169         }
00170 }
00171 // ***************************************************************************
00172 sint CTileBank::addLand (const std::string& name)
00173 {
00174         sint last=_LandVector.size();
00175         _LandVector.push_back(CTileLand());
00176         _LandVector[last].setName (name);
00177         return last;
00178 }
00179 // ***************************************************************************
00180 void CTileBank::removeLand (sint landIndex)
00181 {
00182         // Check args
00183         nlassert (landIndex>=0);
00184         nlassert (landIndex<(sint)_LandVector.size());
00185 
00186         _LandVector.erase (_LandVector.begin ()+landIndex);
00187 }
00188 // ***************************************************************************
00189 sint CTileBank::addTileSet (const std::string& name)
00190 {
00191         sint last=_TileSetVector.size();
00192         _TileSetVector.push_back(CTileSet());
00193         _TileSetVector[last].setName (name);
00194         for (int i=0; i<CTileSet::count; i++)
00195         {
00196                 _TileSetVector[last]._TileTransition[i]._Tile=createTile ();
00197         }
00198         return last;
00199 }
00200 // ***************************************************************************
00201 void CTileBank::removeTileSet (sint setIndex)
00202 {
00203         // Check args
00204         nlassert (setIndex>=0);
00205         nlassert (setIndex<(sint)_TileSetVector.size());
00206 
00207         for (int i=0; i<CTileSet::count; i++)
00208         {
00209                 int index=_TileSetVector[setIndex]._TileTransition[i]._Tile;
00210                 if (index!=-1)
00211                         freeTile (index);
00212         }
00213         _TileSetVector.erase (_TileSetVector.begin ()+setIndex);
00214 }
00215 // ***************************************************************************
00216 void CTileBank::clear ()
00217 {
00218         _LandVector.clear ();
00219         _TileSetVector.clear ();
00220         _TileVector.clear ();
00221 }
00222 // ***************************************************************************
00223 sint CTileBank::createTile ()
00224 {
00225         // Look for a free tile
00226         for (int i=0; i<(sint)_TileVector.size(); i++)
00227         {
00228                 if (_TileVector[i].isFree())
00229                 {
00230                         _TileVector[i].setFileName (CTile::diffuse, "");
00231                         _TileVector[i].setFileName (CTile::additive, "");
00232                         _TileVector[i].setFileName (CTile::alpha, "");
00233                         return i;
00234                 }
00235         }
00236 
00237         // Nothing free, add a tile at the end
00238         _TileVector.push_back (CTile());
00239         _TileVector[_TileVector.size()-1].setFileName (CTile::diffuse, "");
00240         _TileVector[_TileVector.size()-1].setFileName (CTile::additive, "");
00241         _TileVector[_TileVector.size()-1].setFileName (CTile::alpha, "");
00242         return _TileVector.size()-1;
00243 }
00244 // ***************************************************************************
00245 void CTileBank::freeTile (int tileIndex)
00246 {
00247         // Check args
00248         nlassert (tileIndex>=0);
00249         nlassert (tileIndex<(sint)_TileVector.size());
00250 
00251         // Free
00252         _TileVector[tileIndex].free();
00253 
00254         // Resize tile table
00255         int i;
00256         for (i=(sint)_TileVector.size()-1; i>=0; i--)
00257         {
00258                 if (!_TileVector[i].isFree ())
00259                         break;
00260         }
00261         if (i<(sint)_TileVector.size()-1)
00262                 _TileVector.resize (i+1);
00263 }
00264 // ***************************************************************************
00265 sint CTileBank::getNumBitmap (CTile::TBitmap bitmap) const
00266 {
00267         std::set<std::string> setString;
00268         for (int i=0; i<(sint)_TileVector.size(); i++)
00269         {
00270                 if (!_TileVector[i].isFree())
00271                 {
00272                         const std::string &str=_TileVector[i].getRelativeFileName (bitmap);
00273                         if (str!="")
00274                         {
00275                                 std::vector<char> vect (str.length()+1);
00276                                 memcpy (&*vect.begin(), str.c_str(), str.length()+1);
00277                                 NLMISC::strlwr (&*vect.begin());
00278                                 setString.insert (std::string (&*vect.begin()));
00279                         }
00280                 }
00281         }
00282         return setString.size();
00283 }
00284 // ***************************************************************************
00285 void CTileBank::computeXRef ()
00286 {
00287         // Resize
00288         _TileXRef.resize (_TileVector.size());
00289 
00290         // Erase number of the tileset in xref
00291         for (int tile=0; tile<(sint)_TileVector.size(); tile++)
00292                 _TileXRef[tile]._XRefTileSet=-1;
00293 
00294         // Erase number of the tileset in xref
00295         for (int s=0; s<(sint)_TileSetVector.size(); s++)
00296         {
00297                 int t;
00298                 CTileSet *tileSet=getTileSet (s);
00299                 for (t=0; t<tileSet->getNumTile128(); t++)
00300                 {
00301                         int index=tileSet->getTile128 (t);
00302                         _TileXRef[index]._XRefTileSet=s;
00303                         _TileXRef[index]._XRefTileNumber=t;
00304                         _TileXRef[index]._XRefTileType=_128x128;
00305                 }
00306                 for (t=0; t<tileSet->getNumTile256(); t++)
00307                 {
00308                         int index=tileSet->getTile256 (t);
00309                         _TileXRef[index]._XRefTileSet=s;
00310                         _TileXRef[index]._XRefTileNumber=t;
00311                         _TileXRef[index]._XRefTileType=_256x256;
00312                 }
00313                 for (t=0; t<CTileSet::count; t++)
00314                 {
00315                         int index=tileSet->getTransition (t)->getTile();
00316                         _TileXRef[index]._XRefTileSet=s;
00317                         _TileXRef[index]._XRefTileNumber=t;
00318                         _TileXRef[index]._XRefTileType=transition;
00319                 }
00320         }
00321 }
00322 // ***************************************************************************
00323 void CTileBank::xchgTileset (sint firstTileSet, sint secondTileSet)
00324 {
00325         // Some check
00326         nlassert ((firstTileSet>=0)&&(firstTileSet<(sint)_TileSetVector.size()));
00327         nlassert ((secondTileSet>=0)&&(secondTileSet<(sint)_TileSetVector.size()));
00328 
00329         // Xchange the sets
00330         CTileSet tmp=_TileSetVector[firstTileSet];
00331         _TileSetVector[firstTileSet]=_TileSetVector[secondTileSet];
00332         _TileSetVector[secondTileSet]=tmp;
00333 }
00334 // ***************************************************************************
00335 void TroncFileName (char* sDest, const char* sSrc)
00336 {
00337         char* ptr=strrchr (sSrc, '\\');
00338         if (ptr==NULL)
00339                 ptr=strrchr (sSrc, '/');
00340         if (ptr)
00341         {
00342                 ptr++;
00343                 strcpy (sDest, ptr);
00344         }
00345         else
00346         {
00347                 strcpy (sDest, sSrc);
00348         }
00349 }
00350 // ***************************************************************************
00351 // Je parie que ce patch reste jusqu'� la fin du jeu. (Hulud)
00352 void CTileBank::makeAllPathRelative ()
00353 {
00354         // For all tiles
00355         for (sint nTile=0; nTile<(sint)_TileVector.size(); nTile++)
00356         {
00357                 // Tronc filename
00358                 char sTmpFileName[512];
00359 
00360                 // Diffuse
00361                 TroncFileName (sTmpFileName, _TileVector[nTile].getRelativeFileName (CTile::diffuse).c_str());
00362                 _TileVector[nTile].setFileName (CTile::diffuse, sTmpFileName);
00363 
00364                 // Additive
00365                 TroncFileName (sTmpFileName, _TileVector[nTile].getRelativeFileName (CTile::additive).c_str());
00366                 _TileVector[nTile].setFileName (CTile::additive, sTmpFileName);
00367 
00368                 // Alpha
00369                 TroncFileName (sTmpFileName, _TileVector[nTile].getRelativeFileName (CTile::alpha).c_str());
00370                 _TileVector[nTile].setFileName (CTile::alpha, sTmpFileName);
00371         }
00372 
00373         // For all displaces
00374         for (uint i=0; i<_DisplacementMap.size(); i++)
00375         {
00376                 // Tronc filename
00377                 char sTmpFileName[512];
00378 
00379                 TroncFileName (sTmpFileName, _DisplacementMap[i]._FileName.c_str());
00380                 _DisplacementMap[i]._FileName = sTmpFileName;
00381         }
00382 }
00383 
00384 
00385 // ***************************************************************************
00386 // Moi aussi je le parie (Yoyo).
00387 void CTileBank::makeAllExtensionDDS ()
00388 {
00389         // For all tiles
00390         for (sint nTile=0; nTile<(sint)_TileVector.size(); nTile++)
00391         {
00392                 string          tmp;
00393                 uint32          pos;
00394 
00395                 // Diffuse
00396                 tmp= _TileVector[nTile].getRelativeFileName (CTile::diffuse);
00397                 pos= tmp.rfind(".tga");
00398                 if(pos!= string::npos)
00399                 {
00400                         tmp.replace(pos, 4, ".dds");
00401                         _TileVector[nTile].setFileName (CTile::diffuse, tmp);
00402                 }
00403 
00404                 // Additive.
00405                 tmp= _TileVector[nTile].getRelativeFileName (CTile::additive);
00406                 pos= tmp.rfind(".tga");
00407                 if(pos!= string::npos)
00408                 {
00409                         tmp.replace(pos, 4, ".dds");
00410                         _TileVector[nTile].setFileName (CTile::additive, tmp);
00411                 }
00412 
00413                 // Alpha.
00414                 tmp= _TileVector[nTile].getRelativeFileName (CTile::alpha);
00415                 pos= tmp.rfind(".tga");
00416                 if(pos!= string::npos)
00417                 {
00418                         tmp.replace(pos, 4, ".dds");
00419                         _TileVector[nTile].setFileName (CTile::alpha, tmp);
00420                 }
00421 
00422         }
00423 
00424 }
00425 // ***************************************************************************
00426 void CTileBank::cleanUnusedData ()
00427 {
00428         // Clean each tileset
00429         for (uint i=0; i<_TileSetVector.size(); i++)
00430         {
00431                 // Clean the tileset
00432                 _TileSetVector[i].cleanUnusedData ();
00433         }
00434 
00435         // Clear the land vector
00436         _LandVector.clear();
00437 }
00438 // ***************************************************************************
00439 CTileNoiseMap *CTileBank::getTileNoiseMap (uint tileNumber, uint tileSubNoise)
00440 {
00441         // Check tile number..
00442         if (tileNumber<_TileVector.size())
00443         {
00444                 // Get tileset number
00445                 uint tileSet=_TileXRef[tileNumber]._XRefTileSet;
00446 
00447                 // Checks
00448                 if (tileSet<_TileSetVector.size())
00449                 {
00450                         nlassert (tileSubNoise<CTileSet::CountDisplace);
00451                         nlassert (_TileSetVector[tileSet]._DisplacementBitmap[tileSubNoise]<_DisplacementMap.size());
00452 
00453                         // Return the tile noise map
00454                         CTileNoise &tileNoise=_DisplacementMap[_TileSetVector[tileSet]._DisplacementBitmap[tileSubNoise]];
00455 
00456                         // Not loaded ?
00457                         if (tileNoise._TileNoiseMap==NULL)
00458                         {
00459                                 // Load a bitmap
00460                                 CTextureFile texture (getAbsPath()+tileNoise._FileName);
00461                                 texture.loadGrayscaleAsAlpha (false);
00462                                 texture.generate ();
00463                                 texture.convertToType (CBitmap::Luminance);
00464 
00465                                 // Alloc
00466                                 tileNoise._TileNoiseMap=new CTileNoiseMap;
00467 
00468                                 // Good size ?
00469                                 if ((texture.getWidth ()==NL3D_TILE_NOISE_MAP_SIZE)&&(texture.getHeight()==NL3D_TILE_NOISE_MAP_SIZE))
00470                                 {
00471                                         // Copy
00472                                         memcpy (tileNoise._TileNoiseMap->Pixels, &texture.getPixels()[0], NL3D_TILE_NOISE_MAP_SIZE*NL3D_TILE_NOISE_MAP_SIZE);
00473 
00474                                         // Remap lumels
00475                                         for (uint i=0; i<NL3D_TILE_NOISE_MAP_SIZE*NL3D_TILE_NOISE_MAP_SIZE; i++)
00476                                         {
00477                                                 tileNoise._TileNoiseMap->Pixels[i]=(sint8)((uint8)tileNoise._TileNoiseMap->Pixels[i]-128);
00478                                                 if (tileNoise._TileNoiseMap->Pixels[i]==-128)
00479                                                         tileNoise._TileNoiseMap->Pixels[i]=-127;
00480                                         }
00481                                 }
00482                                 else
00483                                 {
00484                                         // This is not a normal behaviour.
00485                                         string  pathname= getAbsPath()+tileNoise._FileName;
00486                                         if( texture.getWidth ()==0 || texture.getHeight ()==0 )
00487                                                 nlwarning("TileNoiseMap not found: %s.", pathname.c_str());
00488                                         else
00489                                                 nlwarning("Bad TileNoiseMap size: %s.", pathname.c_str());
00490 
00491                                         // Not good size, copy a static map
00492                                         sint8 notGoodSizeForm[NL3D_TILE_NOISE_MAP_SIZE*NL3D_TILE_NOISE_MAP_SIZE]=
00493                                         {
00494                                                 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00,
00495                                                 00, 99, 99, 99, 99, 99, 99, 99, 99, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00,
00496                                                 00, 99, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00,
00497                                                 00, 99, 00, 99, 99, 99, 99, 99, 99, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00,
00498                                                 00, 99, 00, 99, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00,
00499                                                 00, 99, 00, 99, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00,
00500                                                 00, 99, 00, 99, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00,
00501                                                 00, 99, 00, 99, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00,
00502                                                 00, 99, 00, 99, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00,
00503                                                 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00,
00504                                                 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00,
00505                                                 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00,
00506                                                 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00,
00507                                                 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00,
00508                                                 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00,
00509                                                 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00,
00510                                                 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00,
00511                                                 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00,
00512                                                 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00,
00513                                                 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00,
00514                                                 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00,
00515                                                 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00,
00516                                                 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00,
00517                                                 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 99, 00, 99, 00,
00518                                                 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 99, 00, 99, 00,
00519                                                 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 99, 00, 99, 00,
00520                                                 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 99, 00, 99, 00,
00521                                                 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 99, 00, 99, 00,
00522                                                 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 99, 99, 99, 99, 99, 99, 00, 99, 00,
00523                                                 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 99, 00,
00524                                                 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 99, 99, 99, 99, 99, 99, 99, 99, 00,
00525                                                 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00
00526                                         };
00527 
00528                                         // Copy
00529                                         memcpy (tileNoise._TileNoiseMap->Pixels, notGoodSizeForm, NL3D_TILE_NOISE_MAP_SIZE*NL3D_TILE_NOISE_MAP_SIZE);
00530                                 }
00531                         }
00532 
00533                         // Return the noise map
00534                         return tileNoise._TileNoiseMap;
00535                 }
00536         }
00537 
00538         // Checks
00539         nlassert (_DisplacementMap[0]._TileNoiseMap);
00540         return _DisplacementMap[0]._TileNoiseMap;
00541 }
00542 // ***************************************************************************
00543 void CTileBank::removeDisplacementMap (uint mapId)
00544 {
00545         // Checks
00546         nlassert (mapId<_DisplacementMap.size());
00547 
00548         if (mapId!=0)
00549         {
00550                 // Check if another tileSet uses it
00551                 uint tileSet;
00552                 for (tileSet=0; tileSet<_TileSetVector.size(); tileSet++)
00553                 {
00554                         // It uses it ?
00555                         uint tile;
00556                         for (tile=0; tile<CTileSet::CountDisplace; tile++)
00557                         {
00558                                 // The same ?
00559                                 if (_TileSetVector[tileSet]._DisplacementBitmap[tile]==mapId)
00560                                         // Stop
00561                                         break;
00562                         }
00563                         if (tile!=CTileSet::CountDisplace)
00564                                 break;
00565                 }
00566                 if (tileSet==_TileSetVector.size())
00567                 {
00568                         // Remove it
00569                         _DisplacementMap[mapId].reset();
00570                         
00571                         // Last element ?
00572                         if (mapId==_DisplacementMap.size()-1)
00573                         {
00574                                 // Resize the array ?
00575                                 while ((mapId>0)&&(_DisplacementMap[mapId]._FileName==""))
00576                                         _DisplacementMap.resize (mapId--);
00577                         }
00578                 }
00579         }
00580 }
00581 // ***************************************************************************
00582 uint CTileBank::getDisplacementMap (const string &fileName)
00583 {
00584         // Lower string
00585         string lower=fileName;
00586         lower=strlwr (lower);
00587 
00588         // Look for this texture filename
00589         uint noiseTile;
00590         for (noiseTile=0; noiseTile<_DisplacementMap.size(); noiseTile++)
00591         {
00592                 // Same name ?
00593                 if (lower==_DisplacementMap[noiseTile]._FileName)
00594                         return noiseTile;
00595         }
00596 
00597         // Look for a free space
00598         for (noiseTile=0; noiseTile<_DisplacementMap.size(); noiseTile++)
00599         {
00600                 // Same name ?
00601                 if (_DisplacementMap[noiseTile]._FileName=="")
00602                         break;
00603         }
00604         if (noiseTile==_DisplacementMap.size())
00605         {
00606                 // Add a tile
00607                 _DisplacementMap.resize (noiseTile+1);
00608         }
00609 
00610         // Set the file name
00611         _DisplacementMap[noiseTile]._FileName=lower;
00612 
00613         return noiseTile;
00614 }
00615 // ***************************************************************************
00616 const char* CTileBank::getDisplacementMap (uint noiseMap)
00617 {
00618         return _DisplacementMap[noiseMap]._FileName.c_str();
00619 }
00620 // ***************************************************************************
00621 void CTileBank::setDisplacementMap (uint noiseMap, const char *newName)
00622 {
00623         _DisplacementMap[noiseMap]._FileName=newName;
00624 }
00625 // ***************************************************************************
00626 uint CTileBank::getDisplacementMapCount () const
00627 {
00628         return _DisplacementMap.size();
00629 }
00630 
00631 
00632 // ***************************************************************************
00633 const CTileVegetableDesc        &CTileBank::getTileVegetableDesc(uint tileNumber) const
00634 {
00635         // Check tile number..
00636         if (tileNumber<_TileVector.size())
00637         {
00638                 // Get tileset number
00639                 uint tileSet=_TileXRef[tileNumber]._XRefTileSet;
00640 
00641                 // Checks
00642                 if (tileSet<_TileSetVector.size())
00643                 {
00644                         return _TileSetVector[tileSet].getTileVegetableDesc();
00645                 }
00646 
00647         }
00648 
00649         // if fails for any reason, return an empty tileVegetableDesc;
00650         static  CTileVegetableDesc      emptyTvd;
00651         return emptyTvd;
00652 }
00653 
00654 
00655 // ***************************************************************************
00656 void CTileBank::loadTileVegetableDescs()
00657 {
00658         // For all tileSets.
00659         uint tileSet;
00660         
00661         for(tileSet=0; tileSet<_TileSetVector.size(); tileSet++)
00662         {
00663                 // load their fileName
00664                 _TileSetVector[tileSet].loadTileVegetableDesc();
00665         }
00666 }
00667 
00668 
00669 // ***************************************************************************
00670 void    CTileBank::initTileVegetableDescs(CVegetableManager *vegetableManager)
00671 {
00672         // For all tileSets.
00673         uint tileSet;
00674         
00675         for(tileSet=0; tileSet<_TileSetVector.size(); tileSet++)
00676         {
00677                 CTileVegetableDesc      &tvd= _TileSetVector[tileSet].getTileVegetableDesc();
00678                 tvd.registerToManager(vegetableManager);
00679         }
00680 }
00681 
00682 
00683 // ***************************************************************************
00684 // ***************************************************************************
00685 // CTile.
00686 // ***************************************************************************
00687 // ***************************************************************************
00688 
00689 
00690 // ***************************************************************************
00691 const sint CTile::_Version=4;
00692 // ***************************************************************************
00693 void CTile::serial(IStream &f) throw(EStream)
00694 {
00695         sint streamver = f.serialVersion(_Version);
00696 
00697         // Tmp value
00698         bool tmp;
00699         string tmpStr;
00700 
00701         switch (streamver)
00702         {
00703         case 4:
00704         case 3:
00705         case 2:
00706                 f.serial (_Flags);
00707 
00708                 // Version 2, flags are not the same
00709                 if (streamver==2)
00710                         _Flags=(_Flags&NL3D_CTILE_ROT_MASK)|(_Flags&NL3D_CTILE_GROUP_MASK_V2)|(((_Flags&NL3D_CTILE_FREE_FLAG_V2)!=0)?NL3D_CTILE_FREE_FLAG:0);
00711                 if (streamver==3)
00712                         _Flags=(_Flags&NL3D_CTILE_ROT_MASK)|(_Flags&NL3D_CTILE_GROUP_MASK_V3)|(((_Flags&NL3D_CTILE_FREE_FLAG_V3)!=0)?NL3D_CTILE_FREE_FLAG:0);
00713 
00714                 f.serial (_BitmapName[diffuse]);
00715                 f.serial (_BitmapName[additive]);
00716                 f.serial (_BitmapName[alpha]);
00717                 break;
00718         case 1:
00719                 // Don't need invert many more
00720                 f.serial (tmp);
00721         case 0:
00722                 // Initialize flags
00723                 _Flags=0;
00724                 
00725                 // Initialize alpha name
00726                 _BitmapName[alpha]="";
00727                 
00728                 // Read free flag
00729                 f.serial (tmp);
00730 
00731                 // If free, set the flag
00732                 if (tmp)
00733                         _Flags|=NL3D_CTILE_FREE_FLAG;
00734 
00735                 // Read diffuse bitmap and additive
00736                 f.serial (_BitmapName[diffuse]);
00737                 f.serial (_BitmapName[additive]);
00738 
00739                 // Don't need bump name
00740                 f.serial (tmpStr);
00741 
00742                 break;
00743         }
00744 }
00745 // ***************************************************************************
00746 void CTile::clearTile (CTile::TBitmap type)
00747 {
00748         _BitmapName[type]="";
00749 }
00750 
00751 
00752 // ***************************************************************************
00753 // ***************************************************************************
00754 // CTileSet.
00755 // ***************************************************************************
00756 // ***************************************************************************
00757 
00758 
00759 // ***************************************************************************
00760 const sint CTileSet::_Version=5;
00761 // ***************************************************************************
00762 const char* CTileSet::_ErrorMessage[CTileSet::errorCount]=
00763 {
00764         "No error.",                                                            // ok
00765         "Top interface is incompatible.",                       // topInterfaceProblem
00766         "Bottom interface is incompatible.",            // bottomInterfaceProblem
00767         "Left interface is incompatible.",                      // leftInterfaceProblem
00768         "Right interface is incompatible.",                     // rightInterfaceProblem
00769         "Add first a 128x128 tile.",                            // addFirstA128128
00770         "Top and bottom interface not the same.",       // topBottomNotTheSame, 
00771         "Right and left interface not the same.",       // rightLeftNotTheSame
00772         "Invalide bitmap size.",                                        // sizeInvalide
00773 };
00774 // ***************************************************************************
00775 const CTileSet::TFlagBorder CTileSet::_TransitionFlags[CTileSet::count][4]=
00776 {
00777         {_0000,_1111,_0111,_0111},      // tile 0
00778         {_0111,_1111,_0111,_1111},      // tile 1
00779         {_0000,_0111,_0000,_0111},      // tile 2
00780         {_1110,_1110,_1111,_0000},      // tile 3
00781         {_1110,_1111,_1111,_0111},      // tile 4
00782         {_0000,_1110,_0111,_0000},      // tile 5
00783 
00784         {_0000,_1111,_0001,_0001},      // tile 6
00785         {_0000,_1000,_0001,_0000},      // tile 7
00786         {_1111,_1000,_1111,_1000},      // tile 8
00787         {_1000,_1000,_1111,_0000},      // tile 9
00788         {_1000,_0000,_1000,_0000},      // tile 10
00789         {_1111,_0001,_1000,_1111},      // tile 11
00790 
00791         {_0000,_1111,_0111,_0001},      // tile 12
00792         {_0000,_1111,_0001,_0111},      // tile 13
00793         {_0111,_1111,_0001,_1111},      // tile 14
00794         {_1110,_1000,_1111,_0000},      // tile 15
00795         {_1000,_1110,_1111,_0000},      // tile 16
00796         {_1111,_0001,_1110,_1111},      // tile 17
00797 
00798         {_1000,_0000,_1110,_0000},      // tile 18
00799         {_0000,_0111,_0000,_0001},      // tile 19
00800         {_1111,_1000,_1111,_1110},      // tile 21
00801         {_0111,_0000,_0000,_1000},      // tile 21
00802         {_0000,_1000,_0111,_0000},      // tile 22
00803         {_1111,_0111,_1000,_1111},      // tile 23
00804 
00805         {_1111,_0000,_1110,_1110},      // tile 24
00806         {_1111,_1110,_1111,_1110},      // tile 25
00807         {_1110,_0000,_1110,_0000},      // tile 26
00808         {_0111,_0111,_0000,_1111},      // tile 27
00809         {_1111,_0111,_1110,_1111},      // tile 28
00810         {_0111,_0000,_0000,_1110},      // tile 29
00811 
00812         {_1111,_0000,_1000,_1000},      // tile 30
00813         {_0001,_0000,_0000,_1000},      // tile 31
00814         {_0001,_1111,_0001,_1111},      // tile 32
00815         {_0001,_0001,_0000,_1111},      // tile 33
00816         {_0000,_0001,_0000,_0001},      // tile 34
00817         {_1000,_1111,_1111,_0001},      // tile 35
00818 
00819         {_1111,_0000,_1000,_1110},      // tile 36
00820         {_1111,_0000,_1110,_1000},      // tile 37
00821         {_1000,_1111,_1111,_0111},      // tile 38
00822         {_0001,_0111,_0000,_1111},      // tile 39
00823         {_0111,_0001,_0000,_1111},      // tile 40
00824         {_1111,_1110,_1111,_1000},      // tile 41
00825 
00826         {_0000,_0001,_0000,_0111},      // tile 42
00827         {_1110,_0000,_1000,_0000},      // tile 43
00828         {_0001,_1111,_0111,_1111},      // tile 44
00829         {_0000,_1110,_0001,_0000},      // tile 45
00830         {_0001,_0000,_0000,_1110},      // tile 46
00831         {_1110,_1111,_1111,_0001}       // tile 47
00832 };
00833 // ***************************************************************************
00834 CTileSet::CTileSet ()
00835 {
00836         // Default, tileset 0
00837         _Oriented = false;
00838         uint displace;
00839         for (displace=FirstDisplace; displace<CountDisplace; displace++)
00840                 _DisplacementBitmap[displace]=0;
00841 
00842         // Default user surface data
00843         SurfaceData = 0;
00844 }
00845 // ***************************************************************************
00846 void CTileSet::setName (const std::string& name)
00847 {
00848         _Name=name;
00849 }
00850 // ***************************************************************************
00851 const std::string& CTileSet::getName () const
00852 {
00853         return _Name;
00854 }
00855 // ***************************************************************************
00856 void CTileSet::serial(IStream &f) throw(EStream)
00857 {
00858         sint streamver = f.serialVersion(_Version);
00859 
00860         CTileBorder tmp;
00861 
00862         // serial the user surface data
00863         if (streamver>=5)
00864         {
00865                 f.serial (SurfaceData);
00866         }
00867 
00868         // serial the oriented info which tell if the tile has a special orientation
00869         if (streamver>=4)
00870         {
00871                 f.serial (_Oriented);
00872         }
00873 
00874         // serial vegetable info.
00875         if (streamver>=3)
00876         {
00877                 // serialisze only the FileName, not the descrpitor
00878                 f.serial(_TileVegetableDescFileName);
00879         }
00880 
00881         // New version
00882         if (streamver>=2)
00883         {
00884                 uint displace;
00885                 for (displace=FirstDisplace; displace<CountDisplace; displace++)
00886                         f.serial (_DisplacementBitmap[displace]);
00887         }
00888 
00889         // Serial displacement map filename, obsolete
00890         if (streamver==1)
00891         {
00892                 // Remove obsolete data
00893                 string tmp;
00894                 for (uint displace=FirstDisplace; displace<CountDisplace; displace++)
00895                         f.serial (tmp);
00896         }
00897 
00898         int i;
00899         f.serial (_Name);
00900         f.serialCont (_Tile128);
00901         f.serialCont (_Tile256);
00902         for (i=0; i<count; i++)
00903                 f.serial (_TileTransition[i]);
00904         f.serialCont (_ChildName);
00905         f.serial (_Border128[CTile::diffuse]);
00906         f.serial (_Border128[CTile::additive]);
00907 
00908         // old field, border bump 128
00909         if (streamver==0)
00910                 f.serial (tmp);
00911 
00912         f.serial (_Border256[CTile::diffuse]);
00913         f.serial (_Border256[CTile::additive]);
00914 
00915         // old field, border bump 256
00916         if (streamver==0)
00917                 f.serial (tmp);
00918 
00919         for (i=0; i<count; i++)
00920         {
00921                 f.serial (_BorderTransition[i][CTile::diffuse]);
00922                 f.serial (_BorderTransition[i][CTile::additive]);
00923                 f.serial (_BorderTransition[i][CTile::alpha]);
00924 
00925                 // Reset the diffuse and alpha border if old version
00926                 if (streamver==0)
00927                 {
00928                         _BorderTransition[i][CTile::diffuse].reset();
00929                         _BorderTransition[i][CTile::alpha].reset();
00930                 }
00931         }
00932 }
00933 // ***************************************************************************
00934 void CTileSet::addTile128 (int& indexInTileSet, CTileBank& bank)
00935 {
00936         // Create a tile
00937         sint index=bank.createTile ();
00938 
00939         // Index of the new tile
00940         indexInTileSet=_Tile128.size();
00941 
00942         // Add to the end of the list
00943         _Tile128.push_back (index);
00944 }
00945 // ***************************************************************************
00946 void CTileSet::setBorder (CTile::TBitmap type, const CTileBorder& border)
00947 {
00948         // This is our new border desc
00949         _Border128[type]=border;
00950         _Border256[type]=border;
00951         _Border256[type].doubleSize ();
00952 }
00953 // ***************************************************************************
00954 void CTileSet::setTile128 (int indexInTileSet, const std::string& name, CTile::TBitmap type, CTileBank& bank)
00955 {
00956         // Edit a tile
00957         CTile *tile=bank.getTile (_Tile128[indexInTileSet]);
00958         tile->setFileName (type, name);
00959         tile->setRotAlpha (0);
00960 }
00961 // ***************************************************************************
00962 CTileSet::TError CTileSet::checkTile128 (CTile::TBitmap type, const CTileBorder& border, int& pixel, int& composante)
00963 {
00964         // Self check
00965         if ((border.getWidth()!=128)||(border.getHeight()!=128))
00966                 return sizeInvalide;
00967         if (!CTileBorder::compare (border, border, CTileBorder::top, CTileBorder::bottom, pixel, composante))
00968                 return topBottomNotTheSame;
00969         if (!CTileBorder::compare (border, border, CTileBorder::left, CTileBorder::right, pixel, composante))
00970                 return rightLeftNotTheSame;
00971 
00972         // Check
00973         if (_Border128[type].isSet())
00974         {
00975                 // Other check
00976                 if (!CTileBorder::compare (border, _Border128[type], CTileBorder::top, CTileBorder::top, pixel, composante))
00977                         return topInterfaceProblem;
00978                 if (!CTileBorder::compare (border, _Border128[type], CTileBorder::bottom, CTileBorder::bottom, pixel, composante))
00979                         return bottomInterfaceProblem;
00980                 if (!CTileBorder::compare (border, _Border128[type], CTileBorder::left, CTileBorder::left, pixel, composante))
00981                         return leftInterfaceProblem;
00982                 if (!CTileBorder::compare (border, _Border128[type], CTileBorder::right, CTileBorder::right, pixel, composante))
00983                         return rightInterfaceProblem;
00984         }
00985         else
00986         {               
00987                 return addFirstA128128;
00988         }
00989 
00990         return ok;
00991 }
00992 // ***************************************************************************
00993 void CTileSet::addTile256 (int& indexInTileSet, CTileBank& bank)
00994 {
00995         // Create a tile
00996         sint index=bank.createTile ();
00997 
00998         // Index of the new tile
00999         indexInTileSet=_Tile256.size();
01000 
01001         // Add to the end of the list
01002         _Tile256.push_back (index);
01003 }
01004 // ***************************************************************************
01005 CTileSet::TError CTileSet::checkTile256 (CTile::TBitmap type, const CTileBorder& border, int& pixel, int& composante)
01006 {
01007         // Self check
01008         if ((border.getWidth()!=256)||(border.getHeight()!=256))
01009                 return sizeInvalide;
01010         if (!CTileBorder::compare (border, border, CTileBorder::top, CTileBorder::bottom, pixel, composante))
01011                 return topBottomNotTheSame;
01012         if (!CTileBorder::compare (border, border, CTileBorder::left, CTileBorder::right, pixel, composante))
01013                 return rightLeftNotTheSame;
01014         
01015         // Check if prb
01016         if ((!_Border256[type].isSet())&&(_Border128[type].isSet()))
01017         {
01018                 _Border256[type]=_Border128[type];
01019                 _Border256[type].doubleSize ();
01020         }
01021 
01022         // Check
01023         if (_Border256[type].isSet())
01024         {
01025 
01026                 // Other check
01027                 if (!CTileBorder::compare (border, _Border256[type], CTileBorder::top, CTileBorder::top, pixel, composante))
01028                         return topInterfaceProblem;
01029                 if (!CTileBorder::compare (border, _Border256[type], CTileBorder::bottom, CTileBorder::bottom, pixel, composante))
01030                         return bottomInterfaceProblem;
01031                 if (!CTileBorder::compare (border, _Border256[type], CTileBorder::left, CTileBorder::left, pixel, composante))
01032                         return leftInterfaceProblem;
01033                 if (!CTileBorder::compare (border, _Border256[type], CTileBorder::right, CTileBorder::right, pixel, composante))
01034                         return rightInterfaceProblem;
01035         }
01036         else
01037         {
01038                 return addFirstA128128;
01039         }
01040 
01041         return ok;
01042 }
01043 // ***************************************************************************
01044 void CTileSet::setTile256 (int indexInTileSet, const std::string& name, CTile::TBitmap type, CTileBank& bank)
01045 {
01046         // Edit a tile
01047         CTile *tile=bank.getTile (_Tile256[indexInTileSet]);
01048         tile->setFileName (type, name);
01049         tile->setRotAlpha (0);
01050 }
01051 // ***************************************************************************
01052 void CTileSet::setTileTransition (TTransition transition, const std::string& name, CTile::TBitmap type, CTileBank& bank, 
01053                                                                                           const CTileBorder& border)
01054 {
01055         // Check is not an alpha channel
01056         nlassert (type!=CTile::alpha);          // use setTileTransitionAlpha
01057 
01058         // Create a tile
01059         _BorderTransition[transition][type]=border;
01060 
01061         // Set the tile file name
01062         CTile *tile=bank.getTile (_TileTransition[transition]._Tile);
01063         tile->setFileName (type, name);
01064 }
01065 // ***************************************************************************
01066 void CTileSet::setTileTransitionAlpha (TTransition transition, const std::string& name, CTileBank& bank, 
01067                                                                            const CTileBorder& border, uint8 rot)
01068 {
01069         // Check some args
01070         nlassert (rot<4);
01071 
01072         // Create a tile
01073         _BorderTransition[transition][CTile::alpha]=border;
01074 
01075         // Set the tile file name
01076         CTile *tile=bank.getTile (_TileTransition[transition]._Tile);
01077         tile->setFileName (CTile::alpha, name);
01078         tile->setRotAlpha (rot);
01079 }
01080 // ***************************************************************************
01081 CTileSet::TError CTileSet::checkTileTransition (TTransition transition, CTile::TBitmap type, const CTileBorder& border, int& indexError,
01082                 int& pixel, int& composante)
01083 {
01084         nlassert (transition>=0);
01085         nlassert (transition<count);
01086 
01087         // Check
01088         indexError=-1;
01089 
01090         // Top
01091         indexError=getExistingTransitionTile ((TFlagBorder)_TransitionFlags[transition][top], dontcare, dontcare, dontcare, transition, type);
01092         if (indexError!=-1)
01093         {
01094                 if (!CTileBorder::compare (border, _BorderTransition[indexError][type], CTileBorder::top, CTileBorder::top, pixel, composante))
01095                         return topInterfaceProblem;
01096         }
01097         indexError=getExistingTransitionTile (dontcare, (TFlagBorder)_TransitionFlags[transition][top], dontcare, dontcare, transition, type);
01098         if (indexError!=-1)
01099         {
01100                 if (!CTileBorder::compare (border, _BorderTransition[indexError][type], CTileBorder::top, CTileBorder::bottom, pixel, composante))
01101                         return topInterfaceProblem;
01102         }
01103         indexError=-1;
01104         if (_TransitionFlags[transition][top]==_1111)
01105         {
01106                 if (!CTileBorder::allAlphaSet (border, CTileBorder::top, pixel, composante))
01107                         return topInterfaceProblem;
01108         }
01109 
01110         // Bottom
01111         indexError=getExistingTransitionTile (dontcare, (TFlagBorder)_TransitionFlags[transition][bottom], dontcare, dontcare, transition, type);
01112         if (indexError!=-1)
01113         {
01114                 if (!CTileBorder::compare (border, _BorderTransition[indexError][type], CTileBorder::bottom, CTileBorder::bottom, pixel, composante))
01115                         return bottomInterfaceProblem;
01116         }
01117         indexError=getExistingTransitionTile ((TFlagBorder)_TransitionFlags[transition][bottom], dontcare, dontcare, dontcare, transition, type);
01118         if (indexError!=-1)
01119         {
01120                 if (!CTileBorder::compare (border, _BorderTransition[indexError][type], CTileBorder::bottom, CTileBorder::top, pixel, composante))
01121                         return bottomInterfaceProblem;
01122         }
01123         indexError=-1;
01124         if (_TransitionFlags[transition][bottom]==_1111)
01125         {
01126                 if (!CTileBorder::allAlphaSet (border, CTileBorder::bottom, pixel, composante))
01127                         return bottomInterfaceProblem;
01128         }
01129 
01130         // Left
01131         indexError=getExistingTransitionTile (dontcare, dontcare, (TFlagBorder)_TransitionFlags[transition][left], dontcare, transition, type);
01132         if (indexError!=-1)
01133         {
01134                 if (!CTileBorder::compare (border, _BorderTransition[indexError][type], CTileBorder::left, CTileBorder::left, pixel, composante))
01135                         return leftInterfaceProblem;
01136         }
01137         indexError=getExistingTransitionTile (dontcare, dontcare, dontcare, (TFlagBorder)_TransitionFlags[transition][left], transition, type);
01138         if (indexError!=-1)
01139         {
01140                 if (!CTileBorder::compare (border, _BorderTransition[indexError][type], CTileBorder::left, CTileBorder::right, pixel, composante))
01141                         return leftInterfaceProblem;
01142         }
01143         indexError=-1;
01144         if (_TransitionFlags[transition][left]==_1111)
01145         {
01146                 if (!CTileBorder::allAlphaSet (border, CTileBorder::left, pixel, composante))
01147                         return leftInterfaceProblem;
01148         }
01149 
01150         // Right
01151         indexError=getExistingTransitionTile (dontcare, dontcare, dontcare, (TFlagBorder)_TransitionFlags[transition][right], transition, type);
01152         if (indexError!=-1)
01153         {
01154                 if (!CTileBorder::compare (border, _BorderTransition[indexError][type], CTileBorder::right, CTileBorder::right, pixel, composante))
01155                         return rightInterfaceProblem;
01156         }
01157         indexError=getExistingTransitionTile (dontcare, dontcare, (TFlagBorder)_TransitionFlags[transition][right], dontcare, transition, type);
01158         if (indexError!=-1)
01159         {
01160                 if (!CTileBorder::compare (border, _BorderTransition[indexError][type], CTileBorder::right, CTileBorder::left, pixel, composante))
01161                         return rightInterfaceProblem;
01162         }
01163         indexError=-1;
01164         if (_TransitionFlags[transition][right]==_1111)
01165         {
01166                 if (!CTileBorder::allAlphaSet (border, CTileBorder::right, pixel, composante))
01167                         return rightInterfaceProblem;
01168         }
01169         return ok;
01170 }
01171 // ***************************************************************************
01172 void CTileSet::removeTile128 (int indexInTileSet, CTileBank& bank)
01173 {
01174         // Check args
01175         nlassert (indexInTileSet>=0);
01176         nlassert (indexInTileSet<(sint)_Tile128.size());
01177 
01178         // Old index
01179         int index=_Tile128[indexInTileSet];
01180 
01181         // Erase
01182         _Tile128.erase (_Tile128.begin()+indexInTileSet);
01183         bank.freeTile (index);
01184 
01185         // Erase border if it is the last texture
01186         deleteBordersIfLast (bank, CTile::diffuse);
01187         deleteBordersIfLast (bank, CTile::additive);
01188         deleteBordersIfLast (bank, CTile::alpha);
01189 }
01190 // ***************************************************************************
01191 void CTileSet::removeTile256 (int indexInTileSet, CTileBank& bank)
01192 {
01193         // Check args
01194         nlassert (indexInTileSet>=0);
01195         nlassert (indexInTileSet<(sint)_Tile256.size());
01196 
01197         // Old index
01198         int index=_Tile256[indexInTileSet];
01199 
01200         // Erase
01201         _Tile256.erase (_Tile256.begin()+indexInTileSet);
01202         bank.freeTile (index);
01203 
01204         // Erase border if it is the last texture
01205         deleteBordersIfLast (bank, CTile::diffuse);
01206         deleteBordersIfLast (bank, CTile::additive);
01207         deleteBordersIfLast (bank, CTile::alpha);
01208 }
01209 // ***************************************************************************
01210 CTileSet::TTransition CTileSet::getTransitionTile (TFlagBorder _top, TFlagBorder _bottom, TFlagBorder _left, TFlagBorder _right)
01211 {
01212         for (int n=first; n<count; n++)
01213         {
01214                 if (((_top==dontcare)||(_top==(TFlagBorder)_TransitionFlags[n][top]))&&
01215                         ((_bottom==dontcare)||(_bottom==(TFlagBorder)_TransitionFlags[n][bottom]))&&
01216                         ((_left==dontcare)||(_left==(TFlagBorder)_TransitionFlags[n][left]))&&
01217                         ((_right==dontcare)||(_right==(TFlagBorder)_TransitionFlags[n][right])))
01218                 {
01219                         return (TTransition)n;
01220                 }       
01221         }
01222         return notfound;
01223 }
01224 // ***************************************************************************
01225 CTileSet::TTransition CTileSet::getExistingTransitionTile (TFlagBorder _top, TFlagBorder _bottom, TFlagBorder _left, TFlagBorder _right, int reject, CTile::TBitmap type)
01226 {
01227         for (int n=first; n<count; n++)
01228         {
01229                 if ((n!=reject)&&
01230                         (_BorderTransition[n][type].isSet ())&&
01231                         ((_top==dontcare)||(_top==(TFlagBorder)_TransitionFlags[n][top]))&&
01232                         ((_bottom==dontcare)||(_bottom==(TFlagBorder)_TransitionFlags[n][bottom]))&&
01233                         ((_left==dontcare)||(_left==(TFlagBorder)_TransitionFlags[n][left]))&&
01234                         ((_right==dontcare)||(_right==(TFlagBorder)_TransitionFlags[n][right])))
01235                 {
01236                         return (TTransition)n;
01237                 }       
01238         }
01239         return notfound;
01240 }
01241 // ***************************************************************************
01242 void CTileSet::addChild (const std::string& name)
01243 {
01244         _ChildName.insert (name);
01245 }
01246 // ***************************************************************************
01247 void CTileSet::removeChild (const std::string& name)
01248 {
01249         _ChildName.erase (name);
01250 }
01251 // ***************************************************************************
01252 CTileSet::TTransition CTileSet::getComplementaryTransition (TTransition transition)
01253 {
01254         nlassert ((transition>=first)&&(transition<=last));
01255         TTransition trans=getTransitionTile (getComplementaryBorder (_TransitionFlags[transition][top]),
01256                 getComplementaryBorder (_TransitionFlags[transition][bottom]),
01257                 getComplementaryBorder (_TransitionFlags[transition][left]),
01258                 getComplementaryBorder (_TransitionFlags[transition][right]));
01259         
01260         nlassert (trans!=notfound);
01261         
01262         return trans;
01263 }
01264 // ***************************************************************************
01265 CTileSet::TFlagBorder CTileSet::getComplementaryBorder (TFlagBorder border)
01266 {
01267         switch (border)
01268         {
01269         case _0000:
01270                 return _1111;
01271         case _0001:
01272                 return _1110;
01273         case _0111:
01274                 return _1000;
01275         case _1000:
01276                 return _0111;
01277         case _1110:
01278                 return _0001;
01279         case _1111:
01280                 return _0000;
01281         default:
01282                 nlassert (0);   // no
01283         }
01284         return _0000;
01285 }
01286 // ***************************************************************************
01287 CTileSet::TFlagBorder CTileSet::getInvertBorder (TFlagBorder border)
01288 {
01289         switch (border)
01290         {
01291         case _0000:
01292                 return _0000;
01293         case _0001:
01294                 return _1000;
01295         case _0111:
01296                 return _1110;
01297         case _1000:
01298                 return _0001;
01299         case _1110:
01300                 return _0111;
01301         case _1111:
01302                 return _1111;
01303         default:
01304                 nlassert (0);   // no
01305         }
01306         return _0000;
01307 }
01308 // ***************************************************************************
01309 CTileSet::TFlagBorder CTileSet::getOrientedBorder (TBorder where, TFlagBorder border)
01310 {
01311         switch (where)
01312         {
01313         case left:
01314         case bottom:
01315                 return border;
01316         case top:
01317         case right:
01318                 return getInvertBorder (border);
01319         default:
01320                 nlassert (0);   // no
01321         }
01322         return _0000;
01323 }
01324 // ***************************************************************************
01325 CTileSet::TTransition CTileSet::rotateTransition (TTransition transition)
01326 {
01327         return getTransitionTile (
01328                 getOrientedBorder (top, getOrientedBorder (right, _TransitionFlags[transition][right])),        // top
01329                 getOrientedBorder (bottom, getOrientedBorder (left, _TransitionFlags[transition][left])),       // bottom
01330                 getOrientedBorder (left, getOrientedBorder (top, _TransitionFlags[transition][top])),           // left
01331                 getOrientedBorder (right, getOrientedBorder (bottom, _TransitionFlags[transition][bottom])) // right
01332                 );
01333 }
01334 // ***************************************************************************
01335 void CTileSet::clearTile128 (int indexInTileSet, CTile::TBitmap type, CTileBank& bank)
01336 {
01337         int nTile=_Tile128[indexInTileSet];
01338         bank.getTile (nTile)->clearTile(type);
01339         
01340         // Erase border if it is the last texture
01341         deleteBordersIfLast (bank, type);
01342 }
01343 // ***************************************************************************
01344 void CTileSet::clearTile256 (int indexInTileSet, CTile::TBitmap type, CTileBank& bank)
01345 {
01346         int nTile=_Tile256[indexInTileSet];
01347         bank.getTile (nTile)->clearTile(type);
01348         
01349         // Erase border if it is the last texture
01350         deleteBordersIfLast (bank, type);
01351 }
01352 // ***************************************************************************
01353 void CTileSet::clearTransition (TTransition transition, CTile::TBitmap type, CTileBank& bank)
01354 {
01355         int nTile=_TileTransition[transition]._Tile;
01356         if (nTile!=-1)
01357                 bank.getTile (nTile)->clearTile(type);
01358         _BorderTransition[transition][type].reset();
01359         
01360         // Erase border if it is the last texture
01361         deleteBordersIfLast (bank, type);
01362 }
01363 // ***************************************************************************
01364 // Delete 128 and 256 borders if no more valid texture file name for each bitmap type.
01365 void CTileSet::deleteBordersIfLast (const CTileBank& bank, CTile::TBitmap type)
01366 {
01367         // delete is true
01368         bool bDelete=true;
01369 
01370         // iterator..
01371         std::vector<sint32>::iterator ite=_Tile128.begin();
01372 
01373         // Check all the 128x128 tiles
01374         while (ite!=_Tile128.end())
01375         {
01376                 // If the file name is valid
01377                 if (bank.getTile (*ite)->getRelativeFileName(type)!="")
01378                 {
01379                         // Don't delete, 
01380                         bDelete=false;
01381                         break;
01382                 }
01383                 ite++;
01384         }
01385         // If break, not empty, return
01386         if (ite!=_Tile128.end())
01387                 return;
01388 
01389         // Check all the 256x256 tiles
01390         ite=_Tile256.begin();
01391         while (ite!=_Tile256.end())
01392         {
01393                 // If the file name is valid
01394                 if (bank.getTile (*ite)->getRelativeFileName(type)!="")
01395                 {
01396                         // Don't delete, 
01397                         bDelete=false;
01398                         break;
01399                 }
01400                 ite++;
01401         }
01402         // If break, not empty, return
01403         if (ite!=_Tile256.end())
01404                 return;
01405 
01406 
01407         // Check all the transitions tiles
01408         sint trans;
01409         for (trans=0; trans<count; trans++)
01410         {
01411                 // Get the tile associed with the transition
01412                 int nTile=_TileTransition[trans]._Tile;
01413 
01414                 // If it is not NULL..
01415                 if (nTile!=-1)
01416                 {
01417                         // If the file name is valid
01418                         if (bank.getTile (nTile)->getRelativeFileName(type)!="")
01419                         {
01420                                 // Don't delete, 
01421                                 bDelete=false;
01422                                 break;
01423                         }
01424                 }
01425         }
01426         if (trans!=count)
01427                 return;
01428 
01429         // Ok, erase borders because no tile use it anymore
01430         _Border128[type].reset();
01431         _Border256[type].reset();
01432 }
01433 // ***************************************************************************
01434 void CTileSet::clearDisplacement (TDisplacement displacement, CTileBank& bank)
01435 {
01436         // checks
01437         nlassert (displacement>=FirstDisplace);
01438         nlassert (displacement<=LastDisplace);
01439 
01440         // Backup the id
01441         int id=_DisplacementBitmap[displacement];
01442 
01443         // Clear map id
01444         _DisplacementBitmap[displacement]=0;
01445 
01446         // Tell the bank we remove it
01447         bank.removeDisplacementMap (id);
01448 }
01449 // ***************************************************************************
01450 void CTileSet::setDisplacement (TDisplacement displacement, const std::string& fileName, CTileBank& bank)
01451 {
01452         // checks
01453         nlassert (displacement>=FirstDisplace);
01454         nlassert (displacement<=LastDisplace);
01455 
01456         // Clear it
01457         bank.removeDisplacementMap (_DisplacementBitmap[displacement]);
01458 
01459         // Get displacement map
01460         _DisplacementBitmap[displacement]=bank.getDisplacementMap (fileName);
01461 }
01462 // ***************************************************************************
01463 void CTileSet::cleanUnusedData ()
01464 {
01465         _Name="";
01466         _ChildName.clear();
01467         _Border128[0].reset ();
01468         _Border128[1].reset ();
01469         _Border256[0].reset ();
01470         _Border256[1].reset ();
01471         for (uint i=0; i<count; i++)
01472         for (uint j=0; j<CTile::bitmapCount; j++)
01473                 _BorderTransition[i][j].reset();
01474 }
01475 
01476 
01477 // ***************************************************************************
01478 void CTileSet::setTileVegetableDescFileName (const std::string &fileName)
01479 {
01480         _TileVegetableDescFileName= fileName;
01481 }
01482 // ***************************************************************************
01483 const std::string& CTileSet::getTileVegetableDescFileName () const
01484 {
01485         return _TileVegetableDescFileName;
01486 }
01487 // ***************************************************************************
01488 void CTileSet::setTileVegetableDesc (const CTileVegetableDesc   &tvd)
01489 {
01490         _TileVegetableDesc= tvd;
01491 }
01492 
01493 // ***************************************************************************
01494 CTileVegetableDesc                      &CTileSet::getTileVegetableDesc()
01495 {
01496         return _TileVegetableDesc;
01497 }
01498 
01499 // ***************************************************************************
01500 const CTileVegetableDesc        &CTileSet::getTileVegetableDesc() const
01501 {
01502         return _TileVegetableDesc;
01503 }
01504 
01505 // ***************************************************************************
01506 void CTileSet::loadTileVegetableDesc()
01507 {
01508         if(_TileVegetableDescFileName!="")
01509         {
01510                 try
01511                 {
01512                         string  fname= CPath::lookup(_TileVegetableDescFileName);
01513                         CIFile  f(fname);
01514                         // load the TileVegetableDesc
01515                         f.serial(_TileVegetableDesc);
01516                 }
01517                 catch(Exception &e)
01518                 {
01519                         nlinfo("Error loading TileVegetableDesc: %s", e.what());
01520                 }
01521         }
01522 }
01523 
01524 
01525 // ***************************************************************************
01526 // ***************************************************************************
01527 // CTileBorder.
01528 // ***************************************************************************
01529 // ***************************************************************************
01530 
01531 
01532 // ***************************************************************************
01533 const sint CTileBorder::_Version=0;
01534 // ***************************************************************************
01535 void CTileBorder::serial(IStream &f) throw(EStream)
01536 {
01537         (void)f.serialVersion(_Version);
01538 
01539         f.serial (_Set);
01540         f.serial (_Width);
01541         f.serial (_Height);
01542         f.serialCont (_Borders[top]);
01543         f.serialCont (_Borders[bottom]);
01544         f.serialCont (_Borders[left]);
01545         f.serialCont (_Borders[right]);
01546 }
01547 // ***************************************************************************
01548 void CTileBorder::set (int width, int height, const std::vector<CBGRA>& array)
01549 {
01550         // Check array size
01551         nlassert (width>0);
01552         nlassert (height>0);
01553         nlassert ((sint)array.size()==width*height);
01554 
01555         // Copy size
01556         _Width=width;
01557         _Height=height;
01558 
01559         // Last line
01560         int lastLine=(_Height-1)*width;
01561         int lastCol=(_Width-1);
01562         _Borders[top].resize (_Width);
01563         _Borders[bottom].resize (_Width);
01564         _Borders[left].resize (_Height);
01565         _Borders[right].resize (_Height);
01566 
01567         // Copy top/bottom border
01568         for (int w=0; w<_Width; w++)
01569         {
01570                 _Borders[top][w]=array[w];
01571                 _Borders[bottom][w]=array[w+lastLine];
01572         }
01573 
01574         // Copy left/right border
01575         for (int h=0; h<_Height; h++)
01576         {
01577                 _Borders[left][h]=array[h*_Width];
01578                 _Borders[right][h]=array[h*_Width+lastCol];
01579         }
01580 
01581         // Set
01582         _Set=true;
01583 }
01584 // ***************************************************************************
01585 void CTileBorder::get (int &width, int &height, std::vector<CBGRA>& array) const
01586 {
01587         // Go
01588         if (_Set)
01589         {
01590                 width=_Width;
01591                 height=_Height;
01592                 array.resize (0);
01593                 array.resize (_Width*_Height);
01594                 nlassert (_Borders[bottom].size()==(uint)_Width);
01595                 nlassert (_Borders[top].size()==(uint)_Width);
01596                 nlassert (_Borders[left].size()==(uint)_Height);
01597                 nlassert (_Borders[right].size()==(uint)_Height);
01598 
01599                 // Fill
01600                 CBGRA black(0,0,0);
01601                 for (int p=0; p<_Width*_Height; p++)
01602                 {
01603                         array[p]=black;
01604                 }
01605 
01606                 // Last line
01607                 int lastLine=(_Height-1)*_Width;
01608                 int lastCol=(_Width-1);
01609 
01610                 // Copy top/bottom border
01611                 for (int w=0; w<_Width; w++)
01612                 {
01613                         array[w]=_Borders[top][w];
01614                         array[w+lastLine]=_Borders[bottom][w];
01615                 }
01616 
01617                 // Copy left/right border
01618                 for (int h=0; h<_Height; h++)
01619                 {
01620                         array[h*_Width]=_Borders[left][h];
01621                         array[h*_Width+lastCol]=_Borders[right][h];
01622                 }
01623         }
01624         else
01625         {
01626                 width=0;
01627                 height=0;
01628                 array.resize (0);
01629         }
01630 }
01631 // ***************************************************************************
01632 bool CTileBorder::compare (const CTileBorder& border1, const CTileBorder& border2, TBorder where1, TBorder where2, int& pixel, int& composante)
01633 {
01634         // Check border is initialized
01635         nlassert (border1.isSet());
01636         nlassert (border2.isSet());
01637 
01638         if (border1._Borders[where1].size()!=border2._Borders[where2].size())
01639                 return false;
01640         for (pixel=0; pixel<(int)border1._Borders[where1].size(); pixel++)
01641         {
01642                 if (border1._Borders[where1][pixel].R!=border2._Borders[where2][pixel].R)
01643                 {
01644                         composante=0;
01645                         return false;
01646                 }
01647                 else if (border1._Borders[where1][pixel].G!=border2._Borders[where2][pixel].G)
01648                 {
01649                         composante=1;
01650                         return false;
01651                 }
01652                 else if (border1._Borders[where1][pixel].B!=border2._Borders[where2][pixel].B)
01653                 {
01654                         composante=2;
01655                         return false;
01656                 }
01657                 else if (border1._Borders[where1][pixel].A!=border2._Borders[where2][pixel].A)
01658                 {
01659                         composante=3;
01660                         return false;
01661                 }
01662         }
01663 
01664         return true;
01665 }
01666 // ***************************************************************************
01667 bool CTileBorder::allAlphaSet (const CTileBorder& border, TBorder where, int& pixel, int& composante)
01668 {
01669         // Check border is initialized
01670         nlassert (border.isSet());
01671 
01672         // always Alpha
01673         composante=3;
01674 
01675         for (pixel=0; pixel<(int)border._Borders[where].size(); pixel++)
01676         {
01677                 if (border._Borders[where][pixel].A!=0xff)
01678                         return false;
01679         }
01680 
01681         return true;
01682 }
01683 // ***************************************************************************
01684 bool CTileBorder::operator== (const CTileBorder& border) const
01685 {
01686         return (_Width==border._Width) && (_Height==border._Height) && (_Borders==border._Borders);
01687 }
01688 // ***************************************************************************
01689 void CTileBorder::operator= (const CTileBorder& border)
01690 {
01691         _Set=border._Set;
01692         _Width=border._Width;
01693         _Height=border._Width;
01694         _Borders[top]=border._Borders[top];
01695         _Borders[bottom]=border._Borders[bottom];
01696         _Borders[left]=border._Borders[left];
01697         _Borders[right]=border._Borders[right];
01698 }
01699         
01700 // ***************************************************************************
01701 void CTileBorder::doubleSize ()
01702 {
01703         _Borders[top].resize (_Width*2);
01704         _Borders[bottom].resize (_Width*2);
01705         _Borders[left].resize (_Height*2);
01706         _Borders[right].resize (_Height*2);
01707 
01708         for (int w=0; w<_Width; w++)
01709         {
01710                 _Borders[top][w+_Width]=_Borders[top][w];
01711                 _Borders[bottom][w+_Width]=_Borders[bottom][w];
01712         }
01713         for (int h=0; h<_Height; h++)
01714         {
01715                 _Borders[left][h+_Height]=_Borders[left][h];
01716                 _Borders[right][h+_Height]=_Borders[right][h];
01717         }
01718 }
01719 // ***************************************************************************
01720 void CTileBorder::rotate()
01721 {
01722         // Copy the right
01723         std::vector<NLMISC::CBGRA> tmpLeft=_Borders[left];
01724 
01725         // Top inverted becomes left
01726         uint i, size;
01727         size=_Borders[top].size();
01728         _Borders[left].resize (size);
01729 
01730         // copy inverted
01731         for (i=0; i<size; i++)
01732                 _Borders[left][i]=_Borders[top][size-i-1];
01733 
01734         // Right become top
01735         _Borders[top]=_Borders[right];
01736 
01737         // bottom inverted becomes right
01738         size=_Borders[bottom].size();
01739         _Borders[right].resize (size);
01740 
01741         // copy inverted
01742         for (i=0; i<size; i++)
01743                 _Borders[right][i]=_Borders[bottom][size-i-1];
01744 
01745         // Left become bottom
01746         _Borders[bottom]=tmpLeft;
01747 
01748         // Invert size
01749         sint32 tmpSize=_Width;
01750         _Width=_Height;
01751         _Height=tmpSize;
01752 }
01753 
01754 // ***************************************************************************
01755 // ***************************************************************************
01756 // CTileSetTransition.
01757 // ***************************************************************************
01758 // ***************************************************************************
01759 
01760 
01761 // ***************************************************************************
01762 const sint CTileSetTransition::_Version=1;
01763 // ***************************************************************************
01764 void CTileSetTransition::serial(class NLMISC::IStream &f) throw(EStream)
01765 {
01766         sint streamver = f.serialVersion(_Version);
01767 
01768         switch (streamver)
01769         {
01770         case 0:
01771                 {
01772                         bool doomy;
01773                         f.serial (_Tile);
01774                         f.serial (doomy);               // skip the old argu
01775                 }
01776                 break;
01777         case 1:
01778                 f.serial (_Tile);
01779                 break;
01780         }
01781 }
01782 // ***************************************************************************
01783 
01784 
01785 // ***************************************************************************
01786 // ***************************************************************************
01787 // CTileNoise.
01788 // ***************************************************************************
01789 // ***************************************************************************
01790 
01791 
01792 // ***************************************************************************
01793 CTileNoise::CTileNoise ()
01794 {
01795         // Not loaded
01796         _TileNoiseMap=NULL;
01797         _FileName="";
01798 }
01799 // ***************************************************************************
01800 CTileNoise::CTileNoise (const CTileNoise &src)
01801 {
01802         // Default ctor
01803         _TileNoiseMap=NULL;
01804         _FileName="";
01805 
01806         // Copy
01807         *this=src;
01808 }
01809 // ***************************************************************************
01810 CTileNoise::~CTileNoise ()
01811 {
01812         if (_TileNoiseMap)
01813         {
01814                 delete _TileNoiseMap;
01815                 _TileNoiseMap=NULL;
01816         }
01817 }
01818 // ***************************************************************************
01819 CTileNoise& CTileNoise::operator= (const CTileNoise &src)
01820 {
01821         // Copy the filename
01822         _FileName=src._FileName;
01823 
01824         // Tile noise map ?
01825         if (src._TileNoiseMap)
01826         {
01827                 if (_TileNoiseMap==NULL)
01828                 {
01829                         // Allocate it
01830                         _TileNoiseMap=new CTileNoiseMap;
01831                 }
01832 
01833                 // Copy the noise map
01834                 *_TileNoiseMap=*src._TileNoiseMap;
01835         }
01836         else
01837         {
01838                 // Erase the map
01839                 if (_TileNoiseMap)
01840                 {
01841                         delete _TileNoiseMap;
01842                         _TileNoiseMap=NULL;
01843                 }
01844         }
01845         return *this;
01846 }
01847 // ***************************************************************************
01848 void CTileNoise::serial (IStream& f)
01849 {
01850         // Version
01851         f.serialVersion (0);
01852 
01853         // Serial the file name
01854         f.serial (_FileName);
01855 }
01856 // ***************************************************************************
01857 void CTileNoise::setEmpty ()
01858 {
01859         // Reset it
01860         reset();
01861         _FileName="EmptyDisplacementMap";
01862         _TileNoiseMap=new CTileNoiseMap();
01863         memset (_TileNoiseMap->Pixels, 0, NL3D_TILE_NOISE_MAP_SIZE*NL3D_TILE_NOISE_MAP_SIZE);
01864 }
01865 // ***************************************************************************
01866 void CTileNoise::reset()
01867 {
01868         // Erase the map
01869         if (_TileNoiseMap)
01870         {
01871                 delete _TileNoiseMap;
01872                 _TileNoiseMap=NULL;
01873         }
01874 
01875         // Erase filename
01876         _FileName="";
01877 }
01878 // ***************************************************************************
01879 
01880 }       // NL3D
tile_bank.cpp
