NativeArray and Mesh

It would be great if we could pass NativeArray's to the Mesh API.

Methods like Mesh.SetVertices(), Mesh.SetNormals(), etc. currently require a list and can therefore not be jobified properly.

Are there any plans to support this in the forseeable future?

 

More then that, Mesh wants Vector3s and can only be used from the main thread. I do hope we get a way to create and manage meshes from inside the Jobs system (and thus inside ECS as well).

 

It would be great to alter meshes directly from a job, but for the time being i would be satisfied when i could just pass the data i have calculate in the job system to the mesh on the main thread.
Let's not get too greedy

 

"The point is, ladies and gentleman, that greed, for lack of a better word, is good." - Gordon Gekko in Wall Street

I'm not sure there would be huge amount of difference between modify Mesh and creating a new way to create a mesh then manage getting it to the main thread (when needed, DirectX 12, Vulkan and Metal don't have this limit).

 

Thanks for confirming that.
Not that i'm in a hurry, but i think i speak for all users here when i say "We want it NOW"

 

In the future we will also want to have overloads that would accept the types from the new math library, e.g. NativeArray<float3> etc

 

better to not be outdated when that time comes

 

This makes me gitty. I know good things take time, but i cant WAIT for all of this and will be watching the progress on all of this very closely.

 

Any update on this or is it another case where we'll be waiting years for a few lines of code that everyone agrees are needed?

 

I'm glad I'm not the only one. I have requested this in an older thread.

 

I realize I sound petty above, but there is a lot of history on trying to get the Mesh setters improved.
https://feedback.unity3d.com/suggestions/allow-mesh-data-to-have-a-length
https://forum.unity.com/threads/new-mesh-functions.339490/
https://forum.unity.com/threads/years-later-mesh-data-setters-still-terrible.464809/

 

My RAM would appreciate this feature.
This is one of the only (and biggest) sources of garbage I am forced to deal with as of now.

But it's probably more likely that Unity is focusing on reworking the Mesh Component from the ground up for ECS.
Just a guess.

 

How I convert DynamicBuffers to Mesh, no garbage, super quick Single memcpy per buffer.

I actually had an even faster version that I've talked about a bit before where I could manipulate a List<T> within a job so it didn't even require a memcopy but I feel the very minor performance cost of a memcopy is worth the safety of using buffers instead. Also means I don't need SharedComponentData.

Code (CSharp):

