Skip to main content

qualia_core_db/render/gpu/
bloom.rs

1//! Bloom policy and output calibration adapter.
2use 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};
5/// `true` when portal bloom is enabled.
6pub(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    /// Set bounded manual HDR exposure compensation in stops (EV).
33    /// The value remains configured and is applied by whichever scene-output path is active.
34    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    /// Compatibility alias for the original HDR-specific API name.
62    pub fn set_hdr_exposure_compensation(&mut self, compensation_ev: f32) -> bool {
63        self.set_exposure_compensation(compensation_ev)
64    }
65
66    /// Set bounded pre-tone-map white balance, retaining controls across target rebuilds.
67    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    /// HDR exposure compensation.
87    pub fn hdr_exposure_compensation(&self) -> f32 {
88        self.hdr_exposure_ev
89    }
90
91    /// `true` when HDR exposure is available.
92    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    /// Whether the active HDR or SDR scene-to-display path applies manual exposure.
102    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    /// Whether the current WebGPU scene path retains values above SDR white before output mapping.
110    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}