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 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}