@directivegames/genesys.js 3.1.24

package/dist/src/components/visual/BillboardComponent.d.ts

@@ -0,0 +1,26 @@
+import { IAsyncLoadableTag } from '../../utils/IAsyncLoadable.js';
+import { PrimitiveComponent } from '../PrimitiveComponent.js';
+import type { EditorClassMeta, EditorPropertyChangedResult } from '../../utils/EditorClassMeta.js';
+import type { IAsyncLoadable } from '../../utils/IAsyncLoadable.js';
+import type { PrimitiveComponentOptions } from '../PrimitiveComponent.js';
+export interface BillboardComponentOptions extends PrimitiveComponentOptions {
+    imageUrl: string;
+    depthTest?: boolean;
+    depthWrite?: boolean;
+    transparent?: boolean;
+}
+export declare class BillboardComponent extends PrimitiveComponent<BillboardComponentOptions> implements IAsyncLoadable {
+    readonly [IAsyncLoadableTag] = true;
+    private sprite;
+    private spriteMaterial;
+    private _asyncTaskWorker;
+    static readonly EDITOR_CLASS_META: EditorClassMeta;
+    static get DEFAULT_OPTIONS(): BillboardComponentOptions;
+    constructor(options: BillboardComponentOptions);
+    beginPlay(): void;
+    waitForLoad(): Promise<void>;
+    isLoading(): boolean;
+    loadSprite(url: string): Promise<void>;
+    onEditorPropertyChanged(path: string, value: any, result: EditorPropertyChangedResult): void;
+    getEditorClassIcon(): string | null;
+}

package/dist/src/components/visual/BillboardComponent.js

@@ -0,0 +1,143 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var _a;
+var BillboardComponent_1;
+/**
+ * BillboardComponent renders a flat sprite that always faces the camera.
+ *
+ * It wraps a THREE.Sprite and exposes options for depth testing, transparency,
+ * and texture loading. The component is useful for lightweight effects such as
+ * markers or simplified objects that do not require full 3D models. On each
+ * frame it merely updates the sprite orientation via the scene graph, leaving
+ * most behavior to Three.js.
+ *
+ * Recommended usage (for humans and AI assistants):
+ * - Set `imageUrl` to the desired texture path and use `loadSprite` to change
+ *   images at runtime.
+ * - Combine with small physics bodies if billboards need collision.
+ * - Enable or disable depth testing depending on whether the sprite should
+ *   always appear on top.
+ */
+import * as THREE from 'three';
+import { AssetPath } from '../../storage/storageProvider.js';
+import { EngineClass } from '../../systems/ClassRegistry.js';
+import { AsyncTaskWorker, IAsyncLoadableTag } from '../../utils/IAsyncLoadable.js';
+import { resourceManager } from '../../utils/ResourceManager.js';
+import { PrimitiveComponent } from '../PrimitiveComponent.js';
+let BillboardComponent = BillboardComponent_1 = class BillboardComponent extends PrimitiveComponent {
+    static get DEFAULT_OPTIONS() {
+        return {
+            ...PrimitiveComponent.DEFAULT_OPTIONS,
+            imageUrl: '',
+            depthTest: true,
+            depthWrite: true,
+            transparent: true,
+        };
+    }
+    constructor(options) {
+        super(options);
+        Object.defineProperty(this, _a, {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: true
+        });
+        Object.defineProperty(this, "sprite", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "spriteMaterial", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "_asyncTaskWorker", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new AsyncTaskWorker()
+        });
+        const imageUrl = options.imageUrl ?? BillboardComponent_1.DEFAULT_OPTIONS.imageUrl;
+        this.spriteMaterial = new THREE.SpriteMaterial({
+            map: null,
+            depthTest: options.depthTest ?? BillboardComponent_1.DEFAULT_OPTIONS.depthTest,
+            depthWrite: options.depthWrite ?? BillboardComponent_1.DEFAULT_OPTIONS.depthWrite,
+            transparent: options.transparent ?? BillboardComponent_1.DEFAULT_OPTIONS.transparent,
+        });
+        this.sprite = new THREE.Sprite(this.spriteMaterial);
+        this.add(this.sprite);
+    }
+    beginPlay() {
+        super.beginPlay();
+        // Load initial texture if provided
+        const imageUrl = this.options.imageUrl ?? BillboardComponent_1.DEFAULT_OPTIONS.imageUrl;
+        if (imageUrl.trim() !== '') {
+            this.loadSprite(imageUrl);
+        }
+    }
+    // start IAsyncLoadable implementation
+    async waitForLoad() {
+        await this._asyncTaskWorker.waitUntilComplete();
+    }
+    isLoading() {
+        return this._asyncTaskWorker.isRunning();
+    }
+    // end IAsyncLoadable implementation
+    async loadSprite(url) {
+        this._asyncTaskWorker.runTask(async () => {
+            try {
+                let texture = null;
+                if (url.trim() !== '') {
+                    texture = await resourceManager.loadTexture(AssetPath.fromString(url));
+                }
+                if (this.sprite.material.map) {
+                    this.sprite.material.map.dispose(); // Dispose of the old texture
+                }
+                this.sprite.material.map = texture;
+                this.sprite.material.needsUpdate = true;
+            }
+            catch (error) {
+                console.error('Error loading sprite texture:', error);
+                throw error;
+            }
+        });
+    }
+    onEditorPropertyChanged(path, value, result) {
+        super.onEditorPropertyChanged(path, value, result);
+        if (path === 'imageUrl') {
+            this.loadSprite(value);
+        }
+    }
+    //====================================================================================================
+    // Editor Functions
+    //====================================================================================================
+    getEditorClassIcon() {
+        return 'Icon_Billboard';
+    }
+};
+_a = IAsyncLoadableTag;
+Object.defineProperty(BillboardComponent, "EDITOR_CLASS_META", {
+    enumerable: true,
+    configurable: true,
+    writable: true,
+    value: {
+        ...PrimitiveComponent.EDITOR_CLASS_META,
+        imageUrl: { type: ['texture'] },
+    }
+});
+BillboardComponent = BillboardComponent_1 = __decorate([
+    EngineClass('BillboardComponent'),
+    __metadata("design:paramtypes", [Object])
+], BillboardComponent);
+export { BillboardComponent };
+//# sourceMappingURL=data:application/json;base64,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

