bg2e-js 2.1.2 → 2.2.0

package/src/math/constants.ts

@@ -0,0 +1,47 @@
+export enum Axis {
+	NONE = 0,
+	X = 1,
+	Y = 2,
+	Z = 3,
+	W = 4
+}
+
+export namespace Axis {
+	export function name(axis: Axis): string {
+		switch (axis) {
+		case Axis.NONE:
+			return "NONE";
+		case Axis.X:
+			return "X";
+		case Axis.Y:
+			return "Y";
+		case Axis.Z:
+			return "Z";
+		case Axis.W:
+			return "W";
+		default:
+			return "UNKNOWN";
+		}
+	}
+}
+
+export const PI: number = 3.141592653589793;
+export const DEG_TO_RAD: number = 0.01745329251994;
+export const RAD_TO_DEG: number = 57.29577951308233;
+export const PI_2: number = 1.5707963267948966;
+export const PI_4: number = 0.785398163397448;
+export const PI_8: number = 0.392699081698724;
+export const TWO_PI: number = 6.283185307179586;
+export const EPSILON: number = 0.0000001;
+
+// Default array: 32 bits
+export const NumericArray: Float32ArrayConstructor = Float32Array;
+export const NumericArrayHighP: Float64ArrayConstructor = Float64Array;
+export const FLOAT_MAX: number = 3.402823e38;
+
+export const checkArray = (array: ArrayLike<any> | number, length: number): boolean => {
+    if ((array as ArrayLike<any>).length >= length) {
+        return true;
+    }
+    return false;
+}

package/src/math/functions.ts

@@ -0,0 +1,103 @@
+import {
+    EPSILON,
+    DEG_TO_RAD,
+    RAD_TO_DEG
+} from './constants.js';
+
+let s_bg_math_seed: number = Date.now();
+
+export const checkPowerOfTwo = (n: any): boolean => {
+    if (typeof n !== 'number') {
+        return false;
+    }
+    else {
+        return n !== 0 && (n & (n - 1)) === 0;
+    }  
+}
+
+export const checkZero = (v: number): number => {
+    return v>-EPSILON && v<EPSILON ? 0:v;
+}
+
+export const isZero = (v: number): boolean => {
+    return checkZero(v) === 0;
+}
+
+export const equals = (a: number, b: number): boolean => {
+    return Math.abs(a - b) < EPSILON;
+}
+
+export const degreesToRadians = (d: number): number => {
+    return Math.fround(checkZero(d * DEG_TO_RAD));
+}
+
+export const radiansToDegrees = (r: number): number => {
+    return Math.fround(checkZero(r * RAD_TO_DEG));
+}
+
+export const sin = (val: number): number => {
+    return Math.fround(checkZero(Math.sin(val)));
+}
+
+export const cos = (val: number): number => {
+    return Math.fround(checkZero(Math.cos(val)));
+}
+
+export const tan = (val: number): number => {
+    return Math.fround(checkZero(Math.tan(val)));
+}
+
+export const cotan = (val: number): number => {
+    return Math.fround(checkZero(1.0 / tan(val)));
+}
+
+export const atan = (val: number): number => {
+    return Math.fround(checkZero(Math.atan(val)));
+}
+
+export const atan2 = (i: number, j: number): number => {
+    return Math.fround(checkZero(Math.atan2(i, j)));
+}
+
+export const random = (): number => {
+    return Math.random();
+}
+
+export const seededRandom = (): number => {
+    const max: number = 1;
+    const min: number = 0;
+ 
+    s_bg_math_seed = (s_bg_math_seed * 9301 + 49297) % 233280;
+    const rnd: number = s_bg_math_seed / 233280;
+ 
+    return min + rnd * (max - min);
+}
+
+export const max = (a: number, b: number): number => {
+    return Math.fround(Math.max(a,b));
+}
+
+export const min = (a: number, b: number): number => {
+    return Math.fround(Math.min(a,b));
+}
+
+export const abs = (val: number): number => {
+    return Math.fround(Math.abs(val));
+}
+
+export const sqrt = (val: number): number => {
+    return Math.fround(Math.sqrt(val));
+}
+
+export const lerp = (from: number, to: number, t: number): number => {
+    t = t > 1 ? 1 : t;
+    return Math.fround((1.0 - t) * from + t * to);
+}
+
+export const square = (n: number): number => {
+    return Math.fround(n * n);
+}
+
+export const clamp = (value: number, min: number, max: number): number => {
+    return Math.fround(Math.max(min, Math.min(value, max)));
+}

