HLSL path tracer example (new pr) #959

keptsecret · 2025-12-02T10:05:20Z

replaces #947

devshgraphicsprogramming · 2025-12-04T10:16:41Z

include/nbl/builtin/hlsl/sampling/basic.hlsl

+
+    bool operator()(floating_point_type leftProb, NBL_REF_ARG(floating_point_type) xi, NBL_REF_ARG(floating_point_type) rcpChoiceProb)
+    {
+        const floating_point_type NEXT_ULP_AFTER_UNITY = bit_cast<floating_point_type>(bit_cast<uint_type>(floating_point_type(1.0)) + uint_type(1u));


nitpick, renane to NextULPAfterUnity upper snake case we reserve for macros

devshgraphicsprogramming · 2025-12-04T10:16:58Z

include/nbl/builtin/hlsl/sampling/basic.hlsl

+struct PartitionRandVariable
+{
+    using floating_point_type = T;
+    using uint_type = typename unsigned_integer_of_size<sizeof(floating_point_type)>::type;


nitpick, don't we have a _t suffixed alias

devshgraphicsprogramming · 2025-12-04T10:22:30Z

include/nbl/builtin/hlsl/sampling/basic.hlsl

+    using floating_point_type = T;
+    using uint_type = typename unsigned_integer_of_size<sizeof(floating_point_type)>::type;
+
+    bool operator()(floating_point_type leftProb, NBL_REF_ARG(floating_point_type) xi, NBL_REF_ARG(floating_point_type) rcpChoiceProb)


leftProb should be a member, not a argument, why? I can draw multiple times with multiple xi but same leftProb

devshgraphicsprogramming · 2025-12-04T10:25:05Z

include/nbl/builtin/hlsl/sampling/linear.hlsl

+    using scalar_type = T;
+    using vector2_type = vector<T, 2>;
+
+    static Linear<T> create(NBL_CONST_REF_ARG(vector2_type) linearCoeffs)   // start and end importance values (start, end)


const is enough for vector types

devshgraphicsprogramming · 2025-12-04T10:27:06Z

include/nbl/builtin/hlsl/sampling/linear.hlsl

+        retval.linearCoeffStart = linearCoeffs[0];
+        retval.rcpDiff = 1.0 / (linearCoeffs[0] - linearCoeffs[1]);
+        vector2_type squaredCoeffs = linearCoeffs * linearCoeffs;
+        retval.squaredCoeffStart = squaredCoeffs[0];
+        retval.squaredCoeffDiff = squaredCoeffs[1] - squaredCoeffs[0];


you actually want to compute rcpDiff first

Also leave a TODO that we should probably pre-multiply linearCoeffs by rcpDiff so that we have less registers/live-variables to use

and linearCoeffStart, squaredCoeffStart and quaredCoeffDiff would already have rcpDiff inside them.

Trading 1 less register for 1 more MUL

P.S. then the mix condition would then be abs(linearCoeffStartOverDiff) < max

devshgraphicsprogramming · 2025-12-04T11:26:05Z

include/nbl/builtin/hlsl/shapes/spherical_triangle.hlsl

+        retval.vertex1 = nbl::hlsl::normalize(vertex1 - origin);
+        retval.vertex2 = nbl::hlsl::normalize(vertex2 - origin);
+        retval.cos_sides = vector3_type(hlsl::dot(retval.vertex1, retval.vertex2), hlsl::dot(retval.vertex2, retval.vertex0), hlsl::dot(retval.vertex0, retval.vertex1));
+        const vector3_type csc_sides2 = hlsl::promote<vector3_type>(1.0) - retval.cos_sides * retval.cos_sides;


nitpict, this is sin2_sides it becomes a cosecant when you do the rsqrt

devshgraphicsprogramming · 2025-12-04T11:26:33Z

include/nbl/builtin/hlsl/shapes/spherical_triangle.hlsl

+    bool pyramidAngles()
+    {
+        return hlsl::any<vector<bool, 3> >(csc_sides >= (vector3_type)(numeric_limits<scalar_type>::max));
+    }


comment, what does pyramicAngles() mean ?

devshgraphicsprogramming · 2025-12-04T11:29:16Z

include/nbl/builtin/hlsl/shapes/spherical_triangle.hlsl

+        return hlsl::any<vector<bool, 3> >(csc_sides >= (vector3_type)(numeric_limits<scalar_type>::max));
+    }
+
+    scalar_type solidAngleOfTriangle(NBL_REF_ARG(vector3_type) cos_vertices, NBL_REF_ARG(vector3_type) sin_vertices, NBL_REF_ARG(scalar_type) cos_a, NBL_REF_ARG(scalar_type) cos_c, NBL_REF_ARG(scalar_type) csc_b, NBL_REF_ARG(scalar_type) csc_c)


I don't need cos_a, cos_c, csc_b, csc_c as output arguments, I can simply steam them from the members if I wish

devshgraphicsprogramming · 2025-12-04T11:32:16Z

include/nbl/builtin/hlsl/shapes/spherical_triangle.hlsl

+        vector3_type awayFromEdgePlane0 = hlsl::cross<vector3_type>(vertex1, vertex2) * csc_sides[0];
+        vector3_type awayFromEdgePlane1 = hlsl::cross<vector3_type>(vertex2, vertex0) * csc_sides[1];
+        vector3_type awayFromEdgePlane2 = hlsl::cross<vector3_type>(vertex0, vertex1) * csc_sides[2];
+
+        // useless here but could be useful somewhere else
+        cos_vertices[0] = hlsl::dot<vector3_type>(awayFromEdgePlane1, awayFromEdgePlane2);
+        cos_vertices[1] = hlsl::dot<vector3_type>(awayFromEdgePlane2, awayFromEdgePlane0);
+        cos_vertices[2] = hlsl::dot<vector3_type>(awayFromEdgePlane0, awayFromEdgePlane1);
+        // TODO: above dot products are in the wrong order, either work out which is which, or try all 6 permutations till it works
+        cos_vertices = hlsl::clamp<vector3_type>((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));


you're overwriting them anyway, whats the point of computing awayfromEdgePlane and cos_vertices above?

devshgraphicsprogramming · 2025-12-04T11:34:12Z

include/nbl/builtin/hlsl/shapes/spherical_triangle.hlsl

+namespace util
+{
+  // Use this convetion e_i = v_{i+2}-v_{i+1}. vertex index is modulo by 3.
+  template <typename float_t>
+  vector<float_t, 3> compInternalAngle(NBL_CONST_REF_ARG(vector<float_t, 3>) e0, NBL_CONST_REF_ARG(vector<float_t, 3>) e1, NBL_CONST_REF_ARG(vector<float_t, 3>) e2)
+  {
+    // Calculate this triangle's weight for each of its three m_vertices
+    // start by calculating the lengths of its sides
+    const float_t a = hlsl::dot(e0, e0);
+    const float_t asqrt = hlsl::sqrt(a);
+    const float_t b = hlsl::dot(e1, e1);
+    const float_t bsqrt = hlsl::sqrt(b);
+    const float_t c = hlsl::dot(e2, e2);
+    const float_t csqrt = hlsl::sqrt(c);
+
+    const float_t angle0 = hlsl::acos((b + c - a) / (2.f * bsqrt * csqrt));
+    const float_t angle1 = hlsl::acos((-b + c + a) / (2.f * asqrt * csqrt));
+    const float_t angle2 = hlsl::numbers::pi<float_t> - (angle0 + angle1);
+    // use them to find the angle at each vertex
+    return vector<float_t, 3>(angle0, angle1, angle2);
+  }
+}
+
+}


