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/a02277.html | 3237 ++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 3237 insertions(+) create mode 100644 docs/doxygen/nel/a02277.html (limited to 'docs/doxygen/nel/a02277.html') diff --git a/docs/doxygen/nel/a02277.html b/docs/doxygen/nel/a02277.html new file mode 100644 index 00000000..acbc59b7 --- /dev/null +++ b/docs/doxygen/nel/a02277.html @@ -0,0 +1,3237 @@ + + +NeL: NL3D::CBone class Reference + + + +

NL3D::CBone Class Reference

#include <bone.h> +

Inheritance diagram for NL3D::CBone: +

+ + + + +

Detailed Description

+This is a bone, for skeleton animation, with information for result WorldMatrix.

Author:: Lionel Berenguier
+Nevrax France

Date:: 2001

+ +

+Definition at line 96 of file bone.h. + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

Herited from IAnimatable
enum TAnimValues {
+ OwnerBit = IAnimatable::AnimValueLast, +PosValue, +RotEulerValue, +RotQuatValue, +
+ ScaleValue, +PivotValue, +AnimValueLast +
+ }
Added values. More...

virtual IAnimatedValue * getValue (uint valueId)
From IAnimatable.

virtual const char * getValueName (uint valueId) const
From IAnimatable.

Public Types
enum TTransformMode { DirectMatrix = 0, +RotEuler, +RotQuat, +TransformModeCount + }

Public Member Functions
CBone (CBoneBase *boneBase)
bool compareMatrixDate (uint64 callerDate) const
void compute (CBone *parent, const CMatrix &rootMatrix, CSkeletonModel *skeletonForAnimCtrl)
void forceAnimate (CChannelMixer &chanMixer)
CBoneBase & getBoneBase () const
retrieve the boneBase

const std::string & getBoneName () const
retrieve the boneName from BoneBase.

const CMatrix & getBoneSkinMatrix () const
retrieve the BoneSkinMatrix computed in compute().

sint32 getFatherId () const
retrieve the fatherId from BoneBase.

const CMatrix & getLocalSkeletonMatrix () const
retrieve the matrix local to the skeleton, computed in compute().

const CMatrix & getMatrix () const
Get the matrix, compute her if necessary (work in all modes).

uint64 getMatrixDate () const
const CMatrix & getWorldMatrix () const
retrieve the WorldMatrix computed in compute().

void interpolateBoneSkinMatrix (const CMatrix &otherMatrix, float interp)
void lodEnableChannels (CChannelMixer *chanMixer, bool enable)
enable the channels (lodEnable) associated to this bone in the channelMixer.

Herited from ITransformable
virtual ITrack * getDefaultTrack (uint valueId)
retrive the default trak from skeleton shape.

virtual void registerToChannelMixer (CChannelMixer *chanMixer, const std::string &prefix)
register the ITransformable channels as detailled channels.

Static Public Member Functions
const char * getPivotValueName ()
const char * getPosValueName ()
const char * getRotEulerValueName ()
const char * getRotQuatValueName ()
const char * getScaleValueName ()

Data Fields
IAnimCtrl * _AnimCtrl
NLMISC::CBSphere _MaxSphere

Protected Member Functions
sint addValue (CChannelMixer *chanMixer, uint valueId, uint ownerValueId, const std::string &prefix, bool detail)
void clearFlag (uint valueId)
This method clear a bit in the bitset.

void setFlag (uint valueId)
This method set a bit in the bitset.

Private Attributes
NLMISC::CRefPtr< CBoneBase > _BoneBase
CMatrix _BoneSkinMatrix
CMatrix _LocalSkeletonMatrix
sint _PivotChannelId
sint _PosChannelId
sint _RotEulerChannelId
sint _RotQuatChannelId
sint _ScaleChannelId
CMatrix _WorldMatrix
+

Member Enumeration Documentation

+ + + + +
+ + +
enum NL3D::ITransformable::TAnimValues [inherited] +
+
+ + + + + +
+ + + +
+Added values. +
+
Enumeration values:
+ + + + + + + + +
OwnerBit +
PosValue +
RotEulerValue +
RotQuatValue +
ScaleValue +
PivotValue +
AnimValueLast +
+
+ +
+Reimplemented from NL3D::IAnimatable. +
+Reimplemented in NL3D::CCamera, NL3D::CMeshBaseInstance, NL3D::CParticleSystemModel, NL3D::CSegRemanence, and NL3D::CSkeletonModel. +
+Definition at line 280 of file transformable.h. +
+
00281 { +00282 OwnerBit= IAnimatable::AnimValueLast, +00283 PosValue, +00284 RotEulerValue, +00285 RotQuatValue, +00286 ScaleValue, +00287 PivotValue, +00288 AnimValueLast +00289 }; +

+

