incanto 0.4.3 → 0.6.0

package/dist/{create-game-CZHROKcT.js → create-game-B_sW_eiE.js}

@@ -1,13 +1,13 @@
 import { t as __exportAll } from "./rolldown-runtime-D7D4PA-g.js";
-import { _ as registerBehavior, n as loadScene, o as computeViewport, s as resolveViewport } from "./loader-CGs_G-r0.js";
-import { a as Engine } from "./particle-sim-DYuSUxvK.js";
+import { _ as registerBehavior, n as loadScene, o as computeViewport, s as resolveViewport } from "./loader-B4OEXDZ8.js";
+import { a as Engine } from "./particle-sim-CFkILGwh.js";
 import { t as IncantoError } from "./errors-BpWbnbb_.js";
-import { r as AudioPlayer } from "./register-BuUV1_KB.js";
+import { s as AudioPlayer } from "./register-Dl_ixIJe.js";
 import { i as resolveRendering, n as attachTouchControls } from "./touch-031PxtCR.js";
-import { n as registerGameplayBehaviors } from "./gameplay-Ccruc3Wd.js";
-import { f as PhysicsBody2D, h as Node2D, n as UILayer, s as Camera2D, t as registerNodes2D } from "./register-DPEV9_9t.js";
+import { n as registerGameplayBehaviors } from "./gameplay-CDFgSG6z.js";
+import { g as Node2D, n as UILayer, p as PhysicsBody2D, s as Camera2D, t as registerNodes2D } from "./register-BJCfuuZ2.js";
 import { t as debugSources } from "./debug-draw-CZmOYjL2.js";
