Renderer: Add support for cubemaps

include/Nazara/OpenGLRenderer/Utils.inl

@@ -244,10 +244,16 @@ namespace Nz
 	{
 		switch (textureTarget)
 		{
-			case GL::TextureTarget::Cubemap:        return GL_TEXTURE_CUBE_MAP;
+			case GL::TextureTarget::Cubemap:          return GL_TEXTURE_CUBE_MAP;
-			case GL::TextureTarget::Target2D:       return GL_TEXTURE_2D;
+			case GL::TextureTarget::CubemapNegativeX: return GL_TEXTURE_CUBE_MAP_NEGATIVE_X;
-			case GL::TextureTarget::Target2D_Array: return GL_TEXTURE_2D_ARRAY;
+			case GL::TextureTarget::CubemapNegativeY: return GL_TEXTURE_CUBE_MAP_NEGATIVE_Y;
-			case GL::TextureTarget::Target3D:       return GL_TEXTURE_3D;
+			case GL::TextureTarget::CubemapNegativeZ: return GL_TEXTURE_CUBE_MAP_NEGATIVE_Z;
+			case GL::TextureTarget::CubemapPositiveX: return GL_TEXTURE_CUBE_MAP_POSITIVE_X;
+			case GL::TextureTarget::CubemapPositiveY: return GL_TEXTURE_CUBE_MAP_POSITIVE_Y;
+			case GL::TextureTarget::CubemapPositiveZ: return GL_TEXTURE_CUBE_MAP_POSITIVE_Z;
+			case GL::TextureTarget::Target2D:         return GL_TEXTURE_2D;
+			case GL::TextureTarget::Target2D_Array:   return GL_TEXTURE_2D_ARRAY;
+			case GL::TextureTarget::Target3D:         return GL_TEXTURE_3D;
 		}
 
 		NazaraError("Unhandled GL::TextureTarget 0x" + NumberToString(UnderlyingCast(textureTarget), 16));

include/Nazara/OpenGLRenderer/Wrapper/Context.hpp

@@ -72,6 +72,12 @@ namespace Nz::GL
 	enum class TextureTarget
 	{
 		Cubemap,
+		CubemapNegativeX,
+		CubemapNegativeY,
+		CubemapNegativeZ,
+		CubemapPositiveX,
+		CubemapPositiveY,
+		CubemapPositiveZ,
 		Target2D,
 		Target2D_Array,
 		Target3D,

include/Nazara/OpenGLRenderer/Wrapper/Texture.hpp

@@ -29,10 +29,14 @@ namespace Nz::GL
 			inline void SetParameterfv(GLenum pname, const GLfloat* param);
 			inline void SetParameteriv(GLenum pname, const GLint* param);
 
-			inline void TexImage2D(GLint level, GLint internalFormat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type);
+			inline void TexImage2D(TextureTarget target, GLint level, GLint internalFormat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type);
-			inline void TexImage2D(GLint level, GLint internalFormat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const void* data);
+			inline void TexImage2D(TextureTarget target, GLint level, GLint internalFormat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const void* data);
-			inline void TexStorage2D(GLint levels, GLint internalFormat, GLsizei width, GLsizei height);
+			inline void TexImage3D(TextureTarget target, GLint level, GLint internalFormat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type);
-			inline void TexSubImage2D(GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const void* data);
+			inline void TexImage3D(TextureTarget target, GLint level, GLint internalFormat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const void* data);
+			inline void TexStorage2D(TextureTarget target, GLint levels, GLint internalFormat, GLsizei width, GLsizei height);
+			inline void TexStorage3D(TextureTarget target, GLint levels, GLint internalFormat, GLsizei width, GLsizei height, GLsizei depth);
+			inline void TexSubImage2D(TextureTarget target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const void* data);
+			inline void TexSubImage3D(TextureTarget target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const void* data);
 
 			Texture& operator=(const Texture&) = delete;
 			Texture& operator=(Texture&&) noexcept = default;

include/Nazara/OpenGLRenderer/Wrapper/Texture.inl

@@ -44,34 +44,65 @@ namespace Nz::GL
 		context.glTexParameteriv(ToOpenGL(m_target), pname, param);
 	}
 
-	inline void Texture::TexImage2D(GLint level, GLint internalFormat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type)
+	inline void Texture::TexImage2D(TextureTarget target, GLint level, GLint internalFormat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type)
 	{
-		return TexImage2D(level, internalFormat, width, height, border, format, type, nullptr);
+		return TexImage2D(target, level, internalFormat, width, height, border, format, type, nullptr);
 	}
 
-	inline void Texture::TexImage2D(GLint level, GLint internalFormat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const void* data)
+	inline void Texture::TexImage2D(TextureTarget target, GLint level, GLint internalFormat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const void* data)
 	{
-		m_target = TextureTarget::Target2D;
+		m_target = target;
 
 		const Context& context = EnsureDeviceContext();
 		context.BindTexture(m_target, m_objectId);
 		context.glTexImage2D(ToOpenGL(m_target), level, internalFormat, width, height, border, format, type, data);
 	}
 
-	inline void Texture::TexStorage2D(GLint levels, GLint internalFormat, GLsizei width, GLsizei height)
+	inline void Texture::TexImage3D(TextureTarget target, GLint level, GLint internalFormat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type)
 	{
-		m_target = TextureTarget::Target2D;
+		return TexImage3D(target, level, internalFormat, width, height, depth, border, format, type, nullptr);
+	}
+
+	inline void Texture::TexImage3D(TextureTarget target, GLint level, GLint internalFormat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const void* data)
+	{
+		m_target = target;
+
+		const Context& context = EnsureDeviceContext();
+		context.BindTexture(m_target, m_objectId);
+		context.glTexImage3D(ToOpenGL(m_target), level, internalFormat, width, height, depth, border, format, type, data);
+	}
+
+	inline void Texture::TexStorage2D(TextureTarget target, GLint levels, GLint internalFormat, GLsizei width, GLsizei height)
+	{
+		m_target = target;
 
 		const Context& context = EnsureDeviceContext();
 		context.BindTexture(m_target, m_objectId);
 		context.glTexStorage2D(ToOpenGL(m_target), levels, internalFormat, width, height);
 	}
 
-	inline void Texture::TexSubImage2D(GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const void* data)
+	inline void Texture::TexStorage3D(TextureTarget target, GLint levels, GLint internalFormat, GLsizei width, GLsizei height, GLsizei depth)
+	{
+		m_target = target;
+
+		const Context& context = EnsureDeviceContext();
+		context.BindTexture(m_target, m_objectId);
+		context.glTexStorage3D(ToOpenGL(m_target), levels, internalFormat, width, height, depth);
+	}
+
+	inline void Texture::TexSubImage2D(TextureTarget target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const void* data)
 	{
 		const Context& context = EnsureDeviceContext();
 		context.BindTexture(m_target, m_objectId);
-		context.glTexSubImage2D(ToOpenGL(m_target), level, xoffset, yoffset, width, height, format, type, data);
+		context.glTexSubImage2D(ToOpenGL(target), level, xoffset, yoffset, width, height, format, type, data);
+		//< TODO: Handle errors
+	}
+
+	inline void Texture::TexSubImage3D(TextureTarget target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const void* data)
+	{
+		const Context& context = EnsureDeviceContext();
+		context.BindTexture(m_target, m_objectId);
+		context.glTexSubImage3D(ToOpenGL(target), level, xoffset, yoffset, zoffset, width, height, depth, format, type, data);
 		//< TODO: Handle errors
 	}
 

include/Nazara/Renderer/Texture.hpp

@@ -70,6 +70,16 @@ namespace Nz
 			static std::shared_ptr<Texture> LoadFromMemory(const void* data, std::size_t size, const TextureParams& params);
 			static std::shared_ptr<Texture> LoadFromStream(Stream& stream, const TextureParams& params);
 
+			// LoadArray
+			static std::shared_ptr<Texture> LoadArrayFromFile(const std::filesystem::path& filePath, const TextureParams& textureParams, const Vector2ui& atlasSize = Vector2ui(2, 2));
+			static std::shared_ptr<Texture> LoadArrayFromMemory(const void* data, std::size_t size, const TextureParams& textureParams, const Vector2ui& atlasSize = Vector2ui(2, 2));
+			static std::shared_ptr<Texture> LoadArrayFromStream(Stream& stream, const TextureParams& textureParams, const Vector2ui& atlasSize = Vector2ui(2, 2));
+
+			// LoadCubemap
+			static std::shared_ptr<Texture> LoadCubemapFromFile(const std::filesystem::path& filePath, const TextureParams& textureParams, const CubemapParams& cubemapParams = CubemapParams());
+			static std::shared_ptr<Texture> LoadCubemapFromMemory(const void* data, std::size_t size, const TextureParams& textureParams, const CubemapParams& cubemapParams = CubemapParams());
+			static std::shared_ptr<Texture> LoadCubemapFromStream(Stream& stream, const TextureParams& textureParams, const CubemapParams& cubemapParams = CubemapParams());
+
 			Texture& operator=(const Texture&) = delete;
 			Texture& operator=(Texture&&) = delete;
 	};

