@quenty/octree 11.8.1 → 11.8.2

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.8.2](https://github.com/Quenty/NevermoreEngine/compare/@quenty/octree@11.8.1...@quenty/octree@11.8.2) (2025-04-05)
+
+
+### Bug Fixes
+
+* Add types to packages ([2374fb2](https://github.com/Quenty/NevermoreEngine/commit/2374fb2b043cfbe0e9b507b3316eec46a4e353a0))
+
+
+
+
+
 ## [11.8.1](https://github.com/Quenty/NevermoreEngine/compare/@quenty/octree@11.8.0...@quenty/octree@11.8.1) (2025-03-21)
 
 **Note:** Version bump only for package @quenty/octree

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@quenty/octree",
-  "version": "11.8.1",
+  "version": "11.8.2",
   "description": "Octree implementation for Roblox - fast spatial queries",
   "keywords": [
     "Roblox",
@@ -26,11 +26,11 @@
     "Quenty"
   ],
   "dependencies": {
-    "@quenty/draw": "^7.8.1",
-    "@quenty/loader": "^10.8.0"
+    "@quenty/draw": "^7.8.2",
+    "@quenty/loader": "^10.8.1"
   },
   "publishConfig": {
     "access": "public"
   },
-  "gitHead": "6b7c3e15e60cdb185986207b574e2b5591261e7a"
+  "gitHead": "78c3ac0ab08dd18085b6e6e6e4f745e76ed99f68"
 }

package/src/Shared/Octree.lua

@@ -87,10 +87,10 @@ end
 function Octree:GetAllNodes()
 	local options = {}
 
-	for _, regionList in pairs(self._regionHashMap) do
-		for _, region in pairs(regionList) do
-			for node, _ in pairs(region.nodes) do
-				options[#options+1] = node
+	for _, regionList in self._regionHashMap do
+		for _, region in regionList do
+			for node, _ in region.nodes do
+				options[#options + 1] = node
 			end
 		end
 	end
@@ -116,7 +116,7 @@ end
 	@param object T
 	@return OctreeNode<T>
 ]=]
-function Octree:CreateNode(position, object)
+function Octree:CreateNode(position: Vector3, object: any)
 	assert(typeof(position) == "Vector3", "Bad position value")
 	assert(object, "Bad object value")
 
@@ -144,11 +144,11 @@ end
 	@return { T } -- Objects found
 	@return { number } -- Distances squared
 ]=]
-function Octree:RadiusSearch(position, radius)
+function Octree:RadiusSearch(position: Vector3, radius: number)
 	assert(typeof(position) == "Vector3", "Bad position")
 	assert(type(radius) == "number", "Bad radius")
 
-	local px, py, pz = position.x, position.y, position.z
+	local px, py, pz = position.X, position.Y, position.Z
 	return self:_radiusSearch(px, py, pz, radius)
 end
 
@@ -164,18 +164,18 @@ end
 	@return { any } -- Objects found
 	@return { number } -- Distances squared
 ]=]
-function Octree:KNearestNeighborsSearch(position, k, radius)
+function Octree:KNearestNeighborsSearch(position: Vector3, k: number, radius: number)
 	assert(typeof(position) == "Vector3", "Bad position")
 	assert(type(radius) == "number", "Bad radius")
 
-	local px, py, pz = position.x, position.y, position.z
+	local px, py, pz = position.X, position.Y, position.Z
 	local objects, nodeDistances2 = self:_radiusSearch(px, py, pz, radius)
 
 	local sortable = {}
-	for index, dist2 in pairs(nodeDistances2) do
+	for index, dist2 in nodeDistances2 do
 		table.insert(sortable, {
-			dist2 = dist2;
-			index = index;
+			dist2 = dist2,
+			index = index,
 		})
 	end
 
@@ -203,28 +203,36 @@ end
 	@param pz number
 	@return OctreeSubregion
 ]=]
