dynamis-rigid 0.7.0

Rigid body integration, islands, CCD, and constraint solving
Documentation 
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
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128

use crate::capacity::Capacity;
use crate::{
    Ccd, CcdPasses, Rigid, RigidCapacity, RigidDemand, RigidFrame, RigidInputs, RigidPasses,
    RigidResolutionPasses, RigidShape, RigidStreams,
};
use dynamis_abi::COUNTER_ACTIVE;
use dynamis_abi::Counters;
use dynamis_domain::{Domain, Run, StepFacts};
use dynamis_gpu::GpuContext;
use dynamis_gpu::Resources;
use dynamis_pass::{PassGroup, Pipeline, Schedule};
use wgpu::CommandEncoder;

pub struct RigidDomain;

pub struct RigidDomainPasses {
    pub simulation: RigidPasses,
    pub continuous: CcdPasses,
    pub resolution: RigidResolutionPasses,
}

pub struct RigidDomainRuntime {
    pub simulation: Rigid,
    pub continuous: Ccd,
}

#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]
pub struct RigidWork {
    pub body_commands: u32,
    pub constraint_commands: u32,
}

impl Domain for RigidDomain {
    const ID: u32 = 2;

    const SIMULATES: bool = true;

    const PASS_EDGES: dynamis_pass::PassEdges = &[
        RigidPasses::EDGES,
        CcdPasses::EDGES,
        RigidResolutionPasses::EDGES,
    ];

    type Demand = RigidDemand;
    type Inputs = RigidInputs;
    type Work = RigidWork;
    type Streams = RigidStreams;
    type Planner = Capacity;
    type Passes = RigidDomainPasses;
    type Runtime = RigidDomainRuntime;
    type Frame = RigidFrame;
    type Capacity = RigidCapacity;

    fn minimum() -> RigidDemand {
        Capacity::floor(dynamis_domain::STREAM_FLOOR)
    }

    fn occupied(inputs: &RigidInputs) -> bool {
        inputs.bodies > 0
    }

    fn pending(work: &RigidWork) -> bool {
        work.body_commands > 0 || work.constraint_commands > 0
    }

    fn active(measured: &Counters) -> bool {
        measured[COUNTER_ACTIVE] != 0
    }

    fn pass_groups() -> &'static [PassGroup] {
        &[
            RigidPasses::GROUP,
            CcdPasses::GROUP,
            RigidResolutionPasses::GROUP,
        ]
    }

    fn resolve(pipeline: &Pipeline) -> RigidDomainPasses {
        RigidDomainPasses {
            simulation: RigidPasses::resolve(pipeline),
            continuous: CcdPasses::resolve(pipeline),
            resolution: RigidResolutionPasses::resolve(pipeline),
        }
    }

    fn build(
        context: &GpuContext,
        streams: &impl Resources,
        passes: RigidDomainPasses,
    ) -> RigidDomainRuntime {
        RigidDomainRuntime {
            simulation: Rigid::new(context, streams, passes.simulation, passes.resolution),
            continuous: Ccd::new(context, streams, passes.continuous),
        }
    }

    fn frame(facts: &StepFacts, inputs: &RigidInputs, run: Run) -> RigidFrame {
        RigidFrame {
            params: facts.params,
            shape: RigidShape::of(&facts.counts),
            query_count: inputs.queries,
            observed_count: inputs.observed,
            simulating: run.awake,
            indexing: run.indexing,
            ccd: inputs.ccd,
        }
    }

    fn capacity(streams: &RigidStreams) -> RigidCapacity {
        crate::capacity(streams)
    }

    fn record(
        runtime: &RigidDomainRuntime,
        pass: u32,
        schedule: &mut Schedule,
        encoder: &mut CommandEncoder,
        streams: &impl Resources,
        frame: &RigidFrame,
    ) {
        runtime
            .simulation
            .record(pass, schedule, encoder, streams, frame);
        runtime
            .continuous
            .record(pass, schedule, encoder, streams, frame);
    }
}