@tresjs/core 0.2.1 → 0.4.0

package/dist/composables/useLogger.d.ts

@@ -1,6 +1,6 @@
 export declare const isProd: boolean;
 interface LoggerComposition {
-    logError: (message: string, error: Error) => void;
+    logError: (message: string, error?: Error | ErrorEvent) => void;
     logWarning: (message: string) => void;
     logMessage: (name: string, value: any) => void;
 }

package/dist/core/index.d.ts

@@ -1,10 +1,9 @@
-export * from './useCamera/useCamera';
-export * from './useCatalog/useCatalog';
-export * from './useInstanceCreator/useInstanceCreator';
-export * from './useLoop/useLoop';
-export * from './useRenderer/useRenderer';
-export * from './useScene/useScene';
-export * from './useLoader/useLoader';
-export * from './useTexture/useTexture';
+export * from './useCamera';
+export * from './useCatalog';
+export * from './useInstanceCreator';
+export * from './useRenderLoop/';
+export * from './useRenderer/';
+export * from './useScene/';
+export * from './useLoader';
+export * from './useTexture';
 export * from './useTres';
-export * from './useTweakPane';

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

@@ -0,0 +1,15 @@
+import { EventHookOn, Fn } from '@vueuse/core';
+import { Ref } from 'vue';
+export interface RenderLoop {
+    delta: number;
+    elapsed: number;
+}
+export interface UseRenderLoopReturn {
+    onBeforeLoop: EventHookOn<RenderLoop>;
+    onLoop: EventHookOn<RenderLoop>;
+    onAfterLoop: EventHookOn<RenderLoop>;
+    pause: Fn;
+    resume: Fn;
+    isActive: Ref<boolean>;
+}
+export declare function useRenderLoop(): UseRenderLoopReturn;

package/dist/core/useRenderer/component.d.ts

@@ -0,0 +1,37 @@
+import { ShadowMapType, TextureEncoding, ToneMapping } from 'three';
+import { PropType } from 'vue';
+/**
+ * Vue component for rendering a Tres component.
+ */
+export declare const TresCanvas: import("vue").DefineComponent<{
+    shadows: BooleanConstructor;
+    shadowMapType: PropType<ShadowMapType>;
+    physicallyCorrectLights: BooleanConstructor;
+    outputEncoding: PropType<TextureEncoding>;
+    toneMapping: PropType<ToneMapping>;
+    toneMappingExposure: NumberConstructor;
+    context: PropType<WebGLRenderingContext>;
+    powerPreference: PropType<"high-performance" | "low-power" | "default">;
+    preserveDrawingBuffer: BooleanConstructor;
+    clearColor: StringConstructor;
+    windowSize: BooleanConstructor;
+}, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+    [key: string]: any;
+}> | undefined, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
+    shadows: BooleanConstructor;
+    shadowMapType: PropType<ShadowMapType>;
+    physicallyCorrectLights: BooleanConstructor;
+    outputEncoding: PropType<TextureEncoding>;
+    toneMapping: PropType<ToneMapping>;
+    toneMappingExposure: NumberConstructor;
+    context: PropType<WebGLRenderingContext>;
+    powerPreference: PropType<"high-performance" | "low-power" | "default">;
+    preserveDrawingBuffer: BooleanConstructor;
+    clearColor: StringConstructor;
+    windowSize: BooleanConstructor;
+}>>, {
+    shadows: boolean;
+    physicallyCorrectLights: boolean;
+    preserveDrawingBuffer: boolean;
+    windowSize: boolean;
+}>;

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

@@ -0,0 +1,81 @@
+import { MaybeComputedRef, MaybeElementRef } from '@vueuse/core';
+import { WebGLRendererParameters, WebGLRenderer, ShadowMapType } from 'three';
+import type { TextureEncoding, ToneMapping } from 'three';
+export interface UseRendererOptions extends WebGLRendererParameters {
+    /**
+     * Enable shadows in the Renderer
+     *
+     * @default false
+     */
+    shadows?: MaybeComputedRef<boolean>;
+    /**
+     * Set the shadow map type
+     *
+     * @default PCFSoftShadowMap
+     */
+    shadowMapType?: MaybeComputedRef<ShadowMapType>;
+    /**
+     * Whether to use physically correct lighting mode.
+     * See the [lights / physical example](https://threejs.org/examples/#webgl_lights_physical).
+     *
+     * @default false
+     */
+    physicallyCorrectLights?: MaybeComputedRef<boolean>;
+    /**
+     * Defines the output encoding of the renderer.
+     *
+     * @default LinearEncoding
+     */
+    outputEncoding?: MaybeComputedRef<TextureEncoding>;
+    /**
+     * Defines the tone mapping used by the renderer.
+     *
+     * @default NoToneMapping
+     */
+    toneMapping?: MaybeComputedRef<ToneMapping>;
+    /**
+     * Defines the tone mapping exposure used by the renderer.
+     *
+     * @default 1
+     */
+    toneMappingExposure?: MaybeComputedRef<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.
+     *
+     * @default 0x000000
+     */
+    clearColor?: MaybeComputedRef<string | number>;
+    windowSize?: MaybeComputedRef<boolean>;
+}
+/**
+ * Reactive Three.js WebGLRenderer instance
+ *
+ * @param canvas
+ * @param options
+ */
+export declare function useRenderer(canvas: MaybeElementRef, container: MaybeElementRef, options: UseRendererOptions): {
+    renderer: import("vue").ShallowRef<WebGLRenderer | undefined>;
+    isReady: import("vue").Ref<boolean>;
+    dispose: () => void;
+    aspectRatio: import("vue").ComputedRef<number>;
+};
+export declare type UseRendererReturn = ReturnType<typeof useRenderer>;

package/dist/core/useScene/component.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Vue component for rendering a Tres component.
+ */
+export declare const Scene: import("vue").DefineComponent<{}, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+    [key: string]: any;
+}>[] | undefined, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{}>>, {}>;

package/dist/core/useScene/index.d.ts

@@ -0,0 +1,4 @@
+import { Scene } from 'three';
+export declare function useScene(): {
+    scene: import("vue").ShallowRef<Scene>;
+};

package/dist/index.d.ts

@@ -1,6 +1,5 @@
 import { App } from 'vue';
 export * from './core';
-export * as TresCanvas from './components/TresCanvas.vue';
 export * from './keys';
 export interface TresPlugin {
     [key: string]: any;