what is this used for? and why is it in the spherical_triangle.hlsl ?

its clearly for a cartesian/euclidean triangle thats flat!

devshgraphicsprogramming · 2025-12-04T11:36:06Z

include/nbl/builtin/hlsl/shapes/triangle.hlsl

-namespace util
-{
-  // Use this convetion e_i = v_{i+2}-v_{i+1}. vertex index is modulo by 3.
-  template <typename float_t>
-  vector<float_t, 3> compInternalAngle(NBL_CONST_REF_ARG(vector<float_t, 3>) e0, NBL_CONST_REF_ARG(vector<float_t, 3>) e1, NBL_CONST_REF_ARG(vector<float_t, 3>) e2)
-  {
-    // Calculate this triangle's weight for each of its three m_vertices
-    // start by calculating the lengths of its sides
-    const float_t a = hlsl::dot(e0, e0);
-    const float_t asqrt = hlsl::sqrt(a);
-    const float_t b = hlsl::dot(e1, e1);
-    const float_t bsqrt = hlsl::sqrt(b);
-    const float_t c = hlsl::dot(e2, e2);
-    const float_t csqrt = hlsl::sqrt(c);
-
-    const float_t angle0 = hlsl::acos((b + c - a) / (2.f * bsqrt * csqrt));
-    const float_t angle1 = hlsl::acos((-b + c + a) / (2.f * asqrt * csqrt));
-    const float_t angle2 = hlsl::numbers::pi<float_t> - (angle0 + angle1);
-    // use them to find the angle at each vertex
-    return vector<float_t, 3>(angle0, angle1, angle2);
-  }
-}


