slosh2d 0.4.1

Cross-platform GPU 2D 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
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85

use bytemuck::{Pod, Zeroable};
use slang_hal::BufferUsages;
use slang_hal::backend::Backend;
use stensor::tensor::GpuVector;

#[derive(Copy, Clone, Debug, PartialEq, Pod, Zeroable)]
#[repr(C)]
pub struct GpuBoundaryCondition {
    pub ty: u32,
    pub friction: f32,
}

impl GpuBoundaryCondition {
    pub const STICK: u32 = 0u32;
    pub const SLIP: u32 = 1u32;
    pub const SEPARATE: u32 = 2u32;
    pub const FRICTION_Z_UP: u32 = 3u32;
    pub const NON_REFLECTING: u32 = 4u32;
    pub const DISABLED: u32 = 5u32;

    pub fn stick() -> GpuBoundaryCondition {
        Self {
            ty: Self::STICK,
            friction: 0.0,
        }
    }

    pub fn slip() -> GpuBoundaryCondition {
        Self {
            ty: Self::SLIP,
            friction: 0.0,
        }
    }

    pub fn separate(friction: f32) -> GpuBoundaryCondition {
        Self {
            ty: Self::SEPARATE,
            friction,
        }
    }

    pub fn friction_z_up(friction: f32) -> GpuBoundaryCondition {
        Self {
            ty: Self::FRICTION_Z_UP,
            friction,
        }
    }

    pub fn disabled() -> GpuBoundaryCondition {
        Self {
            ty: Self::DISABLED,
            friction: 0.0
        }
    }

    pub fn non_reflecting() -> GpuBoundaryCondition {
        todo!();
    }
}

impl Default for GpuBoundaryCondition {
    fn default() -> Self {
        Self::separate(1.0)
    }
}

/// GPU buffers for storing impulses from MPM to rigid bodies.
pub struct GpuMaterials<B: Backend> {
    pub materials: GpuVector<GpuBoundaryCondition, B>,
}

impl<B: Backend> GpuMaterials<B> {
    /// Creates impulse buffers for rigid bodies.
    ///
    /// Allocates space for up to 16 bodies (CPIC limitation).
    pub fn new(backend: &B, materials: &[GpuBoundaryCondition]) -> Result<Self, B::Error> {
        assert!(
            materials.len() <= 16,
            "CPIC only supports up to 16 colliders"
        );
        Ok(Self {
            materials: GpuVector::vector(backend, materials, BufferUsages::STORAGE)?,
        })
    }
}