nel/tools/3d/tile_edit_qt/browser_model.cpp

   1 // NeL - MMORPG Framework <http://dev.ryzom.com/projects/nel/>
   2 // Copyright (C) 2010  Winch Gate Property Limited
   3 //
   4 // This source file has been modified by the following contributors:
   5 // Copyright (C) 2010  Matt RAYKOWSKI (sfb) <matt.raykowski@gmail.com>
   6 //
   7 // This program is free software: you can redistribute it and/or modify
   8 // it under the terms of the GNU Affero General Public License as
   9 // published by the Free Software Foundation, either version 3 of the
  10 // License, or (at your option) any later version.
  11 //
  12 // This program is distributed in the hope that it will be useful,
  13 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  14 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15 // GNU Affero General Public License for more details.
  16 //
  17 // You should have received a copy of the GNU Affero General Public License
  18 // along with this program.  If not, see <http://www.gnu.org/licenses/>.
  19
  20 #include "common.h"
  21 #include "browser_model.h"
  22
  23 using namespace std;
  24 using namespace NL3D;
  25 using namespace NLMISC;
  26
  27 extern CTileBank tileBankBrowser;
  28 static const char* comp[]={"Red", "Green", "Blue", "Alpha", ""};
  29
  30 static bool loadPic(const string &path, std::vector<NLMISC::CBGRA> &tampon, uint &width, uint &height)
  31 {
  32         try
  33         {
  34                 NLMISC::CIFile file;
  35                 if (file.open(path.c_str()))
  36                 {
  37                         NLMISC::CBitmap bitmap;
  38                         bitmap.load(file);
  39                         width = bitmap.getWidth();
  40                         height = bitmap.getHeight();
  41                         tampon.resize(width * height);
  42                         bitmap.convertToType(NLMISC::CBitmap::RGBA);
  43                         for (uint y = 0; y < height; ++y)
  44                         {
  45                                 for (uint x = 0; x < width; ++x)
  46                                 {
  47                                         NLMISC::CRGBA c = bitmap.getPixelColor(x, y, 0);
  48                                         c.R = (c.R * c.A) / 255;
  49                                         c.G = (c.G * c.A) / 255;
  50                                         c.B = (c.B * c.A) / 255;
  51                                         tampon[(y * width) + x] = c;
  52                                 }
  53                         }
  54                         return true;
  55                 }
  56         }
  57         catch (const NLMISC::Exception& ) { }
  58         return false;
  59 }
  60
  61 bool RemovePath (std::string& path, const char* absolutePathToRemplace);
  62
  63 // Rotate a buffer
  64 void rotateBuffer (std::vector<NLMISC::CBGRA> &Buffer, uint &Width, uint &Height)
  65 {
  66         // Make a copy
  67         std::vector<NLMISC::CBGRA> copy = Buffer;
  68
  69         // Rotate
  70         for (uint y=0; y<Width; y++)
  71         {
  72                 // Line offset
  73                 uint tmp=y*Width;
  74                 for (uint x=0; x<Width; x++)
  75                 {
  76                         Buffer[y+(Width-x-1)*Height]=copy[x+tmp];
  77                 }
  78         }
  79
  80         // New size
  81         uint tmp=Width;
  82         Width=Height;
  83         Height=tmp;
  84 }
  85
  86 /////////////////////////////////////////////////////////////////////////////
  87 // Load a Pic and apply Alpha & Rotation
  88 int loadPixmapBuffer(const std::string& path, std::vector<NLMISC::CBGRA>& Buffer, std::vector<NLMISC::CBGRA>* Alpha, int rot)
  89 {
  90         uint Width;
  91         uint Height;
  92         if (loadPic(path, Buffer, Width, Height))
  93         {
  94                 while (rot)
  95                 {
  96                         // Rotate the buffer
  97                         rotateBuffer (Buffer, Width, Height);
  98                         rot--;
  99                 }
 100
 101                 if ( (Alpha) && (Alpha->size()==Buffer.size()) )
 102                 {
 103                         // Pre mul RGB componates by Alpha one
 104                         int nPixelCount=(int)(Width*Height);
 105                         for (int p=0; p<nPixelCount; p++)
 106                         {
 107                                 // Invert alpha ?
 108                                 int alpha=(*Alpha)[p].A;
 109                                 Buffer[p].R=(uint8)(((int)Buffer[p].R*alpha)>>8);
 110                                 Buffer[p].G=(uint8)(((int)Buffer[p].G*alpha)>>8);
 111                                 Buffer[p].B=(uint8)(((int)Buffer[p].B*alpha)>>8);
 112                         }
 113                 }
 114
 115                 return 1;
 116         }
 117         else
 118                 return 0;
 119 }
 120
 121
 122 /////////////////////////////////////////////////////////////////////////////
 123 //TileInfo
 124
 125
 126 TileInfo::TileInfo():tileType(UnSet)
 127 {
 128         this->loaded = 0;
 129         this->nightLoaded = 0;
 130         this->alphaLoaded = 0;
 131 }
 132
 133
 134
 135 TileInfo::TileInfo(int id, TileType tileType):id(id), tileType(tileType)
 136 {
 137         this->loaded = 0;
 138         this->nightLoaded = 0;
 139         this->alphaLoaded = 0;
 140 }
 141
 142 void TileInfo::Init(int id, TileType tileType)
 143 {
 144         this->id = id;
 145         this->tileType = tileType;
 146         this->loaded = 0;
 147         this->nightLoaded = 0;
 148         this->alphaLoaded = 0;
 149 }
 150
 151
 152 bool TileInfo::Load (int index, std::vector<NLMISC::CBGRA>* Alpha)
 153 {
 154         bool bRes=true;
 155         if (!loaded && !getRelativeFileName (Diffuse, index).empty())
 156         {
 157                 path = fixPath(tileBankBrowser.getAbsPath() + getRelativeFileName (Diffuse, index));
 158
 159
 160
 161                 if ( !loadPixmapBuffer( path, Bits, Alpha, 0))
 162                 {
 163                         bRes=false;
 164                         QMessageBox::information( NULL, QObject::tr("Can't load Diffuse file"),  QString( (path.c_str()) ));
 165
 166                 }
 167                 else
 168                         loaded=1;
 169         }
 170         if (!nightLoaded && !getRelativeFileName (Additive, index).empty())
 171         {
 172                 nightPath = fixPath(tileBankBrowser.getAbsPath() + getRelativeFileName (Additive, index));
 173                 if (!loadPixmapBuffer( nightPath, nightBits, Alpha, 0))
 174                 {
 175                         bRes=false;
 176                         QMessageBox::information( NULL, QObject::tr("Can't load Additive file"),  QString( nightPath.c_str() ) );
 177                 }
 178                 else
 179                         nightLoaded=1;
 180         }
 181         if (!alphaLoaded && !getRelativeFileName (::Alpha, index).empty())
 182         {
 183                 alphaPath = fixPath(tileBankBrowser.getAbsPath() + getRelativeFileName (::Alpha, index));
 184                 if (!loadPixmapBuffer( alphaPath, alphaBits, NULL, tileBankBrowser.getTile (index)->getRotAlpha ()))
 185                 {
 186                         bRes=false;
 187                         QMessageBox::information( NULL, QObject::tr("Can't load Alpha file"),  QString( alphaPath.c_str() ) );
 188
 189                 }
 190                 else
 191                         alphaLoaded=1;
 192         }
 193
 194         return bRes;
 195 }
 196
 197 std::string TileInfo::fixPath(const std::string &path) {
 198         // Fix the Windows path issues for subpaths.
 199         std::string searchStr("\\");
 200         std::string replaceStr("/");
 201         string::size_type pos = 0;
 202         std::string pathStr = path;
 203
 204         while( (pos = pathStr.find(searchStr, pos)) != std::string::npos) {
 205                 pathStr.replace(pos, searchStr.size(), replaceStr);
 206                 pos++;
 207         }
 208         return pathStr;
 209 }
 210
 211 void TileInfo::Delete ()
 212 {
 213         loaded=0;
 214         Bits.resize(0);
 215
 216         nightLoaded=0;
 217         nightBits.resize(0);
 218
 219         alphaLoaded=0;
 220         alphaBits.resize(0);
 221 }
 222
 223 const std::string TileInfo::getRelativeFileName (TileTexture texture, int index)
 224 {
 225         nlassert(this->tileType != UnSet);
 226
 227         std::string currentPath;
 228         if (tileType != Displace)
 229         {
 230                 currentPath = tileBankBrowser.getTile(index)->getRelativeFileName ((CTile::TBitmap)texture);
 231         }
 232         else
 233         {
 234                 if (texture == Diffuse)
 235                 {
 236                         currentPath = tileBankBrowser.getDisplacementMap(index);
 237
 238                         //TODO titegus: remove MAGIC STRING "EmptyDisplacementMap" in Nel \tile_bank.cpp\void CTileNoise::setEmpty () or add an IsEmpty() method !!!!
 239                         if (currentPath == "EmptyDisplacementMap")
 240                                 currentPath.clear();
 241                 }
 242         }
 243
 244         return currentPath;
 245 }
 246
 247
 248
 249 //TileList
 250 TileList::TileList()
 251 {
 252         _tileSet = -1;
 253
 254         // Add 48 transitions
 255         int i;
 256         for (i=0; i<CTileSet::count; i++)
 257         {
 258                 TileInfo info(i, Transition);
 259                 theListTransition.push_back (info);
 260         }
 261
 262         // Add 16 displacements
 263         for (i=0; i<CTileSet::CountDisplace; i++)
 264         {
 265                 TileInfo info(i, Displace);
 266                 theListDisplacement.push_back (info);
 267         }
 268 }
 269
 270
 271 int TileList::addTile128 ()
 272 {
 273
 274         int index;
 275         tileBankBrowser.getTileSet (_tileSet)->addTile128 (index, tileBankBrowser);
 276         nlassert (index==(sint)theList128.size());
 277
 278         TileInfo info(index, _128x128);
 279         theList128.push_back (info);
 280
 281         return index;
 282 }
 283
 284 int TileList::addTile256 ()
 285 {
 286         int index;
 287         tileBankBrowser.getTileSet (_tileSet)->addTile256 (index, tileBankBrowser);
 288         nlassert (index==(sint)theList256.size());
 289
 290         TileInfo info(index, _256x256);
 291         theList256.push_back (info);
 292
 293         return index;
 294 }
 295
 296 bool TileList::setTile128 (int tile, const std::string& name, NL3D::CTile::TBitmap type)
 297 {
 298         // Remove the absolute path from the path name
 299         std::string troncated = name;
 300         if (RemovePath(troncated, tileBankBrowser.getAbsPath ().c_str()))
 301         {
 302                 vector<NLMISC::CBGRA> tampon;
 303                 uint Width;
 304                 uint Height;
 305                 if (!loadPic(tileBankBrowser.getAbsPath ()+troncated, tampon, Width, Height))
 306                 {
 307                         return ( QMessageBox::Yes == QMessageBox::question( NULL, QObject::tr("Can't load bitmap."),  QString( ((tileBankBrowser.getAbsPath ()+troncated)+"\nContinue ?").c_str() ), QMessageBox::Yes | QMessageBox::No));
 308                 }
 309                 else
 310                 {
 311                         CTileBorder border;
 312                         border.set (Width, Height, tampon);
 313
 314                         CTileSet::TError error;
 315                         int pixel=-1;
 316                         int composante=4;
 317                         if (type == CTile::additive)
 318                                 error=CTileSet::ok;
 319                         else
 320                                 error=tileBankBrowser.getTileSet(_tileSet)->checkTile128 (type, border, pixel, composante);
 321
 322                         if ((error!=CTileSet::ok)&&(error!=CTileSet::addFirstA128128))
 323                         {
 324                                 QString pixelMessage = QObject::tr("%1\nPixel: %2(%3).\nContinue ?").arg(CTileSet::getErrorMessage (error)).arg(pixel).arg(comp[composante]);
 325                                 return ( QMessageBox::Yes == QMessageBox::question( NULL, QObject::tr("Can't set Bitmap"),  pixelMessage, QMessageBox::Yes | QMessageBox::No) );
 326                         }
 327                         else
 328                         {
 329                                 if (error==CTileSet::addFirstA128128)
 330                                         tileBankBrowser.getTileSet(_tileSet)->setBorder (type, border);
 331
 332                                 tileBankBrowser.getTileSet(_tileSet)->setTile128 (tile, troncated, type, tileBankBrowser);
 333                                 switch (type)
 334                                 {
 335                                 case CTile::diffuse:
 336                                         theList128[tile].loaded=0;
 337                                         break;
 338                                 case CTile::additive:
 339                                         theList128[tile].nightLoaded=0;
 340                                         break;
 341                                 case CTile::alpha:
 342                                         theList128[tile].alphaLoaded=0;
 343                                         break;
 344                                 default:
 345                                         break;
 346                                 }
 347                                 Reload(tile, tile + 1, _128x128);
 348                         }
 349                 }
 350         }
 351         else
 352         {
 353                 // Error: bitmap not in the absolute path..
 354                 QString notInAbsolutePathMessage = QObject::tr("The bitmap %1 is not in the absolute path %2.\nContinue ?").arg(name.c_str()).arg(tileBankBrowser.getAbsPath ().c_str());
 355                 return ( QMessageBox::Yes == QMessageBox::question( NULL, QObject::tr("Load error"),  notInAbsolutePathMessage, QMessageBox::Yes | QMessageBox::No));
 356         }
 357
 358         return true;
 359 }
 360
 361 bool TileList::setTile256 (int tile, const std::string& name, NL3D::CTile::TBitmap type)
 362 {
 363         // Remove the absolute path from the path name
 364         std::string troncated=name;
 365         if (RemovePath (troncated, tileBankBrowser.getAbsPath ().c_str()))
 366         {
 367                 vector<NLMISC::CBGRA> tampon;
 368                 uint Width;
 369                 uint Height;
 370                 if (!loadPic(tileBankBrowser.getAbsPath ()+troncated, tampon, Width, Height))
 371                 {
 372                         return ( QMessageBox::Yes == QMessageBox::question( NULL, QObject::tr("Can't load bitmap."),  QString( ((tileBankBrowser.getAbsPath ()+troncated)+"\nContinue ?").c_str() ), QMessageBox::Yes | QMessageBox::No) );
 373
 374                 }
 375                 else
 376                 {
 377                         CTileBorder border;
 378                         border.set (Width, Height, tampon);
 379
 380                         CTileSet::TError error;
 381                         int pixel=-1;
 382                         int composante=4;
 383
 384                         if (type == CTile::additive)
 385                                 error=CTileSet::ok;
 386                         else
 387                                 error=tileBankBrowser.getTileSet(_tileSet)->checkTile256 (type, border, pixel, composante);
 388                         if ((error!=CTileSet::ok))
 389                         {
 390                                 QString pixelMessage = QObject::tr("%1\nPixel: %2(%3).\nContinue ?").arg(CTileSet::getErrorMessage (error)).arg(pixel).arg(comp[composante]);
 391                                 return ( QMessageBox::Yes == QMessageBox::question( NULL, QObject::tr("Can't set Bitmap"),  pixelMessage, QMessageBox::Yes | QMessageBox::No) );
 392                         }
 393                         else
 394                         {
 395                                 tileBankBrowser.getTileSet(_tileSet)->setTile256 (tile, troncated, type, tileBankBrowser);
 396                                                 switch (type)
 397                                 {
 398                                 case CTile::diffuse:
 399                                         theList256[tile].loaded=0;
 400                                         break;
 401                                 case CTile::additive:
 402                                         theList256[tile].nightLoaded=0;
 403                                         break;
 404                                 case CTile::alpha:
 405                                         theList256[tile].alphaLoaded=0;
 406                                         break;
 407                                 default:
 408                                         break;
 409                                 }
 410                                 Reload(tile, tile + 1, _256x256);
 411                         }
 412                 }
 413         }
 414         else
 415         {
 416                 // Error: bitmap not in the absolute path..
 417                 QString notInAbsolutePathMessage = QObject::tr("The bitmap %1 is not in the absolute path %2.\nContinue ?").arg(name.c_str()).arg(tileBankBrowser.getAbsPath ().c_str());
 418                 return ( QMessageBox::Yes == QMessageBox::question( NULL, QObject::tr("Load error"),  notInAbsolutePathMessage, QMessageBox::Yes | QMessageBox::No));
 419         }
 420
 421         return true;
 422 }
 423
 424 bool TileList::setTileTransition (int tile, const std::string& name, NL3D::CTile::TBitmap type)
 425 {
 426         // Remove the absolute path from the path name
 427         std::string troncated=name;
 428         if (RemovePath (troncated, tileBankBrowser.getAbsPath ().c_str()))
 429         {
 430                 // No alpha, use setTileTransitionAlpha
 431                 nlassert (CTile::alpha!=type);
 432
 433                 vector<NLMISC::CBGRA> tampon;
 434                 uint Width;
 435                 uint Height;
 436                 if (!loadPic(tileBankBrowser.getAbsPath ()+troncated, tampon, Width, Height))
 437                 {
 438                         return ( QMessageBox::Yes == QMessageBox::question( NULL, QObject::tr("Can't load bitmap."),  QString( ((tileBankBrowser.getAbsPath ()+troncated)+"\nContinue ?").c_str() ), QMessageBox::Yes | QMessageBox::No) );
 439                 }
 440                 else
 441                 {
 442                         CTileBorder border;
 443                         border.set (Width, Height, tampon);
 444
 445                         CTileSet::TError error;
 446                         int pixel=-1;
 447                         int composante=4;
 448                         if (type == CTile::additive)
 449                                 error=CTileSet::ok;
 450                         else
 451                                 error=tileBankBrowser.getTileSet(_tileSet)->checkTile128 (type, border, pixel, composante);
 452                         if ((error!=CTileSet::ok)&&(error!=CTileSet::addFirstA128128))
 453                         {
 454                                 QString pixelMessage = QObject::tr("%1\nPixel: %2(%3).\nContinue ?").arg(CTileSet::getErrorMessage (error)).arg(pixel).arg(comp[composante]);
 455                                 return ( QMessageBox::Yes == QMessageBox::question( NULL, QObject::tr("Can't set Bitmap"),  pixelMessage, QMessageBox::Yes | QMessageBox::No) );
 456                         }
 457                         else
 458                         {
 459                                 if (error==CTileSet::addFirstA128128)
 460                                         tileBankBrowser.getTileSet(_tileSet)->setBorder (type, border);
 461                                 tileBankBrowser.getTileSet(_tileSet)->setTileTransition ((CTileSet::TTransition)tile, troncated, type, tileBankBrowser, border);
 462                                 switch (type)
 463                                 {
 464                                 case CTile::diffuse:
 465                                         theListTransition[tile].loaded=0;
 466                                         break;
 467                                 case CTile::additive:
 468                                         theListTransition[tile].nightLoaded=0;
 469                                         break;
 470                                 case CTile::alpha:
 471                                         theListTransition[tile].alphaLoaded=0;
 472                                         break;
 473                                 default:
 474                                         break;
 475                                 }
 476                                 Reload(tile, tile + 1, Transition);
 477                         }
 478                 }
 479         }
 480         else
 481         {
 482                 // Error: bitmap not in the absolute path..
 483                 QString notInAbsolutePathMessage = QObject::tr("The bitmap %1 is not in the absolute path %2.\nContinue ?").arg(name.c_str()).arg(tileBankBrowser.getAbsPath ().c_str());
 484                 return ( QMessageBox::Yes == QMessageBox::question( NULL, QObject::tr("Load error"),  notInAbsolutePathMessage, QMessageBox::Yes | QMessageBox::No) );
 485         }
 486
 487         return true;
 488 }
 489
 490 bool TileList::setDisplacement (int tile, const std::string& name, NL3D::CTile::TBitmap type)
 491 {
 492         // Remove the absolute path from the path name
 493         std::string troncated=name;
 494         if (RemovePath (troncated, tileBankBrowser.getAbsPath ().c_str()))
 495         {
 496
 497                 vector<NLMISC::CBGRA> tampon;
 498                 uint Width;
 499                 uint Height;
 500                 if (!loadPic(tileBankBrowser.getAbsPath ()+troncated, tampon, Width, Height))
 501                 {
 502                         return ( QMessageBox::Yes == QMessageBox::question( NULL, QObject::tr("Can't load bitmap"),  QString( ((tileBankBrowser.getAbsPath ()+troncated)+"\nContinue ?").c_str() ), QMessageBox::Yes | QMessageBox::No) );
 503                 }
 504                 else
 505                 {
 506                         // Check the size
 507                         if ( (Width!=32) || (Height!=32) )
 508                         {
 509                                 // Error message
 510                                 return ( QMessageBox::Yes == QMessageBox::question( NULL, QObject::tr("Can't set Bitmap"), QString( (troncated+"\nInvalid size: displacement map must be 32x32 8 bits.\nContinue ?").c_str()), QMessageBox::Yes | QMessageBox::No) );
 511                         }
 512                         else
 513                         {
 514                                 // change the file name of the displacement map
 515                                 tileBankBrowser.getTileSet(_tileSet)->setDisplacement ((CTileSet::TDisplacement)tile, troncated, tileBankBrowser);
 516
 517                                 // Loaded
 518                                 theListDisplacement[tile].loaded=0;
 519                                 Reload(tile, tile + 1, Displace);
 520                         }
 521                 }
 522
 523         }
 524         else
 525         {
 526                 // Error: bitmap not in the absolute path..
 527                 QString notInAbsolutePathMessage = QObject::tr("The bitmap %1 is not in the absolute path %2.\nContinue ?").arg(name.c_str()).arg(tileBankBrowser.getAbsPath ().c_str());
 528                 return ( QMessageBox::Yes == QMessageBox::question( NULL, QObject::tr("Load error"),  notInAbsolutePathMessage, QMessageBox::Yes | QMessageBox::No) );
 529         }
 530
 531         return true;
 532 }
 533
 534 bool TileList::setTileTransitionAlpha (int tile, const std::string& name, int rot)
 535 {
 536         // Remove the absolute path from the path name
 537         std::string troncated=name;
 538         if (RemovePath (troncated, tileBankBrowser.getAbsPath ().c_str()))
 539         {
 540                 vector<NLMISC::CBGRA> tampon;
 541                 uint Width;
 542                 uint Height;
 543                 if (!loadPic(tileBankBrowser.getAbsPath ()+troncated, tampon, Width, Height))
 544                 {
 545                         return ( QMessageBox::Yes == QMessageBox::question( NULL, QObject::tr("Can't load bitmap"),  QString( ((tileBankBrowser.getAbsPath ()+troncated)+"\nContinue ?").c_str() ), QMessageBox::Yes | QMessageBox::No) );
 546                 }
 547                 else
 548                 {
 549                         CTileBorder border;
 550                         border.set (Width, Height, tampon);
 551
 552                         // rotate the border
 553                         int rotBis=rot;
 554                         while (rotBis)
 555                         {
 556                                 border.rotate ();
 557                                 rotBis--;
 558                         }
 559
 560                         CTileSet::TError error;
 561                         int indexError;
 562                         int pixel=-1;
 563                         int composante=4;
 564                         if (((error=tileBankBrowser.getTileSet(_tileSet)->checkTileTransition ((CTileSet::TTransition)tile, CTile::alpha, border, indexError,
 565                                 pixel, composante))!=CTileSet::ok))
 566                         {
 567                                 QString pixelMessage;
 568                                 if ((error==CTileSet::topInterfaceProblem)||(error==CTileSet::bottomInterfaceProblem)||(error==CTileSet::leftInterfaceProblem)
 569                                         ||(error==CTileSet::rightInterfaceProblem)||(error==CTileSet::topBottomNotTheSame)||(error==CTileSet::rightLeftNotTheSame)
 570                                         ||(error==CTileSet::topInterfaceProblem))
 571                                 {
 572                                         if (indexError!=-1)
 573                                                 pixelMessage = QObject::tr("%1.\nIncompatible with tile nb %4.\nPixel: %2(%3).\nContinue ?").arg(CTileSet::getErrorMessage (error)).arg(pixel).arg(comp[composante]).arg(indexError);
 574                                         else
 575                                                 pixelMessage = QObject::tr("%1.\nIncompatible with the 128x128 tile.\nPixel: %2(%3).\nContinue ?").arg(CTileSet::getErrorMessage (error)).arg(pixel).arg(comp[composante]);
 576
 577                                 }
 578                                 else
 579                                         pixelMessage = QObject::tr("%1.\nIncompatible filled tile.\nContinue ?").arg(CTileSet::getErrorMessage (error));
 580
 581                                 return ( QMessageBox::Yes == QMessageBox::question( NULL, QObject::tr("Can't set Bitmap"),  pixelMessage, QMessageBox::Yes | QMessageBox::No) );
 582                         }
 583                         else
 584                         {
 585                                 tileBankBrowser.getTileSet(_tileSet)->setTileTransitionAlpha ((CTileSet::TTransition)tile, troncated, tileBankBrowser, border, rot);
 586                                 theListTransition[tile].alphaLoaded=0;
 587                                 theListTransition[tile].Load (tileBankBrowser.getTileSet(_tileSet)->getTransition(tile)->getTile(), NULL);
 588                         }
 589                 }
 590         }
 591         else
 592         {
 593                 // Error: bitmap not in the absolute path..
 594                 QString notInAbsolutePathMessage = QObject::tr("The bitmap %1 is not in the absolute path %2.\nContinue ?").arg(name.c_str()).arg(tileBankBrowser.getAbsPath ().c_str());
 595                 return ( QMessageBox::Yes == QMessageBox::question( NULL, QObject::tr("Load error"),  notInAbsolutePathMessage, QMessageBox::Yes | QMessageBox::No) );
 596         }
 597
 598         return true;
 599 }
 600
 601 void TileList::removeTile128 (int index)
 602 {
 603         tileBankBrowser.getTileSet (_tileSet)->removeTile128 (index, tileBankBrowser);
 604         theList[0].erase (theList[0].begin()+index);
 605         for (int i=0; i<(sint)theList[0].size(); i++)
 606         {
 607                 theList[0][i].setId(i);
 608         }
 609 }
 610
 611 void TileList::removeTile256 (int index)
 612 {
 613         tileBankBrowser.getTileSet (_tileSet)->removeTile256 (index, tileBankBrowser);
 614         theList[1].erase (theList[1].begin()+index);
 615         for (int i=0; i<(sint)theList[1].size(); i++)
 616         {
 617                 theList[1][i].setId(i);
 618         }
 619 }
 620
 621 void TileList::clearTile128 (int index, CTile::TBitmap bitmap)
 622 {
 623         switch (bitmap)
 624         {
 625                 case CTile::diffuse:
 626                         theList128[index].loaded=0;
 627                         theList128[index].Bits.resize(0);
 628                         break;
 629                 case CTile::additive:
 630                         theList128[index].nightLoaded=0;
 631                         theList128[index].nightBits.resize(0);
 632                         break;
 633                 case CTile::alpha:
 634                         nlassert(0);
 635                         break;
 636                 default:
 637                         break;
 638         }
 639         tileBankBrowser.getTileSet (_tileSet)->clearTile128 (index, bitmap, tileBankBrowser);
 640 }
 641
 642 void TileList::clearTile256 (int index, CTile::TBitmap bitmap)
 643 {
 644         switch (bitmap)
 645         {
 646                 case CTile::diffuse:
 647                         theList256[index].loaded=0;
 648                         theList256[index].Bits.resize(0);
 649                         break;
 650                 case CTile::additive:
 651                         theList256[index].nightLoaded=0;
 652                         theList256[index].nightBits.resize(0);
 653                         break;
 654                 case CTile::alpha:
 655                         nlassert(0);
 656                         break;
 657                 default:
 658                         break;
 659         }
 660         tileBankBrowser.getTileSet (_tileSet)->clearTile256 (index, bitmap, tileBankBrowser);
 661 }
 662
 663 void TileList::clearTransition (int index, CTile::TBitmap bitmap)
 664 {
 665         switch (bitmap)
 666         {
 667                 case CTile::diffuse:
 668                         theListTransition[index].loaded=0;
 669                         theListTransition[index].Bits.resize(0);
 670                         break;
 671                 case CTile::additive:
 672                         theListTransition[index].nightLoaded=0;
 673                         theListTransition[index].nightBits.resize(0);
 674                         break;
 675                 case CTile::alpha:
 676                         theListTransition[index].alphaLoaded=0;
 677                         theListTransition[index].alphaBits.resize(0);
 678                         break;
 679                 default:
 680                         break;
 681         }
 682         tileBankBrowser.getTileSet (_tileSet)->clearTransition ((CTileSet::TTransition)index, bitmap, tileBankBrowser);
 683 }
 684
 685 void TileList::clearDisplacement (int index, CTile::TBitmap bitmap)
 686 {
 687         switch (bitmap)
 688         {
 689                 case CTile::diffuse:
 690                         theListDisplacement[index].loaded=0;
 691                         theListDisplacement[index].Bits.resize(0);
 692                         break;
 693                 case CTile::additive:
 694                         nlassert(0);
 695                         break;
 696                 case CTile::alpha:
 697                         nlassert(0);
 698                         break;
 699                 default:
 700                         break;
 701         }
 702
 703         tileBankBrowser.getTileSet (_tileSet)->clearDisplacement ((CTileSet::TDisplacement)index, tileBankBrowser);
 704 }
 705
 706 tilelist::iterator TileList::GetFirst(int n)
 707 {
 708         return theList[n].begin();
 709 }
 710
 711 tilelist::iterator TileList::GetLast(int n)
 712 {
 713         return theList[n].end();
 714 }
 715
 716 tilelist::iterator TileList::Get(int i, int n)
 717 {
 718         return theList[n].begin()+i;
 719 }
 720
 721
 722 int TileList::GetSize(int n)
 723 {
 724         return (int)theList[n].size();
 725 }
 726
 727
 728 void TileList::Reload(int first, int last, TileType n) //recharge en memoire une tranche de tiles
 729 {
 730         for (int i=first; i<last; i++)
 731         {
 732                 switch (n)
 733                 {
 734                         case _128x128:
 735                         {
 736                                 theList[n][i].Load (tileBankBrowser.getTileSet(_tileSet)->getTile128 (i), NULL);
 737                                 break;
 738                         }
 739                         case _256x256:
 740                         {
 741                                 theList[n][i].Load (tileBankBrowser.getTileSet(_tileSet)->getTile256 (i), NULL);
 742                                 break;
 743                         }
 744                         case Transition:
 745                         {
 746                                 int index=tileBankBrowser.getTileSet(_tileSet)->getTransition (i)->getTile();
 747                                 if (index!=-1)
 748                                         theList[n][i].Load (index, &theListTransition[i].alphaBits);
 749                                 break;
 750                         }
 751                         case Displace:
 752                         {
 753                                 int index=tileBankBrowser.getTileSet(_tileSet)->getDisplacementTile ((CTileSet::TDisplacement)i);
 754                                 if (index!=-1)
 755                                         theList[n][i].Load (index, NULL);
 756                                 break;
 757                         }
 758                         default:
 759                                 break;
 760                 }
 761         }
 762 }