-function Octree:GetOrCreateLowestSubRegion(px, py, pz)
+function Octree:GetOrCreateLowestSubRegion(px: number, py: number, pz: number)
 	local region = self:_getOrCreateRegion(px, py, pz)
 	return OctreeRegionUtils.getOrCreateSubRegionAtDepth(region, px, py, pz, self._maxDepth)
 end
 
-function Octree:_radiusSearch(px, py, pz, radius)
+function Octree:_radiusSearch(px: number, py: number, pz: number, radius: number)
 	local objectsFound = {}
 	local nodeDistances2 = {}
 
 	local diameter = self._maxRegionSize[1]
 	local searchRadiusSquared = OctreeRegionUtils.getSearchRadiusSquared(radius, diameter, EPSILON)
 
-	for _, regionList in pairs(self._regionHashMap) do
-		for _, region in pairs(regionList) do
+	for _, regionList in self._regionHashMap do
+		for _, region in regionList do
 			local rpos = region.position
 			local rpx, rpy, rpz = rpos[1], rpos[2], rpos[3]
 			local ox, oy, oz = px - rpx, py - rpy, pz - rpz
-			local dist2 = ox*ox + oy*oy + oz*oz
+			local dist2 = ox * ox + oy * oy + oz * oz
 
 			if dist2 <= searchRadiusSquared then
 				OctreeRegionUtils.getNeighborsWithinRadius(
-					region, radius, px, py, pz, objectsFound, nodeDistances2, self._maxDepth)
+					region,
+					radius,
+					px,
+					py,
+					pz,
+					objectsFound,
+					nodeDistances2,
+					self._maxDepth
+				)
 			end
 		end
 	end
@@ -232,11 +240,11 @@ function Octree:_radiusSearch(px, py, pz, radius)
 	return objectsFound, nodeDistances2
 end
 
-function Octree:_getRegion(px, py, pz)
+function Octree:_getRegion(px: number, py: number, pz: number)
 	return OctreeRegionUtils.findRegion(self._regionHashMap, self._maxRegionSize, px, py, pz)
 end
 
-function Octree:_getOrCreateRegion(px, py, pz)
+function Octree:_getOrCreateRegion(px: number, py: number, pz: number)
 	return OctreeRegionUtils.getOrCreateRegion(self._regionHashMap, self._maxRegionSize, px, py, pz)
 end
 

package/src/Shared/OctreeRegionUtils.lua

@@ -1,4 +1,5 @@
 --!native
