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
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
|
#pragma once
#include "Runtime/mecanim/defs.h"
#include "Runtime/mecanim/memory.h"
#include "Runtime/mecanim/types.h"
#include "Runtime/mecanim/generic/crc32.h"
#include "Runtime/mecanim/generic/typetraits.h"
#include "Runtime/Serialize/Blobification/offsetptr.h"
#include "Runtime/Serialize/TransferFunctions/SerializeTransfer.h"
#include "Runtime/Animation/MecanimArraySerialization.h"
namespace mecanim
{
struct ValueConstant
{
DEFINE_GET_TYPESTRING(ValueConstant)
ValueConstant():m_ID(0),m_Type(kLastType),m_TypeID(0),m_Index(0){}
uint32_t m_ID;
uint32_t m_TypeID; //@TODO: This is deprecated. We should probably make this webplayer only?
uint32_t m_Type;
uint32_t m_Index;
template<class TransferFunction>
inline void Transfer (TransferFunction& transfer)
{
TRANSFER(m_ID);
TRANSFER(m_TypeID);
TRANSFER(m_Type);
TRANSFER(m_Index);
}
};
struct ValueArrayConstant
{
DEFINE_GET_TYPESTRING(ValueArrayConstant)
ValueArrayConstant():m_Count(0){}
uint32_t m_Count;
OffsetPtr<ValueConstant> m_ValueArray;
template<class TransferFunction>
inline void Transfer (TransferFunction& transfer)
{
TRANSFER_BLOB_ONLY(m_Count);
MANUAL_ARRAY_TRANSFER2(ValueConstant, m_ValueArray, m_Count);
}
};
struct ValueArrayMask
{
DEFINE_GET_TYPESTRING(ValueArrayConstant)
ValueArrayMask():m_BoolCount(0),m_IntCount(0),m_FloatCount(0),m_PositionCount(0),m_QuaternionCount(0),m_ScaleCount(0) {}
uint32_t m_BoolCount;
OffsetPtr<bool> m_BoolValues;
uint32_t m_IntCount;
OffsetPtr<bool> m_IntValues;
uint32_t m_FloatCount;
OffsetPtr<bool> m_FloatValues;
uint32_t m_PositionCount;
OffsetPtr<bool> m_PositionValues;
uint32_t m_QuaternionCount;
OffsetPtr<bool> m_QuaternionValues;
uint32_t m_ScaleCount;
OffsetPtr<bool> m_ScaleValues;
template<class TransferFunction>
inline void Transfer (TransferFunction& transfer)
{
TRANSFER_BLOB_ONLY(m_BoolCount);
MANUAL_ARRAY_TRANSFER2(bool, m_BoolValues, m_BoolCount);
TRANSFER_BLOB_ONLY(m_IntCount);
MANUAL_ARRAY_TRANSFER2(bool, m_IntValues, m_IntCount);
TRANSFER_BLOB_ONLY(m_FloatCount);
MANUAL_ARRAY_TRANSFER2(bool, m_FloatValues, m_FloatCount);
TRANSFER_BLOB_ONLY(m_PositionCount);
MANUAL_ARRAY_TRANSFER2(bool, m_PositionValues, m_PositionCount);
TRANSFER_BLOB_ONLY(m_QuaternionCount);
MANUAL_ARRAY_TRANSFER2(bool, m_QuaternionValues, m_QuaternionCount);
TRANSFER_BLOB_ONLY(m_ScaleCount);
MANUAL_ARRAY_TRANSFER2(bool, m_ScaleValues, m_ScaleCount);
}
};
struct ValueArray
{
DEFINE_GET_TYPESTRING(ValueArray)
ValueArray():m_BoolCount(0),m_IntCount(0),m_FloatCount(0),m_PositionCount(0),m_QuaternionCount(0),m_ScaleCount(0) {}
uint32_t m_BoolCount;
OffsetPtr<bool> m_BoolValues;
uint32_t m_IntCount;
OffsetPtr<int32_t> m_IntValues;
uint32_t m_FloatCount;
OffsetPtr<float> m_FloatValues;
uint32_t m_PositionCount;
OffsetPtr<math::float4> m_PositionValues;
uint32_t m_QuaternionCount;
OffsetPtr<math::float4> m_QuaternionValues;
uint32_t m_ScaleCount;
OffsetPtr<math::float4> m_ScaleValues;
MECANIM_FORCE_INLINE void ReadData(bool& data, uint32_t index)const
{
Assert(index < m_BoolCount);
data = m_BoolValues[index];
}
MECANIM_FORCE_INLINE void WriteData(bool const& data, uint32_t index)
{
Assert(index < m_BoolCount);
m_BoolValues[index] = data;
}
MECANIM_FORCE_INLINE void ReadData(int32_t& data, uint32_t index)const
{
Assert(index < m_IntCount);
data = m_IntValues[index];
}
MECANIM_FORCE_INLINE void WriteData(int32_t const& data, uint32_t index)
{
Assert(index < m_IntCount);
m_IntValues[index] = data;
}
MECANIM_FORCE_INLINE void ReadData(float& data, uint32_t index)const
{
Assert(index < m_FloatCount);
data = m_FloatValues[index];
}
MECANIM_FORCE_INLINE void WriteData(float const& data, uint32_t index)
{
Assert(index < m_FloatCount);
m_FloatValues[index] = data;
}
MECANIM_FORCE_INLINE math::float4 ReadPosition(uint32_t index)const
{
Assert(index < m_PositionCount);
return m_PositionValues[index];
}
MECANIM_FORCE_INLINE void WritePosition(math::float4 const& data, uint32_t index)
{
Assert(index < m_PositionCount);
m_PositionValues[index] = data;
}
MECANIM_FORCE_INLINE math::float4 ReadQuaternion(uint32_t index)const
{
Assert(index < m_QuaternionCount);
return m_QuaternionValues[index];
}
MECANIM_FORCE_INLINE void WriteQuaternion(math::float4 const& data, uint32_t index)
{
Assert(index < m_QuaternionCount);
m_QuaternionValues[index] = data;
}
MECANIM_FORCE_INLINE math::float4 ReadScale(uint32_t index)const
{
Assert(index < m_ScaleCount);
return m_ScaleValues[index];
}
MECANIM_FORCE_INLINE void WriteScale(math::float4 const& data, uint32_t index)
{
Assert(index < m_ScaleCount);
m_ScaleValues[index] = data;
}
const float* GetFloatValues () const
{
return m_FloatValues.Get();
}
float* GetFloatValues ()
{
return m_FloatValues.Get();
}
template<class TransferFunction>
inline void Transfer (TransferFunction& transfer)
{
TRANSFER_BLOB_ONLY(m_BoolCount);
MANUAL_ARRAY_TRANSFER2(bool, m_BoolValues, m_BoolCount);
transfer.Align();
TRANSFER_BLOB_ONLY(m_IntCount);
MANUAL_ARRAY_TRANSFER2(int32_t, m_IntValues, m_IntCount);
TRANSFER_BLOB_ONLY(m_FloatCount);
MANUAL_ARRAY_TRANSFER2(float, m_FloatValues, m_FloatCount);
TRANSFER_BLOB_ONLY(m_PositionCount);
MANUAL_ARRAY_TRANSFER2(math::float4, m_PositionValues, m_PositionCount);
TRANSFER_BLOB_ONLY(m_QuaternionCount);
MANUAL_ARRAY_TRANSFER2(math::float4, m_QuaternionValues, m_QuaternionCount);
TRANSFER_BLOB_ONLY(m_ScaleCount);
MANUAL_ARRAY_TRANSFER2(math::float4, m_ScaleValues, m_ScaleCount);
}
};
void SetupValueArrayConstant(ValueArrayConstant* constant, ValueType aType, uint32_t aCount, memory::Allocator& alloc);
ValueArrayConstant* CreateValueArrayConstant(uint32_t* typeArray, uint32_t count, memory::Allocator& alloc);
ValueArrayConstant* CreateValueArrayConstantCopy(const ValueArrayConstant* constant, uint32_t count, memory::Allocator& alloc);
ValueArrayConstant* CreateValueArrayConstant(ValueType type, uint32_t count, memory::Allocator& alloc);
void DestroyValueArrayConstant(ValueArrayConstant * constant, memory::Allocator& alloc);
ValueArrayMask* CreateValueArrayMask(ValueArrayConstant const* constant, memory::Allocator& alloc);
void DestroyValueArrayMask(ValueArrayMask *valueArrayMask, memory::Allocator& alloc);
void SetValueMask(ValueArrayMask *valueArrayMask, bool value);
void CopyValueMask(ValueArrayMask *valueArrayMask,ValueArrayMask const *srcValueArrayMask);
void OrValueMask(ValueArrayMask *valueArrayMask,ValueArrayMask const *srcValueArrayMask);
void AndValueMask(ValueArrayMask *valueArrayMask,ValueArrayMask const *srcValueArrayMask);
void InvertValueMask(ValueArrayMask *valueArrayMask);
ValueArray* CreateValueArray(ValueArrayConstant const* constant, memory::Allocator& alloc);
void DestroyValueArray(ValueArray * valueArray, memory::Allocator& alloc);
void ValueArrayCopy(ValueArray const* source, ValueArray* destination);
void ValueArrayCopy(ValueArrayConstant const* sourceConstant, ValueArray const* source, ValueArrayConstant const* destinationConstant, ValueArray* destination, int32_t const* destinationInSourceIndexArray);
void ValueArrayReverseCopy(ValueArrayConstant const* sourceConstant, ValueArray const* source, ValueArrayConstant const* destinationConstant, ValueArray* destination, int32_t const* sourceInDestinationIndexArray);
void ValueArrayCopy(ValueArray const *aSource, ValueArray* aValues, ValueArrayMask const *mask);
void ValueArrayBlend(ValueArray const *apValuesDefault,ValueArray* aValues, ValueArray ** aValuesArray, const float *apWeightArray, uint32_t aCount, const ValueArrayMask *mask);
void ValueArrayAdd(ValueArray const *apValuesDefault, ValueArray const* apValues, ValueArrayMask const *readMask, float aWeight, bool aAdditive, ValueArray* apValuesOut, ValueArrayMask *defaultMask);
void ValueArraySub(ValueArray const &starts, ValueArray &values, ValueArrayMask const *mask);
void ValueArrayLoop(ValueArray const &starts, ValueArray const &stops, ValueArray &values, float loopWeight, const ValueArrayMask& mask);
int32_t FindValueIndex(const ValueArrayConstant *constant, uint32_t id);
STATIC_INLINE int32_t FindValueIndex(const ValueArrayConstant *constant, char const* binding)
{
return FindValueIndex(constant, processCRC32(binding));
}
}
|
