@jgengine/shell 0.8.0 → 0.10.0

package/dist/devtools/collisionDebug.js

@@ -0,0 +1,127 @@
+export const COLLISION_DEBUG_LAYERS = [
+    "hitboxes",
+    "bodies",
+    "projectiles",
+    "muzzles",
+    "aimLaser",
+];
+const DEFAULT_LAYERS = {
+    hitboxes: false,
+    bodies: false,
+    projectiles: false,
+    muzzles: false,
+    aimLaser: false,
+};
+export function createDefaultCollisionDebugState() {
+    return {
+        layers: { ...DEFAULT_LAYERS },
+        aimProbe: null,
+        projectileTraces: [],
+        maxProjectileTraces: 32,
+        projectileTraceLifeMs: 2500,
+    };
+}
+export function anyCollisionLayerOn(layers) {
+    return (layers.hitboxes ||
+        layers.bodies ||
+        layers.projectiles ||
+        layers.muzzles ||
+        layers.aimLaser);
+}
+export function colliderScanNeeded(layers) {
+    return layers.hitboxes || layers.bodies;
+}
+export function projectileListenNeeded(layers) {
+    return layers.projectiles || layers.muzzles;
+}
+export function aimProbeNeeded(layers) {
+    return layers.aimLaser;
+}
+export function createCollisionDebugController(initial = createDefaultCollisionDebugState()) {
+    let state = {
+        ...initial,
+        layers: { ...initial.layers },
+        projectileTraces: [...initial.projectileTraces],
+    };
+    const listeners = new Set();
+    let nextTraceId = 1;
+    function emit() {
+        for (const listener of listeners)
+            listener();
+    }
+    function replace(next) {
+        state = next;
+        emit();
+    }
+    return {
+        getState() {
+            return state;
+        },
+        subscribe(listener) {
+            listeners.add(listener);
+            return () => {
+                listeners.delete(listener);
+            };
+        },
+        setLayer(layer, on) {
+            if (state.layers[layer] === on)
+                return;
+            replace({ ...state, layers: { ...state.layers, [layer]: on } });
+        },
+        toggleLayer(layer) {
+            replace({ ...state, layers: { ...state.layers, [layer]: !state.layers[layer] } });
+        },
+        setLayers(partial) {
+            const layers = { ...state.layers, ...partial };
+            replace({ ...state, layers });
+        },
+        setAllLayers(on) {
+            const layers = {
+                hitboxes: on,
+                bodies: on,
+                projectiles: on,
+                muzzles: on,
+                aimLaser: on,
+            };
+            replace({ ...state, layers });
+        },
+        setAimProbe(probe) {
+            state = { ...state, aimProbe: probe };
+        },
+        getAimProbe() {
+            return state.aimProbe;
+        },
+        pushProjectileTrace(input) {
+            if (!projectileListenNeeded(state.layers))
+                return;
+            const trace = {
+                id: nextTraceId++,
+                origin: input.origin,
+                at: input.at,
+                hit: input.hit,
+                bornMs: input.nowMs ?? 0,
+            };
+            const next = [...state.projectileTraces, trace];
+            while (next.length > state.maxProjectileTraces)
+                next.shift();
+            replace({ ...state, projectileTraces: next });
+        },
+        pruneProjectileTraces(nowMs) {
+            if (state.projectileTraces.length === 0)
+                return;
+            const life = state.projectileTraceLifeMs;
+            const next = state.projectileTraces.filter((trace) => nowMs - trace.bornMs <= life);
+            if (next.length === state.projectileTraces.length)
+                return;
+            replace({ ...state, projectileTraces: next });
+        },
+        reset() {
+            nextTraceId = 1;
+            replace(createDefaultCollisionDebugState());
+        },
+        isActive() {
+            return anyCollisionLayerOn(state.layers);
+        },
+    };
+}
+export const collisionDebug = createCollisionDebugController();

package/dist/devtools/collisionDebugMath.d.ts

