@tresjs/core 5.9.3 → 5.10.1

package/dist/webgpu.d.ts

@@ -0,0 +1,193 @@
+/**
+  * name: @tresjs/core
+  * version: v5.10.1
+  * (c) 2026
+  * description: Declarative ThreeJS using Vue Components
+  * author: Alvaro Saburido <hola@alvarosaburido.dev> (https://github.com/alvarosabu/)
+  */
+import { $ as isProd, $t as TresPointerEvent, A as createTimer, At as TresCamera, B as catalogue, Bt as TresLayers, C as isNode, Ct as Mutable, D as isPerspectiveCamera, Dt as ThreeElement, E as isOrthographicCamera, Et as Properties, F as AssetLoadData, Ft as TresComponentsOf, G as TresCanvasEmits, Gt as TresQuaternion, H as _default$2, Ht as TresObject, I as DevtoolsMessage, It as TresContextWithClock, J as templateCompilerOptions, Jt as TresVector3, K as TresCanvasInstance, Kt as TresScene, L as DevtoolsMessageType, Lt as TresControl, M as vLightHelper, Mt as TresColor, N as vDistanceTo, Nt as TresColorArray, O as isScene, Ot as ThreeInstances, P as registerTresDevtools, Pt as TresComponents, Q as disposeObject3D, Qt as WithMathProps, R as DevtoolsMessenger, Rt as TresEuler, S as isMesh, Sn as useLoader, St as MathType, T as isObject3D, Tt as Overwrite, Ut as TresObject3D, V as extend, Vt as TresMaterial, Wt as TresPrimitive, X as normalizeColor, Xt as VectorCoordinates, Y as VectorFlexibleParams, Yt as TresVector4, Z as normalizeVectorFlexibleParam, Zt as VueProps, _ as isFog, _n as LoaderProto, _t as ConstructorRepresentation, a as isCopyable, an as RenderMode, at as useLoop, b as isLight, bn as UseLoaderReturn, bt as InstanceProps, c as isTresObject, cn as TresRendererSetupContext, ct as useGraph, d as isWebGLRenderer, dn as TresRendererError, dt as _default$3, en as INJECTION_KEY, et as logError, f as isWebGPURenderer, fn as TresRendererErrorCode, ft as TresObjectMap, g as isColorRepresentation, gn as LoaderMethods, gt as AttachType, h as isColor, hn as RafLoopContext, ht as AttachFnType, i as isClassInstance, in as RenderFunction, it as LoopContext, j as vLog, jt as TresCatalogue, k as TresTimer, kt as ThreeInstancesOf, l as isTresPrimitive, ln as UseRendererManagerReturn, m as isCamera, mn as useCameraManager, mt as Args, n as TresPlugin, nn as TresContextProviderOptions, nt as logWarning, o as isTresCamera, on as RendererOptions, ot as TresPartialContext, p as isBufferGeometry, pn as UseCameraReturn, pt as buildGraph, q as TresCanvasProps, qt as TresVector2, rn as useTresContext, rt as TresCustomRendererOptions, s as isTresInstance, sn as TresRenderer, t as TresOptions, tn as TresContext, tt as logMessage, u as isVectorLike, un as UseRendererOptions, v as isGroup, vn as TresLoader, vt as DisposeType, w as isNodeMaterial, wt as NonFunctionKeys, x as isMaterial, xn as UseLoaderReturnBase, xt as LocalState, y as isLayers, yn as TresLoaderOptions, yt as ElementProps, z as DevtoolsSubscriber, zt as TresInstance } from "./index-BGtWKBla.js";
+import * as THREE_WEBGPU from "three/webgpu";
+import { WebGPURenderer } from "three/webgpu";
+//#region src/webgpu/TresCanvas.vue.d.ts
+interface TresWebGPUCanvasProps extends Omit<TresCanvasProps, 'renderer'> {
+  /**
+   * Custom renderer factory. It must return a `WebGPURenderer`, because `useTres()` from this entry types the renderer as one.
+   */
+  renderer?: (ctx: TresRendererSetupContext) => WebGPURenderer;
+}
+type __VLS_Slots$1 = {
+  default: () => any;
+};
+declare const __VLS_base$1: import("vue").DefineComponent<TresWebGPUCanvasProps, TresCanvasInstance, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+  click: (event: TresPointerEvent) => any;
+  contextmenu: (event: TresPointerEvent) => any;
+  pointermove: (event: TresPointerEvent) => any;
+  pointerenter: (event: TresPointerEvent) => any;
+  pointerleave: (event: TresPointerEvent) => any;
+  pointerover: (event: TresPointerEvent) => any;
+  pointerout: (event: TresPointerEvent) => any;
+  dblclick: (event: TresPointerEvent) => any;
+  pointerdown: (event: TresPointerEvent) => any;
+  pointerup: (event: TresPointerEvent) => any;
+  pointercancel: (event: TresPointerEvent) => any;
+  lostpointercapture: (event: TresPointerEvent) => any;
+  wheel: (event: TresPointerEvent) => any;
+  ready: (context: TresContext) => any;
+  error: (error: Error) => any;
+  pointermissed: (event: TresPointerEvent) => any;
+  render: (context: TresContext) => any;
+  beforeLoop: (context: TresContextWithClock) => any;
+  loop: (context: TresContextWithClock) => any;
+}, string, import("vue").PublicProps, Readonly<TresWebGPUCanvasProps> & Readonly<{
+  onClick?: ((event: TresPointerEvent) => any) | undefined;
+  onContextmenu?: ((event: TresPointerEvent) => any) | undefined;
+  onPointermove?: ((event: TresPointerEvent) => any) | undefined;
+  onPointerenter?: ((event: TresPointerEvent) => any) | undefined;
+  onPointerleave?: ((event: TresPointerEvent) => any) | undefined;
+  onPointerover?: ((event: TresPointerEvent) => any) | undefined;
+  onPointerout?: ((event: TresPointerEvent) => any) | undefined;
+  onDblclick?: ((event: TresPointerEvent) => any) | undefined;
+  onPointerdown?: ((event: TresPointerEvent) => any) | undefined;
+  onPointerup?: ((event: TresPointerEvent) => any) | undefined;
+  onPointercancel?: ((event: TresPointerEvent) => any) | undefined;
+  onLostpointercapture?: ((event: TresPointerEvent) => any) | undefined;
+  onWheel?: ((event: TresPointerEvent) => any) | undefined;
+  onReady?: ((context: TresContext) => any) | undefined;
+  onError?: ((error: Error) => any) | undefined;
+  onPointermissed?: ((event: TresPointerEvent) => any) | undefined;
+  onRender?: ((context: TresContext) => any) | undefined;
+  onBeforeLoop?: ((context: TresContextWithClock) => any) | undefined;
+  onLoop?: ((context: TresContextWithClock) => any) | undefined;
+}>, {
+  windowSize: boolean;
+  enableProvideBridge: boolean;
+  customRendererOptions: TresCustomRendererOptions;
+  antialias: boolean;
+  stencil: boolean;
+  depth: boolean;
+  logarithmicDepthBuffer: boolean;
+  preserveDrawingBuffer: boolean;
+  alpha: boolean;
+  failIfMajorPerformanceCaveat: boolean;
+  clearColor: import("three").ColorRepresentation;
+  clearAlpha: number;
+  shadows: boolean;
+  toneMapping: import("three").ToneMapping;
+  shadowMapType: import("three").ShadowMapType;
+  useLegacyLights: boolean;
+  renderMode: "always" | "on-demand" | "manual";
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const __VLS_export$1: __VLS_WithSlots$1<typeof __VLS_base$1, __VLS_Slots$1>;
+declare const _default: typeof __VLS_export$1;
+type __VLS_WithSlots$1<T, S> = T & {
+  new (): {
+    $slots: S;
+  };
+};
+//#endregion
+//#region src/webgpu/WebGPUContext.vue.d.ts
+type __VLS_Props = TresWebGPUCanvasProps & {
+  canvas: HTMLCanvasElement;
+};
+type __VLS_Slots = {
+  default: () => any;
+};
+declare const __VLS_base: import("vue").DefineComponent<__VLS_Props, TresCanvasInstance, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+  click: (event: TresPointerEvent) => any;
+  contextmenu: (event: TresPointerEvent) => any;
+  pointermove: (event: TresPointerEvent) => any;
+  pointerenter: (event: TresPointerEvent) => any;
+  pointerleave: (event: TresPointerEvent) => any;
+  pointerover: (event: TresPointerEvent) => any;
+  pointerout: (event: TresPointerEvent) => any;
+  dblclick: (event: TresPointerEvent) => any;
+  pointerdown: (event: TresPointerEvent) => any;
+  pointerup: (event: TresPointerEvent) => any;
+  pointercancel: (event: TresPointerEvent) => any;
+  lostpointercapture: (event: TresPointerEvent) => any;
+  wheel: (event: TresPointerEvent) => any;
+  ready: (context: TresContext) => any;
+  error: (error: Error) => any;
+  pointermissed: (event: TresPointerEvent) => any;
+  render: (context: TresContext) => any;
+  beforeLoop: (context: TresContextWithClock) => any;
+  loop: (context: TresContextWithClock) => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
+  onClick?: ((event: TresPointerEvent) => any) | undefined;
+  onContextmenu?: ((event: TresPointerEvent) => any) | undefined;
+  onPointermove?: ((event: TresPointerEvent) => any) | undefined;
+  onPointerenter?: ((event: TresPointerEvent) => any) | undefined;
+  onPointerleave?: ((event: TresPointerEvent) => any) | undefined;
+  onPointerover?: ((event: TresPointerEvent) => any) | undefined;
+  onPointerout?: ((event: TresPointerEvent) => any) | undefined;
+  onDblclick?: ((event: TresPointerEvent) => any) | undefined;
+  onPointerdown?: ((event: TresPointerEvent) => any) | undefined;
+  onPointerup?: ((event: TresPointerEvent) => any) | undefined;
+  onPointercancel?: ((event: TresPointerEvent) => any) | undefined;
+  onLostpointercapture?: ((event: TresPointerEvent) => any) | undefined;
+  onWheel?: ((event: TresPointerEvent) => any) | undefined;
+  onReady?: ((context: TresContext) => any) | undefined;
+  onError?: ((error: Error) => any) | undefined;
+  onPointermissed?: ((event: TresPointerEvent) => any) | undefined;
+  onRender?: ((context: TresContext) => any) | undefined;
+  onBeforeLoop?: ((context: TresContextWithClock) => any) | undefined;
+  onLoop?: ((context: TresContextWithClock) => any) | undefined;
+}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default$1: typeof __VLS_export;
+type __VLS_WithSlots<T, S> = T & {
+  new (): {
+    $slots: S;
+  };
+};
+//#endregion
+//#region src/webgpu/renderer.d.ts
+export declare const useRendererManager: (options: UseRendererOptions) => {
+  loop: {
+    start: () => void;
+    stop: () => void;
+    isActive: Readonly<import("vue").ShallowRef<boolean>>;
+    onBeforeLoop: import("@vueuse/core").EventHookOn<RafLoopContext>;
+    onLoop: import("@vueuse/core").EventHookOn<RafLoopContext>;
+  };
+  instance: TresRenderer;
+  advance: () => void;
+  onReady: import("@vueuse/core").EventHookOn<TresRenderer>;
+  onRender: import("@vueuse/core").EventHookOn<TresRenderer>;
+  onError: import("@vueuse/core").EventHookOn<TresRendererError>;
+  invalidate: (amountOfFramesToInvalidate?: number) => void;
+  canBeInvalidated: import("vue").ComputedRef<boolean>;
+  mode: "always" | "on-demand" | "manual" | undefined;
+  replaceRenderFunction: (fn: RenderFunction) => void;
+  isInitialized: import("vue").Ref<boolean, boolean>;
+  error: import("vue").Ref<TresRendererError | null, TresRendererError | null>;
+};
+export declare const useTresContextProvider: (options: TresContextProviderOptions) => TresContext;
+//#endregion
+//#region src/webgpu/types.d.ts
+/**
+ * Tres components for the `three/webgpu` classes that `three` does not export
+ * (node materials, nodes, ...). Shared names keep the root types, which also matches the
+ * runtime catalogue (see `index.ts`).
+ */
+type TresWebGPUComponents = Omit<TresComponentsOf<ThreeInstancesOf<typeof THREE_WEBGPU>>, keyof TresComponents>;
+declare module 'vue' {
+  interface GlobalComponents extends TresWebGPUComponents {}
+}
+//#endregion
+//#region src/webgpu/useTres.d.ts
+interface TresWebGPUPartialContext extends Omit<TresPartialContext, 'renderer'> {
+  /**
+   * The renderer instance. The WebGPU `TresCanvas` only accepts renderer factories that return a `WebGPURenderer`.
+   */
+  renderer: WebGPURenderer;
+}
+/**
+ * `useTres` for canvases from `@tresjs/core/webgpu`, with the renderer typed as `WebGPURenderer`.
+ */
+export declare function useTres(): TresWebGPUPartialContext;
+//#endregion
+//#region src/webgpu/index.d.ts
+declare const plugin: TresPlugin;
+//#endregion
+export { Args, AssetLoadData, AttachFnType, AttachType, ConstructorRepresentation, DevtoolsMessage, DevtoolsMessageType, DevtoolsMessenger, DevtoolsSubscriber, DisposeType, ElementProps, INJECTION_KEY, InstanceProps, LoaderMethods, LoaderProto, LocalState, LoopContext, MathType, Mutable, NonFunctionKeys, Overwrite, Properties, type RenderFunction, type RenderMode, type RendererOptions, ThreeElement, ThreeInstances, ThreeInstancesOf, TresCamera, _default as TresCanvas, _default$1 as TresCanvasContext, type TresCanvasEmits, type TresCanvasInstance, type TresCanvasProps, TresCatalogue, TresColor, TresColorArray, TresComponents, TresComponentsOf, type TresContext, TresContextWithClock, TresControl, type TresCustomRendererOptions, TresEuler, TresInstance, TresLayers, TresLoader, TresLoaderOptions, TresMaterial, TresObject, TresObject3D, TresObjectMap, TresOptions, TresPartialContext, TresPlugin, type TresPointerEvent, _default$2 as TresPortal, TresPrimitive, TresQuaternion, type TresRenderer, TresRendererError, TresRendererErrorCode, type TresRendererSetupContext, TresScene, TresTimer, TresVector2, TresVector3, TresVector4, type TresWebGPUCanvasProps, type TresWebGPUComponents, type TresWebGPUPartialContext, UseCameraReturn, _default$3 as UseLoader, UseLoaderReturn, UseLoaderReturnBase, type UseRendererManagerReturn, type UseRendererOptions, VectorCoordinates, type VectorFlexibleParams, VueProps, WithMathProps, buildGraph, catalogue, createTimer, plugin as default, disposeObject3D as dispose, extend, isBufferGeometry, isCamera, isClassInstance, isColor, isColorRepresentation, isCopyable, isFog, isGroup, isLayers, isLight, isMaterial, isMesh, isNode, isNodeMaterial, isObject3D, isOrthographicCamera, isPerspectiveCamera, isProd, isScene, isTresCamera, isTresInstance, isTresObject, isTresPrimitive, isVectorLike, isWebGLRenderer, isWebGPURenderer, logError, logMessage, logWarning, normalizeColor, normalizeVectorFlexibleParam, registerTresDevtools, templateCompilerOptions, useCameraManager, useGraph, useLoader, useLoop, useTresContext, vDistanceTo, vLightHelper, vLog };

