Mesh data bug fix

2025-06-02 15:11 UTC o4-mini-high Open in ChatGPT ↗

You

find bugs in this script

   reflectedMeshData.Clear();

    var ray = new Ray(observer.position, observer.forward);
    Physics.Raycast(ray, out var hit, 1000f, 1 << mirrorPlane.gameObject.layer);

    if (!hit.collider) return;

    var hp = hit.point;
    var normal = hit.normal;

    var md = Mesh.AcquireReadOnlyMeshData(meshToReflect.sharedMesh);
    var mdw = Mesh.AllocateWritableMeshData(reflectedMeshData);
    var data = md[0];
    var outData = mdw[0];

    var inVerts = new NativeArray<Vector3>(data.vertexCount, Allocator.TempJob);
    var outVerts = new NativeArray<Vector3>(outData.vertexCount, Allocator.TempJob);

    var inInds = data.GetIndexData<int>();
    var outInds = outData.GetIndexData<int>();

    outData.subMeshCount = data.subMeshCount;
    outData.SetSubMesh(0,
        new SubMeshDescriptor(
            0,
            inInds.Length,
            MeshTopology.Triangles));

    data.GetVertices(inVerts);
    outData.GetVertices(outVerts);

    new ReflectPointsJob()
    {
        points = inVerts.Reinterpret<float3>(),
        normal = normal,
        rayStart = hp,
        reflectedPoints = outVerts.Reinterpret<float3>()
    }.Schedule(inVerts.Length, 128).Complete();

    outInds.CopyFrom(inInds);

    Mesh.ApplyAndDisposeWritableMeshData(mdw, reflectedMeshData);
    reflectedMeshData.RecalculateNormals();
    reflectedMeshData.RecalculateBounds();

ChatGPT

[Unsupported Content]

ChatGPT

[Unsupported Content]

ChatGPT

Below is a list of the most important problems (bugs or mis‐uses of the Mesh/MeshData API) in your snippet. For each one, I explain why it’s wrong and, where appropriate, sketch how to fix it.

---

1. Incorrectly calling AllocateWritableMeshData

   var mdw = Mesh.AllocateWritableMeshData(reflectedMeshData);

   • What’s wrong:
     The overload of Mesh.AllocateWritableMeshData(...) does not take a single Mesh instance as its argument. In current Unity versions, you either call

     // (a) allocate N MeshData slots, then apply them to an array of target Meshes:
     var mdw = Mesh.AllocateWritableMeshData(meshCount);
     // … then later: Mesh.ApplyAndDisposeWritableMeshData(mdw, new Mesh[]{ reflectedMeshData, … })

     or, if you want to allocate exactly as many slots as there are in an existing Mesh[] you pass an array:

     var mdw = Mesh.AllocateWritableMeshData(new Mesh[]{ reflectedMeshData });
     // (this returns a MeshDataArray of length = 1)

     But passing a single Mesh object is a type mismatch (there is no overload AllocateWritableMeshData(Mesh)).

   • Consequence:
     This code won’t compile (or will throw an overload‐resolution error). Even if an overload did exist, you still need to match “number of writable slots” ↔ “which meshes get written to.”

   • How to fix:
     If you only want to produce one reflected mesh, do:

     // 1) allocate exactly one writable-mesh slot
     var mdw = Mesh.AllocateWritableMeshData(1);
     // 2) later, when you’re done writing to mdw[0], apply it to reflectedMeshData:
     Mesh.ApplyAndDisposeWritableMeshData(mdw, new[] { reflectedMeshData });

     In other words, replace

     var mdw = Mesh.AllocateWritableMeshData(reflectedMeshData);

     with

     var mdw = Mesh.AllocateWritableMeshData(1);

     and then, at the bottom, call

     Mesh.ApplyAndDisposeWritableMeshData(mdw, new[] { reflectedMeshData });

     (instead of the single‐mesh overload you tried to use). This ensures you have exactly one MeshData “write slot” and that it’s applied to reflectedMeshData.

---

2. Never initializing the vertex‐ and index‐buffer parameters on the writable MeshData

   var data    = md[0];
   var outData = mdw[0];
   
   // … later:
   data.GetVertices(inVerts);
   outData.GetVertices(outVerts);
   // and then write into outVerts

   • What’s wrong:
     A freshly‐allocated MeshData (from AllocateWritableMeshData) has zero‐length vertex and index buffers by default. You must call SetVertexBufferParams(...) (and SetIndexBufferParams(...)) before you can safely read or write into its underlying GPU buffers. In your code, you never call:

     outData.SetVertexBufferParams(vertexCount,
         new VertexAttributeDescriptor( … ),
         new VertexAttributeDescriptor( … ),
         …);
     outData.SetIndexBufferParams(indexCount, IndexFormat.UInt32);

     (or whatever attributes/formats you actually need). As soon as you do outData.GetVertices(outVerts), you’re assuming that outData already has a valid vertex buffer of the right length. But it doesn’t—so at runtime you will get either an exception (“no vertex buffer exists yet”) or garbage writes into uninitialized memory.

   • Consequence:
     Even if you fix the AllocateWritableMeshData call to compile, you will crash (or silently fail) once you try to GetVertices or write into outVerts. Unity requires you to say how many vertices and exactly which vertex attributes the new MeshData will contain.

   • How to fix:
     Right after grabbing outData = mdw[0];, do something like:

     int vertexCount = data.vertexCount;
     int indexCount  = data.GetIndexData<int>().Length;
     
     // 1) Specify exactly how many vertices and which attributes you want:
     outData.SetVertexBufferParams(
         vertexCount,
         new VertexAttributeDescriptor(VertexAttribute.Position, VertexAttributeFormat.Float32, 3),
         // If you also need normals, tangents, UVs, etc., add more descriptors here:
         new VertexAttributeDescriptor(VertexAttribute.Normal,   VertexAttributeFormat.Float32, 3),
         new VertexAttributeDescriptor(VertexAttribute.Tangent,  VertexAttributeFormat.Float32, 4),
         new VertexAttributeDescriptor(VertexAttribute.TexCoord0,VertexAttributeFormat.Float32, 2)
     );
     
     // 2) Allocate the index buffer to hold exactly the same number of indices:
     outData.SetIndexBufferParams(indexCount, IndexFormat.UInt32);

     Only after those two calls may you safely call outData.GetVertices(outVerts) (which will give you a NativeArray of length vertexCount) and outData.GetIndexData<int>() (which will be a NativeArray of length indexCount) and then overwrite them in your job.

---

