tawasuyu/brahman
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

feat(dominium): maqueta isométrica agnóstica — dominium-render-plan

Browse Source 
build_plan(World, IsoProjector, ZWeights, PlanConfig) → RenderPlan:
un quad por celda (color = mezcla pesada de las 5 capas, relieve =
Z compuesto) + un quad-marca por Lemming posado sobre el terreno.
Quads ordenados por profundidad de pintor (depth = x+y) + caja
envolvente para centrado. Cero deps gráficas. 10 tests.

Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>
This commit is contained in:
sergio
2026-05-20 16:19:40 +00:00
parent e2833a20c4
commit cba61e3549
4 changed files with 412 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files
crates/modules/dominium/dominium-render-plan/src/lib.rs
+389
View File
@@ -0,0 +1,389 @@
//! `dominium-render-plan` — la maqueta isométrica, agnóstica de backend.
//!
//! El último eslabón antes de la pantalla. Toma un [`World`] lógico, lo
//! proyecta con un [`IsoProjector`] y emite una lista plana de
//! [`Quad`]s 2D ya ordenados de atrás hacia adelante: cualquier backend
//! (GPUI, `<canvas>` web, TUI) sólo tiene que pintarlos en orden.
//!
//! Aquí no hay `gpui`, ni `wgpu`, ni `f64`: sólo aritmética `f32` y
//! `dominium-iso`. La regla de la spec —cero dependencias gráficas en el
//! núcleo— se respeta hasta el penúltimo crate.
//!
//! ```text
//! World ──► build_plan(iso, weights, cfg) ──► RenderPlan { quads }
//! │
//! backend.paint(quad) ◄─────┘ (en orden)
//! ```
//!
//! - Una celda → un quad-rombo aproximado, coloreado por la mezcla de sus
//! 5 capas (la altura sale del `Z` compuesto, el color de la psique del
//! suelo).
//! - Un Lemming → un quad-marca posado sobre el relieve de su celda.
//! - Todo se ordena por `depth = x + y` (orden de pintor isométrico).
#![forbid(unsafe_code)]
use dominium_core::World;
use dominium_iso::{IsoProjector, ZWeights};
use serde::{Deserialize, Serialize};
/// Color RGBA lineal, componentes en `0.0..=1.0`.
pub type Color = [f32; 4];
/// Un rectángulo 2D en coordenadas de pantalla, listo para pintar. El
/// origen `(0,0)` es el centro de la proyección; el backend traslada.
#[derive(Debug, Clone, Copy, PartialEq, Serialize, Deserialize)]
pub struct Quad {
/// Esquina superior-izquierda, eje X de pantalla.
pub x: f32,
/// Esquina superior-izquierda, eje Y de pantalla.
pub y: f32,
/// Ancho en pixels.
pub w: f32,
/// Alto en pixels.
pub h: f32,
/// Color RGBA.
pub color: Color,
/// Clave de orden de pintor: menor = más al fondo. El plan ya viene
/// ordenado, pero se conserva por si el backend reordena.
pub depth: f32,
}
/// Paleta: un color por capa de la grilla, más el de los Lemmings. El
/// color de cada celda es la mezcla de estos pesada por el valor relativo
/// de cada capa.
#[derive(Debug, Clone, Copy, Serialize, Deserialize)]
pub struct Palette {
/// Color de una celda sin ningún campo (terreno desnudo).
pub floor: Color,
pub materia: Color,
pub psique: Color,
pub poder: Color,
pub oro: Color,
pub degradacion: Color,
/// Color de la marca de un Lemming.
pub lemming: Color,
}
impl Default for Palette {
/// Paleta "tablero psicológico": verde materia, azul psique, rojo
/// poder, ámbar oro, violeta degradación.
fn default() -> Self {
Self {
floor: [0.10, 0.11, 0.13, 1.0],
materia: [0.30, 0.72, 0.38, 1.0],
psique: [0.32, 0.55, 0.86, 1.0],
poder: [0.84, 0.27, 0.24, 1.0],
oro: [0.90, 0.74, 0.24, 1.0],
degradacion: [0.52, 0.30, 0.62, 1.0],
lemming: [0.96, 0.96, 0.98, 1.0],
}
}
}
/// Ajustes de la maqueta: tamaños de quad y paleta. Lo que un panel
/// expondría como controles de presentación (no afectan la simulación).
#[derive(Debug, Clone, Copy, Serialize, Deserialize)]
pub struct PlanConfig {
/// Lado del quad de una celda, en pixels.
pub tile: f32,
/// Lado del quad-marca de un Lemming, en pixels.
pub lemming_size: f32,
/// Cuánto se eleva la marca del Lemming sobre el relieve de su celda,
/// en unidades de `Z`.
pub lemming_lift: f32,
pub palette: Palette,
}
impl Default for PlanConfig {
fn default() -> Self {
Self {
tile: 18.0,
lemming_size: 9.0,
lemming_lift: 0.6,
palette: Palette::default(),
}
}
}
/// Lista de quads ordenada de atrás hacia adelante + caja envolvente.
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct RenderPlan {
/// Quads ya ordenados por `depth` ascendente: píntalos en orden.
pub quads: Vec<Quad>,
/// Caja envolvente de todos los quads — el backend la usa para
/// centrar o escalar la vista.
pub min_x: f32,
pub min_y: f32,
pub max_x: f32,
pub max_y: f32,
}
impl RenderPlan {
/// Ancho de la caja envolvente.
pub fn width(&self) -> f32 {
self.max_x - self.min_x
}
/// Alto de la caja envolvente.
pub fn height(&self) -> f32 {
self.max_y - self.min_y
}
}
/// Mezcla `n` colores con pesos: `Σ wᵢ·colorᵢ / Σ wᵢ`. Alpha del primero.
fn blend(parts: &[(f32, Color)]) -> Color {
let total: f32 = parts.iter().map(|(w, _)| *w).sum();
if total <= f32::EPSILON {
return [0.0, 0.0, 0.0, 1.0];
}
let mut out = [0.0f32; 4];
for (w, c) in parts {
let k = w / total;
for ch in 0..3 {
out[ch] += k * c[ch];
}
}
out[3] = 1.0;
out
}
/// Color de una celda: mezcla de la paleta pesada por el valor relativo
/// de sus 5 capas. Una celda vacía cae al color `floor`.
fn cell_color(world: &World, idx: usize, pal: &Palette) -> Color {
let g = &world.grid;
let layers = [
(g.materia[idx].max(0.0), pal.materia),
(g.psique[idx].max(0.0), pal.psique),
(g.poder[idx].max(0.0), pal.poder),
(g.oro[idx].max(0.0), pal.oro),
(g.degradacion[idx].max(0.0), pal.degradacion),
];
let total: f32 = layers.iter().map(|(v, _)| *v).sum();
if total <= f32::EPSILON {
return pal.floor;
}
blend(&layers)
}
/// Construye la maqueta isométrica de un `World`.
///
/// Emite un quad por celda (coloreado por sus capas, elevado por el `Z`
/// compuesto de `weights`) y un quad-marca por Lemming vivo, posado sobre
/// el relieve de su celda. El resultado viene ordenado por profundidad de
/// pintor: el backend sólo recorre `plan.quads` y pinta.
pub fn build_plan(
world: &World,
iso: &IsoProjector,
weights: &ZWeights,
cfg: &PlanConfig,
) -> RenderPlan {
let g = &world.grid;
let mut quads: Vec<Quad> = Vec::with_capacity(g.cells() + world.lemmings.len());
// --- Celdas: un quad-rombo aproximado por celda ---
for cy in 0..g.height {
for cx in 0..g.width {
let idx = g.idx(cx, cy);
let z = weights.z_of(g, idx);
let (sx, sy) = iso.project(cx as f32, cy as f32, z);
quads.push(Quad {
x: sx - cfg.tile * 0.5,
y: sy - cfg.tile * 0.5,
w: cfg.tile,
h: cfg.tile,
color: cell_color(world, idx, &cfg.palette),
depth: cx as f32 + cy as f32,
});
}
}
// --- Lemmings: una marca posada sobre el relieve de su celda ---
let lem = &world.lemmings;
for i in 0..lem.len() {
let (px, py) = (lem.pos_x[i], lem.pos_y[i]);
let (cx, cy) = g.clamp_cell(px, py);
let z = weights.z_of(g, g.idx(cx, cy)) + cfg.lemming_lift;
let (sx, sy) = iso.project(px, py, z);
quads.push(Quad {
x: sx - cfg.lemming_size * 0.5,
y: sy - cfg.lemming_size * 0.5,
w: cfg.lemming_size,
h: cfg.lemming_size,
color: cfg.palette.lemming,
// +0.5 → la marca se pinta después de su celda y de las
// celdas con su misma diagonal.
depth: px + py + 0.5,
});
}
// --- Orden de pintor: atrás (depth bajo) primero ---
quads.sort_by(|a, b| {
a.depth.partial_cmp(&b.depth).unwrap_or(core::cmp::Ordering::Equal)
});
// --- Caja envolvente ---
let mut plan = RenderPlan { quads, ..Default::default() };
if let Some(first) = plan.quads.first() {
plan.min_x = first.x;
plan.min_y = first.y;
plan.max_x = first.x + first.w;
plan.max_y = first.y + first.h;
for q in &plan.quads {
plan.min_x = plan.min_x.min(q.x);
plan.min_y = plan.min_y.min(q.y);
plan.max_x = plan.max_x.max(q.x + q.w);
plan.max_y = plan.max_y.max(q.y + q.h);
}
}
plan
}
#[cfg(test)]
mod tests {
use super::*;
fn iso() -> IsoProjector {
IsoProjector::new(1.0, 10.0)
}
#[test]
fn empty_world_yields_one_quad_per_cell() {
let world = World::new(5, 4);
let plan = build_plan(&world, &iso(), &ZWeights::default(), &PlanConfig::default());
assert_eq!(plan.quads.len(), 20);
}
#[test]
fn each_lemming_adds_a_quad() {
let mut world = World::new(8, 8);
world.lemmings.spawn(2.0, 3.0, 50.0, [1.0, 0.0, 0.0, 0.0]);
world.lemmings.spawn(5.0, 5.0, 50.0, [0.0, 1.0, 0.0, 0.0]);
let plan = build_plan(&world, &iso(), &ZWeights::default(), &PlanConfig::default());
// 64 celdas + 2 marcas.
assert_eq!(plan.quads.len(), 66);
}
#[test]
fn quads_are_depth_sorted_back_to_front() {
let mut world = World::new(6, 6);
world.lemmings.spawn(3.0, 3.0, 50.0, [0.0; 4]);
let plan = build_plan(&world, &iso(), &ZWeights::default(), &PlanConfig::default());
for w in plan.quads.windows(2) {
assert!(w[0].depth <= w[1].depth, "deben ir de atrás hacia adelante");
}
}
#[test]
fn lemming_draws_after_its_cell() {
// Lemming en la celda (2,2): su marca (depth 4.5) debe ir tras la
// celda (2,2) (depth 4.0).
let mut world = World::new(6, 6);
world.lemmings.spawn(2.0, 2.0, 50.0, [0.0; 4]);
let plan = build_plan(&world, &iso(), &ZWeights::default(), &PlanConfig::default());
let cfg = PlanConfig::default();
let marca = plan
.quads
.iter()
.find(|q| q.w == cfg.lemming_size)
.expect("hay una marca");
assert_eq!(marca.depth, 4.5);
}
#[test]
fn empty_cell_uses_floor_color() {
let world = World::new(3, 3);
let cfg = PlanConfig::default();
let plan = build_plan(&world, &iso(), &ZWeights::default(), &cfg);
assert_eq!(plan.quads[0].color, cfg.palette.floor);
}
#[test]
fn high_materia_cell_leans_green() {
// Sólo la celda (1,1) tiene campo → sólo ella escapa del color
// `floor`; el resto del tablero queda desnudo.
let mut world = World::new(3, 3);
let idx = world.grid.idx(1, 1);
world.grid.materia[idx] = 100.0;
let cfg = PlanConfig::default();
let plan = build_plan(&world, &iso(), &ZWeights::default(), &cfg);
let painted: Vec<_> = plan
.quads
.iter()
.filter(|q| q.w == cfg.tile && q.color != cfg.palette.floor)
.collect();
assert_eq!(painted.len(), 1, "una sola celda con campo");
assert_eq!(painted[0].color, cfg.palette.materia);
}
#[test]
fn cell_color_blends_two_layers() {
let mut world = World::new(3, 3);
let idx = world.grid.idx(0, 0);
world.grid.materia[idx] = 50.0;
world.grid.poder[idx] = 50.0;
let pal = Palette::default();
let c = cell_color(&world, idx, &pal);
// Mezcla 50/50 de verde materia y rojo poder → canal por canal.
for ch in 0..3 {
let expected = 0.5 * pal.materia[ch] + 0.5 * pal.poder[ch];
assert!((c[ch] - expected).abs() < 1e-5);
}
}
#[test]
fn bounding_box_encloses_every_quad() {
let mut world = World::new(7, 5);
world.lemmings.spawn(3.0, 2.0, 50.0, [0.0; 4]);
let plan = build_plan(&world, &iso(), &ZWeights::default(), &PlanConfig::default());
for q in &plan.quads {
assert!(q.x >= plan.min_x - 1e-3);
assert!(q.y >= plan.min_y - 1e-3);
assert!(q.x + q.w <= plan.max_x + 1e-3);
assert!(q.y + q.h <= plan.max_y + 1e-3);
}
assert!(plan.width() > 0.0 && plan.height() > 0.0);
}
#[test]
fn plan_is_deterministic() {
let mut world = World::new(10, 10);
world.lemmings.spawn(4.0, 6.0, 50.0, [0.5, 0.2, 0.1, 0.7]);
let idx = world.grid.idx(2, 2);
world.grid.materia[idx] = 33.0;
let a = build_plan(&world, &iso(), &ZWeights::default(), &PlanConfig::default());
let b = build_plan(&world, &iso(), &ZWeights::default(), &PlanConfig::default());
assert_eq!(a.quads, b.quads);
}
#[test]
fn z_weights_raise_the_terrain() {
// Con materia alta y peso de relieve, la celda sube (menor y).
let mut world = World::new(3, 3);
let idx = world.grid.idx(1, 1);
world.grid.materia[idx] = 50.0;
let flat = build_plan(
&world,
&iso(),
&ZWeights { materia: 0.0, ..ZWeights::default() },
&PlanConfig::default(),
);
let raised = build_plan(
&world,
&iso(),
&ZWeights { materia: 1.0, ..ZWeights::default() },
&PlanConfig::default(),
);
let cfg = PlanConfig::default();
// La celda (1,1) es la única con campo → la única coloreada
// `materia`; la identificamos por color, no por `depth`.
let pick = |p: &RenderPlan| {
p.quads
.iter()
.find(|q| q.w == cfg.tile && q.color == cfg.palette.materia)
.unwrap()
.y
};
assert!(pick(&raised) < pick(&flat), "el relieve sube la celda");
}
}