aylis-core 0.4.0

Núcleo do Aylis: componentes, layout, propriedades, temas e interfaces de plataforma
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
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
//! O cache de imagens dos renderizadores: o que já foi feito de uma [`Image`] (decodificada,
//! enviada à placa de vídeo) para não refazer a cada pintura.
//!
//! Uma entrada sai quando o app solta a imagem (ninguém mais pede aquele id) ou, passando dos
//! [limites](ImageCacheLimits), a usada há mais tempo. Os limites valem para o processo todo
//! e vêm do `image_cache` do `.aylisproj`.

use std::collections::HashMap;
use std::sync::atomic::{AtomicBool, AtomicU32, AtomicUsize, Ordering};
use std::sync::{Arc, Mutex, Weak};

use crate::image::{Image, WeakImage};

/// Quanto os renderizadores guardam de imagens prontas que o app ainda segura. Passar do
/// limite não erra nada na tela: a imagem que sai é refeita (decodificada ou reenviada à
/// placa) quando aparecer de novo, o que custa tempo de pintura.
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub struct ImageCacheLimits {
    /// Megabytes de imagens em pixels (quadros de vídeo, prévias, câmera, os blocos de um
    /// desenho) guardadas na placa. Precisa caber o que fica na tela ao mesmo tempo; um
    /// desenho 4K inteiro visível ocupa ~33 MB.
    pub pixels_mb: u32,
    /// Quantas imagens de arquivo (PNG, JPEG, SVG...) ficam guardadas, decodificadas e na
    /// placa. Precisa caber as que aparecem juntas numa tela (ícones, miniaturas, uma galeria).
    pub files: u32,
    /// Megabytes das camadas guardadas ([`LayerCache`]): o desenho de um controle com
    /// `cache_layer`, ou das páginas numa transição, guardado como imagem para andar e
    /// esmaecer sem repintar os filhos. Precisa caber as que andam juntas (uma transição de
    /// aba em 4K são duas de ~33 MB). `0`: nenhuma fica guardada (tudo é repintado a cada
    /// quadro).
    pub layers_mb: u32,
}

impl ImageCacheLimits {
    pub const DEFAULT: Self = Self { pixels_mb: 96, files: 256, layers_mb: 128 };
    /// Os menores e maiores valores aceitos: abaixo, uma tela comum já refaria imagens a cada
    /// pintura; acima, o cache poderia tomar a memória da placa.
    pub const PIXELS_MB_RANGE: (u32, u32) = (8, 4096);
    pub const FILES_RANGE: (u32, u32) = (16, 65_536);
    pub const LAYERS_MB_RANGE: (u32, u32) = (0, 4096);

    /// Os limites dentro das faixas aceitas.
    pub fn clamped(self) -> Self {
        Self {
            pixels_mb: self.pixels_mb.clamp(Self::PIXELS_MB_RANGE.0, Self::PIXELS_MB_RANGE.1),
            files: self.files.clamp(Self::FILES_RANGE.0, Self::FILES_RANGE.1),
            layers_mb: self.layers_mb.clamp(Self::LAYERS_MB_RANGE.0, Self::LAYERS_MB_RANGE.1),
        }
    }

    /// Os bytes de [`layers_mb`](Self::layers_mb).
    pub fn layers_bytes(self) -> usize {
        self.layers_mb as usize * (1 << 20)
    }

    /// Os bytes de [`pixels_mb`](Self::pixels_mb).
    pub fn pixels_bytes(self) -> usize {
        self.pixels_mb as usize * (1 << 20)
    }
}

impl Default for ImageCacheLimits {
    fn default() -> Self {
        Self::DEFAULT
    }
}

static PIXELS_MB: AtomicU32 = AtomicU32::new(ImageCacheLimits::DEFAULT.pixels_mb);
static FILES: AtomicU32 = AtomicU32::new(ImageCacheLimits::DEFAULT.files);
static LAYERS_MB: AtomicU32 = AtomicU32::new(ImageCacheLimits::DEFAULT.layers_mb);
static AUTO_LAYERS: AtomicBool = AtomicBool::new(true);

