Esempio n. 1
0
        private static unsafe void Allocate(int length, Allocator allocator, out NativeArrayBurst <T> array)
        {
            long totalSize = (long)((ulong)UnsafeUtility.SizeOf <T>() * (ulong)length);

            #if COLLECTIONS_CHECKS
            // Native allocation is only valid for Temp, Job and Persistent
            if (allocator <= Allocator.None)
            {
                throw new ArgumentException("Allocator must be Temp, TempJob or Persistent", "allocator");
            }
            if (length < 0)
            {
                throw new ArgumentOutOfRangeException("length", "Length must be >= 0");
            }
            if (!UnsafeUtility.IsBlittable <T>())
            {
                throw new ArgumentException(string.Format("{0} used in NativeArrayBurst<{0}> must be blittable", typeof(T)));
            }
            #endif

            array.m_Buffer = UnsafeUtility.Malloc(totalSize, UnsafeUtility.AlignOf <T>(), allocator);
            UnsafeUtility.MemClear(array.m_Buffer, totalSize);

            array.m_Length         = length;
            array.m_AllocatorLabel = allocator;

            #if COLLECTIONS_CHECKS
            array.m_MinIndex = 0;
            array.m_MaxIndex = length - 1;
            DisposeSentinel.Create(out array.m_Safety, out array.m_DisposeSentinel, 1, allocator);
            #endif
        }
Esempio n. 2
0
        public unsafe NativeSliceBurst(NativeArrayBurst <T> array, int start, int length)
        {
            #if COLLECTIONS_CHECKS
            if (start < 0)
            {
                throw new ArgumentOutOfRangeException(nameof(start), string.Format("Slice start {0} < 0.", (object)start));
            }

            if (length < 0)
            {
                throw new ArgumentOutOfRangeException(nameof(length), string.Format("Slice length {0} < 0.", (object)length));
            }

            if (start + length > array.Length)
            {
                throw new ArgumentException(string.Format("Slice start + length ({0}) range must be <= array.Length ({1})", (object)(start + length), (object)array.Length));
            }

            if ((array.m_MinIndex != 0 || array.m_MaxIndex != array.m_Length - 1) &&
                (start < array.m_MinIndex || array.m_MaxIndex < start || array.m_MaxIndex < start + length - 1))
            {
                throw new ArgumentException("Slice may not be used on a restricted range array", nameof(array));
            }

            this.m_MinIndex = 0;
            this.m_MaxIndex = length - 1;
            this.m_Safety   = array.m_Safety;
            #endif
            this.m_Stride = UnsafeUtility.SizeOf <T>();
            this.m_Buffer = (byte *)((IntPtr)array.m_Buffer + this.m_Stride * start);
            this.m_Length = length;
        }
Esempio n. 3
0
        public NativeArrayBurst(T[] array, Allocator allocator)
        {
            if (array == null)
            {
                throw new ArgumentNullException(nameof(array));
            }
            NativeArrayBurst <T> .Allocate(array.Length, allocator, out this);

            NativeArrayBurst <T> .Copy(array, this);
        }
Esempio n. 4
0
 public static void Copy(T[] src, NativeArrayBurst <T> dst)
 {
     #if COLLECTIONS_CHECKS
     AtomicSafetyHandle.CheckWriteAndThrow(dst.m_Safety);
     if (src.Length != dst.Length)
     {
         throw new ArgumentException("source and destination length must be the same");
     }
     #endif
     NativeArrayBurst <T> .Copy(src, 0, dst, 0, src.Length);
 }
Esempio n. 5
0
 public static ref T GetRefRead <T>(this NativeArrayBurst <T> array, int index) where T : struct
 {
     CheckArray(index, array.Length);
     unsafe {
         var ptr = array.GetUnsafePtr();
         #if UNITY_2020_1_OR_NEWER
         return(ref UnsafeUtility.ArrayElementAsRef <T>(ptr, index));
         #else
         throw new Exception("UnsafeUtility.ArrayElementAsRef");
         #endif
     }
 }
Esempio n. 6
0
 public static ref T GetRefRead <T>(this NativeArrayBurst <T> array, int index) where T : struct
 {
     if (index < 0 || index >= array.Length)
     {
         throw new ArgumentOutOfRangeException(nameof(index));
     }
     unsafe {
         var ptr = array.GetUnsafePtr();
         #if UNITY_2020_1_OR_NEWER
         return(ref UnsafeUtility.ArrayElementAsRef <T>(ptr, index));
         #else
         throw new Exception("UnsafeUtility.ArrayElementAsRef");
         #endif
     }
 }
Esempio n. 7
0
 public static void Copy(
     T[] src,
     int srcIndex,
     NativeArrayBurst <T> dst,
     int dstIndex,
     int length)
 {
     #if COLLECTIONS_CHECKS
     AtomicSafetyHandle.CheckWriteAndThrow(dst.m_Safety);
     #endif
     if (src == null)
     {
         throw new ArgumentNullException(nameof(src));
     }
     if (length < 0)
     {
         throw new ArgumentOutOfRangeException(nameof(length), "length must be equal or greater than zero.");
     }
     if (srcIndex < 0 || srcIndex > src.Length || srcIndex == src.Length && (uint)src.Length > 0U)
     {
         throw new ArgumentOutOfRangeException(nameof(srcIndex), "srcIndex is outside the range of valid indexes for the source array.");
     }
     if (dstIndex < 0 || dstIndex > dst.Length || dstIndex == dst.Length && dst.Length > 0)
     {
         throw new ArgumentOutOfRangeException(nameof(dstIndex), "dstIndex is outside the range of valid indexes for the destination NativeArray.");
     }
     if (srcIndex + length > src.Length)
     {
         throw new ArgumentException("length is greater than the number of elements from srcIndex to the end of the source array.", nameof(length));
     }
     if (dstIndex + length > dst.Length)
     {
         throw new ArgumentException("length is greater than the number of elements from dstIndex to the end of the destination NativeArray.", nameof(length));
     }
     var    gcHandle = System.Runtime.InteropServices.GCHandle.Alloc(src, System.Runtime.InteropServices.GCHandleType.Pinned);
     IntPtr num      = gcHandle.AddrOfPinnedObject();
     UnsafeUtility.MemCpy((void *)((IntPtr)dst.m_Buffer + dstIndex * UnsafeUtility.SizeOf <T>()), (void *)((IntPtr)(void *)num + srcIndex * UnsafeUtility.SizeOf <T>()), (long)(length * UnsafeUtility.SizeOf <T>()));
     gcHandle.Free();
 }
Esempio n. 8
0
 public NativeSliceBurst(NativeArrayBurst <T> array, int start) : this(array, start, array.Length - start)
 {
 }
Esempio n. 9
0
 public NativeSliceBurst(NativeArrayBurst <T> array) : this(array, 0, array.Length)
 {
 }
Esempio n. 10
0
 public NativeArrayBurst(int length, Allocator allocator)
 {
     NativeArrayBurst <T> .Allocate(length, allocator, out this);
 }
Esempio n. 11
0
        public NativeArrayBurst(NativeArrayBurst <T> array, Allocator allocator)
        {
            NativeArrayBurst <T> .Allocate(array.Length, allocator, out this);

            NativeArrayUtils.Copy(array, ref this);
        }
Esempio n. 12
0
 public NativeArrayBurstDebugView(NativeArrayBurst <T> array)
 {
     m_Array = array;
 }
Esempio n. 13
0
 public static void Copy(T[] src, NativeArrayBurst <T> dst, int length) => NativeArrayBurst <T> .Copy(src, 0, dst, 0, length);