Struct Vec2 

pub struct Vec2 {
    pub x: f32,
    pub y: f32,
}

Vecteur 2D à composantes en virgule flottante (f32).

Fields

x: f32

Composante sur l’axe horizontal X.

y: f32

Composante sur l’axe vertical Y.

Implementations

impl Vec2

pub const ZERO: Self

Vecteur nul (0.0, 0.0).

pub const fn new(x: f32, y: f32) -> Self

Crée un nouveau vecteur 2D avec les composantes x et y.

Examples found in repository

examples/simulation.rs (line 32)

fn main() {
    println!("=== Test de simulation avec drew-physics ===");

    // Configuration des paramètres du monde (écran 240x320)
    let settings = WorldSettings {
        gravity: Vec2::new(0.0, 9.81),
        viscosity: 0.05,
        bounds_min: Vec2::ZERO,
        bounds_max: Vec2::new(240.0, 320.0),
    };

    // Instanciation du monde physique sans allocation dynamique (capacité fixe de 4 corps)
    let mut world = World::<4>::new(settings);

    // Initialisation d'une bille dynamique avec vitesse initiale
    let mut bille = Body::new(Vec2::new(120.0, 10.0), 1.0, 8.0);
    bille.velocity = Vec2::new(40.0, 0.0);
    let _ = world.add_body(bille);

    // Intervalle de temps par frame (soit ~60 images par seconde)
    let dt = 0.016;

    // Boucle de simulation sur 60 pas de temps
    for step in 0..60 {
        world.step(dt);

        if let Some(body) = world.bodies[0] {
            let x_px = body.position.x as i32;
            let y_px = body.position.y as i32;

            // Affichage toutes les 10 frames pour suivre l'évolution
            if step % 10 == 0 {
                println!(
                    "Frame {:02} | Pos: ({:3}, {:3}) | Vel: ({:6.2}, {:6.2})",
                    step, x_px, y_px, body.velocity.x, body.velocity.y
                );
            }
        }
    }
}

pub fn length_squared(&self) -> f32

Calcule la norme au carré du vecteur (x² + y²).

Utile pour comparer des distances sans coût d’extraction de racine carrée (sqrt).

Trait Implementations

impl Add for Vec2

type Output = Vec2

The resulting type after applying the + operator.

fn add(self, rhs: Self) -> Self

Performs the + operation.

impl AddAssign for Vec2

fn add_assign(&mut self, rhs: Self)

Performs the += operation.

impl Clone for Vec2

fn clone(&self) -> Vec2

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for Vec2

impl Debug for Vec2

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

Formats the value using the given formatter.

impl Default for Vec2

fn default() -> Vec2

Returns the “default value” for a type.

impl Mul<f32> for Vec2

type Output = Vec2

The resulting type after applying the * operator.

fn mul(self, rhs: f32) -> Self

Performs the * operation.

impl PartialEq for Vec2

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

Equality operator ==.

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

Inequality operator !=.

impl StructuralPartialEq for Vec2

impl Sub for Vec2

type Output = Vec2

The resulting type after applying the - operator.

fn sub(self, rhs: Self) -> Self

Performs the - operation.