@quenty/fakeskybox 11.15.0 → 11.16.0

package/src/Client/Render/SkyboxRenderPart.lua

@@ -0,0 +1,258 @@
+--!strict
+--[=[
+	@class SkyboxRenderPart
+]=]
+
+local require = require(script.Parent.loader).load(script)
+
+local BaseObject = require("BaseObject")
+local Blend = require("Blend")
+local ColorSequenceUtils = require("ColorSequenceUtils")
+local FakeSkyboxRenderMethod = require("FakeSkyboxRenderMethod")
+local Rx = require("Rx")
+local ValueObject = require("ValueObject")
+
+local SkyboxRenderPart = setmetatable({}, BaseObject)
+SkyboxRenderPart.__index = SkyboxRenderPart
+SkyboxRenderPart.ClassName = "SkyboxRenderPart"
+
+export type SkyboxRenderPart =
+	typeof(setmetatable(
+		{} :: {
+			Gui: Part,
+			_partRef: ValueObject.ValueObject<Part>,
+			_size: ValueObject.ValueObject<Vector3>,
+			_transparency: ValueObject.ValueObject<number>,
+			_zOffset: ValueObject.ValueObject<number>,
+			_cframe: ValueObject.ValueObject<CFrame>,
+			_image: ValueObject.ValueObject<string>,
+			_canvasSize: ValueObject.ValueObject<Vector2>,
+			_brightness: ValueObject.ValueObject<number>,
+			_imageColor3: ValueObject.ValueObject<Color3>,
+			_imageGradientSequence: ValueObject.ValueObject<ColorSequence?>,
+			_renderMethod: ValueObject.ValueObject<FakeSkyboxRenderMethod.FakeSkyboxRenderMethod>,
+		},
+		{} :: typeof({ __index = SkyboxRenderPart })
+	))
+	& BaseObject.BaseObject
+
+function SkyboxRenderPart.new(): SkyboxRenderPart
+	local self: SkyboxRenderPart = setmetatable(BaseObject.new() :: any, SkyboxRenderPart)
+
+	self._partRef = self._maid:Add(ValueObject.new(nil))
+	self._size = self._maid:Add(ValueObject.new(Vector3.new(1, 1, 1), "Vector3"))
+	self._zOffset = self._maid:Add(ValueObject.new(0, "number"))
+	self._transparency = self._maid:Add(ValueObject.new(1, "number"))
+	self._cframe = self._maid:Add(ValueObject.new(CFrame.identity, "CFrame"))
+	self._image = self._maid:Add(ValueObject.new("", "string"))
+	self._imageColor3 = self._maid:Add(ValueObject.new(Color3.new(1, 1, 1), "Color3"))
+	self._imageGradientSequence = self._maid:Add(ValueObject.new(nil))
+	self._brightness = self._maid:Add(ValueObject.new(1, "number"))
+	self._canvasSize = self._maid:Add(ValueObject.new(Vector2.new(512, 512), "Vector2"))
+	self._renderMethod =
+		self._maid:Add(ValueObject.new(FakeSkyboxRenderMethod.SURFACEGUI :: any, FakeSkyboxRenderMethod:GetInterface()))
+
+	self._maid:GiveTask(self:_render():Subscribe(function(gui)
+		self.Gui = gui
+	end))
+
+	return self
+end
+
+function SkyboxRenderPart.SetCFrame(self: SkyboxRenderPart, cframe: ValueObject.Mountable<CFrame>): () -> ()
+	return self._cframe:Mount(cframe)
+end
+
+function SkyboxRenderPart.SetRenderMethod(
+	self: SkyboxRenderPart,
+	renderMethod: ValueObject.Mountable<FakeSkyboxRenderMethod.FakeSkyboxRenderMethod>
+): () -> ()
+	return self._renderMethod:Mount(renderMethod)
+end
+
+function SkyboxRenderPart.SetCanvasSize(self: SkyboxRenderPart, canvasSize: ValueObject.Mountable<Vector2>): () -> ()
+	return self._canvasSize:Mount(canvasSize)
+end
+
+function SkyboxRenderPart.SetBrightness(self: SkyboxRenderPart, brightness: ValueObject.Mountable<number>): () -> ()
+	return self._brightness:Mount(brightness)
+end
+
+function SkyboxRenderPart.SetImageColor3(self: SkyboxRenderPart, imageColor3: ValueObject.Mountable<Color3>): () -> ()
+	return self._imageColor3:Mount(imageColor3)
+end
+
+function SkyboxRenderPart.SetImageGradientSequence(
+	self: SkyboxRenderPart,
+	imageGradientSequence: ValueObject.Mountable<ColorSequence?>
+): () -> ()
+	return self._imageGradientSequence:Mount(imageGradientSequence)
+end
+
+function SkyboxRenderPart.SetSize(self: SkyboxRenderPart, size: ValueObject.Mountable<Vector3>): () -> ()
+	return self._size:Mount(size)
+end
+
+function SkyboxRenderPart.SetImage(self: SkyboxRenderPart, image: ValueObject.Mountable<string>): () -> ()
+	return self._image:Mount(image)
+end
+
+function SkyboxRenderPart.SetTransparency(self: SkyboxRenderPart, transparency: ValueObject.Mountable<number>): () -> ()
+	return self._transparency:Mount(transparency)
+end
+
+function SkyboxRenderPart.SetZOffset(self: SkyboxRenderPart, zOffset: ValueObject.Mountable<number>): () -> ()
+	return self._zOffset:Mount(zOffset)
+end
+
+function SkyboxRenderPart._render(self: SkyboxRenderPart): any
+	local observeSingleSequenceColor = self._imageGradientSequence:Observe():Pipe({
+		Rx.map(function(imageGradientSequence): Color3?
+			if imageGradientSequence == nil then
+				return nil
+			end
+
+			return ColorSequenceUtils.getSingleColorInSequence(imageGradientSequence)
+		end) :: any,
+		Rx.cache() :: any,
+	})
+
+	local observeTopColorOfGradient = self._imageGradientSequence:Observe():Pipe({
+		Rx.map(function(imageGradientSequence): Color3?
+			if imageGradientSequence == nil then
+				return nil
+			end
+
+			return ColorSequenceUtils.getColor(imageGradientSequence, 1)
+		end) :: any,
+		Rx.cache() :: any,
+	})
+
+	local observeDecalColor3 = Blend.Computed(
+		observeSingleSequenceColor,
+		observeTopColorOfGradient,
+		self._imageColor3:Observe(),
+		self._brightness:Observe(),
+		function(
+			singleSequenceColor: Color3?,
+			topColorOfGradient: Color3?,
+			imageColor3: Color3,
+			brightness: number
+		): Color3
+			-- We blend with the "top" color since usually you look up, not down
+			local blendWithColor
+			if singleSequenceColor ~= nil then
+				blendWithColor = singleSequenceColor
+			elseif topColorOfGradient ~= nil then
+				blendWithColor = topColorOfGradient
+			else
+				blendWithColor = Color3.new(1, 1, 1)
+			end
+
+			-- We also compensate for brightness here since decals don't respond to it like surface guis do
+			return Color3.new(
+				imageColor3.R * blendWithColor.R * brightness,
+				imageColor3.G * blendWithColor.G * brightness,
+				imageColor3.B * blendWithColor.B * brightness
+			)
+		end
+	)
+
+	local observeImageColor3 = Blend.Shared(
+		Blend.Computed(
+			observeSingleSequenceColor,
+			self._imageColor3:Observe(),
+			function(singleSequenceColor: Color3?, imageColor3: Color3): Color3
+				if singleSequenceColor == nil then
+					-- Gradient will tint
+					return imageColor3
+				end
+
+				return Color3.new(
+					imageColor3.R * singleSequenceColor.R,
+					imageColor3.G * singleSequenceColor.G,
+					imageColor3.B * singleSequenceColor.B
+				)
+			end
+		)
+	)
+
+	return Blend.New "Part" {
+		Name = "SkyboxPart",
+		Anchored = true,
+		Transparency = 1,
+		Color = observeImageColor3,
+		CanCollide = false,
+		CastShadow = false,
+		CanQuery = false,
+		CanTouch = false,
+		AudioCanCollide = false,
+		Material = Enum.Material.Fabric, -- Reduces specularity, but we should do something more custom in general
+		Size = self._size:Observe(),
+		CFrame = self._cframe:Observe(),
+
+		[Blend.Instance] = self._partRef,
+
+		Blend.New "Decal" {
+			Name = "SkyboxDecal",
+			Face = Enum.NormalId.Front,
+			ColorMap = self._image:Observe(),
+			Color3 = observeDecalColor3,
+			Transparency = Blend.Computed(
+				self._renderMethod,
+				self._transparency:Observe(),
+				function(renderMethod, transparency)
+					if renderMethod == FakeSkyboxRenderMethod.DECAL then
+						return transparency
+					else
+						return 1
+					end
+				end
+			),
+			ZIndex = self._zOffset:Observe(),
+		},
+
+		Blend.New "SurfaceGui" {
+			Adornee = self._partRef,
+			AutoLocalize = false,
+			SizingMode = Enum.SurfaceGuiSizingMode.FixedSize,
+			Active = false,
+			CanvasSize = self._canvasSize:Observe(),
+			LightInfluence = 0,
+			Brightness = self._brightness:Observe(),
+			Face = Enum.NormalId.Front,
+			ZOffset = self._zOffset:Observe(),
+			Enabled = Blend.Computed(self._renderMethod, function(renderMethod)
+				return renderMethod == FakeSkyboxRenderMethod.SURFACEGUI
+			end),
+
+			Blend.New "ImageLabel" {
+				Name = "SkyboxImage",
+				AnchorPoint = Vector2.new(0.5, 0.5),
+				Position = UDim2.fromScale(0.5, 0.5),
+				Size = UDim2.fromScale(1, 1),
+				ImageTransparency = self._transparency:Observe(),
+				Image = self._image:Observe(),
+				ImageColor3 = observeImageColor3,
+				BackgroundColor3 = Color3.new(0, 0, 0),
+				BackgroundTransparency = 1,
+				BorderSizePixel = 0,
+
+				Blend.New "UIGradient" {
+					Name = "SkyboxGradient",
+					Enabled = Blend.Computed(observeSingleSequenceColor, function(color)
+						return color == nil
+					end),
+					Color = self._imageGradientSequence:Observe():Pipe({
+						Rx.where(function(imageGradientSequence)
+							return imageGradientSequence ~= nil
+						end) :: any,
+					}) :: any,
+					Rotation = -90,
+				},
+			},
+		},
+	}
+end
+
+return SkyboxRenderPart

