@skewedaspect/sage 0.3.0

package/src/classes/loggers/consoleBackend.ts

@@ -0,0 +1,135 @@
+//----------------------------------------------------------------------------------------------------------------------
+// Console Logger Backend
+//----------------------------------------------------------------------------------------------------------------------
+
+import type { LogLevel, LoggingBackend } from '../../interfaces/logger.ts';
+
+//----------------------------------------------------------------------------------------------------------------------
+
+type ColorLevel = LogLevel | 'timer';
+
+/**
+ * A logging backend that logs to the console.
+ */
+export class ConsoleBackend implements LoggingBackend
+{
+    private timers : Map<string, number>;
+
+    constructor()
+    {
+        this.timers = new Map();
+    }
+
+    /**
+     * Get the CSS style for a specific log level
+     */
+    private getStyleForLevel(level : ColorLevel) : string
+    {
+        // CSS styles for browser console
+        const styles : Record<ColorLevel, string> = {
+            trace: 'color: #999999', // Dim gray
+            debug: 'color: #00AAAA', // Cyan
+            info: 'color: #00AA00', // Green
+            warn: 'color: #AAAA00', // Yellow
+            error: 'color: #AA0000', // Red
+            timer: 'color: #AA00AA', // Magenta
+            none: 'color: inherit', // Default
+        };
+
+        return styles[level] || styles.none;
+    }
+
+    /**
+     * Format a log message with category, timestamp and log level
+     */
+    private formatMessage(category : string, level : ColorLevel) : [string, string, string, string]
+    {
+        // Format time as HH:MM:SS AM/PM
+        const now = new Date();
+        const hours = now.getHours() % 12 || 12; // Convert 0 to 12 for 12 AM
+        const minutes = now.getMinutes().toString()
+            .padStart(2, '0');
+        const seconds = now.getSeconds().toString()
+            .padStart(2, '0');
+        const ampm = now.getHours() >= 12 ? 'PM' : 'AM';
+        const timestamp = `[${ hours }:${ minutes }:${ seconds } ${ ampm }]`;
+
+        const upperLevel = level.toUpperCase();
+
+        // Return format strings and styling that will be used with console methods
+        return [
+            `${ timestamp } %c${ upperLevel }%c (${ category }): `, // Format string with placeholders
+            this.getStyleForLevel(level), // Level style
+            '', // Default style
+            '', // Reset style
+        ];
+    }
+
+    trace(category : string, message : string, ...args : any[]) : void
+    {
+        const [ format, defaultStyle, levelStyle, resetStyle ] = this.formatMessage(category, 'trace');
+        console.debug(format, defaultStyle, levelStyle, resetStyle, message, ...args);
+    }
+
+    debug(category : string, message : string, ...args : any[]) : void
+    {
+        const [ format, defaultStyle, levelStyle, resetStyle ] = this.formatMessage(category, 'debug');
+        console.debug(format, defaultStyle, levelStyle, resetStyle, message, ...args);
+    }
+
+    info(category : string, message : string, ...args : any[]) : void
+    {
+        const [ format, defaultStyle, levelStyle, resetStyle ] = this.formatMessage(category, 'info');
+        console.info(format, defaultStyle, levelStyle, resetStyle, message, ...args);
+    }
+
+    warn(category : string, message : string, ...args : any[]) : void
+    {
+        const [ format, defaultStyle, levelStyle, resetStyle ] = this.formatMessage(category, 'warn');
+        console.warn(format, defaultStyle, levelStyle, resetStyle, message, ...args);
+    }
+
+    error(category : string, message : string, ...args : any[]) : void
+    {
+        const [ format, defaultStyle, levelStyle, resetStyle ] = this.formatMessage(category, 'error');
+        console.error(format, defaultStyle, levelStyle, resetStyle, message, ...args);
+    }
+
+    /**
+     * Start a timer with the specified label.
+     */
+    time(category : string, label : string) : void
+    {
+        const timerKey = `${ category }:${ label }`;
+        this.timers.set(timerKey, performance.now());
+    }
+
+    /**
+     * End a timer and log the elapsed time.
+     */
+    timeEnd(category : string, label : string) : void
+    {
+        const timerKey = `${ category }:${ label }`;
+        const startTime = this.timers.get(timerKey);
+
+        if(startTime !== undefined)
+        {
+            const duration = performance.now() - startTime;
+            this.timers.delete(timerKey);
+
+            const [ format, defaultStyle, levelStyle, resetStyle ] = this.formatMessage(category, 'timer');
+            console.info(
+                `${ format } Timer '${ label }' completed in ${ duration.toFixed(2) }ms`,
+                defaultStyle,
+                levelStyle,
+                resetStyle
+            );
+        }
+        else
+        {
+            console.warn(`[${ category }]: Timer '${ label }' does not exist`);
+        }
+    }
+}
+
+//----------------------------------------------------------------------------------------------------------------------

package/src/classes/loggers/nullBackend.ts

