@tresjs/cientos 4.0.3 → 4.1.1

package/dist/core/abstractions/AnimatedSprite/component.vue.d.ts

@@ -48,11 +48,25 @@ export interface AnimatedSpriteProps {
     depthWrite?: boolean;
 }
 declare function __VLS_template(): {
-    default?(_: {}): any;
+    slots: {
+        default?(_: {}): any;
+    };
+    refs: {
+        groupRef: import('vue').CreateComponentPublicInstanceWithMixins<Readonly<import('@tresjs/core').Mutable<import('@tresjs/core').Overwrite<Partial<import('@tresjs/core').Overwrite<import('three').Group<import('three').Object3DEventMap>, import('@tresjs/core').WithMathProps<import('three').Group<import('three').Object3DEventMap>> & import('@tresjs/core').VueProps & Partial<import('@tresjs/core').EventHandlers>>>, Omit<import('@tresjs/core').InstanceProps<import('three').Group<import('three').Object3DEventMap>, typeof import('three').Group>, "object">>>>, {}, {}, import('vue').ComputedOptions, import('vue').MethodOptions, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, import('vue').PublicProps, {}, true, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {}, any, import('vue').ComponentProvideOptions, {
+            P: {};
+            B: {};
+            D: {};
+            C: {};
+            M: {};
+            Defaults: {};
+        }, Readonly<import('@tresjs/core').Mutable<import('@tresjs/core').Overwrite<Partial<import('@tresjs/core').Overwrite<import('three').Group<import('three').Object3DEventMap>, import('@tresjs/core').WithMathProps<import('three').Group<import('three').Object3DEventMap>> & import('@tresjs/core').VueProps & Partial<import('@tresjs/core').EventHandlers>>>, Omit<import('@tresjs/core').InstanceProps<import('three').Group<import('three').Object3DEventMap>, typeof import('three').Group>, "object">>>>, {}, {}, import('vue').ComputedOptions, import('vue').MethodOptions, {}> | null;
+    };
+    attrs: Partial<{}>;
 };
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
 declare const __VLS_component: import('vue').DefineComponent<AnimatedSpriteProps, {
-    instance: import('vue').ShallowRef<any>;
-}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    instance: import('vue').ShallowRef<any, any>;
+}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {} & {
     loop: (frameName: string) => any;
     frame: (frameName: string) => any;
     end: (frameName: string) => any;
@@ -74,9 +88,8 @@ declare const __VLS_component: import('vue').DefineComponent<AnimatedSpriteProps
     depthTest: boolean;
     depthWrite: boolean;
 }, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
-declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, ReturnType<typeof __VLS_template>>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
 export default _default;
