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

PhysicalBone3D

Eredita: PhysicsBody3D < CollisionObject3D < Node3D < Node < Object

Un corpo fisico utilizzato per far reagire le ossa in uno Skeleton3D alla fisica.

Descrizione

Il nodo PhysicalBone3D è un corpo fisico che può essere utilizzato per far reagire le ossa in uno Skeleton3D alla fisica.

Nota: Per rilevare le ossa fisiche con i raycast, la proprietà SkeletonModifier3D.active del PhysicalBoneSimulator3D genitore deve essere true e l'osso dello Skeleton3D deve essere assegnato correttamente a PhysicalBone3D; ciò significa che get_bone_id() dovrebbe restituire un ID valido (>= 0).

Tutorial

Ragdoll System

Proprietà

float	angular_damp	`0.0`
DampMode	angular_damp_mode	`0`
Vector3	angular_velocity	`Vector3(0, 0, 0)`
Transform3D	body_offset	`Transform3D(1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0)`
float	bounce	`0.0`
bool	can_sleep	`true`
bool	custom_integrator	`false`
float	friction	`1.0`
float	gravity_scale	`1.0`
Transform3D	joint_offset	`Transform3D(1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0)`
Vector3	joint_rotation	`Vector3(0, 0, 0)`
JointType	joint_type	`0`
float	linear_damp	`0.0`
DampMode	linear_damp_mode	`0`
Vector3	linear_velocity	`Vector3(0, 0, 0)`
float	mass	`1.0`

Metodi

void	_integrate_forces(state: PhysicsDirectBodyState3D) virtual
void	apply_central_impulse(impulse: Vector3)
void	apply_impulse(impulse: Vector3, position: Vector3 = Vector3(0, 0, 0))
int	get_bone_id() const
bool	get_simulate_physics()
bool	is_simulating_physics()

Enumerazioni

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.

enum JointType: 🔗

JointType JOINT_TYPE_NONE = 0

Nessuna articolazione è applicata al PhysicsBone3D.

JointType JOINT_TYPE_PIN = 1

Un giunto a perno viene applicato al PhysicsBone3D.

JointType JOINT_TYPE_CONE = 2

Un'articolazione conica è applicata al PhysicsBone3D.

JointType JOINT_TYPE_HINGE = 3

Un giunto a cerniera viene applicato al PhysicsBone3D.

JointType JOINT_TYPE_SLIDER = 4

Un'articolazione scorrevole è applicata al PhysicsBone3D.

JointType JOINT_TYPE_6DOF = 5

Un giunto a 6 gradi di libertà viene applicato al PhysicsBone3D.

Descrizioni delle proprietà

float angular_damp = 0.0 🔗

void set_angular_damp(value: float)
float get_angular_damp()

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 🔗

void set_angular_damp_mode(value: DampMode)
DampMode get_angular_damp_mode()

Definisce come angular_damp è applicato.

Vector3 angular_velocity = Vector3(0, 0, 0) 🔗

void set_angular_velocity(value: Vector3)
Vector3 get_angular_velocity()

Velocità di rotazione del PhysicalBone3D in radianti al secondo.

Transform3D body_offset = Transform3D(1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0) 🔗

void set_body_offset(value: Transform3D)
Transform3D get_body_offset()

Imposta la trasformazione del corpo.

float bounce = 0.0 🔗

void set_bounce(value: float)
float get_bounce()

Il rimbalzo del corpo. I valori variano da 0 (nessun rimbalzo) a 1 (rimbalzo totale).

Nota: Anche con bounce impostato su 1.0, parte dell'energia sarà persa nel tempo a causa dello smorzamento lineare e angolare. Per avere un PhysicalBone3D che conservi tutta la sua energia nel tempo, imposta bounce su 1.0, linear_damp_mode su DAMP_MODE_REPLACE, linear_damp su 0.0, angular_damp_mode su DAMP_MODE_REPLACE e angular_damp su 0.0.

bool can_sleep = true 🔗

void set_can_sleep(value: bool)
bool is_able_to_sleep()

Se true, il corpo viene disattivato quando non c'è movimento, quindi non parteciperà alla simulazione finché non sarà risvegliato da una forza esterna.

bool custom_integrator = false 🔗

void set_use_custom_integrator(value: bool)
bool is_using_custom_integrator()

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

float friction = 1.0 🔗

void set_friction(value: float)
float get_friction()

L'attrito del corpo, da 0 (senza attrito) a 1 (massimo attrito).

float gravity_scale = 1.0 🔗

void set_gravity_scale(value: float)
float get_gravity_scale()

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.

Transform3D joint_offset = Transform3D(1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0) 🔗

void set_joint_offset(value: Transform3D)
Transform3D get_joint_offset()

Imposta la trasformazione dell'articolazione.

Vector3 joint_rotation = Vector3(0, 0, 0) 🔗

void set_joint_rotation(value: Vector3)
Vector3 get_joint_rotation()

Imposta la rotazione dell'articolazione in radianti.

JointType joint_type = 0 🔗

void set_joint_type(value: JointType)
JointType get_joint_type()

Imposta il tipo di giunto.

float linear_damp = 0.0 🔗

void set_linear_damp(value: float)
float get_linear_damp()

Smorza il movimento del corpo. Come predefinito, il corpo utilizzerà ProjectSettings.physics/3d/default_linear_damp, o un valore sostitutivo 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.

Vedi ProjectSettings.physics/3d/default_linear_damp per ulteriori dettagli sullo smorzamento.

DampMode linear_damp_mode = 0 🔗

void set_linear_damp_mode(value: DampMode)
DampMode get_linear_damp_mode()

Definisce come linear_damp è applicato.

Vector3 linear_velocity = Vector3(0, 0, 0) 🔗

void set_linear_velocity(value: Vector3)
Vector3 get_linear_velocity()

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.

float mass = 1.0 🔗

void set_mass(value: float)
float get_mass()

La massa del corpo.

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 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 "_integrate_forces").

Ciò equivale a usare apply_impulse() al centro di massa del corpo.

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 "_integrate_forces").

position è lo scostamento dall'origine del PhysicsBone3D in coordinate globali.

int get_bone_id() const 🔗

Restituisce l'identificatore unico del PhysicsBone3D.

bool get_simulate_physics() 🔗

Restituisce true se al PhysicsBone3D è consentito simulare la fisica.

bool is_simulating_physics() 🔗

Restituisce true se il PhysicsBone3D sta attualmente simulando la fisica.