@gg-web-engine/core 0.0.2 → 0.0.3

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

@@ -1,28 +1,102 @@
 import { Point3, Point4 } from '../models/points';
+/**
+ * Helper class with static functions, containing util functions, related to Quaternion (represented as Point4 type).
+ * In terms of rotation, a quaternion is a mathematical representation of an orientation or rotation in 3D space.
+ * It consists of a scalar component and a vector component, and can be written as q = w + xi + yj + zk, where w is the
+ * scalar component, and i, j, and k are the vector components. The scalar component, w, represents the amount of
+ * rotation, and the vector component, (x, y, z), represents the axis of rotation. The length of the vector component
+ * represents the amount of rotation around the axis. Quaternions are often used in 3D computer graphics and animation
+ * because they can be used to interpolate between two rotations, and they can avoid some of the issues with using
+ * Euler angles (such as gimbal lock).
+ */
 export declare class Qtrn {
-    /** clone quaternion */
+    /**
+     * Returns a new quaternion instance with the same values as the given quaternion object.
+     * @param q The Point4 object to clone.
+     * @returns A new Point4 instance with the same values as the given Point4 object.
+     */
     static clone(q: Point4): Point4;
-    /** add quaternion b to quaternion a */
+    /**
+     * Returns the sum of two Point4 objects.
+     * @param a The first Point4 object to add.
+     * @param b The second Point4 object to add.
+     * @returns The sum of the two Point4 objects.
+     */
     static add(a: Point4, b: Point4): Point4;
+    /**
+     * Returns the result of multiplying two Point4 objects. This can be used for combining rotations
+     * @param a The first Point4 object to multiply.
+     * @param b The second Point4 object to multiply.
+     * @returns The product of the two Point4 objects.
+     */
     static mult(a: Point4, b: Point4): Point4;
+    /**
+     * Combines an arbitrary number of quaternions by multiplying them together in order.
+     * @param quaternions The quaternions to combine.
+     * @returns The combined quaternion.
+     */
     static combineRotations(...quaternions: Point4[]): Point4;
-    /** linear interpolation */
+    /**
+     * Performs a linear interpolation between two Point4 objects.
+     * @param a The first Point4 object.
+     * @param b The second Point4 object.
+     * @param t The interpolation factor.
+     * @returns The interpolated Point4 object.
+     */
     static lerp(a: Point4, b: Point4, t: number): Point4;
-    /** spherical interpolation */
+    /**
+     * Performs a spherical linear interpolation between two Point4 objects.
+     * @param a The first Point4 object.
+     * @param b The second Point4 object.
+     * @param t The interpolation factor.
+     * @returns The interpolated Point4 object.
+     */
     static slerp(a: Point4, b: Point4, t: number): Point4;
-    /** creates quaternion from simple angle around axis. Assumes that axis vector is normalized */
+    /**
+     * Converts an angle and an axis of rotation into a quaternion
+     * @param axis the axis of rotation
+     * @param angle the angle of rotation in radians
+     * @returns a quaternion representing the rotation
+     */
     static fromAngle(axis: Point3, angle: number): {
         w: number;
         x: number;
         y: number;
         z: number;
     };
-    /** creates quaternion from 4-dimension rotation matrix */
+    /**
+     * Converts a 4x4 matrix representing a rotation into a quaternion
+     * @param m the matrix representing the rotation
+     * @returns a quaternion representing the rotation
+     */
     static fromMatrix4(m: number[]): Point4;
-    /** creates a quaternion from euler */
+    /**
+     * Creates a quaternion from euler
+     * @param e the euler vector
+     * @returns a quaternion representing the rotation
+     */
     static fromEuler(e: Point3): Point4;
-    /** converts a quaternion to euler */
+    /**
+     * Converts a quaternion to euler
+     * @param q Point4 object
+     * @returns an Euler vector, representing the same rotation
+     */
     static toEuler(q: Point4): Point3;
-    /** creates a rotation for object, so it will look at some point in space */
+    /**
+     * Returns a quaternion that represents the rotation required to align an object to face towards a target point.
+     * @param eye - The position of the camera or object that needs to be rotated to face the target point.
+     * @param target - The target point to look at
+     * @param up - The up direction of the object
+     * @returns A new quaternion representing the rotation required to face towards the target point.
+     */
     static lookAt(eye: Point3, target: Point3, up: Point3): Point4;
+    /**
+     * Returns a quaternion that represents the input quaternion, rotated around provided axis vector by provided angle.
+     * Assumes that axis vector is already normalized
+     * @param q - Input quaternion.
+     * @param axis - Axis vector
+     * @param angle - Angle
+     * @returns A new quaternion representing the updated rotation.
+     */
+    static rotAround(q: Point4, axis: Point3, angle: number): Point4;
 }

