HLSL migration of all shaders related to example 48.ArithmeticUnitTest

include/nbl/builtin/hlsl/algorithm.hlsl

@@ -109,15 +109,6 @@ uint upper_bound(inout Accessor accessor, const uint begin, const uint end, cons
 namespace impl
 {
 
-template<typename T>
-struct comparator_lt_t
-{
-    bool operator()(const T lhs, const T rhs)
-    {
-        return lhs<rhs;
-    }
-};
-
 // extra indirection due to https://github.com/microsoft/DirectXShaderCompiler/issues/4771
 template<class Accessor, typename T>
 uint lower_bound(inout Accessor accessor, const uint begin, const uint end, const T value)

include/nbl/builtin/hlsl/bxdf/common.hlsl

@@ -4,9 +4,9 @@
 #ifndef _NBL_BUILTIN_HLSL_BXDF_COMMON_INCLUDED_
 #define _NBL_BUILTIN_HLSL_BXDF_COMMON_INCLUDED_
 
-#include <nbl/builtin/hlsl/limits.hlsl>
-#include <nbl/builtin/hlsl/numbers.hlsl>
-#include <nbl/builtin/hlsl/math/functions.glsl>
+#include "nbl/builtin/hlsl/limits.hlsl"
+#include "nbl/builtin/hlsl/numbers.hlsl"
+#include "nbl/builtin/hlsl/math/functions.glsl"
 
 namespace nbl
 {

include/nbl/builtin/hlsl/binops.hlsl → include/nbl/builtin/hlsl/functional.hlsl

@@ -1,21 +1,33 @@
-// Copyright (C) 2022 - DevSH Graphics Programming Sp. z O.O.
+// Copyright (C) 2023 - 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_BINOPS_INCLUDED_
-#define _NBL_BUILTIN_HLSL_BINOPS_INCLUDED_
+#ifndef _NBL_BUILTIN_HLSL_FUNCTIONAL_INCLUDED_
+#define _NBL_BUILTIN_HLSL_FUNCTIONAL_INCLUDED_
 
 namespace nbl
 {
 namespace hlsl
 {
-namespace binops
-{
+#ifndef __HLSL_VERSION // CPP
+
+template<class T> using bit_and = std::bit_and;
+template<class T> using bit_or = std::bit_or;
+template<class T> using bit_xor = std::bit_xor;
+template<class T> using plus = std::plus;
+template<class T> using multiplies = std::multiplies;
+template<class T> using greater = std::greater;
+template<class T> using less = std::less;
+template<class T> using greater_equal = std::greater_equal;
+template<class T> using less_equal = std::less_equal;
+
+#else // HLSL
+
 template<typename T>
-struct bitwise_and
+struct bit_and
 {
     T operator()(const T lhs, const T rhs)
     {
-        return lhs&rhs;
+        return lhs & rhs;
     }
 
     static T identity()
@@ -25,11 +37,11 @@ struct bitwise_and
 };
 
 template<typename T>
-struct bitwise_or
+struct bit_or
 {
     T operator()(const T lhs, const T rhs)
     {
-        return lhs|rhs;
+        return lhs | rhs;
     }
 
     static T identity()
@@ -39,11 +51,11 @@ struct bitwise_or
 };
 
 template<typename T>
-struct bitwise_xor
+struct bit_xor
 {
     T operator()(const T lhs, const T rhs)
     {
-        return lhs^rhs;
+        return lhs ^ rhs;
     }
 
     static T identity()
@@ -53,11 +65,11 @@ struct bitwise_xor
 };
 
 template<typename T>
-struct add
+struct plus
 {
     T operator()(const T lhs, const T rhs)
     {
-        return lhs+rhs;
+        return lhs + rhs;
     }
 
     static T identity()
@@ -67,11 +79,11 @@ struct add
 };
 
 template<typename T>
-struct mul
+struct multiplies
 {
     T operator()(const T lhs, const T rhs)
     {
-        return lhs*rhs;
+        return lhs * rhs;
     }
 
     static T identity()
@@ -81,48 +93,47 @@ struct mul
 };
 
 template<typename T>
-struct comparator_lt_t
+struct greater
 {
     bool operator()(const T lhs, const T rhs)
     {
-        return lhs<rhs;
+        return lhs > rhs;
     }
 };
 
 template<typename T>
-struct comparator_gt_t
+struct less
 {
     bool operator()(const T lhs, const T rhs)
     {
-        return lhs>rhs;
+        return lhs < rhs;
     }
 };
 
 template<typename T>
-struct comparator_lte_t
+struct greater_equal
 {
     bool operator()(const T lhs, const T rhs)
     {
-        return lhs<=rhs;
+        return lhs >= rhs;
     }
 };
 
 template<typename T>
-struct comparator_gte_t
+struct less_equal
 {
     bool operator()(const T lhs, const T rhs)
     {
-        return lhs>=rhs;
+        return lhs <= rhs;
     }
 };
 
 template<typename T>
-struct min
+struct minimum
 {
     T operator()(const T lhs, const T rhs)
     {
-        comparator_lt_t<T> comp;
-        return comp(lhs, rhs) ? lhs : rhs;
+        return (rhs < lhs) ? rhs : lhs;
     }
 
     static T identity()
@@ -132,12 +143,11 @@ struct min
 };
 
 template<typename T>
-struct max
+struct maximum
 {
     T operator()(const T lhs, const T rhs)
     {
-        comparator_gt_t<T> comp;
-        return comp(lhs, rhs) ? lhs : rhs;
+        return (lhs < rhs) ? rhs : lhs;
     }
 
     static T identity()
@@ -146,7 +156,8 @@ struct max
     }
 };
 
-}
+#endif
+
 }
 }
 

include/nbl/builtin/hlsl/glsl_compat/core.hlsl

@@ -56,11 +56,11 @@ T atomicCompSwap(NBL_REF_ARG(T) ptr, T comparator, T value)
 }
 
 void barrier() {
-    spirv::controlBarrier(2, 2, 0x8 | 0x100);
+    spirv::controlBarrier(spv::ScopeWorkgroup, spv::ScopeWorkgroup, spv::MemorySemanticsAcquireReleaseMask | spv::MemorySemanticsWorkgroupMemoryMask);
 }
 
 void memoryBarrierShared() {
-    spirv::memoryBarrier(1, 0x8 | 0x100);
+    spirv::memoryBarrier(spv::ScopeDevice, spv::MemorySemanticsAcquireReleaseMask | spv::MemorySemanticsWorkgroupMemoryMask);
 }
 
 }