package/src/math/index.ts

@@ -0,0 +1,74 @@
+
+import {
+    Axis,
+    PI,
+    DEG_TO_RAD,
+    RAD_TO_DEG,
+    PI_2,
+    PI_4,
+    PI_8,
+    TWO_PI,
+    EPSILON,
+    NumericArray,
+    NumericArrayHighP,
+    FLOAT_MAX
+} from "./constants.js";
+
+import {
+    checkPowerOfTwo,
+    checkZero,
+    isZero,
+    equals,
+    degreesToRadians,
+    radiansToDegrees,
+    sin,
+    cos,
+    tan,
+    cotan,
+    atan,
+    atan2,
+    random,
+    seededRandom,
+    max,
+    min,
+    abs,
+    sqrt,
+    lerp,
+    square
+} from "./functions.js";
+
+export default {
+    Axis,
+    PI,
+    DEG_TO_RAD,
+    RAD_TO_DEG,
+    PI_2,
+    PI_4,
+    PI_8,
+    TWO_PI,
+    EPSILON,
+    NumericArray,
+    NumericArrayHighP,
+    FLOAT_MAX,
+
+    checkPowerOfTwo,
+    checkZero,
+    isZero,
+    equals,
+    degreesToRadians,
+    radiansToDegrees,
+    sin,
+    cos,
+    tan,
+    cotan,
+    atan,
+    atan2,
+    random,
+    seededRandom,
+    max,
+    min,
+    abs,
+    sqrt,
+    lerp,
+    square
+};

package/src/phsics/joint.ts

@@ -0,0 +1,137 @@
+import Vec from '../math/Vec';
+import Mat4 from '../math/Mat4';
+
+export default class Joint {
+    protected _transform: Mat4;
+
+    static Factory(linkData?: any): Joint | null {
+        if (!linkData || !linkData.type) { 
+            return null;
+        }
+        let result: Joint | null = null;
+        switch (linkData.type) {
+        case 'LinkJoint':
+            result = new LinkJoint();
+            result.deserialize(linkData);
+            break;
+        }
+        return result;
+    }
+
+    constructor() {
+        this._transform = Mat4.MakeIdentity();
+    }
+
+    get transform(): Mat4 { return this._transform; }
+    set transform(t: Mat4) { this._transform.assign(t); }
+
+    applyTransform(matrix: Mat4): void {
+
+    }
+
+    calculateTransform(): void {
+
+    }
+
+    deserialize(linkData: any): void {
+
+    }
+}
+
+export const LinkTransformOrder = {
+    TRANSLATE_ROTATE: 1,
+    ROTATE_TRANSLATE: 0
+};
+
+export class LinkJoint extends Joint {
+    private _offset: Vec;
+    private _eulerRotation: Vec;
+    private _transformOrder: number;
+
+    constructor() {
+        super();
+        this._offset = new Vec(0, 0, 0);
+        this._eulerRotation = new Vec(0, 0, 0);
+        this._transformOrder = LinkTransformOrder.TRANSLATE_ROTATE;
+    }
+
+    get offset(): Vec { return this._offset; }
+    set offset(o: Vec | number[]) { this._offset = new Vec(o); this.calculateTransform(); }
+
+    get eulerRotation(): Vec { return this._eulerRotation; }
+    set eulerRotation(e: Vec | number[]) { this._eulerRotation = new Vec(e); this.calculateTransform(); }
+
+    get yaw(): number { return this._eulerRotation.x; }
+    get pitch(): number { return this._eulerRotation.y; }
+    get roll(): number { return this._eulerRotation.z; }
+
+    set yaw(y: number) { this._eulerRotation.x = y; this.calculateTransform(); }
+    set pitch(p: number) { this._eulerRotation.y = p; this.calculateTransform(); }
+    set roll(r: number) { this._eulerRotation.z = r; this.calculateTransform(); }
+
+    get transformOrder(): number { return this._transformOrder; }
+    set transformOrder(t: number) { this._transformOrder = t; this.calculateTransform(); }
+
+    applyTransform(matrix: Mat4): void {
+        matrix.mult(this.transform);
+    }
+
+    multTransform(dst: Mat4): void {
+        const offset = this.offset;
+        switch (this.transformOrder) {
+        case LinkTransformOrder.TRANSLATE_ROTATE:
+            dst.translate(offset.x, offset.y, offset.z);
+            this.multRotation(dst);
+            break;
+        case LinkTransformOrder.ROTATE_TRANSLATE:
+            this.multRotation(dst);
+            dst.translate(offset.x, offset.y, offset.z);
+            break;
+        }
+    }
+
+    multRotation(dst: Mat4): void {
+        dst .rotate(this.eulerRotation.z, 0, 0, 1)
+            .rotate(this.eulerRotation.y, 0, 1, 0)
+            .rotate(this.eulerRotation.x, 1, 0, 0);
+    }
+
+    calculateTransform(): void {
+        this.transform.identity();
+        this.multTransform(this.transform);
+    }
+
+    clone(): LinkJoint {
+        const other = new LinkJoint();
+        other.assign(this);
+        return other;
+    }
+
+    assign(other: LinkJoint): void {
+        this._offset = new Vec(other._offset);
+        this._eulerRotation = new Vec(other._eulerRotation);
+        this._transformOrder = other._transformOrder;
+        this.calculateTransform();
+    }
+
+    serialize(sceneData: any): void {
+        if (sceneData.offset && sceneData.offset.length >= 3) {
+            this._offset = new Vec(sceneData.offset);
+        }
+        this._eulerRotation = new Vec(
+            sceneData.yaw || 0,
+            sceneData.pitch || 0,
+            sceneData.roll || 0
+        );
+        this._transformOrder = sceneData.order !== undefined ? sceneData.order : LinkTransformOrder.TRANSLATE_ROTATE;
+    }
+
+    deserialize(sceneData: any): void {
+        sceneData.type = 'LinkJoint';
+        sceneData.offset = Array.from(this._offset);
+        sceneData.yaw = this.yaw;
+        sceneData.pitch = this.pitch;
+        sceneData.roll = this.roll;
+        sceneData.order = this.transformOrder;
+    }
+}