+ + + + +
+ + +
enum NL3D::ITransformable::TTransformMode [inherited] +
+
+ + + + + +
+ + + +
+
Enumeration values:
+ + + + + +
DirectMatrix +
RotEuler +
RotQuat +
TransformModeCount +
+
+ +
+Definition at line 58 of file transformable.h. +
+Referenced by NL3D::ITransformable::getTransformMode(). +
+
00059 { +00060 DirectMatrix=0, // DirectMatrixMode. +00061 RotEuler, // Matrix is computed from sperated composantes, with euler rotation. +00062 RotQuat, // Matrix is computed from sperated composantes, with quat rotation (default). +00063 +00064 TransformModeCount +00065 }; +

+

Constructor & Destructor Documentation

+ + + + +
+ + + + + + + + + + +
NL3D::CBone::CBone ( CBoneBase * boneBase )
+
+ + + + + +
+ + + +
+Constructor. build a bone from a CBoneBase*. By defautl, a bone is in RotQuat transform mode. This ctor:
+
store a RefPtr on the bonebase (for getDefaultTracks() method). the refptr is just for nlassert.
copy the bonebase default track value into Animated Values Pos/Rot etc....
+ +
+Definition at line 93 of file bone.cpp. +
+References _AnimCtrl, _BoneBase, _PivotChannelId, _PosChannelId, _RotEulerChannelId, _RotQuatChannelId, _ScaleChannelId, NL3D::CAnimatedValueQuat, NL3D::CAnimatedValueVector, and nlassert. +
+
00094 { +00095 nlassert(boneBase); +00096 _BoneBase= boneBase; +00097 +00098 // IAnimatable. +00099 IAnimatable::resize(AnimValueLast); +00100 +00101 ITransformable::setTransformMode(ITransformable::RotQuat); +00102 ITransformable::setPos( ((CAnimatedValueVector&)_BoneBase->DefaultPos.getValue()).Value ); +00103 ITransformable::setRotQuat( ((CAnimatedValueQuat&)_BoneBase->DefaultRotQuat.getValue()).Value ); +00104 ITransformable::setScale( ((CAnimatedValueVector&)_BoneBase->DefaultScale.getValue()).Value ); +00105 ITransformable::setPivot( ((CAnimatedValueVector&)_BoneBase->DefaultPivot.getValue()).Value ); +00106 +00107 // By default, the bone is not binded to a channelMixer. +00108 _PosChannelId= -1; +00109 _RotEulerChannelId= -1; +00110 _RotQuatChannelId= -1; +00111 _ScaleChannelId= -1; +00112 _PivotChannelId= -1; +00113 +00114 // No animCtrl by default +00115 _AnimCtrl= NULL; +00116 } +

+

Member Function Documentation

+ + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
sint NL3D::IAnimatable::addValue ( CChannelMixer * chanMixer,
uint valueId,
uint ownerValueId,
const std::string & prefix,
bool detail
) [protected, inherited]
+
+ + + + + +
+ + + +
+This is a tool function which add a given value to a channel.
Returns:
-1 if the track was not found in the animationSet, else it return the channelId as if returned by CAnimationSet::getChannelIdByName(channelName).
+ +
+Definition at line 37 of file animatable.cpp. +
+References NL3D::CChannelMixer::addChannel(), NL3D::IAnimatable::getDefaultTrack(), NL3D::IAnimatable::getValue(), NL3D::IAnimatable::getValueName(), nlassert, sint, and uint. +
+Referenced by NL3D::CTransform::registerToChannelMixer(), NL3D::CParticleSystemModel::registerToChannelMixer(), NL3D::CCamera::registerToChannelMixer(), registerToChannelMixer(), NL3D::CAnimatedMorph::registerToChannelMixer(), NL3D::CAnimatedMaterial::registerToChannelMixer(), and NL3D::CAnimatedLightmap::registerToChannelMixer(). +
+
00038 { +00039 nlassert(chanMixer); +00040 return chanMixer->addChannel(prefix+getValueName(valueId), this, getValue(valueId), getDefaultTrack(valueId), valueId, ownerValueId, detail); +00041 } +

+

+ + + + +
+ + + + + + + + + + +
void NL3D::IAnimatable::clearFlag ( uint valueId ) [inline, protected, inherited]
+
+ + + + + +
+ + + +
+This method clear a bit in the bitset. +
+ +
+Definition at line 233 of file animatable.h. +
+References NL3D::IAnimatable::_BitSet, and uint. +
+Referenced by NL3D::ITransformable::clearTransformFlags(), NL3D::CParticleSystemModel::doAnimate(), and NL3D::CAnimatedMaterial::update(). +
+
00234 { +00235 _BitSet&= ~(1<<valueId); +00236 } +

+

+ + + + +
+ + + + + + + + + + +
bool NL3D::ITransformable::compareMatrixDate ( uint64 callerDate ) const [inline, inherited]
+
+ + + + + +
+ + + +
+Tells if the LocalMatrix is newer than what caller except. This return true either if the matrix components (pos/rot etc...) are touched, or if matrix is newer than caller date. +
+Definition at line 82 of file transformable.h. +
+References NL3D::ITransformable::_LocalMatrixDate, NL3D::ITransformable::needCompute(), and uint64. +
+Referenced by NL3D::CWaterModel::updateDiffuseMapMatrix(). +
+
00083 { +00084 return callerDate<_LocalMatrixDate || needCompute(); +00085 } +

+

+ + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + + +
void NL3D::CBone::compute ( CBone * parent,
const CMatrix & rootMatrix,
CSkeletonModel * skeletonForAnimCtrl
)
+
+ + + + + +
+ + + +
+Compute the LocalSkeletonMatrix, the WorldMatrix, and the BoneSkinMatrix (for skinning). NB: the result localSkeletonMatrix depends on BoneBase::UnheritScale.
+ NB: the result worldMatrix depends on BoneBase::UnheritScale.
+ NB: the result boneSkinMatrix depends on BoneBase::InvBindPos.
+
Parameters:
+ + + + +
parent the parent of this bone (maybe NULL if root). his WorldMatrix is used, so it should be computed before.
rootMatrix is used as father worldmatrix if parent==NULL. Usefull for computing WorldMatrix.
skeletonForAnimCtrl if NULL, no AnimCtrl is performed, else skeletonForAnimCtrl->getWorldMAtrix() should be == to rootMatrix
+
+ +
+Definition at line 155 of file bone.cpp. +
+References _AnimCtrl, _BoneBase, _BoneSkinMatrix, _LocalSkeletonMatrix, _WorldMatrix, NL3D::IAnimCtrl::execute(), NL3D::ITransformable::getMatrix(), NLMISC::CMatrix::getPos(), NL3D::ITransformable::getScale(), nlassert, NLMISC::CMatrix::setMulMatrixNoProj(), NLMISC::CMatrix::setPos(), NLMISC::CMatrix::setScale(), NLMISC::CVector::x, NLMISC::CVector::y, and NLMISC::CVector::z. +
+Referenced by NL3D::CTargetAnimCtrl::execute(), NL3D::CSkeletonModel::forceComputeBone(), and NL3D::CSkeletonModel::traverseAnimDetail(). +
+
00156 { +00157 // compute is called typically 800 time per frame. +00158 #ifdef NL_DEBUG +00159 nlassert(_BoneBase); +00160 #endif +00161 +00162 // get/compute our local matrix +00163 const CMatrix &localMatrix= getMatrix(); +00164 +00165 // Compute LocalSkeletonMatrix. +00166 // Root case? +00167 if(!parent) +00168 { +00169 _LocalSkeletonMatrix= localMatrix; +00170 } +00171 // Else, son case, take world matrix from parent. +00172 else +00173 { +00174 // UnheritScale case. +00175 if(_BoneBase->UnheritScale) +00176 { +00177 CMatrix invScaleComp; +00178 CVector fatherScale; +00179 CVector trans; +00180 +00181 /* Optim note: +00182 the scale is rarely ==1, so don't optimize case where it may be. +00183 */ +00184 +00185 // retrieve our translation +00186 localMatrix.getPos(trans); +00187 // retrieve scale from our father. +00188 parent->getScale(fatherScale); +00189 // inverse this scale. +00190 fatherScale.x= 1.0f / fatherScale.x; +00191 fatherScale.y= 1.0f / fatherScale.y; +00192 fatherScale.z= 1.0f / fatherScale.z; +00193 +00194 // Compute InverseScale compensation: +00195 // with UnheritScale, formula per bone should be T*Sf-1*P*R*S*P-1. +00196 // But getMatrix() return T*P*R*S*P-1. +00197 // So we must compute T*Sf-1*T-1, in order to get wanted result. +00198 invScaleComp.setScale(fatherScale); +00199 // Faster compute of the translation part: just "trans + fatherScale MUL -trans" where MUL is comp mul +00200 trans.x-= fatherScale.x * trans.x; +00201 trans.y-= fatherScale.y * trans.y; +00202 trans.z-= fatherScale.z * trans.z; +00203 invScaleComp.setPos(trans); +00204 +00205 +00206 // And finally, we got ParentWM * T*Sf-1*P*R*S*P-1. +00207 // Do: _LocalSkeletonMatrix= parent->_LocalSkeletonMatrix * invScaleComp * localMatrix +00208 static CMatrix tmp; +00209 tmp.setMulMatrixNoProj( parent->_LocalSkeletonMatrix, invScaleComp ); +00210 _LocalSkeletonMatrix.setMulMatrixNoProj( tmp, localMatrix ); +00211 } +00212 // Normal case. +00213 else +00214 { +00215 // Do: _LocalSkeletonMatrix= parent->_LocalSkeletonMatrix * localMatrix +00216 _LocalSkeletonMatrix.setMulMatrixNoProj( parent->_LocalSkeletonMatrix, localMatrix ); +00217 } +00218 } +00219 +00220 // Compute WorldMatrix. Do: _WorldMatrix= rootMatrix * _LocalSkeletonMatrix +00221 _WorldMatrix.setMulMatrixNoProj( rootMatrix, _LocalSkeletonMatrix ); +00222 +00223 // Compute BoneSkinMatrix. Do: _BoneSkinMatrix= _LocalSkeletonMatrix * _BoneBase->InvBindPos +00224 _BoneSkinMatrix.setMulMatrixNoProj( _LocalSkeletonMatrix, _BoneBase->InvBindPos ); +00225 +00226 // When compute is done, do extra user ctrl? +00227 if(_AnimCtrl && skeletonForAnimCtrl) +00228 _AnimCtrl->execute(skeletonForAnimCtrl, this); +00229 } +

+

+ + + + +
+ + + + + + + + + + +
void NL3D::CBone::forceAnimate ( CChannelMixer & chanMixer ) [inline]
+
+ + + + + +
+ + + +
+Force to eval the animation of that bone Useful when a bone position is needed, and if the father skeleton has been clipped (and thus not detail-animated)
Parameters:
+ + +
chanMixer the channel mixer to which that bone has been registered
+
+ +
+Definition at line 194 of file bone.h. +
+References _PivotChannelId, _PosChannelId, _RotEulerChannelId, _RotQuatChannelId, _ScaleChannelId, NL3D::CChannelMixer::evalChannels(), and sint. +
+
00195 { +00196 sint ids[] = +00197 { +00198 _PosChannelId, +00199 _RotEulerChannelId, +00200 _RotQuatChannelId, +00201 _ScaleChannelId, +00202 _PivotChannelId +00203 }; +00204 chanMixer.evalChannels(ids, sizeof(ids) / sizeof(ids[0])); +00205 } +

+

+ + + + +
+ + + + + + + + + +
CBoneBase& NL3D::CBone::getBoneBase ( ) const [inline]
+
+ + + + + +
+ + + +
+retrieve the boneBase +
+ +
+Definition at line 114 of file bone.h. +
+References _BoneBase, and nlassert. +
+Referenced by NL3D::CTargetAnimCtrl::execute(), and NL3D::CTargetAnimCtrl::getCurrentLSRotationFromBone(). +
+
00114 {nlassert(_BoneBase); return *_BoneBase;} +

+

+ + + + +
+ + + + + + + + + +
const std::string& NL3D::CBone::getBoneName ( ) const [inline]
+
+ + + + + +
+ + + +
+retrieve the boneName from BoneBase. +
+ +
+Definition at line 110 of file bone.h. +
+References _BoneBase, and nlassert. +
+
00110 {nlassert(_BoneBase); return _BoneBase->Name;} +

+

+ + + + +
+ + + + + + + + + +
const CMatrix& NL3D::CBone::getBoneSkinMatrix ( ) const [inline]
+
+ + + + + +
+ + + +
+retrieve the BoneSkinMatrix computed in compute(). +
+ +
+Definition at line 150 of file bone.h. +
+References _BoneSkinMatrix. +
+Referenced by NL3D::CSkeletonModel::traverseAnimDetail(). +
+
00150 {return _BoneSkinMatrix;} +

+

+ + + + +
+ + + + + + + + + + +
ITrack * NL3D::CBone::getDefaultTrack ( uint valueId ) [virtual]
+
+ + + + + +
+ + + +
+retrive the default trak from skeleton shape. +
+ +
+Implements NL3D::ITransformable. +
+Definition at line 119 of file bone.cpp. +
+References _BoneBase, nlassert, nlstop, and uint. +
+
00120 { +00121 nlassert(_BoneBase); +00122 +00123 // what value ? +00124 switch (valueId) +00125 { +00126 case PosValue: return &_BoneBase->DefaultPos; +00127 case RotEulerValue: return &_BoneBase->DefaultRotEuler; +00128 case RotQuatValue: return &_BoneBase->DefaultRotQuat; +00129 case ScaleValue: return &_BoneBase->DefaultScale; +00130 case PivotValue: return &_BoneBase->DefaultPivot; +00131 } +00132 +00133 // No, only ITrnasformable values! +00134 nlstop; +00135 // Deriver note: else call BaseClass::getDefaultTrack(valueId); +00136 +00137 return NULL; +00138 } +

+

+ + + + +
+ + + + + + + + + +
sint32 NL3D::CBone::getFatherId ( ) const [inline]
+
+ + + + + +
+ + + +
+retrieve the fatherId from BoneBase. +
+ +
+Definition at line 112 of file bone.h. +
+References _BoneBase, nlassert, and sint32. +
+Referenced by NL3D::CTargetAnimCtrl::execute(), and NL3D::CSkeletonModel::forceComputeBone(). +
+
00112 {nlassert(_BoneBase); return _BoneBase->FatherId;} +

+

+ + + + +
+ + + + + + + + + +
const CMatrix& NL3D::CBone::getLocalSkeletonMatrix ( ) const [inline]
+
+ + + + + +
+ + + +
+retrieve the matrix local to the skeleton, computed in compute(). +
+ +
+Definition at line 144 of file bone.h. +
+References _LocalSkeletonMatrix. +
+Referenced by NL3D::CTargetAnimCtrl::execute(), and NL3D::CTargetAnimCtrl::getCurrentLSRotationFromBone(). +
+
00144 {return _LocalSkeletonMatrix;} +

+

+ + + + +
+ + + + + + + + + +
const CMatrix& NL3D::ITransformable::getMatrix ( ) const [inline, inherited]
+
+ + + + + +
+ + + +
+Get the matrix, compute her if necessary (work in all modes). +
+ +
+Definition at line 76 of file transformable.h. +
+References NL3D::ITransformable::updateMatrix(). +
+Referenced by NL3D::CInstanceGroup::addToSceneWhenAllShapesLoaded(), NL3D::CCamera::buildCameraPyramid(), compute(), NL3D::CWaterShape::createInstance(), NL3D::CWaterModel::getAttenuatedHeight(), NL3D::CTransformableUser::getMatrix(), NL3D::CCloudScape::render(), NL3D::CMeshMultiLod::renderCoarseMesh(), and NL3D::CTransform::update(). +
+
00076 {updateMatrix(); return _LocalMatrix;} +

+

+ + + + +
+ + + + + + + + + +
uint64 NL3D::ITransformable::getMatrixDate ( ) const [inline, inherited]
+
+ + + + + +
+ + + +
+return the last date of computed matrix. updateMatrix() if necessary. +
+Definition at line 90 of file transformable.h. +
+References NL3D::ITransformable::_LocalMatrixDate, uint64, and NL3D::ITransformable::updateMatrix(). +
+Referenced by NL3D::CWaterModel::updateDiffuseMapMatrix(). +
+
00091 { +00092 updateMatrix(); +00093 return _LocalMatrixDate; +00094 } +

+

+ + + + +
+ + + + + + + + + +
CVector NL3D::ITransformable::getPivot ( ) [inline, inherited]
+
+ + + + + +
+ + + +
+Work only in Rot* mode (nlassert). +
+ +
+Definition at line 255 of file transformable.h. +
+References NL3D::ITransformable::_Pivot, nlassert, NL3D::ITransformable::RotEuler, NL3D::ITransformable::RotQuat, and NL3D::CAnimatedValueBlendable< T >::Value. +
+
00256 { +00257 nlassert(_Mode==RotEuler || _Mode==RotQuat); +00258 return _Pivot.Value; +00259 } +

+

+ + + + +
+ + + + + + + + + + +
void NL3D::ITransformable::getPivot ( CVector & pivot ) [inline, inherited]
+
+ + + + + +
+ + + +
+Work only in Rot* mode (nlassert). +
+ +
+Definition at line 224 of file transformable.h. +
+References NL3D::ITransformable::_Pivot, nlassert, NL3D::ITransformable::RotEuler, NL3D::ITransformable::RotQuat, and NL3D::CAnimatedValueBlendable< T >::Value. +
+Referenced by NL3D::CTransformableUser::getPivot(). +
+
00225 { +00226 nlassert(_Mode==RotEuler || _Mode==RotQuat); +00227 pivot= _Pivot.Value; +00228 } +

+

+ + + + +
+ + + + + + + + + +
const char * NL3D::ITransformable::getPivotValueName ( ) [static, inherited]
+
+ + + + + +
+ + + +
+ +
+Definition at line 117 of file transformable.cpp. +
+Referenced by NL3D::ITransformable::getValueName(). +
+
00118 { +00119 return "pivot"; +00120 } +

+

+ + + + +
+ + + + + + + + + + +
CVector NL3D::ITransformable::getPos ( void ) [inline, inherited]
+
+ + + + + +
+ + + +
+Work only in Rot* mode(nlassert). +
+ +
+Definition at line 231 of file transformable.h. +
+References nlassert, NL3D::ITransformable::RotEuler, NL3D::ITransformable::RotQuat, and NL3D::CAnimatedValueBlendable< T >::Value. +
+Referenced by NL3D::CSkeletonModel::generateShadowMap(), NL3D::CWaterModel::getHeight(), NL3D::CSkeletonModel::renderIntoSkeletonShadowMap(), NL3D::CMeshInstance::renderIntoSkeletonShadowMap(), and NL3D::CPointLightModel::traverseLight(). +
+
00232 { +00233 nlassert(_Mode==RotEuler || _Mode==RotQuat); +00234 return _Pos.Value; +00235 } +

+

+ + + + +
+ + + + + + + + + + +
void NL3D::ITransformable::getPos ( CVector & pos ) [inline, inherited]
+
+ + + + + +
+ + + +
+Work only in Rot* mode(nlassert). +
+ +
+Definition at line 200 of file transformable.h. +
+References nlassert, NL3D::ITransformable::RotEuler, NL3D::ITransformable::RotQuat, and NL3D::CAnimatedValueBlendable< T >::Value. +
+Referenced by NL3D::CTransformableUser::getPos(), NL3D::CInstanceGroup::getPos(), and NL3D::CPSLight::step(). +
+
00201 { +00202 nlassert(_Mode==RotEuler || _Mode==RotQuat); +00203 pos= _Pos.Value; +00204 } +

+

+ + + + +
+ + + + + + + + + +
const char * NL3D::ITransformable::getPosValueName ( ) [static, inherited]
+
+ + + + + +
+ + + +
+ +
+Definition at line 97 of file transformable.cpp. +
+Referenced by NL3D::ITransformable::getValueName(). +
+
00098 { +00099 return "pos"; +00100 } +

+

+ + + + +
+ + + + + + + + + +
CVector NL3D::ITransformable::getRotEuler ( ) [inline, inherited]
+
+ + + + + +
+ + + +
+Work only in RotEuler mode(nlassert). +
+ +
+Definition at line 237 of file transformable.h. +
+References NL3D::ITransformable::_RotEuler, nlassert, NL3D::ITransformable::RotEuler, and NL3D::CAnimatedValueBlendable< T >::Value. +
+
00238 { +00239 nlassert(_Mode==RotEuler); +00240 return _RotEuler.Value; +00241 } +

+

+ + + + +
+ + + + + + + + + + +
void NL3D::ITransformable::getRotEuler ( CVector & rot ) [inline, inherited]
+
+ + + + + +
+ + + +
+Work only in RotEuler mode(nlassert). +
+ +
+Definition at line 206 of file transformable.h. +
+References NL3D::ITransformable::_RotEuler, nlassert, NL3D::ITransformable::RotEuler, and NL3D::CAnimatedValueBlendable< T >::Value. +
+Referenced by NL3D::CTransformableUser::getRotEuler(). +
+
00207 { +00208 nlassert(_Mode==RotEuler); +00209 rot= _RotEuler.Value; +00210 } +

+

+ + + + +
+ + + + + + + + + +
const char * NL3D::ITransformable::getRotEulerValueName ( ) [static, inherited]
+
+ + + + + +
+ + + +
+ +
+Definition at line 102 of file transformable.cpp. +
+Referenced by NL3D::ITransformable::getValueName(). +
+
00103 { +00104 return "roteuler"; +00105 } +

+

+ + + + +
+ + + + + + + + + +
CMatrix::TRotOrder NL3D::ITransformable::getRotOrder ( ) [inline, inherited]
+
+ + + + + +
+ + + +
+get the current rotorder (information vlaid only when RotEuler mode). +
+ +
+Definition at line 194 of file transformable.h. +
+References NL3D::ITransformable::_RotOrder. +
+Referenced by NL3D::CTransformableUser::getRotOrder(). +
+
00195 { +00196 return _RotOrder; +00197 } +

+

+ + + + +
+ + + + + + + + + +
CQuat NL3D::ITransformable::getRotQuat ( ) [inline, inherited]
+
+ + + + + +
+ + + +
+Work only in RotQuat mode (nlassert). +
+ +
+Definition at line 243 of file transformable.h. +
+References NL3D::ITransformable::_RotQuat, nlassert, NL3D::ITransformable::RotQuat, and NL3D::CAnimatedValueBlendable< T >::Value. +
+
00244 { +00245 nlassert(_Mode==RotQuat); +00246 return _RotQuat.Value; +00247 } +

+

+ + + + +
+ + + + + + + + + + +
void NL3D::ITransformable::getRotQuat ( CQuat & quat ) [inline, inherited]
+
+ + + + + +
+ + + +
+Work only in RotQuat mode (nlassert). +
+ +
+Definition at line 212 of file transformable.h. +
+References NL3D::ITransformable::_RotQuat, nlassert, NL3D::ITransformable::RotQuat, and NL3D::CAnimatedValueBlendable< T >::Value. +
+Referenced by NL3D::CTransformableUser::getRotQuat(), and NL3D::CInstanceGroup::getRotQuat(). +
+
00213 { +00214 nlassert(_Mode==RotQuat); +00215 quat= _RotQuat.Value; +00216 } +

+

+ + + + +
+ + + + + + + + + +
const char * NL3D::ITransformable::getRotQuatValueName ( ) [static, inherited]
+
+ + + + + +
+ + + +
+ +
+Definition at line 107 of file transformable.cpp. +
+Referenced by NL3D::ITransformable::getValueName(). +
+
00108 { +00109 return "rotquat"; +00110 } +

+

+ + + + +
+ + + + + + + + + + +
CVector NL3D::ITransformable::getScale ( void ) [inline, inherited]
+
+ + + + + +
+ + + +
+Work only in Rot* mode (nlassert). +
+ +
+Definition at line 249 of file transformable.h. +
+References nlassert, NL3D::ITransformable::RotEuler, NL3D::ITransformable::RotQuat, and NL3D::CAnimatedValueBlendable< T >::Value. +
+
00250 { +00251 nlassert(_Mode==RotEuler || _Mode==RotQuat); +00252 return _Scale.Value; +00253 } +

+

+ + + + +
+ + + + + + + + + + +
void NL3D::ITransformable::getScale ( CVector & scale ) [inline, inherited]
+
+ + + + + +
+ + + +
+Work only in Rot* mode (nlassert). +
+ +
+Definition at line 218 of file transformable.h. +
+References nlassert, NL3D::ITransformable::RotEuler, NL3D::ITransformable::RotQuat, and NL3D::CAnimatedValueBlendable< T >::Value. +
+Referenced by compute(), and NL3D::CTransformableUser::getScale(). +
+
00219 { +00220 nlassert(_Mode==RotEuler || _Mode==RotQuat); +00221 scale= _Scale.Value; +00222 } +

+

+ + + + +
+ + + + + + + + + +
const char * NL3D::ITransformable::getScaleValueName ( ) [static, inherited]
+
+ + + + + +
+ + + +
+ +
+Definition at line 112 of file transformable.cpp. +
+Referenced by NL3D::ITransformable::getValueName(). +
+
00113 { +00114 return "scale"; +00115 } +

+

+ + + + +
+ + + + + + + + + +
TTransformMode NL3D::ITransformable::getTransformMode ( ) [inline, inherited]
+
+ + + + + +
+ + + +
+get the current transform mode. +
+ +
+Definition at line 189 of file transformable.h. +
+References NL3D::ITransformable::TTransformMode. +
+Referenced by NL3D::CTargetAnimCtrl::execute(), and NL3D::CTransformableUser::getTransformMode(). +
+
00190 { +00191 return _Mode; +00192 } +

+

+ + + + +
+ + + + + + + + + + +
IAnimatedValue * NL3D::ITransformable::getValue ( uint valueId ) [virtual, inherited]
+
+ + + + + +
+ + + +
+From IAnimatable. +
+ +
+Implements NL3D::IAnimatable. +
+Reimplemented in NL3D::CCamera, and NL3D::CParticleSystemModel. +
+Definition at line 58 of file transformable.cpp. +
+References NL3D::ITransformable::_Pivot, NL3D::ITransformable::_RotEuler, NL3D::ITransformable::_RotQuat, nlstop, NL3D::ITransformable::PivotValue, NL3D::ITransformable::PosValue, NL3D::ITransformable::RotEulerValue, NL3D::ITransformable::RotQuatValue, NL3D::ITransformable::ScaleValue, and uint. +
+
00059 { +00060 // what value ? +00061 switch (valueId) +00062 { +00063 case PosValue: return &_Pos; +00064 case RotEulerValue: return &_RotEuler; +00065 case RotQuatValue: return &_RotQuat; +00066 case ScaleValue: return &_Scale; +00067 case PivotValue: return &_Pivot; +00068 } +00069 +00070 // No, only ITrnasformable values! +00071 nlstop; +00072 // Deriver note: else call BaseClass::getValue(valueId); +00073 +00074 return NULL; +00075 } +

+

+ + + + +
+ + + + + + + + + + +
const char * NL3D::ITransformable::getValueName ( uint valueId ) const [virtual, inherited]
+
+ + + + + +
+ + + +
+From IAnimatable. +
+ +
+Implements NL3D::IAnimatable. +
+Reimplemented in NL3D::CCamera, and NL3D::CParticleSystemModel. +
+Definition at line 77 of file transformable.cpp. +
+References NL3D::ITransformable::getPivotValueName(), NL3D::ITransformable::getPosValueName(), NL3D::ITransformable::getRotEulerValueName(), NL3D::ITransformable::getRotQuatValueName(), NL3D::ITransformable::getScaleValueName(), nlstop, NL3D::ITransformable::PivotValue, NL3D::ITransformable::PosValue, NL3D::ITransformable::RotEulerValue, NL3D::ITransformable::RotQuatValue, NL3D::ITransformable::ScaleValue, and uint. +
+
00078 { +00079 // what value ? +00080 switch (valueId) +00081 { +00082 case PosValue: return getPosValueName (); +00083 case RotEulerValue: return getRotEulerValueName(); +00084 case RotQuatValue: return getRotQuatValueName(); +00085 case ScaleValue: return getScaleValueName(); +00086 case PivotValue: return getPivotValueName(); +00087 } +00088 +00089 // No, only ITrnasformable values! +00090 nlstop; +00091 // Deriver note: else call BaseClass::getValueName(valueId); +00092 +00093 return ""; +00094 } +

+

+ + + + +
+ + + + + + + + + +
const CMatrix& NL3D::CBone::getWorldMatrix ( ) const [inline]
+
+ + + + + +
+ + + +
+retrieve the WorldMatrix computed in compute(). +
+ +
+Definition at line 147 of file bone.h. +
+References _WorldMatrix. +
+Referenced by NL3D::CSkeletonModel::computeWorldBBoxForShadow(), NL3D::CTargetAnimCtrl::execute(), and NL3D::CSkeletonModel::forceComputeBone(). +
+
00147 {return _WorldMatrix;} +

+

+ + + + +
+ + + + + + + + + + + + + + + + + + + +
void NL3D::CBone::interpolateBoneSkinMatrix ( const CMatrix & otherMatrix,
float interp
)
+
+ + + + + +
+ + + +
+Interpolate the current result of _BoneSkinMatrix fith otherMatrix. when interp==0.f, _BoneSkinMatrix= otherMatrix. NB: the interpolation is made on per-vector basis => bad matrix interpolation. +
+Definition at line 233 of file bone.cpp. +
+References _BoneSkinMatrix, NLMISC::CMatrix::getI(), NLMISC::CMatrix::getJ(), NLMISC::CMatrix::getK(), NLMISC::CMatrix::getPos(), NLMISC::CMatrix::setPos(), and NLMISC::CMatrix::setRot(). +
+Referenced by NL3D::CSkeletonModel::traverseAnimDetail(). +
+
00234 { +00235 CMatrix &curMatrix= _BoneSkinMatrix; +00236 +00237 // interpolate rot/scale. Just interpolate basis vectors +00238 CVector fatherI= otherMatrix.getI(); +00239 CVector curI= curMatrix.getI(); +00240 curI= fatherI*(1-interp) + curI*interp; +00241 CVector fatherJ= otherMatrix.getJ(); +00242 CVector curJ= curMatrix.getJ(); +00243 curJ= fatherJ*(1-interp) + curJ*interp; +00244 CVector fatherK= otherMatrix.getK(); +00245 CVector curK= curMatrix.getK(); +00246 curK= fatherK*(1-interp) + curK*interp; +00247 // replace rotation +00248 curMatrix.setRot(curI, curJ, curK); +00249 +00250 // interpolate pos +00251 CVector fatherPos= otherMatrix.getPos(); +00252 CVector curPos= curMatrix.getPos(); +00253 curPos= fatherPos*(1-interp) + curPos*interp; +00254 curMatrix.setPos(curPos); +00255 } +

+

+ + + + +
+ + + + + + + + + + +
uint32 NL3D::IAnimatable::isTouched ( uint valueId ) const [inline, inherited]
+
+ + + + + +
+ + + +
+Return non 0 int if the value as been touched else 0.
+
Parameters:
+ + +
valueId is the animated value ID in the object we want to test the touch flag. or it may be an OwnerBit.
+
+ +
+Definition at line 184 of file animatable.h. +
+References NL3D::IAnimatable::_BitSet, uint, and uint32. +
+Referenced by NL3D::CParticleSystemModel::doAnimate(), NL3D::ITransformable::needCompute(), NL3D::IAnimatable::propagateTouch(), and NL3D::CAnimatedMaterial::update(). +
+
00185 { +00186 return _BitSet&(1<<valueId); +00187 } +

+

+ + + + +
+ + + + + + + + + + + + + + + + + + + +
void NL3D::CBone::lodEnableChannels ( CChannelMixer * chanMixer,
bool enable
)
+
+ + + + + +
+ + + +
+enable the channels (lodEnable) associated to this bone in the channelMixer. +
+ +
+Definition at line 259 of file bone.cpp. +
+References _PivotChannelId, _PosChannelId, _RotEulerChannelId, _RotQuatChannelId, _ScaleChannelId, NL3D::CChannelMixer::lodEnableChannel(), and nlassert. +
+
00260 { +00261 nlassert(chanMixer); +00262 +00263 // Lod Enable channels if they are correclty registered to the channelMixer. +00264 if( _PosChannelId>=0 ) +00265 chanMixer->lodEnableChannel(_PosChannelId, enable); +00266 if( _RotEulerChannelId>=0 ) +00267 chanMixer->lodEnableChannel(_RotEulerChannelId, enable); +00268 if( _RotQuatChannelId>=0 ) +00269 chanMixer->lodEnableChannel(_RotQuatChannelId, enable); +00270 if( _ScaleChannelId>=0 ) +00271 chanMixer->lodEnableChannel(_ScaleChannelId, enable); +00272 if( _PivotChannelId>=0 ) +00273 chanMixer->lodEnableChannel(_PivotChannelId, enable); +00274 +00275 } +

+

+ + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + + +
void NL3D::ITransformable::lookAt ( const CVector & eye,
const CVector & target,
float roll = 0.f
) [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.
+
+ +
+Definition at line 169 of file transformable.cpp. +
+References NL3D::ITransformable::DirectMatrix, NLMISC::CMatrix::getPos(), NLMISC::CMatrix::getRot(), NLMISC::CMatrix::identity(), nlassert, NLMISC::CVector::normalize(), NLMISC::CMatrix::rotateY(), NL3D::ITransformable::RotQuat, NL3D::ITransformable::setMatrix(), NL3D::ITransformable::setPivot(), NL3D::ITransformable::setPos(), NLMISC::CMatrix::setPos(), NLMISC::CMatrix::setRot(), NL3D::ITransformable::setRotQuat(), and NL3D::ITransformable::setScale(). +
+Referenced by NL3D::CTransformableUser::lookAt(), and NL3D::CCamera::update(). +
+
00170 { +00171 nlassert(_Mode==RotQuat || _Mode==DirectMatrix); +00172 +00173 // Roll matrix +00174 CMatrix rollMT; +00175 rollMT.identity(); +00176 if (roll!=0.f) +00177 rollMT.rotateY (roll); +00178 +00179 // Make the target base +00180 CVector j=target; +00181 j-=eye; +00182 j.normalize(); +00183 CVector i=j^CVector (0,0,1.f); +00184 CVector k=i^j; +00185 k.normalize(); +00186 i=j^k; +00187 i.normalize(); +00188 +00189 // Make the target matrix +00190 CMatrix targetMT; +00191 targetMT.identity(); +00192 targetMT.setRot (i, j, k); +00193 targetMT.setPos (eye); +00194 +00195 // Compose matrix +00196 targetMT*=rollMT; +00197 +00198 // Set the matrix +00199 if(_Mode==DirectMatrix) +00200 setMatrix (targetMT); +00201 else +00202 { +00203 // transfrom to quaternion mode. +00204 setScale(CVector(1,1,1)); +00205 setPivot(CVector::Null); +00206 setPos(targetMT.getPos()); +00207 setRotQuat(targetMT.getRot()); +00208 } +00209 } +

+

+ + + + +
+ + + + + + + + + + + + + + + + + + + +
void NL3D::CBone::registerToChannelMixer ( CChannelMixer * chanMixer,
const std::string & prefix
) [virtual]
+
+ + + + + +
+ + + +
+register the ITransformable channels as detailled channels. +
+ +
+Implements NL3D::ITransformable. +
+Definition at line 141 of file bone.cpp. +
+References _PivotChannelId, _PosChannelId, _RotEulerChannelId, _RotQuatChannelId, _ScaleChannelId, and NL3D::IAnimatable::addValue(). +
+
00142 { +00143 // For CBone, channels are detailled. +00144 // Bkup each channelId (for disable). +00145 _PosChannelId= addValue(chanMixer, PosValue, OwnerBit, prefix, true); +00146 _RotEulerChannelId= addValue(chanMixer, RotEulerValue, OwnerBit, prefix, true); +00147 _RotQuatChannelId= addValue(chanMixer, RotQuatValue, OwnerBit, prefix, true); +00148 _ScaleChannelId= addValue(chanMixer, ScaleValue, OwnerBit, prefix, true); +00149 _PivotChannelId= addValue(chanMixer, PivotValue, OwnerBit, prefix, true); +00150 +00151 // Deriver note: if necessary, call BaseClass::registerToChannelMixer(chanMixer, prefix); +00152 } +

+

+ + + + +
+ + + + + + + + + + +
void NL3D::IAnimatable::resize ( uint count ) [inline, inherited]
+
+ + + + + +
+ + + +
+Change value count, bit are set to 0
+
Parameters:
+ + +
count is the new value count.
+
+ +
+Definition at line 195 of file animatable.h. +
+References count, nlassert, and uint. +
+
00196 { +00197 // with the "uint32 _BitSet" implementation, juste check the size is correct +00198 nlassert(count<=32); +00199 } +

+

+ + + + +
+ + + + + + + + + + + + + + + + + + + +
void NL3D::IAnimatable::setFather ( IAnimatable * father,
uint fatherOwnerBit
) [inline, inherited]
+
+ + + + + +
+ + + +
+Say which (if any) IAnimatable owns this one. This is important for Touch propagation. By this system, Fathers and ancestors know if they must check their sons (isTouched() return true).
+
Parameters:
+ + + +
father the father we must inform of our update.
fatherOwnerBit What bit of father we must set when we are updated
+
+ +
+Definition at line 153 of file animatable.h. +
+References NL3D::IAnimatable::_Father, NL3D::IAnimatable::_FatherOwnerBit, NL3D::IAnimatable::propagateTouch(), and uint. +
+Referenced by NL3D::CMeshBase::instanciateMeshBase(), and NL3D::CSegRemanence::setAnimatedMaterial(). +
+
00154 { +00155 _Father= father; _FatherOwnerBit= fatherOwnerBit; +00156 +00157 // propagate the touch to the fathers. +00158 propagateTouch(); +00159 } +

+

+ + + + +
+ + + + + + + + + + +
void NL3D::IAnimatable::setFlag ( uint valueId ) [inline, protected, inherited]
+
+ + + + + +
+ + + +
+This method set a bit in the bitset. +
+ +
+Definition at line 239 of file animatable.h. +
+References NL3D::IAnimatable::_BitSet, and uint. +
+Referenced by NL3D::IAnimatable::propagateTouch(), and NL3D::IAnimatable::touch(). +
+
00240 { +00241 _BitSet|= (1<<valueId); +00242 } +

+

+ + + + +
+ + + + + + + + + + +
void NL3D::ITransformable::setMatrix ( const CMatrix & mat ) [inline, inherited]
+
+ + + + + +
+ + + +
+Work only in DirecTMatrix mode (nlassert). +
+ +
+Definition at line 174 of file transformable.h. +
+References NL3D::ITransformable::_LocalMatrixDate, NL3D::ITransformable::DirectMatrix, and nlassert. +
+Referenced by NL3D::ITransformable::lookAt(), and NL3D::CTransformableUser::setMatrix(). +
+
00175 { +00176 nlassert(_Mode==DirectMatrix); +00177 _LocalMatrix= mat; +00178 // The matrix has changed. +00179 _LocalMatrixDate++; +00180 } +

+

+ + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + + +
void NL3D::ITransformable::setPivot ( float x,
float y,
float z
) [inline, inherited]
+
+ + + + + +
+ + + +
+Work only in Rot* mode (nlassert). +
+ +
+Definition at line 169 of file transformable.h. +
+References NL3D::ITransformable::setPivot(), x, y, and z. +
+
00170 { +00171 setPivot(CVector(x, y, z)); +00172 } +

+

+ + + + +
+ + + + + + + + + + +
void NL3D::ITransformable::setPivot ( const CVector & pivot ) [inline, inherited]
+
+ + + + + +
+ + + +
+Work only in Rot* mode (nlassert). +
+ +
+Definition at line 162 of file transformable.h. +
+References NL3D::ITransformable::_Pivot, nlassert, NL3D::ITransformable::PivotValue, NL3D::ITransformable::RotEuler, NL3D::ITransformable::RotQuat, NL3D::IAnimatable::touch(), and NL3D::CAnimatedValueBlendable< T >::Value. +
+Referenced by NL3D::ITransformable::lookAt(), NL3D::CTransformableUser::setPivot(), and NL3D::ITransformable::setPivot(). +
+
00163 { +00164 nlassert(_Mode==RotEuler || _Mode==RotQuat); +00165 _Pivot.Value= pivot; +00166 touch(PivotValue, OwnerBit); +00167 } +

+

+ + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + + +
void NL3D::ITransformable::setPos ( float x,
float y,
float z
) [inline, inherited]
+
+ + + + + +
+ + + +
+Work only in Rot* mode(nlassert). +
+ +
+Definition at line 121 of file transformable.h. +
+References NL3D::ITransformable::setPos(), x, y, and z. +
+
00122 { +00123 setPos(CVector(x,y,z)); +00124 } +

+

+ + + + +
+ + + + + + + + + + +
void NL3D::ITransformable::setPos ( const CVector & pos ) [inline, inherited]
+
+ + + + + +
+ + + +
+Work only in Rot* mode(nlassert). +
+ +
+Definition at line 114 of file transformable.h. +
+References nlassert, NL3D::ITransformable::PosValue, NL3D::ITransformable::RotEuler, NL3D::ITransformable::RotQuat, NL3D::IAnimatable::touch(), and NL3D::CAnimatedValueBlendable< T >::Value. +
+Referenced by NL3D::CCamera::build(), NL3D::ITransformable::lookAt(), NL3D::CTransformableUser::setPos(), NL3D::ITransformable::setPos(), NL3D::CInstanceGroup::setPos(), and NL3D::CPSLight::step(). +
+
00115 { +00116 nlassert(_Mode==RotEuler || _Mode==RotQuat); +00117 _Pos.Value= pos; +00118 touch(PosValue, OwnerBit); +00119 } +

+

+ + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + + +
void NL3D::ITransformable::setRotEuler ( float rotX,
float rotY,
float rotZ
) [inline, inherited]
+
+ + + + + +
+ + + +
+Work only in RotEuler mode(nlassert). +
+ +
+Definition at line 133 of file transformable.h. +
+References NL3D::ITransformable::setRotEuler(). +
+
00134 { +00135 setRotEuler(CVector(rotX, rotY, rotZ)); +00136 } +

+

+ + + + +
+ + + + + + + + + + +
void NL3D::ITransformable::setRotEuler ( const CVector & rot ) [inline, inherited]
+
+ + + + + +
+ + + +
+Work only in RotEuler mode(nlassert). +
+ +
+Definition at line 126 of file transformable.h. +
+References NL3D::ITransformable::_RotEuler, nlassert, NL3D::ITransformable::RotEuler, NL3D::ITransformable::RotEulerValue, NL3D::IAnimatable::touch(), and NL3D::CAnimatedValueBlendable< T >::Value. +
+Referenced by NL3D::CTransformableUser::setRotEuler(), and NL3D::ITransformable::setRotEuler(). +
+
00127 { +00128 nlassert(_Mode==RotEuler); +00129 _RotEuler.Value= rot; +00130 touch(RotEulerValue, OwnerBit); +00131 } +

+

+ + + + +
+ + + + + + + + + + +
void NL3D::ITransformable::setRotQuat ( const CQuat & quat ) [inline, inherited]
+
+ + + + + +
+ + + +
+Work only in RotQuat mode (nlassert). +
+ +
+Definition at line 138 of file transformable.h. +
+References NL3D::ITransformable::_RotQuat, nlassert, NL3D::ITransformable::RotQuat, NL3D::ITransformable::RotQuatValue, NL3D::IAnimatable::touch(), and NL3D::CAnimatedValueBlendable< T >::Value. +
+Referenced by NL3D::CTargetAnimCtrl::execute(), NL3D::ITransformable::lookAt(), NL3D::CTransformableUser::setRotQuat(), and NL3D::CInstanceGroup::setRotQuat(). +
+
00139 { +00140 nlassert(_Mode==RotQuat); +00141 _RotQuat.Value= quat; +00142 touch(RotQuatValue, OwnerBit); +00143 } +

+

+ + + + +
+ + + + + + + + + + +
void NL3D::ITransformable::setScale ( float scale ) [inline, inherited]
+
+ + + + + +
+ + + +
+Work only in Rot* mode (nlassert). +
+ +
+Definition at line 157 of file transformable.h. +
+References NL3D::ITransformable::setScale(). +
+
00158 { +00159 setScale(CVector(scale, scale, scale)); +00160 } +

+

+ + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + + +
void NL3D::ITransformable::setScale ( float scaleX,
float scaleY,
float scaleZ
) [inline, inherited]
+
+ + + + + +
+ + + +
+Work only in Rot* mode (nlassert). +
+ +
+Definition at line 152 of file transformable.h. +
+References NL3D::ITransformable::setScale(). +
+
00153 { +00154 setScale(CVector(scaleX, scaleY, scaleZ)); +00155 } +

+

+ + + + +
+ + + + + + + + + + +
void NL3D::ITransformable::setScale ( const CVector & scale ) [inline, inherited]
+
+ + + + + +
+ + + +
+Work only in Rot* mode (nlassert). +
+ +
+Definition at line 145 of file transformable.h. +
+References nlassert, NL3D::ITransformable::RotEuler, NL3D::ITransformable::RotQuat, NL3D::ITransformable::ScaleValue, NL3D::IAnimatable::touch(), and NL3D::CAnimatedValueBlendable< T >::Value. +
+Referenced by NL3D::ITransformable::lookAt(), NL3D::CTransformableUser::setScale(), and NL3D::ITransformable::setScale(). +
+
00146 { +00147 nlassert(_Mode==RotEuler || _Mode==RotQuat); +00148 _Scale.Value= scale; +00149 touch(ScaleValue, OwnerBit); +00150 } +

+

+ + + + +
+ + + + + + + + + + + + + + + + + + + +
void NL3D::ITransformable::setTransformMode ( TTransformMode mode,
CMatrix::TRotOrder ro = CMatrix::ZXY
) [inline, inherited]
+
+ + + + + +
+ + + +
+Change the transform mode. Components or matrix are not reseted. +
+ +
+Definition at line 100 of file transformable.h. +
+References NL3D::ITransformable::_RotOrder, NL3D::ITransformable::PosValue, and NL3D::IAnimatable::touch(). +
+Referenced by NL3D::CCamera::build(), NL3D::CCamera::enableTargetAnimation(), NL3D::CPSMesh::newElement(), NL3D::CTransformableUser::setTransformMode(), and NL3D::CPSMesh::updatePos(). +
+
00101 { +00102 _Mode= mode; +00103 _RotOrder= ro; +00104 // just for information. +00105 touch(PosValue, OwnerBit); +00106 } +

+

+ + + + +
+ + + + + + + + + + + + + + + + + + + +
void NL3D::IAnimatable::touch ( uint valueId,
uint ownerValueId
) [inline, inherited]
+
+ + + + + +
+ + + +
+Touch a value because it has been modified.
+
Parameters:
+ + + +
valueId is the animated value ID in the object we want to touch.
ownerValueId is the bit of the IAnimatable part which owns this animated value.
+
+ +
+Definition at line 168 of file animatable.h. +
+References NL3D::IAnimatable::propagateTouch(), NL3D::IAnimatable::setFlag(), and uint. +
+Referenced by NL3D::CChannelMixer::eval(), NL3D::CChannelMixer::evalSingleChannel(), NL3D::CParticleSystemModel::reallocRsc(), NL3D::CChannelMixer::refreshList(), NL3D::CCamera::setFov(), NL3D::ITransformable::setPivot(), NL3D::ITransformable::setPos(), NL3D::CCamera::setRoll(), NL3D::ITransformable::setRotEuler(), NL3D::ITransformable::setRotQuat(), NL3D::ITransformable::setScale(), NL3D::CCamera::setTargetPos(), NL3D::ITransformable::setTransformMode(), and NL3D::CParticleSystemInstanceUser::setUserParam(). +
+
00169 { +00170 // Set the bit +00171 setFlag(valueId); +00172 // Set the owner bit +00173 setFlag(ownerValueId); +00174 +00175 // propagate the touch to the fathers. +00176 propagateTouch(); +00177 } +

+

Field Documentation

+ + + + +
+ + +
IAnimCtrl* NL3D::CBone::_AnimCtrl +
+
+ + + + + +
+ + + +
+ +
+Definition at line 166 of file bone.h. +
+Referenced by CBone(), compute(), and NL3D::CSkeletonModel::setBoneAnimCtrl().
+

+ + + + +
+ + +
NLMISC::CRefPtr<CBoneBase> NL3D::CBone::_BoneBase [private] +
+
+ + + + + +
+ + + +
+ +
+Definition at line 173 of file bone.h. +
+Referenced by CBone(), compute(), getBoneBase(), getBoneName(), getDefaultTrack(), and getFatherId().
+

+ + + + +
+ + +
CMatrix NL3D::CBone::_BoneSkinMatrix [private] +
+
+ + + + + +
+ + + +
+ +
+Definition at line 180 of file bone.h. +
+Referenced by compute(), getBoneSkinMatrix(), and interpolateBoneSkinMatrix().
+

+ + + + +
+ + +
CMatrix NL3D::CBone::_LocalSkeletonMatrix [private] +
+
+ + + + + +
+ + + +
+ +
+Definition at line 176 of file bone.h. +
+Referenced by compute(), and getLocalSkeletonMatrix().
+

+ + + + +
+ + +
NLMISC::CBSphere NL3D::CBone::_MaxSphere +
+
+ + + + + +
+ + + +
+ +
+Definition at line 169 of file bone.h. +
+Referenced by NL3D::CSkeletonModel::computeWorldBBoxForShadow().
+

+ + + + +
+ + +
sint NL3D::CBone::_PivotChannelId [private] +
+
+ + + + + +
+ + + +
+ +
+Definition at line 187 of file bone.h. +
+Referenced by CBone(), forceAnimate(), lodEnableChannels(), and registerToChannelMixer().
+

+ + + + +
+ + +
sint NL3D::CBone::_PosChannelId [private] +
+
+ + + + + +
+ + + +
+ +
+Definition at line 183 of file bone.h. +
+Referenced by CBone(), forceAnimate(), lodEnableChannels(), and registerToChannelMixer().
+

+ + + + +
+ + +
sint NL3D::CBone::_RotEulerChannelId [private] +
+
+ + + + + +
+ + + +
+ +
+Definition at line 184 of file bone.h. +
+Referenced by CBone(), forceAnimate(), lodEnableChannels(), and registerToChannelMixer().
+

+ + + + +
+ + +
sint NL3D::CBone::_RotQuatChannelId [private] +
+
+ + + + + +
+ + + +
+ +
+Definition at line 185 of file bone.h. +
+Referenced by CBone(), forceAnimate(), lodEnableChannels(), and registerToChannelMixer().
+

+ + + + +
+ + +
sint NL3D::CBone::_ScaleChannelId [private] +
+
+ + + + + +
+ + + +
+ +
+Definition at line 186 of file bone.h. +
+Referenced by CBone(), forceAnimate(), lodEnableChannels(), and registerToChannelMixer().
+

+ + + + +
+ + +
CMatrix NL3D::CBone::_WorldMatrix [private] +
+
+ + + + + +
+ + + +
+ +
+Definition at line 178 of file bone.h. +
+Referenced by compute(), and getWorldMatrix().
+

The documentation for this class was generated from the following files:

bone.h
bone.cpp

Generated on Tue Mar 16 06:44:38 2004 for NeL by + +

+1.3.6

+ + -- cgit v1.2.1


Herited from IAnimatable
enum	TAnimValues { + OwnerBit = IAnimatable::AnimValueLast, +PosValue, +RotEulerValue, +RotQuatValue, + + ScaleValue, +PivotValue, +AnimValueLast + + }
	Added values. More...
virtual IAnimatedValue *	getValue (uint valueId)
	From IAnimatable.
virtual const char *	getValueName (uint valueId) const
	From IAnimatable.
Public Types
enum	TTransformMode { DirectMatrix = 0, +RotEuler, +RotQuat, +TransformModeCount + }
Public Member Functions
	CBone (CBoneBase *boneBase)
bool	compareMatrixDate (uint64 callerDate) const
void	compute (CBone parent, const CMatrix &rootMatrix, CSkeletonModel skeletonForAnimCtrl)
void	forceAnimate (CChannelMixer &chanMixer)
CBoneBase &	getBoneBase () const
	retrieve the boneBase
const std::string &	getBoneName () const
	retrieve the boneName from BoneBase.
const CMatrix &	getBoneSkinMatrix () const
	retrieve the BoneSkinMatrix computed in compute().
sint32	getFatherId () const
	retrieve the fatherId from BoneBase.
const CMatrix &	getLocalSkeletonMatrix () const
	retrieve the matrix local to the skeleton, computed in compute().
const CMatrix &	getMatrix () const
	Get the matrix, compute her if necessary (work in all modes).
uint64	getMatrixDate () const
const CMatrix &	getWorldMatrix () const
	retrieve the WorldMatrix computed in compute().
void	interpolateBoneSkinMatrix (const CMatrix &otherMatrix, float interp)
void	lodEnableChannels (CChannelMixer *chanMixer, bool enable)
	enable the channels (lodEnable) associated to this bone in the channelMixer.
Herited from ITransformable
virtual ITrack *	getDefaultTrack (uint valueId)
	retrive the default trak from skeleton shape.
virtual void	registerToChannelMixer (CChannelMixer *chanMixer, const std::string &prefix)
	register the ITransformable channels as detailled channels.
Static Public Member Functions
const char *	getPivotValueName ()
const char *	getPosValueName ()
const char *	getRotEulerValueName ()
const char *	getRotQuatValueName ()
const char *	getScaleValueName ()
Data Fields
IAnimCtrl *	_AnimCtrl
NLMISC::CBSphere	_MaxSphere
Protected Member Functions
sint	addValue (CChannelMixer *chanMixer, uint valueId, uint ownerValueId, const std::string &prefix, bool detail)
void	clearFlag (uint valueId)
	This method clear a bit in the bitset.
void	setFlag (uint valueId)
	This method set a bit in the bitset.
Private Attributes
NLMISC::CRefPtr< CBoneBase >	_BoneBase
CMatrix	_BoneSkinMatrix
CMatrix	_LocalSkeletonMatrix
sint	_PivotChannelId
sint	_PosChannelId
sint	_RotEulerChannelId
sint	_RotQuatChannelId
sint	_ScaleChannelId
CMatrix	_WorldMatrix