Fix merge

include/Nazara/Core/StringExt.hpp

@@ -29,6 +29,9 @@ namespace Nz
 	inline bool IsNumber(const char* str);
 	inline bool IsNumber(const std::string_view& str);
 
+	inline bool MatchPattern(const std::string_view& str, const char* pattern);
+	NAZARA_CORE_API bool MatchPattern(const std::string_view& str, const std::string_view& pattern);
+
 	template<typename... Args> bool StartsWith(const std::string_view& str, const char* s, Args&&... args);
 	inline bool StartsWith(const std::string_view& str, const std::string_view& s);
 	NAZARA_CORE_API bool StartsWith(const std::string_view& str, const std::string_view& s, CaseIndependent);

include/Nazara/Core/StringExt.inl

@@ -21,6 +21,14 @@ namespace Nz
 		return !str.empty() && std::find_if(str.begin(), str.end(), [](unsigned char c) { return !std::isdigit(c); }) == str.end();
 	}
 
+	bool MatchPattern(const std::string_view& str, const char* pattern)
+	{
+		if (!pattern)
+			return false;
+
+		return MatchPattern(str, std::string_view(pattern, std::strlen(pattern)));
+	}
+
 	template<typename... Args> bool StartsWith(const std::string_view& str, const char* s, Args&&... args)
 	{
 		std::size_t size = std::strlen(s);

include/Nazara/VulkanRenderer/Wrapper/Device.hpp

@@ -48,8 +48,8 @@ namespace Nz
 				inline VkResult GetLastErrorCode() const;
 				inline VkPhysicalDevice GetPhysicalDevice() const;
 
-				inline bool IsExtensionLoaded(const String& extensionName);
-				inline bool IsLayerLoaded(const String& layerName);
+				inline bool IsExtensionLoaded(const std::string& extensionName);
+				inline bool IsLayerLoaded(const std::string& layerName);
 
 				inline bool WaitForIdle();
 
@@ -219,8 +219,8 @@ namespace Nz
 				VkDevice m_device;
 				VkPhysicalDevice m_physicalDevice;
 				VkResult m_lastErrorCode;
-				std::unordered_set<String> m_loadedExtensions;
-				std::unordered_set<String> m_loadedLayers;
+				std::unordered_set<std::string> m_loadedExtensions;
+				std::unordered_set<std::string> m_loadedLayers;
 				std::vector<QueueFamilyInfo> m_enabledQueuesInfos;
 				std::vector<const QueueList*> m_queuesByFamily;
 		};

include/Nazara/VulkanRenderer/Wrapper/Device.inl

@@ -68,12 +68,12 @@ namespace Nz
 			return m_physicalDevice;
 		}
 
-		inline bool Device::IsExtensionLoaded(const String& extensionName)
+		inline bool Device::IsExtensionLoaded(const std::string& extensionName)
 		{
 			return m_loadedExtensions.count(extensionName) > 0;
 		}
 
-		inline bool Device::IsLayerLoaded(const String& layerName)
+		inline bool Device::IsLayerLoaded(const std::string& layerName)
 		{
 			return m_loadedLayers.count(layerName) > 0;
 		}

src/Nazara/Core/StringExt.cpp

@@ -118,6 +118,57 @@ namespace Nz
 		return WideConverter<sizeof(wchar_t)>::From(wstr.data(), wstr.size());
 	}
 
