Efficient mesh vertex count changes from code?

Unity Engine
1

I have a mesh I am constructing in code and I want to dynamically add and remove vertices. Right now it looks to me that to change the vertex count I have to specify a completely new array for the mesh.

Is there any way to avoid this? I am thinking something along the lines of I give mesh an array of indices as well as a length, which is uses instead of the actual array length. So in that case if I had an array of 100 verts capacity I could use only 4 of those verts one time, then 10 verts the next time, etc, without having to every create new arrays and later free them. (I want to avoid dynamic constant dynamic allocation / deallocation)

As far as I know in C# there is no way to have an array point to some shared memory - ArraySegment looked promising but it doesn’t really do that. Nor can I subclass array.

Maybe there is some C++ magic that can be done to accomplish this? Again, the key goal is to allocate an array with some capacity and then feed that into mesh for vertices / indices / etc such that the length can be different from the capacity and I don’t have to allocate new arrays for each length change.

2

You could always assign it an array of 100 verts, but only triangulate 4 of them

1 Like
3

assuming that works in that case I would still need to dynamically resize the array of indices. Which is better than dynamically resizing every array I guess, but still not ideal.

4

What happenes if you pass 0,0,0 for a triangle every time? means the tris array is always the same size
You would have to change tris array every time if you want to change vertex count anyway

5

I’ll have to try, but even in the best-case scenario Unity’s code would have to run the through unused indices and reject them one by one. (Worst case would be passing them along to the actual rendering where they are rejected late / never)

6

Well I think the short answer is no, you can’t allocate an array bigger than the actual length. But you can do tricks like having more vertices than you actually use, as you guys already covered above.

Another trick to consider, if cycles are precious and memory is cheap, is to pre-allocate a separate mesh for every possible number of vertices you might need (within some range). Then, when the mesh “resizes,” you really just swap it out for one of the correct size.