Mesh merger script

2025-11-25 09:26 UTC gpt-5-1-thinking Open in ChatGPT ↗

Here’s a single, focused script that does exactly what you asked, with low allocations and no LINQ / reflection / fancy OOP. It uses Mesh.CombineMeshes with a reusable buffer to keep GC low and is friendly to DOTS-style code (plain data, tight loops).

using System.Collections.Generic;
using UnityEngine;

/// <summary>
/// High-performance mesh merger.
/// 1) Accepts an array of root objects.
/// 2) Walks each hierarchy non-recursively and collects MeshRenderers + SkinnedMeshRenderers.
/// 3) Skinned meshes are culled against an optional BoxCollider.
/// 4) All meshes are merged into a single mesh and assigned to this object's MeshFilter.
///
/// Attach this to the "merger object" that has a MeshFilter + MeshRenderer.
/// </summary>
[DisallowMultipleComponent]
[RequireComponent(typeof(MeshFilter))]
[RequireComponent(typeof(MeshRenderer))]
public sealed class MeshMerger : MonoBehaviour
{
    [Header("Sources")]
    [Tooltip("Root objects whose hierarchies will be scanned every frame.")]
    [SerializeField] private Transform[] roots;

    [Header("Culling")]
    [Tooltip("Optional BoxCollider used to cull SkinnedMeshRenderers by bounds.")]
    [SerializeField] private BoxCollider skinnedCullBox;

    [Header("Options")]
    [Tooltip("Include inactive objects in hierarchy traversal.")]
    [SerializeField] private bool includeInactive = false;

    /// <summary>Reusable stack to traverse hierarchies without recursion.</summary>
    private readonly Stack<Transform> _transformStack = new Stack<Transform>(128);

    /// <summary>Static mesh filters (MeshRenderer + MeshFilter).</summary>
    private readonly List<MeshFilter> _meshFilters = new List<MeshFilter>(128);

    /// <summary>Skinned mesh renderers.</summary>
    private readonly List<SkinnedMeshRenderer> _skinnedRenderers = new List<SkinnedMeshRenderer>(64);

    /// <summary>Reusable combine buffer – no per-frame allocations once grown.</summary>
    private CombineInstance[] _combineBuffer = new CombineInstance[128];

    /// <summary>Target mesh where the merged result is stored.</summary>
    private Mesh _mergedMesh;

    private MeshFilter _targetMeshFilter;

    /// <summary>Allow external code to set/override roots in a DOP-style fashion.</summary>
    public void SetRoots(Transform[] newRoots)
    {
        roots = newRoots;
    }

    /// <summary>Optional external control of the culling box.</summary>
    public void SetSkinnedCullBox(BoxCollider box)
    {
        skinnedCullBox = box;
    }

    private void Awake()
    {
        _targetMeshFilter = GetComponent<MeshFilter>();

        // Reuse a single mesh instance for the merged result.
        _mergedMesh = _targetMeshFilter.sharedMesh;
        if (_mergedMesh == null)
        {
            _mergedMesh = new Mesh
            {
                name = "MergedMesh (Runtime)"
            };
            // Support large vertex counts.
            _mergedMesh.indexFormat = UnityEngine.Rendering.IndexFormat.UInt32;
            _targetMeshFilter.sharedMesh = _mergedMesh;
        }
        else
        {
            _mergedMesh.Clear(false);
            _mergedMesh.indexFormat = UnityEngine.Rendering.IndexFormat.UInt32;
        }
    }

    private void OnDestroy()
    {
        // We do NOT destroy the mesh here, because it may be referenced from assets or pooling.
        // If you want full cleanup, uncomment the next line:
        // if (_mergedMesh != null) Destroy(_mergedMesh);
    }

    private void LateUpdate()
    {
        // 1) Gather renderers
        CollectRenderers();

        // Nothing to merge
        if (_meshFilters.Count == 0 && _skinnedRenderers.Count == 0)
        {
            if (_mergedMesh.vertexCount > 0)
                _mergedMesh.Clear(false);
            return;
        }

        // 2) Build combine instances, with SkinnedMeshRenderer culling by box collider
        int instanceCount = BuildCombineBuffer();

        if (instanceCount == 0)
        {
            // After culling, nothing left to draw
            if (_mergedMesh.vertexCount > 0)
                _mergedMesh.Clear(false);
            return;
        }

        // 3) Merge – single call into native engine side, very fast, no GC.
        _mergedMesh.Clear(false);
        _mergedMesh.indexFormat = UnityEngine.Rendering.IndexFormat.UInt32;
        _mergedMesh.CombineMeshes(_combineBuffer, true, true, false);
    }

