Merge branch 'main-headless' into test-headless

CMakeSettings.json

@@ -81,6 +81,20 @@
       "rsyncCommandArgs": "-t --delete",
       "remoteCopyBuildOutput": false,
       "remoteCopySourcesMethod": "rsync"
+    },
+    {
+      "name": "WSL-Clang-Release",
+      "generator": "Ninja",
+      "configurationType": "RelWithDebInfo",
+      "buildRoot": "${projectDir}\\out\\build\\${name}",
+      "installRoot": "${projectDir}\\out\\install\\${name}",
+      "cmakeExecutable": "cmake",
+      "cmakeCommandArgs": "",
+      "buildCommandArgs": "",
+      "ctestCommandArgs": "",
+      "inheritEnvironments": [ "linux_clang_x64" ],
+      "wslPath": "${defaultWSLPath}",
+      "variables": []
     }
   ]
 }

base/VulkanSwapChain.hpp

@@ -53,7 +53,8 @@ public:
 	VkExtent2D extent = {};
 	uint32_t queueNodeIndex = UINT32_MAX;
 
-	/** @brief Creates the platform specific surface abstraction of the native platform window used for presentation */	
+	/* @brief Creates the platform specific surface abstraction of the native platform window used for presentation */	
+/*
 #if defined(VK_USE_PLATFORM_WIN32_KHR)
 	void initSurface(void* platformHandle, void* platformWindow)
 #elif defined(VK_USE_PLATFORM_ANDROID_KHR)
@@ -67,6 +68,7 @@ public:
 #elif defined(_DIRECT2DISPLAY)
 	void initSurface(uint32_t width, uint32_t height)
 #endif
+	void initSurface
 	{
 		VkResult err = VK_SUCCESS;
 
@@ -112,6 +114,7 @@ public:
 		err = vkCreateXcbSurfaceKHR(instance, &surfaceCreateInfo, nullptr, &surface);
 #endif
 
+
 		if (err != VK_SUCCESS) {
 			std::cerr << "Could not create surface!" << std::endl;
 			exit(err);
@@ -232,7 +235,7 @@ public:
 		}
 
 	}
-
+*/
 	/**
 	* Set instance, physical and logical device to use for the swapchain and get all required function pointers
 	* 

base/VulkanTools.cpp

@@ -10,17 +10,17 @@ const std::string getAssetPath()
 	return "";
 #elif defined(VK_EXAMPLE_DATA_DIR)
 
-	if (_access("./../data/", 0) != -1)
+	if (std::filesystem::exists("./../data/"))
 	{
 		
 		return "./../data/";
 	}
-	else if (_access("./data/", 0) != -1)
+	else if (std::filesystem::exists("./data/"))
 	{
 		
 		return "./data/";
 	}
-	else if (_access("./../../data/", 0) != -1)
+	else if (std::filesystem::exists("./../../data/"))
 	{
 		
 		return "../../data/";
@@ -28,7 +28,7 @@ const std::string getAssetPath()
 	else
 	{
 		
-		return VK_EXAMPLE_DATA_DIR;
+		return std::filesystem::path(VK_EXAMPLE_DATA_DIR);
 	}
 
 #endif

base/VulkanTools.h

@@ -16,6 +16,7 @@
 #include <stdexcept>
 #include <fstream>
 #include <algorithm>
+#include <filesystem>
 #if defined(_WIN32)
 #include <windows.h>
 #include <fcntl.h>

base/VulkanUtils.hpp

@@ -107,6 +107,7 @@ VkPipelineShaderStageCreateInfo loadShader(VkDevice device, std::string filename
 	return shaderStage;
 }
 
+/*
 void readDirectory(const std::string& directory, const std::string &pattern, std::map<std::string, std::string> &filelist, bool recursive)
 {
 #if defined(VK_USE_PLATFORM_ANDROID_KHR)
@@ -173,4 +174,5 @@ void readDirectory(const std::string& directory, const std::string &pattern, std
 	}
 	closedir(dir);
 #endif
-}
+}
+*/

base/vulkanexamplebase.cpp

@@ -482,31 +482,19 @@ void VulkanExampleBase::initVulkan()
 		std::cerr << "Could not enumerate physical devices!" << std::endl;
 		exit(err);
 	}
-	uint32_t selectedDevice = 0;
-#if !defined(VK_USE_PLATFORM_ANDROID_KHR)	
-	for (size_t i = 0; i < args.size(); i++) {
-		if ((args[i] == std::string("-g")) || (args[i] == std::string("--gpu"))) {
-			char* endptr;
-			selectedPhysicalDeviceIndex = strtol(args[i + 1], &endptr, 10);
-			if (endptr != args[i + 1])  { 
-				if (selectedPhysicalDeviceIndex > gpuCount - 1) {
-					std::cerr << "Selected device index " << selectedPhysicalDeviceIndex << " is out of range, reverting to device 0 (use -listgpus to show available Vulkan devices)" << std::endl;
-				} else {
-					std::cout << "Selected Vulkan device " << selectedPhysicalDeviceIndex << std::endl;
-					selectedDevice = selectedPhysicalDeviceIndex;
-				}
-			};
-			break;
-		}
+	uint32_t selectedDevice = settings.selectedPhysicalDeviceIndex;
+	if (settings.selectedPhysicalDeviceIndex > gpuCount)
+	{
+		std::cerr << "wrong GPU selection,check selectedPhysicalDeviceIndex in config file,fallback to 0" << std::endl;
+		selectedDevice = 0;
 	}
-#endif
 
 	physicalDevice = physicalDevices[selectedDevice];
 
 	vkGetPhysicalDeviceProperties(physicalDevice, &deviceProperties);
 	vkGetPhysicalDeviceFeatures(physicalDevice, &deviceFeatures);
 	vkGetPhysicalDeviceMemoryProperties(physicalDevice, &deviceMemoryProperties);
-
+	
 	/*
 		queueFamilyIndex creation
 	*/
@@ -790,7 +778,10 @@ void VulkanExampleBase::initSwapchain()
 */
 }
 