package/src/Client/Render/SkyboxSide.lua

@@ -0,0 +1,135 @@
+--!strict
+--[=[
+	@class SkyboxSide
+]=]
+
+local require = require(script.Parent.loader).load(script)
+
+local BaseObject = require("BaseObject")
+local Blend = require("Blend")
+local ColorSequenceUtils = require("ColorSequenceUtils")
+local FakeSkyboxRenderMethod = require("FakeSkyboxRenderMethod")
+local Observable = require("Observable")
+local SkyboxRenderPart = require("SkyboxRenderPart")
+local ValueObject = require("ValueObject")
+
+local SkyboxSide = setmetatable({}, BaseObject)
+SkyboxSide.__index = SkyboxSide
+SkyboxSide.ClassName = "SkyboxSide"
+
+local RENDER_PART_DEPTH = 1
+
+export type SkyboxSide =
+	typeof(setmetatable(
+		{} :: {
+			Gui: Part,
+			_normal: Enum.NormalId,
+			_renderPart: SkyboxRenderPart.SkyboxRenderPart,
+			_skyboxWidth: ValueObject.ValueObject<number>,
+			_skyboxCFrame: ValueObject.ValueObject<CFrame>,
+			_skyboxGradient: ValueObject.ValueObject<ColorSequence>,
+		},
+		{} :: typeof({ __index = SkyboxSide })
+	))
+	& BaseObject.BaseObject
+
+function SkyboxSide.new(normal: Enum.NormalId): SkyboxSide
+	assert(normal, "Bad normal")
+
+	local self: SkyboxSide = setmetatable(BaseObject.new() :: any, SkyboxSide)
+
+	self._normal = normal
+	self._skyboxWidth = self._maid:Add(ValueObject.new(1024, "number"))
+	self._skyboxCFrame = self._maid:Add(ValueObject.new(CFrame.identity, "CFrame"))
+	self._skyboxGradient = self._maid:Add(ValueObject.new(ColorSequence.new(Color3.new(1, 1, 1)), "ColorSequence"))
+
+	self._renderPart = self._maid:Add(SkyboxRenderPart.new())
+	self._renderPart:SetCFrame(
+		Blend.Computed(self._skyboxWidth, self._skyboxCFrame, function(skyboxWidth: number, skyboxCFrame: CFrame)
+			local direction = Vector3.FromNormalId(self._normal)
+			local offset = direction * RENDER_PART_DEPTH / 2
+
+			local relativeOffset = CFrame.new(direction * (skyboxWidth / 2) + offset)
+				* CFrame.new(Vector3.zero, -direction)
+
+			if self._normal == Enum.NormalId.Bottom then
+				-- Hack
+				relativeOffset = relativeOffset * CFrame.Angles(0, 0, math.pi)
+			end
+
+			return skyboxCFrame * relativeOffset
+		end)
+	)
+	self._renderPart:SetSize(Blend.Computed(self._skyboxWidth, function(skyboxWidth: number)
+		return Vector3.new(skyboxWidth, skyboxWidth, RENDER_PART_DEPTH)
+	end))
+	self._renderPart:SetImageGradientSequence(self:_observeImageGradientSequence())
+
+	self.Gui = self._renderPart.Gui
+	self.Gui.Name = self._normal.Name .. "SkyboxPart"
+
+	return self
+end
+
+function SkyboxSide.SetRenderMethod(
+	self: SkyboxSide,
+	renderMethod: ValueObject.Mountable<FakeSkyboxRenderMethod.FakeSkyboxRenderMethod>
+): () -> ()
+	return self._renderPart:SetRenderMethod(renderMethod)
+end
+
+function SkyboxSide.SetZOffset(self: SkyboxSide, zOffset: ValueObject.Mountable<number>): () -> ()
+	return self._renderPart:SetZOffset(zOffset)
+end
+
+function SkyboxSide.SetSkyboxGradient(self: SkyboxSide, skyboxGradient: ValueObject.Mountable<ColorSequence>): () -> ()
+	return self._skyboxGradient:Mount(skyboxGradient)
+end
+
+function SkyboxSide._observeImageGradientSequence(self): Observable.Observable<ColorSequence?>
+	return Blend.Computed(
+		self._renderMode,
+		self._skyboxGradient,
+		self._normal,
+		function(
+			renderMode: FakeSkyboxRenderMethod.FakeSkyboxRenderMethod,
+			skyboxGradient: ColorSequence,
+			normal: Enum.NormalId
+		): ColorSequence
+			if renderMode == FakeSkyboxRenderMethod.DECAL then
+				-- Decal mode doesn't support gradient, so we just use the lowest color for tinting
+				return ColorSequence.new(ColorSequenceUtils.getColor(skyboxGradient, 0))
+			end
+
+			if normal == Enum.NormalId.Top then
+				return ColorSequence.new(ColorSequenceUtils.getColor(skyboxGradient, 1))
+			elseif normal == Enum.NormalId.Bottom then
+				return ColorSequence.new(ColorSequenceUtils.getColor(skyboxGradient, 0))
+			else
+				return skyboxGradient
+			end
+		end
+	)
+end
+
+function SkyboxSide.SetBrightness(self: SkyboxSide, brightness: ValueObject.Mountable<number>): () -> ()
+	return self._renderPart:SetBrightness(brightness)
+end
+
+function SkyboxSide.SetPartSize(self: SkyboxSide, skyboxWidth: ValueObject.Mountable<number>): () -> ()
+	return self._skyboxWidth:Mount(skyboxWidth)
+end
+
+function SkyboxSide.SetImage(self: SkyboxSide, image: ValueObject.Mountable<string>): () -> ()
+	return self._renderPart:SetImage(image)
+end
+
+function SkyboxSide.SetTransparency(self: SkyboxSide, transparency: ValueObject.Mountable<number>): () -> ()
+	return self._renderPart:SetTransparency(transparency)
+end
+
+function SkyboxSide.SetSkyboxCFrame(self: SkyboxSide, skyboxCFrame: ValueObject.Mountable<CFrame>): () -> ()
+	return self._skyboxCFrame:Mount(skyboxCFrame)
+end
+
+return SkyboxSide