    /// <summary>
    /// Traverses all roots and collects MeshFilters and SkinnedMeshRenderers.
    /// No recursion, no allocations after warmup.
    /// </summary>
    private void CollectRenderers()
    {
        _meshFilters.Clear();
        _skinnedRenderers.Clear();

        if (roots == null)
            return;

        for (int r = 0; r < roots.Length; r++)
        {
            Transform root = roots[r];
            if (root == null)
                continue;

            _transformStack.Clear();
            _transformStack.Push(root);

            while (_transformStack.Count > 0)
            {
                Transform t = _transformStack.Pop();
                if (!includeInactive && !t.gameObject.activeInHierarchy)
                    goto PUSH_CHILDREN; // skip components but still traverse children if wanted? Here we skip entirely.

                // Static mesh: MeshRenderer + MeshFilter
                if (t.TryGetComponent<MeshRenderer>(out var mr) &&
                    mr.enabled &&
                    t.TryGetComponent<MeshFilter>(out var mf) &&
                    mf.sharedMesh != null)
                {
                    _meshFilters.Add(mf);
                }

                // Skinned mesh
                if (t.TryGetComponent<SkinnedMeshRenderer>(out var smr) &&
                    smr.enabled &&
                    smr.sharedMesh != null)
                {
                    _skinnedRenderers.Add(smr);
                }

            PUSH_CHILDREN:
                // Manual child push – no foreach/allocs
                int childCount = t.childCount;
                for (int i = 0; i < childCount; i++)
                {
                    _transformStack.Push(t.GetChild(i));
                }
            }
        }
    }

    /// <summary>
    /// Fills the reusable CombineInstance buffer based on current renderers,
    /// applying culling rules for SkinnedMeshRenderers.
    /// </summary>
    /// <returns>Number of valid combine instances prepared.</returns>
    private int BuildCombineBuffer()
    {
        int totalNeeded = _meshFilters.Count + _skinnedRenderers.Count;

        // Grow buffer only when needed.
        if (_combineBuffer.Length < totalNeeded)
        {
            // Rare allocation; steady-state is allocation-free.
            int newSize = _combineBuffer.Length;
            while (newSize < totalNeeded)
                newSize *= 2;

            _combineBuffer = new CombineInstance[newSize];
        }

        int count = 0;

        // Static meshes
        for (int i = 0; i < _meshFilters.Count; i++)
        {
            MeshFilter mf = _meshFilters[i];
            if (mf == null)
                continue;

            Mesh mesh = mf.sharedMesh;
            if (mesh == null || mesh.vertexCount == 0)
                continue;

            var ci = new CombineInstance
            {
                mesh = mesh,
                // MeshRenderer is guaranteed to exist here (we checked when collecting).
                transform = mf.GetComponent<Renderer>().localToWorldMatrix
            };
            _combineBuffer[count++] = ci;
        }

        // Skinned meshes (with culling)
        var hasCullBox = skinnedCullBox != null;
        Bounds boxBounds = hasCullBox ? skinnedCullBox.bounds : default;

        for (int i = 0; i < _skinnedRenderers.Count; i++)
        {
            SkinnedMeshRenderer smr = _skinnedRenderers[i];
            if (smr == null)
                continue;

            // Step 2: cull against BoxCollider if present
            if (hasCullBox)
            {
                Bounds b = smr.bounds;

                // Require renderer bounds to be fully contained in the box bounds.
                if (!boxBounds.Contains(b.min) || !boxBounds.Contains(b.max))
                    continue;
            }

            Mesh mesh = smr.sharedMesh;
            if (mesh == null || mesh.vertexCount == 0)
                continue;

            // NOTE:
            // Using sharedMesh + localToWorldMatrix here is fast and allocation-free.
            // If you need fully animated vertex positions, you can add an optional
            // BakeMesh step into a pooled Mesh and use that mesh instead.
            var ci = new CombineInstance
            {
                mesh = mesh,
                transform = smr.localToWorldMatrix
            };
            _combineBuffer[count++] = ci;
        }

        return count;
    }
}

Notes / extension hooks

