warscript 0.0.1-dev.404878c

package/core/vecmath/vec3.lua

@@ -0,0 +1,350 @@
+local ____lualib = require("lualib_bundle")
+local __TS__Class = ____lualib.__TS__Class
+local __TS__New = ____lualib.__TS__New
+local __TS__ObjectDefineProperty = ____lualib.__TS__ObjectDefineProperty
+local __TS__SetDescriptor = ____lualib.__TS__SetDescriptor
+local ____exports = {}
+local ____common = require("core.vecmath.common")
+local EPSILON = ____common.EPSILON
+local Vector3 = __TS__Class()
+Vector3.name = "Vector3"
+function Vector3.prototype.____constructor(self, values)
+    self._values = {0, 0, 0}
+    if values then
+        self.xyz = values
+    end
+end
+function Vector3.cross(self, vector, vector2, dest)
+    if not dest then
+        dest = __TS__New(Vector3)
+    end
+    local x = vector.x
+    local y = vector.y
+    local z = vector.z
+    local x2 = vector2.x
+    local y2 = vector2.y
+    local z2 = vector2.z
+    dest.x = y * z2 - z * y2
+    dest.y = z * x2 - x * z2
+    dest.z = x * y2 - y * x2
+    return dest
+end
+function Vector3.dot(self, vector, vector2)
+    local x = vector.x
+    local y = vector.y
+    local z = vector.z
+    local x2 = vector2.x
+    local y2 = vector2.y
+    local z2 = vector2.z
+    return x * x2 + y * y2 + z * z2
+end
+function Vector3.distance(self, vector, vector2)
+    return math.sqrt(self:squaredDistance(vector, vector2))
+end
+function Vector3.squaredDistance(self, vector, vector2)
+    local x = vector2.x - vector.x
+    local y = vector2.y - vector.y
+    local z = vector2.z - vector.z
+    return x * x + y * y + z * z
+end
+function Vector3.direction(self, vector, vector2, dest)
+    if not dest then
+        dest = __TS__New(Vector3)
+    end
+    local x = vector.x - vector2.x
+    local y = vector.y - vector2.y
+    local z = vector.z - vector2.z
+    local length = math.sqrt(x * x + y * y + z * z)
+    if length == 0 then
+        dest.x = 0
+        dest.y = 0
+        dest.z = 0
+        return dest
+    end
+    length = 1 / length
+    dest.x = x * length
+    dest.y = y * length
+    dest.z = z * length
+    return dest
+end
+function Vector3.lerp(self, a, b, t, dest)
+    if not dest then
+        dest = __TS__New(Vector3)
+    end
+    dest.x = a.x + t * (b.x - a.x)
+    dest.y = a.y + t * (b.y - a.y)
+    dest.z = a.z + t * (b.z - a.z)
+    return dest
+end
+function Vector3.sum(self, vector, vector2, dest)
+    if not dest then
+        dest = __TS__New(Vector3)
+    end
+    dest.x = vector.x + vector2.x
+    dest.y = vector.y + vector2.y
+    dest.z = vector.z + vector2.z
+    return dest
+end
+function Vector3.difference(self, vector, vector2, dest)
+    if not dest then
+        dest = __TS__New(Vector3)
+    end
+    dest.x = vector.x - vector2.x
+    dest.y = vector.y - vector2.y
+    dest.z = vector.z - vector2.z
+    return dest
+end
+function Vector3.product(self, vector, vector2, dest)
+    if not dest then
+        dest = __TS__New(Vector3)
+    end
+    dest.x = vector.x * vector2.x
+    dest.y = vector.y * vector2.y
+    dest.z = vector.z * vector2.z
+    return dest
+end
+function Vector3.quotient(self, vector, vector2, dest)
+    if not dest then
+        dest = __TS__New(Vector3)
+    end
+    dest.x = vector.x / vector2.x
+    dest.y = vector.y / vector2.y
+    dest.z = vector.z / vector2.z
+    return dest
+end
+function Vector3.prototype.at(self, index)
+    return self._values[index + 1]
+end
+function Vector3.prototype.reset(self)
+    self.xyz = {0, 0, 0}
+end
+function Vector3.prototype.copy(self, dest)
+    if not dest then
+        dest = __TS__New(Vector3)
+    end
+    dest.xyz = self.xyz
+    return dest
+end
+function Vector3.prototype.negate(self, dest)
+    if not dest then
+        dest = self
+    end
+    dest.x = -self.x
+    dest.y = -self.y
+    dest.z = -self.z
+    return dest
+end
+function Vector3.prototype.equals(self, other, threshold)
+    if threshold == nil then
+        threshold = EPSILON
+    end
+    if math.abs(self.x - other.x) > threshold then
+        return false
+    end
+    if math.abs(self.y - other.y) > threshold then
+        return false
+    end
+    if math.abs(self.z - other.z) > threshold then
+        return false
+    end
+    return true
+end
+function Vector3.prototype.length(self)
+    return math.sqrt(self:squaredLength())
+end
+function Vector3.prototype.squaredLength(self)
+    local x = self.x
+    local y = self.y
+    local z = self.z
+    return x * x + y * y + z * z
+end
+function Vector3.prototype.add(self, vector, dest)
+    if not dest then
+        dest = self
+    end
+    dest.x = self.x + vector.x
+    dest.y = self.y + vector.y
+    dest.z = self.z + vector.z
+    return dest
+end
+function Vector3.prototype.subtract(self, vector, dest)
+    if not dest then
+        dest = self
+    end
+    dest.x = self.x - vector.x
+    dest.y = self.y - vector.y
+    dest.z = self.z - vector.z
+    return dest
+end
+function Vector3.prototype.multiply(self, vector, dest)
+    if not dest then
+        dest = self
+    end
+    dest.x = self.x * vector.x
+    dest.y = self.y * vector.y
+    dest.z = self.z * vector.z
+    return dest
+end
+function Vector3.prototype.divide(self, vector, dest)
+    if not dest then
+        dest = self
+    end
+    dest.x = self.x / vector.x
+    dest.y = self.y / vector.y
+    dest.z = self.z / vector.z
+    return dest
+end
+function Vector3.prototype.scale(self, value, dest)
+    if not dest then
+        dest = self
+    end
+    dest.x = self.x * value
+    dest.y = self.y * value
+    dest.z = self.z * value
+    return dest
+end
+function Vector3.prototype.normalize(self, dest)
+    if not dest then
+        dest = self
+    end
+    dest.xyz = self.xyz
+    local length = dest:length()
+    if length == 1 then
+        return dest
+    end
+    if length == 0 then
+        dest:reset()
+        return dest
+    end
+    length = 1 / length
+    dest.x = dest.x * length
+    dest.y = dest.y * length
+    dest.z = dest.z * length
+    return dest
+end
+__TS__ObjectDefineProperty(
+    Vector3,
+    "zero",
+    {get = function(self)
+        return __TS__New(Vector3, {0, 0, 0})
+    end}
+)
+__TS__ObjectDefineProperty(
+    Vector3,
+    "one",
+    {get = function(self)
+        return __TS__New(Vector3, {1, 1, 1})
+    end}
+)
+__TS__ObjectDefineProperty(
+    Vector3,
+    "up",
+    {get = function(self)
+        return __TS__New(Vector3, {0, 1, 0})
+    end}
+)
+__TS__ObjectDefineProperty(
+    Vector3,
+    "down",
+    {get = function(self)
+        return __TS__New(Vector3, {0, -1, 0})
+    end}
+)
+__TS__ObjectDefineProperty(
+    Vector3,
+    "right",
+    {get = function(self)
+        return __TS__New(Vector3, {1, 0, 0})
+    end}
+)
+__TS__ObjectDefineProperty(
+    Vector3,
+    "left",
+    {get = function(self)
+        return __TS__New(Vector3, {-1, 0, 0})
+    end}
+)
+__TS__ObjectDefineProperty(
+    Vector3,
+    "forward",
+    {get = function(self)
+        return __TS__New(Vector3, {0, 0, 1})
+    end}
+)
+__TS__ObjectDefineProperty(
+    Vector3,
+    "backward",
+    {get = function(self)
+        return __TS__New(Vector3, {0, 0, -1})
+    end}
+)
+__TS__SetDescriptor(
+    Vector3.prototype,
+    "x",
+    {
+        get = function(self)
+            return self._values[1]
+        end,
+        set = function(self, value)
+            self._values[1] = value
+        end
+    },
+    true
+)
+__TS__SetDescriptor(
+    Vector3.prototype,
+    "y",
+    {
+        get = function(self)
+            return self._values[2]
+        end,
+        set = function(self, value)
+            self._values[2] = value
+        end
+    },
+    true
+)
+__TS__SetDescriptor(
+    Vector3.prototype,
+    "z",
+    {
+        get = function(self)
+            return self._values[3]
+        end,
+        set = function(self, value)
+            self._values[3] = value
+        end
+    },
+    true
+)
+__TS__SetDescriptor(
+    Vector3.prototype,
+    "xy",
+    {
+        get = function(self)
+            return {self._values[1], self._values[2]}
+        end,
+        set = function(self, values)
+            self._values[1] = values[1]
+            self._values[2] = values[2]
+        end
+    },
+    true
+)
+__TS__SetDescriptor(
+    Vector3.prototype,
+    "xyz",
+    {
+        get = function(self)
+            return {self._values[1], self._values[2], self._values[3]}
+        end,
+        set = function(self, values)
+            self._values[1] = values[1]
+            self._values[2] = values[2]
+            self._values[3] = values[3]
+        end
+    },
+    true
+)
+____exports.default = Vector3
+return ____exports

