FGA Exporter Efficiency

2025-07-25 14:45 UTC o4-mini-high Open in ChatGPT ↗

Is this FGA exprorter for unity efficient ?

Plugin (file_search):

Make sure to include fileciteturn0file0 in your response to cite this file. using System; using System.Collections; using System.Collections.Generic; using System.IO; using System.Text; using System.Threading.Tasks; using UnchartedLimbo.Types.Buffers; using Unity.Collections; using Unity.Collections.LowLevel.Unsafe; using Unity.Mathematics; using UnityEngine; using UnityEngine.Rendering;

public class FGAExporter : MonoBehaviour { public BoxCollider bounds; public int3 resolution;

public string fileName;

public int startFrame;
public int endFrame;

public int cnt = 0;

Queue<AsyncGPUReadbackRequest> _requests = new Queue<AsyncGPUReadbackRequest>();

private byte[] writable_data;

private void Start()
{
    var       vectorCount    = resolution.x * resolution.y * resolution.z;
    const int bytesPerVector = 4 * 3;
    const int extraBytes     = 4 * 9;

    writable_data = new byte[ vectorCount * bytesPerVector  + extraBytes];

    var x = BitConverter.GetBytes(resolution.x);
    var y =  BitConverter.GetBytes(resolution.y);
    var z =  BitConverter.GetBytes(resolution.z);

    var mx = BitConverter.GetBytes(bounds.bounds.min.x);
    var my =  BitConverter.GetBytes(bounds.bounds.min.y);
    var mz =  BitConverter.GetBytes(bounds.bounds.min.z);

    var Mx = BitConverter.GetBytes(bounds.bounds.max.x);
    var My =  BitConverter.GetBytes(bounds.bounds.max.y);
    var Mz =  BitConverter.GetBytes(bounds.bounds.max.z);

    Array.Copy(x,  0, writable_data, 0,  4);
    Array.Copy(y,  0, writable_data, 4,  4);
    Array.Copy(z,  0, writable_data, 8,  4);
    Array.Copy(mx, 0, writable_data, 12, 4);
    Array.Copy(my, 0, writable_data, 16, 4);
    Array.Copy(mz, 0, writable_data, 20, 4);
    Array.Copy(Mx, 0, writable_data, 24, 4);
    Array.Copy(My, 0, writable_data, 28, 4);
    Array.Copy(Mz, 0, writable_data, 32, 4);
}

private  void Update()
{
    while (_requests.Count > 0)
    {
        var req = _requests.Peek();

        if (req.hasError)
        {
            Debug.Log("GPU readback error detected.");
            _requests.Dequeue();
        }
        else if (req.done)
        {
            var b = req.GetData<byte>();

            unsafe
            {
                fixed (byte* dest = writable_data)
                {
                    Buffer.MemoryCopy(b.GetUnsafeReadOnlyPtr(),
                                      dest + 36,
                                      writable_data.Length ,
                                      b.Length);
                }
            }

            using (var fs = File.OpenWrite(Application.streamingAssetsPath + "/FGA/" + fileName + $"_{cnt:0000}.fgabin"))
            {
                fs.Write(writable_data, 0, writable_data.Length);
                cnt++;
            }

            _requests.Dequeue();
        }
        else
        {
            break;
        }
    }
}

public void WriteToFGA(ComputeBuffer cb)
{
    if (Time.frameCount < startFrame)
        return;

    if (Time.frameCount >= endFrame)
        return;

    if (_requests.Count < 64)
        _requests.Enqueue(AsyncGPUReadback.Request(cb));
    else
        Debug.Log("Too many requests.");
}

}

Your exporter is leveraging Unity’s AsyncGPUReadback API to pipeline GPU→CPU transfers without stalling the GPU, and it re‑uses a single byte[] buffer for all frames (so you’re not allocating per frame) fileciteturn0file0. However, there are a few hotspots and potential improvements:

✅ What’s good