+--!strict
 --[=[
 	Octree implementation utilities. Primarily this utility code
 	should not be used directly and should be considered private to
@@ -14,39 +15,20 @@ local require = require(script.Parent.loader).load(script)
 local Draw = require("Draw")
 
 local EPSILON = 1e-6
-local SQRT_3_OVER_2 = math.sqrt(3)/2
+local SQRT_3_OVER_2 = math.sqrt(3) / 2
 local SUB_REGION_POSITION_OFFSET = {
-	{ 0.25, 0.25, -0.25 };
-	{ -0.25, 0.25, -0.25 };
-	{ 0.25, 0.25, 0.25 };
-	{ -0.25, 0.25, 0.25 };
-	{ 0.25, -0.25, -0.25 };
-	{ -0.25, -0.25, -0.25 };
-	{ 0.25, -0.25, 0.25 };
-	{ -0.25, -0.25, 0.25 };
+	{ 0.25, 0.25, -0.25 },
+	{ -0.25, 0.25, -0.25 },
+	{ 0.25, 0.25, 0.25 },
+	{ -0.25, 0.25, 0.25 },
+	{ 0.25, -0.25, -0.25 },
+	{ -0.25, -0.25, -0.25 },
+	{ 0.25, -0.25, 0.25 },
+	{ -0.25, -0.25, 0.25 },
 }
 
 local OctreeRegionUtils = {}
 
---[=[
-	Visualizes the octree region.
-
-	@param region OctreeRegion<T>
-	@return MaidTask
-]=]
-function OctreeRegionUtils.visualize(region)
-	local size = region.size
-	local position = region.position
-	local sx, sy, sz = size[1], size[2], size[3]
-	local px, py, pz = position[1], position[2], position[3]
-
-	local box = Draw.box(Vector3.new(px, py, pz), Vector3.new(sx, sy, sz))
-	box.Transparency = 0.9
-	box.Name = "OctreeRegion_" .. tostring(region.depth)
-
-	return box
-end
-
 --[=[
 	A Vector3 equivalent for octrees. This type is primarily internal and
 	used for faster access than a Vector3.
@@ -54,6 +36,12 @@ end
 	@type OctreeVector3 { [1]: number, [2]: number, [3]: number }
 	@within OctreeRegionUtils
 ]=]
+export type OctreeVector3 = { number }
+
+export type OctreeNode<T> = {
+	GetRawPosition: (self: OctreeNode<T>) -> (number, number, number),
+	GetObject: (self: OctreeNode<T>) -> T,
+}
 
 --[=[
 	An internal region which stores the data.
@@ -71,6 +59,39 @@ end
 	.node_count number
 	@within OctreeRegionUtils
 ]=]
+export type OctreeRegion<T> = {
+	subRegions: { OctreeRegion<T> },
+	lowerBounds: OctreeVector3,
+	upperBounds: OctreeVector3,
+	position: OctreeVector3,
+	size: OctreeVector3,
+	parent: OctreeRegion<T>?,
+	parentIndex: number?,
+	depth: number,
+	nodes: { [OctreeNode<T>]: OctreeNode<T> },
+	node_count: number,
+}
+
+export type OctreeRegionHashMap<T> = { [number]: { OctreeRegion<T> } }
+
+--[=[
+	Visualizes the octree region.
+
+	@param region OctreeRegion<T>
+	@return MaidTask
+]=]
+function OctreeRegionUtils.visualize<T>(region: OctreeRegion<T>): Instance
+	local size = region.size
+	local position = region.position
+	local sx, sy, sz = size[1], size[2], size[3]
+	local px, py, pz = position[1], position[2], position[3]
+
+	local box = Draw.box(Vector3.new(px, py, pz), Vector3.new(sx, sy, sz))
+	box.Transparency = 0.9
+	box.Name = "OctreeRegion_" .. tostring(region.depth)
+
+	return box
+end
 
 --[=[
 	Creates a new OctreeRegion<T>
@@ -85,8 +106,17 @@ end
 	@param parentIndex number?
 	@return OctreeRegion<T>
 ]=]
-function OctreeRegionUtils.create(px, py, pz, sx, sy, sz, parent, parentIndex)
-	local hsx, hsy, hsz = sx/2, sy/2, sz/2
+function OctreeRegionUtils.create<T>(
+	px: number,
+	py: number,
+	pz: number,
+	sx: number,
+	sy: number,
+	sz: number,
+	parent: OctreeRegion<T>?,
+	parentIndex: number?
+): OctreeRegion<T>
+	local hsx, hsy, hsz = sx / 2, sy / 2, sz / 2
 
 	local region = {
 		subRegions = {
@@ -98,16 +128,16 @@ function OctreeRegionUtils.create(px, py, pz, sx, sy, sz, parent, parentIndex)
 			--bottomNorthWest
 			--bottomSouthEast
 			--bottomSouthWest
-		};
-		lowerBounds = { px - hsx, py - hsy, pz - hsz };
-		upperBounds = { px + hsx, py + hsy, pz + hsz };
-		position = { px, py, pz };
-		size = { sx, sy, sz }; -- { sx, sy, sz }
-		parent = parent;
-		depth = parent and (parent.depth + 1) or 1;
-		parentIndex = parentIndex;
-		nodes = {}; -- [node] = true (contains subchild nodes too)
-		node_count = 0;
+		},
+		lowerBounds = { px - hsx, py - hsy, pz - hsz },
+		upperBounds = { px + hsx, py + hsy, pz + hsz },
+		position = { px, py, pz },
+		size = { sx, sy, sz }, -- { sx, sy, sz }
+		parent = parent,
+		depth = parent and (parent.depth + 1) or 1,
+		parentIndex = parentIndex,
+		nodes = {}, -- [node] = true (contains subchild nodes too)
+		node_count = 0,
 	}
 
 	-- if region.depth >= 5 then
@@ -122,16 +152,16 @@ end
 	@param lowestSubregion OctreeRegion<T>
 	@param node OctreeNode
 ]=]
