@gg-web-engine/core 0.0.1

package/dist/base/gg-viewport-manager.js

@@ -0,0 +1,125 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GgViewportManager = void 0;
+const rxjs_1 = require("rxjs");
+const gg_viewport_1 = require("./gg-viewport");
+class GgViewportManager {
+    constructor() {
+        this.canvases = {};
+        this.gameStage$ = new rxjs_1.BehaviorSubject(null);
+        this.destroyed = new rxjs_1.Subject();
+        setTimeout(() => __awaiter(this, void 0, void 0, function* () {
+            let retries = 120;
+            let stage = null;
+            while (retries > 0) {
+                retries--;
+                stage = document.getElementById('gg-stage');
+                if (stage) {
+                    break;
+                }
+                yield new Promise(r => setTimeout(r, 250));
+            }
+            if (!stage) {
+                this.gameStage$.error(new Error('Div with id "gg-stage" not found in 30 seconds'));
+            }
+            else {
+                gg_viewport_1.GgViewport.instance
+                    .subscribeOnViewportSize()
+                    .pipe((0, rxjs_1.takeUntil)(this.destroyed))
+                    .subscribe(size => {
+                    for (const zIndex of Object.keys(this.canvases)) {
+                        const canvasDescr = this.canvases[+zIndex];
+                        if (canvasDescr.renderer && !canvasDescr.renderer.rendererOptions.forceRendererSize) {
+                            canvasDescr.renderer.resize(size);
+                        }
+                        canvasDescr.canvas.width = size.x;
+                        canvasDescr.canvas.height = size.y;
+                    }
+                });
+                this.gameStage$.next(stage);
+            }
+        }), 0);
+    }
+    static get instance() {
+        if (!this._instance) {
+            this._instance = new GgViewportManager();
+        }
+        return this._instance;
+    }
+    getStageAsync() {
+        const current = this.gameStage$.getValue();
+        if (current) {
+            return Promise.resolve(current);
+        }
+        return Promise.race([
+            this.gameStage$
+                .pipe((0, rxjs_1.takeUntil)(this.destroyed), (0, rxjs_1.filter)(x => !!x), (0, rxjs_1.first)())
+                .toPromise(),
+            new Promise((resolve, reject) => {
+                setTimeout(() => {
+                    reject('Cannot find div with id "gg-stage" in 30 seconds');
+                }, 30000);
+            }),
+        ]);
+    }
+    createCanvas(zIndex) {
+        return __awaiter(this, void 0, void 0, function* () {
+            zIndex = Math.round(zIndex);
+            if (this.canvases[zIndex]) {
+                throw new Error(`Cannot add canvas on zIndex ${zIndex}. Index is locked by another canvas`);
+            }
+            const stage = yield this.getStageAsync();
+            const canvas = document.createElement('canvas');
+            yield this.registerCanvas(canvas, zIndex);
+            stage.appendChild(canvas);
+            return canvas;
+        });
+    }
+    registerCanvas(canvas, zIndex) {
+        return __awaiter(this, void 0, void 0, function* () {
+            canvas.style.zIndex = '' + zIndex;
+            canvas.style.position = 'absolute';
+            canvas.style.width = '100%';
+            canvas.style.height = '100%';
+            canvas.id = 'canvas-' + zIndex;
+            this.canvases[zIndex] = { canvas };
+            const size = gg_viewport_1.GgViewport.instance.getCurrentViewportSize();
+            canvas.width = size.x;
+            canvas.height = size.y;
+        });
+    }
+    assignRendererToCanvas(renderer, canvas) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!gg_viewport_1.GgViewport.instance.isActive) {
+                gg_viewport_1.GgViewport.instance.activate();
+            }
+            let zIndex = null;
+            let maxExistingZIndex = 0;
+            for (const index in this.canvases) {
+                if (this.canvases[index].canvas === canvas) {
+                    zIndex = +index;
+                    break;
+                }
+                maxExistingZIndex = +index;
+            }
+            if (!zIndex) {
+                zIndex = maxExistingZIndex + 1;
+                yield this.registerCanvas(canvas, zIndex);
+            }
+            this.canvases[zIndex].renderer = renderer;
+            if (!renderer.rendererOptions.forceRendererSize) {
+                renderer.resize(gg_viewport_1.GgViewport.instance.getCurrentViewportSize());
+            }
+        });
+    }
+}
+exports.GgViewportManager = GgViewportManager;