package/dist/webgpu.js

@@ -0,0 +1,361 @@
+/**
+  * name: @tresjs/core
+  * version: v5.10.1
+  * (c) 2026
+  * description: Declarative ThreeJS using Vue Components
+  * author: Alvaro Saburido <hola@alvarosaburido.dev> (https://github.com/alvarosabu/)
+  */
+import { $ as isGroup, A as catalogue, B as isCopyable, C as disposeObject3D, D as useBaseTresContextProvider, E as INJECTION_KEY, F as isProd, G as isVectorLike, H as isTresInstance, I as logError, J as isBufferGeometry, K as isWebGLRenderer, L as logMessage, M as useBaseRendererManager, N as TresRendererError, O as useTresContext, P as createTimer, Q as isFog, R as logWarning, S as DevtoolsMessenger, U as isTresObject, V as isTresCamera, W as isTresPrimitive, X as isColor, Y as isCamera, Z as isColorRepresentation, _ as BaseCanvas_default, a as useLoop, at as isNodeMaterial, b as Context_default, c as buildGraph, ct as isPerspectiveCamera, d as TresPortal_default, et as isLayers, h as normalizeVectorFlexibleParam, i as vDistanceTo, it as isNode, j as extend, k as useCameraManager, l as component_default, lt as isScene, m as normalizeColor, n as vLog, nt as isMaterial, o as useTres$1, ot as isObject3D, p as templateCompilerOptions, q as isWebGPURenderer, r as vLightHelper, rt as isMesh, s as useGraph, st as isOrthographicCamera, tt as isLight, u as useLoader, v as tresCanvasDefaults, x as registerTresDevtools, y as forwardContext, z as isClassInstance } from "./src-D_6lJnFs.js";
+import { createBlock, defineComponent, mergeDefaults, mergeProps, openBlock, renderSlot, shallowRef, toHandlers, toValue, unref, withCtx } from "vue";
+import * as THREE_WEBGPU from "three/webgpu";
+import { WebGPURenderer } from "three/webgpu";
+//#region src/webgpu/renderer.ts
+const WEBGPU_RENDERER_OPTIONS = [
+	"antialias",
+	"alpha",
+	"depth",
+	"stencil",
+	"logarithmicDepthBuffer"
+];
+/**
+* Picks the `TresCanvas` props that `WebGPURenderer` takes in its constructor.
+* Undefined props are left out so three keeps its own defaults.
+*/
+const toWebGPURendererParameters = (options) => {
+	const parameters = {};
+	for (const key of WEBGPU_RENDERER_OPTIONS) if (options[key] !== void 0) parameters[key] = options[key];
+	if (options.powerPreference && options.powerPreference !== "default") parameters.powerPreference = options.powerPreference;
+	return parameters;
+};
+const createWebGPURenderer = (ctx, options) => new WebGPURenderer({
+	...toWebGPURendererParameters(options),
+	canvas: toValue(ctx.canvas)
+});
+const useRendererManager = (options) => useBaseRendererManager(options, createWebGPURenderer);
+const useTresContextProvider = (options) => useBaseTresContextProvider(options, createWebGPURenderer);
+//#endregion
+//#region src/webgpu/TresCanvas.vue
+var TresCanvas_default = /* @__PURE__ */ defineComponent({
+	__name: "TresCanvas",
+	props: /*@__PURE__*/ mergeDefaults({
+		renderer: {
+			type: Function,
+			required: false
+		},
+		camera: {
+			type: null,
+			required: false
+		},
+		windowSize: {
+			type: Boolean,
+			required: false
+		},
+		fpsLimit: {
+			type: Number,
+			required: false
+		},
+		enableProvideBridge: {
+			type: Boolean,
+			required: false
+		},
+		customRendererOptions: {
+			type: Object,
+			required: false
+		},
+		antialias: {
+			type: Boolean,
+			required: false
+		},
+		stencil: {
+			type: Boolean,
+			required: false
+		},
+		depth: {
+			type: Boolean,
+			required: false
+		},
+		precision: {
+			type: String,
+			required: false
+		},
+		logarithmicDepthBuffer: {
+			type: Boolean,
+			required: false
+		},
+		preserveDrawingBuffer: {
+			type: Boolean,
+			required: false
+		},
+		powerPreference: {
+			type: null,
+			required: false
+		},
+		alpha: {
+			type: Boolean,
+			required: false
+		},
+		premultipliedAlpha: {
+			type: Boolean,
+			required: false
+		},
+		failIfMajorPerformanceCaveat: {
+			type: Boolean,
+			required: false
+		},
+		clearColor: {
+			type: [
+				Object,
+				String,
+				Number
+			],
+			required: false
+		},
+		clearAlpha: {
+			type: Number,
+			required: false
+		},
+		shadows: {
+			type: Boolean,
+			required: false
+		},
+		toneMapping: {
+			type: null,
+			required: false
+		},
+		shadowMapType: {
+			type: null,
+			required: false
+		},
+		useLegacyLights: {
+			type: Boolean,
+			required: false
+		},
+		outputColorSpace: {
+			type: null,
+			required: false
+		},
+		toneMappingExposure: {
+			type: Number,
+			required: false
+		},
+		renderMode: {
+			type: String,
+			required: false
+		},
+		dpr: {
+			type: [Number, Array],
+			required: false
+		}
+	}, tresCanvasDefaults),
+	emits: [
+		"ready",
+		"error",
+		"pointermissed",
+		"render",
+		"beforeLoop",
+		"loop",
+		"click",
+		"contextmenu",
+		"pointermove",
+		"pointerenter",
+		"pointerleave",
+		"pointerover",
+		"pointerout",
+		"dblclick",
+		"pointerdown",
+		"pointerup",
+		"pointercancel",
+		"lostpointercapture",
+		"wheel"
+	],
+	setup(__props, { expose: __expose, emit: __emit }) {
+		const props = __props;
+		const emit = __emit;
+		const child = shallowRef();
+		const { listeners, exposed } = forwardContext(emit, child);
+		__expose(exposed);
+		const createDefaultRenderer = (ctx) => createWebGPURenderer(ctx, props);
+		return (_ctx, _cache) => {
+			return openBlock(), createBlock(BaseCanvas_default, mergeProps({
+				ref_key: "child",
+				ref: child
+			}, props, { renderer: props.renderer ?? createDefaultRenderer }, toHandlers(unref(listeners))), {
+				default: withCtx(() => [renderSlot(_ctx.$slots, "default")]),
+				_: 3
+			}, 16, ["renderer"]);
+		};
+	}
+});
+//#endregion
+//#region src/webgpu/WebGPUContext.vue
+var WebGPUContext_default = /* @__PURE__ */ defineComponent({
+	__name: "WebGPUContext",
+	props: {
+		renderer: {
+			type: Function,
+			required: false
+		},
+		camera: {
+			type: null,
+			required: false
+		},
+		windowSize: {
+			type: Boolean,
+			required: false
+		},
+		fpsLimit: {
+			type: Number,
+			required: false
+		},
+		enableProvideBridge: {
+			type: Boolean,
+			required: false
+		},
+		customRendererOptions: {
+			type: Object,
+			required: false
+		},
+		antialias: {
+			type: Boolean,
+			required: false
+		},
+		stencil: {
+			type: Boolean,
+			required: false
+		},
+		depth: {
+			type: Boolean,
+			required: false
+		},
+		precision: {
+			type: String,
+			required: false
+		},
+		logarithmicDepthBuffer: {
+			type: Boolean,
+			required: false
+		},
+		preserveDrawingBuffer: {
+			type: Boolean,
+			required: false
+		},
+		powerPreference: {
+			type: null,
+			required: false
+		},
+		alpha: {
+			type: Boolean,
+			required: false
+		},
+		premultipliedAlpha: {
+			type: Boolean,
+			required: false
+		},
+		failIfMajorPerformanceCaveat: {
+			type: Boolean,
+			required: false
+		},
+		clearColor: {
+			type: [
+				Object,
+				String,
+				Number
+			],
+			required: false
+		},
+		clearAlpha: {
+			type: Number,
+			required: false
+		},
+		shadows: {
+			type: Boolean,
+			required: false
+		},
+		toneMapping: {
+			type: null,
+			required: false
+		},
+		shadowMapType: {
+			type: null,
+			required: false
+		},
+		useLegacyLights: {
+			type: Boolean,
+			required: false
+		},
+		outputColorSpace: {
+			type: null,
+			required: false
+		},
+		toneMappingExposure: {
+			type: Number,
+			required: false
+		},
+		renderMode: {
+			type: String,
+			required: false
+		},
+		dpr: {
+			type: [Number, Array],
+			required: false
+		},
+		canvas: {
+			type: null,
+			required: true
+		}
+	},
+	emits: [
+		"ready",
+		"error",
+		"pointermissed",
+		"render",
+		"beforeLoop",
+		"loop",
+		"click",
+		"contextmenu",
+		"pointermove",
+		"pointerenter",
+		"pointerleave",
+		"pointerover",
+		"pointerout",
+		"dblclick",
+		"pointerdown",
+		"pointerup",
+		"pointercancel",
+		"lostpointercapture",
+		"wheel"
+	],
+	setup(__props, { expose: __expose, emit: __emit }) {
+		const props = __props;
+		const emit = __emit;
+		const child = shallowRef();
+		const { listeners, exposed } = forwardContext(emit, child);
+		__expose(exposed);
+		const createDefaultRenderer = (ctx) => createWebGPURenderer(ctx, props);
+		return (_ctx, _cache) => {
+			return openBlock(), createBlock(Context_default, mergeProps({
+				ref_key: "child",
+				ref: child
+			}, props, { renderer: props.renderer ?? createDefaultRenderer }, toHandlers(unref(listeners))), {
+				default: withCtx(() => [renderSlot(_ctx.$slots, "default")]),
+				_: 3
+			}, 16, ["renderer"]);
+		};
+	}
+});
+//#endregion
+//#region src/webgpu/useTres.ts
+/**
+* `useTres` for canvases from `@tresjs/core/webgpu`, with the renderer typed as `WebGPURenderer`.
+*/
+function useTres() {
+	return useTres$1();
+}
+//#endregion
+//#region src/webgpu/index.ts
+extend(THREE_WEBGPU);
+const plugin = { install(app) {
+	app.component("TresCanvas", TresCanvas_default);
+} };
+//#endregion
+export { DevtoolsMessenger, INJECTION_KEY, TresCanvas_default as TresCanvas, WebGPUContext_default as TresCanvasContext, TresPortal_default as TresPortal, TresRendererError, component_default as UseLoader, buildGraph, catalogue, createTimer, plugin as default, disposeObject3D as dispose, extend, isBufferGeometry, isCamera, isClassInstance, isColor, isColorRepresentation, isCopyable, isFog, isGroup, isLayers, isLight, isMaterial, isMesh, isNode, isNodeMaterial, isObject3D, isOrthographicCamera, isPerspectiveCamera, isProd, isScene, isTresCamera, isTresInstance, isTresObject, isTresPrimitive, isVectorLike, isWebGLRenderer, isWebGPURenderer, logError, logMessage, logWarning, normalizeColor, normalizeVectorFlexibleParam, registerTresDevtools, templateCompilerOptions, useCameraManager, useGraph, useLoader, useLoop, useRendererManager, useTres, useTresContext, useTresContextProvider, vDistanceTo, vLightHelper, vLog };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@tresjs/core",
   "type": "module",
