@pascal-app/viewer 1.0.6 → 1.1.0

package/dist/lib/daylight/runtime.d.ts

@@ -0,0 +1,33 @@
+import { Color } from 'three';
+/**
+ * Live controls of the colored appearance's daylight look, shared by the atmosphere (which drives
+ * them every frame), the material hooks and the post-processing. Uniforms only: switching time,
+ * weather, lamps or quality never recompiles a material.
+ */
+export declare const daylightUniforms: {
+    /** EON rough-diffuse amount on matte surfaces (0 = Lambert). Off on the Low tier. */
+    eon: import("three/webgpu").UniformNode<"float", number>;
+    /** 1 = albedo remapped into sRGB 40–243 (no black holes, no pure whites). */
+    albedoClamp: import("three/webgpu").UniformNode<"float", number>;
+    /** Time-of-day lamp level: 0 by day … 1 at night (lamps on 'auto'). */
+    lampLevel: import("three/webgpu").UniformNode<"float", number>;
+    /** Extra emission of lamp shades and screens at night (× lampLevel). */
+    emissiveBoost: import("three/webgpu").UniformNode<"float", number>;
+    /** 1 / the night exposure lift, so glows don't blow out when the meter brightens the scene. */
+    glowComp: import("three/webgpu").UniformNode<"float", number>;
+    /** 1 / exposure: lit lamp emitters target a fixed display brightness (always read as lit). */
+    emitterExpInv: import("three/webgpu").UniformNode<"float", number>;
+    /** Lit lamp emitter brightness on screen, × display white. */
+    emitterDisplay: import("three/webgpu").UniformNode<"float", number>;
+    /** 1 = the camera stands outside every room (drives the exterior window glow). */
+    cameraOutside: import("three/webgpu").UniformNode<"float", number>;
+    /** Night window glow, and whether panes emit enough to bloom softly. */
+    windowGlow: import("three/webgpu").UniformNode<"float", number>;
+    windowEmit: import("three/webgpu").UniformNode<"float", number>;
+    /** Tuned glass: base opacity at normal incidence and tint. */
+    glassOpacity: import("three/webgpu").UniformNode<"float", number>;
+    glassTint: import("three/webgpu").UniformNode<"color", Color>;
+};
+export declare function setDaylightRenderer(renderer: object, active: boolean): void;
+export declare function isDaylightRenderer(renderer: unknown): boolean;
+//# sourceMappingURL=runtime.d.ts.map

package/dist/lib/daylight/runtime.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"runtime.d.ts","sourceRoot":"","sources":["../../../src/lib/daylight/runtime.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,MAAM,OAAO,CAAA;AAG7B;;;;GAIG;AACH,eAAO,MAAM,gBAAgB;IAC3B,qFAAqF;IACrF,GAAG;IACH,6EAA6E;IAC7E,WAAW;IACX,uEAAuE;IACvE,SAAS;IACT,wEAAwE;IACxE,aAAa;IACb,+FAA+F;IAC/F,QAAQ;IACR,8FAA8F;IAC9F,aAAa;IACb,8DAA8D;IAC9D,cAAc;IACd,kFAAkF;IAClF,aAAa;IACb,wEAAwE;IACxE,UAAU;IACV,UAAU;IACV,8DAA8D;IAC9D,YAAY;IACZ,SAAS;CACV,CAAA;AAKD,wBAAgB,mBAAmB,CAAC,QAAQ,EAAE,MAAM,EAAE,MAAM,EAAE,OAAO,GAAG,IAAI,CAG3E;AAED,wBAAgB,kBAAkB,CAAC,QAAQ,EAAE,OAAO,GAAG,OAAO,CAE7D"}

package/dist/lib/daylight/runtime.js

@@ -0,0 +1,42 @@
+import { Color } from 'three';
+import { uniform } from 'three/tsl';
+/**
+ * Live controls of the colored appearance's daylight look, shared by the atmosphere (which drives
+ * them every frame), the material hooks and the post-processing. Uniforms only: switching time,
+ * weather, lamps or quality never recompiles a material.
+ */
+export const daylightUniforms = {
+    /** EON rough-diffuse amount on matte surfaces (0 = Lambert). Off on the Low tier. */
+    eon: uniform(0),
+    /** 1 = albedo remapped into sRGB 40–243 (no black holes, no pure whites). */
+    albedoClamp: uniform(0),
+    /** Time-of-day lamp level: 0 by day … 1 at night (lamps on 'auto'). */
+    lampLevel: uniform(0),
+    /** Extra emission of lamp shades and screens at night (× lampLevel). */
+    emissiveBoost: uniform(5),
+    /** 1 / the night exposure lift, so glows don't blow out when the meter brightens the scene. */
+    glowComp: uniform(1),
+    /** 1 / exposure: lit lamp emitters target a fixed display brightness (always read as lit). */
+    emitterExpInv: uniform(1),
+    /** Lit lamp emitter brightness on screen, × display white. */
+    emitterDisplay: uniform(4),
+    /** 1 = the camera stands outside every room (drives the exterior window glow). */
+    cameraOutside: uniform(1),
+    /** Night window glow, and whether panes emit enough to bloom softly. */
+    windowGlow: uniform(1.12),
+    windowEmit: uniform(1),
+    /** Tuned glass: base opacity at normal incidence and tint. */
+    glassOpacity: uniform(0.1),
+    glassTint: uniform(new Color(0.86, 0.95, 0.93)),
+};
+/** Renderers currently showing the daylight look; material hooks only attach for these. */
+const activeRenderers = new WeakSet();
+export function setDaylightRenderer(renderer, active) {
+    if (active)
+        activeRenderers.add(renderer);
+    else
+        activeRenderers.delete(renderer);
+}
+export function isDaylightRenderer(renderer) {
+    return !!renderer && typeof renderer === 'object' && activeRenderers.has(renderer);
+}

