@gg-web-engine/core 0.0.1 → 0.0.3

package/src/3d/loader.ts

@@ -1,165 +0,0 @@
-import { Gg3dWorld } from './gg-3d-world';
-import { GgMeta } from './models/gg-meta';
-import { Gg3dEntity } from './entities/gg-3d-entity';
-import { Point3, Point4 } from '../base/models/points';
-import { Pnt3 } from '../base/math/point3';
-import { Qtrn } from '../base/math/quaternion';
-import { IGg3dBody, IGg3dObject } from './interfaces';
-
-export enum CachingStrategy {
-  Nothing,
-  Files,
-  Entities,
-}
-
-export type LoadOptions = {
-  // whether to cache anything
-  // "Nothing" does not cache anything
-  // "Files" caches GLB+Meta file contents
-  // "Entities" clones and saves parsed from GLB+Meta objects and bodies
-  cachingStrategy: CachingStrategy;
-  // initial position
-  position: Point3;
-  // initial rotation
-  rotation: Point4;
-  // process dummies with flag is_prop
-  loadProps: boolean;
-  // path where to find prop scenes
-  propsPath?: string;
-};
-
-const defaultLoadOptions: LoadOptions = {
-  cachingStrategy: CachingStrategy.Nothing,
-  position: { x: 0, y: 0, z: 0 },
-  rotation: { x: 0, y: 0, z: 0, w: 1 },
-  loadProps: true,
-};
-
-export type LoadResourcesResult = {
-  resources: { object3D: IGg3dObject | null; body: IGg3dBody | null }[];
-  meta: GgMeta;
-};
-
-export type LoadResult = {
-  entities: Gg3dEntity[];
-  meta: GgMeta;
-};
-
-const cloneLoadResourcesResult = (loadResult: LoadResourcesResult) => ({
-  meta: loadResult.meta, // TODO deep clone it
-  resources: loadResult.resources.map(({ object3D, body }) => ({
-    object3D: object3D && object3D.clone(),
-    body: body && body.clone(),
-  })),
-});
-
-export type LoadResultWithProps = LoadResult & { props?: LoadResult[] };
-
-export class Gg3dLoader {
-  readonly filesCache: Map<string, [ArrayBuffer, GgMeta] | Promise<[ArrayBuffer, GgMeta]>> = new Map<
-    string,
-    [ArrayBuffer, GgMeta] | Promise<[ArrayBuffer, GgMeta]>
-  >();
-
-  readonly loadResultCache: Map<string, LoadResourcesResult | Promise<LoadResourcesResult>> = new Map<
-    string,
-    LoadResourcesResult | Promise<LoadResourcesResult>
-  >();
-
-  constructor(protected readonly world: Gg3dWorld) {}
-
-  public async loadGgGlbFiles(path: string, useCache: boolean = false): Promise<[ArrayBuffer, GgMeta]> {
-    if (useCache && this.filesCache.has(path)) {
-      return this.filesCache.get(path)!;
-    }
-    const loadPromise = Promise.all([
-      fetch(`${path}.glb`).then(r => r.arrayBuffer()),
-      fetch(`${path}.meta`)
-        .then(r => r.text())
-        .then(r => JSON.parse(r)),
-    ]);
-    if (useCache) {
-      this.filesCache.set(path, loadPromise);
-    }
-    const result = await loadPromise;
-    if (useCache) {
-      this.filesCache.set(path, result);
-    }
-    return result;
-  }
-
-  public async loadGgGlbResources(
-    path: string,
-    cachingStrategy: CachingStrategy = CachingStrategy.Nothing,
-  ): Promise<LoadResourcesResult> {
-    if (cachingStrategy == CachingStrategy.Entities && this.loadResultCache.has(path)) {
-      const cached = this.loadResultCache.get(path);
-      const cachedResult = cached instanceof Promise ? await cached : cached;
-      return cloneLoadResourcesResult(cachedResult!);
-    }
-    const [glb, meta] = await this.loadGgGlbFiles(path, cachingStrategy == CachingStrategy.Files);
-    if (!glb) {
-      throw new Error('GLB not found');
-    }
-    const [object, bodies] = await Promise.all([
-      this.world.visualScene.loader.loadFromGgGlb(glb, meta),
-      this.world.physicsWorld.loader.loadFromGgGlb(glb, meta),
-    ]);
-    const result: LoadResourcesResult = { resources: [], meta };
-    if (!object) {
-      return result;
-    }
-    if (bodies.length == 0) {
-      result.resources.push({ object3D: object, body: null });
-    } else if (bodies.length == 1) {
-      result.resources.push({ object3D: object, body: bodies[0] });
-    } else {
-      for (const body of bodies) {
-        result.resources.push({ object3D: object.popChild(body.name), body });
-      }
-      if (!object.isEmpty()) {
-        result.resources.push({ object3D: object, body: null });
-      }
-    }
-    if (cachingStrategy == CachingStrategy.Entities) {
-      this.loadResultCache.set(path, cloneLoadResourcesResult(result));
-    }
-    return result;
-  }
-
-  public async loadGgGlb(
-    path: string,
-    options: Partial<LoadOptions> = defaultLoadOptions,
-  ): Promise<LoadResultWithProps> {
-    const loadOptions = { ...defaultLoadOptions, ...options };
-    const { resources, meta } = await this.loadGgGlbResources(path, loadOptions.cachingStrategy);
-    const result: LoadResultWithProps = {
-      entities: resources.map(({ object3D, body }) => new Gg3dEntity(object3D, body)),
-      meta,
-    };
-    if (loadOptions.loadProps) {
-      result.props = await Promise.all(
-        (meta as GgMeta).dummies
-          .filter(x => x.is_prop || x.is_scene)
-          .map(dummy =>
-            this.loadGgGlb(
-              dummy.is_prop
-                ? (loadOptions.propsPath || path.substring(0, path.lastIndexOf('/') + 1)) + dummy.prop_id
-                : dummy.scene_id,
-              {
-                loadProps: !!dummy.is_scene,
-                position: Pnt3.add(Pnt3.rot(dummy.position, loadOptions.rotation), loadOptions.position),
-                rotation: Qtrn.combineRotations(dummy.rotation, loadOptions.rotation),
-              },
-            ),
-          ),
-      );
-    }
-    result.entities.forEach(e => {
-      e.position = Pnt3.add(Pnt3.rot(Pnt3.clone(e.position), loadOptions.rotation), loadOptions.position);
-      // FIXME this rotation is wrong
-      e.rotation = Qtrn.mult(Qtrn.clone(e.rotation), loadOptions.rotation);
-    });
-    return result;
-  }
-}

