public void ChangeEntityCapacity(int capacity)
{
Debug.Assert(IsPool);
Debug.Assert(Archetypes.Length == 1); // Only pools with 1 PersistenceArchetype are supported
Debug.Assert(capacity != EntityCapacity);
// Grow InitialSceneState & fill with default
InitialSceneState.ResizeByInitializingWithFirstEntry(capacity);
// for each in ringbuffer
// Copy that array & copy existing smaller data into it
// Dispose of old array
for (var i = 0; i < RingBuffer.Count; i++)
{
PersistentDataContainer persistentDataContainer = RingBuffer[i];
persistentDataContainer.ResizeByInitializingFromOther(capacity, InitialSceneState);
RingBuffer[i] = persistentDataContainer;
}
// Change ArchetypeDataLayout
PersistencyArchetypeDataLayout dataLayout = Archetypes[0];
dataLayout.Amount = capacity;
Archetypes[0] = dataLayout;
ref BlobArray <PersistencyArchetypeDataLayout.TypeInfo> typeInfoArray = ref dataLayout.PersistedTypeInfoArrayRef.Value;
private JobHandle SchedulePersistJobs(JobHandle inputDeps, PersistentDataContainer dataContainer, ComponentTypeHandle <PersistenceState> persistenceStateTypeHandle)
{
var returnJobHandle = inputDeps;
for (int persistenceArchetypeIndex = 0; persistenceArchetypeIndex < dataContainer.DataLayoutCount; persistenceArchetypeIndex++)
{
PersistencyArchetypeDataLayout dataLayout = dataContainer.GetDataLayoutAtIndex(persistenceArchetypeIndex);
ref BlobArray <PersistencyArchetypeDataLayout.TypeInfo> typeInfoArray = ref dataLayout.PersistedTypeInfoArrayRef.Value;
PersistencyContainerTag containerTag = new PersistencyContainerTag {
DataIdentifier = dataContainer.DataIdentifier
};
PersistableTypeCombinationHash persistableTypeCombinationHash = new PersistableTypeCombinationHash {
Value = dataLayout.PersistableTypeHandleCombinationHash
};
for (int typeInfoIndex = 0; typeInfoIndex < typeInfoArray.Length; typeInfoIndex++)
{
// type info
PersistencyArchetypeDataLayout.TypeInfo typeInfo = typeInfoArray[typeInfoIndex];
ComponentType runtimeType = ComponentType.ReadOnly(PersistencySettings.GetTypeIndex(typeInfo.PersistableTypeHandle));
int stride = typeInfo.ElementSize * typeInfo.MaxElements + PersistenceMetaData.SizeOfStruct;
int byteSize = dataLayout.Amount * stride;
// query
var query = PersistableEntitiesQuery;
query.SetSharedComponentFilter(containerTag, persistableTypeCombinationHash);
JobHandle jobHandle;
if (typeInfo.IsBuffer)
{
jobHandle = new CopyBufferElementsToByteArray
{
BufferTypeHandle = GetDynamicComponentTypeHandle(runtimeType),
MaxElements = typeInfo.MaxElements,
PersistenceStateType = persistenceStateTypeHandle,
RawContainerData = dataContainer.GetRawData(),
SubArrayOffset = dataLayout.Offset + typeInfo.Offset,
SubArrayByteSize = byteSize,
ElementSize = typeInfo.ElementSize
}.Schedule(query, inputDeps);
}
else
{
jobHandle = new CopyComponentDataToByteArray()
{
ComponentTypeHandle = GetDynamicComponentTypeHandle(runtimeType),
TypeSize = typeInfo.ElementSize,
PersistenceStateType = persistenceStateTypeHandle,
RawContainerData = dataContainer.GetRawData(),
SubArrayOffset = dataLayout.Offset + typeInfo.Offset,
SubArrayByteSize = byteSize
}.Schedule(query, inputDeps);
}
query.ResetFilter();
returnJobHandle = JobHandle.CombineDependencies(returnJobHandle, jobHandle);
}
}
protected internal void SlowSynchronousPersist(PersistentDataContainer dataContainer)
{
ComponentTypeHandle <PersistenceState> persistenceStateTypeHandle = GetComponentTypeHandle <PersistenceState>();
ComponentTypeHandle <PersistencyArchetypeIndexInContainer> archetypeIndexInContainerTypeHandle = GetComponentTypeHandle <PersistencyArchetypeIndexInContainer>();
JobHandle jobHandle = default;
jobHandle = SchedulePersist(jobHandle, dataContainer, persistenceStateTypeHandle, archetypeIndexInContainerTypeHandle);
jobHandle.Complete();
}
protected JobHandle ScheduleApply(JobHandle inputDeps, PersistentDataContainer dataContainer, EntityCommandBufferSystem ecbSystem,
EntityTypeHandle entityTypeHandle, ComponentTypeHandle <PersistenceState> persistenceStateTypeHandle, ComponentTypeHandle <PersistencyArchetypeIndexInContainer> indexInContainerTypeHandle)
{
if (PersistencySettings.UseGroupedJobs())
{
return(ScheduleApplyGroupedJob(inputDeps, dataContainer, ecbSystem, entityTypeHandle, persistenceStateTypeHandle, indexInContainerTypeHandle));
}
else
{
return(ScheduleApplyJobs(inputDeps, dataContainer, ecbSystem, entityTypeHandle, persistenceStateTypeHandle));
}
}
protected JobHandle SchedulePersist(JobHandle inputDeps, PersistentDataContainer dataContainer, ComponentTypeHandle <PersistenceState> persistenceStateTypeHandle,
ComponentTypeHandle <PersistencyArchetypeIndexInContainer> persistencyArchetypeIndexInContainerTypeHandle)
{
if (PersistencySettings.UseGroupedJobs())
{
return(SchedulePersistGroupedJob(inputDeps, dataContainer, persistenceStateTypeHandle, persistencyArchetypeIndexInContainerTypeHandle));
}
else
{
return(SchedulePersistJobs(inputDeps, dataContainer, persistenceStateTypeHandle));
}
}
internal void RequestInitialStatePersist(PersistentDataContainer dataContainer)
{
for (int i = 0; i < _initialStatePersistRequests.Count; i++)
{
if (_initialStatePersistRequests[i].DataIdentifier.Equals(dataContainer.DataIdentifier))
{
_initialStatePersistRequests[i] = dataContainer;
Debug.LogWarning($"BeginFramePersistentDataSystem:: Double persist request for container with DataIdentifier: {dataContainer.DataIdentifier.ToString()}! (Will only do last request)");
return;
}
}
_initialStatePersistRequests.Add(dataContainer);
}
public void ReadContainerData(PersistentDataContainer container)
{
string path = GetResourcePath(container.DataIdentifier);
Debug.Assert(File.Exists(path));
using (var fileStream = new FileStream(path, FileMode.Open))
{
int length = (int)fileStream.Length;
// Read Data
byte[] dataByteArray = new byte[length];
fileStream.Read(dataByteArray, 0, length);
container.GetRawData().CopyFrom(dataByteArray);
}
}
public void WriteContainerData(PersistentDataContainer container)
{
string path = GetResourcePath(container.DataIdentifier);
string folderPath = Path.GetDirectoryName(path);
if (!Directory.Exists(folderPath))
{
Directory.CreateDirectory(folderPath);
}
using (var fileStream = new FileStream(path, FileMode.Create))
{
var dataArray = container.GetRawData().ToArray();
fileStream.Write(dataArray, 0, dataArray.Length);
}
}
public void RequestPersist(PersistentDataContainer dataContainer)
{
for (int i = 0; i < _persistRequests.Count; i++)
{
if (_persistRequests[i].DataIdentifier.Equals(dataContainer.DataIdentifier))
{
if (_persistRequests[i].Tick < dataContainer.Tick)
{
_persistRequests[i] = dataContainer;
Debug.LogWarning($"BeginFramePersistentDataSystem:: Multiple different persist requests for DataIdentifier: {dataContainer.DataIdentifier.ToString()}! (Will apply oldest data)");
}
return;
}
}
_persistRequests.Add(dataContainer);
}
private unsafe void InitSceneSection(SceneSection sceneSection)
{
Hash128 containerIdentifier = sceneSection.SceneGUID;
PersistencyContainerTag containerTag = new PersistencyContainerTag()
{
DataIdentifier = containerIdentifier
};
if (PersistentDataStorage.IsInitialized(containerIdentifier))
{
PersistentDataContainer latestState = PersistentDataStorage.GetReadContainerForLatestWriteIndex(containerIdentifier, out bool isInitial);
_beginFrameSystem.RequestApply(latestState);
}
else
{
_scenePersistencyInfoQuery.SetSharedComponentFilter(containerTag);
if (_scenePersistencyInfoQuery.CalculateEntityCount() != 1)
{
return;
}
var scenePersistencyInfoRef = _scenePersistencyInfoQuery.GetSingleton <ScenePersistencyInfoRef>();
ref ScenePersistencyInfo sceneInfo = ref scenePersistencyInfoRef.InfoRef.Value;
int offset = 0;
var dataLayouts = new NativeArray <PersistencyArchetypeDataLayout>(sceneInfo.PersistencyArchetypes.Length, Allocator.Persistent);
for (var i = 0; i < sceneInfo.PersistencyArchetypes.Length; i++)
{
ref PersistencyArchetype persistencyArchetype = ref sceneInfo.PersistencyArchetypes[i];
var hashFilter = new PersistableTypeCombinationHash
{
Value = persistencyArchetype.PersistableTypeHandleCombinationHash
};
var dataLayout = new PersistencyArchetypeDataLayout()
{
Amount = persistencyArchetype.AmountEntities,
ArchetypeIndexInContainer = (ushort)i,
PersistedTypeInfoArrayRef = persistencyArchetype.BuildTypeInfoBlobAsset(PersistencySettings, persistencyArchetype.AmountEntities, out int sizePerEntity),
SizePerEntity = sizePerEntity,
Offset = offset,
PersistableTypeHandleCombinationHash = hashFilter.Value
};
offset += persistencyArchetype.AmountEntities * sizePerEntity;
dataLayouts[i] = dataLayout;
}
// BlobData is disposed if the owning entity is destroyed, we need this data even if the scene is unloaded
NativeArray <PersistableTypeHandle> allUniqueTypeHandles = new NativeArray <PersistableTypeHandle>(sceneInfo.AllUniqueTypeHandles.Length, Allocator.Persistent);
UnsafeUtility.MemCpy(allUniqueTypeHandles.GetUnsafePtr(), sceneInfo.AllUniqueTypeHandles.GetUnsafePtr(), allUniqueTypeHandles.Length * sizeof(PersistableTypeHandle));
// this function takes ownership over the dataLayouts array & allUniqueTypeHandles array
PersistentDataStorage.InitializeSceneContainer(containerIdentifier, dataLayouts, allUniqueTypeHandles,
out PersistentDataContainer initialStateContainer, out PersistentDataContainer containerToApply);
_beginFrameSystem.RequestInitialStatePersist(initialStateContainer);
if (containerToApply.IsCreated)
{
// containerToApply only exists if it was already added as uninitialized raw data beforehand (e.g. read from disk)
_beginFrameSystem.RequestApply(containerToApply);
}
}