@directivegames/genesys.js 3.1.27 → 3.1.29

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

@@ -0,0 +1,373 @@
+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);
+};
+/**
+ * SplineMeshComponent generates a flat ribbon mesh along a Catmull-Rom spline.
+ *
+ * Use cases include roads, paths, rivers, and any geometry that follows a curved path.
+ * The component samples points along the spline and creates a ribbon with proper
+ * UV mapping for texture tiling based on world distance.
+ *
+ * Recommended usage (for humans and AI assistants):
+ * - Provide an array of control points defining the path
+ * - Adjust width, segments, and tension for desired appearance
+ * - Use uvScale to control texture tiling density
+ * - Enable showDebug to visualize control points and spline curve
+ */
+import * as THREE from 'three';
+import { MaterialUtils } from '../../materials.js';
+import { EngineClass } from '../../systems/ClassRegistry.js';
+import { resourceManager } from '../../utils/ResourceManager.js';
+import { isNode } from '../../utils/Utils.js';
+import { PrimitiveComponent } from '../PrimitiveComponent.js';
+let SplineMeshComponent = class SplineMeshComponent extends PrimitiveComponent {
+    static get DEFAULT_OPTIONS() {
+        return {
+            ...PrimitiveComponent.DEFAULT_OPTIONS,
+            // Provide default starter points so the spline is visible when created
+            points: [
+                new THREE.Vector3(-2, 0, 0),
+                new THREE.Vector3(0, 0, 1),
+                new THREE.Vector3(2, 0, 0),
+            ],
+            width: 1,
+            segments: 50,
+            closed: false,
+            tension: 0.5,
+            uvScale: 1,
+            material: '', // Asset path to material JSON file
+            showDebug: false,
+            physicsOptions: {
+                ...PrimitiveComponent.DEFAULT_PHYSICS_OPTIONS,
+                enabled: false,
+            },
+        };
+    }
+    constructor(options = {}) {
+        super(options);
+        Object.defineProperty(this, "mesh", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: null
+        });
+        Object.defineProperty(this, "curve", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: null
+        });
+        Object.defineProperty(this, "debugGroup", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: null
+        });
+        this.rebuildMesh();
+    }
+    /**
+     * Returns the THREE.Mesh object associated with this component
+     */
+    getMesh() {
+        return this.mesh;
+    }
+    /**
+     * Returns the underlying Catmull-Rom curve
+     */
+    getCurve() {
+        return this.curve;
+    }
+    /**
+     * Sets new control points and rebuilds the mesh
+     */
+    setPoints(points) {
+        this.options.points = points;
+        this.rebuildMesh();
+    }
+    /**
+     * Sets the ribbon width and rebuilds the mesh
+     */
+    setWidth(width) {
+        this.options.width = width;
+        this.rebuildMesh();
+    }
+    /**
+     * Sets the segment count and rebuilds the mesh
+     */
+    setSegments(segments) {
+        this.options.segments = segments;
+        this.rebuildMesh();
+    }
+    /**
+     * Sets the Catmull-Rom tension and rebuilds the mesh
+     */
+    setTension(tension) {
+        this.options.tension = tension;
+        this.rebuildMesh();
+    }
+    /**
+     * Sets the UV scale and rebuilds the mesh
+     */
+    setUvScale(uvScale) {
+        this.options.uvScale = uvScale;
+        this.rebuildMesh();
+    }
+    /**
+     * Sets whether the spline is closed and rebuilds the mesh
+     */
+    setClosed(closed) {
+        this.options.closed = closed;
+        this.rebuildMesh();
+    }
+    /**
+     * Sets the material for the mesh
+     */
+    setMaterial(material) {
+        this.options.material = material;
+        if (this.mesh) {
+            resourceManager.loadGenericMaterial(material).then((loadedMaterial) => {
+                if (loadedMaterial && this.mesh) {
+                    this.mesh.material = loadedMaterial;
+                }
+            });
+        }
+        else {
+            // Mesh doesn't exist yet - rebuild to create it with the new material
+            this.rebuildMesh();
+        }
+    }
+    /**
+     * Toggles debug visualization
+     */
+    setShowDebug(show) {
+        this.options.showDebug = show;
+        this.updateDebugVisualization();
+    }
+    /**
+     * Rebuilds the ribbon mesh based on current options
+     */
+    rebuildMesh() {
+        // Filter out null/undefined points and ensure they are Vector3 instances
+        // (points may be plain {x,y,z} objects after deserialization)
+        const rawPoints = this.options.points ?? [];
+        const points = rawPoints
+            .filter((p) => p != null)
+            .map(p => p instanceof THREE.Vector3 ? p : new THREE.Vector3(p.x, p.y, p.z));
+        if (points.length < 2) {
+            this.clearMesh();
+            return;
+        }
+        // Create the Catmull-Rom curve
+        this.curve = new THREE.CatmullRomCurve3(points, this.options.closed ?? false, 'catmullrom', this.options.tension ?? 0.5);
+        const segments = this.options.segments ?? 50;
+        const width = this.options.width ?? 1;
+        const uvScale = this.options.uvScale ?? 1;
+        const halfWidth = width / 2;
+        // Generate geometry
+        const geometry = this.generateRibbonGeometry(this.curve, segments, halfWidth, uvScale);
+        // Remove old mesh if exists
+        if (this.mesh) {
+            this.mesh.removeFromParent();
+            this.mesh.geometry.dispose();
+        }
+        // Create new mesh with default material initially
+        this.mesh = new THREE.Mesh(geometry, MaterialUtils.DefaultMaterial);
+        this.mesh.setTransient(true);
+        this.bindObject3DProperties(this.mesh, ['castShadow', 'receiveShadow']);
+        this.add(this.mesh);
+        // Load material if specified
+        if (!isNode() && this.options.material) {
+            resourceManager.loadGenericMaterial(this.options.material).then((loadedMaterial) => {
+                if (loadedMaterial && this.mesh) {
+                    this.mesh.material = loadedMaterial;
+                }
+            });
+        }
+        // Update debug visualization
+        this.updateDebugVisualization();
+    }
+    /**
+     * Generates a ribbon geometry along the curve
+     */
+    generateRibbonGeometry(curve, segments, halfWidth, uvScale) {
+        const vertices = [];
+        const normals = [];
+        const uvs = [];
+        const indices = [];
+        const totalLength = curve.getLength();
+        const up = new THREE.Vector3(0, 1, 0);
+        const tempTangent = new THREE.Vector3();
+        const tempNormal = new THREE.Vector3();
+        const tempBinormal = new THREE.Vector3();
+        // Sample points along the curve
+        for (let i = 0; i <= segments; i++) {
+            const t = i / segments;
+            const point = curve.getPointAt(t);
+            const tangent = curve.getTangentAt(t).normalize();
+            // Calculate binormal (perpendicular to tangent and up)
+            tempBinormal.crossVectors(up, tangent).normalize();
+            // Handle degenerate case when tangent is parallel to up
+            if (tempBinormal.lengthSq() < 0.001) {
+                tempBinormal.set(1, 0, 0);
+            }
+            // Calculate normal (perpendicular to tangent and binormal)
+            tempNormal.crossVectors(tangent, tempBinormal).normalize();
+            // Create two vertices at this point (left and right edges)
+            const leftPoint = point.clone().addScaledVector(tempBinormal, -halfWidth);
+            const rightPoint = point.clone().addScaledVector(tempBinormal, halfWidth);
+            vertices.push(leftPoint.x, leftPoint.y, leftPoint.z);
+            vertices.push(rightPoint.x, rightPoint.y, rightPoint.z);
+            // Normals point up
+            normals.push(tempNormal.x, tempNormal.y, tempNormal.z);
+            normals.push(tempNormal.x, tempNormal.y, tempNormal.z);
+            // UVs: U tiles along length based on world distance, V is 0-1 across width
+            const distanceAlongCurve = t * totalLength;
+            const u = distanceAlongCurve * uvScale;
+            uvs.push(u, 0); // Left edge
+            uvs.push(u, 1); // Right edge
+        }
+        // Generate indices for triangle strip (CCW winding for upward-facing normals)
+        for (let i = 0; i < segments; i++) {
+            const baseIndex = i * 2;
+            // First triangle: left[i] -> left[i+1] -> right[i]
+            indices.push(baseIndex, baseIndex + 2, baseIndex + 1);
+            // Second triangle: right[i] -> left[i+1] -> right[i+1]
+            indices.push(baseIndex + 1, baseIndex + 2, baseIndex + 3);
+        }
+        const geometry = new THREE.BufferGeometry();
+        geometry.setAttribute('position', new THREE.Float32BufferAttribute(vertices, 3));
+        geometry.setAttribute('normal', new THREE.Float32BufferAttribute(normals, 3));
+        geometry.setAttribute('uv', new THREE.Float32BufferAttribute(uvs, 2));
+        geometry.setIndex(indices);
+        return geometry;
+    }
+    /**
+     * Clears the current mesh
+     */
+    clearMesh() {
+        if (this.mesh) {
+            this.mesh.removeFromParent();
+            this.mesh.geometry.dispose();
+            this.mesh = null;
+        }
+        this.curve = null;
+        this.clearDebugVisualization();
+    }
+    /**
+     * Updates debug visualization showing control points and spline
+     */
+    updateDebugVisualization() {
+        this.clearDebugVisualization();
+        if (!this.options.showDebug || !this.curve) {
+            return;
+        }
+        this.debugGroup = new THREE.Group();
+        this.debugGroup.setTransient(true);
+        // Filter out null/undefined points and ensure they are Vector3 instances
+        const rawPoints = this.options.points ?? [];
+        const points = rawPoints
+            .filter((p) => p != null)
+            .map(p => p instanceof THREE.Vector3 ? p : new THREE.Vector3(p.x, p.y, p.z));
+        // Draw control point spheres
+        const sphereGeometry = new THREE.SphereGeometry(0.15);
+        const sphereMaterial = new THREE.MeshBasicMaterial({ color: 0xff0000 });
+        for (let i = 0; i < points.length; i++) {
+            const sphere = new THREE.Mesh(sphereGeometry, sphereMaterial);
+            sphere.position.copy(points[i]);
+            this.debugGroup.add(sphere);
+        }
+        // Draw spline curve line
+        const curvePoints = this.curve.getPoints(100);
+        const lineGeometry = new THREE.BufferGeometry().setFromPoints(curvePoints);
+        const lineMaterial = new THREE.LineBasicMaterial({ color: 0x00ff00 });
+        const line = new THREE.Line(lineGeometry, lineMaterial);
+        this.debugGroup.add(line);
+        // Draw tangent indicators at control points
+        const arrowMaterial = new THREE.LineBasicMaterial({ color: 0x0000ff });
+        for (let i = 0; i < points.length; i++) {
+            const t = this.options.closed ? i / points.length : i / (points.length - 1);
+            const tangent = this.curve.getTangentAt(Math.min(t, 1)).normalize();
+            const arrowPoints = [
+                points[i].clone(),
+                points[i].clone().addScaledVector(tangent, 0.5)
+            ];
+            const arrowGeometry = new THREE.BufferGeometry().setFromPoints(arrowPoints);
+            const arrow = new THREE.Line(arrowGeometry, arrowMaterial);
+            this.debugGroup.add(arrow);
+        }
+        this.add(this.debugGroup);
+    }
+    /**
+     * Clears debug visualization
+     */
+    clearDebugVisualization() {
+        if (this.debugGroup) {
+            this.debugGroup.removeFromParent();
+            this.debugGroup.traverse((child) => {
+                if (child instanceof THREE.Mesh || child instanceof THREE.Line) {
+                    child.geometry.dispose();
+                    if (Array.isArray(child.material)) {
+                        child.material.forEach(m => m.dispose());
+                    }
+                    else {
+                        child.material.dispose();
+                    }
+                }
+            });
+            this.debugGroup = null;
+        }
+    }
+    calcBoundingBox() {
+        if (this.mesh) {
+            this.mesh.geometry.computeBoundingBox();
+            this._boundingBox.copy(this.mesh.geometry.boundingBox).applyMatrix4(this.mesh.matrixWorld);
+        }
+    }
+    getEditorClassIcon() {
+        return 'Icon_Path';
+    }
+    onEditorPropertyChanged(path, value, result) {
+        super.onEditorPropertyChanged(path, value, result);
+        // Rebuild mesh when any spline-related property changes
+        if (result.isOptions) {
+            if (path === 'material') {
+                this.setMaterial(value);
+            }
+            else if (path === 'points' || path.startsWith('points[') || path.startsWith('points.')) {
+                // Handle array changes: full replacement, element changes, or property changes
+                this.rebuildMesh();
+            }
+            else if (['width', 'segments', 'tension', 'uvScale', 'closed', 'showDebug'].includes(path)) {
+                this.rebuildMesh();
+            }
+        }
+    }
+};
+Object.defineProperty(SplineMeshComponent, "EDITOR_CLASS_META", {
+    enumerable: true,
+    configurable: true,
+    writable: true,
+    value: {
+        ...PrimitiveComponent.EDITOR_CLASS_META,
+        points: { array: { child: { type: THREE.Vector3 } } },
+        width: { number: { min: 0.1, max: 100, step: 0.1, decimals: 2 } },
+        segments: { integer: { min: 2, max: 500, step: 1 } },
+        tension: { number: { min: 0, max: 1, step: 0.05, decimals: 2 } },
+        uvScale: { number: { min: 0.01, max: 10, step: 0.1, decimals: 2 } },
+        closed: { boolean: {} },
+        showDebug: { boolean: {} },
+        material: { type: ['material'] },
+    }
+});
+SplineMeshComponent = __decorate([
+    EngineClass('SplineMeshComponent'),
+    __metadata("design:paramtypes", [Object])
+], SplineMeshComponent);
+export { SplineMeshComponent };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"SplineMeshComponent.js","sourceRoot":"","sources":["../../../../src/components/visual/SplineMeshComponent.ts"],"names":[],"mappings":"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"}

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

