@rbxts/planck 0.1.3-rc.4 → 0.2.0

package/out/DependencyGraph.luau

@@ -0,0 +1,180 @@
+local AdjacencyMatrix = {}
+AdjacencyMatrix.__index = AdjacencyMatrix
+
+function AdjacencyMatrix:__tostring()
+	local s = "\n"
+
+	for i = 1, self.length do
+		if i == 1 then
+			s ..= "\n"
+		end
+
+		local sub = ""
+		for j = 1, self.width do
+			if j == self.width then
+				sub ..= `{self.matrix[i][j]}`
+				continue
+			end
+
+			sub ..= `{self.matrix[i][j]}, `
+		end
+
+		sub ..= "\n"
+		s ..= sub
+	end
+
+	return s
+end
+
+function AdjacencyMatrix:extend()
+	self.length = (self.length :: number) + 1
+	self.width = (self.length :: number) + 1
+
+	self.matrix[self.length] = {}
+	for j = 1, self.width do
+		self.matrix[self.length][j] = 0
+	end
+
+	for i = 1, self.length do
+		self.matrix[i][self.width] = 0
+	end
+end
+
+function AdjacencyMatrix:setEdge(i, j, val)
+	self.matrix[i][j] = val
+end
+
+function AdjacencyMatrix:toAdjacencyList()
+	local list = {}
+
+	for i = 1, self.length do
+		list[i] = {}
+		for j = 1, self.width do
+			if self.matrix[i][j] ~= 0 then
+				table.insert(list[i], j)
+			end
+		end
+	end
+
+	return list
+end
+
+function AdjacencyMatrix:topologicalSort(): { number }?
+	local adjacencyList = self:toAdjacencyList()
+
+	local result = {}
+	local inDegrees = table.create(self.length, 0)
+
+	for i = 1, self.length do
+		for _, j in adjacencyList[i] do
+			inDegrees[j] += 1
+		end
+	end
+
+	local queue = {}
+	for i = 1, self.length do
+		if inDegrees[i] == 0 then
+			table.insert(queue, i)
+		end
+	end
+
+	while #queue ~= 0 do
+		local i = table.remove(queue, 1) :: number
+		table.insert(result, i)
+
+		for _, j in adjacencyList[i] do
+			inDegrees[j] -= 1
+			if inDegrees[j] == 0 then
+				table.insert(queue, j)
+			end
+		end
+	end
+
+	if #result ~= self.length then
+		return nil
+	end
+
+	return result
+end
+
+function AdjacencyMatrix.new()
+	return setmetatable({
+		matrix = {},
+		length = 0,
+		width = 0,
+	}, AdjacencyMatrix)
+end
+
+local DependencyGraph = {}
+DependencyGraph.__index = DependencyGraph
+
+function DependencyGraph:getOrderedList(): { any }?
+	local orderedList = {}
+
+	local topologicalSort = self.matrix:topologicalSort()
+	if not topologicalSort then
+		return nil
+	end
+
+	for _, i in topologicalSort do
+		table.insert(orderedList, self.nodes[i])
+	end
+
+	return orderedList
+end
+
+function DependencyGraph:insertBefore(node, beforeNode)
+	if not table.find(self.nodes, beforeNode) then
+		error("Node not found in DependencyGraph:insertBefore(_, unknown)")
+	end
+
+	table.insert(self.nodes, node)
+	local j = #self.nodes
+	local i = table.find(self.nodes, beforeNode)
+
+	self.matrix:extend()
+	self.matrix:setEdge(j, i, 1)
+
+	return self
+end
+
+function DependencyGraph:insertAfter(node, afterNode)
+	if not table.find(self.nodes, afterNode) then
+		error("Node not found in DependencyGraph:insertAfter(_, unknown)")
+	end
+
+	table.insert(self.nodes, node)
+
+	local j = #self.nodes
+	local i = table.find(self.nodes, afterNode)
+
+	self.matrix:extend()
+	self.matrix:setEdge(i, j, 1)
+
+	return self
+end
+
+function DependencyGraph:insert(node)
+	local i = #self.nodes
+	table.insert(self.nodes, node)
+	local j = #self.nodes
+
+	self.matrix:extend()
+
+	if i ~= 0 then
+		self.matrix:setEdge(i, j, 1)
+	end
+
+	return self
+end
+
+function DependencyGraph.new()
+	return setmetatable({
+		nodes = {},
+		matrix = AdjacencyMatrix.new(),
+		length = 0,
+		width = 0,
+	}, DependencyGraph)
+end
+
+return DependencyGraph