package/dist/lib/daylight/sky.d.ts

@@ -0,0 +1,26 @@
+import { Color, Vector3 } from 'three';
+import type { SolarLight } from './solar';
+/** Cloud cover per weather preset (0 clear … 1 overcast). */
+export declare const WEATHER_COVER: {
+    readonly clear: 0;
+    readonly fair: 0.45;
+    readonly cloudy: 0.7;
+    readonly overcast: 0.9;
+};
+export type Weather = keyof typeof WEATHER_COVER;
+export declare function createDaylightSky(): {
+    skyRadiance: (rawDir: any, { disc: withDisc }?: {
+        disc?: boolean;
+    }) => any;
+    horizonRadiance: (rawDir: any) => any;
+    lightRadiance: (rawDir: any) => any;
+    radianceCpu: (dir: Vector3, out?: Color) => Color;
+    update: (sun: SolarLight, coverValue: number) => void;
+    cloudTime: import("three/webgpu").UniformNode<"float", number>;
+    cover: import("three/webgpu").UniformNode<"float", number>;
+    horizon: import("three/webgpu").UniformNode<"color", Color>;
+    top: import("three/webgpu").UniformNode<"color", Color>;
+    ground: import("three/webgpu").UniformNode<"color", Color>;
+};
+export type DaylightSky = ReturnType<typeof createDaylightSky>;
+//# sourceMappingURL=sky.d.ts.map

package/dist/lib/daylight/sky.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sky.d.ts","sourceRoot":"","sources":["../../../src/lib/daylight/sky.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAa,OAAO,EAAE,MAAM,OAAO,CAAA;AAoBjD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,SAAS,CAAA;AAsBzC,6DAA6D;AAC7D,eAAO,MAAM,aAAa;aAAK,KAAK,EAAE,CAAC;aAAE,IAAI,EAAE,IAAI;aAAE,MAAM,EAAE,GAAG;aAAE,QAAQ,EAAE,GAAG;CAAW,CAAA;AAC1F,MAAM,MAAM,OAAO,GAAG,MAAM,OAAO,aAAa,CAAA;AAqBhD,wBAAgB,iBAAiB;0BAqEF,GAAG,uBAA6B;QAAE,IAAI,CAAC,EAAE,OAAO,CAAA;KAAE,KAAQ,GAAG;8BA8CzD,GAAG,KAAG,GAAG;4BAeX,GAAG,KAAG,GAAG;uBAiBd,OAAO;kBAkCZ,UAAU,cAAc,MAAM;;;;;;EAwBpD;AAED,MAAM,MAAM,WAAW,GAAG,UAAU,CAAC,OAAO,iBAAiB,CAAC,CAAA"}

package/dist/lib/daylight/sky.js

