Merge branch 'shader_pipeline_irrlichtbaw' of https://github.com/Devsh-Graphics-Programming/Nabla

Author: Przemog1

examples_tests/18.MitsubaLoader/main.cpp

@@ -15,6 +15,9 @@ using namespace core;
 constexpr const char* GLSL_COMPUTE_LIGHTING =
 R"(
 #define _IRR_COMPUTE_LIGHTING_DEFINED_
+
+#include <irr/builtin/glsl/format/decode.glsl>
+
 struct SLight
 {
 	vec3 position;
@@ -25,20 +28,43 @@ layout (set = 2, binding = 0, std430) readonly restrict buffer Lights
 {
 	SLight lights[];
 };
+layout(set = 2, binding = 1) uniform sampler2D envMap;
+
+vec2 SampleSphericalMap(in vec3 v)
+{
+    vec2 uv = vec2(atan(v.z, v.x), asin(v.y));
+    uv *= irr_glsl_RECIPROCAL_PI*0.5;
+    uv += 0.5; 
+    return uv;
+}
 
 vec3 irr_computeLighting(inout irr_glsl_IsotropicViewSurfaceInteraction out_interaction, in mat2 dUV)
 {
-	vec3 emissive = decodeRGB19E7(InstData.data[InstanceIndex].emissive);
+	vec3 emissive = irr_glsl_decodeRGB19E7(InstData.data[InstanceIndex].emissive);
 
-	irr_glsl_BSDFIsotropicParams params;
 	vec3 color = vec3(0.0);
+/*
+	instr_stream_t gcs = getGenChoiceStream();
+	const int N = 100;
+	for (int i = 0; i < N; ++i)
+	{
+		vec3 rem;
+		vec2 rand;//TODO
+		vec3 L = runGeneratorChoiceStream(gcs, rand, rem);
+		vec2 uv = SampleSphericalMap(L);
+		color += rem*textureLod(envMap, uv, 0.0).xyz;
+	}
+*/
+	irr_glsl_BSDFIsotropicParams params;
 	for (int i = 0; i < 13; ++i)
 	{
 		SLight l = lights[i];
 		vec3 L = l.position-WorldPos;
 		params.L = L;
-		color += irr_bsdf_cos_eval(params, out_interaction, dUV)*l.intensity*0.01 / dot(L,L);
+#define INTENSITY 0.01 //ehh might want to render to hdr fbo and do tonemapping
+		color += irr_bsdf_cos_eval(params, out_interaction, dUV)*l.intensity*INTENSITY / dot(L,L);
 	}
+
 	return color+emissive;
 }
 )";
@@ -61,6 +87,33 @@ static core::smart_refctd_ptr<asset::ICPUSpecializedShader> createModifiedFragSh
     return fsNew;
 }
 
+static auto createGPUImageView(const std::string& path, asset::IAssetManager* am, video::IVideoDriver* driver)
+{
+	using namespace asset;
+	using namespace video;
+
+	IAssetLoader::SAssetLoadParams lp(0ull, nullptr, IAssetLoader::ECF_DONT_CACHE_REFERENCES);
+	auto cpuTexture = am->getAsset(path, lp);
+	auto cpuTextureContents = cpuTexture.getContents();
+
+	auto asset = *cpuTextureContents.begin();
+	auto cpuimg = core::smart_refctd_ptr_static_cast<asset::ICPUImage>(asset);
+
+	IGPUImageView::SCreationParams viewParams;
+	viewParams.flags = static_cast<IGPUImageView::E_CREATE_FLAGS>(0u);
+	viewParams.image = driver->getGPUObjectsFromAssets(&cpuimg.get(),&cpuimg.get()+1u)->front();
+	viewParams.format = viewParams.image->getCreationParameters().format;
+	viewParams.viewType = IImageView<IGPUImage>::ET_2D;
+	viewParams.subresourceRange.baseArrayLayer = 0u;
+	viewParams.subresourceRange.layerCount = 1u;
+	viewParams.subresourceRange.baseMipLevel = 0u;
+	viewParams.subresourceRange.levelCount = viewParams.image->getCreationParameters().mipLevels;
+
+	auto gpuImageView = driver->createGPUImageView(std::move(viewParams));
+
+	return gpuImageView;
+};
+
 #include "irr/irrpack.h"
 //std430-compatible
 struct SLight
