Renderer: Handle more depthstencil formats (as Depth24Stencil8 may not be supported everywhere)

examples/DeferredShading/main.cpp

@@ -576,6 +576,22 @@ int main()
 
 	Nz::BakedFrameGraph bakedGraph = [&]
 	{
+		Nz::PixelFormat depthStencilFormat = Nz::PixelFormat::Undefined;
+		for (Nz::PixelFormat candidate : { Nz::PixelFormat::Depth24Stencil8, Nz::PixelFormat::Depth32FStencil8, Nz::PixelFormat::Depth16Stencil8 })
+		{
+			if (device->IsTextureFormatSupported(candidate, Nz::TextureUsage::DepthStencilAttachment))
+			{
+				depthStencilFormat = candidate;
+				break;
+			}
+		}
+
+		if (depthStencilFormat == Nz::PixelFormat::Undefined)
+		{
+			std::cerr << "no depth-stencil format found" << std::endl;
+			std::exit(__LINE__);
+		}
+
 		Nz::FrameGraph graph;
 
 		colorTexture = graph.AddAttachment({
@@ -595,7 +611,7 @@ int main()
 
 		depthBuffer = graph.AddAttachment({
 			"Depth buffer",
-			Nz::PixelFormat::Depth24Stencil8
+			depthStencilFormat
 		});
 
 		lightOutput = graph.AddAttachment({

include/Nazara/OpenGLRenderer/OpenGLDevice.hpp

@@ -45,6 +45,8 @@ namespace Nz
 			std::shared_ptr<Texture> InstantiateTexture(const TextureInfo& params) override;
 			std::shared_ptr<TextureSampler> InstantiateTextureSampler(const TextureSamplerInfo& params) override;
 
+			bool IsTextureFormatSupported(PixelFormat format, TextureUsage usage) const override;
+
 			inline void NotifyBufferDestruction(GLuint buffer) const;
 			inline void NotifyFramebufferDestruction(GLuint fbo) const;
 			inline void NotifyProgramDestruction(GLuint program) const;

include/Nazara/OpenGLRenderer/Utils.inl

@@ -20,7 +20,10 @@ namespace Nz
 			case PixelFormat::BGR8_SRGB:        return GLTextureFormat{ GL_SRGB8,              GL_RGB,             GL_UNSIGNED_BYTE,                  GL_BLUE,  GL_GREEN, GL_RED,  GL_ONE };
 			case PixelFormat::BGRA8:            return GLTextureFormat{ GL_SRGB8_ALPHA8,       GL_RGBA,            GL_UNSIGNED_BYTE,                  GL_BLUE,  GL_GREEN, GL_RED,  GL_ALPHA };
 			case PixelFormat::BGRA8_SRGB:       return GLTextureFormat{ GL_SRGB8_ALPHA8,       GL_RGBA,            GL_UNSIGNED_BYTE,                  GL_BLUE,  GL_GREEN, GL_RED,  GL_ALPHA };
+			case PixelFormat::Depth16:          return GLTextureFormat{ GL_DEPTH_COMPONENT16,  GL_DEPTH_COMPONENT, GL_UNSIGNED_SHORT,                 GL_RED,   GL_ZERO,  GL_ZERO, GL_ZERO };
 			case PixelFormat::Depth24Stencil8:  return GLTextureFormat{ GL_DEPTH24_STENCIL8,   GL_DEPTH_STENCIL,   GL_UNSIGNED_INT_24_8,              GL_RED,   GL_GREEN, GL_ZERO, GL_ZERO };
+			case PixelFormat::Depth32F:         return GLTextureFormat{ GL_DEPTH_COMPONENT32F, GL_DEPTH_COMPONENT, GL_FLOAT,                          GL_RED,   GL_ZERO,  GL_ZERO, GL_ZERO };
+			case PixelFormat::Depth32FStencil8: return GLTextureFormat{ GL_DEPTH32F_STENCIL8,  GL_DEPTH_STENCIL,   GL_FLOAT_32_UNSIGNED_INT_24_8_REV, GL_RED,   GL_GREEN, GL_ZERO, GL_ZERO };
 			case PixelFormat::RGB8:             return GLTextureFormat{ GL_RGB8,               GL_RGB,             GL_UNSIGNED_BYTE,                  GL_RED,   GL_GREEN, GL_BLUE, GL_ONE };
 			case PixelFormat::RGB8_SRGB:        return GLTextureFormat{ GL_SRGB8,              GL_RGB,             GL_UNSIGNED_BYTE,                  GL_RED,   GL_GREEN, GL_BLUE, GL_ONE };
 			case PixelFormat::RGBA8:            return GLTextureFormat{ GL_RGBA8,              GL_RGBA,            GL_UNSIGNED_BYTE,                  GL_RED,   GL_GREEN, GL_BLUE, GL_ALPHA };

include/Nazara/Renderer/RenderDevice.hpp

@@ -20,6 +20,7 @@
 #include <Nazara/Shader/Ast/Nodes.hpp>
 #include <Nazara/Shader/ShaderWriter.hpp>
 #include <Nazara/Utility/AbstractBuffer.hpp>
+#include <Nazara/Utility/PixelFormat.hpp>
 #include <memory>
 #include <string>
 
@@ -47,6 +48,8 @@ namespace Nz
 			std::shared_ptr<ShaderModule> InstantiateShaderModule(ShaderStageTypeFlags shaderStages, ShaderLanguage lang, const std::filesystem::path& sourcePath, const ShaderWriter::States& states);
 			virtual std::shared_ptr<Texture> InstantiateTexture(const TextureInfo& params) = 0;
 			virtual std::shared_ptr<TextureSampler> InstantiateTextureSampler(const TextureSamplerInfo& params) = 0;
+
+			virtual bool IsTextureFormatSupported(PixelFormat format, TextureUsage usage) const = 0;
 	};
 }
 

include/Nazara/Renderer/RenderWindowParameters.hpp

@@ -15,7 +15,7 @@ namespace Nz
 {
 	struct RenderWindowParameters
 	{
-		std::vector<PixelFormat> depthFormats = {Nz::PixelFormat::Depth24Stencil8, Nz::PixelFormat::Depth32, Nz::PixelFormat::Depth24}; //< By order of preference
+		std::vector<PixelFormat> depthFormats = {Nz::PixelFormat::Depth24Stencil8, Nz::PixelFormat::Depth32FStencil8, Nz::PixelFormat::Depth16Stencil8, Nz::PixelFormat::Depth32F, Nz::PixelFormat::Depth24}; //< By order of preference
 		bool verticalSync = false;
 	};
 }

include/Nazara/Utility/Enums.hpp

@@ -245,9 +245,11 @@ namespace Nz
 		RGBA32I,         // 4*int32
 		RGBA32UI,        // 4*uint32
 		Depth16,
+		Depth16Stencil8,
 		Depth24,
 		Depth24Stencil8,
-		Depth32,
+		Depth32F,
+		Depth32FStencil8,
 		Stencil1,
 		Stencil4,
 		Stencil8,

include/Nazara/VulkanRenderer/Utils.inl

@@ -16,8 +16,11 @@ namespace Nz
 		{
 			case VK_FORMAT_B8G8R8A8_UNORM:     return PixelFormat::BGRA8;
 			case VK_FORMAT_B8G8R8A8_SRGB:      return PixelFormat::BGRA8_SRGB;
+			case VK_FORMAT_D16_UNORM:          return PixelFormat::Depth16;
+			case VK_FORMAT_D16_UNORM_S8_UINT:  return PixelFormat::Depth16Stencil8;
 			case VK_FORMAT_D24_UNORM_S8_UINT:  return PixelFormat::Depth24Stencil8;
-			case VK_FORMAT_D32_SFLOAT: return PixelFormat::Depth32;
+			case VK_FORMAT_D32_SFLOAT:         return PixelFormat::Depth32F;
+			case VK_FORMAT_D32_SFLOAT_S8_UINT: return PixelFormat::Depth32FStencil8;
 			case VK_FORMAT_R8G8B8A8_UNORM:     return PixelFormat::RGBA8;
 			case VK_FORMAT_R8G8B8A8_SRGB:      return PixelFormat::RGBA8_SRGB;
 			default: break;
@@ -248,8 +251,11 @@ namespace Nz
 		{
 			case PixelFormat::BGRA8: return VK_FORMAT_B8G8R8A8_UNORM;
 			case PixelFormat::BGRA8_SRGB: return VK_FORMAT_B8G8R8A8_SRGB;
+			case PixelFormat::Depth16: return VK_FORMAT_D16_UNORM;
+			case PixelFormat::Depth16Stencil8: return VK_FORMAT_D16_UNORM_S8_UINT;
 			case PixelFormat::Depth24Stencil8: return VK_FORMAT_D24_UNORM_S8_UINT;
-			case PixelFormat::Depth32: return VK_FORMAT_D32_SFLOAT;
+			case PixelFormat::Depth32F: return VK_FORMAT_D32_SFLOAT;
+			case PixelFormat::Depth32FStencil8: return VK_FORMAT_D32_SFLOAT_S8_UINT;
 			case PixelFormat::RGBA8: return VK_FORMAT_R8G8B8A8_UNORM;
 			case PixelFormat::RGBA8_SRGB: return VK_FORMAT_R8G8B8A8_SRGB;
 			case PixelFormat::RGBA32F: return VK_FORMAT_R32G32B32A32_SFLOAT;

include/Nazara/VulkanRenderer/VulkanDevice.hpp

@@ -36,6 +36,8 @@ namespace Nz
 			std::shared_ptr<Texture> InstantiateTexture(const TextureInfo& params) override;
 			std::shared_ptr<TextureSampler> InstantiateTextureSampler(const TextureSamplerInfo& params) override;
 
+			bool IsTextureFormatSupported(PixelFormat format, TextureUsage usage) const override;
+
 			VulkanDevice& operator=(const VulkanDevice&) = delete;
 			VulkanDevice& operator=(VulkanDevice&&) = delete; ///TODO?
 

include/Nazara/VulkanRenderer/Wrapper/Instance.hpp

@@ -59,20 +59,20 @@ namespace Nz
 				inline bool Create(const std::string& appName, UInt32 appVersion, const std::string& engineName, UInt32 engineVersion, UInt32 apiVersion, const std::vector<const char*>& layers, const std::vector<const char*>& extensions, const VkAllocationCallbacks* allocator = nullptr);
 				inline void Destroy();
 
-				bool EnumeratePhysicalDevices(std::vector<VkPhysicalDevice>* physicalDevices);
+				bool EnumeratePhysicalDevices(std::vector<VkPhysicalDevice>* physicalDevices) const;
 
-				inline PFN_vkVoidFunction GetDeviceProcAddr(VkDevice device, const char* name);
+				inline PFN_vkVoidFunction GetDeviceProcAddr(VkDevice device, const char* name) const;
 
 				inline UInt32 GetApiVersion() const;
 				inline VkResult GetLastErrorCode() const;
 
-				bool GetPhysicalDeviceExtensions(VkPhysicalDevice device, std::vector<VkExtensionProperties>* extensionProperties);
+				bool GetPhysicalDeviceExtensions(VkPhysicalDevice device, std::vector<VkExtensionProperties>* extensionProperties) const;
-				inline VkPhysicalDeviceFeatures GetPhysicalDeviceFeatures(VkPhysicalDevice device);
+				inline VkPhysicalDeviceFeatures GetPhysicalDeviceFeatures(VkPhysicalDevice device) const;
-				inline VkFormatProperties GetPhysicalDeviceFormatProperties(VkPhysicalDevice device, VkFormat format);
+				inline VkFormatProperties GetPhysicalDeviceFormatProperties(VkPhysicalDevice device, VkFormat format) const;
-				inline bool GetPhysicalDeviceImageFormatProperties(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkImageTiling tiling, VkImageUsageFlags usage, VkImageCreateFlags flags, VkImageFormatProperties* imageFormatProperties);
+				inline bool GetPhysicalDeviceImageFormatProperties(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkImageTiling tiling, VkImageUsageFlags usage, VkImageCreateFlags flags, VkImageFormatProperties* imageFormatProperties) const;
-				inline VkPhysicalDeviceMemoryProperties GetPhysicalDeviceMemoryProperties(VkPhysicalDevice device);
+				inline VkPhysicalDeviceMemoryProperties GetPhysicalDeviceMemoryProperties(VkPhysicalDevice device) const;
-				inline VkPhysicalDeviceProperties GetPhysicalDeviceProperties(VkPhysicalDevice device);
+				inline VkPhysicalDeviceProperties GetPhysicalDeviceProperties(VkPhysicalDevice device) const;
-				bool GetPhysicalDeviceQueueFamilyProperties(VkPhysicalDevice device, std::vector<VkQueueFamilyProperties>* queueFamilyProperties);
+				bool GetPhysicalDeviceQueueFamilyProperties(VkPhysicalDevice device, std::vector<VkQueueFamilyProperties>* queueFamilyProperties) const;
 
 				void InstallDebugMessageCallback();
 
@@ -95,7 +95,7 @@ namespace Nz
 				void DestroyInstance();
 				void ResetPointers();
 
-				inline PFN_vkVoidFunction GetProcAddr(const char* name);
+				inline PFN_vkVoidFunction GetProcAddr(const char* name) const;
 
 				struct InternalData;
 
@@ -104,7 +104,7 @@ namespace Nz
 				std::unordered_set<std::string> m_loadedLayers;
 				VkAllocationCallbacks m_allocator;
 				VkInstance m_instance;
-				VkResult m_lastErrorCode;
+				mutable VkResult m_lastErrorCode;
 				UInt32 m_apiVersion;
 		};
 	}

include/Nazara/VulkanRenderer/Wrapper/Instance.inl

@@ -49,7 +49,7 @@ namespace Nz
 			}
 		}
 
-		inline PFN_vkVoidFunction Instance::GetDeviceProcAddr(VkDevice device, const char* name)
+		inline PFN_vkVoidFunction Instance::GetDeviceProcAddr(VkDevice device, const char* name) const
 		{
 			PFN_vkVoidFunction func = vkGetDeviceProcAddr(device, name);
 			if (!func)
@@ -88,7 +88,7 @@ namespace Nz
 			return m_instance;
 		}
 
-		inline VkPhysicalDeviceFeatures Instance::GetPhysicalDeviceFeatures(VkPhysicalDevice device)
+		inline VkPhysicalDeviceFeatures Instance::GetPhysicalDeviceFeatures(VkPhysicalDevice device) const
 		{
 			VkPhysicalDeviceFeatures features;
 			vkGetPhysicalDeviceFeatures(device, &features);
@@ -96,7 +96,7 @@ namespace Nz
 			return features;
 		}
 
-		inline VkFormatProperties Instance::GetPhysicalDeviceFormatProperties(VkPhysicalDevice device, VkFormat format)
+		inline VkFormatProperties Instance::GetPhysicalDeviceFormatProperties(VkPhysicalDevice device, VkFormat format) const
 		{
 			VkFormatProperties formatProperties;
 			vkGetPhysicalDeviceFormatProperties(device, format, &formatProperties);
@@ -104,7 +104,7 @@ namespace Nz
 			return formatProperties;
 		}
 
-		inline bool Instance::GetPhysicalDeviceImageFormatProperties(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkImageTiling tiling, VkImageUsageFlags usage, VkImageCreateFlags flags, VkImageFormatProperties* imageFormatProperties)
+		inline bool Instance::GetPhysicalDeviceImageFormatProperties(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkImageTiling tiling, VkImageUsageFlags usage, VkImageCreateFlags flags, VkImageFormatProperties* imageFormatProperties) const
 		{
 			m_lastErrorCode = vkGetPhysicalDeviceImageFormatProperties(physicalDevice, format, type, tiling, usage, flags, imageFormatProperties);
 			if (m_lastErrorCode != VkResult::VK_SUCCESS)
@@ -116,7 +116,7 @@ namespace Nz
 			return true;
 		}
 
-		inline VkPhysicalDeviceMemoryProperties Instance::GetPhysicalDeviceMemoryProperties(VkPhysicalDevice device)
+		inline VkPhysicalDeviceMemoryProperties Instance::GetPhysicalDeviceMemoryProperties(VkPhysicalDevice device) const
 		{
 			VkPhysicalDeviceMemoryProperties memoryProperties;
 			vkGetPhysicalDeviceMemoryProperties(device, &memoryProperties);
@@ -124,7 +124,7 @@ namespace Nz
 			return memoryProperties;
 		}
 
-		inline VkPhysicalDeviceProperties Instance::GetPhysicalDeviceProperties(VkPhysicalDevice device)
+		inline VkPhysicalDeviceProperties Instance::GetPhysicalDeviceProperties(VkPhysicalDevice device) const
 		{
 			VkPhysicalDeviceProperties properties;
 			vkGetPhysicalDeviceProperties(device, &properties);
@@ -132,7 +132,7 @@ namespace Nz
 			return properties;
 		}
 
-		inline PFN_vkVoidFunction Instance::GetProcAddr(const char* name)
+		inline PFN_vkVoidFunction Instance::GetProcAddr(const char* name) const
 		{
 			PFN_vkVoidFunction func = Loader::GetInstanceProcAddr(m_instance, name);
 			if (!func)

src/Nazara/OpenGLRenderer/OpenGLDevice.cpp

@@ -134,4 +134,78 @@ namespace Nz
 		return std::make_shared<OpenGLTextureSampler>(*this, params);
 	}
 
+	bool OpenGLDevice::IsTextureFormatSupported(PixelFormat format, TextureUsage usage) const
+	{
+		switch (format)
+		{
+			case PixelFormat::Undefined:
+				return false;
+
+			case PixelFormat::A8:
+			case PixelFormat::BGR8:
+			case PixelFormat::BGR8_SRGB:
+			case PixelFormat::BGRA8:
+			case PixelFormat::BGRA8_SRGB:
+			case PixelFormat::L8:
+			case PixelFormat::LA8:
+			case PixelFormat::R8:
+			case PixelFormat::R8I:
+			case PixelFormat::R8UI:
+			case PixelFormat::R16:
+			case PixelFormat::R16F:
+			case PixelFormat::R16I:
+			case PixelFormat::R16UI:
+			case PixelFormat::R32F:
+			case PixelFormat::R32I:
+			case PixelFormat::R32UI:
+			case PixelFormat::RG8:
+			case PixelFormat::RG8I:
+			case PixelFormat::RG8UI:
+			case PixelFormat::RG16:
+			case PixelFormat::RG16F:
+			case PixelFormat::RG16I:
+			case PixelFormat::RG16UI:
+			case PixelFormat::RG32F:
+			case PixelFormat::RG32I:
+			case PixelFormat::RG32UI:
+			case PixelFormat::RGB5A1:
+			case PixelFormat::RGB8:
+			case PixelFormat::RGB8_SRGB:
+			case PixelFormat::RGB16F:
+			case PixelFormat::RGB16I:
+			case PixelFormat::RGB16UI:
+			case PixelFormat::RGB32F:
+			case PixelFormat::RGB32I:
+			case PixelFormat::RGB32UI:
+			case PixelFormat::RGBA4:
+			case PixelFormat::RGBA8:
+			case PixelFormat::RGBA8_SRGB:
+			case PixelFormat::RGBA16F:
+			case PixelFormat::RGBA16I:
+			case PixelFormat::RGBA16UI:
+			case PixelFormat::RGBA32F:
+			case PixelFormat::RGBA32I:
+			case PixelFormat::RGBA32UI:
+				return usage == TextureUsage::ColorAttachment || usage == TextureUsage::InputAttachment || usage == TextureUsage::ShaderSampling || usage == TextureUsage::TransferDestination || usage == TextureUsage::TransferSource;
+
+			case PixelFormat::DXT1:
+			case PixelFormat::DXT3:
+			case PixelFormat::DXT5:
+				return usage == TextureUsage::InputAttachment || usage == TextureUsage::ShaderSampling || usage == TextureUsage::TransferDestination || usage == TextureUsage::TransferSource;
+
+			case PixelFormat::Depth16:
+			case PixelFormat::Depth16Stencil8:
+			case PixelFormat::Depth24:
+			case PixelFormat::Depth24Stencil8:
+			case PixelFormat::Depth32F:
+			case PixelFormat::Depth32FStencil8:
+			case PixelFormat::Stencil1:
+			case PixelFormat::Stencil4:
+			case PixelFormat::Stencil8:
+			case PixelFormat::Stencil16:
+				return usage == TextureUsage::DepthStencilAttachment || usage == TextureUsage::ShaderSampling || usage == TextureUsage::TransferDestination || usage == TextureUsage::TransferSource;
+		}
+
+		return false;
+	}
 }

