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
//! Quadros por segundo: o limite (para economizar bateria) e a medida. A plataforma conta
//! cada quadro desenhado ([`Ui::frame_drawn`]) e respeita o limite antes de pedir o
//! próximo ([`Ui::next_frame_at`]).
use std::collections::VecDeque;
use crate::ui::Ui;
#[derive(Debug, Default)]
pub(crate) struct FrameClock {
/// Os instantes (tempo do `Ui`) dos quadros do último segundo.
times: VecDeque<f64>,
/// 0 = sem limite.
max_fps: f32,
/// Quanto um quadro leva para ser desenhado (média dos últimos, em segundos).
cost: f64,
}
impl Ui {
/// Limita os quadros por segundo (0 = sem limite, o padrão: acompanha a tela).
/// Animações continuam suaves dentro do limite; parado, o aylis já não desenha nada.
/// Útil no celular e em notebooks: `ui.set_max_fps(30.0)` corta pela metade o trabalho
/// de uma animação contínua.
pub fn set_max_fps(&mut self, fps: f32) {
self.frames.max_fps = if fps.is_finite() && fps > 0.0 { fps } else { 0.0 };
}
pub fn max_fps(&self) -> f32 {
self.frames.max_fps
}
/// Quantos quadros foram desenhados no último segundo (0 com a tela parada, porque o
/// aylis só desenha quando algo muda).
pub fn fps(&self) -> f32 {
let now = self.time;
self.frames.times.iter().filter(|&&t| now - t <= 1.0).count() as f32
}
/// A plataforma avisa que desenhou um quadro (no tempo atual do `Ui`).
pub fn frame_drawn(&mut self) {
let now = self.time;
self.frames.times.push_back(now);
while self.frames.times.front().is_some_and(|&t| now - t > 1.0) {
self.frames.times.pop_front();
}
}
/// A plataforma diz quanto o último quadro levou para ser desenhado (em segundos).
pub fn frame_cost_measured(&mut self, seconds: f64) {
let c = &mut self.frames.cost;
*c = if *c == 0.0 { seconds } else { *c * 0.8 + seconds * 0.2 };
}
/// Quanto um quadro leva para ser desenhado (a média dos últimos; 0 antes do primeiro).
pub fn frame_cost(&self) -> f64 {
self.frames.cost
}
/// A rolagem pode deslizar: o deslize está ligado e os quadros são rápidos (até 20 ms;
/// com quadros lentos, como num build de depuração, o deslize atrasaria a roda e ela
/// salta direto).
pub fn smooth_scrolling(&self) -> bool {
self.scroll_options().smooth && self.frames.cost <= 0.020
}
/// Quando o último quadro foi desenhado (tempo do `Ui`).
pub fn last_frame(&self) -> Option<f64> {
self.frames.times.back().copied()
}
/// Quando o próximo quadro pode sair (tempo do `Ui`), respeitando o limite. `None` sem
/// limite.
pub fn next_frame_at(&self) -> Option<f64> {
if self.frames.max_fps <= 0.0 {
return None;
}
self.frames.times.back().map(|&last| last + 1.0 / self.frames.max_fps as f64)
}
}