package/src/primitives/arrow.ts

@@ -0,0 +1,58 @@
+import PolyList, { DrawMode } from "../base/PolyList";
+import Mat4 from "../math/Mat4";
+import Vec from "../math/Vec";
+
+export default function arrow(length: number, arrowSize = 0.3, direction = new Vec(0, 0, 1), up = new Vec(0, 1, 0) ): PolyList {
+    const polyList = new PolyList();
+    direction.normalize();
+
+    polyList.drawMode = DrawMode.LINES;
+
+    const trx = Mat4.MakeRotationWithDirection(direction, up);
+
+    const arrowVector = trx.multVector(new Vec(0, 0, -1));
+    const arrowHeadDir1 = trx.multVector(new Vec( arrowSize, 0, -1 + arrowSize));
+    const arrowHeadDir2 = trx.multVector(new Vec(-arrowSize, 0, -1 + arrowSize));
+
+
+    polyList.vertex = [
+        0, 0, 0,
+        arrowVector.x * length, arrowVector.y * length, arrowVector.z * length,
+
+        arrowVector.x * length, arrowVector.y * length, arrowVector.z * length,
+        arrowHeadDir1.x * length, arrowHeadDir1.y * length, arrowHeadDir1.z * length,
+
+        arrowVector.x * length, arrowVector.y * length, arrowVector.z * length,
+        arrowHeadDir2.x * length, arrowHeadDir2.y * length, arrowHeadDir2.z * length
+    ];
+
+    polyList.normal = [
+        0, 0, 1,
+        0, 0, 1,
+
+        0, 0, 1,
+        0, 0, 1,
+
+        0, 0, 1,
+        0, 0, 1
+    ];
+
+    polyList.texCoord0 = [
+        0, 0,
+        0, 1,
+
+        0, 0,
+        0, 1,
+
+        0, 0,
+        0, 1
+    ];
+
+    polyList.index = [
+        0, 1,
+        2, 3,
+        4, 5
+    ];
+
+    return polyList;
+}

package/src/primitives/cone.ts