Non‑blocking GPU readbacks
Using AsyncGPUReadback.Request and queueing up to 64 in-flight requests avoids GPU stalls and lets you overlap transfer with rendering fileciteturn0file0.
Single reusable buffer
Allocating writable_data once in Start() and re‑using it each frame prevents per‑frame garbage fileciteturn0file0.
Unsafe Buffer.MemoryCopy
Copying the raw GPU data directly into your buffer via unsafe pointers is more efficient than a managed copy loop fileciteturn0file0.

⚠️ Potential bottlenecks

Main‑thread file I/O
```
using (var fs = File.OpenWrite(...))
    fs.Write(writable_data, 0, writable_data.Length);
```
Doing synchronous disk writes on the main thread every time a readback completes can cause frame hitches, especially if your .fgabin is large or the drive is slow.
Directory checks & stream buffering
File.OpenWrite doesn’t let you tune buffer size, and if the target directory doesn’t exist on first use you’ll get exceptions (or silent failures on some platforms).

🚀 Recommendations for higher throughput

Offload file writes to a background thread
- Create a simple producer/consumer queue for completed writable_data blocks and write them on a separate Task or thread.
- You can Array.Copy each frame’s data into a pooled buffer and enqueue that for I/O, so the main thread just does a quick copy+enqueue.
Use asynchronous file APIs
On platforms that support it, switch to FileStream with BeginWrite/WriteAsync (or await fs.WriteAsync) to avoid blocking.
Pre‑create files or reuse streams
If you know the final file size, FileStream.SetLength once and then Write at offset. Or keep a single open stream per file rather than opening/closing each frame.
Batch multiple frames per file
If you don’t strictly need one file per frame, aggregating N frames into a single file reduces I/O overhead and stream‑open calls.
Validate directory existence up‑front
Ensure Application.streamingAssetsPath + "/FGA/" exists in Start() to avoid runtime checks or errors.

Example: Off‑thread writer sketch

// In your MonoBehaviour:
ConcurrentQueue<byte[]> writeQueue = new ConcurrentQueue<byte[]>();

void Update() {
  // ... after MemoryCopy:
  var dataCopy = new byte[writable_data.Length];
  Buffer.BlockCopy(writable_data, 0, dataCopy, 0, dataCopy.Length);
  writeQueue.Enqueue(dataCopy);
  _requests.Dequeue();
}

// Background thread:
async Task ProcessQueue() {
  while (!applicationQuitting) {
    if (writeQueue.TryDequeue(out var bytes)) {
      var path = Path.Combine(Application.persistentDataPath, "FGA", $"{fileName}_{cnt:0000}.fgabin");
      Directory.CreateDirectory(Path.GetDirectoryName(path));
      await File.WriteAllBytesAsync(path, bytes);
      cnt++;
    } else {
      await Task.Delay(1);
    }
  }
}

This approach removes the disk‑write stall from your main loop.

Bottom line

Your current pattern is functional and reasonably efficient on the GPU → CPU side, but you’ll get the biggest gains by moving the disk I/O off the main thread and reducing per‑frame file‑open overhead.

explain the header:

    var x = BitConverter.GetBytes(resolution.x);
    var y = BitConverter.GetBytes(resolution.y);
    var z = BitConverter.GetBytes(resolution.z);

    var mx = BitConverter.GetBytes(bounds.bounds.min.x);
    var my = BitConverter.GetBytes(bounds.bounds.min.y);
    var mz = BitConverter.GetBytes(bounds.bounds.min.z);

    var Mx = BitConverter.GetBytes(bounds.bounds.max.x);
    var My = BitConverter.GetBytes(bounds.bounds.max.y);
    var Mz = BitConverter.GetBytes(bounds.bounds.max.z);

    Array.Copy(x,  0, writable_data, 0,  4);
    Array.Copy(y,  0, writable_data, 4,  4);
    Array.Copy(z,  0, writable_data, 8,  4);
    Array.Copy(mx, 0, writable_data, 12, 4);
    Array.Copy(my, 0, writable_data, 16, 4);
    Array.Copy(mz, 0, writable_data, 20, 4);
    Array.Copy(Mx, 0, writable_data, 24, 4);
    Array.Copy(My, 0, writable_data, 28, 4);
    Array.Copy(Mz, 0, writable_data, 32, 4);