package/dist/base/math/quaternion.js

@@ -3,12 +3,31 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.Qtrn = void 0;
 const point3_1 = require("./point3");
 const matrix4_1 = require("./matrix4");
+/**
+ * Helper class with static functions, containing util functions, related to Quaternion (represented as Point4 type).
+ * In terms of rotation, a quaternion is a mathematical representation of an orientation or rotation in 3D space.
+ * It consists of a scalar component and a vector component, and can be written as q = w + xi + yj + zk, where w is the
+ * scalar component, and i, j, and k are the vector components. The scalar component, w, represents the amount of
+ * rotation, and the vector component, (x, y, z), represents the axis of rotation. The length of the vector component
+ * represents the amount of rotation around the axis. Quaternions are often used in 3D computer graphics and animation
+ * because they can be used to interpolate between two rotations, and they can avoid some of the issues with using
+ * Euler angles (such as gimbal lock).
+ */
 class Qtrn {
-    /** clone quaternion */
+    /**
+     * Returns a new quaternion instance with the same values as the given quaternion object.
+     * @param q The Point4 object to clone.
+     * @returns A new Point4 instance with the same values as the given Point4 object.
+     */
     static clone(q) {
-        return Object.assign({}, q);
+        return { x: q.x, y: q.y, z: q.z, w: q.w };
     }
-    /** add quaternion b to quaternion a */
+    /**
+     * Returns the sum of two Point4 objects.
+     * @param a The first Point4 object to add.
+     * @param b The second Point4 object to add.
+     * @returns The sum of the two Point4 objects.
+     */
     static add(a, b) {
         const w = a.w + b.w;
         const x = a.x + b.x;
@@ -17,6 +36,12 @@ class Qtrn {
         const magnitude = Math.sqrt(w * w + x * x + y * y + z * z);
         return { w: w / magnitude, x: x / magnitude, y: y / magnitude, z: z / magnitude };
     }
+    /**
+     * Returns the result of multiplying two Point4 objects. This can be used for combining rotations
+     * @param a The first Point4 object to multiply.
+     * @param b The second Point4 object to multiply.
+     * @returns The product of the two Point4 objects.
+     */
     static mult(a, b) {
         return {
             w: a.w * b.w - a.x * b.x - a.y * b.y - a.z * b.z,
@@ -25,6 +50,11 @@ class Qtrn {
             z: a.w * b.z + a.x * b.y - a.y * b.x + a.z * b.w,
         };
     }
+    /**
+     * Combines an arbitrary number of quaternions by multiplying them together in order.
+     * @param quaternions The quaternions to combine.
+     * @returns The combined quaternion.
+     */
     static combineRotations(...quaternions) {
         let result = { w: 1, x: 0, y: 0, z: 0 };
         for (const quat of quaternions) {
@@ -32,7 +62,13 @@ class Qtrn {
         }
         return result;
     }
-    /** linear interpolation */
+    /**
+     * Performs a linear interpolation between two Point4 objects.
+     * @param a The first Point4 object.
+     * @param b The second Point4 object.
+     * @param t The interpolation factor.
+     * @returns The interpolated Point4 object.
+     */
     static lerp(a, b, t) {
         return {
             x: a.x + t * (b.x - a.x),
@@ -41,7 +77,13 @@ class Qtrn {
             w: a.w + t * (b.w - a.w),
         };
     }
-    /** spherical interpolation */
+    /**
+     * Performs a spherical linear interpolation between two Point4 objects.
+     * @param a The first Point4 object.
+     * @param b The second Point4 object.
+     * @param t The interpolation factor.
+     * @returns The interpolated Point4 object.
+     */
     static slerp(a, b, t) {
         let dot = a.x * b.x + a.y * b.y + a.z * b.z + a.w * b.w;
         let theta = Math.acos(dot);
@@ -56,13 +98,22 @@ class Qtrn {
         }
         return { x, y, z, w };
     }
-    /** creates quaternion from simple angle around axis. Assumes that axis vector is normalized */
+    /**
+     * Converts an angle and an axis of rotation into a quaternion
+     * @param axis the axis of rotation
+     * @param angle the angle of rotation in radians
+     * @returns a quaternion representing the rotation
+     */
     static fromAngle(axis, angle) {
         // http://www.euclideanspace.com/maths/geometry/rotations/conversions/angleToQuaternion/index.htm
         const halfAngle = angle / 2, s = Math.sin(halfAngle);
         return Object.assign(Object.assign({}, point3_1.Pnt3.scalarMult(axis, s)), { w: Math.cos(halfAngle) });
     }
-    /** creates quaternion from 4-dimension rotation matrix */
+    /**
+     * Converts a 4x4 matrix representing a rotation into a quaternion
+     * @param m the matrix representing the rotation
+     * @returns a quaternion representing the rotation
+     */
     static fromMatrix4(m) {
         // http://www.euclideanspace.com/maths/geometry/rotations/conversions/matrixToQuaternion/index.htm
         // assumes the upper 3x3 of m is a pure rotation matrix (i.e, unscaled)
@@ -104,7 +155,11 @@ class Qtrn {
             };
         }
     }
-    /** creates a quaternion from euler */
+    /**
+     * Creates a quaternion from euler
+     * @param e the euler vector
+     * @returns a quaternion representing the rotation
+     */
     static fromEuler(e) {
         const roll = e.x;
         const pitch = e.y;
@@ -121,7 +176,11 @@ class Qtrn {
         const qz = cr * cp * sy - sr * sp * cy;
         return { w: qw, x: qx, y: qy, z: qz };
     }
-    /** converts a quaternion to euler */
+    /**
+     * Converts a quaternion to euler
+     * @param q Point4 object
+     * @returns an Euler vector, representing the same rotation
+     */
     static toEuler(q) {
         const qw = q.w;
         const qx = q.x;
@@ -137,9 +196,33 @@ class Qtrn {
         const yaw = Math.atan2(siny_cosp, cosy_cosp);
         return { x: roll, y: pitch, z: yaw };
     }
-    /** creates a rotation for object, so it will look at some point in space */
+    /**
+     * Returns a quaternion that represents the rotation required to align an object to face towards a target point.
+     * @param eye - The position of the camera or object that needs to be rotated to face the target point.
+     * @param target - The target point to look at
+     * @param up - The up direction of the object
+     * @returns A new quaternion representing the rotation required to face towards the target point.
+     */
     static lookAt(eye, target, up) {
         return this.fromMatrix4(matrix4_1.Mtrx4.lookAt(eye, target, up));
     }
+    /**
+     * Returns a quaternion that represents the input quaternion, rotated around provided axis vector by provided angle.
+     * Assumes that axis vector is already normalized
+     * @param q - Input quaternion.
+     * @param axis - Axis vector
+     * @param angle - Angle
+     * @returns A new quaternion representing the updated rotation.
+     */
+    static rotAround(q, axis, angle) {
+        const sinHalfAngle = Math.sin(angle / 2);
+        const rotationQuat = {
+            w: Math.cos(angle / 2),
+            x: axis.x * sinHalfAngle,
+            y: axis.y * sinHalfAngle,
+            z: axis.z * sinHalfAngle,
+        };
+        return this.mult(rotationQuat, q);
+    }
 }
 exports.Qtrn = Qtrn;

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

@@ -1,15 +1,15 @@
 export declare type Point2 = {
-    x: number;
-    y: number;
+    readonly x: number;
+    readonly y: number;
 };
 export declare type Point3 = {
-    x: number;
-    y: number;
-    z: number;
+    readonly x: number;
+    readonly y: number;
+    readonly z: number;
 };
 export declare type Point4 = {
-    x: number;
-    y: number;
-    z: number;
-    w: number;
+    readonly x: number;
+    readonly y: number;
+    readonly z: number;
+    readonly w: number;
 };

package/dist/index.d.ts

@@ -1,6 +1,8 @@
-export * from './base/clock';
+export * from './base/clock/clock';
+export * from './base/clock/global-clock';
 export * from './base/gg-viewport';
 export * from './base/gg-viewport-manager';
+export * from './base/entities/controllers/animation-mixer';
 export * from './base/entities/interfaces/i-tick-listener';
 export * from './base/entities/gg-entity';
 export * from './base/entities/base-gg-renderer';
@@ -25,6 +27,7 @@ export * from './base/controllers/common';
 export * from './base/controllers/i-controller';
 export * from './base/controllers/keyboard.controller';
 export * from './base/controllers/mouse.controller';
+export * from './2d/entities/controllers/entity-2d-positioning.animator';
 export * from './2d/entities/gg-2d-entity';
 export * from './2d/entities/gg-positionable-2d-entity';
 export * from './2d/entities/gg-2d-trigger.entity';
@@ -35,7 +38,8 @@ export * from './2d/factories';
 export * from './2d/gg-2d-world';
 export * from './3d/controllers/car-keyboard.controller';
 export * from './3d/controllers/free-camera.controller';
-export * from './3d/entities/controllers/entity-motion.controller';
+export * from './3d/entities/controllers/camera-3d.animator';
+export * from './3d/entities/controllers/entity-3d-positioning.animator';
 export * from './3d/entities/gg-3d-entity';
 export * from './3d/entities/gg-positionable-3d-entity';
 export * from './3d/entities/gg-3d-camera.entity';

package/dist/index.js

@@ -14,9 +14,11 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-__exportStar(require("./base/clock"), exports);
+__exportStar(require("./base/clock/clock"), exports);
+__exportStar(require("./base/clock/global-clock"), exports);
 __exportStar(require("./base/gg-viewport"), exports);
 __exportStar(require("./base/gg-viewport-manager"), exports);
+__exportStar(require("./base/entities/controllers/animation-mixer"), exports);
 __exportStar(require("./base/entities/interfaces/i-tick-listener"), exports);
 __exportStar(require("./base/entities/gg-entity"), exports);
 __exportStar(require("./base/entities/base-gg-renderer"), exports);
@@ -41,6 +43,7 @@ __exportStar(require("./base/controllers/common"), exports);
 __exportStar(require("./base/controllers/i-controller"), exports);
 __exportStar(require("./base/controllers/keyboard.controller"), exports);
 __exportStar(require("./base/controllers/mouse.controller"), exports);
+__exportStar(require("./2d/entities/controllers/entity-2d-positioning.animator"), exports);
 __exportStar(require("./2d/entities/gg-2d-entity"), exports);
 __exportStar(require("./2d/entities/gg-positionable-2d-entity"), exports);
 __exportStar(require("./2d/entities/gg-2d-trigger.entity"), exports);
@@ -51,7 +54,8 @@ __exportStar(require("./2d/factories"), exports);
 __exportStar(require("./2d/gg-2d-world"), exports);
 __exportStar(require("./3d/controllers/car-keyboard.controller"), exports);
 __exportStar(require("./3d/controllers/free-camera.controller"), exports);
-__exportStar(require("./3d/entities/controllers/entity-motion.controller"), exports);
+__exportStar(require("./3d/entities/controllers/camera-3d.animator"), exports);
+__exportStar(require("./3d/entities/controllers/entity-3d-positioning.animator"), exports);
 __exportStar(require("./3d/entities/gg-3d-entity"), exports);
 __exportStar(require("./3d/entities/gg-positionable-3d-entity"), exports);
 __exportStar(require("./3d/entities/gg-3d-camera.entity"), exports);

package/package.json

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

package/.prettierrc

@@ -1,8 +0,0 @@
-{
-  "semi": true,
-  "trailingComma": "all",
-  "singleQuote": true,
-  "bracketSameLine":true,
-  "printWidth": 120,
-  "arrowParens": "avoid"
-}