@directivegames/genesys.js 3.1.24

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

@@ -0,0 +1,309 @@
+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 TerrainMeshComponent_1;
+/**
+ * TerrainMeshComponent procedurally generates a height-mapped terrain mesh.
+ *
+ * At creation it builds a plane geometry and displaces vertices using either
+ * random or Perlin noise. Options control size, segment resolution, noise scale
+ * and seed. The component can regenerate the terrain or query height values at
+ * runtime, and it integrates with physics when enabled to create a static
+ * collision body.
+ *
+ * Recommended usage (for humans and AI assistants):
+ * - Call `generateTerrain` when changing dimensions or noise parameters.
+ * - Retrieve heights via `getHeightAt` for gameplay checks.
+ * - Use `uvScaleTilesPerUnit` so materials tile correctly over large areas.
+ */
+import * as THREE from 'three';
+import { MaterialUtils } from '../../materials.js';
+import { PhysicsMotionType } from '../../physics/PhysicsTypes.js';
+import { EngineClass } from '../../systems/ClassRegistry.js';
+import Perlin from '../../utils/Perlin.js';
+import { resourceManager } from '../../utils/ResourceManager.js';
+import { PrimitiveComponent } from '../PrimitiveComponent.js';
+let TerrainMeshComponent = TerrainMeshComponent_1 = class TerrainMeshComponent extends PrimitiveComponent {
+    static get DEFAULT_OPTIONS() {
+        return {
+            ...PrimitiveComponent.DEFAULT_OPTIONS,
+            width: 200,
+            depth: 200,
+            widthSegments: 200,
+            depthSegments: 200,
+            maxHeight: 5,
+            material: undefined,
+            noiseType: 'perlin',
+            noiseFrequency: 0.1,
+            noiseSeed: 100,
+            physicsOptions: {
+                enabled: true,
+                motionType: PhysicsMotionType.Static,
+                density: 1
+            }
+        };
+    }
+    /**
+       * Creates a new TerrainMeshComponent instance
+       * @param options Configuration options for the terrain
+       * @param options.width Width of the terrain in world units
+       * @param options.depth Depth of the terrain in world units
+       * @param options.widthSegments Number of segments along the width
+       * @param options.depthSegments Number of segments along the depth
+       * @param options.maxHeight Maximum height of the terrain
+       * @param options.material Material to use for the terrain (defaults to MeshStandardMaterial)
+       * @param options.noiseType Type of noise to use for terrain generation ('random' or 'perlin')
+       * @param options.noiseFrequency Frequency of the noise (default: 1)
+       * @param options.noiseSeed Seed for noise generation (default: random)
+       */
+    constructor(options = TerrainMeshComponent_1.DEFAULT_OPTIONS) {
+        options.material = options.material ?? new THREE.MeshStandardMaterial();
+        // Call the parent constructor
+        super(options);
+        Object.defineProperty(this, "heightMap", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: null
+        });
+        Object.defineProperty(this, "mesh", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        // Create a placeholder geometry initially
+        const geometry = new THREE.PlaneGeometry(1, 1, 1, 1);
+        this.mesh = new THREE.Mesh(geometry);
+        this.bindObject3DProperties(this.mesh, ['castShadow', 'receiveShadow']);
+        this.add(this.mesh);
+        if (options.material) {
+            this.setMaterial(options.material);
+        }
+        this.generateTerrain();
+    }
+    /**
+       * Gets the underlying Three.js mesh object
+       * @returns The Three.js Mesh instance representing the terrain
+       */
+    getMesh() {
+        return this.mesh;
+    }
+    /**
+       * Sets the material for the terrain mesh
+       * @param material The new material to apply
+       */
+    setMaterial(material) {
+        resourceManager.loadGenericMaterial(material).then((material) => {
+            if (material) {
+                this.mesh.material = material;
+            }
+        });
+    }
+    /**
+       * Applies the height map to the vertices
+       * @param vertices The vertices to modify
+       */
+    applyHeightMap(vertices) {
+        if (!this.heightMap)
+            return;
+        // Fix: Convert ArrayLike to a mutable array
+        const verticesArray = new Float32Array(vertices);
+        // Apply height map to the y-coordinate of each vertex
+        for (let i = 0; i < verticesArray.length; i += 3) {
+            const index = Math.floor(i / 3);
+            // Y is the up axis after rotation
+            verticesArray[i + 1] = this.heightMap[index];
+        }
+        // Update the original buffer with our modified values
+        for (let i = 0; i < vertices.length; i++) {
+            vertices[i] = verticesArray[i];
+        }
+    }
+    /**
+       * Sets a new height map for the terrain
+       * @param heightMap New height map data
+       */
+    setHeightMap(heightMap) {
+        if (heightMap.length !== (this.options.widthSegments + 1) * (this.options.depthSegments + 1)) {
+            console.error('Height map size does not match terrain dimensions');
+            return;
+        }
+        this.heightMap = heightMap;
+        this.generateFromHeightMap();
+        if (this.options.uvScaleTilesPerUnit) {
+            MaterialUtils.scaleUVsBySize(this.mesh, this.options.uvScaleTilesPerUnit);
+        }
+    }
+    /**
+       * Generates a height map using Perlin noise
+       * @param scale Scale of the noise
+       * @param maxHeight Maximum height of the terrain (defaults to the component's maxHeight)
+       */
+    generateTerrain(frequency, maxHeight, seed, noiseType) {
+        frequency = frequency ?? this.options.noiseFrequency ?? 1;
+        maxHeight = maxHeight ?? this.options.maxHeight;
+        seed = seed ?? this.options.noiseSeed ?? Math.random();
+        noiseType = noiseType ?? this.options.noiseType;
+        const generator = new Perlin(seed);
+        // always recreate the height map to support regeneration
+        this.heightMap = new Float32Array((this.options.widthSegments + 1) * (this.options.depthSegments + 1));
+        // Generate heights using noise
+        if (noiseType === 'random') {
+            let index = 0;
+            for (let z = 0; z <= this.options.depthSegments; z++) {
+                for (let x = 0; x <= this.options.widthSegments; x++) {
+                    const height = generator.simplex2(x * frequency, z * frequency);
+                    this.heightMap[index++] = height * maxHeight;
+                }
+            }
+        }
+        else {
+            let index = 0;
+            for (let z = 0; z <= this.options.depthSegments; z++) {
+                for (let x = 0; x <= this.options.widthSegments; x++) {
+                    const height = generator.perlin2(x * frequency, z * frequency);
+                    this.heightMap[index++] = height * maxHeight;
+                }
+            }
+        }
+        this.generateFromHeightMap();
+        if (this.options.uvScaleTilesPerUnit) {
+            MaterialUtils.scaleUVsBySize(this.mesh, this.options.uvScaleTilesPerUnit);
+        }
+    }
+    generateFromHeightMap() {
+        // Create a plane geometry for the terrain
+        const geometry = new THREE.PlaneGeometry(this.options.width, this.options.depth, this.options.widthSegments, this.options.depthSegments);
+        // Rotate the plane to be horizontal (facing up)
+        geometry.rotateX(-Math.PI / 2);
+        // Get the position attribute from the geometry
+        const positionAttribute = geometry.getAttribute('position');
+        const vertices = positionAttribute.array;
+        // Apply the height map to the vertices
+        this.applyHeightMap(vertices);
+        // Update the position attribute
+        positionAttribute.needsUpdate = true;
+        // Update normals
+        geometry.computeVertexNormals();
+        // Set the new geometry
+        this.mesh.geometry.dispose();
+        this.mesh.geometry = geometry;
+    }
+    /**
+       * Sets the maximum height for the terrain
+       * @param height New maximum height
+       * @param regenerate Whether to regenerate the terrain with the new height
+       */
+    setMaxHeight(height, regenerate = true) {
+        this.options.maxHeight = height;
+        if (regenerate && this.heightMap) {
+            this.generateTerrain();
+        }
+    }
+    /**
+       * Gets the current maximum height setting
+       */
+    getMaxHeight() {
+        return this.options.maxHeight;
+    }
+    /**
+       * Updates the terrain with new dimensions
+       * @param width New width
+       * @param depth New depth
+       * @param widthSegments New width segments
+       * @param depthSegments New depth segments
+       */
+    updateTerrainDimensions(width, depth, widthSegments, depthSegments) {
+        if (width !== undefined)
+            this.options.width = width;
+        if (depth !== undefined)
+            this.options.depth = depth;
+        if (widthSegments !== undefined)
+            this.options.widthSegments = widthSegments;
+        if (depthSegments !== undefined)
+            this.options.depthSegments = depthSegments;
+        this.generateTerrain();
+    }
+    /**
+       * Gets the height at a specific world position
+       * @param x X coordinate in world space
+       * @param z Z coordinate in world space
+       * @returns Height at position or null if out of bounds
+       */
+    getHeightAt(x, z) {
+        if (!this.heightMap)
+            return null;
+        // Convert world coordinates to terrain coordinates
+        const localX = x + this.options.width / 2;
+        const localZ = z + this.options.depth / 2;
+        // Convert to UV coordinates (0-1)
+        const u = localX / this.options.width;
+        const v = localZ / this.options.depth;
+        // Check if the point is within the terrain bounds
+        if (u < 0 || u > 1 || v < 0 || v > 1) {
+            return null;
+        }
+        // Convert to grid coordinates
+        const gridX = Math.min(Math.floor(u * this.options.widthSegments), this.options.widthSegments - 1);
+        const gridZ = Math.min(Math.floor(v * this.options.depthSegments), this.options.depthSegments - 1);
+        // Get the index in the height map
+        const index = gridZ * (this.options.widthSegments + 1) + gridX;
+        return this.heightMap[index];
+    }
+    /**
+       * Gets the current height map data
+       * @returns Current height map array or null if not generated
+       */
+    getHeightMap() {
+        return this.heightMap;
+    }
+    /**
+       * Syncs the terrain with physics (currently does nothing)
+       * @param position Position vector (unused)
+       * @param quat Quaternion (unused)
+       * @returns This instance for chaining
+       */
+    syncFromPhysics(position, quat) {
+        return this;
+    }
+    //====================================================================================================
+    // Editor Functions
+    //====================================================================================================
+    getEditorClassIcon() {
+        return 'Icon_TerrainMesh';
+    }
+    onEditorPropertyChanged(path, value, result) {
+        super.onEditorPropertyChanged(path, value, result);
+        if (['width', 'depth', 'widthSegments', 'depthSegments', 'maxHeight', 'noiseType', 'noiseFrequency', 'noiseSeed', 'uvScaleTilesPerUnit'].includes(path)) {
+            this.generateTerrain();
+            return;
+        }
+        if (['material'].includes(path)) {
+            this.setMaterial(value);
+            return;
+        }
+    }
+};
+Object.defineProperty(TerrainMeshComponent, "EDITOR_CLASS_META", {
+    enumerable: true,
+    configurable: true,
+    writable: true,
+    value: {
+        ...PrimitiveComponent.EDITOR_CLASS_META,
+        noiseType: { select: ['random', 'perlin'] },
+        material: { type: ['material'] },
+    }
+});
+TerrainMeshComponent = TerrainMeshComponent_1 = __decorate([
+    EngineClass('TerrainMeshComponent'),
+    __metadata("design:paramtypes", [Object])
+], TerrainMeshComponent);
+export { TerrainMeshComponent };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"TerrainMeshComponent.js","sourceRoot":"","sources":["../../../../src/components/visual/TerrainMeshComponent.ts"],"names":[],"mappings":"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"}

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

