aleajactaest/khanat-opennel-code
1
0
Fork 0
mirror of https://port.numenaute.org/aleajactaest/khanat-opennel-code.git synced 2024-11-15 20:23:47 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions
khanat-opennel-code/code/nel/src/3d/transform.cpp

1471 lines
44 KiB
C++
Raw Normal View History

initial version
2010-05-06 00:08:41 +00:00
// NeL - MMORPG Framework <http://dev.ryzom.com/projects/nel/>
// Copyright (C) 2010 Winch Gate Property Limited
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU Affero General Public License as
// published by the Free Software Foundation, either version 3 of the
// License, or (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU Affero General Public License for more details.
//
// You should have received a copy of the GNU Affero General Public License
// along with this program. If not, see <http://www.gnu.org/licenses/>.
#include "std3d.h"
#include "nel/3d/transform.h"
#include "nel/3d/skeleton_model.h"
#include "nel/3d/scene.h"
#include "nel/3d/scene_group.h"
#include "nel/3d/root_model.h"
#include "nel/3d/u_transform.h"
#include "nel/misc/fast_floor.h"
#include "nel/misc/hierarchical_timer.h"
using namespace NLMISC;
using namespace std;
namespace NL3D
{
// ***************************************************************************
#define NL3D_TRANSFORM_DEFAULT_SHADOW_MAP_DEPTH 8.f
// ***************************************************************************
void CTransform::registerBasic()
{
CScene::registerModel( TransformId, 0, CTransform::creator);
}
// ***************************************************************************
CTransform::CTransform()
{
// important to reset for destructor to know if linked or not (CCluster !!)
_OwnerScene= NULL;
// Hrc/Graph hierarchy
_HrcParent= NULL;
_HrcParentUnfreeze= NULL;
_PrecModelToUpdate= NULL;
_NextModelToUpdate= NULL;
_TransformDirty= true;
Visibility= CHrcTrav::Herit;
_LastTransformableMatrixDate= 0;
_FatherSkeletonModel= NULL;
_ClusterSystem = NULL;
_FreezeHRCState= FreezeHRCStateDisabled;
_OrderingLayer = 2;
_TransparencyPriority = 0;
// No logicInfo by default
_LogicInfo= NULL;
_ForceCLodSticked= false;
// default MeanColor value
_MeanColor.set(255,255,255,255);
// Default ShadowMap direction
_ShadowMapDirectionZThreshold= -0.5f;
_ShadowMapMaxDepth= NL3D_TRANSFORM_DEFAULT_SHADOW_MAP_DEPTH;
// Setup some state.
/*
Default are:
IsAnimDetailable= 0
IsLoadBalancable= 0
IsLightable= 0
IsRenderable= 0
IsTransparent= 0
IsOpaque= 1
QuadGridClipEnabled= 0.
IsUserLightable= 1 // default, the model may be lighted.
IsFinalLightable= 0
IsNeedUpdateLighting= 0
ISNeedUpdateFrozenStaticLightSetup= 0
IsSkeleton= 0
IsTransformShape=0
IsCluster= 0
IsMeshBaseInstance= 0
IsDeleteChannelMixer = 0;
*/
_StateFlags= IsOpaque | IsUserLightable;
// By default, always allow rendering of Transform Models.
_RenderFilterType= ~0;
// By default, don't suport fast intersection detection
_SupportFastIntersect= false;
// **** HRC Init Traversal Computed Data.
_LocalVis= CHrcTrav::Herit; _LocalMatrix.identity(); _LocalDate=0;
_WorldVis= true; _WorldMatrix.identity();
// Init the _WorldDate to -1 so at first pass, _LocalDate>_WorldDate, and so
// the model will be processed and so it'll may be inserted in LightingManager (for example)
_WorldDate=-1;
_Frozen = false;
_DontUnfreezeChildren = false;
_AncestorSkeletonModel= NULL;
_ClipLinkedInSonsOfAncestorSkeletonModelGroup= false;
// **** Clip Init Traversal Computed Data.
_ClipDate= 0;
_Visible=false;
_IndexInVisibleList= -1;
// **** AnimDetail Init Traversal Computed Data.
// none
// **** LoadBalancing Init Traversal Computed Data.
_LoadBalancingGroup= NULL;
}
// ***************************************************************************
CTransform::~CTransform()
{
// If still binded to a father skeleton
if( _FatherSkeletonModel )
{
/* If skinned, cannot detach me from skeleton here because detachSkeletonSon()
use some virtual calls of transform: setApplySkin().
Hence, It is the deriver job to detach himself from the skeleton.
NB: test isSkinned(), not isSkinnable(), since isSkinned() is not virtual ....
This means that if a Mesh isSkinnable(), but never skinned, it is not asserted here.
*/
if( isSkinned() )
{
nlstop;
}
else
// Can detach Me. Important for UTransform sticked
_FatherSkeletonModel->detachSkeletonSon(this);
}
// resetLighting, removing me from PointLight Transform list.
// NB: not done for FrozenStaticLightSetup, because those lights don't owns me.
resetLighting();
// Must also remove me from the lightingManager.
// must test getOwnerScene() because of CCluster usage out of CScene (thanks to mat!! :) )
if(getOwnerScene())
{
CLightTrav &lightTrav= getOwnerScene()->getLightTrav();
_LightedModelIt= lightTrav.LightingManager.eraseStaticLightedModel(_LightedModelIt);
}
if (getChannelMixerOwnerShip()) delete (CChannelMixer *) _ChannelMixer;
// ensure the model is no more linked to the UpdateList.
unlinkFromUpdateList();
// I must remove me from _VisibleList.
if(_IndexInVisibleList>=0)
{
CClipTrav &clipTrav= getOwnerScene()->getClipTrav();
nlassert(_IndexInVisibleList < (sint)clipTrav._CurrentNumVisibleModels );
// Mark NULL. NB: faster than a CRefPtr.
clipTrav._VisibleList[_IndexInVisibleList]= NULL;
_IndexInVisibleList= -1;
}
// remove me from parents in Hrc and Clip
setStateFlag(ForceClipRoot, false); // ensure that not 'glued' to the root so that the following call will succeed
hrcUnlink();
clipUnlinkFromAll();
// remove mys sons.
while(hrcGetNumChildren())
{
hrcGetChild(0)->hrcUnlink();
}
while(clipGetNumChildren())
{
clipDelChild(clipGetChild(0));
}
nlassert(_HrcSons.empty());
nlassert(_HrcParent==NULL);
nlassert(_ClipSons.empty());
nlassert(_ClipParents.empty());
}
// ***************************************************************************
void CTransform::initModel()
{
// assign me to the default group
_LoadBalancingGroup= getOwnerScene()->getLoadBalancingTrav().getDefaultGroup();
}
// ***************************************************************************
void CTransform::hide()
{
// Optim: do nothing if already set
if(Visibility!= CHrcTrav::Hide)
{
_TransformDirty= true;
Visibility= CHrcTrav::Hide;
// If skinned, then must inform skeleton parent that it must recompute skin render/animDetail lists
if(isSkinned())
{
nlassert(_FatherSkeletonModel);
_FatherSkeletonModel->dirtSkinRenderLists();
}
}
}
// ***************************************************************************
void CTransform::setTransparency(bool v)
{
bool bTmp = getStateFlag(IsTransparent) == 0 ? false : true;
if (bTmp != v)
{
setStateFlag(IsTransparent, v);
if(isSkinned())
{
nlassert(_FatherSkeletonModel);
_FatherSkeletonModel->dirtSkinRenderLists();
}
}
}
// ***************************************************************************
void CTransform::setBypassLODOpacityFlag(bool bypass)
{
setStateFlag(BypassLODOpacity, bypass);
}
// ***************************************************************************
void CTransform::setOpacity(bool v)
{
bool bTmp = getStateFlag(IsOpaque) == 0 ? false : true;
if (bTmp != v)
{
setStateFlag(IsOpaque, v);
if(isSkinned())
{
nlassert(_FatherSkeletonModel);
_FatherSkeletonModel->dirtSkinRenderLists();
}
}
}
// ***************************************************************************
void CTransform::show()
{
// Optim: do nothing if already set
if(Visibility!= CHrcTrav::Show)
{
_TransformDirty= true;
Visibility= CHrcTrav::Show;
// If skinned, then must inform skeleton parent that it must recompute skin render/animDetail lists
if(isSkinned())
{
nlassert(_FatherSkeletonModel);
_FatherSkeletonModel->dirtSkinRenderLists();
}
}
}
// ***************************************************************************
void CTransform::heritVisibility()
{
// Optim: do nothing if already set
if(Visibility!= CHrcTrav::Herit)
{
_TransformDirty= true;
Visibility= CHrcTrav::Herit;
// If skinned, then must inform skeleton parent that it must recompute skin render/animDetail lists
if(isSkinned())
{
nlassert(_FatherSkeletonModel);
_FatherSkeletonModel->dirtSkinRenderLists();
}
}
}
// ***************************************************************************
CTrackDefaultVector CTransform::DefaultPos( CVector::Null );
CTrackDefaultVector CTransform::DefaultRotEuler( CVector::Null );
CTrackDefaultQuat CTransform::DefaultRotQuat( NLMISC::CQuat::Identity );
CTrackDefaultVector CTransform::DefaultScale( CVector(1,1,1) );
CTrackDefaultVector CTransform::DefaultPivot( CVector::Null );
ITrack* CTransform::getDefaultTrack (uint valueId)
{
// Cyril: prefer do it here in CTransform, because of CCamera, CLight etc... (which may not need a default value too!!)
// what value ?
switch (valueId)
{
case PosValue: return &DefaultPos;
case RotEulerValue: return &DefaultRotEuler;
case RotQuatValue: return &DefaultRotQuat;
case ScaleValue: return &DefaultScale;
case PivotValue: return &DefaultPivot;
}
// No, only ITrnasformable values!
nlstop;
// Deriver note: else call BaseClass::getDefaultTrack(valueId);
return NULL;
}
// ***************************************************************************
void CTransform::registerToChannelMixer(CChannelMixer *chanMixer, const std::string &prefix)
{
if (getChannelMixerOwnerShip() && chanMixer != _ChannelMixer)
{
delete _ChannelMixer;
setChannelMixerOwnerShip(false);
}
// Hey!! we are animated!!
_ChannelMixer= chanMixer;
// Update flag, if we must be inserted in AnimDetail
setStateFlag(IsAnimDetailable, _ChannelMixer || getStateFlag(IsForceAnimDetail) );
// If skinned, then must inform skeleton parent that it must recompute skin render/animDetail lists
if(isSkinned())
{
nlassert(_FatherSkeletonModel);
_FatherSkeletonModel->dirtSkinRenderLists();
}
// For CTransfom, channels are not detailled.
addValue(chanMixer, PosValue, OwnerBit, prefix, false);
addValue(chanMixer, RotEulerValue, OwnerBit, prefix, false);
addValue(chanMixer, RotQuatValue, OwnerBit, prefix, false);
addValue(chanMixer, ScaleValue, OwnerBit, prefix, false);
addValue(chanMixer, PivotValue, OwnerBit, prefix, false);
// Deriver note: if necessary, call BaseClass::registerToChannelMixer(chanMixer, prefix);
}
// ***************************************************************************
void CTransform::freeze()
{
// First, update the model
// _Frozen state is disabled here (in CTransform::update()).
update();
// Then flag the frozen state.
_Frozen= true;
}
// ***************************************************************************
void CTransform::setDontUnfreezeChildren(bool val)
{
_DontUnfreezeChildren = val;
}
// ***************************************************************************
void CTransform::freezeHRC()
{
// if disabled, say we are ready to validate our worldMatrix for long.
if(_FreezeHRCState==FreezeHRCStateDisabled)
{
_FreezeHRCState= FreezeHRCStateRequest;
setStateFlag(QuadGridClipEnabled, true);
/* If the transform is not frozen (ie staticaly inserted in a cluster),
We must be sure it will be tested against QuadGridClipManager at next ClipTrav pass.
=> must make this object a "moving object" at next render=> dirt _LocalMatrixDate.
*/
if(!_Frozen)
{
_TransformDirty= true;
}
}
}
// ***************************************************************************
void CTransform::unfreezeHRC()
{
// if this model is no HRC frozen disabled
if(_FreezeHRCState!=FreezeHRCStateDisabled)
{
// if model correctly frozen.
if(_FreezeHRCState == CTransform::FreezeHRCStateEnabled )
{
// Should not be linked : can't link after a freezeHRC
nlassert (_HrcParent == NULL);
// Set as unfreeze else, hrcLinkSon doesn't work
_FreezeHRCState= FreezeHRCStateDisabled;
// Link this model to the previous HRC parent.
if (_HrcParentUnfreeze)
_HrcParentUnfreeze->hrcLinkSon( this );
else
getOwnerScene()->getRoot()->hrcLinkSon( this );
// Link this object to the validateList.
linkToUpdateList();
// if lightable()
if( isLightable() )
{
CLightTrav &lightTrav= getOwnerScene()->getLightTrav();
// Lighting: must remove the object from the quadGrid.
// NB: works if _LightedModelIt==NULL. result is that _LightedModelIt= NULL.
_LightedModelIt= lightTrav.LightingManager.eraseStaticLightedModel(_LightedModelIt);
}
}
else
_FreezeHRCState= FreezeHRCStateDisabled;
// unlink me from any QuadCluster, and disable QuadCluster
unlinkFromQuadCluster();
setStateFlag(QuadGridClipEnabled, false);
}
}
// ***************************************************************************
void CTransform::update()
{
// test if the matrix has been changed in ITransformable.
if(ITransformable::compareMatrixDate(_LastTransformableMatrixDate))
{
_LastTransformableMatrixDate= ITransformable::getMatrixDate();
_TransformDirty= true;
}
// update the freezeHRC state.
if(_FreezeHRCState != CTransform::FreezeHRCStateDisabled)
{
// if the model request to be frozen in HRC
if(_FreezeHRCState == CTransform::FreezeHRCStateRequest )
{
// Wait for next Hrc traversal to compute good _WorldMatrix for this model and his sons.
// Also, next Hrc traversal will insert the model in the LightingManager quadGrid (if lightable)
_FreezeHRCState = CTransform::FreezeHRCStateReady;
}
// if the model is ready to be frozen in HRC, then do it!!
else if( _FreezeHRCState == CTransform::FreezeHRCStateReady )
{
// Unlink this model.
hrcUnlink();
// unLink this object from the validateList. NB: the list will still be correclty parsed.
unlinkFromUpdateList();
// if lightable, the model is inserted in a quadgrid to update his lighting only when
// dynamicLights touch him (since himself is static).
if( isLightable() )
{
CLightTrav &lightTrav= getOwnerScene()->getLightTrav();
// Lighting: must reinsert the object from the quadGrid.
// NB: works if _LightedModelIt==NULL. result is that _LightedModelIt= NULL.
_LightedModelIt= lightTrav.LightingManager.eraseStaticLightedModel(_LightedModelIt);
// insert in the quadgrid.
_LightedModelIt= lightTrav.LightingManager.insertStaticLightedModel(this);
}
// Now this model won't be tested for validation nor for worldMatrix update. End!!
_FreezeHRCState = CTransform::FreezeHRCStateEnabled;
}
}
// update _LocalMatrix
if(_TransformDirty)
{
// update the local matrix.
_LocalMatrix= getMatrix();
_LocalVis= Visibility;
// update the date of the local matrix.
_LocalDate= getOwnerScene()->getHrcTrav().CurrentDate;
// The transform has been modified. Hence, it is no more frozen.
_Frozen= false;
// ok!
_TransformDirty= false;
}
}
// ***************************************************************************
void CTransform::getAABBox(NLMISC::CAABBox &bbox) const
{
bbox.setCenter(CVector::Null);
bbox.setHalfSize(CVector::Null);
}
// ***************************************************************************
void CTransform::setLoadBalancingGroup(const std::string &group)
{
// Get the traversal.
CLoadBalancingTrav &trav= getOwnerScene()->getLoadBalancingTrav();
// get the group from trav (create if needed), and set it.
_LoadBalancingGroup= trav.getOrCreateGroup(group);
}
// ***************************************************************************
const std::string &CTransform::getLoadBalancingGroup() const
{
// get the group name
return _LoadBalancingGroup->Name;
}
// ***************************************************************************
void CTransform::setMeanColor(CRGBA color)
{
// if the color is different from prec
if(color!=_MeanColor)
{
// change it.
_MeanColor= color;
}
}
// ***************************************************************************
void CTransform::setIsLightable(bool val)
{
setStateFlag(IsLightable, val);
// update IsFinalLightable
setStateFlag(IsFinalLightable, (getStateFlag(IsLightable) && getStateFlag(IsUserLightable)) );
}
// ***************************************************************************
void CTransform::setUserLightable(bool enable)
{
setStateFlag(IsUserLightable, enable);
// update IsFinalLightable
setStateFlag(IsFinalLightable, (getStateFlag(IsLightable) && getStateFlag(IsUserLightable)) );
}
// ***************************************************************************
void CTransform::setIsRenderable(bool val)
{
setStateFlag(IsRenderable, val);
}
// ***************************************************************************
void CTransform::setIsBigLightable(bool val)
{
setStateFlag(IsBigLightable, val);
}
// ***************************************************************************
void CTransform::setIsSkeleton(bool val)
{
setStateFlag(IsSkeleton, val);
}
// ***************************************************************************
void CTransform::setApplySkin(bool state)
{
setStateFlag(IsSkinned, state);
}
// ***************************************************************************
void CTransform::setIsForceAnimDetail(bool val)
{
setStateFlag(IsForceAnimDetail, val );
// Update flag, if we must be inserted in AnimDetail
setStateFlag(IsAnimDetailable, _ChannelMixer || getStateFlag(IsForceAnimDetail) );
// If skinned, then must inform skeleton parent that it must recompute skin render/animDetail lists
if(isSkinned())
{
nlassert(_FatherSkeletonModel);
_FatherSkeletonModel->dirtSkinRenderLists();
}
}
// ***************************************************************************
void CTransform::setIsLoadbalancable(bool val)
{
setStateFlag(IsLoadBalancable, val );
}
// ***************************************************************************
void CTransform::linkToUpdateList()
{
if(!_OwnerScene)
return;
// If the model is not already inserted.
if( ! (_PrecModelToUpdate!=NULL || _OwnerScene->_UpdateModelList==this) )
{
// insert it.
_NextModelToUpdate= _OwnerScene->_UpdateModelList;
_PrecModelToUpdate= NULL;
if(_NextModelToUpdate)
_NextModelToUpdate->_PrecModelToUpdate= this;
_OwnerScene->_UpdateModelList= this;
}
}
// ***************************************************************************
void CTransform::unlinkFromUpdateList()
{
if(!_OwnerScene)
return;
// If the model is inserted.
if( _PrecModelToUpdate!=NULL || _OwnerScene->_UpdateModelList==this )
{
// update prec.
if(_PrecModelToUpdate)
_PrecModelToUpdate->_NextModelToUpdate= _NextModelToUpdate;
else
_OwnerScene->_UpdateModelList= _NextModelToUpdate;
// update next.
if(_NextModelToUpdate)
_NextModelToUpdate->_PrecModelToUpdate= _PrecModelToUpdate;
// End.
_PrecModelToUpdate= NULL;
_NextModelToUpdate= NULL;
}
}
// ***************************************************************************
// ***************************************************************************
// Hrc Trav
// ***************************************************************************
// ***************************************************************************
// ***************************************************************************
void CTransform::updateWorld()
{
const CMatrix *pFatherWM;
bool visFather;
// If not root case, link to Fahter.
if(_HrcParent)
{
pFatherWM= &(_HrcParent->_WorldMatrix);
visFather= _HrcParent->_WorldVis;
// if _HrcParent is not frozen (for any reason), disable us!
if (!_HrcParent->_Frozen && !_HrcParent->_DontUnfreezeChildren)
_Frozen= false;
// herit _AncestorSkeletonModel
if (_HrcParent->_AncestorSkeletonModel)
// If my father has an _AncestorSkeletonModel, get it.
_AncestorSkeletonModel= _HrcParent->_AncestorSkeletonModel;
else
// else I have an ancestor skel model if I am sticked/binded directly to a skeleton model.
_AncestorSkeletonModel= _FatherSkeletonModel;
}
// else, default!!
else
{
pFatherWM= &(CMatrix::Identity);
visFather= true;
// at the root of the hierarchy, we have no parent, hence no FatherSkeletonModel nor _AncestorSkeletonModel.
_AncestorSkeletonModel= NULL;
// NB: Root is Frozen by essence :), so don't modify the frozen state here.
}
// Combine matrix
if(_LocalDate>_WorldDate || (_HrcParent && _HrcParent->_WorldDate>_WorldDate) )
{
// Must recompute the world matrix. ONLY IF I AM NOT SKINNED/STICKED TO A SKELETON in the hierarchy!
if( _AncestorSkeletonModel==NULL )
{
_WorldMatrix= *pFatherWM * _LocalMatrix;
_WorldDate= getOwnerScene()->getHrcTrav().CurrentDate;
// Add the model to the moving object list, only if I am a transform shape
if (!_Frozen && isTransformShape() && !getStateFlag(ForceClipRoot))
getOwnerScene()->getHrcTrav()._MovingObjects.push_back (static_cast<CTransformShape*>(this));
}
}
// Update dynamic lighting.
/*
If the model is not frozen in StaticLight, then must update lighting each frame.
Even if the object doesn't move, a new dynamic light may enter in its aera. Hence we must test
it in the light quadrid. StaticLight-ed Objects don't need it because they are inserted in a special quadgrid,
where dynamics lights touch all StaticLight-ed object to force their computing
NB: not done if _AncestorSkeletonModel!=NULL. no need because in this case,
result is driven by the _LightContribution of the _AncestorSkeletonModel.
*/
if( !_LightContribution.FrozenStaticLightSetup && _AncestorSkeletonModel==NULL )
{
// if the model is lightable reset lighting
if( isLightable() )
resetLighting();
}
// Combine visibility.
switch(_LocalVis)
{
case CHrcTrav::Herit: _WorldVis= visFather; break;
case CHrcTrav::Hide: _WorldVis= false; break;
case CHrcTrav::Show: _WorldVis= true; break;
default: break;
}
// If I have an ancestor Skeleton Model, I must be binded in ClipTrav to the SonsOfAncestorSkeletonModelGroup
updateClipTravForAncestorSkeleton();
}
// ***************************************************************************
void CTransform::updateClipTravForAncestorSkeleton()
{
// If I have an ancestor Skeleton Model, I must be binded in ClipTrav to the SonsOfAncestorSkeletonModelGroup
if(_AncestorSkeletonModel && !_ClipLinkedInSonsOfAncestorSkeletonModelGroup)
{
// must unlink from ALL olds models.
clipUnlinkFromAll();
// And link to SonsOfAncestorSkeletonModelGroup.
getOwnerScene()->SonsOfAncestorSkeletonModelGroup->clipAddChild(this);
// update the flag.
_ClipLinkedInSonsOfAncestorSkeletonModelGroup= true;
}
// else I must be binded to the standard Root.
if(!_AncestorSkeletonModel && _ClipLinkedInSonsOfAncestorSkeletonModelGroup)
{
// verify first I am really still linked to the SonsOfAncestorSkeletonModelGroup.
// This test is important, because link may have changed for any reason (portals, clipManager....).
if( clipGetNumParents() == 1 && clipGetParent(0)==getOwnerScene()->SonsOfAncestorSkeletonModelGroup )
{
// must unlink from ALL olds models.
clipUnlinkFromAll();
// and now, link to std root.
getOwnerScene()->getRoot()->clipAddChild(this);
}
// update the flag
_ClipLinkedInSonsOfAncestorSkeletonModelGroup= false;
}
}
// ***************************************************************************
void CTransform::traverseHrc()
{
// Recompute the matrix, according to _HrcParent matrix mode, and local matrix.
updateWorld();
// Traverse the Hrc sons.
uint num= hrcGetNumChildren();
for(uint i=0;i<num;i++)
hrcGetChild(i)->traverseHrc();
}
// ***************************************************************************
// ***************************************************************************
// Clip Trav
// ***************************************************************************
// ***************************************************************************
// ***************************************************************************
void CTransform::setClusterSystem(CInstanceGroup *pCS)
{
if (pCS != NULL)
{
nlassert(!getStateFlag(ForceClipRoot)); // the transform must be linked to the root, and have not cluster system when this flag is set
}
// Special case for the "AutoClusterSystem" when pCS==-1
if(pCS==(CInstanceGroup*)-1)
{
_ClusterSystem = NULL;
setStateFlag(ClusterSystemAuto, true);
}
else
{
_ClusterSystem = pCS;
setStateFlag(ClusterSystemAuto, false);
}
}
// ***************************************************************************
CInstanceGroup* CTransform::getClusterSystem ()
{
if(getStateFlag(ClusterSystemAuto))
return (CInstanceGroup*)-1;
else
return _ClusterSystem;
}
// ***************************************************************************
void CTransform::traverseClip()
{
// disable H_AUTO, because slowdown when lot of models (eg 1000-2000 tested in forest)
//H_AUTO( NL3D_TransformClip );
CScene *scene= getOwnerScene();
CClipTrav &clipTrav= scene->getClipTrav();
if ((_ClipDate == clipTrav.CurrentDate) && _Visible)
return;
_ClipDate = clipTrav.CurrentDate;
// clip: update Visible flag.
_Visible= false;
// if at least visible.
if(_WorldVis)
{
// If linked to a SkeletonModel anywhere in the hierarchy, don't clip, and use skeleton model clip result.
// This works because we are sons of a special node which is not in the clip traversal, and
// which is traversed at end of the traversal.
if( _AncestorSkeletonModel!=NULL )
{
_Visible= _AncestorSkeletonModel->isClipVisible();
// Special test: if we are sticked to a skeletonModel, and if we are still visible, maybe we don't have to
if(_Visible && _FatherSkeletonModel)
{
// if our skeletonModel father is displayed with a Lod, maybe we are not to be displayed
if(_FatherSkeletonModel->isDisplayedAsLodCharacter())
{
// We are visible only if we where sticked to the skeleton with forceCLod==true.
// This is also true if we are actually a skeletonModel
if(!_ForceCLodSticked)
// otherWise we are not visible. eg: this is the case of skins and some sticked object
_Visible= false;
}
}
}
// else, clip.
else
{
// If the instance is not filtered
if(scene->getFilterRenderFlags() & _RenderFilterType)
{
// User cliping enabled ?
if (_StateFlags & UserClipping)
_Visible= true;
else
_Visible= clip();
}
}
}
// if visible, add to list.
if(_Visible)
{
// add this model to the visibility list.
clipTrav.addVisibleModel(this);
// Has not an ancestor skeleton model?
if( _AncestorSkeletonModel==NULL )
{
// If needed, insert the model in the lighted list.
// don't insert if has an ancestorSkeletonModel, because in this case, result is driven by
// the _LightContribution of the _AncestorSkeletonModel.
if( isLightable() )
scene->getLightTrav().addLightedModel(this);
// If needed, insert the model in the animDetail list.
// don't insert if has an ancestoreSkeletonModel, because in this case, this ancestore will
// animDetail through the hierarchy...
if( isAnimDetailable() )
scene->getAnimDetailTrav().addVisibleModel(this);
}
// If needed, Add it to the loadBalancing trav
if( isLoadBalancable() )
scene->getLoadBalancingTrav().addVisibleModel(this);
// If needed, insert the model in the render list.
if( isRenderable() )
scene->getRenderTrav().addRenderModel(this);
}
// Traverse the Clip sons.
uint num= clipGetNumChildren();
for(uint i=0;i<num;i++)
clipGetChild(i)->traverseClip();
}
// ***************************************************************************
// ***************************************************************************
// AnimDetail Trav
// ***************************************************************************
// ***************************************************************************
// ***************************************************************************
void CTransform::updateWorldMatrixFromFather()
{
// If I am not skinned, and If I have a skeleton ancestor
if(!isSkinned() && _AncestorSkeletonModel )
{
// Compute the HRC _WorldMatrix.
// if I am not sticked.
if(!_FatherSkeletonModel)
{
// get the normal father worldMatrix in Hrc.
CTransform *fatherTransform= hrcGetParent();
// if exist
if(fatherTransform)
{
const CMatrix &parentWM= fatherTransform->_WorldMatrix;
// combine worldMatrix
_WorldMatrix= parentWM * _LocalMatrix;
}
else
_WorldMatrix= _LocalMatrix;
}
else
{
// get the worldMatrix of the bone if I am sticked (standard stick)
if(!getStateFlag(SSSWO))
{
const CMatrix &parentWM= _FatherSkeletonModel->Bones[_FatherBoneId].getWorldMatrix();
// combine worldMatrix
_WorldMatrix= parentWM * _LocalMatrix;
}
// Special SkeletonSpawnScript stick
else
{
// The parent matrix must be computed from a special matrix given to the skeleton model
CMatrix parentWM;
parentWM.setRot(CVector::I, _FatherSkeletonModel->getSSSWODir(), CVector::K);
parentWM.normalize(CMatrix::YZX);
parentWM.setPos(_FatherSkeletonModel->getSSSWOPos());
// combine worldMatrix
_WorldMatrix= parentWM * _LocalMatrix;
}
}
}
}
// ***************************************************************************
void CTransform::traverseAnimDetailWithoutUpdateWorldMatrix()
{
// AnimDetail behavior: animate only if not clipped.
// NB: no need to test because of VisibilityList use.
// test if the refptr is NULL or not (RefPtr).
CChannelMixer *chanmix= _ChannelMixer;
if(chanmix)
{
// eval detail!!
chanmix->eval(true, getOwnerScene()->getAnimDetailTrav().CurrentDate);
}
}
// ***************************************************************************
void CTransform::traverseAnimDetail()
{
// First, test if I must update my worldMatrix because of the ancestorSkeleton scheme
updateWorldMatrixFromFather();
// eval channelMixer.
traverseAnimDetailWithoutUpdateWorldMatrix();
// NB: if want to add something, do it in traverseAnimDetailWithoutUpdateWorldMatrix(), because
// CSkeletonModel doesn't call CTransform::traverseAnimDetail()
}
// ***************************************************************************
// ***************************************************************************
// LoadBalancing
// ***************************************************************************
// ***************************************************************************
// ***************************************************************************
void CTransform::traverseLoadBalancing()
{
// noop
}
// ***************************************************************************
// ***************************************************************************
// Lighting.
// ***************************************************************************
// ***************************************************************************
// ***************************************************************************
void CTransform::resetLighting()
{
// if the model is already isNeedUpdateLighting, his light setup is reseted.
// so no need to reset again
if(isNeedUpdateLighting())
return;
// For all light not in FrozenStaticLightSetup, remove me from their list
uint startLight= 0;
if(_LightContribution.FrozenStaticLightSetup)
{
startLight= _LightContribution.NumFrozenStaticLight;
}
// for all light in the list, remove me from their list.
for(uint i=startLight; i<NL3D_MAX_LIGHT_CONTRIBUTION; i++)
{
CPointLight *pl= _LightContribution.PointLight[i];
// if end of list, break.
if(!pl)
break;
else
{
// remove me from this light.
pl->removeLightedModel(_LightContribution.TransformIterator[i]);
}
}
// empty the list.
if(startLight<NL3D_MAX_LIGHT_CONTRIBUTION)
_LightContribution.PointLight[startLight]= NULL;
// the model needs to update his lighting.
setStateFlag(IsNeedUpdateLighting, true);
}
// ***************************************************************************
void CTransform::freezeStaticLightSetup(CPointLight *pointLight[NL3D_MAX_LIGHT_CONTRIBUTION],
uint numPointLights, uint8 sunContribution, CPointLight *frozenAmbientlight)
{
nlassert(numPointLights <= NL3D_MAX_LIGHT_CONTRIBUTION);
// resetLighting() first.
resetLighting();
// Enable StaticLightSetup.
_LightContribution.FrozenStaticLightSetup= true;
_LightContribution.NumFrozenStaticLight= uint8(numPointLights);
_LightContribution.SunContribution= sunContribution;
// setup the FrozenAmbientLight
_LightContribution.FrozenAmbientLight= frozenAmbientlight;
// Setup other pointLights
uint i;
for(i=0;i<numPointLights;i++)
{
// set the light
_LightContribution.PointLight[i]= pointLight[i];
// Enable at max.
_LightContribution.Factor[i]= 255;
// Compute static AttFactor Later because don't have WorlPosition of the model here!!
setStateFlag(IsNeedUpdateFrozenStaticLightSetup, true);
// Do NOT set the iterator, because it is a staticLight.
}
// End the list
if(i<NL3D_MAX_LIGHT_CONTRIBUTION)
_LightContribution.PointLight[i]= NULL;
}
// ***************************************************************************
void CTransform::unfreezeStaticLightSetup()
{
// resetLighting() first.
resetLighting();
// Disable StaticLightSetup.
_LightContribution.FrozenStaticLightSetup= false;
_LightContribution.NumFrozenStaticLight= 0;
// End the list
_LightContribution.PointLight[0]= NULL;
// No more FrozenAmbientLight
_LightContribution.FrozenAmbientLight= NULL;
// Don't need to update StaticLightSetup since no more exist.
setStateFlag(IsNeedUpdateFrozenStaticLightSetup, false);
}
// ***************************************************************************
void CTransform::traverseLight()
{
// if the model do not need to update his lighting, just skip.
if(!isNeedUpdateLighting())
return;
// If a freezeStaticLightSetup() has been called on this model recently.
if(isNeedUpdateFrozenStaticLightSetup())
{
// Now, the correct matrix is computed.
// get the untransformed bbox from the model.
CAABBox bbox;
getAABBox(bbox);
// get transformed center pos of bbox
CVector worldModelPos= getWorldMatrix() * bbox.getCenter();
// So we can compute AttFactor for each static light influencing this static object
uint numPointLights= _LightContribution.NumFrozenStaticLight;
for(uint i=0;i<numPointLights;i++)
{
const CPointLight *pl= _LightContribution.PointLight[i];
// don't worry about the precision of floor, because of *255.
float distToModel= (pl->getPosition() - worldModelPos).norm();
sint attFactor= NLMISC::OptFastFloor( 255 * pl->computeLinearAttenuation(worldModelPos, distToModel) );
_LightContribution.AttFactor[i]= (uint8)attFactor;
}
// clean.
setStateFlag(CTransform::IsNeedUpdateFrozenStaticLightSetup, false);
}
// see CTransform::clip(), here I am Lightable(), and I have no _AncestorSkeletonModel
// So I am sure that I really need to recompute my ModelLightContributions.
CScene *scene= getOwnerScene();
scene->getLightTrav().LightingManager.computeModelLightContributions(scene->getSunAmbient(), this,
_LightContribution, _LogicInfo);
// done!
setStateFlag(CTransform::IsNeedUpdateLighting, false);
}
// ***************************************************************************
// ***************************************************************************
// Rendering
// ***************************************************************************
// ***************************************************************************
// ***************************************************************************
void CTransform::traverseRender()
{
// no-op
}
// ***************************************************************************
void CTransform::profileRender()
{
// no-op
}
// ***************************************************************************
// ***************************************************************************
// Hrc Linking
// ***************************************************************************
// ***************************************************************************
// ***************************************************************************
void CTransform::hrcLinkSon(CTransform *son)
{
if(!son)
return;
// If not unfrozen, can't link
if (son->_FreezeHRCState != CTransform::FreezeHRCStateDisabled)
return;
// no-op if already me.
if(son->_HrcParent==this)
return;
// unlink from anyone
son->hrcUnlink();
// link son to me
_HrcSons.insert(son, &son->_HrcNode);
// link me to son
son->_HrcParent= this;
// Backup parent
son->_HrcParentUnfreeze= this;
// my son should recompute his worldMatrix!
son->_WorldDate= -1;
}
// ***************************************************************************
void CTransform::hrcUnlink()
{
// no-op if already NULL
if(_HrcParent==NULL)
return;
// if ForceClipRoot flag is set, then the fx can't be linked elsewhere in the hierarchy
nlassert(!getStateFlag(ForceClipRoot));
// unlink my parent from me.
_HrcNode.unlink();
// unlink me from parent
_HrcParent= NULL;
_HrcParentUnfreeze= NULL;
// I should recompute my worldMatrix (well not useful since not linked, but still do it...)
_WorldDate= -1;
}
// ***************************************************************************
CTransform *CTransform::hrcGetChild(uint index) const
{
nlassert(index < _HrcSons.size());
return (const_cast<CTransform*>(this))->_HrcSons.begin()[index];
}
// ***************************************************************************
// ***************************************************************************
// Clip Linking
// ***************************************************************************
// ***************************************************************************
// ***************************************************************************
void CTransform::clipAddChild(CTransform *son)
{
if(!son)
return;
// if already linked, no-op.
if(son->clipHasParent(this))
return;
// add a new parent entry for our son.
CClipNode *clipNode= new CClipNode;
son->_ClipParents.push_back(clipNode);
// link the son to us
clipNode->Parent= this;
// link us to the son
_ClipSons.insert(son, &clipNode->ClipNode);
}
// ***************************************************************************
void CTransform::clipDelChild(CTransform *son)
{
if(!son)
return;
// try to remove from me from my parent
son->clipDelFromParent(this);
}
// ***************************************************************************
void CTransform::clipUnlinkFromAll()
{
// unlink from all parent clip
while( clipGetNumParents() )
{
clipDelFromParent( clipGetParent(0) );
}
}
// ***************************************************************************
CTransform *CTransform::clipGetParent(uint index) const
{
nlassert(index < _ClipParents.size());
return _ClipParents[index]->Parent;
}
// ***************************************************************************
CTransform *CTransform::clipGetChild(uint index) const
{
nlassert(index < _ClipSons.size());
return (const_cast<CTransform*>(this))->_ClipSons.begin()[index];
}
// ***************************************************************************
bool CTransform::clipHasParent(CTransform *parent)
{
// search O(n) for all parents
for(uint i=0;i<_ClipParents.size();i++)
{
if(_ClipParents[i]->Parent==parent)
return true;
}
return false;
}
// ***************************************************************************
void CTransform::clipDelFromParent(CTransform *parent)
{
// search O(n) for all Parents
Changed: #825 Remove all warning when compiling Ryzom on Linux
2010-05-13 20:14:36 +00:00
uint numParents= (uint)_ClipParents.size();
initial version
2010-05-06 00:08:41 +00:00
for(uint i=0;i<numParents;i++)
{
if(_ClipParents[i]->Parent==parent)
{
// found! remove me from my parent list
_ClipParents[i]->ClipNode.unlink();
// remove this parent entry. swap with last
swap(_ClipParents[i], _ClipParents[numParents-1]);
// and delete last.
delete _ClipParents[numParents-1];
_ClipParents.resize(numParents-1);
break;
}
}
}
// ***************************************************************************
void CTransform::setUserClipping(bool enable)
{
setStateFlag (UserClipping, enable);
}
// ***************************************************************************
bool CTransform::getUserClipping() const
{
return getStateFlag(UserClipping) != 0;
}
// ***************************************************************************
// ***************************************************************************
// ShadowMap
// ***************************************************************************
// ***************************************************************************
// ***************************************************************************
void CTransform::getReceiverBBox(CAABBox &bbox)
{
bbox.setCenter(CVector::Null);
bbox.setHalfSize(CVector::Null);
}
// ***************************************************************************
void CTransform::enableCastShadowMap(bool state)
{
bool precState= canCastShadowMap();
if(modelCanCastShadowMap())
setStateFlag(IsFinalShadowMapCaster, state);
else
setStateFlag(IsFinalShadowMapCaster, false);
// if just enabled, create the shadowMap
if(canCastShadowMap() && !precState)
{
createShadowMap();
// The user must have created it.
nlassert(getShadowMap());
}
// if just disabled, free ressource
else if(!canCastShadowMap() && precState)
{
deleteShadowMap();
}
}
// ***************************************************************************
void CTransform::forceCompute()
{
// if father is a skeleton, force to compute the bone we are sticked to
if (_FatherSkeletonModel)
{
_FatherSkeletonModel->forceComputeBone(_FatherBoneId);
}
else
{
// force to comp<6D>te the father
if (_HrcParent)
{
_HrcParent->forceCompute();
}
}
// compute
update();
updateWorldMatrixFromFather();
}
// ***************************************************************************
void CTransform::setForceClipRoot(bool forceClipRoot)
{
if (forceClipRoot == (getStateFlag(ForceClipRoot) != 0)) return;
if (forceClipRoot)
{
// unlink from previous father and link to the root
hrcUnlink();
if (_OwnerScene)
{
_OwnerScene->getRoot()->hrcLinkSon(this);
}
setClusterSystem(NULL);
}
setStateFlag(ForceClipRoot, forceClipRoot);
}
// ***************************************************************************
UTransform *CTransform::buildMatchingUserInterfaceObject()
{
return new UTransform(this);
}
// ***************************************************************************
void CTransform::setShadowMapDirectionZThreshold(float zthre)
{
clamp(zthre, -1.f, 1.f);
_ShadowMapDirectionZThreshold= zthre;
}
// ***************************************************************************
void CTransform::setShadowMapMaxDepth(float depth)
{
depth= max(0.f, depth);
_ShadowMapMaxDepth= depth;
}
}
Reference in a new issue Copy permalink