DOTS-friendly:
- Data-oriented: flat arrays, tight loops, no polymorphic dispatch, no LINQ, no delegates.
- A jobs/DOTS system can compute the roots list or culling input and feed it into this merger each frame.
Skinned meshes & animation:
- For absolute correctness with animated characters, use SkinnedMeshRenderer.BakeMesh into a pooled Mesh (per renderer) and plug that into the CombineInstance.
- That’s more CPU-heavy, so it’s intentionally omitted here to keep the core merger lean and fast.
No leaks / low allocations:
- Lists, stack, and combine buffer are created once and reused.
- The merged mesh is reused; only its contents are updated.

You can drop this script into your project as MeshMerger.cs, put it on a “Merger” GameObject with a MeshFilter + MeshRenderer, assign your roots and optional BoxCollider, and it will merge everything every LateUpdate with minimal overhead.

Below is the updated high-performance, allocation-free, DOTS-friendly Unity 6000.3 script with your new rule:

✔ NEW:

Both static MeshRenderers and SkinnedMeshRenderers are culled using the BoxCollider.

SkinnedMeshRenderers → culled by checking Renderer.bounds against the BoxCollider bounds.
Static MeshRenderers → culled by checking whether the Transform.position lies inside the BoxCollider bounds.

Everything else remains minimal, tight-looped, non-recursive, no LINQ, no GC churn, no spaghettification.

✅ Updated Mesh Merger (Unity 6000.3 Compatible)

using System.Collections.Generic;
using UnityEngine;

/// <summary>
/// Ultra-fast runtime mesh merger.
/// Performs:
/// 1) Iterative (non-recursive) transform traversal on user-specified roots.
/// 2) Collects MeshRenderers + SkinnedMeshRenderers.
/// 3) Culling rule:
///     - Static meshes: transform.position must be within BoxCollider bounds.
///     - Skinned meshes: renderer.bounds must be fully contained in BoxCollider bounds.
/// 4) Combines all surviving meshes into one final mesh with low allocations.
/// </summary>
[DisallowMultipleComponent]
[RequireComponent(typeof(MeshFilter))]
[RequireComponent(typeof(MeshRenderer))]
public sealed class MeshMerger : MonoBehaviour
{
    [Header("Sources")]
    [SerializeField] private Transform[] roots;

    [Header("Culling")]
    [Tooltip("BoxCollider used to cull static and skinned meshes.")]
    [SerializeField] private BoxCollider cullBox;

    [Header("Traversal")]
    [SerializeField] private bool includeInactive = false;

    // Runtime reusable containers (no GC after warmup)
    private readonly Stack<Transform> _stack = new Stack<Transform>(128);
    private readonly List<MeshFilter> _meshFilters = new List<MeshFilter>(128);
    private readonly List<SkinnedMeshRenderer> _skinnedRenderers = new List<SkinnedMeshRenderer>(64);

    private CombineInstance[] _combine = new CombineInstance[128];

    private Mesh _mergedMesh;
    private MeshFilter _targetMF;

    public void SetRoots(Transform[] newRoots) => roots = newRoots;
    public void SetCullBox(BoxCollider box) => cullBox = box;

    private void Awake()
    {
        _targetMF = GetComponent<MeshFilter>();
        _mergedMesh = _targetMF.sharedMesh;

        if (_mergedMesh == null)
        {
            _mergedMesh = new Mesh
            {
                name = "MergedMesh (Runtime)"
            };
            _mergedMesh.indexFormat = UnityEngine.Rendering.IndexFormat.UInt32;
            _targetMF.sharedMesh = _mergedMesh;
        }
        else
        {
            _mergedMesh.Clear(false);
            _mergedMesh.indexFormat = UnityEngine.Rendering.IndexFormat.UInt32;
        }
    }

    private void LateUpdate()
    {
        CollectRenderers();

        if (_meshFilters.Count == 0 && _skinnedRenderers.Count == 0)
        {
            if (_mergedMesh.vertexCount > 0)
                _mergedMesh.Clear(false);
            return;
        }

        int instanceCount = BuildCombineInstances();

        if (instanceCount == 0)
        {
            if (_mergedMesh.vertexCount > 0)
                _mergedMesh.Clear(false);
            return;
        }

        _mergedMesh.Clear(false);
        _mergedMesh.indexFormat = UnityEngine.Rendering.IndexFormat.UInt32;
        _mergedMesh.CombineMeshes(_combine, true, true, false);
    }