this should have stayed here, also awful name InternalAngle but of what ? a Pentagon!?

please change the name to anglesFromTriangleEdge and make sure the smooth normal compute still works

devshgraphicsprogramming · 2025-12-04T12:08:09Z

include/nbl/builtin/hlsl/shapes/spherical_triangle.hlsl

+        return angle_adder.getSumofArccos() - numbers::pi<scalar_type>;
+    }
+
+    scalar_type solidAngleOfTriangle()


also OfTriangle in the name of the method is a tautology

devshgraphicsprogramming · 2025-12-04T13:27:18Z

include/nbl/builtin/hlsl/rwmc/CascadeAccumulator.hlsl

+    cascade_layer_scalar_type getLuma(NBL_CONST_REF_ARG(CascadeLayerType) col)
+    {
+        return hlsl::dot<CascadeLayerType>(hlsl::transpose(colorspace::scRGBtoXYZ)[1], col);
+    }


this should be a method of the SplattingParameters

devshgraphicsprogramming · 2025-12-04T13:28:15Z

include/nbl/builtin/hlsl/rwmc/CascadeAccumulator.hlsl

+        const cascade_layer_scalar_type log2Base = unpackedParams[1];
+        const cascade_layer_scalar_type luma = getLuma(_sample);
+        const cascade_layer_scalar_type log2Luma = log2<cascade_layer_scalar_type>(luma);
+        const cascade_layer_scalar_type cascade = log2Luma * 1.f / log2Base - log2Start / log2Base;


its okay to write this as (log2Luma-log2Start)/log2Base

actually your splatting parameter should store rcpLog2Base and baseRootOfStart

devshgraphicsprogramming · 2025-12-04T13:29:56Z

include/nbl/builtin/hlsl/rwmc/CascadeAccumulator.hlsl

+        const float32_t2 unpackedParams = hlsl::unpackHalf2x16(splattingParameters.packedLog2);
+        const cascade_layer_scalar_type log2Start = unpackedParams[0];
+        const cascade_layer_scalar_type log2Base = unpackedParams[1];
+        const cascade_layer_scalar_type luma = getLuma(_sample);
+        const cascade_layer_scalar_type log2Luma = log2<cascade_layer_scalar_type>(luma);
+        const cascade_layer_scalar_type cascade = log2Luma * 1.f / log2Base - log2Start / log2Base;
+        const cascade_layer_scalar_type clampedCascade = clamp(cascade, 0, CascadeCount - 1);
+        // c<=0 -> 0, c>=Count-1 -> Count-1 
+        uint32_t lowerCascadeIndex = floor<cascade_layer_scalar_type>(cascade);
+        // 0 whenever clamped or `cascade` is integer (when `clampedCascade` is integer)
+        cascade_layer_scalar_type higherCascadeWeight = clampedCascade - floor<cascade_layer_scalar_type>(clampedCascade);
+        // never 0 thanks to magic of `1-fract(x)`
+        cascade_layer_scalar_type lowerCascadeWeight = cascade_layer_scalar_type(1) - higherCascadeWeight;