-function OctreeRegionUtils.addNode(lowestSubregion, node)
+function OctreeRegionUtils.addNode<T>(lowestSubregion: OctreeRegion<T>, node: OctreeNode<T>)
 	assert(node, "Bad node")
 
-	local current = lowestSubregion
+	local current: OctreeRegion<T> = lowestSubregion
 	while current do
 		if not current.nodes[node] then
-			current.nodes[node] = node
+			current.nodes[node] = node :: OctreeNode<T>
 			current.node_count = current.node_count + 1
 		end
-		current = current.parent
+		current = current.parent :: OctreeRegion<T>
 	end
 end
 
@@ -142,12 +172,12 @@ end
 	@param toLowest OctreeRegion<T>
 	@param node OctreeNode
 ]=]
-function OctreeRegionUtils.moveNode(fromLowest, toLowest, node)
+function OctreeRegionUtils.moveNode<T>(fromLowest: OctreeRegion<T>, toLowest: OctreeRegion<T>, node: OctreeNode<T>)
 	assert(fromLowest.depth == toLowest.depth, "fromLowest.depth ~= toLowest.depth")
 	assert(fromLowest ~= toLowest, "fromLowest == toLowest")
 
-	local currentFrom = fromLowest
-	local currentTo = toLowest
+	local currentFrom: OctreeRegion<T> = fromLowest
+	local currentTo: OctreeRegion<T> = toLowest
 	while currentFrom ~= currentTo do
 		-- remove from current
 		do
@@ -155,13 +185,14 @@ function OctreeRegionUtils.moveNode(fromLowest, toLowest, node)
 			assert(currentFrom.node_count > 0, "No nodes in currentFrom")
 
 			currentFrom.nodes[node] = nil
-			currentFrom.node_count = currentFrom.node_count - 1
+			currentFrom.node_count -= 1
 
 			-- remove subregion!
-			if currentFrom.node_count <= 0 and currentFrom.parentIndex then
+			local parentIndex = currentFrom.parentIndex
+			if currentFrom.node_count <= 0 and parentIndex then
 				assert(currentFrom.parent, "Bad currentFrom.parent")
-				assert(currentFrom.parent.subRegions[currentFrom.parentIndex] == currentFrom, "Not in subregion")
-				currentFrom.parent.subRegions[currentFrom.parentIndex] = nil
+				assert(currentFrom.parent.subRegions[parentIndex] == currentFrom, "Not in subregion")
+				currentFrom.parent.subRegions[parentIndex] = nil
 			end
 		end
 
@@ -172,8 +203,8 @@ function OctreeRegionUtils.moveNode(fromLowest, toLowest, node)
 			currentTo.node_count = currentTo.node_count + 1
 		end
 
-		currentFrom = currentFrom.parent
-		currentTo = currentTo.parent
+		currentFrom = currentFrom.parent :: OctreeRegion<T>
+		currentTo = currentTo.parent :: OctreeRegion<T>
 	end
 end
 
@@ -183,29 +214,29 @@ end
 	@param lowestSubregion OctreeRegion<T>
 	@param node OctreeNode
 ]=]
-function OctreeRegionUtils.removeNode(lowestSubregion, node)
+function OctreeRegionUtils.removeNode<T>(lowestSubregion: OctreeRegion<T>, node: OctreeNode<T>)
 	assert(node, "Bad node")
 
-	local current = lowestSubregion
+	local current: OctreeRegion<T> = lowestSubregion
 	while current do
 		assert(current.nodes[node], "Not in current")
 		assert(current.node_count > 0, "Current has bad node count")
 
 		current.nodes[node] = nil
