@tresjs/cientos 4.0.0-next.0 → 4.0.0-next.1

package/dist/core/materials/holographicMaterial/material.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Holographic material by Anderson Mancini - Dec 2023.
+ */
+/**
+
+  MIT License
+
+  Copyright (c) 2023 Anderson Mancini
+
+  Permission is hereby granted, free of charge, to any person obtaining a copy
+  of this software and associated documentation files (the "Software"), to deal
+  in the Software without restriction, including without limitation the rights
+  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+  copies of the Software, and to permit persons to whom the Software is
+  furnished to do so, subject to the following conditions:
+
+  The above copyright notice and this permission notice shall be included in all
+  copies or substantial portions of the Software.
+
+  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+  SOFTWARE.
+ */

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

@@ -1,5 +1,7 @@
-import MeshWobbleMaterial from './meshWobbleMaterial/index.vue';
-import MeshGlassMaterial from './meshGlassMaterial/index.vue';
-import CustomShaderMaterial from './customShaderMaterial/index.vue';
-import MeshReflectionMaterial from './meshReflectionMaterial/index.vue';
-export { MeshWobbleMaterial, MeshGlassMaterial, CustomShaderMaterial, MeshReflectionMaterial };
+import { default as MeshWobbleMaterial } from './meshWobbleMaterial/index.vue';
+import { default as MeshGlassMaterial } from './meshGlassMaterial/index.vue';
+import { default as CustomShaderMaterial } from './customShaderMaterial/index.vue';
+import { default as MeshReflectionMaterial } from './meshReflectionMaterial/index.vue';
+import { default as HolographicMaterial } from './holographicMaterial/index.vue';
+
+export { MeshWobbleMaterial, MeshGlassMaterial, CustomShaderMaterial, MeshReflectionMaterial, HolographicMaterial };

package/dist/core/materials/meshGlassMaterial/index.vue.d.ts

@@ -1,4 +1,4 @@
-declare const _default: import("vue").DefineComponent<{}, {
-    MeshGlassMaterialClass: import("vue").ShallowRef<any>;
-}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{}>>, {}, {}>;
+declare const _default: import('vue').DefineComponent<{}, {
+    instance: import('vue').ShallowRef<any>;
+}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{}>>, {}, {}>;
 export default _default;

package/dist/core/materials/meshGlassMaterial/material.d.ts

@@ -1,7 +1,7 @@
-import type { MeshStandardMaterialParameters } from 'three';
-import { MeshStandardMaterial } from 'three';
+import { MeshStandardMaterialParameters, MeshStandardMaterial } from 'three';
 import { Vector2 } from 'three/src/math/Vector2.js';
 import { Color } from 'three/src/math/Color.js';
