Added sky color, my plane is cut in half

src/camera/camera_controller.rs

@@ -5,7 +5,7 @@ use winit::keyboard::{KeyCode, PhysicalKey};
 
 
 use super::camera_struct::Camera;
-struct CameraController {
+pub struct CameraController {
     speed: f32,
     is_up_pressed: bool,
     is_down_pressed: bool,
@@ -16,7 +16,7 @@ struct CameraController {
 }
 
 impl CameraController {
-    fn update_camera(&self, camera: &mut Camera) {
+    pub fn update_camera(&self, camera: &mut Camera) {
         // Calculate direction vector
         let forward = camera.target - camera.eye;
         let forward_norm = forward.normalize();
@@ -48,7 +48,7 @@ impl CameraController {
 }
 
 impl CameraController {
-    fn new(speed: f32) -> Self {
+    pub fn new(speed: f32) -> Self {
         Self {
             speed,
             is_up_pressed: false,
@@ -60,7 +60,7 @@ impl CameraController {
         }
     }
 
-    fn process_events(&mut self, event: &WindowEvent) -> bool {
+    pub fn process_events(&mut self, event: &WindowEvent) -> bool {
         match event {
             WindowEvent::KeyboardInput {
                 event:

src/lib.rs

@@ -1,6 +1,6 @@
 use std::{iter, time::{Duration, Instant}};
 
-use camera::{camera_buffer, camera_struct::Camera, camera_uniform};
+use camera::{camera_buffer, camera_controller, camera_struct::Camera, camera_uniform};
 use wgpu::{util::DeviceExt, BlendState, ColorTargetState, PipelineLayoutDescriptor, RenderPipelineDescriptor};
 use winit::{
     event::*,
@@ -23,10 +23,12 @@ struct State<'a> {
     size: winit::dpi::PhysicalSize<u32>,
     render_pipeline : wgpu::RenderPipeline,
     vertex_buffer: wgpu::Buffer,
+
     camera: camera::camera_struct::Camera,
     camera_buffer : wgpu::Buffer,
     camera_bind_group: wgpu::BindGroup,
     camera_uniform : camera_uniform::CameraUniform,
+    camera_controller: camera_controller::CameraController,
     // The window must be declared after the surface so
     // it gets dropped after it as the surface contains
     // unsafe references to the window's resources.
@@ -110,6 +112,7 @@ impl<'a> State<'a> {
 
 
         let plan1 = object::generate_plane(2,2,1.,1.);
+        println!("{:?}", plan1.positions_list());
         let plan2 = plan1.clone();
         let vertex_buffer = device.create_buffer_init(&wgpu::util::BufferInitDescriptor{
             label: Some("Vertex Buffer 1"),
@@ -119,7 +122,7 @@ impl<'a> State<'a> {
 
         let num_vertices = plan2.len();
         let (camera, camera_uniform, camera_buffer,camera_bind_group, camera_bind_group_layout) = camera_buffer::new(&device, &config);
-
+        let camera_controller = camera_controller::CameraController::new(0.1);
 
         let pipeline_layout = device.create_pipeline_layout(&PipelineLayoutDescriptor{
             label: Some("Pipeline Layout"),
@@ -143,7 +146,7 @@ impl<'a> State<'a> {
                 topology: wgpu::PrimitiveTopology::TriangleList,
                 strip_index_format: None,
                 front_face: wgpu::FrontFace::Ccw,
-                cull_mode: Some(wgpu::Face::Back),
+                cull_mode: None,
                 unclipped_depth: false,
                 polygon_mode: wgpu::PolygonMode::Fill,
                 conservative: false
@@ -184,6 +187,7 @@ impl<'a> State<'a> {
             camera_bind_group,
             camera_buffer,
             camera_uniform,
+            camera_controller,
             num_vertices: num_vertices,
             last_frame: last_frame,
             frametime: delta,
@@ -201,16 +205,24 @@ impl<'a> State<'a> {
             self.config.width = new_size.width;
             self.config.height = new_size.height;
             self.surface.configure(&self.device, &self.config);
+
+            self.camera.aspect = self.config.width as f32 / self.config.height as f32;
         }
     }
 
-    #[allow(unused_variables)]
     fn input(&mut self, event: &WindowEvent) -> bool {
-        false
+        self.camera_controller.process_events(event)
     }
 
-    fn update(&mut self) {}
-
+    fn update(&mut self) {
+        self.camera_controller.update_camera(&mut self.camera);
+        self.camera_uniform.update_view_proj(&self.camera);
+        self.queue.write_buffer(
+            &self.camera_buffer,
+            0,
+            bytemuck::cast_slice(&[self.camera_uniform]),
+        );
+    }
     fn render(&mut self) -> Result<(), wgpu::SurfaceError> {
         let output = self.surface.get_current_texture()?;
         let view = output
@@ -231,9 +243,9 @@ impl<'a> State<'a> {
                     resolve_target: None,
                     ops: wgpu::Operations {
                         load: wgpu::LoadOp::Clear(wgpu::Color {
-                            r: 0.0,
-                            g: 0.0,
-                            b: 0.0,
+                            r: 0.52,
+                            g: 0.80,
+                            b: 0.92,
                             a: 1.0,
                         }),
                         store: wgpu::StoreOp::Store,
@@ -245,7 +257,6 @@ impl<'a> State<'a> {
             });
             //render_pass.set_pipeline(&self.sky_pipeline);
 
-
             render_pass.set_pipeline(&self.render_pipeline);
             render_pass.set_vertex_buffer(0, self.vertex_buffer.slice(..));
             render_pass.set_bind_group(0, &self.camera_bind_group, &[]);

src/object.rs

@@ -33,6 +33,9 @@ impl Mesh{
     pub fn vertices(self)-> Vec<Vertex>{
         self.vertices
     }
+    pub fn positions_list(&self) -> Vec<[f32; 3]> {
+        self.vertices.iter().map(|vertex| vertex.position).collect()
+    }
 }
 
 pub fn generate_plane(num_segx: u32, num_segy: u32, width: f32, height: f32) -> Mesh {

src/shaders/shader.wgsl

@@ -1,5 +1,12 @@
 // Vertex shader
 
+struct CameraUniform {
+    view_proj: mat4x4<f32>
+}
+
+@group(0) @binding(0)
+var<uniform> camera: CameraUniform;
+
 struct VertexInput {
     @location(0) position: vec3<f32>,
     @location(1) color: vec3<f32>,
@@ -16,7 +23,7 @@ fn vs_main(
 ) -> VertexOutput {
     var out: VertexOutput;
     out.color = model.color;
-    out.clip_position = vec4<f32>(model.position, 1.0);
+    out.clip_position = camera.view_proj * vec4<f32>(model.position, 1.0);
     return out;
 }
 
@@ -24,5 +31,5 @@ fn vs_main(
 
 @fragment
 fn fs_main(in: VertexOutput) -> @location(0) vec4<f32> {
-    return vec4<f32>(in.color, 1.0);
+    return vec4<f32>(1.0,0.0,0.0, 1.0);
 }