made scene a static global var

Author: keptsecret

31_HLSLPathTracer/app_resources/hlsl/render.comp.hlsl

@@ -6,9 +6,6 @@
 #include "nbl/builtin/hlsl/bxdf/reflection.hlsl"
 #include "nbl/builtin/hlsl/bxdf/transmission.hlsl"
 
-#include "render_common.hlsl"
-#include "pathtracer.hlsl"
-
 // add these defines (one at a time) using -D argument to dxc
 // #define SPHERE_LIGHT
 // #define TRIANGLE_LIGHT
@@ -17,10 +14,33 @@
 #ifdef SPHERE_LIGHT
 #define SPHERE_COUNT 9
 #define LIGHT_TYPE ext::PST_SPHERE
-#else
+
+#define TRIANGLE_COUNT 0
+#define RECTANGLE_COUNT 0
+#endif
+
+#ifdef TRIANGLE_LIGHT
+#define TRIANGLE_COUNT 1
+#define LIGHT_TYPE ext::PST_TRIANGLE
+
+#define SPHERE_COUNT 8
+#define RECTANGLE_COUNT 0
+#endif
+
+#ifdef RECTANGLE_LIGHT
+#define RECTANGLE_COUNT 1
+#define LIGHT_TYPE ext::PST_RECTANGLE
+
 #define SPHERE_COUNT 8
+#define TRIANGLE_COUNT 0
 #endif
 
+#define LIGHT_COUNT 1
+#define BXDF_COUNT 7
+
+#include "render_common.hlsl"
+#include "pathtracer.hlsl"
+
 using namespace nbl::hlsl;
 
 NBL_CONSTEXPR uint32_t WorkgroupSize = 32;
@@ -80,22 +100,21 @@ static const ext::Shape<ext::PST_SPHERE> spheres[SPHERE_COUNT] = {
 };
 
 #ifdef TRIANGLE_LIGHT
-#define LIGHT_TYPE ext::PST_TRIANGLE
-#define TRIANGLE_COUNT 1
 static const ext::Shape<ext::PST_TRIANGLE> triangles[TRIANGLE_COUNT] = {
     ext::Shape<ext::PST_TRIANGLE>::create(float3(-1.8,0.35,0.3) * 10.0, float3(-1.2,0.35,0.0) * 10.0, float3(-1.5,0.8,-0.3) * 10.0, bxdfnode_type::INVALID_ID, 0u)
 };
+#else
+static const ext::Shape<ext::PST_TRIANGLE> triangles[1];
 #endif
 
 #ifdef RECTANGLE_LIGHT
-#define LIGHT_TYPE ext::PST_RECTANGLE
-#define RECTANGLE_COUNT 1
 static const ext::Shape<ext::PST_RECTANGLE> rectangles[RECTANGLE_COUNT] = {
     ext::Shape<ext::PST_RECTANGLE>::create(float3(-3.8,0.35,1.3), normalize(float3(2,0,-1))*7.0, normalize(float3(2,-5,4))*0.1, bxdfnode_type::INVALID_ID, 0u)
 };
+#else
+static const ext::Shape<ext::PST_RECTANGLE> rectangles[1];
 #endif
 
