slosh3d 0.1.0

Cross-platform GPU 3D Material Point Method implementation.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59

use crate::grid::grid::{GpuGrid, GpuGridMetadata};
use crate::models::{DruckerPrager, DruckerPragerPlasticState, ElasticCoefficients, GpuModels};
use crate::solver::params::GpuSimulationParams;
use crate::solver::{
    GpuParticles, ParticleDynamics, ParticlePhase, ParticlePosition, SimulationParams,
};
use nexus::dynamics::GpuBodySet;
use slang_hal::backend::Backend;
use slang_hal::function::GpuFunction;
use slang_hal::{Shader, ShaderArgs};
use stensor::tensor::GpuTensor;

#[derive(Shader)]
#[shader(module = "slosh::solver::particle_update")]
pub struct WgParticleUpdate<B: Backend> {
    pub particle_update: GpuFunction<B>,
}

#[derive(ShaderArgs)]
struct ParticleUpdateArgs<'a, B: Backend> {
    params: &'a GpuTensor<SimulationParams, B>,
    grid: &'a GpuTensor<GpuGridMetadata, B>,
    plasticity: &'a GpuTensor<DruckerPrager, B>,
    constitutive_model: &'a GpuTensor<ElasticCoefficients, B>,
    plastic_state: &'a GpuTensor<DruckerPragerPlasticState, B>,
    particles_pos: &'a GpuTensor<ParticlePosition, B>,
    particles_dyn: &'a GpuTensor<ParticleDynamics, B>,
    phases: &'a GpuTensor<ParticlePhase, B>,
}

impl<B: Backend> WgParticleUpdate<B> {
    pub fn launch(
        &self,
        backend: &B,
        pass: &mut B::Pass,
        sim_params: &GpuSimulationParams<B>,
        grid: &GpuGrid<B>,
        particles: &GpuParticles<B>,
        models: &GpuModels<B>,
        _bodies: &GpuBodySet<B>,
    ) -> Result<(), B::Error> {
        let args = ParticleUpdateArgs {
            params: &sim_params.params,
            grid: &grid.meta,
            plasticity: &models.drucker_prager_plasticity,
            constitutive_model: &models.linear_elasticity,
            plastic_state: &models.drucker_prager_plastic_state,
            particles_pos: &particles.positions,
            particles_dyn: &particles.dynamics,
            phases: &models.phases,
        };
        self.particle_update.launch(
            backend,
            pass,
            &args,
            [particles.positions.len() as u32, 1, 1],
        )
    }
}