@corensystem/coren-ui 1.0.0-next.20260924.75108.887a9c2

package/dist/fragment-viewer/cinematic.mjs

@@ -0,0 +1,382 @@
+import "@thatopen/components";
+import * as THREE from "three";
+import "@thatopen/components-front";
+import { EffectComposer } from "three/examples/jsm/postprocessing/EffectComposer.js";
+import { GTAOPass } from "three/examples/jsm/postprocessing/GTAOPass.js";
+import { FullScreenQuad } from "three/examples/jsm/postprocessing/Pass.js";
+import { RenderPass } from "three/examples/jsm/postprocessing/RenderPass.js";
+//#region src/fragment-viewer/cinematic.ts
+/** ACES filmic + sRGB, inlined to match three's ACESFilmicToneMapping + SRGBColorSpace exactly, plus a
+*  hard silhouette mask so only building pixels are ever written. */
+const COMPOSITE_FRAGMENT = `
+	varying vec2 vUv;
+	uniform sampler2D tBuilding; // linear HDR (off-screen render — leave colorSpace default, do not decode)
+	uniform sampler2D tMask;     // white-on-black building coverage
+	uniform float uExposure;
+
+	vec3 RRTAndODTFit(vec3 v) {
+		vec3 a = v * (v + 0.0245786) - 0.000090537;
+		vec3 b = v * (0.983729 * v + 0.4329510) + 0.238081;
+		return a / b;
+	}
+	vec3 ACESFilmic(vec3 color) {
+		const mat3 ACESInputMat = mat3(
+			0.59719, 0.07600, 0.02840,
+			0.35458, 0.90834, 0.13383,
+			0.04823, 0.01566, 0.83777);
+		const mat3 ACESOutputMat = mat3(
+			 1.60475, -0.10208, -0.00327,
+			-0.53108,  1.10813, -0.07276,
+			-0.07367, -0.00605,  1.07602);
+		color *= uExposure / 0.6;
+		color = ACESInputMat * color;
+		color = RRTAndODTFit(color);
+		color = ACESOutputMat * color;
+		return clamp(color, 0.0, 1.0);
+	}
+	vec3 sRGB_OETF(vec3 c) {
+		return mix(pow(c, vec3(0.41666)) * 1.055 - vec3(0.055), c * 12.92, vec3(lessThanEqual(c, vec3(0.0031308))));
+	}
+	void main() {
+		float m = texture2D(tMask, vUv).r;
+		if (m < 0.5) discard; // grid + background pixels are never written
+		vec3 hdr = texture2D(tBuilding, vUv).rgb;
+		gl_FragColor = vec4(sRGB_OETF(ACESFilmic(hdr)), 1.0);
+	}
+`;
+const COMPOSITE_VERTEX = `
+	varying vec2 vUv;
+	void main() { vUv = uv; gl_Position = vec4(position.xy, 0.0, 1.0); }
+`;
+var Cinematic = class {
+	world;
+	exposure = 1.2;
+	enabled = false;
+	hooked = null;
+	grid = null;
+	composer = null;
+	renderPass = null;
+	gtaoPass = null;
+	maskRT = null;
+	whiteMaterial = null;
+	compositeMaterial = null;
+	fsQuad = null;
+	sunLight = null;
+	ambientLight = null;
+	saved = null;
+	/** Tracks the camera projection so the GTAO material's PERSPECTIVE_CAMERA define can be refreshed
+	*  when the viewer toggles perspective↔orthographic (the SDK bakes it once at construction). */
+	lastCameraIsPerspective = null;
+	constructor(world, options = {}) {
+		this.world = world;
+		if (options.exposure !== void 0) this.exposure = options.exposure;
+	}
+	get active() {
+		return this.enabled;
+	}
+	/** Turn cinematic mode on. `modelBox` frames the sun's shadow camera; `grid` is hidden per sub-render. */
+	enable(modelBox, grid) {
+		if (this.enabled) return;
+		if (!this.world.renderer) return;
+		this.enabled = true;
+		this.grid = grid;
+		this.saveState();
+		this.configureShadowsAndLights(modelBox);
+		this.flagMeshes();
+		this.buildComposer();
+		const render = () => this.render();
+		this.world.onAfterUpdate.add(render);
+		this.hooked = () => this.world.onAfterUpdate.remove(render);
+	}
+	/** Turn it off: restore every mutation and free every GPU resource (no idle VRAM). */
+	disable() {
+		if (!this.enabled) return;
+		this.enabled = false;
+		this.hooked?.();
+		this.hooked = null;
+		this.disposeComposer();
+		this.restoreState();
+		this.grid = null;
+	}
+	resize() {
+		if (!this.enabled || !this.composer) return;
+		const { width, height, dpr } = this.canvasSize();
+		this.composer.setSize(width, height);
+		this.composer.setPixelRatio(dpr);
+		this.maskRT?.setSize(Math.floor(width * dpr), Math.floor(height * dpr));
+	}
+	dispose() {
+		this.disable();
+	}
+	canvasSize() {
+		const three = this.world.renderer?.three;
+		const dpr = three?.getPixelRatio() ?? 1;
+		const canvas = three?.domElement;
+		if (!canvas) return {
+			width: 2,
+			height: 2,
+			dpr
+		};
+		return {
+			width: Math.floor(canvas.clientWidth || canvas.width / dpr),
+			height: Math.floor(canvas.clientHeight || canvas.height / dpr),
+			dpr
+		};
+	}
+	saveState() {
+		const three = this.world.renderer?.three;
+		if (!three) return;
+		const scene = this.world.scene.three;
+		const meshShadows = [];
+		scene.traverse((object) => {
+			const mesh = object;
+			if (mesh.isMesh) meshShadows.push({
+				mesh,
+				cast: mesh.castShadow,
+				receive: mesh.receiveShadow
+			});
+		});
+		this.saved = {
+			shadowEnabled: three.shadowMap.enabled,
+			shadowType: three.shadowMap.type,
+			shadowAutoUpdate: three.shadowMap.autoUpdate,
+			meshShadows,
+			light: null,
+			ambientIntensity: null
+		};
+	}
+	/** Enable the shadow map and re-balance the lights so the building isn't flat under ACES. Global
+	*  colour state (tone mapping / output colour space / background) is intentionally left untouched —
+	*  the grid + background must render exactly as normal, and only the building buffer is tone-mapped. */
+	configureShadowsAndLights(modelBox) {
+		const three = this.world.renderer?.three;
+		if (!three) return;
+		three.shadowMap.enabled = true;
+		three.shadowMap.type = THREE.PCFSoftShadowMap;
+		three.shadowMap.autoUpdate = false;
+		const sphere = (modelBox && !modelBox.isEmpty() ? modelBox : new THREE.Box3(new THREE.Vector3(-10, 0, -10), new THREE.Vector3(10, 20, 10))).getBoundingSphere(new THREE.Sphere());
+		const r = Math.max(sphere.radius, 1);
+		const light = [...this.world.scene.directionalLights.values()][0];
+		if (light) {
+			this.sunLight = light;
+			if (this.saved) {
+				const c = light.shadow.camera;
+				this.saved.light = {
+					castShadow: light.castShadow,
+					position: light.position.clone(),
+					target: light.target.position.clone(),
+					intensity: light.intensity,
+					color: light.color.getHex(),
+					mapSize: light.shadow.mapSize.clone(),
+					bias: light.shadow.bias,
+					normalBias: light.shadow.normalBias,
+					shadowCam: {
+						left: c.left,
+						right: c.right,
+						top: c.top,
+						bottom: c.bottom,
+						near: c.near,
+						far: c.far
+					}
+				};
+			}
+			light.intensity = 3;
+			light.color.set("#ffedcf");
+			const dir = new THREE.Vector3(.45, .85, .35).normalize();
+			light.position.copy(sphere.center).add(dir.multiplyScalar(r * 2.5));
+			light.target.position.copy(sphere.center);
+			light.target.updateMatrixWorld();
+			light.castShadow = true;
+			light.shadow.mapSize.set(4096, 4096);
+			light.shadow.bias = -4e-4;
+			light.shadow.normalBias = .05;
+			const cam = light.shadow.camera;
+			cam.left = -r;
+			cam.right = r;
+			cam.top = r;
+			cam.bottom = -r;
+			cam.near = r;
+			cam.far = r * 4;
+			cam.updateProjectionMatrix();
+		}
+		const ambient = [...this.world.scene.ambientLights.values()][0];
+		if (ambient) {
+			this.ambientLight = ambient;
+			if (this.saved) this.saved.ambientIntensity = ambient.intensity;
+			ambient.intensity = .3;
+		}
+	}
+	/** Flag full-detail (MeshLambert) meshes to cast + receive self-shadows; exclude the LOD shader (no
+	*  depth program) and the grid. Run per-frame because zoom streams new meshes. */
+	flagMeshes() {
+		this.world.scene.three.traverse((object) => {
+			const mesh = object;
+			if (!mesh.isMesh || mesh === this.grid) return;
+			const material = mesh.material;
+			if (Array.isArray(material) ? material.some((m) => m.isMeshLambertMaterial) : material.isMeshLambertMaterial === true) {
+				mesh.castShadow = true;
+				mesh.receiveShadow = true;
+			} else mesh.castShadow = false;
+		});
+	}
+	buildComposer() {
+		const renderer = this.world.renderer?.three;
+		if (!renderer) return;
+		const scene = this.world.scene.three;
+		const camera = this.world.camera.three;
+		const { width, height, dpr } = this.canvasSize();
+		this.composer = new EffectComposer(renderer);
+		this.composer.renderToScreen = false;
+		this.composer.setSize(width, height);
+		this.composer.setPixelRatio(dpr);
+		this.renderPass = new RenderPass(scene, camera);
+		this.composer.addPass(this.renderPass);
+		this.gtaoPass = new GTAOPass(scene, camera, width, height);
+		this.gtaoPass.output = GTAOPass.OUTPUT.Default;
+		this.gtaoPass.blendIntensity = 1;
+		this.gtaoPass.updateGtaoMaterial({
+			radius: 1.5,
+			distanceExponent: 1,
+			thickness: 1,
+			scale: 1,
+			samples: 16,
+			screenSpaceRadius: false
+		});
+		this.composer.addPass(this.gtaoPass);
+		this.lastCameraIsPerspective = camera.isPerspectiveCamera === true;
+		this.maskRT = new THREE.WebGLRenderTarget(Math.floor(width * dpr), Math.floor(height * dpr), {
+			depthBuffer: true,
+			minFilter: THREE.LinearFilter,
+			magFilter: THREE.LinearFilter
+		});
+		this.whiteMaterial = new THREE.MeshBasicMaterial({ color: 16777215 });
+		this.compositeMaterial = new THREE.ShaderMaterial({
+			uniforms: {
+				tBuilding: { value: null },
+				tMask: { value: null },
+				uExposure: { value: this.exposure }
+			},
+			vertexShader: COMPOSITE_VERTEX,
+			fragmentShader: COMPOSITE_FRAGMENT,
+			toneMapped: false,
+			depthTest: false,
+			depthWrite: false,
+			blending: THREE.NoBlending
+		});
+		this.fsQuad = new FullScreenQuad(this.compositeMaterial);
+	}
+	render() {
+		const renderer = this.world.renderer?.three;
+		if (!this.enabled || !renderer) return;
+		if (!this.composer || !this.maskRT || !this.whiteMaterial || !this.compositeMaterial || !this.fsQuad) return;
+		const scene = this.world.scene.three;
+		const camera = this.world.camera.three;
+		this.flagMeshes();
+		if (this.renderPass) this.renderPass.camera = camera;
+		if (this.gtaoPass) {
+			this.gtaoPass.camera = camera;
+			const isPerspective = camera.isPerspectiveCamera === true;
+			if (this.lastCameraIsPerspective !== isPerspective) {
+				this.gtaoPass.gtaoMaterial.defines.PERSPECTIVE_CAMERA = isPerspective ? 1 : 0;
+				this.gtaoPass.gtaoMaterial.needsUpdate = true;
+				this.lastCameraIsPerspective = isPerspective;
+			}
+		}
+		renderer.shadowMap.needsUpdate = true;
+		const prevTarget = renderer.getRenderTarget();
+		const prevAutoClear = renderer.autoClear;
+		const prevClearColor = renderer.getClearColor(new THREE.Color());
+		const prevClearAlpha = renderer.getClearAlpha();
+		const prevBackground = scene.background;
+		const prevOverride = scene.overrideMaterial;
+		const prevGridVisible = this.grid?.visible ?? true;
+		if (this.grid) this.grid.visible = false;
+		scene.background = null;
+		renderer.setClearColor(0, 0);
+		this.composer.render();
+		scene.overrideMaterial = this.whiteMaterial;
+		renderer.setRenderTarget(this.maskRT);
+		renderer.setClearColor(0, 1);
+		renderer.autoClear = true;
+		renderer.clear();
+		renderer.render(scene, camera);
+		scene.overrideMaterial = prevOverride;
+		scene.background = prevBackground;
+		if (this.grid) this.grid.visible = prevGridVisible;
+		this.compositeMaterial.uniforms.tBuilding.value = this.composer.readBuffer.texture;
+		this.compositeMaterial.uniforms.tMask.value = this.maskRT.texture;
+		renderer.setRenderTarget(null);
+		renderer.autoClear = false;
+		this.fsQuad.render(renderer);
+		renderer.autoClear = prevAutoClear;
+		renderer.setClearColor(prevClearColor, prevClearAlpha);
+		renderer.setRenderTarget(prevTarget);
+	}
+	disposeComposer() {
+		this.composer?.dispose();
+		this.gtaoPass?.gtaoMaterial?.dispose();
+		this.gtaoPass?.blendMaterial?.dispose();
+		this.gtaoPass?.dispose();
+		this.maskRT?.dispose();
+		this.whiteMaterial?.dispose();
+		this.compositeMaterial?.dispose();
+		this.fsQuad?.dispose();
+		this.composer = null;
+		this.renderPass = null;
+		this.gtaoPass = null;
+		this.maskRT = null;
+		this.whiteMaterial = null;
+		this.compositeMaterial = null;
+		this.fsQuad = null;
+	}
+	restoreState() {
+		const saved = this.saved;
+		const three = this.world.renderer?.three;
+		if (!saved || !three) return;
+		three.shadowMap.enabled = saved.shadowEnabled;
+		three.shadowMap.type = saved.shadowType;
+		three.shadowMap.autoUpdate = saved.shadowAutoUpdate;
+		const savedMeshes = new Set(saved.meshShadows.map((m) => m.mesh));
+		for (const { mesh, cast, receive } of saved.meshShadows) {
+			mesh.castShadow = cast;
+			mesh.receiveShadow = receive;
+		}
+		this.world.scene.three.traverse((object) => {
+			const mesh = object;
+			if (mesh.isMesh && !savedMeshes.has(mesh)) {
+				mesh.castShadow = false;
+				mesh.receiveShadow = false;
+			}
+		});
+		if (this.sunLight && saved.light) {
+			const s = saved.light;
+			this.sunLight.castShadow = s.castShadow;
+			this.sunLight.position.copy(s.position);
+			this.sunLight.target.position.copy(s.target);
+			this.sunLight.target.updateMatrixWorld();
+			this.sunLight.intensity = s.intensity;
+			this.sunLight.color.setHex(s.color);
+			this.sunLight.shadow.mapSize.copy(s.mapSize);
+			this.sunLight.shadow.bias = s.bias;
+			this.sunLight.shadow.normalBias = s.normalBias;
+			const c = this.sunLight.shadow.camera;
+			c.left = s.shadowCam.left;
+			c.right = s.shadowCam.right;
+			c.top = s.shadowCam.top;
+			c.bottom = s.shadowCam.bottom;
+			c.near = s.shadowCam.near;
+			c.far = s.shadowCam.far;
+			c.updateProjectionMatrix();
+			this.sunLight.shadow.map?.dispose();
+			this.sunLight.shadow.map = null;
+		}
+		if (this.ambientLight && saved.ambientIntensity !== null) this.ambientLight.intensity = saved.ambientIntensity;
+		this.sunLight = null;
+		this.ambientLight = null;
+		this.saved = null;
+	}
+};
+//#endregion
+export { Cinematic };
+
+//# sourceMappingURL=cinematic.mjs.map

