@directivegames/genesys.js 3.1.24

package/dist/src/game/GameLoop.js

@@ -0,0 +1,545 @@
+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);
+};
+/**
+ * BaseGameLoop drives the frame update cycle and manages the active World.
+ *
+ * Detailed explanation:
+ * - Encapsulates requestAnimationFrame handling, delta time calculation and performance stats collection.
+ * - Constructs a World instance with rendering, physics and navigation options and exposes hooks for subclasses.
+ * - Coordinates the lifecycle by calling beginPlay, ticking the world and destroying resources when finished.
+ *
+ * Recommended usage (for humans and AI assistants):
+ * - Extend this class to customize world configuration or implement preStart/postStart behaviors.
+ * - Toggle input processing with setInputEnabled when pausing or showing menus.
+ * - Keep per-frame logic minimal and let World and components handle detailed simulation work.
+ */
+import Stats from 'stats.js';
+import * as THREE from 'three';
+import { Pawn } from '../actors/Pawn.js';
+import { PlayerController } from '../actors/PlayerController.js';
+import { CharacterMovementType } from '../components/movement/CharacterMovementComponent.js';
+import { ENABLE_LIGHTMAPS } from '../const.js';
+import { NavigationEngine } from '../navigation/NavigationServer.js';
+import { RecastNavigationServer } from '../navigation/RecastNavigationServer.js';
+import { PhysicsEngine } from '../physics/PhysicsEngine.js';
+import { Renderer } from '../render/Renderer.js';
+import { projectInfo } from '../storage/projectContext.js';
+import { AssetPath } from '../storage/storageProvider.js';
+import { ConsoleCommand } from '../systems/ConsoleManager.js';
+import { WorldSerializer } from '../systems/WorldSerialization.js';
+import { WorldSerializationContext } from '../systems/WorldSerialization.js';
+import { resourceManager } from '../utils/ResourceManager.js';
+import { ResourceType } from '../utils/ResourceManager.js';
+import { createVRButton } from '../utils/VRButtonUtils.js';
+import { GameBuilder } from './GameBuilder.js';
+import { World } from './World.js';
+/**
+ * Game loop life cycles
+ * await loadWorldData
+ * start
+ *    createPhysicsEngine
+ *    preStart
+ *    postStart
+ *    world.beginPlay
+ *    tick
+ * destroy
+ *    world.destroy
+ *    renderer.destroy
+ *
+ */
+export class BaseGameLoop {
+    static get DEFAULT_OPTIONS() {
+        return {
+            backgroundColor: 0x87CEEB,
+            gravity: new THREE.Vector3(0, -9.81, 0),
+            xrEnabled: false,
+        };
+    }
+    //====================================================================================================
+    constructor(container, options = {}) {
+        Object.defineProperty(this, "container", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: container
+        });
+        /** Reference to the game world containing all actors and components */
+        Object.defineProperty(this, "world", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        /** Performance monitoring stats display */
+        Object.defineProperty(this, "stats", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new Stats()
+        });
+        /** Timestamp of the previous frame for delta time calculation */
+        Object.defineProperty(this, "lastTickTimeMS", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 0
+        });
+        Object.defineProperty(this, "renderer", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "destroyed", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: false
+        });
+        Object.defineProperty(this, "options", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "vrButton", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: null
+        });
+        Object.defineProperty(this, "actorsFromWorldData", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: []
+        });
+        Object.defineProperty(this, "loadingScreen", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: null
+        });
+        // clear the cached resources to avoid loading stale resources
+        resourceManager.clearCachedResources();
+        // Merge provided options with defaults
+        this.options = { ...BaseGameLoop.DEFAULT_OPTIONS, ...options };
+        this.container.style.position = 'relative';
+        const rendererOptions = {
+            ...this.getDefaultRendererOptions(),
+            ...this.options.rendererOptions
+        };
+        this.renderer = new Renderer(this.container, rendererOptions);
+        // Configure and add the performance stats display
+        this.stats.dom.style.position = 'absolute';
+        this.stats.dom.style.top = '10px';
+        this.stats.dom.style.left = '10px';
+        this.container.appendChild(this.stats.dom);
+        this.stats.showPanel(0);
+        this.world = new World({
+            ...this.getWorldConfiguration(),
+            gameId: this.options.gameId,
+            gameLoop: new WeakRef(this)
+        });
+        // Set up XR if enabled in options
+        if (this.options.xrEnabled) {
+            this.renderer.enableXR();
+            // Set framebuffer scale factor if specified
+            if (this.options.vrSessionOptions?.framebufferScaleFactor !== undefined) {
+                this.renderer.renderer.xr.setFramebufferScaleFactor(this.options.vrSessionOptions.framebufferScaleFactor);
+                console.log('🎯 XR framebuffer scale factor set to:', this.options.vrSessionOptions.framebufferScaleFactor);
+            }
+        }
+        this.world.consoleManager.addCommandHandler(this);
+    }
+    /**
+     * Get the world configuration. Override this to change the world configuration in your child class.
+     * @returns The world configuration.
+     */
+    getWorldConfiguration() {
+        return {
+            rendererDomElement: this.renderer.renderer.domElement,
+            gameContainer: this.container,
+            backgroundColor: this.options.backgroundColor,
+            physicsOptions: {
+                gravity: this.options.gravity,
+                engine: PhysicsEngine.Rapier
+            },
+            navigationOptions: {
+                engine: NavigationEngine.RecastNavigation,
+                debug: false,
+                options: RecastNavigationServer.DEFAULT_OPTIONS,
+                generateOnStartUp: false
+            },
+            useManifold: false,
+            enableGamepad: true
+        };
+    }
+    getDefaultRendererOptions() {
+        return {
+            powerPreference: 'high-performance',
+            antialias: this.options.xrEnabled, // antialias is set here for XR only as it does not support postprocessing
+        };
+    }
+    async start() {
+        // create the physics engine before calling preStart in case the user code replies on it.
+        this.startLoadingScreen();
+        await this.world.createPhysicsEngine();
+        console.log('[GameLoop] waiting for resources (1)...');
+        await resourceManager.waitForResources(ResourceType.All);
+        console.log('[GameLoop] loading scene resources...');
+        await this.loadSceneResources(this.world);
+        console.log('[GameLoop] calling preStart...');
+        await this.preStart();
+        await this.world.createNavigationServer();
+        await this.world.createManifold();
+        await this.world.createLightmapManager(this.renderer.renderer);
+        if (this.world.options.navigationOptions.generateOnStartUp) {
+            await this.world.createNavigationMeshFromScene();
+        }
+        console.log('[GameLoop] calling postStart...');
+        this.postStart();
+        // Auto-create VR button if XR is enabled
+        if (this.options.xrEnabled) {
+            this.createVRButton().catch(error => {
+                console.warn('[GameLoop] failed to create VR button:', error);
+            });
+        }
+        console.log('[GameLoop] calling world.beginPlay...');
+        this.world.beginPlay();
+        // Local function to be used as animation loop callback
+        const tickCallback = (currentTimeMS) => {
+            if (this.destroyed) {
+                return;
+            }
+            if (!this.options.xrEnabled) {
+                // For XR, this is handled by three.js itself using WebGlRenderer.setAnimationLoop
+                requestAnimationFrame(tickCallback);
+            }
+            this.stats.begin();
+            // Initialize lastTime on first frame to prevent large initial deltaTime
+            if (!this.lastTickTimeMS) {
+                this.lastTickTimeMS = currentTimeMS;
+                this.stats.end();
+                return;
+            }
+            const deltaTimeMS = currentTimeMS - this.lastTickTimeMS;
+            this.lastTickTimeMS = currentTimeMS;
+            this.tick({ currentTimeMS, deltaTimeMS });
+            this.stats.end();
+        };
+        // Always use WebGL renderer's setAnimationLoop when XR is enabled
+        // This is required by Three.js for proper VR support
+        if (this.options.xrEnabled) {
+            this.renderer.setupXRAnimationLoop(tickCallback);
+        }
+        else {
+            requestAnimationFrame(tickCallback);
+        }
+        console.log('[GameLoop] waiting for resources (2)...');
+        await resourceManager.waitForResources(ResourceType.All);
+        console.log('[GameLoop] resources loaded');
+        this.stopLoadingScreen();
+    }
+    destroy() {
+        this.actorsFromWorldData = [];
+        this.world.destroy();
+        this.renderer.destroy();
+        this.stats.dom.remove();
+        // Clean up VR button if it exists
+        if (this.vrButton) {
+            this.vrButton.remove();
+            this.vrButton = null;
+        }
+        this.destroyed = true;
+    }
+    /**
+     * Enables or disables input processing for the game
+     * @param enabled - When true, input events will be processed; when false, all input events are ignored
+     */
+    setInputEnabled(enabled) {
+        this.world.inputManager.setInputEnabled(enabled);
+    }
+    /**
+     * Loads world data into the game loop
+     * @param worldData - The world data to load
+     */
+    async loadWorldData(worldData) {
+        // remove actors from the old world before loading the new one
+        console.log(`[GameLoop] removing ${this.actorsFromWorldData.length} actors before loading the new world`);
+        this.startLoadingScreen();
+        this.world.removeActors(...this.actorsFromWorldData);
+        this.actorsFromWorldData = [];
+        const actorsBeforeLoadingWorldData = this.world.getActors();
+        await WorldSerializer.loadWorld(this.world, worldData);
+        const actorsAfterLoadingWorldData = this.world.getActors();
+        this.actorsFromWorldData = actorsAfterLoadingWorldData.filter(actor => !actorsBeforeLoadingWorldData.includes(actor));
+    }
+    /**
+     * Loads world data from a url
+     * @param url - The url to load the world data from
+     */
+    async loadWorldDataFromPath(path) {
+        console.log(`[GameLoop] loading world data from ${path}`);
+        const worldData = await resourceManager.loadJsonObject(path);
+        console.log(`[GameLoop] world data loaded from ${path}, loading...`);
+        // Load the world data
+        await this.loadWorldData(worldData);
+    }
+    /**
+     * Loads scene resources (lightmaps and NavMesh) based on scene metadata.
+     */
+    async loadSceneResources(world) {
+        const resources = world.sceneResources;
+        if (!resources) {
+            console.log('[GameLoop] No scene resources configured, skipping automatic loading');
+            return;
+        }
+        // Load lightmaps if configured
+        if (resources.lightmap) {
+            await this.loadLightmapFromPaths(resources.lightmap.metadataPath, resources.lightmap.texturePath);
+        }
+        // Load NavMesh if configured
+        if (resources.navMesh) {
+            await this.loadNavMeshFromPath(resources.navMesh.path);
+        }
+    }
+    /**
+     * Loads lightmaps from explicit file paths.
+     */
+    async loadLightmapFromPaths(metadataPath, texturePath) {
+        if (!ENABLE_LIGHTMAPS) {
+            return;
+        }
+        try {
+            const provider = projectInfo.storageProvider;
+            const lightmapMetadataPath = new AssetPath(metadataPath);
+            const lightmapTexturePath = new AssetPath(texturePath);
+            // Load lightmap files
+            const lightmapData = await provider.downloadFileAsJson(lightmapMetadataPath);
+            const textureData = await provider.downloadFileAsBuffer(lightmapTexturePath);
+            // Apply lightmaps if the world has a lightmap manager
+            const lightmapManager = this.world.getLightmapManager();
+            if (lightmapManager) {
+                await lightmapManager.importLightmap(lightmapData, textureData, { throwOnError: false });
+                console.log(`[GameLoop] ✓ Lightmaps loaded from: ${metadataPath}`);
+            }
+        }
+        catch (error) {
+            console.warn(`[GameLoop] ⚠️ Could not load lightmaps from: ${metadataPath}`, error);
+        }
+    }
+    /**
+     * Loads NavMesh from an explicit file path.
+     */
+    async loadNavMeshFromPath(navMeshPath) {
+        try {
+            const assetPath = new AssetPath(navMeshPath);
+            const provider = projectInfo.storageProvider;
+            // Load NavMesh data directly
+            const navMeshBuffer = await provider.downloadFileAsBuffer(assetPath);
+            const navigationServer = this.world.getNavigationServer();
+            if (navigationServer) {
+                const success = await navigationServer.importNavigationMeshFromData(navMeshBuffer);
+                if (success) {
+                    console.log(`[GameLoop] ✓ NavMesh loaded from: ${navMeshPath}`);
+                    return;
+                }
+            }
+        }
+        catch (error) {
+            console.warn(`[GameLoop] ⚠️ Could not load NavMesh from: ${navMeshPath}`, error);
+        }
+        // Fallback: Generate NavMesh from scene geometry if auto-generation is enabled
+        const navigationOptions = this.world.options.navigationOptions;
+        if (navigationOptions.generateOnStartUp) {
+            try {
+                console.log('[GameLoop] 🔄 Falling back to auto-generation of NavMesh');
+                await this.world.createNavigationMeshFromScene();
+                console.log('[GameLoop] ✓ NavMesh auto-generated from scene geometry');
+            }
+            catch (error) {
+                console.error('[GameLoop] ✗ Failed to auto-generate NavMesh', error);
+            }
+        }
+        else {
+            console.log('[GameLoop] ℹ️ NavMesh auto-generation disabled');
+        }
+    }
+    /**
+     * Gets the world
+     * @returns The world
+     */
+    getWorld() {
+        return this.world;
+    }
+    /**
+     * Enables XR mode for this game loop (runtime)
+     */
+    enableXR() {
+        this.options.xrEnabled = true;
+        this.renderer.enableXR();
+        // Note: Animation loop setup happens in start() method
+    }
+    /**
+     * Disables XR mode for this game loop (runtime)
+     */
+    disableXR() {
+        this.options.xrEnabled = false;
+        this.renderer.disableXR();
+    }
+    /**
+     * Creates a VR button for entering VR mode
+     * @returns Promise that resolves to the VR button element
+     */
+    async createVRButton() {
+        try {
+            // Clean up existing VR button if any
+            if (this.vrButton) {
+                this.vrButton.remove();
+                this.vrButton = null;
+            }
+            // Use utility function with configurable features
+            this.vrButton = await createVRButton(this.renderer.renderer, this.container, this.options.vrSessionOptions ?? {});
+            return this.vrButton;
+        }
+        catch (error) {
+            console.error('[GameLoop] failed to load VRButton:', error);
+            return Promise.reject(error);
+        }
+    }
+    /**
+     * Checks if XR is enabled
+     */
+    isXREnabled() {
+        return this.renderer.isXREnabled();
+    }
+    /**
+     * Checks if currently presenting in XR
+     */
+    isXRPresenting() {
+        return this.renderer.isXRPresenting();
+    }
+    /**
+     * Export the current navigation mesh to a file.
+     * @param scenePath The scene path to use for filename generation
+     * @returns Promise resolving to export result with data and filename
+     */
+    async exportNavigationMesh(scenePath) {
+        return await this.world.exportNavigationMesh(scenePath);
+    }
+    /**
+     * Import a navigation mesh from data or from the configured path in scene resources.
+     * @param navMeshData Optional NavMesh data to import directly
+     * @returns Promise resolving to success/failure
+     */
+    async importNavigationMesh(navMeshData) {
+        if (navMeshData) {
+            // Import from provided data
+            const navigationServer = this.world.getNavigationServer();
+            if (navigationServer) {
+                return await navigationServer.importNavigationMeshFromData(navMeshData);
+            }
+            return false;
+        }
+        // Import from scene resources configuration
+        const navMeshPath = this.world.sceneResources?.navMesh?.path;
+        if (navMeshPath) {
+            await this.loadNavMeshFromPath(navMeshPath);
+            return true;
+        }
+        console.error('[GameLoop] importNavigationMesh: No NavMesh data provided and no navMesh configured in scene resources');
+        return false;
+    }
+    startLoadingScreen(customLoadingScreen = null) {
+        if (!this.loadingScreen) {
+            this.loadingScreen = customLoadingScreen ?? this.createLoadingScreen();
+            if (this.loadingScreen) {
+                console.trace('[GameLoop] starting loading screen');
+                this.loadingScreen.start(this.world);
+            }
+        }
+    }
+    stopLoadingScreen() {
+        if (this.loadingScreen) {
+            console.trace('[GameLoop] stopping loading screen');
+            this.loadingScreen.stop();
+            this.loadingScreen = null;
+        }
+    }
+    //====================================================================================================
+    /**
+     * Pre-start initialization
+     */
+    async preStart() {
+        GameBuilder.createDefaultLighting(this.world);
+        GameBuilder.createDefaultPawnWithPhysics(this.world, CharacterMovementType.ThirdPerson);
+        GameBuilder.createDefaultGround(this.world);
+        GameBuilder.createDefaultSkybox(this.world);
+    }
+    postStart() {
+    }
+    createLoadingScreen() {
+        return null;
+    }
+    /**
+       * The main game loop function that runs once per frame
+       * Manages timing, updates the world state, and renders the scene
+       * @param tickTime - The current timestamp from requestAnimationFrame and the delta time since the last frame
+       */
+    tick(tickTime) {
+        // tick and render the world
+        this.world.tick(tickTime.deltaTimeMS / 1000);
+        this.renderer.render(this.world);
+    }
+    loadWorld(path) {
+        this.loadWorldDataFromPath(AssetPath.fromString(path));
+        return true;
+    }
+    reload() {
+        const worldData = new WorldSerializationContext().exportObject(this.world, false);
+        const worldDataString = JSON.stringify(worldData);
+        this.world.clearWorld();
+        WorldSerializer.loadWorld(this.world, JSON.parse(worldDataString)).then(() => {
+            // this is a hack as currently there's no way to restore the camera
+            const controller = this.world.getFirstActor(PlayerController);
+            const pawn = this.world.getFirstActor(Pawn);
+            if (controller && pawn) {
+                controller.possess(pawn);
+            }
+            console.dir(worldData);
+        });
+        return true;
+    }
+}
+__decorate([
+    ConsoleCommand('loadworld', 'Load world from file path (usage: loadworld <path>)'),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String]),
+    __metadata("design:returntype", Boolean)
+], BaseGameLoop.prototype, "loadWorld", null);
+__decorate([
+    ConsoleCommand('reload', 'Reload the current world'),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", Boolean)
+], BaseGameLoop.prototype, "reload", null);
+/**
+ * A dummy game loop that does nothing
+ */
+export class DummyGameLoop {
+    async loadWorldData(worldData) { return Promise.resolve(); }
+    async loadWorldDataFromPath(path) { return Promise.resolve(); }
+    start() { return Promise.resolve(); }
+    destroy() { }
+    setInputEnabled(enabled) { }
+    getWorld() { return null; }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"GameLoop.js","sourceRoot":"","sources":["../../../src/game/GameLoop.ts"],"names":[],"mappings":"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"}