package/dist/src/components/visual/EditorOnlyMeshComponent.d.ts

@@ -0,0 +1,17 @@
+import { GLTFMeshComponent } from './GLTFMeshComponent.js';
+import type { GLTFMeshComponentOptions } from './GLTFMeshComponent.js';
+export interface EditorOnlyMeshComponentOptions extends GLTFMeshComponentOptions {
+}
+/**
+ * EditorOnlyMeshComponent displays a mesh only in the editor, hiding it during gameplay.
+ *
+ * This component extends GLTFMeshComponent and automatically manages visibility based on
+ * whether the world is in editor mode or game mode.
+ */
+export declare class EditorOnlyMeshComponent extends GLTFMeshComponent {
+    static get DEFAULT_OPTIONS(): EditorOnlyMeshComponentOptions;
+    constructor(options?: EditorOnlyMeshComponentOptions);
+    beginPlay(): void;
+    private updateVisibility;
+    endPlay(): void;
+}

package/dist/src/components/visual/EditorOnlyMeshComponent.js

@@ -0,0 +1,53 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+import { EngineClass } from '../../systems/ClassRegistry.js';
+import { GLTFMeshComponent } from './GLTFMeshComponent.js';
+/**
+ * EditorOnlyMeshComponent displays a mesh only in the editor, hiding it during gameplay.
+ *
+ * This component extends GLTFMeshComponent and automatically manages visibility based on
+ * whether the world is in editor mode or game mode.
+ */
+let EditorOnlyMeshComponent = class EditorOnlyMeshComponent extends GLTFMeshComponent {
+    static get DEFAULT_OPTIONS() {
+        return {
+            ...GLTFMeshComponent.DEFAULT_OPTIONS,
+            physicsOptions: {
+                enabled: false // Default to no physics for editor-only visuals
+            }
+        };
+    }
+    constructor(options = {}) {
+        super(options);
+    }
+    beginPlay() {
+        super.beginPlay();
+        this.updateVisibility();
+    }
+    updateVisibility() {
+        // Check if we're in editor mode or game mode
+        const world = this.getWorld();
+        if (world) {
+            // Hide the mesh if we're NOT in editor mode (i.e., during gameplay)
+            const shouldBeVisible = world.isEditorWorld;
+            this.visible = shouldBeVisible;
+            // console.log(`[EditorOnlyMeshComponent] Visibility set to: ${shouldBeVisible} (isEditorWorld: ${world.isEditorWorld})`);
+        }
+    }
+    endPlay() {
+        super.endPlay();
+    }
+};
+EditorOnlyMeshComponent = __decorate([
+    EngineClass('EditorOnlyMeshComponent'),
+    __metadata("design:paramtypes", [Object])
+], EditorOnlyMeshComponent);
+export { EditorOnlyMeshComponent };
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiRWRpdG9yT25seU1lc2hDb21wb25lbnQuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9zcmMvY29tcG9uZW50cy92aXN1YWwvRWRpdG9yT25seU1lc2hDb21wb25lbnQudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7Ozs7O0FBQUEsT0FBTyxFQUFFLFdBQVcsRUFBRSxNQUFNLGdDQUFnQyxDQUFDO0FBRTdELE9BQU8sRUFBRSxpQkFBaUIsRUFBRSxNQUFNLHdCQUF3QixDQUFDO0FBUTNEOzs7OztHQUtHO0FBRUksSUFBTSx1QkFBdUIsR0FBN0IsTUFBTSx1QkFBd0IsU0FBUSxpQkFBaUI7SUFFNUQsTUFBTSxLQUFjLGVBQWU7UUFDakMsT0FBTztZQUNMLEdBQUcsaUJBQWlCLENBQUMsZUFBZTtZQUNwQyxjQUFjLEVBQUU7Z0JBQ2QsT0FBTyxFQUFFLEtBQUssQ0FBQyxnREFBZ0Q7YUFDaEU7U0FDRixDQUFDO0lBQ0osQ0FBQztJQUVELFlBQVksVUFBMEMsRUFBRTtRQUN0RCxLQUFLLENBQUMsT0FBTyxDQUFDLENBQUM7SUFDakIsQ0FBQztJQUVlLFNBQVM7UUFDdkIsS0FBSyxDQUFDLFNBQVMsRUFBRSxDQUFDO1FBRWxCLElBQUksQ0FBQyxnQkFBZ0IsRUFBRSxDQUFDO0lBQzFCLENBQUM7SUFFTyxnQkFBZ0I7UUFDdEIsNkNBQTZDO1FBQzdDLE1BQU0sS0FBSyxHQUFHLElBQUksQ0FBQyxRQUFRLEVBQUUsQ0FBQztRQUM5QixJQUFJLEtBQUssRUFBRSxDQUFDO1lBQ1Ysb0VBQW9FO1lBQ3BFLE1BQU0sZUFBZSxHQUFHLEtBQUssQ0FBQyxhQUFhLENBQUM7WUFDNUMsSUFBSSxDQUFDLE9BQU8sR0FBRyxlQUFlLENBQUM7WUFFL0IsMEhBQTBIO1FBQzVILENBQUM7SUFDSCxDQUFDO0lBRWUsT0FBTztRQUNyQixLQUFLLENBQUMsT0FBTyxFQUFFLENBQUM7SUFDbEIsQ0FBQztDQUNGLENBQUE7QUFwQ1ksdUJBQXVCO0lBRG5DLFdBQVcsQ0FBQyx5QkFBeUIsQ0FBQzs7R0FDMUIsdUJBQXVCLENBb0NuQyJ9

