public static void Execute(NativeArray <byte> outputData, int typeSize, NativeArray <byte> componentByteArray, NativeArray <PersistenceState> persistenceStateArray)
{
const int amountFound = 1;
int totalElementSize = typeSize + PersistenceMetaData.SizeOfStruct;
for (int i = 0; i < persistenceStateArray.Length; i++)
{
PersistenceState persistenceState = persistenceStateArray[i];
#if ENABLE_UNITY_COLLECTIONS_CHECKS
if (persistenceState.ArrayIndex * totalElementSize >= outputData.Length)
{
throw new IndexOutOfRangeException("CopyComponentDataToByteArray:: persistenceState.ArrayIndex seems to be out of range. Or the totalElementSize is wrong.");
}
#endif
PersistenceMetaData *outputMetaDataBytePtr = (PersistenceMetaData *)((byte *)outputData.GetUnsafePtr() + (persistenceState.ArrayIndex * totalElementSize));
void *outputDataBytePtr = outputMetaDataBytePtr + 1;
void *compDataBytePtr = (byte *)componentByteArray.GetUnsafeReadOnlyPtr() + (i * typeSize);
// Diff
int diff = outputMetaDataBytePtr->AmountFound - amountFound;
diff |= UnsafeUtility.MemCmp(outputDataBytePtr, compDataBytePtr, typeSize);
// Write Meta Data
*outputMetaDataBytePtr = new PersistenceMetaData(diff, amountFound); // 1 branch in this constructor
// Write Data
UnsafeUtility.MemCpy(outputDataBytePtr, compDataBytePtr, typeSize);
}
}
public static void Execute(NativeArray <byte> inputData, int maxElements, UnsafeUntypedBufferAccessor untypedBufferAccessor,
NativeArray <PersistenceState> persistenceStateArray)
{
Debug.Assert(maxElements < PersistenceMetaData.MaxValueForAmount);
int elementSize = untypedBufferAccessor.ElementSize;
int sizePerEntity = elementSize * maxElements + PersistenceMetaData.SizeOfStruct;
for (int i = 0; i < persistenceStateArray.Length; i++)
{
PersistenceState persistenceState = persistenceStateArray[i];
#if ENABLE_UNITY_COLLECTIONS_CHECKS
if (persistenceState.ArrayIndex >= inputData.Length / sizePerEntity)
{
throw new IndexOutOfRangeException("CopyByteArrayToBufferElements:: persistenceState.ArrayIndex seems to be out of range. Or the sizePerEntity is wrong.");
}
#endif
PersistenceMetaData *inputMetaDataPtr = (PersistenceMetaData *)((byte *)inputData.GetUnsafeReadOnlyPtr() + persistenceState.ArrayIndex * sizePerEntity);
void *inputDataBytePtr = inputMetaDataPtr + 1; // + 1 because it's a PersistenceMetaData pointer
// Resize
int amountToCopy = inputMetaDataPtr->AmountFound;
untypedBufferAccessor.ResizeUninitialized(i, amountToCopy);
// Get (Possibly modified because of resize) ptr to buffer data
void *bufferDataPtr = untypedBufferAccessor.GetUnsafePtrAndLength(i, out int length);
Debug.Assert(length == amountToCopy);
// Write Data
UnsafeUtility.MemCpy(bufferDataPtr, inputDataBytePtr, elementSize * amountToCopy);
}
}
public static void Execute(NativeArray <byte> outputData, int maxElements, UnsafeUntypedBufferAccessor untypedBufferAccessor,
NativeArray <PersistenceState> persistenceStateArray)
{
int elementSize = untypedBufferAccessor.ElementSize;
int sizePerEntity = elementSize * maxElements + PersistenceMetaData.SizeOfStruct;
for (int i = 0; i < persistenceStateArray.Length; i++)
{
PersistenceState persistenceState = persistenceStateArray[i];
#if ENABLE_UNITY_COLLECTIONS_CHECKS
if (persistenceState.ArrayIndex >= outputData.Length / sizePerEntity)
{
throw new IndexOutOfRangeException("CopyBufferElementsToByteArray:: persistenceState.ArrayIndex seems to be out of range. Or the sizePerEntity is wrong.");
}
#endif
void *bufferDataPtr = untypedBufferAccessor.GetUnsafeReadOnlyPtrAndLength(i, out int length);;
PersistenceMetaData *outputMetaBytePtr = (PersistenceMetaData *)((byte *)outputData.GetUnsafePtr() + persistenceState.ArrayIndex * sizePerEntity);
void *outputDataBytePtr = outputMetaBytePtr + 1;
int amountToCopy = math.clamp(length, 0, maxElements);
// Diff
int diff = outputMetaBytePtr->AmountFound - amountToCopy;
diff |= UnsafeUtility.MemCmp(outputDataBytePtr, bufferDataPtr, amountToCopy * elementSize);
// Write Meta Data
*outputMetaBytePtr = new PersistenceMetaData(diff, (ushort)amountToCopy); // 1 branch in this constructor
// Write Data
UnsafeUtility.MemCpy(outputDataBytePtr, bufferDataPtr, elementSize * amountToCopy);
}
}
public static void Execute(NativeArray <byte> inputData, ComponentType componentType, int typeSize, NativeArray <Entity> entityArray,
NativeArray <PersistenceState> persistenceStateArray, EntityCommandBuffer.ParallelWriter ecb, int batchIndex)
{
int totalElementSize = typeSize + PersistenceMetaData.SizeOfStruct;
for (int i = 0; i < entityArray.Length; i++)
{
PersistenceState persistenceState = persistenceStateArray[i];
int inputMetaByteIndex = persistenceState.ArrayIndex * totalElementSize;
int inputDataByteIndex = inputMetaByteIndex + PersistenceMetaData.SizeOfStruct;
#if ENABLE_UNITY_COLLECTIONS_CHECKS
if (persistenceState.ArrayIndex * totalElementSize >= inputData.Length)
{
throw new IndexOutOfRangeException("AddMissingComponent:: persistenceState.ArrayIndex seems to be out of range. Or the totalElementSize is wrong.");
}
#endif
var metaData = UnsafeUtility.ReadArrayElementWithStride <PersistenceMetaData>(inputData.GetUnsafeReadOnlyPtr(), persistenceState.ArrayIndex, totalElementSize);
if (metaData.AmountFound == 1)
{
ecb.AddComponent(batchIndex, entityArray[i], componentType);
if (typeSize != 0)
{
ecb.SetComponent(batchIndex, entityArray[i], componentType, typeSize, inputData.GetSubArray(inputDataByteIndex, typeSize));
}
}
}
}
public static void Execute(NativeArray <byte> inputData, int typeSize, NativeArray <byte> componentByteArray, NativeArray <PersistenceState> persistenceStateArray)
{
int totalElementSize = typeSize + PersistenceMetaData.SizeOfStruct;
for (int i = 0; i < persistenceStateArray.Length; i++)
{
PersistenceState persistenceState = persistenceStateArray[i];
#if ENABLE_UNITY_COLLECTIONS_CHECKS
if (persistenceState.ArrayIndex * totalElementSize >= inputData.Length)
{
throw new IndexOutOfRangeException("CopyByteArrayToComponentData:: persistenceState.ArrayIndex seems to be out of range. Or the totalElementSize is wrong.");
}
#endif
byte *inputDataPtr = (byte *)inputData.GetUnsafeReadOnlyPtr() + (persistenceState.ArrayIndex * totalElementSize + PersistenceMetaData.SizeOfStruct);
byte *compDataBytePtr = (byte *)componentByteArray.GetUnsafePtr() + (i * typeSize);
// Write Data
UnsafeUtility.MemCpy(compDataBytePtr, inputDataPtr, typeSize);
}
}
public static void Execute(NativeArray <byte> outputData, int stride, NativeArray <PersistenceState> persistenceStateArray, int amountFound)
{
for (int i = 0; i < persistenceStateArray.Length; i++)
{
PersistenceState persistenceState = persistenceStateArray[i];
#if ENABLE_UNITY_COLLECTIONS_CHECKS
if (persistenceState.ArrayIndex * stride >= outputData.Length)
{
throw new IndexOutOfRangeException("UpdateMetaDataForTagComponent:: persistenceState.ArrayIndex seems to be out of range. Or the PersistenceMetaData.SizeOfStruct is wrong.");
}
#endif
var metaData = UnsafeUtility.ReadArrayElementWithStride <PersistenceMetaData>(outputData.GetUnsafeReadOnlyPtr(), persistenceState.ArrayIndex, stride);
// Diff
int diff = metaData.AmountFound - amountFound;
// Write Meta Data
// 1 branch in PersistenceMetaData constructor
UnsafeUtility.WriteArrayElementWithStride(outputData.GetUnsafePtr(), persistenceState.ArrayIndex, stride, new PersistenceMetaData(diff, (ushort)amountFound));
}
}
