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

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

@@ -0,0 +1,17 @@
+import type { Intersection, Object3D, Object3DEventMap } from 'three';
+import type { TresContext } from '../useTresContextProvider';
+type CallbackFn = (intersection: Intersection<Object3D<Object3DEventMap>>, event: PointerEvent) => void;
+type CallbackFnPointerLeave = (object: Object3D, event: PointerEvent) => void;
+export interface EventProps {
+    onClick?: CallbackFn;
+    onPointerEnter?: CallbackFn;
+    onPointerMove?: CallbackFn;
+    onPointerLeave?: CallbackFnPointerLeave;
+}
+export declare const usePointerEventHandler: (ctx: TresContext) => {
+    registerObject: (object: Object3D & EventProps) => void;
+    deregisterObject: (object: Object3D) => void;
+    registerBlockingObject: (object: Object3D) => void;
+    deregisterBlockingObject: (object: Object3D) => void;
+};
+export {};

package/dist/{composables → src/composables}/useRenderer/const.d.ts

@@ -10,5 +10,9 @@ export declare const rendererPresets: {
             type: 2;
         };
     };
+    flat: {
+        toneMapping: 0;
+        toneMappingExposure: number;
+    };
 };
 export type RendererPresetsType = keyof typeof rendererPresets;

package/dist/{composables → src/composables}/useRenderer/index.d.ts

@@ -52,7 +52,7 @@ export interface UseRendererOptions extends TransformToMaybeRefOrGetter<WebGLRen
      * CineonToneMapping, ACESFilmicToneMapping,
      * CustomToneMapping
      *
-     * @default NoToneMapping
+     * @default ACESFilmicToneMapping
      */
     toneMapping?: MaybeRefOrGetter<ToneMapping>;
     /**
@@ -69,6 +69,7 @@ export interface UseRendererOptions extends TransformToMaybeRefOrGetter<WebGLRen
     clearColor?: MaybeRefOrGetter<TresColor>;
     windowSize?: MaybeRefOrGetter<boolean | string>;
     preset?: MaybeRefOrGetter<RendererPresetsType>;
+    renderMode?: MaybeRefOrGetter<'always' | 'on-demand' | 'manual'>;
 }
 /**
  * Reactive three.js WebGLRenderer instance
@@ -76,11 +77,15 @@ export interface UseRendererOptions extends TransformToMaybeRefOrGetter<WebGLRen
  * @param canvas
  * @param {UseRendererOptions} [options]
  */
