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)); } }