qualia_core_db/render/gpu/
bloom.rs1use super::*;
3use crate::gpu_context::{global_vram_ledger, VramResourceClass};
4pub(super) use etalon_render::bloom::{hdr_color_target_state, probe_hdr_format, run_bloom_passes};
5pub(super) fn portal_bloom_enabled() -> bool {
7 let ledger = global_vram_ledger();
8 universe_orchestrator().bloom_enabled(ComputeUniverse::Viewport, ledger.mode())
9}
10
11pub(super) fn create_bloom_chain(
12 device: &etalon::Device,
13 width: u32,
14 height: u32,
15 format: etalon::TextureFormat,
16 exposure_ev: f32,
17) -> Option<BloomChain> {
18 if !portal_bloom_enabled() {
19 return None;
20 }
21 let scale = crate::render::output::exposure_scale_from_ev(exposure_ev)?;
22 etalon_render::bloom::create_bloom_chain(device, width, height, format, scale, |bytes| {
23 global_vram_ledger()
24 .try_reserve_graphics(VramResourceClass::FrameTarget, bytes)
25 .ok()
26 })
27}
28fn hdr_composite_available(a: bool, b: bool, c: bool, d: bool) -> bool {
29 a && b && c && d
30}
31impl PortalGpu {
32 pub fn set_exposure_compensation(&mut self, compensation_ev: f32) -> bool {
35 if !compensation_ev.is_finite() {
36 return false;
37 }
38 let Some(exposure_scale) = crate::render::output::exposure_scale_from_ev(compensation_ev)
39 else {
40 return false;
41 };
42 let compensation_ev = compensation_ev.clamp(
43 crate::render::output::MIN_HDR_EXPOSURE_EV,
44 crate::render::output::MAX_HDR_EXPOSURE_EV,
45 );
46 if portal_bloom_enabled() != self.bloom_policy_snapshot {
47 self.sync_bloom_targets();
48 }
49 self.hdr_exposure_ev = compensation_ev;
50 if let Some(bloom) = self.bloom.as_mut() {
51 bloom.exposure_scale = exposure_scale;
52 }
53 let output_available = self
54 .output_chain
55 .as_mut()
56 .map(|output| output.set_exposure(&self.queue, compensation_ev))
57 .unwrap_or(false);
58 self.hdr_exposure_available() || output_available
59 }
60
61 pub fn set_hdr_exposure_compensation(&mut self, compensation_ev: f32) -> bool {
63 self.set_exposure_compensation(compensation_ev)
64 }
65
66 pub fn set_white_balance(&mut self, temperature_ev: f32, tint_ev: f32) -> bool {
68 let Some(gains) =
69 crate::render::output::white_balance_gains_from_stops(temperature_ev, tint_ev)
70 else {
71 return false;
72 };
73 self.white_balance_gains = gains;
74 if let Some(bloom) = self.bloom.as_mut() {
75 bloom.white_balance_gains = gains;
76 }
77 let output_available = if let Some(output) = self.output_chain.as_mut() {
78 output.set_white_balance(&self.queue, gains);
79 true
80 } else {
81 false
82 };
83 self.hdr_exposure_available() || output_available
84 }
85
86 pub fn hdr_exposure_compensation(&self) -> f32 {
88 self.hdr_exposure_ev
89 }
90
91 pub fn hdr_exposure_available(&self) -> bool {
93 hdr_composite_available(
94 self.bloom.is_some(),
95 self.ambient_pipeline_hdr.is_some(),
96 self.projector_pipeline_hdr.is_some(),
97 portal_bloom_enabled(),
98 )
99 }
100
101 pub fn exposure_transform_available(&self) -> bool {
103 if portal_bloom_enabled() != self.bloom_policy_snapshot {
104 return false;
105 }
106 self.hdr_exposure_available() || self.output_chain.is_some()
107 }
108
109 pub fn hdr_scene_available(&self) -> bool {
111 if portal_bloom_enabled() != self.bloom_policy_snapshot {
112 return false;
113 }
114 let hdr_pipelines = self.ambient_pipeline_hdr.is_some()
115 && self.projector_pipeline_hdr.is_some()
116 && self.sky_pipeline_hdr.is_some()
117 && self.mesh_pipeline_hdr.is_some();
118 hdr_pipelines
119 && (self.hdr_exposure_available()
120 || self
121 .output_chain
122 .as_ref()
123 .is_some_and(|o| o.uses_hdr_scene()))
124 }
125}