BxDF tests #165

Przemog1 · 2024-12-30T12:54:39Z

No description provided.

devshgraphicsprogramming · 2025-01-06T08:51:06Z

why do you have random things from sorakrit here instead of your own branch against his or master ?

I literally can't see whats yours and what's @keptsecret's.

66_HLSLBxDFTests/app_resources/tests.hlsl

devshgraphicsprogramming · 2025-01-08T09:19:52Z

66_HLSLBxDFTests/app_resources/tests.hlsl

+        SBxDFTestResources retval;
+
+        retval.rng = nbl::hlsl::Xoroshiro64Star::construct(seed);
+        retval.u = float32_t3(rngFloat01(retval.rng), rngFloat01(retval.rng), 0.0);


the third random number is sometimes necessary to discern discrete BxDF branches:

reflection vs refraction in e.g. glass

diffuse vs specular in e.g. plastic

choosing a leaf BxDF in a mixture/tree of BxDFs

devshgraphicsprogramming · 2025-01-08T09:21:03Z

66_HLSLBxDFTests/app_resources/tests.hlsl

+    ray_dir_info_t dV(int axis)
+    {
+        float32_t3 d = (float32_t3)0.0;
+        d[axis] += h;
+        ray_dir_info_t retval;
+        retval.direction = V.direction + d;
+        return retval;
+    }
+
+    float h = 0.001;


what do you need dV for?

this is not the way to vary V parameter

devshgraphicsprogramming · 2025-01-08T09:33:51Z

66_HLSLBxDFTests/app_resources/tests.hlsl

+struct STestMeta
+{
+    float32_t4 result;
+#ifndef __HLSL_VERSION
+    std::string bxdfName;
+    std::string testName;
+#endif
+};


returning a result as a vec4 is quite a bit meh, I'd actually provide a callback (via static polymorphism) which is only called upon a failure

struct FailureCallbackConceptExample { void __call(NBL_CONST_REF_ARG(SBxDFTestResources) failedFor, NBL_CONST_REF_ARG(sample_t) failedAt); };

then you can print in C++, mark booleans, append to vector, break & repeat call or whatever

perfect C++ callback

printf(...your error message...); for (volatile bool repeat=true; gDebuggerAttached&&repeat; ) { repeat = false; // I can set to true with debugger and repeat as many times as I want till I find the cause __debugbreak(); failedFor.test(failedAt); }

devshgraphicsprogramming · 2025-01-08T09:40:00Z

66_HLSLBxDFTests/app_resources/tests.hlsl

@@ -78,6 +80,9 @@ struct SBxDFTestResources
    float32_t2 alpha;
    float eta;
    float32_t3x2 ior;
+
+    float32_t3 eta2;    // what is this?


eta squared, compute on the fly, don't leave stuff like this here

devshgraphicsprogramming · 2025-01-08T09:50:43Z

66_HLSLBxDFTests/app_resources/tests.hlsl

+        t.meta.result = t.test();
+        t.meta.testName = "u offset";
+        return t.meta;
+    }


setting those thousands of times will be expensive, function should be void and not return anything, callback instead of meta

devshgraphicsprogramming · 2025-01-08T09:54:35Z

66_HLSLBxDFTests/app_resources/tests.hlsl

