@pascal-app/viewer 1.0.6 → 1.1.0

package/dist/lib/daylight/material-hooks.js

@@ -0,0 +1,150 @@
+import { abs, cameraPosition, clamp, diffuseColor, diffuseRoughness, dot, float, hash, length, materialEmissive, max, mix, normalize, normalWorld, positionWorld, pow, smoothstep, vec3, vec4, } from 'three/tsl';
+import { MeshBasicNodeMaterial, PhysicalLightingModel, MeshStandardNodeMaterial as StandardNodeMaterial, } from 'three/webgpu';
+import { isHighlight } from '../editor-highlight';
+import { SCENE_LAYER } from '../layers';
+import { daylightRooms } from './rooms';
+import { daylightUniforms, isDaylightRenderer } from './runtime';
+/** sRGB 40 / 243 in linear: lo + c·(hi − lo). */
+const ALBEDO_LO = 0.0212;
+const ALBEDO_HI = 0.896;
+function hooked(material, builder) {
+    // Physical materials own their lighting model; glass and other transparent surfaces keep theirs.
+    return (!material.isMeshPhysicalNodeMaterial &&
+        !material.transparent &&
+        isDaylightRenderer(builder.renderer));
+}
+function matte(material) {
+    return (material.metalness ?? 0) < 0.2 && (material.roughness ?? 1) >= 0.55;
+}
+function emitter(material) {
+    return (!material.emissiveNode &&
+        !isHighlight(material) &&
+        !!material.emissive &&
+        material.emissive.getHex() !== 0 &&
+        material.emissiveIntensity > 0);
+}
+/** Window/door glass (its slot, live or baked), item glass by material name, or flagged glass. */
+function glass(material, object) {
+    if (!material.transparent || material.isMeshPhysicalNodeMaterial)
+        return false;
+    return (object?.userData?.slotId === 'glass' ||
+        material.userData.isGlass === true ||
+        /glass/i.test(material.name));
+}
+/** The enhanced viewer's glass: tint, near-mirror roughness, distance/Fresnel opacity, night glow. */
+function tunedGlassNodes() {
+    const u = daylightUniforms;
+    const V = normalize(cameraPosition.sub(positionWorld));
+    const N = normalWorld;
+    const fresnel = pow(float(1).sub(abs(dot(N, V))), 5);
+    // /next trick: glass gets more opaque + reflective with distance and grazing angle, so façades
+    // read as glazing from the street while interiors stay visible up close.
+    const far = smoothstep(6, 30, length(cameraPosition.sub(positionWorld)));
+    // Night: warm radiance from the lit room behind the pane (strongest from outside / far away).
+    const behind = daylightRooms.roomAtNode(positionWorld.sub(N.mul(0.35)));
+    const front = daylightRooms.roomAtNode(positionWorld.add(N.mul(0.35)));
+    const room = max(behind, front);
+    // Pane tint = the room's actual lamp colour (18% towards white), dark when its lamps are off.
+    const lampRad = daylightRooms.roomGlowNode(room);
+    const tint = mix(lampRad, vec3(lampRad.dot(vec3(0.33))), 0.18);
+    // Per-room variation, like a game city: not every window equally bright.
+    const variation = mix(0.55, 1.0, hash(float(room).add(7.13)));
+    const strength = u.windowGlow
+        .mul(u.glowComp)
+        .mul(float(1).add(u.windowEmit.mul(1.8)))
+        .mul(variation)
+        .mul(mix(1.0, 0.35, fresnel))
+        .mul(mix(0.25, 1.0, u.cameraOutside))
+        .mul(mix(0.4, 1, far));
+    return {
+        colorNode: u.glassTint,
+        roughnessNode: float(0.04),
+        metalnessNode: float(0),
+        opacityNode: clamp(u.glassOpacity.add(far.mul(0.18)).add(fresnel.mul(0.7)), 0, 0.72),
+        emissiveNode: tint.mul(strength).mul(0.9),
+    };
+}
+let installed = false;
+export function installDaylightMaterialHooks() {
+    if (installed)
+        return;
+    installed = true;
+    const proto = StandardNodeMaterial.prototype;
+    const setup = proto.setup;
+    proto.setup = function (builder) {
+        if (!isDaylightRenderer(builder.renderer) || !glass(this, builder.object))
+            return setup.call(this, builder);
+        // Build-time only: the tuned glass joins this compile without touching the material.
+        const own = this;
+        const nodes = tunedGlassNodes();
+        const saved = Object.fromEntries(Object.keys(nodes).map((key) => [key, own[key]]));
+        Object.assign(own, nodes);
+        try {
+            return setup.call(this, builder);
+        }
+        finally {
+            Object.assign(own, saved);
+        }
+    };
+    const setupDiffuseColor = proto.setupDiffuseColor;
+    proto.setupDiffuseColor = function (builder) {
+        setupDiffuseColor.call(this, builder);
+        if (!hooked(this, builder))
+            return;
+        const rgb = diffuseColor.rgb;
+        const clamped = rgb.mul(ALBEDO_HI - ALBEDO_LO).add(ALBEDO_LO);
+        diffuseColor.assign(vec4(mix(rgb, clamped, daylightUniforms.albedoClamp), diffuseColor.a));
+    };
+    const setupVariants = proto.setupVariants;
+    proto.setupVariants = function (builder) {
+        setupVariants.call(this, builder);
+        if (hooked(this, builder) && matte(this))
+            diffuseRoughness.assign(daylightUniforms.eon);
+    };
+    const setupLightingModel = proto.setupLightingModel;
+    proto.setupLightingModel = function (builder) {
+        if (!hooked(this, builder) || !matte(this))
+            return setupLightingModel.call(this, builder);
+        // The eighth flag enables EON rough diffuse (fed by `diffuseRoughness` above).
+        return new PhysicalLightingModel(false, false, false, false, false, false, false, true);
+    };
+    const setupLighting = proto.setupLighting;
+    proto.setupLighting = function (builder) {
+        if (hooked(this, builder) && !this.emissiveNode && isHighlight(this)) {
+            // Editor highlights: the tint keeps its on-screen strength whatever the exposure.
+            this.emissiveNode = materialEmissive.mul(daylightUniforms.emitterExpInv);
+            try {
+                return setupLighting.call(this, builder);
+            }
+            finally {
+                this.emissiveNode = null;
+            }
+        }
+        if (!hooked(this, builder) || !emitter(this))
+            return setupLighting.call(this, builder);
+        // Build-time only: the emission joins this compile without touching the material.
+        // Glowing surfaces (screens, signs; lamps get their own materials): brighter at night, kept
+        // out of the night exposure lift.
+        const u = daylightUniforms;
+        this.emissiveNode = materialEmissive.mul(float(1).add(u.lampLevel.mul(u.emissiveBoost).mul(u.glowComp)));
+        try {
+            return setupLighting.call(this, builder);
+        }
+        finally {
+            this.emissiveNode = null;
+        }
+    };
+    // Unlit scene surfaces: undo the metered exposure (zones and editor overlays are compensated in
+    // the post-processing, on their own layers; the sky capture is radiance and keeps it).
+    const basic = MeshBasicNodeMaterial.prototype;
+    const setupBasicLighting = basic.setupLighting;
+    basic.setupLighting = function (builder) {
+        const light = setupBasicLighting.call(this, builder);
+        const object = builder.object;
+        if (!isDaylightRenderer(builder.renderer) ||
+            this.userData.daylightSky === true ||
+            !object?.layers?.isEnabled(SCENE_LAYER))
+            return light;
+        return light.mul(daylightUniforms.emitterExpInv);
+    };
+}

