+ | Triangle intersection

shaders/compute.glsl

@@ -15,8 +15,8 @@ struct GPUObject {
 	float   radius;         // 4
 	vec3	normal;			// 12 + 4
 
-	vec3	edge1;			// 12 + 4
-	vec3	edge2;			// 12 + 4
+	vec3	vertex1;		// 12 + 4
+	vec3	vertex2;		// 12 + 4
 
 	int     type;           // 4
 };
@@ -109,9 +109,16 @@ vec3    pathtrace(Ray ray, inout uint rng_state)
 
 		GPUObject obj = objects[hit.obj_index];
 		
-		color *= obj.color;
+		// RR
+		float p = max(color.r, max(color.g, color.b));
+        if (randomValue(rng_state) > p)
+            break;
+        color /= p;
+		//
 
+		color *= obj.color;
 		light += obj.emission * obj.color;
+		
 		if (obj.emission > 0.0)
 			break;
 

shaders/intersect.glsl

@@ -31,23 +31,19 @@ bool intersectPlane(Ray ray, GPUObject obj, out hitInfo hit)
 
 bool intersectQuad(Ray ray, GPUObject obj, out hitInfo hit)
 {
-    // obj.edge1 and obj.edge2 are the two edge vectors from quad origin
-    vec3 normal = normalize(cross(obj.edge1, obj.edge2));
+    vec3 normal = normalize(cross(obj.vertex1, obj.vertex2));
     float d = dot(normal, ray.direction);
     float t = dot(obj.position - ray.origin, normal) / d;
 
     if (t <= 0.0 || d == 0.0) return (false);
     
-    // Get hit point relative to quad origin
     vec3 p = ray.origin + ray.direction * t - obj.position;
     
-    // Project hit point onto edges using dot product
-    float e1 = dot(p, obj.edge1);
-    float e2 = dot(p, obj.edge2);
+    float e1 = dot(p, obj.vertex1);
+    float e2 = dot(p, obj.vertex2);
     
-    // Check if point is inside quad using edge lengths
-    float l1 = dot(obj.edge1, obj.edge1);
-    float l2 = dot(obj.edge2, obj.edge2);
+    float l1 = dot(obj.vertex1, obj.vertex1);
+    float l2 = dot(obj.vertex2, obj.vertex2);
     
     bool inside = e1 >= 0.0 && e1 <= l1 && e2 >= 0.0 && e2 <= l2;
     
@@ -58,6 +54,60 @@ bool intersectQuad(Ray ray, GPUObject obj, out hitInfo hit)
     return (inside);
 }
 
+// bool intersectTriangle(Ray ray, GPUObject obj, out hitInfo hit)
+// {
+//     vec3 pvec = cross(ray.direction, obj.vertex2);
+//     float det = dot(obj.vertex1, pvec);
+//     vec3 tvec = ray.origin - obj.position;
+    
+//     float invDet = 1.0 / det;
+//     float u = dot(tvec, pvec) * invDet;
+//     vec3 qvec = cross(tvec, obj.vertex1);
+//     float v = dot(ray.direction, qvec) * invDet;
+//     float t = dot(obj.vertex2, qvec) * invDet;
+    
+//     bool valid = abs(det) > 1e-8 &&
+//                 u >= 0.0 && u <= 1.0 &&
+//                 v >= 0.0 && (u + v) <= 1.0 &&
+//                 t > 0.0;
+    
+//     hit.t = t;
+//     hit.position = ray.origin + ray.direction * t;
+//     hit.normal = obj.normal * sign(-dot(ray.direction, obj.normal));
+    
+//     return (valid);
+// }
+
+bool intersectTriangle(Ray ray, GPUObject obj, out hitInfo hit)
+{
+    vec3 pvec = cross(ray.direction, obj.vertex2);
+    float det = dot(obj.vertex1, pvec);
+    
+    if (abs(det) < 1e-8) return (false); // det < 0.0
+    
+    float invDet = 1.0 / det;
+    
+    vec3 tvec = ray.origin - obj.position;
+    
+    float u = dot(tvec, pvec) * invDet;
+    if (u < 0.0 || u > 1.0) return (false);
+    
+    vec3 qvec = cross(tvec, obj.vertex1);
+    float v = dot(ray.direction, qvec) * invDet;
+    if (v < 0.0 || u + v > 1.0) return (false);
+    
+    float t = dot(obj.vertex2, qvec) * invDet;
+    if (t <= 0.0) return (false);
+    
+    hit.t = t;
+    hit.position = ray.origin + ray.direction * t;
+    
+    vec3 normal = obj.normal;
+    hit.normal = dot(ray.direction, normal) < 0.0 ? normal : -normal;
+        
+    return (true);
+}
+
 bool intersect(Ray ray, GPUObject obj, out hitInfo hit)
 {
     if (obj.type == 0)
@@ -66,6 +116,8 @@ bool intersect(Ray ray, GPUObject obj, out hitInfo hit)
         return (intersectPlane(ray, obj, hit));
     if (obj.type == 2)
         return (intersectQuad(ray, obj, hit));
+    if (obj.type == 3)
+        return (intersectTriangle(ray, obj, hit));
 
     return (false);
 }

shaders/random.glsl

@@ -1,9 +1,9 @@
 float randomValue(inout uint rng_state)
 {
-	rng_state = rng_state * 747796405 + 2891336453;
-	uint result = ((rng_state >> ((rng_state >> 28) + 4)) ^ rng_state) * 277803737;
-	result = (result >> 22) ^ result;
-	return (result / 4294967295.0);
+	rng_state = rng_state * 747796405u + 2891336453u;
+	uint result = ((rng_state >> ((rng_state >> 28u) + 4u)) ^ rng_state) * 277803737u;
+	result = (result >> 22u) ^ result;
+	return (float(result) * (1.0 / 4294967295.0));
 }
 
 float randomValueNormalDistribution(inout uint rng_state)
@@ -25,4 +25,31 @@ vec3 randomHemisphereDirection(vec3 normal, inout uint rng_state)
 {
 	vec3 direction = randomDirection(rng_state);
 	return (direction * sign(dot(normal, direction)));
-}
+}
+
+#define M_PI 3.1415926535897932384626433832795
+
+// vec3 randomHemisphereDirection(vec3 normal, inout uint rng_state)
+// {
+//     float r1 = randomValue(rng_state);
+//     float r2 = randomValue(rng_state);
+    
+//     float phi = 2.0 * M_PI * r1;
+//     float cos_theta = sqrt(1.0 - r2);
+//     float sin_theta = sqrt(r2);
+    
+//     // Create orthonormal basis
+//     vec3 tangent, bitangent;
+//     if (abs(normal.x) > abs(normal.z)) {
+//         tangent = normalize(vec3(-normal.y, normal.x, 0.0));
+//     } else {
+//         tangent = normalize(vec3(0.0, -normal.z, normal.y));
+//     }
+//     bitangent = cross(normal, tangent);
+    
+//     return normalize(
+//         tangent * (cos(phi) * sin_theta) +
+//         bitangent * (sin(phi) * sin_theta) +
+//         normal * cos_theta
+//     );
+// }