/// Até quantos KB um quadro de câmera ou de vídeo (pixels novos a cada quadro) reaproveita o
/// bitmap do quadro anterior na placa, em vez de criar outro (o `frame_reuse_kb` do
/// `image_cache`). Medido em 14/11 no Direct2D (`medicoes/d2d_frames.json`): abaixo de ~1 MB
/// reaproveitar é mais rápido (36 câmeras de 320 × 180: de 7,3 para 1,7 ms por quadro); acima,
/// copiar num bitmap grande custa mais que criar outro. `0` desliga.
pub const DEFAULT_FRAME_REUSE_KB: u32 = 1024;
/// A faixa aceita de [`frame_reuse_kb`] (até um quadro 4K, ~32 MB).
pub const FRAME_REUSE_KB_RANGE: (u32, u32) = (0, 32 * 1024);

static FRAME_REUSE_KB: AtomicU32 = AtomicU32::new(DEFAULT_FRAME_REUSE_KB);

/// Veja [`DEFAULT_FRAME_REUSE_KB`].
pub fn frame_reuse_kb() -> u32 {
    FRAME_REUSE_KB.load(Ordering::Relaxed)
}

/// Troca o limite (o projeto faz isso ao abrir); fora da faixa, ajustado.
pub fn set_frame_reuse_kb(kb: u32) {
    FRAME_REUSE_KB.store(kb.clamp(FRAME_REUSE_KB_RANGE.0, FRAME_REUSE_KB_RANGE.1), Ordering::Relaxed);
}

/// O valor da propriedade `frame_reuse_kb` do form como limite próprio: negativo é "o do
/// projeto" (`None`); fora da faixa, ajustado.
pub fn form_frame_reuse(value: i64) -> Option<u32> {
    (value >= 0).then(|| value.min(FRAME_REUSE_KB_RANGE.1 as i64) as u32)
}

/// O limite que vale numa janela, em três níveis: o forçado no diagnóstico
/// (`AYLIS_FRAME_REUSE_KB`, só em depuração), o do form (`frame_reuse_kb` ≥ 0) e o do
/// projeto ([`frame_reuse_kb`], que o `RenderSettings` troca em execução).
pub fn frame_reuse_limit(forced: Option<u32>, form: Option<u32>) -> u32 {
    forced.or(form).unwrap_or_else(frame_reuse_kb)
}

/// Se um quadro de `width × height` (4 bytes por pixel) reaproveita o bitmap do anterior com o
/// limite `kb`.
pub fn reuses_frame(width: u32, height: u32, kb: u32) -> bool {
    kb > 0 && (width as u64) * (height as u64) * 4 <= kb as u64 * 1024
}

/// Os limites em vigor.
pub fn limits() -> ImageCacheLimits {
    ImageCacheLimits { pixels_mb: PIXELS_MB.load(Ordering::Relaxed), files: FILES.load(Ordering::Relaxed), layers_mb: LAYERS_MB.load(Ordering::Relaxed) }
}

/// Troca os limites (o projeto faz isso ao abrir); valores fora da faixa são ajustados.
pub fn set_limits(limits: ImageCacheLimits) {
    let l = limits.clamped();
    PIXELS_MB.store(l.pixels_mb, Ordering::Relaxed);
    FILES.store(l.files, Ordering::Relaxed);
    LAYERS_MB.store(l.layers_mb, Ordering::Relaxed);
}

/// As camadas automáticas: as páginas numa transição e o contêiner que recorta os filhos com
/// o lugar ou a transparência animando vão para uma camada guardada sem o app pedir (o
/// `cache_layer` pedido no controle vale sempre). É o padrão do projeto (`auto_layers` do
/// `image_cache`); cada form pode trocar pela propriedade `layer_cache` ([`LayerCaching`]).
pub fn auto_layers() -> bool {
    AUTO_LAYERS.load(Ordering::Relaxed)
}

/// Veja [`auto_layers`]; o projeto faz isso ao abrir.
pub fn set_auto_layers(on: bool) {
    AUTO_LAYERS.store(on, Ordering::Relaxed);
}