-#define LIGHT_COUNT 1
 static const light_type lights[LIGHT_COUNT] = {
     light_type::create(spectral_t(30.0,25.0,15.0),
 #ifdef SPHERE_LIGHT
@@ -106,7 +125,6 @@ static const light_type lights[LIGHT_COUNT] = {
         ext::IntersectMode::IM_PROCEDURAL, LIGHT_TYPE)
 };
 
-#define BXDF_COUNT 7
 static const bxdfnode_type bxdfs[BXDF_COUNT] = {
     bxdfnode_type::create(ext::MaterialSystem::MaterialType::DIFFUSE, false, float2(0,0), spectral_t(0.8,0.8,0.8)),
     bxdfnode_type::create(ext::MaterialSystem::MaterialType::DIFFUSE, false, float2(0,0), spectral_t(0.8,0.4,0.4)),
@@ -117,6 +135,12 @@ static const bxdfnode_type bxdfs[BXDF_COUNT] = {
     bxdfnode_type::create(ext::MaterialSystem::MaterialType::DIELECTRIC, false, float2(0.0625,0.0625), spectral_t(1,1,1), spectral_t(0.71,0.69,0.67))
 };
 
+static const ext::Scene<light_type, bxdfnode_type> scene = ext::Scene<light_type, bxdfnode_type>::create(
+    spheres, triangles, rectangles,
+    SPHERE_COUNT, TRIANGLE_COUNT, RECTANGLE_COUNT,
+    lights, LIGHT_COUNT, bxdfs, BXDF_COUNT
+);
+
 [numthreads(WorkgroupSize, WorkgroupSize, 1)]
 void main(uint32_t3 threadID : SV_DispatchThreadID)
 {
@@ -164,32 +188,6 @@ void main(uint32_t3 threadID : SV_DispatchThreadID)
 
     pathtracer_type pathtracer = pathtracer_type::create(ptCreateParams);
 
-    // set up scene (can do as global var?)
-    ext::Scene<light_type, bxdfnode_type> scene;
-    scene.sphereCount = SPHERE_COUNT;
-    for (uint32_t i = 0; i < SPHERE_COUNT; i++)
-        scene.spheres[i] = spheres[i];
-#ifdef TRIANGLE_LIGHT
-    scene.triangleCount = TRIANGLE_COUNT;
-    for (uint32_t i = 0; i < TRIANGLE_COUNT; i++)
-        scene.triangles[i] = triangles[i];
-#else
-    scene.triangleCount = 0;
-#endif
-#ifdef RECTANGLE_LIGHT
-    scene.rectangleCount = RECTANGLE_COUNT;
-    for (uint32_t i = 0; i < RECTANGLE_COUNT; i++)
-        scene.rectangles[i] = rectangles[i];
-#else
-    scene.rectangleCount = 0;
-#endif
-    scene.lightCount = LIGHT_COUNT;
-    for (uint32_t i = 0; i < LIGHT_COUNT; i++)
-        scene.lights[i] = lights[i];
-    scene.bxdfCount = BXDF_COUNT;
-    for (uint32_t i = 0; i < BXDF_COUNT; i++)
-        scene.bxdfs[i] = bxdfs[i];
-
     float32_t3 color = pathtracer.getMeasure(pc.sampleCount, pc.depth, scene);
     float32_t4 pixCol = float32_t4(color, 1.0);
     outImage[coords] = pixCol;

31_HLSLPathTracer/app_resources/hlsl/scene.hlsl

@@ -15,31 +15,78 @@ struct Scene
 {
     using light_type = Light;
     using bxdfnode_type = BxdfNode;
+    using this_t = Scene<Light, BxdfNode>;
 
-    NBL_CONSTEXPR_STATIC_INLINE uint32_t maxSphereCount = 25;
-    NBL_CONSTEXPR_STATIC_INLINE uint32_t maxTriangleCount = 12;
-    NBL_CONSTEXPR_STATIC_INLINE uint32_t maxRectangleCount = 12;
+    // NBL_CONSTEXPR_STATIC_INLINE uint32_t maxSphereCount = 25;
+    // NBL_CONSTEXPR_STATIC_INLINE uint32_t maxTriangleCount = 12;
+    // NBL_CONSTEXPR_STATIC_INLINE uint32_t maxRectangleCount = 12;
 
-    Shape<PST_SPHERE> spheres[maxSphereCount];
-    Shape<PST_TRIANGLE> triangles[maxTriangleCount];
-    Shape<PST_RECTANGLE> rectangles[maxRectangleCount];
+#if SPHERE_COUNT < 1
+#define SCENE_SPHERE_COUNT 1
+#else
+#define SCENE_SPHERE_COUNT SPHERE_COUNT
+#endif
+
+#if TRIANGLE_COUNT < 1
+#define SCENE_TRIANGLE_COUNT 1
+#else
+#define SCENE_TRIANGLE_COUNT TRIANGLE_COUNT
+#endif
+
+#if RECTANGLE_COUNT < 1
+#define SCENE_RECTANGLE_COUNT 1
+#else
+#define SCENE_RECTANGLE_COUNT RECTANGLE_COUNT
+#endif
+
+    Shape<PST_SPHERE> spheres[SCENE_SPHERE_COUNT];
+    Shape<PST_TRIANGLE> triangles[SCENE_TRIANGLE_COUNT];
+    Shape<PST_RECTANGLE> rectangles[SCENE_RECTANGLE_COUNT];
 
     uint32_t sphereCount;
     uint32_t triangleCount;
     uint32_t rectangleCount;
 
-    NBL_CONSTEXPR_STATIC_INLINE uint32_t maxLightCount = 4;
+    // NBL_CONSTEXPR_STATIC_INLINE uint32_t maxLightCount = 4;
 
-    light_type lights[maxLightCount];
+    light_type lights[LIGHT_COUNT];
     uint32_t lightCount;
 
-    NBL_CONSTEXPR_STATIC_INLINE uint32_t maxBxdfCount = 16; // TODO: limit change?
+    // NBL_CONSTEXPR_STATIC_INLINE uint32_t maxBxdfCount = 16;
 
-    bxdfnode_type bxdfs[maxBxdfCount];
+    bxdfnode_type bxdfs[BXDF_COUNT];
     uint32_t bxdfCount;
 
     // AS ases;
 
+    static this_t create(
+        NBL_CONST_REF_ARG(Shape<PST_SPHERE>) spheres[SCENE_SPHERE_COUNT],
+        NBL_CONST_REF_ARG(Shape<PST_TRIANGLE>) triangles[SCENE_TRIANGLE_COUNT],
+        NBL_CONST_REF_ARG(Shape<PST_RECTANGLE>) rectangles[SCENE_RECTANGLE_COUNT],
+        uint32_t sphereCount, uint32_t triangleCount, uint32_t rectangleCount,
+        NBL_CONST_REF_ARG(light_type) lights[LIGHT_COUNT], uint32_t lightCount,
+        NBL_CONST_REF_ARG(bxdfnode_type) bxdfs[BXDF_COUNT], uint32_t bxdfCount)
+    {
+        this_t retval;
+        retval.spheres = spheres;
+        retval.triangles = triangles;
+        retval.rectangles = rectangles;
+        retval.sphereCount = sphereCount;
+        retval.triangleCount = triangleCount;
+        retval.rectangleCount = rectangleCount;
+
+        retval.lights = lights;
+        retval.lightCount = lightCount;
+
+        retval.bxdfs = bxdfs;
+        retval.bxdfCount = bxdfCount;
+        return retval;
+    }
+
+#undef SCENE_SPHERE_COUNT
+#undef SCENE_TRIANGLE_COUNT
+#undef SCENE_RECTANGLE_COUNT
+
     // obsolete?
     // Intersector::IntersectData toIntersectData(uint32_t mode, ProceduralShapeType type)
     // {