warscript 0.0.1-dev.404878c

package/core/vecmath/common.d.ts

@@ -0,0 +1,18 @@
+/** @noSelfInFile */
+export declare const EPSILON = 0.00001;
+/**
+ * Convert Degrees to Radians
+ * @param {number} a Angle in Degrees
+ * @returns {number} Angle in Radians
+ */
+export declare function toRadians(a: number): number;
+/**
+ * Tests whether or not the arguments have approximately the same value, within an absolute
+ * or relative tolerance (an absolute tolerance is used for values less  than or equal to
+ * 1.0, and a relative tolerance is used for larger values)
+ * @param {number} a The first number to test
+ * @param {number} b The second number to test
+ * @param {number} tolerance The tolerance to test for
+ * @returns {boolean} True if the numbers are approximately equal, false otherwise
+ */
+export declare function equals(a: number, b: number, tolerance?: number): boolean;

package/core/vecmath/common.lua

@@ -0,0 +1,29 @@
+local ____exports = {}
+____exports.EPSILON = 0.00001
+local degree = math.pi / 180
+--- Convert Degrees to Radians
+-- 
+-- @param a Angle in Degrees
+-- @returns Angle in Radians
+function ____exports.toRadians(a)
+    return a * degree
+end
+--- Tests whether or not the arguments have approximately the same value, within an absolute
+-- or relative tolerance (an absolute tolerance is used for values less  than or equal to
+-- 1.0, and a relative tolerance is used for larger values)
+-- 
+-- @param a The first number to test
+-- @param b The second number to test
+-- @param tolerance The tolerance to test for
+-- @returns True if the numbers are approximately equal, false otherwise
+function ____exports.equals(a, b, tolerance)
+    if tolerance == nil then
+        tolerance = ____exports.EPSILON
+    end
+    return math.abs(a - b) <= tolerance * math.max(
+        1,
+        math.abs(a),
+        math.abs(b)
+    )
+end
+return ____exports

package/core/vecmath/mat2.d.ts

@@ -0,0 +1,73 @@
+/** @noSelfInFile */
+declare class Matrix2 {
+    static get identity(): Matrix2;
+    mul: (matrix: Matrix2, dest?: Matrix2) => Matrix2;
+    sub: (matrix: Matrix2, dest?: Matrix2) => Matrix2;
+    private _values;
+    constructor(values?: number[]);
+    /**
+     * Creates a Matrix2 from a given angle
+     * This is equivalent to (but much faster than):
+     *     m = Matrix2.identity;
+     *     m.rotate(radians, m);
+     *
+     * @param {number} radians the angle to rotate the matrix by
+     * @param {Matrix2} dest the receiving matrix
+     * @returns {Matrix2} dest
+     */
+    static fromRotation(radians: number, dest?: Matrix2): Matrix2;
+    /**
+     * Creates a matrix from a vector scaling
+     * This is equivalent to (but much faster than):
+     *     m = Matrix2.identity;
+     *     m.scale(v, m);
+     *
+     * @param {Vec2} v the scaling vector
+     * @param {Matrix2} dest the receiving matrix
+     * @returns {Matrix2} dest
+     */
+    static fromScaling(v: Vec2, dest?: Matrix2): Matrix2;
+    at(index: number): number;
+    init(values: number[]): Matrix2;
+    copy(dest?: Matrix2): Matrix2;
+    all(): number[];
+    row(index: number): number[];
+    col(index: number): number[];
+    equals(matrix: Matrix2, threshold?: number): boolean;
+    determinant(): number;
+    setIdentity(): Matrix2;
+    transpose(dest?: Matrix2): Matrix2;
+    inverse(dest?: Matrix2): Matrix2 | undefined;
+    /**
+     * Calculates the adjugate of a Matrix2
+     * @param {Matrix2} dest the receiving matrix
+     * @returns {Matrix2} dest
+     */
+    adjoint(dest?: Matrix2): Matrix2;
+    multiply(matrix: Matrix2, dest?: Matrix2): Matrix2;
+    /**
+     * Rotates a Matrix2 by the given angle
+     * @param {number} radians the angle to rotate the matrix by
+     * @param {Matrix2} dest the receiving matrix
+     * @returns {Matrix2} dest
+     */
+    rotate(radians: number, dest?: Matrix2): Matrix2;
+    /**
+     * Scales a Matrix2 by the dimensions in the given Vector2
+     * @param {Vec2} v the Vector2 to scale the matrix by
+     * @param {Matrix2} dest the receiving matrix
+     * @returns {Matrix2} dest
+     */
+    scale(v: Vec2, dest?: Matrix2): Matrix2;
+    toString(): string;
+    /**
+     * Returns the Frobenius norm of a Matrix2
+     * @returns {number} Frobenius norm
+     */
+    frobenius(): number;
+    add(matrix: Matrix2, dest?: Matrix2): Matrix2;
+    subtract(matrix: Matrix2, dest?: Matrix2): Matrix2;
+    exactEquals(matrix: Matrix2): boolean;
+    multiplyScalar(scalar: number, dest?: Matrix2): Matrix2;
+}
+export default Matrix2;

