Struct Collision1D 

pub struct Collision1D {
    pub body_a: CollisionBody1D,
    pub body_b: CollisionBody1D,
    pub coefficient_of_restitution: f64,
}

A one-dimensional collision configuration with two bodies and a restitution coefficient.

Fields

body_a: CollisionBody1D

body_b: CollisionBody1D

coefficient_of_restitution: f64

Implementations

impl Collision1D

pub fn new( body_a: CollisionBody1D, body_b: CollisionBody1D, coefficient_of_restitution: f64, ) -> Option<Self>

Creates a one-dimensional collision when the restitution coefficient is valid.

pub fn final_velocities(&self) -> Option<(f64, f64)>

Computes the final velocities of both bodies.

Examples

use use_collision::{Collision1D, CollisionBody1D};

let body_a = CollisionBody1D::new(1.0, 1.0).unwrap();
let body_b = CollisionBody1D::new(1.0, -1.0).unwrap();
let collision = Collision1D::new(body_a, body_b, 1.0).unwrap();

let (final_a, final_b) = collision.final_velocities().unwrap();

assert!((final_a + 1.0).abs() < 1.0e-12);
assert!((final_b - 1.0).abs() < 1.0e-12);

pub fn final_bodies(&self) -> Option<(CollisionBody1D, CollisionBody1D)>

Computes the final body states after the collision.

pub fn initial_kinetic_energy(&self) -> Option<f64>

Computes the initial total kinetic energy.

pub fn final_kinetic_energy(&self) -> Option<f64>

Computes the final total kinetic energy.

pub fn kinetic_energy_loss(&self) -> Option<f64>

Computes the total kinetic energy lost in the collision.

pub fn kinetic_energy_loss_fraction(&self) -> Option<f64>

Computes the fraction of kinetic energy lost in the collision.

pub fn impulses(&self) -> Option<(f64, f64)>

Computes the impulses applied to both bodies.

Trait Implementations

impl Clone for Collision1D

fn clone(&self) -> Collision1D

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Collision1D

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

Formats the value using the given formatter.

impl PartialEq for Collision1D

fn eq(&self, other: &Collision1D) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Copy for Collision1D

impl StructuralPartialEq for Collision1D