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
Hérite de : PhysicsBody3D < CollisionObject3D < Node3D < Node < Object
Hérité par : VehicleBody3D
Un corps physique 3D qui est déplacé par une simulation physique.
Description
RigidBody2D implémente la physique 3D complète. Il ne peut pas être contrôlé directement, au lieu de cela, vous devez appliquer des forces à celui-ci (gravité, impulsions, etc.), et la simulation physique calculera le mouvement résultant, la rotation, la réaction aux collisions et effets sur d'autres corps de physique dans son chemin.
Le comportement du corps peut être ajusté par lock_rotation, freeze, et freeze_mode. En changeant diverses propriétés de l'objet, comme mass, vous pouvez contrôler comment la simulation physique agit sur lui.
Un corps rigide maintiendra toujours sa forme et sa taille, même lorsque des forces lui sont appliquées. Il est utile pour les objets qui peuvent être interagis avec dans un environnement, comme un arbre qui peut être renversé ou une pile de caisses qui peut être bousculée.
Si vous devez directement affecter le corps, préférez _integrate_forces() car il vous permet d'accéder directement à l'état physique.
Si vous devez redéfinir le comportement physique par défaut, vous pouvez écrire une fonction d'intégration des forces personnalisée. Voir custom_integrator.
Note : Changer la transformation 3D ou linear_velocity d'un RigidBody3D peut très souvent conduire à des comportements imprévisibles. Cela se produit aussi lorsqu'un RigidBody3D est le descendant d'un nœud bougeant constamment, comme un autre RigidBody3D, car cela fera que sa transformation globale sera définie chaque fois que son ancêtre se déplace.
Tutoriels
Propriétés
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
Méthodes
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) |
Signaux
Émis lorsqu'une collision avec un autre PhysicsBody3D or GridMap arrive. Nécessite que contact_monitor soit défini à true et que max_contacts_reported soit défini assez haut pour détecter toutes les collisions. Les GridMap sont détectées si la MeshLibrary a des Collision Shape3Ds.
body le Node, s'il existe dans l'arbre, de l'autre PhysicsBody3D ou GridMap.
Émis lorsque la collision avec un autre PhysicsBody3D or GridMap se finit. Nécessite que contact_monitor soit défini à true et que max_contacts_reported soit défini assez haut pour détecter toutes les collisions. Les GridMap sont détectées si la MeshLibrary a des Collision Shape3Ds.
body le Node, s'il existe dans l'arbre, de l'autre PhysicsBody3D ou GridMap.
body_shape_entered(body_rid: RID, body: Node, body_shape_index: int, local_shape_index: int) 🔗
Émis quand une des Shape3D de ce RigidBody3D entre en collision avec un autre PhysicsBody3D ou d'une Shape3D d'une GridMap. Nécessite que contact_monitor soit défini à true et que max_contacts_reported soit défini assez haut pour détecter toutes les collisions. Les GridMap sont détectées si la MeshLibrary a des Collision Shape3Ds.
body_rid le RID de l'autre PhysicsBody3D ou CollisionObject3D de la MeshLibrary utilisé par le PhysicsServer3D.
body le Node, s'il existe dans l'arbre, du PhysicsBody3D ou du GridMap.
body_shape_index l'index de la Shape3D du PhysicsBody3D ou du GridMap utilisé par le PhysicsServer3D. Obtenez le nœud CollisionShape3D avec corps.shape_owner_get_owner(body.shape_find_owner(body_shape_index)).
local_shape_index l'index de la Shape3D de ce RigidBody3D utilisée par le PhysicsServer3D. Obtenez le nœud CollisionShape3D avec 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) 🔗
Émis lorsque la collision entre l'une des Shape3D de ce RigidBody3D et un autre PhysicsBody3D ou Shape3D de GridMap se termine. Nécessite que contact_monitor soit défini à true et que max_contacts_reported soit défini assez haut pour détecter toutes les collisions. Les GridMaps sont détectées si la MeshLibrary a des Collision Shape3Ds.
body_rid le RID de l'autre PhysicsBody3D or CollisionObject3D d'une TileSet utilisé par le PhysicsServer3D.
body le Node, s'il existe dans l'arbre, de l'autre PhysicsBody3D ou GridMap.
body_shape_index l'index de la Shape3D de l'autre PhysicsBody3D ou GridMap utilisé par le PhysicsServer2D. Obtenez le nœud CollisionShape3D avec body.shape_owner_get_owner(body.shape_find_owner(body_shape_index).
local_shape_index l'index de la Shape3D de ce RigidBody3D utilisé par le PhysicsServer3D. Obtenez le nœud CollisionShape3D avec self.shape_owner_get_owner(self.shape_find_owner(local_shape_index).
sleeping_state_changed() 🔗
Émis lorsque le moteur de physique change l'état de sommeil du corps.
Note : Changer la valeur de sleeping ne déclenchera pas ce signal. Il est seulement émis si l'état de sommeil est changé par le moteur de physique ou si emit_signal("sleeping_state_changed") est utilisé.
Énumérations
enum FreezeMode: 🔗
FreezeMode FREEZE_MODE_STATIC = 0
Mode de gel du corps statique (par défaut). Le corps n'est pas affecté par la gravité et les forces. Il ne peut être déplacé que par le code de l'utilisateur et n'entre pas en collision avec d'autres corps le long de son chemin.
FreezeMode FREEZE_MODE_KINEMATIC = 1
Mode de gel du corps cinématique. Semblable à FREEZE_MODE_STATIC, mais collisionne avec d'autres corps le long de son chemin lorsqu'il est déplacé. Utile pour un corps gelé qui doit être animé.
enum CenterOfMassMode: 🔗
CenterOfMassMode CENTER_OF_MASS_MODE_AUTO = 0
Dans ce mode, le centre de masse du corps est calculé automatiquement en fonction de ses formes. Cela suppose que les origines des formes sont aussi leur centre de masse.
CenterOfMassMode CENTER_OF_MASS_MODE_CUSTOM = 1
Dans ce mode, le centre de masse du corps est défini par center_of_mass. La valeur par défaut est à l'origine du corps.
enum DampMode: 🔗
DampMode DAMP_MODE_COMBINE = 0
Dans ce mode, la valeur d'amortissement du corps est ajoutée à toute valeur définie dans les zones ou la valeur par défaut.
DampMode DAMP_MODE_REPLACE = 1
Dans ce mode, la valeur d'amortissement du corps remplace toute valeur définie dans les zones ou la valeur par défaut.
Descriptions des propriétés
Amortit la rotation du corps. Par défaut, le corps utilisera le paramètre de projet ProjectSettings.physics/3d/default_angular_damp ou toute redéfinition de valeur définie par une Area3D où se trouve le corps. Selon angular_damp_mode, vous pouvez définir que angular_damp soit ajouté à ou va remplacer la valeur d'amortissement du corps.
Voir ProjectSettings.physics/3d/default_angular_damp pour plus de détails sur l'amortissement.
DampMode angular_damp_mode = 0 🔗
Définit comment angular_damp est appliqué.
Vector3 angular_velocity = Vector3(0, 0, 0) 🔗
La vitesse de rotation du RigidBody3D en radians par seconde.
Si true, le corps peut entrer en mode sommeil lorsqu'il n'y a pas de mouvement. Voir sleeping.
Vector3 center_of_mass = Vector3(0, 0, 0) 🔗
Le centre de masse personnalisé du corps, relatif à la position d'origine du corps, quand center_of_mass_mode est défini à CENTER_OF_MASS_MODE_CUSTOM. C'est le point d'équilibre du corps, où les forces appliquées ne provoquent qu'une accélération linéaire. Appliquer des forces en dehors du centre de masse provoque une accélération angulaire.
Lorsque center_of_mass_mode est défini à CENTER_OF_MASS_MODE_AUTO (valeur par défaut), le centre de masse est automatiquement calculé, mais cela ne met pas à jour la valeur de center_of_mass.
CenterOfMassMode center_of_mass_mode = 0 🔗
void set_center_of_mass_mode(value: CenterOfMassMode)
CenterOfMassMode get_center_of_mass_mode()
Définit la manière dont le centre de masse du corps est défini.
Vector3 constant_force = Vector3(0, 0, 0) 🔗
Les forces positionnelles constantes totales du corps appliquées lors de chaque mise à jour de physique.
Voir add_constant_force() et add_constant_central_force().
Vector3 constant_torque = Vector3(0, 0, 0) 🔗
Les forces de rotation constantes totales du corps appliquées lors de chaque mise à jour de physique.
Voir add_constant_torque().
bool contact_monitor = false 🔗
Si true, le RigidBody3D émettra des signaux lorsqu'il se heurte à un autre corps.
Note : Par défaut, les contacts maximaux indiqués sont définis à 0, ce qui signifie que rien ne sera enregistré, voir max_contacts_reported.
void set_use_continuous_collision_detection(value: bool)
bool is_using_continuous_collision_detection()
Si true, la détection des collisions continue est utilisée.
La détection des collisions continue tente de prédire où un corps mobile va entrer en collision, au lieu de le déplacer et de corriger son mouvement s'il entre en collision. La détection des collisions continue est plus précise et manque moins d'impacts par les petits objets avec un mouvement rapide. Ne pas utiliser la détection des collisions continue est plus rapide pour calculer, mais peut manquer les petits objets avec un mouvement rapide.
bool custom_integrator = false 🔗
Si true, l'intégration des forces standardes (comme la gravité ou l'amortissement) sera désactivée pour ce corps. En dehors de la réponse à la collision, le corps ne se déplacera que selon la méthode _integrate_forces(), si cette méthode virtuelle est surchargée.
Définir cette propriété appellera la méthode PhysicsServer3D.body_set_omit_force_integration() en interne.
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.
Ceci est multiplié par ProjectSettings.physics/3d/default_gravity pour produire la gravité de ce corps. Par exemple, une valeur de 1.0 appliquera la gravité normale, 2.0 appliquera le double de la gravité, et 0.5 appliquera la moitié de la gravité à ce corps.
Vector3 inertia = Vector3(0, 0, 0) 🔗
Le moment d'inertie du corps. C'est comme la masse, mais pour la rotation : il détermine combien de couple il faut pour tourner le corps sur chaque axe. Le moment d'inertie est généralement calculé automatiquement à partir de la masse et des formes, mais cette propriété vous permet de définir une valeur personnalisée.
Si elle est définie à Vector3.ZERO, l'inertie est automatiquement calculée (valeur par défaut).
Note : Cette valeur ne change pas lorsque l'inertie est automatiquement calculée. Utilisez PhysicsServer3D pour obtenir l'inertie calculée.
@onready var balle = $Balle
func obtenir_inertie_balle():
return 1.0 / PhysicsServer.D.body_get_direct_state(ball.get_rid()).inverse_inertia
private RigidBody.D _balle;
public override void _Ready()
{
_balle = GetNode<RigidBody3D>("Balle");
}
private float ObtenirInertieBalle()
{
return 1.0f / PhysicsServer3D.BodyGetDirectState(_ball.GetRid()).InverseInertia;
}
Amortit le mouvement du corps. Par défaut, le corps utilisera le paramètre de projet ProjectSettings.physics/3d/default_linear_damp ou toute redéfinition de valeur définie par une Area3D où se trouve le corps. Selon linear_damp_mode, vous pouvez définir que linear_damp soit ajouté à ou va remplacer la valeur d'amortissement du corps.
Voir ProjectSettings.physics/3d/default_linear_damp pour plus de détails sur l'amortissement.
DampMode linear_damp_mode = 0 🔗
Définit comment linear_damp est appliqué.
Vector3 linear_velocity = Vector3(0, 0, 0) 🔗
La vitesse linéaire du corps en unités par seconde. Peut être utilisé sporadiquement, mais ne pas définir à chaque trame, car la physique peut s'exécuter dans un autre fil d'exécution et s'exécute à une granularité différente. Utilisez _integrate_forces() comme boucle de traitement pour un contrôle précis de l'état du corps.
Si true, le corps ne peut pas pivoter. La gravité et les forces n'appliquent qu'un mouvement linéaire.
La masse du corps.
int max_contacts_reported = 0 🔗
Le nombre maximal de contacts qui seront enregistrés. Nécessite une valeur supérieure à 0 et contact_monitor défini à true pour commencer à enregistrer les contacts. Utilisez get_contact_count() pour récupérer le compte ou get_colliding_bodies() pour récupérer les corps qui sont entrés en collision avec.
Note : Le nombre de contacts est différent du nombre de collisions. Les collisions entre des bords parallèles se traduiront par deux contacts (un à chaque extrémité), et les collisions entre les faces parallèles se traduiront par quatre contacts (un à chaque coin).
PhysicsMaterial physics_material_override 🔗
void set_physics_material_override(value: PhysicsMaterial)
PhysicsMaterial get_physics_material_override()
Le matériau physique de remplacement pour le corps.
Si un matériau est affecté à cette propriété, il sera utilisé au lieu de tout autre matériau physique, tel qu'un matériau hérité.
Si true, le corps ne bougera pas et ne calculera pas les forces jusqu'à ce qu'un autre corps le réveille à cause, par exemple, d'une collision, ou en utilisant les méthodes apply_impulse() ou apply_force().
Descriptions des méthodes
void _integrate_forces(state: PhysicsDirectBodyState3D) virtual 🔗
Appelé pendant le traitement physique, vous permettant de lire et de modifier en toute sécurité l'état de simulation de l'objet. Par défaut, elle est appelée avant l'intégration des forces standardes, mais la propriété custom_integrator vous permet de désactiver l'intégration des forces standardes et de faire une intégration des forces entièrement personnalisée pour un corps.
void add_constant_central_force(force: Vector3) 🔗
Ajoute une force directionnelle constante n'affectant pas la rotation, qui continue d'être appliquée au cours du temps jusqu'à ce qu'elle soit enlevée avec constant_force = Vector3(0, 0, 0).
Ceci est équivalent à utiliser add_constant_force() au centre de masse du corps.
void add_constant_force(force: Vector3, position: Vector3 = Vector3(0, 0, 0)) 🔗
Ajoute une force positionnée constante au corps qui continue d'être appliquée au cours du temps jusqu'à ce qu'elle soit nettoyée avec constant_force = Vector3(0, 0, 0).
position est le décalage depuis l'origine du corps dans les coordonnées globales.
void add_constant_torque(torque: Vector3) 🔗
Ajoute une force de rotation constante n'affectant pas la position, qui continue d'être appliquée au cours du temps jusqu'à ce qu'elle soit enlevée avec constant_torque = Vector3(0, 0, 0).
void apply_central_force(force: Vector3) 🔗
Applique une force directionnelle n'affectant pas la rotation. Une force est dépendante du temps et destinée à être appliquée chaque mise à jour physique.
Ceci est équivalent à utiliser apply_force() au centre de masse du corps.
void apply_central_impulse(impulse: Vector3) 🔗
Applique une impulsion directionnelle n'affectant pas la rotation.
Une impulsion est indépendante du temps ! Appliquer une impulsion à chaque trame entraînerait une force dépendante du taux de rafraîchissement. Pour cette raison, elle ne devrait être utilisée que pour simuler des impacts ponctuels (utilisez les fonctions "_force" sinon).
Ceci est équivalent à utiliser apply_impulse() au centre de masse du corps.
void apply_force(force: Vector3, position: Vector3 = Vector3(0, 0, 0)) 🔗
Applique une force positionnée au corps. Une force est dépendante du temps et destinée à être appliquée à chaque mise à jour physique.
position est le décalage depuis l'origine du corps dans les coordonnées globales.
void apply_impulse(impulse: Vector3, position: Vector3 = Vector3(0, 0, 0)) 🔗
Applique une impulsion positionnée au corps.
Une impulsion est indépendante du temps ! Appliquer une impulsion à chaque trame entraînerait une force dépendante du taux de rafraîchissement. Pour cette raison, elle ne devrait être utilisée que pour simuler des impacts ponctuels (utilisez les fonctions "_force" sinon).
position est le décalage depuis l'origine du corps dans les coordonnées globales.
void apply_torque(torque: Vector3) 🔗
Applique une force de rotation sans affecter la position. Une force est dépendante du temps et destinée à être appliquée à chaque mise à jour physique.
Note : L'inertie (inertia) est nécessaire pour que cela fonctionne. Pour avoir de l’inertie (inertia), un CollisionShape3D actif doit être un enfant du nœud, ou vous pouvez définir manuellement inertia.
void apply_torque_impulse(impulse: Vector3) 🔗
Applique une impulsion de rotation au corps sans affecter la position.
Une impulsion est indépendante du temps ! Appliquer une impulsion à chaque trame entraînerait une force dépendante du taux de rafraîchissement. Pour cette raison, elle ne devrait être utilisée que pour simuler des impacts ponctuels (utilisez les fonctions "_force" sinon).
Note : L'inertie (inertia) est nécessaire pour que cela fonctionne. Pour avoir de l’inertie (inertia), un CollisionShape3D actif doit être un enfant du nœud, ou vous pouvez définir manuellement inertia.
Array[Node3D] get_colliding_bodies() const 🔗
Renvoie une liste des corps en collision avec celui-ci. Nécessite contact_monitor d'être défini à true et max_contacts_reported d'être défini assez haut pour détecter toutes les collisions.
Note : Le résultat de ce test n'est pas immédiat après le déplacement des objets. Pour la performance, la liste des collisions est mise à jour une fois par trame et avant l'étape de physique. Envisagez d'utiliser des signaux à la place.
int get_contact_count() const 🔗
Renvoie le nombre de contacts que ce corps a avec d'autres corps. Par défaut, cela renvoie 0 sauf si les corps sont configurés pour surveiller les contacts (voir contact_monitor).
Note : Pour récupérer les corps en collision, utilisez get_colliding_bodies().
Basis get_inverse_inertia_tensor() const 🔗
Renvoie la base du tenseur d’inertie inverse. Ceci est utilisé pour calculer l'accélération angulaire résultant d'un couple appliqué au RigidBody3D.
void set_axis_velocity(axis_velocity: Vector3) 🔗
Définit la vélocité d'un axe. La vélocité dans l'axe du vecteur donné sera définie comme la longueur du vecteur donné. Utile pour le comportement lors d'un saut.