@tresjs/cientos 5.0.0-next.6 → 5.0.0-rc.0

package/dist/core/loaders/useFBX/index.d.ts

@@ -0,0 +1,32 @@
+import { TresObject } from '@tresjs/core';
+import { ComputedRef, MaybeRef, Ref } from 'vue';
+import { Group } from 'three';
+export interface UseFBXOptions {
+    /**
+     * A traverse function applied to the scene upon loading the model.
+     * @type {Function}
+     */
+    traverse?: (child: TresObject) => void;
+}
+/**
+ * Vue composable for loading FBX models in TresJS
+ *
+ * @remarks
+ * This composable uses Three.js FBXLoader under the hood to load FBX 3D models.
+ * The loaded model is automatically parsed and made available as a reactive state.
+ *
+ * @example
+ * ```ts
+ * const { state: model } = useFBX('/path/to/model.fbx')
+ * ```
+ *
+ * @param {MaybeRef<string>} path - Path to the FBX model file
+ * @returns {{ state: Group, isLoading: boolean, execute: () => Promise<void>, nodes: object, materials: object }} Object containing the model state, loading state, reload function, and parsed nodes/materials
+ */
+export declare function useFBX(path: MaybeRef<string>, options?: UseFBXOptions): {
+    state: Ref<Group | null>;
+    isLoading: Ref<boolean>;
+    execute: (delay?: number, ...args: any[]) => Promise<Group>;
+    nodes: ComputedRef<Record<string, any>>;
+    materials: ComputedRef<Record<string, any>>;
+};

package/dist/core/loaders/useGLTF/component.vue.d.ts

