neovide 0.16.1

Neovide: No Nonsense Neovim Gui
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
140
141
142
143
144

use std::collections::VecDeque;
use std::{rc::Rc, sync::Arc};

use crate::{
    profiling::tracy_zone,
    renderer::{RendererSettings, animation_utils::lerp, fonts::font_loader::*},
    settings::Settings,
};
use skia_safe::{Canvas, Color, Paint, Point, Rect, Size};

const FRAMETIMES_COUNT: usize = 48;

pub struct Profiler {
    pub font: Rc<FontPair>,
    pub position: Point,
    pub size: Size,
    pub frametimes: VecDeque<f32>,

    settings: Arc<Settings>,
}

impl Profiler {
    pub fn new(font_size: f32, settings: Arc<Settings>) -> Self {
        let font_key = FontKey::default();
        let mut font_loader = FontLoader::new(font_size);
        let font = font_loader.get_or_load(&font_key).unwrap();
        Self {
            font,
            position: Point::new(32.0, 32.0),
            size: Size::new(200.0, 120.0),
            frametimes: VecDeque::with_capacity(FRAMETIMES_COUNT),

            settings,
        }
    }

    pub fn draw(&mut self, root_canvas: &Canvas, dt: f32) {
        tracy_zone!("profiler_draw");
        if !self.settings.get::<RendererSettings>().profiler {
            return;
        }

        root_canvas.save();
        let rect = self.get_rect();
        root_canvas.clip_rect(rect, None, Some(false));

        let mut paint = Paint::default();

        // Draw background
        let color = Color::from_argb(200, 30, 30, 30);
        paint.set_color(color);
        root_canvas.draw_paint(&paint);

        // Draw FPS
        let color = Color::from_argb(255, 0, 255, 0);
        paint.set_color(color);
        let mut text_position = self.position;
        text_position.y += self.font.skia_font.size();
        root_canvas.draw_str(
            format!("{:.0}FPS", 1.0 / dt.max(f32::EPSILON)),
            text_position,
            &self.font.skia_font,
            &paint,
        );

        self.frametimes.push_back(dt * 1000.0); // to msecs
        while self.frametimes.len() > FRAMETIMES_COUNT {
            self.frametimes.pop_front();
        }

        self.draw_graph(root_canvas);

        root_canvas.restore();
    }

    fn draw_graph(&self, root_canvas: &Canvas) {
        let mut paint = Paint::default();
        let color = Color::from_argb(255, 0, 100, 200);
        paint.set_color(color);

        // Get min and max and avg.
        let mut min_ft = f32::MAX;
        let mut max_ft = f32::MIN;
        let mut sum = 0.0;
        for dt in self.frametimes.iter() {
            min_ft = dt.min(min_ft);
            max_ft = dt.max(max_ft);
            sum += dt;
        }
        let avg = sum / self.frametimes.len() as f32;
        let min_g = min_ft * 0.8;
        let max_g = max_ft * 1.1;
        let diff = max_g - min_g;

        let mut rect = self.get_rect();
        rect.bottom -= 8.0; // bottom margin

        let graph_height = 80.0;

        paint.set_anti_alias(true);

        let mut prev_point = (rect.left - 10.0, self.position.y + rect.bottom);
        for (i, dt) in self.frametimes.iter().enumerate() {
            let x = lerp(rect.left, rect.right, i as f32 / self.frametimes.len() as f32);
            let y = rect.bottom - graph_height * (*dt - min_g) / diff;
            let point = (x, y);
            root_canvas.draw_line(prev_point, point, &paint);
            prev_point = point;
        }

        let color = Color::from_argb(255, 0, 255, 0);
        paint.set_color(color);
        paint.set_anti_alias(false);

        // Show min, max, avg (average).
        root_canvas.draw_str(
            format!("min: {min_ft:.1}ms"),
            (rect.left, rect.bottom),
            &self.font.skia_font,
            &paint,
        );
        root_canvas.draw_str(
            format!("avg: {avg:.1}ms"),
            (rect.left, rect.bottom - graph_height * 0.5),
            &self.font.skia_font,
            &paint,
        );
        root_canvas.draw_str(
            format!("max: {max_ft:.1}ms"),
            (rect.left, rect.bottom - graph_height),
            &self.font.skia_font,
            &paint,
        );
    }

    fn get_rect(&self) -> Rect {
        Rect::new(
            self.position.x,
            self.position.y,
            self.position.x + self.size.width,
            self.position.y + self.size.height,
        )
    }
}