-		current.node_count = current.node_count - 1
+		current.node_count -= 1
 
 		-- remove subregion!
-		if current.node_count <= 0 and current.parentIndex then
+		local parentIndex = current.parentIndex
+		if current.node_count <= 0 and parentIndex then
 			assert(current.parent, "No parent")
-			assert(current.parent.subRegions[current.parentIndex] == current, "Not in subregion")
-			current.parent.subRegions[current.parentIndex] = nil
+			assert(current.parent.subRegions[parentIndex] == current, "Not in subregion")
+			current.parent.subRegions[parentIndex] = nil
 		end
 
-		current = current.parent
+		current = current.parent :: OctreeRegion<T>
 	end
 end
 
-
 --[=[
 	Retrieves the search radius for a given radius given the region
 	diameter
@@ -215,10 +246,10 @@ end
 	@param epsilon number
 	@return number
 ]=]
-function OctreeRegionUtils.getSearchRadiusSquared(radius, diameter, epsilon)
-	local diagonal = SQRT_3_OVER_2*diameter
+function OctreeRegionUtils.getSearchRadiusSquared(radius: number, diameter: number, epsilon: number): number
+	local diagonal = SQRT_3_OVER_2 * diameter
 	local searchRadius = radius + diagonal
-	return searchRadius*searchRadius + epsilon
+	return searchRadius * searchRadius + epsilon
 end
 
 -- luacheck: push ignore
@@ -237,30 +268,39 @@ end
 	@param nodeDistances2 { number }
 	@param maxDepth number
 ]=]
-function OctreeRegionUtils.getNeighborsWithinRadius(region, radius, px, py, pz, objectsFound, nodeDistances2, maxDepth)
--- luacheck: pop
+function OctreeRegionUtils.getNeighborsWithinRadius<T>(
+	region: OctreeRegion<T>,
+	radius: number,
+	px: number,
+	py: number,
+	pz: number,
+	objectsFound: { T },
+	nodeDistances2: { number },
+	maxDepth: number
+)
+	-- luacheck: pop
 	assert(maxDepth, "Bad maxDepth")
 
-	local childDiameter = region.size[1]/2
+	local childDiameter = region.size[1] / 2
 	local searchRadiusSquared = OctreeRegionUtils.getSearchRadiusSquared(radius, childDiameter, EPSILON)
 
-	local radiusSquared = radius*radius
+	local radiusSquared = radius * radius
 
 	-- for each child
-	for _, childRegion in pairs(region.subRegions) do
+	for _, childRegion in region.subRegions do
 		local cposition = childRegion.position
 		local cpx, cpy, cpz = cposition[1], cposition[2], cposition[3]
 
 		local ox, oy, oz = px - cpx, py - cpy, pz - cpz
-		local dist2 = ox*ox + oy*oy + oz*oz
+		local dist2 = ox * ox + oy * oy + oz * oz
 
 		-- within search radius
 		if dist2 <= searchRadiusSquared then
 			if childRegion.depth == maxDepth then
-				for node, _ in pairs(childRegion.nodes) do
+				for node, _ in childRegion.nodes do
 					local npx, npy, npz = node:GetRawPosition()
 					local nox, noy, noz = px - npx, py - npy, pz - npz
-					local ndist2 = nox*nox + noy*noy + noz*noz
+					local ndist2 = nox * nox + noy * noy + noz * noz
 					if ndist2 <= radiusSquared then
 						objectsFound[#objectsFound + 1] = node:GetObject()
 						nodeDistances2[#nodeDistances2 + 1] = ndist2
@@ -268,7 +308,15 @@ function OctreeRegionUtils.getNeighborsWithinRadius(region, radius, px, py, pz,
 				end
 			else
 				OctreeRegionUtils.getNeighborsWithinRadius(
-					childRegion, radius, px, py, pz, objectsFound, nodeDistances2, maxDepth)
+					childRegion,
+					radius,
+					px,
+					py,
+					pz,
+					objectsFound,
+					nodeDistances2,
+					maxDepth
+				)
 			end
 		end
 	end
@@ -285,7 +333,13 @@ end
 	@param maxDepth number
 	@return OctreeRegion<T>
 ]=]
