From 0ea5fc66924303d1bf73ba283a383e2aadee02f2 Mon Sep 17 00:00:00 2001 From: neodarz Date: Sat, 11 Aug 2018 20:21:34 +0200 Subject: Initial commit --- docs/doxygen/nel/a03404.html | 6702 ++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 6702 insertions(+) create mode 100644 docs/doxygen/nel/a03404.html (limited to 'docs/doxygen/nel/a03404.html') diff --git a/docs/doxygen/nel/a03404.html b/docs/doxygen/nel/a03404.html new file mode 100644 index 00000000..6850fb2b --- /dev/null +++ b/docs/doxygen/nel/a03404.html @@ -0,0 +1,6702 @@ + + +NeL: NL3D::CSkeletonUser class Reference + + + +
+

NL3D::CSkeletonUser Class Reference

#include <skeleton_user.h> +

+

Inheritance diagram for NL3D::CSkeletonUser: +

+ +NL3D::USkeleton +NL3D::CTransformUser +NL3D::UTransform +NL3D::UTransform +NL3D::CTransformableUser +NL3D::UTransformable +NL3D::UTransformable +NL3D::UTransformable + +

Detailed Description

+USkeleton implementation.
Author:
Lionel Berenguier

+Nevrax France

+
Date:
2001
+ +

+ +

+Definition at line 51 of file skeleton_user.h. + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

Public Types

enum  TTransformMode { DirectMatrix = 0, +RotEuler, +RotQuat, +TransformModeCount + }
enum  TVisibility { Show = 0, +Hide, +Herit, +VisibilityCount + }
 The visibility flag. In the root case, Herit means Show. More...


Public Member Functions

virtual bool getForceClipRoot () const
virtual bool getForceClipRoot () const=0
virtual bool getLastClippedState () const
 Return true if the object was rendered during the last Scene->rendere(). return false else (ie clipped).

virtual bool getLastClippedState () const=0
 Return true if the object was rendered during the last Scene->rendere(). return false else (ie clipped).

virtual void getLastParentClusters (std::vector< CCluster * > &clusters) const
 Fill a list of cluster that contain this tranform. This is valid after the clip traversal.

virtual void getLastParentClusters (std::vector< CCluster * > &clusters) const=0
 Fill a list of cluster that contain this tranform. This is valid after the clip traversal.

virtual const CMatrixgetLastWorldMatrixComputed () const
virtual const CMatrixgetLastWorldMatrixComputed () const=0
virtual bool getLastWorldVisState () const
 Return true if the object was determined as Visible in Hrc during the last Scene->rendere(). NB: interesting only if Herit. else can use getVisibility().

virtual bool getLastWorldVisState () const=0
 Return true if the object was determined as Visible in Hrc during the last Scene->rendere(). NB: interesting only if Herit. else can use getVisibility().

virtual uint getOrderingLayer () const
 Get the ordering layer.

virtual uint getOrderingLayer () const=0
 Get the ordering layer.

virtual void setForceClipRoot (bool forceClipRoot)
virtual void setForceClipRoot (bool forceClipRoot)=0
virtual void setLogicInfo (ILogicInfo *logicInfo)
virtual void setLogicInfo (ILogicInfo *logicInfo)=0
virtual void setOrderingLayer (uint layer)
virtual void setOrderingLayer (uint layer)=0
Skin operation.
virtual bool bindSkin (UInstance *mi)
virtual void detachSkeletonSon (UTransform *mi)
virtual void stickObject (UTransform *mi, uint boneId)
virtual void stickObjectEx (UTransform *mi, uint boneId, bool forceCLod)
Lod interaction
virtual void changeMRMDistanceSetup (float distanceFinest, float distanceMiddle, float distanceCoarsest)
virtual float getInterpolationDistance () const
 see setInterpolationDistance()

virtual uint getNumBoneComputed () const
 return the number of bones currently animated/computed (because of bindSkin()/stickObject() / Lod system).

virtual float getShapeDistMax () const
 see setShapeDistMax()

virtual void setInterpolationDistance (float dist)
virtual void setShapeDistMax (float distMax)
Misc
virtual bool computeCurrentBBox (NLMISC::CAABBox &bbox, UPlayList *playList, double playTime=0, bool forceCompute=false, bool computeInWorld=false)
virtual bool computeRenderedBBox (NLMISC::CAABBox &bbox, bool computeInWorld=false)
CLod / Character Lod
virtual void computeLodTexture ()
virtual uint getLodCharacterAnimId () const
virtual TGlobalAnimationTime getLodCharacterAnimTime () const
virtual float getLodCharacterDistance () const
 see setLodCharacterDistance. 0 if disabled

virtual sint getLodCharacterShape () const
 see setLodCharacterShape

virtual bool getLodCharacterWrapMode () const
virtual bool isDisplayedAsLodCharacter () const
virtual void setLodCharacterAnimId (uint animId)
 Change/get the Character Lod anim setup.

virtual void setLodCharacterAnimTime (TGlobalAnimationTime time)
virtual void setLodCharacterDistance (float dist)
virtual void setLodCharacterShape (sint shapeId)
virtual void setLodCharacterWrapMode (bool wrapMode)
 tells if the animation must loop or clamp.

Object
 CSkeletonUser (CScene *scene, CTransform *model)
 This model should have been created with Scene::createInstance().

virtual ~CSkeletonUser ()
 This model should have been created with Scene::createInstance().

Bone access.
virtual bool forceComputeBone (uint boneId)
 Force to compute a bone, even if object clipped. false if boneId is invalid.

virtual UBonegetBone (uint boneId)
 retrieve the bone. nlerror if not here. (>=getNumBones())

virtual sint getBoneIdByName (const std::string &boneName) const
 retrieve the bone Id, by his name. -1 if not found.

virtual uint getNumBones () const
 retrieve the number of bones.

virtual bool isBoneComputed (uint boneId) const
 Tell if a bone has been computed in the last frame or not. false if boneId is invalid.

AnimCtrl (IK...)
virtual IAnimCtrlgetBoneAnimCtrl (uint boneId) const
 return NULL if bad BoneId

virtual void setBoneAnimCtrl (uint boneId, IAnimCtrl *ctrl)
Accessor for CSeneUser.
CSkeletonModelgetSkeleton ()

Data Fields

std::vector< CBoneUser_Bones
 This is a mirror of _Skeleton->Bones.

CSkeletonModel_Skeleton
 This is the SAME pointer than _Transform, but correctly casted.


Protected Attributes

bool _DeleteIt
CScene_Scene
CTransform_Transform
ITransformable_Transformable
+


Member Enumeration Documentation

+

+ + + + +
+ + +
enum NL3D::UTransformable::TTransformMode [inherited] +
+
+ + + + + +
+   + + +

+

Enumeration values:
+ + + + + +
DirectMatrix  +
RotEuler  +
RotQuat  +
TransformModeCount  +
+
+ +

+Definition at line 66 of file u_transformable.h. +

+

00067         {
+00068                 DirectMatrix=0,         // DirectMatrixMode .
+00069                 RotEuler,                       // Matrix is computed from sperated composantes, with euler rotation.
+00070                 RotQuat,                        // Matrix is computed from sperated composantes, with quat rotation (default).
+00071 
+00072                 TransformModeCount
+00073         };
+
+

+ + + + +
+ + +
enum NL3D::UTransform::TVisibility [inherited] +
+
+ + + + + +
+   + + +

+The visibility flag. In the root case, Herit means Show. +

+

Enumeration values:
+ + + + + +
Show  +
Hide  +
Herit  +
VisibilityCount  +
+
+ +

+Definition at line 68 of file u_transform.h. +

+

00069         {
+00070                 Show=0,         // The model is shown in the hierarchy
+00071                 Hide,           // The model is hidden in the hierarchy
+00072                 Herit,          // The model herit the visibilty from his father
+00073 
+00074                 VisibilityCount
+00075         };
+
+


Constructor & Destructor Documentation

+

+ + + + +
+ + + + + + + + + + + + + + + + + + + +
NL3D::CSkeletonUser::CSkeletonUser CScene scene,
CTransform model
[inline]
+
+ + + + + +
+   + + +

+This model should have been created with Scene::createInstance(). +

+ +

+Definition at line 66 of file skeleton_user.h. +

+References _Skeleton, NL3D::CSkeletonModel::Bones, NL3D_MEM_SKELETON, and uint. +

+

00066                                                         : 
+00067           CTransformUser(scene, model, true)
+00068         {
+00069                 NL3D_MEM_SKELETON
+00070                 _Skeleton= NLMISC::safe_cast<CSkeletonModel*>(_Transform);
+00071 
+00072                 // create user bones.
+00073                 uint    numBones= _Skeleton->Bones.size();
+00074                 _Bones.reserve(numBones);
+00075                 for(uint i=0;i<numBones;i++)
+00076                 {
+00077                         _Bones.push_back(&_Skeleton->Bones[i]);
+00078                 }
+00079         }
+
+

+ + + + +
+ + + + + + + + + +
virtual NL3D::CSkeletonUser::~CSkeletonUser  )  [inline, virtual]
+
+ + + + + +
+   + + +

+This model should have been created with Scene::createInstance(). +

+ +

+Definition at line 80 of file skeleton_user.h. +

+References _Skeleton, and NL3D_MEM_SKELETON. +

+

00081         {
+00082                 NL3D_MEM_SKELETON
+00083                 // deleted in CTransformUser.
+00084                 _Skeleton= NULL;
+00085                 // user bones are auto deleted.
+00086         }
+
+


Member Function Documentation

+

+ + + + +
+ + + + + + + + + + +
bool NL3D::CSkeletonUser::bindSkin UInstance mi  )  [virtual]
+
+ + + + + +
+   + + +

+bind a MeshInstance skin to the skeleton. NB: ~UTransform() and ~USkeleton() call detachSkeletonSon(). NB: nlerror() if mi is not a UInstance. (ie a mesh instance). NB: an object can't be skinned and sticked at same time :) NB: replaced if already here. NB: when a skin is binded, the command hide(), show(), ... have no effect on it, until it is detachSkeletonSon()-ed

Returns:
false if mi is NULL or not skinnable, true otherwise
+ +

+Implements NL3D::USkeleton. +

+Definition at line 97 of file skeleton_user.cpp. +

+References _Skeleton, NL3D::CSkeletonModel::bindSkin(), NL3D_HAUTO_UI_SKELETON, NL3D_MEM_SKELETON, and nlerror. +

+

00098 {
+00099         NL3D_MEM_SKELETON
+00100         NL3D_HAUTO_UI_SKELETON;
+00101 
+00102         if(mi==NULL)
+00103         {
+00104                 nlerror("USkeleton::bindSkin(): mi is NULL");
+00105                 return false;
+00106         }
+00107         CTransform                      *trans= dynamic_cast<CTransformUser*>(mi)->getTransform();
+00108         CMeshBaseInstance       *meshi= dynamic_cast<CMeshBaseInstance*>(trans);
+00109         if(meshi==NULL)
+00110         {
+00111                 nlerror("USkeleton::bindSkin(): mi is not a MeshInstance or MeshMRMInstance");
+00112                 return false;
+00113         }
+00114         return _Skeleton->bindSkin(meshi);
+00115 }
+
+

+ + + + +
+ + + + + + + + + +
virtual bool NL3D::CTransformUser::canCastShadowMap  )  const [virtual, inherited]
+
+ + + + + +
+   + + +

+true if the instance cast shadow. By default false +

+ +

+Implements NL3D::UTransform.

+

+ + + + +
+ + + + + + + + + +
virtual bool NL3D::UTransform::canCastShadowMap  )  const [pure virtual, inherited]
+
+ + + + + +
+   + + +

+true if the instance cast shadow. By default false +

+ +

+Implemented in NL3D::CTransformUser.

+

+ + + + +
+ + + + + + + + + +
virtual bool NL3D::CTransformUser::canReceiveShadowMap  )  const [virtual, inherited]
+
+ + + + + +
+   + + +

+true if the instance receive shadow. By default false +

+ +

+Implements NL3D::UTransform.

+

+ + + + +
+ + + + + + + + + +
virtual bool NL3D::UTransform::canReceiveShadowMap  )  const [pure virtual, inherited]
+
+ + + + + +
+   + + +

+true if the instance receive shadow. By default false +

+ +

+Implemented in NL3D::CTransformUser.

+

+ + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + + +
void NL3D::CSkeletonUser::changeMRMDistanceSetup float  distanceFinest,
float  distanceMiddle,
float  distanceCoarsest
[virtual]
+
+ + + + + +
+   + + +

