Architecture of shaders organised + start of the compute pipeline for FFT

src/camera/camera_buffer.rs

@@ -4,7 +4,7 @@ use super::camera_struct;
 
 
 
-pub fn new(device: wgpu::Device, config: SurfaceConfiguration)->(camera_struct::Camera, super::camera_uniform::CameraUniform, wgpu::Buffer, wgpu::BindGroup, wgpu::BindGroupLayout){
+pub fn new(device: &wgpu::Device, config: &SurfaceConfiguration)->(camera_struct::Camera, super::camera_uniform::CameraUniform, wgpu::Buffer, wgpu::BindGroup, wgpu::BindGroupLayout){
     let cam : camera_struct::Camera = camera_struct::Camera {
         eye: (0.0, 1.0, 2.0).into(),
         target: (0.0,0.0,0.0).into(),

src/camera/camera_controller.rs

@@ -1,18 +1,58 @@
 use glam::{Vec3};
-use winit::event::WindowEvent;
+use winit::event::{ElementState, KeyEvent, WindowEvent};
 use winit::event::WindowEvent::KeyboardInput;
+use winit::keyboard::{KeyCode, PhysicalKey};
+
+
+use super::camera_struct::Camera;
 struct CameraController {
     speed: f32,
+    is_up_pressed: bool,
+    is_down_pressed: bool,
     is_forward_pressed: bool,
     is_backward_pressed: bool,
     is_left_pressed: bool,
     is_right_pressed: bool,
 }
 
+impl CameraController {
+    fn update_camera(&self, camera: &mut Camera) {
+        // Calculate direction vector
+        let forward = camera.target - camera.eye;
+        let forward_norm = forward.normalize();
+
+        // Forward/backward movement
+        if self.is_forward_pressed && forward.length() > self.speed {
+            camera.eye += forward_norm * self.speed;
+        }
+        if self.is_backward_pressed {
+            camera.eye -= forward_norm * self.speed;
+        }
+
+        // Right vector using cross product
+        let right = forward_norm.cross(camera.up);
+
+        // Recalculate forward vector (optional)
+        let forward = camera.target - camera.eye;
+
+        // Left/right movement - maintain distance to target
+        if self.is_right_pressed {
+            let new_forward = (forward + right * self.speed).normalize();
+            camera.eye = camera.target - new_forward * forward.length();
+        }
+        if self.is_left_pressed {
+            let new_forward = (forward - right * self.speed).normalize();
+            camera.eye = camera.target - new_forward * forward.length();
+        }
+    }
+}
+
 impl CameraController {
     fn new(speed: f32) -> Self {
         Self {
             speed,
+            is_up_pressed: false,
+            is_down_pressed: false,
             is_forward_pressed: false,
             is_backward_pressed: false,
             is_left_pressed: false,
@@ -23,15 +63,24 @@ impl CameraController {
     fn process_events(&mut self, event: &WindowEvent) -> bool {
         match event {
             WindowEvent::KeyboardInput {
-                input: KeyboardInput {
-                    state,
-                    virtual_keycode: Some(keycode),
-                    ..
-                },
+                event:
+                    KeyEvent {
+                        state,
+                        physical_key: PhysicalKey::Code(keycode),
+                        ..
+                    },
                 ..
             } => {
                 let is_pressed = *state == ElementState::Pressed;
                 match keycode {
+                    KeyCode::Space => {
+                        self.is_up_pressed = is_pressed;
+                        true
+                    }
+                    KeyCode::ShiftLeft => {
+                        self.is_down_pressed = is_pressed;
+                        true
+                    }
                     KeyCode::KeyW | KeyCode::ArrowUp => {
                         self.is_forward_pressed = is_pressed;
                         true
@@ -54,34 +103,4 @@ impl CameraController {
             _ => false,
         }
     }
-
-    fn update_camera(&self, camera: &mut Camera) {
-        // Calculate direction vector
-        let forward = camera.target - camera.eye;
-        let forward_norm = forward.normalize();
-
-        // Forward/backward movement
-        if self.is_forward_pressed && forward.length() > self.speed {
-            camera.eye += forward_norm * self.speed;
-        }
-        if self.is_backward_pressed {
-            camera.eye -= forward_norm * self.speed;
-        }
-
-        // Right vector using cross product
-        let right = forward_norm.cross(camera.up);
-
-        // Recalculate forward vector (optional)
-        let forward = camera.target - camera.eye;
-
-        // Left/right movement - maintain distance to target
-        if self.is_right_pressed {
-            let new_forward = (forward + right * self.speed).normalize();
-            camera.eye = camera.target - new_forward * forward.length();
-        }
-        if self.is_left_pressed {
-            let new_forward = (forward - right * self.speed).normalize();
-            camera.eye = camera.target - new_forward * forward.length();
-        }
-    }
 }

src/compute/compute_pipeline.rs

@@ -0,0 +1,21 @@
+use wgpu::{include_wgsl, ComputePipeline};
+
+pub fn new_compute_pipeline(device: &wgpu::Device)-> ComputePipeline{
+
+    let compute_pipeline_layout = device.create_pipeline_layout(&wgpu::PipelineLayoutDescriptor{
+        label: Some("Compute Pipeline Layout 1"),
+        bind_group_layouts: &[],
+        push_constant_ranges: &[]
+    });
+
+    let compute_shader = device.create_shader_module(include_wgsl!("../shaders/compute.wgsl"));
+
+    let compute_pipeline = device.create_compute_pipeline(&wgpu::ComputePipelineDescriptor{
+        label: Some("Compute Pipeline 1"),
+        layout: Some(&compute_pipeline_layout),
+        module: &compute_shader,
+        entry_point: "@compute"
+    });
+
+    return compute_pipeline
+}

src/compute/mod.rs

@@ -0,0 +1 @@
+mod compute_pipeline;

src/lib.rs

@@ -9,6 +9,7 @@ use winit::{
     window::{Window, WindowBuilder},
 };
 mod camera;
+mod object;
 
 #[cfg(target_arch = "wasm32")]
 use wasm_bindgen::prelude::*;
@@ -98,19 +99,19 @@ impl<'a> State<'a> {
 
         let shader = device.create_shader_module(wgpu::ShaderModuleDescriptor {
             label: Some("Shader 1 from shader.wgsl"),
-            source: wgpu::ShaderSource::Wgsl(include_str!("shader.wgsl").into()),
+            source: wgpu::ShaderSource::Wgsl(include_str!("./shaders/shader.wgsl").into()),
         });
         
 
 
-        let plan1 = generate_plane();
+        let plan1 = object::generate_plane(1,1,1.,1.);
         let vertex_buffer = device.create_buffer_init(&wgpu::util::BufferInitDescriptor{
             label: Some("Vertex Buffer 1"),
-            contents: bytemuck::cast_slice(todo!()),
+            contents: bytemuck::cast_slice(&plan1.vertices()),
             usage: wgpu::BufferUsages::VERTEX,
         });
 
-        let (camera, camera_uniform, camera_buffer,camera_bind_group, camera_bind_group_layout) = camera_buffer::new(device, config);
+        let (camera, camera_uniform, camera_buffer,camera_bind_group, camera_bind_group_layout) = camera_buffer::new(&device, &config);
 
 
         let pipeline_layout = device.create_pipeline_layout(&PipelineLayoutDescriptor{
@@ -128,7 +129,7 @@ impl<'a> State<'a> {
                 module: &shader,
                 entry_point: "@vertex",
                 buffers: &[
-                    Vertex::desc(),
+                    object::Vertex::desc(),
                 ],
             },
             primitive: wgpu::PrimitiveState{

src/main.rs

@@ -4,6 +4,7 @@ use crate::object::generate_plane;
 
 mod camera;
 mod window;
+mod compute;
 mod object;
 fn main() {
     println!("Hello, world!");

src/shaders/compute.wgsl

@@ -0,0 +1,2 @@
+@compute
+fn compute_main(){}