nel/src/3d/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/transform.h"
  20 #include "nel/3d/skeleton_model.h"
  21 #include "nel/3d/scene.h"
  22 #include "nel/3d/scene_group.h"
  23 #include "nel/3d/root_model.h"
  24 #include "nel/3d/u_transform.h"
  25 #include "nel/misc/fast_floor.h"
  26 #include "nel/misc/hierarchical_timer.h"
  27
  28
  29 using namespace NLMISC;
  30 using namespace std;
  31
  32 #ifdef DEBUG_NEW
  33 #define new DEBUG_NEW
  34 #endif
  35
  36 namespace       NL3D
  37 {
  38
  39
  40 // ***************************************************************************
  41 #define NL3D_TRANSFORM_DEFAULT_SHADOW_MAP_DEPTH         8.f
  42
  43
  44 // ***************************************************************************
  45 void    CTransform::registerBasic()
  46 {
  47         CScene::registerModel( TransformId, 0, CTransform::creator);
  48 }
  49
  50
  51 // ***************************************************************************
  52 CTransform::CTransform()
  53 {
  54         // important to reset for destructor to know if linked or not (CCluster !!)
  55         _OwnerScene= NULL;
  56
  57         // Hrc/Graph hierarchy
  58         _HrcParent= NULL;
  59         _HrcParentUnfreeze= NULL;
  60
  61         _PrecModelToUpdate= NULL;
  62         _NextModelToUpdate= NULL;
  63
  64         _TransformDirty= true;
  65
  66         Visibility= CHrcTrav::Herit;
  67
  68         _LastTransformableMatrixDate= 0;
  69
  70         _FatherSkeletonModel= NULL;
  71
  72         _ClusterSystem = NULL;
  73
  74         _FreezeHRCState= FreezeHRCStateDisabled;
  75
  76         _OrderingLayer = 2;
  77
  78         _TransparencyPriority = 0;
  79
  80
  81         // No logicInfo by default
  82         _LogicInfo= NULL;
  83
  84         _ForceCLodSticked= false;
  85
  86         // default MeanColor value
  87         _MeanColor.set(255,255,255,255);
  88
  89         // Default ShadowMap direction
  90         _ShadowMapDirectionZThreshold= -0.5f;
  91         _ShadowMapMaxDepth= NL3D_TRANSFORM_DEFAULT_SHADOW_MAP_DEPTH;
  92
  93         // Setup some state.
  94
  95         /*
  96                 Default are:
  97                         IsAnimDetailable= 0
  98                         IsLoadBalancable= 0
  99                         IsLightable= 0
 100                         IsRenderable= 0
 101                         IsTransparent= 0
 102                         IsOpaque= 1
 103                         QuadGridClipEnabled= 0.
 104
 105                         IsUserLightable= 1                      // default, the model may be lighted.
 106                         IsFinalLightable= 0
 107                         IsNeedUpdateLighting= 0
 108                         ISNeedUpdateFrozenStaticLightSetup= 0
 109
 110                         IsSkeleton= 0
 111                         IsTransformShape=0
 112                         IsCluster= 0
 113                         IsMeshBaseInstance= 0
 114
 115                         IsDeleteChannelMixer = 0;
 116         */
 117         _StateFlags= IsOpaque | IsUserLightable;
 118
 119         // By default, always allow rendering of Transform Models.
 120         _RenderFilterType = std::numeric_limits<uint32>::max();
 121
 122         // By default, don't suport fast intersection detection
 123         _SupportFastIntersect= false;
 124
 125
 126         // **** HRC Init Traversal Computed Data.
 127         _LocalVis= CHrcTrav::Herit; _LocalMatrix.identity(); _LocalDate=0;
 128         _WorldVis= true; _WorldMatrix.identity();
 129         // Init the _WorldDate to -1 so at first pass, _LocalDate>_WorldDate, and so
 130         // the model will be processed and so it'll may be inserted in LightingManager (for example)
 131         _WorldDate=-1;
 132         _Frozen = false;
 133         _DontUnfreezeChildren = false;
 134         _AncestorSkeletonModel= NULL;
 135         _ClipLinkedInSonsOfAncestorSkeletonModelGroup= false;
 136
 137         // **** Clip Init Traversal Computed Data.
 138         _ClipDate= 0;
 139         _Visible=false;
 140         _IndexInVisibleList= -1;
 141
 142         // **** AnimDetail Init Traversal Computed Data.
 143         // none
 144
 145         // **** LoadBalancing Init Traversal Computed Data.
 146         _LoadBalancingGroup= NULL;
 147 }
 148
 149
 150 // ***************************************************************************
 151 CTransform::~CTransform()
 152 {
 153         // If still binded to a father skeleton
 154         if( _FatherSkeletonModel )
 155         {
 156                 /* If skinned, cannot detach me from skeleton here because detachSkeletonSon()
 157                         use some virtual calls of transform: setApplySkin().
 158                         Hence, It is the deriver job to detach himself from the skeleton.
 159
 160                         NB: test isSkinned(), not isSkinnable(), since isSkinned() is not virtual ....
 161                         This means that if a Mesh isSkinnable(), but never skinned, it is not asserted here.
 162                 */
 163                 if( isSkinned() )
 164                 {
 165                         nlstop;
 166                 }
 167                 else
 168                         // Can detach Me. Important for UTransform sticked
 169                         _FatherSkeletonModel->detachSkeletonSon(this);
 170         }
 171
 172         // resetLighting, removing me from PointLight Transform list.
 173         // NB: not done for FrozenStaticLightSetup, because those lights don't owns me.
 174         resetLighting();
 175
 176         // Must also remove me from the lightingManager.
 177         // must test getOwnerScene() because of CCluster usage out of CScene (thanks to mat!! :) )
 178         if(getOwnerScene())
 179         {
 180                 CLightTrav      &lightTrav= getOwnerScene()->getLightTrav();
 181                 _LightedModelIt= lightTrav.LightingManager.eraseStaticLightedModel(_LightedModelIt);
 182         }
 183
 184         if (getChannelMixerOwnerShip()) delete (CChannelMixer *) _ChannelMixer;
 185
 186         // ensure the model is no more linked to the UpdateList.
 187         unlinkFromUpdateList();
 188
 189         // I must remove me from _VisibleList.
 190         if(_IndexInVisibleList>=0)
 191         {
 192                 CClipTrav       &clipTrav= getOwnerScene()->getClipTrav();
 193                 nlassert(_IndexInVisibleList < (sint)clipTrav._CurrentNumVisibleModels );
 194                 // Mark NULL. NB: faster than a CRefPtr.
 195                 clipTrav._VisibleList[_IndexInVisibleList]= NULL;
 196                 _IndexInVisibleList= -1;
 197         }
 198
 199         // remove me from parents in Hrc and Clip
 200         setStateFlag(ForceClipRoot, false); // ensure that not 'glued' to the root so that the following call will succeed
 201         hrcUnlink();
 202         clipUnlinkFromAll();
 203
 204         // remove mys sons.
 205         while(hrcGetNumChildren())
 206         {
 207                 hrcGetChild(0)->hrcUnlink();
 208         }
 209         while(clipGetNumChildren())
 210         {
 211                 clipDelChild(clipGetChild(0));
 212         }
 213
 214         nlassert(_HrcSons.empty());
 215         nlassert(_HrcParent==NULL);
 216         nlassert(_ClipSons.empty());
 217         nlassert(_ClipParents.empty());
 218 }
 219
 220
 221 // ***************************************************************************
 222 void    CTransform::initModel()
 223 {
 224         // assign me to the default group
 225         _LoadBalancingGroup= getOwnerScene()->getLoadBalancingTrav().getDefaultGroup();
 226 }
 227
 228
 229
 230 // ***************************************************************************
 231 void            CTransform::hide()
 232 {
 233         // Optim: do nothing if already set
 234         if(Visibility!= CHrcTrav::Hide)
 235         {
 236                 _TransformDirty= true;
 237                 Visibility= CHrcTrav::Hide;
 238                 // If skinned, then must inform skeleton parent that it must recompute skin render/animDetail lists
 239                 if(isSkinned())
 240                 {
 241                         nlassert(_FatherSkeletonModel);
 242                         _FatherSkeletonModel->dirtSkinRenderLists();
 243                 }
 244         }
 245 }
 246
 247 // ***************************************************************************
 248 void            CTransform::setTransparency(bool v)
 249 {
 250         bool bTmp = getStateFlag(IsTransparent) == 0 ? false : true;
 251         if (bTmp != v)
 252         {
 253                 setStateFlag(IsTransparent, v);
 254                 if(isSkinned())
 255                 {
 256                         nlassert(_FatherSkeletonModel);
 257                         _FatherSkeletonModel->dirtSkinRenderLists();
 258                 }
 259         }
 260 }
 261
 262 // ***************************************************************************
 263 void CTransform::setBypassLODOpacityFlag(bool bypass)
 264 {
 265         setStateFlag(BypassLODOpacity, bypass);
 266 }
 267
 268 // ***************************************************************************
 269 void            CTransform::setOpacity(bool v)
 270 {
 271         bool bTmp = getStateFlag(IsOpaque) == 0 ? false : true;
 272         if (bTmp != v)
 273         {
 274                 setStateFlag(IsOpaque, v);
 275                 if(isSkinned())
 276                 {
 277                         nlassert(_FatherSkeletonModel);
 278                         _FatherSkeletonModel->dirtSkinRenderLists();
 279                 }
 280         }
 281 }
 282
 283
 284 // ***************************************************************************
 285 void            CTransform::show()
 286 {
 287         // Optim: do nothing if already set
 288         if(Visibility!= CHrcTrav::Show)
 289         {
 290                 _TransformDirty= true;
 291                 Visibility= CHrcTrav::Show;
 292                 // If skinned, then must inform skeleton parent that it must recompute skin render/animDetail lists
 293                 if(isSkinned())
 294                 {
 295                         nlassert(_FatherSkeletonModel);
 296                         _FatherSkeletonModel->dirtSkinRenderLists();
 297                 }
 298         }
 299 }
 300 // ***************************************************************************
 301 void            CTransform::heritVisibility()
 302 {
 303         // Optim: do nothing if already set
 304         if(Visibility!= CHrcTrav::Herit)
 305         {
 306                 _TransformDirty= true;
 307                 Visibility= CHrcTrav::Herit;
 308                 // If skinned, then must inform skeleton parent that it must recompute skin render/animDetail lists
 309                 if(isSkinned())
 310                 {
 311                         nlassert(_FatherSkeletonModel);
 312                         _FatherSkeletonModel->dirtSkinRenderLists();
 313                 }
 314         }
 315 }
 316
 317
 318 // ***************************************************************************
 319 CTrackDefaultVector             CTransform::DefaultPos( CVector::Null );
 320 CTrackDefaultVector             CTransform::DefaultRotEuler( CVector::Null );
 321 CTrackDefaultQuat               CTransform::DefaultRotQuat( NLMISC::CQuat::Identity );
 322 CTrackDefaultVector             CTransform::DefaultScale( CVector(1,1,1) );
 323 CTrackDefaultVector             CTransform::DefaultPivot( CVector::Null );
 324
 325 ITrack* CTransform::getDefaultTrack (uint valueId)
 326 {
 327         // Cyril: prefer do it here in CTransform, because of CCamera, CLight etc... (which may not need a default value too!!)
 328
 329         // what value ?
 330         switch (valueId)
 331         {
 332         case PosValue:                  return &DefaultPos;
 333         case RotEulerValue:             return &DefaultRotEuler;
 334         case RotQuatValue:              return &DefaultRotQuat;
 335         case ScaleValue:                return &DefaultScale;
 336         case PivotValue:                return &DefaultPivot;
 337         }
 338
 339         // No, only ITrnasformable values!
 340         nlstop;
 341         // Deriver note: else call BaseClass::getDefaultTrack(valueId);
 342
 343         return NULL;
 344
 345 }
 346
 347 // ***************************************************************************
 348 void    CTransform::registerToChannelMixer(CChannelMixer *chanMixer, const std::string &prefix)
 349 {
 350         if (getChannelMixerOwnerShip() && chanMixer != _ChannelMixer)
 351         {
 352                 delete _ChannelMixer;
 353                 setChannelMixerOwnerShip(false);
 354         }
 355
 356         // Hey!! we are animated!!
 357         _ChannelMixer= chanMixer;
 358
 359         // Update flag, if we must be inserted in AnimDetail
 360         setStateFlag(IsAnimDetailable, _ChannelMixer || getStateFlag(IsForceAnimDetail) );
 361
 362         // If skinned, then must inform skeleton parent that it must recompute skin render/animDetail lists
 363         if(isSkinned())
 364         {
 365                 nlassert(_FatherSkeletonModel);
 366                 _FatherSkeletonModel->dirtSkinRenderLists();
 367         }
 368
 369         // For CTransfom, channels are not detailled.
 370         addValue(chanMixer, PosValue, OwnerBit, prefix, false);
 371         addValue(chanMixer, RotEulerValue, OwnerBit, prefix, false);
 372         addValue(chanMixer, RotQuatValue, OwnerBit, prefix, false);
 373         addValue(chanMixer, ScaleValue, OwnerBit, prefix, false);
 374         addValue(chanMixer, PivotValue, OwnerBit, prefix, false);
 375
 376         // Deriver note: if necessary, call     BaseClass::registerToChannelMixer(chanMixer, prefix);
 377 }
 378
 379
 380 // ***************************************************************************
 381 void                    CTransform::freeze()
 382 {
 383         // First, update the model
 384         // _Frozen state is disabled here (in CTransform::update()).
 385         update();
 386
 387         // Then flag the frozen state.
 388         _Frozen= true;
 389 }
 390
 391 // ***************************************************************************
 392 void                    CTransform::setDontUnfreezeChildren(bool val)
 393 {
 394         _DontUnfreezeChildren = val;
 395 }
 396
 397
 398 // ***************************************************************************
 399 void            CTransform::freezeHRC()
 400 {
 401         // if disabled, say we are ready to validate our worldMatrix for long.
 402         if(_FreezeHRCState==FreezeHRCStateDisabled)
 403         {
 404                 _FreezeHRCState= FreezeHRCStateRequest;
 405                 setStateFlag(QuadGridClipEnabled, true);
 406
 407                 /* If the transform is not frozen (ie staticaly inserted in a cluster),
 408                         We must be sure it will be tested against QuadGridClipManager at next ClipTrav pass.
 409                         => must make this object a "moving object" at next render=> dirt _LocalMatrixDate.
 410                 */
 411                 if(!_Frozen)
 412                 {
 413                         _TransformDirty= true;
 414                 }
 415         }
 416 }
 417
 418
 419 // ***************************************************************************
 420 void            CTransform::unfreezeHRC()
 421 {
 422         // if this model is no HRC frozen disabled
 423         if(_FreezeHRCState!=FreezeHRCStateDisabled)
 424         {
 425                 // if model correctly frozen.
 426                 if(_FreezeHRCState == CTransform::FreezeHRCStateEnabled )
 427                 {
 428                         // Should not be linked : can't link after a freezeHRC
 429                         nlassert (_HrcParent == NULL);
 430
 431                         // Set as unfreeze else, hrcLinkSon doesn't work
 432                         _FreezeHRCState= FreezeHRCStateDisabled;
 433
 434                         // Link this model to the previous HRC parent.
 435                         if (_HrcParentUnfreeze)
 436                                 _HrcParentUnfreeze->hrcLinkSon( this );
 437                         else
 438                                 getOwnerScene()->getRoot()->hrcLinkSon( this );
 439
 440                         // Link this object to the validateList.
 441                         linkToUpdateList();
 442
 443                         // if lightable()
 444                         if( isLightable() )
 445                         {
 446                                 CLightTrav      &lightTrav= getOwnerScene()->getLightTrav();
 447                                 // Lighting: must remove the object from the quadGrid.
 448                                 // NB: works if _LightedModelIt==NULL. result is that _LightedModelIt= NULL.
 449                                 _LightedModelIt= lightTrav.LightingManager.eraseStaticLightedModel(_LightedModelIt);
 450                         }
 451
 452                 }
 453                 else
 454                         _FreezeHRCState= FreezeHRCStateDisabled;
 455
 456                 // unlink me from any QuadCluster, and disable QuadCluster
 457                 unlinkFromQuadCluster();
 458                 setStateFlag(QuadGridClipEnabled, false);
 459         }
 460 }
 461
 462
 463 // ***************************************************************************
 464 void            CTransform::update()
 465 {
 466         // test if the matrix has been changed in ITransformable.
 467         if(ITransformable::compareMatrixDate(_LastTransformableMatrixDate))
 468         {
 469                 _LastTransformableMatrixDate= ITransformable::getMatrixDate();
 470                 _TransformDirty= true;
 471         }
 472
 473         // update the freezeHRC state.
 474         if(_FreezeHRCState != CTransform::FreezeHRCStateDisabled)
 475         {
 476                 // if the model request to be frozen in HRC
 477                 if(_FreezeHRCState == CTransform::FreezeHRCStateRequest )
 478                 {
 479                         // Wait for next Hrc traversal to compute good _WorldMatrix for this model and his sons.
 480                         // Also, next Hrc traversal will insert the model in the LightingManager quadGrid (if lightable)
 481                         _FreezeHRCState = CTransform::FreezeHRCStateReady;
 482                 }
 483                 // if the model is ready to be frozen in HRC, then do it!!
 484                 else if( _FreezeHRCState == CTransform::FreezeHRCStateReady )
 485                 {
 486                         // Unlink this model.
 487                         hrcUnlink();
 488
 489                         // unLink this object from the validateList. NB: the list will still be correclty parsed.
 490                         unlinkFromUpdateList();
 491
 492                         // if lightable, the model is inserted in a quadgrid to update his lighting only when
 493                         // dynamicLights touch him (since himself is static).
 494                         if( isLightable() )
 495                         {
 496                                 CLightTrav      &lightTrav= getOwnerScene()->getLightTrav();
 497                                 // Lighting: must reinsert the object from the quadGrid.
 498                                 // NB: works if _LightedModelIt==NULL. result is that _LightedModelIt= NULL.
 499                                 _LightedModelIt= lightTrav.LightingManager.eraseStaticLightedModel(_LightedModelIt);
 500                                 // insert in the quadgrid.
 501                                 _LightedModelIt= lightTrav.LightingManager.insertStaticLightedModel(this);
 502                         }
 503
 504                         // Now this model won't be tested for validation nor for worldMatrix update. End!!
 505                         _FreezeHRCState = CTransform::FreezeHRCStateEnabled;
 506                 }
 507         }
 508
 509         // update _LocalMatrix
 510         if(_TransformDirty)
 511         {
 512                 // update the local matrix.
 513                 _LocalMatrix= getMatrix();
 514                 _LocalVis= Visibility;
 515                 // update the date of the local matrix.
 516                 _LocalDate= getOwnerScene()->getHrcTrav().CurrentDate;
 517
 518                 // The transform has been modified. Hence, it is no more frozen.
 519                 _Frozen= false;
 520
 521                 // ok!
 522                 _TransformDirty= false;
 523         }
 524 }
 525
 526
 527 // ***************************************************************************
 528 void    CTransform::getAABBox(NLMISC::CAABBox &bbox) const
 529 {
 530         bbox.setCenter(CVector::Null);
 531         bbox.setHalfSize(CVector::Null);
 532 }
 533
 534
 535 // ***************************************************************************
 536 void    CTransform::setLoadBalancingGroup(const std::string &group)
 537 {
 538         // Get the traversal.
 539         CLoadBalancingTrav      &trav= getOwnerScene()->getLoadBalancingTrav();
 540         // get the group from trav (create if needed), and set it.
 541         _LoadBalancingGroup= trav.getOrCreateGroup(group);
 542 }
 543
 544
 545 // ***************************************************************************
 546 const std::string &CTransform::getLoadBalancingGroup() const
 547 {
 548         // get the group name
 549         return _LoadBalancingGroup->Name;
 550 }
 551
 552
 553 // ***************************************************************************
 554 void            CTransform::setMeanColor(CRGBA color)
 555 {
 556         // if the color is different from prec
 557         if(color!=_MeanColor)
 558         {
 559                 // change it.
 560                 _MeanColor= color;
 561         }
 562 }
 563
 564
 565 // ***************************************************************************
 566 void            CTransform::setIsLightable(bool val)
 567 {
 568         setStateFlag(IsLightable, val);
 569         // update IsFinalLightable
 570         setStateFlag(IsFinalLightable, (getStateFlag(IsLightable) && getStateFlag(IsUserLightable)) );
 571 }
 572 // ***************************************************************************
 573 void            CTransform::setUserLightable(bool enable)
 574 {
 575         setStateFlag(IsUserLightable, enable);
 576         // update IsFinalLightable
 577         setStateFlag(IsFinalLightable, (getStateFlag(IsLightable) && getStateFlag(IsUserLightable)) );
 578 }
 579
 580
 581 // ***************************************************************************
 582 void            CTransform::setIsRenderable(bool val)
 583 {
 584         setStateFlag(IsRenderable, val);
 585 }
 586
 587 // ***************************************************************************
 588 void            CTransform::setIsBigLightable(bool val)
 589 {
 590         setStateFlag(IsBigLightable, val);
 591 }
 592 // ***************************************************************************
 593 void            CTransform::setIsSkeleton(bool val)
 594 {
 595         setStateFlag(IsSkeleton, val);
 596 }
 597 // ***************************************************************************
 598 void            CTransform::setApplySkin(bool state)
 599 {
 600         setStateFlag(IsSkinned, state);
 601 }
 602
 603 // ***************************************************************************
 604 void            CTransform::setIsForceAnimDetail(bool val)
 605 {
 606         setStateFlag(IsForceAnimDetail, val );
 607
 608         // Update flag, if we must be inserted in AnimDetail
 609         setStateFlag(IsAnimDetailable, _ChannelMixer || getStateFlag(IsForceAnimDetail) );
 610
 611         // If skinned, then must inform skeleton parent that it must recompute skin render/animDetail lists
 612         if(isSkinned())
 613         {
 614                 nlassert(_FatherSkeletonModel);
 615                 _FatherSkeletonModel->dirtSkinRenderLists();
 616         }
 617 }
 618 // ***************************************************************************
 619 void            CTransform::setIsLoadbalancable(bool val)
 620 {
 621         setStateFlag(IsLoadBalancable, val );
 622 }
 623
 624
 625 // ***************************************************************************
 626 void            CTransform::linkToUpdateList()
 627 {
 628         if(!_OwnerScene)
 629                 return;
 630
 631         // If the model is not already inserted.
 632         if( ! (_PrecModelToUpdate!=NULL  ||  _OwnerScene->_UpdateModelList==this) )
 633         {
 634                 // insert it.
 635                 _NextModelToUpdate= _OwnerScene->_UpdateModelList;
 636                 _PrecModelToUpdate= NULL;
 637                 if(_NextModelToUpdate)
 638                         _NextModelToUpdate->_PrecModelToUpdate= this;
 639                 _OwnerScene->_UpdateModelList= this;
 640         }
 641 }
 642
 643 // ***************************************************************************
 644 void            CTransform::unlinkFromUpdateList()
 645 {
 646         if(!_OwnerScene)
 647                 return;
 648
 649         // If the model is inserted.
 650         if( _PrecModelToUpdate!=NULL  ||  _OwnerScene->_UpdateModelList==this )
 651         {
 652                 // update prec.
 653                 if(_PrecModelToUpdate)
 654                         _PrecModelToUpdate->_NextModelToUpdate= _NextModelToUpdate;
 655                 else
 656                         _OwnerScene->_UpdateModelList= _NextModelToUpdate;
 657
 658                 // update next.
 659                 if(_NextModelToUpdate)
 660                         _NextModelToUpdate->_PrecModelToUpdate= _PrecModelToUpdate;
 661
 662                 // End.
 663                 _PrecModelToUpdate= NULL;
 664                 _NextModelToUpdate= NULL;
 665         }
 666 }
 667
 668
 669 // ***************************************************************************
 670 // ***************************************************************************
 671 // Hrc Trav
 672 // ***************************************************************************
 673 // ***************************************************************************
 674
 675
 676 // ***************************************************************************
 677 void    CTransform::updateWorld()
 678 {
 679         const   CMatrix         *pFatherWM;
 680         bool                            visFather;
 681
 682         // If not root case, link to Fahter.
 683         if(_HrcParent)
 684         {
 685                 pFatherWM= &(_HrcParent->_WorldMatrix);
 686                 visFather= _HrcParent->_WorldVis;
 687
 688                 // if _HrcParent is not frozen (for any reason), disable us!
 689
 690                 if (!_HrcParent->_Frozen && !_HrcParent->_DontUnfreezeChildren)
 691                         _Frozen= false;
 692
 693                 // herit _AncestorSkeletonModel
 694                 if (_HrcParent->_AncestorSkeletonModel)
 695                         // If my father has an _AncestorSkeletonModel, get it.
 696                         _AncestorSkeletonModel= _HrcParent->_AncestorSkeletonModel;
 697                 else
 698                         // else I have an ancestor skel model if I am sticked/binded directly to a skeleton model.
 699                         _AncestorSkeletonModel= _FatherSkeletonModel;
 700         }
 701         // else, default!!
 702         else
 703         {
 704                 pFatherWM= &(CMatrix::Identity);
 705                 visFather= true;
 706
 707                 // at the root of the hierarchy, we have no parent, hence no FatherSkeletonModel nor _AncestorSkeletonModel.
 708                 _AncestorSkeletonModel= NULL;
 709
 710                 // NB: Root is Frozen by essence :), so don't modify the frozen state here.
 711         }
 712
 713         // Combine matrix
 714         if(_LocalDate>_WorldDate || (_HrcParent && _HrcParent->_WorldDate>_WorldDate) )
 715         {
 716                 // Must recompute the world matrix.  ONLY IF I AM NOT SKINNED/STICKED TO A SKELETON in the hierarchy!
 717                 if( _AncestorSkeletonModel==NULL )
 718                 {
 719                         _WorldMatrix=  *pFatherWM * _LocalMatrix;
 720                         _WorldDate= getOwnerScene()->getHrcTrav().CurrentDate;
 721
 722                         // Add the model to the moving object list, only if I am a transform shape
 723                         if (!_Frozen && isTransformShape() && !getStateFlag(ForceClipRoot))
 724                                 getOwnerScene()->getHrcTrav()._MovingObjects.push_back (static_cast<CTransformShape*>(this));
 725                 }
 726         }
 727
 728         // Update dynamic lighting.
 729         /*
 730                 If the model is not frozen in StaticLight, then must update lighting each frame.
 731                 Even if the object doesn't move, a new dynamic light may enter in its aera. Hence we must test
 732                 it in the light quadrid. StaticLight-ed Objects don't need it because they are inserted in a special quadgrid,
 733                 where dynamics lights touch all StaticLight-ed object to force their computing
 734
 735                 NB: not done if _AncestorSkeletonModel!=NULL. no need because  in this case,
 736                 result is driven by the _LightContribution of the _AncestorSkeletonModel.
 737         */
 738         if( !_LightContribution.FrozenStaticLightSetup && _AncestorSkeletonModel==NULL )
 739         {
 740                 // if the model is lightable reset lighting
 741                 if( isLightable() )
 742                         resetLighting();
 743         }
 744
 745         // Combine visibility.
 746         switch(_LocalVis)
 747         {
 748                 case CHrcTrav::Herit: _WorldVis= visFather; break;
 749                 case CHrcTrav::Hide: _WorldVis= false; break;
 750                 case CHrcTrav::Show: _WorldVis= true; break;
 751                 default: break;
 752         }
 753
 754
 755         // If I have an ancestor Skeleton Model, I must be binded in ClipTrav to the SonsOfAncestorSkeletonModelGroup
 756         updateClipTravForAncestorSkeleton();
 757
 758 }
 759
 760
 761 // ***************************************************************************
 762 void    CTransform::updateClipTravForAncestorSkeleton()
 763 {
 764         // If I have an ancestor Skeleton Model, I must be binded in ClipTrav to the SonsOfAncestorSkeletonModelGroup
 765         if(_AncestorSkeletonModel && !_ClipLinkedInSonsOfAncestorSkeletonModelGroup)
 766         {
 767                 // must unlink from ALL olds models.
 768                 clipUnlinkFromAll();
 769
 770                 // And link to SonsOfAncestorSkeletonModelGroup.
 771                 getOwnerScene()->SonsOfAncestorSkeletonModelGroup->clipAddChild(this);
 772
 773                 // update the flag.
 774                 _ClipLinkedInSonsOfAncestorSkeletonModelGroup= true;
 775         }
 776
 777
 778         // else I must be binded to the standard Root.
 779         if(!_AncestorSkeletonModel && _ClipLinkedInSonsOfAncestorSkeletonModelGroup)
 780         {
 781                 // verify first I am really still linked to the SonsOfAncestorSkeletonModelGroup.
 782                 // This test is important, because link may have changed for any reason (portals, clipManager....).
 783                 if( clipGetNumParents() == 1 && clipGetParent(0)==getOwnerScene()->SonsOfAncestorSkeletonModelGroup )
 784                 {
 785                         // must unlink from ALL olds models.
 786                         clipUnlinkFromAll();
 787                         // and now, link to std root.
 788                         getOwnerScene()->getRoot()->clipAddChild(this);
 789                 }
 790
 791                 // update the flag
 792                 _ClipLinkedInSonsOfAncestorSkeletonModelGroup= false;
 793         }
 794 }
 795
 796
 797 // ***************************************************************************
 798 void    CTransform::traverseHrc()
 799 {
 800         // Recompute the matrix, according to _HrcParent matrix mode, and local matrix.
 801         updateWorld();
 802
 803         // Traverse the Hrc sons.
 804         uint    num= hrcGetNumChildren();
 805         for(uint i=0;i<num;i++)
 806                 hrcGetChild(i)->traverseHrc();
 807 }
 808
 809
 810 // ***************************************************************************
 811 // ***************************************************************************
 812 // Clip Trav
 813 // ***************************************************************************
 814 // ***************************************************************************
 815
 816
 817 // ***************************************************************************
 818 void    CTransform::setClusterSystem(CInstanceGroup *pCS)
 819 {
 820         if (pCS != NULL)
 821         {
 822                 nlassert(!getStateFlag(ForceClipRoot)); // the transform must be linked to the root, and have not cluster system when this flag is set
 823         }
 824         // Special case for the "AutoClusterSystem" when pCS==-1
 825         if(pCS==(CInstanceGroup*)-1)
 826         {
 827                 _ClusterSystem = NULL;
 828                 setStateFlag(ClusterSystemAuto, true);
 829         }
 830         else
 831         {
 832                 _ClusterSystem = pCS;
 833                 setStateFlag(ClusterSystemAuto, false);
 834         }
 835 }
 836
 837 // ***************************************************************************
 838 CInstanceGroup*         CTransform::getClusterSystem ()
 839 {
 840         if(getStateFlag(ClusterSystemAuto))
 841                 return (CInstanceGroup*)-1;
 842         else
 843                 return _ClusterSystem;
 844 }
 845
 846 // ***************************************************************************
 847 void    CTransform::traverseClip()
 848 {
 849         // disable H_AUTO, because slowdown when lot of models (eg 1000-2000 tested in forest)
 850         //H_AUTO( NL3D_TransformClip );
 851
 852         CScene                  *scene= getOwnerScene();
 853         CClipTrav               &clipTrav= scene->getClipTrav();
 854
 855         if ((_ClipDate == clipTrav.CurrentDate) && _Visible)
 856                 return;
 857         _ClipDate = clipTrav.CurrentDate;
 858
 859         // clip: update Visible flag.
 860         _Visible= false;
 861         // if at least visible.
 862         if(_WorldVis)
 863         {
 864                 // If linked to a SkeletonModel anywhere in the hierarchy, don't clip, and use skeleton model clip result.
 865                 // This works because we are sons of a special node which is not in the clip traversal, and
 866                 // which is traversed at end of the traversal.
 867                 if( _AncestorSkeletonModel!=NULL )
 868                 {
 869                         _Visible= _AncestorSkeletonModel->isClipVisible();
 870                         // Special test: if we are sticked to a skeletonModel, and if we are still visible, maybe we don't have to
 871                         if(_Visible && _FatherSkeletonModel)
 872                         {
 873                                 // if our skeletonModel father is displayed with a Lod, maybe we are not to be displayed
 874                                 if(_FatherSkeletonModel->isDisplayedAsLodCharacter())
 875                                 {
 876                                         // We are visible only if we where sticked to the skeleton with forceCLod==true.
 877                                         // This is also true if we are actually a skeletonModel
 878                                         if(!_ForceCLodSticked)
 879                                                 // otherWise we are not visible. eg: this is the case of skins and some sticked object
 880                                                 _Visible= false;
 881                                 }
 882                         }
 883                 }
 884                 // else, clip.
 885                 else
 886                 {
 887                         // If the instance is not filtered
 888                         if(scene->getFilterRenderFlags() & _RenderFilterType)
 889                         {
 890                                 // User cliping enabled ?
 891                                 if (_StateFlags & UserClipping)
 892                                         _Visible= true;
 893                                 else
 894                                         _Visible= clip();
 895                         }
 896                 }
 897         }
 898
 899         // if visible, add to list.
 900         if(_Visible)
 901         {
 902                 // add this model to the visibility list.
 903                 clipTrav.addVisibleModel(this);
 904
 905                 // Has not an ancestor skeleton model?
 906                 if( _AncestorSkeletonModel==NULL )
 907                 {
 908                         // If needed, insert the model in the lighted list.
 909                         // don't insert if has an ancestorSkeletonModel, because in this case, result is driven by
 910                         // the _LightContribution of the _AncestorSkeletonModel.
 911                         if( isLightable() )
 912                                 scene->getLightTrav().addLightedModel(this);
 913
 914                         // If needed, insert the model in the animDetail list.
 915                         // don't insert if has an ancestoreSkeletonModel, because in this case, this ancestore will
 916                         // animDetail through the hierarchy...
 917                         if( isAnimDetailable() )
 918                                 scene->getAnimDetailTrav().addVisibleModel(this);
 919                 }
 920
 921                 // If needed, Add it to the loadBalancing trav
 922                 if( isLoadBalancable() )
 923                         scene->getLoadBalancingTrav().addVisibleModel(this);
 924
 925                 // If needed, insert the model in the render list.
 926                 if( isRenderable() )
 927                         scene->getRenderTrav().addRenderModel(this);
 928         }
 929
 930         // Traverse the Clip sons.
 931         uint    num= clipGetNumChildren();
 932         for(uint i=0;i<num;i++)
 933                 clipGetChild(i)->traverseClip();
 934 }
 935
 936
 937
 938 // ***************************************************************************
 939 // ***************************************************************************
 940 // AnimDetail Trav
 941 // ***************************************************************************
 942 // ***************************************************************************
 943
 944
 945 // ***************************************************************************
 946 void                    CTransform::updateWorldMatrixFromFather()
 947 {
 948         // If I am not skinned, and If I have a skeleton ancestor
 949         if(!isSkinned() && _AncestorSkeletonModel )
 950         {
 951                 // Compute the HRC _WorldMatrix.
 952                 // if I am not sticked.
 953                 if(!_FatherSkeletonModel)
 954                 {
 955                         // get the normal father worldMatrix in Hrc.
 956                         CTransform      *fatherTransform= hrcGetParent();
 957                         // if exist
 958                         if(fatherTransform)
 959                         {
 960                                 const CMatrix &parentWM= fatherTransform->_WorldMatrix;
 961                                 // combine worldMatrix
 962                                 _WorldMatrix= parentWM * _LocalMatrix;
 963                         }
 964                         else
 965                                 _WorldMatrix= _LocalMatrix;
 966                 }
 967                 else
 968                 {
 969                         // get the worldMatrix of the bone if I am sticked (standard stick)
 970                         if(!getStateFlag(SSSWO))
 971                         {
 972                                 const CMatrix &parentWM= _FatherSkeletonModel->Bones[_FatherBoneId].getWorldMatrix();
 973                                 // combine worldMatrix
 974                                 _WorldMatrix= parentWM * _LocalMatrix;
 975                         }
 976                         // Special SkeletonSpawnScript stick
 977                         else
 978                         {
 979                                 // The parent matrix must be computed from a special matrix given to the skeleton model
 980                                 CMatrix         parentWM;
 981                                 parentWM.setRot(CVector::I, _FatherSkeletonModel->getSSSWODir(), CVector::K);
 982                                 parentWM.normalize(CMatrix::YZX);
 983                                 parentWM.setPos(_FatherSkeletonModel->getSSSWOPos());
 984                                 // combine worldMatrix
 985                                 _WorldMatrix= parentWM * _LocalMatrix;
 986                         }
 987                 }
 988         }
 989 }
 990
 991
 992 // ***************************************************************************
 993 void                    CTransform::traverseAnimDetailWithoutUpdateWorldMatrix()
 994 {
 995         // AnimDetail behavior: animate only if not clipped.
 996         // NB: no need to test because of VisibilityList use.
 997
 998         // test if the refptr is NULL or not (RefPtr).
 999         CChannelMixer   *chanmix= _ChannelMixer;
1000         if(chanmix)
1001         {
1002                 // eval detail!!
1003                 chanmix->eval(true, getOwnerScene()->getAnimDetailTrav().CurrentDate);
1004         }
1005 }
1006
1007 // ***************************************************************************
1008 void                    CTransform::traverseAnimDetail()
1009 {
1010         // First, test if I must update my worldMatrix because of the ancestorSkeleton scheme
1011         updateWorldMatrixFromFather();
1012
1013         // eval channelMixer.
1014         traverseAnimDetailWithoutUpdateWorldMatrix();
1015
1016         // NB: if want to add something, do it in traverseAnimDetailWithoutUpdateWorldMatrix(), because
1017         // CSkeletonModel doesn't call CTransform::traverseAnimDetail()
1018 }
1019
1020
1021 // ***************************************************************************
1022 // ***************************************************************************
1023 // LoadBalancing
1024 // ***************************************************************************
1025 // ***************************************************************************
1026
1027
1028 // ***************************************************************************
1029 void            CTransform::traverseLoadBalancing()
1030 {
1031         // noop
1032 }
1033
1034
1035 // ***************************************************************************
1036 // ***************************************************************************
1037 // Lighting.
1038 // ***************************************************************************
1039 // ***************************************************************************
1040
1041
1042 // ***************************************************************************
1043 void            CTransform::resetLighting()
1044 {
1045         // if the model is already isNeedUpdateLighting, his light setup is reseted.
1046         // so no need to reset again
1047
1048         if(isNeedUpdateLighting())
1049                 return;
1050
1051
1052         // For all light not in FrozenStaticLightSetup, remove me from their list
1053         uint    startLight= 0;
1054         if(_LightContribution.FrozenStaticLightSetup)
1055         {
1056                 startLight= _LightContribution.NumFrozenStaticLight;
1057         }
1058
1059         // for all light in the list, remove me from their list.
1060         for(uint i=startLight; i<NL3D_MAX_LIGHT_CONTRIBUTION; i++)
1061         {
1062                 CPointLight             *pl= _LightContribution.PointLight[i];
1063                 // if end of list, break.
1064                 if(!pl)
1065                         break;
1066                 else
1067                 {
1068                         // remove me from this light.
1069                         pl->removeLightedModel(_LightContribution.TransformIterator[i]);
1070                 }
1071         }
1072         // empty the list.
1073         if(startLight<NL3D_MAX_LIGHT_CONTRIBUTION)
1074                 _LightContribution.PointLight[startLight]= NULL;
1075
1076
1077         // the model needs to update his lighting.
1078         setStateFlag(IsNeedUpdateLighting, true);
1079
1080 }
1081
1082
1083 // ***************************************************************************
1084 void                    CTransform::freezeStaticLightSetup(CPointLight *pointLight[NL3D_MAX_LIGHT_CONTRIBUTION],
1085                 uint numPointLights, uint8 sunContribution, CPointLight *frozenAmbientlight)
1086 {
1087         nlassert(numPointLights <= NL3D_MAX_LIGHT_CONTRIBUTION);
1088
1089         // resetLighting() first.
1090         resetLighting();
1091
1092         // Enable StaticLightSetup.
1093         _LightContribution.FrozenStaticLightSetup= true;
1094         _LightContribution.NumFrozenStaticLight= uint8(numPointLights);
1095         _LightContribution.SunContribution= sunContribution;
1096         // setup the FrozenAmbientLight
1097         _LightContribution.FrozenAmbientLight= frozenAmbientlight;
1098         // Setup other pointLights
1099         uint i;
1100         for(i=0;i<numPointLights;i++)
1101         {
1102                 // set the light
1103                 _LightContribution.PointLight[i]= pointLight[i];
1104                 // Enable at max.
1105                 _LightContribution.Factor[i]= 255;
1106                 // Compute static AttFactor Later because don't have WorlPosition of the model here!!
1107                 setStateFlag(IsNeedUpdateFrozenStaticLightSetup, true);
1108
1109                 // Do NOT set the iterator, because it is a staticLight.
1110         }
1111         // End the list
1112         if(i<NL3D_MAX_LIGHT_CONTRIBUTION)
1113                 _LightContribution.PointLight[i]= NULL;
1114 }
1115
1116 // ***************************************************************************
1117 void                    CTransform::unfreezeStaticLightSetup()
1118 {
1119         // resetLighting() first.
1120         resetLighting();
1121
1122         // Disable StaticLightSetup.
1123         _LightContribution.FrozenStaticLightSetup= false;
1124         _LightContribution.NumFrozenStaticLight= 0;
1125         // End the list
1126         _LightContribution.PointLight[0]= NULL;
1127         // No more FrozenAmbientLight
1128         _LightContribution.FrozenAmbientLight= NULL;
1129
1130         // Don't need to update StaticLightSetup since no more exist.
1131         setStateFlag(IsNeedUpdateFrozenStaticLightSetup, false);
1132 }
1133
1134
1135 // ***************************************************************************
1136 void    CTransform::traverseLight()
1137 {
1138         // if the model do not need to update his lighting, just skip.
1139         if(!isNeedUpdateLighting())
1140                 return;
1141
1142
1143         // If a freezeStaticLightSetup() has been called on this model recently.
1144         if(isNeedUpdateFrozenStaticLightSetup())
1145         {
1146                 // Now, the correct matrix is computed.
1147                 // get the untransformed bbox from the model.
1148                 CAABBox         bbox;
1149                 getAABBox(bbox);
1150                 // get transformed center pos of bbox
1151                 CVector worldModelPos= getWorldMatrix() * bbox.getCenter();
1152
1153                 // So we can compute AttFactor for each static light influencing this static object
1154                 uint    numPointLights= _LightContribution.NumFrozenStaticLight;
1155                 for(uint i=0;i<numPointLights;i++)
1156                 {
1157                         const CPointLight       *pl= _LightContribution.PointLight[i];
1158                         // don't worry about the precision of floor, because of *255.
1159                         float   distToModel= (pl->getPosition() - worldModelPos).norm();
1160                         sint    attFactor= NLMISC::OptFastFloor( 255 * pl->computeLinearAttenuation(worldModelPos, distToModel) );
1161                         _LightContribution.AttFactor[i]= (uint8)attFactor;
1162                 }
1163
1164                 // clean.
1165                 setStateFlag(CTransform::IsNeedUpdateFrozenStaticLightSetup, false);
1166         }
1167
1168
1169         // see CTransform::clip(), here I am Lightable(), and I have no _AncestorSkeletonModel
1170         // So I am sure that I really need to recompute my ModelLightContributions.
1171         CScene  *scene= getOwnerScene();
1172         scene->getLightTrav().LightingManager.computeModelLightContributions(scene->getSunAmbient(), this,
1173                 _LightContribution, _LogicInfo);
1174
1175         // done!
1176         setStateFlag(CTransform::IsNeedUpdateLighting, false);
1177 }
1178
1179
1180 // ***************************************************************************
1181 // ***************************************************************************
1182 // Rendering
1183 // ***************************************************************************
1184 // ***************************************************************************
1185
1186
1187 // ***************************************************************************
1188 void    CTransform::traverseRender()
1189 {
1190         // no-op
1191 }
1192
1193 // ***************************************************************************
1194 void    CTransform::profileRender()
1195 {
1196         // no-op
1197 }
1198
1199
1200 // ***************************************************************************
1201 // ***************************************************************************
1202 // Hrc Linking
1203 // ***************************************************************************
1204 // ***************************************************************************
1205
1206
1207 // ***************************************************************************
1208 void                    CTransform::hrcLinkSon(CTransform *son)
1209 {
1210         if(!son)
1211                 return;
1212
1213         // If not unfrozen, can't link
1214         if (son->_FreezeHRCState != CTransform::FreezeHRCStateDisabled)
1215                 return;
1216
1217         // no-op if already me.
1218         if(son->_HrcParent==this)
1219                 return;
1220
1221         // unlink from anyone
1222         son->hrcUnlink();
1223
1224         // link son to me
1225         _HrcSons.insert(son, &son->_HrcNode);
1226
1227         // link me to son
1228         son->_HrcParent= this;
1229
1230         // Backup parent
1231         son->_HrcParentUnfreeze= this;
1232
1233         // my son should recompute his worldMatrix!
1234         son->_WorldDate= -1;
1235 }
1236
1237 // ***************************************************************************
1238 void                    CTransform::hrcUnlink()
1239 {
1240         // no-op if already NULL
1241         if(_HrcParent==NULL)
1242                 return;
1243
1244         // if ForceClipRoot flag is set, then the fx can't be linked elsewhere in the hierarchy
1245         nlassert(!getStateFlag(ForceClipRoot));
1246
1247         // unlink my parent from me.
1248         _HrcNode.unlink();
1249
1250         // unlink me from parent
1251         _HrcParent= NULL;
1252         _HrcParentUnfreeze= NULL;
1253
1254         // I should recompute my worldMatrix (well not useful since not linked, but still do it...)
1255         _WorldDate= -1;
1256 }
1257
1258 // ***************************************************************************
1259 CTransform              *CTransform::hrcGetChild(uint index) const
1260 {
1261         nlassert(index < _HrcSons.size());
1262         return (const_cast<CTransform*>(this))->_HrcSons.begin()[index];
1263 }
1264
1265
1266 // ***************************************************************************
1267 // ***************************************************************************
1268 // Clip Linking
1269 // ***************************************************************************
1270 // ***************************************************************************
1271
1272
1273 // ***************************************************************************
1274 void                    CTransform::clipAddChild(CTransform *son)
1275 {
1276         if(!son)
1277                 return;
1278
1279         // if already linked, no-op.
1280         if(son->clipHasParent(this))
1281                 return;
1282
1283         // add a new parent entry for our son.
1284         CClipNode       *clipNode= new CClipNode;
1285         son->_ClipParents.push_back(clipNode);
1286
1287         // link the son to us
1288         clipNode->Parent= this;
1289
1290         // link us to the son
1291         _ClipSons.insert(son, &clipNode->ClipNode);
1292 }
1293
1294 // ***************************************************************************
1295 void                    CTransform::clipDelChild(CTransform *son)
1296 {
1297         if(!son)
1298                 return;
1299
1300         // try to remove from me from my parent
1301         son->clipDelFromParent(this);
1302 }
1303
1304 // ***************************************************************************
1305 void                    CTransform::clipUnlinkFromAll()
1306 {
1307         // unlink from all parent clip
1308         while( clipGetNumParents() )
1309         {
1310                 clipDelFromParent( clipGetParent(0) );
1311         }
1312 }
1313
1314 // ***************************************************************************
1315 CTransform              *CTransform::clipGetParent(uint index) const
1316 {
1317         nlassert(index < _ClipParents.size());
1318         return _ClipParents[index]->Parent;
1319 }
1320
1321 // ***************************************************************************
1322 CTransform              *CTransform::clipGetChild(uint index) const
1323 {
1324         nlassert(index < _ClipSons.size());
1325         return (const_cast<CTransform*>(this))->_ClipSons.begin()[index];
1326 }
1327
1328
1329 // ***************************************************************************
1330 bool                    CTransform::clipHasParent(CTransform *parent)
1331 {
1332         // search O(n) for all parents
1333         for(uint i=0;i<_ClipParents.size();i++)
1334         {
1335                 if(_ClipParents[i]->Parent==parent)
1336                         return true;
1337         }
1338
1339         return false;
1340 }
1341
1342 // ***************************************************************************
1343 void                    CTransform::clipDelFromParent(CTransform *parent)
1344 {
1345         // search O(n) for all Parents
1346         uint    numParents= (uint)_ClipParents.size();
1347         for(uint i=0;i<numParents;i++)
1348         {
1349                 if(_ClipParents[i]->Parent==parent)
1350                 {
1351                         // found! remove me from my parent list
1352                         _ClipParents[i]->ClipNode.unlink();
1353
1354                         // remove this parent entry. swap with last
1355                         swap(_ClipParents[i], _ClipParents[numParents-1]);
1356
1357                         // and delete last.
1358                         delete _ClipParents[numParents-1];
1359                         _ClipParents.resize(numParents-1);
1360
1361                         break;
1362                 }
1363         }
1364 }
1365
1366 // ***************************************************************************
1367 void                    CTransform::setUserClipping(bool enable)
1368 {
1369         setStateFlag (UserClipping, enable);
1370 }
1371
1372 // ***************************************************************************
1373 bool                    CTransform::getUserClipping() const
1374 {
1375         return getStateFlag(UserClipping) != 0;
1376 }
1377
1378 // ***************************************************************************
1379 // ***************************************************************************
1380 // ShadowMap
1381 // ***************************************************************************
1382 // ***************************************************************************
1383
1384 // ***************************************************************************
1385 void                    CTransform::getReceiverBBox(CAABBox &bbox)
1386 {
1387         bbox.setCenter(CVector::Null);
1388         bbox.setHalfSize(CVector::Null);
1389 }
1390
1391 // ***************************************************************************
1392 void                    CTransform::enableCastShadowMap(bool state)
1393 {
1394         bool    precState= canCastShadowMap();
1395
1396         if(modelCanCastShadowMap())
1397                 setStateFlag(IsFinalShadowMapCaster, state);
1398         else
1399                 setStateFlag(IsFinalShadowMapCaster, false);
1400
1401         // if just enabled, create the shadowMap
1402         if(canCastShadowMap() && !precState)
1403         {
1404                 createShadowMap();
1405                 // The user must have created it.
1406                 nlassert(getShadowMap());
1407         }
1408         // if just disabled, free ressource
1409         else if(!canCastShadowMap() && precState)
1410         {
1411                 deleteShadowMap();
1412         }
1413 }
1414
1415 // ***************************************************************************
1416 void CTransform::forceCompute()
1417 {
1418         // if father is a skeleton, force to compute the bone we are sticked to
1419         if (_FatherSkeletonModel)
1420         {
1421                 _FatherSkeletonModel->forceComputeBone(_FatherBoneId);
1422         }
1423         else
1424         {
1425                 // force to compute the father
1426                 if (_HrcParent)
1427                 {
1428                         _HrcParent->forceCompute();
1429                 }
1430         }
1431         // compute
1432         update();
1433         updateWorldMatrixFromFather();
1434 }
1435
1436 // ***************************************************************************
1437 void CTransform::setForceClipRoot(bool forceClipRoot)
1438 {
1439         if (forceClipRoot == (getStateFlag(ForceClipRoot) != 0)) return;
1440         if (forceClipRoot)
1441         {
1442                 // unlink from previous father and link to the root
1443                 hrcUnlink();
1444                 if (_OwnerScene)
1445                 {
1446                         _OwnerScene->getRoot()->hrcLinkSon(this);
1447                 }
1448                 setClusterSystem(NULL);
1449         }
1450         setStateFlag(ForceClipRoot, forceClipRoot);
1451 }
1452
1453 // ***************************************************************************
1454 UTransform *CTransform::buildMatchingUserInterfaceObject()
1455 {
1456         return new UTransform(this);
1457 }
1458
1459 // ***************************************************************************
1460 void CTransform::setShadowMapDirectionZThreshold(float zthre)
1461 {
1462         clamp(zthre, -1.f, 1.f);
1463         _ShadowMapDirectionZThreshold= zthre;
1464 }
1465
1466 // ***************************************************************************
1467 void CTransform::setShadowMapMaxDepth(float depth)
1468 {
1469         depth= max(0.f, depth);
1470         _ShadowMapMaxDepth= depth;
1471 }
1472
1473
1474 }