@gg-web-engine/core 0.0.1

package/dist/3d/controllers/car-keyboard.controller.js

@@ -0,0 +1,98 @@
+"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.CarKeyboardController = void 0;
+const rxjs_1 = require("rxjs");
+const operators_1 = require("rxjs/operators");
+const common_1 = require("../../base/controllers/common");
+// TODO pass as settings
+// TODO smooth y?
+const TICKER_INTERVAL = 16;
+const TICKER_MAX_STEPS = 10;
+class CarKeyboardController {
+    constructor(keyboardController, car, options = { keymap: 'arrows', gearUpDownKeys: ['KeyA', 'KeyZ'] }) {
+        this.keyboardController = keyboardController;
+        this.options = options;
+        // emits values -1 - 1; -1 = full turn left; 1 = full turn right
+        this.x$ = new rxjs_1.BehaviorSubject(0);
+        // emits values -1 - 1; -1 = full brake; 1 = full acceleration
+        this.y$ = new rxjs_1.BehaviorSubject(0);
+        this.lastX = 0;
+        this.stop$ = new rxjs_1.Subject();
+        this.car$ = new rxjs_1.BehaviorSubject(null);
+        this.pairTickerPipe = (0, rxjs_1.pipe)((0, operators_1.startWith)(0), (0, operators_1.pairwise)(), (0, operators_1.map)(([beforeValue, afterValue]) => [this.lastX, afterValue]), (0, operators_1.switchMap)(([beforeValue, afterValue]) => (0, rxjs_1.interval)(TICKER_INTERVAL).pipe((0, operators_1.take)(TICKER_MAX_STEPS), (0, operators_1.map)(count => ++count), (0, operators_1.map)(count => beforeValue * ((TICKER_MAX_STEPS - count) / TICKER_MAX_STEPS) + afterValue * (count / TICKER_MAX_STEPS)), (0, operators_1.tap)(x => {
+            this.lastX = x;
+        }))));
+        this.car$.next(car);
+    }
+    set car(value) {
+        this.car$.next(value);
+    }
+    get car() {
+        return this.car$.getValue();
+    }
+    start() {
+        return __awaiter(this, void 0, void 0, function* () {
+            let moveDirection = {};
+            (0, common_1.bindDirectionKeys)(this.keyboardController, this.options.keymap)
+                .pipe((0, rxjs_1.takeUntil)(this.stop$))
+                .subscribe(d => {
+                moveDirection = d;
+            });
+            this.car$
+                .pipe((0, rxjs_1.takeUntil)(this.stop$), (0, operators_1.switchMap)(c => c.tick$), (0, rxjs_1.takeUntil)(this.stop$), (0, operators_1.map)(() => {
+                const direction = [0, 0];
+                if (moveDirection.leftRight !== undefined)
+                    direction[0] = moveDirection.leftRight ? -1 : 1;
+                if (moveDirection.upDown !== undefined)
+                    direction[1] = moveDirection.upDown ? 1 : -1;
+                return direction;
+            }))
+                .subscribe(([x, y]) => {
+                this.x$.next(x);
+                this.y$.next(y);
+            });
+            (0, rxjs_1.combineLatest)([
+                this.x$.pipe((0, rxjs_1.takeUntil)(this.stop$), (0, operators_1.distinctUntilChanged)(), this.pairTickerPipe),
+                this.y$.pipe((0, rxjs_1.takeUntil)(this.stop$), (0, operators_1.distinctUntilChanged)()),
+            ]).subscribe(([x, y]) => {
+                this.car$.getValue().setXAxisControlValue(x);
+                this.car$.getValue().setYAxisControlValue(y);
+            });
+            this.keyboardController
+                .bind(this.options.gearUpDownKeys[0])
+                .pipe((0, rxjs_1.takeUntil)(this.stop$), (0, rxjs_1.filter)(x => !!x))
+                .subscribe(() => {
+                if (this.car$.getValue() &&
+                    (!this.car$.getValue().carProperties.transmission.isAuto || this.car$.getValue().gear <= 0)) {
+                    this.car$.getValue().gear++;
+                }
+            });
+            this.keyboardController
+                .bind(this.options.gearUpDownKeys[1])
+                .pipe((0, rxjs_1.takeUntil)(this.stop$), (0, rxjs_1.filter)(x => !!x))
+                .subscribe(() => {
+                if (this.car$.getValue().carProperties.transmission.isAuto && this.car.gear > 1) {
+                    this.car$.getValue().gear = 0;
+                }
+                else {
+                    this.car$.getValue().gear--;
+                }
+            });
+        });
+    }
+    stop() {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.stop$.next();
+        });
+    }
+}
+exports.CarKeyboardController = CarKeyboardController;