src/Nazara/OpenGLRenderer/OpenGLRenderWindow.cpp

@@ -69,7 +69,7 @@ namespace Nz
 		if (contextParams.stencilBits > 0)
 			depthFormat = PixelFormat::Depth24Stencil8;
 		else if (contextParams.depthBits > 24)
-			depthFormat = PixelFormat::Depth32;
+			depthFormat = PixelFormat::Depth32F;
 		else if (contextParams.depthBits > 16)
 			depthFormat = PixelFormat::Depth24;
 		else if (contextParams.depthBits > 0)

src/Nazara/Utility/PixelFormat.cpp

@@ -1424,6 +1424,9 @@ namespace Nz
 			s_pixelFormatInfos[UnderlyingCast(format)] = std::move(desc);
 		};
 
+		Bitset<> b8(0xFF);
+		b8.Resize(128);
+
 		Bitset<> b32(0xFFFFFFFF);
 		b32.Resize(128);
 
@@ -1477,9 +1480,11 @@ namespace Nz
 		SetupPixelFormat(PixelFormat::RGBA32I,          PixelFormatDescription("RGBA32I",          PixelFormatContent::ColorRGBA,    b32,                b32 >> 32,          b32 >> 64,          b32 >> 96,          PixelFormatSubType::Int));
 		SetupPixelFormat(PixelFormat::RGBA32UI,         PixelFormatDescription("RGBA32UI",         PixelFormatContent::ColorRGBA,    b32,                b32 >> 32,          b32 >> 64,          b32 >> 96,          PixelFormatSubType::Unsigned));
 		SetupPixelFormat(PixelFormat::Depth16,          PixelFormatDescription("Depth16",          PixelFormatContent::Depth,        0xFFFF,             0,                  0,                  0,                  PixelFormatSubType::Unsigned));
