rsbullet 0.4.0

Compiles bullet3 and exposes rust bindings to the C API
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

use std::future::Future;
use std::time::{Duration, Instant};

use robot_behavior::PhysicsEngine;
use roplat::rhythm::Rhythm;
use roplat::{Completion, Execution, ExecutionContext, Lifecycle, RoplatError};

use crate::RsBullet;

/// Rhythm for stepping a simulation.
///
/// Drives the `RsBullet` physics engine at a fixed period and calls
/// `engine.step()` on every tick. It yields `()` to downstream nodes.
///
/// ```ignore
/// let mut sim_rhythm = SimRhythm::new(engine, Duration::from_secs_f64(1.0 / 240.0));
/// sim_rhythm >> { /* observer nodes */ };
/// ```
pub struct SimRhythm {
    engine: RsBullet,
    interval: Duration,
}

impl SimRhythm {
    pub fn new(engine: RsBullet, interval: Duration) -> Self {
        Self { engine, interval }
    }

    /// 获取引擎的可变引用（用于初始化后的额外配置）
    pub fn engine_mut(&mut self) -> &mut RsBullet {
        &mut self.engine
    }
}

impl Lifecycle for SimRhythm {
    type Error = RoplatError;
}

impl Rhythm for SimRhythm {
    type Yield = ();
    type Feed = ();
    type Input = ();
    type Output = ();

    async fn drive<N, F, Fut>(
        &mut self,
        mut nodes: N,
        mut op_domain: F,
        _input: Self::Input,
        context: ExecutionContext,
    ) -> (Execution<()>, N)
    where
        N: Send,
        F: FnMut(N, Self::Yield, ExecutionContext) -> Fut + Send,
        Fut: Future<Output = (Execution<Self::Feed>, N)> + Send,
    {
        let mut sequence = 0u32;
        let start_time = Instant::now();

        loop {
            if context.is_stopping() {
                return (Ok(Completion::Stopped), nodes);
            }
            let next_target = start_time + self.interval * sequence;
            tokio::time::sleep_until(next_target.into()).await;
            sequence += 1;

            if context.is_stopping() {
                return (Ok(Completion::Stopped), nodes);
            }
            // Existing simulator policy is intentionally unchanged: step errors
            // are ignored until simulator semantics receive their own review.
            let _ = self.engine.step();

            let (outcome, returned_nodes) = op_domain(nodes, (), context.clone()).await;
            nodes = returned_nodes;
            match outcome {
                Ok(Completion::Completed(())) => {}
                Ok(Completion::Stopped) => return (Ok(Completion::Stopped), nodes),
                Err(error) => {
                    context.request_stop();
                    return (Err(error), nodes);
                }
            }
        }
    }
}