rayzee 9.4.1 → 9.5.0

package/dist/sceneCachePolicy-BmwYOYDu.js

@@ -0,0 +1,183 @@
+import { t as e } from "./EngineEvents-Ci8dVWCP.js";
+import { n as t, r as n } from "./shared-BGBcSxBQ.js";
+import { n as r } from "./AssetConfig-DSEntE65.js";
+import "three";
+//#region src/Processor/utils.js
+var i = null;
+function a(e) {
+	i = e;
+}
+var o = () => i?.({ type: e.LOADING_RESET }), s = (t) => {
+	i?.({
+		type: e.LOADING_UPDATE,
+		...t
+	});
+}, c = (t) => {
+	i?.({
+		type: e.STATS_UPDATE,
+		...t
+	});
+};
+function l(e) {
+	return e.frameCount || 0;
+}
+function u(e) {
+	if (Array.isArray(e)) e.forEach((e) => {
+		e.userData && e.userData.isFallback || (d(e), e.dispose());
+	});
+	else {
+		if (e.userData && e.userData.isFallback) return;
+		d(e), e.dispose();
+	}
+}
+function d(e) {
+	e && [
+		"alphaMap",
+		"aoMap",
+		"bumpMap",
+		"clearcoatMap",
+		"clearcoatNormalMap",
+		"clearcoatRoughnessMap",
+		"displacementMap",
+		"emissiveMap",
+		"envMap",
+		"gradientMap",
+		"lightMap",
+		"map",
+		"metalnessMap",
+		"normalMap",
+		"roughnessMap",
+		"specularMap",
+		"sheenColorMap",
+		"sheenRoughnessMap",
+		"specularIntensityMap",
+		"specularColorMap",
+		"thicknessMap",
+		"transmissionMap",
+		"diffuseTransmissionMap",
+		"diffuseTransmissionColorMap"
+	].forEach((t) => {
+		e[t] && (e[t].dispose(), e[t] = null);
+	});
+}
+function f({ material: e, geometry: t, children: n }) {
+	if (e && u(e), t && t.dispose(), n.length > 0) for (let e of n) f(e);
+}
+function p(e) {
+	if (!e) return;
+	e._canvasTarget && e._onCanvasTargetResize && e._canvasTarget.removeEventListener("resize", e._onCanvasTargetResize);
+	let t = e.dispose();
+	return e._canvasTarget = null, t;
+}
+function m(e, t = []) {
+	if (e && !(t.includes(e.name) || e.isScene)) {
+		if (e.isMaterial) {
+			u(e);
+			return;
+		}
+		for (; e.children.length > 0;) for (let t of e.children) m(t);
+		f(e), e.removeFromParent(), e.clear();
+	}
+}
+function h(e) {
+	e?.traverse((e) => {
+		e.geometry?.userData?.__rayzeeOwned && e.geometry.dispose();
+	});
+}
+function g(e, t) {
+	return t;
+}
+function _(e, t = !1) {
+	return t ? 1 : 1 / (e + 1);
+}
+function v() {
+	let e = 0, t = 0, n = 0, r = 0;
+	return {
+		start() {
+			e = performance.now();
+		},
+		end() {
+			t = performance.now();
+			let i = t - e;
+			return r += i, n++, i;
+		},
+		getAverageFrameTime() {
+			return n > 0 ? r / n : 0;
+		},
+		getFPS() {
+			let e = this.getAverageFrameTime();
+			return e > 0 ? 1e3 / e : 0;
+		},
+		reset() {
+			n = 0, r = 0;
+		}
+	};
+}
+//#endregion
+//#region src/Storage/CDFCache.js
+var y = 5;
+function b(e, t) {
+	e && t && (e.userData.__rayzeeSource = t);
+}
+function x(e) {
+	let t = e?.userData?.__rayzeeSource;
+	if (!t) return null;
+	let { width: n = 0, height: r = 0 } = e.image ?? {};
+	return `cdf:${y}:${t}|${n}x${r}|${e.userData.__rayzeeColorSpace ?? "native"}`;
+}
+var S = () => t(r().cacheNamespace)?.area(n.CDF) ?? null, C = [
+	"exactConditional",
+	"exactMarginal",
+	"exactRowGuide",
+	"exactMarginalGuide"
+], w = C.map((e) => `${e}.f32`);
+async function T(e) {
+	let t = x(e), n = t ? await S()?.open(t) : null;
+	if (!n) return null;
+	try {
+		let e = await Promise.all(w.map((e) => n.file(e)));
+		if (e.some((e) => !e)) return null;
+		let t = await Promise.all(e.map(async (e) => new Float32Array(await e.arrayBuffer()))), { totalSum: r, width: i, height: a, exactWidth: o, exactHeight: s, radianceIntegral: c } = n.extra;
+		return {
+			...Object.fromEntries(C.map((e, n) => [e, t[n]])),
+			totalSum: r,
+			width: i,
+			height: a,
+			exactWidth: o,
+			exactHeight: s,
+			radianceIntegral: c
+		};
+	} finally {
+		n.release();
+	}
+}
+async function E(e, t) {
+	let { totalSum: n, width: r, height: i, exactWidth: a, exactHeight: o, radianceIntegral: s } = t, c = C.map((e) => t[e]), l = x(e), u = l ? S() : null;
+	if (!u || c.some((e) => !e)) return !1;
+	let d = await u.create(l, {
+		label: e.name || "environment",
+		expectedBytes: c.reduce((e, t) => e + t.byteLength, 0)
+	});
+	if (!d) return !1;
+	try {
+		for (let e = 0; e < w.length; e++) await d.write(w[e], c[e]);
+		return await d.commit({
+			totalSum: n,
+			width: r,
+			height: i,
+			exactWidth: a,
+			exactHeight: o,
+			radianceIntegral: s
+		}), !0;
+	} catch {
+		return await d.abort(), !1;
+	}
+}
+//#endregion
+//#region src/version.js
+var D = "9.5.0", O = 1e4, k = 15e5;
+function A(e, t, n = O) {
+	return e >= n && t / k < e / 3;
+}
+//#endregion
+export { c as _, E as a, v as c, p as d, l as f, s as g, g as h, T as i, h as l, a as m, A as n, b as o, o as p, D as r, _ as s, O as t, m as u };

