1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
|
#include "UnityPrefix.h"
#include "Runtime/mecanim/animation/curvedata.h"
namespace mecanim
{
namespace animation
{
Clip* CreateClipSimple(uint32_t count, memory::Allocator& alloc)
{
SETPROFILERLABEL(Clip);
// Allocate data.
Clip* clip = alloc.Construct<Clip>();
return clip;
}
void DestroyClip(Clip* clip, memory::Allocator& alloc)
{
if(clip)
{
DestroyStreamedClip(clip->m_StreamedClip, alloc);
DestroyDenseClip(clip->m_DenseClip, alloc);
alloc.Deallocate(clip);
}
}
ClipMemory* CreateClipMemory(Clip const* clip, memory::Allocator& alloc)
{
return CreateClipMemory(clip, GetClipCurveCount(*clip), alloc);
}
ClipMemory* CreateClipMemory(Clip const* clip, int32_t totalUsedCurves, memory::Allocator& alloc)
{
SETPROFILERLABEL(ClipMemory);
ClipMemory* mem = alloc.Construct<ClipMemory>();
mem->m_ConstantClipValueCount = totalUsedCurves - (GetClipCurveCount(*clip) - clip->m_ConstantClip.curveCount);
Assert(mem->m_ConstantClipValueCount >= 0 && mem->m_ConstantClipValueCount <= clip->m_ConstantClip.curveCount);
CreateStreamedClipMemory(clip->m_StreamedClip, mem->m_StreamedClipCache, alloc);
return mem;
}
void DestroyClipMemory(ClipMemory* memory, memory::Allocator& alloc)
{
if(memory)
{
DestroyStreamedClipMemory(memory->m_StreamedClipCache, alloc);
alloc.Deallocate(memory);
}
}
ClipOutput* CreateClipOutput(Clip const* clip, memory::Allocator& alloc)
{
return CreateClipOutput(GetClipCurveCount(*clip), alloc);
}
ClipOutput* CreateClipOutput(int32_t totalUsedCurves, memory::Allocator& alloc)
{
SETPROFILERLABEL(ClipOutput);
ClipOutput* out = alloc.Construct<ClipOutput>();
out->m_Values = alloc.ConstructArray<float> (totalUsedCurves);
return out;
}
void DestroyClipOutput(ClipOutput* output, memory::Allocator& alloc)
{
if(output)
{
alloc.Deallocate(output->m_Values);
alloc.Deallocate(output);
}
}
float EvaluateClipAtIndex(Clip const* clip, ClipInput const* input, ClipMemory* memory, uint32_t index)
{
if (index < clip->m_StreamedClip.curveCount)
return SampleClipAtIndex(clip->m_StreamedClip, memory->m_StreamedClipCache, index, input->m_Time);
index -= clip->m_StreamedClip.curveCount;
if (index < clip->m_DenseClip.m_CurveCount)
return SampleClipAtIndex(clip->m_DenseClip, index, input->m_Time);
index -= clip->m_DenseClip.m_CurveCount;
return SampleClipAtIndex(clip->m_ConstantClip, index);
}
void EvaluateClip(Clip const* clip, ClipInput const* input, ClipMemory* memory, ClipOutput* output )
{
float* outputData = output->m_Values;
if (clip->m_StreamedClip.curveCount != 0)
{
SampleClip(clip->m_StreamedClip, memory->m_StreamedClipCache, input->m_Time, outputData);
outputData += clip->m_StreamedClip.curveCount;
}
if (clip->m_DenseClip.m_CurveCount != 0)
{
SampleClip(clip->m_DenseClip, input->m_Time, outputData);
outputData += clip->m_DenseClip.m_CurveCount;
}
if (memory->m_ConstantClipValueCount != 0)
{
// Constant clips are not sampling based on the total curve count
SampleClip(clip->m_ConstantClip, memory->m_ConstantClipValueCount, outputData);
}
}
}
}
|
