@openglobus/og 0.17.2 → 0.18.0

package/src/{og/math/Vec4.js → math/Vec4.ts}

@@ -1,7 +1,7 @@
-"use strict";
+import {frac} from "../math";
+import {Vec3} from "./Vec3";
 
-import { frac } from "../math.js";
-import { Vec3 } from "./Vec3.js";
+export type NumberArray4 = [number, number, number, number];
 
 /**
  * Class represents a 4d vector.
@@ -12,30 +12,37 @@ import { Vec3 } from "./Vec3.js";
  * @param {number} [w] - Fourth value.
  */
 export class Vec4 {
-    constructor(x = 0.0, y = 0.0, z = 0.0, w = 0.0) {
-        /**
-         * @public
-         * @type {number}
-         */
-        this.x = x || 0.0;
 
-        /**
-         * @public
-         * @type {number}
-         */
-        this.y = y || 0.0;
+    /**
+     * @public
+     * @type {number}
+     */
+    public x: number;
+
+    /**
+     * @public
+     * @type {number}
+     */
+    public y: number;
 
-        /**
-         * @public
-         * @type {number}
-         */
-        this.z = z || 0.0;
+    /**
+     * @public
+     * @type {number}
+     */
+    public z: number;
 
-        /**
-         * @public
-         * @type {number}
-         */
-        this.w = w || 0.0;
+    /**
+     * @public
+     * @type {number}
+     */
+    public w: number;
+
+
+    constructor(x: number = 0.0, y: number = 0.0, z: number = 0.0, w: number = 0.0) {
+        this.x = x;
+        this.y = y;
+        this.z = z;
+        this.w = w;
     }
 
     /**
@@ -43,26 +50,26 @@ export class Vec4 {
      * @const
      * @type {Vec4}
      */
-    static get identity() {
+    static get identity(): Vec4 {
         return new Vec4(0, 0, 0, 1);
     }
 
     /**
      * Creates 4d vector from array.
      * @function
-     * @param {Array.<number>} - (exactly 4 entries)
+     * @param {Array.<number>} arr - Array of four values
      * @returns {Vec4}
      */
-    static fromVec(arr) {
+    static fromVec(arr: NumberArray4): Vec4 {
         return new Vec4(arr[0], arr[1], arr[2], arr[3]);
     }
 
     /**
-     * Converts to 3d vector, without fourth value.
+     * Converts to Vec3, without fourth value.
      * @public
      * @returns {Vec3}
      */
-    toVec3() {
+    public toVec3(): Vec3 {
         return new Vec3(this.x, this.y, this.z);
     }
 
@@ -71,17 +78,17 @@ export class Vec4 {
      * @public
      * @returns {Vec4}
      */
-    clone() {
+    public clone(): Vec4 {
         return new Vec4(this.x, this.y, this.z, this.w);
     }
 
     /**
      * Compares with vector. Returns true if it equals another.
      * @public
-     * @param {Vec4} p - Vector to compare.
+     * @param {Vec4} v - Vector to compare.
      * @returns {boolean}
      */
-    equal(v) {
+    public equal(v: Vec4): boolean {
         return this.x === v.x && this.y === v.y && this.z === v.z && this.w === v.w;
     }
 
@@ -90,7 +97,7 @@ export class Vec4 {
      * @param {Vec4} v - Vector to copy.
      * @returns {Vec4}
      */
-    copy(v) {
+    public copy(v: Vec4): Vec4 {
         this.x = v.x;
         this.y = v.y;
         this.z = v.z;
@@ -103,7 +110,7 @@ export class Vec4 {
      * @public
      * @returns {Array.<number>} - (exactly 4 entries)
      */
-    toArray() {
+    public toArray(): NumberArray4 {
         return [this.x, this.y, this.z, this.w];
     }
 
@@ -112,7 +119,7 @@ export class Vec4 {
      * @public
      * @returns {Array.<number>} - (exactly 4 entries)
      */
-    toArray3() {
+    toArray3(): [number, number, number] {
         return [this.x, this.y, this.z];
     }
 
@@ -125,7 +132,7 @@ export class Vec4 {
      * @param {number} w - Value W.
      * @returns {Vec4}
      */
-    set(x, y, z, w) {
+    public set(x: number, y: number, z: number, w: number): Vec4 {
         this.x = x;
         this.y = y;
         this.z = z;
@@ -136,10 +143,10 @@ export class Vec4 {
     /**
      * Adds vector to the current.
      * @public
-     * @param {Vec4}
+     * @param {Vec4} v - Vector to add.
      * @returns {Vec4}
      */
-    addA(v) {
+    public addA(v: Vec4): Vec4 {
         this.x += v.x;
         this.y += v.y;
         this.z += v.z;
@@ -153,7 +160,7 @@ export class Vec4 {
      * @param {Vec4} v - Subtract vector.
      * @returns {Vec4}
      */
-    subA(v) {
+    public subA(v: Vec4): Vec4 {
         this.x -= v.x;
         this.y -= v.y;
         this.z -= v.z;
@@ -167,7 +174,7 @@ export class Vec4 {
      * @param {number} scale - Scale value.
      * @returns {Vec4}
      */
-    scale(scale) {
+    public scale(scale: number): Vec4 {
         this.x *= scale;
         this.y *= scale;
         this.z *= scale;
@@ -176,16 +183,19 @@ export class Vec4 {
     }
 
     /**
-     * Makes vector affinity. Thereby fourh component becomes to 1.0.
+     * Makes vector affinity. Thereby fourth component becomes to 1.0.
      * @public
      * @returns {Vec4}
      */
-    affinity() {
-        var iw = 1 / this.w;
+    public affinity(): Vec4 {
+
+        let iw = 1.0 / this.w;
+
         this.x *= iw;
         this.y *= iw;
         this.z *= iw;
         this.w = 1.0;
+
         return this;
     }
 
@@ -195,16 +205,16 @@ export class Vec4 {
      * @param {number} scale - Scale value.
      * @returns {Vec3}
      */
-    scaleTo(scale) {
+    public scaleTo(scale: number): Vec4 {
         return new Vec4(this.x * scale, this.y * scale, this.z * scale, this.w * scale);
     }
 
     /**
-     * Vector's edge function that returns vector where each component is 0.0 if it's smaller then edge and otherwise 1.0.
+     * Vector's edge function that returns vector where each component is 0.0 if it's smaller than edge and otherwise 1.0.
      * @public
      * @returns {Vec4}
      */
-    getStep(edge) {
+    public getStep(edge: number): Vec4 {
         return new Vec4(
             this.x < edge ? 0.0 : 1.0,
             this.y < edge ? 0.0 : 1.0,
@@ -214,21 +224,22 @@ export class Vec4 {
     }
 
     /**
-     * The vector fract function returns the vector of fractional parts of each value, i.e. x minus floor(x).
+     * The vector frac function returns the vector of fractional parts of each value, i.e. x minus floor(x).
      * @public
+     * @param {Vec4} v - Input vector
      * @returns {Vec4}
      */
-    getFrac(v) {
+    public getFrac(v: Vec4): Vec4 {
         return new Vec4(frac(v.x), frac(v.y), frac(v.z), frac(v.w));
     }
 
     /**
      * Gets vectors dot production.
      * @public
-     * @param {math.Vec4} v - Another vector.
+     * @param {Vec4} v - Another vector.
      * @returns {number} - Dot product.
      */
-    dot(v) {
+    public dot(v: Vec4): number {
         return v.x * this.x + v.y * this.y + v.z * this.z + v.w * this.w;
     }
 
@@ -237,7 +248,7 @@ export class Vec4 {
      * @public
      * @returns {boolean} -
      */
-    isZero() {
+    public isZero(): boolean {
         return !(this.x || this.y || this.z || this.w);
     }
 }
@@ -245,12 +256,12 @@ export class Vec4 {
 /**
  * Vector 4d object creator.
  * @function
- * @param {number} [x] - First cvalue.
+ * @param {number} [x] - First value.
  * @param {number} [y] - Second value.
  * @param {number} [z] - Third value.
  * @param {number} [w] - Fourth value.
  * @returns {Vec4}
  */
-export function vec4(x, y, z, w) {
+export function vec4(x: number = 0, y: number = 0, z: number = 0, w: number = 0): Vec4 {
     return new Vec4(x, y, z, w);
 }

package/src/{og/math/coder.js → math/coder.ts}

@@ -2,20 +2,20 @@
  * @module og/math/coder
  */
 
-"use strict";
-
-import * as math from "../math.js";
-import { Vec4 } from "./Vec4.js";
+import * as math from "../math";
+import {NumberArray4, Vec4} from "./Vec4";
+import {NumberArray3} from "./Vec3";
+import {NumberArray2, Vec2} from "./Vec2";
 
 /**
  * Encode 32 bit float value to the RGBA vector.
  * @function
  * @param {number} v - 32 bit float value.
- * @returns {math.Vec4} - RGBA vector value.
+ * @returns {Vec4} - RGBA vector value.
  */
-export function encodeFloatToRGBA(v) {
-    var enc = new Vec4((1.0 * v) % 1, (255.0 * v) % 1, (65025.0 * v) % 1, (160581375.0 * v) % 1);
-    var yzww = new Vec4(enc.y / 255, enc.z / 255, enc.w / 255, 0);
+export function encodeFloatToRGBA(v: number): Vec4 {
+    let enc = new Vec4((1.0 * v) % 1, (255.0 * v) % 1, (65025.0 * v) % 1, (160581375.0 * v) % 1);
+    let yzww = new Vec4(enc.y / 255, enc.z / 255, enc.w / 255, 0);
     return enc.subA(yzww);
 }
 
@@ -25,34 +25,35 @@ export function encodeFloatToRGBA(v) {
  * @param {Vec4} rgba - RGBA encoded 32 bit float value.
  * @returns {number} - Float value.
  */
-export function decodeFloatFromRGBA(rgba) {
-    var s = 1.0 - math.step(128.0, rgba.x) * 2.0;
-    var e = 2.0 * math.mod(rgba.x, 128.0) + math.step(128.0, rgba.y) - 127.0;
-    var m = math.mod(rgba.y, 128.0) * 65536.0 + rgba.z * 256.0 + rgba.w + 8388608.0;
+export function decodeFloatFromRGBA(rgba: Vec4): number {
+    let s = 1.0 - math.step(128.0, rgba.x) * 2.0;
+    let e = 2.0 * math.mod(rgba.x, 128.0) + math.step(128.0, rgba.y) - 127.0;
+    let m = math.mod(rgba.y, 128.0) * 65536.0 + rgba.z * 256.0 + rgba.w + 8388608.0;
     return s * math.exp2(e) * (m * 1.1920928955078125e-7);
 }
 
 /**
  * Decode RGBA vector to 32 bit float value.
  * @function
- * @param {Vec4} rgba - RGBA encoded 32 bit float value.
+ * @param {NumberArray4 | NumberArray3} arr - RGBA encoded 32 bit float value.
+ * @param {boolean} [use32=false] Use 32 bit result
  * @returns {number} - Float value.
  */
-export function decodeFloatFromRGBAArr(arr, use32) {
-    var s = 1.0 - math.step(128.0, arr[0]) * 2.0;
-    var e = 2.0 * math.mod(arr[0], 128.0) + math.step(128.0, arr[1]) - 127.0;
-    var m = math.mod(arr[1], 128.0) * 65536.0 + arr[2] * 256.0 + (use32 ? arr[3] : 0.0) + 8388608.0;
+export function decodeFloatFromRGBAArr(arr: NumberArray4 | NumberArray3 | Uint8Array, use32: boolean = false): number {
+    let s = 1.0 - math.step(128.0, arr[0]) * 2.0;
+    let e = 2.0 * math.mod(arr[0], 128.0) + math.step(128.0, arr[1]) - 127.0;
+    let m = math.mod(arr[1], 128.0) * 65536.0 + arr[2] * 256.0 + (use32 ? arr[3] || 0.0 : 0.0) + 8388608.0;
     return s * math.exp2(e) * (m * 1.1920928955078125e-7);
 }
 
 /**
- * Separate 64 bit value to two 32 bit float values.
+ * Separate 64 bit value to two 32-bit float values.
  * @function
  * @param {number} value - Double type value.
- * @returns {Array.<number>} Encoded array. (exactly 2 entries)
+ * @returns {Float32Array} Encoded array. (exactly 2 entries)
  */
-export function doubleToTwoFloats(value) {
-    var high, low;
+export function doubleToTwoFloats(value: number): Float32Array {
+    let high: number, low: number;
     if (value >= 0.0) {
         let doubleHigh = Math.floor(value / 65536.0) * 65536.0;
         high = Math.fround(doubleHigh);
@@ -66,12 +67,13 @@ export function doubleToTwoFloats(value) {
 }
 
 /**
- * Separate 64 bit value to two 32 bit float values.
+ * Separate 64 bit value to two 32-bit float values.
  * @function
  * @param {number} value - Double type value.
- * @returns {Array.<number>} Encoded array. (exactly 2 entries)
+ * @param {NumberArray2 | Float32Array} - Reference out array.
+ * @returns {NumberArray2 | Float32Array} Encoded array. (exactly 2 entries)
  */
-export function doubleToTwoFloats2(value, highLowArr) {
+export function doubleToTwoFloats2(value: number, highLowArr: NumberArray2 | Float32Array): NumberArray2 | Float32Array {
     if (value >= 0.0) {
         let doubleHigh = Math.floor(value / 65536.0) * 65536.0;
         highLowArr[0] = Math.fround(doubleHigh);
@@ -85,12 +87,13 @@ export function doubleToTwoFloats2(value, highLowArr) {
 }
 
 /**
- * Separate 64 bit value to two 32 bit float values.
+ * Separate 64 bit value to two 32-bit float values.
  * @function
  * @param {number} value - Double type value.
- * @returns {Array.<number>} Encoded array. (exactly 2 entries)
+ * @param {Vec2} highLowVec - Reference out vector object.
+ * @returns {Vec2} Encoded array. (exactly 2 entries)
  */
-export function doubleToTwoFloatsV2(value, highLowVec) {
+export function doubleToTwoFloatsV2(value: number, highLowVec: Vec2): Vec2 {
     if (value >= 0.0) {
         let doubleHigh = Math.floor(value / 65536.0) * 65536.0;
         highLowVec.x = Math.fround(doubleHigh);

package/src/math/index.ts

@@ -0,0 +1,26 @@
+import {Line2} from './Line2';
+import {Line3} from './Line3';
+import {Mat3} from './Mat3';
+import {Mat4} from './Mat4';
+import {Plane} from './Plane';
+import {Quat} from './Quat';
+import {Ray} from './Ray';
+import {Vec2, NumberArray2} from './Vec2';
+import {Vec3, NumberArray3} from './Vec3';
+import {Vec4, NumberArray4} from './Vec4';
+
+export {
+    Line2,
+    Line3,
+    Mat3,
+    Mat4,
+    Plane,
+    Quat,
+    Ray,
+    Vec2,
+    Vec3,
+    Vec4,
+    NumberArray2,
+    NumberArray3,
+    NumberArray4
+};