@@ -0,0 +1,103 @@
+import type { EntityPosition } from "@jgengine/core/scene/entityStore";
+import { type ColliderPurpose, type EntityColliderSet, type ResolvedCollider } from "@jgengine/core/scene/colliders";
+import { type SceneRaycastApi, type SceneRaycastHit } from "@jgengine/core/scene/sceneRaycast";
+import { type ShotOriginPolicy } from "@jgengine/core/combat/shotOrigin";
+import type { Aim } from "@jgengine/core/scene/spatial";
+import type { CollisionDebugLayers } from "./collisionDebug.js";
+export type AimEndpointKind = "damage" | "solid" | "miss";
+export interface DebugShapeEntry {
+    key: string;
+    targetKind: "entity" | "object";
+    instanceId: string;
+    catalogId?: string;
+    name: string;
+    purpose: ColliderPurpose;
+    damageEligible: boolean;
+    blocks: boolean;
+    position: EntityPosition;
+    rotationY: number;
+    shape: {
+        kind: "sphere";
+        radius: number;
+        center: EntityPosition;
+    } | {
+        kind: "aabb";
+        halfExtents: EntityPosition;
+        center: EntityPosition;
+    };
+    label: string;
+    style: "hitbox" | "body";
+}
+export interface AimLaserDebug {
+    origin: EntityPosition;
+    direction: EntityPosition;
+    end: EntityPosition;
+    maxDistance: number;
+    kind: AimEndpointKind;
+    nearest: SceneRaycastHit | null;
+    firstImpact: SceneRaycastHit | null;
+    /** Counts scene raycast calls performed (0 when skipped). */
+    queryCount: number;
+}
+export interface CollectDebugShapesInput {
+    layers: CollisionDebugLayers;
+    entities: readonly {
+        id: string;
+        position: EntityPosition;
+        rotationY: number;
+        name?: string;
+    }[];
+    objects?: readonly {
+        instanceId: string;
+        catalogId: string;
+        position: EntityPosition;
+        rotationY: number;
+    }[];
+    entityCollidersOf?(instanceId: string): EntityColliderSet | null | undefined;
+    objectCollidersOf?(instanceId: string): EntityColliderSet | null | undefined;
+    objectHalfExtentsOf?(catalogId: string): EntityPosition | null | undefined;
+    /** Mutated when a scene scan runs — tests assert 0 when hidden. */
+    counters?: {
+        scans: number;
+        shapes: number;
+    };
+}
+export declare function classifyAimEndpoint(hit: Pick<SceneRaycastHit, "damageEligible"> | null | undefined): AimEndpointKind;
+export declare function pointAlongRay(origin: EntityPosition, direction: EntityPosition, distance: number): EntityPosition;
+export declare function shapeWorldCenter(collider: ResolvedCollider, position: EntityPosition, rotationY: number): EntityPosition;
+/**
+ * Collects world-space collider wireframe entries for enabled layers.
+ * Returns [] and performs no entity/object iteration when both hitbox/body layers are off.
+ */
+export declare function collectDebugShapes(input: CollectDebugShapesInput): DebugShapeEntry[];
+export interface ComputeAimLaserInput {
+    layers: CollisionDebugLayers;
+    sceneRaycast: SceneRaycastApi;
+    positionOf(instanceId: string): EntityPosition | undefined;
+    rotationYOf?(instanceId: string): number | undefined;
+    collidersOf?(instanceId: string): EntityColliderSet | null | undefined;
+    from: string;
+    aim: Aim;
+    originPolicy?: ShotOriginPolicy;
+    maxDistance: number;
+    counters?: {
+        queries: number;
+    };
+}
+/**
+ * Builds the authoritative aim-laser segment using resolveShot + scene raycast
+ * (same seam as projectile prediction/settlement). Zero queries when aimLaser is off.
+ */
+export declare function computeAimLaser(input: ComputeAimLaserInput): AimLaserDebug | null;
+export declare function muzzleMarkerFromOrigin(origin: EntityPosition): {
+    center: EntityPosition;
+    radius: number;
+    color: string;
+};
+export declare const HITBOX_WIRE_COLOR = "#f472b6";
+export declare const BODY_WIRE_COLOR = "#38bdf8";
+export declare const PROJECTILE_PATH_COLOR = "#fde68a";
+export declare const AIM_LASER_COLOR = "#a3e635";
+export declare const AIM_DAMAGE_COLOR = "#f87171";
+export declare const AIM_SOLID_COLOR = "#fbbf24";
+export declare const AIM_MISS_COLOR = "#94a3b8";

