SIMON Master Console Rebuild

File viewer

guarded to /htdocs

/assetts/bg/43.html

<?php
declare(strict_types=1);

header('X-Content-Type-Options: nosniff');
header('Referrer-Policy: strict-origin-when-cross-origin');
header('Permissions-Policy: camera=(), microphone=(), geolocation=()');
?>
<!doctype html>
<html lang="en" data-system="simon" data-interface="data-sphere">
<head>
    <meta charset="utf-8">
    <meta name="viewport" content="width=device-width,initial-scale=1,viewport-fit=cover">
    <meta name="theme-color" content="#02070d">

<title>SIMON Intelligence — Data Sphere</title>

* {
            box-sizing: border-box;
        }

html,
        body {
            width: 100%;
            height: 100%;
            margin: 0;
            overflow: hidden;
            background: var(--bg);
            color: var(--white);
            font-family:
                Inter,
                ui-sans-serif,
                -apple-system,
                BlinkMacSystemFont,
                "Segoe UI",
                Arial,
                Helvetica,
                sans-serif;
        }

body {
            min-height: 100dvh;
        }

button,
        input {
            font: inherit;
        }

button {
            color: inherit;
        }

.background {
            position: fixed;
            inset: 0;
            z-index: 0;
            background:
                linear-gradient(
                    180deg,
                    rgba(0, 5, 12, 0.18) 0%,
                    rgba(0, 5, 12, 0.34) 45%,
                    rgba(0, 5, 12, 0.88) 100%
                ),
                radial-gradient(
                    circle at 50% 42%,
                    rgba(47, 171, 255, 0.16),
                    transparent 35%
                ),
                url("/assets/images/simon-intelligence-city.jpeg")
                center center / cover no-repeat;
            transform: scale(1.025);
            filter: saturate(1.08) contrast(1.04) brightness(0.72);
        }

.background::after {
            content: "";
            position: absolute;
            inset: 0;
            background:
                linear-gradient(
                    90deg,
                    rgba(0, 4, 10, 0.72),
                    transparent 26%,
                    transparent 74%,
                    rgba(0, 4, 10, 0.72)
                ),
                radial-gradient(
                    ellipse at center,
                    transparent 30%,
                    rgba(0, 4, 10, 0.52) 100%
                );
            pointer-events: none;
        }

#webgl {
            position: fixed;
            inset: 0;
            z-index: 2;
            width: 100%;
            height: 100%;
            display: block;
            pointer-events: auto;
        }

.noise {
            position: fixed;
            inset: 0;
            z-index: 3;
            opacity: 0.055;
            pointer-events: none;
            background-image:
                repeating-linear-gradient(
                    0deg,
                    rgba(255, 255, 255, 0.08) 0,
                    rgba(255, 255, 255, 0.08) 1px,
                    transparent 1px,
                    transparent 3px
                );
            mix-blend-mode: overlay;
        }

.scanline {
            position: fixed;
            left: 0;
            right: 0;
            top: -18%;
            height: 18%;
            z-index: 4;
            pointer-events: none;
            opacity: 0.22;
            background: linear-gradient(
                180deg,
                transparent,
                rgba(76, 225, 255, 0.05),
                rgba(76, 225, 255, 0.18),
                transparent
            );
            animation: scan 8s linear infinite;
        }

@keyframes scan {
            from {
                transform: translateY(0);
            }

to {
                transform: translateY(660%);
            }
        }

.interface {
            position: fixed;
            inset: 0;
            z-index: 5;
            pointer-events: none;
            padding:
                calc(20px + var(--safe-top))
                calc(20px + var(--safe-right))
                calc(20px + var(--safe-bottom))
                calc(20px + var(--safe-left));
        }

.topbar {
            display: flex;
            align-items: center;
            justify-content: space-between;
            gap: 18px;
        }

.brand {
            display: flex;
            align-items: center;
            gap: 13px;
            min-width: 0;
        }

.brand-mark {
            position: relative;
            width: 46px;
            height: 46px;
            flex: 0 0 auto;
            border: 1px solid var(--line-bright);
            border-radius: 14px;
            background:
                radial-gradient(
                    circle,
                    rgba(100, 228, 255, 0.25),
                    rgba(0, 20, 38, 0.72)
                );
            box-shadow:
                inset 0 0 18px rgba(100, 228, 255, 0.16),
                0 0 24px rgba(100, 228, 255, 0.14);
        }

