A otimização de malhas 3D em projetos Unity é crucial para garantir a fluidez da experiência, especialmente em plataformas com recursos limitados. Modelos de alta contagem de polígonos podem facilmente causar quedas de framerate e sobrecarregar o desempenho do sistema. O UnityMeshSimplifier, uma biblioteca C# de código aberto baseada no algoritmo Fast Quadric Mesh Simplification, oferece uma solução robusta para este desafio, permitindo reduzir significativamente a complexidade geométrica de modelos com alta fidelidade visual.

Visão Geral do UnityMeshSimplifier

O UnityMeshSimplifier se destaca das ferramentas nativas de simplificação de malhas do Unity por sua flexibilidade e poder. Ele foi projetado para operar tanto no editor quanto em tempo de execução, oferecendo um controle granular sobre o processo de otimização. O projeto está disponível em seu repositório oficial: UnityMeshSimplifier no GitCode.

Diferenciais Chave

Característica	Simplificação Nativa Unity	UnityMeshSimplifier
Algoritmo	Quadric básico	Algoritmo de Erro Quadrático (QEM) aprimorado
Suporte em Tempo de Execução	Apenas Editor	Suporte completo em todas as plataformas
Parâmetros de Configuração	3 parâmetros básicos	Mais de 12 parâmetros de controle fino
Funcionalidades Avançadas	Ausentes	Conexão inteligente de vértices, preservação de curvatura, geração automática de LOD
Desempenho	Mais alto	Implementação C# otimizada, 40% mais rápida
Formatos Suportados	Apenas MeshFilter	MeshFilter e SkinnedMeshRenderer

Arquitetura Técnica

O projeto é uma biblioteca escrita inteiramente em C#, licenciada sob a licença MIT, o que facilita sua integração e personalização em diversos projetos Unity. Sua arquitetura modular permite que os desenvolvedores estendam ou modifiquem seu comportamento para necessidades específicas.

Iniciando a Simplificação de Malhas

Procedimento Básico de Simplificação

O exemplo a seguir demonstra como utilizar a API principal do UnityMeshSimplifier para reduzir a contagem de triângulos de uma malha em 50%.

using UnityEngine;
using UnityMeshSimplifier; // Importa o namespace da biblioteca

public class SimplificacaoBasicaDeMalha : MonoBehaviour
{
    [Range(0.1f, 1.0f)]
    public float nivelQualidade = 0.5f; // Mantém 50% dos triângulos originais
    
    void Start()
    {
        MeshFilter filtroMalha = GetComponent<meshfilter>();
        if (filtroMalha == null || filtroMalha.sharedMesh == null)
        {
            Debug.LogError("Componente MeshFilter válido não encontrado neste GameObject.");
            return;
        }
        
        // Cria uma instância do simplificador
        var simplificador = new MeshSimplifier();
        simplificador.Initialize(filtroMalha.sharedMesh);
        
        // Define as opções de simplificação
        SimplificationOptions opcoes = SimplificationOptions.Default;
        opcoes.PreserveBorderEdges = true; // Impede furos nas bordas
        opcoes.EnableSmartLink = true;     // Ativa a ligação inteligente de vértices para melhor qualidade
        simplificador.SimplificationOptions = opcoes;
        
        // Executa o processo de simplificação
        simplificador.SimplifyMesh(nivelQualidade);
        
        // Aplica a malha simplificada ao MeshFilter
        Mesh malhaSimplificada = simplificador.ToMesh();
        filtroMalha.sharedMesh = malhaSimplificada;
        
        // Loga os resultados para comparação
        int numTriangulosOriginais = filtroMalha.sharedMesh.triangles.Length / 3;
        int numTriangulosSimplificados = malhaSimplificada.triangles.Length / 3;
        Debug.Log($"Simplificação concluída: Original {numTriangulosOriginais} → Simplificado {numTriangulosSimplificados} (Redução de {(1 - nivelQualidade) * 100:F0}%)");
    }
}
</meshfilter>

Compreendendo os Parâmetros Essenciais

A classe SimplificationOptions oferece um controle detalhado sobre o comportamento do algoritmo de simplificação. Abaixo estão alguns dos parâmetros mais utilizados e suas configurações recomendadas:

Parâmetro	Função	Valor Padrão	Configuração Recomendada
PreserveBorderEdges	Mantém as bordas da malha intactas.	false	true para modelos com superfícies rígidas (ex: arquitetura).
PreserveUVSeamEdges	Preserva as arestas de emenda UV.	false	true para modelos com texturas detalhadas para evitar distorções.
PreserveSurfaceCurvature	Tenta manter a curvatura original da superfície.	false	true para personagens ou modelos orgânicos.
EnableSmartLink	Conecta vértices próximos com diferentes atributos.	true	Sempre true para reduzir artefatos como furos.
VertexLinkDistance	Distância máxima para ligação inteligente de vértices.	1e-3	Pode ser aumentado para 1e-2 em modelos muito grandes.
Agressiveness	Quão agressiva será a simplificação.	7.0	10.0 para qualidade visual, 5.0 para priorizar performance.
MaxIterationCount	Número máximo de iterações do algoritmo.	100	Aumentar para 200 em malhas complexas.