@@ -0,0 +1,217 @@
+import { Color, MathUtils, Vector3 } from 'three';
+import { abs, clamp, dot, exp, float, floor, hash, max, mix, mx_fractal_noise_float, normalize, pow, select, smoothstep, uniform, vec2, vec3, } from 'three/tsl';
+const STOPS = [
+    { el: -18, top: '#050b18', horizon: '#1b2232', ground: '#0c1016', glow: '#1b2232' },
+    { el: -8, top: '#0b1731', horizon: '#424b64', ground: '#17202a', glow: '#4a4f6a' },
+    { el: -3, top: '#2f4470', horizon: '#9a8aa0', ground: '#3e434f', glow: '#d98c6c' },
+    { el: 1, top: '#4e638b', horizon: '#e5a38b', ground: '#5d626e', glow: '#f08a52' },
+    { el: 7, top: '#5d7fae', horizon: '#ecc6a4', ground: '#8d8c7e', glow: '#f3b070' },
+    { el: 18, top: '#5b88b8', horizon: '#d8e2e3', ground: '#aeb3a0', glow: '#efd9b8' },
+    { el: 45, top: '#4f82b8', horizon: '#d4e1e6', ground: '#b4b9a6', glow: '#e8e6dc' },
+];
+/** Cloud cover per weather preset (0 clear … 1 overcast). */
+export const WEATHER_COVER = { clear: 0, fair: 0.45, cloudy: 0.7, overcast: 0.9 };
+const scratchA = new Color();
+const scratchB = new Color();
+function lerpStops(el, key, out) {
+    const first = STOPS[0];
+    const last = STOPS[STOPS.length - 1];
+    if (el <= first.el)
+        return out.set(first[key]);
+    for (let i = 0; i < STOPS.length - 1; i++) {
+        const a = STOPS[i];
+        const b = STOPS[i + 1];
+        if (el <= b.el) {
+            return out
+                .copy(scratchA.set(a[key]))
+                .lerp(scratchB.set(b[key]), MathUtils.smoothstep(el, a.el, b.el));
+        }
+    }
+    return out.set(last[key]);
+}
+export function createDaylightSky() {
+    const top = uniform(new Color());
+    const horizon = uniform(new Color());
+    const ground = uniform(new Color());
+    const glow = uniform(new Color());
+    const sunDir = uniform(new Vector3(0, 1, 0));
+    const sunColor = uniform(new Color(1, 1, 1));
+    const sunVisible = uniform(1);
+    const night = uniform(0);
+    const cover = uniform(WEATHER_COVER.fair);
+    const cloudTime = uniform(0);
+    /** Gradient + warm band towards the sun + overcast greying (shared by every sampler). */
+    const base = (dir) => {
+        const y = dir.y;
+        const gradient = mix(horizon, select(y.greaterThanEqual(0), top, ground), pow(abs(y), 0.55));
+        const sunFlat = normalize(vec3(sunDir.x, 0.0001, sunDir.z));
+        const toward = max(dot(normalize(vec3(dir.x, 0, dir.z)), sunFlat), 0);
+        const banded = mix(gradient, glow, exp(abs(y).mul(-6)).mul(pow(toward, 3)).mul(0.75));
+        const lum = dot(banded, vec3(0.2126, 0.7152, 0.0722));
+        const grey = vec3(lum).mul(1.08).add(sunColor.mul(sunVisible).mul(0.06));
+        return mix(banded, grey, cover
+            .mul(cover)
+            .mul(0.75)
+            .mul(smoothstep(-0.2, 0.05, y)));
+    };
+    const cloudColor = () => {
+        const ambient = mix(horizon, top, 0.35).mul(0.95);
+        const dusk = glow.mul(float(1).sub(sunVisible)).mul(0.5).mul(float(1).sub(night));
+        return { ambient, dusk };
+    };
+    /**
+     * Stars: one in a few hundred cells of a fine grid on the sphere, each a small round dot at a
+     * jittered spot in its cell. The cell index is offset positive before hashing (the hash reads
+     * its seed as an unsigned int, so negative cells all hashed alike and half the sky had none)
+     * and kept under 2^24 so the float seed stays exact. Most stars sit below the bloom threshold
+     * at night exposure; only the brightest few cross it, for a faint glow.
+     */
+    const STAR_GRID = 450;
+    const stars = (dir) => {
+        const grid = dir.mul(STAR_GRID);
+        const cell = floor(grid).add(STAR_GRID + 1);
+        const seed = cell.x.add(cell.y.mul(311)).add(cell.z.mul(17123));
+        const presence = smoothstep(0.9968, 1, hash(seed));
+        const magnitude = presence.mul(presence);
+        const jitter = vec3(hash(seed.add(101)), hash(seed.add(211)), hash(seed.add(307)))
+            .sub(0.5)
+            .mul(0.5);
+        const offset = grid.sub(floor(grid)).sub(0.5).sub(jitter);
+        const radius = mix(float(0.2), float(0.4), magnitude);
+        const dot = float(1).sub(smoothstep(radius.mul(0.35), radius, offset.length()));
+        return dot
+            .mul(presence)
+            .mul(mix(float(0.12), float(0.6), magnitude))
+            .mul(night)
+            .mul(smoothstep(0.05, 0.3, dir.y));
+    };
+    /**
+     * Visible sky: fbm clouds (self-shadowed towards the sun), aureole, AA'd sun disc, stars.
+     * `disc: false` is the environment capture: aureole kept, disc and stars off (the sun is the
+     * directional light — no double specular sun).
+     */
+    const skyRadiance = (rawDir, { disc: withDisc = true } = {}) => {
+        const dir = normalize(rawDir);
+        const y = dir.y;
+        const proj = vec2(dir.x, dir.z)
+            .div(max(y, 0).add(0.12))
+            .mul(0.6)
+            .add(vec2(cloudTime.mul(0.006), cloudTime.mul(0.0025)));
+        const noiseAt = (q) => mx_fractal_noise_float(vec3(q.x, q.y, 0.37), 5, 2, 0.5)
+            .mul(0.5)
+            .add(0.5);
+        const thresh = float(0.8).sub(cover.mul(0.56));
+        const dens = smoothstep(thresh.sub(0.06), thresh.add(0.2), noiseAt(proj));
+        const toSun = normalize(vec2(sunDir.x, sunDir.z).add(vec2(1e-4, 0)));
+        const occl = smoothstep(thresh.sub(0.06), thresh.add(0.2), noiseAt(proj.add(toSun.mul(0.08))));
+        const { ambient, dusk } = cloudColor();
+        const lit = sunColor.mul(sunVisible).mul(clamp(float(1.15).sub(occl.mul(0.75)), 0.25, 1.15));
+        const cloud = ambient
+            .mul(0.55)
+            .add(lit.mul(0.85))
+            .add(dusk)
+            .mul(mix(float(1), float(0.72), cover.mul(cover)));
+        const cloudA = dens.mul(smoothstep(0.015, 0.16, y)).mul(0.96);
+        const col = mix(base(dir), cloud, cloudA);
+        const align = dot(dir, sunDir);
+        const aureole = exp(align.sub(1).mul(110))
+            .mul(0.2)
+            .add(exp(align.sub(1).mul(8)).mul(0.08));
+        const disc = withDisc
+            ? smoothstep(0.99996, 0.999985, align).mul(40).mul(float(1).sub(cloudA))
+            : float(0);
+        const sun = sunColor
+            .mul(aureole.add(disc))
+            .mul(sunVisible)
+            .mul(smoothstep(-0.01, 0.02, y))
+            .mul(float(1).sub(cover.mul(0.6)));
+        if (!withDisc)
+            return col.add(sun);
+        return col.add(sun).add(vec3(stars(dir).mul(float(1).sub(cloudA))));
+    };
+    /**
+     * The sky just above the horizon, where the fog and the backdrop meet: `skyRadiance` without
+     * its disc, minus the clouds, which fade out below 0.015 of elevation anyway. Every fogged
+     * material samples it, so leaving out the cloud noise saves two 5-octave fbm calls per fragment
+     * and keeps `cloudTime` (which moves every frame) out of every material's uniforms.
+     */
+    const horizonRadiance = (rawDir) => {
+        const dir = normalize(rawDir);
+        const align = dot(dir, sunDir);
+        const aureole = exp(align.sub(1).mul(110))
+            .mul(0.2)
+            .add(exp(align.sub(1).mul(8)).mul(0.08));
+        const sun = sunColor
+            .mul(aureole)
+            .mul(sunVisible)
+            .mul(smoothstep(-0.01, 0.02, dir.y))
+            .mul(float(1).sub(cover.mul(0.6)));
+        return base(dir).add(sun);
+    };
+    /** Lighting sky: clouds as their coverage-weighted average (smooth, cheap, sun-free). */
+    const lightRadiance = (rawDir) => {
+        const dir = normalize(rawDir);
+        const { ambient, dusk } = cloudColor();
+        const cloud = ambient
+            .mul(0.55)
+            .add(sunColor.mul(sunVisible).mul(0.68))
+            .add(dusk)
+            .mul(float(1).sub(cover.mul(cover).mul(0.28)));
+        const cloudA = cover
+            .mul(0.85)
+            .min(1)
+            .mul(smoothstep(0.015, 0.16, dir.y))
+            .mul(0.7);
+        return mix(base(dir), cloud, cloudA);
+    };
+    /** CPU mirror of the sky (statistical clouds, aureole, no disc) for meters and window portals. */
+    const radianceCpu = (dir, out = new Color()) => {
+        const d = dir.clone().normalize();
+        const t = top.value;
+        const h = horizon.value;
+        out.copy(h).lerp(d.y >= 0 ? t : ground.value, Math.abs(d.y) ** 0.55);
+        const sd = sunDir.value;
+        const flat = new Vector3(sd.x, 0.0001, sd.z).normalize();
+        const toward = Math.max(new Vector3(d.x, 0, d.z).normalize().dot(flat), 0);
+        out.lerp(glow.value, Math.exp(-6 * Math.abs(d.y)) * toward ** 3 * 0.75);
+        const c = cover.value;
+        const sv = sunVisible.value;
+        const sc = sunColor.value;
+        const lum = 0.2126 * out.r + 0.7152 * out.g + 0.0722 * out.b;
+        const above = MathUtils.smoothstep(d.y, -0.2, 0.05);
+        out.lerp(new Color(lum * 1.08 + sc.r * sv * 0.06, lum * 1.08 + sc.g * sv * 0.06, lum * 1.08 + sc.b * sv * 0.06), c * c * 0.75 * above);
+        const amb = h.clone().lerp(t, 0.35).multiplyScalar(0.95);
+        const cloud = amb
+            .multiplyScalar(0.55)
+            .add(sc.clone().multiplyScalar(sv * 0.68))
+            .multiplyScalar(1 - 0.28 * c * c);
+        out.lerp(cloud, Math.min(1, c * 0.85) * MathUtils.smoothstep(d.y, 0.015, 0.16) * 0.7);
+        const align = d.dot(sd);
+        const aureole = Math.exp((align - 1) * 110) * 0.2 + Math.exp((align - 1) * 8) * 0.08;
+        out.add(sc.clone().multiplyScalar(aureole * sv));
+        return out;
+    };
+    const update = (sun, coverValue) => {
+        lerpStops(sun.elevation, 'top', top.value);
+        lerpStops(sun.elevation, 'horizon', horizon.value);
+        lerpStops(sun.elevation, 'ground', ground.value);
+        lerpStops(sun.elevation, 'glow', glow.value);
+        sunDir.value.copy(sun.direction);
+        sunColor.value.copy(sun.color);
+        sunVisible.value = MathUtils.smoothstep(sun.elevation, -1, 1);
+        night.value = sun.night;
+        cover.value = coverValue;
+    };
+    return {
+        skyRadiance,
+        horizonRadiance,
+        lightRadiance,
+        radianceCpu,
+        update,
+        cloudTime,
+        cover,
+        horizon,
+        top,
+        ground,
+    };
+}