+Special version for skins. NB: skins never follow their original MRM distance setup, but follow this skeleton MRM setup. Default is 3-10-50. NB: Unlike UInstance::changeMRMDistanceSetup(), this setup applies to the SkeletonModel, not the shape. NB: no-op if distanceFinest<0, distanceMiddle<=distanceFinest or if distanceCoarsest<=distanceMiddle.

Parameters:
+ + + + +
distanceFinest The MRM has its max faces when dist<=distanceFinest.
distanceMiddle The MRM has 50% of its faces at dist==distanceMiddle.
distanceCoarsest The MRM has faces/Divisor (ie near 0) when dist>=distanceCoarsest.
+
+ +

+Implements NL3D::USkeleton. +

+Definition at line 265 of file skeleton_user.cpp. +

+References _Skeleton, NL3D::CSkeletonModel::changeMRMDistanceSetup(), NL3D_HAUTO_UI_SKELETON, and NL3D_MEM_SKELETON. +

+

00266 {
+00267         NL3D_MEM_SKELETON
+00268         NL3D_HAUTO_UI_SKELETON;
+00269         _Skeleton->changeMRMDistanceSetup(distanceFinest, distanceMiddle, distanceCoarsest);
+00270 }
+
+

+ + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
bool NL3D::CSkeletonUser::computeCurrentBBox NLMISC::CAABBox bbox,
UPlayList playList,
double  playTime = 0,
bool  forceCompute = false,
bool  computeInWorld = false
[virtual]
+
+ + + + + +
+   + + +

+same as computeRenderedBBox() but force animation and compute of all bones => don't need render(), but slower. for all used bones, extend the bbox with their pos

Parameters:
+ + + + + +
bbox return the bbox of the skinned skeleton, local to the skeleton. If the skeleton is not skinned/sticked at all, bbox is not modified.
playList set NULL if no one, else this playList will be played at the time playTime
forceCompute force evaluation of bbox even if not skinned
computeInWorld true if want to get the bbox in world.
+
+
Returns:
true if the bbox is computed, false otherwise.
+ +

+Implements NL3D::USkeleton. +

+Definition at line 281 of file skeleton_user.cpp. +

+References _Skeleton, NL3D::CSkeletonModel::computeCurrentBBox(), NL3D::CPlayListUser::evalPlayList(), NL3D_HAUTO_UI_SKELETON, and NL3D_MEM_SKELETON. +

+

00282 {
+00283         NL3D_MEM_SKELETON
+00284         NL3D_HAUTO_UI_SKELETON;
+00285 
+00286         if(playList!=NULL)
+00287         {
+00288                 CPlayListUser   *plUser= static_cast<CPlayListUser*>(playList);
+00289                 plUser->evalPlayList(playTime);
+00290         }
+00291 
+00292         return _Skeleton->computeCurrentBBox(bbox, forceCompute, computeInWorld);
+00293 }
+
+

+ + + + +
+ + + + + + + + + +
void NL3D::CSkeletonUser::computeLodTexture  )  [virtual]
+
+ + + + + +
+   + + +

+Call it when you want the system to recompute the Lod texture NB: Lod texturing is possible only in conjunction with AsyncTextureManager. Hence, instances skinned to the skeleton should be in AsyncTextureMode. For best result, you should wait that each of these instances are isAsyncTextureReady() (texture loaded) +

+Implements NL3D::USkeleton. +

+Definition at line 295 of file skeleton_user.cpp. +

+References _Skeleton, NL3D::CSkeletonModel::computeLodTexture(), NL3D_HAUTO_UI_SKELETON, and NL3D_MEM_SKELETON. +

+

00296 {
+00297         NL3D_MEM_SKELETON
+00298         NL3D_HAUTO_UI_SKELETON;
+00299 
+00300         _Skeleton->computeLodTexture();
+00301 }
+
+

+ + + + +
+ + + + + + + + + + + + + + + + + + + +
bool NL3D::CSkeletonUser::computeRenderedBBox NLMISC::CAABBox bbox,
bool  computeInWorld = false
[virtual]
+
+ + + + + +
+   + + +

+Retrieve the current approx BBox around the skeleton, computed in the last USene::render(). for all computed bones, extend the bbox with their pos

Parameters:
+ + + +
bbox return the bbox of the skinned skeleton, local to the skeleton. If the skeleton was clipped, the bbox is not modified.
computeInWorld true if want to get the bbox in world.
+
+
Returns:
true if the bbox is computed, false otherwise.
+ +

+Implements NL3D::USkeleton. +

+Definition at line 274 of file skeleton_user.cpp. +

+References _Skeleton, NL3D::CSkeletonModel::computeRenderedBBox(), NL3D_HAUTO_UI_SKELETON, and NL3D_MEM_SKELETON. +

+

00275 {
+00276         NL3D_MEM_SKELETON
+00277         NL3D_HAUTO_UI_SKELETON;
+00278         return _Skeleton->computeRenderedBBox(bbox, computeInWorld);
+00279 }
+
+

+ + + + +
+ + + + + + + + + + +
void NL3D::CSkeletonUser::detachSkeletonSon UTransform mi  )  [virtual]
+
+ + + + + +
+   + + +

+unparent a CTransform from a bone of the skeleton, or unbind a skin. No-op if not here. NB: mi is placed at root of hierarchy. +

+Implements NL3D::USkeleton. +

+Definition at line 142 of file skeleton_user.cpp. +

+References _Skeleton, NL3D::CSkeletonModel::detachSkeletonSon(), NL3D_HAUTO_UI_SKELETON, NL3D_MEM_SKELETON, and nlerror. +

+

00143 {
+00144         NL3D_MEM_SKELETON
+00145         NL3D_HAUTO_UI_SKELETON;
+00146 
+00147         if(mi==NULL)
+00148                 nlerror("USkeleton::detachSkeletonSon(): mi is NULL");
+00149         CTransform              *trans= (dynamic_cast<CTransformUser*>(mi))->getTransform();
+00150         _Skeleton->detachSkeletonSon(trans);
+00151 }
+
+

+ + + + +
+ + + + + + + + + + +
virtual void NL3D::CTransformUser::enableCastShadowMap bool  state  )  [virtual, inherited]
+
+ + + + + +
+   + + +

+By default, map shadow casting is disabled. This enabled shadow for this model. Fails if the model don't support dynamic Map Shadow Casting (eg landscape) +

+Implements NL3D::UTransform.

+

+ + + + +
+ + + + + + + + + + +
virtual void NL3D::UTransform::enableCastShadowMap bool  state  )  [pure virtual, inherited]
+
+ + + + + +
+   + + +

+By default, map shadow casting is disabled. This enabled shadow for this model. Fails if the model don't support dynamic Map Shadow Casting (eg landscape) +

+Implemented in NL3D::CTransformUser.

+

+ + + + +
+ + + + + + + + + + +
virtual void NL3D::CTransformUser::enableReceiveShadowMap bool  state  )  [virtual, inherited]
+
+ + + + + +
+   + + +

+By default, map shadow receiving is disabled. This enabled shadow for this model. Fails if the model don't support dynamic Map Shadow Receiving (eg Particle system) +

+Implements NL3D::UTransform.

+

+ + + + +
+ + + + + + + + + + +
virtual void NL3D::UTransform::enableReceiveShadowMap bool  state  )  [pure virtual, inherited]
+
+ + + + + +
+   + + +

+By default, map shadow receiving is disabled. This enabled shadow for this model. Fails if the model don't support dynamic Map Shadow Receiving (eg Particle system) +

+Implemented in NL3D::CTransformUser.

+

+ + + + +
+ + + + + + + + + + +
bool NL3D::CSkeletonUser::forceComputeBone uint  boneId  )  [virtual]
+
+ + + + + +
+   + + +

+Force to compute a bone, even if object clipped. false if boneId is invalid. +

+ +

+Implements NL3D::USkeleton. +

+Definition at line 187 of file skeleton_user.cpp. +

+References _Skeleton, NL3D::CSkeletonModel::forceComputeBone(), NL3D_HAUTO_UI_SKELETON, NL3D_MEM_SKELETON, and uint. +

+

00188 {
+00189         NL3D_MEM_SKELETON
+00190         NL3D_HAUTO_UI_SKELETON;
+00191 
+00192         return _Skeleton->forceComputeBone(boneId);
+00193 }
+
+

+ + + + +
+ + + + + + + + + +
virtual void NL3D::CTransformUser::freezeHRC  )  [virtual, inherited]
+
+ + + + + +
+   + + +

+Optimisation: freeze the HRC so the WorldMatrix computed at next render() will be kept for long, and the model won't either be tested in HRC.

+NB: the model won't be tested in HRC only if this model is a "root" For maximum optimisation, you should freezeHRC() all the models of a hierarchy, from base root to leaves.

+NB: if the hierarchy of this object must change, or if the object must moves, you must call unfreezeHRC() first, and you should do this for all the parents of this model. +

+Implements NL3D::UTransform.

+

+ + + + +
+ + + + + + + + + +
virtual void NL3D::UTransform::freezeHRC  )  [pure virtual, inherited]
+
+ + + + + +
+   + + +

+Optimisation: freeze the HRC so the WorldMatrix computed at next render() will be kept for long, and the model won't either be tested in HRC.

+NB: the model won't be tested in HRC only if this model is a "root" For maximum optimisation, you should freezeHRC() all the models of a hierarchy, from base root to leaves.

+NB: if the hierarchy of this object must change, or if the object must moves, you must call unfreezeHRC() first, and you should do this for all the parents of this model. +

+Implemented in NL3D::CTransformUser.

+

+ + + + +
+ + + + + + + + + + +
UBone & NL3D::CSkeletonUser::getBone uint  boneId  )  [virtual]
+
+ + + + + +
+   + + +

+retrieve the bone. nlerror if not here. (>=getNumBones()) +

+ +

+Implements NL3D::USkeleton. +

+Definition at line 162 of file skeleton_user.cpp. +

+References NL3D_HAUTO_UI_SKELETON, NL3D_MEM_SKELETON, nlerror, and uint. +

+

00163 {
+00164         NL3D_MEM_SKELETON
+00165         NL3D_HAUTO_UI_SKELETON;
+00166 
+00167         if(boneId>=_Bones.size())
+00168                 nlerror("getBone(): bad boneId");
+00169         return dynamic_cast<UBone&>(_Bones[boneId]);
+00170 }
+
+

+ + + + +
+ + + + + + + + + + +
IAnimCtrl * NL3D::CSkeletonUser::getBoneAnimCtrl uint  boneId  )  const [virtual]
+
+ + + + + +
+   + + +

+return NULL if bad BoneId +

+ +

+Implements NL3D::USkeleton. +

+Definition at line 313 of file skeleton_user.cpp. +

+References _Skeleton, NL3D::CSkeletonModel::getBoneAnimCtrl(), NL3D_HAUTO_UI_SKELETON, NL3D_MEM_SKELETON, and uint. +

+

00314 {
+00315         NL3D_MEM_SKELETON
+00316         NL3D_HAUTO_UI_SKELETON;
+00317 
+00318         return _Skeleton->getBoneAnimCtrl(boneId);
+00319 }
+
+

+ + + + +
+ + + + + + + + + + +
sint NL3D::CSkeletonUser::getBoneIdByName const std::string &  boneName  )  const [virtual]
+
+ + + + + +
+   + + +

+retrieve the bone Id, by his name. -1 if not found. +

+ +

+Implements NL3D::USkeleton. +

+Definition at line 171 of file skeleton_user.cpp. +

+References _Skeleton, NL3D::CSkeletonModel::getBoneIdByName(), NL3D_HAUTO_UI_SKELETON, NL3D_MEM_SKELETON, and sint. +

+

00172 {
+00173         NL3D_MEM_SKELETON
+00174         NL3D_HAUTO_UI_SKELETON;
+00175 
+00176         return _Skeleton->getBoneIdByName(boneName);
+00177 }
+
+

+ + + + +
+ + + + + + + + + +
virtual UInstanceGroup* NL3D::CTransformUser::getClusterSystem  )  [virtual, inherited]
+
+ + + + + +
+   + + +

+ +

+Implements NL3D::UTransform.

+

+ + + + +
+ + + + + + + + + +
virtual UInstanceGroup* NL3D::UTransform::getClusterSystem  )  [pure virtual, inherited]
+
+ + + + + +
+   + + +

+ +

+Implemented in NL3D::CTransformUser.

+

+ + + + +
+ + + + + + + + + +
virtual bool NL3D::CTransformUser::getForceClipRoot  )  const [inline, virtual, inherited]
+
+ + + + + +
+   + + +

+ +

+Implements NL3D::UTransform. +

+Definition at line 265 of file transform_user.h. +

+References NL3D::CTransformUser::_Transform, NL3D::CTransform::getForceClipRoot(), and NL3D_MEM_TRANSFORM. +

+