package/dist/devtools/collisionDebugMath.js

@@ -0,0 +1,129 @@
+import { colliderWorldCenter, defaultEntityColliders, defaultObjectColliders, resolveColliders, } from "@jgengine/core/scene/colliders";
+import { firstImpact, hitsUntilBlocked, } from "@jgengine/core/scene/sceneRaycast";
+import { resolveShot } from "@jgengine/core/combat/shotOrigin";
+import { aimProbeNeeded, colliderScanNeeded } from "./collisionDebug.js";
+export function classifyAimEndpoint(hit) {
+    if (hit === null || hit === undefined)
+        return "miss";
+    return hit.damageEligible ? "damage" : "solid";
+}
+export function pointAlongRay(origin, direction, distance) {
+    return [
+        origin[0] + direction[0] * distance,
+        origin[1] + direction[1] * distance,
+        origin[2] + direction[2] * distance,
+    ];
+}
+export function shapeWorldCenter(collider, position, rotationY) {
+    return colliderWorldCenter(collider, position, rotationY);
+}
+function styleFor(purpose) {
+    return purpose === "damage" ? "hitbox" : "body";
+}
+function labelFor(collider) {
+    return `${collider.purpose}:${collider.name}`;
+}
+function pushResolved(out, targetKind, instanceId, catalogId, position, rotationY, set, layers) {
+    for (const collider of resolveColliders(set)) {
+        const style = styleFor(collider.purpose);
+        if (style === "hitbox" && !layers.hitboxes)
+            continue;
+        if (style === "body" && !layers.bodies)
+            continue;
+        const center = shapeWorldCenter(collider, position, rotationY);
+        const shape = collider.shape.kind === "sphere"
+            ? { kind: "sphere", radius: collider.shape.radius, center }
+            : {
+                kind: "aabb",
+                halfExtents: collider.shape.halfExtents,
+                center,
+            };
+        out.push({
+            key: `${targetKind}:${instanceId}:${collider.purpose}:${collider.name}`,
+            targetKind,
+            instanceId,
+            ...(catalogId !== undefined ? { catalogId } : {}),
+            name: collider.name,
+            purpose: collider.purpose,
+            damageEligible: collider.damageEligible,
+            blocks: collider.blocks,
+            position,
+            rotationY,
+            shape,
+            label: labelFor(collider),
+            style,
+        });
+    }
+}
+/**
+ * Collects world-space collider wireframe entries for enabled layers.
+ * Returns [] and performs no entity/object iteration when both hitbox/body layers are off.
+ */
+export function collectDebugShapes(input) {
+    if (!colliderScanNeeded(input.layers))
+        return [];
+    input.counters !== undefined && (input.counters.scans += 1);
+    const out = [];
+    for (const entity of input.entities) {
+        const set = input.entityCollidersOf?.(entity.id) ?? defaultEntityColliders();
+        pushResolved(out, "entity", entity.id, entity.name, entity.position, entity.rotationY, set, input.layers);
+    }
+    if (input.objects !== undefined) {
+        for (const object of input.objects) {
+            const half = input.objectHalfExtentsOf?.(object.catalogId) ?? undefined;
+            const set = input.objectCollidersOf?.(object.instanceId) ??
+                defaultObjectColliders(half === null || half === undefined ? undefined : half);
+            pushResolved(out, "object", object.instanceId, object.catalogId, object.position, object.rotationY, set, input.layers);
+        }
+    }
+    if (input.counters !== undefined)
+        input.counters.shapes += out.length;
+    return out;
+}
+/**
+ * Builds the authoritative aim-laser segment using resolveShot + scene raycast
+ * (same seam as projectile prediction/settlement). Zero queries when aimLaser is off.
+ */
+export function computeAimLaser(input) {
+    if (!aimProbeNeeded(input.layers)) {
+        return null;
+    }
+    const resolved = resolveShot({
+        positionOf: input.positionOf,
+        rotationYOf: input.rotationYOf,
+        collidersOf: input.collidersOf,
+    }, input.from, input.aim, input.originPolicy ?? { kind: "eye" });
+    if (resolved === null)
+        return null;
+    input.counters !== undefined && (input.counters.queries += 1);
+    const all = input.sceneRaycast.raycastAll({
+        origin: resolved.origin,
+        direction: resolved.direction,
+        maxDistance: input.maxDistance,
+        excludeInstanceIds: [input.from],
+    });
+    const until = hitsUntilBlocked(all);
+    const nearest = until[0] ?? null;
+    const impact = firstImpact(until);
+    const end = nearest !== null ? nearest.point : pointAlongRay(resolved.origin, resolved.direction, input.maxDistance);
+    return {
+        origin: resolved.origin,
+        direction: resolved.direction,
+        end,
+        maxDistance: input.maxDistance,
+        kind: classifyAimEndpoint(nearest),
+        nearest,
+        firstImpact: impact,
+        queryCount: 1,
+    };
+}
+export function muzzleMarkerFromOrigin(origin) {
+    return { center: origin, radius: 0.08, color: "#ef4444" };
+}
+export const HITBOX_WIRE_COLOR = "#f472b6";
+export const BODY_WIRE_COLOR = "#38bdf8";
+export const PROJECTILE_PATH_COLOR = "#fde68a";
+export const AIM_LASER_COLOR = "#a3e635";
+export const AIM_DAMAGE_COLOR = "#f87171";
+export const AIM_SOLID_COLOR = "#fbbf24";
+export const AIM_MISS_COLOR = "#94a3b8";