package/dist/lib/daylight/solar.d.ts

@@ -0,0 +1,46 @@
+import { Color, Vector3 } from 'three';
+export declare function solarPosition(date: Date, lat: number, lng: number): {
+    azimuth: number;
+    elevation: number;
+};
+export type SolarLight = {
+    azimuth: number;
+    elevation: number;
+    /** Unit vector towards the sun, site frame. */
+    direction: Vector3;
+    /** Linear RGB, max channel 1: white at noon, gold low, orange at sunset. */
+    color: Color;
+    /** 0…1 relative strength of the disc (horizon fade × air-mass extinction). */
+    strength: number;
+    /** 0 day … 1 night (sun below −7°). */
+    night: number;
+};
+export declare function solarLight(date: Date, lat: number, lng: number, northRotation: number, out?: SolarLight): SolarLight;
+/** Sun elevation each preset aims for (degrees); midday takes the day's highest sun. */
+declare const PRESET_ELEVATION: {
+    readonly golden: 6;
+    readonly midday: number;
+    readonly blue: -4;
+    readonly night: -14;
+};
+export type TimeOfDay = keyof typeof PRESET_ELEVATION;
+/**
+ * The instant on `day` (local calendar day at the site's longitude) when the sun reaches the
+ * preset's elevation on the afternoon/evening side. Defined by the sun, not the clock, so no
+ * timezone is needed. Falls back to the closest elevation reached (polar summer/winter).
+ */
+export declare function presetInstant(day: Date, lat: number, lng: number, preset: TimeOfDay): Date;
+/** The instant `minutes` after local mean midnight on `day` at longitude `lng`. */
+export declare function solarClockInstant(day: Date, lng: number, minutes: number): Date;
+/** Minutes after local mean midnight of `date` at longitude `lng`, 0…1440. */
+export declare function solarClockMinutes(date: Date, lng: number): number;
+/** Sunrise and sunset on `day` (local mean minutes), or null where the sun never crosses. */
+export declare function sunEvents(day: Date, lat: number, lng: number): {
+    sunrise: number;
+    sunset: number;
+} | null;
+/** The phase a moment of the day reads as, from the sun's elevation and the side of noon. */
+export type SkyPhase = 'night' | 'blue' | 'golden' | 'morning' | 'midday' | 'afternoon';
+export declare function skyPhase(elevation: number, minutes: number): SkyPhase;
+export {};
+//# sourceMappingURL=solar.d.ts.map