include/Nazara/Shader/SpirvConstantCache.hpp

@@ -72,10 +72,10 @@ namespace Nz
 				std::optional<bool> depth;
 				std::optional<bool> sampled;
 				SpirvDim dim;
-				SpirvImageFormat format;
+				SpirvImageFormat format = SpirvImageFormat::Unknown;
 				TypePtr sampledType;
-				bool arrayed;
+				bool arrayed = false;
-				bool multisampled;
+				bool multisampled = false;
 			};
 
 			struct Pointer

include/Nazara/VulkanRenderer/Wrapper/CommandBuffer.hpp

@@ -57,6 +57,7 @@ namespace Nz
 
 				inline void CopyBuffer(VkBuffer source, VkBuffer target, UInt64 size, UInt64 sourceOffset = 0, UInt64 targetOffset = 0);
 				inline void CopyBufferToImage(VkBuffer source, VkImage target, VkImageLayout targetLayout, UInt32 width, UInt32 height, UInt32 depth = 1);
+				inline void CopyBufferToImage(VkBuffer source, VkImage target, VkImageLayout targetLayout, const VkImageSubresourceLayers& subresourceLayers, UInt32 width, UInt32 height, UInt32 depth = 1);
 
 				inline void Draw(UInt32 vertexCount, UInt32 instanceCount = 1, UInt32 firstVertex = 0, UInt32 firstInstance = 0);
 				inline void DrawIndexed(UInt32 indexCount, UInt32 instanceCount = 1, UInt32 firstVertex = 0, Int32 vertexOffset = 0, UInt32 firstInstance = 0);

