@directivegames/genesys.js 3.1.24

package/dist/games/navmesh-primitives-demo.js

@@ -0,0 +1,1105 @@
+import * as ENGINE from 'genesys.js';
+import * as THREE from 'three';
+import { OrbitControls } from 'three/addons/controls/OrbitControls.js';
+import { Pane } from 'tweakpane';
+/**
+ * Navmesh Primitives Demo
+ *
+ * This demo showcases automatic navmesh generation using the built-in scene analysis system,
+ * including the new export/import functionality for external editor workflows:
+ *
+ * Features Demonstrated:
+ * - Setting up scenes with primitive MeshComponents (boxes, spheres, cylinders)
+ * - Setting up scenes with GLTF models from the asset library
+ * - **Automatic scene analysis**: NavMesh generation finds all static geometry automatically
+ * - Respects `excludeFromNavigation` flags on mesh components
+ * - Only includes actors with `PhysicsMotionType.Static` motion type
+ * - Debug visualization of the generated navmesh
+ * - Interactive Tweakpane UI for real-time navmesh parameter adjustment
+ * - Real-time navmesh regeneration with updated parameters
+ * - **Export current navmesh to binary file for external editors**
+ * - **Import navmesh from binary file (direct application without regeneration)**
+ * - **NEW: Scene export with explicit resource metadata (no more currentScenePath!)**
+ * - **NEW: External tool APIs for setting resource references in scenes**
+ *
+ * The demo creates two environments side by side:
+ * LEFT SIDE (Primitives): Ground plane, primitive obstacles, platforms, maze walls
+ * RIGHT SIDE (GLTF): Floor tiles, modular walls, trees, rocks, vehicles, structures
+ * - **Automatic scene analysis**: No manual mesh collection required!
+ * - Green debug visualization overlay showing walkable areas across both scenes
+ * - Tweakpane controls for adjusting all Recast Navigation parameters
+ * - Export/Import buttons for navmesh workflow testing
+ *
+ * Export/Import Workflow:
+ * 1. Generate a navmesh using the "Regenerate Navmesh" button (automatic scene analysis)
+ * 2. Export it to binary file using "Export NavMesh" button
+ * 3. Optionally modify the navmesh in an external editor
+ * 4. Import the modified navmesh using "Import NavMesh" button
+ * 5. The imported navmesh is applied directly without regeneration
+ *
+ * NEW Resource Metadata Workflow:
+ * 1. Use "Set NavMesh Reference in Scene" to configure resource path
+ * 2. Use "Export Scene with NavMesh Reference" to save scene with metadata
+ * 3. External tools can edit scenes to set resource references
+ * 4. Engine automatically loads resources from scene metadata
+ */
+export class NavmeshPrimitivesDemo extends ENGINE.BaseGameLoop {
+    // Tweakpane controls and parameters - defined as static getter to be available during construction
+    static get DEFAULT_NAVMESH_PARAMS() {
+        return {
+            // Cell dimensions
+            cs: 0.2, // Cell size (XZ plane resolution)
+            ch: 0.2, // Cell height (Y axis resolution)
+            // Agent capabilities
+            walkableSlopeAngle: 35, // Maximum slope angle in degrees
+            walkableHeight: 2.0, // Minimum ceiling height for agent
+            walkableClimb: 0.5, // Maximum step height agent can climb
+            walkableRadius: 0.5, // Agent radius (affects corridor width)
+            // Mesh generation quality
+            maxEdgeLen: 12, // Maximum edge length in world units
+            maxSimplificationError: 1.3, // Edge simplification tolerance
+            // Region processing
+            minRegionArea: 8, // Minimum area for isolated regions
+            mergeRegionArea: 20, // Merge regions smaller than this
+            // Polygon generation
+            maxVertsPerPoly: 6, // Maximum vertices per polygon
+            // Detail mesh (for height sampling)
+            detailSampleDist: 6, // Detail mesh sample distance
+            detailSampleMaxError: 1, // Maximum detail mesh error
+            // Border handling
+            borderSize: 0, // Border size around the mesh
+            // Debug visualization
+            debugEnabled: true, // Show navmesh debug visualization
+            // Scene control
+            sceneType: 'Both' // Which scene types to show
+        };
+    }
+    constructor(container, options) {
+        super(container, options);
+        Object.defineProperty(this, "pane", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "navmeshParams", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: { ...NavmeshPrimitivesDemo.DEFAULT_NAVMESH_PARAMS }
+        });
+        this.setupCamera(container);
+    }
+    /**
+     * Configure the world with navigation server enabled
+     */
+    getWorldConfiguration() {
+        // Use static defaults during construction when instance fields aren't ready yet
+        const params = NavmeshPrimitivesDemo.DEFAULT_NAVMESH_PARAMS;
+        return {
+            ...super.getWorldConfiguration(),
+            navigationOptions: {
+                engine: ENGINE.NavigationEngine.RecastNavigation,
+                debug: params.debugEnabled,
+                generateOnStartUp: false, // Manual generation after adding meshes
+                options: {
+                    ...ENGINE.RecastNavigationServer.DEFAULT_OPTIONS,
+                    cs: params.cs,
+                    ch: params.ch,
+                    walkableSlopeAngle: params.walkableSlopeAngle,
+                    walkableHeight: params.walkableHeight,
+                    walkableClimb: params.walkableClimb,
+                    walkableRadius: params.walkableRadius,
+                    maxEdgeLen: params.maxEdgeLen,
+                    maxSimplificationError: params.maxSimplificationError,
+                    minRegionArea: params.minRegionArea,
+                    mergeRegionArea: params.mergeRegionArea,
+                    maxVertsPerPoly: params.maxVertsPerPoly,
+                    detailSampleDist: params.detailSampleDist,
+                    detailSampleMaxError: params.detailSampleMaxError,
+                    borderSize: params.borderSize
+                }
+            }
+        };
+    }
+    async preStart() {
+        // Set up basic lighting
+        this.setupLighting();
+        // Create scenes based on current settings
+        this.createActiveScenes();
+    }
+    postStart() {
+        // // Generate navmesh after all geometry is in place
+        // await this.generateNavmesh();
+        // Create Tweakpane UI controls
+        this.createTweakPane();
+        // Log information about the new export/import functionality
+        console.log('🚀 NavMesh Export/Import Demo Ready!');
+        console.log('📝 Use Export/Import controls to save/load navmesh as GLTF files');
+        console.log('🆕 NEW: Scene export with resource metadata system!');
+    }
+    /**
+     * Create all scenes and set initial visibility based on scene type setting
+     */
+    createActiveScenes() {
+        // Always create both scenes so we can toggle between them
+        this.createScene();
+        this.createGLTFScene();
+        // Set initial visibility based on current scene type
+        this.updateSceneVisibility();
+        console.log(`Created all scenes, showing: ${this.navmeshParams.sceneType}`);
+    }
+    /**
+     * Update scene visibility based on current scene type setting
+     */
+    updateSceneVisibility() {
+        const sceneType = this.navmeshParams.sceneType;
+        // Get all actors in the world
+        const allActors = this.world.getActorsByPredicate(() => true);
+        allActors.forEach(actor => {
+            // Determine if this is a primitive or GLTF actor based on components
+            const hasMeshComponent = actor.getComponent(ENGINE.MeshComponent) !== null;
+            const hasGLTFComponent = actor.getComponent(ENGINE.GLTFMeshComponent) !== null;
+            // Skip lighting actors
+            if (actor.name.includes('Light') || actor.name.includes('light')) {
+                return;
+            }
+            let shouldBeVisible = false;
+            if (hasMeshComponent && !hasGLTFComponent) {
+                // This is a primitive actor
+                shouldBeVisible = sceneType === 'Primitives' || sceneType === 'Both';
+            }
+            else if (hasGLTFComponent) {
+                // This is a GLTF actor
+                shouldBeVisible = sceneType === 'GLTF' || sceneType === 'Both';
+            }
+            else {
+                // Keep other actors visible (like lighting)
+                shouldBeVisible = true;
+            }
+            // Update visibility
+            actor.rootComponent.visible = shouldBeVisible;
+        });
+        console.log(`Updated scene visibility: ${sceneType}`);
+    }
+    /**
+     * Set up basic lighting for the scene
+     */
+    setupLighting() {
+        console.log('Setting up lighting...');
+        // Ambient light for overall illumination
+        const ambientLight = new ENGINE.Actor({
+            name: 'AmbientLight',
+            sceneComponents: [
+                new ENGINE.AmbientLightComponent({
+                    color: 0x404080,
+                    intensity: 0.4
+                })
+            ]
+        });
+        this.world.addActors(ambientLight);
+        // Directional light as main light source with shadows
+        const directionalLight = new ENGINE.Actor({
+            name: 'DirectionalLight',
+            position: new THREE.Vector3(10, 20, 10),
+            sceneComponents: [
+                new ENGINE.DirectionalLightComponent({
+                    color: 0xffffff,
+                    intensity: 1.5,
+                    castShadow: true
+                })
+            ]
+        });
+        this.world.addActors(directionalLight);
+    }
+    /**
+       * Create the scene with various primitive MeshComponents
+       */
+    createScene() {
+        console.log('Creating scene with primitive meshes...');
+        // Create ground plane
+        this.createGroundPlane();
+        // Create various obstacles and platforms
+        this.createObstacles();
+        // Create platforms at different heights
+        this.createPlatforms();
+        // Create a maze-like structure
+        this.createMazeWalls();
+    }
+    /**
+       * Create the main ground plane
+       */
+    createGroundPlane() {
+        const ground = new ENGINE.Actor({
+            name: 'Ground',
+            position: new THREE.Vector3(0, 0, 0),
+            rootComponent: new ENGINE.MeshComponent({
+                geometry: new THREE.BoxGeometry(40, 0.2, 40),
+                material: new THREE.MeshStandardMaterial({
+                    color: 0x8B7355, // Brown ground color
+                    roughness: 0.8,
+                    metalness: 0.1
+                })
+            })
+        });
+        // Enable shadows
+        const meshComponent = ground.rootComponent;
+        meshComponent.receiveShadow = true;
+        this.world.addActors(ground);
+    }
+    /**
+       * Create various obstacles using different primitive shapes
+       */
+    createObstacles() {
+        // Box obstacles
+        const boxObstacle1 = new ENGINE.Actor({
+            name: 'BoxObstacle1',
+            position: new THREE.Vector3(5, 1, 5),
+            rootComponent: new ENGINE.MeshComponent({
+                geometry: new THREE.BoxGeometry(2, 2, 2),
+                material: new THREE.MeshStandardMaterial({
+                    color: 0xFF6B6B, // Red
+                    roughness: 0.7,
+                    metalness: 0.2
+                })
+            })
+        });
+        const boxObstacle2 = new ENGINE.Actor({
+            name: 'BoxObstacle2',
+            position: new THREE.Vector3(-8, 1.5, -3),
+            rootComponent: new ENGINE.MeshComponent({
+                geometry: new THREE.BoxGeometry(3, 3, 1.5),
+                material: new THREE.MeshStandardMaterial({
+                    color: 0x4ECDC4, // Teal
+                    roughness: 0.6,
+                    metalness: 0.3
+                })
+            })
+        });
+        // Cylinder obstacles
+        const cylinderObstacle1 = new ENGINE.Actor({
+            name: 'CylinderObstacle1',
+            position: new THREE.Vector3(-5, 1, 8),
+            rootComponent: new ENGINE.MeshComponent({
+                geometry: new THREE.CylinderGeometry(1.5, 1.5, 2, 8),
+                material: new THREE.MeshStandardMaterial({
+                    color: 0x45B7D1, // Blue
+                    roughness: 0.5,
+                    metalness: 0.4
+                })
+            })
+        });
+        const cylinderObstacle2 = new ENGINE.Actor({
+            name: 'CylinderObstacle2',
+            position: new THREE.Vector3(10, 0.75, -8),
+            rootComponent: new ENGINE.MeshComponent({
+                geometry: new THREE.CylinderGeometry(1, 1, 1.5, 6),
+                material: new THREE.MeshStandardMaterial({
+                    color: 0x96CEB4, // Green
+                    roughness: 0.8,
+                    metalness: 0.1
+                })
+            })
+        });
+        // Sphere obstacles
+        const sphereObstacle = new ENGINE.Actor({
+            name: 'SphereObstacle',
+            position: new THREE.Vector3(0, 1.2, -12),
+            rootComponent: new ENGINE.MeshComponent({
+                geometry: new THREE.SphereGeometry(1.2, 16, 12),
+                material: new THREE.MeshStandardMaterial({
+                    color: 0xFECA57, // Yellow
+                    roughness: 0.4,
+                    metalness: 0.6
+                })
+            })
+        });
+        // Enable shadows for all obstacles
+        const obstacles = [boxObstacle1, boxObstacle2, cylinderObstacle1, cylinderObstacle2, sphereObstacle];
+        obstacles.forEach(obstacle => {
+            const meshComponent = obstacle.rootComponent;
+            meshComponent.castShadow = true;
+            meshComponent.receiveShadow = true;
+        });
+        this.world.addActors(...obstacles);
+    }
+    /**
+       * Create elevated platforms using box geometry
+       */
+    createPlatforms() {
+        // Platform 1 - Low platform
+        const platform1 = new ENGINE.Actor({
+            name: 'Platform1',
+            position: new THREE.Vector3(12, 1, 12),
+            rootComponent: new ENGINE.MeshComponent({
+                geometry: new THREE.BoxGeometry(6, 2, 6),
+                material: new THREE.MeshStandardMaterial({
+                    color: 0x686DE0, // Purple
+                    roughness: 0.7,
+                    metalness: 0.2
+                })
+            })
+        });
+        // Platform 2 - Medium platform
+        const platform2 = new ENGINE.Actor({
+            name: 'Platform2',
+            position: new THREE.Vector3(-12, 2, 12),
+            rootComponent: new ENGINE.MeshComponent({
+                geometry: new THREE.BoxGeometry(5, 4, 5),
+                material: new THREE.MeshStandardMaterial({
+                    color: 0xF8B500, // Orange
+                    roughness: 0.6,
+                    metalness: 0.3
+                })
+            })
+        });
+        // Platform 3 - High platform with ramp
+        const platform3 = new ENGINE.Actor({
+            name: 'Platform3',
+            position: new THREE.Vector3(-12, 3, -12),
+            rootComponent: new ENGINE.MeshComponent({
+                geometry: new THREE.BoxGeometry(4, 6, 4),
+                material: new THREE.MeshStandardMaterial({
+                    color: 0xE17055, // Dark orange
+                    roughness: 0.8,
+                    metalness: 0.1
+                })
+            })
+        });
+        // Ramp to platform 3
+        const ramp = new ENGINE.Actor({
+            name: 'Ramp',
+            position: new THREE.Vector3(-8, 1.5, -12),
+            rotation: new THREE.Euler(0, 0, Math.PI / 12), // Slight slope
+            rootComponent: new ENGINE.MeshComponent({
+                geometry: new THREE.BoxGeometry(4, 0.5, 4),
+                material: new THREE.MeshStandardMaterial({
+                    color: 0xA29BFE, // Light purple
+                    roughness: 0.7,
+                    metalness: 0.2
+                })
+            })
+        });
+        // Enable shadows for platforms
+        const platforms = [platform1, platform2, platform3, ramp];
+        platforms.forEach(platform => {
+            const meshComponent = platform.rootComponent;
+            meshComponent.castShadow = true;
+            meshComponent.receiveShadow = true;
+        });
+        this.world.addActors(...platforms);
+    }
+    /**
+     * Create a simple maze-like structure using box walls
+     */
+    createMazeWalls() {
+        const walls = [];
+        // Create a series of wall segments to form a mini maze
+        const wallConfigs = [
+            { pos: [15, 1, 0], size: [1, 2, 8] }, // Vertical wall 1
+            { pos: [8, 1, -5], size: [6, 2, 1] }, // Horizontal wall 1
+            { pos: [2, 1, -8], size: [1, 2, 6] }, // Vertical wall 2
+            { pos: [-2, 1, -5], size: [4, 2, 1] }, // Horizontal wall 2
+            { pos: [-8, 1, 0], size: [1, 2, 6] }, // Vertical wall 3
+            { pos: [-12, 1, 3], size: [6, 2, 1] }, // Horizontal wall 3
+        ];
+        wallConfigs.forEach((config, index) => {
+            const wall = new ENGINE.Actor({
+                name: `MazeWall${index + 1}`,
+                position: new THREE.Vector3(config.pos[0], config.pos[1], config.pos[2]),
+                rootComponent: new ENGINE.MeshComponent({
+                    geometry: new THREE.BoxGeometry(config.size[0], config.size[1], config.size[2]),
+                    material: new THREE.MeshStandardMaterial({
+                        color: 0x74B9FF, // Light blue
+                        roughness: 0.8,
+                        metalness: 0.2
+                    })
+                })
+            });
+            const meshComponent = wall.rootComponent;
+            meshComponent.castShadow = true;
+            meshComponent.receiveShadow = true;
+            walls.push(wall);
+        });
+        this.world.addActors(...walls);
+    }
+    /**
+     * Create a scene using GLTF models for navmesh testing
+     */
+    createGLTFScene() {
+        console.log('Creating GLTF scene for navmesh testing...');
+        // Create a base ground using sandbox floor assets
+        this.createGLTFGround();
+        // Create walls and structures
+        this.createGLTFStructures();
+        // Add decorative elements and obstacles
+        this.createGLTFDecorations();
+        // Add some buildings/larger structures
+        this.createGLTFBuildings();
+    }
+    /**
+     * Create ground/floor using GLTF tiles
+     */
+    createGLTFGround() {
+        // Create a grid of floor tiles
+        const floorSize = 4; // Assuming each floor tile is about 4x4 units
+        const gridSize = 6; // 6x6 grid of tiles
+        for (let x = 0; x < gridSize; x++) {
+            for (let z = 0; z < gridSize; z++) {
+                const floor = new ENGINE.Actor({
+                    name: `GLTFFloor_${x}_${z}`,
+                    position: new THREE.Vector3((x - gridSize / 2) * floorSize + 30, // Offset to the right of primitive scene
+                    0, (z - gridSize / 2) * floorSize),
+                    rootComponent: new ENGINE.GLTFMeshComponent({
+                        modelUrl: '@engine/assets/dev/models/SandboxAsset/Floors/SM_SB_Floor_01.glb',
+                        physicsOptions: {
+                            enabled: true,
+                            motionType: ENGINE.PhysicsMotionType.Static
+                        }
+                    })
+                });
+                this.world.addActors(floor);
+            }
+        }
+    }
+    /**
+     * Create walls and structural elements
+     */
+    createGLTFStructures() {
+        const structures = [
+            // Main walls creating rooms
+            {
+                name: 'WallNorth1',
+                position: new THREE.Vector3(25, 0, -10),
+                modelUrl: '@engine/assets/dev/models/SandboxAsset/Walls/SM_SB_Wall_L_01_128x96.glb'
+            },
+            {
+                name: 'WallNorth2',
+                position: new THREE.Vector3(35, 0, -10),
+                modelUrl: '@engine/assets/dev/models/SandboxAsset/Walls/SM_SB_Wall_L_02_128x96.glb'
+            },
+            {
+                name: 'WallEast1',
+                position: new THREE.Vector3(40, 0, -5),
+                rotation: new THREE.Euler(0, Math.PI / 2, 0),
+                modelUrl: '@engine/assets/dev/models/SandboxAsset/Walls/SM_SB_Wall_L_01B_128x96.glb'
+            },
+            {
+                name: 'WallEast2',
+                position: new THREE.Vector3(40, 0, 5),
+                rotation: new THREE.Euler(0, Math.PI / 2, 0),
+                modelUrl: '@engine/assets/dev/models/SandboxAsset/Walls/SM_SB_Wall_L_03_128x96.glb'
+            },
+            {
+                name: 'WallSouth1',
+                position: new THREE.Vector3(35, 0, 10),
+                rotation: new THREE.Euler(0, Math.PI, 0),
+                modelUrl: '@engine/assets/dev/models/SandboxAsset/Walls/SM_SB_Aztec_Wall_01.glb'
+            },
+            {
+                name: 'WallSouth2',
+                position: new THREE.Vector3(25, 0, 10),
+                rotation: new THREE.Euler(0, Math.PI, 0),
+                modelUrl: '@engine/assets/dev/models/SandboxAsset/Walls/SM_SB_Aztec_Wall_02.glb'
+            },
+            // Interior walls creating obstacles
+            {
+                name: 'InteriorWall1',
+                position: new THREE.Vector3(30, 0, 0),
+                modelUrl: '@engine/assets/dev/models/SandboxAsset/Walls/SM_SB_BrickBlock01.glb'
+            },
+            {
+                name: 'InteriorWall2',
+                position: new THREE.Vector3(27, 0, -5),
+                rotation: new THREE.Euler(0, Math.PI / 4, 0),
+                modelUrl: '@engine/assets/dev/models/SandboxAsset/Walls/SM_SB_BrickBlock02.glb'
+            }
+        ];
+        structures.forEach(structure => {
+            const wall = new ENGINE.Actor({
+                name: structure.name,
+                position: structure.position,
+                rotation: structure.rotation ?? new THREE.Euler(0, 0, 0),
+                rootComponent: new ENGINE.GLTFMeshComponent({
+                    modelUrl: structure.modelUrl,
+                    physicsOptions: {
+                        enabled: true,
+                        motionType: ENGINE.PhysicsMotionType.Static
+                    }
+                })
+            });
+            this.world.addActors(wall);
+        });
+    }
+    /**
+     * Add decorative elements and obstacles
+     */
+    createGLTFDecorations() {
+        const decorations = [
+            // Trees for natural obstacles
+            {
+                name: 'Tree1',
+                position: new THREE.Vector3(32, 0, -7),
+                modelUrl: '@engine/assets/dev/models/SandboxAsset/Trees/SM_SB_CaribbeanPine_01.glb'
+            },
+            {
+                name: 'Tree2',
+                position: new THREE.Vector3(38, 0, 3),
+                modelUrl: '@engine/assets/dev/models/SandboxAsset/Trees/SM_SB_CoconutTree01.glb'
+            },
+            {
+                name: 'Tree3',
+                position: new THREE.Vector3(22, 0, 7),
+                modelUrl: '@engine/assets/dev/models/SandboxAsset/Trees/SM_SB_QueenPalm_01.glb'
+            },
+            // Rocks as obstacles
+            {
+                name: 'Rock1',
+                position: new THREE.Vector3(28, 0, 2),
+                modelUrl: '@engine/assets/dev/models/SandboxAsset/Rocks/SM_SB_Rock01.glb'
+            },
+            {
+                name: 'Rock2',
+                position: new THREE.Vector3(34, 0, -3),
+                modelUrl: '@engine/assets/dev/models/SandboxAsset/Rocks/SM_SB_Rock02.glb'
+            },
+            // Foliage for detail
+            {
+                name: 'Plant1',
+                position: new THREE.Vector3(26, 0, -2),
+                modelUrl: '@engine/assets/dev/models/SandboxAsset/Foliage/SM_SB_Plant01.glb'
+            },
+            {
+                name: 'Fern1',
+                position: new THREE.Vector3(37, 0, -1),
+                modelUrl: '@engine/assets/dev/models/SandboxAsset/Foliage/SM_SB_Fern01.glb'
+            },
+            // Game items as interesting obstacles
+            {
+                name: 'MovingPlatform',
+                position: new THREE.Vector3(29, 0, 5),
+                modelUrl: '@engine/assets/dev/models/SandboxAsset/Game Items/SM_SB_MovingPlatform_01.glb'
+            }
+        ];
+        decorations.forEach(decoration => {
+            const actor = new ENGINE.Actor({
+                name: decoration.name,
+                position: decoration.position,
+                rootComponent: new ENGINE.GLTFMeshComponent({
+                    modelUrl: decoration.modelUrl,
+                    physicsOptions: {
+                        enabled: true,
+                        motionType: ENGINE.PhysicsMotionType.Static
+                    }
+                })
+            });
+            this.world.addActors(actor);
+        });
+    }
+    /**
+     * Add some larger structures and vehicles
+     */
+    createGLTFBuildings() {
+        const structures = [
+            // Large floor pieces as elevated platforms
+            {
+                position: new THREE.Vector3(45, 2, -8),
+                modelUrl: '@engine/assets/dev/models/Architecture/SM_Floor_400x400.glb'
+            },
+            {
+                position: new THREE.Vector3(45, 1, 0),
+                modelUrl: '@engine/assets/dev/models/Architecture/SM_Floor_300x300.glb'
+            },
+            {
+                position: new THREE.Vector3(45, 1.5, 8),
+                modelUrl: '@engine/assets/dev/models/Architecture/SM_Floor_200x400.glb'
+            },
+            // Add a vehicle as an obstacle
+            {
+                name: 'Car1',
+                position: new THREE.Vector3(20, 0, 0),
+                rotation: new THREE.Euler(0, Math.PI / 4, 0),
+                modelUrl: '@engine/assets/dev/models/Vehicles/SM_Car01.glb'
+            },
+            // Add some larger decorative items
+            {
+                name: 'Slide1',
+                position: new THREE.Vector3(24, 0, 4),
+                modelUrl: '@engine/assets/dev/models/SandboxAsset/Slides/SM_SB_Slide_Module.glb'
+            },
+            {
+                name: 'Bridge1',
+                position: new THREE.Vector3(33, 1, -8),
+                modelUrl: '@engine/assets/dev/models/SandboxAsset/Game Items/SM_SB_HangingBridgeMiddle.glb'
+            }
+        ];
+        structures.forEach(structure => {
+            const actor = new ENGINE.Actor({
+                name: structure.name,
+                position: structure.position,
+                rotation: structure.rotation ?? new THREE.Euler(0, 0, 0),
+                rootComponent: new ENGINE.GLTFMeshComponent({
+                    modelUrl: structure.modelUrl,
+                    physicsOptions: {
+                        enabled: true,
+                        motionType: ENGINE.PhysicsMotionType.Static
+                    }
+                })
+            });
+            this.world.addActors(actor);
+        });
+    }
+    /**
+     * Generate navmesh automatically from all static geometry in the scene
+     * Uses the built-in World.createNavigationMeshFromScene() method which automatically:
+     * - Finds all GLTFMeshComponents with Static motion type and !excludeFromNavigation
+     * - Finds all MeshComponents with Static motion type and !excludeFromNavigation
+     * - Waits for GLTF models to load before processing
+     */
+    async generateNavmesh() {
+        console.log('Generating navmesh using built-in scene analysis...');
+        const navigationServer = this.world.getNavigationServer();
+        if (!navigationServer) {
+            console.error('Navigation server not available');
+            return;
+        }
+        try {
+            // Update navigation server options with current parameters before generation
+            const navmeshOptions = {
+                cs: this.navmeshParams.cs,
+                ch: this.navmeshParams.ch,
+                walkableSlopeAngle: this.navmeshParams.walkableSlopeAngle,
+                walkableHeight: this.navmeshParams.walkableHeight,
+                walkableClimb: this.navmeshParams.walkableClimb,
+                walkableRadius: this.navmeshParams.walkableRadius,
+                maxEdgeLen: this.navmeshParams.maxEdgeLen,
+                maxSimplificationError: this.navmeshParams.maxSimplificationError,
+                minRegionArea: this.navmeshParams.minRegionArea,
+                mergeRegionArea: this.navmeshParams.mergeRegionArea,
+                maxVertsPerPoly: this.navmeshParams.maxVertsPerPoly,
+                detailSampleDist: this.navmeshParams.detailSampleDist,
+                detailSampleMaxError: this.navmeshParams.detailSampleMaxError,
+                borderSize: this.navmeshParams.borderSize
+            };
+            // Update the navigation server's options
+            navigationServer.options = { ...navigationServer.options, ...navmeshOptions };
+            // Use the built-in scene analysis method
+            // This automatically finds all static mesh components that should be included in navigation
+            await this.world.createNavigationMeshFromScene();
+            console.log('✅ NavMesh generated successfully using automatic scene analysis!');
+            // Create debug visualization if enabled
+            if (this.navmeshParams.debugEnabled) {
+                const debugVisualization = navigationServer.createDebugVisualization();
+                if (debugVisualization) {
+                    // Disable raycasting for debug mesh to prevent interference
+                    debugVisualization.traverse((child) => {
+                        child.raycast = () => { };
+                    });
+                    debugVisualization.name = 'NavmeshDebugVisualization';
+                    this.world.scene.add(debugVisualization);
+                    console.log('Debug visualization added to scene');
+                }
+            }
+        }
+        catch (error) {
+            console.error('❌ Error during navmesh generation:', error);
+        }
+    }
+    /**
+     * Set up camera for better viewing of both scenes
+     */
+    setupCamera(container) {
+        // Create and set an override camera for better scene viewing
+        const camera = new THREE.PerspectiveCamera(75, 1, 0.1, 1000);
+        const controls = new OrbitControls(camera, container);
+        controls.enableDamping = true;
+        controls.dampingFactor = 0.25;
+        controls.enableZoom = true;
+        controls.enablePan = true;
+        controls.enableRotate = true;
+        // controls.enableKeys = true;
+        // Position camera to see both primitive scene (left) and GLTF scene (right)
+        camera.position.set(15, 20, 35);
+        camera.lookAt(new THREE.Vector3(15, 0, 0)); // Look at center between both scenes
+        this.world.setOverrideCamera(camera);
+        console.log('Camera positioned for dual scene overview');
+    }
+    /**
+     * Create Tweakpane UI for navmesh controls
+     */
+    createTweakPane() {
+        this.pane = new Pane({ title: 'Navmesh Generation Controls' });
+        // Actions folder - split into generation and export/import
+        const generationFolder = this.pane.addFolder({ title: 'NavMesh Generation', expanded: true });
+        const regenerateButton = generationFolder.addButton({ title: 'Regenerate Navmesh' });
+        regenerateButton.on('click', () => {
+            this.regenerateNavmesh();
+        });
+        // Export/Import folder for the new functionality
+        const exportImportFolder = this.pane.addFolder({ title: 'Export/Import', expanded: true });
+        const exportButton = exportImportFolder.addButton({ title: 'Export NavMesh' });
+        exportButton.on('click', () => {
+            this.exportNavmesh();
+        });
+        const importButton = exportImportFolder.addButton({ title: 'Import NavMesh' });
+        importButton.on('click', () => {
+            this.openImportDialog();
+        });
+        // Scene export functionality demonstrating the new metadata system
+        const sceneExportFolder = this.pane.addFolder({ title: 'Scene Export (New System)', expanded: true });
+        const exportSceneButton = sceneExportFolder.addButton({ title: 'Export Scene with NavMesh Reference' });
+        exportSceneButton.on('click', () => {
+            this.exportSceneWithNavMeshReference();
+        });
+        const setNavMeshReferenceButton = sceneExportFolder.addButton({ title: 'Set NavMesh Reference in Scene' });
+        setNavMeshReferenceButton.on('click', () => {
+            this.setNavMeshReferenceInScene();
+        });
+        // Status display following lightmapping demo pattern
+        this.pane.addBlade({ view: 'separator' });
+        const statusElement = document.createElement('div');
+        statusElement.style.padding = '8px';
+        statusElement.style.fontSize = '12px';
+        statusElement.style.color = '#888';
+        statusElement.style.backgroundColor = '#1a1a1a';
+        statusElement.style.borderRadius = '4px';
+        statusElement.innerHTML = 'Status: Ready<br/>🚀 NavMesh Export/Import Demo<br/>📝 1. Generate a navmesh<br/>📤 2. Export to .navmesh file<br/>📥 3. Import .navmesh file<br/>🔧 Files saved as scenename.navmesh<br/>🆕 NEW: Export scenes with resource metadata!';
+        sceneExportFolder.element.appendChild(statusElement);
+        // Store reference for updates
+        this.statusElement = statusElement;
+        // Cell dimensions folder
+        const cellFolder = this.pane.addFolder({ title: 'Cell Dimensions', expanded: true });
+        cellFolder.addBinding(this.navmeshParams, 'cs', {
+            min: 0.05,
+            max: 1.0,
+            step: 0.05,
+            label: 'Cell Size (XZ)'
+        });
+        cellFolder.addBinding(this.navmeshParams, 'ch', {
+            min: 0.05,
+            max: 1.0,
+            step: 0.05,
+            label: 'Cell Height (Y)'
+        });
+        // Agent capabilities folder
+        const agentFolder = this.pane.addFolder({ title: 'Agent Capabilities', expanded: true });
+        agentFolder.addBinding(this.navmeshParams, 'walkableSlopeAngle', {
+            min: 0,
+            max: 90,
+            step: 1,
+            label: 'Max Slope (°)'
+        });
+        agentFolder.addBinding(this.navmeshParams, 'walkableHeight', {
+            min: 0.5,
+            max: 5.0,
+            step: 0.1,
+            label: 'Agent Height'
+        });
+        agentFolder.addBinding(this.navmeshParams, 'walkableClimb', {
+            min: 0.1,
+            max: 2.0,
+            step: 0.1,
+            label: 'Max Step Height'
+        });
+        agentFolder.addBinding(this.navmeshParams, 'walkableRadius', {
+            min: 0.1,
+            max: 2.0,
+            step: 0.1,
+            label: 'Agent Radius'
+        });
+        // Mesh quality folder
+        const qualityFolder = this.pane.addFolder({ title: 'Mesh Quality', expanded: false });
+        qualityFolder.addBinding(this.navmeshParams, 'maxEdgeLen', {
+            min: 1,
+            max: 50,
+            step: 1,
+            label: 'Max Edge Length'
+        });
+        qualityFolder.addBinding(this.navmeshParams, 'maxSimplificationError', {
+            min: 0.1,
+            max: 5.0,
+            step: 0.1,
+            label: 'Simplification Error'
+        });
+        // Region processing folder
+        const regionFolder = this.pane.addFolder({ title: 'Region Processing', expanded: false });
+        regionFolder.addBinding(this.navmeshParams, 'minRegionArea', {
+            min: 1,
+            max: 50,
+            step: 1,
+            label: 'Min Region Area'
+        });
+        regionFolder.addBinding(this.navmeshParams, 'mergeRegionArea', {
+            min: 1,
+            max: 100,
+            step: 1,
+            label: 'Merge Region Area'
+        });
+        // Advanced settings folder
+        const advancedFolder = this.pane.addFolder({ title: 'Advanced Settings', expanded: false });
+        advancedFolder.addBinding(this.navmeshParams, 'maxVertsPerPoly', {
+            min: 3,
+            max: 12,
+            step: 1,
+            label: 'Max Verts Per Poly'
+        });
+        advancedFolder.addBinding(this.navmeshParams, 'detailSampleDist', {
+            min: 1,
+            max: 20,
+            step: 1,
+            label: 'Detail Sample Dist'
+        });
+        advancedFolder.addBinding(this.navmeshParams, 'detailSampleMaxError', {
+            min: 0.1,
+            max: 5.0,
+            step: 0.1,
+            label: 'Detail Max Error'
+        });
+        advancedFolder.addBinding(this.navmeshParams, 'borderSize', {
+            min: 0,
+            max: 10,
+            step: 1,
+            label: 'Border Size'
+        });
+        // Scene control folder
+        const sceneFolder = this.pane.addFolder({ title: 'Scene Control', expanded: true });
+        const sceneTypeControl = sceneFolder.addBinding(this.navmeshParams, 'sceneType', {
+            options: {
+                'Primitives Only': 'Primitives',
+                'GLTF Only': 'GLTF',
+                'Both Scenes': 'Both'
+            },
+            label: 'Scene Type'
+        });
+        sceneTypeControl.on('change', () => {
+            this.updateSceneVisibility();
+            // Regenerate navmesh with the new scene configuration
+            this.regenerateNavmesh();
+        });
+        // Debug visualization folder
+        const debugFolder = this.pane.addFolder({ title: 'Debug Visualization', expanded: true });
+        const debugToggle = debugFolder.addBinding(this.navmeshParams, 'debugEnabled', {
+            label: 'Show Debug Mesh'
+        });
+        debugToggle.on('change', () => {
+            this.toggleDebugVisualization();
+        });
+        console.log('Tweakpane UI created successfully');
+    }
+    /**
+     * Regenerate navmesh with current parameters
+     */
+    async regenerateNavmesh() {
+        console.log('Regenerating navmesh with updated parameters...');
+        // Clear existing debug visualization
+        this.clearDebugVisualization();
+        // Generate new navmesh
+        await this.generateNavmesh();
+    }
+    /**
+     * Export the current navmesh to a binary file
+     */
+    async exportNavmesh() {
+        this.updateStatus('Exporting navmesh to binary file...');
+        const navigationServer = this.world.getNavigationServer();
+        if (!navigationServer) {
+            this.updateStatus('❌ Navigation server not available');
+            return;
+        }
+        if (!navigationServer.isReady()) {
+            this.updateStatus('❌ No navmesh to export - generate first');
+            return;
+        }
+        try {
+            // Create a dummy scene path for the demo (in a real game this would be the actual scene path)
+            const demoScenePath = ENGINE.AssetPath.fromString('@project/assets/scenes/navmesh-demo.genesys-scene');
+            const result = await this.exportNavigationMesh(demoScenePath);
+            if (result.success && result.data && result.filename) {
+                // Download the NavMesh file directly to user's computer
+                const blob = new Blob([result.data], { type: 'application/octet-stream' });
+                this.downloadBlob(blob, result.filename);
+                this.updateStatus(`✅ NavMesh exported as ${result.filename}`);
+                console.log(`✅ NavMesh exported successfully as ${result.filename}`);
+            }
+            else {
+                this.updateStatus('❌ Export failed');
+                console.error('❌ Failed to export navmesh');
+            }
+        }
+        catch (error) {
+            this.updateStatus(`❌ Export error: ${error}`);
+            console.error('❌ Error during NavMesh export:', error);
+        }
+    }
+    /**
+     * Helper method to download a blob as a file (following lightmapping demo pattern)
+     */
+    downloadBlob(blob, filename) {
+        const url = URL.createObjectURL(blob);
+        const a = document.createElement('a');
+        a.href = url;
+        a.download = filename;
+        a.style.display = 'none';
+        document.body.appendChild(a);
+        a.click();
+        document.body.removeChild(a);
+        URL.revokeObjectURL(url);
+    }
+    /**
+     * Opens a file dialog to select a navmesh file to import
+     */
+    openImportDialog() {
+        // Create file input element for navmesh files
+        const fileInput = document.createElement('input');
+        fileInput.type = 'file';
+        fileInput.accept = '.navmesh';
+        fileInput.multiple = false;
+        fileInput.style.display = 'none';
+        // Handle file selection
+        fileInput.addEventListener('change', (event) => {
+            const target = event.target;
+            const file = target.files?.[0];
+            if (file) {
+                this.importNavmeshFromFile(file);
+            }
+            // Clean up
+            document.body.removeChild(fileInput);
+        });
+        // Add to DOM and trigger click
+        document.body.appendChild(fileInput);
+        fileInput.click();
+    }
+    /**
+     * Import a navmesh from a selected file
+     */
+    async importNavmeshFromFile(file) {
+        try {
+            this.updateStatus('📂 Loading navmesh file...');
+            // Read the NavMesh binary file
+            const fileData = await file.arrayBuffer();
+            this.updateStatus('📥 Importing navmesh data...');
+            // Import using the new API - can import from data directly
+            const success = await this.importNavigationMesh(fileData);
+            if (success) {
+                this.updateStatus(`✅ NavMesh imported from ${file.name}`);
+                console.log(`✅ NavMesh imported successfully from ${file.name}`);
+                // Clear and recreate debug visualization if enabled
+                if (this.navmeshParams.debugEnabled) {
+                    this.clearDebugVisualization();
+                    this.toggleDebugVisualization();
+                }
+            }
+            else {
+                this.updateStatus('❌ Import failed - check console for details');
+                console.error('❌ Failed to import NavMesh');
+            }
+        }
+        catch (error) {
+            this.updateStatus(`❌ Import error: ${error}`);
+            console.error('❌ Import failed:', error);
+        }
+    }
+    /**
+     * Sets a NavMesh resource reference in the current scene using the new metadata system
+     */
+    setNavMeshReferenceInScene() {
+        this.updateStatus('Setting NavMesh reference in scene metadata...');
+        // Set the NavMesh resource reference using the new API
+        const navMeshPath = '@engine/assets/dev/navmesh-demo.navmesh';
+        this.world.setNavMeshResource(navMeshPath);
+        this.updateStatus(`✅ NavMesh reference set: ${navMeshPath}`);
+        console.log(`✅ NavMesh resource reference set in scene: ${navMeshPath}`);
+        console.log('Scene resources:', this.world.getSceneResources());
+    }
+    /**
+     * Exports the current scene with NavMesh resource metadata
+     */
+    exportSceneWithNavMeshReference() {
+        this.updateStatus('Exporting scene with NavMesh resource metadata...');
+        try {
+            // Ensure we have a NavMesh reference set
+            if (!this.world.getSceneResources()?.navMesh) {
+                this.setNavMeshReferenceInScene();
+            }
+            // Export the current world/scene
+            const context = new ENGINE.WorldSerializationContext();
+            const sceneData = this.world.export(context, false);
+            // Convert to JSON string with nice formatting
+            const sceneJson = JSON.stringify(sceneData, null, 2);
+            // Create and download the scene file
+            const blob = new Blob([sceneJson], { type: 'application/json' });
+            this.downloadBlob(blob, 'navmesh-demo-with-metadata.genesys-scene');
+            this.updateStatus('✅ Scene exported with NavMesh resource metadata');
+            console.log('✅ Scene exported with resource metadata:', sceneData.resources);
+            // Log what the new system does differently
+            console.log('🆕 NEW SYSTEM FEATURES:');
+            console.log('- Scene file explicitly references NavMesh file path');
+            console.log('- No more fragile path manipulation');
+            console.log('- External tools can set resource references');
+            console.log('- Engine loads resources from explicit paths');
+            console.log('Resource metadata in scene:', sceneData.resources);
+        }
+        catch (error) {
+            this.updateStatus(`❌ Scene export error: ${error}`);
+            console.error('❌ Error during scene export:', error);
+        }
+    }
+    /**
+     * Updates the status display in the UI
+     */
+    updateStatus(message) {
+        const statusElement = this.statusElement;
+        if (statusElement) {
+            statusElement.innerHTML = `Status: ${message}`;
+        }
+    }
+    /**
+     * Toggle debug visualization on/off
+     */
+    toggleDebugVisualization() {
+        const navigationServer = this.world.getNavigationServer();
+        if (!navigationServer)
+            return;
+        if (this.navmeshParams.debugEnabled) {
+            // Show debug visualization
+            const debugVisualization = navigationServer.createDebugVisualization();
+            if (debugVisualization) {
+                debugVisualization.traverse((child) => {
+                    child.raycast = () => { };
+                });
+                debugVisualization.name = 'NavmeshDebugVisualization';
+                this.world.scene.add(debugVisualization);
+                console.log('Debug visualization enabled');
+            }
+        }
+        else {
+            // Hide debug visualization
+            this.clearDebugVisualization();
+            console.log('Debug visualization disabled');
+        }
+    }
+    /**
+     * Clear existing debug visualization
+     */
+    clearDebugVisualization() {
+        const existingDebug = this.world.scene.getObjectByName('NavmeshDebugVisualization');
+        if (existingDebug) {
+            this.world.scene.remove(existingDebug);
+        }
+    }
+    /**
+     * Clean up resources when demo is destroyed
+     */
+    destroy() {
+        // Clean up debug visualization
+        this.clearDebugVisualization();
+        // Clean up Tweakpane
+        if (this.pane) {
+            this.pane.dispose();
+        }
+        super.destroy();
+    }
+}
+// Export the demo for use
+export default NavmeshPrimitivesDemo;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"navmesh-primitives-demo.js","sourceRoot":"","sources":["../../games/navmesh-primitives-demo.ts"],"names":[],"mappings":"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"}