package/dist/lib/daylight/solar.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"solar.d.ts","sourceRoot":"","sources":["../../../src/lib/daylight/solar.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAa,OAAO,EAAE,MAAM,OAAO,CAAA;AAWjD,wBAAgB,aAAa,CAAC,IAAI,EAAE,IAAI,EAAE,GAAG,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM;;;EA4CjE;AAED,MAAM,MAAM,UAAU,GAAG;IACvB,OAAO,EAAE,MAAM,CAAA;IACf,SAAS,EAAE,MAAM,CAAA;IACjB,+CAA+C;IAC/C,SAAS,EAAE,OAAO,CAAA;IAClB,4EAA4E;IAC5E,KAAK,EAAE,KAAK,CAAA;IACZ,8EAA8E;IAC9E,QAAQ,EAAE,MAAM,CAAA;IAChB,uCAAuC;IACvC,KAAK,EAAE,MAAM,CAAA;CACd,CAAA;AAUD,wBAAgB,UAAU,CACxB,IAAI,EAAE,IAAI,EACV,GAAG,EAAE,MAAM,EACX,GAAG,EAAE,MAAM,EACX,aAAa,EAAE,MAAM,EACrB,GAAG,CAAC,EAAE,UAAU,GACf,UAAU,CA4BZ;AAED,wFAAwF;AACxF,QAAA,MAAM,gBAAgB;aACpB,MAAM,EAAE,CAAC;aACT,MAAM;aACN,IAAI,EAAE,CAAC,CAAC;aACR,KAAK,EAAE,CAAC,EAAE;CACF,CAAA;AACV,MAAM,MAAM,SAAS,GAAG,MAAM,OAAO,gBAAgB,CAAA;AAErD;;;;GAIG;AACH,wBAAgB,aAAa,CAAC,GAAG,EAAE,IAAI,EAAE,GAAG,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,EAAE,MAAM,EAAE,SAAS,GAAG,IAAI,CAiB1F;AAUD,mFAAmF;AACnF,wBAAgB,iBAAiB,CAAC,GAAG,EAAE,IAAI,EAAE,GAAG,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,IAAI,CAE/E;AAED,8EAA8E;AAC9E,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,IAAI,EAAE,GAAG,EAAE,MAAM,GAAG,MAAM,CAGjE;AAED,6FAA6F;AAC7F,wBAAgB,SAAS,CACvB,GAAG,EAAE,IAAI,EACT,GAAG,EAAE,MAAM,EACX,GAAG,EAAE,MAAM,GACV;IAAE,OAAO,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,GAAG,IAAI,CAa5C;AAED,6FAA6F;AAC7F,MAAM,MAAM,QAAQ,GAAG,OAAO,GAAG,MAAM,GAAG,QAAQ,GAAG,SAAS,GAAG,QAAQ,GAAG,WAAW,CAAA;AAEvF,wBAAgB,QAAQ,CAAC,SAAS,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,QAAQ,CAOrE"}

package/dist/lib/daylight/solar.js

