Struct gdnative::api::VehicleBody

pub struct VehicleBody { /* fields omitted */ }

core class VehicleBody inherits RigidBody (unsafe).

Official documentation

See the documentation of this class in the Godot engine's official documentation.

Memory management

Non reference counted objects such as the ones of this type are usually owned by the engine.

VehicleBody is a reference-only type. Persistent references can only exist in the unsafe Ref<VehicleBody> form.

In the cases where Rust code owns an object of this type, for example if the object was just created on the Rust side and not passed to the engine yet, ownership should be either given to the engine or the object must be manually destroyed using Ref::free, or Ref::queue_free if it is a Node.

Class hierarchy

VehicleBody inherits methods from:

• RigidBody
• PhysicsBody
• CollisionObject
• Spatial
• Node
• Object

Safety

All types in the Godot API have "interior mutability" in Rust parlance. To enforce that the official thread-safety guidelines are followed, the typestate pattern is used in the Ref and TRef smart pointers, and the Instance API. The typestate Access in these types tracks whether the access is unique, shared, or exclusive to the current thread. For more information, see the type-level documentation on Ref.

Implementations

impl VehicleBody

pub fn new() -> Ref<VehicleBody, Unique>

Creates a new instance of this object.

Because this type is not reference counted, the lifetime of the returned object is not automatically managed.

Immediately after creation, the object is owned by the caller, and can be passed to the engine (in which case the engine will be responsible for destroying the object) or destroyed manually using Ref::free, or preferably Ref::queue_free if it is a Node.

pub fn brake(&self) -> f64

Slows down the vehicle by applying a braking force. The vehicle is only slowed down if the wheels are in contact with a surface. The force you need to apply to adequately slow down your vehicle depends on the [member RigidBody.mass] of the vehicle. For a vehicle with a mass set to 1000, try a value in the 25 - 30 range for hard braking.

pub fn engine_force(&self) -> f64

Accelerates the vehicle by applying an engine force. The vehicle is only speed up if the wheels that have [member VehicleWheel.use_as_traction] set to [code]true[/code] and are in contact with a surface. The [member RigidBody.mass] of the vehicle has an effect on the acceleration of the vehicle. For a vehicle with a mass set to 1000, try a value in the 25 - 50 range for acceleration.
			[b]Note:[/b] The simulation does not take the effect of gears into account, you will need to add logic for this if you wish to simulate gears.
			A negative value will result in the vehicle reversing.

pub fn steering(&self) -> f64

The steering angle for the vehicle. Setting this to a non-zero value will result in the vehicle turning when it's moving. Wheels that have [member VehicleWheel.use_as_steering] set to [code]true[/code] will automatically be rotated.

pub fn set_brake(&self, brake: f64)

Slows down the vehicle by applying a braking force. The vehicle is only slowed down if the wheels are in contact with a surface. The force you need to apply to adequately slow down your vehicle depends on the [member RigidBody.mass] of the vehicle. For a vehicle with a mass set to 1000, try a value in the 25 - 30 range for hard braking.

pub fn set_engine_force(&self, engine_force: f64)

Accelerates the vehicle by applying an engine force. The vehicle is only speed up if the wheels that have [member VehicleWheel.use_as_traction] set to [code]true[/code] and are in contact with a surface. The [member RigidBody.mass] of the vehicle has an effect on the acceleration of the vehicle. For a vehicle with a mass set to 1000, try a value in the 25 - 50 range for acceleration.
			[b]Note:[/b] The simulation does not take the effect of gears into account, you will need to add logic for this if you wish to simulate gears.
			A negative value will result in the vehicle reversing.

pub fn set_steering(&self, steering: f64)

The steering angle for the vehicle. Setting this to a non-zero value will result in the vehicle turning when it's moving. Wheels that have [member VehicleWheel.use_as_steering] set to [code]true[/code] will automatically be rotated.

Methods from Deref<Target = RigidBody>

pub const MODE_CHARACTER: i64

pub const MODE_KINEMATIC: i64

pub const MODE_RIGID: i64