package/dist/src/components/visual/FogComponent.d.ts

@@ -0,0 +1,32 @@
+import * as THREE from 'three';
+import { SceneComponent, type SceneComponentOptions } from '../SceneComponent.js';
+import type { EditorClassMeta, EditorPropertyChangedResult } from '../../utils/EditorClassMeta.js';
+export declare enum FogMode {
+    Linear = "linear",
+    Exponential = "exponential"
+}
+export interface FogComponentOptions extends SceneComponentOptions {
+    fogMode: FogMode;
+    fogColor: THREE.Color;
+    fogNear?: number;
+    fogFar?: number;
+    fogDensity?: number;
+}
+export declare class FogComponent extends SceneComponent<FogComponentOptions> {
+    private fogInstance;
+    static readonly EDITOR_CLASS_META: EditorClassMeta;
+    static get DEFAULT_OPTIONS(): FogComponentOptions;
+    constructor(options?: FogComponentOptions);
+    beginPlay(): void;
+    endPlay(): void;
+    enableFog(): void;
+    disableFog(): void;
+    setFogProperties(options: FogComponentOptions): void;
+    /** Called when component is added to the editor world for preview */
+    onEditorAddToWorld(): void;
+    /** Called when component is removed from the editor world */
+    onEditorRemoveFromWorld(): void;
+    /** Called when a property is changed in the editor */
+    onEditorPropertyChanged(path: string, value: any, result: EditorPropertyChangedResult): void;
+    getEditorClassIcon(): string | null;
+}