00266         {
+00267                 NL3D_MEM_TRANSFORM
+00268                 return _Transform->getForceClipRoot();
+00269         }
+
+

+ + + + +
+ + + + + + + + + +
virtual bool NL3D::UTransform::getForceClipRoot  )  const [pure virtual, inherited]
+
+ + + + + +
+   + + +

+ +

+Implemented in NL3D::CTransformUser.

+

+ + + + +
+ + + + + + + + + +
float NL3D::CSkeletonUser::getInterpolationDistance  )  const [virtual]
+
+ + + + + +
+   + + +

+see setInterpolationDistance() +

+ +

+Implements NL3D::USkeleton. +

+Definition at line 60 of file skeleton_user.cpp. +

+References _Skeleton, NL3D::CSkeletonModel::getInterpolationDistance(), NL3D_HAUTO_UI_SKELETON, and NL3D_MEM_SKELETON. +

+

00061 {
+00062         NL3D_MEM_SKELETON
+00063         NL3D_HAUTO_UI_SKELETON;
+00064 
+00065         return _Skeleton->getInterpolationDistance();
+00066 }
+
+

+ + + + +
+ + + + + + + + + +
virtual bool NL3D::CTransformUser::getLastClippedState  )  const [inline, virtual, inherited]
+
+ + + + + +
+   + + +

+Return true if the object was rendered during the last Scene->rendere(). return false else (ie clipped). +

+ +

+Implements NL3D::UTransform. +

+Definition at line 204 of file transform_user.h. +

+References NL3D::CTransformUser::_Transform, NL3D::CTransform::isClipVisible(), and NL3D_MEM_TRANSFORM. +

+

00205         {
+00206                 NL3D_MEM_TRANSFORM
+00207                 return _Transform->isClipVisible();
+00208         }
+
+

+ + + + +
+ + + + + + + + + +
virtual bool NL3D::UTransform::getLastClippedState  )  const [pure virtual, inherited]
+
+ + + + + +
+   + + +

+Return true if the object was rendered during the last Scene->rendere(). return false else (ie clipped). +

+ +

+Implemented in NL3D::CTransformUser.

+

+ + + + +
+ + + + + + + + + + +
virtual void NL3D::CTransformUser::getLastParentClusters std::vector< CCluster * > &  clusters  )  const [virtual, inherited]
+
+ + + + + +
+   + + +

+Fill a list of cluster that contain this tranform. This is valid after the clip traversal. +

+ +

+Implements NL3D::UTransform.

+

+ + + + +
+ + + + + + + + + + +
virtual void NL3D::UTransform::getLastParentClusters std::vector< CCluster * > &  clusters  )  const [pure virtual, inherited]
+
+ + + + + +
+   + + +

+Fill a list of cluster that contain this tranform. This is valid after the clip traversal. +

+ +

+Implemented in NL3D::CTransformUser.

+

+ + + + +
+ + + + + + + + + +
virtual const CMatrix& NL3D::CTransformUser::getLastWorldMatrixComputed  )  const [virtual, inherited]
+
+ + + + + +
+   + + +

+get the last world matrix computed in last render(). NB: this WM is computed in last render() only if the object was not clipped. So use it wisely. use getLastClippedState() to konw if the object was visible in last render(). +

+Implements NL3D::UTransform.

+

+ + + + +
+ + + + + + + + + +
virtual const CMatrix& NL3D::UTransform::getLastWorldMatrixComputed  )  const [pure virtual, inherited]
+
+ + + + + +
+   + + +

+get the last world matrix computed in last render(). NB: this WM is computed in last render() only if the object was not clipped. So use it wisely. use getLastClippedState() to konw if the object was visible in last render(). +

+Implemented in NL3D::CTransformUser.

+

+ + + + +
+ + + + + + + + + +
virtual bool NL3D::CTransformUser::getLastWorldVisState  )  const [inline, virtual, inherited]
+
+ + + + + +
+   + + +

+Return true if the object was determined as Visible in Hrc during the last Scene->rendere(). NB: interesting only if Herit. else can use getVisibility(). +

+ +

+Implements NL3D::UTransform. +

+Definition at line 198 of file transform_user.h. +

+References NL3D::CTransformUser::_Transform, NL3D::CTransform::isHrcVisible(), and NL3D_MEM_TRANSFORM. +

+

00199         {
+00200                 NL3D_MEM_TRANSFORM
+00201                 return _Transform->isHrcVisible();
+00202         }
+
+

+ + + + +
+ + + + + + + + + +
virtual bool NL3D::UTransform::getLastWorldVisState  )  const [pure virtual, inherited]
+
+ + + + + +
+   + + +

+Return true if the object was determined as Visible in Hrc during the last Scene->rendere(). NB: interesting only if Herit. else can use getVisibility(). +

+ +

+Implemented in NL3D::CTransformUser.

+

+ + + + +
+ + + + + + + + + +
virtual const std::string& NL3D::CTransformUser::getLoadBalancingGroup  )  const [virtual, inherited]
+
+ + + + + +
+   + + +

+Get the load Balancing group of a model. see setLoadBalancingGroup(). +

+Implements NL3D::UTransform.

+

+ + + + +
+ + + + + + + + + +
virtual const std::string& NL3D::UTransform::getLoadBalancingGroup  )  const [pure virtual, inherited]
+
+ + + + + +
+   + + +

+Get the load Balancing group of a model. see setLoadBalancingGroup(). +

+Implemented in NL3D::CTransformUser.

+

+ + + + +
+ + + + + + + + + +
uint NL3D::CSkeletonUser::getLodCharacterAnimId  )  const [virtual]
+
+ + + + + +
+   + + +

+Call it when you want the system to recompute the Lod texture NB: Lod texturing is possible only in conjunction with AsyncTextureManager. Hence, instances skinned to the skeleton should be in AsyncTextureMode. For best result, you should wait that each of these instances are isAsyncTextureReady() (texture loaded) +

+Implements NL3D::USkeleton. +

+Definition at line 214 of file skeleton_user.cpp. +

+References _Skeleton, NL3D::CSkeletonModel::getLodCharacterAnimId(), NL3D_HAUTO_UI_SKELETON, NL3D_MEM_SKELETON, and uint. +

+

00215 {
+00216         NL3D_MEM_SKELETON
+00217         NL3D_HAUTO_UI_SKELETON;
+00218         return _Skeleton->getLodCharacterAnimId();
+00219 }
+
+

+ + + + +
+ + + + + + + + + +
TGlobalAnimationTime NL3D::CSkeletonUser::getLodCharacterAnimTime  )  const [virtual]
+
+ + + + + +
+   + + +

+Call it when you want the system to recompute the Lod texture NB: Lod texturing is possible only in conjunction with AsyncTextureManager. Hence, instances skinned to the skeleton should be in AsyncTextureMode. For best result, you should wait that each of these instances are isAsyncTextureReady() (texture loaded) +

+Implements NL3D::USkeleton. +

+Definition at line 226 of file skeleton_user.cpp. +

+References _Skeleton, NL3D::CSkeletonModel::getLodCharacterAnimTime(), NL3D_HAUTO_UI_SKELETON, NL3D_MEM_SKELETON, and NL3D::TGlobalAnimationTime. +

+

00227 {
+00228         NL3D_MEM_SKELETON
+00229         NL3D_HAUTO_UI_SKELETON;
+00230         return _Skeleton->getLodCharacterAnimTime();
+00231 }
+
+

+ + + + +
+ + + + + + + + + +
float NL3D::CSkeletonUser::getLodCharacterDistance  )  const [virtual]
+
+ + + + + +
+   + + +

+see setLodCharacterDistance. 0 if disabled +

+ +

+Implements NL3D::USkeleton. +

+Definition at line 244 of file skeleton_user.cpp. +

+References _Skeleton, NL3D::CSkeletonModel::getLodCharacterDistance(), NL3D_HAUTO_UI_SKELETON, and NL3D_MEM_SKELETON. +

+

00245 {
+00246         NL3D_MEM_SKELETON
+00247         NL3D_HAUTO_UI_SKELETON;
+00248         return _Skeleton->getLodCharacterDistance();
+00249 }
+
+

+ + + + +
+ + + + + + + + + +
sint NL3D::CSkeletonUser::getLodCharacterShape  )  const [virtual]
+
+ + + + + +
+   + + +

+see setLodCharacterShape +

+ +

+Implements NL3D::USkeleton. +

+Definition at line 202 of file skeleton_user.cpp. +

+References _Skeleton, NL3D::CSkeletonModel::getLodCharacterShape(), NL3D_HAUTO_UI_SKELETON, NL3D_MEM_SKELETON, and sint. +

+

00203 {
+00204         NL3D_MEM_SKELETON
+00205         NL3D_HAUTO_UI_SKELETON;
+00206         return _Skeleton->getLodCharacterShape();
+00207 }
+
+

+ + + + +
+ + + + + + + + + +
bool NL3D::CSkeletonUser::getLodCharacterWrapMode  )  const [virtual]
+
+ + + + + +
+   + + +

+Call it when you want the system to recompute the Lod texture NB: Lod texturing is possible only in conjunction with AsyncTextureManager. Hence, instances skinned to the skeleton should be in AsyncTextureMode. For best result, you should wait that each of these instances are isAsyncTextureReady() (texture loaded) +

+Implements NL3D::USkeleton. +

+Definition at line 256 of file skeleton_user.cpp. +

+References _Skeleton, NL3D::CSkeletonModel::getLodCharacterWrapMode(), NL3D_HAUTO_UI_SKELETON, and NL3D_MEM_SKELETON. +

+

00257 {
+00258         NL3D_MEM_SKELETON
+00259         NL3D_HAUTO_UI_SKELETON;
+00260         return _Skeleton->getLodCharacterWrapMode();
+00261 }
+
+

+ + + + +
+ + + + + + + + + +
virtual const CMatrix& NL3D::CTransformableUser::getMatrix  )  const [inline, virtual, inherited]
+
+ + + + + +
+   + + +

+Get the matrix, compute her if necessary (work in all modes). +

+ +

+Implements NL3D::UTransformable. +

+Definition at line 81 of file transformable_user.h. +

+References NL3D::CTransformableUser::_Transformable, NL3D::ITransformable::getMatrix(), and NL3D_MEM_TRANSFORMABLE. +

+

00082         {
+00083                 NL3D_MEM_TRANSFORMABLE
+00084                 return _Transformable->getMatrix();
+00085         }
+
+

+ + + + +
+ + + + + + + + + +
virtual const CMatrix& NL3D::UTransformable::getMatrix  )  const [pure virtual, inherited]
+
+ + + + + +
+   + + +

+Get the matrix, compute her if necessary (work in all modes). +

+ +

+Implemented in NL3D::CTransformableUser. +

+Referenced by NL3D::CDriverUser::setMatrixMode3D().

+

+ + + + +
+ + + + + + + + + +
virtual NLMISC::CRGBA NL3D::CTransformUser::getMeanColor  )  const [virtual, inherited]
+
+ + + + + +
+   + + +

+see setMeanColor() +

+ +

+Implements NL3D::UTransform.

+

+ + + + +
+ + + + + + + + + +
virtual NLMISC::CRGBA NL3D::UTransform::getMeanColor  )  const [pure virtual, inherited]
+
+ + + + + +
+   + + +

+see setMeanColor() +

+ +

+Implemented in NL3D::CTransformUser.

+

+ + + + +
+ + + + + + + + + +
virtual uint NL3D::CSkeletonUser::getNumBoneComputed  )  const [virtual]
+
+ + + + + +
+   + + +

+return the number of bones currently animated/computed (because of bindSkin()/stickObject() / Lod system). +

+ +

+Implements NL3D::USkeleton.

+

+ + + + +
+ + + + + + + + + +
uint NL3D::CSkeletonUser::getNumBones  )  const [virtual]
+
+ + + + + +
+   + + +

+retrieve the number of bones. +

+ +

+Implements NL3D::USkeleton. +

+Definition at line 155 of file skeleton_user.cpp. +

+References NL3D_HAUTO_UI_SKELETON, NL3D_MEM_SKELETON, and uint. +

+

00156 {
+00157         NL3D_MEM_SKELETON
+00158         NL3D_HAUTO_UI_SKELETON;
+00159 
+00160         return _Bones.size();
+00161 }
+
+

+ + + + +
+ + + + + + + + + +
virtual uint NL3D::CTransformUser::getOrderingLayer  )  const [inline, virtual, inherited]
+
+ + + + + +
+   + + +

+Get the ordering layer. +

+ +

+Implements NL3D::UTransform. +

+Definition at line 169 of file transform_user.h. +

+References NL3D::CTransformUser::_Transform, NL3D::CTransform::getOrderingLayer(), NL3D_MEM_TRANSFORM, and uint. +

+

