+Unity Runtime codeHEADmaster

1 files changed, 706 insertions, 0 deletions

diff --git a/Runtime/mecanim/animation/avatar.h b/Runtime/mecanim/animation/avatar.h
new file mode 100644
index 0000000..e90be7a
--- /dev/null
+++ b/Runtime/mecanim/animation/avatar.h
@@ -0,0 +1,706 @@
+#pragma once
+
+#include "Runtime/mecanim/defs.h"
+#include "Runtime/mecanim/memory.h"
+#include "Runtime/mecanim/types.h"
+#include "Runtime/mecanim/bind.h"
+#include "Runtime/Math/Simd/float4.h"
+
+#include "Runtime/mecanim/skeleton/skeleton.h"
+#include "Runtime/mecanim/human/human.h"
+#include "Runtime/mecanim/animation/clipmuscle.h"
+#include "Runtime/mecanim/animation/curvedata.h"
+#include "Runtime/mecanim/statemachine/statemachine.h"
+
+#include "Runtime/Serialize/Blobification/offsetptr.h"
+#include "Runtime/Serialize/TransferFunctions/SerializeTransfer.h"
+#include "Runtime/Animation/MecanimArraySerialization.h" 
+
+typedef UInt32 BindingHash;
+
+namespace mecanim
+{
+
+	static const uint32_t DISABLED_SYNCED_LAYER_IN_NON_PRO = 0xffffffff;
+	struct ValueArrayConstant;
+
+	typedef int ProcessString(mecanim::String const&);
+	
+	namespace animation
+	{
+		struct ClipMuscleConstant;
+		struct AvatarConstant;
+		struct ControllerConstant;
+
+		enum LayerBlendingMode
+		{
+			kLayerBlendingModeOverride,
+			kLayerBlendingModeAdditive		
+		};
+	
+		struct LayerConstant
+		{
+			DEFINE_GET_TYPESTRING(LayerConstant)
+
+			LayerConstant():m_IKPass(true), m_SyncedLayerAffectsTiming(false), m_LayerBlendingMode(kLayerBlendingModeOverride){}
+
+			uint32_t				m_StateMachineIndex;
+			uint32_t				m_StateMachineMotionSetIndex;
+
+			human::HumanPoseMask	m_BodyMask;
+			OffsetPtr<skeleton::SkeletonMask> m_SkeletonMask;
+									
+			uint32_t				m_Binding;
+			uint32_t				m_LayerBlendingMode; //LayerBlendingMode
+			float					m_DefaultWeight;
+			bool					m_IKPass;
+			bool					m_SyncedLayerAffectsTiming;
+
+			template<class TransferFunction>
+			inline void Transfer (TransferFunction& transfer)
+			{				
+
+				TRANSFER(m_StateMachineIndex);
+				TRANSFER(m_StateMachineMotionSetIndex);
+				TRANSFER(m_BodyMask);
+				TRANSFER(m_SkeletonMask);				
+				TRANSFER(m_Binding);			
+				TRANSFER((int&)m_LayerBlendingMode);
+				TRANSFER(m_DefaultWeight);
+				TRANSFER(m_IKPass);
+				TRANSFER(m_SyncedLayerAffectsTiming);
+				transfer.Align();	
+				
+				
+			}
+		};
+
+		struct ControllerConstant
+		{
+			DEFINE_GET_TYPESTRING(ControllerConstant)
+
+			ControllerConstant():	m_LayerCount(0),
+									m_StateMachineCount(0) {}
+
+			uint32_t													m_LayerCount;
+			OffsetPtr< OffsetPtr<LayerConstant> >						m_LayerArray;
+
+			uint32_t													m_StateMachineCount;
+			OffsetPtr< OffsetPtr<statemachine::StateMachineConstant> >	m_StateMachineArray;
+
+			OffsetPtr<ValueArrayConstant>								m_Values;													
+			OffsetPtr<ValueArray>										m_DefaultValues;		
+
+			template<class TransferFunction>
+			inline void Transfer (TransferFunction& transfer)
+			{
+				TRANSFER_BLOB_ONLY(m_LayerCount);
+				MANUAL_ARRAY_TRANSFER2( OffsetPtr<mecanim::animation::LayerConstant>, m_LayerArray, m_LayerCount);
+				
+				TRANSFER_BLOB_ONLY(m_StateMachineCount);
+				MANUAL_ARRAY_TRANSFER2( OffsetPtr<mecanim::statemachine::StateMachineConstant>, m_StateMachineArray, m_StateMachineCount);
+				
+				TRANSFER(m_Values);							
+				TRANSFER(m_DefaultValues);
+				
+			}	
+
+			static void InitializeClass();
+		};
+
+		struct SkeletonTQSMap
+		{
+			SkeletonTQSMap() : m_TIndex(-1), m_QIndex(-1), m_SIndex(-1) {};
+
+			int32_t m_TIndex;
+			int32_t m_QIndex;
+			int32_t m_SIndex;
+		};
+		
+		struct ClipBindings
+		{
+			ClipBindings () : m_PositionIndex(0), m_QuaternionIndex(0), m_ScaleIndex(0), m_FloatIndex(0), m_IntIndex(0), m_IntegerRemap(0)  {}
+			
+			// Maps from the curve float array of the clip to the ValueArrayConstant.
+			// This allows us to bring the curve float array into a ValueArray that has the same layout between all clips.
+			int16_t* m_PositionIndex;
+			int16_t* m_QuaternionIndex;
+			int16_t* m_ScaleIndex;
+			int16_t* m_FloatIndex;
+			int16_t* m_IntIndex;
+			
+			// Points directly to AnimationClipBindingConstant pptrCurveMapping.
+			int32_t* m_IntegerRemap;
+		};
+
+		struct AnimationSet
+		{	
+			struct Clip
+			{
+				Clip() : m_Clip(0), m_TotalUsedOptimizedCurveCount(0), m_ClipIndex(-1) {}
+
+				// The referenced constant clip
+				ClipMuscleConstant*	m_Clip;
+				int32_t m_ClipIndex;
+				// The amount of ConstantClip curves that need to be sampled (Constant curves are often ignored during binding if they are determined to have no impact)
+				uint32_t            m_TotalUsedOptimizedCurveCount;
+				// Binding indices to index from the curve float[] to the ValueArray
+				ClipBindings        m_Bindings;
+			};
+
+			AnimationSet() :	m_MaxBlendState(0),
+								m_LayerCount(0), 
+								m_ClipPerLayer(0),
+								m_ClipConstant(0), 
+								m_AdditionalCount(0), 
+								m_AdditionalIndexArray(0),
+								m_DynamicFullValuesConstant(0),
+								m_DynamicValuesMaskArray(0),
+								m_GravityWeightIndex(-1),
+								m_IntegerRemapStride(-1)
+								{}
+
+			uint32_t										m_MaxBlendState;
+			uint32_t										m_LayerCount;
+			uint32_t*										m_ClipPerLayer;
+
+			Clip**											m_ClipConstant;
+			
+			uint32_t										m_AdditionalCount;
+			int32_t*										m_AdditionalIndexArray;
+
+			mecanim::ValueArrayConstant*					m_DynamicFullValuesConstant;
+			mecanim::ValueArrayMask**						m_DynamicValuesMaskArray;
+
+			int32_t											m_GravityWeightIndex;
+			int32_t											m_IntegerRemapStride;
+		};
+
+		struct ControllerBindingConstant
+		{
+			ControllerBindingConstant():	m_DynamicValuesDefault(0),
+											m_SkeletonTQSMap(0),
+											m_RootMotionLayerMask(0),
+											m_Avatar(0),
+											m_Controller(0),
+											m_DynamicValuesConstant(0),
+											m_AnimationSet(0) {}
+
+			ValueArrayConstant*								m_DynamicValuesConstant;
+			ValueArray*										m_DynamicValuesDefault;		
+
+			SkeletonTQSMap*									m_SkeletonTQSMap;
+
+			bool*											m_RootMotionLayerMask;
+
+			AvatarConstant const*							m_Avatar;
+			ControllerConstant const*						m_Controller;
+			AnimationSet const*								m_AnimationSet;
+		};
+
+		struct AnimationSetMemory
+		{
+			AnimationSetMemory() : m_LayerCount(0), m_ClipPerLayer(0), m_ClipMemory(0), m_ClipOutput(0) {}
+
+			uint32_t				m_LayerCount;
+			uint32_t*				m_ClipPerLayer;
+			ClipMemory***			m_ClipMemory;
+			ClipOutput*				m_ClipOutput;
+		};
+
+		template<bool dynamic>
+		struct BlendingState
+		{
+			BlendingState():
+				m_DynamicValuesBlending(0),
+				m_MotionBlending(0),
+				m_HumanPoseBlending(0),
+				m_BlendFactor(0)
+			{}
+
+			ValueArray**				m_DynamicValuesBlending;
+			MotionOutput**				m_MotionBlending;
+			human::HumanPose**			m_HumanPoseBlending;
+			float* m_BlendFactor;
+
+			uint32_t					m_Size;
+		};
+
+		template<>
+		struct BlendingState<false>
+		{
+			BlendingState(): m_BlendFactor(0) {}
+
+			OffsetPtr<ValueArray> m_DynamicValuesBlending;
+			OffsetPtr<ValueArrayMask> m_DynamicValuesBlendingMask;
+			OffsetPtr<MotionOutput>	m_MotionBlending;
+			OffsetPtr<human::HumanPose>	m_HumanPoseBlending;
+			float m_BlendFactor;
+		};
+
+		struct BlendingClip
+		{
+			BlendingClip() : m_ClipIndex(-1), m_LayerIndex(-1), m_Weight(0), m_PrevTime(0), m_Time(0), m_Reverse(false) {}
+
+			int m_ClipIndex;
+			int m_LayerIndex;
+			float m_Weight;
+			float m_PrevTime;
+			float m_Time;
+			bool m_Reverse;
+		};
+
+		struct ControllerMemory
+		{
+			DEFINE_GET_TYPESTRING(ControllerMemory)
+
+			ControllerMemory():	m_StateMachineCount(0),
+								m_LayerCount(0) {}
+
+			uint32_t													m_StateMachineCount;
+			OffsetPtr< OffsetPtr<statemachine::StateMachineMemory> >	m_StateMachineMemory;
+
+			uint32_t													m_LayerCount;
+			OffsetPtr<BlendingState<false> >							m_InteruptedTransitionsBlendingStateArray;
+			OffsetPtr<float>											m_LayerWeights;
+
+			OffsetPtr<ValueArray>										m_Values;
+
+			template<class TransferFunction>
+			inline void Transfer (TransferFunction& transfer)
+			{
+				TRANSFER_BLOB_ONLY(m_StateMachineCount);
+				MANUAL_ARRAY_TRANSFER2( OffsetPtr<mecanim::statemachine::StateMachineMemory>, m_StateMachineMemory, m_StateMachineCount);
+
+				TRANSFER_BLOB_ONLY(m_LayerCount);
+				MANUAL_ARRAY_TRANSFER2( BlendingState<false>, m_InteruptedTransitionsBlendingStateArray, m_LayerCount);						
+				MANUAL_ARRAY_TRANSFER2( float, m_LayerWeights, m_LayerCount);
+
+				TRANSFER(m_Values);							
+			}
+		};
+
+		struct ControllerWorkspace 
+		{
+			ControllerWorkspace() :	m_StateMachineWorkspace(0),
+									m_StateMachineOutput(0),
+									m_BlendingState(0),
+									m_BlendingClipCount(0),
+									m_BlendingClipArray(0),
+									m_ValueArrayStart(0),
+									m_ValueArrayStop(0),
+									m_ReadMask(0),
+									m_BlendMask(0),
+									m_DefaultMask(0),
+									m_DoIK(false),
+									m_DoWrite(false) {}
+	
+			statemachine::StateMachineWorkspace**   m_StateMachineWorkspace;
+			statemachine::StateMachineOutput**		m_StateMachineOutput;
+			
+			uint32_t								m_StateMachineCount;
+
+			float*									m_MotionSetTimingWeightArray;
+
+			BlendingState<true>*					m_BlendingState;
+			BlendingState<false>					m_BlendingStateWs;
+
+			int										m_BlendingClipCount;
+			BlendingClip*							m_BlendingClipArray;
+
+			ValueArray								*m_ValueArrayStart;
+			ValueArray								*m_ValueArrayStop;
+
+			ValueArrayMask							*m_ReadMask;
+			ValueArrayMask							*m_BlendMask;
+			ValueArrayMask							*m_DefaultMask;
+
+			bool									m_DoIK;
+			bool									m_DoWrite;
+		};
+
+		struct ExposedTransform
+		{
+			DEFINE_GET_TYPESTRING(ExposedTransform);
+
+			// For SkinnedMeshRenderer, the following two indices are different
+			// - 'skeletonIndex'
+			//		corresponds to the SkinnedMeshRenderer itself
+			// - 'skeletonIndexForUpdateTransform'
+			//		corresponds to the root bone of the SkinnedMeshRenderer
+			uint32_t	skeletonIndex;
+			uint32_t    skeletonIndexForUpdateTransform;
+
+			BindingHash	transformPath;		// flattened path
+
+			template<class TransferFunction>
+			inline void Transfer (TransferFunction& transfer)
+			{
+				TRANSFER(skeletonIndex);
+				TRANSFER(skeletonIndexForUpdateTransform);
+				TRANSFER(transformPath);
+			}	
+		};
+
+		struct AvatarConstant
+		{
+			DEFINE_GET_TYPESTRING(AvatarConstant)
+
+			AvatarConstant() :	m_SkeletonNameIDCount(0), 
+								m_HumanSkeletonIndexCount(0),
+								m_HumanSkeletonReverseIndexCount(0),
+								m_RootMotionBoneIndex(-1), 
+								m_RootMotionBoneX(math::xformIdentity()),
+								m_RootMotionSkeletonIndexCount(0) {}
+
+			OffsetPtr<skeleton::Skeleton>			m_AvatarSkeleton;
+			OffsetPtr<skeleton::SkeletonPose>		m_AvatarSkeletonPose;
+
+			OffsetPtr<skeleton::SkeletonPose>		m_DefaultPose;	// The default pose when model is imported.
+
+			uint32_t								m_SkeletonNameIDCount;
+			OffsetPtr<uint32_t>						m_SkeletonNameIDArray;	// CRC(name)
+
+			OffsetPtr<human::Human>					m_Human;
+
+			uint32_t								m_HumanSkeletonIndexCount;
+			OffsetPtr<int32_t>						m_HumanSkeletonIndexArray;
+
+			// needed to update human pose and additonal bones in optimize mode
+			// decided to put the info in constant for perf and memory reason vs doing masking at runtime
+			uint32_t								m_HumanSkeletonReverseIndexCount;
+			OffsetPtr<int32_t>						m_HumanSkeletonReverseIndexArray;
+
+			int32_t									m_RootMotionBoneIndex;
+			math::xform								m_RootMotionBoneX;
+			OffsetPtr<skeleton::Skeleton>			m_RootMotionSkeleton;
+			OffsetPtr<skeleton::SkeletonPose>		m_RootMotionSkeletonPose;
+			uint32_t								m_RootMotionSkeletonIndexCount;
+			OffsetPtr<int32_t>						m_RootMotionSkeletonIndexArray;
+
+			template<class TransferFunction>
+			inline void Transfer (TransferFunction& transfer)
+			{
+				transfer.SetVersion(3);
+
+				TRANSFER(m_AvatarSkeleton);
+
+				TRANSFER(m_AvatarSkeletonPose);
+				TRANSFER(m_DefaultPose);
+
+				TRANSFER_BLOB_ONLY(m_SkeletonNameIDCount);
+				MANUAL_ARRAY_TRANSFER2(uint32_t,m_SkeletonNameIDArray,m_SkeletonNameIDCount);	
+
+				TRANSFER(m_Human);
+
+				TRANSFER_BLOB_ONLY(m_HumanSkeletonIndexCount);
+				MANUAL_ARRAY_TRANSFER2(int32_t,m_HumanSkeletonIndexArray,m_HumanSkeletonIndexCount);	
+
+				TRANSFER_BLOB_ONLY(m_HumanSkeletonReverseIndexCount);
+				MANUAL_ARRAY_TRANSFER2(int32_t,m_HumanSkeletonReverseIndexArray,m_HumanSkeletonReverseIndexCount);	
+
+				TRANSFER(m_RootMotionBoneIndex);
+				TRANSFER(m_RootMotionBoneX);
+				TRANSFER(m_RootMotionSkeleton);
+				TRANSFER(m_RootMotionSkeletonPose);
+
+				TRANSFER_BLOB_ONLY(m_RootMotionSkeletonIndexCount);
+				MANUAL_ARRAY_TRANSFER2(int32_t,m_RootMotionSkeletonIndexArray,m_RootMotionSkeletonIndexCount);	
+
+				transfer.Align();
+
+				if (transfer.IsVersionSmallerOrEqual (1))
+				{
+					if(m_RootMotionBoneIndex != -1)
+					{
+						mecanim::memory::Allocator *alloc = reinterpret_cast<mecanim::memory::Allocator *>(transfer.GetUserData());
+
+						m_RootMotionSkeleton = skeleton::CreateSkeleton(m_AvatarSkeleton->m_Count,m_AvatarSkeleton->m_AxesCount,*alloc);
+						skeleton::SkeletonCopy(m_AvatarSkeleton.Get(),m_RootMotionSkeleton.Get());
+
+						m_RootMotionSkeletonPose = skeleton::CreateSkeletonPose(m_RootMotionSkeleton.Get(),*alloc);
+						skeleton::SkeletonPoseCopy(m_AvatarSkeletonPose.Get(),m_RootMotionSkeletonPose.Get());						
+						
+						m_RootMotionSkeletonIndexCount = m_AvatarSkeleton->m_Count;
+						m_RootMotionSkeletonIndexArray = alloc->ConstructArray<mecanim::int32_t>(m_RootMotionSkeletonIndexCount);
+
+						for(int i = 0; i < m_RootMotionSkeletonIndexCount; i++)
+						{
+							m_RootMotionSkeletonIndexArray[i] = i;
+						}
+					}
+				}
+
+				if (transfer.IsVersionSmallerOrEqual (2))
+				{
+					if(isHuman())
+					{
+						mecanim::memory::Allocator *alloc = reinterpret_cast<mecanim::memory::Allocator *>(transfer.GetUserData());
+
+						m_HumanSkeletonReverseIndexCount = m_AvatarSkeleton->m_Count;
+						m_HumanSkeletonReverseIndexArray = alloc->ConstructArray<mecanim::int32_t>(m_HumanSkeletonReverseIndexCount);
+						skeleton::SkeletonBuildReverseIndexArray(m_HumanSkeletonReverseIndexArray.Get(),m_HumanSkeletonIndexArray.Get(),m_Human->m_Skeleton.Get(),m_AvatarSkeleton.Get());
+					}
+				}
+			}
+
+			bool isHuman() const { return !m_Human.IsNull() && m_Human->GetTypeString() != 0 && m_Human->m_Skeleton->m_Count > 0; };
+
+			static void InitializeClass();
+		};
+
+		struct AvatarInput 
+		{
+			AvatarInput() : m_GotoStateInfos(0), m_DeltaTime(0), m_TargetIndex(-1), m_TargetTime(1), m_FeetPivotActive(1), m_StabilizeFeet(false), m_ForceStateTime(false), m_StateTime(0), m_LayersAffectMassCenter(false) {}
+
+			statemachine::GotoStateInfo*	m_GotoStateInfos;
+			float			m_DeltaTime;
+			int				m_TargetIndex;
+			float			m_TargetTime;
+
+			float			m_FeetPivotActive;
+			bool			m_StabilizeFeet;
+
+			bool			m_ForceStateTime;
+			float			m_StateTime;
+			bool			m_LayersAffectMassCenter;
+		};
+		
+		struct AvatarMemory
+		{
+			DEFINE_GET_TYPESTRING(AvatarMemory)
+
+			AvatarMemory() :	m_AvatarX(math::xformIdentity()),
+								m_LeftFootX(math::xformIdentity()),
+								m_RightFootX(math::xformIdentity()),
+								m_Pivot(math::float4::zero()),
+								m_PivotWeight(0.5),								
+								m_FirstEval(1),
+								m_SkeletonPoseOutputReady(0) {}
+
+			OffsetPtr<ControllerMemory>		m_ControllerMemory;
+
+			math::xform						m_AvatarX;
+			
+			math::xform						m_LeftFootX;
+			math::xform						m_RightFootX;			
+			math::float4					m_Pivot;
+
+			float							m_PivotWeight;
+			UInt8							m_FirstEval;
+			UInt8							m_SkeletonPoseOutputReady;
+
+
+			template<class TransferFunction>
+			inline void Transfer (TransferFunction& transfer)
+			{
+				TRANSFER(m_ControllerMemory);
+				TRANSFER(m_AvatarX);
+				TRANSFER(m_LeftFootX);
+				TRANSFER(m_RightFootX);
+				TRANSFER(m_Pivot);
+				TRANSFER(m_PivotWeight);
+				TRANSFER(m_FirstEval);
+				TRANSFER(m_SkeletonPoseOutputReady);
+				transfer.Align();
+			}
+		};
+
+		struct AvatarWorkspace 
+		{
+			AvatarWorkspace() : m_BodySkeletonPoseWs(0),
+								m_BodySkeletonPoseWsA(0),
+								m_BodySkeletonPoseWsB(0),
+								m_RootMotionSkeletonPoseWsA(0),
+								m_RootMotionSkeletonPoseWsB(0),
+								m_HumanPoseWs(0),
+								m_ControllerWorkspace(0),
+								m_LeftFootSpeedT(0),
+								m_LeftFootSpeedQ(0),
+								m_RightFootSpeedT(0),
+								m_RightFootSpeedQ(0),
+								m_IKOnFeet(false)
+								{} 
+				
+			skeleton::SkeletonPose*					m_BodySkeletonPoseWs;
+			skeleton::SkeletonPose*					m_BodySkeletonPoseWsA;
+			skeleton::SkeletonPose*					m_BodySkeletonPoseWsB;
+		
+			skeleton::SkeletonPose*					m_RootMotionSkeletonPoseWsA;
+			skeleton::SkeletonPose*					m_RootMotionSkeletonPoseWsB;
+
+			human::HumanPose*						m_HumanPoseWs;
+
+			ControllerWorkspace*					m_ControllerWorkspace;
+		
+			math::xform								m_AvatarX;
+			
+			float									m_LeftFootSpeedT;
+			float									m_LeftFootSpeedQ;
+			float									m_RightFootSpeedT;
+			float									m_RightFootSpeedQ;
+			bool									m_IKOnFeet;
+		};
+
+		struct AvatarOutput 
+		{
+			AvatarOutput() :		m_DynamicValuesOutput(0),
+									m_SkeletonPoseOutput(0),
+									m_MotionOutput(0),
+									m_HumanPoseBaseOutput(0),
+									m_HumanPoseOutput(0) {}
+	
+			ValueArray*				m_DynamicValuesOutput;
+
+			skeleton::SkeletonPose*	m_SkeletonPoseOutput;
+
+			MotionOutput*			m_MotionOutput;
+			human::HumanPose*		m_HumanPoseBaseOutput;
+			human::HumanPose*		m_HumanPoseOutput;
+		};
+
+		AvatarConstant*     CreateAvatarConstant(	skeleton::Skeleton* skeleton,
+													skeleton::SkeletonPose* skeletonPose,
+													skeleton::SkeletonPose* defaultPose,
+													human::Human* human,
+													skeleton::Skeleton* rootMotionSkeleton,
+													int rootMotionIndex,
+													math::xform const& rootMotionX,
+													memory::Allocator& alloc);
+
+		void				DestroyAvatarConstant(AvatarConstant* constant, memory::Allocator& alloc);
+
+		void				InitializeAvatarConstant(AvatarConstant * constant, memory::Allocator& alloc);
+		void				ClearAvatarConstant(AvatarConstant * constant, memory::Allocator& alloc);
+
+		ControllerConstant* CreateControllerConstant(	uint32_t LayerCount, LayerConstant** layerArray,
+														uint32_t stateMachineCount, statemachine::StateMachineConstant** stateMachineConstant,
+														ValueArrayConstant* values, ValueArray* defaultValues,
+														memory::Allocator& alloc);
+
+		void				DestroyControllerConstant(ControllerConstant* controller, memory::Allocator& alloc);
+
+		void				InitializeControllerConstant(ControllerConstant * controller, memory::Allocator& alloc);
+		void				ClearControllerConstant(ControllerConstant * controller, memory::Allocator& alloc);
+		
+		LayerConstant* CreateLayerConstant(mecanim::uint32_t stateMachineIndex, mecanim::uint32_t motionSetIndex, memory::Allocator& alloc);
+		void				DestroyLayerConstant(LayerConstant* constant, memory::Allocator& alloc);
+
+		ControllerMemory* CreateControllerMemory(ControllerConstant const* controller, AvatarConstant const *avatar, AnimationSet const *animationSet, const ValueArrayConstant* dynamicValueConstant, memory::Allocator& alloc);
+		void						DestroyControllerMemory(ControllerMemory* memory, memory::Allocator& alloc);
+
+		ControllerWorkspace*		CreateControllerWorkspace(ControllerConstant const* controller, AvatarConstant const *avatar, AnimationSet const *animationSet, const ValueArrayConstant* dynamicValueConstant, memory::Allocator& alloc);
+		void						DestroyControllerWorkspace(ControllerWorkspace* workspace, memory::Allocator& alloc);
+
+		AvatarInput*		CreateAvatarInput(AvatarConstant const* constant, memory::Allocator& alloc);
+		void				DestroyAvatarInput(AvatarInput* input, memory::Allocator& alloc);
+
+		AvatarMemory*		CreateAvatarMemory(AvatarConstant const* constant, memory::Allocator& alloc);
+		void				DestroyAvatarMemory(AvatarMemory* memory, memory::Allocator& alloc);
+
+		AvatarWorkspace*	CreateAvatarWorkspace(AvatarConstant const* constant, memory::Allocator& alloc);
+		void				DestroyAvatarWorkspace(AvatarWorkspace* workspace, memory::Allocator& alloc);
+
+		AvatarOutput*		CreateAvatarOutput(AvatarConstant const* constant, bool hasTransformHierarchy, memory::Allocator& alloc);
+		void				DestroyAvatarOutput(AvatarOutput* output, memory::Allocator& alloc);
+
+		AnimationSet*		CreateAnimationSet(ControllerConstant const* controller, memory::Allocator& alloc);
+		void				DestroyAnimationSet(AnimationSet* animationSet, memory::Allocator& alloc);
+
+		AnimationSetMemory*	CreateAnimationSetMemory(AnimationSet const* animationSet, bool allowConstantCurveOptimization, memory::Allocator& alloc);
+		void				DestroyAnimationSetMemory(AnimationSetMemory* animationSetMemory, memory::Allocator& alloc);		
+
+		void UpdateLeafNodeDuration(const ControllerConstant &controllerConstant, const AnimationSet &animationSet, ControllerMemory &controllerMemory);
+
+		void				SetIKOnFeet(		bool left,
+												AvatarConstant const &avatar, 
+												const AvatarInput &input, 
+												AvatarMemory &memory, 
+												AvatarWorkspace &workspace, 
+												AvatarOutput &output);
+
+		void				EvaluateAvatarSM(	AvatarConstant const* constant, 
+												AvatarInput const* input, 
+												AvatarOutput * output, 
+												AvatarMemory * memory, 
+												AvatarWorkspace * workspace,
+												ControllerConstant const* controllerConstant);
+
+		void				EvaluateAvatarLayers(	ControllerBindingConstant const* controllerBindingConstant, 
+													AvatarInput const* input, 
+													AvatarOutput *output, 
+													AvatarMemory *memory, 
+													AvatarWorkspace *workspace,
+													AnimationSetMemory* animationSetMemory);
+
+		void				EvaluateAvatarX(	AvatarConstant const* constant, 
+												AvatarInput const* input, 
+												AvatarOutput *output, 
+												AvatarMemory *memory, 
+												AvatarWorkspace *workspace);
+
+		void				EvaluateAvatarRetarget(	AvatarConstant const* constant, 
+													AvatarInput const* input, 
+													AvatarOutput *output, 
+													AvatarMemory *memory, 
+													AvatarWorkspace *workspace,
+													ControllerConstant const* controllerConstant);
+
+		void				EvaluateAvatarIK(	AvatarConstant const* constant, 
+												AvatarInput const* input, 
+												AvatarOutput *output, 
+												AvatarMemory *memory, 
+												AvatarWorkspace *workspace,
+												ControllerConstant const* controllerConstant);
+
+		void				EvaluateAvatarEnd(	AvatarConstant const* constant, 
+													AvatarInput const* input, 
+													AvatarOutput *output, 
+													AvatarMemory *memory, 
+													AvatarWorkspace *workspace,
+													ControllerConstant const* controllerConstant);
+
+	void ValuesFromClip(	mecanim::ValueArray const &valuesDefault,
+							mecanim::animation::ClipMuscleConstant const &cst, 
+							mecanim::animation::ClipOutput const &out,
+							const ClipBindings& bindings,
+							int32_t        integerRemapStride,
+							mecanim::ValueArray &values,
+							mecanim::ValueArrayMask &mask);
+
+	void DeltasFromClip(	mecanim::animation::ClipMuscleConstant const &cst,
+							const ClipBindings& bindings,
+							const ValueArrayMask& mask,
+							mecanim::ValueArray &starts,
+							mecanim::ValueArray &stops);
+
+	void SkeletonPoseFromValue(skeleton::Skeleton const &skeleton, skeleton::SkeletonPose const &defaultPose, ValueArray const &values, SkeletonTQSMap const *skeletonTQSMap, skeleton::SkeletonPose &pose,int32_t const *humanReverseIndex,bool skipRoot);
+	void SkeletonPoseFromValue(skeleton::Skeleton const &skeleton, skeleton::SkeletonPose const &defaultPose, ValueArray const &values, SkeletonTQSMap const *skeletonTQSMap, int32_t const *indexArray, skeleton::SkeletonPose &pose,int index, int stopIndex);
+	void ValueFromSkeletonPose(skeleton::Skeleton const &skeleton, skeleton::SkeletonPose const &pose, SkeletonTQSMap const *skeletonTQSMap, ValueArray &values);
+	void ValueFromSkeletonPose(skeleton::Skeleton const &skeleton, skeleton::SkeletonPose const &pose, SkeletonTQSMap const *skeletonTQSMap, int32_t const *indexArray, ValueArray &values, int index, int stopIndex);
+	}
+}
+
+template<>
+class SerializeTraits< mecanim::animation::BlendingState<false> > : public SerializeTraitsBase< mecanim::animation::BlendingState<false> >
+{
+	public:
+
+	typedef mecanim::animation::BlendingState<false>	value_type;
+	inline static const char* GetTypeString (void*)	{ return "BlendingState<1>"; }
+	inline static bool IsAnimationChannel ()	{ return false; }
+	inline static bool MightContainPPtr ()	{ return true; }
+	inline static bool AllowTransferOptimization ()	{ return false; }
+
+	template<class TransferFunction> inline
+	static void Transfer (value_type& data, TransferFunction& transfer)
+	{
+		transfer.Transfer(data.m_DynamicValuesBlending, "m_DynamicValuesBlending");
+		transfer.Transfer(data.m_DynamicValuesBlendingMask, "m_DynamicValuesBlendingMask");
+		transfer.Transfer(data.m_MotionBlending, "m_MotionBlending");
+		transfer.Transfer(data.m_HumanPoseBlending, "m_HumanPoseBlending");
+		transfer.Transfer(data.m_BlendFactor, "m_BlendFactor");
+	}
+};
+
+