cluaupp 0.1.0

package/runtime/EzVisualz/Presets/SilverStroke.luau

@@ -0,0 +1,15 @@
+local TextEffects = require(script.Parent.Parent);
+
+return function(uiInstance: GuiObject, speed: number, size: number, customColor: ColorSequence | Color3?, customTransparency: NumberSequence | number?, useScaledSize: boolean?)
+    local mainGradient = TextEffects.Gradient.new(uiInstance, TextEffects.Templates.Silver.Color, 0);
+    mainGradient:SetRotation(-80, 1);
+    mainGradient:SetOffsetSpeed(speed, 1);
+
+    local mainStroke = TextEffects.Stroke.new(uiInstance, size, nil, nil, useScaledSize);
+    local strokeGradient = TextEffects.Gradient.new(mainStroke.Instance, TextEffects.Templates.Silver.Color, 0);
+    strokeGradient:SetRotation(-79, 1);
+    strokeGradient:SetOffsetSpeed(speed * 0.56, 1);
+    return {
+        Effects = { mainGradient, strokeGradient, mainStroke }
+    };
+end

package/runtime/EzVisualz/Presets/SunsetStroke.luau

@@ -0,0 +1,31 @@
+local RunService = game:GetService("RunService");
+
+local TextEffects = require(script.Parent.Parent);
+
+return function(uiInstance: GuiObject, speed: number, size: number, customColor: ColorSequence | Color3?, customTransparency: NumberSequence | number?, useScaledSize: boolean?)
+    local mainGradient = TextEffects.Gradient.new(uiInstance, TextEffects.Templates.Sunset.Color, 0);
+    mainGradient:SetRotation(-60, 1);
+    mainGradient:SetOffsetSpeed(speed * 0.8, 1);
+
+    local mainStroke = TextEffects.Stroke.new(uiInstance, size, nil, nil, useScaledSize);
+    local strokeGradient = TextEffects.Gradient.new(mainStroke.Instance, TextEffects.Templates.Sunset.Color, 0);
+    strokeGradient:SetRotation(60, 1);
+    strokeGradient:SetOffsetSpeed(-speed * 0.6, 1);
+
+    local Rotation = 0;
+    local Connection;
+    Connection = RunService.Heartbeat:Connect(function(dt)
+        if (not mainGradient.Instance or mainGradient.Instance.Parent == nil) then
+            Connection:Disconnect();
+            return;
+        end;
+        Rotation = Rotation + speed * dt * 20;
+        mainGradient:SetRotation(-60 + math.sin(Rotation * 0.1) * 20, 0.2);
+        strokeGradient:SetRotation(60 - math.sin(Rotation * 0.1) * 20, 0.2);
+    end);
+
+    return {
+        Effects = { mainGradient, strokeGradient, mainStroke },
+        Connections = { Connection }
+    };
+end

package/runtime/EzVisualz/Presets/WaveStroke.luau

@@ -0,0 +1,33 @@
+local TextEffects = require(script.Parent.Parent);
+
+return function(uiInstance: GuiObject, speed: number, size: number, customColor: ColorSequence | Color3?, customTransparency: NumberSequence | number?, useScaledSize: boolean?)
+    local actualColor: Color3 = Color3.new(1, 1, 1);
+    if customColor then
+        if typeof(customColor) == "ColorSequence" then
+            actualColor = customColor.Keypoints[1].Value;
+        else
+            actualColor = customColor;
+        end;
+    end;
+    local colorSequence = ColorSequence.new({
+        ColorSequenceKeypoint.new(0, actualColor),
+        ColorSequenceKeypoint.new(0.5, actualColor),
+        ColorSequenceKeypoint.new(1, actualColor)
+    });
+
+    local transparencySequence = NumberSequence.new({
+        NumberSequenceKeypoint.new(0, 0),
+        NumberSequenceKeypoint.new(0.25, 1),
+        NumberSequenceKeypoint.new(0.5, 1),
+        NumberSequenceKeypoint.new(0.75, 1),
+        NumberSequenceKeypoint.new(1, 0)
+    });
+
+    local mainStroke = TextEffects.Stroke.new(uiInstance, size, nil, nil, useScaledSize);
+    local strokeGradient = TextEffects.Gradient.new(mainStroke.Instance, colorSequence, transparencySequence);
+    strokeGradient:SetOffsetSpeed(speed, 1);
+    strokeGradient:SetTransparencyOffsetSpeed(speed * 0.9, 1);
+    return {
+        Effects = { strokeGradient, mainStroke }
+    };
+end

package/runtime/EzVisualz/Presets/Zebra.luau