@@ -0,0 +1,156 @@
+import { Color, MathUtils, Vector3 } from 'three';
+/**
+ * Sun position (NOAA / Meeus low-precision, ~0.01° for 1950–2050) and a small art-directed
+ * model of the light it gives. Angles in degrees unless noted. The site frame is x east,
+ * y up, z south; `northRotation` (radians, clockwise) is true north's offset from plan −z,
+ * so a compass bearing `az` points along plan angle `az + northRotation`.
+ */
+const RAD = Math.PI / 180;
+export function solarPosition(date, lat, lng) {
+    const jd = date.getTime() / 86_400_000 + 2_440_587.5;
+    const t = (jd - 2_451_545) / 36_525;
+    const l0 = (280.46646 + t * (36_000.76983 + t * 0.0003032)) % 360;
+    const m = 357.52911 + t * (35_999.05029 - 0.0001537 * t);
+    const e = 0.016708634 - t * (0.000042037 + 0.0000001267 * t);
+    const c = Math.sin(m * RAD) * (1.914602 - t * (0.004817 + 0.000014 * t)) +
+        Math.sin(2 * m * RAD) * (0.019993 - 0.000101 * t) +
+        Math.sin(3 * m * RAD) * 0.000289;
+    const omega = 125.04 - 1934.136 * t;
+    const lambda = l0 + c - 0.00569 - 0.00478 * Math.sin(omega * RAD);
+    const eps0 = 23 + (26 + (21.448 - t * (46.815 + t * (0.00059 - t * 0.001813))) / 60) / 60;
+    const eps = eps0 + 0.00256 * Math.cos(omega * RAD);
+    const decl = Math.asin(Math.sin(eps * RAD) * Math.sin(lambda * RAD)) / RAD;
+    const y = Math.tan((eps / 2) * RAD) ** 2;
+    const eqTime = (4 / RAD) *
+        (y * Math.sin(2 * l0 * RAD) -
+            2 * e * Math.sin(m * RAD) +
+            4 * e * y * Math.sin(m * RAD) * Math.cos(2 * l0 * RAD) -
+            0.5 * y * y * Math.sin(4 * l0 * RAD) -
+            1.25 * e * e * Math.sin(2 * m * RAD));
+    const minutes = date.getUTCHours() * 60 + date.getUTCMinutes() + date.getUTCSeconds() / 60;
+    const solarTime = (((minutes + eqTime + 4 * lng) % 1440) + 1440) % 1440;
+    let hourAngle = solarTime / 4 - 180;
+    if (hourAngle < -180)
+        hourAngle += 360;
+    const cosZenith = Math.sin(lat * RAD) * Math.sin(decl * RAD) +
+        Math.cos(lat * RAD) * Math.cos(decl * RAD) * Math.cos(hourAngle * RAD);
+    const zenith = Math.acos(MathUtils.clamp(cosZenith, -1, 1)) / RAD;
+    const azimuth = (Math.atan2(Math.sin(hourAngle * RAD), Math.cos(hourAngle * RAD) * Math.sin(lat * RAD) - Math.tan(decl * RAD) * Math.cos(lat * RAD)) /
+        RAD +
+        180) %
+        360;
+    let elevation = 90 - zenith;
+    // Atmospheric refraction only matters near the horizon.
+    if (elevation > -1)
+        elevation += 1.02 / Math.tan((elevation + 10.3 / (elevation + 5.11)) * RAD) / 60;
+    return { azimuth, elevation };
+}
+// Rayleigh (680/550/440 nm) plus a light aerosol term.
+const TAU = [0.043 + 0.07, 0.098 + 0.08, 0.236 + 0.095];
+function airMass(elevation) {
+    const z = 90 - Math.max(elevation, -0.5);
+    return 1 / (Math.cos(z * RAD) + 0.50572 * (96.07995 - z) ** -1.6364);
+}
+export function solarLight(date, lat, lng, northRotation, out) {
+    const { azimuth, elevation } = solarPosition(date, lat, lng);
+    const s = out ?? {
+        azimuth: 0,
+        elevation: 0,
+        direction: new Vector3(),
+        color: new Color(),
+        strength: 0,
+        night: 0,
+    };
+    s.azimuth = azimuth;
+    s.elevation = elevation;
+    const bearing = azimuth * RAD + northRotation;
+    const el = elevation * RAD;
+    s.direction
+        .set(Math.sin(bearing) * Math.cos(el), Math.sin(el), -Math.cos(bearing) * Math.cos(el))
+        .normalize();
+    const m = airMass(elevation);
+    const ratio = TAU.map((tau) => Math.exp(-tau * m) / Math.exp(-tau));
+    const peak = Math.max(...ratio, 1e-6);
+    // pow 0.6: golden rather than raw-physical orange.
+    s.color.setRGB((ratio[0] / peak) ** 0.6, (ratio[1] / peak) ** 0.6, (ratio[2] / peak) ** 0.6);
+    s.strength =
+        MathUtils.smoothstep(elevation, -1, 1.5) *
+            peak *
+            Math.min(1, Math.sin(Math.max(el, 0)) * 0.5 + 0.55);
+    s.night = 1 - MathUtils.smoothstep(elevation, -7, 2);
+    return s;
+}
+/** Sun elevation each preset aims for (degrees); midday takes the day's highest sun. */
+const PRESET_ELEVATION = {
+    golden: 6,
+    midday: Number.POSITIVE_INFINITY,
+    blue: -4,
+    night: -14,
+};
+/**
+ * The instant on `day` (local calendar day at the site's longitude) when the sun reaches the
+ * preset's elevation on the afternoon/evening side. Defined by the sun, not the clock, so no
+ * timezone is needed. Falls back to the closest elevation reached (polar summer/winter).
+ */
+export function presetInstant(day, lat, lng, preset) {
+    // Solar noon in UTC for this longitude: 12:00 local mean time.
+    const noonUtc = Date.UTC(day.getFullYear(), day.getMonth(), day.getDate(), 12) - (lng / 15) * 3_600_000;
+    const target = PRESET_ELEVATION[preset];
+    let best = noonUtc;
+    let bestScore = Number.POSITIVE_INFINITY;
+    for (let minutes = -120; minutes <= 14 * 60; minutes += 5) {
+        const t = noonUtc + minutes * 60_000;
+        const { elevation } = solarPosition(new Date(t), lat, lng);
+        const score = Number.isFinite(target) ? Math.abs(elevation - target) : -elevation;
+        if (score < bestScore) {
+            bestScore = score;
+            best = t;
+        }
+    }
+    return new Date(best);
+}
+/**
+ * Times of day as minutes after local mean midnight at the site's longitude (sun time, no
+ * timezone): 720 is roughly when the sun is highest, give or take the equation of time.
+ */
+function meanMidnightUtc(day, lng) {
+    return Date.UTC(day.getFullYear(), day.getMonth(), day.getDate()) - (lng / 15) * 3_600_000;
+}
+/** The instant `minutes` after local mean midnight on `day` at longitude `lng`. */
+export function solarClockInstant(day, lng, minutes) {
+    return new Date(meanMidnightUtc(day, lng) + minutes * 60_000);
+}
+/** Minutes after local mean midnight of `date` at longitude `lng`, 0…1440. */
+export function solarClockMinutes(date, lng) {
+    const minutes = (date.getTime() - meanMidnightUtc(date, lng)) / 60_000;
+    return ((minutes % 1440) + 1440) % 1440;
+}
+/** Sunrise and sunset on `day` (local mean minutes), or null where the sun never crosses. */
+export function sunEvents(day, lat, lng) {
+    const above = (minutes) => solarPosition(solarClockInstant(day, lng, minutes), lat, lng).elevation > -0.833;
+    let sunrise = null;
+    let sunset = null;
+    let previous = above(0);
+    for (let minutes = 5; minutes <= 1440; minutes += 5) {
+        const now = above(minutes);
+        if (now && !previous && sunrise === null)
+            sunrise = minutes;
+        if (!now && previous && sunrise !== null)
+            sunset = minutes;
+        previous = now;
+    }
+    return sunrise !== null && sunset !== null ? { sunrise, sunset } : null;
+}
+export function skyPhase(elevation, minutes) {
+    if (elevation < -6)
+        return 'night';
+    if (elevation < 0)
+        return 'blue';
+    if (elevation < 10)
+        return 'golden';
+    if (minutes < 11 * 60)
+        return 'morning';
+    if (minutes > 14.5 * 60)
+        return 'afternoon';
+    return 'midday';
+}

