Viktor Grigorev developer blog

MeshData mess

—

by

dr-vij
in

Hello Unity community! I’d like to talk about the improvements in the Unity Unity 2020.1 Mesh API Improvements. What makes it standout compared to the earlier versions we’ve been used to since Unity 1.5? The key advantages include enhanced speed, efficient memory use, and better integration with the Job System. For a practical comparison, I recommend reviewing the examples provided on their GitHub under MeshApiExamples. These improvements significantly boost our development capabilities, reminding us of the importance of handling such power with care.

Let me share an example where things didn’t go as planned. I attempted to create a triangle using the points (0,0,0), (0,1,0), and (1,1,0). However, I made a crucial mistake in my code.

Here’s the example code

(note: it contains a mistake):

using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using Unity.Mathematics;
using static UnityEngine.Mesh;
using UnityEngine.Rendering;

public struct MeshStruct
{
    //Textures and normals
    public float3 Normal;
    public float2 TexCoord0;

    //Positions
    public float3 Position;
}

public class MeshQuestion : MonoBehaviour
{
    [SerializeField] private MeshFilter mFilter;

    void Start()
    {
        MeshDataArray meshDataArr = AllocateWritableMeshData(1);
        var meshData = meshDataArr[0];

        //Allocate index and vector descriptors
        meshData.SetIndexBufferParams(3, IndexFormat.UInt16);
        meshData.SetVertexBufferParams(3,
            new VertexAttributeDescriptor(VertexAttribute.Position, VertexAttributeFormat.Float32, dimension: 3, stream: 0),
            new VertexAttributeDescriptor(VertexAttribute.Normal, VertexAttributeFormat.Float32, dimension: 3, stream: 0),
            new VertexAttributeDescriptor(VertexAttribute.TexCoord0, VertexAttributeFormat.Float32, dimension: 2, stream: 0));

        //Get index and vertex descriptors
        var vertexData = meshData.GetVertexData<MeshStruct>(stream: 0);
        var indexData = meshData.GetIndexData<ushort>();

        //Write index buffer data (one CW triangles)
        indexData[0] = 0; indexData[1] = 1; indexData[2] = 2;

        //Write vertex buffer data (three points)
        vertexData[0] = new MeshStruct() { Position = new float3(0, 0, 0), Normal = math.forward(), TexCoord0 = float2.zero };
        vertexData[1] = new MeshStruct() { Position = new float3(0, 1, 0), Normal = math.forward(), TexCoord0 = float2.zero };
        vertexData[2] = new MeshStruct() { Position = new float3(1, 1, 0), Normal = math.forward(), TexCoord0 = float2.zero };

        //Init submesh descriptor
        var submesh = new SubMeshDescriptor(indexStart: 0, indexCount: 3, topology: MeshTopology.Triangles);
        meshData.subMeshCount = 1;
        meshData.SetSubMesh(0, submesh);

        mFilter.mesh = new Mesh();
        ApplyAndDisposeWritableMeshData(meshDataArr, mFilter.mesh, MeshUpdateFlags.Default);
    }
}

The outcome of executing this code snippet is the creation of a mesh that encompasses 3 vertices and 3 indices, effectively forming a single triangle. Despite this, the triangle remains invisible. Additionally, the computed bounds of this mesh are of zero size, with its center positioned at (0,0,1).

Let’s delve into why this might be occurring.

The issue stems from the incorrect arrangement of fields within my structure. According to Unity’s Documentation, the attributes of a vertex within each stream must be sequentially organized in a specific order, namely:

  1. Position
  2. Normal
  3. Tangent
  4. Color
  5. TexCoord0
  6. TexCoord1
  7. TexCoord2
  8. TexCoord3
  9. TexCoord4
  10. TexCoord5
  11. TexCoord6
  12. TexCoord7
  13. BlendWeight
  14. BlendIndices.

Adhering to this sequence ensures that the data is correctly interpreted and utilized by Unity’s rendering system. Now, let’s examine the actual layout of the vertex attributes in the given code snippet to identify any discrepancies from the expected order.

public struct MeshStruct
{
    public float3 Normal;
    public float2 TexCoord0;
    public float3 Position;
}

And thats what we have in SetVertexBufferParams

