wip wip adding particles

create a bigger buffer than necessary + store a u32 to know the actual number of particles

Not working yet.

Author: ThierryBerger

examples2d/src/dynamic_add.rs

@@ -0,0 +1,108 @@
+use wgsparkl2d::rapier::prelude::{ColliderBuilder, RigidBodyBuilder};
+use wgsparkl_testbed2d::{wgsparkl, Callbacks, RapierData};
+
+use bevy::render::renderer::RenderDevice;
+use nalgebra::{vector, Vector2};
+use wgsparkl::models::DruckerPrager;
+use wgsparkl::{
+    models::ElasticCoefficients,
+    pipeline::MpmData,
+    solver::{Particle, SimulationParams},
+};
+use wgsparkl2d::solver::ParticleDynamics;
+use wgsparkl_testbed2d::{AppState, PhysicsContext};
+
+pub fn dynamic_demo(
+    device: RenderDevice,
+    app_state: &mut AppState,
+    callbacks: &mut Callbacks,
+) -> PhysicsContext {
+    let mut rapier_data = RapierData::default();
+    let device = device.wgpu_device();
+
+    let offset_y = 46.0;
+    let cell_width = 0.2;
+    let mut particles = vec![];
+    let position = vector![0.5, 0.5] * cell_width / 2.0 + Vector2::y() * offset_y;
+    let density = 1000.0;
+    let radius = cell_width / 4.0;
+    particles.push(Particle {
+        position,
+        dynamics: ParticleDynamics::with_density(radius, density),
+        model: ElasticCoefficients::from_young_modulus(10_000_000.0, 0.2),
+        plasticity: Some(DruckerPrager::new(10_000_000.0, 0.2)),
+        phase: None,
+        color: None,
+    });
+
+    if !app_state.restarting {
+        app_state.num_substeps = 10;
+        app_state.gravity_factor = 1.0;
+    };
+
+    let params = SimulationParams {
+        gravity: vector![0.0, -9.81] * app_state.gravity_factor,
+        dt: (1.0 / 60.0) / (app_state.num_substeps as f32),
+        padding: 0.0,
+    };
+
+    /*
+     * Static platforms.
+     */
+    let rb = RigidBodyBuilder::fixed().translation(vector![35.0, -1.0]);
+    let rb_handle = rapier_data.bodies.insert(rb);
+    let co = ColliderBuilder::cuboid(42.0, 1.0);
+    rapier_data
+        .colliders
+        .insert_with_parent(co, rb_handle, &mut rapier_data.bodies);
+
+    let rb = RigidBodyBuilder::fixed()
+        .translation(vector![-25.0, 45.0])
+        .rotation(0.5);
+    let rb_handle = rapier_data.bodies.insert(rb);
+    let co = ColliderBuilder::cuboid(1.0, 52.0);
+    rapier_data
+        .colliders
+        .insert_with_parent(co, rb_handle, &mut rapier_data.bodies);
+
+    let rb = RigidBodyBuilder::fixed()
+        .translation(vector![95.0, 45.0])
+        .rotation(-0.5);
+    let rb_handle = rapier_data.bodies.insert(rb);
+    let co = ColliderBuilder::cuboid(1.0, 52.0);
+    rapier_data
+        .colliders
+        .insert_with_parent(co, rb_handle, &mut rapier_data.bodies);
+
+    callbacks.0.push(Box::new(
+        move |_, physics: &mut PhysicsContext, _, _, queue| {
+            physics.data.particles.push(
+                queue,
+                &Particle {
+                    position,
+                    dynamics: ParticleDynamics::with_density(radius, density),
+                    model: ElasticCoefficients::from_young_modulus(2_000_000_000.0, 0.2),
+                    plasticity: Some(DruckerPrager::new(2_000_000_000.0, 0.2)),
+                    phase: None,
+                    color: None,
+                },
+            )
+        },
+    ));
+
+    let data = MpmData::new(
+        device,
+        params,
+        &particles,
+        1_000,
+        &rapier_data.bodies,
+        &rapier_data.colliders,
+        cell_width,
+        60_000,
+    );
+    PhysicsContext {
+        data,
+        rapier_data,
+        particles,
+    }
+}