package/dist/lib/device-tier.d.ts

@@ -0,0 +1,29 @@
+import type { RenderQuality } from '../store/use-viewer';
+/** What the browser tells us about the device: capabilities, never measured frame rate. */
+export type DeviceSignals = {
+    backend: 'webgpu' | 'webgl';
+    /** GPU identity: WebGPU adapter info plus the WebGL renderer string, lower-cased. */
+    gpu: string;
+    /** WebGPU fell back to a software adapter. */
+    fallbackAdapter: boolean;
+    /** `navigator.deviceMemory` in GB (Chromium only, capped at 8). */
+    memoryGb?: number;
+    cores?: number;
+    /** A phone or tablet: coarse primary pointer, or an iPad passing as a Mac. */
+    touch: boolean;
+    /** The screen's short side in CSS px. */
+    screenShortSide: number;
+    mac: boolean;
+};
+/**
+ * The quality tier a device starts on, from what it is rather than how fast it ran a frame:
+ * - Low: no WebGPU, software rendering, 4 GB or less, phones, older Intel integrated graphics.
+ * - High: discrete GPUs, Apple Pro/Max/Ultra (Safari hides the model: Macs with 10+ cores).
+ * - Medium: tablets, other integrated GPUs, base Apple M chips, and anything unrecognized.
+ */
+export declare function classifyDevice(signals: DeviceSignals): RenderQuality;
+/** Rendering on the CPU (a software adapter or rasterizer): every frame competes with the app. */
+export declare function isSoftwareRenderer(signals: DeviceSignals): boolean;
+/** The device's signals, read once the renderer is up (its backend and WebGPU device). */
+export declare function readDeviceSignals(backend: 'webgpu' | 'webgl', device?: unknown): DeviceSignals;
+//# sourceMappingURL=device-tier.d.ts.map

package/dist/lib/device-tier.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"device-tier.d.ts","sourceRoot":"","sources":["../../src/lib/device-tier.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAA;AAExD,2FAA2F;AAC3F,MAAM,MAAM,aAAa,GAAG;IAC1B,OAAO,EAAE,QAAQ,GAAG,OAAO,CAAA;IAC3B,qFAAqF;IACrF,GAAG,EAAE,MAAM,CAAA;IACX,8CAA8C;IAC9C,eAAe,EAAE,OAAO,CAAA;IACxB,mEAAmE;IACnE,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,8EAA8E;IAC9E,KAAK,EAAE,OAAO,CAAA;IACd,yCAAyC;IACzC,eAAe,EAAE,MAAM,CAAA;IACvB,GAAG,EAAE,OAAO,CAAA;CACb,CAAA;AASD;;;;;GAKG;AACH,wBAAgB,cAAc,CAAC,OAAO,EAAE,aAAa,GAAG,aAAa,CAWpE;AAED,kGAAkG;AAClG,wBAAgB,kBAAkB,CAAC,OAAO,EAAE,aAAa,GAAG,OAAO,CAElE;AAID,0FAA0F;AAC1F,wBAAgB,iBAAiB,CAAC,OAAO,EAAE,QAAQ,GAAG,OAAO,EAAE,MAAM,CAAC,EAAE,OAAO,GAAG,aAAa,CAoB9F"}