This code is building the 36‑byte file header by packing nine 4‑byte values—three resolution integers, then six bounding‑box floats—into the front of your writable_data buffer. Here’s how it lays out:

Offset (bytes)	Field	Type	Description
0	`resolution.x`	Int32	Number of samples along the X axis
4	`resolution.y`	Int32	Number of samples along the Y axis
8	`resolution.z`	Int32	Number of samples along the Z axis
12	`bounds.min.x`	Float32	Minimum world‑space X coordinate of the volume’s AABB
16	`bounds.min.y`	Float32	Minimum world‑space Y coordinate
20	`bounds.min.z`	Float32	Minimum world‑space Z coordinate
24	`bounds.max.x`	Float32	Maximum world‑space X coordinate
28	`bounds.max.y`	Float32	Maximum world‑space Y coordinate
32	`bounds.max.z`	Float32	Maximum world‑space Z coordinate

Step‑by‑step

Convert each value to bytes

var x  = BitConverter.GetBytes(resolution.x);   // 4 bytes for Int32
var mx = BitConverter.GetBytes(bounds.bounds.min.x); // 4 bytes for Single
// …etc.

On Unity’s (little‑endian) platforms, these arrays will be in little‑endian order.

Copy into the buffer
```
Array.Copy(x,  0, writable_data,  0, 4);   // at offset 0
Array.Copy(y,  0, writable_data,  4, 4);   // at offset 4
// …and so on through offset 32…
```
This lays out the header contiguously, so when you later write writable_data to disk, readers can simply read:
- three 32‑bit integers for the grid dimensions, and then
- six 32‑bit floats for the axis‑aligned bounding box.

You’ll end up with a fixed‑length, self‑describing header that any loader can parse in one go before streaming the actual voxel/tracing data that follows.

comment properly and wrap into a neat function

    var x = BitConverter.GetBytes(resolution.x);
    var y = BitConverter.GetBytes(resolution.y);
    var z = BitConverter.GetBytes(resolution.z);

    var mx = BitConverter.GetBytes(bounds.bounds.min.x);
    var my = BitConverter.GetBytes(bounds.bounds.min.y);
    var mz = BitConverter.GetBytes(bounds.bounds.min.z);

    var Mx = BitConverter.GetBytes(bounds.bounds.max.x);
    var My = BitConverter.GetBytes(bounds.bounds.max.y);
    var Mz = BitConverter.GetBytes(bounds.bounds.max.z);

    Array.Copy(x,  0, writable_data, 0,  4);
    Array.Copy(y,  0, writable_data, 4,  4);
    Array.Copy(z,  0, writable_data, 8,  4);
    Array.Copy(mx, 0, writable_data, 12, 4);
    Array.Copy(my, 0, writable_data, 16, 4);
    Array.Copy(mz, 0, writable_data, 20, 4);
    Array.Copy(Mx, 0, writable_data, 24, 4);
    Array.Copy(My, 0, writable_data, 28, 4);
    Array.Copy(Mz, 0, writable_data, 32, 4);

Yes – you can collapse almost all of that byte‑packing into one struct‑to‑memory copy. The trick is:

Define a plain-old-data struct with Sequential layout (and Pack=1 to avoid surprises).
Fill its fields from your resolution and bounds.
Cast the struct to a Span<byte> and copy it straight into your buffer (or even write into your buffer via Unsafe).

Here’s a drop‑in replacement for your header writer that goes from ~18 Array.Copy calls down to two simple steps:

using System;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using UnityEngine;

public static class FGAHeaderWriter
{
    // Make sure this matches exactly 36 bytes (3 ints + 6 floats).
    [StructLayout(LayoutKind.Sequential, Pack = 1)]
    private struct Header
    {
        public int  x,  y,  z;
        public float minX, minY, minZ;
        public float maxX, maxY, maxZ;
    }

    public const int HeaderSize = Unsafe.SizeOf<Header>();