@@ -0,0 +1,138 @@
+import ObjParser from "../db/ObjParser";
+import PolyList from "../base/PolyList";
+
+const objData = (height: number, radius: number): string => {
+    return `mtllib cone.mtl
+o Cone
+v ${radius * 0.000000} ${height * -0.500000} ${radius * -1.000000}
+v ${radius * 0.309017} ${height * -0.500000} ${radius * -0.951057}
+v ${radius * 0.587785} ${height * -0.500000} ${radius * -0.809017}
+v ${radius * 0.809017} ${height * -0.500000} ${radius * -0.587785}
+v ${radius * 0.951057} ${height * -0.500000} ${radius * -0.309017}
+v ${radius * 1.000000} ${height * -0.500000} ${radius * 0.000000}
+v ${radius * 0.951056} ${height * -0.500000} ${radius * 0.309017}
+v ${radius * 0.809017} ${height * -0.500000} ${radius * 0.587785}
+v ${radius * 0.587785} ${height * -0.500000} ${radius * 0.809017}
+v ${radius * 0.309017} ${height * -0.500000} ${radius * 0.951056}
+v ${radius * -0.000000} ${height * -0.500000} ${radius * 1.000000}
+v ${radius * -0.309017} ${height * -0.500000} ${radius * 0.951057}
+v ${radius * -0.587785} ${height * -0.500000} ${radius * 0.809017}
+v ${radius * -0.809017} ${height * -0.500000} ${radius * 0.587785}
+v ${radius * -0.951056} ${height * -0.500000} ${radius * 0.309017}
+v ${radius * -1.000000} ${height * -0.500000} ${radius * -0.000000}
+v ${radius * -0.951056} ${height * -0.500000} ${radius * -0.309017}
+v ${radius * -0.809017} ${height * -0.500000} ${radius * -0.587785}
+v ${radius * -0.587785} ${height * -0.500000} ${radius * -0.809017}
+v ${radius * -0.309017} ${height * -0.500000} ${radius * -0.951057}
+v ${radius * 0.000000} ${height * 0.500000} ${radius * 0.000000}
+vn -0.0000 0.7071 -0.7071
+vn -0.0000 1.0000 -0.0000
+vn 0.2185 0.7071 -0.6725
+vn 0.4156 0.7071 -0.5721
+vn 0.5721 0.7071 -0.4156
+vn 0.6725 0.7071 -0.2185
+vn 0.7071 0.7071 -0.0000
+vn 0.6725 0.7071 0.2185
+vn 0.5721 0.7071 0.4156
+vn 0.4156 0.7071 0.5721
+vn 0.2185 0.7071 0.6725
+vn -0.0000 0.7071 0.7071
+vn -0.2185 0.7071 0.6725
+vn -0.4156 0.7071 0.5721
+vn -0.5721 0.7071 0.4156
+vn -0.6725 0.7071 0.2185
+vn -0.7071 0.7071 -0.0000
+vn -0.6725 0.7071 -0.2185
+vn -0.5721 0.7071 -0.4156
+vn -0.4156 0.7071 -0.5721
+vn -0.0000 -1.0000 -0.0000
+vn -0.2185 0.7071 -0.6725
+vt 0.250000 0.490000
+vt 0.750000 0.490000
+vt 0.324164 0.478254
+vt 0.824164 0.478254
+vt 0.391068 0.444164
+vt 0.891068 0.444164
+vt 0.444164 0.391068
+vt 0.944164 0.391068
+vt 0.478254 0.324164
+vt 0.978254 0.324164
+vt 0.490000 0.250000
+vt 0.990000 0.250000
+vt 0.478254 0.175836
+vt 0.978254 0.175836
+vt 0.444164 0.108932
+vt 0.944164 0.108932
+vt 0.391068 0.055836
+vt 0.891068 0.055836
+vt 0.324164 0.021746
+vt 0.824164 0.021746
+vt 0.250000 0.010000
+vt 0.750000 0.010000
+vt 0.175836 0.021746
+vt 0.675836 0.021746
+vt 0.108932 0.055836
+vt 0.608932 0.055836
+vt 0.055836 0.108932
+vt 0.555836 0.108932
+vt 0.021746 0.175836
+vt 0.521746 0.175836
+vt 0.010000 0.250000
+vt 0.510000 0.250000
+vt 0.021746 0.324164
+vt 0.521746 0.324164
+vt 0.055836 0.391068
+vt 0.555836 0.391068
+vt 0.108932 0.444164
+vt 0.608932 0.444164
+vt 0.175836 0.478254
+vt 0.675836 0.478254
+vt 0.250000 0.250000
+s 1
+usemtl Cone
+f 1/1/1 21/41/2 2/3/3
+f 2/3/3 21/41/2 3/5/4
+f 3/5/4 21/41/2 4/7/5
+f 4/7/5 21/41/2 5/9/6
+f 5/9/6 21/41/2 6/11/7
+f 6/11/7 21/41/2 7/13/8
+f 7/13/8 21/41/2 8/15/9
+f 8/15/9 21/41/2 9/17/10
+f 9/17/10 21/41/2 10/19/11
+f 10/19/11 21/41/2 11/21/12
+f 11/21/12 21/41/2 12/23/13
+f 12/23/13 21/41/2 13/25/14
+f 13/25/14 21/41/2 14/27/15
+f 14/27/15 21/41/2 15/29/16
+f 15/29/16 21/41/2 16/31/17
+f 16/31/17 21/41/2 17/33/18
+f 17/33/18 21/41/2 18/35/19
+f 18/35/19 21/41/2 19/37/20
+f 4/8/21 8/16/21 16/32/21
+f 19/37/20 21/41/2 20/39/22
+f 20/39/22 21/41/2 1/1/1
+f 20/40/21 1/2/21 2/4/21
+f 2/4/21 3/6/21 20/40/21
+f 3/6/21 4/8/21 20/40/21
+f 4/8/21 5/10/21 8/16/21
+f 5/10/21 6/12/21 8/16/21
+f 6/12/21 7/14/21 8/16/21
+f 8/16/21 9/18/21 12/24/21
+f 9/18/21 10/20/21 12/24/21
+f 10/20/21 11/22/21 12/24/21
+f 12/24/21 13/26/21 14/28/21
+f 14/28/21 15/30/21 16/32/21
+f 16/32/21 17/34/21 18/36/21
+f 18/36/21 19/38/21 16/32/21
+f 19/38/21 20/40/21 16/32/21
+f 12/24/21 14/28/21 8/16/21
+f 14/28/21 16/32/21 8/16/21
+f 20/40/21 4/8/21 16/32/21
+`;
+}
+
+export default function cone(height: number, radius: number): PolyList {
+    const objTextData = objData(height, radius);
+    const parser = new ObjParser(objTextData);
+    return parser.polyListArray[0];
+}