@@ -187,17 +240,27 @@ int main()
 
 
 	video::IVideoDriver* driver = device->getVideoDriver();
+	asset::IAssetManager* am = device->getAssetManager();
 
 	core::smart_refctd_ptr<asset::ICPUDescriptorSetLayout> ds2layout;
 	{
-		asset::ICPUDescriptorSetLayout::SBinding bnd;
-		bnd.binding = 0u;
-		bnd.count = 1u;
-		bnd.samplers = nullptr;
-		bnd.stageFlags = asset::ISpecializedShader::ESS_FRAGMENT;
-		bnd.type = asset::EDT_STORAGE_BUFFER;
-
-		ds2layout = core::make_smart_refctd_ptr<asset::ICPUDescriptorSetLayout>(&bnd, &bnd + 1);
+		asset::ICPUDescriptorSetLayout::SBinding bnd[2];
+		bnd[0].binding = 0u;
+		bnd[0].count = 1u;
+		bnd[0].samplers = nullptr;
+		bnd[0].stageFlags = asset::ISpecializedShader::ESS_FRAGMENT;
+		bnd[0].type = asset::EDT_STORAGE_BUFFER;
+
+		using namespace asset;
+		ISampler::SParams samplerParams = { ISampler::ETC_CLAMP_TO_EDGE, ISampler::ETC_CLAMP_TO_EDGE, ISampler::ETC_CLAMP_TO_EDGE, ISampler::ETBC_FLOAT_OPAQUE_BLACK, ISampler::ETF_LINEAR, ISampler::ETF_LINEAR, ISampler::ESMM_LINEAR, 0u, false, ECO_ALWAYS };
+		auto smplr = core::make_smart_refctd_ptr<asset::ICPUSampler>(samplerParams);
+		bnd[1].binding = 1u;
+		bnd[1].count = 1u;
+		bnd[1].samplers = &smplr;
+		bnd[1].stageFlags = asset::ISpecializedShader::ESS_FRAGMENT;
+		bnd[1].type = asset::EDT_COMBINED_IMAGE_SAMPLER;
+
+		ds2layout = core::make_smart_refctd_ptr<asset::ICPUDescriptorSetLayout>(bnd, bnd + 2);
 	}
 
 	//gather all meshes into core::vector and modify their pipelines
@@ -364,20 +427,31 @@ int main()
 	auto gpuds2layout = driver->getGPUObjectsFromAssets(&ds2layout.get(), &ds2layout.get()+1)->front();
 	auto gpuds2 = driver->createGPUDescriptorSet(std::move(gpuds2layout));
 	{
-		video::IGPUDescriptorSet::SDescriptorInfo info;
-		video::IGPUDescriptorSet::SWriteDescriptorSet w;
-		w.arrayElement = 0u;
-		w.binding = 0u;
-		w.count = 1u;
-		w.descriptorType = asset::EDT_STORAGE_BUFFER;
-		w.dstSet = gpuds2.get();
-		w.info = &info;
+		video::IGPUDescriptorSet::SDescriptorInfo info[2];
+		video::IGPUDescriptorSet::SWriteDescriptorSet w[2];
+		w[0].arrayElement = 0u;
+		w[0].binding = 0u;
+		w[0].count = 1u;
+		w[0].descriptorType = asset::EDT_STORAGE_BUFFER;
+		w[0].dstSet = gpuds2.get();
+		w[0].info = info+0;
 		auto lightsBuf = driver->createFilledDeviceLocalGPUBufferOnDedMem(lights.size()*sizeof(SLight), lights.data());
-		info.buffer.offset = 0u;
-		info.buffer.size = lightsBuf->getSize();
-		info.desc = std::move(lightsBuf);
-
-		driver->updateDescriptorSets(1u, &w, 0u, nullptr);
+		info[0].buffer.offset = 0u;
+		info[0].buffer.size = lightsBuf->getSize();
+		info[0].desc = std::move(lightsBuf);
+
+		w[1].arrayElement = 0u;
+		w[1].binding = 1u;
+		w[1].count = 1u;
+		w[1].descriptorType = asset::EDT_COMBINED_IMAGE_SAMPLER;
+		w[1].dstSet = gpuds2.get();
+		w[1].info = info+1;
+		auto gpuEnvmapImageView = createGPUImageView("../../media/envmap/envmap_0.exr", am, driver);
+		info[1].image.imageLayout = asset::EIL_UNDEFINED;
+		info[1].image.sampler = nullptr;
+		info[1].desc = std::move(gpuEnvmapImageView);
+
+		driver->updateDescriptorSets(2u, w, 0u, nullptr);
 	}
 
 	// camera and viewport