@@ -21,3 +21,4 @@ export * from './TerrainMeshComponent.js';
 export * from './SkyboxComponent.js';
 export * from './FogComponent.js';
 export * from './UI3DComponent.js';
+export * from './SplineMeshComponent.js';

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

@@ -21,4 +21,5 @@ export * from './TerrainMeshComponent.js';
 export * from './SkyboxComponent.js';
 export * from './FogComponent.js';
 export * from './UI3DComponent.js';
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9zcmMvY29tcG9uZW50cy92aXN1YWwvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7Ozs7Ozs7O0dBUUc7QUFDSCxjQUFjLHlCQUF5QixDQUFDO0FBQ3hDLGNBQWMsaUNBQWlDLENBQUM7QUFDaEQsY0FBYyw4QkFBOEIsQ0FBQztBQUM3QyxjQUFjLHdCQUF3QixDQUFDO0FBQ3ZDLGNBQWMseUJBQXlCLENBQUM7QUFDeEMsY0FBYyxxQ0FBcUMsQ0FBQztBQUNwRCxjQUFjLGlDQUFpQyxDQUFDO0FBQ2hELGNBQWMsNkJBQTZCLENBQUM7QUFDNUMsY0FBYyxvQkFBb0IsQ0FBQztBQUNuQyxjQUFjLCtCQUErQixDQUFDO0FBQzlDLGNBQWMsMkJBQTJCLENBQUM7QUFDMUMsY0FBYyxzQkFBc0IsQ0FBQztBQUNyQyxjQUFjLG1CQUFtQixDQUFDO0FBQ2xDLGNBQWMsb0JBQW9CLENBQUMifQ==
+export * from './SplineMeshComponent.js';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9zcmMvY29tcG9uZW50cy92aXN1YWwvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7Ozs7Ozs7O0dBUUc7QUFDSCxjQUFjLHlCQUF5QixDQUFDO0FBQ3hDLGNBQWMsaUNBQWlDLENBQUM7QUFDaEQsY0FBYyw4QkFBOEIsQ0FBQztBQUM3QyxjQUFjLHdCQUF3QixDQUFDO0FBQ3ZDLGNBQWMseUJBQXlCLENBQUM7QUFDeEMsY0FBYyxxQ0FBcUMsQ0FBQztBQUNwRCxjQUFjLGlDQUFpQyxDQUFDO0FBQ2hELGNBQWMsNkJBQTZCLENBQUM7QUFDNUMsY0FBYyxvQkFBb0IsQ0FBQztBQUNuQyxjQUFjLCtCQUErQixDQUFDO0FBQzlDLGNBQWMsMkJBQTJCLENBQUM7QUFDMUMsY0FBYyxzQkFBc0IsQ0FBQztBQUNyQyxjQUFjLG1CQUFtQixDQUFDO0FBQ2xDLGNBQWMsb0JBQW9CLENBQUM7QUFDbkMsY0FBYywwQkFBMEIsQ0FBQyJ9