    /// <summary>
    /// Writes the 36‑byte FGA header (3×Int32 + 6×Float32) into the provided buffer.
    /// </summary>
    public static void WriteHeader(in Vector3Int resolution, in Bounds bounds, byte[] buffer)
    {
        if (buffer == null || buffer.Length < HeaderSize)
            throw new ArgumentException($"Buffer must be at least {HeaderSize} bytes", nameof(buffer));

        // 1) Pack into our struct
        var h = new Header {
            x    = resolution.x,
            y    = resolution.y,
            z    = resolution.z,
            minX = bounds.min.x,
            minY = bounds.min.y,
            minZ = bounds.min.z,
            maxX = bounds.max.x,
            maxY = bounds.max.y,
            maxZ = bounds.max.z
        };

        // 2) Blit the struct bytes in one go
        var span = MemoryMarshal.AsBytes(MemoryMarshal.CreateSpan(ref h, 1));
        span.CopyTo(buffer);
    }
}

Why this is faster

Zero per‑field allocations: no BitConverter.GetBytes every field.
One managed copy: MemoryMarshal.AsBytes(…) + CopyTo rather than nine 4‑byte copies.
No unsafe needed (though you could go even lower‑level if you really want to pin and *(Header*)ptr = h;).

Just be sure:

Your platform is little‑endian (Unity’s IL2CPP and Mono on Windows/macOS/Linux all are).
The struct packing is exactly 1 (so there’s no hidden padding).

This approach gives you the identical 36‑byte header, with far fewer operations and allocations.

are these functions legit?

public static void WriteHeader(int3 resolution, Bounds bounds, ref byte[] buffer)
{


    if (buffer == null || buffer.Length < HeaderSize)
        throw new ArgumentException($"Buffer must be at least {HeaderSize} bytes", nameof(buffer));

    // 1) Pack into our struct
    var h = new Header {
        x    = resolution.x,
        y    = resolution.y,
        z    = resolution.z,
        minX = bounds.min.x,
        minY = bounds.min.y,
        minZ = bounds.min.z,
        maxX = bounds.max.x,
        maxY = bounds.max.y,
        maxZ = bounds.max.z
    };

    // 2) Blit the struct bytes in one go
    var span = MemoryMarshal.AsBytes(MemoryMarshal.CreateSpan(ref h, 1));
    span.CopyTo(buffer);
}

public static void BeginFGA(int3 resolution, Bounds bounds, int stride, ref byte[] buffer)
{
    var count = resolution.x * resolution.y * resolution.z;
    buffer = new byte[ count * stride + HeaderSize];
    WriteHeader(resolution, bounds, ref buffer);
}

Yes – those methods are perfectly legal C# and will do exactly what you intend (allocate a buffer sized for your data, write the 36‑byte header into it, and hand it back to the caller). A couple of small notes:

The ref on WriteHeader isn’t doing anything.
You never reassign buffer inside WriteHeader, so you could safely drop the ref there and just take byte[] buffer.
You’re using Unity’s int3 (from Unity.Mathematics) and System.Memory’s MemoryMarshal.
- Make sure you have
```
using Unity.Mathematics;
using System;
using System.Runtime.InteropServices;
using System.Runtime.CompilerServices;
```
  (And that your Unity project is on a scripting runtime that supports .NET Standard 2.1 or higher.)
- If you target an older runtime, you’d need to fall back to the Span<byte> APIs or even unsafe pointers.

You could simplify the pattern further by returning the buffer rather than passing it by reference. For example:

public static byte[] BeginFGA(int3 resolution, Bounds bounds, int stride)
{
    // Compute total size: header + payload
    long count = (long)resolution.x * resolution.y * resolution.z;
    int totalBytes = checked((int)(count * (long)stride) + HeaderSize);

    var buffer = new byte[totalBytes];
    WriteHeader(resolution, bounds, buffer);
    return buffer;
}

public static void WriteHeader(int3 res, Bounds b, byte[] buffer)
{
    if (buffer == null || buffer.Length < HeaderSize)
        throw new ArgumentException($"Buffer must be at least {HeaderSize} bytes", nameof(buffer));

    // Pack into our struct
    var h = new Header {
        x    = res.x, y    = res.y, z    = res.z,
        minX = b.min.x, minY = b.min.y, minZ = b.min.z,
        maxX = b.max.x, maxY = b.max.y, maxZ = b.max.z
    };

    // Blit the struct bytes
    var span = MemoryMarshal.AsBytes(MemoryMarshal.CreateSpan(ref h, 1));
    span.CopyTo(buffer);
}