package/dist/3d/controllers/free-camera.controller.d.ts

@@ -0,0 +1,23 @@
+import { IController } from '../../base/controllers/i-controller';
+import { MouseControllerOptions } from '../../base/controllers/mouse.controller';
+import { Gg3dCameraEntity } from '../entities/gg-3d-camera.entity';
+import { KeyboardController } from '../../base/controllers/keyboard.controller';
+import { DirectionKeymap } from '../../base/controllers/common';
+declare type FreeCameraControllerOptions = {
+    keymap: DirectionKeymap;
+    movementOptions: {
+        speed: number;
+    };
+    mouseOptions: MouseControllerOptions;
+};
+export declare class FreeCameraController implements IController {
+    private readonly keyboardController;
+    private readonly camera;
+    private readonly options;
+    private readonly mController;
+    private readonly stop$;
+    constructor(keyboardController: KeyboardController, camera: Gg3dCameraEntity, options?: FreeCameraControllerOptions);
+    start(): Promise<void>;
+    stop(unlockPointer?: boolean): Promise<void>;
+}
+export {};

package/dist/3d/controllers/free-camera.controller.js

@@ -0,0 +1,79 @@
+"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.FreeCameraController = void 0;
+const rxjs_1 = require("rxjs");
+const mouse_controller_1 = require("../../base/controllers/mouse.controller");
+const point3_1 = require("../../base/math/point3");
+const point2_1 = require("../../base/math/point2");
+const quaternion_1 = require("../../base/math/quaternion");
+const common_1 = require("../../base/controllers/common");
+class FreeCameraController {
+    constructor(keyboardController, camera, options = {
+        keymap: 'wasd',
+        movementOptions: { speed: 0.5 },
+        mouseOptions: {},
+    }) {
+        this.keyboardController = keyboardController;
+        this.camera = camera;
+        this.options = options;
+        this.stop$ = new rxjs_1.Subject();
+        this.mController = new mouse_controller_1.MouseController(options.mouseOptions);
+    }
+    start() {
+        return __awaiter(this, void 0, void 0, function* () {
+            let controls = { direction: {}, rest: [] };
+            const keys = ['KeyE', 'KeyQ'];
+            if (this.camera.object3D.supportsFov) {
+                keys.push('KeyZ', 'KeyC');
+            }
+            (0, common_1.bindDirectionKeys)(this.keyboardController, this.options.keymap)
+                .pipe((0, rxjs_1.takeUntil)(this.stop$))
+                .subscribe(d => {
+                controls.direction = d;
+            });
+            (0, rxjs_1.combineLatest)(keys.map(c => this.keyboardController.bind(c)))
+                .pipe((0, rxjs_1.takeUntil)(this.stop$))
+                .subscribe((d) => {
+                controls.rest = d;
+            });
+            let rotationDelta = { x: 0, y: 0 };
+            this.mController.delta$.pipe((0, rxjs_1.takeUntil)(this.stop$)).subscribe(delta => {
+                rotationDelta = point2_1.Pnt2.add(rotationDelta, delta);
+            });
+            this.camera.tick$.pipe((0, rxjs_1.takeUntil)(this.stop$)).subscribe(() => {
+                let translateVector = { x: 0, y: 0, z: 0 };
+                const [u, d, zo, zi] = controls.rest;
+                if (controls.direction.upDown !== undefined)
+                    translateVector.z = controls.direction.upDown ? -1 : 1;
+                if (controls.direction.leftRight !== undefined)
+                    translateVector.x = controls.direction.leftRight ? -1 : 1;
+                if (u != d)
+                    translateVector.y = d ? -1 : 1;
+                if (zo != zi)
+                    this.camera.object3D.fov += zo ? 1 : -1;
+                this.camera.position = point3_1.Pnt3.add(this.camera.position, point3_1.Pnt3.rot(point3_1.Pnt3.scalarMult(point3_1.Pnt3.norm(translateVector), this.options.movementOptions.speed), this.camera.rotation));
+                if (rotationDelta.x != 0 || rotationDelta.y != 0) {
+                    this.camera.rotation = quaternion_1.Qtrn.combineRotations(quaternion_1.Qtrn.fromAngle({ x: 0, y: 0, z: 1 }, -rotationDelta.x / 300), this.camera.rotation, quaternion_1.Qtrn.fromAngle({ x: 1, y: 0, z: 0 }, -rotationDelta.y / 300));
+                    rotationDelta = { x: 0, y: 0 };
+                }
+            });
+            yield this.mController.start();
+        });
+    }
+    stop(unlockPointer = true) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.stop$.next();
+            yield this.mController.stop(unlockPointer);
+        });
+    }
+}
+exports.FreeCameraController = FreeCameraController;

