commit bad gpu stuff

Cargo.toml

@@ -6,9 +6,12 @@ edition = "2021"
 [dependencies]
 bytemuck = "1.16.0"
 eframe = {version = "0.27", features = ["wgpu"]}
+egui-file-dialog = "0.5.0"
 egui_extras = "0.27.2"
 env_logger = "0.11.3"
+image = "0.25.1"
 nalgebra = "0.32.5"
+threadpool = "1.8.1"
 # winit = { version = "0.30", features = ["rwh_05" ] }
 # log = "0.4"
 # console_error_panic_hook = "0.1.6"

src/lib.rs

@@ -1,16 +1,22 @@
-use std::num::NonZeroU64;
+use std::{num::NonZeroU64, path::PathBuf};
 
 use cb::TriangleRenderResources;
 use eframe::{
     egui, egui_wgpu,
     wgpu::{self, util::DeviceExt},
 };
+use egui_file_dialog::FileDialog;
 use nalgebra::{Matrix3, SMatrix};
 
 use crate::cb::CustomTriangleCallback;
 
 pub struct App {
-    mat: SMatrix<f32, 3, 3>,
+    color_matrix: SMatrix<f32, 4, 4>,
+    pos_matrix: SMatrix<f32, 3, 3>,
+    file_dialog: FileDialog,
+    new_file: Option<PathBuf>,
+    cur_img_size: Option<egui::Vec2>,
+    image_loaded: bool,
 }
 impl App {
     pub fn new<'a>(cc: &'a eframe::CreationContext<'a>) -> Option<Self> {
@@ -20,28 +26,88 @@ impl App {
 
         let device = &wgpu_render_state.device;
 
+        // let cat = include_bytes!("./cat.jpg");
+        // let cat_img = image::load_from_memory(cat).unwrap();
+        // let cat_rgba = cat_img.to_rgba();
+
+        // use image::GenericImageView;
+        // let dimensions = cat_img.dimensions();
+
+        // let tex_size = wgpu::Extent3d {
+        //     width: dimensions.0,
+        //     height: dimensions.1,
+        //     depth_or_array_layers: 1,
+        // };
+        // let cat_tex = device.create_texture(&wgpu::TextureDescriptor {
+        //     size: tex_size,
+        //     mip_level_count: 1,
+        //     sample_count: 1,
+        //     dimension: wgpu::TextureDimension::D2,
+        //     format: wgpu::TextureFormat::Rgba8UnormSrgb,
+        //     usage: wgpu::TextureUsages::TEXTURE_BINDING | wgpu::TextureUsages::COPY_DST,
+        //     label: Some("cat"),
+        //     view_formats: &[],
+        // });
+
         let shader = device.create_shader_module(wgpu::ShaderModuleDescriptor {
-            label: Some("custom3d"),
+            label: Some("shader"),
-            source: wgpu::ShaderSource::Wgsl(include_str!("./custom3d_wgpu_shader.wgsl").into()),
+            source: wgpu::ShaderSource::Wgsl(include_str!("./shader.wgsl").into()),
         });
 
-        let bind_group_layout = device.create_bind_group_layout(&wgpu::BindGroupLayoutDescriptor {
+        let tex_bind_group_layout =
-            label: Some("custom3d"),
+            device.create_bind_group_layout(&wgpu::BindGroupLayoutDescriptor {
-            entries: &[wgpu::BindGroupLayoutEntry {
+                label: Some("tex_bind_group_layout"),
-                binding: 0,
+                entries: &[
-                visibility: wgpu::ShaderStages::VERTEX,
+                    wgpu::BindGroupLayoutEntry {
-                ty: wgpu::BindingType::Buffer {
+                        binding: 0,
-                    ty: wgpu::BufferBindingType::Uniform,
+                        visibility: wgpu::ShaderStages::FRAGMENT,
-                    has_dynamic_offset: false,
+                        ty: wgpu::BindingType::Texture {
-                    min_binding_size: NonZeroU64::new(16),
+                            multisampled: false,
-                },
+                            view_dimension: wgpu::TextureViewDimension::D2,
-                count: None,
+                            sample_type: wgpu::TextureSampleType::Float { filterable: true },
-            }],
+                        },
-        });
+                        count: None,
+                    },
+                    wgpu::BindGroupLayoutEntry {
+                        binding: 1,
+                        visibility: wgpu::ShaderStages::FRAGMENT,
+                        // This should match the filterable field of the
+                        // corresponding Texture entry above.
+                        ty: wgpu::BindingType::Sampler(wgpu::SamplerBindingType::Filtering),
+                        count: None,
+                    },
+                ],
+            });
+        let matrices_bind_group_layout =
+            device.create_bind_group_layout(&wgpu::BindGroupLayoutDescriptor {
+                label: Some("matrices_bind_group_layout"),
+                entries: &[
+                    wgpu::BindGroupLayoutEntry {
+                        binding: 0,
+                        visibility: wgpu::ShaderStages::FRAGMENT,
+                        ty: wgpu::BindingType::Buffer {
+                            ty: wgpu::BufferBindingType::Uniform,
+                            has_dynamic_offset: false,
+                            min_binding_size: Some(NonZeroU64::new(64)?),
+                        },
+                        count: None,
+                    },
+                    wgpu::BindGroupLayoutEntry {
+                        binding: 1,
+                        visibility: wgpu::ShaderStages::FRAGMENT,
+                        ty: wgpu::BindingType::Buffer {
+                            ty: wgpu::BufferBindingType::Uniform,
+                            has_dynamic_offset: false,
+                            min_binding_size: Some(NonZeroU64::new(36)?),
+                        },
+                        count: None,
+                    },
+                ],
+            });
 
         let pipeline_layout = device.create_pipeline_layout(&wgpu::PipelineLayoutDescriptor {
-            label: Some("custom3d"),
+            label: Some("pipeline_layout"),
-            bind_group_layouts: &[&bind_group_layout],
+            bind_group_layouts: &[&tex_bind_group_layout, &matrices_bind_group_layout],
             push_constant_ranges: &[],
         });
 
@@ -66,64 +132,98 @@ impl App {
             multiview: None,
         });
 
-        let uniform_buffer = device.create_buffer_init(&wgpu::util::BufferInitDescriptor {
+        // let color_matrix_buffer = device.create_buffer_init(&wgpu::util::BufferInitDescriptor {
-            label: Some("custom3d"),
+        //     label: Some("color_matrix_buffer"),
-            contents: bytemuck::cast_slice(&[0.0_f32; 4]), // 16 bytes aligned!
+        //     contents: bytemuck::cast_slice(&[0.0_f32; 4]), // 16 bytes aligned!
-            // Mapping at creation (as done by the create_buffer_init utility) doesn't require us to to add the MAP_WRITE usage
+        //     // Mapping at creation (as done by the create_buffer_init utility) doesn't require us to to add the MAP_WRITE usage
-            // (this *happens* to workaround this bug )
+        //     // (this *happens* to workaround this bug )
-            usage: wgpu::BufferUsages::COPY_DST | wgpu::BufferUsages::UNIFORM,
+        //     usage: wgpu::BufferUsages::COPY_DST | wgpu::BufferUsages::UNIFORM,
-        });
+        // });
 
-        let bind_group = device.create_bind_group(&wgpu::BindGroupDescriptor {
+        // let bind_group = device.create_bind_group(&wgpu::BindGroupDescriptor {
-            label: Some("custom3d"),
+        //     label: Some("custom3d"),
-            layout: &bind_group_layout,
+        //     layout: &bind_group_layout,
-            entries: &[wgpu::BindGroupEntry {
+        //     entries: &[wgpu::BindGroupEntry {
-                binding: 0,
+        //         binding: 0,
-                resource: uniform_buffer.as_entire_binding(),
+        //         resource: uniform_buffer.as_entire_binding(),
-            }],
+        //     }],
-        });
+        // });
 
         // Because the graphics pipeline must have the same lifetime as the egui render pass,
         // instead of storing the pipeline in our `Custom3D` struct, we insert it into the
         // `paint_callback_resources` type map, which is stored alongside the render pass.
-        wgpu_render_state
+
-            .renderer
+        // wgpu_render_state
-            .write()
+        //     .renderer
-            .callback_resources
+        //     .write()
-            .insert(TriangleRenderResources {
+        //     .callback_resources
-                pipeline,
+        //     .insert(TriangleRenderResources {
-                bind_group,
+        //         pipeline,
-                uniform_buffer,
+        //         bind_group,
-            });
+        //         uniform_buffer,
+        //     });
 
         Some(Self {
-            mat: SMatrix::identity(),
+            color_matrix: SMatrix::identity(),
+            pos_matrix: SMatrix::identity(),
+            file_dialog: FileDialog::new(),
+            new_file: None,
+            image_loaded: false,
+            cur_img_size: None,
         })
     }
 }
 
 impl eframe::App for App {
     fn update(&mut self, ctx: &eframe::egui::Context, frame: &mut eframe::Frame) {
+        let mut img = None;
+        egui::SidePanel::right("sidebar").show(ctx, |ui| {
+            if ui.button("Select Image").clicked() {
+                self.file_dialog.select_file()
+            }
+            if self.file_dialog.update(ctx).selected().is_some() {
+                if let Some(path) = self.file_dialog.take_selected() {
+                    println!("path: {path:?}");
+                    if path.ends_with(".jpg") || path.ends_with(".jpeg") || path.ends_with(".png") {
+                        img = Some(image::open(path).unwrap().to_rgba8());
+                    }
+                }
+            }
+
+            ui.add_space(8.);
+            ui.label("Color Matrix Editor");
+            components::mat_editor(ui, &mut self.color_matrix, "color_matrix");
+            ui.add_space(8.);
+            ui.label("Position Matrix Editor");
+            components::mat_editor(ui, &mut self.pos_matrix, "pos_matrix");
+        });
         egui::CentralPanel::default().show(ctx, |ui| {
             ui.heading("My egui Application");
 
-            components::mat_editor(ui, &mut self.mat);
+            if let Some(dimensions) = self.cur_img_size {
+                egui::Frame::canvas(ui.style()).show(ui, |ui| {
+                    let (rect, response) = ui.allocate_exact_size(dimensions, egui::Sense::drag());
 
-            egui::Frame::canvas(ui.style()).show(ui, |ui| {
+                    // let callback = egui_wgpu::Callback::new_paint_callback(
-                let (rect, response) =
+                    //     rect,
-                    ui.allocate_exact_size(egui::Vec2::splat(300.0), egui::Sense::drag());
+                    //     CustomTriangleCallback { angle: 0.5 },
-                dbg!(response);
+                    // );
-
+                    // ui.painter().add(callback);
-                let callback = egui_wgpu::Callback::new_paint_callback(
+                });
-                    rect,
+            }
-                    CustomTriangleCallback { angle: 0.5 },
-                );
-                ui.painter().add(callback);
-            });
         });
     }
 }
 