.brand-mark::before,
        .brand-mark::after {
            content: "";
            position: absolute;
            inset: 10px;
            border: 1px solid var(--cyan);
            transform: rotate(45deg);
        }

.brand-mark::after {
            inset: 15px;
            border-color: rgba(168, 242, 255, 0.66);
        }

.brand-copy {
            min-width: 0;
        }

.brand-title {
            margin: 0;
            font-size: clamp(17px, 2vw, 24px);
            font-weight: 760;
            line-height: 1;
            letter-spacing: 0.2em;
            text-shadow: 0 0 18px rgba(100, 228, 255, 0.6);
            white-space: nowrap;
        }

.brand-subtitle {
            margin-top: 7px;
            color: var(--muted);
            font-size: 10px;
            letter-spacing: 0.23em;
            text-transform: uppercase;
            white-space: nowrap;
            overflow: hidden;
            text-overflow: ellipsis;
        }

.system-state {
            display: flex;
            align-items: center;
            gap: 10px;
            padding: 10px 13px;
            border: 1px solid var(--line);
            border-radius: 999px;
            background: rgba(2, 12, 23, 0.62);
            -webkit-backdrop-filter: blur(16px);
            backdrop-filter: blur(16px);
            color: var(--cyan-soft);
            font-size: 10px;
            font-weight: 700;
            letter-spacing: 0.16em;
            text-transform: uppercase;
        }

.status-light {
            width: 8px;
            height: 8px;
            border-radius: 50%;
            background: var(--green);
            box-shadow:
                0 0 6px var(--green),
                0 0 16px rgba(120, 255, 196, 0.85);
            animation: statusPulse 1.8s ease-in-out infinite;
        }

@keyframes statusPulse {
            50% {
                opacity: 0.48;
                transform: scale(0.82);
            }
        }

.side-panel {
            position: absolute;
            top: 50%;
            width: min(290px, calc(100vw - 40px));
            transform: translateY(-50%);
            padding: 18px;
            border: 1px solid var(--line);
            border-radius: 18px;
            background:
                linear-gradient(
                    145deg,
                    rgba(8, 25, 42, 0.76),
                    rgba(1, 8, 17, 0.52)
                );
            box-shadow:
                inset 0 0 28px rgba(92, 221, 255, 0.055),
                0 20px 60px rgba(0, 0, 0, 0.28);
            -webkit-backdrop-filter: blur(18px);
            backdrop-filter: blur(18px);
        }

.side-panel.left {
            left: calc(20px + var(--safe-left));
        }

.side-panel.right {
            right: calc(20px + var(--safe-right));
        }

.panel-label {
            margin: 0 0 14px;
            color: var(--cyan);
            font-size: 10px;
            font-weight: 800;
            letter-spacing: 0.24em;
            text-transform: uppercase;
        }

.metric-list {
            display: grid;
            gap: 13px;
        }

.metric {
            display: grid;
            grid-template-columns: 1fr auto;
            gap: 10px;
            align-items: center;
        }

.metric-name {
            color: var(--muted);
            font-size: 11px;
            letter-spacing: 0.06em;
            text-transform: uppercase;
        }

.metric-value {
            color: var(--white);
            font-family: ui-monospace, SFMono-Regular, Menlo, Monaco, Consolas, monospace;
            font-size: 12px;
        }

.meter {
            grid-column: 1 / -1;
            height: 3px;
            overflow: hidden;
            border-radius: 999px;
            background: rgba(255, 255, 255, 0.09);
        }

.meter > span {
            display: block;
            width: var(--value);
            height: 100%;
            border-radius: inherit;
            background: linear-gradient(90deg, var(--blue), var(--cyan));
            box-shadow: 0 0 10px rgba(100, 228, 255, 0.6);
            transition: width 400ms ease;
        }

.signal-log {
            display: grid;
            gap: 9px;
        }

.signal {
            display: grid;
            grid-template-columns: auto 1fr;
            gap: 9px;
            align-items: start;
            color: #b7c8d4;
            font-family: ui-monospace, SFMono-Regular, Menlo, Monaco, Consolas, monospace;
            font-size: 10px;
            line-height: 1.45;
        }