all this computation should be done in SplattingParameters::scalar_t

Also make the lowerCascadeIndex a uint16_t

devshgraphicsprogramming · 2025-12-04T13:31:26Z

include/nbl/builtin/hlsl/rwmc/CascadeAccumulator.hlsl

+        if (cascade > CascadeCount - 1)
+            lowerCascadeWeight = exp2(log2Start + log2Base * (CascadeCount - 1) - log2Luma);


wrap the CascadeCount-1 in a _static_cast<SplattingParameters::scalar_t> so we get no conversion/comparison warnings.

Actually declare a const SplattingParameters::scalar_t LastCascade = CascadeCount-1 to use throughout

devshgraphicsprogramming · 2025-12-04T13:37:27Z

include/nbl/builtin/hlsl/rwmc/CascadeAccumulator.hlsl

+    using output_storage_type = CascadeEntry;
+    using initialization_data = SplattingParameters;
+    output_storage_type accumulation;


I don't get the need for extra typedefs here, I get that an alias of CascadeLayerType is needed, but not the rest

Although after you do https://github.com/Devsh-Graphics-Programming/Nabla/pull/959/files#r2589131299 then they may be needed (except for initialization_data alias)

devshgraphicsprogramming · 2025-12-04T13:39:11Z

include/nbl/builtin/hlsl/rwmc/CascadeAccumulator.hlsl

+        uint32_t cascadeSampleCounter[CascadeCount];
+        CascadeLayerType data[CascadeCount];
+
+        void addSampleIntoCascadeEntry(CascadeLayerType _sample, uint32_t lowerCascadeIndex, float lowerCascadeLevelWeight, float higherCascadeLevelWeight, uint32_t sampleCount)


you want the weights to be same type as SplattingParameters::scalar_t

devshgraphicsprogramming · 2025-12-04T13:40:22Z

include/nbl/builtin/hlsl/rwmc/CascadeAccumulator.hlsl

