【Unity】NativeArrayを使いこなせ

[NativeHeader("Configuration/UnityConfigure.h")]
[NativeHeader("Runtime/Transform/Transform.h")]
[NativeHeader("Runtime/Transform/ScriptBindings/TransformScriptBindings.h")]
[RequiredByNativeCode]
public partial class Transform : Component, IEnumerable
{
    protected Transform() { }

    // The position of the transform in world space.
    public extern Vector3 position { get; set; }

    // Position of the transform relative to the parent transform.
    public extern Vector3 localPosition { get; set; }

    // Get local euler angles with rotation order specified
    internal extern Vector3 GetLocalEulerAngles(RotationOrder order);

    // Set local euler angles with rotation order specified
    internal extern void SetLocalEulerAngles(Vector3 euler, RotationOrder order);

    ...
}

using Unity.Collections;
using UnityEngine;

public class NativeArrayExample : MonoBehaviour
{
    void Start()
    {
        // NativeArrayを生成、アンマネージド領域にメモリを確保する
        NativeArray<int> array1 = new NativeArray<int>(10, Allocator.Temp);

        // 通常の配列のように使用できる
        for (int i = 0; i < array1.Length; i++)
        {
            // 適当に値を代入するだけ
            array1[i] = 10;
        }

        // 構造体なのでコピーされているように見えるが...?
        NativeArray<int> array2 = array1;

        // array2を書き換える
        for (int i = 0; i < array2.Length; i++)
        {
            array2[i] = 0;
        }

        // array1を読み取る
        for (int i = 0; i < array1.Length; i++)
        {
            // 書き換えたのはarray2のはずが、0が表示される！
            // これはNativeArrayが単なるメモリの参照(ポインタ)に過ぎないため
            Debug.Log(array1[i]);
        }

        // 使い終わったら "必ず" Dispose()を呼び出して破棄する
        // これを忘れるとメモリリークするので注意
        array1.Dispose();

        // array2はarray1と同じメモリを指しているため、こちらをDisposeする必要はない
    }
}

var array = new NativeArray<byte>(100, Allocator.Temp);

// NativeArrayをSpanに変換
Span<byte> span = array.AsSpan();

// NativeArrayをReadOnlySpanに変換
ReadOnlySpan<byte> readonlySpan = array.AsReadOnlySpan();

using System;
using Unity.Collections;

public struct ExampleStruct
{
    // AllocatorHelperを介してカスタムAllocatorを使用する
    AllocatorHelper<RewindableAllocator> rwdAllocatorHelper;

    // AllocatorHelper内のAllocatorにrefでアクセスするためのプロパティ
    public ref RewindableAllocator RwdAllocator => ref rwdAllocatorHelper.Allocator;

    // RewindableAllocatorを作成するサンプル
    void CreateRewindableAllocator(AllocatorManager.AllocatorHandle backgroundAllocator, int initialBlockSize, bool enableBlockFree = false)
    {
        // backgroundAllocatorから新たなRewindableAllocatorを作成し、AllocatorManagerに登録する
        rwdAllocatorHelper = new AllocatorHelper<RewindableAllocator>(backgroundAllocator);

        // メモリブロックを割り当て、Allocatorを有効化する
        RwdAllocator.Initialize(initialBlockSize, enableBlockFree);
    }

    // RewindableAllocatorを用いてメモリ確保を行うサンプル
    public unsafe void UseRewindableAllocator(out NativeArray<int> nativeArray, out NativeList<int> nativeList, out byte* bytePtr)
    {
        // RewindableAllocatorを用いてNativeArrayを作成する
        // RewindableAllocatorでまとめてメモリの解放を行うため、このNativeArrayをDisposeする必要はない
        var nativeArray = CollectionHelper.CreateNativeArray<int, RewindableAllocator>(100, ref RwdAllocator);

        // RewindableAllocatorを用いてNativeListを作成する
        var nativeList = new NativeList<int>(RwdAllocator.Handle);
        for (int i = 0; i < 50; i++)
        {
            nativeList.Add(i);
        }

        // RewindableAllocatorを用いてメモリの確保を行う
        var bytePtr = (byte*)AllocatorManager.Allocate(ref RwdAllocator, sizeof(byte), sizeof(byte), 10);
    }