include/nbl/builtin/hlsl/glsl_compat/subgroup_basic.hlsl

@@ -53,17 +53,27 @@ uint4 gl_SubgroupLtMask() {
 }
 
 bool subgroupElect() {
-    return spirv::subgroupElect(/*subgroup execution scope*/ 3);
+    return spirv::subgroupElect(spv::ScopeSubgroup);
 }
 
-// Memory Semantics: AcquireRelease, UniformMemory, WorkgroupMemory, AtomicCounterMemory, ImageMemory
 void subgroupBarrier() {
-    // REVIEW-519: barrier with subgroup scope is not supported  so leave commented out for now 
-    //spirv::controlBarrier(3, 3, 0x800 | 0x400 | 0x100 | 0x40 | 0x8);
+    spirv::controlBarrier(spv::ScopeSubgroup, spv::ScopeSubgroup, spv::MemorySemanticsImageMemoryMask | spv::MemorySemanticsWorkgroupMemoryMask | spv::MemorySemanticsUniformMemoryMask | spv::MemorySemanticsAcquireReleaseMask);
+}
+
+void subgroupMemoryBarrier() {
+    spirv::memoryBarrier(spv::ScopeSubgroup, spv::MemorySemanticsImageMemoryMask | spv::MemorySemanticsWorkgroupMemoryMask | spv::MemorySemanticsUniformMemoryMask | spv::MemorySemanticsAcquireReleaseMask);
+}
+
+void subgroupMemoryBarrierBuffer() {
+    spirv::memoryBarrier(spv::ScopeSubgroup, spv::MemorySemanticsAcquireReleaseMask | spv::MemorySemanticsUniformMemoryMask);
 }
 
 void subgroupMemoryBarrierShared() {
-    spirv::memoryBarrier(3, 0x800 | 0x400 | 0x100 | 0x40 | 0x8);
+    spirv::memoryBarrier(spv::ScopeSubgroup, spv::MemorySemanticsAcquireReleaseMask | spv::MemorySemanticsWorkgroupMemoryMask);
+}
+
+void subgroupMemoryBarrierImage() {
+    spirv::memoryBarrier(spv::ScopeSubgroup, spv::MemorySemanticsAcquireReleaseMask | spv::MemorySemanticsImageMemoryMask);
 }
 
 }

include/nbl/builtin/hlsl/memory_accessor.hlsl

