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

package/dist/composables/useOnDemandInvalidation.d.ts

@@ -0,0 +1,3 @@
+export declare function useOnDemandInvalidation(props: Record<string, any>): {
+    invalidateOnDemand: () => void;
+};

package/dist/core/abstractions/AnimatedSprite/Atlas.d.ts

@@ -0,0 +1,38 @@
+import { Texture } from 'three';
+
+export declare function getTextureAndAtlasAsync(imagePathOrImageData: string, atlasPathOrAtlasish: string | Atlasish): Promise<[Texture, Atlas]>;
+export interface AtlasFrame {
+    name: string;
+    width: number;
+    height: number;
+    offsetX: number;
+    offsetY: number;
+    repeatX: number;
+    repeatY: number;
+}
+export interface Atlas {
+    frames: AtlasFrame[];
+    animations: Record<string, AtlasFrame[]>;
+}
+export declare function getAtlas(atlasish: Atlasish, textureWidth: number, textureHeight: number): Atlas;
+export declare function getAtlasFrames(atlas: Atlas, animationNameOrFrameNumber: string | number | [number, number], reversed: boolean): AtlasFrame[];
+export declare function getNullAtlasFrame(): AtlasFrame;
+export type AtlasData = TexturePackerFrameDataArray | TexturePackerFrameDataObject;
+export type Atlasish = AtlasData | [number, number] | number;
+interface TexturePackerFrameData {
+    filename: string;
+    frame: {
+        x: number;
+        y: number;
+        w: number;
+        h: number;
+    };
+}
+interface TexturePackerFrameDataArray {
+    frames: TexturePackerFrameData[];
+}
+interface TexturePackerFrameDataObject {
+    frames: Record<string, TexturePackerFrameData>;
+}
+export declare function setAtlasDefinitions(atlas: Atlas, definitions?: Record<string, string>): void;
+export {};

package/dist/core/abstractions/AnimatedSprite/AtlasAnimationDefinitionParser.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Expand an animation definition string into an array of numbers.
+ * @param definitionStr - A comma-separated string of frame numbers with optional parentheses-surrounded durations.
+ * @example - expand("0,2") === [0,2]
+ * @example - expand("2(10)") === [2,2,2,2,2,2,2,2,2,2]
+ * @example - expand("1-4") === [1,2,3,4]
+ * @example - expand("10-5(2)") === [10,10,9,9,8,8,7,7,6,6,5,5]
+ * @example - expand("1-4(3),10(2)") === [1,1,1,2,2,2,3,3,3,4,4,4,10,10]
+ */
+export declare function expand(definitionStr: string): number[];

package/dist/core/abstractions/AnimatedSprite/StringOps.d.ts

@@ -0,0 +1,2 @@
+export declare function stripUnderscoresNumbersFromEnd(str: string): string;
+export declare function getNumbersFromEnd(str: string): number | null;

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