package/dist/fragment-viewer/cinematic.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"cinematic.mjs","names":[],"sources":["../../src/fragment-viewer/cinematic.ts"],"sourcesContent":["import * as OBC from \"@thatopen/components\";\nimport * as OBF from \"@thatopen/components-front\";\nimport * as THREE from \"three\";\nimport {EffectComposer} from \"three/examples/jsm/postprocessing/EffectComposer.js\";\nimport {GTAOPass} from \"three/examples/jsm/postprocessing/GTAOPass.js\";\nimport {FullScreenQuad} from \"three/examples/jsm/postprocessing/Pass.js\";\nimport {RenderPass} from \"three/examples/jsm/postprocessing/RenderPass.js\";\n\n/**\n * Cinematic mode — sun-lit shading for the building, over a pixel-identical grid and background.\n *\n * The look that reads as \"3D and beautiful\" is a sun that casts shadows, ambient occlusion for contact\n * darkening, and ACES filmic tone mapping. But the grid and background must stay exactly what the normal\n * viewer shows — no tone mapping, no AO, no glow — for both a white and a dark app background.\n *\n * How it stays pixel-identical (verified against the installed three r182 + SDK source):\n *  - That Open keeps rendering the normal frame to the canvas every tick (renderer stays enabled). That\n *    frame IS the untouched grid + background.\n *  - On `world.onAfterUpdate` we render ONLY the building through an effect chain into an off-screen HDR\n *    buffer (RenderPass → GTAO), build a white-on-black silhouette mask, then draw a fullscreen quad over\n *    the canvas that applies ACES + sRGB to the building and **discards every non-building pixel**. Grid\n *    and background pixels are therefore never written — byte-identical, by construction.\n *  - Global renderer colour state (`toneMapping`, `outputColorSpace`) is never touched: three forces\n *    linear/no-tone-map when rendering into a target, so the building buffer is linear HDR and the quad\n *    does the one and only ACES+sRGB encode itself.\n *\n * Two deliberate limitations of keeping the grid untouched: no ground/cast shadow (it would darken the\n * grid — the building self-shadows only), and no outward bloom halo (it would tint the grid/sky).\n *\n * Everything is built on enable and fully freed on disable, so it costs nothing (memory or frame time)\n * while off.\n */\n\ninterface CinematicOptions {\n\t/** ACES exposure applied to the building in the composite. */\n\texposure?: number;\n}\n\n/** ACES filmic + sRGB, inlined to match three's ACESFilmicToneMapping + SRGBColorSpace exactly, plus a\n *  hard silhouette mask so only building pixels are ever written. */\nconst COMPOSITE_FRAGMENT = /* glsl */ `\n\tvarying vec2 vUv;\n\tuniform sampler2D tBuilding; // linear HDR (off-screen render — leave colorSpace default, do not decode)\n\tuniform sampler2D tMask;     // white-on-black building coverage\n\tuniform float uExposure;\n\n\tvec3 RRTAndODTFit(vec3 v) {\n\t\tvec3 a = v * (v + 0.0245786) - 0.000090537;\n\t\tvec3 b = v * (0.983729 * v + 0.4329510) + 0.238081;\n\t\treturn a / b;\n\t}\n\tvec3 ACESFilmic(vec3 color) {\n\t\tconst mat3 ACESInputMat = mat3(\n\t\t\t0.59719, 0.07600, 0.02840,\n\t\t\t0.35458, 0.90834, 0.13383,\n\t\t\t0.04823, 0.01566, 0.83777);\n\t\tconst mat3 ACESOutputMat = mat3(\n\t\t\t 1.60475, -0.10208, -0.00327,\n\t\t\t-0.53108,  1.10813, -0.07276,\n\t\t\t-0.07367, -0.00605,  1.07602);\n\t\tcolor *= uExposure / 0.6;\n\t\tcolor = ACESInputMat * color;\n\t\tcolor = RRTAndODTFit(color);\n\t\tcolor = ACESOutputMat * color;\n\t\treturn clamp(color, 0.0, 1.0);\n\t}\n\tvec3 sRGB_OETF(vec3 c) {\n\t\treturn mix(pow(c, vec3(0.41666)) * 1.055 - vec3(0.055), c * 12.92, vec3(lessThanEqual(c, vec3(0.0031308))));\n\t}\n\tvoid main() {\n\t\tfloat m = texture2D(tMask, vUv).r;\n\t\tif (m < 0.5) discard; // grid + background pixels are never written\n\t\tvec3 hdr = texture2D(tBuilding, vUv).rgb;\n\t\tgl_FragColor = vec4(sRGB_OETF(ACESFilmic(hdr)), 1.0);\n\t}\n`;\n\nconst COMPOSITE_VERTEX = /* glsl */ `\n\tvarying vec2 vUv;\n\tvoid main() { vUv = uv; gl_Position = vec4(position.xy, 0.0, 1.0); }\n`;\n\ntype World = OBC.SimpleWorld<OBC.SimpleScene, OBC.OrthoPerspectiveCamera, OBF.PostproductionRenderer>;\n\ninterface SavedLight {\n\tcastShadow: boolean;\n\tposition: THREE.Vector3;\n\ttarget: THREE.Vector3;\n\tintensity: number;\n\tcolor: number;\n\tmapSize: THREE.Vector2;\n\tbias: number;\n\tnormalBias: number;\n\tshadowCam: {left: number; right: number; top: number; bottom: number; near: number; far: number};\n}\n\nexport class Cinematic {\n\tprivate readonly world: World;\n\tprivate exposure = 1.2;\n\n\tprivate enabled = false;\n\tprivate hooked: (() => void) | null = null;\n\tprivate grid: THREE.Object3D | null = null;\n\n\t// Effect chain + composite (built on enable, disposed on disable).\n\tprivate composer: EffectComposer | null = null;\n\tprivate renderPass: RenderPass | null = null;\n\tprivate gtaoPass: GTAOPass | null = null;\n\tprivate maskRT: THREE.WebGLRenderTarget | null = null;\n\tprivate whiteMaterial: THREE.MeshBasicMaterial | null = null;\n\tprivate compositeMaterial: THREE.ShaderMaterial | null = null;\n\tprivate fsQuad: FullScreenQuad | null = null;\n\n\t// Lights we drive (restored on disable).\n\tprivate sunLight: THREE.DirectionalLight | null = null;\n\tprivate ambientLight: THREE.AmbientLight | null = null;\n\n\tprivate saved: {\n\t\tshadowEnabled: boolean;\n\t\tshadowType: THREE.ShadowMapType;\n\t\tshadowAutoUpdate: boolean;\n\t\tmeshShadows: {mesh: THREE.Mesh; cast: boolean; receive: boolean}[];\n\t\tlight: SavedLight | null;\n\t\tambientIntensity: number | null;\n\t} | null = null;\n\n\t/** Tracks the camera projection so the GTAO material's PERSPECTIVE_CAMERA define can be refreshed\n\t *  when the viewer toggles perspective↔orthographic (the SDK bakes it once at construction). */\n\tprivate lastCameraIsPerspective: boolean | null = null;\n\n\tconstructor(world: World, options: CinematicOptions = {}) {\n\t\tthis.world = world;\n\t\tif (options.exposure !== undefined) this.exposure = options.exposure;\n\t}\n\n\tget active(): boolean {\n\t\treturn this.enabled;\n\t}\n\n\t/** Turn cinematic mode on. `modelBox` frames the sun's shadow camera; `grid` is hidden per sub-render. */\n\tenable(modelBox: THREE.Box3 | null, grid: THREE.Object3D | null): void {\n\t\tif (this.enabled) return;\n\t\tconst renderer = this.world.renderer;\n\t\tif (!renderer) return;\n\t\tthis.enabled = true;\n\t\tthis.grid = grid;\n\n\t\tthis.saveState();\n\t\tthis.configureShadowsAndLights(modelBox);\n\t\tthis.flagMeshes();\n\t\tthis.buildComposer();\n\n\t\tconst render = () => this.render();\n\t\tthis.world.onAfterUpdate.add(render);\n\t\tthis.hooked = () => this.world.onAfterUpdate.remove(render);\n\t}\n\n\t/** Turn it off: restore every mutation and free every GPU resource (no idle VRAM). */\n\tdisable(): void {\n\t\tif (!this.enabled) return;\n\t\tthis.enabled = false;\n\t\tthis.hooked?.();\n\t\tthis.hooked = null;\n\t\tthis.disposeComposer();\n\t\tthis.restoreState();\n\t\tthis.grid = null;\n\t}\n\n\tresize(): void {\n\t\tif (!this.enabled || !this.composer) return;\n\t\tconst {width, height, dpr} = this.canvasSize();\n\t\tthis.composer.setSize(width, height);\n\t\tthis.composer.setPixelRatio(dpr);\n\t\tthis.maskRT?.setSize(Math.floor(width * dpr), Math.floor(height * dpr));\n\t}\n\n\tdispose(): void {\n\t\tthis.disable();\n\t}\n\n\t// ─── Setup ──────────────────────────────────────────────────────────────\n\n\tprivate canvasSize(): {width: number; height: number; dpr: number} {\n\t\tconst three = this.world.renderer?.three;\n\t\tconst dpr = three?.getPixelRatio() ?? 1;\n\t\tconst canvas = three?.domElement;\n\t\tif (!canvas) return {width: 2, height: 2, dpr};\n\t\treturn {\n\t\t\twidth: Math.floor(canvas.clientWidth || canvas.width / dpr),\n\t\t\theight: Math.floor(canvas.clientHeight || canvas.height / dpr),\n\t\t\tdpr,\n\t\t};\n\t}\n\n\tprivate saveState(): void {\n\t\tconst three = this.world.renderer?.three;\n\t\tif (!three) return;\n\t\tconst scene = this.world.scene.three;\n\t\tconst meshShadows: {mesh: THREE.Mesh; cast: boolean; receive: boolean}[] = [];\n\t\tscene.traverse((object) => {\n\t\t\tconst mesh = object as THREE.Mesh;\n\t\t\tif (mesh.isMesh) meshShadows.push({mesh, cast: mesh.castShadow, receive: mesh.receiveShadow});\n\t\t});\n\t\tthis.saved = {\n\t\t\tshadowEnabled: three.shadowMap.enabled,\n\t\t\tshadowType: three.shadowMap.type,\n\t\t\tshadowAutoUpdate: three.shadowMap.autoUpdate,\n\t\t\tmeshShadows,\n\t\t\tlight: null,\n\t\t\tambientIntensity: null,\n\t\t};\n\t}\n\n\t/** Enable the shadow map and re-balance the lights so the building isn't flat under ACES. Global\n\t *  colour state (tone mapping / output colour space / background) is intentionally left untouched —\n\t *  the grid + background must render exactly as normal, and only the building buffer is tone-mapped. */\n\tprivate configureShadowsAndLights(modelBox: THREE.Box3 | null): void {\n\t\tconst three = this.world.renderer?.three;\n\t\tif (!three) return;\n\t\tthree.shadowMap.enabled = true;\n\t\tthree.shadowMap.type = THREE.PCFSoftShadowMap;\n\t\t// The sun and model are static during the mode, and the shadow map is view-independent, so don't\n\t\t// let three recompute the 4096² map on every renderer.render (~4×/frame). render() flags a single\n\t\t// recompute per frame instead — which also picks up geometry streamed in as you zoom.\n\t\tthree.shadowMap.autoUpdate = false;\n\n\t\tconst box =\n\t\t\tmodelBox && !modelBox.isEmpty()\n\t\t\t\t? modelBox\n\t\t\t\t: new THREE.Box3(new THREE.Vector3(-10, 0, -10), new THREE.Vector3(10, 20, 10));\n\t\tconst sphere = box.getBoundingSphere(new THREE.Sphere());\n\t\tconst r = Math.max(sphere.radius, 1);\n\n\t\tconst light = [...this.world.scene.directionalLights.values()][0];\n\t\tif (light) {\n\t\t\tthis.sunLight = light;\n\t\t\tif (this.saved) {\n\t\t\t\tconst c = light.shadow.camera;\n\t\t\t\tthis.saved.light = {\n\t\t\t\t\tcastShadow: light.castShadow,\n\t\t\t\t\tposition: light.position.clone(),\n\t\t\t\t\ttarget: light.target.position.clone(),\n\t\t\t\t\tintensity: light.intensity,\n\t\t\t\t\tcolor: light.color.getHex(),\n\t\t\t\t\tmapSize: light.shadow.mapSize.clone(),\n\t\t\t\t\tbias: light.shadow.bias,\n\t\t\t\t\tnormalBias: light.shadow.normalBias,\n\t\t\t\t\tshadowCam: {left: c.left, right: c.right, top: c.top, bottom: c.bottom, near: c.near, far: c.far},\n\t\t\t\t};\n\t\t\t}\n\t\t\t// Warm key pushed past linear 1.0 so ACES's highlight rolloff engages; low fill so shadows read.\n\t\t\tlight.intensity = 3.0;\n\t\t\tlight.color.set(\"#ffedcf\");\n\t\t\tconst dir = new THREE.Vector3(0.45, 0.85, 0.35).normalize();\n\t\t\tlight.position.copy(sphere.center).add(dir.multiplyScalar(r * 2.5));\n\t\t\tlight.target.position.copy(sphere.center);\n\t\t\tlight.target.updateMatrixWorld();\n\t\t\tlight.castShadow = true;\n\t\t\tlight.shadow.mapSize.set(4096, 4096);\n\t\t\tlight.shadow.bias = -0.0004;\n\t\t\tlight.shadow.normalBias = 0.05;\n\t\t\tconst cam = light.shadow.camera;\n\t\t\tcam.left = -r;\n\t\t\tcam.right = r;\n\t\t\tcam.top = r;\n\t\t\tcam.bottom = -r;\n\t\t\tcam.near = r;\n\t\t\tcam.far = r * 4;\n\t\t\tcam.updateProjectionMatrix();\n\t\t}\n\n\t\tconst ambient = [...this.world.scene.ambientLights.values()][0];\n\t\tif (ambient) {\n\t\t\tthis.ambientLight = ambient;\n\t\t\tif (this.saved) this.saved.ambientIntensity = ambient.intensity;\n\t\t\tambient.intensity = 0.3;\n\t\t}\n\t}\n\n\t/** Flag full-detail (MeshLambert) meshes to cast + receive self-shadows; exclude the LOD shader (no\n\t *  depth program) and the grid. Run per-frame because zoom streams new meshes. */\n\tprivate flagMeshes(): void {\n\t\tthis.world.scene.three.traverse((object) => {\n\t\t\tconst mesh = object as THREE.Mesh;\n\t\t\tif (!mesh.isMesh || mesh === this.grid) return;\n\t\t\tconst material = mesh.material;\n\t\t\tconst isLambert = Array.isArray(material)\n\t\t\t\t? material.some((m) => (m as {isMeshLambertMaterial?: boolean}).isMeshLambertMaterial)\n\t\t\t\t: (material as {isMeshLambertMaterial?: boolean}).isMeshLambertMaterial === true;\n\t\t\tif (isLambert) {\n\t\t\t\tmesh.castShadow = true;\n\t\t\t\tmesh.receiveShadow = true;\n\t\t\t} else {\n\t\t\t\tmesh.castShadow = false;\n\t\t\t}\n\t\t});\n\t}\n\n\tprivate buildComposer(): void {\n\t\tconst renderer = this.world.renderer?.three;\n\t\tif (!renderer) return;\n\t\tconst scene = this.world.scene.three;\n\t\tconst camera = this.world.camera.three;\n\t\tconst {width, height, dpr} = this.canvasSize();\n\n\t\tthis.composer = new EffectComposer(renderer);\n\t\tthis.composer.renderToScreen = false; // final building image stays in composer.readBuffer.texture\n\t\tthis.composer.setSize(width, height);\n\t\tthis.composer.setPixelRatio(dpr);\n\n\t\tthis.renderPass = new RenderPass(scene, camera);\n\t\tthis.composer.addPass(this.renderPass);\n\n\t\tthis.gtaoPass = new GTAOPass(scene, camera, width, height);\n\t\tthis.gtaoPass.output = GTAOPass.OUTPUT.Default;\n\t\tthis.gtaoPass.blendIntensity = 1.0;\n\t\tthis.gtaoPass.updateGtaoMaterial({\n\t\t\tradius: 1.5,\n\t\t\tdistanceExponent: 1.0,\n\t\t\tthickness: 1.0,\n\t\t\tscale: 1.0,\n\t\t\tsamples: 16,\n\t\t\tscreenSpaceRadius: false,\n\t\t});\n\t\tthis.composer.addPass(this.gtaoPass);\n\t\t// GTAO bakes PERSPECTIVE_CAMERA at construction from the current camera; remember it so render()\n\t\t// only refreshes the define on an actual projection change.\n\t\tthis.lastCameraIsPerspective = (camera as THREE.PerspectiveCamera).isPerspectiveCamera === true;\n\n\t\t// Full-res silhouette mask (must pixel-align with the canvas; no half-res).\n\t\tthis.maskRT = new THREE.WebGLRenderTarget(Math.floor(width * dpr), Math.floor(height * dpr), {\n\t\t\tdepthBuffer: true,\n\t\t\tminFilter: THREE.LinearFilter,\n\t\t\tmagFilter: THREE.LinearFilter,\n\t\t});\n\t\tthis.whiteMaterial = new THREE.MeshBasicMaterial({color: 0xffffff});\n\n\t\tthis.compositeMaterial = new THREE.ShaderMaterial({\n\t\t\tuniforms: {\n\t\t\t\ttBuilding: {value: null},\n\t\t\t\ttMask: {value: null},\n\t\t\t\tuExposure: {value: this.exposure},\n\t\t\t},\n\t\t\tvertexShader: COMPOSITE_VERTEX,\n\t\t\tfragmentShader: COMPOSITE_FRAGMENT,\n\t\t\ttoneMapped: false, // custom shader does its own ACES+sRGB; three must not re-encode\n\t\t\tdepthTest: false,\n\t\t\tdepthWrite: false,\n\t\t\tblending: THREE.NoBlending,\n\t\t});\n\t\tthis.fsQuad = new FullScreenQuad(this.compositeMaterial);\n\t}\n\n\t// ─── Per-frame ──────────────────────────────────────────────────────────\n\n\tprivate render(): void {\n\t\tconst renderer = this.world.renderer?.three;\n\t\tif (!this.enabled || !renderer) return;\n\t\tif (!this.composer || !this.maskRT || !this.whiteMaterial || !this.compositeMaterial || !this.fsQuad) return;\n\t\tconst scene = this.world.scene.three;\n\t\tconst camera = this.world.camera.three;\n\n\t\t// Re-flag streamed meshes each frame (cheap, and catches new geometry). Refresh pass cameras too\n\t\t// (OrthoPerspectiveCamera swaps its object on projection toggle).\n\t\tthis.flagMeshes();\n\t\tif (this.renderPass) this.renderPass.camera = camera;\n\t\tif (this.gtaoPass) {\n\t\t\tthis.gtaoPass.camera = camera;\n\t\t\t// GTAO's projection define is baked once; refresh it when perspective↔ortho actually changes,\n\t\t\t// or its depth→view reconstruction (and the AO) goes wrong in the swapped projection.\n\t\t\tconst isPerspective = (camera as THREE.PerspectiveCamera).isPerspectiveCamera === true;\n\t\t\tif (this.lastCameraIsPerspective !== isPerspective) {\n\t\t\t\tthis.gtaoPass.gtaoMaterial.defines.PERSPECTIVE_CAMERA = isPerspective ? 1 : 0;\n\t\t\t\tthis.gtaoPass.gtaoMaterial.needsUpdate = true;\n\t\t\t\tthis.lastCameraIsPerspective = isPerspective;\n\t\t\t}\n\t\t}\n\t\t// One shadow-map recompute per frame (autoUpdate is off) — picks up streamed geometry, but avoids\n\t\t// the ~4 recomputes the multiple renderer.render calls below would otherwise each trigger.\n\t\trenderer.shadowMap.needsUpdate = true;\n\n\t\tconst prevTarget = renderer.getRenderTarget();\n\t\tconst prevAutoClear = renderer.autoClear;\n\t\tconst prevClearColor = renderer.getClearColor(new THREE.Color());\n\t\tconst prevClearAlpha = renderer.getClearAlpha();\n\t\tconst prevBackground = scene.background;\n\t\tconst prevOverride = scene.overrideMaterial;\n\t\tconst prevGridVisible = this.grid?.visible ?? true;\n\n\t\t// 1) Building layer → composer.readBuffer (linear HDR, grid hidden, transparent clear).\n\t\tif (this.grid) this.grid.visible = false;\n\t\tscene.background = null;\n\t\trenderer.setClearColor(0x000000, 0);\n\t\tthis.composer.render();\n\n\t\t// 2) White-on-black silhouette mask (same hidden grid).\n\t\tscene.overrideMaterial = this.whiteMaterial;\n\t\trenderer.setRenderTarget(this.maskRT);\n\t\trenderer.setClearColor(0x000000, 1);\n\t\trenderer.autoClear = true;\n\t\trenderer.clear();\n\t\trenderer.render(scene, camera);\n\n\t\t// Restore the scene before drawing to the canvas.\n\t\tscene.overrideMaterial = prevOverride;\n\t\tscene.background = prevBackground;\n\t\tif (this.grid) this.grid.visible = prevGridVisible;\n\n\t\t// 3) Composite over That Open's canvas frame: ACES+sRGB the building, discard grid/bg pixels.\n\t\tthis.compositeMaterial.uniforms.tBuilding.value = this.composer.readBuffer.texture;\n\t\tthis.compositeMaterial.uniforms.tMask.value = this.maskRT.texture;\n\t\trenderer.setRenderTarget(null);\n\t\trenderer.autoClear = false;\n\t\tthis.fsQuad.render(renderer);\n\n\t\trenderer.autoClear = prevAutoClear;\n\t\trenderer.setClearColor(prevClearColor, prevClearAlpha);\n\t\trenderer.setRenderTarget(prevTarget);\n\t}\n\n\t// ─── Teardown ───────────────────────────────────────────────────────────\n\n\tprivate disposeComposer(): void {\n\t\tthis.composer?.dispose();\n\t\t// three's GTAOPass.dispose() leaks its gtaoMaterial + blendMaterial; free them explicitly.\n\t\tthis.gtaoPass?.gtaoMaterial?.dispose();\n\t\tthis.gtaoPass?.blendMaterial?.dispose();\n\t\tthis.gtaoPass?.dispose();\n\t\tthis.maskRT?.dispose();\n\t\tthis.whiteMaterial?.dispose();\n\t\tthis.compositeMaterial?.dispose();\n\t\tthis.fsQuad?.dispose();\n\t\tthis.composer = null;\n\t\tthis.renderPass = null;\n\t\tthis.gtaoPass = null;\n\t\tthis.maskRT = null;\n\t\tthis.whiteMaterial = null;\n\t\tthis.compositeMaterial = null;\n\t\tthis.fsQuad = null;\n\t}\n\n\tprivate restoreState(): void {\n\t\tconst saved = this.saved;\n\t\tconst three = this.world.renderer?.three;\n\t\tif (!saved || !three) return;\n\t\tthree.shadowMap.enabled = saved.shadowEnabled;\n\t\tthree.shadowMap.type = saved.shadowType;\n\t\tthree.shadowMap.autoUpdate = saved.shadowAutoUpdate;\n\t\t// Restore the enable-time meshes; reset anything streamed in while active to the default (unflagged)\n\t\t// so no stale cast/receive flags linger after the mode is off.\n\t\tconst savedMeshes = new Set(saved.meshShadows.map((m) => m.mesh));\n\t\tfor (const {mesh, cast, receive} of saved.meshShadows) {\n\t\t\tmesh.castShadow = cast;\n\t\t\tmesh.receiveShadow = receive;\n\t\t}\n\t\tthis.world.scene.three.traverse((object) => {\n\t\t\tconst mesh = object as THREE.Mesh;\n\t\t\tif (mesh.isMesh && !savedMeshes.has(mesh)) {\n\t\t\t\tmesh.castShadow = false;\n\t\t\t\tmesh.receiveShadow = false;\n\t\t\t}\n\t\t});\n\t\tif (this.sunLight && saved.light) {\n\t\t\tconst s = saved.light;\n\t\t\tthis.sunLight.castShadow = s.castShadow;\n\t\t\tthis.sunLight.position.copy(s.position);\n\t\t\tthis.sunLight.target.position.copy(s.target);\n\t\t\tthis.sunLight.target.updateMatrixWorld();\n\t\t\tthis.sunLight.intensity = s.intensity;\n\t\t\tthis.sunLight.color.setHex(s.color);\n\t\t\tthis.sunLight.shadow.mapSize.copy(s.mapSize);\n\t\t\tthis.sunLight.shadow.bias = s.bias;\n\t\t\tthis.sunLight.shadow.normalBias = s.normalBias;\n\t\t\tconst c = this.sunLight.shadow.camera;\n\t\t\tc.left = s.shadowCam.left;\n\t\t\tc.right = s.shadowCam.right;\n\t\t\tc.top = s.shadowCam.top;\n\t\t\tc.bottom = s.shadowCam.bottom;\n\t\t\tc.near = s.shadowCam.near;\n\t\t\tc.far = s.shadowCam.far;\n\t\t\tc.updateProjectionMatrix();\n\t\t\tthis.sunLight.shadow.map?.dispose();\n\t\t\tthis.sunLight.shadow.map = null;\n\t\t}\n\t\tif (this.ambientLight && saved.ambientIntensity !== null) {\n\t\t\tthis.ambientLight.intensity = saved.ambientIntensity;\n\t\t}\n\t\tthis.sunLight = null;\n\t\tthis.ambientLight = null;\n\t\tthis.saved = null;\n\t}\n}\n"],"mappings":"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"}