package/dist/base/gg-viewport.d.ts

@@ -0,0 +1,23 @@
+import { Observable, Subject } from 'rxjs';
+import { Point2 } from './models/points';
+export declare class GgViewport {
+    private static _instance;
+    static get instance(): GgViewport;
+    private constructor();
+    protected destroy$: Subject<void> | null;
+    private scenes;
+    get isActive(): boolean;
+    activate(): void;
+    deactivate(): void;
+    private viewportSize;
+    getCurrentViewportSize(): Point2;
+    subscribeOnViewportSize(): Observable<Point2>;
+    private mousePosition;
+    private mouseClicked;
+    private isMouseDown;
+    isMouseEnabled(): boolean;
+    isTouchDevice(): boolean;
+    subscribeOnMouseMove(): Observable<Point2>;
+    subscribeOnIsMouseDown(): Observable<boolean>;
+    subscribeOnMouseClick(): Observable<Point2>;
+}

package/dist/base/gg-viewport.js

@@ -0,0 +1,123 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GgViewport = void 0;
+const rxjs_1 = require("rxjs");
+const operators_1 = require("rxjs/operators");
+const getCurrentWindowSize = () => {
+    return {
+        x: window.innerWidth,
+        y: window.innerHeight,
+    };
+};
+const getMousePositionFromEvent = (event) => {
+    if (event instanceof MouseEvent) {
+        return { x: event.x, y: event.y };
+    }
+    else if (event instanceof TouchEvent) {
+        if (event.touches.length === 0) {
+            return null;
+        }
+        return { x: event.touches[0].clientX, y: event.touches[0].clientY };
+    }
+    console.warn('Cannot determine mouse position from event', event);
+    return null;
+};
+class GgViewport {
+    constructor() {
+        this.destroy$ = null;
+        this.scenes = [];
+        // ================================================== VIEWPORT SIZE ==================================================
+        this.viewportSize = new rxjs_1.BehaviorSubject(getCurrentWindowSize());
+        // ================================================== VIEWPORT SIZE ==================================================
+        // ================================================== POINTER LOGIC ==================================================
+        this.mousePosition = new rxjs_1.BehaviorSubject({ x: 0, y: 0 });
+        this.mouseClicked = new rxjs_1.Subject();
+        this.isMouseDown = new rxjs_1.Subject();
+    }
+    static get instance() {
+        if (!this._instance) {
+            this._instance = new GgViewport();
+        }
+        return this._instance;
+    }
+    get isActive() {
+        return !!this.destroy$;
+    }
+    activate() {
+        if (this.destroy$) {
+            throw new Error('GgViewport is already active');
+        }
+        this.destroy$ = new rxjs_1.Subject();
+        // cursor position
+        (0, rxjs_1.merge)((0, rxjs_1.fromEvent)(window, 'mousemove'), (0, rxjs_1.fromEvent)(window, 'touchstart'), (0, rxjs_1.fromEvent)(window, 'touchmove'))
+            .pipe((0, rxjs_1.takeUntil)(this.destroy$), (0, operators_1.map)(event => event))
+            .subscribe(event => {
+            const point = getMousePositionFromEvent(event);
+            if (point) {
+                this.mousePosition.next(point);
+            }
+        });
+        // clicks
+        (0, rxjs_1.merge)((0, rxjs_1.fromEvent)(window, 'mousedown'), (0, rxjs_1.fromEvent)(window, 'touchstart'))
+            .pipe((0, rxjs_1.takeUntil)(this.destroy$), (0, operators_1.map)(event => event))
+            .subscribe(event => {
+            const point = getMousePositionFromEvent(event);
+            if (point) {
+                this.mousePosition.next(point);
+            }
+            this.isMouseDown.next(true);
+        });
+        (0, rxjs_1.merge)((0, rxjs_1.fromEvent)(window, 'mouseup'), (0, rxjs_1.fromEvent)(window, 'click'), (0, rxjs_1.fromEvent)(window, 'touchend'))
+            .pipe((0, rxjs_1.takeUntil)(this.destroy$), (0, operators_1.map)(event => event))
+            .subscribe(event => {
+            const point = getMousePositionFromEvent(event);
+            if (point) {
+                this.mousePosition.next(point);
+            }
+            this.isMouseDown.next(false);
+            if (event.target['nodeName'] === 'canvas') {
+                this.mouseClicked.next(this.mousePosition.getValue());
+            }
+        });
+        // viewport size
+        (0, rxjs_1.merge)((0, rxjs_1.fromEvent)(window, 'resize'), (0, rxjs_1.fromEvent)(window, 'orientationchange'))
+            .pipe((0, rxjs_1.takeUntil)(this.destroy$), (0, operators_1.map)(() => getCurrentWindowSize()))
+            .subscribe(this.viewportSize);
+    }
+    deactivate() {
+        if (!this.destroy$) {
+            throw new Error('GgViewport is already inactive');
+        }
+        this.destroy$.next();
+        this.destroy$.complete();
+        this.destroy$ = null;
+    }
+    getCurrentViewportSize() {
+        return this.viewportSize.getValue();
+    }
+    subscribeOnViewportSize() {
+        return this.viewportSize.asObservable().pipe((0, rxjs_1.distinctUntilChanged)((v1, v2) => {
+            return v1.x === v2.x && v1.y === v2.y;
+        }));
+    }
+    isMouseEnabled() {
+        return matchMedia('(hover:hover)').matches && matchMedia('(pointer:fine)').matches;
+    }
+    isTouchDevice() {
+        return ('createTouch' in document ||
+            !!navigator.userAgent.match(/(iPhone|iPod|iPad)/) ||
+            !!navigator.userAgent.match(/Android/));
+    }
+    subscribeOnMouseMove() {
+        return this.mousePosition.asObservable().pipe((0, rxjs_1.distinctUntilChanged)((v1, v2) => {
+            return v1.x === v2.x && v1.y === v2.y;
+        }));
+    }
+    subscribeOnIsMouseDown() {
+        return this.isMouseDown.asObservable().pipe((0, rxjs_1.distinctUntilChanged)());
+    }
+    subscribeOnMouseClick() {
+        return this.mouseClicked.asObservable();
+    }
+}
+exports.GgViewport = GgViewport;

