709 lines
24 KiB
C#
709 lines
24 KiB
C#
using System;
|
|
using System.Text;
|
|
using System.Collections.Generic;
|
|
using UnityEngine;
|
|
using Unity.Collections;
|
|
using Unity.Collections.LowLevel.Unsafe;
|
|
using System.Collections;
|
|
using UnityEngine.Rendering;
|
|
using System.Linq;
|
|
|
|
namespace Obi
|
|
{
|
|
public unsafe class ObiNativeList<T> : IEnumerable<T>, IDisposable, ISerializationCallbackReceiver where T : struct
|
|
{
|
|
public T[] serializedContents;
|
|
protected void* m_AlignedPtr = null;
|
|
|
|
protected int m_Stride;
|
|
protected int m_Capacity;
|
|
protected int m_Count;
|
|
[SerializeField] protected int m_AlignBytes = 16;
|
|
|
|
#if ENABLE_UNITY_COLLECTIONS_CHECKS
|
|
protected AtomicSafetyHandle m_SafetyHandle;
|
|
#endif
|
|
|
|
protected GraphicsBuffer.Target m_ComputeBufferType;
|
|
protected GraphicsBuffer m_ComputeBuffer;
|
|
protected GraphicsBuffer m_CountBuffer; // used to hold the counter value in case m_ComputeBufferType is Counter.
|
|
protected bool computeBufferDirty = false;
|
|
protected AsyncGPUReadbackRequest m_AsyncRequest;
|
|
protected AsyncGPUReadbackRequest m_CounterAsyncRequest;
|
|
|
|
public int count
|
|
{
|
|
set
|
|
{
|
|
if (value != m_Count)
|
|
{
|
|
// we should not use ResizeUninitialized as it would destroy all current data.
|
|
// we first ensure we can hold the previous count, and then set the new one.
|
|
EnsureCapacity(m_Count);
|
|
m_Count = Mathf.Min(m_Capacity, value);
|
|
|
|
if (m_ComputeBuffer != null && m_ComputeBuffer.IsValid() && m_ComputeBufferType == GraphicsBuffer.Target.Counter)
|
|
m_ComputeBuffer.SetCounterValue((uint)m_Count);
|
|
}
|
|
}
|
|
get { return m_Count; }
|
|
}
|
|
|
|
public int capacity
|
|
{
|
|
get { return m_Capacity; }
|
|
}
|
|
|
|
public int stride
|
|
{
|
|
get { return m_Stride; }
|
|
}
|
|
|
|
public bool isCreated
|
|
{
|
|
get { return m_AlignedPtr != null; }
|
|
}
|
|
|
|
public bool noReadbackInFlight
|
|
{
|
|
get { return m_AsyncRequest.done && (m_ComputeBufferType != GraphicsBuffer.Target.Counter || m_CounterAsyncRequest.done); }
|
|
}
|
|
|
|
// Returns the current compute buffer representation of this list. Will return null if AsComputeBuffer() hasn't been called yet,
|
|
// or if the list has been disposed of.
|
|
public GraphicsBuffer computeBuffer
|
|
{
|
|
get { return m_ComputeBuffer; }
|
|
}
|
|
|
|
public T this[int index]
|
|
{
|
|
get
|
|
{
|
|
#if ENABLE_UNITY_COLLECTIONS_CHECKS
|
|
if (index < 0 || index >= m_Capacity)
|
|
{
|
|
throw new IndexOutOfRangeException($"Reading from index {index} is out of range of '{m_Capacity}' Capacity.");
|
|
}
|
|
#endif
|
|
return UnsafeUtility.ReadArrayElementWithStride<T>(m_AlignedPtr, index, m_Stride);
|
|
}
|
|
set
|
|
{
|
|
#if ENABLE_UNITY_COLLECTIONS_CHECKS
|
|
if (index < 0 || index >= m_Capacity)
|
|
{
|
|
throw new IndexOutOfRangeException($"Writing to index {index} is out of range of '{m_Capacity}' Capacity.");
|
|
}
|
|
#endif
|
|
UnsafeUtility.WriteArrayElementWithStride<T>(m_AlignedPtr, index, m_Stride, value);
|
|
computeBufferDirty = true;
|
|
}
|
|
}
|
|
|
|
// Declare parameterless constructor, called by Unity upon deserialization.
|
|
protected ObiNativeList()
|
|
{
|
|
m_Stride = UnsafeUtility.SizeOf<T>();
|
|
|
|
#if ENABLE_UNITY_COLLECTIONS_CHECKS
|
|
m_SafetyHandle = AtomicSafetyHandle.Create();
|
|
#endif
|
|
}
|
|
|
|
public ObiNativeList(int capacity = 8, int alignment = 16)
|
|
{
|
|
m_Stride = UnsafeUtility.SizeOf<T>();
|
|
|
|
#if ENABLE_UNITY_COLLECTIONS_CHECKS
|
|
m_SafetyHandle = AtomicSafetyHandle.Create();
|
|
#endif
|
|
m_AlignBytes = alignment;
|
|
ChangeCapacity(capacity);
|
|
}
|
|
|
|
~ObiNativeList()
|
|
{
|
|
Dispose(false);
|
|
}
|
|
|
|
protected void Dispose(bool disposing)
|
|
{
|
|
DisposeOfComputeBuffer();
|
|
|
|
if (isCreated)
|
|
{
|
|
// free unmanaged memory buffer:
|
|
UnsafeUtility.Free(m_AlignedPtr, Allocator.Persistent);
|
|
m_AlignedPtr = null;
|
|
m_Count = m_Capacity = 0;
|
|
|
|
#if ENABLE_UNITY_COLLECTIONS_CHECKS
|
|
// dispose of atomic safety handle:
|
|
AtomicSafetyHandle.CheckDeallocateAndThrow(m_SafetyHandle);
|
|
AtomicSafetyHandle.Release(m_SafetyHandle);
|
|
#endif
|
|
}
|
|
}
|
|
|
|
public void Dispose()
|
|
{
|
|
Dispose(true);
|
|
}
|
|
|
|
public void DisposeOfComputeBuffer()
|
|
{
|
|
// dispose of compute buffer representation:
|
|
if (m_ComputeBuffer != null)
|
|
{
|
|
// if there's any pending async readback, finalize it.
|
|
// otherwise we pull the rug from under the readbacks' feet and that's no good.
|
|
WaitForReadback();
|
|
|
|
m_ComputeBuffer.Dispose();
|
|
m_ComputeBuffer = null;
|
|
}
|
|
|
|
if (m_CountBuffer != null)
|
|
{
|
|
m_CountBuffer.Dispose();
|
|
m_CountBuffer = null;
|
|
}
|
|
}
|
|
|
|
public void OnBeforeSerialize()
|
|
{
|
|
if (isCreated)
|
|
{
|
|
// create a new managed array to serialize the data:
|
|
serializedContents = new T[m_Count];
|
|
|
|
// pin the managed array and get its address:
|
|
ulong serializedContentsHandle;
|
|
var serializedContentsAddress = UnsafeUtility.PinGCArrayAndGetDataAddress(serializedContents, out serializedContentsHandle);
|
|
|
|
// copy data over to the managed array:
|
|
UnsafeUtility.MemCpy(serializedContentsAddress, m_AlignedPtr, m_Count * m_Stride);
|
|
|
|
// unpin the managed array:
|
|
UnsafeUtility.ReleaseGCObject(serializedContentsHandle);
|
|
}
|
|
}
|
|
|
|
public void OnAfterDeserialize()
|
|
{
|
|
if (serializedContents != null)
|
|
{
|
|
// resize to receive the serialized data:
|
|
ResizeUninitialized(serializedContents.Length);
|
|
|
|
// pin the managed array and get its address:
|
|
ulong serializedContentsHandle;
|
|
var serializedContentsAddress = UnsafeUtility.PinGCArrayAndGetDataAddress(serializedContents, out serializedContentsHandle);
|
|
|
|
// copy data from the managed array:
|
|
UnsafeUtility.MemCpy(m_AlignedPtr, serializedContentsAddress, m_Count * m_Stride);
|
|
|
|
// unpin the managed array:
|
|
UnsafeUtility.ReleaseGCObject(serializedContentsHandle);
|
|
}
|
|
}
|
|
|
|
// Reinterprets the data in the list as a native array.
|
|
public NativeArray<U> AsNativeArray<U>() where U : struct
|
|
{
|
|
return AsNativeArray<U>(m_Count);
|
|
}
|
|
|
|
public NativeArray<T> AsNativeArray()
|
|
{
|
|
return AsNativeArray<T>(m_Count);
|
|
}
|
|
|
|
// Reinterprets the data in the list as a native array of the given length, up to the list's capacity.
|
|
public NativeArray<U> AsNativeArray<U>(int arrayLength) where U : struct
|
|
{
|
|
unsafe
|
|
{
|
|
NativeArray<U> array = NativeArrayUnsafeUtility.ConvertExistingDataToNativeArray<U>(m_AlignedPtr, Mathf.Min(arrayLength, m_Capacity), Allocator.None);
|
|
|
|
#if ENABLE_UNITY_COLLECTIONS_CHECKS
|
|
NativeArrayUnsafeUtility.SetAtomicSafetyHandle(ref array, m_SafetyHandle);
|
|
#endif
|
|
// assume the NativeArray will write new data, so we'll need to update the computeBuffer upon Upload().
|
|
computeBufferDirty = true;
|
|
return array;
|
|
}
|
|
}
|
|
|
|
// Reinterprets the data in the list as a compute buffer, in case of an empty list it returns a buffer of size 1 with uninitialized content.
|
|
public GraphicsBuffer SafeAsComputeBuffer<U>(GraphicsBuffer.Target bufferType = GraphicsBuffer.Target.Structured) where U : struct
|
|
{
|
|
return AsComputeBuffer<U>(Mathf.Max(1,m_Count), bufferType);
|
|
}
|
|
|
|
// Reinterprets the data in the list as a compute buffer.
|
|
public GraphicsBuffer AsComputeBuffer<U>(GraphicsBuffer.Target bufferType = GraphicsBuffer.Target.Structured) where U : struct
|
|
{
|
|
return AsComputeBuffer<U>(m_Count, bufferType);
|
|
}
|
|
|
|
// Reinterprets the data in the list as a compute buffer of the given length. Returns null if the list is empty.
|
|
public GraphicsBuffer AsComputeBuffer<U>(int arrayLength, GraphicsBuffer.Target bufferType = GraphicsBuffer.Target.Structured) where U : struct
|
|
{
|
|
DisposeOfComputeBuffer();
|
|
|
|
if (arrayLength > 0)
|
|
{
|
|
m_ComputeBufferType = bufferType;
|
|
m_ComputeBuffer = new GraphicsBuffer(bufferType, arrayLength, UnsafeUtility.SizeOf<U>());
|
|
m_ComputeBuffer.SetData(AsNativeArray<U>(arrayLength));
|
|
|
|
if (bufferType == GraphicsBuffer.Target.Counter)
|
|
{
|
|
// initialize count to zero, since counter buffers always start empty:
|
|
m_Count = 0;
|
|
m_ComputeBuffer.SetCounterValue((uint)m_Count);
|
|
m_CountBuffer = new GraphicsBuffer(GraphicsBuffer.Target.IndirectArguments, 1, 4);
|
|
GraphicsBuffer.CopyCount(m_ComputeBuffer, m_CountBuffer, 0);
|
|
}
|
|
|
|
return m_ComputeBuffer;
|
|
}
|
|
return null;
|
|
}
|
|
|
|
// Kicks a GPU readback request, to bring compute buffer data to this list.
|
|
public void Readback<U>(int readcount, bool async) where U : struct
|
|
{
|
|
if (m_ComputeBuffer != null && m_ComputeBuffer.IsValid() && noReadbackInFlight)
|
|
{
|
|
var nativeArray = AsNativeArray<U>(readcount);
|
|
|
|
// When using SafeAsComputeBuffer, we'll get a compute buffer of size 1 even if the list (and the NativeArray) is empty.
|
|
// Guard against trying to readback into a smaller NativeArray. Also guard against requesting zero items.
|
|
if (nativeArray.Length >= readcount && readcount > 0)
|
|
m_AsyncRequest = AsyncGPUReadback.RequestIntoNativeArray(ref nativeArray, m_ComputeBuffer, readcount * UnsafeUtility.SizeOf<U>(), 0);
|
|
|
|
// For counter buffers, request the counter value too:
|
|
if (m_ComputeBufferType == GraphicsBuffer.Target.Counter)
|
|
{
|
|
GraphicsBuffer.CopyCount(m_ComputeBuffer, m_CountBuffer, 0);
|
|
m_CounterAsyncRequest = AsyncGPUReadback.Request(m_CountBuffer, m_CountBuffer.stride, 0, (AsyncGPUReadbackRequest request)=>
|
|
{
|
|
if (!request.hasError)
|
|
m_Count = Mathf.Min(m_Capacity, request.GetData<int>()[0]);
|
|
});
|
|
}
|
|
|
|
if (!async)
|
|
WaitForReadback();
|
|
}
|
|
}
|
|
|
|
public void Readback(bool async = true)
|
|
{
|
|
// On counter buffers, we shouldn't read data up to m_Count and then update m_Count with the compute buffer's counter value *afterwards*.
|
|
// This would lead to reading back less data than we should, so we need to request the entire compute buffer.
|
|
if (m_ComputeBuffer != null)
|
|
Readback<T>(m_ComputeBuffer.count, async);
|
|
}
|
|
|
|
public void Readback(int readcount ,bool async = true)
|
|
{
|
|
Readback<T>(readcount, async);
|
|
}
|
|
|
|
// Makes sure any pending changes by the CPU are sent to the GPU.
|
|
// If the list data has been changed on the CPU since the last time Unmap() was called and there's a compute buffer associated to it,
|
|
// will write the current contents of the list to the compute buffer.
|
|
public void Upload<U>(int length, bool force = false) where U : struct
|
|
{
|
|
if ((computeBufferDirty || force) && m_ComputeBuffer != null && m_ComputeBuffer.IsValid())
|
|
m_ComputeBuffer.SetData(AsNativeArray<U>(length));
|
|
|
|
computeBufferDirty = false;
|
|
}
|
|
|
|
public void Upload(bool force = false)
|
|
{
|
|
Upload<T>(m_Count,force);
|
|
}
|
|
|
|
public void UploadFullCapacity()
|
|
{
|
|
Upload<T>(m_Capacity, true);
|
|
}
|
|
|
|
// Waits for the last readback request to be complete, this brings back data from the GPU to the CPU:
|
|
public void WaitForReadback()
|
|
{
|
|
if (isCreated)
|
|
{
|
|
m_AsyncRequest.WaitForCompletion();
|
|
m_CounterAsyncRequest.WaitForCompletion();
|
|
}
|
|
}
|
|
|
|
protected void ChangeCapacity(int newCapacity)
|
|
{
|
|
// invalidate compute buffer:
|
|
DisposeOfComputeBuffer();
|
|
|
|
// allocate a new buffer:
|
|
m_Stride = UnsafeUtility.SizeOf<T>();
|
|
var newAlignedPtr = UnsafeUtility.Malloc(newCapacity * m_Stride, m_AlignBytes, Allocator.Persistent);
|
|
|
|
// if there was a previous allocation:
|
|
if (isCreated)
|
|
{
|
|
// copy contents from previous memory region
|
|
unsafe
|
|
{
|
|
UnsafeUtility.MemCpy(newAlignedPtr, m_AlignedPtr, Mathf.Min(newCapacity, m_Capacity) * m_Stride);
|
|
}
|
|
|
|
// free previous memory region
|
|
UnsafeUtility.Free(m_AlignedPtr, Allocator.Persistent);
|
|
}
|
|
|
|
// get hold of new pointers/capacity.
|
|
m_AlignedPtr = newAlignedPtr;
|
|
m_Capacity = newCapacity;
|
|
}
|
|
|
|
public bool Compare(ObiNativeList<T> other)
|
|
{
|
|
if (other == null || !isCreated || !other.isCreated)
|
|
throw new ArgumentNullException();
|
|
|
|
if (m_Count != other.m_Count)
|
|
return false;
|
|
|
|
return UnsafeUtility.MemCmp(m_AlignedPtr, other.m_AlignedPtr, m_Count * m_Stride) == 0;
|
|
}
|
|
|
|
public void CopyFrom(ObiNativeList<T> source)
|
|
{
|
|
if (source == null || !isCreated || !source.isCreated)
|
|
throw new ArgumentNullException();
|
|
|
|
if (m_Count < source.m_Count)
|
|
throw new ArgumentOutOfRangeException();
|
|
|
|
UnsafeUtility.MemCpy(m_AlignedPtr, source.m_AlignedPtr, source.count * m_Stride);
|
|
}
|
|
|
|
public void CopyFrom(ObiNativeList<T> source, int sourceIndex, int destIndex, int length)
|
|
{
|
|
if (source == null || !isCreated || !source.isCreated)
|
|
throw new ArgumentNullException();
|
|
|
|
if (length <= 0 || source.m_Count == 0)
|
|
return;
|
|
|
|
if (sourceIndex >= source.m_Count || sourceIndex < 0 || destIndex >= m_Count || destIndex < 0 ||
|
|
sourceIndex + length > source.m_Count || destIndex + length > m_Count)
|
|
throw new ArgumentOutOfRangeException();
|
|
|
|
void* sourceAddress = source.AddressOfElement(sourceIndex);
|
|
void* destAddress = AddressOfElement(destIndex);
|
|
UnsafeUtility.MemCpy(destAddress, sourceAddress, length * m_Stride);
|
|
}
|
|
|
|
public void CopyFrom<U>(NativeArray<U> source, int sourceIndex, int destIndex, int length) where U : struct
|
|
{
|
|
if (!isCreated || !source.IsCreated || UnsafeUtility.SizeOf<U>() != m_Stride)
|
|
throw new ArgumentNullException();
|
|
|
|
if (length <= 0 || source.Length == 0)
|
|
return;
|
|
|
|
if (sourceIndex >= source.Length || sourceIndex < 0 || destIndex >= m_Count || destIndex < 0 ||
|
|
sourceIndex + length > source.Length || destIndex + length > m_Count)
|
|
throw new ArgumentOutOfRangeException();
|
|
|
|
void* sourceAddress = (byte*)source.GetUnsafePtr() + sourceIndex * m_Stride;
|
|
void* destAddress = AddressOfElement(destIndex);
|
|
UnsafeUtility.MemCpy(destAddress, sourceAddress, length * m_Stride);
|
|
}
|
|
|
|
public void CopyFrom(T[] source, int sourceIndex, int destIndex, int length)
|
|
{
|
|
if (source == null || !isCreated)
|
|
throw new ArgumentNullException();
|
|
|
|
if (length <= 0 || source.Length == 0)
|
|
return;
|
|
|
|
if (sourceIndex < 0 || destIndex < 0 ||
|
|
sourceIndex + length > source.Length || destIndex + length > m_Count)
|
|
throw new ArgumentOutOfRangeException();
|
|
|
|
// pin the managed array and get its address:
|
|
ulong sourceHandle;
|
|
void* sourceAddress = UnsafeUtility.PinGCArrayAndGetDataAddress(source, out sourceHandle);
|
|
void* destAddress = UnsafeUtility.AddressOf(ref UnsafeUtility.ArrayElementAsRef<T>(m_AlignedPtr, destIndex));
|
|
UnsafeUtility.MemCpy(destAddress, sourceAddress, length * m_Stride);
|
|
|
|
// unpin the managed array:
|
|
UnsafeUtility.ReleaseGCObject(sourceHandle);
|
|
}
|
|
|
|
public void CopyReplicate(T value, int destIndex, int length)
|
|
{
|
|
if (length <= 0) return;
|
|
|
|
if (!isCreated)
|
|
throw new ArgumentNullException();
|
|
|
|
if (destIndex >= m_Count || destIndex < 0 || destIndex + length > m_Count)
|
|
throw new ArgumentOutOfRangeException();
|
|
|
|
void* sourceAddress = UnsafeUtility.AddressOf(ref value);
|
|
void* destAddress = AddressOfElement(destIndex);
|
|
UnsafeUtility.MemCpyReplicate(destAddress, sourceAddress, m_Stride, length);
|
|
}
|
|
|
|
public void CopyTo(T[] dest, int sourceIndex, int length)
|
|
{
|
|
if (length <= 0) return;
|
|
|
|
if (dest == null || !isCreated)
|
|
throw new ArgumentNullException();
|
|
|
|
if (sourceIndex < 0 || sourceIndex >= m_Count || sourceIndex + length > m_Count || length > dest.Length)
|
|
throw new ArgumentOutOfRangeException();
|
|
|
|
ulong destHandle;
|
|
void* sourceAddress = AddressOfElement(sourceIndex);
|
|
void* destAddress = UnsafeUtility.PinGCArrayAndGetDataAddress(dest, out destHandle);
|
|
UnsafeUtility.MemCpy(destAddress, sourceAddress, length * m_Stride);
|
|
|
|
UnsafeUtility.ReleaseGCObject(destHandle);
|
|
}
|
|
|
|
public void Clear()
|
|
{
|
|
m_Count = 0;
|
|
}
|
|
|
|
public void Add(T item)
|
|
{
|
|
EnsureCapacity(m_Count + 1);
|
|
computeBufferDirty = true;
|
|
this[m_Count++] = item;
|
|
}
|
|
|
|
public void AddReplicate(T value, int times)
|
|
{
|
|
int appendAt = m_Count;
|
|
ResizeUninitialized(m_Count + times);
|
|
CopyReplicate(value, appendAt, times);
|
|
}
|
|
|
|
public void AddRange(T[] array)
|
|
{
|
|
AddRange(array, array.Length);
|
|
}
|
|
|
|
public void AddRange(T[] array, int length)
|
|
{
|
|
AddRange(array, 0, length);
|
|
}
|
|
|
|
public void AddRange(T[] array, int start, int length)
|
|
{
|
|
int appendAt = m_Count;
|
|
ResizeUninitialized(m_Count + length);
|
|
CopyFrom(array, start, appendAt, length);
|
|
}
|
|
|
|
public void AddRange(ObiNativeList<T> array, int length)
|
|
{
|
|
int appendAt = m_Count;
|
|
ResizeUninitialized(m_Count + length);
|
|
CopyFrom(array, 0, appendAt, length);
|
|
}
|
|
|
|
public void AddRange(ObiNativeList<T> array, int start, int length)
|
|
{
|
|
int appendAt = m_Count;
|
|
ResizeUninitialized(m_Count + length);
|
|
CopyFrom(array, start, appendAt, length);
|
|
}
|
|
|
|
public void AddRange(ObiNativeList<T> array)
|
|
{
|
|
AddRange(array, array.count);
|
|
}
|
|
|
|
public void AddRange(IEnumerable<T> enumerable)
|
|
{
|
|
ICollection<T> collection = enumerable as ICollection<T>;
|
|
if (collection != null && collection.Count > 0)
|
|
{
|
|
EnsureCapacity(m_Count + collection.Count);
|
|
}
|
|
|
|
using (IEnumerator<T> enumerator = enumerable.GetEnumerator())
|
|
{
|
|
while (enumerator.MoveNext())
|
|
{
|
|
Add(enumerator.Current);
|
|
}
|
|
}
|
|
}
|
|
|
|
public void RemoveRange(int index, int count)
|
|
{
|
|
if (index < 0 || count < 0 || index + count > m_Count)
|
|
throw new ArgumentOutOfRangeException();
|
|
|
|
for (int i = index; i < m_Count - count; ++i)
|
|
this[i] = this[i + count];
|
|
|
|
m_Count -= count;
|
|
}
|
|
|
|
public void RemoveAt(int index)
|
|
{
|
|
if (index < 0 || index >= count)
|
|
throw new ArgumentOutOfRangeException();
|
|
|
|
for (int i = index; i < m_Count - 1; ++i)
|
|
this[i] = this[i + 1];
|
|
|
|
m_Count--;
|
|
}
|
|
|
|
/**
|
|
* Ensures a minimal capacity of count elements, then sets the new count. Useful when passing the backing array to C++
|
|
* for being filled with new data.
|
|
*/
|
|
public bool ResizeUninitialized(int newCount)
|
|
{
|
|
newCount = Mathf.Max(0, newCount);
|
|
bool realloc = EnsureCapacity(newCount);
|
|
|
|
m_Count = newCount;
|
|
|
|
return realloc;
|
|
}
|
|
|
|
public bool ResizeInitialized(int newCount, T value = default(T))
|
|
{
|
|
newCount = Mathf.Max(0, newCount);
|
|
|
|
bool initialize = newCount >= m_Capacity || !isCreated;
|
|
bool realloc = EnsureCapacity(newCount);
|
|
|
|
if (initialize)
|
|
{
|
|
void* sourceAddress = UnsafeUtility.AddressOf(ref value);
|
|
void* destAddress = AddressOfElement(m_Count);
|
|
UnsafeUtility.MemCpyReplicate(destAddress, sourceAddress, m_Stride, m_Capacity - m_Count);
|
|
}
|
|
|
|
m_Count = newCount;
|
|
|
|
return realloc;
|
|
}
|
|
|
|
public bool EnsureCapacity(int min)
|
|
{
|
|
if (min >= m_Capacity || !isCreated)
|
|
{
|
|
ChangeCapacity(min * 2);
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
public void WipeToZero()
|
|
{
|
|
unsafe
|
|
{
|
|
if (isCreated)
|
|
{
|
|
UnsafeUtility.MemClear(m_AlignedPtr, count * m_Stride);
|
|
|
|
computeBufferDirty = true;
|
|
}
|
|
}
|
|
}
|
|
|
|
public void WipeToValue(T value)
|
|
{
|
|
unsafe
|
|
{
|
|
if (isCreated)
|
|
{
|
|
void* sourceAddress = UnsafeUtility.AddressOf(ref value);
|
|
UnsafeUtility.MemCpyReplicate(m_AlignedPtr, sourceAddress, m_Stride, count);
|
|
|
|
computeBufferDirty = true;
|
|
}
|
|
}
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder sb = new StringBuilder();
|
|
sb.Append('[');
|
|
|
|
for (int t = 0; t < m_Count; t++)
|
|
{
|
|
sb.Append(this[t].ToString());
|
|
|
|
if (t < (m_Count - 1)) sb.Append(',');
|
|
|
|
}
|
|
sb.Append(']');
|
|
return sb.ToString();
|
|
}
|
|
|
|
public void* AddressOfElement(int index)
|
|
{
|
|
return (void*) ((byte*)m_AlignedPtr + m_Stride * index);
|
|
}
|
|
|
|
public NativeReference<int> GetCountReference(Allocator alloc)
|
|
{
|
|
return new NativeReference<int>(m_Count, alloc);
|
|
}
|
|
|
|
public IntPtr GetIntPtr()
|
|
{
|
|
if (isCreated)
|
|
return new IntPtr(m_AlignedPtr);
|
|
return IntPtr.Zero;
|
|
}
|
|
|
|
public void Swap(int index1, int index2)
|
|
{
|
|
// check to avoid out of bounds access:
|
|
if (index1 >= 0 && index1 < count && index2 >= 0 && index2 < count)
|
|
{
|
|
var aux = this[index1];
|
|
this[index1] = this[index2];
|
|
this[index2] = aux;
|
|
}
|
|
}
|
|
|
|
public IEnumerator<T> GetEnumerator()
|
|
{
|
|
for (int i = 0; i < count; ++i)
|
|
{
|
|
yield return this[i];
|
|
}
|
|
}
|
|
|
|
IEnumerator IEnumerable.GetEnumerator()
|
|
{
|
|
return this.GetEnumerator();
|
|
}
|
|
}
|
|
}
|
|
|