+/*
+
 void VulkanExampleBase::setupSwapChain()
 {
 	//swapChain.create(&width, &height, settings.vsync);
 }
+*/

src/render/render.cpp

@@ -223,10 +223,10 @@ PlumageRender::PlumageRender()
 	{
 		const std::string assetpath = getAssetPath();
 		
-		if (_access(assetpath.c_str(),0) != 0) {
+		if (!std::filesystem::exists(assetpath.c_str())) {
 			std::string msg = "Could not locate asset path in \"" + assetpath + "\".\nMake sure binary is running from correct relative directory!";
 			std::cerr << msg << std::endl;
-			system("pause");
+			//system("pause");
 			//exit(-1);
 		}
 		else {
@@ -234,7 +234,7 @@ PlumageRender::PlumageRender()
 			std::cout << msg << std::endl;
 		}
 
-		readDirectory(assetpath + "environments", "*.ktx", environments, false);
+		//readDirectory(assetpath + "environments", "*.ktx", environments, false);
 
 		textures.empty.loadFromFile(PlumageRender::filePath.emptyEnvmapFilePath, VK_FORMAT_R8G8B8A8_UNORM, vulkanDevice, queue);
 
@@ -1847,7 +1847,7 @@ PlumageRender::PlumageRender()
 			removeImageSequence();
 		}
 
-		 filePath.deviceSpecFilePath = filePath.imageOutputPath + "/device" + std::to_string(selectedPhysicalDeviceIndex);
+		 filePath.deviceSpecFilePath = filePath.imageOutputPath + "/device" + std::to_string(settings.selectedPhysicalDeviceIndex);
 		
 		if (savedFrameCounter > settings.endFrameIndex)
 		{
@@ -1871,7 +1871,7 @@ PlumageRender::PlumageRender()
 			filePath.totalImageOutputPath = filePath.deviceSpecFilePath + fileName;
 			return;
 		}
-		if (_access(filePath.deviceSpecFilePath.c_str(), 0) == -1)
+		if (std::filesystem::exists(filePath.deviceSpecFilePath.c_str()))
 		{
 			std::filesystem::create_directories(filePath.deviceSpecFilePath.c_str());
 		}
@@ -1901,8 +1901,8 @@ PlumageRender::PlumageRender()
 		{
 			return;
 		}
-		std::string deviceFilePath = filePath.videoOutputPath + "/device" + std::to_string(selectedPhysicalDeviceIndex);
-		if (_access(deviceFilePath.c_str(), 0) == -1)
+		std::string deviceFilePath = filePath.videoOutputPath + "/device" + std::to_string(settings.selectedPhysicalDeviceIndex);
+		if (std::filesystem::exists(deviceFilePath.c_str()))
 		{
 			std::filesystem::create_directories(deviceFilePath.c_str());
 		}
@@ -2076,7 +2076,7 @@ PlumageRender::PlumageRender()
 			buildCommandBuffers();
 
 		}
-
+	/*
 	void PlumageRender::updateUIOverlay()
 	{
 		ImGuiIO& io = ImGui::GetIO();
@@ -2290,13 +2290,13 @@ PlumageRender::PlumageRender()
 
 	}
 
-	
+	*/
 
 	PlumageRender* plumageRender;
 	// OS specific macros for the example main entry points
-	int main()
+	int main(int argc, char* argv[])
 	{
-		for (int32_t i = 0; i < __argc; i++) { PlumageRender::args.push_back(__argv[i]); };
+		for (int32_t i = 0; i < argc; i++) { PlumageRender::args.push_back(argv[i]); };
 		plumageRender = new PlumageRender();
 		std::cout << "start to init vulkan" << std::endl;
 		plumageRender->initVulkan();

src/render/render.h

@@ -296,7 +296,7 @@ public:
 	void         prepareUniformBuffers();
 	void         updateUniformBuffers();
 	void updateShaderData();
-	void windowResized();
+	//void windowResized();
 	void         prepare();
 	void submitWork(VkCommandBuffer cmdBuffer, VkQueue queue);
 
@@ -307,6 +307,6 @@ public:
 	//void outputScreenShot();
 	uint32_t getMemoryTypeIndex(uint32_t typeBits, VkMemoryPropertyFlags properties);
 	virtual void render();
-	virtual void updateUIOverlay();
+	//virtual void updateUIOverlay();
 	virtual void fileDropped(std::string filename);
 };