package/src/3d/models/body-options.ts

@@ -1,3 +0,0 @@
-import { BodyOptions } from '../../base/models/body-options';
-
-export interface Body3DOptions extends BodyOptions {}

package/src/3d/models/gg-meta.ts

@@ -1,12 +0,0 @@
-import { Point3, Point4 } from '../../base/models/points';
-import { BodyShape3DDescriptor } from './shapes';
-
-export type GgDummy = { name: string; position: Point3; rotation: Point4 } & any;
-export type GgCurve = { name: string; cyclic: boolean; points: Point3[] } & any;
-export type GgRigidBody = { name: string; position: Point3; rotation: Point4 } & BodyShape3DDescriptor;
-
-export type GgMeta = {
-  dummies: GgDummy[];
-  curves: GgCurve[];
-  rigidBodies: GgRigidBody[];
-};

package/src/3d/models/shapes.ts

@@ -1,13 +0,0 @@
-import { Point3, Point4 } from '../../base/models/points';
-import { Body3DOptions } from './body-options';
-
-export type Shape3DDescriptor =
-  | { shape: 'BOX'; dimensions: Point3 }
-  | { shape: 'CONE' | 'CYLINDER'; radius: number; height: number }
-  | { shape: 'CAPSULE'; radius: number; centersDistance: number }
-  | { shape: 'SPHERE'; radius: number }
-  | { shape: 'COMPOUND'; children: { position?: Point3; rotation?: Point4; shape: Shape3DDescriptor }[] }
-  | { shape: 'CONVEX_HULL'; vertices: Point3[] }
-  | { shape: 'MESH'; vertices: Point3[]; faces: [number, number, number][] };
-
-export type BodyShape3DDescriptor = { shape: Shape3DDescriptor; body: Partial<Body3DOptions> };

package/src/base/clock.ts

