C＃（Unity）不同托管数组类型之间的快速复制

Question

I have a byte[] of colors that I need to transfer to Texture2D object via SetPixels(Color32[]) . I want to know what the fastest way to create the Color32[] from the byte[] is. Since each Color32 is 4 bytes (1 byte per channel), there would be one quarter the number of elements.

Array.CopyTo doesn't allow different object array types.

From what I read, it seems like managed code can't reinterpret the byte[] as Color32[] and skip the copy altogether.

The reverse of this ( Color32[] -> byte[] ) has a SO solution via marshalling, but there seems to be a ton of copying involved.

private static byte[] Color32ArrayToByteArray(Color32[] colors)
{
int length = 4 * colors.Length;
byte[] bytes = new byte[length];
IntPtr ptr = Marshal.AllocHGlobal(length); // unmanaged memory alloc
Marshal.StructureToPtr(colors, ptr, true); // memcpy 1
Marshal.Copy(ptr, bytes, 0, length); // memcpy 2
Marshal.FreeHGlobal(ptr);
return bytes;
}

For my case, I'm using:

 int length = bytes.Length;
 IntPtr ptr = Marshal.AllocHGlobal(length); // unmanaged mem alloc
 Marshal.Copy(bytes, 0, ptr, length); // memcpy 1
 Marshal.PtrToStructure(ptr, colors); // memcpy 2
 Marshal.FreeHGlobal(ptr);

However, I don't see the texture updating after doing myTexture.SetPixels(colors) . Still trying to figure out why.

Regardless, do I have to do 2 mem copies to accomplish this in C#? Seems like such a waste.. I was looking at unions in C# to get around the copies.

Answer 1

Here's what I learned:

1) There is no need to Marshal b/w managed and unmanaged memory to convert byte[] to Color32[] and vice versa. Instead, use a union in C#:

[StructLayout(LayoutKind.Explicit)]
public struct Color32Bytes
{
    [FieldOffset(0)]
    public byte[] byteArray;

    [FieldOffset(0)]
    public Color32[] colors;
}

Color32Bytes data = new Color32Bytes();
data.byteArray = new byte[width * height * bytesPerPixel];
data.colors = new Color32[width * height];

Now, if you update the byteArray with data from a camera, you can apply it to the Texture2D using myTexture.SetPixels(data.colors) ;

No copying involved.

2) No need for the union solution above. Haha. As NineBerry pointed out, you can just upload a raw byte buffer to a texture via myTexture.LoadRawTextureData(bytes);

This is perfect in my case, since my camera bytebuffer comes as BGRA (low to high) and I'd need to swizzle the channels before upload (expensive) OR solve it in my shader if i went with (1)

3) The SetPixels method in Unity can be expensive on low end systems. I haven't dug deeper, but I suspect it's because the D3D textures created under the hood use D3D_USAGE_DEFAULT , which means updating them has to use UpdateSubresource which incurs a driver copy and possible stall (can't update a resource currently in use by the GPU).

So, the ideal solution is to write a native plugin that creates a 2D texture with D3D_USAGE_DYNAMIC, maps-updates-unmaps it, and pass that reference back to Unity. Overkill for now, but I might revisit this later.