@@ -51,7 +51,7 @@ export interface GLTFModelProps {
     decoderPath?: string;
 }
 declare const _default: import('vue').DefineComponent<GLTFModelProps, {
-    instance: import('vue').Ref<import('three-stdlib').GLTF, import('three-stdlib').GLTF>;
+    instance: import('vue').Ref<import('three-stdlib').GLTF | null, import('three-stdlib').GLTF | null>;
 }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<GLTFModelProps> & Readonly<{}>, {
     castShadow: boolean;
     receiveShadow: boolean;

package/dist/core/loaders/useGLTF/index.d.ts

@@ -0,0 +1,43 @@
+import { TresObject } from '@tresjs/core';
+import { ComputedRef, MaybeRef, Ref } from 'vue';
+import { GLTF } from 'three-stdlib';
+export interface UseGLTFOptions {
+    /**
+     * Whether to use DRACO compression for loading the model
+     * @type {boolean}
+     */
+    draco?: boolean;
+    /**
+     * Path to the DRACO decoder. Defaults to https://www.gstatic.com/draco/versioned/decoders/1.5.6/
+     * @type {string}
+     */
+    decoderPath?: string;
+    /**
+     * A traverse function applied to the scene upon loading the model.
+     * @type {Function}
+     */
+    traverse?: (child: TresObject) => void;
+}
+/**
+ * Vue composable for loading GLTF models in TresJS
+ *
+ * @remarks
+ * This composable uses Three.js GLTFLoader under the hood and supports DRACO compression.
+ * When DRACO compression is enabled, it will use the specified decoder path or fallback to Google's CDN.
+ *
+ * @example
+ * ```ts
+ * const { state: model } = useGLTF('/path/to/model.glb', { draco: true })
+ * ```
+ *
+ * @param {MaybeRef<string>} path - Path to the GLTF model file
+ * @param {UseGLTFOptions} options - Options for loading the model
+ * @returns {{ state: GLTF, isLoading: boolean, execute: () => Promise<void> }} Object containing the model state, loading state and reload function
+ */
+export declare function useGLTF(path: MaybeRef<string>, options?: UseGLTFOptions): {
+    state: Ref<GLTF | null>;
+    isLoading: Ref<boolean>;
+    execute: (delay?: number, ...args: any[]) => Promise<GLTF>;
+    nodes: ComputedRef<Record<string, any>>;
+    materials: ComputedRef<Record<string, any>>;
+};

package/dist/core/loaders/useSVG/component.vue.d.ts

@@ -91,7 +91,7 @@ interface SVGProps {
     depth?: 'renderOrder' | 'flat' | 'offsetZ' | number;
 }
 declare const _default: import('vue').DefineComponent<SVGProps, {
-    instance: import('vue').Ref<import('three-stdlib').SVGResult, import('three-stdlib').SVGResult>;
+    instance: import('vue').Ref<import('three-stdlib').SVGResult | null, import('three-stdlib').SVGResult | null>;
     layers: import('vue').ComputedRef<import('.').SVGLayer[]>;
 }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<SVGProps> & Readonly<{}>, {
     depth: "renderOrder" | "flat" | "offsetZ" | number;

package/dist/core/loaders/useSVG/index.d.ts

@@ -0,0 +1,65 @@
+import { ComputedRef, MaybeRef, Ref } from 'vue';
+import { BufferGeometry, MeshBasicMaterialParameters } from 'three';
+import { SVGResult } from 'three-stdlib';
+export interface UseSVGOptions {
+    /**
+     * Whether to skip rendering strokes
+     * @type {boolean}
+     * @default false
+     */
+    skipStrokes?: boolean;
+    /**
+     * Whether to skip rendering fills
+     * @type {boolean}
+     * @default false
+     */
+    skipFills?: boolean;
+    /**
+     * Fill material properties
+     * @type {MeshBasicMaterialParameters}
+     */
+    fillMaterial?: MeshBasicMaterialParameters;
+    /**
+     * Stroke material properties
+     * @type {MeshBasicMaterialParameters}
+     */
+    strokeMaterial?: MeshBasicMaterialParameters;
+    /**
+     * Depth type - how should the resulting meshes be rendered?
+     * 'renderOrder' disables depthWrite and sets renderOrder of each layer
+     * 'flat' disables depthWrite on materials
+     * 'offsetZ' enables depthWrite and inserts small distance between layers
+     * number is treated same as 'offsetZ' using the number as distance
+     * @type {'renderOrder' | 'flat' | 'offsetZ' | number}
+     * @default 'renderOrder'
+     */
+    depth?: 'renderOrder' | 'flat' | 'offsetZ' | number;
+}
+export interface SVGLayer {
+    geometry: BufferGeometry;
+    material: MeshBasicMaterialParameters;
+    isStroke: boolean;
+}
+/**
+ * Vue composable for loading SVG files in TresJS
+ *
+ * @remarks
+ * This composable uses Three.js SVGLoader under the hood to load and process SVG files
+ * into geometries and materials that can be rendered in a 3D scene.
+ *
+ * @example
+ * ```ts
+ * const { state: svg, layers } = useSVG('/path/to/file.svg', { skipStrokes: false })
+ * ```
+ *
+ * @param {MaybeRef<string>} path - Path to the SVG file or SVG data string
+ * @param {UseSVGOptions} options - Options for processing the SVG
+ * @returns Object containing the SVG state, loading state, processed layers and disposal function
+ */
+export declare function useSVG(path: MaybeRef<string>, options?: UseSVGOptions): {
+    state: Ref<SVGResult | null>;
+    isLoading: Ref<boolean>;
+    execute: (delay?: number, ...args: any[]) => Promise<SVGResult>;
+    layers: ComputedRef<SVGLayer[]>;
+    dispose: () => void;
+};

package/dist/core/loaders/useTexture/component.vue.d.ts

@@ -1383,7 +1383,7 @@ declare function __VLS_template(): {
                         };
                         width: number;
                         height: number;
-                    }[] | /*elided*/ any[] | undefined;
+                    }[] | /*elided*/ any[];
                     channel: number;
                     wrapS: import('three').Wrapping;
                     wrapT: import('three').Wrapping;
@@ -2460,7 +2460,7 @@ declare function __VLS_template(): {
                                 };
                                 width: number;
                                 height: number;
-                            }[] | /*elided*/ any[] | undefined;
+                            }[] | /*elided*/ any[];
                             mapping: import('three').AnyMapping;
                             channel: number;
                             wrapS: import('three').Wrapping;
@@ -2767,7 +2767,7 @@ declare function __VLS_template(): {
                     dispatchEvent: <T extends "dispose">(event: import('three').BaseEvent<T> & {
                         dispose: {};
                     }[T]) => void;
-                }[] | undefined;
+                }[];
                 mapping: import('three').AnyMapping;
                 channel: number;
                 wrapS: import('three').Wrapping;
@@ -4531,7 +4531,7 @@ declare function __VLS_template(): {
                                 };
                                 width: number;
                                 height: number;
-                            }[] | /*elided*/ any[] | undefined;
+                            }[] | /*elided*/ any[];
                             channel: number;
                             wrapS: import('three').Wrapping;
                             wrapT: import('three').Wrapping;
@@ -4802,7 +4802,7 @@ declare function __VLS_template(): {
                             dispatchEvent: <T extends "dispose">(event: import('three').BaseEvent<T> & {
                                 dispose: {};
                             }[T]) => void;
-                        }[] | undefined;
+                        }[];
                         mapping: import('three').AnyMapping;
                         channel: number;
                         wrapS: import('three').Wrapping;