@@ -0,0 +1,51 @@
+//----------------------------------------------------------------------------------------------------------------------
+// Null Logger Backend
+//----------------------------------------------------------------------------------------------------------------------
+
+import type { LoggingBackend } from '../../interfaces/logger.ts';
+
+//----------------------------------------------------------------------------------------------------------------------
+
+/**
+ * A logging backend that does nothing (discards all logs).
+ * Useful for production environments or when you want to completely disable logging.
+ */
+export class NullBackend implements LoggingBackend
+{
+    trace(_category : string, _message : string, ..._args : any[]) : void
+    {
+        // Do nothing
+    }
+
+    debug(_category : string, _message : string, ..._args : any[]) : void
+    {
+        // Do nothing
+    }
+
+    info(_category : string, _message : string, ..._args : any[]) : void
+    {
+        // Do nothing
+    }
+
+    warn(_category : string, _message : string, ..._args : any[]) : void
+    {
+        // Do nothing
+    }
+
+    error(_category : string, _message : string, ..._args : any[]) : void
+    {
+        // Do nothing
+    }
+
+    time(_category : string, _label : string) : void
+    {
+        // Do nothing
+    }
+
+    timeEnd(_category : string, _label : string) : void
+    {
+        // Do nothing
+    }
+}
+
+//----------------------------------------------------------------------------------------------------------------------

package/src/engines/scene.ts

@@ -0,0 +1,112 @@
+//----------------------------------------------------------------------------------------------------------------------
+// Scene Engine
+//----------------------------------------------------------------------------------------------------------------------
+
+import {
+    AbstractEngine,
+    FreeCamera,
+    HavokPlugin,
+    HemisphericLight,
+    MeshBuilder,
+    PhysicsAggregate,
+    PhysicsShapeType,
+    Scene,
+    Vector3,
+} from '@babylonjs/core';
+import type { GameCanvas } from '../interfaces/game.ts';
+import type { LoggerInterface } from '../interfaces/logger.ts';
+import { type LoggingUtility, SAGELogger } from '../utils/logger.ts';
+
+//----------------------------------------------------------------------------------------------------------------------
+
+export class SceneEngine
+{
+    private _engine : AbstractEngine;
+    private _physics : HavokPlugin;
+    private _log : LoggerInterface;
+
+    constructor(engine : AbstractEngine, physics : HavokPlugin, logger ?: LoggingUtility)
+    {
+        this._engine = engine;
+        this._physics = physics;
+        this._log = logger?.getLogger('SceneEngine') || new SAGELogger('SceneEngine');
+    }
+
+    private async _buildDemoScene(scene : Scene, canvas : GameCanvas) : Promise<void>
+    {
+        this._log.debug('Building demo scene...');
+
+        // This creates and positions a free camera (non-mesh)
+        this._log.trace('Creating camera...');
+        const camera = new FreeCamera('camera1', new Vector3(0, 5, -10), scene);
+
+        // This targets the camera to scene origin
+        camera.setTarget(Vector3.Zero());
+
+        // This attaches the camera to the canvas
+        camera.attachControl(canvas, true);
+
+        // This creates a light, aiming 0,1,0 - to the sky (non-mesh)
+        this._log.trace('Creating light...');
+        const light = new HemisphericLight('light', new Vector3(0, 1, 0), scene);
+
+        // Default intensity is 1. Let's dim the light a small amount
+        light.intensity = 0.7;
+
+        // Our built-in 'sphere' shape.
+        this._log.trace('Creating sphere...');
+        const sphere = MeshBuilder.CreateSphere('sphere', { diameter: 2, segments: 32 }, scene);
+
+        // Move the sphere upward at 4 units
+        sphere.position.y = 4;
+
+        // Our built-in 'ground' shape.
+        this._log.trace('Creating ground...');
+        const ground = MeshBuilder.CreateGround('ground', { width: 10, height: 10 }, scene);
+
+        // Create a sphere shape and the associated body. Size will be determined automatically.
+        this._log.trace('Adding physics to sphere...');
+        // @ts-expect-error Need these, or they don't show up in the scene.
+        // eslint-disable-next-line @typescript-eslint/no-unused-vars
+        const sphereAggregate = new PhysicsAggregate(
+            sphere,
+            PhysicsShapeType.SPHERE,
+            { mass: 1, restitution: 0.75 },
+            scene
+        );
+
+        // Create a static box shape.
+        this._log.trace('Adding physics to ground...');
+        // @ts-expect-error Need these, or they don't show up in the scene.
+        // eslint-disable-next-line @typescript-eslint/no-unused-vars
+        const groundAggregate = new PhysicsAggregate(ground, PhysicsShapeType.BOX, { mass: 0 }, scene);
+
+        this._log.debug('Demo scene built successfully');
+    }
+
+    // TODO: This needs more logic to handle different scenes
+    async loadScene(canvas : GameCanvas) : Promise<Scene>
+    {
+        this._log.info('Loading scene...');
+        this._log.time('sceneLoad');
+
+        // Create a new scene
+        this._log.debug('Creating new scene...');
+        const scene = new Scene(this._engine);
+
+        // TODO: Some scenes may not need physics, or may need different gravity settings
+        // Initialize the scene with physics
+        this._log.debug('Enabling physics with gravity (0, -9.8, 0)...');
+        scene.enablePhysics(new Vector3(0, -9.8, 0), this._physics);
+
+        // TODO: Need to set up a real scene...
+        await this._buildDemoScene(scene, canvas);
+
+        this._log.timeEnd('sceneLoad');
+        this._log.info('Scene loaded successfully');
+
+        return scene;
+    }
+}
+
+//----------------------------------------------------------------------------------------------------------------------