nel/src/3d/u_instance_material.cpp

   1 // NeL - MMORPG Framework <http://dev.ryzom.com/projects/nel/>
   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 #include "std3d.h"
  18
  19 #include "nel/3d/u_instance_material.h"
  20 #include "nel/3d/async_texture_block.h"
  21 #include "nel/3d/mesh_base_instance.h"
  22 #include "nel/3d/driver.h"
  23 #include "nel/3d/texture_mem.h"
  24 #include "nel/3d/texture_file.h"
  25
  26 #ifdef DEBUG_NEW
  27 #define new DEBUG_NEW
  28 #endif
  29
  30 namespace NL3D
  31 {
  32
  33
  34 // ***************************************************************************
  35 bool                            UInstanceMaterial::isTextureFile(uint stage) const
  36 {
  37         if (stage >= IDRV_MAT_MAXTEXTURES)
  38         {
  39                 nlwarning("UInstanceMaterialUser::isTextureFile : invalid stage");
  40                 return false;
  41         }
  42         return dynamic_cast<CTextureFile *>(_Object->getTexture(stage)) != NULL;
  43 }
  44
  45 // ***************************************************************************
  46 std::string                     UInstanceMaterial::getTextureFileName(uint stage) const
  47 {
  48         if (stage >= IDRV_MAT_MAXTEXTURES)
  49         {
  50                 nlwarning("UInstanceMaterialUser::getTextureFileName : invalid stage");
  51                 return "";
  52         }
  53
  54         // If Async mode
  55         if(_MBI->getAsyncTextureMode())
  56         {
  57                 nlassert(_AsyncTextureBlock->isTextureFile(stage));
  58                 // return name of the async one.
  59                 return _AsyncTextureBlock->TextureNames[stage];
  60         }
  61         else
  62         {
  63                 // return the name in the material
  64                 return NLMISC::safe_cast<CTextureFile *>(_Object->getTexture(stage))->getFileName();
  65         }
  66 }
  67
  68 // ***************************************************************************
  69 void                            UInstanceMaterial::setTextureFileName(const std::string &fileName, uint stage)
  70 {
  71         if (stage >= IDRV_MAT_MAXTEXTURES)
  72         {
  73                 nlwarning("UInstanceMaterialUser::setTextureFileName : invalid stage");
  74                 return;
  75         }
  76
  77         // If Async mode
  78         if(_MBI->getAsyncTextureMode())
  79         {
  80                 if(!_AsyncTextureBlock->isTextureFile(stage))
  81                 {
  82                         nlwarning("UInstanceMaterialUser::setTextureFileName : the texture is not a texture file");
  83                         return;
  84                 }
  85                 // replace the fileName
  86                 _AsyncTextureBlock->TextureNames[stage]= fileName;
  87                 // Flag the instance.
  88                 _MBI->setAsyncTextureDirty(true);
  89         }
  90         else
  91         {
  92                 CTextureFile *otherTex = dynamic_cast<CTextureFile *>(_Object->getTexture(stage));
  93                 if (!otherTex)
  94                 {
  95                         nlwarning("UInstanceMaterialUser::setTextureFileName : the texture is not a texture file");
  96                         return;
  97                 }
  98                 CTextureFile *tf = new CTextureFile(*otherTex);
  99                 tf->setFileName(fileName);
 100                 NLMISC::CSmartPtr<ITexture> old = _Object->getTexture(stage);
 101                 _Object->setTexture(stage, tf);
 102         }
 103 }
 104
 105 // ***************************************************************************
 106 void UInstanceMaterial::emptyTexture(uint stage /*=0*/)
 107 {
 108         if (stage >= IDRV_MAT_MAXTEXTURES)
 109         {
 110                 nlwarning("UInstanceMaterialUser::emptyTexture : invalid stage");
 111                 return;
 112         }
 113         _Object->setTexture(stage, NULL);
 114 }
 115
 116 // ***************************************************************************
 117 /*bool UInstanceMaterial::isSupportedByDriver(UDriver &drv, bool forceBaseCaps)
 118 {
 119         IDriver *idrv = NLMISC::safe_cast<CDriverUser *>(&drv)->getDriver();
 120         return _Object->isSupportedByDriver(*idrv, forceBaseCaps);
 121 }*/
 122
 123 // ***************************************************************************
 124 void UInstanceMaterial::setTextureMem(uint stage, uint8 *data, uint32 length, bool _delete, bool isFile /*=true*/, uint width /*=0*/, uint height /*=0*/, CBitmap::TType texType /*=CBitmap::RGBA*/)
 125 {
 126         if (stage >= IDRV_MAT_MAXTEXTURES)
 127         {
 128                 nlwarning("UInstanceMaterialUser::emptyTexture : invalid stage");
 129                 return;
 130         }
 131         _Object->setTexture((uint8) stage, new CTextureMem(data, length, _delete, isFile, width, height, texType));
 132 }
 133
 134 // ***************************************************************************
 135 bool                            UInstanceMaterial::isLighted() const
 136 {
 137         return _Object->isLighted();
 138 }
 139
 140 // ***************************************************************************
 141 void UInstanceMaterial::setLighting(bool active,
 142                                                                         CRGBA emissive /*=CRGBA(0,0,0)*/,
 143                                                                         CRGBA ambient /*=CRGBA(0,0,0)*/,
 144                                                                         CRGBA diffuse /*=CRGBA(0,0,0)*/,
 145                                                                         CRGBA specular /*=CRGBA(0,0,0)*/,
 146                                                                         float shininess /*=10*/)
 147 {
 148         _Object->setLighting(active, emissive, ambient, diffuse, specular, shininess);
 149 }
 150
 151 // ***************************************************************************
 152
 153 bool                            UInstanceMaterial::isUserColor() const
 154 {
 155         return _Object->getShader()==CMaterial::UserColor;
 156 }
 157
 158 // ***************************************************************************
 159
 160 void                            UInstanceMaterial::setEmissive( CRGBA emissive )
 161 {
 162         _Object->setEmissive(emissive);
 163 }
 164
 165 // ***************************************************************************
 166
 167 void                            UInstanceMaterial::setAmbient( CRGBA ambient )
 168 {
 169         _Object->setAmbient( ambient);
 170 }
 171
 172 // ***************************************************************************
 173
 174 void                            UInstanceMaterial::setDiffuse( CRGBA diffuse )
 175 {
 176         _Object->setDiffuse( diffuse);
 177 }
 178
 179 // ***************************************************************************
 180
 181 void                            UInstanceMaterial::setOpacity( uint8    opa )
 182 {
 183         _Object->setOpacity( opa );
 184 }
 185
 186 // ***************************************************************************
 187
 188 void                            UInstanceMaterial::setSpecular( CRGBA specular )
 189 {
 190         _Object->setSpecular( specular);
 191 }
 192
 193 // ***************************************************************************
 194
 195 void                            UInstanceMaterial::setShininess( float shininess )
 196 {
 197         _Object->setShininess( shininess );
 198 }
 199
 200 // ***************************************************************************
 201
 202 CRGBA                           UInstanceMaterial::getEmissive() const
 203 {
 204         return _Object->getEmissive();
 205 }
 206
 207 // ***************************************************************************
 208
 209 CRGBA                           UInstanceMaterial::getAmbient() const
 210 {
 211         return _Object->getAmbient();
 212 }
 213
 214 // ***************************************************************************
 215
 216 CRGBA                           UInstanceMaterial::getDiffuse() const
 217 {
 218         return _Object->getDiffuse();
 219 }
 220
 221 // ***************************************************************************
 222
 223 uint8                           UInstanceMaterial::getOpacity() const
 224 {
 225         return _Object->getOpacity();
 226 }
 227
 228 // ***************************************************************************
 229
 230 CRGBA                           UInstanceMaterial::getSpecular() const
 231 {
 232         return _Object->getSpecular();
 233 }
 234
 235 // ***************************************************************************
 236
 237 float                           UInstanceMaterial::getShininess() const
 238 {
 239         return _Object->getShininess();
 240 }
 241
 242 // ***************************************************************************
 243
 244 void                            UInstanceMaterial::setColor(CRGBA rgba)
 245 {
 246         _Object->setColor(rgba) ;
 247 }
 248
 249 // ***************************************************************************
 250
 251 CRGBA                           UInstanceMaterial::getColor(void) const
 252 {
 253         return _Object->getColor();
 254 }
 255
 256 // ***************************************************************************
 257
 258 void                            UInstanceMaterial::setUserColor(CRGBA userColor)
 259 {
 260         if(isUserColor())
 261                 _Object->setUserColor(userColor);
 262 }
 263
 264 // ***************************************************************************
 265
 266 CRGBA                           UInstanceMaterial::getUserColor() const
 267 {
 268         if(isUserColor())
 269                 return _Object->getUserColor();
 270         else
 271                 return CRGBA(0,0,0,0);
 272 }
 273
 274 // ***************************************************************************
 275
 276 void                            UInstanceMaterial::setConstantColor(uint stage, NLMISC::CRGBA color)
 277 {
 278         if (stage >= IDRV_MAT_MAXTEXTURES)
 279         {
 280                 nlwarning("UInstanceMaterialUser::setConstantColor : invalid stage");
 281                 return;
 282         }
 283         _Object->texConstantColor(stage, color);
 284 }
 285
 286 // ***************************************************************************
 287
 288 NLMISC::CRGBA           UInstanceMaterial::getConstantColor(uint stage) const
 289 {
 290         if (stage >= IDRV_MAT_MAXTEXTURES)
 291         {
 292                 nlwarning("UInstanceMaterialUser::getConstantColor : invalid stage");
 293                 return NLMISC::CRGBA::Black;
 294         }
 295         return _Object->getTexConstantColor(stage);
 296
 297 }
 298
 299 // ***************************************************************************
 300
 301 sint                            UInstanceMaterial::getLastTextureStage() const
 302 {
 303         sint lastStage = -1;
 304         for(uint k = 0; k < IDRV_MAT_MAXTEXTURES; ++k)
 305         {
 306                 if (_Object->getTexture(k) != NULL)
 307                 {
 308                         lastStage = k;
 309                 }
 310         }
 311         return lastStage;
 312 }
 313
 314 // ***************************************************************************
 315
 316 void                    UInstanceMaterial::setBlend(bool active)
 317 {
 318         _Object->setBlend(active);
 319 }
 320
 321 // ***************************************************************************
 322
 323 void                    UInstanceMaterial::setBlendFunc(TBlend src, TBlend dst)
 324 {
 325         _Object->setBlendFunc((CMaterial::TBlend)(uint32)src, (CMaterial::TBlend)(uint32)dst);
 326 }
 327
 328 // ***************************************************************************
 329
 330 void                    UInstanceMaterial::setSrcBlend(TBlend val)
 331 {
 332         _Object->setSrcBlend((CMaterial::TBlend)(uint32)val);
 333 }
 334
 335 // ***************************************************************************
 336
 337 void                    UInstanceMaterial::setDstBlend(TBlend val)
 338 {
 339         _Object->setDstBlend((CMaterial::TBlend)(uint32)val);
 340 }
 341
 342 // ***************************************************************************
 343
 344 void                    UInstanceMaterial::setAlphaTestThreshold(float at)
 345 {
 346         _Object->setAlphaTestThreshold(at);
 347 }
 348
 349 // ***************************************************************************
 350 float UInstanceMaterial::getAlphaTestThreshold() const
 351 {
 352         return _Object->getAlphaTestThreshold();
 353 }
 354
 355 // ***************************************************************************
 356 void UInstanceMaterial::setAlphaTest(bool active)
 357 {
 358         _Object->setAlphaTest(active);
 359 }
 360
 361 // ***************************************************************************
 362
 363 void                    UInstanceMaterial::setZWrite(bool active)
 364 {
 365         _Object->setZWrite(active);
 366 }
 367
 368 // ***************************************************************************
 369 void UInstanceMaterial::setZFunc(ZFunc val)
 370 {
 371                 _Object->setZFunc((CMaterial::ZFunc) val);
 372 }
 373
 374 // ***************************************************************************
 375
 376 bool                    UInstanceMaterial::getBlend() const
 377 {
 378         return _Object->getBlend();
 379 }
 380
 381 // ***************************************************************************
 382
 383 UInstanceMaterial::TBlend                       UInstanceMaterial::getSrcBlend(void)  const
 384 {
 385         return (UInstanceMaterial::TBlend)(uint32)_Object->getSrcBlend();
 386 }
 387
 388 // ***************************************************************************
 389
 390 UInstanceMaterial::TBlend                       UInstanceMaterial::getDstBlend(void)  const
 391 {
 392         return (UInstanceMaterial::TBlend)(uint32)_Object->getDstBlend();
 393 }
 394
 395 // ***************************************************************************
 396
 397 void                    UInstanceMaterial::enableUserTexMat(uint stage, bool enabled)
 398 {
 399         if (stage >= IDRV_MAT_MAXTEXTURES)
 400         {
 401                 nlwarning("UInstanceMaterial::enableUserTexMat : stage %d is invalid", stage);
 402                 return;
 403         }
 404         _Object->enableUserTexMat(stage, enabled);
 405 }
 406
 407 // ***************************************************************************
 408
 409 bool                    UInstanceMaterial::isUserTexMatEnabled(uint stage) const
 410 {
 411         if (stage >= IDRV_MAT_MAXTEXTURES)
 412         {
 413                 nlwarning("UInstanceMaterial::enableUserTexMat : stage %d is invalid", stage);
 414                 return false;
 415         }
 416         return _Object->isUserTexMatEnabled(stage);
 417 }
 418
 419 // ***************************************************************************
 420
 421 void                                    UInstanceMaterial::setUserTexMat(uint stage, const NLMISC::CMatrix &m)
 422 {
 423         if (stage >= IDRV_MAT_MAXTEXTURES)
 424         {
 425                 nlwarning("UInstanceMaterial::enableUserTexMat : stage %d is invalid", stage);
 426                 return;
 427         }
 428         if (!_Object->isUserTexMatEnabled(stage))
 429         {
 430                 nlwarning("UInstanceMaterial::setUserTexMat : texture stage %d has no user matrix.", stage);
 431         }
 432         _Object->setUserTexMat(stage, m);
 433 }
 434
 435 // ***************************************************************************
 436
 437 const NLMISC::CMatrix  &UInstanceMaterial::getUserTexMat(uint stage) const
 438 {
 439         if (stage >= IDRV_MAT_MAXTEXTURES)
 440         {
 441                 nlwarning("UInstanceMaterial::enableUserTexMat : stage %d is invalid", stage);
 442                 return CMatrix::Identity;
 443         }
 444         if (!_Object->isUserTexMatEnabled(stage))
 445         {
 446                 nlwarning("UInstanceMaterial::setUserTexMat : texture stage %d has no user matrix.", stage);
 447                 return CMatrix::Identity;
 448         }
 449         return _Object->getUserTexMat(stage);
 450 }
 451
 452 // ***************************************************************************
 453
 454 void                            UInstanceMaterial::setWrapS(uint stage, TWrapMode mode)
 455 {
 456         if (stage >= IDRV_MAT_MAXTEXTURES || _Object->getTexture(stage) == NULL)
 457         {
 458                 nlwarning("UInstanceMaterial::setWrapS : stage %d is invalid or there's no texture", stage);
 459                 return;
 460         }
 461         _Object->getTexture(stage)->setWrapS((ITexture::TWrapMode) mode);
 462 }
 463
 464 // ***************************************************************************
 465
 466 void                            UInstanceMaterial::setWrapT(uint stage, TWrapMode mode)
 467 {
 468         if (stage >= IDRV_MAT_MAXTEXTURES || _Object->getTexture(stage) == NULL)
 469         {
 470                 nlwarning("UInstanceMaterial::setWrapT : stage %d is invalid or there's no texture", stage);
 471                 return;
 472         }
 473         _Object->getTexture(stage)->setWrapT((ITexture::TWrapMode) mode);
 474 }
 475
 476 // ***************************************************************************
 477
 478 UInstanceMaterial::TWrapMode                    UInstanceMaterial::getWrapS(uint stage) const
 479 {
 480         if (stage >= IDRV_MAT_MAXTEXTURES || _Object->getTexture(uint8(stage)) == NULL)
 481         {
 482                 nlwarning("UInstanceMaterial::getWrapS : stage %d is invalid or there's no texture", stage);
 483                 return Repeat;
 484         }
 485         return (TWrapMode) _Object->getTexture(uint8(stage))->getWrapS();
 486 }
 487
 488 // ***************************************************************************
 489
 490 UInstanceMaterial::TWrapMode                    UInstanceMaterial::getWrapT(uint stage) const
 491 {
 492         if (stage >= IDRV_MAT_MAXTEXTURES || _Object->getTexture(uint8(stage)) == NULL)
 493         {
 494                 nlwarning("UInstanceMaterial::getWrapT : stage %d is invalid or there's no texture", stage);
 495                 return Repeat;
 496         }
 497         return (TWrapMode) _Object->getTexture(uint8(stage))->getWrapT();
 498 }
 499
 500 // ***************************************************************************
 501
 502 } // NL3D