.signal::before {
            content: "";
            width: 5px;
            height: 5px;
            margin-top: 5px;
            border-radius: 50%;
            background: var(--cyan);
            box-shadow: 0 0 8px rgba(100, 228, 255, 0.8);
        }

.hero {
            position: absolute;
            left: 50%;
            bottom: calc(34px + var(--safe-bottom));
            width: min(760px, calc(100vw - 40px));
            transform: translateX(-50%);
            text-align: center;
        }

.hero-kicker {
            margin-bottom: 9px;
            color: var(--cyan);
            font-size: 10px;
            font-weight: 800;
            letter-spacing: 0.34em;
            text-transform: uppercase;
        }

.hero-title {
            margin: 0;
            font-size: clamp(42px, 8vw, 92px);
            font-weight: 820;
            line-height: 0.95;
            letter-spacing: clamp(0.1em, 1.5vw, 0.22em);
            text-indent: clamp(0.1em, 1.5vw, 0.22em);
            text-shadow:
                0 0 10px rgba(255, 255, 255, 0.45),
                0 0 25px rgba(78, 220, 255, 0.6),
                0 0 60px rgba(33, 128, 255, 0.34);
        }

.hero-subtitle {
            margin: 12px auto 0;
            max-width: 680px;
            color: #b1c5d3;
            font-size: clamp(10px, 1.5vw, 13px);
            letter-spacing: 0.18em;
            line-height: 1.6;
            text-transform: uppercase;
        }

.controls {
            position: absolute;
            left: 50%;
            bottom: calc(172px + var(--safe-bottom));
            display: flex;
            gap: 8px;
            transform: translateX(-50%);
            pointer-events: auto;
        }

.control {
            min-width: 44px;
            height: 40px;
            padding: 0 14px;
            border: 1px solid var(--line);
            border-radius: 999px;
            background: rgba(3, 14, 26, 0.64);
            -webkit-backdrop-filter: blur(15px);
            backdrop-filter: blur(15px);
            color: var(--cyan-soft);
            cursor: pointer;
            font-size: 10px;
            font-weight: 750;
            letter-spacing: 0.14em;
            text-transform: uppercase;
            transition:
                transform 160ms ease,
                border-color 160ms ease,
                background 160ms ease;
        }

.control:hover,
        .control:focus-visible {
            border-color: var(--line-bright);
            background: rgba(13, 40, 61, 0.8);
            outline: none;
            transform: translateY(-2px);
        }

.control[aria-pressed="true"] {
            border-color: rgba(120, 255, 196, 0.7);
            color: var(--green);
        }

.loading {
            position: fixed;
            inset: 0;
            z-index: 20;
            display: grid;
            place-items: center;
            background: #02070d;
            transition:
                opacity 600ms ease,
                visibility 600ms ease;
        }

.loading.hidden {
            opacity: 0;
            visibility: hidden;
        }

.loader {
            display: grid;
            place-items: center;
            gap: 16px;
        }

.loader-ring {
            width: 82px;
            height: 82px;
            border: 1px solid rgba(100, 228, 255, 0.2);
            border-top-color: var(--cyan);
            border-radius: 50%;
            box-shadow:
                inset 0 0 22px rgba(100, 228, 255, 0.07),
                0 0 24px rgba(100, 228, 255, 0.13);
            animation: spin 1.3s linear infinite;
        }

.loader-copy {
            color: var(--cyan-soft);
            font-size: 10px;
            font-weight: 700;
            letter-spacing: 0.24em;
            text-transform: uppercase;
        }

@keyframes spin {
            to {
                transform: rotate(360deg);
            }
        }

.fallback {
            position: fixed;
            inset: 0;
            z-index: 30;
            display: none;
            place-items: center;
            padding: 30px;
            background: rgba(0, 5, 11, 0.94);
            text-align: center;
        }

.fallback.visible {
            display: grid;
        }

.fallback-card {
            max-width: 540px;
            padding: 26px;
            border: 1px solid var(--line);
            border-radius: 20px;
            background: var(--panel-strong);
        }

.fallback-card h2 {
            margin-top: 0;
        }

