studio/src/plugins/tile_editor/tile_bank.cpp

   1 // Ryzom Core Studio - Tile Editor plugin
   2 // Copyright (C) 2010  Winch Gate Property Limited
   3 //
   4 // This program is free software: you can redistribute it and/or modify
   5 // it under the terms of the GNU Affero General Public License as
   6 // published by the Free Software Foundation, either version 3 of the
   7 // License, or (at your option) any later version.
   8 //
   9 // This program is distributed in the hope that it will be useful,
  10 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  11 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12 // GNU Affero General Public License for more details.
  13 //
  14 // You should have received a copy of the GNU Affero General Public License
  15 // along with this program.  If not, see <http://www.gnu.org/licenses/>.
  16
  17
  18 #include "tile_bank.h"
  19 #include "nel/3d/tile_bank.h"
  20
  21 #include <QPixmap>
  22
  23 namespace{
  24
  25         bool pixmapToCBGRA( QPixmap &pixmap, std::vector< NLMISC::CBGRA >& pixels )
  26         {
  27                 QImage img = pixmap.toImage();
  28                 if( img.format() != QImage::Format_ARGB32 )
  29                         img = img.convertToFormat( QImage::Format_ARGB32 );
  30
  31                 if( img.format() != QImage::Format_ARGB32 )
  32                         return false;
  33
  34                 int c = img.width() * img.height();
  35
  36                 const unsigned char *data = img.bits();
  37                 const unsigned int *idata = reinterpret_cast< const unsigned int* >( data );
  38
  39                 NLMISC::CBGRA bgra;
  40                 pixels.clear();
  41
  42                 int i = 0;
  43                 while( i < c )
  44                 {
  45                         bgra.A = ( idata[ i ] & 0xFF000000 ) >> 24;
  46                         bgra.R = ( idata[ i ] & 0x00FF0000 ) >> 16;
  47                         bgra.G = ( idata[ i ] & 0x0000FF00 ) >> 8;
  48                         bgra.B = ( idata[ i ] & 0x000000FF );
  49                         pixels.push_back( bgra );
  50
  51                         i++;
  52                 }
  53
  54                 return true;
  55         }
  56
  57
  58         NL3D::CTile::TBitmap channelToTBitmap( TileConstants::TTileChannel channel )
  59         {
  60                 return NL3D::CTile::TBitmap( int( channel ) );
  61         }
  62
  63
  64 }
  65
  66 /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
  67
  68
  69 class TileBankPvt
  70 {
  71 public:
  72
  73         bool checkSize( TileConstants::TNodeTileType type, TileConstants::TTileChannel channel, int w, int h )
  74         {
  75                 int width = -1;
  76
  77                 switch( type )
  78                 {
  79                 case TileConstants::Tile128:
  80                         width = 128;
  81                         break;
  82
  83                 case TileConstants::Tile256:
  84                         width = 256;
  85                         break;
  86
  87                 case TileConstants::TileTransition:
  88                         {
  89                                 if( channel == TileConstants::TileAlpha )
  90                                         width = 64;
  91                                 else
  92                                         width = 128;
  93
  94                         }
  95                         break;
  96
  97                 case TileConstants::TileDisplacement:
  98                         width = 32;
  99                         break;
 100                 }
 101
 102                 if( width == w )
 103                         return true;
 104
 105                 return false;
 106         }
 107
 108         NL3D::CTileSet::TError checkTile( NL3D::CTileSet *set, int tile, TileConstants::TNodeTileType type, NL3D::CTileBorder &border, NL3D::CTile::TBitmap bitmap, QString &msg )
 109         {
 110                 NL3D::CTileSet::TError error;
 111
 112                 if( bitmap == NL3D::CTile::additive )
 113                         return NL3D::CTileSet::ok;
 114
 115                 if( type == TileConstants::TileDisplacement )
 116                         return NL3D::CTileSet::ok;
 117
 118                 int component;
 119                 int pixel;
 120                 int idx;
 121
 122                 switch( type )
 123                 {
 124                 case TileConstants::Tile128:
 125                         error = set->checkTile128( bitmap, border, pixel, component );
 126                         break;
 127
 128                 case TileConstants::Tile256:
 129                         error = set->checkTile256( bitmap, border, pixel, component );
 130                         break;
 131
 132                 case TileConstants::TileTransition:
 133                         {
 134                                 if( bitmap != NL3D::CTile::alpha )
 135                                         error = set->checkTile128( bitmap, border, pixel, component );
 136                                 else
 137                                         error = set->checkTileTransition( NL3D::CTileSet::TTransition( tile ), bitmap, border, idx, pixel, component );
 138
 139                                 break;
 140                         }
 141                 }
 142
 143                 if( ( error != NL3D::CTileSet::ok ) && ( error != NL3D::CTileSet::addFirstA128128 ) )
 144                 {
 145                         static const char* comp[]={"Red", "Green", "Blue", "Alpha", ""};
 146
 147                         msg = NL3D::CTileSet::getErrorMessage( error );
 148                         msg += "\n";
 149                         msg += " pixel %1 component %2";
 150                         msg = msg.arg( pixel );
 151                         msg = msg.arg( comp[ component ] );
 152                 }
 153
 154                 return error;
 155         }
 156
 157         void setTile( NL3D::CTileSet *set, int tile, int rotation, const QString &name, NL3D::CTile::TBitmap bm, TileConstants::TNodeTileType type, NL3D::CTileBorder &border )
 158         {
 159                 switch( type )
 160                 {
 161                 case TileConstants::Tile128:
 162                         set->setTile128( tile, name.toUtf8().constData(), bm, m_bank );
 163                         break;
 164
 165                 case TileConstants::Tile256:
 166                         set->setTile256( tile, name.toUtf8().constData(), bm, m_bank );
 167                         break;
 168
 169                 case TileConstants::TileTransition:
 170                         if( bm != NL3D::CTile::alpha )
 171                                 set->setTileTransition( NL3D::CTileSet::TTransition( tile ), name.toUtf8().constData(), bm, m_bank, border );
 172                         else
 173                                 set->setTileTransitionAlpha( NL3D::CTileSet::TTransition( tile ), name.toUtf8().constData(), m_bank, border, rotation );
 174                         break;
 175
 176                 case TileConstants::TileDisplacement:
 177                         set->setDisplacement( NL3D::CTileSet::TDisplacement( tile ), name.toUtf8().constData(), m_bank );
 178                         break;
 179                 }
 180
 181         }
 182
 183         void buildBorder( QPixmap &pm, NL3D::CTileBorder &border )
 184         {
 185                 std::vector< NLMISC::CBGRA > pixels;
 186                 pixmapToCBGRA( pm, pixels );
 187                 border.set( pm.width(), pm.height(), pixels );
 188         }
 189
 190         NL3D::CTileBank m_bank;
 191 };
 192
 193
 194
 195 ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 196
 197 TileBank::TileBank()
 198 {
 199         m_pvt = new TileBankPvt();
 200         resetError();
 201         m_rotation = 0;
 202 }
 203
 204 TileBank::~TileBank()
 205 {
 206         delete m_pvt;
 207 }
 208
 209 void TileBank::addTileSet( const QString &name )
 210 {
 211         m_pvt->m_bank.addTileSet( name.toUtf8().constData() );
 212         NL3D::CTileSet *set = m_pvt->m_bank.getTileSet( 0 );
 213 }
 214
 215 void TileBank::removeTileSet( int idx )
 216 {
 217         NL3D::CTileSet *set = m_pvt->m_bank.getTileSet( idx );
 218         if( set == NULL )
 219                 return;
 220
 221         int c = m_pvt->m_bank.getLandCount();
 222         for( int i = 0; i < c; i++ )
 223         {
 224                 NL3D::CTileLand *land = m_pvt->m_bank.getLand( i );
 225                 land->removeTileSet( set->getName() );
 226         }
 227
 228         m_pvt->m_bank.removeTileSet( idx );
 229 }
 230
 231 void TileBank::renameTileSet( int idx, const QString &newName )
 232 {
 233         NL3D::CTileSet *set = m_pvt->m_bank.getTileSet( idx );
 234         if( set == NULL )
 235                 return;
 236
 237         std::string oldName = set->getName();
 238         set->setName( newName.toUtf8().constData() );
 239
 240         int c = m_pvt->m_bank.getLandCount();
 241         for( int i = 0; i < c; i++ )
 242         {
 243                 NL3D::CTileLand *land = m_pvt->m_bank.getLand( i );
 244                 land->removeTileSet( oldName );
 245                 land->addTileSet( newName.toUtf8().constData() );
 246         }
 247
 248 }
 249
 250 void TileBank::getTileSets( QStringList &l )
 251 {
 252         int c = m_pvt->m_bank.getTileSetCount();
 253         for( int i = 0; i < c; i++ )
 254         {
 255                 NL3D::CTileSet *set = m_pvt->m_bank.getTileSet( i );
 256                 l.push_back( set->getName().c_str() );
 257         }
 258 }
 259
 260 void TileBank::addLand( const QString &name )
 261 {
 262         m_pvt->m_bank.addLand( name.toUtf8().constData() );
 263 }
 264
 265 void TileBank::removeLand( int idx )
 266 {
 267         m_pvt->m_bank.removeLand( idx );
 268 }
 269
 270 void TileBank::getLands( QStringList &l )
 271 {
 272         l.clear();
 273
 274         int c = m_pvt->m_bank.getLandCount();
 275         for( int i = 0; i < c; i++ )
 276         {
 277                 NL3D::CTileLand *land = m_pvt->m_bank.getLand( i );
 278                 l.push_back( land->getName().c_str() );
 279         }
 280 }
 281
 282 void TileBank::setLandSets( int idx, const QStringList &l )
 283 {
 284         NL3D::CTileLand *land = m_pvt->m_bank.getLand( idx );
 285         land->clear();
 286
 287         QStringListIterator itr( l );
 288         while( itr.hasNext() )
 289         {
 290                 land->addTileSet( itr.next().toUtf8().constData() );
 291         }
 292 }
 293
 294 void TileBank::getLandSets( int idx, QStringList &l )
 295 {
 296         NL3D::CTileLand *land = m_pvt->m_bank.getLand( idx );
 297         if( land == NULL )
 298                 return;
 299
 300         l.clear();
 301
 302         std::set< std::string> sets = land->getTileSets();
 303         std::set< std::string >::const_iterator itr = sets.begin();
 304         while( itr != sets.end() )
 305         {
 306                 l.push_back( itr->c_str() );
 307                 ++itr;
 308         }
 309 }
 310
 311 bool TileBank::addTile( int setIdx, const QString &name, const QVariant &pixmap, TileConstants::TTileChannel channel, TileConstants::TNodeTileType type )
 312 {
 313         resetError();
 314
 315         NL3D::CTileSet *set = m_pvt->m_bank.getTileSet( setIdx );
 316
 317         int tile;
 318         switch( type )
 319         {
 320         case TileConstants::Tile128: set->addTile128( tile, m_pvt->m_bank ); break;
 321         case TileConstants::Tile256: set->addTile256( tile, m_pvt->m_bank ); break;
 322         }
 323
 324         bool b = setTile( setIdx, tile, name, pixmap, channel, type );
 325         if( b )
 326                 return true;
 327
 328         // There was an error, roll back
 329         switch( type )
 330         {
 331         case TileConstants::Tile128: set->removeTile128( tile, m_pvt->m_bank ); break;
 332         case TileConstants::Tile256: set->removeTile256( tile, m_pvt->m_bank ); break;
 333         }
 334
 335         return false;
 336 }
 337
 338 void TileBank::removeTile( int ts, int type, int tile )
 339 {
 340         NL3D::CTileSet *set = m_pvt->m_bank.getTileSet( ts );
 341
 342         switch( type )
 343         {
 344         case TileConstants::Tile128: set->removeTile128( tile, m_pvt->m_bank ); break;
 345         case TileConstants::Tile256: set->removeTile256( tile, m_pvt->m_bank ); break;
 346         }
 347 }
 348
 349 bool TileBank::setTile( int tileset, int tile, const QString &name, const QVariant &pixmap, TileConstants::TTileChannel channel, TileConstants::TNodeTileType type )
 350 {
 351         resetError();
 352
 353         NL3D::CTileSet *set = m_pvt->m_bank.getTileSet( tileset );
 354         if( set == NULL )
 355                 return false;
 356
 357         QPixmap pm = pixmap.value< QPixmap >();
 358         if( pm.isNull() )
 359         {
 360                 m_hasError = true;
 361                 m_lastError = "Failed to load image.";
 362                 return false;
 363         }
 364
 365         if( pm.width() != pm.height() )
 366         {
 367                 m_hasError = true;
 368                 m_lastError = "Image isn't square.";
 369                 return false;
 370         }
 371
 372         if( !m_pvt->checkSize( type, channel, pm.width(), pm.height() ) )
 373         {
 374                 m_hasError = true;
 375                 m_lastError = "Invalid image size.";
 376                 return false;
 377         }
 378
 379         NL3D::CTileBorder border;
 380         m_pvt->buildBorder( pm, border );
 381
 382         if( ( type == TileConstants::TileTransition ) && ( channel == TileConstants::TileAlpha ) )
 383         {
 384                 int rotBits = m_rotation;
 385                 while( rotBits > 0 )
 386                 {
 387                         border.rotate();
 388                         rotBits--;
 389                 }
 390         }
 391
 392         QString msg;
 393         NL3D::CTileSet::TError error = m_pvt->checkTile( set, tile, type, border, channelToTBitmap( channel ), msg );
 394
 395         // Tile checks out fine, set it
 396         if( ( error == NL3D::CTileSet::ok ) || ( error == NL3D::CTileSet::addFirstA128128 ) )
 397         {
 398                 if( error == NL3D::CTileSet::addFirstA128128 )
 399                         set->setBorder( channelToTBitmap( channel ), border );
 400
 401                 m_pvt->setTile( set, tile, m_rotation, name, channelToTBitmap( channel ), type, border );
 402
 403                 return true;
 404         }
 405
 406         setError( msg );
 407
 408         return false;
 409 }
 410
 411 void TileBank::replaceImage( int ts, int type, int tile, TileConstants::TTileChannel channel, const QString &name, const QVariant &pixmap )
 412 {
 413         setTile( ts, tile, name, pixmap, channel, TileConstants::TNodeTileType( type ) );
 414 }
 415
 416 void TileBank::clearImage( int ts, int type, int tile, TileConstants::TTileChannel channel )
 417 {
 418         NL3D::CTileSet *set = m_pvt->m_bank.getTileSet( ts );
 419
 420         int tileId;
 421
 422         NL3D::CTile::TBitmap bm = channelToTBitmap( channel );
 423
 424         switch( type )
 425         {
 426         case TileConstants::Tile128:
 427                 set->clearTile128( tile, bm, m_pvt->m_bank );
 428                 break;
 429
 430         case TileConstants::Tile256:
 431                 set->clearTile256( tile, bm, m_pvt->m_bank );
 432                 break;
 433
 434         case TileConstants::TileTransition:
 435                 set->clearTransition( NL3D::CTileSet::TTransition( tile ), bm, m_pvt->m_bank );
 436                 break;
 437
 438         case TileConstants::TileDisplacement:
 439                 set->clearDisplacement( NL3D::CTileSet::TDisplacement( tile ), m_pvt->m_bank );
 440                 break;
 441         }
 442
 443 }
 444
 445 int TileBank::getTileCount( int tileSet, TileConstants::TNodeTileType type )
 446 {
 447         NL3D::CTileSet *set = m_pvt->m_bank.getTileSet( tileSet );
 448         if( set == NULL )
 449                 return -1;
 450
 451         int c = 0;
 452
 453         switch( type )
 454         {
 455         case TileConstants::Tile128:
 456                 c = set->getNumTile128();
 457                 break;
 458
 459         case TileConstants::Tile256:
 460                 c = set->getNumTile256();
 461                 break;
 462
 463         case TileConstants::TileTransition:
 464                 c = NL3D::CTileSet::count;
 465                 break;
 466
 467         case TileConstants::TileDisplacement:
 468                 c = NL3D::CTileSet::CountDisplace;
 469                 break;
 470         }
 471
 472         return c;
 473 }
 474
 475 int TileBank::getRealTileId( int tileSet, TileConstants::TNodeTileType type, int tileIdInSet )
 476 {
 477         NL3D::CTileSet *set = m_pvt->m_bank.getTileSet( tileSet );
 478         if( set == NULL )
 479                 return -1;
 480
 481         int tile = -1;
 482
 483         switch( type )
 484         {
 485         case TileConstants::Tile128:
 486                 tile = set->getTile128( tileIdInSet );
 487                 break;
 488
 489         case TileConstants::Tile256:
 490                 tile = set->getTile256( tileIdInSet );
 491                 break;
 492
 493         case TileConstants::TileTransition:
 494                 tile = set->getTransition( tileIdInSet )->getTile();
 495                 break;
 496
 497         case TileConstants::TileDisplacement:
 498                 tile = set->getDisplacementTile( NL3D::CTileSet::TDisplacement( tileIdInSet ) );
 499                 break;
 500         }
 501
 502         return tile;
 503 }
 504
 505 void TileBank::getTileImages( int tileSet, TileConstants::TNodeTileType type, int tileId, TileImages &images )
 506 {
 507         NL3D::CTileSet *set = m_pvt->m_bank.getTileSet( tileSet );
 508         if( set == NULL )
 509                 return;
 510
 511         switch( type )
 512         {
 513         case TileConstants::Tile128:
 514         case TileConstants::Tile256:
 515         case TileConstants::TileTransition:
 516                 {
 517                         NL3D::CTile *t = m_pvt->m_bank.getTile( tileId );
 518                         if( t == NULL )
 519                                 return;
 520
 521                         images.diffuse = t->getFileName( channelToTBitmap( TileConstants::TileDiffuse ) ).c_str();
 522                         images.additive = t->getFileName( channelToTBitmap( TileConstants::TileAdditive ) ).c_str();
 523                         images.alpha = t->getFileName( channelToTBitmap( TileConstants::TileAlpha ) ).c_str();
 524                 }
 525                 break;
 526
 527         case TileConstants::TileDisplacement:
 528                 {
 529                         images.diffuse = m_pvt->m_bank.getDisplacementMap( tileId );
 530                 }
 531                 break;
 532         }
 533
 534 }
 535
 536 void TileBank::getTileImages( int tileSet, TileConstants::TNodeTileType type, QList< TileImages > &l )
 537 {
 538         l.clear();
 539
 540         NL3D::CTileSet *set = m_pvt->m_bank.getTileSet( tileSet );
 541         if( set == NULL )
 542                 return;
 543
 544         int c = getTileCount( tileSet, type );
 545
 546         TileImages images;
 547
 548         for( int i = 0; i < c; i++ )
 549         {
 550                 images.clear();
 551
 552                 int id = getRealTileId( tileSet, type, i );
 553                 if( id < 0 )
 554                 {
 555                         l.push_back( images );
 556                         continue;
 557                 }
 558
 559                 getTileImages( tileSet, type, id, images );
 560
 561                 l.push_back( images );
 562         }
 563
 564 }
 565
 566 void TileBank::setVegetation( int tileSet, const QString &vegetation )
 567 {
 568         NL3D::CTileSet *set = m_pvt->m_bank.getTileSet( tileSet );
 569         if( set == NULL )
 570                 return;
 571
 572         set->setTileVegetableDescFileName( vegetation.toUtf8().constData() );
 573 }
 574
 575
 576 QString TileBank::getVegetation( int tileSet ) const
 577 {
 578         NL3D::CTileSet *set = m_pvt->m_bank.getTileSet( tileSet );
 579         if( set == NULL )
 580                 return "";
 581
 582         return set->getTileVegetableDescFileName().c_str();
 583 }
 584
 585 void TileBank::setOriented( int tileSet, bool b )
 586 {
 587         NL3D::CTileSet *set = m_pvt->m_bank.getTileSet( tileSet );
 588         if( set == NULL )
 589                 return;
 590
 591         set->setOriented( b );
 592 }
 593
 594 bool TileBank::getOriented( int tileSet ) const
 595 {
 596         NL3D::CTileSet *set = m_pvt->m_bank.getTileSet( tileSet );
 597         if( set == NULL )
 598                 return false;
 599
 600         return set->getOriented();
 601 }
 602
 603
 604 void TileBank::setSurfaceData( int tileSet, unsigned long data )
 605 {
 606         NL3D::CTileSet *set = m_pvt->m_bank.getTileSet( tileSet );
 607         if( set == NULL )
 608                 return;
 609
 610         set->SurfaceData = data;
 611 }
 612
 613 unsigned long TileBank::getSurfaceData( int tileSet ) const
 614 {
 615         NL3D::CTileSet *set = m_pvt->m_bank.getTileSet( tileSet );
 616         if( set == NULL )
 617                 return 0;
 618
 619         return set->SurfaceData;
 620 }
 621
 622 void TileBank::setTexturePath( const QString &path )
 623 {
 624         m_pvt->m_bank.setAbsPath( path.toUtf8().constData() );
 625 }
 626
 627 QString TileBank::getTexturePath() const
 628 {
 629         return m_pvt->m_bank.getAbsPath().c_str();
 630 }
 631
 632 void TileBank::setRotation( int rotation )
 633 {
 634         m_rotation = rotation;
 635 }
 636
 637 void TileBank::serial( NLMISC::IStream &f )
 638 {
 639         m_pvt->m_bank.serial( f );
 640 }
 641
 642