rusting_engine 2.5.7

Vulkan 3D game engine with GPU-accelerated physics for massive physics-heavy scenes
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

//! Input-to-photon latency as far as the engine can see it.
//!
//! A sample runs from the oldest press not yet drawn to the moment the
//! frame that first saw it is handed to the presentation engine, plus that
//! frame's GPU time. The display's scan-out and the monitor's own delay are
//! not included; measuring those needs a camera or a photodiode.

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

#[derive(Debug, Default)]
pub struct InputLatency {
    pending: Option<Instant>,
    /// Latencies since the last [`InputLatency::take_samples`], in ms.
    samples: Vec<f64>,
}

impl InputLatency {
    /// Notes a key or button press. Later presses before the next frame
    /// share the oldest one's sample.
    pub fn record_input(&mut self, at: Instant) {
        self.pending.get_or_insert(at);
    }

    /// Closes the pending sample: the frame that read the press was
    /// presented at `at` and took `gpu` on the GPU.
    pub fn frame_presented(&mut self, at: Instant, gpu: Duration) {
        if let Some(input) = self.pending.take() {
            let latency = at.saturating_duration_since(input) + gpu;
            self.samples.push(latency.as_secs_f64() * 1000.0);
        }
    }

    pub fn take_samples(&mut self) -> Vec<f64> {
        std::mem::take(&mut self.samples)
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn a_sample_spans_the_oldest_press_to_its_presented_frame() {
        let start = Instant::now();
        let ms = Duration::from_millis;
        let mut latency = InputLatency::default();
        // A frame with no press makes no sample.
        latency.frame_presented(start, ms(2));
        latency.record_input(start + ms(1));
        latency.record_input(start + ms(4));
        latency.frame_presented(start + ms(10), ms(3));
        // The next frame has nothing pending.
        latency.frame_presented(start + ms(20), ms(3));
        latency.record_input(start + ms(25));
        latency.frame_presented(start + ms(30), ms(1));
        assert_eq!(latency.take_samples(), [12.0, 6.0]);
        assert!(latency.take_samples().is_empty());
    }
}