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

Author: Przemog1

examples_tests/18.MitsubaLoader/main.cpp

@@ -9,6 +9,8 @@
 #include "../../ext/MitsubaLoader/CMitsubaLoader.h"
 #include <irr/video/IGPUVirtualTexture.h>
 
+#define USE_ENVMAP
+
 using namespace irr;
 using namespace core;
 
@@ -17,6 +19,7 @@ R"(
 #define _IRR_COMPUTE_LIGHTING_DEFINED_
 
 #include <irr/builtin/glsl/format/decode.glsl>
+#include <irr/builtin/glsl/random/xoroshiro.glsl>
 
 struct SLight
 {
@@ -29,6 +32,15 @@ layout (set = 2, binding = 0, std430) readonly restrict buffer Lights
 	SLight lights[];
 };
 layout(set = 2, binding = 1) uniform sampler2D envMap;
+layout(set = 2, binding = 2) uniform usamplerBuffer sampleSequence;
+layout(set = 2, binding = 3) uniform usampler2D scramblebuf;
+
+vec2 rand2d(in uint _sample, inout irr_glsl_xoroshiro64star_state_t scramble_state)
+{
+	uvec2 seqVal = texelFetch(sampleSequence,int(_sample)).xy;
+	seqVal ^= uvec2(irr_glsl_xoroshiro64star(scramble_state),irr_glsl_xoroshiro64star(scramble_state));
+    return vec2(seqVal)*uintBitsToFloat(0x2f800004u);
+}
 
 vec2 SampleSphericalMap(in vec3 v)
 {
@@ -40,41 +52,60 @@ vec2 SampleSphericalMap(in vec3 v)
 
 vec3 irr_computeLighting(inout irr_glsl_IsotropicViewSurfaceInteraction out_interaction, in mat2 dUV)
 {
+	irr_glsl_xoroshiro64star_state_t scramble_start_state = textureLod(scramblebuf,gl_FragCoord.xy/VIEWPORT_SZ,0).rg;
+
 	vec3 emissive = irr_glsl_decodeRGB19E7(InstData.data[InstanceIndex].emissive);
 
 	vec3 color = vec3(0.0);
-/*
+
+#ifdef USE_ENVMAP
 	instr_stream_t gcs = getGenChoiceStream();
-	const int N = 100;
-	for (int i = 0; i < N; ++i)
+	for (int i = 0; i < SAMPLE_COUNT; ++i)
 	{
-		vec3 rem;
-		vec2 rand;//TODO
-		vec3 L = runGeneratorChoiceStream(gcs, rand, rem);
+		irr_glsl_xoroshiro64star_state_t scramble_state = scramble_start_state;
+
+		instr_stream_t gcs = getGenChoiceStream();
+		instr_stream_t rnps = getRemAndPdfStream();
+
+		vec2 rand = rand2d(i,scramble_state);//TODO has to be 3d
+		float pdf;
+		runGenerateAndRemainderStream(gcs, rnps, rand, pdf);
+
 		vec2 uv = SampleSphericalMap(L);
 		color += rem*textureLod(envMap, uv, 0.0).xyz;
 	}
-*/
+	color /= float(SAMPLE_COUNT);
+#endif
+
 	irr_glsl_BSDFIsotropicParams params;
-	for (int i = 0; i < 13; ++i)
+	for (int i = 0; i < LIGHT_COUNT; ++i)
 	{
 		SLight l = lights[i];
 		vec3 L = l.position-WorldPos;
 		params.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);
+		const float intensityScale = LIGHT_INTENSITY_SCALE;//ehh might want to render to hdr fbo and do tonemapping
+		color += irr_bsdf_cos_eval(params, out_interaction, dUV)*l.intensity*intensityScale / dot(L,L);
 	}
 
 	return color+emissive;
 }
 )";
