NL3D::CChannelMixer Class Reference

#include <channel_mixer.h>

Inheritance diagram for NL3D::CChannelMixer:

---

Detailed Description

A channel mixer. Animated value are registred in it. Each animated value create a channel in the mixer. Then, mixer animates all those channels with 1 to CChannelMixer::NumAnimationSlot animations.

Animation are referenced in an animation slot (CSlot).

Each slot have an IAnimation pointer, a weight for this animation between [0.f ~ 1.f] and a time for this animation.

Each CChannel have a weight on each animation slot between [0.f ~ 1.f].

Blending is normalized internaly so, weight sum have not to be == 1.f.

Author:

Cyril 'Hulud' Corvazier

Nevrax France

Date:

2001

Definition at line 64 of file channel_mixer.h.

Slots acces
void	applySkeletonWeight (uint slot, uint skeleton, bool invert=false)
void	emptySlot (uint slot)
const CAnimation *	getSlotAnimation (uint slot) const
	Get the animation used by a given slot.
void	resetEvalDetailDate ()
	reset to -1 the evalDetailDate. Hence next eval(true,..) will be forced to compute
void	resetSkeletonWeight (uint slot)
void	resetSlots ()
void	setSlotAnimation (uint slot, uint animation)
void	setSlotTime (uint slot, TAnimationTime time)
void	setSlotWeight (uint slot, float weight)
void	cleanAll ()
	Clean the mixer.
void	dirtAll ()
	Dirt all slots.
void	evalSingleChannel (CChannel &chan, uint numActiveSlots, uint activeSlot[NumAnimationSlot])
void	refreshList ()
	Reshresh channel list.
void	refreshListToEval ()
	Reshresh animate list.
const CAnimationSet *	_AnimationSet
std::map< uint, CChannel >	_Channels
std::vector< CChannel * >	_DetailListToEval
bool	_Dirt
CChannel *	_FirstChannelDetail
CChannel *	_FirstChannelGlobal
std::vector< CChannel * >	_GlobalListToEval
sint64	_LastEvalDetailDate
bool	_ListToEvalDirt
CSlot	_SlotArray [NumAnimationSlot]
Public Types
Const values
enum	{ NumAnimationSlot = 8 }
Public Member Functions
const sint &	getRefCount () const
Channel access
sint	addChannel (const std::string &channelName, IAnimatable *animatable, IAnimatedValue *value, ITrack *defaultValue, uint32 valueId, uint32 ownerValueId, bool detail)
void	enableChannel (uint channelId, bool enable)
bool	isChannelEnabled (uint channelId) const
bool	isChannelLodEnabled (uint channelId) const
void	lodEnableChannel (uint channelId, bool enable)
void	resetChannels ()
	Reset the channel list if the mixer. All channels are removed from the mixer.
Internal classes
	CChannelMixer ()
	Constructor. The default constructor resets the slots and the channels.
Setup the mixer
void	eval (bool detail, uint64 evalDetailDate=0)
void	evalChannels (sint *channelIdArray, uint numID)
void	evalSingleChannel (sint channelId)
const CAnimationSet *	getAnimationSet () const
void	setAnimationSet (const CAnimationSet *animationSet)
Data Fields
sint	crefs
CPtrInfo *	pinfo
Static Public Attributes
CPtrInfo	NullPtrInfo
Friends
struct	CPtrInfo

---

Member Enumeration Documentation

anonymous enum

Enumeration values: NumAnimationSlot  Number of animation slot in the CChannelMixer. Definition at line 70 of file channel_mixer.h. { NumAnimationSlot=8 };

---

Constructor & Destructor Documentation

NL3D::CChannelMixer::CChannelMixer (   )

