EasyPool - a simple to use system meant to make object pooling easy

Resources Community Resources
#1

Hi everyone! I recently made a module for object pooling system, and I wanted to share it

Why Use Object Pooling?

Object pooling helps improve performance by reusing instances instead of constantly creating and destroying them. This is especially useful for:

  • Custom particle systems
  • Projectiles & bullets
  • Sound effects
  • Other frequently spawned objects

Instead of calling Instance:Clone() every time you need an object, you can pull from a pre-allocated pool.

Since objects aren’t destroyed and created anew all the time, it will help prevent memory leaks associated with connecting to events, such as .Changed

How to use it?

Get started by requiring the module, and simply create an object pool with

local Pool = ObjectPoolingModule.new(Count,Instance)

This creates an object pool size of Count filled with clones of Instance

Parameters

The .new() function also accepts parameters, that affect how the object pool acts, the parameters are passed in a table like

local Pool = ObjectPoolingModule.new(Count,Instance,{Parameter = State})

Available parameters include:

  • LiveReusing:boolean -- false by default - whether or not objects that have already been loaded should be reused. If enabled, this will take the object that has been loaded for the longest time
  • LoadWait:number -- 0 by default – how many heartbeats should the .new() function wait between the addition of each instance to the pool
  • AutoExpand:boolean -- false by default - should the table automatically expand itself if it runs out of available instances. Requires Instance be passed during the .new() function
  • MaxPoolSize:number -- math.huge by default – if the table automatically expands, at what point should it stop expanding
  • UnloadTimer:number -- -1 by default – how many seconds should the instances wait after being loaded, before being unloaded automatically. Anything below 0 disables this functionality

Loading objects

To load an object into the game, simply do

local Item = Pool:LoadItem(Parent?) -- optionally sets the parent of the item, if none is provided, sets the parent to Workspace
-- IMPORTANT, the 'Item' object returned is a custom class, to refer to the Instance within the class itself, use Item.Instance

Then, the item can be unloaded again with

Item:Unload()

Events

This module comes with events you can track to make utilisation easier

-- The pool has events like
Pool.ItemLoaded:Connect(function(item)
-- when an item is loaded via :LoadItem(), this event fires and passes the item that has been loaded
end)
Pool.ItemUnloaded:Connect(function(item)
-- when an item is unloaded, this event fires and passes the item that has been unloaded
end)

Item Events

-- Items themselves have events like
Item.Unloaded:Connect(function()
-- fires AFTER the item has been unloaded from the game
end)
Item.Loaded:Connect(function()
-- fires when an item is loaded into the game
end)
Item.OnUnloading:Connect(function()
-- fires BEFORE an item is unloaded, yields for 1.5 seconds if any functions are attached to this event
-- useful if you wanna, for example, tween an object's size to 0,0,0 before its unloaded
end)

That & much much more available in this module. Reading the documentation is recommended

How I use it

Here’s a snippet of code from a custom particle system I have made, this shows how you can utilise the pooling system efficiently

for _,Obj in pairs(BloodPool:GetAll()) do
	local Particle = Obj.Instance :: BasePart
	
	local Con : RBXScriptConnection
	
	Obj.Loaded:Connect(function()
		local Size = math.random(80,140)/100
		Particle.Size = Vector3.new(.1,.1,Size)
		
		local DefaultPos = game.Workspace.Folder:GetChildren()[math.random(1,#game.Workspace.Folder:GetChildren())].CFrame
		
		Particle.CFrame = CFrame.new(DefaultPos.Position,DefaultPos.Position + DefaultPos.LookVector)*CFrame.Angles(math.rad(math.random(-40,40)),math.rad(math.random(-40,40)),0)
		
		local P = Particle.Position
		local V = 7
		local G = Vector3.new(0,-workspace.Gravity/22,0)
		local D = Particle.CFrame.LookVector * 6
		local T = 0
		
		Con = game:GetService("RunService").Heartbeat:Connect(function(dt)
			T += dt * V
			
			local Pos = PositionCalc(P,D,G,T)
			Particle.CFrame = CFrame.new(Particle.Position,Pos)
			Particle.Position = Pos
		end)
	end)
	
	Obj.Unloaded:Connect(function()
		if Con then
			Con:Disconnect()
		end
	end)
end

Install

GitHub | Roblox Asset | Documentation

I hope you find this module useful in your next project! I’m happy to answer any questions and take suggestions!

8 Likes
#2

Omg this module fixed my marriage!

After a quick try:

  • Simple usability
  • Good performance

Object Pooling!

2 Likes