@tresjs/core 4.0.0-rc.0 → 4.0.0-rc.2

package/dist/src/components/TresCanvas.vue.d.ts

@@ -1,7 +1,7 @@
-import { TresCamera } from '../types/';
-import { RendererPresetsType } from '../composables/useRenderer/const';
-import { TresContext } from '../composables';
 import { ColorSpace, ShadowMapType, ToneMapping, WebGLRendererParameters } from 'three';
+import { TresContext } from '../composables';
+import { RendererPresetsType } from '../composables/useRenderer/const';
+import { TresCamera } from '../types/';
 
 export interface TresCanvasProps extends Omit<WebGLRendererParameters, 'canvas'> {
     shadows?: boolean;
@@ -36,6 +36,7 @@ declare const _default: __VLS_WithTemplateSlots<import('vue').DefineComponent<__
 }, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
     render: (...args: any[]) => void;
     click: (...args: any[]) => void;
+    wheel: (...args: any[]) => void;
     "double-click": (...args: any[]) => void;
     "context-menu": (...args: any[]) => void;
     "pointer-move": (...args: any[]) => void;
@@ -46,7 +47,6 @@ declare const _default: __VLS_WithTemplateSlots<import('vue').DefineComponent<__
     "pointer-over": (...args: any[]) => void;
     "pointer-out": (...args: any[]) => void;
     "pointer-missed": (...args: any[]) => void;
