latest example

Author: keptsecret

.github/workflows/build-nabla.yml

@@ -569,7 +569,7 @@ jobs:
           $imageBadge | Set-Content -Path "$imagePath/image-badge.json" -Encoding utf8
 
       - name: Deploy Badges
-        uses: Devsh-Graphics-Programming/actions-gh-pages@v4.0.0-devsh.1
+        uses: peaceiris/actions-gh-pages@v3
         with:
           github_token: ${{ secrets.GITHUB_TOKEN }}
           publish_branch: badges

3rdparty/boost/superproject

@@ -276,7 +276,7 @@ class ICPUScene final : public IAsset, public IScene
                         instances.emplace_back().instance = std::move(inst);
                     }
                     // TODO: adjust BLAS geometry flags according to materials set opaqueness and NO_DUPLICATE_ANY_HIT_INVOCATION_BIT
-                    SResult retval = {.instances=core::make_refctd_dynamic_array<decltype(SResult::instances)>(instanceCount),.allInstancesValid=allInstancesValid};
+                    SResult retval = {.instances=core::make_refctd_dynamic_array<decltype(SResult::instances)>(instances.size()),.allInstancesValid=allInstancesValid};
                     std::move(instances.begin(),instances.end(),retval.instances->begin());
                     return retval;
                 }

examples_tests

@@ -16,6 +16,8 @@
 
 #include "nbl/builtin/hlsl/enums.hlsl"
 
+#include <functional>
+
 namespace nbl::asset
 {
 
@@ -136,6 +138,7 @@ class NBL_API2 IShaderCompiler : public core::IReferenceCounted
 			E_SPIRV_VERSION targetSpirvVersion = E_SPIRV_VERSION::ESV_1_6;
 			bool depfile = false;
 			system::path depfilePath = {};
+			std::function<void(std::string_view)> onPartialOutputOnFailure = {};
 		};
 
 		// https://github.com/microsoft/DirectXShaderCompiler/blob/main/docs/SPIR-V.rst#debugging

include/nbl/asset/ICPUScene.h

@@ -54,7 +54,7 @@ struct Unidirectional
         return hlsl::dot(spectralTypeToLumaCoeffs, col);
     }
 
-    bool closestHitProgram(uint16_t depth, uint32_t _sample, NBL_REF_ARG(ray_type) ray, NBL_CONST_REF_ARG(closest_hit_type) intersectData)
+    bool closestHitProgram(const bool lastBounce, uint16_t depth, uint32_t _sample, NBL_REF_ARG(ray_type) ray, NBL_CONST_REF_ARG(closest_hit_type) intersectData)
     {
         anisotropic_interaction_type interaction = intersectData.getInteraction();
 
@@ -76,7 +76,7 @@ struct Unidirectional
             ray.addPayloadContribution(emissive);
         }
 
-        if (!matLightID.canContinuePath())
+        if (lastBounce || !matLightID.canContinuePath())
             return false;
 
         bxdfnode_type bxdf = materialSystem.getBxDFNode(matID, interaction);
@@ -185,16 +185,17 @@ struct Unidirectional
         // bounces
         // note do 1-based indexing because we expect first dimension was consumed to generate the ray
         bool continuePath = true;
+        bool notMissed = true;
         for (uint16_t d = 1; (d <= maxDepth) && continuePath; d++)
         {
             ray.setT(numeric_limits<scalar_type>::max);
             closest_hit_type intersection = intersector_type::traceClosestHit(scene, ray);
 
-            continuePath = intersection.foundHit();
-            if (continuePath)
-                continuePath = closestHitProgram(d, sampleIndex, ray, intersection);
+            notMissed = intersection.foundHit();
+            if (notMissed)
+                continuePath = closestHitProgram(d==maxDepth, d, sampleIndex, ray, intersection);
         }
-        if (!continuePath)
+        if (!notMissed)
             missProgram(ray);
 
         const uint32_t sampleCount = sampleIndex + 1;

include/nbl/asset/material_compiler3/CFrontendIR.h

@@ -48,7 +48,8 @@ struct SphericalTriangle
         if (pyramidAngles())
             return 0.f;
 
-        // Both vertices and angles at the vertices are denoted by the same upper case letters A, B, and C. The angles A, B, C of the triangle are equal to the angles between the planes that intersect the surface of the sphere or, equivalently, the angles between the tangent vectors of the great circle arcs where they meet at the vertices. Angles are in radians. The angles of proper spherical triangles are (by convention) less than PI
+        // Both vertices and angles at the vertices are denoted by the same upper case letters A, B, and C. The angles A, B, C of the triangle are equal to the angles between the planes that intersect the surface of the sphere or,
+        // equivalently, the angles between the tangent vectors of the great circle arcs where they meet at the vertices. Angles are in radians. The angles of proper spherical triangles are (by convention) less than PI
         cos_vertices = hlsl::clamp((cos_sides - cos_sides.yzx * cos_sides.zxy) * csc_sides.yzx * csc_sides.zxy, hlsl::promote<vector3_type>(-1.0), hlsl::promote<vector3_type>(1.0)); // using Spherical Law of Cosines (TODO: do we need to clamp anymore? since the pyramid angles method introduction?) 
         sin_vertices = hlsl::sqrt(hlsl::promote<vector3_type>(1.0) - cos_vertices * cos_vertices);
 
