[Unreal Engine] FMath::FInterpConstantTo

Il FMath::FInterpConstantTo interpola il float dalla Posizione attuale al Target desiderato con un andamento costante.

FMath::FInterpConstantTo, Riferimenti

Module 	Core
Header 	/Engine/Source/Runtime/Core/Public/Math/UnrealMathUtility.h
Include 	#include "Math/UnrealMathUtility.h"
Source 	/Engine/Source/Runtime/Core/Private/Math/UnrealMath.cpp

Sintassi:

 static float FInterpConstantTo
(
    float Current,
    float Target,
    float DeltaTime,
    float InterpSpeed
)

• Current: il valore di partenza da cui si desidera iniziare l’interpolazione.
• Target: il valore di destinazione a cui si desidera arrivare.
• DeltaTime: il tempo trascorso tra un frame e l’altro, solitamente ottenuto dal frametime del gioco.
• InterpSpeed: la velocità di interpolazione, che determina quanto rapidamente l’oggetto si sposterà verso il valore di destinazione.

La funzione restituirà il nuovo valore interpolato che può essere utilizzato per aggiornare l’oggetto o il parametro desiderato.

Esempio sulla rotazione

Nella classe corrente di MioScript.h:

 private:
      float TargetYaw = 90.f; 
      float InitialYaw = 0.f; 
      float CurrentYaw;

MioScript.cpp:

// Called every frame
void UMioScript::TickComponent(float DeltaTime, ELevelTick TickType, FActorComponentTickFunction* ThisTickFunction)
{
      Super::TickComponent(DeltaTime, TickType, ThisTickFunction);

      // HERE BEGIN CODE
      CurrentYaw = GetOwner()->GetActorRotation().Yaw;
      FRotator OpenDoor(0.f, TargetYaw, 0.f);

      /*
      Change Yaw of OpenDoor      
      StartingYaw
      TargetYaw: CurrentYaw
      0-1
      */
      OpenDoor.Yaw = FMath::FInterpConstantTo(CurrentYaw, TargetYaw, DeltaTime, 45);
      GetOwner()->SetActorRotation(OpenDoor);
}

Questo è un esempio di codice all’interno di una funzione TickComponent di una classe chiamata UMioScript, che estende la classe base AActorComponent in Unreal Engine. Questa funzione viene chiamata ad ogni frame per aggiornare il componente.

Ecco una descrizione linea per linea del codice:

1. Super::TickComponent(DeltaTime, TickType, ThisTickFunction); – Questa chiamata richiama l’implementazione della classe base per assicurarsi che la logica di aggiornamento di base venga eseguita correttamente.
2. CurrentYaw = GetOwner()->GetActorRotation().Yaw; – Questa riga ottiene l’angolo di rotazione attuale (yaw) dell’oggetto proprietario del componente e lo assegna alla variabile CurrentYaw.
3. FRotator OpenDoor(0.f, TargetYaw, 0.f); – Qui viene creato un oggetto FRotator chiamato OpenDoor con valori predefiniti di roll e pitch pari a 0 e un valore di yaw impostato sulla variabile TargetYaw.
4. OpenDoor.Yaw = FMath::FInterpConstantTo(CurrentYaw, TargetYaw, DeltaTime, 45); – Questa riga utilizza la funzione FMath::FInterpConstantTo per calcolare un nuovo valore di yaw per l’oggetto OpenDoor. L’interpolazione costante viene utilizzata per spostare gradualmente il valore di CurrentYaw verso il valore di TargetYaw con una velocità di interpolazione di 45 unità al secondo. Il risultato viene quindi assegnato a OpenDoor.Yaw.
5. GetOwner()->SetActorRotation(OpenDoor); – Questa riga imposta la rotazione dell’oggetto proprietario del componente sul valore di OpenDoor, applicando la rotazione calcolata nell’interpolazione costante.

In sostanza, questo codice viene utilizzato per creare un’animazione di transizione fluida della rotazione di un oggetto nel tempo. Ad ogni frame, la funzione TickComponent calcola un nuovo valore di rotazione per l’oggetto, spostandolo gradualmente da CurrentYaw a TargetYaw utilizzando l’interpolazione costante. Infine, viene impostata la nuova rotazione sull’oggetto.

Un altro esempio

Ed ecco un altro esempio di utilizzo della funzione FMath::FInterpConstantTo per interpolare un valore da 0 a 100 con una velocità di 50 unità al secondo:

float StartValue = 0.0f;
float TargetValue = 100.0f;
float InterpolationSpeed = 50.0f;

// Nel tuo ciclo di gioco o aggiornamento
float DeltaTime = ...; // Ottenere il tempo trascorso tra un frame e l'altro

float InterpolatedValue = FMath::FInterpConstantTo(StartValue, TargetValue, DeltaTime, InterpolationSpeed);

// Usa InterpolatedValue per aggiornare l'oggetto o il parametro desiderato

Questa funzione è molto utile quando si desidera creare animazioni o transizioni fluide tra valori nel corso del tempo, senza accelerazioni o decelerazioni.

I nostri corsi : https://www.develop4fun.it/premium-corsi-online-in-abbonamento

▼ SEGUICI SU ▼
» Facebook: https://www.facebook.com/developforfun
» Instagram: https://www.instagram.com/develop4fun
» Twitter: https://twitter.com/Develop4fun

VISITA IL NOSTRO SITO WEB: https://www.develop4fun.it
ISCRIVITI SUBITO AL NOSTRO CANALE: https://www.youtube.com/channel/UCZ4dhshzpVbbRPVuL9TNH4Q