@react-three/drei 10.7.6 → 10.8.0-alpha.1

package/core/_chunks/libs/stats-gl.mjs

@@ -0,0 +1,301 @@
+//#region node_modules/stats-gl/dist/panel.js
+var Panel = class {
+	constructor(name, fg, bg) {
+		this.name = name;
+		this.fg = fg;
+		this.bg = bg;
+		this.PR = Math.round(window.devicePixelRatio || 1);
+		this.WIDTH = 90 * this.PR;
+		this.HEIGHT = 48 * this.PR;
+		this.TEXT_X = 3 * this.PR;
+		this.TEXT_Y = 2 * this.PR;
+		this.GRAPH_X = 3 * this.PR;
+		this.GRAPH_Y = 15 * this.PR;
+		this.GRAPH_WIDTH = 84 * this.PR;
+		this.GRAPH_HEIGHT = 30 * this.PR;
+		this.canvas = document.createElement("canvas");
+		this.canvas.width = 90 * this.PR;
+		this.canvas.height = 48 * this.PR;
+		this.canvas.style.width = "90px";
+		this.canvas.style.position = "absolute";
+		this.canvas.style.height = "48px";
+		this.canvas.style.cssText = "width:90px;height:48px";
+		this.context = this.canvas.getContext("2d");
+		if (this.context) {
+			this.context.font = "bold " + 9 * this.PR + "px Helvetica,Arial,sans-serif";
+			this.context.textBaseline = "top";
+			this.context.fillStyle = this.bg;
+			this.context.fillRect(0, 0, this.WIDTH, this.HEIGHT);
+			this.context.fillStyle = this.fg;
+			this.context.fillText(this.name, this.TEXT_X, this.TEXT_Y);
+			this.context.fillRect(this.GRAPH_X, this.GRAPH_Y, this.GRAPH_WIDTH, this.GRAPH_HEIGHT);
+			this.context.fillStyle = this.bg;
+			this.context.globalAlpha = .9;
+			this.context.fillRect(this.GRAPH_X, this.GRAPH_Y, this.GRAPH_WIDTH, this.GRAPH_HEIGHT);
+		}
+	}
+	update(value, valueGraph, maxValue, maxGraph, decimals = 0) {
+		let min = Infinity, max = 0;
+		if (!this.context) return;
+		min = Math.min(min, value);
+		max = Math.max(maxValue, value);
+		maxGraph = Math.max(maxGraph, valueGraph);
+		this.context.fillStyle = this.bg;
+		this.context.globalAlpha = 1;
+		this.context.fillRect(0, 0, this.WIDTH, this.GRAPH_Y);
+		this.context.fillStyle = this.fg;
+		this.context.fillText(value.toFixed(decimals) + " " + this.name + " (" + min.toFixed(decimals) + "-" + parseFloat(max.toFixed(decimals)) + ")", this.TEXT_X, this.TEXT_Y);
+		this.context.drawImage(this.canvas, this.GRAPH_X + this.PR, this.GRAPH_Y, this.GRAPH_WIDTH - this.PR, this.GRAPH_HEIGHT, this.GRAPH_X, this.GRAPH_Y, this.GRAPH_WIDTH - this.PR, this.GRAPH_HEIGHT);
+		this.context.fillRect(this.GRAPH_X + this.GRAPH_WIDTH - this.PR, this.GRAPH_Y, this.PR, this.GRAPH_HEIGHT);
+		this.context.fillStyle = this.bg;
+		this.context.globalAlpha = .9;
+		this.context.fillRect(this.GRAPH_X + this.GRAPH_WIDTH - this.PR, this.GRAPH_Y, this.PR, (1 - valueGraph / maxGraph) * this.GRAPH_HEIGHT);
+	}
+};
+
+//#endregion
+//#region node_modules/stats-gl/dist/main.js
+const _Stats = class _Stats2 {
+	constructor({ logsPerSecond = 20, samplesLog = 100, samplesGraph = 10, precision = 2, minimal = false, horizontal = true, mode = 0 } = {}) {
+		this.totalCpuDuration = 0;
+		this.totalGpuDuration = 0;
+		this.totalGpuDurationCompute = 0;
+		this.totalFps = 0;
+		this.activeQuery = null;
+		this.gpuQueries = [];
+		this.renderCount = 0;
+		this.mode = mode;
+		this.horizontal = horizontal;
+		this.dom = document.createElement("div");
+		this.dom.style.cssText = "position:fixed;top:0;left:0;opacity:0.9;z-index:10000;";
+		if (minimal) this.dom.style.cssText += "cursor:pointer";
+		this.gl = null;
+		this.query = null;
+		this.isRunningCPUProfiling = false;
+		this.minimal = minimal;
+		this.beginTime = (performance || Date).now();
+		this.prevTime = this.beginTime;
+		this.prevCpuTime = this.beginTime;
+		this.frames = 0;
+		this.renderCount = 0;
+		this.threeRendererPatched = false;
+		this.averageCpu = {
+			logs: [],
+			graph: []
+		};
+		this.averageGpu = {
+			logs: [],
+			graph: []
+		};
+		this.averageGpuCompute = {
+			logs: [],
+			graph: []
+		};
+		this.queryCreated = false;
+		this.fpsPanel = this.addPanel(new _Stats2.Panel("FPS", "#0ff", "#002"), 0);
+		this.msPanel = this.addPanel(new _Stats2.Panel("CPU", "#0f0", "#020"), 1);
+		this.gpuPanel = null;
+		this.gpuPanelCompute = null;
+		this.samplesLog = samplesLog;
+		this.samplesGraph = samplesGraph;
+		this.precision = precision;
+		this.logsPerSecond = logsPerSecond;
+		if (this.minimal) {
+			this.dom.addEventListener("click", (event) => {
+				event.preventDefault();
+				this.showPanel(++this.mode % this.dom.children.length);
+			}, false);
+			this.mode = mode;
+			this.showPanel(this.mode);
+		} else window.addEventListener("resize", () => {
+			this.resizePanel(this.fpsPanel, 0);
+			this.resizePanel(this.msPanel, 1);
+			if (this.gpuPanel) this.resizePanel(this.gpuPanel, 2);
+			if (this.gpuPanelCompute) this.resizePanel(this.gpuPanelCompute, 3);
+		});
+	}
+	patchThreeRenderer(renderer) {
+		const originalRenderMethod = renderer.render;
+		const statsInstance = this;
+		renderer.render = function(scene, camera) {
+			statsInstance.begin();
+			originalRenderMethod.call(this, scene, camera);
+			statsInstance.end();
+		};
+		this.threeRendererPatched = true;
+	}
+	resizePanel(panel, offset) {
+		panel.canvas.style.position = "absolute";
+		if (this.minimal) panel.canvas.style.display = "none";
+		else {
+			panel.canvas.style.display = "block";
+			if (this.horizontal) {
+				panel.canvas.style.top = "0px";
+				panel.canvas.style.left = offset * panel.WIDTH / panel.PR + "px";
+			} else {
+				panel.canvas.style.left = "0px";
+				panel.canvas.style.top = offset * panel.HEIGHT / panel.PR + "px";
+			}
+		}
+	}
+	addPanel(panel, offset) {
+		if (panel.canvas) {
+			this.dom.appendChild(panel.canvas);
+			this.resizePanel(panel, offset);
+		}
+		return panel;
+	}
+	showPanel(id) {
+		for (let i = 0; i < this.dom.children.length; i++) {
+			const child = this.dom.children[i];
+			child.style.display = i === id ? "block" : "none";
+		}
+		this.mode = id;
+	}
+	async init(canvasOrGL) {
+		if (!canvasOrGL) {
+			console.error("Stats: The \"canvas\" parameter is undefined.");
+			return;
+		}
+		if (canvasOrGL.isWebGLRenderer && !this.threeRendererPatched) {
+			const canvas = canvasOrGL;
+			this.patchThreeRenderer(canvas);
+			this.gl = canvas.getContext();
+		} else if (!this.gl && canvasOrGL instanceof WebGL2RenderingContext) this.gl = canvasOrGL;
+		if (canvasOrGL.isWebGPURenderer) {
+			canvasOrGL.backend.trackTimestamp = true;
+			if (await canvasOrGL.hasFeatureAsync("timestamp-query")) {
+				this.gpuPanel = this.addPanel(new _Stats2.Panel("GPU", "#ff0", "#220"), 2);
+				this.gpuPanelCompute = this.addPanel(new _Stats2.Panel("CPT", "#e1e1e1", "#212121"), 3);
+				this.info = canvasOrGL.info;
+			}
+			return;
+		} else if (!this.gl && canvasOrGL instanceof HTMLCanvasElement || canvasOrGL instanceof OffscreenCanvas) {
+			this.gl = canvasOrGL.getContext("webgl2");
+			if (!this.gl) {
+				console.error("Stats: Unable to obtain WebGL2 context.");
+				return;
+			}
+		} else if (!this.gl) {
+			console.error("Stats: Invalid input type. Expected WebGL2RenderingContext, HTMLCanvasElement, or OffscreenCanvas.");
+			return;
+		}
+		this.ext = this.gl.getExtension("EXT_disjoint_timer_query_webgl2");
+		if (this.ext) this.gpuPanel = this.addPanel(new _Stats2.Panel("GPU", "#ff0", "#220"), 2);
+	}
+	begin() {
+		if (!this.isRunningCPUProfiling) this.beginProfiling("cpu-started");
+		if (!this.gl || !this.ext) return;
+		if (this.gl && this.ext) {
+			if (this.activeQuery) this.gl.endQuery(this.ext.TIME_ELAPSED_EXT);
+			this.activeQuery = this.gl.createQuery();
+			if (this.activeQuery !== null) this.gl.beginQuery(this.ext.TIME_ELAPSED_EXT, this.activeQuery);
+		}
+	}
+	end() {
+		this.renderCount++;
+		if (this.gl && this.ext && this.activeQuery) {
+			this.gl.endQuery(this.ext.TIME_ELAPSED_EXT);
+			this.gpuQueries.push({ query: this.activeQuery });
+			this.activeQuery = null;
+		}
+	}
+	processGpuQueries() {
+		if (!this.gl || !this.ext) return;
+		this.totalGpuDuration = 0;
+		this.gpuQueries.forEach((queryInfo, index) => {
+			if (this.gl) {
+				const available = this.gl.getQueryParameter(queryInfo.query, this.gl.QUERY_RESULT_AVAILABLE);
+				const disjoint = this.gl.getParameter(this.ext.GPU_DISJOINT_EXT);
+				if (available && !disjoint) {
+					const duration = this.gl.getQueryParameter(queryInfo.query, this.gl.QUERY_RESULT) * 1e-6;
+					this.totalGpuDuration += duration;
+					this.gl.deleteQuery(queryInfo.query);
+					this.gpuQueries.splice(index, 1);
+				}
+			}
+		});
+	}
+	update() {
+		if (this.info === void 0) this.processGpuQueries();
+		else {
+			this.totalGpuDuration = this.info.render.timestamp;
+			this.totalGpuDurationCompute = this.info.compute.timestamp;
+			this.addToAverage(this.totalGpuDurationCompute, this.averageGpuCompute);
+		}
+		this.endProfiling("cpu-started", "cpu-finished", "cpu-duration");
+		this.addToAverage(this.totalCpuDuration, this.averageCpu);
+		this.addToAverage(this.totalGpuDuration, this.averageGpu);
+		this.renderCount = 0;
+		if (this.totalCpuDuration === 0) this.beginProfiling("cpu-started");
+		this.totalCpuDuration = 0;
+		this.totalFps = 0;
+		this.beginTime = this.endInternal();
+	}
+	endInternal() {
+		this.frames++;
+		const time = (performance || Date).now();
+		if (time >= this.prevCpuTime + 1e3 / this.logsPerSecond) {
+			this.updatePanel(this.msPanel, this.averageCpu);
+			this.updatePanel(this.gpuPanel, this.averageGpu);
+			if (this.gpuPanelCompute) this.updatePanel(this.gpuPanelCompute, this.averageGpuCompute);
+			this.prevCpuTime = time;
+		}
+		if (time >= this.prevTime + 1e3) {
+			const fps = this.frames * 1e3 / (time - this.prevTime);
+			this.fpsPanel.update(fps, fps, 100, 100, 0);
+			this.prevTime = time;
+			this.frames = 0;
+		}
+		return time;
+	}
+	addToAverage(value, averageArray) {
+		averageArray.logs.push(value);
+		if (averageArray.logs.length > this.samplesLog) averageArray.logs.shift();
+		averageArray.graph.push(value);
+		if (averageArray.graph.length > this.samplesGraph) averageArray.graph.shift();
+	}
+	beginProfiling(marker) {
+		if (window.performance) {
+			window.performance.mark(marker);
+			this.isRunningCPUProfiling = true;
+		}
+	}
+	endProfiling(startMarker, endMarker, measureName) {
+		if (window.performance && endMarker && this.isRunningCPUProfiling) {
+			window.performance.mark(endMarker);
+			const cpuMeasure = performance.measure(measureName, startMarker, endMarker);
+			this.totalCpuDuration += cpuMeasure.duration;
+			this.isRunningCPUProfiling = false;
+		}
+	}
+	updatePanel(panel, averageArray) {
+		if (averageArray.logs.length > 0) {
+			let sumLog = 0;
+			let max = .01;
+			for (let i = 0; i < averageArray.logs.length; i++) {
+				sumLog += averageArray.logs[i];
+				if (averageArray.logs[i] > max) max = averageArray.logs[i];
+			}
+			let sumGraph = 0;
+			let maxGraph = .01;
+			for (let i = 0; i < averageArray.graph.length; i++) {
+				sumGraph += averageArray.graph[i];
+				if (averageArray.graph[i] > maxGraph) maxGraph = averageArray.graph[i];
+			}
+			if (panel) panel.update(sumLog / Math.min(averageArray.logs.length, this.samplesLog), sumGraph / Math.min(averageArray.graph.length, this.samplesGraph), max, maxGraph, this.precision);
+		}
+	}
+	get domElement() {
+		return this.dom;
+	}
+	get container() {
+		console.warn("Stats: Deprecated! this.container as been replaced to this.dom ");
+		return this.dom;
+	}
+};
+_Stats.Panel = Panel;
+let Stats = _Stats;
+
+//#endregion
+export { Stats as t };