/// A propriedade `layer_cache` do form: se as camadas automáticas valem nele.
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]
pub enum LayerCaching {
    /// O padrão do projeto ([`auto_layers`]).
    #[default]
    Project,
    On,
    Off,
}

impl LayerCaching {
    pub const ALL: [LayerCaching; 3] = [LayerCaching::Project, LayerCaching::On, LayerCaching::Off];

    /// Ligadas ou não, com o padrão do projeto no lugar de `Project`.
    pub fn enabled(self) -> bool {
        match self {
            LayerCaching::Project => auto_layers(),
            LayerCaching::On => true,
            LayerCaching::Off => false,
        }
    }
}

impl crate::prop::PropEnum for LayerCaching {
    const NAMES: &'static [&'static str] = &["project", "on", "off"];

    fn from_index(index: usize) -> Option<Self> {
        LayerCaching::ALL.get(index).copied()
    }

    fn index(self) -> usize {
        self as usize
    }
}

struct Layer<T> {
    owner: u64,
    value: T,
    bytes: usize,
    used: u64,
}

/// As camadas guardadas de um renderizador ([`Canvas::begin_cached`](crate::Canvas::begin_cached)),
/// pela chave completa (a do núcleo com o tamanho e a escala em pixels). Cada uma lembra a
/// chave que o núcleo passou (`owner`), para o núcleo soltar a de um controle quando ela deixa
/// de valer ([`forget`](Self::forget)). Passando de [`ImageCacheLimits::layers_mb`], sai a
/// usada há mais tempo; uma camada maior que o limite inteiro nem é montada
/// ([`accepts`](Self::accepts)).
pub struct LayerCache<T> {
    entries: HashMap<u64, Layer<T>>,
    clock: u64,
    bytes: usize,
    counters: Option<Arc<Counters>>,
}

impl<T> Default for LayerCache<T> {
    fn default() -> Self {
        Self { entries: HashMap::new(), clock: 0, bytes: 0, counters: None }
    }
}

impl<T> LayerCache<T> {
    /// Um cache que aparece no painel de memória ([`stats`]) com este nome.
    pub fn named(name: &'static str) -> Self {
        let counters = Arc::new(Counters { name, images: AtomicUsize::new(0), bytes: AtomicUsize::new(0) });
        REGISTRY.lock().unwrap_or_else(|e| e.into_inner()).push(Arc::downgrade(&counters));
        Self { counters: Some(counters), ..Self::default() }
    }

    fn publish(&self) {
        if let Some(c) = &self.counters {
            c.images.store(self.entries.len(), Ordering::Relaxed);
            c.bytes.store(self.bytes, Ordering::Relaxed);
        }
    }

    /// Se vale montar uma camada de `bytes`: com o limite em zero, ou menor que ela, não (quem
    /// chama desenha direto, sem a imagem fora da tela).
    pub fn accepts(bytes: usize) -> bool {
        bytes > 0 && bytes <= limits().layers_bytes()
    }

    /// A camada pela chave completa, marcada como usada agora. Se o limite baixou em execução
    /// (o `layers_mb` do `RenderSettings`), o excedente sai aqui, as usadas há mais tempo
    /// primeiro (a pedida também, se não couber: quem chama desenha de novo).
    pub fn get(&mut self, key: u64) -> Option<&T> {
        let max = limits().layers_bytes();
        if self.bytes > max {
            while self.bytes > max {
                let Some(oldest) = self.entries.iter().min_by_key(|(_, e)| e.used).map(|(k, _)| *k) else { break };
                if let Some(e) = self.entries.remove(&oldest) {
                    self.bytes -= e.bytes;
                }
            }
            self.publish();
        }
        self.clock += 1;
        let clock = self.clock;
        self.entries.get_mut(&key).map(|e| {
            e.used = clock;
            &e.value
        })
    }