package/core/vecmath/mat2.lua

@@ -0,0 +1,261 @@
+local ____lualib = require("lualib_bundle")
+local __TS__Class = ____lualib.__TS__Class
+local __TS__New = ____lualib.__TS__New
+local __TS__ObjectDefineProperty = ____lualib.__TS__ObjectDefineProperty
+local ____exports = {}
+local tsmath = require("core.vecmath.common")
+local Matrix2 = __TS__Class()
+Matrix2.name = "Matrix2"
+function Matrix2.prototype.____constructor(self, values)
+    self.mul = self.multiply
+    self.sub = self.subtract
+    self._values = __TS__New(Float32Array, 4)
+    if values then
+        self:init(values)
+    else
+        self:init({1, 0, 0, 1})
+    end
+end
+function Matrix2.fromRotation(self, radians, dest)
+    if not dest then
+        dest = __TS__New(Matrix2)
+    end
+    local s = math.sin(radians)
+    local c = math.cos(radians)
+    dest._values[0] = c
+    dest._values[1] = s
+    dest._values[2] = -s
+    dest._values[3] = c
+    return dest
+end
+function Matrix2.fromScaling(self, v, dest)
+    if not dest then
+        dest = __TS__New(Matrix2)
+    end
+    dest._values[0] = v.x
+    dest._values[1] = 0
+    dest._values[2] = 0
+    dest._values[3] = v.y
+    return dest
+end
+function Matrix2.prototype.at(self, index)
+    return self._values[index]
+end
+function Matrix2.prototype.init(self, values)
+    do
+        local i = 0
+        while i < 4 do
+            self._values[i] = values[i + 1]
+            i = i + 1
+        end
+    end
+    return self
+end
+function Matrix2.prototype.copy(self, dest)
+    if not dest then
+        dest = __TS__New(Matrix2)
+    end
+    do
+        local i = 0
+        while i < 4 do
+            dest._values[i] = self._values[i]
+            i = i + 1
+        end
+    end
+    return dest
+end
+function Matrix2.prototype.all(self)
+    local data = {}
+    do
+        local i = 0
+        while i < 4 do
+            data[i + 1] = self._values[i]
+            i = i + 1
+        end
+    end
+    return data
+end
+function Matrix2.prototype.row(self, index)
+    return {self._values[index * 2 + 0], self._values[index * 2 + 1]}
+end
+function Matrix2.prototype.col(self, index)
+    return {self._values[index], self._values[index + 2]}
+end
+function Matrix2.prototype.equals(self, matrix, threshold)
+    if threshold == nil then
+        threshold = tsmath.EPSILON
+    end
+    do
+        local i = 0
+        while i < 4 do
+            if not tsmath.equals(
+                self:at(i),
+                matrix:at(i),
+                threshold
+            ) then
+                return false
+            end
+            i = i + 1
+        end
+    end
+    return true
+end
+function Matrix2.prototype.determinant(self)
+    return self._values[0] * self._values[3] - self._values[2] * self._values[1]
+end
+function Matrix2.prototype.setIdentity(self)
+    self._values[0] = 1
+    self._values[1] = 0
+    self._values[2] = 0
+    self._values[3] = 1
+    return self
+end
+function Matrix2.prototype.transpose(self, dest)
+    if not dest then
+        dest = self
+    end
+    self:copy(dest)
+    local temp = self._values[1]
+    dest._values[1] = self._values[2]
+    dest._values[2] = temp
+    return dest
+end
+function Matrix2.prototype.inverse(self, dest)
+    if not dest then
+        dest = self
+    end
+    local a0 = self._values[0]
+    local a1 = self._values[1]
+    local a2 = self._values[2]
+    local a3 = self._values[3]
+    local det = self:determinant()
+    if not det then
+        return
+    end
+    det = 1 / det
+    dest._values[0] = det * a3
+    dest._values[1] = det * -a1
+    dest._values[2] = det * -a2
+    dest._values[3] = det * a0
+    return dest
+end
+function Matrix2.prototype.adjoint(self, dest)
+    if not dest then
+        dest = self
+    end
+    local a0 = self._values[0]
+    dest._values[0] = self._values[3]
+    dest._values[1] = -self._values[1]
+    dest._values[2] = -self._values[2]
+    dest._values[3] = a0
+    return dest
+end
+function Matrix2.prototype.multiply(self, matrix, dest)
+    if not dest then
+        dest = self
+    end
+    local a0 = self._values[0]
+    local a1 = self._values[1]
+    local a2 = self._values[2]
+    local a3 = self._values[3]
+    local b0 = matrix._values[0]
+    local b1 = matrix._values[1]
+    local b2 = matrix._values[2]
+    local b3 = matrix._values[3]
+    dest._values[0] = a0 * b0 + a2 * b1
+    dest._values[1] = a1 * b0 + a3 * b1
+    dest._values[2] = a0 * b2 + a2 * b3
+    dest._values[3] = a1 * b2 + a3 * b3
+    return dest
+end
+function Matrix2.prototype.rotate(self, radians, dest)
+    if not dest then
+        dest = self
+    end
+    local a0 = self._values[0]
+    local a1 = self._values[1]
+    local a2 = self._values[2]
+    local a3 = self._values[3]
+    local s = math.sin(radians)
+    local c = math.cos(radians)
+    dest._values[0] = a0 * c + a2 * s
+    dest._values[1] = a1 * c + a3 * s
+    dest._values[2] = a0 * -s + a2 * c
+    dest._values[3] = a1 * -s + a3 * c
+    return dest
+end
+function Matrix2.prototype.scale(self, v, dest)
+    if not dest then
+        dest = self
+    end
+    local a0 = self._values[0]
+    local a1 = self._values[1]
+    local a2 = self._values[2]
+    local a3 = self._values[3]
+    dest._values[0] = a0 * v.x
+    dest._values[1] = a1 * v.x
+    dest._values[2] = a2 * v.y
+    dest._values[3] = a3 * v.y
+    return dest
+end
+function Matrix2.prototype.__tostring(self)
+    return ((((((("mat2(" .. tostring(self._values[0])) .. ", ") .. tostring(self._values[1])) .. ", ") .. tostring(self._values[2])) .. ", ") .. tostring(self._values[3])) .. ")"
+end
+function Matrix2.prototype.frobenius(self)
+    local a0 = self._values[0]
+    local a1 = self._values[1]
+    local a2 = self._values[2]
+    local a3 = self._values[3]
+    return math.sqrt(a0 ^ 2 + a1 ^ 2 + a2 ^ 2 + a3 ^ 2)
+end
+function Matrix2.prototype.add(self, matrix, dest)
+    if not dest then
+        dest = self
+    end
+    dest._values[0] = self._values[0] + matrix._values[0]
+    dest._values[1] = self._values[1] + matrix._values[1]
+    dest._values[2] = self._values[2] + matrix._values[2]
+    dest._values[3] = self._values[3] + matrix._values[3]
+    return dest
+end
+function Matrix2.prototype.subtract(self, matrix, dest)
+    if not dest then
+        dest = self
+    end
+    dest._values[0] = self._values[0] - matrix._values[0]
+    dest._values[1] = self._values[1] - matrix._values[1]
+    dest._values[2] = self._values[2] - matrix._values[2]
+    dest._values[3] = self._values[3] - matrix._values[3]
+    return dest
+end
+function Matrix2.prototype.exactEquals(self, matrix)
+    do
+        local i = 0
+        while i < 4 do
+            if self:at(i) ~= matrix:at(i) then
+                return false
+            end
+            i = i + 1
+        end
+    end
+    return true
+end
+function Matrix2.prototype.multiplyScalar(self, scalar, dest)
+    if not dest then
+        dest = self
+    end
+    dest._values[0] = self._values[0] * scalar
+    dest._values[1] = self._values[1] * scalar
+    dest._values[2] = self._values[2] * scalar
+    dest._values[3] = self._values[3] * scalar
+    return dest
+end
+__TS__ObjectDefineProperty(
+    Matrix2,
+    "identity",
+    {get = function(self)
+        return __TS__New(Matrix2)
+    end}
+)
+____exports.default = Matrix2
+return ____exports

