Fixes and Support for screenshoting multiple sensors

Author: Erfan-Ahmadi

examples_tests/22.RaytracedAO/Renderer.cpp

@@ -837,12 +837,12 @@ void Renderer::deinitSceneResources()
 	m_rasterInstanceDataDS = nullptr;
 	m_globalBackendDataDS = nullptr;
 
-	m_cullPipeline = nullptr;
-	m_raygenPipeline = nullptr;
-	m_closestHitPipeline = nullptr;
-	m_resolvePipeline = nullptr;
-
 	m_perCameraRasterDS = nullptr;
+	
+	m_cullPipelineLayout = nullptr;
+	m_raygenPipelineLayout = nullptr;
+	m_closestHitPipelineLayout = nullptr;
+	m_resolvePipelineLayout = nullptr;
 
 	m_cullWorkGroups = 0u;
 	m_cullPushConstants = {core::matrix4SIMD(),1.f,0u,0u,0u};
@@ -923,16 +923,16 @@ void Renderer::initScreenSizedResources(uint32_t width, uint32_t height, core::s
 		).close();
 
 		// cull
-		m_cullPipeline = m_driver->createGPUComputePipeline(nullptr,std::move(m_cullPipelineLayout),gpuSpecializedShaderFromFile(m_assetManager,m_driver,"../cull.comp"));
+		m_cullPipeline = m_driver->createGPUComputePipeline(nullptr,core::smart_refctd_ptr(m_cullPipelineLayout),gpuSpecializedShaderFromFile(m_assetManager,m_driver,"../cull.comp"));
 
 		// raygen
-		m_raygenPipeline = m_driver->createGPUComputePipeline(nullptr,std::move(m_raygenPipelineLayout),gpuSpecializedShaderFromFile(m_assetManager,m_driver,"../raygen.comp"));
+		m_raygenPipeline = m_driver->createGPUComputePipeline(nullptr,core::smart_refctd_ptr(m_raygenPipelineLayout),gpuSpecializedShaderFromFile(m_assetManager,m_driver,"../raygen.comp"));
 
 		// closest hit
-		m_closestHitPipeline = m_driver->createGPUComputePipeline(nullptr,std::move(m_closestHitPipelineLayout),gpuSpecializedShaderFromFile(m_assetManager,m_driver,"../closestHit.comp"));
+		m_closestHitPipeline = m_driver->createGPUComputePipeline(nullptr,core::smart_refctd_ptr(m_closestHitPipelineLayout),gpuSpecializedShaderFromFile(m_assetManager,m_driver,"../closestHit.comp"));
 
 		// resolve
-		m_resolvePipeline = m_driver->createGPUComputePipeline(nullptr,std::move(m_resolvePipelineLayout),gpuSpecializedShaderFromFile(m_assetManager,m_driver,m_useDenoiser ? "../resolveForDenoiser.comp":"../resolve.comp"));
+		m_resolvePipeline = m_driver->createGPUComputePipeline(nullptr,core::smart_refctd_ptr(m_resolvePipelineLayout),gpuSpecializedShaderFromFile(m_assetManager,m_driver,m_useDenoiser ? "../resolveForDenoiser.comp":"../resolve.comp"));
 	}
 
 	auto setBufferInfo = [&](IGPUDescriptorSet::SDescriptorInfo* info, const core::smart_refctd_ptr<IGPUBuffer>& buffer) -> void
@@ -1202,11 +1202,17 @@ void Renderer::deinitScreenSizedResources()
 
 	m_raygenWorkGroups[0] = m_raygenWorkGroups[1] = 0u;
 
+	m_cullPipeline = nullptr;
+	m_raygenPipeline = nullptr;
+	m_closestHitPipeline = nullptr;
+	m_resolvePipeline = nullptr;
+
 	m_staticViewData = {{0.f,0.f,0.f},0u,{0u,0u},0u,0u};
 	m_totalRaysCast = 0ull;
 	m_rcpPixelSize = {0.f,0.f};
 	m_framesDispatched = 0u;
 	std::fill_n(m_prevView.pointer(),12u,0.f);
+	m_prevCamTform = nbl::core::matrix4x3();
 }
 
 

examples_tests/22.RaytracedAO/main.cpp

@@ -49,7 +49,8 @@ int main(int argc, char** argv)
 	std::string outputScreenshotsFolderPath = cmdHandler.getOutputScreenshotsFolderPath();
 	bool shouldTerminate = cmdHandler.getTerminate(); // skip interaction with window and take screenshots only
 	bool takeScreenShots = true;
-	
+	std::string mainFileName; // std::filesystem::path(filePath).filename().string();
+
 	// create device with full flexibility over creation parameters
 	// you can add more parameters if desired, check nbl::SIrrlichtCreationParameters
 	nbl::SIrrlichtCreationParameters params;
@@ -89,6 +90,9 @@ int main(int argc, char** argv)
 
 		if(filePath.empty())
 			filePath = "../../media/mitsuba/staircase2.zip";
+		
+		mainFileName = std::filesystem::path(filePath).filename().string();
+		mainFileName = mainFileName.substr(0u, mainFileName.find_first_of('.')); 
 
 		if (core::hasFileExtension(io::path(filePath.c_str()), "zip", "ZIP"))
 		{
@@ -183,6 +187,7 @@ int main(int argc, char** argv)
 		float moveSpeed = core::nan<float>();
 		scene::ICameraSceneNode * staticCamera;
 		scene::ICameraSceneNode * interactiveCamera;
+		std::string outputFileName = "";
 	};
 
 	auto smgr = device->getSceneManager();
