@tresjs/core 3.8.0 → 3.9.0

package/dist/src/composables/useLoader/index.d.ts

@@ -0,0 +1,45 @@
+import { Loader, Object3D } from 'three';
+
+export interface TresLoader<T> extends Loader {
+    load: (url: string, onLoad?: (result: T) => void, onProgress?: (event: ProgressEvent) => void, onError?: (event: ErrorEvent) => void) => unknown;
+    loadAsync: (url: string, onProgress?: (event: ProgressEvent) => void) => Promise<T>;
+}
+export type LoaderProto<T> = new (...args: any) => TresLoader<T extends unknown ? any : T>;
+export type LoaderReturnType<T, L extends LoaderProto<T>> = T extends unknown ? Awaited<ReturnType<InstanceType<L>['loadAsync']>> : T;
+/**
+ * Traverse an object and return all the nodes and materials
+ *
+ * @export
+ * @param {Object3D} object
+ * @return { [key: string]: any }
+ */
+export declare function trasverseObjects(object: Object3D): {
+    [key: string]: any;
+};
+export type Extensions<T extends {
+    prototype: LoaderProto<any>;
+}> = (loader: T['prototype']) => void;
+/**
+ * Load resources using THREE loaders and return the result as a promise
+ *
+ * @see https://tresjs.org/api/composables.html#useloader
+ * @see https://threejs.org/docs/index.html?q=loader#api/en/loaders/Loader
+ *
+ * ```ts
+ * import { useLoader } from '@tresjs/core'
+ * import { GLTFLoader } from 'three/examples/jsm/loaders/GLTFLoader'
+ *
+ * const { scene } = await useLoader(THREE.GLTFLoader, 'path/to/asset.gltf')
+ * ```
+ *
+ * @export
+ * @template T
+ * @template U
+ * @param {T} Loader
+ * @param {U} url
+ * @param {Extensions<T>} [extensions]
+ * @param {(event: ProgressEvent<EventTarget>) => void} [onProgress]
+ * @param {(proto: TresLoader<T>) => void} [cb]
+ * @return {*}
+ */
+export declare function useLoader<T extends LoaderProto<T>, U extends string | string[]>(Loader: T, url: U, extensions?: Extensions<T>, onProgress?: (event: ProgressEvent<EventTarget>) => void, cb?: (proto: TresLoader<T>) => void): Promise<U extends any[] ? LoaderReturnType<T, T>[] : LoaderReturnType<T, T>>;

package/dist/src/composables/usePointerEventHandler/index.d.ts

@@ -1,6 +1,6 @@
 import { TresContext } from '../useTresContextProvider';
 import { TresScene } from 'src/types';
-import { Intersection, Event, Object3D } from 'three';
+import { Event, Intersection, Object3D } from 'three';
 
 type CallbackFn = (intersection: Intersection<Object3D<Event>>, event: PointerEvent) => void;
 type CallbackFnPointerLeave = (object: Object3D<Event>, event: PointerEvent) => void;

package/dist/src/composables/useRaycaster/index.d.ts

@@ -0,0 +1,19 @@
+import { TresContext } from '../useTresContextProvider';
+import { Ref } from 'vue';
+import { Intersection, Object3D, Object3DEventMap } from 'three';
+
+export type Intersects = Intersection<Object3D<Object3DEventMap>>[];
+interface PointerMoveEventPayload {
+    intersects?: Intersects;
+    event: PointerEvent;
+}
+interface PointerClickEventPayload {
+    intersects: Intersects;
+    event: PointerEvent;
+}
+export declare const useRaycaster: (objects: Ref<Object3D[]>, { renderer, camera, raycaster }: Pick<TresContext, 'renderer' | 'camera' | 'raycaster'>) => {
+    intersects: import('vue').ComputedRef<Intersects>;
+    onClick: (fn: (value: PointerClickEventPayload) => void) => () => void;
+    onPointerMove: (fn: (value: PointerMoveEventPayload) => void) => () => void;
+};
+export {};

package/dist/src/composables/useRenderer/index.d.ts

@@ -3,7 +3,7 @@ import { TresContext } from '../useTresContextProvider';
 import { TresColor } from '../../types';
 import { MaybeRefOrGetter } from '@vueuse/core';
 import { MaybeRef } from 'vue';
-import { WebGLRenderer, Scene, ToneMapping, ColorSpace, ShadowMapType, WebGLRendererParameters } from 'three';
+import { WebGLRenderer, ColorSpace, Scene, ShadowMapType, ToneMapping, WebGLRendererParameters } from 'three';
 
 type TransformToMaybeRefOrGetter<T> = {
     [K in keyof T]: MaybeRefOrGetter<T[K]> | MaybeRefOrGetter<T[K]>;
@@ -70,12 +70,6 @@ export interface UseRendererOptions extends TransformToMaybeRefOrGetter<WebGLRen
     windowSize?: MaybeRefOrGetter<boolean | string>;
     preset?: MaybeRefOrGetter<RendererPresetsType>;
 }