3. Not setting all submesh descriptors (only setting submesh 0)

   outData.subMeshCount = data.subMeshCount;
   outData.SetSubMesh(
       0,
       new SubMeshDescriptor(0, inInds.Length, MeshTopology.Triangles)
   );

   • What’s wrong:
     You copy data.subMeshCount into outData.subMeshCount, but you only ever call SetSubMesh(0, …). If data.subMeshCount > 1, submeshes 1, 2, etc. remain un‐described. In other words, you tell Unity “there are N submeshes,” but you only give the descriptor for submesh index 0. Submesh 1, 2, … have no valid (baseVertex, indexCount, topology) information, so Unity won’t know how to render them (or may throw “submesh descriptor not set” exceptions).

   • Consequence:
     If the source mesh has multiple submeshes, the reflected mesh might end up missing (or crashing on) every submesh beyond 0. In the simplest case (a single‐submesh mesh) you won’t notice right away—because data.subMeshCount == 1. But as soon as you try this on a mesh with two or more submeshes, you’ll see invalid geometry or out‐of‐bounds errors.

   • How to fix:
     Mirror every submesh exactly. For example:

     outData.subMeshCount = data.subMeshCount;
     for (int s = 0; s < data.subMeshCount; ++s)
     {
         var desc = data.GetSubMesh(s);
         // desc.indexStart, desc.indexCount, desc.topology, etc.
         outData.SetSubMesh(s, new SubMeshDescriptor(
             desc.indexStart,
             desc.indexCount,
             desc.topology
         ));
     }

     That way, each submesh is given the same (indexStart, indexCount, topology) pair as the original. Do not hard‐code 0 or assume there’s only one submesh.

---

4. Copying indices “as-is” without reversing triangle winding

   var inInds  = data.GetIndexData<int>();
   var outInds = outData.GetIndexData<int>();
   // …
   outInds.CopyFrom(inInds);

   • What’s wrong:
     Reflection across a plane flips triangle orientation. If you simply copy inInds straight into outInds, every triangle’s winding (clockwise vs. counterclockwise) remains the same. When you later RecalculateNormals(), Unity will compute normals as if the mesh were inside out. In practice, the triangles will cull or shade incorrectly (they’ll face the wrong direction). The fix is to swap two indices per triangle so that the winding gets reversed. For example, if your indices come in triples (i0, i1, i2), you must write them out as (i0, i2, i1) (or (i2, i1, i0)—anything that flips the winding).

   • Consequence:
     The mirrored mesh will appear inside-out (backfaces will be facing outward), leading to incorrect backface culling or inverted normals.

   • How to fix:
     After Schedule(...).Complete() (when you have the reflected vertex positions in place), do something like:

     int indexCount = inInds.Length;
     // newIndices will hold the “re-wound” triangles:
     NativeArray<int> newIndices = new NativeArray<int>(indexCount, Allocator.Temp);
     
     // Assume triangles (0,1,2), (3,4,5), … in a 1D array.
     for (int t = 0; t < indexCount; t += 3)
     {
         int a = inInds[t + 0];
         int b = inInds[t + 1];
         int c = inInds[t + 2];
         // Swap b and c to flip winding:
         newIndices[t + 0] = a;
         newIndices[t + 1] = c;
         newIndices[t + 2] = b;
     }
     
     outInds.CopyFrom(newIndices);
     newIndices.Dispose();

     You must do this for each submesh range separately if you have multiple submeshes. (In that case, instead of one giant loop, iterate over each SubMeshDescriptor, use its indexStart and indexCount to identify the triangle‐triples belonging to that submesh, and flip each triple in place.)

---

5. Misusing GetVertices on the writable MeshData instead of writing with SetVertices

   data.GetVertices(inVerts);
   outData.GetVertices(outVerts);
   // … job writes into outVerts.Reinterpret<float3>() …

   • What’s wrong:

     • data.GetVertices(inVerts) correctly copies the existing vertices from the read‐only mesh into inVerts.
     • But outData.GetVertices(outVerts) tries to “read” from a brand-new (uninitialized) vertex buffer—because you never called SetVertexBufferParams to allocate or size that buffer properly. In theory, once you call SetVertexBufferParams(...), you could use GetVertices(...) to get a NativeArray that wraps the newly created (zero‐initialized) buffer so that your job can write into those slots. But if you haven’t called SetVertexBufferParams yet, outData.GetVertices(...) is reading from unallocated memory.
     • Even if you do call SetVertexBufferParams first, it’s more typical to use SetVertices to upload a completed NativeArray<Vector3> of transformed vertices, rather than “fill an array returned by GetVertices.” The GetVertices path is more error‐prone.

   • Consequence:

     • Without SetVertexBufferParams, outData.GetVertices(...) will fail or give you invalid memory.
     • If you did call SetVertexBufferParams (as you should), it might give you a scratch buffer that the job can fill—but Unity’s recommendation is to call data.GetVertices(inVerts), then run your job to produce a brand‐new NativeArray<Vector3>, then after the job finishes do outData.SetVertices(reflectedVertsArray) rather than reading/writing a GetVertices buffer directly. Relying on GetVertices to return a “writable slice” is fragile and undocumented.

   • How to fix:
     Two options:

   1. “Pull out the data → job → push it back” pattern

      // 1) Read the original vertices:
      data.GetVertices(inVerts); // inVerts is NativeArray<Vector3>
      
      // 2) Create a brand-new NativeArray<Vector3> to hold the output:
      var reflectedVertsArray = new NativeArray<Vector3>(vertexCount, Allocator.TempJob);
      
      // 3) Have the job write into reflectedVertsArray.Reinterpret<float3>()
      new ReflectPointsJob()
      {
          points          = inVerts.Reinterpret<float3>(),
          normal          = normal,
          rayStart        = hp,
          reflectedPoints = reflectedVertsArray.Reinterpret<float3>()
      }
      .Schedule(inVerts.Length, 128)
      .Complete();
      
      // 4) Now push those back into outData in one shot:
      outData.SetVertices(reflectedVertsArray);
      
      // (Dispose reflectedVertsArray + inVerts later.)

   2. “Allocate buffers via SetVertexBufferParams, then use GetVertices to hand the job a pointer”

      // 1) do SetVertexBufferParams(vertexCount, …) on outData
      outData.SetVertexBufferParams(vertexCount,
          new VertexAttributeDescriptor(VertexAttribute.Position, VertexAttributeFormat.Float32, 3),
          // etc…
      );
      // 2) Now get a writable array from outData:
      var outVerts = outData.GetVertices<Vector3>();
      // (This array is zero-initialized by Unity.)
      // 3) Run the job to fill outVerts.Reinterpret<float3>().
      // 4) No need to call SetVertices again—Unity already sees outVerts as the backing memory.

      Either way, you cannot simply call outData.GetVertices(...) without first calling SetVertexBufferParams(...) (and ideally SetIndexBufferParams(...)) to size the buffers.

