Merge branch 'master' into mesh_loaders_kevin

Author: kevyuu

09_GeometryCreator/main.cpp

@@ -37,25 +37,32 @@ class GeometryCreatorApp final : public MonoWindowApplication, public BuiltinRes
 			}
 
 			const uint32_t addtionalBufferOwnershipFamilies[] = {getGraphicsQueue()->getFamilyIndex()};
-			// we want to use the vertex data through UTBs
-			using usage_f = IGPUBuffer::E_USAGE_FLAGS;
-			CAssetConverter::patch_t<asset::ICPUPolygonGeometry> patch = {};
-			patch.positionBufferUsages = usage_f::EUF_UNIFORM_TEXEL_BUFFER_BIT;
-			patch.indexBufferUsages = usage_f::EUF_INDEX_BUFFER_BIT;
-			patch.otherBufferUsages = usage_f::EUF_UNIFORM_TEXEL_BUFFER_BIT;
 			m_scene = CGeometryCreatorScene::create(
 				{
 					.transferQueue = getTransferUpQueue(),
 					.utilities = m_utils.get(),
 					.logger = m_logger.get(),
 					.addtionalBufferOwnershipFamilies = addtionalBufferOwnershipFamilies
-				},patch
+				},
+				CSimpleDebugRenderer::DefaultPolygonGeometryPatch // we want to use the vertex data through UTBs
 			);
 
 			auto scRes = static_cast<CDefaultSwapchainFramebuffers*>(m_surface->getSwapchainResources());
-			m_renderer = CSimpleDebugRenderer::create(m_assetMgr.get(),scRes->getRenderpass(),0,m_scene.get());
-			if (!m_renderer)
+			const auto& geometries = m_scene->getInitParams().geometries;
+			m_renderer = CSimpleDebugRenderer::create(m_assetMgr.get(),scRes->getRenderpass(),0,{&geometries.front().get(),geometries.size()});
+			if (!m_renderer || m_renderer->getGeometries().size() != geometries.size())
 				return logFail("Could not create Renderer!");
+			// special case
+			{
+				const auto& pipelines = m_renderer->getInitParams().pipelines;
+				auto ix = 0u;
+				for (const auto& name : m_scene->getInitParams().geometryNames)
+				{
+					if (name=="Cone")
+						m_renderer->getGeometry(ix).pipeline = pipelines[CSimpleDebugRenderer::SInitParams::PipelineType::Cone];
+					ix++;
+				}
+			}
 			m_renderer->m_instances.resize(1);
 			m_renderer->m_instances[0].world = float32_t3x4(
 				float32_t4(1,0,0,0),
@@ -143,7 +150,7 @@ class GeometryCreatorApp final : public MonoWindowApplication, public BuiltinRes
 			const auto viewParams = CSimpleDebugRenderer::SViewParams(viewMatrix,viewProjMatrix);
 
 			// tear down scene every frame
-			m_renderer->m_instances[0].packedGeo = m_renderer->getInitParams().geoms.data()+gcIndex;
+			m_renderer->m_instances[0].packedGeo = m_renderer->getGeometries().data()+gcIndex;
  			m_renderer->render(cb,viewParams);
 
 			cb->endRenderPass();
@@ -185,7 +192,7 @@ class GeometryCreatorApp final : public MonoWindowApplication, public BuiltinRes
 			std::string caption = "[Nabla Engine] Geometry Creator";
 			{
 				caption += ", displaying [";
-				caption += m_scene->getGeometries()[gcIndex].name;
+				caption += m_scene->getInitParams().geometryNames[gcIndex];
 				caption += "]";
 				m_window->setCaption(caption);
 			}
@@ -258,7 +265,7 @@ class GeometryCreatorApp final : public MonoWindowApplication, public BuiltinRes
 				if (ev.type==nbl::ui::SMouseEvent::EET_SCROLL && m_renderer)
 				{
 					gcIndex += int16_t(core::sign(ev.scrollEvent.verticalScroll));
-					gcIndex = core::clamp(gcIndex,0ull,m_renderer->getInitParams().geoms.size()-1);
+					gcIndex = core::clamp(gcIndex,0ull,m_renderer->getGeometries().size()-1);
 				}
 			}
 		}