package/dist/3d/entities/controllers/entity-motion.controller.d.ts

@@ -0,0 +1,32 @@
+import { GgEntity } from '../../../base/entities/gg-entity';
+import { ITickListener } from '../../../base/entities/interfaces/i-tick-listener';
+import { Subject } from 'rxjs';
+import { Gg3dWorld } from '../../gg-3d-world';
+import { GgPositionable3dEntity } from '../gg-positionable-3d-entity';
+import { Point3, Point4 } from '../../../base/models/points';
+export declare type MotionControlFuncReturn = {
+    position: Point3;
+    rotation: Point4;
+    customParameters: {
+        [key: string]: any;
+    };
+};
+export declare type MotionControlFunction = (delta: number) => MotionControlFuncReturn;
+export declare class EntityMotionController extends GgEntity implements ITickListener {
+    target: GgPositionable3dEntity;
+    protected _motionControlFunction: MotionControlFunction;
+    customParametersHandleFunc: (target: GgPositionable3dEntity, params: any) => void;
+    get motionControlFunction(): MotionControlFunction;
+    set motionControlFunction(value: MotionControlFunction);
+    readonly tick$: Subject<[number, number]>;
+    protected readonly removed$: Subject<void>;
+    readonly tickOrder: number;
+    constructor(target: GgPositionable3dEntity, _motionControlFunction: MotionControlFunction, customParametersHandleFunc?: (target: GgPositionable3dEntity, params: any) => void);
+    protected lastValue: MotionControlFuncReturn | undefined;
+    private currentTransition;
+    transitFromStaticState(state: MotionControlFuncReturn, newFunc: MotionControlFunction, transitionDuration: number, easing?: (t: number) => number, customParametersLerpFunc?: (a: any, b: any, t: number) => any): void;
+    transitControlFunction(newFunc: MotionControlFunction, transitionDuration: number, easing?: (t: number) => number, customParametersLerpFunc?: (a: any, b: any, t: number) => any): void;
+    onSpawned(world: Gg3dWorld): void;
+    onRemoved(): void;
+    dispose(): void;
+}

package/dist/3d/entities/controllers/entity-motion.controller.js