package/dist/lib/daylight/room-context.d.ts

@@ -0,0 +1,12 @@
+type N = any;
+/**
+ * The daylight look's scene-pass lighting hooks: room light enters the material lighting as
+ * indirect irradiance (`getGI`, × albedo, × contact AO), the room enclosure dims the sky IBL
+ * (`getAO`), and outside surfaces receive the window spill and exterior lamps at night.
+ *
+ * Materials flagged `userData.noRooms` (the grounds) skip the room system: the dilated room
+ * map reaches ~20 cm past the walls and would light a strip of lawn.
+ */
+export declare function daylightRoomContext(): N;
+export {};
+//# sourceMappingURL=room-context.d.ts.map

package/dist/lib/daylight/room-context.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"room-context.d.ts","sourceRoot":"","sources":["../../../src/lib/daylight/room-context.ts"],"names":[],"mappings":"AAaA,KAAK,CAAC,GAAG,GAAG,CAAA;AAKZ;;;;;;;GAOG;AACH,wBAAgB,mBAAmB,IAAI,CAAC,CAqCvC"}

package/dist/lib/daylight/room-context.js

@@ -0,0 +1,54 @@
+import { context, diffuseColor, Fn, If, max, normalWorld, positionWorld, uniform, vec3, } from 'three/tsl';
+import { daylightRooms } from './rooms';
+/** Window spill only: receivers darker than this albedo are lit as if they had it (decal-style). */
+const spillAlbedoFloor = uniform(0.35);
+/**
+ * The daylight look's scene-pass lighting hooks: room light enters the material lighting as
+ * indirect irradiance (`getGI`, × albedo, × contact AO), the room enclosure dims the sky IBL
+ * (`getAO`), and outside surfaces receive the window spill and exterior lamps at night.
+ *
+ * Materials flagged `userData.noRooms` (the grounds) skip the room system: the dilated room
+ * map reaches ~20 cm past the walls and would light a strip of lawn.
+ */
+export function daylightRoomContext() {
+    const rooms = daylightRooms;
+    const room = rooms.probeRoomNode();
+    const roomNode = rooms.lightingNode(room);
+    const enclosure = roomNode.w;
+    const outsideMask = rooms.exteriorMaskNode(room);
+    // GI is later × albedo, so near-black paving would swallow the pools: lift dark receivers for
+    // the spill term only (like a light decal).
+    const lum = diffuseColor.rgb.dot(vec3(0.2126, 0.7152, 0.0722)).max(1e-3);
+    const albedoLift = lum.max(spillAlbedoFloor).div(lum);
+    const spill = rooms.exteriorSpillNode(positionWorld, normalWorld).mul(albedoLift);
+    const exteriorLamps = rooms.exteriorLampsNode(positionWorld, normalWorld);
+    // Inside a room the outside terms are masked to nothing anyway: skip their loops there.
+    const outsideLight = Fn(() => {
+        const light = vec3(0).toVar();
+        If(outsideMask.greaterThan(0), () => {
+            light.assign(spill.add(exteriorLamps).mul(outsideMask));
+        });
+        return light;
+    })();
+    return context({
+        getAO: (input, { material }) => {
+            if (material.transparent === true)
+                return input;
+            if (material.userData.noRooms)
+                return input;
+            return input !== null ? input.mul(enclosure) : enclosure;
+        },
+        getGI: (input, { material }) => {
+            if (material.transparent === true)
+                return input;
+            // The lighting model multiplies GI by the AO term again: undo it so room light keeps only
+            // the contact AO, and outside terms aren't dimmed by an enclosure they don't sit in.
+            let gi;
+            if (material.userData.noRooms)
+                gi = spill.add(exteriorLamps);
+            else
+                gi = outsideLight.add(roomNode.xyz).div(max(enclosure, 1e-3));
+            return input !== null ? input.add(gi) : gi;
+        },
+    });
+}

