Autoexposure example restoration

include/nbl/asset/utils/IMeshPacker.h

@@ -6,7 +6,7 @@
 #define __NBL_ASSET_I_MESH_PACKER_H_INCLUDED__
 
 #include "nbl/asset/utils/IMeshManipulator.h"
-#include "nbl/core/math/morton.h"
+#include "nbl/builtin/hlsl/math/morton.hlsl"
 
 namespace nbl
 {

include/nbl/asset/utils/IVirtualTexture.h

@@ -7,7 +7,6 @@
 
 #include <functional>
 
-#include "nbl/core/math/morton.h"
 #include "nbl/core/memory/memory.h"
 #include "nbl/core/alloc/GeneralpurposeAddressAllocator.h"
 #include "nbl/core/alloc/PoolAddressAllocator.h"
@@ -19,6 +18,8 @@
 #include "nbl/asset/filters/CPaddedCopyImageFilter.h"
 #include "nbl/asset/filters/CFillImageFilter.h"
 
+#include "nbl/builtin/hlsl/math/morton.hlsl"
+
 namespace nbl::asset
 {
 
@@ -921,7 +922,7 @@ class IVirtualTexture : public core::IReferenceCounted, public IVirtualTextureBa
         storage->incrTileCounter(neededPhysPages);
 
         return offsetToTextureData(
-            page_tab_offset_t(core::morton2d_decode_x(addr), core::morton2d_decode_y(addr), pgtLayer),
+            page_tab_offset_t(hlsl::morton2d_decode_x(addr), hlsl::morton2d_decode_y(addr), pgtLayer),
             extent,
             _subres.levelCount,
             _wrapu,
@@ -933,7 +934,7 @@ class IVirtualTexture : public core::IReferenceCounted, public IVirtualTextureBa
     {
         uint32_t sz = computeSquareSz(_addr.origsize_x, _addr.origsize_y);
         sz *= sz;
-        const uint32_t addr = core::morton2d_encode(_addr.pgTab_x, _addr.pgTab_y);
+        const uint32_t addr = hlsl::morton2d_encode(_addr.pgTab_x, _addr.pgTab_y);
 
         core::address_allocator_traits<pg_tab_addr_alctr_t>::multi_free_addr(m_pageTableLayerAllocators[_addr.pgTab_layer], 1u, &addr, &sz);
 

include/nbl/builtin/hlsl/luma_meter/luma_meter.hlsl

@@ -0,0 +1,122 @@
+// Copyright (C) 2018-2024 - DevSH Graphics Programming Sp. z O.O.
+// This file is part of the "Nabla Engine".
+// For conditions of distribution and use, see copyright notice in nabla.h
+
+#ifndef _NBL_BUILTIN_HLSL_LUMA_METER_INCLUDED_
+#define _NBL_BUILTIN_HLSL_LUMA_METER_INCLUDED_
+
+#include "nbl/builtin/hlsl/cpp_compat.hlsl"
+#include "nbl/builtin/hlsl/glsl_compat/core.hlsl"
+#include "nbl/builtin/hlsl/glsl_compat/subgroup_basic.hlsl"
+#include "nbl/builtin/hlsl/workgroup/basic.hlsl"
+#include "nbl/builtin/hlsl/workgroup/arithmetic.hlsl"
+#include "nbl/builtin/hlsl/type_traits.hlsl"
+#include "nbl/builtin/hlsl/math/morton.hlsl"
+#include "nbl/builtin/hlsl/colorspace/EOTF.hlsl"
+#include "nbl/builtin/hlsl/colorspace/encodeCIEXYZ.hlsl"
+
+namespace nbl
+{
+namespace hlsl
+{
+namespace luma_meter
+{
+
+struct LumaMeteringWindow
+{
+	float32_t2 meteringWindowScale;
+	float32_t2 meteringWindowOffset;
+};
+
+template<uint32_t GroupSize, typename ValueAccessor, typename SharedAccessor, typename TexAccessor>
+struct geom_luma_meter {
+    using this_t = geom_luma_meter<GroupSize, ValueAccessor, SharedAccessor, TexAccessor>;
+
+    static this_t create(NBL_REF_ARG(LumaMeteringWindow) window, float32_t lumaMinimum, float32_t lumaMaximum)
+    {
+        this_t retval;
+        retval.window = window;
+        retval.minLuma = lumaMinimum;
+        retval.maxLuma = lumaMaximum;
+        return retval;
+    }
+
+    float32_t reduction(float32_t value, NBL_REF_ARG(SharedAccessor) sdata)
+    {
+        return workgroup::reduction < plus < float32_t >, GroupSize >::
+            template __call <SharedAccessor>(value, sdata);
+    }
+
+    float32_t computeLuma(
+        NBL_REF_ARG(TexAccessor) tex,
+        uint32_t2 sampleCount,
+        uint32_t2 sampleIndex,
+        float32_t2 viewportSize
+    )
+    {
+        float32_t2 stride = window.meteringWindowScale / (sampleCount + float32_t2(1.0f, 1.0f));
+        float32_t2 samplePos = stride * sampleIndex;
+        float32_t2 uvPos = (samplePos + float32_t2(0.5f, 0.5f)) / viewportSize;
+        float32_t3 color = colorspace::eotf::sRGB(tex.get(uvPos));
+        float32_t luma = dot(colorspace::sRGBtoXYZ[1], color);
+
+        luma = clamp(luma, minLuma, maxLuma);
+
+        return log2(luma / minLuma) / log2(maxLuma / minLuma);
+    }
+
+    void gatherLuma(
+        NBL_REF_ARG(ValueAccessor) val,
+        NBL_REF_ARG(TexAccessor) tex,
+        NBL_REF_ARG(SharedAccessor) sdata,
+        uint32_t2 sampleCount,
+        float32_t2 viewportSize
+    )
+    {
+        uint32_t2 coord = {
+            morton2d_decode_x(glsl::gl_LocalInvocationIndex()),
+            morton2d_decode_y(glsl::gl_LocalInvocationIndex())
+        };
+        uint32_t tid = workgroup::SubgroupContiguousIndex();
+
+        uint32_t2 sampleIndex = coord * GroupSize + float32_t2(glsl::gl_SubgroupID() + 1, glsl::gl_SubgroupInvocationID() + 1);
+        float32_t luma = 0.0f;
+
+        if (sampleIndex.x <= sampleCount.x && sampleIndex.y <= sampleCount.y) {
+            luma = computeLuma(tex, sampleCount, sampleIndex, viewportSize);
+            float32_t lumaSum = reduction(luma, sdata);
+
+            sdata.workgroupExecutionAndMemoryBarrier();
+
+            if (tid == GroupSize - 1) {
+                uint32_t3 workGroupCount = glsl::gl_NumWorkGroups();
+                uint32_t fixedPointBitsLeft = 32 - uint32_t(ceil(log2(workGroupCount.x * workGroupCount.y * workGroupCount.z))) + glsl::gl_SubgroupSizeLog2();
+
+                uint32_t lumaSumBitPattern = uint32_t(clamp((lumaSum - log2(minLuma)) * (log2(maxLuma) - log2(minLuma)), 0.f, float32_t((1 << fixedPointBitsLeft) - 1)));
+
+                uint32_t3 workgroupSize = glsl::gl_WorkGroupSize();
+                uint32_t workgroupIndex = dot(uint32_t3(workgroupSize.y * workgroupSize.z, workgroupSize.z, 1), glsl::gl_WorkGroupID());
+
+                val.atomicAdd(workgroupIndex & ((1 << glsl::gl_SubgroupSizeLog2()) - 1), lumaSumBitPattern);
+            }
+        }
+    }
+
+    float32_t getGatheredLuma(
+        NBL_REF_ARG(ValueAccessor) val,
+        uint32_t2 sampleCount
+    )
+    {
+        uint32_t lumaSumBitPattern = val.get(glsl::gl_SubgroupInvocationID());
+        float32_t lumaSumValue = float32_t(lumaSumBitPattern) / (log2(maxLuma) - log2(minLuma)) + log2(minLuma);
+        return glsl::subgroupAdd(lumaSumValue) / (sampleCount.x * sampleCount.y);
+    }
+
+    LumaMeteringWindow window;
+    float32_t minLuma, maxLuma;
+};
+}
+}
+}
+
+#endif