@@ -0,0 +1,136 @@
+// Copyright (C) 2023 - 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_MEMORY_ACCESSOR_INCLUDED_
+#define _NBL_BUILTIN_HLSL_MEMORY_ACCESSOR_INCLUDED_
+
+#include "nbl/builtin/hlsl/glsl_compat/core.hlsl"
+
+namespace nbl 
+{
+namespace hlsl
+{
+template<class NumberMemoryAccessor>
+struct MemoryAdaptor
+{
+    NumberMemoryAccessor accessor;
+
+    uint get(const uint ix) { return accessor.get(ix); }
+    void get(const uint ix, NBL_REF_ARG(uint) value) { value = accessor.get(ix);}
+    void get(const uint ix, NBL_REF_ARG(uint2) value) { value = uint2(accessor.get(ix), accessor.get(ix + _NBL_HLSL_WORKGROUP_SIZE_));}
+    void get(const uint ix, NBL_REF_ARG(uint3) value) { value = uint3(accessor.get(ix), accessor.get(ix + _NBL_HLSL_WORKGROUP_SIZE_), accessor.get(ix + 2 * _NBL_HLSL_WORKGROUP_SIZE_));}
+    void get(const uint ix, NBL_REF_ARG(uint4) value) { value = uint4(accessor.get(ix), accessor.get(ix + _NBL_HLSL_WORKGROUP_SIZE_), accessor.get(ix + 2 * _NBL_HLSL_WORKGROUP_SIZE_), accessor.get(ix + 3 * _NBL_HLSL_WORKGROUP_SIZE_));}
+
+    void get(const uint ix, NBL_REF_ARG(int) value) { value = asint(accessor.get(ix));}
+    void get(const uint ix, NBL_REF_ARG(int2) value) { value = asint(uint2(accessor.get(ix), accessor.get(ix + _NBL_HLSL_WORKGROUP_SIZE_)));}
+    void get(const uint ix, NBL_REF_ARG(int3) value) { value = asint(uint3(accessor.get(ix), accessor.get(ix + _NBL_HLSL_WORKGROUP_SIZE_), accessor.get(ix + 2 * _NBL_HLSL_WORKGROUP_SIZE_)));}
+    void get(const uint ix, NBL_REF_ARG(int4) value) { value = asint(uint4(accessor.get(ix), accessor.get(ix + _NBL_HLSL_WORKGROUP_SIZE_), accessor.get(ix + 2 * _NBL_HLSL_WORKGROUP_SIZE_), accessor.get(ix + 3 * _NBL_HLSL_WORKGROUP_SIZE_)));}
+
+    void get(const uint ix, NBL_REF_ARG(float) value) { value = asfloat(accessor.get(ix));}
+    void get(const uint ix, NBL_REF_ARG(float2) value) { value = asfloat(uint2(accessor.get(ix), accessor.get(ix + _NBL_HLSL_WORKGROUP_SIZE_)));}
+    void get(const uint ix, NBL_REF_ARG(float3) value) { value = asfloat(uint3(accessor.get(ix), accessor.get(ix + _NBL_HLSL_WORKGROUP_SIZE_), accessor.get(ix + 2 * _NBL_HLSL_WORKGROUP_SIZE_)));}
+    void get(const uint ix, NBL_REF_ARG(float4) value) { value = asfloat(uint4(accessor.get(ix), accessor.get(ix + _NBL_HLSL_WORKGROUP_SIZE_), accessor.get(ix + 2 * _NBL_HLSL_WORKGROUP_SIZE_), accessor.get(ix + 3 * _NBL_HLSL_WORKGROUP_SIZE_)));}
+
+    void set(const uint ix, const uint value) {accessor.set(ix, value);}
+    void set(const uint ix, const uint2 value) {
+        accessor.set(ix, value.x);
+        accessor.set(ix + _NBL_HLSL_WORKGROUP_SIZE_, value.y);
+    }
+    void set(const uint ix, const uint3 value)  {
+        accessor.set(ix, value.x);
+        accessor.set(ix + _NBL_HLSL_WORKGROUP_SIZE_, value.y);
+        accessor.set(ix + 2 * _NBL_HLSL_WORKGROUP_SIZE_, value.z);
+    }
+    void set(const uint ix, const uint4 value) {
+        accessor.set(ix, value.x);
+        accessor.set(ix + _NBL_HLSL_WORKGROUP_SIZE_, value.y);
+        accessor.set(ix + 2 * _NBL_HLSL_WORKGROUP_SIZE_, value.z);
+        accessor.set(ix + 3 * _NBL_HLSL_WORKGROUP_SIZE_, value.w);
+    }
+
+    void set(const uint ix, const int value) {accessor.set(ix, asuint(value));}
+    void set(const uint ix, const int2 value) {
+        accessor.set(ix, asuint(value.x));
+        accessor.set(ix + _NBL_HLSL_WORKGROUP_SIZE_, asuint(value.y));
+    }
+    void set(const uint ix, const int3 value)  {
+        accessor.set(ix, asuint(value.x));
+        accessor.set(ix + _NBL_HLSL_WORKGROUP_SIZE_, asuint(value.y));
+        accessor.set(ix + 2 * _NBL_HLSL_WORKGROUP_SIZE_, asuint(value.z));
+    }
+    void set(const uint ix, const int4 value) {
+        accessor.set(ix, asuint(value.x));
+        accessor.set(ix + _NBL_HLSL_WORKGROUP_SIZE_, asuint(value.y));
+        accessor.set(ix + 2 * _NBL_HLSL_WORKGROUP_SIZE_, asuint(value.z));
+        accessor.set(ix + 3 * _NBL_HLSL_WORKGROUP_SIZE_, asuint(value.w));
+    }
+
+    void set(const uint ix, const float value) {accessor.set(ix, asuint(value));}
+    void set(const uint ix, const float2 value) {
+        accessor.set(ix, asuint(value.x));
+        accessor.set(ix + _NBL_HLSL_WORKGROUP_SIZE_, asuint(value.y));
+    }
+    void set(const uint ix, const float3 value)  {
+        accessor.set(ix, asuint(value.x));
+        accessor.set(ix + _NBL_HLSL_WORKGROUP_SIZE_, asuint(value.y));
+        accessor.set(ix + 2 * _NBL_HLSL_WORKGROUP_SIZE_, asuint(value.z));
+    }
+    void set(const uint ix, const float4 value) {
+        accessor.set(ix, asuint(value.x));
+        accessor.set(ix + _NBL_HLSL_WORKGROUP_SIZE_, asuint(value.y));
+        accessor.set(ix + 2 * _NBL_HLSL_WORKGROUP_SIZE_, asuint(value.z));
+        accessor.set(ix + 3 * _NBL_HLSL_WORKGROUP_SIZE_, asuint(value.w));
+    }
+
+    void atomicAnd(const uint ix, const uint value, NBL_REF_ARG(uint) orig) {
+       orig = accessor.atomicAnd(ix, value);
+    }
+    void atomicAnd(const uint ix, const int value, NBL_REF_ARG(int) orig) {
+       orig = asint(accessor.atomicAnd(ix, asuint(value)));
+    }
+    void atomicAnd(const uint ix, const float value, NBL_REF_ARG(float) orig) {
+       orig = asfloat(accessor.atomicAnd(ix, asuint(value)));
+    }
+    void atomicOr(const uint ix, const uint value, NBL_REF_ARG(uint) orig) {
+       orig = accessor.atomicOr(ix, value);
+    }
+    void atomicOr(const uint ix, const int value, NBL_REF_ARG(int) orig) {
+       orig = asint(accessor.atomicOr(ix, asuint(value)));
+    }
+    void atomicOr(const uint ix, const float value, NBL_REF_ARG(float) orig) {
+       orig = asfloat(accessor.atomicOr(ix, asuint(value)));
+    }
+    void atomicXor(const uint ix, const uint value, NBL_REF_ARG(uint) orig) {
+       orig = accessor.atomicXor(ix, value);
+    }
+    void atomicXor(const uint ix, const int value, NBL_REF_ARG(int) orig) {
+       orig = asint(accessor.atomicXor(ix, asuint(value)));
+    }
+    void atomicXor(const uint ix, const float value, NBL_REF_ARG(float) orig) {
+       orig = asfloat(accessor.atomicXor(ix, asuint(value)));
+    }
+    void atomicAdd(const uint ix, const uint value, NBL_REF_ARG(uint) orig) {
+       orig = accessor.atomicAdd(ix, value);
+    }
+    void atomicMin(const uint ix, const uint value, NBL_REF_ARG(uint) orig) {
+       orig = accessor.atomicMin(ix, value);
+    }
+    void atomicMax(const uint ix, const uint value, NBL_REF_ARG(uint) orig) {
+       orig = accessor.atomicMax(ix, value);
+    }
+    void atomicExchange(const uint ix, const uint value, NBL_REF_ARG(uint) orig) {
+       orig = accessor.atomicExchange(ix, value);
+    }
+    void atomicCompSwap(const uint ix, const uint value, const uint comp, NBL_REF_ARG(uint) orig) {
+       orig = accessor.atomicCompSwap(ix, comp, value);
+    }
+
+    void workgroupExecutionAndMemoryBarrier() {
+        accessor.workgroupExecutionAndMemoryBarrier();
+    }
+};
+
+}
+}
+
+#endif