@@ -342,15 +347,12 @@ int main(int argc, char** argv)
 
 	bool rightHandedCamera = true;
 	float moveSpeed = core::nan<float>();
-	uint32_t sensorSamplesNeeded = 0u;
 
 	if (globalMeta->m_global.m_sensors.size() && isOkSensorType(globalMeta->m_global.m_sensors.front()))
 	{
 		const auto& sensor = globalMeta->m_global.m_sensors.front();
 		const auto& film = sensor.film;
 
-		sensorSamplesNeeded = sensor.sampler.sampleCount;
-
 		// need to extract individual components
 		{
 			auto relativeTransform = sensor.transform.matrix.extractSub3x4();
@@ -489,33 +491,31 @@ int main(int argc, char** argv)
 	renderer->initSceneResources(meshes);
 	meshes = {}; // free memory
 
+	uint32_t activeSensor = 0u; // that outputs to current window when not in TERMIANTE mode.
+
 	auto extent = renderer->getSceneBound().getExtent();
-	smgr->setActiveCamera(camera);
+	smgr->setActiveCamera(sensors[activeSensor].interactiveCamera);
 
 	QToQuitEventReceiver receiver;
 	device->setEventReceiver(&receiver);
 
-	renderer->initScreenSizedResources(sensors[0].width, sensors[0].height, std::move(sampleSequence));
+	renderer->initScreenSizedResources(sensors[activeSensor].width, sensors[activeSensor].height, std::move(sampleSequence));
 
 	uint64_t lastFPSTime = 0;
 	auto start = std::chrono::steady_clock::now();
 	while (device->run() && receiver.keepOpen())
 	{
 		driver->beginScene(false, false);
 
-		std::cout << "Camera Position Before Render: (" << camera->getPosition().X << "," << camera->getPosition().Y << "," << camera->getPosition().Z << ")" << std::endl;
-		std::cout << "Target Before Render: (" << camera->getTarget().X << "," << camera->getTarget().Y << "," << camera->getTarget().Z << ")" << std::endl;
 		renderer->render(device->getTimer());
-		std::cout << "Camera Position After Render: (" << camera->getPosition().X << "," << camera->getPosition().Y << "," << camera->getPosition().Z << ")" << std::endl;
-		std::cout << "Target After Render: (" << camera->getTarget().X << "," << camera->getTarget().Y << "," << camera->getTarget().Z << ")" << std::endl;
 
 		auto oldVP = driver->getViewPort();
 		driver->blitRenderTargets(renderer->getColorBuffer(),nullptr,false,false,{},{},true);
 		driver->setViewPort(oldVP);
 
 		driver->endScene();
 
-		if(shouldTerminate && renderer->getTotalSamplesPerPixelComputed() >= sensorSamplesNeeded)
+		if(shouldTerminate && renderer->getTotalSamplesPerPixelComputed() >= sensors[activeSensor].samplesNeeded)
 			break;
 
 		// display frames per second in window title
@@ -532,9 +532,54 @@ int main(int argc, char** argv)
 			lastFPSTime = time;
 		}
 	}
-
-	renderer->takeAndSaveScreenShot("tonemapped", outputScreenshotsFolderPath);
+	
+	renderer->takeAndSaveScreenShot("LastView_" + mainFileName + "_Sensor_" + std::to_string(activeSensor), outputScreenshotsFolderPath);
 	renderer->deinitScreenSizedResources();
+
+	for(uint32_t s = 0u; s < sensors.size(); ++s)
+	{
+		const auto& sensorData = sensors[s];
+		
+		std::cout << "-- Rendering  " << filePath << " (Sensor=" << s << ") to file..." << std::endl;
+		smgr->setActiveCamera(sensorData.staticCamera);
+
+		renderer->initScreenSizedResources(sensors[0].width, sensors[0].height, std::move(sampleSequence));
+
+		const uint32_t samplesPerPixelPerDispatch = renderer->getSamplesPerPixelPerDispatch();
+		const uint32_t maxNeededIterations = (sensorData.samplesNeeded + samplesPerPixelPerDispatch - 1) / samplesPerPixelPerDispatch;
+		
+		uint32_t itr = 0u;
+		bool takenEnoughSamples = false;
+
+		while(!takenEnoughSamples)
+		{
+			if(itr >= maxNeededIterations)
+				std::cout << "[ERROR] Samples taken (" << renderer->getTotalSamplesPerPixelComputed() << ") must've exceeded samples needed for Sensor (" << sensorData.samplesNeeded << ") by now; something is wrong." << std::endl;
+
+			driver->beginScene(false, false);
+			renderer->render(device->getTimer());
+			auto oldVP = driver->getViewPort();
+			driver->blitRenderTargets(renderer->getColorBuffer(),nullptr,false,false,{},{},true);
+			driver->setViewPort(oldVP);
+
+			driver->endScene();
+			
+			if(renderer->getTotalSamplesPerPixelComputed() >= sensorData.samplesNeeded)
+				takenEnoughSamples = true;
+			
+			itr++;
+		}
+
+		auto screenshotFileNameWithoutExtension = sensorData.outputFileName;
+		if (screenshotFileNameWithoutExtension.empty())
+			screenshotFileNameWithoutExtension = "ScreenShot_" + mainFileName + "_Sensor_" + std::to_string(s);
+		
+		std::cout << "-- Rendered Successfully: " << filePath << " (Sensor=" << s << ") to file (" << screenshotFileNameWithoutExtension << ")." << std::endl;
+
+		renderer->takeAndSaveScreenShot(screenshotFileNameWithoutExtension, outputScreenshotsFolderPath);
+		renderer->deinitScreenSizedResources();
+	}
+
 	renderer->deinitSceneResources();
 	renderer = nullptr;