@@ -0,0 +1,21 @@
+local TextEffects = require(script.Parent.Parent);
+
+return function(uiInstance: GuiObject, speed: number, size: number, customColor: ColorSequence | Color3?, customTransparency: NumberSequence | number?, useScaledSize: boolean?)
+    local mainGradient = TextEffects.Gradient.new(uiInstance, TextEffects.Templates.Zebra.Color, 0);
+    mainGradient:SetOffsetSpeed(speed, 1);
+    mainGradient:SetRotation(90, 1);
+
+    local mainStroke = TextEffects.Stroke.new(uiInstance, size, nil, nil, useScaledSize);
+
+    local strokeGradient = TextEffects.Gradient.new(mainStroke.Instance, TextEffects.Templates.Zebra.Color, 0);
+    strokeGradient:SetOffset(0.5, 1);
+    strokeGradient:SetRotation(90, 1);
+
+    task.delay(0.1, function()
+        strokeGradient:SetOffsetSpeed(speed, 1);
+    end);
+
+    return {
+        Effects = { mainGradient, strokeGradient, mainStroke }
+    };
+end

package/runtime/EzVisualz/Presets/init.luau

@@ -0,0 +1,9 @@
+local Modules = script:GetDescendants();
+local SubModules = {};
+
+for _, module in Modules do
+    if (not module:IsA("ModuleScript")) then continue end;
+    SubModules[module.Name] = require(module);
+end
+
+return SubModules;

package/runtime/EzVisualz/Stroke.luau