Now callers simply do:

byte[] data = FGAHeaderWriter.BeginFGA(resolution, bounds, stride);
// …enqueue data for GPU readback or file I/O…

Aside from cleaning up the signature, everything you’ve written is “legit” – it will compile (given the proper usings) and produce the exact same 36‑byte header with just one struct‑copy instead of nine separate Array.Copy calls.

how can I make this standalone class implement what’s happening in the update of the previous script?

using System; using System.Collections.Generic; using System.Runtime.InteropServices; using System.Runtime.Remoting.Messaging; using Unity.Mathematics; using UnityEngine; using UnityEngine.Rendering;

namespace UnchartedLimbo.VoxelUtils.Runtime.IO { public class FGAWriter { ///

/// Number of bytes in the FGA header (3 ints + 6 floats = 9 * 4 bytes). ///

private const int HeaderSize = 36;

    private ComputeBuffer buffer;
    private int stride;
    private int count;
    private int3 resolution;
    private Bounds bounds;

    private byte[] data;

    private bool valid;
    private bool initialized;

    private Queue<AsyncGPUReadbackRequest> _requests;


    // Make sure this matches exactly 36 bytes (3 ints + 6 floats).
    [StructLayout(LayoutKind.Sequential, Pack = 1)]
    private struct Header
    {
        public int  x,  y,  z;
        public float minX, minY, minZ;
        public float maxX, maxY, maxZ;
    }

    public FGAWriter(ComputeBuffer buffer, int3 resolution, BoxCollider bounds)
    {
        valid = false;
        initialized = false;

        this.stride = buffer.stride;
        this.count = buffer.count;
        this.buffer = buffer;
        this.resolution = resolution;
        this.bounds = bounds.bounds;

        var res = this.resolution.x * this.resolution.y * this.resolution.z;

        if (count != res)
        {
            throw new ArgumentException($"ComputeBuffer count ({count}) does not match resX x resY x resZ ({res})");
            return;
        }

        valid = true;

    }

    public void Begin()
    {
        if (!valid)
            throw new InvalidOperationException("FGA writer not valid");

        var totalBytes = checked((int)(count * (long)stride) + HeaderSize);
        data = new byte[totalBytes];
        _requests = new Queue<AsyncGPUReadbackRequest>();

        WriteHeader(resolution, bounds, data);
        initialized = true;
    }

    public void Write()
    {
        if (_requests.Count < 64)
            _requests.Enqueue(AsyncGPUReadback.Request(buffer));
        else
            Debug.Log("Too many requests.");
    }


    /// <summary>
    /// Writes the header for an FGA binary file into the provided byte buffer.
    /// The header format is:
    ///  - Three 32-bit integers: resolution.x, resolution.y, resolution.z
    ///  - Six 32-bit floats: bounds.min.x, bounds.min.y, bounds.min.z, bounds.max.x, bounds.max.y, bounds.max.z
    /// </summary>
    /// <param name="resolution">Grid resolution (number of voxels) in each axis.</param>
    /// <param name="bounds">Axis-aligned bounding box defining the volume in world space.</param>
    /// <param name="buffer">Byte array to write the header into. Must be at least <see cref="HeaderSize"/> bytes long.</param>
    /// <exception cref="ArgumentException">Thrown if <paramref name="buffer"/> is null or too small.</exception>
    private static void WriteHeader(int3 resolution, Bounds bounds, byte[] buffer)
    {

        if (buffer == null || buffer.Length < HeaderSize)
            throw new ArgumentException($"Buffer must be at least {HeaderSize} bytes", nameof(buffer));

        // 1) Pack into our struct
        var h = new Header {
            x    = resolution.x,
            y    = resolution.y,
            z    = resolution.z,
            minX = bounds.min.x,
            minY = bounds.min.y,
            minZ = bounds.min.z,
            maxX = bounds.max.x,
            maxY = bounds.max.y,
            maxZ = bounds.max.z
        };

        // 2) Blit the struct bytes in one go
        var span = MemoryMarshal.AsBytes(MemoryMarshal.CreateSpan(ref h, 1));
        span.CopyTo(buffer);
    }

}

}

