Fixed instanced rendering rendering incorrectly

Changes committed:
	modified:   Cargo.toml
	modified:   src/core.rs
	modified:   src/math.rs
	modified:   src/shaders/final_shader.rs
	modified:   src/shaders/glsl/VkModel.vert
	modified:   src/shaders/model_shader.rs
	modified:   src/shaders/sprv/VkModelVert.spv
	modified:   src/shaders/texture_shader.rs
	modified:   src/vulkan/window.rs

Author: Owlkaline

Cargo.toml

@@ -18,7 +18,7 @@ libc = "0.2.44"
 csv = "1.1"
 
 [dependencies.gltf]
-version = "0.15"
+version = "0.15.1"
 features = ["extras", "names"]
 
 [dependencies.cgmath]

src/core.rs

@@ -785,11 +785,11 @@ impl CoreRender for CoreMaat {
   }
 
   fn show_cursor(&mut self) {
-    
+    self.window.set_cursor_visible(true);
   }
 
   fn hide_cursor(&mut self) {
-    
+    self.window.set_cursor_visible(false);
   }
 
   fn set_clear_colour(&mut self, r: f32, g: f32, b: f32, a: f32) {

src/math.rs

@@ -72,11 +72,81 @@ pub fn sphere_intersect_AABB(sphere: Vector4<f32>, box_location: Vector3<f32>, b
   dist < sphere.w
 }
 
-pub fn is_point_inside_circle(point: Vector2<f32>, sphere: Vector3<f32>) -> bool {
+pub fn is_point_inside_circle(point: Vector2<f32>, sphere: Vector2<f32>, radius: f32) -> bool {
   let dist = ((point.x - sphere.x) * (point.x - sphere.x) +
               (point.y - sphere.y) * (point.y - sphere.y)).sqrt();
 
-  dist < sphere.z // dist < radius
+  dist < radius // dist < radius
+}
+
+pub fn intersect_circle(sphere_a: Vector2<f32>, radius_a: f32, sphere_b: Vector2<f32>, radius_b: f32) -> bool {
+  let dist = ((sphere_a.x - sphere_b.x) * (sphere_a.x - sphere_b.x) +
+              (sphere_a.y - sphere_b.y) * (sphere_a.y - sphere_b.y)).sqrt();
+  
+  dist < radius_a + radius_b // dist < a_radius+b_radius
+}
+
+pub fn intersect_square(box_a_location: Vector2<f32>, box_a_size: Vector2<f32>, box_b_location: Vector2<f32>, box_b_size: Vector2<f32>) -> bool {
+  let a_min_x = box_a_location.x - box_a_size.x*0.5;
+  let a_max_x = box_a_location.x + box_a_size.x*0.5;
+  let a_min_y = box_a_location.y - box_a_size.y*0.5;
+  let a_max_y = box_a_location.y + box_a_size.y*0.5;
+  
+  let b_min_x = box_b_location.x - box_b_size.x*0.5;
+  let b_max_x = box_b_location.x + box_b_size.x*0.5;
+  let b_min_y = box_b_location.y - box_b_size.y*0.5;
+  let b_max_y = box_b_location.y + box_b_size.y*0.5;
+  
+  (a_min_x <= b_max_x && a_max_x >= b_min_x) &&
+  (a_min_y <= b_max_y && a_max_y >= b_min_y)
+}
+
+pub fn circle_intersect_square(sphere: Vector2<f32>, radius: f32, box_location: Vector2<f32>, box_size: Vector2<f32>) -> bool {
+  let min_x = box_location.x - box_size.x*0.5;
+  let max_x = box_location.x + box_size.x*0.5;
+  let min_y = box_location.y - box_size.y*0.5;
+  let max_y = box_location.y + box_size.y*0.5;
+  
+  let x = ((sphere.x).min(max_x)).max(min_x);
+  let y = ((sphere.y).min(max_y)).max(min_y);
+  
+  let dist = ((x - sphere.x) * (x - sphere.x) +
+              (y - sphere.y) * (y - sphere.y)).sqrt();
+  
+  dist < radius
+}
+
+pub fn line_intersect_square(point_a: Vector2<f32>, point_b: Vector2<f32>, box_location: Vector2<f32>, box_size: Vector2<f32>) -> bool {
+  let min_x = box_location.x - box_size.x*0.5;
+  let max_x = box_location.x + box_size.x*0.5;
+  let min_y = box_location.y - box_size.y*0.5;
+  let max_y = box_location.y + box_size.y*0.5;
+  
+  let line_min_x = point_a.x.min(point_b.x);
+  let line_max_x = point_a.x.max(point_b.x);
+  let line_min_y = point_a.y.min(point_b.y);
+  let line_max_y = point_a.y.max(point_b.y);
+  
+  if min_x > line_max_x || max_x < line_min_x {
+    return false;
+  }
+  
+  if max_y < line_min_y || min_y > line_max_y {
+    return false;
+  }
+  
+  // if box not axis aligned
+  // let y_at_rect_min_x = line.calculate_y_for_x(box.left)
+  // let y_at_rect_max_x = line.calculate_y_for_x(box.right)
+  //if min_x > yatrectleft || max_x < yatrectright {
+  //  return false;
+  //}
+  
+  //if max_y < yatrectleft || min_y > yatrectright {
+  //  return false;
+  //}
+  
+  true
 }
 
 pub trait Vector2Math<T> {

src/shaders/final_shader.rs

@@ -244,7 +244,7 @@ impl FinalShader {
     cmd.draw_indexed(Arc::clone(&device), &self.vertex_buffer.internal_object(0),
                              &self.index_buffer.internal_object(0),
                              index_count, &self.pipeline,
-                             vec!(if is_model_texture { 
+                             vec!(if is_model_texture {
                                     *self.descriptor_sets[current_buffer].set(0) 
                                   } else {
                                     *self.ds[current_buffer].set(0)

src/shaders/glsl/VkModel.vert

@@ -83,16 +83,37 @@ vec4 quaternion_normalise(vec4 q) {
   return vec4(q.x/n, q.y/n, q.z/n, q.w/n);
 }
 
-vec4 quaternion_from_rotation(vec3 axis, float deg_rotation) {
-  vec4 q = vec4(0.0);
+vec4 quaternion_from_rotation(vec3 deg_rotation) {
+  /*vec4 q = vec4(0.0);
   
   float h_angle = (deg_rotation*0.5) * M_PI / 180.0;
   q.x = axis.x * sin(h_angle);
   q.y = axis.y * sin(h_angle);
   q.z = axis.z * sin(h_angle);
   q.w = cos(h_angle);
   
+  return q;*/
+  //deg_rotation.x += 180.0;
+  //deg_rotation.z += 270.0;
+  //deg_rotation = vec3(0.0, 0.0, 0.0);
+  float h = 0.5;
+  float s_x = sin(to_radians(deg_rotation.x) * h); // 0
+  float c_x = cos(to_radians(deg_rotation.x) * h); // 1
+  
+  float s_y = sin(to_radians(deg_rotation.z) * h); // 0
+  float c_y = cos(to_radians(deg_rotation.z) * h); // 1
+   
+  float s_z = sin(to_radians(deg_rotation.y) * h); // 0
+  float c_z = cos(to_radians(deg_rotation.y) * h); // 1
+  
+  vec4 q = vec4(0.0);
+  q.w = -s_x*s_y*s_z + c_x*c_y*c_z; //1
+  q.x =  s_x*c_y*c_z + s_y*s_z*c_x; //0
+  q.z = -s_x*s_z*c_y + s_y*c_x*c_z; //0
+  q.y = s_z*s_y*c_z + s_z*c_x*c_y;  // 
+  
   return q;
+  //return vec4(0.0, 0.707, 0.0, 1.0);
 }
 
 vec4 quaternion_conj(vec4 q) {
@@ -121,29 +142,27 @@ vec4 quaternion_mul(vec4 q1, vec4 q2) {
   return qr;
 }
 
-vec3 rotate_vertex_position(vec3 position, vec3 axis, float angle) { 
-  vec4 q = quaternion_from_rotation(axis, angle);
+vec3 rotate_vertex_position(vec3 position, vec3 angle) { 
+  vec4 q = quaternion_normalise(quaternion_from_rotation(angle));
   vec3 v = position.xyz;
   return v + 2.0 * cross(q.xyz, cross(q.xyz, v) + q.w * v);
 }
 
 
-mat4 create_rotation_matrix_from_quaternion(vec3 axis, float deg_rotation) {
-  vec4 q = quaternion_from_rotation(axis, deg_rotation);
-  float s = sin(to_radians(deg_rotation) * 0.5);
+mat4 create_rotation_matrix_from_quaternion(vec3 deg_rotation) {
+  vec4 q = quaternion_from_rotation(deg_rotation);
+  /*float s = sin(to_radians(deg_rotation.x) * 0.5) + sin(to_radians(deg_rotation.y) * 0.5) + sin(to_radians(deg_rotation.z) * 0.5);
   mat4 rotation_matrix = mat4(
           vec4(1.0 - 2.0*s*(q.y*q.y + q.z*q.z),       2.0*s*(q.x*q.y - q.z*q.w),       2.0*s*(q.x*q.z + q.y*q.w), 0.0),
           vec4(      2.0*s*(q.x*q.y + q.z*q.w), 1.0 - 2.0*s*(q.x*q.x + q.z*q.z),       2.0*s*(q.y*q.z - q.x*q.w), 0.0),
           vec4(      2.0*s*(q.x*q.z - q.y*q.w),       2.0*s*(q.y*q.z + q.x*q.w), 1.0 - 2.0*s*(q.x*q.x + q.y*q.y), 0.0),
           vec4(0.0, 0.0, 0.0, 1.0));
-  
+  */
   return rotation_matrix;
 }
 
 vec3 rotate_vector_by_angle(vec3 pos, vec3 rotation) {
-  vec3 rotated_pos = rotate_vertex_position(pos, vec3(1.0, 0.0, 0.0), rotation.x);
-  rotated_pos = rotate_vertex_position(rotated_pos, vec3(0.0, 1.0, 0.0), rotation.y);
-  rotated_pos = rotate_vertex_position(rotated_pos, vec3(0.0, 0.0, 1.0), rotation.z);
+  vec3 rotated_pos = rotate_vertex_position(pos, rotation);
 
   return rotated_pos;
 }

src/shaders/model_shader.rs

@@ -1266,6 +1266,7 @@ impl ModelShader {
       let camera_up          = Vector4::new(c_up.x,     c_up.y,     c_up.z,     scale.x);
       let model              = Vector4::new(position.x, position.y, position.z, scale.y);
       let rotation           = Vector4::new(rotation.x, rotation.y, rotation.z, scale.z);
+      println!("MS: {}: Rotation {:?}", model_reference, rotation);
       let hologram           = Vector4::new(if hologram { 1.0 } else { -1.0 }, self.scanline, 0.0, 0.0);
 
       for j in 0..self.models[i].vertex_buffers.len() {

src/shaders/sprv/VkModelVert.spv

@@ -504,9 +504,9 @@ impl TextureShader {
 
     let height = self.camera.get_top();
     let width = self.camera.get_right();
-    let top = height + height*0.01;
-    let right = width + width*0.01;
-    let pos = self.camera.get_position()+Vector2::new(0.0, -10.0);
+    let top = height; //+ height*0.01;
+    let right = width;// + width*0.01;
+    let pos = self.camera.get_position();//+Vector2::new(0.0, -10.0);
     let projection_details = Vector4::new(pos.x, pos.y, right, top);
     let model = Vector4::new(position.x, position.y, scale.x, scale.y);
     let rotation = Vector4::new(rotation, 0.0, 0.0, 0.0);

src/shaders/texture_shader.rs

@@ -387,6 +387,10 @@ impl VkWindow {
     dpi as f32
   }
 
+  pub fn set_cursor_visible(&mut self, visible: bool) {
+    self.window.set_cursor_visible(visible);
+  }
+  
   pub fn set_cursor_position(&self, new_pos: LogicalPosition<f32>, logs: &mut Logs) {
     if let Err(e) = self.window.set_cursor_position(new_pos) {
       logs.error_msg(&e.to_string());