Is it actually possible to dynamically batch 300+ vertice mesh ?

Unity Engine
1

I’m gonna take one more angle at my problem of getting dynamic batching to work.

Recap: This answer lets you understand 900 is the max vertice count that can be batched dynamically.
The actual documentation doesn’t deny nor confirm it.

But can anyone make these meshes actually batch ? The script should work by just slapping it on the camera in an empty scene.

Looks like 300 is actually the hard limit (double click on any of the meshes on the created prefabs to see vertice count). Or do i have to change something in project settings to go over 300 ? You can reduce vertice count by reducing “quadsW” to 12 → they will batch.

using UnityEngine;
using System.Collections;
using System.Collections.Generic;

public class VertexTest : MonoBehaviour
{
    void Start ()
    {
        const int quadsW = 13;
        const int quadsH = 6;

        List<Vector3> verts = new List<Vector3>();
        List<int> tris = new List<int>();

        for (int qx = 0; qx < quadsW; qx++)
        {
            for (int qy = 0; qy < quadsH; qy++)
            {
                makeSquare(qx, qy, 0, verts, tris);
            }
        }

        Mesh m = new Mesh();
        m.Clear ();
        m.vertices = verts.ToArray();
        m.triangles = tris.ToArray();
        m.uv = null;//new Vector2[verts.Count];
        m.uv1 = null;//new Vector2[verts.Count];
        m.uv2 = null;//new Vector2[verts.Count];
        m.colors32 = null;//new Color32[verts.Count];
        m.colors = null;//new Color[verts.Count];
        m.normals = null;//new Vector3[verts.Count];
        m.Optimize ();
        m.RecalculateNormals ();

        Material mat = new Material(Shader.Find("Mobile/VertexLit"));

        const int gameobjectsW = 4;
        const int gameobjectsH = 4;
       
        for (int x = 0; x < gameobjectsW; x++)
        {
            for (int y = 0; y < gameobjectsH; y++)
            {
                GameObject go = new GameObject(x+", "+y);
                go.transform.position = new Vector3((x*quadsW) + x, (y*quadsH) + y);

                MeshRenderer mr = go.AddComponent<MeshRenderer>();
                MeshFilter mf = go.AddComponent<MeshFilter>();
                mf.sharedMesh = m;
                mr.castShadows = false;
                mr.receiveShadows = false;
                mr.sharedMaterial = mat;
            }
        }

        Camera.main.transform.position = new Vector3(gameobjectsW * (quadsW+1), gameobjectsH * (quadsH+1), -50 ) / 2f;
    }
   
    void makeSquare(int x, int y, int z, List<Vector3> verts, List<int> tris)
    {
        int statrCount = verts.Count;
        verts.Add (new Vector3(x, y, z));
        verts.Add (new Vector3(x, y+1, z));
        verts.Add (new Vector3(x+1, y+1, z));
        verts.Add (new Vector3(x+1, y, z));

        tris.Add(statrCount);
        tris.Add(statrCount+1);
        tris.Add(statrCount+2);

        tris.Add(statrCount);
        tris.Add(statrCount+2);
        tris.Add(statrCount+3);
    }
}
2

Vertex data can mean a lot of things. Can carry more than just position information - things like colour, uv1, uv2, tangent, normal etc. etc.

Not sure if that would make a difference but maybe worth looking at?

3

Are you using the batching to combine meshes that change all the time ore do you just like to combine stuff that instantiate at run-time?
If the meshes do not change / move you can use the StaticBatchingUtility to combine them at run-time.
Then i acts like if you would set it to be batching static.

In all cases , thanks for sharing your research.

1 Like
4

@Zenchuck I’m setting those in my code snippet (edited) but they don’t seem to affect anything :-/

The sources I linked say the vertex amount that can get batched depends on the shader, not the mesh and it is
900 / [number of attributes used by the shader]. “Shader attributes” being the ones you mention: position, normal, tangent, uv…

This screenshot is not from my shader. I’m using one that only lists “position” in used attributes

@fffMalzbier I’ll be having 30+ pre-compile generated Voxel enemies on the screen, made out of ~5 different meshes and I was looking for dynamic batching to give me 5 draw calls instead of 30+. I’ll be dynamically generating stuff only when stuff dies and disintegrates. Luckily now that my design has clarified, I noticed I can make my meshes under 300 verts by removing back and upper faces since the camera will never see them. Now they batch as I want them to.

Actually I have never tried that StaticBatchingUtility. Thanks for the tip. It’ll come in handy with the static obstacles probably.

1 Like