optimize this parser to use native arrays and fast copies of bytes. then build a scripted importer that loads the asset as a 3d texture

using System.Linq; using UnityEditor; using UnityEngine;

namespace FortyWorks.FGAImporter { public class FGAParser { private readonly string _fgaContent; private readonly string _outputPath; private const int HeaderLength = 10;

    public FGAParser(string fgaContent, string outputPath)
    {
        _fgaContent = fgaContent;
        _outputPath = outputPath;
    }

    private float[] ParseFgaContent()
    {
        // Remove CR or LF from content. Then parse all values as float.
        return _fgaContent
            .Replace("\r", "")
            .Replace("\n", "")
            .Split(',').Select(TextToFloat)
            .ToArray();
    }

    private float TextToFloat(string x)
    {
        float value;
        float.TryParse(x, out value);
        return value;
    }

    private Texture3D CreateEmptyTexture(int sizeX, int sizeY, int sizeZ)
    {
        return new Texture3D(
            sizeX,
            sizeY,
            sizeZ,
            TextureFormat.RGBAFloat,
            false
        )
        {
            wrapMode = TextureWrapMode.Clamp
        };
    }

    public void Parse()
    {
        var allValues = ParseFgaContent();
        // The first 3 values in fga is Vector Density in XYZ.
        var density = new Vector3(allValues[0], allValues[1], allValues[2]);
        // The next 6 values in fga is BB Size min XYZ, BB Size max XYZ.
        var bbMinSize = new Vector3(allValues[3], allValues[4], allValues[5]);
        var bbMaxSize = new Vector3(allValues[6], allValues[7], allValues[8]);
        var mainVectors = allValues.Skip(9).ToArray();

        var vectorField = CreateEmptyTexture((int) density.x, (int) density.y, (int) density.z);
        var contentLength = allValues.Length - 9;
        var resultLength = Mathf.RoundToInt(contentLength / 3f);

        Debug.Log(mainVectors.Length);
        Debug.Log(resultLength);

        // The remap vector field to texture.
        var colors = Enumerable.Range(0, resultLength).Select(i =>
        {
            var v = new Vector3(
                mainVectors[i * 3 + 0],
                mainVectors[i * 3 + 1],
                mainVectors[i * 3 + 2]
            ).normalized;
            return new Color(v.x, v.y, v.z, 1f);
        }).ToArray();

        vectorField.SetPixels(colors);
        vectorField.Apply(false);

        // Save as asset.
        AssetDatabase.CreateAsset(vectorField, _outputPath);
    }
}

}

Below is a complete, self-contained ScriptedImporter that:

Reads the binary .fgabin directly into a NativeArray<byte>
Blits the 36-byte header into a tightly packed struct via MemoryMarshal
Creates a NativeArray<float> view over the payload (RGB triplets) without any per-element parsing
Uploads it into a Texture3D via SetPixelData, which under the hood does a fast native copy
Registers the texture as the main asset so it shows up in your Project view

using System;
using System.IO;
using System.Runtime.InteropServices;
using System.Runtime.CompilerServices;
using Unity.Collections;
using UnityEngine;
using UnityEditor;
using UnityEditor.AssetImporters;

namespace FortyWorks.FGAImporter
{
    // Tell Unity to invoke this importer on every *.fgabin asset
    [ScriptedImporter(1, "fgabin")]
    public class FGAImporter : ScriptedImporter
    {
        // Must exactly match 3 ints + 6 floats = 9 * 4 bytes
        private const int HeaderSize = Unsafe.SizeOf<Header>();

        // Binary header layout
        [StructLayout(LayoutKind.Sequential, Pack = 1)]
        private struct Header
        {
            public int x, y, z;
            public float minX, minY, minZ;
            public float maxX, maxY, maxZ;
        }