package/dist/fragment-viewer/context.d.mts

@@ -0,0 +1,106 @@
+import { FragmentMarker, FragmentSelection, FragmentStorey, FragmentViewport, FragmentViewportStatus, InteractionMode, NavigationMode, ProjectionMode } from "./runtime.mjs";
+import * as React from "react";
+//#region src/fragment-viewer/context.d.ts
+/**
+ * Shared state between FragmentViewer (the canvas) and ViewerToolbar (the chrome).
+ *
+ * A context rather than an imperative ref because the toolbar has to *reflect* engine state — which
+ * projection is active, which tool is armed — not just fire at it. Both components mount under one
+ * FragmentViewerProvider; the template composes them however it likes.
+ */
+export interface FragmentViewerState {
+  status: FragmentViewportStatus;
+  error: Error | null;
+  /** True once a viewport has mounted and registered itself. */
+  ready: boolean;
+  selection: FragmentSelection | null;
+  modelIds: string[];
+  navigation: NavigationMode;
+  projection: ProjectionMode;
+  /** Armed tool: what a double-click will do. */
+  interaction: InteractionMode;
+  /** Whether existing clipping planes are active (they persist while disabled). */
+  clippingEnabled: boolean;
+  /** Whole model faded back so selections and sections read clearly. */
+  ghost: boolean;
+  /** Cinematic mode (shadows + AO + bloom + beams + tone mapping) is on. Full navigation stays live. */
+  cinematic: boolean;
+  storeys: FragmentStorey[];
+  activeStorey: string | null;
+  /** Camera yaw (azimuth) in degrees, updated as the model is orbited. Lets chrome like the site
+   * minimap rotate to stay aligned with the view. */
+  heading: number;
+}
+export interface FragmentViewerApi {
+  fit(): Promise<void>;
+  setNavigation(mode: NavigationMode): void;
+  toggleProjection(): Promise<void>;
+  /** Arm a tool, or pass null to return to plain selection. Re-arming the same tool disarms it. */
+  setInteraction(mode: InteractionMode): void;
+  toggleClipping(): void;
+  clearSections(): void;
+  clearMeasurements(): void;
+  hideSelection(): Promise<void>;
+  isolateSelection(): Promise<void>;
+  showAll(): Promise<void>;
+  setPostproduction(enabled: boolean): void;
+  /** Fade the model back (or restore it). */
+  setGhost(enabled: boolean): Promise<void>;
+  /** Toggle cinematic mode (shadows + AO + bloom + beams + tone mapping). */
+  setCinematic(enabled: boolean): void;
+  /** Derive storey views from the IFC spatial structure. Cached in state afterwards. */
+  loadStoreys(): Promise<void>;
+  openStorey(id: string): Promise<void>;
+  closeStorey(): Promise<void>;
+  /** Draw point markers (workers, sensors…) — one InstancedMesh, so thousands stay cheap. */
+  setMarkers(markers: FragmentMarker[], options?: {
+    radius?: number;
+    color?: string;
+    occluded?: boolean;
+  }): void;
+  clearMarkers(): void;
+  /** The whole model's world-space bounding box, for placing markers across the footprint. */
+  bounds(): {
+    min: [number, number, number];
+    max: [number, number, number];
+  } | null;
+  /** Each storey's world-space box (real footprint + height), keyed by storey id. */
+  storeyFootprints(): Promise<Record<string, {
+    min: [number, number, number];
+    max: [number, number, number];
+  }>>;
+  /** The underlying viewport, for callers that need the raw SDK. */
+  viewport(): FragmentViewport | null;
+}
+interface ContextValue {
+  state: FragmentViewerState;
+  api: FragmentViewerApi;
+  /** Called by FragmentViewer on mount/unmount. Not for application code. */
+  register: (viewport: FragmentViewport | null) => void;
+  patch: (next: Partial<FragmentViewerState>) => void;
+}
+export declare function FragmentViewerProvider({ children }: {
+  children: React.ReactNode;
+}): import("react/jsx-runtime").JSX.Element;
+/** Read viewer state and drive the engine. Must be called under a FragmentViewerProvider. */
+export declare function useFragmentViewer(): {
+  state: FragmentViewerState;
+  api: FragmentViewerApi;
+};
+/**
+ * Viewer state and engine when there is a provider, or `null` when there is not.
+ *
+ * The null-tolerant twin of {@link useFragmentViewer}, for a surface whose stage may or may not be a
+ * FragmentViewer — Workforce Map View renders a placeholder plan when it is not. Callers used to get
+ * this by wrapping `useFragmentViewer()` in a try/catch, which reads as a conditional hook call (and
+ * oxlint's `react-hooks(rules-of-hooks)` rejects it), besides swallowing every other error the hook
+ * might raise. Reading the context directly is both honest and unconditional.
+ */
+export declare function useOptionalFragmentViewer(): {
+  state: FragmentViewerState;
+  api: FragmentViewerApi;
+} | null;
+/** Internal wiring for FragmentViewer. Returns null outside a provider so the viewer can stand alone. */
+export declare function useFragmentViewerRegistration(): Pick<ContextValue, "register" | "patch"> | null;
+//#endregion
+//# sourceMappingURL=context.d.mts.map