-static core::smart_refctd_ptr<asset::ICPUSpecializedShader> createModifiedFragShader(const asset::ICPUSpecializedShader* _fs)
+static core::smart_refctd_ptr<asset::ICPUSpecializedShader> createModifiedFragShader(const asset::ICPUSpecializedShader* _fs, uint32_t viewport_w, uint32_t viewport_h, uint32_t lightCnt, uint32_t smplCnt, float intensityScale)
 {
     const asset::ICPUShader* unspec = _fs->getUnspecialized();
     assert(unspec->containsGLSL());
 
     std::string glsl = reinterpret_cast<const char*>( unspec->getSPVorGLSL()->getPointer() );
-    glsl.insert(glsl.find("#ifndef _IRR_COMPUTE_LIGHTING_DEFINED_"), GLSL_COMPUTE_LIGHTING);
+	std::string extra = "\n#define VIEWPORT_SZ vec2(" + std::to_string(viewport_w)+","+std::to_string(viewport_h)+")" +
+		"\n#define LIGHT_COUNT " + std::to_string(lightCnt) +
+		"\n#define SAMPLE_COUNT " + std::to_string(smplCnt) +
+		"\n#define LIGHT_INTENSITY_SCALE " + std::to_string(intensityScale) +
+#ifdef USE_ENVMAP
+		"\n#define USE_ENVMAP" +
+#endif
+		GLSL_COMPUTE_LIGHTING;
+
+    glsl.insert(glsl.find("#ifndef _IRR_COMPUTE_LIGHTING_DEFINED_"), extra);
 
     //auto* f = fopen("fs.glsl","w");
     //fwrite(glsl.c_str(), 1, glsl.size(), f);
@@ -244,7 +275,7 @@ int main()
 
 	core::smart_refctd_ptr<asset::ICPUDescriptorSetLayout> ds2layout;
 	{
-		asset::ICPUDescriptorSetLayout::SBinding bnd[2];
+		asset::ICPUDescriptorSetLayout::SBinding bnd[4];
 		bnd[0].binding = 0u;
 		bnd[0].count = 1u;
 		bnd[0].samplers = nullptr;
@@ -260,39 +291,30 @@ int main()
 		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);
+		bnd[2].binding = 2u;
+		bnd[2].count = 1u;
+		bnd[2].samplers = nullptr;
+		bnd[2].stageFlags = asset::ISpecializedShader::ESS_FRAGMENT;
+		bnd[2].type = asset::EDT_UNIFORM_TEXEL_BUFFER;
+
+		samplerParams = { ISampler::ETC_CLAMP_TO_EDGE, ISampler::ETC_CLAMP_TO_EDGE, ISampler::ETC_CLAMP_TO_EDGE, ISampler::ETBC_INT_OPAQUE_BLACK, ISampler::ETF_NEAREST, ISampler::ETF_NEAREST, ISampler::ESMM_NEAREST, 0u, false, ECO_ALWAYS };
+		auto smplr_int = core::make_smart_refctd_ptr<asset::ICPUSampler>(samplerParams);
+		bnd[3].binding = 3u;
+		bnd[3].count = 1u;
+		bnd[3].samplers = &smplr_int;
+		bnd[3].stageFlags = asset::ISpecializedShader::ESS_FRAGMENT;
+		bnd[3].type = asset::EDT_COMBINED_IMAGE_SAMPLER;
+
+		ds2layout = core::make_smart_refctd_ptr<asset::ICPUDescriptorSetLayout>(bnd, bnd + 4);
 	}
 
 	//gather all meshes into core::vector and modify their pipelines
