@quenty/depthoffield 11.0.0 → 11.1.0

package/CHANGELOG.md

@@ -3,6 +3,17 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+# [11.1.0](https://github.com/Quenty/NevermoreEngine/compare/@quenty/depthoffield@11.0.0...@quenty/depthoffield@11.1.0) (2024-03-09)
+
+
+### Features
+
+* Refactor DepthOfFieldService (Technically a breaking change, but I don't think anyone is using this package) ([b43d54e](https://github.com/Quenty/NevermoreEngine/commit/b43d54ea4edccf33def7e8d60c97d9dbec694379))
+
+
+
+
+
 # [11.0.0](https://github.com/Quenty/NevermoreEngine/compare/@quenty/depthoffield@10.0.0...@quenty/depthoffield@11.0.0) (2024-02-14)
 
 **Note:** Version bump only for package @quenty/depthoffield

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@quenty/depthoffield",
-  "version": "11.0.0",
+  "version": "11.1.0",
   "description": "Depth of field service to allow multiple systems to write depth of field",
   "keywords": [
     "Roblox",
@@ -26,15 +26,22 @@
   ],
   "dependencies": {
     "@quenty/acceltween": "^2.3.0",
-    "@quenty/baseobject": "^10.0.0",
-    "@quenty/loader": "^10.0.0",
-    "@quenty/maid": "^3.0.0",
-    "@quenty/signal": "^7.0.0",
+    "@quenty/baseobject": "^10.1.0",
+    "@quenty/basicpane": "^13.1.0",
+    "@quenty/blend": "^12.1.0",
+    "@quenty/brio": "^14.1.0",
+    "@quenty/instanceutils": "^13.1.0",
+    "@quenty/loader": "^10.1.0",
+    "@quenty/maid": "^3.1.0",
+    "@quenty/math": "^2.6.0",
+    "@quenty/rx": "^13.1.0",
+    "@quenty/signal": "^7.1.0",
     "@quenty/steputils": "^3.3.0",
-    "@quenty/valueobject": "^13.0.0"
+    "@quenty/transitionmodel": "^7.1.0",
+    "@quenty/valueobject": "^13.1.0"
   },
   "publishConfig": {
     "access": "public"
   },
-  "gitHead": "63f949a67b77d3edc98b358cace163da8c789e9f"
+  "gitHead": "e0148dde5ca3864389a0faa2da66153a776acc1e"
 }

package/src/Client/DepthOfFieldEffect.lua

