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

package/dist/core/staging/Smoke.vue.d.ts

@@ -1,4 +1,5 @@
-import type { TresColor } from '@tresjs/core';
+import { TresColor } from '@tresjs/core';
+
 export interface SmokeProps {
     /**
      * The color of the smoke.
@@ -65,7 +66,7 @@ export interface SmokeProps {
      */
     depthTest?: boolean;
 }
-declare const _default: import("vue").DefineComponent<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<SmokeProps>, {
+declare const _default: import('vue').DefineComponent<__VLS_WithDefaults<__VLS_TypePropsToOption<SmokeProps>, {
     opacity: number;
     speed: number;
     width: number;
@@ -75,8 +76,8 @@ declare const _default: import("vue").DefineComponent<__VLS_WithDefaults<__VLS_T
     color: string;
     depthTest: 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<SmokeProps>, {
+    instance: import('vue').ShallowRef<any>;
+}, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToOption<SmokeProps>, {
     opacity: number;
     speed: number;
     width: number;
@@ -86,25 +87,16 @@ declare const _default: import("vue").DefineComponent<__VLS_WithDefaults<__VLS_T
     color: string;
     depthTest: boolean;
 }>>>, {
-    speed: number;
-    color: import("three").ColorRepresentation | [r: number, g: number, b: number];
+    color: TresColor;
     texture: string;
-    depthTest: boolean;
-    opacity: number;
+    speed: number;
     width: number;
     depth: number;
+    depthTest: boolean;
+    opacity: number;
     segments: 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];
@@ -113,3 +105,12 @@ type __VLS_WithDefaults<P, D> = {
 type __VLS_Prettify<T> = {
     [K in keyof T]: T[K];
 } & {};
+type __VLS_NonUndefinedable<T> = T extends undefined ? never : T;
+type __VLS_TypePropsToOption<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;
+    };
+};

package/dist/core/staging/Sparkles/ShaderData.d.ts

@@ -1,13 +1,14 @@
 import { DataTexture } from 'three';
-import type { Ref, MaybeRef } from 'vue';
-import type { GradientTresColor, GradientScalar, GradientVectorFlexibleParams } from './../../../utils/Gradient';
+import { MaybeRef, Ref } from 'vue';
+import { GradientScalar, GradientTresColor, GradientVectorFlexibleParams } from './../../../utils/Gradient';
+
 export type CanvasGradientRenderer<T> = (g: CanvasGradient, entry: ShaderDataEntry<T>) => void;
 export declare class ShaderData {
     private entries;
     private resolution;
     constructor(entries: ShaderDataEntry<any>[], resolution: number);
     useTexture(): {
-        texture: import("vue").ShallowRef<DataTexture>;
+        texture: import('vue').ShallowRef<DataTexture>;
         dispose: () => void;
         yFor: Record<string, number>;
     };

package/dist/core/staging/Sparkles/ShaderDataBuilder.d.ts

@@ -1,10 +1,10 @@
-import type { MaybeRef } from 'vue';
-import type { GradientTresColor, GradientScalar, GradientVectorFlexibleParams } from './../../../utils/Gradient';
-import type { ShaderDataEntry, CanvasGradientRenderer } from './ShaderData';
-import { ShaderData } from './ShaderData';
-declare const rgbaSuffixes: readonly ["r", "rg", "rgb", "rgba"];
-declare const xyzwSuffixes: readonly ["x", "xy", "xyz", "xyzw"];
-type ShaderSuffix = (typeof rgbaSuffixes)[number] | (typeof xyzwSuffixes)[number];
+import { MaybeRef } from 'vue';
+import { GradientScalar, GradientTresColor, GradientVectorFlexibleParams } from './../../../utils/Gradient';
+import { CanvasGradientRenderer, ShaderDataEntry, ShaderData } from './ShaderData';
+
+type rgbaSuffixes = ['r', 'rg', 'rgb', 'rgba'];
+type xyzwSuffixes = ['x', 'xy', 'xyz', 'xyzw'];
+type ShaderSuffix = (rgbaSuffixes)[number] | (xyzwSuffixes)[number];
 export default class ShaderDataBuilder {
     private entries;
     private resolution;

package/dist/core/staging/Sparkles/component.vue.d.ts

@@ -1,8 +1,8 @@
-import type { Texture, Blending, BufferGeometry } from 'three';
-import { Object3D } from 'three';
-import type { TresColor } from '@tresjs/core';
-import type { VectorFlexibleParams } from '@tresjs/core/dist/utils/normalize';
-import type { Gradient } from '../../../utils/Gradient';
+import { Blending, BufferGeometry, Texture, Object3D, Points, ShaderMaterial } from 'three';
+import { TresColor } from '@tresjs/core';
+import { VectorFlexibleParams } from '@tresjs/core/dist/utils/normalize';
+import { Gradient } from '../../../utils/Gradient';
+
 interface SparkleProps {
     /**
      * Texture or image path for individual sparkles
@@ -11,9 +11,9 @@ interface SparkleProps {
     /**
      * Vertices of the geometry will be used to emit sparkles. Geometry normals are used for sparkles' traveling direction and for responding to the directional light prop.
      *
-     * * If provided, the component will use the passed geometry.
-     * * If no geometry is provided, the component will try to make a copy of the parent object's geometry.
-     * * If no parent geometry exists, the component will create and use an IcosphereGeometry.
+     * - If provided, the component will use the passed geometry.
+     * - If no geometry is provided, the component will try to make a copy of the parent object's geometry.
+     * - If no parent geometry exists, the component will create and use an IcosphereGeometry.
      */
     geometry?: Object3D | BufferGeometry;
     /**
@@ -93,8 +93,8 @@ interface SparkleProps {
     /**
      * 'mix*' props: A particle "progresses" with a mix of two factors:
      *
-     * * its normal "facing" the directionalLight
-     * * its lifetime
+     * its normal "facing" the directionalLight
+     * its lifetime
      *
      * 'mix*' props specify the relationship between the two factors.
      *
@@ -134,7 +134,7 @@ interface SparkleProps {
      */
     depthWrite?: boolean;
 }
-declare const _default: import("vue").DefineComponent<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<SparkleProps>, {
+declare const _default: import('vue').DefineComponent<__VLS_WithDefaults<__VLS_TypePropsToOption<SparkleProps>, {
     map: string;
     geometry: undefined;
     directionalLight: undefined;
@@ -164,7 +164,9 @@ declare const _default: import("vue").DefineComponent<__VLS_WithDefaults<__VLS_T
     blending: 2;
     transparent: boolean;
     depthWrite: boolean;
-}>, {}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<SparkleProps>, {
+}>, {
+    instance: Points<BufferGeometry<import('three').NormalOrGLBufferAttributes>, ShaderMaterial, import('three').Object3DEventMap>;
+}, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToOption<SparkleProps>, {
     map: string;
     geometry: undefined;
     directionalLight: undefined;
@@ -195,15 +197,14 @@ declare const _default: import("vue").DefineComponent<__VLS_WithDefaults<__VLS_T
     transparent: boolean;
     depthWrite: boolean;
 }>>>, {
-    map: string | Texture;
-    directionalLight: Object3D<import("three").Object3DEventMap>;
-    blending: Blending;
-    depthWrite: boolean;
-    transparent: boolean;
     size: number;
-    geometry: Object3D<import("three").Object3DEventMap> | BufferGeometry<import("three").NormalBufferAttributes>;
+    map: Texture | string;
+    directionalLight: Object3D;
+    geometry: Object3D | BufferGeometry;
     offset: number;
-    alpha: number;
+    depthWrite: boolean;
+    transparent: boolean;
+    blending: Blending;
     lifetimeSec: number;
     cooldownSec: number;
     normalThreshold: number;
@@ -211,11 +212,12 @@ declare const _default: import("vue").DefineComponent<__VLS_WithDefaults<__VLS_T
     scaleNoise: number;
     offsetNoise: number;
     lifetimeNoise: number;
+    alpha: number;
     surfaceDistance: number;
-    sequenceColor: Gradient<import("three").ColorRepresentation | [r: number, g: number, b: number]>;
+    sequenceColor: Gradient<TresColor>;
     sequenceAlpha: Gradient<number>;
-    sequenceOffset: any;
-    sequenceNoise: any;
+    sequenceOffset: Gradient<VectorFlexibleParams>;
+    sequenceNoise: Gradient<VectorFlexibleParams>;
     sequenceSize: Gradient<number>;
     sequenceSurfaceDistance: Gradient<number>;
     mixColor: number;
@@ -226,15 +228,6 @@ declare const _default: import("vue").DefineComponent<__VLS_WithDefaults<__VLS_T
     mixNoise: 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];
@@ -243,3 +236,12 @@ type __VLS_WithDefaults<P, D> = {
 type __VLS_Prettify<T> = {
     [K in keyof T]: T[K];
 } & {};
+type __VLS_NonUndefinedable<T> = T extends undefined ? never : T;
+type __VLS_TypePropsToOption<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;
+    };
+};

package/dist/core/staging/Sparkles/useEmptyDataTexture.d.ts

@@ -1,2 +1,3 @@
 import { DataTexture } from 'three';
+
 export default function useEmptyDataTexture(): DataTexture;

package/dist/core/staging/Stars.vue.d.ts

@@ -64,7 +64,7 @@ export interface StarsProps {
      */
     alphaMap?: null;
 }
-declare const _default: import("vue").DefineComponent<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<StarsProps>, {
+declare const _default: import('vue').DefineComponent<__VLS_WithDefaults<__VLS_TypePropsToOption<StarsProps>, {
     size: number;
     sizeAttenuation: boolean;
     transparent: boolean;
@@ -74,8 +74,8 @@ declare const _default: import("vue").DefineComponent<__VLS_WithDefaults<__VLS_T
     depth: number;
     radius: 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<StarsProps>, {
+    instance: import('vue').ShallowRef<any>;
+}, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToOption<StarsProps>, {
     size: number;
     sizeAttenuation: boolean;
     transparent: boolean;
@@ -85,25 +85,16 @@ declare const _default: import("vue").DefineComponent<__VLS_WithDefaults<__VLS_T
     depth: number;
     radius: number;
 }>>>, {
-    alphaTest: number;
-    transparent: boolean;
-    count: number;
-    radius: number;
     size: number;
     depth: number;
+    count: number;
+    alphaTest: number;
     alphaMap: null;
     sizeAttenuation: boolean;
+    transparent: boolean;
+    radius: 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];
@@ -112,3 +103,12 @@ type __VLS_WithDefaults<P, D> = {
 type __VLS_Prettify<T> = {
     [K in keyof T]: T[K];
 } & {};
+type __VLS_NonUndefinedable<T> = T extends undefined ? never : T;
+type __VLS_TypePropsToOption<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;
+    };
+};

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

@@ -1,10 +1,13 @@
-import Environment from './useEnvironment/component.vue';
-import Backdrop from './Backdrop.vue';
-import ContactShadows from './ContactShadows.vue';
-import Precipitation from './Precipitation.vue';
-import Sky from './Sky.vue';
-import Smoke from './Smoke.vue';
-import Sparkles from './Sparkles/component.vue';
-import Stars from './Stars.vue';
-import Ocean from './Ocean.vue';
-export { Backdrop, ContactShadows, Environment, Precipitation, Sky, Smoke, Sparkles, Stars, Ocean, };
+import { default as Environment } from './useEnvironment/component.vue';
+import { default as Lightformer } from './useEnvironment/lightformer/index.vue';
+import { default as Backdrop } from './Backdrop.vue';
+import { default as ContactShadows } from './ContactShadows.vue';
+import { default as Fit } from './Fit.vue';
+import { default as Precipitation } from './Precipitation.vue';
+import { default as Sky } from './Sky.vue';
+import { default as Smoke } from './Smoke.vue';
+import { default as Sparkles } from './Sparkles/component.vue';
+import { default as Stars } from './Stars.vue';
+import { default as Ocean } from './Ocean.vue';
+
+export { Backdrop, ContactShadows, Environment, Fit, Precipitation, Sky, Smoke, Sparkles, Stars, Ocean, Lightformer, };

package/dist/core/staging/useEnvironment/component.vue.d.ts

@@ -0,0 +1,64 @@
+import { Ref } from 'vue';
+import { CubeTexture, Texture } from 'three';
+import { EnvironmentOptions } from './const';
+
+declare function __VLS_template(): {
+    default?(_: {}): any;
+};
+declare const __VLS_component: import('vue').DefineComponent<__VLS_WithDefaults<__VLS_TypePropsToOption<EnvironmentOptions>, {
+    background: boolean;
+    blur: number;
+    files: never[];
+    path: string;
+    preset: undefined;
+    resolution: number;
+    near: number;
+    far: number;
+    frames: number;
+}>, {
+    texture: Ref<Texture | CubeTexture | null>;
+}, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToOption<EnvironmentOptions>, {
+    background: boolean;
+    blur: number;
+    files: never[];
+    path: string;
+    preset: undefined;
+    resolution: number;
+    near: number;
+    far: number;
+    frames: number;
+}>>>, {
+    path: string;
+    background: boolean | string;
+    blur: number;
+    preset: import('./const').EnvironmentPresetsType;
+    files: string | string[];
+    resolution: number;
+    near: number;
+    far: number;
+    frames: number;
+}, {}>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, ReturnType<typeof __VLS_template>>;
+export default _default;
+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;
+    };
+};
+type __VLS_NonUndefinedable<T> = T extends undefined ? never : T;
+type __VLS_TypePropsToOption<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;
+    };
+};