Constructor. The default constructor resets the slots and the channels. Definition at line 44 of file channel_mixer.cpp. References _FirstChannelDetail, _FirstChannelGlobal, _LastEvalDetailDate, and _ListToEvalDirt. { // No channel in the list _FirstChannelGlobal=NULL; _FirstChannelDetail=NULL; // No animation set _AnimationSet=NULL; // Mixer no dirty _Dirt=false; _ListToEvalDirt= false; // never evaluated. _LastEvalDetailDate= -1; }

---

Member Function Documentation

sint NL3D::CChannelMixer::addChannel (  const std::string &  channelName, IAnimatable *  animatable, IAnimatedValue *  value, ITrack *  defaultValue, uint32  valueId, uint32  ownerValueId, bool  detail )

Add a channel for a specific value of an IAnimatable object. Warning: this method will assign the default value in the animated value. Parameters: channelName  is the name of the channel. animatable  is a pointer on the IAnimatable object in which the value is stored. It will be kept by the CChannelMixer until it is removed from the channel. value  is a pointer on the value the channel works with. It will be kept by the CChannelMixer until it is removed from the channel. defaultValue  is a track used by default if a track is not presents in the animation for this channel. It will be kept by the CChannelMixer until it is removed from the channel. valueId  is the value ID in the IAnimatable object. ownerId  is the owner Bit of the animated vlaue, in the IAnimatable object. touched when the animatedvalue is touched. detail  true if this channel must be evaluated in detail mode (see eval()). 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 306 of file channel_mixer.cpp. References NL3D::CChannelMixer::CChannel::_ChannelName, _Channels, NL3D::CChannelMixer::CChannel::_DefaultTracks, NL3D::CChannelMixer::CChannel::_Detail, NL3D::CChannelMixer::CChannel::_IsQuat, NL3D::CChannelMixer::CChannel::_Object, NL3D::CChannelMixer::CChannel::_OwnerValueId, NL3D::CChannelMixer::CChannel::_Tracks, NL3D::CChannelMixer::CChannel::_Value, NL3D::CChannelMixer::CChannel::_ValueId, NL3D::CChannelMixer::CChannel::_Weights, dirtAll(), NL3D::CAnimationSet::getChannelIdByName(), nlassert, NumAnimationSlot, s, sint, uint, uint32, and value. Referenced by NL3D::IAnimatable::addValue(), and NL3D::CScene::setAutomaticAnimationSet(). { // Check the animationSet has been set nlassert (_AnimationSet); // Check args nlassert (animatable); nlassert (value); nlassert (defaultValue); // Get the channel Id having the same name than the tracks in this animation set. uint iDInAnimationSet=_AnimationSet->getChannelIdByName (channelName); // Tracks exist in this animation set? if (iDInAnimationSet!=CAnimationSet::NotFound) { // The channel entry CChannel entry; // Set the channel name entry._ChannelName=channelName; // Set the object pointer entry._Object=animatable; // Set the pointer on the value in the object entry._Value=value; // Is this a CQuat animated value??? entry._IsQuat= (typeid (*(entry._Value))==typeid (CAnimatedValueBlendable<NLMISC::CQuat>))!=0; // Set the default track pointer entry._DefaultTracks=defaultValue; // Set the value ID in the object entry._ValueId=valueId; // Set the First value ID in the object entry._OwnerValueId=ownerValueId; // in what mode is the channel? entry._Detail= detail; // All weights default to 1. All Tracks default to defaultTrack. for(sint s=0;s<NumAnimationSlot;s++) { entry._Weights[s]= 1.0f; entry._Tracks[s]= entry._DefaultTracks; } // add (if not already done) the entry in the map. _Channels[iDInAnimationSet]= entry; // Dirt all the slots dirtAll (); // Affect the default value in the animated value entry._Value->affect (entry._DefaultTracks->getValue()); // Touch the animated value and its owner to recompute them later. entry._Object->touch (entry._ValueId, entry._OwnerValueId); // return the id. return iDInAnimationSet; } else { // return Not found. return -1; } }

void NL3D::CChannelMixer::applySkeletonWeight (  uint  slot, uint  skeleton, bool  invert = false )

Apply a skeleton template weight on a specific slot. This method apply the weight of each node contains in skelWeight to the channel's slot weight. Parameters: slot  is the slot number to empty. Must be >= 0 and < NumAnimationSlot. skeleton  is the index of a skeleton in the animationSet. invert  is true if the weights to attach to the channels are the weights of the skeleton template. false if the weights to attach to the channels are the 1.f-weights of the skeleton template. Definition at line 516 of file channel_mixer.cpp. References _Channels, NL3D::CChannelMixer::CSlot::_InvertedSkeletonWeight, NL3D::CChannelMixer::CSlot::_SkeletonWeight, _SlotArray, NL3D::CAnimationSet::getChannelIdByName(), NL3D::CSkeletonWeight::getNodeName(), NL3D::CSkeletonWeight::getNodeWeight(), NL3D::CSkeletonWeight::getNumNode(), NL3D::CAnimationSet::getSkeletonWeight(), nlassert, NumAnimationSlot, and uint. Referenced by NL3D::CAnimationPlaylist::setupMixer(). { // Check alot arg nlassert (slot<NumAnimationSlot); // Check the animationSet has been set nlassert (_AnimationSet); // Get the skeleton weight const CSkeletonWeight *pSkeleton=_AnimationSet->getSkeletonWeight (skeleton); // Something to change ? if ((pSkeleton!=_SlotArray[slot]._SkeletonWeight)||(invert!=_SlotArray[slot]._InvertedSkeletonWeight)) { // Set the current skeleton _SlotArray[slot]._SkeletonWeight=pSkeleton; _SlotArray[slot]._InvertedSkeletonWeight=invert; // Get number of node in the skeleton weight uint sizeSkel=pSkeleton->getNumNode (); // For each entry of the skeleton weight for (uint n=0; n<sizeSkel; n++) { // Get the name of the channel for this node const string& channelName=pSkeleton->getNodeName (n); // Get the channel Id having the same name than the tracks in this animation set. uint channelId=_AnimationSet->getChannelIdByName (channelName); // Tracks exist in this animation set? if (channelId!=CAnimationSet::NotFound) { // Get the weight of the channel for this node float weight=pSkeleton->getNodeWeight (n); // Set the weight of this channel for this slot (only if channel setuped!!) std::map<uint, CChannel>::iterator ite=_Channels.find(channelId); if (ite!=_Channels.end()) ite->second._Weights[slot]=invert?1.f-weight:weight; } } } }

void NL3D::CChannelMixer::cleanAll (   )  [private]

Clean the mixer. Definition at line 587 of file channel_mixer.cpp. References NL3D::CChannelMixer::CSlot::_Dirt, _SlotArray, NumAnimationSlot, s, and uint. Referenced by eval(), and evalChannels(). { // For each slot for (uint s=0; s<NumAnimationSlot; s++) { // Clean it _SlotArray[s]._Dirt=false; } // Clean the mixer _Dirt=false; }

void NL3D::CChannelMixer::dirtAll (   )  [private]

Dirt all slots. Definition at line 602 of file channel_mixer.cpp. References NL3D::CChannelMixer::CSlot::_Dirt, _SlotArray, NL3D::CChannelMixer::CSlot::isEmpty(), NumAnimationSlot, s, and uint. Referenced by addChannel(), and resetChannels(). { // For each slot for (uint s=0; s<NumAnimationSlot; s++) { // Dirt if (!_SlotArray[s].isEmpty()) { // Dirt it _SlotArray[s]._Dirt=true; // Dirt the mixer _Dirt=true; } } }

void NL3D::CChannelMixer::emptySlot (  uint  slot  )

Empty a slot. Calling this method will dirt the mixer, ie, all the mixer's channels will be visited to check if they are used by the old animation. If they are, they will be linked in the internal CChannel list. Warning: this method will assign the default value in the animated value that are removed from the active channel queue. Parameters: slot  is the slot number to empty. Must be >= 0 and < NumAnimationSlot. Definition at line 485 of file channel_mixer.cpp. References NL3D::CChannelMixer::CSlot::_Dirt, _SlotArray, NL3D::CChannelMixer::CSlot::empty(), NL3D::CChannelMixer::CSlot::isEmpty(), nlassert, NumAnimationSlot, and uint. Referenced by resetSlots(), and NL3D::CAnimationPlaylist::setupMixer(). { // Check alot arg nlassert (slot<NumAnimationSlot); // Does this animation already empty ? if (!_SlotArray[slot].isEmpty ()) { // Change it _SlotArray[slot].empty (); // Dirt it _SlotArray[slot]._Dirt=true; // Dirt the mixer _Dirt=true; } }

void NL3D::CChannelMixer::enableChannel (  uint  channelId, bool  enable )

disabling a channel means it is no more modified during animation. Default is enabled. NB: this channel must have been added (via addChannel()....). Parameters: channelId  channelId get from CAnimationSet::getChannelIdByName() or addChannel() Definition at line 389 of file channel_mixer.cpp. References _Channels, _ListToEvalDirt, and uint. Referenced by NL3D::CPlayListUser::enableChannel(). { std::map<uint, CChannel>::iterator it= _Channels.find(channelId); if(it!=_Channels.end()) { it->second._EnableFlags &= ~CChannel::EnableUserFlag; if(enable) it->second._EnableFlags |= CChannel::EnableUserFlag; // Must recompute the channels to animate. _ListToEvalDirt= true; } }

void NL3D::CChannelMixer::eval (  bool  detail, uint64  evalDetailDate = 0 )

Launch evaluation of all channels. This is the main method. It evals animations selected in the slots for listed channels. Only the channels that are animated by animations selected in the slots are evaluated. They are stored in a linked list managed by the channel array. Others are initialized with the default channel value. Parameters: detail  true if eval the detail part of animation. (done after clipping). evalDetailDate  chann mixer store the last date of anim detail evaluated. if same, do nothing, else if < or >, compute the anim. ingored if detail is false. Definition at line 154 of file channel_mixer.cpp. References _DetailListToEval, _GlobalListToEval, _LastEvalDetailDate, _ListToEvalDirt, NL3D::CChannelMixer::CChannel::_Object, NL3D::CChannelMixer::CChannel::_OwnerValueId, _SlotArray, NL3D::CChannelMixer::CSlot::_Time, NL3D::CChannelMixer::CChannel::_Tracks, NL3D::CChannelMixer::CChannel::_Value, NL3D::CChannelMixer::CChannel::_ValueId, NL3D::CChannelMixer::CSlot::_Weight, NL3D::CChannelMixer::CChannel::_Weights, NL3D::IAnimatedValue::affect(), cleanAll(), evalSingleChannel(), NL3D::ITrack::getValue(), NL3D::CChannelMixer::CSlot::isEmpty(), nlassert, NumAnimationSlot, refreshList(), refreshListToEval(), s, sint64, NL3D::TAnimationTime, NL3D::IAnimatable::touch(), uint, and uint64. Referenced by NL3D::CLodCharacterBuilder::addAnim(), NL3D::CSkeletonModel::computeCurrentBBox(), NL3D::CPlayListUser::evalPlayList(), NL3D::CTransform::traverseAnimDetailWithoutUpdateWorldMatrix(), and NL3D::CMeshBaseInstance::traverseHrc(). { // eval the detail animation only one time per scene traversal. if(detail) { if((sint64)evalDetailDate== _LastEvalDetailDate) return; _LastEvalDetailDate= evalDetailDate; } // clean list according to anim setup if(_Dirt) { refreshList(); cleanAll(); } // clean eval list, according to channels enabled. if(_ListToEvalDirt) { refreshListToEval(); nlassert(!_ListToEvalDirt); } // If the number of channels to draw is 0, quick quit. CChannel **channelArrayPtr; uint numChans; if(detail) { numChans= _DetailListToEval.size(); if(numChans) channelArrayPtr= &_DetailListToEval[0]; else return; } else { numChans= _GlobalListToEval.size(); if(numChans) channelArrayPtr= &_GlobalListToEval[0]; else return; } // Setup an array of animation that are not empty and stay. HTimer: 0.0% (because CLod skeletons not parsed here) uint numActive=0; uint activeSlot[NumAnimationSlot]; for (uint s=0; s<NumAnimationSlot; s++) { // Dirt, not empty and has an influence? (add) if (!_SlotArray[s].isEmpty() && _SlotArray[s]._Weight>0) // Add a dirt slot activeSlot[numActive++]=s; } // no slot enabled at all?? skip if(numActive==0) return; // For each selected channel // fast 'just one slot Activated' version if(numActive==1) { // Slot number uint slot=activeSlot[0]; // Slot time TAnimationTime slotTime= _SlotArray[slot]._Time; // For all channels for(;numChans>0; numChans--, channelArrayPtr++) { CChannel &chan= **channelArrayPtr; // if Current blend factor is not 0 if(chan._Weights[slot]!=0.0f) { // Eval the track at this time. HTimer: 0.7% ((ITrack*)chan._Tracks[slot])->eval (slotTime); // Copy the interpolated value. HTimer: 0.7% chan._Value->affect (chan._Tracks[slot]->getValue()); // Touch the animated value and its owner to recompute them later. HTimer: 0.6% chan._Object->touch (chan._ValueId, chan._OwnerValueId); } } } // little bit slower Blend version else { // For all channels for(;numChans>0; numChans--, channelArrayPtr++) { CChannel *pChannel= *channelArrayPtr; evalSingleChannel(**channelArrayPtr, numActive, activeSlot); } } }

void NL3D::CChannelMixer::evalChannels (  sint *  channelIdArray, uint  numID )

Launch evaluation of some channels. Parameters: channelIdArray  array that contains the id of the channel to eval. numID  number of ids in the array Definition at line 255 of file channel_mixer.cpp. References _Channels, _ListToEvalDirt, _SlotArray, NL3D::CChannelMixer::CSlot::_Weight, cleanAll(), evalSingleChannel(), NL3D::CChannelMixer::CSlot::isEmpty(), nlassert, NumAnimationSlot, refreshList(), refreshListToEval(), s, sint, and uint. Referenced by evalSingleChannel(), and NL3D::CBone::forceAnimate(). { if (!channelIdArray) return; if (numID == 0) return; // Setup an array of animation that are not empty and stay uint numActive=0; uint activeSlot[NumAnimationSlot]; // clean list according to anim setup if(_Dirt) { refreshList(); cleanAll(); } // clean eval list, according to channels enabled. if(_ListToEvalDirt) { refreshListToEval(); nlassert(!_ListToEvalDirt); } // Setup it up for (uint s=0; s<NumAnimationSlot; s++) { // Dirt, not empty and has an influence? (add) if (!_SlotArray[s].isEmpty() && _SlotArray[s]._Weight>0) // Add a dirt slot activeSlot[numActive++]=s; } // no slot enabled at all?? skip if(numActive==0) return; for(uint k = 0; k < numID; ++k) { std::map<uint, CChannel>::iterator it = _Channels.find(channelIdArray[k]); if (it != _Channels.end()) { evalSingleChannel(it->second, numActive, activeSlot); } } }

void NL3D::CChannelMixer::evalSingleChannel (  CChannel &  chan, uint  numActiveSlots, uint  activeSlot[NumAnimationSlot] )  [private]

Force evaluation of a single channel Parameters: chan  the channel to eval numActiveSlots  number of active slots activeSlot  array of contiguous slots ids (there are 'numActiveSlots' of them) Definition at line 83 of file channel_mixer.cpp. References NL3D::CChannelMixer::CChannel::_IsQuat, NL3D::CChannelMixer::CChannel::_Object, NL3D::CChannelMixer::CChannel::_OwnerValueId, _SlotArray, NL3D::CChannelMixer::CChannel::_Tracks, NL3D::CChannelMixer::CChannel::_Value, NL3D::CChannelMixer::CChannel::_ValueId, NL3D::CChannelMixer::CSlot::_Weight, NL3D::CChannelMixer::CChannel::_Weights, NL3D::IAnimatedValue::affect(), NL3D::IAnimatedValue::blend(), NL3D::ITrack::getValue(), NL3D::IAnimatable::touch(), uint, and NL3D::CAnimatedValueBlendable< T >::Value. { // For Quat animated value only. CQuat firstQuat; // First slot found bool bFirst=true; // Last blend factor float lastBlend=0.0; // Eval each slot for (uint a=0; a<numActive; a++) { // Slot number uint slot=activeSlot[a]; // Current blend factor float blend=chan._Weights[slot]*_SlotArray[slot]._Weight; if(blend!=0.0f) { // Eval the track at this time ((ITrack*)chan._Tracks[slot])->eval (_SlotArray[slot]._Time); // First track to be eval ? if (bFirst) { // If channel is a Quaternion animated Value, must store the first Quat. if (chan._IsQuat) { CAnimatedValueBlendable<NLMISC::CQuat> *pQuatValue=(CAnimatedValueBlendable<NLMISC::CQuat>*)&chan._Tracks[slot]->getValue(); firstQuat=pQuatValue->Value; } // Copy the interpolated value chan._Value->affect (chan._Tracks[slot]->getValue()); // First blend factor lastBlend=blend; // Not first anymore bFirst=false; } else { // If channel is a Quaternion animated Value, must makeClosest the ith result of the track, from firstQuat. if (chan._IsQuat) { CAnimatedValueBlendable<NLMISC::CQuat> *pQuatValue=(CAnimatedValueBlendable<NLMISC::CQuat>*)&chan._Tracks[slot]->getValue(); pQuatValue->Value.makeClosest (firstQuat); } // Blend with this value and the previous sum chan._Value->blend (chan._Tracks[slot]->getValue(), lastBlend/(lastBlend+blend)); // last blend update lastBlend+=blend; } } // NB: if all weights are 0, the AnimatedValue is not modified... } // Touch the animated value and its owner to recompute them later. chan._Object->touch (chan._ValueId, chan._OwnerValueId); }

void NL3D::CChannelMixer::evalSingleChannel (  sint  channelId  )  [inline]

Force evaluation of a single channel Definition at line 481 of file channel_mixer.h. References evalChannels(), and sint. Referenced by eval(), and evalChannels(). { evalChannels(&channelId, 1); }

const CAnimationSet * NL3D::CChannelMixer::getAnimationSet (   )  const

Get the animation set used by this channel mixer. The pointer is hold by the channel mixer until it changes. Return NULL if no animationSet defined. Definition at line 74 of file channel_mixer.cpp. Referenced by NL3D::CAnimationPlaylist::setupMixer(). { // Return the animationSet Pointer return _AnimationSet; }

const sint& NLMISC::CRefCount::getRefCount (   )  const [inline, inherited]

Definition at line 70 of file smart_ptr.h. References NLMISC::CRefCount::crefs, and sint. { return crefs; }

const CAnimation * NL3D::CChannelMixer::getSlotAnimation (  uint  slot  )  const

Get the animation used by a given slot. Definition at line 476 of file channel_mixer.cpp. References NL3D::CChannelMixer::CSlot::_Animation, _SlotArray, nlassert, NumAnimationSlot, and uint. Referenced by NL3D::CMeshBaseInstance::traverseHrc(). { nlassert(slot < NumAnimationSlot); return _SlotArray[slot]._Animation; }

bool NL3D::CChannelMixer::isChannelEnabled (  uint  channelId  )  const

see enableChannel(). return false if channel do not exist... Parameters: channelId  channelId get from CAnimationSet::getChannelIdByName() or addChannel() Definition at line 405 of file channel_mixer.cpp. References _Channels, and uint. Referenced by NL3D::CPlayListUser::isChannelEnabled(). { std::map<uint, CChannel>::const_iterator it= _Channels.find(channelId); if(it!=_Channels.end()) { return (it->second._EnableFlags & CChannel::EnableUserFlag) != 0; } else return false; }

bool NL3D::CChannelMixer::isChannelLodEnabled (  uint  channelId  )  const

see enableChannel(). return false if channel do not exist... Parameters: channelId  channelId get from CAnimationSet::getChannelIdByName() or addChannel() Definition at line 434 of file channel_mixer.cpp. References _Channels, and uint. { std::map<uint, CChannel>::const_iterator it= _Channels.find(channelId); if(it!=_Channels.end()) { return (it->second._EnableFlags & CChannel::EnableLodFlag) != 0; } else return false; }

void NL3D::CChannelMixer::lodEnableChannel (  uint  channelId, bool  enable )

Same as enableChannel but for Animation Lod system. The channel is animated only if both enableChannel() and lodEnableChannel() are true. Default is enabled. NB: this channel must have been added (via addChannel()....). Parameters: channelId  channelId get from CAnimationSet::getChannelIdByName() or addChannel() Definition at line 418 of file channel_mixer.cpp. References _Channels, _ListToEvalDirt, and uint. Referenced by NL3D::CBone::lodEnableChannels(). { std::map<uint, CChannel>::iterator it= _Channels.find(channelId); if(it!=_Channels.end()) { it->second._EnableFlags &= ~CChannel::EnableLodFlag; if(enable) it->second._EnableFlags |= CChannel::EnableLodFlag; // Must recompute the channels to animate. _ListToEvalDirt= true; } }

void NL3D::CChannelMixer::refreshList (   )  [private]

Reshresh channel list. Definition at line 621 of file channel_mixer.cpp. References NL3D::CChannelMixer::CSlot::_Animation, NL3D::CChannelMixer::CChannel::_ChannelName, _Channels, NL3D::CChannelMixer::CChannel::_DefaultTracks, NL3D::CChannelMixer::CChannel::_Detail, NL3D::CChannelMixer::CSlot::_Dirt, _FirstChannelDetail, _FirstChannelGlobal, NL3D::CChannelMixer::CChannel::_InTheList, _ListToEvalDirt, NL3D::CChannelMixer::CChannel::_Next, NL3D::CChannelMixer::CChannel::_Object, NL3D::CChannelMixer::CChannel::_OwnerValueId, _SlotArray, NL3D::CChannelMixer::CChannel::_Tracks, NL3D::CChannelMixer::CChannel::_Value, NL3D::CChannelMixer::CChannel::_ValueId, NL3D::IAnimatedValue::affect(), NL3D::CAnimation::getIdTrackByName(), NL3D::ITrack::getValue(), NL3D::CChannelMixer::CSlot::isEmpty(), NumAnimationSlot, s, NL3D::IAnimatable::touch(), and uint. Referenced by eval(), and evalChannels(). { // Setup an array of animation to add uint numAdd=0; uint addSlot[NumAnimationSlot]; // Setup an array of animation that are not empty and stay uint numStay=0; uint staySlot[NumAnimationSlot]; // Setup it up uint s; for (s=0; s<NumAnimationSlot; s++) { // Dirt and not empty ? (add) if ((_SlotArray[s]._Dirt)&&(!_SlotArray[s].isEmpty())) // Add a dirt slot addSlot[numAdd++]=s; // Not empty and not dirt ? (stay) if ((!_SlotArray[s]._Dirt)&&(!_SlotArray[s].isEmpty())) // Add a dirt slot staySlot[numStay++]=s; } // Last channel pointer CChannel **lastPointerGlobal=&_FirstChannelGlobal; CChannel **lastPointerDetail=&_FirstChannelDetail; // Now scan each channel map<uint, CChannel>::iterator itChannel; for(itChannel= _Channels.begin(); itChannel!=_Channels.end();itChannel++) { CChannel &channel= (*itChannel).second; // Add this channel to the list if true bool add=false; // For each slot to add for (s=0; s<numAdd; s++) { // Find the index of the channel track in the animation set uint iDTrack=_SlotArray[addSlot[s]]._Animation->getIdTrackByName (channel._ChannelName); // If this track exist if (iDTrack!=CAnimation::NotFound) { // Set the track channel._Tracks[addSlot[s]]=_SlotArray[addSlot[s]]._Animation->getTrack (iDTrack); // Add this channel to the list add=true; } else { // Set the default track channel._Tracks[addSlot[s]]=channel._DefaultTracks; } } // Add this channel to the list ? if (!add) { // Was it in the list ? if (channel._InTheList) { // Check if this channel is still in use // For each slot in the stay list for (s=0; s<numStay; s++) { // Use anything interesting ? if (channel._Tracks[staySlot[s]]!=channel._DefaultTracks) { // Ok, add it to the list add=true; // Stop break; } } // Still in use? if (!add) { // Set it's value to default and touch it's object channel._Value->affect (channel._DefaultTracks->getValue()); channel._Object->touch (channel._ValueId, channel._OwnerValueId); } } } // Do i have to add the channel to the list if (add) { // It is in the list channel._InTheList=true; if(channel._Detail) { // Set the last pointer value *lastPointerDetail=&channel; // Change last pointer lastPointerDetail=&channel._Next; } else { // Set the last pointer value *lastPointerGlobal=&channel; // Change last pointer lastPointerGlobal=&channel._Next; } } else { // It is not in the list channel._InTheList=false; } } // End of the list *lastPointerGlobal=NULL; *lastPointerDetail=NULL; // Must recompute the channels to animate. _ListToEvalDirt= true; }

void NL3D::CChannelMixer::refreshListToEval (   )  [private]

Reshresh animate list. Definition at line 753 of file channel_mixer.cpp. References _Channels, _DetailListToEval, NL3D::CChannelMixer::CChannel::_EnableFlags, _FirstChannelDetail, _FirstChannelGlobal, _GlobalListToEval, _ListToEvalDirt, and NL3D::CChannelMixer::CChannel::_Next. Referenced by eval(), and evalChannels(). { CChannel* pChannel; /* NB: this save if(), especially when Used with Skeleton, and CLod mode */ // Global list. _GlobalListToEval.clear(); _GlobalListToEval.reserve(_Channels.size()); pChannel=_FirstChannelGlobal; while(pChannel) { // if the channel is enabled (both user and lod), must eval all active slot. if(pChannel->_EnableFlags == CChannel::EnableAllFlag) _GlobalListToEval.push_back(pChannel); // next pChannel= pChannel->_Next; } // Global list. _DetailListToEval.clear(); _DetailListToEval.reserve(_Channels.size()); pChannel=_FirstChannelDetail; while(pChannel) { // if the channel is enabled (both user and lod), must eval all active slot. if(pChannel->_EnableFlags == CChannel::EnableAllFlag) _DetailListToEval.push_back(pChannel); // next pChannel= pChannel->_Next; } // done _ListToEvalDirt= false; }

void NL3D::CChannelMixer::resetChannels (   )

Reset the channel list if the mixer. All channels are removed from the mixer. Definition at line 381 of file channel_mixer.cpp. References _Channels, and dirtAll(). Referenced by NL3D::CPlayListUser::resetAllChannels(), and setAnimationSet(). { _Channels.clear(); dirtAll (); }

void NL3D::CChannelMixer::resetEvalDetailDate (   )

reset to -1 the evalDetailDate. Hence next eval(true,..) will be forced to compute Definition at line 791 of file channel_mixer.cpp. References _LastEvalDetailDate. Referenced by NL3D::CSkeletonModel::computeCurrentBBox(). { _LastEvalDetailDate= -1; }

void NL3D::CChannelMixer::resetSkeletonWeight (  uint  slot  )

Reset the skeleton weight for a specific slot. This method apply set each channel's slot weight to 1.f. Parameters: slot  is the slot number to empty. Must be >= 0 and < NumAnimationSlot. Definition at line 563 of file channel_mixer.cpp. References _Channels, NL3D::CChannelMixer::CSlot::_InvertedSkeletonWeight, NL3D::CChannelMixer::CSlot::_SkeletonWeight, _SlotArray, nlassert, NumAnimationSlot, and uint. Referenced by NL3D::CAnimationPlaylist::setupMixer(). { // Check alot arg nlassert (slot<NumAnimationSlot); // Something to change ? if (_SlotArray[slot]._SkeletonWeight!=NULL) { // Set skeleton _SlotArray[slot]._SkeletonWeight=NULL; _SlotArray[slot]._InvertedSkeletonWeight=false; // For each channels map<uint, CChannel>::iterator itChannel; for(itChannel= _Channels.begin(); itChannel!=_Channels.end();itChannel++) { // Reset (*itChannel).second._Weights[slot]=1.f; } } }

void NL3D::CChannelMixer::resetSlots (   )

Reset the slot of the mixer. All slot will be empty. Calling this method will dirt the mixer, ie, all the mixer's channels will be visited to check if they are used by the old animation. If they are, they will be linked in the internal CChannel list. Definition at line 506 of file channel_mixer.cpp. References emptySlot(), NumAnimationSlot, s, and uint. { // Empty all slots for (uint s=0; s<NumAnimationSlot; s++) // Empty it emptySlot (s); }

void NL3D::CChannelMixer::setAnimationSet (  const CAnimationSet *  animationSet  )

Set the animation set used by this channel mixer. The pointer is hold by the channel mixer until it changes. Definition at line 63 of file channel_mixer.cpp. References resetChannels(). Referenced by NL3D::CLodCharacterBuilder::addAnim(), NL3D::CPlayListUser::CPlayListUser(), NL3D::CScene::createInstance(), and NL3D::CScene::setAutomaticAnimationSet(). { // Set the animationSet Pointer _AnimationSet=animationSet; // clear the channels. resetChannels(); }

void NL3D::CChannelMixer::setSlotAnimation (  uint  slot, uint  animation )

Set slot animation. You must set an animationSet in the channel mixer before calling this. Calling this method will dirt the mixer, ie, all the mixer's channels will be visited to check if they are used by the new animation. If they are, they will be linked in the internal CChannel list. Parameters: slot  is the slot number to change the animation. Must be >= 0 and < NumAnimationSlot. animation  is the new animation index in the animationSet use by this slot. See also: CAnimationSet, CAnimation Definition at line 449 of file channel_mixer.cpp. References NL3D::CChannelMixer::CSlot::_Animation, NL3D::CChannelMixer::CSlot::_Dirt, _SlotArray, NL3D::CAnimationSet::getAnimation(), nlassert, NumAnimationSlot, and uint. Referenced by NL3D::CLodCharacterBuilder::addAnim(), NL3D::CScene::createInstance(), and NL3D::CAnimationPlaylist::setupMixer(). { // Check alot arg nlassert (slot<NumAnimationSlot); // Check an animationSet as been set. nlassert (_AnimationSet); // Find the animation pointer for this animation const CAnimation* pAnimation=_AnimationSet->getAnimation (animation); // Does this animation change ? if (_SlotArray[slot]._Animation!=pAnimation) { // Change it _SlotArray[slot]._Animation=pAnimation; // Dirt it _SlotArray[slot]._Dirt=true; // Dirt the mixer _Dirt=true; } }

void NL3D::CChannelMixer::setSlotTime (  uint  slot, TAnimationTime  time )  [inline]

Set time of a slot. This time will be used to eval the animation set in this slot. Each slot can have different time. Calling this method won't dirt the mixer. Parameters: slot  is the slot number to change the time. Must be >= 0 and < NumAnimationSlot. time  is the new time to use in the slot. See also: TAnimationTime Definition at line 345 of file channel_mixer.h. References _SlotArray, NL3D::CChannelMixer::CSlot::_Time, nlassert, NumAnimationSlot, NL3D::TAnimationTime, and uint. Referenced by NL3D::CLodCharacterBuilder::addAnim(), NL3D::CAnimationPlaylist::setupMixer(), and NL3D::CMeshBaseInstance::traverseHrc(). { // Check alot arg nlassert (slot<NumAnimationSlot); // Set the time _SlotArray[slot]._Time=time; }

void NL3D::CChannelMixer::setSlotWeight (  uint  slot, float  weight )  [inline]

Set slot weight. This weight will be used to eval the animation set in this slot. Each slot can have different weight. Calling this method won't dirt the mixer. By default the weight of the slot is 1.0f. Parameters: slot  is the slot number to change the weight. weight  is the new weight to use in the slot. No range for this weight. If the weight == 0.f, the slot have no effect on the final mix. Definition at line 366 of file channel_mixer.h. References _SlotArray, NL3D::CChannelMixer::CSlot::_Weight, nlassert, NumAnimationSlot, and uint. Referenced by NL3D::CAnimationPlaylist::setupMixer(). { // Check alot arg nlassert (slot<NumAnimationSlot); // Set the time _SlotArray[slot]._Weight=weight; }

---

Friends And Related Function Documentation

friend struct CPtrInfo [friend, inherited]

Definition at line 67 of file smart_ptr.h.

---

Field Documentation

const CAnimationSet* NL3D::CChannelMixer::_AnimationSet [private]

Apply a skeleton template weight on a specific slot. This method apply the weight of each node contains in skelWeight to the channel's slot weight. Parameters: slot  is the slot number to empty. Must be >= 0 and < NumAnimationSlot. skeleton  is the index of a skeleton in the animationSet. invert  is true if the weights to attach to the channels are the weights of the skeleton template. false if the weights to attach to the channels are the 1.f-weights of the skeleton template. Definition at line 439 of file channel_mixer.h.

std::map<uint, CChannel> NL3D::CChannelMixer::_Channels [private]

Apply a skeleton template weight on a specific slot. This method apply the weight of each node contains in skelWeight to the channel's slot weight. Parameters: slot  is the slot number to empty. Must be >= 0 and < NumAnimationSlot. skeleton  is the index of a skeleton in the animationSet. invert  is true if the weights to attach to the channels are the weights of the skeleton template. false if the weights to attach to the channels are the 1.f-weights of the skeleton template. Definition at line 442 of file channel_mixer.h. Referenced by addChannel(), applySkeletonWeight(), enableChannel(), evalChannels(), isChannelEnabled(), isChannelLodEnabled(), lodEnableChannel(), refreshList(), refreshListToEval(), resetChannels(), and resetSkeletonWeight().

std::vector<CChannel*> NL3D::CChannelMixer::_DetailListToEval [private]

Apply a skeleton template weight on a specific slot. This method apply the weight of each node contains in skelWeight to the channel's slot weight. Parameters: slot  is the slot number to empty. Must be >= 0 and < NumAnimationSlot. skeleton  is the index of a skeleton in the animationSet. invert  is true if the weights to attach to the channels are the weights of the skeleton template. false if the weights to attach to the channels are the 1.f-weights of the skeleton template. Definition at line 461 of file channel_mixer.h. Referenced by eval(), and refreshListToEval().

bool NL3D::CChannelMixer::_Dirt [private]

Apply a skeleton template weight on a specific slot. This method apply the weight of each node contains in skelWeight to the channel's slot weight. Parameters: slot  is the slot number to empty. Must be >= 0 and < NumAnimationSlot. skeleton  is the index of a skeleton in the animationSet. invert  is true if the weights to attach to the channels are the weights of the skeleton template. false if the weights to attach to the channels are the 1.f-weights of the skeleton template. Definition at line 454 of file channel_mixer.h.

CChannel* NL3D::CChannelMixer::_FirstChannelDetail [private]

Apply a skeleton template weight on a specific slot. This method apply the weight of each node contains in skelWeight to the channel's slot weight. Parameters: slot  is the slot number to empty. Must be >= 0 and < NumAnimationSlot. skeleton  is the index of a skeleton in the animationSet. invert  is true if the weights to attach to the channels are the weights of the skeleton template. false if the weights to attach to the channels are the 1.f-weights of the skeleton template. Definition at line 448 of file channel_mixer.h. Referenced by CChannelMixer(), refreshList(), and refreshListToEval().

CChannel* NL3D::CChannelMixer::_FirstChannelGlobal [private]

Apply a skeleton template weight on a specific slot. This method apply the weight of each node contains in skelWeight to the channel's slot weight. Parameters: slot  is the slot number to empty. Must be >= 0 and < NumAnimationSlot. skeleton  is the index of a skeleton in the animationSet. invert  is true if the weights to attach to the channels are the weights of the skeleton template. false if the weights to attach to the channels are the 1.f-weights of the skeleton template. Definition at line 445 of file channel_mixer.h. Referenced by CChannelMixer(), refreshList(), and refreshListToEval().

std::vector<CChannel*> NL3D::CChannelMixer::_GlobalListToEval [private]

Apply a skeleton template weight on a specific slot. This method apply the weight of each node contains in skelWeight to the channel's slot weight. Parameters: slot  is the slot number to empty. Must be >= 0 and < NumAnimationSlot. skeleton  is the index of a skeleton in the animationSet. invert  is true if the weights to attach to the channels are the weights of the skeleton template. false if the weights to attach to the channels are the 1.f-weights of the skeleton template. Definition at line 460 of file channel_mixer.h. Referenced by eval(), and refreshListToEval().

sint64 NL3D::CChannelMixer::_LastEvalDetailDate [private]

Apply a skeleton template weight on a specific slot. This method apply the weight of each node contains in skelWeight to the channel's slot weight. Parameters: slot  is the slot number to empty. Must be >= 0 and < NumAnimationSlot. skeleton  is the index of a skeleton in the animationSet. invert  is true if the weights to attach to the channels are the weights of the skeleton template. false if the weights to attach to the channels are the 1.f-weights of the skeleton template. Definition at line 451 of file channel_mixer.h. Referenced by CChannelMixer(), eval(), and resetEvalDetailDate().

bool NL3D::CChannelMixer::_ListToEvalDirt [private]

Apply a skeleton template weight on a specific slot. This method apply the weight of each node contains in skelWeight to the channel's slot weight. Parameters: slot  is the slot number to empty. Must be >= 0 and < NumAnimationSlot. skeleton  is the index of a skeleton in the animationSet. invert  is true if the weights to attach to the channels are the weights of the skeleton template. false if the weights to attach to the channels are the 1.f-weights of the skeleton template. Definition at line 457 of file channel_mixer.h. Referenced by CChannelMixer(), enableChannel(), eval(), evalChannels(), lodEnableChannel(), refreshList(), and refreshListToEval().

CSlot NL3D::CChannelMixer::_SlotArray[NumAnimationSlot] [private]

Apply a skeleton template weight on a specific slot. This method apply the weight of each node contains in skelWeight to the channel's slot weight. Parameters: slot  is the slot number to empty. Must be >= 0 and < NumAnimationSlot. skeleton  is the index of a skeleton in the animationSet. invert  is true if the weights to attach to the channels are the weights of the skeleton template. false if the weights to attach to the channels are the 1.f-weights of the skeleton template. Definition at line 436 of file channel_mixer.h. Referenced by applySkeletonWeight(), cleanAll(), dirtAll(), emptySlot(), eval(), evalChannels(), evalSingleChannel(), getSlotAnimation(), refreshList(), resetSkeletonWeight(), setSlotAnimation(), setSlotTime(), and setSlotWeight().

sint NLMISC::CRefCount::crefs [mutable, inherited]

Definition at line 79 of file smart_ptr.h. Referenced by NLMISC::CRefCount::CRefCount(), NLMISC::CRefCount::getRefCount(), and NLMISC::CRefCount::~CRefCount().

CRefCount::CPtrInfo NLMISC::CRefCount::NullPtrInfo [static, inherited]

Referenced by NLMISC::CRefCount::CRefCount().

CPtrInfo* NLMISC::CRefCount::pinfo [mutable, inherited]

Definition at line 80 of file smart_ptr.h. Referenced by NLMISC::CRefCount::CRefCount(), and NLMISC::CRefCount::~CRefCount().

---

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

• channel_mixer.h
• channel_mixer.cpp

---