package/src/Server/FakeSkyboxService.lua

@@ -0,0 +1,17 @@
+--[=[
+	@class FakeSkyboxService
+]=]
+
+local require = require(script.Parent.loader).load(script)
+
+local ServiceBag = require("ServiceBag")
+
+local FakeSkyboxService = {}
+FakeSkyboxService.ServiceName = "FakeSkyboxService"
+
+function FakeSkyboxService:Init(serviceBag: ServiceBag.ServiceBag)
+	assert(not self._serviceBag, "Already initialized")
+	self._serviceBag = assert(serviceBag, "No serviceBag")
+end
+
+return FakeSkyboxService

package/src/jest.config.lua

@@ -0,0 +1,3 @@
+return {
+	testMatch = { "**/*.spec" },
+}

package/test/default.project.json

@@ -0,0 +1,32 @@
+{
+  "name": "FakeSkyboxTest",
+  "globIgnorePaths": [
+    "**/.package-lock.json",
+    "**/.pnpm",
+    "**/.pnpm-workspace-state-v1.json",
+    "**/.modules.yaml",
+    "**/.ignored",
+    "**/.ignored_*"
+  ],
+  "tree": {
+    "$className": "DataModel",
+    "ServerScriptService": {
+      "$properties": {
+        "LoadStringEnabled": true
+      },
+      "fakeskybox": {
+        "$path": ".."
+      },
+      "Script": {
+        "$path": "scripts/Server"
+      }
+    },
+    "StarterPlayer": {
+      "StarterPlayerScripts": {
+        "Main": {
+          "$path": "scripts/Client"
+        }
+      }
+    }
+  }
+}