    // ----------------------------------------------------------------------
    // STEP 1: ITERATIVE TRANSFORM SEARCH (NO RECURSION)
    // ----------------------------------------------------------------------
    private void CollectRenderers()
    {
        _meshFilters.Clear();
        _skinnedRenderers.Clear();

        if (roots == null)
            return;

        for (int r = 0; r < roots.Length; r++)
        {
            Transform root = roots[r];
            if (root == null) continue;

            _stack.Clear();
            _stack.Push(root);

            while (_stack.Count > 0)
            {
                Transform t = _stack.Pop();

                if (!includeInactive && !t.gameObject.activeInHierarchy)
                    continue;

                if (t.TryGetComponent<MeshRenderer>(out var mr) &&
                    t.TryGetComponent<MeshFilter>(out var mf) &&
                    mf.sharedMesh != null &&
                    mr.enabled)
                {
                    _meshFilters.Add(mf);
                }

                if (t.TryGetComponent<SkinnedMeshRenderer>(out var smr) &&
                    smr.sharedMesh != null &&
                    smr.enabled)
                {
                    _skinnedRenderers.Add(smr);
                }

                int ch = t.childCount;
                for (int i = 0; i < ch; i++)
                    _stack.Push(t.GetChild(i));
            }
        }
    }

    // ----------------------------------------------------------------------
    // STEP 2: CULLING + FILLING COMBINE BUFFER
    // ----------------------------------------------------------------------
    private int BuildCombineInstances()
    {
        Bounds boxBounds = default;
        bool hasCull = cullBox != null;

        if (hasCull)
            boxBounds = cullBox.bounds;

        int totalNeeded = _meshFilters.Count + _skinnedRenderers.Count;

        if (_combine.Length < totalNeeded)
        {
            int size = _combine.Length;
            while (size < totalNeeded) size *= 2;
            _combine = new CombineInstance[size];
        }

        int count = 0;

        // ---- STATIC MESH CULLING: position inside box ----
        if (hasCull)
        {
            for (int i = 0; i < _meshFilters.Count; i++)
            {
                MeshFilter mf = _meshFilters[i];
                if (mf == null) continue;

                Transform t = mf.transform;

                if (!boxBounds.Contains(t.position))
                    continue;

                Mesh mesh = mf.sharedMesh;
                if (!mesh) continue;

                _combine[count++] = new CombineInstance
                {
                    mesh = mesh,
                    transform = mf.GetComponent<Renderer>().localToWorldMatrix
                };
            }

            // ---- SKINNED MESH CULLING: bounds fully inside box ----
            for (int i = 0; i < _skinnedRenderers.Count; i++)
            {
                SkinnedMeshRenderer smr = _skinnedRenderers[i];
                if (smr == null) continue;

                Bounds b = smr.bounds;

                if (!boxBounds.Contains(b.min) || !boxBounds.Contains(b.max))
                    continue;

                Mesh mesh = smr.sharedMesh;
                if (!mesh) continue;

                _combine[count++] = new CombineInstance
                {
                    mesh = mesh,
                    transform = smr.localToWorldMatrix
                };
            }
        }
        else
        {
            // No culling → include everything
            for (int i = 0; i < _meshFilters.Count; i++)
            {
                MeshFilter mf = _meshFilters[i];
                if (mf == null) continue;

                Mesh mesh = mf.sharedMesh;
                if (!mesh) continue;

                _combine[count++] = new CombineInstance
                {
                    mesh = mesh,
                    transform = mf.GetComponent<Renderer>().localToWorldMatrix
                };
            }

            for (int i = 0; i < _skinnedRenderers.Count; i++)
            {
                SkinnedMeshRenderer smr = _skinnedRenderers[i];
                if (smr == null) continue;

                Mesh mesh = smr.sharedMesh;
                if (!mesh) continue;

                _combine[count++] = new CombineInstance
                {
                    mesh = mesh,
                    transform = smr.localToWorldMatrix
                };
            }
        }

        return count;
    }
}

✔ Summary of Changes You Requested

Requirement	Implemented
Check both static and skinned meshes for bounding-box inclusion	✔
Cull static meshes based on transform.position inside BoxCollider	✔
Cull skinned meshes by testing bounds inside BoxCollider	✔
Still recursive-free, no LINQ, no GC, DOTS-friendly	✔
Single combined mesh assigned to merger object	✔
Clean, concise, documented	✔

If you’d like, I can also provide:

✅ A jobified Burst-compatible version
✅ A variant that bakes skinned meshes into GPU-deformed meshes
✅ A compute shader–based combiner (extremely fast)
✅ A version compatible with Entities Graphics / DOTS Mesh APIs

