2 files changed, 177 insertions, 2 deletions
diff --git a/crates/fparkan-render/src/lib.rs b/crates/fparkan-render/src/lib.rs
index db0171f..80193c7 100644
--- a/crates/fparkan-render/src/lib.rs
+++ b/crates/fparkan-render/src/lib.rs
@@ -382,8 +382,9 @@ pub enum LegacyCullMode {
 
 /// CPU diffuse alpha for a colourless MSH batch carrying flag `0x0008`.
 ///
-/// `packet_distance` is the distance to the packet's first accepted vertex,
-/// after its object transform. Flag `0x0010` takes precedence over `0x0040`.
+/// `packet_distance` is the native distance to the input packet's first indexed
+/// vertex after its object transform, even when that vertex is outside the
+/// viewport. Flag `0x0010` takes precedence over `0x0040`.
 /// Returns `None` for invalid distance or projection inputs. Callers must keep
 /// the material alpha for batches with a type-16 colour stream or without `0x0008`.
 #[must_use]
diff --git a/crates/fparkan-render/src/water.rs b/crates/fparkan-render/src/water.rs
index 0c7ad2a..7a5ccbd 100644
--- a/crates/fparkan-render/src/water.rs
+++ b/crates/fparkan-render/src/water.rs
@@ -7,6 +7,32 @@ pub const EMBM_BUMP_TILE: f32 = 100.0;
 /// Native diagonal bump matrix, without luminance modulation.
 pub const EMBM_COEFFICIENTS: [f32; 2] = [0.01, 0.01];
 
+/// Terrain draws ordinary textured water into its reflection with this alpha.
+pub const REFLECTED_WATER_ALPHA: f32 = 0.1;
+
+/// Native packet category 4 enables source-alpha blending without changing depth.
+#[must_use]
+pub fn legacy_reflected_water_pipeline(
+    state: crate::LegacyPipelineState,
+) -> crate::LegacyPipelineState {
+    crate::LegacyPipelineState {
+        blend: crate::LegacyBlendMode::SourceAlpha,
+        alpha_test: true,
+        ..state
+    }
+}
+
+/// Square reflection size chosen by Terrain.dll RVA 0x27FC7 from renderer dimensions.
+#[must_use]
+pub fn legacy_embm_reflection_size(extent: [u32; 2]) -> u32 {
+    let limit = extent[0].min(extent[1]).min(1024);
+    let mut side = 2;
+    while side * 2 <= limit {
+        side *= 2;
+    }
+    side
+}
+
 /// Generates the signed bytes written by Terrain.dll RVA 0x2BF50 with CW 0x007F.
 #[must_use]
 pub fn legacy_embm_bump_map() -> Vec<[i8; 2]> {
@@ -51,11 +77,159 @@ pub fn legacy_embm_uv(world_xy: [f32; 2], bounds: [f32; 4]) -> Option<[f32; 2]>
     ])
 }
 