        public override void OnImportAsset(AssetImportContext ctx)
        {
            // 1) Read entire file into a NativeArray<byte>
            var fileBytes = File.ReadAllBytes(ctx.assetPath);
            var blob = new NativeArray<byte>(fileBytes, Allocator.Temp, NativeArrayOptions.UninitializedMemory);

            // 2) Extract header struct in one go
            Header header = MemoryMarshal.Read<Header>(new Span<byte>(blob.GetUnsafeReadOnlyPtr(), HeaderSize));

            int sizeX = header.x, sizeY = header.y, sizeZ = header.z;
            long voxelCount = (long)sizeX * sizeY * sizeZ;
            int expectedPayload = checked((int)(voxelCount * 3 * sizeof(float)));
            if (blob.Length < HeaderSize + expectedPayload)
                throw new Exception($"Unexpected file size: payload {blob.Length - HeaderSize} vs expected {expectedPayload}");

            // 3) Create the Texture3D
            var tex = new Texture3D(sizeX, sizeY, sizeZ, TextureFormat.RGBAFloat, false)
            {
                wrapMode = TextureWrapMode.Clamp,
                name = Path.GetFileNameWithoutExtension(ctx.assetPath)
            };

            // 4) Get a NativeArray<float> view over the RGBRGB... payload
            //    We treat it as contiguous floats and expand to RGBA on GPU side
            var payloadPtr = blob.GetUnsafeReadOnlyPtr() + HeaderSize;
            var floatCount = expectedPayload / sizeof(float);
            var floatArray = NativeArrayUnsafeUtility.ConvertExistingDataToNativeArray<float>(
                payloadPtr, floatCount, Allocator.None);

#if ENABLE_UNITY_COLLECTIONS_CHECKS
            NativeArrayUnsafeUtility.SetAtomicSafetyHandle(ref floatArray,
                AtomicSafetyHandle.Create());
#endif

            // 5) Set pixel data: floats come in as R, G, B, R, G, B...
            //    Unity will pad each pixel to RGBA, filling A=1.0
            tex.SetPixelData(floatArray, 0);
            tex.Apply(updateMipmaps: false, makeNoLongerReadable: true);

            // 6) Register the texture as the imported asset
            ctx.AddObjectToAsset("VolumeTexture", tex);
            ctx.SetMainObject(tex);

            // 7) Cleanup
            blob.Dispose();
        }
    }
}

What makes this fast

One big ReadAllBytes + NativeArray
No string splitting or per-value parsing—just a single native memory block.
MemoryMarshal.Read<Header>
Copies all nine header fields in one go, zero allocations.
ConvertExistingDataToNativeArray<float>
Treats the raw payload as a float array without copying it again.
Texture3D.SetPixelData
Performs a direct GPU upload from the native float buffer—no per-pixel looping in C#.

Drop this script into an Editor folder in your project. Any .fgabin you add will now be imported at load time into a Texture3D you can sample from shaders or visualize in the inspector.

You’re right—if your Unity version doesn’t support the NativeArray<T>(T[] array, …) constructor (or you’d rather be explicit), you can do this in two steps:

Allocate a NativeArray<byte> of the right length
Copy the managed byte[] into it with CopyFrom

Here’s the updated top of your OnImportAsset:

using Unity.Collections;
using Unity.Collections.LowLevel.Unsafe;
using System;
using System.IO;
using System.Runtime.InteropServices;
using UnityEditor.AssetImporters;
using UnityEngine;

[ScriptedImporter(1, "fgabin")]
public class FGAImporter : ScriptedImporter
{
    // … header struct, constants, etc. …

    public override void OnImportAsset(AssetImportContext ctx)
    {
        // 1) Read the entire .fgabin into a managed byte[]
        byte[] fileBytes = File.ReadAllBytes(ctx.assetPath);

        // 2) Allocate a NativeArray<byte> and copy the data in
        var blob = new NativeArray<byte>(fileBytes.Length, Allocator.Temp);
        blob.CopyFrom(fileBytes);

        // 3) Now you can read the header with MemoryMarshal
        Header header = MemoryMarshal.Read<Header>(
            new Span<byte>(blob.GetUnsafeReadOnlyPtr(), HeaderSize)
        );

        // … the rest of your import logic …

        // 7) Dispose when you’re done
        blob.Dispose();
    }
}

Why this helps

