@tresjs/core 2.1.3 → 2.2.0

package/README.md

@@ -39,7 +39,8 @@ Checkout the [docs](https://tresjs.org)
 | Package                     | Version                                                                                            |
 | --------------------------- | :------------------------------------------------------------------------------------------------- |
 | [Tres](packages/tres)       | ![tres version](https://img.shields.io/npm/v/@tresjs/core/latest.svg?label=%20&color=%2382DBCA)    |
-| [Cientos](packages/cientos) | ![tres version](https://img.shields.io/npm/v/@tresjs/cientos/latest.svg?label=%20&color=%23f19b00) |
+| [Cientos](packages/cientos) | ![cientos version](https://img.shields.io/npm/v/@tresjs/cientos/latest.svg?label=%20&color=%23f19b00) |
+| [Post-processing](packages/post-processing) | ![post-processing version](https://img.shields.io/npm/v/@tresjs/post-processing/latest.svg?label=%20&color=%ff7bac00) |
 
 ## Contribution
 

package/dist/composables/index.d.ts

@@ -7,3 +7,4 @@ export * from './useTres';
 export * from './useRaycaster';
 export * from './useLogger';
 export * from './useSeek';
+export * from './usePointerEventHandler';

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

@@ -0,0 +1,14 @@
+import type { Intersection, Event, Object3D } from 'three';
+type CallbackFn = (intersection: Intersection<Object3D<Event>>, event: PointerEvent) => void;
+type CallbackFnPointerLeave = (object: Object3D<Event>, event: PointerEvent) => void;
+type EventProps = {
+    onClick?: CallbackFn;
+    onPointerEnter?: CallbackFn;
+    onPointerMove?: CallbackFn;
+    onPointerLeave?: CallbackFnPointerLeave;
+};
+export declare const usePointerEventHandler: () => {
+    registerObject: (object: Object3D & EventProps) => void;
+    deregisterObject: (object: Object3D) => void;
+};
+export {};

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

@@ -1,32 +1,17 @@
-import { Raycaster, Vector2 } from 'three';
-import { Ref, ShallowRef } from 'vue';
-/**
- * Raycaster composable return type
- *
- * @export
- * @interface UseRaycasterReturn
- */
-export interface UseRaycasterReturn {
-    /**
-     * Raycaster instance
-     *
-     * @type {ShallowRef<Raycaster>}
-     * @memberof UseRaycasterReturn
-     */
-    raycaster: ShallowRef<Raycaster>;
-    /**
-     * Pointer position
-     *
-     * @type {Ref<Vector2>}
-     * @memberof UseRaycasterReturn
-     */
-    pointer: Ref<Vector2>;
+import { Object3D } from 'three';
+import { Ref } from 'vue';
+export type Intersects = THREE.Intersection<THREE.Object3D<THREE.Event>>[];
+interface PointerMoveEventPayload {
+    intersects?: Intersects;
+    event: PointerEvent;
 }
-/**
- * Composable to provide raycaster support and pointer information
- *
- * @see https://threejs.org/docs/index.html?q=raycas#api/en/core/Raycaster
- * @export
- * @return {*} {UseRaycasterReturn}
- */
-export declare function useRaycaster(): UseRaycasterReturn;
+interface PointerClickEventPayload {
+    intersects: Intersects;
+    event: PointerEvent;
+}
+export declare const useRaycaster: (objects: Ref<THREE.Object3D[]>) => {
+    intersects: import("vue").ComputedRef<Intersects>;
+    onClick: (fn: (value: PointerClickEventPayload) => void) => () => void;
+    onPointerMove: (fn: (value: PointerMoveEventPayload) => void) => () => void;
+};
+export {};

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

@@ -1,6 +1,7 @@
 import { Clock, EventDispatcher, Raycaster, Scene, Vector2, WebGLRenderer } from 'three';
-import { ComputedRef } from 'vue';
+import { ComputedRef, Ref } from 'vue';
 import { Camera } from '../useCamera';
+import type { usePointerEventHandler } from '../usePointerEventHandler';
 export interface TresState {
     /**
      * The active camera used for rendering the scene.
@@ -87,6 +88,13 @@ export interface TresState {
     controls?: (EventDispatcher & {
         enabled: boolean;
     }) | null;
+    canvas?: Ref<HTMLElement>;
+    /**
+     * The entity that handles pointer events
+     * @type {ReturnType<typeof usePointerEventHandler>}
+     * @memberof TresState
+     */
+    pointerEventHandler?: ReturnType<typeof usePointerEventHandler>;
     [key: string]: any;
 }
 export type UseTresReturn = {
@@ -107,18 +115,28 @@ export declare const TRES_CONTEXT_KEY: unique symbol;
 export declare function useTresProvider(): {
     getState: (key: string) => any;
     setState: (key: string, value: any) => void;
-    camera?: import("vue").Ref<Camera | undefined> | undefined;
-    cameras?: import("vue").Ref<Camera[] | undefined> | undefined;
-    aspectRatio?: import("vue").Ref<ComputedRef<number> | undefined> | undefined;
-    renderer?: import("vue").Ref<WebGLRenderer | undefined> | undefined;
-    scene?: import("vue").Ref<Scene | undefined> | undefined;
-    raycaster?: import("vue").Ref<Raycaster | undefined> | undefined;
-    clock?: import("vue").Ref<Clock | undefined> | undefined;
-    pointer?: import("vue").Ref<Vector2 | undefined> | undefined;
-    currentInstance?: import("vue").Ref<any> | undefined;
-    controls?: import("vue").Ref<(EventDispatcher<import("three").Event> & {
+    camera?: Ref<Camera | undefined> | undefined;
+    cameras?: Ref<Camera[] | undefined> | undefined;
+    aspectRatio?: Ref<ComputedRef<number> | undefined> | undefined;
+    renderer?: Ref<WebGLRenderer | undefined> | undefined;
+    scene?: Ref<Scene | undefined> | undefined;
+    raycaster?: Ref<Raycaster | undefined> | undefined;
+    clock?: Ref<Clock | undefined> | undefined;
+    pointer?: Ref<Vector2 | undefined> | undefined;
+    currentInstance?: Ref<any> | undefined;
+    controls?: Ref<(EventDispatcher<import("three").Event> & {
         enabled: boolean;
     }) | null | undefined> | undefined;
+    canvas?: Ref<Ref<HTMLElement> | undefined> | undefined;
+    pointerEventHandler?: Ref<{
+        registerObject: (object: import("three").Object3D<import("three").Event> & {
+            onClick?: ((intersection: import("three").Intersection<import("three").Object3D<import("three").Event>>, event: PointerEvent) => void) | undefined;
+            onPointerEnter?: ((intersection: import("three").Intersection<import("three").Object3D<import("three").Event>>, event: PointerEvent) => void) | undefined;
+            onPointerMove?: ((intersection: import("three").Intersection<import("three").Object3D<import("three").Event>>, event: PointerEvent) => void) | undefined;
+            onPointerLeave?: ((object: import("three").Object3D<import("three").Event>, event: PointerEvent) => void) | undefined;
+        }) => void;
+        deregisterObject: (object: import("three").Object3D<import("three").Event>) => void;
+    } | undefined> | undefined;
     state: TresState;
 };
 export declare const useTres: () => UseTresReturn;

package/dist/keys.d.ts

@@ -0,0 +1,6 @@
+export declare const UseTresStateSymbol: unique symbol;
+export declare const OBJECT_3D_USER_DATA_KEYS: {
+    GEOMETRY_VIA_PROP: string;
+    MATERIAL_VIA_PROP: string;
+    REGISTER_AT_POINTER_EVENT_HANDLER: string;
+};