zenithsiz/zsw
1
0
Fork 0
mirror of https://github.com/Zenithsiz/zsw.git synced 2026-02-03 17:52:15 +00:00
Code Issues Packages Projects Releases Wiki Activity

Renamed FrameTime[s] to RenderFrameTime[s].

Browse Source
This commit is contained in:
Filipe Rodrigues 2025-09-14 23:08:56 +01:00
parent fd0fdbd92b
commit e6227c4bca
Signed by: zenithsiz
SSH Key Fingerprint: SHA256:Mb5ppb3Sh7IarBO/sBTXLHbYEOz37hJAlslLQPPAPaU
3 changed files with 47 additions and 44 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

18
zsw/src/main.rs
View File

@ -347,14 +347,16 @@ async fn renderer(
}
let frame_resize = frame_start.elapsed();
shared.metrics.frame_times_add(window.id(), metrics::FrameTime {
paint_egui: frame_paint_egui,
render_start: frame_render_start,
render_panels: frame_render_panels,
render_egui: frame_render_egui,
render_finish: frame_render_finish,
resize: frame_resize,
});
shared
.metrics
.render_frame_times_add(window.id(), metrics::RenderFrameTime {
paint_egui: frame_paint_egui,
render_start: frame_render_start,
render_panels: frame_render_panels,
render_egui: frame_render_egui,
render_finish: frame_render_finish,
resize: frame_resize,
});
}
}

28
zsw/src/metrics.rs
View File

