@directivegames/genesys.js 3.1.24

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

@@ -0,0 +1,411 @@
+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 GLTFMeshComponent_1;
+import * as THREE from 'three';
+import * as SkeletonUtils from 'three/examples/jsm/utils/SkeletonUtils.js';
+import { ENABLE_LIGHTMAPS } from '../../const.js';
+import { AssetPath } from '../../storage/storageProvider.js';
+import { EngineClass } from '../../systems/ClassRegistry.js';
+import { Delegate } from '../../utils/Delegate.js';
+import { AsyncTaskWorker, IAsyncLoadableTag } from '../../utils/IAsyncLoadable.js';
+import { resourceManager } from '../../utils/ResourceManager.js';
+import { isNode } from '../../utils/Utils.js';
+import { PrimitiveComponent } from '../PrimitiveComponent.js';
+let GLTFMeshComponent = GLTFMeshComponent_1 = class GLTFMeshComponent extends PrimitiveComponent {
+    static get DEFAULT_OPTIONS() {
+        return {
+            ...PrimitiveComponent.DEFAULT_OPTIONS,
+            modelUrl: undefined,
+            material: undefined,
+            materials: undefined,
+            excludeFromNavigation: false,
+            useDynamicMaterials: false,
+        };
+    }
+    /**
+       * Creates a new GLTFMeshComponent with the specified options
+       * @param options Configuration options including the model URL
+       */
+    constructor(options = {}) {
+        super(options);
+        Object.defineProperty(this, _a, {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: true
+        });
+        Object.defineProperty(this, "onMeshLoaded", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new Delegate()
+        });
+        Object.defineProperty(this, "model", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: null
+        });
+        /** The last loaded glTF result, including animations and other data */
+        Object.defineProperty(this, "gltf", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: null
+        });
+        Object.defineProperty(this, "_asyncTaskWorker", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new AsyncTaskWorker()
+        });
+        if (this.options.modelUrl) {
+            this.loadModel(AssetPath.fromString(this.options.modelUrl));
+        }
+    }
+    async waitForLoad() {
+        await this._asyncTaskWorker.waitUntilComplete();
+    }
+    isLoading() {
+        return this._asyncTaskWorker.isRunning();
+    }
+    /**
+       * 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
+       */
+    async loadModel(path) {
+        await this._asyncTaskWorker.runTask(async () => {
+            this.options.modelUrl = path.initialPath;
+            const gltf = await resourceManager.loadModel(path);
+            if (!gltf) {
+                return;
+            }
+            this.model?.removeFromParent();
+            this.gltf = gltf;
+            // NOTE: the returned gltf is the same instance under the same url so we need to instantiate for this particular component
+            this.model = SkeletonUtils.clone(gltf.scene);
+            // CRITICAL: SkeletonUtils.clone() creates shallow copies of geometries, meaning multiple instances
+            // share the same geometry objects. This causes issues when systems like lightmapping modify
+            // geometries by adding UV2 coordinates - the changes affect all instances.
+            // This is a workaround and should be replaced down the line with a better solution.
+            if (ENABLE_LIGHTMAPS) {
+                this.deepCloneGeometries(this.model);
+            }
+            if (!isNode()) {
+                if (this.options.material) {
+                    await this.setMaterial(this.options.material);
+                }
+                else if (this.options.materials) {
+                    await this.setMaterials(this.options.materials);
+                }
+            }
+            this.add(this.model);
+            this.updateMatrixWorld(true);
+            this.gltf = gltf;
+            // Refresh physics representation if component is already in scene and playing
+            this.refreshPhysics();
+            this.model.traverse((child) => {
+                if (child instanceof THREE.Mesh) {
+                    this.bindObject3DProperties(child, ['castShadow', 'receiveShadow']);
+                }
+            });
+            // Clone materials if useDynamicMaterials is enabled and we're playing
+            // Must happen AFTER materials are loaded and applied
+            if (this.options.useDynamicMaterials && this.getActor()?.isPlaying()) {
+                this.cloneMaterials();
+            }
+            // Call all callbacks
+            this.onMeshLoaded.invoke(this, this.model);
+        });
+    }
+    /**
+     * 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.
+     */
+    deepCloneGeometries(object) {
+        object.traverse((child) => {
+            if (child instanceof THREE.Mesh && child.geometry) {
+                // Clone the geometry to create a unique instance for this component
+                child.geometry = child.geometry.clone();
+                //TODO: Might need to clone the material as well
+            }
+        });
+    }
+    /**
+     * Clones all materials in the model to create unique instances
+     * This allows runtime material modifications without affecting other instances
+     */
+    cloneMaterials() {
+        if (!this.model)
+            return;
+        this.model.traverse((child) => {
+            if (child instanceof THREE.Mesh && child.material) {
+                if (Array.isArray(child.material)) {
+                    // Clone each material in the array
+                    child.material = child.material.map(mat => mat.clone());
+                }
+                else {
+                    // Clone single material
+                    child.material = child.material.clone();
+                }
+            }
+        });
+    }
+    /**
+     * Refreshes the physics representation of this component
+     * Should be called when the model is loaded or changed significantly
+     */
+    refreshPhysics() {
+        const actor = this.getActor();
+        if (actor?.isPlaying() && this.isPhysicsEnabled()) {
+            const physicsEngine = this.getPhysicsEngine();
+            if (physicsEngine) {
+                // Remove existing physics representation
+                physicsEngine.removeComponent(this);
+                // Create new physics representation based on the loaded model
+                this.motionType = physicsEngine.addComponent(this) ?? null;
+            }
+        }
+    }
+    /**
+     * Sets a material to override all materials in the model
+     * @param material The material to use for the entire model
+     */
+    async setMaterial(material) {
+        if (typeof material === 'string') {
+            this.options.material = material;
+            if (!material) {
+                // TODO: better way to reset to default material?
+                if (!material && typeof this.options.modelUrl === 'string') {
+                    await this.loadModel(AssetPath.fromString(this.options.modelUrl));
+                    return;
+                }
+            }
+        }
+        const loadedMaterial = await resourceManager.loadGenericMaterial(material);
+        if (loadedMaterial) {
+            const allMeshes = this.getAllMeshes();
+            for (const mesh of allMeshes) {
+                mesh.material = loadedMaterial;
+            }
+        }
+    }
+    /**
+     * Sets materials to override specific material slots in the model
+     * @param materials Array of materials to use for specific slots (by index)
+     */
+    async setMaterials(materials) {
+        this.options.materials = materials;
+        const allMeshes = this.getAllMeshes();
+        // Load all materials first
+        const loadedMaterials = await Promise.all(materials.map(mat => resourceManager.loadGenericMaterial(mat)));
+        // Apply materials by index
+        loadedMaterials.forEach((material, index) => {
+            if (material && index < allMeshes.length) {
+                allMeshes[index].material = material;
+            }
+        });
+    }
+    /**
+     * 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) {
+        const allMeshes = this.getAllMeshes();
+        if (index < 0 || index >= allMeshes.length) {
+            return null;
+        }
+        return allMeshes[index].material;
+    }
+    /**
+     * 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
+     */
+    async setMaterialBySlot(index, material) {
+        const allMeshes = this.getAllMeshes();
+        if (index < 0 || index >= allMeshes.length) {
+            console.warn(`GLTFMeshComponent: Invalid slot index ${index}. Valid range is 0-${allMeshes.length - 1}`);
+            return;
+        }
+        const loadedMaterial = await resourceManager.loadGenericMaterial(material);
+        if (loadedMaterial) {
+            allMeshes[index].material = loadedMaterial;
+        }
+    }
+    /**
+     * Gets the loaded THREE.Group model instance
+     * @returns The loaded model group, or null if no model is loaded
+     */
+    getModel() {
+        return this.model;
+    }
+    /**
+     * Gets the template model that's kept by resource manager
+     * @returns the template model
+     */
+    getModelTemplate() {
+        return this.gltf?.scene ?? null;
+    }
+    /**
+     * Gets the loaded GLTF model instance
+     * @returns The loaded GLTF model, or null if no model is loaded
+     */
+    getGLTF() {
+        return this.gltf;
+    }
+    /**
+     * Gets the loaded animations from the GLTF model
+     * @returns The loaded animations, or an empty array if no animations are loaded
+     */
+    getAnimations() {
+        return this.gltf?.animations ?? [];
+    }
+    /**
+     * 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() {
+        if (!this.model)
+            return null;
+        return this.getAllSkinnedMeshes()[0] ?? null;
+    }
+    /**
+     * Finds all skinned meshes in the model
+     * @returns Array of objects containing skinned meshes and their skeletons
+     */
+    getAllSkinnedMeshes() {
+        if (!this.model)
+            return [];
+        const results = [];
+        for (const mesh of this.getAllMeshes()) {
+            if (mesh instanceof THREE.SkinnedMesh) {
+                if (mesh.skeleton && mesh.skeleton.bones && mesh.skeleton.bones.length > 0) {
+                    results.push({
+                        skinnedMesh: mesh,
+                        skeleton: mesh.skeleton
+                    });
+                }
+            }
+        }
+        return results;
+    }
+    /**
+     * Returns the first mesh in the model, if any
+     * @returns The first mesh, or null if no mesh found
+     */
+    getMesh() {
+        return this.getAllMeshes()[0] ?? null;
+    }
+    /**
+     * Returns all meshes in the model
+     * @returns Array of meshes
+     */
+    getAllMeshes() {
+        const meshes = [];
+        this.model?.traverse((object) => {
+            if (object instanceof THREE.Mesh) {
+                meshes.push(object);
+            }
+        });
+        return meshes;
+    }
+    /**
+       * Checks if the model has been successfully loaded
+       * @returns true if the model is loaded, false otherwise
+       */
+    isModelLoaded() {
+        return !!this.model;
+    }
+    onEditorPropertyChanged(path, value, result) {
+        super.onEditorPropertyChanged(path, value, result);
+        if (path === 'modelUrl') {
+            this.loadModel(AssetPath.fromString(value));
+        }
+        else if (path === 'material') {
+            this.setMaterial(value);
+        }
+        else if (path.startsWith('materials')) {
+            // If material (singular) is set, it takes precedence
+            if (!this.options.material && this.options.materials) {
+                this.setMaterials(this.options.materials);
+            }
+        }
+    }
+    calcBoundingBox() {
+        console.log('Calculating bounding box for GLTFMeshComponent', this.getActor()?.editorData?.displayName);
+        this._boundingBox = GLTFMeshComponent_1.calcBoundingBoxFromGLTFModel(this.getModel(), this.getActor()?.editorData?.displayName);
+    }
+    static calcBoundingBoxFromGLTF(gltf) {
+        if (!gltf || !gltf.scene) {
+            console.warn('GLTFMeshComponent: No GLTF scene available to calculate bounding box. Has the model finished loading?');
+            return new THREE.Box3();
+        }
+        return GLTFMeshComponent_1.calcBoundingBoxFromGLTFModel(gltf.scene);
+    }
+    static calcBoundingBoxFromGLTFModel(gltfScene, context) {
+        if (!gltfScene) {
+            console.warn('GLTFMeshComponent: No GLTF scene available to calculate bounding box. Has the model finished loading?', context);
+            return new THREE.Box3();
+        }
+        const boundingBox = new THREE.Box3();
+        gltfScene.traverse((child) => {
+            if (child instanceof THREE.Mesh) {
+                child.updateMatrixWorld(true);
+                child.geometry.computeBoundingBox();
+                const box = new THREE.Box3();
+                box.copy(child.geometry.boundingBox);
+                box.applyMatrix4(child.matrixWorld);
+                boundingBox.union(box);
+            }
+        });
+        return boundingBox;
+    }
+    describe(options) {
+        const result = super.describe(options);
+        if (options?.includeDetails) {
+            result.modelUrl = this.options.modelUrl;
+            result.material = this.options.material;
+            result.materials = this.options.materials;
+            result.useDynamicMaterials = this.options.useDynamicMaterials;
+        }
+        ;
+        return result;
+    }
+    //====================================================================================================
+    // Editor Functions
+    //====================================================================================================
+    getEditorClassIcon() {
+        return 'Icon_GLTFMesh';
+    }
+};
+_a = IAsyncLoadableTag;
+Object.defineProperty(GLTFMeshComponent, "EDITOR_CLASS_META", {
+    enumerable: true,
+    configurable: true,
+    writable: true,
+    value: {
+        ...PrimitiveComponent.EDITOR_CLASS_META,
+        modelUrl: { type: ['model'] },
+        material: { type: ['material'] },
+        materials: { array: { child: { type: ['material'] } } },
+    }
+});
+GLTFMeshComponent = GLTFMeshComponent_1 = __decorate([
+    EngineClass('GLTFMeshComponent'),
+    __metadata("design:paramtypes", [Object])
+], GLTFMeshComponent);
+export { GLTFMeshComponent };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"GLTFMeshComponent.js","sourceRoot":"","sources":["../../../../src/components/visual/GLTFMeshComponent.ts"],"names":[],"mappings":"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"}

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

