161 lines
4.0 KiB
Lua
161 lines
4.0 KiB
Lua
Vec3 = { x = 0.0, y = 0.0, z = 0.0 }
|
|
Vec3.__index = Vec3
|
|
Vec3.__name = "Vec3"
|
|
|
|
--- Constructs a new vector
|
|
---@param x number
|
|
---@param y number
|
|
---@param z number
|
|
---@return Vec3
|
|
function Vec3:new(x, y, z)
|
|
local v = {}
|
|
setmetatable(v, Vec3)
|
|
|
|
v.x = x
|
|
v.y = y
|
|
v.z = z
|
|
|
|
return v
|
|
end
|
|
|
|
function Vec3:copy()
|
|
return Vec3:new(self.x, self.y, self.z)
|
|
end
|
|
|
|
--- Constructs a vector with all elements as parameter `x`.
|
|
---@param x number
|
|
---@return Vec3
|
|
function Vec3:all(x)
|
|
return Vec3:new(x, x, x)
|
|
end
|
|
|
|
--- A unit-length vector pointing alongside the positive X axis.
|
|
Vec3.X = Vec3:new(1, 0, 0)
|
|
--- A unit-length vector pointing alongside the positive Y axis.
|
|
Vec3.Y = Vec3:new(0, 1, 0)
|
|
--- A unit-length vector pointing alongside the positive Z axis.
|
|
Vec3.Z = Vec3:new(0, 0, 1)
|
|
|
|
--- A unit-length vector pointing alongside the negative X axis.
|
|
Vec3.NEG_X = Vec3:new(-1, 0, 0)
|
|
--- A unit-length vector pointing alongside the negative Y axis.
|
|
Vec3.NEG_Y = Vec3:new(0, -1, 0)
|
|
--- A unit-length vector pointing alongside the negative Z axis.
|
|
Vec3.NEG_Z = Vec3:new(0, 0, -1)
|
|
|
|
--- A vector of all zeros
|
|
Vec3.ZERO = Vec3:new(0, 0, 0)
|
|
--- A vector of all ones
|
|
Vec3.ONE = Vec3:new(1, 1, 1)
|
|
|
|
--- Computes the absolute value of `self`.
|
|
---@return Vec3
|
|
function Vec3:abs()
|
|
return Vec3:new(math.abs(self.x), math.abs(self.y), math.abs(self.z))
|
|
end
|
|
|
|
--- Computes the length of `self`.
|
|
---@return number
|
|
function Vec3:length()
|
|
return math.sqrt(self:dot(self))
|
|
end
|
|
|
|
--- Computes the dot product of `self` and `rhs`.
|
|
---@param rhs Vec3
|
|
---@return number
|
|
function Vec3:dot(rhs)
|
|
assert(rhs.__name == "Vec3")
|
|
|
|
return (self.x * rhs.x) + (self.y * rhs.y) + (self.z * rhs.z)
|
|
end
|
|
|
|
--- Returns a vector that has the minimum value of each element of `self` and `rhs`
|
|
---@param rhs Vec3
|
|
---@return Vec3
|
|
function Vec3:min(rhs)
|
|
local x = math.min(self.x, rhs.x)
|
|
local y = math.min(self.y, rhs.y)
|
|
local z = math.min(self.z, rhs.z)
|
|
|
|
return Vec3:new(x, y, z)
|
|
end
|
|
|
|
--- Returns `self` normalized to a length 1.
|
|
---@return unknown
|
|
function Vec3:normalize()
|
|
local len_recip = 1.0 / self:length()
|
|
return self * len_recip
|
|
end
|
|
|
|
--- Calculates the linear iterpolation between `self` and `rhs` based on the `alpha`.
|
|
--- When `alpha` is `0`, the result will be equal to `self`. When `s` is `1`, the result
|
|
--- will be equal to `rhs`
|
|
--- @param rhs Vec3
|
|
--- @param alpha number
|
|
--- @return Vec3
|
|
function Vec3:lerp(rhs, alpha)
|
|
-- ensure alpha is [0, 1]
|
|
local alpha = math.max(0, math.min(1, alpha))
|
|
|
|
local res = self:copy()
|
|
res = res + ((rhs - res) * alpha)
|
|
return res
|
|
end
|
|
|
|
function Vec3:__add(rhs)
|
|
return Vec3:new(self.x + rhs.x, self.y + rhs.y, self.z + rhs.z)
|
|
end
|
|
|
|
function Vec3:__sub(rhs)
|
|
return Vec3:new(self.x - rhs.x, self.y - rhs.y, self.z - rhs.z)
|
|
end
|
|
|
|
function Vec3:__mul(rhs)
|
|
if type(rhs) == "number" then
|
|
return Vec3:new(self.x * rhs, self.y * rhs, self.z * rhs)
|
|
else
|
|
return Vec3:new(self.x * rhs.x, self.y * rhs.y, self.z * rhs.z)
|
|
end
|
|
end
|
|
|
|
function Vec3:__div(rhs)
|
|
if type(rhs) == "number" then
|
|
return Vec3:new(self.x / rhs, self.y / rhs, self.z / rhs)
|
|
else
|
|
return Vec3:new(self.x / rhs.x, self.y / rhs.y, self.z / rhs.z)
|
|
end
|
|
end
|
|
|
|
function Vec3:__idiv(rhs)
|
|
if type(rhs) == "number" then
|
|
return Vec3:new(self.x // rhs, self.y // rhs, self.z // rhs)
|
|
else
|
|
return Vec3:new(self.x // rhs.x, self.y // rhs.y, self.z // rhs.z)
|
|
end
|
|
end
|
|
|
|
function Vec3:__unm()
|
|
return Vec3:new(-self.x, -self.y, -self.z)
|
|
end
|
|
|
|
function Vec3:__pow(rhs)
|
|
if type(rhs) == "number" then
|
|
return Vec3:new(self.x ^ rhs, self.y ^ rhs, self.z ^ rhs)
|
|
end
|
|
end
|
|
|
|
function Vec3:__eq(rhs)
|
|
return self.x == rhs.x and self.y == rhs.y and self.z == rhs.z
|
|
end
|
|
|
|
function Vec3:__lt(rhs)
|
|
return self.x < rhs.x and self.y < rhs.y and self.z < rhs.z
|
|
end
|
|
|
|
function Vec3:__le(rhs)
|
|
return self.x <= rhs.x and self.y <= rhs.y and self.z <= rhs.z
|
|
end
|
|
|
|
function Vec3:__tostring()
|
|
return "Vec3(" .. self.x .. ", " .. self.y .. ", " .. self.z .. ")"
|
|
end |