@ -13,7 +13,7 @@ use {
/// Inner
#[derive(Debug)]
struct Inner {
frame_times: HashMap<WindowId, FrameTimes>,
frame_times: HashMap<WindowId, RenderFrameTimes>,
}
/// Metrics
@ -33,7 +33,7 @@ impl Metrics {
}
/// Adds a frame time to the metrics
pub fn frame_times_add(&self, window_id: WindowId, frame_time: FrameTime) {
pub fn render_frame_times_add(&self, window_id: WindowId, frame_time: RenderFrameTime) {
let mut inner = self.inner.lock();
let frame_times = inner.frame_times.entry(window_id).or_default();
if frame_times.paused {
@ -47,12 +47,12 @@ impl Metrics {
}
/// Pauses the frame times for a window
pub fn frame_times_pause(&self, window_id: WindowId, pause: bool) {
pub fn render_frame_times_pause(&self, window_id: WindowId, pause: bool) {
self.inner.lock().frame_times.entry(window_id).or_default().paused = pause;
}
/// Returns if the frame time is paused
pub fn frame_times_is_paused(&self, window_id: WindowId) -> bool {
pub fn render_frame_times_is_paused(&self, window_id: WindowId) -> bool {
match self.inner.lock().frame_times.get(&window_id) {
Some(frame_times) => frame_times.paused,
None => true,
@ -60,7 +60,7 @@ impl Metrics {
}
/// Returns the max number of frame times kept
pub fn frame_times_max_len(&self, window_id: WindowId) -> usize {
pub fn render_frame_times_max_len(&self, window_id: WindowId) -> usize {
match self.inner.lock().frame_times.get(&window_id) {
Some(frame_times) => frame_times.max_len,
None => 0,
@ -68,12 +68,12 @@ impl Metrics {
}
/// Sets the max number of frame times kept
pub fn frame_times_set_max_len(&self, window_id: WindowId, max_len: usize) {
pub fn render_frame_times_set_max_len(&self, window_id: WindowId, max_len: usize) {
self.inner.lock().frame_times.entry(window_id).or_default().max_len = max_len;
}
/// Returns the frame times from the metrics
pub fn frame_times(&self) -> BTreeMap<WindowId, Vec<FrameTime>> {
pub fn render_frame_times(&self) -> BTreeMap<WindowId, Vec<RenderFrameTime>> {
self.inner
.lock()
.frame_times
@ -83,11 +83,11 @@ impl Metrics {
}
}
/// Frame times
/// Render frame times
#[derive(Debug)]
struct FrameTimes {
/// Frame times
times: VecDeque<FrameTime>,
struct RenderFrameTimes {
/// Render frame times
times: VecDeque<RenderFrameTime>,
/// Maximum frame times
max_len: usize,
@ -96,7 +96,7 @@ struct FrameTimes {
paused: bool,
}
impl Default for FrameTimes {
impl Default for RenderFrameTimes {
fn default() -> Self {
Self {
times: VecDeque::new(),
@ -107,12 +107,12 @@ impl Default for FrameTimes {
}
}
/// Frame time.
/// Render frame time.
///
/// These are the durations (cumulative by order) that it
/// took to perform each step of the frame
#[derive(Clone, Copy, Debug)]
pub struct FrameTime {
pub struct RenderFrameTime {
pub paint_egui: Duration,
pub render_start: Duration,
pub render_panels: Duration,

45
zsw/src/settings_menu/metrics.rs
View File

@ -2,7 +2,7 @@
// Imports
use {
crate::metrics::{FrameTime, Metrics},
crate::metrics::{Metrics, RenderFrameTime},
core::time::Duration,
egui::Widget,
std::collections::HashMap,
@ -12,13 +12,13 @@ use {
/// Draws the metrics tab
#[expect(clippy::too_many_lines, reason = "TODO: Split it up")]
pub fn draw_metrics_tab(ui: &mut egui::Ui, metrics: &Metrics) {
let frame_times = metrics.frame_times();
let render_frame_times = metrics.render_frame_times();
// Use the first window as the current window if we hadn't selected one yet
let cur_window_id = super::get_data::<Option<WindowId>>(ui, "metrics-tab-cur-window");
let mut cur_window_id = cur_window_id.lock();
if cur_window_id.is_none() &&
let Some((&window_id, _)) = frame_times.first_key_value()
let Some((&window_id, _)) = render_frame_times.first_key_value()
{
*cur_window_id = Some(window_id);
}
@ -37,23 +37,23 @@ pub fn draw_metrics_tab(ui: &mut egui::Ui, metrics: &Metrics) {
.selected_text(format!("{cur_window_id:?}"))
.show_ui(ui, |ui| {
// TODO: Get windows through another way?
for &window_id in frame_times.keys() {
for &window_id in render_frame_times.keys() {
ui.selectable_value(&mut *cur_window_id, Some(window_id), format!("{window_id:?}"));
}
});
ui.horizontal(|ui| {
let Some(window_id) = *cur_window_id else { return };
let mut is_paused = metrics.frame_times_is_paused(window_id);
let mut is_paused = metrics.render_frame_times_is_paused(window_id);
if ui.toggle_value(&mut is_paused, "Pause").changed() {
metrics.frame_times_pause(window_id, is_paused);
metrics.render_frame_times_pause(window_id, is_paused);
}
let mut max_len = metrics.frame_times_max_len(window_id);
let mut max_len = metrics.render_frame_times_max_len(window_id);
ui.horizontal(|ui| {
ui.label("Maximum frames: ");
if egui::Slider::new(&mut max_len, 0..=60 * 100).ui(ui).changed() {
metrics.frame_times_set_max_len(window_id, max_len);
metrics.render_frame_times_set_max_len(window_id, max_len);
}
});
@ -77,7 +77,7 @@ pub fn draw_metrics_tab(ui: &mut egui::Ui, metrics: &Metrics) {
});
let Some(window_id) = *cur_window_id else { return };
let Some(frame_times) = frame_times.get(&window_id) else {
let Some(render_frame_times) = render_frame_times.get(&window_id) else {
return;
};
@ -86,10 +86,11 @@ pub fn draw_metrics_tab(ui: &mut egui::Ui, metrics: &Metrics) {
let bars = match *is_histogram {
true => {
let mut buckets = HashMap::<_, usize>::new();
for frame_time in frame_times {
let frame_time = self::frame_time_non_cumulative(frame_time, duration_idx).as_millis_f64();
for render_frame_time in render_frame_times {
let render_frame_time =
self::render_frame_time_non_cumulative(render_frame_time, duration_idx).as_millis_f64();
#[expect(clippy::cast_sign_loss, reason = "Durations are positive")]
let bucket_idx = (frame_time * *histogram_time_scale) as usize;
let bucket_idx = (render_frame_time * *histogram_time_scale) as usize;
*buckets.entry(bucket_idx).or_default() += 1;
}
@ -99,26 +100,26 @@ pub fn draw_metrics_tab(ui: &mut egui::Ui, metrics: &Metrics) {
.map(|(bucket_idx, bucket)| {
let width = 1.0 / *histogram_time_scale;
let center = bucket_idx as f64 / *histogram_time_scale + width / 2.0;
let height = *histogram_time_scale * bucket as f64 / frame_times.len() as f64;
let height = *histogram_time_scale * bucket as f64 / render_frame_times.len() as f64;
egui_plot::Bar::new(center, height).width(width)
})
.collect()
},
false => frame_times
false => render_frame_times
.iter()
.enumerate()
.map(|(frame_idx, frame_time)| {
.map(|(frame_idx, render_frame_time)| {
egui_plot::Bar::new(
frame_idx as f64,
self::frame_time_non_cumulative(frame_time, duration_idx).as_millis_f64(),
self::render_frame_time_non_cumulative(render_frame_time, duration_idx).as_millis_f64(),
)
.width(1.0)
})
.collect(),
};
let mut chart = egui_plot::BarChart::new(self::frame_time_name(duration_idx), bars);
let mut chart = egui_plot::BarChart::new(self::render_frame_time_name(duration_idx), bars);
if !*is_histogram && *stack_charts {
chart = chart.stack_on(&charts.iter().collect::<Vec<_>>());
}
@ -142,7 +143,7 @@ pub fn draw_metrics_tab(ui: &mut egui::Ui, metrics: &Metrics) {
}
/// Returns the duration with index `idx`
pub fn frame_time(frame_time: &FrameTime, idx: usize) -> Duration {
pub fn render_frame_time(frame_time: &RenderFrameTime, idx: usize) -> Duration {
match idx {
0 => frame_time.paint_egui,
1 => frame_time.render_start,
@ -155,15 +156,15 @@ pub fn frame_time(frame_time: &FrameTime, idx: usize) -> Duration {
}
/// Returns the non-cumulative duration with index `idx`
pub fn frame_time_non_cumulative(frame_time: &FrameTime, idx: usize) -> Duration {
pub fn render_frame_time_non_cumulative(frame_time: &RenderFrameTime, idx: usize) -> Duration {
match idx {
0 => self::frame_time(frame_time, 0),
_ => self::frame_time(frame_time, idx) - self::frame_time(frame_time, idx - 1),
0 => self::render_frame_time(frame_time, 0),
_ => self::render_frame_time(frame_time, idx) - self::render_frame_time(frame_time, idx - 1),
}
}
/// Returns the name for a frame time duration
pub fn frame_time_name(idx: usize) -> &'static str {
pub fn render_frame_time_name(idx: usize) -> &'static str {
match idx {
0 => "Paint egui",
1 => "Render start",