Just tell me!

Gotcha — we’ll switch SkinnedMeshRenderers to use BakeMesh, with pooled meshes so there are no per-frame allocations and no asset corruption.

Here’s the updated script, incorporating:

Static meshes: culled by transform.position inside BoxCollider.bounds
Skinned meshes:
- culled by renderer.bounds vs BoxCollider.bounds
- then baked into reusable runtime meshes via SkinnedMeshRenderer.BakeMesh
No leaks: baked meshes are destroyed in OnDestroy

using System.Collections.Generic;
using UnityEngine;

/// <summary>
/// High-performance runtime mesh merger.
/// - Iterative hierarchy traversal (no recursion).
/// - Collects MeshRenderers and SkinnedMeshRenderers.
/// - Culling:
///     * Static: Transform.position must be inside BoxCollider bounds.
///     * Skinned: Renderer.bounds must be fully inside BoxCollider bounds.
/// - Skinned meshes are baked via SkinnedMeshRenderer.BakeMesh into pooled meshes.
/// - All surviving meshes are combined into a single mesh assigned to this object's MeshFilter.
/// </summary>
[DisallowMultipleComponent]
[RequireComponent(typeof(MeshFilter))]
[RequireComponent(typeof(MeshRenderer))]
public sealed class MeshMerger : MonoBehaviour
{
    [Header("Sources")]
    [SerializeField] private Transform[] roots;

    [Header("Culling")]
    [Tooltip("BoxCollider used to cull static and skinned meshes.")]
    [SerializeField] private BoxCollider cullBox;

    [Header("Traversal")]
    [SerializeField] private bool includeInactive = false;

    // Iterative traversal
    private readonly Stack<Transform> _stack = new Stack<Transform>(128);

    // Collected renderers
    private readonly List<MeshFilter> _meshFilters = new List<MeshFilter>(128);
    private readonly List<SkinnedMeshRenderer> _skinnedRenderers = new List<SkinnedMeshRenderer>(64);

    // Pooled baked meshes for SMRs (index matches _skinnedRenderers index at build time)
    private readonly List<Mesh> _bakedMeshes = new List<Mesh>(64);

    // Combine buffer (reused, grown as needed)
    private CombineInstance[] _combine = new CombineInstance[128];

    private Mesh _mergedMesh;
    private MeshFilter _targetMF;

    public void SetRoots(Transform[] newRoots) => roots = newRoots;
    public void SetCullBox(BoxCollider box) => cullBox = box;

    private void Awake()
    {
        _targetMF = GetComponent<MeshFilter>();
        _mergedMesh = _targetMF.sharedMesh;

        if (_mergedMesh == null)
        {
            _mergedMesh = new Mesh { name = "MergedMesh (Runtime)" };
            _mergedMesh.indexFormat = UnityEngine.Rendering.IndexFormat.UInt32;
            _targetMF.sharedMesh = _mergedMesh;
        }
        else
        {
            _mergedMesh.Clear(false);
            _mergedMesh.indexFormat = UnityEngine.Rendering.IndexFormat.UInt32;
        }
    }

    private void OnDestroy()
    {
        // Clean baked meshes to prevent leaks.
        for (int i = 0; i < _bakedMeshes.Count; i++)
        {
            Mesh m = _bakedMeshes[i];
            if (m != null)
                Destroy(m);
        }
        _bakedMeshes.Clear();

        // If you are sure this mesh is runtime-only, you can destroy it too.
        // if (_mergedMesh != null) Destroy(_mergedMesh);
    }

    private void LateUpdate()
    {
        CollectRenderers();

        if (_meshFilters.Count == 0 && _skinnedRenderers.Count == 0)
        {
            if (_mergedMesh.vertexCount > 0)
                _mergedMesh.Clear(false);
            return;
        }

        int instanceCount = BuildCombineInstancesWithBaking();

        if (instanceCount == 0)
        {
            if (_mergedMesh.vertexCount > 0)
                _mergedMesh.Clear(false);
            return;
        }

        _mergedMesh.Clear(false);
        _mergedMesh.indexFormat = UnityEngine.Rendering.IndexFormat.UInt32;
        _mergedMesh.CombineMeshes(_combine, true, true, false);
    }