@@ -0,0 +1,75 @@
+/**
+ * InstancedGltfMeshComponent loads a GLTF model and creates instanced meshes for each child mesh.
+ *
+ * This component automatically loads a GLTF model and creates one THREE.InstancedMesh for each
+ * mesh found in the model. This is ideal for rendering large numbers of complex models
+ * efficiently, such as trees, buildings, or other detailed objects that contain multiple
+ * sub-meshes.
+ *
+ * The component manages instance matrices and colors internally, providing methods
+ * to update individual instances or all instances at once across all child meshes.
+ *
+ * Recommended usage (for humans and AI assistants):
+ * - Use when you need to render many copies of a complex GLTF model efficiently.
+ * - Perfect for vegetation, buildings, vehicles, or any detailed models with multiple parts.
+ * - Each child mesh in the GLTF becomes its own instanced mesh for optimal performance.
+ * - Call updateInstanceMatrix() after modifying instance transforms.
+ * - Use setInstanceColor() for per-instance color variations.
+ */
+import * as THREE from 'three';
+import { IAsyncLoadableTag } from '../../utils/IAsyncLoadable.js';
+import { BaseInstancedMeshComponent } from './BaseInstancedMeshComponent.js';
+import type { BaseInstancedMeshComponentOptions } from './BaseInstancedMeshComponent.js';
+import type { EditorClassMeta, EditorPropertyChangedResult } from '../../utils/EditorClassMeta.js';
+import type { IAsyncLoadable } from '../../utils/IAsyncLoadable.js';
+export interface InstancedGltfMeshComponentOptions extends BaseInstancedMeshComponentOptions {
+    modelUrl?: string;
+}
+export declare class InstancedGltfMeshComponent extends BaseInstancedMeshComponent<InstancedGltfMeshComponentOptions> implements IAsyncLoadable {
+    readonly [IAsyncLoadableTag] = true;
+    private _modelUrl;
+    private modelTemplate;
+    private _asyncTaskWorker;
+    static readonly EDITOR_CLASS_META: EditorClassMeta;
+    static get DEFAULT_OPTIONS(): InstancedGltfMeshComponentOptions;
+    /**
+     * Creates a new InstancedGltfMeshComponent with the specified options
+     * @param options Configuration options for the instanced GLTF mesh component
+     */
+    constructor(options?: InstancedGltfMeshComponentOptions);
+    /**
+     * Gets the current model URL
+     * @returns The model URL or null if not set
+     */
+    getModelUrl(): string | null;
+    /**
+       * Gets the loaded THREE.Group model instance
+       * @returns The loaded model group, or null if no model is loaded
+       */
+    getModelTemplate(): THREE.Object3D | null;
+    /**
+     * Sets the model URL and loads the new model
+     * @param modelUrl The URL or AssetPath to the GLTF model
+     */
+    setModelUrl(modelUrl: string): Promise<void>;
+    /**
+     * Checks if the model is currently loading
+     * @returns True if the model is loading, false otherwise
+     */
+    isLoading(): boolean;
+    /**
+     * Waits for the current model loading to complete
+     * @returns Promise that resolves when loading is complete
+     */
+    waitForLoad(): Promise<void>;
+    /**
+     * Loads the GLTF model and creates instanced meshes for each child mesh
+     */
+    private loadModel;
+    /**
+     * Performs the actual model loading and mesh creation
+     */
+    private _internalPerformModelLoad;
+    onEditorPropertyChanged(path: string, value: any, result: EditorPropertyChangedResult): void;
+    getEditorClassIcon(): string | null;
+}