@@ -399,7 +473,7 @@ int main()
 		viewport = core::recti(core::position2di(film.cropOffsetX,film.cropOffsetY), core::position2di(film.cropWidth,film.cropHeight));
 
 		auto extent = sceneBound.getExtent();
-		camera = smgr->addCameraSceneNodeFPS(nullptr,100.f,core::min(extent.X,extent.Y,extent.Z)*0.001f);
+		camera = smgr->addCameraSceneNodeFPS(nullptr,100.f,core::min(extent.X,extent.Y,extent.Z)*0.0001f);
 		// need to extract individual components
 		bool leftHandedCamera = false;
 		{

examples_tests/39.DenoiserTonemapper/CommandLineHandler.cpp

@@ -365,6 +365,8 @@ irr::core::matrix3x4SIMD CommandLineHandler::getCameraTransform(uint64_t id)
 			for (auto j = 0; j < 3u && sit != send; j++)
 				cameraTransform(i, j) = std::stof(*(sit++));
 
+		cameraTransform.rows[1] *= vectorSIMDf(-1.f, -1.f, -1.f, 1.f);
+
 		return cameraTransform;
 	};
 

examples_tests/39.DenoiserTonemapper/main.cpp

@@ -4,6 +4,7 @@
 #include <irrlicht.h>
 
 #include "CommandLineHandler.hpp"
+#include "irr/asset/filters/dithering/CPrecomputedDither.h"
 
 #include "../ext/ToneMapper/CToneMapper.h"
 #include "../../ext/OptiX/Manager.h"