package/dist/lib/device-tier.js

@@ -0,0 +1,71 @@
+const SOFTWARE = /swiftshader|llvmpipe|softpipe|software|basic render/;
+const DISCRETE = /nvidia|geforce|quadro|radeon\s*(rx|pro|r9|vii)|intel.*arc\s*a\d|intel.*arc\(tm\)\s*a\d/;
+const OLD_INTEL = /intel.*(hd graphics|uhd graphics)|gen-(7|8|9)\b/;
+const APPLE_BIG = /apple m\d+\s*(pro|max|ultra)/;
+const APPLE_BASE = /apple m\d+/;
+/**
+ * The quality tier a device starts on, from what it is rather than how fast it ran a frame:
+ * - Low: no WebGPU, software rendering, 4 GB or less, phones, older Intel integrated graphics.
+ * - High: discrete GPUs, Apple Pro/Max/Ultra (Safari hides the model: Macs with 10+ cores).
+ * - Medium: tablets, other integrated GPUs, base Apple M chips, and anything unrecognized.
+ */
+export function classifyDevice(signals) {
+    const gpu = signals.gpu;
+    if (signals.backend === 'webgl' || signals.fallbackAdapter || SOFTWARE.test(gpu))
+        return 'low';
+    if (signals.memoryGb !== undefined && signals.memoryGb <= 4)
+        return 'low';
+    if (signals.touch)
+        return signals.screenShortSide < 600 ? 'low' : 'medium';
+    if (DISCRETE.test(gpu))
+        return 'high';
+    if (OLD_INTEL.test(gpu) && !/iris|arc/.test(gpu))
+        return 'low';
+    if (APPLE_BIG.test(gpu))
+        return 'high';
+    if (APPLE_BASE.test(gpu))
+        return 'medium';
+    if (signals.mac && /apple/.test(gpu) && (signals.cores ?? 0) >= 10)
+        return 'high';
+    return 'medium';
+}
+/** Rendering on the CPU (a software adapter or rasterizer): every frame competes with the app. */
+export function isSoftwareRenderer(signals) {
+    return signals.fallbackAdapter || SOFTWARE.test(signals.gpu);
+}
+/** The device's signals, read once the renderer is up (its backend and WebGPU device). */
+export function readDeviceSignals(backend, device) {
+    const info = device
+        ?.adapterInfo;
+    const nav = navigator;
+    const mac = /mac/i.test(nav.platform || nav.userAgent);
+    const touch = window.matchMedia?.('(pointer: coarse)').matches === true || (mac && nav.maxTouchPoints > 1);
+    return {
+        backend,
+        gpu: [info?.vendor, info?.architecture, info?.device, info?.description, webglRenderer()]
+            .filter(Boolean)
+            .join(' ')
+            .toLowerCase(),
+        fallbackAdapter: info?.isFallbackAdapter === true,
+        memoryGb: typeof nav.deviceMemory === 'number' ? nav.deviceMemory : undefined,
+        cores: nav.hardwareConcurrency || undefined,
+        touch,
+        screenShortSide: Math.min(window.screen?.width ?? 0, window.screen?.height ?? 0),
+        mac,
+    };
+}
+/** The WebGL renderer string (the GPU model on Chromium; masked on Safari and Firefox). */
+function webglRenderer() {
+    try {
+        const gl = document.createElement('canvas').getContext('webgl2');
+        if (!gl)
+            return '';
+        const debug = gl.getExtension('WEBGL_debug_renderer_info');
+        const name = String(gl.getParameter(debug ? debug.UNMASKED_RENDERER_WEBGL : gl.RENDERER));
+        gl.getExtension('WEBGL_lose_context')?.loseContext();
+        return name;
+    }
+    catch {
+        return '';
+    }
+}

package/dist/lib/dispose-object3d.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"dispose-object3d.d.ts","sourceRoot":"","sources":["../../src/lib/dispose-object3d.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAA4B,QAAQ,EAAE,MAAM,OAAO,CAAA;AAM/D,8EAA8E;AAC9E,wBAAgB,wBAAwB,CAAC,IAAI,EAAE,QAAQ,GAAG,IAAI,CAsB7D"}
+{"version":3,"file":"dispose-object3d.d.ts","sourceRoot":"","sources":["../../src/lib/dispose-object3d.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAA4B,QAAQ,EAAE,MAAM,OAAO,CAAA;AAM/D,8EAA8E;AAC9E,wBAAgB,wBAAwB,CAAC,IAAI,EAAE,QAAQ,GAAG,IAAI,CAwB7D"}

package/dist/lib/dispose-object3d.js

@@ -18,8 +18,10 @@ export function disposeObject3DResources(root) {
             materials.add(objectMaterials);
         }
     });
-    for (const geometry of geometries)
-        geometry.dispose();
+    for (const geometry of geometries) {
+        if (!geometry.userData.shared)
+            geometry.dispose();
+    }
     for (const material of materials) {
         if (!isCachedMaterial(material))
             material.dispose();