Initial porting of arithmetic shaders to HLSL

Author: kpentaris

include/nbl/builtin/hlsl/atomics.hlsl

@@ -0,0 +1,79 @@
+// 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_ATOMICS_INCLUDED_
+#define _NBL_BUILTIN_HLSL_ATOMICS_INCLUDED_
+
+namespace nbl
+{
+namespace hlsl
+{
+namespace atomics
+{
+	template<typename T>
+	T atomicAdd(inout T mem, T data)
+	{
+		T orig;
+		InterlockedAdd(mem, data, orig);
+		return orig;
+	}
+	
+	template<typename T>
+	T atomicAnd(inout T mem, T data)
+	{
+		T orig;
+		InterlockedAnd(mem, data, orig);
+		return orig;
+	}
+	
+	template<typename T>
+	T atomicOr(inout T mem, T data)
+	{
+		T orig;
+		InterlockedOr(mem, data, orig);
+		return orig;
+	}
+	
+	template<typename T>
+	T atomicXor(inout T mem, T data)
+	{
+		T orig;
+		InterlockedXor(mem, data, orig);
+		return orig;
+	}
+	
+	template<typename T>
+	T atomicMin(inout T mem, T data)
+	{
+		T orig;
+		InterlockedMin(mem, data, orig);
+		return orig;
+	}
+	
+	template<typename T>
+	T atomicMax(inout T mem, T data)
+	{
+		T orig;
+		InterlockedMax(mem, data, orig);
+		return orig;
+	}
+	
+	template<typename T>
+	T atomicExchange(inout T mem, T data)
+	{
+		T orig;
+		InterlockedExchange(mem, data, orig);
+		return orig;
+	}
+	
+	template<typename T>
+	T atomicCompSwap(inout T mem, T compare, T data)
+	{
+		T orig;
+		InterlockedCompareExchange(mem, compare, data, orig);
+		return orig;
+	}
+}
+}
+}
+#endif

include/nbl/builtin/hlsl/binops.hlsl

@@ -80,88 +80,70 @@ struct mul
 	}
 };
 
-template<typename T, class Comparator>
-struct min
-{
-    T operator()(const T lhs, const T rhs, inout Comparator comp)
-    {
-        return comp(lhs, rhs) ? lhs : rhs;
-    }
-};
-
 template<typename T>
-struct min
-{
-    T operator()(const T lhs, const T rhs)
-    {
-		comparator_lt_t comp;
-        return bitwise_min(lhs, rhs, comp);
-    }
-	
-	T identity()
-	{
-		return ~0;
-	}
-};
-
-template<typename T, class Comparator>
-struct max
+struct comparator_lt_t
 {
-    T operator()(const T lhs, const T rhs, inout Comparator comp)
+    bool operator()(const T lhs, const T rhs)
     {
-        return comp(lhs, rhs) ? lhs : rhs;
+        return lhs<rhs;
     }
 };
 
 template<typename T>
-struct max
+struct comparator_gt_t
 {
-    T operator()(const T lhs, const T rhs)
+    bool operator()(const T lhs, const T rhs)
     {
-		comparator_gt_t comp;
-        return bitwise_max(lhs, rhs, comp);
+        return lhs>rhs;
     }
-	
-	T identity()
-	{
-		return 0; // REVIEW: This assumes T = unsigned but what if we got T = signed ?
-	}
 };
 
 template<typename T>
-struct comparator_lt_t
+struct comparator_lte_t
 {
     bool operator()(const T lhs, const T rhs)
     {
-        return lhs<rhs;
+        return lhs<=rhs;
     }
 };
 
 template<typename T>
-struct comparator_gt_t
+struct comparator_gte_t
 {
     bool operator()(const T lhs, const T rhs)
     {
-        return lhs>rhs;
+        return lhs>=rhs;
     }
 };
 
 template<typename T>
-struct comparator_lte_t
+struct min
 {
-    bool operator()(const T lhs, const T rhs)
+    T operator()(const T lhs, const T rhs)
     {
-        return lhs<=rhs;
+		comparator_lt_t<T> comp;
+        return comp(lhs, rhs) ? lhs : rhs;
     }
+
+	T identity()
+	{
+		return ~0;
+	}
 };
 
 template<typename T>
-struct comparator_gte_t
+struct max
 {
-    bool operator()(const T lhs, const T rhs)
+    T operator()(const T lhs, const T rhs)
     {
-        return lhs>=rhs;
+		comparator_gt_t<T> comp;
+        return comp(lhs, rhs) ? lhs : rhs;
     }
+
+	T identity()
+	{
+		return 0;
+	}
 };
 
 }

include/nbl/builtin/hlsl/scan/descriptors.hlsl

@@ -0,0 +1,3 @@
+
+
+// choerent -> globallycoherent

include/nbl/builtin/hlsl/scan/virtual_workgroup.hlsl

@@ -11,6 +11,7 @@
 
 const uint gl_LocalInvocationIndex: SV_GroupIndex;
 
+#if 0
 namespace nbl
 {
 namespace hlsl
@@ -24,20 +25,21 @@ namespace scan
 		const Parameters_t params = getParameters();
 		const uint levelInvocationIndex = localWorkgroupIndex * _NBL_HLSL_WORKGROUP_SIZE_ + gl_LocalInvocationIndex;
 		const bool lastInvocationInGroup = gl_LocalInvocationIndex == (_NBL_HLSL_WORKGROUP_SIZE_ - 1);
-		
+
 		const uint lastLevel = params.topLevel << 1u;
 		const uint pseudoLevel = levelInvocationIndex <= params.lastElement[pseudoLevel];
-		
+
 		const bool inRange = levelInvocationIndex <= params.lastElement[pseudoLevel];
-		
+
 		Storage_t data = binop.identity();
 		if(inRange)
 		{
 			getData(data, levelInvocationIndex, localWorkgroupIndex, treeLevel, pseudoLevel);
 		}
-		
+
 		if(treeLevel < params.topLevel) 
 		{
+			#error "Must also define some scratch accessor when calling operation()"
 			data = workgroup::reduction<binop>()(data);
 		}
 		// REVIEW: missing _TYPE_ check and extra case here
@@ -85,6 +87,8 @@ namespace scan
 }
 }
 }
+#endif
+
 #define _NBL_HLSL_SCAN_MAIN_DEFINED_
 #endif