@adiholick/nvstudio-mcp 2.3.0 → 2.4.1

package/studio-plugin/nv_auto_rigger.lua

@@ -0,0 +1,392 @@
+--!strict
+-- ══════════════════════════════════════════════════════════════════════
+-- NVStudio Subsystem: nv_auto_rigger
+-- Deskripsi: Mesin Auto-Rigging Deterministik & Heuristik Geometris
+-- Membangun struktur rig lengkap untuk Avatar R6, R15, Senjata/Prop,
+-- dan Assembly Model secara instan dengan zero-dislocation math.
+-- ══════════════════════════════════════════════════════════════════════
+
+local jointMathMod = script.Parent:WaitForChild("nv_joint_math")
+local JointMath = require(jointMathMod)
+
+local AutoRigger = {}
+
+-- ── Helper: Dapatkan atau buat Motor6D ─────────────────────────────────────────
+local function createOrUpdateMotor(name: string, part0: BasePart, part1: BasePart, parent: Instance?): Motor6D
+	part1.Anchored = false
+	local existing = part0:FindFirstChild(name) or part1:FindFirstChild(name)
+	local motor: Motor6D
+	if existing and existing:IsA("Motor6D") then
+		motor = existing
+	else
+		motor = Instance.new("Motor6D")
+		motor.Name = name
+	end
+
+	motor.Part0 = part0
+	motor.Part1 = part1
+	local c0, c1 = JointMath.computeInitialOffsets(part0, part1)
+	motor.C0 = c0
+	motor.C1 = c1
+	motor.Parent = parent or part0
+	return motor
+end
+
+-- ── 1. Auto-Rig R6 Avatar ─────────────────────────────────────────────────────
+function AutoRigger.rigR6(model: Model): { [string]: any }
+	assert(model and model:IsA("Model"), "Target harus berupa Model")
+
+	local parts: { [string]: BasePart } = {}
+	for _, desc in ipairs(model:GetDescendants()) do
+		if desc:IsA("BasePart") then
+			parts[desc.Name] = desc
+		end
+	end
+
+	local torso = parts["Torso"] or parts["UpperTorso"]
+	if not torso then
+		return { status = "error", error = "Model tidak memiliki part 'Torso' untuk R6 rig." }
+	end
+
+	local rootPart = parts["HumanoidRootPart"]
+	if not rootPart then
+		-- Buat HumanoidRootPart transparan jika belum ada
+		rootPart = Instance.new("Part")
+		rootPart.Name = "HumanoidRootPart"
+		rootPart.Size = Vector3.new(2, 2, 1)
+		rootPart.Transparency = 1
+		rootPart.CanCollide = false
+		rootPart.CFrame = torso.CFrame
+		rootPart.Parent = model
+		parts["HumanoidRootPart"] = rootPart
+		model.PrimaryPart = rootPart
+	end
+
+	local created = {}
+
+	-- 1. RootJoint: HumanoidRootPart -> Torso
+	local rootJoint = createOrUpdateMotor("RootJoint", rootPart, torso, rootPart)
+	table.insert(created, "RootJoint")
+
+	-- 2. Neck: Torso -> Head
+	if parts["Head"] then
+		createOrUpdateMotor("Neck", torso, parts["Head"], torso)
+		table.insert(created, "Neck")
+	end
+
+	-- 3. Shoulders: Torso -> Arms
+	local lArm = parts["Left Arm"] or parts["LeftArm"]
+	if lArm then
+		createOrUpdateMotor("Left Shoulder", torso, lArm, torso)
+		table.insert(created, "Left Shoulder")
+	end
+
+	local rArm = parts["Right Arm"] or parts["RightArm"]
+	if rArm then
+		createOrUpdateMotor("Right Shoulder", torso, rArm, torso)
+		table.insert(created, "Right Shoulder")
+	end
+
+	-- 4. Hips: Torso -> Legs
+	local lLeg = parts["Left Leg"] or parts["LeftLeg"]
+	if lLeg then
+		createOrUpdateMotor("Left Hip", torso, lLeg, torso)
+		table.insert(created, "Left Hip")
+	end
+
+	local rLeg = parts["Right Leg"] or parts["RightLeg"]
+	if rLeg then
+		createOrUpdateMotor("Right Hip", torso, rLeg, torso)
+		table.insert(created, "Right Hip")
+	end
+
+	-- Pastikan Humanoid bertipe R6
+	local humanoid = model:FindFirstChildOfClass("Humanoid")
+	if humanoid then
+		humanoid.RigType = Enum.HumanoidRigType.R6
+	end
+
+	return {
+		status = "success",
+		rigType = "R6",
+		jointsCreated = #created,
+		jointNames = created,
+		rootPart = rootPart.Name
+	}
+end
+
+-- ── 2. Auto-Rig R15 Avatar ────────────────────────────────────────────────────
+function AutoRigger.rigR15(model: Model): { [string]: any }
+	assert(model and model:IsA("Model"), "Target harus berupa Model")
+
+	local parts: { [string]: BasePart } = {}
+	for _, desc in ipairs(model:GetDescendants()) do
+		if desc:IsA("BasePart") then
+			parts[desc.Name] = desc
+		end
+	end
+
+	local lowerTorso = parts["LowerTorso"]
+	local upperTorso = parts["UpperTorso"]
+	if not lowerTorso or not upperTorso then
+		return { status = "error", error = "Model tidak memiliki 'LowerTorso' dan 'UpperTorso' untuk R15 rig." }
+	end
+
+	local rootPart = parts["HumanoidRootPart"]
+	if not rootPart then
+		rootPart = Instance.new("Part")
+		rootPart.Name = "HumanoidRootPart"
+		rootPart.Size = Vector3.new(2, 2, 1)
+		rootPart.Transparency = 1
+		rootPart.CanCollide = false
+		rootPart.CFrame = lowerTorso.CFrame
+		rootPart.Parent = model
+		parts["HumanoidRootPart"] = rootPart
+		model.PrimaryPart = rootPart
+	end
+
+	local r15Hierarchy = {
+		{ name = "Root", p0 = "HumanoidRootPart", p1 = "LowerTorso" },
+		{ name = "Waist", p0 = "LowerTorso", p1 = "UpperTorso" },
+		{ name = "Neck", p0 = "UpperTorso", p1 = "Head" },
+
+		-- Left Arm Chain
+		{ name = "LeftShoulder", p0 = "UpperTorso", p1 = "LeftUpperArm" },
+		{ name = "LeftElbow", p0 = "LeftUpperArm", p1 = "LeftLowerArm" },
+		{ name = "LeftWrist", p0 = "LeftLowerArm", p1 = "LeftHand" },
+
+		-- Right Arm Chain
+		{ name = "RightShoulder", p0 = "UpperTorso", p1 = "RightUpperArm" },
+		{ name = "RightElbow", p0 = "RightUpperArm", p1 = "RightLowerArm" },
+		{ name = "RightWrist", p0 = "RightLowerArm", p1 = "RightHand" },
+
+		-- Left Leg Chain
+		{ name = "LeftHip", p0 = "LowerTorso", p1 = "LeftUpperLeg" },
+		{ name = "LeftKnee", p0 = "LeftUpperLeg", p1 = "LeftLowerLeg" },
+		{ name = "LeftAnkle", p0 = "LeftLowerLeg", p1 = "LeftFoot" },
+
+		-- Right Leg Chain
+		{ name = "RightHip", p0 = "LowerTorso", p1 = "RightUpperLeg" },
+		{ name = "RightKnee", p0 = "RightUpperLeg", p1 = "RightLowerLeg" },
+		{ name = "RightAnkle", p0 = "RightLowerLeg", p1 = "RightFoot" }
+	}
+
+	local created = {}
+	for _, item in ipairs(r15Hierarchy) do
+		local p0 = parts[item.p0]
+		local p1 = parts[item.p1]
+		if p0 and p1 then
+			createOrUpdateMotor(item.name, p0, p1, p0)
+			table.insert(created, item.name)
+		end
+	end
+
+	local humanoid = model:FindFirstChildOfClass("Humanoid")
+	if humanoid then
+		humanoid.RigType = Enum.HumanoidRigType.R15
+	end
+
+	return {
+		status = "success",
+		rigType = "R15",
+		jointsCreated = #created,
+		jointNames = created,
+		rootPart = rootPart.Name
+	}
+end
+
+-- ── 3. Rig Weapon / Tool ke Karakter ──────────────────────────────────────────
+function AutoRigger.rigWeapon(characterModel: Model, weaponInstance: Instance, targetLimbName: string?): { [string]: any }
+	assert(characterModel and characterModel:IsA("Model"), "Character target harus berupa Model")
+	assert(weaponInstance and weaponInstance:IsA("Instance"), "Weapon target tidak valid")
+
+	local parts: { [string]: BasePart } = {}
+	for _, desc in ipairs(characterModel:GetDescendants()) do
+		if desc:IsA("BasePart") then
+			parts[desc.Name] = desc
+		end
+	end
+
+	local limb = targetLimbName and parts[targetLimbName]
+	if not limb then
+		limb = parts["RightHand"] or parts["Right Arm"] or parts["RightArm"] or parts["HumanoidRootPart"]
+	end
+	if not limb then
+		return { status = "error", error = "Tidak dapat menemukan anggota tubuh target (RightHand / Right Arm) pada karakter." }
+	end
+
+	-- Cari handle pada senjata
+	local weaponHandle: BasePart? = nil
+	if weaponInstance:IsA("BasePart") then
+		weaponHandle = weaponInstance
+	elseif weaponInstance:IsA("Model") or weaponInstance:IsA("Tool") then
+		weaponHandle = (weaponInstance :: any).PrimaryPart
+			or weaponInstance:FindFirstChild("Handle") :: BasePart?
+			or weaponInstance:FindFirstChildWhichIsA("BasePart")
+	end
+
+	if not weaponHandle then
+		return { status = "error", error = "Senjata tidak memiliki BasePart atau Handle." }
+	end
+
+	-- 1. Buat Motor6D penaut karakter ke Handle
+	local weaponMotor = createOrUpdateMotor("WeaponGrip", limb, weaponHandle, limb)
+
+	-- 2. Las seluruh bagian senjata lain ke Handle
+	local weldedCount = 0
+	if weaponInstance ~= weaponHandle then
+		for _, desc in ipairs(weaponInstance:GetDescendants()) do
+			if desc:IsA("BasePart") and desc ~= weaponHandle then
+				desc.Anchored = false
+				local weld = desc:FindFirstChild("WeldToHandle") or Instance.new("Weld")
+				weld.Name = "WeldToHandle"
+				weld.Part0 = weaponHandle
+				weld.Part1 = desc
+				weld.C0 = weaponHandle.CFrame:ToObjectSpace(desc.CFrame)
+				weld.C1 = CFrame.identity
+				weld.Parent = weaponHandle
+				weldedCount += 1
+			end
+		end
+	end
+
+	return {
+		status = "success",
+		attachedTo = limb.Name,
+		handleName = weaponHandle.Name,
+		weldedComponents = weldedCount,
+		message = string.format("Senjata '%s' berhasil dirig ke '%s' (%d part dilas)", weaponInstance.Name, limb.Name, weldedCount)
+	}
+end
+
+-- ── 4. Weld Assembly (Props, Armor, Kendaraan) ────────────────────────────────
+function AutoRigger.weldAssembly(container: Instance, primaryPart: BasePart?): { [string]: any }
+	assert(container and container:IsA("Instance"), "Container tidak valid")
+
+	local rootPart: BasePart? = primaryPart
+	if not rootPart and container:IsA("Model") then
+		rootPart = container.PrimaryPart
+	end
+
+	local allParts: { BasePart } = {}
+	for _, desc in ipairs(container:GetDescendants()) do
+		if desc:IsA("BasePart") then
+			table.insert(allParts, desc)
+		end
+	end
+	if container:IsA("BasePart") then
+		table.insert(allParts, container)
+	end
+
+	if #allParts == 0 then
+		return { status = "error", error = "Tidak ada BasePart di dalam kontainer untuk dilas." }
+	end
+
+	-- Jika belum ada rootPart, tentukan berdasarkan volume terbesar
+	if not rootPart then
+		local maxVol = -1
+		for _, p in ipairs(allParts) do
+			local vol = p.Size.X * p.Size.Y * p.Size.Z
+			if vol > maxVol then
+				maxVol = vol
+				rootPart = p
+			end
+		end
+	end
+
+	if not rootPart then
+		return { status = "error", error = "Gagal menentukan Root Part untuk pengelasan." }
+	end
+
+	local weldsCreated = 0
+	for _, p in ipairs(allParts) do
+		if p ~= rootPart then
+			p.Anchored = false
+			local w = p:FindFirstChild("AssemblyWeld") or Instance.new("Weld")
+			w.Name = "AssemblyWeld"
+			w.Part0 = rootPart
+			w.Part1 = p
+			w.C0 = rootPart.CFrame:ToObjectSpace(p.CFrame)
+			w.C1 = CFrame.identity
+			w.Parent = rootPart
+			weldsCreated += 1
+		end
+	end
+
+	return {
+		status = "success",
+		rootPart = rootPart.Name,
+		weldsCreated = weldsCreated,
+		message = string.format("Berhasil mengelas %d part ke Root '%s'", weldsCreated, rootPart.Name)
+	}
+end
+
+-- ── 5. Spatial Geometric Limb Analyzer (Heuristik Bounding Box) ───────────────
+-- Menganalisis model dengan nama part acak/impor dan mengklasifikasikan anggota tubuh
+function AutoRigger.discoverLimbsBySpatialGeometry(model: Model): { [string]: BasePart }
+	local parts: { BasePart } = {}
+	for _, desc in ipairs(model:GetDescendants()) do
+		if desc:IsA("BasePart") then
+			table.insert(parts, desc)
+		end
+	end
+
+	if #parts == 0 then return {} end
+
+	-- 1. Hitung bounding box pusat model
+	local cframe, size = model:GetBoundingBox()
+	local center = cframe.Position
+
+	-- 2. Temukan torso (part dengan volume besar di sekitar pusat vertikal)
+	local bestTorso: BasePart = parts[1]
+	local bestScore = -1e9
+
+	for _, p in ipairs(parts) do
+		local vol = p.Size.X * p.Size.Y * p.Size.Z
+		local distToCenter = (p.Position - center).Magnitude
+		local score = vol / (distToCenter + 1)
+		if score > bestScore then
+			bestScore = score
+			bestTorso = p
+		end
+	end
+
+	local identified: { [string]: BasePart } = {
+		Torso = bestTorso
+	}
+
+	local torsoPos = bestTorso.Position
+
+	-- 3. Klasifikasi part lainnya relatif terhadap Torso
+	for _, p in ipairs(parts) do
+		if p ~= bestTorso then
+			local relPos = bestTorso.CFrame:PointToObjectSpace(p.Position)
+
+			if relPos.Y > bestTorso.Size.Y * 0.5 then
+				-- Bagian atas -> Head
+				if not identified["Head"] or p.Position.Y > identified["Head"].Position.Y then
+					identified["Head"] = p
+				end
+			elseif relPos.Y < -bestTorso.Size.Y * 0.3 then
+				-- Bagian bawah -> Legs
+				if relPos.X < 0 then
+					identified["Left Leg"] = p
+				else
+					identified["Right Leg"] = p
+				end
+			else
+				-- Bagian samping -> Arms
+				if relPos.X < 0 then
+					identified["Left Arm"] = p
+				else
+					identified["Right Arm"] = p
+				end
+			end
+		end
+	end
+
+	return identified
+end
+
+return AutoRigger
+

