benilla-octo/crates/benilla-assets/src/water_depth.rs

//! Shared water settings and image binding, independent of world streaming.
use bevy::prelude::*;
use bevy::render::render_resource::ShaderType;

/// The enhanced water module's uniform (binding 104, `WaterParams` in `enhanced_water.wgsl`).
/// Field order is the shader's; change the two together.
#[derive(ShaderType, Clone, Copy, Debug, PartialEq)]
pub struct WaterUniform {
    /// x = quality (0 Classic, 1 Enhanced, 2 High); y = wave energy (ocean 1.0, ADT inland 0.18,
    /// WMO pools 0.12); z = the pinned capture time; w = clock enable (0 on a deterministic run).
    pub mode: Vec4,
    /// x = which renderer (0 ADT MCLQ, 1 WMO exterior, 2 WMO interior); y = ocean; z = fullbright.
    pub lane: Vec4,
    /// Reflection endpoints, linear RGB from the dome's resolved LightIntBand 2 / 6.
    pub sky_zenith: Vec4,
    pub sky_horizon: Vec4,
    /// xyz toward the visible sun by day, the white moon by night; w = 0 sun, 1 moon.
    pub celestial: Vec4,
    /// GFX (planar water): the mirror pass's state. `x` = 1 while the reflection target holds a
    /// view for THIS surface's plane, 0 otherwise (the pass off, no plane found, or the camera
    /// under the water). `y` = the plane's world height, so a surface can tell whether the mirror
    /// was rendered for its own sheet or for a different body a few yards away — a lake and a
    /// canal in one frame share one target, and only the one the pass was aimed at may use it.
    /// `zw` unused.
    pub mirror: Vec4,
}

impl Default for WaterUniform {
    fn default() -> Self {
        Self {
            mode: Vec4::new(0.0, 0.0, 0.0, 1.0),
            lane: Vec4::ZERO,
            sky_zenith: Vec4::ZERO,
            sky_horizon: Vec4::ZERO,
            celestial: Vec3::Y.extend(0.0),
            mirror: Vec4::ZERO,
        }
    }
}

/// 0 = Classic, 1 = Enhanced, 2 = High (Enhanced + screen-space reflection of the scenery).
#[derive(Resource, Clone, Copy, PartialEq)]
pub struct WaterQuality(pub u8);

impl Default for WaterQuality {
    /// GFX (water): High. The scenery reflection was held back until its cost was measured, and
    /// it measures as nothing — Lake Everstill runs 1.91 / 1.84 / 1.90 ms over 300 frames at the
    /// three tiers and the ocean 1.89 / 1.88 / 1.89, inside the run-to-run noise. Kept welded to
    /// `cvars::REGISTERED`'s `waterQuality` by `registered_defaults_mirror_the_code_truths`.
    fn default() -> Self {
        Self(2)
    }
}

/// The world view's opaque depth, resolved to a sampleable R32Float image.
#[derive(Resource, Clone)]
pub struct WaterDepthImage(pub Handle<Image>);

impl FromWorld for WaterDepthImage {
    fn from_world(world: &mut World) -> Self {
        use bevy::{asset::RenderAssetUsages, render::render_resource::*};
        let mut image = Image::new_fill(
            Extent3d::default(),
            TextureDimension::D2,
            &0f32.to_le_bytes(),
            TextureFormat::R32Float,
            RenderAssetUsages::default(),
        );
        image.texture_descriptor.usage = TextureUsages::TEXTURE_BINDING
            | TextureUsages::RENDER_ATTACHMENT
            | TextureUsages::COPY_DST;
        // Render-only: no CPU copy, so a resize does not allocate (and upload) a screen of zeros.
        image.data = None;
        Self(world.resource_mut::<Assets<Image>>().add(image))
    }
}

/// GFX (planar water): the mirrored view of the world, rendered by a second camera placed on the
/// far side of the water plane (`benilla_world::liquid::reflect`).
///
/// `Rgba16Float` and half the viewport on each axis. Half because a reflection is read through a
/// rippled normal and across a surface the eye never sees square-on, so the resolution it can
/// actually show is far below the screen's — and because the pass costs a second scene draw, which
/// is the one thing this renderer cannot spend freely (`docs/GRAPHICS.md`).
#[derive(Resource, Clone)]
pub struct WaterReflectionImage(pub Handle<Image>);

impl FromWorld for WaterReflectionImage {
    fn from_world(world: &mut World) -> Self {
        use bevy::{asset::RenderAssetUsages, render::render_resource::*};
        let mut image = Image::new_fill(
            Extent3d::default(),
            TextureDimension::D2,
            &[0u8; 8],
            TextureFormat::Rgba16Float,
            RenderAssetUsages::default(),
        );
        image.texture_descriptor.usage = TextureUsages::TEXTURE_BINDING
            | TextureUsages::RENDER_ATTACHMENT
            | TextureUsages::COPY_DST;
        // `$WOW_MIRROR_DUMP=1` reads this target back to a PNG (`capture::save_mirror`), which
        // needs COPY_SRC — and a readback usage the shipped build never exercises is not one to
        // declare for everyone.
        if std::env::var_os("WOW_MIRROR_DUMP").is_some() {
            image.texture_descriptor.usage |= TextureUsages::COPY_SRC;
        }
        // Filtered, unlike the depth and colour copies beside it: the reflection is sampled at a
        // rippled UV, so a nearest fetch would alias the ripple into stair steps.
        image.sampler =
            bevy::image::ImageSampler::Descriptor(bevy::image::ImageSamplerDescriptor {
                label: Some("water_reflection".to_owned()),
                address_mode_u: bevy::image::ImageAddressMode::ClampToEdge,
                address_mode_v: bevy::image::ImageAddressMode::ClampToEdge,
                mag_filter: bevy::image::ImageFilterMode::Linear,
                min_filter: bevy::image::ImageFilterMode::Linear,
                ..Default::default()
            });
        // Render-only: no CPU copy, so a resize does not allocate (and upload) a screen of zeros.
        image.data = None;
        Self(world.resource_mut::<Assets<Image>>().add(image))
    }
}

/// The world view's opaque COLOUR, copied right after the main opaque pass (the frame as it stood
/// before any water drew), for the enhanced water's refraction. `Rgba16Float`: a load and a store,
/// never filtered, so the copy is exact whatever the view target's own format is.
#[derive(Resource, Clone)]
pub struct WaterColourImage(pub Handle<Image>);

impl FromWorld for WaterColourImage {
    fn from_world(world: &mut World) -> Self {
        use bevy::{asset::RenderAssetUsages, render::render_resource::*};
        let mut image = Image::new_fill(
            Extent3d::default(),
            TextureDimension::D2,
            &[0u8; 8],
            TextureFormat::Rgba16Float,
            RenderAssetUsages::default(),
        );
        image.texture_descriptor.usage = TextureUsages::TEXTURE_BINDING
            | TextureUsages::RENDER_ATTACHMENT
            | TextureUsages::COPY_DST;
        // Render-only: no CPU copy, so a resize does not allocate (and upload) a screen of zeros.
        image.data = None;
        Self(world.resource_mut::<Assets<Image>>().add(image))
    }
}