Merge pull request #2 from lucascompython/test-tranform-feedback

Test tranform feedback

Author: lucascompython

Cargo.lock

@@ -13,7 +13,7 @@ eframe = { version = "0.31", default-features = false, features = [
 ] }
 wgpu = "24"
 egui-wgpu = "0.31"
-log = "0.4"
+log = { version = "0.4", optional = true }
 glam = { version = "0.30", features = ["fast-math"] }
 bytemuck = "1.22"
 rand = { version = "0.9", default-features = false, features = ["small_rng"] }
@@ -27,10 +27,11 @@ mimalloc = { version = "0.1" }
 [target.'cfg(target_arch = "wasm32")'.dependencies]
 wgpu = { version = "24", features = ["webgl"] }
 wasm-bindgen-futures = "0.4"
+web-time = "1.1"                                # TODO: See if I can get rid of this
 web-sys = "0.3"                                 # to access the DOM (to hide the loading text)
 
 [features]
-logs = ["dep:env_logger"]
+logs = ["dep:env_logger", "dep:log"]
 
 [profile.release]
 codegen-units = 1 # Allows LLVM to perform better optimization.

Cargo.toml

@@ -10,10 +10,14 @@ use crate::simulation::{ParticleSimulation, SimParams, SimulationMethod};
 use egui::epaint::text::{FontInsert, InsertFontFamily};
 use glam::Vec3;
 use std::collections::HashSet;
+#[cfg(not(target_arch = "wasm32"))]
 use std::time::Instant;