@@ -0,0 +1,314 @@
+--[=[
+	Handles interpolation of depth of field, which is tricky due to how Roblox implemented the shader
+	and how it interacts with other depth of field effects.
+
+	@class DepthOfFieldEffect
+]=]
+
+local require = require(script.Parent.loader).load(script)
+
+local Lighting = game:GetService("Lighting")
+local Workspace = game:GetService("Workspace")
+
+local Blend = require("Blend")
+local Maid = require("Maid")
+local Math = require("Math")
+local Observable = require("Observable")
+local Rx = require("Rx")
+local RxBrioUtils = require("RxBrioUtils")
+local RxInstanceUtils = require("RxInstanceUtils")
+local SpringObject = require("SpringObject")
+local SpringTransitionModel = require("SpringTransitionModel")
+local TransitionModel = require("TransitionModel")
+local ValueObject = require("ValueObject")
+local RxAttributeUtils = require("RxAttributeUtils")
+
+local DepthOfFieldEffect = setmetatable({}, TransitionModel)
+DepthOfFieldEffect.ClassName = "DepthOfFieldEffect"
+DepthOfFieldEffect.__index = DepthOfFieldEffect
+
+function DepthOfFieldEffect.new()
+	local self = setmetatable(TransitionModel.new(), DepthOfFieldEffect)
+
+	self._focusDistanceSpring = self._maid:Add(SpringObject.new(40, 30))
+	self._inFocusRadiusSpring = self._maid:Add(SpringObject.new(35, 30))
+	self._nearIntensitySpring = self._maid:Add(SpringObject.new(1, 30))
+	self._farIntensitySpring = self._maid:Add(SpringObject.new(1, 30))
+
+	self._focusDistanceSpring.Epsilon = 1e-3
+	self._focusDistanceSpring.Epsilon = 1e-3
+	self._nearIntensitySpring.Epsilon = 1e-4
+	self._farIntensitySpring.Epsilon = 1e-4
+
+	self._percentVisibleModel = self._maid:Add(SpringTransitionModel.new())
+	self._percentVisibleModel:SetSpeed(10)
+	self._percentVisibleModel:BindToPaneVisbility(self)
+
+	self:SetPromiseShow(function(_, doNotAnimate)
+		return self._percentVisibleModel:PromiseShow(doNotAnimate)
+	end)
+	self:SetPromiseHide(function(_, doNotAnimate)
+		return self._percentVisibleModel:PromiseHide(doNotAnimate)
+	end)
+
+	self._maid:GiveTask(self:_render():Subscribe(function(gui)
+		self.Gui = gui
+	end))
+
+	return self
+end
+
+function DepthOfFieldEffect:SetShowSpeed(speed)
+	self._percentVisibleModel:SetSpeed(speed)
+end
+
+--[=[
+	Sets the target depth of field distance
+	@param focusDistanceTarget number
+	@param doNotAnimate boolean
+]=]
+function DepthOfFieldEffect:SetFocusDistanceTarget(focusDistanceTarget, doNotAnimate)
+	assert(type(focusDistanceTarget) == "number", "Bad focusDistanceTarget")
+
+	self._focusDistanceSpring:SetTarget(focusDistanceTarget, doNotAnimate)
+end
+
+--[=[
+	Sets the target depth of field radius
+	@param inFocusRadiusTarget number
+	@param doNotAnimate boolean
+]=]
+function DepthOfFieldEffect:SetInFocusRadiusTarget(inFocusRadiusTarget, doNotAnimate)
+	assert(type(inFocusRadiusTarget) == "number", "Bad inFocusRadiusTarget")
+
+	self._inFocusRadiusSpring:SetTarget(inFocusRadiusTarget, doNotAnimate)
+end
+
+--[=[
+	Sets the near intensity target
+	@param nearIntensityTarget number
+	@param doNotAnimate boolean
+]=]
+function DepthOfFieldEffect:SetNearIntensityTarget(nearIntensityTarget, doNotAnimate)
+	assert(type(nearIntensityTarget) == "number", "Bad nearIntensityTarget")
+
+	self._nearIntensitySpring:SetTarget(nearIntensityTarget, doNotAnimate)
+end
+
+--[=[
+	Sets the far intensity target
+	@param farIntensityTarget number
+	@param doNotAnimate boolean
+]=]
+function DepthOfFieldEffect:SetFarIntensityTarget(farIntensityTarget, doNotAnimate)
+	assert(type(farIntensityTarget) == "number", "Bad farIntensityTarget")
+
+	self._farIntensitySpring:SetTarget(farIntensityTarget, doNotAnimate)
+end
+
+--[=[
+	Retrieves the distance target
+	@return number
+]=]
+function DepthOfFieldEffect:GetFocusDistanceTarget()
+	return self._focusDistanceSpring.Target
+end
+
+--[=[
+	Retrieves the radius target
+	@return number
+]=]
+function DepthOfFieldEffect:GetInFocusRadiusTarget()
+	return self._inFocusRadiusSpring.Target
+end
+
+--[=[
+	Retrieve the near intensity target
+	@return number
+]=]
+function DepthOfFieldEffect:GetNearIntensityTarget()
+	return self._nearIntensitySpring.Target
+end
+
+--[=[
+	Retrieve the far intensity target
+	@return number
+]=]
+function DepthOfFieldEffect:GetFarIntensityTarget()
+	return self._farIntensitySpring.Target
+end
+
+function DepthOfFieldEffect:_render()
+	-- Note: Roblox blends DepthOfField by picking highest value in each category, so we always drive the "hidden"
+	-- state towards zero. The only issue is `InFocusRadius` must be rendered at target of 500 to fade "out" the effect
+	-- if other
+
+	return Blend.New "DepthOfFieldEffect" {
+		Name = "DepthOfField";
+		Enabled = Blend.Computed(self._percentVisibleModel, function(visible)
+			return visible > 0
+		end);
+		FocusDistance = Blend.Computed(
+			self._percentVisibleModel,
+			self._focusDistanceSpring,
+			self:_observeRenderedDepthOfFieldState(),
+			function(percentVisible, focusDistance, externalRenderedState)
+				-- This help smooth out interpolation
+
+				local externalFocusDistance = focusDistance
+				if externalRenderedState and externalRenderedState.focusDistance then
+					externalFocusDistance = externalRenderedState.focusDistance
+				end
+
+				return Math.map(percentVisible, 0, 1, externalFocusDistance, focusDistance)
+			end);
+		InFocusRadius = Blend.Computed(
+			self._percentVisibleModel,
+			self._inFocusRadiusSpring,
+			self:_observeRenderedDepthOfFieldState(),
+			function(percentVisible, inFocusRadius, externalRenderedState)
+				-- If we tween this to 0 then we create lots of blur as we do so
+				-- However, if we tween out to 500 then we get picked, blocking in-focus blur...
+				-- So tween to the minimum of other enabled depth of fields
+
+				-- Tweening just intensity doesn't work because of the way Roblox shaders work.
+
+				local externalInFocusRadius = 500
+				if externalRenderedState and externalRenderedState.inFocusRadius then
+					externalInFocusRadius = externalRenderedState.inFocusRadius
+				end
+
+				return Math.map(percentVisible, 0, 1, externalInFocusRadius, inFocusRadius)
+			end);
+		NearIntensity = Blend.Computed(self._percentVisibleModel, self._nearIntensitySpring, function(percentVisible, intensity)
+			return Math.map(percentVisible, 0, 1, 0, intensity)
+		end);
+		FarIntensity = Blend.Computed(self._percentVisibleModel, self._farIntensitySpring, function(percentVisible, intensity)
+			return Math.map(percentVisible, 0, 1, 0, intensity)
+		end);
+		[Blend.Instance] = function(gui)
+			self._depthOfField = gui
+
+			-- Setup attributes so multiple tweening depth off fields with this system isn't sad
+			self._maid:GiveTask(Blend.Computed(self._percentVisibleModel, self._inFocusRadiusSpring, function(percentVisible, inFocusRadius)
+				return Math.map(percentVisible, 0, 1, 0, inFocusRadius)
+			end):Subscribe(function(targetDepthOfFieldRadius)
+				self._depthOfField:SetAttribute("DepthOfFieldEffect_TargetInFocusRadius", targetDepthOfFieldRadius)
+			end))
+
+			self._maid:GiveTask(Blend.Computed(self._percentVisibleModel, self._focusDistanceSpring, function(percentVisible, focusDistance)
+				return Math.map(percentVisible, 0, 1, 0, focusDistance)
+			end):Subscribe(function(targetDepthOfFieldRadius)
+				self._depthOfField:SetAttribute("DepthOfFieldEffect_TargetFocusDistance", targetDepthOfFieldRadius)
+			end))
+		end;
+	}
+end
+
+function DepthOfFieldEffect:_observeRenderedDepthOfFieldState()
+	if self._observeOtherStates then
+		return self._observeOtherStates
+	end
+
+	self._observeOtherStates = Observable.new(function(sub)
+		local topMaid = Maid.new()
+
+		local result = topMaid:Add(ValueObject.new(nil))
+
+		local latestStates = {}
+
+		local function update()
+			local output = {
+				inFocusRadius = 0;
+				focusDistance = 0;
+				externalCount = 0;
+			}
+
+			for _, state in pairs(latestStates) do
+				if state.depthOfField == self._depthOfField then
+					continue
+				end
+
+				if state.enabled then
+					output.externalCount += 1
+					local inFocusRadius
+					if state.targetInFocusRadius then
+						inFocusRadius = state.targetInFocusRadius
+					else
+						inFocusRadius = state.inFocusRadius
+					end
+
+					output.inFocusRadius = math.max(output.inFocusRadius, inFocusRadius)
+
+					local focusDistance
+					if state.targetFocusDistance then
+						focusDistance = state.targetFocusDistance
+					else
+						focusDistance = state.focusDistance
+					end
+					output.focusDistance = math.max(output.focusDistance, focusDistance)
+				end
+			end
+
+			if output.externalCount == 0 then
+				result.Value = nil
+			else
+				result.Value = output
+			end
+		end
+
+		topMaid:GiveTask(self:_observeAllDepthOfFieldBrio():Subscribe(function(brio)
+			if brio:IsDead() then
+				return
+			end
+
+			local maid, depthOfField = brio:ToMaidAndValue()
+			maid:GiveTask(Rx.combineLatest({
+				depthOfField = depthOfField;
+
+				inFocusRadius = RxInstanceUtils.observeProperty(depthOfField, "InFocusRadius");
+				targetInFocusRadius = RxAttributeUtils.observeAttribute(depthOfField, "DepthOfFieldEffect_TargetInFocusRadius");
+
+				focusDistance = RxInstanceUtils.observeProperty(depthOfField, "FocusDistance");
+				targetFocusDistance = RxAttributeUtils.observeAttribute(depthOfField, "DepthOfFieldEffect_TargetFocusDistance");
+
+				enabled = RxInstanceUtils.observeProperty(depthOfField, "Enabled");
+			}):Subscribe(function(state)
+				if state.depthOfField == self._depthOfField then
+					latestStates[maid] = nil
+				else
+					latestStates[maid] = state
+					update()
+				end
+			end))
+
+			maid:GiveTask(function()
+				latestStates[maid] = nil
+				update()
+			end)
+		end))
+
+		topMaid:GiveTask(result:Observe():Subscribe(sub:GetFireFailComplete()))
+
+		return topMaid
+	end):Pipe({
+		Rx.cache()
+	})
+
+	return self._observeOtherStates
+end
+
+function DepthOfFieldEffect:_observeAllDepthOfFieldBrio()
+	return Rx.merge({
+		RxInstanceUtils.observeChildrenOfClassBrio(Lighting, "DepthOfFieldEffect");
+		RxInstanceUtils.observePropertyBrio(Workspace, "CurrentCamera", function(camera)
+			return camera ~= nil
+		end):Pipe({
+			RxBrioUtils.flatMapBrio(function(currentCamera)
+				return RxInstanceUtils.observeChildrenOfClassBrio(currentCamera, "DepthOfFieldEffect")
+			end)
+		})
+	})
+end
+
+return DepthOfFieldEffect