+		SetupPixelFormat(PixelFormat::Depth16Stencil8,  PixelFormatDescription("Depth16Stencil8",  PixelFormatContent::DepthStencil, 0xFFFF0000,         0x0000FF00,         0,                  0,                  PixelFormatSubType::Unsigned));
 		SetupPixelFormat(PixelFormat::Depth24,          PixelFormatDescription("Depth24",          PixelFormatContent::Depth,        0xFFFFFF,           0,                  0,                  0,                  PixelFormatSubType::Unsigned));
 		SetupPixelFormat(PixelFormat::Depth24Stencil8,  PixelFormatDescription("Depth24Stencil8",  PixelFormatContent::DepthStencil, 0xFFFFFF00,         0x000000FF,         0,                  0,                  PixelFormatSubType::Unsigned));
-		SetupPixelFormat(PixelFormat::Depth32,         PixelFormatDescription("Depth32",         PixelFormatContent::Depth,        0xFFFFFFFF,         0,                  0,                  0,                  PixelFormatSubType::Unsigned));
+		SetupPixelFormat(PixelFormat::Depth32F,         PixelFormatDescription("Depth32F",         PixelFormatContent::Depth,        0xFFFFFFFF,         0,                  0,                  0,                  PixelFormatSubType::Unsigned));
+		SetupPixelFormat(PixelFormat::Depth32FStencil8, PixelFormatDescription("Depth32FStencil8", PixelFormatContent::DepthStencil, b32,                b8 >> 32,           0,                  0,                  PixelFormatSubType::Unsigned));
 		SetupPixelFormat(PixelFormat::Stencil1,         PixelFormatDescription("Stencil1",         PixelFormatContent::Stencil,      0x1,                0,                  0,                  0,                  PixelFormatSubType::Unsigned));
 		SetupPixelFormat(PixelFormat::Stencil4,         PixelFormatDescription("Stencil4",         PixelFormatContent::Stencil,      0xF,                0,                  0,                  0,                  PixelFormatSubType::Unsigned));
 		SetupPixelFormat(PixelFormat::Stencil8,         PixelFormatDescription("Stencil8",         PixelFormatContent::Stencil,      0xFF,               0,                  0,                  0,                  PixelFormatSubType::Unsigned));

