Vector3.ttslua

---
--- A 3D vector implementation.
---
--- Components can be accessed as x, y and z properties, or indexed by numbers [1], [2] and [3].
---
---@class ge_tts__Vector3 : __ge_tts__NumCharVec3<number>

---@shape __ge_tts__NumCharVec3<T>
---@field x T
---@field y T
---@field z T
---@field [1] T
---@field [2] T
---@field [3] T

---@shape ge_tts__NumCharVec3 : __ge_tts__NumCharVec3<number>

---@param vector ge_tts__Vector3
---@param index any
local function numberedIndex(vector, index)
    if type(index) == 'number' then
        if index == 1 then
            return vector.x
        elseif index == 2 then
            return vector.y
        elseif index == 3 then
            return vector.z
        end

        return nil
    end
end

local RADIANS_RATIO = math.pi / 180

---@class ge_tts__static_Vector3
---@overload fun(): ge_tts__Vector3
---@overload fun(x: number, y: number, z: number): ge_tts__Vector3
---@overload fun(source: tts__VectorShape): ge_tts__Vector3
local Vector3 = {}

setmetatable(Vector3, {
    ---@param sourceXOrVector nil | __ge_tts__NumCharVec3<nil | number>
    ---@param sourceY nil | number
    ---@param sourceZ nil | number
    __call = function(_, sourceXOrVector, sourceY, sourceZ)
        local self = --[[---@type ge_tts__Vector3]] {x = 0, y = 0, z = 0}

        setmetatable(self, {
            __index = numberedIndex,
            __tostring = function(_)
                return self.toString()
            end,
        })

        if sourceXOrVector then
            if type(sourceXOrVector) == 'table' then
                local source = --[[---@type __ge_tts__NumCharVec3<nil | number>]] sourceXOrVector

                self.x = source.x or source[1] or self.x
                self.y = source.y or source[2] or self.y
                self.z = source.z or source[3] or self.z
            else
                self.x = --[[---@type number]] sourceXOrVector
                self.y = --[[---@type number]] sourceY
                self.z = --[[---@type number]] sourceZ
            end
        end

        ---@return string
        function self.toString()
            return '{x = ' .. self.x .. ', y = ' .. self.y .. ', z = ' .. self.z .. '}'
        end

        ---@return tts__CharVectorShape
        function self.toData()
            return {x = self.x, y = self.y, z = self.z}
        end

        ---@return number
        function self.lengthSquared()
            return Vector3.lengthSquared(self)
        end

        ---@return number
        function self.length()
            return Vector3.length(self)
        end

        ---Add a vector to self.
        ---@overload fun(v: tts__VectorShape): self
        ---@param v ge_tts__NumCharVec3
        ---@return ge_tts__Vector3 @self
        function self.add(v)
            self.x = self.x + (v.x or v[1])
            self.y = self.y + (v.y or v[2])
            self.z = self.z + (v.z or v[3])
            return self
        end

        ---Subtract a vector from self.
        ---@overload fun(v: tts__VectorShape): self
        ---@param v ge_tts__NumCharVec3
        ---@return ge_tts__Vector3 @self
        function self.sub(v)
            self.x = self.x - (v.x or v[1])
            self.y = self.y - (v.y or v[2])
            self.z = self.z - (v.z or v[3])
            return self
        end

        ---@param factor number | tts__VectorShape
        ---@return ge_tts__Vector3 @self
        function self.scale(factor)
            if (type(factor) == 'number') then
                self.x = self.x * factor
                self.y = self.y * factor
                self.z = self.z * factor
            else
                self.x = self.x * ((--[[---@type tts__CharVectorShape]] factor).x or (--[[---@type tts__NumVectorShape]] factor)[1])
                self.y = self.y * ((--[[---@type tts__CharVectorShape]] factor).y or (--[[---@type tts__NumVectorShape]] factor)[2])
                self.z = self.z * ((--[[---@type tts__CharVectorShape]] factor).z or (--[[---@type tts__NumVectorShape]] factor)[3])
            end

            return self
        end

        ---@return ge_tts__Vector3 @self
        function self.normalize()
            return self.scale(1 / self.length())
        end

        ---@param angle number @angle in degrees
        ---@return ge_tts__Vector3 @self
        function self.rotateX(angle)
            angle = angle * RADIANS_RATIO
            local y = self.y
            self.y = y * math.cos(angle) - self.z * math.sin(angle)
            self.z = y * math.sin(angle) + self.z * math.cos(angle)
            return self
        end

        ---@param angle number @angle in degrees
        ---@return ge_tts__Vector3 @self
        function self.rotateY(angle)
            angle = angle * RADIANS_RATIO
            local x = self.x
            self.x = self.z * math.sin(angle) + x * math.cos(angle)
            self.z = self.z * math.cos(angle) - x * math.sin(angle)
            return self
        end

        ---@param angle number @angle in degrees
        ---@return ge_tts__Vector3 @self
        function self.rotateZ(angle)
            angle = angle * RADIANS_RATIO
            local x = self.x
            self.x = x * math.cos(angle) - self.y * math.sin(angle)
            self.y = x * math.sin(angle) + self.y * math.cos(angle)
            return self
        end

        return self
    end,
})