00170         { 
+00171                 NL3D_MEM_TRANSFORM
+00172                 return _Transform->getOrderingLayer(); 
+00173         }
+
+

+ + + + +
+ + + + + + + + + +
virtual uint NL3D::UTransform::getOrderingLayer  )  const [pure virtual, inherited]
+
+ + + + + +
+   + + +

+Get the ordering layer. +

+ +

+Implemented in NL3D::CTransformUser.

+

+ + + + +
+ + + + + + + + + +
virtual CVector NL3D::CTransformableUser::getPivot  )  [inline, virtual, inherited]
+
+ + + + + +
+   + + +

+Work only in Rot* mode (nlassert). +

+ +

+Implements NL3D::UTransformable. +

+Definition at line 195 of file transformable_user.h. +

+References NL3D::CTransformableUser::_Transformable, NL3D::ITransformable::getPivot(), and NL3D_MEM_TRANSFORMABLE. +

+

00196         {
+00197                 NL3D_MEM_TRANSFORMABLE
+00198                 return _Transformable->getPivot();
+00199         }
+
+

+ + + + +
+ + + + + + + + + + +
virtual void NL3D::CTransformableUser::getPivot CVector pivot  )  [inline, virtual, inherited]
+
+ + + + + +
+   + + +

+Work only in Rot* mode (nlassert). +

+ +

+Implements NL3D::UTransformable. +

+Definition at line 169 of file transformable_user.h. +

+References NL3D::CTransformableUser::_Transformable, NL3D::ITransformable::getPivot(), and NL3D_MEM_TRANSFORMABLE. +

+

00170         {
+00171                 NL3D_MEM_TRANSFORMABLE
+00172                 _Transformable->getPivot(pivot);
+00173         }
+
+

+ + + + +
+ + + + + + + + + +
virtual CVector NL3D::UTransformable::getPivot  )  [pure virtual, inherited]
+
+ + + + + +
+   + + +

+Work only in Rot* mode (nlassert). +

+ +

+Implemented in NL3D::CTransformableUser.

+

+ + + + +
+ + + + + + + + + + +
virtual void NL3D::UTransformable::getPivot CVector pivot  )  [pure virtual, inherited]
+
+ + + + + +
+   + + +

+Work only in Rot* mode (nlassert). +

+ +

+Implemented in NL3D::CTransformableUser.

+

+ + + + +
+ + + + + + + + + +
const char * NL3D::UTransformable::getPivotValueName  )  [static, inherited]
+
+ + + + + +
+   + + +

+ +

+Definition at line 55 of file transformable_user.cpp. +

+References NL3D_MEM_TRANSFORMABLE. +

+

00056 {
+00057         NL3D_MEM_TRANSFORMABLE
+00058         return ITransformable::getPivotValueName();
+00059 }
+
+

+ + + + +
+ + + + + + + + + +
virtual CVector NL3D::CTransformableUser::getPos  )  [inline, virtual, inherited]
+
+ + + + + +
+   + + +

+Work only in Rot* mode(nlassert). +

+ +

+Implements NL3D::UTransformable. +

+Definition at line 175 of file transformable_user.h. +

+References NL3D::CTransformableUser::_Transformable, NL3D::ITransformable::getPos(), and NL3D_MEM_TRANSFORMABLE. +

+Referenced by NL3D::CInstanceUser::startAsyncTextureLoading(). +

+

00176         {
+00177                 NL3D_MEM_TRANSFORMABLE
+00178                 return _Transformable->getPos();
+00179         }
+
+

+ + + + +
+ + + + + + + + + + +
virtual void NL3D::CTransformableUser::getPos CVector pos  )  [inline, virtual, inherited]
+
+ + + + + +
+   + + +

+Work only in Rot* mode(nlassert). +

+ +

+Implements NL3D::UTransformable. +

+Definition at line 149 of file transformable_user.h. +

+References NL3D::CTransformableUser::_Transformable, NL3D::ITransformable::getPos(), and NL3D_MEM_TRANSFORMABLE. +

+

00150         {
+00151                 NL3D_MEM_TRANSFORMABLE
+00152                 _Transformable->getPos(pos);
+00153         }
+
+

+ + + + +
+ + + + + + + + + +
virtual CVector NL3D::UTransformable::getPos  )  [pure virtual, inherited]
+
+ + + + + +
+   + + +

+Work only in Rot* mode(nlassert). +

+ +

+Implemented in NL3D::CTransformableUser.

+

+ + + + +
+ + + + + + + + + + +
virtual void NL3D::UTransformable::getPos CVector pos  )  [pure virtual, inherited]
+
+ + + + + +
+   + + +

+Work only in Rot* mode(nlassert). +

+ +

+Implemented in NL3D::CTransformableUser.

+

+ + + + +
+ + + + + + + + + +
const char * NL3D::UTransformable::getPosValueName  )  [static, inherited]
+
+ + + + + +
+   + + +

+ +

+Definition at line 35 of file transformable_user.cpp. +

+References NL3D_MEM_TRANSFORMABLE. +

+

00036 {
+00037         NL3D_MEM_TRANSFORMABLE
+00038         return ITransformable::getPosValueName ();
+00039 }
+
+

+ + + + +
+ + + + + + + + + +
virtual CVector NL3D::CTransformableUser::getRotEuler  )  [inline, virtual, inherited]
+
+ + + + + +
+   + + +

+Work only in RotEuler mode(nlassert). +

+ +

+Implements NL3D::UTransformable. +

+Definition at line 180 of file transformable_user.h. +

+References NL3D::CTransformableUser::_Transformable, NL3D::ITransformable::getRotEuler(), and NL3D_MEM_TRANSFORMABLE. +

+

00181         {
+00182                 NL3D_MEM_TRANSFORMABLE
+00183                 return _Transformable->getRotEuler();
+00184         }
+
+

+ + + + +
+ + + + + + + + + + +
virtual void NL3D::CTransformableUser::getRotEuler CVector rot  )  [inline, virtual, inherited]
+
+ + + + + +
+   + + +

+Work only in RotEuler mode(nlassert). +

+ +

+Implements NL3D::UTransformable. +

+Definition at line 154 of file transformable_user.h. +

+References NL3D::CTransformableUser::_Transformable, NL3D::ITransformable::getRotEuler(), and NL3D_MEM_TRANSFORMABLE. +

+

00155         {
+00156                 NL3D_MEM_TRANSFORMABLE
+00157                 _Transformable->getRotEuler(rot);
+00158         }
+
+

+ + + + +
+ + + + + + + + + +
virtual CVector NL3D::UTransformable::getRotEuler  )  [pure virtual, inherited]
+
+ + + + + +
+   + + +

+Work only in RotEuler mode(nlassert). +

+ +

+Implemented in NL3D::CTransformableUser.

+

+ + + + +
+ + + + + + + + + + +
virtual void NL3D::UTransformable::getRotEuler CVector rot  )  [pure virtual, inherited]
+
+ + + + + +
+   + + +

+Work only in RotEuler mode(nlassert). +

+ +

+Implemented in NL3D::CTransformableUser.

+

+ + + + +
+ + + + + + + + + +
const char * NL3D::UTransformable::getRotEulerValueName  )  [static, inherited]
+
+ + + + + +
+   + + +

+ +

+Definition at line 40 of file transformable_user.cpp. +

+References NL3D_MEM_TRANSFORMABLE. +

+

00041 {
+00042         NL3D_MEM_TRANSFORMABLE
+00043         return ITransformable::getRotEulerValueName();
+00044 }
+
+

+ + + + +
+ + + + + + + + + +
virtual CMatrix::TRotOrder NL3D::CTransformableUser::getRotOrder  )  [inline, virtual, inherited]
+
+ + + + + +
+   + + +

+get the current rotorder (information vlaid only when RotEuler mode). +

+ +

+Implements NL3D::UTransformable. +

+Definition at line 143 of file transformable_user.h. +

+References NL3D::CTransformableUser::_Transformable, NL3D::ITransformable::getRotOrder(), and NL3D_MEM_TRANSFORMABLE. +

+

00144         {
+00145                 NL3D_MEM_TRANSFORMABLE
+00146                 return _Transformable->getRotOrder();
+00147         }
+
+

+ + + + +
+ + + + + + + + + +
virtual CMatrix::TRotOrder NL3D::UTransformable::getRotOrder  )  [pure virtual, inherited]
+
+ + + + + +
+   + + +

+get the current rotorder (information vlaid only when RotEuler mode). +

+ +

+Implemented in NL3D::CTransformableUser.

+

+ + + + +
+ + + + + + + + + +
virtual CQuat NL3D::CTransformableUser::getRotQuat  )  [inline, virtual, inherited]
+
+ + + + + +
+   + + +

+Work only in RotQuat mode (nlassert). +

+ +

+Implements NL3D::UTransformable. +

+Definition at line 185 of file transformable_user.h. +

+References NL3D::CTransformableUser::_Transformable, NL3D::ITransformable::getRotQuat(), and NL3D_MEM_TRANSFORMABLE. +

+

00186         {
+00187                 NL3D_MEM_TRANSFORMABLE
+00188                 return _Transformable->getRotQuat();
+00189         }
+
+

+ + + + +
+ + + + + + + + + + +
virtual void NL3D::CTransformableUser::getRotQuat CQuat quat  )  [inline, virtual, inherited]
+
+ + + + + +
+   + + +

+Work only in RotQuat mode (nlassert). +

+ +

+Implements NL3D::UTransformable. +

+Definition at line 159 of file transformable_user.h. +

+References NL3D::CTransformableUser::_Transformable, NL3D::ITransformable::getRotQuat(), and NL3D_MEM_TRANSFORMABLE. +

+

00160         {
+00161                 NL3D_MEM_TRANSFORMABLE
+00162                 _Transformable->getRotQuat(quat);
+00163         }
+
+

+ + + + +
+ + + + + + + + + +
virtual CQuat NL3D::UTransformable::getRotQuat  )  [pure virtual, inherited]
+
+ + + + + +
+   + + +

+Work only in RotQuat mode (nlassert). +

+ +

+Implemented in NL3D::CTransformableUser.

+

+ + + + +
+ + + + + + + + + + +
virtual void NL3D::UTransformable::getRotQuat CQuat quat  )  [pure virtual, inherited]
+
+ + + + + +
+   + + +

+Work only in RotQuat mode (nlassert). +

+ +

+Implemented in NL3D::CTransformableUser.

+

+ + + + +
+ + + + + + + + + +
const char * NL3D::UTransformable::getRotQuatValueName  )  [static, inherited]
+
+ + + + + +
+   + + +

+ +

+Definition at line 45 of file transformable_user.cpp. +

+References NL3D_MEM_TRANSFORMABLE. +

+

00046 {
+00047         NL3D_MEM_TRANSFORMABLE
+00048         return ITransformable::getRotQuatValueName();
+00049 }
+
+

+ + + + +
+ + + + + + + + + +
virtual CVector NL3D::CTransformableUser::getScale  )  [inline, virtual, inherited]
+
+ + + + + +
+   + + +

+Work only in Rot* mode (nlassert). +

+ +

+Implements NL3D::UTransformable. +

+Definition at line 190 of file transformable_user.h. +

+References NL3D::CTransformableUser::_Transformable, NL3D::ITransformable::getScale(), and NL3D_MEM_TRANSFORMABLE. +

+

00191         {
+00192                 NL3D_MEM_TRANSFORMABLE
+00193                 return _Transformable->getScale();
+00194         }
+
+

+ + + + +
+ + + + + + + + + + +
virtual void NL3D::CTransformableUser::getScale CVector scale  )  [inline, virtual, inherited]
+
+ + + + + +
+   + + +

+Work only in Rot* mode (nlassert). +

+ +

+Implements NL3D::UTransformable. +

+Definition at line 164 of file transformable_user.h. +

+References NL3D::CTransformableUser::_Transformable, NL3D::ITransformable::getScale(), and NL3D_MEM_TRANSFORMABLE. +

+

00165         {
+00166                 NL3D_MEM_TRANSFORMABLE
+00167                 _Transformable->getScale(scale);
+00168         }
+
+

+ + + + +
+ + + + + + + + + +
virtual CVector NL3D::UTransformable::getScale  )  [pure virtual, inherited]
+
+ + + + + +
+   + + +

+Work only in Rot* mode (nlassert). +

+ +

+Implemented in NL3D::CTransformableUser.

+

+ + + + +
+ + + + + + + + + + +
virtual void NL3D::UTransformable::getScale CVector scale  )  [pure virtual, inherited]
+
+ + + + + +
+   + + +

+Work only in Rot* mode (nlassert). +

+ +

+Implemented in NL3D::CTransformableUser.

+