-	core::unordered_set<const asset::ICPURenderpassIndependentPipeline*> modifiedPipelines;
-	core::unordered_map<core::smart_refctd_ptr<asset::ICPUSpecializedShader>, core::smart_refctd_ptr<asset::ICPUSpecializedShader>> modifiedShaders;
 	core::vector<core::smart_refctd_ptr<asset::ICPUMesh>> cpumeshes;
 	cpumeshes.reserve(meshes.getSize());
 	for (auto it = meshes.getContents().begin(); it != meshes.getContents().end(); ++it)
 	{
 		cpumeshes.push_back(core::smart_refctd_ptr_static_cast<asset::ICPUMesh>(std::move(*it)));
-		//modify pipeline layouts with our custom DS2 layout (DS2 will be used for lights buffer)
-		for (uint32_t i = 0u; i < cpumeshes.back()->getMeshBufferCount(); ++i)
-		{
-			auto* pipeline = cpumeshes.back()->getMeshBuffer(i)->getPipeline();
-			if (modifiedPipelines.find(pipeline)==modifiedPipelines.end())
-			{
-				//if (!pipeline->getLayout()->getDescriptorSetLayout(2u))
-				pipeline->getLayout()->setDescriptorSetLayout(2u, core::smart_refctd_ptr(ds2layout));
-				auto* fs = pipeline->getShaderAtStage(asset::ICPUSpecializedShader::ESS_FRAGMENT);
-				auto found = modifiedShaders.find(core::smart_refctd_ptr<asset::ICPUSpecializedShader>(fs));
-				if (found != modifiedShaders.end())
-					pipeline->setShaderAtStage(asset::ICPUSpecializedShader::ESS_FRAGMENT, found->second.get());
-				else {
-					auto newfs = createModifiedFragShader(fs);
-					modifiedShaders.insert({ core::smart_refctd_ptr<asset::ICPUSpecializedShader>(fs),newfs});
-					pipeline->setShaderAtStage(asset::ICPUSpecializedShader::ESS_FRAGMENT, newfs.get());
-				}
-				modifiedPipelines.insert(pipeline);
-			}
-		}
 	}
-	modifiedShaders.clear();
 
 	core::smart_refctd_ptr<asset::ICPUDescriptorSet> cpuds0;
 	{
@@ -370,7 +392,35 @@ int main()
 		}
 	}
 
-	constexpr uint32_t MAX_INSTANCES = 512u;
+	constexpr uint32_t ENVMAP_SAMPLE_COUNT = 64u;
+	constexpr float LIGHT_INTENSITY_SCALE = 0.01f;
+
+	core::unordered_set<const asset::ICPURenderpassIndependentPipeline*> modifiedPipelines;
+	core::unordered_map<core::smart_refctd_ptr<asset::ICPUSpecializedShader>, core::smart_refctd_ptr<asset::ICPUSpecializedShader>> modifiedShaders;
+	for (auto& mesh : cpumeshes)
+	{
+		//modify pipeline layouts with our custom DS2 layout (DS2 will be used for lights buffer)
+		for (uint32_t i = 0u; i < mesh->getMeshBufferCount(); ++i)
+		{
+			auto* pipeline = mesh->getMeshBuffer(i)->getPipeline();
+			if (modifiedPipelines.find(pipeline) == modifiedPipelines.end())
+			{
+				//if (!pipeline->getLayout()->getDescriptorSetLayout(2u))
+				pipeline->getLayout()->setDescriptorSetLayout(2u, core::smart_refctd_ptr(ds2layout));
+				auto* fs = pipeline->getShaderAtStage(asset::ICPUSpecializedShader::ESS_FRAGMENT);
+				auto found = modifiedShaders.find(core::smart_refctd_ptr<asset::ICPUSpecializedShader>(fs));
+				if (found != modifiedShaders.end())
+					pipeline->setShaderAtStage(asset::ICPUSpecializedShader::ESS_FRAGMENT, found->second.get());
+				else {
+					auto newfs = createModifiedFragShader(fs, params.WindowSize.Width, params.WindowSize.Height, lights.size(), ENVMAP_SAMPLE_COUNT, LIGHT_INTENSITY_SCALE);
+					modifiedShaders.insert({ core::smart_refctd_ptr<asset::ICPUSpecializedShader>(fs),newfs });
+					pipeline->setShaderAtStage(asset::ICPUSpecializedShader::ESS_FRAGMENT, newfs.get());
+				}
+				modifiedPipelines.insert(pipeline);
+			}
+		}
+	}
+	modifiedShaders.clear();
 
 	core::aabbox3df sceneBound;
 	auto gpumeshes = driver->getGPUObjectsFromAssets(cpumeshes.data(), cpumeshes.data()+cpumeshes.size());
@@ -424,11 +474,63 @@ int main()
         driver->updateDescriptorSets(1u, &write, 0u, nullptr);
     }
 