---@overload fun(v: tts__VectorShape): number
---@param v ge_tts__NumCharVec3
---@return number
function Vector3.lengthSquared(v)
    local x = v.x or v[1]
    local y = v.y or v[2]
    local z = v.z or v[3]
    return x * x + y * y + z * z
end

---@param v tts__VectorShape
---@return number
function Vector3.length(v)
    return math.sqrt(Vector3.lengthSquared(v))
end

---@param v1 tts__VectorShape
---@param v2 tts__VectorShape
---@return ge_tts__Vector3
function Vector3.add(v1, v2)
    return Vector3(v1).add(v2)
end

---@param v1 tts__VectorShape
---@param v2 tts__VectorShape
---@return ge_tts__Vector3
function Vector3.sub(v1, v2)
    return Vector3(v1).sub(v2)
end

---@param v tts__VectorShape
---@param factor number | tts__VectorShape
---@return ge_tts__Vector3
function Vector3.scale(v, factor)
    return Vector3(v).scale(factor)
end

---@param v tts__VectorShape
---@return ge_tts__Vector3
function Vector3.normalize(v)
    return Vector3(v).normalize()
end

---@overload fun(v1: tts__VectorShape, v2: tts__VectorShape): ge_tts__Vector3
---@param v1 ge_tts__NumCharVec3
---@param v2 ge_tts__NumCharVec3
---@return ge_tts__Vector3
function Vector3.cross(v1, v2)
    local x1 = v1.x or v1[1]
    local y1 = v1.y or v1[2]
    local z1 = v1.z or v1[3]

    local x2 = v2.x or v2[1]
    local y2 = v2.y or v2[2]
    local z2 = v2.z or v2[3]

    return Vector3(y1 * z2 - z1 * y2, z1 * x2 - x1 * z2, x1 * y2 - y1 * x2)
end

---@overload fun(v1: tts__VectorShape, v2: tts__VectorShape): number
---@param v1 ge_tts__NumCharVec3
---@param v2 ge_tts__NumCharVec3
---@return number
function Vector3.dot(v1, v2)
    local x1 = v1.x or v1[1]
    local y1 = v1.y or v1[2]
    local z1 = v1.z or v1[3]

    local x2 = v2.x or v2[1]
    local y2 = v2.y or v2[2]
    local z2 = v2.z or v2[3]

    return x1 * x2 + y1 * y2 + z1 * z2
end

---@overload fun(v1: tts__VectorShape, v2: tts__VectorShape): number
---@param v1 ge_tts__NumCharVec3
---@param v2 ge_tts__NumCharVec3
---@return number
function Vector3.distanceSquared(v1, v2)
    local x1 = v1.x or v1[1]
    local y1 = v1.y or v1[2]
    local z1 = v1.z or v1[3]

    local x2 = v2.x or v2[1]
    local y2 = v2.y or v2[2]
    local z2 = v2.z or v2[3]

    return Vector3.lengthSquared({x = x2 - x1, y = y2 - y1, z = z2 - z1})
end

---@overload fun(v1: tts__VectorShape, v2: tts__VectorShape): number
---@param v1 ge_tts__NumCharVec3
---@param v2 ge_tts__NumCharVec3
---@return number
function Vector3.distance(v1, v2)
    return math.sqrt(Vector3.distanceSquared(v1, v2))
end

---@overload fun(v: tts__VectorShape, angle: number): ge_tts__Vector3
---@param v ge_tts__NumCharVec3
---@param angle number @angle in degrees
---@return ge_tts__Vector3
function Vector3.rotateX(v, angle)
    angle = angle * RADIANS_RATIO

    local x = v.x or v[1]
    local y = v.y or v[2]
    local z = v.z or v[3]

    return Vector3(
        x,
        y * math.cos(angle) - z * math.sin(angle),
        y * math.sin(angle) + z * math.cos(angle)
    )
end

---@overload fun(v: tts__VectorShape, angle: number): ge_tts__Vector3
---@param v ge_tts__NumCharVec3
---@param angle number @angle in degrees
---@return ge_tts__Vector3
function Vector3.rotateY(v, angle)
    angle = angle * RADIANS_RATIO

    local x = v.x or v[1]
    local y = v.y or v[2]
    local z = v.z or v[3]

    return Vector3(
        z * math.sin(angle) + x * math.cos(angle),
        y,
        z * math.cos(angle) - x * math.sin(angle)
    )
end

---@overload fun(v: tts__VectorShape, angle: number): ge_tts__Vector3
---@param v ge_tts__NumCharVec3
---@param angle number @angle in degrees
---@return ge_tts__Vector3
function Vector3.rotateZ(v, angle)
    angle = angle * RADIANS_RATIO

    local x = v.x or v[1]
    local y = v.y or v[2]
    local z = v.z or v[3]

    return Vector3(
        x * math.cos(angle) - y * math.sin(angle),
        x * math.sin(angle) + y * math.cos(angle),
        z
    )
end

return Vector3