+Unity Runtime codeHEADmaster

1 files changed, 228 insertions, 0 deletions

diff --git a/Runtime/mecanim/animation/poseblender.cpp b/Runtime/mecanim/animation/poseblender.cpp
new file mode 100644
index 0000000..ccbdf8f
--- /dev/null
+++ b/Runtime/mecanim/animation/poseblender.cpp
@@ -0,0 +1,228 @@
+#include "UnityPrefix.h"
+#include "Runtime/mecanim/skeleton/skeleton.h"
+
+#include "Runtime/mecanim/graph/plugbinder.h"
+#include "Runtime/mecanim/animation/common.h"
+#include "Runtime/mecanim/animation/poseblender.h"
+
+namespace mecanim
+{
+
+namespace animation
+{
+	namespace 
+	{		
+		void SetPoseBlenderValue(graph::GraphPlug const* plug, uint32_t index, PoseBlenderInput const* input, graph::EvaluationGraphWorkspace* graphMemory)
+		{
+			float value;
+			plug->ReadData(&value, graphMemory->m_EvaluationInfo);   
+			input->m_WeightArray[index] += value;			
+		}
+	}
+
+	PoseBlenderConstant* CreatePoseBlenderConstant(skeleton::Skeleton * skeleton, skeleton::SkeletonPose*	defaultPose, skeleton::SkeletonPose**	arrayPose, uint32_t count, graph::Graph* graph, memory::Allocator& alloc)
+	{
+		PoseBlenderConstant *cst = alloc.Construct<PoseBlenderConstant>();
+
+		cst->m_Skeleton = skeleton;
+		cst->m_SkeletonPoseCount = count;
+
+		cst->m_DefaultSkeletonPose = defaultPose;
+		cst->m_SkeletonPoseArray = alloc.ConstructArray<skeleton::SkeletonPose*>(count);
+		cst->m_PosesID = alloc.ConstructArray<uint32_t>(count);
+		cst->m_HasGraph = graph != 0;
+		cst->m_Graph = graph;
+
+		uint32_t i;
+		for(i=0;i<count;i++)
+		{
+			cst->m_SkeletonPoseArray[i] = arrayPose[i];
+		}
+
+		if(cst->m_HasGraph)
+		{
+			cst->m_ValuesConstant = CreateValueArrayConstant(kFloatType, cst->m_Graph->m_InEdgesCount, alloc);
+			for(i=0;i<cst->m_Graph->m_InEdgesCount;++i)
+			{
+				cst->m_ValuesConstant->m_ValueArray[i].m_ID = cst->m_Graph->m_InEdges[i].m_Binding;
+			}
+		}
+
+		return cst;
+	}
+
+	void DestroyPoseBlenderConstant(PoseBlenderConstant * constant, memory::Allocator& alloc)
+	{
+		if(constant)
+		{
+			alloc.Deallocate(constant->m_PosesID);
+			alloc.Deallocate(constant->m_SkeletonPoseArray);
+			alloc.Deallocate(constant);
+		}
+	}
+
+	void InitializePoseBlenderConstant(PoseBlenderConstant * constant, graph::GraphFactory const& factory, memory::Allocator& alloc)
+	{
+		if(constant->m_Graph)
+		{
+			constant->m_EvaluationGraph = graph::CreateEvaluationGraph(constant->m_Graph, factory, alloc);
+		}
+	}
+
+	void ClearPoseBlenderConstant(PoseBlenderConstant * constant, memory::Allocator& alloc)
+	{
+		if(constant->m_EvaluationGraph)
+		{
+			graph::DestroyEvaluationGraph(constant->m_EvaluationGraph, alloc);
+			constant->m_EvaluationGraph = 0;
+		}
+	}
+
+	PoseBlenderInput* CreatePoseBlenderInput(PoseBlenderConstant const* constant, memory::Allocator& alloc)
+	{
+		PoseBlenderInput *in = alloc.Construct<PoseBlenderInput>();
+
+		if(constant->m_ValuesConstant)
+		{
+			in->m_Values = CreateValueArray(constant->m_ValuesConstant, alloc);
+		}
+		in->m_WeightPoseCount = constant->m_SkeletonPoseCount;
+		in->m_SkeletonPose = skeleton::CreateSkeletonPose(constant->m_Skeleton, alloc);
+		in->m_WeightArray = alloc.ConstructArray<float>(constant->m_SkeletonPoseCount);
+
+		uint32_t i;
+		for(i=0;i<in->m_WeightPoseCount;i++)
+		{
+			in->m_WeightArray[i] = 0.f;
+		}
+		
+		return in;
+	}
+
+	void DestroyPoseBlenderInput(PoseBlenderInput * input, memory::Allocator& alloc)
+	{
+		if(input)
+		{
+			skeleton::DestroySkeletonPose(input->m_SkeletonPose, alloc);
+			alloc.Deallocate(input->m_WeightArray);
+			alloc.Deallocate(input);
+		}
+	}
+
+	PoseBlenderWorkspace* CreatePoseBlenderWorkspace(PoseBlenderConstant const* constant, memory::Allocator& alloc)
+	{
+		PoseBlenderWorkspace *ws = alloc.Construct<PoseBlenderWorkspace>();
+		ws->m_SkeletonPose = skeleton::CreateSkeletonPose(constant->m_Skeleton, alloc);
+
+		return ws;
+	}
+	void DestroyPoseBlenderWorkspace(PoseBlenderWorkspace * workspace, memory::Allocator& alloc)
+	{
+		if(workspace)
+		{
+			skeleton::DestroySkeletonPose(workspace->m_SkeletonPose, alloc);
+			alloc.Deallocate(workspace);
+		}
+	}
+
+	PoseBlenderMemory* CreatePoseBlenderMemory(PoseBlenderConstant const* constant, memory::Allocator& alloc)
+	{
+		PoseBlenderMemory* mem = alloc.Construct<PoseBlenderMemory>();
+
+		if(constant->m_EvaluationGraph)
+		{
+			mem->m_GraphWS = graph::CreateEvaluationGraphWorkspace(constant->m_EvaluationGraph, alloc);
+			mem->m_InputPoseBlenderBindingCount = 0;
+			uint32_t i,j;
+			for(i=0;i<constant->m_EvaluationGraph->m_Output->mPlugCount;i++)
+			{
+				graph::GraphPlug const* plug = constant->m_EvaluationGraph->m_Output->mPlugArray[i];
+				for(j=0;j<constant->m_SkeletonPoseCount;j++)
+				{
+					if( plug->m_ID == constant->m_PosesID[j])
+					{
+						mem->m_InputPoseBlenderBindingCount++;
+					}
+				}
+			}
+			if(mem->m_InputPoseBlenderBindingCount)
+			{
+				mem->m_InputPoseBlenderBinding = alloc.ConstructArray<SetPoseBlenderInput2>(mem->m_InputPoseBlenderBindingCount);
+				uint32_t k = 0;
+				for(i=0;i<constant->m_EvaluationGraph->m_Output->mPlugCount;i++)
+				{
+					graph::GraphPlug const* plug = constant->m_EvaluationGraph->m_Output->mPlugArray[i];
+					for(j=0;j<constant->m_SkeletonPoseCount;j++)
+					{
+						if( plug->m_ID == constant->m_PosesID[j])
+						{
+							mem->m_InputPoseBlenderBinding[k++] = bind( SetPoseBlenderValue, plug, j);
+						}
+					}
+				}
+			}
+		}
+
+		return mem;
+	}
+
+	void DestroyPoseBlenderMemory(PoseBlenderMemory* memory, memory::Allocator& alloc)
+	{
+		if(memory)
+		{
+			graph::DestroyEvaluationGraphWorkspace(memory->m_GraphWS, alloc);
+			alloc.Deallocate(memory->m_InputPoseBlenderBinding);
+			alloc.Deallocate(memory);
+		}
+	}
+
+
+	PoseBlenderOutput* CreatePoseBlenderOutput(PoseBlenderConstant const* constant, memory::Allocator& alloc)
+	{
+		PoseBlenderOutput *out = alloc.Construct<PoseBlenderOutput>();
+		out->m_SkeletonPose = skeleton::CreateSkeletonPose(constant->m_Skeleton, alloc);
+
+		return out;
+	}
+
+	void DestroyPoseBlenderOutput(PoseBlenderOutput * output, memory::Allocator& alloc)
+	{
+		if(output)
+		{
+			skeleton::DestroySkeletonPose(output->m_SkeletonPose, alloc);
+			alloc.Deallocate(output);
+		}
+	}
+
+	void EvaluatePoseBlender(PoseBlenderConstant const * constant, PoseBlenderInput const * input, PoseBlenderOutput * output, PoseBlenderMemory* memory, PoseBlenderWorkspace * workspace)
+	{		
+		if(constant->m_EvaluationGraph)
+		{
+			memory->m_GraphWS->m_EvaluationInfo.m_EvaluationId++;
+
+			// Value Array is constructed based on graph so they should be sync
+			uint32_t i, count = constant->m_ValuesConstant->m_Count;
+			for(i=0;i<count;i++)
+			{
+				SetPlugValue(&constant->m_EvaluationGraph->m_Input->GetPlug(i), i, input->m_Values, memory->m_GraphWS);
+			}
+			
+			count = memory->m_InputPoseBlenderBindingCount;
+			for(i=0;i<count;i++)
+			{
+				memory->m_InputPoseBlenderBinding[i](input, memory->m_GraphWS);			
+			}
+		}
+
+		skeleton::SkeletonPoseCopy(input->m_SkeletonPose, output->m_SkeletonPose);
+		uint32_t i;
+		for(i = 0; i < constant->m_SkeletonPoseCount; i++)
+		{
+			skeleton::SkeletonPoseSub(constant->m_SkeletonPoseArray[i], input->m_SkeletonPose, workspace->m_SkeletonPose);
+			skeleton::SkeletonPoseWeight(workspace->m_SkeletonPose, math::float1(input->m_WeightArray[i]), workspace->m_SkeletonPose);
+			skeleton::SkeletonPoseAdd(output->m_SkeletonPose, workspace->m_SkeletonPose, output->m_SkeletonPose);
+		}
+	}	
+}
+
+}