+	smart_refctd_ptr<video::IGPUBufferView> gpuSequenceBufferView;
+	{
+		constexpr uint32_t MaxSamples = ENVMAP_SAMPLE_COUNT;
+
+		auto sampleSequence = core::make_smart_refctd_ptr<asset::ICPUBuffer>(sizeof(uint32_t) * MaxSamples*2u);
+
+		core::OwenSampler sampler(1u, 0xdeadbeefu);
+
+		auto out = reinterpret_cast<uint32_t*>(sampleSequence->getPointer());
+		for (uint32_t i = 0; i < MaxSamples*2u; i++)
+		{
+			out[i] = sampler.sample(i&1u, i>>1);
+		}
+		auto gpuSequenceBuffer = driver->createFilledDeviceLocalGPUBufferOnDedMem(sampleSequence->getSize(), sampleSequence->getPointer());
+		gpuSequenceBufferView = driver->createGPUBufferView(gpuSequenceBuffer.get(), asset::EF_R32G32_UINT);
+	}
+
+	smart_refctd_ptr<video::IGPUImageView> gpuScrambleImageView;
+	{
+		video::IGPUImage::SCreationParams imgParams;
+		imgParams.flags = static_cast<asset::IImage::E_CREATE_FLAGS>(0u);
+		imgParams.type = asset::IImage::ET_2D;
+		imgParams.format = asset::EF_R32G32_UINT;
+		imgParams.extent = {params.WindowSize.Width,params.WindowSize.Height,1u};
+		imgParams.mipLevels = 1u;
+		imgParams.arrayLayers = 1u;
+		imgParams.samples = asset::IImage::ESCF_1_BIT;
+
+		video::IGPUImage::SBufferCopy region;
+		region.imageExtent = imgParams.extent;
+		region.imageSubresource.layerCount = 1u;
+
+		constexpr auto ScrambleStateChannels = 2u;
+		const auto renderPixelCount = imgParams.extent.width*imgParams.extent.height;
+		core::vector<uint32_t> random(renderPixelCount*ScrambleStateChannels);
+		{
+			core::RandomSampler rng(0xbadc0ffeu);
+			for (auto& pixel : random)
+				pixel = rng.nextSample();
+		}
+		auto buffer = driver->createFilledDeviceLocalGPUBufferOnDedMem(random.size()*sizeof(uint32_t),random.data());
+
+		video::IGPUImageView::SCreationParams viewParams;
+		viewParams.flags = static_cast<video::IGPUImageView::E_CREATE_FLAGS>(0u);
+		viewParams.image = driver->createFilledDeviceLocalGPUImageOnDedMem(std::move(imgParams),buffer.get(),1u,&region);
+		viewParams.viewType = video::IGPUImageView::ET_2D;
+		viewParams.format = asset::EF_R32G32_UINT;
+		viewParams.subresourceRange.levelCount = 1u;
+		viewParams.subresourceRange.layerCount = 1u;
+		gpuScrambleImageView = driver->createGPUImageView(std::move(viewParams));
+	}
+
 	auto gpuds2layout = driver->getGPUObjectsFromAssets(&ds2layout.get(), &ds2layout.get()+1)->front();
 	auto gpuds2 = driver->createGPUDescriptorSet(std::move(gpuds2layout));
 	{
-		video::IGPUDescriptorSet::SDescriptorInfo info[2];
-		video::IGPUDescriptorSet::SWriteDescriptorSet w[2];
+		video::IGPUDescriptorSet::SDescriptorInfo info[4];
+		video::IGPUDescriptorSet::SWriteDescriptorSet w[4];
 		w[0].arrayElement = 0u;
 		w[0].binding = 0u;
 		w[0].count = 1u;
@@ -451,7 +553,25 @@ int main()
 		info[1].image.sampler = nullptr;
 		info[1].desc = std::move(gpuEnvmapImageView);
 
-		driver->updateDescriptorSets(2u, w, 0u, nullptr);
+		w[2].arrayElement = 0u;
+		w[2].binding = 2u;
+		w[2].count = 1u;
+		w[2].descriptorType = asset::EDT_UNIFORM_TEXEL_BUFFER;
+		w[2].dstSet = gpuds2.get();
+		w[2].info = info+2;
+		info[2].desc = gpuSequenceBufferView;
+
+		w[3].arrayElement = 0u;
+		w[3].binding = 3u;
+		w[3].count = 1u;
+		w[3].descriptorType = asset::EDT_COMBINED_IMAGE_SAMPLER;
+		w[3].dstSet = gpuds2.get();
+		w[3].info = info+3;
+		info[3].image.imageLayout = asset::EIL_UNDEFINED;
+		info[3].image.sampler = nullptr;//imm sampler is present
+		info[3].desc = gpuScrambleImageView;
+
+		driver->updateDescriptorSets(4u, w, 0u, nullptr);
 	}
 
 	// camera and viewport