@@ -0,0 +1,60 @@
+import { IAsyncLoadableTag } from '../../utils/IAsyncLoadable.js';
+import { SceneComponent } from '../SceneComponent.js';
+import type { BaseUIComponent } from '../../ui/components/BaseUIComponent.js';
+import type { IAsyncLoadable } from '../../utils/IAsyncLoadable.js';
+import type { SceneComponentOptions } from '../SceneComponent.js';
+export interface UI3DComponentOptions extends SceneComponentOptions {
+    /** The BaseUIComponent instance to manage */
+    uiComponent?: BaseUIComponent<any>;
+    /** Margin from screen edges to hide the UI component */
+    screenMargin?: number;
+    /** Whether to hide the UI when the component is behind the camera */
+    hideWhenBehindCamera?: boolean;
+    /** Whether to clamp the UI position to screen bounds */
+    clampToScreenBounds?: boolean;
+    /** Screen space offset in pixels {x, y} */
+    screenOffset?: {
+        x: number;
+        y: number;
+    };
+    distanceScaling?: {
+        /** Base distance for scale calculation (scale = 1.0 at this distance) */
+        baseDistance: number;
+        /** Minimum scale factor */
+        minScale: number;
+        /** Maximum scale factor */
+        maxScale: number;
+    };
+}
+export declare class UI3DComponent extends SceneComponent<UI3DComponentOptions> implements IAsyncLoadable {
+    static get DEFAULT_OPTIONS(): UI3DComponentOptions;
+    readonly [IAsyncLoadableTag] = true;
+    private uiComponent;
+    private tempWorldPosition;
+    private tempCameraWorldPosition;
+    private tempScreenPosition;
+    private isUIComponentReady;
+    private _asyncTaskWorker;
+    constructor(options?: UI3DComponentOptions);
+    beginPlay(): void;
+    endPlay(): void;
+    waitForLoad(): Promise<void>;
+    isLoading(): boolean;
+    /**
+     * Set the UI component to be managed by this 3D component
+     */
+    setUIComponent(uiComponent: BaseUIComponent<any>): Promise<void>;
+    /**
+     * Get the managed UI component
+     */
+    getUIComponent(): BaseUIComponent<any> | null;
+    /**
+     * Set the visibility of the UI component
+     */
+    setVisible(visible: boolean): void;
+    private initializeUIComponent;
+    private detachUIComponent;
+    tickPostPhysics(deltaTime: number): void;
+    private shouldUIBeVisible;
+    getEditorClassIcon(): string | null;
+}

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