pub const MODE_STATIC: i64

pub fn add_central_force(&self, force: Vector3D<f32, UnknownUnit>)

Adds a constant directional force (i.e. acceleration) without affecting rotation.
				This is equivalent to [code]add_force(force, Vector3(0,0,0))[/code].

pub fn add_force(
    &self,
    force: Vector3D<f32, UnknownUnit>,
    position: Vector3D<f32, UnknownUnit>
)

Adds a constant directional force (i.e. acceleration).
				The position uses the rotation of the global coordinate system, but is centered at the object's origin.

pub fn add_torque(&self, torque: Vector3D<f32, UnknownUnit>)

Adds a constant rotational force (i.e. a motor) without affecting position.

pub fn apply_central_impulse(&self, impulse: Vector3D<f32, UnknownUnit>)

Applies a directional impulse without affecting rotation.
				This is equivalent to [code]apply_impulse(Vector3(0,0,0), impulse)[/code].

pub fn apply_impulse(
    &self,
    position: Vector3D<f32, UnknownUnit>,
    impulse: Vector3D<f32, UnknownUnit>
)

Applies a positioned impulse to the body. An impulse is time independent! Applying an impulse every frame would result in a framerate-dependent force. For this reason it should only be used when simulating one-time impacts. The position uses the rotation of the global coordinate system, but is centered at the object's origin.

pub fn apply_torque_impulse(&self, impulse: Vector3D<f32, UnknownUnit>)

Applies a torque impulse which will be affected by the body mass and shape. This will rotate the body around the [code]impulse[/code] vector passed.

pub fn angular_damp(&self) -> f64

Damps RigidBody's rotational forces.

pub fn angular_velocity(&self) -> Vector3D<f32, UnknownUnit>

RigidBody's rotational velocity.

pub fn axis_lock(&self, axis: i64) -> bool

Lock the body's movement in the Z axis.

pub fn bounce(&self) -> f64

The body's bounciness. Values range from [code]0[/code] (no bounce) to [code]1[/code] (full bounciness).
			Deprecated, use [member PhysicsMaterial.bounce] instead via [member physics_material_override].

pub fn get_colliding_bodies(&self) -> VariantArray<Shared>

Returns a list of the bodies colliding with this one. Requires [member contact_monitor] to be set to [code]true[/code] and [member contacts_reported] to be set high enough to detect all the collisions.
				[b]Note:[/b] The result of this test is not immediate after moving objects. For performance, list of collisions is updated once per frame and before the physics step. Consider using signals instead.

pub fn friction(&self) -> f64

The body's friction, from 0 (frictionless) to 1 (max friction).
			Deprecated, use [member PhysicsMaterial.friction] instead via [member physics_material_override].

pub fn gravity_scale(&self) -> f64

This is multiplied by the global 3D gravity setting found in [b]Project > Project Settings > Physics > 3d[/b] to produce RigidBody's gravity. For example, a value of 1 will be normal gravity, 2 will apply double gravity, and 0.5 will apply half gravity to this object.

pub fn get_inverse_inertia_tensor(&self) -> Basis

Returns the inverse inertia tensor basis. This is used to calculate the angular acceleration resulting from a torque applied to the RigidBody.

pub fn linear_damp(&self) -> f64

The body's linear damp. Cannot be less than -1.0. If this value is different from -1.0, any linear damp derived from the world or areas will be overridden.

pub fn linear_velocity(&self) -> Vector3D<f32, UnknownUnit>

The body's linear velocity. Can be used sporadically, but [b]don't set this every frame[/b], because physics may run in another thread and runs at a different granularity. Use [method _integrate_forces] as your process loop for precise control of the body state.

pub fn mass(&self) -> f64

The body's mass.

pub fn max_contacts_reported(&self) -> i64

The maximum number of contacts that will be recorded. Requires [member contact_monitor] to be set to [code]true[/code].
			[b]Note:[/b] The number of contacts is different from the number of collisions. Collisions between parallel edges will result in two contacts (one at each end), and collisions between parallel faces will result in four contacts (one at each corner).

