get the blit to compile and write output image

Author: devshgraphicsprogramming

examples_tests

@@ -6,6 +6,7 @@
 
 #include <nbl/builtin/hlsl/binding_info.hlsl>
 
+#include <nbl/builtin/hlsl/glsl_compat/core.hlsl>
 namespace nbl
 {
 namespace hlsl
@@ -44,7 +45,7 @@ RWTexture3D<float4> outAs3D[ConstevalParameters::output_binding_t::Count];
 
 groupshared uint32_t sMem[ConstevalParameters::SharedMemoryDWORDs];
 
-[[vk::push_constant]] const nbl::hlsl::blit::SPerWorkgroup pc;
+[[vk::push_constant]] const nbl::hlsl::blit::Parameters pc;
 
 
 #include <nbl/builtin/hlsl/concepts.hlsl>

include/nbl/builtin/hlsl/blit/common.hlsl

@@ -62,7 +62,25 @@ using namespace nbl::hlsl::blit;
 void main()
 {
 	InImgAccessor inImgA;
+
 	OutImgAccessor outImgA;
+	outImgA.descIx = pc.outputDescIx;
+
+	const uint16_t3 wgID = _static_cast<uint16_t3>(glsl::gl_WorkGroupID());
+	const uint16_t3 baseCoord = pc.perWG.getOutputBaseCoord(wgID);
+	// TODO: If and when someone can be bothered, change the blit api to compile a pipeline per image dimension, maybe it will be faster
+	switch (pc.perWG.imageDim)
+	{
+		case 1:
+			outImgA.set(uint16_t1(baseCoord.x),wgID.z,float32_t4(1,0,1,1));
+			break;
+		case 2:
+			outImgA.set(baseCoord.xy,wgID.z,float32_t4(1,0,1,1));
+			break;
+		case 3:
+			outImgA.set(baseCoord,0xdeadu,float32_t4(1,0,1,1));
+			break;
+	}
 /*
 	blit::compute_blit_t<ConstevalParameters> blit = blit::compute_blit_t<ConstevalParameters>::create(params);
     InCSAccessor inCSA;

include/nbl/builtin/hlsl/blit/default_blit.comp.hlsl

@@ -45,10 +45,11 @@ struct parameters_t
 // We do some dumb things with bitfields here like not using `vector<uint16_t,N>`, because AMD doesn't support them in push constants
 struct SPerWorkgroup
 {
-	static inline SPerWorkgroup create(const float32_t3 _scale, const uint16_t3 output, const uint16_t3 preload, const uint16_t _otherPreloadOffset)
+	static inline SPerWorkgroup create(const float32_t3 _scale, const uint16_t _imageDim, const uint16_t3 output, const uint16_t3 preload, const uint16_t _otherPreloadOffset)
 	{
 		SPerWorkgroup retval;
 		retval.scale = _scale;
+		retval.imageDim = _imageDim;
 		retval.preloadWidth = preload[0];
 		retval.preloadHeight = preload[1];
 		retval.preloadDepth = preload[2];
@@ -59,34 +60,37 @@ struct SPerWorkgroup
 		return retval;
 	}
 
-	inline uint16_t3 getOutput() NBL_CONST_MEMBER_FUNC
+	inline uint16_t3 getOutputBaseCoord(const uint16_t3 workgroup) NBL_CONST_MEMBER_FUNC
 	{
-		return uint16_t3(outputWidth,outputHeight,outputDepth);
+		return workgroup*uint16_t3(outputWidth,outputHeight,outputDepth);
 	}
 
 	inline uint16_t3 getWorkgroupCount(const uint16_t3 outExtent, const uint16_t layersToBlit=0) NBL_CONST_MEMBER_FUNC
 	{
-		uint16_t3 retval = uint16_t3(1,1,1);
-		retval += (outExtent-uint16_t3(1,1,1))/getOutput();
+		const uint16_t3 unit = uint16_t3(1,1,1);
+		uint16_t3 retval = unit;
+		retval += (outExtent-unit)/getOutputBaseCoord(unit);
 		if (layersToBlit)
-			retval[3] = layersToBlit;
+			retval[2] = layersToBlit;
 		return retval;
 	}
 
 #ifndef __HLSL_VERSION
-	inline operator bool() const
+	explicit inline operator bool() const
 	{
 		return outputWidth && outputHeight && outputDepth && preloadWidth && preloadHeight && preloadDepth;
 	}
 #endif
 
 	// ratio of input pixels to output
 	float32_t3 scale;
+	// whether its an image1D, image2D or image3D
+	uint32_t imageDim : 2;
+	uint32_t unused0 : 14; // channel, iterationRegionPrefixSums ?
 	// 16bit in each dimension because some GPUs actually have enough shared memory for 32k pixels
 	uint32_t outputWidth	: 16;
 	uint32_t outputHeight	: 16;
 	uint32_t outputDepth	: 16;
-	uint32_t unused0		: 16; // channel, image type, iterationRegionPrefixSums ?
 	uint32_t preloadWidth		: 16;
 	uint32_t preloadHeight		: 16;
 	uint32_t preloadDepth		: 16;
@@ -97,22 +101,27 @@ struct SPerWorkgroup
 
 struct Parameters
 {
-	static Parameters create(
-		const SPerWorkgroup perWG,
-		const uint16_t3 inImageExtent, const uint16_t3 outImageExtent
-	)
+#ifndef __HLSL_VERSION
+	explicit inline operator bool() const
 	{
-		Parameters retval;
-		retval.perWG = perWG;
-		return retval;
+		return bool(perWG);
 	}
+#endif
 
-	SPerWorkgroup perWG;
-	// general settings
-	uint32_t lastChannel : 2;
-	uint32_t coverage : 1;
-	uint32_t unused : 29;
+	SPerWorkgroup perWG; // rename to perBlitWG? 
+	//! general settings
+	uint32_t inputDescIx : 19;
+	uint32_t samplerDescIx : 11;
+	uint32_t unused0 : 2;
+	//
+	uint32_t outputDescIx : 19;
+	uint32_t channelCount : 3;
+	uint32_t unused1 : 10;
+	//
+	uint32_t unused2 : 12;
 	//! coverage settings
+	uint32_t intermAlphaDescIx : 19;
+	uint32_t coverage : 1;
 	// required to compare the atomic count of passing pixels against, so we can get original coverage
 	uint32_t inPixelCount;
 };

include/nbl/builtin/hlsl/blit/parameters.hlsl

@@ -416,6 +416,11 @@ class NBL_API2 IGPUCommandBuffer : public IBackendObject
 
         //! dispatches
         bool dispatch(const uint32_t groupCountX, const uint32_t groupCountY=1, const uint32_t groupCountZ=1);
+        template<typename T> requires std::is_integral_v<T>
+        bool dispatch(const hlsl::vector<T,3> groupCount)
+        {
+            return dispatch(groupCount.x,groupCount.y,groupCount.z);
+        }
         bool dispatchIndirect(const asset::SBufferBinding<const IGPUBuffer>& binding);
 
         //! Begin/End RenderPasses

include/nbl/video/IGPUCommandBuffer.h

@@ -151,16 +151,16 @@ class CComputeBlit : public core::IReferenceCounted
 		template <typename BlitUtilities>
 		static inline hlsl::blit::SPerWorkgroup computePerWorkGroup(
 			const uint16_t sharedMemorySize, const typename BlitUtilities::convolution_kernels_t& kernels, const IGPUImage::E_TYPE type,
-			const bool halfPrecision, const hlsl::uint16_t3 inExtent, const hlsl::uint16_t3 outExtent
+			const hlsl::uint16_t3 inExtent, const hlsl::uint16_t3 outExtent, const bool halfPrecision=false
 		)
 		{
 			const hlsl::float32_t3 minSupport(std::get<0>(kernels).getMinSupport(), std::get<1>(kernels).getMinSupport(), std::get<2>(kernels).getMinSupport());
 			const hlsl::float32_t3 maxSupport(std::get<0>(kernels).getMaxSupport(), std::get<1>(kernels).getMaxSupport(), std::get<2>(kernels).getMaxSupport());
-			return computePerWorkGroup(sharedMemorySize,minSupport,maxSupport,type,halfPrecision);
+			return computePerWorkGroup(sharedMemorySize,minSupport,maxSupport,type,inExtent,outExtent,halfPrecision);
 		}
-		static hlsl::blit::SPerWorkgroup computePerWorkGroup(
+		NBL_API2 static hlsl::blit::SPerWorkgroup computePerWorkGroup(
 			const uint16_t sharedMemorySize, const hlsl::float32_t3 minSupportInOutput, const hlsl::float32_t3 maxSupportInOutput, const IGPUImage::E_TYPE type,
-			const bool halfPrecision, const hlsl::uint16_t3 inExtent, const hlsl::uint16_t3 outExtent
+			const hlsl::uint16_t3 inExtent, const hlsl::uint16_t3 outExtent, const bool halfPrecision=false
 		);
 
 #if 0

include/nbl/video/utilities/CComputeBlit.h

@@ -117,8 +117,8 @@ struct ConstevalParameters
 }
 
 SPerWorkgroup CComputeBlit::computePerWorkGroup(
-	const uint16_t sharedMemorySize, const float32_t3 minSupportInOutput, const float32_t3 maxSupportInOutput,
-	const IGPUImage::E_TYPE type, const bool halfPrecision, const uint16_t3 inExtent, const uint16_t3 outExtent
+	const uint16_t sharedMemorySize, const float32_t3 minSupportInOutput, const float32_t3 maxSupportInOutput, const IGPUImage::E_TYPE type,
+	const uint16_t3 inExtent, const uint16_t3 outExtent, const bool halfPrecision
 )
 {
 	SPerWorkgroup retval;
@@ -157,7 +157,7 @@ SPerWorkgroup CComputeBlit::computePerWorkGroup(
 			if (requiredSharedMemory>size_t(sharedMemorySize))
 				break;
 			// still fits, update return value
-			retval = SPerWorkgroup::create(scale,output,preload,otherPreloadOffset);
+			retval = SPerWorkgroup::create(scale,Dims,output,preload,otherPreloadOffset);
 		}
 
 		// we want to fix the dimension that's the smallest, so that we increase the volume of the support by a smallest increment and stay close to a cube shape