@@ -1,97 +0,0 @@
-import { animationFrameScheduler, Observable, of, Subject, Subscription } from 'rxjs';
-import { map, repeat, tap } from 'rxjs/operators';
-
-const now = () => {
-  return (typeof performance === 'undefined' ? Date : performance).now();
-};
-
-/**
- * A class, providing ability to track time, fire ticks, provide time elapsed + tick delta with ability to suspend/resume it.
- */
-export class Clock {
-  /**
-   * A global clock, based on animation frame ticks
-   */
-  public static readonly animationFrameClock: Clock = new Clock(
-    of(undefined, animationFrameScheduler).pipe(repeat()),
-    true,
-  );
-
-  // value is global clock time, delta ms from last tick
-  public get tick$(): Observable<[number, number]> {
-    return this._tick$.pipe(map(([oldTime, newTime]) => [newTime, newTime - oldTime]));
-  }
-
-  public get isRunning(): boolean {
-    return !!this.tickSub;
-  }
-
-  public get isPaused(): boolean {
-    return this.pausedAt !== -1;
-  }
-
-  public get elapsedTime(): number {
-    if (this.isPaused) {
-      return this.pausedAt - this.startedAt;
-    }
-    return now() - this.startedAt;
-  }
-
-  private tickSub: Subscription | null = null;
-  private readonly _tick$: Subject<[number, number]> = new Subject<[number, number]>();
-
-  // state
-  private startedAt: number = -1;
-  private pausedAt: number = -1;
-
-  constructor(private readonly tickSource: Observable<any>, autoStart: boolean = false) {
-    if (autoStart) {
-      this.start();
-    }
-  }
-
-  start() {
-    if (this.isRunning) {
-      return;
-    }
-    this.startedAt = now();
-    this.startListeningTicks();
-  }
-
-  stop() {
-    this.stopListeningTicks();
-    this.startedAt = this.pausedAt = -1;
-  }
-
-  pause() {
-    this.stopListeningTicks();
-    this.pausedAt = now();
-  }
-
-  resume() {
-    if (this.isRunning || this.pausedAt == -1) {
-      return;
-    }
-    this.startedAt += now() - this.pausedAt;
-    this.pausedAt = -1;
-    this.startListeningTicks();
-  }
-
-  private startListeningTicks() {
-    if (this.tickSub) {
-      throw new Error('Clock is already ticking!');
-    }
-    let oldRelativeTime = 0;
-    this.tickSub = this.tickSource
-      .pipe(
-        map(() => [oldRelativeTime, now() - this.startedAt] as [number, number]),
-        tap(([_, cur]) => (oldRelativeTime = cur)),
-      )
-      .subscribe(this._tick$);
-  }
-
-  private stopListeningTicks() {
-    this.tickSub?.unsubscribe();
-    this.tickSub = null;
-  }
-}

package/src/base/controllers/common.ts

@@ -1,37 +0,0 @@
-import { combineLatest, Observable } from 'rxjs';
-import { KeyboardController } from './keyboard.controller';
-import { map } from 'rxjs/operators';
-
-export type DirectionKeymap = 'arrows' | 'wasd' | 'wasd+arrows';
-
-export type DirectionOutput = { upDown?: boolean; leftRight?: boolean };
-
-export const bindDirectionKeys: (
-  keyboard: KeyboardController,
-  keymap: DirectionKeymap,
-) => Observable<DirectionOutput> = (keyboard: KeyboardController, keymap: DirectionKeymap) => {
-  const keys = [[], [], [], []] as string[][];
-  if (keymap.includes('wasd')) {
-    keys[0].push('KeyW');
-    keys[1].push('KeyA');
-    keys[2].push('KeyS');
-    keys[3].push('KeyD');
-  }
-  if (keymap.includes('arrows')) {
-    keys[0].push('ArrowUp');
-    keys[1].push('ArrowLeft');
-    keys[2].push('ArrowDown');
-    keys[3].push('ArrowRight');
-  }
-  return combineLatest(keys.map(x => keyboard.bindMany(...x))).pipe(
-    map(moveDirection => {
-      const result: DirectionOutput = {};
-      if (moveDirection.includes(true)) {
-        const [f, l, b, r] = moveDirection;
-        if (f != b) result.upDown = f;
-        if (l != r) result.leftRight = l;
-      }
-      return result;
-    }),
-  );
-};

package/src/base/controllers/i-controller.ts

@@ -1,5 +0,0 @@
-export interface IController {
-  start(): Promise<void>;
-
-  stop(): Promise<void>;
-}

package/src/base/controllers/keyboard.controller.ts

