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,27 +53,27 @@ uint4 gl_SubgroupLtMask() {
 }
 
 bool subgroupElect() {
-    return spirv::subgroupElect(/*subgroup execution scope*/ 3);
+    return spirv::subgroupElect(spv::ScopeSubgroup);
 }
 
 void subgroupBarrier() {
-    spirv::controlBarrier(3, 3, SpvMemorySemanticsImageMemoryMask | SpvMemorySemanticsWorkgroupMemoryMask | SpvMemorySemanticsUniformMemoryMask | SpvMemorySemanticsAcquireReleaseMask);
+    spirv::controlBarrier(spv::ScopeSubgroup, spv::ScopeSubgroup, spv::MemorySemanticsImageMemoryMask | spv::MemorySemanticsWorkgroupMemoryMask | spv::MemorySemanticsUniformMemoryMask | spv::MemorySemanticsAcquireReleaseMask);
 }
 
 void subgroupMemoryBarrier() {
-    spirv::memoryBarrier(3, SpvMemorySemanticsImageMemoryMask | SpvMemorySemanticsWorkgroupMemoryMask | SpvMemorySemanticsUniformMemoryMask | SpvMemorySemanticsAcquireReleaseMask);
+    spirv::memoryBarrier(spv::ScopeSubgroup, spv::MemorySemanticsImageMemoryMask | spv::MemorySemanticsWorkgroupMemoryMask | spv::MemorySemanticsUniformMemoryMask | spv::MemorySemanticsAcquireReleaseMask);
 }
 
 void subgroupMemoryBarrierBuffer() {
-    spirv::memoryBarrier(3, SpvMemorySemanticsAcquireReleaseMask | SpvMemorySemanticsUniformMemoryMask);
+    spirv::memoryBarrier(spv::ScopeSubgroup, spv::MemorySemanticsAcquireReleaseMask | spv::MemorySemanticsUniformMemoryMask);
 }
 
 void subgroupMemoryBarrierShared() {
-    spirv::memoryBarrier(3, SpvMemorySemanticsAcquireReleaseMask | SpvMemorySemanticsWorkgroupMemoryMask);
+    spirv::memoryBarrier(spv::ScopeSubgroup, spv::MemorySemanticsAcquireReleaseMask | spv::MemorySemanticsWorkgroupMemoryMask);
 }
 
 void subgroupMemoryBarrierImage() {
-    spirv::memoryBarrier(3, SpvMemorySemanticsAcquireReleaseMask | SpvMemorySemanticsImageMemoryMask);
+    spirv::memoryBarrier(spv::ScopeSubgroup, spv::MemorySemanticsAcquireReleaseMask | spv::MemorySemanticsImageMemoryMask);
 }
 
 }

include/nbl/builtin/hlsl/spirv_intrinsics/core.hlsl

@@ -5,7 +5,7 @@
 #define _NBL_BUILTIN_HLSL_SPIRV_INTRINSICS_CORE_INCLUDED_
 
 
-#include "spirv/unified1/spirv.h"
+#include "spirv/unified1/spirv.hpp"
 
 
 namespace nbl