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...

VehicleWheel3D

Eredita: Node3D < Node < Object

Un corpo fisico 3D per un VehicleBody3D che simula il comportamento di una ruota.

Descrizione

Un nodo utilizzato come figlio di un VehicleBody3D genitore per simulare il comportamento di una delle sue ruote. Questo nodo funge anche da collisore per rilevare se la ruota sta toccando una superficie.

Nota: Questa classe presenta problemi noti e non è progettata per fornire una fisica realistica dei veicoli 3D. Se desideri una fisica avanzata dei veicoli, potresti dover scrivere la tua integrazione fisica tramite un'altra classe PhysicsBody3D.

Tutorial

Proprietà

float

brake

0.0

float

damping_compression

0.83

float

damping_relaxation

0.88

float

engine_force

0.0

PhysicsInterpolationMode

physics_interpolation_mode

2 (overrides Node)

float

steering

0.0

float

suspension_max_force

6000.0

float

suspension_stiffness

5.88

float

suspension_travel

0.2

bool

use_as_steering

false

bool

use_as_traction

false

float

wheel_friction_slip

10.5

float

wheel_radius

0.5

float

wheel_rest_length

0.15

float

wheel_roll_influence

0.1

Metodi

Node3D

get_contact_body() const

Vector3

get_contact_normal() const

Vector3

get_contact_point() const

float

get_rpm() const

float

get_skidinfo() const

bool

is_in_contact() const

Descrizioni delle proprietà

float brake = 0.0 🔗

Rallenta la ruota applicando una forza frenante. La ruota rallenta solo se è a contatto con una superficie. La forza che devi applicare per rallentare adeguatamente il tuo veicolo dipende dal RigidBody3D.mass del veicolo. Per un veicolo con una massa impostata su 1000, prova un valore nell'intervallo 25 - 30 per una frenata brusca.

float damping_compression = 0.83 🔗

  • void set_damping_compression(value: float)

  • float get_damping_compression()

Lo smorzamento applicato alla molla quando la molla viene compressa, ovvero quando la ruota si muove verso l'alto rispetto al veicolo. Si misura in Newton-secondi per millimetro (N⋅s/mm), o megagrammi al secondo (Mg/s). Questo valore dovrebbe essere compreso tra 0,0 (nessuno smorzamento) e 1,0, ma può essere più grande. Un valore di 0,0 significa che l'automobile continuerà a rimbalzare poiché la molla conserva la sua energia. Un buon valore per questo è intorno a 0,3 per un'automobile normale, 0,5 per un'automobile da corsa.

float damping_relaxation = 0.88 🔗

  • void set_damping_relaxation(value: float)

  • float get_damping_relaxation()

Lo smorzamento applicato alla molla durante il rilassamento, ovvero quando la ruota si muove verso il basso rispetto al veicolo. Si misura in Newton-secondi per millimetro (N⋅s/mm), o megagrammi al secondo (Mg/s). Questo valore dovrebbe essere compreso tra 0,0 (nessuno smorzamento) e 1,0, ma può essere più grande. Questo valore dovrebbe sempre essere leggermente superiore alla proprietà damping_compression. Per un valore di damping_compression di 0,3, prova un valore di rilassamento di 0,5.

float engine_force = 0.0 🔗

  • void set_engine_force(value: float)

  • float get_engine_force()

Accelera la ruota applicando una forza del motore. La ruota accelera solo se è a contatto con una superficie. La RigidBody3D.mass del veicolo ha un effetto sull'accelerazione del veicolo. Per un veicolo con una massa impostata su 1000, prova un valore nell'intervallo 25 - 50 per l'accelerazione.

Nota: La simulazione non tiene conto dell'effetto degli ingranaggi, dovrai aggiungere una logica per questo se desideri simulare gli ingranaggi.

Un valore negativo provocherà l'inversione della ruota.

float steering = 0.0 🔗

  • void set_steering(value: float)

  • float get_steering()

Angolo di sterzata per la ruota, in radianti. Impostando questo su un valore diverso da zero, il veicolo sterzerà quando è in movimento.

float suspension_max_force = 6000.0 🔗

  • void set_suspension_max_force(value: float)

  • float get_suspension_max_force()

La forza massima che la molla può resistere. Questo valore dovrebbe essere superiore a un quarto della RigidBody3D.mass del VehicleBody3D o la molla non sopporterà il peso del veicolo. Spesso si ottengono buoni risultati con un valore che è circa 3 o 4 volte questo numero.

float suspension_stiffness = 5.88 🔗

  • void set_suspension_stiffness(value: float)

  • float get_suspension_stiffness()