@@ -0,0 +1,248 @@
+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;
+/**
+ * UI3DComponent provides a bridge between 3D world objects and 2D UI components.
+ *
+ * This component automatically calculates the UI component's 2D position by projecting
+ * its own 3D position to screen space each frame. It's useful for world-space UI
+ * components like health bars, name tags, or interaction prompts that need to follow
+ * 3D objects.
+ *
+ * Recommended usage:
+ * - Attach to any actor that needs a UI component to follow it in screen space
+ * - Provide a BaseUIComponent instance that will be managed by this component
+ * - The component handles visibility culling and boundary clamping automatically
+ */
+import * as THREE from 'three';
+import { EngineClass } from '../../systems/ClassRegistry.js';
+import { AsyncTaskWorker, IAsyncLoadableTag } from '../../utils/IAsyncLoadable.js';
+import { SceneComponent } from '../SceneComponent.js';
+let UI3DComponent = class UI3DComponent extends SceneComponent {
+    static get DEFAULT_OPTIONS() {
+        return {
+            ...SceneComponent.DEFAULT_OPTIONS,
+            uiComponent: undefined,
+            screenMargin: 10,
+            hideWhenBehindCamera: true,
+            clampToScreenBounds: true,
+        };
+    }
+    constructor(options = {}) {
+        super(options);
+        Object.defineProperty(this, _a, {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: true
+        });
+        Object.defineProperty(this, "uiComponent", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: null
+        });
+        Object.defineProperty(this, "tempWorldPosition", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new THREE.Vector3()
+        });
+        Object.defineProperty(this, "tempCameraWorldPosition", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new THREE.Vector3()
+        });
+        Object.defineProperty(this, "tempScreenPosition", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new THREE.Vector3()
+        });
+        Object.defineProperty(this, "isUIComponentReady", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: false
+        });
+        Object.defineProperty(this, "_asyncTaskWorker", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new AsyncTaskWorker()
+        });
+        if (options.uiComponent) {
+            this.setUIComponent(options.uiComponent);
+        }
+    }
+    beginPlay() {
+        super.beginPlay();
+        if (this.uiComponent && !this.isUIComponentReady) {
+            this.initializeUIComponent();
+        }
+    }
+    endPlay() {
+        this.detachUIComponent();
+        super.endPlay();
+    }
+    // start IAsyncLoadable implementation
+    async waitForLoad() {
+        await this._asyncTaskWorker.waitUntilComplete();
+    }
+    isLoading() {
+        return this._asyncTaskWorker.isRunning();
+    }
+    // end IAsyncLoadable implementation
+    /**
+     * Set the UI component to be managed by this 3D component
+     */
+    async setUIComponent(uiComponent) {
+        // Detach existing component if any
+        if (this.uiComponent) {
+            this.detachUIComponent();
+        }
+        this.uiComponent = uiComponent;
+        // If the component is already playing, initialize the UI component immediately
+        if (this.getWorld()) {
+            await this.initializeUIComponent();
+        }
+    }
+    /**
+     * Get the managed UI component
+     */
+    getUIComponent() {
+        return this.uiComponent;
+    }
+    /**
+     * Set the visibility of the UI component
+     */
+    setVisible(visible) {
+        if (this.uiComponent && this.isUIComponentReady) {
+            if (visible) {
+                this.uiComponent.show();
+            }
+            else {
+                this.uiComponent.hide();
+            }
+        }
+    }
+    async initializeUIComponent() {
+        await this._asyncTaskWorker.runTask(async () => {
+            if (!this.uiComponent) {
+                return;
+            }
+            try {
+                // Initialize the UI component if not already initialized
+                if (!this.uiComponent.getIsInitialized()) {
+                    await this.uiComponent.initialize();
+                }
+                // Set initial visibility
+                this.uiComponent.show();
+                this.isUIComponentReady = true;
+            }
+            catch (error) {
+                console.error('UI3DComponent: Failed to initialize UI component:', error);
+            }
+        });
+    }
+    detachUIComponent() {
+        if (this.uiComponent && this.isUIComponentReady) {
+            this.uiComponent.hide();
+            this.isUIComponentReady = false;
+        }
+        // Note: We don't destroy the UI component as it might be used elsewhere
+        // The caller is responsible for component lifecycle management
+        this.uiComponent = null;
+    }
+    tickPostPhysics(deltaTime) {
+        super.tickPostPhysics(deltaTime);
+        if (!this.uiComponent || !this.isUIComponentReady) {
+            return;
+        }
+        const camera = this.getWorld()?.getActiveCamera();
+        const windowSize = this.getWorld()?.getRenderWindowSize();
+        if (!camera || !windowSize) {
+            return;
+        }
+        // Calculate world position with offset
+        this.getWorldPosition(this.tempWorldPosition);
+        // Project 3D position to screen coordinates
+        this.tempScreenPosition.copy(this.tempWorldPosition).project(camera);
+        const containerSize = windowSize;
+        const screenX = (this.tempScreenPosition.x * 0.5 + 0.5) * containerSize.width;
+        const screenY = (this.tempScreenPosition.y * -0.5 + 0.5) * containerSize.height;
+        // Calculate distance-based scale
+        let distanceScale = 1.0;
+        if (this.options.distanceScaling) {
+            camera.getWorldPosition(this.tempCameraWorldPosition);
+            const distanceToCamera = this.tempWorldPosition.distanceTo(this.tempCameraWorldPosition);
+            const baseDistance = this.options.distanceScaling.baseDistance;
+            const minScale = this.options.distanceScaling.minScale;
+            const maxScale = this.options.distanceScaling.maxScale;
+            // Scale inversely with distance (closer = larger, farther = smaller)
+            distanceScale = baseDistance / distanceToCamera;
+            distanceScale = Math.max(minScale, Math.min(maxScale, distanceScale));
+        }
+        // Apply screen offset
+        const offset = this.options.screenOffset ?? { x: 0, y: 0 };
+        const finalX = screenX + offset.x * distanceScale;
+        const finalY = screenY + offset.y * distanceScale;
+        // Check visibility conditions
+        const margin = this.options.screenMargin ?? 0;
+        const isVisible = this.shouldUIBeVisible(finalX, finalY, containerSize, margin);
+        if (isVisible) {
+            // Clamp to screen bounds if enabled
+            let clampedX = finalX;
+            let clampedY = finalY;
+            if (this.options.clampToScreenBounds) {
+                clampedX = Math.max(margin, Math.min(finalX, containerSize.width - margin));
+                clampedY = Math.max(margin, Math.min(finalY, containerSize.height - margin));
+            }
+            // Update UI component position and scale using BaseUIComponent's setPosition method
+            this.uiComponent.setPosition({
+                left: `${clampedX}px`,
+                top: `${clampedY}px`,
+                position: 'absolute',
+                transform: `translate(-50%, -50%) scale(${distanceScale})`,
+                transformOrigin: 'center'
+            });
+            this.uiComponent.show();
+        }
+        else {
+            this.uiComponent.hide();
+        }
+    }
+    shouldUIBeVisible(x, y, containerSize, margin) {
+        // Check if behind camera
+        if (this.options.hideWhenBehindCamera && (this.tempScreenPosition.z > 1 || this.tempScreenPosition.z < 0)) {
+            return false;
+        }
+        // Check if outside screen bounds
+        if (x < margin || x > containerSize.width - margin ||
+            y < margin || y > containerSize.height - margin) {
+            return false;
+        }
+        return true;
+    }
+    //====================================================================================================
+    // Editor Functions
+    //====================================================================================================
+    getEditorClassIcon() {
+        return 'Icon_UI3D';
+    }
+};
+_a = IAsyncLoadableTag;
+UI3DComponent = __decorate([
+    EngineClass('UI3DComponent'),
+    __metadata("design:paramtypes", [Object])
+], UI3DComponent);
+export { UI3DComponent };
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,23 @@
+/**
+ * Visual components aggregate export.
+ *
+ * This module re-exports components responsible for rendering and animation in
+ * the Genesys engine. Including this barrel allows external modules and AI
+ * scripts to easily access billboard, mesh, camera, and particle systems from a
+ * single import location. Keeping these exports together makes engine
+ * extensibility more straightforward.
+ */
+export * from './BillboardComponent.js';
+export * from './BaseInstancedMeshComponent.js';
+export * from './EditorOnlyMeshComponent.js';
+export * from './GLTFMeshComponent.js';
+export * from './AnimationComponent.js';
+export * from './AnimationStateMachineComponent.js';
+export * from './InstancedGltfMeshComponent.js';
+export * from './InstancedMeshComponent.js';
+export * from './MeshComponent.js';
+export * from './ParticleEmitterComponent.js';
+export * from './TerrainMeshComponent.js';
+export * from './SkyboxComponent.js';
+export * from './FogComponent.js';
+export * from './UI3DComponent.js';