-  "version": "5.9.3",
+  "version": "5.10.1",
   "description": "Declarative ThreeJS using Vue Components",
   "author": "Alvaro Saburido <hola@alvarosaburido.dev> (https://github.com/alvarosabu/)",
   "license": "MIT",
@@ -17,9 +17,15 @@
     "three",
     "threejs-vue"
   ],
-  "sideEffects": false,
+  "sideEffects": [
+    "./dist/webgpu.js"
+  ],
   "exports": {
     ".": "./dist/tres.js",
+    "./webgpu": {
+      "types": "./dist/webgpu.d.ts",
+      "default": "./dist/webgpu.js"
+    },
     "./template-compiler-options": "./dist/template-compiler-options.mjs",
     "./package.json": "./package.json"
   },
@@ -30,6 +36,9 @@
     "*": {
       "template-compiler-options": [
         "dist/template-compiler-options.d.mts"
+      ],
+      "webgpu": [
+        "dist/webgpu.d.ts"
       ]
     }
   },
@@ -86,7 +95,7 @@
     ]
   },
   "scripts": {
-    "build": "tsdown",
+    "build": "tsdown && node ./scripts/check-entries.mjs && node ./scripts/check-bundle.mjs",
     "build:analyze": "ANALYZE=true tsdown",
     "test": "vitest",
     "test:ci": "vitest run --typecheck",