Optimize trajectory calculation

Author: Pixels67

build_all.sh

@@ -0,0 +1,22 @@
+#!/bin/bash
+cargo build --release --target wasm32-unknown-unknown
+cargo build --release --target x86_64-pc-windows-gnu
+cargo build --release --target x86_64-apple-darwin
+
+cp -r res ./target/wasm32-unknown-unknown/release/ &&
+cp -r res ./target/x86_64-pc-windows-gnu/release/ &&
+cp -r res ./target/x86_64-apple-darwin/release/
+
+cd target || exit
+
+cd wasm32-unknown-unknown/release/ || exit
+zip -r ../../gravity-sim-web.zip gravity-sim.wasm res index.html
+cd ../../
+
+cd x86_64-pc-windows-gnu/release/ || exit
+zip -r ../../gravity-sim-windows.zip gravity-sim.exe res
+cd ../../
+
+cd x86_64-apple-darwin/release/ || exit
+zip -r ../../gravity-sim-mac.zip gravity-sim res
+cd ../../

src/control.rs

@@ -9,23 +9,19 @@ pub struct ControlHandler {
     move_speed: f32,
     scale_speed: f32,
     place_elevation: f32,
-    traj_update_interval: u64,
     control_state: ControlState,
     ghost_obj: Option<Object>,
-    traj_update_counter: u64,
     trajectories: HashMap<usize, Trajectory>,
 }
 
 impl ControlHandler {
-    fn new(move_speed: f32, scale_speed: f32, traj_update_interval: u64) -> Self {
+    fn new(move_speed: f32, scale_speed: f32) -> Self {
         ControlHandler {
             move_speed,
             scale_speed,
-            traj_update_interval,
             place_elevation: 0.0,
             control_state: ControlState::Idle,
             ghost_obj: None,
-            traj_update_counter: 0,
             trajectories: HashMap::new(),
         }
     }
@@ -60,8 +56,7 @@ impl ControlHandler {
             };
 
             renderer.draw_halo(obj.position, obj.radius * 1.1, Some(color));
-            let traj = obj.calculate_trajectory(objects, physics_handler, 10_000, 10);
-            traj.draw(renderer, Some(obj.color), obj.radius);
+            self.draw_obj_trajectory(physics_handler, renderer, objects, &obj);
         }
 
         if is_key_released(KeyCode::R) {
@@ -116,7 +111,7 @@ impl ControlHandler {
         let ray = Ray::new_from_mouse(renderer.get_cam());
 
         if let Some(obj) = &mut self.ghost_obj {
-            let veloc = (ray.plane_intersect(Some(self.place_elevation)) - obj.position) / 100.0;
+            let veloc = (ray.plane_intersect(Some(self.place_elevation)) - obj.position) / 10.0;
 
             let mut virtual_obj: Object = obj.clone();
             virtual_obj.add_velocity(veloc);
@@ -128,37 +123,16 @@ impl ControlHandler {
             );
 
             obj.draw(renderer);
-            let traj = virtual_obj.calculate_trajectory(objects, physics_handler, 10_000, 20);
-            traj.draw(renderer, Some(obj.color), obj.radius);
-
-            let mut clones = objects.get_all_in_area(obj.position, 100.0);
-            let id = clones.push(virtual_obj.clone());
-
-            for (id, traj) in &self.trajectories {
-                let obj = match clones.get(*id) {
-                    Some(obj) => obj,
-                    None => continue,
-                };
-
-                traj.draw(renderer, Some(obj.color), obj.radius);
-            }
 
-            if self.traj_update_counter % self.traj_update_interval == 0 {
-                self.trajectories =
-                    clones.calculate_trajectories_except(id, physics_handler, 5_000, 20);
-            }
-
-            self.traj_update_counter += 1;
+            let mut clones = objects.clone().get_all_in_area(virtual_obj.position, 500.0);
+            clones.push(virtual_obj.clone());
 
-            if self.traj_update_counter == (2u128.pow(64) - 1) as u64 {
-                self.traj_update_counter = 0;
-            }
+            self.draw_objects_trajectories(physics_handler, renderer, &clones);
         }
 
         if is_mouse_button_released(MouseButton::Left) {
             if let Some(obj) = &mut self.ghost_obj {
-                let veloc =
-                    (ray.plane_intersect(Some(self.place_elevation)) - obj.position) / 100.0;
+                let veloc = (ray.plane_intersect(Some(self.place_elevation)) - obj.position) / 10.0;
                 obj.add_velocity(veloc);
                 objects.push(obj.clone());
                 self.ghost_obj = None;
@@ -237,6 +211,35 @@ impl ControlHandler {
         None
     }
 
+    fn draw_obj_trajectory(
+        &mut self,
+        physics_handler: &PhysicsHandler,
+        renderer: &Renderer,
+        objects: &ObjectPool,
+        object: &Object,
+    ) {
+        let traj = object.calculate_trajectory(objects, physics_handler, 10_000, 2);
+        traj.draw(renderer, Some(object.color), object.radius);
+    }
+
+    fn draw_objects_trajectories(
+        &mut self,
+        physics_handler: &PhysicsHandler,
+        renderer: &Renderer,
+        objects: &ObjectPool,
+    ) {
+        self.trajectories = objects.calculate_trajectories(physics_handler, 10_000, 2);
+
+        for (id, traj) in &self.trajectories {
+            let obj = match objects.get(*id) {
+                Some(obj) => obj,
+                None => continue,
+            };
+
+            traj.draw(renderer, Some(obj.color), obj.radius);
+        }
+    }
+
     fn random_color() -> Color {
         Color {
             r: rand::gen_range(0.0, 1.0),
@@ -249,7 +252,7 @@ impl ControlHandler {
 
 impl Default for ControlHandler {
     fn default() -> Self {
-        ControlHandler::new(20.0, 5.0, 5)
+        ControlHandler::new(20.0, 5.0)
     }
 }
 

src/object.rs

@@ -60,8 +60,8 @@ impl Object {
         self
     }
 
-    pub fn update_pos(&mut self) -> &mut Self {
-        self.position += self.velocity;
+    pub fn update_pos(&mut self, time: f32) -> &mut Self {
+        self.position += self.velocity * time;
         self
     }
 
@@ -75,10 +75,8 @@ impl Object {
         objects: &ObjectPool,
         physics_handler: &PhysicsHandler,
         point_count: u32,
-        skip: u32,
+        step: u32,
     ) -> Trajectory {
-        let mut physics_handler = physics_handler.clone();
-
         let mut objects = objects.clone();
         let mut id = self.id;
         if objects.get(id).is_none() {
@@ -87,8 +85,13 @@ impl Object {
 
         let mut trajectory = Trajectory::new();
 
-        for i in 0..point_count {
-            physics_handler.update_objects(&mut objects);
+        for i in 0..point_count * step {
+            let time = physics_handler.get_timestep();
+            physics_handler.update_objects(&mut objects, time);
+
+            if i % step != 0 {
+                continue;
+            }
 
             let obj = objects.get(id);
 
@@ -98,14 +101,7 @@ impl Object {
             }
 
             let obj = obj.unwrap().clone();
-
-            if i % skip == 0 {
-                trajectory.push(obj.position);
-            }
-
-            if (trajectory.first().cloned().unwrap() - obj.position).length() > 1000.0 {
-                return trajectory;
-            }
+            trajectory.push(obj.position);
         }
 
         trajectory
@@ -196,47 +192,55 @@ impl ObjectPool {
         &self,
         physics_handler: &PhysicsHandler,
         point_count: u32,
-        skip: u32,
+        step: u32,
     ) -> HashMap<usize, Trajectory> {
-        let mut trajectories = HashMap::new();
+        let mut ids: Vec<usize> = Vec::new();
+        let mut objects = self.clone();
+        let mut trajectories: HashMap<usize, Trajectory> = HashMap::new();
 
-        for obj in &self.objects {
-            trajectories.insert(
-                obj.id,
-                obj.calculate_trajectory(self, physics_handler, point_count, skip),
-            );
+        for obj in objects.iter_mut() {
+            ids.push(obj.id);
         }
 
-        trajectories
-    }
-
-    pub fn calculate_trajectories_except(
-        &self,
-        id: usize,
-        physics_handler: &PhysicsHandler,
-        point_count: u32,
-        skip: u32,
-    ) -> HashMap<usize, Trajectory> {
-        let mut trajectories = HashMap::new();
+        for i in 0..point_count * step {
+            let time = physics_handler.get_timestep();
+            physics_handler.update_objects(&mut objects, time);
 
-        for obj in &self.objects {
-            if obj.id == id {
+            if i % step != 0 {
                 continue;
             }
 
-            trajectories.insert(
-                obj.id,
-                obj.calculate_trajectory(self, physics_handler, point_count, skip),
-            );
+            for id in ids.clone().iter() {
+                if objects.iter().find(|o| o.id == *id).is_some() {
+                    continue;
+                }
+
+                if let Some(traj) = trajectories.get_mut(id) {
+                    traj.end();
+                }
+
+                ids.remove(ids.iter().position(|id| *id == *id).unwrap());
+            }
+
+            for obj in objects.iter_mut() {
+                if i % step != 0 {
+                    continue;
+                }
+
+                trajectories
+                    .entry(obj.id)
+                    .or_insert(Trajectory::new())
+                    .push(obj.position);
+            }
         }
 
         trajectories
     }
 
     pub fn draw_all(&self, renderer: &Renderer) {
-        for obj in &self.objects {
+        self.iter().for_each(|obj| {
             obj.draw(renderer);
-        }
+        });
     }
 }
 
@@ -254,6 +258,7 @@ impl Clone for ObjectPool {
     }
 }
 
+#[derive(Clone)]
 pub struct Trajectory {
     points: Vec<Vec3>,
     has_end: bool,
@@ -267,12 +272,14 @@ impl Trajectory {
         }
     }
 
-    pub fn push(&mut self, point: Vec3) {
+    pub fn push(&mut self, point: Vec3) -> &mut Trajectory {
         self.points.push(point);
+        self
     }
 
-    pub fn end(&mut self) {
+    pub fn end(&mut self) -> &mut Trajectory {
         self.has_end = true;
+        self
     }
 
     pub fn len(&self) -> usize {

src/physics.rs

@@ -20,31 +20,30 @@ impl PhysicsHandler {
     pub fn update(&mut self, objects: &mut ObjectPool, dt: f32) {
         self.accumulator += dt;
         while self.accumulator > self.timestep {
-            self.update_objects(objects);
-
+            self.update_objects(objects, self.timestep);
             self.accumulator -= self.timestep;
         }
     }
 
-    pub fn update_objects(&mut self, mut objects: &mut ObjectPool) {
+    pub fn update_objects(&self, objects: &mut ObjectPool, time: f32) {
         let mut clone = objects.clone();
 
         for obj in clone.iter_mut() {
-            obj.velocity += self.get_obj_veloc(obj, objects);
+            obj.add_velocity(self.get_obj_veloc(obj, objects, time));
         }
 
         for obj in clone.iter_mut() {
-            obj.update_pos();
+            obj.update_pos(time);
         }
 
-        *objects = clone;
-
-        for obj in objects.clone().iter_mut() {
-            self.handle_collisions(&mut objects, obj);
+        for obj in objects.iter_mut() {
+            self.handle_collisions(&mut clone, obj);
         }
+
+        *objects = clone;
     }
 
-    pub fn handle_collisions(&mut self, objects: &mut ObjectPool, object: &mut Object) {
+    pub fn handle_collisions(&self, objects: &mut ObjectPool, object: &mut Object) {
         for other in objects
             .get_all_in_area(object.position, object.radius)
             .iter_mut()
@@ -84,14 +83,24 @@ impl PhysicsHandler {
         }
     }
 
-    pub fn get_obj_veloc(&self, object: &Object, objects: &ObjectPool) -> Vec3 {
-        let mut force = Vec3::ZERO;
+    pub fn get_obj_veloc(&self, object: &Object, objects: &ObjectPool, time: f32) -> Vec3 {
+        let mut veloc = Vec3::ZERO;
 
         for other in objects.iter() {
-            force += self.get_grav_force(object.mass, other.mass, other.position - object.position);
+            veloc += self.get_grav_veloc(other.mass, other.position - object.position, time);
+        }
+
+        veloc
+    }
+
+    pub fn get_grav_veloc(&self, m2: f32, dist: Vec3, time: f32) -> Vec3 {
+        if dist.length_squared() == 0. {
+            return Vec3::ZERO;
         }
 
-        Self::get_veloc(force, object.mass, self.timestep)
+        let veloc = self.grav_const * m2 / dist.length_squared() * time;
+        let dir = dist.normalize();
+        dir * veloc
     }
 
     pub fn get_grav_force(&self, m1: f32, m2: f32, dist: Vec3) -> Vec3 {
@@ -138,7 +147,7 @@ impl Default for PhysicsHandler {
     fn default() -> PhysicsHandler {
         PhysicsHandler {
             grav_const: 1.0,
-            timestep: 0.01,
+            timestep: 0.2,
             accumulator: 0.,
         }
     }