aylis_core/gpu.rs
1//! Qual placa de vídeo usar quando a máquina tem mais de uma (a integrada e a dedicada de um
2//! notebook, ou duas placas num desktop). Vale para o processo inteiro: o Direct2D, o 3D e o
3//! OpenGL do Linux (pelo Mesa) leem a escolha ao abrir a GPU.
4//!
5//! O projeto guarda a escolha (`"gpu"` no `.aylisproj`); com os diagnósticos ligados (exemplos,
6//! testes e o app com `dev`), `AYLIS_GPU` troca na hora: `alto-desempenho`, `economia`, `monitor` ou parte do nome da placa (`AYLIS_GPU=radeon`).
7//!
8//! Cada form pode pedir outra (a propriedade `gpu` do `Form`; vazia: a do projeto). Com
9//! `monitor`, a janela desenha na placa ligada ao monitor em que está e troca de placa quando
10//! passa para um monitor da outra: sem isso, o Windows copia cada quadro de uma placa para a
11//! outra, e a janela trava (veja `docs/gpu-por-monitor.md`).
12
13use std::sync::{Mutex, OnceLock};
14
15use crate::ComponentId;
16
17#[derive(Clone, Debug, Default, PartialEq, Eq)]
18pub enum GpuChoice {
19 /// A que o sistema escolher (a padrão).
20 #[default]
21 Auto,
22 /// A mais rápida (a dedicada).
23 HighPerformance,
24 /// A que gasta menos energia (a integrada).
25 LowPower,
26 /// A placa do monitor em que a janela está, trocando quando ela muda de monitor (no
27 /// Windows e no Linux com Wayland; nas outras plataformas, a do sistema).
28 FollowMonitor,
29 /// A primeira cujo nome contém este texto (sem diferenciar maiúsculas).
30 Named(String),
31}
32
33impl GpuChoice {
34 /// Lê a escolha como o `.aylisproj` e o `AYLIS_GPU` gravam.
35 pub fn parse(text: &str) -> GpuChoice {
36 match text.trim().to_lowercase().as_str() {
37 "" | "auto" | "automatica" | "automática" => GpuChoice::Auto,
38 "alto-desempenho" | "high-performance" | "alto" | "high" => GpuChoice::HighPerformance,
39 "economia" | "low-power" | "baixo" | "low" => GpuChoice::LowPower,
40 "monitor" | "seguir-monitor" | "follow-monitor" => GpuChoice::FollowMonitor,
41 _ => GpuChoice::Named(text.trim().to_string()),
42 }
43 }
44
45 /// O texto que [`GpuChoice::parse`] lê de volta (vazio na automática).
46 pub fn to_text(&self) -> String {
47 match self {
48 GpuChoice::Auto => String::new(),
49 GpuChoice::HighPerformance => "alto-desempenho".into(),
50 GpuChoice::LowPower => "economia".into(),
51 GpuChoice::FollowMonitor => "monitor".into(),
52 GpuChoice::Named(name) => name.clone(),
53 }
54 }
55
56 /// Se a placa `adapter` é a pedida pelo nome.
57 pub fn matches_name(&self, adapter: &str) -> bool {
58 match self {
59 GpuChoice::Named(name) => adapter.to_lowercase().contains(&name.to_lowercase()),
60 _ => false,
61 }
62 }
63}
64
65/// Como o quadro desenhado chega à janela (no Windows, com o Direct2D): o `"present"` do
66/// `.aylisproj` e a propriedade `present` do form ([`present_for`]).
67#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]
68pub enum PresentMode {
69 /// A swap chain ligada à janela, como nos jogos: em tela cheia o quadro vai direto ao
70 /// monitor (a menor latência) e pode trocar sem esperar o monitor (tearing). O padrão.
71 #[default]
72 Window,
73 /// DirectComposition: o quadro vai para uma camada que o compositor do Windows (DWM)
74 /// junta à janela, como nos navegadores (sempre composto, sem tearing). Não tira o aviso
75 /// do Radeon Software em tela cheia (conferido em 04/11/2026). O DWM ainda pode promover a
76 /// camada a um plano de overlay (MPO).
77 Composition,
78 /// Sempre composta pelo DWM: a swap chain no modelo de cópia (*blit*), que nunca vai a um
79 /// plano de overlay (MPO) nem a *independent flip*, que são só do modelo *flip*. Para forms
80 /// em tela cheia que ficam por cima do resto (seleção de área, print, overlay): numa placa
81 /// AMD com MPO, o cursor desenhado no plano de overlay congelava sobre um form assim
82 /// (relatado pelo NoOBS em 15/11). Custa uma cópia a mais por quadro e não tem tearing.
83 Composed,
84 /// A composição (como `Composition`) com o alfa por pixel: a janela deixa ver o que está
85 /// atrás onde o quadro não é opaco. Vem do form transparente ou com forma
86 /// (`transparent`, `window_shape`), não do projeto.
87 Transparent,
88}
89
90impl PresentMode {
91 /// Lê como o `.aylisproj` e o `AYLIS_PRESENT` gravam (vazio ou desconhecido: o padrão).
92 pub fn parse(text: &str) -> PresentMode {
93 match text.trim().to_lowercase().as_str() {
94 "composition" | "composicao" | "composição" => PresentMode::Composition,
95 "composed" | "composto" => PresentMode::Composed,
96 "transparent" | "transparente" => PresentMode::Transparent,
97 _ => PresentMode::Window,
98 }
99 }
100
101 /// O texto que [`PresentMode::parse`] lê de volta (vazio no padrão).
102 pub fn name(self) -> &'static str {
103 match self {
104 PresentMode::Window => "",
105 PresentMode::Composition => "composition",
106 PresentMode::Composed => "composed",
107 PresentMode::Transparent => "transparent",
108 }
109 }
110}
111
112static PRESENT: std::sync::atomic::AtomicU8 = std::sync::atomic::AtomicU8::new(0);
113
114/// Grava o modo de apresentar (a plataforma faz isso ao abrir, com o do projeto).
115pub fn set_present(mode: PresentMode) {
116 let code = match mode {
117 PresentMode::Window => 0,
118 PresentMode::Composition => 1,
119 PresentMode::Composed => 2,
120 PresentMode::Transparent => 3,
121 };
122 PRESENT.store(code, std::sync::atomic::Ordering::Relaxed);
123}
124
125/// O modo de apresentar do projeto.
126pub fn present() -> PresentMode {
127 match PRESENT.load(std::sync::atomic::Ordering::Relaxed) {
128 1 => PresentMode::Composition,
129 2 => PresentMode::Composed,
130 3 => PresentMode::Transparent,
131 _ => PresentMode::Window,
132 }
133}
134
135/// O modo de apresentar de um form: a propriedade `present` dele ou, vazia, o do projeto.
136pub fn present_for(form_text: &str) -> PresentMode {
137 if form_text.trim().is_empty() || form_text.trim() == "project" { present() } else { PresentMode::parse(form_text) }
138}
139
140/// O `present` de um form: o do projeto ou um dos modos (`PresentMode` sem o `transparent`,
141/// que vem do form transparente).
142#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]
143pub enum FormPresent {
144 #[default]
145 Project,
146 Window,
147 Composition,
148 Composed,
149}
150
151impl crate::PropEnum for FormPresent {
152 const NAMES: &'static [&'static str] = &["project", "window", "composition", "composed"];
153 fn from_index(index: usize) -> Option<Self> {
154 [Self::Project, Self::Window, Self::Composition, Self::Composed].get(index).copied()
155 }
156 fn index(self) -> usize {
157 self as usize
158 }
159 /// Vazio é o do projeto (o padrão de antes, quando era texto).
160 fn from_name(name: &str) -> Option<Self> {
161 if name.trim().is_empty() {
162 return Some(Self::Project);
163 }
164 Self::NAMES.iter().position(|n| n.eq_ignore_ascii_case(name.trim())).and_then(Self::from_index)
165 }
166}
167
168static CHOICE: Mutex<GpuChoice> = Mutex::new(GpuChoice::Auto);
169
170/// Grava a escolha (a plataforma faz isso ao abrir, com a do projeto).
171pub fn set_choice(choice: GpuChoice) {
172 if let Ok(mut c) = CHOICE.lock() {
173 *c = choice;
174 }
175}
176
177/// A escolha em vigor (a do projeto; com os diagnósticos, a plataforma aceita `AYLIS_GPU`).
178pub fn choice() -> GpuChoice {
179 CHOICE.lock().map(|c| c.clone()).unwrap_or_default()
180}
181
182/// A escolha de um form: a propriedade `gpu` dele (`form_text`) ou, vazia, a do projeto.
183pub fn choice_for(form_text: &str) -> GpuChoice {
184 if form_text.trim().is_empty() { choice() } else { GpuChoice::parse(form_text) }
185}
186
187/// Quem lista as placas (a plataforma põe ao abrir) e a lista, perguntada só na primeira vez
188/// que alguém pede: as placas não mudam com o app aberto.
189static ADAPTER_LIST: OnceLock<fn() -> Vec<String>> = OnceLock::new();
190static ADAPTERS: OnceLock<Vec<String>> = OnceLock::new();
191
192/// A plataforma diz como listar as placas de vídeo (no Windows, pelo DXGI).
193pub fn set_adapter_list(list: fn() -> Vec<String>) {
194 let _ = ADAPTER_LIST.set(list);
195}
196
197/// As placas de vídeo da máquina, pelo nome (vazio onde não se sabe).
198pub fn adapters() -> &'static [String] {
199 ADAPTERS.get_or_init(|| ADAPTER_LIST.get().map(|list| list()).unwrap_or_default())
200}
201
202impl crate::Ui {
203
204 /// A placa em que a janela do form desenha agora (`None`: não se sabe, como na CPU).
205 pub fn form_gpu(&self, form: ComponentId) -> Option<&str> {
206 self.form_gpus.get(&self.root_of(form)).map(String::as_str)
207 }
208
209 /// A plataforma informa a placa da janela do form. Se mudou (não na primeira vez), dispara
210 /// o `on_gpu_change` do form com o nome da placa nova.
211 pub fn set_form_gpu(&mut self, form: ComponentId, adapter: Option<String>) {
212 let old = match adapter.clone() {
213 Some(a) => self.form_gpus.insert(form, a),
214 None => self.form_gpus.remove(&form),
215 };
216 if let (Some(old), Some(new)) = (old, adapter)
217 && old != new
218 {
219 self.fire(form, "on_gpu_change", &crate::EventArgs::Text(new));
220 }
221 }
222}
223
224thread_local! {
225 static BEFORE_FLUSH: std::cell::RefCell<Vec<Box<dyn FnOnce()>>> = const { std::cell::RefCell::new(Vec::new()) };
226}
227
228/// Pede que `f` rode no fim do quadro, logo antes de o canvas na GPU executar o que gravou
229/// (o `flush` do Skia): quem desenha por fora no mesmo contexto (o 3D) grava os comandos de
230/// todos os seus controles durante a pintura e envia tudo de uma vez ali, em vez de um envio
231/// por controle. Roda uma vez; peça de novo no quadro seguinte.
232pub fn before_flush(f: impl FnOnce() + 'static) {
233 let _ = BEFORE_FLUSH.try_with(|list| list.borrow_mut().push(Box::new(f)));
234}
235
236/// Roda o que foi pedido por [`before_flush`] (o canvas chama antes do flush). `true` se algo
237/// rodou: o estado da GPU mudou e o canvas precisa refazer o dele.
238pub fn run_before_flush() -> bool {
239 let pending = BEFORE_FLUSH.try_with(|list| std::mem::take(&mut *list.borrow_mut())).unwrap_or_default();
240 let ran = !pending.is_empty();
241 for f in pending {
242 f();
243 }
244 ran
245}