src/Nazara/VulkanRenderer/VkRenderWindow.cpp

@@ -163,15 +163,23 @@ namespace Nz
 						m_depthStencilFormat = VK_FORMAT_D16_UNORM;
 						break;
 
+					case PixelFormat::Depth16Stencil8:
+						m_depthStencilFormat = VK_FORMAT_D16_UNORM_S8_UINT;
+						break;
+
 					case PixelFormat::Depth24:
 					case PixelFormat::Depth24Stencil8:
 						m_depthStencilFormat = VK_FORMAT_D24_UNORM_S8_UINT;
 						break;
 
-					case PixelFormat::Depth32:
+					case PixelFormat::Depth32F:
 						m_depthStencilFormat = VK_FORMAT_D32_SFLOAT;
 						break;
 
+					case PixelFormat::Depth32FStencil8:
+						m_depthStencilFormat = VK_FORMAT_D32_SFLOAT_S8_UINT;
+						break;
+
 					case PixelFormat::Stencil1:
 					case PixelFormat::Stencil4:
 					case PixelFormat::Stencil8:
@@ -336,6 +344,14 @@ namespace Nz
 			return false;
 		}
 
+		PixelFormat format = FromVulkan(m_depthStencilFormat).value();
+
+		VkImageAspectFlags aspectMask;
+		if (PixelFormatInfo::GetContent(format) == PixelFormatContent::DepthStencil)
+			aspectMask = VK_IMAGE_ASPECT_DEPTH_BIT | VK_IMAGE_ASPECT_STENCIL_BIT;
+		else
+			aspectMask = VK_IMAGE_ASPECT_DEPTH_BIT;
+
 		VkImageViewCreateInfo imageViewCreateInfo = {
 			VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO, // VkStructureType            sType;
 			nullptr,                                  // const void*                pNext;
@@ -350,7 +366,7 @@ namespace Nz
 				VK_COMPONENT_SWIZZLE_A                // VkComponentSwizzle         .a;
 			},
 			{                                         // VkImageSubresourceRange    subresourceRange;
-				VK_IMAGE_ASPECT_DEPTH_BIT | VK_IMAGE_ASPECT_STENCIL_BIT,            // VkImageAspectFlags         .aspectMask;
+				aspectMask,                           // VkImageAspectFlags         .aspectMask;
 				0,                                    // uint32_t                   .baseMipLevel;
 				1,                                    // uint32_t                   .levelCount;
 				0,                                    // uint32_t                   .baseArrayLayer;

src/Nazara/VulkanRenderer/VulkanDevice.cpp

@@ -83,4 +83,35 @@ namespace Nz
 	{
 		return std::make_shared<VulkanTextureSampler>(*this, params);
 	}
+
+	bool VulkanDevice::IsTextureFormatSupported(PixelFormat format, TextureUsage usage) const
+	{
+		VkFormatFeatureFlags flags = 0;
+		switch (usage)
+		{
+			case TextureUsage::ColorAttachment:
+				flags = VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT;
+				break;
+
+			case TextureUsage::DepthStencilAttachment:
+				flags = VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT;
+				break;
+
+			case TextureUsage::InputAttachment:
+			case TextureUsage::ShaderSampling:
+				flags = VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT;
+				break;
+
+			case TextureUsage::TransferSource:
+				flags = VK_FORMAT_FEATURE_TRANSFER_SRC_BIT;
+				break;
+
+			case TextureUsage::TransferDestination:
+				flags = VK_FORMAT_FEATURE_TRANSFER_DST_BIT;
+				break;
+		}
+
+		VkFormatProperties formatProperties = GetInstance().GetPhysicalDeviceFormatProperties(GetPhysicalDevice(), ToVulkan(format));
+		return formatProperties.optimalTilingFeatures & flags; //< Assume optimal tiling
+	}
 }

