devela 0.28.0

A development substrate of coherence.
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

// devela::run::time::step
//
//! Defines [`RunStep`].
//

use crate::{RunPhase, RuntimeTick};

#[doc = crate::_tags!(runtime time)]
/// A per-step snapshot passed to app logic.
#[doc = crate::_doc_meta!{
    location("run/time"),
    #[cfg(target_pointer_width = "32")]
    test_size_of(__: RunStep<'_, ()> = 20|160),
    #[cfg(target_pointer_width = "64")]
    test_size_of(__: RunStep<'_, ()> = 32|256),
}]
///
/// `RunStep` is the minimal envelope of one runtime iteration.
///
/// It exposes:
/// - the current logical tick,
/// - the current run phase,
/// - and the events gathered for this step.
///
/// It does not own the runtime, control pacing, or store long-lived state.
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
pub struct RunStep<'a, E = ()> {
    tick: RuntimeTick,
    phase: RunPhase,
    // real_dt: Option<Duration>,
    events: &'a [E],
}

impl<'a, E> RunStep<'a, E> {
    /// Creates a new step snapshot.
    pub const fn new(tick: RuntimeTick, phase: RunPhase, events: &'a [E]) -> Self {
        Self { tick, phase, events }
    }

    /// Returns the logical tick of this step.
    pub const fn tick(&self) -> RuntimeTick {
        self.tick
    }

    /// Returns the run phase of this step.
    pub const fn phase(&self) -> RunPhase {
        self.phase
    }

    /// Returns the events gathered for this step.
    pub const fn events(&self) -> &'a [E] {
        self.events
    }

    /// Returns `true` if this step is in the [`Running`][RunPhase::Running] phase.
    pub const fn is_running(&self) -> bool {
        matches!(self.phase, RunPhase::Running)
    }
}