public override void OnBeforeSerialize(Type storageType, object instance)
{
CompRef cref = instance as CompRef;
ECSComponent comp = cref.component;
if (comp != null)
{
cref.isNull = false;
if (blueprint)
{
cref.entity_ID = comp.Entity.blueprintID;
}
else
{
cref.entity_ID = comp.Entity.ID;
}
cref.component_ID = comp.componentID;
cref.entityName = comp.Entity.name;
}
else
{
cref.isNull = true;
}
cref.component = null;
}
private void IncreaseBuffer(int count)
{
Console.WriteLine($"[ECS] Increasing buffer to {ecsComponentData.GetLength(0) + count} entities");
int rows = ecsComponentData.GetLength(0) + count;
int cols = typeIndexLookup.Count;
var newArray = new ECSComponent[rows, cols];
int minRows = Math.Min(rows, ecsComponentData.GetLength(0));
int minCols = Math.Min(cols, ecsComponentData.GetLength(1));
for (int i = 0; i < rows; i++)
{
if (i < minRows)
{
for (int j = 0; j < minCols; j++)
{
newArray[i, j] = ecsComponentData[i, j];
}
}
else
{
CreateInvalidEntity(i);
}
}
ecsComponentData = newArray;
}
public virtual void OnComponentRemovedFromEntity(ECSEntity entity, ECSComponent component)
{
if (Accept(component))
{
RemoveComponent(component);
}
}
public Bag <ECSComponent> ParseComponentData(JSONNode archetypeData)
{
Bag <ECSComponent> components = new Bag <ECSComponent>();
JSONNode data = null;
JSONNode componentDataArray = m_dataLocator.GetComponentData(archetypeData);
Type componentType = null;
for (int i = 0; i < componentDataArray.Count; i++)
{
data = componentDataArray[i];
componentType = GetComponentTypeByName(m_dataLocator.GetComponentName(data));
if (componentType == null)
{
continue;
}
ECSComponent component = JsonUtility.FromJson(data.ToString(), componentType) as ECSComponent;
ECSDebug.Assert(component != null, "Failed to create Component " + m_dataLocator.GetComponentName(data));
components.Add(component);
}
components.ResizeToFit();
return(components);
}
public override void OnComponentRemovedPre(int entityID, ECSComponent component)
{
if (component.GetType() == typeof(CCollider))
{
RemoveEntity(entityID);
}
}
public void RemoveComponent(int entityID, ECSComponent component)
{
OnComponentRemovedPre(entityID, component);
GetComponentBag(entityID).Set(GetComponentID(component.GetType()), null);
m_componentFactory.DeInitializeComponent(entityID, component);
OnComponentRemovedPost(entityID, component);
}
public virtual void OnComponentAddedToEntity(ECSEntity entity, ECSComponent component)
{
if (Accept(component))
{
AddComponent(component);
}
}
public override void OnComponentAddedToEntity(ECSEntity entity, ECSComponent component)
{
if (component != null && component is Renderer)
{
AddComponent(new RenderingSystemComponent(component as Renderer, entity.GetComponent <Transform>()));
}
}
public void RemoveComponent(ECSComponent component)
{
bool removed = components.Remove(component);
if (removed)
{
OnComponentRemoved?.Invoke(component);
}
}
private T GetComponent <T>(ECSComponent component, int entityID) where T : ECSComponent
{
if (m_componentManager.HasComponent <T>(entityID) == false)
{
OnComponentInitializeFailure(component, "Cannot initialize component " + component.GetType().Name + " without component " + typeof(T).Name);
return(null);
}
return(m_componentManager.GetComponent <T>(entityID));
}
static void SetDataForComponent(ECSComponent comp, SerializedData data)
{
Type t = comp.GetType();
var field = findDataField(t);
if (field != null)
{
field.SetValue(comp, data);
}
}
internal static T GetEntityComponent <T>(this ECSComponent component) where T : ECSComponent
{
if ((object)component == null)
{
return(null);
}
if ((object)component.Entity == null)
{
return(null);
}
return(component.Entity.GetECSComponent <T>());
}
public virtual int DeInitializeComponent(int entityID, ECSComponent component)
{
if (component.GetType() == typeof(CTransform))
{
CTransform cTransform = component as CTransform;
GameObject.Destroy(cTransform.GameObject);
}
if (component.GetType() == typeof(CSpriteRenderer))
{
CSpriteRenderer cRenderer = component as CSpriteRenderer;
DestroyUnityComponent <SpriteRenderer>(entityID, cRenderer);
}
if (component.GetType() == typeof(CBoxCollider))
{
CBoxCollider cBoxCollider = component as CBoxCollider;
OnColliderRemoved(entityID, cBoxCollider.BoxCollider);
DestroyUnityComponent <BoxCollider>(entityID, cBoxCollider);
}
if (component.GetType() == typeof(CMeshCollider))
{
CMeshCollider cMeshCollider = component as CMeshCollider;
OnColliderRemoved(entityID, cMeshCollider.Collider);
DestroyUnityComponent <MeshCollider>(entityID, cMeshCollider);
}
if (component.GetType() == typeof(CSphereCollider))
{
CSphereCollider cSphereCollider = component as CSphereCollider;
OnColliderRemoved(entityID, cSphereCollider.Collider);
DestroyUnityComponent <SphereCollider>(entityID, cSphereCollider);
}
if (component.GetType() == typeof(CRigidbody))
{
CRigidbody cRigidbody = component as CRigidbody;
DestroyUnityComponent <Rigidbody>(entityID, cRigidbody);
}
if (component.GetType() == typeof(CMeshRenderer))
{
CMeshRenderer cMeshRenderer = component as CMeshRenderer;
DestroyUnityComponent <MeshRenderer>(entityID, cMeshRenderer);
DestroyUnityComponent <MeshFilter>(entityID, cMeshRenderer);
}
return(0);
}
public T GetComponent <T>() where T : ECSComponent
{
ECSComponent component = components.Find(c => c.GetType() == typeof(T));
if (component != null)
{
return((T)component);
}
else
{
return(default(T));
}
}
private RenderingSystemComponent FindComponent(Transform transform, Renderer renderer)
{
ECSComponent cmp = GetComponents().Find(c => ((RenderingSystemComponent)c).Renderer.Equals(renderer) && ((RenderingSystemComponent)c).Transform.Equals(transform));
if (cmp != null)
{
return((RenderingSystemComponent)cmp);
}
else
{
return(null);
}
}
public ECSEntity AddComponent(ECSComponent component)
{
if (!components.Contains(component))
{
components.Add(component);
component.Entity = this;
component.Init();
OnComponentAdded?.Invoke(component);
}
return(this);
}
public void UnregisterECSComponent(ECSComponent component)
{
Type t = component.GetType();
IList comps;
components.TryGetValue(t, out comps);
if (comps != null)
{
comps.Remove(component);
}
allComponents.Remove(component);
}
private CTransform VerifyTransform(ECSComponent component, int entityID)
{
CTransform cTransform = GetComponent <CTransform>(component, entityID);
if (cTransform == null)
{
return(null);
}
if (cTransform.GameObject == null)
{
OnComponentInitializeFailure(component, "GameObject does not exist!");
return(null);
}
return(cTransform);
}
public void RegisterECSComponent(ECSComponent component)
{
Type t = component.GetType();
IList comps;
components.TryGetValue(t, out comps);
if (comps == null)
{
comps = MakeNewGenericList(t);
components.Add(t, comps);
}
comps.Add(component);
allComponents.Add(component);
}
public void InitializePendingComponents(int entityID)
{
Bag <ECSComponent> bag = SafeGetPendingComponentBag(entityID).Clone();
bag.ResizeToFit();
ECSComponent component = null;
List <ECSComponent> toInit = new List <ECSComponent>(bag.GetAll());
int attemptThreshold = -1;
int START_THRESHOLD = 1;
if (toInit.Count > 0)
{
START_THRESHOLD = 10;
}
attemptThreshold = START_THRESHOLD;
while (toInit.Count > 0 && attemptThreshold > 0)
{
for (int i = toInit.Count - 1; i >= 0; i--)
{
component = toInit[i];
RemovePendingComponent(entityID, component);
if (m_componentFactory.InitializeComponent(entityID, component) == 0)
{
SafeGetComponentBag(entityID).Set(SafeGetComponentID(component.GetType()), component);
OnComponentAdded(entityID, component);
toInit.RemoveAt(i);
attemptThreshold = START_THRESHOLD;
continue;
}
else
{
AddPendingComponent(entityID, component);
attemptThreshold--;
}
}
}
ECSDebug.Assert(attemptThreshold > 0, " Reached attempt threshold, maybe two components are dependent on eachother?");
}
private void OnComponentAdded(int entityID, ECSComponent component)
{
Bag <int> query = null;
foreach (Type[] type in m_queries.Keys)
{
query = GetQuery(type);
if (query.Has(entityID) == -1)
{
if (m_componentManager.HasComponents(entityID, type))
{
query.Add(entityID);
query.ResizeToFit();
}
}
}
}
static SerializedData GetDataFromComponent(ECSComponent comp)
{
if (comp == null)
{
return(null);
}
Type t = comp.GetType();
var field = findDataField(t);
if (field != null)
{
var data = field.GetValue(comp) as SerializedData;
return(data);
}
else
{
return(null);
}
}
private void OnComponentRemovedPost(int entityID, ECSComponent component)
{
Bag <int> query = null;
foreach (Type[] type in m_queries.Keys)
{
query = GetQuery(type);
if (query.Has(entityID) == -1)
{
continue;
}
if (m_componentManager.HasComponents(entityID, type) == false)
{
query.RemoveIndex(query.Has(entityID));
query.ResizeToFit();
}
}
}
private int DestroyUnityComponent <T>(int entityID, ECSComponent component) where T : Component
{
CTransform cTransform = VerifyTransform(component, entityID);
if (cTransform == null)
{
OnComponentDeInitializeFailure(component, "Transform not found.");
return(1);
}
T unityComponent = cTransform.GameObject.GetComponent <T>();
if (component == null)
{
OnComponentDeInitializeFailure(component, "Unity component not found on transform " + typeof(T));
return(1);
}
GameObject.Destroy(unityComponent);
return(0);
}
private void RemovePendingComponent(int entityID, ECSComponent component)
{
int componentID = GetComponentID(component.GetType());
SafeGetPendingComponentBag(entityID).Set(componentID, null);
}
private void AddPendingComponent(int entityID, ECSComponent component)
{
int componentID = SafeGetComponentID(component.GetType());
SafeGetPendingComponentBag(entityID).Set(componentID, component);
}
public ECSComponent AddComponent(int entityID, ECSComponent component)
{
AddPendingComponent(entityID, component);
InitializePendingComponents(entityID);
return(null);
}
internal void CreateComponent <T>(int entityID)
{
ECSComponent component = CreateComponent <T>();
AddComponent(entityID, component);
}
internal void RemoveComponent <T>(int entityID)
{
ECSComponent component = GetComponentBag(entityID).Get(GetComponentID(typeof(T)));
RemoveComponent(entityID, component);
}
public int InitializeComponent(int entityID, ECSComponent component)
{
LogWarning();
return(0);
}
