Add Rays

Author: Pixels67

Cargo.toml

@@ -4,5 +4,4 @@ version = "0.1.0"
 edition = "2024"
 
 [dependencies]
-macroquad = "0.4.13"
-
+macroquad = "0.4.13"

README.md

@@ -8,4 +8,8 @@ git clone https://github.com/Pixels67/gravity-sim.git
 cd gravity-sim
 cargo build --release
 ```
-***Note***: To get debug lines build with `--dev`
+***Note***: To get debug lines build with `--dev`
+## Controls
+**[A]** / **[D]**: Left / Right \
+**[W]** / **[S]**: Forward / Back \
+**[LShift]** / **[LCtrl]**: Up / Down

src/lib.rs

@@ -1,6 +1,7 @@
 pub mod object;
 pub mod world;
 pub mod physics;
+pub mod screen;
 
 #[cfg(test)]
 mod tests {
@@ -105,4 +106,24 @@ mod tests {
 
         assert_eq!(new, original);
     }
+
+    use crate::screen::*;
+
+    #[test]
+    fn raycast() {
+        let ray = Ray::new(vec3(0., 0., 0.), vec3(1., 0., 0.), 10.);
+        let pos = vec3(5., 0., 0.);
+
+        assert!(ray.raycast(pos, 0.));
+
+        let ray = Ray::new(vec3(0., 0., 0.), vec3(1., 0., 0.), 10.);
+        let pos = vec3(5., 1., 0.);
+
+        assert!(ray.raycast(pos, 1.));
+
+        let ray = Ray::new(vec3(0., 0., 0.), vec3(1., 0., 0.), 10.);
+        let pos = vec3(5., 2., 0.);
+
+        assert!(!ray.raycast(pos, 1.));
+    }
 }

src/main.rs

@@ -1,22 +1,22 @@
-use macroquad::miniquad::*;
+use macroquad::miniquad::window::*;
 use macroquad::prelude::*;
 use gravity_sim::object::*;
 use gravity_sim::world::*;
 
 const BG_COLOR: Color = Color{r: 0.05, g: 0.05, b: 0.05, a: 1.};
 const WINDOW_WIDTH: u32 = 1280;
 const WINDOW_HEIGHT: u32 = 720;
-const GRAV_CONST: f32 = 1.;
-const UPDATE_INTERVAL: f32 = 0.005;
+const GRAV_CONST: f32 = 0.5;
+const UPDATE_INTERVAL: f32 = 0.001;
 
 #[macroquad::main("Sim")]
 async fn main() {
     let mut world = World::new(GRAV_CONST, UPDATE_INTERVAL);
-    window::set_window_size(WINDOW_WIDTH, WINDOW_HEIGHT);
+    set_window_size(WINDOW_WIDTH, WINDOW_HEIGHT);
 
-    world.add_object(Object::new(vec3( 5., 0., 0.), vec3(0., 0.,   0.025), 1., 0.5, RED));
-    world.add_object(Object::new(vec3( 0., 1., 0.), vec3(0., 0.01, 0.),    1., 0.5, GREEN));
-    world.add_object(Object::new(vec3(-5., 0., 0.), vec3(0., 0.,  -0.025), 1., 0.5, BLUE));
+    world.add_object(Object::new(vec3( 5., 0., 0.), vec3(0., 0.,  0.01), 1., 0.5, RED));
+    world.add_object(Object::new(vec3( 0., 0., 0.), vec3(0., 0.,  0.),   1., 0.5, GREEN));
+    world.add_object(Object::new(vec3(-5., 0., 0.), vec3(0., 0., -0.01), 1., 0.5, BLUE));
 
     loop {
         clear_background(BG_COLOR);

src/screen.rs

@@ -0,0 +1,68 @@
+use macroquad::prelude::*;
+
+pub fn get_mouse_pos() -> Vec2 {
+    vec2(
+        (mouse_position().0 - screen_width() / 2.) / screen_width(),
+        (-mouse_position().1 + screen_height() / 2.) / screen_height(),
+    ) * 2.
+}
+
+pub fn get_aspect_ratio() -> f32 {
+    screen_width() / screen_height()
+}
+
+pub struct Ray {
+    pub origin: Vec3,
+    pub dir: Vec3,
+    pub len: f32,
+}
+
+impl Ray {
+    pub fn new(origin: Vec3, dir: Vec3, len: f32) -> Self {
+        let dir = dir.normalize();
+        Self { origin, dir, len }
+    }
+
+    pub fn new_from_cam(cam: &Camera3D, pos: Vec2, len: f32) -> Self {
+        let cam_forward = (cam.target - cam.position).normalize();
+        let cam_right = Vec3::cross(cam_forward, cam.up).normalize();
+        let cam_up = Vec3::cross(cam_right, cam_forward).normalize();
+
+        let aspect_ratio = get_aspect_ratio();
+        let fov_scale = f32::tan(cam.fovy / 2.);
+
+        let offset = cam_right * (pos.x * aspect_ratio * fov_scale) + cam_up * (pos.y * fov_scale);
+        let dir = (offset + cam_forward).normalize();
+
+        Self {
+            origin: cam.position,
+            dir,
+            len,
+        }
+    }
+
+    pub fn raycast(&self, target_pos: Vec3, margin_of_err: f32) -> bool {
+        if self.dir == Vec3::ZERO {
+            return false;
+        }
+
+        let closest_point_approx = self.origin + self.dir * (target_pos - self.origin).length();
+        if target_pos == closest_point_approx {
+            return true;
+        }
+
+        let point_to_target = target_pos - closest_point_approx;
+        let plane_normal = self.dir.cross(point_to_target).normalize();
+        let mirror_axis = self.dir.cross(plane_normal);
+        let mirror_target = (target_pos - closest_point_approx) * mirror_axis;
+
+        let closest_point = target_pos + mirror_target;
+
+        (closest_point - target_pos).length() <= margin_of_err
+    }
+
+    #[cfg(debug_assertions)]
+    pub fn draw(&self, color: Color) {
+        draw_line_3d(self.origin, self.origin + self.dir * self.len, color);
+    }
+}

src/world.rs

@@ -1,7 +1,8 @@
-use super::object::*;
-use super::physics;
+use crate::object::*;
+use crate::physics;
 use macroquad::prelude::*;
 use std::vec;
+use crate::screen::{get_mouse_pos, Ray};
 
 pub struct World {
     pub grav_const: f32,
@@ -15,7 +16,7 @@ pub struct World {
 impl World {
     pub fn new(grav_const: f32, update_interval: f32) -> Self {
         let cam = Camera3D {
-            position: vec3(15., 10., 0.),
+            position: vec3(0., 10., -15.),
             up: vec3(0., 1., 0.),
             target: vec3(0., 0., 0.),
             ..Default::default()
@@ -44,8 +45,8 @@ impl World {
         };
 
         let obj_mat = load_material(shader, params).unwrap();
-        obj_mat.set_uniform("light_pos", vec3(0., 10., 10.));
-        obj_mat.set_uniform("ambient_light", 0.3f32);
+        obj_mat.set_uniform("light_pos", Vec3::ONE);
+        obj_mat.set_uniform("ambient_light", 0.25f32);
 
         World {
             grav_const,
@@ -112,6 +113,14 @@ impl World {
 
         self.objects.draw_all(&self.obj_mat);
 
+        let ray = Ray::new_from_cam(&self.cam, get_mouse_pos(), 100.);
+
+        for obj in self.objects.iter() {
+            if ray.raycast(obj.position, 0.5) {
+                draw_sphere(obj.position, 0.5, None, WHITE);
+            }
+        }
+
         #[cfg(debug_assertions)]
         for obj in self.objects.iter() {
             draw_line_3d(
@@ -141,28 +150,28 @@ impl World {
 
     fn handle_input(&mut self) {
         if get_keys_down().contains(&KeyCode::W) {
-            self.cam.position.x -= 0.4;
-            self.cam.target.x   -= 0.4;
+            self.cam.position.z += 0.4;
+            self.cam.target.z += 0.4;
         }
         if get_keys_down().contains(&KeyCode::S) {
-            self.cam.position.x += 0.4;
-            self.cam.target.x   += 0.4;
+            self.cam.position.z -= 0.4;
+            self.cam.target.z -= 0.4;
         }
         if get_keys_down().contains(&KeyCode::LeftControl) {
             self.cam.position.y -= 0.4;
-            self.cam.target.y   -= 0.4;
+            self.cam.target.y -= 0.4;
         }
         if get_keys_down().contains(&KeyCode::LeftShift) {
             self.cam.position.y += 0.4;
-            self.cam.target.y   += 0.4;
+            self.cam.target.y += 0.4;
         }
         if get_keys_down().contains(&KeyCode::D) {
-            self.cam.position.z -= 0.4;
-            self.cam.target.z   -= 0.4;
+            self.cam.position.x -= 0.4;
+            self.cam.target.x -= 0.4;
         }
         if get_keys_down().contains(&KeyCode::A) {
-            self.cam.position.z += 0.4;
-            self.cam.target.z   += 0.4;
+            self.cam.position.x += 0.4;
+            self.cam.target.x += 0.4;
         }
     }
 }