package/dist/lib/daylight/room-map.d.ts

@@ -0,0 +1,124 @@
+/**
+ * Which room a point is in, at any scale: a sparse, tiled room-id map.
+ *
+ * Every level keeps its own map of 10 cm cells, cut into square tiles. A tile entirely inside one
+ * room (or outside every room) is a single value; only tiles a room edge crosses keep their cells,
+ * packed into one shared atlas. A level's rooms are grouped into clusters, each with its own tile
+ * rect, so open ground between distant rooms costs nothing. Memory then follows the length of the
+ * walls, not the site's area, and no texture grows with the number of floors. Tiles are built one
+ * at a time, so neither does the build.
+ *
+ * A point finds its level by height within its own building (a coarse directory lists the
+ * buildings near it), so neighbouring buildings with different floor heights, or a 40-storey
+ * tower, each keep their floors. Within a building, levels sorted by height stay sorted when they
+ * explode apart, so the search runs on live heights.
+ */
+type N = any;
+export declare const CELL = 0.1;
+/** Cells per tile side. */
+export declare const TILE = 16;
+/** Room ids are stored as two bytes (id + 1). */
+export declare const MAX_ROOMS = 65535;
+/** WebGPU guarantees 8192 texels a side; the renderer asks for no more. */
+export declare const DEFAULT_TEXTURE_LIMIT = 8192;
+export type MapLevel = {
+    /** World Y of the level's floor, assembled (not exploded). */
+    y: number;
+    /** Index of the level's building; levels of one building stack. */
+    building: number;
+};
+export type MapRoom = {
+    level: number;
+    /** World XZ. */
+    polygon: [number, number][];
+    holes?: [number, number][][];
+};
+/** One tile while it is being built, inside its row's dilated cells (with a margin all round). */
+export type TileCells = {
+    level: number;
+    /** Site cell index of `cells[0]`. */
+    ci0: number;
+    cj0: number;
+    /** World XZ of `cells[0]`'s lower corner. */
+    x0: number;
+    z0: number;
+    /** Cells per buffer row. */
+    stride: number;
+    /** The tile's first cell in the buffer. */
+    i0: number;
+    j0: number;
+    /** Room index + 1 per cell, 0 outside. */
+    cells: Uint16Array;
+    /** Every cell of the tile itself holds the same value (no edge inside). */
+    uniform: boolean;
+};
+export declare class RoomMap {
+    /** The device's largest 2D texture side; set before `build`. */
+    textureLimit: number;
+    private levels;
+    /** Level indices sorted by building, then height: the order the GPU searches in. */
+    private order;
+    private position;
+    /** Per building: its range in `order`. */
+    private buildingRange;
+    private originX;
+    private originZ;
+    private dirTiles;
+    private dirW;
+    private dirH;
+    /** Per directory cell: the buildings whose rooms reach it. */
+    private dirLists;
+    private atlas;
+    private atlasTilesW;
+    private atlasTiles;
+    private indexBytes;
+    private warnedOverflow;
+    readonly u: {
+        origin: N;
+        dirTiles: import("three/webgpu").UniformNode<"int", number>;
+        dirW: import("three/webgpu").UniformNode<"int", number>;
+        dirH: import("three/webgpu").UniformNode<"int", number>;
+        /** One building: its level range is the only candidate (no directory reads). */
+        single: import("three/webgpu").UniformNode<"int", number>;
+        singleCount: import("three/webgpu").UniformNode<"int", number>;
+        /** Binary-search steps for the tallest building. */
+        searchSteps: import("three/webgpu").UniformNode<"int", number>;
+        atlasTilesW: import("three/webgpu").UniformNode<"int", number>;
+        indexW: import("three/webgpu").UniformNode<"int", number>;
+        index: N;
+        levels: N;
+        atlas: N;
+    };
+    private levelData;
+    /** Rebuild from rooms. `onTile` sees every built tile (the doorway search walks room edges). */
+    build(levels: MapLevel[], rooms: MapRoom[], onTile?: (tile: TileCells) => void): void;
+    /** CPU lookup in assembled space (same rule as the shader). */
+    roomAt(x: number, y: number, z: number): number;
+    /** A level's room at a point; clusters' rects can overlap (a wing around a courtyard pavilion). */
+    private levelRoomAt;
+    /** The level stacked right above `level` in its building, or −1. */
+    levelAbove(level: number): number;
+    /** Index the GPU uses for `level` (rooms store it). */
+    gpuLevel(level: number): number;
+    /**
+     * Live presentation per level (input order): explode offset, whether it is shown, and whether
+     * the levels over it are hidden (its rooms open to the sky from above).
+     */
+    setPresentation(offsets: number[], shown: boolean[], focused: boolean[]): void;
+    memoryBytes(): number;
+    get stats(): {
+        atlasTiles: number;
+        dirW: number;
+        dirH: number;
+    };
+    private upload;
+    private indexTexel;
+    /** [liveY, clusterStart, clusterCount, 0] of the level at GPU position `pos`. */
+    levelTexel0(pos: N): N;
+    /** [0, 0, offset, flags] of the level at GPU position `pos`. */
+    levelTexel1(pos: N): N;
+    /** Room index (−1 outside) at a world-space position (live heights). */
+    roomAtNode: import("three/tsl").FnNode<[any], import("three/webgpu").VarNode<"int", import("three/webgpu").ConstNode<"int", number>>>;
+}
+export {};
+//# sourceMappingURL=room-map.d.ts.map

package/dist/lib/daylight/room-map.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"room-map.d.ts","sourceRoot":"","sources":["../../../src/lib/daylight/room-map.ts"],"names":[],"mappings":"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"}