-export declare function useRenderer({ scene, canvas, options, disableRender, contextParts: { sizes, camera }, }: {
+export declare function useRenderer({ scene, canvas, options, disableRender, emit, contextParts: { sizes, camera, render, invalidate, advance }, }: {
     canvas: MaybeRef<HTMLCanvasElement>;
     scene: Scene;
     options: UseRendererOptions;
-    contextParts: Pick<TresContext, 'sizes' | 'camera'>;
+    emit: (event: string, ...args: any[]) => void;
+    contextParts: Pick<TresContext, 'sizes' | 'camera' | 'render'> & {
+        invalidate: () => void;
+        advance: () => void;
+    };
     disableRender: MaybeRefOrGetter<boolean>;
 }): {
     renderer: import("vue").ShallowRef<WebGLRenderer>;

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

@@ -0,0 +1,11 @@
+import type { MaybeRefOrGetter, MaybeRef, ComputedRef, Ref } from 'vue';
+export interface SizesType {
+    height: Readonly<Ref<number>>;
+    width: Readonly<Ref<number>>;
+    aspectRatio: ComputedRef<number>;
+}
+export default function useSizes(windowSize: MaybeRefOrGetter<boolean>, canvas: MaybeRef<HTMLCanvasElement>, debounceMs?: number): {
+    height: Readonly<Ref<number>>;
+    width: Readonly<Ref<number>>;
+    aspectRatio: ComputedRef<number>;
+};

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

@@ -0,0 +1,75 @@
+import type { Camera, EventDispatcher, Object3D, WebGLRenderer } from 'three';
+import { Raycaster } from 'three';
+import type { ComputedRef, DeepReadonly, MaybeRef, MaybeRefOrGetter, Ref, ShallowRef } from 'vue';
+import type { UseRendererOptions } from '../useRenderer';
+import type { TresScene } from '../../types';
+import type { EventProps } from '../usePointerEventHandler';
+import { type SizesType } from '../useSizes';
+export interface InternalState {
+    priority: Ref<number>;
+    frames: Ref<number>;
+    maxFrames: number;
+}
+export interface RenderState {
+    /**
+     * If set to 'on-demand', the scene will only be rendered when the current frame is invalidated
+     * If set to 'manual', the scene will only be rendered when advance() is called
+     * If set to 'always', the scene will be rendered every frame
+     */
+    mode: Ref<'always' | 'on-demand' | 'manual'>;
+    priority: Ref<number>;
+    frames: Ref<number>;
+    maxFrames: number;
+    canBeInvalidated: ComputedRef<boolean>;
+}
+export interface PerformanceState {
+    maxFrames: number;
+    fps: {
+        value: number;
+        accumulator: number[];
+    };
+    memory: {
+        currentMem: number;
+        allocatedMem: number;
+        accumulator: number[];
+    };
+}
+export interface TresContext {
+    scene: ShallowRef<TresScene>;
+    sizes: SizesType;
+    extend: (objects: any) => void;
+    camera: ComputedRef<Camera | undefined>;
+    cameras: DeepReadonly<Ref<Camera[]>>;
+    controls: Ref<(EventDispatcher & {
+        enabled: boolean;
+    }) | null>;
+    renderer: ShallowRef<WebGLRenderer>;
+    raycaster: ShallowRef<Raycaster>;
+    perf: PerformanceState;
+    render: RenderState;
+    /**
+     * Invalidates the current frame when renderMode === 'on-demand'
+     */
+    invalidate: () => void;
+    /**
+       * Advance one frame when renderMode === 'manual'
+       */
+    advance: () => void;
+    registerCamera: (camera: Camera) => void;
+    setCameraActive: (cameraOrUuid: Camera | string) => void;
+    deregisterCamera: (camera: Camera) => void;
+    registerObjectAtPointerEventHandler: (object: Object3D & EventProps) => void;
+    deregisterObjectAtPointerEventHandler: (object: Object3D) => void;
+    registerBlockingObjectAtPointerEventHandler: (object: Object3D) => void;
+    deregisterBlockingObjectAtPointerEventHandler: (object: Object3D) => void;
+}
+export declare function useTresContextProvider({ scene, canvas, windowSize, disableRender, rendererOptions, emit, }: {
+    scene: TresScene;
+    canvas: MaybeRef<HTMLCanvasElement>;
+    windowSize: MaybeRefOrGetter<boolean>;
+    disableRender: MaybeRefOrGetter<boolean>;
+    rendererOptions: UseRendererOptions;
+    emit: (event: string, ...args: any[]) => void;
+}): TresContext;
+export declare function useTresContext(): TresContext;
+export declare const useTres: typeof useTresContext;

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

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

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

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

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

@@ -0,0 +1,6 @@
+import type { Object3D } from 'three';
+import type { Ref } from 'vue';
+import type { TresVector3 } from '../types';
+export declare const vAlwaysLookAt: {
+    updated: (el: Object3D, binding: Ref<TresVector3>) => void;
+};

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

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

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

@@ -0,0 +1,6 @@
+import type { TresObject } from '../types';
+export declare const vLightHelper: {
+    mounted: (el: TresObject) => void;
+    updated: (el: TresObject) => void;
+    unmounted: (el: TresObject) => void;
+};

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

@@ -0,0 +1,6 @@
+import type { TresObject } from '../types';
+export declare const vLog: {
+    mounted: (el: TresObject, binding: {
+        arg: string;
+    }) => void;
+};

package/dist/src/index.d.ts

@@ -0,0 +1,18 @@
+import type { App } from 'vue';
+import { normalizeColor, normalizeVectorFlexibleParam } from './utils/normalize';
+import templateCompilerOptions from './utils/template-compiler-options';
+export * from './composables';
+export * from './core/catalogue';
+export * from './components';
+export * from './types';
+export * from './directives';
+export interface TresOptions {
+    extends?: Record<string, unknown>;
+}
+export interface TresPlugin {
+    [key: string]: any;
+    install: (app: App, options?: TresOptions) => void;
+}
+declare const plugin: TresPlugin;
+export default plugin;
+export { normalizeColor, normalizeVectorFlexibleParam, templateCompilerOptions, };

package/dist/{types → src/types}/index.d.ts

@@ -1,6 +1,6 @@
 import type { DefineComponent, VNode, VNodeRef } from 'vue';
 import type * as THREE from 'three';
-import type { EventProps as PointerEventHandlerEventProps } from '../composables/usePointerEventHandler';
+import type { TresContext } from '../composables/useTresContextProvider';
 export type AttachFnType<O = any> = (parent: any, self: O) => () => void;
 export type AttachType<O = any> = string | AttachFnType<O>;
 export type ConstructorRepresentation = new (...args: any[]) => any;
@@ -30,25 +30,29 @@ interface TresBaseObject {
     dispose?: () => void;
     [prop: string]: any;
 }
-export interface TresObject3D extends THREE.Object3D {
-    geometry?: THREE.BufferGeometry & TresBaseObject;
-    material?: THREE.Material & TresBaseObject;
-    userData: {
-        tres__materialViaProp: boolean;
-        tres__geometryViaProp: boolean;
+export interface LocalState {
+    type: string;
+    objects: TresObject3D[];
+    parent: TresObject3D | null;
+    primitive?: boolean;
+    eventCount: number;
+    handlers: Partial<EventHandlers>;
+    memoizedProps: {
         [key: string]: any;
     };
+    disposable: boolean;
+    root: TresContext;
 }
-export type TresObject = TresBaseObject & (TresObject3D | THREE.BufferGeometry | THREE.Material | THREE.Fog);
+export interface TresObject3D extends THREE.Object3D<THREE.Object3DEventMap> {
+    geometry?: THREE.BufferGeometry & TresBaseObject;
+    material?: THREE.Material & TresBaseObject;
+}
+export type TresObject = TresBaseObject & (TresObject3D | THREE.BufferGeometry | THREE.Material | THREE.Fog) & {
+    __tres: LocalState;
+};
 export interface TresScene extends THREE.Scene {
-    userData: {
-        tres__registerCamera?: (newCamera: THREE.Camera, active?: boolean) => void;
-        tres__deregisterCamera?: (camera: THREE.Camera) => void;
-        tres__registerAtPointerEventHandler?: (object: THREE.Object3D & PointerEventHandlerEventProps) => void;
-        tres__deregisterAtPointerEventHandler?: (object: THREE.Object3D) => void;
-        tres__registerBlockingObjectAtPointerEventHandler?: (object: THREE.Object3D) => void;
-        tres__deregisterBlockingObjectAtPointerEventHandler?: (object: THREE.Object3D) => void;
-        [key: string]: any;
+    __tres: {
+        root: TresContext;
     };
 }
 export interface Intersection extends THREE.Intersection {

package/dist/{utils → src/utils}/index.d.ts

@@ -1,5 +1,5 @@
-import { MeshBasicMaterial } from 'three';
-import type { Mesh, type Scene, type Object3D } from 'three';
+import { MeshBasicMaterial, Vector3 } from 'three';
+import type { Mesh, Scene, Object3D } from 'three';
 export declare function toSetMethodName(key: string): string;
 export declare const merge: (target: any, source: any) => any;
 export declare const isHTMLTag: (key: string) => boolean;
@@ -20,3 +20,4 @@ export declare function createHighlightMaterial(): MeshBasicMaterial;
 export declare function animateHighlight(highlightMesh: Mesh, startTime: number): void;
 export declare function stopHighlightAnimation(): void;
 export declare function createHighlightMesh(object: Object3D): Mesh;
+export declare function extractBindingPosition(binding: any): Vector3;