package/core/_chunks/libs/stats.js.mjs

@@ -0,0 +1,90 @@
+import { t as __commonJSMin } from "../rolldown-runtime.mjs";
+
+//#region node_modules/stats.js/build/stats.min.js
+var require_stats_min = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	(function(f, e) {
+		"object" === typeof exports && "undefined" !== typeof module ? module.exports = e() : "function" === typeof define && define.amd ? define(e) : f.Stats = e();
+	})(exports, function() {
+		var f = function() {
+			function e(a$1) {
+				c.appendChild(a$1.dom);
+				return a$1;
+			}
+			function u(a$1) {
+				for (var d = 0; d < c.children.length; d++) c.children[d].style.display = d === a$1 ? "block" : "none";
+				l = a$1;
+			}
+			var l = 0, c = document.createElement("div");
+			c.style.cssText = "position:fixed;top:0;left:0;cursor:pointer;opacity:0.9;z-index:10000";
+			c.addEventListener("click", function(a$1) {
+				a$1.preventDefault();
+				u(++l % c.children.length);
+			}, !1);
+			var k = (performance || Date).now(), g = k, a = 0, r = e(new f.Panel("FPS", "#0ff", "#002")), h = e(new f.Panel("MS", "#0f0", "#020"));
+			if (self.performance && self.performance.memory) var t = e(new f.Panel("MB", "#f08", "#201"));
+			u(0);
+			return {
+				REVISION: 16,
+				dom: c,
+				addPanel: e,
+				showPanel: u,
+				begin: function() {
+					k = (performance || Date).now();
+				},
+				end: function() {
+					a++;
+					var c$1 = (performance || Date).now();
+					h.update(c$1 - k, 200);
+					if (c$1 > g + 1e3 && (r.update(1e3 * a / (c$1 - g), 100), g = c$1, a = 0, t)) {
+						var d = performance.memory;
+						t.update(d.usedJSHeapSize / 1048576, d.jsHeapSizeLimit / 1048576);
+					}
+					return c$1;
+				},
+				update: function() {
+					k = this.end();
+				},
+				domElement: c,
+				setMode: u
+			};
+		};
+		f.Panel = function(e, f$1, l) {
+			var c = Infinity, k = 0, g = Math.round, a = g(window.devicePixelRatio || 1), r = 80 * a, h = 48 * a, t = 3 * a, v = 2 * a, d = 3 * a, m = 15 * a, n = 74 * a, p = 30 * a, q = document.createElement("canvas");
+			q.width = r;
+			q.height = h;
+			q.style.cssText = "width:80px;height:48px";
+			var b = q.getContext("2d");
+			b.font = "bold " + 9 * a + "px Helvetica,Arial,sans-serif";
+			b.textBaseline = "top";
+			b.fillStyle = l;
+			b.fillRect(0, 0, r, h);
+			b.fillStyle = f$1;
+			b.fillText(e, t, v);
+			b.fillRect(d, m, n, p);
+			b.fillStyle = l;
+			b.globalAlpha = .9;
+			b.fillRect(d, m, n, p);
+			return {
+				dom: q,
+				update: function(h$1, w) {
+					c = Math.min(c, h$1);
+					k = Math.max(k, h$1);
+					b.fillStyle = l;
+					b.globalAlpha = 1;
+					b.fillRect(0, 0, r, m);
+					b.fillStyle = f$1;
+					b.fillText(g(h$1) + " " + e + " (" + g(c) + "-" + g(k) + ")", t, v);
+					b.drawImage(q, d + a, m, n - a, p, d, m, n - a, p);
+					b.fillRect(d + n - a, m, a, p);
+					b.fillStyle = l;
+					b.globalAlpha = .9;
+					b.fillRect(d + n - a, m, a, g((1 - h$1 / w) * p));
+				}
+			};
+		};
+		return f;
+	});
+}));
+
+//#endregion
+export { require_stats_min as t };