include/Nazara/VulkanRenderer/Wrapper/CommandBuffer.inl

@@ -225,17 +225,24 @@ namespace Nz
 		}
 
 		inline void CommandBuffer::CopyBufferToImage(VkBuffer source, VkImage target, VkImageLayout targetLayout, UInt32 width, UInt32 height, UInt32 depth)
+		{
+			VkImageSubresourceLayers subresourceLayers = {
+				VK_IMAGE_ASPECT_COLOR_BIT, //< aspectMask
+				0,
+				0,
+				1
+			};
+
+			return CopyBufferToImage(source, target, targetLayout, subresourceLayers, width, height, depth);
+		}
+
+		inline void CommandBuffer::CopyBufferToImage(VkBuffer source, VkImage target, VkImageLayout targetLayout, const VkImageSubresourceLayers& subresourceLayers, UInt32 width, UInt32 height, UInt32 depth)
 		{
 			VkBufferImageCopy region = {
 				0,
 				0,
 				0,
-				{ // imageSubresource
+				subresourceLayers,
-					VK_IMAGE_ASPECT_COLOR_BIT, //< aspectMask
-					0,
-					0,
-					1
-				},
 				{ // imageOffset
 					0, 0, 0
 				},

src/Nazara/OpenGLRenderer/OpenGLTexture.cpp

@@ -29,7 +29,7 @@ namespace Nz
 				break;
 
 			case ImageType::E2D:
-				m_texture.TexStorage2D(params.mipmapLevel, format->internalFormat, params.width, params.height);
+				m_texture.TexStorage2D(GL::TextureTarget::Target2D, params.mipmapLevel, format->internalFormat, params.width, params.height);
 				break;
 
 			case ImageType::E2D_Array:
@@ -39,6 +39,7 @@ namespace Nz
 				break;
 
 			case ImageType::Cubemap:
+				m_texture.TexStorage2D(GL::TextureTarget::Cubemap, params.mipmapLevel, format->internalFormat, params.width, params.height);
 				break;
 
 			default:
@@ -86,7 +87,7 @@ namespace Nz
 				break;
 
 			case ImageType::E2D:
-				m_texture.TexSubImage2D(0, 0, 0, m_params.width, m_params.height, format->format, format->type, ptr);
+				m_texture.TexSubImage2D(GL::TextureTarget::Target2D, 0, 0, 0, m_params.width, m_params.height, format->format, format->type, ptr);
 				break;
 
 			case ImageType::E2D_Array:
@@ -96,7 +97,17 @@ namespace Nz
 				break;
 
 			case ImageType::Cubemap:
+			{
+				std::size_t faceSize = PixelFormatInfo::ComputeSize(m_params.pixelFormat, m_params.width, m_params.height, 1);
+				const UInt8* facePtr = static_cast<const UInt8*>(ptr);
+
+				for (GL::TextureTarget face : { GL::TextureTarget::CubemapPositiveX, GL::TextureTarget::CubemapNegativeX, GL::TextureTarget::CubemapPositiveY, GL::TextureTarget::CubemapNegativeY, GL::TextureTarget::CubemapPositiveZ, GL::TextureTarget::CubemapNegativeZ })
+				{
+					m_texture.TexSubImage2D(face, 0, 0, 0, m_params.width, m_params.height, format->format, format->type, facePtr);
+					facePtr += faceSize;
+				}
 				break;
+			}
 
 			default:
 				break;

src/Nazara/Renderer/Texture.cpp

@@ -71,4 +71,40 @@ namespace Nz
 		std::shared_ptr<Image> image = Image::LoadFromStream(stream, params);
 		return CreateFromImage(*image, params);
 	}
+
+	std::shared_ptr<Texture> Texture::LoadArrayFromFile(const std::filesystem::path& filePath, const TextureParams& textureParams, const Vector2ui& atlasSize)
+	{
+		std::shared_ptr<Image> image = Image::LoadArrayFromFile(filePath, textureParams, atlasSize);
+		return CreateFromImage(*image, textureParams);
+	}
+
+	std::shared_ptr<Texture> Texture::LoadArrayFromMemory(const void* data, std::size_t size, const TextureParams& textureParams, const Vector2ui& atlasSize)
+	{
+		std::shared_ptr<Image> image = Image::LoadArrayFromMemory(data, size, textureParams, atlasSize);
+		return CreateFromImage(*image, textureParams);
+	}
+
+	std::shared_ptr<Texture> Texture::LoadArrayFromStream(Stream& stream, const TextureParams& textureParams, const Vector2ui& atlasSize)
+	{
+		std::shared_ptr<Image> image = Image::LoadArrayFromStream(stream, textureParams, atlasSize);
+		return CreateFromImage(*image, textureParams);
+	}
+
+	std::shared_ptr<Texture> Texture::LoadCubemapFromFile(const std::filesystem::path& filePath, const TextureParams& textureParams, const CubemapParams& cubemapParams)
+	{
+		std::shared_ptr<Image> image = Image::LoadCubemapFromFile(filePath, textureParams, cubemapParams);
+		return CreateFromImage(*image, textureParams);
+	}
+
+	std::shared_ptr<Texture> Texture::LoadCubemapFromMemory(const void* data, std::size_t size, const TextureParams& textureParams, const CubemapParams& cubemapParams)
+	{
+		std::shared_ptr<Image> image = Image::LoadCubemapFromMemory(data, size, textureParams, cubemapParams);
+		return CreateFromImage(*image, textureParams);
+	}
+
+	std::shared_ptr<Texture> Texture::LoadCubemapFromStream(Stream& stream, const TextureParams& textureParams, const CubemapParams& cubemapParams)
+	{
+		std::shared_ptr<Image> image = Image::LoadCubemapFromStream(stream, textureParams, cubemapParams);
+		return CreateFromImage(*image, textureParams);
+	}
 }