@@ -1,109 +0,0 @@
-import { IController } from './i-controller';
-import { BehaviorSubject, combineLatest, finalize, NEVER, Observable } from 'rxjs';
-import { map } from 'rxjs/operators';
-
-export class KeyboardController implements IController {
-  private bindings: { [code: string]: BehaviorSubject<boolean>[] } = {};
-
-  constructor() {
-    this.handleKeys = this.handleKeys.bind(this);
-  }
-
-  private _running: boolean = false;
-  public get running(): boolean {
-    return this._running;
-  }
-
-  bind(code: string): Observable<boolean> {
-    if (!this.bindings[code]) {
-      this.bindings[code] = [];
-    }
-    const subj = new BehaviorSubject<boolean>(false);
-    this.bindings[code].push(subj);
-    return subj.pipe(
-      finalize(() => {
-        this.bindings[code].splice(this.bindings[code].indexOf(subj), 1);
-        subj.complete();
-      }),
-    );
-  }
-
-  bindMany(...codes: string[]): Observable<boolean> {
-    if (codes.length == 0) {
-      console.warn('[KeyboardController] bindMany called without any key code');
-      return NEVER;
-    }
-    if (codes.length == 1) {
-      return this.bind(codes[0]);
-    }
-    const subjects: BehaviorSubject<boolean>[] = [];
-    for (const code of codes) {
-      if (!this.bindings[code]) {
-        this.bindings[code] = [];
-      }
-      const subj = new BehaviorSubject<boolean>(false);
-      this.bindings[code].push(subj);
-      subjects.push(subj);
-    }
-    return combineLatest(subjects).pipe(
-      finalize(() => {
-        for (let i = 0; i < codes.length; i++) {
-          this.bindings[codes[i]].splice(this.bindings[codes[i]].indexOf(subjects[i]), 1);
-          subjects[i].complete();
-        }
-      }),
-      map(values => values.includes(true)),
-    );
-  }
-
-  emulateKeyDown(code: string): void {
-    if (!this.running) {
-      return;
-    }
-    for (const subj of this.bindings[code] || []) {
-      subj.next(true);
-    }
-  }
-
-  emulateKeyUp(code: string): void {
-    if (!this.running) {
-      return;
-    }
-    for (const subj of this.bindings[code] || []) {
-      subj.next(false);
-    }
-  }
-
-  emulateKeyPress(code: string): void {
-    this.emulateKeyDown(code);
-    this.emulateKeyUp(code);
-  }
-
-  async start() {
-    if (this.running) {
-      return;
-    }
-    window.addEventListener('keydown', this.handleKeys);
-    window.addEventListener('keyup', this.handleKeys);
-    this._running = true;
-  }
-
-  private handleKeys(e: KeyboardEvent) {
-    if (e.type != 'keydown' && e.type != 'keyup') {
-      return;
-    }
-    const pressed = e.type == 'keydown';
-    for (const subj of this.bindings[e.code] || []) {
-      subj.next(pressed);
-    }
-  }
-
-  async stop() {
-    if (!this.running) {
-      return;
-    }
-    window.removeEventListener('keydown', this.handleKeys);
-    window.removeEventListener('keyup', this.handleKeys);
-    this._running = false;
-  }
-}

package/src/base/controllers/mouse.controller.ts

@@ -1,73 +0,0 @@
-import { IController } from './i-controller';
-import { filter, fromEvent, Observable, Subject, takeUntil } from 'rxjs';
-import { map } from 'rxjs/operators';
-import { Point2 } from '../models/points';
-
-export type MouseControllerPointLockOptions = { ignoreMovementWhenNotLocked: boolean; canvas: HTMLCanvasElement };
-export type MouseControllerOptions = {
-  pointerLock?: MouseControllerPointLockOptions;
-};
-
-export class MouseController implements IController {
-  private readonly _delta$: Subject<Point2> = new Subject<Point2>();
-
-  public get deltaX$(): Observable<number> {
-    return this._delta$.pipe(map(d => d.x));
-  }
-
-  public get deltaY$(): Observable<number> {
-    return this._delta$.pipe(map(d => d.y));
-  }
-
-  public get delta$(): Observable<Point2> {
-    return this._delta$.asObservable();
-  }
-
-  constructor(private readonly options: MouseControllerOptions = {}) {
-    this.canvasClickListener = this.canvasClickListener.bind(this);
-  }
-
-  private stopped$: Subject<void> = new Subject();
-  private _running: boolean = false;
-  public get running(): boolean {
-    return this._running;
-  }
-
-  async start() {
-    if (this.running) {
-      return;
-    }
-    fromEvent(window, 'mousemove')
-      .pipe(
-        takeUntil(this.stopped$),
-        filter(
-          () =>
-            !this.options.pointerLock ||
-            !this.options.pointerLock.ignoreMovementWhenNotLocked ||
-            !!document.pointerLockElement,
-        ),
-        map((e: any) => ({ x: e.movementX, y: e.movementY })),
-      )
-      .subscribe(v => this._delta$.next(v));
-    if (!!this.options.pointerLock) {
-      this.options.pointerLock.canvas.addEventListener('click', this.canvasClickListener);
-    }
-    this._running = true;
-  }
-
-  private canvasClickListener(): void {
-    this.options.pointerLock!.canvas.requestPointerLock();
-  }
-
-  async stop(unlockPointer: boolean = true) {
-    if (!this.running) {
-      return;
-    }
-    this.stopped$.next();
-    if (unlockPointer && !!this.options.pointerLock) {
-      this.options.pointerLock.canvas.removeEventListener('click', this.canvasClickListener);
-      document.exitPointerLock();
-    }
-    this._running = false;
-  }
-}