package/core/_chunks/libs/suspend-react.mjs

@@ -0,0 +1,60 @@
+import { t as __commonJSMin } from "../rolldown-runtime.mjs";
+
+//#region node_modules/suspend-react/index.cjs.js
+var require_index_cjs = /* @__PURE__ */ __commonJSMin(((exports) => {
+	Object.defineProperty(exports, "__esModule", { value: true });
+	const isPromise = (promise) => typeof promise === "object" && typeof promise.then === "function";
+	const globalCache = [];
+	function shallowEqualArrays(arrA, arrB, equal = (a, b) => a === b) {
+		if (arrA === arrB) return true;
+		if (!arrA || !arrB) return false;
+		const len = arrA.length;
+		if (arrB.length !== len) return false;
+		for (let i = 0; i < len; i++) if (!equal(arrA[i], arrB[i])) return false;
+		return true;
+	}
+	function query(fn, keys = null, preload = false, config = {}) {
+		if (keys === null) keys = [fn];
+		for (const entry$1 of globalCache) if (shallowEqualArrays(keys, entry$1.keys, entry$1.equal)) {
+			if (preload) return void 0;
+			if (Object.prototype.hasOwnProperty.call(entry$1, "error")) throw entry$1.error;
+			if (Object.prototype.hasOwnProperty.call(entry$1, "response")) {
+				if (config.lifespan && config.lifespan > 0) {
+					if (entry$1.timeout) clearTimeout(entry$1.timeout);
+					entry$1.timeout = setTimeout(entry$1.remove, config.lifespan);
+				}
+				return entry$1.response;
+			}
+			if (!preload) throw entry$1.promise;
+		}
+		const entry = {
+			keys,
+			equal: config.equal,
+			remove: () => {
+				const index = globalCache.indexOf(entry);
+				if (index !== -1) globalCache.splice(index, 1);
+			},
+			promise: (isPromise(fn) ? fn : fn(...keys)).then((response) => {
+				entry.response = response;
+				if (config.lifespan && config.lifespan > 0) entry.timeout = setTimeout(entry.remove, config.lifespan);
+			}).catch((error) => entry.error = error)
+		};
+		globalCache.push(entry);
+		if (!preload) throw entry.promise;
+	}
+	const suspend = (fn, keys, config) => query(fn, keys, false, config);
+	const preload = (fn, keys, config) => void query(fn, keys, true, config);
+	const clear = (keys) => {
+		if (keys === void 0 || keys.length === 0) globalCache.splice(0, globalCache.length);
+		else {
+			const entry = globalCache.find((entry$1) => shallowEqualArrays(keys, entry$1.keys, entry$1.equal));
+			if (entry) entry.remove();
+		}
+	};
+	exports.clear = clear;
+	exports.preload = preload;
+	exports.suspend = suspend;
+}));
+
+//#endregion
+export { require_index_cjs as t };