meshData.SetVertexBufferParams(3,
            new VertexAttributeDescriptor(VertexAttribute.Position, VertexAttributeFormat.Float32, dimension: 3, stream: 0),
            new VertexAttributeDescriptor(VertexAttribute.Normal, VertexAttributeFormat.Float32, dimension: 3, stream: 0),
            new VertexAttributeDescriptor(VertexAttribute.TexCoord0, VertexAttributeFormat.Float32, dimension: 2, stream: 0));

The dimensions for VertexAttributeDescriptor are set as 3, 3, 2, with all being Float32. This implies an expectation for the data structure in the order of positions (3 floats), normals (3 floats), and texture coordinates (2 floats).

Given the struct layout as float3 (for normals), float2 (for texture coordinates), and float3 (for positions), it diverges from the expected sequence of PPPNNNTT (where PPP is position xyz, NNN is normal xyz, and TT is texcoord xy).

Because of this mismatch:

  • The first float3 in the struct, intended as normals, is misinterpreted as position.
  • The following float2 and part of the next float3 (specifically, the first float), intended as texture coordinates and the initial part of position, are misinterpreted as normals.
  • The remainder of the final float3 (the last two floats), intended as the rest of the position, is misinterpreted as texture coordinates.

This misinterpretation leads to incorrect vertex positions, resulting in the mesh’s bounds being centered at (0,0,1) with zero size, and vertices not displaying as expected.

Unfortunately, simply rearranging the arguments in SetVertexBufferParams does not rectify this issue, and Unity will generate a warning if the data does not match the expected layout. The solution is to align your struct’s layout with Unity’s expected order of vertex attributes.

To ensure correct rendering and avoid such data confusion:

  • Always structure your vertex data in the order Unity expects: Position, Normal, Tangent, Color, TexCoords, BlendWeights, and BlendIndices.
  • Be mindful of how Unity interprets the data based on the order and type of each attribute in your struct.

By adjusting the structure of your vertex data to align with Unity’s expectations, you can achieve the desired rendering outcome, such as drawing a correctly displayed triangle. Remember, managing data structure carefully is key to leveraging Unity’s rendering capabilities effectively.

The correct version (MeshStructFixed)

using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using Unity.Mathematics;
using static UnityEngine.Mesh;
using UnityEngine.Rendering;

public struct MeshStruct
{
    //Positions
    public float3 Position;
    //Textures and normals
    public float3 Normal;
    public float2 TexCoord0;
}

public class MeshQuestion : MonoBehaviour
{
    [SerializeField] private MeshFilter mFilter;

    void Start()
    {
        MeshDataArray meshDataArr = AllocateWritableMeshData(1);
        var meshData = meshDataArr[0];

        //Allocate index and vector descriptors
        meshData.SetIndexBufferParams(3, IndexFormat.UInt16);
        meshData.SetVertexBufferParams(3,
            new VertexAttributeDescriptor(VertexAttribute.Position, VertexAttributeFormat.Float32, dimension: 3, stream: 0),
            new VertexAttributeDescriptor(VertexAttribute.Normal, VertexAttributeFormat.Float32, dimension: 3, stream: 0),
            new VertexAttributeDescriptor(VertexAttribute.TexCoord0, VertexAttributeFormat.Float32, dimension: 2, stream: 0));

        //Get index and vertex descriptors
        var vertexData = meshData.GetVertexData<MeshStruct>(stream: 0);
        var indexData = meshData.GetIndexData<ushort>();

        //Write index buffer data (one CW triangles)
        indexData[0] = 0; indexData[1] = 1; indexData[2] = 2;

        //Write vertex buffer data (three points)
        vertexData[0] = new MeshStruct() { Position = new float3(0, 0, 0), Normal = math.forward(), TexCoord0 = float2.zero };
        vertexData[1] = new MeshStruct() { Position = new float3(0, 1, 0), Normal = math.forward(), TexCoord0 = float2.zero };
        vertexData[2] = new MeshStruct() { Position = new float3(1, 1, 0), Normal = math.forward(), TexCoord0 = float2.zero };

        //Init submesh descriptor
        var submesh = new SubMeshDescriptor(indexStart: 0, indexCount: 3, topology: MeshTopology.Triangles);
        meshData.subMeshCount = 1;
        meshData.SetSubMesh(0, submesh);

        mFilter.mesh = new Mesh();
        ApplyAndDisposeWritableMeshData(meshDataArr, mFilter.mesh, MeshUpdateFlags.Default);
    }
}

Pay close attention when crafting meshes and managing data in Unity! Doing so will help you avoid mistakes and make your development process smoother and more productive. Thank you for taking the time to read!