rayzee 10.0.0 → 11.0.0

package/dist/sceneCachePolicy-BSSsKY98.js

@@ -0,0 +1,443 @@
+import { t as e } from "./EngineEvents-Ci8dVWCP.js";
+import { s as t } from "./BufferLayout-D_IBo2ci.js";
+import { n, r } from "./shared-BGBcSxBQ.js";
+import { n as i } from "./AssetConfig-DSEntE65.js";
+import "three";
+//#region src/Processor/utils.js
+var a = null;
+function o(e) {
+	a = e;
+}
+var s = () => a?.({ type: e.LOADING_RESET }), c = (t) => {
+	a?.({
+		type: e.LOADING_UPDATE,
+		...t
+	});
+}, l = (t) => {
+	a?.({
+		type: e.STATS_UPDATE,
+		...t
+	});
+};
+function u(e) {
+	return e.frameCount || 0;
+}
+function d(e) {
+	if (Array.isArray(e)) e.forEach((e) => {
+		e.userData && e.userData.isFallback || (f(e), e.dispose());
+	});
+	else {
+		if (e.userData && e.userData.isFallback) return;
+		f(e), e.dispose();
+	}
+}
+function f(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 p({ material: e, geometry: t, children: n }) {
+	if (e && d(e), t && t.dispose(), n.length > 0) for (let e of n) p(e);
+}
+function m(e) {
+	if (!e) return;
+	e._canvasTarget && e._onCanvasTargetResize && e._canvasTarget.removeEventListener("resize", e._onCanvasTargetResize);
+	let t = e.dispose();
+	return e._canvasTarget = null, t;
+}
+function h(e, t = []) {
+	if (e && !(t.includes(e.name) || e.isScene)) {
+		if (e.isMaterial) {
+			d(e);
+			return;
+		}
+		for (; e.children.length > 0;) for (let t of e.children) h(t);
+		p(e), e.removeFromParent(), e.clear();
+	}
+}
+function g(e) {
+	e?.traverse((e) => {
+		e.geometry?.userData?.__rayzeeOwned && e.geometry.dispose();
+	});
+}
+function _(e, t) {
+	return t;
+}
+function v(e, t = !1) {
+	return t ? 1 : 1 / (e + 1);
+}
+function y() {
+	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/Processor/ChunkedRecords.js
+var b = 64 * 1024 * 1024, x = typeof SharedArrayBuffer < "u", S = null;
+function C(e) {
+	S = e;
+}
+function w(e, t, n) {
+	let r = n ? new e(new SharedArrayBuffer(t * e.BYTES_PER_ELEMENT)) : new e(t);
+	return S && r.byteLength > 0 && S(r.byteLength, n), r;
+}
+var T = class e {
+	constructor(e, t, n, r = b, i = !1) {
+		let a = t * n.BYTES_PER_ELEMENT, o = Math.max(1, Math.floor(r / a));
+		this.recordCount = e, this.lanesPerRecord = t, this.LaneType = n, this.recordsPerChunk = e <= o ? Math.max(e, 1) : o, this.shared = i, this.chunks = [];
+		let s = e;
+		for (; s > 0;) {
+			let e = Math.min(s, this.recordsPerChunk);
+			this.chunks.push(w(n, e * t, i)), s -= e;
+		}
+		this.chunks.length === 0 && this.chunks.push(w(n, 0, i));
+	}
+	static adopt(t, n, r, i) {
+		let a = Object.create(e.prototype);
+		return a.recordCount = n, a.lanesPerRecord = r, a.LaneType = t[0]?.constructor ?? null, a.recordsPerChunk = i, a.chunks = t, a.shared = typeof SharedArrayBuffer < "u" && t[0]?.buffer instanceof SharedArrayBuffer, a;
+	}
+	static lazy(t, n, r, i = b, a = !1) {
+		let o = Math.max(1, Math.floor(i / (n * r.BYTES_PER_ELEMENT))), s = Object.create(e.prototype);
+		return s.recordCount = t, s.lanesPerRecord = n, s.LaneType = r, s.recordsPerChunk = t <= o ? Math.max(t, 1) : o, s.shared = a, s.chunks = Array(Math.max(1, Math.ceil(t / s.recordsPerChunk))), s._views = [], s;
+	}
+	_materialize(e) {
+		if (this._owner) return this._owner._materialize(e), this.chunks[e];
+		let t = e * this.recordsPerChunk, n = Math.min(this.recordsPerChunk, this.recordCount - t) * this.lanesPerRecord, r = this.chunks[e] = w(this.LaneType, n, this.shared);
+		for (let t of this._liveViews()) t.chunks[e] = new t.LaneType(r.buffer, r.byteOffset, r.byteLength / t.LaneType.BYTES_PER_ELEMENT);
+		return r;
+	}
+	materializeAll() {
+		for (let e = 0; e < this.chunks.length; e++) !this.chunks[e] && !this._spilled?.has(e) && this._materialize(e);
+		return this;
+	}
+	get chunkCount() {
+		return this.chunks.length;
+	}
+	get single() {
+		return this.chunks.length === 1 ? this.chunks[0] : null;
+	}
+	get byteLength() {
+		let e = 0;
+		for (let t of this.chunks) t && (e += t.byteLength);
+		return e;
+	}
+	chunkFor(e) {
+		let t = e / this.recordsPerChunk | 0, n = this.chunks[t];
+		if (n) return n;
+		if (this._spilled?.has(t)) throw Error(`ChunkedRecords: chunk ${t} is on disk — await ensureResident() before touching record ${e}`);
+		return this._materialize(t);
+	}
+	async spill(e, { keep: t = () => !1 } = {}) {
+		if (this._owner) throw Error("ChunkedRecords: spill the storage, not a view of it");
+		this._store = e, this._spilled ??= /* @__PURE__ */ new Set();
+		let n = 0;
+		for (let r = 0; r < this.chunks.length; r++) {
+			let i = this.chunks[r];
+			if (!(!i || t(r))) {
+				await e.write(r, i), this.chunks[r] = null;
+				for (let e of this._liveViews()) e.chunks[r] = null;
+				this._spilled.add(r), n += i.byteLength;
+			}
+		}
+		return n;
+	}
+	async spillChunk(e, t) {
+		let n = this.chunks[e];
+		if (!n) return 0;
+		this._store = t, this._spilled ??= /* @__PURE__ */ new Set(), await t.write(e, n), this.chunks[e] = null;
+		for (let t of this._liveViews()) t.chunks[e] = null;
+		return this._spilled.add(e), n.byteLength;
+	}
+	async ensureResident(e = 0, t = this.recordCount) {
+		if (!this._spilled?.size || t <= 0) return;
+		let n = e / this.recordsPerChunk | 0, r = (e + t - 1) / this.recordsPerChunk | 0;
+		for (let e = n; e <= r; e++) {
+			if (!this._spilled.has(e)) continue;
+			let t = Math.min(this.recordsPerChunk, this.recordCount - e * this.recordsPerChunk) * this.lanesPerRecord, n = await this._store.read(e, t * this.LaneType.BYTES_PER_ELEMENT), r = w(this.LaneType, t, this.shared);
+			new Uint8Array(r.buffer, r.byteOffset, r.byteLength).set(new Uint8Array(n)), this.chunks[e] = r;
+			for (let t of this._liveViews()) t.chunks[e] = new t.LaneType(r.buffer, r.byteOffset, r.byteLength / t.LaneType.BYTES_PER_ELEMENT);
+			this._spilled.delete(e);
+		}
+	}
+	_liveViews() {
+		return this._weakViews &&= this._weakViews.filter((e) => e.deref()), [...this._views ?? [], ...(this._weakViews ?? []).map((e) => e.deref())];
+	}
+	isResident(e = 0, t = this.recordCount) {
+		if (!this._spilled?.size || t <= 0) return !0;
+		let n = e / this.recordsPerChunk | 0, r = (e + t - 1) / this.recordsPerChunk | 0;
+		for (let e = n; e <= r; e++) if (this._spilled.has(e)) return !1;
+		return !0;
+	}
+	get spilledChunks() {
+		return this._spilled?.size ?? 0;
+	}
+	baseOf(e) {
+		return e % this.recordsPerChunk * this.lanesPerRecord;
+	}
+	isContiguous(e, t) {
+		return t <= 0 ? !0 : (e / this.recordsPerChunk | 0) == ((e + t - 1) / this.recordsPerChunk | 0);
+	}
+	slice(e, t) {
+		let n = this.baseOf(e), r = t * this.lanesPerRecord;
+		if (this.isContiguous(e, t)) return this.chunkFor(e).subarray(n, n + r);
+		let i = new this.LaneType(r);
+		return this.readRecords(e, t, i), i;
+	}
+	readRecords(e, t, n) {
+		let r = 0;
+		for (; r < t;) {
+			let i = e + r, a = this.chunkFor(i), o = this.baseOf(i), s = this.recordsPerChunk - i % this.recordsPerChunk, c = Math.min(s, t - r);
+			n.set(a.subarray(o, o + c * this.lanesPerRecord), r * this.lanesPerRecord), r += c;
+		}
+		return n;
+	}
+	setRecords(e, t) {
+		let n = t.length / this.lanesPerRecord, r = 0;
+		for (; r < n;) {
+			let i = e + r, a = this.chunkFor(i), o = this.baseOf(i), s = this.recordsPerChunk - i % this.recordsPerChunk, c = Math.min(s, n - r);
+			a.set(t.subarray(r * this.lanesPerRecord, (r + c) * this.lanesPerRecord), o), r += c;
+		}
+	}
+	copyOf(e, t) {
+		return this.readRecords(e, t, new this.LaneType(t * this.lanesPerRecord));
+	}
+	trimTo(t) {
+		let n = Math.max(1, Math.ceil(t / this.recordsPerChunk)), r = this.chunks.slice(0, n), i = (t - (n - 1) * this.recordsPerChunk) * this.lanesPerRecord, a = r[n - 1];
+		return a.length > i && (r[n - 1] = a.subarray(0, Math.max(0, i))), e.adopt(r, t, this.lanesPerRecord, this.recordsPerChunk);
+	}
+	grow(e) {
+		if (e <= this.recordCount) return;
+		let t = this.chunks.length - 1, n = (e, t) => Math.min(this.recordsPerChunk, t - e * this.recordsPerChunk) * this.lanesPerRecord, r = this.chunks[t];
+		this.recordCount = e;
+		for (let t of this._liveViews()) t.recordCount = e;
+		if (this.chunks.length * this.recordsPerChunk < e) {
+			this.chunks.length = Math.ceil(e / this.recordsPerChunk);
+			for (let e of this._liveViews()) e.chunks.length = this.chunks.length;
+		}
+		if (r && r.length < n(t, e)) {
+			let i = w(this.LaneType, n(t, e), this.shared);
+			i.set(r), this.chunks[t] = i;
+			for (let e of this._liveViews()) e.chunks[t] = new e.LaneType(i.buffer, i.byteOffset, i.byteLength / e.LaneType.BYTES_PER_ELEMENT);
+		} else if (!r && this._spilled?.has(t)) throw Error(`ChunkedRecords: cannot grow past chunk ${t}, which is on disk`);
+	}
+	release(e, t) {
+		let n = this.recordsPerChunk, r = Math.ceil(e / n), i = Math.floor((e + t) / n), a = 0;
+		for (let e = r; e < i; e++) {
+			let t = this.chunks[e];
+			if (t) {
+				a += t.byteLength, this.chunks[e] = void 0;
+				for (let t of this._liveViews()) t.chunks[e] = void 0;
+			}
+		}
+		return a;
+	}
+	trimInPlace(e) {
+		let t = Math.max(1, Math.ceil(e / this.recordsPerChunk)), n = Math.max(0, (e - (t - 1) * this.recordsPerChunk) * this.lanesPerRecord), r = [this, ...this._liveViews()];
+		for (let i of r) {
+			i.chunks.length = t;
+			let r = i.chunks[t - 1];
+			r && r.length > n && (i.chunks[t - 1] = r.subarray(0, n)), i.recordCount = e;
+		}
+		if (this._spilled) for (let e of this._spilled) e >= t && this._spilled.delete(e);
+		return this;
+	}
+	viewAs(t) {
+		let n = (e) => new t(e.buffer, e.byteOffset, e.byteLength / t.BYTES_PER_ELEMENT), r = e.adopt(this.chunks.map((e) => e ? n(e) : void 0), this.recordCount, this.lanesPerRecord, this.recordsPerChunk);
+		return r.LaneType = t, r._owner = this, this._views ? this._views.push(r) : (this._weakViews ??= []).push(new WeakRef(r)), r._spilled = this._spilled ??= /* @__PURE__ */ new Set(), r;
+	}
+}, E = 5;
+function D(e, t) {
+	e && t && (e.userData.__rayzeeSource = t);
+}
+function O(e) {
+	let t = e?.userData?.__rayzeeSource;
+	if (!t) return null;
+	let { width: n = 0, height: r = 0 } = e.image ?? {};
+	return `cdf:${E}:${t}|${n}x${r}|${e.userData.__rayzeeColorSpace ?? "native"}`;
+}
+var k = () => n(i().cacheNamespace)?.area(r.CDF) ?? null, A = [
+	"exactConditional",
+	"exactMarginal",
+	"exactRowGuide",
+	"exactMarginalGuide"
+], j = A.map((e) => `${e}.f32`);
+async function M(e) {
+	let t = O(e), n = t ? await k()?.open(t) : null;
+	if (!n) return null;
+	try {
+		let e = await Promise.all(j.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(A.map((e, n) => [e, t[n]])),
+			totalSum: r,
+			width: i,
+			height: a,
+			exactWidth: o,
+			exactHeight: s,
+			radianceIntegral: c
+		};
+	} finally {
+		n.release();
+	}
+}
+async function N(e, t) {
+	let { totalSum: n, width: r, height: i, exactWidth: a, exactHeight: o, radianceIntegral: s } = t, c = A.map((e) => t[e]), l = O(e), u = l ? k() : 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 < j.length; e++) await d.write(j[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/Processor/HostMemory.js
+var P = t.FLOATS_PER_TRIANGLE * 4, F = 64, I = .9, L = 64, R = 4, z = 1536 * 1024 * 1024, B = 7040 * 1024 * 1024, V = 9216 * 1024 * 1024, H = 6e7, U = 8e6;
+function W(e) {
+	if (e > 0) return {
+		gb: e,
+		assumed: !1
+	};
+	let t = typeof navigator < "u" ? navigator.deviceMemory : void 0;
+	return t > 0 ? {
+		gb: t,
+		assumed: !1
+	} : {
+		gb: 4,
+		assumed: !0
+	};
+}
+var G = 1.15, K = 12 * 1024 * 1024 * 1024;
+function q({ triangles: e, placements: t, geometryBytes: n = 0 }) {
+	let r = {
+		triangles: e * P,
+		bvh: Math.ceil(e * I) * F,
+		geometry: n,
+		placements: t * L,
+		orderMaps: e * R
+	};
+	return r.total = r.triangles + r.bvh + r.geometry + r.placements + r.orderMaps, r;
+}
+function J(e, { chunkBytes: t = b, shared: n = !1, allocate: r = null } = {}) {
+	let i = Math.min(e, K), a = r ?? (n ? (e) => new SharedArrayBuffer(e) : (e) => new ArrayBuffer(e)), o = [], s = 0;
+	try {
+		for (; s < i;) {
+			let e = Math.min(t, i - s);
+			o.push(a(e)), s += e;
+		}
+	} catch {}
+	for (let e = o.length - 1; e >= 0; e--) o[e] = null;
+	return o.length = 0, {
+		placed: s,
+		want: i,
+		exhausted: s < i,
+		capped: e > i
+	};
+}
+var Y = class {
+	constructor() {
+		this.reset();
+	}
+	reset() {
+		this.phase = "idle", this.events = [], this.samples = [], this.allocatedBytes = 0, this.peakLiveBytes = 0, this.byPhase = Object.create(null);
+	}
+	mark(e) {
+		return this.phase = e, this.byPhase[e] ??= {
+			allocated: 0,
+			chunks: 0
+		}, this;
+	}
+	alloc(e, t = "chunk") {
+		if (!(e > 0)) return;
+		let n = this.byPhase[this.phase] ??= {
+			allocated: 0,
+			chunks: 0
+		};
+		n.allocated += e, n.chunks++, this.allocatedBytes += e, this.events.push({
+			phase: this.phase,
+			bytes: e,
+			what: t,
+			at: performance.now()
+		});
+	}
+	sample(e, t) {
+		let n = 0;
+		for (let e in t) n += t[e] || 0;
+		return n > this.peakLiveBytes && (this.peakLiveBytes = n), this.samples.push({
+			label: e,
+			phase: this.phase,
+			total: n,
+			parts: t,
+			at: performance.now()
+		}), n;
+	}
+	get report() {
+		return {
+			allocatedBytes: this.allocatedBytes,
+			peakLiveBytes: this.peakLiveBytes,
+			byPhase: { ...this.byPhase },
+			samples: this.samples.slice()
+		};
+	}
+}, X = "11.0.0", Z = 1e4, Q = 15e5;
+function $(e, t, n = Z) {
+	return e >= n && t / Q < e / 3;
+}
+//#endregion
+export { c as A, g as C, s as D, u as E, o as O, y as S, m as T, T as _, Y as a, C as b, B as c, W as d, q as f, D as g, N as h, V as i, l as j, _ as k, U as l, M as m, $ as n, z as o, J as p, X as r, G as s, Z as t, H as u, b as v, h as w, v as x, x as y };

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": "10.0.0",
+  "version": "11.0.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 );
+
+		}
+
+	}
+
+}