package/dist/base/gg-world.d.ts

@@ -0,0 +1,32 @@
+import { GgEntity } from './entities/gg-entity';
+import { ITickListener } from './entities/interfaces/i-tick-listener';
+import { GgPhysicsWorld } from './interfaces/gg-physics-world';
+import { GgVisualScene } from './interfaces/gg-visual-scene';
+import { KeyboardController } from './controllers/keyboard.controller';
+export declare abstract class GgWorld<D, R, V extends GgVisualScene<D, R> = GgVisualScene<D, R>, P extends GgPhysicsWorld<D, R> = GgPhysicsWorld<D, R>> {
+    readonly visualScene: V;
+    readonly physicsWorld: P;
+    protected readonly consoleEnabled: boolean;
+    private readonly animationFrameClock;
+    private readonly worldClock;
+    readonly keyboardController: KeyboardController;
+    readonly children: GgEntity[];
+    protected readonly tickListeners: ITickListener[];
+    constructor(visualScene: V, physicsWorld: P, consoleEnabled?: boolean);
+    init(): Promise<void>;
+    start(): void;
+    pauseWorld(): void;
+    resumeWorld(): void;
+    dispose(): void;
+    addEntity(entity: GgEntity): void;
+    removeEntity(entity: GgEntity, dispose?: boolean): void;
+    protected commands: {
+        [key: string]: {
+            handler: (...args: string[]) => Promise<string>;
+            doc?: string;
+        };
+    };
+    registerConsoleCommand(command: string, handler: (...args: string[]) => Promise<string>, doc?: string): void;
+    runConsoleCommand(command: string, args: string[]): Promise<string>;
+    triggerPhysicsDebugView(): void;
+}

package/dist/base/gg-world.js