@@ -0,0 +1,130 @@
+import { TresVector2 } from '@tresjs/core';
+import { Intersection } from 'three';
+import { Atlasish } from './Atlas';
+
+export interface AnimatedSpriteProps {
+    /** URL of the image texture or an image dataURL. This prop is not reactive. */
+    image: string;
+    /**
+     * If `string`, the URL of the JSON atlas.
+     * If `number`, the number of columns in the texture.
+     * If `[number, number]`, the number of columns/rows in the texture.
+     * If `AtlasData`, the atlas as a JS object.
+     * This prop is not reactive.
+     */
+    atlas: string | Atlasish;
+    /**
+    * Specify playback frame order and repeated frames (delays). `definitions` is a record where keys are atlas animation names and values are strings containing an animation definition.
+    * A "animation definition" comma-separated string of frame numbers with optional parentheses-surrounded durations.
+    * Here is how various definition strings convert to arrays of frames for playback:
+    * "0,2,1" - [0,2,1], i.e., play frame 0, 2, then 1.
+    * "2(10)" - [2,2,2,2,2,2,2,2,2,2], i.e., play from 2 10 times.
+    * "1-4" - [1,2,3,4]
+    * "10-5(2)" - [10,10,9,9,8,8,7,7,6,6,5,5]
+    * "1-4(3),10(2)" - [1,1,1,2,2,2,3,3,3,4,4,4,10,10]
+     */
+    definitions?: Record<string, string>;
+    /** Desired frames per second of the animation. */
+    fps?: number;
+    /** Whether or not the animation should loop. */
+    loop?: boolean;
+    /** If `string`, name of the animation to play. If `[number, number]`, start and end frames of the animation. If `number`, frame number to display. */
+    animation?: string | [number, number] | number;
+    /** Event callback when the animation ends. */
+    paused?: boolean;
+    /** Whether to play the animation in reverse. */
+    reversed?: boolean;
+    /** Whether the sprite should be flipped, left to right. */
+    flipX?: boolean;
+    /** For a non-looping animation, when the animation ends, whether to display the zeroth frame. */
+    resetOnEnd?: boolean;
+    /** Whether to display the object as a THREE.Sprite. [See THREE.Sprite](https://threejs.org/docs/?q=sprite#api/en/objects/Sprite) */
+    asSprite?: boolean;
+    /** Anchor point of the object. A value of [0.5, 0.5] corresponds to the center. [0, 0] is left, bottom. */
+    center?: TresVector2;
+    /** Alpha test value for the material. [See THREE.Material.alphaTest](https://threejs.org/docs/#api/en/materials/Material.alphaTest) */
+    alphaTest?: number;
+    /** Depth test value for the material. [See THREE.Material.depthTest](https://threejs.org/docs/#api/en/materials/Material.depthTest) */
+    depthTest?: boolean;
+    /** Depth write value for the material. [See THREE.Material.depthWrite](https://threejs.org/docs/#api/en/materials/Material.depthWrite) */
+    depthWrite?: boolean;
+}
+declare function __VLS_template(): {
+    default?(_: {}): any;
+};
+declare const __VLS_component: import('vue').DefineComponent<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<AnimatedSpriteProps>, {
+    fps: number;
+    loop: boolean;
+    animation: number;
+    paused: boolean;
+    reversed: boolean;
+    flipX: boolean;
+    resetOnEnd: boolean;
+    asSprite: boolean;
+    center: () => number[];
+    alphaTest: number;
+    depthTest: boolean;
+    depthWrite: boolean;
+}>, {
+    instance: import('vue').ShallowRef<any>;
+}, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    frame: (frameName: string) => void;
+    end: (frameName: string) => void;
+    loop: (frameName: string) => void;
+    click: (event: Intersection<import('three').Object3D<import('three').Object3DEventMap>>) => void;
+}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<AnimatedSpriteProps>, {
+    fps: number;
+    loop: boolean;
+    animation: number;
+    paused: boolean;
+    reversed: boolean;
+    flipX: boolean;
+    resetOnEnd: boolean;
+    asSprite: boolean;
+    center: () => number[];
+    alphaTest: number;
+    depthTest: boolean;
+    depthWrite: boolean;
+}>>> & {
+    onClick?: ((event: Intersection<import('three').Object3D<import('three').Object3DEventMap>>) => any) | undefined;
+    onLoop?: ((frameName: string) => any) | undefined;
+    onFrame?: ((frameName: string) => any) | undefined;
+    onEnd?: ((frameName: string) => any) | undefined;
+}, {
+    loop: boolean;
+    depthTest: boolean;
+    depthWrite: boolean;
+    alphaTest: number;
+    center: TresVector2;
+    fps: number;
+    animation: string | [number, number] | number;
+    paused: boolean;
+    reversed: boolean;
+    flipX: boolean;
+    resetOnEnd: boolean;
+    asSprite: boolean;
+}, {}>;
+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> = {
+    [K in keyof T]-?: {} extends Pick<T, K> ? {
+        type: import('vue').PropType<__VLS_NonUndefinedable<T[K]>>;
+    } : {
+        type: import('vue').PropType<T[K]>;
+        required: true;
+    };
+};
+type __VLS_WithDefaults<P, D> = {
+    [K in keyof Pick<P, keyof P>]: K extends keyof D ? __VLS_Prettify<P[K] & {
+        default: D[K];
+    }> : P[K];
+};
+type __VLS_Prettify<T> = {
+    [K in keyof T]: T[K];
+} & {};
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/core/abstractions/GlobalAudio.d.ts

@@ -47,4 +47,4 @@ export interface AudioProps {
      */
     playbackRate?: number;
 }