.fallback-card p {
            color: var(--muted);
            line-height: 1.6;
        }

@media (max-width: 1060px) {
            .side-panel {
                width: 230px;
            }
        }

@media (max-width: 820px) {
            .side-panel {
                display: none;
            }

.controls {
                bottom: calc(155px + var(--safe-bottom));
            }

.background {
                background-position: 50% 50%;
            }
        }

@media (max-width: 560px) {
            .interface {
                padding:
                    calc(14px + var(--safe-top))
                    calc(14px + var(--safe-right))
                    calc(14px + var(--safe-bottom))
                    calc(14px + var(--safe-left));
            }

.brand-mark {
                width: 40px;
                height: 40px;
            }

.brand-title {
                font-size: 16px;
            }

.brand-subtitle {
                max-width: 190px;
                font-size: 8px;
            }

.system-state {
                padding: 9px;
            }

.system-state span:last-child {
                display: none;
            }

.hero {
                bottom: calc(24px + var(--safe-bottom));
            }

.hero-subtitle {
                max-width: 350px;
                font-size: 9px;
            }

.controls {
                bottom: calc(137px + var(--safe-bottom));
            }

.control {
                min-width: 38px;
                height: 36px;
                padding: 0 11px;
                font-size: 9px;
            }
        }

@media (prefers-reduced-motion: reduce) {
            .scanline,
            .status-light,
            .loader-ring {
                animation: none;
            }
        }
    </style>
</head>

<div class="brand-copy">
                    <h1 class="brand-title">SIMON</h1>
                    <div class="brand-subtitle">
                        Intelligence architecture · Data sphere
                    </div>
                </div>
            </div>

<div class="system-state">
                <span class="status-light" aria-hidden="true"></span>
                <span>System online</span>
            </div>
        </header>

<aside class="side-panel left" aria-label="System metrics">
            <h2 class="panel-label">System Health</h2>

<div class="metric-list">
                <div class="metric">
                    <span class="metric-name">Signal integrity</span>
                    <span class="metric-value" id="signalValue">98.4%</span>
                    <div class="meter">
                        <span id="signalMeter" style="--value:98.4%"></span>
                    </div>
                </div>

<div class="metric">
                    <span class="metric-name">Memory cohesion</span>
                    <span class="metric-value" id="memoryValue">94.7%</span>
                    <div class="meter">
                        <span id="memoryMeter" style="--value:94.7%"></span>
                    </div>
                </div>

<div class="metric">
                    <span class="metric-name">Truth confidence</span>
                    <span class="metric-value" id="truthValue">91.2%</span>
                    <div class="meter">
                        <span id="truthMeter" style="--value:91.2%"></span>
                    </div>
                </div>

<div class="metric">
                    <span class="metric-name">Sphere nodes</span>
                    <span class="metric-value" id="nodeCount">2,400</span>
                </div>

<div class="metric">
                    <span class="metric-name">Render state</span>
                    <span class="metric-value" id="renderState">ACTIVE</span>
                </div>
            </div>
        </aside>

<aside class="side-panel right" aria-label="Live signal stream">
            <h2 class="panel-label">Live Signal Stream</h2>

<div class="signal-log" id="signalLog">
                <div class="signal">Initializing cognitive visualization layer.</div>
                <div class="signal">Connecting memory and signal nodes.</div>
                <div class="signal">Truth evaluation matrix synchronized.</div>
                <div class="signal">Spatial intelligence engine online.</div>
                <div class="signal">Awaiting creator input.</div>
            </div>
        </aside>

<div class="controls" aria-label="Visualization controls">
            <button
                class="control"
                id="pauseButton"
                type="button"
                aria-pressed="false"
            >
                Pause
            </button>

<button
                class="control"
                id="pulseButton"
                type="button"
                aria-pressed="true"
            >
                Pulse
            </button>

<button
                class="control"
                id="resetButton"
                type="button"
            >
                Reset
            </button>
        </div>

<section class="hero" aria-label="SIMON identity">
            <div class="hero-kicker">Architects of reality</div>

<div class="hero-subtitle">
                Intelligence · Memory · Signal · Conscious systems
            </div>
        </section>
    </div>

