@tresjs/core 4.1.0 → 4.2.0

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

@@ -1,10 +1,10 @@
-import { Intersection, Object3D } from 'three';
-import { Ref, ShallowRef } from 'vue';
-import { TresEvent } from 'src/types';
+import { Intersection, Object3D, Object3DEventMap } from 'three';
+import { ShallowRef } from 'vue';
+import { TresEvent, TresInstance } from 'src/types';
 import { TresContext } from '../useTresContextProvider';
 
-export declare const useRaycaster: (objectsWithEvents: Ref<Object3D[]>, ctx: TresContext) => {
-    intersects: ShallowRef<Intersection<Object3D<import('three').Object3DEventMap>>[]>;
+export declare const useRaycaster: (objectsWithEvents: ShallowRef<TresInstance[]>, ctx: TresContext) => {
+    intersects: ShallowRef<Intersection<Object3D<Object3DEventMap>>[]>;
     onClick: (fn: (value: TresEvent) => void) => () => void;
     onDblClick: (fn: (value: TresEvent) => void) => () => void;
     onContextMenu: (fn: (value: TresEvent) => void) => () => void;

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

@@ -70,6 +70,11 @@ export interface UseRendererOptions extends TransformToMaybeRefOrGetter<WebGLRen
     windowSize?: MaybeRefOrGetter<boolean | string>;
     preset?: MaybeRefOrGetter<RendererPresetsType>;
     renderMode?: MaybeRefOrGetter<'always' | 'on-demand' | 'manual'>;
+    /**
+     * A `number` sets the renderer's device pixel ratio.
+     * `[number, number]` clamp's the renderer's device pixel ratio.
+     */
+    dpr?: MaybeRefOrGetter<number | [number, number]>;
 }
 export declare function useRenderer({ canvas, options, contextParts: { sizes, render, invalidate, advance }, }: {
     canvas: MaybeRef<HTMLCanvasElement>;

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

@@ -2,7 +2,6 @@ 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';
@@ -62,7 +61,7 @@ export interface TresContext {
     setCameraActive: (cameraOrUuid: Camera | string) => void;
     deregisterCamera: (maybeCamera: unknown) => void;
     eventManager?: TresEventManager;
-    registerObjectAtPointerEventHandler?: (object: TresObject & EventProps) => void;
+    registerObjectAtPointerEventHandler?: (object: TresObject) => void;
     deregisterObjectAtPointerEventHandler?: (object: TresObject) => void;
     registerBlockingObjectAtPointerEventHandler?: (object: TresObject) => void;
     deregisterBlockingObjectAtPointerEventHandler?: (object: TresObject) => void;

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

@@ -12,11 +12,15 @@ export interface TresEventManager {
      * So we need to track them separately
      * Note: These are used in nodeOps
      */
+    registerObject: (object: unknown) => void;
+    deregisterObject: (object: unknown) => void;
     registerPointerMissedObject: (object: unknown) => void;
     deregisterPointerMissedObject: (object: unknown) => void;
 }
 export declare function useTresEventManager(scene: Scene, context: TresContext, emit: EmitEventFn): {
     forceUpdate: () => void;
+    registerObject: (maybeTresObject: unknown) => void;
+    deregisterObject: (maybeTresObject: unknown) => void;
     registerPointerMissedObject: (maybeTresObject: unknown) => void;
     deregisterPointerMissedObject: (maybeTresObject: unknown) => void;
 };

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

@@ -2,8 +2,9 @@ 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;
-export type AttachType<O = any> = string | AttachFnType<O>;
+export type AttachFnType = (parent: any, self: TresInstance) => () => void;
+export type AttachType = string | AttachFnType;
+export type DisposeType = ((self: TresInstance) => void) | boolean | 'default';
 export type ConstructorRepresentation = new (...args: any[]) => any;
 export type NonFunctionKeys<P> = {
     [K in keyof P]-?: P[K] extends Function ? never : K;
@@ -25,11 +26,9 @@ export interface InstanceProps<T = any, P = any> {
     object?: T;
     visible?: boolean;
     dispose?: null;
-    attach?: AttachType<T>;
     [prop: string]: any;
 }
 interface TresBaseObject {
-    attach?: string;
     removeFromParent?: () => void;
     dispose?: () => void;
     [prop: string]: any;
@@ -45,7 +44,9 @@ export interface LocalState {
     objects: TresObject[];
     parent: TresObject | null;
     primitive?: boolean;
-    disposable?: boolean;
+    dispose?: DisposeType;
+    attach?: AttachType;
+    previousAttach: any;
 }
 export interface TresObject3D extends THREE.Object3D<THREE.Object3DEventMap> {
     geometry?: THREE.BufferGeometry & TresBaseObject;
@@ -57,6 +58,10 @@ export type TresObject = TresBaseObject & (TresObject3D | THREE.BufferGeometry |
 export type TresInstance = TresObject & {
     __tres: LocalState;
 };
+export type TresPrimitive = TresInstance & {
+    object: TresInstance;
+    isPrimitive: true;
+};
 export interface TresScene extends THREE.Scene {
     __tres: {
         root: TresContext;

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

@@ -1,5 +1,7 @@
 import { Material, Mesh, MeshBasicMaterial, Scene, Vector3 } from 'three';
-import { TresObject } from 'src/types';
+import { AttachType, LocalState, TresInstance, TresObject, TresPrimitive } from 'src/types';
+import { nodeOps } from 'src/core/nodeOps';
+import { TresContext } from '../composables/useTresContextProvider';
 
 export declare function toSetMethodName(key: string): string;
 export declare const merge: (target: any, source: any) => any;
@@ -31,3 +33,20 @@ export declare function disposeObject3D(object: TresObject): void;
  * @param callbackFn - A function called for each element of the array. It should return a truthy value to keep the element in the array.
  */
 export declare function filterInPlace<T>(array: T[], callbackFn: (element: T, index: number) => unknown): T[];
+export declare function resolve(obj: Record<string, any>, key: string): {
+    target: Record<string, any>;
+    key: string;
+};
+export declare function attach(parent: TresInstance, child: TresInstance, type: AttachType): void;
+export declare function detach(parent: any, child: TresInstance, type: AttachType): void;
+export declare function prepareTresInstance<T extends TresObject>(obj: T, state: Partial<LocalState>, context: TresContext): TresInstance;
+export declare function invalidateInstance(instance: TresObject): void;
+export declare function noop(fn: string): any;
+export declare function setPixelRatio(renderer: {
+    setPixelRatio?: (dpr: number) => void;
+    getPixelRatio?: () => number;
+}, systemDpr: number, userDpr?: number | [number, number]): void;
+export declare function setPrimitiveObject(newObject: TresObject, primitive: TresPrimitive, setTarget: (object: TresObject) => void, nodeOpsFns: Pick<ReturnType<typeof nodeOps>, 'patchProp' | 'insert' | 'remove'>, context: TresContext): boolean;
+export declare function unboxTresPrimitive<T>(maybePrimitive: T): T | TresInstance;
+export declare function doRemoveDetach(node: TresObject, context: TresContext): void;
+export declare function doRemoveDeregister(node: TresObject, context: TresContext): void;

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

@@ -1,7 +1,11 @@
-import { TresObject } from 'src/types';
-import { BufferGeometry, Camera, Fog, Material, Object3D } from 'three';
+import { TresObject, TresPrimitive } from 'src/types';
+import { BufferGeometry, Camera, Fog, Material, Object3D, Scene } from 'three';
 
-export declare function arr(u: unknown): boolean;
+export declare function und(u: unknown): u is undefined;
+export declare function arr(u: unknown): u is any[];
+export declare function num(u: unknown): u is number;
+export declare function str(u: unknown): u is string;
+export declare function bool(u: unknown): u is boolean;
 export declare function fun(u: unknown): u is Function;
 export declare function obj(u: unknown): u is Record<string | number | symbol, unknown>;
 export declare function object3D(u: unknown): u is Object3D;
@@ -9,4 +13,6 @@ export declare function camera(u: unknown): u is Camera;
 export declare function bufferGeometry(u: unknown): u is BufferGeometry;
 export declare function material(u: unknown): u is Material;
 export declare function fog(u: unknown): u is Fog;
+export declare function scene(u: unknown): u is Scene;
 export declare function tresObject(u: unknown): u is TresObject;
+export declare function tresPrimitive(u: unknown): u is TresPrimitive;

package/dist/src/utils/primitive/createRetargetingProxy.d.ts

@@ -0,0 +1 @@
+export declare function createRetargetingProxy<T extends Record<string | number | symbol, any>, K extends keyof T & string & symbol>(target: T, getters?: Record<string | number | symbol, (t: T) => unknown>, setters?: Partial<Record<K, (val: T[K], t: T, proxy: T, setTarget: (newTarget: T) => void) => boolean>>): T;