-function OctreeRegionUtils.getOrCreateSubRegionAtDepth(region, px, py, pz, maxDepth)
+function OctreeRegionUtils.getOrCreateSubRegionAtDepth<T>(
+	region: OctreeRegion<T>,
+	px: number,
+	py: number,
+	pz: number,
+	maxDepth: number
+): OctreeRegion<T>
 	local current = region
 	for _ = region.depth, maxDepth do
 		local index = OctreeRegionUtils.getSubRegionIndex(current, px, py, pz)
@@ -309,15 +363,15 @@ end
 	@param parentIndex number
 	@return OctreeRegion<T>
 ]=]
-function OctreeRegionUtils.createSubRegion(parentRegion, parentIndex)
+function OctreeRegionUtils.createSubRegion<T>(parentRegion: OctreeRegion<T>, parentIndex: number): OctreeRegion<T>
 	local size = parentRegion.size
 	local position = parentRegion.position
 	local multiplier = SUB_REGION_POSITION_OFFSET[parentIndex]
 
-	local px = position[1] + multiplier[1]*size[1]
-	local py = position[2] + multiplier[2]*size[2]
-	local pz = position[3] + multiplier[3]*size[3]
-	local sx, sy, sz = size[1]/2, size[2]/2, size[3]/2
+	local px = position[1] + multiplier[1] * size[1]
+	local py = position[2] + multiplier[2] * size[2]
+	local pz = position[3] + multiplier[3] * size[3]
+	local sx, sy, sz = size[1] / 2, size[2] / 2, size[3] / 2
 
 	return OctreeRegionUtils.create(px, py, pz, sx, sy, sz, parentRegion, parentIndex)
 end
@@ -333,13 +387,16 @@ end
 	@param pz number
 	@return boolean
 ]=]
-function OctreeRegionUtils.inRegionBounds(region, px, py, pz)
+function OctreeRegionUtils.inRegionBounds<T>(region: OctreeRegion<T>, px: number, py: number, pz: number): boolean
 	local lowerBounds = region.lowerBounds
 	local upperBounds = region.upperBounds
 	return (
-		px >= lowerBounds[1] and px <= upperBounds[1] and
-		py >= lowerBounds[2] and py <= upperBounds[2] and
-		pz >= lowerBounds[3] and pz <= upperBounds[3]
+		px >= lowerBounds[1]
+		and px <= upperBounds[1]
+		and py >= lowerBounds[2]
+		and py <= upperBounds[2]
+		and pz >= lowerBounds[3]
+		and pz <= upperBounds[3]
 	)
 end
 
@@ -352,7 +409,7 @@ end
 	@param pz number
 	@return number
 ]=]
-function OctreeRegionUtils.getSubRegionIndex(region, px, py, pz)
+function OctreeRegionUtils.getSubRegionIndex<T>(region: OctreeRegion<T>, px: number, py: number, pz: number): number
 	local index = px > region.position[1] and 1 or 2
 	if py <= region.position[2] then
 		index = index + 4
@@ -374,9 +431,9 @@ end
 	@param cz number
 	@return number
 ]=]
-function OctreeRegionUtils.getTopLevelRegionHash(cx, cy, cz)
+function OctreeRegionUtils.getTopLevelRegionHash(cx: number, cy: number, cz: number): number
 	-- Normally you would modulus this to hash table size, but we want as flat of a structure as possible
-	return cx * 73856093 + cy*19351301 + cz*83492791
+	return cx * 73856093 + cy * 19351301 + cz * 83492791
 end
 
 --[=[
@@ -390,7 +447,12 @@ end
 	@return number -- rpy
 	@return number -- rpz
 ]=]
