A new and improved Light vs AABB intersection testing routine. Resurrection of the old debug draw code.

Author: achalpandeyy

examples_tests/60.ClusteredRendering/clipmap/first_cull.comp

@@ -60,7 +60,7 @@ void main()
 				const uvec3 localClusterID = uvec3(clusterX, clusterY, clusterZ);
 				const nbl_glsl_shapes_AABB_t cluster = getCluster(localClusterID, levelMinVertex, voxelSideLength);
 
-				if (coneIntersectAABB(cone, cluster))
+				if (lightIntersectAABB(cone, cluster))
 				{
 					// Record intersection
 					intersection_record_t record;

examples_tests/60.ClusteredRendering/clipmap/intermediate_cull.comp

@@ -63,7 +63,7 @@ void main()
 				const uvec3 localClusterID = 2u*(parentVoxelID >> 1u) + uvec3(voxelX, voxelY, voxelZ);
 				const nbl_glsl_shapes_AABB_t cluster = getCluster(localClusterID, levelMinVertex, voxelSideLength);
 
-				if (coneIntersectAABB(cone, cluster))
+				if (lightIntersectAABB(cone, cluster))
 				{
 					// Record intersection
 					intersection_record_t record;

examples_tests/60.ClusteredRendering/clipmap/last_cull.comp

@@ -55,7 +55,7 @@ void main()
 				const uvec3 localClusterID = 2u*(parentVoxelID >> 1u) + uvec3(voxelX, voxelY, voxelZ);
 				const nbl_glsl_shapes_AABB_t cluster = getCluster(localClusterID, levelMinVertex, voxelSideLength);
 
-				if (coneIntersectAABB(cone, cluster))
+				if (lightIntersectAABB(cone, cluster))
 				{
 					// Record intersection
 					intersection_record_t record;

examples_tests/60.ClusteredRendering/cull_common.glsl

@@ -19,6 +19,7 @@
 layout(local_size_x = _NBL_GLSL_WORKGROUP_SIZE_) in;
 
 #include <nbl/builtin/glsl/shapes/aabb.glsl>
+#include <nbl/builtin/glsl/math/quaternions.glsl>
 
 #include <../intersection_record.glsl>
 
@@ -39,14 +40,6 @@ struct cone_t
 	float baseRadius;
 };
 
-bool isPointBehindPlane(in vec3 p, in vec4 plane)
-{
-	// As an optimization we can add an epsilon to 0, to ignore cones which have a
-	// very very small intersecting region with the AABB, could help with FP precision
-	// too when the point is on the plane
-	return (dot(p, plane.xyz) + plane.w) <= 0.f /* + EPSILON*/;
-}
-
 cone_t getLightVolume(in nbl_glsl_ext_ClusteredLighting_SpotLight light)
 {
 	cone_t cone;
@@ -102,66 +95,141 @@ vec4[PLANE_COUNT] getAABBPlanes(in nbl_glsl_shapes_AABB_t aabb)
 	vec3 p1 = vec3(aabb.maxVx.x, aabb.minVx.y, aabb.maxVx.z);
 	vec3 p2 = vec3(aabb.maxVx.x, aabb.maxVx.y, aabb.maxVx.z);
 	planes[0].xyz = normalize(cross(p1 - p0, p2 - p0));
-	planes[0].w = -dot(planes[0].xyz, p0);
+	planes[0].w = dot(planes[0].xyz, p0);
 
 	// 013
 	p0 = vec3(aabb.minVx.x, aabb.minVx.y, aabb.minVx.z);
 	p1 = vec3(aabb.maxVx.x, aabb.minVx.y, aabb.minVx.z);
 	p2 = vec3(aabb.maxVx.x, aabb.maxVx.y, aabb.minVx.z);
 	planes[1].xyz = normalize(cross(p1 - p0, p2 - p0));
-	planes[1].w = -dot(planes[1].xyz, p0);
+	planes[1].w = dot(planes[1].xyz, p0);
 
 	// 402
 	p0 = vec3(aabb.minVx.x, aabb.minVx.y, aabb.maxVx.z);
 	p1 = vec3(aabb.minVx.x, aabb.minVx.y, aabb.minVx.z);
 	p2 = vec3(aabb.minVx.x, aabb.maxVx.y, aabb.minVx.z);
 	planes[2].xyz = normalize(cross(p1 - p0, p2 - p0));
-	planes[2].w = -dot(planes[2].xyz, p0);
+	planes[2].w = dot(planes[2].xyz, p0);
 
 	// 546
 	p0 = vec3(aabb.maxVx.x, aabb.minVx.y, aabb.maxVx.z);
 	p1 = vec3(aabb.minVx.x, aabb.minVx.y, aabb.maxVx.z);
 	p2 = vec3(aabb.minVx.x, aabb.maxVx.y, aabb.maxVx.z);
 	planes[3].xyz = normalize(cross(p1 - p0, p2 - p0));
-	planes[3].w = -dot(planes[3].xyz, p0);
+	planes[3].w = dot(planes[3].xyz, p0);
 
 	// 451
 	p0 = vec3(aabb.minVx.x, aabb.minVx.y, aabb.maxVx.z);
 	p1 = vec3(aabb.maxVx.x, aabb.minVx.y, aabb.maxVx.z);
 	p2 = vec3(aabb.maxVx.x, aabb.minVx.y, aabb.minVx.z);
 	planes[4].xyz = normalize(cross(p1 - p0, p2 - p0));
-	planes[4].w = -dot(planes[4].xyz, p0);
+	planes[4].w = dot(planes[4].xyz, p0);
 
 	// 762
 	p0 = vec3(aabb.maxVx.x, aabb.maxVx.y, aabb.maxVx.z);
 	p1 = vec3(aabb.minVx.x, aabb.maxVx.y, aabb.maxVx.z);
 	p2 = vec3(aabb.minVx.x, aabb.maxVx.y, aabb.minVx.z);
 	planes[5].xyz = normalize(cross(p1 - p0, p2 - p0));
-	planes[5].w = -dot(planes[5].xyz, p0);
+	planes[5].w = dot(planes[5].xyz, p0);
 
 	return planes;
 }
 
-bool coneIntersectAABB(in cone_t cone, in nbl_glsl_shapes_AABB_t aabb)
+bvec3 and(in bvec3 a, in bvec3 b)
+{
+	return bvec3(a.x && b.x, a.y && b.y, a.z && b.z);
+}
+
+bvec3 or(in bvec3 a, in bvec3 b)
+{
+	return bvec3(a.x || b.x, a.y || b.y, a.z || b.z);
+}
+
+float projectedSphericalVertex(in vec3 origin, in vec3 planeNormal, in vec3 pos)
+{
+	return dot(normalize(pos - origin), planeNormal);
+}
+
+vec3 findFarthestPointOnConeInDirection(in vec3 planeNormal, in cone_t cone)
+{
+	const vec3 m = cross(cross(planeNormal, cone.direction), cone.direction);
+	const vec3 farthestBasePoint = cone.tip + (cone.direction * cone.height) - (m * cone.baseRadius); // farthest to plane's surface, away from positive half-space
+	return farthestBasePoint;
+}
+
+bool cullCone(in cone_t cone, in nbl_glsl_shapes_AABB_t aabb)
 {
-	vec4 planes[PLANE_COUNT] = getAABBPlanes(aabb);
+	float maxCosine = projectedSphericalVertex(cone.tip, cone.direction, vec3(aabb.minVx.x, aabb.minVx.y, aabb.minVx.z));
 
-	for (uint i = 0u; i < PLANE_COUNT; ++i)
+	for (uint i = 1u; i < 8u; ++i)
 	{
-		const vec3 m = cross(cross(planes[i].xyz, cone.direction), cone.direction);
-		const vec3 farthestBasePoint = cone.tip + (cone.direction * cone.height) - (m * cone.baseRadius); // farthest to plane's surface, away from positive half-space
-
-		// There are two edge cases here:
-		// 1. When cone's direction and plane's normal are anti-parallel
-		//		There is no reason to check farthestBasePoint in this case, because cone's tip is the farthest point!
-		//		But there is no harm in doing so.
-		// 2. When cone's direction and plane's normal are parallel
-		//		This edge case will get handled nicely by the farthestBasePoint coming as center of the base of the cone itself
-		if (isPointBehindPlane(cone.tip, planes[i]) && isPointBehindPlane(farthestBasePoint, planes[i]))
-			return false;
+		const uvec3 t = (uvec3(i) >> uvec3(0, 1, 2)) & 0x1u;
+		const vec3 vertex = mix(aabb.minVx, aabb.maxVx, t);
+
+		// assuming cone.direction is normalized
+		maxCosine = max(projectedSphericalVertex(cone.tip, cone.direction, vertex), maxCosine);
+	}
+
+	const bool allVerticesOutsideCone = maxCosine < cone.cosHalfAngle;
+
+	if (cone.cosHalfAngle <= 0.f) // obtuse
+	{
+		return allVerticesOutsideCone; // cull if whole AABB is inside complementary acute cone
+	}
+	else if (any(or(greaterThan(aabb.minVx, cone.tip), greaterThan(cone.tip, aabb.maxVx))) && allVerticesOutsideCone)
+	{
+		// step 1
+		for (uint i = 0u; i < 8u; ++i)
+		{
+			const uvec3 t = (uvec3(i) >> uvec3(0, 1, 2)) & 0x1u;
+			const vec3 vertex = mix(aabb.minVx, aabb.maxVx, t);
+
+			const vec3 waypoint = normalize(vertex - cone.tip);
+			
+			const vec3 normal = nbl_glsl_slerp_impl_impl(cone.direction, normalize(waypoint), sqrt(1.f - cone.cosHalfAngle * cone.cosHalfAngle));
+			if (dot(nbl_glsl_shapes_AABB_getFarthestPointInFront(aabb, normal) - cone.tip, normal) < 0.f)
+				return true;
+		}
+
+		vec4 planes[PLANE_COUNT] = getAABBPlanes(aabb);
+
+		for (uint i = 0u; i < PLANE_COUNT; ++i)
+		{
+			const vec3 normal = planes[i].xyz;
+
+			float farthestPoint = dot(normal, cone.tip);
+			if (dot(normal, cone.direction) < cone.cosHalfAngle)
+				farthestPoint = max(dot(normal, findFarthestPointOnConeInDirection(normal, cone)), farthestPoint); // https://www.3dgep.com/forward-plus/#Frustum-Cone_Culling 
+			else
+				farthestPoint += (cone.height / cone.cosHalfAngle);
+
+			if (farthestPoint < planes[i].w)
+				return true;
+		}
 	}
+	return false;
+}
+
+// Todo(achal): Can make this cone_t something like light_volume_t..
+bool lightIntersectAABB(in cone_t cone, in nbl_glsl_shapes_AABB_t aabb)
+{
+#if 1
+	const vec3 sphereMinPoint = cone.tip - cone.height;
+	const vec3 sphereMaxPoint = cone.tip + cone.height;
+
+	if (!any(and(lessThan(aabb.minVx, sphereMaxPoint),lessThan(sphereMinPoint, aabb.maxVx))))
+		return false;
+
+	const vec3 closestPoint = clamp(cone.tip, aabb.minVx, aabb.maxVx);
+
+	if (dot(closestPoint - cone.tip, closestPoint - cone.tip) > (cone.height * cone.height))
+		return false;
+
+	if (cone.cosHalfAngle <= -(1.f - 1e-3f))
+		return false;
+#endif
 
-	return true;
+	return !cullCone(cone, aabb);
 }
 
 float getLightImportanceMagnitude(in nbl_glsl_ext_ClusteredLighting_SpotLight light)

examples_tests/60.ClusteredRendering/debug_draw_aabb.vert

@@ -0,0 +1,28 @@
+#version 460 core
+
+#include <nbl/builtin/glsl/utils/common.glsl>
+#include <nbl/builtin/glsl/utils/transform.glsl>
+#include <nbl/builtin/glsl/shapes/aabb.glsl>
+
+layout (set = 0, binding = 0) restrict buffer readonly DebugAABBs
+{
+	nbl_glsl_shapes_AABB_t data[];
+} debugAABBs;
+
+layout (set = 0, binding = 1, row_major, std140) uniform UBO
+{
+    nbl_glsl_SBasicViewParameters params;
+} CamData;
+
+layout(location = 0) out vec3 color;
+
+void main()
+{
+	const nbl_glsl_shapes_AABB_t aabb = debugAABBs.data[gl_InstanceIndex];
+
+	const bvec3 mask = bvec3(gl_VertexIndex&0x1u,gl_VertexIndex&0x2u,gl_VertexIndex&0x4u);
+	vec3 pos = mix(aabb.minVx,aabb.maxVx,mask);
+
+	gl_Position = nbl_glsl_pseudoMul4x4with3x1(CamData.params.MVP, pos);
+	color = vec3(1.f, 0.f, 0.f);
+}

examples_tests/60.ClusteredRendering/debug_draw_light_volume.vert

@@ -0,0 +1,16 @@
+#version 460 core
+
+layout (location = 0) in vec4 VS_in_position;
+
+layout (push_constant, row_major) uniform Block
+{
+	mat4 mvp;
+} PushConstants;
+
+layout(location = 0) out vec3 color;
+
+void main()
+{
+	gl_Position = PushConstants.mvp * VS_in_position;
+	color = vec3(1.f, 1.f, 0.f);
+}