-/**
- * Reactive three.js WebGLRenderer instance
- *
- * @param canvas
- * @param {UseRendererOptions} [options]
- */
 export declare function useRenderer({ scene, canvas, options, disableRender, contextParts: { sizes, camera }, }: {
     canvas: MaybeRef<HTMLCanvasElement>;
     scene: Scene;

package/dist/src/composables/useSeek/index.d.ts

@@ -0,0 +1,21 @@
+import { Object3D, Scene } from 'three';
+
+/**
+ * Seek composable return type
+ *
+ * @export
+ * @interface UseSeekReturn
+ */
+export interface UseSeekReturn {
+    seek: (parent: Scene | Object3D, property: string, value: string) => Object3D | null;
+    seekByName: (parent: Scene | Object3D, value: string) => Object3D | null;
+    seekAll: (parent: Scene | Object3D, property: string, value: string) => Object3D[];
+    seekAllByName: (parent: Scene | Object3D, value: string) => Object3D[];
+}
+/**
+ * Composable that provides utilities to easily traverse and navigate through complex scenes and object children graphs
+ *
+ * @export
+ * @return {*}  {UseSeekReturn}
+ */
+export declare function useSeek(): UseSeekReturn;

package/dist/src/composables/useSizes/index.d.ts

@@ -1,4 +1,4 @@
-import { MaybeRefOrGetter, MaybeRef, ComputedRef, Ref } from 'vue';
+import { ComputedRef, MaybeRef, MaybeRefOrGetter, Ref } from 'vue';
 
 export interface SizesType {
     height: Readonly<Ref<number>>;

package/dist/src/core/renderer.d.ts

@@ -1,4 +1,4 @@
-export declare const render: import('vue').RootRenderFunction<import("src").TresObject>;
+export declare const render: import('vue').RootRenderFunction<import('..').TresObject>;
 declare const _default: {
     extend: (objects: any) => any;
 };

package/dist/src/directives/index.d.ts

@@ -1,6 +1,7 @@
+import { vRotate } from './vRotate';
 import { vDistanceTo } from './vDistanceTo';
 import { vAlwaysLookAt } from './vAlwaysLookAt';
 import { vLightHelper } from './vLightHelper';
 import { vLog } from './vLog';
 
-export { vLog, vLightHelper, vAlwaysLookAt, vDistanceTo };
+export { vLog, vLightHelper, vAlwaysLookAt, vDistanceTo, vRotate };

package/dist/src/directives/vRotate.d.ts

@@ -0,0 +1,13 @@
+import { TresObject } from '../types';
+
+export declare const vRotate: {
+    mounted: (el: TresObject, binding: {
+        arg: 'x' | 'y' | 'z';
+        value: number;
+        modifiers: Partial<{
+            x: boolean;
+            y: boolean;
+            z: boolean;
+        }>;
+    }) => void;
+};

package/dist/src/types/index.d.ts

@@ -108,10 +108,10 @@ export interface EventHandlers {
     onWheel?: (event: ThreeEvent<WheelEvent>) => void;
 }
 interface MathRepresentation {
-    set(...args: number[] | [THREE.ColorRepresentation]): any;
+    set: (...args: number[] | [THREE.ColorRepresentation]) => any;
 }
 interface VectorRepresentation extends MathRepresentation {
-    setScalar(s: number): any;
+    setScalar: (s: number) => any;
 }
 export interface VectorCoordinates {
     x: number;
@@ -130,11 +130,11 @@ type WithMathProps<P> = {
     [K in keyof P]: P[K] extends MathRepresentation | THREE.Euler ? MathType<P[K]> : P[K];
 };
 interface RaycastableRepresentation {
-    raycast(raycaster: THREE.Raycaster, intersects: THREE.Intersection[]): void;
+    raycast: (raycaster: THREE.Raycaster, intersects: THREE.Intersection[]) => void;
 }
 type EventProps<P> = P extends RaycastableRepresentation ? Partial<EventHandlers> : unknown;
 export interface VueProps<P> {
-    children?: VNode[];
+    children?: VNode<P>[];
     ref?: VNodeRef;
     key?: string | number | symbol;
 }

package/dist/src/utils/index.d.ts

@@ -1,4 +1,4 @@
-import { MeshBasicMaterial, Vector3, Mesh, Scene, Object3D } from 'three';
+import { MeshBasicMaterial, Vector3, Mesh, Object3D, Scene } from 'three';
 
 export declare function toSetMethodName(key: string): string;
 export declare const merge: (target: any, source: any) => any;

package/dist/src/utils/normalize.d.ts

@@ -1,4 +1,4 @@
-import { ColorRepresentation, Vector3, Color } from 'three';
+import { ColorRepresentation, Color, Vector3 } from 'three';
 
 export type SizeFlexibleParams = number[] | {
     width: number;