package/dist/core/staging/useEnvironment/const.d.ts

@@ -33,6 +33,34 @@ export interface EnvironmentOptions {
      * @type {EnvironmentPresetsType}
      */
     preset?: EnvironmentPresetsType;
+    /**
+     * The resolution of the WebGLCubeRenderTarget.
+     *
+     * @type {number}
+     * @default 256
+     */
+    resolution?: number;
+    /**
+     * The near of the CubeCamera.
+     *
+     * @type {number}
+     * @default 1
+     */
+    near?: number;
+    /**
+     * The far of the CubeCamera.
+     *
+     * @type {number}
+     * @default 1000
+     */
+    far?: number;
+    /**
+     * The frames of the cubeCamera.update.
+     *
+     * @type {number}
+     * @default Infinity
+     */
+    frames?: number;
 }
 export declare const environmentPresets: {
     sunset: string;

package/dist/core/staging/useEnvironment/envSence.d.ts

@@ -0,0 +1,9 @@
+import { Object3D, Scene } from 'three';
+
+declare class EnvSence extends Object3D {
+    virtualScene: Scene;
+    constructor();
+    add(...object: Object3D[]): this;
+    destructor(): void;
+}
+export default EnvSence;

package/dist/core/staging/useEnvironment/index.d.ts

@@ -1,3 +1,5 @@
-import type { CubeTexture, Texture } from 'three';
-import type { EnvironmentOptions } from './const';
-export declare function useEnvironment(options: Partial<EnvironmentOptions>): Promise<Texture | CubeTexture>;
+import { CubeTexture, Texture, WebGLCubeRenderTarget } from 'three';
+import { Ref } from 'vue';
+import { EnvironmentOptions } from './const';
+
+export declare function useEnvironment(options: Partial<EnvironmentOptions>, fbo: Ref<WebGLCubeRenderTarget | undefined>): Promise<Texture | CubeTexture>;

package/dist/core/staging/useEnvironment/lightformer/index.vue.d.ts

@@ -0,0 +1,56 @@
+import { Texture, Color } from 'three';
+
+declare const _default: import('vue').DefineComponent<__VLS_WithDefaults<__VLS_TypePropsToOption<{
+    args?: any[];
+    from?: "circle" | "ring" | "rect" | any;
+    toneMapped?: boolean;
+    map?: Texture;
+    intensity?: number;
+    color?: any;
+}>, {
+    args: any;
+    from: string;
+    toneMapped: boolean;
+    map: any;
+    intensity: number;
+    color: Color;
+}>, {}, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToOption<{
+    args?: any[];
+    from?: "circle" | "ring" | "rect" | any;
+    toneMapped?: boolean;
+    map?: Texture;
+    intensity?: number;
+    color?: any;
+}>, {
+    args: any;
+    from: string;
+    toneMapped: boolean;
+    map: any;
+    intensity: number;
+    color: Color;
+}>>>, {
+    map: Texture;
+    color: any;
+    args: any[];
+    toneMapped: boolean;
+    from: "circle" | "ring" | "rect" | any;
+    intensity: number;
+}, {}>;
+export default _default;
+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_NonUndefinedable<T> = T extends undefined ? never : T;
+type __VLS_TypePropsToOption<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;
+    };
+};