Análise Profunda: Algoritmo e Implementação

Algoritmo de Erro Quadrático (QEM)

O cerne do UnityMeshSimplifier reside em uma versão aprimorada do algoritmo de Erro Quadrático (QEM). Este método avalia a prioridade de simplificação de cada vértice através do cálculo de uma matriz de erro, que quantifica o custo de contrair uma aresta.

Fragmento de código para cálculo da matriz de erro:

// Função auxiliar para calcular a matriz de erro para um vértice
private SymmetricMatrix GerarMatrizErroVertice(Vector3d posicaoVertice, Vector3d normalVertice)
{
    // Coordenadas da normal e distância do plano à origem (d)
    double nx = normalVertice.x, ny = normalVertice.y, nz = normalVertice.z;
    double d = -(nx * posicaoVertice.x + ny * posicaoVertice.y + nz * posicaoVertice.z);
    
    // Constrói a matriz simétrica a partir dos coeficientes do plano (ax + by + cz + d = 0)
    // Representa a soma dos quadrados das distâncias do vértice aos planos incidentes
    return new SymmetricMatrix(
        nx * nx, nx * ny, nx * nz, nx * d,
        ny * ny, ny * nz, ny * d,
        nz * nz, nz * d,
        d * d
    );
}

Tecnologia de Ligação Inteligente de Vértices

Algoritmos de simplificação tradicionais podem introduzir furos ou artefatos ao lidar com vértices que compartilham a mesma posição espacial, mas possuem atributos diferentes (como UVs ou cores). A técnica de ligação inteligente de vértices do UnityMeshSimplifier mitiga este problema ao tratar as posições dos vértices e seus atributos de forma mais sofisticada.

private void VincularVertices()
{
    // Mapeia posições de vértices para uma lista de seus índices
    var mapaPosicoesParaIndices = new Dictionary<vector3d list="">>();
    
    // Agrupa os vértices pela sua posição 3D
    for (int i = 0; i < vertices.Length; i++)
    {
        Vector3d pos = vertices[i].posicao; // Assumindo 'posicao' é um campo do struct Vertex
        if (!mapaPosicoesParaIndices.ContainsKey(pos))
        {
            mapaPosicoesParaIndices[pos] = new List<int>();
        }
        mapaPosicoesParaIndices[pos].Add(i);
    }
    
    // Processa grupos de vértices na mesma posição
    foreach (var grupoIndices in mapaPosicoesParaIndices.Values)
    {
        if (grupoIndices.Count > 1)
        {
            ProcessarGrupoDeVertices(grupoIndices); // Função auxiliar para ligar vértices
        }
    }
}
</int></vector3d>

Aplicações Avançadas: Geração Automatizada de Sistemas LOD

Utilizando o Componente LODGeneratorHelper

O componente LODGeneratorHelper simplifica a criação de grupos LOD (Level of Detail) diretamente no editor Unity. O processo envolve três passos simples:

1. Adicionar o componente LODGeneratorHelper ao GameObject desejado.
2. Configurar os níveis de LOD, especificando a qualidade da malha e a altura relativa na tela para cada nível.
3. Clicar no botão "Generate LODs" para que o sistema crie automaticamente o LODGroup e as malhas simplificadas.

Exemplo de Geração de LODs em Tempo de Execução

Para cenários onde a geração de LODs precisa ser dinâmica, o UnityMeshSimplifier oferece uma API que permite criar e configurar LODGroups programaticamente.

using UnityEngine;
using UnityMeshSimplifier;

public class GeradorLODRuntime : MonoBehaviour
{
    [System.Serializable]
    public class ConfiguracaoNivelLOD
    {
        [Range(0.1f, 1.0f)] public float qualidadeMalha = 0.5f;
        public float alturaRelativaTela = 0.1f;
    }
    
    public ConfiguracaoNivelLOD[] niveisLOD;
    public bool combinarMalhas = true;
    
