Struct PhysicsWorld

pub struct PhysicsWorld {
    pub enabled: InheritableVariable<bool>,
    pub integration_parameters: InheritableVariable<IntegrationParameters>,
    pub gravity: InheritableVariable<Vector3<f32>>,
    pub performance_statistics: PhysicsPerformanceStatistics,
    /* private fields */
}

Physics world is responsible for physics simulation in the engine. There is a very few public methods, mostly for ray casting. You should add physical entities using scene graph nodes, such as RigidBody, Collider, Joint.

Fields

enabled: InheritableVariable<bool>

A flag that defines whether physics simulation is enabled or not.

integration_parameters: InheritableVariable<IntegrationParameters>

A set of parameters that define behavior of every rigid body.

gravity: InheritableVariable<Vector3<f32>>

Current gravity vector. Default is (0.0, -9.81, 0.0)

performance_statistics: PhysicsPerformanceStatistics

Performance statistics of a single simulation step.

Implementations

impl PhysicsWorld

pub const ENABLED: &'static str = "enabled"

pub const INTEGRATION_PARAMETERS: &'static str = "integration_parameters"

pub const GRAVITY: &'static str = "gravity"

impl PhysicsWorld

pub fn draw(&self, context: &mut SceneDrawingContext)

Draws physics world. Very useful for debugging, it allows you to see where are rigid bodies, which colliders they have and so on.

pub fn cast_ray<S: QueryResultsStorage>( &self, opts: RayCastOptions, query_buffer: &mut S, )

Casts a ray with given options.

pub fn cast_shape( &self, graph: &Graph, shape: &dyn Shape, shape_pos: &Isometry3<f32>, shape_vel: &Vector3<f32>, max_toi: f32, stop_at_penetration: bool, filter: QueryFilter<'_>, ) -> Option<(Handle<Node>, TOI)>

Casts a shape at a constant linear velocity and retrieve the first collider it hits.

This is similar to ray-casting except that we are casting a whole shape instead of just a point (the ray origin). In the resulting TOI, witness and normal 1 refer to the world collider, and are in world space.

Parameters

• graph - a reference to the scene graph.
• shape - The shape to cast.
• shape_pos - The initial position of the shape to cast.
• shape_vel - The constant velocity of the shape to cast (i.e. the cast direction).
• max_toi - The maximum time-of-impact that can be reported by this cast. This effectively limits the distance traveled by the shape to shapeVel.norm() * maxToi.
• stop_at_penetration - If set to false, the linear shape-cast won’t immediately stop if the shape is penetrating another shape at its starting point and its trajectory is such that it’s on a path to exist that penetration state.
• filter: set of rules used to determine which collider is taken into account by this scene query.

pub fn contacts(&self) -> impl Iterator<Item = ContactPair> + '_

Returns an iterator over all contact pairs generated in this frame.

Trait Implementations

impl Clone for PhysicsWorld

fn clone(&self) -> Self

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for PhysicsWorld

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

Formats the value using the given formatter.

impl Default for PhysicsWorld

fn default() -> Self

Returns the “default value” for a type.

impl Reflect for PhysicsWorld

where Self: 'static, InheritableVariable<bool>: Reflect, InheritableVariable<IntegrationParameters>: Reflect, InheritableVariable<Vector3<f32>>: Reflect,

fn source_path() -> &'static str

fn type_name(&self) -> &'static str

fn doc(&self) -> &'static str

fn assembly_name(&self) -> &'static str

Returns a parent assembly name of the type that implements this trait. WARNING: You should use proc-macro (#[derive(Reflect)]) to ensure that this method will return correct assembly name. In other words - there’s no guarantee, that any implementation other than proc-macro will return a correct name of the assembly. Alternatively, you can use env!("CARGO_PKG_NAME") as an implementation.

fn type_assembly_name() -> &'static str

Returns a parent assembly name of the type that implements this trait. WARNING: You should use proc-macro (#[derive(Reflect)]) to ensure that this method will return correct assembly name. In other words - there’s no guarantee, that any implementation other than proc-macro will return a correct name of the assembly. Alternatively, you can use env!("CARGO_PKG_NAME") as an implementation.

fn fields_info(&self, func: &mut dyn FnMut(&[FieldInfo<'_, '_>]))

fn into_any(self: Box<Self>) -> Box<dyn Any>

fn set( &mut self, value: Box<dyn Reflect>, ) -> Result<Box<dyn Reflect>, Box<dyn Reflect>>

fn as_any(&self, func: &mut dyn FnMut(&dyn Any))

fn as_any_mut(&mut self, func: &mut dyn FnMut(&mut dyn Any))

fn as_reflect(&self, func: &mut dyn FnMut(&dyn Reflect))

fn as_reflect_mut(&mut self, func: &mut dyn FnMut(&mut dyn Reflect))

fn fields(&self, func: &mut dyn FnMut(&[&dyn Reflect]))

fn fields_mut(&mut self, func: &mut dyn FnMut(&mut [&mut dyn Reflect]))

fn field(&self, name: &str, func: &mut dyn FnMut(Option<&dyn Reflect>))

fn field_mut( &mut self, name: &str, func: &mut dyn FnMut(Option<&mut dyn Reflect>), )

fn set_field( &mut self, field: &str, value: Box<dyn Reflect>, func: &mut dyn FnMut(Result<Box<dyn Reflect>, Box<dyn Reflect>>), )

Calls user method specified with #[reflect(setter = ..)] or falls back to Reflect::field_mut

fn as_array(&self, func: &mut dyn FnMut(Option<&(dyn ReflectArray + 'static)>))

fn as_array_mut( &mut self, func: &mut dyn FnMut(Option<&mut (dyn ReflectArray + 'static)>), )

fn as_list(&self, func: &mut dyn FnMut(Option<&(dyn ReflectList + 'static)>))

fn as_list_mut( &mut self, func: &mut dyn FnMut(Option<&mut (dyn ReflectList + 'static)>), )

fn as_inheritable_variable( &self, func: &mut dyn FnMut(Option<&(dyn ReflectInheritableVariable + 'static)>), )

fn as_inheritable_variable_mut( &mut self, func: &mut dyn FnMut(Option<&mut (dyn ReflectInheritableVariable + 'static)>), )

fn as_hash_map( &self, func: &mut dyn FnMut(Option<&(dyn ReflectHashMap + 'static)>), )

fn as_hash_map_mut( &mut self, func: &mut dyn FnMut(Option<&mut (dyn ReflectHashMap + 'static)>), )

impl Visit for PhysicsWorld

where InheritableVariable<bool>: Visit, InheritableVariable<IntegrationParameters>: Visit, InheritableVariable<Vector3<f32>>: Visit,

fn visit(&mut self, name: &str, visitor: &mut Visitor) -> VisitResult

Read or write this value, depending on whether Visitor::is_reading() is true or false.