package/dist/shared-BGBcSxBQ.js

@@ -0,0 +1,17 @@
+//#region src/Storage/areas.js
+var e = Object.freeze({
+	CACHE: "cache",
+	USER: "user",
+	SCRATCH: "scratch"
+}), t = Object.freeze({
+	DOWNLOADS: "downloads",
+	ARCHIVES: "archives",
+	SCENES: "scenes",
+	CDF: "cdf",
+	SPILL: "spill"
+}), n = /* @__PURE__ */ new Map();
+function r(e) {
+	return n.get(e)?.storage ?? null;
+}
+//#endregion
+export { e as i, r as n, t as r, n as t };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rayzee",
-  "version": "9.4.1",
+  "version": "9.5.0",
   "type": "module",
   "description": "Real-time WebGPU path tracing engine built on Three.js",
   "main": "dist/rayzee.umd.js",
@@ -10,6 +10,27 @@
       "import": "./dist/rayzee.es.js",
       "require": "./dist/rayzee.umd.js"
     },
+    "./core": {
+      "import": "./dist/rayzee-core.es.js"
+    },
+    "./addons/physical-sky": {
+      "import": "./dist/addons/physical-sky.es.js"
+    },
+    "./addons/archives": {
+      "import": "./dist/addons/archives.es.js"
+    },
+    "./addons/bidirectional": {
+      "import": "./dist/addons/bidirectional.es.js"
+    },
+    "./addons/color": {
+      "import": "./dist/addons/color.es.js"
+    },
+    "./addons/storage": {
+      "import": "./dist/addons/storage.es.js"
+    },
+    "./addons/formats": {
+      "import": "./dist/addons/formats.es.js"
+    },
     "./node": "./src/node/index.js"
   },
   "files": [
@@ -32,7 +53,7 @@
   "author": "Atul Mourya",
   "license": "MIT",
   "scripts": {
-    "build": "vite build",
+    "build": "vite build && RAYZEE_FORMAT=umd vite build",
     "prepublishOnly": "npm run build"
   },
   "peerDependencies": {

package/src/Color/ActiveColor.js

@@ -0,0 +1,34 @@
+/**
+ * The colour management the engine reads — `BasicColor` in the renderer core, the OCIO `ColorManagement` once a host
+ * installs it (rayzee/addons/color). A config, a working space and a set of view transforms are process-wide — there
+ * is one OCIO runtime and one set of baked tables — so code far from the app (texture processing, the environment)
+ * asks for the active instance rather than having one threaded through six constructors.
+ */
+
+/** What the engine renders in when no config has been adopted. */
+export const DEFAULT_WORKING_SPACE = 'Linear Rec.709 (sRGB)';
+
+let active = null;
+
+/** The colour management the engine is currently using, or null. */
+export function getActiveColorManagement() {
+
+	return active;
+
+}
+
+/** Make an instance the one the engine reads. Normally the app's own, set on construction. */
+export function setActiveColorManagement( cm ) {
+
+	active = cm;
+	// Whatever the previous instance published is not this one's working space.
+	cm?._publishWorkingMatrix?.();
+
+}
+
+/** Becomes the active one only when there is none, without publishing (a constructor's claim). */
+export function claimActiveColorManagement( cm ) {
+
+	if ( active === null ) active = cm;
+
+}

package/src/Color/BasicColor.js

@@ -0,0 +1,147 @@
+/**
+ * The renderer core's colour management: linear Rec.709, three.js's built-in view transforms, nothing converted — what
+ * the OCIO `ColorManagement` (rayzee/addons/color) does with no config loaded. `renderer.setColorManagement(
+ * ColorManagement )` replaces it.
+ */
+
+import { SRGBColorSpace } from 'three';
+import { DEFAULT_WORKING_SPACE, getActiveColorManagement, setActiveColorManagement } from './ActiveColor.js';
+import { registerWithRenderer, onRegistryChange, getViewTransform, listViewTransforms, getRegistryVersion } from './ViewTransforms.js';
+import { setWorkingMatrix } from './WorkingMatrix.js';
+import { ISSUE_CODES } from '../EngineIssues.js';
+
+export class BasicColor {
+
+	constructor( { issues = null } = {} ) {
+
+		this._issues = issues;
+		this._renderer = null;
+		this._offRegistry = onRegistryChange( () => {
+
+			if ( this._renderer ) registerWithRenderer( this._renderer );
+
+		} );
+
+	}
+
+	get hasConfig() {
+
+		return false;
+
+	}
+
+	get workingSpace() {
+
+		return DEFAULT_WORKING_SPACE;
+
+	}
+
+	get workingSpaceAdopted() {
+
+		return false;
+
+	}
+
+	/** Part of a converted texture's cache key: nothing is converted here. */
+	get inputKey() {
+
+		return '-';
+
+	}
+
+	attachRenderer( renderer ) {
+
+		this._renderer = renderer;
+		const n = registerWithRenderer( renderer );
+		renderer.outputColorSpace = SRGBColorSpace;
+		return n;
+
+	}
+
+	/** Every registered view transform, for a host menu. */
+	listViews() {
+
+		return listViewTransforms();
+
+	}
+
+	/** The active OCIO view: none without a config. */
+	get activeView() {
+
+		return null;
+
+	}
+
+	/**
+	 * Make a registered transform the one the renderer uses — three.js's own seven, or one a host added. A view that
+	 * returns display-encoded colour (an OCIO view) needs the OCIO pipeline, which sets the output colour space for it.
+	 */
+	setActiveView( id ) {
+
+		const t = getViewTransform( id );
+		if ( ! t ) throw new Error( `no view transform with id ${id}` );
+		if ( t.outputEncoded ) throw new Error( `"${t.name}" returns display-encoded colour: it needs rayzee/addons/color` );
+		if ( this._renderer ) this._renderer.toneMapping = id;
+		return t;
+
+	}
+
+	_publishWorkingMatrix() {
+
+		setWorkingMatrix( null, DEFAULT_WORKING_SPACE );
+
+	}
+
+	/** Colour configs, views and working spaces need the OCIO pipeline. */
+	loadConfig() {
+
+		const message = 'colour configs need the OCIO pipeline: renderer.setColorManagement( ColorManagement ), from rayzee/addons/color';
+		this._issues?.record( ISSUE_CODES.CAPABILITY_MISSING, message, { capability: 'color' } );
+		return Promise.reject( new Error( message ) );
+
+	}
+
+	unloadConfig() {}
+
+	setWorkingSpace() {}
+
+	/** No export space without a config: the working space as it is. */
+	exportPixels( rgba ) {
+
+		return { rgba, colorSpace: DEFAULT_WORKING_SPACE };
+
+	}
+
+	status() {
+
+		const active = this._renderer ? getViewTransform( this._renderer.toneMapping ) : null;
+		return {
+			config: null,
+			workingSpace: DEFAULT_WORKING_SPACE,
+			workingSpaceAdopted: false,
+			activeTransform: active ? { id: active.id, name: active.name, source: active.source } : null,
+			activeView: null,
+			context: null,
+			exportSpace: null,
+			views: listViewTransforms(),
+			registryVersion: getRegistryVersion(),
+			bakeError: active?.error ?? null,
+		};
+
+	}
+
+	dispose() {
+
+		this._offRegistry?.();
+		this._renderer = null;
+		this._issues = null;
+		if ( getActiveColorManagement() === this ) {
+
+			setWorkingMatrix( null );
+			setActiveColorManagement( null );
+
+		}
+
+	}
+
+}

package/src/Color/ColorManagement.js

@@ -44,34 +44,9 @@ import {
 } from './InputColorSpaces.js';
 import { setWorkingMatrix, convertLinearTriple, convertLinearTriples } from './WorkingMatrix.js';
 import { packHalf, unpackHalf } from './LutBake.js';
+import { DEFAULT_WORKING_SPACE, getActiveColorManagement, setActiveColorManagement, claimActiveColorManagement } from './ActiveColor.js';
 
-/** What the engine renders in when no config has been adopted. */
-export const DEFAULT_WORKING_SPACE = 'Linear Rec.709 (sRGB)';
-
-/**
- * The instance the rest of the engine reads.
- *
- * A config, a working space and a set of view transforms are process-wide — there is one OCIO
- * runtime and one set of baked tables — so code far from the app (texture processing, the asset
- * loader) asks for the active instance rather than having one threaded through six constructors.
- */
-let active = null;
-
-/** The colour management the engine is currently using, or null. */
-export function getActiveColorManagement() {
-
-	return active;
-
-}
-
-/** Make an instance the one the engine reads. Normally the app's own, set on construction. */
-export function setActiveColorManagement( cm ) {
-
-	active = cm;
-	// Whatever the previous instance published is not this one's working space.
-	cm?._publishWorkingMatrix?.();
-
-}
+export { DEFAULT_WORKING_SPACE, getActiveColorManagement, setActiveColorManagement };
 
 /** The canvas colour space for a display: its own when it has one, sRGB otherwise. */
 export function canvasColorSpaceFor( display ) {
@@ -150,7 +125,7 @@ export class ColorManagement {
 
 		} );
 
-		if ( active === null ) active = this;
+		claimActiveColorManagement( this );
 
 	}
 
@@ -850,6 +825,7 @@ export class ColorManagement {
 	/** Recompute the published primaries matrix. Called whenever the config or space changes. */
 	_publishWorkingMatrix() {
 
+		const active = getActiveColorManagement();
 		if ( active !== null && active !== this ) return;
 		setWorkingMatrix( hasConfig() ? this.primariesMatrixToWorking() : null, this.workingSpace );
 
@@ -1094,12 +1070,12 @@ export class ColorManagement {
 		setOcioIssueLog( null );
 		this._renderer = null;
 		this._issues = null;
-		if ( active === this ) {
+		if ( getActiveColorManagement() === this ) {
 
 			// The matrix is module state that materials and lights read with no idea whose it is.
 			// Left behind, the next app would convert every colour into a space it never adopted.
 			setWorkingMatrix( null );
-			active = null;
+			setActiveColorManagement( null );
 
 		}
 
@@ -1108,7 +1084,7 @@ export class ColorManagement {
 	/** Tear down the shared runtime as well. Tests use this; an app normally should not. */
 	static resetAll() {
 
-		active = null;
+		setActiveColorManagement( null );
 		setWorkingMatrix( null );
 		disposeOcioViewTextures();
 		resetViewTransforms();

package/src/EngineDefaults.js

@@ -52,6 +52,12 @@ export function getRenderProfile( name = 'viewer' ) {
 
 }
 
+// Scene-archive budgets with the memory spill on: the triangles and BVH leave the heap as the build goes, so the host
+// passes these instead of the importer's own. The whole 15-part Moana subset (55.7M / 7.0M) loads cold under them, at
+// an 8.1 GB preflight estimate; the preflight, not the budget, refuses anything larger.
+export const SPILL_TRIANGLE_BUDGET = 60_000_000;
+export const SPILL_PLACEMENT_BUDGET = 8_000_000;
+
 export const ENGINE_DEFAULTS = {
 	// Canvas output
 	resolution: 512,
@@ -91,12 +97,7 @@ export const ENGINE_DEFAULTS = {
 	globalIlluminationIntensity: 1,
 
 	// Environment Mode System
-	environmentMode: 'hdri', // 'hdri' | 'procedural' | 'gradient' | 'color'
-
-	// Gradient Sky Colors
-	gradientZenithColor: '#0077BE',
-	gradientHorizonColor: '#87CEEB',
-	gradientGroundColor: '#654321',
+	environmentMode: 'hdri', // 'hdri' | 'procedural' | 'color'
 
 	// Solid Color Sky
 	solidSkyColor: '#87CEEB',
@@ -169,6 +170,7 @@ export const ENGINE_DEFAULTS = {
 	convergenceOverlay: false, // display-only Compositor overlay; never alters the render
 
 	samplingTechnique: 2,
+	integrator: 'path', // 'path' | 'bidirectional' | 'vcm'
 	enableEmissiveTriangleSampling: false,
 	emissiveBoost: 1.0,
 
@@ -634,8 +636,8 @@ export function unpackNormalOct( packed, out ) {
 // Shared between CPU writers (TextureCreator, MaterialDataManager) and GPU readers (Common.js getMaterial).
 export const MATERIAL_DATA_LAYOUT = {
 
-	SLOTS_PER_MATERIAL: 33, // vec4 slots per material
-	FLOATS_PER_MATERIAL: 132, // total floats per material (33 × 4)
+	SLOTS_PER_MATERIAL: 34, // vec4 slots per material
+	FLOATS_PER_MATERIAL: 136, // total floats per material (34 × 4)
 
 	// ── Flat float offsets (CPU side) ────────────────────────────────
 	// Used as: data[ materialIndex * FLOATS_PER_MATERIAL + offset ]
@@ -659,8 +661,8 @@ export const MATERIAL_DATA_LAYOUT = {
 	EMISSIVE_MAP_INDEX: 28, BUMP_MAP_INDEX: 29, CLEARCOAT: 30, CLEARCOAT_ROUGHNESS: 31,
 	// Slot 8: dispersion + visible + sheen + sheenRoughness         [extended BxDF]
 	DISPERSION: 32, VISIBLE: 33, SHEEN: 34, SHEEN_ROUGHNESS: 35,
-	// Slot 9: sheenColor.rgb + (reserved)                           [extended BxDF]
-	SHEEN_COLOR: 36,
+	// Slot 9: sheenColor.rgb + diffuseTransmission                 [extended BxDF]
+	SHEEN_COLOR: 36, DIFFUSE_TRANSMISSION: 39,
 	// Slot 10: specularIntensity + specularColor.rgb                [extended BxDF]
 	SPECULAR_INTENSITY: 40, SPECULAR_COLOR: 41,
 	// Slot 11: iridescence + iridescenceIOR + iridescenceThicknessRange [extended BxDF]
@@ -688,8 +690,11 @@ export const MATERIAL_DATA_LAYOUT = {
 	TRANSMISSION_MAP_INDEX: 120, CLEARCOAT_MAP_INDEX: 121, CLEARCOAT_ROUGHNESS_MAP_INDEX: 122, SHEEN_COLOR_MAP_INDEX: 123,
 	// Slot 31: extension-texture map indices B (sheenRoughness, iridescence, iridescenceThickness, specularIntensity)
 	SHEEN_ROUGHNESS_MAP_INDEX: 124, IRIDESCENCE_MAP_INDEX: 125, IRIDESCENCE_THICKNESS_MAP_INDEX: 126, SPECULAR_INTENSITY_MAP_INDEX: 127,
-	// Slot 32: extension-texture map indices C (specularColor + 3 reserved)
-	SPECULAR_COLOR_MAP_INDEX: 128,
+	// Slot 32: extension-texture map index C (specularColor) + diffuseTransmissionColor.rgb
+	SPECULAR_COLOR_MAP_INDEX: 128, DIFFUSE_TRANSMISSION_COLOR: 129,
+	// Slot 33: extension-texture map indices D (diffuseTransmission, diffuseTransmissionColor) + 2 reserved;
+	// read only for a material with diffuse transmission
+	DIFFUSE_TRANSMISSION_MAP_INDEX: 132, DIFFUSE_TRANSMISSION_COLOR_MAP_INDEX: 133,
 
 	// ── Vec4 slot indices (GPU/TSL side) ─────────────────────────────
 	// Used with getDatafromStorageBuffer( buf, matIdx, int(slot), int(SLOTS_PER_MATERIAL) )
@@ -703,7 +708,7 @@ export const MATERIAL_DATA_LAYOUT = {
 		MAP_INDICES_A: 6, // [maps] albedo, normal, roughness, metalness
 		MAP_INDICES_B: 7, // [maps] emissive, bump, clearcoat, clearcoatRoughness
 		DISPERSION_SHEEN: 8, // [extended] dispersion, visible, sheen, sheenRoughness
-		SHEEN_COLOR: 9, // [extended] sheenColor, reserved
+		SHEEN_COLOR: 9, // [extended] sheenColor, diffuseTransmission
 		SPECULAR: 10, // [extended] specularIntensity, specularColor
 		IRIDESCENCE: 11, // [extended] iridescence, iridescenceIOR, iridescenceThicknessRange
 		BUMP_DISPLACEMENT: 12, // bumpScale, displacementScale, displacementMapIndex
@@ -719,7 +724,8 @@ export const MATERIAL_DATA_LAYOUT = {
 		SUBSURFACE_C: 29, // subsurfaceAnisotropy g, anisotropy, anisotropyRotation, anisotropyMapIndex
 		EXT_MAP_INDICES_A: 30, // transmission, clearcoat, clearcoatRoughness, sheenColor map indices
 		EXT_MAP_INDICES_B: 31, // sheenRoughness, iridescence, iridescenceThickness, specularIntensity map indices
-		EXT_MAP_INDICES_C: 32, // specularColor map index + 3 reserved
+		EXT_MAP_INDICES_C: 32, // specularColor map index, diffuseTransmissionColor
+		EXT_MAP_INDICES_D: 33, // diffuseTransmission, diffuseTransmissionColor map indices + 2 reserved
 	},
 
 };
@@ -769,6 +775,9 @@ export const MATERIAL_DEFAULTS = deepFreeze( {
 	subsurfaceAnisotropy: 0,
 	anisotropy: 0,
 	anisotropyRotation: 0,
+	// KHR_materials_diffuse_transmission: the share of the diffuse lobe passed through to the other side.
+	diffuseTransmission: 0,
+	diffuseTransmissionColor: [ 1, 1, 1 ],
 } );
 
 function deepFreeze( object ) {

package/src/EngineEvents.js

@@ -8,6 +8,8 @@ export const EngineEvents = {
 	RENDER_COMPLETE: 'engine:renderComplete',
 	RENDER_RESET: 'engine:renderReset',
 	FRAME: 'engine:frame',
+	// The path tracer compiles its shaders in the background ({ compiling }); the canvas keeps its last frame meanwhile.
+	SHADERS_COMPILING: 'engine:shadersCompiling',
 
 	// Denoiser
 	DENOISING_START: 'engine:denoisingStart',

package/src/EngineIssues.js

@@ -34,6 +34,7 @@ export const ISSUE_CODES = Object.freeze( {
 	OUTPUT_SOURCE_FALLBACK: 'output.source_fallback',
 	OUTPUT_TONEMAP_FALLBACK: 'output.tonemap_fallback',
 	LIGHT_PLACEHOLDER_SKIPPED: 'light.placeholder_skipped',
+	CAPABILITY_MISSING: 'capability.missing',
 } );
 
 /** Strict throws on ERROR only. */