@motion-core/motion-gpu 0.7.0 → 0.8.0

package/src/lib/vue/index.ts

@@ -0,0 +1,78 @@
+/**
+ * Vue adapter entrypoint for MotionGPU.
+ */
+export { default as FragCanvas } from './FragCanvas.vue';
+export { defineMaterial } from '../core/material.js';
+export {
+	BlitPass,
+	CopyPass,
+	ShaderPass,
+	ComputePass,
+	PingPongComputePass
+} from '../passes/index.js';
+export { useMotionGPU } from './motiongpu-context.js';
+export { useFrame } from './frame-context.js';
+export { usePointer } from './use-pointer.js';
+export { useTexture } from './use-texture.js';
+export type {
+	FrameInvalidationToken,
+	FrameState,
+	OutputColorSpace,
+	AnyPass,
+	ComputePassLike,
+	RenderPass,
+	RenderPassContext,
+	RenderPassFlags,
+	RenderPassInputSlot,
+	RenderPassOutputSlot,
+	RenderMode,
+	RenderTarget,
+	RenderTargetDefinition,
+	RenderTargetDefinitionMap,
+	TextureData,
+	TextureDefinition,
+	TextureDefinitionMap,
+	TextureUpdateMode,
+	TextureMap,
+	TextureSource,
+	TextureValue,
+	TypedUniform,
+	UniformMat4Value,
+	UniformMap,
+	UniformType,
+	UniformValue
+} from '../core/types.js';
+export type {
+	LoadedTexture,
+	TextureDecodeOptions,
+	TextureLoadOptions
+} from '../core/texture-loader.js';
+export type {
+	FragMaterial,
+	FragMaterialInput,
+	MaterialIncludes,
+	MaterialDefineValue,
+	MaterialDefines,
+	TypedMaterialDefineValue
+} from '../core/material.js';
+export type { MotionGPUContext } from './motiongpu-context.js';
+export type { UseFrameOptions, UseFrameResult } from './frame-context.js';
+export type {
+	PointerClick,
+	PointerFrameRequestMode,
+	PointerKind,
+	PointerPoint,
+	PointerState,
+	UsePointerOptions,
+	UsePointerResult
+} from './use-pointer.js';
+export type { TextureUrlInput, UseTextureResult } from './use-texture.js';
+export type {
+	StorageBufferAccess,
+	StorageBufferDefinition,
+	StorageBufferDefinitionMap,
+	StorageBufferType,
+	ComputePassContext
+} from '../core/types.js';
+export type { ComputePassOptions, ComputeDispatchContext } from '../passes/ComputePass.js';
+export type { PingPongComputePassOptions } from '../passes/PingPongComputePass.js';

package/src/lib/vue/motiongpu-context.ts

@@ -0,0 +1,97 @@
+import { inject, provide, type InjectionKey } from 'vue';
+import type { RenderMode } from '../core/types.js';
+import type { CurrentReadable, CurrentWritable } from '../core/current-value.js';
+import type {
+	FrameProfilingSnapshot,
+	FrameRunTimings,
+	FrameScheduleSnapshot
+} from '../core/frame-registry.js';
+import type { MotionGPUScheduler as CoreMotionGPUScheduler } from '../core/scheduler-helpers.js';
+
+export type MotionGPUScheduler = CoreMotionGPUScheduler;
+export type { FrameProfilingSnapshot, FrameRunTimings, FrameScheduleSnapshot };
+
+/**
+ * Namespace identifier for user-owned context entries.
+ */
+export type MotionGPUUserNamespace = string | symbol;
+
+/**
+ * Shared user context store exposed by `FragCanvas`.
+ */
+export type MotionGPUUserContext = CurrentWritable<Record<MotionGPUUserNamespace, unknown>>;
+
+/**
+ * Public `FragCanvas` runtime context available to composables and user components.
+ */
+export interface MotionGPUContext {
+	/**
+	 * Underlying canvas element used by the renderer.
+	 */
+	canvas: HTMLCanvasElement | undefined;
+	/**
+	 * Reactive canvas pixel size.
+	 */
+	size: CurrentReadable<{ width: number; height: number }>;
+	/**
+	 * Device pixel ratio multiplier.
+	 */
+	dpr: CurrentWritable<number>;
+	/**
+	 * Max frame delta clamp passed to scheduled callbacks.
+	 */
+	maxDelta: CurrentWritable<number>;
+	/**
+	 * Scheduler render mode (`always`, `on-demand`, `manual`).
+	 */
+	renderMode: CurrentWritable<RenderMode>;
+	/**
+	 * Global toggle for automatic rendering.
+	 */
+	autoRender: CurrentWritable<boolean>;
+	/**
+	 * Namespaced user context store shared within the canvas subtree.
+	 */
+	user: MotionGPUUserContext;
+	/**
+	 * Marks current frame as invalidated.
+	 */
+	invalidate: () => void;
+	/**
+	 * Requests one manual frame advance.
+	 */
+	advance: () => void;
+	/**
+	 * Public scheduler API.
+	 */
+	scheduler: MotionGPUScheduler;
+}
+
+/**
+ * Vue injection key used to expose `FragCanvas` runtime state.
+ */
+export const motionGPUContextKey: InjectionKey<MotionGPUContext> = Symbol('motiongpu.context');
+
+/**
+ * Registers the motiongpu context in the current Vue component tree.
+ *
+ * @param context - Context payload to provide.
+ */
+export function provideMotionGPUContext(context: MotionGPUContext): void {
+	provide(motionGPUContextKey, context);
+}
+
+/**
+ * Returns the active motiongpu context.
+ *
+ * @returns Active context.
+ * @throws {Error} When called outside `<FragCanvas>`.
+ */
+export function useMotionGPU(): MotionGPUContext {
+	const context = inject(motionGPUContextKey, null);
+	if (!context) {
+		throw new Error('useMotionGPU must be used inside <FragCanvas>');
+	}
+
+	return context;
+}