package/out/Phase.d.ts

@@ -3,15 +3,6 @@ declare class Phase {
     static readonly PreStartup: Phase
     static readonly Startup: Phase
     static readonly PostStartup: Phase
-    static readonly PreRender: Phase
-    static readonly PreAnimation: Phase
-    static readonly PreSimulation: Phase
-    static readonly PostSimulation: Phase
-    static readonly First: Phase
-    static readonly PreUpdate: Phase
-    static readonly Update: Phase
-    static readonly PostUpdate: Phase
-    static readonly Last: Phase
 }
 
 export = Phase;

package/out/Phase.luau

@@ -38,52 +38,4 @@ Phase.PreStartup = Phase.new("PreStartup")
 Phase.Startup = Phase.new("Startup")
 Phase.PostStartup = Phase.new("PostStartup")
 
---- @prop PreRender Phase
---- @within Phase
---- Runs on the `RunService.PreRender` Event.
-
---- @prop PreAnimation Phase
---- @within Phase
---- Runs on the `RunService.PreAnimation` Event.
-
---- @prop PreSimulation Phase
---- @within Phase
---- Runs on the `RunService.PreSimulation` Event.
-
---- @prop PostSimulation Phase
---- @within Phase
---- Runs on the `RunService.PostSimulation` Event.
-
-Phase.PreRender = Phase.new("PreRender")
-Phase.PreAnimation = Phase.new("PreAnimation")
-Phase.PreSimulation = Phase.new("PreSimulation")
-Phase.PostSimulation = Phase.new("PostSimulation")
-
---- @prop First Phase
---- @within Phase
---- Will always run first on the `RunService.Heartbeat` Event.
-
---- @prop PreUpdate Phase
---- @within Phase
---- Runs before the `Update` Phase.
-
---- @prop Update Phase
---- @within Phase
---- Runs on the `RunService.Heartbeat` Event.
---- This is the default Phase systems will run on.
-
---- @prop PostUpdate Phase
---- @within Phase
---- Runs after the `Update` Phase.
-
---- @prop Last Phase
---- @within Phase
---- Will always run last on the `RunService.Heartbeat` Event.
-
-Phase.First = Phase.new("First")
-Phase.PreUpdate = Phase.new("PreUpdate")
-Phase.Update = Phase.new("Update")
-Phase.PostUpdate = Phase.new("PostUpdate")
-Phase.Last = Phase.new("Last")
-
-return Phase
+return Phase

package/out/Pipeline.d.ts

@@ -4,7 +4,7 @@ declare class Pipeline {
     constructor(debugName?: string)
     insert(phase: Phase) : Pipeline
     insertAfter(phase: Phase, after: Phase): Pipeline
-    static readonly Main: Pipeline
+    insertBefore(phase: Phase, before: Phase): Pipeline
     static readonly Startup: Pipeline
 }
 

package/out/Pipeline.luau

@@ -1,10 +1,12 @@
-local Phase = require(script.Parent:WaitForChild('Phase'))
+--!nonstrict
+local DependencyGraph = require("./DependencyGraph")
+local Phase = require("./Phase")
+
 --- @class Pipeline
 ---
 --- Pipelines represent a set of ordered Phases. Systems cannot be
 --- assigned to Pipelines themselves, but rather to Phases within
 --- those Pipelines.
-
 local Pipeline = {}
 Pipeline.__index = Pipeline
 
@@ -19,22 +21,43 @@ end
 ---
 --- Adds a Phase to the Pipeline, ordering it implicitly.
 function Pipeline:insert(phase)
-	table.insert(self._phases, phase)
+	self.dependencyGraph:insert(phase)
 	return self
 end
 
---- @method insert
+--- @method insertAfter
 --- @within Pipeline
 --- @param phase Phase
 --- @param after Phase
 --- @return Pipeline
 ---
 --- Adds a Phase to the Pipeline after another Phase, ordering it explicitly.
