nel/src/3d/u_instance.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.h"
  20 #include "nel/3d/transform_shape.h"
  21 #include "nel/3d/mesh_base.h"
  22 #include "nel/3d/driver_user.h"
  23 #include "nel/3d/mesh_multi_lod_instance.h"
  24 #include "nel/3d/seg_remanence.h"
  25 #include "nel/misc/debug.h"
  26 #include "nel/3d/scene.h"
  27 #include "nel/3d/shape_bank.h"
  28
  29
  30 using   namespace NLMISC;
  31
  32 #ifdef DEBUG_NEW
  33 #define new DEBUG_NEW
  34 #endif
  35
  36 namespace NL3D
  37 {
  38
  39
  40 // ***************************************************************************
  41
  42 void UInstance::getShapeAABBox(NLMISC::CAABBox &bbox) const
  43 {
  44         CTransformShape *object = getObjectPtr();
  45         object->getAABBox(bbox);
  46 }
  47
  48 // ***************************************************************************
  49 void UInstance::setBlendShapeFactor (const std::string &blendShapeName, float factor, bool /* dynamic */)
  50 {
  51         CTransformShape *object = getObjectPtr();
  52         CMeshBaseInstance       *mi= dynamic_cast<CMeshBaseInstance*>(object);
  53
  54         if (mi)
  55         {
  56                 mi->setBlendShapeFactor (blendShapeName, factor);
  57         }
  58 }
  59
  60 // ***************************************************************************
  61 void            UInstance::changeMRMDistanceSetup(float distanceFinest, float distanceMiddle, float distanceCoarsest)
  62 {
  63         CTransformShape *object = getObjectPtr();
  64         CMeshBaseInstance       *mi= dynamic_cast<CMeshBaseInstance*>(object);
  65
  66         // Just for CMeshBaseInstance.
  67         if (mi)
  68         {
  69                 mi->changeMRMDistanceSetup(distanceFinest, distanceMiddle, distanceCoarsest);
  70         }
  71 }
  72
  73
  74 // ***************************************************************************
  75 void            UInstance::setShapeDistMax(float distMax)
  76 {
  77         CTransformShape *object = getObjectPtr();
  78         if(object && object->Shape)
  79         {
  80                 object->Shape->setDistMax(distMax);
  81         }
  82 }
  83
  84 // ***************************************************************************
  85 float           UInstance::getShapeDistMax() const
  86 {
  87         CTransformShape *object = getObjectPtr();
  88         if(object && object->Shape)
  89         {
  90                 return object->Shape->getDistMax();
  91         }
  92         else
  93                 return -1;
  94 }
  95
  96
  97 // ***************************************************************************
  98 void            UInstance::selectTextureSet(uint id)
  99 {
 100         CTransformShape *object = getObjectPtr();
 101         CMeshBaseInstance *mbi  = dynamic_cast<CMeshBaseInstance *>(object);
 102         if (mbi)
 103                 mbi->selectTextureSet(id);
 104 }
 105
 106
 107 // ***************************************************************************
 108 void            UInstance::enableAsyncTextureMode(bool enable)
 109 {
 110         CTransformShape *object = getObjectPtr();
 111         if(object->isMeshBaseInstance())
 112         {
 113                 CMeshBaseInstance *mbi  = static_cast<CMeshBaseInstance *>(object);
 114                 mbi->enableAsyncTextureMode(enable) ;
 115         }
 116 }
 117 // ***************************************************************************
 118 bool            UInstance::getAsyncTextureMode() const
 119 {
 120         CTransformShape *object = getObjectPtr();
 121         if(object->isMeshBaseInstance())
 122         {
 123                 CMeshBaseInstance *mbi  = static_cast<CMeshBaseInstance *>(object);
 124                 return mbi->getAsyncTextureMode() ;
 125         }
 126         else
 127                 return false;
 128 }
 129 // ***************************************************************************
 130 void            UInstance::startAsyncTextureLoading()
 131 {
 132         CTransformShape *object = getObjectPtr();
 133         if(object->isMeshBaseInstance())
 134         {
 135                 CMeshBaseInstance *mbi  = static_cast<CMeshBaseInstance *>(object);
 136                 mbi->startAsyncTextureLoading(getPos());
 137         }
 138 }
 139 // ***************************************************************************
 140 bool            UInstance::isAsyncTextureReady()
 141 {
 142         CTransformShape *object = getObjectPtr();
 143         if(object->isMeshBaseInstance())
 144         {
 145                 CMeshBaseInstance *mbi  = static_cast<CMeshBaseInstance *>(object);
 146                 return mbi->isAsyncTextureReady();
 147         }
 148         else
 149                 return true;
 150 }
 151 // ***************************************************************************
 152 void            UInstance::setAsyncTextureDistance(float dist)
 153 {
 154         CTransformShape *object = getObjectPtr();
 155         if(object->isMeshBaseInstance())
 156         {
 157                 CMeshBaseInstance *mbi  = static_cast<CMeshBaseInstance *>(object);
 158                 mbi->setAsyncTextureDistance(dist);
 159         }
 160 }
 161 // ***************************************************************************
 162 float           UInstance::getAsyncTextureDistance() const
 163 {
 164         CTransformShape *object = getObjectPtr();
 165         if(object->isMeshBaseInstance())
 166         {
 167                 CMeshBaseInstance *mbi  = static_cast<CMeshBaseInstance *>(object);
 168                 return mbi->getAsyncTextureDistance();
 169         }
 170         else
 171                 return 0.f;
 172 }
 173 // ***************************************************************************
 174 void            UInstance::setAsyncTextureDirty(bool flag)
 175 {
 176         CTransformShape *object = getObjectPtr();
 177         if(object->isMeshBaseInstance())
 178         {
 179                 CMeshBaseInstance *mbi  = static_cast<CMeshBaseInstance *>(object);
 180                 mbi->setAsyncTextureDirty(flag);
 181         }
 182 }
 183 // ***************************************************************************
 184 bool            UInstance::isAsyncTextureDirty() const
 185 {
 186         CTransformShape *object = getObjectPtr();
 187         if(object->isMeshBaseInstance())
 188         {
 189                 CMeshBaseInstance *mbi  = static_cast<CMeshBaseInstance *>(object);
 190                 return mbi->isAsyncTextureDirty();
 191         }
 192         else
 193                 return false;
 194 }
 195
 196 // ***************************************************************************
 197 void UInstance::setCoarseMeshDist(float dist)
 198 {
 199         CTransformShape *object = getObjectPtr();
 200         CMeshMultiLodInstance *mmli = dynamic_cast<CMeshMultiLodInstance *>(object);
 201         if (mmli) mmli->setCoarseMeshDist(dist);
 202 }
 203
 204 // ***************************************************************************
 205 float UInstance::getCoarseMeshDist() const
 206 {
 207         CTransformShape *object = getObjectPtr();
 208         CMeshMultiLodInstance *mmli = dynamic_cast<CMeshMultiLodInstance *>(object);
 209         return mmli ? mmli->getCoarseMeshDist() : -1.f;
 210 }
 211
 212 // ***************************************************************************
 213 void UInstance::setSliceTime(float duration)
 214 {
 215         CTransformShape *object = getObjectPtr();
 216         CSegRemanence *sr = dynamic_cast<CSegRemanence *>(object);
 217         if (!sr) return;
 218         sr->setSliceTime(duration);
 219 }
 220
 221 // ***************************************************************************
 222 float UInstance::getSliceTime() const
 223 {
 224         CTransformShape *object = getObjectPtr();
 225         CSegRemanence *sr = dynamic_cast<CSegRemanence *>(object);
 226         if (!sr) return 0.f;
 227         return sr->getSliceTime();
 228 }
 229
 230 // ***************************************************************************
 231 bool UInstance::supportMaterialRendering(UDriver &drv, bool forceBaseCaps)
 232 {
 233         CTransformShape *object = getObjectPtr();
 234         IDriver *driver = static_cast<CDriverUser*>(&drv)->getDriver ();
 235         const uint count = object->getNumMaterial ();
 236         uint i;
 237         for (i=0; i<count; i++)
 238         {
 239                 if (!object->getMaterial (i)->isSupportedByDriver(*driver, forceBaseCaps))
 240                         return false;
 241         }
 242         return true;
 243 }
 244
 245 // ***************************************************************************
 246
 247 uint UInstance::getNumMaterials() const
 248 {
 249         CMeshBaseInstance       *mi= dynamic_cast<CMeshBaseInstance*>(_Object);
 250         if(mi)
 251                 return (uint)mi->Materials.size();
 252         else
 253                 return 0;
 254 }
 255
 256 // ***************************************************************************
 257
 258 UInstanceMaterial UInstance::getMaterial(uint materialId)
 259 {
 260         CMeshBaseInstance       *mi= dynamic_cast<CMeshBaseInstance*>(_Object);
 261         nlassertex (mi, ("Should be a CMeshBaseInstance object. Call getNumMaterials() first."));
 262
 263         // create user mats.
 264         return UInstanceMaterial (mi, &mi->Materials[materialId], &mi->AsyncTextures[materialId]);
 265 }
 266
 267 // ***************************************************************************
 268
 269 bool UInstance::canStartStop()
 270 {
 271         CTransformShape *object = getObjectPtr();
 272         return object->canStartStop();
 273 }
 274
 275 // ***************************************************************************
 276
 277 void UInstance::start()
 278 {
 279         CTransformShape *object = getObjectPtr();
 280         object->start();
 281 }
 282
 283 // ***************************************************************************
 284
 285 void UInstance::stop()
 286 {
 287         CTransformShape *object = getObjectPtr();
 288         object->stop();
 289 }
 290
 291 // ***************************************************************************
 292
 293 bool UInstance::isStarted() const
 294 {
 295         CTransformShape *object = getObjectPtr();
 296         return object->isStarted();
 297 }
 298
 299 // ***************************************************************************
 300
 301 float UInstance::getDistMax() const
 302 {
 303         CTransformShape *object = getObjectPtr();
 304         return object->getDistMax();
 305 }
 306
 307 // ***************************************************************************
 308
 309 void UInstance::setDistMax(float distMax)
 310 {
 311         CTransformShape *object = getObjectPtr();
 312         object->setDistMax(distMax);
 313 }
 314
 315 // ***************************************************************************
 316 UShape          UInstance::getShape() const
 317 {
 318
 319         CTransformShape *object = getObjectPtr();
 320         if(!object)
 321                 return UShape();
 322
 323         // get the shape name
 324         return UShape(object->Shape);
 325 }
 326
 327 // ***************************************************************************
 328 const std::string &UInstance::getShapeName() const
 329 {
 330
 331         static std::string emptyStr;
 332
 333         CTransformShape *object = getObjectPtr();
 334         if(!object)
 335                 return emptyStr;
 336
 337         // get the shape bank
 338         CScene *scene= object->getOwnerScene();
 339         CShapeBank      *sb= scene->getShapeBank();
 340         if(!sb)
 341                 return emptyStr;
 342
 343         // get the shape name
 344         const std::string *str= sb->getShapeNameFromShapePtr(object->Shape);
 345         if(str)
 346                 return *str;
 347         else
 348                 return emptyStr;
 349 }
 350
 351 // ***************************************************************************
 352 void    UInstance::cast(UTransform object)
 353 {
 354         attach(dynamic_cast<CTransformShape*>(object.getObjectPtr()));
 355 }
 356
 357 // ***************************************************************************
 358 bool    UInstance::getDefaultPos (CVector &pos) const
 359 {
 360         CTransformShape *object = getObjectPtr();
 361         if(object && object->isMeshBaseInstance())
 362         {
 363                 CMeshBaseInstance *mbi  = static_cast<CMeshBaseInstance *>(object);
 364                 CMeshBase *mb= (CMeshBase*)(IShape*)(mbi->Shape);
 365                 pos= mb->getDefaultPos()->getDefaultValue();
 366                 return true;
 367         }
 368         return false;
 369 }
 370
 371 // ***************************************************************************
 372 bool    UInstance::getDefaultRotQuat (CQuat &rotQuat) const
 373 {
 374         CTransformShape *object = getObjectPtr();
 375         if(object && object->isMeshBaseInstance())
 376         {
 377                 CMeshBaseInstance *mbi  = static_cast<CMeshBaseInstance *>(object);
 378                 CMeshBase *mb= (CMeshBase*)(IShape*)(mbi->Shape);
 379                 rotQuat= mb->getDefaultRotQuat()->getDefaultValue();
 380                 return true;
 381         }
 382         return false;
 383 }
 384
 385 // ***************************************************************************
 386 bool    UInstance::getDefaultScale (CVector &scale) const
 387 {
 388         CTransformShape *object = getObjectPtr();
 389         if(object && object->isMeshBaseInstance())
 390         {
 391                 CMeshBaseInstance *mbi  = static_cast<CMeshBaseInstance *>(object);
 392                 CMeshBase *mb= (CMeshBase*)(IShape*)(mbi->Shape);
 393                 scale= mb->getDefaultScale()->getDefaultValue();
 394                 return true;
 395         }
 396         return false;
 397 }
 398
 399 // ***************************************************************************
 400 void    UInstance::setRelativeScale (const CVector &rs)
 401 {
 402         CTransformShape *object = getObjectPtr();
 403         if(object && object->isMeshBaseInstance())
 404         {
 405                 // get the default scale
 406                 CMeshBaseInstance *mbi  = static_cast<CMeshBaseInstance *>(object);
 407                 CMeshBase *mb= (CMeshBase*)(IShape*)(mbi->Shape);
 408                 CVector scale= mb->getDefaultScale()->getDefaultValue();
 409                 // scale it by the relative one
 410                 scale.x*= rs.x;
 411                 scale.y*= rs.y;
 412                 scale.z*= rs.z;
 413                 object->setScale(scale);
 414         }
 415 }
 416
 417
 418 } // NL3D