@quenty/color3utils 2.0.2-canary.256.edbbcfc.0 → 3.0.0

package/CHANGELOG.md

@@ -3,7 +3,18 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
-## [2.0.2-canary.256.edbbcfc.0](https://github.com/Quenty/NevermoreEngine/compare/@quenty/color3utils@2.0.1...@quenty/color3utils@2.0.2-canary.256.edbbcfc.0) (2022-03-27)
+# [3.0.0](https://github.com/Quenty/NevermoreEngine/compare/@quenty/color3utils@2.1.0...@quenty/color3utils@3.0.0) (2022-05-21)
+
+
+### Features
+
+* Add LuvUtils to Color3Utils ([b705bdd](https://github.com/Quenty/NevermoreEngine/commit/b705bdd8cd1613329a73362899a4b8cd47f45336))
+
+
+
+
+
+# [2.1.0](https://github.com/Quenty/NevermoreEngine/compare/@quenty/color3utils@2.0.1...@quenty/color3utils@2.1.0) (2022-03-27)
 
 **Note:** Version bump only for package @quenty/color3utils
 

package/LICENSE.md

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2014-2021 Quenty
+Copyright (c) 2014-2022 Quenty
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@quenty/color3utils",
-  "version": "2.0.2-canary.256.edbbcfc.0",
+  "version": "3.0.0",
   "description": "Utility methods for Roblox Color3 values",
   "keywords": [
     "Roblox",
@@ -27,5 +27,12 @@
   "publishConfig": {
     "access": "public"
   },
-  "gitHead": "edbbcfc38516772a791d50dc43cd6b304ffc4aff"
+  "dependencies": {
+    "@quenty/blend": "^4.0.0",
+    "@quenty/loader": "^5.0.0",
+    "@quenty/math": "^2.2.0",
+    "@quenty/rx": "^5.0.0",
+    "@quenty/valueobject": "^5.0.0"
+  },
+  "gitHead": "9f7eaea7543c33c89d2e32c38491b13f9271f4f7"
 }

package/src/Shared/luv/LuvColor3Utils.lua

@@ -0,0 +1,68 @@
+--[=[
+	Handles color manipulation in the HpLuv space.
+
+	https://www.hsluv.org/comparison/
+
+	@class LuvColor3Utils
+]=]
+
+local require = require(script.Parent.loader).load(script)
+
+local LuvUtils = require("LuvUtils")
+local Math = require("Math")
+
+local LuvColor3Utils = {}
+
+--[=[
+	Interpolates in LUV space.
+	@param color0 Color3
+	@param color1 Color3
+	@param t number
+	@return Color3
+]=]
+function LuvColor3Utils.lerp(color0, color1, t)
+	assert(typeof(color0) == "Color3", "Bad color0")
+	assert(typeof(color1) == "Color3", "Bad color0")
+	assert(type(t) == "number", "Bad t")
+
+	if t == 0 then
+		return color0
+	elseif t == 1 then
+		return color1
+	else
+		local l0, u0, v0 = unpack(LuvColor3Utils.fromColor3(color0))
+		local l1, u1, v1 = unpack(LuvColor3Utils.fromColor3(color1))
+
+		local l = Math.lerp(l0, l1, t)
+		local u = Math.lerp(u0, u1, t)
+		local v = Math.lerp(v0, v1, t)
+
+		return LuvColor3Utils.toColor3({l, u, v})
+	end
+end
+
+--[=[
+	Converts from Color3 to LUV
+	@param color3 Color3
+	@return { number, number, number }
+]=]
+function LuvColor3Utils.fromColor3(color3)
+	assert(typeof(color3) == "Color3", "Bad color3")
+
+	return LuvUtils.rgb_to_hsluv({ color3.r, color3.g, color3.b })
+end
+
+--[=[
+	Converts from LUV to Color3
+	@param luv { number, number, number }
+	@return Color3
+]=]
+function LuvColor3Utils.toColor3(luv)
+	assert(type(luv) == "table", "Bad luv")
+
+	local r, g, b = unpack(LuvUtils.hsluv_to_rgb(luv))
+	-- deal with floating point numbers
+	return Color3.new(math.clamp(r, 0, 1), math.clamp(g, 0, 1), math.clamp(b, 0, 1))
+end
+
+return LuvColor3Utils

package/src/Shared/luv/LuvUtils.lua

@@ -0,0 +1,348 @@
+--[[
+Lua implementation of LuvUtils and HPLuv color spaces
+Homepage: http://www.LuvUtils.org/
+
+Copyright (C) 2019 Alexei Boronine
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and
+associated documentation files (the "Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the
+following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial
+portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT
+LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+]]
+
+-- https://github.com/hsluv/hsluv-lua
+
+local LuvUtils = {}
+
+local hexChars = "0123456789abcdef"
+
+local function distance_line_from_origin(line)
+	return math.abs(line.intercept) / math.sqrt((line.slope*line.slope) + 1)
+end
+
+local function length_of_ray_until_intersect(theta, line)
+	return line.intercept / (math.sin(theta) - line.slope * math.cos(theta))
+end
+
+function LuvUtils.get_bounds(l)
+	local result = {}
+	local sub2
+	local sub1 = ((l + 16) ^ 3) / 1560896
+	if sub1 > LuvUtils.epsilon then
+		sub2 = sub1
+	else
+		sub2 = l / LuvUtils.kappa
+	end
+
+	for i = 1, 3 do
+		local m1 = LuvUtils.m[i][1]
+		local m2 = LuvUtils.m[i][2]
+		local m3 = LuvUtils.m[i][3]
+
+		for t = 0, 1 do
+			local top1 = (284517 * m1 - 94839 * m3) * sub2
+			local top2 = (838422 * m3 + 769860 * m2 + 731718 * m1) * l * sub2 - 769860 * t * l
+			local bottom = (632260 * m3 - 126452 * m2) * sub2 + 126452 * t
+			table.insert(result, {
+				slope = top1 / bottom,
+				intercept = top2 / bottom
+			})
+		end
+	end
+	return result
+end
+
+function LuvUtils.max_safe_chroma_for_l(l)
+	local bounds = LuvUtils.get_bounds(l)
+	local min = 1.7976931348623157e+308
+
+	for i = 1, 6 do
+		local length = distance_line_from_origin(bounds[i])
+		if length >= 0 then
+			min = math.min(min, length)
+		end
+	end
+	return min
+end
+
+function LuvUtils.max_safe_chroma_for_lh(l, h)
+	local hrad = h / 360 * math.pi * 2
+	local bounds = LuvUtils.get_bounds(l)
+	local min = 1.7976931348623157e+308
+
+	for i = 1, 6 do
+		local bound = bounds[i]
+		local length = length_of_ray_until_intersect(hrad, bound)
+		if length >= 0 then
+			min = math.min(min, length)
+		end
+	end
+	return min
+end
+
+function LuvUtils.dot_product(a, b)
+	local sum = 0
+	for i = 1, 3 do
+		sum = sum + a[i] * b[i]
+	end
+	return sum
+end
+
+function LuvUtils.from_linear(c)
+	if c <= 0.0031308 then
+		return 12.92 * c
+	else
+		return 1.055 * (c ^ 0.416666666666666685) - 0.055
+	end
+end
+
+function LuvUtils.to_linear(c)
+	if c > 0.04045 then
+		return ((c + 0.055) / 1.055) ^ 2.4
+	else
+		return c / 12.92
+	end
+end
+
+function LuvUtils.xyz_to_rgb(tuple)
+	return {
+		LuvUtils.from_linear(LuvUtils.dot_product(LuvUtils.m[1], tuple)),
+		LuvUtils.from_linear(LuvUtils.dot_product(LuvUtils.m[2], tuple)),
+		LuvUtils.from_linear(LuvUtils.dot_product(LuvUtils.m[3], tuple))
+	}
+end
+
+function LuvUtils.rgb_to_xyz(tuple)
+	local rgbl = {
+		LuvUtils.to_linear(tuple[1]),
+		LuvUtils.to_linear(tuple[2]),
+		LuvUtils.to_linear(tuple[3])
+	}
+	return {
+		LuvUtils.dot_product(LuvUtils.minv[1], rgbl),
+		LuvUtils.dot_product(LuvUtils.minv[2], rgbl),
+		LuvUtils.dot_product(LuvUtils.minv[3], rgbl)
+	}
+end
+
+function LuvUtils.y_to_l(Y)
+	if Y <= LuvUtils.epsilon then
+		return Y / LuvUtils.refY * LuvUtils.kappa
+	else
+		return 116 * ((Y / LuvUtils.refY) ^ 0.333333333333333315) - 16
+	end
+end
+
+function LuvUtils.l_to_y(L)
+	if L <= 8 then
+		return LuvUtils.refY * L / LuvUtils.kappa
+	else
+		return LuvUtils.refY * (((L + 16) / 116) ^ 3)
+	end
+end
+
+function LuvUtils.xyz_to_luv(tuple)
+	local X = tuple[1]
+	local Y = tuple[2]
+	local divider = X + 15 * Y + 3 * tuple[3]
+	local varU = 4 * X
+	local varV = 9 * Y
+	if divider ~= 0 then
+		varU = varU / divider
+		varV = varV / divider
+	else
+		varU = 0
+		varV = 0
+	end
+	local L = LuvUtils.y_to_l(Y)
+	if L == 0 then
+		return { 0, 0, 0 }
+	end
+	return { L, 13 * L * (varU - LuvUtils.refU), 13 * L * (varV - LuvUtils.refV) }
+end
+
+function LuvUtils.luv_to_xyz(tuple)
+	local L = tuple[1]
+	local U = tuple[2]
+	local V = tuple[3]
+	if L == 0 then
+		return { 0, 0, 0 }
+	end
+	local varU = U / (13 * L) + LuvUtils.refU
+	local varV = V / (13 * L) + LuvUtils.refV
+	local Y = LuvUtils.l_to_y(L)
+	local X = 0 - (9 * Y * varU) / ((((varU - 4) * varV) - varU * varV))
+	return { X, Y, (9 * Y - 15 * varV * Y - varV * X) / (3 * varV) }
+end
+
+function LuvUtils.luv_to_lch(tuple)
+	local L = tuple[1]
+	local U = tuple[2]
+	local V = tuple[3]
+	local C = math.sqrt(U * U + V * V)
+	local H
+	if C < 0.00000001 then
+		H = 0
+	else
+		H = math.atan2(V, U) * 180.0 / 3.1415926535897932
+		if H < 0 then
+			H = 360 + H
+		end
+	end
+	return { L, C, H }
+end
+
+function LuvUtils.lch_to_luv(tuple)
+	local L = tuple[1]
+	local C = tuple[2]
+	local Hrad = tuple[3] / 360.0 * 2 * math.pi
+	return { L, math.cos(Hrad) * C, math.sin(Hrad) * C }
+end
+
+function LuvUtils.hsluv_to_lch(tuple)
+	local H = tuple[1]
+	local S = tuple[2]
+	local L = tuple[3]
+	if L > 99.9999999 then
+		return { 100, 0, H }
+	end
+	if L < 0.00000001 then
+		return { 0, 0, H }
+	end
+	return { L, LuvUtils.max_safe_chroma_for_lh(L, H) / 100 * S, H }
+end
+
+function LuvUtils.lch_to_hsluv(tuple)
+	local L = tuple[1]
+	local C = tuple[2]
+	local H = tuple[3]
+	local max_chroma = LuvUtils.max_safe_chroma_for_lh(L, H)
+	if L > 99.9999999 then
+		return { H, 0, 100 }
+	end
+	if L < 0.00000001 then
+		return { H, 0, 0 }
+	end
+
+	return { H, C / max_chroma * 100, L }
+end
+
+function LuvUtils.hpluv_to_lch(tuple)
+	local H = tuple[1]
+	local S = tuple[2]
+	local L = tuple[3]
+	if L > 99.9999999 then
+		return { 100, 0, H }
+	end
+	if L < 0.00000001 then
+		return { 0, 0, H }
+	end
+	return { L, LuvUtils.max_safe_chroma_for_l(L) / 100 * S, H }
+end
+
+function LuvUtils.lch_to_hpluv(tuple)
+	local L = tuple[1]
+	local C = tuple[2]
+	local H = tuple[3]
+	if L > 99.9999999 then
+		return { H, 0, 100 }
+	end
+	if L < 0.00000001 then
+		return { H, 0, 0 }
+	end
+	return { H, C / LuvUtils.max_safe_chroma_for_l(L) * 100, L }
+end
+
+function LuvUtils.rgb_to_hex(tuple)
+	local h = "#"
+	for i = 1, 3 do
+		local c = math.floor(tuple[i] * 255 + 0.5)
+		local digit2 = math.fmod(c, 16)
+		local x = (c - digit2) / 16
+		local digit1 = math.floor(x)
+		h = h .. string.sub(hexChars, digit1 + 1, digit1 + 1)
+		h = h .. string.sub(hexChars, digit2 + 1, digit2 + 1)
+	end
+	return h
+end
+
+function LuvUtils.hex_to_rgb(hex)
+	hex = string.lower(hex)
+	local ret = {}
+	for i = 0, 2 do
+		local char1 = string.sub(hex, i * 2 + 2, i * 2 + 2)
+		local char2 = string.sub(hex, i * 2 + 3, i * 2 + 3)
+		local digit1 = string.find(hexChars, char1) - 1
+		local digit2 = string.find(hexChars, char2) - 1
+		ret[i + 1] = (digit1 * 16 + digit2) / 255.0
+	end
+	return ret
+end
+
+function LuvUtils.lch_to_rgb(tuple)
+	return LuvUtils.xyz_to_rgb(LuvUtils.luv_to_xyz(LuvUtils.lch_to_luv(tuple)))
+end
+
+function LuvUtils.rgb_to_lch(tuple)
+	return LuvUtils.luv_to_lch(LuvUtils.xyz_to_luv(LuvUtils.rgb_to_xyz(tuple)))
+end
+
+function LuvUtils.hsluv_to_rgb(tuple)
+	return LuvUtils.lch_to_rgb(LuvUtils.hsluv_to_lch(tuple))
+end
+
+function LuvUtils.rgb_to_hsluv(tuple)
+	return LuvUtils.lch_to_hsluv(LuvUtils.rgb_to_lch(tuple))
+end
+
+function LuvUtils.hpluv_to_rgb(tuple)
+	return LuvUtils.lch_to_rgb(LuvUtils.hpluv_to_lch(tuple))
+end
+
+function LuvUtils.rgb_to_hpluv(tuple)
+	return LuvUtils.lch_to_hpluv(LuvUtils.rgb_to_lch(tuple))
+end
+
+function LuvUtils.hsluv_to_hex(tuple)
+	return LuvUtils.rgb_to_hex(LuvUtils.hsluv_to_rgb(tuple))
+end
+
+function LuvUtils.hpluv_to_hex(tuple)
+	return LuvUtils.rgb_to_hex(LuvUtils.hpluv_to_rgb(tuple))
+end
+
+function LuvUtils.hex_to_hsluv(s)
+	return LuvUtils.rgb_to_hsluv(LuvUtils.hex_to_rgb(s))
+end
+
+function LuvUtils.hex_to_hpluv(s)
+	return LuvUtils.rgb_to_hpluv(LuvUtils.hex_to_rgb(s))
+end
+
+LuvUtils.m = {
+	{ 3.240969941904521, -1.537383177570093, -0.498610760293 },
+	{ -0.96924363628087, 1.87596750150772, 0.041555057407175 },
+	{ 0.055630079696993, -0.20397695888897, 1.056971514242878 }
+}
+LuvUtils.minv = {
+	{ 0.41239079926595, 0.35758433938387, 0.18048078840183 },
+	{ 0.21263900587151, 0.71516867876775, 0.072192315360733 },
+	{ 0.019330818715591, 0.11919477979462, 0.95053215224966 }
+}
+LuvUtils.refY = 1.0
+LuvUtils.refU = 0.19783000664283
+LuvUtils.refV = 0.46831999493879
+LuvUtils.kappa = 903.2962962
+LuvUtils.epsilon = 0.0088564516
+
+return LuvUtils

package/src/Shared/luv/LuvVectorColor3Utils.lua

@@ -0,0 +1,41 @@
+--[=[
+	@class LuvVectorColor3Utils
+]=]
+
+local require = require(script.Parent.loader).load(script)
+
+local LuvUtils = require("LuvUtils")
+
+local LuvVectorColor3Utils = {}
+
+--[=[
+	Converts the Color3 to a Vector3 which can be interpolated by something
+	like a spring.
+	@param color3 Color3
+	@return Vector3
+]=]
+function LuvVectorColor3Utils.fromColor3(color3)
+	local hsl = LuvUtils.rgb_to_hsluv({ color3.r, color3.g, color3.b })
+
+	-- Transform from -100% to 100% into 0 to 1 space
+	return Vector3.new(
+		hsl[1]/200 + 0.5,
+		hsl[2]/200 + 0.5,
+		hsl[3]/200 + 0.5)
+end
+
+--[=[
+	Converts the Vector3 to a Color3 assuming it is the interpolated version.
+	@param luvV3 Vector3
+	@return Color3
+]=]
+function LuvVectorColor3Utils.toColor3(luvV3)
+	-- Transform out of this space
+	return Color3.new(unpack(LuvUtils.hsluv_to_rgb({
+		(luvV3.x - 0.5)*200,
+		(luvV3.y - 0.5)*200,
+		(luvV3.z - 0.5)*200})
+	))
+end
+
+return LuvVectorColor3Utils

package/src/node_modules.project.json

@@ -0,0 +1,7 @@
+{
+  "name": "node_modules",
+  "globIgnorePaths": [ "**/.package-lock.json" ],
+  "tree": {
+    "$path": { "optional": "../node_modules" }
+  }
+}