@motion-core/motion-gpu 0.4.1 → 0.5.0

package/dist/core/runtime-loop.js

@@ -1,365 +1,356 @@
-import { resolveMaterial } from './material.js';
-import { toMotionGPUErrorReport } from './error-report.js';
-import { createRenderer } from './renderer.js';
-import { buildRendererPipelineSignature } from './recompile-policy.js';
-import { assertUniformValueForType } from './uniforms.js';
+import { assertUniformValueForType } from "./uniforms.js";
+import { resolveMaterial } from "./material.js";
+import { toMotionGPUErrorReport } from "./error-report.js";
+import { createRenderer } from "./renderer.js";
+import { buildRendererPipelineSignature } from "./recompile-policy.js";
+//#region src/lib/core/runtime-loop.ts
 function getRendererRetryDelayMs(attempt) {
-    return Math.min(8000, 250 * 2 ** Math.max(0, attempt - 1));
+	return Math.min(8e3, 250 * 2 ** Math.max(0, attempt - 1));
 }
-export function createMotionGPURuntimeLoop(options) {
-    const { canvas: canvasElement, registry, size } = options;
-    let frameId = null;
-    let renderer = null;
-    let isDisposed = false;
-    let previousTime = performance.now() / 1000;
-    let activeRendererSignature = '';
-    let failedRendererSignature = null;
-    let failedRendererAttempts = 0;
-    let nextRendererRetryAt = 0;
-    let rendererRebuildPromise = null;
-    const runtimeUniforms = {};
-    const runtimeTextures = {};
-    let activeUniforms = {};
-    let activeTextures = {};
-    let uniformKeys = [];
-    let uniformKeySet = new Set();
-    let uniformTypes = new Map();
-    let textureKeys = [];
-    let textureKeySet = new Set();
-    let activeMaterialSignature = '';
-    let currentCssWidth = -1;
-    let currentCssHeight = -1;
-    const renderUniforms = {};
-    const renderTextures = {};
-    const canvasSize = { width: 0, height: 0 };
-    let shouldContinueAfterFrame = false;
-    let activeErrorKey = null;
-    let errorHistory = [];
-    const getHistoryLimit = () => {
-        const value = options.getErrorHistoryLimit?.() ?? 0;
-        if (!Number.isFinite(value) || value <= 0) {
-            return 0;
-        }
-        return Math.floor(value);
-    };
-    const publishErrorHistory = () => {
-        options.reportErrorHistory?.(errorHistory);
-        const onErrorHistory = options.getOnErrorHistory?.();
-        if (!onErrorHistory) {
-            return;
-        }
-        try {
-            onErrorHistory(errorHistory);
-        }
-        catch {
-            // User-provided error history handlers must not break runtime error recovery.
-        }
-    };
-    const syncErrorHistory = () => {
-        const limit = getHistoryLimit();
-        if (limit <= 0) {
-            if (errorHistory.length === 0) {
-                return;
-            }
-            errorHistory = [];
-            publishErrorHistory();
-            return;
-        }
-        if (errorHistory.length <= limit) {
-            return;
-        }
-        errorHistory = errorHistory.slice(errorHistory.length - limit);
-        publishErrorHistory();
-    };
-    const setError = (error, phase) => {
-        const report = toMotionGPUErrorReport(error, phase);
-        const reportKey = JSON.stringify({
-            phase: report.phase,
-            title: report.title,
-            message: report.message,
-            rawMessage: report.rawMessage
-        });
-        if (activeErrorKey === reportKey) {
-            return;
-        }
-        activeErrorKey = reportKey;
-        const historyLimit = getHistoryLimit();
-        if (historyLimit > 0) {
-            errorHistory = [...errorHistory, report];
-            if (errorHistory.length > historyLimit) {
-                errorHistory = errorHistory.slice(errorHistory.length - historyLimit);
-            }
-            publishErrorHistory();
-        }
-        options.reportError(report);
-        const onError = options.getOnError();
-        if (!onError) {
-            return;
-        }
-        try {
-            onError(report);
-        }
-        catch {
-            // User-provided error handlers must not break runtime error recovery.
-        }
-    };
-    const clearError = () => {
-        if (activeErrorKey === null) {
-            return;
-        }
-        activeErrorKey = null;
-        options.reportError(null);
-    };
-    const scheduleFrame = () => {
-        if (isDisposed || frameId !== null) {
-            return;
-        }
-        frameId = requestAnimationFrame(renderFrame);
-    };
-    const requestFrame = () => {
-        scheduleFrame();
-    };
-    const invalidate = (token) => {
-        registry.invalidate(token);
-        requestFrame();
-    };
-    const advance = () => {
-        registry.advance();
-        requestFrame();
-    };
-    const resetRuntimeMaps = () => {
-        for (const key of Object.keys(runtimeUniforms)) {
-            if (!uniformKeySet.has(key)) {
-                Reflect.deleteProperty(runtimeUniforms, key);
-            }
-        }
-        for (const key of Object.keys(runtimeTextures)) {
-            if (!textureKeySet.has(key)) {
-                Reflect.deleteProperty(runtimeTextures, key);
-            }
-        }
-    };
-    const resetRenderPayloadMaps = () => {
-        for (const key of Object.keys(renderUniforms)) {
-            if (!uniformKeySet.has(key)) {
-                Reflect.deleteProperty(renderUniforms, key);
-            }
-        }
-        for (const key of Object.keys(renderTextures)) {
-            if (!textureKeySet.has(key)) {
-                Reflect.deleteProperty(renderTextures, key);
-            }
-        }
-    };
-    const syncMaterialRuntimeState = (materialState) => {
-        const signatureChanged = activeMaterialSignature !== materialState.signature;
-        const defaultsChanged = activeUniforms !== materialState.uniforms || activeTextures !== materialState.textures;
-        if (!signatureChanged && !defaultsChanged) {
-            return;
-        }
-        activeUniforms = materialState.uniforms;
-        activeTextures = materialState.textures;
-        if (!signatureChanged) {
-            return;
-        }
-        uniformKeys = materialState.uniformLayout.entries.map((entry) => entry.name);
-        uniformTypes = new Map(materialState.uniformLayout.entries.map((entry) => [entry.name, entry.type]));
-        textureKeys = materialState.textureKeys;
-        uniformKeySet = new Set(uniformKeys);
-        textureKeySet = new Set(textureKeys);
-        resetRuntimeMaps();
-        resetRenderPayloadMaps();
-        activeMaterialSignature = materialState.signature;
-    };
-    const resolveActiveMaterial = () => {
-        return resolveMaterial(options.getMaterial());
-    };
-    const setUniform = (name, value) => {
-        if (!uniformKeySet.has(name)) {
-            throw new Error(`Unknown uniform "${name}". Declare it in material.uniforms first.`);
-        }
-        const expectedType = uniformTypes.get(name);
-        if (!expectedType) {
-            throw new Error(`Unknown uniform type for "${name}"`);
-        }
-        assertUniformValueForType(expectedType, value);
-        runtimeUniforms[name] = value;
-    };
-    const setTexture = (name, value) => {
-        if (!textureKeySet.has(name)) {
-            throw new Error(`Unknown texture "${name}". Declare it in material.textures first.`);
-        }
-        runtimeTextures[name] = value;
-    };
-    const renderFrame = (timestamp) => {
-        frameId = null;
-        if (isDisposed) {
-            return;
-        }
-        syncErrorHistory();
-        let materialState;
-        try {
-            materialState = resolveActiveMaterial();
-        }
-        catch (error) {
-            setError(error, 'initialization');
-            scheduleFrame();
-            return;
-        }
-        shouldContinueAfterFrame = false;
-        const outputColorSpace = options.getOutputColorSpace();
-        const rendererSignature = buildRendererPipelineSignature({
-            materialSignature: materialState.signature,
-            outputColorSpace
-        });
-        syncMaterialRuntimeState(materialState);
-        if (failedRendererSignature && failedRendererSignature !== rendererSignature) {
-            failedRendererSignature = null;
-            failedRendererAttempts = 0;
-            nextRendererRetryAt = 0;
-        }
-        if (!renderer || activeRendererSignature !== rendererSignature) {
-            if (failedRendererSignature === rendererSignature &&
-                performance.now() < nextRendererRetryAt) {
-                scheduleFrame();
-                return;
-            }
-            if (!rendererRebuildPromise) {
-                rendererRebuildPromise = (async () => {
-                    try {
-                        const nextRenderer = await createRenderer({
-                            canvas: canvasElement,
-                            fragmentWgsl: materialState.fragmentWgsl,
-                            fragmentLineMap: materialState.fragmentLineMap,
-                            fragmentSource: materialState.fragmentSource,
-                            includeSources: materialState.includeSources,
-                            defineBlockSource: materialState.defineBlockSource,
-                            materialSource: materialState.source,
-                            materialSignature: materialState.signature,
-                            uniformLayout: materialState.uniformLayout,
-                            textureKeys: materialState.textureKeys,
-                            textureDefinitions: materialState.textures,
-                            getRenderTargets: options.getRenderTargets,
-                            getPasses: options.getPasses,
-                            outputColorSpace,
-                            getClearColor: options.getClearColor,
-                            getDpr: () => options.dpr.current,
-                            adapterOptions: options.getAdapterOptions(),
-                            deviceDescriptor: options.getDeviceDescriptor()
-                        });
-                        if (isDisposed) {
-                            nextRenderer.destroy();
-                            return;
-                        }
-                        renderer?.destroy();
-                        renderer = nextRenderer;
-                        activeRendererSignature = rendererSignature;
-                        failedRendererSignature = null;
-                        failedRendererAttempts = 0;
-                        nextRendererRetryAt = 0;
-                        clearError();
-                    }
-                    catch (error) {
-                        failedRendererSignature = rendererSignature;
-                        failedRendererAttempts += 1;
-                        const retryDelayMs = getRendererRetryDelayMs(failedRendererAttempts);
-                        nextRendererRetryAt = performance.now() + retryDelayMs;
-                        setError(error, 'initialization');
-                    }
-                    finally {
-                        rendererRebuildPromise = null;
-                        scheduleFrame();
-                    }
-                })();
-            }
-            return;
-        }
-        const time = timestamp / 1000;
-        const rawDelta = Math.max(0, time - previousTime);
-        const delta = Math.min(rawDelta, options.maxDelta.current);
-        previousTime = time;
-        const rect = canvasElement.getBoundingClientRect();
-        const width = Math.max(0, Math.floor(rect.width));
-        const height = Math.max(0, Math.floor(rect.height));
-        if (width !== currentCssWidth || height !== currentCssHeight) {
-            currentCssWidth = width;
-            currentCssHeight = height;
-            size.set({ width, height });
-        }
-        try {
-            registry.run({
-                time,
-                delta,
-                setUniform,
-                setTexture,
-                invalidate,
-                advance,
-                renderMode: registry.getRenderMode(),
-                autoRender: registry.getAutoRender(),
-                canvas: canvasElement
-            });
-            const shouldRenderFrame = registry.shouldRender();
-            shouldContinueAfterFrame =
-                registry.getRenderMode() === 'always' ||
-                    (registry.getRenderMode() === 'on-demand' && shouldRenderFrame);
-            if (shouldRenderFrame) {
-                for (const key of uniformKeys) {
-                    const runtimeValue = runtimeUniforms[key];
-                    renderUniforms[key] =
-                        runtimeValue === undefined ? activeUniforms[key] : runtimeValue;
-                }
-                for (const key of textureKeys) {
-                    const runtimeValue = runtimeTextures[key];
-                    renderTextures[key] =
-                        runtimeValue === undefined ? (activeTextures[key]?.source ?? null) : runtimeValue;
-                }
-                canvasSize.width = width;
-                canvasSize.height = height;
-                renderer.render({
-                    time,
-                    delta,
-                    renderMode: registry.getRenderMode(),
-                    uniforms: renderUniforms,
-                    textures: renderTextures,
-                    canvasSize
-                });
-            }
-            clearError();
-        }
-        catch (error) {
-            setError(error, 'render');
-        }
-        finally {
-            registry.endFrame();
-        }
-        if (shouldContinueAfterFrame) {
-            scheduleFrame();
-        }
-    };
-    (async () => {
-        try {
-            const initialMaterial = resolveActiveMaterial();
-            syncMaterialRuntimeState(initialMaterial);
-            activeRendererSignature = '';
-            scheduleFrame();
-        }
-        catch (error) {
-            setError(error, 'initialization');
-            scheduleFrame();
-        }
-    })();
-    return {
-        requestFrame,
-        invalidate,
-        advance,
-        destroy: () => {
-            isDisposed = true;
-            if (frameId !== null) {
-                cancelAnimationFrame(frameId);
-                frameId = null;
-            }
-            renderer?.destroy();
-            registry.clear();
-        }
-    };
+function createMotionGPURuntimeLoop(options) {
+	const { canvas: canvasElement, registry, size } = options;
+	let frameId = null;
+	let renderer = null;
+	let isDisposed = false;
+	let previousTime = performance.now() / 1e3;
+	let activeRendererSignature = "";
+	let failedRendererSignature = null;
+	let failedRendererAttempts = 0;
+	let nextRendererRetryAt = 0;
+	let rendererRebuildPromise = null;
+	const runtimeUniforms = {};
+	const runtimeTextures = {};
+	let activeUniforms = {};
+	let activeTextures = {};
+	let uniformKeys = [];
+	let uniformKeySet = /* @__PURE__ */ new Set();
+	let uniformTypes = /* @__PURE__ */ new Map();
+	let textureKeys = [];
+	let textureKeySet = /* @__PURE__ */ new Set();
+	let activeMaterialSignature = "";
+	let currentCssWidth = -1;
+	let currentCssHeight = -1;
+	const renderUniforms = {};
+	const renderTextures = {};
+	const canvasSize = {
+		width: 0,
+		height: 0
+	};
+	let storageBufferKeys = [];
+	let storageBufferKeySet = /* @__PURE__ */ new Set();
+	let storageBufferDefinitions = {};
+	const pendingStorageWrites = [];
+	let shouldContinueAfterFrame = false;
+	let activeErrorKey = null;
+	let errorHistory = [];
+	const getHistoryLimit = () => {
+		const value = options.getErrorHistoryLimit?.() ?? 0;
+		if (!Number.isFinite(value) || value <= 0) return 0;
+		return Math.floor(value);
+	};
+	const publishErrorHistory = () => {
+		options.reportErrorHistory?.(errorHistory);
+		const onErrorHistory = options.getOnErrorHistory?.();
+		if (!onErrorHistory) return;
+		try {
+			onErrorHistory(errorHistory);
+		} catch {}
+	};
+	const syncErrorHistory = () => {
+		const limit = getHistoryLimit();
+		if (limit <= 0) {
+			if (errorHistory.length === 0) return;
+			errorHistory = [];
+			publishErrorHistory();
+			return;
+		}
+		if (errorHistory.length <= limit) return;
+		errorHistory = errorHistory.slice(errorHistory.length - limit);
+		publishErrorHistory();
+	};
+	const setError = (error, phase) => {
+		const report = toMotionGPUErrorReport(error, phase);
+		const reportKey = JSON.stringify({
+			phase: report.phase,
+			title: report.title,
+			message: report.message,
+			rawMessage: report.rawMessage
+		});
+		if (activeErrorKey === reportKey) return;
+		activeErrorKey = reportKey;
+		const historyLimit = getHistoryLimit();
+		if (historyLimit > 0) {
+			errorHistory = [...errorHistory, report];
+			if (errorHistory.length > historyLimit) errorHistory = errorHistory.slice(errorHistory.length - historyLimit);
+			publishErrorHistory();
+		}
+		options.reportError(report);
+		const onError = options.getOnError();
+		if (!onError) return;
+		try {
+			onError(report);
+		} catch {}
+	};
+	const clearError = () => {
+		if (activeErrorKey === null) return;
+		activeErrorKey = null;
+		options.reportError(null);
+	};
+	const scheduleFrame = () => {
+		if (isDisposed || frameId !== null) return;
+		frameId = requestAnimationFrame(renderFrame);
+	};
+	const requestFrame = () => {
+		scheduleFrame();
+	};
+	const invalidate = (token) => {
+		registry.invalidate(token);
+		requestFrame();
+	};
+	const advance = () => {
+		registry.advance();
+		requestFrame();
+	};
+	const resetRuntimeMaps = () => {
+		for (const key of Object.keys(runtimeUniforms)) if (!uniformKeySet.has(key)) Reflect.deleteProperty(runtimeUniforms, key);
+		for (const key of Object.keys(runtimeTextures)) if (!textureKeySet.has(key)) Reflect.deleteProperty(runtimeTextures, key);
+	};
+	const resetRenderPayloadMaps = () => {
+		for (const key of Object.keys(renderUniforms)) if (!uniformKeySet.has(key)) Reflect.deleteProperty(renderUniforms, key);
+		for (const key of Object.keys(renderTextures)) if (!textureKeySet.has(key)) Reflect.deleteProperty(renderTextures, key);
+	};
+	const syncMaterialRuntimeState = (materialState) => {
+		const signatureChanged = activeMaterialSignature !== materialState.signature;
+		const defaultsChanged = activeUniforms !== materialState.uniforms || activeTextures !== materialState.textures;
+		if (!signatureChanged && !defaultsChanged) return;
+		activeUniforms = materialState.uniforms;
+		activeTextures = materialState.textures;
+		if (!signatureChanged) return;
+		uniformKeys = materialState.uniformLayout.entries.map((entry) => entry.name);
+		uniformTypes = new Map(materialState.uniformLayout.entries.map((entry) => [entry.name, entry.type]));
+		textureKeys = materialState.textureKeys;
+		uniformKeySet = new Set(uniformKeys);
+		textureKeySet = new Set(textureKeys);
+		storageBufferKeys = materialState.storageBufferKeys;
+		storageBufferKeySet = new Set(storageBufferKeys);
+		storageBufferDefinitions = options.getMaterial().storageBuffers ?? {};
+		resetRuntimeMaps();
+		resetRenderPayloadMaps();
+		activeMaterialSignature = materialState.signature;
+	};
+	const resolveActiveMaterial = () => {
+		return resolveMaterial(options.getMaterial());
+	};
+	const setUniform = (name, value) => {
+		if (!uniformKeySet.has(name)) throw new Error(`Unknown uniform "${name}". Declare it in material.uniforms first.`);
+		const expectedType = uniformTypes.get(name);
+		if (!expectedType) throw new Error(`Unknown uniform type for "${name}"`);
+		assertUniformValueForType(expectedType, value);
+		runtimeUniforms[name] = value;
+	};
+	const setTexture = (name, value) => {
+		if (!textureKeySet.has(name)) throw new Error(`Unknown texture "${name}". Declare it in material.textures first.`);
+		runtimeTextures[name] = value;
+	};
+	const writeStorageBuffer = (name, data, writeOptions) => {
+		if (!storageBufferKeySet.has(name)) throw new Error(`Unknown storage buffer "${name}". Declare it in material.storageBuffers first.`);
+		const definition = storageBufferDefinitions[name];
+		if (!definition) throw new Error(`Missing definition for storage buffer "${name}".`);
+		const offset = writeOptions?.offset ?? 0;
+		if (offset < 0 || offset + data.byteLength > definition.size) throw new Error(`Storage buffer "${name}" write out of bounds: offset=${offset}, dataSize=${data.byteLength}, bufferSize=${definition.size}.`);
+		pendingStorageWrites.push({
+			name,
+			data,
+			offset
+		});
+	};
+	const readStorageBuffer = (name) => {
+		if (!storageBufferKeySet.has(name)) throw new Error(`Unknown storage buffer "${name}". Declare it in material.storageBuffers first.`);
+		if (!renderer) return Promise.reject(/* @__PURE__ */ new Error(`Cannot read storage buffer "${name}": renderer not initialized.`));
+		const gpuBuffer = renderer.getStorageBuffer?.(name);
+		if (!gpuBuffer) return Promise.reject(/* @__PURE__ */ new Error(`Storage buffer "${name}" not allocated on GPU.`));
+		const device = renderer.getDevice?.();
+		if (!device) return Promise.reject(/* @__PURE__ */ new Error("Cannot read storage buffer: GPU device unavailable."));
+		const definition = storageBufferDefinitions[name];
+		if (!definition) return Promise.reject(/* @__PURE__ */ new Error(`Missing definition for storage buffer "${name}".`));
+		const stagingBuffer = device.createBuffer({
+			size: definition.size,
+			usage: GPUBufferUsage.MAP_READ | GPUBufferUsage.COPY_DST
+		});
+		const commandEncoder = device.createCommandEncoder();
+		commandEncoder.copyBufferToBuffer(gpuBuffer, 0, stagingBuffer, 0, definition.size);
+		device.queue.submit([commandEncoder.finish()]);
+		return stagingBuffer.mapAsync(GPUMapMode.READ).then(() => {
+			const result = stagingBuffer.getMappedRange().slice(0);
+			stagingBuffer.unmap();
+			stagingBuffer.destroy();
+			return result;
+		});
+	};
+	const renderFrame = (timestamp) => {
+		frameId = null;
+		if (isDisposed) return;
+		syncErrorHistory();
+		let materialState;
+		try {
+			materialState = resolveActiveMaterial();
+		} catch (error) {
+			setError(error, "initialization");
+			scheduleFrame();
+			return;
+		}
+		shouldContinueAfterFrame = false;
+		const outputColorSpace = options.getOutputColorSpace();
+		const rendererSignature = buildRendererPipelineSignature({
+			materialSignature: materialState.signature,
+			outputColorSpace
+		});
+		syncMaterialRuntimeState(materialState);
+		if (failedRendererSignature && failedRendererSignature !== rendererSignature) {
+			failedRendererSignature = null;
+			failedRendererAttempts = 0;
+			nextRendererRetryAt = 0;
+		}
+		if (!renderer || activeRendererSignature !== rendererSignature) {
+			if (failedRendererSignature === rendererSignature && performance.now() < nextRendererRetryAt) {
+				scheduleFrame();
+				return;
+			}
+			if (!rendererRebuildPromise) rendererRebuildPromise = (async () => {
+				try {
+					const nextRenderer = await createRenderer({
+						canvas: canvasElement,
+						fragmentWgsl: materialState.fragmentWgsl,
+						fragmentLineMap: materialState.fragmentLineMap,
+						fragmentSource: materialState.fragmentSource,
+						includeSources: materialState.includeSources,
+						defineBlockSource: materialState.defineBlockSource,
+						materialSource: materialState.source,
+						materialSignature: materialState.signature,
+						uniformLayout: materialState.uniformLayout,
+						textureKeys: materialState.textureKeys,
+						textureDefinitions: materialState.textures,
+						storageBufferKeys: materialState.storageBufferKeys,
+						storageBufferDefinitions,
+						storageTextureKeys: materialState.storageTextureKeys,
+						getRenderTargets: options.getRenderTargets,
+						getPasses: options.getPasses,
+						outputColorSpace,
+						getClearColor: options.getClearColor,
+						getDpr: () => options.dpr.current,
+						adapterOptions: options.getAdapterOptions(),
+						deviceDescriptor: options.getDeviceDescriptor()
+					});
+					if (isDisposed) {
+						nextRenderer.destroy();
+						return;
+					}
+					renderer?.destroy();
+					renderer = nextRenderer;
+					activeRendererSignature = rendererSignature;
+					failedRendererSignature = null;
+					failedRendererAttempts = 0;
+					nextRendererRetryAt = 0;
+					clearError();
+				} catch (error) {
+					failedRendererSignature = rendererSignature;
+					failedRendererAttempts += 1;
+					const retryDelayMs = getRendererRetryDelayMs(failedRendererAttempts);
+					nextRendererRetryAt = performance.now() + retryDelayMs;
+					setError(error, "initialization");
+				} finally {
+					rendererRebuildPromise = null;
+					scheduleFrame();
+				}
+			})();
+			return;
+		}
+		const time = timestamp / 1e3;
+		const rawDelta = Math.max(0, time - previousTime);
+		const delta = Math.min(rawDelta, options.maxDelta.current);
+		previousTime = time;
+		const rect = canvasElement.getBoundingClientRect();
+		const width = Math.max(0, Math.floor(rect.width));
+		const height = Math.max(0, Math.floor(rect.height));
+		if (width !== currentCssWidth || height !== currentCssHeight) {
+			currentCssWidth = width;
+			currentCssHeight = height;
+			size.set({
+				width,
+				height
+			});
+		}
+		try {
+			registry.run({
+				time,
+				delta,
+				setUniform,
+				setTexture,
+				writeStorageBuffer,
+				readStorageBuffer,
+				invalidate,
+				advance,
+				renderMode: registry.getRenderMode(),
+				autoRender: registry.getAutoRender(),
+				canvas: canvasElement
+			});
+			const shouldRenderFrame = registry.shouldRender();
+			shouldContinueAfterFrame = registry.getRenderMode() === "always" || registry.getRenderMode() === "on-demand" && shouldRenderFrame;
+			if (shouldRenderFrame) {
+				for (const key of uniformKeys) {
+					const runtimeValue = runtimeUniforms[key];
+					renderUniforms[key] = runtimeValue === void 0 ? activeUniforms[key] : runtimeValue;
+				}
+				for (const key of textureKeys) {
+					const runtimeValue = runtimeTextures[key];
+					renderTextures[key] = runtimeValue === void 0 ? activeTextures[key]?.source ?? null : runtimeValue;
+				}
+				canvasSize.width = width;
+				canvasSize.height = height;
+				renderer.render({
+					time,
+					delta,
+					renderMode: registry.getRenderMode(),
+					uniforms: renderUniforms,
+					textures: renderTextures,
+					canvasSize,
+					...pendingStorageWrites.length > 0 ? { pendingStorageWrites: pendingStorageWrites.splice(0) } : {}
+				});
+			}
+			clearError();
+		} catch (error) {
+			setError(error, "render");
+		} finally {
+			registry.endFrame();
+		}
+		if (shouldContinueAfterFrame) scheduleFrame();
+	};
+	(async () => {
+		try {
+			syncMaterialRuntimeState(resolveActiveMaterial());
+			activeRendererSignature = "";
+			scheduleFrame();
+		} catch (error) {
+			setError(error, "initialization");
+			scheduleFrame();
+		}
+	})();
+	return {
+		requestFrame,
+		invalidate,
+		advance,
+		destroy: () => {
+			isDisposed = true;
+			if (frameId !== null) {
+				cancelAnimationFrame(frameId);
+				frameId = null;
+			}
+			renderer?.destroy();
+			registry.clear();
+		}
+	};
 }
+//#endregion
+export { createMotionGPURuntimeLoop };
+
+//# sourceMappingURL=runtime-loop.js.map