package/src/Client/DepthOfFieldEffect.story.lua

@@ -0,0 +1,79 @@
+--[[
+	@class DepthOfFieldEffect.story
+]]
+
+local require = require(game:GetService("ServerScriptService"):FindFirstChild("LoaderUtils", true).Parent).load(script)
+
+local Workspace = game:GetService("Workspace")
+
+local Maid = require("Maid")
+local DepthOfFieldEffect = require("DepthOfFieldEffect")
+local Blend = require("Blend")
+
+return function(target)
+	local maid = Maid.new()
+
+	local depthOfFieldEffect = maid:Add(DepthOfFieldEffect.new())
+	depthOfFieldEffect:SetShowSpeed(10)
+	depthOfFieldEffect.Gui.Parent = Workspace.CurrentCamera
+	depthOfFieldEffect:Show()
+
+	local depthOfFieldEffect2 = maid:Add(DepthOfFieldEffect.new())
+	depthOfFieldEffect2:SetFocusDistanceTarget(100, true)
+	depthOfFieldEffect2:SetInFocusRadiusTarget(50, true)
+	depthOfFieldEffect2:SetShowSpeed(10)
+	depthOfFieldEffect2.Gui.Parent = Workspace.CurrentCamera
+	-- depthOfFieldEffect2:Show()
+
+
+	maid:Add(Blend.mount(target, {
+		Blend.New "Frame" {
+			Size = UDim2.new(1, 0, 1, 0);
+			BackgroundTransparency = 1;
+
+			Blend.New "UIListLayout" {
+				Padding = UDim.new(0, 5);
+			};
+
+			Blend.New "TextButton" {
+				Text = Blend.Computed(depthOfFieldEffect:ObserveVisible(), function(visible)
+					return string.format("Toggle 1 (%s)", visible and "on" or "off")
+				end);
+				BackgroundColor3 = Blend.Computed(depthOfFieldEffect:ObserveVisible(), function(visible)
+					return visible and Color3.new(0.5, 1, 0.5) or Color3.new(1, 0.5, 0.5)
+				end);
+				AutoButtonColor = true;
+				Size = UDim2.new(0, 100, 0, 30);
+				[Blend.OnEvent "Activated"] = function()
+					depthOfFieldEffect:Toggle()
+				end;
+
+				Blend.New "UICorner" {
+					CornerRadius = UDim.new(0, 5);
+				};
+			};
+
+			Blend.New "TextButton" {
+				Text = Blend.Computed(depthOfFieldEffect2:ObserveVisible(), function(visible)
+					return string.format("Toggle 2 (%s)", visible and "on" or "off")
+				end);
+				BackgroundColor3 = Blend.Computed(depthOfFieldEffect2:ObserveVisible(), function(visible)
+					return visible and Color3.new(0.5, 1, 0.5) or Color3.new(1, 0.5, 0.5)
+				end);
+				AutoButtonColor = true;
+				Size = UDim2.new(0, 100, 0, 30);
+				[Blend.OnEvent "Activated"] = function()
+					depthOfFieldEffect2:Toggle()
+				end;
+
+				Blend.New "UICorner" {
+					CornerRadius = UDim.new(0, 5);
+				};
+			};
+		};
+	}))
+
+	return function()
+		maid:DoCleaning()
+	end
+end