@@ -0,0 +1,172 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GgWorld = void 0;
+const clock_1 = require("./clock");
+const i_tick_listener_1 = require("./entities/interfaces/i-tick-listener");
+const gg_static_1 = require("./gg-static");
+const keyboard_controller_1 = require("./controllers/keyboard.controller");
+const rxjs_1 = require("rxjs");
+const gg_console_ui_1 = require("./ui/gg-console.ui");
+const gg_debugger_ui_1 = require("./ui/gg-debugger.ui");
+class GgWorld {
+    constructor(visualScene, physicsWorld, consoleEnabled = false) {
+        this.visualScene = visualScene;
+        this.physicsWorld = physicsWorld;
+        this.consoleEnabled = consoleEnabled;
+        // inner clock, runs constantly
+        this.animationFrameClock = clock_1.Clock.animationFrameClock;
+        // world clock, can be paused/resumed. Stops when disposing world
+        this.worldClock = new clock_1.Clock(this.animationFrameClock.tick$);
+        // TODO consider adding mouse controller
+        this.keyboardController = new keyboard_controller_1.KeyboardController();
+        this.children = [];
+        this.tickListeners = [];
+        this.commands = {};
+        gg_static_1.GgStatic.instance.worlds.push(this);
+        gg_static_1.GgStatic.instance.selectedWorld = this;
+        this.keyboardController.start().then();
+        if (consoleEnabled) {
+            this.keyboardController
+                .bind('Backquote')
+                .pipe((0, rxjs_1.filter)(x => x))
+                .subscribe(() => {
+                // open console UI
+                if (gg_console_ui_1.GgConsoleUI.instance.isUIShown) {
+                    gg_console_ui_1.GgConsoleUI.instance.destroyUI();
+                }
+                else {
+                    gg_console_ui_1.GgConsoleUI.instance.createUI();
+                }
+            });
+            this.registerConsoleCommand('commandslist', () => __awaiter(this, void 0, void 0, function* () {
+                return Object.entries(this.commands)
+                    .map(([key, value]) => `${key}${value.doc ? '\t// ' + value.doc : ''}`)
+                    .sort()
+                    .join('\n\n');
+            }), 'no args; print all available commands');
+            this.registerConsoleCommand('debugger', (...args) => __awaiter(this, void 0, void 0, function* () {
+                const shouldDraw = ['1', 'true', '+'].includes(args[0]);
+                if (shouldDraw != gg_debugger_ui_1.GgDebuggerUI.instance.isUIShown) {
+                    if (gg_debugger_ui_1.GgDebuggerUI.instance.isUIShown) {
+                        gg_debugger_ui_1.GgDebuggerUI.instance.destroyUI();
+                    }
+                    else {
+                        gg_debugger_ui_1.GgDebuggerUI.instance.createUI();
+                    }
+                }
+                return '' + gg_debugger_ui_1.GgDebuggerUI.instance.isUIShown;
+            }), 'args: [0 or 1]; turn on/off debug panel. Default value is 0');
+            this.registerConsoleCommand('ph_timescale', (...args) => __awaiter(this, void 0, void 0, function* () {
+                this.physicsWorld.timeScale = +args[0];
+                return JSON.stringify(this.physicsWorld.timeScale);
+            }), 'args: [float]; change time scale of physics engine. Default value is 1.0');
+            this.registerConsoleCommand('dr_drawphysics', (...args) => __awaiter(this, void 0, void 0, function* () {
+                const shouldDraw = ['1', 'true', '+'].includes(args[0]);
+                if (shouldDraw != this.physicsWorld.physicsDebugViewActive) {
+                    this.triggerPhysicsDebugView();
+                }
+                return '' + this.physicsWorld.physicsDebugViewActive;
+            }), 'args: [0 or 1]; turn on/off physics debug view. Default value is 0');
+        }
+    }
+    init() {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield Promise.all([this.physicsWorld.init(), this.visualScene.init()]);
+            this.worldClock.tick$.subscribe(([elapsed, delta]) => {
+                let physicsTickPerformed = false;
+                for (let i = 0; i < this.tickListeners.length; i++) {
+                    if (!physicsTickPerformed && this.tickListeners[i].tickOrder >= 500) {
+                        this.physicsWorld.simulate(delta);
+                        physicsTickPerformed = true;
+                    }
+                    this.tickListeners[i].tick$.next([elapsed, delta]);
+                }
+                if (!physicsTickPerformed) {
+                    this.physicsWorld.simulate(delta);
+                }
+            });
+        });
+    }
+    start() {
+        this.worldClock.start();
+    }
+    pauseWorld() {
+        this.worldClock.pause();
+    }
+    resumeWorld() {
+        this.worldClock.pause();
+    }
+    dispose() {
+        this.worldClock.stop();
+        for (let i = 0; i < this.children.length; i++) {
+            this.children[i].dispose();
+        }
+        this.children.splice(0, this.children.length);
+        this.tickListeners.splice(0, this.tickListeners.length);
+        this.physicsWorld.dispose();
+        this.visualScene.dispose();
+    }
+    addEntity(entity) {
+        if (!!entity.world) {
+            throw new Error('Entity already spawned');
+        }
+        this.children.push(entity);
+        if ((0, i_tick_listener_1.isITickListener)(entity)) {
+            this.tickListeners.push(entity);
+            this.tickListeners.sort((l1, l2) => l1.tickOrder - l2.tickOrder);
+        }
+        entity.onSpawned(this);
+    }
+    removeEntity(entity, dispose = true) {
+        if (entity.world !== this) {
+            throw new Error('Entity is not a part of this world');
+        }
+        this.children.splice(this.children.findIndex(x => x === entity), 1);
+        if ((0, i_tick_listener_1.isITickListener)(entity)) {
+            this.tickListeners.splice(this.tickListeners.findIndex(x => x === entity), 1);
+        }
+        entity.onRemoved();
+        if (dispose) {
+            entity.dispose();
+        }
+    }
+    registerConsoleCommand(command, handler, doc) {
+        if (!this.consoleEnabled) {
+            throw new Error('Console not enabled for this world');
+        }
+        this.commands[command] = { handler, doc };
+    }
+    runConsoleCommand(command, args) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.consoleEnabled) {
+                throw new Error('Console not enabled for this world');
+            }
+            if (!this.commands[command]) {
+                return 'Unrecognized command: ' + command;
+            }
+            return this.commands[command].handler(...args);
+        });
+    }
+    triggerPhysicsDebugView() {
+        if (this.physicsWorld.physicsDebugViewActive) {
+            this.physicsWorld.stopDebugger(this);
+        }
+        else {
+            const cls = this.visualScene.debugPhysicsDrawerClass;
+            if (!cls) {
+                throw new Error('Debug drawer is not available');
+            }
+            this.physicsWorld.startDebugger(this, new cls());
+        }
+    }
+}
+exports.GgWorld = GgWorld;