---

6. Not disposing your temporary NativeArray<Vector3>s (inVerts and outVerts)

   var inVerts  = new NativeArray<Vector3>(… , Allocator.TempJob);
   var outVerts = new NativeArray<Vector3>(… , Allocator.TempJob);
   // … schedule & complete the job …
   // but there is no inVerts.Dispose() or outVerts.Dispose()

   • What’s wrong:
     Anything allocated with Allocator.TempJob must be disposed before the end of the frame (ideally immediately after job completion). Otherwise Unity will warn about leaked temporary memory, and in tight loops you will exhaust the TempJob pool.

   • Consequence:
     You’ll get a warning at runtime:

     “TempJob allocator leaked 1 job memory. … Remember to call Dispose() on the NativeArray.”
     Over time (especially if this code runs every frame) you may eventually crash or see out‐of‐memory issues.

   • How to fix:
     After your job completes (i.e. right after .Complete()), dispose them:

     inVerts.Dispose();
     outVerts.Dispose();

     (If you switch to the “pull-out, job, SetVertices” pattern above, you would dispose inVerts and reflectedVertsArray once you’ve called SetVertices.)

---

7. Checking hit.collider instead of the boolean return from Physics.Raycast

   Physics.Raycast(ray, out var hit, 1000f, 1 << mirrorPlane.gameObject.layer);
   if (!hit.collider) return;

   • What’s wrong (mostly stylistic/semantic):
     The Physics.Raycast(...) call returns a bool that says “did we hit anything?” If it returns false, then hit is actually a default‐constructed RaycastHit (all fields zeroed, including collider == null). Checking if (!hit.collider) return; works in most cases, but is less clear than:

     if (!Physics.Raycast(ray, out var hit, 1000f, 1 << mirrorPlane.gameObject.layer))
         return;

     Because relying on hit.collider == null obscures the intended check. Plus, if someone later rearranges the code so that hit might get assigned from some other call, it becomes fragile.

   • How to fix:
     Rewrite as:

     if (!Physics.Raycast(ray, out var hit, 1000f, 1 << mirrorPlane.gameObject.layer))
         return;

     That way, you’re explicitly testing the boolean return. Internally, Unity still sets hit.collider = null when the raycast fails, but reading the return value is clearer.

---

8. Copying only positions, then calling RecalculateNormals()—losing other vertex attributes

   // You only reflect the vertex positions via ReflectPointsJob.
   // Then:
   Mesh.ApplyAndDisposeWritableMeshData(mdw, reflectedMeshData);
   reflectedMeshData.RecalculateNormals();
   reflectedMeshData.RecalculateBounds();

   • What’s wrong:

     • You take the original mesh, pull out only its vertex positions (GetVertices(...)), reflect them, and write them back to reflectedMeshData.
     • You never copy UVs, tangents, colors, vertex weights, or any other custom vertex streams over. As a result, your final reflectedMeshData will have valid positions but missing (or zeroed) UV coordinates, tangents, vertex‐color, bone weights, blend shapes, etc.
     • By calling RecalculateNormals(), you get “some” normals, but they may not match exactly the original mesh’s high‐quality normals or tangents. If the original mesh used a custom normal map or had smoothed‐vs‐hard edges set manually, you will lose that information.

   • Consequence:
     Your reflected mesh may appear “flat‐shaded” (if you rely on RecalculateNormals in a case where the original had custom hard edges). Texturing or normal‐mapped shading will be incorrect because UVs/tangents are gone.

   • How to fix:
     If you want a “pixel-perfect” mirror of everything except positions, you must copy all vertex streams. For instance:

     // 1) Copy positions the way you already do.
     data.GetVertices( inVerts      );
     // 2) ALSO copy normals, tangents, UVs, etc.:
     var inNormals   = new NativeArray<Vector3>(data.vertexCount, Allocator.TempJob);
     var inTangents  = new NativeArray<Vector4>(data.vertexCount, Allocator.TempJob);
     var inUVs       = new NativeArray<Vector2>(data.vertexCount, Allocator.TempJob);
     data.GetNormals(inNormals);
     data.GetTangents(inTangents);
     data.GetUVs(0, inUVs);
     
     // 3) Reflect positions *and* reflect normals/tangents appropriately:
     //     - normals should be mirrored across the plane (like: normal' = normal – 2*(n·normal)*n)
     //     - tangents should be mirrored similarly with w flipped for handedness.
     // (Your ReflectPointsJob would have to take multiple streams as input/output.)
     
     // 4) Then do: outData.SetNormals(...), outData.SetTangents(...), outData.SetUVs(...).
     // 5) After that, you may no longer need RecalculateNormals—unless you want to recalc because your job didn’t touch tangents/Uv weights, etc.

     In other words, you must copy every vertex attribute you care about (normals, tangents, UV0, UV1, colors, bone weights, blend shapes, etc.) and mirror each stream appropriately. Otherwise, the result is incomplete.

---