    // RewindableAllocatorで確保したメモリを解放する
    public void FreeRewindableAllocator()
    {
        // 確保したメモリを全て解放する (RwdAllocatorは引き続き使用可能)
        RwdAllocator.Rewind();
    }

    // RewindableAllocatorを破棄する
    void DisposeRewindableAllocator()
    {
        // 確保したメモリを解放し、Allocatorを破棄する
        RwdAllocator.Dispose();
        // AlloatorManagerから登録を解除し、AllocatorHelperを破棄する
        rwdAllocatorHelper.Dispose();
    }
}

using Unity.Collections.LowLevel.Unsafe;

// 必要なメモリのサイズを取得
int size = UnsafeUtility.SizeOf<int>();
// メモリアライメントを取得
int alignment = UnsafeUtility.AlignOf<int>();

// Mallocでメモリを確保する
void* ptr = UnsafeUtility.Malloc(size, alignment, Allocator.Persistent);
// Freeで確保したメモリの解放を行う
UnsafeUtility.Free(ptr, Allocator.Persistent);

int size = UnsafeUtility.SizeOf<int>();
int alignment = UnsafeUtility.AlignOf<int>();

// MallocTrackedで、リークの追跡を有効化してメモリを確保する
void* ptr = UnsafeUtility.MallocTracked(size, alignment, Allocator.Persistent, 1);
// FreeTrackedで追跡中のメモリの解放を行う
UnsafeUtility.FreeTracked(ptr, Allocator.Persistent);

using Unity.Collections;
using Unity.Collections.LowLevel.Unsafe;

var nativeArray = new NativeArray<int>(10, Allocator.Temp);

using Unity.Collections;
using Unity.Collections.LowLevel.Unsafe;

var nativeArray = new NativeArray(10, Allocator.Temp);

// 内部のポインタを取得できる
var ptr = nativeArray.GetUnsafePtr();

// 既存のポインタをNativeArrayに変換 (AllocatorにはNoneを指定する)
var array = NativeArrayUnsafeUtility.ConvertExistingDataToNativeArray<byte>(
    ptr,
    array.Length,
    Allocator.None
);

#if ENABLE_UNITY_COLLECTIONS_CHECKS
// 安全性チェック用のAtomicSafetyHandleを設定する
NativeArrayUnsafeUtility.SetAtomicSafetyHandle(ref array, AtomicSafetyHandle.GetTempMemoryHandle());
#endif

using System;
using System.Diagnostics;
using Unity.Burst;
using Unity.Collections.LowLevel.Unsafe;
using Unity.Collections;

// NativeContainerであることを示す属性を付加
[NativeContainer]
// これは主にJobSystem用に設定される属性で、IJobParallelFor内でアクセスできるindex範囲を制限できるようになる (細かい説明は後ほど)
[NativeContainerSupportsMinMaxWriteRestriction]
// デバッガ用のクラスを指定。Visual Studio等のツールで中身を確認できるようになるため、これもセットで実装する
[DebuggerDisplay("Length = {Length}")]
[DebuggerTypeProxy(typeof(NativeCustomArrayDebugView<>))]
public unsafe struct NativeCustomArray<T> : IDisposable where T : unmanaged
{
    // ポインタと長さを保持するフィールド
    [NativeDisableUnsafePtrRestriction] internal void* m_Buffer;
    internal int m_Length;

    // 安全性チェック用のフィールド、実行時には含まれない
#if ENABLE_UNITY_COLLECTIONS_CHECKS

    // [NativeContainerSupportsMinMaxWriteRestriction]属性用のフィールド
    // フィールド名は必ず「m_MinIndex」「m_MaxIndex」である必要がある
    internal int m_MinIndex;
    internal int m_MaxIndex;

    // 安全機構として用いるAtomicSafetyHandle。こちらも名前は「m_Safety」から変更してはいけない
    internal AtomicSafetyHandle m_Safety;

    // デバッガが型の判別に用いるID、BurstがアクセスできるようにSharedStatic<int>で定義する
    internal static readonly SharedStatic<int> s_staticSafetyId = SharedStatic<int>.GetOrCreate<NativeCustomArray<T>>();

#endif