@@ -0,0 +1,167 @@
+local RunService = game:GetService("RunService");
+local SmartAssert = require(script.Parent.Util);
+
+-- Fingeroo was here ( ͡° ͜ʖ ͡°)
+
+export type Stroke<T...> = {
+	UIInstance: GuiObject,
+	Instance: UIStroke,
+	IsPaused: boolean,
+	UseScaledSize: boolean,
+	Color: Color3,
+	ColorTarget: Color3,
+	ColorAcceleration: number,
+	Transparency: number,
+	TransparencyTarget: number,
+	TransparencyAcceleration: number,
+	Size: number,
+	SizeTarget: number,
+	SizeAcceleration: number,
+	Connection: RBXScriptConnection,
+	IsText: boolean,
+
+	Pause: (self: Stroke<T...>) -> nil,
+	Resume: (self: Stroke<T...>) -> nil,
+	SetSize: (self: Stroke<T...>, size: number, acceleration: number) -> nil,
+	SetTransparency: (self: Stroke<T...>, transparency: number, acceleration: number) -> nil,
+	SetColor: (self: Stroke<T...>, color: Color3, acceleration: number) -> nil,
+	SetScaledSize: (self: Stroke<T...>, useScaledSize: boolean) -> nil,
+	Destroy: (self: Stroke<T...>) -> nil,
+};
+
+local Stroke = {};
+Stroke.__index = Stroke;
+
+function Stroke.new<T...>(uiInstance: GuiObject | UIStroke, size: number, color: Color3?, transparency: number?, useScaledSize: boolean?): Stroke<T...>
+	SmartAssert(uiInstance ~= nil, "UIInstance not provided");
+	SmartAssert(uiInstance:IsA("GuiObject") or uiInstance:IsA("UIStroke"), "UIInstance is not a GuiObject or UIStroke");
+	SmartAssert(size ~= nil, "Size not provided");
+	SmartAssert(typeof(size) == "number", "Size is not a number");
+	if (color) then
+		SmartAssert(typeof(color) == "Color3", "Color is not a Color3");
+	end;
+	if (transparency) then
+		SmartAssert(typeof(transparency) == "number", "Transparency is not a number");
+	end;
+	if (useScaledSize ~= nil) then
+		SmartAssert(typeof(useScaledSize) == "boolean", "useScaledSize is not a boolean");
+	end;
+
+	local self = {};
+
+	self.UIInstance = uiInstance;
+	self.Instance = uiInstance:FindFirstChildWhichIsA("UIStroke") or Instance.new("UIStroke");
+	self.UseScaledSize = useScaledSize == true;
+	if (useScaledSize == true) then
+		self.Instance.StrokeSizingMode = Enum.StrokeSizingMode.ScaledSize;
+	end;
+	self.IsPaused = false;
+
+	self.Color = color or Color3.new(1, 1, 1);
+	self.ColorTarget = color or Color3.new(1, 1, 1);
+	self.ColorAcceleration = 1;
+
+	self.Transparency = transparency or 0;
+	self.TransparencyTarget = transparency or 0;
+	self.TransparencyAcceleration = 1;
+
+	if self.UseScaledSize and math.abs(size) > 1 then
+		size = size / 100;
+	end
+
+	self.Size = size;
+	self.SizeTarget = size;
+	self.SizeAcceleration = 1;
+	self.Connection = nil;
+	self.IsText = false;
+
+	if (uiInstance:IsA("TextLabel") or uiInstance:IsA("TextBox") or uiInstance:IsA("TextButton")) then
+		self.IsText = true;
+	end;
+
+	self.Instance.Parent = self.UIInstance;
+
+	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;
+
+		self.Color = self.Color:Lerp(self.ColorTarget, self.ColorAcceleration * dt * 10);
+		self.Size = self.Size + ((self.SizeTarget - self.Size) * self.SizeAcceleration * dt * 10);
+		self.Transparency = self.Transparency + ((self.TransparencyTarget - self.Transparency) * self.TransparencyAcceleration * dt * 10);
+
+		self.Instance.Transparency = self.Transparency;
+		self.Instance.Color = self.Color;
+		self.Instance.Thickness = self.Size;
+	end);
+
+	return setmetatable(self, Stroke);
+end
+
+function Stroke:SetSize(size: 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(size) == "number", "Size isn't a number");
+	SmartAssert(typeof(acceleration) == "number", "Acceleration isn't a number");
+
+	-- What I thought of doing here is when someone uses ScaledSize and they pass a number greater than 1, we divide it by 100 to get the percentage.
+	if self.UseScaledSize and math.abs(size) > 1 then
+		size = size / 100;
+	end
+
+	self.SizeTarget = size;
+	self.SizeAcceleration = math.clamp(acceleration, 0, 1);
+end
+
+function Stroke:SetTransparency(transparency: 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(transparency) == "number", "Transparency isn't a number");
+	SmartAssert(typeof(acceleration) == "number", "Acceleration isn't a number");
+
+	self.TransparencyTarget = transparency;
+	self.TransparencyAcceleration = math.clamp(acceleration, 0, 1);
+end
+
+function Stroke:SetColor(color: Color3, acceleration: number)
+	-- Accepts a Color3 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(color) == "Color3", "Color isn't a Color3");
+	SmartAssert(typeof(acceleration) == "number", "Acceleration isn't a number");
+
+	self.ColorTarget = color;
+	self.ColorAcceleration = math.clamp(acceleration, 0, 1);
+end
+
+function Stroke:SetScaledSize(useScaledSize: boolean)
+	SmartAssert(typeof(useScaledSize) == "boolean", "useScaledSize isn't a boolean");
+
+	if (useScaledSize) then
+		self.Instance.StrokeSizingMode = Enum.StrokeSizingMode.ScaledSize;
+	else
+		self.Instance.StrokeSizingMode = Enum.StrokeSizingMode.FixedSize;
+	end;
+end
+
+function Stroke:Pause()
+	self.IsPaused = true;
+end
+
+function Stroke:Resume()
+	self.IsPaused = false;
+end
+
+function Stroke:Destroy()
+	self.Connection:Disconnect();
+	if (self.Instance) then
+		self.Instance:Destroy();
+		self.Instance = nil;
+	end;
+end
+
+return table.freeze(Stroke);

package/runtime/EzVisualz/Util.luau

@@ -0,0 +1,7 @@
+local function SmartAssert(condition: boolean, message: string)
+	if (not condition) then
+		error(message, 2);
+	end;
+end
+
+return SmartAssert :: (boolean, string) -> ();

package/runtime/EzVisualz/_impl/Dropshadow.luau

