@gg-web-engine/core 0.0.57 → 0.0.58

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

@@ -1,5 +1,6 @@
 import { IDisplayObjectComponent, IEntity, IPhysicsWorldComponent, IPositionable, IRenderableEntity, IRendererComponent, IRendererEntity, IRigidBodyComponent, ITriggerComponent, IVisualSceneComponent, KeyboardInput, PausableClock } from '../base';
 import { Subject } from 'rxjs';
+import { IVisualScene2dComponent, VisualTypeDocRepo2D } from '../2d';
 export type VisualTypeDocRepo<D, R> = {
     factory: unknown;
     displayObject: IDisplayObjectComponent<D, R>;
@@ -11,13 +12,33 @@ export type PhysicsTypeDocRepo<D, R> = {
     rigidBody: IRigidBodyComponent<D, R>;
     trigger: ITriggerComponent<D, R>;
 };
-export declare abstract class GgWorld<D, R, VTypeDoc extends VisualTypeDocRepo<D, R> = VisualTypeDocRepo<D, R>, PTypeDoc extends PhysicsTypeDocRepo<D, R> = PhysicsTypeDocRepo<D, R>, VS extends IVisualSceneComponent<D, R, VTypeDoc> = IVisualSceneComponent<D, R, VTypeDoc>, PW extends IPhysicsWorldComponent<D, R, PTypeDoc> = IPhysicsWorldComponent<D, R, PTypeDoc>> {
-    readonly visualScene: VS;
-    readonly physicsWorld: PW;
+export type GgWorldTypeDocRepo<D, R> = {
+    vTypeDoc: VisualTypeDocRepo<D, R>;
+    pTypeDoc: PhysicsTypeDocRepo<D, R>;
+};
+export type GgWorldTypeDocVPatch<D, R, VTypeDoc extends VisualTypeDocRepo<D, R>> = Omit<GgWorldTypeDocRepo<D, R>, 'vTypeDoc'> & {
+    vTypeDoc: VTypeDoc;
+};
+export type GgWorldTypeDocPPatch<D, R, PTypeDoc extends PhysicsTypeDocRepo<D, R>> = Omit<GgWorldTypeDocRepo<D, R>, 'pTypeDoc'> & {
+    pTypeDoc: PTypeDoc;
+};
+export type GgWorldSceneTypeRepo<D, R, TypeDoc extends GgWorldTypeDocRepo<D, R> = GgWorldTypeDocRepo<D, R>> = {
+    visualScene: IVisualSceneComponent<D, R, TypeDoc['vTypeDoc']> | null;
+    physicsWorld: IPhysicsWorldComponent<D, R, TypeDoc['pTypeDoc']> | null;
+};
+export type GgWorldSceneTypeDocVPatch<D, R, VTypeDoc extends VisualTypeDocRepo2D, VS extends IVisualScene2dComponent<VTypeDoc> | null> = Omit<GgWorldSceneTypeRepo<D, R>, 'visualScene'> & {
+    visualScene: VS;
+};
+export type GgWorldSceneTypeDocPPatch<D, R, PTypeDoc extends PhysicsTypeDocRepo<D, R>, PW extends IPhysicsWorldComponent<D, R, PTypeDoc> | null> = Omit<GgWorldSceneTypeRepo<D, R>, 'physicsWorld'> & {
+    physicsWorld: PW;
+};
+export declare abstract class GgWorld<D, R, TypeDoc extends GgWorldTypeDocRepo<D, R> = GgWorldTypeDocRepo<D, R>, SceneTypeDoc extends GgWorldSceneTypeRepo<D, R, TypeDoc> = GgWorldSceneTypeRepo<D, R, TypeDoc>> {
     private static default_name_counter;
     private static _documentWorlds;
     static readonly worldCreated$: Subject<GgWorld<any, any>>;
     static get documentWorlds(): GgWorld<any, any>[];
+    readonly visualScene: SceneTypeDoc['visualScene'];
+    readonly physicsWorld: SceneTypeDoc['physicsWorld'];
     readonly worldClock: PausableClock;
     readonly keyboardInput: KeyboardInput;
     name: string;
@@ -29,7 +50,10 @@ export declare abstract class GgWorld<D, R, VTypeDoc extends VisualTypeDocRepo<D
     readonly tickForwardedTo$: Subject<IEntity | 'PHYSICS_WORLD'>;
     readonly paused$: Subject<boolean>;
     readonly disposed$: Subject<void>;
-    protected constructor(visualScene: VS, physicsWorld: PW);
+    protected constructor(args: {
+        visualScene?: SceneTypeDoc['visualScene'];
+        physicsWorld?: SceneTypeDoc['physicsWorld'];
+    });
     init(): Promise<void>;
     start(): void;
     pauseWorld(): void;
@@ -40,7 +64,7 @@ export declare abstract class GgWorld<D, R, VTypeDoc extends VisualTypeDocRepo<D
     createClock(autoStart: boolean): PausableClock;
     dispose(): void;
     abstract addPrimitiveRigidBody(descr: unknown, // type defined in subclasses
-    position?: D, rotation?: R, material?: unknown): IPositionable<D, R> & IRenderableEntity<D, R, VTypeDoc>;
+    position?: D, rotation?: R, material?: unknown): IPositionable<D, R> & IRenderableEntity<D, R, TypeDoc>;
     addEntity(entity: IEntity): void;
     removeEntity(entity: IEntity, dispose?: boolean): void;
     private onGgStaticInitialized;

package/dist/base/gg-world.js

@@ -17,9 +17,7 @@ export class GgWorld {
     get renderers() {
         return this.tickListeners.filter(e => e instanceof IRendererEntity);
     }
-    constructor(visualScene, physicsWorld) {
-        this.visualScene = visualScene;
-        this.physicsWorld = physicsWorld;
+    constructor(args) {
         this.worldClock = new PausableClock(false);
         this.keyboardInput = new KeyboardInput();
         this.name = 'w0x' + (GgWorld.default_name_counter++).toString(16);
@@ -32,6 +30,8 @@ export class GgWorld {
         this.tickForwardedTo$ = new Subject();
         this.paused$ = new Subject();
         this.disposed$ = new Subject();
+        this.visualScene = args.visualScene || null;
+        this.physicsWorld = args.physicsWorld || null;
         this.keyboardInput.start();
         if (window.ggstatic) {
             this.registerConsoleCommands(window.ggstatic);
@@ -46,7 +46,14 @@ export class GgWorld {
     }
     init() {
         return __awaiter(this, void 0, void 0, function* () {
-            yield Promise.all([this.physicsWorld.init(), this.visualScene.init()]);
+            const initPromises = [];
+            if (this.visualScene) {
+                initPromises.push(this.visualScene.init());
+            }
+            if (this.physicsWorld) {
+                initPromises.push(this.physicsWorld.init());
+            }
+            yield Promise.all(initPromises);
             const forwardTick = (listener, elapsed, delta) => {
                 if (listener.active) {
                     this.tickForwardTo$.next(listener);
@@ -65,9 +72,11 @@ export class GgWorld {
                     forwardTick(this.tickListeners[i], elapsed, delta);
                 }
                 // run physics simulation
-                this.tickForwardTo$.next('PHYSICS_WORLD');
-                this.physicsWorld.simulate(delta);
-                this.tickForwardedTo$.next('PHYSICS_WORLD');
+                if (this.physicsWorld) {
+                    this.tickForwardTo$.next('PHYSICS_WORLD');
+                    this.physicsWorld.simulate(delta);
+                    this.tickForwardedTo$.next('PHYSICS_WORLD');
+                }
                 // emit tick to all remained entities
                 for (i; i < this.tickListeners.length; i++) {
                     forwardTick(this.tickListeners[i], elapsed, delta);
@@ -114,8 +123,12 @@ export class GgWorld {
         }
         this.children.splice(0, this.children.length);
         this.tickListeners.splice(0, this.tickListeners.length);
-        this.physicsWorld.dispose();
-        this.visualScene.dispose();
+        if (this.physicsWorld) {
+            this.physicsWorld.dispose();
+        }
+        if (this.visualScene) {
+            this.visualScene.dispose();
+        }
         GgWorld._documentWorlds.splice(GgWorld._documentWorlds.indexOf(this), 1);
         this.disposed$.next();
         this.disposed$.complete();

package/dist/base/index.d.ts

@@ -26,6 +26,7 @@ export * from './models/axis-directions';
 export * from './models/body-options';
 export * from './models/geometry-nodes';
 export * from './models/points';
+export * from './models/raycasting';
 export * from './math/box';
 export * from './math/point2';
 export * from './math/point3';

package/dist/base/index.js

@@ -26,6 +26,7 @@ export * from './models/axis-directions';
 export * from './models/body-options';
 export * from './models/geometry-nodes';
 export * from './models/points';
+export * from './models/raycasting';
 export * from './math/box';
 export * from './math/point2';
 export * from './math/point3';

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

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

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;
@@ -40,10 +40,26 @@ export declare class Pnt2 {
     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() {
@@ -89,6 +90,15 @@ 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 magnitudeProduct = Pnt2.len(a) * Pnt2.len(b);
@@ -113,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

@@ -46,6 +46,8 @@ export declare class Pnt3 {
     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() {
@@ -114,10 +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 magnitudeProduct = Pnt3.len(a) * Pnt3.len(b);
-        return Math.acos(Pnt3.dot(a, b) / magnitudeProduct);
+        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/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/version.d.ts

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

package/dist/version.js

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

package/package.json

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