Skip to main content

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}