Implemented bounding sphere culling.

Author: akoreman

UnityProject/Assets/Scripts/AddToPathEngine.cs

@@ -46,29 +46,13 @@ private void OnEnable()
         emissionColor = Vector3.Normalize(emissionColor) ;
         emission = emissionStrength * emissionColor;
 
-        RayTracing.RegisterObject(this);
-
+        
 
+        RayTracing.RegisterObject(this);
     }
 
     private void OnDisable()
     {
         RayTracing.UnregisterObject(this);
     }
-
-    Vector3 meshAverage(Mesh mesh)
-    {
-        Vector3[] vertexList = mesh.vertices;
-
-        Vector3 average = Vector3.zero;
-        int count = 0;
-
-        foreach (Vector3 vertex in vertexList)
-        {
-            average += vertex;
-            count++;
-        }
-
-        return average / count;
-    }
 }

UnityProject/Assets/Scripts/RayGeometry.hlsl

@@ -21,7 +21,7 @@ void GroundPlaneRayIntersection(Ray ray, inout RayCollision collision)
 	}
 
 }
-
+/*
 void SphereRayIntersection(Ray ray, inout RayCollision collision, Sphere sphere)//, float3 sphereposition, float sphereradius)
 {
 	float3 spherePosition = sphere.position;
@@ -63,6 +63,51 @@ void SphereRayIntersection(Ray ray, inout RayCollision collision, Sphere sphere)
 		collision.emission = sphere.emission;
 	}
 }
+*/
+bool SphereRayIntersection(Ray ray, Sphere sphere)
+{
+	float3 spherePosition = sphere.position;
+	float sphereRadius = sphere.radius;
+
+	// Vector pointing from the Origin to the center of the sphere.
+	float3 distanceVector = ray.origin - spherePosition;
+
+	// p1 defines the point where the ray enters the sphere, the dot product is correlated with the overlap between the distance vector and the ray direction. 
+	// Large overlap -> ray direction and distance vector close to the same direction.
+	float p1 = -dot(ray.direction, distanceVector);
+
+	// Check whether the ray hits the sphere.
+	float p2Squared = p1 * p1 - dot(distanceVector, distanceVector) + sphereRadius * sphereRadius;
+
+	if (p2Squared < 0)
+		return false;
+
+	return true;
+	/*
+	// Find the point where the ray exits the sphere.
+	float p2 = sqrt(p2Squared);
+
+	// Find the distance between the ray origin and the entry (or exit) point of the sphere.
+	float distance;
+
+	if (p1 - p2 > 0)
+		distance = p1 - p2;
+	else
+		distance = p1 + p2;
+
+	if (distance > 0.0 && distance < collision.distance)
+	{
+		collision.distance = distance;
+		collision.position = ray.origin + distance * ray.direction;
+		// Find the normal vector.
+		collision.positionNormal = normalize(collision.position - spherePosition);
+
+		collision.albedo = sphere.albedo;
+		collision.specular = sphere.specular;
+		collision.emission = sphere.emission;
+	}
+	*/
+}
 
 struct TriangleCollisionPoint
 {

UnityProject/Assets/Scripts/RayTracing.compute

@@ -37,7 +37,7 @@ StructuredBuffer<float3> _normals;
 
 
 // Set from RayTracing.cs ////////
-//StructuredBuffer<Sphere> _SphereBuffer;
+StructuredBuffer<Sphere> _SphereBuffer;
 //////////////////////////////////
 
 
@@ -99,7 +99,8 @@ RayCollision TraceRays(Ray ray)
 
 	for (int j = 0; j < count; j++)
 	{
-		MeshRayIntersection(ray, collision, _meshObjects[j]);
+		if (SphereRayIntersection(ray, _SphereBuffer[j] ))
+			MeshRayIntersection(ray, collision, _meshObjects[j] );
 	}
 
 

UnityProject/Assets/Scripts/RayTracing.cs

@@ -28,7 +28,9 @@ public class RayTracing : MonoBehaviour
     //float lightIntensity;
 
     Material addMaterial;
+
     ComputeBuffer sphereBuffer;
+    private static List<Sphere> spheres = new List<Sphere>();
 
     private static List<MeshObject> meshObjects = new List<MeshObject>();
     private static List<Vector3> vertices = new List<Vector3>();
@@ -79,6 +81,7 @@ void OnRenderImage(RenderTexture source, RenderTexture destination)
         }
 
         //SetUpGeometryBuffer();
+        //BuildSphereBuffer();
         BuildMeshBuffer();
 
         // Send stuff to the computer shader.
@@ -88,7 +91,7 @@ void OnRenderImage(RenderTexture source, RenderTexture destination)
         rayTracer.SetVector("_cameraRotation", camera.transform.eulerAngles);
         //rayTracer.SetVector("_LightVector", new Vector4(lightDirection.x, lightDirection.y, lightDirection.z, lightIntensity));
 
-        //rayTracer.SetBuffer(0, "_SphereBuffer", sphereBuffer);
+        rayTracer.SetBuffer(0, "_SphereBuffer", sphereBuffer);
         rayTracer.SetBuffer(0, "_meshObjects", meshObjectBuffer);
         rayTracer.SetBuffer(0, "_vertices", vertexBuffer);
         rayTracer.SetBuffer(0, "_indices", indexBuffer);