12_MeshLoaders/CMakeLists.txt

@@ -1,8 +1,18 @@
 set(NBL_INCLUDE_SERACH_DIRECTORIES
 	"${CMAKE_CURRENT_SOURCE_DIR}/include"
 )
+set(NBL_LIBRARIES)
+
+if (NBL_BUILD_MITSUBA_LOADER)
+	list(APPEND NBL_INCLUDE_SERACH_DIRECTORIES
+		"${NBL_EXT_MITSUBA_LOADER_INCLUDE_DIRS}"
+	)
+	list(APPEND NBL_LIBRARIES
+		"${NBL_EXT_MITSUBA_LOADER_LIB}"
+	)
+endif()
 
 	# TODO; Arek I removed `NBL_EXECUTABLE_PROJECT_CREATION_PCH_TARGET` from the last parameter here, doesn't this macro have 4 arguments anyway !?
-nbl_create_executable_project("" "" "${NBL_INCLUDE_SERACH_DIRECTORIES}" "" "")
+nbl_create_executable_project("" "" "${NBL_INCLUDE_SERACH_DIRECTORIES}" "${NBL_LIBRARIES}")
 # TODO: Arek temporarily disabled cause I haven't figured out how to make this target yet
 # LINK_BUILTIN_RESOURCES_TO_TARGET(${EXECUTABLE_NAME} nblExamplesGeometrySpirvBRD)

12_MeshLoaders/main.cpp

@@ -5,6 +5,9 @@
 
 #include "../3rdparty/portable-file-dialogs/portable-file-dialogs.h"
 
+#ifdef NBL_BUILD_MITSUBA_LOADER
+#include "nbl/ext/MitsubaLoader/CSerializedLoader.h"
+#endif
 
 class MeshLoadersApp final : public MonoWindowApplication, public BuiltinResourcesApplication
 {
@@ -14,12 +17,15 @@ class MeshLoadersApp final : public MonoWindowApplication, public BuiltinResourc
 	public:
 		inline MeshLoadersApp(const path& _localInputCWD, const path& _localOutputCWD, const path& _sharedInputCWD, const path& _sharedOutputCWD)
 			: IApplicationFramework(_localInputCWD, _localOutputCWD, _sharedInputCWD, _sharedOutputCWD),
-			device_base_t({1280,720}, EF_UNKNOWN, _localInputCWD, _localOutputCWD, _sharedInputCWD, _sharedOutputCWD) {}
+			device_base_t({1280,720}, EF_D32_SFLOAT, _localInputCWD, _localOutputCWD, _sharedInputCWD, _sharedOutputCWD) {}
 
 		inline bool onAppInitialized(smart_refctd_ptr<ISystem>&& system) override
 		{
 			if (!asset_base_t::onAppInitialized(smart_refctd_ptr(system)))
 				return false;
+		#ifdef NBL_BUILD_MITSUBA_LOADER
+			m_assetMgr->addAssetLoader(make_smart_refctd_ptr<ext::MitsubaLoader::CSerializedLoader>());
+		#endif
 			if (!device_base_t::onAppInitialized(smart_refctd_ptr(system)))
 				return false;
 
@@ -36,32 +42,15 @@ class MeshLoadersApp final : public MonoWindowApplication, public BuiltinResourc
 					return logFail("Couldn't create Command Buffer!");
 			}
 
-			//! cache results -- speeds up mesh generation on second run
-			m_qnc->loadCacheFromFile<EF_R8G8B8_SNORM>(m_system.get(),sharedOutputCWD/"../../tmp/normalCache888.sse");
+
+			auto scRes = static_cast<CDefaultSwapchainFramebuffers*>(m_surface->getSwapchainResources());
+			m_renderer = CSimpleDebugRenderer::create(m_assetMgr.get(),scRes->getRenderpass(),0,{});
+			if (!m_renderer)
+				return logFail("Failed to create renderer!");
 
 			//
 			if (!reloadModel())
 				return false;
-#if 0			
-			const uint32_t addtionalBufferOwnershipFamilies[] = {getGraphicsQueue()->getFamilyIndex()};
-			// we want to use the vertex data through UTBs
-			using usage_f = IGPUBuffer::E_USAGE_FLAGS;
-			CAssetConverter::patch_t<asset::ICPUPolygonGeometry> patch = {};
-			patch.positionBufferUsages = usage_f::EUF_UNIFORM_TEXEL_BUFFER_BIT;
-			patch.indexBufferUsages = usage_f::EUF_INDEX_BUFFER_BIT;
-			patch.otherBufferUsages = usage_f::EUF_UNIFORM_TEXEL_BUFFER_BIT;
-			m_scene = CGeometryCreatorScene::create(
-				{
-					.transferQueue = getTransferUpQueue(),
-					.utilities = m_utils.get(),
-					.logger = m_logger.get(),
-					.addtionalBufferOwnershipFamilies = addtionalBufferOwnershipFamilies
-				},patch
-			);
-#endif
-
-			auto scRes = static_cast<CDefaultSwapchainFramebuffers*>(m_surface->getSwapchainResources());
-			m_renderer = CSimpleDebugRenderer::create(m_assetMgr.get(),scRes->getRenderpass(),0,nullptr);
 
 			camera.mapKeysToArrows();
 
@@ -114,15 +103,21 @@ class MeshLoadersApp final : public MonoWindowApplication, public BuiltinResourc
 				}
 				// late latch input
 				{
+					bool reload = false;
 					camera.beginInputProcessing(nextPresentationTimestamp);
 					mouse.consumeEvents([&](const IMouseEventChannel::range_t& events) -> void { camera.mouseProcess(events); }, m_logger.get());
 					keyboard.consumeEvents([&](const IKeyboardEventChannel::range_t& events) -> void
 						{
+							for (const auto& event : events)
+							if (event.keyCode==E_KEY_CODE::EKC_R && event.action==SKeyboardEvent::ECA_RELEASED)
+								reload = true;
 							camera.keyboardProcess(events);
 						},
 						m_logger.get()
 					);
 					camera.endInputProcessing(nextPresentationTimestamp);
+					if (reload)
+						reloadModel();
 				}
 				// draw scene
 				{
@@ -139,8 +134,6 @@ class MeshLoadersApp final : public MonoWindowApplication, public BuiltinResourc
 			}
 			cb->end();
 
