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

package/dist/src/components/TresCanvas.vue.d.ts

@@ -1,85 +1,87 @@
-import { ColorSpace, ShadowMapType, ToneMapping, WebGLRendererParameters } from 'three';
-import { RendererPresetsType } from '../composables/useRenderer/const';
 import { TresCamera } from '../types/';
-import { TresContext } from '../composables';
-export interface TresCanvasProps extends Omit<WebGLRendererParameters, 'canvas'> {
-    shadows?: boolean;
-    clearColor?: string;
-    toneMapping?: ToneMapping;
-    shadowMapType?: ShadowMapType;
-    useLegacyLights?: boolean;
-    outputColorSpace?: ColorSpace;
-    toneMappingExposure?: number;
-    renderMode?: 'always' | 'on-demand' | 'manual';
-    dpr?: number | [number, number];
+import { PointerEvent } from '@pmndrs/pointer-events';
+import { RendererOptions, TresContext, TresRenderer } from '../composables';
+import * as THREE from 'three';
+export interface TresCanvasProps extends RendererOptions {
+    /**
+     * Custom camera instance to use as main camera
+     * If not provided, a default PerspectiveCamera will be created
+     */
     camera?: TresCamera;
-    preset?: RendererPresetsType;
+    /**
+     * Whether the canvas should be sized to the window
+     * When true, canvas will be fixed positioned and full viewport size
+     * @default false
+     */
     windowSize?: boolean;
+    /**
+     * Whether to enable the provide/inject bridge between Vue and TresJS
+     * When true, Vue's provide/inject will work across the TresJS boundary
+     * @default true
+     */
     enableProvideBridge?: boolean;
 }
-declare function __VLS_template(): {
-    attrs: Partial<{}>;
-    slots: Readonly<{
-        default: () => any;
-    }> & {
-        default: () => any;
-    };
-    refs: {
-        canvas: HTMLCanvasElement;
-    };
-    rootEl: HTMLCanvasElement;
-};
-type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
-declare const __VLS_component: import('vue').DefineComponent<TresCanvasProps, {
+declare const _default: __VLS_WithTemplateSlots<import('vue').DefineComponent<TresCanvasProps, {
     context: import('vue').ShallowRef<TresContext | null, TresContext | null>;
     dispose: () => void;
 }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
-    render: (...args: any[]) => void;
-    click: (...args: any[]) => void;
-    wheel: (...args: any[]) => void;
-    ready: (...args: any[]) => void;
-    "double-click": (...args: any[]) => void;
-    "context-menu": (...args: any[]) => void;
-    "pointer-move": (...args: any[]) => void;
-    "pointer-up": (...args: any[]) => void;
-    "pointer-down": (...args: any[]) => void;
-    "pointer-enter": (...args: any[]) => void;
-    "pointer-leave": (...args: any[]) => void;
-    "pointer-over": (...args: any[]) => void;
-    "pointer-out": (...args: any[]) => void;
-    "pointer-missed": (...args: any[]) => void;
+    render: (renderer: TresRenderer) => any;
+    click: (event: PointerEvent<MouseEvent>) => any;
+    contextmenu: (event: PointerEvent<MouseEvent>) => any;
+    pointermove: (event: PointerEvent<MouseEvent>) => any;
+    pointerenter: (event: PointerEvent<MouseEvent>) => any;
+    pointerleave: (event: PointerEvent<MouseEvent>) => any;
+    pointerover: (event: PointerEvent<MouseEvent>) => any;
+    pointerout: (event: PointerEvent<MouseEvent>) => any;
+    dblclick: (event: PointerEvent<MouseEvent>) => any;
+    pointerdown: (event: PointerEvent<MouseEvent>) => any;
+    pointerup: (event: PointerEvent<MouseEvent>) => any;
+    pointercancel: (event: PointerEvent<MouseEvent>) => any;
+    lostpointercapture: (event: PointerEvent<MouseEvent>) => any;
+    wheel: (event: PointerEvent<MouseEvent>) => any;
+    ready: (context: TresContext) => any;
+    pointermissed: (event: PointerEvent<MouseEvent>) => any;
 }, string, import('vue').PublicProps, Readonly<TresCanvasProps> & Readonly<{
-    onRender?: ((...args: any[]) => any) | undefined;
-    onClick?: ((...args: any[]) => any) | undefined;
-    onWheel?: ((...args: any[]) => any) | undefined;
-    onReady?: ((...args: any[]) => any) | undefined;
-    "onDouble-click"?: ((...args: any[]) => any) | undefined;
-    "onContext-menu"?: ((...args: any[]) => any) | undefined;
-    "onPointer-move"?: ((...args: any[]) => any) | undefined;
-    "onPointer-up"?: ((...args: any[]) => any) | undefined;
-    "onPointer-down"?: ((...args: any[]) => any) | undefined;
-    "onPointer-enter"?: ((...args: any[]) => any) | undefined;
-    "onPointer-leave"?: ((...args: any[]) => any) | undefined;
-    "onPointer-over"?: ((...args: any[]) => any) | undefined;
-    "onPointer-out"?: ((...args: any[]) => any) | undefined;
-    "onPointer-missed"?: ((...args: any[]) => any) | undefined;
+    onRender?: ((renderer: TresRenderer) => any) | undefined;
+    onClick?: ((event: PointerEvent<MouseEvent>) => any) | undefined;
+    onContextmenu?: ((event: PointerEvent<MouseEvent>) => any) | undefined;
+    onPointermove?: ((event: PointerEvent<MouseEvent>) => any) | undefined;
+    onPointerenter?: ((event: PointerEvent<MouseEvent>) => any) | undefined;
+    onPointerleave?: ((event: PointerEvent<MouseEvent>) => any) | undefined;
+    onPointerover?: ((event: PointerEvent<MouseEvent>) => any) | undefined;
+    onPointerout?: ((event: PointerEvent<MouseEvent>) => any) | undefined;
+    onDblclick?: ((event: PointerEvent<MouseEvent>) => any) | undefined;
+    onPointerdown?: ((event: PointerEvent<MouseEvent>) => any) | undefined;
+    onPointerup?: ((event: PointerEvent<MouseEvent>) => any) | undefined;
+    onPointercancel?: ((event: PointerEvent<MouseEvent>) => any) | undefined;
+    onLostpointercapture?: ((event: PointerEvent<MouseEvent>) => any) | undefined;
+    onWheel?: ((event: PointerEvent<MouseEvent>) => any) | undefined;
+    onReady?: ((context: TresContext) => any) | undefined;
+    onPointermissed?: ((event: PointerEvent<MouseEvent>) => any) | undefined;
 }>, {
+    toneMapping: THREE.ToneMapping;
     alpha: boolean;
-    antialias: boolean;
+    logarithmicDepthBuffer: boolean;
+    depth: boolean;
     stencil: boolean;
+    windowSize: boolean;
+    clearColor: THREE.ColorRepresentation;
+    shadowMapType: THREE.ShadowMapType;
+    enableProvideBridge: boolean;
+    antialias: boolean;
     preserveDrawingBuffer: boolean;
-    depth: boolean;
     failIfMajorPerformanceCaveat: boolean;
-    logarithmicDepthBuffer: boolean;
+    clearAlpha: number;
     shadows: boolean;
     useLegacyLights: boolean;
-    windowSize: boolean;
     renderMode: "always" | "on-demand" | "manual";
-    enableProvideBridge: boolean;
 }, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {
-    canvas: HTMLCanvasElement;
-}, HTMLCanvasElement>;
-declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
+    canvasRef: HTMLCanvasElement;
+}, HTMLCanvasElement>, Readonly<{
+    default: () => any;
+}> & {
+    default: () => any;
+}>;
 export default _default;
 type __VLS_WithTemplateSlots<T, S> = T & {
     new (): {

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

@@ -1,15 +1,10 @@
 import { default as UseLoader } from './useLoader/component.vue';
-import { default as UseTexture } from './useTexture/component.vue';
-export * from './useCamera/';
+export * from './useCamera';
 export * from './useGraph';
 export * from './useLoader';
 export * from './useLoop';
-export * from './useRaycaster';
-export * from './useRenderer/';
+export * from './useRenderer/useRendererManager';
 export * from './useRenderLoop';
-export * from './useSeek';
-export * from './useTexture';
+export * from './useTres';
 export * from './useTresContextProvider';
-export * from './useTresEventManager';
-export { onTresReady } from './useTresReady';
-export { UseLoader, UseTexture };
+export { UseLoader };