    // ----------------------------------------------------------------------
    // 1) ITERATIVE COLLECT
    // ----------------------------------------------------------------------
    private void CollectRenderers()
    {
        _meshFilters.Clear();
        _skinnedRenderers.Clear();

        if (roots == null)
            return;

        for (int r = 0; r < roots.Length; r++)
        {
            Transform root = roots[r];
            if (root == null) continue;

            _stack.Clear();
            _stack.Push(root);

            while (_stack.Count > 0)
            {
                Transform t = _stack.Pop();

                if (!includeInactive && !t.gameObject.activeInHierarchy)
                    continue;

                if (t.TryGetComponent<MeshRenderer>(out var mr) &&
                    mr.enabled &&
                    t.TryGetComponent<MeshFilter>(out var mf) &&
                    mf.sharedMesh != null)
                {
                    _meshFilters.Add(mf);
                }

                if (t.TryGetComponent<SkinnedMeshRenderer>(out var smr) &&
                    smr.enabled &&
                    smr.sharedMesh != null)
                {
                    _skinnedRenderers.Add(smr);
                }

                int ch = t.childCount;
                for (int i = 0; i < ch; i++)
                    _stack.Push(t.GetChild(i));
            }
        }
    }

    // ----------------------------------------------------------------------
    // 2) CULL + BAKE SMR + FILL COMBINE BUFFER
    // ----------------------------------------------------------------------
    private int BuildCombineInstancesWithBaking()
    {
        bool hasCull = cullBox != null;
        Bounds boxBounds = hasCull ? cullBox.bounds : default;

        int totalNeeded = _meshFilters.Count + _skinnedRenderers.Count;

        // Grow combine buffer only when required
        if (_combine.Length < totalNeeded)
        {
            int size = _combine.Length;
            while (size < totalNeeded) size *= 2;
            _combine = new CombineInstance[size];
        }

        // Ensure we have enough baked meshes for all SMRs this frame
        if (_bakedMeshes.Capacity < _skinnedRenderers.Count)
            _bakedMeshes.Capacity = _skinnedRenderers.Count;

        for (int i = _bakedMeshes.Count; i < _skinnedRenderers.Count; i++)
        {
            var m = new Mesh { name = "BakedSMRMesh" };
            m.indexFormat = UnityEngine.Rendering.IndexFormat.UInt32;
            m.MarkDynamic(); // optimized for frequent updates
            _bakedMeshes.Add(m);
        }

        int count = 0;

        // --- STATIC MESHES ---
        for (int i = 0; i < _meshFilters.Count; i++)
        {
            MeshFilter mf = _meshFilters[i];
            if (mf == null) continue;

            Mesh mesh = mf.sharedMesh;
            if (mesh == null || mesh.vertexCount == 0) continue;

            if (hasCull)
            {
                // Culling by transform.position inside cull box
                if (!boxBounds.Contains(mf.transform.position))
                    continue;
            }

            _combine[count++] = new CombineInstance
            {
                mesh = mesh,
                transform = mf.GetComponent<Renderer>().localToWorldMatrix
            };
        }

        // --- SKINNED MESHES (BAKED) ---
        for (int i = 0; i < _skinnedRenderers.Count; i++)
        {
            SkinnedMeshRenderer smr = _skinnedRenderers[i];
            if (smr == null) continue;

            if (hasCull)
            {
                Bounds b = smr.bounds;
                if (!boxBounds.Contains(b.min) || !boxBounds.Contains(b.max))
                    continue;
            }

            Mesh bakeMesh = _bakedMeshes[i];
            if (bakeMesh == null) continue;

            // Bake deformed vertices into our pooled mesh.
            smr.BakeMesh(bakeMesh);

            if (bakeMesh.vertexCount == 0)
                continue;

            _combine[count++] = new CombineInstance
            {
                mesh = bakeMesh,
                // Baked mesh is in SMR local space; transform to world
                transform = smr.localToWorldMatrix
            };
        }

        return count;
    }
}

Key points:

BakeMesh usage:
smr.BakeMesh(bakedMesh) is called once per active SMR per frame into a reused Mesh (no per-frame new Mesh()).
No asset corruption:
We never bake into sharedMesh; only into runtime-created meshes stored in _bakedMeshes.
No leaks:
All baked meshes are Destroyed in OnDestroy.
Low allocation:
- Lists and arrays are grown once, then reused.
- No LINQ, no recursion, no closures.

If you want, next step I can give you a Jobs/Burst variant where bake + culling still happen on main thread (BakeMesh is main-thread), but combining / matrix prep are done in jobs.

