Users/quenty/tracking

.vscode/settings.json

@@ -8,7 +8,7 @@
   "luau-lsp.ignoreGlobs": ["**/node_modules/**"],
 
   // This prevents Rojo from memory leaking
-  "luau-lsp.sourcemap.generatorCommand": "rojo sourcemap",
+  "luau-lsp.sourcemap.generatorCommand": "npm run build:sourcemap",
   "luau-lsp.sourcemap.useVSCodeWatcher": true,
 
   "[lua]": {

Nevermore.code-workspace

@@ -8,30 +8,30 @@
     "files.exclude": {
       "*.sublime-workspace": true,
       "**/node_modules/**": true,
-      "roblox.toml": true
+      "roblox.toml": true,
     },
     "luau-lsp.sourcemap.rojoProjectFile": "default.project.json",
     "luau-lsp.ignoreGlobs": ["**/node_modules/**"],
 
     // This prevents Rojo from memory leaking
-    "luau-lsp.sourcemap.generatorCommand": "rojo sourcemap",
+    "luau-lsp.sourcemap.generatorCommand": "npm run build:sourcemap",
     "luau-lsp.sourcemap.useVSCodeWatcher": true,
 
     "[lua]": {
       "editor.defaultFormatter": "JohnnyMorganz.stylua",
       "editor.formatOnSave": true,
-      "editor.formatOnSaveMode": "file"
+      "editor.formatOnSaveMode": "file",
     },
     "[luau]": {
       "editor.defaultFormatter": "JohnnyMorganz.stylua",
       "editor.formatOnSave": true,
-      "editor.formatOnSaveMode": "file"
+      "editor.formatOnSaveMode": "file",
     },
     "[typescript]": {
       "editor.defaultFormatter": "esbenp.prettier-vscode",
       "editor.formatOnSave": true,
-      "editor.formatOnSaveMode": "file"
-    }
+      "editor.formatOnSaveMode": "file",
+    },
   },
   "extensions": {
     "recommendations": [

src/binarysearch/src/Shared/BinarySearchUtils.lua

@@ -49,6 +49,13 @@ end
 --[=[
 	Same as searching a span, but uses a list of nodes
 
+	```
+		if t lands within the domain of two spans of time
+		t = 5
+		[3   5][5   7]
+		          ^ picks this one
+	```
+
 	@param list { TNode }
 	@param index string
 	@param t number

src/binder/src/Shared/Binder.lua

@@ -249,7 +249,7 @@ end
 	@param instance Instance
 	@return Observable<T?>
 ]=]
-function Binder:Observe(instance: Instance)
+function Binder.Observe<T>(self: Binder<T>, instance: Instance): Observable.Observable<T?>
 	assert(typeof(instance) == "Instance", "Bad instance")
 
 	return Observable.new(function(sub)

src/hide/package.json

@@ -30,8 +30,12 @@
   ],
   "dependencies": {
     "@quenty/binder": "workspace:*",
+    "@quenty/brio": "workspace:*",
+    "@quenty/instanceutils": "workspace:*",
     "@quenty/loader": "workspace:*",
-    "@quenty/servicebag": "workspace:*"
+    "@quenty/rx": "workspace:*",
+    "@quenty/servicebag": "workspace:*",
+    "@quenty/transparencyservice": "workspace:*"
   },
   "publishConfig": {
     "access": "public"

src/hide/src/Client/DynamicHideClient.lua

@@ -0,0 +1,68 @@
+--!strict
+--[=[
+    @class DynamicHideClient
+]=]
+
+local require = require(script.Parent.loader).load(script)
+
+local Binder = require("Binder")
+local DynamicHideBase = require("DynamicHideBase")
+local HideUtils = require("HideUtils")
+local Maid = require("Maid")
+local ServiceBag = require("ServiceBag")
+local TransparencyService = require("TransparencyService")
+
+local DynamicHideClient = setmetatable({}, DynamicHideBase)
+DynamicHideClient.ClassName = "DynamicHideClient"
+DynamicHideClient.__index = DynamicHideClient
+
+export type DynamicHideClient =
+	typeof(setmetatable(
+		{} :: {
+			_obj: Instance,
+			_serviceBag: ServiceBag.ServiceBag,
+			_transparencyService: any,
+			_hideBinder: any,
+		},
+		{} :: typeof({ __index = DynamicHideClient })
+	))
+	& DynamicHideBase.DynamicHideBase
+
+function DynamicHideClient.new(instance: Instance, serviceBag: ServiceBag.ServiceBag): DynamicHideClient
+	local self: DynamicHideClient = setmetatable(DynamicHideBase.new(instance) :: any, DynamicHideClient)
+
+	self._serviceBag = assert(serviceBag, "No serviceBag")
+	self._transparencyService = self._serviceBag:GetService(TransparencyService)
+	self._hideBinder = self._serviceBag:GetService(require("HideClient"))
+
+	self._maid:GiveTask(self:_observeHideChildrenBrio(self._hideBinder):Subscribe(function(childBrio)
+		if childBrio:IsDead() then
+			return
+		end
+
+		local childMaid, childInstance = childBrio:ToMaidAndValue()
+		self:_hideChild(childMaid, childInstance)
+	end))
+
+	return self
+end
+
+function DynamicHideClient._hideChild(self: DynamicHideClient, maid: Maid.Maid, instance: Instance)
+	if HideUtils.hasLocalTransparencyModifier(instance) then
+		self._transparencyService:SetLocalTransparencyModifier(self, instance, 1)
+
+		maid:GiveTask(function()
+			self._transparencyService:ResetLocalTransparencyModifier(self, instance)
+		end)
+	elseif HideUtils.hasTransparency(instance) then
+		self._transparencyService:SetTransparency(self, instance, 1)
+
+		maid:GiveTask(function()
+			self._transparencyService:ResetTransparency(self, instance)
+		end)
+	else
+		error("[DynamicHideClient] - Bad instance for hiding")
+	end
+end
+
+return Binder.new("DynamicHide", DynamicHideClient :: any) :: Binder.Binder<DynamicHideClient>

src/hide/src/Client/HideServiceClient.lua

@@ -14,8 +14,12 @@ function HideServiceClient:Init(serviceBag: ServiceBag.ServiceBag)
 	assert(not self._serviceBag, "Already initialized")
 	self._serviceBag = assert(serviceBag, "No serviceBag")
 
-	-- Internal
+	-- External
+	self._serviceBag:GetService(require("TransparencyService"))
+
+	-- Binders
 	self._serviceBag:GetService(require("HideClient"))
+	self._serviceBag:GetService(require("DynamicHideClient"))
 end
 
 return HideServiceClient

src/hide/src/Server/DynamicHide.lua

@@ -0,0 +1,62 @@
+--!strict
+--[=[
+    @class DynamicHide
+]=]
+
+local require = require(script.Parent.loader).load(script)
+
+local Binder = require("Binder")
+local DynamicHideBase = require("DynamicHideBase")
+local HideUtils = require("HideUtils")
+local Maid = require("Maid")
+local ServiceBag = require("ServiceBag")
+
+local DynamicHide = setmetatable({}, DynamicHideBase)
+DynamicHide.ClassName = "DynamicHide"
+DynamicHide.__index = DynamicHide
+
+export type DynamicHide =
+	typeof(setmetatable(
+		{} :: {
+			_obj: Instance,
+			_serviceBag: ServiceBag.ServiceBag,
+			_hideBinder: any,
+		},
+		{} :: typeof({ __index = DynamicHide })
+	))
+	& DynamicHideBase.DynamicHideBase
+
+function DynamicHide.new(instance: Instance, serviceBag: ServiceBag.ServiceBag): DynamicHide
+	local self: DynamicHide = setmetatable(DynamicHideBase.new(instance) :: any, DynamicHide)
+
+	self._serviceBag = assert(serviceBag, "No serviceBag")
+	self._hideBinder = self._serviceBag:GetService(require("Hide"))
+
+	self._maid:GiveTask(self:_observeHideChildrenBrio(self._hideBinder):Subscribe(function(childBrio)
+		if childBrio:IsDead() then
+			return
+		end
+
+		local childMaid, childInstance = childBrio:ToMaidAndValue()
+		self:_hideChild(childMaid, childInstance)
+	end))
+
+	return self
+end
+
+function DynamicHide._hideChild(_self: DynamicHide, maid: Maid.Maid, instance: Instance)
+	if HideUtils.hasLocalTransparencyModifier(instance) then
+		(instance :: any).LocalTransparencyModifier = 1
+
+		maid:GiveTask(function()
+			(instance :: any).LocalTransparencyModifier = 0
+		end)
+	-- selene: allow(empty_if)
+	elseif HideUtils.hasTransparency(instance) then
+		-- Note we don't want to replicate this necessarily
+	else
+		error("[DynamicHide] - Bad instance for hiding")
+	end
+end
+
+return Binder.new("DynamicHide", DynamicHide :: any) :: Binder.Binder<DynamicHide>

src/hide/src/Server/Hide.lua

@@ -1,4 +1,5 @@
 --!strict
+local HideUtils = require(script.Parent.Parent.Shared.HideUtils)
 --[=[
 	Primarily used for authoring, this hides the tagged instance from render. Great for
 	making bounding boxes in studio that are then hidden upon runtime.
@@ -25,28 +26,27 @@ Hide.__index = Hide
 function Hide.new(adornee: Instance)
 	local self = setmetatable({}, Hide)
 
-	self._obj = assert(adornee, "No adornee")
+	self._instance = assert(adornee, "No adornee")
 
-	if self._obj:IsA("BasePart") then
-		self:_setupPart(self._obj)
-	elseif self._obj:IsA("Model") then
-		for _, item in self._obj:GetChildren() do
-			if item:IsA("BasePart") then
-				self:_setupPart(item)
-			end
-		end
-	elseif self._obj:IsA("GuiObject") then
-		self._obj.BackgroundTransparency = 1
-	else
-		error("[Hide] - Bad object type for hide")
+	if not self._instance:HasTag("DynamicHide") then
+		self:_hideInstance(self._instance)
 	end
 
 	return self
 end
 
-function Hide:_setupPart(part: BasePart)
-	part.Locked = true
-	part.Transparency = 1
+function Hide:_hideInstance(instance: Instance)
+	if instance:IsA("BasePart") then
+		instance.Locked = true
+		instance.Transparency = 1
+	elseif instance:IsA("Model") or instance:IsA("Folder") then
+		-- Be limited in what we recurse down
+		for _, child in self._instance:GetChildren() do
+			self:_hideInstance(child)
+		end
+	elseif HideUtils.hasTransparency(instance) then
+		(instance :: any).Transparency = 1
+	end
 end
 
 --[=[

src/hide/src/Server/HideService.lua

@@ -14,8 +14,9 @@ function HideService:Init(serviceBag: ServiceBag.ServiceBag)
 	assert(not self._serviceBag, "Already initialized")
 	self._serviceBag = assert(serviceBag, "No serviceBag")
 
-	-- Internal
+	-- Binders
 	self._serviceBag:GetService(require("Hide"))
+	self._serviceBag:GetService(require("DynamicHide"))
 end
 
 return HideService

src/hide/src/Shared/DynamicHideBase.lua

@@ -0,0 +1,47 @@
+--!strict
+--[=[
+    @class DynamicHideBase
+]=]
+
+local require = require(script.Parent.loader).load(script)
+
+local BaseObject = require("BaseObject")
+local Brio = require("Brio")
+local HideUtils = require("HideUtils")
+local Observable = require("Observable")
+local RxBrioUtils = require("RxBrioUtils")
+local RxInstanceUtils = require("RxInstanceUtils")
+
+local DynamicHideBase = setmetatable({}, BaseObject)
+DynamicHideBase.ClassName = "DynamicHideBase"
+DynamicHideBase.__index = DynamicHideBase
+
+export type DynamicHideBase =
+	typeof(setmetatable(
+		{} :: {
+			_obj: Instance,
+		},
+		{} :: typeof({ __index = DynamicHideBase })
+	))
+	& BaseObject.BaseObject
+
+function DynamicHideBase.new(instance: Instance): DynamicHideBase
+	local self: DynamicHideBase = setmetatable(BaseObject.new(instance) :: any, DynamicHideBase)
+
+	return self
+end
+
+function DynamicHideBase._observeHideChildrenBrio(
+	self: DynamicHideBase,
+	hideBinder: any
+): Observable.Observable<Brio.Brio<Instance>>
+	return hideBinder:ObserveBrio(self._obj):Pipe({
+		RxBrioUtils.switchMapBrio(function()
+			return RxInstanceUtils.observeDescendantsAndSelfBrio(self._obj, function(child)
+				return HideUtils.hasLocalTransparencyModifier(child) or HideUtils.hasTransparency(child)
+			end)
+		end),
+	})
+end
+
+return DynamicHideBase