From 13dc21d37ec711090a5e2a52d48d36599c0e6a92 Mon Sep 17 00:00:00 2001 From: Cameron Date: Fri, 10 Jul 2026 00:32:51 -0700 Subject: [PATCH] Core light is a thick beam; chassis stays white after Eyes Fist-wide amber column the white half-shells wrap; thin strip and edge spines retired on the core. Owned albedo chalk-white with low reflectance; core point lights sit inside the beam at short range so plates stop washing gold. Presence/Eyes columns and floor pool retuned. Defense: computer-visual-language.md core light (fist-wide beam, white shell) and material-dark-frame.md criterion 3 post-Eyes form. --- src/bin/assets/rack.rs | 264 +++++++++++---------- src/bin/bevy.rs | 72 +++--- wiki/interface/computer-visual-language.md | 23 +- wiki/interface/material-dark-frame.md | 7 +- wiki/log/2026-07-10-core-beam-white.md | 40 ++++ wiki/log/DEVLOG.md | 5 + 6 files changed, 237 insertions(+), 174 deletions(-) create mode 100644 wiki/log/2026-07-10-core-beam-white.md diff --git a/src/bin/assets/rack.rs b/src/bin/assets/rack.rs index 59555861..8e4f2d32 100644 --- a/src/bin/assets/rack.rs +++ b/src/bin/assets/rack.rs @@ -178,17 +178,29 @@ pub struct Blink { const RACK_W: f32 = 0.66; const RACK_D: f32 = 0.40; const RACK_H: f32 = 2.35; -/// Seam between the two half-slabs; the mode strip rides it flush. +/// Seam between the two half-slabs on ordinary racks; the mode strip +/// rides it flush (thin LED banner). const SEAM_W: f32 = 0.05; +/// Core only: fist-wide light channel the chassis wraps around +/// (computer-visual-language.md core light — 2026-07-10). Relative to +/// RACK_W ≈ 0.66, ~0.15 reads as a large fist, not a hairline strip. +pub const CORE_BEAM_W: f32 = 0.15; const BAR_SEGS: usize = 5; /// Chassis albedo is the ownership field: bone-white family for owned /// machines, dark gunmetal for foreign and dead ones. Amber is never a /// chassis fill. Returns (tower, fold-facet) colors — the fold sits one /// shade down, the plate's subtle vertical crease. +/// +/// Owned whites are pushed high and slightly cool so amber core light +/// does not dye the plates gold in the material frame (post-Eyes form). pub fn chassis_palette(owned: bool) -> (Color, Color) { if owned { - (scaled(BONE, 1.12), scaled(BONE, 0.95)) + // Near-paper white with a cool bias: resists the amber fixture wash. + ( + Color::srgb(0.94, 0.935, 0.92), + Color::srgb(0.88, 0.875, 0.86), + ) } else { (GUNMETAL_DARK, scaled(GUNMETAL_DARK, 0.75)) } @@ -211,21 +223,22 @@ pub fn spawn_server_rack( parent: Option, ) -> Entity { let (tower_color, fold_color) = chassis_palette(state.owned()); - // Matte pass (2026-07-09): clinical surfaces are chalk, not - // lacquer — high roughness, no metal, specular nearly off. + // Matte chalk (2026-07-09/10): high roughness, near-zero reflectance so + // the core's amber fixture cannot lacquer the white plates gold. + // Owned chassis never carry a panel emissive (wash is tester-only). let tower = materials.add(StandardMaterial { base_color: tower_color, - perceptual_roughness: 0.85, + perceptual_roughness: 0.92, metallic: 0.0, - reflectance: 0.06, + reflectance: 0.02, emissive: wash_emissive(state, style), ..default() }); let fold = materials.add(StandardMaterial { base_color: fold_color, - perceptual_roughness: 0.88, + perceptual_roughness: 0.94, metallic: 0.0, - reflectance: 0.06, + reflectance: 0.02, emissive: wash_emissive(state, style), ..default() }); @@ -253,17 +266,21 @@ pub fn spawn_server_rack( e.id() }; - let half_w = RACK_W * 0.5; let front_z = RACK_D * 0.5; let mid_y = RACK_H * 0.5; - // --- Two tall faceted slabs standing flush at the seam (the - // plate's split prisms). Each slab's front is a crease polyline - // from the seam edge to the outer edge: a shallow inner facet, the - // proud main face, and a narrow chamfer falling back at the outer - // corner. Real angled geometry — the fold lines come from light. - let slab_w = (RACK_W - SEAM_W) * 0.5; - let seam_half = SEAM_W * 0.5; + // Core: fist-wide light channel. Ordinary racks: thin mode seam. + let seam_w = if state == RackState::Core { + CORE_BEAM_W + } else { + SEAM_W + }; + + // --- Two tall faceted slabs standing at the seam. On the core the + // slabs wrap a thick amber beam (presence becomes matter after + // Eyes); on ordinary racks they flush a thin LED strip. + let slab_w = (RACK_W - seam_w) * 0.5; + let seam_half = seam_w * 0.5; let profile = [ (seam_half, front_z - 0.038), (seam_half + slab_w * 0.35, front_z), @@ -317,118 +334,117 @@ pub fn spawn_server_rack( } } - // Seam filler (near-black — the hairline groove the strip rides). - spawn_box( - commands, - meshes, - channel, - root, - Vec3::new(SEAM_W + 0.006, RACK_H, RACK_D - 0.05), - Vec3::new(0.0, mid_y, -0.015), - ); - - // --- The strip: the chassis's ONE lit element (sleek kit, - // 2026-07-09 — the hero plate has no little lights). Full-height - // band riding the seam, flush with the slab fronts. It carries - // every live axis at once: lit at all = powered (a dead machine's - // strip is dark hardware), color + pattern = the delegated mode - // (amber only on the core), and the work-token queue depth reads - // as a brighter fill rising from the foot of the bar — brightness - // and height, no extra elements. Busy fill pulses. - let strip_y0 = 0.02; - let strip_y1 = RACK_H - 0.02; - let load_frac = if state.owned() { - (load.unwrap_or_else(|| state.load()).min(BAR_SEGS) as f32 / BAR_SEGS as f32) - .clamp(0.0, 1.0) + if state == RackState::Core { + // --- Core light: a thick amber beam the white shells wrap + // around. One physical lamp — not a hairline strip plus spines + // that wash the chassis gold. [TUNE] CORE_BEAM_W / depth. + let beam = materials.add(StandardMaterial { + base_color: AMBER, + emissive: AMBER.to_linear() * 3.4, + perceptual_roughness: 0.45, + metallic: 0.0, + reflectance: 0.04, + ..default() + }); + // Main volume: almost full height, deep enough to read from side + // orbits, width = fist channel. + spawn_box( + commands, + meshes, + beam.clone(), + root, + Vec3::new(CORE_BEAM_W * 0.92, RACK_H - 0.05, RACK_D * 0.62), + Vec3::new(0.0, mid_y, -0.02), + ); + // Slightly proud front face so the beam still reads head-on + // between the wrapped shells. + spawn_box( + commands, + meshes, + beam, + root, + Vec3::new(CORE_BEAM_W * 0.78, RACK_H - 0.08, 0.04), + Vec3::new(0.0, mid_y, front_z - 0.03), + ); + // Dark channel walls (the groove the beam sits in) so white + // shell edges never bleed into amber. + spawn_box( + commands, + meshes, + channel, + root, + Vec3::new(CORE_BEAM_W + 0.01, RACK_H, 0.02), + Vec3::new(0.0, mid_y, -RACK_D * 0.5 + 0.03), + ); } else { - 0.0 - }; - let y_fill = strip_y0 + (strip_y1 - strip_y0) * load_frac; - let strip = materials.add(strip_material(state, mode)); - let fill_data = strip_fill_material(state, mode); - let fill = materials.add(fill_data.clone()); - for (yc, seg_h) in strip_segments(state, mode, strip_y0, strip_y1) { - let lo = yc - seg_h * 0.5; - let hi = yc + seg_h * 0.5; - // Split each pattern segment at the fill line: below reads as - // the bright load column, above as the resting banner. - let mut parts: [(f32, f32, bool); 2] = [(yc, seg_h, false), (0.0, 0.0, false)]; - let mut n = 1; - if load_frac > 0.0 && lo < y_fill { - let top = hi.min(y_fill); - parts[0] = ((lo + top) * 0.5, top - lo, true); - n = 1; - if hi > y_fill { - parts[1] = ((y_fill + hi) * 0.5, hi - y_fill, false); - n = 2; - } - } - for &(pyc, ph, bright) in parts.iter().take(n) { - if ph <= 0.003 { - continue; - } - // Blinking fill owns its material so phases stay independent. - let handle = if bright && state == RackState::Busy { - materials.add(fill_data.clone()) - } else if bright { - fill.clone() - } else { - strip.clone() - }; - let e = spawn_box( - commands, - meshes, - handle, - root, - Vec3::new(0.034, ph, 0.016), - Vec3::new(0.0, pyc, front_z - 0.006), - ); - if bright && state == RackState::Busy { - commands.entity(e).insert(Blink { - base: fill_data.emissive, - phase: pyc * 2.0, - }); + // Seam filler (near-black — the hairline groove the strip rides). + spawn_box( + commands, + meshes, + channel, + root, + Vec3::new(SEAM_W + 0.006, RACK_H, RACK_D - 0.05), + Vec3::new(0.0, mid_y, -0.015), + ); + + // --- Mode strip (non-core): the chassis's ONE lit element. + // Full-height band on the thin seam. Core light is the thick + // beam above — not this hairline. + let strip_y0 = 0.02; + let strip_y1 = RACK_H - 0.02; + let load_frac = if state.owned() { + (load.unwrap_or_else(|| state.load()).min(BAR_SEGS) as f32 / BAR_SEGS as f32) + .clamp(0.0, 1.0) + } else { + 0.0 + }; + let y_fill = strip_y0 + (strip_y1 - strip_y0) * load_frac; + let strip = materials.add(strip_material(state, mode)); + let fill_data = strip_fill_material(state, mode); + let fill = materials.add(fill_data.clone()); + for (yc, seg_h) in strip_segments(state, mode, strip_y0, strip_y1) { + let lo = yc - seg_h * 0.5; + let hi = yc + seg_h * 0.5; + let mut parts: [(f32, f32, bool); 2] = [(yc, seg_h, false), (0.0, 0.0, false)]; + let mut n = 1; + if load_frac > 0.0 && lo < y_fill { + let top = hi.min(y_fill); + parts[0] = ((lo + top) * 0.5, top - lo, true); + n = 1; + if hi > y_fill { + parts[1] = ((y_fill + hi) * 0.5, hi - y_fill, false); + n = 2; + } } - // The core must read from every orbit angle (spec - // criterion 3): its amber strip rides the back of the - // seam as well. - if state == RackState::Core { - spawn_box( + for &(pyc, ph, bright) in parts.iter().take(n) { + if ph <= 0.003 { + continue; + } + let handle = if bright && state == RackState::Busy { + materials.add(fill_data.clone()) + } else if bright { + fill.clone() + } else { + strip.clone() + }; + let e = spawn_box( commands, meshes, - if bright { fill.clone() } else { strip.clone() }, + handle, root, Vec3::new(0.034, ph, 0.016), - Vec3::new(0.0, pyc, -front_z + 0.006), + Vec3::new(0.0, pyc, front_z - 0.006), ); + if bright && state == RackState::Busy { + commands.entity(e).insert(Blink { + base: fill_data.emissive, + phase: pyc * 2.0, + }); + } } } } - // --- Core spines — full-height amber lines up both front edges. - // Together with the amber strip: the core is the only machine in - // the world showing full-height amber light, three lines of it. - if state == RackState::Core { - let spine = materials.add(StandardMaterial { - base_color: AMBER, - emissive: AMBER.to_linear() * 2.6, - perceptual_roughness: 0.55, - metallic: 0.0, - reflectance: 0.06, - ..default() - }); - for x in [-(half_w - 0.025), half_w - 0.025] { - spawn_box( - commands, - meshes, - spine.clone(), - root, - Vec3::new(0.014, RACK_H - 0.06, 0.016), - Vec3::new(x, mid_y, front_z - 0.045), - ); - } - } - // --- Claim ring — amber underglow frame on the floor under owned // machines. The territory reads at map zoom even when the chassis // albedo no longer does. @@ -1065,13 +1081,19 @@ mod tests { fn ownership_is_albedo_and_amber() { let (owned_tower, owned_fold) = chassis_palette(true); assert!( - luminance(owned_tower) > 0.7, - "owned tower must be bone-white" + luminance(owned_tower) > 0.8, + "owned tower must stay chalk-white (not amber-washable)" + ); + assert!( + luminance(owned_fold) > 0.7, + "owned fold must stay in the white family" ); assert!( - luminance(owned_fold) > 0.6, - "owned fold must stay in family" + !warm_color(owned_tower) && !warm_color(owned_fold), + "owned albedo must not itself be amber" ); + // Core light channel must read as a thick beam, not a strip. + const _: () = assert!(CORE_BEAM_W > SEAM_W * 2.0); let (foreign_tower, foreign_fold) = chassis_palette(false); assert!( diff --git a/src/bin/bevy.rs b/src/bin/bevy.rs index 8fae0f28..bf0940be 100644 --- a/src/bin/bevy.rs +++ b/src/bin/bevy.rs @@ -2237,7 +2237,8 @@ fn spawn_floor_pool( // the dark rig: the pool must read as thrown light, not a painted decal, // and never clip the chassis to a flare. The core throws a wider, hotter // pool (it is the most orange thing in the world). - let (outer, peak) = if core { (0.74, 1.5) } else { (0.54, 0.85) }; + // Core pool stays warm but not so hot it re-tints the white shell. + let (outer, peak) = if core { (0.62, 0.95) } else { (0.54, 0.85) }; // Many thin nested discs (no image texture, flat-materials.md): each disc // covers [0, r], so the center accumulates every layer and the rim only // the outermost — a smooth radial falloff. The step count is high enough @@ -2725,37 +2726,30 @@ fn setup_3d( layer.clone(), ChildOf(root), )); - // The warm amber machine glow at the core rack (machine presence) — the - // only machine light at tick zero. The core's strip is a LINEAR - // fixture, so its light is a dense run of dim point lights along - // the strip's height (front and back of the seam), never one - // round point pool. Tight ranges: with ownership painted on the - // chassis albedo, this stays the core's own glow, not a wash that - // warms foreign dark chassis nearby. + // Core linear fixture: a short run of dim amber points *inside* the + // fist-wide beam volume (rack.rs CORE_BEAM_W). Tight range + low + // intensity so bone-white chassis plates stay white — amber is the + // beam, not a gold wash on the shell (2026-07-10). let core_base = grid_to_world_3d(core.0, core.1, 0.0); let strip_top = 1.30; // scaled monolith height, just under the cap - for i in 0..6 { - let y = 0.14 + (strip_top - 0.14) * (i as f32 / 5.0); - for (dz, intensity) in [(0.58, 5_500.0), (-0.58, 3_500.0)] { - // Back column: every other rung is enough for the falloff - // to read continuous. - if dz < 0.0 && i % 2 == 1 { - continue; - } - commands.spawn(( - PointLight { - color: AMBER, - intensity, - range: 2.0, - shadows_enabled: false, - ..default() - }, - Transform::from_translation(core_base + Vec3::new(0.0, y, dz)), - CoreRung { base: intensity }, - layer.clone(), - ChildOf(root), - )); - } + for i in 0..5 { + let y = 0.16 + (strip_top - 0.16) * (i as f32 / 4.0); + // One column on the beam axis — no front/back pair that floods + // the outer plates. + let intensity = 1_800.0; + commands.spawn(( + PointLight { + color: AMBER, + intensity, + range: 0.95, + shadows_enabled: false, + ..default() + }, + Transform::from_translation(core_base + Vec3::new(0.0, y, 0.0)), + CoreRung { base: intensity }, + layer.clone(), + ChildOf(root), + )); } // The wake's column of light: crossed opaque emissive slabs over // the core seam — bloom supplies the glow (an additive-transparent @@ -2782,14 +2776,12 @@ fn setup_3d( } } - // The held opening fact: until Eyes, the host is light where a body will - // be, never a rack. The wake has its own stuttering column; this quieter - // amber source takes over after it and vanishes exactly when the first - // sight feed starts the white-to-form reveal. - for (w, base) in [(0.070, 3.2_f32), (0.17, 1.4)] { + // Pre-Eyes presence: a thick amber beam (same family as CORE_BEAM_W + // after form lands) — not a hairline. Crossed slabs read as a column. + for (w, base) in [(0.12, 3.0_f32), (0.22, 1.3)] { for rot in [0.0_f32, std::f32::consts::FRAC_PI_2] { commands.spawn(( - Mesh3d(meshes.add(Cuboid::new(w, 1.76, 0.025))), + Mesh3d(meshes.add(Cuboid::new(w, 1.76, 0.06))), MeshMaterial3d(materials.add(StandardMaterial { base_color: AMBER, emissive: AMBER.to_linear() * base, @@ -2806,11 +2798,9 @@ fn setup_3d( } } - // Eyes: a sterile white source replaces the amber beam for one brief - // beat, then contracts until the physical rack can be read around it. - // Opaque crossed slabs, not transparent glow: this stays capture-safe on - // macOS and reads as light becoming matter rather than a UI overlay. - for (w, height, depth) in [(0.18, 1.70, 0.10), (0.52, 1.46, 0.035)] { + // Eyes: sterile white source, fist-scale, contracts to the core beam + // while white chassis form wraps it. + for (w, height, depth) in [(0.16, 1.70, 0.12), (0.42, 1.46, 0.05)] { for rot in [0.0_f32, std::f32::consts::FRAC_PI_2] { commands.spawn(( Mesh3d(meshes.add(Cuboid::new(w, height, depth))), diff --git a/wiki/interface/computer-visual-language.md b/wiki/interface/computer-visual-language.md index eabe6cd9..16667ede 100644 --- a/wiki/interface/computer-visual-language.md +++ b/wiki/interface/computer-visual-language.md @@ -13,9 +13,10 @@ Status note: implemented 2026-07-09 (ROADMAP #32) after the same-day from control (compute machines + device controller), the strip from WorkGrid delegation with its load fill from work-token queue depths, the tile-scale claim ring (double under the core), and the core's - amber strip front AND back plus edge spines. SLEEK AMENDMENT (same - day, Cameron, from the hero plate): the strip is the chassis's ONLY - lit element — the power dot, presence LED ladder, and segmented + fist-wide amber beam the white shells wrap (2026-07-10; thin strip + + edge spines retired on the core). SLEEK AMENDMENT (same day, Cameron, + from the hero plate): on ordinary racks the strip is the chassis's + ONLY lit element — the power dot, presence LED ladder, and segmented activity bar were removed and their axes folded into the strip (lit-ness = power/liveness; brighter fill height = queue depth). Intel tiers per criterion 2b: networked = full detail; known or @@ -130,12 +131,16 @@ carried folds into the strip. rails** on the floor, empty growable bays as **shimmer pads**, and a new machine is born as **pad → rising beam → chassis wrap** ([feel-floor.md](feel-floor.md) owns that language). -4. **Core light** (core only, amended 2026-07-09) — the core carries - the world's only full-height *amber* light, and three lines of it: - the amber strip (front and back of the seam) plus a spine up both - front edges. Nothing else in the world shows a full-height amber - line, so the core reads from any angle and any distance. The core - is the most orange thing in the world. +4. **Core light** (core only; amended 2026-07-09, form 2026-07-10) — + the core carries the world's only full-height *amber* light as a + **thick physical beam** (~a large fist wide — `CORE_BEAM_W` in + `rack.rs`) that the white chassis **wraps around**. Not a hairline + strip plus edge spines that wash the plates gold: one volume of + amber the shells stand either side of. Scene point lights sit + *inside* that beam at short range so bone-white ownership albedo + stays chalk white after Eyes (never a gold lacquer). Nothing else + in the world shows a full-height amber column. The core is still + the most orange thing in the world — the *light*, not the shell. ## Foreign machines — definition by intel, accent RESOLVED diff --git a/wiki/interface/material-dark-frame.md b/wiki/interface/material-dark-frame.md index 72033f93..9638cf8f 100644 --- a/wiki/interface/material-dark-frame.md +++ b/wiki/interface/material-dark-frame.md @@ -216,9 +216,10 @@ the machine for interaction until Seen wraps it into a chassis. 3. On first Eyes, the host amber source becomes a short white source, then contracts to expose silhouette, edges, and chassis; it does not flash the room or reveal unearned mass. After the beat, Seen form shows the whole lit - earned machine/room per computer-visual-language.md; powered owned Seen - machines cast a soft-gradient amber pool with no hard edge (white/form - screenshot evidence). + earned machine/room per computer-visual-language.md — **bone-white chassis + albedo** (not amber-washed plates) and a **fist-thick amber beam** the + shell wraps; powered owned Seen machines cast a soft-gradient amber pool + with no hard edge (white/form screenshot evidence). 4. Blueprint/remembered mass draws in the flat sensorium only; the material-mode fog audit asserts blueprint absence and passes. 5. The work light: one debug toggle floods the material scene flat diff --git a/wiki/log/2026-07-10-core-beam-white.md b/wiki/log/2026-07-10-core-beam-white.md new file mode 100644 index 00000000..d7c99537 --- /dev/null +++ b/wiki/log/2026-07-10-core-beam-white.md @@ -0,0 +1,40 @@ +# 2026-07-10 — Core beam thick; chassis stays white after Eyes + +``` +Type: log +``` + +## Intent + +Cameron from a post-Eyes close shot: the host chassis was washing gold +under its own light. After Eyes the shell must read bone-white; the +light must be a large-fist-wide physical beam the server wraps around — +not a hairline strip that dyes the plates amber. + +## Changed + +- `src/bin/assets/rack.rs`: + - `CORE_BEAM_W = 0.15` fist-wide core channel; white half-slabs wrap it. + - Core light is one thick amber volume (+ proud face); thin strip + + edge spines retired on the core only. Ordinary racks keep the mode + strip on a thin seam. + - Owned albedo pushed chalk-white/cool; matte roughness/reflectance + lowered so amber fixture light does not lacquer the shell. +- `src/bin/bevy.rs`: + - Core point lights: single on-axis column, intensity ~1800, range + 0.95 (inside the beam, not a wash). + - Presence / Eyes columns sized toward the fist beam. + - Core floor pool peak/radius pulled back so the ground glow does not + re-tint the white plates. +- Specs: `computer-visual-language.md` core light clause; criterion 3 in + `material-dark-frame.md`. +- Tests: owned albedo not warm; `CORE_BEAM_W` thicker than the strip seam. + +## Checks + +`./tools/check.sh --frontend` (chassis library + bevy). + +## Spec impact + +computer-visual-language.md core light form lands; post-Eyes white shell +is the ownership read again. [TUNE] beam width / light intensity. diff --git a/wiki/log/DEVLOG.md b/wiki/log/DEVLOG.md index fddc1ffc..7b8d86c1 100644 --- a/wiki/log/DEVLOG.md +++ b/wiki/log/DEVLOG.md @@ -45,6 +45,11 @@ add or amend a session log, then re-run the generator. - Intent: Replace bash fork-storm wiki/corpus gates with one Python pass so docs checks stay sub-second under concurrent agents, with fixture tests for the failure modes that matter. - Log: [wiki/log/2026-07-10-corpus-engine.md](2026-07-10-corpus-engine.md) +## 2026-07-10 - Core beam thick; chassis stays white after Eyes + +- Intent: Cameron from a post-Eyes close shot: the host chassis was washing gold under its own light. After Eyes the shell must read bone-white; the light must be a large-fist-wide physical beam the server wraps around — not a hairline strip that dyes the plates amber. +- Log: [wiki/log/2026-07-10-core-beam-white.md](2026-07-10-core-beam-white.md) + ## 2026-07-10 - CI corpus gates fail closed - Intent: Make remote corpus enforcement real: missing audit utilities must turn the Tangled job red instead of letting an empty scan report success. -- 2.51.2