177 lines
4.9 KiB
Lua
177 lines
4.9 KiB
Lua
Quat = { x = 0.0, y = 0.0, z = 0.0, w = 0.0 }
|
|
Quat.__index = Quat
|
|
Quat.__name = "Quat"
|
|
|
|
--- Constructs a new Quaternion from x, y, z, and w.
|
|
---@param x number
|
|
---@param y number
|
|
---@param z number
|
|
---@param w number
|
|
---@return Quat
|
|
function Quat:new(x, y, z, w)
|
|
local q = {}
|
|
setmetatable(q, Quat)
|
|
|
|
q.x = x
|
|
q.y = y
|
|
q.z = z
|
|
q.w = w
|
|
|
|
return q
|
|
end
|
|
|
|
Quat.IDENTITY = Quat:new(0, 0, 0, 1)
|
|
|
|
function Quat:copy()
|
|
return Quat:new(self.x, self.y, self.z, self.w)
|
|
end
|
|
|
|
--- Creates a quaternion from the angle, in radians, around the x axis.
|
|
--- @param rad number
|
|
--- @return Quat
|
|
function Quat:from_rotation_x(rad)
|
|
local sin = math.sin(rad * 0.5)
|
|
local cos = math.cos(rad * 0.5)
|
|
return Quat:new(sin, 0, 0, cos)
|
|
end
|
|
|
|
--- Creates a quaternion from the angle, in radians, around the y axis.
|
|
--- @param rad number
|
|
--- @return Quat
|
|
function Quat:from_rotation_y(rad)
|
|
local sin = math.sin(rad * 0.5)
|
|
local cos = math.cos(rad * 0.5)
|
|
return Quat:new(0, sin, 0, cos)
|
|
end
|
|
|
|
--- Creates a quaternion from the angle, in radians, around the z axis.
|
|
--- @param rad number
|
|
--- @return Quat
|
|
function Quat:from_rotation_z(rad)
|
|
local sin = math.sin(rad * 0.5)
|
|
local cos = math.cos(rad * 0.5)
|
|
return Quat:new(0, 0, sin, cos)
|
|
end
|
|
|
|
--- Computes the dot product of `self`.
|
|
---@param rhs Quat
|
|
---@return number
|
|
function Quat:dot(rhs)
|
|
return (self.x * rhs.x) + (self.y * rhs.y) + (self.z * rhs.z) + (self.w * rhs.w)
|
|
end
|
|
|
|
--- Computes the length of `self`.
|
|
---@return number
|
|
function Quat:length()
|
|
return math.sqrt(self:dot(self))
|
|
end
|
|
|
|
--- Compute the length of `self` squared.
|
|
---@return number
|
|
function Quat:length_squared()
|
|
return self:length() ^ 2
|
|
end
|
|
|
|
--- Normalizes `self` and returns the new Quat
|
|
---@return unknown
|
|
function Quat:normalize()
|
|
local length = self:length()
|
|
return self / length
|
|
end
|
|
|
|
--- Multiplies two Quaternions together. Keep in mind that Quaternion multiplication is NOT
|
|
--- commutative so the order in which you multiply the quaternions matters.
|
|
---@param rhs Quat
|
|
---@return Quat
|
|
function Quat:mult_quat(rhs)
|
|
local x1, y1, z1, w1 = self.x, self.y, self.z, self.w
|
|
local x2, y2, z2, w2 = rhs.x, rhs.y, rhs.z, rhs.w
|
|
|
|
local x = w1 * x2 + x1 * w2 + y1 * z2 - z1 * y2
|
|
local y = w1 * y2 - x1 * z2 + y1 * w2 + z1 * x2
|
|
local z = w1 * z2 + x1 * y2 - y1 * x2 + z1 * w2
|
|
local w = w1 * w2 - x1 * x2 - y1 * y2 - z1 * x2
|
|
|
|
return Quat:new(x, y, z, w)
|
|
end
|
|
|
|
--- Multiplies `self` by a Vec3, returning the rotated Vec3
|
|
---@param vec Vec3
|
|
---@return Vec3
|
|
function Quat:mult_vec3(vec)
|
|
local vec_quat = Quat:new(vec.x, vec.y, vec.z, 0)
|
|
local quat = self:mult_quat(vec_quat)
|
|
return Vec3:new(quat.x, quat.y, quat.z)
|
|
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 Quat
|
|
--- @param alpha number
|
|
--- @return Quat
|
|
function Quat:lerp(rhs, alpha)
|
|
-- ensure alpha is [0, 1]
|
|
local alpha = math.max(0, math.min(1, alpha))
|
|
|
|
local x1, y1, z1, w1 = self.x, self.y, self.z, self.w
|
|
local x2, y2, z2, w2 = rhs.x, rhs.y, rhs.z, rhs.w
|
|
|
|
local x = (1 - alpha) * x1 + alpha * x2
|
|
local y = (1 - alpha) * y1 + alpha * y2
|
|
local z = (1 - alpha) * z1 + alpha * z2
|
|
local w = (1 - alpha) * w1 + alpha * w2
|
|
|
|
return Quat:new(x, y, z, w):normalize()
|
|
end
|
|
|
|
function Quat:__add(rhs)
|
|
return Quat:new(self.x + rhs.x, self.y + rhs.y, self.z + rhs.z, self.w + rhs.w)
|
|
end
|
|
|
|
function Quat:__sub(rhs)
|
|
return Quat:new(self.x - rhs.x, self.y - rhs.y, self.z - rhs.z, self.w - rhs.w)
|
|
end
|
|
|
|
function Quat:__mul(rhs)
|
|
if type(rhs) == "number" then
|
|
return Quat:new(self.x * rhs, self.y * rhs, self.z * rhs, self.w * rhs)
|
|
elseif type(rhs) == "table" then
|
|
local name = rhs.__name
|
|
|
|
if name == "Vec3" then
|
|
return self:mult_vec3(rhs)
|
|
elseif name == "Quat" then
|
|
return self:mult_quat(rhs)
|
|
else
|
|
assert(false, "Unknown usertype of rhs" .. name)
|
|
end
|
|
else
|
|
assert(false, "Unknown type of rhs" .. type(rhs))
|
|
end
|
|
end
|
|
|
|
function Quat:__div(rhs)
|
|
if type(rhs) == "number" then
|
|
return Quat:new(self.x / rhs, self.y / rhs, self.z / rhs, self.w / rhs)
|
|
else
|
|
assert(rhs.__name == "Quat", "Attempted to divide Quat by unknown type " .. rhs.__name)
|
|
return Quat:new(self.x / rhs.x, self.y / rhs.y, self.z / rhs.z, self.w / rhs.w)
|
|
end
|
|
end
|
|
|
|
function Quat:__eq(rhs)
|
|
return self.x == rhs.x and self.y == rhs.y and self.z == rhs.z and self.w == rhs.w
|
|
end
|
|
|
|
function Quat:__lt(rhs)
|
|
return self.x < rhs.x and self.y < rhs.y and self.z < rhs.z and self.w < rhs.w
|
|
end
|
|
|
|
function Quat:__le(rhs)
|
|
return self.x <= rhs.x and self.y <= rhs.y and self.z <= rhs.z and self.w <= rhs.w
|
|
end
|
|
|
|
function Quat:__tostring()
|
|
return "Quat(" .. self.x .. ", " .. self.y .. ", " .. self.z .. ", " .. self.w .. ")"
|
|
end |