sid
/
NazaraEngine
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Renderer: Add support for cubemaps

This commit is contained in:
Jérôme Leclercq 2021-06-01 12:30:37 +02:00
parent c243217dd8
commit 465837ff12
14 changed files with 201 additions and 41 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

14
include/Nazara/OpenGLRenderer/Utils.inl
View File

@ -244,10 +244,16 @@ namespace Nz
{
switch (textureTarget)
{
case GL::TextureTarget::Cubemap: return GL_TEXTURE_CUBE_MAP;
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;
case GL::TextureTarget::Cubemap: return GL_TEXTURE_CUBE_MAP;
case GL::TextureTarget::CubemapNegativeX: return GL_TEXTURE_CUBE_MAP_NEGATIVE_X;
case GL::TextureTarget::CubemapNegativeY: return GL_TEXTURE_CUBE_MAP_NEGATIVE_Y;
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));

6
include/Nazara/OpenGLRenderer/Wrapper/Context.hpp
View File

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

12
include/Nazara/OpenGLRenderer/Wrapper/Texture.hpp
View File

@ -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(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 TexSubImage2D(GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, 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);
inline void TexImage2D(TextureTarget target, GLint level, GLint internalFormat, GLsizei width, GLsizei height, GLint border, 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);
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;

47
include/Nazara/OpenGLRenderer/Wrapper/Texture.inl
View File

@ -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
}

10
include/Nazara/Renderer/Texture.hpp
View File

@ -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;
};

6
include/Nazara/Shader/SpirvConstantCache.hpp
View File

@ -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 multisampled;
bool arrayed = false;
bool multisampled = false;
};
struct Pointer

1
include/Nazara/VulkanRenderer/Wrapper/CommandBuffer.hpp
View File

@ -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);

19
include/Nazara/VulkanRenderer/Wrapper/CommandBuffer.inl
View File

@ -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
VK_IMAGE_ASPECT_COLOR_BIT, //< aspectMask
0,
0,
1
},
subresourceLayers,
{ // imageOffset
0, 0, 0
},

15
src/Nazara/OpenGLRenderer/OpenGLTexture.cpp
View File

@ -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;

36
src/Nazara/Renderer/Texture.cpp
View File

@ -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);
}
}

13
src/Nazara/Shader/ShaderLangParser.cpp
View File

@ -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();

37
src/Nazara/Shader/SpirvConstantCache.cpp
View File

@ -545,17 +545,32 @@ namespace Nz
auto SpirvConstantCache::BuildType(const ShaderAst::SamplerType& type) const -> TypePtr
{
//TODO
auto imageType = Image{
{}, //< qualifier
{}, //< depth
true, //< sampled
SpirvDim::Dim2D, //< dim
SpirvImageFormat::Unknown, //< format
BuildType(ShaderAst::PrimitiveType::Float32), //< sampledType
false, //< arrayed,
false //< multisampled
};
Image imageType;
imageType.sampled = true;
imageType.sampledType = BuildType(type.sampledType);
switch (type.dim)
{
case ImageType::Cubemap:
imageType.dim = SpirvDim::Cube;
break;
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) });
}

2
src/Nazara/VulkanRenderer/VulkanRenderPipeline.cpp
View File

@ -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())
{

24
src/Nazara/VulkanRenderer/VulkanTexture.cpp
View File

@ -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;