<div class="loading" id="loadingScreen" aria-live="polite">
        <div class="loader">
            <div class="loader-ring" aria-hidden="true"></div>
            <div class="loader-copy">Activating SIMON data sphere</div>
        </div>
    </div>

<div class="fallback" id="fallback">
        <div class="fallback-card">
            <h2>SIMON visualization unavailable</h2>
            <p>
                Your browser could not initialize the WebGL visualization.
                The primary interface image remains available, but the live
                three-dimensional data sphere requires WebGL support.
            </p>
        </div>
    </div>

const canvas = document.getElementById("webgl");
        const loadingScreen = document.getElementById("loadingScreen");
        const fallback = document.getElementById("fallback");

const pauseButton = document.getElementById("pauseButton");
        const pulseButton = document.getElementById("pulseButton");
        const resetButton = document.getElementById("resetButton");

const reducedMotion = window.matchMedia(
            "(prefers-reduced-motion: reduce)"
        ).matches;

if (!window.THREE || !canvas) {
            loadingScreen.classList.add("hidden");
            fallback.classList.add("visible");
            return;
        }

let renderer;

try {
            renderer = new THREE.WebGLRenderer({
                canvas,
                antialias: true,
                alpha: true,
                powerPreference: "high-performance"
            });
        } catch (error) {
            console.error("SIMON WebGL initialization failed:", error);
            loadingScreen.classList.add("hidden");
            fallback.classList.add("visible");
            return;
        }

renderer.setPixelRatio(Math.min(window.devicePixelRatio || 1, 1.75));
        renderer.setSize(window.innerWidth, window.innerHeight, false);
        renderer.outputColorSpace = THREE.SRGBColorSpace;
        renderer.setClearColor(0x000000, 0);

const scene = new THREE.Scene();

const camera = new THREE.PerspectiveCamera(
            48,
            window.innerWidth / window.innerHeight,
            0.1,
            500
        );

camera.position.set(0, 0, 11.8);

const root = new THREE.Group();
        scene.add(root);

const sphereGroup = new THREE.Group();
        root.add(sphereGroup);

const pointer = {
            x: 0,
            y: 0,
            targetX: 0,
            targetY: 0
        };

let paused = false;
        let pulseEnabled = true;
        let elapsed = 0;
        let previousTime = performance.now();

const isMobile = window.matchMedia("(max-width: 820px)").matches;
        const particleCount = isMobile ? 1400 : 2400;
        const binaryCount = isMobile ? 130 : 260;
        const sphereRadius = isMobile ? 2.65 : 3.25;

const clock = new THREE.Clock();

function createGlowTexture() {
            const size = 128;
            const textureCanvas = document.createElement("canvas");
            textureCanvas.width = size;
            textureCanvas.height = size;

const context = textureCanvas.getContext("2d");
            const gradient = context.createRadialGradient(
                size / 2,
                size / 2,
                0,
                size / 2,
                size / 2,
                size / 2
            );

gradient.addColorStop(0, "rgba(255,255,255,1)");
            gradient.addColorStop(0.12, "rgba(150,245,255,1)");
            gradient.addColorStop(0.34, "rgba(59,194,255,0.72)");
            gradient.addColorStop(1, "rgba(0,90,255,0)");

context.fillStyle = gradient;
            context.fillRect(0, 0, size, size);

const texture = new THREE.CanvasTexture(textureCanvas);
            texture.colorSpace = THREE.SRGBColorSpace;

return texture;
        }

function createDigitTexture(digit) {
            const size = 96;
            const textureCanvas = document.createElement("canvas");
            textureCanvas.width = size;
            textureCanvas.height = size;

const context = textureCanvas.getContext("2d");

context.clearRect(0, 0, size, size);
            context.textAlign = "center";
            context.textBaseline = "middle";
            context.font = "700 58px ui-monospace, monospace";

context.shadowColor = "#45dcff";
            context.shadowBlur = 14;
            context.fillStyle = "#baf7ff";
            context.fillText(String(digit), size / 2, size / 2);

const texture = new THREE.CanvasTexture(textureCanvas);
            texture.colorSpace = THREE.SRGBColorSpace;

return texture;
        }

const glowTexture = createGlowTexture();

