Unity中如何快速实现Mesh数组到MeshFilter数组的转换

MeshFilter是Unity中依附于GameObject存在的组件，不存在脱离GameObject的独立MeshFilter实例，因此转换逻辑的本质是为每一个输入的Mesh，分配一个持有该Mesh引用的MeshFilter实例。

场景1：一次性转换（低频次调用，无复用需求） #

using UnityEngine;

public static MeshFilter[] ConvertMeshesToMeshFilters(Mesh[] inputMeshes, Transform parent = null)
{
    if (inputMeshes == null || inputMeshes.Length == 0)
        return System.Array.Empty<MeshFilter>();
    
    MeshFilter[] result = new MeshFilter[inputMeshes.Length];
    // 批量创建时先禁用父节点，减少脏标记更新开销
    bool parentOriginalState = parent != null && parent.gameObject.activeSelf;
    if (parentOriginalState)
        parent.gameObject.SetActive(false);
    
    for (int i = 0; i < inputMeshes.Length; i++)
    {
        if (inputMeshes[i] == null) continue;
        
        GameObject meshObj = new GameObject($"Mesh_{i}_{inputMeshes[i].name}");
        meshObj.transform.SetParent(parent, false);
        // 不需要MeshRenderer可以删掉对应行
        MeshFilter filter = meshObj.AddComponent<MeshFilter>();
        meshObj.AddComponent<MeshRenderer>();
        
        filter.sharedMesh = inputMeshes[i];
        result[i] = filter;
    }
    
    // 恢复父节点原有状态
    if (parentOriginalState)
        parent.gameObject.SetActive(true);
    
    return result;
}

场景2：高频生成场景（最高效方案，对象池避免GC和组件创建开销） #

提前预生成足够的MeshFilter实例池，运行时直接取实例赋值Mesh即可：

using UnityEngine;
using System.Collections.Generic;

public static class MeshFilterPool
{
    private static readonly Queue<MeshFilter> _pool = new Queue<MeshFilter>();
    private static Transform _poolRoot;

    // 初始化时预生成指定数量的MeshFilter实例
    public static void PreWarm(int count, Transform parent = null)
    {
        _poolRoot = new GameObject("MeshFilterPoolRoot").transform;
        _poolRoot.SetParent(parent, false);
        _poolRoot.gameObject.SetActive(false);
        
        for (int i = 0; i < count; i++)
        {
            GameObject obj = new GameObject("PooledMeshFilter");
            obj.transform.SetParent(_poolRoot, false);
            MeshFilter filter = obj.AddComponent<MeshFilter>();
            obj.AddComponent<MeshRenderer>();
            _pool.Enqueue(filter);
        }
    }

    // 批量获取MeshFilter实例
    public static MeshFilter[] GetBatch(int count)
    {
        MeshFilter[] result = new MeshFilter[count];
        for (int i = 0; i < count; i++)
        {
            if (_pool.Count == 0)
            {
                // 池不够时自动扩容，每次扩容20%避免频繁扩容
                PreWarm(Mathf.Max(1, (int)(count * 0.2f)), _poolRoot.parent);
            }
            MeshFilter filter = _pool.Dequeue();
            filter.gameObject.SetActive(true);
            result[i] = filter;
        }
        return result;
    }

    // 批量归还实例到池
    public static void ReturnBatch(MeshFilter[] filters)
    {
        foreach (var filter in filters)
        {
            if (filter == null) continue;
            filter.sharedMesh = null;
            filter.gameObject.SetActive(false);
            filter.transform.SetParent(_poolRoot, false);
            _pool.Enqueue(filter);
        }
    }
}

// 调用示例
public static MeshFilter[] ConvertMeshesToMeshFiltersHighPerformance(Mesh[] inputMeshes)
{
    if (inputMeshes == null || inputMeshes.Length == 0)
        return System.Array.Empty<MeshFilter>();
    
    MeshFilter[] filters = MeshFilterPool.GetBatch(inputMeshes.Length);
    for (int i = 0; i < inputMeshes.Length; i++)
    {
        if (inputMeshes[i] != null)
            filters[i].sharedMesh = inputMeshes[i];
    }
    return filters;
}

性能优化注意点 #

• 优先使用sharedMesh而非mesh赋值，避免触发Mesh拷贝产生额外GC
• 批量操作时尽量关闭父节点激活状态，减少Unity内部渲染脏标记的更新次数
• 高频调用场景下严禁动态调用AddComponent，对象池方案可以减少90%以上的转换开销
• 所有数组提前指定长度初始化，避免动态扩容的额外开销

内容的提问来源于stack exchange，提问作者user16565188