package/dist/environment/Daylight.d.ts

@@ -7,10 +7,16 @@ export interface SkyDomeProps {
     radius?: number;
     offset?: number;
     exponent?: number;
+    /** Direction toward the sun; a bright HDR sun disc + warm glow is drawn there (blooms through the post chain). Omit to skip the sun. */
+    sunDirection?: readonly [number, number, number];
+    /** Sun disc/glow colour. Default warm white. */
+    sunColor?: string;
+    /** Sun disc/glow intensity multiplier. Default 1. */
+    sunIntensity?: number;
     /** Exposes the created shader material so a time-of-day driver can mutate its uniforms per frame without recreating it. */
     materialRef?: MutableRefObject<THREE.ShaderMaterial | null>;
 }
-export declare function SkyDome({ topColor, horizonColor, radius, offset, exponent, materialRef, }?: SkyDomeProps): import("react").JSX.Element;
+export declare function SkyDome({ topColor, horizonColor, radius, offset, exponent, sunDirection, sunColor, sunIntensity, materialRef, }?: SkyDomeProps): import("react").JSX.Element;
 export interface DaylightProps {
     sky?: SkyDomeProps | false;
     fog?: {
@@ -28,12 +34,16 @@ export interface DaylightProps {
         groundColor?: string;
         intensity?: number;
     };
+    /** When false, only the sky dome and fog mount — use with authored `PlayableGame.lighting`. Default true. */
+    lights?: boolean;
 }
-export declare function Daylight({ sky, fog, sun, ambient }?: DaylightProps): import("react").JSX.Element;
-/** Renders a fixed sky/sun/fog look sampled from `sky`'s preset (or, when `timeOfDay` is on but no clock drives it, its noon look). No per-frame updates. */
-export declare function SkyDaylight({ sky }: {
+export declare function Daylight({ sky, fog, sun, ambient, lights }?: DaylightProps): import("react").JSX.Element;
+export interface SkyDaylightProps {
     sky: SkyEnvironmentDescriptor;
-}): import("react").JSX.Element;
+    lights?: boolean;
+}
+/** Renders a fixed sky/sun/fog look sampled from `sky`'s preset (or, when `timeOfDay` is on but no clock drives it, its noon look). No per-frame updates. */
+export declare function SkyDaylight({ sky, lights }: SkyDaylightProps): import("react").JSX.Element;
 export interface TimeOfDayDaylightProps {
     sky: SkyEnvironmentDescriptor;
     /** The world's `SimClock` (or a stub exposing `calendar().dayFraction`). Absent means static rendering. */
@@ -42,9 +52,11 @@ export interface TimeOfDayDaylightProps {
             dayFraction: number;
         };
     };
+    lights?: boolean;
 }
 /**
- * Drives `Daylight`'s sun/sky/fog from the world clock when `sky.timeOfDay` and `clock` are both present,
- * sampling `daylightStateAt` every frame; otherwise renders the static preset look via `SkyDaylight`.
+ * Drives sky/fog (and optional default lights) from the world clock when `sky.timeOfDay` and `clock`
+ * are both present. Authored `PlayableGame.lighting` is never rewritten — pass `lights={false}` so
+ * only dome colors and fog track the day fraction.
  */
