internal unsafe void Initialize() { brushIDValues = new NativeList <CompactNodeID>(1000, Allocator.Persistent); allKnownBrushMeshIndices = new NativeHashSet <int>(1000, Allocator.Persistent); // TODO: not used?? brushTreeSpaceBoundLookup = new NativeHashMap <CompactNodeID, ChiselAABB>(1000, Allocator.Persistent); brushRenderBufferLookup = new NativeHashMap <CompactNodeID, ChiselBlobAssetReference <ChiselBrushRenderBuffer> >(1000, Allocator.Persistent); // brushIndex basePolygonCache = new NativeList <ChiselBlobAssetReference <BasePolygonsBlob> >(1000, Allocator.Persistent); brushTreeSpaceBoundCache = new NativeList <ChiselAABB>(1000, Allocator.Persistent); treeSpaceVerticesCache = new NativeList <ChiselBlobAssetReference <BrushTreeSpaceVerticesBlob> >(1000, Allocator.Persistent); routingTableCache = new NativeList <ChiselBlobAssetReference <RoutingTable> >(1000, Allocator.Persistent); brushTreeSpacePlaneCache = new NativeList <ChiselBlobAssetReference <BrushTreeSpacePlanes> >(1000, Allocator.Persistent); brushesTouchedByBrushCache = new NativeList <ChiselBlobAssetReference <BrushesTouchedByBrush> >(1000, Allocator.Persistent); transformationCache = new NativeList <NodeTransformations>(1000, Allocator.Persistent); brushRenderBufferCache = new NativeList <ChiselBlobAssetReference <ChiselBrushRenderBuffer> >(1000, Allocator.Persistent); parameters = new NativeArray <ChiselLayerParameters>(SurfaceLayers.ParameterCount, Allocator.Persistent); // Regular index operator will return a copy instead of a reference *sigh* var parameterPtr = parameters.GetUnsafePtr(); for (int i = 0; i < parameters.Length; i++) { ref var parameter = ref UnsafeUtility.ArrayElementAsRef <ChiselLayerParameters>(parameterPtr, i); parameter.Initialize(); Debug.Assert(parameter.IsCreated); }
public static unsafe void Execute(ref JobNativeMultiHashMapVisitKeyMutableValueProducer <TJob, TKey, TValue> producer, IntPtr additionalPtr, IntPtr bufferRangePatchData, ref JobRanges ranges, int jobIndex) { while (true) { int begin; int end; if (!JobsUtility.GetWorkStealingRange(ref ranges, jobIndex, out begin, out end)) { return; } var bucketData = producer.HashMap.GetUnsafeBucketData(); var buckets = (int *)bucketData.buckets; var nextPtrs = (int *)bucketData.next; var keys = bucketData.keys; var values = bucketData.values; for (int i = begin; i < end; i++) { int entryIndex = buckets[i]; while (entryIndex != -1) { var key = UnsafeUtility.ReadArrayElement <TKey>(keys, entryIndex); producer.JobData.ExecuteNext(key, ref UnsafeUtility.ArrayElementAsRef <TValue>(values, entryIndex)); entryIndex = nextPtrs[entryIndex]; } } } }
/// <summary> /// /// </summary> /// <param name="index"></param> /// <returns></returns> public ref T ElementAt(int index) { #if ENABLE_UNITY_COLLECTIONS_CHECKS AtomicSafetyHandle.CheckWriteAndThrow(m_Safety); #endif CheckIndexInRange(index, m_ListData->Length); return ref UnsafeUtility.ArrayElementAsRef<T>(m_ListData->Ptr, index); }
public void Execute(ArchetypeChunk chunk, int chunkIndex, int firstEntityIndex) { var random = new Unity.Mathematics.Random(RandomSeed); var index = chunk.GetSharedComponentIndex(SpriteAnimationChunkType); var spriteAnimation = UniqueSpriteAnimations[index]; var entities = chunk.GetNativeArray(EntityChunkType); var states = chunk.GetNativeArray(SpriteAnimationStateChunkType).GetUnsafePtr(); var randomizers = chunk.GetNativeArray(SpriteAnimationRandomizerChunkType); for (var i = 0; i < chunk.Count; ++i) { spriteAnimation.ClipIndex = random.NextInt(0, spriteAnimation.ClipCount); SpriteAnimationMap.TryAdd(entities[i], spriteAnimation); UnsafeUtility.ArrayElementAsRef <SpriteAnimationTimeSpeedState>(states, i).Speed = random.NextFloat(randomizers[i].RandomSpeedStart, randomizers[i].RandomSpeedEnd); } }
public ref Keyframe this[int index] => ref UnsafeUtility.ArrayElementAsRef <Keyframe>(array, index);
protected override unsafe void OnUpdate() { _renderedItemPositionComputationSystem.SetupDependency.Complete(); if (!RenderedItemCount.IsCreated) { RenderedItemCount = new NativeArray <int>(ItemTypes, Allocator.Persistent); } else { for (var index = 0; index < RenderedItemCount.Length; index++) { RenderedItemCount[index] = 0; } } var countPtr = (int *)RenderedItemCount.GetUnsafePtr(); var camera = Camera.main; var camPos = camera.transform.position; camera.CalculateFrustumCorners(new Rect(0, 0, 1, 1), camera.farClipPlane, Camera.MonoOrStereoscopicEye.Mono, _corners); for (int i = 0; i < 4; i++) { var worldSpaceCorner = camera.transform.TransformVector(_corners[i]); Debug.DrawRay(camPos, worldSpaceCorner, Color.blue); } var cullingPlanes = _cameraPlanes; FrustumPlanes.FromCamera(camera, cullingPlanes); Dependency = Entities.ForEach((DynamicBuffer <BeltItem> items, ref BeltSegment s) => { var sAABB = s.AABB; s.Rendered = FrustumPlanes.Intersect(cullingPlanes, sAABB) != FrustumPlanes.IntersectResult.Out; if (s.Rendered) { int *counts = stackalloc int[2]; UnsafeUtility.MemClear(counts, UnsafeUtility.SizeOf <int>() * ItemTypes); for (int i = 0; i < items.Length; i++) { counts[items[i].Type - ItemType.PaintBucket]++; } for (int i = 0; i < ItemTypes; i++) { Interlocked.Add(ref UnsafeUtility.ArrayElementAsRef <int>(countPtr, i), counts[i]); } } }) .WithNativeDisableUnsafePtrRestriction(countPtr) .WithNativeDisableParallelForRestriction(cullingPlanes) .ScheduleParallel(Dependency); var countPtr2 = (int *)RenderedItemCount.GetUnsafePtr(); CountDependency = Dependency = Entities.ForEach((ref BeltSplitter s) => { var sAABB = s.AABB; s.Rendered = FrustumPlanes.Intersect(cullingPlanes, sAABB) != FrustumPlanes.IntersectResult.Out; if (s.Rendered) { int *counts = stackalloc int[2]; UnsafeUtility.MemClear(counts, UnsafeUtility.SizeOf <int>() * 2); if (s.Input.Type != ItemType.None) { counts[s.Input.Type - ItemType.PaintBucket]++; } if (s.Output1.Type != ItemType.None) { counts[s.Output1.Type - ItemType.PaintBucket]++; } if (s.Output2.Type != ItemType.None) { counts[s.Output2.Type - ItemType.PaintBucket]++; } for (int i = 0; i < 2; i++) { Interlocked.Add(ref UnsafeUtility.ArrayElementAsRef <int>(countPtr2, i), counts[i]); } } }) .WithNativeDisableUnsafePtrRestriction(countPtr2) .WithNativeDisableParallelForRestriction(cullingPlanes) .ScheduleParallel(Dependency); }
public ref T this[int index] => ref UnsafeUtility.ArrayElementAsRef <T>((byte *)m_OffsetPtr + *m_OffsetPtr, index);