cluaupp 0.1.0

package/runtime/EzVisualz/Gradient.luau

@@ -0,0 +1,452 @@
+local RunService = game:GetService("RunService");
+local SmartAssert = require(script.Parent.Util);
+
+type ColorSequenceKeypoints = typeof(ColorSequence.new(Color3.new()).Keypoints);
+type NumberSequenceKeypoints = typeof(NumberSequence.new(0).Keypoints);
+export type Gradient<T...> = {
+	UIInstance: GuiObject,
+	Instance: UIGradient,
+	IsPaused: boolean,
+
+	ColorSequence: ColorSequence,
+	ColorSequenceTarget: ColorSequence,
+	TrueColorSequence: ColorSequence?,
+	ColorSequenceBlendRate: number,
+
+	TransparencySequence: NumberSequence,
+	TransparencySequenceTarget: NumberSequence,
+	TrueTransparencySequence: NumberSequence?,
+	TransparencySequenceBlendRate: number,
+
+	Offset: number,
+	OffsetTarget: number?,
+	OffsetSpeed: number,
+	OffsetSpeedTarget: number,
+	OffsetAcceleration: number,
+
+	TransparencyOffset: number,
+	TransparencyOffsetTarget: number?,
+	TransparencyOffsetSpeed: number,
+	TransparencyOffsetSpeedTarget: number,
+	TransparencyOffsetAcceleration: number,
+
+	Rotation: number,
+	RotationTarget: number?,
+	RotationSpeed: number,
+	RotationSpeedTarget: number,
+	RotationAcceleration: number,
+
+	Connection: RBXScriptConnection,
+	IsText: boolean,
+
+	Pause: (self: Gradient<T...>) -> nil,
+	Resume: (self: Gradient<T...>) -> nil,
+	SetColorSequence: (self: Gradient<T...>, sequence: ColorSequence, blendRate: number?) -> ColorSequence,
+	SetOffset: (self: Gradient<T...>, offset: number, acceleration: number) -> nil,
+	SetOffsetSpeed: (self: Gradient<T...>, offset: number, acceleration: number) -> nil,
+	SetRotation: (self: Gradient<T...>, rotation: number, acceleration: number) -> nil,
+	SetRotationSpeed: (self: Gradient<T...>, rotation: number, acceleration: number) -> nil,
+	SetTransparencyOffset: (self: Gradient<T...>, offset: number, acceleration: number) -> nil,
+	SetTransparencyOffsetSpeed: (self: Gradient<T...>, offset: number, acceleration: number) -> nil,
+	SetTransparencySequence: (self: Gradient<T...>, transparency: number | NumberSequence, acceleration: number?) -> nil,
+	EqualizeColorSequenceKeypoints: (self: Gradient<T...>) -> nil,
+	EqualizeTransparencySequenceKeypoints: (self: Gradient<T...>) -> nil,
+	CalculateTrueColorSequence: (self: Gradient<T...>) -> ColorSequence,
+	CalculateTrueTransparencySequence: (self: Gradient<T...>) -> NumberSequence,
+	Destroy: (self: Gradient<T...>) -> nil,
+};
+
+local function evalColorSequence(inputSequence: ColorSequenceKeypoints, time: number)
+	local sequence = {};
+	time += 1;
+
+	for x = 0, 2 do
+		for i = 1, #inputSequence do
+			local datapoint = {Time = inputSequence[i].Time + x, Value = inputSequence[i].Value};
+			table.insert(sequence, datapoint);
+		end;
+	end;
+
+	-- Otherwise, step through each sequential pair of keypoints
+	for i = 1, #sequence - 1 do
+		local thisKeypoint = sequence[i];
+		local nextKeypoint = sequence[i + 1];
+		if (time >= thisKeypoint.Time and time < nextKeypoint.Time) then
+			-- Calculate how far alpha lies between the points
+			local alpha = (time - thisKeypoint.Time) / (nextKeypoint.Time - thisKeypoint.Time);
+			-- Evaluate the real value between the points using alpha
+			return Color3.new(
+				(nextKeypoint.Value.R - thisKeypoint.Value.R) * alpha + thisKeypoint.Value.R,
+				(nextKeypoint.Value.G - thisKeypoint.Value.G) * alpha + thisKeypoint.Value.G,
+				(nextKeypoint.Value.B - thisKeypoint.Value.B) * alpha + thisKeypoint.Value.B
+			);
+		end;
+	end;
+end
+
+local function evalNumberSequence(inputSequence: NumberSequenceKeypoints, time: number)
+	local sequence = {};
+	time += 1;
+
+	for x = 0, 2 do
+		for i = 1, #inputSequence do
+			local datapoint = {Time = inputSequence[i].Time + x, Value = inputSequence[i].Value};
+			table.insert(sequence, datapoint);
+		end;
+	end;
+
+	-- Otherwise, step through each sequential pair of keypoints
+	for i = 1, #sequence - 1 do
+		local thisKeypoint = sequence[i];
+		local nextKeypoint = sequence[i + 1];
+		if (time >= thisKeypoint.Time and time < nextKeypoint.Time) then
+			-- Calculate how far alpha lies between the points
+			local alpha = (time - thisKeypoint.Time) / (nextKeypoint.Time - thisKeypoint.Time);
+			-- Evaluate the real value between the points using alpha
+			return thisKeypoint.Value + (nextKeypoint.Value - thisKeypoint.Value) * alpha;
+		end;
+	end;
+end
+
+local MAX_COLORSEQUENCE_KEYPOINTS = 19;
+local MAX_NUMBERSEQUENCE_KEYPOINTS = 19;
+local Gradient = {};
+Gradient.__index = Gradient;
+
+function Gradient.new<T...>(uiInstance: GuiObject | UIStroke, colorSequence: ColorSequence, transparencySequence: number | NumberSequence): Gradient<T...>
+	SmartAssert(uiInstance ~= nil, "UIInstance not provided");
+	SmartAssert(uiInstance:IsA("GuiObject") or uiInstance:IsA("UIStroke"), "UIInstance is not a GuiObject or UIStroke");
+	SmartAssert(colorSequence ~= nil, "ColorSequence not provided");
+	SmartAssert(transparencySequence ~= nil, "TransparencySequence not provided")
+	SmartAssert(typeof(colorSequence) == "ColorSequence", "ColorSequence is not a ColorSequence");
+	SmartAssert(typeof(transparencySequence) == "number" or typeof(transparencySequence) == "NumberSequence", "TransparencySequence is not a number or NumberSequence");
+	SmartAssert(#colorSequence.Keypoints <= MAX_COLORSEQUENCE_KEYPOINTS, "ColorSequence has too many keypoints");
+	if (typeof(transparencySequence) == "NumberSequence") then
+		SmartAssert(#transparencySequence.Keypoints <= MAX_NUMBERSEQUENCE_KEYPOINTS, "TransparencySequence has too many keypoints");
+	end;
+
+	local self = {};
+
+	self.UIInstance = uiInstance;
+	self.Instance = uiInstance:FindFirstChildWhichIsA("UIGradient") or Instance.new("UIGradient");
+	self.IsPaused = false;
+
+	self.ColorSequenceTarget = colorSequence;
+	self.ColorSequence = colorSequence;
+	self.TrueColorSequence = nil;
+	self.ColorSequenceBlendRate = 1;
+
+	self.TransparencySequenceTarget = nil;
+	self.TransparencySequence = nil;
+	self.TrueTransparencySequence = nil;
+	self.TransparencySequenceBlendRate = 1;
+
+	self.Offset = 0;
+	self.OffsetTarget = nil;
+	self.OffsetSpeed = 0;
+	self.OffsetSpeedTarget = 0;
+	self.OffsetAcceleration = 1;
+
+	self.TransparencyOffset = 0;
+	self.TransparencyOffsetTarget = nil;
+	self.TransparencyOffsetSpeed = 0;
+	self.TransparencyOffsetSpeedTarget = 0;
+	self.TransparencyOffsetAcceleration = 1;
+
+	self.Rotation = 0;
+	self.RotationSpeed = 0;
+	self.RotationSpeedTarget = 0;
+	self.RotationAcceleration = 0;
+	self.RotationTarget = nil;
+
+	self.Connection = nil;
+	self.IsText = false;
+
+	if (typeof(transparencySequence) == "number") then
+		self.TransparencySequenceTarget = NumberSequence.new({NumberSequenceKeypoint.new(0, transparencySequence), NumberSequenceKeypoint.new(1, transparencySequence)});
+	elseif (typeof(transparencySequence) == "NumberSequence") then
+		self.TransparencySequenceTarget = transparencySequence;
+	else
+		warn("Weird type of data?");
+	end;
+
+	self.TransparencySequence = self.TransparencySequenceTarget;
+
+	if (uiInstance:IsA("TextLabel") or uiInstance:IsA("TextBox") or uiInstance:IsA("TextButton")) then
+		self.IsText = true;
+	end;
+
+	self.Connection = RunService.Heartbeat:Connect(function(dt)
+		if (self.IsPaused) then
+			return;
+		end;
+
+		if (not self.UIInstance or self.UIInstance.Parent == nil) then
+			self:Destroy();
+			return;
+		end;
+
+		if (self.ColorSequenceBlendRate == 1) then
+			self.ColorSequence = self.ColorSequenceTarget;
+		else
+			self:EqualizeColorSequenceKeypoints();
+		end;
+
+		if (self.TransparencySequenceBlendRate == 1) then
+			self.TransparencySequence = self.TransparencySequenceTarget;
+		end;
+
+		if (self.OffsetTarget) then
+			self.Offset = self.Offset + (self.OffsetTarget - self.Offset) * self.OffsetAcceleration;
+		else
+			self.OffsetSpeed = self.OffsetSpeed + (self.OffsetSpeedTarget - self.OffsetSpeed) * self.OffsetAcceleration * dt;
+			self.Offset += self.OffsetSpeed * dt;
+		end;
+
+		if (self.TransparencyOffsetTarget) then
+			self.TransparencyOffset = self.TransparencyOffset + (self.TransparencyOffsetTarget - self.TransparencyOffset) * self.TransparencyOffsetAcceleration;
+		else
+			self.TransparencyOffsetSpeed = self.TransparencyOffsetSpeed + (self.TransparencyOffsetSpeedTarget - self.TransparencyOffsetSpeed) * self.TransparencyOffsetAcceleration * dt;
+			self.TransparencyOffset += self.TransparencyOffsetSpeed * dt;
+		end;
+
+		if (self.RotationTarget) then
+			self.Rotation = self.Rotation + (self.RotationTarget - self.Rotation) * self.RotationAcceleration;
+		else
+			self.RotationSpeed = self.RotationSpeed + (self.RotationSpeedTarget - self.RotationSpeed) * self.RotationAcceleration * dt;
+			self.Rotation += self.RotationSpeed * dt;
+		end;
+
+		self.Instance.Rotation = self.Rotation;
+		self.Instance.Color = self:CalculateTrueColorSequence();
+		self.Instance.Transparency = self:CalculateTrueTransparencySequence();
+	end);
+
+	self.Instance.Parent = self.UIInstance;
+	return setmetatable(self, Gradient);
+end
+
+function Gradient:SetColorSequence(sequence: ColorSequence, blendRate: number?): ColorSequence
+	SmartAssert(typeof(sequence) == "ColorSequence", "Sequence argument is nil or not a ColorSequence");
+
+	self.ColorSequenceBlendRate = blendRate or 1;
+	self.ColorSequenceTarget = sequence;
+
+	return self.ColorSequenceTarget;
+end
+
+function Gradient:SetOffset(offset: number, acceleration: number?)
+	-- Accepts a number as the first argument and a number as the second argument.
+	-- Values below 0 or above 1 for the acceleration argument do not make sense.
+	SmartAssert(typeof(offset) == "number", "Offset isn't a number");
+	SmartAssert(typeof(acceleration) == "number", "Acceleration isn't a number");
+
+	self.OffsetTarget = offset;
+	self.OffsetSpeed = 0;
+	self.OffsetSpeedTarget = 0;
+	self.OffsetAcceleration = math.clamp(acceleration, 0, 1);
+end
+
+function Gradient:SetOffsetSpeed(offset: number, acceleration: number)
+	-- Accepts a number as the first argument and a number as the second argument.
+	-- Values below 0 or above 1 for the acceleration argument do not make sense.
+	SmartAssert(typeof(offset) == "number", "Offset isn't a number");
+	SmartAssert(typeof(acceleration) == "number", "Acceleration isn't a number");
+
+	self.OffsetSpeedTarget = offset;
+	self.OffsetTarget = nil;
+	self.OffsetAcceleration = math.clamp(acceleration, 0, 1);
+end
+
+function Gradient:SetRotation(rotation: number, acceleration: number)
+	-- Accepts a number as the first argument and a number as the second argument.
+	-- Values below 0 or above 1 for the acceleration argument do not make sense.
+	SmartAssert(typeof(rotation) == "number", "Offset isn't a number");
+	SmartAssert(typeof(acceleration) == "number", "Acceleration isn't a number");
+
+	self.RotationTarget = rotation;
+	self.RotationSpeed = 0;
+	self.RotationSpeedTarget = 0;
+	self.RotationAcceleration = math.clamp(acceleration, 0, 1);
+end
+
+function Gradient:SetRotationSpeed(rotation: number, acceleration: number)
+	-- Accepts a number as the first argument and a number as the second argument.
+	-- Values below 0 or above 1 for the acceleration argument do not make sense.
+	SmartAssert(typeof(rotation) == "number", "Offset isn't a number");
+	SmartAssert(typeof(acceleration) == "number", "Acceleration isn't a number");
+
+	self.RotationSpeedTarget = rotation;
+	self.RotationTarget = nil;
+	self.RotationAcceleration = math.clamp(acceleration, 0, 1);
+end
+
+function Gradient:SetTransparencyOffset(offset: number, acceleration: number)
+	-- Accepts a number as the first argument and a number as the second argument.
+	-- Values below 0 or above 1 for the acceleration argument do not make sense.
+	SmartAssert(typeof(offset) == "number", "Offset isn't a number");
+	SmartAssert(typeof(acceleration) == "number", "Acceleration isn't a number");
+
+	self.TransparencyOffsetTarget = offset;
+	self.TransparencyOffsetSpeed = 0;
+	self.TransparencyOffsetSpeedTarget = 0;
+	self.TransparencyOffsetAcceleration = math.clamp(acceleration, 0, 1);
+end
+
+function Gradient:SetTransparencyOffsetSpeed(offset: number, acceleration: number)
+	-- Accepts a number as the first argument and a number as the second argument.
+	-- Values below 0 or above 1 for the acceleration argument do not make sense.
+	SmartAssert(typeof(offset) == "number", "Offset isn't a number");
+	SmartAssert(typeof(acceleration) == "number", "Acceleration isn't a number");
+
+	self.TransparencyOffsetSpeedTarget = offset;
+	self.TransparencyOffsetTarget = nil;
+	self.TransparencyOffsetAcceleration = math.clamp(acceleration, 0, 1);
+end
+
+function Gradient:SetTransparencySequence(transparency: number | NumberSequence, acceleration: number)
+	-- Accepts a number or a NumberSequence as the first argument and a number as the second argument.
+	-- Values below 0 or above 1 for the acceleration argument do not make sense.
+	SmartAssert(transparency ~= nil, "Transparency is nil");
+	SmartAssert(typeof(acceleration) == "number", "Acceleration isn't a number");
+
+	if (typeof(transparency) == "number") then
+		self.TransparencyTarget = NumberSequence.new({NumberSequenceKeypoint.new(0, transparency), NumberSequenceKeypoint.new(1, transparency)});
+	elseif (typeof(transparency) == "NumberSequence") then
+		self.TransparencyTarget = transparency;
+	else
+		warn("Weird type of data?");
+	end;
+
+	self.TransparencyAcceleration = math.clamp(acceleration, 0, 1);
+end
+
+function Gradient:EqualizeColorSequenceKeypoints()
+	local keypointsA = self.ColorSequenceTarget.Keypoints;
+	local keypointsB = self.ColorSequence.Keypoints;
+	local newkeypoints = {};
+
+	if (#keypointsA ~= #keypointsB) then
+		for _, v in keypointsA do
+			local new = ColorSequenceKeypoint.new(v.Time, evalColorSequence(keypointsB, v.Time));
+			table.insert(newkeypoints, new);
+		end;
+	else
+		for _, v in keypointsA do
+			local sample = evalColorSequence(keypointsB, v.Time);
+			local blend = sample:Lerp(v.Value, self.ColorSequenceBlendRate);
+			local new = ColorSequenceKeypoint.new(v.Time, blend);
+			table.insert(newkeypoints, new);
+		end;
+	end;
+
+	self.ColorSequence = ColorSequence.new(newkeypoints);
+end
+
+function Gradient:EqualizeTransparencySequenceKeypoints()
+	local keypointsA = self.TransparencySequenceTarget.Keypoints;
+	local keypointsB = self.TransparencySequence.Keypoints;
+	local newkeypoints = {};
+
+	if (#keypointsA ~= #keypointsB) then
+		for _, v in keypointsA do
+			local new = NumberSequenceKeypoint.new(v.Time, evalNumberSequence(keypointsB, v.Time));
+			table.insert(newkeypoints, new);
+		end;
+	else
+		for _, v in keypointsA do
+			local sample = evalNumberSequence(keypointsB, v.Time);
+			local blend = sample:Lerp(v.Value, self.TransparencySequenceBlendRate);
+			local new = NumberSequenceKeypoint.new(v.Time, blend);
+			table.insert(newkeypoints, new);
+		end;
+	end;
+
+	self.TransparencySequence = NumberSequence.new(newkeypoints);
+end
+
+function Gradient:CalculateTrueColorSequence()
+	local keypoints = {};
+
+	-- Build keypoints array directly
+	for i, v in ipairs(self.ColorSequence.Keypoints) do
+		local evaledTime = (v.Time + self.Offset);
+		if (evaledTime > 1 or evaledTime < 0) then
+			evaledTime = evaledTime % 1;
+		end;
+		keypoints[i] = ColorSequenceKeypoint.new(evaledTime, v.Value);
+	end;
+
+	table.sort(keypoints, function(a, b)
+		return a.Time < b.Time;
+	end);
+
+	if keypoints[1].Time ~= 0 then
+		local newPoint = ColorSequenceKeypoint.new(0, evalColorSequence(keypoints, 0));
+		table.insert(keypoints, 1, newPoint);
+	end;
+
+	if keypoints[#keypoints].Time ~= 1 then
+		local newPoint = ColorSequenceKeypoint.new(1, evalColorSequence(keypoints, 1));
+		table.insert(keypoints, newPoint);
+	end;
+
+	self.TrueColorSequence = ColorSequence.new(keypoints);
+	return self.TrueColorSequence;
+end
+
+function Gradient:CalculateTrueTransparencySequence()
+	if (#self.TransparencySequenceTarget.Keypoints == 2) then
+		if (self.TransparencySequenceTarget.Keypoints[1].Value == self.TransparencySequenceTarget.Keypoints[2].Value) then
+			self.TrueTransparencySequence = self.TransparencySequenceTarget;
+			return self.TrueTransparencySequence;
+		end;
+	end;
+
+	local keypoints = {};
+
+	-- Build keypoints array directly
+	for i, v in ipairs(self.TransparencySequence.Keypoints) do
+		local evaledTime = (v.Time + self.TransparencyOffset);
+		if (evaledTime > 1 or evaledTime < 0) then
+			evaledTime = evaledTime % 1;
+		end;
+		keypoints[i] = NumberSequenceKeypoint.new(evaledTime, v.Value);
+	end;
+
+	table.sort(keypoints, function(a, b)
+		return a.Time < b.Time;
+	end)
+
+	if (keypoints[1].Time ~= 0) then
+		local newPoint = NumberSequenceKeypoint.new(0, evalNumberSequence(keypoints, 0));
+		table.insert(keypoints, 1, newPoint);
+	end;
+
+	if (keypoints[#keypoints].Time ~= 1) then
+		local value = evalNumberSequence(keypoints, 1);
+		local newPoint = NumberSequenceKeypoint.new(1, value);
+		table.insert(keypoints, newPoint);
+	end;
+
+	self.TrueTransparencySequence = NumberSequence.new(keypoints);
+	return self.TrueTransparencySequence;
+end
+
+function Gradient:Pause()
+	self.IsPaused = true;
+end
+
+function Gradient:Resume()
+	self.IsPaused = false;
+end
+
+function Gradient:Destroy()
+	self.Connection:Disconnect();
+	if (self.Instance) then
+		self.Instance:Destroy();
+		self.Instance = nil;
+	end;
+end
+
+return table.freeze(Gradient);

package/runtime/EzVisualz/GradientTemplates/Bubblegum.luau

@@ -0,0 +1,16 @@
+return function()
+    local Gradient = Instance.new("UIGradient");
+    Gradient.Color = ColorSequence.new({
+        ColorSequenceKeypoint.new(0, Color3.new(0.9529411792755127, 0.3960784375667572, 0.6941176652908325)),
+        ColorSequenceKeypoint.new(0.5, Color3.new(1, 0.6549019813537598, 0.8901960849761963)),
+        ColorSequenceKeypoint.new(1, Color3.new(0.9529411792755127, 0.3960784375667572, 0.6941176652908325)),
+    })
+    Gradient.Transparency = NumberSequence.new({
+        NumberSequenceKeypoint.new(0, 0),
+        NumberSequenceKeypoint.new(0.09894459694623947, 0),
+        NumberSequenceKeypoint.new(0.5, 1),
+        NumberSequenceKeypoint.new(0.8997361660003662, 0),
+        NumberSequenceKeypoint.new(1, 0),
+    })
+    return Gradient;
+end;

package/runtime/EzVisualz/GradientTemplates/Chrome.luau

@@ -0,0 +1,16 @@
+return function()
+    local Gradient = Instance.new("UIGradient");
+    Gradient.Color = ColorSequence.new({
+        ColorSequenceKeypoint.new(0, Color3.new(0, 0.062745101749897, 0.3529411852359772)),
+        ColorSequenceKeypoint.new(0.0677083358168602, Color3.new(0.686274528503418, 0.7882353067398071, 0.8352941274642944)),
+        ColorSequenceKeypoint.new(0.171875, Color3.new(0.8784313797950745, 0.9411764740943909, 1)),
+        ColorSequenceKeypoint.new(0.3177083432674408, Color3.new(1, 0.7058823704719543, 1)),
+        ColorSequenceKeypoint.new(0.4670138955116272, Color3.new(0.2666666805744171, 0, 0.49803921580314636)),
+        ColorSequenceKeypoint.new(0.4982638955116272, Color3.new(0.019607843831181526, 0.003921568859368563, 0.03529411926865578)),
+        ColorSequenceKeypoint.new(0.5034722089767456, Color3.new(1, 1, 1)),
+        ColorSequenceKeypoint.new(0.71875, Color3.new(0.7058823704719543, 1, 0.9529411792755127)),
+        ColorSequenceKeypoint.new(0.9409722089767456, Color3.new(0.15203255414962769, 0.6226686239242554, 0.6860832571983337)),
+        ColorSequenceKeypoint.new(1, Color3.new(0, 0.062745101749897, 0.3529411852359772)),
+    })
+    return Gradient;
+end

package/runtime/EzVisualz/GradientTemplates/Death.luau

@@ -0,0 +1,15 @@
+return function()
+    local Gradient = Instance.new("UIGradient");
+    Gradient.Color = ColorSequence.new({
+        ColorSequenceKeypoint.new(0, Color3.new(0.6, 0, 0)),
+        ColorSequenceKeypoint.new(0.125, Color3.new(1, 0, 0)),
+        ColorSequenceKeypoint.new(0.2552083432674408, Color3.new(0.411764, 0, 0)),
+        ColorSequenceKeypoint.new(0.3767361044883728, Color3.new(0.3, 0, 0)),
+        ColorSequenceKeypoint.new(0.5, Color3.new(0.690196, 0, 0)),
+        ColorSequenceKeypoint.new(0.6197916865348816, Color3.new(0.3, 0, 0)),
+        ColorSequenceKeypoint.new(0.7378472089767456, Color3.new(1, 0, 0)),
+        ColorSequenceKeypoint.new(0.8680555820465088, Color3.new(0.3, 0, 0)),
+        ColorSequenceKeypoint.new(1, Color3.new(0.6, 0, 0))
+    })
+    return Gradient;
+end

package/runtime/EzVisualz/GradientTemplates/Electric.luau

@@ -0,0 +1,14 @@
+return function()
+    local Gradient = Instance.new("UIGradient");
+    Gradient.Color = ColorSequence.new({
+        ColorSequenceKeypoint.new(0, Color3.fromRGB(0, 150, 255)), -- Bright Electric Blue
+        ColorSequenceKeypoint.new(0.15, Color3.fromRGB(255, 255, 255)), -- Pure White
+        ColorSequenceKeypoint.new(0.3, Color3.fromRGB(100, 200, 255)), -- Light Electric Blue
+        ColorSequenceKeypoint.new(0.45, Color3.fromRGB(255, 255, 255)), -- Pure White
+        ColorSequenceKeypoint.new(0.6, Color3.fromRGB(0, 200, 255)), -- Cyan Blue
+        ColorSequenceKeypoint.new(0.75, Color3.fromRGB(255, 255, 255)), -- Pure White
+        ColorSequenceKeypoint.new(0.9, Color3.fromRGB(50, 150, 255)), -- Medium Electric Blue
+        ColorSequenceKeypoint.new(1, Color3.fromRGB(0, 150, 255)), -- Bright Electric Blue
+    });
+    return Gradient;
+end

package/runtime/EzVisualz/GradientTemplates/Fire.luau

@@ -0,0 +1,13 @@
+return function()
+    local Gradient = Instance.new("UIGradient");
+    Gradient.Color = ColorSequence.new({
+        ColorSequenceKeypoint.new(0, Color3.new(1, 0.917647, 0)),
+        ColorSequenceKeypoint.new(0.1510416716337204, Color3.new(1, 0.917647, 0)),
+        ColorSequenceKeypoint.new(0.3072916567325592, Color3.new(1, 0.6, 0)),
+        ColorSequenceKeypoint.new(0.4965277910232544, Color3.new(0.545098, 0.368627, 0.035294)),
+        ColorSequenceKeypoint.new(0.6649305820465088, Color3.new(1, 0.666666, 0)),
+        ColorSequenceKeypoint.new(0.8385416865348816, Color3.new(0.678431, 0.490196, 0.113725)),
+        ColorSequenceKeypoint.new(1, Color3.new(1, 0.917647, 0)),
+    });
+    return Gradient;
+end

package/runtime/EzVisualz/GradientTemplates/Galaxy.luau

@@ -0,0 +1,11 @@
+return function()
+    local Gradient = Instance.new("UIGradient");
+    Gradient.Color = ColorSequence.new({
+        ColorSequenceKeypoint.new(0, Color3.fromRGB(75, 0, 130)), -- Indigo
+        ColorSequenceKeypoint.new(0.25, Color3.fromRGB(138, 43, 226)), -- Blue Violet
+        ColorSequenceKeypoint.new(0.5, Color3.fromRGB(25, 25, 112)), -- Midnight Blue
+        ColorSequenceKeypoint.new(0.75, Color3.fromRGB(72, 61, 139)), -- Dark Slate Blue
+        ColorSequenceKeypoint.new(1, Color3.fromRGB(75, 0, 130)), -- Indigo
+    });
+    return Gradient;
+end

package/runtime/EzVisualz/GradientTemplates/Ghost.luau

@@ -0,0 +1,16 @@
+return function()
+    local Gradient = Instance.new("UIGradient");
+    Gradient.Color = ColorSequence.new({
+        ColorSequenceKeypoint.new(0, Color3.new(1, 1, 1)),
+        ColorSequenceKeypoint.new(0.5, Color3.new(0.7098039388656616, 0.7215686440467834, 0.7372549176216125)),
+        ColorSequenceKeypoint.new(1, Color3.new(1, 1, 1)),
+    })
+    Gradient.Transparency = NumberSequence.new({
+        NumberSequenceKeypoint.new(0, 0),
+        NumberSequenceKeypoint.new(0.09894459694623947, 0),
+        NumberSequenceKeypoint.new(0.5, 1),
+        NumberSequenceKeypoint.new(0.8997361660003662, 0),
+        NumberSequenceKeypoint.new(1, 0),
+    })
+    return Gradient;
+end

package/runtime/EzVisualz/GradientTemplates/Gold.luau

@@ -0,0 +1,14 @@
+return function()
+    local Gradient = Instance.new("UIGradient");
+    Gradient.Color = ColorSequence.new({
+        ColorSequenceKeypoint.new(0, Color3.new(0.8352941274642944, 0.6823529601097107, 0.21960784494876862)),
+        ColorSequenceKeypoint.new(0.220486119389534, Color3.new(0.8352941274642944, 0.6823529601097107, 0.21960784494876862)),
+        ColorSequenceKeypoint.new(0.3680555522441864, Color3.new(0.7803921699523926, 0.5960784554481506, 0.0470588244497776)),
+        ColorSequenceKeypoint.new(0.4982638955116272, Color3.new(0.8509804010391235, 0.6980392336845398, 0.0117647061124444)),
+        ColorSequenceKeypoint.new(0.5034722089767456, Color3.new(1, 0.9254902005195618, 0.5058823823928833)),
+        ColorSequenceKeypoint.new(0.6927083134651184, Color3.new(0.8352941274642944, 0.6823529601097107, 0.21960784494876862)),
+        ColorSequenceKeypoint.new(0.7916666865348816, Color3.new(0.8352941274642944, 0.6823529601097107, 0.21960784494876862)),
+        ColorSequenceKeypoint.new(1, Color3.new(0.8352941274642944, 0.6823529601097107, 0.21960784494876862)),
+    })
+    return Gradient;
+end

package/runtime/EzVisualz/GradientTemplates/Green.luau

@@ -0,0 +1,14 @@
+return function()
+    local Gradient = Instance.new("UIGradient");
+    Gradient.Color = ColorSequence.new({
+        ColorSequenceKeypoint.new(0, Color3.fromRGB(0, 255, 0)),
+        ColorSequenceKeypoint.new(0.5, Color3.fromRGB(0, 255, 0)),
+        ColorSequenceKeypoint.new(1, Color3.fromRGB(0, 255, 0))
+    });
+    Gradient.Transparency = NumberSequence.new({
+        NumberSequenceKeypoint.new(0, 0),
+        NumberSequenceKeypoint.new(0.7, 1),
+        NumberSequenceKeypoint.new(1, 1)
+    })
+    return Gradient;
+end

package/runtime/EzVisualz/GradientTemplates/Ice.luau

@@ -0,0 +1,14 @@
+return function()
+    local Gradient = Instance.new("UIGradient");
+    Gradient.Color = ColorSequence.new({
+        ColorSequenceKeypoint.new(0, Color3.fromRGB(109, 210, 212)),
+        ColorSequenceKeypoint.new(0.171875, Color3.new(0.8784313797950745, 0.9411764740943909, 1)),
+        ColorSequenceKeypoint.new(0.3177083432674408, Color3.fromRGB(140, 208, 209)),
+        ColorSequenceKeypoint.new(0.4670138955116272, Color3.fromRGB(109, 210, 212)),
+        ColorSequenceKeypoint.new(0.4982638955116272, Color3.fromRGB(109, 210, 212)),
+        ColorSequenceKeypoint.new(0.5034722089767456, Color3.new(1, 1, 1)),
+        ColorSequenceKeypoint.new(0.71875, Color3.new(0.7058823704719543, 1, 0.9529411792755127)),
+        ColorSequenceKeypoint.new(1, Color3.fromRGB(109, 210, 212)),
+    })
+    return Gradient;
+end

package/runtime/EzVisualz/GradientTemplates/Lava.luau

@@ -0,0 +1,15 @@
+return function()
+    local Gradient = Instance.new("UIGradient");
+    Gradient.Color = ColorSequence.new({
+        ColorSequenceKeypoint.new(0, Color3.new(1, 0, 0)),
+        ColorSequenceKeypoint.new(0.125, Color3.new(1, 0.7843137383460999, 0)),
+        ColorSequenceKeypoint.new(0.2552083432674408, Color3.new(1, 0, 0)),
+        ColorSequenceKeypoint.new(0.3767361044883728, Color3.new(1, 0.7843137383460999, 0)),
+        ColorSequenceKeypoint.new(0.5, Color3.new(1, 0, 0)),
+        ColorSequenceKeypoint.new(0.6197916865348816, Color3.new(1, 0.7843137383460999, 0)),
+        ColorSequenceKeypoint.new(0.7378472089767456, Color3.new(1, 0, 0)),
+        ColorSequenceKeypoint.new(0.8680555820465088, Color3.new(1, 0.7843137383460999, 0)),
+        ColorSequenceKeypoint.new(1, Color3.new(1, 0, 0)),
+    });
+    return Gradient;
+end

package/runtime/EzVisualz/GradientTemplates/Matrix.luau

@@ -0,0 +1,19 @@
+return function()
+    local Gradient = Instance.new("UIGradient");
+    Gradient.Color = ColorSequence.new({
+        -- matrix colors
+        ColorSequenceKeypoint.new(0, Color3.new(0.243137, 0.937254, 0.007843)),
+        ColorSequenceKeypoint.new(0.015625, Color3.new(0.243137, 0.937254, 0.007843)),
+        ColorSequenceKeypoint.new(0.1458333283662796, Color3.new(0.243137, 0.937254, 0.007843)),
+        ColorSequenceKeypoint.new(0.2482638955116272, Color3.new(0.243137, 0.937254, 0.007843)),
+        ColorSequenceKeypoint.new(0.3559027910232544, Color3.new(0.243137, 0.937254, 0.007843)),
+        ColorSequenceKeypoint.new(0.4970000088214874, Color3.new(0.243137, 0.937254, 0.007843)),
+        ColorSequenceKeypoint.new(0.503000020980835, Color3.new(0, 0, 0)),
+        ColorSequenceKeypoint.new(0.647569477558136, Color3.new(0, 0, 0)),
+        ColorSequenceKeypoint.new(0.7829861044883728, Color3.new(0, 0, 0)),
+        ColorSequenceKeypoint.new(0.890625, Color3.new(0, 0, 0)),
+        ColorSequenceKeypoint.new(0.9774305820465088, Color3.new(0, 0, 0)),
+        ColorSequenceKeypoint.new(1, Color3.new(0, 0, 0)),
+    })
+    return Gradient;
+end

package/runtime/EzVisualz/GradientTemplates/Neon.luau

@@ -0,0 +1,12 @@
+return function()
+    local Gradient = Instance.new("UIGradient");
+    Gradient.Color = ColorSequence.new({
+        ColorSequenceKeypoint.new(0, Color3.fromRGB(255, 0, 255)), -- Magenta
+        ColorSequenceKeypoint.new(0.2, Color3.fromRGB(0, 255, 255)), -- Cyan
+        ColorSequenceKeypoint.new(0.4, Color3.fromRGB(255, 0, 255)), -- Magenta
+        ColorSequenceKeypoint.new(0.6, Color3.fromRGB(255, 0, 150)), -- Pink
+        ColorSequenceKeypoint.new(0.8, Color3.fromRGB(0, 255, 255)), -- Cyan
+        ColorSequenceKeypoint.new(1, Color3.fromRGB(255, 0, 255)), -- Magenta
+    });
+    return Gradient;
+end

package/runtime/EzVisualz/GradientTemplates/Oceanic.luau

@@ -0,0 +1,15 @@
+return function()
+    local Gradient = Instance.new("UIGradient");
+    Gradient.Color = ColorSequence.new({
+        ColorSequenceKeypoint.new(0, Color3.new(0, 0.45098039507865906, 1)),
+        ColorSequenceKeypoint.new(0.125, Color3.new(1, 0, 0)),
+        ColorSequenceKeypoint.new(0.2552083432674408, Color3.new(0, 0.45098039507865906, 1)),
+        ColorSequenceKeypoint.new(0.3767361044883728, Color3.new(1, 0, 0)),
+        ColorSequenceKeypoint.new(0.5, Color3.new(0, 0.45098039507865906, 1)),
+        ColorSequenceKeypoint.new(0.6197916865348816, Color3.new(1, 0, 0)),
+        ColorSequenceKeypoint.new(0.7374784350395203, Color3.new(0, 0.45098039507865906, 1)),
+        ColorSequenceKeypoint.new(0.8680555820465088, Color3.new(1, 0, 0)),
+        ColorSequenceKeypoint.new(1, Color3.new(0, 0.45098039507865906, 1)),
+    })
+    return Gradient;
+end