1940 lines
60 KiB
C++
1940 lines
60 KiB
C++
// NeL - MMORPG Framework <http://dev.ryzom.com/projects/nel/>
|
|
// Copyright (C) 2010 Winch Gate Property Limited
|
|
//
|
|
// This program is free software: you can redistribute it and/or modify
|
|
// it under the terms of the GNU Affero General Public License as
|
|
// published by the Free Software Foundation, either version 3 of the
|
|
// License, or (at your option) any later version.
|
|
//
|
|
// This program is distributed in the hope that it will be useful,
|
|
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
// GNU Affero General Public License for more details.
|
|
//
|
|
// You should have received a copy of the GNU Affero General Public License
|
|
// along with this program. If not, see <http://www.gnu.org/licenses/>.
|
|
|
|
#include "std3d.h"
|
|
|
|
#include "nel/3d/tile_bank.h"
|
|
#include "nel/3d/texture_file.h"
|
|
#include "nel/3d/tile_noise_map.h"
|
|
|
|
#include "nel/misc/stream.h"
|
|
#include "nel/misc/common.h"
|
|
#include "nel/misc/path.h"
|
|
#include "nel/misc/file.h"
|
|
#include <string>
|
|
|
|
using namespace NLMISC;
|
|
using namespace std;
|
|
|
|
namespace NL3D
|
|
{
|
|
|
|
|
|
// ***************************************************************************
|
|
// ***************************************************************************
|
|
// TileBankLand.
|
|
// ***************************************************************************
|
|
// ***************************************************************************
|
|
|
|
|
|
// ***************************************************************************
|
|
const sint CTileLand::_Version=0;
|
|
// ***************************************************************************
|
|
void CTileLand::serial(NLMISC::IStream &f) throw(NLMISC::EStream)
|
|
{
|
|
(void)f.serialVersion(_Version);
|
|
|
|
f.serial (_Name);
|
|
f.serialCont (_TileSet);
|
|
}
|
|
// ***************************************************************************
|
|
void CTileLand::addTileSet (const std::string& name)
|
|
{
|
|
_TileSet.insert (name);
|
|
}
|
|
// ***************************************************************************
|
|
void CTileLand::removeTileSet (const std::string& name)
|
|
{
|
|
_TileSet.erase (name);
|
|
}
|
|
// ***************************************************************************
|
|
void CTileLand::setName (const std::string& name)
|
|
{
|
|
_Name=name;
|
|
};
|
|
// ***************************************************************************
|
|
|
|
|
|
// ***************************************************************************
|
|
// ***************************************************************************
|
|
// CTileBank.
|
|
// ***************************************************************************
|
|
// ***************************************************************************
|
|
|
|
|
|
// ***************************************************************************
|
|
const sint CTileBank::_Version=4;
|
|
// ***************************************************************************
|
|
CTileBank::CTileBank ()
|
|
{
|
|
// Default _DisplacementMap
|
|
_DisplacementMap.resize (1);
|
|
|
|
// Fill it with 0
|
|
_DisplacementMap[0].setEmpty ();
|
|
}
|
|
// ***************************************************************************
|
|
void CTileBank::serial(NLMISC::IStream &f) throw(NLMISC::EStream)
|
|
{
|
|
f.serialCheck (std::string ("BANK"));
|
|
|
|
sint streamver = f.serialVersion(_Version);
|
|
|
|
// Version 1 not compatible
|
|
if (f.isReading())
|
|
{
|
|
if (streamver<2)
|
|
throw EOlderStream(f);
|
|
}
|
|
|
|
switch (streamver)
|
|
{
|
|
case 4:
|
|
// Displacement map array
|
|
f.serialCont (_DisplacementMap);
|
|
if (f.isReading())
|
|
{
|
|
// Checks
|
|
nlassert (_DisplacementMap.size()>0);
|
|
|
|
// Set first empty
|
|
_DisplacementMap[0].setEmpty ();
|
|
}
|
|
case 3:
|
|
// Absolute path
|
|
f.serial (_AbsPath);
|
|
case 2:
|
|
// Serial all containers
|
|
f.serialCont (_LandVector);
|
|
f.serialCont (_TileSetVector);
|
|
f.serialCont (_TileVector);
|
|
}
|
|
|
|
// Compute XRef in read mode
|
|
if (f.isReading())
|
|
computeXRef ();
|
|
|
|
// If Version<=2, remove diffuse and alpha tiles in transitions
|
|
if (streamver<=2)
|
|
{
|
|
// Must be reading
|
|
nlassert (f.isReading());
|
|
|
|
// Reset _AbsPath
|
|
_AbsPath="";
|
|
|
|
// Remove diffuse and additive in transition
|
|
uint tileCount=(uint)getTileCount ();
|
|
for (uint i=0; i<tileCount; i++)
|
|
{
|
|
int tileSet;
|
|
int number;
|
|
TTileType type;
|
|
|
|
// Get xref
|
|
getTileXRef (i, tileSet, number, type);
|
|
|
|
// Transition ?
|
|
if (type==transition)
|
|
{
|
|
// Remove diffuse bitmap
|
|
getTileSet(tileSet)->clearTransition ((CTileSet::TTransition)number, CTile::diffuse, *this);
|
|
|
|
// Remove alpha bitmap
|
|
getTileSet(tileSet)->clearTransition ((CTileSet::TTransition)number, CTile::alpha, *this);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
// ***************************************************************************
|
|
sint CTileBank::addLand (const std::string& name)
|
|
{
|
|
sint last=(sint)_LandVector.size();
|
|
_LandVector.push_back(CTileLand());
|
|
_LandVector[last].setName (name);
|
|
return last;
|
|
}
|
|
// ***************************************************************************
|
|
void CTileBank::removeLand (sint landIndex)
|
|
{
|
|
// Check args
|
|
nlassert (landIndex>=0);
|
|
nlassert (landIndex<(sint)_LandVector.size());
|
|
|
|
_LandVector.erase (_LandVector.begin ()+landIndex);
|
|
}
|
|
// ***************************************************************************
|
|
sint CTileBank::addTileSet (const std::string& name)
|
|
{
|
|
sint last=(sint)_TileSetVector.size();
|
|
_TileSetVector.push_back(CTileSet());
|
|
_TileSetVector[last].setName (name);
|
|
for (int i=0; i<CTileSet::count; i++)
|
|
{
|
|
_TileSetVector[last]._TileTransition[i]._Tile=createTile ();
|
|
}
|
|
return last;
|
|
}
|
|
// ***************************************************************************
|
|
void CTileBank::removeTileSet (sint setIndex)
|
|
{
|
|
// Check args
|
|
nlassert (setIndex>=0);
|
|
nlassert (setIndex<(sint)_TileSetVector.size());
|
|
|
|
for (int i=0; i<CTileSet::count; i++)
|
|
{
|
|
int index=_TileSetVector[setIndex]._TileTransition[i]._Tile;
|
|
if (index!=-1)
|
|
freeTile (index);
|
|
}
|
|
_TileSetVector.erase (_TileSetVector.begin ()+setIndex);
|
|
}
|
|
// ***************************************************************************
|
|
void CTileBank::clear ()
|
|
{
|
|
_LandVector.clear ();
|
|
_TileSetVector.clear ();
|
|
_TileVector.clear ();
|
|
_TileXRef.clear ();
|
|
_DisplacementMap.clear ();
|
|
_AbsPath.clear ();
|
|
}
|
|
// ***************************************************************************
|
|
sint CTileBank::createTile ()
|
|
{
|
|
// Look for a free tile
|
|
for (int i=0; i<(sint)_TileVector.size(); i++)
|
|
{
|
|
if (_TileVector[i].isFree())
|
|
{
|
|
_TileVector[i].setFileName (CTile::diffuse, "");
|
|
_TileVector[i].setFileName (CTile::additive, "");
|
|
_TileVector[i].setFileName (CTile::alpha, "");
|
|
return i;
|
|
}
|
|
}
|
|
|
|
// Nothing free, add a tile at the end
|
|
_TileVector.push_back (CTile());
|
|
_TileVector[_TileVector.size()-1].setFileName (CTile::diffuse, "");
|
|
_TileVector[_TileVector.size()-1].setFileName (CTile::additive, "");
|
|
_TileVector[_TileVector.size()-1].setFileName (CTile::alpha, "");
|
|
return (sint)_TileVector.size()-1;
|
|
}
|
|
// ***************************************************************************
|
|
void CTileBank::freeTile (int tileIndex)
|
|
{
|
|
// Check args
|
|
nlassert (tileIndex>=0);
|
|
nlassert (tileIndex<(sint)_TileVector.size());
|
|
|
|
// Free
|
|
_TileVector[tileIndex].free();
|
|
|
|
// Resize tile table
|
|
int i;
|
|
for (i=(sint)_TileVector.size()-1; i>=0; i--)
|
|
{
|
|
if (!_TileVector[i].isFree ())
|
|
break;
|
|
}
|
|
if (i<(sint)_TileVector.size()-1)
|
|
_TileVector.resize (i+1);
|
|
}
|
|
// ***************************************************************************
|
|
sint CTileBank::getNumBitmap (CTile::TBitmap bitmap) const
|
|
{
|
|
std::set<std::string> setString;
|
|
for (int i=0; i<(sint)_TileVector.size(); i++)
|
|
{
|
|
if (!_TileVector[i].isFree())
|
|
{
|
|
const std::string &str=_TileVector[i].getRelativeFileName (bitmap);
|
|
if (str!="")
|
|
{
|
|
std::vector<char> vect (str.length()+1);
|
|
memcpy (&*vect.begin(), str.c_str(), str.length()+1);
|
|
toLower(&*vect.begin());
|
|
setString.insert (std::string (&*vect.begin()));
|
|
}
|
|
}
|
|
}
|
|
return (sint)setString.size();
|
|
}
|
|
// ***************************************************************************
|
|
void CTileBank::computeXRef ()
|
|
{
|
|
// Resize
|
|
_TileXRef.resize (_TileVector.size());
|
|
|
|
// Erase number of the tileset in xref
|
|
for (int tile=0; tile<(sint)_TileVector.size(); tile++)
|
|
_TileXRef[tile]._XRefTileSet=-1;
|
|
|
|
// Erase number of the tileset in xref
|
|
for (int s=0; s<(sint)_TileSetVector.size(); s++)
|
|
{
|
|
int t;
|
|
CTileSet *tileSet=getTileSet (s);
|
|
for (t=0; t<tileSet->getNumTile128(); t++)
|
|
{
|
|
int index=tileSet->getTile128 (t);
|
|
_TileXRef[index]._XRefTileSet=s;
|
|
_TileXRef[index]._XRefTileNumber=t;
|
|
_TileXRef[index]._XRefTileType=_128x128;
|
|
}
|
|
for (t=0; t<tileSet->getNumTile256(); t++)
|
|
{
|
|
int index=tileSet->getTile256 (t);
|
|
_TileXRef[index]._XRefTileSet=s;
|
|
_TileXRef[index]._XRefTileNumber=t;
|
|
_TileXRef[index]._XRefTileType=_256x256;
|
|
}
|
|
for (t=0; t<CTileSet::count; t++)
|
|
{
|
|
int index=tileSet->getTransition (t)->getTile();
|
|
_TileXRef[index]._XRefTileSet=s;
|
|
_TileXRef[index]._XRefTileNumber=t;
|
|
_TileXRef[index]._XRefTileType=transition;
|
|
}
|
|
}
|
|
}
|
|
// ***************************************************************************
|
|
void CTileBank::xchgTileset (sint firstTileSet, sint secondTileSet)
|
|
{
|
|
// Some check
|
|
nlassert ((firstTileSet>=0)&&(firstTileSet<(sint)_TileSetVector.size()));
|
|
nlassert ((secondTileSet>=0)&&(secondTileSet<(sint)_TileSetVector.size()));
|
|
|
|
// Xchange the sets
|
|
CTileSet tmp=_TileSetVector[firstTileSet];
|
|
_TileSetVector[firstTileSet]=_TileSetVector[secondTileSet];
|
|
_TileSetVector[secondTileSet]=tmp;
|
|
}
|
|
// ***************************************************************************
|
|
void TroncFileName (char* sDest, const char* sSrc)
|
|
{
|
|
const char* ptr=strrchr (sSrc, '\\');
|
|
if (ptr==NULL)
|
|
ptr=strrchr (sSrc, '/');
|
|
if (ptr)
|
|
{
|
|
ptr++;
|
|
strcpy (sDest, ptr);
|
|
}
|
|
else
|
|
{
|
|
strcpy (sDest, sSrc);
|
|
}
|
|
}
|
|
// ***************************************************************************
|
|
// TODO: this is a temporary hack, see if it could be removed
|
|
void CTileBank::makeAllPathRelative ()
|
|
{
|
|
// For all tiles
|
|
for (sint nTile=0; nTile<(sint)_TileVector.size(); nTile++)
|
|
{
|
|
// Tronc filename
|
|
char sTmpFileName[512];
|
|
|
|
// Diffuse
|
|
TroncFileName (sTmpFileName, _TileVector[nTile].getRelativeFileName (CTile::diffuse).c_str());
|
|
_TileVector[nTile].setFileName (CTile::diffuse, sTmpFileName);
|
|
|
|
// Additive
|
|
TroncFileName (sTmpFileName, _TileVector[nTile].getRelativeFileName (CTile::additive).c_str());
|
|
_TileVector[nTile].setFileName (CTile::additive, sTmpFileName);
|
|
|
|
// Alpha
|
|
TroncFileName (sTmpFileName, _TileVector[nTile].getRelativeFileName (CTile::alpha).c_str());
|
|
_TileVector[nTile].setFileName (CTile::alpha, sTmpFileName);
|
|
}
|
|
|
|
// For all displaces
|
|
for (uint i=0; i<_DisplacementMap.size(); i++)
|
|
{
|
|
// Tronc filename
|
|
char sTmpFileName[512];
|
|
|
|
TroncFileName (sTmpFileName, _DisplacementMap[i]._FileName.c_str());
|
|
_DisplacementMap[i]._FileName = sTmpFileName;
|
|
}
|
|
}
|
|
|
|
|
|
// ***************************************************************************
|
|
// Moi aussi je le parie (Yoyo).
|
|
void CTileBank::makeAllExtensionDDS ()
|
|
{
|
|
// For all tiles
|
|
for (sint nTile=0; nTile<(sint)_TileVector.size(); nTile++)
|
|
{
|
|
string tmp;
|
|
string::size_type pos;
|
|
|
|
// Diffuse
|
|
tmp= _TileVector[nTile].getRelativeFileName (CTile::diffuse);
|
|
pos= tmp.rfind(".tga");
|
|
if (pos == string::npos)
|
|
pos = tmp.rfind(".png");
|
|
if(pos!= string::npos)
|
|
{
|
|
tmp.replace(pos, 4, ".dds");
|
|
_TileVector[nTile].setFileName (CTile::diffuse, tmp);
|
|
}
|
|
|
|
// Additive.
|
|
tmp= _TileVector[nTile].getRelativeFileName (CTile::additive);
|
|
pos= tmp.rfind(".tga");
|
|
if (pos == string::npos)
|
|
pos = tmp.rfind(".png");
|
|
if(pos!= string::npos)
|
|
{
|
|
tmp.replace(pos, 4, ".dds");
|
|
_TileVector[nTile].setFileName (CTile::additive, tmp);
|
|
}
|
|
|
|
// Alpha.
|
|
tmp= _TileVector[nTile].getRelativeFileName (CTile::alpha);
|
|
pos= tmp.rfind(".tga");
|
|
if (pos == string::npos)
|
|
pos = tmp.rfind(".png");
|
|
if(pos!= string::npos)
|
|
{
|
|
tmp.replace(pos, 4, ".dds");
|
|
_TileVector[nTile].setFileName (CTile::alpha, tmp);
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
// ***************************************************************************
|
|
void CTileBank::cleanUnusedData ()
|
|
{
|
|
// Clean each tileset
|
|
for (uint i=0; i<_TileSetVector.size(); i++)
|
|
{
|
|
// Clean the tileset
|
|
_TileSetVector[i].cleanUnusedData ();
|
|
}
|
|
|
|
// Clear the land vector
|
|
_LandVector.clear();
|
|
}
|
|
// ***************************************************************************
|
|
CTileNoiseMap *CTileBank::getTileNoiseMap (uint tileNumber, uint tileSubNoise)
|
|
{
|
|
if (_DisplacementMap.size() == 0)
|
|
{
|
|
// it happens when serial a tile bank with version < 4
|
|
return NULL;
|
|
}
|
|
|
|
// Check tile number..
|
|
if (tileNumber<_TileVector.size())
|
|
{
|
|
// Get tileset number
|
|
uint tileSet=_TileXRef[tileNumber]._XRefTileSet;
|
|
|
|
// Checks
|
|
if (tileSet<_TileSetVector.size())
|
|
{
|
|
nlassert (tileSubNoise<CTileSet::CountDisplace);
|
|
//nlassert (_TileSetVector[tileSet]._DisplacementBitmap[tileSubNoise]<_DisplacementMap.size());
|
|
|
|
if (_TileSetVector[tileSet]._DisplacementBitmap[tileSubNoise]>=_DisplacementMap.size())
|
|
return NULL;
|
|
|
|
// Return the tile noise map
|
|
CTileNoise &tileNoise=_DisplacementMap[_TileSetVector[tileSet]._DisplacementBitmap[tileSubNoise]];
|
|
|
|
// Not loaded ?
|
|
if (tileNoise._TileNoiseMap==NULL)
|
|
{
|
|
// Load a bitmap
|
|
CTextureFile texture (getAbsPath()+tileNoise._FileName);
|
|
texture.loadGrayscaleAsAlpha (false);
|
|
texture.generate ();
|
|
texture.convertToType (CBitmap::Luminance);
|
|
|
|
// Alloc
|
|
tileNoise._TileNoiseMap=new CTileNoiseMap;
|
|
|
|
// Good size ?
|
|
if ((texture.getWidth ()==NL3D_TILE_NOISE_MAP_SIZE)&&(texture.getHeight()==NL3D_TILE_NOISE_MAP_SIZE))
|
|
{
|
|
// Copy
|
|
memcpy (tileNoise._TileNoiseMap->Pixels, &texture.getPixels()[0], NL3D_TILE_NOISE_MAP_SIZE*NL3D_TILE_NOISE_MAP_SIZE);
|
|
|
|
// Remap lumels
|
|
for (uint i=0; i<NL3D_TILE_NOISE_MAP_SIZE*NL3D_TILE_NOISE_MAP_SIZE; i++)
|
|
{
|
|
tileNoise._TileNoiseMap->Pixels[i]=(sint8)((uint8)tileNoise._TileNoiseMap->Pixels[i]-128);
|
|
if (tileNoise._TileNoiseMap->Pixels[i]==-128)
|
|
tileNoise._TileNoiseMap->Pixels[i]=-127;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// This is not a normal behaviour.
|
|
string pathname= getAbsPath()+tileNoise._FileName;
|
|
if( texture.getWidth ()==0 || texture.getHeight ()==0 )
|
|
nlwarning("TileNoiseMap not found: %s.", pathname.c_str());
|
|
else
|
|
nlwarning("Bad TileNoiseMap size: %s.", pathname.c_str());
|
|
|
|
// Not good size, copy a static map
|
|
sint8 notGoodSizeForm[NL3D_TILE_NOISE_MAP_SIZE*NL3D_TILE_NOISE_MAP_SIZE]=
|
|
{
|
|
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,
|
|
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,
|
|
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,
|
|
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,
|
|
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,
|
|
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,
|
|
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,
|
|
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,
|
|
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,
|
|
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,
|
|
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,
|
|
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,
|
|
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,
|
|
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,
|
|
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,
|
|
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,
|
|
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,
|
|
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,
|
|
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,
|
|
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,
|
|
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,
|
|
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,
|
|
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,
|
|
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,
|
|
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,
|
|
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,
|
|
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,
|
|
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,
|
|
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,
|
|
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,
|
|
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,
|
|
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
|
|
};
|
|
|
|
// Copy
|
|
memcpy (tileNoise._TileNoiseMap->Pixels, notGoodSizeForm, NL3D_TILE_NOISE_MAP_SIZE*NL3D_TILE_NOISE_MAP_SIZE);
|
|
}
|
|
}
|
|
|
|
// Return the noise map
|
|
return tileNoise._TileNoiseMap;
|
|
}
|
|
}
|
|
|
|
if (_DisplacementMap.size()==0 || _DisplacementMap[0]._TileNoiseMap)
|
|
return NULL;
|
|
|
|
// Checks
|
|
nlassert (_DisplacementMap[0]._TileNoiseMap);
|
|
return _DisplacementMap[0]._TileNoiseMap;
|
|
}
|
|
// ***************************************************************************
|
|
void CTileBank::removeDisplacementMap (uint mapId)
|
|
{
|
|
// Checks
|
|
nlassert (mapId<_DisplacementMap.size());
|
|
|
|
if (mapId!=0)
|
|
{
|
|
// Check if another tileSet uses it
|
|
uint tileSet;
|
|
for (tileSet=0; tileSet<_TileSetVector.size(); tileSet++)
|
|
{
|
|
// It uses it ?
|
|
uint tile;
|
|
for (tile=0; tile<CTileSet::CountDisplace; tile++)
|
|
{
|
|
// The same ?
|
|
if (_TileSetVector[tileSet]._DisplacementBitmap[tile]==mapId)
|
|
// Stop
|
|
break;
|
|
}
|
|
if (tile!=CTileSet::CountDisplace)
|
|
break;
|
|
}
|
|
if (tileSet==_TileSetVector.size())
|
|
{
|
|
// Remove it
|
|
_DisplacementMap[mapId].reset();
|
|
|
|
// Last element ?
|
|
if (mapId==_DisplacementMap.size()-1)
|
|
{
|
|
// Resize the array ?
|
|
while ((mapId>0)&&(_DisplacementMap[mapId]._FileName==""))
|
|
_DisplacementMap.resize (mapId--);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
// ***************************************************************************
|
|
uint CTileBank::getDisplacementMap (const string &fileName)
|
|
{
|
|
// Lower string
|
|
string lower=toLower(fileName);
|
|
|
|
// Look for this texture filename
|
|
uint noiseTile;
|
|
for (noiseTile=0; noiseTile<_DisplacementMap.size(); noiseTile++)
|
|
{
|
|
// Same name ?
|
|
if (lower==_DisplacementMap[noiseTile]._FileName)
|
|
return noiseTile;
|
|
}
|
|
|
|
// Look for a free space
|
|
for (noiseTile=0; noiseTile<_DisplacementMap.size(); noiseTile++)
|
|
{
|
|
// Same name ?
|
|
if (_DisplacementMap[noiseTile]._FileName=="")
|
|
break;
|
|
}
|
|
if (noiseTile==_DisplacementMap.size())
|
|
{
|
|
// Add a tile
|
|
_DisplacementMap.resize (noiseTile+1);
|
|
}
|
|
|
|
// Set the file name
|
|
_DisplacementMap[noiseTile]._FileName=lower;
|
|
|
|
return noiseTile;
|
|
}
|
|
// ***************************************************************************
|
|
const char* CTileBank::getDisplacementMap (uint noiseMap)
|
|
{
|
|
return _DisplacementMap[noiseMap]._FileName.c_str();
|
|
}
|
|
// ***************************************************************************
|
|
void CTileBank::setDisplacementMap (uint noiseMap, const char *newName)
|
|
{
|
|
_DisplacementMap[noiseMap]._FileName=newName;
|
|
}
|
|
// ***************************************************************************
|
|
uint CTileBank::getDisplacementMapCount () const
|
|
{
|
|
return (uint)_DisplacementMap.size();
|
|
}
|
|
|
|
|
|
// ***************************************************************************
|
|
const CTileVegetableDesc &CTileBank::getTileVegetableDesc(uint tileNumber) const
|
|
{
|
|
// Check tile number..
|
|
if (tileNumber<_TileVector.size())
|
|
{
|
|
// Get tileset number
|
|
uint tileSet=_TileXRef[tileNumber]._XRefTileSet;
|
|
|
|
// Checks
|
|
if (tileSet<_TileSetVector.size())
|
|
{
|
|
return _TileSetVector[tileSet].getTileVegetableDesc();
|
|
}
|
|
|
|
}
|
|
|
|
// if fails for any reason, return an empty tileVegetableDesc;
|
|
static CTileVegetableDesc emptyTvd;
|
|
return emptyTvd;
|
|
}
|
|
|
|
|
|
// ***************************************************************************
|
|
void CTileBank::loadTileVegetableDescs()
|
|
{
|
|
// For all tileSets.
|
|
uint tileSet;
|
|
|
|
for(tileSet=0; tileSet<_TileSetVector.size(); tileSet++)
|
|
{
|
|
// load their fileName
|
|
_TileSetVector[tileSet].loadTileVegetableDesc();
|
|
}
|
|
}
|
|
|
|
|
|
// ***************************************************************************
|
|
void CTileBank::initTileVegetableDescs(CVegetableManager *vegetableManager)
|
|
{
|
|
// For all tileSets.
|
|
uint tileSet;
|
|
|
|
for(tileSet=0; tileSet<_TileSetVector.size(); tileSet++)
|
|
{
|
|
CTileVegetableDesc &tvd= _TileSetVector[tileSet].getTileVegetableDesc();
|
|
tvd.registerToManager(vegetableManager);
|
|
}
|
|
}
|
|
|
|
|
|
// ***************************************************************************
|
|
void CTileBank::postfixTileFilename (const char *postfix)
|
|
{
|
|
// For each tiles
|
|
uint tile;
|
|
for (tile=0; tile<_TileVector.size (); tile++)
|
|
{
|
|
// For each bitmap
|
|
uint bitmap;
|
|
for (bitmap=0; bitmap<CTile::bitmapCount; bitmap++)
|
|
{
|
|
string &filename = _TileVector[tile]._BitmapName[bitmap];
|
|
if (!filename.empty())
|
|
{
|
|
string ext = CFile::getExtension(filename);
|
|
string name = CFile::getFilenameWithoutExtension(filename);
|
|
filename = CFile::getPath (filename);
|
|
filename += name;
|
|
filename += postfix;
|
|
filename += ".";
|
|
filename += ext;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
// ***************************************************************************
|
|
void CTileBank::postfixTileVegetableDesc (const char *postfix)
|
|
{
|
|
// For each tiles
|
|
uint tileSet;
|
|
for (tileSet=0; tileSet<_TileSetVector.size (); tileSet++)
|
|
{
|
|
string &filename = _TileSetVector[tileSet]._TileVegetableDescFileName;
|
|
if (!filename.empty())
|
|
{
|
|
string ext = CFile::getExtension(filename);
|
|
string name = CFile::getFilenameWithoutExtension(filename);
|
|
filename = CFile::getPath (filename);
|
|
filename += name;
|
|
filename += postfix;
|
|
filename += ".";
|
|
filename += ext;
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
// ***************************************************************************
|
|
// ***************************************************************************
|
|
// CTile.
|
|
// ***************************************************************************
|
|
// ***************************************************************************
|
|
|
|
|
|
// ***************************************************************************
|
|
const sint CTile::_Version=4;
|
|
// ***************************************************************************
|
|
void CTile::serial(NLMISC::IStream &f) throw(NLMISC::EStream)
|
|
{
|
|
sint streamver = f.serialVersion(_Version);
|
|
|
|
// Tmp value
|
|
bool tmp;
|
|
string tmpStr;
|
|
|
|
switch (streamver)
|
|
{
|
|
case 4:
|
|
case 3:
|
|
case 2:
|
|
f.serial (_Flags);
|
|
|
|
// Version 2, flags are not the same
|
|
if (streamver==2)
|
|
_Flags=(_Flags&NL3D_CTILE_ROT_MASK)|(_Flags&NL3D_CTILE_GROUP_MASK_V2)|(((_Flags&NL3D_CTILE_FREE_FLAG_V2)!=0)?NL3D_CTILE_FREE_FLAG:0);
|
|
if (streamver==3)
|
|
_Flags=(_Flags&NL3D_CTILE_ROT_MASK)|(_Flags&NL3D_CTILE_GROUP_MASK_V3)|(((_Flags&NL3D_CTILE_FREE_FLAG_V3)!=0)?NL3D_CTILE_FREE_FLAG:0);
|
|
|
|
f.serial (_BitmapName[diffuse]);
|
|
f.serial (_BitmapName[additive]);
|
|
f.serial (_BitmapName[alpha]);
|
|
break;
|
|
case 1:
|
|
// Don't need invert many more
|
|
f.serial (tmp);
|
|
case 0:
|
|
// Initialize flags
|
|
_Flags=0;
|
|
|
|
// Initialize alpha name
|
|
_BitmapName[alpha]="";
|
|
|
|
// Read free flag
|
|
f.serial (tmp);
|
|
|
|
// If free, set the flag
|
|
if (tmp)
|
|
_Flags|=NL3D_CTILE_FREE_FLAG;
|
|
|
|
// Read diffuse bitmap and additive
|
|
f.serial (_BitmapName[diffuse]);
|
|
f.serial (_BitmapName[additive]);
|
|
|
|
// Don't need bump name
|
|
f.serial (tmpStr);
|
|
|
|
break;
|
|
}
|
|
}
|
|
// ***************************************************************************
|
|
void CTile::clearTile (CTile::TBitmap type)
|
|
{
|
|
_BitmapName[type]="";
|
|
}
|
|
|
|
|
|
// ***************************************************************************
|
|
// ***************************************************************************
|
|
// CTileSet.
|
|
// ***************************************************************************
|
|
// ***************************************************************************
|
|
|
|
|
|
// ***************************************************************************
|
|
const sint CTileSet::_Version=5;
|
|
// ***************************************************************************
|
|
const char* CTileSet::_ErrorMessage[CTileSet::errorCount]=
|
|
{
|
|
"No error.", // ok
|
|
"Top interface is incompatible.", // topInterfaceProblem
|
|
"Bottom interface is incompatible.", // bottomInterfaceProblem
|
|
"Left interface is incompatible.", // leftInterfaceProblem
|
|
"Right interface is incompatible.", // rightInterfaceProblem
|
|
"Add first a 128x128 tile.", // addFirstA128128
|
|
"Top and bottom interface not the same.", // topBottomNotTheSame,
|
|
"Right and left interface not the same.", // rightLeftNotTheSame
|
|
"Invalide bitmap size.", // sizeInvalide
|
|
};
|
|
// ***************************************************************************
|
|
const CTileSet::TFlagBorder CTileSet::_TransitionFlags[CTileSet::count][4]=
|
|
{
|
|
{_0000,_1111,_0111,_0111}, // tile 0
|
|
{_0111,_1111,_0111,_1111}, // tile 1
|
|
{_0000,_0111,_0000,_0111}, // tile 2
|
|
{_1110,_1110,_1111,_0000}, // tile 3
|
|
{_1110,_1111,_1111,_0111}, // tile 4
|
|
{_0000,_1110,_0111,_0000}, // tile 5
|
|
|
|
{_0000,_1111,_0001,_0001}, // tile 6
|
|
{_0000,_1000,_0001,_0000}, // tile 7
|
|
{_1111,_1000,_1111,_1000}, // tile 8
|
|
{_1000,_1000,_1111,_0000}, // tile 9
|
|
{_1000,_0000,_1000,_0000}, // tile 10
|
|
{_1111,_0001,_1000,_1111}, // tile 11
|
|
|
|
{_0000,_1111,_0111,_0001}, // tile 12
|
|
{_0000,_1111,_0001,_0111}, // tile 13
|
|
{_0111,_1111,_0001,_1111}, // tile 14
|
|
{_1110,_1000,_1111,_0000}, // tile 15
|
|
{_1000,_1110,_1111,_0000}, // tile 16
|
|
{_1111,_0001,_1110,_1111}, // tile 17
|
|
|
|
{_1000,_0000,_1110,_0000}, // tile 18
|
|
{_0000,_0111,_0000,_0001}, // tile 19
|
|
{_1111,_1000,_1111,_1110}, // tile 21
|
|
{_0111,_0000,_0000,_1000}, // tile 21
|
|
{_0000,_1000,_0111,_0000}, // tile 22
|
|
{_1111,_0111,_1000,_1111}, // tile 23
|
|
|
|
{_1111,_0000,_1110,_1110}, // tile 24
|
|
{_1111,_1110,_1111,_1110}, // tile 25
|
|
{_1110,_0000,_1110,_0000}, // tile 26
|
|
{_0111,_0111,_0000,_1111}, // tile 27
|
|
{_1111,_0111,_1110,_1111}, // tile 28
|
|
{_0111,_0000,_0000,_1110}, // tile 29
|
|
|
|
{_1111,_0000,_1000,_1000}, // tile 30
|
|
{_0001,_0000,_0000,_1000}, // tile 31
|
|
{_0001,_1111,_0001,_1111}, // tile 32
|
|
{_0001,_0001,_0000,_1111}, // tile 33
|
|
{_0000,_0001,_0000,_0001}, // tile 34
|
|
{_1000,_1111,_1111,_0001}, // tile 35
|
|
|
|
{_1111,_0000,_1000,_1110}, // tile 36
|
|
{_1111,_0000,_1110,_1000}, // tile 37
|
|
{_1000,_1111,_1111,_0111}, // tile 38
|
|
{_0001,_0111,_0000,_1111}, // tile 39
|
|
{_0111,_0001,_0000,_1111}, // tile 40
|
|
{_1111,_1110,_1111,_1000}, // tile 41
|
|
|
|
{_0000,_0001,_0000,_0111}, // tile 42
|
|
{_1110,_0000,_1000,_0000}, // tile 43
|
|
{_0001,_1111,_0111,_1111}, // tile 44
|
|
{_0000,_1110,_0001,_0000}, // tile 45
|
|
{_0001,_0000,_0000,_1110}, // tile 46
|
|
{_1110,_1111,_1111,_0001} // tile 47
|
|
};
|
|
// ***************************************************************************
|
|
CTileSet::CTileSet ()
|
|
{
|
|
// Default, tileset 0
|
|
_Oriented = false;
|
|
uint displace;
|
|
for (displace=FirstDisplace; displace<CountDisplace; displace++)
|
|
_DisplacementBitmap[displace]=0;
|
|
|
|
// Default user surface data
|
|
SurfaceData = 0;
|
|
}
|
|
// ***************************************************************************
|
|
void CTileSet::setName (const std::string& name)
|
|
{
|
|
_Name=name;
|
|
}
|
|
// ***************************************************************************
|
|
const std::string& CTileSet::getName () const
|
|
{
|
|
return _Name;
|
|
}
|
|
// ***************************************************************************
|
|
void CTileSet::serial(NLMISC::IStream &f) throw(NLMISC::EStream)
|
|
{
|
|
sint streamver = f.serialVersion(_Version);
|
|
|
|
CTileBorder tmp;
|
|
|
|
// serial the user surface data
|
|
if (streamver>=5)
|
|
{
|
|
f.serial (SurfaceData);
|
|
}
|
|
|
|
// serial the oriented info which tell if the tile has a special orientation
|
|
if (streamver>=4)
|
|
{
|
|
f.serial (_Oriented);
|
|
}
|
|
|
|
// serial vegetable info.
|
|
if (streamver>=3)
|
|
{
|
|
// serialisze only the FileName, not the descrpitor
|
|
f.serial(_TileVegetableDescFileName);
|
|
}
|
|
|
|
// New version
|
|
if (streamver>=2)
|
|
{
|
|
uint displace;
|
|
for (displace=FirstDisplace; displace<CountDisplace; displace++)
|
|
f.serial (_DisplacementBitmap[displace]);
|
|
}
|
|
|
|
// Serial displacement map filename, obsolete
|
|
if (streamver==1)
|
|
{
|
|
// Remove obsolete data
|
|
string tmp;
|
|
for (uint displace=FirstDisplace; displace<CountDisplace; displace++)
|
|
f.serial (tmp);
|
|
}
|
|
|
|
int i;
|
|
f.serial (_Name);
|
|
f.serialCont (_Tile128);
|
|
f.serialCont (_Tile256);
|
|
for (i=0; i<count; i++)
|
|
f.serial (_TileTransition[i]);
|
|
f.serialCont (_ChildName);
|
|
f.serial (_Border128[CTile::diffuse]);
|
|
f.serial (_Border128[CTile::additive]);
|
|
|
|
// old field, border bump 128
|
|
if (streamver==0)
|
|
f.serial (tmp);
|
|
|
|
f.serial (_Border256[CTile::diffuse]);
|
|
f.serial (_Border256[CTile::additive]);
|
|
|
|
// old field, border bump 256
|
|
if (streamver==0)
|
|
f.serial (tmp);
|
|
|
|
for (i=0; i<count; i++)
|
|
{
|
|
f.serial (_BorderTransition[i][CTile::diffuse]);
|
|
f.serial (_BorderTransition[i][CTile::additive]);
|
|
f.serial (_BorderTransition[i][CTile::alpha]);
|
|
|
|
// Reset the diffuse and alpha border if old version
|
|
if (streamver==0)
|
|
{
|
|
_BorderTransition[i][CTile::diffuse].reset();
|
|
_BorderTransition[i][CTile::alpha].reset();
|
|
}
|
|
}
|
|
}
|
|
// ***************************************************************************
|
|
void CTileSet::addTile128 (int& indexInTileSet, CTileBank& bank)
|
|
{
|
|
// Create a tile
|
|
sint index=bank.createTile ();
|
|
|
|
// Index of the new tile
|
|
indexInTileSet=(int)_Tile128.size();
|
|
|
|
// Add to the end of the list
|
|
_Tile128.push_back (index);
|
|
}
|
|
// ***************************************************************************
|
|
void CTileSet::setBorder (CTile::TBitmap type, const CTileBorder& border)
|
|
{
|
|
// This is our new border desc
|
|
_Border128[type]=border;
|
|
_Border256[type]=border;
|
|
_Border256[type].doubleSize ();
|
|
}
|
|
// ***************************************************************************
|
|
void CTileSet::setTile128 (int indexInTileSet, const std::string& name, CTile::TBitmap type, CTileBank& bank)
|
|
{
|
|
// Edit a tile
|
|
CTile *tile=bank.getTile (_Tile128[indexInTileSet]);
|
|
tile->setFileName (type, name);
|
|
tile->setRotAlpha (0);
|
|
}
|
|
// ***************************************************************************
|
|
CTileSet::TError CTileSet::checkTile128 (CTile::TBitmap type, const CTileBorder& border, int& pixel, int& composante)
|
|
{
|
|
// Self check
|
|
if ((border.getWidth()!=128)||(border.getHeight()!=128))
|
|
return sizeInvalide;
|
|
if (!CTileBorder::compare (border, border, CTileBorder::top, CTileBorder::bottom, pixel, composante))
|
|
return topBottomNotTheSame;
|
|
if (!CTileBorder::compare (border, border, CTileBorder::left, CTileBorder::right, pixel, composante))
|
|
return rightLeftNotTheSame;
|
|
|
|
// Check
|
|
if (_Border128[type].isSet())
|
|
{
|
|
// Other check
|
|
if (!CTileBorder::compare (border, _Border128[type], CTileBorder::top, CTileBorder::top, pixel, composante))
|
|
return topInterfaceProblem;
|
|
if (!CTileBorder::compare (border, _Border128[type], CTileBorder::bottom, CTileBorder::bottom, pixel, composante))
|
|
return bottomInterfaceProblem;
|
|
if (!CTileBorder::compare (border, _Border128[type], CTileBorder::left, CTileBorder::left, pixel, composante))
|
|
return leftInterfaceProblem;
|
|
if (!CTileBorder::compare (border, _Border128[type], CTileBorder::right, CTileBorder::right, pixel, composante))
|
|
return rightInterfaceProblem;
|
|
}
|
|
else
|
|
{
|
|
return addFirstA128128;
|
|
}
|
|
|
|
return ok;
|
|
}
|
|
// ***************************************************************************
|
|
void CTileSet::addTile256 (int& indexInTileSet, CTileBank& bank)
|
|
{
|
|
// Create a tile
|
|
sint index=bank.createTile ();
|
|
|
|
// Index of the new tile
|
|
indexInTileSet=(int)_Tile256.size();
|
|
|
|
// Add to the end of the list
|
|
_Tile256.push_back (index);
|
|
}
|
|
// ***************************************************************************
|
|
CTileSet::TError CTileSet::checkTile256 (CTile::TBitmap type, const CTileBorder& border, int& pixel, int& composante)
|
|
{
|
|
// Self check
|
|
if ((border.getWidth()!=256)||(border.getHeight()!=256))
|
|
return sizeInvalide;
|
|
if (!CTileBorder::compare (border, border, CTileBorder::top, CTileBorder::bottom, pixel, composante))
|
|
return topBottomNotTheSame;
|
|
if (!CTileBorder::compare (border, border, CTileBorder::left, CTileBorder::right, pixel, composante))
|
|
return rightLeftNotTheSame;
|
|
|
|
// Check if prb
|
|
if ((!_Border256[type].isSet())&&(_Border128[type].isSet()))
|
|
{
|
|
_Border256[type]=_Border128[type];
|
|
_Border256[type].doubleSize ();
|
|
}
|
|
|
|
// Check
|
|
if (_Border256[type].isSet())
|
|
{
|
|
|
|
// Other check
|
|
if (!CTileBorder::compare (border, _Border256[type], CTileBorder::top, CTileBorder::top, pixel, composante))
|
|
return topInterfaceProblem;
|
|
if (!CTileBorder::compare (border, _Border256[type], CTileBorder::bottom, CTileBorder::bottom, pixel, composante))
|
|
return bottomInterfaceProblem;
|
|
if (!CTileBorder::compare (border, _Border256[type], CTileBorder::left, CTileBorder::left, pixel, composante))
|
|
return leftInterfaceProblem;
|
|
if (!CTileBorder::compare (border, _Border256[type], CTileBorder::right, CTileBorder::right, pixel, composante))
|
|
return rightInterfaceProblem;
|
|
}
|
|
else
|
|
{
|
|
return addFirstA128128;
|
|
}
|
|
|
|
return ok;
|
|
}
|
|
// ***************************************************************************
|
|
void CTileSet::setTile256 (int indexInTileSet, const std::string& name, CTile::TBitmap type, CTileBank& bank)
|
|
{
|
|
// Edit a tile
|
|
CTile *tile=bank.getTile (_Tile256[indexInTileSet]);
|
|
tile->setFileName (type, name);
|
|
tile->setRotAlpha (0);
|
|
}
|
|
// ***************************************************************************
|
|
void CTileSet::setTileTransition (TTransition transition, const std::string& name, CTile::TBitmap type, CTileBank& bank,
|
|
const CTileBorder& border)
|
|
{
|
|
// Check is not an alpha channel
|
|
nlassert (type!=CTile::alpha); // use setTileTransitionAlpha
|
|
|
|
// Create a tile
|
|
_BorderTransition[transition][type]=border;
|
|
|
|
// Set the tile file name
|
|
CTile *tile=bank.getTile (_TileTransition[transition]._Tile);
|
|
tile->setFileName (type, name);
|
|
}
|
|
// ***************************************************************************
|
|
void CTileSet::setTileTransitionAlpha (TTransition transition, const std::string& name, CTileBank& bank,
|
|
const CTileBorder& border, uint8 rot)
|
|
{
|
|
// Check some args
|
|
nlassert (rot<4);
|
|
|
|
// Create a tile
|
|
_BorderTransition[transition][CTile::alpha]=border;
|
|
|
|
// Set the tile file name
|
|
CTile *tile=bank.getTile (_TileTransition[transition]._Tile);
|
|
tile->setFileName (CTile::alpha, name);
|
|
tile->setRotAlpha (rot);
|
|
}
|
|
// ***************************************************************************
|
|
CTileSet::TError CTileSet::checkTileTransition (TTransition transition, CTile::TBitmap type, const CTileBorder& border, int& indexError,
|
|
int& pixel, int& composante)
|
|
{
|
|
nlassert (transition>=0);
|
|
nlassert (transition<count);
|
|
|
|
// Check
|
|
indexError=-1;
|
|
|
|
// Top
|
|
indexError=getExistingTransitionTile ((TFlagBorder)_TransitionFlags[transition][top], dontcare, dontcare, dontcare, transition, type);
|
|
if (indexError!=-1)
|
|
{
|
|
if (!CTileBorder::compare (border, _BorderTransition[indexError][type], CTileBorder::top, CTileBorder::top, pixel, composante))
|
|
return topInterfaceProblem;
|
|
}
|
|
indexError=getExistingTransitionTile (dontcare, (TFlagBorder)_TransitionFlags[transition][top], dontcare, dontcare, transition, type);
|
|
if (indexError!=-1)
|
|
{
|
|
if (!CTileBorder::compare (border, _BorderTransition[indexError][type], CTileBorder::top, CTileBorder::bottom, pixel, composante))
|
|
return topInterfaceProblem;
|
|
}
|
|
indexError=-1;
|
|
if (_TransitionFlags[transition][top]==_1111)
|
|
{
|
|
if (!CTileBorder::allAlphaSet (border, CTileBorder::top, pixel, composante))
|
|
return topInterfaceProblem;
|
|
}
|
|
|
|
// Bottom
|
|
indexError=getExistingTransitionTile (dontcare, (TFlagBorder)_TransitionFlags[transition][bottom], dontcare, dontcare, transition, type);
|
|
if (indexError!=-1)
|
|
{
|
|
if (!CTileBorder::compare (border, _BorderTransition[indexError][type], CTileBorder::bottom, CTileBorder::bottom, pixel, composante))
|
|
return bottomInterfaceProblem;
|
|
}
|
|
indexError=getExistingTransitionTile ((TFlagBorder)_TransitionFlags[transition][bottom], dontcare, dontcare, dontcare, transition, type);
|
|
if (indexError!=-1)
|
|
{
|
|
if (!CTileBorder::compare (border, _BorderTransition[indexError][type], CTileBorder::bottom, CTileBorder::top, pixel, composante))
|
|
return bottomInterfaceProblem;
|
|
}
|
|
indexError=-1;
|
|
if (_TransitionFlags[transition][bottom]==_1111)
|
|
{
|
|
if (!CTileBorder::allAlphaSet (border, CTileBorder::bottom, pixel, composante))
|
|
return bottomInterfaceProblem;
|
|
}
|
|
|
|
// Left
|
|
indexError=getExistingTransitionTile (dontcare, dontcare, (TFlagBorder)_TransitionFlags[transition][left], dontcare, transition, type);
|
|
if (indexError!=-1)
|
|
{
|
|
if (!CTileBorder::compare (border, _BorderTransition[indexError][type], CTileBorder::left, CTileBorder::left, pixel, composante))
|
|
return leftInterfaceProblem;
|
|
}
|
|
indexError=getExistingTransitionTile (dontcare, dontcare, dontcare, (TFlagBorder)_TransitionFlags[transition][left], transition, type);
|
|
if (indexError!=-1)
|
|
{
|
|
if (!CTileBorder::compare (border, _BorderTransition[indexError][type], CTileBorder::left, CTileBorder::right, pixel, composante))
|
|
return leftInterfaceProblem;
|
|
}
|
|
indexError=-1;
|
|
if (_TransitionFlags[transition][left]==_1111)
|
|
{
|
|
if (!CTileBorder::allAlphaSet (border, CTileBorder::left, pixel, composante))
|
|
return leftInterfaceProblem;
|
|
}
|
|
|
|
// Right
|
|
indexError=getExistingTransitionTile (dontcare, dontcare, dontcare, (TFlagBorder)_TransitionFlags[transition][right], transition, type);
|
|
if (indexError!=-1)
|
|
{
|
|
if (!CTileBorder::compare (border, _BorderTransition[indexError][type], CTileBorder::right, CTileBorder::right, pixel, composante))
|
|
return rightInterfaceProblem;
|
|
}
|
|
indexError=getExistingTransitionTile (dontcare, dontcare, (TFlagBorder)_TransitionFlags[transition][right], dontcare, transition, type);
|
|
if (indexError!=-1)
|
|
{
|
|
if (!CTileBorder::compare (border, _BorderTransition[indexError][type], CTileBorder::right, CTileBorder::left, pixel, composante))
|
|
return rightInterfaceProblem;
|
|
}
|
|
indexError=-1;
|
|
if (_TransitionFlags[transition][right]==_1111)
|
|
{
|
|
if (!CTileBorder::allAlphaSet (border, CTileBorder::right, pixel, composante))
|
|
return rightInterfaceProblem;
|
|
}
|
|
return ok;
|
|
}
|
|
// ***************************************************************************
|
|
void CTileSet::removeTile128 (int indexInTileSet, CTileBank& bank)
|
|
{
|
|
// Check args
|
|
nlassert (indexInTileSet>=0);
|
|
nlassert (indexInTileSet<(sint)_Tile128.size());
|
|
|
|
// Old index
|
|
int index=_Tile128[indexInTileSet];
|
|
|
|
// Erase
|
|
_Tile128.erase (_Tile128.begin()+indexInTileSet);
|
|
bank.freeTile (index);
|
|
|
|
// Erase border if it is the last texture
|
|
deleteBordersIfLast (bank, CTile::diffuse);
|
|
deleteBordersIfLast (bank, CTile::additive);
|
|
deleteBordersIfLast (bank, CTile::alpha);
|
|
}
|
|
// ***************************************************************************
|
|
void CTileSet::removeTile256 (int indexInTileSet, CTileBank& bank)
|
|
{
|
|
// Check args
|
|
nlassert (indexInTileSet>=0);
|
|
nlassert (indexInTileSet<(sint)_Tile256.size());
|
|
|
|
// Old index
|
|
int index=_Tile256[indexInTileSet];
|
|
|
|
// Erase
|
|
_Tile256.erase (_Tile256.begin()+indexInTileSet);
|
|
bank.freeTile (index);
|
|
|
|
// Erase border if it is the last texture
|
|
deleteBordersIfLast (bank, CTile::diffuse);
|
|
deleteBordersIfLast (bank, CTile::additive);
|
|
deleteBordersIfLast (bank, CTile::alpha);
|
|
}
|
|
// ***************************************************************************
|
|
CTileSet::TTransition CTileSet::getTransitionTile (TFlagBorder _top, TFlagBorder _bottom, TFlagBorder _left, TFlagBorder _right)
|
|
{
|
|
for (int n=first; n<count; n++)
|
|
{
|
|
if (((_top==dontcare)||(_top==(TFlagBorder)_TransitionFlags[n][top]))&&
|
|
((_bottom==dontcare)||(_bottom==(TFlagBorder)_TransitionFlags[n][bottom]))&&
|
|
((_left==dontcare)||(_left==(TFlagBorder)_TransitionFlags[n][left]))&&
|
|
((_right==dontcare)||(_right==(TFlagBorder)_TransitionFlags[n][right])))
|
|
{
|
|
return (TTransition)n;
|
|
}
|
|
}
|
|
return notfound;
|
|
}
|
|
// ***************************************************************************
|
|
CTileSet::TTransition CTileSet::getExistingTransitionTile (TFlagBorder _top, TFlagBorder _bottom, TFlagBorder _left, TFlagBorder _right, int reject, CTile::TBitmap type)
|
|
{
|
|
for (int n=first; n<count; n++)
|
|
{
|
|
if ((n!=reject)&&
|
|
(_BorderTransition[n][type].isSet ())&&
|
|
((_top==dontcare)||(_top==(TFlagBorder)_TransitionFlags[n][top]))&&
|
|
((_bottom==dontcare)||(_bottom==(TFlagBorder)_TransitionFlags[n][bottom]))&&
|
|
((_left==dontcare)||(_left==(TFlagBorder)_TransitionFlags[n][left]))&&
|
|
((_right==dontcare)||(_right==(TFlagBorder)_TransitionFlags[n][right])))
|
|
{
|
|
return (TTransition)n;
|
|
}
|
|
}
|
|
return notfound;
|
|
}
|
|
// ***************************************************************************
|
|
void CTileSet::addChild (const std::string& name)
|
|
{
|
|
_ChildName.insert (name);
|
|
}
|
|
// ***************************************************************************
|
|
void CTileSet::removeChild (const std::string& name)
|
|
{
|
|
_ChildName.erase (name);
|
|
}
|
|
// ***************************************************************************
|
|
CTileSet::TTransition CTileSet::getComplementaryTransition (TTransition transition)
|
|
{
|
|
nlassert ((transition>=first)&&(transition<=last));
|
|
TTransition trans=getTransitionTile (getComplementaryBorder (_TransitionFlags[transition][top]),
|
|
getComplementaryBorder (_TransitionFlags[transition][bottom]),
|
|
getComplementaryBorder (_TransitionFlags[transition][left]),
|
|
getComplementaryBorder (_TransitionFlags[transition][right]));
|
|
|
|
nlassert (trans!=notfound);
|
|
|
|
return trans;
|
|
}
|
|
// ***************************************************************************
|
|
CTileSet::TFlagBorder CTileSet::getComplementaryBorder (TFlagBorder border)
|
|
{
|
|
switch (border)
|
|
{
|
|
case _0000:
|
|
return _1111;
|
|
case _0001:
|
|
return _1110;
|
|
case _0111:
|
|
return _1000;
|
|
case _1000:
|
|
return _0111;
|
|
case _1110:
|
|
return _0001;
|
|
case _1111:
|
|
return _0000;
|
|
default:
|
|
nlassert (0); // no
|
|
}
|
|
return _0000;
|
|
}
|
|
// ***************************************************************************
|
|
CTileSet::TFlagBorder CTileSet::getInvertBorder (TFlagBorder border)
|
|
{
|
|
switch (border)
|
|
{
|
|
case _0000:
|
|
return _0000;
|
|
case _0001:
|
|
return _1000;
|
|
case _0111:
|
|
return _1110;
|
|
case _1000:
|
|
return _0001;
|
|
case _1110:
|
|
return _0111;
|
|
case _1111:
|
|
return _1111;
|
|
default:
|
|
nlassert (0); // no
|
|
}
|
|
return _0000;
|
|
}
|
|
// ***************************************************************************
|
|
CTileSet::TFlagBorder CTileSet::getOrientedBorder (TBorder where, TFlagBorder border)
|
|
{
|
|
switch (where)
|
|
{
|
|
case left:
|
|
case bottom:
|
|
return border;
|
|
case top:
|
|
case right:
|
|
return getInvertBorder (border);
|
|
default:
|
|
nlassert (0); // no
|
|
}
|
|
return _0000;
|
|
}
|
|
// ***************************************************************************
|
|
CTileSet::TTransition CTileSet::rotateTransition (TTransition transition)
|
|
{
|
|
return getTransitionTile (
|
|
getOrientedBorder (top, getOrientedBorder (right, _TransitionFlags[transition][right])), // top
|
|
getOrientedBorder (bottom, getOrientedBorder (left, _TransitionFlags[transition][left])), // bottom
|
|
getOrientedBorder (left, getOrientedBorder (top, _TransitionFlags[transition][top])), // left
|
|
getOrientedBorder (right, getOrientedBorder (bottom, _TransitionFlags[transition][bottom])) // right
|
|
);
|
|
}
|
|
// ***************************************************************************
|
|
void CTileSet::clearTile128 (int indexInTileSet, CTile::TBitmap type, CTileBank& bank)
|
|
{
|
|
int nTile=_Tile128[indexInTileSet];
|
|
bank.getTile (nTile)->clearTile(type);
|
|
|
|
// Erase border if it is the last texture
|
|
deleteBordersIfLast (bank, type);
|
|
}
|
|
// ***************************************************************************
|
|
void CTileSet::clearTile256 (int indexInTileSet, CTile::TBitmap type, CTileBank& bank)
|
|
{
|
|
int nTile=_Tile256[indexInTileSet];
|
|
bank.getTile (nTile)->clearTile(type);
|
|
|
|
// Erase border if it is the last texture
|
|
deleteBordersIfLast (bank, type);
|
|
}
|
|
// ***************************************************************************
|
|
void CTileSet::clearTransition (TTransition transition, CTile::TBitmap type, CTileBank& bank)
|
|
{
|
|
int nTile=_TileTransition[transition]._Tile;
|
|
if (nTile!=-1)
|
|
bank.getTile (nTile)->clearTile(type);
|
|
_BorderTransition[transition][type].reset();
|
|
|
|
// Erase border if it is the last texture
|
|
deleteBordersIfLast (bank, type);
|
|
}
|
|
// ***************************************************************************
|
|
// Delete 128 and 256 borders if no more valid texture file name for each bitmap type.
|
|
void CTileSet::deleteBordersIfLast (const CTileBank& bank, CTile::TBitmap type)
|
|
{
|
|
// delete is true
|
|
bool bDelete=true;
|
|
|
|
// iterator..
|
|
std::vector<sint32>::iterator ite=_Tile128.begin();
|
|
|
|
// Check all the 128x128 tiles
|
|
while (ite!=_Tile128.end())
|
|
{
|
|
// If the file name is valid
|
|
if (bank.getTile (*ite)->getRelativeFileName(type)!="")
|
|
{
|
|
// Don't delete,
|
|
bDelete=false;
|
|
break;
|
|
}
|
|
ite++;
|
|
}
|
|
// If break, not empty, return
|
|
if (ite!=_Tile128.end())
|
|
return;
|
|
|
|
// Check all the 256x256 tiles
|
|
ite=_Tile256.begin();
|
|
while (ite!=_Tile256.end())
|
|
{
|
|
// If the file name is valid
|
|
if (bank.getTile (*ite)->getRelativeFileName(type)!="")
|
|
{
|
|
// Don't delete,
|
|
bDelete=false;
|
|
break;
|
|
}
|
|
ite++;
|
|
}
|
|
// If break, not empty, return
|
|
if (ite!=_Tile256.end())
|
|
return;
|
|
|
|
|
|
// Check all the transitions tiles
|
|
sint trans;
|
|
for (trans=0; trans<count; trans++)
|
|
{
|
|
// Get the tile associed with the transition
|
|
int nTile=_TileTransition[trans]._Tile;
|
|
|
|
// If it is not NULL..
|
|
if (nTile!=-1)
|
|
{
|
|
// If the file name is valid
|
|
if (bank.getTile (nTile)->getRelativeFileName(type)!="")
|
|
{
|
|
// Don't delete,
|
|
bDelete=false;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
if (trans!=count)
|
|
return;
|
|
|
|
// Ok, erase borders because no tile use it anymore
|
|
_Border128[type].reset();
|
|
_Border256[type].reset();
|
|
}
|
|
// ***************************************************************************
|
|
void CTileSet::clearDisplacement (TDisplacement displacement, CTileBank& bank)
|
|
{
|
|
// checks
|
|
nlassert (displacement>=FirstDisplace);
|
|
nlassert (displacement<=LastDisplace);
|
|
|
|
// Backup the id
|
|
int id=_DisplacementBitmap[displacement];
|
|
|
|
// Clear map id
|
|
_DisplacementBitmap[displacement]=0;
|
|
|
|
// Tell the bank we remove it
|
|
bank.removeDisplacementMap (id);
|
|
}
|
|
// ***************************************************************************
|
|
void CTileSet::setDisplacement (TDisplacement displacement, const std::string& fileName, CTileBank& bank)
|
|
{
|
|
// checks
|
|
nlassert (displacement>=FirstDisplace);
|
|
nlassert (displacement<=LastDisplace);
|
|
|
|
// Clear it
|
|
bank.removeDisplacementMap (_DisplacementBitmap[displacement]);
|
|
|
|
// Get displacement map
|
|
_DisplacementBitmap[displacement]=bank.getDisplacementMap (fileName);
|
|
}
|
|
// ***************************************************************************
|
|
void CTileSet::cleanUnusedData ()
|
|
{
|
|
_Name="";
|
|
_ChildName.clear();
|
|
_Border128[0].reset ();
|
|
_Border128[1].reset ();
|
|
_Border256[0].reset ();
|
|
_Border256[1].reset ();
|
|
for (uint i=0; i<count; i++)
|
|
for (uint j=0; j<CTile::bitmapCount; j++)
|
|
_BorderTransition[i][j].reset();
|
|
}
|
|
|
|
|
|
// ***************************************************************************
|
|
void CTileSet::setTileVegetableDescFileName (const std::string &fileName)
|
|
{
|
|
_TileVegetableDescFileName= fileName;
|
|
}
|
|
// ***************************************************************************
|
|
const std::string& CTileSet::getTileVegetableDescFileName () const
|
|
{
|
|
return _TileVegetableDescFileName;
|
|
}
|
|
// ***************************************************************************
|
|
void CTileSet::setTileVegetableDesc (const CTileVegetableDesc &tvd)
|
|
{
|
|
_TileVegetableDesc= tvd;
|
|
}
|
|
|
|
// ***************************************************************************
|
|
CTileVegetableDesc &CTileSet::getTileVegetableDesc()
|
|
{
|
|
return _TileVegetableDesc;
|
|
}
|
|
|
|
// ***************************************************************************
|
|
const CTileVegetableDesc &CTileSet::getTileVegetableDesc() const
|
|
{
|
|
return _TileVegetableDesc;
|
|
}
|
|
|
|
// ***************************************************************************
|
|
void CTileSet::loadTileVegetableDesc()
|
|
{
|
|
if(_TileVegetableDescFileName!="")
|
|
{
|
|
try
|
|
{
|
|
string fname= CPath::lookup(_TileVegetableDescFileName);
|
|
CIFile f(fname);
|
|
// load the TileVegetableDesc
|
|
f.serial(_TileVegetableDesc);
|
|
}
|
|
catch(Exception &e)
|
|
{
|
|
nlinfo("Error loading TileVegetableDesc: %s", e.what());
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
// ***************************************************************************
|
|
// ***************************************************************************
|
|
// CTileBorder.
|
|
// ***************************************************************************
|
|
// ***************************************************************************
|
|
|
|
|
|
// ***************************************************************************
|
|
const sint CTileBorder::_Version=0;
|
|
// ***************************************************************************
|
|
void CTileBorder::serial(NLMISC::IStream &f) throw(NLMISC::EStream)
|
|
{
|
|
(void)f.serialVersion(_Version);
|
|
|
|
f.serial (_Set);
|
|
f.serial (_Width);
|
|
f.serial (_Height);
|
|
f.serialCont (_Borders[top]);
|
|
f.serialCont (_Borders[bottom]);
|
|
f.serialCont (_Borders[left]);
|
|
f.serialCont (_Borders[right]);
|
|
}
|
|
// ***************************************************************************
|
|
void CTileBorder::set (int width, int height, const std::vector<CBGRA>& array)
|
|
{
|
|
// Check array size
|
|
nlassert (width>0);
|
|
nlassert (height>0);
|
|
nlassert ((sint)array.size()==width*height);
|
|
|
|
// Copy size
|
|
_Width=width;
|
|
_Height=height;
|
|
|
|
// Last line
|
|
int lastLine=(_Height-1)*width;
|
|
int lastCol=(_Width-1);
|
|
_Borders[top].resize (_Width);
|
|
_Borders[bottom].resize (_Width);
|
|
_Borders[left].resize (_Height);
|
|
_Borders[right].resize (_Height);
|
|
|
|
// Copy top/bottom border
|
|
for (int w=0; w<_Width; w++)
|
|
{
|
|
_Borders[top][w]=array[w];
|
|
_Borders[bottom][w]=array[w+lastLine];
|
|
}
|
|
|
|
// Copy left/right border
|
|
for (int h=0; h<_Height; h++)
|
|
{
|
|
_Borders[left][h]=array[h*_Width];
|
|
_Borders[right][h]=array[h*_Width+lastCol];
|
|
}
|
|
|
|
// Set
|
|
_Set=true;
|
|
}
|
|
// ***************************************************************************
|
|
void CTileBorder::get (int &width, int &height, std::vector<CBGRA>& array) const
|
|
{
|
|
// Go
|
|
if (_Set)
|
|
{
|
|
width=_Width;
|
|
height=_Height;
|
|
array.resize (0);
|
|
array.resize (_Width*_Height);
|
|
nlassert (_Borders[bottom].size()==(uint)_Width);
|
|
nlassert (_Borders[top].size()==(uint)_Width);
|
|
nlassert (_Borders[left].size()==(uint)_Height);
|
|
nlassert (_Borders[right].size()==(uint)_Height);
|
|
|
|
// Fill
|
|
CBGRA black(0,0,0);
|
|
for (int p=0; p<_Width*_Height; p++)
|
|
{
|
|
array[p]=black;
|
|
}
|
|
|
|
// Last line
|
|
int lastLine=(_Height-1)*_Width;
|
|
int lastCol=(_Width-1);
|
|
|
|
// Copy top/bottom border
|
|
for (int w=0; w<_Width; w++)
|
|
{
|
|
array[w]=_Borders[top][w];
|
|
array[w+lastLine]=_Borders[bottom][w];
|
|
}
|
|
|
|
// Copy left/right border
|
|
for (int h=0; h<_Height; h++)
|
|
{
|
|
array[h*_Width]=_Borders[left][h];
|
|
array[h*_Width+lastCol]=_Borders[right][h];
|
|
}
|
|
}
|
|
else
|
|
{
|
|
width=0;
|
|
height=0;
|
|
array.resize (0);
|
|
}
|
|
}
|
|
// ***************************************************************************
|
|
bool CTileBorder::compare (const CTileBorder& border1, const CTileBorder& border2, TBorder where1, TBorder where2, int& pixel, int& composante)
|
|
{
|
|
// Check border is initialized
|
|
nlassert (border1.isSet());
|
|
nlassert (border2.isSet());
|
|
|
|
if (border1._Borders[where1].size()!=border2._Borders[where2].size())
|
|
return false;
|
|
for (pixel=0; pixel<(int)border1._Borders[where1].size(); pixel++)
|
|
{
|
|
if (border1._Borders[where1][pixel].R!=border2._Borders[where2][pixel].R)
|
|
{
|
|
composante=0;
|
|
return false;
|
|
}
|
|
else if (border1._Borders[where1][pixel].G!=border2._Borders[where2][pixel].G)
|
|
{
|
|
composante=1;
|
|
return false;
|
|
}
|
|
else if (border1._Borders[where1][pixel].B!=border2._Borders[where2][pixel].B)
|
|
{
|
|
composante=2;
|
|
return false;
|
|
}
|
|
else if (border1._Borders[where1][pixel].A!=border2._Borders[where2][pixel].A)
|
|
{
|
|
composante=3;
|
|
return false;
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
// ***************************************************************************
|
|
bool CTileBorder::allAlphaSet (const CTileBorder& border, TBorder where, int& pixel, int& composante)
|
|
{
|
|
// Check border is initialized
|
|
nlassert (border.isSet());
|
|
|
|
// always Alpha
|
|
composante=3;
|
|
|
|
for (pixel=0; pixel<(int)border._Borders[where].size(); pixel++)
|
|
{
|
|
if (border._Borders[where][pixel].A!=0xff)
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
// ***************************************************************************
|
|
bool CTileBorder::operator== (const CTileBorder& border) const
|
|
{
|
|
return (_Width==border._Width) && (_Height==border._Height) && (_Borders==border._Borders);
|
|
}
|
|
// ***************************************************************************
|
|
void CTileBorder::operator= (const CTileBorder& border)
|
|
{
|
|
_Set=border._Set;
|
|
_Width=border._Width;
|
|
_Height=border._Width;
|
|
_Borders[top]=border._Borders[top];
|
|
_Borders[bottom]=border._Borders[bottom];
|
|
_Borders[left]=border._Borders[left];
|
|
_Borders[right]=border._Borders[right];
|
|
}
|
|
|
|
// ***************************************************************************
|
|
void CTileBorder::doubleSize ()
|
|
{
|
|
_Borders[top].resize (_Width*2);
|
|
_Borders[bottom].resize (_Width*2);
|
|
_Borders[left].resize (_Height*2);
|
|
_Borders[right].resize (_Height*2);
|
|
|
|
for (int w=0; w<_Width; w++)
|
|
{
|
|
_Borders[top][w+_Width]=_Borders[top][w];
|
|
_Borders[bottom][w+_Width]=_Borders[bottom][w];
|
|
}
|
|
for (int h=0; h<_Height; h++)
|
|
{
|
|
_Borders[left][h+_Height]=_Borders[left][h];
|
|
_Borders[right][h+_Height]=_Borders[right][h];
|
|
}
|
|
}
|
|
// ***************************************************************************
|
|
void CTileBorder::rotate()
|
|
{
|
|
// Copy the right
|
|
std::vector<NLMISC::CBGRA> tmpLeft=_Borders[left];
|
|
|
|
// Top inverted becomes left
|
|
uint i, size;
|
|
size=(uint)_Borders[top].size();
|
|
_Borders[left].resize (size);
|
|
|
|
// copy inverted
|
|
for (i=0; i<size; i++)
|
|
_Borders[left][i]=_Borders[top][size-i-1];
|
|
|
|
// Right become top
|
|
_Borders[top]=_Borders[right];
|
|
|
|
// bottom inverted becomes right
|
|
size=(uint)_Borders[bottom].size();
|
|
_Borders[right].resize (size);
|
|
|
|
// copy inverted
|
|
for (i=0; i<size; i++)
|
|
_Borders[right][i]=_Borders[bottom][size-i-1];
|
|
|
|
// Left become bottom
|
|
_Borders[bottom]=tmpLeft;
|
|
|
|
// Invert size
|
|
sint32 tmpSize=_Width;
|
|
_Width=_Height;
|
|
_Height=tmpSize;
|
|
}
|
|
|
|
// ***************************************************************************
|
|
// ***************************************************************************
|
|
// CTileSetTransition.
|
|
// ***************************************************************************
|
|
// ***************************************************************************
|
|
|
|
|
|
// ***************************************************************************
|
|
const sint CTileSetTransition::_Version=1;
|
|
// ***************************************************************************
|
|
void CTileSetTransition::serial(class NLMISC::IStream &f) throw(EStream)
|
|
{
|
|
sint streamver = f.serialVersion(_Version);
|
|
|
|
switch (streamver)
|
|
{
|
|
case 0:
|
|
{
|
|
bool doomy;
|
|
f.serial (_Tile);
|
|
f.serial (doomy); // skip the old argu
|
|
}
|
|
break;
|
|
case 1:
|
|
f.serial (_Tile);
|
|
break;
|
|
}
|
|
}
|
|
// ***************************************************************************
|
|
|
|
|
|
// ***************************************************************************
|
|
// ***************************************************************************
|
|
// CTileNoise.
|
|
// ***************************************************************************
|
|
// ***************************************************************************
|
|
|
|
|
|
// ***************************************************************************
|
|
CTileNoise::CTileNoise ()
|
|
{
|
|
// Not loaded
|
|
_TileNoiseMap=NULL;
|
|
_FileName="";
|
|
}
|
|
// ***************************************************************************
|
|
CTileNoise::CTileNoise (const CTileNoise &src)
|
|
{
|
|
// Default ctor
|
|
_TileNoiseMap=NULL;
|
|
_FileName="";
|
|
|
|
// Copy
|
|
*this=src;
|
|
}
|
|
// ***************************************************************************
|
|
CTileNoise::~CTileNoise ()
|
|
{
|
|
if (_TileNoiseMap)
|
|
{
|
|
delete _TileNoiseMap;
|
|
_TileNoiseMap=NULL;
|
|
}
|
|
}
|
|
// ***************************************************************************
|
|
CTileNoise& CTileNoise::operator= (const CTileNoise &src)
|
|
{
|
|
// Copy the filename
|
|
_FileName=src._FileName;
|
|
|
|
// Tile noise map ?
|
|
if (src._TileNoiseMap)
|
|
{
|
|
if (_TileNoiseMap==NULL)
|
|
{
|
|
// Allocate it
|
|
_TileNoiseMap=new CTileNoiseMap;
|
|
}
|
|
|
|
// Copy the noise map
|
|
*_TileNoiseMap=*src._TileNoiseMap;
|
|
}
|
|
else
|
|
{
|
|
// Erase the map
|
|
if (_TileNoiseMap)
|
|
{
|
|
delete _TileNoiseMap;
|
|
_TileNoiseMap=NULL;
|
|
}
|
|
}
|
|
return *this;
|
|
}
|
|
// ***************************************************************************
|
|
void CTileNoise::serial (NLMISC::IStream& f)
|
|
{
|
|
// Version
|
|
f.serialVersion (0);
|
|
|
|
// Serial the file name
|
|
f.serial (_FileName);
|
|
}
|
|
// ***************************************************************************
|
|
void CTileNoise::setEmpty ()
|
|
{
|
|
// Reset it
|
|
reset();
|
|
_FileName="EmptyDisplacementMap";
|
|
_TileNoiseMap=new CTileNoiseMap();
|
|
memset (_TileNoiseMap->Pixels, 0, NL3D_TILE_NOISE_MAP_SIZE*NL3D_TILE_NOISE_MAP_SIZE);
|
|
}
|
|
// ***************************************************************************
|
|
void CTileNoise::reset()
|
|
{
|
|
// Erase the map
|
|
if (_TileNoiseMap)
|
|
{
|
|
delete _TileNoiseMap;
|
|
_TileNoiseMap=NULL;
|
|
}
|
|
|
|
// Erase filename
|
|
_FileName="";
|
|
}
|
|
// ***************************************************************************
|
|
|
|
} // NL3D
|