-import { n as enablePhysics2D } from "./physics-2d-KuMWPTf6.js";
+import { n as enablePhysics2D } from "./physics-2d-Cgli1aju.js";
 import { Box3, BufferAttribute, BufferGeometry, Color, LineBasicMaterial, LineSegments, LinearFilter, NearestFilter, OrthographicCamera, Raycaster, SRGBColorSpace, Scene, TextureLoader, Vector2, Vector3, WebGLRenderer } from "three";
 //#region src/2d/assets.ts
 /**
@@ -102,26 +102,41 @@ function worldFromScreen(view, sx, sy) {
 }
 //#endregion
 //#region src/2d/sync.ts
-/**
-* Mirror an Incanto node tree onto two three scenes:
-* - `world`: camera-space drawables
-* - `ui`: everything under a `UILayer` (screen space, ignores the camera);
-*   each layer mounts through its own group, positioned by its `anchor`
-*   against `uiSize` (origin when no size is known — headless).
-*
-* Same dirty-push contract as the 3D sync; pure scene-graph math, headless-testable.
-*/
-function syncTree2D(root, world, ui, assets, uiSize) {
-	const visited = /* @__PURE__ */ new Set();
-	const cameras = [];
-	walk(root, world, ui, false, visited, cameras, assets, uiSize);
-	prune(world, visited);
-	prune(ui, visited);
-	return { activeCamera: cameras.find((c) => c.current) ?? cameras[0] ?? null };
+function createSync2DScratch() {
+	return {
+		visited: /* @__PURE__ */ new Set(),
+		cameras: []
+	};
+}
+function syncTree2D(root, world, ui, assets, uiSize, scratch, opts) {
+	const s = scratch ?? createSync2DScratch();
+	s.visited.clear();
+	s.cameras.length = 0;
+	walk(root, world, ui, false, s.visited, s.cameras, assets, uiSize, opts?.ignoreStatic === true);
+	prune(world, s.visited);
+	prune(ui, s.visited);
+	let current = null;
+	for (let i = 0; i < s.cameras.length; i++) {
+		const c = s.cameras[i];
+		if (c.current) {
+			current = c;
+			break;
+		}
+	}
+	if (!current) current = s.cameras[0] ?? null;
+	return { activeCamera: current };
 }
-function walk(node, parentObj, ui, inUi, visited, cameras, assets, uiSize) {
+function walk(node, parentObj, ui, inUi, visited, cameras, assets, uiSize, ignoreStatic) {
 	let nextParent = parentObj;
 	let nextInUi = inUi;
+	if (node instanceof Node2D && !(node instanceof UILayer)) {
+		const frozen = node._ensureObject2D();
+		if (node.static && !ignoreStatic && frozen.userData.incantoStaticSynced === true) {
+			frozen.userData.incantoStatic = true;
+			visited.add(frozen);
+			return;
+		}
+	}
 	if (node instanceof UILayer) {
 		const group = node._ensureGroup();
 		if (group.parent !== ui) ui.add(group);
@@ -141,11 +156,25 @@ function walk(node, parentObj, ui, inUi, visited, cameras, assets, uiSize) {
 		if (node instanceof Camera2D && !inUi) cameras.push(node);
 		nextParent = obj;
 	}
-	for (const child of node.children) walk(child, nextParent, ui, nextInUi, visited, cameras, assets, uiSize);
+	for (const child of node.children) walk(child, nextParent, ui, nextInUi, visited, cameras, assets, uiSize, ignoreStatic);
+	if (node instanceof Node2D && !(node instanceof UILayer)) {
+		const obj = node._ensureObject2D();
+		if (node.static && !ignoreStatic) {
+			obj.userData.incantoStaticSynced = true;
+			obj.userData.incantoStatic = true;
+		} else if (obj.userData.incantoStaticSynced === true) {
+			obj.userData.incantoStaticSynced = false;
+			obj.userData.incantoStatic = false;
+		}
+	}
 }
 function prune(obj, visited) {
-	for (const child of [...obj.children]) if (child.userData.incantoNode && !visited.has(child)) obj.remove(child);
-	else prune(child, visited);
+	const ch = obj.children;
+	for (let i = ch.length - 1; i >= 0; i--) {
+		const child = ch[i];
+		if (child.userData.incantoNode && !visited.has(child)) obj.remove(child);
+		else if (child.userData.incantoStatic !== true) prune(child, visited);
+	}
 }
 //#endregion
 //#region src/2d/renderer.ts
@@ -163,6 +192,9 @@ var Renderer2D = class {
 	viewOverride = null;
 	webgl;
 	worldScene = new Scene();
+	syncScratch = createSync2DScratch();
+	/** Editors set this: keep syncing `static: true` subtrees every frame. */
+	ignoreStatic = false;
 	uiScene = new Scene();
 	worldCam = new OrthographicCamera(-1, 1, 1, -1, -1e3, 1e3);
 	uiCam = new OrthographicCamera(-1, 1, 1, -1, -1e3, 1e3);
@@ -231,7 +263,7 @@ var Renderer2D = class {
 		const { activeCamera } = syncTree2D(scene.root, this.worldScene, this.uiScene, this.assets, {
 			width: uiW,
 			height: uiH
-		});
+		}, this.syncScratch);
 		let center = vp ? {
 			x: vp.design[0] / 2,
 			y: vp.design[1] / 2

package/dist/{create-game-DiTq3-fQ.js → create-game-DkbZCNaV.js}

@@ -1,14 +1,14 @@
 import { t as __exportAll } from "./rolldown-runtime-D7D4PA-g.js";
-import { _ as registerBehavior, n as loadScene } from "./loader-CGs_G-r0.js";
-import { a as Engine } from "./particle-sim-DYuSUxvK.js";
+import { _ as registerBehavior, n as loadScene } from "./loader-B4OEXDZ8.js";
+import { a as Engine } from "./particle-sim-CFkILGwh.js";
 import { t as IncantoError } from "./errors-BpWbnbb_.js";
-import { r as AudioPlayer } from "./register-BuUV1_KB.js";
+import { s as AudioPlayer } from "./register-Dl_ixIJe.js";
 import { i as resolveRendering, n as attachTouchControls } from "./touch-031PxtCR.js";
-import { n as registerGameplayBehaviors } from "./gameplay-Ccruc3Wd.js";
+import { n as registerGameplayBehaviors } from "./gameplay-CDFgSG6z.js";
 import { t as debugSources } from "./debug-draw-CZmOYjL2.js";
-import { E as PhysicsBody3D, c as ModelInstance3D, k as Node3D, t as registerNodes3D, u as DirectionalLight3D, v as Camera3D } from "./register-BRy8FNox.js";
-import { n as enablePhysics3D } from "./physics-3d-DmNCeh58.js";
-import { ACESFilmicToneMapping, AmbientLight, BufferAttribute, BufferGeometry, Color, DepthTexture, EquirectangularReflectionMapping, FloatType, Fog, LineBasicMaterial, LineSegments, Matrix4, Mesh, PCFShadowMap, PMREMGenerator, PerspectiveCamera, PlaneGeometry, Quaternion, Raycaster, Scene, ShaderMaterial, Vector2, Vector3, WebGLRenderTarget, WebGLRenderer } from "three";
+import { O as PhysicsBody3D, c as ModelInstance3D, d as DirectionalLight3D, j as Node3D, t as registerNodes3D, y as Camera3D } from "./register-Dd7Juujf.js";
+import { n as enablePhysics3D } from "./physics-3d-CBAQ12LY.js";
+import { ACESFilmicToneMapping, AmbientLight, BufferAttribute, BufferGeometry, Color, DepthTexture, EquirectangularReflectionMapping, FloatType, Fog, HalfFloatType, LineBasicMaterial, LineSegments, Matrix4, Mesh, PCFShadowMap, PMREMGenerator, PerspectiveCamera, PlaneGeometry, Quaternion, Raycaster, Scene, ShaderMaterial, Vector2, Vector3, WebGLRenderTarget, WebGLRenderer } from "three";
 import { VRMLoaderPlugin, VRMUtils } from "@pixiv/three-vrm";
 import { GLTFLoader } from "three/addons/loaders/GLTFLoader.js";
 import { RGBELoader } from "three/examples/jsm/loaders/RGBELoader.js";
@@ -127,6 +127,122 @@ var AssetStore3D = class {
 	}
 };
 //#endregion
+//#region src/3d/bloom/bloom-composite.ts
+/**
+* HDR bloom post pass:
+*
+*   scene → offscreen HalfFloat target (raw linear HDR — three applies neither
+*     tone mapping nor the sRGB transform when rendering into a target)
+*   bright-pass at HALF resolution (keep only luminance above `threshold`;
+*     with HDR buffers, emissives and sun glints sit above 1.0)
+*   separable 9-tap Gaussian blur (H then V) at half res
+*   composite: scene + glow × strength, THEN the standard postprocessing tail
+*     (ACES tone mapping + linear→sRGB) — skipping that tail is exactly the
+*     dark/oversaturated bug the volumetric-clouds pipeline shipped with.
+*/
+const VERT = `
+varying vec2 vUv;
+void main() {
+  vUv = uv;
+  gl_Position = vec4(position.xy, 0.0, 1.0);
+}
+`;
+const BRIGHT_FRAG = `
+precision highp float;
+varying vec2 vUv;
+uniform sampler2D tScene;
+uniform float uThreshold;
+void main() {
+  vec3 c = texture2D(tScene, vUv).rgb;
+  // HDR luminance knee: the scene buffer is raw linear HDR (tone mapping is
+  // applied later, in the composite), so emissives/sun glints sit ABOVE 1.0 —
+  // keep only the energy above the threshold, in proportion
+  float l = dot(c, vec3(0.2126, 0.7152, 0.0722));
+  float k = max(l - uThreshold, 0.0);
+  gl_FragColor = vec4(c * (k / max(l, 1e-4)), 1.0);
+}
+`;
+const BLUR_FRAG = `
+precision highp float;
+varying vec2 vUv;
+uniform sampler2D tTex;
+uniform vec2 uDir;
+void main() {
+  // 9-tap Gaussian, sigma ~2 texels (same recipe as the cloud blur)
+  vec4 sum = texture2D(tTex, vUv) * 0.227027;
+  sum += texture2D(tTex, vUv + uDir * 1.3846) * 0.3162162;
+  sum += texture2D(tTex, vUv - uDir * 1.3846) * 0.3162162;
+  sum += texture2D(tTex, vUv + uDir * 3.2308) * 0.0702703;
+  sum += texture2D(tTex, vUv - uDir * 3.2308) * 0.0702703;
+  gl_FragColor = sum;
+}
+`;
+const COMPOSITE_FRAG = `
+precision highp float;
+varying vec2 vUv;
+uniform sampler2D tScene;
+uniform sampler2D tBloom;
+uniform float uStrength;
+void main() {
+  vec3 base = texture2D(tScene, vUv).rgb;
+  vec3 glow = texture2D(tBloom, vUv).rgb;
+  gl_FragColor = vec4(base + glow * uStrength, 1.0);
+  // three skips BOTH tone mapping and the output colorspace transform when the
+  // scene renders into an offscreen target — the buffer holds raw linear HDR.
+  // This is the final to-screen pass, so apply the standard postprocessing
+  // tail here (ACES then linear→sRGB); without it the frame comes out dark
+  // and oversaturated (the volumetric-clouds pipeline bug, root-caused).
+  #include <tonemapping_fragment>
+  #include <colorspace_fragment>
+}
+`;
+function quad(fragment, uniforms) {
+	const material = new ShaderMaterial({
+		vertexShader: VERT,
+		fragmentShader: fragment,
+		depthTest: false,
+		depthWrite: false,
+		uniforms
+	});
+	const mesh = new Mesh(new PlaneGeometry(2, 2), material);
+	mesh.frustumCulled = false;
+	return mesh;
+}
+/** Half-res bright-pass quad — keeps only pixels brighter than the threshold. */
+function createBloomBrightQuad() {
+	const mesh = quad(BRIGHT_FRAG, {
+		tScene: { value: null },
+		uThreshold: { value: 1 }
+	});
+	return {
+		mesh,
+		uniforms: mesh.material.uniforms
+	};
+}
+/** Separable-blur quad (run twice: uDir = (1/w, 0) then (0, 1/h)). */
+function createBloomBlurQuad() {
+	const mesh = quad(BLUR_FRAG, {
+		tTex: { value: null },
+		uDir: { value: new Vector2() }
+	});
+	return {
+		mesh,
+		uniforms: mesh.material.uniforms
+	};
+}
+/** Full-res composite quad — adds the blurred glow over the scene. */
+function createBloomCompositeQuad() {
+	const mesh = quad(COMPOSITE_FRAG, {
+		tScene: { value: null },
+		tBloom: { value: null },
+		uStrength: { value: .85 }
+	});
+	return {
+		mesh,
+		uniforms: mesh.material.uniforms
+	};
+}
+//#endregion
 //#region src/3d/clouds/clouds-composite.ts
 /**
 * Volumetric clouds — a raymarched cloud DECK the camera flies through, drawn as
@@ -446,7 +562,12 @@ const CLOUD_KEYS = [
 	"speed",
 	"scale"
 ];
-const SHADOW_KEYS = ["mapSize", "radius"];
+const BLOOM_KEYS = ["threshold", "strength"];
+const SHADOW_KEYS = [
+	"mapSize",
+	"radius",
+	"static"
+];
 const SHADOW_MAP_SIZES = [1024, 2048];
 const DEFAULT_TURBIDITY = 2;
 const DEFAULT_RAYLEIGH = 1;
@@ -462,6 +583,7 @@ function parseEnvironment3D(env) {
 		sky: parseSky(env?.sky),
 		fog: parseFog(env?.fog, env?.sky !== void 0),
 		clouds: parseClouds(env?.clouds),
+		bloom: parseBloom(env?.bloom),
 		shadows: parseShadows(env?.shadows)
 	};
 }
@@ -616,12 +738,30 @@ function parseClouds(value) {
 		scale
 	};
 }
+function parseBloom(value) {
+	if (value === void 0) return null;
+	if (typeof value !== "object" || value === null || Array.isArray(value)) throw new IncantoError("BAD_FORMAT", `environment.bloom must be an object ({ threshold?, strength? }), got ${JSON.stringify(value)}.`, { prop: "bloom" });
+	const b = value;
+	for (const key of Object.keys(b)) if (!BLOOM_KEYS.includes(key)) throw new IncantoError("BAD_FORMAT", `environment.bloom has unknown key '${key}'. Valid keys: [${BLOOM_KEYS.join(", ")}].`, {
+		prop: "bloom",
+		validOptions: BLOOM_KEYS
+	});
+	const threshold = numberOr(b.threshold, 1, "bloom.threshold");
+	if (threshold < 0 || threshold > 8) throw new IncantoError("BAD_FORMAT", `environment.bloom.threshold must be in [0, 8] (linear-HDR luminance; 1 = white), got ${threshold}.`, { prop: "bloom" });
+	const strength = numberOr(b.strength, .8, "bloom.strength");
+	if (strength < 0) throw new IncantoError("BAD_FORMAT", `environment.bloom.strength must be >= 0, got ${strength}.`, { prop: "bloom" });
+	return {
+		threshold,
+		strength
+	};
+}
 function parseShadows(value) {
 	if (value === void 0) return null;
 	if (value === false) return false;
 	if (value === true) return {
 		mapSize: 2048,
-		radius: 1
+		radius: 1,
+		static: false
 	};
 	if (typeof value !== "object" || value === null || Array.isArray(value)) throw new IncantoError("BAD_FORMAT", `environment.shadows must be true, false or an object ({ mapSize?, radius? }), got ${JSON.stringify(value)}.`, { prop: "shadows" });
 	const shadows = value;
@@ -636,9 +776,12 @@ function parseShadows(value) {
 	});
 	const radius = numberOr(shadows.radius, 1, "shadows.radius");
 	if (radius < 0) throw new IncantoError("BAD_FORMAT", `environment.shadows.radius must be >= 0, got ${radius}.`, { prop: "shadows" });
+	const staticShadows = shadows.static === void 0 ? false : shadows.static;
+	if (typeof staticShadows !== "boolean") throw new IncantoError("BAD_FORMAT", `environment.shadows.static must be a boolean, got ${JSON.stringify(shadows.static)}.`, { prop: "shadows" });
 	return {
 		mapSize,
-		radius
+		radius,
+		static: staticShadows
 	};
 }
 function numberOr(value, fallback, at) {
@@ -730,6 +873,10 @@ var Environment3D = class {
 	get clouds() {
 		return this.config.clouds;
 	}
+	/** Parsed bloom config, or null when no bloom pass is declared. */
+	get bloom() {
+		return this.config.bloom;
+	}
 	/** The live scene fog (color/near/far) the cloud composite fades into, or null. */
 	get sceneFog() {
 		return this.scene.fog instanceof Fog ? this.scene.fog : null;
@@ -748,6 +895,12 @@ var Environment3D = class {
 		if (gl) {
 			gl.toneMappingExposure = cfg.exposure;
 			gl.shadowMap.enabled = cfg.shadows !== false;
+			if (cfg.shadows !== false && cfg.shadows !== null && cfg.shadows.static) {
+				if (gl.shadowMap.autoUpdate) {
+					gl.shadowMap.autoUpdate = false;
+					gl.shadowMap.needsUpdate = true;
+				}
+			} else if (!gl.shadowMap.autoUpdate) gl.shadowMap.autoUpdate = true;
 		}
 		this.applyHdri(env);
 		this.applySky(cfg.sky, gl);
@@ -942,7 +1095,8 @@ function createSyncScratch() {
 			assets: void 0,
 			sunDirection: null,
 			sunLight: null,
-			alpha: 1
+			alpha: 1,
+			ignoreStatic: false
 		}
 	};
 }
@@ -966,6 +1120,7 @@ function syncTree(root, threeScene, assets, opts, scratch) {
 	const state = s.state;
 	state.assets = assets;
 	state.sunDirection = opts?.sunDirection ?? null;
+	state.ignoreStatic = opts?.ignoreStatic === true;
 	state.sunLight = null;
 	state.alpha = opts?.alpha ?? 1;
 	walk(root, threeScene, state);
@@ -1037,6 +1192,11 @@ function walk(node, parentObj, state) {
 	let nextParent = parentObj;
 	if (node instanceof Node3D) {
 		const obj = node._ensureObject3D();
+		if (node.static && !state.ignoreStatic && obj.userData.incantoStaticSynced === true) {
+			obj.userData.incantoStatic = true;
+			state.visited.add(obj);
+			return;
+		}
 		if (obj.parent !== parentObj) parentObj.add(obj);
 		node._syncObject3D(state.alpha);
 		if (state.assets && node instanceof ModelInstance3D) node._syncModel(state.assets);
@@ -1056,13 +1216,37 @@ function walk(node, parentObj, state) {
 		parent: nextParent
 	});
 	for (const child of node.children) walk(child, nextParent, state);
+	if (node instanceof Node3D) {
+		const obj = node._ensureObject3D();
+		if (node.static && !state.ignoreStatic) {
+			obj.userData.incantoStaticSynced = true;
+			obj.userData.incantoStatic = true;
+			warnStaticHazards(node);
+		} else if (obj.userData.incantoStaticSynced === true) {
+			obj.userData.incantoStaticSynced = false;
+			obj.userData.incantoStatic = false;
+		}
+	}
+}
+const warnedStatic = /* @__PURE__ */ new WeakSet();
+/** One-time warning when animated machinery is frozen under a static root. */
+function warnStaticHazards(root) {
+	if (warnedStatic.has(root)) return;
+	warnedStatic.add(root);
+	const hazards = [];
+	const scan = (n) => {
+		if (typeof n._onRender3D === "function" || n instanceof Camera3D) hazards.push(`${n.name} (${n.constructor.typeName ?? "?"})`);
+		for (const c of n.children) scan(c);
+	};
+	scan(root);
+	if (hazards.length > 0) console.warn(`[incanto] static subtree '${root.name}' freezes animated/per-frame nodes: ${hazards.join(", ")} — they will stop updating. Unmark static or move them out.`);
 }
 function prune(obj, visited) {
 	const ch = obj.children;
 	for (let i = ch.length - 1; i >= 0; i--) {
 		const child = ch[i];
 		if (child.userData.incantoNode && !visited.has(child)) obj.remove(child);
-		else prune(child, visited);
+		else if (child.userData.incantoStatic !== true) prune(child, visited);
 	}
 }
 //#endregion
@@ -1209,6 +1393,8 @@ var Renderer3D = class {
 	compiledScene = null;
 	/** Reused per-frame walk scratch (instance-scoped — never a module global). */
 	syncScratch = createSyncScratch();
+	/** Editors set this: keep syncing `static: true` subtrees every frame. */
+	ignoreStatic = false;
 	/** Reused render-hook context — gl/scene are stable, camera reassigned/frame. */
 	renderCtx = null;
 	/** Underwater caustics pass (lazy — only created the first time submerged). */
@@ -1228,6 +1414,15 @@ var Renderer3D = class {
 	cloudsBlurUniforms = null;
 	cloudsCompositeScene = null;
 	cloudsCompositeUniforms = null;
+	bloomTarget = null;
+	bloomBrightTarget = null;
+	bloomBlurTarget = null;
+	bloomBrightScene = null;
+	bloomBrightUniforms = null;
+	bloomBlurScene = null;
+	bloomBlurUniforms = null;
+	bloomCompositeScene = null;
+	bloomCompositeUniforms = null;
 	constructor(opts) {
 		this.canvas = opts.canvas;
 		this.engine = opts.engine;
@@ -1277,7 +1472,8 @@ var Renderer3D = class {
 		this.environment.apply(scene.environment, this.webgl);
 		const { activeCamera: sceneCamera, renderHooks, sunLight } = syncTree(scene.root, this.threeScene, this.assets, {
 			sunDirection: this.environment.sunDirection,
-			alpha: this.engine.interpolationAlpha
+			alpha: this.engine.interpolationAlpha,
+			ignoreStatic: this.ignoreStatic
 		}, this.syncScratch);
 		let activeCamera = sceneCamera;
 		if (this.viewOverride) {
@@ -1334,11 +1530,80 @@ var Renderer3D = class {
 		}
 		this.environment.applyUnderwater(underwater);
 		const clouds = this.environment.clouds;
+		const bloom = this.environment.bloom;
 		if (underwater?.caustics.enabled) this.renderWithCaustics(activeCamera, underwater);
 		else if (clouds && !underwater) this.renderWithClouds(activeCamera, clouds, threeLight);
+		else if (bloom && !underwater) this.renderWithBloom(activeCamera, bloom);
 		else this.webgl.render(this.threeScene, activeCamera);
 	}
 	/**
+	* Bloom post pass (only when `environment.bloom` is declared). LDR and safe:
+	*   1. scene → full-res offscreen (tone-mapped exactly like direct output)
+	*   2. bright-pass at HALF res (keep pixels above threshold)
+	*   3. separable Gaussian blur (H, V) at half res
+	*   4. composite scene + glow×strength → screen (pure ADD — never re-touches
+	*      the scene's tone; the clouds pipeline taught us that lesson)
+	* Caustics/clouds paths take precedence (composite pipelines don't stack yet).
+	*/
+	renderWithBloom(camera, bloom) {
+		const buf = this.webgl.getDrawingBufferSize(sizeScratch);
+		const w = Math.max(1, buf.x);
+		const h = Math.max(1, buf.y);
+		const hw = Math.max(1, Math.ceil(w / 2));
+		const hh = Math.max(1, Math.ceil(h / 2));
+		if (this.bloomTarget && (this.bloomTarget.width !== w || this.bloomTarget.height !== h)) {
+			this.bloomTarget.dispose();
+			this.bloomTarget = null;
+			this.bloomBrightTarget?.dispose();
+			this.bloomBrightTarget = null;
+			this.bloomBlurTarget?.dispose();
+			this.bloomBlurTarget = null;
+		}
+		if (!this.bloomTarget) {
+			this.bloomTarget = new WebGLRenderTarget(w, h, { type: HalfFloatType });
+			this.bloomBrightTarget = new WebGLRenderTarget(hw, hh, { type: HalfFloatType });
+			this.bloomBlurTarget = new WebGLRenderTarget(hw, hh, { type: HalfFloatType });
+		}
+		if (!this.bloomBrightScene) {
+			const bright = createBloomBrightQuad();
+			this.bloomBrightScene = new Scene();
+			this.bloomBrightScene.add(bright.mesh);
+			this.bloomBrightUniforms = bright.uniforms;
+			const blur = createBloomBlurQuad();
+			this.bloomBlurScene = new Scene();
+			this.bloomBlurScene.add(blur.mesh);
+			this.bloomBlurUniforms = blur.uniforms;
+			const composite = createBloomCompositeQuad();
+			this.bloomCompositeScene = new Scene();
+			this.bloomCompositeScene.add(composite.mesh);
+			this.bloomCompositeUniforms = composite.uniforms;
+		}
+		const brightTarget = this.bloomBrightTarget;
+		const blurTarget = this.bloomBlurTarget;
+		this.webgl.setRenderTarget(this.bloomTarget);
+		this.webgl.render(this.threeScene, camera);
+		const bu = this.bloomBrightUniforms;
+		bu.tScene.value = this.bloomTarget.texture;
+		bu.uThreshold.value = bloom.threshold;
+		this.webgl.setRenderTarget(brightTarget);
+		this.webgl.render(this.bloomBrightScene, camera);
+		const blu = this.bloomBlurUniforms;
+		blu.tTex.value = brightTarget.texture;
+		blu.uDir.value.set(1 / hw, 0);
+		this.webgl.setRenderTarget(blurTarget);
+		this.webgl.render(this.bloomBlurScene, camera);
+		blu.tTex.value = blurTarget.texture;
+		blu.uDir.value.set(0, 1 / hh);
+		this.webgl.setRenderTarget(brightTarget);
+		this.webgl.render(this.bloomBlurScene, camera);
+		const cu = this.bloomCompositeUniforms;
+		cu.tScene.value = this.bloomTarget.texture;
+		cu.tBloom.value = brightTarget.texture;
+		cu.uStrength.value = bloom.strength;
+		this.webgl.setRenderTarget(null);
+		this.webgl.render(this.bloomCompositeScene, camera);
+	}
+	/**
 	* Volumetric cloud pass (only when `environment.clouds` is declared — scenes
 	* without it render exactly as before, zero cost). Three steps:
 	*   1. scene → full-res offscreen target (color + depth)
@@ -1546,6 +1811,13 @@ var Renderer3D = class {
 			forward: new Vector3(0, 0, -1).applyQuaternion(q)
 		};
 	}
+	/**
+	* Re-render the shadow pass once (static-shadow scenes,
+	* `environment.shadows.static: true`) after a one-off world edit.
+	*/
+	refreshShadows() {
+		this.webgl.shadowMap.needsUpdate = true;
+	}
 	dispose() {
 		this.disconnect();
 		this.threeScene.traverse((obj) => {
@@ -1564,10 +1836,16 @@ var Renderer3D = class {
 		this.cloudsTarget?.dispose();
 		this.cloudsHalfTarget?.dispose();
 		this.cloudsBlurTarget?.dispose();
+		this.bloomTarget?.dispose();
+		this.bloomBrightTarget?.dispose();
+		this.bloomBlurTarget?.dispose();
 		for (const s of [
 			this.cloudsScene,
 			this.cloudsBlurScene,
-			this.cloudsCompositeScene
+			this.cloudsCompositeScene,
+			this.bloomBrightScene,
+			this.bloomBlurScene,
+			this.bloomCompositeScene
 		]) {
 			const m = s?.children[0];
 			m?.geometry?.dispose();

package/dist/debug.d.ts

@@ -1,4 +1,4 @@
-import { C as RendererStats, k as LogLevel, v as Engine } from "./behavior-BAQq7HGM.js";
+import { C as RendererStats, k as LogLevel, v as Engine } from "./behavior-CWhW3oa6.js";
 
 //#region src/debug/panel.d.ts
 /** Minimal document surface the overlay needs (injectable for tests). */

package/dist/{duplicate-DP2WPYom.js → duplicate-BEvGBtb_.js}

@@ -1,4 +1,4 @@
-import { i as serializeNode, t as buildNodeJson } from "./loader-CGs_G-r0.js";
+import { i as serializeNode, t as buildNodeJson } from "./loader-B4OEXDZ8.js";
 //#region src/core/scene/duplicate.ts
 function stripUids(json) {
 	const { uid: _uid, ...rest } = json;