examples2d/src/elastic_cut2.rs

@@ -103,6 +103,7 @@ pub fn elastic_cut_demo(
         device,
         params,
         &particles,
+        particles.len(),
         &rapier_data.bodies,
         &rapier_data.colliders,
         cell_width,

examples2d/src/elasticity2.rs

@@ -85,6 +85,7 @@ pub fn elastic_demo(
         device,
         params,
         &particles,
+        particles.len(),
         &rapier_data.bodies,
         &rapier_data.colliders,
         cell_width,

examples2d/src/main.rs

@@ -1,6 +1,7 @@
 use bevy::prelude::*;
 use wgsparkl_testbed2d::{init_testbed, SceneInitFn, SceneInits};
 
+mod dynamic_add;
 mod elastic_cut2;
 mod elasticity2;
 mod sand2;
@@ -20,6 +21,10 @@ pub fn main() {
 fn register_scenes(world: &mut World) {
     let scenes: Vec<(String, SceneInitFn)> = vec![
         ("sand".to_string(), Box::new(sand2::sand_demo)),
+        (
+            "dynamic add".to_string(),
+            Box::new(dynamic_add::dynamic_demo),
+        ),
         ("elastic".to_string(), Box::new(elasticity2::elastic_demo)),
         (
             "elastic cut".to_string(),

examples2d/src/sand2.rs

@@ -163,6 +163,7 @@ pub fn sand_demo(
         device,
         params,
         &particles,
+        particles.len(),
         &rapier_data.bodies,
         &rapier_data.colliders,
         cell_width,

examples3d/src/dynamic_add.rs

@@ -0,0 +1,68 @@
+use wgsparkl_testbed3d::{wgsparkl, Callbacks, RapierData};
+
+use bevy::render::renderer::RenderDevice;
+use nalgebra::vector;
+use rapier3d::prelude::{ColliderBuilder, RigidBodyBuilder};
+use wgsparkl::models::DruckerPrager;
+use wgsparkl::{
+    models::ElasticCoefficients,
+    pipeline::MpmData,
+    solver::{Particle, ParticleDynamics, SimulationParams},
+};
+use wgsparkl_testbed3d::{AppState, PhysicsContext};
+
+use crate::utils::default_scene;
+
+pub fn dynamic_demo(
+    device: RenderDevice,
+    app_state: &mut AppState,
+    _callbacks: &mut Callbacks,
+) -> PhysicsContext {
+    let mut rapier_data = RapierData::default();
+    let device = device.wgpu_device();
+
+    if !app_state.restarting {
+        app_state.num_substeps = 20;
+        app_state.gravity_factor = 1.0;
+    };
+
+    let params = SimulationParams {
+        gravity: vector![0.0, -9.81, 0.0] * app_state.gravity_factor,
+        dt: (1.0 / 60.0) / (app_state.num_substeps as f32),
+    };
+
+    default_scene::spawn_ground_and_walls(&mut rapier_data);
+
+    callbacks.0.push(Box::new(
+        move |_, physics: &mut PhysicsContext, _, _, queue| {
+            physics.data.particles.push(
+                queue,
+                &Particle {
+                    position,
+                    dynamics: ParticleDynamics::with_density(radius, density),
+                    model: ElasticCoefficients::from_young_modulus(2_000_000_000.0, 0.2),
+                    plasticity: Some(DruckerPrager::new(2_000_000_000.0, 0.2)),
+                    phase: None,
+                    color: None,
+                },
+            )
+        },
+    ));
+
+    let particles = vec![];
+    let cell_width = 1.0;
+    let data = MpmData::new(
+        device,
+        params,
+        &particles,
+        &rapier_data.bodies,
+        &rapier_data.colliders,
+        cell_width,
+        60_000,
+    );
+    PhysicsContext {
+        data,
+        rapier_data,
+        particles,
+    }
+}

examples3d/src/main.rs

@@ -4,6 +4,7 @@ use wgsparkl_testbed3d::{init_testbed, SceneInitFn, SceneInits};
 pub mod utils;
 
 mod banana3;
+mod dynamic_add;
 mod elastic_cut3;
 mod glb_to_point_cloud_color;
 mod heightfield3;
@@ -24,6 +25,10 @@ pub fn main() {
 fn register_scenes(world: &mut World) {
     let scenes: Vec<(String, SceneInitFn)> = vec![
         ("sand".to_string(), Box::new(sand3::sand_demo)),
+        (
+            "dynamic addition".to_string(),
+            Box::new(dynamic_add::dynamic_demo),
+        ),
         (
             "heightfield".to_string(),
             Box::new(heightfield3::heightfield_demo),

examples3d/src/sand3.rs

@@ -1,3 +1,5 @@
+use std::ptr::dangling;
+
 use wgsparkl_testbed3d::{wgsparkl, Callbacks, RapierData};
 
 use bevy::render::renderer::RenderDevice;
@@ -88,6 +90,7 @@ pub fn sand_demo(
         device,
         params,
         &particles,
+        particles.len(),
         &rapier_data.bodies,
         &rapier_data.colliders,
         cell_width,

src/grid/sort.wgsl

@@ -5,18 +5,20 @@
 
 
 @group(1) @binding(0)
-var<storage, read_write> particles_pos: array<Particle::Position>;
+var<uniform, read> num_particles u32;
 @group(1) @binding(1)
-var<storage, read_write> scan_values: array<atomic<u32>>; // This has to be atomic for finalize_particles_sort. Should it be a different buffer?
+var<storage, read_write> particles_pos: array<Particle::Position>;
 @group(1) @binding(2)
-var<storage, read_write> sorted_particle_ids: array<u32>;
+var<storage, read_write> scan_values: array<atomic<u32>>; // This has to be atomic for finalize_particles_sort. Should it be a different buffer?
 @group(1) @binding(3)
-var<storage, read_write> particle_node_linked_lists: array<u32>;
+var<storage, read_write> sorted_particle_ids: array<u32>;
 @group(1) @binding(4)
-var<storage, read> rigid_particles_pos: array<Particle::Position>;
+var<storage, read_write> particle_node_linked_lists: array<u32>;
 @group(1) @binding(5)
-var<storage, read_write> rigid_particle_node_linked_lists: array<u32>;
+var<storage, read> rigid_particles_pos: array<Particle::Position>;
 @group(1) @binding(6)
+var<storage, read_write> rigid_particle_node_linked_lists: array<u32>;
+@group(1) @binding(7)
 var<storage, read_write> rigid_particle_needs_block: array<atomic<u32>>;
 
 // Disable this kernel on macos because of the underlying compareExchangeMap which is

src/models/mod.rs

@@ -17,15 +17,18 @@ pub struct GpuModels {
 }
 
 impl GpuModels {
-    pub fn from_particles(device: &Device, particles: &[Particle]) -> Self {
+    pub fn from_particles(device: &Device, particles: &[Particle], maximum_size: usize) -> Self {
+        let additional_unused_particles = maximum_size - particles.len();        
         let models: Vec<_> = particles.iter().map(|p| p.model).collect();
         let plasticity: Vec<_> = particles
             .iter()
             .map(|p| p.plasticity.unwrap_or(DruckerPrager::new(-1.0, -1.0)))
+            .chain(vec![DruckerPrager::new(-1.0, -1.0); additional_unused_particles])
             .collect();
         let plastic_states: Vec<_> = particles
             .iter()
             .map(|_| DruckerPragerPlasticState::default())
+            .chain(vec![DruckerPragerPlasticState::default(); additional_unused_particles])
             .collect();
         let phases: Vec<_> = particles
             .iter()
@@ -35,6 +38,10 @@ impl GpuModels {
                     max_stretch: -1.0,
                 })
             })
+            .chain(vec![ParticlePhase {
+                phase: 0.0,
+                max_stretch: -1.0,
+            }; additional_unused_particles])
             .collect();
         Self {
             linear_elasticity: GpuVector::init(device, &models, BufferUsages::STORAGE),
@@ -47,6 +54,10 @@ impl GpuModels {
             phases: GpuVector::init(device, &phases, BufferUsages::STORAGE),
         }
     }
+
+    pub fn push() {
+
+    }
 }
 
 fn lame_lambda_mu(young_modulus: f32, poisson_ratio: f32) -> (f32, f32) {