package/src/primitives/cube.ts

@@ -0,0 +1,60 @@
+
+import ObjParser from "../db/ObjParser";
+import PolyList from "../base/PolyList";
+
+const objData = (width: number, height: number, depth: number): string => {
+    const w = width / 2;
+    const h = height / 2;
+    const d = depth / 2;
+
+    return `mtllib cube.mtl
+o Cube
+v ${w} ${h} -${d}    // 1
+v ${w} -${h} -${d}   // 2
+v ${w} ${h} ${d}     // 3
+v ${w} -${h} ${d}    // 4
+v -${w} ${h} -${d}   // 5
+v -${w} -${h} -${d}  // 6
+v -${w} ${h} ${d}    // 7
+v -${w} -${h} ${d}   // 8
+vt 0.007582 0.995648
+vt 0.007582 0.005685
+vt 0.992623 0.005685
+vt 0.992623 0.995648
+vt 0.992623 0.995648
+vt 0.007582 0.995648
+vt 0.007582 0.005685
+vt 0.992623 0.005685
+vt 0.992623 0.995648
+vt 0.007582 0.995648
+vt 0.007582 0.005685
+vt 0.007582 0.995648
+vt 0.007582 0.005685
+vt 0.992623 0.005685
+vt 0.992623 0.995648
+vt 0.992623 0.995648
+vt 0.007582 0.005685
+vt 0.992623 0.005685
+vt 0.992623 0.995648
+vn 0.0000 1.0000 0.0000
+vn 0.0000 0.0000 1.0000
+vn -1.0000 0.0000 0.0000
+vn 0.0000 -1.0000 0.0000
+vn 1.0000 0.0000 0.0000
+vn 0.0000 0.0000 -1.0000
+usemtl Cube
+s off
+f 1/1/1 5/2/1 7/3/1 3/4/1
+f 4/5/2 3/6/2 7/7/2 8/8/2
+f 8/8/3 7/9/3 5/10/3 6/11/3
+f 6/12/4 2/13/4 4/14/4 8/15/4
+f 2/16/5 1/1/5 3/17/5 4/14/5
+f 6/18/6 5/19/6 1/1/6 2/13/6
+`
+}
+
+export default function cube(w: number, h: number, d: number): PolyList {
+    const objTextData = objData(w,h,d);
+    const parser = new ObjParser(objTextData);
+    return parser.polyListArray[0];
+};