package/src/base/data-structures/graph.ts

@@ -1,125 +0,0 @@
-export class Graph<T> {
-  static fromArray<T>(array: T[]): Graph<T> {
-    const root = new Graph(array[0]);
-    let tail = root;
-    for (let i = 1; i < array.length; i++) {
-      const newTail = new Graph<T>(array[i]);
-      tail.addAdjacent(newTail);
-      tail = newTail;
-    }
-    return root;
-  }
-  static fromSquareGrid<T>(grid: T[][]): Graph<T> {
-    const nodes = grid.map(sgrid => sgrid.map(item => new Graph<T>(item)));
-    // bind them
-    for (let j = 0; j < nodes.length; j++) {
-      for (let i = 0; i < nodes.length; i++) {
-        if (i > 0) {
-          nodes[j][i].addAdjacent(nodes[j][i - 1]);
-        }
-        if (j > 0) {
-          nodes[j][i].addAdjacent(nodes[j - 1][i]);
-        }
-      }
-    }
-    return nodes[0][0];
-  }
-
-  data: T;
-  private adjacent: Set<Graph<T>>;
-
-  constructor(data: T) {
-    this.data = data;
-    this.adjacent = new Set();
-  }
-
-  addAdjacent(node: Graph<T>): boolean {
-    if (this.adjacent.has(node)) {
-      return false;
-    }
-    this.adjacent.add(node);
-    node.adjacent.add(this);
-    return true;
-  }
-
-  removeAdjacent(node: Graph<T>): boolean {
-    if (!this.adjacent.has(node)) {
-      return false;
-    }
-    this.adjacent.delete(node);
-    node.adjacent.delete(this);
-    return true;
-  }
-
-  /**
-   * Create an edge between two nodes
-   */
-  addEdge(source: Graph<T>, destination: Graph<T>): boolean {
-    if (!this.removeAdjacent(destination)) {
-      return false;
-    }
-    this.addAdjacent(source);
-    source.addAdjacent(destination);
-    return true;
-  }
-
-  /**
-   * Remove an edge between two nodes
-   */
-  removeEdge(source: Graph<T>, destination: Graph<T>): boolean {
-    if (!source.adjacent.has(this) || !source.adjacent.has(destination)) {
-      return false;
-    }
-    source.removeAdjacent(this);
-    source.removeAdjacent(destination);
-    return this.addAdjacent(destination);
-  }
-
-  walkRead(depth: number): Set<Graph<T>> {
-    const visited: Set<Graph<T>> = new Set();
-    const stack: [Graph<T>, number][] = [[this, depth]];
-    visited.add(this);
-    while (stack.length) {
-      const next = stack.shift()!;
-      const [node, depthLeft] = next;
-      if (depthLeft !== 0) {
-        const children = Array.from(node.adjacent).filter(c => !visited.has(c));
-        for (const child of children) {
-          visited.add(child);
-          stack.push([child, depthLeft - 1]);
-        }
-      }
-    }
-    return visited;
-  }
-
-  // the same as "walkRead", but returns array of sets (per depth), so distance to each found node can be tracked
-  walkReadPreserveDepth(depth: number): Set<Graph<T>>[] {
-    const visited: Set<Graph<T>> = new Set();
-    const result: Set<Graph<T>>[] = [];
-    const stack: [Graph<T>, number][] = [[this, depth]];
-    visited.add(this);
-    while (stack.length) {
-      const next = stack.shift()!;
-      const [node, depthLeft] = next;
-      const distance = depth - depthLeft;
-      if (!result[distance]) {
-        result[distance] = new Set<Graph<T>>();
-      }
-      result[distance].add(node);
-      if (depthLeft !== 0) {
-        const children = Array.from(node.adjacent).filter(c => !visited.has(c));
-        for (const child of children) {
-          visited.add(child);
-          stack.push([child, depthLeft - 1]);
-        }
-      }
-    }
-    return result;
-  }
-
-  // TODO return iterable?
-  nodes(): Graph<T>[] {
-    return Array.from(this.walkRead(-1));
-  }
-}