nx_sdfrender_attribution_candidate_t344.nx source
↩ module page · 1821 lines · 109622 B
1// nx_sdfrender.nx -- sovereign software GPU, SMOOTH-UNION path (operator 2026-07-04: make the body CONTINUOUS,
2// not jointed ellipsoids). Instead of rasterizing separate ellipsoid surfaces, define the body as an IMPLICIT
3// FIELD -- a smooth-minimum (smin) union of ellipsoid SDFs -- and RAY-MARCH it per pixel: the parts BLEND into
4// one continuous surface (arm melts into shoulder, thigh into hip). Per-pixel normal from the SDF gradient ->
5// Phong. ALL INTEGER fx1024 (deterministic, VM-vettable). This is the same technique modern GPUs use for
6// metaball/organic surfaces -- built entirely on our own stack. license_tier: ORIGINAL
7import "nx_syscalls.nx"
8import "nx_itrig.nx"
9import "nx_vecmath.nx"
10import "nx_relief_lib.nx"
11const PARTS_MAGIC_1206: i64 = 1206
12const PARTS_MAGIC_1330: i64 = 1330
13const PARTS_MAGIC_1024: i64 = 1024
14// The skin-noise hash takes signed model coordinates, and integer division truncates TOWARD ZERO, so a
15// negative coordinate would fold onto its positive mirror and band the shading symmetrically about the
16// origin. This bias lifts every coordinate positive before the divide. It arrived as PARTS_MAGIC_8192,
17// named after its own value, which said nothing about why a hash input needs an offset at all.
18const SK_HASH_BIAS: i64 = 8192
19// The it_sin4096 FIXED-POINT UNIT once lived here a SECOND time, as PARTS_MAGIC_4096 -- an independent
20// copy of the very same quantity nx_itrig defines for itself, under a different name, with nothing tying
21// the two together. Change the trig scale and this file would have gone on dividing by its own 4096.
22// That is the duplicate-ruler defect, and the auto-hoister MANUFACTURED it by naming one quantity twice
23// in two files. It now uses IT_FX from the library that owns it.
24const PARTS_MAGIC_92821: i64 = 92821
25const PARTS_MAGIC_68917: i64 = 68917
26const PARTS_MAGIC_40503: i64 = 40503
27// PARK-MILLER "MINIMAL STANDARD" LEHMER PRNG -- h = (h * 48271) mod (2^31 - 1). Both numbers are NAMED
28// QUANTITIES IN THE LITERATURE: 48271 is the revised Park-Miller multiplier (16807 was the 1988 original)
29// and 2147483647 is the Mersenne prime 2^31 - 1 that is its modulus. They arrived here as
30// PARTS_MAGIC_48271 and PARTS_MAGIC_2147483647, which is the auto-hoist at its worst: a reader who sees
31// (h * 48271) % 2147483647 RECOGNISES the algorithm on sight, and a reader who sees the hoisted form
32// cannot -- nor can they grep for it. The hoist did not fail to name these; it ERASED names the field had
33// already given them.
34const MINSTD_MULT: i64 = 48271
35const MINSTD_MOD: i64 = 2147483647
36const PARTS_MAGIC_999999: i64 = 999999
37const PARTS_MAGIC_1048576: i64 = 1048576
38const PARTS_MAGIC_1250: i64 = 1250
39const PARTS_MAGIC_3600: i64 = 3600
40const PARTS_MAGIC_2600: i64 = 2600
41const PARTS_MAGIC_262144: i64 = 262144
42const PARTS_MAGIC_9000: i64 = 9000
43const PARTS_MAGIC_1445: i64 = 1445
44const PARTS_MAGIC_3400: i64 = 3400
45const PARTS_MAGIC_4200: i64 = 4200
46const PARTS_MAGIC_65536: i64 = 65536
47const PARTS_MAGIC_8201: i64 = 8201
48const PARTS_MAGIC_2048: i64 = 2048
49
50const W: i64 = 512
51const H: i64 = 384
52const HW: i64 = 256
53const HH: i64 = 192
54const FX: i64 = 1024 // fixed-point unit (1.0)
55const FOCAL: i64 = 586 // ray focal (fx1024 ndc scale) -- scaled with width to keep the FOV
56const KBLEND: i64 = 130 // smin blend radius: joints fuse smoothly but limbs stay DISTINCT (340 melted the whole figure into a blob)
57const NPART: i64 = 18
58const PARTS_CAP: i64 = 48 // physical part-array capacity (room for a carved face; side slots moved out)
59// ============================================================================
60// THE ARENA LAYOUT IS DERIVED FIELD BY FIELD. Until 2026-08-28 all twenty offsets
61// below were hand-computed ABSOLUTE byte constants -- 1572864, 1575168, 1575176
62// and so on -- each with the arithmetic that produced it written in the comment
63// BESIDE the value. That is the estate's banked anti-pattern at its purest: a
64// hand-computed number beside the expression that generates it is a SECOND COPY
65// of that expression's result, and the two drift in silence. Change PARTS_CAP
66// from 48 and every offset after O_PARTS is wrong -- nothing fails to compile,
67// nothing raises, and each table simply reads and writes into its neighbour.
68// Silent memory corruption, in the renderer every SDF organ in the estate shares.
69// Each offset is now the previous field's offset plus that field's OWN size, so
70// the layout cannot disagree with itself and adding a field is ONE line instead
71// of a recomputation of everything downstream.
72// NEUTRALITY IS PROVABLE RATHER THAN ASSERTED: every derived value equals the
73// constant it replaces, so a rebuild must reproduce the previous binary BYTE FOR
74// BYTE, and if it does not then this refactor is wrong and the size says so.
75// ============================================================================
76const SDF_I64: i64 = 8
77const SDF_FB_BYTES: i64 = W * H * SDF_I64 // the framebuffer IS the first field; its size is not a guess
78const SDF_PART_FIELDS: i64 = 6 // {cx,cy,cz,rx,ry,rz}
79const SDF_ROT_FIELDS: i64 = 2 // {cos256, sin256}
80const O_FB: i64 = 0
81const O_PARTS: i64 = O_FB + SDF_FB_BYTES // W*H*8 ; up to PARTS_CAP*6 i64 {cx,cy,cz,rx,ry,rz}
82const O_KBLEND: i64 = O_PARTS + PARTS_CAP * SDF_PART_FIELDS * SDF_I64 // per-body smin blend; 0 => default KBLEND
83const O_NPART: i64 = O_KBLEND + SDF_I64 // active part count (t2mesh objects vary); 0 => default NPART
84const O_OPS: i64 = O_NPART + SDF_I64 // PARTS_CAP i64: per-part op -- 0=union(add), 1=carve(smooth-subtract)
85const O_MATS: i64 = O_OPS + PARTS_CAP * SDF_I64 // PARTS_CAP i64: per-part MATERIAL -- 0=skin, 1=EYE
86const O_KB2: i64 = O_MATS + PARTS_CAP * SDF_I64 // PARTS_CAP i64: PER-PART smin blend radius; 0 = inherit.
87 // (limbs need k~130 to fuse; facial features need k~8 to stay crisp -- ONE
88 // field, per-part k is what makes a face-on-a-body expressible at all)
89const O_ROT: i64 = O_KB2 + PARTS_CAP * SDF_I64 // PARTS_CAP*2 i64: per-part PITCH orientation (cos256, sin256); 0,0 =
90 // identity. Lets a primitive follow the face's ANGLED planes (nose slope,
91 // brow arch, cheekbone) instead of being stuck axis-aligned = beyond ellipsoids.
92const O_FLOOR: i64 = O_ROT + PARTS_CAP * SDF_ROT_FIELDS * SDF_I64 // 1 i64: 1 = render a GROUND PLANE (figures only)
93const O_MTXAMP: i64 = O_FLOOR + SDF_I64 // 1 i64: micro-texture amplitude scale (256 = 1.0x) -- the reverse-judge knob
94// ★A-R1 REFERENCE PROJECTION (2026-07-07 "go A"): frontal projective texture -- our OWN Z-Image photoreal
95// reference projected onto the face geometry as albedo (the photogrammetry front-projection move; typography
96// discipline = ground in the reference, stop sculpting blind). NATIVE lane: O_FTEX holds an absolute pointer
97// (fresh arenas are ZERO -> projection OFF -> byte-identical procedural albedo for every existing consumer).
98// Mapping: photo_u = uc + px*su/1024 ; photo_v = vc - py*sv/1024 (head-LOCAL model coords, sdf_face arenas).
99const O_FTEX: i64 = O_MTXAMP + SDF_I64 // *u8 RGB8 rows (w*h*3); 0 = OFF
100const O_FTEXW: i64 = O_FTEX + SDF_I64
101const O_FTEXH: i64 = O_FTEXW + SDF_I64
102const O_FPUC: i64 = O_FTEXH + SDF_I64
103const O_FPVC: i64 = O_FPUC + SDF_I64
104const O_FPSU: i64 = O_FPVC + SDF_I64
105const O_FPSV: i64 = O_FPSU + SDF_I64
106const O_FPVLO: i64 = O_FPSV + SDF_I64 // photo-v projection BAND [vlo,vhi): reference-specific (hairline..chin);
107const O_FPVHI: i64 = O_FPVLO + SDF_I64 // vhi<=0 -> full [1,th-2). Photo-space, so transform-invariant (person path).
108// ★SOVEREIGN STEREO (B-R9, NO WebXR): a lateral EYE OFFSET (model units) along the camera-right axis shifts the
109// ray ORIGIN -> translational parallax = a true stereo eye view, rendered by OUR own soft-GPU. 0 = mono (byte-
110// identical fallback). Render L(-ipd/2) + R(+ipd/2) for a VR pair; the display is ours, not a web-XR standard.
111const O_EYE: i64 = O_FPVHI + SDF_I64 // 1 i64: lateral eye offset (model units); 0 = centered/mono
112// ROLL, the frontal-plane orientation. sdf_ellip_rot rotates only the (y,z) pair -- px passes through
113// untouched -- so the primitive was PITCH-ONLY and could not express a rotation in the frontal plane at
114// all. That is what makes a canthal tilt inexpressible on the aesthetictwin board, and it is why this
115// field exists. It is APPENDED rather than folded into O_ROT because widening O_ROT in place would move
116// every offset after it; here it costs one derived line and moves nothing. A fresh arena is zero-filled,
117// so roll reads as identity and every existing consumer is byte-identical BY CONSTRUCTION.
118const O_ROLL: i64 = O_EYE + SDF_I64 // PARTS_CAP*2 i64: per-part ROLL orientation (cos256, sin256)
119// THE ARENA ENDS WHERE ITS LAST FIELD ENDS. sdf_bytes used to read O_ROT + PARTS_CAP*2*8 + 4096: sized
120// from a MIDDLE field plus a 4096-byte pad, so every field added after O_ROT was squatting in slack and
121// the size silently stopped describing the contents. Derived from the last field, the arena cannot be
122// too small and the pad cannot be mistaken for spare room.
123// LID-SHELL PRIMITIVE PARAMETERS (aesthetictwin AT39, 2026-09-17). An ellipsoid has no margin: at its edge the surface curves
124// away behind the globe, so two ellipsoid lids leave no recessed aperture and no canthus for any instrument to find (the
125// fissure gate read 1 of 8 on the canon face, and the generator's own truth scan refused every genome). Op SDF_OP_LIDSHELL
126// makes a part a spherical SHELL over the globe with an ALMOND opening cut straight through it: the opening is the
127// intersection of two discs that both pass through the two canthi, so the canthi are explicit geometry, the lid margin has the
128// shell's real thickness, and the frontal-plane tilt of the opening is the part's ROLL -- the field reserved above for exactly
129// this and unread until now. APPENDED after O_ROLL so no offset moves; a fresh arena is zero-filled and no part carries the
130// op, so every existing consumer is byte-identical by construction, and the grown arena still fits the page count the old
131// size rounded up to (1580272 against 1581056), so a consumer that sized its arena before this field cannot be overrun.
132const SDF_PRIM_FIELDS: i64 = 6
133const SDF_PR_HALFW: i64 = 0 // half the fissure width: the canthi sit at (-halfw, 0) and (+halfw, 0) before roll
134const SDF_PR_UP: i64 = 1 // rise of the upper lid arc above the canthal line
135const SDF_PR_LOW: i64 = 2 // drop of the lower lid arc below it
136const O_PRIM: i64 = O_ROLL + PARTS_CAP * SDF_ROT_FIELDS * SDF_I64 // PARTS_CAP*6 i64: per-part primitive parameters
137const SDF_ARENA_BYTES: i64 = O_PRIM + PARTS_CAP * SDF_PRIM_FIELDS * SDF_I64
138const SDF_OP_UNION: i64 = 0
139const SDF_OP_CARVE: i64 = 1
140const SDF_OP_LIDSHELL: i64 = 2
141func sdf_set_facetex(base: i64, tex: i64, w: i64, h: i64, uc: i64, vc: i64, su: i64, sv: i64) -> i64 {
142 let t: *i64 = (base + O_FTEX) as *i64
143 t[0] = tex
144 t[1] = w
145 t[2] = h
146 t[3] = uc
147 t[4] = vc
148 t[5] = su
149 t[6] = sv
150 return 0
151}
152// photo-v BAND for the projection (reference-specific: below the hairline, above/incl the chin). Photo-space,
153// so the SAME band serves face- and person-space projections of one reference.
154func sdf_set_facetex_band(base: i64, vlo: i64, vhi: i64) -> i64 {
155 let t: *i64 = (base + O_FPVLO) as *i64
156 t[0] = vlo
157 t[1] = vhi
158 return 0
159}
160// PERSON-space projection (A-R2c): the grafted head = the face scaled 5/16 + shifted +1330 in y, so
161// face-local coords are pxf = px*16/5, pyf = (py-1330)*16/5 -- a LINEAR transform that folds entirely into
162// the mapping constants. Pass the SAME face-space constants; this derives the person-space ones. The v band
163// then lands exactly on the grafted head (body coords map far past the v ceiling -> auto-clipped).
164func sdf_set_facetex_person(base: i64, tex: i64, w: i64, h: i64, uc: i64, vc: i64, su: i64, sv: i64) -> i64 {
165 let sup: i64 = su * 16 / 5
166 let svp: i64 = sv * 16 / 5
167 let vcp: i64 = vc + PARTS_MAGIC_1330 * svp / PARTS_MAGIC_1024
168 return sdf_set_facetex(base, tex, w, h, uc, vcp, sup, svp)
169}
170func sdf_bytes() -> i64 { return SDF_ARENA_BYTES }
171func sdf_set_floor(base: i64, on: i64) -> i64 { let f: *i64 = (base + O_FLOOR) as *i64; f[0] = on; return 0 }
172func sdf_set_mtx_amp(base: i64, amp: i64) -> i64 { let f: *i64 = (base + O_MTXAMP) as *i64; f[0] = amp; return 0 }
173func sdf_set_eye(base: i64, dx: i64) -> i64 { let f: *i64 = (base + O_EYE) as *i64; f[0] = dx; return 0 }
174func fb_off() -> i64 { return O_FB }
175func ww() -> i64 { return W }
176func hh() -> i64 { return H }
177
178func sdf_isqrt(v: i64) -> i64 { return vm_isqrt(v) }
179func sdf_min(a: i64, b: i64) -> i64 { if a < b { return a } return b }
180func sdf_abs(a: i64) -> i64 { if a < 0 { return 0 - a } return a }
181// filmic SHOULDER: below 205 linear, above it rolls off toward 255 (highlights don't blow to flat white).
182func sdf_knee(v: i64) -> i64 { if v < 0 { return 0 } if v < 205 { return v } let x: i64 = v - 205; var o: i64 = 205 + x * 50 / (x + 85); if o > 255 { o = 255 } return o }
183// ★P5 ACES filmic tonemap (Narkowicz fit) -- the AAA/film color operator: rich mids, smooth highlight roll-off
184// to white. Integer fx256 (input 256=1.0; coeffs a=2.51 b=.03 c=2.43 d=.59 e=.14, scaled *256).
185func sdf_aces(v: i64) -> i64 {
186 var x: i64 = v * 30 / 26 // ~1.15x pre-exposure (ACES dims; the standard exposure-before-tonemap)
187 if x < 0 { x = 0 }
188 let num: i64 = x * (643 * x / 256 + 8) / 256
189 let den: i64 = x * (622 * x / 256 + 151) / 256 + 36
190 var o: i64 = 0
191 if den > 0 { o = num * 256 / den }
192 if o > 255 { o = 255 }
193 if o < 0 { o = 0 }
194 return o
195}
196
197// ===== PROCEDURAL SKIN FIELD (integer, deterministic; Lehmer scramble, no XOR) =====
198// skin is not noise: it is quasi-regular PORES (Worley cells), sparse FRECKLES, and multi-scale capillary
199// BLOTCH (value noise). All keyed on MODEL position -> the texture sticks to the surface under camera orbit.
200func sk_hash(a: i64, b: i64, c: i64) -> i64 {
201 var h: i64 = a * PARTS_MAGIC_92821 + b * PARTS_MAGIC_68917 + c * PARTS_MAGIC_40503
202 if h < 0 { h = 0 - h }
203 h = (h * MINSTD_MULT) % MINSTD_MOD
204 return h
205}
206// trilinear value noise in [-128..128] at cell size C (coords must be pre-offset positive)
207func sk_vnoise(x: i64, y: i64, z: i64, C: i64) -> i64 {
208 let cx: i64 = x / C
209 let cy: i64 = y / C
210 let cz: i64 = z / C
211 let fx: i64 = (x % C) * 256 / C
212 let fy: i64 = (y % C) * 256 / C
213 let fz: i64 = (z % C) * 256 / C
214 let v000: i64 = (sk_hash(cx, cy, cz) % 257) - 128
215 let v100: i64 = (sk_hash(cx + 1, cy, cz) % 257) - 128
216 let v010: i64 = (sk_hash(cx, cy + 1, cz) % 257) - 128
217 let v110: i64 = (sk_hash(cx + 1, cy + 1, cz) % 257) - 128
218 let v001: i64 = (sk_hash(cx, cy, cz + 1) % 257) - 128
219 let v101: i64 = (sk_hash(cx + 1, cy, cz + 1) % 257) - 128
220 let v011: i64 = (sk_hash(cx, cy + 1, cz + 1) % 257) - 128
221 let v111: i64 = (sk_hash(cx + 1, cy + 1, cz + 1) % 257) - 128
222 let x00: i64 = v000 + (v100 - v000) * fx / 256
223 let x10: i64 = v010 + (v110 - v010) * fx / 256
224 let x01: i64 = v001 + (v101 - v001) * fx / 256
225 let x11: i64 = v011 + (v111 - v011) * fx / 256
226 let y0: i64 = x00 + (x10 - x00) * fy / 256
227 let y1: i64 = x01 + (x11 - x01) * fy / 256
228 return y0 + (y1 - y0) * fz / 256
229}
230// Worley-F1 pore field: nearest jittered feature point over 3x3x3 cells. Returns pore-dark (0..160) +
231// 1024 * freckle-dark (0..90). Pores = small pits at every feature; freckles = sparse cells, wider + warm.
232func sk_pore(x: i64, y: i64, z: i64) -> i64 {
233 let C: i64 = 30
234 let cx: i64 = x / C
235 let cy: i64 = y / C
236 let cz: i64 = z / C
237 var bd2: i64 = PARTS_MAGIC_999999
238 var bh: i64 = 0
239 var dx: i64 = 0 - 1
240 while dx <= 1 {
241 var dy: i64 = 0 - 1
242 while dy <= 1 {
243 var dz: i64 = 0 - 1
244 while dz <= 1 {
245 let h: i64 = sk_hash(cx + dx, cy + dy, cz + dz)
246 let fxp: i64 = (cx + dx) * C + h % C
247 let fyp: i64 = (cy + dy) * C + (h / PARTS_MAGIC_1024) % C
248 let fzp: i64 = (cz + dz) * C + (h / PARTS_MAGIC_1048576) % C
249 let d2: i64 = (x - fxp) * (x - fxp) + (y - fyp) * (y - fyp) + (z - fzp) * (z - fzp)
250 if d2 < bd2 { bd2 = d2; bh = h }
251 dz = dz + 1
252 }
253 dy = dy + 1
254 }
255 dx = dx + 1
256 }
257 var pore: i64 = 0
258 if bd2 < 48 { pore = (48 - bd2) * 160 / 48 }
259 var frk: i64 = 0
260 if bh % 19 == 0 { if bd2 < 340 { frk = (340 - bd2) * 70 / 340 } }
261 return pore + frk * PARTS_MAGIC_1024
262}
263// ★R2 MESOSTRUCTURE HEIGHT (emit-not-paste micro-geometry, ZBrush surface-noise class): value-noise octaves ->
264// signed skin RELIEF. Its GRADIENT drives the surface normal (coherent, organic -- unlike the old regular sine
265// wobble), so the micro-surface matches the albedo pores. Cheap (value-noise = 8 hashes), gradient = 6 calls.
266func mat_height(qx: i64, qy: i64, qz: i64) -> i64 {
267 return sk_vnoise(qx, qy, qz, 24) / 4 + sk_vnoise(qx, qy, qz, 9) / 6 + sk_vnoise(qx, qy, qz, 5) / 8
268}
269// ★MICRO-TEXTURE (closes the benchmark's gradient-kurtosis gap = "too smooth"): 4 PINK octaves (amplitude falls
270// with frequency) of skin surface variation. Pink (not flat grain) fills the FLAT regions at every scale ->
271// lifts detail everywhere toward the natural heavy-tail WITHOUT breaking the 1/f power law (axis 0). Signed ~±32.
272func sk_microtex(qx: i64, qy: i64, qz: i64) -> i64 {
273 var v: i64 = sk_vnoise(qx, qy, qz, 42) * 12 / 128
274 v = v + sk_vnoise(qx, qy, qz, 20) * 8 / 128
275 v = v + sk_vnoise(qx, qy, qz, 10) * 6 / 128
276 v = v + (sk_hash(qx / 6, qy / 6, qz / 6) % 13 - 6) // finest ~2px speckle that survives the supersampler
277 return v
278}
279// clears ops + materials + per-part blends over the full capacity (reused arenas must inherit nothing)
280func sdf_clear_ops(base: i64, n: i64) -> i64 {
281 let op: *i64 = (base + O_OPS) as *i64
282 let mt: *i64 = (base + O_MATS) as *i64
283 let k2: *i64 = (base + O_KB2) as *i64
284 let rt: *i64 = (base + O_ROT) as *i64
285 var i: i64 = 0
286 while i < PARTS_CAP { op[i] = 0; mt[i] = 0; k2[i] = 0; rt[i * 2] = 0; rt[i * 2 + 1] = 0; i = i + 1 }
287 // roll and the primitive parameters are per-part state too: a reused arena must not inherit a previous face's lid opening
288 let rl: *i64 = (base + O_ROLL) as *i64
289 let pr: *i64 = (base + O_PRIM) as *i64
290 i = 0
291 while i < PARTS_CAP {
292 rl[i * SDF_ROT_FIELDS] = 0
293 rl[i * SDF_ROT_FIELDS + 1] = 0
294 var f: i64 = 0
295 while f < SDF_PRIM_FIELDS { pr[i * SDF_PRIM_FIELDS + f] = 0; f = f + 1 }
296 i = i + 1
297 }
298 return 0
299}
300// set a part's PITCH (rotation about X, tilts the y-z plane). deg4096 is in it_trig units (2*PI=6434 ~ 360deg).
301func sdf_set_rot(base: i64, idx: i64, deg4096: i64) -> i64 {
302 let rt: *i64 = (base + O_ROT) as *i64
303 rt[idx * 2] = it_cos4096(deg4096)
304 rt[idx * 2 + 1] = it_sin4096(deg4096)
305 return 0
306}
307func sdf_set_op(base: i64, idx: i64, v: i64) -> i64 { let op: *i64 = (base + O_OPS) as *i64; op[idx] = v; return 0 }
308func sdf_set_mat(base: i64, idx: i64, v: i64) -> i64 { let mt: *i64 = (base + O_MATS) as *i64; mt[idx] = v; return 0 }
309func sdf_set_kb(base: i64, idx: i64, v: i64) -> i64 { let k2: *i64 = (base + O_KB2) as *i64; k2[idx] = v; return 0 }
310
311// a FEMININE humanoid ("Elara") as ellipsoids in fx1024: narrow waist, wider hips, tapered limbs, hands+feet.
312// Overlapping so smin fuses them into one continuous surface.
313func sdf_body(base: i64) -> i64 {
314 let p: *i64 = (base + O_PARTS) as *i64
315 let kb: *i64 = (base + O_KBLEND) as *i64; kb[0] = 130
316 let nb: *i64 = (base + O_NPART) as *i64; nb[0] = 18
317 sdf_clear_ops(base, 18)
318 sdf_set_floor(base, 1)
319 sdf_set_mtx_amp(base, 0) // ★reverse-judge verdict (eyeball-confirmed): the crude micro-texture added blotch, not detail
320 // {cx,cy,cz, rx,ry,rz}
321 var i: i64 = 0
322 // head (slightly ovoid) + neck (slim, tapers into chest)
323 p[i]=0; p[i+1]=PARTS_MAGIC_1250; p[i+2]=0; p[i+3]=225; p[i+4]=285; p[i+5]=235; i=i+6
324 p[i]=0; p[i+1]=1010; p[i+2]=0; p[i+3]=115; p[i+4]=160; p[i+5]=115; i=i+6
325 // chest (broader shoulders) -> NIPPED waist -> flat abdomen. Front (z) profile PULLED BACK + flattened so
326 // the torso reads athletic, not pot-bellied; hips stay wide (x) but shallow (z). Feminine hourglass.
327 p[i]=0; p[i+1]=770; p[i+2]=0; p[i+3]=360; p[i+4]=300; p[i+5]=230; i=i+6
328 p[i]=0; p[i+1]=500; p[i+2]=0-18; p[i+3]=210; p[i+4]=235; p[i+5]=168; i=i+6
329 p[i]=0; p[i+1]=340; p[i+2]=0-28; p[i+3]=225; p[i+4]=210; p[i+5]=158; i=i+6
330 // breasts -- FRONT = -z (the camera's near hemisphere), MATCHING the face (sdf_face lives at -z). Before,
331 // breasts at +z put the body-front OPPOSITE the face => the head read "on backwards" on the figure.
332 p[i]=0-155; p[i+1]=800; p[i+2]=0-215; p[i+3]=180; p[i+4]=180; p[i+5]=175; i=i+6
333 p[i]=155; p[i+1]=800; p[i+2]=0-215; p[i+3]=180; p[i+4]=180; p[i+5]=175; i=i+6
334 // hips (WIDE in x, SHALLOW in z -> feminine curve without a bulbous front)
335 p[i]=0; p[i+1]=80; p[i+2]=0; p[i+3]=410; p[i+4]=280; p[i+5]=225; i=i+6
336 // arms in A-POSE (stepped outward): the industry rigging convention -- limbs need CLEARANCE from the
337 // torso/legs or contact defeats articulation (auto-rig found hand-touches-thigh with arms at the sides;
338 // pure geometry cannot tell contact from a joint -- the T/A-pose exists exactly for this).
339 p[i]=0-470; p[i+1]=650; p[i+2]=0; p[i+3]=145; p[i+4]=340; p[i+5]=145; i=i+6
340 p[i]=0-620; p[i+1]=280; p[i+2]=0; p[i+3]=115; p[i+4]=330; p[i+5]=118; i=i+6
341 p[i]=470; p[i+1]=650; p[i+2]=0; p[i+3]=145; p[i+4]=340; p[i+5]=145; i=i+6
342 p[i]=620; p[i+1]=280; p[i+2]=0; p[i+3]=115; p[i+4]=330; p[i+5]=118; i=i+6
343 // hands (small, at the wrists, clear of the thighs)
344 p[i]=0-700; p[i+1]=30; p[i+2]=0; p[i+3]=105; p[i+4]=150; p[i+5]=75; i=i+6
345 p[i]=700; p[i+1]=30; p[i+2]=0; p[i+3]=105; p[i+4]=150; p[i+5]=75; i=i+6
346 // legs: LONG tapered (thigh fuses to hip) -- lengthened for adult ~7-head proportions
347 p[i]=0-195; p[i+1]=0-600; p[i+2]=0; p[i+3]=205; p[i+4]=720; p[i+5]=205; i=i+6
348 p[i]=195; p[i+1]=0-600; p[i+2]=0; p[i+3]=205; p[i+4]=720; p[i+5]=205; i=i+6
349 // feet (toes point FORWARD = -z, same front as breasts + face)
350 p[i]=0-195; p[i+1]=0-PARTS_MAGIC_1330; p[i+2]=0-110; p[i+3]=130; p[i+4]=90; p[i+5]=245; i=i+6
351 p[i]=195; p[i+1]=0-PARTS_MAGIC_1330; p[i+2]=0-110; p[i+3]=130; p[i+4]=90; p[i+5]=245; i=i+6
352 // TIGHTER blend along the torso stack so the waist NIP survives (k=130 melted the hourglass into a blob);
353 // limbs/breasts keep the soft 130 fuse. Per-part blend = the same capability that made the face crisp.
354 sdf_set_kb(base, 2, 82) // chest
355 sdf_set_kb(base, 3, 66) // waist -- tightest, so it reads as a real waist
356 sdf_set_kb(base, 4, 80) // abdomen
357 sdf_set_kb(base, 7, 88) // hips
358 return 0
359}
360
361// a HEAD close-up with sculpted facial features (skull/forehead/jaw/chin/brows/nose/cheeks/lips/eyes/ears/
362// temples = 18 additive ellipsoids). smin fuses them into a continuous face. This gives real head-region
363// STRUCTURE (the face_structure axis the critic pins at ~88 on a featureless blob). fx1024, centered near origin.
364func sdf_head(base: i64) -> i64 {
365 let p: *i64 = (base + O_PARTS) as *i64
366 let kp: *i64 = (base + O_KBLEND) as *i64
367 kp[0] = 40 // SHARP blend so facial features (nose/brow/lips) stay DISTINCT, not melted
368 let nh: *i64 = (base + O_NPART) as *i64; nh[0] = 18
369 sdf_clear_ops(base, 18)
370 var i: i64 = 0
371 p[i]=0; p[i+1]=120; p[i+2]=0; p[i+3]=620; p[i+4]=740; p[i+5]=640; i=i+6 // skull
372 p[i]=0; p[i+1]=440; p[i+2]=380; p[i+3]=520; p[i+4]=340; p[i+5]=340; i=i+6 // forehead
373 p[i]=0; p[i+1]=0-360; p[i+2]=140; p[i+3]=470; p[i+4]=360; p[i+5]=430; i=i+6 // jaw
374 p[i]=0; p[i+1]=0-560; p[i+2]=300; p[i+3]=260; p[i+4]=230; p[i+5]=260; i=i+6 // chin
375 p[i]=0-250; p[i+1]=300; p[i+2]=520; p[i+3]=240; p[i+4]=110; p[i+5]=150; i=i+6 // brow L
376 p[i]=250; p[i+1]=300; p[i+2]=520; p[i+3]=240; p[i+4]=110; p[i+5]=150; i=i+6 // brow R
377 p[i]=0; p[i+1]=60; p[i+2]=600; p[i+3]=130; p[i+4]=290; p[i+5]=280; i=i+6 // nose bridge
378 p[i]=0; p[i+1]=0-150; p[i+2]=720; p[i+3]=165; p[i+4]=150; p[i+5]=210; i=i+6 // nose tip
379 p[i]=0-400; p[i+1]=0-40; p[i+2]=380; p[i+3]=260; p[i+4]=300; p[i+5]=280; i=i+6 // cheek L
380 p[i]=400; p[i+1]=0-40; p[i+2]=380; p[i+3]=260; p[i+4]=300; p[i+5]=280; i=i+6 // cheek R
381 p[i]=0; p[i+1]=0-340; p[i+2]=600; p[i+3]=250; p[i+4]=95; p[i+5]=170; i=i+6 // upper lip
382 p[i]=0; p[i+1]=0-450; p[i+2]=590; p[i+3]=235; p[i+4]=115; p[i+5]=165; i=i+6 // lower lip
383 p[i]=0-270; p[i+1]=170; p[i+2]=520; p[i+3]=195; p[i+4]=150; p[i+5]=160; i=i+6 // eye bulge L
384 p[i]=270; p[i+1]=170; p[i+2]=520; p[i+3]=195; p[i+4]=150; p[i+5]=160; i=i+6 // eye bulge R
385 p[i]=0-640; p[i+1]=100; p[i+2]=0-40; p[i+3]=130; p[i+4]=250; p[i+5]=170; i=i+6 // ear L
386 p[i]=640; p[i+1]=100; p[i+2]=0-40; p[i+3]=130; p[i+4]=250; p[i+5]=170; i=i+6 // ear R
387 p[i]=0-560; p[i+1]=320; p[i+2]=200; p[i+3]=170; p[i+4]=300; p[i+5]=260; i=i+6 // temple L
388 p[i]=560; p[i+1]=320; p[i+2]=200; p[i+3]=170; p[i+4]=300; p[i+5]=260; i=i+6 // temple R
389 return 0
390}
391
392// ★sdf_face -- a sculpted head that USES CARVING (the capability additive-smin lacked; the melted-egg fix):
393// additive skull/nose/brows/cheeks/lips/eyeballs, then SUBTRACT eye sockets + a mouth slit + nostrils. The
394// concavities are what a face is made of (an eye is a hole with a ball in it). Pioneer BENCHMARK, carve-op demo.
395func sdf_face(base: i64) -> i64 {
396 let p: *i64 = (base + O_PARTS) as *i64
397 let kb: *i64 = (base + O_KBLEND) as *i64; kb[0] = 18 // SHARP -- features/carves must stay crisp, not melt
398 let nb: *i64 = (base + O_NPART) as *i64; nb[0] = 27
399 sdf_clear_ops(base, 27)
400 sdf_set_floor(base, 0)
401 sdf_set_mtx_amp(base, 0) // ★reverse-judge verdict (eyeball-confirmed): the crude micro-texture added blotch, not detail
402 var i: i64 = 0
403 // ⚠FACE AT NEGATIVE z: sdf_render's camera sits at -z marching +z, so the NEAR (visible, lit) hemisphere
404 // is -z. (The first sdf_head put features at +z = we rendered the OCCIPUT and called it melted -- caught
405 // by the eyeball.) NOTE: the part ARRAY ORDER is the CSG program -- carve after build, add eyeballs after
406 // carving the sockets.
407 // --- additive base, CANON PROPORTIONS (head ~5 eye-widths wide; cheeks INSIDE the skull silhouette;
408 // ears hug; slim brows; lips protrude modestly past the jaw plane; eyes smaller + deeper set) ---
409 // ★A-R2 FIT PASS 2 (2026-07-08, measured off the HI-RES frontal ref): her face outline spans model
410 // ~+-515 at eye level (ours ran 610 = 18% wide); her nose radix->tip = ~287 model (ours ~450).
411 p[i]=0; p[i+1]=120; p[i+2]=0; p[i+3]=530; p[i+4]=760; p[i+5]=630; i=i+6 // 0 skull (ref-width)
412 // ★FEMININE dimorphism pass: slim nose · fuller lips · softer narrow jaw + tapered chin · high full cheeks ·
413 // thin high-arched brows w/ little ridge · larger eyes (below). Grounded in facial sexual dimorphism.
414 p[i]=0; p[i+1]=425; p[i+2]=0-360; p[i+3]=420; p[i+4]=285; p[i+5]=320; i=i+6 // 1 forehead (ref-fit: her hairline lands y~+870; ours ran taller)
415 p[i]=0; p[i+1]=0-375; p[i+2]=0-150; p[i+3]=320; p[i+4]=335; p[i+5]=385; i=i+6 // 2 jaw (ref-width)
416 p[i]=0; p[i+1]=0-520; p[i+2]=0-300; p[i+3]=180; p[i+4]=165; p[i+5]=245; i=i+6 // 3 chin (ref-fit: her chin lands y~-676; was -780 = too long)
417 p[i]=0; p[i+1]=105; p[i+2]=0-600; p[i+3]=82; p[i+4]=205; p[i+5]=225; i=i+6 // 4 nose bridge (ref-length: her radix->tip ~287)
418 p[i]=0; p[i+1]=0-125; p[i+2]=0-688; p[i+3]=86; p[i+4]=100; p[i+5]=150; i=i+6 // 5 nose tip (ref-fit)
419 p[i]=0-330; p[i+1]=15; p[i+2]=0-405; p[i+3]=200; p[i+4]=250; p[i+5]=185; i=i+6 // 6 cheek L (HIGH + full)
420 p[i]=330; p[i+1]=15; p[i+2]=0-405; p[i+3]=200; p[i+4]=250; p[i+5]=185; i=i+6 // 7 cheek R
421 // ★A-R2 GEOMETRY FIT (2026-07-07): feature sizes MEASURED from the reference through the projection
422 // mapping (her eye width 13px -> 177 model units; brows 2-3px thin; lips ~18px -> 246 wide; chin v130 ->
423 // y-676) -- reference-grounded corrections, not blind sculpt. Eye SPACING already matched (516) ✓.
424 p[i]=0-250; p[i+1]=322; p[i+2]=0-565; p[i+3]=205; p[i+4]=26; p[i+5]=70; i=i+6 // 8 brow L (ref-thin)
425 p[i]=250; p[i+1]=322; p[i+2]=0-565; p[i+3]=205; p[i+4]=26; p[i+5]=70; i=i+6 // 9 brow R
426 p[i]=0; p[i+1]=0-330; p[i+2]=0-558; p[i+3]=152; p[i+4]=88; p[i+5]=122; i=i+6 // 10 upper lip (ref-width)
427 p[i]=0; p[i+1]=0-442; p[i+2]=0-545; p[i+3]=132; p[i+4]=114; p[i+5]=122; i=i+6 // 11 lower lip (ref-width)
428 p[i]=0-545; p[i+1]=20; p[i+2]=40; p[i+3]=75; p[i+4]=235; p[i+5]=130; i=i+6 // 12 ear L (hugs the ref-width skull)
429 p[i]=545; p[i+1]=20; p[i+2]=40; p[i+3]=75; p[i+4]=235; p[i+5]=130; i=i+6 // 13 ear R
430 p[i]=0-505; p[i+1]=320; p[i+2]=0-200; p[i+3]=150; p[i+4]=300; p[i+5]=260; i=i+6 // 14 temple L (ref-width)
431 p[i]=505; p[i+1]=320; p[i+2]=0-200; p[i+3]=150; p[i+4]=300; p[i+5]=260; i=i+6 // 15 temple R
432 // --- CARVE eye sockets (ref-fit: her eye width ~177 model units; ours were 248 = 40% oversized) ---
433 p[i]=0-258; p[i+1]=180; p[i+2]=0-650; p[i+3]=148; p[i+4]=118; p[i+5]=235; i=i+6 // 16 socket L (carve)
434 p[i]=258; p[i+1]=180; p[i+2]=0-650; p[i+3]=148; p[i+4]=118; p[i+5]=235; i=i+6 // 17 socket R (carve)
435 // --- eyeballs seated in the sockets (MATERIAL=EYE: sclera/iris/pupil shaded by gaze angle) ---
436 p[i]=0-258; p[i+1]=178; p[i+2]=0-560; p[i+3]=94; p[i+4]=94; p[i+5]=104; i=i+6 // 18 eyeball L (ref-size)
437 p[i]=258; p[i+1]=178; p[i+2]=0-560; p[i+3]=94; p[i+4]=94; p[i+5]=104; i=i+6 // 19 eyeball R
438 // --- CARVE mouth slit + nostrils ---
439 p[i]=0; p[i+1]=0-390; p[i+2]=0-600; p[i+3]=142; p[i+4]=34; p[i+5]=110; i=i+6 // 20 mouth slit (carve, ref-width)
440 p[i]=0-64; p[i+1]=0-210; p[i+2]=0-745; p[i+3]=46; p[i+4]=52; p[i+5]=80; i=i+6 // 21 nostril L (carve, follows the ref-length nose)
441 p[i]=64; p[i+1]=0-210; p[i+2]=0-745; p[i+3]=46; p[i+4]=52; p[i+5]=80; i=i+6 // 22 nostril R (carve)
442 // --- HAIR volume: crown cap + nape (material=HAIR). Visible hair = where the cap surface is OUTERMOST;
443 // the skull/cap intersection curve IS the hairline (no painted edge).
444 p[i]=0; p[i+1]=438; p[i+2]=180; p[i+3]=665; p[i+4]=700; p[i+5]=700; i=i+6 // 23 crown cap (ref-fit: hairline lowered ~40 toward hers)
445 p[i]=0; p[i+1]=0-80; p[i+2]=430; p[i+3]=520; p[i+4]=430; p[i+5]=330; i=i+6 // 24 nape
446 // --- EYELASHES: a dark line along the upper-front rim of each eye (the mascara/liner frame = the biggest
447 // "alive eyes" cue games invest in). Thin in y, wide in x, at the eyeball's upper front. material=LASH.
448 p[i]=0-258; p[i+1]=276; p[i+2]=0-632; p[i+3]=116; p[i+4]=17; p[i+5]=92; i=i+6 // 25 upper lash L (rides the ref-size eye rim)
449 p[i]=258; p[i+1]=276; p[i+2]=0-632; p[i+3]=116; p[i+4]=17; p[i+5]=92; i=i+6 // 26 upper lash R
450 sdf_set_op(base, 16, 1)
451 sdf_set_op(base, 17, 1)
452 sdf_set_op(base, 20, 1)
453 sdf_set_op(base, 21, 1)
454 sdf_set_op(base, 22, 1)
455 sdf_set_mat(base, 18, 1)
456 sdf_set_mat(base, 19, 1)
457 sdf_set_mat(base, 23, 2)
458 sdf_set_mat(base, 24, 2)
459 sdf_set_mat(base, 8, 3)
460 sdf_set_mat(base, 9, 3)
461 sdf_set_mat(base, 25, 4)
462 sdf_set_mat(base, 26, 4)
463 // ★E4 ROTATED primitives -- features follow the face's angled planes (not stuck axis-aligned). The nose
464 // ridge sloping is the clear eyeball win; forehead/jaw rotations read worse, dropped (capability generalizes).
465 sdf_set_rot(base, 4, 0 - 300) // nose BRIDGE slopes forward-down (a real ridge, not a vertical blob)
466 return 0
467}
468
469// ★HAIRSTYLE VARIANTS on the detailed face (the crown-cap TODO, landed 2026-07-07): mutate sdf_face's hair
470// parts 23 (crown cap) + 24 (nape) and/or APPEND fall/tail volume (mat 2 HAIR) -- the skull/cap intersection
471// curve stays the hairline, so every variant keeps a real hairline with no painted edge. Call AFTER sdf_face
472// (and before a person graft). Returns the face part count after any appends.
473const HS_BOB: i64 = 1 // the sdf_face default cap+nape (explicit id = a no-op, negative-control-provable)
474const HS_LONG: i64 = 2 // deep nape + a back-fall volume down the back
475const HS_PIXIE: i64 = 3 // tight cap hugging the skull, nape tucked short
476const HS_PONY: i64 = 4 // nape tucked + a high tail behind the crown
477const HS_BALD: i64 = 5 // hair parts collapsed inside the skull -> skin scalp renders
478func sdf_face_hairstyle(base: i64, hs: i64) -> i64 {
479 let p: *i64 = (base + O_PARTS) as *i64
480 let nb: *i64 = (base + O_NPART) as *i64
481 var n: i64 = nb[0]
482 if hs == HS_LONG {
483 p[24*6]=0; p[24*6+1]=0-420; p[24*6+2]=480; p[24*6+3]=540; p[24*6+4]=760; p[24*6+5]=340
484 p[n*6]=0; p[n*6+1]=0-700; p[n*6+2]=430; p[n*6+3]=430; p[n*6+4]=520; p[n*6+5]=260
485 sdf_set_mat(base, n, 2)
486 n = n + 1
487 // ★HAIRSTYLE-OWNED COVERAGE (what game hair meshes do): long hair OWNS the side-of-head region --
488 // the TEMPLE (14/15) + EAR (12/13) parts become HAIR material (they sit exactly where long hair
489 // lives; their pale skin masses were reading caricature and poked in FRONT of any curtain). Style
490 // data, reversible: bob/pixie/pony keep skin temples + visible ears.
491 sdf_set_mat(base, 12, 2)
492 sdf_set_mat(base, 13, 2)
493 sdf_set_mat(base, 14, 2)
494 sdf_set_mat(base, 15, 2)
495 // ...and since the style OWNS them now, it also TUCKS the temple volumes flush under the cap
496 // silhouette (at their skin size they poked past the cap and read as round side-buns)
497 p[14*6]=0-480; p[14*6+1]=320; p[14*6+2]=0-180; p[14*6+3]=135; p[14*6+4]=260; p[14*6+5]=230
498 p[15*6]=480; p[15*6+1]=320; p[15*6+2]=0-180; p[15*6+3]=135; p[15*6+4]=260; p[15*6+5]=230
499 // SIDE CURTAINS: pulled in + forward so they MERGE with the hair-temples into one hugging mass that
500 // frames the face (no panel gap). Behind the eye plane, so eyes/cheeks/lips stay clear.
501 p[n*6]=0-480; p[n*6+1]=0-150; p[n*6+2]=0-140; p[n*6+3]=190; p[n*6+4]=620; p[n*6+5]=360
502 sdf_set_mat(base, n, 2)
503 n = n + 1
504 p[n*6]=480; p[n*6+1]=0-150; p[n*6+2]=0-140; p[n*6+3]=190; p[n*6+4]=620; p[n*6+5]=360
505 sdf_set_mat(base, n, 2)
506 n = n + 1
507 }
508 if hs == HS_PIXIE {
509 p[23*6]=0; p[23*6+1]=500; p[23*6+2]=140; p[23*6+3]=640; p[23*6+4]=650; p[23*6+5]=660
510 p[24*6]=0; p[24*6+1]=40; p[24*6+2]=470; p[24*6+3]=430; p[24*6+4]=330; p[24*6+5]=250
511 }
512 if hs == HS_PONY {
513 p[24*6]=0; p[24*6+1]=0-40; p[24*6+2]=430; p[24*6+3]=460; p[24*6+4]=380; p[24*6+5]=300
514 p[n*6]=0; p[n*6+1]=180; p[n*6+2]=960; p[n*6+3]=160; p[n*6+4]=540; p[n*6+5]=160
515 sdf_set_mat(base, n, 2)
516 n = n + 1
517 }
518 if hs == HS_BALD {
519 p[23*6]=0; p[23*6+1]=120; p[23*6+2]=0; p[23*6+3]=8; p[23*6+4]=8; p[23*6+5]=8
520 p[24*6]=0; p[24*6+1]=120; p[24*6+2]=0; p[24*6+3]=8; p[24*6+4]=8; p[24*6+5]=8
521 }
522 nb[0] = n
523 return n
524}
525
526// ★sdf_person -- the A-posed BODY with the REAL HEAD (face+hair+eyes) grafted at the neck. Composition is
527// PROGRAMMATIC: build sdf_face in a scratch arena, copy its parts scaled x5/16 (skull 610->190 ~ the blob
528// head it replaces) + translated to the neck top, carrying ops/mats. Per-part blend (O_KB2) is the enabling
529// capability: body parts inherit k=130 (limbs fuse), the skull joins at 55 (soft neck crease), facial
530// features hold k=8 (crisp). ONE field. sdf_person2 adds a HAIRSTYLE on the grafted head (the style runs on
531// the scratch face BEFORE the graft; appended hair parts ride the same copy). Face parts cap at 31
532// (body 17 + 31 = PARTS_CAP 48); appends beyond drop, honest v0.
533func sdf_person2(base: i64, scratch: i64, hs: i64) -> i64 {
534 sdf_body(base) // parts 0..17; part 0 = the blob head (replaced below)
535 sdf_face(scratch) // 27 parts, head-local coords (skull r 610/760/630)
536 var nf: i64 = 27
537 if hs > 0 { nf = sdf_face_hairstyle(scratch, hs) }
538 if nf < 27 { nf = 27 }
539 if nf > 31 { nf = 31 }
540 let pb: *i64 = (base + O_PARTS) as *i64
541 let pf: *i64 = (scratch + O_PARTS) as *i64
542 let opb: *i64 = (base + O_OPS) as *i64
543 let opf: *i64 = (scratch + O_OPS) as *i64
544 let mtb: *i64 = (base + O_MATS) as *i64
545 let mtf: *i64 = (scratch + O_MATS) as *i64
546 var j: i64 = 0
547 while j < nf {
548 var di: i64 = 0 // face part 0 (skull) REPLACES body part 0 (blob head)
549 if j > 0 { di = 17 + j } // the rest append after the body's 17 remaining parts
550 pb[di * 6] = pf[j * 6] * 5 / 16
551 pb[di * 6 + 1] = pf[j * 6 + 1] * 5 / 16 + PARTS_MAGIC_1330
552 pb[di * 6 + 2] = pf[j * 6 + 2] * 5 / 16
553 var rx: i64 = pf[j * 6 + 3] * 5 / 16
554 var ry: i64 = pf[j * 6 + 4] * 5 / 16
555 var rz: i64 = pf[j * 6 + 5] * 5 / 16
556 if rx < 6 { rx = 6 }
557 if ry < 6 { ry = 6 }
558 if rz < 6 { rz = 6 }
559 pb[di * 6 + 3] = rx
560 pb[di * 6 + 4] = ry
561 pb[di * 6 + 5] = rz
562 opb[di] = opf[j]
563 mtb[di] = mtf[j]
564 if j == 0 { sdf_set_kb(base, di, 55) } // skull: soft-ish join into the neck
565 else { sdf_set_kb(base, di, 8) } // features/hair/eyes: crisp
566 j = j + 1
567 }
568 let nb: *i64 = (base + O_NPART) as *i64
569 nb[0] = 17 + nf
570 let kb: *i64 = (base + O_KBLEND) as *i64
571 kb[0] = 130 // body default (limbs fuse); face parts override via O_KB2
572 return 0
573}
574func sdf_person(base: i64, scratch: i64) -> i64 { return sdf_person2(base, scratch, 0) }
575// sdf_person_full -- body + correctly-fitted face, ported from the laptop tree 2026-07-30 because the NAS
576// copy of this file was 2 days stale and nx_arousal_mesh could not compile without it. nx_ship's unpack
577// SILENTLY DECLINED the whole-file update (reported success, left the file at 07-28), so the function is
578// applied here through the nx_fs_write CAS path instead -- the documented remedy for that guard.
579func sdf_person_full(base: i64, scratch: i64, hs: i64) -> i64 {
580 sdf_body(base)
581 sdf_face(scratch)
582 var nf: i64 = 27
583 if hs > 0 { nf = sdf_face_hairstyle(scratch, hs) }
584 if nf < 27 { nf = 27 }
585 if nf > 31 { nf = 31 }
586 let pb: *i64 = (base + O_PARTS) as *i64
587 let pf: *i64 = (scratch + O_PARTS) as *i64
588 let opb: *i64 = (base + O_OPS) as *i64
589 let opf: *i64 = (scratch + O_OPS) as *i64
590 let mtb: *i64 = (base + O_MATS) as *i64
591 let mtf: *i64 = (scratch + O_MATS) as *i64
592 var j: i64 = 0
593 while j < nf {
594 var di: i64 = 0
595 if j > 0 { di = 17 + j }
596 pb[di * 6] = pf[j * 6] * 93 / 256
597 pb[di * 6 + 1] = pf[j * 6 + 1] * 93 / 256 + PARTS_MAGIC_1206
598 pb[di * 6 + 2] = pf[j * 6 + 2] * 93 / 256
599 var rx: i64 = pf[j * 6 + 3] * 93 / 256
600 var ry: i64 = pf[j * 6 + 4] * 93 / 256
601 var rz: i64 = pf[j * 6 + 5] * 93 / 256
602 if rx < 6 { rx = 6 }
603 if ry < 6 { ry = 6 }
604 if rz < 6 { rz = 6 }
605 pb[di * 6 + 3] = rx
606 pb[di * 6 + 4] = ry
607 pb[di * 6 + 5] = rz
608 opb[di] = opf[j]
609 mtb[di] = mtf[j]
610 if j == 0 { sdf_set_kb(base, di, 55) } else { sdf_set_kb(base, di, 8) }
611 j = j + 1
612 }
613 let nb: *i64 = (base + O_NPART) as *i64
614 nb[0] = 17 + nf
615 let kb: *i64 = (base + O_KBLEND) as *i64
616 kb[0] = 130
617 return 0
618}
619// shift every active part by dy (fx1024) -- lets the fixed-height camera frame a HEAD close-up of the person.
620func sdf_shift_y(base: i64, dy: i64) -> i64 {
621 let p: *i64 = (base + O_PARTS) as *i64
622 let npp: *i64 = (base + O_NPART) as *i64
623 var np: i64 = npp[0]
624 if np <= 0 { np = NPART }
625 if np > PARTS_CAP { np = PARTS_CAP }
626 var i: i64 = 0
627 while i < np { p[i * 6 + 1] = p[i * 6 + 1] + dy; i = i + 1 }
628 return 0
629}
630
631// ellipsoid SDF (approx, safe for marching): (len(q/r) - 1) * min(r)
632// A ZERO RADIUS IS A DEGENERATE PART, NOT A REASON TO KILL THE RENDER. Integer scaling truncates any radius below 100/pct to 0
633// (MEASURED 2026-09-18: the AT43 mouth seam's height 8 became 0 under the lip gates' tenth-scale negative control and SIGFPE'd
634// both gates mid-run), and an unwritten slot is all zeros. A zero radius evaluates as one unit; every non-zero radius -- i.e.
635// every input that did not trap before -- takes the identical arithmetic, so no existing render moves by a byte.
636func sdf_ellip(px: i64, py: i64, pz: i64, cx: i64, cy: i64, cz: i64, rx: i64, ry: i64, rz: i64) -> i64 {
637 var ax: i64 = rx
638 var ay: i64 = ry
639 var az: i64 = rz
640 if ax == 0 { ax = 1 }
641 if ay == 0 { ay = 1 }
642 if az == 0 { az = 1 }
643 let nx: i64 = (px - cx) * FX / ax
644 let ny: i64 = (py - cy) * FX / ay
645 let nz: i64 = (pz - cz) * FX / az
646 let l: i64 = sdf_isqrt(nx * nx + ny * ny + nz * nz) // fx1024
647 var mr: i64 = ax
648 if ay < mr { mr = ay }
649 if az < mr { mr = az }
650 return (l - FX) * mr / FX
651}
652// PITCH-ROTATED ellipsoid: the (y,z) offset is rotated into the part's local frame (by -angle; rc,rs = cos,sin
653// of +angle, fx256) before the axis-aligned test -> the primitive follows an angled facial plane.
654func sdf_ellip_rot(px: i64, py: i64, pz: i64, cx: i64, cy: i64, cz: i64, rx: i64, ry: i64, rz: i64, rc: i64, rs: i64) -> i64 {
655 let dy0: i64 = py - cy
656 let dz0: i64 = pz - cz
657 let dy: i64 = (dy0 * rc + dz0 * rs) / 256
658 let dz: i64 = (0 - dy0 * rs + dz0 * rc) / 256
659 var ax: i64 = rx // the zero-radius guard of sdf_ellip, for the same reason
660 var ay: i64 = ry
661 var az: i64 = rz
662 if ax == 0 { ax = 1 }
663 if ay == 0 { ay = 1 }
664 if az == 0 { az = 1 }
665 let nx: i64 = (px - cx) * FX / ax
666 let ny: i64 = dy * FX / ay
667 let nz: i64 = dz * FX / az
668 let l: i64 = sdf_isqrt(nx * nx + ny * ny + nz * nz)
669 var mr: i64 = ax
670 if ay < mr { mr = ay }
671 if az < mr { mr = az }
672 return (l - FX) * mr / FX
673}
674// smooth-min (quadratic) -- fuses two surfaces over KBLEND
675func sdf_smin(a: i64, b: i64, k: i64) -> i64 {
676 var h: i64 = k - sdf_abs(a - b)
677 if h < 0 { h = 0 }
678 return sdf_min(a, b) - h * h / k / 4
679}
680// smooth-max = -smin(-a,-b) ; opSmoothSubtraction(field, tool, k) = smax(field, -tool, k) -- CARVES a concavity
681func sdf_smax(a: i64, b: i64, k: i64) -> i64 { return 0 - sdf_smin(0 - a, 0 - b, k) }
682// a part's ROLL: its frontal-plane orientation (rotation about Z), cos and sin in IT_FX. The lid shell reads it as the tilt of
683// its opening; deg4096 is in it_trig units like sdf_set_rot. Positive roll raises the +x end of the opening
684func sdf_set_roll(base: i64, idx: i64, deg4096: i64) -> i64 {
685 let rl: *i64 = (base + O_ROLL) as *i64
686 rl[idx * SDF_ROT_FIELDS] = it_cos4096(deg4096)
687 rl[idx * SDF_ROT_FIELDS + 1] = it_sin4096(deg4096)
688 return 0
689}
690func sdf_set_prim(base: i64, idx: i64, field: i64, v: i64) -> i64 { let pr: *i64 = (base + O_PRIM) as *i64; pr[idx * SDF_PRIM_FIELDS + field] = v; return 0 }
691func sdf_get_prim(base: i64, idx: i64, field: i64) -> i64 { let pr: *i64 = (base + O_PRIM) as *i64; return pr[idx * SDF_PRIM_FIELDS + field] }
692// LID SHELL: a spherical shell (inner radius rin, thickness t) about the globe centre, kept to its FRONT cap (lateral reach
693// cap), with an almond opening cut straight through it. The opening is the intersection of two discs in the part's frontal
694// plane that both pass through the canthi at (-halfw, 0) and (+halfw, 0): the upper disc rises by up, the lower drops by low,
695// and the plane is rolled by (rc, rs) in IT_FX so one canthus can sit above the other. The max of exact distances is a lower
696// bound on the true distance, which is what a marcher needs (it never oversteps) and what a carve is
697func sdf_lidshell(px: i64, py: i64, pz: i64, cx: i64, cy: i64, cz: i64, rin: i64, t: i64, cap: i64, halfw: i64, up: i64, low: i64, rc: i64, rs: i64) -> i64 {
698 let dx: i64 = px - cx
699 let dy: i64 = py - cy
700 let dz: i64 = pz - cz
701 let r: i64 = sdf_isqrt(dx * dx + dy * dy + dz * dz)
702 var d: i64 = rin - r // inside the inner sphere is outside the wall
703 let dout: i64 = r - (rin + t)
704 if dout > d { d = dout }
705 let q: i64 = sdf_isqrt(dx * dx + dy * dy)
706 if q - cap > d { d = q - cap } // the cap: no wall beyond this lateral reach
707 if dz > d { d = dz } // the front half only (the camera looks along +z)
708 if halfw <= 0 { return d }
709 if up <= 0 { return d }
710 if low <= 0 { return d }
711 var u: i64 = dx
712 var v: i64 = dy
713 var rolled: i64 = 1
714 if rc == 0 { if rs == 0 { rolled = 0 } } // a zero-filled roll is the identity, not a collapse to a point
715 if rolled == 1 {
716 u = (dx * rc + dy * rs) / IT_FX
717 v = (0 - dx * rs + dy * rc) / IT_FX
718 }
719 let ru: i64 = (halfw * halfw + up * up) / (2 * up) // the disc through (-halfw,0), (+halfw,0) and (0,up)
720 let rl: i64 = (halfw * halfw + low * low) / (2 * low) // the disc through (-halfw,0), (+halfw,0) and (0,-low)
721 let vu: i64 = v - (up - ru)
722 let vl: i64 = v - (rl - low)
723 let du: i64 = sdf_isqrt(u * u + vu * vu) - ru
724 let dl: i64 = sdf_isqrt(u * u + vl * vl) - rl
725 var da: i64 = du // inside the almond when both discs contain the point
726 if dl > da { da = dl }
727 if 0 - da > d { d = 0 - da }
728 return d
729}
730// ---- THE LIP SWEEP (aesthetictwin AT43, 2026-09-17): ONE PIECE, BUILT AT ITS OWN SCALE -------------------------------------------
731// Two blended ellipsoids could not make a mouth: an ellipsoid has no vermilion border, no seam and no commissure, so the
732// generator's own lip scan read NO-SULCUS on the canon face and the photo ruler lost the mouth. A lip is HALF of an
733// elliptical tube swept along the mouth line: thickest at the midline, tapering to the commissure, wrapping back along the
734// dental arch, cut flat at the seam (the stomion line) so the upper and the lower lip meet in a line. The part's six
735// numbers are the stomion at the midline (cx, cy, cz = the tube's AXIS) and (half-width, height, depth); the six primitive
736// slots carry the shape. Every outline value is a closed form of these numbers, which is what lets the generator STATE
737// its lip landmarks instead of searching a blended surface for them. No scratch memory: the field is evaluated millions
738// of times a frame and from several threads, so every intermediate is a local.
739const SDF_OP_LIPSWEEP: i64 = 3
740const SDF_PL_ARCH: i64 = 0 // how far back (+z) the commissure sits from the midline
741const SDF_PL_TAPER: i64 = 1 // commissure thickness, permil of the midline thickness
742const SDF_PL_NOTCH: i64 = 2 // cupid's bow: the dip of the upper outline at the midline, permil of this lip's height (0 on a lower lip)
743const SDF_PL_NOTCH_HW: i64 = 3 // half-width of that dip, permil of the half mouth width
744const SDF_PL_CURVE: i64 = 4 // rise (+) or drop (-) of the seam at the commissure
745const SDF_PL_SIDE: i64 = 5 // +1 = the half above the seam (upper lip), -1 = the half below
746const SDF_PERMIL: i64 = 1000
747const SDF_LIP_EDGE: i64 = 6 // the vermilion's colour edge fades over this many model units
748const SDF_LIP_FULL: i64 = 100
749// position along the half mouth in permil of the half-width; past 1000 the point lies beyond the commissure
750func sdf_lip_t(px: i64, cx: i64, halfw: i64) -> i64 {
751 var dx: i64 = px - cx
752 if dx < 0 { dx = 0 - dx }
753 var hw: i64 = halfw
754 if hw < 1 { hw = 1 }
755 return dx * SDF_PERMIL / hw
756}
757// the taper factor in permil at t (t already clamped to 0..1000): 1000 at the midline, taper at the commissure
758func sdf_lip_f(taper: i64, t: i64) -> i64 {
759 let t2: i64 = t * t / SDF_PERMIL
760 return taper + (SDF_PERMIL - taper) * (SDF_PERMIL - t2) / SDF_PERMIL
761}
762// the outline height on this lip's side at t: the tapered height, less the cupid's bow dip on an upper lip. The dip is a FRACTION
763// of the height (permil), so a fuller or a scaled lip carries its bow with it and no morph has to remember to move it
764func sdf_lip_h(hh: i64, taper: i64, notch: i64, notch_hw: i64, side: i64, t: i64) -> i64 {
765 var h: i64 = hh * sdf_lip_f(taper, t) / SDF_PERMIL
766 if side > 0 { if notch > 0 { if notch_hw > 0 { if t < notch_hw {
767 let u: i64 = t * SDF_PERMIL / notch_hw
768 let dip: i64 = hh * notch / SDF_PERMIL
769 h = h - dip * (SDF_PERMIL - u * u / SDF_PERMIL) / SDF_PERMIL
770 } } } }
771 if h < 1 { h = 1 }
772 return h
773}
774func sdf_lipsweep(px: i64, py: i64, pz: i64, cx: i64, cy: i64, cz: i64, halfw: i64, hh: i64, dd: i64, arch: i64, taper: i64, notch: i64, notch_hw: i64, curve: i64, side: i64) -> i64 {
775 var t: i64 = sdf_lip_t(px, cx, halfw)
776 var over: i64 = 0
777 if t > SDF_PERMIL {
778 over = (t - SDF_PERMIL) * halfw / SDF_PERMIL
779 t = SDF_PERMIL
780 }
781 let t2: i64 = t * t / SDF_PERMIL
782 let h: i64 = sdf_lip_h(hh, taper, notch, notch_hw, side, t)
783 var d: i64 = dd * sdf_lip_f(taper, t) / SDF_PERMIL
784 if d < 1 { d = 1 }
785 let seam_y: i64 = cy + curve * t2 / SDF_PERMIL
786 let axis_z: i64 = cz + arch * t2 / SDF_PERMIL
787 let ny: i64 = (py - seam_y) * FX / h
788 let nz: i64 = (pz - axis_z) * FX / d
789 let l: i64 = sdf_isqrt(ny * ny + nz * nz)
790 var mr: i64 = h
791 if d < mr { mr = d }
792 var dist: i64 = (l - FX) * mr / FX
793 var cut: i64 = seam_y - py // the flat seam: an upper lip keeps the half above it
794 if side < 0 { cut = 0 - cut }
795 if cut > dist { dist = cut }
796 if over > 0 {
797 if dist < 0 { dist = 0 }
798 dist = sdf_isqrt(dist * dist + over * over)
799 }
800 return dist
801}
802func sdf_lipsweep_part(base: i64, i: i64, px: i64, py: i64, pz: i64) -> i64 {
803 let p: *i64 = (base + O_PARTS) as *i64
804 let pr: *i64 = (base + O_PRIM) as *i64
805 return sdf_lipsweep(px, py, pz, p[i*6], p[i*6+1], p[i*6+2], p[i*6+3], p[i*6+4], p[i*6+5], pr[i*SDF_PRIM_FIELDS+SDF_PL_ARCH], pr[i*SDF_PRIM_FIELDS+SDF_PL_TAPER], pr[i*SDF_PRIM_FIELDS+SDF_PL_NOTCH], pr[i*SDF_PRIM_FIELDS+SDF_PL_NOTCH_HW], pr[i*SDF_PRIM_FIELDS+SDF_PL_CURVE], pr[i*SDF_PRIM_FIELDS+SDF_PL_SIDE])
806}
807// THE VERMILION is the lip's own stated outline, not a painted window in head space: 0 outside, SDF_LIP_FULL inside, a
808// short fade at the edge. Returns -1 when the body declares no lip sweep at all (the caller keeps its legacy window)
809func sdf_lip_vermilion(base: i64, px: i64, py: i64, pz: i64) -> i64 {
810 let npp: *i64 = (base + O_NPART) as *i64
811 var np: i64 = npp[0]
812 if np <= 0 { np = NPART }
813 if np > PARTS_CAP { np = PARTS_CAP }
814 let op: *i64 = (base + O_OPS) as *i64
815 let p: *i64 = (base + O_PARTS) as *i64
816 let pr: *i64 = (base + O_PRIM) as *i64
817 var have: i64 = 0
818 var best: i64 = 0
819 var i: i64 = 0
820 while i < np {
821 if op[i] == SDF_OP_LIPSWEEP {
822 have = 1
823 let side: i64 = pr[i*SDF_PRIM_FIELDS+SDF_PL_SIDE]
824 let t: i64 = sdf_lip_t(px, p[i*6], p[i*6+3])
825 if t <= SDF_PERMIL {
826 let t2: i64 = t * t / SDF_PERMIL
827 let taper: i64 = pr[i*SDF_PRIM_FIELDS+SDF_PL_TAPER]
828 let axis_z: i64 = p[i*6+2] + pr[i*SDF_PRIM_FIELDS+SDF_PL_ARCH] * t2 / SDF_PERMIL
829 let depth: i64 = p[i*6+5] * sdf_lip_f(taper, t) / SDF_PERMIL
830 if pz < axis_z + depth {
831 let seam_y: i64 = p[i*6+1] + pr[i*SDF_PRIM_FIELDS+SDF_PL_CURVE] * t2 / SDF_PERMIL
832 var rise: i64 = py - seam_y // distance from the seam toward this lip's outline
833 if side < 0 { rise = 0 - rise }
834 if rise >= 0 {
835 let inside: i64 = sdf_lip_h(p[i*6+4], taper, pr[i*SDF_PRIM_FIELDS+SDF_PL_NOTCH], pr[i*SDF_PRIM_FIELDS+SDF_PL_NOTCH_HW], side, t) - rise
836 if inside > 0 {
837 var f: i64 = SDF_LIP_FULL
838 if inside < SDF_LIP_EDGE { f = inside * SDF_LIP_FULL / SDF_LIP_EDGE }
839 if f > best { best = f }
840 }
841 }
842 }
843 }
844 }
845 i = i + 1
846 }
847 if have == 0 { return 0 - 1 }
848 return best
849}
850// whole-body field = smin over all parts (blend radius read from base[O_KBLEND]; sharp for a face, wide for a body)
851// Internal: caller supplies an admitted arena and a valid part index.
852// Geometry and attribution share every primitive transform and operation representation.
853func sdf_part_distance(base:i64,i:i64,px:i64,py:i64,pz:i64)->i64{
854 let p:*i64=(base+O_PARTS) as *i64;let rt:*i64=(base+O_ROT) as *i64
855 let rl:*i64=(base+O_ROLL) as *i64;let pr:*i64=(base+O_PRIM) as *i64;let op:*i64=(base+O_OPS) as *i64
856 let rc: i64 = rt[i * 2]
857 let rs: i64 = rt[i * 2 + 1]
858 var di: i64 = 0
859 if op[i] == SDF_OP_LIDSHELL { // a lid shell reads its own parameter row and its roll, never the ellipsoid
860 di = sdf_lidshell(px, py, pz, p[i*6], p[i*6+1], p[i*6+2], p[i*6+3], p[i*6+4], p[i*6+5], pr[i*SDF_PRIM_FIELDS+SDF_PR_HALFW], pr[i*SDF_PRIM_FIELDS+SDF_PR_UP], pr[i*SDF_PRIM_FIELDS+SDF_PR_LOW], rl[i*SDF_ROT_FIELDS], rl[i*SDF_ROT_FIELDS+1])
861 } else {
862 if rc == 0 { if rs == 0 { // identity (unrotated) -> the fast path
863 di = sdf_ellip(px, py, pz, p[i*6], p[i*6+1], p[i*6+2], p[i*6+3], p[i*6+4], p[i*6+5])
864 } else { di = sdf_ellip_rot(px, py, pz, p[i*6], p[i*6+1], p[i*6+2], p[i*6+3], p[i*6+4], p[i*6+5], rc, rs) } }
865 else { di = sdf_ellip_rot(px, py, pz, p[i*6], p[i*6+1], p[i*6+2], p[i*6+3], p[i*6+4], p[i*6+5], rc, rs) }
866 }
867 if op[i] == SDF_OP_LIPSWEEP { di = sdf_lipsweep_part(base, i, px, py, pz) } // a lip reads its own sweep, never the ellipsoid of its six numbers
868 return di
869}
870func sdf_eval(base: i64, px: i64, py: i64, pz: i64) -> i64 {
871 let p: *i64 = (base + O_PARTS) as *i64
872 let kp: *i64 = (base + O_KBLEND) as *i64
873 var k: i64 = kp[0]
874 if k <= 0 { k = KBLEND }
875 let npp: *i64 = (base + O_NPART) as *i64
876 var np: i64 = npp[0]
877 if np <= 0 { np = NPART }
878 if np > PARTS_CAP { np = PARTS_CAP }
879 let op: *i64 = (base + O_OPS) as *i64
880 let k2: *i64 = (base + O_KB2) as *i64
881 let rt: *i64 = (base + O_ROT) as *i64
882 let rl: *i64 = (base + O_ROLL) as *i64
883 let pr: *i64 = (base + O_PRIM) as *i64
884 var d: i64 = PARTS_MAGIC_999999
885 var i: i64 = 0
886 while i < np {
887 let di:i64=sdf_part_distance(base,i,px,py,pz)
888 var ki: i64 = k2[i] // per-part blend; 0 -> inherit the body default
889 if ki <= 0 { ki = k }
890 if i == 0 { d = di } else {
891 if op[i] == 1 { d = sdf_smax(d, 0 - di, ki) } // CARVE this part out (eye socket, mouth, nostril)
892 else { d = sdf_smin(d, di, ki) } // UNION (add)
893 }
894 i = i + 1
895 }
896 return d
897}
898
899// THE LASH LINE IS THE UPPER LID MARGIN, not a bar floating over the eye. For a hit on lid shell idx: 1 when the point lies
900// outside the opening, the upper arc is the edge it is nearest to, and it is within SDF_LASH_BAND of that arc
901const SDF_LASH_BAND: i64 = 7
902func sdf_lid_lash(base: i64, idx: i64, px: i64, py: i64) -> i64 {
903 let p: *i64 = (base + O_PARTS) as *i64
904 let rl: *i64 = (base + O_ROLL) as *i64
905 let halfw: i64 = sdf_get_prim(base, idx, SDF_PR_HALFW)
906 let up: i64 = sdf_get_prim(base, idx, SDF_PR_UP)
907 let low: i64 = sdf_get_prim(base, idx, SDF_PR_LOW)
908 if halfw <= 0 { return 0 }
909 if up <= 0 { return 0 }
910 if low <= 0 { return 0 }
911 let dx: i64 = px - p[idx * SDF_PART_FIELDS]
912 let dy: i64 = py - p[idx * SDF_PART_FIELDS + 1]
913 let rc: i64 = rl[idx * SDF_ROT_FIELDS]
914 let rs: i64 = rl[idx * SDF_ROT_FIELDS + 1]
915 var u: i64 = dx
916 var v: i64 = dy
917 var rolled: i64 = 1
918 if rc == 0 { if rs == 0 { rolled = 0 } }
919 if rolled == 1 {
920 u = (dx * rc + dy * rs) / IT_FX
921 v = (0 - dx * rs + dy * rc) / IT_FX
922 }
923 let ru: i64 = (halfw * halfw + up * up) / (2 * up)
924 let rw: i64 = (halfw * halfw + low * low) / (2 * low)
925 let vu: i64 = v - (up - ru)
926 let vl: i64 = v - (rw - low)
927 let du: i64 = sdf_isqrt(u * u + vu * vu) - ru
928 let dl: i64 = sdf_isqrt(u * u + vl * vl) - rw
929 if du < 0 { return 0 }
930 if du < dl { return 0 }
931 if du > SDF_LASH_BAND { return 0 }
932 return 1
933}
934// which PART is this surface point on -- nearest by INDIVIDUAL part field (approximate inside smin blends;
935// exact on the part's own surface). Used for material lookup (eyes vs skin).
936func sdf_eval_part(base:i64,px:i64,py:i64,pz:i64)->i64{
937 let npp:*i64=(base+O_NPART) as *i64;var np:i64=npp[0]
938 if np<=0{np=NPART};if np>PARTS_CAP{np=PARTS_CAP}
939 let op:*i64=(base+O_OPS) as *i64;var best:i64=-1;var bd:i64=0
940 var i:i64=0;while i<np{
941 if op[i]==0||op[i]==SDF_OP_LIDSHELL||op[i]==SDF_OP_LIPSWEEP{
942 let di:i64=sdf_part_distance(base,i,px,py,pz)
943 if best<0||di<bd{bd=di;best=i}
944 };i=i+1
945 };if best<0{return 0};return best
946}
947
948// Raw material identity, including the existing geometric upper-lid lash rule.
949func sdf_surface_material(base:i64,part:i64,px:i64,py:i64)->i64{
950 let mats:*i64=(base+O_MATS) as *i64;let ops:*i64=(base+O_OPS) as *i64
951 if ops[part]==SDF_OP_LIDSHELL{if sdf_lid_lash(base,part,px,py)==1{return 4}}
952 return mats[part]
953}
954// Fixed record layout; distances are arena-coordinate FX units, not probabilities.
955const SDF_AT_PART:i64=0
956const SDF_AT_MATERIAL:i64=1
957const SDF_AT_NEAREST:i64=2
958const SDF_AT_RUNNER:i64=3
959const SDF_AT_FIELD:i64=4
960const SDF_AT_COMPOSED:i64=5
961const SDF_AT_TIED:i64=6
962const SDF_AT_RUNNER_PART:i64=7
963const SDF_AT_WORDS:i64=8
964// Nearest-part attribution is a display approximation. A composed field differing
965// from the nearest primitive, or a tie, is reported explicitly rather than called confident.
966// Carve tools never become tissue/material owners. No anatomical certainty is inferred.
967func sdf_part_attribution(base:i64,px:i64,py:i64,pz:i64,out:*i64,words:i64)->i64{
968 if base<=0||(out as i64)<=0||words!=SDF_AT_WORDS{return -1}
969 let npp:*i64=(base+O_NPART) as *i64;var np:i64=npp[0]
970 if np<=0{np=NPART};if np>PARTS_CAP{np=PARTS_CAP}
971 let ops:*i64=(base+O_OPS) as *i64;var best:i64=-1;var runner_part:i64=-1;var nearest:i64=0;var runner:i64=0
972 var i:i64=0;while i<np{
973 if ops[i]==0||ops[i]==SDF_OP_LIDSHELL||ops[i]==SDF_OP_LIPSWEEP{
974 let d:i64=sdf_part_distance(base,i,px,py,pz)
975 if best<0||d<nearest{runner=nearest;runner_part=best;nearest=d;best=i}else{if runner_part<0||d<runner{runner=d;runner_part=i}}
976 };i=i+1
977 }
978 if best<0{return -2}
979 let field:i64=sdf_eval(base,px,py,pz)
980 out[SDF_AT_PART]=best;out[SDF_AT_MATERIAL]=sdf_surface_material(base,best,px,py)
981 out[SDF_AT_NEAREST]=nearest;out[SDF_AT_RUNNER]=runner;out[SDF_AT_FIELD]=field
982 out[SDF_AT_COMPOSED]=(field!=nearest) as i64;out[SDF_AT_TIED]=(runner_part>=0&&nearest==runner) as i64;out[SDF_AT_RUNNER_PART]=runner_part
983 return 0
984}
985
986// SOFT SHADOW: march from the surface toward the light; penumbra from the closest-approach ratio (IQ method).
987// l* = unit light dir fx1024. returns fx256 [0=full shadow .. 256=lit].
988func sdf_softshadow(base: i64, ox: i64, oy: i64, oz: i64, lx: i64, ly: i64, lz: i64) -> i64 {
989 var sh: i64 = 256
990 var t: i64 = 45 // start offset (avoid self-hit)
991 var i: i64 = 0
992 while i < 30 {
993 let hx: i64 = ox + lx * t / FX
994 let hy: i64 = oy + ly * t / FX
995 let hz: i64 = oz + lz * t / FX
996 let h: i64 = sdf_eval(base, hx, hy, hz)
997 if h < 4 { return 12 } // occluded -> ambient floor
998 let cand: i64 = 9 * h * 256 / t // k*h/t penumbra (k=9)
999 if cand < sh { sh = cand }
1000 var stp: i64 = h
1001 if stp < 18 { stp = 18 }
1002 t = t + stp
1003 if t > PARTS_MAGIC_3600 { i = 30 } else { i = i + 1 }
1004 }
1005 if sh < 12 { sh = 12 }
1006 if sh > 256 { sh = 256 }
1007 return sh
1008}
1009// AMBIENT OCCLUSION: sample the field along the normal; crevices read the surface closer than free space.
1010// n* = unit normal fx256. returns fx256 [0=occluded .. 256=open].
1011func sdf_ao(base: i64, ox: i64, oy: i64, oz: i64, nx: i64, ny: i64, nz: i64) -> i64 {
1012 var occ: i64 = 0
1013 var w: i64 = 256
1014 var i: i64 = 1
1015 while i <= 5 {
1016 let dd: i64 = i * i * 16 // 16,64,144,256,400 (fx1024)
1017 let sx: i64 = ox + nx * dd / 256
1018 let sy: i64 = oy + ny * dd / 256
1019 let sz: i64 = oz + nz * dd / 256
1020 let h: i64 = sdf_eval(base, sx, sy, sz)
1021 var d: i64 = dd - h
1022 if d < 0 { d = 0 }
1023 occ = occ + d * w / dd
1024 w = w / 2
1025 i = i + 1
1026 }
1027 var ao: i64 = 256 - occ * 3 / 2
1028 if ao < 0 { ao = 0 }
1029 if ao > 256 { ao = 256 }
1030 return ao
1031}
1032// ★P2 GLOBAL ILLUMINATION -- 1-bounce path-tracing integrator (the flagship non-gen photoreal lever). From a
1033// shading point, cast hemisphere rays around N; a ray that ESCAPES samples the environment (cool sky up / warm
1034// bounce down), a ray that HITS nearby adds a dim warm SKIN bounce. Result = real directional ambient + contact
1035// occlusion + colour bleed in creases, replacing the flat hemisphere term. Returns PACKED r|g<<9|b<<18 (fx256,
1036// each 0..511) so the hot shading path needs NO per-pixel mmap.
1037func sdf_gi(base: i64, px: i64, py: i64, pz: i64, nx: i64, ny: i64, nz: i64) -> i64 {
1038 // orthonormal tangent basis (T,B,N), all fx256 unit
1039 var hx: i64 = 0
1040 var hy: i64 = 0
1041 var hz: i64 = 256
1042 if sdf_abs(nz) > 210 { hx = 256; hy = 0; hz = 0 }
1043 var tx: i64 = (ny * hz - nz * hy) / 256
1044 var ty: i64 = (nz * hx - nx * hz) / 256
1045 var tz: i64 = (nx * hy - ny * hx) / 256
1046 let tl: i64 = sdf_isqrt(tx * tx + ty * ty + tz * tz)
1047 if tl > 0 { tx = tx * 256 / tl; ty = ty * 256 / tl; tz = tz * 256 / tl }
1048 let bx: i64 = (ny * tz - nz * ty) / 256
1049 let by: i64 = (nz * tx - nx * tz) / 256
1050 let bz: i64 = (nx * ty - ny * tx) / 256
1051 var ir: i64 = 0
1052 var ig: i64 = 0
1053 var ib: i64 = 0
1054 var k: i64 = 0
1055 while k < 5 {
1056 var sx: i64 = 0
1057 var sy: i64 = 0
1058 var sz: i64 = 256 // sample k=0 = straight up the normal
1059 if k == 1 { sx = 200; sy = 0; sz = 160 }
1060 if k == 2 { sx = 0 - 200; sy = 0; sz = 160 }
1061 if k == 3 { sx = 0; sy = 200; sz = 160 }
1062 if k == 4 { sx = 0; sy = 0 - 200; sz = 160 }
1063 let dx: i64 = (sx * tx + sy * bx + sz * nx) / 256
1064 let dy: i64 = (sx * ty + sy * by + sz * ny) / 256
1065 let dz: i64 = (sx * tz + sy * bz + sz * nz) / 256
1066 let ox: i64 = px + nx * 40 / 256
1067 let oy: i64 = py + ny * 40 / 256
1068 let oz: i64 = pz + nz * 40 / 256
1069 var t: i64 = 55
1070 var hit: i64 = 0
1071 var st: i64 = 0
1072 while st < 18 {
1073 let sxp: i64 = ox + dx * t / 256
1074 let syp: i64 = oy + dy * t / 256
1075 let szp: i64 = oz + dz * t / 256
1076 let dd: i64 = sdf_eval(base, sxp, syp, szp)
1077 if dd < 5 { hit = 1; st = 18 } else { t = t + dd; if t > PARTS_MAGIC_2600 { st = 18 } else { st = st + 1 } }
1078 }
1079 if hit == 0 {
1080 var up: i64 = (dy + 256) / 2 // 0=down .. 256=up
1081 if up < 0 { up = 0 }
1082 if up > 256 { up = 256 }
1083 ir = ir + 28 + up * 20 / 256 // environment fill: warm-neutral -> cool sky (subtle)
1084 ig = ig + 30 + up * 24 / 256
1085 ib = ib + 38 + up * 32 / 256 // more blue toward the sky
1086 } else {
1087 ir = ir + 9 // occluded -> DARK contact (dim warm bleed) = real form
1088 ig = ig + 6
1089 ib = ib + 5
1090 }
1091 k = k + 1
1092 }
1093 return (ir / 5) + (ig / 5) * 512 + (ib / 5) * PARTS_MAGIC_262144
1094}
1095
1096// shade ONE ray: march from (rox,roy,roz) along (rdx,rdy,rdz); return the shaded color, or misscol on no-hit.
1097// sr_sss_preint -- PRE-INTEGRATED SKIN SHADING, Penner 2011 (the /compare/graphics contract row: the rung
1098// that stops the clay read). The fixed per-channel wrap already here reddens the terminator, but with ONE
1099// wrap width for every point; real skin scatters over ~1-2mm, so the wrap must WIDEN where the surface is
1100// tightly curved (nose ridge, finger, ear rim -- radius small vs the diffusion length) and stay narrow on
1101// flat cheek and forehead. Penner precomputes that as a 2D lookup over (N.L, curvature); this is that
1102// function evaluated by rule, integer, no table: per-channel wrap width w_c(curv) = base_c + curv*gain_c
1103// where red carries the widest base and gain (RGB diffusion profile ordering), and each channel's diffuse
1104// = clamp((ndl + w_c) / (256 + w_c)). curv is the SDF's mean curvature at the point (Laplacian over the
1105// central-difference stencil already used for the normal), clamped 0..256 with 0 = flat.
1106// Guarantees the gate teeth pin: (a) FULLY-AWAY equality -- ndl=-256 gives 0 for every w_c, same as
1107// plain; (b) terminator gain red-ordered -- at ndl=0 diffuse = w_c/(256+w_c), monotone in w_c, so red > blue
1108// by construction; (c) monotone in ndl; (d) CURVATURE MONOTONE -- larger curv never narrows any channel.
1109// The fixed-wrap it supersedes was per-channel constants (120/60/26): those are the curv=0 bases here, so a
1110// flat surface renders IDENTICALLY to before, and the change is only where curvature is real.
1111const SSS_WRAP_R0: i64 = 120 // flat-surface wrap width, red (the proven terminator floor)
1112const SSS_WRAP_G0: i64 = 60
1113const SSS_WRAP_B0: i64 = 26
1114const SSS_CURV_GAIN_R: i64 = 96 // widening per unit curvature (curv 0..256), red widest
1115const SSS_CURV_GAIN_G: i64 = 40
1116const SSS_CURV_GAIN_B: i64 = 12
1117const SSS_CURV_MAX: i64 = 256
1118const SSS_CURV_SCALE: i64 = 24 // Laplacian sum (SDF units) -> 0..256 curvature; sized so a 1-block
1119 // radius sphere reads ~256 and the cheek reads ~0 (measured on the SDF)
1120// packs (wR,wG,wB) each 0..256 into one i64: wR | wG<<10 | wB<<20 (three 10-bit fields)
1121// ★PER-CHANNEL ENTRY (2026-08-25): the three channels no longer have to share one N.L. Penner's
1122// pre-integration has TWO halves -- this file already shipped the CURVATURE half; the NORMAL half
1123// needs each channel lit by its OWN (differently blurred) normal, so the arithmetic takes three dots.
1124// sr_sss_preint delegates with all three EQUAL, so every existing caller and every existing tooth is
1125// bit-identical BY CONSTRUCTION and there is exactly ONE copy of this arithmetic -- a second copy is
1126// the duplicate-ruler defect, and the two halves of one shader are precisely where it would hide.
1127func sr_sss_preint_n(ndlr: i64, ndlg: i64, ndlb: i64, curv: i64) -> i64 {
1128 var cv: i64 = curv
1129 if cv < 0 { cv = 0 }
1130 if cv > SSS_CURV_MAX { cv = SSS_CURV_MAX }
1131 let wr: i64 = SSS_WRAP_R0 + cv * SSS_CURV_GAIN_R / SSS_CURV_MAX
1132 let wg: i64 = SSS_WRAP_G0 + cv * SSS_CURV_GAIN_G / SSS_CURV_MAX
1133 let wb: i64 = SSS_WRAP_B0 + cv * SSS_CURV_GAIN_B / SSS_CURV_MAX
1134 var dr: i64 = (ndlr + wr) * 256 / (256 + wr)
1135 var dg: i64 = (ndlg + wg) * 256 / (256 + wg)
1136 var db: i64 = (ndlb + wb) * 256 / (256 + wb)
1137 if dr < 0 { dr = 0 }
1138 if dg < 0 { dg = 0 }
1139 if db < 0 { db = 0 }
1140 if dr > 256 { dr = 256 }
1141 if dg > 256 { dg = 256 }
1142 if db > 256 { db = 256 }
1143 return dr + dg * 1024 + db * 1048576
1144}
1145func sr_sss_preint(ndl: i64, curv: i64) -> i64 { return sr_sss_preint_n(ndl, ndl, ndl, curv) }
1146// mean curvature of the SDF at p from the same stencil the normal uses: sum over axes of
1147// (f(p+e) + f(p-e) - 2 f(p)) / e, scaled to 0..256. Positive = convex (nose, finger). Six evals.
1148func sr_curvature(base: i64, px: i64, py: i64, pz: i64, e: i64, f0: i64) -> i64 {
1149 let lx: i64 = sdf_eval(base, px + e, py, pz) + sdf_eval(base, px - e, py, pz) - 2 * f0
1150 let ly: i64 = sdf_eval(base, px, py + e, pz) + sdf_eval(base, px, py - e, pz) - 2 * f0
1151 let lz: i64 = sdf_eval(base, px, py, pz + e) + sdf_eval(base, px, py, pz - e) - 2 * f0
1152 var lap: i64 = (lx + ly + lz) * SSS_CURV_SCALE / (e + 1)
1153 if lap < 0 { lap = 0 }
1154 if lap > SSS_CURV_MAX { lap = SSS_CURV_MAX }
1155 return lap
1156}
1157// =============================================================================================
1158// ★PRE-INTEGRATED NORMALS -- Penner 2011's SECOND half, and the one that stops the CLAY READ.
1159// [@penner2011] -- /compare/graphics row "RENDER: pre-integrated SSS bound to baked normals".
1160//
1161// THE DEFECT IT FIXES, LOCATED EXACTLY: sdf_shade_ray tilts ONE normal by the mesostructure height
1162// gradient (mat_height) and then lights ALL THREE channels with that single normal, so a 60um pore
1163// is rendered exactly as sharply in red as in blue. Real skin does the opposite -- red diffuses over
1164// roughly a millimetre and erases pore-scale relief entirely while blue stays sharp. Micro-relief lit
1165// identically in every channel IS the painted-clay read; the curvature half above pre-integrates the
1166// COARSE surface and nothing in this file pre-integrated the FINE relief until this rung.
1167//
1168// THE FIX: light each channel with its own normal, blended from the DETAIL normal toward the
1169// GEOMETRIC one by that channel's diffusion. Specular, rim, fill, AO and shadow keep the SHARP
1170// normal -- only the diffuse is pre-integrated. That split is Penner's own, and it is why the surface
1171// still reads as skin instead of going uniformly soft.
1172//
1173// EVERY WEIGHT IS DERIVED. THERE IS NO TUNABLE IN THIS BLOCK:
1174// (1) the per-channel diffusion profile is the SAME SSS_WRAP_R0/G0/B0 above -- ONE owner. Change the
1175// profile and the terminator wrap and the normal blur move TOGETHER, which is the physical truth
1176// and makes the two halves of the shader structurally incapable of disagreeing.
1177// (2) the relief's OWN angular width is read from the BAKED NORMAL MAP's two physical constants
1178// (nx_relief_lib.nx RLF_RELIEF_UM / RLF_RELIEF_LAMBDA_UM, which the BAKER reads too): a height
1179// field of amplitude A and
1180// wavelength L presents a peak surface tilt of about 4A/L -- rise 2A over run L/2, plain geometry
1181// -- which on the 0..256 N.L axis is SSS_N_FULL*4A/L. That is the width of the signal the
1182// diffusion competes against, and it is what "BOUND TO THE BAKED NORMALS" means here: re-bake the
1183// skin at a different relief and the scattering follows with no edit to this file.
1184// (3) blur_c = W_c / (W_c + W_relief) -- the standard diffusion low-pass ratio. A channel whose
1185// diffusion is WIDER than the relief's own width erases that relief; a channel narrower than it
1186// keeps it. No free parameter, and blur_r > blur_g > blur_b FOLLOWS from the profile, never from
1187// taste. Live: W_relief = 256*4*60/1200 = 51, blur r/g/b = 179/138/86 of 256.
1188// ✅THE MIRROR IS GONE (2026-08-25). SSS_RELIEF_UM / SSS_RELIEF_LAMBDA_UM / SSS_TILT_K were HAND COPIES
1189// of the baker's constants with a gate tooth comparing the copies -- a duplicate ruler that could only
1190// ever be caught AFTER it had drifted, and only while somebody kept running the comparison. The reason
1191// given for copying was real (importing nx_nxa_texbake_lib drags nx_nxa + nx_trimesh + nx_png +
1192// nx_skin_ita into all 46 consumers of this renderer), so the fix was not to import the baker: it was to
1193// give the law its own LEAF home, nx_relief_lib, which the baker and this file both import. There is
1194// nothing left to compare because there is nothing left to copy.
1195const SSS_N_FULL: i64 = 256 // this renderer's unit-normal / N.L scale
1196
1197// the relief's own angular width, in the SAME units as the wrap widths above
1198func sr_relief_wrap() -> i64 { return rlf_tilt_full(SSS_N_FULL) }
1199// how much of the fine relief a channel of diffusion width w erases, 0..SSS_N_FULL
1200func sr_sss_blur(w: i64) -> i64 { return w * SSS_N_FULL / (w + sr_relief_wrap()) }
1201// this channel's N.L, blended from the DETAIL dot toward the GEOMETRIC one.
1202// dot(lerp(a,b,t), L) == lerp(dot(a,L), dot(b,L), t) EXACTLY, so the per-channel normal is never built
1203// and never renormalized in the hot loop -- one multiply-add instead of a vector blend plus an isqrt.
1204// ⚠The exactness is in the LERP. Penner renormalizes the blended normal; at this relief's ~11 degree
1205// peak tilt the two differ by under 1%. Stated rather than hidden.
1206func sr_sss_ndl(nd: i64, gd: i64, blur: i64) -> i64 { return nd + (gd - nd) * blur / SSS_N_FULL }
1207// =============================================================================================
1208// ★THE SAMPLING HALF (2026-08-25): the DETAIL normal is now built from the BAKED NORMAL MAP'S OWN
1209// HEIGHT FIELD, not from a procedural stand-in. Until this rung sdf_shade_ray tilted the normal by
1210// mat_height (three value-noise octaves) through a hand-picked 10/16 gain, and the reach that produced
1211// was MEASURED at 18 on the 0..256 N.L axis against the baked map's own 51 -- so the per-channel blur,
1212// whose weights are derived FROM 51, was competing against a signal of a different width. The mechanism
1213// was correct and the signal it was handed was not the one it had been calibrated against.
1214//
1215// WHY A FIELD SAMPLE AND NOT AN ATLAS FETCH. A ray-marched implicit surface has no UV, so there is no
1216// texel to fetch; inventing a projection would be inventing a parameterisation, i.e. a tunable wearing
1217// a lookup. nx_relief_lib exposes the SAME height field the baker bakes -- rlf_relief_h3 and the
1218// baker's rlf_relief_h are the same rlf_noise3 -- so this reads the map's own field where a ray-marcher
1219// can reach it: same hash, same interpolation, same codomain, same physical law.
1220// ⚠And the ATLAS is the WEAKER witness, measured rather than assumed: rlf_atlas_tilt_full says a
1221// whole-body atlas can encode only SSS_N_FULL*60/(2*texel_um) of the law -- 4 at 1024, 9 at 2048, 18 at
1222// 4096 -- because the texel footprint clamps the relief lattice to two texels. Re-sampling that atlas
1223// would have handed the shader LESS relief than the procedural stand-in it replaces, not more. The gate
1224// prints those three numbers so the choice stays evidenced instead of asserted.
1225//
1226// EVERY WEIGHT IS DERIVED AND THE 10/16 GAIN IS GONE:
1227// (1) the LATTICE is the finest this sampler can carry: the +-e central difference spans exactly ONE
1228// cell, so cell = 2e where e is the shader's OWN half-step. Anything finer aliases -- the
1229// difference stops being a slope and becomes noise, which is what mat_height's two sub-cell
1230// octaves (9 and 5 model units, sampled at +-9) always were.
1231// (2) the GAIN is the baked map's angular width over the field's own full swing. |dh| <= RLF_H_RANGE
1232// and that bound is ATTAINED (two adjacent lattice corners at 0 and RLF_H_RANGE), so the peak tilt
1233// is EXACTLY rlf_tilt_full(SSS_N_FULL). That is a population fact about the field, never a sampled
1234// maximum -- a swept maximum would have been a sample published as a bound.
1235// (3) nothing here can be dialled: change the relief in nx_relief_lib and the mesostructure, the blur
1236// weights and the terminator wrap all move together, because ONE declaration is behind all three.
1237// It is also CHEAPER than what it replaces: 6 rlf_noise3 = 48 hashes per shaded pixel, against 6
1238// mat_height = 18 sk_vnoise = 144 sk_hash before.
1239// ⚠DECLARED IMPRECISION: preserving the PEAK slope across a band-limit overstates what a correct
1240// normal-map mip (Toksvig/LEAN, which preserve slope VARIANCE) would keep. The contract this rung is
1241// built to -- blur = W/(W+W_relief) with W_relief = 4A/L -- is stated in terms of the peak, so the peak
1242// is what is preserved. The variance-correct form is a further rung, not a knob on this one.
1243const SR_RELIEF_E: i64 = 9 // the shader's OWN central-difference half-step. It was spelled as the
1244 // 8201/8183 offsets either side of 8192; hoisted so the lattice DERIVES
1245 // from it instead of the two being free to disagree.
1246func sr_relief_cell() -> i64 { return 2 * SR_RELIEF_E }
1247// one sample of the baked normal map's own height field, at the lattice this sampler can resolve
1248func sr_relief_h(qx: i64, qy: i64, qz: i64) -> i64 { return rlf_relief_h3(qx, qy, qz, sr_relief_cell()) }
1249// a height DELTA -> a normal tilt on the 0..SSS_N_FULL axis. Peak in = RLF_H_RANGE, peak out = the baked
1250// map's own width. This function IS the former 10/16, with the picked number replaced by the law.
1251func sr_relief_tilt(dh: i64) -> i64 { return dh * rlf_tilt_full(SSS_N_FULL) / RLF_H_RANGE }
1252// the relief tilt along one model axis (0=x 1=y 2=z). ONE ruler -- the shader and its gate both call it,
1253// so a reach number measured by the gate is the reach the shipped shader actually has.
1254func sr_relief_grad(px: i64, py: i64, pz: i64, ax: i64) -> i64 {
1255 let e: i64 = SR_RELIEF_E
1256 if ax == 0 { return sr_relief_tilt(sr_relief_h(px + e, py, pz) - sr_relief_h(px - e, py, pz)) }
1257 if ax == 1 { return sr_relief_tilt(sr_relief_h(px, py + e, pz) - sr_relief_h(px, py - e, pz)) }
1258 return sr_relief_tilt(sr_relief_h(px, py, pz + e) - sr_relief_h(px, py, pz - e))
1259}
1260// =============================================================================================
1261func sdf_shade_ray(base: i64, rox: i64, roy: i64, roz: i64, rdx: i64, rdy: i64, rdz: i64, skin_r: i64, skin_g: i64, skin_b: i64, misscol: i64) -> i64 {
1262 let Lx: i64 = 121
1263 let Ly: i64 = 191
1264 let Lz: i64 = 0 - 121
1265 var t: i64 = 0
1266 var hit: i64 = 0
1267 var px: i64 = 0
1268 var py: i64 = 0
1269 var pz: i64 = 0
1270 var stepn: i64 = 0
1271 while stepn < 72 {
1272 px = rox + rdx * t / FX
1273 py = roy + rdy * t / FX
1274 pz = roz + rdz * t / FX
1275 let d: i64 = sdf_eval(base, px, py, pz)
1276 if d < 6 { hit = 1; stepn = 72 } else {
1277 t = t + d
1278 if t > PARTS_MAGIC_9000 { stepn = 72 } else { stepn = stepn + 1 }
1279 }
1280 }
1281 if hit == 0 {
1282 // ★P4 GROUND PLANE (figures only): the ray descends to the floor -> shade it with the figure's CONTACT
1283 // SHADOW (softshadow toward the light) + GI bounce + a radial fade to background. Grounds the figure.
1284 let fon: *i64 = (base + O_FLOOR) as *i64
1285 if fon[0] == 1 { if rdy < 0 {
1286 let FLOORY: i64 = 0 - PARTS_MAGIC_1445
1287 let tp: i64 = (FLOORY - roy) * FX / rdy
1288 if tp > 0 {
1289 let fxp: i64 = rox + rdx * tp / FX
1290 let fzp: i64 = roz + rdz * tp / FX
1291 let rr: i64 = sdf_isqrt(fxp * fxp + fzp * fzp)
1292 if rr < PARTS_MAGIC_3400 {
1293 var fade: i64 = 256 - rr * 256 / PARTS_MAGIC_3400
1294 if fade < 0 { fade = 0 }
1295 let shf: i64 = sdf_softshadow(base, fxp, FLOORY + 8, fzp, 484, 763, 0 - 484)
1296 let gpk: i64 = sdf_gi(base, fxp, FLOORY, fzp, 0, 256, 0)
1297 var fr: i64 = (118 * shf / 256 + gpk % 512) * fade / 256
1298 var fg: i64 = (116 * shf / 256 + (gpk / 512) % 512) * fade / 256
1299 var fbl: i64 = (126 * shf / 256 + gpk / PARTS_MAGIC_262144) * fade / 256
1300 // ★REFLECTIVE FLOOR: mirror the view about the up-normal, march UP; if it hits the figure,
1301 // blend the figure's lit skin tone into the floor = the studio-floor reflection look.
1302 let refy: i64 = 0 - rdy
1303 var rt2: i64 = 40
1304 var rhit: i64 = 0
1305 var rpx: i64 = 0
1306 var rpy: i64 = 0
1307 var rpz: i64 = 0
1308 var rst: i64 = 0
1309 while rst < 20 {
1310 rpx = fxp + rdx * rt2 / FX
1311 rpy = FLOORY + refy * rt2 / FX
1312 rpz = fzp + rdz * rt2 / FX
1313 let rd2: i64 = sdf_eval(base, rpx, rpy, rpz)
1314 if rd2 < 6 { rhit = 1; rst = 20 } else { rt2 = rt2 + rd2; if rt2 > PARTS_MAGIC_4200 { rst = 20 } else { rst = rst + 1 } }
1315 }
1316 if rhit == 1 {
1317 let e3: i64 = 12
1318 let rgx: i64 = sdf_eval(base, rpx + e3, rpy, rpz) - sdf_eval(base, rpx - e3, rpy, rpz)
1319 let rgy: i64 = sdf_eval(base, rpx, rpy + e3, rpz) - sdf_eval(base, rpx, rpy - e3, rpz)
1320 let rgz: i64 = sdf_eval(base, rpx, rpy, rpz + e3) - sdf_eval(base, rpx, rpy, rpz - e3)
1321 let rgl: i64 = sdf_isqrt(rgx * rgx + rgy * rgy + rgz * rgz)
1322 var rnl: i64 = 128
1323 if rgl > 0 { rnl = (rgx * 121 + rgy * 191 + rgz * (0 - 121)) / rgl; if rnl < 0 { rnl = 0 } }
1324 let rlit: i64 = 58 + rnl * 150 / 256
1325 let refl: i64 = 100 * fade / 256 // reflection strength, fades with the floor
1326 fr = fr + skin_r * rlit / 256 * refl / 256
1327 fg = fg + skin_g * rlit / 256 * refl / 256
1328 fbl = fbl + skin_b * rlit / 256 * refl / 256
1329 }
1330 fr = fr + (misscol % 256) * (256 - fade) / 256
1331 fg = fg + ((misscol / 256) % 256) * (256 - fade) / 256
1332 fbl = fbl + ((misscol / PARTS_MAGIC_65536) % 256) * (256 - fade) / 256
1333 return sdf_aces(fr) + sdf_aces(fg) * 256 + sdf_aces(fbl) * PARTS_MAGIC_65536
1334 }
1335 }
1336 } }
1337 return misscol
1338 }
1339 let e: i64 = 12
1340 let gx: i64 = sdf_eval(base, px + e, py, pz) - sdf_eval(base, px - e, py, pz)
1341 let gy: i64 = sdf_eval(base, px, py + e, pz) - sdf_eval(base, px, py - e, pz)
1342 let gz: i64 = sdf_eval(base, px, py, pz + e) - sdf_eval(base, px, py, pz - e)
1343 let gl: i64 = sdf_isqrt(gx * gx + gy * gy + gz * gz)
1344 var nx: i64 = 0
1345 var ny: i64 = 256
1346 var nz: i64 = 0
1347 if gl > 0 { nx = gx * 256 / gl; ny = gy * 256 / gl; nz = gz * 256 / gl }
1348 // ★GEOMETRIC (coarse) normal, banked BEFORE any relief perturbation below. The pre-integrated
1349 // diffuse needs BOTH ends of the per-channel blend; every other term still wants the SHARP normal,
1350 // so nothing else in this function changes.
1351 let gnx: i64 = nx
1352 let gny: i64 = ny
1353 let gnz: i64 = nz
1354 // MATERIAL: which part is this point on (0=skin default, 1=EYE, 2=HAIR, 3=BROW)
1355 let pid: i64 = sdf_eval_part(base, px, py, pz)
1356 var mat: i64 = sdf_surface_material(base, pid, px, py) // the lash line is the upper lid margin itself
1357 // BODY-HAIR groom (nx_char_layers LT_BODYHAIR): mats 14 (natural) / 15 (trimmed) are HAIRY SKIN -- remap to
1358 // the full skin pipeline (pores/SSS/GGX all apply) + a stubble fleck darkening after the albedo (density by
1359 // groom state). Shaved = plain mat 0. So grooming is a material nuance, not a separate flat material.
1360 var hairy: i64 = 0
1361 if mat == 14 { hairy = 1; mat = 0 }
1362 if mat == 15 { hairy = 2; mat = 0 }
1363 // BLUSH (mat 13) is SKIN with pigment, not a separate surface: route it through the FULL skin pipeline
1364 // (pores/SSS wrap/warm key/GGX) with a rosy albedo tint applied after the skin albedo -- a flat mat-13
1365 // branch lost the subsurface warmth and read as a gray patch under the cool fill (eyeball-caught 2026-07-07).
1366 var rosy: i64 = 0
1367 if mat == 13 { rosy = 1; mat = 0 }
1368 var band: i64 = 0
1369 if mat == 0 {
1370 // ★R2: displaced normal from the emitted HEIGHT field's GRADIENT (coherent organic relief), replacing
1371 // the old regular sine wobble. Central differences of mat_height along each axis; tilt N by -grad(h).
1372 // ★BAKED-MAP RELIEF (2026-08-25): the detail normal is tilted by the BAKED NORMAL MAP'S OWN
1373 // height field, through the gain that map's own physical law fixes -- see the sr_relief_* block
1374 // above. The procedural mat_height stand-in it replaces is left RUNNABLE (nothing in the shading
1375 // path calls it now) purely so the gate can keep measuring the incumbent reach as a LIVE control:
1376 // a baseline you cannot re-run is a number, not a control.
1377 nx = nx - sr_relief_grad(px, py, pz, 0)
1378 ny = ny - sr_relief_grad(px, py, pz, 1)
1379 nz = nz - sr_relief_grad(px, py, pz, 2)
1380 }
1381 if mat == 2 {
1382 // HAIR strand field: filaments = bands over the normal's x (constant-nx contours run crown->down,
1383 // i.e. combed meridians), jittered by value noise so strands wave; along-strand variation via y.
1384 band = it_sin4096(nx * 34 + sk_vnoise(px + SK_HASH_BIAS, py + SK_HASH_BIAS, pz + SK_HASH_BIAS, 34) * 5 + py / 9)
1385 ny = ny + band * 34 / IT_FX
1386 nx = nx + it_sin4096(nx * 34 + py / 5) * 20 / IT_FX
1387 }
1388 if mat == 3 {
1389 // BROW strands run horizontally -> bands over the normal's y
1390 band = it_sin4096(ny * 40 + sk_vnoise(px + SK_HASH_BIAS, py + SK_HASH_BIAS, pz + SK_HASH_BIAS, 22) * 4 + px / 6)
1391 nx = nx + band * 26 / IT_FX
1392 }
1393 let bl: i64 = sdf_isqrt(nx * nx + ny * ny + nz * nz)
1394 if bl > 0 { nx = nx * 256 / bl; ny = ny * 256 / bl; nz = nz * 256 / bl }
1395 // subtle skin-tone mottling (low freq)
1396 let mot: i64 = it_sin4096(px * 3 + py * 5 + pz * 2) * 9 / IT_FX
1397 var sr: i64 = skin_r + mot
1398 var sg: i64 = skin_g + mot * 2 / 3
1399 var sb: i64 = skin_b + mot / 2
1400 // ★R1 MATERIAL EMITTER channels (proc PBR, Substance/ZBrush-class, emit-not-paste): a per-surface ROUGHNESS
1401 // field + CAVITY, emitted below for skin and consumed by the microfacet spec. 0..256; rough low=oily.
1402 var skin_rough: i64 = 150
1403 var skin_cav: i64 = 0
1404 if mat == 0 {
1405 // PROCEDURAL SKIN: pores + freckles (Worley) + capillary blotch (2-octave value noise) + micro-grain.
1406 // Model-position keyed (+8192 offset keeps cell math positive). This is the fine_detail the critic
1407 // has pinned us on -- REAL micro-albedo, not lighting.
1408 let qx: i64 = px + SK_HASH_BIAS
1409 let qy: i64 = py + SK_HASH_BIAS
1410 let qz: i64 = pz + SK_HASH_BIAS
1411 let pk: i64 = sk_pore(qx, qy, qz)
1412 let pod: i64 = pk % PARTS_MAGIC_1024
1413 let frk: i64 = pk / PARTS_MAGIC_1024
1414 let bl1: i64 = sk_vnoise(qx, qy, qz, 150) // broad capillary redness patches
1415 let bl2: i64 = sk_vnoise(qx, qy, qz, 55) // fine tonal mottle
1416 sr = sr + bl1 * 9 / 128 + bl2 * 5 / 128
1417 sg = sg - bl1 * 4 / 128 + bl2 * 2 / 128
1418 sb = sb - bl1 * 5 / 128
1419 sr = sr - pod * 34 / 256
1420 sg = sg - pod * 38 / 256
1421 sb = sb - pod * 42 / 256
1422 sr = sr - frk / 3
1423 sg = sg - frk / 2
1424 sb = sb - frk * 2 / 3
1425 // ★PERVASIVE MULTI-OCTAVE MICRO-TEXTURE (replaces the single-scale grain): fills the flat lit regions
1426 // with skin surface variation at every scale -> the gradient-kurtosis climb the benchmark demanded.
1427 // Slight warm bias (skin reddens in the fine relief); all channels move together (luminance texture).
1428 let mamp: *i64 = (base + O_MTXAMP) as *i64
1429 let mtx: i64 = sk_microtex(qx, qy, qz) * mamp[0] / 256 // amplitude = the reverse-judge's search knob
1430 sr = sr + mtx + mtx / 6
1431 sg = sg + mtx
1432 sb = sb + mtx - mtx / 6
1433 if sr < 0 { sr = 0 }
1434 if sg < 0 { sg = 0 }
1435 if sb < 0 { sb = 0 }
1436 // ★E3 MAKEUP (baked into albedo, like a face texture's makeup layer): LIP color + cheek BLUSH, position-
1437 // keyed (makeup lives at fixed spots on the face). Lips also get gloss (lower roughness, below).
1438 var lipf: i64 = 0
1439 // the lip unit states its own vermilion outline; a body that declares no lip sweep keeps the legacy head-space window
1440 let lipu: i64 = sdf_lip_vermilion(base, px, py, pz)
1441 if lipu >= 0 { lipf = lipu } else {
1442 if py < 0 - 300 { if py > 0 - 495 { if pz < 0 - 470 {
1443 var lf: i64 = 232 - sdf_abs(px)
1444 if lf > 0 { if lf > 100 { lf = 100 } lipf = lf }
1445 } } }
1446 }
1447 sr = sr + lipf * 44 / 100
1448 sg = sg - lipf * 30 / 100
1449 sb = sb - lipf * 10 / 100
1450 var bdx: i64 = px + 300
1451 let bdxr: i64 = px - 300
1452 if sdf_abs(bdxr) < sdf_abs(bdx) { bdx = bdxr }
1453 let bdy: i64 = py + 30
1454 var blush: i64 = 150 - sdf_isqrt(bdx * bdx / 3 + bdy * bdy)
1455 if blush < 0 { blush = 0 }
1456 if pz < 0 - 360 {
1457 sr = sr + blush * 20 / 150
1458 sg = sg + blush * 5 / 150
1459 sb = sb + blush * 9 / 150
1460 }
1461 // ★rosy remap tint (the LT_MAKEUP cheek-apple parts): a warm rose shift ON TOP of the full skin albedo
1462 if rosy == 1 { sr = sr + 34; sg = sg - 4; sb = sb + 4 }
1463 if sg < 0 { sg = 0 }
1464 if sb < 0 { sb = 0 }
1465 // EMIT roughness: skin is matte (~170) EXCEPT the oily T-zone (upper + front-facing -> forehead/nose/
1466 // cheekbone sheen), plus a procedural mottle. Pores/creases read matte via the cavity channel.
1467 var tzone: i64 = (py - 300) / 4
1468 if tzone < 0 { tzone = 0 }
1469 if tzone > 95 { tzone = 95 }
1470 if pz > 0 { tzone = tzone / 3 } // only the FRONT of the form is oily
1471 skin_rough = 174 - tzone + sk_vnoise(qx, qy, qz, 85) / 6
1472 if skin_rough < 44 { skin_rough = 44 }
1473 if skin_rough > 232 { skin_rough = 232 }
1474 skin_cav = pod // pore/crease depth -> matte + (already) darkened
1475 if lipf > 45 { skin_rough = skin_rough - 68; if skin_rough < 28 { skin_rough = 28 } } // glossy lips
1476 }
1477 if mat == 2 {
1478 // HAIR albedo: deep warm brown, per-filament light/dark from the band + along-strand micro variation
1479 let hv: i64 = band * 26 / IT_FX + (sk_hash((py + SK_HASH_BIAS) / 5, (px + SK_HASH_BIAS) / 9, (pz + SK_HASH_BIAS) / 9) % 11) - 5
1480 sr = 74 + hv
1481 sg = 52 + hv * 3 / 4
1482 sb = 36 + hv / 2
1483 if sr < 0 { sr = 0 }
1484 if sg < 0 { sg = 0 }
1485 if sb < 0 { sb = 0 }
1486 }
1487 if mat == 3 {
1488 // BROW albedo: darker than scalp hair, same filament logic
1489 let bv: i64 = band * 20 / IT_FX
1490 sr = 56 + bv
1491 sg = 40 + bv * 3 / 4
1492 sb = 28 + bv / 2
1493 }
1494 if mat == 4 {
1495 // EYELASH: near-black, matte, cool -- the dark frame around the eye
1496 sr = 20; sg = 16; sb = 20
1497 }
1498 // OUTFIT materials (nx_outfit): clothing/armor as swap-slot geometry with cloth albedo. Additive -- existing
1499 // materials 0-4 untouched. A subtle weave mottle keeps the cloth from reading as flat plastic.
1500 if mat == 5 { let wv: i64 = sk_vnoise(qx, qy, qz, 40) / 8; sr = 150 + wv; sg = 44 + wv; sb = 50 + wv } // crimson tunic
1501 if mat == 6 { let wv: i64 = sk_vnoise(qx, qy, qz, 40) / 8; sr = 46 + wv; sg = 74 + wv; sb = 150 + wv } // blue robe
1502 if mat == 7 { let wv: i64 = sk_vnoise(qx, qy, qz, 40) / 8; sr = 52 + wv; sg = 118 + wv; sb = 66 + wv } // green cloak
1503 if mat == 8 { sr = 128; sg = 132; sb = 142 } // steel armor
1504 // MAKEUP materials (nx_makeup): a face-region cosmetic LAYER on sdf_face. Additive; a weave/skin mottle keeps
1505 // them from reading flat. Lipstick = berry on the lips; blush = a soft warm push on the cheekbones.
1506 if mat == 12 { let lv: i64 = sk_vnoise(qx, qy, qz, 26) / 12; sr = 156 + lv; sg = 46 + lv; sb = 70 + lv } // lipstick (berry)
1507 // (mat 13 blush is REMAPPED to the skin pipeline above -- see the rosy tint in the skin albedo block)
1508 if mat == 16 { let ev: i64 = sk_vnoise(qx, qy, qz, 22) / 14; sr = 140 + ev; sg = 84 + ev; sb = 160 + ev } // eyeshadow (soft plum on the upper lid -- the lid-part follow-on, 2026-07-07; bright enough to read under the brow shadow)
1509 if mat == 1 {
1510 // EYE: sclera / limbal ring / iris / pupil by the angle off the eyeball's FORWARD (-z) axis. The eye
1511 // is glossy (no bump), gets a wet catchlight via boosted spec below.
1512 let pp: *i64 = (base + O_PARTS) as *i64
1513 let ex: i64 = px - pp[pid * 6]
1514 let ey: i64 = py - pp[pid * 6 + 1]
1515 let ez: i64 = pz - pp[pid * 6 + 2]
1516 let el: i64 = sdf_isqrt(ex * ex + ey * ey + ez * ez)
1517 var facing: i64 = 0
1518 if el > 0 { facing = (0 - ez) * 256 / el }
1519 if facing > 238 { sr = 22; sg = 22; sb = 28 } // pupil
1520 else { if facing > 208 { sr = 78; sg = 104; sb = 138 } // iris (blue-gray)
1521 else { if facing > 196 { sr = 44; sg = 58; sb = 76 } // limbal ring
1522 else { sr = 232; sg = 228; sb = 220 } } } // sclera
1523 }
1524 // BODY-HAIR stubble over hairy skin: sparse dark flecks keyed to MODEL position (stick under camera orbit).
1525 // Groom sets density -- natural 38%, trimmed 15%; shaved skin never reaches here (plain mat 0).
1526 if hairy > 0 {
1527 var hden: i64 = 38
1528 if hairy == 2 { hden = 15 }
1529 let hfl: i64 = sk_hash(qx / 8, qy / 8, qz / 8) % 100
1530 if hfl < hden { sr = sr * 76 / 100; sg = sg * 72 / 100; sb = sb * 70 / 100 }
1531 }
1532 // ★A-R1 REFERENCE-PROJECTED ALBEDO: on FRONT-FACING, in-bounds surface (every material except HAIR 2 /
1533 // LASH 4 -- when aligned, the photo owns the face incl eyes/brows/lips). Bilinear sample in 1/16-px
1534 // precision; soft fade by facing angle + texture border blends into the procedural albedo at the
1535 // silhouette/hairline. O_FTEX==0 (every fresh arena) -> this whole block is skipped -> byte-identical.
1536 let ftx: *i64 = (base + O_FTEX) as *i64
1537 // eyes (mat 1) KEEP our render -- the photo's eyes are smaller than the eye geometry, so projecting them
1538 // smears murky sockets; our iris/pupil/catchlight read better (eyeball-caught). Hair 2 / lash 4 likewise.
1539 if ftx[0] != 0 { if mat != 2 { if mat != 4 { if mat != 1 {
1540 if nz < 0 - 40 {
1541 let tw: i64 = ftx[1]
1542 let th: i64 = ftx[2]
1543 let uq: i64 = ftx[3] * 16 + px * ftx[5] / 64
1544 let vq: i64 = ftx[4] * 16 - py * ftx[6] / 64
1545 let ui: i64 = uq / 16
1546 let vi: i64 = vq / 16
1547 // v BAND [vlo,vhi) from the arena (reference-specific: below the hairline, above/incl the chin --
1548 // hair wisps above the floor smudge the forehead, a dark parted mouth below the ceiling bruises
1549 // the lips; both eyeball-proven on ref #1). vhi<=0 = full frame. Band edges fade over 10px.
1550 var pvlo: i64 = ftx[7]
1551 var pvhi: i64 = ftx[8]
1552 if pvhi <= 0 { pvlo = 1; pvhi = th - 2 }
1553 if pvlo < 1 { pvlo = 1 }
1554 if pvhi > th - 2 { pvhi = th - 2 }
1555 if ui >= 1 { if ui < tw - 2 { if vi >= pvlo { if vi < pvhi {
1556 let fu: i64 = uq % 16
1557 let fv: i64 = vq % 16
1558 let tp: *u8 = ftx[0] as *u8
1559 let i00: i64 = (vi * tw + ui) * 3
1560 let i10: i64 = i00 + 3
1561 let i01: i64 = i00 + tw * 3
1562 let i11: i64 = i01 + 3
1563 var pr: i64 = ((tp[i00] as i64) * (16 - fu) + (tp[i10] as i64) * fu) * (16 - fv) + ((tp[i01] as i64) * (16 - fu) + (tp[i11] as i64) * fu) * fv
1564 var pg: i64 = ((tp[i00 + 1] as i64) * (16 - fu) + (tp[i10 + 1] as i64) * fu) * (16 - fv) + ((tp[i01 + 1] as i64) * (16 - fu) + (tp[i11 + 1] as i64) * fu) * fv
1565 var pb: i64 = ((tp[i00 + 2] as i64) * (16 - fu) + (tp[i10 + 2] as i64) * fu) * (16 - fv) + ((tp[i01 + 2] as i64) * (16 - fu) + (tp[i11 + 2] as i64) * fu) * fv
1566 pr = pr / 256
1567 pg = pg / 256
1568 pb = pb / 256
1569 // (the 90px-ref-era DETAIL LAYER -- pores+noise compensating upscale blur -- was REMOVED
1570 // 2026-07-08 with the hi-res reference: the compensation outlived its cause and pushed the
1571 // local-contrast statistics off the natural band. The photo now carries its own texture.)
1572 var fw: i64 = (0 - nz - 40) * 256 / 120
1573 if fw > 256 { fw = 256 }
1574 var bw: i64 = ui - 1
1575 let bw2: i64 = tw - 3 - ui
1576 if bw2 < bw { bw = bw2 }
1577 let bw3: i64 = vi - pvlo
1578 if bw3 < bw { bw = bw3 }
1579 let bw4: i64 = pvhi - 1 - vi
1580 if bw4 < bw { bw = bw4 }
1581 bw = bw * 256 / 10
1582 if bw > 256 { bw = 256 }
1583 if bw < 0 { bw = 0 }
1584 var f: i64 = fw
1585 if bw < f { f = bw }
1586 sr = (pr * f + sr * (256 - f)) / 256
1587 sg = (pg * f + sg * (256 - f)) / 256
1588 sb = (pb * f + sb * (256 - f)) / 256
1589 } } } }
1590 }
1591 } } } }
1592 var hl: i64 = (((nx * Lx + ny * Ly + nz * Lz) / 256) + 256) / 2
1593 if hl < 0 { hl = 0 }
1594 hl = hl * hl / 256
1595 let ox2: i64 = px + nx * 22 / 256
1596 let oy2: i64 = py + ny * 22 / 256
1597 let oz2: i64 = pz + nz * 22 / 256
1598 let sh: i64 = sdf_softshadow(base, ox2, oy2, oz2, 484, 763, 0 - 484)
1599 let ao: i64 = sdf_ao(base, px, py, pz, nx, ny, nz)
1600 // === LIGHTING RIG: hemisphere ambient (IBL floor) + shadowed KEY + cool FILL + back RIM ===
1601 // hemisphere ambient: cool-blue sky from +y, warm bounce from -y, gated by ambient occlusion
1602 // ★P2 ambient = ray-traced 1-bounce GI (directional environment + contact occlusion + warm crease bleed),
1603 // replacing the flat hemisphere term. (Already occlusion-weighted -- do NOT re-multiply by ao.)
1604 let gipk: i64 = sdf_gi(base, px, py, pz, nx, ny, nz)
1605 let aR: i64 = gipk % 512
1606 let aG: i64 = (gipk / 512) % 512
1607 let aB: i64 = gipk / PARTS_MAGIC_262144
1608 // ★E2 KEY: for SKIN, per-channel SUBSURFACE WRAP -- red light scatters FURTHEST around the terminator
1609 // (pre-integrated-skin idea: RGB diffuse falloff differs -> a reddened soft shadow line = flesh, not plastic).
1610 // Non-skin (eye/hair/lash) keeps the plain warm half-lambert.
1611 var kR: i64 = 0
1612 var kG: i64 = 0
1613 var kB: i64 = 0
1614 if mat == 0 {
1615 let ndl: i64 = (nx * Lx + ny * Ly + nz * Lz) / 256 // -256..256
1616 // sr_sss_preint: curvature-widened per-channel wrap (Penner-class). curv=0 reproduces the
1617 // former fixed 120/60/26 widths bit-for-bit, so flat regions are unchanged and tight features
1618 // (nose, fingers, ear rims) scatter wider -- flesh, not plastic, where it was clay.
1619 let curv: i64 = sr_curvature(base, px, py, pz, e, sdf_eval(base, px, py, pz))
1620 // ★PRE-INTEGRATED NORMALS (Penner's second half): the DETAIL dot above is the sharp,
1621 // relief-tilted surface; gdl is the COARSE body the relief sits on. Each channel is lit by its
1622 // own blend of the two, so the fine relief SCATTERS -- red loses most of it, blue keeps most --
1623 // while the coarse surface stays lit by the geometry. The blur weights are derived from the
1624 // baked normal map's own relief constants; see the sr_sss_blur block above.
1625 let gdl: i64 = (gnx * Lx + gny * Ly + gnz * Lz) / 256 // -256..256, GEOMETRIC (coarse) normal
1626 let ndr: i64 = sr_sss_ndl(ndl, gdl, sr_sss_blur(SSS_WRAP_R0))
1627 let ndg: i64 = sr_sss_ndl(ndl, gdl, sr_sss_blur(SSS_WRAP_G0))
1628 let ndb: i64 = sr_sss_ndl(ndl, gdl, sr_sss_blur(SSS_WRAP_B0))
1629 let sw: i64 = sr_sss_preint_n(ndr, ndg, ndb, curv)
1630 var wR: i64 = sw % 1024
1631 var wG: i64 = (sw / 1024) % 1024
1632 var wB: i64 = sw / 1048576
1633 kR = wR * sh / 256 * 240 / 256
1634 kG = wG * sh / 256 * 212 / 256
1635 kB = wB * sh / 256 * 176 / 256
1636 } else {
1637 let key: i64 = hl * sh / 256
1638 kR = key * 236 / 256
1639 kG = key * 220 / 256
1640 kB = key * 186 / 256
1641 }
1642 // FILL: cool, dim, NO shadow (fills don't cast), from camera-left-low, opposite the key
1643 let fdot: i64 = (nx * (0 - 198) + ny * 40 + nz * (0 - 158)) / 256
1644 var fil: i64 = (fdot + 256) / 2
1645 if fil < 0 { fil = 0 }
1646 fil = fil * fil / 256 * 78 / 256
1647 let fR: i64 = fil * 150 / 256
1648 let fG: i64 = fil * 174 / 256
1649 let fB: i64 = fil * 202 / 256
1650 // albedo x total diffuse irradiance (extended range; the shoulder tames it at output)
1651 var r: i64 = sr * (aR + kR + fR) / 256
1652 var g: i64 = sg * (aG + kG + fG) / 256
1653 var b: i64 = sb * (aB + kB + fB) / 256
1654 // RIM: back-and-up light catching the silhouette -> cool bright edge that separates from the background
1655 var rim: i64 = (nx * 30 + ny * 150 + nz * 200) / 256
1656 if rim < 0 { rim = 0 }
1657 rim = rim * rim / 256 * rim / 256 * 168 / 256
1658 r = r + rim * 196 / 256
1659 g = g + rim * 212 / 256
1660 b = b + rim
1661 if mat == 0 {
1662 // SUBSURFACE (terminator warmth) -- light wraps past the shadow line, reddening (SKIN only)
1663 let sss: i64 = hl * (256 - sh) / 256 * 28 / 256
1664 r = r + sss * 3 / 2
1665 g = g + sss / 2
1666 // SUBSURFACE (THICKNESS) -- thin surface (edges/ears/fingers) bleeds warm light through it
1667 let pinx: i64 = px - nx * 130 / 256
1668 let piny: i64 = py - ny * 130 / 256
1669 let pinz: i64 = pz - nz * 130 / 256
1670 let din: i64 = sdf_eval(base, pinx, piny, pinz)
1671 var interior: i64 = 0 - din
1672 if interior < 0 { interior = 0 }
1673 let transm: i64 = 256 * 150 / (interior + 150)
1674 let sss2: i64 = transm * 42 / 256
1675 r = r + sss2 * 5 / 4
1676 g = g + sss2 * 2 / 4
1677 b = b + sss2 / 4
1678 }
1679 // ★P3 IBL SPECULAR: surfaces REFLECT the environment (sky). Approx the reflected sky by the surface's
1680 // up-facing-ness (N.y), gated by FRESNEL (grazing angles reflect most) + GLOSS (smooth reflects sharper).
1681 // = the subtle cool sky-sheen every real surface has, complementing the P2 diffuse GI.
1682 var az: i64 = nz
1683 if az < 0 { az = 0 - az }
1684 var fres: i64 = 256 - az
1685 fres = fres * fres / 256 // Fresnel proxy ^2 (grazing = high)
1686 var skyup: i64 = (ny + 256) / 2 // 0..256 up-facing (reflects bright sky)
1687 if skyup < 0 { skyup = 0 }
1688 var glossf: i64 = 200 // non-skin default gloss
1689 if mat == 0 { glossf = 256 - skin_rough } // oily skin reflects sharper
1690 let ibl: i64 = fres * skyup / 256 * glossf / 256 * 58 / 256
1691 r = r + ibl * 3 / 4
1692 g = g + ibl * 7 / 8
1693 b = b + ibl // cool sky (more blue)
1694 // DUAL-LOBE specular (broad + tight, half-vector) -- skin's oily sheen. V = -ray dir.
1695 let vx: i64 = 0 - rdx / 4
1696 let vy: i64 = 0 - rdy / 4
1697 let vz: i64 = 0 - rdz / 4
1698 let hx0: i64 = Lx + vx
1699 let hy0: i64 = Ly + vy
1700 let hz0: i64 = Lz + vz
1701 let hl2: i64 = sdf_isqrt(hx0 * hx0 + hy0 * hy0 + hz0 * hz0)
1702 var ndoth: i64 = 0
1703 if hl2 > 0 {
1704 let Hx: i64 = hx0 * 256 / hl2
1705 let Hy: i64 = hy0 * 256 / hl2
1706 let Hz: i64 = hz0 * 256 / hl2
1707 ndoth = (nx * Hx + ny * Hy + nz * Hz) / 256
1708 }
1709 if ndoth < 0 { ndoth = 0 }
1710 let m2: i64 = ndoth * ndoth / 256
1711 let m4: i64 = m2 * m2 / 256
1712 let m8: i64 = m4 * m4 / 256
1713 let m16: i64 = m8 * m8 / 256
1714 let m32: i64 = m16 * m16 / 256
1715 var spc: i64 = (m8 * 38 / 256 + m32 * 66 / 256) * sh / 256
1716 if mat == 0 {
1717 // ★P1 Cook-Torrance GGX (physically-based microfacet, the AAA/PBR foundation): D_GGX(roughness) *
1718 // Schlick-Fresnel, energy-scaled by n.l + shadow. Roughness comes from R1's field. Replaces the ad-hoc
1719 // dual-lobe -> a real energy-shaped highlight (tight+bright on the oily T-zone, broad+soft on matte skin).
1720 let arg: i64 = skin_rough // roughness * 256
1721 let a2g: i64 = arg * arg / 256 // alpha^2 * 256
1722 let nh2g: i64 = ndoth * ndoth / 256 // (n.h)^2, fx256
1723 var ding: i64 = nh2g * (a2g - 256) / 256 + 256 // (n.h)^2(alpha^2-1)+1
1724 if ding < 1 { ding = 1 }
1725 var dd: i64 = ding * ding / 256
1726 if dd < 1 { dd = 1 }
1727 let Dg: i64 = a2g * PARTS_MAGIC_65536 / dd // GGX normal-distribution term
1728 let ug: i64 = 256 - ndoth
1729 let u2g: i64 = ug * ug / 256
1730 let u5g: i64 = u2g * u2g / 256 * ug / 256
1731 let Fg: i64 = 7 + (256 - 7) * u5g / 256 // Schlick Fresnel, F0=7 (~0.028, skin dielectric)
1732 var ndlg: i64 = (nx * Lx + ny * Ly + nz * Lz) / 256
1733 if ndlg < 0 { ndlg = 0 }
1734 spc = Dg * Fg / 256 * ndlg / 256 * sh / 256 * 26 / 256
1735 spc = spc * (256 - skin_cav * 3 / 4) / 256 // cavities suppress the highlight
1736 }
1737 if mat == 1 {
1738 // WET CORNEA: broad glossy sheen + a sharp near-white CATCHLIGHT (the #1 alive-eye cue) where the
1739 // tight lobe peaks -> a crisp bright dot on the eyeball.
1740 spc = spc * 3
1741 let m64: i64 = m32 * m32 / 256
1742 spc = spc + m64 * 210 / 256
1743 }
1744 if mat == 2 { spc = spc * 7 / 4 * (PARTS_MAGIC_2048 + band) / IT_FX + spc / 4 } // hair sheen rides the filaments (aniso-ish)
1745 if mat == 4 { spc = spc / 5 } // eyelashes are matte, not shiny
1746 if mat == 5 { spc = spc / 4 } // cloth: matte
1747 if mat == 6 { spc = spc / 4 }
1748 if mat == 7 { spc = spc / 4 }
1749 if mat == 8 { spc = spc * 5 / 2 } // armor: metallic sheen
1750 if mat == 12 { spc = spc * 2 } // lipstick: glossy sheen (blush mat 13 = skin-remapped, uses skin GGX)
1751 if mat == 16 { spc = spc * 5 / 4 } // eyeshadow: slight shimmer
1752 r = r + spc
1753 g = g + spc
1754 b = b + spc
1755 // ★P5 ACES filmic tonemap (AAA/film color operator) -- rich mids + smooth highlight roll-off, not a hard clip
1756 r = sdf_aces(r)
1757 g = sdf_aces(g)
1758 b = sdf_aces(b)
1759 return r + g * 256 + b * PARTS_MAGIC_65536
1760}
1761
1762// 2x2 SUPERSAMPLED anti-aliasing: 4 rays per pixel at quarter offsets, averaged -> smooth edges (no jaggies).
1763// ROW-RANGE core (y0 inclusive .. y1 exclusive): every pixel is independent -- it writes ONLY fb[y*W+x] and
1764// reads the part arena read-only -- so disjoint row ranges compose to the IDENTICAL full frame. That property
1765// is what the R1c thread fan-out (nx_sdfrender_mt) is byte-identity-gated on.
1766func sdf_render_rows(base: i64, yaw: i64, camz_units: i64, skin_r: i64, skin_g: i64, skin_b: i64, y0: i64, y1: i64) -> i64 {
1767 let fb: *i64 = (base + O_FB) as *i64
1768 let R: i64 = camz_units * FX
1769 let cy4: i64 = it_cos4096(yaw)
1770 let sy4: i64 = it_sin4096(yaw)
1771 var rox: i64 = 0 - sy4 * R / IT_FX
1772 var roz: i64 = 0 - cy4 * R / IT_FX
1773 // ★STEREO: shift the ray origin along the camera-RIGHT axis (perpendicular to the view dir, horizontal) by
1774 // the eye offset -> horizontal parallax between L/R eyes = sovereign stereo (rays keep their directions, so
1775 // this is an off-axis translation of the eye point). eye=0 -> unchanged (mono, byte-identical).
1776 let eyep: *i64 = (base + O_EYE) as *i64
1777 let eye: i64 = eyep[0]
1778 if eye != 0 { rox = rox + eye * cy4 / IT_FX; roz = roz - eye * sy4 / IT_FX }
1779 var y: i64 = y0
1780 while y < y1 {
1781 var x: i64 = 0
1782 while x < W {
1783 let misscol: i64 = (26 + y * 34 / H) + (28 + y * 32 / H) * 256 + (44 + y * 28 / H) * PARTS_MAGIC_65536
1784 var ar: i64 = 0
1785 var ag: i64 = 0
1786 var ab: i64 = 0
1787 var sj: i64 = 0
1788 while sj < 2 {
1789 var si: i64 = 0
1790 while si < 2 {
1791 let qx: i64 = 1 + si * 2 // sub-pixel 0.25 / 0.75
1792 let qy: i64 = 1 + sj * 2
1793 let ndcx: i64 = (4 * x + qx - 4 * HW) * FX / (4 * FOCAL)
1794 let ndcy: i64 = (4 * HH - (4 * y + qy)) * FX / (4 * FOCAL)
1795 let rl: i64 = sdf_isqrt(ndcx * ndcx + ndcy * ndcy + FX * FX)
1796 let vdx: i64 = ndcx * FX / rl
1797 let rdy: i64 = ndcy * FX / rl
1798 let vdz: i64 = FX * FX / rl
1799 let rdx: i64 = (cy4 * vdx + sy4 * vdz) / IT_FX
1800 let rdz: i64 = (0 - sy4 * vdx + cy4 * vdz) / IT_FX
1801 let col: i64 = sdf_shade_ray(base, rox, 0, roz, rdx, rdy, rdz, skin_r, skin_g, skin_b, misscol)
1802 ar = ar + (col & 255)
1803 ag = ag + ((col >> 8) & 255)
1804 ab = ab + ((col >> 16) & 255)
1805 si = si + 1
1806 }
1807 sj = sj + 1
1808 }
1809 fb[y * W + x] = (ar / 4) + (ag / 4) * 256 + (ab / 4) * PARTS_MAGIC_65536
1810 x = x + 1
1811 }
1812 y = y + 1
1813 }
1814 return 0
1815}
1816
1817// public single-thread full-frame render -- API unchanged for every existing consumer, wasm-safe (no thread
1818// imports in this file; the threaded lane lives in nx_sdfrender_mt.nx and is strictly additive).
1819func sdf_render(base: i64, yaw: i64, camz_units: i64, skin_r: i64, skin_g: i64, skin_b: i64) -> i64 {
1820 return sdf_render_rows(base, yaw, camz_units, skin_r, skin_g, skin_b, 0, H)
1821}