9. Not reversing the mesh’s winding inside each submesh’s index array

   (Closely related to #4, but worth calling out separately.)

   • What’s wrong:
     Even if you do reverse every triangle’s winding for the full index buffer, if your mesh has multiple submeshes, you must reverse each submesh’s index‐range separately. Simply doing

     outInds.CopyFrom(inInds);

     and then reversing all triplets in one big pass will mix up the submesh boundaries unless you know for certain that each submesh’s indices are laid out as contiguous triples. In Unity, a single submesh might have 6 triangles (18 indices), then submesh 1 might have another 12 triangles (36 indices), etc. You cannot treat the entire inInds array as one big continuous triangle stream unless subMeshCount==1.

   • Consequence:
     If you copy and reverse all 36 indices for submesh 1, you end up putting some of submesh 1’s indices back into submesh 0’s range. That will make your triangles talk across submesh boundaries—Unity will either raise “Index out of range for this submesh” or simply render wrong geometry.

   • How to fix:

     • Loop per‐submesh:

       for (int s = 0; s < data.subMeshCount; ++s)
       {
           var desc   = data.GetSubMesh(s);
           int start  = desc.indexStart;
           int count  = desc.indexCount;
           // assume 3 indices per triangle → triangleCount = count / 3
           for (int t = start; t < start + count; t += 3)
           {
               int a = inInds[t + 0];
               int b = inInds[t + 1];
               int c = inInds[t + 2];
               // flip winding:
               outInds[t + 0] = a;
               outInds[t + 1] = c;
               outInds[t + 2] = b;
           }
       }

     • Do not treat the entire index buffer as one monolithic block unless you know for sure your mesh has exactly one submesh.

---

10. Using Mesh.Clear() incorrectly (if intended to clear all data)

reflectedMeshData.Clear();

• What’s wrong/ambiguous:
  Calling reflectedMeshData.Clear() will remove all vertex buffers, index buffers, submeshes, etc. That is fine if your next step is to overwrite everything from scratch (which you are trying to do). But if you ever forget to re‐initialize a stream, calling Clear() means “start from zero” and you can accidentally leave out a needed attribute.

• Consequence:
  If you Clear() but then never call SetVertexBufferParams on the new data (or skip some submeshes), the final mesh ends up missing whatever you didn’t explicitly set.

• How to fix:
  Make sure that right after you call Clear(), you go through the full “set vertex buffer / set index buffer / set submesh descriptors / copy all streams” process. If you accidentally skip something, the mesh may be half‐initialized.

---

Putting it all together: a corrected outline

Below is a minimal, “end-to-end” sketch showing how you might fix all of the above in one coherent block. (I’ve omitted the actual job that does reflection—it’s assumed to exist.)

// 1) Raycast against the mirror plane:
var ray = new Ray(observer.position, observer.forward);
if (!Physics.Raycast(ray, out var hit, 1000f, 1 << mirrorPlane.gameObject.layer))
    return;

Vector3 hp     = hit.point;   // hit position on the plane
Vector3 normal = hit.normal;  // plane normal at the hit

// 2) Acquire the original mesh data
var rdArray = Mesh.AcquireReadOnlyMeshData(meshToReflect.sharedMesh);
var readMd  = rdArray[0];
int vertexCount = readMd.vertexCount;
var inInds  = readMd.GetIndexData<int>();
int indexCount  = inInds.Length;

// 3) Allocate exactly one writable MeshData slot
var writeMdArray = Mesh.AllocateWritableMeshData(1);
var writeMd      = writeMdArray[0];

// 4) Clear the existing reflected mesh (start fresh)
reflectedMeshData.Clear();

// 5) Copy submesh count, then set each descriptor
int subMeshCount = readMd.subMeshCount;
writeMd.subMeshCount = subMeshCount;
for (int s = 0; s < subMeshCount; ++s)
{
    // Copy each submesh descriptor verbatim:
    var desc = readMd.GetSubMesh(s);
    writeMd.SetSubMesh(s, new SubMeshDescriptor(
        desc.indexStart,
        desc.indexCount,
        desc.topology
    ));
}

// 6) Set up vertex‐ and index‐buffers on the writable MeshData
writeMd.SetVertexBufferParams(
    vertexCount,
    new VertexAttributeDescriptor(VertexAttribute.Position, VertexAttributeFormat.Float32, 3),
    new VertexAttributeDescriptor(VertexAttribute.Normal,   VertexAttributeFormat.Float32, 3),
    new VertexAttributeDescriptor(VertexAttribute.Tangent,  VertexAttributeFormat.Float32, 4),
    new VertexAttributeDescriptor(VertexAttribute.TexCoord0,VertexAttributeFormat.Float32, 2),
    new VertexAttributeDescriptor(VertexAttribute.Color,    VertexAttributeFormat.Float32, 4)
    // (add more descriptors if your mesh has UV2, UV3, bone weights, etc.)
);

writeMd.SetIndexBufferParams(
    indexCount,
    IndexFormat.UInt32
);

// 7) Allocate and fill NativeArrays for each stream:

// Positions (float3)
var inVerts      = new NativeArray<Vector3>(vertexCount, Allocator.TempJob);
var reflectedPts = new NativeArray<Vector3>(vertexCount, Allocator.TempJob);
readMd.GetVertices(inVerts);

// Normals (float3)
var inNormals    = new NativeArray<Vector3>(vertexCount, Allocator.TempJob);
var reflectedNrm = new NativeArray<Vector3>(vertexCount, Allocator.TempJob);
readMd.GetNormals(inNormals);

// Tangents (float4)
var inTngs       = new NativeArray<Vector4>(vertexCount, Allocator.TempJob);
var reflectedTng = new NativeArray<Vector4>(vertexCount, Allocator.TempJob);
readMd.GetTangents(inTngs);

// UV0 (float2)
var inUVs        = new NativeArray<Vector2>(vertexCount, Allocator.TempJob);
var reflectedUVs = new NativeArray<Vector2>(vertexCount, Allocator.TempJob);
readMd.GetUVs(0, inUVs);

// Colors (float4)
var inCols       = new NativeArray<Color>(vertexCount, Allocator.TempJob);
var reflectedCl  = new NativeArray<Color>(vertexCount, Allocator.TempJob);
readMd.GetColors(inCols);

// (If you have bone weights, blend shapes, etc., do them here.)

// 8) Schedule your reflect‐job, passing all streams:
new ReflectPointsJob()
{
    points          = inVerts      .Reinterpret<float3>(),
    normals         = inNormals    .Reinterpret<float3>(),
    tangents        = inTngs       .Reinterpret<float4>(),
    uvs             = inUVs        .Reinterpret<float2>(),
    colors          = inCols       .Reinterpret<float4>(),

    planeNormal     = normal,
    planePoint      = hp,

    outPoints       = reflectedPts .Reinterpret<float3>(),
    outNormals      = reflectedNrm .Reinterpret<float3>(),
    outTangents     = reflectedTng .Reinterpret<float4>(),
    outUVs          = reflectedUVs .Reinterpret<float2>(),
    outColors       = reflectedCl  .Reinterpret<float4>(),
}
.Schedule(vertexCount, 128)
.Complete();

// 9) Write back each stream into the writable MeshData
writeMd.SetVertices   (reflectedPts);
writeMd.SetNormals    (reflectedNrm);
writeMd.SetTangents   (reflectedTng);
writeMd.SetUVs        (0, reflectedUVs);
writeMd.SetColors     (reflectedCl);

// 10) Take care of index buffer with reversed winding:
var outInds = writeMd.GetIndexData<int>();
// First, copy raw indices so we have the same array length:
outInds.CopyFrom(inInds);
// Then reverse‐winding per‐submesh:
for (int s = 0; s < subMeshCount; ++s)
{
    var desc = readMd.GetSubMesh(s);
    int start  = desc.indexStart;
    int count  = desc.indexCount; // must be divisible by 3

    for (int t = start; t < start + count; t += 3)
    {
        int a = inInds[t + 0];
        int b = inInds[t + 1];
        int c = inInds[t + 2];
        outInds[t + 0] = a;
        outInds[t + 1] = c;
        outInds[t + 2] = b;
    }
}

// 11) Apply the MeshData to the target mesh and release resources
Mesh.ApplyAndDisposeWritableMeshData(writeMdArray, new[] { reflectedMeshData });

// 12) Dispose all temp jobs
inVerts.Dispose();
reflectedPts.Dispose();
inNormals.Dispose();
reflectedNrm.Dispose();
inTngs.Dispose();
reflectedTng.Dispose();
inUVs.Dispose();
reflectedUVs.Dispose();
inCols.Dispose();
reflectedCl.Dispose();

// 13) Optionally recalc bounds if you want Unity to update them automatically
reflectedMeshData.RecalculateBounds();
// (No need to RecalculateNormals(), since we provided mirrored normals explicitly.)

---

Summary of the “biggest” bugs in your original code

1. AllocateWritableMeshData(reflectedMeshData) is the wrong overload.
   You must call AllocateWritableMeshData(1) (or pass a Mesh[]), then later apply with Mesh.ApplyAndDisposeWritableMeshData(writeMdArray, new[] { reflectedMeshData }).

2. Never calling SetVertexBufferParams / SetIndexBufferParams on the new MeshData.
   Without those calls, the writable‐mesh buffer has zero length and you cannot safely GetVertices or GetIndexData on it.

3. Only setting submesh 0’s descriptor despite copying subMeshCount from the original.
   Each submesh needs its own SetSubMesh(...) call.

4. Copying the index array “as is” (with CopyFrom) instead of reversing each triangle’s winding per submesh.
   Reflection across a plane flips winding; if you don’t swap two indices in each triple, the mirrored triangles face the wrong way.

5. Using outData.GetVertices(outVerts) without having initialized outData’s vertex buffer.
   You either need to call SetVertexBufferParams first and then let the job write into that buffer, or gather your own NativeArray of new positions and call SetVertices(...) explicitly.

6. Leaking NativeArray<Vector3> objects (inVerts, outVerts) by not calling .Dispose().
   Anything allocated with Allocator.TempJob must be disposed immediately after job completion.

7. Copying only positions, then calling RecalculateNormals(), so you lose UVs, tangents, colors, bone weights, etc.
   If you want a full, faithful mirror of the original mesh, you must copy and reflect every vertex attribute you care about, not just the position. Simply calling RecalculateNormals() is not enough if the original used custom normals or had arbitrary hard edges/tangents.

8. Checking hit.collider instead of the bool return of Physics.Raycast().
   It’s more idiomatic (and less error-prone) to write:

   if (!Physics.Raycast(ray, out var hit, maxDistance, layerMask)) return;

   rather than relying on hit.collider == null.

Once you fix those core issues—correctly allocating/wiring up the MeshData, reversing winding per submesh, copying every attribute, and disposing each NativeArray—the reflection code will compile and run as intended.

You

how to fast copy the indices regardless of their type (u16, u32)?

ChatGPT

[Unsupported Content]

ChatGPT

[Unsupported Content]

ChatGPT

You can avoid worrying about 16-bit vs. 32-bit indices by copying the raw index‐buffer bytes directly. In Unity’s MeshData API, that means using GetIndexData<byte>() on both the source and the destination, and doing a straight CopyFrom. Here’s the outline:

// 1) Read the source MeshData (readMd) and grab its index format + total index-count:
var readMd       = Mesh.AcquireReadOnlyMeshData(sourceMesh)[0];
var srcFormat    = readMd.indexFormat;           // either IndexFormat.UInt16 or UInt32
int indexCount   = readMd.GetIndexDataCount();   // total number of indices

// 2) On the writable MeshData (writeMd), use the same format and count:
writeMd.SetIndexBufferParams(indexCount, srcFormat);

// 3) Get the “raw bytes” arrays from both:
var srcRaw  = readMd .GetIndexData<byte>(); // length == indexCount * (srcFormat==UInt16 ? 2 : 4)
var dstRaw  = writeMd.GetIndexData<byte>();

// 4) Copy all bytes in one shot:
dstRaw.CopyFrom(srcRaw);

// 5) (Later, after you’ve flipped winding or whatever, you’ll ApplyAndDisposeWritableMeshData.)

Because you’re grabbing GetIndexData<byte>(), you never need to know whether the underlying data is UInt16 or UInt32. Unity will lay out exactly indexCount * sizeof(indexFormat) bytes in both srcRaw and dstRaw, so the CopyFrom will just memcpy the entire buffer regardless of 16- vs. 32-bit.

You

this is my unity code using jobs and collections. I get an error about indices mismatching

using System; using Unity.Burst; using Unity.Collections; using Unity.Jobs; using UnityEngine; using Unity.Mathematics; using UnityEngine.Rendering;

[ExecuteAlways] public class MeshMirroring : MonoBehaviour { public Transform pointToReflect; public MeshFilter meshToReflect;

public MeshFilter reflectedMesh;

public Transform observer;
public Transform mirrorPlane;

public Vector3 rayStart;
public Vector3 reflectedPoint;
public Vector3 inverseReflectedPoint;

private Mesh reflectedMeshData;

// Start is called once before the first execution of Update after the MonoBehaviour is created
private void OnEnable()
{
    if (reflectedMesh.sharedMesh) return;

    reflectedMeshData = new Mesh();
    reflectedMesh.sharedMesh = reflectedMeshData;
}

// Update is called once per frame
private void Update()
{
    if (!meshToReflect || !meshToReflect.sharedMesh || !reflectedMesh.sharedMesh)
        return;

    reflectedMeshData.Clear();

    var ray = new Ray(observer.position, observer.forward);
    Physics.Raycast(ray, out var hit, 1000f, 1 << mirrorPlane.gameObject.layer);

    if (!hit.collider) return;

    var hp = hit.point;
    var normal = hit.normal;

    var inMesh = Mesh.AcquireReadOnlyMeshData(meshToReflect.sharedMesh);
    var outMesh = Mesh.AllocateWritableMeshData(reflectedMeshData);
    var inData = inMesh[0];
    var outData = outMesh[0];

    var vertexCount = inData.vertexCount;
    var indexCount  = inData.indexFormat == IndexFormat.UInt16 ?
        inData.GetIndexData<ushort>().Length : inData.GetIndexData<uint>().Length;

    // 1) Specify exactly how many vertices and which attributes you want:
    outData.SetVertexBufferParams(
        vertexCount,
        new VertexAttributeDescriptor(
            VertexAttribute.Position,
            VertexAttributeFormat.Float32,
            3),
        // If you also need normals, tangents, UVs, etc., add more descriptors here:
        new VertexAttributeDescriptor(VertexAttribute.Normal,   VertexAttributeFormat.Float32, 3, stream:1),
        new VertexAttributeDescriptor(VertexAttribute.TexCoord0,VertexAttributeFormat.Float32, 2, stream:1)
    );

    // 2) Allocate the index buffer to hold exactly the same number of indices:
    outData.SetIndexBufferParams(indexCount, inData.indexFormat);
    outData.subMeshCount = inData.subMeshCount;
    outData.SetSubMesh(0, new SubMeshDescriptor(0, indexCount, MeshTopology.Triangles));;

    for (var s = 0; s < inData.subMeshCount; ++s)
    {
        var desc = inData.GetSubMesh(s);
        // desc.indexStart, desc.indexCount, desc.topology, etc.
        outData.SetSubMesh(s, new SubMeshDescriptor(
            desc.indexStart,
            desc.indexCount,
            desc.topology
        ));
    }

    var inVerts = new NativeArray<Vector3>(vertexCount, Allocator.TempJob);
    inData.GetVertices(inVerts);
    var outVerts = outData.GetVertexData<float3>();

    new ReflectPointsJob()
    {
        points = inVerts.Reinterpret<float3>(),
        normal = normal,
        rayStart = hp,
        reflectedPoints = outVerts
    }.Schedule(inVerts.Length, 128).Complete();


    // 3) Get the “raw bytes” arrays from both:
    var srcRaw  = inData .GetIndexData<byte>(); // length == indexCount * (srcFormat==UInt16 ? 2 : 4)
    var dstRaw  = outData.GetIndexData<byte>();

    // 4) Copy all bytes in one shot:
    dstRaw.CopyFrom(srcRaw);

    Mesh.ApplyAndDisposeWritableMeshData(outMesh, reflectedMeshData);
    reflectedMeshData.RecalculateNormals();
    reflectedMeshData.RecalculateBounds();
}

[BurstCompile]
struct ReflectPointsJob:IJobParallelFor
{
    [ReadOnly]
    public NativeArray<float3> points;

    [WriteOnly]
    public NativeArray<float3> reflectedPoints;

    public float3 rayStart;
    public float3 normal;

    public void Execute(int index)
    {
        var dir = rayStart - points[index];
        reflectedPoints[index] = rayStart - math.reflect(dir, normal);
    }
}

private void OnDrawGizmos()
{
    Gizmos.DrawLine(rayStart, reflectedPoint);
    Gizmos.DrawLine(rayStart, observer.position);
    Gizmos.DrawLine(rayStart, pointToReflect.position);
    Gizmos.DrawLine(rayStart, inverseReflectedPoint);

    Gizmos.color = Color.red;
    Gizmos.DrawSphere(reflectedPoint, 0.05f);
    Gizmos.color = Color.green;
    Gizmos.DrawSphere(inverseReflectedPoint, 0.05f);

}

}

ChatGPT

[Unsupported Content]

ChatGPT

[Unsupported Content]

ChatGPT

You can treat the index buffer as a raw byte‐array—Unity will lay it out as either 2 bytes per index (UInt16) or 4 bytes per index (UInt32). By asking for GetIndexData<byte>() on both the source and destination MeshData, you never have to branch on “is it 16 bit or 32 bit?”; you simply memcpy the entire buffer in one go.

Below is a minimal snippet showing how to do this “byte‐wise” copy. Make sure that:

1. You read the source’s indexFormat.
2. You call SetIndexBufferParams(totalIndexCount, sourceFormat) on the writable MeshData.
3. You call GetIndexData<byte>() on both the read‐only and the writable MeshData.
4. You CopyFrom(...) the raw byte‐array.

// 1) Acquire the read‐only MeshData and grab its indexFormat + index‐count:
var readMdArray = Mesh.AcquireReadOnlyMeshData(meshToReflect.sharedMesh);
var readMd      = readMdArray[0];

IndexFormat srcFormat  = readMd.indexFormat;               // UInt16 or UInt32
int indexCount         = readMd.GetIndexDataCount();       // total # of indices

// 2) Allocate exactly one writable slot and clear the target Mesh
var writeMdArray = Mesh.AllocateWritableMeshData(1);
var writeMd      = writeMdArray[0];
reflectedMeshData.Clear();

// 3) (Re‐create your submeshes / vertex buffers here…)

// 4) Tell Unity “I want an index buffer of length = indexCount, in the same format as the source”:
writeMd.SetIndexBufferParams(indexCount, srcFormat);

// 5) Now grab the raw bytes from both the read‐only and the writable buffers:
NativeArray<byte> srcRaw = readMd .GetIndexData<byte>();
NativeArray<byte> dstRaw = writeMd.GetIndexData<byte>();

// 6) Just memcpy all bytes at once. This works whether srcFormat == UInt16 or UInt32:
dstRaw.CopyFrom(srcRaw);

// 7) Finally, apply & dispose:
Mesh.ApplyAndDisposeWritableMeshData(writeMdArray, reflectedMeshData);
readMdArray.Dispose();

That’s it. By calling GetIndexData<byte>(), Unity will hand you a NativeArray<byte> whose length is exactly:

    indexCount * (srcFormat == UInt16 ? 2 : 4)

So CopyFrom(srcRaw) automatically copies the entire index buffer, regardless of whether the mesh was using 16‐bit or 32‐bit indices under the hood.

---

Extra tip (for mirroring‐or‐reflection scenarios)
If you’re reflecting a mesh, note that simply copying the indices “as‐is” will give you reversed winding (triangles become inside‐out). If your goal is to mirror across a plane, you’ll still need to flip each triangle’s winding in place. You can either:

1. Copy the raw bytes, then—in a separate loop—swap two indices in each triangle (e.g. (i0,i1,i2) → (i0,i2,i1)), or
2. Decode into a typed array (GetIndexData<ushort>() or GetIndexData<uint>()), flip winding per‐triangle in that typed array, and then re‐upload.

But for a pure “copy without caring about 16 vs 32” just use GetIndexData<byte>() + CopyFrom(...) as shown above.

You

ArgumentException: Index buffer element #0 (value 21807) is out of bounds; mesh only has 24 vertices. UnityEngine.Mesh+MeshData.SetSubMeshImpl (System.IntPtr self, System.Int32 index, UnityEngine.Rendering.SubMeshDescriptor desc, UnityEngine.Rendering.MeshUpdateFlags flags) (at :0) UnityEngine.Mesh+MeshData.SetSubMesh (System.Int32 index, UnityEngine.Rendering.SubMeshDescriptor desc, UnityEngine.Rendering.MeshUpdateFlags flags) (at /Users/bokken/build/output/unity/unity/Runtime/Export/Graphics/MeshData.cs:433) MeshMirroring.Update () (at Assets/Scripts/MeshMirroring.cs:75)

ChatGPT

[Unsupported Content]

ChatGPT

[Unsupported Content]

ChatGPT

The short answer is: at the moment you call SetSubMesh(…), Unity is already trying to validate “are all the indices in this submesh < vertexCount ?” Since you have only just done SetIndexBufferParams(…) but haven’t yet copied your index‐bytes in, the index buffer still contains garbage data (uninitialized memory). That garbage index #0 happens to be 21807, which is > 23, so Unity throws “Index buffer element #0 (value 21807) is out of bounds; mesh only has 24 vertices.”

Below is a step‐by‐step explanation of what’s happening and how to fix it:

---

1. Why the exception is thrown

1. You do:

   outData.SetIndexBufferParams(indexCount, inData.indexFormat);
   outData.subMeshCount = inData.subMeshCount;
   outData.SetSubMesh(0, new SubMeshDescriptor(0, indexCount, MeshTopology.Triangles));
   for (var s = 0; s < inData.subMeshCount; ++s)
   {
       var desc = inData.GetSubMesh(s);
       outData.SetSubMesh(s, new SubMeshDescriptor(desc.indexStart, desc.indexCount, desc.topology));
   }

2. Internally, SetSubMesh(s, descriptor) performs a quick validation pass:
   • For each index in the range [descriptor.indexStart .. indexStart + indexCount) it reads the u16/u32 value out of the index buffer, and checks indexValue < vertexCount.
   • But right now you have called SetIndexBufferParams(...) on a brand‐new MeshData. That allocates an index buffer of the correct size (e.g. 24 indices × 2 bytes = 48 bytes), but its contents are uninitialized. In other words, until you do GetIndexData<byte>().CopyFrom(...), that memory is full of random junk (21807 in your case).
   • So when SetSubMesh(…) tries to validate index #0, it sees “21807” (the garbage), and complains “out of bounds; mesh only has 24 vertices.”

In short: you are calling SetSubMesh before you actually wrote valid index data into the new index buffer. Unity sees invalid indices and immediately throws.

---

2. How to fix it

You have two main options:

1. Copy the raw‐index bytes first, then call SetSubMesh(…)
2. Tell Unity “don’t validate indices right now” by using MeshUpdateFlags.DontValidateIndices when you call SetSubMesh (and validate after you’ve copied them).

Below is the more common (and recommended) approach: copy your index buffer bytes before setting submeshes.

2.1 Reorder so that CopyFrom(srcRaw) happens before SetSubMesh(...)

Move this block:

// 3) Get the “raw bytes” arrays from both:
var srcRaw  = inData .GetIndexData<byte>();
var dstRaw  = outData.GetIndexData<byte>();

// 4) Copy all bytes in one shot:
dstRaw.CopyFrom(srcRaw);

to before any call to outData.SetSubMesh(...). In other words, you should:

1. SetIndexBufferParams(...)
2. Copy the raw bytes from inData.GetIndexData<byte>() → outData.GetIndexData<byte>()
3. THEN set outData.subMeshCount = … and loop over SetSubMesh(...)

Practically, your corrected sequence in Update() would look roughly like this (only showing the relevant index/submesh section):

// … after you've called:
//    var inMesh = Mesh.AcquireReadOnlyMeshData(meshToReflect.sharedMesh);
//    var outMesh = Mesh.AllocateWritableMeshData(reflectedMeshData);
//    var inData  = inMesh[0];
//    var outData = outMesh[0];
//    var vertexCount = inData.vertexCount;
//    var indexCount  = (inData.indexFormat == IndexFormat.UInt16)
//                        ? inData.GetIndexData<ushort>().Length
//                        : inData.GetIndexData<uint>().Length;

// 1) Allocate the new index buffer with the same format & count:
outData.SetIndexBufferParams(indexCount, inData.indexFormat);

// 2) Copy the raw bytes from the old index buffer into the new one:
{
    // read‐only side:
    NativeArray<byte> srcRaw = inData.GetIndexData<byte>();
    // writable side:
    NativeArray<byte> dstRaw = outData.GetIndexData<byte>();
    dstRaw.CopyFrom(srcRaw);
    // <-- now outData’s index buffer is fully populated with valid indices
}

// 3) Now that indices are in place, define submeshes:
outData.subMeshCount = inData.subMeshCount;
for (int s = 0;  s < inData.subMeshCount;  ++s)
{
    var desc = inData.GetSubMesh(s);
    outData.SetSubMesh(
        s,
        new SubMeshDescriptor(
            desc.indexStart,
            desc.indexCount,
            desc.topology
        )
    );
}

// 4) … proceed to SetVertexBufferParams, schedule your job for vertices, etc.
//    and finally do:
//    Mesh.ApplyAndDisposeWritableMeshData(outMesh, reflectedMeshData);
//    reflectedMeshData.RecalculateNormals();
//    reflectedMeshData.RecalculateBounds();

By copying the actual index bytes into outData first, the call to SetSubMesh(...) now sees a valid index buffer (every index < vertexCount), so no exception is thrown.

---

2.2 Alternative: Skip Unity’s index‐validation temporarily

If you’d rather keep your original ordering of “SetSubMesh → CopyFrom,” you can tell Unity “skip validation on this SetSubMesh call.” That looks like:

outData.subMeshCount = inData.subMeshCount;

// When calling SetSubMesh, pass MeshUpdateFlags.DontValidateIndices:
for (int s = 0; s < inData.subMeshCount; ++s)
{
    var desc = inData.GetSubMesh(s);
    outData.SetSubMesh(
        s,
        new SubMeshDescriptor(desc.indexStart, desc.indexCount, desc.topology),
        MeshUpdateFlags.DontValidateIndices  // <— skip index bounds‐checking for now
    );
}

// … now copy raw bytes:
var srcRaw = inData .GetIndexData<byte>();
var dstRaw = outData.GetIndexData<byte>();
dstRaw.CopyFrom(srcRaw);

// Finally:
Mesh.ApplyAndDisposeWritableMeshData(outMesh, reflectedMeshData);

Because you passed DontValidateIndices, Unity will wait until you actually do ApplyAndDisposeWritableMeshData(...) to do a final validation pass. That final pass will succeed because by then your index buffer is already filled with valid indices.

---

3. Step‐by‐step “corrected” Update() snippet

Below is a more complete sketch of your Update() body showing exactly where to move the index‐copy so that no “out of bounds” error ever fires. I’ve omitted some details (like vertex‐jobs and UV/normal copying) so you can clearly see just the index/submesh reordering:

private void Update()
{
    if (!meshToReflect || !meshToReflect.sharedMesh || !reflectedMesh.sharedMesh)
        return;

    reflectedMeshData.Clear();

    // Raycast against the mirror plane…
    var ray = new Ray(observer.position, observer.forward);
    if (!Physics.Raycast(ray, out var hit, 1000f, 1 << mirrorPlane.gameObject.layer))
        return;

    Vector3 hp     = hit.point;
    Vector3 normal = hit.normal;

    // Acquire read-only mesh data
    var inMesh  = Mesh.AcquireReadOnlyMeshData(meshToReflect.sharedMesh);
    var inData  = inMesh[0];

    // Allocate exactly 1 writable slot for the reflectedMesh
    var outMesh = Mesh.AllocateWritableMeshData(1);
    var outData = outMesh[0];

    // Count vertices and indices in the source
    int vertexCount = inData.vertexCount;
    int indexCount = (inData.indexFormat == IndexFormat.UInt16)
                     ? inData.GetIndexData<ushort>().Length
                     : inData.GetIndexData<uint>().Length;

    // ─── A) SET UP INDEX BUFFER & COPY GENERIC “RAW” INDICES FIRST ─────────
    outData.SetIndexBufferParams(indexCount, inData.indexFormat);

    // Copy index bytes (works for U16 or U32 automatically)
    {
        NativeArray<byte> srcRaw = inData .GetIndexData<byte>();
        NativeArray<byte> dstRaw = outData.GetIndexData<byte>();
        dstRaw.CopyFrom(srcRaw);
        // Now outData’s index buffer is filled with the same indices as inData
    }

    // ─── B) NOW DEFINE EACH SUBMESH (indices are valid, so no more “out of bounds”) ───
    outData.subMeshCount = inData.subMeshCount;
    for (int s = 0; s < inData.subMeshCount; ++s)
    {
        var desc = inData.GetSubMesh(s);
        outData.SetSubMesh(
            s,
            new SubMeshDescriptor(
                desc.indexStart,
                desc.indexCount,
                desc.topology
            )
        );
    }

    // ─── C) SET UP VERTEX BUFFER PARAMS ────────────────────────────────────────────
    outData.SetVertexBufferParams(
        vertexCount,
        new VertexAttributeDescriptor(VertexAttribute.Position,   VertexAttributeFormat.Float32, 3),
        new VertexAttributeDescriptor(VertexAttribute.Normal,     VertexAttributeFormat.Float32, 3, stream: 1),
        new VertexAttributeDescriptor(VertexAttribute.TexCoord0,  VertexAttributeFormat.Float32, 2, stream: 1)
        // add more attributes if needed (e.g. tangents, colors, UV1, etc.)
    );

    // ─── D) MIRROR POINTS VIA JOB ──────────────────────────────────────────────────
    var inVerts = new NativeArray<Vector3>(vertexCount, Allocator.TempJob);
    inData.GetVertices(inVerts);
    var outVerts = outData.GetVertexData<float3>();  // already zero-initialized

    new ReflectPointsJob()
    {
        points          = inVerts.Reinterpret<float3>(),
        normal          = normal,
        rayStart        = hp,
        reflectedPoints = outVerts
    }.Schedule(vertexCount, 128).Complete();

    inVerts.Dispose();

    // ─── E) APPLY & CLEAN UP ───────────────────────────────────────────────────────
    Mesh.ApplyAndDisposeWritableMeshData(outMesh, reflectedMeshData);
    inMesh.Dispose(); // dispose the read-only mesh data

    // Recalculate bounds & normals if you only copied positions:
    // (If you also mirror normals/tangents in your job, you can skip RecalculateNormals.)
    reflectedMeshData.RecalculateNormals();
    reflectedMeshData.RecalculateBounds();
}

Key points of this reorder:

1. SetIndexBufferParams(indexCount, inData.indexFormat)
   Allocates an index buffer of the correct size (but its contents are uninitialized).

2. Immediately do

   var srcRaw = inData.GetIndexData<byte>();
   var dstRaw = outData.GetIndexData<byte>();
   dstRaw.CopyFrom(srcRaw);

   That MemCpy’s all the 2‐or‐4 bytes‐per‐index bytes from the original mesh into the new buffer in one go—exactly the “copy regardless of u16 vs. u32” trick.

3. Only then call outData.SetSubMesh(s, SubMeshDescriptor(…)). Because the index buffer is already filled with valid indices by step 2, Unity’s internal validation indexValue < vertexCount will succeed.

4. Finally, you can set your vertex attributes, schedule your job, then do ApplyAndDisposeWritableMeshData(...).

---

4. If you still want to keep “SetSubMesh → CopyFrom” order

If you absolutely must set submeshes before copying the indices, you can suppress Unity’s “check all the indices right now” by passing MeshUpdateFlags.DontValidateIndices:

outData.SetIndexBufferParams(indexCount, inData.indexFormat);
outData.subMeshCount = inData.subMeshCount;

for (int s = 0; s < inData.subMeshCount; ++s)
{
    var desc = inData.GetSubMesh(s);
    outData.SetSubMesh(
        s,
        new SubMeshDescriptor(desc.indexStart, desc.indexCount, desc.topology),
        MeshUpdateFlags.DontValidateIndices
    );
}
// ─── index buffer still garbage here ───

var srcRaw = inData .GetIndexData<byte>();
var dstRaw = outData.GetIndexData<byte>();
dstRaw.CopyFrom(srcRaw);  // now the buffer is valid

Mesh.ApplyAndDisposeWritableMeshData(outMesh, reflectedMeshData);

In that approach, Unity won’t complain inside SetSubMesh(…, DontValidateIndices). The final validation happens only when you call ApplyAndDisposeWritableMeshData(...) (by which point the raw bytes have been copied).

However, the cleanest fix is to do “copy‐indices → setSubMesh” in that order.

---

Summary

• Root cause: you were calling SetSubMesh(...) while the writable index buffer still held uninitialized (garbage) data, so Unity saw index #0 = 21807 > (24 – 1) and threw “out of bounds.”
• Fix: either copy the raw byte[] indices first (via GetIndexData<byte>().CopyFrom(…)), then call SetSubMesh(...); or, if you must set submesh descriptors first, pass MeshUpdateFlags.DontValidateIndices to SetSubMesh(…) and only let Unity validate once you call ApplyAndDisposeWritableMeshData(...).

Reordering to “SetIndexBufferParams → CopyIndexBytes → SetSubMesh → …” is by far the most straightforward. That way, as soon as you define each submesh, the indices are already valid, and Unity never throws the “index out of bounds” error.