@tresjs/core 2.4.2 → 3.0.0

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

@@ -1,13 +1,18 @@
+import type { TresContext } from '../useTresContextProvider';
 import type { Intersection, Event, Object3D } from 'three';
+import { TresScene } from 'src/types';
 type CallbackFn = (intersection: Intersection<Object3D<Event>>, event: PointerEvent) => void;
 type CallbackFnPointerLeave = (object: Object3D<Event>, event: PointerEvent) => void;
-type EventProps = {
+export type EventProps = {
     onClick?: CallbackFn;
     onPointerEnter?: CallbackFn;
     onPointerMove?: CallbackFn;
     onPointerLeave?: CallbackFnPointerLeave;
 };
-export declare const usePointerEventHandler: () => {
+export declare const usePointerEventHandler: ({ scene, contextParts }: {
+    scene: TresScene;
+    contextParts: Pick<TresContext, 'renderer' | 'camera' | 'raycaster'>;
+}) => {
     registerObject: (object: Object3D & EventProps) => void;
     deregisterObject: (object: Object3D) => void;
 };

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

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

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

@@ -1,9 +1,15 @@
-import { MaybeRefOrGetter } from '@vueuse/core';
-import { WebGLRendererParameters, WebGLRenderer, ShadowMapType, ColorSpace } from 'three';
-import type { ToneMapping } from 'three';
-import { TresColor } from '../../types';
+import { WebGLRenderer } from 'three';
 import { RendererPresetsType } from './const';
-export interface UseRendererOptions extends WebGLRendererParameters {
+import { type MaybeRef } from 'vue';
+import { type MaybeRefOrGetter } from '@vueuse/core';
+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> {
     /**
      * Enable shadows in the Renderer
      *
@@ -42,7 +48,10 @@ export interface UseRendererOptions extends WebGLRendererParameters {
     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
      */
@@ -53,25 +62,6 @@ export interface UseRendererOptions extends WebGLRendererParameters {
      * @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.
      *
@@ -79,7 +69,7 @@ export interface UseRendererOptions extends WebGLRendererParameters {
      */
     clearColor?: MaybeRefOrGetter<TresColor>;
     windowSize?: MaybeRefOrGetter<boolean | string>;
-    preset?: RendererPresetsType;
+    preset?: MaybeRefOrGetter<RendererPresetsType>;
 }
 /**
  * Reactive Three.js WebGLRenderer instance
@@ -87,10 +77,14 @@ export interface UseRendererOptions extends WebGLRendererParameters {
  * @param canvas
  * @param {UseRendererOptions} [options]
  */
-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 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 type UseRendererReturn = ReturnType<typeof useRenderer>;
+export {};

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

@@ -0,0 +1,27 @@
+import { Camera, Raycaster, Scene, WebGLRenderer } from 'three';
+import { UseRendererOptions } from '../useRenderer';
+import type { ComputedRef, DeepReadonly, MaybeRef, MaybeRefOrGetter, Ref, ShallowRef } from 'vue';
+export type TresContext = {
+    scene: ShallowRef<Scene>;
+    camera: ComputedRef<Camera | undefined>;
+    cameras: DeepReadonly<Ref<Camera[]>>;
+    renderer: ShallowRef<WebGLRenderer>;
+    raycaster: ShallowRef<Raycaster>;
+    addCamera: (camera: Camera) => void;
+    removeCamera: (camera: Camera) => void;
+    setCameraActive: (cameraOrUuid: Camera | string) => void;
+    sizes: {
+        height: Ref<number>;
+        width: Ref<number>;
+        aspectRatio: ComputedRef<number>;
+    };
+};
+export declare function useTresContextProvider({ scene, canvas, windowSize, disableRender, rendererOptions }: {
+    scene: Scene;
+    canvas: MaybeRef<HTMLCanvasElement>;
+    windowSize: MaybeRefOrGetter<boolean>;
+    disableRender: MaybeRefOrGetter<boolean>;
+    rendererOptions: UseRendererOptions;
+}): TresContext;
+export declare function useTresContext(): TresContext;
+export declare const useTres: typeof useTresContext;

package/dist/core/nodeOps.d.ts

@@ -1,4 +1,4 @@
 import { RendererOptions } from 'vue';
-import { TresObject } from '../types';
+import type { TresObject } from '../types';
 export declare const isOn: (key: string) => boolean;
 export declare const nodeOps: RendererOptions<TresObject, TresObject>;

package/dist/index.d.ts

@@ -3,6 +3,7 @@ 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 {
@@ -14,4 +15,4 @@ export interface TresPlugin {
 }
 declare const plugin: TresPlugin;
 export default plugin;
-export { normalizeColor, normalizeVectorFlexibleParam, templateCompilerOptions };
+export { TresContext, useTresContext, normalizeColor, normalizeVectorFlexibleParam, templateCompilerOptions };