package/src/Client/DepthOfFieldModifier.lua

@@ -1,164 +0,0 @@
---[=[
-	@class DepthOfFieldModifier
-]=]
-
-local require = require(script.Parent.loader).load(script)
-
-local BaseObject = require("BaseObject")
-local Signal = require("Signal")
-
-local DepthOfFieldModifier = setmetatable({}, BaseObject)
-DepthOfFieldModifier.ClassName = "DepthOfFieldModifier"
-DepthOfFieldModifier.__index = DepthOfFieldModifier
-
-function DepthOfFieldModifier.new(distance, radius, nearIntensity, farIntensity)
-	local self = setmetatable(BaseObject.new(), DepthOfFieldModifier)
-
-	assert(type(distance) == "number", "Bad distance")
-	assert(type(radius) == "number", "Bad radius")
-	assert(type(nearIntensity) == "number", "Bad nearIntensity")
-	assert(type(farIntensity) == "number", "Bad farIntensity")
-
-	self._originalDistance = distance
-	self._originalRadius = radius
-	self._originalNearIntensity = nearIntensity
-	self._originalFarIntensity = farIntensity
-
-	self._distance = distance
-	self._radius = radius
-	self._nearIntensity = nearIntensity
-	self._farIntensity = farIntensity
-
---[=[
-	Fires when the modifier is removing.
-	@prop Removing Signal
-	@within DepthOfFieldModifier
-]=]
-	self.Removing = Signal.new()
-	self._maid:GiveTask(function()
-		self.Removing:Fire()
-		self.Removing:Destroy()
-	end)
-
---[=[
-	Fires when the distance changes.
-	@prop DistanceChanged Signal
-	@within DepthOfFieldModifier
-]=]
-	self.DistanceChanged = Signal.new()
-	self._maid:GiveTask(self.DistanceChanged)
-
---[=[
-	Fires when the radius changes.
-	@prop RadiusChanged Signal
-	@within DepthOfFieldModifier
-]=]
-	self.RadiusChanged = Signal.new()
-	self._maid:GiveTask(self.RadiusChanged)
-
-	self.NearIntensityChanged = Signal.new()
-	self._maid:GiveTask(self.NearIntensityChanged)
-
-	self.FarIntensityChanged = Signal.new()
-	self._maid:GiveTask(self.FarIntensityChanged)
-
-	return self
-end
-
---[=[
-	Sets the target depth of field distance
-	@param distance number
-	@param doNotAnimate boolean
-]=]
-function DepthOfFieldModifier:SetDistance(distance, doNotAnimate)
-	assert(type(distance) == "number", "Bad distance")
-
-	if self._distance == distance then
-		return
-	end
-
-	self._distance = distance
-	self.DistanceChanged:Fire(distance, doNotAnimate)
-end
-
-function DepthOfFieldModifier:GetOriginalDistance()
-	return self._originalDistance
-end
-
-function DepthOfFieldModifier:GetOriginalRadius()
-	return self._originalRadius
-end
---[=[
-	Sets the target depth of field distance
-	@param radius number
-	@param doNotAnimate boolean
-]=]
-function DepthOfFieldModifier:SetRadius(radius, doNotAnimate)
-	assert(type(radius) == "number", "Bad radius")
-
-	if self._radius == radius then
-		return
-	end
-
-	self._radius = radius
-	self.RadiusChanged:Fire(radius, doNotAnimate)
-end
-
-function DepthOfFieldModifier:SetNearIntensity(nearIntensity, doNotAnimate)
-	assert(type(nearIntensity) == "number", "Bad nearIntensity")
-
-	if self._nearIntensity == nearIntensity then
-		return
-	end
-
-	self._nearIntensity = nearIntensity
-	self.NearIntensityChanged:Fire(nearIntensity, doNotAnimate)
-end
-
-function DepthOfFieldModifier:SetFarIntensity(farIntensity, doNotAnimate)
-	assert(type(farIntensity) == "number", "Bad farIntensity")
-
-	if self._farIntensity == farIntensity then
-		return
-	end
-
-	self._farIntensity = farIntensity
-	self.FarIntensityChanged:Fire(farIntensity, doNotAnimate)
-end
-
---[=[
-	Retrieves the distance
-	@return number
-]=]
-function DepthOfFieldModifier:GetDistance()
-	return self._distance
-end
-
---[=[
-	Retrieves the radius
-	@return number
-]=]
-function DepthOfFieldModifier:GetRadius()
-	return self._radius
-end
-
-function DepthOfFieldModifier:GetNearIntensity()
-	return self._nearIntensity
-end
-
-function DepthOfFieldModifier:GetFarIntensity()
-	return self._farIntensity
-end
-
---[=[
-	Resets the radius
-	@param doNotAnimate boolean
-]=]
-function DepthOfFieldModifier:Reset(doNotAnimate)
-	self:SetDistance(self._originalDistance, doNotAnimate)
-	self:SetRadius(self._originalRadius, doNotAnimate)
-	self:SetNearIntensity(self._originalNearIntensity, doNotAnimate)
-	self:SetFarIntensity(self._originalFarIntensity, doNotAnimate)
-end
-
-return DepthOfFieldModifier