+mod gpu_proc {
+    use eframe::wgpu;
+
+    pub struct GpuResources {
+        pipeline: wgpu::RenderPipeline,
+        // img_buffer: Option<wgpu::
+    }
+}
+
 mod components {
     use eframe::egui;
     use nalgebra::{Matrix, SMatrix};
@@ -131,8 +231,9 @@ mod components {
     pub fn mat_editor<const R: usize, const C: usize>(
         ui: &mut egui::Ui,
         mat: &mut SMatrix<f32, R, C>,
+        id: &str,
     ) -> egui::Response {
-        egui::Grid::new("mat")
+        egui::Grid::new(id)
             .show(ui, |ui| {
                 mat.row_iter_mut().enumerate().for_each(|(i, mut row)| {
                     row.iter_mut().for_each(|item| {

src/shader.wgsl

@@ -0,0 +1,18 @@
+var<private> v_positions: array<vec2<f32>, 6> = array<vec2<f32>, 6>(
+    vec2<f32>(1., 1.),
+    vec2<f32>(1., -1.),
+    vec2<f32>(-1., 1.),
+    vec2<f32>(1., -1.),
+    vec2<f32>(-1., 1.),
+    vec2<f32>(-1., -1.),
+);
+
+@vertex
+fn vs_main(@builtin(vertex_index) v_idx: u32) -> @builtin(position) vec4<f32> {
+    return vec4<f32>(v_positions[v_idx], 0., 0.);
+}
+
+@fragment
+fn fs_main() -> @location(0) vec4<f32> {
+    return vec4<f32>(0.8, 0.2, 0.8, 1.);
+}