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        if let Some(surface) = self.surfaces.get_mut(&window_id) {
217            if surface.display_capabilities == capabilities {
218                return Ok(());
219            }
220            surface.display_capabilities = capabilities;
221        }
222        self.configure_existing_surface(window_id)
223    }
224
225    pub fn window_display_capabilities(&self, window_id: WindowId) -> Option<DisplayCapabilities> {
226        self.surfaces
227            .get(&window_id)
228            .map(|surface| surface.display_capabilities.clone())
229    }
230
231    pub fn set_window_color_management(
232        &mut self,
233        window_id: WindowId,
234        color_management: ColorManagementMode,
235    ) -> Result<()> {
236        if let Some(surface) = self.surfaces.get_mut(&window_id) {
237            if surface.color_management == color_management {
238                return Ok(());
239            }
240            surface.color_management = color_management;
241        }
242        self.configure_existing_surface(window_id)
243    }
244
245    pub fn window_output_strategy(&self, window_id: WindowId) -> Option<OutputStrategy> {
246        self.surfaces
247            .get(&window_id)
248            .map(|surface| surface.output_strategy)
249    }
250
251    pub fn window_surface_formats(&self, window_id: WindowId) -> Option<Vec<wgpu::TextureFormat>> {
252        self.surfaces
253            .get(&window_id)
254            .map(|surface| surface.available_surface_formats.clone())
255    }
256
257    pub fn set_runtime_feathering_override(&mut self, feathering: Option<FeatheringOptions>) {
258        self.runtime_feathering_override = feathering.map(FeatheringOptions::clamped);
259    }
260
261    pub fn set_runtime_text_subpixel_order_override(&mut self, order: Option<TextSubpixelOrder>) {
262        self.runtime_text_subpixel_order_override = order;
263    }
264
265    pub fn set_runtime_text_hinting_override(&mut self, hinting: Option<TextHinting>) {
266        self.runtime_text_hinting_override = hinting.map(TextHinting::normalized);
267    }
268
269    pub fn set_runtime_stem_darkening_override(&mut self, darkening: Option<StemDarkening>) {
270        self.runtime_stem_darkening_override = darkening.map(StemDarkening::normalized);
271    }
272
273    pub fn set_runtime_text_coverage_policy_override(
274        &mut self,
275        policy: Option<TextCoveragePolicy>,
276    ) {
277        self.runtime_text_coverage_policy_override = policy.map(TextCoveragePolicy::normalized);
278    }
279
280    pub fn set_runtime_diagnostics_enabled(&mut self, enabled: bool) {
281        self.runtime_diagnostics_enabled = enabled;
282        if let Some(shared) = &mut self.shared {
283            shared.collect_pipeline_timings = enabled;
284        }
285        if let Some(text_engine) = self.text_engine.as_mut() {
286            text_engine.set_diagnostics_enabled(enabled);
287        }
288        for compositor in self.compositors.values_mut() {
289            compositor.set_diagnostics_enabled(enabled);
290        }
291    }
292
293    pub(crate) fn active_feather_width(&self) -> f32 {
294        self.runtime_feathering_override
295            .unwrap_or_else(|| self.feathering())
296            .effective_width()
297    }
298
299    pub(crate) fn active_text_hinting(&self) -> TextHinting {
300        self.runtime_text_hinting_override
301            .unwrap_or(self.text_hinting)
302            .normalized()
303    }
304
305    pub(crate) fn active_text_subpixel_order(&self) -> TextSubpixelOrder {
306        self.runtime_text_subpixel_order_override
307            .unwrap_or(self.text_subpixel_order)
308    }
309
310    pub(crate) fn active_stem_darkening(&self) -> StemDarkening {
311        self.runtime_stem_darkening_override
312            .unwrap_or(self.stem_darkening)
313            .normalized()
314    }
315
316    pub(crate) fn active_text_coverage_policy(&self) -> TextCoveragePolicy {
317        self.runtime_text_coverage_policy_override
318            .unwrap_or(self.text_coverage_policy)
319            .normalized()
320    }
321
322    pub(crate) fn invalidate_text_render_state(&mut self) {
323        self.text_engine = None;
324        self.text_atlas_array = None;
325        self.compositors.clear();
326        self.last_frames.clear();
327        self.last_frame_stats.clear();
328    }
329
330    pub fn remove_window(&mut self, window_id: WindowId) {
331        self.prepared_surfaces.remove(&window_id);
332        #[cfg(any(target_os = "linux", target_os = "windows", target_os = "macos"))]
333        if self
334            .device_preparation
335            .as_ref()
336            .is_some_and(|pending| pending.window == Some(window_id))
337        {
338            self.device_preparation = None;
339        }
340        self.frame_resources.fragments.remove(&window_id);
341        self.frame_resources.output_transforms.remove(&window_id);
342        self.surfaces.remove(&window_id);
343        self.offscreen_targets.remove(&window_id);
344        self.intermediate_targets.remove(&window_id);
345        self.last_frames.remove(&window_id);
346        self.last_frame_stats.remove(&window_id);
347        self.compositors.remove(&window_id);
348    }
349
350    pub fn render(&mut self, frame: &SceneFrame) -> Result<()> {
351        let pipeline_before = self.shared.as_ref().map_or((0, 0), |shared| {
352            (shared.pipeline_create_time_us, shared.pipeline_create_count)
353        });
354        let viewport = normalize_framebuffer_size(frame.surface_size);
355        let mut frame_stats = RendererFrameStats::default();
356
357        if let Some(size) = viewport {
358            if self.surfaces.contains_key(&frame.window_id) {
359                frame_stats = self.render_surface(frame, size)?;
360            } else {
361                frame_stats = self.render_offscreen(frame, size)?;
362            }
363        }
364
365        frame_stats.device_prepare_time_us =
366            std::mem::take(&mut self.pending_device_prepare_time_us);
367        frame_stats.device_prepare_wait_time_us =
368            std::mem::take(&mut self.pending_device_wait_time_us);
369        if let Some(shared) = &self.shared {
370            frame_stats.pipeline_create_time_us =
371                shared.pipeline_create_time_us - pipeline_before.0;
372            frame_stats.pipeline_create_count = shared.pipeline_create_count - pipeline_before.1;
373        }
374        self.frames_rendered += 1;
375        self.last_frames.insert(frame.window_id, frame.clone());
376        self.last_frame_stats.insert(frame.window_id, frame_stats);
377        self.analytic_path_cache
378            .retain(|_, entry| self.frames_rendered.saturating_sub(entry.last_used_frame) <= 120);
379        self.image_cache
380            .retain(|_, entry| self.frames_rendered.saturating_sub(entry.last_used_frame) <= 120);
381        Ok(())
382    }
383
384    pub fn capabilities(&self) -> RendererCapabilities {
385        self.capabilities
386    }
387
388    /// Adapter metadata after initialization, without requiring an interop registry.
389    pub fn adapter_info(&self) -> Option<wgpu::AdapterInfo> {
390        self.shared.as_ref().map(|shared| shared.adapter.get_info())
391    }
392
393    pub fn frames_rendered(&self) -> usize {
394        self.frames_rendered
395    }
396
397    pub fn last_frame(&self, window_id: WindowId) -> Option<&SceneFrame> {
398        self.last_frames.get(&window_id)
399    }
400
401    pub fn last_frame_stats(&self, window_id: WindowId) -> Option<RendererFrameStats> {
402        self.last_frame_stats.get(&window_id).cloned()
403    }
404
405    pub fn text_cache_snapshot(&self, window_id: WindowId) -> RendererTextCacheSnapshot {
406        let mut snapshot = self
407            .text_engine
408            .as_ref()
409            .map(TextEngine::cache_snapshot)
410            .unwrap_or_default();
411        snapshot.path = self
412            .compositors
413            .get(&window_id)
414            .map(|compositor| compositor.path_cache.snapshot())
415            .unwrap_or_default();
416        snapshot
417    }
418}
419
420impl Default for WgpuRenderer {
421    fn default() -> Self {
422        Self {
423            instance: default_wgpu_instance(),
424            feathering_enabled: FeatheringOptions::default().enabled,
425            feather_width: FeatheringOptions::default().width,
426            text_render_mode: TextRenderMode::default(),
427            text_subpixel_order: TextSubpixelOrder::default(),
428            text_hinting: TextHinting::default(),
429            stem_darkening: StemDarkening::default(),
430            text_coverage_policy: TextCoveragePolicy::default(),
431            vsync_enabled: true,
432            runtime_feathering_override: None,
433            runtime_text_subpixel_order_override: None,
434            runtime_text_hinting_override: None,
435            runtime_stem_darkening_override: None,
436            runtime_text_coverage_policy_override: None,
437            runtime_diagnostics_enabled: true,
438            pending_device_prepare_time_us: 0,
439            pending_device_wait_time_us: 0,
440            #[cfg(any(target_os = "linux", target_os = "windows", target_os = "macos"))]
441            device_preparation: None,
442            prepared_surfaces: HashMap::new(),
443            frames_rendered: 0,
444            capabilities: RendererCapabilities::default(),
445            last_frames: HashMap::new(),
446            last_frame_stats: HashMap::new(),
447            shared: None,
448            text_engine: None,
449            image_cache: HashMap::new(),
450            external_texture_registry: None,
451            external_image_cache: HashMap::new(),
452            text_atlas_array: None,
453            analytic_path_cache: HashMap::new(),
454            compositors: HashMap::new(),
455            surfaces: HashMap::new(),
456            offscreen_targets: HashMap::new(),
457            intermediate_targets: HashMap::new(),
458            frame_resources: FrameResources::default(),
459        }
460    }
461}
462
463impl fmt::Debug for WgpuRenderer {
464    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
465        f.debug_struct("WgpuRenderer")
466            .field("feathering_enabled", &self.feathering_enabled)
467            .field("feather_width", &self.feather_width)
468            .field("text_coverage_policy", &self.text_coverage_policy)
469            .field("frames_rendered", &self.frames_rendered)
470            .field("capabilities", &self.capabilities)
471            .field("last_frame_count", &self.last_frames.len())
472            .field("last_frame_stats_count", &self.last_frame_stats.len())
473            .field("has_device", &self.shared.is_some())
474            .field("surface_count", &self.surfaces.len())
475            .finish()
476    }
477}