-    wheel: (...args: any[]) => void;
 }, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<TresCanvasProps>, {
     alpha: undefined;
     depth: undefined;

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

@@ -1,5 +1,5 @@
 export * from './useCamera/';
-export * from './useRenderLoop/';
+export * from './useRenderLoop';
 export * from './useRenderer/';
 export * from './useLoader';
 export * from './useTexture';
@@ -8,4 +8,5 @@ export * from './useLogger';
 export * from './useSeek';
 export * from './usePointerEventHandler';
 export * from './useTresContextProvider';
+export * from './useLoop';
 export * from './useTresEventManager';

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

@@ -1,6 +1,6 @@
-import { TresContext } from '../useTresContextProvider';
-import { TresScene } from '../../types';
 import { Camera } from 'three';
+import { TresScene } from '../../types';
+import { TresContext } from '../useTresContextProvider';
 
 export declare const useCamera: ({ sizes }: Pick<TresContext, 'sizes'> & {
     scene: TresScene;
@@ -1628,7 +1628,7 @@ export declare const useCamera: ({ sizes }: Pick<TresContext, 'sizes'> & {
                 images: any;
             } | undefined) => any;
             clone: (recursive?: boolean | undefined) => import('three').Object3D<import('three').Object3DEventMap>;
-            copy: (source: import('three').Object3D<import('three').Object3DEventMap>, recursive?: boolean | undefined) => import('three').Object3D<import('three').Object3DEventMap>;
+            copy: (object: import('three').Object3D<import('three').Object3DEventMap>, recursive?: boolean | undefined) => import('three').Object3D<import('three').Object3DEventMap>;
             addEventListener: {
                 <T_7 extends keyof import('three').Object3DEventMap>(type: T_7, listener: import('three').EventListener<import('three').Object3DEventMap[T_7], T_7, import('three').Object3D<import('three').Object3DEventMap>>): void;
                 <T_8 extends string>(type: T_8, listener: import('three').EventListener<{}, T_8, import('three').Object3D<import('three').Object3DEventMap>>): void;
@@ -3009,7 +3009,7 @@ export declare const useCamera: ({ sizes }: Pick<TresContext, 'sizes'> & {
                 images: any;
             } | undefined) => any;
             clone: (recursive?: boolean | undefined) => import('three').Object3D<import('three').Object3DEventMap>;
-            copy: (source: import('three').Object3D<import('three').Object3DEventMap>, recursive?: boolean | undefined) => import('three').Object3D<import('three').Object3DEventMap>;
+            copy: (object: import('three').Object3D<import('three').Object3DEventMap>, recursive?: boolean | undefined) => import('three').Object3D<import('three').Object3DEventMap>;
             addEventListener: {
                 <T_7 extends keyof import('three').Object3DEventMap>(type: T_7, listener: import('three').EventListener<import('three').Object3DEventMap[T_7], T_7, import('three').Object3D<import('three').Object3DEventMap>>): void;
                 <T_8 extends string>(type: T_8, listener: import('three').EventListener<{}, T_8, import('three').Object3D<import('three').Object3DEventMap>>): void;
@@ -4370,7 +4370,7 @@ export declare const useCamera: ({ sizes }: Pick<TresContext, 'sizes'> & {
             images: any;
         } | undefined) => any;
         clone: (recursive?: boolean | undefined) => Camera;
-        copy: (source: Camera, recursive?: boolean | undefined) => Camera;
+        copy: (object: import('three').Object3D<import('three').Object3DEventMap>, recursive?: boolean | undefined) => Camera;
         addEventListener: {
             <T_14 extends keyof import('three').Object3DEventMap>(type: T_14, listener: import('three').EventListener<import('three').Object3DEventMap[T_14], T_14, Camera>): void;
             <T_15 extends string>(type: T_15, listener: import('three').EventListener<{}, T_15, Camera>): void;

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

@@ -0,0 +1,18 @@
+import { LoopCallbackFn } from './../../core/loop';
+
+export declare function useLoop(): {
+    pause: import('@vueuse/core').Fn;
+    resume: import('@vueuse/core').Fn;
+    pauseRender: import('@vueuse/core').Fn;
+    resumeRender: import('@vueuse/core').Fn;
+    isActive: import('vue').Ref<boolean>;
+    onBeforeRender: (cb: LoopCallbackFn, index?: number) => {
+        off: import('@vueuse/core').Fn;
+    };
+    render: (cb: LoopCallbackFn) => {
+        off: import('@vueuse/core').Fn;
+    };
+    onAfterRender: (cb: LoopCallbackFn, index?: number) => {
+        off: import('@vueuse/core').Fn;
+    };
+};

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

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

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

@@ -1,7 +1,7 @@
-import { TresContext } from '../useTresContextProvider';
-import { TresEvent } from 'src/types';
-import { Ref, ShallowRef } from 'vue';
 import { Intersection, Object3D } from 'three';
+import { Ref, ShallowRef } from 'vue';
+import { TresEvent } from 'src/types';
+import { TresContext } from '../useTresContextProvider';
 
 export declare const useRaycaster: (objects: Ref<Object3D[]>, ctx: TresContext) => {
     intersects: ShallowRef<Intersection<Object3D<import('three').Object3DEventMap>>[]>;

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

@@ -1,6 +1,6 @@
-import { Clock } from 'three';
-import { Ref } from 'vue';
 import { EventHookOn, Fn } from '@vueuse/core';
+import { Ref } from 'vue';
+import { Clock } from 'three';
 
 export interface RenderLoop {
     delta: number;

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

@@ -1,9 +1,9 @@
-import { RendererPresetsType } from './const';
-import { TresContext } from '../useTresContextProvider';
-import { EmitEventFn, TresColor } from '../../types';
-import { MaybeRefOrGetter } from '@vueuse/core';
-import { MaybeRef } from 'vue';
 import { WebGLRenderer, ColorSpace, Scene, ShadowMapType, ToneMapping, WebGLRendererParameters } from 'three';
+import { MaybeRef } from 'vue';
+import { MaybeRefOrGetter } from '@vueuse/core';
+import { EmitEventFn, TresColor } from '../../types';
+import { TresContext } from '../useTresContextProvider';
+import { RendererPresetsType } from './const';
 
 type TransformToMaybeRefOrGetter<T> = {
     [K in keyof T]: MaybeRefOrGetter<T[K]> | MaybeRefOrGetter<T[K]>;
@@ -71,7 +71,7 @@ export interface UseRendererOptions extends TransformToMaybeRefOrGetter<WebGLRen
     preset?: MaybeRefOrGetter<RendererPresetsType>;
     renderMode?: MaybeRefOrGetter<'always' | 'on-demand' | 'manual'>;
 }
-export declare function useRenderer({ scene, canvas, options, disableRender, emit, contextParts: { sizes, camera, render, invalidate, advance }, }: {
+export declare function useRenderer({ canvas, options, contextParts: { sizes, render, invalidate, advance }, }: {
     canvas: MaybeRef<HTMLCanvasElement>;
     scene: Scene;
     options: UseRendererOptions;

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

@@ -1,10 +1,11 @@
-import { SizesType } from '../useSizes';
-import { TresEventManager } from '../useTresEventManager';
-import { EventProps } from '../usePointerEventHandler';
-import { EmitEventFn, TresObject, TresScene } from '../../types';
-import { UseRendererOptions } from '../useRenderer';
-import { ComputedRef, DeepReadonly, MaybeRef, MaybeRefOrGetter, Ref, ShallowRef } from 'vue';
 import { Camera, EventDispatcher, WebGLRenderer, Raycaster } from 'three';
+import { ComputedRef, DeepReadonly, MaybeRef, MaybeRefOrGetter, Ref, ShallowRef } from 'vue';
+import { UseRendererOptions } from '../useRenderer';
+import { EmitEventFn, TresObject, TresScene } from '../../types';
+import { EventProps } from '../usePointerEventHandler';
+import { TresEventManager } from '../useTresEventManager';
+import { SizesType } from '../useSizes';
+import { RendererLoop } from '../../core/loop';
 
 export interface InternalState {
     priority: Ref<number>;
@@ -48,6 +49,7 @@ export interface TresContext {
     raycaster: ShallowRef<Raycaster>;
     perf: PerformanceState;
     render: RenderState;
+    loop: RendererLoop;
     /**
      * Invalidates the current frame when renderMode === 'on-demand'
      */

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

@@ -1,6 +1,6 @@
-import { TresContext } from '../useTresContextProvider';
-import { EmitEventFn, TresObject } from 'src/types';
 import { Scene } from 'three';
+import { EmitEventFn, TresObject } from 'src/types';
+import { TresContext } from '../useTresContextProvider';
 
 export interface TresEventManager {
     /**

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

@@ -1,5 +1,5 @@
-import { TresCatalogue } from '../types';
 import { Ref } from 'vue';
+import { TresCatalogue } from '../types';
 
 export declare const catalogue: Ref<TresCatalogue>;
 export declare const extend: (objects: any) => any;

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

@@ -0,0 +1,38 @@
+import { Ref } from 'vue';
+import { Camera, EventDispatcher, Raycaster, Scene, WebGLRenderer, Clock } from 'three';
+import { Fn } from '@vueuse/core';
+
+export type LoopStage = 'before' | 'render' | 'after';
+export interface LoopCallback {
+    delta: number;
+    elapsed: number;
+    clock: Clock;
+}
+export interface LoopCallbackWithCtx extends LoopCallback {
+    camera: Camera;
+    scene: Scene;
+    renderer: WebGLRenderer;
+    raycaster: Raycaster;
+    controls: Ref<(EventDispatcher<object> & {
+        enabled: boolean;
+    }) | null>;
+    invalidate: Fn;
+    advance: Fn;
+}
+export type LoopCallbackFn = (params: LoopCallbackWithCtx) => void;
+export interface RendererLoop {
+    loopId: string;
+    register: (callback: LoopCallbackFn, stage: LoopStage, index?: number) => {
+        off: Fn;
+    };
+    start: Fn;
+    stop: Fn;
+    pause: Fn;
+    resume: Fn;
+    pauseRender: Fn;
+    resumeRender: Fn;
+    isActive: Ref<boolean>;
+    isRenderPaused: Ref<boolean>;
+    setContext: (newContext: Record<string, any>) => void;
+}
+export declare function createRenderLoop(): RendererLoop;

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

@@ -1,5 +1,5 @@
-import { TresObject } from '../types';
 import { RendererOptions } from 'vue';
+import { TresObject } from '../types';
 
 export declare function invalidateInstance(instance: TresObject): void;
 export declare const nodeOps: () => RendererOptions<TresObject, TresObject | null>;

package/dist/src/devtools/plugin.d.ts

@@ -1,5 +1,5 @@
-import { TresContext } from '../composables';
 import { App as DevtoolsApp } from '@vue/devtools-api';
+import { TresContext } from '../composables';
 
 export interface Tags {
     label: string;

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

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

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

@@ -1,5 +1,5 @@
-import { TresObject } from '../types';
 import { Ref } from 'vue';
+import { TresObject } from '../types';
 
 export declare const vDistanceTo: {
     updated: (el: TresObject, binding: Ref<TresObject>) => void;

package/dist/src/index.d.ts

@@ -1,13 +1,14 @@
-import { disposeObject3D as dispose } from './utils';
-import { default as templateCompilerOptions } from './utils/template-compiler-options';
-import { normalizeColor, normalizeVectorFlexibleParam } from './utils/normalize';
 import { App } from 'vue';
+import { normalizeColor, normalizeVectorFlexibleParam } from './utils/normalize';
+import { default as templateCompilerOptions } from './utils/template-compiler-options';
+import { disposeObject3D as dispose } from './utils';
 
 export * from './composables';
 export * from './core/catalogue';
 export * from './components';
 export * from './types';
 export * from './directives';
+export * from './core/loop';
 export interface TresOptions {
     extends?: Record<string, unknown>;
 }

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

@@ -1,5 +1,5 @@
-import { TresContext } from '../composables/useTresContextProvider';
 import { DefineComponent, VNode, VNodeRef } from 'vue';
+import { TresContext } from '../composables/useTresContextProvider';
 
 import type * as THREE from 'three';
 export type AttachFnType<O = any> = (parent: any, self: O) => () => void;

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

@@ -0,0 +1,18 @@
+import { EventHookOff, IsAny } from '@vueuse/core';
+
+export type Callback<T> = IsAny<T> extends true ? (param: any) => void : ([
+    T
+] extends [void] ? () => void : (param: T) => void);
+export type PriorityEventHookOn<T> = (fn: Callback<T>, priority?: number) => {
+    off: () => void;
+};
+export type PriorityEventHookOff<T> = EventHookOff<T>;
+export type PriorityEventHookTrigger<T = any> = (param?: T) => void;
+export interface PriorityEventHook<T = any> {
+    on: PriorityEventHookOn<T>;
+    off: EventHookOff<T>;
+    trigger: PriorityEventHookTrigger<T>;
+    dispose: () => void;
+    count: number;
+}
+export declare function createPriorityEventHook<T>(): PriorityEventHook<T>;

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

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

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

@@ -1,5 +1,5 @@
-import { TresObject } from './../types';
 import { Scene } from 'three';
+import { TresObject } from './../types';
 
 export declare function calculateMemoryUsage(object: TresObject | Scene): number;
 export declare function bytesToKB(bytes: number): string;