-function Pipeline:insertAfter(phase, otherPhase)
-	local i = table.find(self._phases, phase)
-	assert(i, "Phase not initialized in Pipeline")
+function Pipeline:insertAfter(phase, afterPhase)
+	local i = table.find(self.dependencyGraph.nodes, afterPhase)
+	assert(
+		i,
+		"Unknown Phase in Pipeline:insertAfter(_, unknown), try adding this Phase to the Pipeline."
+	)
+
+	self.dependencyGraph:insertAfter(phase, afterPhase)
+	return self
+end
+
+--- @method insertBefore
+--- @within Pipeline
+--- @param phase Phase
+--- @param before Phase
+--- @return Pipeline
+---
+--- Adds a Phase to the Pipeline before another Phase, ordering it explicitly.
+function Pipeline:insertBefore(phase, beforePhase)
+	local i = table.find(self.dependencyGraph.nodes, beforePhase)
+	assert(
+		i,
+		"Unknown Phase in Pipeline:insertBefore(_, unknown), try adding this Phase to the Pipeline."
+	)
 
-	table.insert(self._phases, i + 1, otherPhase)
+	self.dependencyGraph:insertBefore(phase, beforePhase)
 	return self
 end
 
@@ -47,7 +70,7 @@ function Pipeline.new(name: string?)
 	return setmetatable({
 		_name = name,
 		_type = "pipeline",
-		_phases = {},
+		dependencyGraph = DependencyGraph.new(),
 	}, Pipeline)
 end
 
@@ -60,15 +83,4 @@ Pipeline.Startup = Pipeline.new()
 	:insert(Phase.Startup)
 	:insert(Phase.PostStartup)
 
---- @prop Main Pipeline
---- @within Pipeline
----
---- A Pipeline containing the `First`, `PreUpdate`, `Update`, `PostUpdate`, and `Last` phases.
-Pipeline.Main = Pipeline.new()
-	:insert(Phase.First)
-	:insert(Phase.PreUpdate)
-	:insert(Phase.Update)
-	:insert(Phase.PostUpdate)
-	:insert(Phase.Last)
-
-return Pipeline
+return Pipeline

package/out/Scheduler.d.ts

@@ -6,25 +6,22 @@ declare class Scheduler<T extends unknown[]> {
     /** @hidden */
     _orderedPhases: Phase[]
     Hooks: Hooks["Hooks"]
-    insertAfter(phase: Phase, after: Phase | Pipeline): Scheduler<T>
-    insertAfter(pipeline: Pipeline, after: Phase | Pipeline): Scheduler<T>
-    insert(phase: Phase): Scheduler<T>
-    insert(phase: Pipeline): Scheduler<T>
-    getDeltaTime(): number
-    insert(phase: Phase, instance: EventInstance | EventLike): Scheduler<T>
-    insert(pipeline: Pipeline, instance: EventInstance | EventLike): Scheduler<T>
-    runAll(): Scheduler<T>
-    run(system: System<T>): Scheduler<T>
-    run(phase: Phase): Scheduler<T>
-    run(pipeline: Pipeline): Scheduler<T>
-    setRunCondition(system: System<T>, fn: (...args: T) => boolean): Scheduler<T>
-    setRunCondition(phase: Phase, fn: (...args: T) => boolean): Scheduler<T>
-    setRunCondition(pipeline: Pipeline, fn: (...args: T) => boolean): Scheduler<T>
-    removeSystem(system: System<T>): Scheduler<T>
+    cleanup(): void
+    addRunCondition(dependent: System<T>, fn: (...args: T) => boolean): Scheduler<T>
     replaceSystem(oldSystem: System<T>, newSystem: System<T>): Scheduler<T>
+    removeSystem(system: System<T>): Scheduler<T>
     editSystem(system: System<T>, phase: Phase): Scheduler<T>
     addSystem(system: System<T>, phase?: Phase): Scheduler<T>
-    addSystems(...systems: System<T>[]): Scheduler<T>
+    addSystems(systems: System<T>[], phase?: Phase): Scheduler<T>
+    insertBefore(dependent: Phase, before: Phase): Scheduler<T>
+    insertBefore(dependent: Pipeline, before: Phase): Scheduler<T>
+    insertAfter(phase: Phase, after: Phase | Pipeline): Scheduler<T>
+    insertAfter(pipeline: Pipeline, after: Phase | Pipeline): Scheduler<T>
+    insert(dependent: Phase | Pipeline, instance: EventInstance | EventLike, event?: string | EventLike): Scheduler<T>
+    insert(dependent: Phase | Pipeline): Scheduler<T>
+    runAll(): Scheduler<T>
+    run(dependent: System<T> | Phase | Pipeline): Scheduler<T>
+    getDeltaTime(): number
     addPlugin(plugin: Plugin): Scheduler<T>
     /** @hidden */
     _addHook<K extends keyof HookFunctionMap>(hook: K, fn: (info: HookFunctionArgs<K, T>) => void): void