+#[cfg(target_arch = "wasm32")]
+use web_time::Instant;
 
 pub struct ParticleApp {
     simulation: Box<dyn ParticleSimulation>,
+    surface_format: wgpu::TextureFormat,
     renderer: ParticleRenderer,
     camera: Camera,
 
@@ -94,20 +98,33 @@ impl ParticleApp {
             SimulationMethod::TransformFeedback
         };
 
-        // Create simulation based on method
+        let surface_format = wgpu_render_state.target_format;
+
         let initial_particles;
         let simulation: Box<dyn ParticleSimulation> = match default_method {
             SimulationMethod::Cpu => {
                 initial_particles = 10_000;
-                Box::new(CpuParticleSimulation::new(device, initial_particles))
+                Box::new(CpuParticleSimulation::new(
+                    device,
+                    initial_particles,
+                    surface_format,
+                ))
             }
             SimulationMethod::ComputeShader => {
                 initial_particles = 1_000_000;
-                Box::new(ComputeParticleSimulation::new(device, initial_particles))
+                Box::new(ComputeParticleSimulation::new(
+                    device,
+                    initial_particles,
+                    surface_format,
+                ))
             }
             SimulationMethod::TransformFeedback => {
                 initial_particles = 100_000;
-                Box::new(TransformFeedbackSimulation::new(device, initial_particles))
+                Box::new(TransformFeedbackSimulation::new(
+                    device,
+                    initial_particles,
+                    surface_format,
+                ))
             }
         };
 
@@ -122,6 +139,7 @@ impl ParticleApp {
 
         Self {
             simulation,
+            surface_format,
             renderer,
             camera,
 
@@ -161,13 +179,21 @@ impl ParticleApp {
 
         // Create new simulation with the same particle count
         self.simulation = match new_method {
-            SimulationMethod::Cpu => Box::new(CpuParticleSimulation::new(device, current_count)),
-            SimulationMethod::ComputeShader => {
-                Box::new(ComputeParticleSimulation::new(device, current_count))
-            }
-            SimulationMethod::TransformFeedback => {
-                Box::new(TransformFeedbackSimulation::new(device, current_count))
-            }
+            SimulationMethod::Cpu => Box::new(CpuParticleSimulation::new(
+                device,
+                current_count,
+                self.surface_format,
+            )),
+            SimulationMethod::ComputeShader => Box::new(ComputeParticleSimulation::new(
+                device,
+                current_count,
+                self.surface_format,
+            )),
+            SimulationMethod::TransformFeedback => Box::new(TransformFeedbackSimulation::new(
+                device,
+                current_count,
+                self.surface_format,
+            )),
         };
 
         self.simulation.set_paused(was_paused);

src/app.rs

@@ -29,6 +29,7 @@ impl CallbackTrait for ClonedParticleCallback {
         render_pass.set_pipeline(&self.render_pipeline);
         render_pass.set_bind_group(0, &self.camera_bind_group, &[]);
         render_pass.set_vertex_buffer(0, self.particle_buffer.slice(..));
+        // TODO: See this
         render_pass.draw(0..1, 0..self.num_particles);
     }
 }

src/custom_renderer.rs

@@ -4,13 +4,12 @@
 #[global_allocator]
 static GLOBAL: mimalloc::MiMalloc = mimalloc::MiMalloc;
 
-// When compiling natively:
 #[cfg(not(target_arch = "wasm32"))]
 fn main() -> eframe::Result {
     use std::sync::Arc;
 
     #[cfg(feature = "logs")]
-    env_logger::init(); // Log to stderr (if you run with `RUST_LOG=debug`).
+    env_logger::init_from_env(env_logger::Env::new().default_filter_or("debug"));
 
     let native_options = eframe::NativeOptions {
         viewport: egui::ViewportBuilder::default()
@@ -60,7 +59,7 @@ fn main() -> eframe::Result {
             }),
 
             on_surface_error: Arc::new(|error| {
-                log::error!("Surface error: {:?}", error);
+                eprintln!("Surface error: {:?}", error);
                 egui_wgpu::SurfaceErrorAction::RecreateSurface
             }),
         },
@@ -75,12 +74,12 @@ fn main() -> eframe::Result {
     )
 }
 
-// When compiling to web using trunk:
 #[cfg(target_arch = "wasm32")]
 fn main() {
     use eframe::wasm_bindgen::JsCast as _;
 
     // Redirect `log` message to `console.log` and friends:
+    #[cfg(feature = "logs")]
     eframe::WebLogger::init(log::LevelFilter::Debug).ok();
 
     let web_options = eframe::WebOptions::default();

src/main.rs

@@ -72,30 +72,19 @@ impl ParticleRenderer {
                 entry_point: Some("fs_main"),
                 targets: &[Some(wgpu::ColorTargetState {
                     format: *surface_format,
-                    blend: Some(wgpu::BlendState {
-                        color: wgpu::BlendComponent {
-                            src_factor: wgpu::BlendFactor::SrcAlpha,
-                            dst_factor: wgpu::BlendFactor::OneMinusSrcAlpha,
-                            operation: wgpu::BlendOperation::Add,
-                        },
-                        alpha: wgpu::BlendComponent {
-                            src_factor: wgpu::BlendFactor::One,
-                            dst_factor: wgpu::BlendFactor::One,
-                            operation: wgpu::BlendOperation::Add,
-                        },
-                    }),
+                    blend: Some(wgpu::BlendState::ALPHA_BLENDING),
                     write_mask: wgpu::ColorWrites::ALL,
                 })],
                 compilation_options: Default::default(),
             }),
             primitive: wgpu::PrimitiveState {
                 topology: wgpu::PrimitiveTopology::PointList,
-                strip_index_format: None,
-                front_face: wgpu::FrontFace::Ccw,
-                cull_mode: Some(wgpu::Face::Back),
-                polygon_mode: wgpu::PolygonMode::Fill,
-                unclipped_depth: false,
-                conservative: false,
+                ..Default::default() // strip_index_format: None,
+                                     // front_face: wgpu::FrontFace::Ccw,
+                                     // cull_mode: Some(wgpu::Face::Back),
+                                     // polygon_mode: wgpu::PolygonMode::Fill,
+                                     // unclipped_depth: false,
+                                     // conservative: false,
             },
             depth_stencil: None,
             multisample: wgpu::MultisampleState {