package/core/vecmath/vec3.d.ts

@@ -0,0 +1,47 @@
+/** @noSelfInFile */
+declare class Vector3 {
+    static get zero(): Vector3;
+    static get one(): Vector3;
+    static get up(): Vector3;
+    static get down(): Vector3;
+    static get right(): Vector3;
+    static get left(): Vector3;
+    static get forward(): Vector3;
+    static get backward(): Vector3;
+    get x(): number;
+    set x(value: number);
+    get y(): number;
+    set y(value: number);
+    get z(): number;
+    set z(value: number);
+    get xy(): number[];
+    set xy(values: number[]);
+    get xyz(): number[];
+    set xyz(values: number[]);
+    private _values;
+    constructor(values?: number[]);
+    static cross(vector: Vector3, vector2: Vector3, dest?: Vector3): Vector3;
+    static dot(vector: Vector3, vector2: Vector3): number;
+    static distance(vector: Vector3, vector2: Vector3): number;
+    static squaredDistance(vector: Vector3, vector2: Vector3): number;
+    static direction(vector: Vector3, vector2: Vector3, dest?: Vector3): Vector3;
+    static lerp(a: Vector3, b: Vector3, t: number, dest?: Vector3): Vector3;
+    static sum(vector: Vector3, vector2: Vector3, dest?: Vector3): Vector3;
+    static difference(vector: Vector3, vector2: Vector3, dest?: Vector3): Vector3;
+    static product(vector: Vector3, vector2: Vector3, dest?: Vector3): Vector3;
+    static quotient(vector: Vector3, vector2: Vector3, dest?: Vector3): Vector3;
+    at(index: number): number;
+    reset(): void;
+    copy(dest?: Vector3): Vector3;
+    negate(dest?: Vector3): Vector3;
+    equals(other: Vector3, threshold?: number): boolean;
+    length(): number;
+    squaredLength(): number;
+    add(vector: Vector3, dest?: Vector3): Vector3;
+    subtract(vector: Vector3, dest?: Vector3): Vector3;
+    multiply(vector: Vector3, dest?: Vector3): Vector3;
+    divide(vector: Vector3, dest?: Vector3): Vector3;
+    scale(value: number, dest?: Vector3): Vector3;
+    normalize(dest?: Vector3): Vector3;
+}
+export default Vector3;