@gg-web-engine/core 0.0.56 → 0.0.58

package/dist/base/math/numbers.js

@@ -1,4 +1,10 @@
-export const averageAngle = (angleA, angleB, factor = 0.5) => {
+export const averageAngle = (angleA, angleB) => {
+    while (Math.abs(angleA - angleB) > Math.PI) {
+        angleB += Math.PI * (angleA > angleB ? 2 : -2);
+    }
+    return (angleA + angleB) / 2;
+};
+export const lerpAngle = (angleA, angleB, factor) => {
     while (Math.abs(angleA - angleB) > Math.PI) {
         angleB += Math.PI * (angleA > angleB ? 2 : -2);
     }

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

@@ -1,4 +1,4 @@
-import { Point2 } from '../models/points';
+import { Point2, Polar } from '../models/points';
 export declare class Pnt2 {
     /** empty vector */
     static get O(): Point2;
@@ -36,12 +36,30 @@ export declare class Pnt2 {
     static norm(p: Point2): Point2;
     /** scalar multiplication */
     static scalarMult(p: Point2, m: number): Point2;
+    /** dot multiplication */
+    static dot(a: Point2, b: Point2): number;
     /** linear interpolation */
     static lerp(a: Point2, b: Point2, t: number): Point2;
+    /** linear interpolation (spherical/polar) */
+    static slerp(a: Point2, b: Point2, t: number): Point2;
     /** angle between vectors in radians */
     static angle(a: Point2, b: Point2): number;
     /** rotate point around zero by provided angle */
     static rot(p: Point2, angle: number): Point2;
     /** rotate point around pivot by provided angle */
     static rotAround(p: Point2, pivot: Point2, angle: number): Point2;
+    /**
+     * Converts a cartesian 2D point to a polar coordinate system,
+     * phi == 0 is faced towards X axis direction
+     * @param p - The cartesian 2D point.
+     * @returns The polar coordinates as an object with radius and phi properties.
+     */
+    static toPolar(p: Point2): Polar;
+    /**
+     * Converts a polar coordinate system to a cartesian 2D point. Used polar coordinates,
+     * where phi == 0 is faced towards X axis direction
+     * @param p - The polar coordinate system.
+     * @returns The cartesian 2D point as an object with x and y properties.
+     */
+    static fromPolar(p: Polar): Point2;
 }

package/dist/base/math/point2.js

@@ -1,3 +1,4 @@
+import { lerpAngle } from './numbers';
 export class Pnt2 {
     /** empty vector */
     static get O() {
@@ -78,6 +79,10 @@ export class Pnt2 {
             y: p.y * m,
         };
     }
+    /** dot multiplication */
+    static dot(a, b) {
+        return a.x * b.x + a.y * b.y;
+    }
     /** linear interpolation */
     static lerp(a, b, t) {
         return {
@@ -85,11 +90,19 @@ export class Pnt2 {
             y: a.y + t * (b.y - a.y),
         };
     }
+    /** linear interpolation (spherical/polar) */
+    static slerp(a, b, t) {
+        const as = Pnt2.toPolar(a);
+        const bs = Pnt2.toPolar(b);
+        return Pnt2.fromPolar({
+            radius: as.radius + t * (bs.radius - as.radius),
+            phi: lerpAngle(as.phi, bs.phi, t),
+        });
+    }
     /** angle between vectors in radians */
     static angle(a, b) {
-        const dotProduct = a.x * b.x + a.y * b.y;
-        const magnitudeProduct = Math.sqrt(a.x ** 2 + a.y ** 2) * Math.sqrt(b.x ** 2 + b.y ** 2);
-        return Math.acos(dotProduct / magnitudeProduct);
+        const magnitudeProduct = Pnt2.len(a) * Pnt2.len(b);
+        return Math.acos(Pnt2.dot(a, b) / magnitudeProduct);
     }
     /** rotate point around zero by provided angle */
     static rot(p, angle) {
@@ -110,4 +123,29 @@ export class Pnt2 {
             y: p0.x * sin + p0.y * cos + pivot.y,
         };
     }
+    /**
+     * Converts a cartesian 2D point to a polar coordinate system,
+     * phi == 0 is faced towards X axis direction
+     * @param p - The cartesian 2D point.
+     * @returns The polar coordinates as an object with radius and phi properties.
+     */
+    static toPolar(p) {
+        const radius = Math.sqrt(p.x * p.x + p.y * p.y);
+        return {
+            radius,
+            phi: radius == 0 ? 0 : Math.atan2(p.y, p.x),
+        };
+    }
+    /**
+     * Converts a polar coordinate system to a cartesian 2D point. Used polar coordinates,
+     * where phi == 0 is faced towards X axis direction
+     * @param p - The polar coordinate system.
+     * @returns The cartesian 2D point as an object with x and y properties.
+     */
+    static fromPolar(p) {
+        return {
+            x: p.radius * Math.cos(p.phi),
+            y: p.radius * Math.sin(p.phi),
+        };
+    }
 }

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

@@ -42,8 +42,12 @@ export declare class Pnt3 {
     static norm(p: Point3): Point3;
     /** scalar multiplication */
     static scalarMult(p: Point3, m: number): Point3;
+    /** dot multiplication */
+    static dot(a: Point3, b: Point3): number;
     /** linear interpolation */
     static lerp(a: Point3, b: Point3, t: number): Point3;
+    /** linear interpolation (spherical) */
+    static slerp(a: Point3, b: Point3, t: number): Point3;
     /** angle between vectors in radians */
     static angle(a: Point3, b: Point3): number;
     /** rotate point a with quaternion q */

package/dist/base/math/point3.js

@@ -1,4 +1,5 @@
 import { Qtrn } from './quaternion';
+import { lerpAngle } from './numbers';
 export class Pnt3 {
     /** empty vector */
     static get O() {
@@ -102,6 +103,10 @@ export class Pnt3 {
             z: p.z * m,
         };
     }
+    /** dot multiplication */
+    static dot(a, b) {
+        return a.x * b.x + a.y * b.y + a.z * b.z;
+    }
     /** linear interpolation */
     static lerp(a, b, t) {
         return {
@@ -110,11 +115,23 @@ export class Pnt3 {
             z: a.z + t * (b.z - a.z),
         };
     }
+    /** linear interpolation (spherical) */
+    static slerp(a, b, t) {
+        const as = Pnt3.toSpherical(a);
+        const bs = Pnt3.toSpherical(b);
+        return Pnt3.fromSpherical({
+            radius: as.radius + t * (bs.radius - as.radius),
+            phi: lerpAngle(as.phi, bs.phi, t),
+            theta: lerpAngle(as.theta, bs.theta, t),
+        });
+    }
     /** angle between vectors in radians */
     static angle(a, b) {
-        const dotProduct = a.x * b.x + a.y * b.y + a.z * b.z;
-        const magnitudeProduct = Math.sqrt(a.x ** 2 + a.y ** 2 + a.z ** 2) * Math.sqrt(b.x ** 2 + b.y ** 2 + b.z ** 2);
-        return Math.acos(dotProduct / magnitudeProduct);
+        const magnitudeProduct = Pnt3.len(a) * Pnt3.len(b);
+        let cos = Pnt3.dot(a, b) / magnitudeProduct;
+        // this can happen due to precision error
+        cos = Math.min(1, Math.max(cos, -1));
+        return Math.acos(cos);
     }
     /** rotate point a with quaternion q */
     static rot(p, q) {

package/dist/base/models/body-options.d.ts

@@ -4,15 +4,33 @@ export interface BodyOptions {
     mass: number;
     restitution: number;
     friction: number;
-    ownCollisionGroups: CollisionGroup[] | 'all';
-    interactWithCollisionGroups: CollisionGroup[] | 'all';
+    ownCollisionGroups: ReadonlyArray<CollisionGroup> | 'all';
+    interactWithCollisionGroups: ReadonlyArray<CollisionGroup> | 'all';
 }
-export type DebugBodySettings = {
-    shape: any;
-    ignoreTransform?: boolean;
-} & ({
-    type: 'RIGID_STATIC' | 'TRIGGER';
+export type DebugBodyType = {
+    type: 'RIGID_STATIC';
+} | {
+    type: 'TRIGGER';
+    activated: () => boolean;
 } | {
     type: 'RIGID_DYNAMIC';
-    sleeping: boolean;
-});
+    sleeping: () => boolean;
+};
+export declare abstract class DebugBodySettings<S> {
+    private _type;
+    private _shape;
+    private _ignoreTransform;
+    private _color;
+    private _revision;
+    get revision(): number;
+    get type(): DebugBodyType;
+    set type(value: DebugBodyType);
+    get shape(): S;
+    set shape(value: S);
+    get ignoreTransform(): boolean;
+    set ignoreTransform(value: boolean);
+    private lastRetrievedColorCache;
+    get color(): number;
+    set color(value: number | undefined);
+    protected constructor(_type: DebugBodyType, _shape: S, _ignoreTransform?: boolean, _color?: number | undefined);
+}

package/dist/base/models/body-options.js

@@ -1 +1,65 @@
-export {};
+export class DebugBodySettings {
+    get revision() {
+        // force check of color
+        let _ = this.color;
+        return this._revision;
+    }
+    get type() {
+        return this._type;
+    }
+    set type(value) {
+        this._type = value;
+        this._revision++;
+    }
+    get shape() {
+        return this._shape;
+    }
+    set shape(value) {
+        this._shape = value;
+        this._revision++;
+    }
+    get ignoreTransform() {
+        return this._ignoreTransform;
+    }
+    set ignoreTransform(value) {
+        this._ignoreTransform = value;
+        this._revision++;
+    }
+    get color() {
+        let color = 0;
+        if (this._color !== undefined) {
+            color = this._color;
+        }
+        else {
+            switch (this.type.type) {
+                case 'RIGID_DYNAMIC':
+                    color = this.type.sleeping() ? 0x0000ff : 0xff0000;
+                    break;
+                case 'RIGID_STATIC':
+                    color = 0x00ff00;
+                    break;
+                case 'TRIGGER':
+                    color = this.type.activated() ? 0xff9900 : 0xffff00;
+                    break;
+            }
+        }
+        if (color !== this.lastRetrievedColorCache) {
+            this._revision++;
+            this.lastRetrievedColorCache = color;
+        }
+        return color;
+    }
+    set color(value) {
+        this._color = value;
+    }
+    constructor(_type, _shape, _ignoreTransform = false, _color = undefined) {
+        this._type = _type;
+        this._shape = _shape;
+        this._ignoreTransform = _ignoreTransform;
+        this._color = _color;
+        // this value changes on each change inside the settings.
+        // Debug view skips updating anything if value stays the same
+        this._revision = 0;
+        this.lastRetrievedColorCache = 0;
+    }
+}

package/dist/base/models/points.d.ts

@@ -1,25 +1,29 @@
-export type Point2 = {
-    readonly x: number;
-    readonly y: number;
+export type MutablePoint2 = {
+    x: number;
+    y: number;
 };
-export type Point3 = {
-    readonly x: number;
-    readonly y: number;
-    readonly z: number;
+export type MutablePoint3 = {
+    x: number;
+    y: number;
+    z: number;
 };
-export type Point4 = {
-    readonly x: number;
-    readonly y: number;
-    readonly z: number;
-    readonly w: number;
+export type MutablePoint4 = {
+    x: number;
+    y: number;
+    z: number;
+    w: number;
 };
-export type Spherical = {
-    readonly radius: number;
-    readonly phi: number;
-    readonly theta: number;
+export type MutablePolar = {
+    radius: number;
+    phi: number;
 };
 export type MutableSpherical = {
     radius: number;
     phi: number;
     theta: number;
 };
+export type Point2 = Readonly<MutablePoint2>;
+export type Point3 = Readonly<MutablePoint3>;
+export type Point4 = Readonly<MutablePoint4>;
+export type Polar = Readonly<MutablePolar>;
+export type Spherical = Readonly<MutableSpherical>;

package/dist/base/models/raycasting.d.ts

@@ -0,0 +1,52 @@
+import { CollisionGroup } from './body-options';
+/**
+ * Interface representing the result of a raycast operation.
+ *
+ * @template D - Data type used for representing physics properties (Point3 for 3D, Point2 for 2D).
+ * @template B - Type representing the physics engine's body object.
+ */
+export interface RaycastResult<D, B> {
+    /**
+     * Whether the ray hit something.
+     */
+    hasHit: boolean;
+    /**
+     * The hit body, if any.
+     */
+    hitBody?: B;
+    /**
+     * The hit point in world space, if any.
+     */
+    hitPoint?: D;
+    /**
+     * The hit normal in world space, if any.
+     */
+    hitNormal?: D;
+    /**
+     * The distance from the ray origin to the hit point, if any.
+     */
+    hitDistance?: number;
+}
+/**
+ * Interface representing options for a raycast operation.
+ *
+ * @template D - Data type used for representing physics properties (typically Point3 for 3D).
+ */
+export interface RaycastOptions<D> {
+    /**
+     * The starting point of the ray.
+     */
+    from: D;
+    /**
+     * The end point of the ray.
+     */
+    to: D;
+    /**
+     * Optional collision filter groups for the ray.
+     */
+    collisionFilterGroups?: CollisionGroup[];
+    /**
+     * Optional collision filter mask for the ray.
+     */
+    collisionFilterMask?: CollisionGroup[];
+}

package/dist/base/models/raycasting.js

@@ -0,0 +1 @@
+export {};

package/dist/dev/gg-debugger.ui.js

@@ -1,4 +1,4 @@
-import { createInlineTickController, IRendererEntity } from '../base';
+import { createInlineTickController } from '../base';
 import { animationFrameScheduler, fromEvent, of, Subject, takeUntil } from 'rxjs';
 import Stats from 'stats.js';
 import { repeat } from 'rxjs/operators';
@@ -139,19 +139,11 @@ export class GgDebuggerUI {
         }
     }
     makeSnapshot() {
-        var _a, _b;
-        const renderers = [];
-        let performanceMeter = null;
-        for (const e of ((_a = this.currentWorld) === null || _a === void 0 ? void 0 : _a.children) || []) {
-            if (e instanceof IRendererEntity) {
-                renderers.push(e);
-            }
-            else if (e instanceof PerformanceMeterEntity) {
-                performanceMeter = e;
-            }
-        }
+        var _a, _b, _c;
+        const renderers = ((_a = this.currentWorld) === null || _a === void 0 ? void 0 : _a.renderers) || [];
+        let performanceMeter = (((_b = this.currentWorld) === null || _b === void 0 ? void 0 : _b.children) || []).find(e => e instanceof PerformanceMeterEntity);
         return {
-            timeScale: ((_b = this.currentWorld) === null || _b === void 0 ? void 0 : _b.worldClock.timeScale) || NaN,
+            timeScale: ((_c = this.currentWorld) === null || _c === void 0 ? void 0 : _c.worldClock.timeScale) || NaN,
             renderers: renderers.map(r => ({
                 name: r.name,
                 entity: r,

package/dist/version.d.ts

@@ -1 +1 @@
-export declare const VERSION = "0.0.56";
+export declare const VERSION = "0.0.58";

package/dist/version.js

@@ -1 +1 @@
-export const VERSION = '0.0.56';
+export const VERSION = '0.0.58';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gg-web-engine/core",
-  "version": "0.0.56",
+  "version": "0.0.58",
   "description": "An attempt to create open source game engine for browser",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",