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.
Checking the stable version of the documentation...
RigidBody3D
Eredita: PhysicsBody3D < CollisionObject3D < Node3D < Node < Object
Ereditato da: VehicleBody3D
Un corpo fisico 2D che viene spostato da una simulazione fisica.
Descrizione
RigidBody2D implementa la fisica 3D completa. Non può essere controllato direttamente, ma è necessario applicargli delle forze (gravità, impulsi, ecc.) e la simulazione fisica calcolerà il movimento risultante, la rotazione, reagirà alle collisioni e influenzerà altri corpi fisici sul suo percorso.
Il comportamento del corpo può essere regolato tramite lock_rotation, freeze e freeze_mode. Modificando varie proprietà dell'oggetto, come mass, puoi controllare come la simulazione fisica agisce su di esso.
Un corpo rigido manterrà sempre la sua forma e dimensione, anche quando gli vengono applicate delle forze. È utile per oggetti con cui è possibile interagire in un ambiente, come un albero che può essere abbattuto o una pila di casse che può essere spinta.
Se devi influenzare direttamente il corpo, preferisci implementare _integrate_forces() in quanto ti consente di accedere direttamente allo stato fisico.
Se hai bisogno di sovrascrivere il comportamento fisico predefinito, puoi scrivere una funzione di integrazione delle forze personalizzata. Vedi custom_integrator.
Nota: Cambiare la trasformazione 3D o linear_velocity di un RigidBody3D molto spesso può portare ad alcuni comportamenti imprevedibili. Questo accade anche quando un RigidBody3D è il discendente di un nodo in continuo movimento, come un altro RigidBody3D, poiché ciò causerà l'impostazione della sua trasformazione globale ogni volta che il suo antenato si muove.
Tutorial
Proprietà
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
Metodi
void |
_integrate_forces(state: PhysicsDirectBodyState3D) virtual |
void |
add_constant_central_force(force: Vector3) |
void |
add_constant_force(force: Vector3, position: Vector3 = Vector3(0, 0, 0)) |
void |
add_constant_torque(torque: Vector3) |
void |
apply_central_force(force: Vector3) |
void |
apply_central_impulse(impulse: Vector3) |
void |
apply_force(force: Vector3, position: Vector3 = Vector3(0, 0, 0)) |
void |
apply_impulse(impulse: Vector3, position: Vector3 = Vector3(0, 0, 0)) |
void |
apply_torque(torque: Vector3) |
void |
apply_torque_impulse(impulse: Vector3) |
get_colliding_bodies() const |
|
get_contact_count() const |
|
get_inverse_inertia_tensor() const |
|
void |
set_axis_velocity(axis_velocity: Vector3) |
Segnali
Emesso quando avviene una collisione con un altro PhysicsBody3D o GridMap. Richiede che contact_monitor sia impostato su true e che max_contacts_reported sia impostato su un valore alto abbastanza da rilevare tutte le collisioni. Le GridMap sono rilevate se il MeshLibrary ha contiene collisioni Shape3D.
body è il Node, se esiste nell'albero, dell'altro PhysicsBody3D o GridMap.
Emesso quando termina la collisione con un altro PhysicsBody3D o GridMap. Richiede che contact_monitor sia impostato su true e che max_contacts_reported sia impostato su un valore alto abbastanza da rilevare tutte le collisioni. Le GridMap sono rilevate se il MeshLibrary ha contiene collisioni Shape3D.
body è il Node, se esiste nell'albero, dell'altro PhysicsBody3D o GridMap.
body_shape_entered(body_rid: RID, body: Node, body_shape_index: int, local_shape_index: int) 🔗
Emesso quando uno degli Shape3D di questo RigidBody2D entra in collisione con un altro Shape3D di PhysicsBody3D o GridMap. Richiede che contact_monitor sia impostato su true e che max_contacts_reported sia impostato su un valore alto abbastanza da rilevare tutte le collisioni. I GridMap sono rilevati se il MeshLibrary contiene collisioni Shape3D.
body_rid è il RID del CollisionObject3D dell'altro PhysicsBody3D o GridMap utilizzato dal PhysicsServer2D.
body è il Node, se presente nell'albero, dell'altro PhysicsBody3D o GridMap.
body_shape_index l'indice dello Shape3D dell'altro PhysicsBody3D o GridMap utilizzato dal PhysicsServer3D. Ottieni il nodo CollisionShape3D con body.shape_owner_get_owner(body.shape_find_owner(body_shape_index)).
local_shape_index è l'indice dello Shape3D di questo RigidBody3D utilizzato dal PhysicsServer3D. Ottieni il nodo CollisionShape3D con self.shape_owner_get_owner(self.shape_find_owner(local_shape_index)).
body_shape_exited(body_rid: RID, body: Node, body_shape_index: int, local_shape_index: int) 🔗
Emesso quando termina la collisione tra uno degli Shape3D di questo RigidBody3D e un altro Shape3D di PhysicsBody3D o GridMap. Richiede che contact_monitor sia impostato su true e che max_contacts_reported sia impostato su un valore alto abbastanza da rilevare tutte le collisioni. I GridMap sono rilevati se il MeshLibrary contiene collisioni Shape3D.
body_rid è il RID del CollisionObject3D dell'altro PhysicsBody3D o GridMap utilizzato dal PhysicsServer2D.
body è il Node, se presente nell'albero, dell'altro PhysicsBody3D o GridMap.
body_shape_index l'indice dello Shape3D dell'altro PhysicsBody3D o GridMap utilizzato dal PhysicsServer3D. Ottieni il nodo CollisionShape3D con body.shape_owner_get_owner(body.shape_find_owner(body_shape_index)).
local_shape_index è l'indice dello Shape3D di questo RigidBody3D utilizzato dal PhysicsServer3D. Ottieni il nodo CollisionShape3D con self.shape_owner_get_owner(self.shape_find_owner(local_shape_index)).
sleeping_state_changed() 🔗
Emesso quando il motore fisico cambia lo stato di riposo del corpo.
Nota: La modifica del valore sleeping non attiverà questo segnale. Viene emesso solo se lo stato di riposo viene modificato dal motore fisico o se viene utilizzato emit_signal("sleeping_state_changed").
Enumerazioni
enum FreezeMode: 🔗
FreezeMode FREEZE_MODE_STATIC = 0
Modalità di congelamento di corpo statico (predefinita). Il corpo non è influenzato dalla gravità e dalle forze. Può essere spostato solo tramite codice utente e non entra in collisione con altri corpi lungo il suo percorso.
FreezeMode FREEZE_MODE_KINEMATIC = 1
Modalità di congelamento di corpo cinematico. Simile a FREEZE_MODE_STATIC, ma si scontra con altri corpi lungo il suo percorso quando viene spostato. Utile per un corpo congelato che deve essere animato.
enum CenterOfMassMode: 🔗
CenterOfMassMode CENTER_OF_MASS_MODE_AUTO = 0
In questa modalità, il centro di massa del corpo viene calcolato automaticamente in base alle sue forme. Ciò presuppone che le origini delle forme siano anche il loro centro di massa.
CenterOfMassMode CENTER_OF_MASS_MODE_CUSTOM = 1
In questa modalità, il centro di massa del corpo è impostato tramite center_of_mass. Il valore predefinito è la posizione di origine del corpo.
enum DampMode: 🔗
DampMode DAMP_MODE_COMBINE = 0
In questa modalità, il valore di smorzamento del corpo è aggiunto a qualsiasi valore impostato nelle aree o al valore predefinito.
DampMode DAMP_MODE_REPLACE = 1
In questa modalità, il valore di smorzamento del corpo sostituisce qualsiasi valore impostato nelle aree o il valore predefinito.
Descrizioni delle proprietà
Smorza la rotazione del corpo. Come predefinito, il corpo utilizzerà impostazione del progetto ProjectSettings.physics/3d/default_angular_damp, o un valore sostitutivo impostato da un'Area3D in cui si trova il corpo. A seconda di angular_damp_mode, è possibile impostare angular_damp in modo che sia aggiunto o sostituito al valore di smorzamento del corpo.
Vedi ProjectSettings.physics/3d/default_angular_damp per ulteriori dettagli sullo smorzamento.
DampMode angular_damp_mode = 0 🔗
Definisce come angular_damp è applicato.
Vector3 angular_velocity = Vector3(0, 0, 0) 🔗
La velocità di rotazione del RigidBody3D in radianti al secondo.
Se true, il corpo può entrare in modalità di riposo quando non c'è movimento. Vedi sleeping.
Vector3 center_of_mass = Vector3(0, 0, 0) 🔗
Il centro di massa personalizzato del corpo, relativo alla posizione di origine del corpo, quando center_of_mass_mode è impostato su CENTER_OF_MASS_MODE_CUSTOM. Questo è il punto di equilibrio del corpo, dove le forze applicate provocano solo accelerazione lineare. Le forze applicate all'esterno del centro di massa provocano accelerazione angolare.
Quando center_of_mass_mode è impostato su CENTER_OF_MASS_MODE_AUTO (valore predefinito), il centro di massa è calcolato automaticamente, ma ciò non aggiorna il valore di center_of_mass.
CenterOfMassMode center_of_mass_mode = 0 🔗
void set_center_of_mass_mode(value: CenterOfMassMode)
CenterOfMassMode get_center_of_mass_mode()
Definisce il modo in cui è impostato il centro di massa del corpo.
Vector3 constant_force = Vector3(0, 0, 0) 🔗
Le forze posizionali costanti totali del corpo applicate durante ogni aggiornamento della fisica.
Vedi add_constant_force() e add_constant_central_force().
Vector3 constant_torque = Vector3(0, 0, 0) 🔗
Le forze rotazionali costanti totali del corpo applicate durante ogni aggiornamento della fisica.
Vedi add_constant_torque().
bool contact_monitor = false 🔗
Se true, il RigidBody3D emetterà segnali quando entra in collisione con un altro corpo.
Nota: Per impostazione predefinita, il numero massimo di contatti riportati è impostato su 0, il che significa che non sarà registrato nulla, vedi max_contacts_reported.
void set_use_continuous_collision_detection(value: bool)
bool is_using_continuous_collision_detection()
Se true, il rilevamento continuo delle collisioni viene usato.
Il rilevamento continuo delle collisioni cerca di prevedere dove un corpo in movimento entrerà in collisione, invece di spostarlo e correggerne il movimento in caso di collisione. Il rilevamento continuo delle collisioni è più lento, ma più preciso e manca meno collisioni con oggetti piccoli e in rapido movimento.
bool custom_integrator = false 🔗
Se true, l'integrazione predefinita delle forze (come gravità o smorzamento) sarà disabilitata per questo corpo. A parte la risposta alla collisione, il corpo si muoverà solo come determinato dal metodo _integrate_forces(), se tale metodo virtuale è sovrascritto.
Impostando questa proprietà sarà chiamato internamente il metodo PhysicsServer3D.body_set_omit_force_integration().
If true, the body is frozen. Gravity and forces are not applied anymore.
See freeze_mode to set the body's behavior when frozen.
Note: For a body that is always frozen, use StaticBody3D or AnimatableBody3D instead.
FreezeMode freeze_mode = 0 🔗
void set_freeze_mode(value: FreezeMode)
FreezeMode get_freeze_mode()
The body's freeze mode. Determines the body's behavior when freeze is true.
Note: For a body that is always frozen, use StaticBody3D or AnimatableBody3D instead.
Questo è moltiplicato per ProjectSettings.physics/3d/default_gravity per produrre la gravità di questo corpo. Ad esempio, un valore di 1.0 applicherà la gravità normale, 2.0 applicherà il doppio della gravità e 0.5 applicherà metà della gravità per questo corpo.
Vector3 inertia = Vector3(0, 0, 0) 🔗
Il momento di inerzia del corpo. È come la massa, ma per la rotazione: determina la quantità di coppia necessaria per ruotare il corpo. Il momento di inerzia è solitamente calcolato automaticamente dalla massa e dalle forme, ma questa proprietà consente di impostare un valore personalizzato.
Se impostato su Vector3.ZERO, l'inerzia viene calcolata automaticamente (valore predefinito).
Nota: Questo valore non cambia quando l'inerzia viene calcolata automaticamente. Usa il PhysicsServer3D per ottenere l'inerzia calcolata.
@onready var ball = $Ball
func get_ball_inertia():
return PhysicsServer3D.body_get_direct_state(ball.get_rid()).inverse_inertia.inverse()
private RigidBody3D _ball;
public override void _Ready()
{
_ball = GetNode<RigidBody3D>("Ball");
}
private Vector3 GetBallInertia()
{
return PhysicsServer3D.BodyGetDirectState(_ball.GetRid()).InverseInertia.Inverse();
}
Smorza il movimento del corpo. Come predefinito, il corpo utilizzerà l'impostazione ProjectSettings.physics/3d/default_linear_damp o qualsiasi valore di sostituzione impostato da un'Area3D in cui si trova il corpo. A seconda di linear_damp_mode, è possibile impostare linear_damp in modo che sia aggiunto o sostituito al valore di smorzamento del corpo.
Consulta ProjectSettings.physics/3d/default_linear_damp per ulteriori dettagli sullo smorzamento.
DampMode linear_damp_mode = 0 🔗
Definisce come linear_damp è applicato.
Vector3 linear_velocity = Vector3(0, 0, 0) 🔗
La velocità lineare del corpo in unità al secondo. Può essere usata sporadicamente, ma non impostarla ogni frame, perché la fisica potrebbe essere eseguita in un altro thread e funzionare a una granularità diversa. Usa _integrate_forces() come ciclo di processo per un controllo preciso dello stato del corpo.
Se true, il corpo non può ruotare. La gravità e le forze applicano solo un movimento lineare.
La massa del corpo.
int max_contacts_reported = 0 🔗
Il numero massimo di contatti che saranno registrati. Richiede un valore maggiore di 0 e contact_monitor impostato su true per iniziare a registrare i contatti. Usa get_contact_count() per recuperare il conteggio o get_colliding_bodies() per recuperare i corpi con cui si è verificata una collisione.
Nota: Il numero di contatti è diverso dal numero di collisioni. Le collisioni tra bordi paralleli risulteranno in due contatti (uno a ciascuna estremità) e le collisioni tra facce parallele risulteranno in quattro contatti (uno a ciascun angolo).
PhysicsMaterial physics_material_override 🔗
void set_physics_material_override(value: PhysicsMaterial)
PhysicsMaterial get_physics_material_override()
La sostituzione del materiale di fisica per il corpo.
Se a questa proprietà è assegnato un materiale, sarà utilizzato al posto di qualsiasi altro materiale di fisica, come ad esempio uno ereditato.
Se true, il corpo non si muoverà e non calcolerà le forze finché non sarà riattivato da un altro corpo, ad esempio tramite una collisione, o utilizzando i metodi apply_impulse() o apply_force().
Descrizioni dei metodi
void _integrate_forces(state: PhysicsDirectBodyState3D) virtual 🔗
Chiamato durante l'elaborazione di fisica, consente di leggere e modificare in modo sicuro lo stato di simulazione per l'oggetto. Per impostazione predefinita, viene chiamato prima dell'integrazione predefinita delle forze, ma la proprietà custom_integrator consente di disabilitare l'integrazione delle forze predefinita e di eseguire un'integrazione delle forze completamente personalizzata per un corpo.
void add_constant_central_force(force: Vector3) 🔗
Aggiunge una forza direzionale costante senza influenzare la rotazione che continua a essere applicata nel tempo finché non viene cancellata con constant_force = Vector3(0, 0, 0).
Ciò equivale a usare add_constant_force() al centro di massa del corpo.
void add_constant_force(force: Vector3, position: Vector3 = Vector3(0, 0, 0)) 🔗
Aggiunge una forza posizionata costante al corpo che continua a essere applicata nel tempo finché non viene cancellata con constant_force = Vector3(0, 0, 0).
position è lo scostamento dall'origine del corpo in coordinate globali.
void add_constant_torque(torque: Vector3) 🔗
Aggiunge una forza rotazionale costante senza influenzare la posizione che continua a essere applicata nel tempo finché non viene cancellata con constant_torque = Vector3(0, 0, 0).
void apply_central_force(force: Vector3) 🔗
Applica una forza direzionale senza influenzare la rotazione. Una forza è dipendente dal tempo e pensata per essere applicata a ogni aggiornamento della fisica
Ciò equivale a usare apply_force() al centro di massa del corpo.
void apply_central_impulse(impulse: Vector3) 🔗
Applica un impulso direzionale senza influenzare la rotazione.
Un impulso è indipendente dal tempo! Applicare un impulso a ogni frame risulterebbe in una forza dipendente dal frame rate. Per questo motivo, dovrebbe essere utilizzato solo quando si simulano impatti singoli (altrimenti, utilizza le funzioni "_force").
Ciò equivale a usare apply_impulse() al centro di massa del corpo.
void apply_force(force: Vector3, position: Vector3 = Vector3(0, 0, 0)) 🔗
Applica una forza posizionata al corpo. Una forza è dipendente dal tempo e deve essere applicata a ogni aggiornamento della fisica.
position è lo scostamento dall'origine del corpo in coordinate globali.
void apply_impulse(impulse: Vector3, position: Vector3 = Vector3(0, 0, 0)) 🔗
Applica un impulso posizionato al corpo.
Un impulso è indipendente dal tempo! Applicare un impulso a ogni frame risulterebbe in una forza dipendente dal frame rate. Per questo motivo, dovrebbe essere utilizzato solo quando si simulano impatti singoli (altrimenti, utilizza le funzioni "_force").
position è lo scostamento dall'origine del corpo in coordinate globali.
void apply_torque(torque: Vector3) 🔗
Applica una forza rotazionale senza influenzare la posizione. Una forza è dipendente dal tempo e deve essere applicata a ogni aggiornamento della fisica.
Nota: inertia è necessaria affinché ciò funzioni. Per avere inertia, un CollisionShape3D attivo deve essere un figlio del nodo, oppure puoi impostare manualmente inertia.
void apply_torque_impulse(impulse: Vector3) 🔗
Applica un impulso rotazionale al corpo senza influenzare la posizione.
Un impulso è indipendente dal tempo! Applicare un impulso a ogni frame risulterebbe in una forza dipendente dal frame rate. Per questo motivo, dovrebbe essere utilizzato solo quando si simulano impatti una sola volta (altrimenti, usa le funzioni "_force").
Nota: inertia è necessaria affinché ciò funzioni. Per avere inertia, un CollisionShape3D attivo deve essere un figlio del nodo, oppure puoi impostare manualmente inertia.
Array[Node3D] get_colliding_bodies() const 🔗
Restituisce una lista dei corpi in collisione con questo corpo. Richiede che contact_monitor sia impostato su true e che max_contacts_reported sia impostato su un valore alto abbastanza da rilevare tutte le collisioni.
Nota: Il risultato di questo test non è immediato dopo aver spostato gli oggetti. Per le prestazioni, la lista delle collisioni è aggiornata una volta per frame e prima del passaggio di fisica. Si consiglia invece di usare i segnali.
int get_contact_count() const 🔗
Restituisce il numero di contatti che questo corpo ha con altri corpi. Per impostazione predefinita, restituisce 0 a meno che i corpi non siano configurati per monitorare i contatti (vedi contact_monitor).
Nota: Per recuperare i corpi in collisione, usa get_colliding_bodies().
Basis get_inverse_inertia_tensor() const 🔗
Restituisce la base del tensore di inerzia inversa. È utilizzata per calcolare l'accelerazione angolare risultante da una coppia applicata al RigidBody3D.
void set_axis_velocity(axis_velocity: Vector3) 🔗
Imposta una velocità dell'asse. La velocità nell'asse del vettore specificato verrà impostata come la lunghezza del vettore specificato. Ciò è utile per il comportamento di salto.