rayzee 8.3.0 → 8.4.1

package/README.md

@@ -287,6 +287,11 @@ configureAssets({
   oidnWeightsBaseUrl:    '/oidn-tzas/',
   upscalerModelBaseUrl:  '/upscaler-onnx/',
 
+  // DLSS. The runtime is a plain script the host must serve — it installs
+  // `globalThis.DLSSRuntime` as a side effect and cannot be imported.
+  dlssRuntimeUrl:    '/dlss/dlss-runtime.js',
+  dlssAssetBaseUrl:  '/dlss/',
+
   // Prefix for engine-managed IndexedDB stores. Set to a unique value if multiple
   // apps embed the engine on the same origin to avoid cache collisions.
   cacheNamespace: 'my-app',
@@ -504,7 +509,11 @@ engine.lightManager.sync()                  // Re-upload light data to GPU
 engine.lightManager.showHelpers(true)       // Toggle visual helpers
 ```
 
-Light `intensity` follows Blender: radiant power in watts for point, spot and area lights, irradiance in W/m² for directional. Dividing power by area only means something in metres, so the engine assumes **one world unit is one metre**; scenes authored in cm or mm must carry that scale in their node transforms, as glTF exporters do. glTF `RectAreaLightPlaceholder` nodes author `intensity` as three.js radiance (their `power` field is `intensity · width · height · π`); the importer converts it to power through the light's world area so the authored radiance is reproduced exactly, then applies the profile's `areaLightIntensityScale`.
+Every light in the scene graph is a **valid three.js light**: it carries the quantity three.js expects for its type, in radiometric (watt-based) units — W/sr for point and spot, W/m² for directional, radiance for area, with `width`/`height` in world metres at unit scale. three.js' own shading maths is unit-agnostic, so the raster fallback, the light helpers and any host reading `sceneModel` are all correct without knowing anything about the path tracer. The rule lives in one module, `LightUnits.js`.
+
+The **Lights panel edits Blender-style Power** — watts for point, spot and area, W/m² for the Sun — which is a view of that, converted by `lightPower()`/`setLightPower()` and nowhere else; `LightSerializer` converts the other way when it fills the GPU buffer. Dividing power by area only means something in metres, so the engine assumes **one world unit is one metre**; scenes authored in cm or mm must carry that scale in their node transforms, as glTF exporters do.
+
+glTF punctual lights are photometric (candela, lux) and are divided by 683 lm/W on import, exactly as Blender's own glTF importer does. glTF `RectAreaLightPlaceholder` nodes author `intensity` as three.js radiance, which is already the stored quantity, so it is used verbatim. The record's own `power` field is ignored: it is written from the light's unscaled dimensions and disagrees with the world area whenever an ancestor scale is non-uniform.
 
 ### engine.animationManager
 
@@ -588,8 +597,10 @@ engine.denoisingManager.setOIDNQuality('high')
 engine.denoisingManager.setStrategy('oidn')              // OIDN owns the live view; see below
 engine.denoisingManager.continuousDenoiseInterval = 250   // cap refreshes at 4/sec (default 8 = uncapped)
 engine.denoisingManager.setUpscalerEnabled(true)
-engine.denoisingManager.setUpscalerScaleFactor(2)
-engine.denoisingManager.setUpscalerQuality('high')
+engine.denoisingManager.setUpscalerBackend('dlss')        // 'esrgan' (default) | 'dlss'
+engine.denoisingManager.setUpscalerScaleFactor(2)         // ESRGAN only; DLSS is fixed at 2x
+engine.denoisingManager.setUpscalerQuality('high')        // ESRGAN only
+engine.denoisingManager.setNeuralRendering(true, { intensity: 1, colorStrength: 0 })
 ```
 
 ### engine.interactionManager
@@ -1197,6 +1208,51 @@ engine.addEventListener(EngineEvents.UPSCALING_END,      () => console.log('Upsc
 
 **Chaining with OIDN:** Upscaling and OIDN **can** run together — on render completion, OIDN runs first, then its denoised output is fed into the upscaler. Enable both; no manual coordination required.
 
+### The DLSS passes
+
+Two further neural passes, ported from NVIDIA's DLSS weights. Both run once when a render finishes
+and both need a denoised frame — on raw Monte-Carlo noise they measurably lose to a plain resize, so
+enable OIDN alongside them.
+
+Unlike the ONNX upscaler these are **not fetched from a CDN**: `dlss-runtime.js` installs
+`globalThis.DLSSRuntime` as a side effect and cannot be imported, so the host serves it and points
+`configureAssets` at it (see above). It lives at `app/public/dlss/` in this repo, and the local edits
+it carries are written up in `app/public/dlss/PATCHES.md` — re-vendoring it without re-applying them
+breaks the retouch pass with an explanatory throw.
+
+```js
+// Super resolution, as a second AI Upscaler backend
+engine.denoisingManager.setUpscalerEnabled(true);
+engine.denoisingManager.setUpscalerBackend('dlss');
+
+// The retouch pass — appearance, not resolution. Independent of the upscaler.
+engine.denoisingManager.setNeuralRendering(true, {
+  intensity: 1,        // 0..1   how much of the pass reaches the image
+  localTone: 1,        // 0..2   local light shaping; 1 is neutral
+  localStructure: 1,   // 0..2   fine surface detail; 1 is neutral
+  colorStrength: 0,    // 0..1   0 keeps the render's chroma, 1 takes the model's
+});
+```
+
+The chain is **denoise → retouch (at render size) → super resolution (2x) → tone map**, scene-referred
+throughout. The retouch pass runs *before* the upscale deliberately: it sees a quarter of the pixels
+there, and above `DLSS_NR_MAX_PIXELS` (4.19 MP) it takes minutes and then loses every GPU device in
+the page. `DenoisingManager` skips it above that size rather than letting it run.
+
+| | Super resolution | Retouch |
+|---|---|---|
+| What it changes | Resolution, fixed 2x | Appearance only |
+| Weights | 3.2 MB | 141 MB, fetched on first use |
+| Cost (1.9M-tri interior, warm) | 260 ms at 1024²→2048², 947 ms at 2048²→4096² | ~6 s at 2048² |
+| Against a native render | Ties Real-ESRGAN on accuracy, 3x faster, sharper than native | Close to a no-op on path-traced images |
+
+Exported for building UI against: `SR_SCALE`, `SR_MAX_INPUT`, `DLSS_NR_DEFAULTS`, `DLSS_NR_RANGES`,
+`DLSS_NR_MAX_PIXELS`, and `renderUpscaled( app, { outputWidth, outputHeight, samples } )` — the
+offline entry point that drives a half-size render, denoise and upscale in one call.
+
+⚠️ Each model brings **its own `GPUDevice`**, built by the runtime and not shareable. With both on,
+the page holds three: the renderer's and one each.
+
 ## Troubleshooting
 
 **OIDN: `Cannot find module './tza'` (webpack)**

package/dist/DLSSNeural-BNSJ8V3z.js

@@ -0,0 +1,202 @@
+import { t as e } from "./rolldown-runtime-CAFD8bLK.js";
+import { o as t, r as n, t as r } from "./ToneMapGPU-DzqSyzTx.js";
+//#region src/dlss/DLSSNeural.js
+var i = /* @__PURE__ */ e({
+	DLSSNeural: () => m,
+	DLSS_NR_COLOR_STRENGTH: () => 0,
+	DLSS_NR_DEFAULTS: () => a,
+	DLSS_NR_MAX_PIXELS: () => c,
+	DLSS_NR_RANGES: () => l,
+	enhanceFrame: () => g
+}), a = Object.freeze({
+	enabled: !0,
+	intensity: 1,
+	localTone: 1,
+	localStructure: 1,
+	skinStructure: -1,
+	autoMask: !0,
+	style: 0,
+	preset: 0,
+	uiCorrection: !1
+});
+function o(e = {}) {
+	let { colorStrength: t = 0, ...n } = e;
+	return {
+		runtime: {
+			...a,
+			...n
+		},
+		colorStrength: t
+	};
+}
+var s = t("dlss"), c = 2048 * 2048, l = Object.freeze({
+	intensity: [0, 1],
+	localTone: [0, 2],
+	localStructure: [0, 2],
+	skinStructure: [-1, 2],
+	style: [0, 2],
+	preset: [0, 3]
+}), u = null;
+function d() {
+	if (u) return u;
+	let { dlssRuntimeUrl: e, dlssAssetBaseUrl: t } = n();
+	return globalThis.__DLSS5_ASSET_BASE__ = t, u = new Promise((t, n) => {
+		if (globalThis.DLSSRuntime?.getSrNrChain) return t(globalThis.DLSSRuntime.getSrNrChain());
+		let r = document.createElement("script");
+		r.src = e, r.onload = () => {
+			let e = globalThis.DLSSRuntime?.getSrNrChain;
+			if (!e) return n(/* @__PURE__ */ Error("DLSS runtime loaded but exposed no neural-rendering entry"));
+			t(e());
+		}, r.onerror = () => n(/* @__PURE__ */ Error(`Failed to load the DLSS runtime from ${e}`)), document.head.appendChild(r);
+	}), u;
+}
+var f = "\n@group(0) @binding(0) var src: texture_2d<f32>;\n@group(0) @binding(1) var<storage, read_write> dst: array<u32>;\n\n@compute @workgroup_size(8, 8)\nfn main(@builtin(global_invocation_id) gid: vec3<u32>) {\n	let size = textureDimensions(src);\n	if ( gid.x >= size.x || gid.y >= size.y ) { return; }\n	let c = textureLoad(src, vec2<i32>(gid.xy), 0);\n	let r = u32(clamp(c.r, 0.0, 1.0) * 255.0 + 0.5);\n	let g = u32(clamp(c.g, 0.0, 1.0) * 255.0 + 0.5);\n	let b = u32(clamp(c.b, 0.0, 1.0) * 255.0 + 0.5);\n	dst[gid.y * size.x + gid.x] = r | (g << 8u) | (b << 16u) | (255u << 24u);\n}\n", p = "\n@group(0) @binding(0) var src: texture_2d<f32>;\n@group(0) @binding(1) var<storage, read_write> dst: array<u32>;\n\n@compute @workgroup_size(8, 8)\nfn main(@builtin(global_invocation_id) gid: vec3<u32>) {\n	let size = textureDimensions(src);\n	if ( gid.x >= size.x || gid.y >= size.y ) { return; }\n	let c = textureLoad(src, vec2<i32>(gid.xy), 0);\n	let a = (gid.y * size.x + gid.x) * 2u;\n	dst[a] = pack2x16float(c.rg);\n	dst[a + 1u] = pack2x16float(vec2<f32>(c.b, 1.0));\n}\n", m = class e {
+	constructor(e, t) {
+		this.chain = e, this.canvas = t, this.slot = 0, this.source = null, this.staging = null, this._readbackPipeline = null, this._readbackStorage = null, this._readbackMap = null, this._hdrPipeline = null, this._hdrStorage = null, this._hdrMap = null, this._toneMapper = null, this.disposed = !1;
+	}
+	get device() {
+		return this.chain.device;
+	}
+	get width() {
+		return this.chain.pipeline.geometry.validWidth;
+	}
+	get height() {
+		return this.chain.pipeline.geometry.validHeight;
+	}
+	static async create({ width: t, height: n, canvas: r = null, settings: i = {}, onProgress: a = () => {} }) {
+		if (!Number.isInteger(t) || !Number.isInteger(n) || t < 1 || n < 1) throw Error("DLSSNeural.create: width and height must be positive integers");
+		if (t * n > 4194304) throw Error(`DLSSNeural.create: ${t}x${n} is ${(t * n / 1e6).toFixed(1)} MP, above the ${(c / 1e6).toFixed(1)} MP this pass survives. Past it the run takes minutes and then loses every GPU device in the page.`);
+		let s = r ?? document.createElement("canvas");
+		r || (s.style.cssText = "position:fixed;left:-10000px;top:0;pointer-events:none");
+		let l = new e(await (await d()).create(s, t, n, a, o(i).runtime), s);
+		return l._allocate(), l;
+	}
+	_allocate() {
+		let { validWidth: e, validHeight: t } = this.chain.pipeline.geometry;
+		this.source = this.device.createBuffer({
+			label: "rayzee:dlss-nr-source",
+			size: e * t * 8,
+			usage: GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_DST
+		}), this.staging = new Uint16Array(e * t * 4);
+		let n = e * t * 4;
+		this._readbackStorage = this.device.createBuffer({
+			label: "rayzee:dlss-nr-readback",
+			size: n,
+			usage: GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_SRC
+		}), this._readbackMap = this.device.createBuffer({
+			label: "rayzee:dlss-nr-readback-map",
+			size: n,
+			usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ
+		}), this._readbackPipeline = this.device.createComputePipeline({
+			label: "rayzee:dlss-nr-readback",
+			layout: "auto",
+			compute: {
+				module: this.device.createShaderModule({ code: f }),
+				entryPoint: "main"
+			}
+		});
+		let r = e * t * 8;
+		this._hdrStorage = this.device.createBuffer({
+			label: "rayzee:dlss-nr-hdr",
+			size: r,
+			usage: GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_SRC
+		}), this._hdrMap = this.device.createBuffer({
+			label: "rayzee:dlss-nr-hdr-map",
+			size: r,
+			usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ
+		}), this._hdrPipeline = this.device.createComputePipeline({
+			label: "rayzee:dlss-nr-hdr",
+			layout: "auto",
+			compute: {
+				module: this.device.createShaderModule({ code: p }),
+				entryPoint: "main"
+			}
+		});
+	}
+	async _packHDR(e, t, n = !1) {
+		let r = this.chain.pipeline.slots[this.slot]?.hdrOutput;
+		if (!r) throw Error("DLSSNeural: the runtime has no scene-referred output. Either no frame has been produced yet, or dlss-runtime.js was re-vendored without the patch described in its PATCHES.md.");
+		let i = this.device.createBindGroup({
+			layout: this._hdrPipeline.getBindGroupLayout(0),
+			entries: [{
+				binding: 0,
+				resource: r.createView()
+			}, {
+				binding: 1,
+				resource: { buffer: this._hdrStorage }
+			}]
+		}), a = this.device.createCommandEncoder({ label: "rayzee:dlss-nr-hdr" }), o = a.beginComputePass();
+		o.setPipeline(this._hdrPipeline), o.setBindGroup(0, i), o.dispatchWorkgroups(Math.ceil(e / 8), Math.ceil(t / 8)), o.end(), n && a.copyBufferToBuffer(this._hdrStorage, 0, this._hdrMap, 0, e * t * 8), this.device.queue.submit([a.finish()]);
+	}
+	async readOutputHDR() {
+		let { validWidth: e, validHeight: t } = this.chain.pipeline.geometry;
+		await this._packHDR(e, t, !0), await this._hdrMap.mapAsync(GPUMapMode.READ);
+		let n = new Uint16Array(this._hdrMap.getMappedRange().slice(0));
+		return this._hdrMap.unmap(), {
+			half: n,
+			width: e,
+			height: t
+		};
+	}
+	async readOutputToned(e) {
+		let { validWidth: t, validHeight: n } = this.chain.pipeline.geometry;
+		return await this._packHDR(t, n), this._toneMapper ??= new r(this.device, "rayzee:dlss-nr-tonemap"), this._toneMapper.ensureSize(t, n), {
+			rgba8: await this._toneMapper.toRGBA8(this._hdrStorage, {
+				exposure: e.exposure ?? 1,
+				toneMapping: e.toneMapping ?? 0,
+				saturation: e.saturation ?? 1
+			}),
+			width: t,
+			height: n
+		};
+	}
+	async readOutput() {
+		let { validWidth: e, validHeight: t } = this.chain.pipeline.geometry, n = this.chain.pipeline.slots[this.slot]?.output;
+		if (!n) throw Error("DLSSNeural.readOutput: the pass has not produced a frame yet");
+		let r = this.device.createBindGroup({
+			layout: this._readbackPipeline.getBindGroupLayout(0),
+			entries: [{
+				binding: 0,
+				resource: n.createView()
+			}, {
+				binding: 1,
+				resource: { buffer: this._readbackStorage }
+			}]
+		}), i = this.device.createCommandEncoder({ label: "rayzee:dlss-nr-readback" }), a = i.beginComputePass();
+		a.setPipeline(this._readbackPipeline), a.setBindGroup(0, r), a.dispatchWorkgroups(Math.ceil(e / 8), Math.ceil(t / 8)), a.end(), i.copyBufferToBuffer(this._readbackStorage, 0, this._readbackMap, 0, e * t * 4), this.device.queue.submit([i.finish()]), await this._readbackMap.mapAsync(GPUMapMode.READ);
+		let o = new Uint8ClampedArray(this._readbackMap.getMappedRange().slice(0));
+		return this._readbackMap.unmap(), o;
+	}
+	dispose() {
+		if (!this.disposed) {
+			this.disposed = !0, this.source?.destroy(), this._readbackStorage?.destroy(), this._readbackMap?.destroy(), this._hdrStorage?.destroy(), this._hdrMap?.destroy(), this._toneMapper?.dispose();
+			try {
+				this.chain.destroy();
+			} catch (e) {
+				s.warn("retouch teardown:", e);
+			}
+		}
+	}
+}, h = 20;
+async function g({ source: e, settings: t = {}, instance: n = null, exposure: r = 1, tone: i = null, onProgress: a = () => {} }) {
+	let s = n;
+	s && (s.width !== e.width || s.height !== e.height) && (s.dispose(), s = null), s ||= await m.create({
+		width: e.width,
+		height: e.height,
+		settings: t,
+		onProgress: a
+	});
+	let { runtime: c, colorStrength: l } = o(t), u = s.staging;
+	if (!e.half || e.half.length !== u.length) throw Error(`DLSSNeural: expected ${u.length} packed halfs, got ${e.half?.length}`);
+	u.set(e.half), s.device.queue.writeBuffer(s.source, 0, u), s.chain.pipeline.paperWhite = 1 / Math.min(Math.max(r, 1 / h), h), s.chain.pipeline.colorStrength = l;
+	let d = performance.now(), f = s.device.createCommandEncoder({ label: "rayzee:dlss-nr" });
+	await s.chain.encode(f, s.slot, { buffer: s.source }, c, () => {}, { reset: !0 }), s.device.queue.submit([f.finish()]), await s.device.queue.onSubmittedWorkDone();
+	let p = i ? await s.readOutputToned(i) : await s.readOutputHDR();
+	return {
+		instance: s,
+		...p,
+		ms: performance.now() - d
+	};
+}
+//#endregion
+export { l as i, a as n, c as r, i as t };

package/dist/DLSSSuperRes-BoEW89Cl.js

@@ -0,0 +1,266 @@
+import { t as e } from "./rolldown-runtime-CAFD8bLK.js";
+import { o as t, r as n, t as r } from "./ToneMapGPU-DzqSyzTx.js";
+//#region src/EngineEvents.js
+var i = {
+	RENDER_COMPLETE: "engine:renderComplete",
+	RENDER_RESET: "engine:renderReset",
+	FRAME: "engine:frame",
+	DENOISING_START: "engine:denoisingStart",
+	DENOISING_END: "engine:denoisingEnd",
+	UPSCALING_START: "engine:upscalingStart",
+	UPSCALING_PROGRESS: "engine:upscalingProgress",
+	UPSCALING_END: "engine:upscalingEnd",
+	LOADING_UPDATE: "engine:loadingUpdate",
+	LOADING_RESET: "engine:loadingReset",
+	STATS_UPDATE: "engine:statsUpdate",
+	OBJECT_SELECTED: "engine:objectSelected",
+	OBJECT_DESELECTED: "engine:objectDeselected",
+	OBJECT_DOUBLE_CLICKED: "engine:objectDoubleClicked",
+	SELECT_MODE_CHANGED: "engine:selectModeChanged",
+	OBJECT_TRANSFORM_START: "engine:objectTransformStart",
+	OBJECT_TRANSFORM_END: "engine:objectTransformEnd",
+	TRANSFORM_MODE_CHANGED: "engine:transformModeChanged",
+	AUTO_FOCUS_UPDATED: "engine:autoFocusUpdated",
+	AUTO_EXPOSURE_UPDATED: "engine:autoExposureUpdated",
+	AF_POINT_PLACED: "engine:afPointPlaced",
+	SETTING_CHANGED: "engine:settingChanged",
+	ANIMATION_STARTED: "engine:animationStarted",
+	ANIMATION_PAUSED: "engine:animationPaused",
+	ANIMATION_STOPPED: "engine:animationStopped",
+	ANIMATION_FINISHED: "engine:animationFinished",
+	VIDEO_RENDER_PROGRESS: "engine:videoRenderProgress",
+	VIDEO_RENDER_COMPLETE: "engine:videoRenderComplete",
+	DISPOSE: "engine:dispose",
+	DEVICE_LOST: "engine:deviceLost",
+	ISSUE: "engine:issue",
+	SCENE_METADATA_APPLIED: "engine:sceneMetadataApplied"
+}, a = /* @__PURE__ */ e({
+	DLSSSuperRes: () => g,
+	SR_MAX_INPUT: () => c,
+	SR_SCALE: () => 2,
+	presentRGBA8: () => b,
+	readDenoisedHalf: () => h,
+	releaseDenoisedReader: () => m,
+	renderUpscaled: () => v
+}), o = 2, s = t("dlss"), c = 2048, l = null;
+function u() {
+	if (l) return l;
+	let { dlssRuntimeUrl: e, dlssAssetBaseUrl: t } = n();
+	return globalThis.__DLSS5_ASSET_BASE__ = t, l = new Promise((t, n) => {
+		if (globalThis.DLSSRuntime?.getNativeSR) return t(globalThis.DLSSRuntime.getNativeSR());
+		let r = document.createElement("script");
+		r.src = e, r.onload = () => {
+			let e = globalThis.DLSSRuntime?.getNativeSR;
+			if (!e) return n(/* @__PURE__ */ Error("DLSS runtime loaded but exposed no super-resolution entry"));
+			t(e());
+		}, r.onerror = () => n(/* @__PURE__ */ Error(`Failed to load the DLSS runtime from ${e}`)), document.head.appendChild(r);
+	}), l;
+}
+var d = "\n@group(0) @binding(0) var src: texture_2d<f32>;\n@group(0) @binding(1) var<storage, read_write> dst: array<u32>;\n\n@compute @workgroup_size(8, 8)\nfn main( @builtin(global_invocation_id) gid: vec3<u32> ) {\n	let size = textureDimensions( src );\n	if ( gid.x >= size.x || gid.y >= size.y ) { return; }\n	let c = textureLoad( src, vec2<i32>( gid.xy ), 0 ).rgb;\n	let a = ( gid.y * size.x + gid.x ) * 2u;\n	dst[ a ] = pack2x16float( c.rg );\n	dst[ a + 1u ] = pack2x16float( vec2<f32>( c.b, 1.0 ) );\n}\n", f = null;
+function p(e, t, n) {
+	if (f && (f.device !== e || f.width !== t || f.height !== n) && m(), f) return f;
+	let r = t * n * 8;
+	return f = {
+		device: e,
+		width: t,
+		height: n,
+		storage: e.createBuffer({
+			label: "rayzee:dlss-sr-pack",
+			size: r,
+			usage: GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_SRC
+		}),
+		map: e.createBuffer({
+			label: "rayzee:dlss-sr-pack-map",
+			size: r,
+			usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ
+		}),
+		pipeline: e.createComputePipeline({
+			label: "rayzee:dlss-sr-pack",
+			layout: "auto",
+			compute: {
+				module: e.createShaderModule({
+					label: "rayzee:dlss-sr-pack",
+					code: d
+				}),
+				entryPoint: "main"
+			}
+		})
+	}, f;
+}
+function m() {
+	f?.storage.destroy(), f?.map.destroy(), f = null;
+}
+async function h(e) {
+	let t = e?._outGPUTexture;
+	if (!t) throw Error("DLSSSuperRes: no denoised frame — enable OIDN and finish a render first");
+	let n = e.gpuDevice, { width: r, height: i } = e._outTexSize, a = p(n, r, i), o = n.createBindGroup({
+		layout: a.pipeline.getBindGroupLayout(0),
+		entries: [{
+			binding: 0,
+			resource: t.createView()
+		}, {
+			binding: 1,
+			resource: { buffer: a.storage }
+		}]
+	}), s = n.createCommandEncoder({ label: "rayzee:dlss-sr-pack" }), c = s.beginComputePass();
+	c.setPipeline(a.pipeline), c.setBindGroup(0, o), c.dispatchWorkgroups(Math.ceil(r / 8), Math.ceil(i / 8)), c.end(), s.copyBufferToBuffer(a.storage, 0, a.map, 0, r * i * 8), n.queue.submit([s.finish()]), await a.map.mapAsync(GPUMapMode.READ);
+	let l = new Uint16Array(a.map.getMappedRange().slice(0));
+	return a.map.unmap(), {
+		half: l,
+		width: r,
+		height: i
+	};
+}
+var g = class e {
+	constructor(e, t) {
+		this.sr = e, this.canvas = t, this.slot = 0, this._color = null, this._depth = null, this._motion = null, this._toneMapper = null, this.disposed = !1;
+	}
+	get geometry() {
+		return this.sr.geometry;
+	}
+	get inputWidth() {
+		return this.sr.geometry.width;
+	}
+	get inputHeight() {
+		return this.sr.geometry.height;
+	}
+	get outputWidth() {
+		return this.sr.geometry.outputWidth;
+	}
+	get outputHeight() {
+		return this.sr.geometry.outputHeight;
+	}
+	static async create({ width: t, height: n, onProgress: r = () => {} } = {}) {
+		if (!Number.isInteger(t) || !Number.isInteger(n) || t < 1 || n < 1) throw Error("DLSSSuperRes.create: width and height must be positive integers");
+		if (t > 2048 || n > 2048) throw Error(`DLSSSuperRes.create: input capped at ${c}px per side (${c * 2}px output), got ${t}x${n}. Above that the runtime's history plane exceeds maxTextureDimension2D and it fails later with an unrelated bind-group error.`);
+		let i = await u(), a = document.createElement("canvas");
+		a.style.cssText = "position:fixed;left:-10000px;top:0;pointer-events:none", document.body.appendChild(a);
+		let o;
+		try {
+			o = await i.create(a, {
+				width: t,
+				height: n,
+				onProgress: r,
+				timestamps: !0,
+				nrSettings: null
+			});
+		} catch (e) {
+			throw a.remove(), e;
+		}
+		let s = new e(o, a);
+		return s._allocate(), s;
+	}
+	_allocate() {
+		let e = this.inputWidth, t = this.inputHeight;
+		this._color = new Uint16Array(e * t * 4), this._depth = new Float32Array(e * t), this._motion = new Uint16Array(e * t * 2);
+	}
+	async _run(e) {
+		if (this.disposed) throw Error("DLSSSuperRes: disposed");
+		let t = this.inputWidth, n = this.inputHeight;
+		if (e.width !== t || e.height !== n) throw Error(`DLSSSuperRes: expected a ${t}x${n} source, got ${e.width}x${e.height}`);
+		let r = this._color;
+		if (!e.half || e.half.length !== r.length) throw Error(`DLSSSuperRes: expected ${r.length} packed halfs from readDenoisedHalf, got ${e.half?.length}`);
+		r.set(e.half), this._depth.fill(.5), this._motion.fill(0);
+		let i = performance.now(), a = await this.sr.render(this.slot, {
+			color: r,
+			depth: this._depth,
+			motion: this._motion,
+			reset: !0,
+			jitter: [0, 0]
+		});
+		return await this.sr.device.queue.onSubmittedWorkDone(), {
+			result: a,
+			ms: performance.now() - i
+		};
+	}
+	async upscaleToRGBA8(e, t = {}) {
+		let { result: n, ms: i } = await this._run(e), { outputWidth: a, outputHeight: o } = this.geometry;
+		this._toneMapper ??= new r(this.sr.device, "rayzee:dlss-sr-tonemap"), this._toneMapper.ensureSize(a, o);
+		let s = performance.now();
+		return {
+			rgba8: await this._toneMapper.toRGBA8(n.hdr.buffer ?? n.hdr, {
+				exposure: t.exposure ?? 1,
+				toneMapping: t.toneMapping ?? 0,
+				saturation: t.saturation ?? 1,
+				flipY: !0
+			}),
+			width: a,
+			height: o,
+			ms: i,
+			toneMs: performance.now() - s
+		};
+	}
+	dispose() {
+		if (!this.disposed) {
+			this.disposed = !0, this._toneMapper?.dispose(), this._toneMapper = null, this.canvas.remove();
+			try {
+				this.sr.destroy();
+			} catch (e) {
+				s.warn("super resolution teardown:", e);
+			}
+		}
+	}
+};
+function _(e, t, n) {
+	return new Promise((r, a) => {
+		let o = !1, s = (t, n) => {
+			o || (o = !0, e.removeEventListener(i.DENOISING_END, l), clearInterval(u), clearTimeout(d), t ? r() : a(n));
+		}, c = !1, l = () => {
+			(e.stages?.pathTracer?.frameCount ?? 0) >= t && (c = !0);
+		};
+		e.addEventListener(i.DENOISING_END, l);
+		let u = setInterval(() => {
+			c && s(!0);
+		}, 200), d = setTimeout(() => s(!1, /* @__PURE__ */ Error("DLSSSuperRes: timed out waiting for the render to finish")), n);
+	});
+}
+async function v(e, { outputWidth: t, outputHeight: n, samples: r = 64, upscaler: i = null, timeoutMs: a = 6e5, present: o = !0, onProgress: s = () => {} } = {}) {
+	if (t % 2 || n % 2) throw Error(`renderUpscaled: output must be divisible by 2, got ${t}x${n}`);
+	let c = t / 2, l = n / 2, u = e.stages?.pathTracer, d = {
+		width: u?.width,
+		height: u?.height,
+		maxSamples: e.settings?.get?.("maxSamples"),
+		finalDenoise: e.denoisingManager?.finalDenoise,
+		paused: e.pauseRendering
+	}, f = !i, p = i, m = {};
+	try {
+		if (!p) {
+			let e = performance.now();
+			s("Loading the super-resolution model"), p = await g.create({
+				width: c,
+				height: l,
+				onProgress: s
+			}), m.load = performance.now() - e;
+		} else if (p.inputWidth !== c || p.inputHeight !== l) throw Error(`renderUpscaled: upscaler is ${p.inputWidth}x${p.inputHeight}, need ${c}x${l}`);
+		let i = performance.now();
+		s(`Tracing ${c}x${l} at ${r} spp`), e.pauseRendering = !1, e.setCanvasSize(c, l), await new Promise((e) => setTimeout(e, 300)), e.denoisingManager.applyOIDNEnabled(!0), e.settings.set("maxSamples", r);
+		let u = _(e, r, a);
+		e.reset(), await u, e.pauseRendering = !0, m.render = performance.now() - i, s("Reading the denoised frame");
+		let d = performance.now(), f = await h(e.denoisingManager?.denoiser);
+		m.read = performance.now() - d, s(`Upscaling to ${t}x${n}`);
+		let v = {
+			exposure: e.renderer.toneMappingExposure,
+			toneMapping: e.renderer.toneMapping,
+			saturation: e.settings.get("saturation") ?? 1
+		}, { rgba8: b, width: x, height: S, ms: C, toneMs: w } = await p.upscaleToRGBA8(f, v);
+		return m.upscale = C, m.tonemap = w, o && y(e.denoisingManager?.upscalerCanvas, b, x, S), {
+			rgba8: b,
+			width: x,
+			height: S,
+			timings: m,
+			upscaler: p
+		};
+	} catch (e) {
+		throw f && p?.dispose(), e;
+	} finally {
+		d.width && d.height && e.setCanvasSize(d.width, d.height), d.maxSamples !== void 0 && e.settings?.set?.("maxSamples", d.maxSamples), d.finalDenoise !== void 0 && e.denoisingManager?.applyOIDNEnabled(d.finalDenoise), e.pauseRendering = d.paused;
+	}
+}
+function y(e, t, n, r) {
+	return e ? (e.width = n, e.height = r, e.getContext("2d").putImageData(new ImageData(new Uint8ClampedArray(t.buffer ?? t), n, r), 0, 0), e.style.display = "block", !0) : !1;
+}
+function b(e, t, n, r) {
+	return y(e, t, n, r);
+}
+//#endregion
+export { i as a, v as i, c as n, o as r, a as t };