src/Nazara/VulkanRenderer/VulkanTexture.cpp

@@ -263,6 +263,22 @@ namespace Nz
 				break;
 			}
 
+			case PixelFormat::Depth16:
+			{
+				createImage.format = VK_FORMAT_D16_UNORM;
+				createImageView.format = createImage.format;
+				createImageView.subresourceRange.aspectMask = VK_IMAGE_ASPECT_DEPTH_BIT;
+				break;
+			}
+
+			case PixelFormat::Depth16Stencil8:
+			{
+				createImage.format = VK_FORMAT_D16_UNORM_S8_UINT;
+				createImageView.format = createImage.format;
+				createImageView.subresourceRange.aspectMask = VK_IMAGE_ASPECT_DEPTH_BIT | VK_IMAGE_ASPECT_STENCIL_BIT;
+				break;
+			}
+
 			case PixelFormat::Depth24Stencil8:
 			{
 				createImage.format = VK_FORMAT_D24_UNORM_S8_UINT;
@@ -271,6 +287,22 @@ namespace Nz
 				break;
 			}
 
+			case PixelFormat::Depth32F:
+			{
+				createImage.format = VK_FORMAT_D32_SFLOAT;
+				createImageView.format = createImage.format;
+				createImageView.subresourceRange.aspectMask = VK_IMAGE_ASPECT_DEPTH_BIT;
+				break;
+			}
+
+			case PixelFormat::Depth32FStencil8:
+			{
+				createImage.format = VK_FORMAT_D32_SFLOAT_S8_UINT;
+				createImageView.format = createImage.format;
+				createImageView.subresourceRange.aspectMask = VK_IMAGE_ASPECT_DEPTH_BIT | VK_IMAGE_ASPECT_STENCIL_BIT;
+				break;
+			}
+
 			case PixelFormat::L8:
 			{
 				createImage.format = VK_FORMAT_R8_UNORM;

src/Nazara/VulkanRenderer/Wrapper/Instance.cpp

@@ -135,7 +135,7 @@ namespace Nz
 			return true;
 		}
 