+ + + + +
+ + + + + + + + + +
const char * NL3D::UTransformable::getScaleValueName  )  [static, inherited]
+
+ + + + + +
+   + + +

+ +

+Definition at line 50 of file transformable_user.cpp. +

+References NL3D_MEM_TRANSFORMABLE. +

+

00051 {
+00052         NL3D_MEM_TRANSFORMABLE
+00053         return ITransformable::getScaleValueName();
+00054 }
+
+

+ + + + +
+ + + + + + + + + + +
CScene* NL3D::CTransformUser::getScene void   )  [inline, inherited]
+
+ + + + + +
+   + + +

+ +

+Definition at line 274 of file transform_user.h. +

+References NL3D_MEM_TRANSFORM. +

+Referenced by NL3D::CSceneUser::setCam(). +

+

00275         {
+00276                 NL3D_MEM_TRANSFORM
+00277                 return _Scene;
+00278         }
+
+

+ + + + +
+ + + + + + + + + +
float NL3D::CSkeletonUser::getShapeDistMax  )  const [virtual]
+
+ + + + + +
+   + + +

+see setShapeDistMax() +

+ +

+Implements NL3D::USkeleton. +

+Definition at line 82 of file skeleton_user.cpp. +

+References _Skeleton, NL3D_HAUTO_UI_SKELETON, NL3D_MEM_SKELETON, and NL3D::CTransformShape::Shape. +

+

00083 {
+00084         NL3D_MEM_SKELETON
+00085         NL3D_HAUTO_UI_SKELETON;
+00086 
+00087         if(_Skeleton && _Skeleton->Shape)
+00088         {
+00089                 return _Skeleton->Shape->getDistMax();
+00090         }
+00091         else
+00092                 return -1;
+00093 }
+
+

+ + + + +
+ + + + + + + + + +
CSkeletonModel* NL3D::CSkeletonUser::getSkeleton  )  [inline]
+
+ + + + + +
+   + + +

+ +

+Definition at line 152 of file skeleton_user.h. +

+References _Skeleton, and NL3D_MEM_SKELETON. +

+

00153         {
+00154                 NL3D_MEM_SKELETON
+00155                 return _Skeleton;
+00156         }
+
+

+ + + + +
+ + + + + + + + + +
CTransform* NL3D::CTransformUser::getTransform  )  [inline, inherited]
+
+ + + + + +
+   + + +

+ +

+Definition at line 279 of file transform_user.h. +

+References NL3D::CTransformUser::_Transform, and NL3D_MEM_TRANSFORM. +

+Referenced by NL3D::CPlayListUser::registerTransform(). +

+

00280         {
+00281                 NL3D_MEM_TRANSFORM
+00282                 return _Transform;
+00283         }
+
+

+ + + + +
+ + + + + + + + + +
virtual TTransformMode NL3D::CTransformableUser::getTransformMode  )  [inline, virtual, inherited]
+
+ + + + + +
+   + + +

+get the current transform mode. +

+ +

+Implements NL3D::UTransformable. +

+Definition at line 138 of file transformable_user.h. +

+References NL3D::CTransformableUser::_Transformable, NL3D::ITransformable::getTransformMode(), NL3D_MEM_TRANSFORMABLE, and uint. +

+

00139         {
+00140                 NL3D_MEM_TRANSFORMABLE
+00141                 return (TTransformMode)(uint)_Transformable->getTransformMode();
+00142         }
+
+

+ + + + +
+ + + + + + + + + +
virtual TTransformMode NL3D::UTransformable::getTransformMode  )  [pure virtual, inherited]
+
+ + + + + +
+   + + +

+get the current transform mode. +

+ +

+Implemented in NL3D::CTransformableUser.

+

+ + + + +
+ + + + + + + + + +
virtual bool NL3D::CTransformUser::getUserClipping  )  const [inline, virtual, inherited]
+
+ + + + + +
+   + + +

+Return the user clipping state. +

+ +

+Implements NL3D::UTransform. +

+Definition at line 132 of file transform_user.h. +

+References NL3D::CTransformUser::_Transform, NL3D::CTransform::getUserClipping(), NL3D_MEM_TRANSFORM, and nlassert. +

+

00133         {
+00134                 NL3D_MEM_TRANSFORM
+00135                 nlassert(_Transform) ; // object invalid now ...
+00136                 return _Transform->getUserClipping();
+00137         }
+
+

+ + + + +
+ + + + + + + + + +
virtual bool NL3D::UTransform::getUserClipping  )  const [pure virtual, inherited]
+
+ + + + + +
+   + + +

+Return the user clipping state. +

+ +

+Implemented in NL3D::CTransformUser.

+

+ + + + +
+ + + + + + + + + +
virtual bool NL3D::CTransformUser::getUserLightable  )  const [inline, virtual, inherited]
+
+ + + + + +
+   + + +

+Get the UserLightable flag. +

+Implements NL3D::UTransform. +

+Definition at line 183 of file transform_user.h. +

+References NL3D::CTransformUser::_Transform, NL3D::CTransform::getUserLightable(), and NL3D_MEM_TRANSFORM. +

+

00184         {
+00185                 NL3D_MEM_TRANSFORM
+00186                 return  _Transform->getUserLightable();
+00187         }
+
+

+ + + + +
+ + + + + + + + + +
virtual bool NL3D::UTransform::getUserLightable  )  const [pure virtual, inherited]
+
+ + + + + +
+   + + +

+Get the UserLightable flag. +

+Implemented in NL3D::CTransformUser.

+

+ + + + +
+ + + + + + + + + +
virtual TVisibility NL3D::CTransformUser::getVisibility  )  [inline, virtual, inherited]
+
+ + + + + +
+   + + +

+Get the local visibility state. +

+ +

+Implements NL3D::UTransform. +

+Definition at line 146 of file transform_user.h. +

+References NL3D::CTransformUser::_Transform, NL3D::CTransform::getVisibility(), NL3D_MEM_TRANSFORM, nlassert, and uint32. +

+

00147         {
+00148                 NL3D_MEM_TRANSFORM
+00149                 nlassert(_Transform) ; // object invalid now ...
+00150                 return (UTransform::TVisibility)(uint32)_Transform->getVisibility();
+00151         }
+
+

+ + + + +
+ + + + + + + + + +
virtual TVisibility NL3D::UTransform::getVisibility  )  [pure virtual, inherited]
+
+ + + + + +
+   + + +

+Get the local visibility state. +

+ +

+Implemented in NL3D::CTransformUser.

+

+ + + + +
+ + + + + + + + + +
virtual void NL3D::CTransformUser::heritVisibility  )  [inline, virtual, inherited]
+
+ + + + + +
+   + + +

+herit the visibility from his father. (default behavior). +

+ +

+Implements NL3D::UTransform. +

+Definition at line 139 of file transform_user.h. +

+References NL3D::CTransformUser::_Transform, NL3D::CTransform::heritVisibility(), NL3D_MEM_TRANSFORM, and nlassert. +

+

00140         {
+00141                 NL3D_MEM_TRANSFORM
+00142                 nlassert(_Transform) ; // object invalid now ...
+00143                 _Transform->heritVisibility();
+00144         }
+
+

+ + + + +
+ + + + + + + + + +
virtual void NL3D::UTransform::heritVisibility  )  [pure virtual, inherited]
+
+ + + + + +
+   + + +

+herit the visibility from his father. (default behavior). +

+ +

+Implemented in NL3D::CTransformUser.

+

+ + + + +
+ + + + + + + + + +
virtual void NL3D::CTransformUser::hide  )  [inline, virtual, inherited]
+
+ + + + + +
+   + + +

+Hide the object and his sons. +

+ +

+Implements NL3D::UTransform. +

+Definition at line 113 of file transform_user.h. +

+References NL3D::CTransformUser::_Transform, NL3D::CTransform::hide(), NL3D_MEM_TRANSFORM, and nlassert. +

+

00114         {
+00115                 NL3D_MEM_TRANSFORM
+00116                 nlassert(_Transform) ; // object invalid now ...
+00117                 _Transform->hide();
+00118         }
+
+

+ + + + +
+ + + + + + + + + +
virtual void NL3D::UTransform::hide  )  [pure virtual, inherited]
+
+ + + + + +
+   + + +

+Hide the object and his sons. +

+ +

+Implemented in NL3D::CTransformUser.

+

+ + + + +
+ + + + + + + + + + +
bool NL3D::CSkeletonUser::isBoneComputed uint  boneId  )  const [virtual]
+
+ + + + + +
+   + + +

+Tell if a bone has been computed in the last frame or not. false if boneId is invalid. +

+ +

+Implements NL3D::USkeleton. +

+Definition at line 178 of file skeleton_user.cpp. +

+References _Skeleton, NL3D::CSkeletonModel::isBoneComputed(), NL3D_HAUTO_UI_SKELETON, NL3D_MEM_SKELETON, and uint. +

+

00179 {
+00180         NL3D_MEM_SKELETON
+00181         NL3D_HAUTO_UI_SKELETON;
+00182 
+00183         return _Skeleton->isBoneComputed(boneId);
+00184 }
+
+

+ + + + +
+ + + + + + + + + +
bool NL3D::CSkeletonUser::isDisplayedAsLodCharacter  )  const [virtual]
+
+ + + + + +
+   + + +

+True if the skeleton model and his skins have been displayed with a CLodCharacterShape at last scene render +

+Implements NL3D::USkeleton. +

+Definition at line 232 of file skeleton_user.cpp. +

+References _Skeleton, NL3D::CSkeletonModel::isDisplayedAsLodCharacter(), NL3D_HAUTO_UI_SKELETON, and NL3D_MEM_SKELETON. +

+

00233 {
+00234         NL3D_MEM_SKELETON
+00235         NL3D_HAUTO_UI_SKELETON;
+00236         return _Skeleton->isDisplayedAsLodCharacter();
+00237 }
+
+

+ + + + +
+ + + + + + + + + +
virtual uint32 NL3D::CTransformUser::isOpaque  )  [inline, virtual, inherited]
+
+ + + + + +
+   + + +

+ +

+Implements NL3D::UTransform. +

+Definition at line 239 of file transform_user.h. +

+References NL3D::CTransformUser::_Transform, NL3D::CTransform::isOpaque(), NL3D_MEM_TRANSFORM, and uint32. +

+

00240         {
+00241                 NL3D_MEM_TRANSFORM
+00242                 return _Transform->isOpaque();
+00243         }
+
+

+ + + + +
+ + + + + + + + + +
virtual uint32 NL3D::UTransform::isOpaque  )  [pure virtual, inherited]
+
+ + + + + +
+   + + +

+ +

+Implemented in NL3D::CTransformUser.

+

+ + + + +
+ + + + + + + + + +
virtual uint32 NL3D::CTransformUser::isTransparent  )  [inline, virtual, inherited]
+
+ + + + + +
+   + + +

+ +

+Implements NL3D::UTransform. +

+Definition at line 244 of file transform_user.h. +

+References NL3D::CTransformUser::_Transform, NL3D::CTransform::isTransparent(), NL3D_MEM_TRANSFORM, and uint32. +

+

00245         {
+00246                 NL3D_MEM_TRANSFORM
+00247                 return _Transform->isTransparent();
+00248         }
+
+

+ + + + +
+ + + + + + + + + +
virtual uint32 NL3D::UTransform::isTransparent  )  [pure virtual, inherited]
+
+ + + + + +
+   + + +

+ +

+Implemented in NL3D::CTransformUser.

+

+ + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + + +
virtual void NL3D::CTransformableUser::lookAt const CVector eye,
const CVector target,
float  roll = 0.f
[inline, virtual, inherited]
+
+ + + + + +
+   + + +

+Setup Matrix by the lookAt method. Work only in DirectMatrix mode and RotQuat mode (not euler...).

+

Parameters:
+ + + + +
eye is the coordinate of the object.
target is the point the object look at.
roll is the roll angle in radian along the object's Y axis.
+
+ +

+Implements NL3D::UTransformable. +

+Definition at line 206 of file transformable_user.h. +

+References NL3D::CTransformableUser::_Transformable, NL3D::ITransformable::lookAt(), and NL3D_MEM_TRANSFORMABLE. +

+

00207         {
+00208                 NL3D_MEM_TRANSFORMABLE
+00209                 _Transformable->lookAt(eye, target, roll);
+00210         }
+
+

+ + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + + +
virtual void NL3D::UTransformable::lookAt const CVector eye,
const CVector target,
float  roll = 0.f
[pure virtual, inherited]
+
+ + + + + +
+   + + +

+Setup Matrix by the lookAt method. Work only in DirectMatrix mode and RotQuat mode (not euler...).

+

Parameters:
+ + + + +
eye is the coordinate of the object.
target is the point the object look at.
roll is the roll angle in radian along the object's Y axis.
+
+ +

