El Projecte | Sobre nosaltres | Contribuir | Donacions | Llicència
HOME Els meus cursos Finalitzats
◄ Anterior
◄

Tècniques d'Optimització

Següent ►
►

Introducció

En aquest tema, explorarem diverses tècniques d'optimització per millorar el rendiment dels teus projectes a Unreal Engine. L'optimització és crucial per assegurar que els teus jocs funcionin de manera fluida i eficient, especialment en dispositius amb recursos limitats. Aprendrem a identificar colls d'ampolla i a aplicar solucions per millorar el rendiment.

Conceptes Clau

  1. Profiling: Identificar les parts del codi o del projecte que consumeixen més recursos.
  2. Optimització de la CPU: Reduir la càrrega de la CPU mitjançant tècniques com la reducció de la complexitat dels scripts.
  3. Optimització de la GPU: Millorar el rendiment gràfic ajustant els shaders, les textures i els models.
  4. Gestió de la Memòria: Assegurar que la memòria s'utilitzi de manera eficient per evitar fugues de memòria i altres problemes.
  5. Optimització de la Xarxa: Reduir la latència i l'ús de l'ample de banda en jocs multijugador.

Profiling

Eines de Profiling

Unreal Engine proporciona diverses eines per al profiling:

  • Unreal Insights: Una eina completa per analitzar el rendiment del joc.
  • Stat Commands: Comandes de consola que mostren informació en temps real sobre el rendiment.
  • Session Frontend: Permet analitzar el rendiment de les sessions de joc.

Exemple Pràctic

// Exemple d'ús de comandes de profiling
void AMyActor::BeginPlay()
{
    Super::BeginPlay();
    
    // Activar el profiling de la CPU
    GEngine->Exec(GetWorld(), TEXT("stat startfile"));
    
    // Desactivar el profiling després de 10 segons
    FTimerHandle TimerHandle;
    GetWorld()->GetTimerManager().SetTimer(TimerHandle, this, &AMyActor::StopProfiling, 10.0f, false);
}

void AMyActor::StopProfiling()
{
    GEngine->Exec(GetWorld(), TEXT("stat stopfile"));
}

Optimització de la CPU

Reduir la Complexitat dels Scripts

  • Evitar Bucles Innecessaris: Reduir el nombre d'iteracions en bucles.
  • Utilitzar Funcions Natives: Les funcions natives són més ràpides que les funcions personalitzades.

Exemple Pràctic

// Exemple de reducció de la complexitat d'un bucle
for (int32 i = 0; i < Array.Num(); ++i)
{
    if (Array[i] == TargetValue)
    {
        // Fer alguna cosa
        break; // Sortir del bucle tan aviat com es trobi el valor
    }
}

Optimització de la GPU

Ajustar Shaders i Textures

  • Reduir la Resolució de les Textures: Utilitzar textures de menor resolució quan sigui possible.
  • Simplificar Shaders: Evitar l'ús de shaders complexos que consumeixen molts recursos.

Exemple Pràctic

// Exemple de simplificació d'un shader
Material'/Game/Materials/SimpleMaterial.SimpleMaterial'
{
    // Utilitzar un shader simple amb menys instruccions
    BaseColor = TextureSample(Texture2D'/Game/Textures/SimpleTexture.SimpleTexture');
}

Gestió de la Memòria

Evitar Fugues de Memòria

  • Destruir Objectes Innecessaris: Assegurar-se que els objectes que ja no es necessiten es destrueixen correctament.
  • Utilitzar Smart Pointers: Utilitzar smart pointers per gestionar la memòria de manera automàtica.

Exemple Pràctic

// Exemple d'ús de smart pointers
TSharedPtr<MyClass> MyObject = MakeShareable(new MyClass());

Optimització de la Xarxa

Reduir la Latència

  • Compressió de Dades: Comprimir les dades abans d'enviar-les per la xarxa.
  • Sincronització Eficient: Sincronitzar només les dades necessàries.

Exemple Pràctic

// Exemple de compressió de dades
FBufferArchive Buffer;
Buffer << MyData;
FCompressedBuffer CompressedBuffer = FCompression::CompressMemory(ECompressionFlags::COMPRESS_ZLIB, Buffer.GetData(), Buffer.Num());

Exercicis Pràctics

Exercici 1: Identificar Colls d'Ampolla

  1. Utilitza Unreal Insights per identificar un coll d'ampolla en el teu projecte.
  2. Documenta els passos que has seguit i les conclusions a les quals has arribat.

Exercici 2: Optimització de la CPU

  1. Troba un bucle en el teu projecte que pugui ser optimitzat.
  2. Aplica les tècniques apreses per reduir la complexitat del bucle.

Exercici 3: Optimització de la GPU

  1. Identifica un shader complex en el teu projecte.
  2. Simplifica el shader per millorar el rendiment.

Exercici 4: Gestió de la Memòria

  1. Revisa el teu projecte per trobar possibles fugues de memòria.
  2. Utilitza smart pointers per gestionar la memòria de manera eficient.

Solucions

Solució a l'Exercici 1

  1. Obre Unreal Insights i grava una sessió de profiling mentre el teu joc està en execució.
  2. Analitza els resultats per identificar les funcions que consumeixen més temps de CPU.
  3. Documenta les teves troballes i proposa solucions per millorar el rendiment.

Solució a l'Exercici 2

// Abans de l'optimització
for (int32 i = 0; i < Array.Num(); ++i)
{
    for (int32 j = 0; j < AnotherArray.Num(); ++j)
    {
        // Codi complex
    }
}

// Després de l'optimització
for (int32 i = 0; i < Array.Num(); ++i)
{
    // Codi optimitzat
}

Solució a l'Exercici 3

// Shader complex
Material'/Game/Materials/ComplexMaterial.ComplexMaterial'
{
    // Codi del shader complex
}

// Shader simplificat
Material'/Game/Materials/SimpleMaterial.SimpleMaterial'
{
    // Codi del shader simplificat
}

Solució a l'Exercici 4

// Abans de l'optimització
MyClass* MyObject = new MyClass();

// Després de l'optimització
TSharedPtr<MyClass> MyObject = MakeShareable(new MyClass());

Conclusió

En aquest tema, hem après diverses tècniques d'optimització per millorar el rendiment dels nostres projectes a Unreal Engine. Hem explorat com identificar colls d'ampolla, optimitzar la CPU i la GPU, gestionar la memòria de manera eficient i optimitzar la xarxa. Amb aquestes tècniques, podràs assegurar-te que els teus jocs funcionin de manera fluida i eficient.

◄ Anterior
◄
Següent ►
►
El Projecte | Sobre nosaltres | Contribuir | Donacions | Llicència
© Copyright 2024. Tots els drets reservats