tawasuyu/llimphi
Sovereign retained-mode GPU UI framework in Rust (wgpu+vello+taffy+parley), Elm loop, 40+ widgets.
1//! **Humanoide voxel REDONDEADO y expresivo** — el ser estilizado que aprovecha la
2//! no-voxelidad del motor (bisel/isosuperficie sub-voxel) para un look vinyl-toy /
3//! Fall-Guys / chibi CON carácter, en vez del muñeco de cajas tipo Minecraft.
4//!
5//! ## Por qué existe (lección 2026-07-18, ver [[detalle-sub-voxel-rugosidad]])
6//!
7//! El [`Actor`](crate::Actor) histórico es una **malla de 11 cajas** (`push_cube`): se
8//! ve cuadrado. Y voxelizar una foto de persona en LITERAL cae en el valle de inquietud
9//! (a tamaño grande da terror). La regla acordada: **la especie tiene su ESTILO PROPIO**
10//! (proporciones cuantizadas, gestos, ojos grandes) y la foto sólo regula RASGOS
11//! (piel/ropa). Este módulo materializa ese estilo como un **volumen voxel** de primitivas
12//! orgánicas (elipsoides + cápsulas) que, renderizado con `bisel` alto + `silueta_por_voxel`,
13//! el ray-marcher redondea a una figura simpática. Comparte la MISMA gramática de campo que
14//! el terreno/fauna (no otra fidelidad → sin valle).
15//!
16//! ## Diseño anclado en literatura (no intuición)
17//!
18//! Los parámetros de [`EstiloSer`] salen de la teoría del diseño de personajes y la
19//! percepción, no de tanteo visual:
20//! - **Kindchenschema / "baby schema"** (Konrad Lorenz, 1943; Glocker et al. 2009): cabeza
21//! grande respecto al cuerpo, **ojos grandes y BAJOS** (a/por debajo de la mitad de la cara),
22//! cara **redonda/ancha** (nunca alargada), nariz/boca chicas, mentón blando, mejillas y
23//! miembros rechonchos → dispara la respuesta de ternura (activa el núcleo accumbens) y
24//! **escapa del valle**. Dos correcciones de la literatura reciente que este módulo respeta:
25//! (1) *la frente grande se logra BAJANDO los ojos, no estirando el cráneo* — el lever robusto
26//! es la posición baja de los rasgos + mandíbula angosta, no la altura de la frente (estudio
27//! morfométrico 2022); (2) *lo que suma es EVITAR ojos chicos*, no inflarlos sin límite
28//! (Frontiers 2021: grande-vs-natural no fue significativo). → [`EstiloSer::ojo_tam`]/
29//! [`ojo_altura`](EstiloSer::ojo_altura)/[`mejilla`](EstiloSer::mejilla)/
30//! [`extremidad`](EstiloSer::extremidad).
31//! - **Canon de proporciones / "cabezas de alto"**: realista ≈ 7,5–8 cabezas; heroico ≈ 8,5;
32//! cartoon estilizado ≈ 4–6; niño ≈ 4–5; **chibi/super-deformado ≈ 2–4**. Menos cabezas es
33//! el **lever más fuerte** de "más tierno / más joven" (la ontogenia real va de cabeza=½ en el
34//! feto a 1/7 en el adulto → un cabezón se lee juvenil sin importar el resto). → [`EstiloSer::cabezas`]
35//! (default chibi ~2,6, NO realista).
36//! - **Shape language**: círculo = amable/suave, cuadrado = estable/fiable, triángulo =
37//! dinámico/agresivo. Un personaje se lee por su **forma dominante** (el "appeal" nace de
38//! comprometerse con UNA forma). → eje [`redondez`](EstiloSer::redondez) (círculo↔cuadrado,
39//! controla también el `bisel`) y [`angulosidad`](EstiloSer::angulosidad) (hombros anchos/
40//! cadera angosta = triángulo).
41//! - **Valle de inquietud** (Mori; Realism Inconsistency Theory, MacDorman): el valle lo
42//! dispara **mezclar fidelidades** (rasgos en distintos niveles de realismo), no la
43//! caricatura. Ojos grandes sobre cara FOTORREAL = lo más siniestro. Por eso el realismo se
44//! mantiene **uniforme y bajo** y la foto SÓLO regula color (piel/ropa), nunca inyecta
45//! geometría/textura fotográfica.
46//!
47//! ## Gestos
48//!
49//! [`humanoide_voxel`] recibe una [`Pose`](crate::Pose) (los ángulos de articulación del
50//! catálogo de [`Clip`](crate::Clip)) y la aplica a las cápsulas de miembros → el ser
51//! redondeado saluda / señala / camina con la misma expresividad que el [`Actor`], sin
52//! cajas. Es puro y determinista (testeable sin GPU).
53
54use llimphi_3d::glam::Vec3;
55use llimphi_3d::VoxelGrid;
56use serde::{Deserialize, Serialize};
57
58use crate::actor::{Age, Pose};
59
60/// **Estilo de un ser** — el juego de perillas de diseño (ver el módulo para las fuentes).
61/// Todas tienen un default con carga semántica; los presets ([`por_edad`](Self::por_edad),
62/// [`amable`](Self::amable), [`robusto`](Self::robusto), [`agil`](Self::agil)) los combinan.
63#[derive(Debug, Clone, Copy, PartialEq, Serialize, Deserialize)]
64pub struct EstiloSer {
65 /// **Cabezas de alto** (canon de proporciones). Chibi ≈ 2–4, cartoon ≈ 4–6, realista
66 /// ≈ 7,5. Menos = más tierno / más lejos del valle. La cabeza se dimensiona como
67 /// `altura / cabezas`.
68 pub cabezas: f32,
69 /// **Redondez** `[0,1]` (shape language, eje círculo↔cuadrado). `1` = elipsoides casi
70 /// esféricos + bisel máximo (amable/suave); `0` = ejes desiguales y menos bisel (más
71 /// bloque, estable/fiable). Controla también el detalle sub-voxel horneado.
72 pub redondez: f32,
73 /// **Angulosidad** `[0,1]` (shape language, sesgo triángulo): hombros anchos + cadera
74 /// angosta = silueta dinámica/atlética. `0` = cuerpo parejo (más infantil/tierno).
75 pub angulosidad: f32,
76 /// **Tamaño de ojo** como fracción del radio de la cabeza (Kindchenschema: grande =
77 /// tierno). Chibi ≈ 0,26; adulto estilizado ≈ 0,18.
78 pub ojo_tam: f32,
79 /// **Altura del ojo** en la cara, fracción del radio de cabeza desde el centro (positivo =
80 /// arriba). El lever de ternura MÁS robusto (estudio morfométrico 2022): ojos **por debajo**
81 /// de la mitad (**negativo**) agrandan la frente y suben el appeal. Adulto estilizado ≈ 0
82 /// (línea media, canon Loomis); chibi ≈ −0,2..−0,3 (tercio inferior de la cara). Positivo
83 /// (ojos altos) = más adulto/serio.
84 pub ojo_altura: f32,
85 /// **Cráneo**: modulador LEVE de la altura de la cabeza. La literatura reciente advierte
86 /// que la cara tierna es **redonda/ancha, nunca alargada**, y que la frente se logra
87 /// bajando los ojos (no estirando la cúpula) → este campo casi no estira en Y (clamp a
88 /// ~±6 %) y se conserva sólo por compatibilidad/afinado. `1` = cabeza redonda.
89 pub craneo: f32,
90 /// **Mejilla**: ensancha la mitad inferior de la cabeza (cara redonda de bebé). `1` = sin
91 /// ensanche.
92 pub mejilla: f32,
93 /// **Rechonchez de miembros**: radio de brazos/piernas como fracción de la altura
94 /// (chibi ≈ 0,075; esbelto ≈ 0,05). Miembros gorditos = más tierno.
95 pub extremidad: f32,
96 /// **Panza**: redondez del torso (semieje Y/X). `>1` = barriga/pecho abombado (tierno);
97 /// `1` = torso parejo.
98 pub panza: f32,
99}
100
101impl Default for EstiloSer {
102 /// El default es un **chibi amable** (el look probado): ~2,6 cabezas, redondo, ojos
103 /// grandes a la altura media, cráneo abombado. Reproduce el personaje del `demo_elimon`.
104 fn default() -> Self {
105 Self {
106 cabezas: 2.6,
107 redondez: 1.0,
108 angulosidad: 0.0,
109 ojo_tam: 0.26,
110 ojo_altura: -0.20,
111 craneo: 1.0,
112 mejilla: 1.08,
113 extremidad: 0.075,
114 panza: 1.05,
115 }
116 }
117}
118
119impl EstiloSer {
120 /// Estilo por **edad**: el canon de cabezas y el baby-schema varían con el estadio.
121 /// Bebé = 2 cabezas, ojos enormes y bajos, cráneo grande (máxima ternura); adulto
122 /// estilizado = 4,5 cabezas, ojos moderados a la media (NO 7,5 realista: se busca appeal
123 /// y anti-valle). Escala monótona en el medio.
124 pub fn por_edad(age: Age) -> Self {
125 // Escala del "dial de ternura" (mature→cute) coordinada con las cabezas: menos
126 // cabezas ⇒ ojos más grandes y MÁS BAJOS (tercio inferior), cara más ancha, miembros
127 // más gordos. Adulto estilizado = ojos a la línea media (0), NO 7,5 realista (appeal +
128 // anti-valle). (cabezas, ojo_tam, ojo_altura, craneo, mejilla, extremidad, panza)
129 let (cab, ot, oa, cr, mj, ex, pz) = match age {
130 Age::Baby => (2.0, 0.32, -0.32, 1.0, 1.16, 0.092, 1.22),
131 Age::Child => (3.4, 0.28, -0.24, 1.0, 1.10, 0.080, 1.14),
132 Age::Teen => (4.2, 0.22, -0.12, 1.0, 1.04, 0.066, 1.06),
133 Age::Adult => (4.5, 0.19, -0.04, 1.0, 1.00, 0.060, 1.04),
134 Age::Elder => (4.3, 0.19, -0.05, 1.0, 1.02, 0.062, 1.06),
135 };
136 Self {
137 cabezas: cab,
138 redondez: 1.0,
139 angulosidad: 0.0,
140 ojo_tam: ot,
141 ojo_altura: oa,
142 craneo: cr,
143 mejilla: mj,
144 extremidad: ex,
145 panza: pz,
146 }
147 }
148
149 /// **Arquetipo redondo** (shape language: círculo → amable/suave). Chibi cabezón,
150 /// máxima redondez, ojos grandes: el default reforzado.
151 pub fn amable() -> Self {
152 Self::default()
153 }
154
155 /// **Arquetipo robusto** (shape language: cuadrado → estable/fiable). Menos redondez
156 /// (más bloque), cuerpo ancho y parejo, ojos más chicos, algo más de cabezas.
157 pub fn robusto() -> Self {
158 Self {
159 cabezas: 3.6,
160 redondez: 0.45,
161 angulosidad: 0.15,
162 ojo_tam: 0.19,
163 ojo_altura: -0.02,
164 craneo: 1.0,
165 mejilla: 1.12,
166 extremidad: 0.085,
167 panza: 1.02,
168 }
169 }
170
171 /// **Arquetipo ágil** (shape language: triángulo → dinámico/atlético). Más alto, hombros
172 /// anchos y cadera angosta (angulosidad alta), miembros más finos.
173 pub fn agil() -> Self {
174 Self {
175 cabezas: 4.6,
176 redondez: 0.7,
177 angulosidad: 0.7,
178 ojo_tam: 0.19,
179 ojo_altura: 0.02,
180 craneo: 1.0,
181 mejilla: 0.98,
182 extremidad: 0.055,
183 panza: 0.98,
184 }
185 }
186
187 /// Detalle sub-voxel `(rugosidad, bisel)` horneado por voxel: el bisel sube con la
188 /// redondez (silueta lisa), la rugosidad es un grano de piel constante suave. Es la
189 /// gramática de campo del ser vivo — misma que el terreno, con más redondeo.
190 pub fn detalle(&self) -> (f32, f32) {
191 let bisel = (0.35 + 0.65 * self.redondez.clamp(0.0, 1.0)).clamp(0.0, 1.0);
192 // Grano de piel MUY leve: de cerca (el objetivo del plan) una rugosidad fuerte se
193 // ve como escamas/beading. Suficiente para no quedar plástico plano, no más.
194 (0.06, bisel)
195 }
196}
197
198/// Colores de un ser (`[r,g,b]` en `[0,1]`, como [`Actor`](crate::Actor)): los que la foto
199/// regula (piel/remera/pantalón) + el pelo (derivado o fijo).
200#[derive(Debug, Clone, Copy)]
201pub struct Colores {
202 pub skin: [f32; 3],
203 pub shirt: [f32; 3],
204 pub pants: [f32; 3],
205 pub hair: [f32; 3],
206}
207
208impl Colores {
209 /// Colores desde un [`CharSpec`](crate::CharSpec)-like (piel/remera/pantalón), con un
210 /// pelo derivado (marrón oscuro tintado hacia la piel) para que combine. Usa
211 /// [`con_pelo`](Self::con_pelo) si tienes el color de pelo REAL (de la foto).
212 pub fn nuevos(skin: [f32; 3], shirt: [f32; 3], pants: [f32; 3]) -> Self {
213 // Pelo: oscuro cálido, apenas influido por el tono de piel (combina con retratos).
214 let hair = [
215 (0.18 + skin[0] * 0.12).min(1.0),
216 (0.13 + skin[1] * 0.10).min(1.0),
217 (0.12 + skin[2] * 0.08).min(1.0),
218 ];
219 Self { skin, shirt, pants, hair }
220 }
221
222 /// Colores con **pelo explícito** (p.ej. muestreado FIEL de la foto), no derivado.
223 pub fn con_pelo(skin: [f32; 3], shirt: [f32; 3], pants: [f32; 3], hair: [f32; 3]) -> Self {
224 Self { skin, shirt, pants, hair }
225 }
226}
227
228#[inline]
229fn u8c(c: [f32; 3]) -> [u8; 3] {
230 [
231 (c[0].clamp(0.0, 1.0) * 255.0) as u8,
232 (c[1].clamp(0.0, 1.0) * 255.0) as u8,
233 (c[2].clamp(0.0, 1.0) * 255.0) as u8,
234 ]
235}
236
237/// Rota `v` alrededor del eje X por `a` rad (plano Y-Z; adelante = +Z).
238#[inline]
239fn rot_x(v: Vec3, a: f32) -> Vec3 {
240 let (s, c) = a.sin_cos();
241 Vec3::new(v.x, v.y * c - v.z * s, v.y * s + v.z * c)
242}
243
244/// Rota `v` alrededor del eje Z por `a` rad (plano X-Y; abrir brazo al costado).
245#[inline]
246fn rot_z(v: Vec3, a: f32) -> Vec3 {
247 let (s, c) = a.sin_cos();
248 Vec3::new(v.x * c - v.y * s, v.x * s + v.y * c, v.z)
249}
250
251/// **Construye el humanoide voxel** de `altura_vox` voxels de alto (referencia), con el
252/// `estilo` dado, en la `pose` dada (gestos), coloreado por `col`. Pies en `y≈0`, centrado
253/// en X/Z, mirando a `+Z`. Hornea el detalle sub-voxel por voxel (bisel según la redondez).
254/// Puro y determinista.
255pub fn humanoide_voxel(estilo: &EstiloSer, pose: &Pose, altura_vox: u32, col: Colores) -> VoxelGrid {
256 let h = (altura_vox.max(20)) as f32;
257 let cabezas = estilo.cabezas.clamp(1.6, 8.0);
258
259 // --- Proporciones derivadas del canon de cabezas + baby-schema ---
260 let head_r = h / (2.0 * cabezas); // radio de cabeza = ½ (altura / cabezas)
261 // La cabeza tierna es REDONDA/ancha, nunca alargada (lit. 2022): el cráneo casi no estira
262 // en Y (±6 %) — la frente grande la da bajar los ojos, no una cúpula alta.
263 let head_ry = head_r * (1.0 + 0.2 * (estilo.craneo - 1.0)).clamp(0.94, 1.06);
264 // La cabeza corona la figura; su tope roza `h`.
265 let head_cy = h - head_ry * 1.02;
266 let neck = head_r * 0.14;
267 let shoulder_y = (head_cy - head_ry - neck).max(head_r);
268
269 // Torso y piernas se reparten [0, shoulder_y]: chibi = piernas cortas. La fracción de
270 // pierna sube con `cabezas` (más alto = piernas proporcionalmente más largas).
271 let leg_frac = (0.28 + 0.055 * (cabezas - 2.0)).clamp(0.28, 0.52);
272 let hip_y = shoulder_y * leg_frac;
273 let torso_cy = (hip_y + shoulder_y) * 0.5;
274 let torso_ry = (shoulder_y - hip_y) * 0.5;
275 // Ancho del torso: la cabeza debe DOMINAR (head:torso ≈ 1:0,8, cabeza mayor). Base por
276 // altura, modulada por redondez (redondo = más parejo).
277 let torso_rx = h * (0.13 + 0.05 * estilo.redondez);
278 // Profundidad casi igual al ancho (torso REDONDO, no una losa chata): un torso poco
279 // profundo presenta una cara frontal casi plana donde la normal varía lentísimo → el
280 // escalonado residual del gradiente se ve como anillos anchos. Redondearlo aprieta los
281 // pasos y da una panza de peluche.
282 let torso_rz = torso_rx * 0.92;
283
284 let limb_r = h * estilo.extremidad;
285
286 // Shape language triángulo: hombros anchos, cadera angosta con la angulosidad. Los hombros
287 // se anclan JUSTO AFUERA del torso (≥ `torso_rx`) para que los brazos cuelguen al costado con
288 // una junta limpia — hundirlos DENTRO del torso (como antes, 0,72·torso_rx) enterraba la
289 // cápsula del brazo y la normal ancha escalonaba esa junta sepultada → anillos en la panza.
290 let ang = estilo.angulosidad.clamp(0.0, 1.0);
291 let shoulder_x = torso_rx + limb_r * (0.35 + 0.9 * ang);
292 let hip_x = torso_rx * (0.55 - 0.18 * ang);
293 let leg_len = hip_y; // el pie llega a ~0
294 let arm_len = (shoulder_y - hip_y) * 1.02;
295
296 // --- Grid: bbox de la figura + margen (para que el bisel no toque el borde) ---
297 let half_w = (shoulder_x + limb_r * 1.4).max(torso_rx).max(head_r * estilo.mejilla) + 2.0;
298 let half_d = (torso_rz + limb_r).max(head_r) + arm_len * 0.4 + 2.0;
299 let gw = (half_w * 2.0).ceil() as u32 + 1;
300 let gd = (half_d * 2.0).ceil() as u32 + 1;
301 let gh = (h + head_ry * 0.3).ceil() as u32 + 2;
302 let mut g = VoxelGrid::new([gw, gh, gd]);
303 let cx = gw as f32 * 0.5;
304 let cz = gd as f32 * 0.5;
305 let base = Vec3::new(cx, 0.0, cz);
306
307 // Detalle sub-voxel del cuerpo (bisel por redondez) — pincel para todo lo que estampe.
308 let (rug, bisel) = estilo.detalle();
309 g.set_detail_brush(rug, bisel);
310
311 let skin = u8c(col.skin);
312 let shirt = u8c(col.shirt);
313 let pants = u8c(col.pants);
314 let hair = u8c(col.hair);
315
316 // Transform del cuerpo superior (torso/cabeza/brazos): rebote `bob` + inclinación `lean`
317 // alrededor de la cadera (pivote en `hip_y`). Las piernas quedan plantadas.
318 let bob = pose.bob * h * 0.5;
319 let upper = |local_y: f32, off: Vec3| -> Vec3 {
320 // punto (0, local_y, 0)+off, inclinado por lean sobre el pivote de cadera y subido bob
321 let rel = Vec3::new(off.x, local_y - hip_y, off.z);
322 let r = rot_x(rel, pose.lean);
323 base + Vec3::new(r.x, hip_y + r.y + bob, r.z)
324 };
325
326 // --- Piernas: cápsulas rechonchas, articuladas en la cadera (leg swing en X) ---
327 for (sx, swing) in [(-1.0f32, pose.leg_l), (1.0, pose.leg_r)] {
328 let hip = base + Vec3::new(sx * hip_x, hip_y, 0.0);
329 let dir = rot_x(Vec3::new(0.0, -leg_len, 0.0), swing);
330 let foot = hip + dir;
331 capsula(&mut g, hip, foot, limb_r * 1.05, pants);
332 }
333
334 // --- Torso: elipsoide redondo (panza) ---
335 let torso_c = upper(torso_cy, Vec3::ZERO);
336 elipsoide(&mut g, torso_c, Vec3::new(torso_rx, torso_ry * estilo.panza, torso_rz), shirt);
337
338 // --- Brazos: cápsulas al costado, articuladas en el hombro (out en Z, swing en X) ---
339 // Splay base: aun en reposo los brazos abren un poco hacia afuera para NO fundirse con el
340 // torso ni juntar las manos al frente (leía como "manos atadas"). Se suma a la apertura del gesto.
341 let base_out = 0.16;
342 for (sx, swing, out) in [(-1.0f32, pose.arm_l, pose.arm_l_out), (1.0, pose.arm_r, pose.arm_r_out)] {
343 let shoulder = upper(shoulder_y, Vec3::new(sx * shoulder_x, 0.0, 0.0));
344 // dirección local del brazo colgando, rotada: primero swing (X), luego apertura (Z).
345 let mut dir = rot_x(Vec3::new(0.0, -arm_len, 0.0), swing);
346 dir = rot_z(dir, sx * (out + base_out)); // apertura espejada por lado
347 // el brazo también acompaña el lean del cuerpo superior
348 dir = rot_x(dir, pose.lean);
349 let hand = shoulder + dir;
350 capsula(&mut g, shoulder, hand, limb_r, shirt);
351 // Mano: esferita de piel en la punta (apenas mayor que el brazo, no un guante gigante).
352 elipsoide(&mut g, hand, Vec3::splat(limb_r * 0.98), skin);
353 }
354
355 // --- Cabeza + cara (baby-schema) ---
356 let head_c = upper(head_cy, Vec3::ZERO);
357 // Cabeza: elipsoide con cúpula (craneo) arriba y mejilla abajo. La construimos como un
358 // elipsoide con radios asimétricos por hemisferio via `elipsoide_mejilla`.
359 let head_rx = head_r * estilo.mejilla;
360 elipsoide_cabeza(&mut g, head_c, head_r, head_rx, head_ry, skin);
361
362 // **Zona de bigote/barba = coloración PLANA, sin sustancia** (no una boca protuberante,
363 // que parecía un pico de pato): re-tiñe la piel de la mitad inferior FRONTAL de la cara a
364 // un tono apenas más apagado/oscuro (sombra de barba). No agrega geometría; se aplica
365 // ANTES del pelo/ojos para no pisarlos. Sutil a propósito (que no lea como máscara).
366 let eye_y0 = head_c.y + estilo.ojo_altura * head_r;
367 tint_barba(&mut g, head_c, head_rx, head_ry, head_r, eye_y0, skin);
368
369 // Pelo: **casquete alto** sobre la corona, corrido hacia atrás (−Z) para dejar la FRENTE
370 // y las mejillas de piel a la vista (la frente grande es el rasgo tierno). No baja hasta
371 // los ojos: recorte bien por encima → cara abierta, no un antifaz enmarcado.
372 let eye_y = head_c.y + estilo.ojo_altura * head_r;
373 elipsoide_min_y(
374 &mut g,
375 head_c + Vec3::new(0.0, head_ry * 0.40, -head_r * 0.14),
376 Vec3::new(head_rx * 1.02, head_ry * 0.80, head_r * 1.0),
377 hair,
378 eye_y + head_r * 0.58,
379 );
380
381 // Ojos: **esclera clara + pupila oscura + chispa** (NO un óvalo negro suelto, que a esta
382 // resolución + isosuperficie leía como un HUECO/cuenca vacía = cara de monstruo). El blanco
383 // domina y "abre" el ojo; la pupila oscura, más chica y al frente-centro, da la mirada; una
384 // chispa arriba-interior le pone vida. Anchos > altos (ojo infantil), BIEN separados, con piel
385 // en medio y alrededor (no antifaz). A/por debajo de la media (`ojo_altura`). `head_pitch` tilta.
386 let er = head_r * estilo.ojo_tam;
387 let ex = head_rx * 0.5;
388 let zf = head_r * 0.80;
389 let eoff = eye_y - head_c.y;
390 for s in [-1.0f32, 1.0] {
391 let eye = head_c + rot_x(Vec3::new(s * ex, eoff, zf), pose.head_pitch);
392 // Esclera: óvalo claro, ancho, apenas saliente al frente para que no se hunda.
393 elipsoide(&mut g, eye, Vec3::new(er * 1.06, er * 0.86, er * 0.62), [240, 241, 244]);
394 // Pupila/iris: oscura, ~mitad, corrida al FRENTE (+Z) y apenas hacia adentro (mirada
395 // convergente amable) y abajo. Va DESPUÉS de la esclera para pisarla en el centro.
396 let pupil = head_c + rot_x(Vec3::new(s * ex - s * er * 0.12, eoff - er * 0.08, zf + er * 0.28), pose.head_pitch);
397 elipsoide(&mut g, pupil, Vec3::new(er * 0.52, er * 0.6, er * 0.5), [40, 32, 46]);
398 // Chispa (arriba-interior de la pupila) — grande para que lea de lejos.
399 let spark = head_c + rot_x(Vec3::new(s * ex - s * er * 0.28, eoff + er * 0.34, zf + er * 0.5), pose.head_pitch);
400 elipsoide(&mut g, spark, Vec3::new(er * 0.3, er * 0.3, er * 0.34), [250, 251, 253]);
401 }
402
403 // **Boca = sonrisa como tint PLANO** (sin geometría protuberante: una boca de color en
404 // relieve leía como pico de pato). Re-tiñe una banda corta, curvada hacia ARRIBA (feliz),
405 // de la piel frontal-baja de la cara a un tono cálido apagado. Pequeña y centrada. Va
406 // después de barba/ojos para no pisarse.
407 let boca_y = eye_y - head_r * 0.44;
408 sonrisa(&mut g, head_c, head_rx, head_r, boca_y, skin);
409
410 g.clear_detail_brush();
411 g.reset_dirty();
412 g
413}
414
415/// Rellena un elipsoide de semiejes `r` centrado en `c` con `color`.
416fn elipsoide(g: &mut VoxelGrid, c: Vec3, r: Vec3, color: [u8; 3]) {
417 elipsoide_min_y(g, c, r, color, f32::NEG_INFINITY);
418}
419
420/// Elipsoide recortado por abajo (`y >= y_min`) — para casquetes de pelo.
421fn elipsoide_min_y(g: &mut VoxelGrid, c: Vec3, r: Vec3, color: [u8; 3], y_min: f32) {
422 let [dx, dy, dz] = g.dim();
423 let x0 = (c.x - r.x).floor().max(0.0) as u32;
424 let x1 = (c.x + r.x).ceil().min(dx as f32) as u32;
425 let y0 = (c.y - r.y).floor().max(0.0).max(y_min.max(0.0)) as u32;
426 let y1 = (c.y + r.y).ceil().min(dy as f32) as u32;
427 let z0 = (c.z - r.z).floor().max(0.0) as u32;
428 let z1 = (c.z + r.z).ceil().min(dz as f32) as u32;
429 for x in x0..x1 {
430 for y in y0..y1 {
431 if (y as f32) < y_min {
432 continue;
433 }
434 for z in z0..z1 {
435 let d = Vec3::new(
436 (x as f32 + 0.5 - c.x) / r.x,
437 (y as f32 + 0.5 - c.y) / r.y,
438 (z as f32 + 0.5 - c.z) / r.z,
439 );
440 if d.length_squared() <= 1.0 {
441 g.set(x, y, z, color);
442 }
443 }
444 }
445 }
446}
447
448/// Cabeza: elipsoide con **cúpula arriba** (semieje Y superior) y **mejillas** (radio X
449/// pleno abajo, afinado arriba) — la forma del baby-schema. `rx` ya lleva el ensanche de
450/// mejilla; arriba de la mitad se afina hacia `head_r` para no quedar cuadrada.
451fn elipsoide_cabeza(g: &mut VoxelGrid, c: Vec3, head_r: f32, rx: f32, ry: f32, color: [u8; 3]) {
452 let [dx, dy, dz] = g.dim();
453 let x0 = (c.x - rx).floor().max(0.0) as u32;
454 let x1 = (c.x + rx).ceil().min(dx as f32) as u32;
455 let y0 = (c.y - ry).floor().max(0.0) as u32;
456 let y1 = (c.y + ry).ceil().min(dy as f32) as u32;
457 let z0 = (c.z - rx).floor().max(0.0) as u32;
458 let z1 = (c.z + rx).ceil().min(dz as f32) as u32;
459 for y in y0..y1 {
460 let ty = (y as f32 + 0.5 - c.y) / ry; // -1..1
461 // Radio horizontal por altura: mejilla plena abajo (ty<0), afina hacia head_r arriba.
462 let rh = if ty >= 0.0 { rx + (head_r - rx) * ty } else { rx };
463 let rz = rh * 0.96;
464 for x in x0..x1 {
465 for z in z0..z1 {
466 let dxx = (x as f32 + 0.5 - c.x) / rh;
467 let dzz = (z as f32 + 0.5 - c.z) / rz;
468 if dxx * dxx + ty * ty + dzz * dzz <= 1.0 {
469 g.set(x, y, z, color);
470 }
471 }
472 }
473 }
474}
475
476/// **Sombra de barba/bigote como tint PLANO** (sin geometría): re-tiñe la piel de la mitad
477/// inferior FRONTAL de la cara a un tono apenas más oscuro/apagado. Sólo toca voxels que HOY
478/// son piel (`== skin`), así no pisa ojos/pelo (que se estampan después). Sutil a propósito.
479fn tint_barba(g: &mut VoxelGrid, c: Vec3, rx: f32, ry: f32, head_r: f32, eye_y: f32, skin: [u8; 3]) {
480 // Barba = piel un 6% más oscura, apenas más fría (sombra tenue, no una máscara: fuerte
481 // ensuciaba la cara y la volvía adusta/monstruosa).
482 let beard = [
483 (skin[0] as f32 * 0.94) as u8,
484 (skin[1] as f32 * 0.93) as u8,
485 (skin[2] as f32 * 0.94) as u8,
486 ];
487 let [dx, dy, dz] = g.dim();
488 // De la barbilla hasta un poco por debajo de los ojos (zona bigote+barba+mentón).
489 let y0 = (c.y - ry).floor().max(0.0) as u32;
490 let y1 = (eye_y - head_r * 0.30).floor().max(0.0).min(dy as f32) as u32;
491 let x0 = (c.x - rx).floor().max(0.0) as u32;
492 let x1 = (c.x + rx).ceil().min(dx as f32) as u32;
493 // Sólo el frente de la cara (+Z), no la nuca/mandíbula lateral.
494 let z0 = (c.z + head_r * 0.28).floor().max(0.0) as u32;
495 let z1 = (c.z + head_r * 1.1).ceil().min(dz as f32) as u32;
496 for x in x0..x1 {
497 for y in y0..y1 {
498 for z in z0..z1 {
499 if let Some(px) = g.get(x, y, z) {
500 if px[3] > 0 && [px[0], px[1], px[2]] == skin {
501 g.set(x, y, z, beard);
502 }
503 }
504 }
505 }
506 }
507}
508
509/// **Sonrisa como tint PLANO** (sin geometría): re-tiñe una banda corta de piel FRONTAL a la
510/// altura `boca_y`, curvada hacia arriba en los extremos (feliz), a un tono cálido apagado
511/// (labios/sombra de boca, no rojo saturado que a esta resolución grita "pico de pato"). Sólo
512/// pisa voxels que HOY son piel, así no borra ojos/pelo. Centrada en X, en el hemisferio +Z.
513fn sonrisa(g: &mut VoxelGrid, c: Vec3, rx: f32, head_r: f32, boca_y: f32, skin: [u8; 3]) {
514 // Boca = piel bastante más oscura y algo más cálida (rojiza), pero NO roja pura.
515 let mouth = [
516 (skin[0] as f32 * 0.72 + 22.0).min(255.0) as u8,
517 (skin[1] as f32 * 0.55).min(255.0) as u8,
518 (skin[2] as f32 * 0.55).min(255.0) as u8,
519 ];
520 let [dx, dy, dz] = g.dim();
521 let half_w = rx * 0.42; // media boca
522 let thick = head_r * 0.12; // grosor vertical de la línea
523 let curve = head_r * 0.22; // cuánto suben los extremos (sonrisa)
524 let x0 = (c.x - half_w).floor().max(0.0) as u32;
525 let x1 = (c.x + half_w).ceil().min(dx as f32) as u32;
526 // Sólo el frente de la cara (+Z).
527 let z0 = (c.z + head_r * 0.5).floor().max(0.0) as u32;
528 let z1 = (c.z + head_r * 1.1).ceil().min(dz as f32) as u32;
529 for x in x0..x1 {
530 // Altura de la línea de sonrisa en esta X: sube hacia los extremos (parábola).
531 let t = ((x as f32 + 0.5 - c.x) / half_w).clamp(-1.0, 1.0);
532 let ly = boca_y + curve * t * t;
533 let y0 = (ly - thick * 0.5).floor().max(0.0) as u32;
534 let y1 = (ly + thick * 0.5).ceil().min(dy as f32) as u32;
535 for y in y0..y1 {
536 for z in z0..z1 {
537 if let Some(px) = g.get(x, y, z) {
538 if px[3] > 0 && [px[0], px[1], px[2]] == skin {
539 g.set(x, y, z, mouth);
540 }
541 }
542 }
543 }
544 }
545}
546
547/// Cápsula (cilindro con tapas esféricas) de radio `r` entre los puntos `a` y `b`.
548fn capsula(g: &mut VoxelGrid, a: Vec3, b: Vec3, r: f32, color: [u8; 3]) {
549 let [dx, dy, dz] = g.dim();
550 let lo = a.min(b) - Vec3::splat(r + 1.0);
551 let hi = a.max(b) + Vec3::splat(r + 1.0);
552 let x0 = lo.x.floor().max(0.0) as u32;
553 let x1 = hi.x.ceil().min(dx as f32) as u32;
554 let y0 = lo.y.floor().max(0.0) as u32;
555 let y1 = hi.y.ceil().min(dy as f32) as u32;
556 let z0 = lo.z.floor().max(0.0) as u32;
557 let z1 = hi.z.ceil().min(dz as f32) as u32;
558 let ab = b - a;
559 let ab2 = ab.length_squared().max(1e-6);
560 let r2 = r * r;
561 for x in x0..x1 {
562 for y in y0..y1 {
563 for z in z0..z1 {
564 let p = Vec3::new(x as f32 + 0.5, y as f32 + 0.5, z as f32 + 0.5);
565 let t = ((p - a).dot(ab) / ab2).clamp(0.0, 1.0);
566 let closest = a + ab * t;
567 if (p - closest).length_squared() <= r2 {
568 g.set(x, y, z, color);
569 }
570 }
571 }
572 }
573}
574
575#[cfg(test)]
576mod tests {
577 use super::*;
578
579 fn solids(g: &VoxelGrid) -> usize {
580 let [w, h, d] = g.dim();
581 let mut n = 0;
582 for x in 0..w {
583 for y in 0..h {
584 for z in 0..d {
585 if g.is_solid(x as i32, y as i32, z as i32) {
586 n += 1;
587 }
588 }
589 }
590 }
591 n
592 }
593
594 fn col() -> Colores {
595 Colores::nuevos([0.85, 0.68, 0.54], [0.2, 0.6, 0.55], [0.18, 0.22, 0.34])
596 }
597
598 #[test]
599 fn construye_un_ser_con_volumen() {
600 let g = humanoide_voxel(&EstiloSer::default(), &Pose::default(), 46, col());
601 assert!(solids(&g) > 3000, "el ser tiene volumen: {}", solids(&g));
602 }
603
604 #[test]
605 fn pies_en_el_piso() {
606 // El voxel sólido más bajo está cerca de y=0 (pies apoyados).
607 let g = humanoide_voxel(&EstiloSer::default(), &Pose::default(), 46, col());
608 let [w, h, d] = g.dim();
609 let mut ymin = h;
610 for x in 0..w {
611 for y in 0..h {
612 for z in 0..d {
613 if g.is_solid(x as i32, y as i32, z as i32) {
614 ymin = ymin.min(y);
615 }
616 }
617 }
618 }
619 assert!(ymin <= 2, "pies cerca del piso: ymin={ymin}");
620 }
621
622 #[test]
623 fn el_bebe_es_mas_cabezon_que_el_adulto() {
624 // Menos cabezas ⇒ la cabeza ocupa una fracción mayor de la altura.
625 let baby = EstiloSer::por_edad(Age::Baby);
626 let adult = EstiloSer::por_edad(Age::Adult);
627 assert!(baby.cabezas < adult.cabezas, "bebé menos cabezas");
628 // Radio de cabeza relativo a la altura.
629 let hr = |e: &EstiloSer| 1.0 / (2.0 * e.cabezas);
630 assert!(hr(&baby) > hr(&adult) + 0.05, "bebé cabezón");
631 }
632
633 #[test]
634 fn los_gestos_cambian_la_silueta() {
635 // Festejar (brazos arriba) ensancha/eleva la ocupación respecto a idle.
636 let idle = humanoide_voxel(&EstiloSer::default(), &Pose::default(), 46, col());
637 let cheer = crate::Clip::Cheer.pose(1.2);
638 let festeja = humanoide_voxel(&EstiloSer::default(), &cheer, 46, col());
639 // Ocupación en la franja alta (por encima de la cabeza-hombro) crece al levantar brazos.
640 let alto = |g: &VoxelGrid| {
641 let [w, h, d] = g.dim();
642 let y0 = h * 3 / 4;
643 let mut n = 0;
644 for x in 0..w {
645 for y in y0..h {
646 for z in 0..d {
647 if g.is_solid(x as i32, y as i32, z as i32) {
648 n += 1;
649 }
650 }
651 }
652 }
653 n
654 };
655 assert!(alto(&festeja) > alto(&idle), "festejar sube volumen alto: {} vs {}", alto(&festeja), alto(&idle));
656 }
657
658 #[test]
659 fn hornea_detalle_por_voxel() {
660 // Con redondez alta el bisel horneado es alto (silueta lisa).
661 let g = humanoide_voxel(&EstiloSer::default(), &Pose::default(), 40, col());
662 let [w, h, d] = g.dim();
663 let mut con_detalle = 0;
664 for x in 0..w {
665 for y in 0..h {
666 for z in 0..d {
667 if g.is_solid(x as i32, y as i32, z as i32) {
668 if let Some(det) = g.detail_at(x, y, z) {
669 if det != [0, 0] {
670 con_detalle += 1;
671 }
672 }
673 }
674 }
675 }
676 }
677 assert!(con_detalle > 1000, "el cuerpo lleva detalle por voxel: {con_detalle}");
678 }
679
680 #[test]
681 fn presets_de_arquetipo_difieren() {
682 assert!(EstiloSer::amable().redondez > EstiloSer::robusto().redondez);
683 assert!(EstiloSer::agil().angulosidad > EstiloSer::amable().angulosidad);
684 assert!(EstiloSer::agil().cabezas > EstiloSer::amable().cabezas);
685 }
686}