    /// Guarda a camada; passando do limite, tira as usadas há mais tempo (nunca a que entrou).
    pub fn insert(&mut self, owner: u64, key: u64, value: T, bytes: usize) {
        let max = limits().layers_bytes();
        if bytes > max {
            return;
        }
        self.clock += 1;
        if let Some(old) = self.entries.insert(key, Layer { owner, value, bytes, used: self.clock }) {
            self.bytes -= old.bytes;
        }
        self.bytes += bytes;
        while self.bytes > max {
            let Some(oldest) = self.entries.iter().filter(|(k, _)| **k != key).min_by_key(|(_, e)| e.used).map(|(k, _)| *k) else { break };
            if let Some(e) = self.entries.remove(&oldest) {
                self.bytes -= e.bytes;
            }
        }
        self.publish();
    }

    /// Solta as camadas montadas com a chave `owner` do núcleo (a camada deixou de valer: a
    /// transição acabou, o desenho de dentro mudou).
    pub fn forget(&mut self, owner: u64) {
        let mut freed = 0;
        self.entries.retain(|_, e| {
            let keep = e.owner != owner;
            if !keep {
                freed += e.bytes;
            }
            keep
        });
        if freed > 0 {
            self.bytes -= freed;
            self.publish();
        }
    }

    pub fn clear(&mut self) {
        self.entries.clear();
        self.bytes = 0;
        self.publish();
    }

    pub fn len(&self) -> usize {
        self.entries.len()
    }

    pub fn is_empty(&self) -> bool {
        self.entries.is_empty()
    }

    /// A soma dos bytes guardados.
    pub fn bytes(&self) -> usize {
        self.bytes
    }
}

struct Entry<T> {
    image: WeakImage,
    value: T,
    bytes: usize,
    used: u64,
}

/// Quanto um cache com nome guarda agora, para o painel de memória ([`stats`]).
struct Counters {
    name: &'static str,
    images: AtomicUsize,
    bytes: AtomicUsize,
}

/// Os contadores dos caches com nome que existem (os que sumiram ficam mortos e saem).
static REGISTRY: Mutex<Vec<Weak<Counters>>> = Mutex::new(Vec::new());

/// Um cache no painel de memória: o nome, quantas imagens e quantos bytes guarda.
#[derive(Clone, Debug, PartialEq, Eq)]
pub struct CacheStat {
    pub name: &'static str,
    pub images: usize,
    pub bytes: usize,
}

/// O que cada cache com nome guarda agora (os de mesmo nome somados, como os de duas
/// janelas), na ordem em que apareceram. Para o painel de memória do app em depuração e o
/// Profiler da IDE.
pub fn stats() -> Vec<CacheStat> {
    let mut registry = REGISTRY.lock().unwrap_or_else(|e| e.into_inner());
    registry.retain(|w| w.strong_count() > 0);
    let mut out: Vec<CacheStat> = Vec::new();
    for c in registry.iter().filter_map(Weak::upgrade) {
        let (images, bytes) = (c.images.load(Ordering::Relaxed), c.bytes.load(Ordering::Relaxed));
        match out.iter_mut().find(|s| s.name == c.name) {
            Some(s) => {
                s.images += images;
                s.bytes += bytes;
            }
            None => out.push(CacheStat { name: c.name, images, bytes }),
        }
    }
    out
}

/// O que um renderizador fez de cada imagem, pelo [`Image::id`], com a imagem fraca ao lado.
pub struct ImageCache<T> {
    entries: HashMap<u64, Entry<T>>,
    clock: u64,
    bytes: usize,
    counters: Option<Arc<Counters>>,
}

impl<T> Default for ImageCache<T> {
    fn default() -> Self {
        Self { entries: HashMap::new(), clock: 0, bytes: 0, counters: None }
    }
}

impl<T> ImageCache<T> {
    /// Um cache que aparece no painel de memória ([`stats`]) com este nome ("Direct2D ·
    /// pixels na placa").
    pub fn named(name: &'static str) -> Self {
        let counters = Arc::new(Counters { name, images: AtomicUsize::new(0), bytes: AtomicUsize::new(0) });
        REGISTRY.lock().unwrap_or_else(|e| e.into_inner()).push(Arc::downgrade(&counters));
        Self { counters: Some(counters), ..Self::default() }
    }

