nel/src/3d/u_transform.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_transform.h"
  20 #include "nel/3d/transform.h"
  21 #include "nel/3d/instance_group_user.h"
  22 #include "nel/misc/hierarchical_timer.h"
  23 #include "nel/3d/scene_group.h"
  24 #include "nel/3d/scene.h"
  25
  26 H_AUTO_DECL( NL3D_Transform_Set_Cluster_System )
  27
  28 #define NL3D_HAUTO_SET_CLUSTER_SYSTEM           H_AUTO_USE( NL3D_Transform_Set_Cluster_System )
  29
  30
  31 using namespace NLMISC;
  32
  33 #ifdef DEBUG_NEW
  34 #define new DEBUG_NEW
  35 #endif
  36
  37 namespace NL3D
  38 {
  39
  40 // ***************************************************************************
  41 void UTransform::setClusterSystem (UInstanceGroup *pIG)
  42 {
  43         NL3D_HAUTO_SET_CLUSTER_SYSTEM
  44
  45         CTransform      *object = getObjectPtr();
  46         if (object->getForceClipRoot())
  47         {
  48                 nlwarning("Transform has been flagged to be glued to the root, and thus can't be clusterized. See UTransform::setForceClipRoot(bool).");
  49                 return;
  50         }
  51         if ((pIG == NULL) || (pIG == (UInstanceGroup*)-1))
  52         {
  53                 if (pIG == NULL)
  54                         object->setClusterSystem (NULL);
  55                 else
  56                         object->setClusterSystem ((CInstanceGroup*)-1);
  57         }
  58         else
  59                 object->setClusterSystem (&((CInstanceGroupUser*)pIG)->getInternalIG());
  60 }
  61
  62 // ***************************************************************************
  63 UInstanceGroup *UTransform::getClusterSystem () const
  64 {
  65         CTransform      *object = getObjectPtr();
  66         CInstanceGroup  *ig= object->getClusterSystem();
  67         if(ig==((CInstanceGroup*)-1))
  68                 return ((UInstanceGroup*)-1);
  69         else if(ig==NULL)
  70                 return NULL;
  71         else
  72                 return ig->getUserInterface();
  73 }
  74
  75 // ***************************************************************************
  76 void                    UTransform::getLastParentClusters(std::vector<CCluster*> &clusters) const
  77 {
  78         CTransform      *object = getObjectPtr();
  79         CScene *scene = object->getOwnerScene();
  80         // look in the list of parent of the transform object and extract the CCluster parents
  81         if (scene == NULL)
  82                 return;
  83
  84         CClipTrav       &clipTrav= scene->getClipTrav();
  85
  86         uint    num= object->clipGetNumParents();
  87         for(uint i=0;i<num;i++)
  88         {
  89                 CCluster *pcluster = dynamic_cast<CCluster*>(object->clipGetParent(i));
  90                 if (pcluster != NULL)
  91                         clusters.push_back(pcluster);
  92         }
  93
  94         // If the object is link to a QuadCluster, add the RootCluster to the list
  95         CTransformShape *trShp= dynamic_cast<CTransformShape*>( object );
  96         if( trShp && trShp->isLinkToQuadCluster() )
  97                 clusters.push_back(clipTrav.RootCluster);
  98 }
  99
 100
 101 // ***************************************************************************
 102 void                    UTransform::freezeHRC()
 103 {
 104         CTransform      *object = getObjectPtr();
 105         object->freezeHRC();
 106 }
 107
 108 // ***************************************************************************
 109 void                    UTransform::unfreezeHRC()
 110 {
 111         CTransform      *object = getObjectPtr();
 112         while (object)
 113         {
 114                 object->unfreezeHRC();
 115                 object = object->hrcGetParent();
 116         }
 117 }
 118
 119
 120 // ***************************************************************************
 121 void                    UTransform::setLoadBalancingGroup(const std::string &group)
 122 {
 123         CTransform      *object = getObjectPtr();
 124         object->setLoadBalancingGroup(group);
 125 }
 126 // ***************************************************************************
 127 const std::string       &UTransform::getLoadBalancingGroup() const
 128 {
 129         CTransform      *object = getObjectPtr();
 130         return object->getLoadBalancingGroup();
 131 }
 132
 133 // ***************************************************************************
 134 void                    UTransform::setMeanColor(NLMISC::CRGBA color)
 135 {
 136         CTransform      *object = getObjectPtr();
 137         object->setMeanColor(color);
 138 }
 139 // ***************************************************************************
 140 NLMISC::CRGBA   UTransform::getMeanColor() const
 141 {
 142         CTransform      *object = getObjectPtr();
 143         return object->getMeanColor();
 144 }
 145
 146 // ***************************************************************************
 147 const CMatrix   &UTransform::getLastWorldMatrixComputed() const
 148 {
 149         CTransform      *object = getObjectPtr();
 150         return object->getWorldMatrix();
 151 }
 152
 153 // ***************************************************************************
 154 void                    UTransform::enableCastShadowMap(bool state)
 155 {
 156         CTransform      *object = getObjectPtr();
 157         object->enableCastShadowMap(state);
 158 }
 159
 160 // ***************************************************************************
 161 bool                    UTransform::canCastShadowMap() const
 162 {
 163         CTransform      *object = getObjectPtr();
 164         return object->canCastShadowMap();
 165 }
 166
 167 // ***************************************************************************
 168 void                    UTransform::enableReceiveShadowMap(bool state)
 169 {
 170         CTransform      *object = getObjectPtr();
 171         object->enableReceiveShadowMap(state);
 172 }
 173
 174 // ***************************************************************************
 175 bool                    UTransform::canReceiveShadowMap() const
 176 {
 177         CTransform      *object = getObjectPtr();
 178         return object->canReceiveShadowMap();
 179 }
 180
 181 // ***************************************************************************
 182 void                    UTransform::parent(UTransform newFather)
 183 {
 184         CTransform      *object = getObjectPtr();
 185         if (object->getForceClipRoot())
 186         {
 187                 nlwarning("Transform has been flagged to be glued to the root, can't change parent. See UTransform::setForceClipRoot(bool).");
 188                 return;
 189         }
 190         if(!newFather.empty())
 191         {
 192                 // link me to other.
 193                 CTransform      *other= newFather.getObjectPtr();
 194                 if(other->getOwnerScene()!=object->getOwnerScene())
 195                         nlerror("Try to parent 2 object from 2 differnet scenes!!");
 196                 other->hrcLinkSon( object );
 197         }
 198         else
 199         {
 200                 // link me to Root.
 201                 object->getOwnerScene()->getRoot()->hrcLinkSon( object );
 202         }
 203 }
 204
 205 // ***************************************************************************
 206 void UTransform::hide()
 207 {
 208         CTransform      *object = getObjectPtr();
 209         object->hide();
 210 }
 211
 212 // ***************************************************************************
 213
 214 void UTransform::show()
 215 {
 216         CTransform      *object = getObjectPtr();
 217         object->show();
 218 }
 219
 220 // ***************************************************************************
 221
 222 void UTransform::setUserClipping(bool enable)
 223 {
 224         CTransform      *object = getObjectPtr();
 225         object->setUserClipping(enable);
 226 }
 227
 228 // ***************************************************************************
 229
 230 bool UTransform::getUserClipping() const
 231 {
 232         CTransform      *object = getObjectPtr();
 233         return object->getUserClipping();
 234 }
 235
 236 // ***************************************************************************
 237
 238 void UTransform::heritVisibility()
 239 {
 240         CTransform      *object = getObjectPtr();
 241         object->heritVisibility();
 242 }
 243
 244 // ***************************************************************************
 245
 246 UTransform::TVisibility UTransform::getVisibility()
 247 {
 248         CTransform      *object = getObjectPtr();
 249         return (UTransform::TVisibility)(uint32)object->getVisibility();
 250 }
 251
 252 // ***************************************************************************
 253
 254 void UTransform::setOrderingLayer(uint layer)
 255 {
 256         CTransform      *object = getObjectPtr();
 257         object->setOrderingLayer(layer);
 258 }
 259
 260 // ***************************************************************************
 261
 262 uint UTransform::getOrderingLayer() const
 263 {
 264         CTransform      *object = getObjectPtr();
 265         return object->getOrderingLayer();
 266 }
 267
 268 // ***************************************************************************
 269
 270 void UTransform::setUserLightable(bool enable)
 271 {
 272         CTransform      *object = getObjectPtr();
 273         object->setUserLightable(enable);
 274 }
 275
 276 // ***************************************************************************
 277
 278 bool UTransform::getUserLightable() const
 279 {
 280         CTransform      *object = getObjectPtr();
 281         return  object->getUserLightable();
 282 }
 283
 284 // ***************************************************************************
 285
 286 void UTransform::setLogicInfo(ILogicInfo *logicInfo)
 287 {
 288         CTransform      *object = getObjectPtr();
 289         object->setLogicInfo(logicInfo);
 290 }
 291
 292 // ***************************************************************************
 293
 294 bool UTransform::getLastWorldVisState() const
 295 {
 296         CTransform      *object = getObjectPtr();
 297         return object->isHrcVisible();
 298 }
 299
 300 // ***************************************************************************
 301
 302 bool UTransform::getLastClippedState() const
 303 {
 304         CTransform      *object = getObjectPtr();
 305         return object->isClipVisible();
 306 }
 307
 308 // ***************************************************************************
 309
 310 void UTransform::setTransparency(bool v)
 311 {
 312         CTransform      *object = getObjectPtr();
 313         object->setTransparency(v);
 314 }
 315
 316 // ***************************************************************************
 317
 318 void UTransform::setOpacity(bool v)
 319 {
 320         CTransform      *object = getObjectPtr();
 321         object->setOpacity(v);
 322 }
 323
 324 // ***************************************************************************
 325 void UTransform::setBypassLODOpacityFlag(bool bypass)
 326 {
 327         CTransform      *object = getObjectPtr();
 328         object->setBypassLODOpacityFlag(bypass);
 329 }
 330
 331 // ***************************************************************************
 332
 333 uint32 UTransform::isOpaque()
 334 {
 335         CTransform      *object = getObjectPtr();
 336         return object->isOpaque();
 337 }
 338
 339 // ***************************************************************************
 340
 341 uint32 UTransform::isTransparent()
 342 {
 343         CTransform      *object = getObjectPtr();
 344         return object->isTransparent();
 345 }
 346
 347 // ***************************************************************************
 348
 349 void UTransform::setForceClipRoot(bool forceClipRoot)
 350 {
 351         CTransform      *object = getObjectPtr();
 352         object->setForceClipRoot(forceClipRoot);
 353 }
 354
 355 // ***************************************************************************
 356
 357 bool UTransform::getForceClipRoot() const
 358 {
 359         CTransform      *object = getObjectPtr();
 360         return object->getForceClipRoot();
 361 }
 362
 363 // ***************************************************************************
 364
 365 void UTransform::setTransparencyPriority(uint8 priority)
 366 {
 367         CTransform      *object = getObjectPtr();
 368         object->setTransparencyPriority(priority);
 369 }
 370
 371 // ***************************************************************************
 372 void UTransform::setShadowMapDirectionZThreshold(float zthre)
 373 {
 374         CTransform      *object = getObjectPtr();
 375         object->setShadowMapDirectionZThreshold(zthre);
 376 }
 377
 378 // ***************************************************************************
 379 float UTransform::getShadowMapDirectionZThreshold() const
 380 {
 381         CTransform      *object = getObjectPtr();
 382         return object->getShadowMapDirectionZThreshold();
 383 }
 384
 385 // ***************************************************************************
 386 void UTransform::setShadowMapMaxDepth(float depth)
 387 {
 388         CTransform      *object = getObjectPtr();
 389         object->setShadowMapMaxDepth(depth);
 390 }
 391
 392 // ***************************************************************************
 393 float   UTransform::getShadowMapMaxDepth() const
 394 {
 395         CTransform      *object = getObjectPtr();
 396         return object->getShadowMapMaxDepth();
 397 }
 398
 399 // ***************************************************************************
 400 bool    UTransform::supportFastIntersect() const
 401 {
 402         CTransform      *object = getObjectPtr();
 403         return object->supportFastIntersect();
 404 }
 405
 406 // ***************************************************************************
 407 bool    UTransform::fastIntersect(const NLMISC::CVector &p0, const NLMISC::CVector &dir, float &dist2D, float &distZ, bool computeDist2D)
 408 {
 409         CTransform      *object = getObjectPtr();
 410         return object->fastIntersect(p0, dir, dist2D, distZ, computeDist2D);
 411 }
 412
 413
 414 } // NL3D