Attention: Here be dragons

This is the latest (unstable) version of this documentation, which may document features not available in or compatible with released stable versions of Godot.

Interpolazione avanzata della fisica

Sebbene le istruzioni precedenti diano risultati soddisfacenti in molti giochi, in alcuni casi è consigliabile fare un passo in più per ottenere i migliori risultati possibili e un'esperienza di gioco più fluida.

Eccezioni all'interpolazione automatica della fisica

Anche con l'interpolazione della fisica attiva, potrebbero esserci alcune situazioni locali in cui sarebbe utile disabilitare l'interpolazione automatica per un Node (o un ramo dello SceneTree) e avere un controllo più preciso effettuando l'interpolazione manualmente.

Questo è possibile tramite la proprietà Node.physics_interpolation_mode presente in tutti i nodi. Se, ad esempio, si disattiva l'interpolazione per un nodo, anche i figli saranno influenzati ricorsivamente (poiché normalmente ereditano l'impostazione del genitore). Ciò significa che è possibile disabilitare facilmente l'interpolazione per un'intera sotto-scena.

../../../_images/physics_interpolation_mode.webp

È importante notare che, in entrambi 2D e 3D, l'interpolazione della fisica è effettuata sulla trasformazione locale di ogni istanza. Durante il rendering, le trasformazioni locali interpolate sono trasmesse ai figli.

This means that if a parent has physics_interpolation_mode set to On, but the child is set to Off, the child's inherited transform will still be interpolated if the parent is moving. Only the child's local transform is uninterpolated. Controlling the on/off behavior of nodes therefore requires some thought and planning.

Nota

Prior to Godot 4.5, parent nodes did not propagate physics-interpolated transforms to children in the scene tree. This could result in "clunking" in the first child with physics_interpolation_mode Off. Because of this, early tutorials often recommended specifying non-interpolated cameras in global space (by e.g. setting Node3D.top_level). This behavior was fixed in Godot 4.5.

La situazione più comune in cui potrebbe essere necessario effettuare una propria interpolazione è per le telecamere.

Telecamere

Camera3D can use automatic interpolation just like any other node. However, for best results, it is in many cases recommended that you take a manual approach to camera interpolation, especially at low physics tick rates.

Questo perché gli utenti sono molto sensibili ai movimenti della telecamera. Ad esempio, una Camera3D che si riallinea leggermente ogni 1/10 di secondo (a una frequenza di 10 TPS) sarà spesso percettibile. È possibile ottenere un risultato molto più fluido spostando la telecamera a ogni frame in _process e seguendo manualmente un obiettivo interpolato.

Interpolazione manuale della telecamera

Esempio tipico

Un tipico esempio di approccio personalizzato consiste nell'utilizzare la funzione look_at nella Camera3D ad ogni frame in _process() per guardare un nodo obiettivo (come il giocatore).

C'è però un problema. Se usiamo il tradizionale get_global_transform() su un nodo "obiettivo" di una Camera3D, questa trasformazione metterà a fuoco la Camera3D solo sull'obiettivo al tick di fisica attuale. Questo non è ciò che vogliamo, poiché la telecamera salterà a ogni tick fisico man mano che l'obiettivo si muove. Anche se la telecamera è aggiornata a ogni frame, questo non aiuta a ottenere un movimento fluido se l'obiettivo cambia solo a ogni tick di fisica.

get_global_transform_interpolated()

Ciò su cui vogliamo mettere a fuoco la telecamera non è la posizione dell'obiettivo sul tick di fisica, bensì la posizione interpolata, ovvero la posizione in cui l'obiettivo sarà renderizzato.

Possiamo farlo attraverso la funzione Node3D.get_global_transform_interpolated. Questa si comporta esattamente come ottenere Node3D.global_transform, ma restituisce la trasformazione interpolata (durante una chiamata a _process()).

Importante