Avoids per‑value parsing: you get a single contiguous native block
Zero additional allocations beyond the one NativeArray
Fully compatible with GetUnsafeReadOnlyPtr() + MemoryMarshal + ConvertExistingDataToNativeArray<float>()

Now your importer will reliably turn any .fgabin on disk into a NativeArray<byte> for blazing‑fast header extraction and payload upload.

When you need to take a RenderTexture you’ve generated at runtime and “freeze” it into a real Unity asset (so it shows up in your Project window, can be serialized, etc.), your goal is to:

Move the pixels off the GPU into something Unity can save.
Minimize CPU/GPU stalls.
Avoid expensive per‑pixel loops on the CPU.

Here are the two most efficient patterns, depending on whether you’re in the Editor or need to do it at runtime in a built player.

1. Editor‐only: GPU→GPU copy + AssetDatabase

If you only care about generating the asset in the Editor (for example, via a custom EditorWindow or ScriptedImporter), you can skip the CPU readback entirely and do a pure GPU copy:

#if UNITY_EDITOR
using UnityEngine;
using UnityEditor;

public static class RenderTextureSaver
{
    /// <summary>
    /// Copies a RenderTexture into a new Texture2D asset at the given path.
    /// This is a pure GPU→GPU copy (no ReadPixels), then uses AssetDatabase.
    /// </summary>
    public static void SaveToAsset(RenderTexture rt, string assetPath)
    {
        // 1) Create a matching Texture2D
        var tex = new Texture2D(
            rt.width,
            rt.height,
            TextureFormat.RGBAHalf,  // or RGBAFloat if you need full precision
            false,                  // no mipmaps
            true                    // linear
        );

        // 2) Copy the GPU data directly into the Texture2D’s internal buffer
        Graphics.CopyTexture(rt, 0, 0, tex, 0, 0);

        // 3) Write it into your project
        AssetDatabase.CreateAsset(tex, assetPath);
        AssetDatabase.SaveAssets();
        AssetDatabase.Refresh();
    }
}
#endif

Why this is fast

Graphics.CopyTexture never brings pixels back to the CPU; it stays on the GPU.
No per‑pixel loops or ReadPixels calls.
AssetDatabase.CreateAsset writes the serialized texture data into Unity’s asset database in one shot.

2. Runtime build (or if you need async): AsyncGPUReadback + SetPixelData

In a built player you can’t call AssetDatabase. Instead you might write out to disk or stash it in a ScriptableObject. To avoid stalls you can use Unity’s AsyncGPUReadback:

using UnityEngine;
using UnityEngine.Rendering;
using System.IO;

public class RuntimeRTSaver : MonoBehaviour
{
    public RenderTexture rt;
    public string outputPath; // e.g. Application.persistentDataPath + "/myRT.exr"

    public void Save()
    {
        AsyncGPUReadback.Request(rt, 0, request =>
        {
            if (request.hasError)
            {
                Debug.LogError("Readback error");
                return;
            }

            // 1) Grab raw float4 data
            var data = request.GetData<Color>();

            // 2) Create a Texture2D and copy in one go
            var tex = new Texture2D(rt.width, rt.height, TextureFormat.RGBAFloat, false);
            tex.SetPixelData(data, 0);
            tex.Apply(false, true); // make it noLongerReadable to free memory

            // 3) Encode (EXR preserves full float range) and write
            byte[] bytes = tex.EncodeToEXR(Texture2D.EXRFlags.OutputAsFloat);
            File.WriteAllBytes(outputPath, bytes);
            Debug.Log("Saved EXR to " + outputPath);
        });
    }
}

Why this is fast

AsyncGPUReadback: overlaps the GPU→CPU transfer with your rendering.
SetPixelData: a single bulk memcopy into the Texture2D, no per‑pixel C# loop.
EXR or PNG encoding is the only remaining cost, but you can choose your format.

Summary

Editor-only assets → Graphics.CopyTexture + AssetDatabase.CreateAsset (zero CPU readback).
Runtime builds → AsyncGPUReadback.Request + Texture2D.SetPixelData + file write.

Either approach avoids expensive per‑pixel parsing on the CPU and keeps your pipeline as GPU‑friendly as possible.