1.  
2.     public class MeshSystem : ComponentSystem
3.     {
4.         private readonly List<Vector3> verticesList = new List<Vector3>();
5.         private readonly List<Vector3> normalsList = new List<Vector3>();
6.         private readonly List<Vector3> uvsList = new List<Vector3>();
7.         private readonly List<int> trianglesList = new List<int>();
8.  
9.         // ...
10.  
11.         private void SetMesh(
12.             Mesh mesh,
13.             DynamicBuffer<Vector3> vertices,
14.             DynamicBuffer<Vector3> uvs,
15.             DynamicBuffer<Vector3> normals,
16.             DynamicBuffer<int> triangles)
17.         {
18.             mesh.Clear();
19.  
20.             if (vertices.Length == 0)
21.             {
22.                 return;
23.             }
24.  
25.             this.verticesList.NativeAddRange(vertices);
26.             this.uvsList.NativeAddRange(uvs);
27.             this.normalsList.NativeAddRange(normals);
28.             this.trianglesList.NativeAddRange(triangles);
29.  
30.             mesh.SetVertices(this.verticesList);
31.             mesh.SetNormals(this.normalsList);
32.             mesh.SetUVs(0, this.uvsList);
33.             mesh.SetTriangles(this.trianglesList, 0);
34.  
35.             this.verticesList.Clear();
36.             this.normalsList.Clear();
37.             this.uvsList.Clear();
38.             this.trianglesList.Clear();
39.         }

Code (CSharp):

1. public static unsafe void NativeAddRange<T>(this List<T> list, DynamicBuffer<T> dynamicBuffer)
2.             where T : struct
3.         {
4.             NativeAddRange(list, dynamicBuffer.GetBasePointer(), dynamicBuffer.Length);
5.         }
6.  
7.         private static unsafe void NativeAddRange<T>(List<T> list, void* arrayBuffer, int length)
8.             where T : struct
9.         {
10.             var index = list.Count;
11.             var newLength = index + length;
12.  
13.             // Resize our list if we require
14.             if (list.Capacity < newLength)
15.             {
16.                 list.Capacity = newLength;
17.             }
18.  
19.             var items = NoAllocHelpers.ExtractArrayFromListT(list);
20.             var size = UnsafeUtility.SizeOf<T>();
21.  
22.             // Get the pointer to the end of the list
23.             var bufferStart = (IntPtr) UnsafeUtility.AddressOf(ref items[0]);
24.             var buffer = (byte*)(bufferStart + (size * index));
25.  
26.             UnsafeUtility.MemCpy(buffer, arrayBuffer, length * (long) size);
27.  
28.             NoAllocHelpers.ResizeList(list, newLength);
29.         }

 

How did you get access to the internal NoAllocHelpers class? It doesn't appear that you're using reflection.

 

Originally I wrote methods to mimic the behaviour but it required System.Reflection.Emit which is a no go so I just ended up calling it with reflection. The reflection is cached so except for the first time, it's nearly just as fast as calling it normally.

Code (CSharp):

1.     using System;
2.     using System.Collections.Generic;
3.     using System.Reflection;
4.  
5.     using UnityEngine;
6.  
7.     /// <summary>
8.     /// Provides access to the internal UnityEngine.NoAllocHelpers methods.
9.     /// </summary>
10.     public static class NoAllocHelpers
11.     {
12.         private static readonly Dictionary<Type, Delegate> ExtractArrayFromListTDelegates = new Dictionary<Type, Delegate>();
13.         private static readonly Dictionary<Type, Delegate> ResizeListDelegates = new Dictionary<Type, Delegate>();
14.  
15.         /// <summary>
16.         /// Extract the internal array from a list.
17.         /// </summary>
18.         /// <typeparam name="T"><see cref="List{T}"/>.</typeparam>
19.         /// <param name="list">The <see cref="List{T}"/> to extract from.</param>
20.         /// <returns>The internal array of the list.</returns>
21.         public static T[] ExtractArrayFromListT<T>(List<T> list)
22.         {
23.             if (!ExtractArrayFromListTDelegates.TryGetValue(typeof(T), out var obj))
24.             {
25.                 var ass = Assembly.GetAssembly(typeof(Mesh)); // any class in UnityEngine
26.                 var type = ass.GetType("UnityEngine.NoAllocHelpers");
27.                 var methodInfo = type.GetMethod("ExtractArrayFromListT", BindingFlags.Static | BindingFlags.Public)
28.                     .MakeGenericMethod(typeof(T));
29.  
30.                 obj = ExtractArrayFromListTDelegates[typeof(T)] = Delegate.CreateDelegate(typeof(Func<List<T>, T[]>), methodInfo);
31.             }
32.  
33.             var func = (Func<List<T>, T[]>)obj;
34.             return func.Invoke(list);
35.         }
36.  
37.         /// <summary>
38.         /// Resize a list.
39.         /// </summary>
40.         /// <typeparam name="T"><see cref="List{T}"/>.</typeparam>
41.         /// <param name="list">The <see cref="List{T}"/> to resize.</param>
42.         /// <param name="size">The new length of the <see cref="List{T}"/>.</param>
43.         public static void ResizeList<T>(List<T> list, int size)
44.         {
45.             if (!ResizeListDelegates.TryGetValue(typeof(T), out var obj))
46.             {
47.                 var ass = Assembly.GetAssembly(typeof(Mesh)); // any class in UnityEngine
48.                 var type = ass.GetType("UnityEngine.NoAllocHelpers");
49.                 var methodInfo = type.GetMethod("ResizeList", BindingFlags.Static | BindingFlags.Public)
50.                     .MakeGenericMethod(typeof(T));
51.                 obj = ResizeListDelegates[typeof(T)] =
52.                     Delegate.CreateDelegate(typeof(Action<List<T>, int>), methodInfo);
53.             }
54.  
55.             var action = (Action<List<T>, int>)obj;
56.             action.Invoke(list, size);
57.         }
58.     }

 

Sweet. I was previously using reflection to manually adjust my managed list's array and size (using FieldInfo.Get/SetValue), but this is a bit faster and way easier to work with. Also doesn't have any recurring GC allocations. Thanks!

 

@GabrieleUnity Ideally we could use it on anything that is enumerable and of type Vector3 or float3. That way we dont need overloads for Lists, and all other types work too.

 

The mathematics library has been out of preview for a few months. Is there a timeline now for supporting it throughout the other libraries (but like OP I'm particularly interested in meshes)?

 

2019.3 contains some great low level index/vertex buffer access functions:
https://docs.unity3d.com/2019.3/Documentation/ScriptReference/Mesh.html

 

@julian-moschuering Thank you! This looks even better than I was expecting. It's unclear whether the mathematics library types are accepted though. I'll have to test it out when I get a moment unless someone knows offhand.

 

@julian-moschuering It looks like you may be able to set a mesh's VertexAttributeFormat, for example, with SetVertexBufferParams allowing manual specification of the data type (aka float3). I cannot find the use of these in the documentation, though.

 

You can specify the vertex format using SetVertexBufferParams and pass in the data using properly formatted NativeArray. All but Float16 are pretty straight forward. I would expect math.half to work on most platforms.

There is an example in the script reference:
https://docs.unity3d.com/2019.3/Documentation/ScriptReference/Mesh.SetVertexBufferData.html

 

Is it possible to use Mesh.SetVertexBufferParams with Position - float16 (mathemetics.half)?
I'm getting a format error on Mesh.SetVertexBufferData

 

Are there equivalent methods for setting UVs, normals and tangents manually?

Edit: jeeze, I just needed to read a little more carefully. To answer my own question in case someone else is feeling as lazy as I was, its done by creating a struct for a custom vertex layout that contains values for vertex position, normal, tangent, and uv. Then by specifying the proper data characteristics in the second argument of Mesh.SetVertexBufferParams, you can pass in an array of your custom vertex struct to get all of that in there. The VertexAttribute that corresponds with default UVs is TexCoord0. This is all in the example for Mesh.SetVertexBufferData.

 

Would it be possible to use NativeList instead of DynamicBuffer?, I'm not using Entities and i don't think i can use DynamicBuffer.

I'm thinking something like:
NativeAddRange<T>(this List<T> list, NativeList<T> aNativeList)

 

This thread is a bit dated as Unity added support for using NativeArray with SetVertices, SetUVs in 2019.3

Just use AsArray on your NativeList and pass that in.

 

I'm wondering, how would you do that with the triangles ? The mesh won't take a NativeArray in the triangles so it makes it tricky to avoid GC for me

 

Instead of using SetTrianges(), consider using SetIndices(). Not sure why SetTrianges() doesn't have a NativeArray equivalent.

 

As far as I can see, there is still no support for using NativeArrays with MaterialPropertyBlocks. Are there any plans to add this, as it basically causes the same problems?

 

Mesh "simple" API entirely supports the native arrays. Well, not entirely... One small setter still holds out against the natives ... why was that omitted? It makes no sense.



That's in Unity 2020.1.0b10 ...

 

I think you can just use

https://docs.unity3d.com/ScriptReference/Mesh.SetIndices.html

With

https://docs.unity3d.com/ScriptReference/MeshTopology.Triangles.html

 

This is interesting stuff, thanks. I would expect to see a fixed block or a GCHandle.Alloc() on the backing array though, or am I missing something?