@@ -64,7 +65,7 @@ struct SphericalTriangle
         return solidAngle(dummy0,dummy1);
     }
 
-    scalar_type projectedSolidAngle(const vector3_type receiverNormal, NBL_REF_ARG(vector3_type) cos_sides, NBL_REF_ARG(vector3_type) csc_sides, NBL_REF_ARG(vector3_type) cos_vertices)
+    scalar_type projectedSolidAngle(const vector3_type receiverNormal, NBL_REF_ARG(vector3_type) cos_vertices)
     {
         if (pyramidAngles())
             return 0.f;
@@ -75,10 +76,22 @@ struct SphericalTriangle
         awayFromEdgePlane[0] = hlsl::cross(vertices[1], vertices[2]) * csc_sides[0];
         awayFromEdgePlane[1] = hlsl::cross(vertices[2], vertices[0]) * csc_sides[1];
         awayFromEdgePlane[2] = hlsl::cross(vertices[0], vertices[1]) * csc_sides[2];
+        // The ABS makes it so that the computation is correct for an `abs(cos(theta))` factor which is the projected solid angle used for a BSDF
+        // Proof: Kelvin-Stokes theorem, if you split the set into two along the horizon with constant CCW winding, the `cross` along the shared edge goes in different directions and cancels out,
+        // while `acos` of the clipped great arcs corresponding to polygon edges add up to the original sides again
         const vector3_type externalProducts = hlsl::abs(hlsl::mul(/* transposed already */awayFromEdgePlane, receiverNormal));
 
+        // Far TODO: `cross(A,B)*acos(dot(A,B))/sin(1-dot^2)` can be done with `cross*acos_csc_approx(dot(A,B))`
+        // We could skip the `csc_sides` factor, and computing `pyramidAngles` and replace them with this approximation weighting before the dot product with the receiver notmal
+        // The curve fit "revealed in a dream" to me is `exp2(F(log2(x+1)))` where `F(u)` is a polynomial, so far I've calculated `F = (1-u)0.635+(1-u^2)0.0118` which gives <5% error until 165 degrees
+        // I have a feeling that a polynomial of ((Au+B)u+C)u+D could be sufficient if it has following properties:
+        // `F(0) = 0` and
+        // `F(u) <= log2(\frac{\cos^{-1}\left(2^{x}-1\right)}{\sqrt{1-\left(2^{x}-1\right)^{2}}})` because you want to consistently under-estimate the Projected Solid Angle to avoid creating energy
+        // See https://www.desmos.com/calculator/sdptomhbju
+        // Furthermore we could clip the polynomial calc to `Cu+D or `(Bu+C)u+D` for small arguments
         const vector3_type pyramidAngles = hlsl::acos<vector3_type>(cos_sides);
-        return hlsl::dot(pyramidAngles, externalProducts) / (2.f * numbers::pi<scalar_type>);
+        // So that riangle covering almost whole hemisphere sums to PI
+        return hlsl::dot(pyramidAngles, externalProducts) * scalar_type(0.5);
     }
 
     vector3_type vertices[3];

include/nbl/asset/utils/IShaderCompiler.h

@@ -87,6 +87,7 @@ struct SContext final
 #endif
 		core::smart_refctd_ptr<frontend_ir_t> frontIR;
 		// common frontend nodes
+		frontend_ir_t::typed_pointer_type<const frontend_ir_t::CSpectralVariable> unityFactor;
 		frontend_ir_t::typed_pointer_type<const frontend_ir_t::IExprNode> errorBRDF;
 		frontend_ir_t::typed_pointer_type<const frontend_ir_t::CLayer> errorMaterial, unsupportedPhong, unsupportedWard;
 		frontend_ir_t::typed_pointer_type<const frontend_ir_t::CDeltaTransmission> deltaTransmission;
@@ -95,6 +96,7 @@ struct SContext final
 		{
 			Albedo,
 			Opacity,
+			Weight,
 			MitsubaExtraFactor,
 			Count
 		};

include/nbl/builtin/hlsl/path_tracing/unidirectional.hlsl

@@ -157,10 +157,11 @@ bool CImageLoaderJPG::isALoadableFileFormat(system::IFile* _file, const system::
 	if (!_file)
 		return false;
 
-	uint32_t header = 0;	
+	uint16_t soiMarker = 0;	
 	system::IFile::success_t success;
-	_file->read(success, &header, 6, sizeof(uint32_t));
-	return success && ((header&0x00FFD8FFu)==0x00FFD8FFu || header == 0x4a464946 || header == 0x4649464a || header == 0x66697845u || header == 0x70747468u); // maybe 0x4a464946 can go
+	_file->read(success, &soiMarker, 0, sizeof(uint16_t));
+	constexpr auto JPEG_VALID_SOI_MARKER = 0xD8FF;
+	return success && (soiMarker == JPEG_VALID_SOI_MARKER);
 #endif
 }