robust ray origins (work out the transforms like PBRT does)

Author: devshgraphicsprogramming

examples_tests/22.RaytracedAO/Renderer.cpp

@@ -49,7 +49,7 @@ Renderer::Renderer(IVideoDriver* _driver, IAssetManager* _assetManager, scene::I
 	#ifdef _NBL_BUILD_OPTIX_
 		m_optixManager(), m_cudaStream(nullptr), m_optixContext(),
 	#endif
-		m_prevView(), m_sceneBound(FLT_MAX,FLT_MAX,FLT_MAX,-FLT_MAX,-FLT_MAX,-FLT_MAX),
+		m_prevView(), m_prevCamTform(), m_sceneBound(FLT_MAX,FLT_MAX,FLT_MAX,-FLT_MAX,-FLT_MAX,-FLT_MAX),
 		m_framesDispatched(0u), m_rcpPixelSize{0.f,0.f},
 		m_staticViewData{{0.f,0.f,0.f},0u,{0u,0u},0u,0u}, m_raytraceCommonData{vec3(),0.f,0u,0u,0u,0u},
 		m_indirectDrawBuffers{nullptr},m_cullPushConstants{core::matrix4SIMD(),1.f,0u,0u,0u},m_cullWorkGroups(0u),
@@ -1163,15 +1163,14 @@ void Renderer::render(nbl::ITimer* timer)
 
 	// check if camera moved
 	{
-		const auto currentView = camera->getViewMatrix();
-		auto properEquals = [](const auto& lhs, const auto& rhs) -> bool
+		auto properEquals = [](const core::matrix4x3& lhs, const core::matrix4x3& rhs) -> bool
 		{
 			const float rotationTolerance = 1.01f;
 			const float positionTolerance = 1.005f;
 			for (auto r=0; r<3u; r++)
 			for (auto c=0; c<4u; c++)
 			{
-				const float ratio = core::abs(rhs.rows[r][c]/lhs.rows[r][c]);
+				const float ratio = core::abs((&rhs.getColumn(c).X)[r]/(&lhs.getColumn(c).X)[r]);
 				// TODO: do by ULP
 				if (core::isnan(ratio) || core::isinf(ratio))
 					continue;
@@ -1181,17 +1180,15 @@ void Renderer::render(nbl::ITimer* timer)
 			}
 			return true;
 		};
-		if (!properEquals(currentView,m_prevView))
+		auto tform = camera->getRelativeTransformationMatrix();
+		if (!properEquals(tform,m_prevCamTform))
 		{
 			m_framesDispatched = 0u;		
-			m_prevView = currentView;
+			m_prevView = camera->getViewMatrix();
+			m_prevCamTform = tform;
 		}
 		else // need this to stop mouse cursor drift
-		{
-			core::matrix3x4SIMD invView;
-			m_prevView.getInverse(invView);
-			camera->setRelativeTransformationMatrix(invView.getAsRetardedIrrlichtMatrix());
-		}
+			camera->setRelativeTransformationMatrix(m_prevCamTform);
 	}
 
 	// TODO: update positions and rr->Commit() if stuff starts to move

examples_tests/22.RaytracedAO/Renderer.h

@@ -128,6 +128,7 @@ class Renderer : public nbl::core::IReferenceCounted, public nbl::core::Interfac
 		nbl::core::vector<::RadeonRays::Shape*> rrInstances;
 
 		nbl::core::matrix3x4SIMD m_prevView;
+		nbl::core::matrix4x3 m_prevCamTform;
 		nbl::core::aabbox3df m_sceneBound;
 		uint32_t m_framesDispatched;
 		vec2 m_rcpPixelSize;

examples_tests/22.RaytracedAO/raytraceCommon.glsl

@@ -290,13 +290,13 @@ for (uint i=1u; i!=vertex_depth; i++)
 	const uint baseOutputID = atomicAdd(rayCount[pc.cummon.rayCountWriteIx],raysToAllocate);
 
 	// TODO: improve
-	const vec3 error = vec3(0.0001f);// abs(origin)* uintBitsToFloat(0x35480005);
+	const vec3 error = vec3(0.01f);// abs(origin)* uintBitsToFloat(0x35480005);
 	uint offset = 0u;
 	for (uint i=0u; i<maxRaysToGen; i++)
 	if (maxT[i]!=0.f)
 	{
 		nbl_glsl_ext_RadeonRays_ray newRay;
-		newRay.origin = origin+direction[i]*0.002;// nbl_glsl_robust_ray_origin(origin, direction[i], error, normalizedN);
+		newRay.origin = nbl_glsl_robust_ray_origin(origin,direction[i],error,normalizedN);
 		newRay.maxT = maxT[i];
 		newRay.direction = direction[i];
 		newRay.time = packOutPixelLocation(outPixelLocation);

include/nbl/builtin/glsl/limits/numeric.glsl

@@ -69,14 +69,25 @@ float nbl_glsl_numeric_limits_float_epsilon()
 	return nbl_glsl_FLT_EPSILON;
 }
 
+
 float nbl_glsl_ieee754_gamma(float n)
 {
 	const float a = nbl_glsl_numeric_limits_float_epsilon(n);
 	return a/(1.f-a);
 }
+float nbl_glsl_ieee754_rcpgamma(float n)
+{
+	const float a = nbl_glsl_numeric_limits_float_epsilon(n);
+	return 1.f/a-1.f;
+}
+
 float nbl_glsl_ieee754_gamma(uint n)
 {
 	return nbl_glsl_ieee754_gamma(float(n));
 }
+float nbl_glsl_ieee754_rcpgamma(uint n)
+{
+	return nbl_glsl_ieee754_rcpgamma(float(n));
+}
 
 #endif

include/nbl/builtin/glsl/utils/transform.glsl

@@ -5,19 +5,56 @@
 #ifndef _NBL_BUILTIN_GLSL_UTILS_TRANSFORM_INCLUDED_
 #define _NBL_BUILTIN_GLSL_UTILS_TRANSFORM_INCLUDED_
 
+mat3 nbl_glsl_mul_with_bounds_wo_gamma(out mat3 error, in mat3 a, in mat3 b, in mat3 b_error)
+{
+    mat3 retval;
+    for (int i=0; i<3; i++)
+    {
+        vec3 tmp = a[0]*b[i][0];
+        retval[i] = tmp;
+        error[i] = abs(tmp);
+        vec3 additional_error = abs(a[0]*b_error[i][0]);
+        for (int j=1; j<3; j++)
+        {
+            tmp = a[j]*b[i][j];
+            retval[i] += tmp;
+            error[i] += abs(tmp);
+            additional_error += abs(a[j]*b_error[i][j]);
+        }
+        additional_error *= nbl_glsl_ieee754_rcpgamma(2u)+1.f;
+        error[i] += additional_error;
+    }
+    return retval;
+}
+mat3 nbl_glsl_mul_with_bounds_wo_gamma(out mat3 error, in mat3 a, in mat3 b)
+{
+    mat3 retval;
+    for (int i=0; i<3; i++)
+    {
+        vec3 tmp = a[0]*b[i][0];
+        retval[i] = tmp;
+        error[i] = abs(tmp);
+        for (int j=1; j<3; j++)
+        {
+            tmp = a[j]*b[i][j];
+            retval[i] += tmp;
+            error[i] += abs(tmp);
+        }
+    }
+    return retval;
+}
+
 mat3 nbl_glsl_mul_with_bounds(out mat3 error, in mat3 a, in mat3 b, in mat3 b_error)
 {
-    // error = abs(tform[0]*positions.x)+abs(tform[1]*positions.y)+abs(tform[2]*positions.z);
-    // error *= nbl_glsl_ieee754_gamma(2u);
-    return a*b;
+    return nbl_glsl_mul_with_bounds_wo_gamma(error,a,b,b_error);
 }
+
 mat3 nbl_glsl_mul_with_bounds(out mat3 error, in mat3 a, in mat3 b)
 {
-    // error = abs(tform[0]*positions.x)+abs(tform[1]*positions.y)+abs(tform[2]*positions.z);
-    // error *= nbl_glsl_ieee754_gamma(2u);
-    return a*b;
+    return nbl_glsl_mul_with_bounds_wo_gamma(error,a,b);
 }
 
+
 vec4 nbl_glsl_pseudoMul4x4with3x1(in mat4 m, in vec3 v)
 {
     return m[0] * v.x + m[1] * v.y + m[2] * v.z + m[3];