1use sui_core::{Result, WindowId};
7use sui_render_wgpu::{
8 DisplayCapabilities, FeatheringOptions, OutputGamut, OutputStrategy, WgpuRenderer,
9};
10use sui_runtime::{
11 OutputColorRange, RenderOutput, Runtime, WindowRenderOptions, set_window_output_color_range,
12 window_render_options, window_scene_statistics_detail_mode,
13};
14use web_time::Instant;
15
16use crate::{
17 WindowOutputDiagnostics, map_window_color_management, map_window_text_coverage_policy,
18 publish_window_output_diagnostics, resolve_sdr_content_brightness_nits,
19};
20
21pub struct PresentedFrame {
23 pub output: RenderOutput,
24 pub runtime_time_ms: f64,
25 pub renderer_time_ms: f64,
26 pub presented_at: Instant,
29}
30
31pub fn present_window_frame(
40 runtime: &mut Runtime,
41 renderer: &mut WgpuRenderer,
42 window_id: WindowId,
43) -> Result<PresentedFrame> {
44 let setup_started = Instant::now();
45 let options = apply_render_options(renderer, window_id)?;
46 if let Some(strategy) = renderer.window_output_strategy(window_id) {
48 let gamut = strategy.gamut(
49 &renderer
50 .window_display_capabilities(window_id)
51 .unwrap_or_default(),
52 );
53 set_window_output_color_range(window_id, output_color_range(strategy, gamut));
54 }
55 let setup_time = setup_started.elapsed();
56
57 let runtime_started = Instant::now();
58 let output = runtime.render(window_id)?;
59 let runtime_time_ms = runtime_started.elapsed().as_secs_f64() * 1000.0;
60
61 let renderer_started = Instant::now();
62 renderer.render(&output.frame)?;
63 let presented_at = Instant::now();
64 publish_output_diagnostics(renderer, window_id, &options);
65 let renderer_time_ms = (setup_time + renderer_started.elapsed()).as_secs_f64() * 1000.0;
66
67 Ok(PresentedFrame {
68 output,
69 runtime_time_ms,
70 renderer_time_ms,
71 presented_at,
72 })
73}
74
75struct AppliedOptions {
77 options: WindowRenderOptions,
78 sdr_content_brightness_nits: f32,
79}
80
81fn apply_render_options(
82 renderer: &mut WgpuRenderer,
83 window_id: WindowId,
84) -> Result<AppliedOptions> {
85 renderer.set_runtime_diagnostics_enabled(
86 window_scene_statistics_detail_mode(window_id).is_detailed(),
87 );
88 let render_options = window_render_options(window_id);
89 renderer.set_runtime_feathering_override(
90 render_options.map(|options| {
91 FeatheringOptions::new(options.feathering_enabled, options.feather_width)
92 }),
93 );
94 renderer.set_runtime_text_hinting_override(
95 render_options.map(|options| options.text_hinting.normalized()),
96 );
97 renderer.set_runtime_stem_darkening_override(
98 render_options.map(|options| options.stem_darkening.normalized()),
99 );
100 renderer.set_runtime_text_coverage_policy_override(
101 render_options.map(|options| map_window_text_coverage_policy(options.text_coverage_policy)),
102 );
103 renderer.set_runtime_text_subpixel_order_override(
104 render_options.map(|options| options.text_subpixel_order),
105 );
106
107 let options = render_options.unwrap_or_else(|| WindowRenderOptions::new(false, 0.0));
109 let sdr_content_brightness_nits = resolve_sdr_content_brightness_nits(
110 options.sdr_content_brightness_nits,
111 options.use_system_sdr_content_brightness,
112 &renderer
113 .window_display_capabilities(window_id)
114 .unwrap_or_default(),
115 );
116 renderer.set_window_color_management(
117 window_id,
118 map_window_color_management(
119 options.color_management_mode,
120 options.output_color_primaries,
121 options.dynamic_range_mode,
122 options.tone_mapping_mode,
123 sdr_content_brightness_nits,
124 ),
125 )?;
126 Ok(AppliedOptions {
127 options,
128 sdr_content_brightness_nits,
129 })
130}
131
132fn output_color_range(strategy: OutputStrategy, gamut: OutputGamut) -> OutputColorRange {
134 match strategy {
135 OutputStrategy::HdrNativeSurface { .. } => OutputColorRange::HighDynamicRange,
136 _ if gamut.is_wide() => OutputColorRange::WideGamut,
137 _ => OutputColorRange::Standard,
138 }
139}
140
141fn publish_output_diagnostics(
142 renderer: &WgpuRenderer,
143 window_id: WindowId,
144 applied: &AppliedOptions,
145) {
146 let (Some(mut display_capabilities), Some(active_output_strategy)) = (
147 renderer.window_display_capabilities(window_id),
148 renderer.window_output_strategy(window_id),
149 ) else {
150 return;
151 };
152 if let Some(formats) = renderer.window_surface_formats(window_id) {
153 append_note(
154 &mut display_capabilities,
155 &format!("Surface formats: {formats:?}."),
156 );
157 }
158 let options = &applied.options;
159 let output_gamut = active_output_strategy.gamut(&display_capabilities);
160 publish_window_output_diagnostics(
161 window_id,
162 WindowOutputDiagnostics {
163 system_sdr_content_brightness_nits: display_capabilities.sdr_white_nits,
164 display_capabilities,
165 requested_color_management_mode: options.color_management_mode,
166 requested_output_primaries: options.output_color_primaries,
167 requested_dynamic_range_mode: options.dynamic_range_mode,
168 requested_tone_mapping_mode: options.tone_mapping_mode,
169 requested_sdr_content_brightness_nits: applied.sdr_content_brightness_nits,
170 configured_sdr_content_brightness_nits: options.sdr_content_brightness_nits,
171 use_system_sdr_content_brightness: options.use_system_sdr_content_brightness,
172 active_output_strategy,
173 output_gamut,
174 },
175 );
176}
177
178fn append_note(capabilities: &mut DisplayCapabilities, note: &str) {
179 if !capabilities.notes.is_empty() {
180 capabilities.notes.push(' ');
181 }
182 capabilities.notes.push_str(note);
183}