package/src/lib/vue/shims-vue.d.ts

@@ -0,0 +1,6 @@
+declare module '*.vue' {
+	import type { DefineComponent } from 'vue';
+
+	const component: DefineComponent<Record<string, never>, Record<string, never>, unknown>;
+	export default component;
+}

package/src/lib/vue/use-motiongpu-user-context.ts

@@ -0,0 +1,145 @@
+import type { CurrentReadable } from '../core/current-value.js';
+import { useMotionGPU, type MotionGPUUserNamespace } from './motiongpu-context.js';
+
+/**
+ * Internal shape of the user context store.
+ */
+type UserContextStore = Record<MotionGPUUserNamespace, unknown>;
+
+/**
+ * Object-like context payload used by merge semantics.
+ */
+type UserContextEntry = Record<string, unknown>;
+
+/**
+ * Controls how a namespaced user context value behaves when already present.
+ */
+export interface SetMotionGPUUserContextOptions {
+	/**
+	 * Conflict strategy when namespace already exists:
+	 * - `skip`: keep current value
+	 * - `replace`: replace current value
+	 * - `merge`: shallow merge object values, fallback to replace otherwise
+	 *
+	 * @default 'skip'
+	 */
+	existing?: 'merge' | 'replace' | 'skip';
+	/**
+	 * How function inputs should be interpreted:
+	 * - `factory`: call function and store its return value
+	 * - `value`: store function itself
+	 *
+	 * @default 'factory'
+	 */
+	functionValue?: 'factory' | 'value';
+}
+
+/**
+ * Checks whether a value is a non-array object suitable for shallow merge.
+ */
+function isObjectEntry(value: unknown): value is UserContextEntry {
+	return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+
+/**
+ * Returns a read-only view of the entire motiongpu user context store.
+ */
+export function useMotionGPUUserContext<
+	UC extends UserContextStore = UserContextStore
+>(): CurrentReadable<UC>;
+
+/**
+ * Reads a namespaced user context value as a reactive readable store.
+ */
+export function useMotionGPUUserContext<
+	UC extends UserContextStore = UserContextStore,
+	K extends keyof UC & MotionGPUUserNamespace = keyof UC & MotionGPUUserNamespace
+>(namespace: K): CurrentReadable<UC[K] | undefined>;
+
+/**
+ * Read-only user context composable:
+ * - no args: returns full user context store
+ * - namespace: returns namespaced store view
+ *
+ * @param namespace - Optional namespace key.
+ */
+export function useMotionGPUUserContext<
+	UC extends UserContextStore = UserContextStore,
+	K extends keyof UC & MotionGPUUserNamespace = keyof UC & MotionGPUUserNamespace
+>(namespace?: K): CurrentReadable<UC> | CurrentReadable<UC[K] | undefined> {
+	const userStore = useMotionGPU().user;
+
+	if (namespace === undefined) {
+		const allStore: CurrentReadable<UC> = {
+			get current() {
+				return userStore.current as UC;
+			},
+			subscribe(run) {
+				return userStore.subscribe((context) => run(context as UC));
+			}
+		};
+
+		return allStore;
+	}
+
+	const scopedStore: CurrentReadable<UC[K] | undefined> = {
+		get current() {
+			return userStore.current[namespace] as UC[K] | undefined;
+		},
+		subscribe(run) {
+			return userStore.subscribe((context) => run(context[namespace] as UC[K] | undefined));
+		}
+	};
+
+	return scopedStore;
+}
+
+/**
+ * Sets a namespaced user context value with explicit write semantics.
+ *
+ * Returns the effective value stored under the namespace.
+ */
+export function setMotionGPUUserContext<UCT = unknown>(
+	namespace: MotionGPUUserNamespace,
+	value: UCT | (() => UCT),
+	options?: SetMotionGPUUserContextOptions
+): UCT | undefined {
+	const userStore = useMotionGPU().user;
+	const mode = options?.existing ?? 'skip';
+	const functionValueMode = options?.functionValue ?? 'factory';
+	let resolvedValue: UCT | undefined;
+
+	userStore.update((context) => {
+		const hasExisting = namespace in context;
+		if (hasExisting && mode === 'skip') {
+			resolvedValue = context[namespace] as UCT | undefined;
+			return context;
+		}
+
+		const nextValue =
+			typeof value === 'function' && functionValueMode === 'factory'
+				? (value as () => UCT)()
+				: (value as UCT);
+		if (hasExisting && mode === 'merge') {
+			const currentValue = context[namespace];
+			if (isObjectEntry(currentValue) && isObjectEntry(nextValue)) {
+				resolvedValue = {
+					...currentValue,
+					...nextValue
+				} as UCT;
+				return {
+					...context,
+					[namespace]: resolvedValue
+				};
+			}
+		}
+
+		resolvedValue = nextValue;
+		return {
+			...context,
+			[namespace]: nextValue
+		};
+	});
+
+	return resolvedValue;
+}