-
 type __VLS_WithTemplateSlots<T, S> = T & {
     new (): {
         $slots: S;

package/dist/core/abstractions/Billboard.vue.d.ts

@@ -0,0 +1,61 @@
+import { Camera, Group } from 'three';
+export interface BillboardProps {
+    /**
+     * Whether the Billboard should face the camera automatically on every frame.
+     */
+    autoUpdate?: boolean;
+    /**
+     * Whether to lock the x-axis.
+     */
+    lockX?: boolean;
+    /**
+     * Whether to lock the y-axis.
+     */
+    lockY?: boolean;
+    /**
+     * Whether to lock the z-axis.
+     */
+    lockZ?: boolean;
+}
+declare function update(camera?: Camera): void;
+declare function __VLS_template(): {
+    slots: {
+        default?(_: {}): any;
+    };
+    refs: {
+        outerRef: import('vue').CreateComponentPublicInstanceWithMixins<Readonly<import('@tresjs/core').Mutable<import('@tresjs/core').Overwrite<Partial<import('@tresjs/core').Overwrite<Group<import('three').Object3DEventMap>, import('@tresjs/core').WithMathProps<Group<import('three').Object3DEventMap>> & import('@tresjs/core').VueProps & Partial<import('@tresjs/core').EventHandlers>>>, Omit<import('@tresjs/core').InstanceProps<Group<import('three').Object3DEventMap>, typeof Group>, "object">>>>, {}, {}, import('vue').ComputedOptions, import('vue').MethodOptions, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, import('vue').PublicProps, {}, true, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {}, any, import('vue').ComponentProvideOptions, {
+            P: {};
+            B: {};
+            D: {};
+            C: {};
+            M: {};
+            Defaults: {};
+        }, Readonly<import('@tresjs/core').Mutable<import('@tresjs/core').Overwrite<Partial<import('@tresjs/core').Overwrite<Group<import('three').Object3DEventMap>, import('@tresjs/core').WithMathProps<Group<import('three').Object3DEventMap>> & import('@tresjs/core').VueProps & Partial<import('@tresjs/core').EventHandlers>>>, Omit<import('@tresjs/core').InstanceProps<Group<import('three').Object3DEventMap>, typeof Group>, "object">>>>, {}, {}, import('vue').ComputedOptions, import('vue').MethodOptions, {}> | null;
+        innerRef: import('vue').CreateComponentPublicInstanceWithMixins<Readonly<import('@tresjs/core').Mutable<import('@tresjs/core').Overwrite<Partial<import('@tresjs/core').Overwrite<Group<import('three').Object3DEventMap>, import('@tresjs/core').WithMathProps<Group<import('three').Object3DEventMap>> & import('@tresjs/core').VueProps & Partial<import('@tresjs/core').EventHandlers>>>, Omit<import('@tresjs/core').InstanceProps<Group<import('three').Object3DEventMap>, typeof Group>, "object">>>>, {}, {}, import('vue').ComputedOptions, import('vue').MethodOptions, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, import('vue').PublicProps, {}, true, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {}, any, import('vue').ComponentProvideOptions, {
+            P: {};
+            B: {};
+            D: {};
+            C: {};
+            M: {};
+            Defaults: {};
+        }, Readonly<import('@tresjs/core').Mutable<import('@tresjs/core').Overwrite<Partial<import('@tresjs/core').Overwrite<Group<import('three').Object3DEventMap>, import('@tresjs/core').WithMathProps<Group<import('three').Object3DEventMap>> & import('@tresjs/core').VueProps & Partial<import('@tresjs/core').EventHandlers>>>, Omit<import('@tresjs/core').InstanceProps<Group<import('three').Object3DEventMap>, typeof Group>, "object">>>>, {}, {}, import('vue').ComputedOptions, import('vue').MethodOptions, {}> | null;
+    };
+    attrs: Partial<{}>;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<BillboardProps, {
+    instance: import('vue').ShallowRef<Group<import('three').Object3DEventMap>, Group<import('three').Object3DEventMap>>;
+    update: typeof update;
+}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<BillboardProps> & Readonly<{}>, {
+    autoUpdate: boolean;
+    lockX: boolean;
+    lockY: boolean;
+    lockZ: boolean;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/core/abstractions/CubeCamera/component.vue.d.ts

@@ -0,0 +1,39 @@
+import { Group } from 'three';
+import { CubeCameraOptions } from './useCubeCamera';
+import { MaybeRefOrGetter } from 'vue';
+type Props = {
+    /** Number of frames to render, Infinity */
+    frames?: MaybeRefOrGetter<number>;
+} & CubeCameraOptions;
+declare function __VLS_template(): {
+    slots: {
+        default?(_: {}): any;
+    };
+    refs: {
+        groupRef: import('vue').CreateComponentPublicInstanceWithMixins<Readonly<import('@tresjs/core').Mutable<import('@tresjs/core').Overwrite<Partial<import('@tresjs/core').Overwrite<Group<import('three').Object3DEventMap>, import('@tresjs/core').WithMathProps<Group<import('three').Object3DEventMap>> & import('@tresjs/core').VueProps & Partial<import('@tresjs/core').EventHandlers>>>, Omit<import('@tresjs/core').InstanceProps<Group<import('three').Object3DEventMap>, typeof Group>, "object">>>>, {}, {}, import('vue').ComputedOptions, import('vue').MethodOptions, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, import('vue').PublicProps, {}, true, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {}, any, import('vue').ComponentProvideOptions, {
+            P: {};
+            B: {};
+            D: {};
+            C: {};
+            M: {};
+            Defaults: {};
+        }, Readonly<import('@tresjs/core').Mutable<import('@tresjs/core').Overwrite<Partial<import('@tresjs/core').Overwrite<Group<import('three').Object3DEventMap>, import('@tresjs/core').WithMathProps<Group<import('three').Object3DEventMap>> & import('@tresjs/core').VueProps & Partial<import('@tresjs/core').EventHandlers>>>, Omit<import('@tresjs/core').InstanceProps<Group<import('three').Object3DEventMap>, typeof Group>, "object">>>>, {}, {}, import('vue').ComputedOptions, import('vue').MethodOptions, {}> | null;
+    };
+    attrs: Partial<{}>;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<Props, {
+    instance: import('vue').ShallowRef<Group<import('three').Object3DEventMap> | undefined, Group<import('three').Object3DEventMap> | undefined>;
+    fbo: import('vue').ComputedRef<import('three').WebGLCubeRenderTarget>;
+    camera: import('vue').ComputedRef<import('three').CubeCamera>;
+    update: () => void;
+}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<Props> & Readonly<{}>, {
+    frames: MaybeRefOrGetter<number>;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/core/abstractions/CubeCamera/useCubeCamera.d.ts

@@ -0,0 +1,23 @@
+import { MaybeRefOrGetter } from 'vue';
+import { Fog, FogExp2, Scene, Texture, WebGLRenderer, CubeCamera as ThreeCubeCamera, WebGLCubeRenderTarget } from 'three';
+export interface CubeCameraOptions {
+    /** Resolution of the FBO, 255 */
+    resolution?: MaybeRefOrGetter<number>;
+    /** Camera near, 0.1 */
+    near?: MaybeRefOrGetter<number>;
+    /** Camera far, 1000 */
+    far?: MaybeRefOrGetter<number>;
+    /** Custom environment map that is temporarily set as the scene's background */
+    envMap?: MaybeRefOrGetter<Texture>;
+    /** Custom fog that is temporarily set as the scene's fog */
+    fog?: MaybeRefOrGetter<Fog | FogExp2>;
+    /** Renderer */
+    renderer?: MaybeRefOrGetter<WebGLRenderer>;
+    /** Scene */
+    scene?: MaybeRefOrGetter<Scene>;
+}
+export declare function useCubeCamera(props: CubeCameraOptions): {
+    fbo: import('vue').ComputedRef<WebGLCubeRenderTarget>;
+    camera: import('vue').ComputedRef<ThreeCubeCamera>;
+    update: () => void;
+};

package/dist/core/abstractions/Edges.vue.d.ts

@@ -0,0 +1,36 @@
+import { LineSegments, BufferGeometry } from 'three';
+import { TresColor } from '@tresjs/core';
+export interface EdgesProps {
+    color?: TresColor;
+    threshold?: number;
+}
+declare function __VLS_template(): {
+    slots: {
+        default?(_: {}): any;
+    };
+    refs: {
+        lineSegmentsRef: import('vue').CreateComponentPublicInstanceWithMixins<Readonly<import('@tresjs/core').Mutable<import('@tresjs/core').Overwrite<Partial<import('@tresjs/core').Overwrite<LineSegments<BufferGeometry<import('three').NormalBufferAttributes>, import('three').Material | import('three').Material[], import('three').Object3DEventMap>, import('@tresjs/core').WithMathProps<LineSegments<BufferGeometry<import('three').NormalBufferAttributes>, import('three').Material | import('three').Material[], import('three').Object3DEventMap>> & import('@tresjs/core').VueProps & Partial<import('@tresjs/core').EventHandlers>>>, Omit<import('@tresjs/core').InstanceProps<LineSegments<BufferGeometry<import('three').NormalBufferAttributes>, import('three').Material | import('three').Material[], import('three').Object3DEventMap>, typeof LineSegments>, "object">>>>, {}, {}, import('vue').ComputedOptions, import('vue').MethodOptions, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, import('vue').PublicProps, {}, true, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {}, any, import('vue').ComponentProvideOptions, {
+            P: {};
+            B: {};
+            D: {};
+            C: {};
+            M: {};
+            Defaults: {};
+        }, Readonly<import('@tresjs/core').Mutable<import('@tresjs/core').Overwrite<Partial<import('@tresjs/core').Overwrite<LineSegments<BufferGeometry<import('three').NormalBufferAttributes>, import('three').Material | import('three').Material[], import('three').Object3DEventMap>, import('@tresjs/core').WithMathProps<LineSegments<BufferGeometry<import('three').NormalBufferAttributes>, import('three').Material | import('three').Material[], import('three').Object3DEventMap>> & import('@tresjs/core').VueProps & Partial<import('@tresjs/core').EventHandlers>>>, Omit<import('@tresjs/core').InstanceProps<LineSegments<BufferGeometry<import('three').NormalBufferAttributes>, import('three').Material | import('three').Material[], import('three').Object3DEventMap>, typeof LineSegments>, "object">>>>, {}, {}, import('vue').ComputedOptions, import('vue').MethodOptions, {}> | null;
+    };
+    attrs: Partial<{}>;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<EdgesProps, {
+    instance: import('vue').ShallowRef<LineSegments<BufferGeometry<import('three').NormalBufferAttributes>, import('three').Material | import('three').Material[], import('three').Object3DEventMap> | undefined, LineSegments<BufferGeometry<import('three').NormalBufferAttributes>, import('three').Material | import('three').Material[], import('three').Object3DEventMap> | undefined>;
+}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<EdgesProps> & Readonly<{}>, {
+    color: TresColor;
+    threshold: number;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/core/abstractions/GradientTexture.vue.d.ts

@@ -0,0 +1,47 @@
+import * as THREE from 'three';
+export type GradientType = 'linear' | 'radial';
+interface Props {
+    /**
+     * A `number[]` of values between `0` and `1` representing the color positions in the gradient. `stops.length` should match `color.
+     */
+    stops: Array<number>;
+    /**
+     * A `THREE.ColorRepresentation[]` representing the colors in the gradient.
+     */
+    colors: Array<THREE.ColorRepresentation>;
+    /**
+     * Where the component should be attached within its parent.
+     */
+    attach?: string;
+    /**
+     * Height of the canvas used to draw the gradient.
+     */
+    height?: number;
+    /**
+     * Width of the canvas used to draw the gradient.
+     */
+    width?: number;
+    /**
+     * `'linear' \| 'radial'` Type of gradient to draw.
+     */
+    type?: GradientType;
+    /**
+     * Radius of the inner circle of a radial gradient.
+     */
+    innerCircleRadius?: number;
+    /**
+     * Radius of the outer circle of a radial gradient.
+     */
+    outerCircleRadius?: string | number;
+}
+declare const _default: import('vue').DefineComponent<Props, {
+    instance: import('vue').ShallowRef<any, any>;
+}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<Props> & Readonly<{}>, {
+    type: GradientType;
+    attach: string;
+    width: number;
+    height: number;
+    innerCircleRadius: number;
+    outerCircleRadius: string | number;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+export default _default;

package/dist/core/abstractions/Image/ImageMaterial.vue.d.ts

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

package/dist/core/abstractions/Image/ImageMaterialImpl.d.ts

@@ -0,0 +1,8 @@
+/**
+ * NOTE: Source:
+ * https://threejs.org/docs/?q=material#api/en/materials/Material.transparent
+ */
+declare const imageMaterialImpl: typeof import('three').ShaderMaterial & {
+    key: string;
+};
+export default imageMaterialImpl;

package/dist/core/abstractions/Image/component.vue.d.ts

@@ -0,0 +1,81 @@
+import { Side, Texture } from 'three';
+import { TresColor } from '@tresjs/core';
+export type ImageProps = {
+    /**
+     * Number of divisions in the the default geometry.
+     */
+    segments?: number;
+    /**
+     * Scale of the geometry.
+     */
+    scale?: number | [number, number];
+    /**
+     * Color multiplied into the image texture. Default is white.
+     */
+    color?: TresColor;
+    /**
+     * Shrinks or enlarges the image texture.
+     */
+    zoom?: number;
+    /**
+     * Border radius applied to image texture. Intended for rectangular geometries.
+     */
+    radius?: number;
+    /**
+     * Power of grayscale effect. 0 is no grayscale. 1 is full grayscale.
+     */
+    grayscale?: number;
+    /**
+     * Whether this material is tone mapped according to the renderer's toneMapping setting. [See THREE.material.tonemapped](https://threejs.org/docs/?q=material#api/en/materials/Material.toneMapped)
+     */
+    toneMapped?: boolean;
+    /**
+     * Whether the image material should be transparent. [See THREE.material.transparent](https://threejs.org/docs/?q=material#api/en/materials/Material.transparent)
+     */
+    transparent?: boolean;
+    /**
+     * Opacity of the image material. [See THREE.material.transparent](https://threejs.org/docs/?q=material#api/en/materials/Material.transparent)
+     */
+    opacity?: number;
+    /**
+     * THREE.Side of the image material. [See THREE.material.side](https://threejs.org/docs/?q=material#api/en/materials/Material.side)
+     */
+    side?: Side;
+} & ({
+    /**
+     * Image texture to display on the geometry.
+     */
+    texture: Texture;
+    url?: never;
+} | {
+    texture?: never;
+    /**
+     * Image URL to load and display on the geometry.
+     */
+    url: string;
+});
+declare function __VLS_template(): {
+    slots: {
+        default?(_: {}): any;
+    };
+    refs: {
+        imageRef: import('vue').CreateComponentPublicInstanceWithMixins<Readonly<import('@tresjs/core').Mutable<import('@tresjs/core').Overwrite<Partial<import('@tresjs/core').Overwrite<import('three').Mesh<import('three').BufferGeometry<import('three').NormalBufferAttributes>, import('three').Material | import('three').Material[], import('three').Object3DEventMap>, import('@tresjs/core').WithMathProps<import('three').Mesh<import('three').BufferGeometry<import('three').NormalBufferAttributes>, import('three').Material | import('three').Material[], import('three').Object3DEventMap>> & import('@tresjs/core').VueProps & Partial<import('@tresjs/core').EventHandlers>>>, Omit<import('@tresjs/core').InstanceProps<import('three').Mesh<import('three').BufferGeometry<import('three').NormalBufferAttributes>, import('three').Material | import('three').Material[], import('three').Object3DEventMap>, typeof import('three').Mesh>, "object">>>>, {}, {}, import('vue').ComputedOptions, import('vue').MethodOptions, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, import('vue').PublicProps, {}, true, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {}, any, import('vue').ComponentProvideOptions, {
+            P: {};
+            B: {};
+            D: {};
+            C: {};
+            M: {};
+            Defaults: {};
+        }, Readonly<import('@tresjs/core').Mutable<import('@tresjs/core').Overwrite<Partial<import('@tresjs/core').Overwrite<import('three').Mesh<import('three').BufferGeometry<import('three').NormalBufferAttributes>, import('three').Material | import('three').Material[], import('three').Object3DEventMap>, import('@tresjs/core').WithMathProps<import('three').Mesh<import('three').BufferGeometry<import('three').NormalBufferAttributes>, import('three').Material | import('three').Material[], import('three').Object3DEventMap>> & import('@tresjs/core').VueProps & Partial<import('@tresjs/core').EventHandlers>>>, Omit<import('@tresjs/core').InstanceProps<import('three').Mesh<import('three').BufferGeometry<import('three').NormalBufferAttributes>, import('three').Material | import('three').Material[], import('three').Object3DEventMap>, typeof import('three').Mesh>, "object">>>>, {}, {}, import('vue').ComputedOptions, import('vue').MethodOptions, {}> | null;
+    };
+    attrs: Partial<{}>;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineSetupFnComponent<Record<string, any>, {}, {}, Record<string, any> & {}, import('vue').PublicProps>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/core/abstractions/Lensflare/component.vue.d.ts

@@ -1,4 +1,4 @@
-import { Lensflare } from 'three/examples/jsm/objects/Lensflare';
+import { Lensflare } from 'three-stdlib';
 import { TresColor } from '@tresjs/core';
 import { Texture } from 'three';
 import { LensflareElementProps, SeedProps } from '.';
@@ -37,7 +37,7 @@ export interface LensflareProps {
     texture?: Texture | string;
 }
 declare const _default: import('vue').DefineComponent<LensflareProps, {
-    instance: import('vue').ShallowRef<Lensflare | undefined>;
+    instance: import('vue').ShallowRef<Lensflare | undefined, Lensflare | undefined>;
 }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<LensflareProps> & Readonly<{}>, {
     texture: Texture | string;
     color: TresColor;

package/dist/core/abstractions/Levioso.vue.d.ts

@@ -1,13 +1,27 @@
 declare function __VLS_template(): {
-    default?(_: {}): any;
+    slots: {
+        default?(_: {}): any;
+    };
+    refs: {
+        groupRef: import('vue').CreateComponentPublicInstanceWithMixins<Readonly<import('@tresjs/core').Mutable<import('@tresjs/core').Overwrite<Partial<import('@tresjs/core').Overwrite<import('three').Group<import('three').Object3DEventMap>, import('@tresjs/core').WithMathProps<import('three').Group<import('three').Object3DEventMap>> & import('@tresjs/core').VueProps & Partial<import('@tresjs/core').EventHandlers>>>, Omit<import('@tresjs/core').InstanceProps<import('three').Group<import('three').Object3DEventMap>, typeof import('three').Group>, "object">>>>, {}, {}, import('vue').ComputedOptions, import('vue').MethodOptions, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, import('vue').PublicProps, {}, true, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {}, any, import('vue').ComponentProvideOptions, {
+            P: {};
+            B: {};
+            D: {};
+            C: {};
+            M: {};
+            Defaults: {};
+        }, Readonly<import('@tresjs/core').Mutable<import('@tresjs/core').Overwrite<Partial<import('@tresjs/core').Overwrite<import('three').Group<import('three').Object3DEventMap>, import('@tresjs/core').WithMathProps<import('three').Group<import('three').Object3DEventMap>> & import('@tresjs/core').VueProps & Partial<import('@tresjs/core').EventHandlers>>>, Omit<import('@tresjs/core').InstanceProps<import('three').Group<import('three').Object3DEventMap>, typeof import('three').Group>, "object">>>>, {}, {}, import('vue').ComputedOptions, import('vue').MethodOptions, {}> | null;
+    };
+    attrs: Partial<{}>;
 };
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
 declare const __VLS_component: import('vue').DefineComponent<{
     speed?: number;
     rotationFactor?: number;
     floatFactor?: number;
     range?: [number, number];
 }, {
-    instance: import('vue').ShallowRef<any>;
+    instance: import('vue').ShallowRef<any, any>;
 }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{
     speed?: number;
     rotationFactor?: number;
@@ -19,7 +33,7 @@ declare const __VLS_component: import('vue').DefineComponent<{
     floatFactor: number;
     range: [number, number];
 }, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
-declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, ReturnType<typeof __VLS_template>>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
 export default _default;
 type __VLS_WithTemplateSlots<T, S> = T & {
     new (): {

package/dist/core/abstractions/Mask/component.vue.d.ts

@@ -0,0 +1,40 @@
+import { Mesh } from 'three';
+interface MaskProps {
+    /** Id of the stencil buffer to use. Each mask must have an id. Multiple masks can refer to the same id. */
+    id: number;
+    /** Whether the colors of the masks own material will leak through, default: false */
+    colorWrite?: boolean;
+    /** Whether the depth of the masks own material will leak through, default: false */
+    depthWrite?: boolean;
+}
+declare function __VLS_template(): {
+    slots: {
+        default?(_: {}): any;
+    };
+    refs: {
+        meshRef: import('vue').CreateComponentPublicInstanceWithMixins<Readonly<import('@tresjs/core').Mutable<import('@tresjs/core').Overwrite<Partial<import('@tresjs/core').Overwrite<Mesh<import('three').BufferGeometry<import('three').NormalBufferAttributes>, import('three').Material | import('three').Material[], import('three').Object3DEventMap>, import('@tresjs/core').WithMathProps<Mesh<import('three').BufferGeometry<import('three').NormalBufferAttributes>, import('three').Material | import('three').Material[], import('three').Object3DEventMap>> & import('@tresjs/core').VueProps & Partial<import('@tresjs/core').EventHandlers>>>, Omit<import('@tresjs/core').InstanceProps<Mesh<import('three').BufferGeometry<import('three').NormalBufferAttributes>, import('three').Material | import('three').Material[], import('three').Object3DEventMap>, typeof Mesh>, "object">>>>, {}, {}, import('vue').ComputedOptions, import('vue').MethodOptions, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, import('vue').PublicProps, {}, true, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {}, any, import('vue').ComponentProvideOptions, {
+            P: {};
+            B: {};
+            D: {};
+            C: {};
+            M: {};
+            Defaults: {};
+        }, Readonly<import('@tresjs/core').Mutable<import('@tresjs/core').Overwrite<Partial<import('@tresjs/core').Overwrite<Mesh<import('three').BufferGeometry<import('three').NormalBufferAttributes>, import('three').Material | import('three').Material[], import('three').Object3DEventMap>, import('@tresjs/core').WithMathProps<Mesh<import('three').BufferGeometry<import('three').NormalBufferAttributes>, import('three').Material | import('three').Material[], import('three').Object3DEventMap>> & import('@tresjs/core').VueProps & Partial<import('@tresjs/core').EventHandlers>>>, Omit<import('@tresjs/core').InstanceProps<Mesh<import('three').BufferGeometry<import('three').NormalBufferAttributes>, import('three').Material | import('three').Material[], import('three').Object3DEventMap>, typeof Mesh>, "object">>>>, {}, {}, import('vue').ComputedOptions, import('vue').MethodOptions, {}> | null;
+    };
+    attrs: Partial<{}>;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<MaskProps, {
+    instance: import('vue').ShallowRef<Mesh<import('three').BufferGeometry<import('three').NormalBufferAttributes>, import('three').Material | import('three').Material[], import('three').Object3DEventMap> | undefined, Mesh<import('three').BufferGeometry<import('three').NormalBufferAttributes>, import('three').Material | import('three').Material[], import('three').Object3DEventMap> | undefined>;
+}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<MaskProps> & Readonly<{}>, {
+    depthWrite: boolean;
+    id: number;
+    colorWrite: boolean;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/core/abstractions/Mask/useMask.d.ts

@@ -0,0 +1,9 @@
+import { Ref } from 'vue';
+export declare function useMask(id: Ref<number> | number, inverse?: Ref<boolean> | boolean): {
+    stencilWrite: boolean;
+    stencilRef: number;
+    stencilFunc: 514 | 517;
+    stencilFail: 7680;
+    stencilZFail: 7680;
+    stencilZPass: 7680;
+};

package/dist/core/abstractions/Outline/OutlineMaterialImpl.d.ts

@@ -0,0 +1,4 @@
+declare const OutlineMaterialImpl: typeof import('three').ShaderMaterial & {
+    key: string;
+};
+export default OutlineMaterialImpl;

package/dist/core/abstractions/Outline/component.vue.d.ts

@@ -0,0 +1,34 @@
+import { TresColor } from '@tresjs/core';
+interface OutlineProps {
+    /** Outline color, default: black */
+    color?: TresColor;
+    /** Line thickness is independent of zoom, default: false */
+    screenspace?: boolean;
+    /** Outline opacity, default: 1 */
+    opacity?: number;
+    /** Outline transparency, default: false */
+    transparent?: boolean;
+    /** Outline thickness, default 0.05 */
+    thickness?: number;
+    /** Geometry crease angle (-1 === no crease), default: Math.PI, See [BufferGeometryUtils.toCreasedNormals](https://threejs.org/docs/#examples/en/utils/BufferGeometryUtils.toCreasedNormals) */
+    angle?: number;
+    toneMapped?: boolean;
+    polygonOffset?: boolean;
+    polygonOffsetFactor?: number;
+    renderOrder?: number;
+}
+declare const _default: import('vue').DefineComponent<OutlineProps, {
+    instance: import('vue').ShallowRef<any, any>;
+}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<OutlineProps> & Readonly<{}>, {
+    color: TresColor;
+    renderOrder: number;
+    opacity: number;
+    polygonOffset: boolean;
+    polygonOffsetFactor: number;
+    toneMapped: boolean;
+    transparent: boolean;
+    angle: number;
+    thickness: number;
+    screenspace: boolean;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+export default _default;

package/dist/core/abstractions/PositionalAudio.vue.d.ts

@@ -11,7 +11,7 @@ export interface PositionalAudioProps {
     outerGain?: number;
 }
 declare const _default: import('vue').DefineComponent<PositionalAudioProps, {
-    root: import('vue').ShallowRef<PositionalAudio | null>;
+    instance: import('vue').ShallowRef<PositionalAudio | null, PositionalAudio | null>;
     play: () => void;
     stop: () => void;
     pause: () => void;

package/dist/core/abstractions/Reflector.vue.d.ts

@@ -57,10 +57,17 @@ export interface ReflectorProps {
     shader?: object;
 }
 declare function __VLS_template(): {
-    default?(_: {}): any;
+    slots: {
+        default?(_: {}): any;
+    };
+    refs: {
+        reflectorRef: unknown;
+    };
+    attrs: Partial<{}>;
 };
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
 declare const __VLS_component: import('vue').DefineComponent<ReflectorProps, {
-    instance: import('vue').ShallowRef<Reflector | undefined>;
+    instance: import('vue').ShallowRef<Reflector | undefined, Reflector | undefined>;
 }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<ReflectorProps> & Readonly<{}>, {
     color: TresColor;
     textureWidth: number;
@@ -69,7 +76,7 @@ declare const __VLS_component: import('vue').DefineComponent<ReflectorProps, {
     multisample: number;
     shader: object;
 }, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
-declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, ReturnType<typeof __VLS_template>>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
 export default _default;
 type __VLS_WithTemplateSlots<T, S> = T & {
     new (): {

package/dist/core/abstractions/ScreenSizer.vue.d.ts

@@ -0,0 +1,35 @@
+declare function __VLS_template(): {
+    slots: {
+        default?(_: {}): any;
+    };
+    refs: {
+        outerRef: import('vue').CreateComponentPublicInstanceWithMixins<Readonly<import('@tresjs/core').Mutable<import('@tresjs/core').Overwrite<Partial<import('@tresjs/core').Overwrite<import('three').Object3D<import('three').Object3DEventMap>, import('@tresjs/core').WithMathProps<import('three').Object3D<import('three').Object3DEventMap>> & import('@tresjs/core').VueProps & Partial<import('@tresjs/core').EventHandlers>>>, Omit<import('@tresjs/core').InstanceProps<import('three').Object3D<import('three').Object3DEventMap>, typeof import('three').Object3D>, "object">>>>, {}, {}, import('vue').ComputedOptions, import('vue').MethodOptions, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, import('vue').PublicProps, {}, true, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {}, any, import('vue').ComponentProvideOptions, {
+            P: {};
+            B: {};
+            D: {};
+            C: {};
+            M: {};
+            Defaults: {};
+        }, Readonly<import('@tresjs/core').Mutable<import('@tresjs/core').Overwrite<Partial<import('@tresjs/core').Overwrite<import('three').Object3D<import('three').Object3DEventMap>, import('@tresjs/core').WithMathProps<import('three').Object3D<import('three').Object3DEventMap>> & import('@tresjs/core').VueProps & Partial<import('@tresjs/core').EventHandlers>>>, Omit<import('@tresjs/core').InstanceProps<import('three').Object3D<import('three').Object3DEventMap>, typeof import('three').Object3D>, "object">>>>, {}, {}, import('vue').ComputedOptions, import('vue').MethodOptions, {}> | null;
+        innerRef: import('vue').CreateComponentPublicInstanceWithMixins<Readonly<import('@tresjs/core').Mutable<import('@tresjs/core').Overwrite<Partial<import('@tresjs/core').Overwrite<import('three').Object3D<import('three').Object3DEventMap>, import('@tresjs/core').WithMathProps<import('three').Object3D<import('three').Object3DEventMap>> & import('@tresjs/core').VueProps & Partial<import('@tresjs/core').EventHandlers>>>, Omit<import('@tresjs/core').InstanceProps<import('three').Object3D<import('three').Object3DEventMap>, typeof import('three').Object3D>, "object">>>>, {}, {}, import('vue').ComputedOptions, import('vue').MethodOptions, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, import('vue').PublicProps, {}, true, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {}, any, import('vue').ComponentProvideOptions, {
+            P: {};
+            B: {};
+            D: {};
+            C: {};
+            M: {};
+            Defaults: {};
+        }, Readonly<import('@tresjs/core').Mutable<import('@tresjs/core').Overwrite<Partial<import('@tresjs/core').Overwrite<import('three').Object3D<import('three').Object3DEventMap>, import('@tresjs/core').WithMathProps<import('three').Object3D<import('three').Object3DEventMap>> & import('@tresjs/core').VueProps & Partial<import('@tresjs/core').EventHandlers>>>, Omit<import('@tresjs/core').InstanceProps<import('three').Object3D<import('three').Object3DEventMap>, typeof import('three').Object3D>, "object">>>>, {}, {}, import('vue').ComputedOptions, import('vue').MethodOptions, {}> | null;
+    };
+    attrs: Partial<{}>;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<{}, {
+    instance: import('vue').ShallowRef<any, any>;
+}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/core/abstractions/ScreenSpace.vue.d.ts

@@ -0,0 +1,32 @@
+export interface ScreenSpaceProps {
+    depth?: number;
+}
+declare function __VLS_template(): {
+    slots: {
+        default?(_: {}): any;
+    };
+    refs: {
+        outerRef: import('vue').CreateComponentPublicInstanceWithMixins<Readonly<import('@tresjs/core').Mutable<import('@tresjs/core').Overwrite<Partial<import('@tresjs/core').Overwrite<import('three').Group<import('three').Object3DEventMap>, import('@tresjs/core').WithMathProps<import('three').Group<import('three').Object3DEventMap>> & import('@tresjs/core').VueProps & Partial<import('@tresjs/core').EventHandlers>>>, Omit<import('@tresjs/core').InstanceProps<import('three').Group<import('three').Object3DEventMap>, typeof import('three').Group>, "object">>>>, {}, {}, import('vue').ComputedOptions, import('vue').MethodOptions, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, import('vue').PublicProps, {}, true, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {}, any, import('vue').ComponentProvideOptions, {
+            P: {};
+            B: {};
+            D: {};
+            C: {};
+            M: {};
+            Defaults: {};
+        }, Readonly<import('@tresjs/core').Mutable<import('@tresjs/core').Overwrite<Partial<import('@tresjs/core').Overwrite<import('three').Group<import('three').Object3DEventMap>, import('@tresjs/core').WithMathProps<import('three').Group<import('three').Object3DEventMap>> & import('@tresjs/core').VueProps & Partial<import('@tresjs/core').EventHandlers>>>, Omit<import('@tresjs/core').InstanceProps<import('three').Group<import('three').Object3DEventMap>, typeof import('three').Group>, "object">>>>, {}, {}, import('vue').ComputedOptions, import('vue').MethodOptions, {}> | null;
+    };
+    attrs: Partial<{}>;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<ScreenSpaceProps, {
+    instance: import('vue').ShallowRef<any, any>;
+}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<ScreenSpaceProps> & Readonly<{}>, {
+    depth: number;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};