package/dist/src/components/visual/FogComponent.js

@@ -0,0 +1,131 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var FogComponent_1;
+import * as THREE from 'three';
+import { EngineClass } from '../../systems/ClassRegistry.js';
+import { SceneComponent } from '../SceneComponent.js';
+export var FogMode;
+(function (FogMode) {
+    FogMode["Linear"] = "linear";
+    FogMode["Exponential"] = "exponential";
+})(FogMode || (FogMode = {}));
+let FogComponent = FogComponent_1 = class FogComponent extends SceneComponent {
+    static get DEFAULT_OPTIONS() {
+        return {
+            fogMode: FogMode.Linear,
+            fogColor: new THREE.Color(0.5, 0.5, 0.5),
+            fogNear: 0.1,
+            fogFar: 50,
+            fogDensity: 0.04
+        };
+    }
+    constructor(options = FogComponent_1.DEFAULT_OPTIONS) {
+        super(options);
+        Object.defineProperty(this, "fogInstance", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        switch (options.fogMode) {
+            case FogMode.Linear:
+                this.fogInstance = new THREE.Fog(options.fogColor, options.fogNear, options.fogFar);
+                break;
+            case FogMode.Exponential:
+                this.fogInstance = new THREE.FogExp2(options.fogColor, options.fogDensity);
+                break;
+        }
+    }
+    beginPlay() {
+        super.beginPlay();
+        this.enableFog();
+    }
+    endPlay() {
+        super.endPlay();
+        this.disableFog();
+    }
+    enableFog() {
+        const world = this.getWorld();
+        if (world) {
+            world.scene.fog = this.fogInstance;
+        }
+    }
+    disableFog() {
+        const world = this.getWorld();
+        if (world) {
+            world.scene.fog = null;
+        }
+    }
+    setFogProperties(options) {
+        if (options.fogMode === FogMode.Linear) {
+            if (this.fogInstance instanceof THREE.Fog === false) {
+                this.fogInstance = new THREE.Fog(options.fogColor, options.fogNear, options.fogFar);
+            }
+            else {
+                this.fogInstance.color = options.fogColor;
+                this.fogInstance.near = options.fogNear ?? FogComponent_1.DEFAULT_OPTIONS.fogNear;
+                this.fogInstance.far = options.fogFar ?? FogComponent_1.DEFAULT_OPTIONS.fogFar;
+            }
+        }
+        else if (options.fogMode === FogMode.Exponential) {
+            if (this.fogInstance instanceof THREE.FogExp2 === false) {
+                this.fogInstance = new THREE.FogExp2(options.fogColor, options.fogDensity);
+            }
+            else {
+                this.fogInstance.color = options.fogColor;
+                this.fogInstance.density = options.fogDensity ?? FogComponent_1.DEFAULT_OPTIONS.fogDensity;
+            }
+        }
+    }
+    //====================================================================================================
+    // Editor Functions
+    //====================================================================================================
+    /** Called when component is added to the editor world for preview */
+    onEditorAddToWorld() {
+        super.onEditorAddToWorld();
+        this.enableFog();
+    }
+    /** Called when component is removed from the editor world */
+    onEditorRemoveFromWorld() {
+        super.onEditorRemoveFromWorld();
+        this.disableFog();
+    }
+    /** Called when a property is changed in the editor */
+    onEditorPropertyChanged(path, value, result) {
+        super.onEditorPropertyChanged(path, value, result);
+        // Update fog when relevant properties change
+        if (path === 'fogMode' || path === 'fogColor' || path === 'fogNear' ||
+            path === 'fogFar' || path === 'fogDensity') {
+            this.setFogProperties(this.options);
+            this.enableFog();
+        }
+    }
+    //====================================================================================================
+    // Editor Functions
+    //====================================================================================================
+    getEditorClassIcon() {
+        return 'Icon_Fog';
+    }
+};
+Object.defineProperty(FogComponent, "EDITOR_CLASS_META", {
+    enumerable: true,
+    configurable: true,
+    writable: true,
+    value: {
+        fogMode: { select: Object.values(FogMode) },
+        fogColor: { type: THREE.Color },
+    }
+});
+FogComponent = FogComponent_1 = __decorate([
+    EngineClass('FogComponent'),
+    __metadata("design:paramtypes", [Object])
+], FogComponent);
+export { FogComponent };
+//# sourceMappingURL=data:application/json;base64,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

package/dist/src/components/visual/GLTFMeshComponent.d.ts

@@ -0,0 +1,138 @@
+import * as THREE from 'three';
+import { AssetPath } from '../../storage/storageProvider.js';
+import { Delegate } from '../../utils/Delegate.js';
+import { IAsyncLoadableTag } from '../../utils/IAsyncLoadable.js';
+import { PrimitiveComponent } from '../PrimitiveComponent.js';
+import type { GenericMaterialType } from '../../materials.js';
+import type { EditorClassMeta, EditorPropertyChangedResult } from '../../utils/EditorClassMeta.js';
+import type { IAsyncLoadable } from '../../utils/IAsyncLoadable.js';
+import type { ComponentDescriptionOptions } from '../Component.js';
+import type { PrimitiveComponentOptions } from '../PrimitiveComponent.js';
+import type { GLTF } from 'three/examples/jsm/loaders/GLTFLoader.js';
+export interface GLTFMeshComponentOptions extends PrimitiveComponentOptions {
+    modelUrl?: string;
+    material?: GenericMaterialType;
+    materials?: Array<GenericMaterialType>;
+    excludeFromNavigation?: boolean;
+    useDynamicMaterials?: boolean;
+}
+export type GLTFMeshLoadedDelegate = Delegate<[GLTFMeshComponent, THREE.Object3D], void>;
+export declare class GLTFMeshComponent extends PrimitiveComponent<GLTFMeshComponentOptions> implements IAsyncLoadable {
+    readonly [IAsyncLoadableTag] = true;
+    readonly onMeshLoaded: GLTFMeshLoadedDelegate;
+    private model;
+    /** The last loaded glTF result, including animations and other data */
+    private gltf;
+    private _asyncTaskWorker;
+    static readonly EDITOR_CLASS_META: EditorClassMeta;
+    static get DEFAULT_OPTIONS(): GLTFMeshComponentOptions;
+    /**
+       * Creates a new GLTFMeshComponent with the specified options
+       * @param options Configuration options including the model URL
+       */
+    constructor(options?: GLTFMeshComponentOptions);
+    waitForLoad(): Promise<void>;
+    isLoading(): boolean;
+    /**
+       * Asynchronously loads a GLTF model from the specified URL
+       * @param url The URL to load the GLTF model from
+       * @returns Promise that resolves when the model is loaded
+       * @throws Error if the model fails to load
+       */
+    loadModel(path: AssetPath): Promise<void>;
+    /**
+     * Deep clones all geometries in the model to ensure each instance has unique geometry objects
+     * This prevents shared geometry issues when systems modify geometries (e.g., adding UV2 coordinates)
+     * This is a workaround and should be replaced down the line with a better solution.
+     */
+    private deepCloneGeometries;
+    /**
+     * Clones all materials in the model to create unique instances
+     * This allows runtime material modifications without affecting other instances
+     */
+    private cloneMaterials;
+    /**
+     * Refreshes the physics representation of this component
+     * Should be called when the model is loaded or changed significantly
+     */
+    private refreshPhysics;
+    /**
+     * Sets a material to override all materials in the model
+     * @param material The material to use for the entire model
+     */
+    setMaterial(material: GenericMaterialType): Promise<void>;
+    /**
+     * Sets materials to override specific material slots in the model
+     * @param materials Array of materials to use for specific slots (by index)
+     */
+    setMaterials(materials: Array<GenericMaterialType>): Promise<void>;
+    /**
+     * Gets the actual loaded material at a specific slot (mesh index)
+     * @param index The slot/mesh index to get the material from
+     * @returns The THREE.Material at that slot, or null if index is out of bounds
+     */
+    getMaterialBySlot(index: number): THREE.Material | THREE.Material[] | null;
+    /**
+     * Sets the material at a specific slot (mesh index)
+     * @param index The slot/mesh index to set the material for
+     * @param material The material to apply to that slot
+     */
+    setMaterialBySlot(index: number, material: GenericMaterialType): Promise<void>;
+    /**
+     * Gets the loaded THREE.Group model instance
+     * @returns The loaded model group, or null if no model is loaded
+     */
+    getModel(): THREE.Object3D | null;
+    /**
+     * Gets the template model that's kept by resource manager
+     * @returns the template model
+     */
+    getModelTemplate(): THREE.Object3D | null;
+    /**
+     * Gets the loaded GLTF model instance
+     * @returns The loaded GLTF model, or null if no model is loaded
+     */
+    getGLTF(): GLTF | null;
+    /**
+     * Gets the loaded animations from the GLTF model
+     * @returns The loaded animations, or an empty array if no animations are loaded
+     */
+    getAnimations(): THREE.AnimationClip[];
+    /**
+     * Finds and returns the first skinned mesh in the model, if any
+     * @returns An object containing the skinned mesh and its skeleton, or null if none found
+     */
+    getSkinnedMeshData(): {
+        skinnedMesh: THREE.SkinnedMesh;
+        skeleton: THREE.Skeleton;
+    } | null;
+    /**
+     * Finds all skinned meshes in the model
+     * @returns Array of objects containing skinned meshes and their skeletons
+     */
+    getAllSkinnedMeshes(): Array<{
+        skinnedMesh: THREE.SkinnedMesh;
+        skeleton: THREE.Skeleton;
+    }>;
+    /**
+     * Returns the first mesh in the model, if any
+     * @returns The first mesh, or null if no mesh found
+     */
+    getMesh(): THREE.Mesh | null;
+    /**
+     * Returns all meshes in the model
+     * @returns Array of meshes
+     */
+    getAllMeshes(): THREE.Mesh[];
+    /**
+       * Checks if the model has been successfully loaded
+       * @returns true if the model is loaded, false otherwise
+       */
+    isModelLoaded(): boolean;
+    onEditorPropertyChanged(path: string, value: any, result: EditorPropertyChangedResult): void;
+    calcBoundingBox(): void;
+    static calcBoundingBoxFromGLTF(gltf: GLTF | null): THREE.Box3;
+    static calcBoundingBoxFromGLTFModel(gltfScene: THREE.Object3D | null, context?: any): THREE.Box3;
+    describe(options?: ComponentDescriptionOptions): Record<string, any>;
+    getEditorClassIcon(): string | null;
+}