@gg-web-engine/core 0.0.1 → 0.0.3

package/src/base/gg-world.ts

@@ -1,198 +0,0 @@
-import { Clock } from './clock';
-import { GgEntity } from './entities/gg-entity';
-import { isITickListener, ITickListener } from './entities/interfaces/i-tick-listener';
-import { GgPhysicsWorld } from './interfaces/gg-physics-world';
-import { GgVisualScene } from './interfaces/gg-visual-scene';
-import { GgStatic } from './gg-static';
-import { KeyboardController } from './controllers/keyboard.controller';
-import { filter } from 'rxjs';
-import { GgConsoleUI } from './ui/gg-console.ui';
-import { GgDebuggerUI } from './ui/gg-debugger.ui';
-
-export abstract class GgWorld<
-  D,
-  R,
-  V extends GgVisualScene<D, R> = GgVisualScene<D, R>,
-  P extends GgPhysicsWorld<D, R> = GgPhysicsWorld<D, R>,
-> {
-  // inner clock, runs constantly
-  private readonly animationFrameClock: Clock = Clock.animationFrameClock;
-  // world clock, can be paused/resumed. Stops when disposing world
-  private readonly worldClock: Clock = new Clock(this.animationFrameClock.tick$);
-
-  // TODO consider adding mouse controller
-  public readonly keyboardController: KeyboardController = new KeyboardController();
-
-  readonly children: GgEntity[] = [];
-  protected readonly tickListeners: ITickListener[] = [];
-
-  constructor(
-    public readonly visualScene: V,
-    public readonly physicsWorld: P,
-    protected readonly consoleEnabled: boolean = false,
-  ) {
-    GgStatic.instance.worlds.push(this);
-    GgStatic.instance.selectedWorld = this;
-    this.keyboardController.start().then();
-    if (consoleEnabled) {
-      this.keyboardController
-        .bind('Backquote')
-        .pipe(filter(x => x))
-        .subscribe(() => {
-          // open console UI
-          if (GgConsoleUI.instance.isUIShown) {
-            GgConsoleUI.instance.destroyUI();
-          } else {
-            GgConsoleUI.instance.createUI();
-          }
-        });
-      this.registerConsoleCommand(
-        'commandslist',
-        async () => {
-          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',
-        async (...args: string[]) => {
-          const shouldDraw = ['1', 'true', '+'].includes(args[0]);
-          if (shouldDraw != GgDebuggerUI.instance.isUIShown) {
-            if (GgDebuggerUI.instance.isUIShown) {
-              GgDebuggerUI.instance.destroyUI();
-            } else {
-              GgDebuggerUI.instance.createUI();
-            }
-          }
-          return '' + GgDebuggerUI.instance.isUIShown;
-        },
-        'args: [0 or 1]; turn on/off debug panel. Default value is 0',
-      );
-      this.registerConsoleCommand(
-        'ph_timescale',
-        async (...args: string[]) => {
-          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',
-        async (...args: string[]) => {
-          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',
-      );
-    }
-  }
-
-  public async init() {
-    await 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);
-      }
-    });
-  }
-
-  public start() {
-    this.worldClock.start();
-  }
-
-  public pauseWorld() {
-    this.worldClock.pause();
-  }
-
-  public resumeWorld() {
-    this.worldClock.pause();
-  }
-
-  public dispose(): void {
-    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();
-  }
-
-  public addEntity(entity: GgEntity): void {
-    if (!!entity.world) {
-      throw new Error('Entity already spawned');
-    }
-    this.children.push(entity);
-    if (isITickListener(entity)) {
-      this.tickListeners.push(entity as any as ITickListener);
-      this.tickListeners.sort((l1, l2) => l1.tickOrder - l2.tickOrder);
-    }
-    entity.onSpawned(this);
-  }
-
-  public removeEntity(entity: GgEntity, dispose = true): void {
-    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 (isITickListener(entity)) {
-      this.tickListeners.splice(
-        this.tickListeners.findIndex(x => (x as any) === entity),
-        1,
-      );
-    }
-    entity.onRemoved();
-    if (dispose) {
-      entity.dispose();
-    }
-  }
-
-  protected commands: { [key: string]: { handler: (...args: string[]) => Promise<string>; doc?: string } } = {};
-
-  public registerConsoleCommand(command: string, handler: (...args: string[]) => Promise<string>, doc?: string): void {
-    if (!this.consoleEnabled) {
-      throw new Error('Console not enabled for this world');
-    }
-    this.commands[command] = { handler, doc };
-  }
-
-  public async runConsoleCommand(command: string, args: string[]): Promise<string> {
-    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);
-  }
-
-  public 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());
-    }
-  }
-}