You’re right to worry about them “flying” – that usually happens because the combine matrices are in world space while the merged mesh lives under a non-identity parent. We’ll fix that by transforming everything into the merger object’s local space:

using System.Collections.Generic;
using UnityEngine;

/// <summary>
/// High-performance runtime mesh merger.
/// - Iterative hierarchy traversal (no recursion).
/// - Collects MeshRenderers and SkinnedMeshRenderers.
/// - Culling:
///     * Static: Transform.position must be inside BoxCollider bounds.
///     * Skinned: Renderer.bounds must be fully inside BoxCollider bounds.
/// - Skinned meshes are baked via SkinnedMeshRenderer.BakeMesh into pooled meshes.
/// - All surviving meshes are combined into a single mesh assigned to this object's MeshFilter.
/// - FULL transform applied so meshes don't float/fly when the merger object moves/rotates/scales.
/// </summary>
[DisallowMultipleComponent]
[RequireComponent(typeof(MeshFilter))]
[RequireComponent(typeof(MeshRenderer))]
public sealed class MeshMerger : MonoBehaviour
{
    [Header("Sources")]
    [SerializeField] private Transform[] roots;

    [Header("Culling")]
    [Tooltip("BoxCollider used to cull static and skinned meshes.")]
    [SerializeField] private BoxCollider cullBox;

    [Header("Traversal")]
    [SerializeField] private bool includeInactive = false;

    // Iterative traversal
    private readonly Stack<Transform> _stack = new Stack<Transform>(128);

    // Collected renderers
    private readonly List<MeshFilter> _meshFilters = new List<MeshFilter>(128);
    private readonly List<SkinnedMeshRenderer> _skinnedRenderers = new List<SkinnedMeshRenderer>(64);

    // Pooled baked meshes for SMRs
    private readonly List<Mesh> _bakedMeshes = new List<Mesh>(64);

    // Combine buffer (reused)
    private CombineInstance[] _combine = new CombineInstance[128];

    private Mesh _mergedMesh;
    private MeshFilter _targetMF;

    public void SetRoots(Transform[] newRoots) => roots = newRoots;
    public void SetCullBox(BoxCollider box) => cullBox = box;

    private void Awake()
    {
        _targetMF = GetComponent<MeshFilter>();
        _mergedMesh = _targetMF.sharedMesh;

        if (_mergedMesh == null)
        {
            _mergedMesh = new Mesh { name = "MergedMesh (Runtime)" };
            _mergedMesh.indexFormat = UnityEngine.Rendering.IndexFormat.UInt32;
            _targetMF.sharedMesh = _mergedMesh;
        }
        else
        {
            _mergedMesh.Clear(false);
            _mergedMesh.indexFormat = UnityEngine.Rendering.IndexFormat.UInt32;
        }
    }

    private void OnDestroy()
    {
        // Clean baked meshes to prevent leaks.
        for (int i = 0; i < _bakedMeshes.Count; i++)
        {
            Mesh m = _bakedMeshes[i];
            if (m != null)
                Destroy(m);
        }
        _bakedMeshes.Clear();

        // Optional: if this mesh is purely runtime, you can destroy it as well.
        // if (_mergedMesh != null) Destroy(_mergedMesh);
    }

    private void LateUpdate()
    {
        CollectRenderers();

        if (_meshFilters.Count == 0 && _skinnedRenderers.Count == 0)
        {
            if (_mergedMesh.vertexCount > 0)
                _mergedMesh.Clear(false);
            return;
        }

        int instanceCount = BuildCombineInstancesWithBaking();
        if (instanceCount == 0)
        {
            if (_mergedMesh.vertexCount > 0)
                _mergedMesh.Clear(false);
            return;
        }

        _mergedMesh.Clear(false);
        _mergedMesh.indexFormat = UnityEngine.Rendering.IndexFormat.UInt32;
        _mergedMesh.CombineMeshes(_combine, true, true, false);
    }

