Skip to content

Dodaios is an open-source agent OS for your desktop: it runs your coding agents, browser and apps by voice or chat, on your own machine. Formerly Personal Jarvis.

feat(society): the lobby is a floating platform in the app's own tokens, closed from every angle

rubenluetke10-beep924652ab5939
diff --git a/jarvis/ui/web/frontend/src/components/society/figures/AgentFigureViewer.tsx b/jarvis/ui/web/frontend/src/components/society/figures/AgentFigureViewer.tsx
index 45638d7e2e..d78d869f45 100644
--- a/jarvis/ui/web/frontend/src/components/society/figures/AgentFigureViewer.tsx
+++ b/jarvis/ui/web/frontend/src/components/society/figures/AgentFigureViewer.tsx
@@ -36,8 +36,15 @@ import { useFigureAssets } from "./useFigureAssets";
/** Target resolution the pixel pass renders the column at (docs §9.3). */
const PIXEL_TARGET_WIDTH = 240;
-/** Camera pitch limits: straight down is +90°, straight up −90°; stop short of the poles. */
+/** Camera pitch limit upwards: straight down is +90°; stop short of the pole. */
const PITCH_LIMIT = (80 * Math.PI) / 180;
+/**
+ * How far the camera may dip below eye level. The figure stands on a lobby
+ * platform (LobbyStage); a camera under that platform sees its base cap and
+ * nothing else, so "from below" is the low, heroic angle — a little under
+ * the platform's top — never a view from beneath the floor.
+ */
+const PITCH_FLOOR = (12 * Math.PI) / 180;
const ZOOM_MIN = 0.55;
const ZOOM_MAX = 2.4;
@@ -90,7 +97,7 @@ export function AgentFigureViewer({ recipe, clip = "idle", quiet = false, classN
d.y = e.clientY;
const o = orbit.current;
o.yaw += dx * 0.012;
- o.pitch = Math.max(-PITCH_LIMIT, Math.min(PITCH_LIMIT, o.pitch + dy * 0.01));
+ o.pitch = Math.max(-PITCH_FLOOR, Math.min(PITCH_LIMIT, o.pitch + dy * 0.01));
setOrbitTick((n) => n + 1);
}, []);
const onPointerUp = useCallback((e: ReactPointerEvent<HTMLDivElement>) => {
@@ -117,12 +124,12 @@ export function AgentFigureViewer({ recipe, clip = "idle", quiet = false, classN
drag.current ? "cursor-grabbing" : "cursor-grab",
className,
)}
- // The figure stage is the island's own bright space, not the app's ink
- // (MASTERPLAN §4.3): warm light in both themes, so a dark figure — Gigi
- // is near-black with white marks — reads instead of vanishing.
+ // The room around the lobby is the app's own room (v4 tokens): a dark
+ // figure is separated from it by the lobby's accent rim light, not by
+ // painting the stage a warm colour of its own (LobbyStage).
style={{
background:
- "radial-gradient(120% 90% at 50% 38%, #fbf6ee 0%, #ebe2d2 52%, #d9cdb9 100%)",
+ "radial-gradient(120% 90% at 50% 40%, hsl(var(--secondary)) 0%, hsl(var(--background)) 72%)",
}}
onPointerDown={onPointerDown}
onPointerMove={onPointerMove}
@@ -163,7 +170,7 @@ export function AgentFigureViewer({ recipe, clip = "idle", quiet = false, classN
) : (
<PaletteTile palette={palette} label={t("society.figure.no_figure")} />
)}
- <p className="pointer-events-none absolute inset-x-0 bottom-2 text-center text-xs text-[#5b5245]/80">
+ <p className="pointer-events-none absolute inset-x-0 bottom-2 text-center text-xs text-muted-foreground">
{reduced ? t("society.figure.reduced_motion") : t("society.figure.drag_hint")}
</p>
</div>
@@ -258,12 +265,9 @@ function FigureScene({ recipe, look, palette, heightM, clip, quiet, paused, orbi
return (
<>
- <hemisphereLight args={[0xffffff, 0x8fa0b3, 1.15]} />
- <directionalLight position={[2.2, 4.5, 3.2]} intensity={1.9} />
- <directionalLight position={[-3, 2, -2]} intensity={0.45} />
<group ref={groupRef} />
- {/* The room the agent spawns into: podium, floor, back wall, beams (LobbyStage). */}
- <LobbyStage heightM={heightM} accent={palette.accent} paused={paused} />
+ {/* The room the agent spawns into, lights included (LobbyStage). */}
+ <LobbyStage heightM={heightM} paused={paused} />
</>
);
}
diff --git a/jarvis/ui/web/frontend/src/components/society/figures/LobbyStage.tsx b/jarvis/ui/web/frontend/src/components/society/figures/LobbyStage.tsx
index 72f221eee2..bd505dfd7e 100644
--- a/jarvis/ui/web/frontend/src/components/society/figures/LobbyStage.tsx
+++ b/jarvis/ui/web/frontend/src/components/society/figures/LobbyStage.tsx
@@ -1,229 +1,296 @@
/**
* The lobby behind a figure — the room the model card and the creator spawn
* an agent into (maintainer, 2026-09-02: "a lobby in the background, a bit
- * like a Fortnite lobby").
+ * like a Fortnite lobby", "professional, in our theme, correct from every
+ * angle, from below too").
*
- * Built from primitives, no assets: a slate podium with a ring in the agent's
- * accent colour, a tiled floor that fades into a curved back wall, warm
- * light strips on that wall, two light beams from above, a large ring
- * hanging behind the figure, and a few crates at the sides for scale. All
- * of it sits inside the pixel pass the viewer already runs, so it reads as
- * the same voxel world as the island. The room stays warm and bright in
- * both themes on purpose: a near-black figure (Gigi) must read against it.
+ * A floating platform, not a walled room: the viewer's camera may tilt to
+ * 80° below the floor, and a room with a floor and walls has nothing honest
+ * to show from there. A platform does — its underside is designed (a dark
+ * base cap with a glowing rim), so every angle the camera can reach shows
+ * closed, finished geometry: the tiled top with the accent ring, the bevelled
+ * edge, the base, a curved display wall behind the figure (two-sided), four
+ * pillars carrying light strips, and the app's room around it all.
*
- * Geometry is sized in figure heights so a 0.6 m fox and a 2.4 m spirit both
- * stand on a podium that fits, and the walls stay outside the camera's
- * farthest zoom. The ring's glow breathes only while the scene is awake.
+ * Colours are the app's own tokens, read from the stylesheet at mount and
+ * again when the theme flips (`--background`, `--secondary`, `--card`,
+ * `--border`, `--border-strong`, `--accent`): the lobby is the v4 room in
+ * both themes, never a colour of its own. A rim light in the accent colour
+ * from behind separates a dark figure (Gigi is near-black) from the dark
+ * room, which is how a lobby does it rather than by painting the room warm.
+ *
+ * Everything is sized in figure heights so a 0.6 m fox and a 2.4 m spirit
+ * both fit; the accent ring breathes only while the scene is awake.
*/
-import { useMemo, useRef } from "react";
+import { useEffect, useMemo, useRef, useState } from "react";
import { useFrame } from "@react-three/fiber";
import * as THREE from "three";
export interface LobbyStageProps {
/** The figure's rendered height; every measure here is relative to it. */
heightM: number;
- /** The agent's accent colour — the podium ring and the halo wear it. */
- accent: string;
/** No breathing glow while paused (reduced motion, off screen). */
paused: boolean;
}
-const WALL = 0xefe6d6;
-const WALL_PANEL = 0xe4d9c5;
-const FLOOR = 0xcbbfa8;
-const FLOOR_LINE = 0xb9ac94;
-const SLATE = 0x3a4150;
-const SLATE_DARK = 0x2b3140;
-const STRIP = 0xffd9a0;
-const BEAM = 0xfff1d6;
-
-/** A canvas-drawn tile grid: one texture, repeated, filtered nearest for the pixel look. */
-function makeGridTexture(): THREE.CanvasTexture | null {
- if (typeof document === "undefined") return null;
- const size = 128;
- const canvas = document.createElement("canvas");
- canvas.width = size;
- canvas.height = size;
- const ctx = canvas.getContext("2d");
- if (!ctx) return null;
- ctx.fillStyle = `#${FLOOR.toString(16).padStart(6, "0")}`;
- ctx.fillRect(0, 0, size, size);
- ctx.strokeStyle = `#${FLOOR_LINE.toString(16).padStart(6, "0")}`;
- ctx.lineWidth = 3;
- ctx.strokeRect(1.5, 1.5, size - 3, size - 3);
+interface LobbyTokens {
+ dark: boolean;
+ room: THREE.Color;
+ lift: THREE.Color;
+ object: THREE.Color;
+ line: THREE.Color;
+ lineStrong: THREE.Color;
+ accent: THREE.Color;
+}
+
+/** `--name: H S% L%` → a colour; a missing token falls back to `fallback`. */
+function readToken(style: CSSStyleDeclaration, name: string, fallback: string): THREE.Color {
+ const raw = style.getPropertyValue(name).trim();
+ const m = raw.match(/^([\d.]+)\s+([\d.]+)%\s+([\d.]+)%$/);
+ const c = new THREE.Color();
+ if (!m) return c.set(fallback);
+ return c.setHSL(Number(m[1]) / 360, Number(m[2]) / 100, Number(m[3]) / 100, THREE.SRGBColorSpace);
+}
+
+function readTokens(): LobbyTokens {
+ if (typeof document === "undefined") {
+ return {
+ dark: true,
+ room: new THREE.Color("#0a0a0a"),
+ lift: new THREE.Color("#1f1f1f"),
+ object: new THREE.Color("#171717"),
+ line: new THREE.Color("#262626"),
+ lineStrong: new THREE.Color("#383838"),
+ accent: new THREE.Color("#3d8bff"),
+ };
+ }
+ const root = document.documentElement;
+ const style = getComputedStyle(root);
+ return {
+ dark: root.classList.contains("dark"),
+ room: readToken(style, "--background", "#0a0a0a"),
+ lift: readToken(style, "--secondary", "#1f1f1f"),
+ object: readToken(style, "--card", "#171717"),
+ line: readToken(style, "--border", "#262626"),
+ lineStrong: readToken(style, "--border-strong", "#383838"),
+ accent: readToken(style, "--accent", "#3d8bff"),
+ };
+}
+
+/** The app's tokens, re-read whenever the root's class list (the theme) changes. */
+function useLobbyTokens(): LobbyTokens {
+ const [tokens, setTokens] = useState<LobbyTokens>(readTokens);
+ useEffect(() => {
+ if (typeof MutationObserver === "undefined") return;
+ const observer = new MutationObserver(() => setTokens(readTokens()));
+ observer.observe(document.documentElement, { attributes: true, attributeFilter: ["class"] });
+ return () => observer.disconnect();
+ }, []);
+ return tokens;
+}
+
+function pixelTexture(canvas: HTMLCanvasElement, repeatX: number, repeatY: number): THREE.CanvasTexture {
const texture = new THREE.CanvasTexture(canvas);
texture.wrapS = THREE.RepeatWrapping;
texture.wrapT = THREE.RepeatWrapping;
+ texture.repeat.set(repeatX, repeatY);
texture.magFilter = THREE.NearestFilter;
texture.minFilter = THREE.NearestFilter;
texture.colorSpace = THREE.SRGBColorSpace;
return texture;
}
-/** Vertical panels on the back wall: a lighter and a darker band, alternating. */
-function makePanelTexture(): THREE.CanvasTexture | null {
+/** The platform's top: tiles in the lift tone, hairlines in the border tone. */
+function makeTileTexture(t: LobbyTokens): THREE.CanvasTexture | null {
if (typeof document === "undefined") return null;
- const w = 256;
- const h = 32;
+ const size = 64;
const canvas = document.createElement("canvas");
- canvas.width = w;
- canvas.height = h;
+ canvas.width = size;
+ canvas.height = size;
const ctx = canvas.getContext("2d");
if (!ctx) return null;
- ctx.fillStyle = `#${WALL.toString(16).padStart(6, "0")}`;
- ctx.fillRect(0, 0, w, h);
- ctx.fillStyle = `#${WALL_PANEL.toString(16).padStart(6, "0")}`;
- for (let x = 0; x < w; x += 64) ctx.fillRect(x + 28, 0, 8, h);
+ ctx.fillStyle = t.lift.getStyle();
+ ctx.fillRect(0, 0, size, size);
+ ctx.strokeStyle = t.lineStrong.getStyle();
+ ctx.lineWidth = 2;
+ ctx.strokeRect(1, 1, size - 2, size - 2);
+ return pixelTexture(canvas, 14, 14);
+}
+
+/** The pool of light under the figure: accent-tinted at the centre, gone at the rim. */
+function makePoolTexture(t: LobbyTokens): THREE.CanvasTexture | null {
+ if (typeof document === "undefined") return null;
+ const size = 64;
+ const canvas = document.createElement("canvas");
+ canvas.width = size;
+ canvas.height = size;
+ const ctx = canvas.getContext("2d");
+ if (!ctx) return null;
+ const grad = ctx.createRadialGradient(size / 2, size / 2, 2, size / 2, size / 2, size / 2);
+ const a = t.accent;
+ const rgb = `${Math.round(a.r * 255)}, ${Math.round(a.g * 255)}, ${Math.round(a.b * 255)}`;
+ grad.addColorStop(0, `rgba(${rgb}, ${t.dark ? 0.35 : 0.22})`);
+ grad.addColorStop(0.6, `rgba(${rgb}, ${t.dark ? 0.1 : 0.06})`);
+ grad.addColorStop(1, `rgba(${rgb}, 0)`);
+ ctx.fillStyle = grad;
+ ctx.fillRect(0, 0, size, size);
const texture = new THREE.CanvasTexture(canvas);
- texture.wrapS = THREE.RepeatWrapping;
- texture.wrapT = THREE.ClampToEdgeWrapping;
texture.magFilter = THREE.NearestFilter;
texture.minFilter = THREE.NearestFilter;
texture.colorSpace = THREE.SRGBColorSpace;
return texture;
}
-export function LobbyStage({ heightM, accent, paused }: LobbyStageProps) {
+export function LobbyStage({ heightM, paused }: LobbyStageProps) {
const h = heightM;
+ const t = useLobbyTokens();
const ringRef = useRef<THREE.MeshStandardMaterial>(null);
- const haloRef = useRef<THREE.MeshStandardMaterial>(null);
- const grid = useMemo(makeGridTexture, []);
- const panels = useMemo(makePanelTexture, []);
- if (grid) grid.repeat.set(18, 18);
- if (panels) panels.repeat.set(9, 1);
-
- // The key light's target: R3F needs the object in the scene to aim at.
- const spotTarget = useMemo(() => {
- const o = new THREE.Object3D();
- o.position.set(0, h * 0.45, 0);
- return o;
- }, [h]);
+ const underRef = useRef<THREE.MeshStandardMaterial>(null);
+
+ const tiles = useMemo(() => makeTileTexture(t), [t]);
+ const pool = useMemo(() => makePoolTexture(t), [t]);
+ useEffect(
+ () => () => {
+ tiles?.dispose();
+ pool?.dispose();
+ },
+ [tiles, pool],
+ );
useFrame(({ clock }) => {
if (paused) return;
- const pulse = 0.55 + Math.sin(clock.elapsedTime * 1.6) * 0.2;
+ const pulse = 0.7 + Math.sin(clock.elapsedTime * 1.4) * 0.25;
if (ringRef.current) ringRef.current.emissiveIntensity = pulse;
- if (haloRef.current) haloRef.current.emissiveIntensity = pulse * 0.6;
+ if (underRef.current) underRef.current.emissiveIntensity = pulse * 0.8;
});
- // The room's reach: farther than the viewer's widest zoom can look.
- const wallR = h * 5.2;
- const wallH = h * 4.2;
- const floorR = h * 8;
- const podiumR = h * 0.58;
+ // Measures, in figure heights.
+ const platR = h * 1.35;
+ const platH = h * 0.3;
+ const wallR = h * 3.0;
+ const wallH = h * 2.4;
+ const pillarR = h * 2.35;
+
+ const accentHex = `#${t.accent.getHexString()}`;
+ const glow = t.dark ? 1.0 : 0.7;
+
+ const pillars = useMemo(() => {
+ const angles = [-1.25, -0.45, 0.45, 1.25]; // around the back half, 0 = straight behind
+ return angles.map((a) => ({
+ x: Math.sin(a) * pillarR,
+ z: -Math.cos(a) * pillarR,
+ ry: -a,
+ }));
+ }, [pillarR]);
- const strips = useMemo(() => {
- const out: { x: number; z: number; ry: number }[] = [];
+ // The display wall: seven flat panels on an arc behind the figure. Flat
+ // slabs, not a curved sheet — the pixel pass draws every facet edge, and
+ // on a smooth cylinder those read as spokes from above; on panels they
+ // are the seams a panelled wall has.
+ const panels = useMemo(() => {
const n = 7;
- for (let i = 0; i < n; i++) {
- const a = Math.PI * (0.16 + (0.68 * i) / (n - 1)); // spread across the back half
- out.push({ x: Math.cos(a) * (wallR - 0.05), z: -Math.sin(a) * (wallR - 0.05), ry: Math.PI / 2 - a });
- }
- return out;
+ const span = 1.9;
+ return Array.from({ length: n }, (_, i) => {
+ const a = -span / 2 + (span * i) / (n - 1);
+ return { x: Math.sin(a) * wallR, z: -Math.cos(a) * wallR, ry: -a, lifted: i % 2 === 0 };
+ });
}, [wallR]);
-
- const crates = useMemo(
- () => [
- { p: [-h * 2.2, h * 0.3, -h * 1.4], s: h * 0.6, c: SLATE },
- { p: [-h * 2.55, h * 0.18, -h * 0.7], s: h * 0.36, c: FLOOR_LINE },
- { p: [h * 2.35, h * 0.24, -h * 1.1], s: h * 0.48, c: SLATE },
- { p: [h * 2.35, h * 0.72, -h * 1.1], s: h * 0.3, c: FLOOR_LINE },
- { p: [h * 1.9, h * 0.16, -h * 2.2], s: h * 0.32, c: SLATE_DARK },
- ],
- [h],
- );
+ const panelW = (wallR * 1.9) / 7 + h * 0.02;
return (
<group>
- <fog attach="fog" args={[WALL, wallR * 0.9, wallR * 2.1]} />
- <primitive object={spotTarget} />
- <spotLight
- position={[0, h * 3.4, h * 1.2]}
- target={spotTarget}
- angle={0.42}
- penumbra={0.7}
- intensity={2.4}
- color={BEAM}
- distance={h * 8}
- />
-
- {/* floor */}
- <mesh rotation={[-Math.PI / 2, 0, 0]} position={[0, -0.001, 0]} receiveShadow>
- <circleGeometry args={[floorR, 48]} />
- {grid ? <meshStandardMaterial map={grid} color={0xffffff} /> : <meshStandardMaterial color={FLOOR} />}
- </mesh>
+ {/* Lights: a key from the front, a soft fill, and the accent rim from behind. */}
+ <hemisphereLight args={[t.dark ? 0xaab3c2 : 0xffffff, t.dark ? 0x1a1a1a : 0x8a8a8a, t.dark ? 0.9 : 1.0]} />
+ <directionalLight position={[2.2 * h, 3.4 * h, 2.8 * h]} intensity={t.dark ? 1.6 : 1.8} />
+ <directionalLight position={[-2.4 * h, 1.6 * h, 1.2 * h]} intensity={0.35} />
+ <directionalLight position={[0.6 * h, 2.2 * h, -3 * h]} intensity={t.dark ? 1.4 : 0.9} color={accentHex} />
- {/* podium: a wide base, a narrower top, the accent ring between */}
- <mesh position={[0, -h * 0.06, 0]}>
- <cylinderGeometry args={[podiumR * 1.3, podiumR * 1.38, h * 0.12, 32]} />
- <meshStandardMaterial color={SLATE_DARK} />
+ {/* The platform: one closed body (side, plain caps) … */}
+ <mesh position={[0, -platH / 2, 0]}>
+ <cylinderGeometry args={[platR, platR, platH, 48]} />
+ <meshStandardMaterial attach="material-0" color={t.lift} />
+ <meshStandardMaterial attach="material-1" color={t.lift} />
+ <meshStandardMaterial attach="material-2" color={t.line} />
</mesh>
- <mesh position={[0, -h * 0.012, 0]}>
- <cylinderGeometry args={[podiumR, podiumR, h * 0.024, 32]} />
- <meshStandardMaterial color={SLATE} />
- </mesh>
- <mesh position={[0, 0.002, 0]} rotation={[-Math.PI / 2, 0, 0]}>
- <ringGeometry args={[podiumR * 1.02, podiumR * 1.14, 40]} />
- <meshStandardMaterial ref={ringRef} color={accent} emissive={accent} emissiveIntensity={0.55} />
- </mesh>
-
- {/* the back wall: a half cylinder seen from inside, panelled */}
- <mesh position={[0, wallH / 2 - 0.02, 0]} rotation={[0, Math.PI, 0]}>
- <cylinderGeometry args={[wallR, wallR, wallH, 48, 1, true, 0, Math.PI]} />
- {panels ? (
- <meshStandardMaterial map={panels} color={0xffffff} side={THREE.BackSide} />
+ {/* … and the tiled top as a flat disc: a circle's UVs are planar, so the
+ grid stays a grid; a cylinder cap's are polar and turned it into spokes. */}
+ <mesh position={[0, 0.001, 0]} rotation={[-Math.PI / 2, 0, 0]}>
+ <circleGeometry args={[platR, 48]} />
+ {tiles ? (
+ <meshStandardMaterial map={tiles} color={0xffffff} />
) : (
- <meshStandardMaterial color={WALL} side={THREE.BackSide} />
+ <meshStandardMaterial color={t.lift} />
)}
</mesh>
- {/* a dark skirting where wall meets floor */}
- <mesh position={[0, h * 0.09, 0]} rotation={[0, Math.PI, 0]}>
- <cylinderGeometry args={[wallR - 0.02, wallR - 0.02, h * 0.18, 48, 1, true, 0, Math.PI]} />
- <meshStandardMaterial color={SLATE} side={THREE.BackSide} />
+ {/* the bevel lip on the top edge */}
+ <mesh position={[0, -h * 0.02, 0]}>
+ <cylinderGeometry args={[platR * 1.03, platR * 1.03, h * 0.04, 48]} />
+ <meshStandardMaterial color={t.lineStrong} />
</mesh>
-
- {/* warm light strips on the wall */}
- {strips.map((s, i) => (
- <mesh key={i} position={[s.x, wallH * 0.52, s.z]} rotation={[0, s.ry, 0]}>
- <boxGeometry args={[h * 0.07, wallH * 0.62, h * 0.04]} />
- <meshStandardMaterial color={STRIP} emissive={STRIP} emissiveIntensity={0.9} />
+ {/* the accent ring inset in the top */}
+ <mesh position={[0, 0.003, 0]} rotation={[-Math.PI / 2, 0, 0]}>
+ <ringGeometry args={[platR * 0.86, platR * 0.9, 64]} />
+ <meshStandardMaterial
+ ref={ringRef}
+ color={accentHex}
+ emissive={accentHex}
+ emissiveIntensity={0.7 * glow}
+ side={THREE.DoubleSide}
+ />
+ </mesh>
+ {/* the glowing rim under the platform — what a view from below is for */}
+ <mesh position={[0, -platH + h * 0.03, 0]} rotation={[Math.PI / 2, 0, 0]}>
+ <torusGeometry args={[platR * 0.98, h * 0.022, 8, 64]} />
+ <meshStandardMaterial ref={underRef} color={accentHex} emissive={accentHex} emissiveIntensity={0.6 * glow} />
+ </mesh>
+ {/* the pool of light the figure stands in, then a soft contact shadow */}
+ {pool ? (
+ <mesh rotation={[-Math.PI / 2, 0, 0]} position={[0, 0.004, 0]}>
+ <planeGeometry args={[h * 1.9, h * 1.9]} />
+ <meshBasicMaterial map={pool} transparent depthWrite={false} />
</mesh>
- ))}
-
- {/* the halo behind the figure */}
- <mesh position={[0, h * 0.95, -h * 1.9]}>
- <torusGeometry args={[h * 1.05, h * 0.035, 8, 48]} />
- <meshStandardMaterial ref={haloRef} color={accent} emissive={accent} emissiveIntensity={0.35} />
+ ) : null}
+ <mesh rotation={[-Math.PI / 2, 0, 0]} position={[0, 0.006, 0]}>
+ <circleGeometry args={[h * 0.26, 24]} />
+ <meshBasicMaterial color={0x000000} transparent opacity={t.dark ? 0.35 : 0.18} depthWrite={false} />
</mesh>
- {/* two light beams from above */}
- {[-1, 1].map((side) => (
- <mesh key={side} position={[side * h * 1.5, h * 2.4, -h * 0.9]} rotation={[0, 0, side * 0.32]}>
- <coneGeometry args={[h * 0.95, h * 4.6, 24, 1, true]} />
- <meshBasicMaterial
- color={BEAM}
- transparent
- opacity={0.14}
- depthWrite={false}
- blending={THREE.AdditiveBlending}
- side={THREE.DoubleSide}
- />
- </mesh>
+ {/* The display wall: seven panels on an arc, each with its accent line low down. */}
+ {panels.map((p, i) => (
+ <group key={i} position={[p.x, 0, p.z]} rotation={[0, p.ry, 0]}>
+ <mesh position={[0, wallH / 2 - h * 0.25, 0]}>
+ <boxGeometry args={[panelW, wallH, h * 0.08]} />
+ <meshStandardMaterial color={p.lifted ? t.lineStrong : t.lift} />
+ </mesh>
+ <mesh position={[0, h * 0.12, h * 0.045]}>
+ <boxGeometry args={[panelW * 0.92, h * 0.025, h * 0.01]} />
+ <meshStandardMaterial color={accentHex} emissive={accentHex} emissiveIntensity={0.8 * glow} />
+ </mesh>
+ </group>
))}
+ {/* the top rail that ties the panels together */}
+ <mesh position={[0, wallH - h * 0.22, 0]} rotation={[Math.PI / 2, 0, 0]}>
+ <torusGeometry args={[wallR, h * 0.035, 6, 64, 2.0]} />
+ <meshStandardMaterial color={t.lineStrong} />
+ </mesh>
- {/* crates for scale */}
- {crates.map((c, i) => (
- <mesh key={i} position={c.p as [number, number, number]}>
- <boxGeometry args={[c.s, c.s, c.s]} />
- <meshStandardMaterial color={c.c} />
- </mesh>
+ {/* Four pillars, each carrying a light strip. */}
+ {pillars.map((p, i) => (
+ <group key={i} position={[p.x, 0, p.z]} rotation={[0, p.ry, 0]}>
+ <mesh position={[0, h * 1.1 - h * 0.3, 0]}>
+ <boxGeometry args={[h * 0.16, h * 2.2, h * 0.16]} />
+ <meshStandardMaterial color={t.lift} />
+ </mesh>
+ <mesh position={[0, h * 1.1 - h * 0.3, h * 0.085]}>
+ <boxGeometry args={[h * 0.04, h * 1.6, h * 0.01]} />
+ <meshStandardMaterial color={accentHex} emissive={accentHex} emissiveIntensity={0.9 * glow} />
+ </mesh>
+ <mesh position={[0, -h * 0.3 - h * 0.05, 0]}>
+ <boxGeometry args={[h * 0.3, h * 0.1, h * 0.3]} />
+ <meshStandardMaterial color={t.lineStrong} />
+ </mesh>
+ </group>
))}
-
- {/* a soft contact blob under the feet, as before */}
- <mesh rotation={[-Math.PI / 2, 0, 0]} position={[0, 0.004, 0]}>
- <circleGeometry args={[h * 0.26, 24]} />
- <meshBasicMaterial color={0x1a2230} transparent opacity={0.22} depthWrite={false} />
- </mesh>
</group>
);
}