package/dist/base/interfaces/gg-body.d.ts

@@ -0,0 +1,15 @@
+import { GgPhysicsWorld } from './gg-physics-world';
+import { GgEntity } from '../entities/gg-entity';
+export interface GgBody<D, R> {
+    position: D;
+    rotation: R;
+    scale: D;
+    name: string;
+    entity: GgEntity | null;
+    clone(): GgBody<D, R>;
+    addToWorld(world: GgPhysicsWorld<D, R>): void;
+    removeFromWorld(world: GgPhysicsWorld<D, R>): void;
+    dispose(): void;
+    /** clear velocities etc. */
+    resetMotion(): void;
+}

package/dist/base/interfaces/gg-body.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/base/interfaces/gg-debug-physics-drawer.d.ts

@@ -0,0 +1,7 @@
+import { Point3 } from '../models/points';
+import { GgObject } from './gg-object';
+export interface GgDebugPhysicsDrawer<D, R> extends GgObject<D, R> {
+    drawContactPoint(point: D, normal: D, color?: Point3): void;
+    drawLine(from: D, to: D, color?: Point3): void;
+    update(): void;
+}

package/dist/base/interfaces/gg-debug-physics-drawer.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/base/interfaces/gg-object.d.ts

@@ -0,0 +1,16 @@
+import { GgVisualScene } from './gg-visual-scene';
+import { GgBox } from '../models/geometry-nodes';
+export interface GgObject<D, R> {
+    position: D;
+    rotation: R;
+    scale: D;
+    visible: boolean;
+    name: string;
+    isEmpty(): boolean;
+    popChild(name: string): GgObject<D, R> | null;
+    getBoundings(): GgBox<D>;
+    clone(): GgObject<D, R>;
+    addToWorld(world: GgVisualScene<D, R>): void;
+    removeFromWorld(world: GgVisualScene<D, R>): void;
+    dispose(): void;
+}

package/dist/base/interfaces/gg-object.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/base/interfaces/gg-physics-world.d.ts