@@ -426,6 +427,7 @@ void main()
 	uint32_t maxResolution[EII_COUNT][2] = { 0 };
 	{
 		asset::IAssetLoader::SAssetLoadParams lp(0ull,nullptr);
+
 		for (size_t i=0; i < inputFilesAmount; i++)
 		{
 			const auto imageIDString = makeImageIDString(i, colorFileNameBundle);
@@ -988,31 +990,53 @@ void main()
 				am->writeAsset(outputFileBundle[i].value().c_str(), wp);
 			}
 
-			auto getConvertedPNGImageView = [&](core::smart_refctd_ptr<ICPUImage> image)
+			auto getConvertedImageView = [&](core::smart_refctd_ptr<ICPUImage> image, const E_FORMAT& outFormat)
 			{
-				using CONVERSION_FILTER = CConvertFormatImageFilter<EF_UNKNOWN, EF_UNKNOWN, true>; // TESTING
-				constexpr auto pngFormat = EF_R8G8B8A8_SRGB;
+				using CONVERSION_FILTER = CConvertFormatImageFilter<EF_UNKNOWN, EF_UNKNOWN, false, true, asset::CPrecomputedDither>;
 
 				core::smart_refctd_ptr<ICPUImage> newConvertedImage;
 				{
 					auto referenceImageParams = image->getCreationParameters();
 					auto referenceBuffer = image->getBuffer();
 					auto referenceRegions = image->getRegions();
 					auto referenceRegion = referenceRegions.begin();
-					const auto newTexelOrBlockByteSize = asset::getTexelOrBlockBytesize(pngFormat);
+					const auto newTexelOrBlockByteSize = asset::getTexelOrBlockBytesize(outFormat);
 
 					auto newImageParams = referenceImageParams;
 					auto newCpuBuffer = core::make_smart_refctd_ptr<ICPUBuffer>(referenceRegion->getExtent().width * referenceRegion->getExtent().height * referenceRegion->getExtent().depth * newTexelOrBlockByteSize);
 					auto newRegions = core::make_refctd_dynamic_array<core::smart_refctd_dynamic_array<ICPUImage::SBufferCopy>>(1);
 
 					*newRegions->begin() = *referenceRegion;
 
-					newImageParams.format = pngFormat;
+					newImageParams.format = outFormat;
 					newConvertedImage = ICPUImage::create(std::move(newImageParams));
 					newConvertedImage->setBufferAndRegions(std::move(newCpuBuffer), newRegions);
 
 					CONVERSION_FILTER convertFilter;
 					CONVERSION_FILTER::state_type state;
+					
+					auto ditheringBundle = am->getAsset("../../media/blueNoiseDithering/LDR_RGBA.png", {});
+					const auto ditheringStatus = ditheringBundle.isEmpty();
+					if (ditheringStatus)
+					{
+						os::Printer::log("ERROR (" + std::to_string(__LINE__) + " line): Could not load the dithering image!", ELL_ERROR);
+						assert(ditheringStatus);
+					}
+					auto ditheringImage = core::smart_refctd_ptr_static_cast<asset::ICPUImage>(ditheringBundle.getContents().begin()[0]);
+
+					ICPUImageView::SCreationParams imageViewInfo;
+					imageViewInfo.image = ditheringImage;
+					imageViewInfo.format = ditheringImage->getCreationParameters().format;
+					imageViewInfo.viewType = decltype(imageViewInfo.viewType)::ET_2D;
+					imageViewInfo.components = {};
+					imageViewInfo.flags = static_cast<ICPUImageView::E_CREATE_FLAGS>(0u);
+					imageViewInfo.subresourceRange.baseArrayLayer = 0u;
+					imageViewInfo.subresourceRange.baseMipLevel = 0u;
+					imageViewInfo.subresourceRange.layerCount = ditheringImage->getCreationParameters().arrayLayers;
+					imageViewInfo.subresourceRange.levelCount = ditheringImage->getCreationParameters().mipLevels;
+
+					auto ditheringImageView = ICPUImageView::create(std::move(imageViewInfo));
+					state.ditherState = _IRR_NEW(std::remove_pointer<decltype(state.ditherState)>::type, ditheringImageView.get());
 
 					state.inImage = image.get();
 					state.outImage = newConvertedImage.get();
@@ -1030,6 +1054,8 @@ void main()
 
 					if (!convertFilter.execute(&state))
 						os::Printer::log("WARNING (" + std::to_string(__LINE__) + " line): Something went wrong while converting the image!", ELL_WARNING);
+
+					_IRR_DELETE(state.ditherState);
 				}
 
 				// create image view
@@ -1044,21 +1070,19 @@ void main()
 				return newImageView;
 			};
 
-//#if 0 // @Anastazluk uncomment when dither and clamp is done
-			// convert to .PNG and save it as well 
+			// convert to EF_R8G8B8_SRGB and save it as .png and .jpg
 			{
-				auto newImageView = getConvertedPNGImageView(imageView->getCreationParameters().image);
+				auto newImageView = getConvertedImageView(imageView->getCreationParameters().image, EF_R8G8B8_SRGB);
 				IAssetWriter::SAssetWriteParams wp(newImageView.get());
 				std::string fileName = outputFileBundle[i].value().c_str();
 
 				while (fileName.back() != '.')
 					fileName.pop_back();
 
-				fileName += "png";
-
-				am->writeAsset(fileName, wp);
+				const std::string& nonFormatFileName = fileName;
+				am->writeAsset(nonFormatFileName + "png", wp);
+				am->writeAsset(nonFormatFileName + "jpg", wp);
 			}
-//#endif
 
 			// destroy link to CPUBuffer's data (we need to free it)
 			imageView->convertToDummyObject(~0u);

examples_tests/42.FragmentShaderPathTracer/common.glsl

@@ -1,6 +1,6 @@
 // basic settings
 #define MAX_DEPTH 8
-#define SAMPLES 16
+#define SAMPLES 128
 
 // firefly and variance reduction techniques
 //#define KILL_DIFFUSE_SPECULAR_PATHS
@@ -322,7 +322,6 @@ void missProgram()
     rayStack[stackPtr]._payload.accumulation += finalContribution;
 }
 