-			//updateGUIDescriptorSet();
-
 			IQueue::SSubmitInfo::SSemaphoreInfo retval =
 			{
 				.semaphore = m_semaphore.get(),
@@ -224,37 +217,193 @@ class MeshLoadersApp final : public MonoWindowApplication, public BuiltinResourc
 		}
 
 	private:
-		inline bool reloadModel()
+		// TODO: standardise this across examples, and take from `argv`
+		bool m_nonInteractiveTest = false;
+
+		bool reloadModel()
 		{
-			pfd::open_file file("Choose a supported Model File", "../../media", { "All Supported Formats", "*.ply *.stl *.serialized *.obj",
-				"TODO (.ply)", "*.ply",
-				"TODO (.stl)", "*.stl",
-				"Mitsuba 0.6 Serialized (.serialized)", "*.serialized",
-				"Wavefront Object (.obj)", "*.obj" 
-			});
-			if (file.result().empty())
-				return false;
-			m_modelPath = file.result()[0];
+			if (m_nonInteractiveTest) // TODO: maybe also take from argv and argc
+				m_modelPath = (sharedInputCWD/"ply/Spanner-ply.ply").string();
+			else
+			{
+				pfd::open_file file("Choose a supported Model File", sharedInputCWD.string(),
+					{
+						"All Supported Formats", "*.ply *.stl *.serialized *.obj",
+						"TODO (.ply)", "*.ply",
+						"TODO (.stl)", "*.stl",
+						"Mitsuba 0.6 Serialized (.serialized)", "*.serialized",
+						"Wavefront Object (.obj)", "*.obj"
+					},
+					false
+				);
+				if (file.result().empty())
+					return false;
+				m_modelPath = file.result()[0];
+			}
 
 			// free up
+			m_renderer->m_instances.clear();
+			m_renderer->clearGeometries({.semaphore=m_semaphore.get(),.value=m_realFrameIx});
 			m_assetMgr->clearAllAssetCache();
 
 			//! load the geometry
 			IAssetLoader::SAssetLoadParams params = {};
-			params.meshManipulatorOverride = nullptr; // TODO
+			params.logger = m_logger.get();
 			auto bundle = m_assetMgr->getAsset(m_modelPath,params);
 			if (bundle.getContents().empty())
 				return false;
-			//! cache results -- speeds up mesh generation on second run
-			m_qnc->saveCacheToFile<EF_R8G8B8_SNORM>(m_system.get(),sharedOutputCWD/"../../tmp/normalCache888.sse");
+
+			// 
+			core::vector<smart_refctd_ptr<const ICPUPolygonGeometry>> geometries;
+			switch (bundle.getAssetType())
+			{
+				case IAsset::E_TYPE::ET_GEOMETRY:
+					for (const auto& item : bundle.getContents())
+					if (auto polyGeo=IAsset::castDown<ICPUPolygonGeometry>(item); polyGeo)
+						geometries.push_back(polyGeo);
+					break;
+				default:
+					m_logger->log("Asset loaded but not a supported type (ET_GEOMETRY,ET_GEOMETRY_COLLECTION)",ILogger::ELL_ERROR);
+					break;
+			}
+			if (geometries.empty())
+				return false;
+
+			using aabb_t = hlsl::shapes::AABB<3,double>;
+			auto printAABB = [&](const aabb_t& aabb, const char* extraMsg="")->void
+			{
+				m_logger->log("%s AABB is (%f,%f,%f) -> (%f,%f,%f)",ILogger::ELL_INFO,extraMsg,aabb.minVx.x,aabb.minVx.y,aabb.minVx.z,aabb.maxVx.x,aabb.maxVx.y,aabb.maxVx.z);
+			};
+			auto bound = aabb_t::create();
+			// convert the geometries
+			{
+				smart_refctd_ptr<CAssetConverter> converter = CAssetConverter::create({.device=m_device.get()});
+
+				const auto transferFamily = getTransferUpQueue()->getFamilyIndex();
+
+				struct SInputs : CAssetConverter::SInputs
+				{
+					virtual inline std::span<const uint32_t> getSharedOwnershipQueueFamilies(const size_t groupCopyID, const asset::ICPUBuffer* buffer, const CAssetConverter::patch_t<asset::ICPUBuffer>& patch) const
+					{
+						return sharedBufferOwnership;
+					}
+
+					core::vector<uint32_t> sharedBufferOwnership;
+				} inputs = {};
+				core::vector<CAssetConverter::patch_t<ICPUPolygonGeometry>> patches(geometries.size(),CSimpleDebugRenderer::DefaultPolygonGeometryPatch);
+				{
+					inputs.logger = m_logger.get();
+					std::get<CAssetConverter::SInputs::asset_span_t<ICPUPolygonGeometry>>(inputs.assets) = {&geometries.front().get(),geometries.size()};
+					std::get<CAssetConverter::SInputs::patch_span_t<ICPUPolygonGeometry>>(inputs.patches) = patches;
+					// set up shared ownership so we don't have to 
+					core::unordered_set<uint32_t> families;
+					families.insert(transferFamily);
+					families.insert(getGraphicsQueue()->getFamilyIndex());
+					if (families.size()>1)
+					for (const auto fam : families)
+						inputs.sharedBufferOwnership.push_back(fam);
+				}
+				
+				// reserve
+				auto reservation = converter->reserve(inputs);
+				if (!reservation)
+				{
+					m_logger->log("Failed to reserve GPU objects for CPU->GPU conversion!",ILogger::ELL_ERROR);
+					return false;
+				}
+
+				// convert
+				{
+					auto semaphore = m_device->createSemaphore(0u);
+
+					constexpr auto MultiBuffering = 2;
+					std::array<smart_refctd_ptr<IGPUCommandBuffer>,MultiBuffering> commandBuffers = {};
+					{
+						auto pool = m_device->createCommandPool(transferFamily,IGPUCommandPool::CREATE_FLAGS::RESET_COMMAND_BUFFER_BIT|IGPUCommandPool::CREATE_FLAGS::TRANSIENT_BIT);
+						pool->createCommandBuffers(IGPUCommandPool::BUFFER_LEVEL::PRIMARY,commandBuffers,smart_refctd_ptr(m_logger));
+					}
+					commandBuffers.front()->begin(IGPUCommandBuffer::USAGE::ONE_TIME_SUBMIT_BIT);
+
+					std::array<IQueue::SSubmitInfo::SCommandBufferInfo,MultiBuffering> commandBufferSubmits;
+					for (auto i=0; i<MultiBuffering; i++)
+						commandBufferSubmits[i].cmdbuf = commandBuffers[i].get();
+
+					SIntendedSubmitInfo transfer = {};
+					transfer.queue = getTransferUpQueue();
+					transfer.scratchCommandBuffers = commandBufferSubmits;
+					transfer.scratchSemaphore = {
+						.semaphore = semaphore.get(),
+						.value = 0u,
+						.stageMask = PIPELINE_STAGE_FLAGS::ALL_TRANSFER_BITS
+					};
+
+					CAssetConverter::SConvertParams cpar = {};
+					cpar.utilities = m_utils.get();
+					cpar.transfer = &transfer;
+
+					// basically it records all data uploads and submits them right away
+					auto future = reservation.convert(cpar);
+					if (future.copy()!=IQueue::RESULT::SUCCESS)
+					{
+						m_logger->log("Failed to await submission feature!", ILogger::ELL_ERROR);
+						return false;
+					}
+				}
+				
+				auto tmp = hlsl::float32_t4x3(
+					hlsl::float32_t3(1,0,0),
+					hlsl::float32_t3(0,1,0),
+					hlsl::float32_t3(0,0,1),
+					hlsl::float32_t3(0,0,0)
+				);
+				core::vector<hlsl::float32_t3x4> worldTforms;
+				const auto& converted = reservation.getGPUObjects<ICPUPolygonGeometry>();
+				for (const auto& geom : converted)
+				{
+					const auto promoted = geom.value->getAABB<aabb_t>();
+					printAABB(promoted,"Geometry");
+					tmp[3].x += promoted.getExtent().x;
+					const auto promotedWorld = hlsl::float64_t3x4(worldTforms.emplace_back(hlsl::transpose(tmp)));
+					const auto transformed = hlsl::shapes::util::transform(promotedWorld,promoted);
+					printAABB(transformed,"Transformed");
+					bound = hlsl::shapes::util::union_(transformed,bound);
+				}
+				printAABB(bound,"Total");
+				if (!m_renderer->addGeometries({ &converted.front().get(),converted.size() }))
+					return false;
+
+				auto worlTformsIt = worldTforms.begin();
+				for (const auto& geo : m_renderer->getGeometries())
+					m_renderer->m_instances.push_back({
+						.world = *(worlTformsIt++),
+						.packedGeo = &geo
+					});
+			}
+
+			// get scene bounds and reset camera
+			{
+				const double distance = 0.05;
+				const auto diagonal = bound.getExtent();
+				{
+					const auto measure = hlsl::length(diagonal);
+					const auto aspectRatio = float(m_window->getWidth())/float(m_window->getHeight());
+					camera.setProjectionMatrix(core::matrix4SIMD::buildProjectionMatrixPerspectiveFovRH(1.2f,aspectRatio,distance*measure*0.1,measure*4.0));
+					camera.setMoveSpeed(measure*0.04);
+				}
+				const auto pos = bound.maxVx+diagonal*distance;
+				camera.setPosition(vectorSIMDf(pos.x,pos.y,pos.z));
+				const auto center = (bound.minVx+bound.maxVx)*0.5;
+				camera.setTarget(vectorSIMDf(center.x,center.y,center.z));
+			}
+
+			// TODO: write out the geometry
 
 			return true;
 		}
 
 		// Maximum frames which can be simultaneously submitted, used to cycle through our per-frame resources like command buffers
 		constexpr static inline uint32_t MaxFramesInFlight = 3u;
 		//
-		smart_refctd_ptr<CQuantNormalCache> m_qnc;
 		smart_refctd_ptr<CSimpleDebugRenderer> m_renderer;
 		//
 		smart_refctd_ptr<ISemaphore> m_semaphore;