@@ -0,0 +1,100 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EntityMotionController = void 0;
+const gg_entity_1 = require("../../../base/entities/gg-entity");
+const rxjs_1 = require("rxjs");
+const point3_1 = require("../../../base/math/point3");
+const quaternion_1 = require("../../../base/math/quaternion");
+class EntityMotionController extends gg_entity_1.GgEntity {
+    constructor(target, _motionControlFunction, customParametersHandleFunc = () => { }) {
+        super();
+        this.target = target;
+        this._motionControlFunction = _motionControlFunction;
+        this.customParametersHandleFunc = customParametersHandleFunc;
+        this.tick$ = new rxjs_1.Subject();
+        this.removed$ = new rxjs_1.Subject();
+        this.tickOrder = 750;
+        this.currentTransition = null;
+    }
+    get motionControlFunction() {
+        return this._motionControlFunction;
+    }
+    set motionControlFunction(value) {
+        if (this.currentTransition) {
+            this.currentTransition.unsubscribe();
+            this.currentTransition = null;
+        }
+        this._motionControlFunction = value;
+    }
+    // smoothly set controller function, animate from some determined state
+    transitFromStaticState(state, newFunc, transitionDuration, easing = x => x, customParametersLerpFunc = (a, b, t) => b) {
+        this.lastValue = state;
+        this._motionControlFunction = () => state;
+        return this.transitControlFunction(newFunc, transitionDuration, easing, customParametersLerpFunc);
+    }
+    // smoothly change controller function
+    transitControlFunction(newFunc, transitionDuration, easing = x => x, customParametersLerpFunc = (a, b, t) => b) {
+        let oldControlFunc;
+        if (this.currentTransition) {
+            this.currentTransition.unsubscribe();
+            this.currentTransition = null;
+            if (this.lastValue) {
+                oldControlFunc = () => this.lastValue;
+            }
+            else {
+                this._motionControlFunction = newFunc;
+                return;
+            }
+        }
+        else {
+            oldControlFunc = this._motionControlFunction;
+        }
+        let k = 0;
+        this._motionControlFunction = delta => {
+            const oldRes = oldControlFunc(delta);
+            const newRes = newFunc(delta);
+            return {
+                customParameters: customParametersLerpFunc(oldRes.customParameters, newRes.customParameters, k),
+                position: point3_1.Pnt3.lerp(oldRes.position, newRes.position, k),
+                rotation: quaternion_1.Qtrn.slerp(oldRes.rotation, newRes.rotation, k),
+            };
+        };
+        let startTime;
+        this.currentTransition = this.tick$.pipe((0, rxjs_1.takeUntil)(this.removed$)).subscribe(([elapsed, _]) => {
+            if (startTime === undefined) {
+                startTime = elapsed;
+            }
+            else {
+                k = (elapsed - startTime) / transitionDuration;
+                if (k >= 1) {
+                    k = 1;
+                    this.currentTransition.unsubscribe();
+                    this.currentTransition = null;
+                    this._motionControlFunction = newFunc;
+                }
+                else {
+                    k = easing(k);
+                }
+            }
+        });
+    }
+    onSpawned(world) {
+        super.onSpawned(world);
+        this.tick$.pipe((0, rxjs_1.takeUntil)(this.removed$)).subscribe(([_, delta]) => {
+            this.lastValue = this._motionControlFunction(delta);
+            this.target.position = this.lastValue.position;
+            this.target.rotation = this.lastValue.rotation;
+            this.customParametersHandleFunc(this.target, this.lastValue.customParameters);
+        });
+    }
+    onRemoved() {
+        super.onRemoved();
+        this.removed$.next();
+    }
+    dispose() {
+        super.dispose();
+        this.tick$.unsubscribe();
+        this.tick$.complete();
+    }
+}
+exports.EntityMotionController = EntityMotionController;

package/dist/3d/entities/gg-3d-camera.entity.d.ts

@@ -0,0 +1,7 @@
+import { IGg3dBody, IGg3dCamera } from '../interfaces';
+import { Gg3dEntity } from './gg-3d-entity';
+export declare class Gg3dCameraEntity<T extends IGg3dCamera = IGg3dCamera> extends Gg3dEntity {
+    readonly object3D: T;
+    readonly objectBody: IGg3dBody | null;
+    constructor(object3D: T, objectBody?: IGg3dBody | null);
+}