-export declare function TimeOfDayDaylight({ sky, clock }: TimeOfDayDaylightProps): import("react").JSX.Element;
+export declare function TimeOfDayDaylight({ sky, clock, lights }: TimeOfDayDaylightProps): import("react").JSX.Element;

package/dist/environment/Daylight.js

@@ -3,13 +3,36 @@ import { useFrame } from "@react-three/fiber";
 import { useEffect, useMemo, useRef } from "react";
 import * as THREE from "three";
 import { daylightStateAt, SKY_PRESET_DAY_FRACTION } from "./daylightCycle.js";
+function normalizeVec3(v) {
+    const out = new THREE.Vector3(v[0], v[1], v[2]);
+    return out.lengthSq() === 0 ? new THREE.Vector3(0, 1, 0) : out.normalize();
+}
 const SKY_TOP = "#3fa4f2";
 const SKY_HORIZON = "#e3f4ff";
 const FOG_COLOR = "#e9f6ff";
 const SUN_COLOR = "#fff1c9";
 const HEMI_SKY = "#bfe3ff";
 const HEMI_GROUND = "#4c6b34";
-export function SkyDome({ topColor = SKY_TOP, horizonColor = SKY_HORIZON, radius = 260, offset = 24, exponent = 0.65, materialRef, } = {}) {
+/**
+ * Sun directional light whose high-resolution shadow camera follows the view each
+ * frame, so grounded shadows stay crisp under the player anywhere in a large world
+ * instead of only near the origin.
+ */
+function ShadowCastingSun({ position, intensity, color, }) {
+    const ref = useRef(null);
+    useFrame((state) => {
+        const light = ref.current;
+        if (light === null)
+            return;
+        const cx = state.camera.position.x;
+        const cz = state.camera.position.z;
+        light.position.set(cx + position[0], position[1], cz + position[2]);
+        light.target.position.set(cx, 0, cz);
+        light.target.updateMatrixWorld();
+    });
+    return (_jsx("directionalLight", { ref: ref, position: [position[0], position[1], position[2]], intensity: intensity, color: color, castShadow: true, "shadow-mapSize-width": 2048, "shadow-mapSize-height": 2048, "shadow-camera-left": -90, "shadow-camera-right": 90, "shadow-camera-top": 90, "shadow-camera-bottom": -90, "shadow-camera-near": 10, "shadow-camera-far": 520, "shadow-bias": -0.0004, "shadow-normalBias": 0.02 }));
+}
+export function SkyDome({ topColor = SKY_TOP, horizonColor = SKY_HORIZON, radius = 260, offset = 24, exponent = 0.65, sunDirection, sunColor = "#fff4d6", sunIntensity = 1, materialRef, } = {}) {
     const material = useMemo(() => {
         return new THREE.ShaderMaterial({
             uniforms: {
@@ -17,6 +40,9 @@ export function SkyDome({ topColor = SKY_TOP, horizonColor = SKY_HORIZON, radius
                 bottomColor: { value: new THREE.Color(horizonColor) },
                 offset: { value: offset },
                 exponent: { value: exponent },
+                uSunColor: { value: new THREE.Color(sunColor) },
+                uSunDirection: { value: sunDirection === undefined ? new THREE.Vector3(0, 1, 0) : normalizeVec3(sunDirection) },
+                uSunIntensity: { value: sunDirection === undefined ? 0 : sunIntensity },
             },
             vertexShader: `
         varying vec3 vWorldPosition;
@@ -29,19 +55,40 @@ export function SkyDome({ topColor = SKY_TOP, horizonColor = SKY_HORIZON, radius
             fragmentShader: `
         uniform vec3 topColor;
         uniform vec3 bottomColor;
+        uniform vec3 uSunColor;
+        uniform vec3 uSunDirection;
+        uniform float uSunIntensity;
         uniform float offset;
         uniform float exponent;
         varying vec3 vWorldPosition;
+        float sHash(vec2 p){ return fract(sin(dot(p, vec2(127.1, 311.7))) * 43758.5453); }
+        float sNoise(vec2 p){
+          vec2 i = floor(p); vec2 f = fract(p); vec2 u = f * f * (3.0 - 2.0 * f);
+          return mix(mix(sHash(i), sHash(i + vec2(1.0, 0.0)), u.x),
+                     mix(sHash(i + vec2(0.0, 1.0)), sHash(i + vec2(1.0, 1.0)), u.x), u.y);
+        }
+        float sFbm(vec2 p){ float v = 0.0; float a = 0.5; for (int i = 0; i < 5; i++){ v += a * sNoise(p); p *= 2.0; a *= 0.5; } return v; }
         void main() {
-          float h = normalize(vWorldPosition + vec3(0.0, offset, 0.0)).y;
-          gl_FragColor = vec4(mix(bottomColor, topColor, max(pow(max(h, 0.0), exponent), 0.0)), 1.0);
+          vec3 dir = normalize(vWorldPosition + vec3(0.0, offset, 0.0));
+          float h = max(dir.y, 0.0);
+          vec3 col = mix(bottomColor, topColor, pow(h, exponent));
+          col = mix(col, bottomColor * 1.12, pow(1.0 - h, 6.0) * 0.5);
+          vec3 vd = normalize(vWorldPosition);
+          vec2 cuv = vd.xz / (max(vd.y, 0.06) + 0.15) * 1.2;
+          float clouds = smoothstep(0.52, 0.82, sFbm(cuv));
+          float band = smoothstep(0.08, 0.35, dir.y) * smoothstep(1.0, 0.35, dir.y);
+          col = mix(col, mix(topColor, vec3(1.0), 0.6), clouds * band * 0.35);
+          float sd = max(dot(vd, normalize(uSunDirection)), 0.0);
+          float glow = pow(sd, 8.0) * 0.35 + pow(sd, 128.0) * 2.6;
+          col += uSunColor * glow * uSunIntensity;
+          gl_FragColor = vec4(col, 1.0);
         }
       `,
             side: THREE.BackSide,
             depthWrite: false,
             fog: false,
         });
-    }, [topColor, horizonColor, offset, exponent]);
+    }, [topColor, horizonColor, offset, exponent, sunColor, sunDirection, sunIntensity]);
     useEffect(() => {
         if (materialRef !== undefined)
             materialRef.current = material;
@@ -53,25 +100,26 @@ export function SkyDome({ topColor = SKY_TOP, horizonColor = SKY_HORIZON, radius
     }, [material, materialRef]);
     return (_jsx("mesh", { material: material, renderOrder: -1, children: _jsx("sphereGeometry", { args: [radius, 32, 16] }) }));
 }
-export function Daylight({ sky, fog, sun, ambient } = {}) {
+export function Daylight({ sky, fog, sun, ambient, lights = true } = {}) {
     const sunPosition = sun?.position ?? [120, 160, 70];
-    return (_jsxs(_Fragment, { children: [sky === false ? null : _jsx(SkyDome, { ...(sky ?? {}) }), fog === false ? null : (_jsx("fog", { attach: "fog", args: [fog?.color ?? FOG_COLOR, fog?.near ?? 70, fog?.far ?? 260] })), _jsx("hemisphereLight", { args: [ambient?.skyColor ?? HEMI_SKY, ambient?.groundColor ?? HEMI_GROUND, ambient?.intensity ?? 0.55] }), _jsx("directionalLight", { position: [sunPosition[0], sunPosition[1], sunPosition[2]], intensity: sun?.intensity ?? 0.85, color: sun?.color ?? SUN_COLOR, castShadow: true })] }));
+    return (_jsxs(_Fragment, { children: [sky === false ? null : (_jsx(SkyDome, { ...(sky ?? {}), sunDirection: sunPosition, sunColor: sun?.color ?? SUN_COLOR, sunIntensity: sun?.intensity ?? 1 })), fog === false ? null : (_jsx("fog", { attach: "fog", args: [fog?.color ?? FOG_COLOR, fog?.near ?? 70, fog?.far ?? 260] })), lights ? (_jsxs(_Fragment, { children: [_jsx("hemisphereLight", { args: [ambient?.skyColor ?? HEMI_SKY, ambient?.groundColor ?? HEMI_GROUND, ambient?.intensity ?? 0.55] }), _jsx(ShadowCastingSun, { position: sunPosition, intensity: sun?.intensity ?? 0.85, color: sun?.color ?? SUN_COLOR })] })) : null] }));
 }
 /** Renders a fixed sky/sun/fog look sampled from `sky`'s preset (or, when `timeOfDay` is on but no clock drives it, its noon look). No per-frame updates. */
-export function SkyDaylight({ sky }) {
+export function SkyDaylight({ sky, lights = true }) {
     const state = useMemo(() => daylightStateAt(SKY_PRESET_DAY_FRACTION[sky.preset], sky), [sky]);
-    return (_jsx(Daylight, { sky: { topColor: state.skyTop, horizonColor: state.skyBottom }, fog: { color: sky.fog?.color ?? state.background, near: sky.fog?.near, far: sky.fog?.far }, sun: { position: state.sunPosition, intensity: state.sunIntensity }, ambient: { intensity: state.ambientIntensity } }));
+    return (_jsx(Daylight, { sky: { topColor: state.skyTop, horizonColor: state.skyBottom }, fog: { color: sky.fog?.color ?? state.background, near: sky.fog?.near, far: sky.fog?.far }, sun: { position: state.sunPosition, intensity: state.sunIntensity }, ambient: { intensity: state.ambientIntensity }, lights: lights }));
 }
 /**
- * Drives `Daylight`'s sun/sky/fog from the world clock when `sky.timeOfDay` and `clock` are both present,
- * sampling `daylightStateAt` every frame; otherwise renders the static preset look via `SkyDaylight`.
+ * Drives sky/fog (and optional default lights) from the world clock when `sky.timeOfDay` and `clock`
+ * are both present. Authored `PlayableGame.lighting` is never rewritten — pass `lights={false}` so
+ * only dome colors and fog track the day fraction.
  */
-export function TimeOfDayDaylight({ sky, clock }) {
+export function TimeOfDayDaylight({ sky, clock, lights = true }) {
     if (!sky.timeOfDay || clock === undefined)
-        return _jsx(SkyDaylight, { sky: sky });
-    return _jsx(DrivenDaylight, { sky: sky, clock: clock });
+        return _jsx(SkyDaylight, { sky: sky, lights: lights });
+    return _jsx(DrivenDaylight, { sky: sky, clock: clock, lights: lights });
 }
-function DrivenDaylight({ sky, clock, }) {
+function DrivenDaylight({ sky, clock, lights, }) {
     const initial = useMemo(() => daylightStateAt(clock.calendar().dayFraction, sky), [clock, sky]);
     const sunRef = useRef(null);
     const hemiRef = useRef(null);
@@ -96,5 +144,5 @@ function DrivenDaylight({ sky, clock, }) {
             skyMaterial.uniforms.bottomColor.value.set(state.skyBottom);
         }
     });
-    return (_jsxs(_Fragment, { children: [_jsx(SkyDome, { topColor: initial.skyTop, horizonColor: initial.skyBottom, materialRef: skyMaterialRef }), _jsx("fog", { attach: "fog", ref: fogRef, args: [sky.fog?.color ?? initial.background, sky.fog?.near ?? 70, sky.fog?.far ?? 260] }), _jsx("hemisphereLight", { ref: hemiRef, args: [HEMI_SKY, HEMI_GROUND, initial.ambientIntensity] }), _jsx("directionalLight", { ref: sunRef, position: initial.sunPosition, intensity: initial.sunIntensity, color: SUN_COLOR, castShadow: true })] }));
+    return (_jsxs(_Fragment, { children: [_jsx(SkyDome, { topColor: initial.skyTop, horizonColor: initial.skyBottom, materialRef: skyMaterialRef }), _jsx("fog", { attach: "fog", ref: fogRef, args: [sky.fog?.color ?? initial.background, sky.fog?.near ?? 70, sky.fog?.far ?? 260] }), lights ? (_jsxs(_Fragment, { children: [_jsx("hemisphereLight", { ref: hemiRef, args: [HEMI_SKY, HEMI_GROUND, initial.ambientIntensity] }), _jsx("directionalLight", { ref: sunRef, position: initial.sunPosition, intensity: initial.sunIntensity, color: SUN_COLOR, castShadow: true })] })) : null] }));
 }