package/test/scripts/Client/ClientMain.client.lua

@@ -0,0 +1,235 @@
+--[[
+	@class ClientMain
+]]
+local loader = game:GetService("ReplicatedStorage"):WaitForChild("fakeskybox"):WaitForChild("loader")
+local require = require(loader).bootstrapGame(loader.Parent)
+
+local serviceBag = require("ServiceBag").new()
+serviceBag:GetService(require("FakeSkyboxServiceClient"))
+serviceBag:Init()
+serviceBag:Start()
+
+local Lighting = game:GetService("Lighting")
+local Players = game:GetService("Players")
+local UserInputService = game:GetService("UserInputService")
+
+local Blend = require("Blend")
+local FakeSkybox = require("FakeSkybox")
+local FakeSkyboxRenderMethod = require("FakeSkyboxRenderMethod")
+local Observable = require("Observable")
+local Rx = require("Rx")
+local RxInstanceUtils = require("RxInstanceUtils")
+local RxStateStackUtils = require("RxStateStackUtils")
+
+local function observeSkyboxProperty(property: string): Observable.Observable<any>
+	return RxInstanceUtils.observeChildrenOfClassBrio(Lighting, "Sky")
+		:Pipe({
+			RxStateStackUtils.topOfStack(nil) :: any,
+		})
+		:Pipe({
+			Rx.switchMap(function(sky)
+				if not sky then
+					return Rx.EMPTY
+				end
+
+				return RxInstanceUtils.observeProperty(sky, property)
+			end),
+		})
+end
+
+local skybox = FakeSkybox.new()
+skybox.Gui.Parent = workspace.CurrentCamera
+skybox:SetSpeed(10)
+skybox:Show(true)
+skybox:SetRenderMethod(FakeSkyboxRenderMethod.DECAL)
+
+type Props = {
+	Text: string,
+	OnActivated: () -> (),
+	TextSize: number?,
+}
+local function button(props: Props)
+	return Blend.New "TextButton" {
+		Text = props.Text,
+		AutomaticSize = Enum.AutomaticSize.XY,
+		AutoButtonColor = true,
+		TextColor3 = Color3.new(1, 1, 1),
+		BackgroundColor3 = Color3.new(0, 0, 0),
+		Font = Enum.Font.SourceSansBold,
+		TextSize = props.TextSize or 18,
+
+		[Blend.OnEvent "Activated"] = props.OnActivated,
+
+		Blend.New "UIPadding" {
+			PaddingLeft = UDim.new(0, 8),
+			PaddingRight = UDim.new(0, 8),
+			PaddingTop = UDim.new(0, 8),
+			PaddingBottom = UDim.new(0, 8),
+		},
+
+		Blend.New "UICorner" {
+			CornerRadius = UDim.new(0, 4),
+			Name = "UICorner",
+		},
+	}
+end
+
+local sunsetSky = Blend.State(nil)
+local islandSky = Blend.State(nil)
+
+Blend.mount(Players.LocalPlayer:WaitForChild("PlayerGui"), {
+	Blend.New "ScreenGui" {
+		Name = "TestSkyboxGui",
+		ResetOnSpawn = false,
+		IgnoreGuiInset = true,
+
+		Blend.New "Frame" {
+			AutomaticSize = Enum.AutomaticSize.XY,
+			Position = UDim2.fromScale(0.5, 0.8),
+			AnchorPoint = Vector2.new(0.5, 0.5),
+			BackgroundTransparency = 1,
+
+			Blend.New "UIListLayout" {
+				FillDirection = Enum.FillDirection.Vertical,
+				HorizontalAlignment = Enum.HorizontalAlignment.Center,
+				VerticalAlignment = Enum.VerticalAlignment.Center,
+				Padding = UDim.new(0, 8),
+			},
+
+			button {
+				Text = Blend.Computed(skybox:ObserveVisible(), function(visible)
+					return `Toggle [E] {visible and "Fake Skybox Enabled" or ""}`
+				end),
+				OnActivated = function()
+					skybox:SetVisible(not skybox:IsVisible())
+				end,
+				TextSize = 24,
+			},
+
+			Blend.New "Frame" {
+				AutomaticSize = Enum.AutomaticSize.XY,
+				BackgroundTransparency = 1,
+
+				Blend.New "UIListLayout" {
+					FillDirection = Enum.FillDirection.Horizontal,
+					HorizontalAlignment = Enum.HorizontalAlignment.Center,
+					VerticalAlignment = Enum.VerticalAlignment.Center,
+					Padding = UDim.new(0, 4),
+				},
+
+				button {
+					Text = "Random time of day",
+					OnActivated = function()
+						Lighting.ClockTime = math.random() * 24
+					end,
+				},
+
+				button {
+					Text = "3 AM",
+					OnActivated = function()
+						Lighting.ClockTime = 3
+					end,
+				},
+
+				button {
+					Text = "Afternoon",
+					OnActivated = function()
+						Lighting.ClockTime = 14.5
+					end,
+				},
+
+				button {
+					Text = "Sunset",
+					OnActivated = function()
+						Lighting.ClockTime = 17.9
+					end,
+				},
+
+				button {
+					Text = "Atmosphere off",
+					OnActivated = function()
+						Lighting.Atmosphere.Density = 0
+					end,
+				},
+
+				button {
+					Text = "Atmosphere on",
+					OnActivated = function()
+						Lighting.Atmosphere.Density = 0.3
+					end,
+				},
+			},
+
+			Blend.New "Frame" {
+				AutomaticSize = Enum.AutomaticSize.XY,
+				BackgroundTransparency = 1,
+
+				Blend.New "UIListLayout" {
+					FillDirection = Enum.FillDirection.Horizontal,
+					HorizontalAlignment = Enum.HorizontalAlignment.Center,
+					VerticalAlignment = Enum.VerticalAlignment.Center,
+					Padding = UDim.new(0, 4),
+				},
+
+				button {
+					Text = "Fake Empty baseplate",
+					OnActivated = function()
+						skybox:SetSky(nil)
+					end,
+				},
+
+				button {
+					Text = "Fake Sunset",
+					OnActivated = function()
+						skybox:SetSky(sunsetSky.Value)
+					end,
+				},
+
+				button {
+					Text = "Fake Island",
+					OnActivated = function()
+						skybox:SetSky(islandSky.Value)
+					end,
+				},
+			},
+
+			Blend.New "Sky" {
+				SkyboxBk = "rbxassetid://653719502",
+				SkyboxDn = "rbxassetid://653718790",
+				SkyboxFt = "rbxassetid://653719067",
+				SkyboxLf = "rbxassetid://653719190",
+				SkyboxRt = "rbxassetid://653718931",
+				SkyboxUp = "rbxassetid://653719321",
+				SunTextureId = observeSkyboxProperty("SunTextureId"),
+				MoonTextureId = observeSkyboxProperty("MoonTextureId"),
+				SunAngularSize = observeSkyboxProperty("SunAngularSize"),
+				MoonAngularSize = observeSkyboxProperty("MoonAngularSize"),
+				SkyboxOrientation = observeSkyboxProperty("SkyboxOrientation"),
+				CelestialBodiesShown = observeSkyboxProperty("CelestialBodiesShown"),
+				StarCount = observeSkyboxProperty("StarCount"),
+				[Blend.Instance] = sunsetSky,
+			},
+
+			Blend.New "Sky" {
+				Name = "Island Sky",
+				CelestialBodiesShown = false,
+				SkyboxBk = "http://www.roblox.com/asset/?id=319343577",
+				SkyboxDn = "http://www.roblox.com/asset/?id=319343653",
+				SkyboxFt = "http://www.roblox.com/asset/?id=319343666",
+				SkyboxLf = "http://www.roblox.com/asset/?id=319343686",
+				SkyboxRt = "http://www.roblox.com/asset/?id=319343631",
+				SkyboxUp = "http://www.roblox.com/asset/?id=319343614",
+				StarCount = 500,
+				[Blend.Instance] = islandSky,
+			},
+		},
+	},
+})
+
+skybox:SetSky(sunsetSky.Value)
+
+UserInputService.InputBegan:Connect(function(input)
+	if input.KeyCode == Enum.KeyCode.E then
+		skybox:SetVisible(not skybox:IsVisible())
+	end
+end)

package/test/scripts/Server/ServerMain.server.lua

@@ -0,0 +1,18 @@
+--[[
+	@class ServerMain
+]]
+local ServerScriptService = game:GetService("ServerScriptService")
+
+local root = ServerScriptService.fakeskybox
+local loader = root:FindFirstChild("LoaderUtils", true).Parent
+local require = require(loader).bootstrapGame(root)
+
+local NevermoreTestRunnerUtils = require("NevermoreTestRunnerUtils")
+if NevermoreTestRunnerUtils.runTestsIfNeededAsync(root) then
+	return
+end
+
+local serviceBag = require("ServiceBag").new()
+serviceBag:GetService(require("FakeSkyboxService"))
+serviceBag:Init()
+serviceBag:Start()