+    struct CascadeEntry
+    {
+        uint32_t cascadeSampleCounter[CascadeCount];
+        CascadeLayerType data[CascadeCount];
+
+        void addSampleIntoCascadeEntry(CascadeLayerType _sample, uint32_t lowerCascadeIndex, float lowerCascadeLevelWeight, float higherCascadeLevelWeight, uint32_t sampleCount)


you can pull the CascadeEntry (can rename to DefaultCascades) outside of CascadeAccumulator just to allow it to be templated on both CascadeLayerType and SampleCountType (should default to uint16_t instead of uint32_t)

then the CascadeAccumulator would be templated only on the CascadesType

I know I told przemek to put it inside before, but now I realize we can mess around with the types of more things

See the rationale for this : #936 (comment)

devshgraphicsprogramming · 2025-12-04T13:44:25Z

include/nbl/builtin/hlsl/rwmc/CascadeAccumulator.hlsl

+            retval.accumulation.data[i] = promote<CascadeLayerType, float32_t>(0.0f);
+            retval.accumulation.cascadeSampleCounter[i] = 0u;


better to require the accumulation ( CascadesType::clear(cascadeIx)) has a clear method than poke members directly

devshgraphicsprogramming · 2025-12-04T13:50:31Z

include/nbl/builtin/hlsl/rwmc/resolve.hlsl

+		// declare concept
+#define NBL_CONCEPT_NAME ResolveAccessorBase
+#define NBL_CONCEPT_TPLT_PRM_KINDS (typename)(typename)(int32_t)
+#define NBL_CONCEPT_TPLT_PRM_NAMES (T)(VectorScalarType)(Dims)
+// not the greatest syntax but works
+#define NBL_CONCEPT_PARAM_0 (a,T)
+#define NBL_CONCEPT_PARAM_1 (scalar,VectorScalarType)
+// start concept
+	NBL_CONCEPT_BEGIN(2)
+// need to be defined AFTER the concept begins
+#define a NBL_CONCEPT_PARAM_T NBL_CONCEPT_PARAM_0
+#define scalar NBL_CONCEPT_PARAM_T NBL_CONCEPT_PARAM_1
+NBL_CONCEPT_END(
+	((NBL_CONCEPT_REQ_EXPR)((a.calcLuma(vector<VectorScalarType, 3>(scalar, scalar, scalar)))))
+);
+#undef a
+#undef scalar
+#include <nbl/builtin/hlsl/concepts/__end.hlsl>


this should be a more generic concept because this is what I want SplattingParameters to be checked for when its used with `CascadeAccumulator

it should check that T::scalar_t (which is a FloatingPointScalar) and a templated (on the sample type) calcLuma which does not necessarily enforce that the sample type is a vector<T,3>

don't take a Dims template parameter, you should only have two

devshgraphicsprogramming · 2025-12-04T13:51:40Z

include/nbl/builtin/hlsl/rwmc/resolve.hlsl

+	using output_type = vector<OutputScalar, 4>;
+	NBL_CONSTEXPR int32_t image_dimension = 2;
+
+	RWTexture2DArray<float32_t4> cascade;


you can't store a texture as a local variable in DXC, it really doesn't like it, they need to be declared by the user on the fly

this unfortunately always need to be user-space and the texture declaration needs to be a global

devshgraphicsprogramming · 2025-12-04T14:01:35Z

include/nbl/builtin/hlsl/rwmc/resolve.hlsl

+	float32_t calcLuma(NBL_REF_ARG(float32_t3) col)
+	{
+		return hlsl::dot<float32_t3>(colorspace::scRGB::ToXYZ()[1], col);
+	}


ok SplattingParameters should inherit from a BaseParameters that defines scalar_t, and calcLuma this stuff obviously need to be shared

devshgraphicsprogramming · 2025-12-04T14:04:14Z

include/nbl/builtin/hlsl/rwmc/resolve.hlsl

+	using output_scalar_type = OutputScalar;
+	using output_type = vector<OutputScalar, 4>;


I'd advise for the output type to already have the correct number of components

devshgraphicsprogramming · 2025-12-04T14:05:50Z

include/nbl/builtin/hlsl/rwmc/resolve.hlsl

+template<typename T, typename VectorScalarType, int32_t Dims>
+NBL_BOOL_CONCEPT ResolveAccessor = ResolveAccessorBase<T, VectorScalarType, Dims> && concepts::accessors::LoadableImage<T, VectorScalarType, Dims>;


ok we definitely need to extend the LoadableImage concept with a final template argument which is the number of components (so they don't always load vector<T,4>)

devshgraphicsprogramming · 2025-12-04T14:06:46Z

include/nbl/builtin/hlsl/rwmc/resolve.hlsl

+template<typename CascadeAccessor, typename OutputColorTypeVec NBL_PRIMARY_REQUIRES(concepts::Vector<OutputColorTypeVec> && ResolveAccessor<CascadeAccessor, typename CascadeAccessor::output_scalar_type, CascadeAccessor::image_dimension>)
+struct Resolver
+{
+	using output_type = OutputColorTypeVec;
+	using scalar_t = typename vector_traits<output_type>::scalar_type;


template only on the CascadeAccessor, require the CascadeAccessor to have an output_t alias

also template on the cascade count

devshgraphicsprogramming · 2025-12-04T14:37:39Z

include/nbl/builtin/hlsl/rwmc/ResolveParameters.hlsl

+ResolveParameters computeResolveParameters(float base, uint32_t sampleCount, float minReliableLuma, float kappa, uint32_t cascadeSize)
+{


not cascadeSize, but cascadeCount , also it should really just be a template parameter on the Resolver, the loops really need to be unrolled and its something you can set up at compile time no problem

Finally this should have been static create factory inside the struct.

keptsecret added 30 commits February 4, 2025 14:16

initial example

02d6d0f

use bxdf creation params struct

129b50e

triangle and rectangle shapes

74261dc

more sampling methods

ab3ae20

spherical rectangle

355cfec

merge pcg fix from upstream

ebf8fca

fix aniso cache bug

11180f4

init func to modify bxdf params directly

4516051

bug fixes

d9a00c9

fix sampling bugs #2

ffe9029

update to master

cee192e

fix rank type trait for matrix/vector

b207312

merge hlsl bxdfs, resolve conflict

673f788

temporary fix for dxc bug issue 7154

69a257d

some bug fixes again

866e6d7

fix wrong template usage

85e955f

merge changes from hlsl_bxdf

3b167ab

merge master/bxdf fixes, resolve conflicts

19e3a35

Merge branch 'hlsl_bxdfs' into hlsl_path_tracer_example

6b5bf06

Merge branch 'hlsl_bxdfs' into hlsl_path_tracer_example

7b574da

fix typo

1c773d9

Merge branch 'hlsl_bxdfs' into hlsl_path_tracer_example

326c885

Merge branch 'revert-some-device-limits' into hlsl_path_tracer_example

6132a4e

Merge branch 'master' into hlsl_path_tracer_example

0bd26c7

Merge branch 'hlsl_bxdfs' into hlsl_path_tracer_example

ebb1b15

Merge branch 'hlsl_bxdfs' into hlsl_path_tracer_example

7cb977d

Merge branch 'master' into hlsl_path_tracer_example

67c525e

Merge branch 'hlsl_bxdfs' into hlsl_path_tracer_example

a8f209e

fixed some func usage to nbl ver

e8d2ed8

specify template args

c47f446

devshgraphicsprogramming reviewed Dec 4, 2025

View reviewed changes

keptsecret added 3 commits December 5, 2025 14:04

fixes more nan problems + a few bugs in iridescent fresnel

6971906

fixes iridescent fresnel under transmission

cb68928

fix wrong get refraction eta in iridescent transmission

76ed66c

		if (cascade > CascadeCount - 1)
		lowerCascadeWeight = exp2(log2Start + log2Base * (CascadeCount - 1) - log2Luma);

		retval.accumulation.data[i] = promote<CascadeLayerType, float32_t>(0.0f);
		retval.accumulation.cascadeSampleCounter[i] = 0u;

		using output_scalar_type = OutputScalar;
		using output_type = vector<OutputScalar, 4>;

		template<typename T, typename VectorScalarType, int32_t Dims>
		NBL_BOOL_CONCEPT ResolveAccessor = ResolveAccessorBase<T, VectorScalarType, Dims> && concepts::accessors::LoadableImage<T, VectorScalarType, Dims>;

		ResolveParameters computeResolveParameters(float base, uint32_t sampleCount, float minReliableLuma, float kappa, uint32_t cascadeSize)
		{

HLSL path tracer example (new pr) #959

Are you sure you want to change the base?

HLSL path tracer example (new pr) #959

Conversation

keptsecret commented Dec 2, 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!

devshgraphicsprogramming Dec 4, 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!

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 Dec 4, 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!

devshgraphicsprogramming Dec 4, 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!

devshgraphicsprogramming Dec 4, 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

keptsecret commented Dec 2, 2025 •

edited

Loading

devshgraphicsprogramming Dec 4, 2025 •

edited

Loading

devshgraphicsprogramming Dec 4, 2025 •

edited

Loading

devshgraphicsprogramming Dec 4, 2025 •

edited

Loading

devshgraphicsprogramming Dec 4, 2025 •

edited

Loading