Function oblique_proj

native/shared/src/renderer/planar_reflection.rs:230–273

EN-011 V2 — modify a projection matrix so its near plane is clipped at the given eye-space plane. Used for planar reflection to prevent geometry below the water from polluting the reflection along the shoreline edge. Reference: Eric Lengyel, "Oblique View Frustum Depth Projection and Clipping" (Journal of Game Development, 2005). The technique shifts the projection's near plane to coincide with t

(
    proj: [[f32; 4]; 4],
    plane_eye_space: [f32; 4],
)

/// plane satisfy `N · p_eye + d = 0`. Use `world_plane_to_eye_space`
/// to convert from a world-space plane.
pub fn oblique_proj(
    proj: [[f32; 4]; 4],
    plane_eye_space: [f32; 4],
) -> [[f32; 4]; 4] {
    let c = plane_eye_space;

    // Far-plane corner in clip space is in the direction of (sgn(c.x),
    // sgn(c.y), 1, 1) — Lengyel §2. Pulled back into eye space by
    // multiplying with `inv(proj)`.
    let sx = if c[0] >= 0.0 { 1.0 } else { -1.0 };
    let sy = if c[1] >= 0.0 { 1.0 } else { -1.0 };
    let q_clip = [sx, sy, 1.0, 1.0];
    let inv_p = mat4_invert(proj);
    let q = mat4_mul_vec4(&inv_p, &q_clip);

    // Scale `c` so the near-plane crosses through the supplied plane:
    //   M = (2 / dot(c, q)) · c
    // Then the new third row of P (which controls the depth output) is
    //   P_row2 = M - P_row3
    // (P_row3 is the standard perspective w-row, all stays the same.)
    let denom = c[0] * q[0] + c[1] * q[1] + c[2] * q[2] + c[3] * q[3];
    if denom.abs() < 1e-10 {
        // Degenerate plane orientation w.r.t. the frustum — leave
        // projection unchanged rather than divide-by-zero. The
        // reflection still renders, just without near-plane clipping.
        return proj;
    }
    let scale = 2.0 / denom;
    let m = [c[0] * scale, c[1] * scale, c[2] * scale, c[3] * scale];

    // proj is column-major: proj[col][row]. The "third row" we want
    // to replace is at row index 2 across all four columns. The
    // "fourth row" is at row index 3. New row-2 = M - row3 — but
    // since wgpu's clip-space z range is [0, 1] (not [-1, 1] like
    // OpenGL), the depth-rescaling pre-step is `M - P_row3` exactly
    // as in Lengyel's original derivation; the [-1, 1] vs [0, 1]
    // difference is absorbed by the scale.
    let mut out = proj;
    out[0][2] = m[0] - proj[0][3];
    out[1][2] = m[1] - proj[1][3];
    out[2][2] = m[2] - proj[2][3];
    out[3][2] = m[3] - proj[3][3];
    out
}

fn normalise(v: [f32; 3]) -> [f32; 3] {
    let len_sq = v[0] * v[0] + v[1] * v[1] + v[2] * v[2];