+    static STestMeta run(uint32_t2 seed)
+    {
+        this_t t;
+        t.init(seed);


I'd make the function take uint32_t as an argument, then run a hash function (wide not deep)
https://rene.ruhr/gfx/gpuhash/

This will make it easy to invoke multiple run(uint32_t invocationID) in parallel independently, be it on CPU with for loop or GPU with gl_GlobalInvocationID.x

devshgraphicsprogramming · 2025-01-08T10:07:43Z

66_HLSLBxDFTests/app_resources/tests.hlsl

+template<class BxDF, bool aniso = false>
+struct TestVOffset : TestBxDF<BxDF>
+{
+    using base_t = TestBase<BxDF>;
+    using this_t = TestVOffset<BxDF, aniso>;
+
+    float32_t4 test()
+    {
+        sample_t s, sx, sy, sz;
+        quotient_pdf_t pdf;
+        float32_t3 brdf;
+        aniso_cache cache, dummy;
+
+        iso_interaction isointerx = iso_interaction::create(base_t::rc.dV(0), base_t::rc.N);
+        aniso_interaction anisointerx = aniso_interaction::create(isointerx, base_t::rc.T, base_t::rc.B);
+        iso_interaction isointery = iso_interaction::create(base_t::rc.dV(1), base_t::rc.N);
+        aniso_interaction anisointery = aniso_interaction::create(isointery, base_t::rc.T, base_t::rc.B);
+        iso_interaction isointerz = iso_interaction::create(base_t::rc.dV(2), base_t::rc.N);
+        aniso_interaction anisointerz = aniso_interaction::create(isointerz, base_t::rc.T, base_t::rc.B);


there's no point to this test existing, the test I've outlined ONLY makes sense for varying (differentiating) the 2D random number xi, because thats the uniform distribution that must be stretched and squeezed to form the PDF of the importance sampler

devshgraphicsprogramming · 2025-01-08T10:08:37Z

66_HLSLBxDFTests/main.cpp

+
+#include "app_resources/tests.hlsl"
+
+#define ASSERT_ZERO(x) (assert(all<bool32_t4>((x.result) < float32_t4(1e-3))));


use a nice callback

devshgraphicsprogramming · 2025-01-08T10:10:14Z

66_HLSLBxDFTests/main.cpp

+    const uint32_t2 state = uint32_t2(12u, 69u);    // (12u, 69u)
+
+    // test u offset, 2 axis
+    ASSERT_ZERO((TestUOffset<bxdf::reflection::SLambertianBxDF<sample_t, iso_interaction, aniso_interaction>>::run(state)));
+    ASSERT_ZERO((TestUOffset<bxdf::reflection::SOrenNayarBxDF<sample_t, iso_interaction, aniso_interaction>>::run(state)));
+    printResult(TestUOffset<bxdf::reflection::SBeckmannBxDF<sample_t, iso_cache, aniso_cache>,false>::run(state));
+    ASSERT_ZERO((TestUOffset<bxdf::reflection::SBeckmannBxDF<sample_t, iso_cache, aniso_cache>,true>::run(state)));
+    printResult(TestUOffset<bxdf::reflection::SGGXBxDF<sample_t, iso_cache, aniso_cache>,false>::run(state));
+    ASSERT_ZERO((TestUOffset<bxdf::reflection::SGGXBxDF<sample_t, iso_cache, aniso_cache>,true>::run(state)));
+
+    ASSERT_ZERO((TestUOffset<bxdf::transmission::SLambertianBxDF<sample_t, iso_interaction, aniso_interaction>>::run(state)));
+    printResult(TestUOffset<bxdf::transmission::SBeckmannDielectricBxDF<sample_t, iso_cache, aniso_cache>,false>::run(state));
+    ASSERT_ZERO((TestUOffset<bxdf::transmission::SBeckmannDielectricBxDF<sample_t, iso_cache, aniso_cache>,true>::run(state)));
+    printResult(TestUOffset<bxdf::transmission::SGGXDielectricBxDF<sample_t, iso_cache, aniso_cache>,false>::run(state));
+    printResult(TestUOffset<bxdf::transmission::SGGXDielectricBxDF<sample_t, iso_cache, aniso_cache>,true>::run(state));


you need to run the tests thousands of times with different seeds, I'd use for_each over a ranges::iota_view with par_unseq policy to perform these tests on all CPU cores at once.
https://godbolt.org/z/xvxE7jzE3

this connects with https://github.com/Devsh-Graphics-Programming/Nabla-Examples-and-Tests/pull/165/files#r1906914911

devshgraphicsprogramming · 2025-01-08T10:21:49Z

66_HLSLBxDFTests/app_resources/tests.hlsl

+        if NBL_CONSTEXPR_FUNC (is_basic_brdf_v<BxDF>)
+        {
+            s = base_t::bxdf.generate(base_t::anisointer, base_t::rc.u.xy);
+            sx = base_t::bxdf.generate(base_t::anisointer, base_t::rc.u.xy + float32_t2(base_t::rc.h,0));
+            sy = base_t::bxdf.generate(base_t::anisointer, base_t::rc.u.xy + float32_t2(0,base_t::rc.h));
+        }
+        if NBL_CONSTEXPR_FUNC (is_microfacet_brdf_v<BxDF>)
+        {
+            s = base_t::bxdf.generate(base_t::anisointer, base_t::rc.u.xy, cache);
+            sx = base_t::bxdf.generate(base_t::anisointer, base_t::rc.u.xy + float32_t2(base_t::rc.h,0), dummy);
+            sy = base_t::bxdf.generate(base_t::anisointer, base_t::rc.u.xy + float32_t2(0,base_t::rc.h), dummy);
+        }
+        if NBL_CONSTEXPR_FUNC (is_basic_bsdf_v<BxDF>)
+        {
+            s = base_t::bxdf.generate(base_t::anisointer, base_t::rc.u);
+            sx = base_t::bxdf.generate(base_t::anisointer, base_t::rc.u + float32_t3(base_t::rc.h,0,0));
+            sy = base_t::bxdf.generate(base_t::anisointer, base_t::rc.u + float32_t3(0,base_t::rc.h,0));
+        }
+        if NBL_CONSTEXPR_FUNC (is_microfacet_bsdf_v<BxDF>)
+        {
+            s = base_t::bxdf.generate(base_t::anisointer, base_t::rc.u, cache);
+            float32_t3 ux = base_t::rc.u + float32_t3(base_t::rc.h,0,0);
+            sx = base_t::bxdf.generate(base_t::anisointer, ux, dummy);
+            float32_t3 uy = base_t::rc.u + float32_t3(0,base_t::rc.h,0);
+            sy = base_t::bxdf.generate(base_t::anisointer, uy, dummy);
+        }


h should be a parameter of each individual specialized BxDF test, because its specific to the differential test and also may need to change depending on the BxDF getting tested

also maybe compute the perturbed u above for readability

devshgraphicsprogramming · 2025-01-08T10:25:42Z

66_HLSLBxDFTests/app_resources/tests.hlsl

+        float32_t2x2 m = float32_t2x2(sx.TdotL - s.TdotL, sy.TdotL - s.TdotL, sx.BdotL - s.BdotL, sy.BdotL - s.BdotL);
+        float det = nbl::hlsl::determinant<float32_t2x2>(m);
+
+        return float32_t4(nbl::hlsl::abs<float32_t3>(pdf.value() - brdf), nbl::hlsl::abs<float>(det*pdf.pdf/s.NdotL) * 0.5);


this needs to be done better semantically with a callback, one thing for each individually.

Alos pdf.value() does not equal brdf in general!!!!!

P.s. the *0.5 thing on the PDF to Jacobian ratio was a thing for visualization, you should really have a callback which gets triggered if the value is too far from 1.0

devshgraphicsprogramming · 2025-01-08T10:38:52Z

66_HLSLBxDFTests/app_resources/tests.hlsl

+        }
+


you need to skip checking anything that produces an "impossible" s, so if eval or quotient is 0, you can skip the rest of the function (but not before you check pdf and quotient for 0 and INF respectively - the checks also check for NaN)

add more simple tests for:

pdf>0 because something you generated cannot have 0 probability of getting generated

quotient<INF always because our importance sampler's job is to prevent that!

positivity, all pdf, quotient, and eval need to be >=0

recprocity (eval must be equal if we swap L and V around, make a method/function to swap L and V around in s, the interaction, the bxdf itself and the cache)

Leave lots of comments.

Also when pdf is close to INF (above some super high threshold) you need to back off the last test you have here

devshgraphicsprogramming · 2025-01-09T15:46:41Z

66_HLSLBxDFTests/app_resources/tests.hlsl

+        retval.V.direction = nbl::hlsl::normalize<float32_t3>(projected_hemisphere_generate<float>(rngUniformDist<float32_t2>(retval.rng)));
+        retval.N = nbl::hlsl::normalize<float32_t3>(projected_hemisphere_generate<float>(rngUniformDist<float32_t2>(retval.rng)));


not projected hemisphere, just hemisphere.

Also not hemisphere but full sphere, because its good to test that BRDFs handle invalid (below hemisphere) correctly

66_HLSLBxDFTests/app_resources/tests.hlsl

…ng/Nabla-Examples-and-Tests into bxdf_unit_tests

devshgraphicsprogramming · 2025-04-01T14:05:57Z

~~@keptsecret where's the branch with the HLSL and GLSL path tracer changes?~~

Found it #188

devshgraphicsprogramming · 2025-07-10T08:03:16Z

66_HLSLBxDFTests/app_resources/tests.hlsl

+
+// custom hash for float32_t2
+template<>
+struct std::hash<float32_t2>
+{
+    size_t operator()(const float32_t2& v) const noexcept
+    {
+        size_t v1 = std::hash<float32_t>()(v.x);
+        size_t v2 = std::hash<float32_t>()(v.y);
+        return v1 ^ (v2 << 1);
+    }
+};


make one in cpp_compat under __HLSL_VERSION note that we have our own hash_combine which is very similar to GLM's https://github.com/g-truc/glm/blob/master/glm/gtx/hash.inl

You can fairly easily make hash_helper which you can partial specialize for vectors and matrices of all types and dimensions

devshgraphicsprogramming · 2025-07-10T09:51:27Z

66_HLSLBxDFTests/app_resources/tests.hlsl

@@ -82,6 +105,46 @@ T rngUniformDist(NBL_REF_ARG(nbl::hlsl::Xoroshiro64Star) rng)
    return impl::RNGUniformDist<T>::__call(rng);


you already have an adapter for turning scalar rng into recursive, why are you using RNGUniformDist ?

devshgraphicsprogramming · 2025-07-10T09:52:30Z

66_HLSLBxDFTests/app_resources/tests.hlsl

+    return nbl::hlsl::all<vector<bool, vector_traits<T>::Dimension> >(nbl::hlsl::max<T>(a / b, b / a) <= (T)(1 + eps));
+}
+
+template<typename T>
+bool checkLt(T a, T b)
+{
+    return nbl::hlsl::all<vector<bool, vector_traits<T>::Dimension> >(a < b);
+}
+
+template<typename T>
+bool checkZero(T a, float32_t eps)
+{
+    return nbl::hlsl::all<vector<bool, vector_traits<T>::Dimension> >(nbl::hlsl::abs<T>(a) < (T)eps);


use promote not a C-cast check it everywhere

devshgraphicsprogramming · 2025-07-10T09:52:44Z

66_HLSLBxDFTests/app_resources/tests.hlsl

+#ifndef __HLSL_VERSION
+// because atan2 is not in tgmath.hlsl yet


atan2 should be there now

devshgraphicsprogramming · 2025-07-10T09:53:15Z

66_HLSLBxDFTests/app_resources/tests.hlsl

+// takes in normalized vectors
+inline float32_t3 polarToCartesian(float32_t2 theta_phi)
+{
+    return float32_t3(std::cos(theta_phi.y) * std::cos(theta_phi.x),
+                        std::sin(theta_phi.y) * std::cos(theta_phi.x),
+                        std::sin(theta_phi.x));
+}
+
+inline float32_t2 cartesianToPolar(float32_t3 coords)
+{
+    return float32_t2(std::acos(clamp<float>(coords.z, -1, 1)), std::atan2(coords.y, coords.x));
+}


make these into general utilities in nbl/builtin/hlsl/math

devshgraphicsprogramming · 2025-07-10T09:54:48Z

66_HLSLBxDFTests/app_resources/tests.hlsl

+template<typename T>
+bool checkEq(T a, T b, float32_t eps)
+{
+    return nbl::hlsl::all<vector<bool, vector_traits<T>::Dimension> >(nbl::hlsl::max<T>(a / b, b / a) <= (T)(1 + eps));


you need to take abs of a and b, otherwise quotient of a and b of differing signs will always be negative, no matter the max the result will be negative and always pass your inequality

devshgraphicsprogramming · 2025-07-10T10:05:11Z

66_HLSLBxDFTests/app_resources/tests.hlsl

+        float32_t3 tangent, bitangent;
+        math::frisvad<float32_t3>(retval.N, tangent, bitangent);
+        tangent = nbl::hlsl::normalize<float32_t3>(tangent);
+        bitangent = nbl::hlsl::normalize<float32_t3>(bitangent);
 #ifndef __HLSL_VERSION
        const float angle = 2 * numbers::pi<float> * rngUniformDist<float>(retval.rng);


use 2.f instead of 2 as the literal

devshgraphicsprogramming · 2025-07-10T10:18:04Z

66_HLSLBxDFTests/app_resources/tests.hlsl

@@ -113,8 +179,8 @@ struct SBxDFTestResources
        return retval;


eta is just a quotient of IoR, so it only makes sense to have one

furthermore you should generate a random eta between 0.4 and 2.5, but not too near 1.0

devshgraphicsprogramming · 2025-07-10T10:18:27Z

66_HLSLBxDFTests/app_resources/tests.hlsl

-    // epsilon
-    float eps = 1e-3;
+    float eps = 1e-3;   // epsilon
+    uint32_t state;     // init state seed, for debugging


isn't the seed for xoroshiro 64bit ?

devshgraphicsprogramming · 2025-07-10T10:20:45Z

66_HLSLBxDFTests/app_resources/tests.hlsl

-    is_same<T, bxdf::transmission::SBeckmannDielectricBxDF<sample_t, iso_cache, aniso_cache, spectral_t>>::value ||
-    is_same<T, bxdf::transmission::SGGXDielectricBxDF<sample_t, iso_cache, aniso_cache, spectral_t>>::value
+    is_same<T, bxdf::transmission::SBeckmannDielectricBxDF<sample_t, iso_interaction, aniso_interaction, iso_cache, aniso_cache, spectral_t>>::value ||
+    is_same<T, bxdf::transmission::SGGXDielectricBxDF<sample_t, iso_interaction, aniso_interaction, iso_cache, aniso_cache, spectral_t>>::value
 > {};

 template<class T>


there should be a general trait class in the nbl/builtin/hlsl/bxdf which tells us these things

btw what do you mean by basic ? I think you're checking just NOT microfacet.

devshgraphicsprogramming reviewed Jan 8, 2025

View reviewed changes

66_HLSLBxDFTests/app_resources/tests.hlsl Outdated Show resolved Hide resolved

devshgraphicsprogramming reviewed Jan 8, 2025

View reviewed changes

66_HLSLBxDFTests/app_resources/tests.hlsl Outdated Show resolved Hide resolved

devshgraphicsprogramming reviewed Jan 8, 2025

View reviewed changes

66_HLSLBxDFTests/app_resources/tests.hlsl Outdated Show resolved Hide resolved

devshgraphicsprogramming reviewed Jan 8, 2025

View reviewed changes

66_HLSLBxDFTests/app_resources/tests.hlsl Outdated Show resolved Hide resolved

devshgraphicsprogramming reviewed Jan 8, 2025

View reviewed changes

devshgraphicsprogramming reviewed Jan 9, 2025

View reviewed changes

devshgraphicsprogramming reviewed Jan 10, 2025

View reviewed changes

66_HLSLBxDFTests/app_resources/tests.hlsl Outdated Show resolved Hide resolved

keptsecret and others added 9 commits January 15, 2025 11:50

check util functions

3668d99

reciprocity test

a66dc44

negative value checks

b5d9778

Merge branch 'bxdf_unit_tests' of github.com:Devsh-Graphics-Programmi…

48cc64c

…ng/Nabla-Examples-and-Tests into bxdf_unit_tests

fix test orders

5df264a

Merge branch 'bxdf_unit_tests' of github.com:Devsh-Graphics-Programmi…

983efc3

…ng/Nabla-Examples-and-Tests into bxdf_unit_tests

use new param structs for bxdf funcs

e6e434a

print more info on error

d494e3d

Merge branch 'master' into bxdf_unit_tests

3305441

Przemog1 changed the title ~~New tgmath~~ BxDF tests Jan 20, 2025

fix reciprocity test, adjust comparison

3625ad2

keptsecret added 2 commits March 11, 2025 11:22

updated tests

a490635

Merge branch 'master' into bxdf_unit_tests

a2c84c2

keptsecret added 5 commits April 2, 2025 10:50

Merge branch 'master' into bxdf_unit_tests

01bfc9b

refactor changes in bxdf, sampling

3732687

use getters for interaction, samples

4864a45

use microfacet cache getters

9dc93dd

use new rng wrapper

6f3706a

devshgraphicsprogramming mentioned this pull request Apr 11, 2025

Hlsl bxdfs 2 Devsh-Graphics-Programming/Nabla#811

Closed

keptsecret added 11 commits April 14, 2025 10:59

refactor uniform2d usage

6d298fd

refactor quotient_pdf usage

dd7c0c7

refactor changes to aniso cache

9b071a6

added checking concepts work

61757af

uncommented shader compile test

2ae583f

refactor tests to quotient pdf changes

d4d94e6

refactor typedef changes in bxdfs

cf2dbcf

refactor changes to using bxdf params struct

c4a9602

Merge branch 'master' into bxdf_unit_tests

41d1111

fixes so it works on latest

a6de590

Merge branch 'master' into bxdf_unit_tests

c1493d6

devshgraphicsprogramming reviewed Jul 10, 2025

View reviewed changes


		#include "app_resources/tests.hlsl"

		#define ASSERT_ZERO(x) (assert(all<bool32_t4>((x.result) < float32_t4(1e-3))));

		retval.V.direction = nbl::hlsl::normalize<float32_t3>(projected_hemisphere_generate<float>(rngUniformDist<float32_t2>(retval.rng)));
		retval.N = nbl::hlsl::normalize<float32_t3>(projected_hemisphere_generate<float>(rngUniformDist<float32_t2>(retval.rng)));

		@@ -82,6 +105,46 @@ T rngUniformDist(NBL_REF_ARG(nbl::hlsl::Xoroshiro64Star) rng)
		return impl::RNGUniformDist<T>::__call(rng);

		#ifndef __HLSL_VERSION
		// because atan2 is not in tgmath.hlsl yet

BxDF tests #165

Are you sure you want to change the base?

BxDF tests #165

Conversation

Przemog1 commented Dec 30, 2024

Uh oh!

devshgraphicsprogramming commented Jan 6, 2025 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

devshgraphicsprogramming Jan 8, 2025 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

devshgraphicsprogramming Jan 8, 2025 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Uh oh!

devshgraphicsprogramming commented Apr 1, 2025 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Uh oh!

devshgraphicsprogramming commented Jan 6, 2025 •

edited

Loading

devshgraphicsprogramming Jan 8, 2025 •

edited

Loading

devshgraphicsprogramming Jan 8, 2025 •

edited

Loading

devshgraphicsprogramming commented Apr 1, 2025 •

edited

Loading