render_engine 0.1.0-alpha.3

A Metal-based 3D rendering engine for macOS
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
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135

use super::vector3::Vector3;

#[allow(dead_code)]
#[derive(Debug)]
pub struct RigidBodySystem {
    masses: Vec<f64>,
    positions: Vec<Vector3>,
    velocities: Vec<Vector3>,
    accelerations: Vec<Vector3>,
    forces: Vec<Vector3>,
}

impl RigidBodySystem {
    #[allow(dead_code)]
    pub fn new() -> Self {
        RigidBodySystem {
            masses: Vec::new(),
            positions: Vec::new(),
            velocities: Vec::new(),
            accelerations: Vec::new(),
            forces: Vec::new(),
        }
    }

    #[allow(dead_code)]
    pub fn with_capacity(capacity: usize) -> Self {
        RigidBodySystem {
            masses: Vec::with_capacity(capacity),
            positions: Vec::with_capacity(capacity),
            velocities: Vec::with_capacity(capacity),
            accelerations: Vec::with_capacity(capacity),
            forces: Vec::with_capacity(capacity),
        }
    }

    #[allow(dead_code)]
    pub fn add(&mut self, mass: f64, position: Vector3, velocity: Vector3) -> usize {
        let index = self.masses.len();
        self.masses.push(mass);
        self.positions.push(position);
        self.velocities.push(velocity);
        self.accelerations.push(Vector3::zero());
        self.forces.push(Vector3::zero());
        index
    }

    #[allow(dead_code)]
    pub fn update_verlet(&mut self, dt: f64) {
        for i in 0..self.masses.len() {
            // Calculate acceleration from continuous force
            self.accelerations[i] = self.forces[i] / self.masses[i];

            // Update position using Verlet integration
            // x = x + vt + a*0.5*t^2
            self.positions[i] +=
                self.velocities[i] * dt + self.accelerations[i].scale(0.5 * dt * dt);

            // Store old acceleration for velocity update
            let old_acceleration = self.accelerations[i];

            // Calculate new acceleration
            self.accelerations[i] = self.forces[i] / self.masses[i];

            // Update velocity using average acceleration
            // v = v + 1/2(a_0+a)* t
            self.velocities[i] += (old_acceleration + self.accelerations[i]).scale(0.5 * dt);

            // Reset forces for next iteration
            self.accelerations[i] = Vector3::zero();
        }
    }

    #[allow(dead_code)]
    pub fn update_rk4(&mut self, dt: f64, force_func: impl Fn(&Vector3, &Vector3) -> Vector3) {
        for i in 0..self.masses.len() {
            let k1v = force_func(&self.positions[i], &self.velocities[i]) / self.masses[i] * dt;
            let k1r = self.velocities[i] * dt;

            let k2v = force_func(
                &(self.positions[i] + k1r * 0.5),
                &(self.velocities[i] + k1v * 0.5),
            ) / self.masses[i]
                * dt;
            let k2r = (self.velocities[i] + k1v * 0.5) * dt;

            let k3v = force_func(
                &(self.positions[i] + k2r * 0.5),
                &(self.velocities[i] + k2v * 0.5),
            ) / self.masses[i]
                * dt;
            let k3r = (self.velocities[i] + k2v * 0.5) * dt;

            let k4v = force_func(&(self.positions[i] + k3r), &(self.velocities[i] + k3v))
                / self.masses[i]
                * dt;
            let k4r = (self.velocities[i] + k3v) * dt;

            self.velocities[i] += (k1v + k2v * 2.0 + k3v * 2.0 + k4v) * (1.0 / 6.0);
            self.velocities[i] += (k1r + k2r * 2.0 + k3r * 2.0 + k4r) * (1.0 / 6.0);
        }
    }

    #[allow(dead_code)]
    pub fn apply_force(&mut self, index: usize, force: Vector3) {
        self.forces[index] += force;
    }

    #[allow(dead_code)]
    pub fn apply_force_to_all(&mut self, force: Vector3) {
        for f in &mut self.forces {
            *f += force;
        }
    }

    // Getter methods
    #[allow(dead_code)]
    pub fn position(&self, index: usize) -> Vector3 {
        self.positions[index]
    }

    #[allow(dead_code)]
    pub fn velocity(&self, index: usize) -> Vector3 {
        self.velocities[index]
    }

    #[allow(dead_code)]
    pub fn mass(&self, index: usize) -> f64 {
        self.masses[index]
    }

    #[allow(dead_code)]
    pub fn len(&self) -> usize {
        self.masses.len()
    }
}