package/src/Client/DepthOfFieldService.lua

@@ -1,135 +0,0 @@
---[=[
-	@class DepthOfFieldService
-]=]
-
-local require = require(script.Parent.loader).load(script)
-
-local Lighting = game:GetService("Lighting")
-
-local DepthOfFieldTweener = require("DepthOfFieldTweener")
-local DepthOfFieldModifier = require("DepthOfFieldModifier")
-local Maid = require("Maid")
-local ValueObject = require("ValueObject")
-
-local DepthOfFieldService = {}
-DepthOfFieldService.ServiceName = "DepthOfFieldService"
-
---[=[
-	Initializes the DepthOfFieldService. Should be done via [ServiceBag].
-	@param _serviceBag ServiceBag
-]=]
-function DepthOfFieldService:Init(_serviceBag)
-	self._maid = Maid.new()
-
-	self._topOfStack = self._maid:Add(ValueObject.new())
-
-	self._depthOfField = self:_createDepthOfFIeld()
-
-	self._tweener = self._maid:Add(DepthOfFieldTweener.new(self._depthOfField))
-
-	-- TODO: Reprogram completely to be independent...
-
-	-- Assume we can enable now that we've recorded values
-	-- self._depthOfField.InFocusRadius = self._tweener:GetOriginalRadius()
-	-- self._depthOfField.FocusDistance = self._tweener:GetOriginalDistance()
-	-- self._depthOfField.NearIntensity = self._tweener:GetOriginalNearIntensity()
-	-- self._depthOfField.FarIntensity = self._tweener:GetOriginalFarIntensity()
-	-- self._depthOfField.Enabled = true
-
-	self._maid:GiveTask(self._topOfStack.Changed:Connect(function(new)
-		local maid = Maid.new()
-
-		if new then
-			self._tweener:SetDistance(new:GetDistance(), false)
-			self._tweener:SetRadius(new:GetRadius(), false)
-			self._tweener:SetNearIntensity(new:GetNearIntensity(), false)
-			self._tweener:SetFarIntensity(new:GetFarIntensity(), false)
-
-			maid:GiveTask(new.DistanceChanged:Connect(function(distance, doNotAnimate)
-				self._tweener:SetDistance(distance, doNotAnimate)
-			end))
-			maid:GiveTask(new.RadiusChanged:Connect(function(radius, doNotAnimate)
-				self._tweener:SetRadius(radius, doNotAnimate)
-			end))
-			maid:GiveTask(new.NearIntensityChanged:Connect(function(nearIntensity, doNotAnimate)
-				self._tweener:SetNearIntensity(nearIntensity, doNotAnimate)
-			end))
-			maid:GiveTask(new.FarIntensityChanged:Connect(function(farIntensity, doNotAnimate)
-				self._tweener:SetFarIntensity(farIntensity, doNotAnimate)
-			end))
-		else
-			self._tweener:Reset()
-		end
-
-		self._maid._currentVisible = maid
-	end))
-
-	self._modifierStack = {}
-end
-
---[=[
-	Creates a new depth of field modifier
-	@return DepthOfFieldModifier
-]=]
-function DepthOfFieldService:CreateModifier()
-	local maid = Maid.new()
-
-	local modifier = DepthOfFieldModifier.new(
-		500,
-		500,
-		1,
-		1)
-	maid:GiveTask(modifier)
-
-	maid:GiveTask(function()
-		local index = table.find(self._modifierStack, modifier)
-		if index then
-			table.remove(self._modifierStack, index)
-		else
-			warn("[DepthOfFieldService] - Somehow modifier not in stack")
-		end
-
-		self:_updateTopOfStack()
-	end)
-
-	maid:GiveTask(modifier.Removing:Connect(function()
-		self:_removeModifier(modifier)
-	end))
-
-	self._maid[modifier] = maid
-
-
-	table.insert(self._modifierStack, modifier)
-	self:_updateTopOfStack()
-
-	if #self._modifierStack >= 10 then
-		warn("[DepthOfFieldService.PushEffect] - Memory leak possible in stack")
-	end
-
-	return modifier
-end
-
-function DepthOfFieldService:_updateTopOfStack()
-	self._topOfStack.Value = self._modifierStack[#self._modifierStack]
-end
-
-function DepthOfFieldService:_removeModifier(modifier)
-	self._maid[modifier] = nil
-	self:_updateTopOfStack()
-end
-
-function DepthOfFieldService:_createDepthOfFIeld()
-	local depthOfField = Instance.new("DepthOfFieldEffect")
-	depthOfField.Name = "DepthOfFieldService_DepthOfField"
-	depthOfField.FarIntensity = 0
-	depthOfField.FocusDistance = 500
-	depthOfField.InFocusRadius = 500
-	depthOfField.NearIntensity = 0
-	depthOfField.Enabled = true
-	depthOfField.Parent = Lighting
-	self._maid:GiveTask(depthOfField)
-
-	return depthOfField
-end
-
-return DepthOfFieldService

package/src/Client/DepthOfFieldTweener.lua

@@ -1,203 +0,0 @@
---[=[
-	Tweens DepthOfField. Prefer to use [DepthOfFieldService].
-	@class DepthOfFieldTweener
-]=]
-
-local require = require(script.Parent.loader).load(script)
-
-local AccelTween = require("AccelTween")
-local BaseObject = require("BaseObject")
-local StepUtils = require("StepUtils")
-
-local DepthOfFieldTweener = setmetatable({}, BaseObject)
-DepthOfFieldTweener.ClassName = "DepthOfFieldTweener"
-DepthOfFieldTweener.__index = DepthOfFieldTweener
-
---[=[
-	Create a new DepthOfFieldTweener.
-	@param depthOfField number
-	@return DepthOfFieldTweener
-]=]
-function DepthOfFieldTweener.new(depthOfField)
-	local self = setmetatable(BaseObject.new(), DepthOfFieldTweener)
-
-	self._depthOfField = assert(depthOfField, "No depthOfField")
-
-	-- If we aren't enabled we make sure to set distance to be far
-	self._originalDistance = self._depthOfField.Enabled and self._depthOfField.FocusDistance or 500
-	self._originalRadius = self._depthOfField.Enabled and self._depthOfField.InFocusRadius or 500
-	self._originalNearIntensity = self._depthOfField.NearIntensity
-	self._originalFarIntensity = self._depthOfField.FarIntensity
-
-	self._distance = AccelTween.new(10000)
-	self._distance.t = self._originalDistance
-	self._distance.p = self._originalDistance
-
-	self._radius = AccelTween.new(10000)
-	self._radius.t = self._originalRadius
-	self._radius.p = self._originalRadius
-
-	self._nearIntensity = AccelTween.new(30)
-	self._nearIntensity.t = self._originalNearIntensity
-	self._nearIntensity.p = self._originalNearIntensity
-
-	self._farIntensity = AccelTween.new(30)
-	self._farIntensity.t = self._originalFarIntensity
-	self._farIntensity.p = self._originalFarIntensity
-
-	self._maid:GiveTask(function()
-		self._depthOfField.FocusDistance = self._originalDistance
-		self._depthOfField.InFocusRadius = self._originalRadius
-		self._depthOfField.NearIntensity = self._originalNearIntensity
-		self._depthOfField.FarIntensity = self._originalFarIntensity
-	end)
-
-	self._startAnimation, self._maid._stop = StepUtils.bindToRenderStep(self._update)
-	self:_startAnimation()
-
-	return self
-end
-
-function DepthOfFieldTweener:SetNearIntensity(nearIntensity, doNotAnimate)
-	assert(type(nearIntensity) == "number", "Bad nearIntensity")
-
-	local target = math.clamp(nearIntensity, 0, 1)
-	self._nearIntensity.t = target
-	if doNotAnimate then
-		self._nearIntensity.p = target
-		self._nearIntensity.v = 0
-	end
-
-	self:_startAnimation()
-end
-
-function DepthOfFieldTweener:SetFarIntensity(farIntensity, doNotAnimate)
-	assert(type(farIntensity) == "number", "Bad farIntensity")
-
-	local target = math.clamp(farIntensity, 0, 1)
-	self._farIntensity.t = target
-	if doNotAnimate then
-		self._farIntensity.p = target
-		self._farIntensity.v = 0
-	end
-
-	self:_startAnimation()
-end
-
-
---[=[
-	Sets the radius and starts any animation
-	@param radius number
-	@param doNotAnimate boolean
-]=]
-function DepthOfFieldTweener:SetRadius(radius, doNotAnimate)
-	assert(type(radius) == "number", "Bad radius")
-
-	local target = math.clamp(radius, 0, 500)
-	self._radius.t = target
-	if doNotAnimate then
-		self._radius.p = target
-		self._radius.v = 0
-	end
-
-	self:_startAnimation()
-end
-
---[=[
-	Gets the current radius being rendered
-	@return number
-]=]
-function DepthOfFieldTweener:GetRadius()
-	return self._radius.p
-end
-
---[=[
-	Gets the current distance being set
-	@return number
-]=]
-function DepthOfFieldTweener:GetDistance()
-	return self._distance.p
-end
-
---[=[
-	Sets the distance to render
-	@param distance number
-	@param doNotAnimate boolean
-]=]
-function DepthOfFieldTweener:SetDistance(distance, doNotAnimate)
-	assert(type(distance) == "number", "Bad distance")
-
-	local target = math.clamp(distance, 0, 500)
-	self._distance.t = target
-	if doNotAnimate then
-		self._distance.p = target
-		self._distance.v = 0
-	end
-
-	self:_startAnimation()
-end
-
---[=[
-	Resets the depth of field to the original distance
-	@param doNotAnimate boolean
-]=]
-function DepthOfFieldTweener:Reset(doNotAnimate)
-	self:ResetRadius(doNotAnimate)
-	self:ResetDistance(doNotAnimate)
-	self:ResetNearIntensity(doNotAnimate)
-	self:ResetFarIntensity(doNotAnimate)
-end
-
---[=[
-	Resets the radius
-	@param doNotAnimate boolean
-]=]
-function DepthOfFieldTweener:ResetRadius(doNotAnimate)
-	self:SetRadius(self._originalRadius, doNotAnimate)
-end
-
---[=[
-	Resets the distance
-	@param doNotAnimate boolean
-]=]
-function DepthOfFieldTweener:ResetDistance(doNotAnimate)
-	self:SetDistance(self._originalDistance, doNotAnimate)
-end
-
-function DepthOfFieldTweener:ResetNearIntensity(doNotAnimate)
-	self:SetNearIntensity(self._originalNearIntensity, doNotAnimate)
-end
-
-function DepthOfFieldTweener:ResetFarIntensity(doNotAnimate)
-	self:SetFarIntensity(self._originalFarIntensity, doNotAnimate)
-end
-
-function DepthOfFieldTweener:GetOriginalRadius()
-	return self._originalRadius
-end
-
-function DepthOfFieldTweener:GetOriginalDistance()
-	return self._originalDistance
-end
-
-function DepthOfFieldTweener:GetOriginalNearIntensity()
-	return self._originalNearIntensity
-end
-
-function DepthOfFieldTweener:GetOriginalFarIntensity()
-	return self._originalFarIntensity
-end
-
-function DepthOfFieldTweener:_update()
-	self._depthOfField.FocusDistance = self._distance.p
-	self._depthOfField.InFocusRadius = self._radius.p
-	self._depthOfField.NearIntensity = self._nearIntensity.p
-	self._depthOfField.FarIntensity = self._farIntensity.p
-
-	return self._radius.rtime > 0
-		or self._distance.rtime > 0
-		or self._nearIntensity.rtime > 0
-		or self._farIntensity.rtime > 0
-end
-
-return DepthOfFieldTweener