package/dist/src/game/GameMode.d.ts

@@ -0,0 +1,58 @@
+import { PlayerStart } from '../actors/PlayerStart.js';
+import { ISerializableObjectTag } from '../utils/serialization/serializable.js';
+import { Playable } from './Playable.js';
+import type { World } from './World.js';
+import type { PlayerController } from '../actors/PlayerController.js';
+import type { ISerializable, SerializedObject, WorldSerializationContext } from '../systems/WorldSerialization.js';
+import type { ISceneGraphDebugNodeGenerator, SceneGraphDebugNode } from '../utils/SceneGraphUtils.js';
+import type { Dumper, Loader } from '../utils/serialization/serializer.js';
+export interface GameModeOptions {
+}
+/**
+ * Base class for all game modes.
+ */
+export declare class GameMode<TGameModeOptions extends GameModeOptions = GameModeOptions> extends Playable implements ISerializable, ISceneGraphDebugNodeGenerator {
+    readonly options: TGameModeOptions;
+    readonly [ISerializableObjectTag] = true;
+    readonly name: string;
+    readonly uuid: string;
+    protected world: World | null;
+    constructor(options: TGameModeOptions);
+    /**
+     * Called every frame.
+     * @param deltaTime - The time since the last frame.
+     */
+    tick(deltaTime: number): void;
+    /**
+     * Sets the world for the game mode.
+     * @param world - The world to set.
+     */
+    setWorld(world: World): void;
+    /**
+     * Gets the path name of the game mode.
+     * @returns The path name of the game mode.
+     */
+    getPathName(): string;
+    /**
+     * Finds the player start for the given player controller.
+     * @param playerController - The player controller to find the player start for.
+     * @returns The player start for the given player controller or null if no player start is found.
+     */
+    findPlayerStart(playerController: PlayerController): PlayerStart | null;
+    /**
+     * Generates a debug node for the game mode.
+     * @returns The debug node for the game mode.
+     */
+    generateDebugNode(): SceneGraphDebugNode | null;
+    /**
+     * Exports the game mode.
+     * @param context - The context to export the game mode to.
+     * @param includeDefaults - Whether to include default values.
+     * @returns The exported game mode.
+     */
+    export(context: WorldSerializationContext, includeDefaults: boolean): SerializedObject;
+    serialize(dumper: Dumper): void;
+    deserialize(loader: Loader): void;
+    protected doBeginPlay(): void;
+    protected doEndPlay(): void;
+}