+/// The EMBM camera looks up from the mirrored eye, with its window on the water rectangle.
+/// Terrain.dll+4EFF0 supplies `[min_y-eye_y, min_x-eye_x, span_y, span_x, eye_z-height]`.
+/// The ordinary perspective's depth mapping is retained; orthographic inputs use the caller's fallback.
+#[must_use]
+pub fn legacy_embm_reflection_clip(
+    main_clip: [f32; 16],
+    eye: [f32; 3],
+    height: f32,
+    bounds: [f32; 4],
+) -> Option<[f32; 16]> {
+    let span = [bounds[2] - bounds[0], bounds[3] - bounds[1]];
+    let distance = eye[2] - height;
+    if !main_clip
+        .into_iter()
+        .chain(eye)
+        .chain([height])
+        .chain(bounds)
+        .chain(span)
+        .all(f32::is_finite)
+        || distance <= 0.0
+        || span.into_iter().any(|v| v <= 0.0)
+    {
+        return None;
+    }
+    let w = [main_clip[3], main_clip[7], main_clip[11]];
+    let squared = w.into_iter().map(|v| v * v).sum::<f32>();
+    if !squared.is_finite() || squared <= f32::EPSILON {
+        return None;
+    }
+    let depth_a = (main_clip[2] * w[0] + main_clip[6] * w[1] + main_clip[10] * w[2]) / squared;
+    // shortcut: retain the main depth range until the native shifted depth matrix is verified.
+    let depth_b = (main_clip[14] - depth_a * main_clip[15]) / squared.sqrt();
+    if !depth_a.is_finite() || !depth_b.is_finite() || depth_a < 1.0 || depth_b >= 0.0 {
+        return None;
+    }
+    let z = 2.0 * height - eye[2];
+    let x_scale = -2.0 * distance / span[1];
+    let y_scale = -2.0 * distance / span[0];
+    let x_shift = 1.0 + 2.0 * (bounds[1] - eye[1]) / span[1];
+    let y_shift = 1.0 + 2.0 * (bounds[0] - eye[0]) / span[0];
+    let matrix = [
+        0.0,
+        y_scale,
+        0.0,
+        0.0,
+        x_scale,
+        0.0,
+        0.0,
+        0.0,
+        x_shift,
+        y_shift,
+        depth_a,
+        1.0,
+        -x_scale * eye[1] - x_shift * z,
+        -y_scale * eye[0] - y_shift * z,
+        depth_b - depth_a * z,
+        -z,
+    ];
+    matrix.into_iter().all(f32::is_finite).then_some(matrix)
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
 
     #[test]
+    fn reflected_water_blends_material_alpha_and_preserves_depth_and_cull() {
+        use crate::{LegacyBlendMode, LegacyCullMode, LegacyDepthMode, LegacyPipelineState};
+        for depth in [
+            LegacyDepthMode::Disabled,
+            LegacyDepthMode::TestWrite,
+            LegacyDepthMode::TestReadOnly,
+        ] {
+            let original = LegacyPipelineState {
+                depth,
+                cull: LegacyCullMode::FrontFace,
+                ..LegacyPipelineState::default()
+            };
+            let fallback = legacy_reflected_water_pipeline(original);
+            assert_eq!(fallback.blend, LegacyBlendMode::SourceAlpha);
+            assert!(fallback.alpha_test);
+            assert_eq!(fallback.depth, original.depth);
+            assert_eq!(fallback.cull, original.cull);
+        }
+        assert_eq!(REFLECTED_WATER_ALPHA.to_bits(), 0x3dcc_cccd);
+    }
+
+    #[test]
+    fn reflection_size_matches_native_renderer_dimension_vectors() {
+        for (extent, expected) in [
+            ([1280, 1024], 1024),
+            ([1280, 720], 512),
+            ([800, 600], 512),
+            ([640, 480], 256),
+            ([1920, 1080], 1024),
+            ([2048, 2048], 1024),
+            ([4, 7], 4),
+            ([3, 300], 2),
+            ([1, 1], 2),
+            ([700, 700], 512),
+        ] {
+            assert_eq!(legacy_embm_reflection_size(extent), expected, "{extent:?}");
+        }
+    }
+
+    #[test]
+    fn shifted_camera_maps_native_water_corners_and_retains_perspective_depth() {
+        let projection = crate::LegacyD3d7Projection {
+            viewport: [0, 0, 1280, 1024],
+            near_plane: 0.5,
+            far_plane: 700.0,
+            field_of_view_radians: 1.3,
+        }
+        .try_direct3d7_projection_row_major()
+        .unwrap();
+        let eye = [1200.0, 800.0, 185.0];
+        let mut main = [0.0; 16];
+        main[2] = projection[10];
+        main[3] = projection[11];
+        main[14] = -eye[0] * projection[10] + projection[14];
+        main[15] = -eye[0] * projection[11];
+        let bounds = [1000.0, 500.0, 1500.0, 1200.0];
+        let matrix = legacy_embm_reflection_clip(main, eye, 150.0, bounds).unwrap();
+        let project = |point: [f32; 3]| -> [f32; 4] {
+            std::array::from_fn(|column| {
+                point[0] * matrix[column]
+                    + point[1] * matrix[4 + column]
+                    + point[2] * matrix[8 + column]
+                    + matrix[12 + column]
+            })
+        };
+        for point in [
+            [1000.0, 500.0, 150.0],
+            [1500.0, 1200.0, 150.0],
+            [1125.0, 1025.0, 150.0],
+        ] {
+            let clip = project(point);
+            let expected = legacy_embm_uv([point[0], point[1]], bounds).unwrap();
+            for axis in 0..2 {
+                assert!((clip[axis] / clip[3] * 0.5 + 0.5 - expected[axis]).abs() < 0.00001);
+            }
+            assert_eq!(clip[3], 35.0);
+        }
+        let near = project([1200.0, 800.0, 115.5]);
+        assert!((near[2] / near[3]).abs() < 0.001);
+        let far = project([1200.0, 800.0, 815.0]);
+        assert!((far[2] / far[3] - 1.0).abs() < 0.00001);
+        assert!(legacy_embm_reflection_clip([0.0; 16], eye, 150.0, bounds).is_none());
+        assert!(legacy_embm_reflection_clip(main, eye, 185.0, bounds).is_none());
+        assert!(legacy_embm_reflection_clip(main, eye, 150.0, [1.0; 4]).is_none());
+    }
+
+    #[test]
     fn wave_bytes_match_native_generation_and_clock_wraps_without_float_time_loss() {
         let texels = legacy_embm_bump_map();
         assert_eq!(texels.len(), 128 * 128);