Object Occlusion Culling

2026-10-15 02:41:03 -07:00
parent 3273054766
commit 612a3d0a09
33 changed files with 3629 additions and 84 deletions
--- a/leenkx/Sources/iron/culling/CullSystem.hx
+++ b/leenkx/Sources/iron/culling/CullSystem.hx
@ -0,0 +1,773 @@
+package iron.culling;
+
+import iron.object.CameraObject;
+import iron.object.FrustumPlane;
+import iron.Scene;
+import iron.RenderPath;
+import iron.math.Mat4;
+
+class CullSystem {
+
+	public static var active: CullSystem = null;
+
+	public var tier: CullTier;
+	public var cullData: CullData;
+	public var rasterizer: SoftwareOcclusionRasterizer;
+	public var shadowRasterizer: SoftwareOcclusionRasterizer;
+	public var occluderProxies: Array<OccluderProxy>;
+	public var bvh: ObjectBVH;
+	public var temporal: TemporalState;
+
+	public var enabled: Bool = true;
+	public var occlusionEnabled: Bool = true;
+	public var bvhDirty: Bool = true;
+	public var proxiesDirty: Bool = true;
+	var dataSyncedFrame: Int = -1;
+
+	var focalLengthPx: Float = 500.0;
+	var orthoPxPerUnit: Float = 0.0;
+	var screenW: Int = 1920;
+	var screenH: Int = 1080;
+
+	public static var maxOccluders: Int = 48;
+	public static var maxOccluderTris: Int = 4000;
+	public static var maxTrisPerProxy: Int = 768;
+	public static var maxShadowOccluders: Int = 24;
+	public static var maxShadowOccluderTris: Int = 1536;
+	public static var boxOccluders: Bool = false;
+	public static var shadowBoxOccluders: Bool = false;
+	public static var shadowBoxShrink: Float = 0.7;
+	public static var shadowCullingEnabled: Bool = true;
+	public static var minOccluderPx: Float = 24.0;
+	public static var boxShrink: Float = 0.5;
+	public static var depthEps: Float = 1e-6;
+
+	public static var shadowCullInterval: Int = 2;
+
+	static inline var MAX_SHADOW_SLOTS = 8;
+	var shadowPasses: haxe.ds.ObjectMap<iron.object.LightObject, Array<ShadowPassSlot>> = new haxe.ds.ObjectMap();
+	var shadowCallIdx: Map<iron.object.LightObject, Int> = new Map();
+	var shadowCallFrame: Map<iron.object.LightObject, Int> = new Map();
+	var lastShadowSlot: ShadowPassSlot = null;
+	var lastShadowFrame: Int = -1;
+	var lastShadowCallIdx: Int = -1;
+	#if lnx_csm
+	var shadowVps: haxe.ds.ObjectMap<iron.object.LightObject, Mat4> = new haxe.ds.ObjectMap();
+	#end
+	var sceneRev: Int = 0;
+	var sceneRevFrame: Int = -1;
+	var frameCounter: Int = 0;
+	var bvhSyncedFrame: Int = -1; // Frame when BVH was built/refit
+
+	var occlusionFrustumPlanes: Array<FrustumPlane> = null;
+	var frustumPlanes: Array<FrustumPlane> = null;
+
+	var shadowFrustumPlanes: Array<FrustumPlane> = null;
+
+	var uidToProxy: haxe.ds.IntMap<OccluderProxy> = new haxe.ds.IntMap<OccluderProxy>();
+	var uidScan: haxe.ds.IntMap<Bool> = new haxe.ds.IntMap<Bool>();
+
+	var prevVP: Mat4 = null;
+	#if lnx_taa
+	var unjitteredVP: Mat4 = null;
+	#end
+	public var shadowFlagsValid: Bool = false;
+
+	var inFrustumList: Array<Int> = [];
+	var selIdx: Array<Int> = [];
+	var selScore: Array<Float> = [];
+	var selCount: Int = 0;
+
+	public function new() {
+		cullData = new CullData();
+		rasterizer = new SoftwareOcclusionRasterizer(128, 64);
+		shadowRasterizer = new SoftwareOcclusionRasterizer(128, 128);
+		occluderProxies = [];
+		temporal = new TemporalState();
+		tier = detectTier();
+	}
+
+	static inline var MAT_EPS = 1e-7;
+
+	static inline function matEquals(a: Mat4, b: Mat4): Bool {
+		return
+			Math.abs(a._00 - b._00) < MAT_EPS && Math.abs(a._10 - b._10) < MAT_EPS &&
+			Math.abs(a._20 - b._20) < MAT_EPS && Math.abs(a._30 - b._30) < MAT_EPS &&
+			Math.abs(a._01 - b._01) < MAT_EPS && Math.abs(a._11 - b._11) < MAT_EPS &&
+			Math.abs(a._21 - b._21) < MAT_EPS && Math.abs(a._31 - b._31) < MAT_EPS &&
+			Math.abs(a._02 - b._02) < MAT_EPS && Math.abs(a._12 - b._12) < MAT_EPS &&
+			Math.abs(a._22 - b._22) < MAT_EPS && Math.abs(a._32 - b._32) < MAT_EPS &&
+			Math.abs(a._03 - b._03) < MAT_EPS && Math.abs(a._13 - b._13) < MAT_EPS &&
+			Math.abs(a._23 - b._23) < MAT_EPS && Math.abs(a._33 - b._33) < MAT_EPS;
+	}
+
+	public static function detectTier(): CullTier {
+		#if (target.threaded)
+		return CPUMultiThread;
+		#else
+		return CPUSingleThread;
+		#end
+	}
+
+	public function cull(camera: CameraObject) {
+		frameCounter = RenderPath.active != null ? RenderPath.active.frame : frameCounter + 1;
+		if (!enabled || Scene.active == null || Scene.active.meshes.length == 0) {
+			if (Scene.active != null) {
+				var meshes = Scene.active.meshes;
+				for (i in 0...meshes.length) {
+					meshes[i].occlusionVisible = true;
+					meshes[i].shadowOcclusionVisible = true;
+				}
+			}
+			return;
+		}
+
+		var rp = RenderPath.active;
+		if (rp != null) {
+			screenW = rp.currentW;
+			screenH = rp.currentH;
+		}
+
+		var targetW = Std.int(Math.max(128, Math.min(512, screenW >> 4)));
+		var targetH = Std.int(Math.max(64, Math.min(256, screenH >> 4)));
+		if (rasterizer.width < (targetW >> 1) || rasterizer.width > (targetW << 1) ||
+		    rasterizer.height < (targetH >> 1) || rasterizer.height > (targetH << 1)) {
+			rasterizer = new SoftwareOcclusionRasterizer(targetW, targetH);
+		}
+
+		if (camera.data.raw.ortho == null) {
+			focalLengthPx = ContributionCull.computeFocalLengthPx(
+				camera.data.raw.fov, screenH
+			);
+			orthoPxPerUnit = 0.0;
+		} else {
+			focalLengthPx = 0;
+			var o = camera.data.raw.ortho;
+			var halfH = (o[3] - o[2]) * 0.5;
+			orthoPxPerUnit = halfH > 1e-9 ? screenH * 0.5 / halfH : 0.0;
+		}
+		rasterizer.nearClip = camera.data.raw.ortho == null ?
+			camera.data.raw.near_plane : 0.0001;
+
+		if (dataSyncedFrame != frameCounter) {
+			cullData.syncFromScene();
+			dataSyncedFrame = frameCounter;
+		}
+		if (cullData.slotsRebuilt) temporal.clear();
+		if (sceneRevFrame != frameCounter) {
+			sceneRevFrame = frameCounter;
+			if (cullData.anyMoved || cullData.anyFlagsChanged || cullData.orderChanged) sceneRev++;
+		}
+		var cd = cullData;
+		var meshes = cd.meshes;
+
+		#if lnx_taa
+		if (unjitteredVP == null) unjitteredVP = Mat4.identity();
+		unjitteredVP.multmats(camera.noJitterP, camera.V);
+		var cmpVP = unjitteredVP;
+		#else
+		var cmpVP = camera.VP;
+		#end
+		var vpSame = prevVP != null && matEquals(cmpVP, prevVP);
+		if (vpSame && !cd.anyMoved && !cd.anyFlagsChanged && !cd.orderChanged && !bvhDirty) {
+			return;
+		}
+		var needBvhRebuild = bvhDirty;
+		bvhDirty = false;
+		if (prevVP == null) prevVP = Mat4.identity();
+		prevVP.setFrom(cmpVP);
+
+		if (occlusionFrustumPlanes == null) {
+			occlusionFrustumPlanes = [];
+			for (i in 0...6) occlusionFrustumPlanes.push(new FrustumPlane());
+		}
+		{
+			var vp = camera.VP;
+			var p = occlusionFrustumPlanes;
+			p[0].setComponents(vp._03 + vp._00, vp._13 + vp._10, vp._23 + vp._20, vp._33 + vp._30);
+			p[1].setComponents(vp._03 - vp._00, vp._13 - vp._10, vp._23 - vp._20, vp._33 - vp._30);
+			p[2].setComponents(vp._03 - vp._01, vp._13 - vp._11, vp._23 - vp._21, vp._33 - vp._31);
+			p[3].setComponents(vp._03 + vp._01, vp._13 + vp._11, vp._23 + vp._21, vp._33 + vp._31);
+			p[4].setComponents(vp._02, vp._12, vp._22, vp._32);
+			p[5].setComponents(vp._03 - vp._02, vp._13 - vp._12, vp._23 - vp._22, vp._33 - vp._32);
+		}
+		frustumPlanes = occlusionFrustumPlanes;
+
+		var camX = camera.transform.worldx();
+		var camY = camera.transform.worldy();
+		var camZ = camera.transform.worldz();
+
+		if (bvh == null) bvh = new ObjectBVH();
+		if (bvhSyncedFrame != frameCounter) {
+			if (needBvhRebuild || bvh.root < 0) {
+				bvh.build(cd);
+			} else if (cd.anyMoved || cd.orderChanged) {
+				bvh.refit(cd);
+			}
+			bvhSyncedFrame = frameCounter;
+		}
+		inFrustumList.resize(0);
+		var planes = frustumPlanes;
+		var fpx = focalLengthPx;
+		bvh.traverseFrontToBack(camX, camY, camZ,
+			function(node: BVHNode): Bool {
+				if (!ObjectBVH.aabbInFrustum(node, planes)) return true;
+				if (!ContributionCull.passesNode(node, camX, camY, camZ, fpx)) return true;
+				return false;
+			},
+			function(objIdx: Int, _: Int) {
+				if ((cd.getFlags(objIdx) & 8) == 0) return;
+				if (!ContributionCull.passes(
+					cd.getCenterX(objIdx), cd.getCenterY(objIdx), cd.getCenterZ(objIdx),
+					cd.getRadius(objIdx), camX, camY, camZ, fpx
+				)) return;
+				inFrustumList.push(objIdx);
+			}
+		);
+		cullData.clearVisible();
+
+		if (occlusionEnabled) {
+			selectOccluders(meshes, camX, camY, camZ);
+
+			for (i in 0...meshes.length) {
+				meshes[i].occlusionVisible = true;
+			}
+
+			rasterizer.clear();
+			if (selCount > 0) rasterizeSelected(meshes, camera.VP);
+			var trisDone = rasterizer.trianglesRasterized;
+			if (trisDone > 0) rasterizer.buildHiZ();
+
+			if (trisDone > 0) {
+				testVisibilityBVH(camera.VP, camX, camY, camZ, planes);
+			} else {
+				for (k in 0...inFrustumList.length) {
+					var objIdx = inFrustumList[k];
+					cd.addVisible(objIdx);
+				}
+			}
+		} else {
+			for (i in 0...meshes.length) {
+				meshes[i].occlusionVisible = true;
+			}
+			for (k in 0...inFrustumList.length) {
+				var objIdx = inFrustumList[k];
+				cd.addVisible(objIdx);
+			}
+		}
+
+		temporal.advanceFrame();
+	}
+
+	public function cullShadow(light: iron.object.LightObject) {
+		if (!occlusionEnabled || light == null || Scene.active == null) return;
+		if (!shadowCullingEnabled) {
+			var ms = Scene.active.meshes;
+			for (m in ms) m.shadowOcclusionVisible = true;
+			return;
+		}
+
+		var frame = RenderPath.active != null ? RenderPath.active.frame : frameCounter;
+		var vp = light.VP;
+		if (vp == null) return;
+
+		var cd = cullData;
+
+		if (dataSyncedFrame != frame) {
+			cd.syncFromScene();
+			dataSyncedFrame = frame;
+		}
+		if (sceneRevFrame != frame) {
+			sceneRevFrame = frame;
+			if (cd.anyMoved || cd.anyFlagsChanged || cd.orderChanged) sceneRev++;
+		}
+		var meshes = cd.meshes;
+
+		var slots = shadowPasses.get(light);
+		if (slots == null) {
+			slots = [];
+			shadowPasses.set(light, slots);
+		}
+		var callIdx = 0;
+		{
+			var f = shadowCallFrame.get(light);
+			callIdx = (f == frame) ? shadowCallIdx.get(light) + 1 : 0;
+			shadowCallIdx.set(light, callIdx);
+			shadowCallFrame.set(light, frame);
+		}
+		var slotIdx = callIdx < MAX_SHADOW_SLOTS ? callIdx : MAX_SHADOW_SLOTS - 1;
+		while (slots.length <= slotIdx) slots.push(new ShadowPassSlot());
+		var slot = slots[slotIdx];
+
+		if (slot != null && slot == lastShadowSlot && lastShadowFrame == frame &&
+			lastShadowCallIdx == callIdx && slot.appliedRev == sceneRev) return;
+
+		for (i in 0...meshes.length) {
+			meshes[i].shadowOcclusionVisible = true;
+		}
+
+		#if lnx_csm
+		var isCsmLight = light.data.raw.type == "sun" &&
+			iron.object.LightObject.cascadeCount > 1;
+		if (isCsmLight && callIdx == 0) {
+			var vp0 = shadowVps.get(light);
+			if (vp0 == null) { vp0 = Mat4.identity(); shadowVps.set(light, vp0); }
+			vp0.setFrom(vp);
+		}
+		#end
+
+		if (shadowCullInterval > 1) {
+			if ((frame + slotIdx) % shadowCullInterval != 0) {
+				var applied = false;
+				#if lnx_csm
+				if (isCsmLight && callIdx > 0) {
+					var head = slots[0];
+					var vp0 = shadowVps.get(light);
+					if (head.appliedRev == sceneRev && head.flagsLen > 0 &&
+						head.vp != null && vp0 != null && matEquals(vp0, head.vp)) {
+						var hn = head.flagsLen < meshes.length ? head.flagsLen : meshes.length;
+						for (i in 0...hn) meshes[i].shadowOcclusionVisible = head.flags[i];
+					}
+					applied = true;
+				}
+				#end
+				if (!applied && slot.appliedRev == sceneRev && slot.flagsLen > 0 &&
+					slot.vp != null && matEquals(vp, slot.vp)) {
+					var n = slot.flagsLen < meshes.length ? slot.flagsLen : meshes.length;
+					for (i in 0...n) meshes[i].shadowOcclusionVisible = slot.flags[i];
+				}
+				lastShadowSlot = slot;
+				lastShadowFrame = frame;
+				lastShadowCallIdx = callIdx;
+				return;
+			}
+		}
+
+		if (bvh == null) bvh = new ObjectBVH();
+		if (bvhSyncedFrame != frame) {
+			if (bvhDirty || bvh.root < 0) {
+				bvh.build(cd);
+			} else if (cd.anyMoved || cd.orderChanged) {
+				bvh.refit(cd);
+			}
+			bvhSyncedFrame = frame;
+		}
+
+		if (shadowFrustumPlanes == null) {
+			shadowFrustumPlanes = [];
+			for (i in 0...6) shadowFrustumPlanes.push(new FrustumPlane());
+		}
+		{
+			var p = shadowFrustumPlanes;
+			p[0].setComponents(vp._03 + vp._00, vp._13 + vp._10, vp._23 + vp._20, vp._33 + vp._30);
+			p[1].setComponents(vp._03 - vp._00, vp._13 - vp._10, vp._23 - vp._20, vp._33 - vp._30);
+			p[2].setComponents(vp._03 - vp._01, vp._13 - vp._11, vp._23 - vp._21, vp._33 - vp._31);
+			p[3].setComponents(vp._03 + vp._01, vp._13 + vp._11, vp._23 + vp._21, vp._33 + vp._31);
+			p[4].setComponents(vp._02, vp._12, vp._22, vp._32);
+			p[5].setComponents(vp._03 - vp._02, vp._13 - vp._12, vp._23 - vp._22, vp._33 - vp._32);
+		}
+		var lightPlanes = shadowFrustumPlanes;
+
+		var lx = light.transform.worldx();
+		var ly = light.transform.worldy();
+		var lz = light.transform.worldz();
+
+		var raster = slot.rasterizer;
+		var vpSame = slot.vp != null && matEquals(vp, slot.vp);
+		if (slot.sceneRev == sceneRev && vpSame && raster != null) {
+			// skip 
+		} else {
+			if (raster == null) {
+				raster = new SoftwareOcclusionRasterizer(
+					shadowRasterizer.width, shadowRasterizer.height);
+				slot.rasterizer = raster;
+			}
+			if (slot.vp == null) slot.vp = Mat4.identity();
+			slot.vp.setFrom(vp);
+
+			var perspective = light.data.raw.type != "sun";
+			selCount = 0;
+			bvh.traverseFrontToBack(lx, ly, lz,
+				function(node: BVHNode): Bool {
+					if (!ObjectBVH.aabbInFrustum(node, lightPlanes)) return true;
+					return false;
+				},
+				function(i: Int, _: Int) {
+					if ((cd.getFlags(i) & 8) == 0) return;
+					if ((cd.getFlags(i) & 16) != 0) return;
+					if ((cd.getFlags(i) & 4) == 0) return; 
+					if ((cd.getFlags(i) & 32) != 0) return;
+					if (i >= meshes.length) return;
+					var r = cd.getRadius(i);
+					var score = r;
+					if (perspective) {
+						var dx = cd.getCenterX(i) - lx;
+						var dy = cd.getCenterY(i) - ly;
+						var dz = cd.getCenterZ(i) - lz;
+						var dist2 = dx * dx + dy * dy + dz * dz;
+						if (dist2 <= r * r) return;
+						score = r / Math.sqrt(dist2);
+					}
+					insertTopK(i, score, maxShadowOccluders);
+				}
+			);
+
+			raster = slot.rasterizer;
+			raster.clear();
+			var triBudget = maxShadowOccluderTris;
+			for (s in 0...selCount) {
+				if (triBudget < 12) break;
+				var i = selIdx[s];
+				var proxy = uidToProxy.get(cd.getObjectID(i));
+				if (proxy != null && proxy.triangleCount > 0 &&
+					proxy.triangleCount <= maxTrisPerProxy && proxy.triangleCount <= triBudget) {
+					proxy.rasterize(raster, meshes[i].transform.world, vp,
+						raster.width, raster.height);
+					triBudget -= proxy.triangleCount;
+				} else if (shadowBoxOccluders) {
+					rasterizeBoxOccluder(raster, i, vp, shadowBoxShrink);
+					triBudget -= 12;
+				}
+			}
+			if (raster.trianglesRasterized > 0) raster.buildHiZ();
+		}
+
+		if (raster.trianglesRasterized > 0) {
+		var sw = raster.width;
+		var sh = raster.height;
+
+		bvh.traverseFrontToBack(lx, ly, lz,
+			function(node: BVHNode): Bool {
+				if (!ObjectBVH.aabbInFrustum(node, lightPlanes)) return true;
+				var anyVisible = false;
+				if (node.isLeaf) {
+					for (j in 0...node.objectCount) {
+						var idx = bvh.objectIndices[node.firstObject + j];
+						if ((cd.getFlags(idx) & 8) != 0 && idx < meshes.length) {
+							anyVisible = true; break;
+						}
+					}
+					if (!anyVisible) return true;
+				}
+				if (raster.isOccluded(
+					node.minX, node.minY, node.minZ,
+					node.maxX, node.maxY, node.maxZ,
+					vp, sw, sh
+				)) {
+					bvh.forEachLeafInSubtree(node, function(idx: Int) {
+						if (idx < meshes.length && (cd.getFlags(idx) & 8) != 0) {
+							meshes[idx].shadowOcclusionVisible = false;
+						}
+					});
+					return true;
+				}
+				return false;
+			},
+			function(objIdx: Int, _: Int) {
+				if ((cd.getFlags(objIdx) & 8) == 0) return;
+				if (objIdx >= meshes.length) return;
+				meshes[objIdx].shadowOcclusionVisible = true;
+				if (raster.isOccluded(
+					cd.getMinX(objIdx), cd.getMinY(objIdx), cd.getMinZ(objIdx),
+					cd.getMaxX(objIdx), cd.getMaxY(objIdx), cd.getMaxZ(objIdx),
+					vp, sw, sh
+				)) {
+					meshes[objIdx].shadowOcclusionVisible = false;
+				}
+			}
+		);
+		}
+
+		#if lnx_csm
+		if (isCsmLight) {
+			for (c in 1...iron.object.LightObject.cascadeCount) {
+				if (c >= slots.length) break;
+				var s = slots[c];
+				if (s == null || s == slot || s.vp == null || s.rasterizer == null) continue;
+				for (i in 0...meshes.length) {
+					if (meshes[i].shadowOcclusionVisible) continue;
+					if (!s.rasterizer.isOccluded(
+						cd.getMinX(i), cd.getMinY(i), cd.getMinZ(i),
+						cd.getMaxX(i), cd.getMaxY(i), cd.getMaxZ(i),
+						s.vp, s.rasterizer.width, s.rasterizer.height
+					)) {
+						meshes[i].shadowOcclusionVisible = true;
+					}
+				}
+			}
+		}
+		#end
+
+		if (slot.flags.length < meshes.length) slot.flags.resize(meshes.length);
+		slot.flagsLen = meshes.length;
+		for (i in 0...meshes.length) slot.flags[i] = meshes[i].shadowOcclusionVisible;
+
+		#if lnx_csm
+		if (isCsmLight && callIdx > 0) {
+			var head = slots[0];
+			var vp0 = shadowVps.get(light);
+			if (head.appliedRev == sceneRev && head.flagsLen > 0 &&
+				head.vp != null && vp0 != null && matEquals(vp0, head.vp)) {
+				var hn = head.flagsLen < meshes.length ? head.flagsLen : meshes.length;
+				for (i in 0...hn) meshes[i].shadowOcclusionVisible = head.flags[i];
+			} else {
+				for (i in 0...meshes.length) meshes[i].shadowOcclusionVisible = true;
+			}
+		}
+		#end
+
+		slot.sceneRev = sceneRev;
+		slot.appliedRev = sceneRev;
+		slot.lastUsed = frame;
+		lastShadowSlot = slot;
+		lastShadowFrame = frame;
+		lastShadowCallIdx = callIdx;
+		shadowFlagsValid = true;
+	}
+
+	function selectOccluders(
+		meshes: Array<iron.object.MeshObject>,
+		camX: Float, camY: Float, camZ: Float
+	) {
+		var cd = cullData;
+		selCount = 0;
+		var minPx = minOccluderPx;
+		var autoPx = autoOccluderMinScreenRatio * screenH;
+		for (k in 0...inFrustumList.length) {
+			var i = inFrustumList[k];
+			if (i >= meshes.length) continue;
+			if (!meshes[i].occlusionVisible) continue;
+			var flags = cd.getFlags(i);
+			if ((flags & 16) != 0) continue;
+			if ((flags & 32) != 0) continue;
+			var r = cd.getRadius(i);
+			var px: Float;
+			var camInside = false;
+			if (focalLengthPx > 0) {
+				var dx = cd.getCenterX(i) - camX;
+				var dy = cd.getCenterY(i) - camY;
+				var dz = cd.getCenterZ(i) - camZ;
+				var dist2 = dx * dx + dy * dy + dz * dz;
+				if (dist2 <= r * r) camInside = true;
+				px = camInside ? 1e6 : focalLengthPx * r / Math.sqrt(dist2);
+			} else {
+				px = r * orthoPxPerUnit;
+			}
+			if (px < minPx) continue;
+			if ((flags & 1) == 0 && px < autoPx) continue;
+			if (camInside || !boxOccluders) {
+				var p = uidToProxy.get(cd.getObjectID(i));
+				if (p == null || p.triangleCount <= 0 || p.triangleCount > maxTrisPerProxy) continue;
+			}
+			insertTopK(i, px, maxOccluders);
+		}
+	}
+
+	function insertTopK(idx: Int, score: Float, k: Int) {
+		if (selIdx.length < k + 1) {
+			selIdx.resize(k + 1);
+			selScore.resize(k + 1);
+		}
+		var pos = selCount;
+		while (pos > 0 && selScore[pos - 1] < score) pos--;
+		if (pos >= k) return;
+		var last = selCount < k ? selCount : k - 1;
+		var j = last;
+		while (j > pos) {
+			selIdx[j] = selIdx[j - 1];
+			selScore[j] = selScore[j - 1];
+			j--;
+		}
+		selIdx[pos] = idx;
+		selScore[pos] = score;
+		if (selCount < k) selCount++;
+	}
+
+	function rasterizeSelected(meshes: Array<iron.object.MeshObject>, vp: Mat4) {
+		var cd = cullData;
+		var triBudget = maxOccluderTris;
+		#if (target.threaded)
+		rasterizer.beginCollect();
+		#end
+		for (s in 0...selCount) {
+			if (triBudget < 12) break;
+			var i = selIdx[s];
+			var proxy = uidToProxy.get(cd.getObjectID(i));
+			if (proxy != null && proxy.triangleCount > 0 &&
+				proxy.triangleCount <= maxTrisPerProxy && proxy.triangleCount <= triBudget) {
+				var mesh = i < meshes.length ? meshes[i] : null;
+				if (mesh == null) continue;
+				proxy.rasterize(rasterizer, mesh.transform.world, vp, screenW, screenH);
+				triBudget -= proxy.triangleCount;
+			} else {
+				if (!boxOccluders) continue;
+				rasterizeBoxOccluder(rasterizer, i, vp);
+				triBudget -= 12;
+			}
+		}
+		#if (target.threaded)
+		rasterizer.flushCollected();
+		#end
+	}
+
+	function rasterizeBoxOccluder(raster: SoftwareOcclusionRasterizer, objectIndex: Int, vp: Mat4, shrinkOverride = -1.0) {
+		var cd = cullData;
+		var bx0 = cd.getMinX(objectIndex), by0 = cd.getMinY(objectIndex), bz0 = cd.getMinZ(objectIndex);
+		var bx1 = cd.getMaxX(objectIndex), by1 = cd.getMaxY(objectIndex), bz1 = cd.getMaxZ(objectIndex);
+		var cx = (bx0 + bx1) * 0.5;
+		var cy = (by0 + by1) * 0.5;
+		var cz = (bz0 + bz1) * 0.5;
+		var boxShrink = shrinkOverride >= 0.0 ? shrinkOverride : CullSystem.boxShrink;
+		var hx = (bx1 - bx0) * 0.5 * boxShrink;
+		var hy = (by1 - by0) * 0.5 * boxShrink;
+		var hz = (bz1 - bz0) * 0.5 * boxShrink;
+		raster.rasterizeBox(
+			cx - hx, cy - hy, cz - hz,
+			cx + hx, cy + hy, cz + hz,
+			vp, raster.width, raster.height
+		);
+	}
+
+	function testVisibilityBVH(
+		vp: Mat4, camX: Float, camY: Float, camZ: Float,
+		planes: Array<FrustumPlane>
+	) {
+		var cd = cullData;
+		var raster = rasterizer;
+		var sw = screenW;
+		var sh = screenH;
+		var meshes = cd.meshes;
+		var bvh = this.bvh;
+		var temp = temporal;
+		var retestInterval = 4;
+
+		bvh.traverseFrontToBack(camX, camY, camZ,
+			function(node: BVHNode): Bool {
+				if (!ObjectBVH.aabbInFrustum(node, planes)) return true;
+				var anyVisible = false;
+				if (node.isLeaf) {
+					for (j in 0...node.objectCount) {
+						var idx = bvh.objectIndices[node.firstObject + j];
+						if ((cd.getFlags(idx) & 8) != 0) { anyVisible = true; break; }
+					}
+					if (!anyVisible) return true;
+				}
+				if (raster.isOccluded(
+					node.minX, node.minY, node.minZ,
+					node.maxX, node.maxY, node.maxZ,
+					vp, sw, sh
+				)) {
+					bvh.forEachLeafInSubtree(node, function(idx: Int) {
+						if (idx >= meshes.length || (cd.getFlags(idx) & 8) == 0) return;
+						meshes[idx].occlusionVisible = false;
+						var uid = cd.getObjectID(idx);
+						temp.setVisible(uid, false);
+						temp.markTested(uid);
+					});
+					return true;
+				}
+				return false;
+			},
+			function(objIdx: Int, _: Int) {
+				if ((cd.getFlags(objIdx) & 8) == 0) return;
+				if (objIdx >= meshes.length) return;
+				var uid = cd.getObjectID(objIdx);
+				if (temp.wasVisibleLastFrame(uid) && !temp.needsVisibleReTest(uid, retestInterval)) {
+					meshes[objIdx].occlusionVisible = true;
+					cd.addVisible(objIdx);
+					return;
+				}
+				if (raster.isOccluded(
+					cd.getMinX(objIdx), cd.getMinY(objIdx), cd.getMinZ(objIdx),
+					cd.getMaxX(objIdx), cd.getMaxY(objIdx), cd.getMaxZ(objIdx),
+					vp, sw, sh
+				)) {
+					meshes[objIdx].occlusionVisible = false;
+					temp.setVisible(uid, false);
+					temp.markTested(uid);
+				} else {
+					meshes[objIdx].occlusionVisible = true;
+					cd.addVisible(objIdx);
+					temp.setVisible(uid, true);
+					temp.markTested(uid);
+				}
+			}
+		);
+	}
+
+	public static var autoOccluderMinScreenRatio: Float = 0.10;
+
+	public inline function isVisible(objectIndex: Int): Bool {
+		var ms = cullData.meshes;
+		return objectIndex >= 0 && objectIndex < ms.length && ms[objectIndex].occlusionVisible;
+	}
+
+	public inline function markDirty() {
+		bvhDirty = true;
+		proxiesDirty = true;
+		cullData.slotsDirty = true;
+		shadowFlagsValid = false;
+	}
+
+	public function removeLight(light: iron.object.LightObject) {
+		shadowPasses.remove(light);
+		shadowCallIdx.remove(light);
+		shadowCallFrame.remove(light);
+		#if lnx_csm
+		shadowVps.remove(light);
+		#end
+	}
+
+	public static function init() {
+		if (active == null) {
+			active = new CullSystem();
+		}
+	}
+
+	public function loadOccluderProxies() {
+		occluderProxies.resize(0);
+		if (Scene.active == null) {
+			uidToProxy.clear();
+			return;
+		}
+		var meshes = Scene.active.meshes;
+		uidScan.clear();
+		for (i in 0...meshes.length) {
+			var mesh = meshes[i];
+			uidScan.set(mesh.uid, true);
+			if (uidToProxy.exists(mesh.uid)) continue;
+			if (mesh.data == null || mesh.data.raw == null) continue;
+			var raw = mesh.data.raw;
+			if (raw.occluder_proxy == null) continue;
+			var proxyRaw = raw.occluder_proxy;
+			if (proxyRaw.positions == null || proxyRaw.indices == null) continue;
+			var proxy = new OccluderProxy();
+			proxy.setData(proxyRaw.positions, proxyRaw.indices, mesh.uid);
+			uidToProxy.set(mesh.uid, proxy);
+		}
+		var dead: Array<Int> = null;
+		for (uid in uidToProxy.keys()) {
+			if (!uidScan.exists(uid)) {
+				if (dead == null) dead = [];
+				dead.push(uid);
+			}
+		}
+		if (dead != null) for (uid in dead) uidToProxy.remove(uid);
+		for (proxy in uidToProxy.iterator()) occluderProxies.push(proxy);
+	}
+
+	public static function shutdown() {
+		active = null;
+	}
+}
+
+class ShadowPassSlot {
+	public var vp: Mat4 = null;
+	public var rasterizer: SoftwareOcclusionRasterizer = null;
+	public var sceneRev: Int = -1;
+	public var appliedRev: Int = -1;
+	public var lastUsed: Int = -1;
+	public var flags: Array<Bool> = [];
+	public var flagsLen: Int = 0;
+	public function new() {}
+}