public bool ReadEntityValue(AUT_WH.MajorDomoProtocol.EntityValue _value)
{
bool modified = false;
int dataSize = _value.ValueLength;
// is this a variable size value?
if ((dataSize != m_data.Length) && !m_fixedSize)
{
// yes: adapt buffer
m_data = new byte[dataSize];
m_buffer = new FlatBuffers.ByteBuffer(m_data);
modified = true;
}
else
{
// no: limit to data size
dataSize = Math.Min(dataSize, m_data.Length);
}
// copy over the bytes, checking for changes
for (int i = 0; i < dataSize; i++)
{
byte b = (byte)_value.Value(i);
modified |= (m_data[i] != b);
m_data[i] = b;
}
m_updated |= modified;
return(modified);
}
protected RecordBatch ReadRecordBatch()
{
ReadSchema();
int messageLength = ReadMessageLength(throwOnFullRead: false);
if (messageLength == 0)
{
// reached end
return(null);
}
RecordBatch result = null;
ArrayPool <byte> .Shared.RentReturn(messageLength, messageBuff =>
{
int bytesRead = BaseStream.ReadFullBuffer(messageBuff);
EnsureFullRead(messageBuff, bytesRead);
Flatbuf.Message message = Flatbuf.Message.GetRootAsMessage(CreateByteBuffer(messageBuff));
int bodyLength = checked ((int)message.BodyLength);
IMemoryOwner <byte> bodyBuffOwner = _allocator.Allocate(bodyLength);
Memory <byte> bodyBuff = bodyBuffOwner.Memory.Slice(0, bodyLength);
bytesRead = BaseStream.ReadFullBuffer(bodyBuff);
EnsureFullRead(bodyBuff, bytesRead);
FlatBuffers.ByteBuffer bodybb = CreateByteBuffer(bodyBuff);
result = CreateArrowObjectFromMessage(message, bodybb, bodyBuffOwner);
});
return(result);
}
private static ArrayData LoadVariableField(Field field,
Flatbuf.FieldNode fieldNode,
Flatbuf.RecordBatch recordBatch,
FlatBuffers.ByteBuffer bodyData,
ref int bufferIndex)
{
var nullBitmapBuffer = recordBatch.Buffers(bufferIndex++).GetValueOrDefault();
var offsetBuffer = recordBatch.Buffers(bufferIndex++).GetValueOrDefault();
var valueBuffer = recordBatch.Buffers(bufferIndex++).GetValueOrDefault();
ArrowBuffer nullArrowBuffer = BuildArrowBuffer(bodyData, nullBitmapBuffer);
ArrowBuffer offsetArrowBuffer = BuildArrowBuffer(bodyData, offsetBuffer);
ArrowBuffer valueArrowBuffer = BuildArrowBuffer(bodyData, valueBuffer);
var fieldLength = (int)fieldNode.Length;
var fieldNullCount = (int)fieldNode.NullCount;
if (fieldLength < 0)
{
throw new InvalidDataException("Field length must be >= 0"); // TODO: Localize exception message
}
if (fieldNullCount < 0)
{
throw new InvalidDataException("Null count length must be >= 0"); //TODO: Localize exception message
}
var arrowBuff = new[] { nullArrowBuffer, offsetArrowBuffer, valueArrowBuffer };
return(new ArrayData(field.DataType, fieldLength, fieldNullCount, 0, arrowBuff));
}
public void test()
{
FlatBuffers.ByteBuffer bb = FlatBufferManager.Instance.GetSkillData("skillconfig");
skillconfigTB tb = skillconfigTB.GetRootAsskillconfigTB(bb);
skillconfigTR tr = (skillconfigTR)tb.SkillconfigTRSByKey(1003);
Logger.Log($" {tr._id} : {tr._name} : {tr._skillprefab}");
}
private void OnFlatBuffersUpdated(FlatBuffers.ByteBuffer buffer)
{
ClientDataUtil.OnFlatBuffersUpdated(buffer);
#region 强制回收GC
System.GC.Collect(System.GC.MaxGeneration, System.GCCollectionMode.Forced);
System.GC.WaitForPendingFinalizers();
System.GC.Collect();
#endregion
}
private static ArrowBuffer BuildArrowBuffer(FlatBuffers.ByteBuffer bodyData, Flatbuf.Buffer buffer)
{
if (buffer.Length <= 0)
{
return(null);
}
var segment = bodyData.ToArraySegment((int)buffer.Offset, (int)buffer.Length);
return(ArrowBuffer.FromMemory(segment));
}
public EntityValue(string _name, AUT_WH.MajorDomoProtocol.EntityValueType _type, byte _index, ushort _size)
{
Name = _name;
Type = _type;
Index = _index;
m_data = new byte[_size];
m_buffer = new FlatBuffers.ByteBuffer(m_data);
m_modified = false;
m_updated = false;
m_fixedSize = (_size > 0); // size > 0 indicates a fixed size buffer, size 0 as length indicates a variable length
}
/// <summary>
/// Returns latest frame's hands.
/// </summary>
/// <param name="buffer">Byte buffer to use for deserialization.</param>
/// <param name="frameHands">FrameHands datastructure to populate.</param>
/// <returns></returns>
public static bool GetFrameHandsFlatbufferObject(ref byte[] buffer, out FrameHands frameHands)
{
if (meta_get_frame_hands(buffer) == 0)
{
frameHands = new FrameHands();
return(false);
}
var byteBuffer = new FlatBuffers.ByteBuffer(buffer);
frameHands = FrameHands.GetRootAsFrameHands(byteBuffer);
return(true);
}
private static ArrowBuffer BuildArrowBuffer(FlatBuffers.ByteBuffer bodyData, Flatbuf.Buffer buffer)
{
if (buffer.Length <= 0)
{
return(ArrowBuffer.Empty);
}
var segment = bodyData.ToArraySegment((int)buffer.Offset, (int)buffer.Length);
return(new ArrowBuffer.Builder <byte>(segment.Count)
.Append(segment)
.Build());
}
public static bool GetPose(string source, string target, ref byte[] buffer, out PoseType poseType)
{
if (MetaCoreInterop.meta_get_pose(source, target, buffer))
{
poseType = new PoseType();
return(false);
}
var byteBuffer = new FlatBuffers.ByteBuffer(buffer);
poseType = PoseType.GetRootAsPoseType(byteBuffer);
return(true);
}
protected static T ReadMessage <T>(FlatBuffers.ByteBuffer bb) where T : struct, FlatBuffers.IFlatbufferObject
{
var returnType = typeof(T);
var msg = Flatbuf.Message.GetRootAsMessage(bb);
if (MatchEnum(msg.HeaderType, returnType))
{
return(msg.Header <T>().Value);
}
else
{
throw new Exception($"Requested type '{returnType.Name}' " +
$"did not match type found at offset => '{msg.HeaderType}'");
}
}
static StackObject *get_Position_0(ILIntepreter __intp, StackObject *__esp, IList <object> __mStack, CLRMethod __method, bool isNewObj)
{
ILRuntime.Runtime.Enviorment.AppDomain __domain = __intp.AppDomain;
StackObject *ptr_of_this_method;
StackObject *__ret = ILIntepreter.Minus(__esp, 1);
ptr_of_this_method = ILIntepreter.Minus(__esp, 1);
FlatBuffers.ByteBuffer instance_of_this_method = (FlatBuffers.ByteBuffer) typeof(FlatBuffers.ByteBuffer).CheckCLRTypes(StackObject.ToObject(ptr_of_this_method, __domain, __mStack));
__intp.Free(ptr_of_this_method);
var result_of_this_method = instance_of_this_method.Position;
__ret->ObjectType = ObjectTypes.Integer;
__ret->Value = result_of_this_method;
return(__ret + 1);
}
protected async ValueTask <RecordBatch> ReadRecordBatchAsync(CancellationToken cancellationToken = default)
{
await ReadSchemaAsync().ConfigureAwait(false);
int messageLength = 0;
await ArrayPool <byte> .Shared.RentReturnAsync(4, async (lengthBuffer) =>
{
// Get Length of record batch for message header.
int bytesRead = await BaseStream.ReadFullBufferAsync(lengthBuffer, cancellationToken)
.ConfigureAwait(false);
if (bytesRead == 4)
{
messageLength = BitUtility.ReadInt32(lengthBuffer);
}
}).ConfigureAwait(false);
if (messageLength == 0)
{
// reached end
return(null);
}
RecordBatch result = null;
await ArrayPool <byte> .Shared.RentReturnAsync(messageLength, async (messageBuff) =>
{
int bytesRead = await BaseStream.ReadFullBufferAsync(messageBuff, cancellationToken)
.ConfigureAwait(false);
EnsureFullRead(messageBuff, bytesRead);
Flatbuf.Message message = Flatbuf.Message.GetRootAsMessage(CreateByteBuffer(messageBuff));
int bodyLength = checked ((int)message.BodyLength);
IMemoryOwner <byte> bodyBuffOwner = _allocator.Allocate(bodyLength);
Memory <byte> bodyBuff = bodyBuffOwner?.Memory.Slice(0, bodyLength) ?? Memory <byte> .Empty;
bytesRead = await BaseStream.ReadFullBufferAsync(bodyBuff, cancellationToken)
.ConfigureAwait(false);
EnsureFullRead(bodyBuff, bytesRead);
FlatBuffers.ByteBuffer bodybb = CreateByteBuffer(bodyBuff);
result = CreateArrowObjectFromMessage(message, bodybb, bodyBuffOwner);
}).ConfigureAwait(false);
return(result);
}
protected async ValueTask <RecordBatch> ReadRecordBatchAsync(CancellationToken cancellationToken = default)
{
await ReadSchemaAsync().ConfigureAwait(false);
int messageLength = 0;
await Buffers.RentReturnAsync(4, async (lengthBuffer) =>
{
// Get Length of record batch for message header.
int bytesRead = await BaseStream.ReadFullBufferAsync(lengthBuffer, cancellationToken)
.ConfigureAwait(false);
if (bytesRead == 4)
{
messageLength = BitUtility.ReadInt32(lengthBuffer);
}
}).ConfigureAwait(false);
if (messageLength == 0)
{
// reached end
return(null);
}
RecordBatch result = null;
await Buffers.RentReturnAsync(messageLength, async (messageBuff) =>
{
int bytesRead = await BaseStream.ReadFullBufferAsync(messageBuff, cancellationToken)
.ConfigureAwait(false);
EnsureFullRead(messageBuff, bytesRead);
Flatbuf.Message message = Flatbuf.Message.GetRootAsMessage(CreateByteBuffer(messageBuff));
await Buffers.RentReturnAsync((int)message.BodyLength, async(bodyBuff) =>
{
int bodyBytesRead = await BaseStream.ReadFullBufferAsync(bodyBuff, cancellationToken)
.ConfigureAwait(false);
EnsureFullRead(bodyBuff, bodyBytesRead);
FlatBuffers.ByteBuffer bodybb = CreateByteBuffer(bodyBuff);
result = CreateArrowObjectFromMessage(message, bodybb);
}).ConfigureAwait(false);
}).ConfigureAwait(false);
return(result);
}
public void Excute()
{
int bufferSize = 0;
Protocol protocolType = Protocol.NONE;
while (_recvBuffer.Size() > Consts.PACKET_HEADER_SIZE)
{
Debug.LogWarning("--- _recvBuffer.Size : " + _recvBuffer.Size());
lock (_recvBuffer)
{
_recvBuffer.Read(_rawAnalysisBuffer, Consts.PACKET_HEADER_SIZE);
}
FlatBuffers.ByteBuffer analysisBuffer = new FlatBuffers.ByteBuffer(_rawAnalysisBuffer);
//패킷 헤더 읽기
bufferSize = analysisBuffer.GetUshort(0);
protocolType = (Protocol)analysisBuffer.GetUshort(sizeof(short));
Debug.LogWarning("--- recv packet : " + protocolType + "|" + bufferSize);
//패킷 버퍼가 모두 수신되지 않아 파싱 중지
if (bufferSize > _recvBuffer.Size())
{
Debug.LogWarning("--- wait read full body : " + _recvBuffer.Size() + "/" + bufferSize);
break;
}
lock (_recvBuffer)
{
_recvBuffer.Pop(_rawAnalysisBuffer, bufferSize);
}
if (_protocolDelegates.ContainsKey(protocolType))
{
_protocolDelegates[protocolType](GetFlatBufferObject(protocolType, _rawAnalysisBuffer, Consts.PACKET_HEADER_SIZE));
}
else
{
Debug.LogWarning("--- not register protocol : " + protocolType);
}
}
}
static StackObject *Ctor_0(ILIntepreter __intp, StackObject *__esp, IList <object> __mStack, CLRMethod __method, bool isNewObj)
{
ILRuntime.Runtime.Enviorment.AppDomain __domain = __intp.AppDomain;
StackObject *ptr_of_this_method;
StackObject *__ret = ILIntepreter.Minus(__esp, 2);
ptr_of_this_method = ILIntepreter.Minus(__esp, 1);
System.Int32 @pos = ptr_of_this_method->Value;
ptr_of_this_method = ILIntepreter.Minus(__esp, 2);
System.Byte[] @buffer = (System.Byte[]) typeof(System.Byte[]).CheckCLRTypes(StackObject.ToObject(ptr_of_this_method, __domain, __mStack));
__intp.Free(ptr_of_this_method);
var result_of_this_method = new FlatBuffers.ByteBuffer(@buffer, @pos);
return(ILIntepreter.PushObject(__ret, __mStack, result_of_this_method));
}
protected RecordBatch ReadRecordBatch()
{
ReadSchema();
int messageLength = 0;
Buffers.RentReturn(4, lengthBuffer =>
{
int bytesRead = BaseStream.ReadFullBuffer(lengthBuffer);
if (bytesRead == 4)
{
messageLength = BitUtility.ReadInt32(lengthBuffer);
}
});
if (messageLength == 0)
{
// reached end
return(null);
}
RecordBatch result = null;
Buffers.RentReturn(messageLength, messageBuff =>
{
int bytesRead = BaseStream.ReadFullBuffer(messageBuff);
EnsureFullRead(messageBuff, bytesRead);
Flatbuf.Message message = Flatbuf.Message.GetRootAsMessage(CreateByteBuffer(messageBuff));
Buffers.RentReturn((int)message.BodyLength, bodyBuff =>
{
int bodyBytesRead = BaseStream.ReadFullBuffer(bodyBuff);
EnsureFullRead(bodyBuff, bodyBytesRead);
FlatBuffers.ByteBuffer bodybb = CreateByteBuffer(bodyBuff);
result = CreateArrowObjectFromMessage(message, bodybb);
});
});
return(result);
}
static StackObject *GetFloat_3(ILIntepreter __intp, StackObject *__esp, IList <object> __mStack, CLRMethod __method, bool isNewObj)
{
ILRuntime.Runtime.Enviorment.AppDomain __domain = __intp.AppDomain;
StackObject *ptr_of_this_method;
StackObject *__ret = ILIntepreter.Minus(__esp, 2);
ptr_of_this_method = ILIntepreter.Minus(__esp, 1);
System.Int32 @offset = ptr_of_this_method->Value;
ptr_of_this_method = ILIntepreter.Minus(__esp, 2);
FlatBuffers.ByteBuffer instance_of_this_method = (FlatBuffers.ByteBuffer) typeof(FlatBuffers.ByteBuffer).CheckCLRTypes(StackObject.ToObject(ptr_of_this_method, __domain, __mStack));
__intp.Free(ptr_of_this_method);
var result_of_this_method = instance_of_this_method.GetFloat(@offset);
__ret->ObjectType = ObjectTypes.Float;
*(float *)&__ret->Value = result_of_this_method;
return(__ret + 1);
}
protected virtual void ReadSchema()
{
if (HasReadSchema)
{
return;
}
// Figure out length of schema
int schemaMessageLength = ReadMessageLength(throwOnFullRead: true);
ArrayPool <byte> .Shared.RentReturn(schemaMessageLength, buff =>
{
int bytesRead = BaseStream.ReadFullBuffer(buff);
EnsureFullRead(buff, bytesRead);
FlatBuffers.ByteBuffer schemabb = CreateByteBuffer(buff);
Schema = MessageSerializer.GetSchema(ReadMessage <Flatbuf.Schema>(schemabb), ref _dictionaryMemo);
});
}
protected virtual async ValueTask ReadSchemaAsync()
{
if (HasReadSchema)
{
return;
}
// Figure out length of schema
int schemaMessageLength = await ReadMessageLengthAsync(throwOnFullRead : true)
.ConfigureAwait(false);
await ArrayPool <byte> .Shared.RentReturnAsync(schemaMessageLength, async (buff) =>
{
// Read in schema
int bytesRead = await BaseStream.ReadFullBufferAsync(buff).ConfigureAwait(false);
EnsureFullRead(buff, bytesRead);
FlatBuffers.ByteBuffer schemabb = CreateByteBuffer(buff);
Schema = MessageSerializer.GetSchema(ReadMessage <Flatbuf.Schema>(schemabb), ref _dictionaryMemo);
}).ConfigureAwait(false);
}
protected async ValueTask <RecordBatch> ReadRecordBatchAsync(CancellationToken cancellationToken = default)
{
await ReadSchemaAsync().ConfigureAwait(false);
RecordBatch result = null;
while (result == null)
{
int messageLength = await ReadMessageLengthAsync(throwOnFullRead : false, cancellationToken)
.ConfigureAwait(false);
if (messageLength == 0)
{
// reached end
return(null);
}
await ArrayPool <byte> .Shared.RentReturnAsync(messageLength, async (messageBuff) =>
{
int bytesRead = await BaseStream.ReadFullBufferAsync(messageBuff, cancellationToken)
.ConfigureAwait(false);
EnsureFullRead(messageBuff, bytesRead);
Flatbuf.Message message = Flatbuf.Message.GetRootAsMessage(CreateByteBuffer(messageBuff));
int bodyLength = checked ((int)message.BodyLength);
IMemoryOwner <byte> bodyBuffOwner = _allocator.Allocate(bodyLength);
Memory <byte> bodyBuff = bodyBuffOwner.Memory.Slice(0, bodyLength);
bytesRead = await BaseStream.ReadFullBufferAsync(bodyBuff, cancellationToken)
.ConfigureAwait(false);
EnsureFullRead(bodyBuff, bytesRead);
FlatBuffers.ByteBuffer bodybb = CreateByteBuffer(bodyBuff);
result = CreateArrowObjectFromMessage(message, bodybb, bodyBuffOwner);
}).ConfigureAwait(false);
}
return(result);
}
protected virtual async Task <Schema> ReadSchemaAsync()
{
if (HasReadSchema)
{
return(Schema);
}
byte[] buff = null;
try
{
// Figure out length of schema
buff = Buffers.Rent(4);
await BaseStream.ReadAsync(buff, 0, 4);
var schemaMessageLength = BitConverter.ToInt32(buff, 0);
Buffers.Return(buff);
// Allocate byte array for schema flat buffer
buff = Buffers.Rent(schemaMessageLength);
var schemabb = new FlatBuffers.ByteBuffer(buff);
// Read in schema
await BaseStream.ReadAsync(buff, 0, schemaMessageLength);
Schema = MessageSerializer.GetSchema(ReadMessage <Flatbuf.Schema>(schemabb));
return(Schema);
}
finally
{
if (buff != null)
{
Buffers.Return(buff);
}
}
}
public void ReadEntityValue(AUT_WH.MajorDomoProtocol.EntityValueInformation _information)
{
int dataSize = _information.ValueLength;
// is this a variable size value?
if ((dataSize != m_data.Length) && !m_fixedSize)
{
// yes: adapt buffer
m_data = new byte[dataSize];
m_buffer = new FlatBuffers.ByteBuffer(m_data);
}
else
{
// no: limit to data size
dataSize = Math.Min(dataSize, m_data.Length);
}
for (int i = 0; i < dataSize; i++)
{
m_data[i] = (byte)_information.Value(i);
}
m_updated = true;
}
public static void OnFlatBuffersUpdated(FlatBuffers.ByteBuffer buffer)
{
LogWithTime("OnFlatBuffersUpdated=====>");
var config = GM.DataCache.Config.GetRootAsConfig(buffer);
int configLen = config.ArrayLength;
LogWithTime($"OnFlatBuffersUpdated=====>configLen: {configLen}");
for (int i = 0; i < configLen; ++i)
{
var entity = config.GetArray(i);
string name = entity.Name;
string version = entity.Version;
var bufferSegment = entity.GetBufferBytes();
if (bufferSegment == null)
{
EB.Debug.LogWarning("OnFlatBuffersUpdated: buffer is null");
continue;
}
EB.Debug.Log("{0} offset = {1} count = {2}, array = {3}", name, bufferSegment.Value.Offset, bufferSegment.Value.Count, bufferSegment.Value.Array.Length);
SparxHub.Instance.DataCacheManager.ProcessCache(name, version, bufferSegment.Value);
}
LogWithTime("<=====OnFlatBuffersUpdated");
}
protected static IEnumerable <IArrowArray> BuildArrays(Schema schema,
FlatBuffers.ByteBuffer messageBuffer,
Flatbuf.RecordBatch recordBatchMessage)
{
var arrays = new List <ArrayData>();
var bufferIndex = 0;
for (var n = 0; n < recordBatchMessage.NodesLength; n++)
{
var field = schema.GetFieldByIndex(n);
var fieldNode = recordBatchMessage.Nodes(n).GetValueOrDefault();
if (field.DataType.IsFixedPrimitive())
{
arrays.Add(LoadPrimitiveField(field, fieldNode, recordBatchMessage, messageBuffer, ref bufferIndex));
}
else
{
arrays.Add(LoadVariableField(field, fieldNode, recordBatchMessage, messageBuffer, ref bufferIndex));
}
}
return(arrays.Select(ArrowArrayFactory.BuildArray));
}
protected async Task <RecordBatch> ReadRecordBatchAsync(CancellationToken cancellationToken = default)
{
await ReadSchemaAsync();
var bytesRead = 0;
byte[] lengthBuffer = null;
byte[] messageBuff = null;
byte[] bodyBuff = null;
try
{
// Get Length of record batch for message header.
lengthBuffer = Buffers.Rent(4);
bytesRead += await BaseStream.ReadAsync(lengthBuffer, 0, 4, cancellationToken);
var messageLength = BitConverter.ToInt32(lengthBuffer, 0);
messageBuff = Buffers.Rent(messageLength);
bytesRead += await BaseStream.ReadAsync(messageBuff, 0, messageLength, cancellationToken);
var message = Flatbuf.Message.GetRootAsMessage(new FlatBuffers.ByteBuffer(messageBuff));
bodyBuff = Buffers.Rent((int)message.BodyLength);
var bodybb = new FlatBuffers.ByteBuffer(bodyBuff);
bytesRead += await BaseStream.ReadAsync(bodyBuff, 0, (int)message.BodyLength, cancellationToken);
switch (message.HeaderType)
{
case Flatbuf.MessageHeader.Schema:
// TODO: Read schema and verify equality?
break;
case Flatbuf.MessageHeader.DictionaryBatch:
// TODO: not supported currently
Debug.WriteLine("Dictionaries are not yet supported.");
break;
case Flatbuf.MessageHeader.RecordBatch:
var rb = message.Header <Flatbuf.RecordBatch>().Value;
var arrays = BuildArrays(Schema, bodybb, rb);
return(new RecordBatch(Schema, arrays, (int)rb.Length));
default:
// NOTE: Skip unsupported message type
Debug.WriteLine($"Skipping unsupported message type '{message.HeaderType}'");
break;
}
}
finally
{
if (lengthBuffer != null)
{
Buffers.Return(lengthBuffer);
}
if (messageBuff != null)
{
Buffers.Return(messageBuff);
}
if (bodyBuff != null)
{
Buffers.Return(bodyBuff);
}
}
return(null);
}
protected async Task <RecordBatch> ReadRecordBatchAsync(CancellationToken cancellationToken = default)
{
await ReadSchemaAsync().ConfigureAwait(false);
var bytesRead = 0;
byte[] lengthBuffer = null;
byte[] messageBuff = null;
byte[] bodyBuff = null;
try
{
// Get Length of record batch for message header.
lengthBuffer = Buffers.Rent(4);
bytesRead += await BaseStream.ReadAsync(lengthBuffer, 0, 4, cancellationToken)
.ConfigureAwait(false);
if (bytesRead != 4)
{
//reached the end
return(null);
}
var messageLength = BitConverter.ToInt32(lengthBuffer, 0);
if (messageLength == 0)
{
//reached the end
return(null);
}
messageBuff = Buffers.Rent(messageLength);
bytesRead += await BaseStream.ReadAsync(messageBuff, 0, messageLength, cancellationToken)
.ConfigureAwait(false);
var message = Flatbuf.Message.GetRootAsMessage(new FlatBuffers.ByteBuffer(messageBuff));
bodyBuff = Buffers.Rent((int)message.BodyLength);
var bodybb = new FlatBuffers.ByteBuffer(bodyBuff);
bytesRead += await BaseStream.ReadAsync(bodyBuff, 0, (int)message.BodyLength, cancellationToken)
.ConfigureAwait(false);
return(CreateArrowObjectFromMessage(message, bodybb));
}
finally
{
if (lengthBuffer != null)
{
Buffers.Return(lengthBuffer);
}
if (messageBuff != null)
{
Buffers.Return(messageBuff);
}
if (bodyBuff != null)
{
Buffers.Return(bodyBuff);
}
}
}
public static Dictionary<string, object> LoadCreatureFlatDataFromBytes(byte[] flat_bytes)
{
FlatBuffers.ByteBuffer flat_bytes_buffer = new FlatBuffers.ByteBuffer (flat_bytes);
Dictionary<string, object> ret_dict = new Dictionary<string, object>();
var rootObj = CreatureFlatData.rootData.GetRootAsrootData (flat_bytes_buffer);
var meshObj = rootObj.DataMesh;
var skeletonObj = rootObj.DataSkeleton;
var animationObject = rootObj.DataAnimation;
var uvSwapItemsObject = rootObj.DataUvSwapItem;
var anchorPointsObject = rootObj.DataAnchorPoints;
// ------- Process Mesh --------------------------
Dictionary<string, object> mesh_dict = new Dictionary<string, object> ();
// Mesh Points
Object[] write_points = new Object[meshObj.PointsLength];
for (int i = 0; i < write_points.Length; i++) {
write_points[i] = meshObj.GetPoints(i);
}
mesh_dict ["points"] = write_points;
// Mesh Uvs
Object[] write_uvs = new Object[meshObj.UvsLength];
for (int i = 0; i < write_uvs.Length; i++) {
write_uvs[i] = meshObj.GetUvs(i);
}
mesh_dict ["uvs"] = write_uvs;
// Mesh Indices
Object[] write_indices = new Object[meshObj.IndicesLength];
for (int i = 0; i < write_indices.Length; i++) {
write_indices[i] = meshObj.GetIndices(i);
}
mesh_dict ["indices"] = write_indices;
// Mesh Regions
Dictionary<string, object> mesh_region_list_dict = new Dictionary<string, object> ();
for (int i = 0; i < meshObj.RegionsLength; i++) {
var meshRegionObj = meshObj.GetRegions(i);
Dictionary<string, object> mesh_region_dict = new Dictionary<string, object>();
mesh_region_dict["start_pt_index"] = meshRegionObj.StartPtIndex;
mesh_region_dict["end_pt_index"] = meshRegionObj.EndPtIndex;
mesh_region_dict["start_index"] = meshRegionObj.StartIndex;
mesh_region_dict["end_index"] = meshRegionObj.EndIndex;
mesh_region_dict["id"] = meshRegionObj.Id;
Dictionary<string, object> write_region_weights = new Dictionary<string, object>();
for(int j = 0; j < meshRegionObj.WeightsLength; j++) {
var curBoneWeight = meshRegionObj.GetWeights(j);
Object [] write_bone_weights = new Object[curBoneWeight.WeightsLength];
for(int m = 0; m < write_bone_weights.Length; m++)
{
write_bone_weights[m] = curBoneWeight.GetWeights(m);
}
write_region_weights[curBoneWeight.Name] = write_bone_weights;
}
mesh_region_dict["weights"] = write_region_weights;
mesh_region_list_dict[meshRegionObj.Name] = mesh_region_dict;
}
mesh_dict ["regions"] = mesh_region_list_dict;
ret_dict ["mesh"] = mesh_dict;
// ------- Process Skeleton ----------------------
Dictionary<string, object> skeleton_dict = new Dictionary<string, object> ();
for (int i = 0; i < skeletonObj.BonesLength; i++) {
var skeletonBoneObj = skeletonObj.GetBones(i);
Dictionary<string, object> skeleton_bone_dict = new Dictionary<string, object>();
skeleton_bone_dict["id"] = skeletonBoneObj.Id;
Object [] write_skeleton_bone_restParentMat = new Object[skeletonBoneObj.RestParentMatLength];
for(int j = 0; j < write_skeleton_bone_restParentMat.Length; j++) {
write_skeleton_bone_restParentMat[j] = skeletonBoneObj.GetRestParentMat(j);
}
skeleton_bone_dict["restParentMat"] = write_skeleton_bone_restParentMat;
Object [] write_skeleton_bone_localRestStartPt = new Object[skeletonBoneObj.LocalRestStartPtLength];
for(int j = 0; j < write_skeleton_bone_localRestStartPt.Length; j++) {
write_skeleton_bone_localRestStartPt[j] = skeletonBoneObj.GetLocalRestStartPt(j);
}
skeleton_bone_dict["localRestStartPt"] = write_skeleton_bone_localRestStartPt;
Object [] write_skeleton_bone_localRestEndPt = new Object[skeletonBoneObj.LocalRestEndPtLength];
for(int j = 0; j < write_skeleton_bone_localRestEndPt.Length; j++) {
write_skeleton_bone_localRestEndPt[j] = skeletonBoneObj.GetLocalRestEndPt(j);
}
skeleton_bone_dict["localRestEndPt"] = write_skeleton_bone_localRestEndPt;
Object [] write_skeleton_bone_children = new Object[skeletonBoneObj.ChildrenLength];
for(int j = 0; j < write_skeleton_bone_children.Length; j++) {
write_skeleton_bone_children[j] = skeletonBoneObj.GetChildren(j);
}
skeleton_bone_dict["children"] = write_skeleton_bone_children;
skeleton_dict[skeletonBoneObj.Name] = skeleton_bone_dict;
}
ret_dict ["skeleton"] = skeleton_dict;
// ------- Process Animations --------------------
Dictionary<string, object> animation_dict = new Dictionary<string, object> ();
for (int i = 0; i < animationObject.ClipsLength; i++) {
var animationClipObj = animationObject.GetClips(i);
var animationBonesObj = animationClipObj.Bones;
var animationMeshObj = animationClipObj.Meshes;
var animationUvSwapObj = animationClipObj.UvSwaps;
var animationMeshOpacitiesObj = animationClipObj.MeshOpacities;
Dictionary<string, object> animationClipDict = new Dictionary<string, object>();
// Animation Bones
Dictionary<string, object> animationBonesTimeSamplesDict = new Dictionary<string, object>();
for(int j = 0; j < animationBonesObj.TimeSamplesLength; j++) {
var animationBonesTimeSample = animationBonesObj.GetTimeSamples(j);
String curTime = animationBonesTimeSample.Time.ToString();
Dictionary<string, object> animationBonesDict = new Dictionary<string, object>();
for(int k = 0; k < animationBonesTimeSample.BonesLength; k++) {
Dictionary<string, object> animationSingleBoneDict = new Dictionary<string, object> ();
var animationSingleBone = animationBonesTimeSample.GetBones(k);
Object [] write_animation_single_bone_start_pt = new Object[animationSingleBone.StartPtLength];
for(int m = 0; m < write_animation_single_bone_start_pt.Length; m++) {
write_animation_single_bone_start_pt[m] = animationSingleBone.GetStartPt(m);
}
animationSingleBoneDict["start_pt"] = write_animation_single_bone_start_pt;
Object [] write_animation_single_bone_end_pt = new Object[animationSingleBone.EndPtLength];
for(int m = 0; m < write_animation_single_bone_end_pt.Length; m++) {
write_animation_single_bone_end_pt[m] = animationSingleBone.GetEndPt(m);
}
animationSingleBoneDict["end_pt"] = write_animation_single_bone_end_pt;
animationBonesDict[animationSingleBone.Name] = animationSingleBoneDict;
}
animationBonesTimeSamplesDict[curTime] = animationBonesDict;
}
animationClipDict["bones"] = animationBonesTimeSamplesDict;
// Animation Meshes
Dictionary<string, object> animationMeshTimeSamplesDict = new Dictionary<string, object>();
for(int j = 0; j < animationMeshObj.TimeSamplesLength; j++) {
var animationMeshTimeSample = animationMeshObj.GetTimeSamples(j);
String curTime = animationMeshTimeSample.Time.ToString();
Dictionary<string, object> animationMeshesDict = new Dictionary<string, object>();
for(int k = 0; k < animationMeshTimeSample.MeshesLength; k++) {
Dictionary<string, object> animationSingleMeshDict = new Dictionary<string, object>();
var animationSingleMesh = animationMeshTimeSample.GetMeshes(k);
animationSingleMeshDict["use_dq"] = animationSingleMesh.UseDq;
animationSingleMeshDict["use_local_displacements"] = animationSingleMesh.UseLocalDisplacements;
animationSingleMeshDict["use_post_displacements"] = animationSingleMesh.UsePostDisplacements;
if(animationSingleMesh.UseLocalDisplacements) {
Object [] write_animation_single_mesh_localDisplacements = new Object[animationSingleMesh.LocalDisplacementsLength];
for(int m = 0; m < write_animation_single_mesh_localDisplacements.Length; m++) {
write_animation_single_mesh_localDisplacements[m] = animationSingleMesh.GetLocalDisplacements(m);
}
animationSingleMeshDict["local_displacements"] = write_animation_single_mesh_localDisplacements;
}
if(animationSingleMesh.UsePostDisplacements) {
Object [] write_animation_single_mesh_postDisplacements = new Object[animationSingleMesh.PostDisplacementsLength];
for(int m = 0; m < write_animation_single_mesh_postDisplacements.Length; m++) {
write_animation_single_mesh_postDisplacements[m] = animationSingleMesh.GetPostDisplacements(m);
}
animationSingleMeshDict["post_displacements"] = write_animation_single_mesh_postDisplacements;
}
animationMeshesDict[animationSingleMesh.Name] = animationSingleMeshDict;
}
animationMeshTimeSamplesDict[curTime] = animationMeshesDict;
}
animationClipDict["meshes"] = animationMeshTimeSamplesDict;
// Animation UV Swaps
Dictionary<string, object> animationUvSwapTimeSamplesDict = new Dictionary<string, object>();
for(int j = 0; j < animationUvSwapObj.TimeSamplesLength; j++) {
var animationUvSwapTimeSample = animationUvSwapObj.GetTimeSamples(j);
String curTime = animationUvSwapTimeSample.Time.ToString();
Dictionary<string, object> animationUVSwapDict = new Dictionary<string, object>();
for(int k = 0; k < animationUvSwapTimeSample.UvSwapsLength; k++) {
Dictionary<string, object> animationSingleUvSwapDict = new Dictionary<string, object>();
var animationSingleUvSwap = animationUvSwapTimeSample.GetUvSwaps(k);
animationSingleUvSwapDict["enabled"] = animationSingleUvSwap.Enabled;
Object [] write_animation_single_uvswap_localOffset = new Object[animationSingleUvSwap.LocalOffsetLength];
for(int m = 0; m < write_animation_single_uvswap_localOffset.Length; m++) {
write_animation_single_uvswap_localOffset[m] = animationSingleUvSwap.GetLocalOffset(m);
}
animationSingleUvSwapDict["local_offset"] = write_animation_single_uvswap_localOffset;
Object [] write_animation_single_uvswap_globalOffset = new Object[animationSingleUvSwap.GlobalOffsetLength];
for(int m = 0; m < write_animation_single_uvswap_globalOffset.Length; m++) {
write_animation_single_uvswap_globalOffset[m] = animationSingleUvSwap.GetGlobalOffset(m);
}
animationSingleUvSwapDict["global_offset"] = write_animation_single_uvswap_globalOffset;
Object [] write_animation_single_uvswap_scale = new Object[animationSingleUvSwap.ScaleLength];
for(int m = 0; m < write_animation_single_uvswap_scale.Length; m++) {
write_animation_single_uvswap_scale[m] = animationSingleUvSwap.GetScale(m);
}
animationSingleUvSwapDict["scale"] = write_animation_single_uvswap_scale;
animationUVSwapDict[animationSingleUvSwap.Name] = animationSingleUvSwapDict;
}
animationUvSwapTimeSamplesDict[curTime] = animationUVSwapDict;
}
animationClipDict["uv_swaps"] = animationUvSwapTimeSamplesDict;
// Animation Mesh Opacities
Dictionary<string, object> animationMeshOpacitiesTimeSamplesDict = new Dictionary<string, object>();
for(int j = 0; j < animationMeshOpacitiesObj.TimeSamplesLength; j++) {
var animationMeshOpacitiesTimeSample = animationMeshOpacitiesObj.GetTimeSamples(j);
String curTime = animationMeshOpacitiesTimeSample.Time.ToString();
Dictionary<string, object> animationMeshOpacitiesDict = new Dictionary<string, object>();
for(int k = 0; k < animationMeshOpacitiesTimeSample.MeshOpacitiesLength; k++) {
Dictionary<string, object> animationSingleMeshOpacitiesDict = new Dictionary<string, object>();
var animationSingleMeshOpacities = animationMeshOpacitiesTimeSample.GetMeshOpacities(k);
animationSingleMeshOpacitiesDict["opacity"] = animationSingleMeshOpacities.Opacity;
animationMeshOpacitiesDict[animationSingleMeshOpacities.Name] = animationSingleMeshOpacitiesDict;
}
animationMeshOpacitiesTimeSamplesDict[curTime] = animationMeshOpacitiesDict;
}
animationClipDict["mesh_opacities"] = animationMeshOpacitiesTimeSamplesDict;
animation_dict[animationClipObj.Name] = animationClipDict;
}
ret_dict ["animation"] = animation_dict;
// uv item swaps
Dictionary<string, object> uvItemSwapsDict = new Dictionary<string, object>();
for(int j = 0; j < uvSwapItemsObject.MeshesLength; j++) {
var curSwapMesh = uvSwapItemsObject.GetMeshes(j);
object[] node_list = new object[curSwapMesh.ItemsLength];
var mesh_name = curSwapMesh.Name;
for(int k = 0; k < curSwapMesh.ItemsLength; k++) {
var curItem = curSwapMesh.GetItems(k);
Dictionary<string, object> packet_dict = new Dictionary<string, object>();
Object [] write_localOffset = new Object[curItem.LocalOffsetLength];
for(int m = 0; m < write_localOffset.Length; m++) {
write_localOffset[m] = curItem.GetLocalOffset(m);
}
packet_dict["local_offset"] = write_localOffset;
Object [] write_globalOffset = new Object[curItem.GlobalOffsetLength];
for(int m = 0; m < write_globalOffset.Length; m++) {
write_globalOffset[m] = curItem.GetGlobalOffset(m);
}
packet_dict["global_offset"] = write_globalOffset;
Object [] write_scale = new Object[curItem.ScaleLength];
for(int m = 0; m < write_scale.Length; m++) {
write_scale[m] = curItem.GetScale(m);
}
packet_dict["scale"] = write_scale;
packet_dict["tag"] = curItem.Tag;
node_list[k] = packet_dict;
}
uvItemSwapsDict[mesh_name] = node_list;
}
ret_dict["uv_swap_items"] = uvItemSwapsDict;
// anchor points
Dictionary<string, object> anchorPointsBaseDict = new Dictionary<string, object>();
Object[] anchorPointsList = new Object[anchorPointsObject.AnchorPointsLength];
for(int j = 0; j < anchorPointsObject.AnchorPointsLength; j++)
{
var curItem = anchorPointsObject.GetAnchorPoints(j);
Dictionary<string, object> anchor_dict = new Dictionary<string, object>();
Object [] write_cur_point = new Object[curItem.PointLength];
for(int m = 0; m < write_cur_point.Length; m++) {
write_cur_point[m] = curItem.GetPoint(m);
}
anchor_dict["point"] = write_cur_point;
anchor_dict["anim_clip_name"] = curItem.AnimClipName;
anchorPointsList[j] = anchor_dict;
}
anchorPointsBaseDict["AnchorPoints"] = anchorPointsList;
ret_dict["anchor_points_items"] = anchorPointsBaseDict;
return ret_dict;
}
public static Dictionary <string, object> LoadCreatureFlatDataFromBytes(byte[] flat_bytes)
{
FlatBuffers.ByteBuffer flat_bytes_buffer = new FlatBuffers.ByteBuffer(flat_bytes);
Dictionary <string, object> ret_dict = new Dictionary <string, object>();
var rootObj = CreatureFlatData.rootData.GetRootAsrootData(flat_bytes_buffer);
var meshObj = rootObj.DataMesh;
var skeletonObj = rootObj.DataSkeleton;
var animationObject = rootObj.DataAnimation;
// ------- Process Mesh --------------------------
Dictionary <string, object> mesh_dict = new Dictionary <string, object> ();
// Mesh Points
Object[] write_points = new Object[meshObj.PointsLength];
for (int i = 0; i < write_points.Length; i++)
{
write_points[i] = meshObj.GetPoints(i);
}
mesh_dict ["points"] = write_points;
// Mesh Uvs
Object[] write_uvs = new Object[meshObj.UvsLength];
for (int i = 0; i < write_uvs.Length; i++)
{
write_uvs[i] = meshObj.GetUvs(i);
}
mesh_dict ["uvs"] = write_uvs;
// Mesh Indices
Object[] write_indices = new Object[meshObj.IndicesLength];
for (int i = 0; i < write_indices.Length; i++)
{
write_indices[i] = meshObj.GetIndices(i);
}
mesh_dict ["indices"] = write_indices;
// Mesh Regions
Dictionary <string, object> mesh_region_list_dict = new Dictionary <string, object> ();
for (int i = 0; i < meshObj.RegionsLength; i++)
{
var meshRegionObj = meshObj.GetRegions(i);
Dictionary <string, object> mesh_region_dict = new Dictionary <string, object>();
mesh_region_dict["start_pt_index"] = meshRegionObj.StartPtIndex;
mesh_region_dict["end_pt_index"] = meshRegionObj.EndPtIndex;
mesh_region_dict["start_index"] = meshRegionObj.StartIndex;
mesh_region_dict["end_index"] = meshRegionObj.EndIndex;
mesh_region_dict["id"] = meshRegionObj.Id;
Dictionary <string, object> write_region_weights = new Dictionary <string, object>();
for (int j = 0; j < meshRegionObj.WeightsLength; j++)
{
var curBoneWeight = meshRegionObj.GetWeights(j);
Object [] write_bone_weights = new Object[curBoneWeight.WeightsLength];
for (int m = 0; m < write_bone_weights.Length; m++)
{
write_bone_weights[m] = curBoneWeight.GetWeights(m);
}
write_region_weights[curBoneWeight.Name] = write_bone_weights;
}
mesh_region_dict["weights"] = write_region_weights;
mesh_region_list_dict[meshRegionObj.Name] = mesh_region_dict;
}
mesh_dict ["regions"] = mesh_region_list_dict;
ret_dict ["mesh"] = mesh_dict;
// ------- Process Skeleton ----------------------
Dictionary <string, object> skeleton_dict = new Dictionary <string, object> ();
for (int i = 0; i < skeletonObj.BonesLength; i++)
{
var skeletonBoneObj = skeletonObj.GetBones(i);
Dictionary <string, object> skeleton_bone_dict = new Dictionary <string, object>();
skeleton_bone_dict["id"] = skeletonBoneObj.Id;
Object [] write_skeleton_bone_restParentMat = new Object[skeletonBoneObj.RestParentMatLength];
for (int j = 0; j < write_skeleton_bone_restParentMat.Length; j++)
{
write_skeleton_bone_restParentMat[j] = skeletonBoneObj.GetRestParentMat(j);
}
skeleton_bone_dict["restParentMat"] = write_skeleton_bone_restParentMat;
Object [] write_skeleton_bone_localRestStartPt = new Object[skeletonBoneObj.LocalRestStartPtLength];
for (int j = 0; j < write_skeleton_bone_localRestStartPt.Length; j++)
{
write_skeleton_bone_localRestStartPt[j] = skeletonBoneObj.GetLocalRestStartPt(j);
}
skeleton_bone_dict["localRestStartPt"] = write_skeleton_bone_localRestStartPt;
Object [] write_skeleton_bone_localRestEndPt = new Object[skeletonBoneObj.LocalRestEndPtLength];
for (int j = 0; j < write_skeleton_bone_localRestEndPt.Length; j++)
{
write_skeleton_bone_localRestEndPt[j] = skeletonBoneObj.GetLocalRestEndPt(j);
}
skeleton_bone_dict["localRestEndPt"] = write_skeleton_bone_localRestEndPt;
Object [] write_skeleton_bone_children = new Object[skeletonBoneObj.ChildrenLength];
for (int j = 0; j < write_skeleton_bone_children.Length; j++)
{
write_skeleton_bone_children[j] = skeletonBoneObj.GetChildren(j);
}
skeleton_bone_dict["children"] = write_skeleton_bone_children;
skeleton_dict[skeletonBoneObj.Name] = skeleton_bone_dict;
}
ret_dict ["skeleton"] = skeleton_dict;
// ------- Process Animations --------------------
Dictionary <string, object> animation_dict = new Dictionary <string, object> ();
for (int i = 0; i < animationObject.ClipsLength; i++)
{
var animationClipObj = animationObject.GetClips(i);
var animationBonesObj = animationClipObj.Bones;
var animationMeshObj = animationClipObj.Meshes;
var animationUvSwapObj = animationClipObj.UvSwaps;
var animationMeshOpacitiesObj = animationClipObj.MeshOpacities;
Dictionary <string, object> animationClipDict = new Dictionary <string, object>();
// Animation Bones
Dictionary <string, object> animationBonesTimeSamplesDict = new Dictionary <string, object>();
for (int j = 0; j < animationBonesObj.TimeSamplesLength; j++)
{
var animationBonesTimeSample = animationBonesObj.GetTimeSamples(j);
String curTime = animationBonesTimeSample.Time.ToString();
Dictionary <string, object> animationBonesDict = new Dictionary <string, object>();
for (int k = 0; k < animationBonesTimeSample.BonesLength; k++)
{
Dictionary <string, object> animationSingleBoneDict = new Dictionary <string, object> ();
var animationSingleBone = animationBonesTimeSample.GetBones(k);
Object [] write_animation_single_bone_start_pt = new Object[animationSingleBone.StartPtLength];
for (int m = 0; m < write_animation_single_bone_start_pt.Length; m++)
{
write_animation_single_bone_start_pt[m] = animationSingleBone.GetStartPt(m);
}
animationSingleBoneDict["start_pt"] = write_animation_single_bone_start_pt;
Object [] write_animation_single_bone_end_pt = new Object[animationSingleBone.EndPtLength];
for (int m = 0; m < write_animation_single_bone_end_pt.Length; m++)
{
write_animation_single_bone_end_pt[m] = animationSingleBone.GetEndPt(m);
}
animationSingleBoneDict["end_pt"] = write_animation_single_bone_end_pt;
animationBonesDict[animationSingleBone.Name] = animationSingleBoneDict;
}
animationBonesTimeSamplesDict[curTime] = animationBonesDict;
}
animationClipDict["bones"] = animationBonesTimeSamplesDict;
// Animation Meshes
Dictionary <string, object> animationMeshTimeSamplesDict = new Dictionary <string, object>();
for (int j = 0; j < animationMeshObj.TimeSamplesLength; j++)
{
var animationMeshTimeSample = animationMeshObj.GetTimeSamples(j);
String curTime = animationMeshTimeSample.Time.ToString();
Dictionary <string, object> animationMeshesDict = new Dictionary <string, object>();
for (int k = 0; k < animationMeshTimeSample.MeshesLength; k++)
{
Dictionary <string, object> animationSingleMeshDict = new Dictionary <string, object>();
var animationSingleMesh = animationMeshTimeSample.GetMeshes(k);
animationSingleMeshDict["use_dq"] = animationSingleMesh.UseDq;
animationSingleMeshDict["use_local_displacements"] = animationSingleMesh.UseLocalDisplacements;
animationSingleMeshDict["use_post_displacements"] = animationSingleMesh.UsePostDisplacements;
if (animationSingleMesh.UseLocalDisplacements)
{
Object [] write_animation_single_mesh_localDisplacements = new Object[animationSingleMesh.LocalDisplacementsLength];
for (int m = 0; m < write_animation_single_mesh_localDisplacements.Length; m++)
{
write_animation_single_mesh_localDisplacements[m] = animationSingleMesh.GetLocalDisplacements(m);
}
animationSingleMeshDict["local_displacements"] = write_animation_single_mesh_localDisplacements;
}
if (animationSingleMesh.UsePostDisplacements)
{
Object [] write_animation_single_mesh_postDisplacements = new Object[animationSingleMesh.PostDisplacementsLength];
for (int m = 0; m < write_animation_single_mesh_postDisplacements.Length; m++)
{
write_animation_single_mesh_postDisplacements[m] = animationSingleMesh.GetPostDisplacements(m);
}
animationSingleMeshDict["post_displacements"] = write_animation_single_mesh_postDisplacements;
}
animationMeshesDict[animationSingleMesh.Name] = animationSingleMeshDict;
}
animationMeshTimeSamplesDict[curTime] = animationMeshesDict;
}
animationClipDict["meshes"] = animationMeshTimeSamplesDict;
// Animation UV Swaps
Dictionary <string, object> animationUvSwapTimeSamplesDict = new Dictionary <string, object>();
for (int j = 0; j < animationUvSwapObj.TimeSamplesLength; j++)
{
var animationUvSwapTimeSample = animationUvSwapObj.GetTimeSamples(j);
String curTime = animationUvSwapTimeSample.Time.ToString();
Dictionary <string, object> animationUVSwapDict = new Dictionary <string, object>();
for (int k = 0; k < animationUvSwapTimeSample.UvSwapsLength; k++)
{
Dictionary <string, object> animationSingleUvSwapDict = new Dictionary <string, object>();
var animationSingleUvSwap = animationUvSwapTimeSample.GetUvSwaps(k);
animationSingleUvSwapDict["enabled"] = animationSingleUvSwap.Enabled;
Object [] write_animation_single_uvswap_localOffset = new Object[animationSingleUvSwap.LocalOffsetLength];
for (int m = 0; m < write_animation_single_uvswap_localOffset.Length; m++)
{
write_animation_single_uvswap_localOffset[m] = animationSingleUvSwap.GetLocalOffset(m);
}
animationSingleUvSwapDict["local_offset"] = write_animation_single_uvswap_localOffset;
Object [] write_animation_single_uvswap_globalOffset = new Object[animationSingleUvSwap.GlobalOffsetLength];
for (int m = 0; m < write_animation_single_uvswap_globalOffset.Length; m++)
{
write_animation_single_uvswap_globalOffset[m] = animationSingleUvSwap.GetGlobalOffset(m);
}
animationSingleUvSwapDict["global_offset"] = write_animation_single_uvswap_globalOffset;
Object [] write_animation_single_uvswap_scale = new Object[animationSingleUvSwap.ScaleLength];
for (int m = 0; m < write_animation_single_uvswap_scale.Length; m++)
{
write_animation_single_uvswap_scale[m] = animationSingleUvSwap.GetScale(m);
}
animationSingleUvSwapDict["scale"] = write_animation_single_uvswap_scale;
animationUVSwapDict[animationSingleUvSwap.Name] = animationSingleUvSwapDict;
}
animationUvSwapTimeSamplesDict[curTime] = animationUVSwapDict;
}
animationClipDict["uv_swaps"] = animationUvSwapTimeSamplesDict;
// Animation Mesh Opacities
Dictionary <string, object> animationMeshOpacitiesTimeSamplesDict = new Dictionary <string, object>();
for (int j = 0; j < animationMeshOpacitiesObj.TimeSamplesLength; j++)
{
var animationMeshOpacitiesTimeSample = animationMeshOpacitiesObj.GetTimeSamples(j);
String curTime = animationMeshOpacitiesTimeSample.Time.ToString();
Dictionary <string, object> animationMeshOpacitiesDict = new Dictionary <string, object>();
for (int k = 0; k < animationMeshOpacitiesTimeSample.MeshOpacitiesLength; k++)
{
Dictionary <string, object> animationSingleMeshOpacitiesDict = new Dictionary <string, object>();
var animationSingleMeshOpacities = animationMeshOpacitiesTimeSample.GetMeshOpacities(k);
animationSingleMeshOpacitiesDict["opacity"] = animationSingleMeshOpacities.Opacity;
animationMeshOpacitiesDict[animationSingleMeshOpacities.Name] = animationSingleMeshOpacitiesDict;
}
animationMeshOpacitiesTimeSamplesDict[curTime] = animationMeshOpacitiesDict;
}
animationClipDict["mesh_opacities"] = animationMeshOpacitiesTimeSamplesDict;
animation_dict[animationClipObj.Name] = animationClipDict;
}
ret_dict ["animation"] = animation_dict;
return(ret_dict);
}
public static void OnFlatBuffersEntityUpdated(string name, System.ArraySegment <byte> range)
{
//EB.Debug.LogError("frameCount : {0} , name : {1}", UnityEngine.Time.frameCount, name);
//EB.Debug.LogError("OnFlatBuffersEntityUpdated : {0}", name);
FlatBuffers.ByteBuffer buffer = new FlatBuffers.ByteBuffer(range.Array, range.Offset);
switch (name)
{
case "Combat":
var combat = GM.DataCache.Combat.GetRootAsCombat(buffer);
SkillTemplateManager.Instance.InitFromDataCache(combat);
SkillTemplateManager.Instance.InitSkillLevelUpFromDataCache(combat);
BuffTemplateManager.Instance.InitTemplateFromCache(combat);
break;
case "Economy":
var economy = GM.DataCache.Economy.GetRootAsEconomy(buffer);
EconemyTemplateManager.Instance.InitFromDataCache(economy);
break;
case "Task":
var task = GM.DataCache.Task.GetRootAsTask(buffer);
TaskTemplateManager.Instance.InitFromDataCache(task);
break;
case "Resource":
var resource = GM.DataCache.Resource.GetRootAsResource(buffer);
BuyResourceTemplateManager.Instance.InitFromDataCache(resource);
break;
case "Scene":
var scene = GM.DataCache.Scene.GetRootAsScene(buffer);
SceneTemplateManager.Instance.InitFromDataCache(scene);
break;
case "Character":
var character = GM.DataCache.Character.GetRootAsCharacter(buffer);
CharacterTemplateManager.Instance.InitFromDataCache(character);
break;
case "Guide":
var guide = GM.DataCache.Guide.GetRootAsGuide(buffer);
var gd = guide.GetArray(0);
GuideManager.Instance.InitConfigData(gd);
GuideTemplateManager.Instance.InitFromDataCache(gd);
DialogueTemplateManager.Instance.InitDialogueData(gd);
GuideAudioTemplateManager.Instance.InitGuideAudioData(gd);
MessageTemplateManager.Instance.InitFromDataCache(gd);
FuncTemplateManager.Instance.InitFromDataCache(gd);
PreviewTemplateManager.Instance.InitFromDataCache(gd);
FuncActivedTemplateManager.Instance.InitFuncActivedData(gd);
GuideNodeTemplateManager.Instance.InitGuideNode(gd);
break;
case "Event":
var evt = GM.DataCache.Event.GetRootAsEvent(buffer);
WelfareTemplateManager.Instance.InitTemplateFromCache(evt);
EventTemplateManager.Instance.InitFromDataCache(evt);
break;
case "Vip":
var vip = GM.DataCache.Vip.GetRootAsVip(buffer);
VIPTemplateManager.Instance.InitTemplateFromCache(vip);
break;
case "Alliance":
var alliance = GM.DataCache.Alliance.GetRootAsAlliance(buffer);
AlliancesManager.Instance.Config.OnUpdateFunc(alliance);
AllianceTemplateManager.Instance.InitFromDataCache(alliance);
break;
case "Shop":
var shop = GM.DataCache.Shop.GetRootAsShop(buffer);
ShopTemplateManager.Instance.InitFromDataCache(shop);
break;
case "NewGameConfig":
var newGameConfig = GM.DataCache.NewGameConfig.GetRootAsNewGameConfig(buffer);
NewGameConfigTemplateManager.Instance.InitFromDataCache(newGameConfig);
break;
}
}
