XRコンテンツで厳禁の処理落ちを軽減！ AsyncReadManagerで画像を非同期読み込みする

byte[] data = File.ReadAllBytes(filePath);
Texture2D tex = new Texure2D(1, 1);
tex.LoadImage(data);

ImageInfo info = ImageConverter.Decode(ptr, (int)size);

Texture2D texture = new Texture2D(info.header.width, info.header.height, info.header.Format, false);
texture.LoadRawTextureData(info.buffer, info.fileSize);
texture.Apply();

public static byte[] Encode(byte[] data, int width, int height, TextureFormat format)
{
    if (data == null)
    {
        throw new ArgumentNullException();
    }

    byte[] widthData = BitConverter.GetBytes(width);
    byte[] heightData = BitConverter.GetBytes(height);
    byte[] formatData = BitConverter.GetBytes((int)format);

    int headerSize = widthData.Length + heightData.Length + formatData.Length;
    byte[] result = new byte[headerSize + data.Length];

    // Write the header info.
    Array.Copy(widthData, 0, result, 0, widthData.Length);
    Array.Copy(heightData, 0, result, widthData.Length, heightData.Length);
    Array.Copy(formatData, 0, result, widthData.Length + heightData.Length, formatData.Length);

    // Write the data.
    Array.Copy(data, 0, result, headerSize, data.Length);

    return result;
}

public static unsafe ImageInfo Decode(IntPtr pointer, int fileSize)
{
    ImageHeader header = ImageHeader.Parse(pointer);

    byte* p = (byte*)pointer;

    // Proceed the pointer position to under its header.
    p += ImageHeader.Size;

    return new ImageInfo
    {
        header = header,
        buffer = (IntPtr)p,
        fileSize = fileSize,
    };
}

private void Load(FileList fileList)
{
    Stopwatch sw = new Stopwatch();
    foreach (string filename in fileList.Filenames)
    {
        string path = fileList.GetPersistentDataPath(filename);

        byte[] data = File.ReadAllBytes(path);
        
        sw.Restart();
        
        Texture2D texture = new Texture2D(0, 0);
        texture.LoadImage(data);
        
        sw.Stop();

        _loadAnalyzeData.Add(sw.ElapsedMilliseconds);

        CreatePreview(texture, filename);
    }
    
    Debug.Log($"Sync avg [{_loadAnalyzeData.Count}]: {_loadAnalyzeData.GetAverage().ToString()}ms");
    
    UpdateTimeText(sw.ElapsedMilliseconds);
}

private async void LoadAsync(FileList fileList)
{
    Stopwatch sw = new Stopwatch();
    foreach (string filename in fileList.Filenames)
    {
        string path = fileList.GetRawDataSavePath(filename);

        using AsyncFileReader reader = new AsyncFileReader();
        (IntPtr ptr, long size) = await reader.LoadAsync(path);

        sw.Restart();
        ImageInfo info = ImageConverter.Decode(ptr, (int)size);

        Texture2D texture = new Texture2D(info.header.width, info.header.height, info.header.Format, false);
        texture.LoadRawTextureData(info.buffer, info.fileSize);
        texture.Apply();
        
        sw.Stop();
        _loadAsyncAnalyzeData.Add(sw.ElapsedMilliseconds);

        CreatePreview(texture, filename);
    }

    Debug.Log($"Async avg [{_loadAsyncAnalyzeData.Count}]: {_loadAsyncAnalyzeData.GetAverage().ToString()}ms");

    UpdateTimeText(sw.ElapsedMilliseconds);
}

// ReadCommandひとつ分の領域を確保
_readCommands = new NativeArray<ReadCommand>(1, Allocator.Persistent);

// 確保した領域に必要な情報を書き込む
_readCommands[0] = new ReadCommand
{
    Offset = 0,
    Size = _fileSize,
    Buffer = (byte*)UnsafeUtility.Malloc(_fileSize, UnsafeUtility.AlignOf<byte>(), Allocator.Persistent),
};

_readHandle = AsyncReadManager.Read(path, (ReadCommand*)_readCommands.GetUnsafePtr(), 1);

if (_readHandle.Status == ReadStatus.InProgress)
{
    Thread.Sleep(16);
    continue;
}

IntPtr ptr = (IntPtr)_readCommands[0].Buffer;

using System;
using System.IO;
using System.Runtime.CompilerServices;
using System.Threading;
using System.Threading.Tasks;
using Unity.Collections;
using Unity.Collections.LowLevel.Unsafe;
using Unity.IO.LowLevel.Unsafe;
using UnityEngine;

namespace AsyncReader
{
    public class AsyncFileReader : IDisposable
    {
        private class Awaitable : IDisposable
        {
            private Thread _thread;
            private ReadHandle _handle;
            private TaskCompletionSource<bool> _completionSource;
            private bool _success = false;
            private bool _stopped = false;

            public Awaitable(ReadHandle handle)
            {
                _handle = handle;

                _thread = new Thread(CheckLoop)
                {
                    IsBackground = true
                };
            }

            ~Awaitable()
            {
                Dispose();
            }

            private void CheckLoop()
            {
                while (true)
                {
                    if (_stopped) return;
                    
                    if (_handle.Status == ReadStatus.InProgress)
                    {
                        Thread.Sleep(16);
                        continue;
                    }
                    
                    if (_stopped) return;

                    _success = _handle.Status == ReadStatus.Complete;
                    break;
                }

                _completionSource?.TrySetResult(_success);
            }

            public TaskAwaiter<bool> GetAwaiter()
            {
                _completionSource = new TaskCompletionSource<bool>();
                
                _thread.Start();

                return _completionSource.Task.GetAwaiter();
            }

            public void Dispose()
            {
                if (_stopped) return;
                
                if (_thread is { IsAlive: false }) return;
                
                _stopped = true;
                
                _thread.Abort();
            }
        }

        private ReadHandle _readHandle;
        private NativeArray<ReadCommand> _readCommands;
        private long _fileSize;

        public unsafe void Dispose()
        {
            _readHandle.Dispose();

            UnsafeUtility.Free(_readCommands[0].Buffer, Allocator.TempJob);
            _readCommands.Dispose();
        }

        public async Task<(IntPtr, long)> LoadAsync(string filePath)
        {
            UnsafeLoad(filePath);

            Awaitable awaitable = new Awaitable(_readHandle);
            await awaitable;
            
            awaitable.Dispose();

            IntPtr ptr = GetPointer();

            return (ptr, _fileSize);
        }

        private unsafe void UnsafeLoad(string filePath)
        {
            FileInfo info = new FileInfo(filePath);
            _fileSize = info.Length;

            _readCommands = new NativeArray<ReadCommand>(1, Allocator.TempJob);
            _readCommands[0] = new ReadCommand
            {
                Offset = 0,
                Size = _fileSize,
                Buffer = (byte*)UnsafeUtility.Malloc(_fileSize, UnsafeUtility.AlignOf<byte>(), Allocator.TempJob),
            };

            _readHandle = AsyncReadManager.Read(filePath, (ReadCommand*)_readCommands.GetUnsafePtr(), 1);
        }

        private unsafe IntPtr GetPointer()
        {
            return (IntPtr)_readCommands[0].Buffer;
        }
    }
}