@tresjs/core 2.4.0-next.4 → 2.4.1

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

@@ -1,5 +1,4 @@
-import type { TresContext } from '../useTresContextProvider';
-import type { Intersection, Event, Object3D, Scene } from 'three';
+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 = {
@@ -8,7 +7,7 @@ type EventProps = {
     onPointerMove?: CallbackFn;
     onPointerLeave?: CallbackFnPointerLeave;
 };
-export declare const usePointerEventHandler: (scene: Scene, contextParts: Pick<TresContext, 'renderer' | 'camera'>) => {
+export declare const usePointerEventHandler: () => {
     registerObject: (object: Object3D & EventProps) => void;
     deregisterObject: (object: Object3D) => void;
 };

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

@@ -1,7 +1,6 @@
-import { type Intersection, Object3D } from 'three';
+import { Object3D } from 'three';
 import { Ref } from 'vue';
-import type { TresContext } from '../useTresContextProvider';
-export type Intersects = Intersection<THREE.Object3D<THREE.Event>>[];
+export type Intersects = THREE.Intersection<THREE.Object3D<THREE.Event>>[];
 interface PointerMoveEventPayload {
     intersects?: Intersects;
     event: PointerEvent;
@@ -10,7 +9,7 @@ interface PointerClickEventPayload {
     intersects: Intersects;
     event: PointerEvent;
 }
-export declare const useRaycaster: (objects: Ref<THREE.Object3D[]>, { renderer, camera }: Pick<TresContext, 'renderer' | 'camera'>) => {
+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;

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

@@ -14,4 +14,4 @@ export interface UseRenderLoopReturn {
     resume: Fn;
     isActive: Ref<boolean>;
 }
-export declare const useRenderLoop: () => UseRenderLoopReturn;
+export declare function useRenderLoop(): UseRenderLoopReturn;

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

@@ -1,15 +1,9 @@
-import { WebGLRenderer } from 'three';
-import { RendererPresetsType } from './const';
-import { type MaybeRef } from 'vue';
-import { type MaybeRefOrGetter } from '@vueuse/core';
+import { MaybeRefOrGetter } from '@vueuse/core';
+import { WebGLRendererParameters, WebGLRenderer, ShadowMapType, ColorSpace } from 'three';
+import type { ToneMapping } from 'three';
 import { TresColor } from '../../types';
-import type { Scene, ToneMapping } from 'three';
-import type { TresContext } from '../useTresContextProvider';
-import type { ColorSpace, ShadowMapType, WebGLRendererParameters } from 'three';
-type TransformToMaybeRefOrGetter<T> = {
-    [K in keyof T]: MaybeRefOrGetter<T[K]> | MaybeRefOrGetter<T[K]>;
-};
-export interface UseRendererOptions extends TransformToMaybeRefOrGetter<WebGLRendererParameters> {
+import { RendererPresetsType } from './const';
+export interface UseRendererOptions extends WebGLRendererParameters {
     /**
      * Enable shadows in the Renderer
      *
@@ -48,10 +42,7 @@ export interface UseRendererOptions extends TransformToMaybeRefOrGetter<WebGLRen
     outputColorSpace?: MaybeRefOrGetter<ColorSpace>;
     /**
      * Defines the tone mapping used by the renderer.
-     * Can be NoToneMapping, LinearToneMapping,
-     * ReinhardToneMapping, Uncharted2ToneMapping,
-     * CineonToneMapping, ACESFilmicToneMapping,
-     * CustomToneMapping
+     * Can be NoToneMapping, LinearToneMapping, ReinhardToneMapping, Uncharted2ToneMapping, CineonToneMapping, ACESFilmicToneMapping, CustomToneMapping
      *
      * @default NoToneMapping
      */
@@ -62,6 +53,25 @@ export interface UseRendererOptions extends TransformToMaybeRefOrGetter<WebGLRen
      * @default 1
      */
     toneMappingExposure?: MaybeRefOrGetter<number>;
+    /**
+     * The context used by the renderer.
+     *
+     * @default undefined
+     */
+    context?: WebGLRenderingContext | undefined;
+    /**
+     * Provides a hint to the user agent indicating what configuration of GPU is suitable for this WebGL context.
+     * Can be "high-performance", "low-power" or "default".
+     *
+     * @default "default"
+     */
+    powerPreference?: 'high-performance' | 'low-power' | 'default';
+    /**
+     * Whether to preserve the buffers until manually cleared or overwritten.
+     *
+     * @default false
+     */
+    preserveDrawingBuffer?: boolean;
     /**
      * The color value to use when clearing the canvas.
      *
@@ -69,7 +79,7 @@ export interface UseRendererOptions extends TransformToMaybeRefOrGetter<WebGLRen
      */
     clearColor?: MaybeRefOrGetter<TresColor>;
     windowSize?: MaybeRefOrGetter<boolean | string>;
-    preset?: MaybeRefOrGetter<RendererPresetsType>;
+    preset?: RendererPresetsType;
 }
 /**
  * Reactive Three.js WebGLRenderer instance
@@ -77,14 +87,10 @@ export interface UseRendererOptions extends TransformToMaybeRefOrGetter<WebGLRen
  * @param canvas
  * @param {UseRendererOptions} [options]
  */
-export declare function useRenderer({ scene, canvas, options, disableRender, contextParts: { sizes, camera }, }: {
-    canvas: MaybeRef<HTMLCanvasElement>;
-    scene: Scene;
-    options: UseRendererOptions;
-    contextParts: Pick<TresContext, 'sizes' | 'camera'>;
-    disableRender: MaybeRefOrGetter<boolean>;
-}): {
-    renderer: import("vue").ShallowRef<WebGLRenderer>;
+export declare function useRenderer(options: UseRendererOptions): {
+    renderer: import("vue").ShallowRef<WebGLRenderer | undefined>;
+    isReady: import("vue").Ref<boolean>;
+    dispose: () => void;
+    aspectRatio: import("vue").ComputedRef<number>;
 };
 export type UseRendererReturn = ReturnType<typeof useRenderer>;
-export {};

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

@@ -0,0 +1,142 @@
+import { Clock, EventDispatcher, Raycaster, Scene, Vector2, WebGLRenderer } from 'three';
+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.
+     *
+     * @see https://threejs.org/docs/index.html?q=camera#api/en/cameras/Camera
+     *
+     * @type {Camera}
+     * @memberof TresState
+     */
+    camera?: Camera;
+    /**
+     * All cameras available in the scene.
+     *
+     * @see https://threejs.org/docs/index.html?q=camera#api/en/cameras/Camera
+     *
+     * @type {Camera[]}
+     * @memberof TresState
+     */
+    cameras?: Camera[];
+    /**
+     * The aspect ratio of the scene.
+     *
+     * @type {ComputedRef<number>}
+     * @memberof TresState
+     */
+    aspectRatio?: ComputedRef<number>;
+    /**
+     * The WebGLRenderer used to display the scene using WebGL.
+     *
+     * @see https://threejs.org/docs/index.html?q=webglren#api/en/renderers/WebGLRenderer
+     *
+     * @type {WebGLRenderer}
+     * @memberof TresState
+     */
+    renderer?: WebGLRenderer;
+    /**
+     * The scene. This is the place where you place objects, lights and cameras.
+     *
+     * @see https://threejs.org/docs/index.html?q=scene#api/en/scenes/Scene
+     *
+     * @type {Scene}
+     * @memberof TresState
+     */
+    scene?: Scene;
+    /**
+     * The raycaster.
+     *
+     * @see https://threejs.org/docs/index.html?q=raycas#api/en/core/Raycaster
+     *
+     * @type {Raycaster}
+     * @memberof TresState
+     */
+    raycaster?: Raycaster;
+    /**
+     * Object for keeping track of time. This uses `performance.now` if it is available,
+     * otherwise it reverts to the less accurate `Date.now`.
+     *
+     * @see https://threejs.org/docs/index.html?q=clock#api/en/core/Clock
+     *
+     * @type {Clock}
+     * @memberof TresState
+     */
+    clock?: Clock;
+    /**
+     * The current mouse position.
+     *
+     * @type {Vector2}
+     * @memberof TresState
+     */
+    pointer?: Vector2;
+    /**
+     * The current instance of the component.
+     *
+     * @type {*}
+     * @memberof TresState
+     */
+    currentInstance?: any;
+    /**
+     *  The current active scene control
+     *
+     * @type {((EventDispatcher & { enabled: boolean }) | null)}
+     * @memberof 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 = {
+    state: TresState;
+    getState: (key: string) => void;
+    setState: (key: string, value: any) => void;
+    aspectRatio: ComputedRef<number>;
+};
+export declare const TRES_CONTEXT_KEY: unique symbol;
+/**
+ * The Tres state.
+ *
+ * @see https://threejs.org/docs/index.html?q=scene#api/en/scenes/Scene
+ *
+ * @export
+ * @return {*} {TresState, getState, setState}
+ */
+export declare function useTresProvider(): {
+    getState: (key: string) => any;
+    setState: (key: string, value: any) => void;
+    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/index.d.ts

@@ -3,7 +3,6 @@ export * from './composables';
 export * from './core/catalogue';
 export * from './components';
 export * from './types';
-import { useTresContext, type TresContext } from './composables';
 import { normalizeColor, normalizeVectorFlexibleParam } from './utils/normalize';
 import templateCompilerOptions from './utils/template-compiler-options';
 export interface TresOptions {
@@ -15,4 +14,4 @@ export interface TresPlugin {
 }
 declare const plugin: TresPlugin;
 export default plugin;
-export { TresContext, useTresContext, normalizeColor, normalizeVectorFlexibleParam, templateCompilerOptions };
+export { normalizeColor, normalizeVectorFlexibleParam, templateCompilerOptions };

package/dist/keys.d.ts

@@ -1,9 +1,6 @@
+export declare const UseTresStateSymbol: unique symbol;
 export declare const OBJECT_3D_USER_DATA_KEYS: {
-    REGISTER_CAMERA: string;
-    IS_ACTIVE_CAMERA: string;
     GEOMETRY_VIA_PROP: string;
     MATERIAL_VIA_PROP: string;
-    DEREGISTER_CAMERA: string;
     REGISTER_AT_POINTER_EVENT_HANDLER: string;
-    DEREGISTER_AT_POINTER_EVENT_HANDLER: string;
 };