818 lines
20 KiB
C++
818 lines
20 KiB
C++
// NeL - MMORPG Framework <http://dev.ryzom.com/projects/nel/>
|
|
// Copyright (C) 2010 Winch Gate Property Limited
|
|
//
|
|
// This program is free software: you can redistribute it and/or modify
|
|
// it under the terms of the GNU Affero General Public License as
|
|
// published by the Free Software Foundation, either version 3 of the
|
|
// License, or (at your option) any later version.
|
|
//
|
|
// This program is distributed in the hope that it will be useful,
|
|
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
// GNU Affero General Public License for more details.
|
|
//
|
|
// You should have received a copy of the GNU Affero General Public License
|
|
// along with this program. If not, see <http://www.gnu.org/licenses/>.
|
|
|
|
#include "std3d.h"
|
|
|
|
#include "nel/3d/channel_mixer.h"
|
|
#include "nel/3d/track.h"
|
|
#include "nel/3d/animatable.h"
|
|
#include "nel/3d/skeleton_weight.h"
|
|
#include "nel/misc/debug.h"
|
|
#include "nel/misc/common.h"
|
|
#include "nel/misc/hierarchical_timer.h"
|
|
|
|
using namespace NLMISC;
|
|
using namespace std;
|
|
|
|
namespace NL3D
|
|
{
|
|
|
|
// ***************************************************************************
|
|
|
|
CChannelMixer::CChannelMixer()
|
|
{
|
|
// 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;
|
|
}
|
|
|
|
// ***************************************************************************
|
|
|
|
CChannelMixer::~CChannelMixer()
|
|
{
|
|
resetChannels();
|
|
}
|
|
|
|
// ***************************************************************************
|
|
|
|
void CChannelMixer::setAnimationSet (const CAnimationSet* animationSet)
|
|
{
|
|
// Set the animationSet Pointer
|
|
_AnimationSet=animationSet;
|
|
|
|
// clear the channels.
|
|
resetChannels();
|
|
}
|
|
|
|
// ***************************************************************************
|
|
|
|
const CAnimationSet* CChannelMixer::getAnimationSet () const
|
|
{
|
|
// Return the animationSet Pointer
|
|
return _AnimationSet;
|
|
}
|
|
|
|
// ***************************************************************************
|
|
// Temp Data
|
|
static CAnimatedValueBlock TempAnimatedValueBlock;
|
|
|
|
|
|
// ***************************************************************************
|
|
void CChannelMixer::evalSingleChannel(CChannel &chan, uint numActive, uint activeSlot[NumAnimationSlot])
|
|
{
|
|
// If the refPtr of the object handled has been deleted, then no-op
|
|
if(!chan._Object)
|
|
{
|
|
return;
|
|
}
|
|
|
|
// 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
|
|
const IAnimatedValue &trackResult= ((ITrack*)chan._Tracks[slot])->eval (_SlotArray[slot]._Time, TempAnimatedValueBlock);
|
|
|
|
// 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> &quatValue=(CAnimatedValueBlendable<NLMISC::CQuat>&)trackResult;
|
|
firstQuat=quatValue.Value;
|
|
}
|
|
|
|
// Copy the interpolated value
|
|
chan._Value->affect (trackResult);
|
|
|
|
// 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> &quatValue=(CAnimatedValueBlendable<NLMISC::CQuat>&)trackResult;
|
|
quatValue.Value.makeClosest (firstQuat);
|
|
}
|
|
|
|
// Blend with this value and the previous sum
|
|
chan._Value->blend (trackResult, 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 CChannelMixer::eval (bool detail, uint64 evalDetailDate)
|
|
{
|
|
// 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 the refPtr of the object handled has been deleted, then no-op
|
|
if(!chan._Object)
|
|
{
|
|
continue;
|
|
}
|
|
|
|
// if Current blend factor is not 0
|
|
if(chan._Weights[slot]!=0.0f)
|
|
{
|
|
// Eval the track and copy the interpolated value. HTimer: 1.4%
|
|
chan._Value->affect (((ITrack*)chan._Tracks[slot])->eval (slotTime, TempAnimatedValueBlock));
|
|
|
|
// 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++)
|
|
{
|
|
evalSingleChannel(**channelArrayPtr, numActive, activeSlot);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
// ***************************************************************************
|
|
void CChannelMixer::evalChannels(sint *channelIdArray, uint numID)
|
|
{
|
|
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);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
|
|
|
|
// ***************************************************************************
|
|
|
|
sint CChannelMixer::addChannel (const string& channelName, IAnimatable* animatable, IAnimatedValue* value, ITrack* defaultValue, uint32 valueId, uint32 ownerValueId, bool detail)
|
|
{
|
|
// 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 (((ITrack*)(entry._DefaultTracks))->eval(0, TempAnimatedValueBlock));
|
|
|
|
// 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 CChannelMixer::resetChannels ()
|
|
{
|
|
// clear
|
|
_Channels.clear();
|
|
dirtAll ();
|
|
}
|
|
|
|
|
|
// ***************************************************************************
|
|
void CChannelMixer::enableChannel (uint channelId, bool enable)
|
|
{
|
|
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;
|
|
}
|
|
}
|
|
|
|
|
|
// ***************************************************************************
|
|
bool CChannelMixer::isChannelEnabled (uint channelId) const
|
|
{
|
|
std::map<uint, CChannel>::const_iterator it= _Channels.find(channelId);
|
|
if(it!=_Channels.end())
|
|
{
|
|
return (it->second._EnableFlags & CChannel::EnableUserFlag) != 0;
|
|
}
|
|
else
|
|
return false;
|
|
}
|
|
|
|
|
|
// ***************************************************************************
|
|
void CChannelMixer::lodEnableChannel (uint channelId, bool enable)
|
|
{
|
|
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;
|
|
}
|
|
}
|
|
|
|
|
|
// ***************************************************************************
|
|
bool CChannelMixer::isChannelLodEnabled (uint channelId) const
|
|
{
|
|
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 CChannelMixer::setSlotAnimation (uint slot, uint animation)
|
|
{
|
|
// 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;
|
|
}
|
|
}
|
|
|
|
// ***************************************************************************
|
|
|
|
const CAnimation *CChannelMixer::getSlotAnimation(uint slot) const
|
|
{
|
|
nlassert(slot < NumAnimationSlot);
|
|
return _SlotArray[slot]._Animation;
|
|
}
|
|
|
|
|
|
// ***************************************************************************
|
|
|
|
void CChannelMixer::emptySlot (uint slot)
|
|
{
|
|
// 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 CChannelMixer::resetSlots ()
|
|
{
|
|
// Empty all slots
|
|
for (uint s=0; s<NumAnimationSlot; s++)
|
|
// Empty it
|
|
emptySlot (s);
|
|
}
|
|
|
|
// ***************************************************************************
|
|
|
|
void CChannelMixer::applySkeletonWeight (uint slot, uint skeleton, bool invert)
|
|
{
|
|
// 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 CChannelMixer::resetSkeletonWeight (uint slot)
|
|
{
|
|
// 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 CChannelMixer::cleanAll ()
|
|
{
|
|
// For each slot
|
|
for (uint s=0; s<NumAnimationSlot; s++)
|
|
{
|
|
// Clean it
|
|
_SlotArray[s]._Dirt=false;
|
|
}
|
|
|
|
// Clean the mixer
|
|
_Dirt=false;
|
|
}
|
|
|
|
// ***************************************************************************
|
|
|
|
void CChannelMixer::dirtAll ()
|
|
{
|
|
// 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 CChannelMixer::refreshList ()
|
|
{
|
|
// 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++)
|
|
{
|
|
uint channelId= itChannel->first;
|
|
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++)
|
|
{
|
|
uint iDTrack;
|
|
|
|
// If the animation set is header compressed,
|
|
if(_AnimationSet->isAnimHeaderOptimized())
|
|
// can retrieve the animation trough the channel id (faster)
|
|
iDTrack= _SlotArray[addSlot[s]]._Animation->getIdTrackByChannelId(channelId);
|
|
else
|
|
// get by name
|
|
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)
|
|
{
|
|
// Ensure first the object is not deleted
|
|
if(channel._Object)
|
|
{
|
|
// Set it's value to default and touch it's object
|
|
channel._Value->affect (((ITrack*)(channel._DefaultTracks))->eval(0, TempAnimatedValueBlock));
|
|
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 CChannelMixer::refreshListToEval ()
|
|
{
|
|
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 CChannelMixer::resetEvalDetailDate()
|
|
{
|
|
_LastEvalDetailDate= -1;
|
|
}
|
|
|
|
|
|
} // NL3D
|