Si dovrebbe usare la funzione get_global_transform_interpolated() solo una o due volte in casi particolari, ad esempio per le telecamere. Non si dovrebbe usare dappertutto nel codice (sia per motivi di prestazioni, sia per garantire un'esperienza corretta).

Nota

A parte eccezioni come la telecamera, nella maggior parte dei casi la logica di gioco dovrebbe trovarsi in _physics_process(). Nella logica di gioco dovresti chiamare get_global_transform() o get_transform(), che restituiranno la trasformazione fisica attuale (nello spazio globale o locale, rispettivamente), che è solitamente ciò che servirà per il codice di gioco.

Script di esempio di camera manuale

Here is a basic example of a camera which follows an interpolated target:

extends Camera3D

# Node that the camera will follow
var _target

# We will smoothly lerp to follow the target
# rather than follow exactly
var _target_pos : Vector3 = Vector3()

func _ready() -> void:
    # Find the target node
    _target = get_node("../Player")

    # Turn off automatic physics interpolation for the Camera3D, manually.
    # This can alternatively be done in the Inspector.
    set_physics_interpolation_mode(Node.PHYSICS_INTERPOLATION_MODE_OFF)

func _process(delta: float) -> void:
    # Find the current interpolated transform of the target
    var tr : Transform = _target.get_global_transform_interpolated()

    # Provide some delayed smoothed lerping towards the target position
    _target_pos = lerp(_target_pos, tr.origin, min(delta, 1.0))

    # Our interpolated target, and a vector pointing up.
    look_at(_target_pos, Vector3(0, 1, 0))

Sguardo con il mouse

Il movimento del mouse è un metodo molto comune per controllare le telecamere. Tuttavia, c'è un problema. A differenza dell'input da tastiera, che si può campionare periodicamente ogni tick di fisica, gli eventi di movimento del mouse possono occorrere continuamente. La telecamera dovrà reagire e seguire questi movimenti del mouse nel frame successivo, anziché attendere il tick di fisica successivo.

In questa situazione, può essere meglio disabilitare l'interpolazione della fisica per il nodo della telecamera (tramite Node.physics_interpolation_mode) e applicare direttamente l'input dal mouse alla rotazione della telecamera, piuttosto che applicarlo in _physics_process.

Often, especially with cameras and camera rigs, you will want to use a combination of interpolation and non-interpolation, as in these examples:

  • First person camera: inherit the physics-interpolated position of a parent physics body, but perform rotation without interpolation, using a mouse.

  • Third person camera: determine the target position (where is it looking at) by calling Node3D.get_global_transform_interpolated, but move the camera with the mouse and without interpolation.

Usually you can do this with a subscene arranged something like this: (where ``physics_interpolation_mode`` is specified in square brackets)

PhysicsBody3D ["On"] (or inheriting "On")
└── Node3D ["Off"] acting as a "rig" used to control yaw
    ├── MeshInstance3D ["Inherit"] for visuals
    └── Camera3D ["Inherit"] used to control pitch

With this setup, all children of the "rig" node will therefore inherit the smoothed position from the parent PhysicsBody3D, but can react immediately to mouse movement because local transforms will be uninterpolated.

Esistono numerose permutazioni e variazioni di telecamere, ma dovrebbe essere chiaro che in molti casi, disabilitare l'interpolazione automatica della fisica e gestirla manualmente può fornire un risultato migliore.

Disabilitare l'interpolazione su altri nodi

Although cameras are the most common example, there are a number of cases when you may wish other nodes to control their own interpolation, or be non-interpolated. Consider for example, a player in a top view game whose rotation is controlled by mouse look. Disabling physics interpolation allows the player rotation to match the mouse in real time. This would correspond to the "rig" in the earlier example, but without a camera as a child.

I MultiMesh

Sebbene la maggior parte dei nodi visivi segua il paradigma di un singolo nodo e una singola istanza visiva, i MultiMesh possono controllare diverse istanze dallo stesso nodo. Pertanto, includono qualche funzione in più per controllare la funzionalità di interpolazione per ogni singola istanza. È consigliabile esplorare queste funzioni se si utilizzano MultiMesh con interpolazione.

I dettagli completi sono disponibili nella documentazione MultiMesh.