@@ -0,0 +1,18 @@
+import { GgDebugPhysicsDrawer } from './gg-debug-physics-drawer';
+import { GgWorld } from '../gg-world';
+export interface GgPhysicsWorld<D, R> {
+    readonly factory: any;
+    gravity: D;
+    timeScale: number;
+    get physicsDebugViewActive(): boolean;
+    init(): Promise<void>;
+    /**
+     * Runs simulation of the physics world.
+     *
+     * @param delta delta time from last tick in milliseconds.
+     */
+    simulate(delta: number): void;
+    startDebugger(world: GgWorld<D, R>, drawer: GgDebugPhysicsDrawer<D, R>): void;
+    stopDebugger(world: GgWorld<D, R>): void;
+    dispose(): void;
+}

package/dist/base/interfaces/gg-physics-world.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/base/interfaces/gg-trigger.d.ts

@@ -0,0 +1,8 @@
+import { GgBody } from './gg-body';
+import { GgPositionableEntity } from '../entities/gg-positionable-entity';
+import { Observable } from 'rxjs';
+export interface GgTrigger<D, R> extends GgBody<D, R> {
+    get onEntityEntered(): Observable<GgPositionableEntity<D, R>>;
+    get onEntityLeft(): Observable<GgPositionableEntity<D, R> | null>;
+    checkOverlaps(): void;
+}

package/dist/base/interfaces/gg-trigger.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/base/interfaces/gg-visual-scene.d.ts

@@ -0,0 +1,9 @@
+import { GgDebugPhysicsDrawer } from './gg-debug-physics-drawer';
+export interface GgVisualScene<D, R> {
+    readonly factory: any;
+    readonly debugPhysicsDrawerClass?: {
+        new (): GgDebugPhysicsDrawer<D, R>;
+    };
+    init(): Promise<void>;
+    dispose(): void;
+}

package/dist/base/interfaces/gg-visual-scene.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/base/math/box.d.ts

@@ -0,0 +1,5 @@
+import { GgBox } from '../models/geometry-nodes';
+export declare class Box {
+    static clone<T>(box: GgBox<T>): GgBox<T>;
+    static expandByPoint<T>(box: GgBox<T>, point: T): GgBox<T>;
+}

package/dist/base/math/box.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Box = void 0;
+class Box {
+    static clone(box) {
+        return { min: Object.assign({}, box.min), max: Object.assign({}, box.max) };
+    }
+    static expandByPoint(box, point) {
+        const res = Box.clone(box);
+        for (const c in point) {
+            if (res.min[c] > point[c]) {
+                res.min[c] = point[c];
+            }
+            if (res.max[c] < point[c]) {
+                res.max[c] = point[c];
+            }
+        }
+        return res;
+    }
+}
+exports.Box = Box;

package/dist/base/math/matrix4.d.ts

@@ -0,0 +1,5 @@
+import { Point3 } from '../models/points';
+export declare class Mtrx4 {
+    /** creates a rotation matrix for object, so it will look at some point in space */
+    static lookAt(eye: Point3, target: Point3, up: Point3): number[];
+}

package/dist/base/math/matrix4.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Mtrx4 = void 0;
+const point3_1 = require("./point3");
+class Mtrx4 {
+    /** creates a rotation matrix for object, so it will look at some point in space */
+    static lookAt(eye, target, up) {
+        let z = point3_1.Pnt3.sub(eye, target);
+        if (point3_1.Pnt3.lenSq(z) === 0) {
+            // same position
+            z.z = 1;
+        }
+        else {
+            z = point3_1.Pnt3.norm(z);
+        }
+        let x = point3_1.Pnt3.cross(up, z);
+        if (point3_1.Pnt3.lenSq(x) === 0) {
+            // up and z are parallel
+            if (Math.abs(up.z) === 1) {
+                z.x += 0.0001;
+            }
+            else {
+                z.z += 0.0001;
+            }
+            z = point3_1.Pnt3.norm(z);
+            x = point3_1.Pnt3.cross(up, z);
+        }
+        x = point3_1.Pnt3.norm(x);
+        let y = point3_1.Pnt3.cross(z, x);
+        return [x.x, x.y, x.z, 0, y.x, y.y, y.z, 0, z.x, z.y, z.z, 0];
+    }
+}
+exports.Mtrx4 = Mtrx4;

package/dist/base/math/numbers.d.ts

@@ -0,0 +1,2 @@
+export declare const averageAngle: (angleA: number, angleB: number, factor?: number) => number;
+export declare const lerpNumber: (a: number, b: number, t: number) => number;