En este módulo, aprenderemos sobre diversas técnicas de optimización en Unreal Engine, especialmente cuando trabajamos con C++. La optimización es crucial para asegurar que nuestros juegos y aplicaciones funcionen de manera eficiente y sin problemas en una variedad de hardware. Abordaremos conceptos clave, estrategias y prácticas recomendadas para mejorar el rendimiento de nuestros proyectos.

• Definición: El profiling es el proceso de medir el rendimiento de tu aplicación para identificar cuellos de botella y áreas que necesitan optimización.
• Herramientas: Unreal Engine proporciona herramientas como el Unreal Insights y el Stat Command para realizar profiling.

• Definición: Un draw call es una instrucción enviada a la GPU para renderizar un objeto. Reducir el número de draw calls puede mejorar significativamente el rendimiento.
• Técnicas:
  • Instancing: Utilizar instancing para renderizar múltiples copias de un objeto con una sola draw call.
  • Batching: Agrupar objetos que comparten materiales y texturas.

• Compresión de Texturas: Utilizar formatos de compresión de texturas adecuados para reducir el uso de memoria.
• Materiales Simples: Evitar el uso de materiales complejos y shaders costosos.

• Garbage Collection: Entender y optimizar el proceso de recolección de basura en Unreal Engine.
• Pooling de Objetos: Reutilizar objetos en lugar de crear y destruir instancias repetidamente.

• Evitar Bucles Costosos: Minimizar el uso de bucles anidados y operaciones costosas dentro de bucles.
• Uso Eficiente de Algoritmos: Seleccionar algoritmos eficientes y adecuados para las tareas específicas.

1. Abrir Unreal Insights:

   • Ve a Window > Developer Tools > Unreal Insights.
   • Inicia una sesión de profiling y ejecuta tu proyecto para recopilar datos de rendimiento.

2. Analizar Resultados:

   • Identifica los cuellos de botella en el rendimiento, como tiempos de renderizado altos o uso excesivo de memoria.

1. Utilizar Instancing:

   // Ejemplo de instancing en C++
   UInstancedStaticMeshComponent* InstancedMesh = CreateDefaultSubobject<UInstancedStaticMeshComponent>(TEXT("InstancedMesh"));
   InstancedMesh->SetStaticMesh(SomeStaticMesh);
   for (int32 i = 0; i < 100; ++i)
   {
       FTransform InstanceTransform;
       InstanceTransform.SetLocation(FVector(i * 100.0f, 0.0f, 0.0f));
       InstancedMesh->AddInstance(InstanceTransform);
   }
   

2. Batching de Objetos:

   • Agrupa objetos que comparten materiales y texturas para reducir el número de draw calls.

1. Compresión de Texturas:

   • Utiliza formatos como DXT1 para texturas con pocas variaciones de color y DXT5 para texturas con transparencia.

2. Simplificación de Materiales:

   • Evita el uso de nodos de material costosos y shaders complejos. Utiliza materiales simples siempre que sea posible.

1. Pooling de Objetos:

   // Ejemplo de pooling de objetos en C++
   TArray<AActor*> ObjectPool;
   for (int32 i = 0; i < PoolSize; ++i)
   {
       AActor* PooledObject = GetWorld()->SpawnActor<AActor>(ObjectClass);
       PooledObject->SetActorHiddenInGame(true);
       ObjectPool.Add(PooledObject);
   }
   
   AActor* GetPooledObject()
   {
       for (AActor* PooledObject : ObjectPool)
       {
           if (!PooledObject->IsActive())
           {
               PooledObject->SetActorHiddenInGame(false);
               return PooledObject;
           }
       }
       return nullptr;
   }
   

1. Evitar Bucles Costosos:

   • Revisa tu código para identificar y optimizar bucles anidados y operaciones costosas dentro de bucles.

2. Uso Eficiente de Algoritmos:

   • Selecciona algoritmos eficientes y adecuados para las tareas específicas. Por ejemplo, utiliza algoritmos de búsqueda y ordenación eficientes.

1. Descripción: Tienes un nivel con múltiples objetos estáticos y dinámicos. Realiza profiling para identificar cuellos de botella y aplica técnicas de optimización para mejorar el rendimiento.

2. Pasos:

   • Realiza profiling del nivel utilizando Unreal Insights.
   • Identifica los cuellos de botella en el rendimiento.
   • Aplica técnicas de instancing y batching para reducir draw calls.
   • Optimiza las texturas y materiales utilizados en el nivel.
   • Implementa pooling de objetos para gestionar la memoria de manera eficiente.
   • Revisa y optimiza el código para evitar bucles costosos y utilizar algoritmos eficientes.

1. Profiling:

   • Utiliza Unreal Insights para identificar que el mayor cuello de botella es el número de draw calls.

2. Reducir Draw Calls:

   • Implementa instancing para objetos repetitivos como árboles y rocas.
   • Agrupa objetos que comparten materiales y texturas.

3. Optimización de Texturas y Materiales:

   • Comprime las texturas utilizando formatos adecuados.
   • Simplifica los materiales eliminando nodos costosos.

4. Gestión de Memoria:

   • Implementa pooling de objetos para reutilizar instancias de enemigos y otros objetos dinámicos.

5. Optimización de Código:

   • Revisa el código para eliminar bucles anidados y operaciones costosas dentro de bucles.
   • Utiliza algoritmos eficientes para tareas de búsqueda y ordenación.

En este módulo, hemos aprendido diversas técnicas de optimización en Unreal Engine, desde la reducción de draw calls hasta la gestión eficiente de la memoria y la optimización del código. La optimización es un proceso continuo y crítico para asegurar que nuestros proyectos funcionen de manera eficiente y sin problemas. Con las herramientas y técnicas adecuadas, podemos identificar y resolver cuellos de botella en el rendimiento, mejorando la experiencia del usuario final.