+Implemented in NL3D::CTransformableUser.

+

+ + + + +
+ + + + + + + + + + +
virtual void NL3D::CTransformUser::parent UTransform newFather  )  [virtual, inherited]
+
+ + + + + +
+   + + +

+unlink this from oldparent, and make this be a son of newFather. +

+ +

+Implements NL3D::UTransform.

+

+ + + + +
+ + + + + + + + + + +
virtual void NL3D::UTransform::parent UTransform newFather  )  [pure virtual, inherited]
+
+ + + + + +
+   + + +

+Hierarchy edit. unlink this from oldparent, and make this be a son of newFather. if this was already a son of newFather, no-op.

Parameters:
+ + +
newFather the new Father. If NULL, the transform will be linked to the root of the hierarchy (Default!).
+
+ +

+Implemented in NL3D::CTransformUser.

+

+ + + + +
+ + + + + + + + + + + + + + + + + + + +
void NL3D::CSkeletonUser::setBoneAnimCtrl uint  boneId,
IAnimCtrl ctrl
[virtual]
+
+ + + + + +
+   + + +

+Set a special ctrl on a bone. see IAnimCtrl. set to NULL if you want to reset this bone AnimCtrl. No-op if Bad BoneId. +

+Implements NL3D::USkeleton. +

+Definition at line 304 of file skeleton_user.cpp. +

+References _Skeleton, NL3D_HAUTO_UI_SKELETON, NL3D_MEM_SKELETON, NL3D::CSkeletonModel::setBoneAnimCtrl(), and uint. +

+

00305 {
+00306         NL3D_MEM_SKELETON
+00307         NL3D_HAUTO_UI_SKELETON;
+00308 
+00309         _Skeleton->setBoneAnimCtrl(boneId, ctrl);
+00310 }
+
+

+ + + + +
+ + + + + + + + + + +
virtual void NL3D::CTransformUser::setClusterSystem UInstanceGroup pIG  )  [virtual, inherited]
+
+ + + + + +
+   + + +

+ +

+Implements NL3D::UTransform.

+

+ + + + +
+ + + + + + + + + + +
virtual void NL3D::UTransform::setClusterSystem UInstanceGroup pIG  )  [pure virtual, inherited]
+
+ + + + + +
+   + + +

+ +

+Implemented in NL3D::CTransformUser.

+

+ + + + +
+ + + + + + + + + + +
virtual void NL3D::CTransformUser::setForceClipRoot bool  forceClipRoot  )  [inline, virtual, inherited]
+
+ + + + + +
+   + + +

+Force the transform to always be attached to the root As a consequence, it can't be inserted into a cluster system (even the root cluster) and is thus always visible when in the frustum (not clusterized) NB : any call to setClusterSystem will be ignored (must remain unclesterized) NB : any call to parent will be ignored (must remain linked to the root) +

+Implements NL3D::UTransform. +

+Definition at line 259 of file transform_user.h. +

+References NL3D::CTransformUser::_Transform, NL3D_MEM_TRANSFORM, and NL3D::CTransform::setForceClipRoot(). +

+

00260         {
+00261                 NL3D_MEM_TRANSFORM
+00262                 _Transform->setForceClipRoot(forceClipRoot);
+00263         }
+
+

+ + + + +
+ + + + + + + + + + +
virtual void NL3D::UTransform::setForceClipRoot bool  forceClipRoot  )  [pure virtual, inherited]
+
+ + + + + +
+   + + +

+Force the transform to always be attached to the root As a consequence, it can't be inserted into a cluster system (even the root cluster) and is thus always visible when in the frustum (not clusterized) NB : any call to setClusterSystem will be ignored (must remain unclesterized) NB : any call to parent will be ignored (must remain linked to the root) +

+Implemented in NL3D::CTransformUser.

+

+ + + + +
+ + + + + + + + + + +
void NL3D::CSkeletonUser::setInterpolationDistance float  dist  )  [virtual]
+
+ + + + + +
+   + + +

+change the Lod Bone interpolation distance (in meters). If 0, interpolation is disabled. The smaller this value is, the more Lod skeleton system will "pop". Default is 0.5 meters. +

+Implements NL3D::USkeleton. +

+Definition at line 51 of file skeleton_user.cpp. +

+References _Skeleton, NL3D_HAUTO_UI_SKELETON, NL3D_MEM_SKELETON, and NL3D::CSkeletonModel::setInterpolationDistance(). +

+

00052 {
+00053         NL3D_MEM_SKELETON
+00054         NL3D_HAUTO_UI_SKELETON;
+00055 
+00056         _Skeleton->setInterpolationDistance(dist);
+00057 }
+
+

+ + + + +
+ + + + + + + + + + +
virtual void NL3D::CTransformUser::setLoadBalancingGroup const std::string &  group  )  [virtual, inherited]
+
+ + + + + +
+   + + +

+Change the load Balancing group of a model. Every models are in a special LoadBalancingGroup. NB: the group is created if did not exist. NB: if models are skinned, it is their Skeleton which drive the group

+By default, models lies in the "Default" group, but Skeletons for skinning and ParticlesSystems which are in "Skin" and "Fx" group respectively. The "Default" group is special because it is not balanced (ie models are only degraded from their distance to camera) +

+Implements NL3D::UTransform.

+

+ + + + +
+ + + + + + + + + + +
virtual void NL3D::UTransform::setLoadBalancingGroup const std::string &  group  )  [pure virtual, inherited]
+
+ + + + + +
+   + + +

+Change the load Balancing group of a model. Every models are in a special LoadBalancingGroup. NB: the group is created if did not exist. NB: if models are skinned, it is their Skeleton which drive the group

+By default, models lies in the "Default" group, but Skeletons for skinning and ParticlesSystems which are in "Skin" and "Fx" group respectively. The "Default" group is special because it is not balanced (ie models are only degraded from their distance to camera) +

+Implemented in NL3D::CTransformUser.

+

+ + + + +
+ + + + + + + + + + +
void NL3D::CSkeletonUser::setLodCharacterAnimId uint  animId  )  [virtual]
+
+ + + + + +
+   + + +

+Change/get the Character Lod anim setup. +

+ +

+Implements NL3D::USkeleton. +

+Definition at line 208 of file skeleton_user.cpp. +

+References _Skeleton, NL3D_HAUTO_UI_SKELETON, NL3D_MEM_SKELETON, NL3D::CSkeletonModel::setLodCharacterAnimId(), and uint. +

+

00209 {
+00210         NL3D_MEM_SKELETON
+00211         NL3D_HAUTO_UI_SKELETON;
+00212         _Skeleton->setLodCharacterAnimId(animId);
+00213 }
+
+

+ + + + +
+ + + + + + + + + + +
void NL3D::CSkeletonUser::setLodCharacterAnimTime TGlobalAnimationTime  time  )  [virtual]
+
+ + + + + +
+   + + +

+Call it when you want the system to recompute the Lod texture NB: Lod texturing is possible only in conjunction with AsyncTextureManager. Hence, instances skinned to the skeleton should be in AsyncTextureMode. For best result, you should wait that each of these instances are isAsyncTextureReady() (texture loaded) +

+Implements NL3D::USkeleton. +

+Definition at line 220 of file skeleton_user.cpp. +

+References _Skeleton, NL3D_HAUTO_UI_SKELETON, NL3D_MEM_SKELETON, NL3D::CSkeletonModel::setLodCharacterAnimTime(), and NL3D::TGlobalAnimationTime. +

+

00221 {
+00222         NL3D_MEM_SKELETON
+00223         NL3D_HAUTO_UI_SKELETON;
+00224         _Skeleton->setLodCharacterAnimTime(time);
+00225 }
+
+

+ + + + +
+ + + + + + + + + + +
void NL3D::CSkeletonUser::setLodCharacterDistance float  dist  )  [virtual]
+
+ + + + + +
+   + + +

+This is the distance at which the skeleton use a CLodCharacterShape to display himself if 0, never display the skeleton as a CLodCharacterShape +

+Implements NL3D::USkeleton. +

+Definition at line 238 of file skeleton_user.cpp. +

+References _Skeleton, NL3D_HAUTO_UI_SKELETON, NL3D_MEM_SKELETON, and NL3D::CSkeletonModel::setLodCharacterDistance(). +

+

00239 {
+00240         NL3D_MEM_SKELETON
+00241         NL3D_HAUTO_UI_SKELETON;
+00242         _Skeleton->setLodCharacterDistance(dist);
+00243 }
+
+

+ + + + +
+ + + + + + + + + + +
void NL3D::CSkeletonUser::setLodCharacterShape sint  shapeId  )  [virtual]
+
+ + + + + +
+   + + +

+Change the Character Lod shape Id. set -1 if want to disable the feature (default) +

+Implements NL3D::USkeleton. +

+Definition at line 196 of file skeleton_user.cpp. +

+References _Skeleton, NL3D_HAUTO_UI_SKELETON, NL3D_MEM_SKELETON, NL3D::CSkeletonModel::setLodCharacterShape(), and sint. +

+

00197 {
+00198         NL3D_MEM_SKELETON
+00199         NL3D_HAUTO_UI_SKELETON;
+00200         _Skeleton->setLodCharacterShape(shapeId);
+00201 }
+
+

+ + + + +
+ + + + + + + + + + +
void NL3D::CSkeletonUser::setLodCharacterWrapMode bool  wrapMode  )  [virtual]
+
+ + + + + +
+   + + +

+tells if the animation must loop or clamp. +

+ +

+Implements NL3D::USkeleton. +

+Definition at line 250 of file skeleton_user.cpp. +

+References _Skeleton, NL3D_HAUTO_UI_SKELETON, NL3D_MEM_SKELETON, and NL3D::CSkeletonModel::setLodCharacterWrapMode(). +

+

00251 {
+00252         NL3D_MEM_SKELETON
+00253         NL3D_HAUTO_UI_SKELETON;
+00254         _Skeleton->setLodCharacterWrapMode(wrapMode);
+00255 }
+
+

+ + + + +
+ + + + + + + + + + +
virtual void NL3D::CTransformUser::setLogicInfo ILogicInfo logicInfo  )  [inline, virtual, inherited]
+
+ + + + + +
+   + + +

+Set the LogicInfo for this transfrom, eg to retrieve statc light information, see ILogicInfo. Ptr is kept in UTransfrom, so should call setLogicInfo(NULL) before to clean up. +

+Implements NL3D::UTransform. +

+Definition at line 191 of file transform_user.h. +

+References NL3D::CTransformUser::_Transform, NL3D_MEM_TRANSFORM, and NL3D::CTransform::setLogicInfo(). +

+

00192         {
+00193                 NL3D_MEM_TRANSFORM
+00194                 _Transform->setLogicInfo(logicInfo);
+00195         }
+
+

+ + + + +
+ + + + + + + + + + +
virtual void NL3D::UTransform::setLogicInfo ILogicInfo logicInfo  )  [pure virtual, inherited]
+
+ + + + + +
+   + + +

+Set the LogicInfo for this transfrom, eg to retrieve statc light information, see ILogicInfo. Ptr is kept in UTransfrom, so should call setLogicInfo(NULL) before to clean up. +

+Implemented in NL3D::CTransformUser.

+

+ + + + +
+ + + + + + + + + + +
virtual void NL3D::CTransformableUser::setMatrix const CMatrix mat  )  [inline, virtual, inherited]
+
+ + + + + +
+   + + +

+Work only in DirecTMatrix mode (nlassert). +

+ +

+Implements NL3D::UTransformable. +

+Definition at line 76 of file transformable_user.h. +

+References NL3D::CTransformableUser::_Transformable, NL3D_MEM_TRANSFORMABLE, and NL3D::ITransformable::setMatrix(). +

+

00077         {
+00078                 NL3D_MEM_TRANSFORMABLE
+00079                 _Transformable->setMatrix(mat);
+00080         }
+
+

+ + + + +
+ + + + + + + + + + +
virtual void NL3D::UTransformable::setMatrix const CMatrix mat  )  [pure virtual, inherited]
+
+ + + + + +
+   + + +

+Work only in DirecTMatrix mode (nlassert). +

+ +

+Implemented in NL3D::CTransformableUser.

+

+ + + + +
+ + + + + + + + + + +
virtual void NL3D::CTransformUser::setMeanColor NLMISC::CRGBA  color  )  [virtual, inherited]
+
+ + + + + +
+   + + +

+set the Mean color of the transform. The mean color can be used for many purpose, such as drawing objects if the textures are not loaded. It is used also for Lod Character. Default color is (255,255,255) +

+Implements NL3D::UTransform.

+

+ + + + +
+ + + + + + + + + + +
virtual void NL3D::UTransform::setMeanColor NLMISC::CRGBA  color  )  [pure virtual, inherited]
+
+ + + + + +
+   + + +