function createDataParticles() {
            const geometry = new THREE.BufferGeometry();
            const positions = new Float32Array(particleCount * 3);
            const colors = new Float32Array(particleCount * 3);
            const sizes = new Float32Array(particleCount);

const cyan = new THREE.Color(0x64e4ff);
            const blue = new THREE.Color(0x347dff);
            const white = new THREE.Color(0xe9fbff);

for (let index = 0; index < particleCount; index += 1) {
                const theta = Math.random() * Math.PI * 2;
                const cosinePhi = (Math.random() * 2) - 1;
                const phi = Math.acos(cosinePhi);

const shellOffset = (Math.random() - 0.5) * 0.34;
                const radius = sphereRadius + shellOffset;

const x = radius * Math.sin(phi) * Math.cos(theta);
                const y = radius * Math.sin(phi) * Math.sin(theta);
                const z = radius * Math.cos(phi);

const offset = index * 3;

positions[offset] = x;
                positions[offset + 1] = y;
                positions[offset + 2] = z;

const colorSelector = Math.random();
                const selectedColor =
                    colorSelector > 0.84
                        ? white
                        : colorSelector > 0.42
                            ? cyan
                            : blue;

colors[offset] = selectedColor.r;
                colors[offset + 1] = selectedColor.g;
                colors[offset + 2] = selectedColor.b;

sizes[index] = 0.7 + Math.random() * 1.6;
            }

geometry.setAttribute(
                "position",
                new THREE.BufferAttribute(positions, 3)
            );

geometry.setAttribute(
                "color",
                new THREE.BufferAttribute(colors, 3)
            );

geometry.setAttribute(
                "aSize",
                new THREE.BufferAttribute(sizes, 1)
            );

void main() {
                        vColor = color;

vec4 modelPosition =
                            modelMatrix * vec4(position, 1.0);

vec4 viewPosition =
                            viewMatrix * modelPosition;

gl_Position =
                            projectionMatrix * viewPosition;

float perspective =
                            80.0 / max(1.0, -viewPosition.z);

gl_PointSize =
                            aSize *
                            uPixelRatio *
                            perspective *
                            uPulse;
                    }
                `,
                fragmentShader: `
                    uniform sampler2D uTexture;
                    varying vec3 vColor;

void main() {
                        vec4 textureColor =
                            texture2D(uTexture, gl_PointCoord);

gl_FragColor =
                            vec4(
                                vColor,
                                textureColor.a * 0.84
                            ) * textureColor;
                    }
                `,
                vertexColors: true
            });

const points = new THREE.Points(geometry, material);
            points.userData.material = material;

sphereGroup.add(points);

return points;
        }

function createBinaryDigits() {
            const digitTextures = [
                createDigitTexture(0),
                createDigitTexture(1)
            ];

const materials = digitTextures.map((texture) => {
                return new THREE.SpriteMaterial({
                    map: texture,
                    transparent: true,
                    opacity: 0.76,
                    depthWrite: false,
                    blending: THREE.AdditiveBlending
                });
            });

const digitGroup = new THREE.Group();

for (let index = 0; index < binaryCount; index += 1) {
                const theta = Math.random() * Math.PI * 2;
                const phi = Math.acos((Math.random() * 2) - 1);
                const radius = sphereRadius + 0.2 + Math.random() * 0.38;

const sprite = new THREE.Sprite(
                    materials[Math.random() > 0.5 ? 1 : 0]
                );

sprite.position.set(
                    radius * Math.sin(phi) * Math.cos(theta),
                    radius * Math.sin(phi) * Math.sin(theta),
                    radius * Math.cos(phi)
                );

const scale = 0.12 + Math.random() * 0.13;
                sprite.scale.set(scale, scale, scale);

sprite.userData.phase = Math.random() * Math.PI * 2;
                sprite.userData.baseScale = scale;

digitGroup.add(sprite);
            }

sphereGroup.add(digitGroup);

return digitGroup;
        }

function createSphereShell() {
            const geometry = new THREE.SphereGeometry(
                sphereRadius * 0.965,
                64,
                64
            );

const material = new THREE.MeshBasicMaterial({
                color: 0x0a83b9,
                transparent: true,
                opacity: 0.035,
                wireframe: true,
                blending: THREE.AdditiveBlending,
                depthWrite: false
            });

const shell = new THREE.Mesh(geometry, material);
            sphereGroup.add(shell);

return shell;
        }

function createOrbit(radius, rotationX, rotationY, opacity) {
            const geometry = new THREE.TorusGeometry(
                radius,
                0.012,
                8,
                180
            );

const material = new THREE.MeshBasicMaterial({
                color: 0x64e4ff,
                transparent: true,
                opacity,
                blending: THREE.AdditiveBlending,
                depthWrite: false
            });

const ring = new THREE.Mesh(geometry, material);
            ring.rotation.x = rotationX;
            ring.rotation.y = rotationY;

sphereGroup.add(ring);

return ring;
        }

function createCore() {
            const geometry = new THREE.IcosahedronGeometry(0.48, 3);

const material = new THREE.MeshBasicMaterial({
                color: 0xa7f5ff,
                wireframe: true,
                transparent: true,
                opacity: 0.7,
                blending: THREE.AdditiveBlending
            });

const core = new THREE.Mesh(geometry, material);
            sphereGroup.add(core);

const coreGlowMaterial = new THREE.SpriteMaterial({
                map: glowTexture,
                transparent: true,
                opacity: 0.5,
                blending: THREE.AdditiveBlending,
                depthWrite: false
            });

const coreGlow = new THREE.Sprite(coreGlowMaterial);
            coreGlow.scale.set(2.5, 2.5, 2.5);
            sphereGroup.add(coreGlow);

return { core, coreGlow };
        }

function createBackgroundStars() {
            const count = isMobile ? 500 : 950;
            const geometry = new THREE.BufferGeometry();
            const positions = new Float32Array(count * 3);

for (let index = 0; index < count; index += 1) {
                const offset = index * 3;

positions[offset] = (Math.random() - 0.5) * 45;
                positions[offset + 1] = (Math.random() - 0.5) * 28;
                positions[offset + 2] = -4 - Math.random() * 25;
            }

geometry.setAttribute(
                "position",
                new THREE.BufferAttribute(positions, 3)
            );

const material = new THREE.PointsMaterial({
                color: 0x9cecff,
                size: 0.025,
                transparent: true,
                opacity: 0.5,
                blending: THREE.AdditiveBlending,
                depthWrite: false
            });

const stars = new THREE.Points(geometry, material);
            scene.add(stars);

return stars;
        }

const dataParticles = createDataParticles();
        const binaryDigits = createBinaryDigits();
        const shell = createSphereShell();

const orbitOne = createOrbit(
            sphereRadius * 1.13,
            Math.PI * 0.5,
            0,
            0.45
        );

const orbitTwo = createOrbit(
            sphereRadius * 1.28,
            Math.PI * 0.28,
            Math.PI * 0.22,
            0.28
        );

const orbitThree = createOrbit(
            sphereRadius * 1.39,
            Math.PI * 0.73,
            Math.PI * 0.12,
            0.2
        );

const { core, coreGlow } = createCore();
        const backgroundStars = createBackgroundStars();

sphereGroup.position.y = isMobile ? -0.5 : -0.1;

function updatePointer(clientX, clientY) {
            pointer.targetX = (clientX / window.innerWidth) * 2 - 1;
            pointer.targetY = -((clientY / window.innerHeight) * 2 - 1);
        }

window.addEventListener("pointermove", (event) => {
            updatePointer(event.clientX, event.clientY);
        }, { passive: true });

window.addEventListener("pointerleave", () => {
            pointer.targetX = 0;
            pointer.targetY = 0;
        });

window.addEventListener("deviceorientation", (event) => {
            if (
                typeof event.gamma !== "number" ||
                typeof event.beta !== "number"
            ) {
                return;
            }

pointer.targetX = THREE.MathUtils.clamp(
                event.gamma / 35,
                -1,
                1
            );

pointer.targetY = THREE.MathUtils.clamp(
                (event.beta - 45) / 50,
                -1,
                1
            );
        }, true);

pauseButton.addEventListener("click", () => {
            paused = !paused;
            pauseButton.setAttribute("aria-pressed", String(paused));
            pauseButton.textContent = paused ? "Resume" : "Pause";

document.getElementById("renderState").textContent =
                paused ? "PAUSED" : "ACTIVE";
        });

pulseButton.addEventListener("click", () => {
            pulseEnabled = !pulseEnabled;
            pulseButton.setAttribute(
                "aria-pressed",
                String(pulseEnabled)
            );
        });

resetButton.addEventListener("click", () => {
            pointer.x = 0;
            pointer.y = 0;
            pointer.targetX = 0;
            pointer.targetY = 0;

sphereGroup.rotation.set(0, 0, 0);
            root.rotation.set(0, 0, 0);
        });

function updateMetrics() {
            const signal = 97.8 + Math.random() * 1.6;
            const memory = 93.9 + Math.random() * 1.5;
            const truth = 90.5 + Math.random() * 1.8;

const metrics = [
                {
                    value: signal,
                    text: document.getElementById("signalValue"),
                    meter: document.getElementById("signalMeter")
                },
                {
                    value: memory,
                    text: document.getElementById("memoryValue"),
                    meter: document.getElementById("memoryMeter")
                },
                {
                    value: truth,
                    text: document.getElementById("truthValue"),
                    meter: document.getElementById("truthMeter")
                }
            ];

metrics.forEach((metric) => {
                const formatted = `${metric.value.toFixed(1)}%`;
                metric.text.textContent = formatted;
                metric.meter.style.setProperty(
                    "--value",
                    formatted
                );
            });
        }

window.setInterval(updateMetrics, 2400);

function animate(currentTime) {
            window.requestAnimationFrame(animate);

const delta = Math.min(
                (currentTime - previousTime) / 1000,
                0.05
            );

previousTime = currentTime;

if (!paused) {
                elapsed += delta;
            }

pointer.x += (pointer.targetX - pointer.x) * 0.045;
            pointer.y += (pointer.targetY - pointer.y) * 0.045;

root.rotation.y = pointer.x * 0.16;
            root.rotation.x = pointer.y * 0.09;

if (!paused && !reducedMotion) {
                sphereGroup.rotation.y += delta * 0.11;
                sphereGroup.rotation.x =
                    Math.sin(elapsed * 0.18) * 0.035;

shell.rotation.y -= delta * 0.035;

orbitOne.rotation.z += delta * 0.08;
                orbitTwo.rotation.z -= delta * 0.055;
                orbitThree.rotation.z += delta * 0.037;

core.rotation.x += delta * 0.18;
                core.rotation.y -= delta * 0.24;

backgroundStars.rotation.y += delta * 0.004;

binaryDigits.children.forEach((sprite, index) => {
                    if (index % 3 !== 0) {
                        return;
                    }

const flicker =
                        0.82 +
                        Math.sin(
                            elapsed * 2.2 +
                            sprite.userData.phase
                        ) * 0.18;

const scale =
                        sprite.userData.baseScale * flicker;

sprite.scale.set(scale, scale, scale);
                });
            }

const pulse = pulseEnabled && !reducedMotion
                ? 1 + Math.sin(elapsed * 2.4) * 0.08
                : 1;

dataParticles.userData.material.uniforms.uPulse.value =
                pulse;

coreGlow.scale.setScalar(
                2.5 +
                (
                    pulseEnabled && !reducedMotion
                        ? Math.sin(elapsed * 1.8) * 0.22
                        : 0
                )
            );

renderer.render(scene, camera);
        }

function handleResize() {
            const width = window.innerWidth;
            const height = window.innerHeight;

camera.aspect = width / height;
            camera.updateProjectionMatrix();

renderer.setPixelRatio(
                Math.min(window.devicePixelRatio || 1, 1.75)
            );

renderer.setSize(width, height, false);

dataParticles.userData.material.uniforms.uPixelRatio.value =
                Math.min(window.devicePixelRatio || 1, 1.75);
        }

window.addEventListener("resize", handleResize, {
            passive: true
        });

document.addEventListener("visibilitychange", () => {
            if (document.hidden) {
                previousTime = performance.now();
            }
        });

document.getElementById("nodeCount").textContent =
            particleCount.toLocaleString();

renderer.compile(scene, camera);
        renderer.render(scene, camera);

window.requestAnimationFrame(() => {
            loadingScreen.classList.add("hidden");
        });

window.requestAnimationFrame(animate);
    })();
    </script>
</body>
</html>

Quick jump

open a path

True command center for SIMON + WEB360

File viewer

Quick jump