void EntitySelectionChanged(Entity entity, World _world, ComponentType type) { if (type.GetManagedType() == typeof(Entity)) { if (_world.EntityManager != null) { selectionEntityProxy.SetEntity(_world, entity); } if (Selection.activeObject != selectionEntityProxy) { Selection.activeObject = selectionEntityProxy; } } else { if (_world.EntityManager == null) { return; } if (type.GetManagedType() == typeof(MonoBehaviour) && type.GetManagedType() == typeof(ScriptableObject)) { return; } var obj = _world.EntityManager.GetComponentFromType(entity, type); ObjectSelectionChanged(type, ref obj); } }
public void RegisterRpc(ComponentType type, PortableFunctionPointer <RpcExecutor.ExecuteDelegate> exec) { if (!exec.Ptr.IsCreated) { throw new InvalidOperationException( $"不能注册Rpc类型 {type.GetManagedType()}: Ptr 属性没有创建 (null)" + "Check CompileExecute() and verify you are initializing the PortableFunctionPointer with a valid static function delegate, decorated with [BurstCompile] attribute"); } var hash = TypeManager.GetTypeInfo(type.TypeIndex).StableTypeHash; if (hash == 0) { throw new InvalidOperationException($"Unexpected 0 hash for type {type.GetManagedType()}"); } if (_rpcTypeHashToIndex.TryGetValue(hash, out var index)) { var rpcData = _rpcData[index]; if (rpcData.TypeHash != 0) { #if ENABLE_UNITY_COLLECTIONS_CHECKS if (rpcData.RpcType == type) { throw new InvalidOperationException( String.Format("Registering RPC {0} multiple times is not allowed", type.GetManagedType())); } throw new InvalidOperationException( String.Format("Type hash collision between types {0} and {1}", type.GetManagedType(), rpcData.RpcType.GetManagedType())); #else throw new InvalidOperationException( String.Format("Hash collision or multiple registrations for {0}", type.GetManagedType())); #endif } rpcData.TypeHash = hash; rpcData.Execute = exec; _rpcData[index] = rpcData; } else { _rpcTypeHashToIndex.Add(hash, _rpcData.Length); _rpcData.Add(new RpcData { TypeHash = hash, Execute = exec, #if ENABLE_UNITY_COLLECTIONS_CHECKS RpcType = type #endif }); } // Debug.Log("注册Rpc:" + index + " " + World.Name); }
private IReactiveUpdateGroup CreateReactiveUpdateGroup(ComponentType componentType) { var group = GetComponentGroup(componentType, ComponentType.ReadOnly <ReactiveChanged>()); var reactiveCompareType = typeof(ReactiveCompare <>).MakeGenericType(componentType.GetManagedType()); var reactiveCompareSystem = typeof(ReactiveCompareSystem <,>).MakeGenericType(componentType.GetManagedType(), reactiveCompareType); World.CreateManager(reactiveCompareSystem); var makeme = typeof(ReactiveAddRemoveGroup <,>).MakeGenericType(componentType.GetManagedType(), reactiveCompareType); return((IReactiveUpdateGroup)Activator.CreateInstance(makeme, group)); }
bool GetComponentData <T>(ref Entity entity, out NetworkComponent componentDataContainer) where T : struct, IComponentData { componentDataContainer = null; if (EntityManager.HasComponent <T>(entity)) { ComponentType componentType = ComponentType.Create <T>(); int numberOfMembers = reflectionUtility.GetFieldsCount(componentType.GetManagedType()); T component = EntityManager.GetComponentData <T>(entity); NetworkField[] networkMemberInfos = reflectionUtility.GetFields(componentType); List <ComponentField> memberDataContainers = new List <ComponentField>(); for (int i = 0; i < numberOfMembers; i++) { memberDataContainers.Add(new ComponentField() { Id = i, Value = (networkMemberInfos[i] as NetworkField <T>).GetValue(component) }); } componentDataContainer = new NetworkComponent() { TypeId = reflectionUtility.GetId(componentType), Fields = memberDataContainers }; return(true); } return(false); }
protected override void OnUpdate() { Entities.WithStoreEntityQueryInField(ref m_query).WithStructuralChanges().ForEach((Entity entity, ref BlackboardEntityData globalEntityData) => { var types = EntityManager.GetComponentTypes(entity, Unity.Collections.Allocator.TempJob); var targetEntity = globalEntityData.blackboardScope == BlackboardScope.World ? worldBlackboardEntity : sceneBlackboardEntity; ComponentType errorType = default; bool error = false; foreach (var type in types) { if (type.TypeIndex == ComponentType.ReadWrite <BlackboardEntityData>().TypeIndex) { continue; } if (globalEntityData.mergeMethod == MergeMethod.Overwrite || !targetEntity.HasComponent(type)) { m_copyKit.CopyData(entity, targetEntity, type); } else if (globalEntityData.mergeMethod == MergeMethod.ErrorOnConflict) { errorType = type; error = true; } } types.Dispose(); if (error) { throw new InvalidOperationException( $"Entity {entity} could not copy component {errorType.GetManagedType()} onto {(globalEntityData.blackboardScope == BlackboardScope.World ? "world" : "scene")} entity because the component already exists and the MergeMethod was set to ErrorOnConflict."); } }).Run(); EntityManager.DestroyEntity(m_query); }
protected override JobHandle OnUpdate(JobHandle inputDeps) { inputDeps.Complete(); Entities.WithStructuralChanges().ForEach((Entity entity, ref GlobalEntityData globalEntityData) => { var types = EntityManager.GetComponentTypes(entity, Unity.Collections.Allocator.TempJob); var targetEntity = globalEntityData.globalScope == GlobalScope.World ? worldGlobalEntity : sceneGlobalEntity; ComponentType errorType = default; bool error = false; foreach (var type in types) { if (globalEntityData.mergeMethod == MergeMethod.Overwrite || !targetEntity.HasComponent(type)) { m_copyKit.CopyData(entity, targetEntity, type); } else if (globalEntityData.mergeMethod == MergeMethod.ErrorOnConflict) { errorType = type; error = true; } } types.Dispose(); if (error) { throw new InvalidOperationException( $"Entity {entity} could not copy component {errorType.GetManagedType()} onto {(globalEntityData.globalScope == GlobalScope.World ? "world" : "scene")} entity because the component already exists and the MergeMethod was set to ErrorOnConflict."); } }).Run(); return(inputDeps); }
private bool AddComponentDataOnEntityAdded <T>(ref Entity entity, out NetworkComponent componentDataContainer) where T : struct, IComponentData { componentDataContainer = null; if (EntityManager.HasComponent <T>(entity)) { ComponentType componentType = ComponentType.Create <T>(); int numberOfMembers = reflectionUtility.GetFieldsCount(componentType.GetManagedType()); Entity networkDataEntity = networkFactory.CreateNetworkComponentData <T>(entity, numberOfMembers); NativeArray <int> values = networkFactory.NetworkEntityManager.GetFixedArray <int>(networkDataEntity); PostUpdateCommands.AddComponent(entity, new NetworkComponentState <T>()); T component = EntityManager.GetComponentData <T>(entity); NetworkField[] networkMemberInfos = reflectionUtility.GetFields(componentType); List <ComponentField> memberDataContainers = new List <ComponentField>(); for (int i = 0; i < numberOfMembers; i++) { int value = (networkMemberInfos[i] as NetworkField <T>).GetValue(component); memberDataContainers.Add(new ComponentField() { Id = i, Value = value }); values[i] = value; } componentDataContainer = new NetworkComponent() { TypeId = reflectionUtility.GetId(componentType), Fields = memberDataContainers }; return(true); } return(false); }
private bool GetComponentData <T>(ref Entity entity, out ComponentDataContainer componentDataContainer) where T : struct, IComponentData { componentDataContainer = null; if (EntityManager.HasComponent <T>(entity)) { ComponentType componentType = ComponentType.Create <T>(); int numberOfMembers = reflectionUtility.GetNumberOfMembers(componentType.GetManagedType()); T component = EntityManager.GetComponentData <T>(entity); NetworkMemberInfo[] networkMemberInfos = reflectionUtility.GetNetworkMemberInfo(componentType); List <MemberDataContainer> memberDataContainers = new List <MemberDataContainer>(); for (int i = 0; i < numberOfMembers; i++) { memberDataContainers.Add(new MemberDataContainer() { MemberId = i, Data = (networkMemberInfos[i] as NetworkMemberInfo <T>).GetValue(component) }); } componentDataContainer = new ComponentDataContainer() { ComponentTypeId = reflectionUtility.GetComponentTypeID(componentType), MemberData = memberDataContainers }; return(true); } return(false); }
private void AddedComponents <T>() where T : struct, IComponentData { ComponentType componentType = ComponentType.Create <T>(); ComponentGroup group = GetComponentGroup(ComponentType.Create <NetworkSyncState>(), componentType, ComponentType.Subtractive <NetworkComponentState <T> >(), ComponentType.Create <NetworktAuthority>()); ComponentDataArray <T> components = group.GetComponentDataArray <T>(); ComponentDataArray <NetworkSyncState> networkSyncStateComponents = group.GetComponentDataArray <NetworkSyncState>(); EntityArray entities = group.GetEntityArray(); NetworkMemberInfo[] networkMemberInfos = reflectionUtility.GetNetworkMemberInfo(componentType); for (int i = 0; i < entities.Length; i++) { NetworkSyncState networkSyncState = networkSyncStateComponents[i]; ComponentDataContainer componentData = new ComponentDataContainer { ComponentTypeId = reflectionUtility.GetComponentTypeID(componentType) }; T component = components[i]; for (int j = 0; j < networkMemberInfos.Length; j++) { componentData.MemberData.Add(new MemberDataContainer { MemberId = j, Data = (networkMemberInfos[j] as NetworkMemberInfo <T>).GetValue(component), }); } ownNetworkSendMessageUtility.AddComponent(entities[i], networkSyncState.actorId, networkSyncState.networkId, componentData); AllNetworkSendMessageUtility.AddComponent(entities[i], networkSyncState.actorId, networkSyncState.networkId, componentData); int numberOfMembers = reflectionUtility.GetNumberOfMembers(componentType.GetManagedType()); networkFactory.CreateNetworkComponentData <T>(entities[i], numberOfMembers); PostUpdateCommands.AddComponent(entities[i], new NetworkComponentState <T>()); } }
public static object GetComponentData(EntityManager entityManager, Entity entity, ComponentType componentType) { EntityDataAccess * dataAccess = entityManager.GetCheckedEntityDataAccess(); EntityComponentStore *entityComponentStore = dataAccess->EntityComponentStore; byte *ptr = entityComponentStore->GetComponentDataWithTypeRO(entity, componentType.TypeIndex); return(Marshal.PtrToStructure((IntPtr)ptr, componentType.GetManagedType())); }
public static ComponentVisualElement Get(ComponentType componentType) { if (!cache.TryGetValue(componentType, out var element)) { throw new ArgumentException($"Unknown component type: '{componentType.GetManagedType().Name}'", nameof(componentType)); } return(element); }
private static string Name(ComponentType type) { var str = $"{type.ToString()}"; foreach (var @interface in type.GetManagedType().GetInterfaces()) { str += $": {@interface.Name}"; } return(str + " : " + type.TypeIndex); }
public void RegisterRpc(ComponentType type, PortableFunctionPointer <RpcExecutor.ExecuteDelegate> exec) { if (!m_CanRegister) { throw new InvalidOperationException("Cannot register new RPCs after the RpcSystem has started running"); } if (!exec.Ptr.IsCreated) { throw new InvalidOperationException($"Cannot register RPC for type {type.GetManagedType()}: Ptr property is not created (null)" + "Check CompileExecute() and verify you are initializing the PortableFunctionPointer with a valid static function delegate, decorated with [BurstCompile] attribute"); } var hash = TypeManager.GetTypeInfo(type.TypeIndex).StableTypeHash; if (hash == 0) { throw new InvalidOperationException(String.Format("Unexpected 0 hash for type {0}", type.GetManagedType())); } if (m_RpcTypeHashToIndex.TryGetValue(hash, out var index)) { var rpcData = m_RpcData[index]; if (rpcData.TypeHash != 0) { #if ENABLE_UNITY_COLLECTIONS_CHECKS if (rpcData.RpcType == type) { throw new InvalidOperationException( String.Format("Registering RPC {0} multiple times is not allowed", type.GetManagedType())); } throw new InvalidOperationException( String.Format("Type hash collision between types {0} and {1}", type.GetManagedType(), rpcData.RpcType.GetManagedType())); #else throw new InvalidOperationException( String.Format("Hash collision or multiple registrations for {0}", type.GetManagedType())); #endif } rpcData.TypeHash = hash; rpcData.Execute = exec; m_RpcData[index] = rpcData; } else { m_RpcTypeHashToIndex.Add(hash, m_RpcData.Length); m_RpcData.Add(new RpcData { TypeHash = hash, Execute = exec, #if ENABLE_UNITY_COLLECTIONS_CHECKS RpcType = type #endif }); } }
public void CopyData(Entity src, Entity dst, ComponentType componentType) { //Check to ensure dst has componentType if (!m_em.HasComponent(dst, componentType)) { m_em.AddComponent(dst, componentType); } if (componentType.IsSharedComponent) { CopyScd(src, dst, componentType); } else if (componentType.IsBuffer) { CopyBuffer(src, dst, componentType); } else { bool handled = false; var type = componentType.GetManagedType(); if (type.IsConstructedGenericType) { var genType = type.GetGenericTypeDefinition(); if (genType == typeof(ManagedComponentTag <>)) { if (!m_typeTagsToTypesCache.TryGetValue(type, out Type managedType)) { managedType = type.GenericTypeArguments[0]; m_typeTagsToTypesCache[type] = managedType; } LatiosWorld lw = m_em.World as LatiosWorld; lw.ManagedStructStorage.CopyComponent(src, dst, managedType); handled = true; } else if (genType == typeof(CollectionComponentTag <>)) { if (!m_typeTagsToTypesCache.TryGetValue(type, out Type managedType)) { managedType = type.GenericTypeArguments[0]; m_typeTagsToTypesCache[type] = managedType; } LatiosWorld lw = m_em.World as LatiosWorld; lw.CollectionComponentStorage.CopyComponent(src, dst, managedType); handled = true; } else if (genType == typeof(ManagedComponentSystemStateTag <>) || genType == typeof(CollectionComponentSystemStateTag <>)) { handled = true; } } if (!handled) { CopyIcd(src, dst, componentType); } } }
public unsafe DebugComponent(EntityManager entityManager, Entity entity, ComponentType componentType) { Type = componentType.GetManagedType(); Data = null; if (Type.IsClass) { Data = entityManager.GetComponentObject <object>(entity, componentType); } else if (typeof(IComponentData).IsAssignableFrom(Type)) { if (componentType.IsZeroSized) { Data = Activator.CreateInstance(Type); } else { var dataPtr = entityManager.GetComponentDataRawRO(entity, componentType.TypeIndex); // this doesn't work for structs that contain BlobAssetReferences Data = Marshal.PtrToStructure((IntPtr)dataPtr, Type); } } else if (typeof(ISharedComponentData).IsAssignableFrom(Type)) { try { Data = entityManager.GetSharedComponentData(entity, componentType.TypeIndex); } catch (Exception x) // currently triggered in dots runtime (see GetAllEntities_WithSharedTagEntity) { Data = x; } } else if (typeof(IBufferElementData).IsAssignableFrom(Type)) { var bufferPtr = (byte *)entityManager.GetBufferRawRO(entity, componentType.TypeIndex); var length = entityManager.GetBufferLength(entity, componentType.TypeIndex); var elementSize = Marshal.SizeOf(Type); var array = Array.CreateInstance(Type, length); Data = array; for (var i = 0; i < length; ++i) { var elementPtr = bufferPtr + (elementSize * i); array.SetValue(Marshal.PtrToStructure((IntPtr)elementPtr, Type), i); } } else { throw new InvalidOperationException("Unsupported ECS data type"); } }
public SharedComponentDataDiffer(ComponentType componentType) { if (!CanWatch(componentType)) { throw new ArgumentException($"{nameof(SharedComponentDataDiffer)} only supports {nameof(ISharedComponentData)} components.", nameof(componentType)); } WatchedComponentType = componentType; m_TypeIndex = componentType.TypeIndex; m_ManagedComponentIndexInCopyByChunk = new NativeHashMap <ulong, int>(100, Allocator.Persistent); m_ShadowChunks = new NativeHashMap <ulong, ShadowChunk>(100, Allocator.Persistent); m_DefaultComponentDataValue = Activator.CreateInstance(componentType.GetManagedType()); }
private void CacheCommandType(ComponentType command, int priority) { var commandCode = command.GetManagedType().GetHashCode(); if (cachedCommandsPrio.ContainsKey(commandCode)) { return; } var query = EntityManager.CreateEntityQuery(command); queries.Add(query); cachedCommandsPrio.Add(commandCode, priority); cachedCommandsIndex.Add(commandCode, queries.Count - 1); }
public unsafe DebugComponent(EntityManager entityManager, Entity entity, ComponentType componentType) { Type = componentType.GetManagedType(); Data = null; if (Type.IsClass) { Data = entityManager.GetComponentObject <object>(entity, componentType); } else if (typeof(IComponentData).IsAssignableFrom(Type)) { if (componentType.IsZeroSized) { Data = Activator.CreateInstance(Type); } else { var dataPtr = entityManager.GetComponentDataRawRO(entity, componentType.TypeIndex); Data = Marshal.PtrToStructure((IntPtr)dataPtr, Type); } } else if (typeof(IBufferElementData).IsAssignableFrom(Type)) { var bufferPtr = (byte *)entityManager.GetBufferRawRO(entity, componentType.TypeIndex); var length = entityManager.GetBufferLength(entity, componentType.TypeIndex); var elementSize = Marshal.SizeOf(Type); var array = Array.CreateInstance(Type, length); Data = array; for (var i = 0; i < length; ++i) { var elementPtr = bufferPtr + (elementSize * i); array.SetValue(Marshal.PtrToStructure((IntPtr)elementPtr, Type), i); } } else { throw new InvalidOperationException("Unsupported ECS data type"); } }
public static object GetComponentFromType(this EntityManager EntityManager, Entity entity, ComponentType type) { object componentData = new object(); if (type.GetManagedType().GetInterface("IComponentData") != null) { if (!type.IsZeroSized) { MethodInfo methodInfo = typeof(EntityManager).GetMethod("GetComponentData"); MethodInfo genericMethodInfo = methodInfo.MakeGenericMethod(type.GetManagedType()); var parameters = new object[] { entity }; componentData = genericMethodInfo.Invoke(EntityManager, parameters); } //else if (type.IsZeroSized) //Zero sized components should not be passed // return null; } else if (type.GetManagedType().GetInterface("ISharedComponentData", true) != null) { MethodInfo methodInfo = typeof(EntityManager).GetMethod("GetSharedComponentData", new[] { typeof(Entity) }); MethodInfo genericMethodInfo = methodInfo.MakeGenericMethod(type.GetManagedType()); var parameters = new object[] { entity }; componentData = genericMethodInfo.Invoke(EntityManager, parameters); } else if (type.GetManagedType() == typeof(Mesh) || type.GetManagedType() == typeof(Material)) { MethodInfo methodInfo = typeof(EntityManagerExtensions).GetMethod("GetComponentObject", new[] { typeof(EntityManager), typeof(Entity) }); MethodInfo genericMethodInfo = methodInfo.MakeGenericMethod(type.GetManagedType()); var parameters = new object[] { EntityManager, entity }; var data = genericMethodInfo.Invoke(EntityManager, parameters); if (data != null) { componentData = data; } } return(componentData); }
public static bool SetComponentWithType(this EntityManager entityManager, Entity entity, ComponentType type, object obj) { if (type.IsZeroSized) { Debug.Assert(type.IsZeroSized, "Zero-sized Components can not be set only added or removed"); } else if (type.GetManagedType().GetInterface("IComponentData") != null) { MethodInfo methodInfo = typeof(EntityManager).GetMethod("SetComponentData"); MethodInfo genericMethodInfo = methodInfo.MakeGenericMethod(type.GetManagedType()); var parameters = new object[] { entity, obj }; if (genericMethodInfo.Invoke(entityManager, parameters) != null) { return(true); } } else if (type.GetManagedType().GetInterface("ISharedComponentData", true) != null) { MethodInfo methodInfo = typeof(EntityManager).GetMethod("SetSharedComponentData", new[] { typeof(Entity) }); MethodInfo genericMethodInfo = methodInfo.MakeGenericMethod(type.GetManagedType()); var parameters = new object[] { entity, obj }; if (genericMethodInfo.Invoke(entityManager, parameters) != null) { return(true); } } else if (!type.GetManagedType().IsValueType) { MethodInfo methodInfo = typeof(EntityManager).GetMethod("GetComponentObject"); MethodInfo genericMethodInfo = methodInfo.MakeGenericMethod(type.GetManagedType()); var parameters = new object[] { entity }; var component = genericMethodInfo.Invoke(entityManager, parameters); if (component != null) { component = obj; return(true); } } return(false); }
internal static int CompareTypes(ComponentType x, ComponentType y) { var accessModeOrder = SortOrderFromAccessMode(x.AccessModeType).CompareTo(SortOrderFromAccessMode(y.AccessModeType)); return(accessModeOrder != 0 ? accessModeOrder : String.Compare(x.GetManagedType().Name, y.GetManagedType().Name, StringComparison.InvariantCulture)); }
public static void AddDependency(AssetImportContext ctx, ComponentType type) { var typeString = TypeString(type.GetManagedType()); ctx.DependsOnCustomDependency(typeString); }
public static bool CanWatch(ComponentType componentType) { var typeInfo = TypeManager.GetTypeInfo(componentType.TypeIndex); return(typeInfo.Category == TypeManager.TypeCategory.ComponentData && UnsafeUtility.IsUnmanaged(componentType.GetManagedType())); }
protected override IEnumerator ExecuteRoutine() { Log.Info("Start Sim Serialization Process..."); Dictionary <uint, byte[]> blobAssetsMap = new Dictionary <uint, byte[]>(); Dictionary <ComponentType, Type> compToManaged = new Dictionary <ComponentType, Type>(); Dictionary <ComponentType, DynamicComponentTypeHandle> compToHandle = new Dictionary <ComponentType, DynamicComponentTypeHandle>(); NativeArray <ArchetypeChunk> chunks = _simulationWorld.EntityManager.GetAllChunks(Allocator.TempJob); foreach (var item in BlobAssetDataCollectors.Values) { item.BeginCollect(_simulationWorld); } // iterate over all chunks for (int i = 0; i < chunks.Length; i++) { ArchetypeChunk chunk = chunks[i]; // iterate over all components in chunk foreach (ComponentType c in chunk.Archetype.GetComponentTypes()) { ComponentType componentType = c; componentType.AccessModeType = ComponentType.AccessMode.ReadOnly; // get managed type if (!compToManaged.TryGetValue(componentType, out Type managedType)) { managedType = componentType.GetManagedType(); compToManaged[componentType] = managedType; } // if collector exists for given component, invoke it if (BlobAssetDataCollectors.TryGetValue(managedType, out IPtrObjectCollector collector)) { // get componentTypeHandle (necessary for chunk data access) if (!compToHandle.TryGetValue(componentType, out DynamicComponentTypeHandle typeHandle)) { typeHandle = _simulationWorld.EntityManager.GetDynamicComponentTypeHandle(componentType); compToHandle[componentType] = typeHandle; } // invoke! collector.Collect(typeHandle, chunk, blobAssetsMap); } } } chunks.Dispose(); foreach (var item in BlobAssetDataCollectors.Values) { item.EndCollect(); } SerializedWorld serializedWorld = new SerializedWorld(); { serializedWorld.BlobAssets = new SerializedWorld.BlobAsset[blobAssetsMap.Count]; int i = 0; foreach (var item in blobAssetsMap) { serializedWorld.BlobAssets[i] = new SerializedWorld.BlobAsset() { Id = item.Key, Data = item.Value, }; i++; } } serializedWorld.WorldData = SerializeUtilityX.SerializeWorld(_simulationWorld.EntityManager, out object[] referencedObjects); SerializationData = NetSerializer.Serialize(serializedWorld); foreach (var obj in referencedObjects) { Log.Warning($"The ECS simulation references {obj}, which is a managed object. " + $"This is not allowed for now due to serialization"); } Log.Info("Sim Serialization Complete!"); TerminateWithSuccess(); yield break; }
MethodInfo GetMethod(ComponentType componentType, Type type, string methodName) => type .GetMethod(methodName, BindingFlags.Instance | BindingFlags.NonPublic) .MakeGenericMethod(componentType.GetManagedType());
private bool AddComponentDataOnEntityAdded <T>(ref Entity entity, out ComponentDataContainer componentDataContainer) where T : struct, IComponentData { componentDataContainer = null; ComponentDataFromEntity <NetworkSyncState> networkSyncStateEntities = EntityManager.GetComponentDataFromEntity <NetworkSyncState>(); if (EntityManager.HasComponent <T>(entity)) { ComponentType componentType = ComponentType.Create <T>(); int numberOfMembers = reflectionUtility.GetNumberOfMembers(componentType.GetManagedType()); Entity networkDataEntity = networkFactory.CreateNetworkComponentData <T>(entity, numberOfMembers); DynamicBuffer <int> values = networkFactory.NetworkEntityManager.GetBuffer <NetworkValue>(networkDataEntity).Reinterpret <int>(); PostUpdateCommands.AddComponent(entity, new NetworkComponentState <T>()); T component = EntityManager.GetComponentData <T>(entity); NetworkMemberInfo[] networkMemberInfos = reflectionUtility.GetNetworkMemberInfo(componentType); List <MemberDataContainer> memberDataContainers = new List <MemberDataContainer>(); for (int i = 0; i < numberOfMembers; i++) { int value = (networkMemberInfos[i] as NetworkMemberInfo <T>).GetValue(component, networkSyncStateEntities); memberDataContainers.Add(new MemberDataContainer() { MemberId = i, Data = value }); values[i] = value; } componentDataContainer = new ComponentDataContainer() { ComponentTypeId = reflectionUtility.GetComponentTypeID(componentType), MemberData = memberDataContainers }; return(true); } return(false); }