@tresjs/cientos 4.3.0 → 5.0.0-alpha.0

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

@@ -1,3 +1,4 @@
+import { Group } from 'three';
 export interface FBXModelProps {
     /**
      * Path to the FBX file.
@@ -28,17 +29,9 @@ export interface FBXModelProps {
      */
     receiveShadow?: boolean;
 }
-declare const _default: import('vue').DefineComponent<{
-    path: string;
-    castShadow?: boolean;
-    receiveShadow?: boolean;
-}, {
-    instance: import('vue').Ref<any, any>;
-}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{
-    path: string;
-    castShadow?: boolean;
-    receiveShadow?: boolean;
-}> & Readonly<{}>, {
+declare const _default: import('vue').DefineComponent<FBXModelProps, {
+    instance: import('vue').Ref<Group<import('three').Object3DEventMap> | null, Group<import('three').Object3DEventMap> | null>;
+}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<FBXModelProps> & Readonly<{}>, {
     castShadow: boolean;
     receiveShadow: boolean;
 }, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;

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

@@ -1,9 +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;
+}
 /**
- * Loads an FBX file and returns a THREE.Object3D.
+ * Vue composable for loading FBX models in TresJS
  *
- * @export
- * @param {(string | string[])} path
- * @return {*}  {Promise<Group>}
+ * @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<T extends string | string[]>(path: T): Promise<T extends string[] ? Group[] : Group>;
+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

@@ -50,21 +50,9 @@ export interface GLTFModelProps {
      */
     decoderPath?: string;
 }
-declare const _default: import('vue').DefineComponent<{
-    path: string;
-    draco?: boolean;
-    decoderPath?: string;
-    castShadow?: boolean;
-    receiveShadow?: boolean;
-}, {
-    instance: import('vue').Ref<any, any>;
-}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{
-    path: string;
-    draco?: boolean;
-    decoderPath?: string;
-    castShadow?: boolean;
-    receiveShadow?: boolean;
-}> & Readonly<{}>, {
+declare const _default: import('vue').DefineComponent<GLTFModelProps, {
+    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;
     draco: boolean;

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

@@ -1,39 +1,43 @@
-import { TresLoader, TresObject3D } from '@tresjs/core';
-import { DRACOLoader, GLTF } from 'three-stdlib';
-import { AnimationClip, Material, Scene } from 'three';
-export interface GLTFLoaderOptions {
+import { TresObject } from '@tresjs/core';
+import { ComputedRef, MaybeRef, Ref } from 'vue';
+import { GLTF } from 'three-stdlib';
+export interface UseGLTFOptions {
     /**
-     * Whether to use Draco compression.
-     *
+     * Whether to use DRACO compression for loading the model
      * @type {boolean}
-     * @memberof GLTFLoaderOptions
      */
     draco?: boolean;
     /**
-     * The path to the Draco decoder.
-     *
+     * Path to the DRACO decoder. Defaults to https://www.gstatic.com/draco/versioned/decoders/1.5.6/
      * @type {string}
-     * @memberof GLTFLoaderOptions
      */
     decoderPath?: string;
-}
-export interface GLTFResult {
-    animations: Array<AnimationClip>;
-    nodes: Record<string, TresObject3D>;
-    materials: Record<string, Material>;
-    scene: Scene;
-}
-export interface TresGLTFLoaderType extends TresLoader<GLTF> {
-    setDRACOLoader?: (dracoLoader: DRACOLoader) => void;
+    /**
+     * A traverse function applied to the scene upon loading the model.
+     * @type {Function}
+     */
+    traverse?: (child: TresObject) => void;
 }
 /**
- * Loads a GLTF file and returns a THREE.Object3D.
+ * 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 })
+ * ```
  *
- * @export
- * @template T
- * @param {T} path - Path or array of paths to the GLTF file(s)
- * @param {GLTFLoaderOptions} [options] - Options for the loader
- * @param {(loader: TresGLTFLoaderType) => void} [extendLoader] - Function to extend the loader
- * @returns {Promise<T extends string[] ? GLTFResult[] : GLTFResult>} Promise that resolves with the loaded model(s)
+ * @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<T extends string | string[]>(path: T, options?: GLTFLoaderOptions, extendLoader?: (loader: TresGLTFLoaderType) => void): Promise<T extends string[] ? GLTFResult[] : GLTFResult>;
+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/{SVG → useSVG}/component.vue.d.ts

@@ -91,7 +91,8 @@ interface SVGProps {
     depth?: 'renderOrder' | 'flat' | 'offsetZ' | number;
 }
 declare const _default: import('vue').DefineComponent<SVGProps, {
-    instance: import('vue').ShallowRef<any, any>;
+    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;
     skipStrokes: boolean;

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;
+};