-		bool Instance::EnumeratePhysicalDevices(std::vector<VkPhysicalDevice>* devices)
+		bool Instance::EnumeratePhysicalDevices(std::vector<VkPhysicalDevice>* devices) const
 		{
 			NazaraAssert(devices, "Invalid device vector");
 
@@ -160,7 +160,7 @@ namespace Nz
 			return true;
 		}
 
-		bool Instance::GetPhysicalDeviceExtensions(VkPhysicalDevice device, std::vector<VkExtensionProperties>* extensionProperties)
+		bool Instance::GetPhysicalDeviceExtensions(VkPhysicalDevice device, std::vector<VkExtensionProperties>* extensionProperties) const
 		{
 			NazaraAssert(extensionProperties, "Invalid extension properties vector");
 
@@ -188,7 +188,7 @@ namespace Nz
 			return true;
 		}
 
-		bool Instance::GetPhysicalDeviceQueueFamilyProperties(VkPhysicalDevice device, std::vector<VkQueueFamilyProperties>* queueFamilyProperties)
+		bool Instance::GetPhysicalDeviceQueueFamilyProperties(VkPhysicalDevice device, std::vector<VkQueueFamilyProperties>* queueFamilyProperties) const
 		{
 			NazaraAssert(queueFamilyProperties, "Invalid family properties vector");