    // メモリ確保に使用したAllocatorを保持する、これも名前は「m_AllocatorLabel」で
    internal Allocator m_AllocatorLabel;

    public NativeCustomArray(int length, Allocator allocator)
    {
        // メモリサイズを取得
        long totalSize = UnsafeUtility.SizeOf<T>() * length;

#if ENABLE_UNITY_COLLECTIONS_CHECKS
        // 不正なAllocatorが指定されたら例外をスロー
        if (allocator <= Allocator.None) throw new ArgumentException("Allocator must be Temp, TempJob or Persistent", "allocator");
        
        // lengthのチェック
        if (length < 0) throw new ArgumentOutOfRangeException("length", "Length must be >= 0");
#endif

        // MallocTrackedで新たにメモリを確保する
        m_Buffer = UnsafeUtility.MallocTracked(totalSize, UnsafeUtility.AlignOf<T>(), allocator, 0);
        UnsafeUtility.MemClear(m_Buffer, totalSize);

        m_Length = length;
        m_AllocatorLabel = allocator;

#if ENABLE_UNITY_COLLECTIONS_CHECKS
        m_MinIndex = 0;
        m_MaxIndex = length - 1;

        // 新たなAtomicSafetyHandleを作成し、StaticSafetyIdを設定
        m_Safety = CollectionHelper.CreateSafetyHandle(allocator);
        CollectionHelper.SetStaticSafetyId<NativeCustomArray<T>>(ref m_Safety, ref s_staticSafetyId.Data);
#endif
    }

    public int Length { get { return m_Length; } }

    public unsafe T this[int index]
    {
        get
        {
#if ENABLE_UNITY_COLLECTIONS_CHECKS
            // 読み取りが可能かをチェック
            // すでにメモリが解放されている、またはJobによるアクセスがある場合は例外をスロー
            AtomicSafetyHandle.CheckReadAndThrow(m_Safety);

            // indexの境界チェック
            if (index < m_MinIndex || index > m_MaxIndex) FailOutOfRangeError(index);
#endif
            // ネイティブメモリから配列の値を読み取る
            return UnsafeUtility.ReadArrayElement<T>(m_Buffer, index);
        }

        set
        {
#if ENABLE_UNITY_COLLECTIONS_CHECKS
            // 書き込みが可能かをチェック
            // すでにメモリが解放されている、またはJobによるアクセスがある場合は例外をスロー
            AtomicSafetyHandle.CheckWriteAndThrow(m_Safety);

            // indexの境界チェック
            if (index < m_MinIndex || index > m_MaxIndex)  FailOutOfRangeError(index);
#endif
            // ネイティブメモリに配列の値を書き込む
            UnsafeUtility.WriteArrayElement(m_Buffer, index, value);
        }
    }

    public T[] ToArray()
    {
#if ENABLE_UNITY_COLLECTIONS_CHECKS
        AtomicSafetyHandle.CheckReadAndThrow(m_Safety);
#endif

        var array = new T[Length];
        for (var i = 0; i < Length; i++)
            array[i] = UnsafeUtility.ReadArrayElement<T>(m_Buffer, i);
        return array;
    }

    public bool IsCreated
    {
        get { return m_Buffer != null; }
    }

    public void Dispose()
    {
#if ENABLE_UNITY_COLLECTIONS_CHECKS
        // 不要になったAtomicSafetyHandleを破棄
        // すでに破棄されている場合は例外をスロー
        CollectionHelper.DisposeSafetyHandle(ref m_Safety);
#endif

        // 確保したメモリを解放する
        UnsafeUtility.FreeTracked(m_Buffer, m_AllocatorLabel);
        m_Buffer = null;
        m_Length = 0;
    }

#if ENABLE_UNITY_COLLECTIONS_CHECKS
    private void FailOutOfRangeError(int index)
    {
        // IJobParallelForが不正な範囲にアクセスしたら例外をスローする
        if (index < Length && (m_MinIndex != 0 || m_MaxIndex != Length - 1))
            throw new IndexOutOfRangeException(string.Format(
                "Index {0} is out of restricted IJobParallelFor range [{1}...{2}] in ReadWriteBuffer.\n" +
                "ReadWriteBuffers are restricted to only read & write the element at the job index. " +
                "You can use double buffering strategies to avoid race conditions due to " +
                "reading & writing in parallel to the same elements from a job.",
                index, m_MinIndex, m_MaxIndex));

        throw new IndexOutOfRangeException(string.Format("Index {0} is out of range of '{1}' Length.", index, Length));
    }

#endif
}

