private static ArchetypeOffsetsFromChunk GetChunkOffsets(EntityManager em, EntityArchetype archetype, ComponentType metaType, ComponentType componentType, ComponentType bufferType = default, ComponentType linkType = default)
{
ArchetypeOffsetsFromChunk schema = default;
var tmpEntity = em.CreateEntity(archetype);
var chunk = em.GetChunk(tmpEntity);
byte *chunkPtr = *(byte **)&chunk;
var tmp = em.GetArchetypeChunkComponentType <ChunkHeader>(false);
var types = archetype.GetComponentTypes();
UnsafeUtility.CopyStructureToPtr(ref metaType.TypeIndex, UnsafeUtility.AddressOf(ref tmp));
schema.MetaOffset = (byte *)chunk.GetNativeArray(tmp).GetUnsafeReadOnlyPtr() - chunkPtr;
UnsafeUtility.CopyStructureToPtr(ref componentType.TypeIndex, UnsafeUtility.AddressOf(ref tmp));
schema.ComponentOffset = (byte *)chunk.GetNativeArray(tmp).GetUnsafeReadOnlyPtr() - chunkPtr;
if (bufferType != default)
{
UnsafeUtility.CopyStructureToPtr(ref linkType.TypeIndex, UnsafeUtility.AddressOf(ref tmp));
schema.BufferLinkOffset = (byte *)chunk.GetNativeArray(tmp).GetUnsafeReadOnlyPtr() - chunkPtr;
UnsafeUtility.CopyStructureToPtr(ref bufferType.TypeIndex, UnsafeUtility.AddressOf(ref tmp));
schema.BufferOffset = (byte *)chunk.GetNativeArray(tmp).GetUnsafeReadOnlyPtr() - chunkPtr;
}
em.DestroyEntity(tmpEntity);
return(schema);
}
/// <summary>
/// Gets the <see cref="IComponentData"/> instance of type T for the specified entity.
/// </summary>
/// <param name="entity">The entity.</param>
/// <returns>An <see cref="IComponentData"/> type.</returns>
/// <remarks>You cannot use ComponentDataFromEntity to get zero-sized <see cref="IComponentData"/>.
/// Use <see cref="HasComponent"/> to check whether an entity has the zero-sized component instead.
///
/// Normally, you cannot write to components accessed using a ComponentDataFromEntity instance
/// in a parallel Job. This restriction is in place because multiple threads could write to the same component,
/// leading to a race condition and nondeterministic results. However, when you are certain that your algorithm
/// cannot write to the same component from different threads, you can manually disable this safety check
/// by putting the [NativeDisableParallelForRestrictions] attribute on the ComponentDataFromEntity field in the Job.
///
/// [NativeDisableParallelForRestrictionAttribute]: https://docs.unity3d.com/ScriptReference/Unity.Collections.NativeDisableParallelForRestrictionAttribute.html
/// </remarks>
/// <exception cref="System.ArgumentException">Thrown if T is zero-size.</exception>
public T this[Entity entity]
{
get
{
#if ENABLE_UNITY_COLLECTIONS_CHECKS
AtomicSafetyHandle.CheckReadAndThrow(m_Safety);
#endif
m_EntityComponentStore->AssertEntityHasComponent(entity, m_TypeIndex);
CheckComponentIsZeroSized();
void *ptr = m_EntityComponentStore->GetComponentDataWithTypeRO(entity, m_TypeIndex, ref m_Cache);
UnsafeUtility.CopyPtrToStructure(ptr, out T data);
return(data);
}
set
{
#if ENABLE_UNITY_COLLECTIONS_CHECKS
AtomicSafetyHandle.CheckWriteAndThrow(m_Safety);
#endif
m_EntityComponentStore->AssertEntityHasComponent(entity, m_TypeIndex);
CheckComponentIsZeroSized();
void *ptr = m_EntityComponentStore->GetComponentDataWithTypeRW(entity, m_TypeIndex, m_GlobalSystemVersion, ref m_Cache);
UnsafeUtility.CopyStructureToPtr(ref value, ptr);
}
}
// ----------------------------------------------------
#region // Protected Methods
protected override void OnCreateManager()
{
this._playerGroup = base.GetComponentGroup(
ComponentType.ReadOnly <PlayerTag>(),
ComponentType.Create <PlayerStatus>(),
ComponentType.Subtractive <BulletTag>(),
ComponentType.Create <Destroyable>(),
ComponentType.ReadOnly <Position2D>());
this._enemyGroup = base.GetComponentGroup(
ComponentType.ReadOnly <EnemyTag>(),
ComponentType.Create <EnemyData>(),
ComponentType.Create <Destroyable>(),
ComponentType.Create <Position2D>());
this._playerBulletGenerateGroup = base.GetComponentGroup(
ComponentType.ReadOnly <BulletData>(),
ComponentType.ReadOnly <PlayerBulletGenerate>());
this._enemyGenerateGroup = base.GetComponentGroup(
ComponentType.ReadOnly <EnemyData>(),
ComponentType.ReadOnly <EnemyGenerate>());
// 乱数生成器の構造体をJobに渡すためにPtrに変換
// ※Ptrで渡さないと値渡しになってシード値が維持されないため。
var random = new Random((uint)System.DateTime.Now.Ticks);
var randomStrSize = UnsafeUtility.SizeOf <Random>();
this._randomPtr = (Random *)UnsafeUtility.Malloc(randomStrSize, UnsafeUtility.AlignOf <Random>(), Allocator.Persistent);
UnsafeUtility.MemClear(this._randomPtr, randomStrSize);
UnsafeUtility.CopyStructureToPtr <Random>(ref random, this._randomPtr);
}
private unsafe static void WriteFunctionPointer <TDelegate>(IntPtr ptr, TypeDecomposer.FieldData fieldData, MethodInfo method) where TDelegate : Delegate
{
var func = (TDelegate)method.CreateDelegate(typeof(TDelegate));
var compiled = BurstCompiler.CompileFunctionPointer <TDelegate>(func);
UnsafeUtility.CopyStructureToPtr(ref compiled, (ptr + fieldData.offset).ToPointer());
}
public unsafe void Write(string s, IntPtr ptr, TypeDecomposer.FieldData fieldData, MemoryBinaryWriter extraBytesStream, long extraByteStreamOffset, UIPropertyWriterContext context)
{
if (parser.Invoke(s, out TValue result))
{
UnsafeUtility.CopyStructureToPtr(ref result, (ptr + fieldData.offset).ToPointer());
}
}
protected override void OnCreate()
{
var pointerArray = new NavMeshQueryPointer[JobsUtility.MaxJobThreadCount];
for (int i = 0; i < JobsUtility.MaxJobThreadCount; ++i)
{
pointerArray[i] = new NavMeshQueryPointer
{
Value = UnsafeUtility.Malloc(
UnsafeUtility.SizeOf <NavMeshQuery>(),
UnsafeUtility.AlignOf <NavMeshQuery>(),
Allocator.Persistent
)
};
var query = new NavMeshQuery(
NavMeshWorld.GetDefaultWorld(),
Allocator.Persistent,
NavConstants.PATH_NODE_MAX
);
queryList.Add(query);
UnsafeUtility.CopyStructureToPtr(ref query, pointerArray[i].Value);
}
PointerArray = new NativeArray <NavMeshQueryPointer>(pointerArray, Allocator.Persistent);
}
protected override void OnCreate()
{
var settings = pathSystem.Settings;
var pointerArray = new PathMeshQueryPointer[JobsUtility.MaxJobThreadCount];
for (var i = 0; i < JobsUtility.MaxJobThreadCount; ++i)
{
pointerArray[i] = new PathMeshQueryPointer
{
Value = UnsafeUtility.Malloc(
UnsafeUtility.SizeOf <NavMeshQuery>(),
UnsafeUtility.AlignOf <NavMeshQuery>(),
Allocator.Persistent
)
};
var query = new NavMeshQuery(
NavMeshWorld.GetDefaultWorld(),
Allocator.Persistent,
settings.PathMeshQueryNodeMax
);
queryList.Add(query);
UnsafeUtility.CopyStructureToPtr(ref query, pointerArray[i].Value);
}
PointerArray = new NativeArray <PathMeshQueryPointer>(pointerArray, Allocator.Persistent);
}
public void SetValue <T>(ActionStateIndex index, T value) where T : struct
{
var node = _nodes[ToNodeIndex(index)];
var valueOffset = _chunks[index.ChunkIndex].Position * _containerInfo[0].StatesSize + node.offset;
UnsafeUtility.CopyStructureToPtr(ref value, _states + valueOffset);
}
public static unsafe JobHandle ScheduleParallelFor(ref JobScheduleParameters parameters, int arrayLength, int innerloopBatchCount)
{
UnsafeUtility.AssertHeap(parameters.JobDataPtr.ToPointer());
UnsafeUtility.AssertHeap(parameters.ReflectionData.ToPointer());
ReflectionDataProxy jobReflectionData = UnsafeUtility.AsRef <ReflectionDataProxy>(parameters.ReflectionData.ToPointer());
Assert.IsFalse(jobReflectionData.GenExecuteFunctionPtr.ToPointer() == null);
Assert.IsFalse(jobReflectionData.GenCleanupFunctionPtr.ToPointer() == null);
void * jobMetaPtr = parameters.JobDataPtr.ToPointer();
JobMetaData jobMetaData = default;
jobMetaData.JobRanges.ArrayLength = arrayLength;
jobMetaData.JobRanges.IndicesPerPhase = GetDefaultIndicesPerPhase(arrayLength);
UnsafeUtility.CopyStructureToPtr(ref jobMetaData, jobMetaPtr);
#if UNITY_SINGLETHREADED_JOBS
// In the single threaded case, this is synchronous execution.
UnsafeUtility.CallFunctionPtr_pi(jobReflectionData.GenExecuteFunctionPtr.ToPointer(), jobMetaPtr, 0);
UnsafeUtility.CallFunctionPtr_p(jobReflectionData.GenCleanupFunctionPtr.ToPointer(), jobMetaPtr);
// This checks that the generated code was actually called; the last responsibility of
// the generated code is to clean up the memory. Unfortunately only works in single threaded mode,
Assert.IsTrue(UnsafeUtility.GetLastFreePtr() == jobMetaPtr);
return(new JobHandle());
#else
return(ScheduleJobParallelFor(jobReflectionData.GenExecuteFunctionPtr, jobReflectionData.GenCleanupFunctionPtr,
parameters.JobDataPtr, arrayLength, innerloopBatchCount, parameters.Dependency));
#endif
}
internal override unsafe void InjectEntry(InjectionContext.Entry entry, ComponentGroup entityGroup, ref ComponentChunkIterator iterator, int length, byte *groupStructPtr)
{
iterator.IndexInComponentGroup = entry.IndexInComponentGroup;
var data = new ComponentArray <Component>(iterator, length, entityGroup.ArchetypeManager);
UnsafeUtility.CopyStructureToPtr(ref data, groupStructPtr + entry.FieldOffset);
}
public static Trait Create <T>(T value) where T : struct
{
if (!UnsafeUtility.IsUnmanaged <T>())
{
throw new Exception($"{typeof(T).Name} must be an unmanaged type");
}
var sizeOfType = UnsafeUtility.SizeOf <T>();
var result = new Trait
{
type = typeof(T),
byteArray = sizeOfType > 0 ? new byte[sizeOfType] : null
};
unsafe
{
fixed(void *destination = result.byteArray)
{
UnsafeUtility.CopyStructureToPtr(ref value, destination);
}
}
return(result);
}
private NativeFasterDictionaryData *Allocate(int size, Allocator allocator, NativeArrayOptions options = NativeArrayOptions.ClearMemory)
{
var layout = CalculateLayout(size);
var ptr = UnsafeUtility.Malloc(layout.AllocationBytes, UnsafeUtility.AlignOf <int>(), allocator);
if (options == NativeArrayOptions.ClearMemory)
{
UnsafeUtility.MemClear(ptr, layout.AllocationBytes);
}
var header = new NativeFasterDictionaryData
{
//BaseAddress = ptr,
FreeValueCellIndex = 0,
Collisions = 0,
Capacity = size,
Layout = layout,
Nodes = NativeSpan.Assign <Node>((IntPtr)ptr + layout.NodesOffset, layout.NodesCount),
Values = NativeSpan.Assign <TValue>((IntPtr)ptr + layout.ValuesOffset, layout.ValuesCount),
Buckets = NativeSpan.Assign <int>((IntPtr)ptr + layout.BucketsOffset, layout.BucketsCount),
};
UnsafeUtility.CopyStructureToPtr(ref header, ptr);
return(CastPtr <NativeFasterDictionaryData>(ptr, 0));
}
public static unsafe JobHandle ScheduleBatch <T>(this T jobData, int arrayLength, int minIndicesPerJobCount, JobHandle dependsOn = new JobHandle()) where T : struct, IJobParallelForBatch
{
#if UNITY_SINGLETHREADED_JOBS
jobData.Execute(0, arrayLength);
DoDeallocateOnJobCompletion(jobData);
return(new JobHandle());
#elif UNITY_DOTSPLAYER
var jobStruct = new ParallelForBatchJobStruct <T>()
{
JobData = jobData,
Ranges = new JobRanges()
{
ArrayLength = arrayLength,
IndicesPerPhase = JobsUtility.GetDefaultIndicesPerPhase(arrayLength)
},
};
var jobDataPtr = UnsafeUtility.Malloc(UnsafeUtility.SizeOf <ParallelForBatchJobStruct <T> >(),
UnsafeUtility.AlignOf <ParallelForBatchJobStruct <T> >(), Allocator.TempJob);
UnsafeUtility.CopyStructureToPtr(ref jobStruct, jobDataPtr);
var scheduleParams = new JobsUtility.JobScheduleParameters(jobDataPtr, ParallelForBatchJobStruct <T> .Initialize(),
dependsOn, ScheduleMode.Batched);
return(JobsUtility.ScheduleParallelFor(ref scheduleParams, arrayLength, minIndicesPerJobCount));
#else
var scheduleParams = new JobsUtility.JobScheduleParameters(UnsafeUtility.AddressOf(ref jobData), ParallelForBatchJobStruct <T> .Initialize(), dependsOn, ScheduleMode.Batched);
return(JobsUtility.ScheduleParallelFor(ref scheduleParams, arrayLength, minIndicesPerJobCount));
#endif
}
public unsafe void SetJobData <T>(T jobData)
where T : struct, IAnimationJob
{
CheckJobTypeValidity <T>();
UnsafeUtility.CopyStructureToPtr(ref jobData, (void *)GetHandle().GetJobData());
}
public T this[Entity entity]
{
get
{
T local;
AtomicSafetyHandle.CheckReadAndThrow(this.m_Safety);
this.m_Entities.AssertEntityHasComponent(entity, this.m_TypeIndex);
if (this.m_IsZeroSized)
{
throw new ArgumentException($"ComponentDataFromEntity<{typeof(T)}> indexer can not get the component because it is zero sized, you can use Exists instead.");
}
UnsafeUtility.CopyPtrToStructure <T>((void *)this.m_Entities.GetComponentDataWithTypeRO(entity, this.m_TypeIndex, ref this.m_TypeLookupCache), out local);
return(local);
}
set
{
AtomicSafetyHandle.CheckWriteAndThrow(this.m_Safety);
this.m_Entities.AssertEntityHasComponent(entity, this.m_TypeIndex);
if (this.m_IsZeroSized)
{
throw new ArgumentException($"ComponentDataFromEntity<{typeof(T)}> indexer can not set the component because it is zero sized, you can use Exists instead.");
}
void *ptr = (void *)ref this.m_Entities.GetComponentDataWithTypeRW(entity, this.m_TypeIndex, this.m_GlobalSystemVersion, ref this.m_TypeLookupCache);
UnsafeUtility.CopyStructureToPtr <T>(ref value, ptr);
}
}
static unsafe JobHandle Schedule <T>(ref T jobData, IntPtr arrayLengthPtr, int innerloopBatchCount, JobHandle dependsOn)
where T : struct, IJobParallelForDefer
{
#if UNITY_SINGLETHREADED_JOBS
var arrayLength = UnsafeUtility.AsRef <int>(arrayLengthPtr.ToPointer());
for (var i = 0; i < arrayLength; ++i)
{
jobData.Execute(i);
}
DoDeallocateOnJobCompletion(jobData);
return(new JobHandle());
#else
var jobStruct = new JobStructDefer <T>()
{
JobData = jobData,
ArrayLengthPtr = arrayLengthPtr,
};
var jobDataPtr = UnsafeUtility.Malloc(UnsafeUtility.SizeOf <JobStructDefer <T> >(),
UnsafeUtility.AlignOf <JobStructDefer <T> >(), Allocator.TempJob);
UnsafeUtility.CopyStructureToPtr(ref jobStruct, jobDataPtr);
var scheduleParams = new JobsUtility.JobScheduleParameters(jobDataPtr, JobStructDefer <T> .Initialize(),
dependsOn, ScheduleMode.Batched);
return(JobsUtility.ScheduleParallelFor(ref scheduleParams, JobsUtility.JobQueueThreadCount, innerloopBatchCount));
#endif
}
public unsafe void SetJobData <T>(T value)
where T : struct, IAnimationJob
{
CheckJobTypeValidity <T>();
UnsafeUtility.CopyStructureToPtr(ref value, (void *)GetHandle().GetAdditionalPayload());
}
public T this[Entity entity]
{
get
{
#if ENABLE_UNITY_COLLECTIONS_CHECKS
AtomicSafetyHandle.CheckReadAndThrow(m_Safety);
#endif
m_Entities->AssertEntityHasComponent(entity, m_TypeIndex);
void *ptr = m_Entities->GetComponentDataWithType(entity, m_TypeIndex, ref m_TypeLookupCache);
T data;
UnsafeUtility.CopyPtrToStructure(ptr, out data);
return(data);
}
set
{
#if ENABLE_UNITY_COLLECTIONS_CHECKS
AtomicSafetyHandle.CheckWriteAndThrow(m_Safety);
#endif
m_Entities->AssertEntityHasComponent(entity, m_TypeIndex);
void *ptr = m_Entities->GetComponentDataWithType(entity, m_TypeIndex);
UnsafeUtility.CopyStructureToPtr(ref value, ptr);
}
}
public AtomicFloat Create(float initial_value)
{
int LOOP_MAX = m_Capacity;
int current_index = -1;
long current = 0;
int i = 0;
for (; i < LOOP_MAX; ++i)
{
current_index = Interlocked.Increment(ref *m_Index) % LOOP_MAX;
current = (m_Table + current_index)->m_Value;
var next = ALIVE_FLG | current;
var prev = Interlocked.CompareExchange(ref (m_Table + current_index)->m_Value, next, current);
if (prev == current)
{
break;
}
}
Assert.AreNotEqual(current_index, -1, "bug.");
Assert.AreNotEqual(i, LOOP_MAX, "capacity exceeded.");
byte *ptr = m_Data + (GetUnitSize() * current_index);
UnsafeUtility.CopyStructureToPtr(ref this, ptr + UnsafeUtility.SizeOf <float>() /* value */); // embed whole AtomicFloatResource here.
return(new AtomicFloat(ptr, current, initial_value));
}
unsafe static void SwapSortAscending <T>(ref NativeArrayData <T> array, int left, int mid, int right) where T : struct, IComparable <T>
{
var typeSize = UnsafeUtility.SizeOf <T>();
void *leftAddr = array.ptr + (typeSize * left);
void *midAddr = array.ptr + (typeSize * mid);
void *rightAddr = array.ptr + (typeSize * right);
UnsafeUtility.CopyPtrToStructure(leftAddr, out array.aux_first);
UnsafeUtility.CopyPtrToStructure(midAddr, out array.aux_second);
UnsafeUtility.CopyPtrToStructure(rightAddr, out array.aux_third);
int bitmask = 0;
if (array.aux_first.CompareTo(array.aux_second) > 0)
{
bitmask = 1;
}
if (array.aux_first.CompareTo(array.aux_third) > 0)
{
bitmask |= 1 << 1;
}
if (array.aux_second.CompareTo(array.aux_third) > 0)
{
bitmask |= 1 << 2;
}
switch (bitmask)
{
case 1:
UnsafeUtility.CopyStructureToPtr(ref array.aux_second, leftAddr);
UnsafeUtility.CopyStructureToPtr(ref array.aux_first, midAddr);
return;
case 3:
UnsafeUtility.CopyStructureToPtr(ref array.aux_second, leftAddr);
UnsafeUtility.CopyStructureToPtr(ref array.aux_third, midAddr);
UnsafeUtility.CopyStructureToPtr(ref array.aux_first, rightAddr);
return;
case 4:
UnsafeUtility.CopyStructureToPtr(ref array.aux_third, midAddr);
UnsafeUtility.CopyStructureToPtr(ref array.aux_second, rightAddr);
return;
case 6:
UnsafeUtility.CopyStructureToPtr(ref array.aux_third, leftAddr);
UnsafeUtility.CopyStructureToPtr(ref array.aux_first, midAddr);
UnsafeUtility.CopyStructureToPtr(ref array.aux_second, rightAddr);
return;
case 7:
UnsafeUtility.CopyStructureToPtr(ref array.aux_third, leftAddr);
UnsafeUtility.CopyStructureToPtr(ref array.aux_first, rightAddr);
return;
default: //we are already ordered
return;
}
}
public NativeMinHeap(COMPARER comparer, Allocator allocator, int capacity)
{
_allocator = allocator;
_stack = new NativeStack <VALUE>(capacity, allocator);
_comparer = (COMPARER *)UnsafeUtility.Malloc(sizeof(COMPARER), UnsafeUtility.AlignOf <COMPARER>(), allocator);
UnsafeUtility.CopyStructureToPtr(ref comparer, _comparer);
}
public static GameInput Create <T>(int iframe, ref T value, uint offset = 0) where T : struct
{
var size = UnsafeUtility.SizeOf <T>();
var input = new GameInput(iframe, null, (uint)size);
UnsafeUtility.CopyStructureToPtr(ref value, input.bits + size * offset);
return(input);
}
public void WriteStruct <T>(ref T value) where T : struct
{
var size = UnsafeUtility.SizeOf <T>();
CheckRemainingSize(size);
UnsafeUtility.CopyStructureToPtr(ref value, _current);
_current += size;
}
public static T *Create <T>(ref T source, Unity.Collections.Allocator allocator = Unity.Collections.Allocator.Persistent) where T : unmanaged
{
var size = UnsafeUtility.SizeOf <T>();
var ptr = (T *)System.Runtime.InteropServices.Marshal.AllocHGlobal(size);
//var ptr = UnsafeUtility.Malloc(UnsafeUtility.SizeOf<T>(), UnsafeUtility.AlignOf<T>(), allocator);
UnsafeUtility.CopyStructureToPtr(ref source, ptr);
return(ptr);
}
public static void *CreateFromStruct <T>(ref void *ptr, ref T source, Unity.Collections.Allocator allocator = Unity.Collections.Allocator.Persistent) where T : struct
{
var size = UnsafeUtility.SizeOf <T>();
ptr = (void *)System.Runtime.InteropServices.Marshal.AllocHGlobal(size);
//ptr = UnsafeUtility.Malloc(UnsafeUtility.SizeOf<T>(), UnsafeUtility.AlignOf<T>(), allocator);
UnsafeUtility.CopyStructureToPtr(ref source, ptr);
return(ptr);
}
/// <summary>
/// Make a copy of a structure in native memory
/// </summary>
/// <param name="structure">The structure to copy</param>
/// <typeparam name="T">The type of structure</typeparam>
/// <returns>A pointer to newly-allocated memory containing a copy of structure</returns>
/// <remarks>
/// This uses the Persistent native allocator
/// </remarks>
public static unsafe void *CopyToPersistentAllocation <T>(ref T structure)
where T : struct
{
void *copy = UnsafeUtility.Malloc(UnsafeUtility.SizeOf <T>(), UnsafeUtility.AlignOf <T>(), Allocator.Persistent);
RegisterAllocation(copy, Allocator.Persistent);
UnsafeUtility.CopyStructureToPtr(ref structure, copy);
return(copy);
}
public static BlobData Create <T0>(BlobAssetReference <T0> reference, int identifier)
where T0 : struct
{
BlobData blobData = default;
UnsafeUtility.CopyStructureToPtr(ref reference, &blobData.m_blobRef);
return(blobData);
}
public void SetChunkComponentData <T>(ArchetypeChunkComponentType <T> chunkComponentType, T value)
where T : struct
{
#if ENABLE_UNITY_COLLECTIONS_CHECKS
AtomicSafetyHandle.CheckWriteAndThrow(chunkComponentType.m_Safety);
#endif
var ptr = entityComponentStore->GetComponentDataWithTypeRW(m_Chunk->metaChunkEntity, chunkComponentType.m_TypeIndex, entityComponentStore->GlobalSystemVersion);
UnsafeUtility.CopyStructureToPtr(ref value, ptr);
}
public void Set <T>(T value) where T : struct
{
if (head.GetPosition <T>(out var pos))
{
UnsafeUtility.CopyStructureToPtr(ref value, data + pos.Offset);
return;
}
throw new Exception("T does not exist");
}
public unsafe void WriteBack(Entity entity, ref T lambdaComponent, ref T originalComponent)
{
// MemCmp check is necessary to ensure we only write-back the value if we changed it in the lambda (or a called function)
if (UnsafeUtility.MemCmp(UnsafeUtility.AddressOf(ref lambdaComponent), UnsafeUtility.AddressOf(ref originalComponent), UnsafeUtility.SizeOf <T>()) != 0 &&
_manager.EntityComponentStore->HasComponent(entity, _typeIndex))
{
UnsafeUtility.CopyStructureToPtr(ref lambdaComponent, _manager.EntityComponentStore->GetComponentDataWithTypeRW(
entity, _typeIndex, _manager.EntityComponentStore->GlobalSystemVersion));
}
}