-function OctreeRegionUtils.getTopLevelRegionCellIndex(maxRegionSize, px, py, pz)
+function OctreeRegionUtils.getTopLevelRegionCellIndex(
+	maxRegionSize: OctreeVector3,
+	px: number,
+	py: number,
+	pz: number
+): (number, number, number)
 	return math.floor(px / maxRegionSize[1] + 0.5),
 		math.floor(py / maxRegionSize[2] + 0.5),
 		math.floor(pz / maxRegionSize[3] + 0.5)
@@ -407,10 +469,13 @@ end
 	@return number
 	@return number
 ]=]
-function OctreeRegionUtils.getTopLevelRegionPosition(maxRegionSize, cx, cy, cz)
-	return maxRegionSize[1] * cx,
-		maxRegionSize[2] * cy,
-		maxRegionSize[3] * cz
+function OctreeRegionUtils.getTopLevelRegionPosition(
+	maxRegionSize: OctreeVector3,
+	cx: number,
+	cy: number,
+	cz: number
+): (number, number, number)
+	return maxRegionSize[1] * cx, maxRegionSize[2] * cy, maxRegionSize[3] * cz
 end
 
 --[=[
@@ -423,11 +488,9 @@ end
 	@param rpz number
 	@return boolean
 ]=]
-function OctreeRegionUtils.areEqualTopRegions(region, rpx, rpy, rpz)
+function OctreeRegionUtils.areEqualTopRegions<T>(region: OctreeRegion<T>, rpx: number, rpy: number, rpz: number)
 	local position = region.position
-	return position[1] == rpx
-		and position[2] == rpy
-		and position[3] == rpz
+	return position[1] == rpx and position[2] == rpy and position[3] == rpz
 end
 
 --[=[
@@ -440,17 +503,23 @@ end
 	@param pz number
 	@return OctreeRegion3?
 ]=]
-function OctreeRegionUtils.findRegion(regionHashMap, maxRegionSize, px, py, pz)
+function OctreeRegionUtils.findRegion<T>(
+	regionHashMap: OctreeRegionHashMap<T>,
+	maxRegionSize: OctreeVector3,
+	px: number,
+	py: number,
+	pz: number
+): OctreeRegion<T>?
 	local cx, cy, cz = OctreeRegionUtils.getTopLevelRegionCellIndex(maxRegionSize, px, py, pz)
 	local hash = OctreeRegionUtils.getTopLevelRegionHash(cx, cy, cz)
 
-	local regionList = regionHashMap[hash]
+	local regionList: { OctreeRegion<T> } = regionHashMap[hash]
 	if not regionList then
 		return nil
 	end
 
 	local rpx, rpy, rpz = OctreeRegionUtils.getTopLevelRegionPosition(maxRegionSize, cx, cy, cz)
-	for _, region in pairs(regionList) do
+	for _, region in regionList do
 		if OctreeRegionUtils.areEqualTopRegions(region, rpx, rpy, rpz) then
 			return region
 		end
@@ -469,7 +538,7 @@ end
 	@param pz number
 	@return OctreeRegion<T>
 ]=]
-function OctreeRegionUtils.getOrCreateRegion(regionHashMap, maxRegionSize, px, py, pz)
+function OctreeRegionUtils.getOrCreateRegion<T>(regionHashMap: OctreeRegionHashMap<T>, maxRegionSize: OctreeVector3, px: number, py: never, pz: number): OctreeRegion<T>
 	local cx, cy, cz = OctreeRegionUtils.getTopLevelRegionCellIndex(maxRegionSize, px, py, pz)
 	local hash = OctreeRegionUtils.getTopLevelRegionHash(cx, cy, cz)
 
@@ -480,7 +549,7 @@ function OctreeRegionUtils.getOrCreateRegion(regionHashMap, maxRegionSize, px, p
 	end
 
 	local rpx, rpy, rpz = OctreeRegionUtils.getTopLevelRegionPosition(maxRegionSize, cx, cy, cz)
-	for _, region in pairs(regionList) do
+	for _, region in regionList do
 		if OctreeRegionUtils.areEqualTopRegions(region, rpx, rpy, rpz) then
 			return region
 		end