package/dist/3d/entities/gg-3d-camera.entity.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Gg3dCameraEntity = void 0;
+const gg_3d_entity_1 = require("./gg-3d-entity");
+class Gg3dCameraEntity extends gg_3d_entity_1.Gg3dEntity {
+    constructor(object3D, objectBody = null) {
+        super(object3D, objectBody);
+        this.object3D = object3D;
+        this.objectBody = objectBody;
+    }
+}
+exports.Gg3dCameraEntity = Gg3dCameraEntity;

package/dist/3d/entities/gg-3d-entity.d.ts

@@ -0,0 +1,25 @@
+import { Subject } from 'rxjs';
+import { GgPositionable3dEntity } from './gg-positionable-3d-entity';
+import { ITickListener } from '../../base/entities/interfaces/i-tick-listener';
+import { Point3, Point4 } from '../../base/models/points';
+import { Gg3dWorld } from '../gg-3d-world';
+import { IGg3dBody, IGg3dObject } from '../interfaces';
+export declare class Gg3dEntity extends GgPositionable3dEntity implements ITickListener {
+    readonly object3D: IGg3dObject | null;
+    readonly objectBody: IGg3dBody | null;
+    readonly tick$: Subject<[number, number]>;
+    readonly tickOrder = 750;
+    get position(): Point3;
+    set position(value: Point3);
+    get rotation(): Point4;
+    set rotation(value: Point4);
+    get scale(): Point3;
+    set scale(value: Point3);
+    get visible(): boolean;
+    set visible(value: boolean);
+    protected runTransformBinding(objectBody: IGg3dBody, object3D: IGg3dObject): void;
+    constructor(object3D: IGg3dObject | null, objectBody?: IGg3dBody | null);
+    onSpawned(world: Gg3dWorld): void;
+    onRemoved(): void;
+    dispose(): void;
+}

package/dist/3d/entities/gg-3d-entity.js

@@ -0,0 +1,108 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Gg3dEntity = void 0;
+const rxjs_1 = require("rxjs");
+const gg_positionable_3d_entity_1 = require("./gg-positionable-3d-entity");
+class Gg3dEntity extends gg_positionable_3d_entity_1.GgPositionable3dEntity {
+    constructor(object3D, objectBody = null) {
+        super();
+        this.object3D = object3D;
+        this.objectBody = objectBody;
+        this.tick$ = new rxjs_1.Subject();
+        this.tickOrder = 750;
+        if (objectBody && object3D) {
+            this.tick$.subscribe(() => {
+                this.runTransformBinding(objectBody, object3D);
+            });
+            this.runTransformBinding(objectBody, object3D);
+        }
+        else if (!objectBody && !object3D) {
+            throw new Error('Cannot create entity without a mesh and a body');
+        }
+        if (objectBody) {
+            objectBody.entity = this;
+        }
+    }
+    get position() {
+        return super.position;
+    }
+    set position(value) {
+        if (this.object3D) {
+            this.object3D.position = value;
+        }
+        if (this.objectBody) {
+            this.objectBody.position = value;
+        }
+        super.position = value;
+    }
+    get rotation() {
+        return super.rotation;
+    }
+    set rotation(value) {
+        if (this.object3D) {
+            this.object3D.rotation = value;
+        }
+        if (this.objectBody) {
+            this.objectBody.rotation = value;
+        }
+        super.rotation = value;
+    }
+    get scale() {
+        return super.scale;
+    }
+    set scale(value) {
+        if (this.object3D) {
+            this.object3D.scale = value;
+        }
+        if (this.objectBody) {
+            this.objectBody.scale = value;
+        }
+        super.scale = value;
+    }
+    get visible() {
+        var _a;
+        return !!((_a = this.object3D) === null || _a === void 0 ? void 0 : _a.visible);
+    }
+    set visible(value) {
+        if (this.object3D) {
+            this.object3D.visible = value;
+        }
+        for (const entity of this._children) {
+            if (entity instanceof Gg3dEntity && entity.object3D) {
+                entity.object3D.visible = value;
+            }
+        }
+    }
+    runTransformBinding(objectBody, object3D) {
+        // bind physics body transform to mesh transform
+        const pos = objectBody.position;
+        const quat = objectBody.rotation;
+        object3D.position = pos;
+        object3D.rotation = quat;
+        this._position$.next(pos);
+        this._rotation$.next(quat);
+    }
+    onSpawned(world) {
+        var _a, _b;
+        super.onSpawned(world);
+        (_a = this.object3D) === null || _a === void 0 ? void 0 : _a.addToWorld(world.visualScene);
+        (_b = this.objectBody) === null || _b === void 0 ? void 0 : _b.addToWorld(world.physicsWorld);
+    }
+    onRemoved() {
+        var _a, _b;
+        (_a = this.object3D) === null || _a === void 0 ? void 0 : _a.removeFromWorld(this.world.visualScene);
+        (_b = this.objectBody) === null || _b === void 0 ? void 0 : _b.removeFromWorld(this.world.physicsWorld);
+        super.onRemoved();
+    }
+    dispose() {
+        super.dispose();
+        this.tick$.unsubscribe();
+        if (this.object3D) {
+            this.object3D.dispose();
+        }
+        if (this.objectBody) {
+            this.objectBody.dispose();
+        }
+    }
+}
+exports.Gg3dEntity = Gg3dEntity;

