enginerenderer 0.0.1

A zero-dependency offline rendering engine in pure Rust — CPU path tracing, BVH acceleration, 16-band spectral rendering, PBR materials, animation & video export.
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
129
130
131
132
133
134
135
136
137
138
139

use crate::core::debug::runtime::RuntimeAdaptationState;

/// Events emitted by engine subsystems during a frame.
#[derive(Debug, Clone)]
pub enum EngineEvent {
    /// Marks the beginning of a frame.
    FrameStarted {
        /// Frame index.
        frame_index: u64,
        /// Target frame duration in milliseconds.
        target_ms: f64,
    },
    /// Reports a simulation update.
    SimulationAdvanced {
        /// Number of simulated bodies.
        body_count: usize,
    },
    /// Reports scene preparation completion.
    ScenePrepared {
        /// Number of prepared nodes.
        node_count: usize,
    },
    /// Reports audio mix completion.
    AudioMixed {
        /// Final master gain value.
        master_gain: f64,
    },
    /// Reports network synchronization.
    NetworkSynchronized {
        /// Snapshot checksum.
        checksum: u64,
        /// Number of connected clients.
        clients: usize,
    },
    /// Reports frame rendering completion.
    FrameRendered {
        /// Number of rendered pixels.
        pixels: usize,
        /// Output file path.
        output_path: String,
    },
    /// Reports runtime adaptation updates.
    AdaptationUpdated {
        /// Current adaptation state.
        state: RuntimeAdaptationState,
    },
}

/// Aggregated snapshot of the latest event values.
#[derive(Debug, Default, Clone)]
pub struct EventSummary {
    /// Last seen frame index.
    pub last_frame_index: u64,
    /// Last seen target frame duration.
    pub target_ms: f64,
    /// Last reported body count.
    pub body_count: usize,
    /// Last reported node count.
    pub node_count: usize,
    /// Last reported master gain.
    pub master_gain: f64,
    /// Last reported checksum.
    pub checksum: u64,
    /// Last reported client count.
    pub clients: usize,
    /// Last reported pixel count.
    pub pixels: usize,
    /// Last reported output path.
    pub output_path: String,
    /// Last reported adaptation state.
    pub adaptation: RuntimeAdaptationState,
}

/// Event queue with history and summary helpers.
#[derive(Debug, Default, Clone)]
pub struct EventBus {
    pending: Vec<EngineEvent>,
    history: Vec<EngineEvent>,
}

impl EventBus {
    /// Pushes a new event to pending and history buffers.
    pub fn push(&mut self, event: EngineEvent) {
        self.history.push(event.clone());
        self.pending.push(event);
    }

    /// Drains pending events.
    pub fn drain(&mut self) -> Vec<EngineEvent> {
        std::mem::take(&mut self.pending)
    }

    /// Returns the number of events stored in history.
    pub fn history_len(&self) -> usize {
        self.history.len()
    }

    /// Builds a summary from the event history.
    pub fn summarize_history(&self) -> EventSummary {
        let mut summary = EventSummary::default();

        for event in &self.history {
            match event {
                EngineEvent::FrameStarted {
                    frame_index,
                    target_ms,
                } => {
                    summary.last_frame_index = *frame_index;
                    summary.target_ms = *target_ms;
                }
                EngineEvent::SimulationAdvanced { body_count } => {
                    summary.body_count = *body_count;
                }
                EngineEvent::ScenePrepared { node_count } => {
                    summary.node_count = *node_count;
                }
                EngineEvent::AudioMixed { master_gain } => {
                    summary.master_gain = *master_gain;
                }
                EngineEvent::NetworkSynchronized { checksum, clients } => {
                    summary.checksum = *checksum;
                    summary.clients = *clients;
                }
                EngineEvent::FrameRendered {
                    pixels,
                    output_path,
                } => {
                    summary.pixels = *pixels;
                    summary.output_path = output_path.clone();
                }
                EngineEvent::AdaptationUpdated { state } => {
                    summary.adaptation = *state;
                }
            }
        }

        summary
    }
}