internal void AddCreateCommand(EntityCommandBufferChain *chain, ECBCommand op, EntityArchetype archetype)
{
var data = (CreateCommand *)Reserve(chain, sizeof(CreateCommand));
data->Header.CommandType = (int)op;
data->Header.TotalSize = sizeof(CreateCommand);
data->Archetype = archetype;
}
public void CreateEntity(EntityArchetype archetype, NativeArray <Entity> entities)
{
CreateEntityInternal(archetype, (Entity *)entities.GetUnsafePtr(), entities.Length);
}
public Entity CreateEntity(EntityArchetype archetype)
{
var access = GetCheckedEntityDataAccess();
return(access->CreateEntity(archetype));
}
public EntityArchetypeDebugView(EntityArchetype entityArchetype)
{
m_EntityArchetype = entityArchetype;
}
public void CreateEntity(EntityArchetype archetype, NativeArray <Entity> entities)
{
m_EntityDataAccess.CreateEntity(archetype, entities);
}
public void CreateEntity(EntityArchetype archetype, NativeArray <Entity> entities)
{
m_Manager.CreateEntity(archetype, entities);
}
private unsafe void CreateEntityInternal(EntityArchetype archetype, Entity *entities, int count)
{
this.CheckAccess();
this.m_Entities.CreateEntities(this.ArchetypeManager, archetype.Archetype, entities, count);
}
public void CreateEntity(EntityArchetype archetype, NativeArray <Entity> entities)
{
CheckAccess();
EntityManagerCreateDestroyEntitiesUtility.CreateEntities(archetype.Archetype, (Entity *)entities.GetUnsafePtr(), entities.Length, EntityComponentStore, ManagedComponentStore);
}
internal static Entity CallCreateEntity(void *emHandle, EntityArchetype arch)
{
return(((EntityManager)GCHandle.FromIntPtr((IntPtr)emHandle).Target).CreateEntity(arch));
}
internal void AddCreateCommand(EntityCommandBufferChain *chain, ECBCommand op, EntityArchetype archetype)
{
if (chain->m_PrevCreateCommand != null &&
chain->m_PrevCreateCommand->Archetype == archetype &&
chain->m_PrevCreateCommand->BatchCount < kMaxBatchCount)
{
++chain->m_PrevCreateCommand->BatchCount;
var data = (CreateCommand *)Reserve(chain, sizeof(CreateCommand));
data->Header.CommandType = (int)op;
data->Header.TotalSize = sizeof(CreateCommand);
data->Archetype = archetype;
data->BatchCount = 0;
}
else
{
var data = (CreateCommand *)Reserve(chain, sizeof(CreateCommand));
data->Header.CommandType = (int)op;
data->Header.TotalSize = sizeof(CreateCommand);
data->Archetype = archetype;
data->BatchCount = 1;
chain->m_PrevCreateCommand = data;
}
}
public Entity CreateEntity(EntityArchetype archetype)
{
CheckAccess();
return m_EntityDataAccess.CreateEntity(archetype);
}
public unsafe void AddMatchingArchetypes(EntityArchetypeQuery query, NativeList <EntityArchetype> foundArchetypes)
{
ComponentType *typePtr;
ComponentType[] pinned typeArray;
ComponentType *typePtr2;
ComponentType[] pinned typeArray2;
ComponentType *typePtr3;
ComponentType[] pinned typeArray3;
int length = query.Any.Length;
int noneCount = query.None.Length;
int allCount = query.All.Length;
if (((typeArray = query.Any) == null) || (typeArray.Length == 0))
{
typePtr = null;
}
else
{
typePtr = typeArray;
}
if (((typeArray2 = query.None) == null) || (typeArray2.Length == 0))
{
typePtr2 = null;
}
else
{
typePtr2 = typeArray2;
}
if (((typeArray3 = query.All) == null) || (typeArray3.Length == 0))
{
typePtr3 = null;
}
else
{
typePtr3 = typeArray3;
}
Archetype *lastArchetype = this.ArchetypeManager.m_LastArchetype;
while (true)
{
if (lastArchetype == null)
{
typeArray3 = null;
typeArray2 = null;
typeArray = null;
return;
}
bool flag2 = lastArchetype->EntityCount == 0;
if ((!flag2 && (this.TestMatchingArchetypeAny(lastArchetype, typePtr, length) && this.TestMatchingArchetypeNone(lastArchetype, typePtr2, noneCount))) && this.TestMatchingArchetypeAll(lastArchetype, typePtr3, allCount))
{
EntityArchetype archetype = new EntityArchetype {
Archetype = lastArchetype
};
if (!foundArchetypes.Contains <EntityArchetype, EntityArchetype>(archetype))
{
foundArchetypes.Add(archetype);
}
}
lastArchetype = lastArchetype->PrevArchetype;
}
}
internal unsafe void CreateEntityInternal(EntityArchetype archetype, Entity *entities, int count)
{
this.BeforeStructuralChange();
this.Entities.CreateEntities(this.ArchetypeManager, archetype.Archetype, entities, count);
}
internal void CreateEntityInternal(EntityArchetype archetype, Entity *entities, int count)
{
BeforeStructuralChange();
Entities->CreateEntities(ArchetypeManager, archetype.Archetype, entities, count);
}
public void CreateEntity(EntityArchetype archetype, int entityCount)
{
archetype.CheckValidEntityArchetype();
GetCheckedEntityDataAccess()->CreateEntity(archetype, entityCount);
}
public void CreateEntity(EntityArchetype archetype)
{
EnforceSingleThreadOwnership();
AddCreateCommand(Command.CreateEntityImplicit, archetype);
}
public void CreateEntity(EntityArchetype archetype, NativeArray <Entity> entities)
{
archetype.CheckValidEntityArchetype();
GetCheckedEntityDataAccess()->CreateEntity(archetype, entities);
}
public Entity CreateEntity(EntityArchetype archetype)
{
return(m_EntityDataAccess.CreateEntity(archetype));
}
private void CreateEntityInternal(EntityArchetype archetype, Entity *entities, int count)
{
CheckAccess();
m_Entities->CreateEntities(ArchetypeManager, archetype.Archetype, entities, count);
}
public Entity CreateEntity(EntityArchetype archetype)
{
return(m_Manager.CreateEntity(archetype));
}
public Entity CreateEntity(EntityArchetype archetype)
{
CheckWriteAccess();
return(m_EntityDataAccess.CreateEntity(archetype));
}
public void CreateEntityWithValidation(EntityArchetype archetype, Entity *outEntities, int count)
{
AssertValidArchetype((EntityComponentStore *)UnsafeUtility.AddressOf(ref this), archetype);
CreateEntities(archetype.Archetype, outEntities, count);
}
internal unsafe void AddCreateCommand(EntityCommandBufferChain *chain, int jobIndex, ECBCommand op, EntityArchetype archetype)
{
int num1;
if ((chain.m_PrevCreateCommand == null) || !(chain.m_PrevCreateCommand.Archetype == archetype))
{
num1 = 0;
}
else
{
num1 = (int)(chain.m_PrevCreateCommand.BatchCount < 0x200);
}
if (num1 == 0)
{
CreateCommand *commandPtr2 = (CreateCommand *)ref this.Reserve(chain, jobIndex, sizeof(CreateCommand));
commandPtr2->Header.CommandType = (int)op;
commandPtr2->Header.TotalSize = sizeof(CreateCommand);
commandPtr2->Header.SortIndex = chain.m_LastSortIndex;
commandPtr2->Archetype = archetype;
commandPtr2->BatchCount = 1;
chain.m_PrevCreateCommand = commandPtr2;
}
else
{
int *numPtr1 = (int *)ref chain.m_PrevCreateCommand.BatchCount;
numPtr1[0]++;
CreateCommand *commandPtr = (CreateCommand *)ref this.Reserve(chain, jobIndex, sizeof(CreateCommand));
commandPtr->Header.CommandType = (int)op;
commandPtr->Header.TotalSize = sizeof(CreateCommand);
commandPtr->Header.SortIndex = chain.m_LastSortIndex;
commandPtr->Archetype = archetype;
commandPtr->BatchCount = 0;
}
}