@@ -124,55 +127,17 @@ void OnRenderImage(RenderTexture source, RenderTexture destination)
 
         ReleaseBuffer();
     }
-    /*
+    
     struct Sphere
     {
         public Vector3 Position;
         public float Radius;
-        public Vector3 Specular;
-        public Vector3 Albedo;
-        public Vector3 Emission;
     };
-    
-    void SetUpGeometryBuffer()
-    {
-        List<Sphere> spheres = new List<Sphere>();
-
-        Sphere sphere;
-        sphere.Position = new Vector3(0, .5f, 0);
-        sphere.Radius = .5f;
-        sphere.Specular = new Vector3(0f, 0f, 0f);
-        sphere.Albedo = new Vector3(1f, 1f, 1f);
-        sphere.Emission = new Vector3(1f,1f,1f);
-
-        spheres.Add(sphere);
-
-        sphere.Position = new Vector3(4f, 2f, 1f);
-        sphere.Radius = 1f;
-        sphere.Specular = new Vector3(1f, 1f, 1f);
-        sphere.Albedo = new Vector3(0f, 0f, 0f);
-        sphere.Emission = new Vector3(0f, 0f, 0f);
-
-
-        spheres.Add(sphere);
-
-        sphere.Position = new Vector3(1f, 2f, 1f);
-        sphere.Radius = 1f;
-        sphere.Specular = new Vector3(0f, 0f, 0f);
-        sphere.Albedo = new Vector3(1f, 0f, 0f);
-        sphere.Emission = new Vector3(0f, 0f, 0f);
-
-
-        spheres.Add(sphere);
-
-        sphereBuffer = new ComputeBuffer(spheres.Count, 52);
-        sphereBuffer.SetData(spheres);
-    }
-    */
+   
     void OnEnable()
     {
         sampleNumber = 0;
-        //BuildMeshBuffer();
+        BuildMeshBuffer();
     }
 
     void Update()
@@ -323,6 +288,8 @@ private void BuildMeshBuffer()
 
             RayTracing.indices.AddRange(indicesOffset);
 
+            Matrix4x4 localToWorld = obj.gameObject.transform.localToWorldMatrix;
+
             meshObjects.Add(new MeshObject()
             {
                 localToWorldMatrix = obj.transform.localToWorldMatrix,
@@ -333,6 +300,12 @@ private void BuildMeshBuffer()
                 emission = obj.emission,
                 alpha = obj.alpha
             });
+
+            spheres.Add(new Sphere(){
+                Position = meshAverage(mesh, localToWorld),
+                Radius = 100000f
+                //Radius = meshRadius(mesh, localToWorld)
+            });
         }
 
         // Set-up the buffers.
@@ -348,5 +321,63 @@ private void BuildMeshBuffer()
         normalBuffer = new ComputeBuffer(normals.Count, 12);
         normalBuffer.SetData(normals);
 
+        sphereBuffer = new ComputeBuffer(spheres.Count, 16);
+        sphereBuffer.SetData(spheres);
+
+    }
+
+    
+
+    Vector3 meshAverage(Mesh mesh, Matrix4x4 localToWorld)
+    {
+        Vector3[] vertexList = mesh.vertices;
+
+        Vector3 average = Vector3.zero;
+        int count = 0;
+
+        foreach (Vector3 vertex in vertexList)
+        {
+            //print(vertex);
+            //localToWorld.MultiplyPoint3x4(mf.mesh.vertices[i]);
+            average += localToWorld.MultiplyPoint3x4(vertex);
+            count++;
+
+        }
+        //print(average);
+        return average / count;
+    }
+
+    float meshRadius(Mesh mesh, Matrix4x4 localToWorld)
+    {
+        Vector3[] vertexList = mesh.vertices;
+
+        float minX = 100000000000000;
+        float minY = 100000000000000;
+        float minZ = 100000000000000;
+        float maxX = 0;
+        float maxY = 0;
+        float maxZ = 0;
+
+        foreach (Vector3 vertexIt in vertexList)
+        {
+            Vector3 vertex = localToWorld.MultiplyPoint3x4(vertexIt);
+
+            if (vertex.x < minX) { minX = vertex.x; }
+            if (vertex.y < minY) { minY = vertex.y; }
+            if (vertex.z < minZ) { minY = vertex.z; }
+
+            if (vertex.x > maxX) { maxX = vertex.x; }
+            if (vertex.y > maxY) { maxY = vertex.y; }
+            if (vertex.z > maxZ) { maxZ = vertex.z; }
+        }
+
+        float radius = 0;
+
+        if (maxX - minX > radius) {radius = maxX - minX; }
+        if (maxY - minY > radius) {radius = maxY - minY; }
+        if (maxZ - minZ > radius) {radius = maxZ - minZ; }
+
+        return Mathf.Abs(radius);
     }
-}
+}
+

UnityProject/Assets/Scripts/SceneItems.hlsl

@@ -7,9 +7,9 @@ struct Sphere
 {
 	float3 position;
 	float radius;
-	float3 specular;
-	float3 albedo;
-	float3 emission;
+	//float3 specular;
+	//float3 albedo;
+	//float3 emission;
 };
 
 struct MeshObject