    // ----------------------------------------------------------------------
    // 1) ITERATIVE COLLECT
    // ----------------------------------------------------------------------
    private void CollectRenderers()
    {
        _meshFilters.Clear();
        _skinnedRenderers.Clear();

        if (roots == null)
            return;

        for (int r = 0; r < roots.Length; r++)
        {
            Transform root = roots[r];
            if (root == null) continue;

            _stack.Clear();
            _stack.Push(root);

            while (_stack.Count > 0)
            {
                Transform t = _stack.Pop();

                if (!includeInactive && !t.gameObject.activeInHierarchy)
                    continue;

                if (t.TryGetComponent<MeshRenderer>(out var mr) &&
                    mr.enabled &&
                    t.TryGetComponent<MeshFilter>(out var mf) &&
                    mf.sharedMesh != null)
                {
                    _meshFilters.Add(mf);
                }

                if (t.TryGetComponent<SkinnedMeshRenderer>(out var smr) &&
                    smr.enabled &&
                    smr.sharedMesh != null)
                {
                    _skinnedRenderers.Add(smr);
                }

                int ch = t.childCount;
                for (int i = 0; i < ch; i++)
                    _stack.Push(t.GetChild(i));
            }
        }
    }

    // ----------------------------------------------------------------------
    // 2) CULL + BAKE SMR + FILL COMBINE BUFFER
    // ----------------------------------------------------------------------
    private int BuildCombineInstancesWithBaking()
    {
        bool hasCull = cullBox != null;
        Bounds boxBounds = hasCull ? cullBox.bounds : default;

        int totalNeeded = _meshFilters.Count + _skinnedRenderers.Count;

        // Grow combine buffer only when required
        if (_combine.Length < totalNeeded)
        {
            int size = _combine.Length;
            while (size < totalNeeded) size *= 2;
            _combine = new CombineInstance[size];
        }

        // Ensure we have enough baked meshes for all SMRs this frame
        if (_bakedMeshes.Capacity < _skinnedRenderers.Count)
            _bakedMeshes.Capacity = _skinnedRenderers.Count;

        for (int i = _bakedMeshes.Count; i < _skinnedRenderers.Count; i++)
        {
            var m = new Mesh { name = "BakedSMRMesh" };
            m.indexFormat = UnityEngine.Rendering.IndexFormat.UInt32;
            m.MarkDynamic(); // optimized for frequent updates
            _bakedMeshes.Add(m);
        }

        int count = 0;

        // IMPORTANT:
        // CombineInstance.transform is in *target mesh local space*.
        // So we convert from renderer world → merger local:
        Matrix4x4 worldToLocalOfMerger = _targetMF.transform.worldToLocalMatrix;

        // --- STATIC MESHES ---
        for (int i = 0; i < _meshFilters.Count; i++)
        {
            MeshFilter mf = _meshFilters[i];
            if (mf == null) continue;

            Mesh mesh = mf.sharedMesh;
            if (mesh == null || mesh.vertexCount == 0) continue;

            if (hasCull && !boxBounds.Contains(mf.transform.position))
                continue;

            Matrix4x4 rendererLocalToWorld =
                mf.GetComponent<Renderer>().localToWorldMatrix;

            _combine[count++] = new CombineInstance
            {
                mesh = mesh,
                // full transform into merger's local space
                transform = worldToLocalOfMerger * rendererLocalToWorld
            };
        }

        // --- SKINNED MESHES (BAKED) ---
        for (int i = 0; i < _skinnedRenderers.Count; i++)
        {
            SkinnedMeshRenderer smr = _skinnedRenderers[i];
            if (smr == null) continue;

            if (hasCull)
            {
                Bounds b = smr.bounds;
                if (!boxBounds.Contains(b.min) || !boxBounds.Contains(b.max))
                    continue;
            }

            Mesh bakeMesh = _bakedMeshes[i];
            if (bakeMesh == null) continue;

            // Bake deformed vertices into our pooled mesh.
            smr.BakeMesh(bakeMesh);

            if (bakeMesh.vertexCount == 0)
                continue;

            Matrix4x4 smrLocalToWorld = smr.localToWorldMatrix;

            _combine[count++] = new CombineInstance
            {
                mesh = bakeMesh,
                // FULL transform: baked mesh (in smr local space) → world → merger local
                transform = worldToLocalOfMerger * smrLocalToWorld
            };
        }

        return count;
    }
}

What changed to stop “flying” SMRs

Before: CombineInstance.transform = smr.localToWorldMatrix;
This works only if the merger object is at identity (no move/rotate/scale).
Now: transform = merger.worldToLocalMatrix * smr.localToWorldMatrix;
This converts each mesh from its own local space → world → merger’s local space, so:
- The merged mesh follows the merger object correctly.
- SMRs and statics stay exactly where their renderers are, no offsets or floating.

You can move/rotate/scale the merger object however you like; everything should stay locked in place visually.