@@ -0,0 +1,148 @@
+local RunService = game:GetService("RunService");
+local SmartAssert = require(script.Parent.Util);
+
+export type Dropshadow<T...> = {
+	UIInstance: GuiObject,
+	Instance: GuiObject,
+	IsPaused: boolean,
+	Color: Color3,
+	ColorTarget: Color3,
+	ColorAcceleration: number,
+	Transparency: number,
+	TransparencyTarget: number,
+	TransparencyAcceleration: number,
+	Offset: Vector2,
+	OffsetTarget: Vector2,
+	OffsetAcceleration: number,
+	Connection: RBXScriptConnection,
+	IsText: boolean,
+
+	Pause: (self: Dropshadow<T...>) -> nil,
+	Resume: (self: Dropshadow<T...>) -> nil,
+	SetOffset: (self: Dropshadow<T...>, offset: Vector2, acceleration: number) -> nil,
+	SetTransparency: (self: Dropshadow<T...>, transparency: number, acceleration: number) -> nil,
+	SetColor: (self: Dropshadow<T...>, color: Color3, acceleration: number) -> nil,
+	Destroy: (self: Dropshadow<T...>) -> nil,
+};
+
+local Dropshadow = {};
+Dropshadow.__index = Dropshadow;
+
+function Dropshadow.new<T...>(uiInstance: GuiObject | UIStroke, color: Color3?, transparency: number?, offset: Vector2?): Dropshadow<T...>
+	SmartAssert(uiInstance ~= nil, "UIInstance not provided");
+	SmartAssert(uiInstance:IsA("GuiObject") or uiInstance:IsA("UIStroke"), "UIInstance is not a GuiObject or UIStroke");
+	if (color) then
+		SmartAssert(typeof(color) == "Color3", "Color is not a Color3");
+	end;
+	if (transparency) then
+		SmartAssert(typeof(transparency) == "number", "Transparency is not a number");
+	end;
+	if (offset) then
+		SmartAssert(typeof(offset) == "Vector2", "Offset is not a Vector2");
+	end;
+
+	local self = {};
+
+	self.UIInstance = uiInstance;
+	self.Instance = uiInstance:Clone();
+	self.IsPaused = false;
+
+	self.Color = color or Color3.new();
+	self.ColorTarget = color or Color3.new();
+	self.ColorAcceleration = 1;
+	self.Transparency = transparency or 0;
+	self.TransparencyTarget = transparency or 0;
+	self.TransparencyAcceleration = 1;
+	self.Offset = offset or Vector2.new(-4, 4);
+	self.OffsetTarget = offset or Vector2.new();
+	self.OffsetAcceleration = 1;
+	self.Connection = nil;
+	self.IsText = false;
+
+	self.Instance.Size = UDim2.new(1, 0, 1, 0);
+	self.Instance:ClearAllChildren();
+
+	self.Instance.Position = UDim2.new(0, self.Offset.X, 0, self.Offset.Y);
+
+	if (uiInstance:IsA("TextLabel") or uiInstance:IsA("TextBox") or uiInstance:IsA("TextButton")) then
+		self.Instance.TextColor3 = self.Color;
+		self.IsText = true;
+	end;
+
+	self.Instance.Parent = self.UIInstance;
+
+	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;
+
+		self.Color = self.Color:Lerp(self.ColorTarget, math.min(1, self.ColorAcceleration * dt));
+		self.Offset = self.Offset:Lerp(self.OffsetTarget, math.min(1, self.OffsetAcceleration * dt));
+		self.Transparency = self.Transparency + ((self.TransparencyTarget - self.Transparency) * self.TransparencyAcceleration * dt);
+
+		self.Instance.Position = UDim2.new(0, self.Offset.X, 0, self.Offset.Y);
+
+		if (self.IsText) then
+			self.Instance.Text = self.UIInstance.Text;
+			self.Instance.TextTransparency = self.Transparency;
+			self.Instance.TextColor3 = self.Color;
+		end;
+
+		self.Instance.ZIndex = self.UIInstance.ZIndex - 1;
+	end);
+
+	return setmetatable(self, Dropshadow);
+end
+
+function Dropshadow:SetOffset(offset: Vector2, acceleration: number)
+	-- Accepts a Vector2 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) == "Vector2", "Offset isn't a Vector2");
+	SmartAssert(typeof(acceleration) == "number", "Acceleration isn't a number");
+
+	self.OffsetTarget = offset;
+	self.OffsetAcceleration = math.clamp(acceleration, 0, 1);
+end
+
+function Dropshadow:SetTransparency(transparency: 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(transparency) == "number", "Transparency isn't a number");
+	SmartAssert(typeof(acceleration) == "number", "Acceleration isn't a number");
+
+	self.TransparencyTarget = transparency;
+	self.TransparencyAcceleration = math.clamp(acceleration, 0, 1);
+end
+
+function Dropshadow:SetColor(color: Color3, acceleration: number)
+	-- Accepts a Color3 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(color) == "Color3", "Color isn't a Color3");
+	SmartAssert(typeof(acceleration) == "number", "Acceleration isn't a number");
+
+	self.ColorTarget = color;
+	self.ColorAcceleration = math.clamp(acceleration, 0, 1);
+end
+
+function Dropshadow:Pause()
+	self.IsPaused = true;
+end
+
+function Dropshadow:Resume()
+	self.IsPaused = false;
+end
+
+function Dropshadow:Destroy()
+	self.Connection:Disconnect();
+	if (self.Instance) then
+		self.Instance:Destroy();
+		self.Instance = nil;
+	end;
+end
+
+return table.freeze(Dropshadow);