-export declare const GlobalAudio: import("vue").DefineComponent<AudioProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<AudioProps>, {}, {}>;
+export declare const GlobalAudio: import('vue').DefineComponent<AudioProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<AudioProps>, {}, {}>;

package/dist/core/abstractions/Lensflare/RandUtils.d.ts

@@ -6,8 +6,8 @@ export default class RandUtils {
     private _getGenerator;
     /**
      * Create a new seeded pseudorandom number generator.
-     * @param [seed=0] - the seed for the generator
-     * @param [getSeededRandomGenerator=getMulberry32] - a function that returns a pseudorandom number generator
+     * @param [seed] - the seed for the generator
+     * @param [getSeededRandomGenerator] - a function that returns a pseudorandom number generator
      * @constructor
      */
     constructor(seed?: number, getSeededRandomGenerator?: (seed: number) => () => number);

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

@@ -1,7 +1,8 @@
 import { Lensflare } from 'three/examples/jsm/objects/Lensflare';
-import type { Texture } from 'three';
-import type { TresColor } from '@tresjs/core';
-import type { LensflareElementProps, SeedProps } from '.';
+import { Texture } from 'three';
+import { TresColor } from '@tresjs/core';
+import { LensflareElementProps, SeedProps } from '.';
+
 export interface LensflareProps {
     /**
      * scale of the lensflare
@@ -12,8 +13,8 @@ export interface LensflareProps {
      */
     elements?: Partial<LensflareElementProps>[];
     /**
-       * random seed for generating random seeded elements
-       */
+     * random seed for generating random seeded elements
+     */
     seed?: number;
     /**
      * specifications for generating random seeded elements
@@ -36,7 +37,7 @@ export interface LensflareProps {
      */
     texture?: Texture | string[];
 }
-declare const _default: import("vue").DefineComponent<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<LensflareProps>, {
+declare const _default: import('vue').DefineComponent<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<LensflareProps>, {
     scale: number;
     elements: undefined;
     seed: undefined;
@@ -46,8 +47,8 @@ declare const _default: import("vue").DefineComponent<__VLS_WithDefaults<__VLS_T
     size: undefined;
     texture: undefined;
 }>, {
-    value: import("vue").ShallowRef<Lensflare | undefined>;
-}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<LensflareProps>, {
+    instance: import('vue').ShallowRef<Lensflare | undefined>;
+}, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<LensflareProps>, {
     scale: number;
     elements: undefined;
     seed: undefined;
@@ -57,14 +58,14 @@ declare const _default: import("vue").DefineComponent<__VLS_WithDefaults<__VLS_T
     size: undefined;
     texture: undefined;
 }>>>, {
-    color: import("three").ColorRepresentation | [r: number, g: number, b: number];
-    texture: string[] | Texture;
+    color: TresColor;
+    texture: Texture | string[];
     scale: number;
-    elements: Partial<LensflareElementProps>[];
+    distance: number;
     size: number;
+    elements: Partial<LensflareElementProps>[];
     seed: number;
     seedProps: SeedProps[];
-    distance: number;
 }, {}>;
 export default _default;
 type __VLS_NonUndefinedable<T> = T extends undefined ? never : T;

package/dist/core/abstractions/Lensflare/constants.d.ts

@@ -1,4 +1,5 @@
-import type { LensflareElementProps, SeedProps } from '.';
+import { LensflareElementProps, SeedProps } from '.';
+
 export declare const TEXTURE_PATH = "https://raw.githubusercontent.com/Tresjs/assets/93976c7d63ac83d4a254a41a10b2362bc17e90c9/textures/lensflare/";
 export declare const circle = "https://raw.githubusercontent.com/Tresjs/assets/93976c7d63ac83d4a254a41a10b2362bc17e90c9/textures/lensflare/circle.png";
 export declare const circleBlur = "https://raw.githubusercontent.com/Tresjs/assets/93976c7d63ac83d4a254a41a10b2362bc17e90c9/textures/lensflare/circleBlur.png";

package/dist/core/abstractions/Lensflare/index.d.ts

@@ -1,6 +1,7 @@
-import type { Texture } from 'three';
-import type { TresColor } from '@tresjs/core';
-import Lensflare from './component.vue';
+import { Texture } from 'three';
+import { TresColor } from '@tresjs/core';
+import { default as Lensflare } from './component.vue';
+
 export { Lensflare };
 export interface SeedProps {
     texture: string[];
@@ -25,7 +26,7 @@ export interface SeedProps {
  * @param seedProps - `undefined` or an array of SeedProps for generating random seeded properties
  * @param systemDefaultElement - default values to "fill in" any remaining missing props
  * @returns LensflareElementProps[] - An array of complete props
- **/
+ */
 export declare const partialLensflarePropsArrayToLensflarePropsArray: (elements: Partial<LensflareElementProps>[] | undefined, userDefaultElement: Partial<LensflareElementProps>, seed?: number | undefined, seedProps?: SeedProps[] | undefined, systemDefaultElement?: LensflareElementProps) => LensflareElementProps[];
 export interface LensflareElementProps {
     texture: Texture | string;

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

@@ -1,20 +1,23 @@
-declare const _default: __VLS_WithTemplateSlots<import("vue").DefineComponent<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<{
-    speed: number;
-    rotationFactor?: number | undefined;
-    floatFactor?: number | undefined;
-    range?: [number, number] | undefined;
+declare function __VLS_template(): {
+    default?(_: {}): any;
+};
+declare const __VLS_component: import('vue').DefineComponent<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<{
+    speed?: number;
+    rotationFactor?: number;
+    floatFactor?: number;
+    range?: [number, number];
 }>, {
     speed: number;
     rotationFactor: number;
     floatFactor: number;
     range: () => number[];
 }>, {
-    value: 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;
-    rotationFactor?: number | undefined;
-    floatFactor?: number | undefined;
-    range?: [number, 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;
+    rotationFactor?: number;
+    floatFactor?: number;
+    range?: [number, number];
 }>, {
     speed: number;
     rotationFactor: number;
@@ -25,9 +28,8 @@ declare const _default: __VLS_WithTemplateSlots<import("vue").DefineComponent<__
     rotationFactor: number;
     floatFactor: number;
     range: [number, number];
-}, {}>, {
-    default?(_: {}): any;
-}>;
+}, {}>;
+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/abstractions/MouseParallax.vue.d.ts

@@ -9,33 +9,44 @@ export interface MouseParallaxProps {
     disabled?: boolean;
     /**
      * The factor to multiply the mouse movement by.
-     * @type {number}
+     * @type {number | [number, number]}
      * @default 2.5
      * @memberof MouseParallaxProps
      *
-     **/
-    factor?: number;
+     */
+    factor?: number | [number, number];
     /**
-     * The factor to multiply the mouse movement by.
-     * @type {number}
+     * The factor to smooth the mouse movement by.
+     * @type {number | [number, number]}
      * @default 2.5
      * @memberof MouseParallaxProps
      *
-     **/
-    ease?: number;
+     */
+    ease?: number | [number, number];
+    /**
+     * Whether to apply the parallax effect to the local canvas.
+     * @type {boolean}
+     * @default false
+     * @memberof MouseParallaxProps
+     *
+     */
+    local?: boolean;
 }
-declare const _default: import("vue").DefineComponent<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<MouseParallaxProps>, {
+declare const _default: import('vue').DefineComponent<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<MouseParallaxProps>, {
     disabled: boolean;
     factor: number;
     ease: number;
-}>, {}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<MouseParallaxProps>, {
+    local: boolean;
+}>, {}, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<MouseParallaxProps>, {
     disabled: boolean;
     factor: number;
     ease: number;
+    local: boolean;
 }>>>, {
     disabled: boolean;
-    factor: number;
-    ease: number;
+    factor: number | [number, number];
+    ease: number | [number, number];
+    local: boolean;
 }, {}>;
 export default _default;
 type __VLS_NonUndefinedable<T> = T extends undefined ? never : T;

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

@@ -0,0 +1,69 @@
+import { PositionalAudio } from 'three';
+
+export interface PositionalAudioProps {
+    ready: boolean;
+    url: string;
+    distance?: number;
+    helper?: boolean;
+    loop?: boolean;
+    autoplay?: boolean;
+    innerAngle?: number;
+    outerAngle?: number;
+    outerGain?: number;
+}
+declare const _default: import('vue').DefineComponent<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<PositionalAudioProps>, {
+    ready: boolean;
+    helper: boolean;
+    distance: number;
+    loop: boolean;
+    autoplay: boolean;
+    innerAngle: number;
+    outerAngle: number;
+    outerGain: number;
+}>, {
+    root: import('vue').ShallowRef<PositionalAudio | null>;
+    play: () => void;
+    stop: () => void;
+    pause: () => void;
+    dispose: () => void;
+}, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    isPlaying: (...args: any[]) => void;
+}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<PositionalAudioProps>, {
+    ready: boolean;
+    helper: boolean;
+    distance: number;
+    loop: boolean;
+    autoplay: boolean;
+    innerAngle: number;
+    outerAngle: number;
+    outerGain: number;
+}>>> & {
+    onIsPlaying?: ((...args: any[]) => any) | undefined;
+}, {
+    ready: boolean;
+    distance: number;
+    helper: boolean;
+    loop: boolean;
+    autoplay: boolean;
+    innerAngle: number;
+    outerAngle: number;
+    outerGain: number;
+}, {}>;
+export default _default;
+type __VLS_NonUndefinedable<T> = T extends undefined ? never : T;
+type __VLS_TypePropsToRuntimeProps<T> = {
+    [K in keyof T]-?: {} extends Pick<T, K> ? {
+        type: import('vue').PropType<__VLS_NonUndefinedable<T[K]>>;
+    } : {
+        type: import('vue').PropType<T[K]>;
+        required: true;
+    };
+};
+type __VLS_WithDefaults<P, D> = {
+    [K in keyof Pick<P, keyof P>]: K extends keyof D ? __VLS_Prettify<P[K] & {
+        default: D[K];
+    }> : P[K];
+};
+type __VLS_Prettify<T> = {
+    [K in keyof T]: T[K];
+} & {};

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

@@ -1,5 +1,6 @@
-import type { TresColor } from '@tresjs/core';
-import { Reflector } from 'three/examples/jsm/objects/Reflector.js';
+import { TresColor } from '@tresjs/core';
+import { Reflector } from 'three-stdlib';
+
 export interface ReflectorProps {
     /**
      * The color of the reflector.
@@ -56,7 +57,10 @@ export interface ReflectorProps {
      */
     shader?: object;
 }
-declare const _default: __VLS_WithTemplateSlots<import("vue").DefineComponent<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<ReflectorProps>, {
+declare function __VLS_template(): {
+    default?(_: {}): any;
+};
+declare const __VLS_component: import('vue').DefineComponent<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<ReflectorProps>, {
     color: string;
     textureWidth: number;
     textureHeight: number;
@@ -64,8 +68,8 @@ declare const _default: __VLS_WithTemplateSlots<import("vue").DefineComponent<__
     multisample: number;
     shader: any;
 }>, {
-    reflectorRef: import("vue").ShallowRef<Reflector | undefined>;
-}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<ReflectorProps>, {
+    instance: import('vue').ShallowRef<Reflector | undefined>;
+}, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<ReflectorProps>, {
     color: string;
     textureWidth: number;
     textureHeight: number;
@@ -73,15 +77,14 @@ declare const _default: __VLS_WithTemplateSlots<import("vue").DefineComponent<__
     multisample: number;
     shader: any;
 }>>>, {
-    color: import("three").ColorRepresentation | [r: number, g: number, b: number];
+    color: TresColor;
     textureWidth: number;
     textureHeight: number;
     clipBias: number;
     multisample: number;
     shader: object;
-}, {}>, {
-    default?(_: {}): any;
-}>;
+}, {}>;
+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/abstractions/Text3D.vue.d.ts

@@ -114,7 +114,10 @@ export interface Text3DProps {
      */
     needUpdates?: boolean;
 }
-declare const _default: __VLS_WithTemplateSlots<import("vue").DefineComponent<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<Text3DProps>, {
+declare function __VLS_template(): {
+    default?(_: {}): any;
+};
+declare const __VLS_component: import('vue').DefineComponent<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<Text3DProps>, {
     size: number;
     height: number;
     curveSegments: number;
@@ -126,8 +129,8 @@ declare const _default: __VLS_WithTemplateSlots<import("vue").DefineComponent<__
     center: boolean;
     needUpdates: boolean;
 }>, {
-    value: import("vue").ShallowRef<any>;
-}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<Text3DProps>, {
+    instance: import('vue').ShallowRef<any>;
+}, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<Text3DProps>, {
     size: number;
     height: number;
     curveSegments: number;
@@ -149,9 +152,8 @@ declare const _default: __VLS_WithTemplateSlots<import("vue").DefineComponent<__
     bevelOffset: number;
     bevelSegments: number;
     needUpdates: boolean;
-}, {}>, {
-    default?(_: {}): any;
-}>;
+}, {}>;
+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/abstractions/index.d.ts

@@ -1,13 +1,16 @@
-import Text3D from './Text3D.vue';
+import { default as Text3D } from './Text3D.vue';
 import { useAnimations } from './useAnimations';
-import Levioso from './Levioso.vue';
-import Reflector from './Reflector.vue';
-import MouseParallax from './MouseParallax.vue';
+import { default as Levioso } from './Levioso.vue';
+import { default as Reflector } from './Reflector.vue';
+import { default as MouseParallax } from './MouseParallax.vue';
 import { GlobalAudio } from './GlobalAudio';
-import Lensflare from './Lensflare/component.vue';
-import Fbo from './useFBO/component.vue';
-import Sampler from './useSurfaceSampler/component.vue';
+import { default as Lensflare } from './Lensflare/component.vue';
+import { default as Fbo } from './useFBO/component.vue';
+import { default as Sampler } from './useSurfaceSampler/component.vue';
+import { default as AnimatedSprite } from './AnimatedSprite/component.vue';
+import { default as PositionalAudio } from './PositionalAudio.vue';
+
 export * from './useFBO/';
 export * from './useSurfaceSampler';
 export * from '../staging/useEnvironment';
-export { Text3D, useAnimations, MouseParallax, Levioso, Reflector, Lensflare, GlobalAudio, Fbo, Sampler, };
+export { Text3D, useAnimations, MouseParallax, Levioso, Reflector, Lensflare, GlobalAudio, Fbo, Sampler, AnimatedSprite, PositionalAudio, };

package/dist/core/abstractions/useAnimations.d.ts

@@ -1,6 +1,6 @@
-import type { AnimationAction, AnimationClip, Object3D, Scene } from 'three';
-import { AnimationMixer } from 'three';
-import type { Ref } from 'vue';
+import { AnimationAction, AnimationClip, Object3D, Scene, AnimationMixer } from 'three';
+import { Ref } from 'vue';
+
 /**
  * Creates an AnimationMixer and returns it.
  *
@@ -11,7 +11,7 @@ import type { Ref } from 'vue';
  * @return {*}
  */
 export declare function useAnimations<T extends AnimationClip>(animations: T[], modelRef?: Scene | Ref<Object3D | undefined | null>): {
-    actions: import("vue").ShallowReactive<{
+    actions: import('vue').ShallowReactive<{
         [key: string]: AnimationAction;
     }>;
     mixer: AnimationMixer;

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

@@ -1,14 +1,15 @@
-import type { FboOptions } from '.';
-declare const _default: import("vue").DefineComponent<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<FboOptions>, {
+import { FboOptions } from '.';
+
+declare const _default: import('vue').DefineComponent<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<FboOptions>, {
     depth: boolean;
     settings: undefined;
 }>, {
-    value: import("vue").Ref<import("three").WebGLRenderTarget<import("three").Texture> | null>;
-}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<FboOptions>, {
+    instance: import('vue').Ref<import('three').WebGLRenderTarget<import('three').Texture> | null>;
+}, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<FboOptions>, {
     depth: boolean;
     settings: undefined;
 }>>>, {
-    settings: import("three").WebGLRenderTargetOptions;
+    settings: import('three').RenderTargetOptions;
     depth: boolean;
 }, {}>;
 export default _default;

package/dist/core/abstractions/useFBO/index.d.ts

@@ -1,10 +1,10 @@
-import type { WebGLRenderTargetOptions } from 'three';
-import { WebGLRenderTarget } from 'three';
-import type { Ref } from 'vue';
+import { RenderTargetOptions, WebGLRenderTarget } from 'three';
+import { Ref } from 'vue';
+
 export interface FboOptions {
     width?: number;
     height?: number;
     depth?: boolean;
-    settings?: WebGLRenderTargetOptions;
+    settings?: RenderTargetOptions;
 }
-export declare function useFBO(options: FboOptions): Ref<WebGLRenderTarget<import("three").Texture> | null>;
+export declare function useFBO(options: FboOptions): Ref<WebGLRenderTarget<import('three').Texture> | null>;