Occlusion Culling Universal

 RunService = :()
 Players = :()
 player = Players.LocalPlayer
 camera = .CurrentCamera

 CONFIG = {
	UpdateInterval = ,
	MaxDistance = ,
	NearDistance = ,
	FOVAngle = ,
	MinSize = ,
	MaxObjectsPerFrame = ,
	MaxTotalObjects = ,
	RegisterDelay = ,
}

 trackedObjects = {}
 objectLookup = {}
 lastUpdate = 
 currentIndex = 
 isRegistering = 

 excludedClasses = {
	, , , , , ,
	, , , , , 
}

 excludedNames = {
	[] = ,
	[] = ,
}

  (obj)
	  obj:()    
	
	 _, class  (excludedClasses) 
		 obj:(class)    
	
	
	 excludedNames[obj.Name]    
	 obj.Transparency >=     
	 obj.Size.Magnitude < CONFIG.MinSize    
	
	 model = obj:()
	 model 
		 Players:(model)    
		 model:()    
	
	
	 


  (obj)
	 (obj)   
	 objectLookup[obj]   
	 #trackedObjects >= CONFIG.MaxTotalObjects   
	
	 tracked = {
		obj = obj,
		origTrans = obj.Transparency,
		origColl = obj.CanCollide,
		visible = ,
	}
	
	.(trackedObjects, tracked)
	objectLookup[obj] = tracked


  (objPos, camPos, camLook)
	 toObject = (objPos - camPos)
	 distance = toObject.Magnitude
	 distance <     
	
	toObject = toObject.Unit
	 dot = camLook:(toObject)
	
	 dot > 


  (tracked, visible)
	  tracked   tracked.obj   tracked.obj.Parent   
	 tracked.visible == visible   
	
	 obj = tracked.obj
	
	 success = (()
		 visible 
			obj.Transparency = tracked.origTrans
			obj.CanCollide = tracked.origColl
		
			obj.Transparency = 
			obj.CanCollide = 
		
	)
	
	 success 
		tracked.visible = visible
	


  ()
	  camera   camera.Parent   
	
	 camPos = camera.CFrame.Position
	 camLook = camera.CFrame.LookVector
	
	 totalObjects = #trackedObjects
	 totalObjects ==    
	
	 i = , CONFIG.MaxObjectsPerFrame 
		 currentIndex > totalObjects 
			currentIndex = 
			
		
		
		 tracked = trackedObjects[currentIndex]
		
		 tracked  tracked.obj  tracked.obj.Parent 
			 objPos = tracked.obj.Position
			 distance = (camPos - objPos).Magnitude
			
			 shouldBeVisible = distance <= CONFIG.MaxDistance
			
			 shouldBeVisible  distance > CONFIG.NearDistance 
				shouldBeVisible = (objPos, camPos, camLook)
			
			
			(tracked, shouldBeVisible)
		
		
		currentIndex = currentIndex + 
	


  ()
	 i = #trackedObjects, , - 
		 tracked = trackedObjects[i]
		  tracked.obj   tracked.obj.Parent 
			objectLookup[tracked.obj] = 
			.(trackedObjects, i)
		
	


  ()
	 isRegistering   
	isRegistering = 
	
	 count = 
	
	 _, obj  (:()) 
		 count >= CONFIG.MaxTotalObjects   
		(obj)
		count = count + 
		
		 count %  ==  
			.()
		
	
	
	isRegistering = 
	( .. #trackedObjects .. )


 pendingObjects = {}
 lastRegisterTime = 

.DescendantAdded:((obj)
	 isRegistering   
	 #trackedObjects >= CONFIG.MaxTotalObjects   
	
	.(pendingObjects, obj)
)

.(()
	 .(CONFIG.RegisterDelay) 
		 #pendingObjects >    isRegistering 
			 currentTime = ()
			 currentTime - lastRegisterTime >= CONFIG.RegisterDelay 
				 toRegister = .(#pendingObjects, )
				
				 i = , toRegister 
					 obj = .(pendingObjects, )
					 obj  obj.Parent 
						(obj)
					
				
				
				lastRegisterTime = currentTime
			
		
	
)

.DescendantRemoving:((obj)
	 objectLookup[obj] 
		objectLookup[obj] = 
	
)

.(()
	 .() 
		  isRegistering 
			()
		
	
)

RunService.RenderStepped:(()
	 currentTime = ()
	 currentTime - lastUpdate >= CONFIG.UpdateInterval 
		()
		lastUpdate = currentTime
	
)

.(batchRegister)

.OcclusionStats = ()
	 visible = 
	 _, tracked  (trackedObjects) 
		 tracked.visible 
			visible = visible + 
		
	
	 {
		Total = #trackedObjects,
		Visible = visible,
		Hidden = #trackedObjects - visible,
		Pending = #pendingObjects,
	}


()