pub fn mode(&self) -> Mode

The body mode. See [enum Mode] for possible values.

pub fn physics_material_override(&self) -> Option<Ref<PhysicsMaterial, Shared>>

The physics material override for the body.
			If a material is assigned to this property, it will be used instead of any other physics material, such as an inherited one.

pub fn weight(&self) -> f64

The body's weight based on its mass and the global 3D gravity. Global values are set in [b]Project > Project Settings > Physics > 3d[/b].

pub fn is_able_to_sleep(&self) -> bool

If [code]true[/code], the body can enter sleep mode when there is no movement. See [member sleeping].
			[b]Note:[/b] A RigidBody3D will never enter sleep mode automatically if its [member mode] is [constant MODE_CHARACTER]. It can still be put to sleep manually by setting its [member sleeping] property to [code]true[/code].

pub fn is_contact_monitor_enabled(&self) -> bool

If [code]true[/code], the RigidBody will emit signals when it collides with another RigidBody. See also [member contacts_reported].

pub fn is_sleeping(&self) -> bool

If [code]true[/code], the body will not move and will not calculate forces until woken up by another body through, for example, a collision, or by using the [method apply_impulse] or [method add_force] methods.

pub fn is_using_continuous_collision_detection(&self) -> bool

If [code]true[/code], continuous collision detection is used.
			Continuous collision detection tries to predict where a moving body will collide, instead of moving it and correcting its movement if it collided. Continuous collision detection is more precise, and misses fewer impacts by small, fast-moving objects. Not using continuous collision detection is faster to compute, but can miss small, fast-moving objects.

pub fn is_using_custom_integrator(&self) -> bool

If [code]true[/code], internal force integration will be disabled (like gravity or air friction) for this body. Other than collision response, the body will only move as determined by the [method _integrate_forces] function, if defined.

pub fn set_angular_damp(&self, angular_damp: f64)

Damps RigidBody's rotational forces.

pub fn set_angular_velocity(&self, angular_velocity: Vector3D<f32, UnknownUnit>)

RigidBody's rotational velocity.

pub fn set_axis_lock(&self, axis: i64, lock: bool)

Lock the body's movement in the Z axis.

pub fn set_axis_velocity(&self, axis_velocity: Vector3D<f32, UnknownUnit>)

Sets an axis velocity. The velocity in the given vector axis will be set as the given vector length. This is useful for jumping behavior.

pub fn set_bounce(&self, bounce: f64)

The body's bounciness. Values range from [code]0[/code] (no bounce) to [code]1[/code] (full bounciness).
			Deprecated, use [member PhysicsMaterial.bounce] instead via [member physics_material_override].

pub fn set_can_sleep(&self, able_to_sleep: bool)

If [code]true[/code], the body can enter sleep mode when there is no movement. See [member sleeping].
			[b]Note:[/b] A RigidBody3D will never enter sleep mode automatically if its [member mode] is [constant MODE_CHARACTER]. It can still be put to sleep manually by setting its [member sleeping] property to [code]true[/code].

pub fn set_contact_monitor(&self, enabled: bool)

If [code]true[/code], the RigidBody will emit signals when it collides with another RigidBody. See also [member contacts_reported].

pub fn set_friction(&self, friction: f64)

The body's friction, from 0 (frictionless) to 1 (max friction).
			Deprecated, use [member PhysicsMaterial.friction] instead via [member physics_material_override].

pub fn set_gravity_scale(&self, gravity_scale: f64)

This is multiplied by the global 3D gravity setting found in [b]Project > Project Settings > Physics > 3d[/b] to produce RigidBody's gravity. For example, a value of 1 will be normal gravity, 2 will apply double gravity, and 0.5 will apply half gravity to this object.

pub fn set_linear_damp(&self, linear_damp: f64)

The body's linear damp. Cannot be less than -1.0. If this value is different from -1.0, any linear damp derived from the world or areas will be overridden.

pub fn set_linear_velocity(&self, linear_velocity: Vector3D<f32, UnknownUnit>)

