leptos_verlet 2.0.2

An engine to perform Verlet simulations in Leptos apps.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94

use bevy::prelude::*;

use crate::{
    core::{
        parameters::{Point, SimulationSettings},
        spawner::{SpawnNode, spawner},
    },
    prelude::{MaterialType, MeshType},
};

/// Smaller stick length will result in a denser rope
const STICK_LENGTH: f32 = 0.025; // m
const DROP_ANGLE: f32 = 35.; // deg
const ROPE_LENGTH: f32 = 1.5; // m

pub fn spawn_rope(
    commands: &mut Commands,
    meshes: &mut ResMut<Assets<Mesh>>,
    materials: &mut ResMut<Assets<StandardMaterial>>,
    point_material: MaterialType,
    stick_material: MaterialType,
    sim_settings: &Res<SimulationSettings>,
    position: Vec3,
) {
    let point_mesh = MeshType::Sphere;
    let stick_mesh = MeshType::Cuboid;

    // red “locked” material for the root node
    let locked_material = MaterialType::Color([1., 0., 0., 1.]);

    // how many sticks (and thus how many extra points)
    let sticks_tot = (ROPE_LENGTH / STICK_LENGTH).floor() as usize;

    // build the chain of point‐positions, respecting bounds of simulation
    let theta = DROP_ANGLE.to_radians();
    let mut positions = Vec::with_capacity(sticks_tot + 1);
    positions.push(position);
    for _ in 0..sticks_tot {
        let prev = *positions.last().unwrap();
        let mut next =
            prev + Vec3::new(-STICK_LENGTH * theta.sin(), STICK_LENGTH * theta.cos(), 0.0);

        // clamp X into [–width/2, +width/2]
        let half_w = sim_settings.simulation_bounds.x.1 / 2.0;
        if next.x <= -half_w {
            let cx = -half_w + 0.001;
            let dy = cx - next.x;
            next = Vec3::new(cx, next.y + dy, next.z);
        } else if next.x >= half_w {
            let cx = half_w - 0.001;
            let dy = next.x - cx;
            next = Vec3::new(cx, next.y + dy, next.z);
        }

        positions.push(next);
    }

    // build adjacency for a linear chain (bidirectional)
    let mut adj = vec![Vec::new(); positions.len()];
    for i in 0..positions.len() - 1 {
        adj[i].push(i + 1);
        adj[i + 1].push(i);
    }

    // turn positions + adj into Vec<SpawnNode>
    let mut mesh_network = Vec::with_capacity(positions.len());
    for i in 0..positions.len() {
        let pos = positions[i];
        let locked = i == 0;
        let neighbors = &adj[i];

        mesh_network.push(SpawnNode {
            point: Point::new(pos, pos, locked),
            connection: Some(neighbors.iter().map(|&j| positions[j]).collect()),
            point_material: if locked {
                locked_material.clone()
            } else {
                point_material.clone()
            },
            point_mesh: point_mesh.clone(),
            point_size: sim_settings.default_geometry_point_size,
            connection_mesh: Some(vec![stick_mesh.clone(); neighbors.len()]),
            connection_material: Some(vec![stick_material.clone(); neighbors.len()]),
            connection_size: Some(vec![
                sim_settings.default_geometry_stick_size;
                neighbors.len()
            ]),
            connection_scale: Some(vec![Vec3::ONE; neighbors.len()]),
            ..default()
        });
    }

    spawner(mesh_network, commands, meshes, materials);
}