@@ -561,6 +681,7 @@ int main()
 	uint64_t lastFPSTime = 0;
 	float lastFastestMeshFrameNr = -1.f;
 
+	constexpr uint32_t MAX_INSTANCES = 512u;
 	core::vector<core::matrix4SIMD> uboData(MAX_INSTANCES);
 	while (device->run() && receiver.keepOpen())
 	{

examples_tests/23.Autoexposure/main.cpp

@@ -39,7 +39,7 @@ int main()
 	IAssetManager* am = device->getAssetManager();
 
 	IAssetLoader::SAssetLoadParams lp;
-	auto imageBundle = am->getAsset("../../media/OpenEXR/56_render_0_2_256.exr", lp);
+	auto imageBundle = am->getAsset("../../media/noises/spp_benchmark_4k_512.exr", lp);
 
 	E_FORMAT inFormat;
 	constexpr auto outFormat = EF_R8G8B8A8_SRGB;

examples_tests/26.MultidrawIndirectVSCPUCull/boxFrustCull.comp

@@ -1,8 +1,8 @@
 #version 430 core
 
 #include "common.glsl"
-
 #include "commonIndirect.glsl"
+
 layout(local_size_x = kCullWorkgroupSize) in;
 
 layout(set = 1, binding = 0, std430, row_major) restrict writeonly buffer PerDraw
@@ -11,7 +11,7 @@ layout(set = 1, binding = 0, std430, row_major) restrict writeonly buffer PerDra
 };
 layout(set = 1, binding = 1, std430) restrict writeonly buffer IndirectDraws
 {
-    DrawElementsIndirectCommand_t draws[];
+    irr_glsl_DrawElementsIndirectCommand_t draws[];
 };
 layout(set = 1, binding = 2, std430, row_major) restrict readonly buffer PerInstance
 {

examples_tests/26.MultidrawIndirectVSCPUCull/common.glsl

@@ -23,5 +23,10 @@ struct DrawData_t
 };
 
 #ifndef __cplusplus
-#include <irr/builtin/glsl/utils/vertex.glsl>
+#include <irr/builtin/glsl/utils/common.glsl>
+#include <irr/builtin/glsl/utils/transform.glsl>
+
+#include <irr/builtin/glsl/utils/indirect_commands.glsl>
+
+#include <irr/builtin/glsl/utils/culling.glsl>
 #endif

examples_tests/26.MultidrawIndirectVSCPUCull/commonIndirect.glsl

@@ -4,15 +4,6 @@
     #define mat3 core::matrix3x4SIMD
 #endif
 
-struct DrawElementsIndirectCommand_t
-{
-    uint count;
-    uint instanceCount;
-    uint firstIndex;
-    uint baseVertex;
-    uint baseInstance;
-};
-
 struct CullShaderData_t
 {
     mat4 viewProjMatrix;

examples_tests/29.SpecializationConstants/particles.vert

@@ -2,7 +2,8 @@
 
 layout (location = 0) in vec3 vPos;
 
-#include <irr/builtin/glsl/utils/vertex.glsl>
+#include <irr/builtin/glsl/utils/common.glsl>
+#include <irr/builtin/glsl/utils/transform.glsl>
 
 layout (set = 0, binding = 0, row_major, std140) uniform UBO
 {

examples_tests/35.GeometryCreator/main.cpp

@@ -43,7 +43,8 @@ const char* vertexSource = R"===(
 layout(location = 0) in vec4 vPos;
 layout(location = 3) in vec3 vNormal;
 
-#include <irr/builtin/glsl/utils/vertex.glsl>
+#include <irr/builtin/glsl/utils/common.glsl>
+#include <irr/builtin/glsl/utils/transform.glsl>
 #include <irr/builtin/glsl/broken_driver_workarounds/amd.glsl>
 
 layout( push_constant, row_major ) uniform Block {