package/src/base/interfaces/gg-body.ts

@@ -1,23 +0,0 @@
-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/src/base/interfaces/gg-debug-physics-drawer.ts

@@ -1,10 +0,0 @@
-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/src/base/interfaces/gg-object.ts

@@ -1,26 +0,0 @@
-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/src/base/interfaces/gg-physics-world.ts

@@ -1,24 +0,0 @@
-import { GgDebugPhysicsDrawer } from './gg-debug-physics-drawer';
-import { GgWorld } from '../gg-world';
-
-export interface GgPhysicsWorld<D, R> {
-  readonly factory: any; // type defined in sub-interfaces
-  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/src/base/interfaces/gg-trigger.ts

@@ -1,10 +0,0 @@
-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/src/base/interfaces/gg-visual-scene.ts

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

package/src/base/math/box.ts

@@ -1,19 +0,0 @@
-import { GgBox } from '../models/geometry-nodes';
-
-export class Box {
-  static clone<T>(box: GgBox<T>): GgBox<T> {
-    return { min: { ...box.min }, max: { ...box.max } };
-  }
-  static expandByPoint<T>(box: GgBox<T>, point: T): GgBox<T> {
-    const res: GgBox<T> = 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;
-  }
-}

package/src/base/math/matrix4.ts

@@ -1,29 +0,0 @@
-import { Point3, Point4 } from '../models/points';
-import { Pnt3 } from './point3';
-
-export 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[] {
-    let z: Point3 = Pnt3.sub(eye, target);
-    if (Pnt3.lenSq(z) === 0) {
-      // same position
-      z.z = 1;
-    } else {
-      z = Pnt3.norm(z);
-    }
-    let x = Pnt3.cross(up, z);
-    if (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 = Pnt3.norm(z);
-      x = Pnt3.cross(up, z);
-    }
-    x = Pnt3.norm(x);
-    let y = 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];
-  }
-}

package/src/base/math/numbers.ts

@@ -1,10 +0,0 @@
-export const averageAngle = (angleA: number, angleB: number, factor: number = 0.5) => {
-  while (Math.abs(angleA - angleB) > Math.PI) {
-    angleB += Math.PI * (angleA > angleB ? 2 : -2);
-  }
-  return angleA * (1 - factor) + angleB * factor;
-};
-
-export const lerpNumber = (a: number, b: number, t: number) => {
-  return a + t * (b - a);
-};

package/src/base/math/point2.ts

@@ -1,43 +0,0 @@
-import { Point2 } from '../models/points';
-
-export class Pnt2 {
-  /** clone point */
-  static clone(p: Point2): Point2 {
-    return { ...p };
-  }
-
-  /** add point b to point a */
-  static add(a: Point2, b: Point2): Point2 {
-    return { x: a.x + b.x, y: a.y + b.y };
-  }
-
-  /** subtract point b from point a */
-  static sub(a: Point2, b: Point2): Point2 {
-    return { x: a.x - b.x, y: a.y - b.y };
-  }
-
-  /** normalize */
-  static norm(p: Point2): Point2 {
-    const length = Math.sqrt(p.x ** 2 + p.y ** 2);
-    return {
-      x: p.x / length,
-      y: p.y / length,
-    };
-  }
-
-  /** scalar multiplication */
-  static scalarMult(p: Point2, m: number): Point2 {
-    return {
-      x: p.x * m,
-      y: p.y * m,
-    };
-  }
-
-  /** linear interpolation */
-  static lerp(a: Point2, b: Point2, t: number): Point2 {
-    return {
-      x: a.x + t * (b.x - a.x),
-      y: a.y + t * (b.y - a.y),
-    };
-  }
-}