    /// Atualiza os contadores do painel depois de uma mudança.
    fn publish(&self) {
        if let Some(c) = &self.counters {
            c.images.store(self.entries.len(), Ordering::Relaxed);
            c.bytes.store(self.bytes, Ordering::Relaxed);
        }
    }

    /// O valor guardado da imagem, marcado como usado agora.
    pub fn get(&mut self, image: &Image) -> Option<&T> {
        self.clock += 1;
        let clock = self.clock;
        self.entries.get_mut(&image.id()).map(|e| {
            e.used = clock;
            &e.value
        })
    }

    /// O valor pelo id, sem marcar uso (quem termina de carregar depois, como o navegador).
    pub fn get_by_id_mut(&mut self, id: u64) -> Option<&mut T> {
        self.entries.get_mut(&id).map(|e| &mut e.value)
    }

    /// Guarda o valor da imagem (`bytes`: quanto ocupa, para o limite em bytes). Antes, solta
    /// o das imagens mortas; depois, enquanto passar de `max_count` entradas ou `max_bytes`,
    /// tira a usada há mais tempo (nunca a que acabou de entrar).
    pub fn insert(&mut self, image: &Image, value: T, bytes: usize, max_count: usize, max_bytes: usize) {
        self.forget_dropped();
        self.clock += 1;
        if let Some(old) = self.entries.insert(image.id(), Entry { image: image.downgrade(), value, bytes, used: self.clock }) {
            self.bytes -= old.bytes;
        }
        self.bytes += bytes;
        while self.entries.len() > 1 && (self.entries.len() > max_count || self.bytes > max_bytes) {
            let Some(oldest) = self.entries.iter().filter(|(id, _)| **id != image.id()).min_by_key(|(_, e)| e.used).map(|(id, _)| *id) else { break };
            if let Some(e) = self.entries.remove(&oldest) {
                self.bytes -= e.bytes;
            }
        }
        self.publish();
    }

    /// Como [`forget_dropped`](Self::forget_dropped), devolvendo os valores das imagens
    /// soltas: o renderizador reaproveita o bitmap de um quadro de câmera no quadro seguinte.
    pub fn drain_dropped(&mut self) -> Vec<T> {
        let dead: Vec<u64> = self.entries.iter().filter(|(_, e)| !e.image.is_alive()).map(|(id, _)| *id).collect();
        let mut out = Vec::with_capacity(dead.len());
        for id in dead {
            if let Some(e) = self.entries.remove(&id) {
                self.bytes -= e.bytes;
                out.push(e.value);
            }
        }
        self.publish();
        out
    }

    /// Solta o que é de imagens que o app já soltou.
    pub fn forget_dropped(&mut self) {
        let mut freed = 0;
        self.entries.retain(|_, e| {
            let alive = e.image.is_alive();
            if !alive {
                freed += e.bytes;
            }
            alive
        });
        self.bytes -= freed;
        self.publish();
    }

    pub fn clear(&mut self) {
        self.entries.clear();
        self.bytes = 0;
        self.publish();
    }

    pub fn len(&self) -> usize {
        self.entries.len()
    }

    pub fn is_empty(&self) -> bool {
        self.entries.is_empty()
    }

    /// A soma dos `bytes` guardados.
    pub fn bytes(&self) -> usize {
        self.bytes
    }
}

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

    /// O quadro solto sai com o valor (o bitmap que o renderizador reaproveita), e o vivo fica.
    #[test]
    fn the_dropped_frames_come_back_with_their_values() {
        let mut cache: ImageCache<&str> = ImageCache::default();
        let alive = Image::bgra(2, 2, vec![0; 16]);
        let dropped = Image::bgra(2, 2, vec![1; 16]);
        cache.insert(&alive, "vivo", 16, usize::MAX, usize::MAX);
        cache.insert(&dropped, "solto", 16, usize::MAX, usize::MAX);
        drop(dropped);
        assert_eq!(cache.drain_dropped(), vec!["solto"]);
        assert_eq!((cache.len(), cache.bytes()), (1, 16));
        assert!(cache.drain_dropped().is_empty());
        assert_eq!(cache.get(&alive), Some(&"vivo"));
    }
}