Skip to main content

sui_render_wgpu/
renderer.rs

1use crate::WgpuRenderer;
2use crate::device::default_wgpu_instance;
3use crate::diagnostics::RendererFrameStats;
4use crate::interop::WgpuExternalTextureRegistry;
5use crate::output::ColorManagementMode;
6use crate::output::DisplayCapabilities;
7use crate::output::OutputStrategy;
8use crate::output::RendererCapabilities;
9use crate::resources::FrameResources;
10use crate::surface::normalize_framebuffer_size;
11use crate::text::RendererTextCacheSnapshot;
12use crate::text_engine::TextEngine;
13use crate::text_policy::FeatheringOptions;
14use crate::text_policy::StemDarkening;
15use crate::text_policy::TextCoveragePolicy;
16use crate::text_policy::TextHinting;
17use crate::text_policy::TextRenderMode;
18use std::collections::HashMap;
19use std::fmt;
20use sui_core::Result;
21use sui_core::WindowId;
22use sui_scene::SceneFrame;
23pub use sui_scene::TextSubpixelOrder;
24
25impl WgpuRenderer {
26    pub fn new() -> Self {
27        Self::default()
28    }
29
30    pub fn with_feathering(mut self, feathering: FeatheringOptions) -> Self {
31        self.set_feathering(feathering);
32        self
33    }
34
35    pub fn with_feathering_enabled(mut self, enabled: bool) -> Self {
36        self.set_feathering_enabled(enabled);
37        self
38    }
39
40    pub fn with_text_coverage_policy(mut self, policy: TextCoveragePolicy) -> Self {
41        self.set_text_coverage_policy(policy);
42        self
43    }
44
45    pub fn with_text_render_mode(mut self, mode: TextRenderMode) -> Self {
46        self.set_text_render_mode(mode);
47        self
48    }
49
50    pub fn with_text_subpixel_order(mut self, order: TextSubpixelOrder) -> Self {
51        self.set_text_subpixel_order(order);
52        self
53    }
54
55    pub fn with_text_hinting(mut self, hinting: TextHinting) -> Self {
56        self.set_text_hinting(hinting);
57        self
58    }
59
60    pub fn with_stem_darkening(mut self, darkening: StemDarkening) -> Self {
61        self.set_stem_darkening(darkening);
62        self
63    }
64
65    pub fn with_feather_width(mut self, feather_width: f32) -> Self {
66        self.set_feather_width(feather_width);
67        self
68    }
69
70    pub fn with_vsync_enabled(mut self, enabled: bool) -> Self {
71        self.set_vsync_enabled(enabled);
72        self
73    }
74
75    pub fn with_external_texture_registry(mut self, registry: WgpuExternalTextureRegistry) -> Self {
76        self.set_external_texture_registry(registry);
77        self
78    }
79
80    pub fn feathering(&self) -> FeatheringOptions {
81        FeatheringOptions::new(self.feathering_enabled, self.feather_width)
82    }
83
84    pub fn feathering_enabled(&self) -> bool {
85        self.feathering_enabled
86    }
87
88    pub fn feather_width(&self) -> f32 {
89        self.feather_width
90    }
91
92    pub fn vsync_enabled(&self) -> bool {
93        self.vsync_enabled
94    }
95
96    pub fn external_texture_registry(&self) -> Option<&WgpuExternalTextureRegistry> {
97        self.external_texture_registry.as_ref()
98    }
99
100    pub fn set_external_texture_registry(&mut self, registry: WgpuExternalTextureRegistry) {
101        if let Some(shared) = &self.shared {
102            registry.attach(
103                shared.device.clone(),
104                shared.queue.clone(),
105                shared.adapter.get_info(),
106            );
107        }
108        self.external_texture_registry = Some(registry);
109        self.external_image_cache.clear();
110    }
111
112    pub fn text_coverage_policy(&self) -> TextCoveragePolicy {
113        self.text_coverage_policy
114    }
115
116    pub fn text_render_mode(&self) -> TextRenderMode {
117        self.text_render_mode
118    }
119
120    pub fn text_subpixel_order(&self) -> TextSubpixelOrder {
121        self.text_subpixel_order
122    }
123
124    pub fn text_hinting(&self) -> TextHinting {
125        self.text_hinting
126    }
127
128    pub fn stem_darkening(&self) -> StemDarkening {
129        self.stem_darkening
130    }
131
132    pub fn set_feathering(&mut self, feathering: FeatheringOptions) {
133        let feathering = feathering.clamped();
134        self.feathering_enabled = feathering.enabled;
135        self.feather_width = feathering.width;
136    }
137
138    pub fn set_feathering_enabled(&mut self, enabled: bool) {
139        self.feathering_enabled = enabled;
140    }
141
142    pub fn set_text_coverage_policy(&mut self, policy: TextCoveragePolicy) {
143        let policy = policy.normalized();
144        if self.text_coverage_policy == policy {
145            return;
146        }
147
148        self.text_coverage_policy = policy;
149        if let Some(text_engine) = self.text_engine.as_mut() {
150            text_engine.set_text_coverage_policy(policy);
151        }
152        self.invalidate_text_render_state();
153    }
154
155    pub fn set_text_render_mode(&mut self, mode: TextRenderMode) {
156        if self.text_render_mode == mode {
157            return;
158        }
159
160        self.text_render_mode = mode;
161        if let Some(text_engine) = self.text_engine.as_mut() {
162            text_engine.set_text_render_mode(mode);
163        }
164        self.invalidate_text_render_state();
165    }
166
167    pub fn set_text_subpixel_order(&mut self, order: TextSubpixelOrder) {
168        if self.text_subpixel_order == order {
169            return;
170        }
171
172        self.text_subpixel_order = order;
173        if let Some(text_engine) = self.text_engine.as_mut() {
174            text_engine.set_text_subpixel_order(order);
175        }
176        self.invalidate_text_render_state();
177    }
178
179    pub fn set_text_hinting(&mut self, hinting: TextHinting) {
180        let hinting = hinting.normalized();
181        if self.text_hinting == hinting {
182            return;
183        }
184
185        self.text_hinting = hinting;
186        if let Some(text_engine) = self.text_engine.as_mut() {
187            text_engine.set_text_hinting(hinting);
188        }
189    }
190
191    pub fn set_stem_darkening(&mut self, darkening: StemDarkening) {
192        let darkening = darkening.normalized();
193        if self.stem_darkening == darkening {
194            return;
195        }
196
197        self.stem_darkening = darkening;
198        if let Some(text_engine) = self.text_engine.as_mut() {
199            text_engine.set_stem_darkening(darkening);
200        }
201    }
202
203    pub fn set_feather_width(&mut self, feather_width: f32) {
204        self.feather_width = feather_width.max(0.0);
205    }
206
207    pub fn set_vsync_enabled(&mut self, enabled: bool) {
208        self.vsync_enabled = enabled;
209    }
210
211    pub fn set_window_display_capabilities(
212        &mut self,
213        window_id: WindowId,
214        capabilities: DisplayCapabilities,
215    ) -> Result<()> {
216        let Some(surface) = self.surfaces.get_mut(&window_id) else {
217            // Offscreen windows render as if presenting to this display.
218            self.offscreen_outputs
219                .entry(window_id)
220                .or_default()
221                .display_capabilities = capabilities;
222            return Ok(());
223        };
224        if surface.display_capabilities == capabilities {
225            return Ok(());
226        }
227        surface.display_capabilities = capabilities;
228        self.configure_existing_surface(window_id)
229    }
230
231    pub fn window_display_capabilities(&self, window_id: WindowId) -> Option<DisplayCapabilities> {
232        self.surfaces
233            .get(&window_id)
234            .map(|surface| surface.display_capabilities.clone())
235            .or_else(|| {
236                self.offscreen_outputs
237                    .get(&window_id)
238                    .map(|output| output.display_capabilities.clone())
239            })
240    }
241
242    pub fn set_window_color_management(
243        &mut self,
244        window_id: WindowId,
245        color_management: ColorManagementMode,
246    ) -> Result<()> {
247        let Some(surface) = self.surfaces.get_mut(&window_id) else {
248            // Offscreen windows fit and capture with it too.
249            self.offscreen_outputs
250                .entry(window_id)
251                .or_default()
252                .color_management = color_management;
253            return Ok(());
254        };
255        if surface.color_management == color_management {
256            return Ok(());
257        }
258        surface.color_management = color_management;
259        self.configure_existing_surface(window_id)
260    }
261
262    /// The color management `window_id` renders with.
263    pub fn window_color_management(&self, window_id: WindowId) -> ColorManagementMode {
264        self.surfaces
265            .get(&window_id)
266            .map(|surface| surface.color_management)
267            .or_else(|| {
268                self.offscreen_outputs
269                    .get(&window_id)
270                    .map(|output| output.color_management)
271            })
272            .unwrap_or_default()
273    }
274
275    /// The strategy `window_id` presents with. A window without a surface
276    /// reports the strategy it would use on the display it was given.
277    pub fn window_output_strategy(&self, window_id: WindowId) -> Option<OutputStrategy> {
278        self.surfaces
279            .get(&window_id)
280            .map(|surface| surface.output_strategy)
281            .or_else(|| {
282                self.offscreen_outputs
283                    .get(&window_id)
284                    .map(crate::output::OffscreenOutput::output_strategy)
285            })
286    }
287
288    pub fn window_surface_formats(&self, window_id: WindowId) -> Option<Vec<wgpu::TextureFormat>> {
289        self.surfaces
290            .get(&window_id)
291            .map(|surface| surface.available_surface_formats.clone())
292    }
293
294    pub fn set_runtime_feathering_override(&mut self, feathering: Option<FeatheringOptions>) {
295        self.runtime_feathering_override = feathering.map(FeatheringOptions::clamped);
296    }
297
298    pub fn set_runtime_text_subpixel_order_override(&mut self, order: Option<TextSubpixelOrder>) {
299        self.runtime_text_subpixel_order_override = order;
300    }
301
302    pub fn set_runtime_text_hinting_override(&mut self, hinting: Option<TextHinting>) {
303        self.runtime_text_hinting_override = hinting.map(TextHinting::normalized);
304    }
305
306    pub fn set_runtime_stem_darkening_override(&mut self, darkening: Option<StemDarkening>) {
307        self.runtime_stem_darkening_override = darkening.map(StemDarkening::normalized);
308    }
309
310    pub fn set_runtime_text_coverage_policy_override(
311        &mut self,
312        policy: Option<TextCoveragePolicy>,
313    ) {
314        self.runtime_text_coverage_policy_override = policy.map(TextCoveragePolicy::normalized);
315    }
316
317    pub fn set_runtime_diagnostics_enabled(&mut self, enabled: bool) {
318        self.runtime_diagnostics_enabled = enabled;
319        if let Some(shared) = &mut self.shared {
320            shared.collect_pipeline_timings = enabled;
321        }
322        if let Some(text_engine) = self.text_engine.as_mut() {
323            text_engine.set_diagnostics_enabled(enabled);
324        }
325        for compositor in self.compositors.values_mut() {
326            compositor.set_diagnostics_enabled(enabled);
327        }
328    }
329
330    pub(crate) fn active_feather_width(&self) -> f32 {
331        self.runtime_feathering_override
332            .unwrap_or_else(|| self.feathering())
333            .effective_width()
334    }
335
336    pub(crate) fn active_text_hinting(&self) -> TextHinting {
337        self.runtime_text_hinting_override
338            .unwrap_or(self.text_hinting)
339            .normalized()
340    }
341
342    pub(crate) fn active_text_subpixel_order(&self) -> TextSubpixelOrder {
343        self.runtime_text_subpixel_order_override
344            .unwrap_or(self.text_subpixel_order)
345    }
346
347    pub(crate) fn active_stem_darkening(&self) -> StemDarkening {
348        self.runtime_stem_darkening_override
349            .unwrap_or(self.stem_darkening)
350            .normalized()
351    }
352
353    pub(crate) fn active_text_coverage_policy(&self) -> TextCoveragePolicy {
354        self.runtime_text_coverage_policy_override
355            .unwrap_or(self.text_coverage_policy)
356            .normalized()
357    }
358
359    pub(crate) fn invalidate_text_render_state(&mut self) {
360        self.text_engine = None;
361        self.text_atlas_array = None;
362        self.compositors.clear();
363        self.last_frames.clear();
364        self.last_frame_stats.clear();
365    }
366
367    pub fn remove_window(&mut self, window_id: WindowId) {
368        self.prepared_surfaces.remove(&window_id);
369        #[cfg(any(target_os = "linux", target_os = "windows", target_os = "macos"))]
370        if self
371            .device_preparation
372            .as_ref()
373            .is_some_and(|pending| pending.window == Some(window_id))
374        {
375            self.device_preparation = None;
376        }
377        self.frame_resources.fragments.remove(&window_id);
378        self.frame_resources.output_transforms.remove(&window_id);
379        self.surfaces.remove(&window_id);
380        self.offscreen_outputs.remove(&window_id);
381        self.offscreen_targets.remove(&window_id);
382        self.intermediate_targets.remove(&window_id);
383        self.last_frames.remove(&window_id);
384        self.last_frame_stats.remove(&window_id);
385        self.compositors.remove(&window_id);
386        self.debug_captures_in_flight
387            .retain(|capture| capture.window_id != window_id);
388    }
389
390    pub fn render(&mut self, frame: &SceneFrame) -> Result<()> {
391        let pipeline_before = self.shared.as_ref().map_or((0, 0), |shared| {
392            (shared.pipeline_create_time_us, shared.pipeline_create_count)
393        });
394        let viewport = normalize_framebuffer_size(frame.surface_size);
395        let mut frame_stats = RendererFrameStats::default();
396
397        if let Some(size) = viewport {
398            if self.surfaces.contains_key(&frame.window_id) {
399                frame_stats = self.render_surface(frame, size)?;
400            } else {
401                frame_stats = self.render_offscreen(frame, size)?;
402            }
403        }
404
405        frame_stats.device_prepare_time_us =
406            std::mem::take(&mut self.pending_device_prepare_time_us);
407        frame_stats.device_prepare_wait_time_us =
408            std::mem::take(&mut self.pending_device_wait_time_us);
409        if let Some(shared) = &self.shared {
410            frame_stats.pipeline_create_time_us =
411                shared.pipeline_create_time_us - pipeline_before.0;
412            frame_stats.pipeline_create_count = shared.pipeline_create_count - pipeline_before.1;
413        }
414        self.frames_rendered += 1;
415        self.last_frames.insert(frame.window_id, frame.clone());
416        self.last_frame_stats.insert(frame.window_id, frame_stats);
417        self.analytic_path_cache
418            .retain(|_, entry| self.frames_rendered.saturating_sub(entry.last_used_frame) <= 120);
419        self.image_cache
420            .retain(|_, entry| self.frames_rendered.saturating_sub(entry.last_used_frame) <= 120);
421        Ok(())
422    }
423
424    pub fn capabilities(&self) -> RendererCapabilities {
425        self.capabilities
426    }
427
428    /// Adapter metadata after initialization, without requiring an interop registry.
429    pub fn adapter_info(&self) -> Option<wgpu::AdapterInfo> {
430        self.shared.as_ref().map(|shared| shared.adapter.get_info())
431    }
432
433    pub fn frames_rendered(&self) -> usize {
434        self.frames_rendered
435    }
436
437    pub fn last_frame(&self, window_id: WindowId) -> Option<&SceneFrame> {
438        self.last_frames.get(&window_id)
439    }
440
441    pub fn last_frame_stats(&self, window_id: WindowId) -> Option<RendererFrameStats> {
442        self.last_frame_stats.get(&window_id).cloned()
443    }
444
445    pub fn text_cache_snapshot(&self, window_id: WindowId) -> RendererTextCacheSnapshot {
446        let mut snapshot = self
447            .text_engine
448            .as_ref()
449            .map(TextEngine::cache_snapshot)
450            .unwrap_or_default();
451        snapshot.path = self
452            .compositors
453            .get(&window_id)
454            .map(|compositor| compositor.path_cache.snapshot())
455            .unwrap_or_default();
456        snapshot
457    }
458}
459
460impl Default for WgpuRenderer {
461    fn default() -> Self {
462        Self {
463            instance: default_wgpu_instance(),
464            feathering_enabled: FeatheringOptions::default().enabled,
465            feather_width: FeatheringOptions::default().width,
466            text_render_mode: TextRenderMode::default(),
467            text_subpixel_order: TextSubpixelOrder::default(),
468            text_hinting: TextHinting::default(),
469            stem_darkening: StemDarkening::default(),
470            text_coverage_policy: TextCoveragePolicy::default(),
471            vsync_enabled: true,
472            runtime_feathering_override: None,
473            runtime_text_subpixel_order_override: None,
474            runtime_text_hinting_override: None,
475            runtime_stem_darkening_override: None,
476            runtime_text_coverage_policy_override: None,
477            runtime_diagnostics_enabled: true,
478            pending_device_prepare_time_us: 0,
479            pending_device_wait_time_us: 0,
480            #[cfg(any(target_os = "linux", target_os = "windows", target_os = "macos"))]
481            device_preparation: None,
482            prepared_surfaces: HashMap::new(),
483            frames_rendered: 0,
484            capabilities: RendererCapabilities::default(),
485            last_frames: HashMap::new(),
486            last_frame_stats: HashMap::new(),
487            shared: None,
488            text_engine: None,
489            image_cache: HashMap::new(),
490            external_texture_registry: None,
491            external_image_cache: HashMap::new(),
492            text_atlas_array: None,
493            analytic_path_cache: HashMap::new(),
494            compositors: HashMap::new(),
495            surfaces: HashMap::new(),
496            offscreen_targets: HashMap::new(),
497            intermediate_targets: HashMap::new(),
498            offscreen_outputs: HashMap::new(),
499            frame_resources: FrameResources::default(),
500            debug_captures_in_flight: Vec::new(),
501            next_debug_capture_id: 1,
502        }
503    }
504}
505
506impl fmt::Debug for WgpuRenderer {
507    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
508        f.debug_struct("WgpuRenderer")
509            .field("feathering_enabled", &self.feathering_enabled)
510            .field("feather_width", &self.feather_width)
511            .field("text_coverage_policy", &self.text_coverage_policy)
512            .field("frames_rendered", &self.frames_rendered)
513            .field("capabilities", &self.capabilities)
514            .field("last_frame_count", &self.last_frames.len())
515            .field("last_frame_stats_count", &self.last_frame_stats.len())
516            .field("has_device", &self.shared.is_some())
517            .field("surface_count", &self.surfaces.len())
518            .finish()
519    }
520}