-#include <irr/builtin/glsl/bxdf/brdf/cos_weighted_sample.glsl>
 #include <irr/builtin/glsl/bxdf/brdf/diffuse/oren_nayar.glsl>
 #include <irr/builtin/glsl/bxdf/brdf/specular/ggx.glsl>
 #include <irr/builtin/glsl/bxdf/bsdf/specular/dielectric.glsl>

examples_tests/42.FragmentShaderPathTracer/main.cpp

@@ -250,7 +250,7 @@ int main()
 		return { gpuPipeline, gpuMeshBuffer };
 	};
 
-	constexpr bool litByTriangle = true;
+	constexpr bool litByTriangle = false;
 	auto gpuEnvmapResources = createGpuResources(litByTriangle ? "../litByTriangle.frag":"../litBySphere.frag");
 	auto gpuEnvmapPipeline = gpuEnvmapResources.first;
 	auto gpuEnvmapMeshBuffer = gpuEnvmapResources.second;

examples_tests/43A.SumAndCDFFilters/main.cpp

@@ -22,7 +22,7 @@ using namespace video;
 */
 
 // #define IMAGE_VIEW 
-// #define OVERLAPPING_REGIONS				// @devsh I leave it for you
+// #define OVERLAPPING_REGIONS			
 constexpr bool EXCLUSIVE_SUM = true;
 constexpr auto MIPMAP_IMAGE_VIEW = 2u;		// feel free to change the mipmap
 constexpr auto MIPMAP_IMAGE = 0u;			// ordinary image used in the example has only 0-th mipmap
@@ -268,7 +268,7 @@ int main()
 	{
 		auto outImage = core::move_and_static_cast<ICPUImage>(inImage->clone());
 
-		using DISCRETE_CONVOLUTION_BLIT_FILTER = asset::CBlitImageFilter<CDiscreteConvolutionFilterKernel,CDiscreteConvolutionFilterKernel,CBoxImageFilterKernel>;
+		using DISCRETE_CONVOLUTION_BLIT_FILTER = asset::CBlitImageFilter<false,true,DefaultSwizzle,CWhiteNoiseDither,CDiscreteConvolutionFilterKernel,CDiscreteConvolutionFilterKernel,CBoxImageFilterKernel>;
 		DISCRETE_CONVOLUTION_BLIT_FILTER blitImageFilter;
 		DISCRETE_CONVOLUTION_BLIT_FILTER::state_type state;
 
@@ -291,12 +291,16 @@ int main()
 		state.outExtentLayerCount = extentLayerCount;
 		state.outImage = outImage.get();
 
+		state.swizzle = {};
+
+		state.ditherState = _IRR_NEW(std::remove_pointer<decltype(state.ditherState)>::type);
 		state.scratchMemoryByteSize = blitImageFilter.getRequiredScratchByteSize(&state);
 		state.scratchMemory = reinterpret_cast<uint8_t*>(_IRR_ALIGNED_MALLOC(state.scratchMemoryByteSize, 32));
 
 		if (!blitImageFilter.execute(&state))
 			os::Printer::log("Something went wrong while performing discrete convolution operation!", ELL_WARNING);
 
+		_IRR_DELETE(state.ditherState);
 		_IRR_ALIGNED_FREE(state.scratchMemory);
 
 		return outImage;