package/src/base/math/point3.ts

@@ -1,119 +0,0 @@
-import { Point3, Point4 } from '../models/points';
-import { Qtrn } from './quaternion';
-
-export class Pnt3 {
-  /** clone point */
-  static clone(p: Point3): Point3 {
-    return { ...p };
-  }
-
-  /** add point b to point a */
-  static add(a: Point3, b: Point3): Point3 {
-    return { x: a.x + b.x, y: a.y + b.y, z: a.z + b.z };
-  }
-
-  /** subtract point b from point a */
-  static sub(a: Point3, b: Point3): Point3 {
-    return { x: a.x - b.x, y: a.y - b.y, z: a.z - b.z };
-  }
-
-  /** calculate vector length (squared) */
-  static lenSq(v: Point3) {
-    return v.x * v.x + v.y * v.y + v.z * v.z;
-  }
-
-  /** calculate vector length */
-  static len(v: Point3) {
-    return Math.sqrt(v.x * v.x + v.y * v.y + v.z * v.z);
-  }
-
-  /** cross vectors */
-  static cross(a: Point3, b: Point3): Point3 {
-    const ax = a.x,
-      ay = a.y,
-      az = a.z;
-    const bx = b.x,
-      by = b.y,
-      bz = b.z;
-    return {
-      x: ay * bz - az * by,
-      y: az * bx - ax * bz,
-      z: ax * by - ay * bx,
-    };
-  }
-
-  /** normalize */
-  static norm(p: Point3): Point3 {
-    const length = Math.sqrt(p.x ** 2 + p.y ** 2 + p.z ** 2);
-    if (length === 0) {
-      return p;
-    }
-    return {
-      x: p.x / length,
-      y: p.y / length,
-      z: p.z / length,
-    };
-  }
-
-  /** scalar multiplication */
-  static scalarMult(p: Point3, m: number): Point3 {
-    return {
-      x: p.x * m,
-      y: p.y * m,
-      z: p.z * m,
-    };
-  }
-
-  /** linear interpolation */
-  static lerp(a: Point3, b: Point3, t: number): Point3 {
-    return {
-      x: a.x + t * (b.x - a.x),
-      y: a.y + t * (b.y - a.y),
-      z: a.z + t * (b.z - a.z),
-    };
-  }
-
-  /** rotate point a with quaternion q */
-  static rot(p: Point3, q: Point4): Point3 {
-    // faster version of:
-    // let qvec: Point4 = {x: v.x, y: v.y, z: v.z, w: 0};
-    // let qinv: Point4 = {x: -q.x, y: -q.y, z: -q.z, w: q.w};
-    // let res = Qtrn.mult(q, Qtrn.mult(qvec, qinv));
-    // return {x: res.x, y: res.y, z: res.z};
-    const { x, y, z } = p;
-    return {
-      x:
-        q.w * q.w * x +
-        2 * q.y * q.w * z -
-        2 * q.z * q.w * y +
-        q.x * q.x * x +
-        2 * q.y * q.x * y +
-        2 * q.z * q.x * z -
-        q.y * q.y * x -
-        q.z * q.z * x,
-      y:
-        2 * q.x * q.y * x +
-        q.y * q.y * y +
-        2 * q.z * q.y * z +
-        2 * q.w * q.z * x -
-        q.z * q.z * y +
-        q.w * q.w * y -
-        2 * q.x * q.w * z -
-        q.x * q.x * y,
-      z:
-        2 * q.x * q.z * x +
-        2 * q.y * q.z * y +
-        q.z * q.z * z -
-        2 * q.w * q.y * x -
-        q.y * q.y * z +
-        2 * q.w * q.x * y -
-        q.x * q.x * z +
-        q.w * q.w * z,
-    };
-  }
-
-  /** rotate point around axis a (normalized vector) */
-  static rotAround(p: Point3, axis: Point3, angle: number): Point3 {
-    return this.rot(p, Qtrn.fromAngle(axis, angle));
-  }
-}