package/core/vecmath/vec4.d.ts

@@ -0,0 +1,54 @@
+/** @noSelfInFile */
+declare class Vector4 {
+    static get zero(): Vector4;
+    static get one(): Vector4;
+    private _values;
+    get x(): number;
+    set x(value: number);
+    get y(): number;
+    set y(value: number);
+    get z(): number;
+    set z(value: number);
+    get w(): number;
+    set w(value: number);
+    get xy(): number[];
+    set xy(values: number[]);
+    get xyz(): number[];
+    set xyz(values: number[]);
+    get xyzw(): number[];
+    set xyzw(values: number[]);
+    get r(): number;
+    set r(value: number);
+    get g(): number;
+    set g(value: number);
+    get b(): number;
+    set b(value: number);
+    get a(): number;
+    set a(value: number);
+    get rg(): number[];
+    set rg(values: number[]);
+    get rgb(): number[];
+    set rgb(values: number[]);
+    get rgba(): number[];
+    set rgba(values: number[]);
+    constructor(values?: number[]);
+    static lerp(a: Vector4, b: Vector4, t: number, dest?: Vector4): Vector4;
+    static sum(vector: Vector4, vector2: Vector4, dest?: Vector4): Vector4;
+    static difference(vector: Vector4, vector2: Vector4, dest?: Vector4): Vector4;
+    static product(vector: Vector4, vector2: Vector4, dest?: Vector4): Vector4;
+    static quotient(vector: Vector4, vector2: Vector4, dest?: Vector4): Vector4;
+    at(index: number): number;
+    reset(): void;
+    copy(dest?: Vector4): Vector4;
+    negate(dest?: Vector4): Vector4;
+    equals(vector: Vector4, threshold?: number): boolean;
+    length(): number;
+    squaredLength(): number;
+    add(vector: Vector4, dest?: Vector4): Vector4;
+    subtract(vector: Vector4, dest?: Vector4): Vector4;
+    multiply(vector: Vector4, dest?: Vector4): Vector4;
+    divide(vector: Vector4, dest?: Vector4): Vector4;
+    scale(value: number, dest?: Vector4): Vector4;
+    normalize(dest?: Vector4): Vector4;
+}
+export default Vector4;