package/dist/3d/entities/gg-3d-map-graph.entity.d.ts

@@ -0,0 +1,51 @@
+import { BehaviorSubject, Observable, Subject } from 'rxjs';
+import { Point3, Point4 } from '../../base/models/points';
+import { Graph } from '../../base/data-structures/graph';
+import { GgEntity } from '../../base/entities/gg-entity';
+import { ITickListener } from '../../base/entities/interfaces/i-tick-listener';
+import { GgPositionable3dEntity } from './gg-positionable-3d-entity';
+import { Gg3dWorld } from '../gg-3d-world';
+import { Gg3dEntity } from './gg-3d-entity';
+import { LoadOptions, LoadResultWithProps } from '../loader';
+declare type MapGraphNodeType = {
+    path: string;
+    position: Point3;
+    rotation?: Point4;
+    loadOptions: Partial<Omit<LoadOptions, 'position' | 'rotation'>>;
+};
+export declare class MapGraph extends Graph<MapGraphNodeType> {
+    static fromMapArray(array: MapGraphNodeType[]): MapGraph;
+    static fromMapSquareGrid(grid: MapGraphNodeType[][]): MapGraph;
+    getNearestDummy(thisNodes: Graph<MapGraphNodeType>[], cursor: Point3): Graph<MapGraphNodeType>;
+    nodes(): MapGraph[];
+}
+export declare type Gg3dMapGraphEntityOptions = {
+    loadDepth: number;
+    inertia: number;
+};
+export declare class Gg3dMapGraphEntity extends GgEntity implements ITickListener {
+    readonly mapGraph: MapGraph;
+    readonly tick$: Subject<[number, number]>;
+    readonly tickOrder = 1500;
+    readonly loaderCursorEntity$: BehaviorSubject<GgPositionable3dEntity | null>;
+    readonly loaded: Map<MapGraphNodeType, GgPositionable3dEntity[]>;
+    private _initialLoadComplete$;
+    get initialLoadComplete$(): Observable<boolean>;
+    private _nearestDummy$;
+    get nearestDummy(): Graph<MapGraphNodeType> | null;
+    private _chunkLoaded$;
+    get chunkLoaded$(): Observable<[LoadResultWithProps, {
+        position: Point3;
+        rotation: Point4;
+    }]>;
+    get world(): Gg3dWorld | null;
+    protected _world: Gg3dWorld | null;
+    private readonly mapGraphNodes;
+    protected readonly options: Gg3dMapGraphEntityOptions;
+    constructor(mapGraph: MapGraph, options?: Partial<Gg3dMapGraphEntityOptions>);
+    onSpawned(world: Gg3dWorld): void;
+    onRemoved(): void;
+    protected loadChunk(node: MapGraphNodeType): Promise<Gg3dEntity[]>;
+    protected disposeChunk(node: MapGraphNodeType): void;
+}
+export {};