+set the Mean color of the transform. The mean color can be used for many purpose, such as drawing objects if the textures are not loaded. It is used also for Lod Character. Default color is (255,255,255) +

+Implemented in NL3D::CTransformUser.

+

+ + + + +
+ + + + + + + + + + +
virtual void NL3D::CTransformUser::setOpacity bool  v  )  [inline, virtual, inherited]
+
+ + + + + +
+   + + +

+ +

+Implements NL3D::UTransform. +

+Definition at line 234 of file transform_user.h. +

+References NL3D::CTransformUser::_Transform, NL3D_MEM_TRANSFORM, NL3D::CTransform::setOpacity(), and v. +

+

00235         {
+00236                 NL3D_MEM_TRANSFORM
+00237                 _Transform->setOpacity(true);
+00238         }
+
+

+ + + + +
+ + + + + + + + + + +
virtual void NL3D::UTransform::setOpacity bool  v  )  [pure virtual, inherited]
+
+ + + + + +
+   + + +

+ +

+Implemented in NL3D::CTransformUser.

+

+ + + + +
+ + + + + + + + + + +
virtual void NL3D::CTransformUser::setOrderingLayer uint  layer  )  [inline, virtual, inherited]
+
+ + + + + +
+   + + +

+Set the current ordering layer for this transform. Typically, this is used to sort transparent objects. Isn't used with solid objects. For now : Layer 0 is for underwater Layer 1 is for water surfaces Layer 2 is for object above water +

+Implements NL3D::UTransform. +

+Definition at line 162 of file transform_user.h. +

+References NL3D::CTransformUser::_Transform, NL3D_MEM_TRANSFORM, NL3D::CTransform::setOrderingLayer(), and uint. +

+

00163         { 
+00164                 NL3D_MEM_TRANSFORM
+00165                 _Transform->setOrderingLayer(layer); 
+00166         }
+
+

+ + + + +
+ + + + + + + + + + +
virtual void NL3D::UTransform::setOrderingLayer uint  layer  )  [pure virtual, inherited]
+
+ + + + + +
+   + + +

+Set the current ordering layer for this transform. Typically, this is used to sort transparent objects. Isn't used with solid objects. For now : Layer 0 is for underwater Layer 1 is for water surfaces Layer 2 is for object above water +

+Implemented in NL3D::CTransformUser.

+

+ + + + +
+ + + + + + + + + + +
virtual void NL3D::CTransformableUser::setPivot const CVector pivot  )  [inline, virtual, inherited]
+
+ + + + + +
+   + + +

+Work only in Rot* mode (nlassert). +

+ +

+Implements NL3D::UTransformable. +

+Definition at line 132 of file transformable_user.h. +

+References NL3D::CTransformableUser::_Transformable, NL3D_MEM_TRANSFORMABLE, and NL3D::ITransformable::setPivot(). +

+

00133         {
+00134                 NL3D_MEM_TRANSFORMABLE
+00135                 _Transformable->setPivot(pivot);
+00136         }
+
+

+ + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + + +
void NL3D::UTransformable::setPivot float  px,
float  py,
float  pz
[inline, inherited]
+
+ + + + + +
+   + + +

+Work only in Rot* mode (nlassert). +

+ +

+Definition at line 108 of file u_transformable.h. +

+References NL3D::UTransformable::setPivot(). +

+

00108 {setPivot(CVector(px, py, pz));}
+
+

+ + + + +
+ + + + + + + + + + +
virtual void NL3D::UTransformable::setPivot const CVector pivot  )  [pure virtual, inherited]
+
+ + + + + +
+   + + +

+Work only in Rot* mode (nlassert). +

+ +

+Implemented in NL3D::CTransformableUser. +

+Referenced by NL3D::UTransformable::setPivot().

+

+ + + + +
+ + + + + + + + + + +
virtual void NL3D::CTransformableUser::setPos const CVector pos  )  [inline, virtual, inherited]
+
+ + + + + +
+   + + +

+Work only in Rot* mode(nlassert). +

+ +

+Implements NL3D::UTransformable. +

+Definition at line 97 of file transformable_user.h. +

+References NL3D::CTransformableUser::_Transformable, NL3D_MEM_TRANSFORMABLE, and NL3D::ITransformable::setPos(). +

+

00098         {
+00099                 NL3D_MEM_TRANSFORMABLE
+00100                 _Transformable->setPos(pos);
+00101         }
+
+

+ + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + + +
void NL3D::UTransformable::setPos float  px,
float  py,
float  pz
[inline, inherited]
+
+ + + + + +
+   + + +

+Work only in Rot* mode(nlassert). +

+ +

+Definition at line 86 of file u_transformable.h. +

+References NL3D::UTransformable::setPos(). +

+

00086 {setPos(CVector(px, py, pz));}
+
+

+ + + + +
+ + + + + + + + + + +
virtual void NL3D::UTransformable::setPos const CVector pos  )  [pure virtual, inherited]
+
+ + + + + +
+   + + +

+Work only in Rot* mode(nlassert). +

+ +

+Implemented in NL3D::CTransformableUser. +

+Referenced by NL3D::UTransformable::setPos().

+

+ + + + +
+ + + + + + + + + + +
virtual void NL3D::CTransformableUser::setRotEuler const CVector rot  )  [inline, virtual, inherited]
+
+ + + + + +
+   + + +

+Work only in RotEuler mode(nlassert). +

+ +

+Implements NL3D::UTransformable. +

+Definition at line 102 of file transformable_user.h. +

+References NL3D::CTransformableUser::_Transformable, NL3D_MEM_TRANSFORMABLE, and NL3D::ITransformable::setRotEuler(). +

+

00103         {
+00104                 NL3D_MEM_TRANSFORMABLE
+00105                 _Transformable->setRotEuler(rot);
+00106         }
+
+

+ + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + + +
void NL3D::UTransformable::setRotEuler float  rx,
float  ry,
float  rz
[inline, inherited]
+
+ + + + + +
+   + + +

+Work only in RotEuler mode(nlassert). +

+ +

+Definition at line 90 of file u_transformable.h. +

+References NL3D::UTransformable::setRotEuler(). +

+

00090 {setRotEuler(CVector(rx, ry, rz));}
+
+

+ + + + +
+ + + + + + + + + + +
virtual void NL3D::UTransformable::setRotEuler const CVector rot  )  [pure virtual, inherited]
+
+ + + + + +
+   + + +

+Work only in RotEuler mode(nlassert). +

+ +

+Implemented in NL3D::CTransformableUser. +

+Referenced by NL3D::UTransformable::setRotEuler().

+

+ + + + +
+ + + + + + + + + + + + + + + + + + + +
virtual void NL3D::CTransformableUser::setRotQuat const CVector jdir,
const CVector vup
[inline, virtual, inherited]
+
+ + + + + +
+   + + +

+Work only in RotQuat mode (nlassert). Build a quaternion from a forward direction (a J vector). the roll is determined with help of the vector up vup... vectors do not need to be noramlized. +

+Implements NL3D::UTransformable. +

+Definition at line 120 of file transformable_user.h. +

+References NL3D_MEM_TRANSFORMABLE, and NL3D::CTransformableUser::setRotQuat(). +

+

00121         {
+00122                 NL3D_MEM_TRANSFORMABLE
+00123                 CMatrix mat;
+00124                 mat.setRot(CVector::I, jdir, vup);
+00125                 mat.normalize(CMatrix::YZX);
+00126                 setRotQuat(mat.getRot());
+00127         }
+
+

+ + + + +
+ + + + + + + + + + +
virtual void NL3D::CTransformableUser::setRotQuat const CVector jdir  )  [inline, virtual, inherited]
+
+ + + + + +
+   + + +

+Work only in RotQuat mode (nlassert). Build a quaternion from a forward direction (a J vector). there is no roll... jdir do not need to be noramlized. +

+Implements NL3D::UTransformable. +

+Definition at line 112 of file transformable_user.h. +

+References NL3D_MEM_TRANSFORMABLE, and NL3D::CTransformableUser::setRotQuat(). +

+

00113         {
+00114                 NL3D_MEM_TRANSFORMABLE
+00115                 CMatrix mat;
+00116                 mat.setRot(CVector::I, jdir, CVector::K);
+00117                 mat.normalize(CMatrix::YZX);
+00118                 setRotQuat(mat.getRot());
+00119         }
+
+

+ + + + +
+ + + + + + + + + + +
virtual void NL3D::CTransformableUser::setRotQuat const CQuat quat  )  [inline, virtual, inherited]
+
+ + + + + +
+   + + +

+Work only in RotQuat mode (nlassert). +

+ +

+Implements NL3D::UTransformable. +

+Definition at line 107 of file transformable_user.h. +

+References NL3D::CTransformableUser::_Transformable, NL3D_MEM_TRANSFORMABLE, and NL3D::ITransformable::setRotQuat(). +

+Referenced by NL3D::CTransformableUser::setRotQuat(). +

+

00108         {
+00109                 NL3D_MEM_TRANSFORMABLE
+00110                 _Transformable->setRotQuat(quat);
+00111         }
+
+

+ + + + +
+ + + + + + + + + + + + + + + + + + + +
virtual void NL3D::UTransformable::setRotQuat const CVector jdir,
const CVector vup
[pure virtual, inherited]
+
+ + + + + +
+   + + +

+Work only in RotQuat mode (nlassert). Build a quaternion from a forward direction (a J vector). the roll is determined with help of the vector up vup... vectors do not need to be noramlized. +

+Implemented in NL3D::CTransformableUser.

+

+ + + + +
+ + + + + + + + + + +
virtual void NL3D::UTransformable::setRotQuat const CVector jdir  )  [pure virtual, inherited]
+
+ + + + + +
+   + + +

+Work only in RotQuat mode (nlassert). Build a quaternion from a forward direction (a J vector). there is no roll... jdir do not need to be noramlized. +

+Implemented in NL3D::CTransformableUser.

+

+ + + + +
+ + + + + + + + + + +
virtual void NL3D::UTransformable::setRotQuat const CQuat quat  )  [pure virtual, inherited]
+
+ + + + + +
+   + + +

+Work only in RotQuat mode (nlassert). +

+ +

+Implemented in NL3D::CTransformableUser.

+

+ + + + +
+ + + + + + + + + + +
virtual void NL3D::CTransformableUser::setScale const CVector scale  )  [inline, virtual, inherited]
+
+ + + + + +
+   + + +

+Work only in Rot* mode (nlassert). +

+ +

+Implements NL3D::UTransformable. +

+Definition at line 128 of file transformable_user.h. +

+References NL3D::CTransformableUser::_Transformable, and NL3D::ITransformable::setScale(). +

+

00129         {
+00130                 _Transformable->setScale(scale);
+00131         }
+
+

+ + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + + +
void NL3D::UTransformable::setScale float  sx,
float  sy,
float  sz
[inline, inherited]
+
+ + + + + +
+   + + +

+Work only in Rot* mode (nlassert). +

+ +

+Definition at line 104 of file u_transformable.h. +

+References NL3D::UTransformable::setScale(). +

+

00104 {setScale(CVector(sx, sy, sz));}
+
+

+ + + + +
+ + + + + + + + + + +
virtual void NL3D::UTransformable::setScale const CVector scale  )  [pure virtual, inherited]
+
+ + + + + +
+   + + +

+Work only in Rot* mode (nlassert). +

+ +

+Implemented in NL3D::CTransformableUser. +

+Referenced by NL3D::UTransformable::setScale().

+

+ + + + +
+ + + + + + + + + + +
void NL3D::CSkeletonUser::setShapeDistMax float  distMax  )  [virtual]
+
+ + + + + +
+   + + +

+Change Max Display Skeleton distance. After this distance the shape won't be displayed. setting <0 means -1 and so means DistMax = infinite (default in meshs but multilod meshes). NB: This apply to the shape direclty!! ie All instances using same shape will be affected

+Note: If the skeleton himself is sticked to an other skeleton, this setup is not taken into account. ie the skeleton clip follow the ancestor skeleton clip result (ie the first skeleton in hierarchy which is not sticked).

+Note (complex): same remark for QuadGridClipManager interaction with this function as in UInstance::setShapeDistMax() +

+Implements NL3D::USkeleton. +

+Definition at line 70 of file skeleton_user.cpp. +

+References _Skeleton, NL3D_HAUTO_UI_SKELETON, NL3D_MEM_SKELETON, and NL3D::CTransformShape::Shape. +

+

00071 {
+00072         NL3D_MEM_SKELETON
+00073         NL3D_HAUTO_UI_SKELETON;
+00074 
+00075         if(_Skeleton && _Skeleton->Shape)
+00076         {
+00077                 _Skeleton->Shape->setDistMax(distMax);
+00078         }
+00079 }
+
+

