From c508e232b0d2b515a6db84dbe9d40f2e553a3841 Mon Sep 17 00:00:00 2001 From: Richard Zink Date: Tue, 3 Nov 2026 07:25:46 +0100 Subject: [PATCH] Dig marks and hover follow the real block shape; sprites no longer clipped by walls behind them Co-Authored-By: Claude Opus 5.5 --- DESIGN.md | 6 +-- src/render3d.rs | 101 ++++++++++++++++++++++++++++++------------------ 2 files changed, 66 insertions(+), 41 deletions(-) diff --git a/DESIGN.md b/DESIGN.md index 894940a..4951ed0 100644 --- a/DESIGN.md +++ b/DESIGN.md @@ -16,10 +16,10 @@ An original dungeon management game (genre: dungeon building & defence) that run - Camera **freely rotatable 360° and tiltable** - Walls with an **irregular surface** (noise displacement of the wall faces, seamless between neighbours) - Textures: **procedural pixel art** (tile atlas) -- Units: **pixel sprites as billboards** (always facing the camera) +- Units: **pixel sprites as billboards** (always facing the camera), pulled towards the camera in depth so walls behind a unit never cut into its sprite - Lighting: **dark + torches** – dark base level; claimed areas and light sources (torches, core, portal, gate) are bright, flickering light -- **Dig marking**: a marked block glows as a translucent yellow box with a yellow outline around all edges -- **Hover**: the wall block under the mouse gets a faint version of that box (in the colour of the active tool); while dragging a dig rectangle, every block inside is tinted faintly; floor tiles get an outline +- **Dig marking**: a marked block glows yellow along its **real irregular shape** (tinted top and open sides, outline following the displaced edges) +- **Hover**: the wall block under the mouse gets a faint version of that highlight (in the colour of the active tool); while dragging a dig rectangle, every block inside is tinted faintly; floor tiles get an outline - **Tile outlines**: subtle dark lines around every tile (floors, wall tops, vertical wall edges), following the irregular surface; toggle with G (later in the graphics settings) - The UI is a 2D layer on top, including a minimap diff --git a/src/render3d.rs b/src/render3d.rs index 3410363..6b499be 100644 --- a/src/render3d.rs +++ b/src/render3d.rs @@ -415,39 +415,61 @@ const MARK_FILL: [u8; 4] = [255, 205, 50, 70]; const MARK_LINE: [u8; 4] = [255, 220, 70, 235]; // Glowing yellow box around a block that is marked for digging -fn mark_block(mk: &mut MB, map: &Map, x: i32, z: i32) { - block_box(mk, map, x, z, MARK_FILL, MARK_LINE, 0.06, 1.0); +fn mark_block(mk: &mut MB, map: &Map, x: i32, z: i32, n: usize) { + block_shell(mk, map, x, z, n, MARK_FILL, MARK_LINE, 1.0, 0.03); } -// Translucent box around a wall block: fill on top and open sides, outline on all edges. -// pad = how far the box sticks out, lw = line width factor -fn block_box(mk: &mut MB, map: &Map, x: i32, z: i32, fill: [u8; 4], line: [u8; 4], pad: f32, lw: f32) { - let (x0, z0) = (x as f32 - pad, z as f32 - pad); - let (x1, z1) = (x as f32 + 1.0 + pad, z as f32 + 1.0 + pad); - let top = WALL_H + 0.1 + pad; - let c = [x0, z0, x1, z1]; - let p = |xx: f32, y: f32, zz: f32| vec3(xx, y, zz); - // top face - mk.quad([p(c[0], top, c[1]), p(c[2], top, c[1]), p(c[2], top, c[3]), p(c[0], top, c[3])], [Vec2::ZERO; 4], [fill; 4], [Vec3::Y; 4]); - let corners = [p(c[0], 0.0, c[1]), p(c[2], 0.0, c[1]), p(c[2], 0.0, c[3]), p(c[0], 0.0, c[3])]; - // side faces towards open neighbours, outline on all edges - for k in 0..4 { - let a = corners[k]; - let b = corners[(k + 1) % 4]; - let (dx, dz) = DIR4[k]; - let up = vec3(0.0, top, 0.0); - let out = vec3(dx as f32, 0.0, dz as f32); - if !solid_at(map, x + dx, z + dz) { - mk.quad([a, b, b + up, a + up], [Vec2::ZERO; 4], [fill; 4], [out; 4]); - mk.strip(a + vec3(0.0, 0.02, 0.0), b + vec3(0.0, 0.02, 0.0), out, 0.05 * lw, line); +// Colored, slightly lifted copy of a displaced face (same grid and displacement as the wall) +fn shell_face(mk: &mut MB, pos: impl Fn(f32, f32) -> Vec3, face_n: Vec3, n: usize, fill: [u8; 4], lift: f32) { + let m = n + 1; + let mut p = Vec::with_capacity(m * m); + for j in 0..m { + for i in 0..m { + let base = pos(i as f32 / n as f32, j as f32 / n as f32); + p.push(base + displace(base) + face_n * lift); } - mk.strip(a + up, b + up, Vec3::Y, 0.06 * lw, line); - // vertical edge at this corner: down to the floor only where a side is open, - // otherwise just the part that sticks out above the neighbouring walls + } + let b = mk.v.len() as u16; + for &q in &p { + mk.vert(q, Vec2::ZERO, fill, face_n); + } + for j in 0..n { + for i in 0..n { + let a = b + (j * m + i) as u16; + mk.i.extend_from_slice(&[a, a + 1, a + m as u16 + 1, a, a + m as u16 + 1, a + m as u16]); + } + } +} + +// Highlight that follows the block's real (irregular) shape: tinted top and open sides, +// outline along the displaced edges. lw = line width factor, lift = distance off the surface. +fn block_shell(mk: &mut MB, map: &Map, x: i32, z: i32, n: usize, fill: [u8; 4], line: [u8; 4], lw: f32, lift: f32) { + let (xf, zf) = (x as f32, z as f32); + let up = Vec3::Y * lift; + shell_face(mk, |u, v| vec3(xf + u, WALL_H, zf + v), Vec3::Y, n, fill, lift); + let tops = [vec3(xf, WALL_H, zf), vec3(xf + 1.0, WALL_H, zf), vec3(xf + 1.0, WALL_H, zf + 1.0), vec3(xf, WALL_H, zf + 1.0)]; + for k in 0..4 { + let (dx, dz) = DIR4[k]; + let out = vec3(dx as f32, 0.0, dz as f32); + let (ta, tb) = (tops[k], tops[(k + 1) % 4]); + // top edge (lifted a bit outwards so it sits on the rim) + let rim: Vec = edge_pts(ta, tb, n).into_iter().map(|q| q + up + out * lift).collect(); + mk.polyline(&rim, Vec3::Y, 0.06 * lw, line); + let open = !solid_at(map, x + dx, z + dz); + if open { + let (ga, gb) = (ta - Vec3::Y * WALL_H, tb - Vec3::Y * WALL_H); + shell_face(mk, |u, v| ga + (gb - ga) * u + vec3(0.0, WALL_H * (1.0 - v), 0.0), out, n, fill, lift); + let foot: Vec = edge_pts(ga, gb, n).into_iter().map(|q| q + out * lift + Vec3::Y * 0.02).collect(); + mk.polyline(&foot, out, 0.05 * lw, line); + } + // vertical edge at corner ta: only where one of the two sides meeting there is open let (pdx, pdz) = DIR4[(k + 3) % 4]; - let open_here = !solid_at(map, x + dx, z + dz) || !solid_at(map, x + pdx, z + pdz); - let bottom = if open_here { 0.0 } else { WALL_H - 0.05 }; - mk.strip(a + vec3(0.0, bottom, 0.0), a + up, out, 0.05 * lw, line); + if open || !solid_at(map, x + pdx, z + pdz) { + let g = ta - Vec3::Y * WALL_H; + let pout = vec3(pdx as f32, 0.0, pdz as f32); + let col: Vec = edge_pts(g, ta, n).into_iter().map(|q| q + (out + pout) * lift).collect(); + mk.polyline(&col, (out + pout).normalize(), 0.05 * lw, line); + } } } @@ -549,8 +571,9 @@ fn build_chunk(map: &Map, amb: &[f32], cx: i32, cz: i32, gold_fill: f32, atlas: if !solid_at(map, x + 1, z) { ln.polyline(&edge_pts(tr, br, n), Vec3::Y, OUTLINE_W, OUTLINE_C); } - if t.marked { - mark_block(&mut mk, map, x, z); + // vertex budget: one draw call holds at most 40000 vertices + if t.marked && mk.v.len() < 34000 { + mark_block(&mut mk, map, x, z, n); } for (d, &(dx, dz)) in DIR4.iter().enumerate() { if solid_at(map, x + dx, z + dz) { @@ -881,7 +904,7 @@ impl R3d { for f in &g.fx { draw_fx(f, t); } - draw_overlay(&g.map, ov); + draw_overlay(&g.map, ov, self.wall_sub); gl_use_default_material(); set_default_camera(); @@ -923,7 +946,9 @@ impl R3d { } let a = amb(e.x, e.y) * if sleeping { 0.6 } else { 1.0 }; let c = if white { [255, 255, 255, 255] } else { col(Vec3::splat(a), 1.0) }; - let base = vec3(e.x, bob, e.y); + // pulled towards the camera: unchanged on screen (orthographic), but walls behind + // the unit no longer cut into the sprite + let base = vec3(e.x, bob, e.y) + toward * 0.45; let (sr, cr) = rot.sin_cos(); let corner = |dx: f32, dy: f32| { let x = dx * cr - dy * sr; @@ -1198,8 +1223,8 @@ fn outline(x0: f32, z0: f32, x1: f32, z1: f32, y: f32, c: Color) { // Hover feedback: wall blocks get a faint version of the dig-mark box (in the tool colour), // floor tiles an outline. While dragging a dig rectangle, every block inside is tinted. -fn draw_overlay(map: &Map, ov: &Overlay) { - const MAX_BOXES: usize = 400; // keeps the per-frame mesh within one draw call +fn draw_overlay(map: &Map, ov: &Overlay, n: usize) { + const MAX_BOXES: usize = 150; // keeps the per-frame mesh within one draw call let c = ov.color; let fill = [(c.r * 255.0) as u8, (c.g * 255.0) as u8, (c.b * 255.0) as u8, 28]; let line = [(c.r * 255.0) as u8, (c.g * 255.0) as u8, (c.b * 255.0) as u8, 110]; @@ -1213,10 +1238,10 @@ fn draw_overlay(map: &Map, ov: &Overlay) { 'outer: for z in az..=bz { for x in ax..=bx { if map.get(x, z).map_or(false, |t| t.diggable()) { - if boxes >= MAX_BOXES { + if boxes >= MAX_BOXES || mb.v.len() > 30000 { break 'outer; } - block_box(&mut mb, map, x, z, fill, line, 0.08, 0.6); + block_shell(&mut mb, map, x, z, n, fill, line, 0.6, 0.05); boxes += 1; } } @@ -1226,7 +1251,7 @@ fn draw_overlay(map: &Map, ov: &Overlay) { outline(ax as f32, az as f32, bx as f32 + 1.0, bz as f32 + 1.0, y, ov.color); } else if let Some((x, z)) = ov.hover { if solid(x, z) { - block_box(&mut mb, map, x, z, fill, line, 0.08, 0.6); + block_shell(&mut mb, map, x, z, n, fill, line, 0.6, 0.05); } else { outline(x as f32, z as f32, x as f32 + 1.0, z as f32 + 1.0, 0.04, ov.color); }