package/dist/fragment-viewer/context.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"context.d.mts","names":[],"sources":["../../src/fragment-viewer/context.tsx"],"mappings":";;;;;;;;;;iBAqBiB;EAChB,QAAQ;EACR,OAAO;;EAEP;EACA,WAAW;EACX;EACA,YAAY;EACZ,YAAY;;EAEZ,aAAa;;EAEb;;EAEA;;EAEA;EACA,SAAS;EACT;;;EAGA;;iBAGgB;EAChB,OAAO;EACP,cAAc,MAAM;EACpB,oBAAoB;;EAEpB,eAAe,MAAM;EACrB;EACA;EACA;EACA,iBAAiB;EACjB,oBAAoB;EACpB,WAAW;EACX,kBAAkB;;EAElB,SAAS,mBAAmB;;EAE5B,aAAa;;EAEb,eAAe;EACf,WAAW,aAAa;EACxB,eAAe;;EAEf,WAAW,SAAS,kBAAkB;IAAW;IAAiB;IAAgB;;EAClF;;EAEA;IAAW;IAA+B;;;EAE1C,oBAAoB,QAAQ;IAAgB;IAA+B;;;EAE3E,YAAY;;UAGH;EACT,OAAO;EACP,KAAK;;EAEL,WAAW,UAAU;EACrB,QAAQ,MAAM,QAAQ;;wBAsBP,yBAAwB;EAAY,UAAU,MAAM;gCAAU,IAAA;;wBAoG9D;EAAsB,OAAO;EAAqB,KAAK;;;;;;;;;;;wBAevD;EAA8B,OAAO;EAAqB,KAAK;;;wBAO/D,iCAAiC,KAAK"}