+
 declare class MeshGlassMaterial extends MeshStandardMaterial {
     isMeshPhysicalMaterial: boolean;
     clearcoatMap: null;

package/dist/core/materials/{blurPass.d.ts → meshReflectionMaterial/BlurPass.d.ts}

@@ -1,13 +1,14 @@
-import { Mesh, Scene, WebGLRenderTarget, Camera } from 'three';
-import { ConvolutionMaterial } from './convolutionMaterial';
+import { Camera, Mesh, Scene, WebGLRenderTarget } from 'three';
+import { ConvolutionMaterial } from './ConvolutionMaterial';
+
 export interface BlurPassProps {
     resolution: number;
     width?: number;
     height?: number;
-    minDepthThreshold?: number;
-    maxDepthThreshold?: number;
+    depthEdge0?: number;
+    depthEdge1?: number;
     depthScale?: number;
-    depthToBlurRatioBias?: number;
+    depthBias?: number;
 }
 export declare class BlurPass {
     readonly renderTargetA: WebGLRenderTarget;
@@ -17,6 +18,7 @@ export declare class BlurPass {
     readonly camera: Camera;
     readonly screen: Mesh;
     renderToScreen: boolean;
-    constructor({ resolution, width, height, minDepthThreshold, maxDepthThreshold, depthScale, depthToBlurRatioBias, }: BlurPassProps);
+    constructor({ resolution, width, height, depthEdge0, depthEdge1, depthScale, depthBias, }: BlurPassProps);
     render(renderer: any, inputBuffer: any, outputBuffer: any): void;
+    dispose(): void;
 }

package/dist/core/materials/{convolutionMaterial.d.ts → meshReflectionMaterial/ConvolutionMaterial.d.ts}

@@ -1,4 +1,5 @@
 import { ShaderMaterial, Vector2 } from 'three';
+
 export declare class ConvolutionMaterial extends ShaderMaterial {
     readonly kernel: Float32Array;
     constructor(texelSize?: Vector2);

package/dist/core/materials/meshReflectionMaterial/index.vue.d.ts

@@ -1,58 +1,189 @@
-import type { Texture, MeshStandardMaterial } from 'three';
-export interface MeshReflectorMaterialProps extends /* @vue-ignore */ MeshStandardMaterial {
+import { Texture, Color, Euler, Vector2 } from 'three';
+import { TresColor } from '@tresjs/core';
+
+export interface MeshReflectionMaterialProps {
+    /** Length in pixels of one side of the square reflective textures. */
     resolution?: number;
-    mixBlur?: number;
-    mixStrength?: number;
-    blur?: [number, number] | number;
-    mirror?: number;
-    minDepthThreshold?: number;
-    maxDepthThreshold?: number;
-    depthScale?: number;
-    depthToBlurRatioBias?: number;
+    /** Overall strength of the reflection. */
+    mix?: number;
+    /** Strength of the sharp reflection on smooth surfaces. */
+    sharpMix?: number;
+    /** Sharp reflection can be faded out by depth – distance from the reflective surface. Performance note: if the value is greater than `0`, a depth texture will be created. */
+    sharpDepthScale?: number;
+    /** Sharp reflection depth falloff bias. */
+    sharpDepthBias?: number;
+    /** Sharp reflection depth falloff start. */
+    sharpDepthEdgeMin?: number;
+    /** Sharp reflection depth falloff end. */
+    sharpDepthEdgeMax?: number;
+    /** Strength of the blurred reflection on smooth surfaces. */
+    blurMixSmooth?: number;
+    /** Strength of the blurred reflection on rough surfaces. */
+    blurMixRough?: number;
+    /** Blurred reflection can spread out by depth – distance from the reflective surface. Performance note: if the value is greater than `0`, depth texture will be rendered. */
+    blurDepthScale?: number;
+    /** Blurred reflection depth spread bias. */
+    blurDepthBias?: number;
+    /** Blurred reflection depth spread start. */
+    blurDepthEdgeMin?: number;
+    /** Blurred reflection depth spread end. */
+    blurDepthEdgeMax?: number;
+    /** Size of the blur. If `[number, number]`, first number is width, second is height. Performance note: if other than `[0, 0]` or `0`, a blur texture will be rendered. */
+    blurSize?: [number, number] | number;
+    /** Texture for offsetting the reflection. */
     distortionMap?: Texture;
+    /** Influence of `distortionMap`. */
     distortion?: number;
-    mixContrast?: number;
+    /** Offsets the reflection. */
     reflectorOffset?: number;
+    color?: TresColor;
+    roughness?: number;
+    metalness?: number;
+    map?: Texture;
+    lightMap?: Texture;
+    lightMapIntensity?: number;
+    aoMap?: Texture | null;
+    aoMapIntensity?: number;
+    emissive?: TresColor;
+    emissiveIntensity?: number;
+    emissiveMap?: Texture;
+    bumpMap?: Texture;
+    bumpScale?: number;
+    normalMap?: Texture;
+    normalMapType?: number;
+    normalScale?: Vector2;
+    displacementMap?: Texture;
+    displacementScale?: number;
+    displacementBias?: number;
+    roughnessMap?: Texture | null;
+    metalnessMap?: Texture | null;
+    alphaMap?: Texture | null;
+    envMap?: Texture | null;
+    envMapRotation?: Euler;
+    envMapIntensity?: number;
+    wireframe?: boolean;
+    wireframeLinewidth?: number;
+    wireframeLinecap?: string;
+    wireframeLinejoin?: string;
+    flatShading?: boolean;
+    fog?: boolean;
 }
-declare const _default: import("vue").DefineComponent<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<MeshReflectorMaterialProps>, {
-    mixBlur: number;
-    mixStrength: number;
+declare const _default: import('vue').DefineComponent<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<MeshReflectionMaterialProps>, {
     resolution: number;
-    blur: () => number[];
-    minDepthThreshold: number;
-    maxDepthThreshold: number;
-    depthScale: number;
-    depthToBlurRatioBias: number;
-    mirror: number;
+    mix: number;
+    sharpMix: number;
+    sharpDepthEdgeMin: number;
+    sharpDepthEdgeMax: number;
+    sharpDepthScale: number;
+    sharpDepthBias: number;
+    blurMixSmooth: number;
+    blurMixRough: number;
+    blurDepthEdgeMin: number;
+    blurDepthEdgeMax: number;
+    blurDepthScale: number;
+    blurDepthBias: number;
+    blurSize: () => number[];
     distortion: number;
-    mixContrast: number;
     reflectorOffset: number;
-}>, {}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<MeshReflectorMaterialProps>, {
-    mixBlur: number;
-    mixStrength: number;
+    color: () => Color;
+    roughness: number;
+    roughnessMap: null;
+    metalness: number;
+    lightMapIntensity: number;
+    aoMapIntensity: number;
+    emissive: () => Color;
+    emissiveIntensity: number;
+    bumpScale: number;
+    normalMapType: 0;
+    normalScale: () => Vector2;
+    displacementScale: number;
+    displacementBias: number;
+    envMapRotation: () => Euler;
+    envMapIntensity: number;
+    wireframe: boolean;
+    wireframeLinewidth: number;
+    wireframeLinecap: string;
+    wireframeLinejoin: string;
+    flatShading: boolean;
+    fog: boolean;
+}>, {
+    instance: import('vue').ShallowRef<any>;
+}, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<MeshReflectionMaterialProps>, {
     resolution: number;
-    blur: () => number[];
-    minDepthThreshold: number;
-    maxDepthThreshold: number;
-    depthScale: number;
-    depthToBlurRatioBias: number;
-    mirror: number;
+    mix: number;
+    sharpMix: number;
+    sharpDepthEdgeMin: number;
+    sharpDepthEdgeMax: number;
+    sharpDepthScale: number;
+    sharpDepthBias: number;
+    blurMixSmooth: number;
+    blurMixRough: number;
+    blurDepthEdgeMin: number;
+    blurDepthEdgeMax: number;
+    blurDepthScale: number;
+    blurDepthBias: number;
+    blurSize: () => number[];
     distortion: number;
-    mixContrast: number;
     reflectorOffset: number;
+    color: () => Color;
+    roughness: number;
+    roughnessMap: null;
+    metalness: number;
+    lightMapIntensity: number;
+    aoMapIntensity: number;
+    emissive: () => Color;
+    emissiveIntensity: number;
+    bumpScale: number;
+    normalMapType: 0;
+    normalScale: () => Vector2;
+    displacementScale: number;
+    displacementBias: number;
+    envMapRotation: () => Euler;
+    envMapIntensity: number;
+    wireframe: boolean;
+    wireframeLinewidth: number;
+    wireframeLinecap: string;
+    wireframeLinejoin: string;
+    flatShading: boolean;
+    fog: boolean;
 }>>>, {
-    blur: number | [number, number];
+    color: TresColor;
+    fog: boolean;
+    lightMapIntensity: number;
+    aoMapIntensity: number;
+    envMapRotation: Euler;
+    wireframe: boolean;
+    wireframeLinewidth: number;
+    wireframeLinecap: string;
+    wireframeLinejoin: string;
     resolution: number;
-    minDepthThreshold: number;
-    maxDepthThreshold: number;
-    depthScale: number;
-    depthToBlurRatioBias: number;
-    mixBlur: number;
-    mixStrength: number;
-    mirror: number;
+    mix: number;
+    sharpMix: number;
+    sharpDepthScale: number;
+    sharpDepthBias: number;
+    sharpDepthEdgeMin: number;
+    sharpDepthEdgeMax: number;
+    blurMixSmooth: number;
+    blurMixRough: number;
+    blurDepthScale: number;
+    blurDepthBias: number;
+    blurDepthEdgeMin: number;
+    blurDepthEdgeMax: number;
+    blurSize: [number, number] | number;
     distortion: number;
-    mixContrast: number;
     reflectorOffset: number;
+    roughness: number;
+    metalness: number;
+    emissive: TresColor;
+    emissiveIntensity: number;
+    bumpScale: number;
+    normalMapType: number;
+    normalScale: Vector2;
+    displacementScale: number;
+    displacementBias: number;
+    roughnessMap: Texture | null;
+    envMapIntensity: number;
+    flatShading: boolean;
 }, {}>;
 export default _default;
 type __VLS_NonUndefinedable<T> = T extends undefined ? never : T;

package/dist/core/materials/meshReflectionMaterial/material.d.ts

@@ -1,51 +1,48 @@
-import type { Matrix4, Texture } from 'three';
-import { MeshStandardMaterial } from 'three';
-export declare class MeshReflectorMaterial extends MeshStandardMaterial {
+import { Matrix4, Texture, MeshStandardMaterial } from 'three';
+
+export declare class MeshReflectionMaterial extends MeshStandardMaterial {
     private _tDepth;
     private _distortionMap;
-    private _tDiffuse;
-    private _tDiffuseBlur;
+    private _tSharp;
+    private _tBlur;
     private _textureMatrix;
-    private _hasBlur;
-    private _mirror;
-    private _mixBlur;
-    private _blurStrength;
-    private _minDepthThreshold;
-    private _maxDepthThreshold;
-    private _depthScale;
-    private _depthToBlurRatioBias;
+    private _mix;
+    private _sharpMix;
+    private _blurMixSmooth;
+    private _blurMixRough;
+    private _sharpDepthEdgeMin;
+    private _sharpDepthEdgeMax;
+    private _sharpDepthScale;
+    private _sharpDepthBias;
     private _distortion;
-    private _mixContrast;
     constructor(parameters?: {});
     onBeforeCompile(shader: any): void;
-    get tDiffuse(): Texture | null;
-    set tDiffuse(v: Texture | null);
+    get tSharp(): Texture | null;
+    set tSharp(v: Texture | null);
     get tDepth(): Texture | null;
     set tDepth(v: Texture | null);
     get distortionMap(): Texture | null;
     set distortionMap(v: Texture | null);
-    get tDiffuseBlur(): Texture | null;
-    set tDiffuseBlur(v: Texture | null);
+    get tBlur(): Texture | null;
+    set tBlur(v: Texture | null);
     get textureMatrix(): Matrix4 | null;
     set textureMatrix(v: Matrix4 | null);
-    get hasBlur(): boolean;
-    set hasBlur(v: boolean);
-    get mirror(): number;
-    set mirror(v: number);
-    get mixBlur(): number;
-    set mixBlur(v: number);
-    get mixStrength(): number;
-    set mixStrength(v: number);
-    get minDepthThreshold(): number;
-    set minDepthThreshold(v: number);
-    get maxDepthThreshold(): number;
-    set maxDepthThreshold(v: number);
-    get depthScale(): number;
-    set depthScale(v: number);
-    get depthToBlurRatioBias(): number;
-    set depthToBlurRatioBias(v: number);
+    get sharpMix(): number;
+    set sharpMix(v: number);
+    get blurMixSmooth(): number;
+    set blurMixSmooth(v: number);
+    get blurMixRough(): number;
+    set blurMixRough(v: number);
+    get mix(): number;
+    set mix(v: number);
+    get sharpDepthScale(): number;
+    set sharpDepthScale(v: number);
+    get sharpDepthBias(): number;
+    set sharpDepthBias(v: number);
+    get sharpDepthEdgeMin(): number;
+    set sharpDepthEdgeMin(v: number);
+    get sharpDepthEdgeMax(): number;
+    set sharpDepthEdgeMax(v: number);
     get distortion(): number;
     set distortion(v: number);
-    get mixContrast(): number;
-    set mixContrast(v: number);
 }

package/dist/core/materials/meshWobbleMaterial/index.vue.d.ts

@@ -1,12 +1,14 @@
-declare const _default: import("vue").DefineComponent<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<{
-    speed?: number | undefined;
-    factor?: number | undefined;
+declare const _default: import('vue').DefineComponent<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<{
+    speed?: number;
+    factor?: number;
 }>, {
     speed: number;
     factor: number;
-}>, {}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<{
-    speed?: number | undefined;
-    factor?: number | undefined;
+}>, {
+    instance: import('vue').ShallowRef<any>;
+}, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<{
+    speed?: number;
+    factor?: number;
 }>, {
     speed: number;
     factor: number;

package/dist/core/materials/meshWobbleMaterial/material.d.ts

@@ -1,5 +1,5 @@
-import type { MeshStandardMaterialParameters, Shader } from 'three';
-import { MeshStandardMaterial } from 'three';
+import { MeshStandardMaterialParameters, Shader, MeshStandardMaterial } from 'three';
+
 interface Uniform<T> {
     value: T;
 }

package/dist/core/misc/BakeShadows.d.ts

@@ -1 +1 @@
-export declare const BakeShadows: import("vue").DefineComponent<{}, void, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{}>>, {}, {}>;
+export declare const BakeShadows: import('vue').DefineComponent<{}, void, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{}>>, {}, {}>;

package/dist/core/misc/Stats.d.ts

@@ -1,9 +1,9 @@
-export declare const Stats: import("vue").DefineComponent<{
+export declare const Stats: import('vue').DefineComponent<{
     showPanel: {
         type: NumberConstructor;
         default: number;
     };
-}, void, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+}, void, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
     showPanel: {
         type: NumberConstructor;
         default: number;

package/dist/core/misc/StatsGl.d.ts

@@ -7,4 +7,4 @@ export interface StatsGlProps {
     minimal?: boolean;
     mode?: number;
 }
-export declare const StatsGl: import("vue").DefineComponent<StatsGlProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<StatsGlProps>, {}, {}>;
+export declare const StatsGl: import('vue').DefineComponent<StatsGlProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<StatsGlProps>, {}, {}>;

package/dist/core/misc/html/HTML.vue.d.ts

@@ -1,7 +1,8 @@
-import type { Ref } from 'vue';
+import { Ref } from 'vue';
 import { PlaneGeometry } from 'three';
-import type { TresObject3D } from '@tresjs/core';
-import type { Mutable } from '@vueuse/core';
+import { TresObject3D } from '@tresjs/core';
+import { Mutable } from '@vueuse/core';
+
 export interface HTMLProps {
     geometry?: any;
     material?: any;
@@ -19,7 +20,8 @@ export interface HTMLProps {
     occlude?: Ref<TresObject3D>[] | boolean | 'raycast' | 'blending';
 }
 type PointerEventsProperties = 'auto' | 'none' | 'visiblePainted' | 'visibleFill' | 'visibleStroke' | 'visible' | 'painted' | 'fill' | 'stroke' | 'all' | 'inherit';
-declare const _default: __VLS_WithTemplateSlots<import("vue").DefineComponent<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<HTMLProps>, {
+declare function __VLS_template(): Readonly<Record<string, any>> & Record<string, any>;
+declare const __VLS_component: import('vue').DefineComponent<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<HTMLProps>, {
     geometry: PlaneGeometry;
     zIndexRange: () => number[];
     as: string;
@@ -27,9 +29,11 @@ declare const _default: __VLS_WithTemplateSlots<import("vue").DefineComponent<__
     eps: number;
     pointerEvents: string;
     sprite: boolean;
-}>, {}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+}>, {
+    instance: Ref<TresObject3D | undefined>;
+}, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
     onOcclude: (...args: any[]) => void;
-}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<HTMLProps>, {
+}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<HTMLProps>, {
     geometry: PlaneGeometry;
     zIndexRange: () => number[];
     as: string;
@@ -46,8 +50,9 @@ declare const _default: __VLS_WithTemplateSlots<import("vue").DefineComponent<__
     as: string;
     eps: number;
     pointerEvents: PointerEventsProperties;
-    zIndexRange: number[];
-}, {}>, Readonly<Record<string, any>> & Record<string, any>>;
+    zIndexRange: Array<number>;
+}, {}>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, ReturnType<typeof __VLS_template>>;
 export default _default;
 type __VLS_NonUndefinedable<T> = T extends undefined ? never : T;
 type __VLS_TypePropsToRuntimeProps<T> = {

package/dist/core/misc/html/utils.d.ts

@@ -1,6 +1,6 @@
-import type { TresCamera, TresObject3D } from '@tresjs/core';
-import type { Matrix4, Raycaster } from 'three';
-import { Vector3 } from 'three';
+import { TresCamera, TresObject3D } from '@tresjs/core';
+import { Matrix4, Raycaster, Vector3 } from 'three';
+
 export declare const v1: Vector3;
 export declare const v2: Vector3;
 export declare const v3: Vector3;

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

@@ -1,7 +1,7 @@
-import { useTweakPane } from './useTweakPane';
 import { Stats } from './Stats';
 import { StatsGl } from './StatsGl';
 import { BakeShadows } from './BakeShadows';
-import Html from './html/HTML.vue';
+import { default as Html } from './html/HTML.vue';
 import { useGLTFExporter } from './useGLTFExporter';
-export { useTweakPane, Html, Stats, StatsGl, BakeShadows, useGLTFExporter };
+
+export { Html, Stats, StatsGl, BakeShadows, useGLTFExporter };

package/dist/core/misc/useGLTFExporter.d.ts

@@ -1,4 +1,5 @@
-import type { AnimationClip, Object3D } from 'three';
+import { AnimationClip, Object3D } from 'three';
+
 interface gltfExporterOptions {
     fileName?: string;
     trs?: boolean;

package/dist/core/shapes/Box.vue.d.ts

@@ -1,5 +1,6 @@
-import type { TresColor } from '@tresjs/core';
-import type { BoxGeometry } from 'three';
+import { TresColor } from '@tresjs/core';
+import { BoxGeometry } from 'three';
+
 export interface BoxProps {
     /**
      * The width, height and depth of the box.
@@ -19,20 +20,22 @@ export interface BoxProps {
      */
     color?: TresColor;
 }
-declare const _default: __VLS_WithTemplateSlots<import("vue").DefineComponent<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<BoxProps>, {
+declare function __VLS_template(): {
+    default?(_: {}): any;
+};
+declare const __VLS_component: import('vue').DefineComponent<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<BoxProps>, {
     args: () => number[];
     color: string;
 }>, {
-    value: import("vue").ShallowRef<any>;
-}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<BoxProps>, {
+    instance: import('vue').ShallowRef<any>;
+}, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<BoxProps>, {
     args: () => number[];
     color: string;
 }>>>, {
-    color: import("three").ColorRepresentation | [r: number, g: number, b: number];
-    args: [width?: number | undefined, height?: number | undefined, depth?: number | undefined, widthSegments?: number | undefined, heightSegments?: number | undefined, depthSegments?: number | undefined];
-}, {}>, {
-    default?(_: {}): any;
-}>;
+    color: TresColor;
+    args: ConstructorParameters<typeof BoxGeometry>;
+}, {}>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, ReturnType<typeof __VLS_template>>;
 export default _default;
 type __VLS_NonUndefinedable<T> = T extends undefined ? never : T;
 type __VLS_TypePropsToRuntimeProps<T> = {

package/dist/core/shapes/CatmullRomCurve3.vue.d.ts

@@ -1,5 +1,6 @@
-import type { TresColor } from '@tresjs/core';
+import { TresColor } from '@tresjs/core';
 import { Vector3 } from 'three';
+
 type CurveType = 'centripetal' | 'chordal' | 'catmullrom';
 type Points = Array<Vector3 | [number, number, number]>;
 interface CatmullRomCurve3Props {
@@ -19,12 +20,14 @@ interface CatmullRomCurve3Props {
     gapSize?: number;
     worldUnits?: boolean;
 }
-declare const _default: import("vue").DefineComponent<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<CatmullRomCurve3Props>, {
+declare const _default: import('vue').DefineComponent<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<CatmullRomCurve3Props>, {
     segments: number;
     closed: boolean;
     curveType: string;
     tension: number;
-}>, {}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<CatmullRomCurve3Props>, {
+}>, {
+    instance: import('vue').ShallowRef<any>;
+}, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<CatmullRomCurve3Props>, {
     segments: number;
     closed: boolean;
     curveType: string;