src/Nazara/Shader/ShaderLangParser.cpp

@@ -166,6 +166,19 @@ namespace Nz::ShaderLang
 
 			return samplerType;
 		}
+		else if (identifier == "samplerCube")
+		{
+			Consume();
+
+			ShaderAst::SamplerType samplerType;
+			samplerType.dim = ImageType::Cubemap;
+
+			Expect(Advance(), TokenType::LessThan); //< '<'
+			samplerType.sampledType = ParsePrimitiveType();
+			Expect(Advance(), TokenType::GreatherThan); //< '>'
+
+			return samplerType;
+		}
 		else if (identifier == "uniform")
 		{
 			Consume();

src/Nazara/Shader/SpirvConstantCache.cpp

@@ -545,17 +545,32 @@ namespace Nz
 
 	auto SpirvConstantCache::BuildType(const ShaderAst::SamplerType& type) const -> TypePtr
 	{
-		//TODO
+		Image imageType;
-		auto imageType = Image{
+		imageType.sampled = true;
-			{}, //< qualifier
+		imageType.sampledType = BuildType(type.sampledType);
-			{}, //< depth
+
-			true, //< sampled
+		switch (type.dim)
-			SpirvDim::Dim2D, //< dim
+		{
-			SpirvImageFormat::Unknown, //< format
+			case ImageType::Cubemap:
-			BuildType(ShaderAst::PrimitiveType::Float32), //< sampledType
+				imageType.dim = SpirvDim::Cube;
-			false, //< arrayed,
+				break;
-			false  //< multisampled
+
-		};
+			case ImageType::E1D_Array:
+				imageType.arrayed = true;
+			case ImageType::E1D:
+				imageType.dim = SpirvDim::Dim1D;
+				break;
+
+			case ImageType::E2D_Array:
+				imageType.arrayed = true;
+			case ImageType::E2D:
+				imageType.dim = SpirvDim::Dim2D;
+				break;
+
+			case ImageType::E3D:
+				imageType.dim = SpirvDim::Dim3D;
+				break;
+		}
 
 		return std::make_shared<Type>(SampledImage{ std::make_shared<Type>(imageType) });
 	}

src/Nazara/VulkanRenderer/VulkanRenderPipeline.cpp

@@ -181,6 +181,8 @@ namespace Nz
 
 		for (auto&& stagePtr : pipelineInfo.shaderModules)
 		{
+			assert(stagePtr);
+
 			Nz::VulkanShaderModule& vulkanModule = *static_cast<Nz::VulkanShaderModule*>(stagePtr.get());
 			for (auto& stage : vulkanModule.GetStages())
 			{

src/Nazara/VulkanRenderer/VulkanTexture.cpp

@@ -110,6 +110,7 @@ namespace Nz
 				NazaraAssert(params.height > 0, "Height must be over zero");
 
 				createInfoView.viewType = VK_IMAGE_VIEW_TYPE_CUBE;
+				createInfoView.subresourceRange.layerCount = 6;
 
 				createInfo.imageType = VK_IMAGE_TYPE_2D;
 				createInfo.extent.width = params.width;
@@ -168,6 +169,8 @@ namespace Nz
 	bool VulkanTexture::Update(const void* ptr)
 	{
 		std::size_t textureSize = m_params.width * m_params.height * m_params.depth * PixelFormatInfo::GetBytesPerPixel(m_params.pixelFormat);
+		if (m_params.type == ImageType::Cubemap)
+			textureSize *= 6;
 
 		VkBufferCreateInfo createInfo = {};
 		createInfo.sType = VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO;
@@ -200,11 +203,26 @@ namespace Nz
 		if (!copyCommandBuffer->Begin(VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT))
 			return false;
 
-		copyCommandBuffer->SetImageLayout(m_image, VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_IMAGE_LAYOUT_UNDEFINED, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL);
+		VkImageSubresourceLayers subresourceLayers = { //< FIXME
+			VK_IMAGE_ASPECT_COLOR_BIT,
+			0, //< mipLevel
+			0, //< baseArrayLayer
+			(m_params.type == ImageType::Cubemap) ? 6 : 1 //< layerCount
+		};
 
-		copyCommandBuffer->CopyBufferToImage(stagingBuffer, m_image, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, m_params.width, m_params.height, m_params.depth);
+		VkImageSubresourceRange subresourceRange = { //< FIXME
+			VK_IMAGE_ASPECT_COLOR_BIT,
+			0, //< baseMipLevel
+			1, //< levelCount
+			subresourceLayers.baseArrayLayer, //< baseArrayLayer
+			subresourceLayers.layerCount      //< layerCount
+		};
 
-		copyCommandBuffer->SetImageLayout(m_image, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL);
+		copyCommandBuffer->SetImageLayout(m_image, VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_IMAGE_LAYOUT_UNDEFINED, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, subresourceRange);
+
+		copyCommandBuffer->CopyBufferToImage(stagingBuffer, m_image, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, subresourceLayers, m_params.width, m_params.height, m_params.depth);
+
+		copyCommandBuffer->SetImageLayout(m_image, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL, subresourceRange);
 
 		if (!copyCommandBuffer->End())
 			return false;