+	bool MatchPattern(const std::string_view& str, const std::string_view& pattern)
+	{
+		if (str.empty() || pattern.empty())
+			return false;
+
+		// Par Jack Handy - akkhandy@hotmail.com
+		// From : http://www.codeproject.com/Articles/1088/Wildcard-string-compare-globbing
+		const char* ptr = str.data();
+		const char* ptrEnd = str.data() + str.size();
+
+		const char* patternPtr = pattern.data();
+		const char* patternPtrEnd = pattern.data() + pattern.size();
+
+		while (ptr < ptrEnd && *patternPtr != '*')
+		{
+			if (patternPtr < patternPtrEnd && *patternPtr != *ptr && *patternPtr != '?')
+				return false;
+
+			patternPtr++;
+			ptr++;
+		}
+
+		const char* cp = nullptr;
+		const char* mp = nullptr;
+		while (*ptr)
+		{
+			if (*patternPtr == '*')
+			{
+				if (patternPtr + 1 >= patternPtrEnd)
+					return true;
+
+				mp = ++patternPtr;
+				cp = ptr + 1;
+			}
+			else if (*patternPtr == *ptr || *patternPtr == '?')
+			{
+				patternPtr++;
+				ptr++;
+			}
+			else
+			{
+				patternPtr = mp;
+				ptr = cp++;
+			}
+		}
+
+		while (patternPtr < patternPtrEnd && *patternPtr == '*')
+			patternPtr++;
+
+		return patternPtr >= patternPtrEnd;
+	}
 	bool StartsWith(const std::string_view& str, const std::string_view& s, CaseIndependent)
 	{
 		if (s.size() > str.size())

src/Nazara/Renderer/Renderer.cpp

@@ -4,16 +4,23 @@
 
 #include <Nazara/Renderer/Renderer.hpp>
 #include <Nazara/Core/CallOnExit.hpp>
-#include <Nazara/Core/Directory.hpp>
 #include <Nazara/Core/DynLib.hpp>
 #include <Nazara/Core/Log.hpp>
+#include <Nazara/Core/StringExt.hpp>
 #include <Nazara/Platform/Platform.hpp>
 #include <Nazara/Renderer/RenderBuffer.hpp>
 #include <Nazara/Utility/AbstractBuffer.hpp>
 #include <Nazara/Utility/Buffer.hpp>
 #include <Nazara/Utility/Utility.hpp>
+#include <filesystem>
 #include <Nazara/Renderer/Debug.hpp>
 
+#ifdef NAZARA_DEBUG
+	#define NazaraRendererPattern "Nazara?*Renderer-d" NAZARA_DYNLIB_EXTENSION
+#else
+	#define NazaraRendererPattern "Nazara?*Renderer" NAZARA_DYNLIB_EXTENSION
+#endif
+
 namespace Nz
 {
 	bool Renderer::Initialize()
@@ -43,32 +50,33 @@ namespace Nz
 
 		NazaraDebug("Searching for renderer implementation");
 
-		Directory dir(".");
-		dir.SetPattern("Nazara?*Renderer*" NAZARA_DYNLIB_EXTENSION); //< Ex: NazaraVulkanRenderer.dll
-
-		if (!dir.Open())
-		{
-			NazaraError("Failed to open directory");
-			return false;
-		}
-
 		DynLib chosenLib;
 		std::unique_ptr<RendererImpl> chosenImpl;
-		while (dir.NextResult())
+
+		for (auto&& entry : std::filesystem::directory_iterator("."))
 		{
-			NazaraDebug("Trying to load " + dir.GetResultName());
+			if (!entry.is_regular_file())
+				continue;
+
+			const std::filesystem::path& entryPath = entry.path();
+			std::filesystem::path fileName = entryPath.filename();
+			std::string fileNameStr = fileName.generic_u8string();
+			if (!MatchPattern(fileNameStr, NazaraRendererPattern))
+				continue;
+
+			NazaraDebug("Trying to load " + fileNameStr);
 
 			DynLib implLib;
-			if (!implLib.Load(dir.GetResultPath()))
+			if (!implLib.Load(entryPath))
 			{
-				NazaraWarning("Failed to load " + dir.GetResultName() + ": " + implLib.GetLastError());
+				NazaraWarning("Failed to load " + fileNameStr + ": " + implLib.GetLastError());
 				continue;
 			}
 
 			CreateRendererImplFunc createRenderer = reinterpret_cast<CreateRendererImplFunc>(implLib.GetSymbol("NazaraRenderer_Instantiate"));
 			if (!createRenderer)
 			{
-				NazaraDebug("Skipped " + dir.GetResultName() + " (symbol not found)");
+				NazaraDebug("Skipped " + fileNameStr + " (symbol not found)");
 				continue;
 			}
 

src/Nazara/Utility/IndexBuffer.cpp

@@ -110,7 +110,7 @@ namespace Nz
 		NazaraAssert(size > 0, "Invalid size");
 		NazaraAssert(offset + size > buffer->GetSize(), "Virtual buffer exceed buffer bounds");
 
-		std::size_t stride = static_cast<std::size_t>((largeIndices) ? sizeof(std::size_t) : sizeof(UInt16));
+		std::size_t stride = static_cast<std::size_t>((largeIndices) ? sizeof(UInt32) : sizeof(UInt16));
 
 		m_buffer = buffer;
 		m_endOffset = offset + size;
@@ -121,7 +121,7 @@ namespace Nz
 
 	void IndexBuffer::Reset(bool largeIndices, std::size_t length, DataStorage storage, BufferUsageFlags usage)
 	{
-		std::size_t stride = static_cast<std::size_t>((largeIndices) ? sizeof(std::size_t) : sizeof(UInt16));
+		std::size_t stride = static_cast<std::size_t>((largeIndices) ? sizeof(UInt32) : sizeof(UInt16));
 
 		m_endOffset = length * stride;
 		m_indexCount = length;

src/Nazara/VulkanRenderer/Export.cpp

@@ -9,7 +9,7 @@ extern "C"
 {
 	NAZARA_EXPORT Nz::RendererImpl* NazaraRenderer_Instantiate()
 	{
-		std::unique_ptr<Nz::VulkanRenderer> renderer(new Nz::VulkanRenderer);
+		std::unique_ptr<Nz::VulkanRenderer> renderer = std::make_unique<Nz::VulkanRenderer>();
 		return renderer.release();
 	}
 }

src/Nazara/VulkanRenderer/Wrapper/Device.cpp

@@ -38,10 +38,10 @@ namespace Nz
 
 			// Parse extensions and layers
 			for (UInt32 i = 0; i < createInfo.enabledExtensionCount; ++i)
-				m_loadedExtensions.insert(createInfo.ppEnabledExtensionNames[i]);
+				m_loadedExtensions.emplace(createInfo.ppEnabledExtensionNames[i]);
 
 			for (UInt32 i = 0; i < createInfo.enabledLayerCount; ++i)
-				m_loadedLayers.insert(createInfo.ppEnabledLayerNames[i]);
+				m_loadedLayers.emplace(createInfo.ppEnabledLayerNames[i]);
 
 			// Load all device-related functions
 			#define NAZARA_VULKANRENDERER_LOAD_DEVICE(func) func = reinterpret_cast<PFN_##func>(GetProcAddr(#func))

src/Nazara/VulkanRenderer/Wrapper/Loader.cpp

@@ -3,6 +3,7 @@
 // For conditions of distribution and use, see copyright notice in Config.hpp
 
 #include <Nazara/VulkanRenderer/Wrapper/Loader.hpp>
+#include <Nazara/Core/Error.hpp>
 #include <Nazara/VulkanRenderer/Utils.hpp>
 #include <Nazara/VulkanRenderer/Debug.hpp>