Select stuff (hit detection is still off)

shaders/triangle.frag

@@ -1,6 +1,11 @@
 #version 450
 #extension GL_ARB_separate_shader_objects : enable
 
+layout(push_constant) uniform PushConstants {
+    mat4 model;
+    bool is_selected;
+} push;
+
 layout(binding = 0) uniform ObjectUniformData {
     mat4 view;
     mat4 projection;
@@ -42,4 +47,7 @@ void main() {
     vec3 specular_color = specular_value * specular_strength * light_color;
 
     out_color = vec4(ambient_color + diffuse_color + specular_color, 1.0) * texture(diffuse_tex, tex_coords);
+    if (push.is_selected) {
+        out_color = mix(out_color, vec4(0.5, 0.5, 0.0, 1.0), 0.1);
+    }
 }

shaders/triangle.vert

@@ -3,6 +3,7 @@
 
 layout(push_constant) uniform PushConstants {
     mat4 model;
+    bool is_selected;
 } push;
 
 layout(binding = 0) uniform ObjectUniformData {

src/game/player.rs

@@ -1,4 +1,5 @@
 use cgmath::{Deg, InnerSpace, Matrix4, One, Quaternion, Rad, Rotation, Rotation3, SquareMatrix, Vector3, vec3, vec4};
+use mgf::Intersection;
 
 use crate::game::player::PlayerMovementMode::{FirstPerson, Flying};
 
@@ -117,13 +118,28 @@ impl Updatable for Player {
             let ray_direction = self.camera.viewport_pos_to_ray(input.mouse_position, renderer.game_data.dimensions).unwrap();
             let ray_origin: [f32; 3] = self.camera.position.into();
             let ray = mgf::Ray::new(ray_origin.into(), ray_direction);
-            println!("Ray: {:?}", ray);
+
-            let collision_mesh = &renderer.game_data.meshes[renderer.game_data.game_objects[0].mesh_index].collision_mesh;
+            let mut shortest_hit: Option<(usize, Intersection)> = None;
-            collision_mesh.bvh.raytrace(&ray, |v, is| {
+            let mut shortest_hit_distance: f32 = f32::MAX;
-                println!("v: {:?}, is: {:?}", v, is);
+
+            for i in 0..renderer.game_data.game_objects.len() {
+                let obj = &renderer.game_data.game_objects[i];
+                let collision_mesh = &renderer.game_data.meshes[obj.mesh_index].collision_mesh;
+                collision_mesh.bvh.raytrace(&ray, |_, is| {
+                    if is.t < shortest_hit_distance {
+                        shortest_hit = Some((i, is));
+                        shortest_hit_distance = is.t;
+                    }
                 });
             }
 
+            if let Some((obj_index, intersection)) = shortest_hit {
+                let obj = &mut renderer.game_data.game_objects[obj_index];
+                obj.is_selected = !obj.is_selected;
+                println!("Hit: {:?}, {:?}", obj.mesh_index, intersection);
+            }
+        }
+
         // Rotation
         self.camera.rotation = self.camera.rotation * Quaternion::from_angle_y(Deg(input.get_axis("look_horizontal") * delta_time * self.look_sensitivity));
         self.camera.rotation = Quaternion::from_angle_x(Deg(input.get_axis("look_vertical") * delta_time * self.look_sensitivity)) * self.camera.rotation;

src/vulkan/gameobject.rs

@@ -6,6 +6,8 @@ use crate::input::InputState;
 use crate::vulkan::{RendererDescriptorSets, TextureHandle};
 use crate::vulkan::{MeshHandle, VulkanRenderer};
 
+use super::pipelines::vs;
+
 #[derive(Clone)]
 pub struct GameObject {
     pub mesh_index: usize,
@@ -15,14 +17,15 @@ pub struct GameObject {
     pub rotation: Quaternion<f32>,
     pub scale: Vector3<f32>,
     pub children: Vec<GameObject>,
-    pub descriptor_sets: Vec<Arc<RendererDescriptorSets>>
+    pub descriptor_sets: Vec<Arc<RendererDescriptorSets>>,
+    pub is_selected: bool
 }
 
 impl GameObject {
     pub fn new(mesh: MeshHandle) -> GameObject {
         GameObject { mesh_index: mesh.index, texture_index: mesh.diffuse_handle, normal_map_index: mesh.normal_handle, position: Vector3::new(0.0, 0.0, 0.0),
             rotation: Quaternion::new(1.0, 0.0, 0.0, 0.0), scale: Vector3::new(1.0, 1.0, 1.0), children: vec![],
-            descriptor_sets: vec![] }
+            descriptor_sets: vec![], is_selected: false }
     }
 
     pub fn _set_position(&mut self, x: f32, y: f32, z: f32) {
@@ -51,6 +54,13 @@ impl GameObject {
         self.rotation = self.rotation * Quaternion::from(Euler::new(Deg(x), Deg(y), Deg(z)));
     }
 
+    pub fn get_push_constants(&self) -> vs::ty::PushConstants {
+        vs::ty::PushConstants {
+            model: self.get_model_matrix().into(),
+            is_selected: if self.is_selected { 0 } else { 1 },
+        }
+    }
+
     pub fn get_model_matrix(&self) -> Matrix4<f32> {
         let translation = Matrix4::from_translation(self.position);
         let rotation: Matrix4<f32> = self.rotation.into();

src/vulkan/mod.rs

@@ -27,7 +27,6 @@ use pipelines::{Drawcall, LineShader};
 use pipelines::line_vs::ty::LinePushConstants;
 use pipelines::DefaultShader;
 use pipelines::vs;
-use pipelines::vs::ty::PushConstants;
 
 use crate::config::RenderConfig;
 use crate::vulkan::gameobject::{GameObject, GameObjectHandle};
@@ -91,7 +90,6 @@ pub struct Texture {
 pub struct GameData {
     pub start_time: SystemTime,
     pub line_vertices: Vec<LinePoint>,
-    pub push_constants: PushConstants,
     pub line_push_constants: LinePushConstants,
     pub recreate_pipeline: bool,
     pub dimensions: [u32; 2],
@@ -126,9 +124,6 @@ impl VulkanRenderer {
     pub fn init(line_vertices: Vec<LinePoint>, enable_validation_layers: bool, render_config: RenderConfig) -> (VulkanRenderer, EventLoop<()>) {
         // Create empty game data struct to be filled
         let mut data = GameData {
-            push_constants: PushConstants {
-                model: Matrix4::identity().into(),
-            },
             line_push_constants: LinePushConstants {
                 model: Matrix4::identity().into(),
                 view: Matrix4::identity().into(),

src/vulkan/pipelines.rs

@@ -140,8 +140,7 @@ impl Drawcall for DefaultShader {
         for i in 0..game_data.game_objects.len() {
             let game_object = &game_data.game_objects[i];
             let mesh = &game_data.meshes[game_object.mesh_index];
-            let mut push_constants = game_data.push_constants.clone();
+            let push_constants = game_object.get_push_constants();
-            push_constants.model = game_object.get_model_matrix().into();
 
             builder.draw_indexed(
                 self.pipeline.clone(),