La rigidità della sospensione, misurata in Newton per millimetro (N/mm) o megagrammi al secondo quadrato (Mg/s²). Usa un valore inferiore a 50 per un'auto fuoristrada, un valore tra 50 e 100 per un'auto da corsa e prova qualcosa intorno a 200 per qualcosa come un'auto di Formula 1.

float suspension_travel = 0.2 🔗

  • void set_suspension_travel(value: float)

  • float get_suspension_travel()

Questa è la distanza che la sospensione può percorrere. Poiché le unità di Godot equivalgono a metri, mantieni questa impostazione relativamente bassa. Prova un valore tra 0,1 e 0,3 a seconda del tipo di auto.

bool use_as_steering = false 🔗

  • void set_use_as_steering(value: bool)

  • bool is_used_as_steering()

Se true, questa ruota verrà girata quando l'auto sterza. Questo valore viene usato insieme a VehicleBody3D.steering e ignorato se si usa invece il valore steering per ogni ruota.

bool use_as_traction = false 🔗

  • void set_use_as_traction(value: bool)

  • bool is_used_as_traction()

Se true, questa ruota trasferisce la forza del motore al terreno per spingere il veicolo in avanti. Questo valore viene usato insieme a VehicleBody3D.engine_force e ignorato se si usa invece il valore engine_force per ogni ruota.

float wheel_friction_slip = 10.5 🔗

  • void set_friction_slip(value: float)

  • float get_friction_slip()

Questo determina quanta aderenza ha questa ruota. È combinato con l'impostazione dell'attrito della superficie con cui la ruota è a contatto. 0,0 significa nessuna aderenza, 1,0 è aderenza normale. Per un'impostazione di auto da drift, prova a impostare l'aderenza delle ruote posteriori leggermente più in basso rispetto alle ruote anteriori, oppure usa un valore inferiore per simulare l'usura degli pneumatici.

È meglio impostarlo su 1,0 per cominciare.

float wheel_radius = 0.5 🔗

  • void set_radius(value: float)

  • float get_radius()

Il raggio della ruota in metri.

float wheel_rest_length = 0.15 🔗

  • void set_suspension_rest_length(value: float)

  • float get_suspension_rest_length()

Questa è la distanza in metri a cui la ruota si abbassa dal suo punto di origine. Non impostarla su 0,0 e spostare la ruota in posizione. Sposta invece il punto di origine della tua ruota (il gizmo in Godot) nella posizione che la ruota assumerà quando toccherà il fondo, quindi usa la lunghezza di riposo per spostare la ruota verso il basso nella posizione in cui dovrebbe trovarsi quando l'auto è ferma.

float wheel_roll_influence = 0.1 🔗

  • void set_roll_influence(value: float)

  • float get_roll_influence()

Questo valore influenza il rollio del tuo veicolo. Se impostato su 1.0 per tutte le ruote, il tuo veicolo resisterà al rollio della carrozzeria, mentre un valore di 0.0 sarà incline al ribaltamento.

Descrizioni dei metodi

Node3D get_contact_body() const 🔗

Restituisce il nodo del corpo di contatto se valido nell'albero, come Node3D. Al momento, GridMap non è supportato, quindi il nodo sarà sempre di tipo PhysicsBody3D.

Restituisce null se la ruota non è in contatto con una superficie o il corpo di contatto non è un PhysicsBody3D.

Vector3 get_contact_normal() const 🔗

Restituisce la normale della collisione della sospensione nello spazio mondiale se la ruota è in contatto. Se la ruota non è in contatto con nulla, restituisce un vettore che punta direttamente lungo l'asse della sospensione verso il veicolo nello spazio mondiale.

Vector3 get_contact_point() const 🔗

Restituisce il punto di collisione della sospensione nello spazio mondiale se la ruota è in contatto. Se la ruota non è in contatto con nulla, restituisce il punto massimo del raggio di proiezione della ruota nello spazio mondiale, che è definito da wheel_rest_length + wheel_radius.

float get_rpm() const 🔗

Restituisce la velocità di rotazione della ruota in giri al minuto.

float get_skidinfo() const 🔗

Restituisce un valore compreso tra 0,0 e 1,0 che indica se questa ruota sta slittando. 0,0 significa slittamento (la ruota ha perso aderenza, ad esempio su terreno ghiacciato), 1,0 significa nessun slittamento (la ruota ha piena aderenza, ad esempio su strada asfaltata asciutta).

bool is_in_contact() const 🔗

Restituisce true se questa ruota è a contatto con una superficie.