// デバッガ用のクラス
internal sealed class NativeCustomArrayDebugView<T> where T : unmanaged
{
    private NativeCustomArray<T> m_Array;

    public NativeCustomArrayDebugView(NativeCustomArray<T> array)
    {
        m_Array = array;
    }

    public T[] Items
    {
        get { return m_Array.ToArray(); }
    }
}

// NativeContainerであることを示す属性を付加
[NativeContainer]
// これは主にJobSystem用に設定される属性で、IJobParallelFor内でアクセスできるindex範囲を制限できるようになる (細かい説明は後ほど)
[NativeContainerSupportsMinMaxWriteRestriction]
// デバッガ用のクラスを指定。Visual Studio等のツールで中身を確認できるようになるため、これもセットで実装する
[DebuggerDisplay("Length = {Length}")]
[DebuggerTypeProxy(typeof(NativeCustomArrayDebugView<>))]
public unsafe struct NativeCustomArray<T> : IDisposable where T : unmanaged
{
   ...
}

[NativeDisableUnsafePtrRestriction] internal void* m_Buffer;

// MallocTrackedで新たにメモリを確保する
m_Buffer = UnsafeUtility.MallocTracked(totalSize, UnsafeUtility.AlignOf<T>(), allocator, 0);
UnsafeUtility.MemClear(m_Buffer, totalSize);

// 安全機構として用いるAtomicSafetyHandle。名前は「m_Safety」から変更してはいけない
internal AtomicSafetyHandle m_Safety;

// デバッガが型の判別に用いるID、BurstがアクセスできるようにSharedStatic<int>で定義する
internal static readonly SharedStatic<int> s_staticSafetyId = SharedStatic<int>.GetOrCreate<NativeCustomArray<T>>();

// AtomicSafetyHandle.Create()で新たなAtomicSafetyHandleを作成する
m_Safety = AtomicSafetyHandle.Create();

// Allocator.Tempでメモリ確保した場合にはこちらを代わりに用いる
m_Safety = AtomicSafetyHandle.GetTempMemoryHandle();

// CollectionHelperから作成すると上の細かい使い分けをまとめてやってくれる
m_Safety = CollectionHelper.CreateSafetyHandle(allocator);

CollectionHelper.SetStaticSafetyId<NativeCustomArray<T>>(
    ref m_Safety, // 作成したAtomicSafetyHandle
    ref s_staticSafetyId.Data // SharedStaticとしてIDを保持する
);

// 読み取り時のチェック
AtomicSafetyHandle.CheckReadAndThrow(m_Safety);

// 書き込み時のチェック
AtomicSafetyHandle.CheckWriteAndThrow(m_Safety);

#if ENABLE_UNITY_COLLECTIONS_CHECKS
    // 不要になったAtomicSafetyHandleを破棄
    CollectionHelper.DisposeSafetyHandle(ref m_Safety);
#endif

// 確保したメモリを解放する
UnsafeUtility.FreeTracked(m_Buffer, m_AllocatorLabel);

m_Buffer = null;
m_Length = 0;

internal int m_MinIndex;
internal int m_MaxIndex;

private void FailOutOfRangeError(int index)
{
    // IJobParallelForが不正な範囲にアクセスしたら例外をスローする
    if (index < Length && (m_MinIndex != 0 || m_MaxIndex != Length - 1))
        throw new IndexOutOfRangeException(string.Format(
           "Index {0} is out of restricted IJobParallelFor range [{1}...{2}] in ReadWriteBuffer.\n" +
           "ReadWriteBuffers are restricted to only read & write the element at the job index. " +
           "You can use double buffering strategies to avoid race conditions due to " +
           "reading & writing in parallel to the same elements from a job.",
           index, m_MinIndex, m_MaxIndex));

    throw new IndexOutOfRangeException(string.Format("Index {0} is out of range of '{1}' Length.", index, Length));
}