    void Awake()
    {
        if (niveisLOD == null || niveisLOD.Length == 0)
        {
            Debug.LogError("Níveis de LOD não configurados.");
            return;
        }
        
        // Converte as configurações personalizadas para um array de LODLevel
        LODLevel[] levelsParaGerar = new LODLevel[niveisLOD.Length];
        for (int i = 0; i < niveisLOD.Length; i++)
        {
            levelsParaGerar[i] = new LODLevel
            {
                Quality = niveisLOD[i].qualidadeMalha,
                ScreenRelativeTransitionHeight = niveisLOD[i].alturaRelativaTela,
                CombineMeshes = combinarMalhas
            };
        }
        
        // Gera o LOD Group no GameObject atual
        LODGroup grupoLOD = LODGenerator.GenerateLODs(
            gameObject, 
            levelsParaGerar, 
            autoCollectRenderers: true,
            simplificationOptions: SimplificationOptions.Default,
            saveAssetsPath: null // Não salva os ativos em tempo de execução
        );
        
        if (grupoLOD != null)
        {
            Debug.Log($"Sistema LOD com {levelsParaGerar.Length} níveis gerado com sucesso.");
        }
    }
}

Otimização de Performance: Ajuste Fino de Parâmetros e Boas Práticas

Estratégias de Otimização para Diferentes Tipos de Modelos

A escolha dos parâmetros de simplificação deve ser adaptada ao tipo de modelo e ao resultado desejado:

Tipo de Modelo	Configurações de Parâmetros Sugeridas	Nível de Qualidade (%)	Impacto na Otimização
Modelos Rígidos (Hard-Surface)	PreserveBorderEdges = true	30-60%	Redução de ~70% de triângulos, baixa distorção.
Personagens Orgânicos	PreserveSurfaceCurvature = true	50-80%	Redução de ~50% de triângulos, mantém contornos.
Vegetação de Cenário	EnableSmartLink = true	20-40%	Redução de ~80% de triângulos, priorizando performance.
Malhas de UI/2D	PreserveUVSeamEdges = true	60-90%	Redução de ~40% de triângulos, preserva silhueta.

Fluxo de Trabalho para Otimização de Cenas Extensas

Em cenas complexas, um fluxo de trabalho em duas fases é recomendado:

1. Fase de Pré-processamento (no Editor):
   • Combine objetos estáticos utilizando um MeshCombiner para reduzir draw calls.
   • Aplique a simplificação às malhas combinadas (qualidade entre 0.4-0.6).
   • Salve as malhas simplificadas como novos ativos.
2. Fase de Tempo de Execução:
   • Ajuste dinamicamente os limites de transição do LOD com base no desempenho do dispositivo.
   • Utilize os níveis de LOD mais baixos para modelos fora do campo de visão ou distantes.
   • Desative cálculos de simplificação em tempo real durante movimentos rápidos da câmera para evitar picos de performance.

// Função para ajustar dinamicamente os níveis de LOD com base no FPS
public class ControladorLODAdaptativo : MonoBehaviour
{
    // ... outros membros da classe
    
    public void AjustarLODPorPerformance(float taxaQuadrosAtual)
    {
        LODGroup grupoLOD = GetComponent<lodgroup>();
        if (grupoLOD == null) return;
        
        LOD[] niveisAtuais = grupoLOD.GetLODs();
        float fatorAjuste = 1.0f; // Fator para escalar as alturas de transição
        
        if (taxaQuadrosAtual < 30)
        {
            // FPS baixo, transita para LODs mais baixos mais agressivamente
            fatorAjuste = 1.5f; 
        }
        else if (taxaQuadrosAtual > 50)
        {
            // FPS alto, permite LODs de maior qualidade por mais tempo
            fatorAjuste = 0.7f;
        }
        // Para FPS normal, fatorAjuste permanece 1.0f
        
        for (int i = 0; i < niveisAtuais.Length; i++)
        {
            // Aplica o fator de ajuste à altura relativa de transição
            niveisAtuais[i].screenRelativeTransitionHeight *= fatorAjuste;
        }
        
        grupoLOD.SetLODs(niveisAtuais); // Aplica as novas configurações de LOD
    }
}
</lodgroup>

Resolução de Problemas Comuns

Problema 1: Malha com Furos ou Distorções após Simplificação

Causa: Arestas de borda ou emendas UV foram contraídas incorretamente durante o processo.

Solução:

var opcoesSimplificacao = SimplificationOptions.Default;
opcoesSimplificacao.PreserveBorderEdges = true;      // Impede a contração de bordas abertas
opcoesSimplificacao.PreserveUVSeamEdges = true;      // Mantém as emendas UV
opcoesSimplificacao.VertexLinkDistance = 0.001f;     // Aumenta a distância para ligar vértices próximos
simplificador.SimplificationOptions = opcoesSimplificacao;

Problema 2: Animações de Personagens Distorcidas

Causa: Informações de peso ósseo (bone weights) não são tratadas corretamente durante a simplificação de SkinnedMeshRenderer.

Solução:

SkinnedMeshRenderer renderizadorPele = GetComponent<skinnedmeshrenderer>();
if (renderizadorPele != null)
{
    var simplificadorPersonagem = new MeshSimplifier(renderizadorPele.sharedMesh);
    simplificadorPersonagem.Bindposes = renderizadorPele.sharedMesh.bindposes; // Preserva bind poses
    simplificadorPersonagem.BoneWeights = renderizadorPele.sharedMesh.boneWeights; // Preserva pesos ósseos
    
    // Assegura que os pesos ósseos sejam considerados durante a simplificação
    simplificadorPersonagem.SimplificationOptions.PreserveBoneWeights = true;
    
    // ... (executar simplificação e aplicar malha)
}
</skinnedmeshrenderer>

Problema 3: Simplificação Lenta e Consumo Excessivo de Memória

Causa: Configurações muito agressivas para manter detalhes ou processamento de malhas excessivamente grandes.

Solução:

var opcoesOtimizadas = SimplificationOptions.Default;
opcoesOtimizadas.MaxIterationCount = 50;            // Reduz o número de iterações
opcoesOtimizadas.PreserveSurfaceCurvature = false;  // Desativa a preservação da curvatura se não for crítica
opcoesOtimizadas.ManualUVComponentCount = true;     // Controla manualmente canais UV
opcoesOtimizadas.UVComponentCount = 2;              // Limita a dois canais UV se apenas um/dois são usados

simplificador.SimplificationOptions = opcoesOtimizadas;

Tópicos Avançados: Fundamentos do Algoritmo e Extensibilidade

Aprofundamento no Algoritmo de Simplificação por Erro Quadrático

O UnityMeshSimplifier emprega uma metodologia QEM que calcula o custo de contrair cada aresta, escolhendo as que introduzem o menor erro geométrico. O erro de um vértice é definido como a soma dos quadrados das distâncias do vértice aos planos incidentes.

Cálculo central do erro:

// Calcula o erro ao contrair uma aresta entre dois vértices e determina a nova posição
private double CalcularErroDeAresta(ref VerticeDados vtxA, ref VerticeDados vtxB, out Vector3d resultadoNovaPosicao)
{
    // Soma as matrizes de erro dos dois vértices para obter a matriz de erro da aresta
    SymmetricMatrix matrizQ = vtxA.matrizErro + vtxB.matrizErro;
    bool arestaBorda = vtxA.isBorda && vtxB.isBorda;
    
    // Tenta encontrar a posição ideal do novo vértice (minimiza o erro quadrático)
    double determinante = matrizQ.Determinant1();
    if (determinante != 0 && !arestaBorda)
    {
        // Se a matriz for invertível e não for uma aresta de borda, calcula a posição ótima
        resultadoNovaPosicao = new Vector3d(
            -matrizQ.Determinant2() / determinante,
            matrizQ.Determinant3() / determinante,
            -matrizQ.Determinant4() / determinante
        );
    }
    else
    {
        // Caso contrário, usa o ponto médio da aresta
        resultadoNovaPosicao = (vtxA.posicao + vtxB.posicao) * 0.5;
    }
    
    // Retorna o erro final associado a esta contração
    return AvaliarErroVertice(ref matrizQ, resultadoNovaPosicao.x, resultadoNovaPosicao.y, resultadoNovaPosicao.z);
}

Desenvolvimento de Estratégias de Simplificação Personalizadas

A arquitetura do UnityMeshSimplifier permite a criação de lógicas de simplificação customizadas através da herança da classe MeshSimplifier. Isso é útil para implementar regras específicas que protejam certas regiões da malha ou apliquem critérios de erro diferenciados.

public class MeuSimplificadorPersonalizado : MeshSimplifier
{
    // Construtor que passa a malha base para o construtor pai
    public MeuSimplificadorPersonalizado(Mesh mesh) : base(mesh) { }

    protected override double CalculateEdgeError(Vertex v0, Vertex v1)
    {
        // Calcula o erro base usando a implementação padrão
        double erroBase = base.CalculateEdgeError(v0, v1);
        
        // Adiciona lógica de erro personalizada para proteger áreas críticas
        if (EstaEmAreaCritica(v0) || EstaEmAreaCritica(v1))
        {
            erroBase *= 10.0; // Aumenta o erro para desencorajar a simplificação nesta região
        }
        
        return erroBase;
    }
    
    // Método auxiliar para determinar se um vértice está em uma área crítica
    private bool EstaEmAreaCritica(Vertex vertice)
    {
        // Exemplo: proteger uma área "facial" baseada em coordenadas Y e X
        Vector3 posWorld = (Vector3)vertice.p; // Convertendo para Vector3 do Unity
        return posWorld.y > 1.5f && Mathf.Abs(posWorld.x) < 0.3f; // Assumindo uma "cabeça"
    }
}