The body's linear velocity. Can be used sporadically, but [b]don't set this every frame[/b], because physics may run in another thread and runs at a different granularity. Use [method _integrate_forces] as your process loop for precise control of the body state.

pub fn set_mass(&self, mass: f64)

The body's mass.

pub fn set_max_contacts_reported(&self, amount: i64)

The maximum number of contacts that will be recorded. Requires [member contact_monitor] to be set to [code]true[/code].
			[b]Note:[/b] The number of contacts is different from the number of collisions. Collisions between parallel edges will result in two contacts (one at each end), and collisions between parallel faces will result in four contacts (one at each corner).

pub fn set_mode(&self, mode: i64)

The body mode. See [enum Mode] for possible values.

pub fn set_physics_material_override(
    &self,
    physics_material_override: impl AsArg<PhysicsMaterial>
)

The physics material override for the body.
			If a material is assigned to this property, it will be used instead of any other physics material, such as an inherited one.

pub fn set_sleeping(&self, sleeping: bool)

If [code]true[/code], the body will not move and will not calculate forces until woken up by another body through, for example, a collision, or by using the [method apply_impulse] or [method add_force] methods.

pub fn set_use_continuous_collision_detection(&self, enable: bool)

If [code]true[/code], continuous collision detection is used.
			Continuous collision detection tries to predict where a moving body will collide, instead of moving it and correcting its movement if it collided. Continuous collision detection is more precise, and misses fewer impacts by small, fast-moving objects. Not using continuous collision detection is faster to compute, but can miss small, fast-moving objects.

pub fn set_use_custom_integrator(&self, enable: bool)

If [code]true[/code], internal force integration will be disabled (like gravity or air friction) for this body. Other than collision response, the body will only move as determined by the [method _integrate_forces] function, if defined.

pub fn set_weight(&self, weight: f64)

The body's weight based on its mass and the global 3D gravity. Global values are set in [b]Project > Project Settings > Physics > 3d[/b].

Trait Implementations

impl Debug for VehicleBody

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.

impl Deref for VehicleBody

type Target = RigidBody

The resulting type after dereferencing.

fn deref(&self) -> &RigidBody

Dereferences the value.

impl DerefMut for VehicleBody

fn deref_mut(&mut self) -> &mut RigidBody

Mutably dereferences the value.

impl GodotObject for VehicleBody

type RefKind = ManuallyManaged

The memory management kind of this type. This modifies the behavior of the Ref smart pointer. See its type-level documentation for more information.

fn class_name() -> &'static str

fn null() -> Null<Self>

Creates an explicitly null reference of Self as a method argument. This makes type inference easier for the compiler compared to Option.

fn new() -> Ref<Self, Unique> where
    Self: Instanciable, 

Creates a new instance of Self using a zero-argument constructor, as a Unique reference.

fn cast<T>(&self) -> Option<&T> where
    T: GodotObject + SubClass<Self>, 

Performs a dynamic reference downcast to target type.

fn upcast<T>(&self) -> &T where
    Self: SubClass<T>,
    T: GodotObject, 

Performs a static reference upcast to a supertype that is guaranteed to be valid.

unsafe fn assume_shared(&self) -> Ref<Self, Shared>

Creates a persistent reference to the same Godot object with shared thread access.

unsafe fn assume_thread_local(&self) -> Ref<Self, ThreadLocal> where
    Self: GodotObject<RefKind = RefCounted>, 

Creates a persistent reference to the same Godot object with thread-local thread access.

unsafe fn assume_unique(&self) -> Ref<Self, Unique>

Creates a persistent reference to the same Godot object with unique access.

impl Instanciable for VehicleBody

fn construct() -> Ref<VehicleBody, Unique>

impl QueueFree for VehicleBody

unsafe fn godot_queue_free(obj: *mut c_void)

impl SubClass<CollisionObject> for VehicleBody

impl SubClass<Node> for VehicleBody

impl SubClass<Object> for VehicleBody

impl SubClass<PhysicsBody> for VehicleBody

impl SubClass<RigidBody> for VehicleBody

impl SubClass<Spatial> for VehicleBody