+ + + + +
+ + + + + + + + + + + + + + + + + + + +
virtual void NL3D::CTransformableUser::setTransformMode TTransformMode  mode,
CMatrix::TRotOrder  ro = CMatrix::ZXY
[inline, virtual, inherited]
+
+ + + + + +
+   + + +

+Change the transform mode. Components or matrix are not reseted. +

+ +

+Implements NL3D::UTransformable. +

+Definition at line 92 of file transformable_user.h. +

+References NL3D::CTransformableUser::_Transformable, NL3D_MEM_TRANSFORMABLE, NL3D::ITransformable::setTransformMode(), and uint. +

+

00093         {
+00094                 NL3D_MEM_TRANSFORMABLE
+00095                 _Transformable->setTransformMode((ITransformable::TTransformMode)(uint)mode, ro);
+00096         }
+
+

+ + + + +
+ + + + + + + + + + + + + + + + + + + +
virtual void NL3D::UTransformable::setTransformMode TTransformMode  mode,
CMatrix::TRotOrder  ro = CMatrix::ZXY
[pure virtual, inherited]
+
+ + + + + +
+   + + +

+Change the transform mode. Components or matrix are not reseted. +

+ +

+Implemented in NL3D::CTransformableUser.

+

+ + + + +
+ + + + + + + + + + +
virtual void NL3D::CTransformUser::setTransparency bool  v  )  [inline, virtual, inherited]
+
+ + + + + +
+   + + +

+ +

+Implements NL3D::UTransform. +

+Definition at line 229 of file transform_user.h. +

+References NL3D::CTransformUser::_Transform, NL3D_MEM_TRANSFORM, NL3D::CTransform::setTransparency(), and v. +

+

00230         {
+00231                 NL3D_MEM_TRANSFORM
+00232                 _Transform->setTransparency(v);
+00233         }
+
+

+ + + + +
+ + + + + + + + + + +
virtual void NL3D::UTransform::setTransparency bool  v  )  [pure virtual, inherited]
+
+ + + + + +
+   + + +

+ +

+Implemented in NL3D::CTransformUser.

+

+ + + + +
+ + + + + + + + + + +
virtual void NL3D::CTransformUser::setUserClipping bool  enable  )  [inline, virtual, inherited]
+
+ + + + + +
+   + + +

+Return the user clipping state. +

+ +

+Implements NL3D::UTransform. +

+Definition at line 126 of file transform_user.h. +

+References NL3D::CTransformUser::_Transform, NL3D_MEM_TRANSFORM, nlassert, and NL3D::CTransform::setUserClipping(). +

+

00127         {
+00128                 NL3D_MEM_TRANSFORM
+00129                 nlassert(_Transform) ; // object invalid now ...
+00130                 _Transform->setUserClipping(enable);
+00131         }
+
+

+ + + + +
+ + + + + + + + + + +
virtual void NL3D::UTransform::setUserClipping bool  enable  )  [pure virtual, inherited]
+
+ + + + + +
+   + + +

+Return the user clipping state. +

+ +

+Implemented in NL3D::CTransformUser.

+

+ + + + +
+ + + + + + + + + + +
virtual void NL3D::CTransformUser::setUserLightable bool  enable  )  [inline, virtual, inherited]
+
+ + + + + +
+   + + +

+Set the UserLightable flag. if false, isLightable() will always return false. Doing this, user can disable lighting on a model which may be interesting for speed. NB: most of models don't need it. For example models with LightMaps are by default Lighing-disabled. Default behavior is UserLightable==true. +

+Implements NL3D::UTransform. +

+Definition at line 178 of file transform_user.h. +

+References NL3D::CTransformUser::_Transform, NL3D_MEM_TRANSFORM, and NL3D::CTransform::setUserLightable(). +

+

00179         {
+00180                 NL3D_MEM_TRANSFORM
+00181                 _Transform->setUserLightable(enable);
+00182         }
+
+

+ + + + +
+ + + + + + + + + + +
virtual void NL3D::UTransform::setUserLightable bool  enable  )  [pure virtual, inherited]
+
+ + + + + +
+   + + +

+Set the UserLightable flag. if false, isLightable() will always return false. Doing this, user can disable lighting on a model which may be interesting for speed. NB: most of models don't need it. For example models with LightMaps are by default Lighing-disabled. Default behavior is UserLightable==true. +

+Implemented in NL3D::CTransformUser.

+

+ + + + +
+ + + + + + + + + +
virtual void NL3D::CTransformUser::show  )  [inline, virtual, inherited]
+
+ + + + + +
+   + + +

+Show the objet and his sons. +

+ +

+Implements NL3D::UTransform. +

+Definition at line 120 of file transform_user.h. +

+References NL3D::CTransformUser::_Transform, NL3D_MEM_TRANSFORM, nlassert, and NL3D::CTransform::show(). +

+

00121         {
+00122                 NL3D_MEM_TRANSFORM
+00123                 nlassert(_Transform) ; // object invalid now ...
+00124                 _Transform->show();
+00125         }
+
+

+ + + + +
+ + + + + + + + + +
virtual void NL3D::UTransform::show  )  [pure virtual, inherited]
+
+ + + + + +
+   + + +

+Show the objet and his sons. +

+ +

+Implemented in NL3D::CTransformUser.

+

+ + + + +
+ + + + + + + + + + + + + + + + + + + +
void NL3D::CSkeletonUser::stickObject UTransform mi,
uint  boneId
[virtual]
+
+ + + + + +
+   + + +

+parent a CTransform to a bone of the skeleton. NB: ~CTransform() calls detachSkeletonSon(). This object will be visible only when the Skeleton is not clipped. NB: an object can't be skinned and sticked at same time :) NB: replaced if already here. +

+Implements NL3D::USkeleton. +

+Definition at line 118 of file skeleton_user.cpp. +

+References _Skeleton, NL3D_HAUTO_UI_SKELETON, NL3D_MEM_SKELETON, nlerror, NL3D::CSkeletonModel::stickObject(), and uint. +

+

00119 {
+00120         NL3D_MEM_SKELETON
+00121         NL3D_HAUTO_UI_SKELETON;
+00122 
+00123         if(mi==NULL)
+00124                 nlerror("USkeleton::stickObject(): mi is NULL");
+00125         CTransform              *trans= (dynamic_cast<CTransformUser*>(mi))->getTransform();
+00126         _Skeleton->stickObject(trans, boneId);
+00127 }
+
+

+ + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + + +
void NL3D::CSkeletonUser::stickObjectEx UTransform mi,
uint  boneId,
bool  forceCLod
[virtual]
+
+ + + + + +
+   + + +

+same method as stickObject(), but if you set forceCLod as true, then this object will be visible even if the skeleton father is in CLod state (ie displayed with a CLodCharacterShape) NB: if "mi" is a skeleton model, forceCLod is considerer true, whatever the value passed in. +

+Implements NL3D::USkeleton. +

+Definition at line 130 of file skeleton_user.cpp. +

+References _Skeleton, NL3D_HAUTO_UI_SKELETON, NL3D_MEM_SKELETON, nlerror, NL3D::CSkeletonModel::stickObjectEx(), and uint. +

+

00131 {
+00132         NL3D_MEM_SKELETON
+00133         NL3D_HAUTO_UI_SKELETON;
+00134 
+00135         if(mi==NULL)
+00136                 nlerror("USkeleton::stickObject(): mi is NULL");
+00137         CTransform              *trans= (dynamic_cast<CTransformUser*>(mi))->getTransform();
+00138         _Skeleton->stickObjectEx(trans, boneId, forceCLod);
+00139 }
+
+

+ + + + +
+ + + + + + + + + +
virtual void NL3D::CTransformUser::unfreezeHRC  )  [virtual, inherited]
+
+ + + + + +
+   + + +

+see freezeHRC(). +

+Implements NL3D::UTransform.

+

+ + + + +
+ + + + + + + + + +
virtual void NL3D::UTransform::unfreezeHRC  )  [pure virtual, inherited]
+
+ + + + + +
+   + + +

+see freezeHRC(). +

+Implemented in NL3D::CTransformUser.

+


Field Documentation

+

+ + + + +
+ + +
std::vector<CBoneUser> NL3D::CSkeletonUser::_Bones +
+
+ + + + + +
+   + + +

+This is a mirror of _Skeleton->Bones. +

+ +

+Definition at line 58 of file skeleton_user.h.

+

+ + + + +
+ + +
bool NL3D::CTransformUser::_DeleteIt [protected, inherited] +
+
+ + + + + +
+   + + +

+ +

+Definition at line 60 of file transform_user.h. +

+Referenced by NL3D::CTransformUser::CTransformUser(), and NL3D::CTransformUser::~CTransformUser().

+

+ + + + +
+ + +
CScene* NL3D::CTransformUser::_Scene [protected, inherited] +
+
+ + + + + +
+   + + +

+ +

+Definition at line 55 of file transform_user.h.

+

+ + + + +
+ + +
CSkeletonModel* NL3D::CSkeletonUser::_Skeleton +
+
+ + + + + +
+   + + +

+This is the SAME pointer than _Transform, but correctly casted. +

+ +

+Definition at line 55 of file skeleton_user.h. +

+Referenced by bindSkin(), changeMRMDistanceSetup(), computeCurrentBBox(), computeLodTexture(), computeRenderedBBox(), CSkeletonUser(), detachSkeletonSon(), forceComputeBone(), getBoneAnimCtrl(), getBoneIdByName(), getInterpolationDistance(), getLodCharacterAnimId(), getLodCharacterAnimTime(), getLodCharacterDistance(), getLodCharacterShape(), getLodCharacterWrapMode(), getShapeDistMax(), getSkeleton(), isBoneComputed(), isDisplayedAsLodCharacter(), setBoneAnimCtrl(), setInterpolationDistance(), setLodCharacterAnimId(), setLodCharacterAnimTime(), setLodCharacterDistance(), setLodCharacterShape(), setLodCharacterWrapMode(), setShapeDistMax(), stickObject(), stickObjectEx(), and ~CSkeletonUser().

+

+ + + + +
+ + +
CTransform* NL3D::CTransformUser::_Transform [protected, inherited] +
+
+ + + + + +
+   + + +

+ +

+Definition at line 57 of file transform_user.h. +

+Referenced by NL3D::CTransformUser::CTransformUser(), NL3D::CTransformUser::getForceClipRoot(), NL3D::CTransformUser::getLastClippedState(), NL3D::CTransformUser::getLastWorldVisState(), NL3D::CTransformUser::getOrderingLayer(), NL3D::CTransformUser::getTransform(), NL3D::CTransformUser::getUserClipping(), NL3D::CTransformUser::getUserLightable(), NL3D::CTransformUser::getVisibility(), NL3D::CTransformUser::heritVisibility(), NL3D::CTransformUser::hide(), NL3D::CTransformUser::isOpaque(), NL3D::CTransformUser::isTransparent(), NL3D::CTransformUser::setForceClipRoot(), NL3D::CTransformUser::setLogicInfo(), NL3D::CTransformUser::setOpacity(), NL3D::CTransformUser::setOrderingLayer(), NL3D::CTransformUser::setTransparency(), NL3D::CTransformUser::setUserClipping(), NL3D::CTransformUser::setUserLightable(), NL3D::CTransformUser::show(), and NL3D::CTransformUser::~CTransformUser().

+

+ + + + +
+ + +
ITransformable* NL3D::CTransformableUser::_Transformable [protected, inherited] +
+
+ + + + + +
+   + + +

+ +

+Definition at line 50 of file transformable_user.h. +

+Referenced by NL3D::CTransformableUser::CTransformableUser(), NL3D::CTransformableUser::getMatrix(), NL3D::CTransformableUser::getPivot(), NL3D::CTransformableUser::getPos(), NL3D::CTransformableUser::getRotEuler(), NL3D::CTransformableUser::getRotOrder(), NL3D::CTransformableUser::getRotQuat(), NL3D::CTransformableUser::getScale(), NL3D::CTransformableUser::getTransformMode(), NL3D::CTransformableUser::lookAt(), NL3D::CTransformableUser::setMatrix(), NL3D::CTransformableUser::setPivot(), NL3D::CTransformableUser::setPos(), NL3D::CTransformableUser::setRotEuler(), NL3D::CTransformableUser::setRotQuat(), NL3D::CTransformableUser::setScale(), NL3D::CTransformableUser::setTransformMode(), and NL3D::CTransformableUser::~CTransformableUser().

+


The documentation for this class was generated from the following files: +
Generated on Tue Mar 16 07:46:59 2004 for NeL by + +doxygen +1.3.6
+ + -- cgit v1.2.1