package/studio-plugin/nv_curves.lua

@@ -0,0 +1,260 @@
+--!strict
+--!native
+-- ══════════════════════════════════════════════════════════════════════
+-- NVStudio Subsystem: nv_curves
+-- Deskripsi: Mesin Kurva Cubic Bezier, Easing Functions & Quaternion SLERP
+-- Menghitung interpolasi waktu dan rotasi sendi secara ultra-halus
+-- layaknya kurva Graph Editor animator profesional.
+-- ══════════════════════════════════════════════════════════════════════
+
+local Curves = {}
+local PI = math.pi
+local HALF_PI = math.pi * 0.5
+local TAU = math.pi * 2
+local DEFAULT_OVERSHOOT = 1.70158
+
+-- ── 1. Cubic Bezier Solver ───────────────────────────────────────────────────
+function Curves.bezierParameter(alpha: number, x1: number, x2: number): number
+	if alpha <= 0 then return 0 end
+	if alpha >= 1 then return 1 end
+
+	x1 = math.clamp(x1, 0, 1)
+	x2 = math.clamp(x2, 0, 1)
+
+	local lo, hi, u = 0, 1, alpha
+	for _ = 1, 32 do
+		local v = 1 - u
+		local x = 3 * v * v * u * x1 + 3 * v * u * u * x2 + u * u * u
+		local delta = x - alpha
+		if math.abs(delta) <= 1e-7 then
+			break
+		end
+
+		if delta < 0 then
+			lo = u
+		else
+			hi = u
+		end
+
+		local deriv = 3 * v * v * x1 + 6 * v * u * (x2 - x1) + 3 * u * u * (1 - x2)
+		local cand = deriv > 1e-7 and (u - delta / deriv) or -1
+		u = (cand > lo and cand < hi) and cand or (lo + hi) * 0.5
+	end
+
+	return u
+end
+
+function Curves.cubic(a: number, b: number, c: number, d: number, u: number): number
+	local v = 1 - u
+	return a * (v * v * v) + b * (3 * v * v * u) + c * (3 * v * u * u) + d * (u * u * u)
+end
+
+function Curves.bezierAlpha(t: number, x1: number?, y1: number?, x2: number?, y2: number?): number
+	if t <= 0 then return 0 end
+	if t >= 1 then return 1 end
+
+	local px1 = x1 or 0.42
+	local py1 = y1 or 0.0
+	local px2 = x2 or 0.58
+	local py2 = y2 or 1.0
+
+	local u = Curves.bezierParameter(t, px1, px2)
+	return Curves.cubic(0, py1, py2, 1, u)
+end
+
+-- ── 2. Standard Easing Functions ─────────────────────────────────────────────
+local EasingTable: { [string]: (t: number) -> number } = {
+	Linear = function(t) return t end,
+
+	SineIn = function(t) return 1 - math.cos(t * HALF_PI) end,
+	SineOut = function(t) return math.sin(t * HALF_PI) end,
+	SineInOut = function(t) return -(math.cos(PI * t) - 1) * 0.5 end,
+
+	QuadIn = function(t) return t * t end,
+	QuadOut = function(t) return t * (2 - t) end,
+	QuadInOut = function(t) return t < 0.5 and (2 * t * t) or (-1 + (4 - 2 * t) * t) end,
+
+	CubicIn = function(t) return t * t * t end,
+	CubicOut = function(t) local f = t - 1 return f * f * f + 1 end,
+	CubicInOut = function(t) return t < 0.5 and (4 * t * t * t) or ((t - 1) * (2 * t - 2) * (2 * t - 2) + 1) end,
+
+	QuartIn = function(t) return t * t * t * t end,
+	QuartOut = function(t) local f = t - 1 return 1 - f * f * f * f end,
+	QuartInOut = function(t) local f = t - 1 return t < 0.5 and (8 * t * t * t * t) or (1 - 8 * f * f * f * f) end,
+
+	ExpoIn = function(t) return t == 0 and 0 or math.pow(2, 10 * (t - 1)) end,
+	ExpoOut = function(t) return t == 1 and 1 or (1 - math.pow(2, -10 * t)) end,
+	ExpoInOut = function(t)
+		if t == 0 then return 0 end
+		if t == 1 then return 1 end
+		if t < 0.5 then return math.pow(2, 20 * t - 10) * 0.5 end
+		return (2 - math.pow(2, -20 * t + 10)) * 0.5
+	end,
+
+	BackIn = function(t) local s = DEFAULT_OVERSHOOT return t * t * ((s + 1) * t - s) end,
+	BackOut = function(t) local s = DEFAULT_OVERSHOOT local f = t - 1 return f * f * ((s + 1) * f + s) + 1 end,
+	BackInOut = function(t)
+		local s = DEFAULT_OVERSHOOT * 1.525
+		local f = t * 2
+		if f < 1 then return 0.5 * (f * f * ((s + 1) * f - s)) end
+		f = f - 2
+		return 0.5 * (f * f * ((s + 1) * f + s) + 2)
+	end,
+
+	BounceOut = function(t)
+		if t < (1 / 2.75) then
+			return 7.5625 * t * t
+		elseif t < (2 / 2.75) then
+			local f = t - (1.5 / 2.75)
+			return 7.5625 * f * f + 0.75
+		elseif t < (2.5 / 2.75) then
+			local f = t - (2.25 / 2.75)
+			return 7.5625 * f * f + 0.9375
+		else
+			local f = t - (2.625 / 2.75)
+			return 7.5625 * f * f + 0.984375
+		end
+	end,
+	BounceIn = function(t)
+		local fn = nil
+		-- forward declaration
+		return 1 - (function(x)
+			if x < (1 / 2.75) then return 7.5625 * x * x
+			elseif x < (2 / 2.75) then local f = x - (1.5 / 2.75) return 7.5625 * f * f + 0.75
+			elseif x < (2.5 / 2.75) then local f = x - (2.25 / 2.75) return 7.5625 * f * f + 0.9375
+			else local f = x - (2.625 / 2.75) return 7.5625 * f * f + 0.984375 end
+		end)(1 - t)
+	end,
+	BounceInOut = function(t)
+		local bounceOut = function(x: number): number
+			if x < (1 / 2.75) then return 7.5625 * x * x
+			elseif x < (2 / 2.75) then local f = x - (1.5 / 2.75) return 7.5625 * f * f + 0.75
+			elseif x < (2.5 / 2.75) then local f = x - (2.25 / 2.75) return 7.5625 * f * f + 0.9375
+			else local f = x - (2.625 / 2.75) return 7.5625 * f * f + 0.984375 end
+		end
+		if t < 0.5 then
+			return (1 - bounceOut(1 - t * 2)) * 0.5
+		end
+		return bounceOut(t * 2 - 1) * 0.5 + 0.5
+	end,
+
+	ElasticOut = function(t)
+		if t == 0 then return 0 end
+		if t == 1 then return 1 end
+		local p = 0.3
+		local s = p / 4
+		return math.pow(2, -10 * t) * math.sin((t - s) * TAU / p) + 1
+	end,
+	ElasticIn = function(t)
+		if t == 0 then return 0 end
+		if t == 1 then return 1 end
+		local p = 0.3
+		local s = p / 4
+		local f = t - 1
+		return -(math.pow(2, 10 * f) * math.sin((f - s) * TAU / p))
+	end,
+	ElasticInOut = function(t)
+		if t == 0 then return 0 end
+		if t == 1 then return 1 end
+		local p = 0.3 * 1.5
+		local s = p / 4
+		local f = t * 2 - 1
+		if f < 0 then
+			return -0.5 * (math.pow(2, 10 * f) * math.sin((f - s) * TAU / p))
+		end
+		return math.pow(2, -10 * f) * math.sin((f - s) * TAU / p) * 0.5 + 1
+	end
+}
+
+function Curves.evaluate(easingName: string?, t: number): number
+	t = math.clamp(t, 0, 1)
+	local name = easingName or "QuadInOut"
+	local fn = EasingTable[name]
+	if fn then
+		return fn(t)
+	end
+	return t
+end
+
+-- ── 3. Quaternion SLERP (Spherical Linear Interpolation) ──────────────────────
+-- Representasi Quaternion: { x, y, z, w }
+type Quat = { x: number, y: number, z: number, w: number }
+
+local function cframeToQuat(cf: CFrame): (Vector3, Quat)
+	local _, _, _, m00, m01, m02, m10, m11, m12, m20, m21, m22 = cf:GetComponents()
+	local trace = m00 + m11 + m22
+	local q: Quat
+	if trace > 0 then
+		local s = math.sqrt(trace + 1) * 2
+		q = { x = (m21 - m12) / s, y = (m02 - m20) / s, z = (m10 - m01) / s, w = 0.25 * s }
+	elseif (m00 > m11) and (m00 > m22) then
+		local s = math.sqrt(1 + m00 - m11 - m22) * 2
+		q = { x = 0.25 * s, y = (m01 + m10) / s, z = (m02 + m20) / s, w = (m21 - m12) / s }
+	elseif m11 > m22 then
+		local s = math.sqrt(1 + m11 - m00 - m22) * 2
+		q = { x = (m01 + m10) / s, y = 0.25 * s, z = (m12 + m21) / s, w = (m02 - m20) / s }
+	else
+		local s = math.sqrt(1 + m22 - m00 - m11) * 2
+		q = { x = (m02 + m20) / s, y = (m12 + m21) / s, z = 0.25 * s, w = (m10 - m01) / s }
+	end
+	return cf.Position, q
+end
+
+local function quatToCFrame(pos: Vector3, q: Quat): CFrame
+	local x, y, z, w = q.x, q.y, q.z, q.w
+	local xx, yy, zz = x * x, y * y, z * z
+	local xy, xz, yz = x * y, x * z, y * z
+	local wx, wy, wz = w * x, w * y, w * z
+
+	return CFrame.new(
+		pos.X, pos.Y, pos.Z,
+		1 - 2 * (yy + zz), 2 * (xy - wz), 2 * (xz + wy),
+		2 * (xy + wz), 1 - 2 * (xx + zz), 2 * (yz - wx),
+		2 * (xz - wy), 2 * (yz + wx), 1 - 2 * (xx + yy)
+	)
+end
+
+function Curves.slerp(cfA: CFrame, cfB: CFrame, alpha: number): CFrame
+	if alpha <= 0 then return cfA end
+	if alpha >= 1 then return cfB end
+
+	local posA, qA = cframeToQuat(cfA)
+	local posB, qB = cframeToQuat(cfB)
+
+	local cosHalfTheta = qA.x * qB.x + qA.y * qB.y + qA.z * qB.z + qA.w * qB.w
+	if cosHalfTheta < 0 then
+		qB = { x = -qB.x, y = -qB.y, z = -qB.z, w = -qB.w }
+		cosHalfTheta = -cosHalfTheta
+	end
+
+	local qResult: Quat
+	if math.abs(cosHalfTheta) >= 1 then
+		qResult = qA
+	else
+		local halfTheta = math.acos(math.clamp(cosHalfTheta, -1, 1))
+		local sinHalfTheta = math.sqrt(1 - cosHalfTheta * cosHalfTheta)
+		if math.abs(sinHalfTheta) < 1e-4 then
+			qResult = {
+				x = qA.x * (1 - alpha) + qB.x * alpha,
+				y = qA.y * (1 - alpha) + qB.y * alpha,
+				z = qA.z * (1 - alpha) + qB.z * alpha,
+				w = qA.w * (1 - alpha) + qB.w * alpha,
+			}
+		else
+			local ratioA = math.sin((1 - alpha) * halfTheta) / sinHalfTheta
+			local ratioB = math.sin(alpha * halfTheta) / sinHalfTheta
+			qResult = {
+				x = qA.x * ratioA + qB.x * ratioB,
+				y = qA.y * ratioA + qB.y * ratioB,
+				z = qA.z * ratioA + qB.z * ratioB,
+				w = qA.w * ratioA + qB.w * ratioB,
+			}
+		end
+	end
+
+	local interpPos = posA:Lerp(posB, alpha)
+	return quatToCFrame(interpPos, qResult)
+end
+
+return Curves
+