From cce32a64d46b1c9468a13c1eab6830bf4843eb16 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?J=C3=A9r=C3=B4me=20Leclercq?= Date: Mon, 24 May 2021 19:10:53 +0200 Subject: [PATCH] Upgrade Utility --- include/Nazara/Core/ResourceSaver.hpp | 39 +- include/Nazara/Core/ResourceSaver.inl | 86 +-- include/Nazara/Graphics/GraphicalMesh.hpp | 6 +- include/Nazara/Graphics/GraphicalMesh.inl | 2 +- include/Nazara/Graphics/Material.hpp | 4 +- include/Nazara/Graphics/Material.inl | 2 +- .../Nazara/OpenGLRenderer/OpenGLTexture.inl | 12 +- include/Nazara/OpenGLRenderer/Utils.inl | 96 +-- include/Nazara/Utility/AbstractImage.hpp | 12 +- include/Nazara/Utility/AbstractImage.inl | 4 - include/Nazara/Utility/AbstractTextDrawer.hpp | 3 +- include/Nazara/Utility/Algorithm.inl | 28 +- include/Nazara/Utility/Animation.hpp | 38 +- include/Nazara/Utility/Animation.inl | 9 +- include/Nazara/Utility/Buffer.hpp | 28 +- include/Nazara/Utility/Buffer.inl | 9 - include/Nazara/Utility/Enums.hpp | 539 +++++++------- include/Nazara/Utility/FieldOffsets.inl | 126 ++-- include/Nazara/Utility/Font.hpp | 19 +- include/Nazara/Utility/Font.inl | 9 +- include/Nazara/Utility/Image.hpp | 49 +- include/Nazara/Utility/Image.inl | 9 +- include/Nazara/Utility/IndexBuffer.hpp | 36 +- include/Nazara/Utility/IndexBuffer.inl | 13 +- include/Nazara/Utility/IndexMapper.hpp | 8 +- include/Nazara/Utility/Mesh.hpp | 53 +- include/Nazara/Utility/Mesh.inl | 16 - include/Nazara/Utility/PixelFormat.hpp | 6 +- include/Nazara/Utility/PixelFormat.inl | 48 +- include/Nazara/Utility/RichTextDrawer.hpp | 30 +- include/Nazara/Utility/RichTextDrawer.inl | 16 +- include/Nazara/Utility/SimpleTextDrawer.hpp | 12 +- include/Nazara/Utility/SimpleTextDrawer.inl | 10 +- include/Nazara/Utility/SkeletalMesh.hpp | 36 +- include/Nazara/Utility/SkeletalMesh.inl | 9 +- include/Nazara/Utility/Skeleton.hpp | 27 +- include/Nazara/Utility/Skeleton.inl | 8 - include/Nazara/Utility/StaticMesh.hpp | 35 +- include/Nazara/Utility/StaticMesh.inl | 8 - include/Nazara/Utility/SubMesh.hpp | 16 +- include/Nazara/Utility/TriangleIterator.hpp | 4 +- include/Nazara/Utility/UniformBuffer.hpp | 36 +- include/Nazara/Utility/UniformBuffer.inl | 13 +- include/Nazara/Utility/Utility.hpp | 29 + include/Nazara/Utility/VertexBuffer.hpp | 47 +- include/Nazara/Utility/VertexBuffer.inl | 16 +- include/Nazara/Utility/VertexDeclaration.hpp | 12 +- include/Nazara/Utility/VertexDeclaration.inl | 19 +- include/Nazara/Utility/VertexMapper.hpp | 8 +- include/Nazara/Utility/VertexMapper.inl | 2 +- include/Nazara/VulkanRenderer/Utils.inl | 148 ++-- plugins/Assimp/Plugin.cpp | 110 ++- src/Nazara/Graphics/BakedFrameGraph.cpp | 2 +- src/Nazara/Graphics/BasicMaterial.cpp | 12 +- src/Nazara/Graphics/FrameGraph.cpp | 2 +- src/Nazara/Graphics/GraphicalMesh.cpp | 28 +- src/Nazara/Graphics/Graphics.cpp | 4 +- src/Nazara/Graphics/Material.cpp | 4 +- src/Nazara/Graphics/ModelInstance.cpp | 4 +- src/Nazara/Graphics/PhongLightingMaterial.cpp | 26 +- .../Graphics/PredefinedShaderStructs.cpp | 44 +- src/Nazara/OpenGLRenderer/OpenGLBuffer.cpp | 22 +- .../OpenGLRenderer/OpenGLCommandBuffer.cpp | 34 +- .../OpenGLRenderer/OpenGLFboFramebuffer.cpp | 10 +- .../OpenGLRenderer/OpenGLShaderBinding.cpp | 2 +- src/Nazara/OpenGLRenderer/OpenGLTexture.cpp | 24 +- src/Nazara/Shader/GlslWriter.cpp | 14 +- src/Nazara/Shader/LangWriter.cpp | 14 +- src/Nazara/Shader/ShaderLangParser.cpp | 4 +- src/Nazara/Shader/SpirvConstantCache.cpp | 24 +- src/Nazara/Utility/AbstractImage.cpp | 2 +- src/Nazara/Utility/Animation.cpp | 81 +-- src/Nazara/Utility/Buffer.cpp | 41 +- src/Nazara/Utility/FieldOffsets.cpp | 20 +- src/Nazara/Utility/Font.cpp | 53 +- src/Nazara/Utility/Formats/DDSLoader.cpp | 61 +- src/Nazara/Utility/Formats/DDSLoader.hpp | 9 +- src/Nazara/Utility/Formats/FreeTypeLoader.cpp | 61 +- src/Nazara/Utility/Formats/FreeTypeLoader.hpp | 11 +- src/Nazara/Utility/Formats/MD2Loader.cpp | 36 +- src/Nazara/Utility/Formats/MD2Loader.hpp | 9 +- src/Nazara/Utility/Formats/MD5AnimLoader.cpp | 18 +- src/Nazara/Utility/Formats/MD5AnimLoader.hpp | 9 +- src/Nazara/Utility/Formats/MD5MeshLoader.cpp | 48 +- src/Nazara/Utility/Formats/MD5MeshLoader.hpp | 9 +- src/Nazara/Utility/Formats/OBJLoader.cpp | 40 +- src/Nazara/Utility/Formats/OBJLoader.hpp | 9 +- src/Nazara/Utility/Formats/OBJSaver.cpp | 25 +- src/Nazara/Utility/Formats/OBJSaver.hpp | 9 +- src/Nazara/Utility/Formats/PCXLoader.cpp | 22 +- src/Nazara/Utility/Formats/PCXLoader.hpp | 9 +- src/Nazara/Utility/Formats/STBLoader.cpp | 36 +- src/Nazara/Utility/Formats/STBLoader.hpp | 9 +- src/Nazara/Utility/Formats/STBSaver.cpp | 58 +- src/Nazara/Utility/Formats/STBSaver.hpp | 9 +- src/Nazara/Utility/GuillotineImageAtlas.cpp | 6 +- src/Nazara/Utility/Image.cpp | 257 ++++--- src/Nazara/Utility/IndexBuffer.cpp | 40 +- src/Nazara/Utility/IndexMapper.cpp | 67 +- src/Nazara/Utility/Mesh.cpp | 231 +++--- src/Nazara/Utility/Node.cpp | 2 +- src/Nazara/Utility/PixelFormat.cpp | 663 +++++++++--------- src/Nazara/Utility/RichTextDrawer.cpp | 26 +- src/Nazara/Utility/SimpleTextDrawer.cpp | 8 +- src/Nazara/Utility/SkeletalMesh.cpp | 60 +- src/Nazara/Utility/Skeleton.cpp | 270 ++----- src/Nazara/Utility/SoftwareBuffer.cpp | 2 +- src/Nazara/Utility/StaticMesh.cpp | 68 +- src/Nazara/Utility/SubMesh.cpp | 61 +- src/Nazara/Utility/TriangleIterator.cpp | 16 +- src/Nazara/Utility/UniformBuffer.cpp | 34 +- src/Nazara/Utility/Utility.cpp | 109 ++- src/Nazara/Utility/VertexBuffer.cpp | 44 +- src/Nazara/Utility/VertexDeclaration.cpp | 283 ++++---- src/Nazara/Utility/VertexMapper.cpp | 48 +- src/Nazara/VulkanRenderer/VkRenderWindow.cpp | 18 +- src/Nazara/VulkanRenderer/VulkanBuffer.cpp | 16 +- .../VulkanCommandBufferBuilder.cpp | 2 +- src/Nazara/VulkanRenderer/VulkanTexture.cpp | 36 +- src/ShaderNode/ShaderGraph.cpp | 4 +- 120 files changed, 2328 insertions(+), 2971 deletions(-) diff --git a/include/Nazara/Core/ResourceSaver.hpp b/include/Nazara/Core/ResourceSaver.hpp index 4333106e9..a9cc4bcef 100644 --- a/include/Nazara/Core/ResourceSaver.hpp +++ b/include/Nazara/Core/ResourceSaver.hpp @@ -28,25 +28,38 @@ namespace Nz friend Type; public: - using ExtensionGetter = bool (*)(const std::string& extension); - using FormatQuerier = bool (*)(const std::string& format); - using FileSaver = bool (*)(const Type& resource, const std::filesystem::path& filePath, const Parameters& parameters); - using StreamSaver = bool (*)(const Type& resource, const std::string& format, Stream& stream, const Parameters& parameters); + struct Entry; + using FormatSupport = std::function; + using FileSaver = std::function; + using StreamSaver = std::function; - ResourceSaver() = delete; - ~ResourceSaver() = delete; + ResourceSaver() = default; + ResourceSaver(const ResourceSaver&) = delete; + ResourceSaver(ResourceSaver&&) noexcept = default; + ~ResourceSaver() = default; - static bool IsFormatSupported(const std::string& extension); + void Clear(); - static bool SaveToFile(const Type& resource, const std::filesystem::path& filePath, const Parameters& parameters = Parameters()); - static bool SaveToStream(const Type& resource, Stream& stream, const std::string& format, const Parameters& parameters = Parameters()); + bool IsExtensionSupported(const std::string_view& extension) const; - static void RegisterSaver(FormatQuerier formatQuerier, StreamSaver streamSaver, FileSaver fileSaver = nullptr); - static void UnregisterSaver(FormatQuerier formatQuerier, StreamSaver streamSaver, FileSaver fileSaver = nullptr); + bool SaveToFile(const Type& resource, const std::filesystem::path& filePath, const Parameters& parameters = Parameters()) const; + bool SaveToStream(const Type& resource, Stream& stream, const std::string& format, const Parameters& parameters = Parameters()) const; + + const Entry* RegisterSaver(Entry saver); + void UnregisterSaver(const Entry* saver); + + ResourceSaver& operator=(const ResourceSaver&) = delete; + ResourceSaver& operator=(ResourceSaver&&) noexcept = default; + + struct Entry + { + FormatSupport formatSupport; + FileSaver fileSaver; + StreamSaver streamSaver; + }; private: - using Saver = std::tuple; - using SaverList = std::list; + std::vector> m_savers; }; } diff --git a/include/Nazara/Core/ResourceSaver.inl b/include/Nazara/Core/ResourceSaver.inl index 7686ce4d9..68450db68 100644 --- a/include/Nazara/Core/ResourceSaver.inl +++ b/include/Nazara/Core/ResourceSaver.inl @@ -18,6 +18,15 @@ namespace Nz * \brief Core class that represents a list of saver functions for a specific resource type */ + /*! + * \brief Unregister every saver registered + */ + template + void ResourceSaver::Clear() + { + m_savers.clear(); + } + /*! * \brief Checks whether the extension of the file is supported * \return true if supported @@ -25,13 +34,12 @@ namespace Nz * \param extension Extension of the file */ template - bool ResourceSaver::IsFormatSupported(const std::string& extension) + bool ResourceSaver::IsExtensionSupported(const std::string_view& extension) const { - for (Saver& saver : Type::s_savers) + for (const auto& saverPtr : m_savers) { - ExtensionGetter isExtensionSupported = std::get<0>(saver); - - if (isExtensionSupported && isExtensionSupported(extension)) + const Entry& saver = *saverPtr; + if (saver.formatSupport(extension)) return true; } @@ -52,45 +60,42 @@ namespace Nz * \see SaveToStream */ template - bool ResourceSaver::SaveToFile(const Type& resource, const std::filesystem::path& filePath, const Parameters& parameters) + bool ResourceSaver::SaveToFile(const Type& resource, const std::filesystem::path& filePath, const Parameters& parameters) const { NazaraAssert(parameters.IsValid(), "Invalid parameters"); - std::string ext = ToLower(filePath.extension().generic_u8string()); - if (ext.empty()) + std::string extension = ToLower(filePath.extension().generic_u8string()); + if (extension.empty()) { NazaraError("Failed to get file extension from \"" + filePath.generic_u8string() + '"'); return false; } - File file(filePath.generic_u8string()); // Opened only is required - bool found = false; - for (Saver& saver : Type::s_savers) + for (const auto& saverPtr : m_savers) { - FormatQuerier formatQuerier = std::get<0>(saver); - if (!formatQuerier || !formatQuerier(ext)) + const Entry& saver = *saverPtr; + if (!saver.formatSupport(extension)) continue; found = true; - StreamSaver streamSeaver = std::get<1>(saver); - FileSaver fileSaver = std::get<2>(saver); - - if (fileSaver) + if (saver.fileSaver) { - if (fileSaver(resource, filePath, parameters)) + if (saver.fileSaver(resource, filePath, parameters)) return true; } else { + File file(filePath.generic_u8string()); + if (!file.Open(OpenMode_WriteOnly | OpenMode_Truncate)) { NazaraError("Failed to save to file: unable to open \"" + filePath.generic_u8string() + "\" in write mode"); return false; } - if (streamSeaver(resource, ext, file, parameters)) + if (saver.streamSaver(resource, extension, file, parameters)) return true; } @@ -100,7 +105,7 @@ namespace Nz if (found) NazaraError("Failed to save resource: all savers failed"); else - NazaraError("Failed to save resource: no saver found for extension \"" + ext + '"'); + NazaraError("Failed to save resource: no saver found for extension \"" + extension + '"'); return false; } @@ -117,28 +122,26 @@ namespace Nz * \see SaveToFile */ template - bool ResourceSaver::SaveToStream(const Type& resource, Stream& stream, const std::string& format, const Parameters& parameters) + bool ResourceSaver::SaveToStream(const Type& resource, Stream& stream, const std::string& format, const Parameters& parameters) const { NazaraAssert(stream.IsWritable(), "Stream is not writable"); NazaraAssert(parameters.IsValid(), "Invalid parameters"); UInt64 streamPos = stream.GetCursorPos(); bool found = false; - for (Saver& saver : Type::s_savers) + for (const auto& saverPtr : m_savers) { - FormatQuerier formatQuerier = std::get<0>(saver); - if (!formatQuerier || !formatQuerier(format)) + const Entry& saver = *saverPtr; + if (!saver.formatSupport(format)) continue; found = true; - StreamSaver streamSeaver = std::get<1>(saver); - // We move the stream to its old position stream.SetCursorPos(streamPos); // Load of the resource - if (streamSeaver(resource, format, stream, parameters)) + if (saver.streamSaver(resource, format, stream, parameters)) return true; NazaraWarning("Saver failed"); @@ -154,36 +157,35 @@ namespace Nz /*! * \brief Registers a saver + * \return A pointer to the registered Entry which can be unsed to unregister it later * - * \param formatQuerier A function to test whether the format (as a string) is supported by this saver - * \param streamSaver A function which saves the resource to a stream - * \param fileSaver Optional function which saves the resource directly to a file given a file path + * \param loader A collection of saver callbacks that will be registered * - * \remark The fileSaver argument is only present for compatibility with external savers which cannot be interfaced with streams - * \remark At least one saver is required + * \see UnregisterLoader */ template - void ResourceSaver::RegisterSaver(FormatQuerier formatQuerier, StreamSaver streamSaver, FileSaver fileSaver) + auto ResourceSaver::RegisterSaver(Entry saver) -> const Entry* { - NazaraAssert(formatQuerier, "A format querier is mandaroty"); - NazaraAssert(streamSaver || fileSaver, "A saver function is mandaroty"); + NazaraAssert(saver.formatSupport, "A format support callback is mandatory"); + NazaraAssert(saver.streamSaver || saver.fileSaver, "A saver function is mandatory"); - Type::s_savers.push_front(std::make_tuple(formatQuerier, streamSaver, fileSaver)); + auto it = m_savers.emplace(m_savers.begin(), std::make_unique(std::move(saver))); + return it->get(); } /*! * \brief Unregisters a saver * - * \param formatQuerier A function to test whether the format (as a string) is supported by this saver - * \param streamSaver A function which saves the resource to a stream - * \param fileSaver A function function which saves the resource directly to a file given a file path + * \param saver A pointer to a loader returned by RegisterSaver * - * \remark The saver will only be unregistered if the function pointers are exactly the same + * \see RegisterSaver */ template - void ResourceSaver::UnregisterSaver(FormatQuerier formatQuerier, StreamSaver streamSaver, FileSaver fileSaver) + void ResourceSaver::UnregisterSaver(const Entry* saver) { - Type::s_savers.remove(std::make_tuple(formatQuerier, streamSaver, fileSaver)); + auto it = std::find_if(m_savers.begin(), m_savers.end(), [&](const std::unique_ptr& saverPtr) { return saverPtr.get() == saver; }); + if (it != m_savers.end()) + m_savers.erase(it); } } diff --git a/include/Nazara/Graphics/GraphicalMesh.hpp b/include/Nazara/Graphics/GraphicalMesh.hpp index cc68dcf95..aabb44d32 100644 --- a/include/Nazara/Graphics/GraphicalMesh.hpp +++ b/include/Nazara/Graphics/GraphicalMesh.hpp @@ -18,7 +18,7 @@ namespace Nz class NAZARA_GRAPHICS_API GraphicalMesh { public: - GraphicalMesh(const Mesh* mesh); + GraphicalMesh(const Mesh& mesh); GraphicalMesh(const GraphicalMesh&) = delete; GraphicalMesh(GraphicalMesh&&) noexcept = default; ~GraphicalMesh() = default; @@ -26,7 +26,7 @@ namespace Nz inline const std::shared_ptr& GetIndexBuffer(std::size_t subMesh) const; inline std::size_t GetIndexCount(std::size_t subMesh) const; inline const std::shared_ptr& GetVertexBuffer(std::size_t subMesh) const; - inline const VertexDeclarationConstRef& GetVertexDeclaration(std::size_t subMesh) const; + inline const std::shared_ptr& GetVertexDeclaration(std::size_t subMesh) const; inline std::size_t GetSubMeshCount() const; GraphicalMesh& operator=(const GraphicalMesh&) = delete; @@ -38,7 +38,7 @@ namespace Nz std::shared_ptr indexBuffer; std::shared_ptr vertexBuffer; std::size_t indexCount; - VertexDeclarationConstRef vertexDeclaration; + std::shared_ptr vertexDeclaration; }; std::vector m_subMeshes; diff --git a/include/Nazara/Graphics/GraphicalMesh.inl b/include/Nazara/Graphics/GraphicalMesh.inl index f00facb56..5e1f73dd1 100644 --- a/include/Nazara/Graphics/GraphicalMesh.inl +++ b/include/Nazara/Graphics/GraphicalMesh.inl @@ -26,7 +26,7 @@ namespace Nz return m_subMeshes[subMesh].vertexBuffer; } - inline const VertexDeclarationConstRef& GraphicalMesh::GetVertexDeclaration(std::size_t subMesh) const + inline const std::shared_ptr& GraphicalMesh::GetVertexDeclaration(std::size_t subMesh) const { assert(subMesh < m_subMeshes.size()); return m_subMeshes[subMesh].vertexDeclaration; diff --git a/include/Nazara/Graphics/Material.hpp b/include/Nazara/Graphics/Material.hpp index abb4fe973..af7f38612 100644 --- a/include/Nazara/Graphics/Material.hpp +++ b/include/Nazara/Graphics/Material.hpp @@ -10,8 +10,6 @@ #include #include #include -#include -#include #include #include #include @@ -32,7 +30,7 @@ namespace Nz class CommandBufferBuilder; class UploadPool; - class NAZARA_GRAPHICS_API Material : public RefCounted, public Resource + class NAZARA_GRAPHICS_API Material : public Resource { public: Material(std::shared_ptr settings); diff --git a/include/Nazara/Graphics/Material.inl b/include/Nazara/Graphics/Material.inl index 9d5a0869e..016e4830e 100644 --- a/include/Nazara/Graphics/Material.inl +++ b/include/Nazara/Graphics/Material.inl @@ -107,7 +107,7 @@ namespace Nz * * This parameter is required for depth writing. * - * In order to enable depth writing without enabling depth test, set the depth comparison function to RendererComparison_Never + * In order to enable depth writing without enabling depth test, set the depth comparison function to RendererComparison::Never * * \param depthBuffer Defines if this material will use depth buffer * diff --git a/include/Nazara/OpenGLRenderer/OpenGLTexture.inl b/include/Nazara/OpenGLRenderer/OpenGLTexture.inl index e7d789788..85a41a988 100644 --- a/include/Nazara/OpenGLRenderer/OpenGLTexture.inl +++ b/include/Nazara/OpenGLRenderer/OpenGLTexture.inl @@ -17,13 +17,13 @@ namespace Nz { switch (imageType) { - case ImageType_2D: return GL::TextureTarget::Target2D; - case ImageType_2D_Array: return GL::TextureTarget::Target2D_Array; - case ImageType_3D: return GL::TextureTarget::Target3D; - case ImageType_Cubemap: return GL::TextureTarget::Cubemap; + case ImageType::E2D: return GL::TextureTarget::Target2D; + case ImageType::E2D_Array: return GL::TextureTarget::Target2D_Array; + case ImageType::E3D: return GL::TextureTarget::Target3D; + case ImageType::Cubemap: return GL::TextureTarget::Cubemap; - case ImageType_1D: - case ImageType_1D_Array: + case ImageType::E1D: + case ImageType::E1D_Array: default: throw std::runtime_error("unsupported texture type"); } diff --git a/include/Nazara/OpenGLRenderer/Utils.inl b/include/Nazara/OpenGLRenderer/Utils.inl index 74d435d3b..739bda857 100644 --- a/include/Nazara/OpenGLRenderer/Utils.inl +++ b/include/Nazara/OpenGLRenderer/Utils.inl @@ -15,17 +15,17 @@ namespace Nz // TODO: Fill this switch switch (pixelFormat) { - case PixelFormat_A8: return GLTextureFormat{ GL_R8, GL_RED, GL_UNSIGNED_BYTE, GL_ZERO, GL_ZERO, GL_ZERO, GL_RED }; - case PixelFormat_BGR8: return GLTextureFormat{ GL_RGB8, GL_RGB, GL_UNSIGNED_BYTE, GL_BLUE, GL_GREEN, GL_RED, GL_ONE }; - 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_Depth24Stencil8: return GLTextureFormat{ GL_DEPTH24_STENCIL8, GL_DEPTH_STENCIL, GL_UNSIGNED_INT_24_8, 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 }; - case PixelFormat_RGBA8_SRGB: return GLTextureFormat{ GL_SRGB8_ALPHA8, GL_RGBA, GL_UNSIGNED_BYTE, GL_RED, GL_GREEN, GL_BLUE, GL_ALPHA }; - case PixelFormat_RGBA32F: return GLTextureFormat{ GL_RGBA32F, GL_RGBA, GL_FLOAT, GL_RED, GL_GREEN, GL_BLUE, GL_ALPHA }; + case PixelFormat::A8: return GLTextureFormat{ GL_R8, GL_RED, GL_UNSIGNED_BYTE, GL_ZERO, GL_ZERO, GL_ZERO, GL_RED }; + case PixelFormat::BGR8: return GLTextureFormat{ GL_RGB8, GL_RGB, GL_UNSIGNED_BYTE, GL_BLUE, GL_GREEN, GL_RED, GL_ONE }; + 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::Depth24Stencil8: return GLTextureFormat{ GL_DEPTH24_STENCIL8, GL_DEPTH_STENCIL, GL_UNSIGNED_INT_24_8, 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 }; + case PixelFormat::RGBA8_SRGB: return GLTextureFormat{ GL_SRGB8_ALPHA8, GL_RGBA, GL_UNSIGNED_BYTE, GL_RED, GL_GREEN, GL_BLUE, GL_ALPHA }; + case PixelFormat::RGBA32F: return GLTextureFormat{ GL_RGBA32F, GL_RGBA, GL_FLOAT, GL_RED, GL_GREEN, GL_BLUE, GL_ALPHA }; default: break; } @@ -76,12 +76,12 @@ namespace Nz { switch (filter) { - case FaceSide_None: + case FaceSide::None: break; - case FaceSide_Back: return GL_BACK; - case FaceSide_Front: return GL_FRONT; - case FaceSide_FrontAndBack: return GL_FRONT_AND_BACK; + case FaceSide::Back: return GL_BACK; + case FaceSide::Front: return GL_FRONT; + case FaceSide::FrontAndBack: return GL_FRONT_AND_BACK; } NazaraError("Unhandled FaceSide 0x" + NumberToString(UnderlyingCast(filter), 16)); @@ -92,12 +92,12 @@ namespace Nz { switch (primitiveMode) { - case PrimitiveMode_LineList: return GL_LINES; - case PrimitiveMode_LineStrip: return GL_LINE_STRIP; - case PrimitiveMode_PointList: return GL_POINTS; - case PrimitiveMode_TriangleList: return GL_TRIANGLES; - case PrimitiveMode_TriangleStrip: return GL_TRIANGLE_STRIP; - case PrimitiveMode_TriangleFan: return GL_TRIANGLE_FAN; + case PrimitiveMode::LineList: return GL_LINES; + case PrimitiveMode::LineStrip: return GL_LINE_STRIP; + case PrimitiveMode::PointList: return GL_POINTS; + case PrimitiveMode::TriangleList: return GL_TRIANGLES; + case PrimitiveMode::TriangleStrip: return GL_TRIANGLE_STRIP; + case PrimitiveMode::TriangleFan: return GL_TRIANGLE_FAN; } NazaraError("Unhandled PrimitiveMode 0x" + NumberToString(UnderlyingCast(primitiveMode), 16)); @@ -108,14 +108,14 @@ namespace Nz { switch (comparison) { - case RendererComparison_Always: return GL_ALWAYS; - case RendererComparison_Equal: return GL_EQUAL; - case RendererComparison_Greater: return GL_GREATER; - case RendererComparison_GreaterOrEqual: return GL_GEQUAL; - case RendererComparison_Less: return GL_LESS; - case RendererComparison_LessOrEqual: return GL_LEQUAL; - case RendererComparison_Never: return GL_NEVER; - case RendererComparison_NotEqual: return GL_NOTEQUAL; + case RendererComparison::Always: return GL_ALWAYS; + case RendererComparison::Equal: return GL_EQUAL; + case RendererComparison::Greater: return GL_GREATER; + case RendererComparison::GreaterOrEqual: return GL_GEQUAL; + case RendererComparison::Less: return GL_LESS; + case RendererComparison::LessOrEqual: return GL_LEQUAL; + case RendererComparison::Never: return GL_NEVER; + case RendererComparison::NotEqual: return GL_NOTEQUAL; } NazaraError("Unhandled RendererComparison 0x" + NumberToString(UnderlyingCast(comparison), 16)); @@ -126,8 +126,8 @@ namespace Nz { switch (filter) { - case SamplerFilter::SamplerFilter_Linear: return GL_LINEAR; - case SamplerFilter::SamplerFilter_Nearest: return GL_NEAREST; + case SamplerFilter::Linear: return GL_LINEAR; + case SamplerFilter::Nearest: return GL_NEAREST; } NazaraError("Unhandled SamplerFilter 0x" + NumberToString(UnderlyingCast(filter), 16)); @@ -138,24 +138,24 @@ namespace Nz { switch (minFilter) { - case SamplerFilter::SamplerFilter_Linear: + case SamplerFilter::Linear: { switch (mipmapFilter) { - case SamplerMipmapMode_Linear: return GL_LINEAR_MIPMAP_LINEAR; - case SamplerMipmapMode_Nearest: return GL_LINEAR_MIPMAP_NEAREST; + case SamplerMipmapMode::Linear: return GL_LINEAR_MIPMAP_LINEAR; + case SamplerMipmapMode::Nearest: return GL_LINEAR_MIPMAP_NEAREST; } NazaraError("Unhandled SamplerFilter 0x" + NumberToString(UnderlyingCast(mipmapFilter), 16)); return {}; } - case SamplerFilter::SamplerFilter_Nearest: + case SamplerFilter::Nearest: { switch (mipmapFilter) { - case SamplerMipmapMode_Linear: return GL_NEAREST_MIPMAP_LINEAR; - case SamplerMipmapMode_Nearest: return GL_NEAREST_MIPMAP_NEAREST; + case SamplerMipmapMode::Linear: return GL_NEAREST_MIPMAP_LINEAR; + case SamplerMipmapMode::Nearest: return GL_NEAREST_MIPMAP_NEAREST; } NazaraError("Unhandled SamplerFilter 0x" + NumberToString(UnderlyingCast(mipmapFilter), 16)); @@ -171,9 +171,9 @@ namespace Nz { switch (wrapMode) { - case SamplerWrap::SamplerWrap_Clamp: return GL_CLAMP_TO_EDGE; - case SamplerWrap::SamplerWrap_MirroredRepeat: return GL_MIRRORED_REPEAT; - case SamplerWrap::SamplerWrap_Repeat: return GL_REPEAT; + case SamplerWrap::Clamp: return GL_CLAMP_TO_EDGE; + case SamplerWrap::MirroredRepeat: return GL_MIRRORED_REPEAT; + case SamplerWrap::Repeat: return GL_REPEAT; } NazaraError("Unhandled SamplerWrap 0x" + NumberToString(UnderlyingCast(wrapMode), 16)); @@ -196,14 +196,14 @@ namespace Nz { switch (stencilOp) { - case StencilOperation_Decrement: return GL_DECR; - case StencilOperation_DecrementNoClamp: return GL_DECR_WRAP; - case StencilOperation_Increment: return GL_INCR; - case StencilOperation_IncrementNoClamp: return GL_INCR_WRAP; - case StencilOperation_Invert: return GL_INVERT; - case StencilOperation_Keep: return GL_KEEP; - case StencilOperation_Replace: return GL_REPLACE; - case StencilOperation_Zero: return GL_ZERO; + case StencilOperation::Decrement: return GL_DECR; + case StencilOperation::DecrementNoClamp: return GL_DECR_WRAP; + case StencilOperation::Increment: return GL_INCR; + case StencilOperation::IncrementNoClamp: return GL_INCR_WRAP; + case StencilOperation::Invert: return GL_INVERT; + case StencilOperation::Keep: return GL_KEEP; + case StencilOperation::Replace: return GL_REPLACE; + case StencilOperation::Zero: return GL_ZERO; } NazaraError("Unhandled StencilOperation 0x" + NumberToString(UnderlyingCast(stencilOp), 16)); diff --git a/include/Nazara/Utility/AbstractImage.hpp b/include/Nazara/Utility/AbstractImage.hpp index 44ee7d4f8..f5e3f22ce 100644 --- a/include/Nazara/Utility/AbstractImage.hpp +++ b/include/Nazara/Utility/AbstractImage.hpp @@ -8,7 +8,6 @@ #define NAZARA_ABSTRACTIMAGE_HPP #include -#include #include #include #include @@ -19,14 +18,12 @@ namespace Nz { class AbstractImage; - using AbstractImageConstRef = ObjectRef; - using AbstractImageRef = ObjectRef; - - class NAZARA_UTILITY_API AbstractImage : public RefCounted + class NAZARA_UTILITY_API AbstractImage { public: AbstractImage() = default; - inline AbstractImage(const AbstractImage& image); + AbstractImage(const AbstractImage&) = default; + AbstractImage(AbstractImage&&) noexcept = default; virtual ~AbstractImage(); UInt8 GetBytesPerPixel() const; @@ -47,6 +44,9 @@ namespace Nz virtual bool Update(const UInt8* pixels, unsigned int srcWidth = 0, unsigned int srcHeight = 0, UInt8 level = 0) = 0; virtual bool Update(const UInt8* pixels, const Boxui& box, unsigned int srcWidth = 0, unsigned int srcHeight = 0, UInt8 level = 0) = 0; virtual bool Update(const UInt8* pixels, const Rectui& rect, unsigned int z = 0, unsigned int srcWidth = 0, unsigned int srcHeight = 0, UInt8 level = 0) = 0; + + AbstractImage& operator=(const AbstractImage&) = default; + AbstractImage& operator=(AbstractImage&&) noexcept = default; }; } diff --git a/include/Nazara/Utility/AbstractImage.inl b/include/Nazara/Utility/AbstractImage.inl index 772ba8418..219d06bbd 100644 --- a/include/Nazara/Utility/AbstractImage.inl +++ b/include/Nazara/Utility/AbstractImage.inl @@ -6,10 +6,6 @@ namespace Nz { - inline AbstractImage::AbstractImage(const AbstractImage&) : - RefCounted() - { - } } #include diff --git a/include/Nazara/Utility/AbstractTextDrawer.hpp b/include/Nazara/Utility/AbstractTextDrawer.hpp index a435ecc03..25e41d6c1 100644 --- a/include/Nazara/Utility/AbstractTextDrawer.hpp +++ b/include/Nazara/Utility/AbstractTextDrawer.hpp @@ -12,6 +12,7 @@ #include #include #include +#include namespace Nz { @@ -30,7 +31,7 @@ namespace Nz virtual void Clear() = 0; virtual const Rectf& GetBounds() const = 0; - virtual Font* GetFont(std::size_t index) const = 0; + virtual const std::shared_ptr& GetFont(std::size_t index) const = 0; virtual std::size_t GetFontCount() const = 0; virtual const Glyph& GetGlyph(std::size_t index) const = 0; virtual std::size_t GetGlyphCount() const = 0; diff --git a/include/Nazara/Utility/Algorithm.inl b/include/Nazara/Utility/Algorithm.inl index e208d3021..d42ac41ae 100644 --- a/include/Nazara/Utility/Algorithm.inl +++ b/include/Nazara/Utility/Algorithm.inl @@ -14,20 +14,20 @@ namespace Nz return ComponentType{}; } - template<> constexpr ComponentType ComponentTypeId() { return ComponentType_Color; } - template<> constexpr ComponentType ComponentTypeId() { return ComponentType_Double1; } - template<> constexpr ComponentType ComponentTypeId() { return ComponentType_Double2; } - template<> constexpr ComponentType ComponentTypeId() { return ComponentType_Double3; } - template<> constexpr ComponentType ComponentTypeId() { return ComponentType_Double4; } - template<> constexpr ComponentType ComponentTypeId() { return ComponentType_Float1; } - template<> constexpr ComponentType ComponentTypeId() { return ComponentType_Float2; } - template<> constexpr ComponentType ComponentTypeId() { return ComponentType_Float3; } - template<> constexpr ComponentType ComponentTypeId() { return ComponentType_Float4; } - template<> constexpr ComponentType ComponentTypeId() { return ComponentType_Int1; } - template<> constexpr ComponentType ComponentTypeId() { return ComponentType_Int2; } - template<> constexpr ComponentType ComponentTypeId() { return ComponentType_Int3; } - template<> constexpr ComponentType ComponentTypeId() { return ComponentType_Int4; } - template<> constexpr ComponentType ComponentTypeId() { return ComponentType_Quaternion; } + template<> constexpr ComponentType ComponentTypeId() { return ComponentType::Color; } + template<> constexpr ComponentType ComponentTypeId() { return ComponentType::Double1; } + template<> constexpr ComponentType ComponentTypeId() { return ComponentType::Double2; } + template<> constexpr ComponentType ComponentTypeId() { return ComponentType::Double3; } + template<> constexpr ComponentType ComponentTypeId() { return ComponentType::Double4; } + template<> constexpr ComponentType ComponentTypeId() { return ComponentType::Float1; } + template<> constexpr ComponentType ComponentTypeId() { return ComponentType::Float2; } + template<> constexpr ComponentType ComponentTypeId() { return ComponentType::Float3; } + template<> constexpr ComponentType ComponentTypeId() { return ComponentType::Float4; } + template<> constexpr ComponentType ComponentTypeId() { return ComponentType::Int1; } + template<> constexpr ComponentType ComponentTypeId() { return ComponentType::Int2; } + template<> constexpr ComponentType ComponentTypeId() { return ComponentType::Int3; } + template<> constexpr ComponentType ComponentTypeId() { return ComponentType::Int4; } + template<> constexpr ComponentType ComponentTypeId() { return ComponentType::Quaternion; } template constexpr ComponentType GetComponentTypeOf() diff --git a/include/Nazara/Utility/Animation.hpp b/include/Nazara/Utility/Animation.hpp index 0bb90f548..4276bf3c0 100644 --- a/include/Nazara/Utility/Animation.hpp +++ b/include/Nazara/Utility/Animation.hpp @@ -10,8 +10,6 @@ #include #include #include -#include -#include #include #include #include @@ -38,23 +36,18 @@ namespace Nz struct SequenceJoint; class Skeleton; - using AnimationConstRef = ObjectRef; using AnimationLibrary = ObjectLibrary; using AnimationLoader = ResourceLoader; using AnimationManager = ResourceManager; - using AnimationRef = ObjectRef; struct AnimationImpl; - class NAZARA_UTILITY_API Animation : public RefCounted, public Resource + class NAZARA_UTILITY_API Animation : public Resource { - friend AnimationLibrary; - friend AnimationLoader; - friend AnimationManager; - friend class Utility; - public: - Animation() = default; + Animation(); + Animation(const Animation&) = delete; + Animation(Animation&&) noexcept; ~Animation(); bool AddSequence(const Sequence& sequence); @@ -86,26 +79,15 @@ namespace Nz void RemoveSequence(const std::string& sequenceName); void RemoveSequence(std::size_t index); - template static AnimationRef New(Args&&... args); + Animation& operator=(const Animation&) = delete; + Animation& operator=(Animation&&) noexcept; - static AnimationRef LoadFromFile(const std::filesystem::path& filePath, const AnimationParams& params = AnimationParams()); - static AnimationRef LoadFromMemory(const void* data, std::size_t size, const AnimationParams& params = AnimationParams()); - static AnimationRef LoadFromStream(Stream& stream, const AnimationParams& params = AnimationParams()); - - // Signals: - NazaraSignal(OnAnimationDestroy, const Animation* /*animation*/); - NazaraSignal(OnAnimationRelease, const Animation* /*animation*/); + static std::shared_ptr LoadFromFile(const std::filesystem::path& filePath, const AnimationParams& params = AnimationParams()); + static std::shared_ptr LoadFromMemory(const void* data, std::size_t size, const AnimationParams& params = AnimationParams()); + static std::shared_ptr LoadFromStream(Stream& stream, const AnimationParams& params = AnimationParams()); private: - static bool Initialize(); - static void Uninitialize(); - - MovablePtr m_impl = nullptr; - - static AnimationLibrary::LibraryMap s_library; - static AnimationLoader::LoaderList s_loaders; - static AnimationManager::ManagerMap s_managerMap; - static AnimationManager::ManagerParams s_managerParameters; + std::unique_ptr m_impl; }; } diff --git a/include/Nazara/Utility/Animation.inl b/include/Nazara/Utility/Animation.inl index 074080565..00631415c 100644 --- a/include/Nazara/Utility/Animation.inl +++ b/include/Nazara/Utility/Animation.inl @@ -2,19 +2,12 @@ // This file is part of the "Nazara Engine - Utility module" // For conditions of distribution and use, see copyright notice in Config.hpp +#include #include #include namespace Nz { - template - AnimationRef Animation::New(Args&&... args) - { - std::unique_ptr object(new Animation(std::forward(args)...)); - object->SetPersistent(false); - - return object.release(); - } } #include diff --git a/include/Nazara/Utility/Buffer.hpp b/include/Nazara/Utility/Buffer.hpp index 5cc4f173f..1302cf383 100644 --- a/include/Nazara/Utility/Buffer.hpp +++ b/include/Nazara/Utility/Buffer.hpp @@ -8,37 +8,30 @@ #define NAZARA_BUFFER_HPP #include -#include -#include -#include #include #include #include #include +#include namespace Nz { - class Buffer; - - using BufferConstRef = ObjectRef; - using BufferRef = ObjectRef; - - class NAZARA_UTILITY_API Buffer : public RefCounted + class NAZARA_UTILITY_API Buffer { friend class Utility; public: - using BufferFactory = AbstractBuffer* (*)(Buffer* parent, BufferType type); + using BufferFactory = std::function(Buffer* parent, BufferType type)>; Buffer(BufferType type); - Buffer(BufferType type, UInt32 size, DataStorage storage = DataStorage_Software, BufferUsageFlags usage = 0); + Buffer(BufferType type, UInt32 size, DataStorage storage = DataStorage::Software, BufferUsageFlags usage = 0); Buffer(const Buffer&) = delete; Buffer(Buffer&&) = delete; - ~Buffer(); + ~Buffer() = default; - bool CopyContent(const BufferRef& buffer); + bool CopyContent(const Buffer& buffer); - bool Create(UInt32 size, DataStorage storage = DataStorage_Software, BufferUsageFlags usage = 0); + bool Create(UInt32 size, DataStorage storage = DataStorage::Software, BufferUsageFlags usage = 0); void Destroy(); bool Fill(const void* data, UInt32 offset, UInt32 size); @@ -64,13 +57,8 @@ namespace Nz Buffer& operator=(Buffer&&) = delete; static bool IsStorageSupported(DataStorage storage); - template static BufferRef New(Args&&... args); static void SetBufferFactory(DataStorage storage, BufferFactory func); - // Signals: - NazaraSignal(OnBufferDestroy, const Buffer* /*buffer*/); - NazaraSignal(OnBufferRelease, const Buffer* /*buffer*/); - private: static bool Initialize(); static void Uninitialize(); @@ -80,7 +68,7 @@ namespace Nz BufferUsageFlags m_usage; UInt32 m_size; - static std::array s_bufferFactories; + static std::array s_bufferFactories; }; } diff --git a/include/Nazara/Utility/Buffer.inl b/include/Nazara/Utility/Buffer.inl index 4b02b35b7..262bea3d6 100644 --- a/include/Nazara/Utility/Buffer.inl +++ b/include/Nazara/Utility/Buffer.inl @@ -41,15 +41,6 @@ namespace Nz { return m_impl != nullptr; } - - template - BufferRef Buffer::New(Args&&... args) - { - std::unique_ptr object(new Buffer(std::forward(args)...)); - object->SetPersistent(false); - - return object.release(); - } } #include diff --git a/include/Nazara/Utility/Enums.hpp b/include/Nazara/Utility/Enums.hpp index d740dfd2c..7f586b630 100644 --- a/include/Nazara/Utility/Enums.hpp +++ b/include/Nazara/Utility/Enums.hpp @@ -11,12 +11,12 @@ namespace Nz { - enum AnimationType + enum class AnimationType { - AnimationType_Skeletal, - AnimationType_Static, + Skeletal, + Static, - AnimationType_Max = AnimationType_Static + Max = Static }; enum class BlendEquation @@ -46,286 +46,281 @@ namespace Nz Zero }; - enum BufferAccess + enum class BufferAccess { - BufferAccess_DiscardAndWrite, - BufferAccess_ReadOnly, - BufferAccess_ReadWrite, - BufferAccess_WriteOnly, + DiscardAndWrite, + ReadOnly, + ReadWrite, + WriteOnly, - BufferAccess_Max = BufferAccess_WriteOnly + Max = WriteOnly }; - enum BufferType + enum class BufferType { - BufferType_Index, - BufferType_Vertex, - BufferType_Uniform, + Index, + Vertex, + Uniform, - BufferType_Max = BufferType_Uniform + Max = Uniform }; - enum BufferUsage + enum class BufferUsage { - BufferUsage_DeviceLocal, - BufferUsage_DirectMapping, - BufferUsage_Dynamic, - BufferUsage_PersistentMapping, + DeviceLocal, + DirectMapping, + Dynamic, + PersistentMapping, - BufferUsage_Max = BufferUsage_DirectMapping + Max = DirectMapping }; template<> struct EnumAsFlags { - static constexpr BufferUsage max = BufferUsage_Max; + static constexpr BufferUsage max = BufferUsage::Max; }; using BufferUsageFlags = Flags; - enum ComponentType + enum class ComponentType { - ComponentType_Color, - ComponentType_Double1, - ComponentType_Double2, - ComponentType_Double3, - ComponentType_Double4, - ComponentType_Float1, - ComponentType_Float2, - ComponentType_Float3, - ComponentType_Float4, - ComponentType_Int1, - ComponentType_Int2, - ComponentType_Int3, - ComponentType_Int4, - ComponentType_Quaternion, + Color, + Double1, + Double2, + Double3, + Double4, + Float1, + Float2, + Float3, + Float4, + Int1, + Int2, + Int3, + Int4, + Quaternion, - ComponentType_Max = ComponentType_Quaternion + Max = Quaternion }; - enum CubemapFace + constexpr std::size_t ComponentTypeCount = static_cast(ComponentType::Max) + 1; + + enum class CubemapFace { // This enumeration is intended to replace the "z" argument of Image's methods containing cubemap // The order is X, -X, Y, -Y, Z, -Z - CubemapFace_PositiveX = 0, - CubemapFace_PositiveY = 2, - CubemapFace_PositiveZ = 4, - CubemapFace_NegativeX = 1, - CubemapFace_NegativeY = 3, - CubemapFace_NegativeZ = 5, + PositiveX = 0, + PositiveY = 2, + PositiveZ = 4, + NegativeX = 1, + NegativeY = 3, + NegativeZ = 5, - CubemapFace_Max = CubemapFace_NegativeZ + Max = NegativeZ }; - enum DataStorage + enum class DataStorage { - DataStorage_Hardware, - DataStorage_Software, + Hardware, + Software, - DataStorage_Max = DataStorage_Software + Max = Software }; - enum FaceFilling - { - FaceFilling_Fill, - FaceFilling_Line, - FaceFilling_Point, + constexpr std::size_t DataStorageCount = static_cast(DataStorage::Max) + 1; - FaceFilling_Max = FaceFilling_Point + enum class FaceFilling + { + Fill, + Line, + Point, + + Max = Point }; - enum FaceSide + enum class FaceSide { - FaceSide_None, + None, - FaceSide_Back, - FaceSide_Front, - FaceSide_FrontAndBack, + Back, + Front, + FrontAndBack, - FaceSide_Max = FaceSide_FrontAndBack + Max = FrontAndBack }; - enum ImageType + enum class ImageType { - ImageType_1D, - ImageType_1D_Array, - ImageType_2D, - ImageType_2D_Array, - ImageType_3D, - ImageType_Cubemap, + E1D, + E1D_Array, + E2D, + E2D_Array, + E3D, + Cubemap, - ImageType_Max = ImageType_Cubemap + Max = Cubemap }; - constexpr std::size_t ImageTypeCount = static_cast(ImageType_Max) + 1; + constexpr std::size_t ImageTypeCount = static_cast(ImageType::Max) + 1; - enum NodeType + enum class NodeType { - NodeType_Default, // Node - NodeType_Scene, // SceneNode (Graphics) - NodeType_Skeletal, ///TODO + Default, // Node + Scene, // SceneNode (Graphics) + Skeletal, ///TODO - NodeType_Max = NodeType_Skeletal + Max = Skeletal }; - enum PixelFormatContent + enum class PixelFormatContent { - PixelFormatContent_Undefined = -1, + Undefined = -1, - PixelFormatContent_ColorRGBA, - PixelFormatContent_Depth, - PixelFormatContent_DepthStencil, - PixelFormatContent_Stencil, + ColorRGBA, + Depth, + DepthStencil, + Stencil, - PixelFormatContent_Max = PixelFormatContent_Stencil + Max = Stencil }; - enum PixelFormat + enum class PixelFormat { - PixelFormat_Undefined = -1, + Undefined = -1, - PixelFormat_A8, // 1*uint8 - PixelFormat_BGR8, // 3*uint8 - PixelFormat_BGR8_SRGB, // 3*uint8 - PixelFormat_BGRA8, // 4*uint8 - PixelFormat_BGRA8_SRGB, // 4*uint8 - PixelFormat_DXT1, - PixelFormat_DXT3, - PixelFormat_DXT5, - PixelFormat_L8, // 1*uint8 - PixelFormat_LA8, // 2*uint8 - PixelFormat_R8, // 1*uint8 - PixelFormat_R8I, // 1*int8 - PixelFormat_R8UI, // 1*uint8 - PixelFormat_R16, // 1*uint16 - PixelFormat_R16F, // 1*half - PixelFormat_R16I, // 1*int16 - PixelFormat_R16UI, // 1*uint16 - PixelFormat_R32F, // 1*float - PixelFormat_R32I, // 1*uint16 - PixelFormat_R32UI, // 1*uint32 - PixelFormat_RG8, // 2*int8 - PixelFormat_RG8I, // 2*int8 - PixelFormat_RG8UI, // 2*uint8 - PixelFormat_RG16, // 2*uint16 - PixelFormat_RG16F, // 2*half - PixelFormat_RG16I, // 2*int16 - PixelFormat_RG16UI, // 2*uint16 - PixelFormat_RG32F, // 2*float - PixelFormat_RG32I, // 2*uint16 - PixelFormat_RG32UI, // 2*uint32 - PixelFormat_RGB5A1, // 3*uint5 + alpha bit - PixelFormat_RGB8, // 3*uint8 - PixelFormat_RGB8_SRGB, // 3*uint8 - PixelFormat_RGB16F, // 3*half - PixelFormat_RGB16I, // 4*int16 - PixelFormat_RGB16UI, // 4*uint16 - PixelFormat_RGB32F, // 3*float - PixelFormat_RGB32I, // 4*int32 - PixelFormat_RGB32UI, // 4*uint32 - PixelFormat_RGBA4, // 4*uint4 - PixelFormat_RGBA8, // 4*uint8 - PixelFormat_RGBA8_SRGB, // 4*uint8 - PixelFormat_RGBA16F, // 4*half - PixelFormat_RGBA16I, // 4*int16 - PixelFormat_RGBA16UI, // 4*uint16 - PixelFormat_RGBA32F, // 4*float - PixelFormat_RGBA32I, // 4*int32 - PixelFormat_RGBA32UI, // 4*uint32 - PixelFormat_Depth16, - PixelFormat_Depth24, - PixelFormat_Depth24Stencil8, - PixelFormat_Depth32, - PixelFormat_Stencil1, - PixelFormat_Stencil4, - PixelFormat_Stencil8, - PixelFormat_Stencil16, + A8, // 1*uint8 + BGR8, // 3*uint8 + BGR8_SRGB, // 3*uint8 + BGRA8, // 4*uint8 + BGRA8_SRGB, // 4*uint8 + DXT1, + DXT3, + DXT5, + L8, // 1*uint8 + LA8, // 2*uint8 + R8, // 1*uint8 + R8I, // 1*int8 + R8UI, // 1*uint8 + R16, // 1*uint16 + R16F, // 1*half + R16I, // 1*int16 + R16UI, // 1*uint16 + R32F, // 1*float + R32I, // 1*uint16 + R32UI, // 1*uint32 + RG8, // 2*int8 + RG8I, // 2*int8 + RG8UI, // 2*uint8 + RG16, // 2*uint16 + RG16F, // 2*half + RG16I, // 2*int16 + RG16UI, // 2*uint16 + RG32F, // 2*float + RG32I, // 2*uint16 + RG32UI, // 2*uint32 + RGB5A1, // 3*uint5 + alpha bit + RGB8, // 3*uint8 + RGB8_SRGB, // 3*uint8 + RGB16F, // 3*half + RGB16I, // 4*int16 + RGB16UI, // 4*uint16 + RGB32F, // 3*float + RGB32I, // 4*int32 + RGB32UI, // 4*uint32 + RGBA4, // 4*uint4 + RGBA8, // 4*uint8 + RGBA8_SRGB, // 4*uint8 + RGBA16F, // 4*half + RGBA16I, // 4*int16 + RGBA16UI, // 4*uint16 + RGBA32F, // 4*float + RGBA32I, // 4*int32 + RGBA32UI, // 4*uint32 + Depth16, + Depth24, + Depth24Stencil8, + Depth32, + Stencil1, + Stencil4, + Stencil8, + Stencil16, - PixelFormat_Max = PixelFormat_Stencil16 + Max = Stencil16 }; - enum PixelFormatSubType - { - PixelFormatSubType_Compressed, // Opaque - PixelFormatSubType_Double, // F64 - PixelFormatSubType_Float, // F32 - PixelFormatSubType_Half, // F16 - PixelFormatSubType_Int, // Signed integer - PixelFormatSubType_Unsigned, // Unsigned integer + constexpr std::size_t PixelFormatCount = static_cast(PixelFormat::Max) + 1; - PixelFormatSubType_Max = PixelFormatSubType_Unsigned + enum class PixelFormatSubType + { + Compressed, // Opaque + Double, // F64 + Float, // F32 + Half, // F16 + Int, // Signed integer + Unsigned, // Unsigned integer + + Max = Unsigned }; - enum PixelFlipping + enum class PixelFlipping { - PixelFlipping_Horizontally, - PixelFlipping_Vertically, + Horizontally, + Vertically, - PixelFlipping_Max = PixelFlipping_Vertically + Max = Vertically }; - enum PrimitiveMode - { - PrimitiveMode_LineList, - PrimitiveMode_LineStrip, - PrimitiveMode_PointList, - PrimitiveMode_TriangleList, - PrimitiveMode_TriangleStrip, - PrimitiveMode_TriangleFan, + constexpr std::size_t PixelFlippingCount = static_cast(PixelFlipping::Max) + 1; - PrimitiveMode_Max = PrimitiveMode_TriangleFan + enum class PrimitiveMode + { + LineList, + LineStrip, + PointList, + TriangleList, + TriangleStrip, + TriangleFan, + + Max = TriangleFan }; - enum RendererComparison + enum class RendererComparison { - RendererComparison_Always, - RendererComparison_Equal, - RendererComparison_Greater, - RendererComparison_GreaterOrEqual, - RendererComparison_Less, - RendererComparison_LessOrEqual, - RendererComparison_Never, - RendererComparison_NotEqual, + Always, + Equal, + Greater, + GreaterOrEqual, + Less, + LessOrEqual, + Never, + NotEqual, - RendererComparison_Max = RendererComparison_NotEqual + Max = NotEqual }; - enum RendererParameter + enum class SamplerFilter { - RendererParameter_Blend, - RendererParameter_ColorWrite, - RendererParameter_DepthBuffer, - RendererParameter_DepthWrite, - RendererParameter_FaceCulling, - RendererParameter_ScissorTest, - RendererParameter_StencilTest, + Linear, + Nearest, - RendererParameter_Max = RendererParameter_StencilTest + Max = Nearest }; - enum SamplerFilter + enum class SamplerMipmapMode { - SamplerFilter_Linear, - SamplerFilter_Nearest, + Linear, + Nearest, - SamplerFilter_Max = SamplerFilter_Nearest + Max = Nearest }; - enum SamplerMipmapMode + enum class SamplerWrap { - SamplerMipmapMode_Linear, - SamplerMipmapMode_Nearest, + Clamp, + MirroredRepeat, + Repeat, - SamplerMipmapMode_Max = SamplerMipmapMode_Nearest - }; - - enum SamplerWrap - { - SamplerWrap_Clamp, - SamplerWrap_MirroredRepeat, - SamplerWrap_Repeat, - - SamplerWrap_Max = SamplerWrap_Repeat + Max = Repeat }; enum class ShaderStageType @@ -348,95 +343,95 @@ namespace Nz constexpr ShaderStageTypeFlags ShaderStageType_All = ShaderStageType::Fragment | ShaderStageType::Vertex; - enum StructFieldType + enum class StructFieldType { - StructFieldType_Bool1, - StructFieldType_Bool2, - StructFieldType_Bool3, - StructFieldType_Bool4, - StructFieldType_Float1, - StructFieldType_Float2, - StructFieldType_Float3, - StructFieldType_Float4, - StructFieldType_Double1, - StructFieldType_Double2, - StructFieldType_Double3, - StructFieldType_Double4, - StructFieldType_Int1, - StructFieldType_Int2, - StructFieldType_Int3, - StructFieldType_Int4, - StructFieldType_UInt1, - StructFieldType_UInt2, - StructFieldType_UInt3, - StructFieldType_UInt4, + Bool1, + Bool2, + Bool3, + Bool4, + Float1, + Float2, + Float3, + Float4, + Double1, + Double2, + Double3, + Double4, + Int1, + Int2, + Int3, + Int4, + UInt1, + UInt2, + UInt3, + UInt4, - StructFieldType_Max = StructFieldType_UInt4 + Max = UInt4 }; - enum StructLayout + enum class StructLayout { - StructLayout_Packed, - StructLayout_Std140, + Packed, + Std140, - StructLayout_Max = StructLayout_Std140 + Max = Std140 }; - enum StencilOperation + enum class StencilOperation { - StencilOperation_Decrement, - StencilOperation_DecrementNoClamp, - StencilOperation_Increment, - StencilOperation_IncrementNoClamp, - StencilOperation_Invert, - StencilOperation_Keep, - StencilOperation_Replace, - StencilOperation_Zero, + Decrement, + DecrementNoClamp, + Increment, + IncrementNoClamp, + Invert, + Keep, + Replace, + Zero, - StencilOperation_Max = StencilOperation_Zero + Max = Zero }; - enum TextAlign + enum class TextAlign { - TextAlign_Left, - TextAlign_Middle, - TextAlign_Right, + Left, + Middle, + Right, - TextAlign_Max = TextAlign_Right + Max = Right }; - enum TextStyle + enum class TextStyle { - TextStyle_Bold, - TextStyle_Italic, - TextStyle_StrikeThrough, - TextStyle_Underlined, + Bold, + Italic, + StrikeThrough, + Underlined, - TextStyle_Max = TextStyle_Underlined + Max = Underlined }; template<> struct EnumAsFlags { - static constexpr TextStyle max = TextStyle_Max; + static constexpr TextStyle max = TextStyle::Max; }; using TextStyleFlags = Flags; constexpr TextStyleFlags TextStyle_Regular = 0; - enum VertexComponent + enum class VertexComponent { - VertexComponent_Unused = -1, + Unused = -1, - VertexComponent_Color, - VertexComponent_Normal, - VertexComponent_Position, - VertexComponent_Tangent, - VertexComponent_TexCoord, - VertexComponent_Userdata, + Color, + Normal, + Position, + Tangent, + TexCoord, + Userdata, - VertexComponent_Max = VertexComponent_Userdata + Max = Userdata }; enum class VertexInputRate @@ -445,26 +440,28 @@ namespace Nz Vertex }; - enum VertexLayout + enum class VertexLayout { // Predefined declarations for rendering - VertexLayout_XY, - VertexLayout_XY_Color, - VertexLayout_XY_UV, - VertexLayout_XYZ, - VertexLayout_XYZ_Color, - VertexLayout_XYZ_Color_UV, - VertexLayout_XYZ_Normal, - VertexLayout_XYZ_Normal_UV, - VertexLayout_XYZ_Normal_UV_Tangent, - VertexLayout_XYZ_Normal_UV_Tangent_Skinning, - VertexLayout_XYZ_UV, + XY, + XY_Color, + XY_UV, + XYZ, + XYZ_Color, + XYZ_Color_UV, + XYZ_Normal, + XYZ_Normal_UV, + XYZ_Normal_UV_Tangent, + XYZ_Normal_UV_Tangent_Skinning, + XYZ_UV, // Predefined declarations for instancing - VertexLayout_Matrix4, + Matrix4, - VertexLayout_Max = VertexLayout_Matrix4 + Max = Matrix4 }; + + constexpr std::size_t VertexLayoutCount = static_cast(VertexLayout::Max) + 1; } #endif // NAZARA_ENUMS_UTILITY_HPP diff --git a/include/Nazara/Utility/FieldOffsets.inl b/include/Nazara/Utility/FieldOffsets.inl index 5a8275ca7..655cb774a 100644 --- a/include/Nazara/Utility/FieldOffsets.inl +++ b/include/Nazara/Utility/FieldOffsets.inl @@ -25,7 +25,7 @@ namespace Nz inline std::size_t FieldOffsets::GetAlignedSize() const { - if (m_layout == StructLayout_Std140) + if (m_layout == StructLayout::Std140) return Align(m_size, m_largestFieldAlignment); else return m_size; @@ -40,43 +40,43 @@ namespace Nz { switch (layout) { - case StructLayout_Packed: + case StructLayout::Packed: return 1; - case StructLayout_Std140: + case StructLayout::Std140: { switch (fieldType) { - case StructFieldType_Bool1: - case StructFieldType_Float1: - case StructFieldType_Int1: - case StructFieldType_UInt1: + case StructFieldType::Bool1: + case StructFieldType::Float1: + case StructFieldType::Int1: + case StructFieldType::UInt1: return 4; - case StructFieldType_Bool2: - case StructFieldType_Float2: - case StructFieldType_Int2: - case StructFieldType_UInt2: + case StructFieldType::Bool2: + case StructFieldType::Float2: + case StructFieldType::Int2: + case StructFieldType::UInt2: return 2 * 4; - case StructFieldType_Bool3: - case StructFieldType_Float3: - case StructFieldType_Int3: - case StructFieldType_UInt3: - case StructFieldType_Bool4: - case StructFieldType_Float4: - case StructFieldType_Int4: - case StructFieldType_UInt4: + case StructFieldType::Bool3: + case StructFieldType::Float3: + case StructFieldType::Int3: + case StructFieldType::UInt3: + case StructFieldType::Bool4: + case StructFieldType::Float4: + case StructFieldType::Int4: + case StructFieldType::UInt4: return 4 * 4; - case StructFieldType_Double1: + case StructFieldType::Double1: return 8; - case StructFieldType_Double2: + case StructFieldType::Double2: return 2 * 8; - case StructFieldType_Double3: - case StructFieldType_Double4: + case StructFieldType::Double3: + case StructFieldType::Double4: return 4 * 8; } } @@ -89,32 +89,32 @@ namespace Nz { switch (fieldType) { - case StructFieldType_Bool1: - case StructFieldType_Double1: - case StructFieldType_Float1: - case StructFieldType_Int1: - case StructFieldType_UInt1: + case StructFieldType::Bool1: + case StructFieldType::Double1: + case StructFieldType::Float1: + case StructFieldType::Int1: + case StructFieldType::UInt1: return 1; - case StructFieldType_Bool2: - case StructFieldType_Double2: - case StructFieldType_Float2: - case StructFieldType_Int2: - case StructFieldType_UInt2: + case StructFieldType::Bool2: + case StructFieldType::Double2: + case StructFieldType::Float2: + case StructFieldType::Int2: + case StructFieldType::UInt2: return 2; - case StructFieldType_Bool3: - case StructFieldType_Double3: - case StructFieldType_Float3: - case StructFieldType_Int3: - case StructFieldType_UInt3: + case StructFieldType::Bool3: + case StructFieldType::Double3: + case StructFieldType::Float3: + case StructFieldType::Int3: + case StructFieldType::UInt3: return 3; - case StructFieldType_Bool4: - case StructFieldType_Double4: - case StructFieldType_Float4: - case StructFieldType_Int4: - case StructFieldType_UInt4: + case StructFieldType::Bool4: + case StructFieldType::Double4: + case StructFieldType::Float4: + case StructFieldType::Int4: + case StructFieldType::UInt4: return 4; } @@ -125,40 +125,40 @@ namespace Nz { switch (fieldType) { - case StructFieldType_Bool1: - case StructFieldType_Float1: - case StructFieldType_Int1: - case StructFieldType_UInt1: + case StructFieldType::Bool1: + case StructFieldType::Float1: + case StructFieldType::Int1: + case StructFieldType::UInt1: return 4; - case StructFieldType_Bool2: - case StructFieldType_Float2: - case StructFieldType_Int2: - case StructFieldType_UInt2: + case StructFieldType::Bool2: + case StructFieldType::Float2: + case StructFieldType::Int2: + case StructFieldType::UInt2: return 2 * 4; - case StructFieldType_Bool3: - case StructFieldType_Float3: - case StructFieldType_Int3: - case StructFieldType_UInt3: + case StructFieldType::Bool3: + case StructFieldType::Float3: + case StructFieldType::Int3: + case StructFieldType::UInt3: return 3 * 4; - case StructFieldType_Bool4: - case StructFieldType_Float4: - case StructFieldType_Int4: - case StructFieldType_UInt4: + case StructFieldType::Bool4: + case StructFieldType::Float4: + case StructFieldType::Int4: + case StructFieldType::UInt4: return 4 * 4; - case StructFieldType_Double1: + case StructFieldType::Double1: return 8; - case StructFieldType_Double2: + case StructFieldType::Double2: return 2 * 8; - case StructFieldType_Double3: + case StructFieldType::Double3: return 3 * 8; - case StructFieldType_Double4: + case StructFieldType::Double4: return 4 * 8; } diff --git a/include/Nazara/Utility/Font.hpp b/include/Nazara/Utility/Font.hpp index 534afb016..636a7a456 100644 --- a/include/Nazara/Utility/Font.hpp +++ b/include/Nazara/Utility/Font.hpp @@ -11,7 +11,6 @@ #include #include -#include #include #include #include @@ -32,12 +31,10 @@ namespace Nz struct FontGlyph; - using FontConstRef = ObjectRef; using FontLibrary = ObjectLibrary; using FontLoader = ResourceLoader; - using FontRef = ObjectRef; - class NAZARA_UTILITY_API Font : public RefCounted, public Resource + class NAZARA_UTILITY_API Font : public Resource { friend FontLibrary; friend FontLoader; @@ -85,15 +82,13 @@ namespace Nz Font& operator=(Font&&) = delete; static std::shared_ptr GetDefaultAtlas(); - static const FontRef& GetDefault(); + static const std::shared_ptr& GetDefault(); static unsigned int GetDefaultGlyphBorder(); static unsigned int GetDefaultMinimumStepSize(); - static FontRef OpenFromFile(const std::filesystem::path& filePath, const FontParams& params = FontParams()); - static FontRef OpenFromMemory(const void* data, std::size_t size, const FontParams& params = FontParams()); - static FontRef OpenFromStream(Stream& stream, const FontParams& params = FontParams()); - - template static FontRef New(Args&&... args); + static std::shared_ptr OpenFromFile(const std::filesystem::path& filePath, const FontParams& params = FontParams()); + static std::shared_ptr OpenFromMemory(const void* data, std::size_t size, const FontParams& params = FontParams()); + static std::shared_ptr OpenFromStream(Stream& stream, const FontParams& params = FontParams()); static void SetDefaultAtlas(const std::shared_ptr& atlas); static void SetDefaultGlyphBorder(unsigned int borderSize); @@ -154,9 +149,7 @@ namespace Nz unsigned int m_minimumStepSize; static std::shared_ptr s_defaultAtlas; - static FontRef s_defaultFont; - static FontLibrary::LibraryMap s_library; - static FontLoader::LoaderList s_loaders; + static std::shared_ptr s_defaultFont; static unsigned int s_defaultGlyphBorder; static unsigned int s_defaultMinimumStepSize; }; diff --git a/include/Nazara/Utility/Font.inl b/include/Nazara/Utility/Font.inl index eaa4fb9bb..f82e86d7c 100644 --- a/include/Nazara/Utility/Font.inl +++ b/include/Nazara/Utility/Font.inl @@ -2,19 +2,12 @@ // This file is part of the "Nazara Engine - Utility module" // For conditions of distribution and use, see copyright notice in Config.hpp +#include #include #include namespace Nz { - template - FontRef Font::New(Args&&... args) - { - std::unique_ptr object(new Font(std::forward(args)...)); - object->SetPersistent(false); - - return object.release(); - } } #include diff --git a/include/Nazara/Utility/Image.hpp b/include/Nazara/Utility/Image.hpp index 6355dc60f..20b949f58 100644 --- a/include/Nazara/Utility/Image.hpp +++ b/include/Nazara/Utility/Image.hpp @@ -27,7 +27,7 @@ namespace Nz struct NAZARA_UTILITY_API ImageParams : ResourceParameters { // Le format dans lequel l'image doit être chargée (Undefined pour le format le plus proche de l'original) - PixelFormat loadFormat = PixelFormat_Undefined; + PixelFormat loadFormat = PixelFormat::Undefined; // Le nombre de niveaux de mipmaps maximum devant être créé UInt8 levelCount = 0; @@ -37,21 +37,13 @@ namespace Nz class Image; - using ImageConstRef = ObjectRef; using ImageLibrary = ObjectLibrary; using ImageLoader = ResourceLoader; using ImageManager = ResourceManager; - using ImageRef = ObjectRef; using ImageSaver = ResourceSaver; class NAZARA_UTILITY_API Image : public AbstractImage, public Resource { - friend ImageLibrary; - friend ImageLoader; - friend ImageManager; - friend ImageSaver; - friend class Utility; - public: struct SharedImage; @@ -63,7 +55,7 @@ namespace Nz bool Convert(PixelFormat format); - void Copy(const Image* source, const Boxui& srcBox, const Vector3ui& dstPos); + void Copy(const Image& source, const Boxui& srcBox, const Vector3ui& dstPos); bool Create(ImageType type, PixelFormat format, unsigned int width, unsigned int height, unsigned int depth = 1, UInt8 levelCount = 1); void Destroy(); @@ -118,23 +110,21 @@ namespace Nz static UInt8 GetMaxLevel(ImageType type, unsigned int width, unsigned int height, unsigned int depth = 1); // Load - static ImageRef LoadFromFile(const std::filesystem::path& filePath, const ImageParams& params = ImageParams()); - static ImageRef LoadFromMemory(const void* data, std::size_t size, const ImageParams& params = ImageParams()); - static ImageRef LoadFromStream(Stream& stream, const ImageParams& params = ImageParams()); + static std::shared_ptr LoadFromFile(const std::filesystem::path& filePath, const ImageParams& params = ImageParams()); + static std::shared_ptr LoadFromMemory(const void* data, std::size_t size, const ImageParams& params = ImageParams()); + static std::shared_ptr LoadFromStream(Stream& stream, const ImageParams& params = ImageParams()); // LoadArray - static ImageRef LoadArrayFromFile(const std::filesystem::path& filePath, const ImageParams& imageParams = ImageParams(), const Vector2ui& atlasSize = Vector2ui(2, 2)); - static ImageRef LoadArrayFromImage(const Image* image, const Vector2ui& atlasSize = Vector2ui(2, 2)); - static ImageRef LoadArrayFromMemory(const void* data, std::size_t size, const ImageParams& imageParams = ImageParams(), const Vector2ui& atlasSize = Vector2ui(2, 2)); - static ImageRef LoadArrayFromStream(Stream& stream, const ImageParams& imageParams = ImageParams(), const Vector2ui& atlasSize = Vector2ui(2, 2)); + static std::shared_ptr LoadArrayFromFile(const std::filesystem::path& filePath, const ImageParams& imageParams = ImageParams(), const Vector2ui& atlasSize = Vector2ui(2, 2)); + static std::shared_ptr LoadArrayFromImage(const Image& image, const Vector2ui& atlasSize = Vector2ui(2, 2)); + static std::shared_ptr LoadArrayFromMemory(const void* data, std::size_t size, const ImageParams& imageParams = ImageParams(), const Vector2ui& atlasSize = Vector2ui(2, 2)); + static std::shared_ptr LoadArrayFromStream(Stream& stream, const ImageParams& imageParams = ImageParams(), const Vector2ui& atlasSize = Vector2ui(2, 2)); // LoadCubemap - static ImageRef LoadCubemapFromFile(const std::filesystem::path& filePath, const ImageParams& imageParams = ImageParams(), const CubemapParams& cubemapParams = CubemapParams()); - static ImageRef LoadCubemapFromImage(const Image* image, const CubemapParams& params = CubemapParams()); - static ImageRef LoadCubemapFromMemory(const void* data, std::size_t size, const ImageParams& imageParams = ImageParams(), const CubemapParams& cubemapParams = CubemapParams()); - static ImageRef LoadCubemapFromStream(Stream& stream, const ImageParams& imageParams = ImageParams(), const CubemapParams& cubemapParams = CubemapParams()); - - template static ImageRef New(Args&&... args); + static std::shared_ptr LoadCubemapFromFile(const std::filesystem::path& filePath, const ImageParams& imageParams = ImageParams(), const CubemapParams& cubemapParams = CubemapParams()); + static std::shared_ptr LoadCubemapFromImage(const Image& image, const CubemapParams& params = CubemapParams()); + static std::shared_ptr LoadCubemapFromMemory(const void* data, std::size_t size, const ImageParams& imageParams = ImageParams(), const CubemapParams& cubemapParams = CubemapParams()); + static std::shared_ptr LoadCubemapFromStream(Stream& stream, const ImageParams& imageParams = ImageParams(), const CubemapParams& cubemapParams = CubemapParams()); struct SharedImage { @@ -163,24 +153,11 @@ namespace Nz static SharedImage emptyImage; - // Signals: - NazaraSignal(OnImageDestroy, const Image* /*image*/); - NazaraSignal(OnImageRelease, const Image* /*image*/); - private: void EnsureOwnership(); void ReleaseImage(); - static bool Initialize(); - static void Uninitialize(); - SharedImage* m_sharedImage; - - static ImageLibrary::LibraryMap s_library; - static ImageLoader::LoaderList s_loaders; - static ImageManager::ManagerMap s_managerMap; - static ImageManager::ManagerParams s_managerParameters; - static ImageSaver::SaverList s_savers; }; } diff --git a/include/Nazara/Utility/Image.inl b/include/Nazara/Utility/Image.inl index 4fd41adf1..e94a81f3d 100644 --- a/include/Nazara/Utility/Image.inl +++ b/include/Nazara/Utility/Image.inl @@ -2,19 +2,12 @@ // This file is part of the "Nazara Engine - Utility module" // For conditions of distribution and use, see copyright notice in Config.hpp +#include #include #include namespace Nz { - template - ImageRef Image::New(Args&&... args) - { - std::unique_ptr object(new Image(std::forward(args)...)); - object->SetPersistent(false); - - return object.release(); - } } #include diff --git a/include/Nazara/Utility/IndexBuffer.hpp b/include/Nazara/Utility/IndexBuffer.hpp index 3a908788d..10f46f324 100644 --- a/include/Nazara/Utility/IndexBuffer.hpp +++ b/include/Nazara/Utility/IndexBuffer.hpp @@ -8,34 +8,27 @@ #define NAZARA_INDEXBUFFER_HPP #include -#include -#include #include namespace Nz { - class IndexBuffer; - - using IndexBufferConstRef = ObjectRef; - using IndexBufferRef = ObjectRef; - - class NAZARA_UTILITY_API IndexBuffer : public RefCounted + class NAZARA_UTILITY_API IndexBuffer { public: IndexBuffer() = default; - IndexBuffer(bool largeIndices, BufferRef buffer); - IndexBuffer(bool largeIndices, BufferRef buffer, std::size_t offset, std::size_t size); + IndexBuffer(bool largeIndices, std::shared_ptr buffer); + IndexBuffer(bool largeIndices, std::shared_ptr buffer, std::size_t offset, std::size_t size); IndexBuffer(bool largeIndices, std::size_t length, DataStorage storage, BufferUsageFlags usage); - IndexBuffer(const IndexBuffer& indexBuffer); - IndexBuffer(IndexBuffer&&) = delete; - ~IndexBuffer(); + IndexBuffer(const IndexBuffer&) = default; + IndexBuffer(IndexBuffer&&) noexcept = default; + ~IndexBuffer() = default; unsigned int ComputeCacheMissCount() const; bool Fill(const void* data, std::size_t startIndex, std::size_t length); bool FillRaw(const void* data, std::size_t offset, std::size_t size); - inline const BufferRef& GetBuffer() const; + inline const std::shared_ptr& GetBuffer() const; inline std::size_t GetEndOffset() const; inline std::size_t GetIndexCount() const; inline std::size_t GetStride() const; @@ -53,23 +46,18 @@ namespace Nz void Optimize(); void Reset(); - void Reset(bool largeIndices, BufferRef buffer); - void Reset(bool largeIndices, BufferRef buffer, std::size_t offset, std::size_t size); + void Reset(bool largeIndices, std::shared_ptr buffer); + void Reset(bool largeIndices, std::shared_ptr buffer, std::size_t offset, std::size_t size); void Reset(bool largeIndices, std::size_t length, DataStorage storage, BufferUsageFlags usage); void Reset(const IndexBuffer& indexBuffer); void Unmap() const; - IndexBuffer& operator=(const IndexBuffer& indexBuffer); - IndexBuffer& operator=(IndexBuffer&&) = delete; - - template static IndexBufferRef New(Args&&... args); - - // Signals: - NazaraSignal(OnIndexBufferRelease, const IndexBuffer* /*indexBuffer*/); + IndexBuffer& operator=(const IndexBuffer&) = default; + IndexBuffer& operator=(IndexBuffer&&) noexcept = default; private: - BufferRef m_buffer; + std::shared_ptr m_buffer; std::size_t m_endOffset; std::size_t m_indexCount; std::size_t m_startOffset; diff --git a/include/Nazara/Utility/IndexBuffer.inl b/include/Nazara/Utility/IndexBuffer.inl index ebd6798e8..a306a77bd 100644 --- a/include/Nazara/Utility/IndexBuffer.inl +++ b/include/Nazara/Utility/IndexBuffer.inl @@ -7,7 +7,7 @@ namespace Nz { - inline const BufferRef& IndexBuffer::GetBuffer() const + inline const std::shared_ptr& IndexBuffer::GetBuffer() const { return m_buffer; } @@ -39,7 +39,7 @@ namespace Nz inline bool IndexBuffer::IsValid() const { - return m_buffer.IsValid(); + return m_buffer != nullptr; } inline void* IndexBuffer::Map(BufferAccess access, std::size_t startIndex, std::size_t length) @@ -53,15 +53,6 @@ namespace Nz std::size_t stride = GetStride(); return MapRaw(access, startIndex*stride, length*stride); } - - template - IndexBufferRef IndexBuffer::New(Args&&... args) - { - std::unique_ptr object(new IndexBuffer(std::forward(args)...)); - object->SetPersistent(false); - - return object.release(); - } } #include diff --git a/include/Nazara/Utility/IndexMapper.hpp b/include/Nazara/Utility/IndexMapper.hpp index f7fbd30f7..be3b1d1f2 100644 --- a/include/Nazara/Utility/IndexMapper.hpp +++ b/include/Nazara/Utility/IndexMapper.hpp @@ -19,10 +19,10 @@ namespace Nz class NAZARA_UTILITY_API IndexMapper { public: - IndexMapper(IndexBuffer* indexBuffer, BufferAccess access = BufferAccess_ReadWrite, std::size_t indexCount = 0); - IndexMapper(SubMesh* subMesh, BufferAccess access = BufferAccess_ReadWrite); - IndexMapper(const IndexBuffer* indexBuffer, BufferAccess access = BufferAccess_ReadOnly, std::size_t indexCount = 0); - IndexMapper(const SubMesh* subMesh, BufferAccess access = BufferAccess_ReadOnly); + IndexMapper(IndexBuffer& indexBuffer, BufferAccess access = BufferAccess::ReadWrite, std::size_t indexCount = 0); + IndexMapper(SubMesh& subMesh, BufferAccess access = BufferAccess::ReadWrite); + IndexMapper(const IndexBuffer& indexBuffer, BufferAccess access = BufferAccess::ReadOnly, std::size_t indexCount = 0); + IndexMapper(const SubMesh& subMesh, BufferAccess access = BufferAccess::ReadOnly); ~IndexMapper() = default; UInt32 Get(std::size_t i) const; diff --git a/include/Nazara/Utility/Mesh.hpp b/include/Nazara/Utility/Mesh.hpp index 0cc867624..587fd38ee 100644 --- a/include/Nazara/Utility/Mesh.hpp +++ b/include/Nazara/Utility/Mesh.hpp @@ -9,8 +9,6 @@ #include #include -#include -#include #include #include #include @@ -35,7 +33,7 @@ namespace Nz BufferUsageFlags indexBufferFlags = 0; ///< Buffer usage flags used to build the index buffers BufferUsageFlags vertexBufferFlags = 0; ///< Buffer usage flags used to build the vertex buffers Matrix4f matrix = Matrix4f::Identity(); ///< A matrix which will transform every vertex position - DataStorage storage = DataStorage_Hardware; ///< The place where the buffers will be allocated + DataStorage storage = DataStorage::Hardware; ///< The place where the buffers will be allocated Vector2f texCoordOffset = {0.f, 0.f}; ///< Offset to apply on the texture coordinates (not scaled) Vector2f texCoordScale = {1.f, 1.f}; ///< Scale to apply on the texture coordinates bool animated = true; ///< If true, will load an animated version of the model if possible @@ -51,7 +49,7 @@ namespace Nz * If the declaration has a Vector3f Normals component enabled, Normals are generated. * If the declaration has a Vector3f Tangents component enabled, Tangents are generated. */ - VertexDeclaration* vertexDeclaration = VertexDeclaration::Get(VertexLayout_XYZ_Normal_UV_Tangent); + std::shared_ptr vertexDeclaration = VertexDeclaration::Get(VertexLayout::XYZ_Normal_UV_Tangent); bool IsValid() const; }; @@ -64,33 +62,25 @@ namespace Nz using MeshVertex = VertexStruct_XYZ_Normal_UV_Tangent; using SkeletalMeshVertex = VertexStruct_XYZ_Normal_UV_Tangent_Skinning; - using MeshConstRef = ObjectRef; using MeshLibrary = ObjectLibrary; using MeshLoader = ResourceLoader; using MeshManager = ResourceManager; - using MeshRef = ObjectRef; using MeshSaver = ResourceSaver; struct MeshImpl; - class NAZARA_UTILITY_API Mesh : public RefCounted, public Resource + class NAZARA_UTILITY_API Mesh : public Resource { - friend MeshLibrary; - friend MeshLoader; - friend MeshManager; - friend MeshSaver; - friend class Utility; - public: inline Mesh(); Mesh(const Mesh&) = delete; Mesh(Mesh&&) = delete; - inline ~Mesh(); + ~Mesh() = default; - void AddSubMesh(SubMesh* subMesh); - void AddSubMesh(const std::string& identifier, SubMesh* subMesh); + void AddSubMesh(std::shared_ptr subMesh); + void AddSubMesh(const std::string& identifier, std::shared_ptr subMesh); - SubMesh* BuildSubMesh(const Primitive& primitive, const MeshParams& params = MeshParams()); + std::shared_ptr BuildSubMesh(const Primitive& primitive, const MeshParams& params = MeshParams()); void BuildSubMeshes(const PrimitiveList& list, const MeshParams& params = MeshParams()); bool CreateSkeletal(std::size_t jointCount); @@ -110,10 +100,8 @@ namespace Nz std::size_t GetMaterialCount() const; Skeleton* GetSkeleton(); const Skeleton* GetSkeleton() const; - SubMesh* GetSubMesh(const std::string& identifier); - SubMesh* GetSubMesh(std::size_t index); - const SubMesh* GetSubMesh(const std::string& identifier) const; - const SubMesh* GetSubMesh(std::size_t index) const; + const std::shared_ptr& GetSubMesh(const std::string& identifier) const; + const std::shared_ptr& GetSubMesh(std::size_t index) const; std::size_t GetSubMeshCount() const; std::size_t GetSubMeshIndex(const std::string& identifier) const; std::size_t GetTriangleCount() const; @@ -144,25 +132,22 @@ namespace Nz Mesh& operator=(const Mesh&) = delete; Mesh& operator=(Mesh&&) = delete; - static MeshRef LoadFromFile(const std::filesystem::path& filePath, const MeshParams& params = MeshParams()); - static MeshRef LoadFromMemory(const void* data, std::size_t size, const MeshParams& params = MeshParams()); - static MeshRef LoadFromStream(Stream& stream, const MeshParams& params = MeshParams()); - - template static MeshRef New(Args&&... args); + static std::shared_ptr LoadFromFile(const std::filesystem::path& filePath, const MeshParams& params = MeshParams()); + static std::shared_ptr LoadFromMemory(const void* data, std::size_t size, const MeshParams& params = MeshParams()); + static std::shared_ptr LoadFromStream(Stream& stream, const MeshParams& params = MeshParams()); // Signals: - NazaraSignal(OnMeshDestroy, const Mesh* /*mesh*/); NazaraSignal(OnMeshInvalidateAABB, const Mesh* /*mesh*/); - NazaraSignal(OnMeshRelease, const Mesh* /*mesh*/); private: struct SubMeshData { - SubMeshRef subMesh; + std::shared_ptr subMesh; NazaraSlot(SubMesh, OnSubMeshInvalidateAABB, onSubMeshInvalidated); }; + std::size_t m_jointCount; // Only used by skeletal meshes std::unordered_map m_subMeshMap; std::vector m_materialData; std::vector m_subMeshes; @@ -172,16 +157,6 @@ namespace Nz std::filesystem::path m_animationPath; mutable bool m_aabbUpdated; bool m_isValid; - std::size_t m_jointCount; // Only used by skeletal meshes - - static bool Initialize(); - static void Uninitialize(); - - static MeshLibrary::LibraryMap s_library; - static MeshLoader::LoaderList s_loaders; - static MeshManager::ManagerMap s_managerMap; - static MeshManager::ManagerParams s_managerParameters; - static MeshSaver::SaverList s_savers; }; } diff --git a/include/Nazara/Utility/Mesh.inl b/include/Nazara/Utility/Mesh.inl index 71af75f0d..0681e0850 100644 --- a/include/Nazara/Utility/Mesh.inl +++ b/include/Nazara/Utility/Mesh.inl @@ -14,22 +14,6 @@ namespace Nz m_isValid(false) { } - - Mesh::~Mesh() - { - OnMeshRelease(this); - - Destroy(); - } - - template - MeshRef Mesh::New(Args&&... args) - { - std::unique_ptr object(new Mesh(std::forward(args)...)); - object->SetPersistent(false); - - return object.release(); - } } #include diff --git a/include/Nazara/Utility/PixelFormat.hpp b/include/Nazara/Utility/PixelFormat.hpp index 52b51da28..bf7e138eb 100644 --- a/include/Nazara/Utility/PixelFormat.hpp +++ b/include/Nazara/Utility/PixelFormat.hpp @@ -87,9 +87,9 @@ namespace Nz static bool Initialize(); static void Uninitialize(); - static PixelFormatDescription s_pixelFormatInfos[PixelFormat_Max + 1]; - static ConvertFunction s_convertFunctions[PixelFormat_Max+1][PixelFormat_Max+1]; - static std::map s_flipFunctions[PixelFlipping_Max+1]; + static PixelFormatDescription s_pixelFormatInfos[PixelFormatCount]; + static ConvertFunction s_convertFunctions[PixelFormatCount][PixelFormatCount]; + static std::map s_flipFunctions[PixelFlippingCount]; }; } diff --git a/include/Nazara/Utility/PixelFormat.inl b/include/Nazara/Utility/PixelFormat.inl index e9b30f0ec..86f5b3435 100644 --- a/include/Nazara/Utility/PixelFormat.inl +++ b/include/Nazara/Utility/PixelFormat.inl @@ -2,7 +2,9 @@ // This file is part of the "Nazara Engine - Utility module" // For conditions of distribution and use, see copyright notice in Config.hpp +#include #include +#include #include #include #include @@ -10,7 +12,7 @@ namespace Nz { inline PixelFormatDescription::PixelFormatDescription() : - content(PixelFormatContent_Undefined), + content(PixelFormatContent::Undefined), bitsPerPixel(0) { } @@ -74,10 +76,10 @@ namespace Nz inline bool PixelFormatDescription::IsCompressed() const { - return redType == PixelFormatSubType_Compressed || - greenType == PixelFormatSubType_Compressed || - blueType == PixelFormatSubType_Compressed || - alphaType == PixelFormatSubType_Compressed; + return redType == PixelFormatSubType::Compressed || + greenType == PixelFormatSubType::Compressed || + blueType == PixelFormatSubType::Compressed || + alphaType == PixelFormatSubType::Compressed; } inline bool PixelFormatDescription::IsValid() const @@ -101,7 +103,7 @@ namespace Nz if (!IsValid()) return false; - if (content <= PixelFormatContent_Undefined || content > PixelFormatContent_Max) + if (content <= PixelFormatContent::Undefined || content > PixelFormatContent::Max) return false; std::array*, 4> masks = { {&redMask, &greenMask, &blueMask, &alphaMask} }; @@ -121,13 +123,13 @@ namespace Nz switch (types[i]) { - case PixelFormatSubType_Half: + case PixelFormatSubType::Half: if (usedBits != 16) return false; break; - case PixelFormatSubType_Float: + case PixelFormatSubType::Float: if (usedBits != 32) return false; @@ -149,10 +151,10 @@ namespace Nz { switch (format) { - case PixelFormat_DXT1: - case PixelFormat_DXT3: - case PixelFormat_DXT5: - return (((width + 3) / 4) * ((height + 3) / 4) * ((format == PixelFormat_DXT1) ? 8 : 16)) * depth; + case PixelFormat::DXT1: + case PixelFormat::DXT3: + case PixelFormat::DXT5: + return (((width + 3) / 4) * ((height + 3) / 4) * ((format == PixelFormat::DXT1) ? 8 : 16)) * depth; default: NazaraError("Unsupported format"); @@ -196,7 +198,7 @@ namespace Nz return true; } - ConvertFunction func = s_convertFunctions[srcFormat][dstFormat]; + ConvertFunction func = s_convertFunctions[UnderlyingCast(srcFormat)][UnderlyingCast(dstFormat)]; if (!func) { NazaraError("Pixel format conversion from " + GetName(srcFormat) + " to " + GetName(dstFormat) + " is not supported"); @@ -214,7 +216,7 @@ namespace Nz inline UInt8 PixelFormatInfo::GetBitsPerPixel(PixelFormat format) { - return s_pixelFormatInfos[format].bitsPerPixel; + return s_pixelFormatInfos[UnderlyingCast(format)].bitsPerPixel; } inline UInt8 PixelFormatInfo::GetBytesPerPixel(PixelFormat format) @@ -224,27 +226,27 @@ namespace Nz inline PixelFormatContent PixelFormatInfo::GetContent(PixelFormat format) { - return s_pixelFormatInfos[format].content; + return s_pixelFormatInfos[UnderlyingCast(format)].content; } inline const PixelFormatDescription& PixelFormatInfo::GetInfo(PixelFormat format) { - return s_pixelFormatInfos[format]; + return s_pixelFormatInfos[UnderlyingCast(format)]; } inline const std::string& PixelFormatInfo::GetName(PixelFormat format) { - return s_pixelFormatInfos[format].name; + return s_pixelFormatInfos[UnderlyingCast(format)].name; } inline bool PixelFormatInfo::HasAlpha(PixelFormat format) { - return s_pixelFormatInfos[format].alphaMask.TestAny(); + return s_pixelFormatInfos[UnderlyingCast(format)].alphaMask.TestAny(); } inline bool PixelFormatInfo::IsCompressed(PixelFormat format) { - return s_pixelFormatInfos[format].IsCompressed(); + return s_pixelFormatInfos[UnderlyingCast(format)].IsCompressed(); } inline bool PixelFormatInfo::IsConversionSupported(PixelFormat srcFormat, PixelFormat dstFormat) @@ -252,22 +254,22 @@ namespace Nz if (srcFormat == dstFormat) return true; - return s_convertFunctions[srcFormat][dstFormat] != nullptr; + return s_convertFunctions[UnderlyingCast(srcFormat)][UnderlyingCast(dstFormat)] != nullptr; } inline bool PixelFormatInfo::IsValid(PixelFormat format) { - return format != PixelFormat_Undefined; + return format != PixelFormat::Undefined; } inline void PixelFormatInfo::SetConvertFunction(PixelFormat srcFormat, PixelFormat dstFormat, ConvertFunction func) { - s_convertFunctions[srcFormat][dstFormat] = func; + s_convertFunctions[UnderlyingCast(srcFormat)][UnderlyingCast(dstFormat)] = func; } inline void PixelFormatInfo::SetFlipFunction(PixelFlipping flipping, PixelFormat format, FlipFunction func) { - s_flipFunctions[flipping][format] = func; + s_flipFunctions[UnderlyingCast(flipping)][format] = func; } } diff --git a/include/Nazara/Utility/RichTextDrawer.hpp b/include/Nazara/Utility/RichTextDrawer.hpp index 44cb55695..f3a3dbefd 100644 --- a/include/Nazara/Utility/RichTextDrawer.hpp +++ b/include/Nazara/Utility/RichTextDrawer.hpp @@ -37,7 +37,7 @@ namespace Nz inline const Color& GetBlockColor(std::size_t index) const; inline std::size_t GetBlockCount() const; inline std::size_t GetBlockFirstGlyphIndex(std::size_t index) const; - inline const FontRef& GetBlockFont(std::size_t index) const; + inline const std::shared_ptr& GetBlockFont(std::size_t index) const; inline float GetBlockLineHeight(std::size_t index) const; inline float GetBlockLineSpacingOffset(std::size_t index) const; inline const Color& GetBlockOutlineColor(std::size_t index) const; @@ -50,12 +50,12 @@ namespace Nz inline unsigned int GetDefaultCharacterSize() const; inline float GetDefaultCharacterSpacingOffset() const; inline const Color& GetDefaultColor() const; - inline const FontRef& GetDefaultFont() const; + inline const std::shared_ptr& GetDefaultFont() const; inline float GetDefaultLineSpacingOffset() const; inline const Color& GetDefaultOutlineColor() const; inline float GetDefaultOutlineThickness() const; inline TextStyleFlags GetDefaultStyle() const; - Font* GetFont(std::size_t index) const override; + const std::shared_ptr& GetFont(std::size_t index) const override; std::size_t GetFontCount() const override; const Glyph& GetGlyph(std::size_t index) const override; std::size_t GetGlyphCount() const override; @@ -72,7 +72,7 @@ namespace Nz inline void SetBlockCharacterSize(std::size_t index, unsigned int characterSize); inline void SetBlockCharacterSpacingOffset(std::size_t index, float offset); inline void SetBlockColor(std::size_t index, const Color& color); - inline void SetBlockFont(std::size_t index, FontRef font); + inline void SetBlockFont(std::size_t index, std::shared_ptr font); inline void SetBlockLineSpacingOffset(std::size_t index, float offset); inline void SetBlockOutlineColor(std::size_t index, const Color& color); inline void SetBlockOutlineThickness(std::size_t index, float thickness); @@ -82,7 +82,7 @@ namespace Nz inline void SetDefaultCharacterSize(unsigned int characterSize); inline void SetDefaultCharacterSpacingOffset(float offset); inline void SetDefaultColor(const Color& color); - inline void SetDefaultFont(const FontRef& font); + inline void SetDefaultFont(const std::shared_ptr& font); inline void SetDefaultLineSpacingOffset(float offset); inline void SetDefaultOutlineColor(const Color& color); inline void SetDefaultOutlineThickness(float thickness); @@ -98,16 +98,16 @@ namespace Nz private: struct Block; - inline void AppendNewLine(const Font* font, unsigned int characterSize, float lineSpacingOffset) const; - void AppendNewLine(const Font* font, unsigned int characterSize, float lineSpacingOffset, std::size_t glyphIndex, float glyphPosition) const; + inline void AppendNewLine(const Font& font, unsigned int characterSize, float lineSpacingOffset) const; + void AppendNewLine(const Font& font, unsigned int characterSize, float lineSpacingOffset, std::size_t glyphIndex, float glyphPosition) const; inline void ClearGlyphs() const; inline void ConnectFontSlots(); inline void DisconnectFontSlots(); - bool GenerateGlyph(Glyph& glyph, char32_t character, float outlineThickness, bool lineWrap, const Font* font, const Color& color, TextStyleFlags style, float lineSpacingOffset, unsigned int characterSize, int renderOrder, int* advance) const; - void GenerateGlyphs(const Font* font, const Color& color, TextStyleFlags style, unsigned int characterSize, const Color& outlineColor, float characterSpacingOffset, float lineSpacingOffset, float outlineThickness, const std::string& text) const; + bool GenerateGlyph(Glyph& glyph, char32_t character, float outlineThickness, bool lineWrap, const Font& font, const Color& color, TextStyleFlags style, float lineSpacingOffset, unsigned int characterSize, int renderOrder, int* advance) const; + void GenerateGlyphs(const Font& font, const Color& color, TextStyleFlags style, unsigned int characterSize, const Color& outlineColor, float characterSpacingOffset, float lineSpacingOffset, float outlineThickness, const std::string& text) const; inline float GetLineHeight(const Block& block) const; inline float GetLineHeight(float lineSpacingOffset, const Font::SizeInfo& sizeInfo) const; - inline std::size_t HandleFontAddition(const FontRef& font); + inline std::size_t HandleFontAddition(const std::shared_ptr& font); inline void InvalidateGlyphs(); inline void ReleaseFont(std::size_t fontIndex); inline bool ShouldLineWrap(float size) const; @@ -136,7 +136,7 @@ namespace Nz struct FontData { - FontRef font; + std::shared_ptr font; std::size_t useCount = 0; NazaraSlot(Font, OnFontAtlasChanged, atlasChangedSlot); @@ -148,9 +148,9 @@ namespace Nz Color m_defaultColor; Color m_defaultOutlineColor; TextStyleFlags m_defaultStyle; - FontRef m_defaultFont; + std::shared_ptr m_defaultFont; mutable std::size_t m_lastSeparatorGlyph; - std::unordered_map m_fontIndexes; + std::unordered_map, std::size_t> m_fontIndexes; std::vector m_blocks; std::vector m_fonts; mutable std::vector m_glyphs; @@ -179,7 +179,7 @@ namespace Nz inline unsigned int GetCharacterSize() const; inline Color GetColor() const; inline std::size_t GetFirstGlyphIndex() const; - inline const FontRef& GetFont() const; + inline const std::shared_ptr& GetFont() const; inline float GetLineSpacingOffset() const; inline Color GetOutlineColor() const; inline float GetOutlineThickness() const; @@ -189,7 +189,7 @@ namespace Nz inline void SetCharacterSpacingOffset(float offset); inline void SetCharacterSize(unsigned int size); inline void SetColor(Color color); - inline void SetFont(FontRef font); + inline void SetFont(std::shared_ptr font); inline void SetLineSpacingOffset(float offset); inline void SetOutlineColor(Color color); inline void SetOutlineThickness(float thickness); diff --git a/include/Nazara/Utility/RichTextDrawer.inl b/include/Nazara/Utility/RichTextDrawer.inl index 977565287..622af5717 100644 --- a/include/Nazara/Utility/RichTextDrawer.inl +++ b/include/Nazara/Utility/RichTextDrawer.inl @@ -80,7 +80,7 @@ namespace Nz return m_blocks[index].glyphIndex; } - inline const FontRef& RichTextDrawer::GetBlockFont(std::size_t index) const + inline const std::shared_ptr& RichTextDrawer::GetBlockFont(std::size_t index) const { NazaraAssert(index < m_blocks.size(), "Invalid block index"); std::size_t fontIndex = m_blocks[index].fontIndex; @@ -139,7 +139,7 @@ namespace Nz return m_defaultColor; } - inline const FontRef& RichTextDrawer::GetDefaultFont() const + inline const std::shared_ptr& RichTextDrawer::GetDefaultFont() const { return m_defaultFont; } @@ -164,7 +164,7 @@ namespace Nz return m_defaultStyle; } - inline void RichTextDrawer::AppendNewLine(const Font* font, unsigned int characterSize, float lineSpacingOffset) const + inline void RichTextDrawer::AppendNewLine(const Font& font, unsigned int characterSize, float lineSpacingOffset) const { AppendNewLine(font, characterSize, lineSpacingOffset, InvalidGlyph, 0); } @@ -214,7 +214,7 @@ namespace Nz return float(sizeInfo.lineHeight) + lineSpacingOffset; } - inline std::size_t RichTextDrawer::HandleFontAddition(const FontRef& font) + inline std::size_t RichTextDrawer::HandleFontAddition(const std::shared_ptr& font) { auto it = m_fontIndexes.find(font); if (it == m_fontIndexes.end()) @@ -292,7 +292,7 @@ namespace Nz InvalidateGlyphs(); } - inline void RichTextDrawer::SetBlockFont(std::size_t index, FontRef font) + inline void RichTextDrawer::SetBlockFont(std::size_t index, std::shared_ptr font) { NazaraAssert(index < m_blocks.size(), "Invalid block index"); std::size_t fontIndex = HandleFontAddition(font); @@ -375,7 +375,7 @@ namespace Nz m_defaultColor = color; } - inline void RichTextDrawer::SetDefaultFont(const FontRef& font) + inline void RichTextDrawer::SetDefaultFont(const std::shared_ptr& font) { m_defaultFont = font; } @@ -457,7 +457,7 @@ namespace Nz * * \see GetCharacterSize, GetColor, GetStyle, GetText, SetFont */ - inline const FontRef& RichTextDrawer::BlockRef::GetFont() const + inline const std::shared_ptr& RichTextDrawer::BlockRef::GetFont() const { return m_drawer.GetBlockFont(m_blockIndex); } @@ -567,7 +567,7 @@ namespace Nz * * \see GetCharacterSize, SetCharacterSize, SetColor, SetStyle, SetText */ - inline void RichTextDrawer::BlockRef::SetFont(FontRef font) + inline void RichTextDrawer::BlockRef::SetFont(std::shared_ptr font) { m_drawer.SetBlockFont(m_blockIndex, std::move(font)); } diff --git a/include/Nazara/Utility/SimpleTextDrawer.hpp b/include/Nazara/Utility/SimpleTextDrawer.hpp index d1d1027dc..b0a0fd92b 100644 --- a/include/Nazara/Utility/SimpleTextDrawer.hpp +++ b/include/Nazara/Utility/SimpleTextDrawer.hpp @@ -31,8 +31,8 @@ namespace Nz inline float GetCharacterSpacingOffset() const; inline unsigned int GetCharacterSize() const; inline const Color& GetColor() const; - inline Font* GetFont() const; - Font* GetFont(std::size_t index) const override; + inline const std::shared_ptr& GetFont() const; + const std::shared_ptr& GetFont(std::size_t index) const override; std::size_t GetFontCount() const override; const Glyph& GetGlyph(std::size_t index) const override; std::size_t GetGlyphCount() const override; @@ -49,7 +49,7 @@ namespace Nz inline void SetCharacterSpacingOffset(float offset); inline void SetCharacterSize(unsigned int characterSize); inline void SetColor(const Color& color); - inline void SetFont(Font* font); + inline void SetFont(std::shared_ptr font); inline void SetLineSpacingOffset(float offset); inline void SetMaxLineWidth(float lineWidth) override; inline void SetOutlineColor(const Color& color); @@ -62,8 +62,8 @@ namespace Nz static inline SimpleTextDrawer Draw(const std::string& str, unsigned int characterSize, TextStyleFlags style = TextStyle_Regular, const Color& color = Color::White); static inline SimpleTextDrawer Draw(const std::string& str, unsigned int characterSize, TextStyleFlags style, const Color& color, float outlineThickness, const Color& outlineColor); - static inline SimpleTextDrawer Draw(Font* font, const std::string& str, unsigned int characterSize, TextStyleFlags style = TextStyle_Regular, const Color& color = Color::White); - static inline SimpleTextDrawer Draw(Font* font, const std::string& str, unsigned int characterSize, TextStyleFlags style, const Color& color, float outlineThickness, const Color& outlineColor); + static inline SimpleTextDrawer Draw(const std::shared_ptr& font, const std::string& str, unsigned int characterSize, TextStyleFlags style = TextStyle_Regular, const Color& color = Color::White); + static inline SimpleTextDrawer Draw(const std::shared_ptr& font, const std::string& str, unsigned int characterSize, TextStyleFlags style, const Color& color, float outlineThickness, const Color& outlineColor); private: inline void AppendNewLine() const; @@ -104,7 +104,7 @@ namespace Nz std::string m_text; Color m_color; Color m_outlineColor; - FontRef m_font; + std::shared_ptr m_font; mutable Rectf m_bounds; TextStyleFlags m_style; mutable UInt32 m_previousCharacter; diff --git a/include/Nazara/Utility/SimpleTextDrawer.inl b/include/Nazara/Utility/SimpleTextDrawer.inl index 0bc38edda..24836d42a 100644 --- a/include/Nazara/Utility/SimpleTextDrawer.inl +++ b/include/Nazara/Utility/SimpleTextDrawer.inl @@ -65,7 +65,7 @@ namespace Nz return m_color; } - inline Font* SimpleTextDrawer::GetFont() const + inline const std::shared_ptr& SimpleTextDrawer::GetFont() const { return m_font; } @@ -131,11 +131,11 @@ namespace Nz } } - inline void SimpleTextDrawer::SetFont(Font* font) + inline void SimpleTextDrawer::SetFont(std::shared_ptr font) { if (m_font != font) { - m_font = font; + m_font = std::move(font); if (m_font) ConnectFontSlots(); @@ -281,7 +281,7 @@ namespace Nz return drawer; } - inline SimpleTextDrawer SimpleTextDrawer::Draw(Font* font, const std::string& str, unsigned int characterSize, TextStyleFlags style, const Color& color) + inline SimpleTextDrawer SimpleTextDrawer::Draw(const std::shared_ptr& font, const std::string& str, unsigned int characterSize, TextStyleFlags style, const Color& color) { SimpleTextDrawer drawer; drawer.SetCharacterSize(characterSize); @@ -293,7 +293,7 @@ namespace Nz return drawer; } - inline SimpleTextDrawer SimpleTextDrawer::Draw(Font* font, const std::string& str, unsigned int characterSize, TextStyleFlags style, const Color& color, float outlineThickness, const Color& outlineColor) + inline SimpleTextDrawer SimpleTextDrawer::Draw(const std::shared_ptr& font, const std::string& str, unsigned int characterSize, TextStyleFlags style, const Color& color, float outlineThickness, const Color& outlineColor) { SimpleTextDrawer drawer; drawer.SetCharacterSize(characterSize); diff --git a/include/Nazara/Utility/SkeletalMesh.hpp b/include/Nazara/Utility/SkeletalMesh.hpp index 486403cda..a5c43d60c 100644 --- a/include/Nazara/Utility/SkeletalMesh.hpp +++ b/include/Nazara/Utility/SkeletalMesh.hpp @@ -8,56 +8,34 @@ #define NAZARA_SKELETALMESH_HPP #include -#include -#include #include #include #include namespace Nz { - class SkeletalMesh; - - using SkeletalMeshConstRef = ObjectRef; - using SkeletalMeshRef = ObjectRef; - class NAZARA_UTILITY_API SkeletalMesh final : public SubMesh { public: - SkeletalMesh(VertexBuffer* vertexBuffer, const IndexBuffer* indexBuffer); - - NAZARA_DEPRECATED("SkeletalMesh constructor taking a mesh is deprecated, submeshes no longer require to be part of a single mesh") - SkeletalMesh(const Mesh* parent); - - ~SkeletalMesh(); - - NAZARA_DEPRECATED("SkeletalMesh create/destroy functions are deprecated, please use constructor") - bool Create(VertexBuffer* vertexBuffer); - void Destroy(); + SkeletalMesh(std::shared_ptr vertexBuffer, std::shared_ptr indexBuffer); + ~SkeletalMesh() = default; const Boxf& GetAABB() const override; AnimationType GetAnimationType() const final; - const IndexBuffer* GetIndexBuffer() const override; - VertexBuffer* GetVertexBuffer(); - const VertexBuffer* GetVertexBuffer() const; + const std::shared_ptr& GetIndexBuffer() const override; + const std::shared_ptr& GetVertexBuffer() const; std::size_t GetVertexCount() const override; bool IsAnimated() const final; bool IsValid() const; void SetAABB(const Boxf& aabb); - void SetIndexBuffer(const IndexBuffer* indexBuffer); - - template static SkeletalMeshRef New(Args&&... args); - - // Signals: - NazaraSignal(OnSkeletalMeshDestroy, const SkeletalMesh* /*skeletalMesh*/); - NazaraSignal(OnSkeletalMeshRelease, const SkeletalMesh* /*skeletalMesh*/); + void SetIndexBuffer(std::shared_ptr indexBuffer); private: Boxf m_aabb; - IndexBufferConstRef m_indexBuffer; - VertexBufferRef m_vertexBuffer; + std::shared_ptr m_indexBuffer; + std::shared_ptr m_vertexBuffer; }; } diff --git a/include/Nazara/Utility/SkeletalMesh.inl b/include/Nazara/Utility/SkeletalMesh.inl index d6b071062..c508ab9a1 100644 --- a/include/Nazara/Utility/SkeletalMesh.inl +++ b/include/Nazara/Utility/SkeletalMesh.inl @@ -2,19 +2,12 @@ // This file is part of the "Nazara Engine - Utility module" // For conditions of distribution and use, see copyright notice in Config.hpp +#include #include #include namespace Nz { - template - SkeletalMeshRef SkeletalMesh::New(Args&&... args) - { - std::unique_ptr object(new SkeletalMesh(std::forward(args)...)); - object->SetPersistent(false); - - return object.release(); - } } #include diff --git a/include/Nazara/Utility/Skeleton.hpp b/include/Nazara/Utility/Skeleton.hpp index 535fc9f7d..27fecbbba 100644 --- a/include/Nazara/Utility/Skeleton.hpp +++ b/include/Nazara/Utility/Skeleton.hpp @@ -9,8 +9,6 @@ #include #include -#include -#include #include #include #include @@ -21,21 +19,18 @@ namespace Nz class Joint; class Skeleton; - using SkeletonConstRef = ObjectRef; using SkeletonLibrary = ObjectLibrary; - using SkeletonRef = ObjectRef; struct SkeletonImpl; - class NAZARA_UTILITY_API Skeleton : public RefCounted + class NAZARA_UTILITY_API Skeleton { friend Joint; - friend SkeletonLibrary; - friend class Utility; public: - Skeleton() = default; + Skeleton(); Skeleton(const Skeleton& skeleton); + Skeleton(Skeleton&&) noexcept; ~Skeleton(); bool Create(std::size_t jointCount); @@ -49,33 +44,25 @@ namespace Nz Joint* GetJoints(); const Joint* GetJoints() const; std::size_t GetJointCount() const; - int GetJointIndex(const std::string& jointName) const; + std::size_t GetJointIndex(const std::string& jointName) const; void Interpolate(const Skeleton& skeletonA, const Skeleton& skeletonB, float interpolation); - void Interpolate(const Skeleton& skeletonA, const Skeleton& skeletonB, float interpolation, std::size_t* indices, std::size_t indiceCount); + void Interpolate(const Skeleton& skeletonA, const Skeleton& skeletonB, float interpolation, const std::size_t* indices, std::size_t indiceCount); bool IsValid() const; Skeleton& operator=(const Skeleton& skeleton); - - template static SkeletonRef New(Args&&... args); + Skeleton& operator=(Skeleton&&) noexcept; // Signals: - NazaraSignal(OnSkeletonDestroy, const Skeleton* /*skeleton*/); NazaraSignal(OnSkeletonJointsInvalidated, const Skeleton* /*skeleton*/); - NazaraSignal(OnSkeletonRelease, const Skeleton* /*skeleton*/); private: void InvalidateJoints(); void InvalidateJointMap(); void UpdateJointMap() const; - static bool Initialize(); - static void Uninitialize(); - - SkeletonImpl* m_impl = nullptr; - - static SkeletonLibrary::LibraryMap s_library; + std::unique_ptr m_impl; }; } diff --git a/include/Nazara/Utility/Skeleton.inl b/include/Nazara/Utility/Skeleton.inl index 033cba926..997159e19 100644 --- a/include/Nazara/Utility/Skeleton.inl +++ b/include/Nazara/Utility/Skeleton.inl @@ -7,14 +7,6 @@ namespace Nz { - template - SkeletonRef Skeleton::New(Args&&... args) - { - std::unique_ptr object(new Skeleton(std::forward(args)...)); - object->SetPersistent(false); - - return object.release(); - } } #include diff --git a/include/Nazara/Utility/StaticMesh.hpp b/include/Nazara/Utility/StaticMesh.hpp index 64887e254..4044521f1 100644 --- a/include/Nazara/Utility/StaticMesh.hpp +++ b/include/Nazara/Utility/StaticMesh.hpp @@ -8,57 +8,36 @@ #define NAZARA_STATICMESH_HPP #include -#include #include namespace Nz { - class StaticMesh; - - using StaticMeshConstRef = ObjectRef; - using StaticMeshRef = ObjectRef; - class NAZARA_UTILITY_API StaticMesh final : public SubMesh { public: - StaticMesh(VertexBuffer* vertexBuffer, const IndexBuffer* indexBuffer); - - NAZARA_DEPRECATED("StaticMesh constructor taking a mesh is deprecated, submeshes no longer require to be part of a single mesh") - StaticMesh(const Mesh* parent); - - ~StaticMesh(); + StaticMesh(std::shared_ptr vertexBuffer, std::shared_ptr indexBuffer); + ~StaticMesh() = default; void Center(); - NAZARA_DEPRECATED("StaticMesh create/destroy functions are deprecated, please use constructor") - bool Create(VertexBuffer* vertexBuffer); - void Destroy(); - bool GenerateAABB(); const Boxf& GetAABB() const override; AnimationType GetAnimationType() const final; - const IndexBuffer* GetIndexBuffer() const override; - VertexBuffer* GetVertexBuffer(); - const VertexBuffer* GetVertexBuffer() const; + const std::shared_ptr& GetIndexBuffer() const override; + const std::shared_ptr& GetVertexBuffer() const; std::size_t GetVertexCount() const override; bool IsAnimated() const final; bool IsValid() const; void SetAABB(const Boxf& aabb); - void SetIndexBuffer(const IndexBuffer* indexBuffer); - - template static StaticMeshRef New(Args&&... args); - - // Signals: - NazaraSignal(OnStaticMeshDestroy, const StaticMesh* /*staticMesh*/); - NazaraSignal(OnStaticMeshRelease, const StaticMesh* /*staticMesh*/); + void SetIndexBuffer(std::shared_ptr indexBuffer); private: Boxf m_aabb; - IndexBufferConstRef m_indexBuffer; - VertexBufferRef m_vertexBuffer; + std::shared_ptr m_indexBuffer; + std::shared_ptr m_vertexBuffer; }; } diff --git a/include/Nazara/Utility/StaticMesh.inl b/include/Nazara/Utility/StaticMesh.inl index d25367dcb..997159e19 100644 --- a/include/Nazara/Utility/StaticMesh.inl +++ b/include/Nazara/Utility/StaticMesh.inl @@ -7,14 +7,6 @@ namespace Nz { - template - StaticMeshRef StaticMesh::New(Args&&... args) - { - std::unique_ptr object(new StaticMesh(std::forward(args)...)); - object->SetPersistent(false); - - return object.release(); - } } #include diff --git a/include/Nazara/Utility/SubMesh.hpp b/include/Nazara/Utility/SubMesh.hpp index 8feb14f15..b1d4e709b 100644 --- a/include/Nazara/Utility/SubMesh.hpp +++ b/include/Nazara/Utility/SubMesh.hpp @@ -8,8 +8,7 @@ #define NAZARA_SUBMESH_HPP #include -#include -#include +#include #include #include #include @@ -18,21 +17,13 @@ namespace Nz { class Mesh; - class SubMesh; - using SubMeshConstRef = ObjectRef; - using SubMeshRef = ObjectRef; - - class NAZARA_UTILITY_API SubMesh : public RefCounted + class NAZARA_UTILITY_API SubMesh { friend Mesh; public: SubMesh(); - - NAZARA_DEPRECATED("Submesh constructor taking a mesh is deprecated, submeshes no longer require to be part of a single mesh") - SubMesh(const Mesh* parent); - SubMesh(const SubMesh&) = delete; SubMesh(SubMesh&&) = delete; virtual ~SubMesh(); @@ -43,7 +34,7 @@ namespace Nz virtual const Boxf& GetAABB() const = 0; virtual AnimationType GetAnimationType() const = 0; - virtual const IndexBuffer* GetIndexBuffer() const = 0; + virtual const std::shared_ptr& GetIndexBuffer() const = 0; std::size_t GetMaterialIndex() const; PrimitiveMode GetPrimitiveMode() const; std::size_t GetTriangleCount() const; @@ -59,7 +50,6 @@ namespace Nz // Signals: NazaraSignal(OnSubMeshInvalidateAABB, const SubMesh* /*subMesh*/); - NazaraSignal(OnSubMeshRelease, const SubMesh* /*subMesh*/); protected: PrimitiveMode m_primitiveMode; diff --git a/include/Nazara/Utility/TriangleIterator.hpp b/include/Nazara/Utility/TriangleIterator.hpp index b33b1b386..43f310264 100644 --- a/include/Nazara/Utility/TriangleIterator.hpp +++ b/include/Nazara/Utility/TriangleIterator.hpp @@ -18,8 +18,8 @@ namespace Nz class NAZARA_UTILITY_API TriangleIterator { public: - TriangleIterator(PrimitiveMode primitiveMode, const IndexBuffer* indexBuffer); - TriangleIterator(const SubMesh* subMesh); + TriangleIterator(PrimitiveMode primitiveMode, const IndexBuffer& indexBuffer); + TriangleIterator(const SubMesh& subMesh); ~TriangleIterator() = default; bool Advance(); diff --git a/include/Nazara/Utility/UniformBuffer.hpp b/include/Nazara/Utility/UniformBuffer.hpp index cf16bc118..faaa2e482 100644 --- a/include/Nazara/Utility/UniformBuffer.hpp +++ b/include/Nazara/Utility/UniformBuffer.hpp @@ -8,31 +8,24 @@ #define NAZARA_UNIFORMBUFFER_HPP #include -#include -#include #include namespace Nz { - class UniformBuffer; - - using UniformBufferConstRef = ObjectRef; - using UniformBufferRef = ObjectRef; - - class NAZARA_UTILITY_API UniformBuffer : public RefCounted + class NAZARA_UTILITY_API UniformBuffer { public: UniformBuffer() = default; - UniformBuffer(BufferRef buffer); - UniformBuffer(BufferRef buffer, UInt32 offset, UInt32 size); + UniformBuffer(std::shared_ptr buffer); + UniformBuffer(std::shared_ptr buffer, UInt32 offset, UInt32 size); UniformBuffer(UInt32 length, DataStorage storage, BufferUsageFlags usage); - UniformBuffer(const UniformBuffer& uniformBuffer); - UniformBuffer(UniformBuffer&&) = delete; - ~UniformBuffer(); + UniformBuffer(const UniformBuffer&) = default; + UniformBuffer(UniformBuffer&&) noexcept = default; + ~UniformBuffer() = default; bool Fill(const void* data, UInt32 offset, UInt32 size); - inline const BufferRef& GetBuffer() const; + inline const std::shared_ptr& GetBuffer() const; inline UInt32 GetEndOffset() const; inline UInt32 GetStartOffset() const; @@ -42,23 +35,18 @@ namespace Nz void* Map(BufferAccess access, UInt32 offset = 0, UInt32 size = 0) const; void Reset(); - void Reset(BufferRef buffer); - void Reset(BufferRef buffer, UInt32 offset, UInt32 size); + void Reset(std::shared_ptr buffer); + void Reset(std::shared_ptr buffer, UInt32 offset, UInt32 size); void Reset(UInt32 size, DataStorage storage, BufferUsageFlags usage); void Reset(const UniformBuffer& uniformBuffer); void Unmap() const; - UniformBuffer& operator=(const UniformBuffer& uniformBuffer); - UniformBuffer& operator=(UniformBuffer&&) = delete; - - template static UniformBufferRef New(Args&&... args); - - // Signals: - NazaraSignal(OnUniformBufferRelease, const UniformBuffer* /*UniformBuffer*/); + UniformBuffer& operator=(const UniformBuffer&) = default; + UniformBuffer& operator=(UniformBuffer&&) noexcept = default; private: - BufferRef m_buffer; + std::shared_ptr m_buffer; UInt32 m_endOffset; UInt32 m_startOffset; }; diff --git a/include/Nazara/Utility/UniformBuffer.inl b/include/Nazara/Utility/UniformBuffer.inl index 958f0131a..e8f912507 100644 --- a/include/Nazara/Utility/UniformBuffer.inl +++ b/include/Nazara/Utility/UniformBuffer.inl @@ -8,7 +8,7 @@ namespace Nz { - inline const BufferRef& UniformBuffer::GetBuffer() const + inline const std::shared_ptr& UniformBuffer::GetBuffer() const { return m_buffer; } @@ -25,16 +25,7 @@ namespace Nz inline bool UniformBuffer::IsValid() const { - return m_buffer.IsValid(); - } - - template - UniformBufferRef UniformBuffer::New(Args&&... args) - { - std::unique_ptr object(new UniformBuffer(std::forward(args)...)); - object->SetPersistent(false); - - return object.release(); + return m_buffer != nullptr; } } diff --git a/include/Nazara/Utility/Utility.hpp b/include/Nazara/Utility/Utility.hpp index 9c2ebb2b4..049a23e5a 100644 --- a/include/Nazara/Utility/Utility.hpp +++ b/include/Nazara/Utility/Utility.hpp @@ -9,7 +9,11 @@ #include #include +#include #include +#include +#include +#include namespace Nz { @@ -23,9 +27,34 @@ namespace Nz struct Config {}; Utility(Config /*config*/); + Utility(const Utility&) = delete; + Utility(Utility&&) = delete; ~Utility(); + AnimationLoader& GetAnimationLoader(); + const AnimationLoader& GetAnimationLoader() const; + FontLoader& GetFontLoader(); + const FontLoader& GetFontLoader() const; + ImageLoader& GetImageLoader(); + const ImageLoader& GetImageLoader() const; + ImageSaver& GetImageSaver(); + const ImageSaver& GetImageSaver() const; + MeshLoader& GetMeshLoader(); + const MeshLoader& GetMeshLoader() const; + MeshSaver& GetMeshSaver(); + const MeshSaver& GetMeshSaver() const; + + Utility& operator=(const Utility&) = delete; + Utility& operator=(Utility&&) = delete; + private: + AnimationLoader m_animationLoader; + FontLoader m_fontLoader; + ImageLoader m_imageLoader; + ImageSaver m_imageSaver; + MeshLoader m_meshLoader; + MeshSaver m_meshSaver; + static Utility* s_instance; }; } diff --git a/include/Nazara/Utility/VertexBuffer.hpp b/include/Nazara/Utility/VertexBuffer.hpp index 82c83399d..237e0bc6b 100644 --- a/include/Nazara/Utility/VertexBuffer.hpp +++ b/include/Nazara/Utility/VertexBuffer.hpp @@ -8,39 +8,31 @@ #define NAZARA_VERTEXBUFFER_HPP #include -#include -#include -#include #include #include namespace Nz { - class VertexBuffer; - - using VertexBufferConstRef = ObjectRef; - using VertexBufferRef = ObjectRef; - - class NAZARA_UTILITY_API VertexBuffer : public RefCounted + class NAZARA_UTILITY_API VertexBuffer { public: VertexBuffer() = default; - VertexBuffer(VertexDeclarationConstRef vertexDeclaration, BufferRef buffer); - VertexBuffer(VertexDeclarationConstRef vertexDeclaration, BufferRef buffer, std::size_t offset, std::size_t size); - VertexBuffer(VertexDeclarationConstRef vertexDeclaration, std::size_t length, DataStorage storage, BufferUsageFlags usage); - VertexBuffer(const VertexBuffer& vertexBuffer); - VertexBuffer(VertexBuffer&&) = delete; - ~VertexBuffer(); + VertexBuffer(std::shared_ptr vertexDeclaration, std::shared_ptr buffer); + VertexBuffer(std::shared_ptr vertexDeclaration, std::shared_ptr buffer, std::size_t offset, std::size_t size); + VertexBuffer(std::shared_ptr vertexDeclaration, std::size_t length, DataStorage storage, BufferUsageFlags usage); + VertexBuffer(const VertexBuffer&) = default; + VertexBuffer(VertexBuffer&&) noexcept = default; + ~VertexBuffer() = default; bool Fill(const void* data, std::size_t startVertex, std::size_t length); bool FillRaw(const void* data, std::size_t offset, std::size_t size); - inline const BufferRef& GetBuffer() const; + inline const std::shared_ptr& GetBuffer() const; inline std::size_t GetEndOffset() const; inline std::size_t GetStartOffset() const; inline std::size_t GetStride() const; inline std::size_t GetVertexCount() const; - inline const VertexDeclarationConstRef& GetVertexDeclaration() const; + inline const std::shared_ptr& GetVertexDeclaration() const; inline bool IsValid() const; @@ -50,29 +42,24 @@ namespace Nz void* MapRaw(BufferAccess access, std::size_t offset = 0, std::size_t size = 0) const; void Reset(); - void Reset(VertexDeclarationConstRef vertexDeclaration, BufferRef buffer); - void Reset(VertexDeclarationConstRef vertexDeclaration, BufferRef buffer, std::size_t offset, std::size_t size); - void Reset(VertexDeclarationConstRef vertexDeclaration, std::size_t length, DataStorage storage, BufferUsageFlags usage); + void Reset(std::shared_ptr vertexDeclaration, std::shared_ptr buffer); + void Reset(std::shared_ptr vertexDeclaration, std::shared_ptr buffer, std::size_t offset, std::size_t size); + void Reset(std::shared_ptr vertexDeclaration, std::size_t length, DataStorage storage, BufferUsageFlags usage); void Reset(const VertexBuffer& vertexBuffer); - void SetVertexDeclaration(VertexDeclarationConstRef vertexDeclaration); + void SetVertexDeclaration(std::shared_ptr vertexDeclaration); void Unmap() const; - VertexBuffer& operator=(const VertexBuffer& vertexBuffer); - VertexBuffer& operator=(VertexBuffer&&) = delete; - - template static VertexBufferRef New(Args&&... args); - - // Signals: - NazaraSignal(OnVertexBufferRelease, const VertexBuffer* /*vertexBuffer*/); + VertexBuffer& operator=(const VertexBuffer&) = default; + VertexBuffer& operator=(VertexBuffer&&) noexcept = default; private: - BufferRef m_buffer; + std::shared_ptr m_buffer; + std::shared_ptr m_vertexDeclaration; std::size_t m_endOffset; std::size_t m_startOffset; std::size_t m_vertexCount; - VertexDeclarationConstRef m_vertexDeclaration; }; } diff --git a/include/Nazara/Utility/VertexBuffer.inl b/include/Nazara/Utility/VertexBuffer.inl index 6cf8e8c19..f3f3c6fde 100644 --- a/include/Nazara/Utility/VertexBuffer.inl +++ b/include/Nazara/Utility/VertexBuffer.inl @@ -2,12 +2,13 @@ // This file is part of the "Nazara Engine - Utility module" // For conditions of distribution and use, see copyright notice in Config.hpp +#include #include #include namespace Nz { - inline const BufferRef& VertexBuffer::GetBuffer() const + inline const std::shared_ptr& VertexBuffer::GetBuffer() const { return m_buffer; } @@ -32,23 +33,14 @@ namespace Nz return m_vertexCount; } - inline const VertexDeclarationConstRef& VertexBuffer::GetVertexDeclaration() const + inline const std::shared_ptr& VertexBuffer::GetVertexDeclaration() const { return m_vertexDeclaration; } inline bool VertexBuffer::IsValid() const { - return m_buffer.IsValid() && m_vertexDeclaration.IsValid(); - } - - template - VertexBufferRef VertexBuffer::New(Args&&... args) - { - std::unique_ptr object(new VertexBuffer(std::forward(args)...)); - object->SetPersistent(false); - - return object.release(); + return m_buffer && m_vertexDeclaration; } } diff --git a/include/Nazara/Utility/VertexDeclaration.hpp b/include/Nazara/Utility/VertexDeclaration.hpp index 6fc49cdd0..abe6001ac 100644 --- a/include/Nazara/Utility/VertexDeclaration.hpp +++ b/include/Nazara/Utility/VertexDeclaration.hpp @@ -9,8 +9,6 @@ #include #include -#include -#include #include #include #include @@ -20,11 +18,9 @@ namespace Nz { class VertexDeclaration; - using VertexDeclarationConstRef = ObjectRef; using VertexDeclarationLibrary = ObjectLibrary; - using VertexDeclarationRef = ObjectRef; - class NAZARA_UTILITY_API VertexDeclaration : public RefCounted + class NAZARA_UTILITY_API VertexDeclaration { friend VertexDeclarationLibrary; friend class Utility; @@ -54,9 +50,8 @@ namespace Nz VertexDeclaration& operator=(const VertexDeclaration&) = delete; VertexDeclaration& operator=(VertexDeclaration&&) = delete; - static inline const VertexDeclarationRef& Get(VertexLayout layout); + static inline const std::shared_ptr& Get(VertexLayout layout); static bool IsTypeSupported(ComponentType type); - template static VertexDeclarationRef New(Args&&... args); struct Component { @@ -81,8 +76,7 @@ namespace Nz std::size_t m_stride; VertexInputRate m_inputRate; - static std::array s_declarations; - static VertexDeclarationLibrary::LibraryMap s_library; + static std::array, VertexLayoutCount> s_declarations; }; } diff --git a/include/Nazara/Utility/VertexDeclaration.inl b/include/Nazara/Utility/VertexDeclaration.inl index df4e9b5a1..b126c562b 100644 --- a/include/Nazara/Utility/VertexDeclaration.inl +++ b/include/Nazara/Utility/VertexDeclaration.inl @@ -12,7 +12,7 @@ namespace Nz { inline auto VertexDeclaration::FindComponent(VertexComponent vertexComponent, std::size_t componentIndex) const -> const Component* { - assert(componentIndex == 0 || vertexComponent == VertexComponent_Userdata); + assert(componentIndex == 0 || vertexComponent == VertexComponent::Userdata); for (const Component& component : m_components) { @@ -56,7 +56,7 @@ namespace Nz template auto VertexDeclaration::GetComponentByType(VertexComponent vertexComponent, std::size_t componentIndex) const -> const Component* { - NazaraAssert(componentIndex == 0 || vertexComponent == VertexComponent_Userdata, "Only userdata vertex component can have component indexes"); + NazaraAssert(componentIndex == 0 || vertexComponent == VertexComponent::Userdata, "Only userdata vertex component can have component indexes"); if (const Component* component = FindComponent(vertexComponent, componentIndex)) { if (GetComponentTypeOf() == component->type) @@ -72,20 +72,11 @@ namespace Nz return GetComponentByType(vertexComponent, componentIndex) != nullptr; } - inline const VertexDeclarationRef& VertexDeclaration::Get(VertexLayout layout) + inline const std::shared_ptr& VertexDeclaration::Get(VertexLayout layout) { - NazaraAssert(layout <= VertexLayout_Max, "Vertex layout out of enum"); + NazaraAssert(layout <= VertexLayout::Max, "Vertex layout out of enum"); - return s_declarations[layout]; - } - - template - VertexDeclarationRef VertexDeclaration::New(Args&&... args) - { - std::unique_ptr object = std::make_unique(std::forward(args)...); - object->SetPersistent(false); - - return object.release(); + return s_declarations[UnderlyingCast(layout)]; } } diff --git a/include/Nazara/Utility/VertexMapper.hpp b/include/Nazara/Utility/VertexMapper.hpp index 39a210b00..c758e057d 100644 --- a/include/Nazara/Utility/VertexMapper.hpp +++ b/include/Nazara/Utility/VertexMapper.hpp @@ -20,10 +20,10 @@ namespace Nz class NAZARA_UTILITY_API VertexMapper { public: - VertexMapper(SubMesh* subMesh, BufferAccess access = BufferAccess_ReadWrite); - VertexMapper(VertexBuffer* vertexBuffer, BufferAccess access = BufferAccess_ReadWrite); - VertexMapper(const SubMesh* subMesh, BufferAccess access = BufferAccess_ReadOnly); - VertexMapper(const VertexBuffer* vertexBuffer, BufferAccess access = BufferAccess_ReadOnly); + VertexMapper(SubMesh& subMesh, BufferAccess access = BufferAccess::ReadWrite); + VertexMapper(VertexBuffer& vertexBuffer, BufferAccess access = BufferAccess::ReadWrite); + VertexMapper(const SubMesh& subMesh, BufferAccess access = BufferAccess::ReadOnly); + VertexMapper(const VertexBuffer& vertexBuffer, BufferAccess access = BufferAccess::ReadOnly); ~VertexMapper(); template SparsePtr GetComponentPtr(VertexComponent component, std::size_t componentIndex = 0); diff --git a/include/Nazara/Utility/VertexMapper.inl b/include/Nazara/Utility/VertexMapper.inl index ddb1015c2..fb704915f 100644 --- a/include/Nazara/Utility/VertexMapper.inl +++ b/include/Nazara/Utility/VertexMapper.inl @@ -13,7 +13,7 @@ namespace Nz SparsePtr VertexMapper::GetComponentPtr(VertexComponent component, std::size_t componentIndex) { // On récupère la déclaration depuis le buffer - const VertexDeclaration* declaration = m_mapper.GetBuffer()->GetVertexDeclaration(); + const std::shared_ptr& declaration = m_mapper.GetBuffer()->GetVertexDeclaration(); if (const auto* componentData = declaration->GetComponentByType(component, componentIndex)) return SparsePtr(static_cast(m_mapper.GetPointer()) + componentData->offset, declaration->GetStride()); diff --git a/include/Nazara/VulkanRenderer/Utils.inl b/include/Nazara/VulkanRenderer/Utils.inl index e4632b053..244eb76a5 100644 --- a/include/Nazara/VulkanRenderer/Utils.inl +++ b/include/Nazara/VulkanRenderer/Utils.inl @@ -14,12 +14,12 @@ namespace Nz { switch (format) { - case VK_FORMAT_B8G8R8A8_UNORM: return PixelFormat::PixelFormat_BGRA8; - case VK_FORMAT_B8G8R8A8_SRGB: return PixelFormat::PixelFormat_BGRA8_SRGB; - case VK_FORMAT_D24_UNORM_S8_UINT: return PixelFormat::PixelFormat_Depth24Stencil8; - case VK_FORMAT_D32_SFLOAT: return PixelFormat::PixelFormat_Depth32; - case VK_FORMAT_R8G8B8A8_UNORM: return PixelFormat::PixelFormat_RGBA8; - case VK_FORMAT_R8G8B8A8_SRGB: return PixelFormat::PixelFormat_RGBA8_SRGB; + case VK_FORMAT_B8G8R8A8_UNORM: return PixelFormat::BGRA8; + case VK_FORMAT_B8G8R8A8_SRGB: return PixelFormat::BGRA8_SRGB; + case VK_FORMAT_D24_UNORM_S8_UINT: return PixelFormat::Depth24Stencil8; + case VK_FORMAT_D32_SFLOAT: return PixelFormat::Depth32; + case VK_FORMAT_R8G8B8A8_UNORM: return PixelFormat::RGBA8; + case VK_FORMAT_R8G8B8A8_SRGB: return PixelFormat::RGBA8_SRGB; default: break; } @@ -94,12 +94,12 @@ namespace Nz { switch (bufferType) { - case BufferType_Index: return VK_BUFFER_USAGE_INDEX_BUFFER_BIT; - case BufferType_Vertex: return VK_BUFFER_USAGE_VERTEX_BUFFER_BIT; - case BufferType_Uniform: return VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT; + case BufferType::Index: return VK_BUFFER_USAGE_INDEX_BUFFER_BIT; + case BufferType::Vertex: return VK_BUFFER_USAGE_VERTEX_BUFFER_BIT; + case BufferType::Uniform: return VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT; } - NazaraError("Unhandled BufferType 0x" + NumberToString(bufferType, 16)); + NazaraError("Unhandled BufferType 0x" + NumberToString(UnderlyingCast(bufferType), 16)); return 0; } @@ -107,23 +107,23 @@ namespace Nz { switch (componentType) { - case ComponentType_Color: return VK_FORMAT_R8G8B8A8_UINT; - case ComponentType_Double1: return VK_FORMAT_R64_SFLOAT; - case ComponentType_Double2: return VK_FORMAT_R64G64_SFLOAT; - case ComponentType_Double3: return VK_FORMAT_R64G64B64_SFLOAT; - case ComponentType_Double4: return VK_FORMAT_R64G64B64A64_SFLOAT; - case ComponentType_Float1: return VK_FORMAT_R32_SFLOAT; - case ComponentType_Float2: return VK_FORMAT_R32G32_SFLOAT; - case ComponentType_Float3: return VK_FORMAT_R32G32B32_SFLOAT; - case ComponentType_Float4: return VK_FORMAT_R32G32B32A32_SFLOAT; - case ComponentType_Int1: return VK_FORMAT_R32_SINT; - case ComponentType_Int2: return VK_FORMAT_R32G32_SINT; - case ComponentType_Int3: return VK_FORMAT_R32G32B32_SINT; - case ComponentType_Int4: return VK_FORMAT_R32G32B32A32_SINT; - case ComponentType_Quaternion: return VK_FORMAT_R32G32B32A32_SFLOAT; + case ComponentType::Color: return VK_FORMAT_R8G8B8A8_UINT; + case ComponentType::Double1: return VK_FORMAT_R64_SFLOAT; + case ComponentType::Double2: return VK_FORMAT_R64G64_SFLOAT; + case ComponentType::Double3: return VK_FORMAT_R64G64B64_SFLOAT; + case ComponentType::Double4: return VK_FORMAT_R64G64B64A64_SFLOAT; + case ComponentType::Float1: return VK_FORMAT_R32_SFLOAT; + case ComponentType::Float2: return VK_FORMAT_R32G32_SFLOAT; + case ComponentType::Float3: return VK_FORMAT_R32G32B32_SFLOAT; + case ComponentType::Float4: return VK_FORMAT_R32G32B32A32_SFLOAT; + case ComponentType::Int1: return VK_FORMAT_R32_SINT; + case ComponentType::Int2: return VK_FORMAT_R32G32_SINT; + case ComponentType::Int3: return VK_FORMAT_R32G32B32_SINT; + case ComponentType::Int4: return VK_FORMAT_R32G32B32A32_SINT; + case ComponentType::Quaternion: return VK_FORMAT_R32G32B32A32_SFLOAT; } - NazaraError("Unhandled ComponentType 0x" + NumberToString(componentType, 16)); + NazaraError("Unhandled ComponentType 0x" + NumberToString(UnderlyingCast(componentType), 16)); return VK_FORMAT_UNDEFINED; } @@ -131,13 +131,13 @@ namespace Nz { switch (faceSide) { - case FaceSide_None: return VK_CULL_MODE_NONE; - case FaceSide_Back: return VK_CULL_MODE_BACK_BIT; - case FaceSide_Front: return VK_CULL_MODE_FRONT_BIT; - case FaceSide_FrontAndBack: return VK_CULL_MODE_FRONT_AND_BACK; + case FaceSide::None: return VK_CULL_MODE_NONE; + case FaceSide::Back: return VK_CULL_MODE_BACK_BIT; + case FaceSide::Front: return VK_CULL_MODE_FRONT_BIT; + case FaceSide::FrontAndBack: return VK_CULL_MODE_FRONT_AND_BACK; } - NazaraError("Unhandled FaceSide 0x" + NumberToString(faceSide, 16)); + NazaraError("Unhandled FaceSide 0x" + NumberToString(UnderlyingCast(faceSide), 16)); return VK_CULL_MODE_BACK_BIT; } @@ -145,12 +145,12 @@ namespace Nz { switch (faceFilling) { - case FaceFilling_Fill: return VK_POLYGON_MODE_FILL; - case FaceFilling_Line: return VK_POLYGON_MODE_LINE; - case FaceFilling_Point: return VK_POLYGON_MODE_POINT; + case FaceFilling::Fill: return VK_POLYGON_MODE_FILL; + case FaceFilling::Line: return VK_POLYGON_MODE_LINE; + case FaceFilling::Point: return VK_POLYGON_MODE_POINT; } - NazaraError("Unhandled FaceFilling 0x" + NumberToString(faceFilling, 16)); + NazaraError("Unhandled FaceFilling 0x" + NumberToString(UnderlyingCast(faceFilling), 16)); return VK_POLYGON_MODE_FILL; } @@ -234,17 +234,17 @@ namespace Nz { switch (pixelFormat) { - case PixelFormat::PixelFormat_BGRA8: return VK_FORMAT_B8G8R8A8_UNORM; - case PixelFormat::PixelFormat_BGRA8_SRGB: return VK_FORMAT_B8G8R8A8_SRGB; - case PixelFormat::PixelFormat_Depth24Stencil8: return VK_FORMAT_D24_UNORM_S8_UINT; - case PixelFormat::PixelFormat_Depth32: return VK_FORMAT_D32_SFLOAT; - case PixelFormat::PixelFormat_RGBA8: return VK_FORMAT_R8G8B8A8_UNORM; - case PixelFormat::PixelFormat_RGBA8_SRGB: return VK_FORMAT_R8G8B8A8_SRGB; - case PixelFormat::PixelFormat_RGBA32F: return VK_FORMAT_R32G32B32A32_SFLOAT; + case PixelFormat::BGRA8: return VK_FORMAT_B8G8R8A8_UNORM; + case PixelFormat::BGRA8_SRGB: return VK_FORMAT_B8G8R8A8_SRGB; + case PixelFormat::Depth24Stencil8: return VK_FORMAT_D24_UNORM_S8_UINT; + case PixelFormat::Depth32: return VK_FORMAT_D32_SFLOAT; + 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; default: break; } - NazaraError("Unhandled PixelFormat 0x" + NumberToString(pixelFormat, 16)); + NazaraError("Unhandled PixelFormat 0x" + NumberToString(UnderlyingCast(pixelFormat), 16)); return {}; } @@ -252,15 +252,15 @@ namespace Nz { switch (primitiveMode) { - case PrimitiveMode_LineList: return VK_PRIMITIVE_TOPOLOGY_LINE_LIST; - case PrimitiveMode_LineStrip: return VK_PRIMITIVE_TOPOLOGY_LINE_STRIP; - case PrimitiveMode_PointList: return VK_PRIMITIVE_TOPOLOGY_POINT_LIST; - case PrimitiveMode_TriangleList: return VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST; - case PrimitiveMode_TriangleStrip: return VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP; - case PrimitiveMode_TriangleFan: return VK_PRIMITIVE_TOPOLOGY_TRIANGLE_FAN; + case PrimitiveMode::LineList: return VK_PRIMITIVE_TOPOLOGY_LINE_LIST; + case PrimitiveMode::LineStrip: return VK_PRIMITIVE_TOPOLOGY_LINE_STRIP; + case PrimitiveMode::PointList: return VK_PRIMITIVE_TOPOLOGY_POINT_LIST; + case PrimitiveMode::TriangleList: return VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST; + case PrimitiveMode::TriangleStrip: return VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP; + case PrimitiveMode::TriangleFan: return VK_PRIMITIVE_TOPOLOGY_TRIANGLE_FAN; } - NazaraError("Unhandled FaceFilling 0x" + NumberToString(primitiveMode, 16)); + NazaraError("Unhandled FaceFilling 0x" + NumberToString(UnderlyingCast(primitiveMode), 16)); return VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST; } @@ -268,17 +268,17 @@ namespace Nz { switch (comparison) { - case RendererComparison_Never: return VK_COMPARE_OP_NEVER; - case RendererComparison_Less: return VK_COMPARE_OP_LESS; - case RendererComparison_Equal: return VK_COMPARE_OP_EQUAL; - case RendererComparison_LessOrEqual: return VK_COMPARE_OP_LESS_OR_EQUAL; - case RendererComparison_Greater: return VK_COMPARE_OP_GREATER; - case RendererComparison_NotEqual: return VK_COMPARE_OP_NOT_EQUAL; - case RendererComparison_GreaterOrEqual: return VK_COMPARE_OP_GREATER_OR_EQUAL; - case RendererComparison_Always: return VK_COMPARE_OP_ALWAYS; + case RendererComparison::Never: return VK_COMPARE_OP_NEVER; + case RendererComparison::Less: return VK_COMPARE_OP_LESS; + case RendererComparison::Equal: return VK_COMPARE_OP_EQUAL; + case RendererComparison::LessOrEqual: return VK_COMPARE_OP_LESS_OR_EQUAL; + case RendererComparison::Greater: return VK_COMPARE_OP_GREATER; + case RendererComparison::NotEqual: return VK_COMPARE_OP_NOT_EQUAL; + case RendererComparison::GreaterOrEqual: return VK_COMPARE_OP_GREATER_OR_EQUAL; + case RendererComparison::Always: return VK_COMPARE_OP_ALWAYS; } - NazaraError("Unhandled RendererComparison 0x" + NumberToString(comparison, 16)); + NazaraError("Unhandled RendererComparison 0x" + NumberToString(UnderlyingCast(comparison), 16)); return VK_COMPARE_OP_NEVER; } @@ -286,8 +286,8 @@ namespace Nz { switch (samplerFilter) { - case SamplerFilter_Linear: return VK_FILTER_LINEAR; - case SamplerFilter_Nearest: return VK_FILTER_NEAREST; + case SamplerFilter::Linear: return VK_FILTER_LINEAR; + case SamplerFilter::Nearest: return VK_FILTER_NEAREST; } NazaraError("Unhandled SamplerFilter 0x" + NumberToString(UnderlyingCast(samplerFilter), 16)); @@ -298,8 +298,8 @@ namespace Nz { switch (samplerMipmap) { - case SamplerMipmapMode_Linear: return VK_SAMPLER_MIPMAP_MODE_LINEAR; - case SamplerMipmapMode_Nearest: return VK_SAMPLER_MIPMAP_MODE_NEAREST; + case SamplerMipmapMode::Linear: return VK_SAMPLER_MIPMAP_MODE_LINEAR; + case SamplerMipmapMode::Nearest: return VK_SAMPLER_MIPMAP_MODE_NEAREST; } NazaraError("Unhandled SamplerMipmapMode 0x" + NumberToString(UnderlyingCast(samplerMipmap), 16)); @@ -310,9 +310,9 @@ namespace Nz { switch (samplerWrap) { - case SamplerWrap_Clamp: return VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE; - case SamplerWrap_MirroredRepeat: return VK_SAMPLER_ADDRESS_MODE_MIRRORED_REPEAT; - case SamplerWrap_Repeat: return VK_SAMPLER_ADDRESS_MODE_REPEAT; + case SamplerWrap::Clamp: return VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE; + case SamplerWrap::MirroredRepeat: return VK_SAMPLER_ADDRESS_MODE_MIRRORED_REPEAT; + case SamplerWrap::Repeat: return VK_SAMPLER_ADDRESS_MODE_REPEAT; } NazaraError("Unhandled SamplerWrap 0x" + NumberToString(UnderlyingCast(samplerWrap), 16)); @@ -360,17 +360,17 @@ namespace Nz { switch (stencilOp) { - case StencilOperation_Decrement: return VK_STENCIL_OP_DECREMENT_AND_CLAMP; - case StencilOperation_DecrementNoClamp: return VK_STENCIL_OP_DECREMENT_AND_WRAP; - case StencilOperation_Increment: return VK_STENCIL_OP_INCREMENT_AND_CLAMP; - case StencilOperation_IncrementNoClamp: return VK_STENCIL_OP_INCREMENT_AND_WRAP; - case StencilOperation_Invert: return VK_STENCIL_OP_INVERT; - case StencilOperation_Keep: return VK_STENCIL_OP_KEEP; - case StencilOperation_Replace: return VK_STENCIL_OP_REPLACE; - case StencilOperation_Zero: return VK_STENCIL_OP_ZERO; + case StencilOperation::Decrement: return VK_STENCIL_OP_DECREMENT_AND_CLAMP; + case StencilOperation::DecrementNoClamp: return VK_STENCIL_OP_DECREMENT_AND_WRAP; + case StencilOperation::Increment: return VK_STENCIL_OP_INCREMENT_AND_CLAMP; + case StencilOperation::IncrementNoClamp: return VK_STENCIL_OP_INCREMENT_AND_WRAP; + case StencilOperation::Invert: return VK_STENCIL_OP_INVERT; + case StencilOperation::Keep: return VK_STENCIL_OP_KEEP; + case StencilOperation::Replace: return VK_STENCIL_OP_REPLACE; + case StencilOperation::Zero: return VK_STENCIL_OP_ZERO; } - NazaraError("Unhandled StencilOperation 0x" + NumberToString(stencilOp, 16)); + NazaraError("Unhandled StencilOperation 0x" + NumberToString(UnderlyingCast(stencilOp), 16)); return {}; } diff --git a/plugins/Assimp/Plugin.cpp b/plugins/Assimp/Plugin.cpp index c27a989df..62c35a6f0 100644 --- a/plugins/Assimp/Plugin.cpp +++ b/plugins/Assimp/Plugin.cpp @@ -36,6 +36,7 @@ SOFTWARE. #include #include #include +#include #include #include #include @@ -74,9 +75,13 @@ void ProcessJoints(aiNode* node, Skeleton* skeleton, const std::set ProcessJoints(node->mChildren[i], skeleton, joints); } -bool IsSupported(const std::string& extension) +bool IsSupported(const std::string_view& extension) { - std::string dotExt = '.' + extension; + std::string dotExt; + dotExt.reserve(extension.size() + 1); + dotExt += '.'; + dotExt += extension; + return (aiIsExtensionSupported(dotExt.data()) == AI_TRUE); } @@ -89,7 +94,7 @@ Ternary CheckAnimation(Stream& /*stream*/, const AnimationParams& parameters) return Ternary::Unknown; } -AnimationRef LoadAnimation(Stream& stream, const AnimationParams& parameters) +std::shared_ptr LoadAnimation(Stream& stream, const AnimationParams& parameters) { std::string streamPath = stream.GetPath().generic_u8string(); @@ -141,7 +146,7 @@ AnimationRef LoadAnimation(Stream& stream, const AnimationParams& parameters) maxFrameCount = std::max({ maxFrameCount, nodeAnim->mNumPositionKeys, nodeAnim->mNumRotationKeys, nodeAnim->mNumScalingKeys }); } - AnimationRef anim = Animation::New(); + std::shared_ptr anim = std::make_shared(); anim->CreateSkeletal(maxFrameCount, animation->mNumChannels); @@ -184,7 +189,7 @@ Ternary CheckMesh(Stream& /*stream*/, const MeshParams& parameters) return Ternary::Unknown; } -MeshRef LoadMesh(Stream& stream, const MeshParams& parameters) +std::shared_ptr LoadMesh(Stream& stream, const MeshParams& parameters) { std::string streamPath = stream.GetPath().generic_u8string(); @@ -221,16 +226,16 @@ MeshRef LoadMesh(Stream& stream, const MeshParams& parameters) int excludedComponents = 0; - if (!parameters.vertexDeclaration->HasComponent(VertexComponent_Color)) + if (!parameters.vertexDeclaration->HasComponent(VertexComponent::Color)) excludedComponents |= aiComponent_COLORS; - if (!parameters.vertexDeclaration->HasComponent(VertexComponent_Normal)) + if (!parameters.vertexDeclaration->HasComponent(VertexComponent::Normal)) excludedComponents |= aiComponent_NORMALS; - if (!parameters.vertexDeclaration->HasComponent(VertexComponent_Tangent)) + if (!parameters.vertexDeclaration->HasComponent(VertexComponent::Tangent)) excludedComponents |= aiComponent_TANGENTS_AND_BITANGENTS; - if (!parameters.vertexDeclaration->HasComponent(VertexComponent_TexCoord)) + if (!parameters.vertexDeclaration->HasComponent(VertexComponent::TexCoord)) excludedComponents |= aiComponent_TEXCOORDS; aiPropertyStore* properties = aiCreatePropertyStore(); @@ -271,7 +276,7 @@ MeshRef LoadMesh(Stream& stream, const MeshParams& parameters) } } - MeshRef mesh = Mesh::New(); + std::shared_ptr mesh = std::make_shared(); if (animatedMesh) { mesh->CreateSkeletal(UInt32(joints.size())); @@ -302,9 +307,9 @@ MeshRef LoadMesh(Stream& stream, const MeshParams& parameters) // Index buffer bool largeIndices = (vertexCount > std::numeric_limits::max()); - IndexBufferRef indexBuffer = IndexBuffer::New(largeIndices, indexCount, parameters.storage, parameters.indexBufferFlags); + std::shared_ptr indexBuffer = std::make_shared(largeIndices, indexCount, parameters.storage, parameters.indexBufferFlags); - IndexMapper indexMapper(indexBuffer, BufferAccess_DiscardAndWrite); + IndexMapper indexMapper(*indexBuffer, BufferAccess::DiscardAndWrite); IndexIterator index = indexMapper.begin(); for (unsigned int faceIdx = 0; faceIdx < iMesh->mNumFaces; ++faceIdx) @@ -324,8 +329,8 @@ MeshRef LoadMesh(Stream& stream, const MeshParams& parameters) if (normalTangentMatrix.HasScale()) normalTangentMatrix.ApplyScale(1.f / normalTangentMatrix.GetScale()); - VertexBufferRef vertexBuffer = VertexBuffer::New(VertexDeclaration::Get(VertexLayout_XYZ_Normal_UV_Tangent_Skinning), vertexCount, parameters.storage, parameters.vertexBufferFlags); - BufferMapper vertexMapper(vertexBuffer, BufferAccess_ReadWrite); + std::shared_ptr vertexBuffer = std::make_shared(VertexDeclaration::Get(VertexLayout::XYZ_Normal_UV_Tangent_Skinning), vertexCount, parameters.storage, parameters.vertexBufferFlags); + BufferMapper vertexMapper(*vertexBuffer, BufferAccess::ReadWrite); SkeletalMeshVertex* vertices = static_cast(vertexMapper.GetPointer()); for (std::size_t vertexIdx = 0; vertexIdx < vertexCount; ++vertexIdx) @@ -357,7 +362,7 @@ MeshRef LoadMesh(Stream& stream, const MeshParams& parameters) } // Submesh - SkeletalMeshRef subMesh = SkeletalMesh::New(vertexBuffer, indexBuffer); + std::shared_ptr subMesh = std::make_shared(vertexBuffer, indexBuffer); subMesh->SetMaterialIndex(iMesh->mMaterialIndex); auto matIt = materials.find(iMesh->mMaterialIndex); @@ -385,20 +390,20 @@ MeshRef LoadMesh(Stream& stream, const MeshParams& parameters) if (wrapKey) { - SamplerWrap wrap = SamplerWrap_Clamp; + SamplerWrap wrap = SamplerWrap::Clamp; switch (mapMode[0]) { case aiTextureMapMode_Clamp: case aiTextureMapMode_Decal: - wrap = SamplerWrap_Clamp; + wrap = SamplerWrap::Clamp; break; case aiTextureMapMode_Mirror: - wrap = SamplerWrap_MirroredRepeat; + wrap = SamplerWrap::MirroredRepeat; break; case aiTextureMapMode_Wrap: - wrap = SamplerWrap_Repeat; + wrap = SamplerWrap::Repeat; break; default: @@ -460,9 +465,9 @@ MeshRef LoadMesh(Stream& stream, const MeshParams& parameters) // Index buffer bool largeIndices = (vertexCount > std::numeric_limits::max()); - IndexBufferRef indexBuffer = IndexBuffer::New(largeIndices, indexCount, parameters.storage, parameters.indexBufferFlags); + std::shared_ptr indexBuffer = std::make_shared(largeIndices, indexCount, parameters.storage, parameters.indexBufferFlags); - IndexMapper indexMapper(indexBuffer, BufferAccess_DiscardAndWrite); + IndexMapper indexMapper(*indexBuffer, BufferAccess::DiscardAndWrite); IndexIterator index = indexMapper.begin(); for (unsigned int faceIdx = 0; faceIdx < iMesh->mNumFaces; ++faceIdx) @@ -484,18 +489,18 @@ MeshRef LoadMesh(Stream& stream, const MeshParams& parameters) if (normalTangentMatrix.HasScale()) normalTangentMatrix.ApplyScale(1.f / normalTangentMatrix.GetScale()); - VertexBufferRef vertexBuffer = VertexBuffer::New(parameters.vertexDeclaration, vertexCount, parameters.storage, parameters.vertexBufferFlags); + std::shared_ptr vertexBuffer = std::make_shared(parameters.vertexDeclaration, vertexCount, parameters.storage, parameters.vertexBufferFlags); - VertexMapper vertexMapper(vertexBuffer, BufferAccess_DiscardAndWrite); + VertexMapper vertexMapper(*vertexBuffer, BufferAccess::DiscardAndWrite); - auto posPtr = vertexMapper.GetComponentPtr(VertexComponent_Position); + auto posPtr = vertexMapper.GetComponentPtr(VertexComponent::Position); for (unsigned int vertexIdx = 0; vertexIdx < vertexCount; ++vertexIdx) { aiVector3D position = iMesh->mVertices[vertexIdx]; *posPtr++ = parameters.matrix * Vector3f(position.x, position.y, position.z); } - if (auto normalPtr = vertexMapper.GetComponentPtr(VertexComponent_Normal)) + if (auto normalPtr = vertexMapper.GetComponentPtr(VertexComponent::Normal)) { for (unsigned int vertexIdx = 0; vertexIdx < vertexCount; ++vertexIdx) { @@ -505,7 +510,7 @@ MeshRef LoadMesh(Stream& stream, const MeshParams& parameters) } bool generateTangents = false; - if (auto tangentPtr = vertexMapper.GetComponentPtr(VertexComponent_Tangent)) + if (auto tangentPtr = vertexMapper.GetComponentPtr(VertexComponent::Tangent)) { if (iMesh->HasTangentsAndBitangents()) { @@ -519,7 +524,7 @@ MeshRef LoadMesh(Stream& stream, const MeshParams& parameters) generateTangents = true; } - if (auto uvPtr = vertexMapper.GetComponentPtr(VertexComponent_TexCoord)) + if (auto uvPtr = vertexMapper.GetComponentPtr(VertexComponent::TexCoord)) { if (iMesh->HasTextureCoords(0)) { @@ -539,7 +544,7 @@ MeshRef LoadMesh(Stream& stream, const MeshParams& parameters) vertexMapper.Unmap(); // Submesh - StaticMeshRef subMesh = StaticMesh::New(vertexBuffer, indexBuffer); + std::shared_ptr subMesh = std::make_shared(vertexBuffer, indexBuffer); subMesh->GenerateAABB(); subMesh->SetMaterialIndex(iMesh->mMaterialIndex); @@ -571,20 +576,20 @@ MeshRef LoadMesh(Stream& stream, const MeshParams& parameters) if (wrapKey) { - SamplerWrap wrap = SamplerWrap_Clamp; + SamplerWrap wrap = SamplerWrap::Clamp; switch (mapMode[0]) { case aiTextureMapMode_Clamp: case aiTextureMapMode_Decal: - wrap = SamplerWrap_Clamp; + wrap = SamplerWrap::Clamp; break; case aiTextureMapMode_Mirror: - wrap = SamplerWrap_MirroredRepeat; + wrap = SamplerWrap::MirroredRepeat; break; case aiTextureMapMode_Wrap: - wrap = SamplerWrap_Repeat; + wrap = SamplerWrap::Repeat; break; default: @@ -636,18 +641,51 @@ MeshRef LoadMesh(Stream& stream, const MeshParams& parameters) return mesh; } +namespace +{ + const Nz::AnimationLoader::Entry* animationLoaderEntry = nullptr; + const Nz::MeshLoader::Entry* meshLoaderEntry = nullptr; +} + extern "C" { NAZARA_EXPORT int PluginLoad() { - Nz::AnimationLoader::RegisterLoader(IsSupported, CheckAnimation, LoadAnimation); - Nz::MeshLoader::RegisterLoader(IsSupported, CheckMesh, LoadMesh); + Nz::Utility* utility = Nz::Utility::Instance(); + NazaraAssert(utility, "utility module is not instancied"); + + Nz::AnimationLoader& animationLoader = utility->GetAnimationLoader(); + animationLoaderEntry = animationLoader.RegisterLoader({ + IsSupported, + nullptr, + nullptr, + CheckAnimation, + LoadAnimation + }); + + Nz::MeshLoader& meshLoader = utility->GetMeshLoader(); + meshLoaderEntry = meshLoader.RegisterLoader({ + IsSupported, + nullptr, + nullptr, + CheckMesh, + LoadMesh + }); + return 1; } NAZARA_EXPORT void PluginUnload() { - Nz::AnimationLoader::RegisterLoader(IsSupported, CheckAnimation, LoadAnimation); - Nz::MeshLoader::UnregisterLoader(IsSupported, CheckMesh, LoadMesh); + Nz::Utility* utility = Nz::Utility::Instance(); + NazaraAssert(utility, "utility module is not instancied"); + + Nz::AnimationLoader& animationLoader = utility->GetAnimationLoader(); + animationLoader.UnregisterLoader(animationLoaderEntry); + animationLoaderEntry = nullptr; + + Nz::MeshLoader& meshLoader = utility->GetMeshLoader(); + meshLoader.UnregisterLoader(meshLoaderEntry); + meshLoaderEntry = nullptr; } } diff --git a/src/Nazara/Graphics/BakedFrameGraph.cpp b/src/Nazara/Graphics/BakedFrameGraph.cpp index 89a13d1df..f88857cf2 100644 --- a/src/Nazara/Graphics/BakedFrameGraph.cpp +++ b/src/Nazara/Graphics/BakedFrameGraph.cpp @@ -130,7 +130,7 @@ namespace Nz for (auto& textureData : m_textures) { TextureInfo textureCreationParams; - textureCreationParams.type = ImageType_2D; + textureCreationParams.type = ImageType::E2D; textureCreationParams.width = textureData.width * width / 100'000; textureCreationParams.height = textureData.height * height / 100'000; textureCreationParams.usageFlags = textureData.usage; diff --git a/src/Nazara/Graphics/BasicMaterial.cpp b/src/Nazara/Graphics/BasicMaterial.cpp index 2108a04fc..a721a0388 100644 --- a/src/Nazara/Graphics/BasicMaterial.cpp +++ b/src/Nazara/Graphics/BasicMaterial.cpp @@ -98,10 +98,10 @@ namespace Nz bool BasicMaterial::Initialize() { - FieldOffsets fieldOffsets(StructLayout_Std140); + FieldOffsets fieldOffsets(StructLayout::Std140); - s_uniformOffsets.alphaThreshold = fieldOffsets.AddField(StructFieldType_Float1); - s_uniformOffsets.diffuseColor = fieldOffsets.AddField(StructFieldType_Float4); + s_uniformOffsets.alphaThreshold = fieldOffsets.AddField(StructFieldType::Float1); + s_uniformOffsets.diffuseColor = fieldOffsets.AddField(StructFieldType::Float4); s_uniformOffsets.totalSize = fieldOffsets.GetSize(); MaterialSettings::Builder settings; @@ -129,21 +129,21 @@ namespace Nz settings.textures.push_back({ "MaterialAlphaMap", "Alpha", - ImageType_2D + ImageType::E2D }); s_textureIndexes.diffuse = settings.textures.size(); settings.textures.push_back({ "MaterialDiffuseMap", "Diffuse", - ImageType_2D + ImageType::E2D }); settings.predefinedBinding[UnderlyingCast(PredefinedShaderBinding::TexOverlay)] = settings.textures.size(); settings.textures.push_back({ "TextureOverlay", "Overlay", - ImageType_2D + ImageType::E2D }); s_uniformBlockIndex = settings.uniformBlocks.size(); diff --git a/src/Nazara/Graphics/FrameGraph.cpp b/src/Nazara/Graphics/FrameGraph.cpp index ac9bbf0da..f825c0ef8 100644 --- a/src/Nazara/Graphics/FrameGraph.cpp +++ b/src/Nazara/Graphics/FrameGraph.cpp @@ -429,7 +429,7 @@ namespace Nz { auto& depthStencilAttachment = renderPassAttachments[colorAttachmentCount]; - if (PixelFormatInfo::GetContent(depthStencilAttachment.format) == PixelFormatContent_DepthStencil) + if (PixelFormatInfo::GetContent(depthStencilAttachment.format) == PixelFormatContent::DepthStencil) { depthStencilAttachment.stencilLoadOp = depthStencilAttachment.loadOp; depthStencilAttachment.stencilStoreOp = depthStencilAttachment.storeOp; diff --git a/src/Nazara/Graphics/GraphicalMesh.cpp b/src/Nazara/Graphics/GraphicalMesh.cpp index a15980189..278ab885a 100644 --- a/src/Nazara/Graphics/GraphicalMesh.cpp +++ b/src/Nazara/Graphics/GraphicalMesh.cpp @@ -11,31 +11,31 @@ namespace Nz { - GraphicalMesh::GraphicalMesh(const Mesh* mesh) + GraphicalMesh::GraphicalMesh(const Mesh& mesh) { - assert(mesh->GetAnimationType() == AnimationType_Static); + assert(mesh.GetAnimationType() == AnimationType::Static); const std::shared_ptr& renderDevice = Graphics::Instance()->GetRenderDevice(); - m_subMeshes.reserve(mesh->GetSubMeshCount()); - for (std::size_t i = 0; i < mesh->GetSubMeshCount(); ++i) + m_subMeshes.reserve(mesh.GetSubMeshCount()); + for (std::size_t i = 0; i < mesh.GetSubMeshCount(); ++i) { - const SubMesh* subMesh = mesh->GetSubMesh(i); + const SubMesh& subMesh = *mesh.GetSubMesh(i); - const StaticMesh* staticMesh = static_cast(subMesh); + const StaticMesh& staticMesh = static_cast(subMesh); - const IndexBuffer* indexBuffer = staticMesh->GetIndexBuffer(); - const VertexBuffer* vertexBuffer = staticMesh->GetVertexBuffer(); + const std::shared_ptr& indexBuffer = staticMesh.GetIndexBuffer(); + const std::shared_ptr& vertexBuffer = staticMesh.GetVertexBuffer(); - assert(indexBuffer->GetBuffer()->GetStorage() == DataStorage_Software); + assert(indexBuffer->GetBuffer()->GetStorage() == DataStorage::Software); const SoftwareBuffer* indexBufferContent = static_cast(indexBuffer->GetBuffer()->GetImpl()); - assert(vertexBuffer->GetBuffer()->GetStorage() == DataStorage_Software); + assert(vertexBuffer->GetBuffer()->GetStorage() == DataStorage::Software); const SoftwareBuffer* vertexBufferContent = static_cast(vertexBuffer->GetBuffer()->GetImpl()); auto& submeshData = m_subMeshes.emplace_back(); - submeshData.indexBuffer = renderDevice->InstantiateBuffer(BufferType_Index); - if (!submeshData.indexBuffer->Initialize(indexBuffer->GetStride() * indexBuffer->GetIndexCount(), BufferUsage_DeviceLocal)) + submeshData.indexBuffer = renderDevice->InstantiateBuffer(BufferType::Index); + if (!submeshData.indexBuffer->Initialize(indexBuffer->GetStride() * indexBuffer->GetIndexCount(), BufferUsage::DeviceLocal)) throw std::runtime_error("failed to create index buffer"); if (!submeshData.indexBuffer->Fill(indexBufferContent->GetData() + indexBuffer->GetStartOffset(), 0, indexBuffer->GetEndOffset() - indexBuffer->GetStartOffset())) @@ -43,8 +43,8 @@ namespace Nz submeshData.indexCount = indexBuffer->GetIndexCount(); - submeshData.vertexBuffer = renderDevice->InstantiateBuffer(BufferType_Vertex); - if (!submeshData.vertexBuffer->Initialize(vertexBuffer->GetStride() * vertexBuffer->GetVertexCount(), BufferUsage_DeviceLocal)) + submeshData.vertexBuffer = renderDevice->InstantiateBuffer(BufferType::Vertex); + if (!submeshData.vertexBuffer->Initialize(vertexBuffer->GetStride() * vertexBuffer->GetVertexCount(), BufferUsage::DeviceLocal)) throw std::runtime_error("failed to create vertex buffer"); if (!submeshData.vertexBuffer->Fill(vertexBufferContent->GetData() + vertexBuffer->GetStartOffset(), 0, vertexBuffer->GetEndOffset() - vertexBuffer->GetStartOffset())) diff --git a/src/Nazara/Graphics/Graphics.cpp b/src/Nazara/Graphics/Graphics.cpp index 2ff5d78ca..433df28ef 100644 --- a/src/Nazara/Graphics/Graphics.cpp +++ b/src/Nazara/Graphics/Graphics.cpp @@ -50,8 +50,8 @@ namespace Nz Nz::PredefinedViewerData viewerUboOffsets = Nz::PredefinedViewerData::GetOffsets(); - m_viewerDataUBO = m_renderDevice->InstantiateBuffer(Nz::BufferType_Uniform); - if (!m_viewerDataUBO->Initialize(viewerUboOffsets.totalSize, Nz::BufferUsage_DeviceLocal | Nz::BufferUsage_Dynamic)) + m_viewerDataUBO = m_renderDevice->InstantiateBuffer(Nz::BufferType::Uniform); + if (!m_viewerDataUBO->Initialize(viewerUboOffsets.totalSize, Nz::BufferUsage::DeviceLocal | Nz::BufferUsage::Dynamic)) throw std::runtime_error("failed to initialize viewer data UBO"); } diff --git a/src/Nazara/Graphics/Material.cpp b/src/Nazara/Graphics/Material.cpp index a7f41fc9e..b2319269c 100644 --- a/src/Nazara/Graphics/Material.cpp +++ b/src/Nazara/Graphics/Material.cpp @@ -43,8 +43,8 @@ namespace Nz { auto& uniformBuffer = m_uniformBuffers.emplace_back(); - uniformBuffer.buffer = Graphics::Instance()->GetRenderDevice()->InstantiateBuffer(Nz::BufferType_Uniform); - if (!uniformBuffer.buffer->Initialize(uniformBufferInfo.blockSize, BufferUsage_Dynamic)) + uniformBuffer.buffer = Graphics::Instance()->GetRenderDevice()->InstantiateBuffer(Nz::BufferType::Uniform); + if (!uniformBuffer.buffer->Initialize(uniformBufferInfo.blockSize, BufferUsage::Dynamic)) throw std::runtime_error("failed to initialize UBO memory"); assert(uniformBufferInfo.defaultValues.size() <= uniformBufferInfo.blockSize); diff --git a/src/Nazara/Graphics/ModelInstance.cpp b/src/Nazara/Graphics/ModelInstance.cpp index 8c0095532..33fa75bf4 100644 --- a/src/Nazara/Graphics/ModelInstance.cpp +++ b/src/Nazara/Graphics/ModelInstance.cpp @@ -15,8 +15,8 @@ namespace Nz { Nz::PredefinedInstanceData instanceUboOffsets = Nz::PredefinedInstanceData::GetOffsets(); - m_instanceDataBuffer = Graphics::Instance()->GetRenderDevice()->InstantiateBuffer(BufferType_Uniform); - if (!m_instanceDataBuffer->Initialize(instanceUboOffsets.totalSize, Nz::BufferUsage_DeviceLocal | Nz::BufferUsage_Dynamic)) + m_instanceDataBuffer = Graphics::Instance()->GetRenderDevice()->InstantiateBuffer(BufferType::Uniform); + if (!m_instanceDataBuffer->Initialize(instanceUboOffsets.totalSize, Nz::BufferUsage::DeviceLocal | Nz::BufferUsage::Dynamic)) throw std::runtime_error("failed to initialize viewer data UBO"); m_shaderBinding = settings->GetRenderPipelineLayout()->AllocateShaderBinding(); diff --git a/src/Nazara/Graphics/PhongLightingMaterial.cpp b/src/Nazara/Graphics/PhongLightingMaterial.cpp index c6d8f4297..f5ac9bda4 100644 --- a/src/Nazara/Graphics/PhongLightingMaterial.cpp +++ b/src/Nazara/Graphics/PhongLightingMaterial.cpp @@ -143,13 +143,13 @@ namespace Nz bool PhongLightingMaterial::Initialize() { // MaterialPhongSettings - FieldOffsets phongUniformStruct(StructLayout_Std140); + FieldOffsets phongUniformStruct(StructLayout::Std140); - s_phongUniformOffsets.alphaThreshold = phongUniformStruct.AddField(StructFieldType_Float1); - s_phongUniformOffsets.shininess = phongUniformStruct.AddField(StructFieldType_Float1); - s_phongUniformOffsets.ambientColor = phongUniformStruct.AddField(StructFieldType_Float4); - s_phongUniformOffsets.diffuseColor = phongUniformStruct.AddField(StructFieldType_Float4); - s_phongUniformOffsets.specularColor = phongUniformStruct.AddField(StructFieldType_Float4); + s_phongUniformOffsets.alphaThreshold = phongUniformStruct.AddField(StructFieldType::Float1); + s_phongUniformOffsets.shininess = phongUniformStruct.AddField(StructFieldType::Float1); + s_phongUniformOffsets.ambientColor = phongUniformStruct.AddField(StructFieldType::Float4); + s_phongUniformOffsets.diffuseColor = phongUniformStruct.AddField(StructFieldType::Float4); + s_phongUniformOffsets.specularColor = phongUniformStruct.AddField(StructFieldType::Float4); MaterialSettings::Builder settings; settings.predefinedBinding.fill(MaterialSettings::InvalidIndex); @@ -207,49 +207,49 @@ namespace Nz settings.textures.push_back({ "MaterialAlphaMap", "Alpha", - ImageType_2D + ImageType::E2D }); s_textureIndexes.diffuse = settings.textures.size(); settings.textures.push_back({ "MaterialDiffuseMap", "Diffuse", - ImageType_2D + ImageType::E2D }); s_textureIndexes.emissive = settings.textures.size(); settings.textures.push_back({ "MaterialEmissiveMap", "Emissive", - ImageType_2D + ImageType::E2D }); s_textureIndexes.height = settings.textures.size(); settings.textures.push_back({ "MaterialHeightMap", "Height", - ImageType_2D + ImageType::E2D }); s_textureIndexes.normal = settings.textures.size(); settings.textures.push_back({ "MaterialNormalMap", "Normal", - ImageType_2D + ImageType::E2D }); s_textureIndexes.specular = settings.textures.size(); settings.textures.push_back({ "MaterialSpecularMap", "Specular", - ImageType_2D + ImageType::E2D }); settings.predefinedBinding[UnderlyingCast(PredefinedShaderBinding::TexOverlay)] = settings.textures.size(); settings.textures.push_back({ "TextureOverlay", "Overlay", - ImageType_2D, + ImageType::E2D, }); s_materialSettings = std::make_shared(std::move(settings)); diff --git a/src/Nazara/Graphics/PredefinedShaderStructs.cpp b/src/Nazara/Graphics/PredefinedShaderStructs.cpp index 5280202f2..a781617b5 100644 --- a/src/Nazara/Graphics/PredefinedShaderStructs.cpp +++ b/src/Nazara/Graphics/PredefinedShaderStructs.cpp @@ -12,18 +12,18 @@ namespace Nz { PredefinedLightData lightData; - FieldOffsets lightStruct(StructLayout_Std140); - lightData.innerOffsets.type = lightStruct.AddField(StructFieldType_Int1); - lightData.innerOffsets.color = lightStruct.AddField(StructFieldType_Float4); - lightData.innerOffsets.factor = lightStruct.AddField(StructFieldType_Float2); - lightData.innerOffsets.parameter1 = lightStruct.AddField(StructFieldType_Float4); - lightData.innerOffsets.parameter2 = lightStruct.AddField(StructFieldType_Float4); - lightData.innerOffsets.parameter3 = lightStruct.AddField(StructFieldType_Float2); - lightData.innerOffsets.shadowMappingFlag = lightStruct.AddField(StructFieldType_Bool1); + FieldOffsets lightStruct(StructLayout::Std140); + lightData.innerOffsets.type = lightStruct.AddField(StructFieldType::Int1); + lightData.innerOffsets.color = lightStruct.AddField(StructFieldType::Float4); + lightData.innerOffsets.factor = lightStruct.AddField(StructFieldType::Float2); + lightData.innerOffsets.parameter1 = lightStruct.AddField(StructFieldType::Float4); + lightData.innerOffsets.parameter2 = lightStruct.AddField(StructFieldType::Float4); + lightData.innerOffsets.parameter3 = lightStruct.AddField(StructFieldType::Float2); + lightData.innerOffsets.shadowMappingFlag = lightStruct.AddField(StructFieldType::Bool1); lightData.innerOffsets.totalSize = lightStruct.GetAlignedSize(); - FieldOffsets lightDataStruct(StructLayout_Std140); + FieldOffsets lightDataStruct(StructLayout::Std140); for (std::size_t& lightOffset : lightData.lightArray) lightOffset = lightDataStruct.AddStruct(lightStruct); @@ -56,11 +56,11 @@ namespace Nz PredefinedInstanceData PredefinedInstanceData::GetOffsets() { - FieldOffsets viewerStruct(StructLayout_Std140); + FieldOffsets viewerStruct(StructLayout::Std140); PredefinedInstanceData instanceData; - instanceData.worldMatrixOffset = viewerStruct.AddMatrix(StructFieldType_Float1, 4, 4, true); - instanceData.invWorldMatrixOffset = viewerStruct.AddMatrix(StructFieldType_Float1, 4, 4, true); + instanceData.worldMatrixOffset = viewerStruct.AddMatrix(StructFieldType::Float1, 4, 4, true); + instanceData.invWorldMatrixOffset = viewerStruct.AddMatrix(StructFieldType::Float1, 4, 4, true); instanceData.totalSize = viewerStruct.GetAlignedSize(); @@ -94,18 +94,18 @@ namespace Nz PredefinedViewerData PredefinedViewerData::GetOffsets() { - FieldOffsets viewerStruct(StructLayout_Std140); + FieldOffsets viewerStruct(StructLayout::Std140); PredefinedViewerData viewerData; - viewerData.projMatrixOffset = viewerStruct.AddMatrix(StructFieldType_Float1, 4, 4, true); - viewerData.invProjMatrixOffset = viewerStruct.AddMatrix(StructFieldType_Float1, 4, 4, true); - viewerData.viewMatrixOffset = viewerStruct.AddMatrix(StructFieldType_Float1, 4, 4, true); - viewerData.invViewMatrixOffset = viewerStruct.AddMatrix(StructFieldType_Float1, 4, 4, true); - viewerData.viewProjMatrixOffset = viewerStruct.AddMatrix(StructFieldType_Float1, 4, 4, true); - viewerData.invViewProjMatrixOffset = viewerStruct.AddMatrix(StructFieldType_Float1, 4, 4, true); - viewerData.targetSizeOffset = viewerStruct.AddField(StructFieldType_Float2); - viewerData.invTargetSizeOffset = viewerStruct.AddField(StructFieldType_Float2); - viewerData.eyePositionOffset = viewerStruct.AddField(StructFieldType_Float3); + viewerData.projMatrixOffset = viewerStruct.AddMatrix(StructFieldType::Float1, 4, 4, true); + viewerData.invProjMatrixOffset = viewerStruct.AddMatrix(StructFieldType::Float1, 4, 4, true); + viewerData.viewMatrixOffset = viewerStruct.AddMatrix(StructFieldType::Float1, 4, 4, true); + viewerData.invViewMatrixOffset = viewerStruct.AddMatrix(StructFieldType::Float1, 4, 4, true); + viewerData.viewProjMatrixOffset = viewerStruct.AddMatrix(StructFieldType::Float1, 4, 4, true); + viewerData.invViewProjMatrixOffset = viewerStruct.AddMatrix(StructFieldType::Float1, 4, 4, true); + viewerData.targetSizeOffset = viewerStruct.AddField(StructFieldType::Float2); + viewerData.invTargetSizeOffset = viewerStruct.AddField(StructFieldType::Float2); + viewerData.eyePositionOffset = viewerStruct.AddField(StructFieldType::Float3); viewerData.totalSize = viewerStruct.GetAlignedSize(); diff --git a/src/Nazara/OpenGLRenderer/OpenGLBuffer.cpp b/src/Nazara/OpenGLRenderer/OpenGLBuffer.cpp index b94e2dc8a..61ae3f075 100644 --- a/src/Nazara/OpenGLRenderer/OpenGLBuffer.cpp +++ b/src/Nazara/OpenGLRenderer/OpenGLBuffer.cpp @@ -31,9 +31,9 @@ namespace Nz GL::BufferTarget target; switch (m_type) { - case BufferType_Index: target = GL::BufferTarget::ElementArray; break; - case BufferType_Uniform: target = GL::BufferTarget::Uniform; break; - case BufferType_Vertex: target = GL::BufferTarget::Array; break; + case BufferType::Index: target = GL::BufferTarget::ElementArray; break; + case BufferType::Uniform: target = GL::BufferTarget::Uniform; break; + case BufferType::Vertex: target = GL::BufferTarget::Array; break; default: throw std::runtime_error("unknown buffer type 0x" + NumberToString(UnderlyingCast(m_type), 16)); @@ -41,12 +41,12 @@ namespace Nz GLenum hint = GL_STREAM_COPY; - if (usage & BufferUsage_Dynamic) + if (usage & BufferUsage::Dynamic) hint = GL_DYNAMIC_DRAW; - else if (usage & BufferUsage_DeviceLocal) + else if (usage & BufferUsage::DeviceLocal) hint = GL_STATIC_DRAW; - if (usage & BufferUsage_DirectMapping) + if (usage & BufferUsage::DirectMapping) hint = GL_DYNAMIC_COPY; m_buffer.Reset(target, size, nullptr, hint); @@ -60,7 +60,7 @@ namespace Nz DataStorage OpenGLBuffer::GetStorage() const { - return DataStorage_Hardware; + return DataStorage::Hardware; } void* OpenGLBuffer::Map(BufferAccess access, UInt64 offset, UInt64 size) @@ -68,7 +68,7 @@ namespace Nz GLbitfield accessBit = 0; switch (access) { - case BufferAccess_DiscardAndWrite: + case BufferAccess::DiscardAndWrite: accessBit |= GL_MAP_WRITE_BIT; if (offset == 0 && size == m_size) accessBit |= GL_MAP_INVALIDATE_BUFFER_BIT; @@ -77,15 +77,15 @@ namespace Nz break; - case BufferAccess_ReadOnly: + case BufferAccess::ReadOnly: accessBit |= GL_MAP_READ_BIT; break; - case BufferAccess_ReadWrite: + case BufferAccess::ReadWrite: accessBit |= GL_MAP_READ_BIT | GL_MAP_WRITE_BIT; break; - case BufferAccess_WriteOnly: + case BufferAccess::WriteOnly: accessBit |= GL_MAP_WRITE_BIT; break; diff --git a/src/Nazara/OpenGLRenderer/OpenGLCommandBuffer.cpp b/src/Nazara/OpenGLRenderer/OpenGLCommandBuffer.cpp index c987162e8..4717f234f 100644 --- a/src/Nazara/OpenGLRenderer/OpenGLCommandBuffer.cpp +++ b/src/Nazara/OpenGLRenderer/OpenGLCommandBuffer.cpp @@ -18,39 +18,39 @@ namespace Nz { switch (component) { - case ComponentType_Color: + case ComponentType::Color: attrib.normalized = GL_TRUE; attrib.size = 4; attrib.type = GL_UNSIGNED_BYTE; return; - case ComponentType_Float1: - case ComponentType_Float2: - case ComponentType_Float3: - case ComponentType_Float4: + case ComponentType::Float1: + case ComponentType::Float2: + case ComponentType::Float3: + case ComponentType::Float4: attrib.normalized = GL_FALSE; - attrib.size = (component - ComponentType_Float1 + 1); + attrib.size = (UnderlyingCast(component) - UnderlyingCast(ComponentType::Float1) + 1); attrib.type = GL_FLOAT; return; - case ComponentType_Int1: - case ComponentType_Int2: - case ComponentType_Int3: - case ComponentType_Int4: + case ComponentType::Int1: + case ComponentType::Int2: + case ComponentType::Int3: + case ComponentType::Int4: attrib.normalized = GL_FALSE; - attrib.size = (component - ComponentType_Int1 + 1); + attrib.size = (UnderlyingCast(component) - UnderlyingCast(ComponentType::Int1) + 1); attrib.type = GL_INT; return; - case ComponentType_Double1: - case ComponentType_Double2: - case ComponentType_Double3: - case ComponentType_Double4: - case ComponentType_Quaternion: + case ComponentType::Double1: + case ComponentType::Double2: + case ComponentType::Double3: + case ComponentType::Double4: + case ComponentType::Quaternion: break; } - throw std::runtime_error("component type 0x" + NumberToString(component, 16) + " is not handled"); + throw std::runtime_error("component type 0x" + NumberToString(UnderlyingCast(component), 16) + " is not handled"); } } diff --git a/src/Nazara/OpenGLRenderer/OpenGLFboFramebuffer.cpp b/src/Nazara/OpenGLRenderer/OpenGLFboFramebuffer.cpp index 57ad58cd5..504f09ba8 100644 --- a/src/Nazara/OpenGLRenderer/OpenGLFboFramebuffer.cpp +++ b/src/Nazara/OpenGLRenderer/OpenGLFboFramebuffer.cpp @@ -30,12 +30,12 @@ namespace Nz GLenum attachment; switch (PixelFormatInfo::GetContent(textureFormat)) { - case PixelFormatContent_ColorRGBA: + case PixelFormatContent::ColorRGBA: attachment = static_cast(GL_COLOR_ATTACHMENT0 + colorAttachmentCount); colorAttachmentCount++; break; - case PixelFormatContent_Depth: + case PixelFormatContent::Depth: if (hasDepth) throw std::runtime_error("a framebuffer can only have one depth attachment"); @@ -43,7 +43,7 @@ namespace Nz hasDepth = true; break; - case PixelFormatContent_DepthStencil: + case PixelFormatContent::DepthStencil: if (hasDepth) throw std::runtime_error("a framebuffer can only have one depth attachment"); @@ -55,7 +55,7 @@ namespace Nz hasStencil = true; break; - case PixelFormatContent_Stencil: + case PixelFormatContent::Stencil: if (hasStencil) throw std::runtime_error("a framebuffer can only have one stencil attachment"); @@ -63,7 +63,7 @@ namespace Nz hasStencil = true; break; - case PixelFormatContent_Undefined: + case PixelFormatContent::Undefined: default: throw std::runtime_error("unhandled pixel format " + PixelFormatInfo::GetName(textureFormat)); } diff --git a/src/Nazara/OpenGLRenderer/OpenGLShaderBinding.cpp b/src/Nazara/OpenGLRenderer/OpenGLShaderBinding.cpp index 5bef6dcc7..f1287462c 100644 --- a/src/Nazara/OpenGLRenderer/OpenGLShaderBinding.cpp +++ b/src/Nazara/OpenGLRenderer/OpenGLShaderBinding.cpp @@ -105,7 +105,7 @@ namespace Nz if (OpenGLBuffer* glBuffer = static_cast(uboBinding.buffer)) { - if (glBuffer->GetType() != BufferType_Uniform) + if (glBuffer->GetType() != BufferType::Uniform) throw std::runtime_error("expected uniform buffer"); uboDescriptor.buffer = glBuffer->GetBuffer().GetObjectId(); diff --git a/src/Nazara/OpenGLRenderer/OpenGLTexture.cpp b/src/Nazara/OpenGLRenderer/OpenGLTexture.cpp index abd49e4a8..c0852654f 100644 --- a/src/Nazara/OpenGLRenderer/OpenGLTexture.cpp +++ b/src/Nazara/OpenGLRenderer/OpenGLTexture.cpp @@ -22,23 +22,23 @@ namespace Nz switch (params.type) { - case ImageType_1D: + case ImageType::E1D: break; - case ImageType_1D_Array: + case ImageType::E1D_Array: break; - case ImageType_2D: + case ImageType::E2D: m_texture.TexStorage2D(params.mipmapLevel, format->internalFormat, params.width, params.height); break; - case ImageType_2D_Array: + case ImageType::E2D_Array: break; - case ImageType_3D: + case ImageType::E3D: break; - case ImageType_Cubemap: + case ImageType::Cubemap: break; default: @@ -79,23 +79,23 @@ namespace Nz switch (m_params.type) { - case ImageType_1D: + case ImageType::E1D: break; - case ImageType_1D_Array: + case ImageType::E1D_Array: break; - case ImageType_2D: + case ImageType::E2D: m_texture.TexSubImage2D(0, 0, 0, m_params.width, m_params.height, format->format, format->type, ptr); break; - case ImageType_2D_Array: + case ImageType::E2D_Array: break; - case ImageType_3D: + case ImageType::E3D: break; - case ImageType_Cubemap: + case ImageType::Cubemap: break; default: diff --git a/src/Nazara/Shader/GlslWriter.cpp b/src/Nazara/Shader/GlslWriter.cpp index a3f2dbcca..33099e4f6 100644 --- a/src/Nazara/Shader/GlslWriter.cpp +++ b/src/Nazara/Shader/GlslWriter.cpp @@ -236,12 +236,12 @@ namespace Nz switch (samplerType.dim) { - case ImageType_1D: Append("1D"); break; - case ImageType_1D_Array: Append("1DArray"); break; - case ImageType_2D: Append("2D"); break; - case ImageType_2D_Array: Append("2DArray"); break; - case ImageType_3D: Append("3D"); break; - case ImageType_Cubemap: Append("Cube"); break; + case ImageType::E1D: Append("1D"); break; + case ImageType::E1D_Array: Append("1DArray"); break; + case ImageType::E2D: Append("2D"); break; + case ImageType::E2D_Array: Append("2DArray"); break; + case ImageType::E3D: Append("3D"); break; + case ImageType::Cubemap: Append("Cube"); break; } } @@ -795,7 +795,7 @@ namespace Nz std::size_t structIndex = std::get(uniform.containedType).structIndex; auto& structInfo = Retrieve(m_currentState->structs, structIndex); - isStd140 = structInfo.layout == StructLayout_Std140; + isStd140 = structInfo.layout == StructLayout::Std140; } if (externalVar.bindingIndex) diff --git a/src/Nazara/Shader/LangWriter.cpp b/src/Nazara/Shader/LangWriter.cpp index 9460057b6..ebaae6ea7 100644 --- a/src/Nazara/Shader/LangWriter.cpp +++ b/src/Nazara/Shader/LangWriter.cpp @@ -147,12 +147,12 @@ namespace Nz switch (samplerType.dim) { - case ImageType_1D: Append("1D"); break; - case ImageType_1D_Array: Append("1DArray"); break; - case ImageType_2D: Append("2D"); break; - case ImageType_2D_Array: Append("2DArray"); break; - case ImageType_3D: Append("3D"); break; - case ImageType_Cubemap: Append("Cube"); break; + case ImageType::E1D: Append("1D"); break; + case ImageType::E1D_Array: Append("1DArray"); break; + case ImageType::E2D: Append("2D"); break; + case ImageType::E2D_Array: Append("2DArray"); break; + case ImageType::E3D: Append("3D"); break; + case ImageType::Cubemap: Append("Cube"); break; } Append("<", samplerType.sampledType, ">"); @@ -261,7 +261,7 @@ namespace Nz switch (*entry.layout) { - case StructLayout_Std140: + case StructLayout::Std140: Append("layout(std140)"); break; } diff --git a/src/Nazara/Shader/ShaderLangParser.cpp b/src/Nazara/Shader/ShaderLangParser.cpp index afc4ad32c..fe57c48bb 100644 --- a/src/Nazara/Shader/ShaderLangParser.cpp +++ b/src/Nazara/Shader/ShaderLangParser.cpp @@ -38,7 +38,7 @@ namespace Nz::ShaderLang }; std::unordered_map s_layoutMapping = { - { "std140", StructLayout_Std140 } + { "std140", StructLayout::Std140 } }; template @@ -157,7 +157,7 @@ namespace Nz::ShaderLang Consume(); ShaderAst::SamplerType samplerType; - samplerType.dim = ImageType_2D; + samplerType.dim = ImageType::E2D; Expect(Advance(), TokenType::LessThan); //< '<' samplerType.sampledType = ParsePrimitiveType(); diff --git a/src/Nazara/Shader/SpirvConstantCache.cpp b/src/Nazara/Shader/SpirvConstantCache.cpp index ff3610131..640f45cdc 100644 --- a/src/Nazara/Shader/SpirvConstantCache.cpp +++ b/src/Nazara/Shader/SpirvConstantCache.cpp @@ -846,7 +846,7 @@ namespace Nz annotations.Append(SpirvOp::OpDecorate, resultId, SpirvDecoration::Block); - FieldOffsets structOffsets(StructLayout_Std140); + FieldOffsets structOffsets(StructLayout::Std140); for (std::size_t memberIndex = 0; memberIndex < structData.members.size(); ++memberIndex) { @@ -858,18 +858,18 @@ namespace Nz using T = std::decay_t; if constexpr (std::is_same_v) - return structOffsets.AddField(StructFieldType_Bool1); + return structOffsets.AddField(StructFieldType::Bool1); else if constexpr (std::is_same_v) { switch (arg.width) { - case 32: return structOffsets.AddField(StructFieldType_Float1); - case 64: return structOffsets.AddField(StructFieldType_Double1); + case 32: return structOffsets.AddField(StructFieldType::Float1); + case 64: return structOffsets.AddField(StructFieldType::Double1); default: throw std::runtime_error("unexpected float width " + std::to_string(arg.width)); } } else if constexpr (std::is_same_v) - return structOffsets.AddField((arg.signedness) ? StructFieldType_Int1 : StructFieldType_UInt1); + return structOffsets.AddField((arg.signedness) ? StructFieldType::Int1 : StructFieldType::UInt1); else if constexpr (std::is_same_v) { assert(std::holds_alternative(arg.columnType->type)); @@ -883,8 +883,8 @@ namespace Nz StructFieldType columnType; switch (vecType.width) { - case 32: columnType = StructFieldType_Float1; break; - case 64: columnType = StructFieldType_Double1; break; + case 32: columnType = StructFieldType::Float1; break; + case 64: columnType = StructFieldType::Double1; break; default: throw std::runtime_error("unexpected float width " + std::to_string(vecType.width)); } @@ -905,14 +905,14 @@ namespace Nz else if constexpr (std::is_same_v) { if (std::holds_alternative(arg.componentType->type)) - return structOffsets.AddField(static_cast(StructFieldType_Bool1 + arg.componentCount - 1)); + return structOffsets.AddField(static_cast(UnderlyingCast(StructFieldType::Bool1) + arg.componentCount - 1)); else if (std::holds_alternative(arg.componentType->type)) { Float& floatData = std::get(arg.componentType->type); switch (floatData.width) { - case 32: return structOffsets.AddField(static_cast(StructFieldType_Float1 + arg.componentCount - 1)); - case 64: return structOffsets.AddField(static_cast(StructFieldType_Double1 + arg.componentCount - 1)); + case 32: return structOffsets.AddField(static_cast(UnderlyingCast(StructFieldType::Float1) + arg.componentCount - 1)); + case 64: return structOffsets.AddField(static_cast(UnderlyingCast(StructFieldType::Double1) + arg.componentCount - 1)); default: throw std::runtime_error("unexpected float width " + std::to_string(floatData.width)); } } @@ -923,9 +923,9 @@ namespace Nz throw std::runtime_error("unexpected integer width " + std::to_string(intData.width)); if (intData.signedness) - return structOffsets.AddField(static_cast(StructFieldType_Int1 + arg.componentCount - 1)); + return structOffsets.AddField(static_cast(UnderlyingCast(StructFieldType::Int1) + arg.componentCount - 1)); else - return structOffsets.AddField(static_cast(StructFieldType_UInt1 + arg.componentCount - 1)); + return structOffsets.AddField(static_cast(UnderlyingCast(StructFieldType::UInt1) + arg.componentCount - 1)); } else throw std::runtime_error("unexpected type for vector"); diff --git a/src/Nazara/Utility/AbstractImage.cpp b/src/Nazara/Utility/AbstractImage.cpp index 72a0f7335..1004aa4e1 100644 --- a/src/Nazara/Utility/AbstractImage.cpp +++ b/src/Nazara/Utility/AbstractImage.cpp @@ -22,6 +22,6 @@ namespace Nz bool AbstractImage::IsCubemap() const { - return GetType() == ImageType_Cubemap; + return GetType() == ImageType::Cubemap; } } diff --git a/src/Nazara/Utility/Animation.cpp b/src/Nazara/Utility/Animation.cpp index 635c96694..e51170d33 100644 --- a/src/Nazara/Utility/Animation.cpp +++ b/src/Nazara/Utility/Animation.cpp @@ -8,6 +8,7 @@ #include #include #include +#include #include #include #include @@ -36,19 +37,16 @@ namespace Nz return true; } - Animation::~Animation() - { - OnAnimationRelease(this); - - Destroy(); - } + Animation::Animation() = default; + Animation::Animation(Animation&&) noexcept = default; + Animation::~Animation() = default; bool Animation::AddSequence(const Sequence& sequence) { NazaraAssert(m_impl, "Animation not created"); NazaraAssert(sequence.frameCount > 0, "Sequence frame count must be over zero"); - if (m_impl->type == AnimationType_Skeletal) + if (m_impl->type == AnimationType::Skeletal) { std::size_t endFrame = sequence.firstFrame + sequence.frameCount - 1; if (endFrame >= m_impl->frameCount) @@ -80,7 +78,7 @@ namespace Nz void Animation::AnimateSkeleton(Skeleton* targetSkeleton, std::size_t frameA, std::size_t frameB, float interpolation) const { NazaraAssert(m_impl, "Animation not created"); - NazaraAssert(m_impl->type == AnimationType_Skeletal, "Animation is not skeletal"); + NazaraAssert(m_impl->type == AnimationType::Skeletal, "Animation is not skeletal"); NazaraAssert(targetSkeleton && targetSkeleton->IsValid(), "Invalid skeleton"); NazaraAssert(targetSkeleton->GetJointCount() == m_impl->jointCount, "Skeleton joint does not match animation joint count"); NazaraAssert(frameA < m_impl->frameCount, "FrameA is out of range"); @@ -106,24 +104,18 @@ namespace Nz Destroy(); - m_impl = new AnimationImpl; + m_impl = std::make_unique(); m_impl->frameCount = frameCount; m_impl->jointCount = jointCount; m_impl->sequenceJoints.resize(frameCount*jointCount); - m_impl->type = AnimationType_Skeletal; + m_impl->type = AnimationType::Skeletal; return true; } void Animation::Destroy() { - if (m_impl) - { - OnAnimationDestroy(this); - - delete m_impl; - m_impl = nullptr; - } + m_impl.reset(); } void Animation::EnableLoopPointInterpolation(bool loopPointInterpolation) @@ -215,7 +207,7 @@ namespace Nz SequenceJoint* Animation::GetSequenceJoints(std::size_t frameIndex) { NazaraAssert(m_impl, "Animation not created"); - NazaraAssert(m_impl->type == AnimationType_Skeletal, "Animation is not skeletal"); + NazaraAssert(m_impl->type == AnimationType::Skeletal, "Animation is not skeletal"); return &m_impl->sequenceJoints[frameIndex*m_impl->jointCount]; } @@ -223,7 +215,7 @@ namespace Nz const SequenceJoint* Animation::GetSequenceJoints(std::size_t frameIndex) const { NazaraAssert(m_impl, "Animation not created"); - NazaraAssert(m_impl->type == AnimationType_Skeletal, "Animation is not skeletal"); + NazaraAssert(m_impl->type == AnimationType::Skeletal, "Animation is not skeletal"); return &m_impl->sequenceJoints[frameIndex*m_impl->jointCount]; } @@ -289,46 +281,29 @@ namespace Nz m_impl->sequences.erase(it); } - AnimationRef Animation::LoadFromFile(const std::filesystem::path& filePath, const AnimationParams& params) + Animation& Animation::operator=(Animation&&) noexcept = default; + + std::shared_ptr Animation::LoadFromFile(const std::filesystem::path& filePath, const AnimationParams& params) { - return AnimationLoader::LoadFromFile(filePath, params); + Utility* utility = Utility::Instance(); + NazaraAssert(utility, "Utility module has not been initialized"); + + return utility->GetAnimationLoader().LoadFromFile(filePath, params); } - AnimationRef Animation::LoadFromMemory(const void* data, std::size_t size, const AnimationParams& params) + std::shared_ptr Animation::LoadFromMemory(const void* data, std::size_t size, const AnimationParams& params) { - return AnimationLoader::LoadFromMemory(data, size, params); + Utility* utility = Utility::Instance(); + NazaraAssert(utility, "Utility module has not been initialized"); + + return utility->GetAnimationLoader().LoadFromMemory(data, size, params); } - AnimationRef Animation::LoadFromStream(Stream& stream, const AnimationParams& params) + std::shared_ptr Animation::LoadFromStream(Stream& stream, const AnimationParams& params) { - return AnimationLoader::LoadFromStream(stream, params); + Utility* utility = Utility::Instance(); + NazaraAssert(utility, "Utility module has not been initialized"); + + return utility->GetAnimationLoader().LoadFromStream(stream, params); } - - bool Animation::Initialize() - { - if (!AnimationLibrary::Initialize()) - { - NazaraError("Failed to initialise library"); - return false; - } - - if (!AnimationManager::Initialize()) - { - NazaraError("Failed to initialise manager"); - return false; - } - - return true; - } - - void Animation::Uninitialize() - { - AnimationManager::Uninitialize(); - AnimationLibrary::Uninitialize(); - } - - AnimationLibrary::LibraryMap Animation::s_library; - AnimationLoader::LoaderList Animation::s_loaders; - AnimationManager::ManagerMap Animation::s_managerMap; - AnimationManager::ManagerParams Animation::s_managerParameters; } diff --git a/src/Nazara/Utility/Buffer.cpp b/src/Nazara/Utility/Buffer.cpp index 22ec561e9..390900160 100644 --- a/src/Nazara/Utility/Buffer.cpp +++ b/src/Nazara/Utility/Buffer.cpp @@ -3,6 +3,7 @@ // For conditions of distribution and use, see copyright notice in Config.hpp #include +#include #include #include #include @@ -29,20 +30,13 @@ namespace Nz Create(size, storage, usage); } - Buffer::~Buffer() - { - OnBufferRelease(this); - - Destroy(); - } - - bool Buffer::CopyContent(const BufferRef& buffer) + bool Buffer::CopyContent(const Buffer& buffer) { NazaraAssert(m_impl, "Invalid buffer"); - NazaraAssert(!buffer && !buffer->IsValid(), "Invalid source buffer"); + NazaraAssert(buffer.IsValid(), "Invalid source buffer"); - BufferMapper mapper(*buffer, BufferAccess_ReadOnly); - return Fill(mapper.GetPointer(), 0, buffer->GetSize()); + BufferMapper mapper(buffer, BufferAccess::ReadOnly); + return Fill(mapper.GetPointer(), 0, buffer.GetSize()); } bool Buffer::Create(UInt32 size, DataStorage storage, BufferUsageFlags usage) @@ -56,7 +50,7 @@ namespace Nz return false; } - std::unique_ptr impl(s_bufferFactories[storage](this, m_type)); + std::unique_ptr impl = s_bufferFactories[UnderlyingCast(storage)](this, m_type); if (!impl->Initialize(size, usage)) { NazaraError("Failed to create buffer"); @@ -72,12 +66,7 @@ namespace Nz void Buffer::Destroy() { - if (m_impl) - { - OnBufferDestroy(this); - - m_impl.reset(); - } + m_impl.reset(); } bool Buffer::Fill(const void* data, UInt32 offset, UInt32 size) @@ -99,7 +88,7 @@ namespace Nz void* Buffer::Map(BufferAccess access, UInt32 offset, UInt32 size) const { NazaraAssert(m_impl, "Invalid buffer"); - NazaraAssert(access == BufferAccess_ReadOnly, "Buffer access must be read-only when used const"); + NazaraAssert(access == BufferAccess::ReadOnly, "Buffer access must be read-only when used const"); NazaraAssert(offset + size <= m_size, "Exceeding buffer size"); return m_impl->Map(access, offset, (size == 0) ? m_size - offset : size); @@ -118,7 +107,7 @@ namespace Nz return false; } - void* ptr = m_impl->Map(BufferAccess_ReadOnly, 0, m_size); + void* ptr = m_impl->Map(BufferAccess::ReadOnly, 0, m_size); if (!ptr) { NazaraError("Failed to map buffer"); @@ -130,7 +119,7 @@ namespace Nz m_impl->Unmap(); }); - std::unique_ptr impl(s_bufferFactories[storage](this, m_type)); + std::unique_ptr impl(s_bufferFactories[UnderlyingCast(storage)](this, m_type)); if (!impl->Initialize(m_size, m_usage)) { NazaraError("Failed to create buffer"); @@ -160,19 +149,19 @@ namespace Nz bool Buffer::IsStorageSupported(DataStorage storage) { - return s_bufferFactories[storage] != nullptr; + return s_bufferFactories[UnderlyingCast(storage)] != nullptr; } void Buffer::SetBufferFactory(DataStorage storage, BufferFactory func) { - s_bufferFactories[storage] = func; + s_bufferFactories[UnderlyingCast(storage)] = func; } bool Buffer::Initialize() { - SetBufferFactory(DataStorage_Software, [](Buffer* parent, BufferType type) -> AbstractBuffer* + SetBufferFactory(DataStorage::Software, [](Buffer* parent, BufferType type) -> std::unique_ptr { - return new SoftwareBuffer(parent, type); + return std::make_unique(parent, type); }); return true; @@ -183,5 +172,5 @@ namespace Nz std::fill(s_bufferFactories.begin(), s_bufferFactories.end(), nullptr); } - std::array Buffer::s_bufferFactories; + std::array Buffer::s_bufferFactories; } diff --git a/src/Nazara/Utility/FieldOffsets.cpp b/src/Nazara/Utility/FieldOffsets.cpp index 5e9f229bb..c9aca38e9 100644 --- a/src/Nazara/Utility/FieldOffsets.cpp +++ b/src/Nazara/Utility/FieldOffsets.cpp @@ -26,8 +26,8 @@ namespace Nz std::size_t FieldOffsets::AddFieldArray(StructFieldType type, std::size_t arraySize) { std::size_t fieldAlignement = GetAlignement(m_layout, type); - if (m_layout == StructLayout_Std140) - fieldAlignement = Align(fieldAlignement, GetAlignement(StructLayout_Std140, StructFieldType_Float4)); + if (m_layout == StructLayout::Std140) + fieldAlignement = Align(fieldAlignement, GetAlignement(StructLayout::Std140, StructFieldType::Float4)); m_largestFieldAlignment = std::max(fieldAlignement, m_largestFieldAlignment); @@ -46,9 +46,9 @@ namespace Nz assert(rows >= 2 && rows <= 4); if (columnMajor) - return AddFieldArray(static_cast(cellType + rows - 1), columns); + return AddFieldArray(static_cast(UnderlyingCast(cellType) + rows - 1), columns); else - return AddFieldArray(static_cast(cellType + columns - 1), rows); + return AddFieldArray(static_cast(UnderlyingCast(cellType) + columns - 1), rows); } std::size_t FieldOffsets::AddMatrixArray(StructFieldType cellType, unsigned int columns, unsigned int rows, bool columnMajor, std::size_t arraySize) @@ -58,16 +58,16 @@ namespace Nz assert(rows >= 2 && rows <= 4); if (columnMajor) - return AddFieldArray(static_cast(cellType + rows - 1), columns * arraySize); + return AddFieldArray(static_cast(UnderlyingCast(cellType) + rows - 1), columns * arraySize); else - return AddFieldArray(static_cast(cellType + columns - 1), rows * arraySize); + return AddFieldArray(static_cast(UnderlyingCast(cellType) + columns - 1), rows * arraySize); } std::size_t FieldOffsets::AddStruct(const FieldOffsets& fieldStruct) { std::size_t fieldAlignement = fieldStruct.GetLargestFieldAlignement(); - if (m_layout == StructLayout_Std140) - fieldAlignement = Align(fieldAlignement, GetAlignement(StructLayout_Std140, StructFieldType_Float4)); + if (m_layout == StructLayout::Std140) + fieldAlignement = Align(fieldAlignement, GetAlignement(StructLayout::Std140, StructFieldType::Float4)); m_largestFieldAlignment = std::max(m_largestFieldAlignment, fieldAlignement); @@ -84,8 +84,8 @@ namespace Nz assert(arraySize > 0); std::size_t fieldAlignement = fieldStruct.GetLargestFieldAlignement(); - if (m_layout == StructLayout_Std140) - fieldAlignement = Align(fieldAlignement, GetAlignement(StructLayout_Std140, StructFieldType_Float4)); + if (m_layout == StructLayout::Std140) + fieldAlignement = Align(fieldAlignement, GetAlignement(StructLayout::Std140, StructFieldType::Float4)); m_largestFieldAlignment = std::max(m_largestFieldAlignment, fieldAlignement); diff --git a/src/Nazara/Utility/Font.cpp b/src/Nazara/Utility/Font.cpp index aa91678af..b27750050 100644 --- a/src/Nazara/Utility/Font.cpp +++ b/src/Nazara/Utility/Font.cpp @@ -8,6 +8,7 @@ #include #include #include +#include #include namespace Nz @@ -329,7 +330,7 @@ namespace Nz return s_defaultAtlas; } - const FontRef& Font::GetDefault() + const std::shared_ptr& Font::GetDefault() { // Nous n'initialisons la police par défaut qu'à la demande pour qu'elle prenne // les paramètres par défaut (qui peuvent avoir étés changés par l'utilisateur), @@ -355,19 +356,28 @@ namespace Nz return s_defaultMinimumStepSize; } - FontRef Font::OpenFromFile(const std::filesystem::path& filePath, const FontParams& params) + std::shared_ptr Font::OpenFromFile(const std::filesystem::path& filePath, const FontParams& params) { - return FontLoader::LoadFromFile(filePath, params); + Utility* utility = Utility::Instance(); + NazaraAssert(utility, "Utility module has not been initialized"); + + return utility->GetFontLoader().LoadFromFile(filePath, params); } - FontRef Font::OpenFromMemory(const void* data, std::size_t size, const FontParams& params) + std::shared_ptr Font::OpenFromMemory(const void* data, std::size_t size, const FontParams& params) { - return FontLoader::LoadFromMemory(data, size, params); + Utility* utility = Utility::Instance(); + NazaraAssert(utility, "Utility module has not been initialized"); + + return utility->GetFontLoader().LoadFromMemory(data, size, params); } - FontRef Font::OpenFromStream(Stream& stream, const FontParams& params) + std::shared_ptr Font::OpenFromStream(Stream& stream, const FontParams& params) { - return FontLoader::LoadFromStream(stream, params); + Utility* utility = Utility::Instance(); + NazaraAssert(utility, "Utility module has not been initialized"); + + return utility->GetFontLoader().LoadFromStream(stream, params); } void Font::SetDefaultAtlas(const std::shared_ptr& atlas) @@ -401,10 +411,10 @@ namespace Nz sizeStylePart <<= 2; // Store bold and italic flags (other style are handled directly by a TextDrawer) - if (style & TextStyle_Bold) + if (style & TextStyle::Bold) sizeStylePart |= 1 << 0; - if (style & TextStyle_Italic) + if (style & TextStyle::Italic) sizeStylePart |= 1 << 1; return (sizeStylePart << 32) | reinterpret_cast(outlineThickness); @@ -488,16 +498,16 @@ namespace Nz glyph.requireFauxItalic = false; TextStyleFlags supportedStyle = style; - if (style & TextStyle_Bold && !m_data->SupportsStyle(TextStyle_Bold)) + if (style & TextStyle::Bold && !m_data->SupportsStyle(TextStyle::Bold)) { glyph.requireFauxBold = true; - supportedStyle &= ~TextStyle_Bold; + supportedStyle &= ~TextStyle::Bold; } - if (style & TextStyle_Italic && !m_data->SupportsStyle(TextStyle_Italic)) + if (style & TextStyle::Italic && !m_data->SupportsStyle(TextStyle::Italic)) { glyph.requireFauxItalic = true; - supportedStyle &= ~TextStyle_Italic; + supportedStyle &= ~TextStyle::Italic; } float supportedOutlineThickness = outlineThickness; @@ -572,13 +582,7 @@ namespace Nz bool Font::Initialize() { - if (!FontLibrary::Initialize()) - { - NazaraError("Failed to initialise library"); - return false; - } - - s_defaultAtlas.reset(new GuillotineImageAtlas); + s_defaultAtlas = std::make_shared(); s_defaultGlyphBorder = 1; s_defaultMinimumStepSize = 1; @@ -588,14 +592,11 @@ namespace Nz void Font::Uninitialize() { s_defaultAtlas.reset(); - s_defaultFont.Reset(); - FontLibrary::Uninitialize(); + s_defaultFont.reset(); } std::shared_ptr Font::s_defaultAtlas; - FontRef Font::s_defaultFont; - FontLibrary::LibraryMap Font::s_library; - FontLoader::LoaderList Font::s_loaders; + std::shared_ptr Font::s_defaultFont; unsigned int Font::s_defaultGlyphBorder; -unsigned int Font::s_defaultMinimumStepSize; + unsigned int Font::s_defaultMinimumStepSize; } diff --git a/src/Nazara/Utility/Formats/DDSLoader.cpp b/src/Nazara/Utility/Formats/DDSLoader.cpp index 2b16f0a93..f157889b8 100644 --- a/src/Nazara/Utility/Formats/DDSLoader.cpp +++ b/src/Nazara/Utility/Formats/DDSLoader.cpp @@ -18,7 +18,7 @@ namespace Nz DDSLoader() = delete; ~DDSLoader() = delete; - static bool IsSupported(const std::string& extension) + static bool IsSupported(const std::string_view& extension) { return (extension == "dds"); } @@ -38,7 +38,7 @@ namespace Nz return (magic == DDS_Magic) ? Ternary::True : Ternary::False; } - static ImageRef Load(Stream& stream, const ImageParams& parameters) + static std::shared_ptr Load(Stream& stream, const ImageParams& parameters) { NazaraUnused(parameters); @@ -88,7 +88,7 @@ namespace Nz if (!IdentifyPixelFormat(header, headerDX10, &format)) return nullptr; - ImageRef image = Image::New(type, format, width, height, depth, levelCount); + std::shared_ptr image = std::make_shared(type, format, width, height, depth, levelCount); // Read all mipmap levels for (unsigned int i = 0; i < image->GetLevelCount(); i++) @@ -114,7 +114,7 @@ namespace Nz } - if (parameters.loadFormat != PixelFormat_Undefined) + if (parameters.loadFormat != PixelFormat::Undefined) image->Convert(parameters.loadFormat); return image; @@ -131,9 +131,9 @@ namespace Nz return false; } else if (header.flags & DDSD_HEIGHT) - *type = ImageType_2D_Array; + *type = ImageType::E2D_Array; else - *type = ImageType_1D_Array; + *type = ImageType::E1D_Array; } else { @@ -145,7 +145,7 @@ namespace Nz return false; } - *type = ImageType_Cubemap; + *type = ImageType::Cubemap; } else if (headerExt.resourceDimension == D3D10_RESOURCE_DIMENSION_BUFFER) { @@ -153,11 +153,11 @@ namespace Nz return false; } else if (headerExt.resourceDimension == D3D10_RESOURCE_DIMENSION_TEXTURE1D) - *type = ImageType_1D; + *type = ImageType::E1D; else if (header.ddsCaps[1] & DDSCAPS2_VOLUME || header.flags & DDSD_DEPTH || headerExt.resourceDimension == D3D10_RESOURCE_DIMENSION_TEXTURE3D) - *type = ImageType_3D; + *type = ImageType::E3D; else - *type = ImageType_2D; + *type = ImageType::E2D; } return true; @@ -167,7 +167,7 @@ namespace Nz { if (header.format.flags & (DDPF_RGB | DDPF_ALPHA | DDPF_ALPHAPIXELS | DDPF_LUMINANCE)) { - PixelFormatDescription info(PixelFormatContent_ColorRGBA, header.format.bpp, PixelFormatSubType_Unsigned); + PixelFormatDescription info(PixelFormatContent::ColorRGBA, header.format.bpp, PixelFormatSubType::Unsigned); if (header.format.flags & DDPF_RGB) { @@ -191,15 +191,15 @@ namespace Nz switch (header.format.fourCC) { case D3DFMT_DXT1: - *format = PixelFormat_DXT1; + *format = PixelFormat::DXT1; break; case D3DFMT_DXT3: - *format = PixelFormat_DXT3; + *format = PixelFormat::DXT3; break; case D3DFMT_DXT5: - *format = PixelFormat_DXT3; + *format = PixelFormat::DXT3; break; case D3DFMT_DX10: @@ -207,30 +207,35 @@ namespace Nz switch (headerExt.dxgiFormat) { case DXGI_FORMAT_R32G32B32A32_FLOAT: - *format = PixelFormat_RGBA32F; + *format = PixelFormat::RGBA32F; break; case DXGI_FORMAT_R32G32B32A32_UINT: - *format = PixelFormat_RGBA32UI; + *format = PixelFormat::RGBA32UI; break; case DXGI_FORMAT_R32G32B32A32_SINT: - *format = PixelFormat_RGBA32I; + *format = PixelFormat::RGBA32I; break; case DXGI_FORMAT_R32G32B32_FLOAT: - *format = PixelFormat_RGB32F; + *format = PixelFormat::RGB32F; break; case DXGI_FORMAT_R32G32B32_UINT: - //*format = PixelFormat_RGB32U; + //*format = PixelFormat::RGB32U; return false; case DXGI_FORMAT_R32G32B32_SINT: - *format = PixelFormat_RGB32I; + *format = PixelFormat::RGB32I; break; case DXGI_FORMAT_R16G16B16A16_SNORM: case DXGI_FORMAT_R16G16B16A16_SINT: case DXGI_FORMAT_R16G16B16A16_UINT: - *format = PixelFormat_RGBA16I; + *format = PixelFormat::RGBA16I; break; case DXGI_FORMAT_R16G16B16A16_UNORM: - *format = PixelFormat_RGBA16UI; + *format = PixelFormat::RGBA16UI; + break; + + default: + //TODO + NazaraError("TODO"); break; } break; @@ -262,14 +267,14 @@ namespace Nz namespace Loaders { - void RegisterDDSLoader() + ImageLoader::Entry GetImageLoader_DDS() { - ImageLoader::RegisterLoader(DDSLoader::IsSupported, DDSLoader::Check, DDSLoader::Load); - } + ImageLoader::Entry loaderEntry; + loaderEntry.extensionSupport = DDSLoader::IsSupported; + loaderEntry.streamChecker = DDSLoader::Check; + loaderEntry.streamLoader = DDSLoader::Load; - void UnregisterDDSLoader() - { - ImageLoader::UnregisterLoader(DDSLoader::IsSupported, DDSLoader::Check, DDSLoader::Load); + return loaderEntry; } } } diff --git a/src/Nazara/Utility/Formats/DDSLoader.hpp b/src/Nazara/Utility/Formats/DDSLoader.hpp index 97dca0e83..563eafb03 100644 --- a/src/Nazara/Utility/Formats/DDSLoader.hpp +++ b/src/Nazara/Utility/Formats/DDSLoader.hpp @@ -8,14 +8,11 @@ #define NAZARA_LOADERS_DDS_HPP #include +#include -namespace Nz +namespace Nz::Loaders { - namespace Loaders - { - void RegisterDDSLoader(); - void UnregisterDDSLoader(); - } + ImageLoader::Entry GetImageLoader_DDS(); } #endif // NAZARA_LOADERS_DDS_HPP diff --git a/src/Nazara/Utility/Formats/FreeTypeLoader.cpp b/src/Nazara/Utility/Formats/FreeTypeLoader.cpp index 1abd9292e..09fe7b457 100644 --- a/src/Nazara/Utility/Formats/FreeTypeLoader.cpp +++ b/src/Nazara/Utility/Formats/FreeTypeLoader.cpp @@ -145,7 +145,7 @@ namespace Nz const FT_Pos boldStrength = 2 << 6; - bool embolden = (style & TextStyle_Bold) != 0; + bool embolden = (style & TextStyle::Bold) != 0; bool hasOutlineFormat = (glyph->format == FT_GLYPH_FORMAT_OUTLINE); dst->advance = (embolden) ? boldStrength >> 6 : 0; @@ -202,7 +202,7 @@ namespace Nz if (width > 0 && height > 0) { - dst->image.Create(ImageType_2D, PixelFormat_A8, width, height); + dst->image.Create(ImageType::E2D, PixelFormat::A8, width, height); UInt8* pixels = dst->image.GetPixels(); const UInt8* data = bitmap.buffer; @@ -363,7 +363,7 @@ namespace Nz bool SupportsStyle(TextStyleFlags style) const override { ///TODO - return style == TextStyle_Regular || style == TextStyle_Bold; + return style == TextStyle_Regular || style == TextStyle::Bold; } private: @@ -384,10 +384,10 @@ namespace Nz mutable unsigned int m_characterSize; }; - bool IsSupported(const std::string& extension) + bool IsSupported(const std::string_view& extension) { ///FIXME: Je suppose qu'il en manque quelques unes.. - static std::set supportedExtensions = { + static std::set supportedExtensions = { "afm", "bdf", "cff", "cid", "dfont", "fnt", "fon", "otf", "pfa", "pfb", "pfm", "pfr", "sfnt", "ttc", "tte", "ttf" }; @@ -409,7 +409,7 @@ namespace Nz return Ternary::False; } - FontRef LoadFile(const std::filesystem::path& filePath, const FontParams& parameters) + std::shared_ptr LoadFile(const std::filesystem::path& filePath, const FontParams& parameters) { NazaraUnused(parameters); @@ -426,7 +426,7 @@ namespace Nz return nullptr; } - FontRef font = Font::New(); + std::shared_ptr font = std::make_shared(); if (font->Create(face.get())) { face.release(); @@ -436,7 +436,7 @@ namespace Nz return nullptr; } - FontRef LoadMemory(const void* data, std::size_t size, const FontParams& parameters) + std::shared_ptr LoadMemory(const void* data, std::size_t size, const FontParams& parameters) { NazaraUnused(parameters); @@ -449,7 +449,7 @@ namespace Nz return nullptr; } - FontRef font = Font::New(); + std::shared_ptr font = std::make_shared(); if (font->Create(face.get())) { face.release(); @@ -459,7 +459,7 @@ namespace Nz return nullptr; } - FontRef LoadStream(Stream& stream, const FontParams& parameters) + std::shared_ptr LoadStream(Stream& stream, const FontParams& parameters) { NazaraUnused(parameters); @@ -472,7 +472,7 @@ namespace Nz return nullptr; } - FontRef font = Font::New(); + std::shared_ptr font = std::make_shared(); if (font->Create(face.get())) { face.release(); @@ -485,27 +485,36 @@ namespace Nz namespace Loaders { - void RegisterFreeType() + bool InitializeFreeType() { - if (FT_Init_FreeType(&s_library) == 0) + NazaraAssert(!s_libraryOwner, "double initialization for FreeType"); + if (FT_Init_FreeType(&s_library) != 0) { - s_libraryOwner = std::make_shared(); - FontLoader::RegisterLoader(IsSupported, Check, LoadStream, LoadFile, LoadMemory); - } - else - { - s_library = nullptr; // On s'assure que le pointeur ne pointe pas sur n'importe quoi - NazaraWarning("Failed to initialize FreeType library"); + NazaraWarning("failed to initialize FreeType library"); + return false; } + + s_libraryOwner = std::make_shared(); + return true; } - void UnregisterFreeType() + FontLoader::Entry GetFontLoader_FreeType() { - if (s_library) - { - FontLoader::UnregisterLoader(IsSupported, Check, LoadStream, LoadFile, LoadMemory); - s_libraryOwner.reset(); - } + NazaraAssert(s_libraryOwner, "FreeType has not been initialized"); + + FontLoader::Entry entry; + entry.extensionSupport = IsSupported; + entry.fileLoader = LoadFile; + entry.memoryLoader = LoadMemory; + entry.streamChecker = Check; + entry.streamLoader = LoadStream; + + return entry; + } + + void UninitializeFreeType() + { + s_libraryOwner.reset(); } } } diff --git a/src/Nazara/Utility/Formats/FreeTypeLoader.hpp b/src/Nazara/Utility/Formats/FreeTypeLoader.hpp index c26e63c4a..d37b1ac8f 100644 --- a/src/Nazara/Utility/Formats/FreeTypeLoader.hpp +++ b/src/Nazara/Utility/Formats/FreeTypeLoader.hpp @@ -8,14 +8,13 @@ #define NAZARA_LOADERS_FREETYPE_HPP #include +#include -namespace Nz +namespace Nz::Loaders { - namespace Loaders - { - void RegisterFreeType(); - void UnregisterFreeType(); - } + bool InitializeFreeType(); + FontLoader::Entry GetFontLoader_FreeType(); + void UninitializeFreeType(); } #endif // NAZARA_LOADERS_FREETYPE_HPP diff --git a/src/Nazara/Utility/Formats/MD2Loader.cpp b/src/Nazara/Utility/Formats/MD2Loader.cpp index 03ce610bd..395007750 100644 --- a/src/Nazara/Utility/Formats/MD2Loader.cpp +++ b/src/Nazara/Utility/Formats/MD2Loader.cpp @@ -20,7 +20,7 @@ namespace Nz { namespace { - bool IsSupported(const std::string& extension) + bool IsSupported(const std::string_view& extension) { return (extension == "md2"); } @@ -46,7 +46,7 @@ namespace Nz return Ternary::False; } - MeshRef Load(Stream& stream, const MeshParams& parameters) + std::shared_ptr Load(Stream& stream, const MeshParams& parameters) { MD2_Header header; if (stream.Read(&header, sizeof(MD2_Header)) != sizeof(MD2_Header)) @@ -80,7 +80,7 @@ namespace Nz } // Since the engine no longer supports keyframe animations, let's make a static mesh - MeshRef mesh = Nz::Mesh::New(); + std::shared_ptr mesh = std::make_shared(); if (!mesh->CreateStatic()) { NazaraInternalError("Failed to create mesh"); @@ -107,7 +107,7 @@ namespace Nz } } - IndexBufferRef indexBuffer = IndexBuffer::New(false, header.num_tris*3, parameters.storage, parameters.indexBufferFlags); + std::shared_ptr indexBuffer = std::make_shared(false, header.num_tris*3, parameters.storage, parameters.indexBufferFlags); // Extract triangles data std::vector triangles(header.num_tris); @@ -116,7 +116,7 @@ namespace Nz stream.Read(&triangles[0], header.num_tris*sizeof(MD2_Triangle)); // And convert them into an index buffer - BufferMapper indexMapper(indexBuffer, BufferAccess_DiscardAndWrite); + BufferMapper indexMapper(*indexBuffer, BufferAccess::DiscardAndWrite); UInt16* index = static_cast(indexMapper.GetPointer()); for (unsigned int i = 0; i < header.num_tris; ++i) @@ -158,8 +158,8 @@ namespace Nz } #endif - VertexBufferRef vertexBuffer = VertexBuffer::New(parameters.vertexDeclaration, header.num_vertices, parameters.storage, parameters.vertexBufferFlags); - StaticMeshRef subMesh = StaticMesh::New(vertexBuffer, indexBuffer); + std::shared_ptr vertexBuffer = std::make_shared(parameters.vertexDeclaration, header.num_vertices, parameters.storage, parameters.vertexBufferFlags); + std::shared_ptr subMesh = std::make_shared(vertexBuffer, indexBuffer); // Extracting vertices stream.SetCursorPos(header.offset_frames); @@ -186,10 +186,10 @@ namespace Nz scale *= ScaleAdjust; translate *= ScaleAdjust; - VertexMapper vertexMapper(vertexBuffer, BufferAccess_DiscardAndWrite); + VertexMapper vertexMapper(*vertexBuffer, BufferAccess::DiscardAndWrite); // Loading texture coordinates - if (auto uvPtr = vertexMapper.GetComponentPtr(VertexComponent_TexCoord)) + if (auto uvPtr = vertexMapper.GetComponentPtr(VertexComponent::TexCoord)) { const unsigned int indexFix[3] = {0, 2, 1}; @@ -214,7 +214,7 @@ namespace Nz Nz::Matrix4f matrix = Matrix4f::Transform(translate, rotationQuat, scale); matrix *= parameters.matrix; - if (auto normalPtr = vertexMapper.GetComponentPtr(VertexComponent_Normal)) + if (auto normalPtr = vertexMapper.GetComponentPtr(VertexComponent::Normal)) { Nz::Matrix4f normalMatrix = Matrix4f::Rotate(rotationQuat); normalMatrix *= parameters.matrix; @@ -227,7 +227,7 @@ namespace Nz } } - auto posPtr = vertexMapper.GetComponentPtr(VertexComponent_Position); + auto posPtr = vertexMapper.GetComponentPtr(VertexComponent::Position); assert(posPtr); for (unsigned int v = 0; v < header.num_vertices; ++v) @@ -244,7 +244,7 @@ namespace Nz subMesh->GenerateAABB(); - if (parameters.vertexDeclaration->HasComponentOfType(VertexComponent_Tangent)) + if (parameters.vertexDeclaration->HasComponentOfType(VertexComponent::Tangent)) subMesh->GenerateTangents(); mesh->AddSubMesh(subMesh); @@ -258,14 +258,14 @@ namespace Nz namespace Loaders { - void RegisterMD2() + MeshLoader::Entry GetMeshLoader_MD2() { - MeshLoader::RegisterLoader(IsSupported, Check, Load); - } + MeshLoader::Entry loader; + loader.extensionSupport = IsSupported; + loader.streamChecker = Check; + loader.streamLoader = Load; - void UnregisterMD2() - { - MeshLoader::UnregisterLoader(IsSupported, Check, Load); + return loader; } } } diff --git a/src/Nazara/Utility/Formats/MD2Loader.hpp b/src/Nazara/Utility/Formats/MD2Loader.hpp index 208a8bbf5..a72dac946 100644 --- a/src/Nazara/Utility/Formats/MD2Loader.hpp +++ b/src/Nazara/Utility/Formats/MD2Loader.hpp @@ -8,14 +8,11 @@ #define NAZARA_LOADERS_MD2_HPP #include +#include -namespace Nz +namespace Nz::Loaders { - namespace Loaders - { - void RegisterMD2(); - void UnregisterMD2(); - } + MeshLoader::Entry GetMeshLoader_MD2(); } #endif // NAZARA_LOADERS_MD2_HPP diff --git a/src/Nazara/Utility/Formats/MD5AnimLoader.cpp b/src/Nazara/Utility/Formats/MD5AnimLoader.cpp index b07dff80f..7afa29a0d 100644 --- a/src/Nazara/Utility/Formats/MD5AnimLoader.cpp +++ b/src/Nazara/Utility/Formats/MD5AnimLoader.cpp @@ -12,7 +12,7 @@ namespace Nz { namespace { - bool IsSupported(const std::string& extension) + bool IsSupported(const std::string_view& extension) { return (extension == "md5anim"); } @@ -27,7 +27,7 @@ namespace Nz return parser.Check(); } - AnimationRef Load(Stream& stream, const AnimationParams& /*parameters*/) + std::shared_ptr Load(Stream& stream, const AnimationParams& /*parameters*/) { ///TODO: Utiliser les paramètres MD5AnimParser parser(stream); @@ -45,7 +45,7 @@ namespace Nz std::size_t jointCount = parser.GetJointCount(); // À ce stade, nous sommes censés avoir assez d'informations pour créer l'animation - AnimationRef animation = Animation::New(); + std::shared_ptr animation = std::make_shared(); animation->CreateSkeletal(frameCount, jointCount); Sequence sequence; @@ -90,14 +90,14 @@ namespace Nz namespace Loaders { - void RegisterMD5Anim() + AnimationLoader::Entry GetAnimationLoader_MD5Anim() { - AnimationLoader::RegisterLoader(IsSupported, Check, Load); - } + AnimationLoader::Entry loader; + loader.extensionSupport = IsSupported; + loader.streamChecker = Check; + loader.streamLoader = Load; - void UnregisterMD5Anim() - { - AnimationLoader::UnregisterLoader(IsSupported, Check, Load); + return loader; } } } diff --git a/src/Nazara/Utility/Formats/MD5AnimLoader.hpp b/src/Nazara/Utility/Formats/MD5AnimLoader.hpp index e84729106..e53ec55fe 100644 --- a/src/Nazara/Utility/Formats/MD5AnimLoader.hpp +++ b/src/Nazara/Utility/Formats/MD5AnimLoader.hpp @@ -8,14 +8,11 @@ #define NAZARA_LOADERS_MD5ANIM_HPP #include +#include -namespace Nz +namespace Nz::Loaders { - namespace Loaders - { - void RegisterMD5Anim(); - void UnregisterMD5Anim(); - } + AnimationLoader::Entry GetAnimationLoader_MD5Anim(); } #endif // NAZARA_LOADERS_MD5ANIM_HPP diff --git a/src/Nazara/Utility/Formats/MD5MeshLoader.cpp b/src/Nazara/Utility/Formats/MD5MeshLoader.cpp index aebcf8396..7a6ba60e1 100644 --- a/src/Nazara/Utility/Formats/MD5MeshLoader.cpp +++ b/src/Nazara/Utility/Formats/MD5MeshLoader.cpp @@ -20,7 +20,7 @@ namespace Nz { namespace { - bool IsSupported(const std::string& extension) + bool IsSupported(const std::string_view& extension) { return (extension == "md5mesh"); } @@ -35,7 +35,7 @@ namespace Nz return parser.Check(); } - MeshRef Load(Stream& stream, const MeshParams& parameters) + std::shared_ptr Load(Stream& stream, const MeshParams& parameters) { MD5MeshParser parser(stream); if (!parser.Parse()) @@ -62,7 +62,7 @@ namespace Nz if (parameters.animated) { - MeshRef mesh = Mesh::New(); + std::shared_ptr mesh = std::make_shared(); mesh->CreateSkeletal(jointCount); Skeleton* skeleton = mesh->GetSkeleton(); @@ -96,11 +96,11 @@ namespace Nz bool largeIndices = (vertexCount > std::numeric_limits::max()); - IndexBufferRef indexBuffer = IndexBuffer::New(largeIndices, UInt32(indexCount), parameters.storage, parameters.indexBufferFlags); - VertexBufferRef vertexBuffer = VertexBuffer::New(VertexDeclaration::Get(VertexLayout_XYZ_Normal_UV_Tangent_Skinning), UInt32(vertexCount), parameters.storage, parameters.vertexBufferFlags); + std::shared_ptr indexBuffer = std::make_shared(largeIndices, UInt32(indexCount), parameters.storage, parameters.indexBufferFlags); + std::shared_ptr vertexBuffer = std::make_shared(VertexDeclaration::Get(VertexLayout::XYZ_Normal_UV_Tangent_Skinning), UInt32(vertexCount), parameters.storage, parameters.vertexBufferFlags); // Index buffer - IndexMapper indexMapper(indexBuffer, BufferAccess_DiscardAndWrite); + IndexMapper indexMapper(*indexBuffer, BufferAccess::DiscardAndWrite); // Le format définit un set de triangles nous permettant de retrouver facilement les indices // Cependant les sommets des triangles ne sont pas spécifiés dans le même ordre que ceux du moteur @@ -128,7 +128,7 @@ namespace Nz std::vector tempWeights; - BufferMapper vertexMapper(vertexBuffer, BufferAccess_WriteOnly); + BufferMapper vertexMapper(*vertexBuffer, BufferAccess::WriteOnly); SkeletalMeshVertex* vertices = static_cast(vertexMapper.GetPointer()); for (const MD5MeshParser::Vertex& vertex : md5Mesh.vertices) @@ -203,7 +203,7 @@ namespace Nz mesh->SetMaterialData(i, std::move(matData)); // Submesh - SkeletalMeshRef subMesh = SkeletalMesh::New(vertexBuffer, indexBuffer); + std::shared_ptr subMesh = std::make_shared(vertexBuffer, indexBuffer); subMesh->GenerateNormalsAndTangents(); subMesh->SetMaterialIndex(i); @@ -224,7 +224,7 @@ namespace Nz } else { - MeshRef mesh = Mesh::New(); + std::shared_ptr mesh = std::make_shared(); if (!mesh->CreateStatic()) // Ne devrait jamais échouer { NazaraInternalError("Failed to create mesh"); @@ -241,9 +241,9 @@ namespace Nz // Index buffer bool largeIndices = (vertexCount > std::numeric_limits::max()); - IndexBufferRef indexBuffer = IndexBuffer::New(largeIndices, UInt32(indexCount), parameters.storage, parameters.indexBufferFlags); + std::shared_ptr indexBuffer = std::make_shared(largeIndices, UInt32(indexCount), parameters.storage, parameters.indexBufferFlags); - IndexMapper indexMapper(indexBuffer, BufferAccess_DiscardAndWrite); + IndexMapper indexMapper(*indexBuffer, BufferAccess::DiscardAndWrite); IndexIterator index = indexMapper.begin(); for (const MD5MeshParser::Triangle& triangle : md5Mesh.triangles) @@ -259,11 +259,11 @@ namespace Nz indexBuffer->Optimize(); // Vertex buffer - VertexBufferRef vertexBuffer = VertexBuffer::New(parameters.vertexDeclaration, UInt32(vertexCount), parameters.storage, parameters.vertexBufferFlags); + std::shared_ptr vertexBuffer = std::make_shared(parameters.vertexDeclaration, UInt32(vertexCount), parameters.storage, parameters.vertexBufferFlags); - VertexMapper vertexMapper(vertexBuffer, BufferAccess_DiscardAndWrite); + VertexMapper vertexMapper(*vertexBuffer, BufferAccess::DiscardAndWrite); - auto posPtr = vertexMapper.GetComponentPtr(VertexComponent_Position); + auto posPtr = vertexMapper.GetComponentPtr(VertexComponent::Position); for (const MD5MeshParser::Vertex& md5Vertex : md5Mesh.vertices) { @@ -281,7 +281,7 @@ namespace Nz *posPtr++ = matrix * finalPos; } - if (auto uvPtr = vertexMapper.GetComponentPtr(VertexComponent_TexCoord)) + if (auto uvPtr = vertexMapper.GetComponentPtr(VertexComponent::TexCoord)) { for (const MD5MeshParser::Vertex& md5Vertex : md5Mesh.vertices) *uvPtr++ = parameters.texCoordOffset + md5Vertex.uv * parameters.texCoordScale; @@ -290,13 +290,13 @@ namespace Nz vertexMapper.Unmap(); // Submesh - StaticMeshRef subMesh = StaticMesh::New(vertexBuffer, indexBuffer); + std::shared_ptr subMesh = std::make_shared(vertexBuffer, indexBuffer); subMesh->GenerateAABB(); subMesh->SetMaterialIndex(i); - if (parameters.vertexDeclaration->HasComponentOfType(VertexComponent_Normal)) + if (parameters.vertexDeclaration->HasComponentOfType(VertexComponent::Normal)) { - if (parameters.vertexDeclaration->HasComponentOfType(VertexComponent_Tangent)) + if (parameters.vertexDeclaration->HasComponentOfType(VertexComponent::Tangent)) subMesh->GenerateNormalsAndTangents(); else subMesh->GenerateNormals(); @@ -321,14 +321,14 @@ namespace Nz namespace Loaders { - void RegisterMD5Mesh() + MeshLoader::Entry GetMeshLoader_MD5Mesh() { - MeshLoader::RegisterLoader(IsSupported, Check, Load); - } + MeshLoader::Entry loader; + loader.extensionSupport = IsSupported; + loader.streamChecker = Check; + loader.streamLoader = Load; - void UnregisterMD5Mesh() - { - MeshLoader::UnregisterLoader(IsSupported, Check, Load); + return loader; } } } diff --git a/src/Nazara/Utility/Formats/MD5MeshLoader.hpp b/src/Nazara/Utility/Formats/MD5MeshLoader.hpp index 0a0fb5af4..cc5d5f30b 100644 --- a/src/Nazara/Utility/Formats/MD5MeshLoader.hpp +++ b/src/Nazara/Utility/Formats/MD5MeshLoader.hpp @@ -8,14 +8,11 @@ #define NAZARA_LOADERS_MD5MESH_HPP #include +#include -namespace Nz +namespace Nz::Loaders { - namespace Loaders - { - void RegisterMD5Mesh(); - void UnregisterMD5Mesh(); - } + MeshLoader::Entry GetMeshLoader_MD5Mesh(); } #endif // NAZARA_LOADERS_MD5MESH_HPP diff --git a/src/Nazara/Utility/Formats/OBJLoader.cpp b/src/Nazara/Utility/Formats/OBJLoader.cpp index 10e889d2f..7641aa018 100644 --- a/src/Nazara/Utility/Formats/OBJLoader.cpp +++ b/src/Nazara/Utility/Formats/OBJLoader.cpp @@ -22,7 +22,7 @@ namespace Nz { namespace { - bool IsSupported(const std::string& extension) + bool IsSupported(const std::string_view& extension) { return (extension == "obj"); } @@ -42,7 +42,7 @@ namespace Nz return Ternary::Unknown; } - bool ParseMTL(Mesh* mesh, const std::filesystem::path& filePath, const std::string* materials, const OBJParser::Mesh* meshes, std::size_t meshCount) + bool ParseMTL(Mesh& mesh, const std::filesystem::path& filePath, const std::string* materials, const OBJParser::Mesh* meshes, std::size_t meshCount) { File file(filePath); if (!file.Open(OpenMode_ReadOnly | OpenMode_Text)) @@ -151,13 +151,13 @@ namespace Nz it = materialCache.emplace(matName, std::move(data)).first; } - mesh->SetMaterialData(meshes[i].material, it->second); + mesh.SetMaterialData(meshes[i].material, it->second); } return true; } - MeshRef Load(Stream& stream, const MeshParams& parameters) + std::shared_ptr Load(Stream& stream, const MeshParams& parameters) { long long reservedVertexCount; if (!parameters.custom.GetIntegerParameter("NativeOBJLoader_VertexCount", &reservedVertexCount)) @@ -170,7 +170,7 @@ namespace Nz return nullptr; } - MeshRef mesh = Mesh::New(); + std::shared_ptr mesh = std::make_shared(); mesh->CreateStatic(); const std::string* materials = parser.GetMaterials(); @@ -254,11 +254,11 @@ namespace Nz } // Création des buffers - IndexBufferRef indexBuffer = IndexBuffer::New(vertexCount > std::numeric_limits::max(), std::size_t(indices.size()), parameters.storage, parameters.indexBufferFlags); - VertexBufferRef vertexBuffer = VertexBuffer::New(parameters.vertexDeclaration, std::size_t(vertexCount), parameters.storage, parameters.vertexBufferFlags); + std::shared_ptr indexBuffer = std::make_shared(vertexCount > std::numeric_limits::max(), std::size_t(indices.size()), parameters.storage, parameters.indexBufferFlags); + std::shared_ptr vertexBuffer = std::make_shared(parameters.vertexDeclaration, std::size_t(vertexCount), parameters.storage, parameters.vertexBufferFlags); // Remplissage des indices - IndexMapper indexMapper(indexBuffer, BufferAccess_WriteOnly); + IndexMapper indexMapper(*indexBuffer, BufferAccess::WriteOnly); for (std::size_t j = 0; j < indices.size(); ++j) indexMapper.Set(j, UInt32(indices[j])); @@ -277,11 +277,11 @@ namespace Nz bool hasNormals = true; bool hasTexCoords = true; - VertexMapper vertexMapper(vertexBuffer, BufferAccess_DiscardAndWrite); + VertexMapper vertexMapper(*vertexBuffer, BufferAccess::DiscardAndWrite); - auto normalPtr = vertexMapper.GetComponentPtr(VertexComponent_Normal); - auto posPtr = vertexMapper.GetComponentPtr(VertexComponent_Position); - auto uvPtr = vertexMapper.GetComponentPtr(VertexComponent_TexCoord); + auto normalPtr = vertexMapper.GetComponentPtr(VertexComponent::Normal); + auto posPtr = vertexMapper.GetComponentPtr(VertexComponent::Position); + auto uvPtr = vertexMapper.GetComponentPtr(VertexComponent::TexCoord); if (!normalPtr) hasNormals = false; @@ -321,7 +321,7 @@ namespace Nz vertexMapper.Unmap(); - StaticMeshRef subMesh = StaticMesh::New(vertexBuffer, indexBuffer); + std::shared_ptr subMesh = std::make_shared(std::move(vertexBuffer), indexBuffer); subMesh->GenerateAABB(); subMesh->SetMaterialIndex(meshes[i].material); @@ -345,7 +345,7 @@ namespace Nz if (!mtlLib.empty()) { ErrorFlags flags(ErrorFlag_ThrowExceptionDisabled); - ParseMTL(mesh, stream.GetDirectory() / mtlLib, materials, meshes, meshCount); + ParseMTL(*mesh, stream.GetDirectory() / mtlLib, materials, meshes, meshCount); } return mesh; @@ -354,14 +354,14 @@ namespace Nz namespace Loaders { - void RegisterOBJLoader() + MeshLoader::Entry GetMeshLoader_OBJ() { - MeshLoader::RegisterLoader(IsSupported, Check, Load); - } + MeshLoader::Entry loader; + loader.extensionSupport = IsSupported; + loader.streamChecker = Check; + loader.streamLoader = Load; - void UnregisterOBJLoader() - { - MeshLoader::UnregisterLoader(IsSupported, Check, Load); + return loader; } } } diff --git a/src/Nazara/Utility/Formats/OBJLoader.hpp b/src/Nazara/Utility/Formats/OBJLoader.hpp index 2f3c2f8e5..c1fc7f86b 100644 --- a/src/Nazara/Utility/Formats/OBJLoader.hpp +++ b/src/Nazara/Utility/Formats/OBJLoader.hpp @@ -8,14 +8,11 @@ #define NAZARA_LOADERS_OBJ_HPP #include +#include -namespace Nz +namespace Nz::Loaders { - namespace Loaders - { - void RegisterOBJLoader(); - void UnregisterOBJLoader(); - } + MeshLoader::Entry GetMeshLoader_OBJ(); } #endif // NAZARA_LOADERS_OBJ_HPP diff --git a/src/Nazara/Utility/Formats/OBJSaver.cpp b/src/Nazara/Utility/Formats/OBJSaver.cpp index 9945d5f55..dc70ef7c1 100644 --- a/src/Nazara/Utility/Formats/OBJSaver.cpp +++ b/src/Nazara/Utility/Formats/OBJSaver.cpp @@ -51,7 +51,7 @@ namespace Nz T* m_buffer; }; - bool IsSupported(const std::string& extension) + bool IsSupported(const std::string_view& extension) { return (extension == "obj"); } @@ -142,21 +142,21 @@ namespace Nz OBJParser::Mesh* meshes = objFormat.SetMeshCount(meshCount); for (std::size_t i = 0; i < meshCount; ++i) { - const StaticMesh* staticMesh = static_cast(mesh.GetSubMesh(i)); + const StaticMesh& staticMesh = static_cast(*mesh.GetSubMesh(i)); - std::size_t triangleCount = staticMesh->GetTriangleCount(); + std::size_t triangleCount = staticMesh.GetTriangleCount(); meshes[i].faces.resize(triangleCount); - meshes[i].material = staticMesh->GetMaterialIndex(); + meshes[i].material = staticMesh.GetMaterialIndex(); meshes[i].name = "mesh_" + std::to_string(i); meshes[i].vertices.resize(triangleCount * 3); { VertexMapper vertexMapper(staticMesh); - SparsePtr normalPtr = vertexMapper.GetComponentPtr(VertexComponent_Normal); - SparsePtr positionPtr = vertexMapper.GetComponentPtr(VertexComponent_Position); - SparsePtr texCoordsPtr = vertexMapper.GetComponentPtr(VertexComponent_TexCoord); + SparsePtr normalPtr = vertexMapper.GetComponentPtr(VertexComponent::Normal); + SparsePtr positionPtr = vertexMapper.GetComponentPtr(VertexComponent::Position); + SparsePtr texCoordsPtr = vertexMapper.GetComponentPtr(VertexComponent::TexCoord); std::size_t faceIndex = 0; TriangleIterator triangle(staticMesh); @@ -201,14 +201,13 @@ namespace Nz namespace Loaders { - void RegisterOBJSaver() + MeshSaver::Entry GetMeshSaver_OBJ() { - MeshSaver::RegisterSaver(IsSupported, SaveToStream); - } + MeshSaver::Entry entry; + entry.formatSupport = IsSupported; + entry.streamSaver = SaveToStream; - void UnregisterOBJSaver() - { - MeshSaver::UnregisterSaver(IsSupported, SaveToStream); + return entry; } } } diff --git a/src/Nazara/Utility/Formats/OBJSaver.hpp b/src/Nazara/Utility/Formats/OBJSaver.hpp index c67e04f48..21f199b5d 100644 --- a/src/Nazara/Utility/Formats/OBJSaver.hpp +++ b/src/Nazara/Utility/Formats/OBJSaver.hpp @@ -8,14 +8,11 @@ #define NAZARA_FORMATS_OBJSAVER_HPP #include +#include -namespace Nz +namespace Nz::Loaders { - namespace Loaders - { - void RegisterOBJSaver(); - void UnregisterOBJSaver(); - } + MeshSaver::Entry GetMeshSaver_OBJ(); } #endif // NAZARA_FORMATS_OBJSAVER_HPP diff --git a/src/Nazara/Utility/Formats/PCXLoader.cpp b/src/Nazara/Utility/Formats/PCXLoader.cpp index 328994191..d2faec125 100644 --- a/src/Nazara/Utility/Formats/PCXLoader.cpp +++ b/src/Nazara/Utility/Formats/PCXLoader.cpp @@ -40,7 +40,7 @@ namespace Nz static_assert(sizeof(pcx_header) == (6+48+54)*sizeof(UInt8) + 10*sizeof(UInt16), "pcx_header struct must be packed"); - bool IsSupported(const std::string& extension) + bool IsSupported(const std::string_view& extension) { return (extension == "pcx"); } @@ -61,7 +61,7 @@ namespace Nz return Ternary::False; } - ImageRef Load(Stream& stream, const ImageParams& parameters) + std::shared_ptr Load(Stream& stream, const ImageParams& parameters) { NazaraUnused(parameters); @@ -91,8 +91,8 @@ namespace Nz unsigned int width = header.xmax - header.xmin+1; unsigned int height = header.ymax - header.ymin+1; - ImageRef image = Image::New(); - if (!image->Create(ImageType_2D, PixelFormat_RGB8, width, height, 1, (parameters.levelCount > 0) ? parameters.levelCount : 1)) + std::shared_ptr image = std::make_shared(); + if (!image->Create(ImageType::E2D, PixelFormat::RGB8, width, height, 1, (parameters.levelCount > 0) ? parameters.levelCount : 1)) { NazaraError("Failed to create image"); return nullptr; @@ -333,7 +333,7 @@ namespace Nz return nullptr; } - if (parameters.loadFormat != PixelFormat_Undefined) + if (parameters.loadFormat != PixelFormat::Undefined) image->Convert(parameters.loadFormat); return image; @@ -342,14 +342,14 @@ namespace Nz namespace Loaders { - void RegisterPCX() + ImageLoader::Entry GetImageLoader_PCX() { - ImageLoader::RegisterLoader(IsSupported, Check, Load); - } + ImageLoader::Entry loaderEntry; + loaderEntry.extensionSupport = IsSupported; + loaderEntry.streamChecker = Check; + loaderEntry.streamLoader = Load; - void UnregisterPCX() - { - ImageLoader::UnregisterLoader(IsSupported, Check, Load); + return loaderEntry; } } } diff --git a/src/Nazara/Utility/Formats/PCXLoader.hpp b/src/Nazara/Utility/Formats/PCXLoader.hpp index 2b83a8526..86e9dd8d4 100644 --- a/src/Nazara/Utility/Formats/PCXLoader.hpp +++ b/src/Nazara/Utility/Formats/PCXLoader.hpp @@ -8,14 +8,11 @@ #define NAZARA_LOADERS_PCX_HPP #include +#include -namespace Nz +namespace Nz::Loaders { - namespace Loaders - { - void RegisterPCX(); - void UnregisterPCX(); - } + ImageLoader::Entry GetImageLoader_PCX(); } #endif // NAZARA_LOADERS_PCX_HPP diff --git a/src/Nazara/Utility/Formats/STBLoader.cpp b/src/Nazara/Utility/Formats/STBLoader.cpp index 0472e0e91..d8c7b9241 100644 --- a/src/Nazara/Utility/Formats/STBLoader.cpp +++ b/src/Nazara/Utility/Formats/STBLoader.cpp @@ -36,9 +36,9 @@ namespace Nz static stbi_io_callbacks callbacks = {Read, Skip, Eof}; - bool IsSupported(const std::string& extension) + bool IsSupported(const std::string_view& extension) { - static std::unordered_set supportedExtensions = {"bmp", "gif", "hdr", "jpg", "jpeg", "pic", "png", "ppm", "pgm", "psd", "tga"}; + static std::unordered_set supportedExtensions = {"bmp", "gif", "hdr", "jpg", "jpeg", "pic", "png", "ppm", "pgm", "psd", "tga"}; return supportedExtensions.find(extension) != supportedExtensions.end(); } @@ -55,7 +55,7 @@ namespace Nz return Ternary::False; } - ImageRef Load(Stream& stream, const ImageParams& parameters) + std::shared_ptr Load(Stream& stream, const ImageParams& parameters) { // Je charge tout en RGBA8 et je converti ensuite via la méthode Convert // Ceci à cause d'un bug de STB lorsqu'il s'agit de charger certaines images (ex: JPG) en "default" @@ -65,7 +65,7 @@ namespace Nz if (!ptr) { NazaraError("Failed to load image: " + std::string(stbi_failure_reason())); - return nullptr; + return {}; } CallOnExit freeStbiImage([ptr]() @@ -73,19 +73,25 @@ namespace Nz stbi_image_free(ptr); }); - ImageRef image = Image::New(); - if (!image->Create(ImageType_2D, PixelFormat_RGBA8, width, height, 1, (parameters.levelCount > 0) ? parameters.levelCount : 1)) + std::shared_ptr image = std::make_shared(); + if (!image->Create(ImageType::E2D, PixelFormat::RGBA8, width, height, 1, (parameters.levelCount > 0) ? parameters.levelCount : 1)) { NazaraError("Failed to create image"); - return nullptr; + return {}; } image->Update(ptr); freeStbiImage.CallAndReset(); - if (parameters.loadFormat != PixelFormat_Undefined) - image->Convert(parameters.loadFormat); + if (parameters.loadFormat != PixelFormat::Undefined) + { + if (!image->Convert(parameters.loadFormat)) + { + NazaraError("Failed to convert image to required format"); + return {}; + } + } return image; } @@ -93,14 +99,14 @@ namespace Nz namespace Loaders { - void RegisterSTBLoader() + ImageLoader::Entry GetImageLoader_STB() { - ImageLoader::RegisterLoader(IsSupported, Check, Load); - } + ImageLoader::Entry loaderEntry; + loaderEntry.extensionSupport = IsSupported; + loaderEntry.streamChecker = Check; + loaderEntry.streamLoader = Load; - void UnregisterSTBLoader() - { - ImageLoader::UnregisterLoader(IsSupported, Check, Load); + return loaderEntry; } } } diff --git a/src/Nazara/Utility/Formats/STBLoader.hpp b/src/Nazara/Utility/Formats/STBLoader.hpp index e1e87b998..673fc7149 100644 --- a/src/Nazara/Utility/Formats/STBLoader.hpp +++ b/src/Nazara/Utility/Formats/STBLoader.hpp @@ -8,14 +8,11 @@ #define NAZARA_FORMATS_STBLOADER_HPP #include +#include -namespace Nz +namespace Nz::Loaders { - namespace Loaders - { - void RegisterSTBLoader(); - void UnregisterSTBLoader(); - } + ImageLoader::Entry GetImageLoader_STB(); } #endif // NAZARA_FORMATS_STBLOADER_HPP diff --git a/src/Nazara/Utility/Formats/STBSaver.cpp b/src/Nazara/Utility/Formats/STBSaver.cpp index 4dc30171a..150de6683 100644 --- a/src/Nazara/Utility/Formats/STBSaver.cpp +++ b/src/Nazara/Utility/Formats/STBSaver.cpp @@ -15,36 +15,36 @@ namespace Nz { using FormatHandler = bool(*)(const Image& image, const ImageParams& parameters, Stream& stream); - std::map s_formatHandlers; + std::map s_formatHandlers; int ConvertToFloatFormat(Image& image) { switch (image.GetFormat()) { - case PixelFormat_R32F: + case PixelFormat::R32F: return 1; - case PixelFormat_RG32F: + case PixelFormat::RG32F: return 2; - case PixelFormat_RGB32F: + case PixelFormat::RGB32F: return 3; - case PixelFormat_RGBA32F: + case PixelFormat::RGBA32F: return 4; default: { if (PixelFormatInfo::HasAlpha(image.GetFormat())) { - if (!image.Convert(PixelFormat_RGBA32F)) + if (!image.Convert(PixelFormat::RGBA32F)) break; return 4; } else { - if (!image.Convert(PixelFormat_RGB32F)) + if (!image.Convert(PixelFormat::RGB32F)) break; return 3; @@ -59,32 +59,32 @@ namespace Nz { switch (image.GetFormat()) { - case PixelFormat_L8: - case PixelFormat_R8: + case PixelFormat::L8: + case PixelFormat::R8: return 1; - case PixelFormat_LA8: - case PixelFormat_RG8: + case PixelFormat::LA8: + case PixelFormat::RG8: return 2; - case PixelFormat_RGB8: + case PixelFormat::RGB8: return 3; - case PixelFormat_RGBA8: + case PixelFormat::RGBA8: return 4; default: { if (PixelFormatInfo::HasAlpha(image.GetFormat())) { - if (!image.Convert(PixelFormat_RGBA8)) + if (!image.Convert(PixelFormat::RGBA8)) break; return 4; } else { - if (!image.Convert(PixelFormat_RGB8)) + if (!image.Convert(PixelFormat::RGB8)) break; return 3; @@ -102,7 +102,7 @@ namespace Nz throw std::runtime_error("Failed to write to stream"); } - bool FormatQuerier(const std::string& extension) + bool FormatQuerier(const std::string_view& extension) { return s_formatHandlers.find(extension) != s_formatHandlers.end(); } @@ -118,9 +118,9 @@ namespace Nz } ImageType type = image.GetType(); - if (type != ImageType_1D && type != ImageType_2D) + if (type != ImageType::E1D && type != ImageType::E2D) { - NazaraError("Image type 0x" + NumberToString(type, 16) + " is not in a supported format"); + NazaraError("Image type 0x" + NumberToString(UnderlyingCast(type), 16) + " is not in a supported format"); return false; } @@ -262,22 +262,20 @@ namespace Nz namespace Loaders { - void RegisterSTBSaver() + ImageSaver::Entry GetImageSaver_STB() { - s_formatHandlers["bmp"] = &SaveBMP; - s_formatHandlers["hdr"] = &SaveHDR; - s_formatHandlers["jpg"] = &SaveJPEG; + s_formatHandlers["bmp"] = &SaveBMP; + s_formatHandlers["hdr"] = &SaveHDR; + s_formatHandlers["jpg"] = &SaveJPEG; s_formatHandlers["jpeg"] = &SaveJPEG; - s_formatHandlers["png"] = &SavePNG; - s_formatHandlers["tga"] = &SaveTGA; + s_formatHandlers["png"] = &SavePNG; + s_formatHandlers["tga"] = &SaveTGA; - ImageSaver::RegisterSaver(FormatQuerier, SaveToStream); - } + ImageSaver::Entry entry; + entry.formatSupport = FormatQuerier; + entry.streamSaver = SaveToStream; - void UnregisterSTBSaver() - { - ImageSaver::UnregisterSaver(FormatQuerier, SaveToStream); - s_formatHandlers.clear(); + return entry; } } } diff --git a/src/Nazara/Utility/Formats/STBSaver.hpp b/src/Nazara/Utility/Formats/STBSaver.hpp index bb4ad5d1b..d459d4346 100644 --- a/src/Nazara/Utility/Formats/STBSaver.hpp +++ b/src/Nazara/Utility/Formats/STBSaver.hpp @@ -8,14 +8,11 @@ #define NAZARA_FORMATS_STBSAVER_HPP #include +#include -namespace Nz +namespace Nz::Loaders { - namespace Loaders - { - void RegisterSTBSaver(); - void UnregisterSTBSaver(); - } + ImageSaver::Entry GetImageSaver_STB(); } #endif // NAZARA_FORMATS_STBSAVER_HPP diff --git a/src/Nazara/Utility/GuillotineImageAtlas.cpp b/src/Nazara/Utility/GuillotineImageAtlas.cpp index ee1101c91..1876bbfa4 100644 --- a/src/Nazara/Utility/GuillotineImageAtlas.cpp +++ b/src/Nazara/Utility/GuillotineImageAtlas.cpp @@ -75,7 +75,7 @@ namespace Nz UInt32 GuillotineImageAtlas::GetStorage() const { - return DataStorage_Software; + return static_cast(DataStorage::Software); } bool GuillotineImageAtlas::Insert(const Image& image, Rectui* rect, bool* flipped, unsigned int* layerIndex) @@ -161,10 +161,10 @@ namespace Nz AbstractImage* GuillotineImageAtlas::ResizeImage(AbstractImage* oldImage, const Vector2ui& size) const { - std::unique_ptr newImage(new Image(ImageType_2D, PixelFormat_A8, size.x, size.y)); + std::unique_ptr newImage(new Image(ImageType::E2D, PixelFormat::A8, size.x, size.y)); if (oldImage) { - newImage->Copy(static_cast(oldImage), Rectui(size), Vector2ui(0, 0)); // Copie des anciennes données + newImage->Copy(static_cast(*oldImage), Rectui(size), Vector2ui(0, 0)); // Copie des anciennes données } return newImage.release(); diff --git a/src/Nazara/Utility/Image.cpp b/src/Nazara/Utility/Image.cpp index a74eab3cd..ff8462f04 100644 --- a/src/Nazara/Utility/Image.cpp +++ b/src/Nazara/Utility/Image.cpp @@ -8,6 +8,7 @@ #include #include #include +#include #include #include @@ -66,8 +67,6 @@ namespace Nz Image::~Image() { - OnImageRelease(this); - Destroy(); } @@ -102,7 +101,7 @@ namespace Nz unsigned int height = m_sharedImage->height; // Les images 3D et cubemaps sont stockés de la même façon - unsigned int depth = (m_sharedImage->type == ImageType_Cubemap) ? 6 : m_sharedImage->depth; + unsigned int depth = (m_sharedImage->type == ImageType::Cubemap) ? 6 : m_sharedImage->depth; for (unsigned int i = 0; i < levels.size(); ++i) { @@ -132,7 +131,7 @@ namespace Nz if (height > 1) height >>= 1; - if (depth > 1 && m_sharedImage->type != ImageType_Cubemap) + if (depth > 1 && m_sharedImage->type != ImageType::Cubemap) depth >>= 1; } @@ -144,13 +143,13 @@ namespace Nz return true; } - void Image::Copy(const Image* source, const Boxui& srcBox, const Vector3ui& dstPos) + void Image::Copy(const Image& source, const Boxui& srcBox, const Vector3ui& dstPos) { - NazaraAssert(IsValid(), "Invalid image"); - NazaraAssert(source && source->IsValid(), "Invalid source image"); - NazaraAssert(source->GetFormat() == m_sharedImage->format, "Image formats don't match"); + NazaraAssert(IsValid(), "invalid image"); + NazaraAssert(source.IsValid(), "invalid source image"); + NazaraAssert(source.GetFormat() == m_sharedImage->format, "image formats don't match"); - const UInt8* srcPtr = source->GetConstPixels(srcBox.x, srcBox.y, srcBox.z); + const UInt8* srcPtr = source.GetConstPixels(srcBox.x, srcBox.y, srcBox.z); #if NAZARA_UTILITY_SAFE if (!srcPtr) { @@ -162,7 +161,7 @@ namespace Nz UInt8 bpp = PixelFormatInfo::GetBytesPerPixel(m_sharedImage->format); UInt8* dstPtr = GetPixelPtr(m_sharedImage->levels[0].get(), bpp, dstPos.x, dstPos.y, dstPos.z, m_sharedImage->width, m_sharedImage->height); - Copy(dstPtr, srcPtr, m_sharedImage->format, srcBox.width, srcBox.height, srcBox.depth, m_sharedImage->width, m_sharedImage->height, source->GetWidth(), source->GetHeight()); + Copy(dstPtr, srcPtr, m_sharedImage->format, srcBox.width, srcBox.height, srcBox.depth, m_sharedImage->width, m_sharedImage->height, source.GetWidth(), source.GetHeight()); } bool Image::Create(ImageType type, PixelFormat format, unsigned int width, unsigned int height, unsigned int depth, UInt8 levelCount) @@ -196,7 +195,7 @@ namespace Nz switch (type) { - case ImageType_1D: + case ImageType::E1D: if (height > 1) { NazaraError("1D textures must be 1 tall"); @@ -210,8 +209,8 @@ namespace Nz } break; - case ImageType_1D_Array: - case ImageType_2D: + case ImageType::E1D_Array: + case ImageType::E2D: if (depth > 1) { NazaraError("2D textures must be 1 deep"); @@ -219,11 +218,11 @@ namespace Nz } break; - case ImageType_2D_Array: - case ImageType_3D: + case ImageType::E2D_Array: + case ImageType::E3D: break; - case ImageType_Cubemap: + case ImageType::Cubemap: if (depth > 1) { NazaraError("Cubemaps must be 1 deep"); @@ -249,7 +248,7 @@ namespace Nz unsigned int w = width; unsigned int h = height; - unsigned int d = (type == ImageType_Cubemap) ? 6 : depth; + unsigned int d = (type == ImageType::Cubemap) ? 6 : depth; for (unsigned int i = 0; i < levelCount; ++i) { @@ -264,7 +263,7 @@ namespace Nz if (h > 1) h >>= 1; - if (d > 1 && type != ImageType_Cubemap) + if (d > 1 && type != ImageType::Cubemap) d >>= 1; } catch (const std::exception& e) @@ -282,10 +281,7 @@ namespace Nz void Image::Destroy() { if (m_sharedImage != &emptyImage) - { - OnImageDestroy(this); ReleaseImage(); - } } bool Image::Fill(const Color& color) @@ -308,7 +304,7 @@ namespace Nz UInt8 bpp = PixelFormatInfo::GetBytesPerPixel(m_sharedImage->format); std::unique_ptr colorBuffer(new UInt8[bpp]); - if (!PixelFormatInfo::Convert(PixelFormat_RGBA8, m_sharedImage->format, &color.r, colorBuffer.get())) + if (!PixelFormatInfo::Convert(PixelFormat::RGBA8, m_sharedImage->format, &color.r, colorBuffer.get())) { NazaraError("Failed to convert RGBA8 to " + PixelFormatInfo::GetName(m_sharedImage->format)); return false; @@ -320,7 +316,7 @@ namespace Nz unsigned int height = m_sharedImage->height; // Les images 3D et cubemaps sont stockés de la même façon - unsigned int depth = (m_sharedImage->type == ImageType_Cubemap) ? 6 : m_sharedImage->depth; + unsigned int depth = (m_sharedImage->type == ImageType::Cubemap) ? 6 : m_sharedImage->depth; for (auto & level : levels) { @@ -342,7 +338,7 @@ namespace Nz if (height > 1U) height >>= 1; - if (depth > 1U && m_sharedImage->type != ImageType_Cubemap) + if (depth > 1U && m_sharedImage->type != ImageType::Cubemap) depth >>= 1; } @@ -386,7 +382,7 @@ namespace Nz UInt8 bpp = PixelFormatInfo::GetBytesPerPixel(m_sharedImage->format); std::unique_ptr colorBuffer(new UInt8[bpp]); - if (!PixelFormatInfo::Convert(PixelFormat_RGBA8, m_sharedImage->format, &color.r, colorBuffer.get())) + if (!PixelFormatInfo::Convert(PixelFormat::RGBA8, m_sharedImage->format, &color.r, colorBuffer.get())) { NazaraError("Failed to convert RGBA8 to " + PixelFormatInfo::GetName(m_sharedImage->format)); return false; @@ -446,7 +442,7 @@ namespace Nz return false; } - unsigned int depth = (m_sharedImage->type == ImageType_Cubemap) ? 6 : m_sharedImage->depth; + unsigned int depth = (m_sharedImage->type == ImageType::Cubemap) ? 6 : m_sharedImage->depth; if (z >= depth) { NazaraError("Z value exceeds depth (" + NumberToString(z) + " >= " + NumberToString(depth) + ')'); @@ -458,7 +454,7 @@ namespace Nz UInt8 bpp = PixelFormatInfo::GetBytesPerPixel(m_sharedImage->format); std::unique_ptr colorBuffer(new UInt8[bpp]); - if (!PixelFormatInfo::Convert(PixelFormat_RGBA8, m_sharedImage->format, &color.r, colorBuffer.get())) + if (!PixelFormatInfo::Convert(PixelFormat::RGBA8, m_sharedImage->format, &color.r, colorBuffer.get())) { NazaraError("Failed to convert RGBA8 to " + PixelFormatInfo::GetName(m_sharedImage->format)); return false; @@ -498,11 +494,11 @@ namespace Nz unsigned int width = m_sharedImage->width; unsigned int height = m_sharedImage->height; - unsigned int depth = (m_sharedImage->type == ImageType_Cubemap) ? 6 : m_sharedImage->depth; + unsigned int depth = (m_sharedImage->type == ImageType::Cubemap) ? 6 : m_sharedImage->depth; for (auto& level : m_sharedImage->levels) { UInt8* ptr = level.get(); - if (!PixelFormatInfo::Flip(PixelFlipping_Horizontally, m_sharedImage->format, width, height, depth, ptr, ptr)) + if (!PixelFormatInfo::Flip(PixelFlipping::Horizontally, m_sharedImage->format, width, height, depth, ptr, ptr)) { NazaraError("Failed to flip image"); return false; @@ -514,7 +510,7 @@ namespace Nz if (height > 1U) height >>= 1; - if (depth > 1U && m_sharedImage->type != ImageType_Cubemap) + if (depth > 1U && m_sharedImage->type != ImageType::Cubemap) depth >>= 1; } @@ -541,11 +537,11 @@ namespace Nz unsigned int width = m_sharedImage->width; unsigned int height = m_sharedImage->height; - unsigned int depth = (m_sharedImage->type == ImageType_Cubemap) ? 6 : m_sharedImage->depth; + unsigned int depth = (m_sharedImage->type == ImageType::Cubemap) ? 6 : m_sharedImage->depth; for (auto& level : m_sharedImage->levels) { UInt8* ptr = level.get(); - if (!PixelFormatInfo::Flip(PixelFlipping_Vertically, m_sharedImage->format, width, height, depth, ptr, ptr)) + if (!PixelFormatInfo::Flip(PixelFlipping::Vertically, m_sharedImage->format, width, height, depth, ptr, ptr)) { NazaraError("Failed to flip image"); return false; @@ -557,7 +553,7 @@ namespace Nz if (height > 1U) height >>= 1; - if (depth > 1U && m_sharedImage->type != ImageType_Cubemap) + if (depth > 1U && m_sharedImage->type != ImageType::Cubemap) depth >>= 1; } @@ -597,7 +593,7 @@ namespace Nz return nullptr; } - unsigned int depth = (m_sharedImage->type == ImageType_Cubemap) ? 6 : GetLevelSize(m_sharedImage->depth, level); + unsigned int depth = (m_sharedImage->type == ImageType::Cubemap) ? 6 : GetLevelSize(m_sharedImage->depth, level); if (z >= depth) { NazaraError("Z value exceeds depth (" + NumberToString(z) + " >= " + NumberToString(depth) + ')'); @@ -670,7 +666,7 @@ namespace Nz depth >>= 1; } - if (m_sharedImage->type == ImageType_Cubemap) + if (m_sharedImage->type == ImageType::Cubemap) size *= 6; return size * PixelFormatInfo::GetBytesPerPixel(m_sharedImage->format); @@ -678,7 +674,7 @@ namespace Nz std::size_t Image::GetMemoryUsage(UInt8 level) const { - return PixelFormatInfo::ComputeSize(m_sharedImage->format, GetLevelSize(m_sharedImage->width, level), GetLevelSize(m_sharedImage->height, level), ((m_sharedImage->type == ImageType_Cubemap) ? 6 : GetLevelSize(m_sharedImage->depth, level))); + return PixelFormatInfo::ComputeSize(m_sharedImage->format, GetLevelSize(m_sharedImage->width, level), GetLevelSize(m_sharedImage->height, level), ((m_sharedImage->type == ImageType::Cubemap) ? 6 : GetLevelSize(m_sharedImage->depth, level))); } Color Image::GetPixelColor(unsigned int x, unsigned int y, unsigned int z) const @@ -708,7 +704,7 @@ namespace Nz return Color(); } - unsigned int depth = (m_sharedImage->type == ImageType_Cubemap) ? 6 : m_sharedImage->depth; + unsigned int depth = (m_sharedImage->type == ImageType::Cubemap) ? 6 : m_sharedImage->depth; if (z >= depth) { NazaraError("Z value exceeds depth (" + NumberToString(z) + " >= " + NumberToString(depth) + ')'); @@ -719,7 +715,7 @@ namespace Nz const UInt8* pixel = GetPixelPtr(m_sharedImage->levels[0].get(), PixelFormatInfo::GetBytesPerPixel(m_sharedImage->format), x, y, z, m_sharedImage->width, m_sharedImage->height); Color color; - if (!PixelFormatInfo::Convert(m_sharedImage->format, PixelFormat_RGBA8, pixel, &color.r)) + if (!PixelFormatInfo::Convert(m_sharedImage->format, PixelFormat::RGBA8, pixel, &color.r)) NazaraError("Failed to convert image's format to RGBA8"); return color; @@ -758,7 +754,7 @@ namespace Nz return nullptr; } - unsigned int depth = (m_sharedImage->type == ImageType_Cubemap) ? 6 : GetLevelSize(m_sharedImage->depth, level); + unsigned int depth = (m_sharedImage->type == ImageType::Cubemap) ? 6 : GetLevelSize(m_sharedImage->depth, level); if (z >= depth) { NazaraError("Z value exceeds depth (" + NumberToString(z) + " >= " + NumberToString(depth) + ')'); @@ -820,7 +816,7 @@ namespace Nz const PixelFormatDescription& info = PixelFormatInfo::GetInfo(m_sharedImage->format); Bitset<> workingBitset; - std::size_t pixelCount = m_sharedImage->width * m_sharedImage->height * ((m_sharedImage->type == ImageType_Cubemap) ? 6 : m_sharedImage->depth); + std::size_t pixelCount = m_sharedImage->width * m_sharedImage->height * ((m_sharedImage->type == ImageType::Cubemap) ? 6 : m_sharedImage->depth); if (pixelCount == 0) return false; @@ -851,21 +847,21 @@ namespace Nz } // LoadArray - ImageRef Image::LoadArrayFromFile(const std::filesystem::path& filePath, const ImageParams& imageParams, const Vector2ui& atlasSize) + std::shared_ptr Image::LoadArrayFromFile(const std::filesystem::path& filePath, const ImageParams& imageParams, const Vector2ui& atlasSize) { - ImageRef image = Image::LoadFromFile(filePath, imageParams); + std::shared_ptr image = Image::LoadFromFile(filePath, imageParams); if (!image) { NazaraError("Failed to load image"); return nullptr; } - return LoadArrayFromImage(image, atlasSize); + return LoadArrayFromImage(*image, atlasSize); } - ImageRef Image::LoadArrayFromImage(const Image* image, const Vector2ui& atlasSize) + std::shared_ptr Image::LoadArrayFromImage(const Image& image, const Vector2ui& atlasSize) { - NazaraAssert(image && image->IsValid(), "Invalid image"); + NazaraAssert(image.IsValid(), "Invalid image"); #if NAZARA_UTILITY_SAFE if (atlasSize.x == 0) @@ -881,17 +877,17 @@ namespace Nz } #endif - ImageType type = image->GetType(); + ImageType type = image.GetType(); #if NAZARA_UTILITY_SAFE - if (type != ImageType_1D && type != ImageType_2D) + if (type != ImageType::E1D && type != ImageType::E2D) { - NazaraError("Image type not handled (0x" + NumberToString(type, 16) + ')'); + NazaraError("Image type not handled (0x" + NumberToString(UnderlyingCast(type), 16) + ')'); return nullptr; } #endif - Vector2ui imageSize(image->GetWidth(), image->GetHeight()); + Vector2ui imageSize(image.GetWidth(), image.GetHeight()); if (imageSize.x % atlasSize.x != 0) { @@ -907,12 +903,12 @@ namespace Nz unsigned int layerCount = atlasSize.x*atlasSize.y; - ImageRef arrayImage = New(); + std::shared_ptr arrayImage = std::make_shared(); // Selon le type de l'image de base, on va créer un array d'images 2D ou 1D - if (type == ImageType_2D) - arrayImage->Create(ImageType_2D_Array, image->GetFormat(), faceSize.x, faceSize.y, layerCount); + if (type == ImageType::E2D) + arrayImage->Create(ImageType::E2D_Array, image.GetFormat(), faceSize.x, faceSize.y, layerCount); else - arrayImage->Create(ImageType_1D_Array, image->GetFormat(), faceSize.x, layerCount); + arrayImage->Create(ImageType::E1D_Array, image.GetFormat(), faceSize.x, layerCount); if (!arrayImage->IsValid()) { @@ -928,57 +924,57 @@ namespace Nz return arrayImage; } - ImageRef Image::LoadArrayFromMemory(const void* data, std::size_t size, const ImageParams& imageParams, const Vector2ui& atlasSize) + std::shared_ptr Image::LoadArrayFromMemory(const void* data, std::size_t size, const ImageParams& imageParams, const Vector2ui& atlasSize) { - ImageRef image = Image::LoadFromMemory(data, size, imageParams); + std::shared_ptr image = Image::LoadFromMemory(data, size, imageParams); if (!image) { NazaraError("Failed to load image"); return nullptr; } - return LoadArrayFromImage(image, atlasSize); + return LoadArrayFromImage(*image, atlasSize); } - ImageRef Image::LoadArrayFromStream(Stream& stream, const ImageParams& imageParams, const Vector2ui& atlasSize) + std::shared_ptr Image::LoadArrayFromStream(Stream& stream, const ImageParams& imageParams, const Vector2ui& atlasSize) { - ImageRef image = Image::LoadFromStream(stream, imageParams); + std::shared_ptr image = Image::LoadFromStream(stream, imageParams); if (!image) { NazaraError("Failed to load image"); return nullptr; } - return LoadArrayFromImage(image, atlasSize); + return LoadArrayFromImage(*image, atlasSize); } - ImageRef Image::LoadCubemapFromFile(const std::filesystem::path& filePath, const ImageParams& imageParams, const CubemapParams& cubemapParams) + std::shared_ptr Image::LoadCubemapFromFile(const std::filesystem::path& filePath, const ImageParams& imageParams, const CubemapParams& cubemapParams) { - ImageRef image = Image::LoadFromFile(filePath, imageParams); + std::shared_ptr image = Image::LoadFromFile(filePath, imageParams); if (!image) { NazaraError("Failed to load image"); return nullptr; } - return LoadCubemapFromImage(image, cubemapParams); + return LoadCubemapFromImage(*image, cubemapParams); } - ImageRef Image::LoadCubemapFromImage(const Image* image, const CubemapParams& params) + std::shared_ptr Image::LoadCubemapFromImage(const Image& image, const CubemapParams& params) { - NazaraAssert(image && image->IsValid(), "Invalid image"); + NazaraAssert(image.IsValid(), "Invalid image"); #if NAZARA_UTILITY_SAFE - ImageType type = image->GetType(); - if (type != ImageType_2D) + ImageType type = image.GetType(); + if (type != ImageType::E2D) { - NazaraError("Image type not handled (0x" + NumberToString(type, 16) + ')'); + NazaraError("Image type not handled (0x" + NumberToString(UnderlyingCast(type), 16) + ')'); return nullptr; } #endif - unsigned int width = image->GetWidth(); - unsigned int height = image->GetHeight(); + unsigned int width = image.GetWidth(); + unsigned int height = image.GetHeight(); unsigned int faceSize = (params.faceSize == 0) ? std::max(width, height)/4 : params.faceSize; // Sans cette vérification, celles des rectangles pourrait réussir via un overflow @@ -1034,52 +1030,52 @@ namespace Nz return nullptr; } - ImageRef cubemap = New(); - if (!cubemap->Create(ImageType_Cubemap, image->GetFormat(), faceSize, faceSize)) + std::shared_ptr cubemap = std::make_shared(); + if (!cubemap->Create(ImageType::Cubemap, image.GetFormat(), faceSize, faceSize)) { NazaraError("Failed to create cubemap"); return nullptr; } - cubemap->Copy(image, Rectui(backPos.x, backPos.y, faceSize, faceSize), Vector3ui(0, 0, CubemapFace_NegativeZ)); - cubemap->Copy(image, Rectui(downPos.x, downPos.y, faceSize, faceSize), Vector3ui(0, 0, CubemapFace_NegativeY)); - cubemap->Copy(image, Rectui(forwardPos.x, forwardPos.y, faceSize, faceSize), Vector3ui(0, 0, CubemapFace_PositiveZ)); - cubemap->Copy(image, Rectui(leftPos.x, leftPos.y, faceSize, faceSize), Vector3ui(0, 0, CubemapFace_NegativeX)); - cubemap->Copy(image, Rectui(rightPos.x, rightPos.y, faceSize, faceSize), Vector3ui(0, 0, CubemapFace_PositiveX)); - cubemap->Copy(image, Rectui(upPos.x, upPos.y, faceSize, faceSize), Vector3ui(0, 0, CubemapFace_PositiveY)); + cubemap->Copy(image, Rectui(backPos.x, backPos.y, faceSize, faceSize), Vector3ui(0, 0, UnderlyingCast(CubemapFace::NegativeZ))); + cubemap->Copy(image, Rectui(downPos.x, downPos.y, faceSize, faceSize), Vector3ui(0, 0, UnderlyingCast(CubemapFace::NegativeY))); + cubemap->Copy(image, Rectui(forwardPos.x, forwardPos.y, faceSize, faceSize), Vector3ui(0, 0, UnderlyingCast(CubemapFace::PositiveZ))); + cubemap->Copy(image, Rectui(leftPos.x, leftPos.y, faceSize, faceSize), Vector3ui(0, 0, UnderlyingCast(CubemapFace::NegativeX))); + cubemap->Copy(image, Rectui(rightPos.x, rightPos.y, faceSize, faceSize), Vector3ui(0, 0, UnderlyingCast(CubemapFace::PositiveX))); + cubemap->Copy(image, Rectui(upPos.x, upPos.y, faceSize, faceSize), Vector3ui(0, 0, UnderlyingCast(CubemapFace::PositiveY))); return cubemap; } - ImageRef Image::LoadCubemapFromMemory(const void* data, std::size_t size, const ImageParams& imageParams, const CubemapParams& cubemapParams) + std::shared_ptr Image::LoadCubemapFromMemory(const void* data, std::size_t size, const ImageParams& imageParams, const CubemapParams& cubemapParams) { - ImageRef image = Image::LoadFromMemory(data, size, imageParams); + std::shared_ptr image = Image::LoadFromMemory(data, size, imageParams); if (!image) { NazaraError("Failed to load image"); return nullptr; } - return LoadCubemapFromImage(image, cubemapParams); + return LoadCubemapFromImage(*image, cubemapParams); } - ImageRef Image::LoadCubemapFromStream(Stream& stream, const ImageParams& imageParams, const CubemapParams& cubemapParams) + std::shared_ptr Image::LoadCubemapFromStream(Stream& stream, const ImageParams& imageParams, const CubemapParams& cubemapParams) { - ImageRef image = Image::LoadFromStream(stream, imageParams); + std::shared_ptr image = Image::LoadFromStream(stream, imageParams); if (!image) { NazaraError("Failed to load image"); return nullptr; } - return LoadCubemapFromImage(image, cubemapParams); + return LoadCubemapFromImage(*image, cubemapParams); } bool Image::LoadFaceFromFile(CubemapFace face, const std::filesystem::path& filePath, const ImageParams& params) { NazaraAssert(IsValid() && IsCubemap(), "Texture must be a valid cubemap"); - ImageRef image = Image::LoadFromFile(filePath, params); + std::shared_ptr image = Image::LoadFromFile(filePath, params); if (!image) { NazaraError("Failed to load image"); @@ -1099,7 +1095,7 @@ namespace Nz return false; } - Copy(image, Rectui(0, 0, faceSize, faceSize), Vector3ui(0, 0, face)); + Copy(*image, Rectui(0, 0, faceSize, faceSize), Vector3ui(0, 0, UnderlyingCast(face))); return true; } @@ -1107,7 +1103,7 @@ namespace Nz { NazaraAssert(IsValid() && IsCubemap(), "Texture must be a valid cubemap"); - ImageRef image = Image::LoadFromMemory(data, size, params); + std::shared_ptr image = Image::LoadFromMemory(data, size, params); if (!image) { NazaraError("Failed to load image"); @@ -1127,7 +1123,7 @@ namespace Nz return false; } - Copy(image, Rectui(0, 0, faceSize, faceSize), Vector3ui(0, 0, face)); + Copy(*image, Rectui(0, 0, faceSize, faceSize), Vector3ui(0, 0, UnderlyingCast(face))); return true; } @@ -1135,7 +1131,7 @@ namespace Nz { NazaraAssert(IsValid() && IsCubemap(), "Texture must be a valid cubemap"); - ImageRef image = Image::LoadFromStream(stream, params); + std::shared_ptr image = Image::LoadFromStream(stream, params); if (!image) { NazaraError("Failed to load image"); @@ -1155,18 +1151,24 @@ namespace Nz return false; } - Copy(image, Rectui(0, 0, faceSize, faceSize), Vector3ui(0, 0, face)); + Copy(*image, Rectui(0, 0, faceSize, faceSize), Vector3ui(0, 0, UnderlyingCast(face))); return true; } bool Image::SaveToFile(const std::filesystem::path& filePath, const ImageParams& params) { - return ImageSaver::SaveToFile(*this, filePath, params); + Utility* utility = Utility::Instance(); + NazaraAssert(utility, "Utility module has not been initialized"); + + return utility->GetImageSaver().SaveToFile(*this, filePath, params); } bool Image::SaveToStream(Stream& stream, const std::string& format, const ImageParams& params) { - return ImageSaver::SaveToStream(*this, stream, format, params); + Utility* utility = Utility::Instance(); + NazaraAssert(utility, "Utility module has not been initialized"); + + return utility->GetImageSaver().SaveToStream(*this, stream, format, params); } void Image::SetLevelCount(UInt8 levelCount) @@ -1227,7 +1229,7 @@ namespace Nz return false; } - unsigned int depth = (m_sharedImage->type == ImageType_Cubemap) ? 6 : m_sharedImage->depth; + unsigned int depth = (m_sharedImage->type == ImageType::Cubemap) ? 6 : m_sharedImage->depth; if (z >= depth) { NazaraError("Z value exceeds depth (" + NumberToString(z) + " >= " + NumberToString(depth) + ')'); @@ -1237,7 +1239,7 @@ namespace Nz UInt8* pixel = GetPixelPtr(m_sharedImage->levels[0].get(), PixelFormatInfo::GetBytesPerPixel(m_sharedImage->format), x, y, z, m_sharedImage->width, m_sharedImage->height); - if (!PixelFormatInfo::Convert(PixelFormat_RGBA8, m_sharedImage->format, &color.r, pixel)) + if (!PixelFormatInfo::Convert(PixelFormat::RGBA8, m_sharedImage->format, &color.r, pixel)) { NazaraError("Failed to convert RGBA8 to image's format"); return false; @@ -1312,9 +1314,9 @@ namespace Nz return false; } - unsigned int depth = (m_sharedImage->type == ImageType_Cubemap) ? 6 : GetLevelSize(m_sharedImage->depth, level); + unsigned int depth = (m_sharedImage->type == ImageType::Cubemap) ? 6 : GetLevelSize(m_sharedImage->depth, level); if (box.x+box.width > width || box.y+box.height > height || box.z+box.depth > depth || - (m_sharedImage->type == ImageType_Cubemap && box.depth > 1)) // Nous n'autorisons pas de modifier plus d'une face du cubemap à la fois + (m_sharedImage->type == ImageType::Cubemap && box.depth > 1)) // Nous n'autorisons pas de modifier plus d'une face du cubemap à la fois { NazaraError("Box dimensions are out of bounds"); return false; @@ -1413,36 +1415,45 @@ namespace Nz // Pour éviter que la profondeur ne soit comptée dans le calcul des niveaux switch (type) { - case ImageType_1D: - case ImageType_1D_Array: + case ImageType::E1D: + case ImageType::E1D_Array: return GetMaxLevel(width, 1U, 1U); - case ImageType_2D: - case ImageType_2D_Array: - case ImageType_Cubemap: + case ImageType::E2D: + case ImageType::E2D_Array: + case ImageType::Cubemap: return GetMaxLevel(width, height, 1U); - case ImageType_3D: + case ImageType::E3D: return GetMaxLevel(width, height, depth); } - NazaraError("Image type not handled (0x" + NumberToString(type, 16) + ')'); + NazaraError("Image type not handled (0x" + NumberToString(UnderlyingCast(type), 16) + ')'); return 0; } - ImageRef Image::LoadFromFile(const std::filesystem::path& filePath, const ImageParams& params) + std::shared_ptr Image::LoadFromFile(const std::filesystem::path& filePath, const ImageParams& params) { - return ImageLoader::LoadFromFile(filePath, params); + Utility* utility = Utility::Instance(); + NazaraAssert(utility, "Utility module has not been initialized"); + + return utility->GetImageLoader().LoadFromFile(filePath, params); } - ImageRef Image::LoadFromMemory(const void* data, std::size_t size, const ImageParams& params) + std::shared_ptr Image::LoadFromMemory(const void* data, std::size_t size, const ImageParams& params) { - return ImageLoader::LoadFromMemory(data, size, params); + Utility* utility = Utility::Instance(); + NazaraAssert(utility, "Utility module has not been initialized"); + + return utility->GetImageLoader().LoadFromMemory(data, size, params); } - ImageRef Image::LoadFromStream(Stream& stream, const ImageParams& params) + std::shared_ptr Image::LoadFromStream(Stream& stream, const ImageParams& params) { - return ImageLoader::LoadFromStream(stream, params); + Utility* utility = Utility::Instance(); + NazaraAssert(utility, "Utility module has not been initialized"); + + return utility->GetImageLoader().LoadFromStream(stream, params); } void Image::EnsureOwnership() @@ -1476,33 +1487,5 @@ namespace Nz m_sharedImage = &emptyImage; } - bool Image::Initialize() - { - if (!ImageLibrary::Initialize()) - { - NazaraError("Failed to initialise library"); - return false; - } - - if (!ImageManager::Initialize()) - { - NazaraError("Failed to initialise manager"); - return false; - } - - return true; - } - - void Image::Uninitialize() - { - ImageManager::Uninitialize(); - ImageLibrary::Uninitialize(); - } - - Image::SharedImage Image::emptyImage(0, ImageType_2D, PixelFormat_Undefined, Image::SharedImage::PixelContainer(), 0, 0, 0); - ImageLibrary::LibraryMap Image::s_library; - ImageLoader::LoaderList Image::s_loaders; - ImageManager::ManagerMap Image::s_managerMap; - ImageManager::ManagerParams Image::s_managerParameters; - ImageSaver::SaverList Image::s_savers; + Image::SharedImage Image::emptyImage(0, ImageType::E2D, PixelFormat::Undefined, Image::SharedImage::PixelContainer(), 0, 0, 0); } diff --git a/src/Nazara/Utility/IndexBuffer.cpp b/src/Nazara/Utility/IndexBuffer.cpp index b0cadc27c..fc07d1012 100644 --- a/src/Nazara/Utility/IndexBuffer.cpp +++ b/src/Nazara/Utility/IndexBuffer.cpp @@ -13,13 +13,13 @@ namespace Nz { - IndexBuffer::IndexBuffer(bool largeIndices, BufferRef buffer) + IndexBuffer::IndexBuffer(bool largeIndices, std::shared_ptr buffer) { ErrorFlags(ErrorFlag_ThrowException, true); Reset(largeIndices, std::move(buffer)); } - IndexBuffer::IndexBuffer(bool largeIndices, BufferRef buffer, std::size_t offset, std::size_t size) + IndexBuffer::IndexBuffer(bool largeIndices, std::shared_ptr buffer, std::size_t offset, std::size_t size) { ErrorFlags(ErrorFlag_ThrowException, true); Reset(largeIndices, std::move(buffer), offset, size); @@ -31,24 +31,9 @@ namespace Nz Reset(largeIndices, length, storage, usage); } - IndexBuffer::IndexBuffer(const IndexBuffer& indexBuffer) : - RefCounted(), - m_buffer(indexBuffer.m_buffer), - m_endOffset(indexBuffer.m_endOffset), - m_indexCount(indexBuffer.m_indexCount), - m_startOffset(indexBuffer.m_startOffset), - m_largeIndices(indexBuffer.m_largeIndices) - { - } - - IndexBuffer::~IndexBuffer() - { - OnIndexBufferRelease(this); - } - unsigned int IndexBuffer::ComputeCacheMissCount() const { - IndexMapper mapper(this); + IndexMapper mapper(*this); return Nz::ComputeCacheMissCount(mapper.begin(), m_indexCount); } @@ -86,27 +71,27 @@ namespace Nz void IndexBuffer::Optimize() { - IndexMapper mapper(this); + IndexMapper mapper(*this); OptimizeIndices(mapper.begin(), m_indexCount); } void IndexBuffer::Reset() { - m_buffer.Reset(); + m_buffer.reset(); } - void IndexBuffer::Reset(bool largeIndices, BufferRef buffer) + void IndexBuffer::Reset(bool largeIndices, std::shared_ptr buffer) { NazaraAssert(buffer && buffer->IsValid(), "Invalid buffer"); Reset(largeIndices, buffer, 0, buffer->GetSize()); } - void IndexBuffer::Reset(bool largeIndices, BufferRef buffer, std::size_t offset, std::size_t size) + void IndexBuffer::Reset(bool largeIndices, std::shared_ptr buffer, std::size_t offset, std::size_t size) { NazaraAssert(buffer && buffer->IsValid(), "Invalid buffer"); - NazaraAssert(buffer->GetType() == BufferType_Index, "Buffer must be an index buffer"); + NazaraAssert(buffer->GetType() == BufferType::Index, "Buffer must be an index buffer"); NazaraAssert(size > 0, "Invalid size"); NazaraAssert(offset + size > buffer->GetSize(), "Virtual buffer exceed buffer bounds"); @@ -128,7 +113,7 @@ namespace Nz m_largeIndices = largeIndices; m_startOffset = 0; - m_buffer = Buffer::New(BufferType_Index, m_endOffset, storage, usage); + m_buffer = std::make_shared(BufferType::Index, m_endOffset, storage, usage); } void IndexBuffer::Reset(const IndexBuffer& indexBuffer) @@ -144,11 +129,4 @@ namespace Nz { m_buffer->Unmap(); } - - IndexBuffer& IndexBuffer::operator=(const IndexBuffer& indexBuffer) - { - Reset(indexBuffer); - - return *this; - } } diff --git a/src/Nazara/Utility/IndexMapper.cpp b/src/Nazara/Utility/IndexMapper.cpp index 7bc0ecb1e..efdfb921d 100644 --- a/src/Nazara/Utility/IndexMapper.cpp +++ b/src/Nazara/Utility/IndexMapper.cpp @@ -49,67 +49,50 @@ namespace Nz } } - IndexMapper::IndexMapper(IndexBuffer* indexBuffer, BufferAccess access, std::size_t indexCount) : - m_indexCount((indexCount != 0) ? indexCount : indexBuffer->GetIndexCount()) + IndexMapper::IndexMapper(IndexBuffer& indexBuffer, BufferAccess access, std::size_t indexCount) : + m_indexCount((indexCount != 0) ? indexCount : indexBuffer.GetIndexCount()) { - NazaraAssert(indexCount != 0 || indexBuffer, "Invalid index count with invalid index buffer"); + if (!m_mapper.Map(indexBuffer, access)) + NazaraError("Failed to map buffer"); ///TODO: Unexcepted - if (indexBuffer) + if (indexBuffer.HasLargeIndices()) { - if (!m_mapper.Map(indexBuffer, access)) - NazaraError("Failed to map buffer"); ///TODO: Unexcepted - - if (indexBuffer->HasLargeIndices()) - { - m_getter = Getter32; - if (access != BufferAccess_ReadOnly) - m_setter = Setter32; - else - m_setter = SetterError; - } + m_getter = Getter32; + if (access != BufferAccess::ReadOnly) + m_setter = Setter32; else - { - m_getter = Getter16; - if (access != BufferAccess_ReadOnly) - m_setter = Setter16; - else - m_setter = SetterError; - } + m_setter = SetterError; } else { - m_getter = GetterSequential; - m_setter = SetterError; + m_getter = Getter16; + if (access != BufferAccess::ReadOnly) + m_setter = Setter16; + else + m_setter = SetterError; } } - IndexMapper::IndexMapper(SubMesh* subMesh, BufferAccess access) : - IndexMapper(subMesh->GetIndexBuffer(), access, (subMesh->GetIndexBuffer()) ? 0 : subMesh->GetVertexCount()) + IndexMapper::IndexMapper(SubMesh& subMesh, BufferAccess access) : + IndexMapper(*subMesh.GetIndexBuffer(), access, (subMesh.GetIndexBuffer()) ? 0 : subMesh.GetVertexCount()) { } - IndexMapper::IndexMapper(const IndexBuffer* indexBuffer, BufferAccess access, std::size_t indexCount) : + IndexMapper::IndexMapper(const IndexBuffer& indexBuffer, BufferAccess access, std::size_t indexCount) : m_setter(SetterError), - m_indexCount((indexCount != 0) ? indexCount : indexBuffer->GetIndexCount()) + m_indexCount((indexCount != 0) ? indexCount : indexBuffer.GetIndexCount()) { - NazaraAssert(indexCount != 0 || indexBuffer, "Invalid index count with invalid index buffer"); + if (!m_mapper.Map(indexBuffer, access)) + NazaraError("Failed to map buffer"); ///TODO: Unexcepted - if (indexBuffer) - { - if (!m_mapper.Map(indexBuffer, access)) - NazaraError("Failed to map buffer"); ///TODO: Unexcepted - - if (indexBuffer->HasLargeIndices()) - m_getter = Getter32; - else - m_getter = Getter16; - } + if (indexBuffer.HasLargeIndices()) + m_getter = Getter32; else - m_getter = GetterSequential; + m_getter = Getter16; } - IndexMapper::IndexMapper(const SubMesh* subMesh, BufferAccess access) : - IndexMapper(subMesh->GetIndexBuffer(), access, (subMesh->GetIndexBuffer()) ? 0 : subMesh->GetVertexCount()) + IndexMapper::IndexMapper(const SubMesh& subMesh, BufferAccess access) : + IndexMapper(*subMesh.GetIndexBuffer(), access, (subMesh.GetIndexBuffer()) ? 0 : subMesh.GetVertexCount()) { } diff --git a/src/Nazara/Utility/Mesh.cpp b/src/Nazara/Utility/Mesh.cpp index 38ddcc512..055bd4c86 100644 --- a/src/Nazara/Utility/Mesh.cpp +++ b/src/Nazara/Utility/Mesh.cpp @@ -14,6 +14,7 @@ #include #include #include +#include #include #include #include @@ -25,7 +26,7 @@ namespace Nz MeshParams::MeshParams() { if (!Buffer::IsStorageSupported(storage)) - storage = DataStorage_Software; + storage = DataStorage::Software; } bool MeshParams::IsValid() const @@ -48,7 +49,7 @@ namespace Nz return false; } - if (!vertexDeclaration->HasComponent(VertexComponent_Position)) + if (!vertexDeclaration->HasComponent(VertexComponent::Position)) { NazaraError("Vertex declaration must contains a vertex position"); return false; @@ -58,7 +59,7 @@ namespace Nz } - void Mesh::AddSubMesh(SubMesh* subMesh) + void Mesh::AddSubMesh(std::shared_ptr subMesh) { NazaraAssert(m_isValid, "Mesh should be created first"); NazaraAssert(subMesh, "Invalid submesh"); @@ -66,13 +67,13 @@ namespace Nz m_subMeshes.emplace_back(); SubMeshData& subMeshData = m_subMeshes.back(); - subMeshData.subMesh = subMesh; - subMeshData.onSubMeshInvalidated.Connect(subMesh->OnSubMeshInvalidateAABB, [this](const SubMesh* /*subMesh*/) { InvalidateAABB(); }); + subMeshData.subMesh = std::move(subMesh); + subMeshData.onSubMeshInvalidated.Connect(subMeshData.subMesh->OnSubMeshInvalidateAABB, [this](const SubMesh* /*subMesh*/) { InvalidateAABB(); }); InvalidateAABB(); } - void Mesh::AddSubMesh(const std::string& identifier, SubMesh* subMesh) + void Mesh::AddSubMesh(const std::string& identifier, std::shared_ptr subMesh) { NazaraAssert(m_isValid, "Mesh should be created first"); NazaraAssert(!identifier.empty(), "Identifier is empty"); @@ -82,26 +83,26 @@ namespace Nz std::size_t index = m_subMeshes.size(); - AddSubMesh(subMesh); + AddSubMesh(std::move(subMesh)); m_subMeshMap[identifier] = static_cast(index); } - SubMesh* Mesh::BuildSubMesh(const Primitive& primitive, const MeshParams& params) + std::shared_ptr Mesh::BuildSubMesh(const Primitive& primitive, const MeshParams& params) { NazaraAssert(m_isValid, "Mesh should be created first"); - NazaraAssert(m_animationType == AnimationType_Static, "Submesh building only works for static meshes"); + NazaraAssert(m_animationType == AnimationType::Static, "Submesh building only works for static meshes"); NazaraAssert(params.IsValid(), "Invalid parameters"); - NazaraAssert(params.vertexDeclaration->HasComponentOfType(VertexComponent_Position), "The vertex declaration doesn't have a Vector3 position component"); + NazaraAssert(params.vertexDeclaration->HasComponentOfType(VertexComponent::Position), "The vertex declaration doesn't have a Vector3 position component"); Boxf aabb; - IndexBufferRef indexBuffer; - VertexBufferRef vertexBuffer; + std::shared_ptr indexBuffer; + std::shared_ptr vertexBuffer; Matrix4f matrix(primitive.matrix); matrix *= params.matrix; - VertexDeclaration* declaration = params.vertexDeclaration; + const std::shared_ptr& declaration = params.vertexDeclaration; switch (primitive.type) { @@ -111,18 +112,18 @@ namespace Nz unsigned int vertexCount; ComputeBoxIndexVertexCount(primitive.box.subdivision, &indexCount, &vertexCount); - indexBuffer = IndexBuffer::New(vertexCount > std::numeric_limits::max(), indexCount, params.storage, params.indexBufferFlags); - vertexBuffer = VertexBuffer::New(declaration, vertexCount, params.storage, params.vertexBufferFlags); + indexBuffer = std::make_shared(vertexCount > std::numeric_limits::max(), indexCount, params.storage, params.indexBufferFlags); + vertexBuffer = std::make_shared(declaration, vertexCount, params.storage, params.vertexBufferFlags); - VertexMapper vertexMapper(vertexBuffer, BufferAccess_WriteOnly); + VertexMapper vertexMapper(*vertexBuffer, BufferAccess::WriteOnly); VertexPointers pointers; - pointers.normalPtr = vertexMapper.GetComponentPtr(VertexComponent_Normal); - pointers.positionPtr = vertexMapper.GetComponentPtr(VertexComponent_Position); - pointers.tangentPtr = vertexMapper.GetComponentPtr(VertexComponent_Tangent); - pointers.uvPtr = vertexMapper.GetComponentPtr(VertexComponent_TexCoord); + pointers.normalPtr = vertexMapper.GetComponentPtr(VertexComponent::Normal); + pointers.positionPtr = vertexMapper.GetComponentPtr(VertexComponent::Position); + pointers.tangentPtr = vertexMapper.GetComponentPtr(VertexComponent::Tangent); + pointers.uvPtr = vertexMapper.GetComponentPtr(VertexComponent::TexCoord); - IndexMapper indexMapper(indexBuffer, BufferAccess_WriteOnly); + IndexMapper indexMapper(*indexBuffer, BufferAccess::WriteOnly); GenerateBox(primitive.box.lengths, primitive.box.subdivision, matrix, primitive.textureCoords, pointers, indexMapper.begin(), &aabb); break; } @@ -133,18 +134,18 @@ namespace Nz unsigned int vertexCount; ComputeConeIndexVertexCount(primitive.cone.subdivision, &indexCount, &vertexCount); - indexBuffer = IndexBuffer::New(vertexCount > std::numeric_limits::max(), indexCount, params.storage, params.indexBufferFlags); - vertexBuffer = VertexBuffer::New(declaration, vertexCount, params.storage, params.vertexBufferFlags); + indexBuffer = std::make_shared(vertexCount > std::numeric_limits::max(), indexCount, params.storage, params.indexBufferFlags); + vertexBuffer = std::make_shared(declaration, vertexCount, params.storage, params.vertexBufferFlags); - VertexMapper vertexMapper(vertexBuffer, BufferAccess_WriteOnly); + VertexMapper vertexMapper(*vertexBuffer, BufferAccess::WriteOnly); VertexPointers pointers; - pointers.normalPtr = vertexMapper.GetComponentPtr(VertexComponent_Normal); - pointers.positionPtr = vertexMapper.GetComponentPtr(VertexComponent_Position); - pointers.tangentPtr = vertexMapper.GetComponentPtr(VertexComponent_Tangent); - pointers.uvPtr = vertexMapper.GetComponentPtr(VertexComponent_TexCoord); + pointers.normalPtr = vertexMapper.GetComponentPtr(VertexComponent::Normal); + pointers.positionPtr = vertexMapper.GetComponentPtr(VertexComponent::Position); + pointers.tangentPtr = vertexMapper.GetComponentPtr(VertexComponent::Tangent); + pointers.uvPtr = vertexMapper.GetComponentPtr(VertexComponent::TexCoord); - IndexMapper indexMapper(indexBuffer, BufferAccess_WriteOnly); + IndexMapper indexMapper(*indexBuffer, BufferAccess::WriteOnly); GenerateCone(primitive.cone.length, primitive.cone.radius, primitive.cone.subdivision, matrix, primitive.textureCoords, pointers, indexMapper.begin(), &aabb); break; } @@ -155,18 +156,18 @@ namespace Nz unsigned int vertexCount; ComputePlaneIndexVertexCount(primitive.plane.subdivision, &indexCount, &vertexCount); - indexBuffer = IndexBuffer::New(vertexCount > std::numeric_limits::max(), indexCount, params.storage, params.indexBufferFlags); - vertexBuffer = VertexBuffer::New(declaration, vertexCount, params.storage, params.vertexBufferFlags); + indexBuffer = std::make_shared(vertexCount > std::numeric_limits::max(), indexCount, params.storage, params.indexBufferFlags); + vertexBuffer = std::make_shared(declaration, vertexCount, params.storage, params.vertexBufferFlags); - VertexMapper vertexMapper(vertexBuffer, BufferAccess_WriteOnly); + VertexMapper vertexMapper(*vertexBuffer, BufferAccess::WriteOnly); VertexPointers pointers; - pointers.normalPtr = vertexMapper.GetComponentPtr(VertexComponent_Normal); - pointers.positionPtr = vertexMapper.GetComponentPtr(VertexComponent_Position); - pointers.tangentPtr = vertexMapper.GetComponentPtr(VertexComponent_Tangent); - pointers.uvPtr = vertexMapper.GetComponentPtr(VertexComponent_TexCoord); + pointers.normalPtr = vertexMapper.GetComponentPtr(VertexComponent::Normal); + pointers.positionPtr = vertexMapper.GetComponentPtr(VertexComponent::Position); + pointers.tangentPtr = vertexMapper.GetComponentPtr(VertexComponent::Tangent); + pointers.uvPtr = vertexMapper.GetComponentPtr(VertexComponent::TexCoord); - IndexMapper indexMapper(indexBuffer, BufferAccess_WriteOnly); + IndexMapper indexMapper(*indexBuffer, BufferAccess::WriteOnly); GeneratePlane(primitive.plane.subdivision, primitive.plane.size, matrix, primitive.textureCoords, pointers, indexMapper.begin(), &aabb); break; } @@ -181,18 +182,18 @@ namespace Nz unsigned int vertexCount; ComputeCubicSphereIndexVertexCount(primitive.sphere.cubic.subdivision, &indexCount, &vertexCount); - indexBuffer = IndexBuffer::New(vertexCount > std::numeric_limits::max(), indexCount, params.storage, params.indexBufferFlags); - vertexBuffer = VertexBuffer::New(declaration, vertexCount, params.storage, params.vertexBufferFlags); + indexBuffer = std::make_shared(vertexCount > std::numeric_limits::max(), indexCount, params.storage, params.indexBufferFlags); + vertexBuffer = std::make_shared(declaration, vertexCount, params.storage, params.vertexBufferFlags); - VertexMapper vertexMapper(vertexBuffer, BufferAccess_ReadWrite); + VertexMapper vertexMapper(*vertexBuffer, BufferAccess::ReadWrite); VertexPointers pointers; - pointers.normalPtr = vertexMapper.GetComponentPtr(VertexComponent_Normal); - pointers.positionPtr = vertexMapper.GetComponentPtr(VertexComponent_Position); - pointers.tangentPtr = vertexMapper.GetComponentPtr(VertexComponent_Tangent); - pointers.uvPtr = vertexMapper.GetComponentPtr(VertexComponent_TexCoord); + pointers.normalPtr = vertexMapper.GetComponentPtr(VertexComponent::Normal); + pointers.positionPtr = vertexMapper.GetComponentPtr(VertexComponent::Position); + pointers.tangentPtr = vertexMapper.GetComponentPtr(VertexComponent::Tangent); + pointers.uvPtr = vertexMapper.GetComponentPtr(VertexComponent::TexCoord); - IndexMapper indexMapper(indexBuffer, BufferAccess_WriteOnly); + IndexMapper indexMapper(*indexBuffer, BufferAccess::WriteOnly); GenerateCubicSphere(primitive.sphere.size, primitive.sphere.cubic.subdivision, matrix, primitive.textureCoords, pointers, indexMapper.begin(), &aabb); break; } @@ -203,18 +204,18 @@ namespace Nz unsigned int vertexCount; ComputeIcoSphereIndexVertexCount(primitive.sphere.ico.recursionLevel, &indexCount, &vertexCount); - indexBuffer = IndexBuffer::New(vertexCount > std::numeric_limits::max(), indexCount, params.storage, params.indexBufferFlags); - vertexBuffer = VertexBuffer::New(declaration, vertexCount, params.storage, params.vertexBufferFlags); + indexBuffer = std::make_shared(vertexCount > std::numeric_limits::max(), indexCount, params.storage, params.indexBufferFlags); + vertexBuffer = std::make_shared(declaration, vertexCount, params.storage, params.vertexBufferFlags); - VertexMapper vertexMapper(vertexBuffer, BufferAccess_WriteOnly); + VertexMapper vertexMapper(*vertexBuffer, BufferAccess::WriteOnly); VertexPointers pointers; - pointers.normalPtr = vertexMapper.GetComponentPtr(VertexComponent_Normal); - pointers.positionPtr = vertexMapper.GetComponentPtr(VertexComponent_Position); - pointers.tangentPtr = vertexMapper.GetComponentPtr(VertexComponent_Tangent); - pointers.uvPtr = vertexMapper.GetComponentPtr(VertexComponent_TexCoord); + pointers.normalPtr = vertexMapper.GetComponentPtr(VertexComponent::Normal); + pointers.positionPtr = vertexMapper.GetComponentPtr(VertexComponent::Position); + pointers.tangentPtr = vertexMapper.GetComponentPtr(VertexComponent::Tangent); + pointers.uvPtr = vertexMapper.GetComponentPtr(VertexComponent::TexCoord); - IndexMapper indexMapper(indexBuffer, BufferAccess_WriteOnly); + IndexMapper indexMapper(*indexBuffer, BufferAccess::WriteOnly); GenerateIcoSphere(primitive.sphere.size, primitive.sphere.ico.recursionLevel, matrix, primitive.textureCoords, pointers, indexMapper.begin(), &aabb); break; } @@ -225,18 +226,18 @@ namespace Nz unsigned int vertexCount; ComputeUvSphereIndexVertexCount(primitive.sphere.uv.sliceCount, primitive.sphere.uv.stackCount, &indexCount, &vertexCount); - indexBuffer = IndexBuffer::New(vertexCount > std::numeric_limits::max(), indexCount, params.storage, params.indexBufferFlags); - vertexBuffer = VertexBuffer::New(declaration, vertexCount, params.storage, params.vertexBufferFlags); + indexBuffer = std::make_shared(vertexCount > std::numeric_limits::max(), indexCount, params.storage, params.indexBufferFlags); + vertexBuffer = std::make_shared(declaration, vertexCount, params.storage, params.vertexBufferFlags); - VertexMapper vertexMapper(vertexBuffer, BufferAccess_WriteOnly); + VertexMapper vertexMapper(*vertexBuffer, BufferAccess::WriteOnly); VertexPointers pointers; - pointers.normalPtr = vertexMapper.GetComponentPtr(VertexComponent_Normal); - pointers.positionPtr = vertexMapper.GetComponentPtr(VertexComponent_Position); - pointers.tangentPtr = vertexMapper.GetComponentPtr(VertexComponent_Tangent); - pointers.uvPtr = vertexMapper.GetComponentPtr(VertexComponent_TexCoord); + pointers.normalPtr = vertexMapper.GetComponentPtr(VertexComponent::Normal); + pointers.positionPtr = vertexMapper.GetComponentPtr(VertexComponent::Position); + pointers.tangentPtr = vertexMapper.GetComponentPtr(VertexComponent::Tangent); + pointers.uvPtr = vertexMapper.GetComponentPtr(VertexComponent::TexCoord); - IndexMapper indexMapper(indexBuffer, BufferAccess_WriteOnly); + IndexMapper indexMapper(*indexBuffer, BufferAccess::WriteOnly); GenerateUvSphere(primitive.sphere.size, primitive.sphere.uv.sliceCount, primitive.sphere.uv.stackCount, matrix, primitive.textureCoords, pointers, indexMapper.begin(), &aabb); break; } @@ -248,7 +249,7 @@ namespace Nz if (params.optimizeIndexBuffers) indexBuffer->Optimize(); - StaticMeshRef subMesh = StaticMesh::New(vertexBuffer, indexBuffer); + std::shared_ptr subMesh = std::make_shared(vertexBuffer, indexBuffer); subMesh->SetAABB(aabb); AddSubMesh(subMesh); @@ -265,7 +266,7 @@ namespace Nz { Destroy(); - m_animationType = AnimationType_Skeletal; + m_animationType = AnimationType::Skeletal; m_jointCount = jointCount; if (!m_skeleton.Create(jointCount)) { @@ -282,7 +283,7 @@ namespace Nz { Destroy(); - m_animationType = AnimationType_Static; + m_animationType = AnimationType::Static; m_isValid = true; return true; @@ -292,8 +293,6 @@ namespace Nz { if (m_isValid) { - OnMeshDestroy(this); - m_animationPath.clear(); m_materialData.clear(); m_materialData.resize(1); @@ -368,7 +367,7 @@ namespace Nz std::size_t Mesh::GetJointCount() const { NazaraAssert(m_isValid, "Mesh should be created first"); - NazaraAssert(m_animationType == AnimationType_Skeletal, "Mesh is not skeletal"); + NazaraAssert(m_animationType == AnimationType::Skeletal, "Mesh is not skeletal"); return m_jointCount; } @@ -399,7 +398,7 @@ namespace Nz Skeleton* Mesh::GetSkeleton() { NazaraAssert(m_isValid, "Mesh should be created first"); - NazaraAssert(m_animationType == AnimationType_Skeletal, "Mesh is not skeletal"); + NazaraAssert(m_animationType == AnimationType::Skeletal, "Mesh is not skeletal"); return &m_skeleton; } @@ -407,12 +406,12 @@ namespace Nz const Skeleton* Mesh::GetSkeleton() const { NazaraAssert(m_isValid, "Mesh should be created first"); - NazaraAssert(m_animationType == AnimationType_Skeletal, "Mesh is not skeletal"); + NazaraAssert(m_animationType == AnimationType::Skeletal, "Mesh is not skeletal"); return &m_skeleton; } - SubMesh* Mesh::GetSubMesh(const std::string& identifier) + const std::shared_ptr& Mesh::GetSubMesh(const std::string& identifier) const { NazaraAssert(m_isValid, "Mesh should be created first"); @@ -422,25 +421,7 @@ namespace Nz return m_subMeshes[it->second].subMesh; } - SubMesh* Mesh::GetSubMesh(std::size_t index) - { - NazaraAssert(m_isValid, "Mesh should be created first"); - NazaraAssert(index < m_subMeshes.size(), "Submesh index out of range"); - - return m_subMeshes[index].subMesh; - } - - const SubMesh* Mesh::GetSubMesh(const std::string& identifier) const - { - NazaraAssert(m_isValid, "Mesh should be created first"); - - auto it = m_subMeshMap.find(identifier); - NazaraAssert(it != m_subMeshMap.end(), "SubMesh " + identifier + " not found"); - - return m_subMeshes[it->second].subMesh; - } - - const SubMesh* Mesh::GetSubMesh(std::size_t index) const + const std::shared_ptr& Mesh::GetSubMesh(std::size_t index) const { NazaraAssert(m_isValid, "Mesh should be created first"); NazaraAssert(index < m_subMeshes.size(), "Submesh index out of range"); @@ -514,7 +495,7 @@ namespace Nz { NazaraAssert(m_isValid, "Mesh should be created first"); - return m_animationType != AnimationType_Static; + return m_animationType != AnimationType::Static; } bool Mesh::IsValid() const @@ -525,7 +506,7 @@ namespace Nz void Mesh::Recenter() { NazaraAssert(m_isValid, "Mesh should be created first"); - NazaraAssert(m_animationType == AnimationType_Static, "Mesh is not static"); + NazaraAssert(m_animationType == AnimationType::Static, "Mesh is not static"); // The center of our mesh is the center of our *global* AABB Vector3f center = GetAABB().GetCenter(); @@ -534,7 +515,7 @@ namespace Nz { StaticMesh& staticMesh = static_cast(*data.subMesh); - BufferMapper mapper(staticMesh.GetVertexBuffer(), BufferAccess_ReadWrite); + BufferMapper mapper(*staticMesh.GetVertexBuffer(), BufferAccess::ReadWrite); MeshVertex* vertices = static_cast(mapper.GetPointer()); std::size_t vertexCount = staticMesh.GetVertexCount(); @@ -577,12 +558,18 @@ namespace Nz bool Mesh::SaveToFile(const std::filesystem::path& filePath, const MeshParams& params) { - return MeshSaver::SaveToFile(*this, filePath, params); + Utility* utility = Utility::Instance(); + NazaraAssert(utility, "Utility module has not been initialized"); + + return utility->GetMeshSaver().SaveToFile(*this, filePath, params); } bool Mesh::SaveToStream(Stream& stream, const std::string& format, const MeshParams& params) { - return MeshSaver::SaveToStream(*this, stream, format, params); + Utility* utility = Utility::Instance(); + NazaraAssert(utility, "Utility module has not been initialized"); + + return utility->GetMeshSaver().SaveToStream(*this, stream, format, params); } void Mesh::SetAnimation(const std::filesystem::path& animationPath) @@ -614,7 +601,7 @@ namespace Nz if (matIndex >= matCount) { data.subMesh->SetMaterialIndex(0); // To prevent a crash - NazaraWarning("SubMesh " + PointerToString(data.subMesh) + " material index is over mesh new material count (" + NumberToString(matIndex) + " >= " + NumberToString(matCount) + "), setting it to first material"); + NazaraWarning("SubMesh " + PointerToString(data.subMesh.get()) + " material index is over mesh new material count (" + NumberToString(matIndex) + " >= " + NumberToString(matCount) + "), setting it to first material"); } } #endif @@ -623,13 +610,13 @@ namespace Nz void Mesh::Transform(const Matrix4f& matrix) { NazaraAssert(m_isValid, "Mesh should be created first"); - NazaraAssert(m_animationType == AnimationType_Static, "Mesh is not static"); + NazaraAssert(m_animationType == AnimationType::Static, "Mesh is not static"); for (SubMeshData& data : m_subMeshes) { StaticMesh& staticMesh = static_cast(*data.subMesh); - BufferMapper mapper(staticMesh.GetVertexBuffer(), BufferAccess_ReadWrite); + BufferMapper mapper(*staticMesh.GetVertexBuffer(), BufferAccess::ReadWrite); MeshVertex* vertices = static_cast(mapper.GetPointer()); Boxf aabb(vertices->position.x, vertices->position.y, vertices->position.z, 0.f, 0.f, 0.f); @@ -647,47 +634,27 @@ namespace Nz } } - MeshRef Mesh::LoadFromFile(const std::filesystem::path& filePath, const MeshParams& params) + std::shared_ptr Mesh::LoadFromFile(const std::filesystem::path& filePath, const MeshParams& params) { - return MeshLoader::LoadFromFile(filePath, params); + Utility* utility = Utility::Instance(); + NazaraAssert(utility, "Utility module has not been initialized"); + + return utility->GetMeshLoader().LoadFromFile(filePath, params); } - MeshRef Mesh::LoadFromMemory(const void* data, std::size_t size, const MeshParams& params) + std::shared_ptr Mesh::LoadFromMemory(const void* data, std::size_t size, const MeshParams& params) { - return MeshLoader::LoadFromMemory(data, size, params); + Utility* utility = Utility::Instance(); + NazaraAssert(utility, "Utility module has not been initialized"); + + return utility->GetMeshLoader().LoadFromMemory(data, size, params); } - MeshRef Mesh::LoadFromStream(Stream& stream, const MeshParams& params) + std::shared_ptr Mesh::LoadFromStream(Stream& stream, const MeshParams& params) { - return MeshLoader::LoadFromStream(stream, params); + Utility* utility = Utility::Instance(); + NazaraAssert(utility, "Utility module has not been initialized"); + + return utility->GetMeshLoader().LoadFromStream(stream, params); } - - bool Mesh::Initialize() - { - if (!MeshLibrary::Initialize()) - { - NazaraError("Failed to initialise library"); - return false; - } - - if (!MeshManager::Initialize()) - { - NazaraError("Failed to initialise manager"); - return false; - } - - return true; - } - - void Mesh::Uninitialize() - { - MeshManager::Uninitialize(); - MeshLibrary::Uninitialize(); - } - - MeshLibrary::LibraryMap Mesh::s_library; - MeshLoader::LoaderList Mesh::s_loaders; - MeshManager::ManagerMap Mesh::s_managerMap; - MeshManager::ManagerParams Mesh::s_managerParameters; - MeshSaver::SaverList Mesh::s_savers; } diff --git a/src/Nazara/Utility/Node.cpp b/src/Nazara/Utility/Node.cpp index 015ad3aeb..72289447a 100644 --- a/src/Nazara/Utility/Node.cpp +++ b/src/Nazara/Utility/Node.cpp @@ -136,7 +136,7 @@ namespace Nz NodeType Node::GetNodeType() const { - return NodeType_Default; + return NodeType::Default; } const Node* Node::GetParent() const diff --git a/src/Nazara/Utility/PixelFormat.cpp b/src/Nazara/Utility/PixelFormat.cpp index d5ecff45e..0c4f652ab 100644 --- a/src/Nazara/Utility/PixelFormat.cpp +++ b/src/Nazara/Utility/PixelFormat.cpp @@ -54,7 +54,7 @@ namespace Nz /**********************************A8***********************************/ template<> - UInt8* ConvertPixels(const UInt8* start, const UInt8* end, UInt8* dst) + UInt8* ConvertPixels(const UInt8* start, const UInt8* end, UInt8* dst) { while (start < end) { @@ -70,7 +70,7 @@ namespace Nz } template<> - UInt8* ConvertPixels(const UInt8* start, const UInt8* end, UInt8* dst) + UInt8* ConvertPixels(const UInt8* start, const UInt8* end, UInt8* dst) { while (start < end) { @@ -84,7 +84,7 @@ namespace Nz } template<> - UInt8* ConvertPixels(const UInt8* start, const UInt8* end, UInt8* dst) + UInt8* ConvertPixels(const UInt8* start, const UInt8* end, UInt8* dst) { UInt16* ptr = reinterpret_cast(dst); while (start < end) @@ -106,7 +106,7 @@ namespace Nz } template<> - UInt8* ConvertPixels(const UInt8* start, const UInt8* end, UInt8* dst) + UInt8* ConvertPixels(const UInt8* start, const UInt8* end, UInt8* dst) { UInt16* ptr = reinterpret_cast(dst); while (start < end) @@ -125,7 +125,7 @@ namespace Nz } template<> - UInt8* ConvertPixels(const UInt8* start, const UInt8* end, UInt8* dst) + UInt8* ConvertPixels(const UInt8* start, const UInt8* end, UInt8* dst) { while (start < end) { @@ -142,7 +142,7 @@ namespace Nz /**********************************BGR8***********************************/ template<> - UInt8* ConvertPixels(const UInt8* start, const UInt8* end, UInt8* dst) + UInt8* ConvertPixels(const UInt8* start, const UInt8* end, UInt8* dst) { while (start < end) { @@ -158,7 +158,7 @@ namespace Nz } template<> - UInt8* ConvertPixels(const UInt8* start, const UInt8* end, UInt8* dst) + UInt8* ConvertPixels(const UInt8* start, const UInt8* end, UInt8* dst) { //FIXME: Not correct std::size_t count = end - start; @@ -167,7 +167,7 @@ namespace Nz } template<> - UInt8* ConvertPixels(const UInt8* start, const UInt8* end, UInt8* dst) + UInt8* ConvertPixels(const UInt8* start, const UInt8* end, UInt8* dst) { while (start < end) { @@ -180,7 +180,7 @@ namespace Nz } template<> - UInt8* ConvertPixels(const UInt8* start, const UInt8* end, UInt8* dst) + UInt8* ConvertPixels(const UInt8* start, const UInt8* end, UInt8* dst) { while (start < end) { @@ -194,7 +194,7 @@ namespace Nz } template<> - UInt8* ConvertPixels(const UInt8* start, const UInt8* end, UInt8* dst) + UInt8* ConvertPixels(const UInt8* start, const UInt8* end, UInt8* dst) { UInt16* ptr = reinterpret_cast(dst); while (start < end) @@ -216,7 +216,7 @@ namespace Nz } template<> - UInt8* ConvertPixels(const UInt8* start, const UInt8* end, UInt8* dst) + UInt8* ConvertPixels(const UInt8* start, const UInt8* end, UInt8* dst) { while (start < end) { @@ -231,7 +231,7 @@ namespace Nz } template<> - UInt8* ConvertPixels(const UInt8* start, const UInt8* end, UInt8* dst) + UInt8* ConvertPixels(const UInt8* start, const UInt8* end, UInt8* dst) { UInt16* ptr = reinterpret_cast(dst); while (start < end) @@ -253,7 +253,7 @@ namespace Nz } template<> - UInt8* ConvertPixels(const UInt8* start, const UInt8* end, UInt8* dst) + UInt8* ConvertPixels(const UInt8* start, const UInt8* end, UInt8* dst) { while (start < end) { @@ -270,7 +270,7 @@ namespace Nz /**********************************BGRA8**********************************/ template<> - UInt8* ConvertPixels(const UInt8* start, const UInt8* end, UInt8* dst) + UInt8* ConvertPixels(const UInt8* start, const UInt8* end, UInt8* dst) { while (start < end) { @@ -283,7 +283,7 @@ namespace Nz } template<> - UInt8* ConvertPixels(const UInt8* start, const UInt8* end, UInt8* dst) + UInt8* ConvertPixels(const UInt8* start, const UInt8* end, UInt8* dst) { while (start < end) { @@ -298,7 +298,7 @@ namespace Nz } template<> - UInt8* ConvertPixels(const UInt8* start, const UInt8* end, UInt8* dst) + UInt8* ConvertPixels(const UInt8* start, const UInt8* end, UInt8* dst) { //FIXME: Not correct std::size_t count = end - start; @@ -307,7 +307,7 @@ namespace Nz } template<> - UInt8* ConvertPixels(const UInt8* start, const UInt8* end, UInt8* dst) + UInt8* ConvertPixels(const UInt8* start, const UInt8* end, UInt8* dst) { while (start < end) { @@ -320,7 +320,7 @@ namespace Nz } template<> - UInt8* ConvertPixels(const UInt8* start, const UInt8* end, UInt8* dst) + UInt8* ConvertPixels(const UInt8* start, const UInt8* end, UInt8* dst) { while (start < end) { @@ -334,7 +334,7 @@ namespace Nz } template<> - UInt8* ConvertPixels(const UInt8* start, const UInt8* end, UInt8* dst) + UInt8* ConvertPixels(const UInt8* start, const UInt8* end, UInt8* dst) { UInt16* ptr = reinterpret_cast(dst); while (start < end) @@ -356,7 +356,7 @@ namespace Nz } template<> - UInt8* ConvertPixels(const UInt8* start, const UInt8* end, UInt8* dst) + UInt8* ConvertPixels(const UInt8* start, const UInt8* end, UInt8* dst) { UInt16* ptr = reinterpret_cast(dst); while (start < end) @@ -378,7 +378,7 @@ namespace Nz } template<> - UInt8* ConvertPixels(const UInt8* start, const UInt8* end, UInt8* dst) + UInt8* ConvertPixels(const UInt8* start, const UInt8* end, UInt8* dst) { while (start < end) { @@ -393,7 +393,7 @@ namespace Nz } template<> - UInt8* ConvertPixels(const UInt8* start, const UInt8* end, UInt8* dst) + UInt8* ConvertPixels(const UInt8* start, const UInt8* end, UInt8* dst) { while (start < end) { @@ -410,7 +410,7 @@ namespace Nz /***********************************L8************************************/ template<> - UInt8* ConvertPixels(const UInt8* start, const UInt8* end, UInt8* dst) + UInt8* ConvertPixels(const UInt8* start, const UInt8* end, UInt8* dst) { while (start < end) { @@ -425,7 +425,7 @@ namespace Nz } template<> - UInt8* ConvertPixels(const UInt8* start, const UInt8* end, UInt8* dst) + UInt8* ConvertPixels(const UInt8* start, const UInt8* end, UInt8* dst) { while (start < end) { @@ -441,7 +441,7 @@ namespace Nz } template<> - UInt8* ConvertPixels(const UInt8* start, const UInt8* end, UInt8* dst) + UInt8* ConvertPixels(const UInt8* start, const UInt8* end, UInt8* dst) { while (start < end) { @@ -455,7 +455,7 @@ namespace Nz } template<> - UInt8* ConvertPixels(const UInt8* start, const UInt8* end, UInt8* dst) + UInt8* ConvertPixels(const UInt8* start, const UInt8* end, UInt8* dst) { UInt16* ptr = reinterpret_cast(dst); while (start < end) @@ -479,7 +479,7 @@ namespace Nz } template<> - UInt8* ConvertPixels(const UInt8* start, const UInt8* end, UInt8* dst) + UInt8* ConvertPixels(const UInt8* start, const UInt8* end, UInt8* dst) { while (start < end) { @@ -494,7 +494,7 @@ namespace Nz } template<> - UInt8* ConvertPixels(const UInt8* start, const UInt8* end, UInt8* dst) + UInt8* ConvertPixels(const UInt8* start, const UInt8* end, UInt8* dst) { UInt16* ptr = reinterpret_cast(dst); while (start < end) @@ -518,7 +518,7 @@ namespace Nz } template<> - UInt8* ConvertPixels(const UInt8* start, const UInt8* end, UInt8* dst) + UInt8* ConvertPixels(const UInt8* start, const UInt8* end, UInt8* dst) { while (start < end) { @@ -535,7 +535,7 @@ namespace Nz /***********************************LA8***********************************/ template<> - UInt8* ConvertPixels(const UInt8* start, const UInt8* end, UInt8* dst) + UInt8* ConvertPixels(const UInt8* start, const UInt8* end, UInt8* dst) { while (start < end) { @@ -548,7 +548,7 @@ namespace Nz } template<> - UInt8* ConvertPixels(const UInt8* start, const UInt8* end, UInt8* dst) + UInt8* ConvertPixels(const UInt8* start, const UInt8* end, UInt8* dst) { while (start < end) { @@ -563,7 +563,7 @@ namespace Nz } template<> - UInt8* ConvertPixels(const UInt8* start, const UInt8* end, UInt8* dst) + UInt8* ConvertPixels(const UInt8* start, const UInt8* end, UInt8* dst) { while (start < end) { @@ -579,7 +579,7 @@ namespace Nz } template<> - UInt8* ConvertPixels(const UInt8* start, const UInt8* end, UInt8* dst) + UInt8* ConvertPixels(const UInt8* start, const UInt8* end, UInt8* dst) { while (start < end) { @@ -592,7 +592,7 @@ namespace Nz } template<> - UInt8* ConvertPixels(const UInt8* start, const UInt8* end, UInt8* dst) + UInt8* ConvertPixels(const UInt8* start, const UInt8* end, UInt8* dst) { UInt16* ptr = reinterpret_cast(dst); while (start < end) @@ -613,7 +613,7 @@ namespace Nz } template<> - UInt8* ConvertPixels(const UInt8* start, const UInt8* end, UInt8* dst) + UInt8* ConvertPixels(const UInt8* start, const UInt8* end, UInt8* dst) { while (start < end) { @@ -628,7 +628,7 @@ namespace Nz } template<> - UInt8* ConvertPixels(const UInt8* start, const UInt8* end, UInt8* dst) + UInt8* ConvertPixels(const UInt8* start, const UInt8* end, UInt8* dst) { UInt16* ptr = reinterpret_cast(dst); while (start < end) @@ -649,7 +649,7 @@ namespace Nz } template<> - UInt8* ConvertPixels(const UInt8* start, const UInt8* end, UInt8* dst) + UInt8* ConvertPixels(const UInt8* start, const UInt8* end, UInt8* dst) { while (start < end) { @@ -666,7 +666,7 @@ namespace Nz /*********************************RGBA4***********************************/ template<> - UInt8* ConvertPixels(const UInt8* start, const UInt8* end, UInt8* dst) + UInt8* ConvertPixels(const UInt8* start, const UInt8* end, UInt8* dst) { while (start < end) { @@ -685,7 +685,7 @@ namespace Nz } template<> - UInt8* ConvertPixels(const UInt8* start, const UInt8* end, UInt8* dst) + UInt8* ConvertPixels(const UInt8* start, const UInt8* end, UInt8* dst) { while (start < end) { @@ -706,7 +706,7 @@ namespace Nz } template<> - UInt8* ConvertPixels(const UInt8* start, const UInt8* end, UInt8* dst) + UInt8* ConvertPixels(const UInt8* start, const UInt8* end, UInt8* dst) { while (start < end) { @@ -728,7 +728,7 @@ namespace Nz } template<> - UInt8* ConvertPixels(const UInt8* start, const UInt8* end, UInt8* dst) + UInt8* ConvertPixels(const UInt8* start, const UInt8* end, UInt8* dst) { while (start < end) { @@ -751,7 +751,7 @@ namespace Nz } template<> - UInt8* ConvertPixels(const UInt8* start, const UInt8* end, UInt8* dst) + UInt8* ConvertPixels(const UInt8* start, const UInt8* end, UInt8* dst) { while (start < end) { @@ -775,7 +775,7 @@ namespace Nz } template<> - UInt8* ConvertPixels(const UInt8* start, const UInt8* end, UInt8* dst) + UInt8* ConvertPixels(const UInt8* start, const UInt8* end, UInt8* dst) { UInt16* ptr = reinterpret_cast(dst); while (start < end) @@ -805,7 +805,7 @@ namespace Nz } template<> - UInt8* ConvertPixels(const UInt8* start, const UInt8* end, UInt8* dst) + UInt8* ConvertPixels(const UInt8* start, const UInt8* end, UInt8* dst) { while (start < end) { @@ -826,7 +826,7 @@ namespace Nz } template<> - UInt8* ConvertPixels(const UInt8* start, const UInt8* end, UInt8* dst) + UInt8* ConvertPixels(const UInt8* start, const UInt8* end, UInt8* dst) { while (start < end) { @@ -849,7 +849,7 @@ namespace Nz /*********************************RGB5A1**********************************/ template<> - UInt8* ConvertPixels(const UInt8* start, const UInt8* end, UInt8* dst) + UInt8* ConvertPixels(const UInt8* start, const UInt8* end, UInt8* dst) { while (start < end) { @@ -868,7 +868,7 @@ namespace Nz } template<> - UInt8* ConvertPixels(const UInt8* start, const UInt8* end, UInt8* dst) + UInt8* ConvertPixels(const UInt8* start, const UInt8* end, UInt8* dst) { while (start < end) { @@ -889,7 +889,7 @@ namespace Nz } template<> - UInt8* ConvertPixels(const UInt8* start, const UInt8* end, UInt8* dst) + UInt8* ConvertPixels(const UInt8* start, const UInt8* end, UInt8* dst) { while (start < end) { @@ -911,7 +911,7 @@ namespace Nz } template<> - UInt8* ConvertPixels(const UInt8* start, const UInt8* end, UInt8* dst) + UInt8* ConvertPixels(const UInt8* start, const UInt8* end, UInt8* dst) { while (start < end) { @@ -934,7 +934,7 @@ namespace Nz } template<> - UInt8* ConvertPixels(const UInt8* start, const UInt8* end, UInt8* dst) + UInt8* ConvertPixels(const UInt8* start, const UInt8* end, UInt8* dst) { while (start < end) { @@ -958,7 +958,7 @@ namespace Nz } template<> - UInt8* ConvertPixels(const UInt8* start, const UInt8* end, UInt8* dst) + UInt8* ConvertPixels(const UInt8* start, const UInt8* end, UInt8* dst) { while (start < end) { @@ -979,7 +979,7 @@ namespace Nz } template<> - UInt8* ConvertPixels(const UInt8* start, const UInt8* end, UInt8* dst) + UInt8* ConvertPixels(const UInt8* start, const UInt8* end, UInt8* dst) { UInt16* ptr = reinterpret_cast(dst); while (start < end) @@ -1008,7 +1008,7 @@ namespace Nz } template<> - UInt8* ConvertPixels(const UInt8* start, const UInt8* end, UInt8* dst) + UInt8* ConvertPixels(const UInt8* start, const UInt8* end, UInt8* dst) { while (start < end) { @@ -1031,7 +1031,7 @@ namespace Nz /**********************************RGB8***********************************/ template<> - UInt8* ConvertPixels(const UInt8* start, const UInt8* end, UInt8* dst) + UInt8* ConvertPixels(const UInt8* start, const UInt8* end, UInt8* dst) { while (start < end) { @@ -1046,7 +1046,7 @@ namespace Nz } template<> - UInt8* ConvertPixels(const UInt8* start, const UInt8* end, UInt8* dst) + UInt8* ConvertPixels(const UInt8* start, const UInt8* end, UInt8* dst) { while (start < end) { @@ -1062,7 +1062,7 @@ namespace Nz } template<> - UInt8* ConvertPixels(const UInt8* start, const UInt8* end, UInt8* dst) + UInt8* ConvertPixels(const UInt8* start, const UInt8* end, UInt8* dst) { while (start < end) { @@ -1075,7 +1075,7 @@ namespace Nz } template<> - UInt8* ConvertPixels(const UInt8* start, const UInt8* end, UInt8* dst) + UInt8* ConvertPixels(const UInt8* start, const UInt8* end, UInt8* dst) { while (start < end) { @@ -1089,7 +1089,7 @@ namespace Nz } template<> - UInt8* ConvertPixels(const UInt8* start, const UInt8* end, UInt8* dst) + UInt8* ConvertPixels(const UInt8* start, const UInt8* end, UInt8* dst) { UInt16* ptr = reinterpret_cast(dst); while (start < end) @@ -1111,7 +1111,7 @@ namespace Nz } template<> - UInt8* ConvertPixels(const UInt8* start, const UInt8* end, UInt8* dst) + UInt8* ConvertPixels(const UInt8* start, const UInt8* end, UInt8* dst) { UInt16* ptr = reinterpret_cast(dst); while (start < end) @@ -1133,7 +1133,7 @@ namespace Nz } template<> - UInt8* ConvertPixels(const UInt8* start, const UInt8* end, UInt8* dst) + UInt8* ConvertPixels(const UInt8* start, const UInt8* end, UInt8* dst) { //FIXME: Not correct std::size_t count = end - start; @@ -1142,7 +1142,7 @@ namespace Nz } template<> - UInt8* ConvertPixels(const UInt8* start, const UInt8* end, UInt8* dst) + UInt8* ConvertPixels(const UInt8* start, const UInt8* end, UInt8* dst) { while (start < end) { @@ -1159,7 +1159,7 @@ namespace Nz /**********************************RGBA8**********************************/ template<> - UInt8* ConvertPixels(const UInt8* start, const UInt8* end, UInt8* dst) + UInt8* ConvertPixels(const UInt8* start, const UInt8* end, UInt8* dst) { while (start < end) { @@ -1172,7 +1172,7 @@ namespace Nz } template<> - UInt8* ConvertPixels(const UInt8* start, const UInt8* end, UInt8* dst) + UInt8* ConvertPixels(const UInt8* start, const UInt8* end, UInt8* dst) { while (start < end) { @@ -1187,7 +1187,7 @@ namespace Nz } template<> - UInt8* ConvertPixels(const UInt8* start, const UInt8* end, UInt8* dst) + UInt8* ConvertPixels(const UInt8* start, const UInt8* end, UInt8* dst) { while (start < end) { @@ -1203,7 +1203,7 @@ namespace Nz } template<> - UInt8* ConvertPixels(const UInt8* start, const UInt8* end, UInt8* dst) + UInt8* ConvertPixels(const UInt8* start, const UInt8* end, UInt8* dst) { while (start < end) { @@ -1216,7 +1216,7 @@ namespace Nz } template<> - UInt8* ConvertPixels(const UInt8* start, const UInt8* end, UInt8* dst) + UInt8* ConvertPixels(const UInt8* start, const UInt8* end, UInt8* dst) { while (start < end) { @@ -1230,7 +1230,7 @@ namespace Nz } template<> - UInt8* ConvertPixels(const UInt8* start, const UInt8* end, UInt8* dst) + UInt8* ConvertPixels(const UInt8* start, const UInt8* end, UInt8* dst) { UInt16* ptr = reinterpret_cast(dst); while (start < end) @@ -1252,7 +1252,7 @@ namespace Nz } template<> - UInt8* ConvertPixels(const UInt8* start, const UInt8* end, UInt8* dst) + UInt8* ConvertPixels(const UInt8* start, const UInt8* end, UInt8* dst) { while (start < end) { @@ -1267,7 +1267,7 @@ namespace Nz } template<> - UInt8* ConvertPixels(const UInt8* start, const UInt8* end, UInt8* dst) + UInt8* ConvertPixels(const UInt8* start, const UInt8* end, UInt8* dst) { UInt16* ptr = reinterpret_cast(dst); while (start < end) @@ -1289,7 +1289,7 @@ namespace Nz } template<> - UInt8* ConvertPixels(const UInt8* start, const UInt8* end, UInt8* dst) + UInt8* ConvertPixels(const UInt8* start, const UInt8* end, UInt8* dst) { //FIXME: Not correct std::size_t count = end - start; @@ -1315,8 +1315,10 @@ namespace Nz } #endif - auto it = s_flipFunctions[flipping].find(format); - if (it != s_flipFunctions[flipping].end()) + std::size_t flippingIndex = UnderlyingCast(flipping); + + auto it = s_flipFunctions[flippingIndex].find(format); + if (it != s_flipFunctions[flippingIndex].end()) it->second(width, height, depth, reinterpret_cast(src), reinterpret_cast(dst)); else { @@ -1334,7 +1336,7 @@ namespace Nz unsigned int lineStride = width*bpp; switch (flipping) { - case PixelFlipping_Horizontally: + case PixelFlipping::Horizontally: { if (src == dst) { @@ -1363,7 +1365,7 @@ namespace Nz break; } - case PixelFlipping_Vertically: + case PixelFlipping::Vertically: { if (src == dst) { @@ -1403,7 +1405,7 @@ namespace Nz PixelFormat PixelFormatInfo::IdentifyFormat(const PixelFormatDescription& info) { - for (unsigned int i = 0; i <= PixelFormat_Max; ++i) + for (unsigned int i = 0; i < PixelFormatCount; ++i) { PixelFormatDescription& info2 = s_pixelFormatInfos[i]; if (info.bitsPerPixel == info2.bitsPerPixel && info.content == info2.content && @@ -1412,317 +1414,322 @@ namespace Nz return static_cast(i); } - return PixelFormat_Undefined; + return PixelFormat::Undefined; } bool PixelFormatInfo::Initialize() { + auto SetupPixelFormat = [](PixelFormat format, PixelFormatDescription&& desc) + { + s_pixelFormatInfos[UnderlyingCast(format)] = std::move(desc); + }; + Bitset<> b32(0xFFFFFFFF); b32.Resize(128); // Setup informations about every pixel format - s_pixelFormatInfos[PixelFormat_A8] = PixelFormatDescription("A8", PixelFormatContent_ColorRGBA, 0, 0, 0, 0xFF, PixelFormatSubType_Unsigned); - s_pixelFormatInfos[PixelFormat_BGR8] = PixelFormatDescription("BGR8", PixelFormatContent_ColorRGBA, 0x0000FF, 0x00FF00, 0xFF0000, 0, PixelFormatSubType_Unsigned); - s_pixelFormatInfos[PixelFormat_BGR8_SRGB] = PixelFormatDescription("BGR8_SRGB", PixelFormatContent_ColorRGBA, 0x0000FF, 0x00FF00, 0xFF0000, 0, PixelFormatSubType_Unsigned); - s_pixelFormatInfos[PixelFormat_BGRA8] = PixelFormatDescription("BGRA8", PixelFormatContent_ColorRGBA, 0x0000FF00, 0x00FF0000, 0xFF000000, 0x000000FF, PixelFormatSubType_Unsigned); - s_pixelFormatInfos[PixelFormat_BGRA8_SRGB] = PixelFormatDescription("BGRA8_SRGB", PixelFormatContent_ColorRGBA, 0x0000FF00, 0x00FF0000, 0xFF000000, 0x000000FF, PixelFormatSubType_Unsigned); - s_pixelFormatInfos[PixelFormat_DXT1] = PixelFormatDescription("DXT1", PixelFormatContent_ColorRGBA, 8, PixelFormatSubType_Compressed); - s_pixelFormatInfos[PixelFormat_DXT3] = PixelFormatDescription("DXT3", PixelFormatContent_ColorRGBA, 16, PixelFormatSubType_Compressed); - s_pixelFormatInfos[PixelFormat_DXT5] = PixelFormatDescription("DXT5", PixelFormatContent_ColorRGBA, 16, PixelFormatSubType_Compressed); - s_pixelFormatInfos[PixelFormat_L8] = PixelFormatDescription("L8", PixelFormatContent_ColorRGBA, 0xFF, 0xFF, 0xFF, 0, PixelFormatSubType_Unsigned); - s_pixelFormatInfos[PixelFormat_LA8] = PixelFormatDescription("LA8", PixelFormatContent_ColorRGBA, 0xFF00, 0xFF00, 0xFF00, 0x00FF, PixelFormatSubType_Unsigned); - s_pixelFormatInfos[PixelFormat_R8] = PixelFormatDescription("R8", PixelFormatContent_ColorRGBA, 0xFF, 0, 0, 0, PixelFormatSubType_Unsigned); - s_pixelFormatInfos[PixelFormat_R8I] = PixelFormatDescription("R8I", PixelFormatContent_ColorRGBA, 0xFF, 0, 0, 0, PixelFormatSubType_Int); - s_pixelFormatInfos[PixelFormat_R8UI] = PixelFormatDescription("R8UI", PixelFormatContent_ColorRGBA, 0xFF, 0, 0, 0, PixelFormatSubType_Unsigned); - s_pixelFormatInfos[PixelFormat_R16] = PixelFormatDescription("R16", PixelFormatContent_ColorRGBA, 0xFFFF, 0, 0, 0, PixelFormatSubType_Unsigned); - s_pixelFormatInfos[PixelFormat_R16F] = PixelFormatDescription("R16F", PixelFormatContent_ColorRGBA, 0xFFFF, 0, 0, 0, PixelFormatSubType_Half); - s_pixelFormatInfos[PixelFormat_R16I] = PixelFormatDescription("R16I", PixelFormatContent_ColorRGBA, 0xFFFF, 0, 0, 0, PixelFormatSubType_Int); - s_pixelFormatInfos[PixelFormat_R16UI] = PixelFormatDescription("R16UI", PixelFormatContent_ColorRGBA, 0xFFFF, 0, 0, 0, PixelFormatSubType_Unsigned); - s_pixelFormatInfos[PixelFormat_R32F] = PixelFormatDescription("R32F", PixelFormatContent_ColorRGBA, 0xFFFFFFFF, 0, 0, 0, PixelFormatSubType_Float); - s_pixelFormatInfos[PixelFormat_R32I] = PixelFormatDescription("R32I", PixelFormatContent_ColorRGBA, 0xFFFFFFFF, 0, 0, 0, PixelFormatSubType_Int); - s_pixelFormatInfos[PixelFormat_R32UI] = PixelFormatDescription("R32UI", PixelFormatContent_ColorRGBA, 0xFFFFFFFF, 0, 0, 0, PixelFormatSubType_Unsigned); - s_pixelFormatInfos[PixelFormat_RG8] = PixelFormatDescription("RG8", PixelFormatContent_ColorRGBA, 0xFF00, 0x00FF, 0, 0, PixelFormatSubType_Unsigned); - s_pixelFormatInfos[PixelFormat_RG8I] = PixelFormatDescription("RG8I", PixelFormatContent_ColorRGBA, 0xFF00, 0x00FF, 0, 0, PixelFormatSubType_Int); - s_pixelFormatInfos[PixelFormat_RG8UI] = PixelFormatDescription("RG8UI", PixelFormatContent_ColorRGBA, 0xFF00, 0x00FF, 0, 0, PixelFormatSubType_Unsigned); - s_pixelFormatInfos[PixelFormat_RG16] = PixelFormatDescription("RG16", PixelFormatContent_ColorRGBA, 0xFFFF0000, 0x0000FFFF, 0, 0, PixelFormatSubType_Unsigned); - s_pixelFormatInfos[PixelFormat_RG16F] = PixelFormatDescription("RG16F", PixelFormatContent_ColorRGBA, 0xFFFF0000, 0x0000FFFF, 0, 0, PixelFormatSubType_Half); - s_pixelFormatInfos[PixelFormat_RG16I] = PixelFormatDescription("RG16I", PixelFormatContent_ColorRGBA, 0xFFFF0000, 0x0000FFFF, 0, 0, PixelFormatSubType_Int); - s_pixelFormatInfos[PixelFormat_RG16UI] = PixelFormatDescription("RG16UI", PixelFormatContent_ColorRGBA, 0xFFFF0000, 0x0000FFFF, 0, 0, PixelFormatSubType_Unsigned); - s_pixelFormatInfos[PixelFormat_RG32F] = PixelFormatDescription("RG32F", PixelFormatContent_ColorRGBA, 0xFFFFFFFF00000000, 0x00000000FFFFFFFF, 0, 0, PixelFormatSubType_Float); - s_pixelFormatInfos[PixelFormat_RG32I] = PixelFormatDescription("RG32I", PixelFormatContent_ColorRGBA, 0xFFFFFFFF00000000, 0x00000000FFFFFFFF, 0, 0, PixelFormatSubType_Int); - s_pixelFormatInfos[PixelFormat_RG32UI] = PixelFormatDescription("RG32UI", PixelFormatContent_ColorRGBA, 0xFFFFFFFF00000000, 0x00000000FFFFFFFF, 0, 0, PixelFormatSubType_Unsigned); - s_pixelFormatInfos[PixelFormat_RGB8] = PixelFormatDescription("RGB8", PixelFormatContent_ColorRGBA, 0xFF000000, 0x00FF0000, 0x0000FF00, 0, PixelFormatSubType_Unsigned); - s_pixelFormatInfos[PixelFormat_RGB8_SRGB] = PixelFormatDescription("RGB8_SRGB", PixelFormatContent_ColorRGBA, 0xFF000000, 0x00FF0000, 0x0000FF00, 0, PixelFormatSubType_Unsigned); - s_pixelFormatInfos[PixelFormat_RGB16F] = PixelFormatDescription("RGB16F", PixelFormatContent_ColorRGBA, 0xFFFF00000000, 0x0000FFFF0000, 0x00000000FFFF, 0, PixelFormatSubType_Half); - s_pixelFormatInfos[PixelFormat_RGB16I] = PixelFormatDescription("RGB16I", PixelFormatContent_ColorRGBA, 0xFFFF00000000, 0x0000FFFF0000, 0x00000000FFFF, 0, PixelFormatSubType_Int); - s_pixelFormatInfos[PixelFormat_RGB16UI] = PixelFormatDescription("RGB16UI", PixelFormatContent_ColorRGBA, 0xFFFF000000000000, 0x0000FFFF00000000, 0x00000000FFFF0000, 0, PixelFormatSubType_Unsigned); - s_pixelFormatInfos[PixelFormat_RGB32F] = PixelFormatDescription("RGB32F", PixelFormatContent_ColorRGBA, b32, b32 >> 32, b32 >> 64, 0, PixelFormatSubType_Float); - s_pixelFormatInfos[PixelFormat_RGB32I] = PixelFormatDescription("RGB32I", PixelFormatContent_ColorRGBA, b32, b32 >> 32, b32 >> 64, 0, PixelFormatSubType_Int); - s_pixelFormatInfos[PixelFormat_RGB32UI] = PixelFormatDescription("RGB32UI", PixelFormatContent_ColorRGBA, b32, b32 >> 32, b32 >> 64, 0, PixelFormatSubType_Unsigned); - s_pixelFormatInfos[PixelFormat_RGBA4] = PixelFormatDescription("RGBA4", PixelFormatContent_ColorRGBA, 0xF000, 0x0F00, 0x00F0, 0x000F, PixelFormatSubType_Unsigned); - s_pixelFormatInfos[PixelFormat_RGB5A1] = PixelFormatDescription("RGB5A1", PixelFormatContent_ColorRGBA, 0xF800, 0x07C0, 0x003E, 0x0001, PixelFormatSubType_Unsigned); - s_pixelFormatInfos[PixelFormat_RGBA8] = PixelFormatDescription("RGBA8", PixelFormatContent_ColorRGBA, 0xFF000000, 0x00FF0000, 0x0000FF00, 0x000000FF, PixelFormatSubType_Unsigned); - s_pixelFormatInfos[PixelFormat_RGBA8_SRGB] = PixelFormatDescription("RGBA8_SRGB", PixelFormatContent_ColorRGBA, 0xFF000000, 0x00FF0000, 0x0000FF00, 0x000000FF, PixelFormatSubType_Unsigned); - s_pixelFormatInfos[PixelFormat_RGBA16F] = PixelFormatDescription("RGBA16F", PixelFormatContent_ColorRGBA, 0xFFFF000000000000, 0x0000FFFF00000000, 0x00000000FFFF0000, 0x000000000000FFFF, PixelFormatSubType_Half); - s_pixelFormatInfos[PixelFormat_RGBA16I] = PixelFormatDescription("RGBA16I", PixelFormatContent_ColorRGBA, 0xFFFF000000000000, 0x0000FFFF00000000, 0x00000000FFFF0000, 0x000000000000FFFF, PixelFormatSubType_Int); - s_pixelFormatInfos[PixelFormat_RGBA16UI] = PixelFormatDescription("RGBA16UI", PixelFormatContent_ColorRGBA, 0xFFFF000000000000, 0x0000FFFF00000000, 0x00000000FFFF0000, 0x000000000000FFFF, PixelFormatSubType_Unsigned); - s_pixelFormatInfos[PixelFormat_RGBA32F] = PixelFormatDescription("RGBA32F", PixelFormatContent_ColorRGBA, b32, b32 >> 32, b32 >> 64, b32 >> 96, PixelFormatSubType_Float); - s_pixelFormatInfos[PixelFormat_RGBA32I] = PixelFormatDescription("RGBA32I", PixelFormatContent_ColorRGBA, b32, b32 >> 32, b32 >> 64, b32 >> 96, PixelFormatSubType_Int); - s_pixelFormatInfos[PixelFormat_RGBA32UI] = PixelFormatDescription("RGBA32UI", PixelFormatContent_ColorRGBA, b32, b32 >> 32, b32 >> 64, b32 >> 96, PixelFormatSubType_Unsigned); - s_pixelFormatInfos[PixelFormat_Depth16] = PixelFormatDescription("Depth16", PixelFormatContent_Depth, 0xFFFF, 0, 0, 0, PixelFormatSubType_Unsigned); - s_pixelFormatInfos[PixelFormat_Depth24] = PixelFormatDescription("Depth24", PixelFormatContent_Depth, 0xFFFFFF, 0, 0, 0, PixelFormatSubType_Unsigned); - s_pixelFormatInfos[PixelFormat_Depth24Stencil8] = PixelFormatDescription("Depth24Stencil8", PixelFormatContent_DepthStencil, 0xFFFFFF00, 0x000000FF, 0, 0, PixelFormatSubType_Unsigned); - s_pixelFormatInfos[PixelFormat_Depth32] = PixelFormatDescription("Depth32", PixelFormatContent_Depth, 0xFFFFFFFF, 0, 0, 0, PixelFormatSubType_Unsigned); - s_pixelFormatInfos[PixelFormat_Stencil1] = PixelFormatDescription("Stencil1", PixelFormatContent_Stencil, 0x1, 0, 0, 0, PixelFormatSubType_Unsigned); - s_pixelFormatInfos[PixelFormat_Stencil4] = PixelFormatDescription("Stencil4", PixelFormatContent_Stencil, 0xF, 0, 0, 0, PixelFormatSubType_Unsigned); - s_pixelFormatInfos[PixelFormat_Stencil8] = PixelFormatDescription("Stencil8", PixelFormatContent_Stencil, 0xFF, 0, 0, 0, PixelFormatSubType_Unsigned); - s_pixelFormatInfos[PixelFormat_Stencil16] = PixelFormatDescription("Stencil16", PixelFormatContent_Stencil, 0xFFFF, 0, 0, 0, PixelFormatSubType_Unsigned); + SetupPixelFormat(PixelFormat::A8, PixelFormatDescription("A8", PixelFormatContent::ColorRGBA, 0, 0, 0, 0xFF, PixelFormatSubType::Unsigned)); + SetupPixelFormat(PixelFormat::BGR8, PixelFormatDescription("BGR8", PixelFormatContent::ColorRGBA, 0x0000FF, 0x00FF00, 0xFF0000, 0, PixelFormatSubType::Unsigned)); + SetupPixelFormat(PixelFormat::BGR8_SRGB, PixelFormatDescription("BGR8_SRGB", PixelFormatContent::ColorRGBA, 0x0000FF, 0x00FF00, 0xFF0000, 0, PixelFormatSubType::Unsigned)); + SetupPixelFormat(PixelFormat::BGRA8, PixelFormatDescription("BGRA8", PixelFormatContent::ColorRGBA, 0x0000FF00, 0x00FF0000, 0xFF000000, 0x000000FF, PixelFormatSubType::Unsigned)); + SetupPixelFormat(PixelFormat::BGRA8_SRGB, PixelFormatDescription("BGRA8_SRGB", PixelFormatContent::ColorRGBA, 0x0000FF00, 0x00FF0000, 0xFF000000, 0x000000FF, PixelFormatSubType::Unsigned)); + SetupPixelFormat(PixelFormat::DXT1, PixelFormatDescription("DXT1", PixelFormatContent::ColorRGBA, 8, PixelFormatSubType::Compressed)); + SetupPixelFormat(PixelFormat::DXT3, PixelFormatDescription("DXT3", PixelFormatContent::ColorRGBA, 16, PixelFormatSubType::Compressed)); + SetupPixelFormat(PixelFormat::DXT5, PixelFormatDescription("DXT5", PixelFormatContent::ColorRGBA, 16, PixelFormatSubType::Compressed)); + SetupPixelFormat(PixelFormat::L8, PixelFormatDescription("L8", PixelFormatContent::ColorRGBA, 0xFF, 0xFF, 0xFF, 0, PixelFormatSubType::Unsigned)); + SetupPixelFormat(PixelFormat::LA8, PixelFormatDescription("LA8", PixelFormatContent::ColorRGBA, 0xFF00, 0xFF00, 0xFF00, 0x00FF, PixelFormatSubType::Unsigned)); + SetupPixelFormat(PixelFormat::R8, PixelFormatDescription("R8", PixelFormatContent::ColorRGBA, 0xFF, 0, 0, 0, PixelFormatSubType::Unsigned)); + SetupPixelFormat(PixelFormat::R8I, PixelFormatDescription("R8I", PixelFormatContent::ColorRGBA, 0xFF, 0, 0, 0, PixelFormatSubType::Int)); + SetupPixelFormat(PixelFormat::R8UI, PixelFormatDescription("R8UI", PixelFormatContent::ColorRGBA, 0xFF, 0, 0, 0, PixelFormatSubType::Unsigned)); + SetupPixelFormat(PixelFormat::R16, PixelFormatDescription("R16", PixelFormatContent::ColorRGBA, 0xFFFF, 0, 0, 0, PixelFormatSubType::Unsigned)); + SetupPixelFormat(PixelFormat::R16F, PixelFormatDescription("R16F", PixelFormatContent::ColorRGBA, 0xFFFF, 0, 0, 0, PixelFormatSubType::Half)); + SetupPixelFormat(PixelFormat::R16I, PixelFormatDescription("R16I", PixelFormatContent::ColorRGBA, 0xFFFF, 0, 0, 0, PixelFormatSubType::Int)); + SetupPixelFormat(PixelFormat::R16UI, PixelFormatDescription("R16UI", PixelFormatContent::ColorRGBA, 0xFFFF, 0, 0, 0, PixelFormatSubType::Unsigned)); + SetupPixelFormat(PixelFormat::R32F, PixelFormatDescription("R32F", PixelFormatContent::ColorRGBA, 0xFFFFFFFF, 0, 0, 0, PixelFormatSubType::Float)); + SetupPixelFormat(PixelFormat::R32I, PixelFormatDescription("R32I", PixelFormatContent::ColorRGBA, 0xFFFFFFFF, 0, 0, 0, PixelFormatSubType::Int)); + SetupPixelFormat(PixelFormat::R32UI, PixelFormatDescription("R32UI", PixelFormatContent::ColorRGBA, 0xFFFFFFFF, 0, 0, 0, PixelFormatSubType::Unsigned)); + SetupPixelFormat(PixelFormat::RG8, PixelFormatDescription("RG8", PixelFormatContent::ColorRGBA, 0xFF00, 0x00FF, 0, 0, PixelFormatSubType::Unsigned)); + SetupPixelFormat(PixelFormat::RG8I, PixelFormatDescription("RG8I", PixelFormatContent::ColorRGBA, 0xFF00, 0x00FF, 0, 0, PixelFormatSubType::Int)); + SetupPixelFormat(PixelFormat::RG8UI, PixelFormatDescription("RG8UI", PixelFormatContent::ColorRGBA, 0xFF00, 0x00FF, 0, 0, PixelFormatSubType::Unsigned)); + SetupPixelFormat(PixelFormat::RG16, PixelFormatDescription("RG16", PixelFormatContent::ColorRGBA, 0xFFFF0000, 0x0000FFFF, 0, 0, PixelFormatSubType::Unsigned)); + SetupPixelFormat(PixelFormat::RG16F, PixelFormatDescription("RG16F", PixelFormatContent::ColorRGBA, 0xFFFF0000, 0x0000FFFF, 0, 0, PixelFormatSubType::Half)); + SetupPixelFormat(PixelFormat::RG16I, PixelFormatDescription("RG16I", PixelFormatContent::ColorRGBA, 0xFFFF0000, 0x0000FFFF, 0, 0, PixelFormatSubType::Int)); + SetupPixelFormat(PixelFormat::RG16UI, PixelFormatDescription("RG16UI", PixelFormatContent::ColorRGBA, 0xFFFF0000, 0x0000FFFF, 0, 0, PixelFormatSubType::Unsigned)); + SetupPixelFormat(PixelFormat::RG32F, PixelFormatDescription("RG32F", PixelFormatContent::ColorRGBA, 0xFFFFFFFF00000000, 0x00000000FFFFFFFF, 0, 0, PixelFormatSubType::Float)); + SetupPixelFormat(PixelFormat::RG32I, PixelFormatDescription("RG32I", PixelFormatContent::ColorRGBA, 0xFFFFFFFF00000000, 0x00000000FFFFFFFF, 0, 0, PixelFormatSubType::Int)); + SetupPixelFormat(PixelFormat::RG32UI, PixelFormatDescription("RG32UI", PixelFormatContent::ColorRGBA, 0xFFFFFFFF00000000, 0x00000000FFFFFFFF, 0, 0, PixelFormatSubType::Unsigned)); + SetupPixelFormat(PixelFormat::RGB8, PixelFormatDescription("RGB8", PixelFormatContent::ColorRGBA, 0xFF000000, 0x00FF0000, 0x0000FF00, 0, PixelFormatSubType::Unsigned)); + SetupPixelFormat(PixelFormat::RGB8_SRGB, PixelFormatDescription("RGB8_SRGB", PixelFormatContent::ColorRGBA, 0xFF000000, 0x00FF0000, 0x0000FF00, 0, PixelFormatSubType::Unsigned)); + SetupPixelFormat(PixelFormat::RGB16F, PixelFormatDescription("RGB16F", PixelFormatContent::ColorRGBA, 0xFFFF00000000, 0x0000FFFF0000, 0x00000000FFFF, 0, PixelFormatSubType::Half)); + SetupPixelFormat(PixelFormat::RGB16I, PixelFormatDescription("RGB16I", PixelFormatContent::ColorRGBA, 0xFFFF00000000, 0x0000FFFF0000, 0x00000000FFFF, 0, PixelFormatSubType::Int)); + SetupPixelFormat(PixelFormat::RGB16UI, PixelFormatDescription("RGB16UI", PixelFormatContent::ColorRGBA, 0xFFFF000000000000, 0x0000FFFF00000000, 0x00000000FFFF0000, 0, PixelFormatSubType::Unsigned)); + SetupPixelFormat(PixelFormat::RGB32F, PixelFormatDescription("RGB32F", PixelFormatContent::ColorRGBA, b32, b32 >> 32, b32 >> 64, 0, PixelFormatSubType::Float)); + SetupPixelFormat(PixelFormat::RGB32I, PixelFormatDescription("RGB32I", PixelFormatContent::ColorRGBA, b32, b32 >> 32, b32 >> 64, 0, PixelFormatSubType::Int)); + SetupPixelFormat(PixelFormat::RGB32UI, PixelFormatDescription("RGB32UI", PixelFormatContent::ColorRGBA, b32, b32 >> 32, b32 >> 64, 0, PixelFormatSubType::Unsigned)); + SetupPixelFormat(PixelFormat::RGBA4, PixelFormatDescription("RGBA4", PixelFormatContent::ColorRGBA, 0xF000, 0x0F00, 0x00F0, 0x000F, PixelFormatSubType::Unsigned)); + SetupPixelFormat(PixelFormat::RGB5A1, PixelFormatDescription("RGB5A1", PixelFormatContent::ColorRGBA, 0xF800, 0x07C0, 0x003E, 0x0001, PixelFormatSubType::Unsigned)); + SetupPixelFormat(PixelFormat::RGBA8, PixelFormatDescription("RGBA8", PixelFormatContent::ColorRGBA, 0xFF000000, 0x00FF0000, 0x0000FF00, 0x000000FF, PixelFormatSubType::Unsigned)); + SetupPixelFormat(PixelFormat::RGBA8_SRGB, PixelFormatDescription("RGBA8_SRGB", PixelFormatContent::ColorRGBA, 0xFF000000, 0x00FF0000, 0x0000FF00, 0x000000FF, PixelFormatSubType::Unsigned)); + SetupPixelFormat(PixelFormat::RGBA16F, PixelFormatDescription("RGBA16F", PixelFormatContent::ColorRGBA, 0xFFFF000000000000, 0x0000FFFF00000000, 0x00000000FFFF0000, 0x000000000000FFFF, PixelFormatSubType::Half)); + SetupPixelFormat(PixelFormat::RGBA16I, PixelFormatDescription("RGBA16I", PixelFormatContent::ColorRGBA, 0xFFFF000000000000, 0x0000FFFF00000000, 0x00000000FFFF0000, 0x000000000000FFFF, PixelFormatSubType::Int)); + SetupPixelFormat(PixelFormat::RGBA16UI, PixelFormatDescription("RGBA16UI", PixelFormatContent::ColorRGBA, 0xFFFF000000000000, 0x0000FFFF00000000, 0x00000000FFFF0000, 0x000000000000FFFF, PixelFormatSubType::Unsigned)); + SetupPixelFormat(PixelFormat::RGBA32F, PixelFormatDescription("RGBA32F", PixelFormatContent::ColorRGBA, b32, b32 >> 32, b32 >> 64, b32 >> 96, PixelFormatSubType::Float)); + 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::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::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)); + SetupPixelFormat(PixelFormat::Stencil16, PixelFormatDescription("Stencil16", PixelFormatContent::Stencil, 0xFFFF, 0, 0, 0, PixelFormatSubType::Unsigned)); - for (unsigned int i = 0; i <= PixelFormat_Max; ++i) + for (unsigned int i = 0; i < PixelFormatCount; ++i) { if (!s_pixelFormatInfos[i].Validate()) NazaraWarning("Pixel format 0x" + NumberToString(i, 16) + " (" + GetName(static_cast(i)) + ") failed validation tests"); } // Reset functions - std::memset(s_convertFunctions, 0, (PixelFormat_Max+1)*(PixelFormat_Max+1)*sizeof(PixelFormatInfo::ConvertFunction)); + std::memset(s_convertFunctions, 0, (PixelFormatCount)*(PixelFormatCount)*sizeof(PixelFormatInfo::ConvertFunction)); /***********************************A8************************************/ - RegisterConverter(); - RegisterConverter(); - RegisterConverter(); - RegisterConverter(); - RegisterConverter(); + RegisterConverter(); + RegisterConverter(); + RegisterConverter(); + RegisterConverter(); + RegisterConverter(); /**********************************BGR8***********************************/ - RegisterConverter(); - RegisterConverter(); - RegisterConverter(); - RegisterConverter();/* - RegisterConverter(); - RegisterConverter(); - RegisterConverter(); - RegisterConverter(); - RegisterConverter(); - RegisterConverter(); - RegisterConverter(); - RegisterConverter();*/ - RegisterConverter(); - RegisterConverter(); - RegisterConverter(); - RegisterConverter(); + RegisterConverter(); + RegisterConverter(); + RegisterConverter(); + RegisterConverter();/* + RegisterConverter(); + RegisterConverter(); + RegisterConverter(); + RegisterConverter(); + RegisterConverter(); + RegisterConverter(); + RegisterConverter(); + RegisterConverter();*/ + RegisterConverter(); + RegisterConverter(); + RegisterConverter(); + RegisterConverter(); /**********************************BGRA8**********************************/ - RegisterConverter(); - RegisterConverter(); - RegisterConverter(); - RegisterConverter(); - RegisterConverter();/* - RegisterConverter(); - RegisterConverter(); - RegisterConverter(); - RegisterConverter(); - RegisterConverter(); - RegisterConverter(); - RegisterConverter(); - RegisterConverter();*/ - RegisterConverter(); - RegisterConverter(); - RegisterConverter(); - RegisterConverter(); + RegisterConverter(); + RegisterConverter(); + RegisterConverter(); + RegisterConverter(); + RegisterConverter();/* + RegisterConverter(); + RegisterConverter(); + RegisterConverter(); + RegisterConverter(); + RegisterConverter(); + RegisterConverter(); + RegisterConverter(); + RegisterConverter();*/ + RegisterConverter(); + RegisterConverter(); + RegisterConverter(); + RegisterConverter(); /**********************************DXT1***********************************/ ///TODO: Décompresseur DXT1 /* - RegisterConverter(); - RegisterConverter(); - RegisterConverter(); - RegisterConverter(); - RegisterConverter(); - RegisterConverter(); - RegisterConverter(); - RegisterConverter(); - RegisterConverter(); - RegisterConverter(); - RegisterConverter(); - RegisterConverter(); - RegisterConverter(); - RegisterConverter(); - RegisterConverter(); - RegisterConverter(); - RegisterConverter(); - RegisterConverter(); + RegisterConverter(); + RegisterConverter(); + RegisterConverter(); + RegisterConverter(); + RegisterConverter(); + RegisterConverter(); + RegisterConverter(); + RegisterConverter(); + RegisterConverter(); + RegisterConverter(); + RegisterConverter(); + RegisterConverter(); + RegisterConverter(); + RegisterConverter(); + RegisterConverter(); + RegisterConverter(); + RegisterConverter(); + RegisterConverter(); */ /**********************************DXT3***********************************/ ///TODO: Décompresseur DXT3 /* - RegisterConverter(); - RegisterConverter(); - RegisterConverter(); - RegisterConverter(); - RegisterConverter(); - RegisterConverter(); - RegisterConverter(); - RegisterConverter(); - RegisterConverter(); - RegisterConverter(); - RegisterConverter(); - RegisterConverter(); - RegisterConverter(); - RegisterConverter(); - RegisterConverter(); - RegisterConverter(); - RegisterConverter(); - RegisterConverter(); + RegisterConverter(); + RegisterConverter(); + RegisterConverter(); + RegisterConverter(); + RegisterConverter(); + RegisterConverter(); + RegisterConverter(); + RegisterConverter(); + RegisterConverter(); + RegisterConverter(); + RegisterConverter(); + RegisterConverter(); + RegisterConverter(); + RegisterConverter(); + RegisterConverter(); + RegisterConverter(); + RegisterConverter(); + RegisterConverter(); */ /**********************************DXT5***********************************/ ///TODO: Décompresseur DXT5 /* - RegisterConverter(); - RegisterConverter(); - RegisterConverter(); - RegisterConverter(); - RegisterConverter(); - RegisterConverter(); - RegisterConverter(); - RegisterConverter(); - RegisterConverter(); - RegisterConverter(); - RegisterConverter(); - RegisterConverter(); - RegisterConverter(); - RegisterConverter(); - RegisterConverter(); - RegisterConverter(); - RegisterConverter(); - RegisterConverter(); + RegisterConverter(); + RegisterConverter(); + RegisterConverter(); + RegisterConverter(); + RegisterConverter(); + RegisterConverter(); + RegisterConverter(); + RegisterConverter(); + RegisterConverter(); + RegisterConverter(); + RegisterConverter(); + RegisterConverter(); + RegisterConverter(); + RegisterConverter(); + RegisterConverter(); + RegisterConverter(); + RegisterConverter(); + RegisterConverter(); */ /***********************************L8************************************/ - RegisterConverter(); - RegisterConverter(); - RegisterConverter();/* - RegisterConverter(); - RegisterConverter(); - RegisterConverter(); - RegisterConverter(); - RegisterConverter(); - RegisterConverter(); - RegisterConverter(); - RegisterConverter();*/ - RegisterConverter(); - RegisterConverter(); - RegisterConverter(); - RegisterConverter(); + RegisterConverter(); + RegisterConverter(); + RegisterConverter();/* + RegisterConverter(); + RegisterConverter(); + RegisterConverter(); + RegisterConverter(); + RegisterConverter(); + RegisterConverter(); + RegisterConverter(); + RegisterConverter();*/ + RegisterConverter(); + RegisterConverter(); + RegisterConverter(); + RegisterConverter(); /***********************************LA8***********************************/ - RegisterConverter(); - RegisterConverter(); - RegisterConverter(); - RegisterConverter();/* - RegisterConverter(); - RegisterConverter(); - RegisterConverter(); - RegisterConverter(); - RegisterConverter(); - RegisterConverter(); - RegisterConverter(); - RegisterConverter();*/ - RegisterConverter(); - RegisterConverter(); - RegisterConverter(); - RegisterConverter(); + RegisterConverter(); + RegisterConverter(); + RegisterConverter(); + RegisterConverter();/* + RegisterConverter(); + RegisterConverter(); + RegisterConverter(); + RegisterConverter(); + RegisterConverter(); + RegisterConverter(); + RegisterConverter(); + RegisterConverter();*/ + RegisterConverter(); + RegisterConverter(); + RegisterConverter(); + RegisterConverter(); /**********************************RGBA4**********************************/ - RegisterConverter(); - RegisterConverter(); - RegisterConverter(); - RegisterConverter(); - RegisterConverter();/* - RegisterConverter(); - RegisterConverter(); - RegisterConverter(); - RegisterConverter(); - RegisterConverter(); - RegisterConverter(); - RegisterConverter(); - RegisterConverter();*/ - RegisterConverter(); - RegisterConverter(); - RegisterConverter(); + RegisterConverter(); + RegisterConverter(); + RegisterConverter(); + RegisterConverter(); + RegisterConverter();/* + RegisterConverter(); + RegisterConverter(); + RegisterConverter(); + RegisterConverter(); + RegisterConverter(); + RegisterConverter(); + RegisterConverter(); + RegisterConverter();*/ + RegisterConverter(); + RegisterConverter(); + RegisterConverter(); /*********************************RGB5A1**********************************/ - RegisterConverter(); - RegisterConverter(); - RegisterConverter(); - RegisterConverter(); - RegisterConverter();/* - RegisterConverter(); - RegisterConverter(); - RegisterConverter(); - RegisterConverter(); - RegisterConverter(); - RegisterConverter(); - RegisterConverter(); - RegisterConverter();*/ - RegisterConverter(); - RegisterConverter(); - RegisterConverter(); + RegisterConverter(); + RegisterConverter(); + RegisterConverter(); + RegisterConverter(); + RegisterConverter();/* + RegisterConverter(); + RegisterConverter(); + RegisterConverter(); + RegisterConverter(); + RegisterConverter(); + RegisterConverter(); + RegisterConverter(); + RegisterConverter();*/ + RegisterConverter(); + RegisterConverter(); + RegisterConverter(); /**********************************RGB8***********************************/ - RegisterConverter(); - RegisterConverter(); - RegisterConverter(); - RegisterConverter();/* - RegisterConverter(); - RegisterConverter(); - RegisterConverter(); - RegisterConverter(); - RegisterConverter(); - RegisterConverter(); - RegisterConverter(); - RegisterConverter();*/ - RegisterConverter(); - RegisterConverter(); - RegisterConverter(); - RegisterConverter(); + RegisterConverter(); + RegisterConverter(); + RegisterConverter(); + RegisterConverter();/* + RegisterConverter(); + RegisterConverter(); + RegisterConverter(); + RegisterConverter(); + RegisterConverter(); + RegisterConverter(); + RegisterConverter(); + RegisterConverter();*/ + RegisterConverter(); + RegisterConverter(); + RegisterConverter(); + RegisterConverter(); /**********************************RGBA8**********************************/ - RegisterConverter(); - RegisterConverter(); - RegisterConverter(); - RegisterConverter(); - RegisterConverter();/* - RegisterConverter(); - RegisterConverter(); - RegisterConverter(); - RegisterConverter(); - RegisterConverter(); - RegisterConverter(); - RegisterConverter(); - RegisterConverter();*/ - RegisterConverter(); - RegisterConverter(); - RegisterConverter(); - RegisterConverter(); + RegisterConverter(); + RegisterConverter(); + RegisterConverter(); + RegisterConverter(); + RegisterConverter();/* + RegisterConverter(); + RegisterConverter(); + RegisterConverter(); + RegisterConverter(); + RegisterConverter(); + RegisterConverter(); + RegisterConverter(); + RegisterConverter();*/ + RegisterConverter(); + RegisterConverter(); + RegisterConverter(); + RegisterConverter(); return true; } void PixelFormatInfo::Uninitialize() { - for (unsigned int i = 0; i <= PixelFormat_Max; ++i) + for (unsigned int i = 0; i < PixelFormatCount; ++i) s_pixelFormatInfos[i].Clear(); - std::memset(s_convertFunctions, 0, (PixelFormat_Max+1)*(PixelFormat_Max+1)*sizeof(PixelFormatInfo::ConvertFunction)); + std::memset(s_convertFunctions, 0, (PixelFormatCount)*(PixelFormatCount)*sizeof(PixelFormatInfo::ConvertFunction)); - for (unsigned int i = 0; i <= PixelFlipping_Max; ++i) + for (unsigned int i = 0; i < PixelFlippingCount; ++i) s_flipFunctions[i].clear(); } - PixelFormatDescription PixelFormatInfo::s_pixelFormatInfos[PixelFormat_Max + 1]; - PixelFormatInfo::ConvertFunction PixelFormatInfo::s_convertFunctions[PixelFormat_Max+1][PixelFormat_Max+1]; - std::map PixelFormatInfo::s_flipFunctions[PixelFlipping_Max+1]; + PixelFormatDescription PixelFormatInfo::s_pixelFormatInfos[PixelFormatCount]; + PixelFormatInfo::ConvertFunction PixelFormatInfo::s_convertFunctions[PixelFormatCount][PixelFormatCount]; + std::map PixelFormatInfo::s_flipFunctions[PixelFlippingCount]; } diff --git a/src/Nazara/Utility/RichTextDrawer.cpp b/src/Nazara/Utility/RichTextDrawer.cpp index b11dce7b2..123c21e91 100644 --- a/src/Nazara/Utility/RichTextDrawer.cpp +++ b/src/Nazara/Utility/RichTextDrawer.cpp @@ -126,7 +126,7 @@ namespace Nz return m_bounds; } - Font* RichTextDrawer::GetFont(std::size_t index) const + const std::shared_ptr& RichTextDrawer::GetFont(std::size_t index) const { NazaraAssert(index < m_fonts.size(), "Font index out of range"); @@ -285,12 +285,12 @@ namespace Nz return *this; } - void RichTextDrawer::AppendNewLine(const Font* font, unsigned int characterSize, float lineSpacingOffset, std::size_t glyphIndex, float glyphPosition) const + void RichTextDrawer::AppendNewLine(const Font& font, unsigned int characterSize, float lineSpacingOffset, std::size_t glyphIndex, float glyphPosition) const { // Ensure we're appending from last line Line& lastLine = m_lines.back(); - const Font::SizeInfo& sizeInfo = font->GetSizeInfo(characterSize); + const Font::SizeInfo& sizeInfo = font.GetSizeInfo(characterSize); float previousDrawPos = m_drawPos.x; @@ -336,12 +336,12 @@ namespace Nz } } - bool RichTextDrawer::GenerateGlyph(Glyph& glyph, char32_t character, float outlineThickness, bool lineWrap, const Font* font, const Color& color, TextStyleFlags style, float lineSpacingOffset, unsigned int characterSize, int renderOrder, int* advance) const + bool RichTextDrawer::GenerateGlyph(Glyph& glyph, char32_t character, float outlineThickness, bool lineWrap, const Font& font, const Color& color, TextStyleFlags style, float lineSpacingOffset, unsigned int characterSize, int renderOrder, int* advance) const { - const Font::Glyph& fontGlyph = font->GetGlyph(characterSize, style, outlineThickness, character); + const Font::Glyph& fontGlyph = font.GetGlyph(characterSize, style, outlineThickness, character); if (fontGlyph.valid && fontGlyph.fauxOutlineThickness <= 0.f) { - glyph.atlas = font->GetAtlas()->GetLayer(fontGlyph.layerIndex); + glyph.atlas = font.GetAtlas()->GetLayer(fontGlyph.layerIndex); glyph.atlasRect = fontGlyph.atlasRect; glyph.color = color; glyph.flipped = fontGlyph.flipped; @@ -376,7 +376,7 @@ namespace Nz return false; }; - void RichTextDrawer::GenerateGlyphs(const Font* font, const Color& color, TextStyleFlags style, unsigned int characterSize, const Color& outlineColor, float characterSpacingOffset, float lineSpacingOffset, float outlineThickness, const std::string& text) const + void RichTextDrawer::GenerateGlyphs(const Font& font, const Color& color, TextStyleFlags style, unsigned int characterSize, const Color& outlineColor, float characterSpacingOffset, float lineSpacingOffset, float outlineThickness, const std::string& text) const { if (text.empty()) return; @@ -391,7 +391,7 @@ namespace Nz char32_t previousCharacter = 0; - const Font::SizeInfo& sizeInfo = font->GetSizeInfo(characterSize); + const Font::SizeInfo& sizeInfo = font.GetSizeInfo(characterSize); float lineHeight = GetLineHeight(lineSpacingOffset, sizeInfo); float heightDifference = lineHeight - m_lines.back().bounds.height; @@ -414,7 +414,7 @@ namespace Nz for (char32_t character : characters) { if (previousCharacter != 0) - m_drawPos.x += font->GetKerning(characterSize, previousCharacter, character); + m_drawPos.x += font.GetKerning(characterSize, previousCharacter, character); previousCharacter = character; @@ -500,7 +500,7 @@ namespace Nz NazaraUnused(font); #ifdef NAZARA_DEBUG - auto it = std::find_if(m_fonts.begin(), m_fonts.end(), [font](const auto& fontData) { return fontData.font == font; }); + auto it = std::find_if(m_fonts.begin(), m_fonts.end(), [font](const auto& fontData) { return fontData.font.get() == font; }); if (it == m_fonts.end()) { NazaraInternalError("Not listening to " + PointerToString(font)); @@ -522,7 +522,7 @@ namespace Nz NazaraUnused(font); #ifdef NAZARA_DEBUG - auto it = std::find_if(m_fonts.begin(), m_fonts.end(), [font](const auto& fontData) { return fontData.font == font; }); + auto it = std::find_if(m_fonts.begin(), m_fonts.end(), [font](const auto& fontData) { return fontData.font.get() == font; }); if (it == m_fonts.end()) { NazaraInternalError("Not listening to " + PointerToString(font)); @@ -539,7 +539,7 @@ namespace Nz NazaraUnused(font); #ifdef NAZARA_DEBUG - auto it = std::find_if(m_fonts.begin(), m_fonts.end(), [font](const auto& fontData) { return fontData.font == font; }); + auto it = std::find_if(m_fonts.begin(), m_fonts.end(), [font](const auto& fontData) { return fontData.font.get() == font; }); if (it == m_fonts.end()) { NazaraInternalError("Not listening to " + PointerToString(font)); @@ -573,7 +573,7 @@ namespace Nz assert(block.fontIndex < m_fonts.size()); const auto& fontData = m_fonts[block.fontIndex]; - GenerateGlyphs(fontData.font, block.color, block.style, block.characterSize, block.outlineColor, block.outlineThickness, block.characterSpacingOffset, block.lineSpacingOffset, block.text); + GenerateGlyphs(*fontData.font, block.color, block.style, block.characterSize, block.outlineColor, block.outlineThickness, block.characterSpacingOffset, block.lineSpacingOffset, block.text); } } else diff --git a/src/Nazara/Utility/SimpleTextDrawer.cpp b/src/Nazara/Utility/SimpleTextDrawer.cpp index 2ff89df99..fd1b18fd3 100644 --- a/src/Nazara/Utility/SimpleTextDrawer.cpp +++ b/src/Nazara/Utility/SimpleTextDrawer.cpp @@ -23,7 +23,7 @@ namespace Nz return m_bounds; } - Font* SimpleTextDrawer::GetFont(std::size_t index) const + const std::shared_ptr& SimpleTextDrawer::GetFont(std::size_t index) const { NazaraAssert(index == 0, "Font index out of range"); NazaraUnused(index); @@ -288,7 +288,7 @@ namespace Nz NazaraUnused(font); #ifdef NAZARA_DEBUG - if (m_font != font) + if (m_font.get() != font) { NazaraInternalError("Not listening to " + PointerToString(font)); return; @@ -309,7 +309,7 @@ namespace Nz NazaraUnused(font); #ifdef NAZARA_DEBUG - if (m_font != font) + if (m_font.get() != font) { NazaraInternalError("Not listening to " + PointerToString(font)); return; @@ -325,7 +325,7 @@ namespace Nz NazaraUnused(font); #ifdef NAZARA_DEBUG - if (m_font != font) + if (m_font.get() != font) { NazaraInternalError("Not listening to " + PointerToString(font)); return; diff --git a/src/Nazara/Utility/SkeletalMesh.cpp b/src/Nazara/Utility/SkeletalMesh.cpp index 21f89da26..da08488d4 100644 --- a/src/Nazara/Utility/SkeletalMesh.cpp +++ b/src/Nazara/Utility/SkeletalMesh.cpp @@ -8,53 +8,14 @@ namespace Nz { - SkeletalMesh::SkeletalMesh(VertexBuffer* vertexBuffer, const IndexBuffer* indexBuffer) : + SkeletalMesh::SkeletalMesh(std::shared_ptr vertexBuffer, std::shared_ptr indexBuffer) : m_aabb(Nz::Boxf::Zero()), - m_indexBuffer(indexBuffer), - m_vertexBuffer(vertexBuffer) + m_indexBuffer(std::move(indexBuffer)), + m_vertexBuffer(std::move(vertexBuffer)) { NazaraAssert(m_vertexBuffer, "Invalid vertex buffer"); } - SkeletalMesh::SkeletalMesh(const Mesh* /*parent*/) : - m_aabb(Nz::Boxf::Zero()) - { - } - - SkeletalMesh::~SkeletalMesh() - { - OnSkeletalMeshRelease(this); - - Destroy(); - } - - bool SkeletalMesh::Create(VertexBuffer* vertexBuffer) - { - Destroy(); - - #if NAZARA_UTILITY_SAFE - if (!vertexBuffer) - { - NazaraError("Invalid vertex buffer"); - return false; - } - #endif - - m_vertexBuffer = vertexBuffer; - return true; - } - - void SkeletalMesh::Destroy() - { - if (m_vertexBuffer) - { - OnSkeletalMeshDestroy(this); - - m_indexBuffer.Reset(); - m_vertexBuffer.Reset(); - } - } - const Boxf& SkeletalMesh::GetAABB() const { return m_aabb; @@ -62,20 +23,15 @@ namespace Nz AnimationType SkeletalMesh::GetAnimationType() const { - return AnimationType_Skeletal; + return AnimationType::Skeletal; } - const IndexBuffer* SkeletalMesh::GetIndexBuffer() const + const std::shared_ptr& SkeletalMesh::GetIndexBuffer() const { return m_indexBuffer; } - VertexBuffer* SkeletalMesh::GetVertexBuffer() - { - return m_vertexBuffer; - } - - const VertexBuffer* SkeletalMesh::GetVertexBuffer() const + const std::shared_ptr& SkeletalMesh::GetVertexBuffer() const { return m_vertexBuffer; } @@ -102,8 +58,8 @@ namespace Nz OnSubMeshInvalidateAABB(this); } - void SkeletalMesh::SetIndexBuffer(const IndexBuffer* indexBuffer) + void SkeletalMesh::SetIndexBuffer(std::shared_ptr indexBuffer) { - m_indexBuffer = indexBuffer; + m_indexBuffer = std::move(indexBuffer); } } diff --git a/src/Nazara/Utility/Skeleton.cpp b/src/Nazara/Utility/Skeleton.cpp index 6927c27cd..7d2570830 100644 --- a/src/Nazara/Utility/Skeleton.cpp +++ b/src/Nazara/Utility/Skeleton.cpp @@ -18,58 +18,36 @@ namespace Nz bool jointMapUpdated = false; }; - Skeleton::Skeleton(const Skeleton& skeleton) : - RefCounted(), - m_impl(nullptr) + Skeleton::Skeleton() = default; + + Skeleton::Skeleton(const Skeleton& skeleton) { operator=(skeleton); } - Skeleton::~Skeleton() - { - OnSkeletonRelease(this); - - Destroy(); - } + Skeleton::Skeleton(Skeleton&&) noexcept = default; + Skeleton::~Skeleton() = default; bool Skeleton::Create(std::size_t jointCount) { - #if NAZARA_UTILITY_SAFE - if (jointCount == 0) - { - NazaraError("Joint count must be over zero"); - return false; - } - #endif + NazaraAssert(jointCount > 0, "joint count must be over zero"); - m_impl = new SkeletonImpl; - m_impl->joints.resize(jointCount, Joint(this)); + m_impl = std::make_unique(); + m_impl->joints.reserve(jointCount); + for (std::size_t i = 0; i < jointCount; ++i) + m_impl->joints.emplace_back(this); return true; } void Skeleton::Destroy() { - if (m_impl) - { - OnSkeletonDestroy(this); - - delete m_impl; - m_impl = nullptr; - } + m_impl.reset(); } const Boxf& Skeleton::GetAABB() const { - #if NAZARA_UTILITY_SAFE - if (!m_impl) - { - NazaraError("Skeleton not created"); - - static Boxf dummy; - return dummy; - } - #endif + NazaraAssert(m_impl, "skeleton must have been created"); if (!m_impl->aabbUpdated) { @@ -92,240 +70,109 @@ namespace Nz Joint* Skeleton::GetJoint(const std::string& jointName) { - #if NAZARA_UTILITY_SAFE - if (!m_impl) - { - NazaraError("Skeleton not created"); - return nullptr; - } - #endif + NazaraAssert(m_impl, "skeleton must have been created"); if (!m_impl->jointMapUpdated) UpdateJointMap(); auto it = m_impl->jointMap.find(jointName); - - #if NAZARA_UTILITY_SAFE - if (it == m_impl->jointMap.end()) - { - NazaraError("Joint not found"); - return nullptr; - } - #endif + NazaraAssert(it != m_impl->jointMap.end(), "joint not found"); InvalidateJoints(); - return &m_impl->joints[it->second]; } Joint* Skeleton::GetJoint(std::size_t index) { - #if NAZARA_UTILITY_SAFE - if (!m_impl) - { - NazaraError("Skeleton not created"); - return nullptr; - } - - if (index >= m_impl->joints.size()) - { - NazaraError("Joint index out of range (" + NumberToString(index) + " >= " + NumberToString(m_impl->joints.size()) + ')'); - return nullptr; - } - #endif + NazaraAssert(m_impl, "skeleton must have been created"); + NazaraAssert(index < m_impl->joints.size(), "joint index out of range"); InvalidateJoints(); - return &m_impl->joints[index]; } const Joint* Skeleton::GetJoint(const std::string& jointName) const { - #if NAZARA_UTILITY_SAFE - if (!m_impl) - { - NazaraError("Skeleton not created"); - return nullptr; - } - #endif + NazaraAssert(m_impl, "skeleton must have been created"); if (!m_impl->jointMapUpdated) UpdateJointMap(); auto it = m_impl->jointMap.find(jointName); - - #if NAZARA_UTILITY_SAFE - if (it == m_impl->jointMap.end()) - { - NazaraError("Joint not found"); - return nullptr; - } - #endif + NazaraAssert(it != m_impl->jointMap.end(), "joint not found"); return &m_impl->joints[it->second]; } const Joint* Skeleton::GetJoint(std::size_t index) const { - #if NAZARA_UTILITY_SAFE - if (!m_impl) - { - NazaraError("Skeleton not created"); - return nullptr; - } - - if (index >= m_impl->joints.size()) - { - NazaraError("Joint index out of range (" + NumberToString(index) + " >= " + NumberToString(m_impl->joints.size()) + ')'); - return nullptr; - } - #endif + NazaraAssert(m_impl, "skeleton must have been created"); + NazaraAssert(index < m_impl->joints.size(), "joint index out of range"); return &m_impl->joints[index]; } Joint* Skeleton::GetJoints() { - #if NAZARA_UTILITY_SAFE - if (!m_impl) - { - NazaraError("Skeleton not created"); - return nullptr; - } - #endif + NazaraAssert(m_impl, "skeleton must have been created"); + InvalidateJoints(); return &m_impl->joints[0]; } const Joint* Skeleton::GetJoints() const { - #if NAZARA_UTILITY_SAFE - if (!m_impl) - { - NazaraError("Skeleton not created"); - return nullptr; - } - #endif - + NazaraAssert(m_impl, "skeleton must have been created"); return &m_impl->joints[0]; } std::size_t Skeleton::GetJointCount() const { - #if NAZARA_UTILITY_SAFE - if (!m_impl) - { - NazaraError("Skeleton not created"); - return 0; - } - #endif - + NazaraAssert(m_impl, "skeleton must have been created"); return static_cast(m_impl->joints.size()); } - int Skeleton::GetJointIndex(const std::string& jointName) const + std::size_t Skeleton::GetJointIndex(const std::string& jointName) const { - #if NAZARA_UTILITY_SAFE - if (!m_impl) - { - NazaraError("Skeleton not created"); - return -1; - } - #endif + NazaraAssert(m_impl, "skeleton must have been created"); if (!m_impl->jointMapUpdated) UpdateJointMap(); auto it = m_impl->jointMap.find(jointName); - - #if NAZARA_UTILITY_SAFE - if (it == m_impl->jointMap.end()) - { - NazaraError("Joint not found"); - return -1; - } - #endif + NazaraAssert(it != m_impl->jointMap.end(), "joint not found"); return it->second; } void Skeleton::Interpolate(const Skeleton& skeletonA, const Skeleton& skeletonB, float interpolation) { - #if NAZARA_UTILITY_SAFE - if (!m_impl) - { - NazaraError("Skeleton not created"); - return; - } + NazaraAssert(m_impl, "skeleton must have been created"); + NazaraAssert(skeletonA.IsValid(), "first skeleton is invalid"); + NazaraAssert(skeletonB.IsValid(), "second skeleton is invalid"); + NazaraAssert(skeletonA.GetJointCount() == skeletonB.GetJointCount() && m_impl->joints.size() == skeletonA.GetJointCount(), "both skeletons must have the same number of joints"); - if (!skeletonA.IsValid()) - { - NazaraError("Skeleton A is invalid"); - return; - } - - if (!skeletonB.IsValid()) - { - NazaraError("Skeleton B is invalid"); - return; - } - - if (skeletonA.GetJointCount() != skeletonB.GetJointCount() || m_impl->joints.size() != skeletonA.GetJointCount()) - { - NazaraError("Skeletons must have the same joint count"); - return; - } - #endif - - Joint* jointsA = &skeletonA.m_impl->joints[0]; - Joint* jointsB = &skeletonB.m_impl->joints[0]; + const Joint* jointsA = &skeletonA.m_impl->joints[0]; + const Joint* jointsB = &skeletonB.m_impl->joints[0]; for (std::size_t i = 0; i < m_impl->joints.size(); ++i) m_impl->joints[i].Interpolate(jointsA[i], jointsB[i], interpolation, CoordSys_Local); InvalidateJoints(); } - void Skeleton::Interpolate(const Skeleton& skeletonA, const Skeleton& skeletonB, float interpolation, std::size_t* indices, std::size_t indiceCount) + void Skeleton::Interpolate(const Skeleton& skeletonA, const Skeleton& skeletonB, float interpolation, const std::size_t* indices, std::size_t indiceCount) { - #if NAZARA_UTILITY_SAFE - if (!m_impl) - { - NazaraError("Skeleton not created"); - return; - } - - if (!skeletonA.IsValid()) - { - NazaraError("Skeleton A is invalid"); - return; - } - - if (!skeletonB.IsValid()) - { - NazaraError("Skeleton B is invalid"); - return; - } - - if (skeletonA.GetJointCount() != skeletonB.GetJointCount() || m_impl->joints.size() != skeletonA.GetJointCount()) - { - NazaraError("Skeletons must have the same joint count"); - return; - } - #endif + NazaraAssert(m_impl, "skeleton must have been created"); + NazaraAssert(skeletonA.IsValid(), "first skeleton is invalid"); + NazaraAssert(skeletonB.IsValid(), "second skeleton is invalid"); + NazaraAssert(skeletonA.GetJointCount() == skeletonB.GetJointCount() && m_impl->joints.size() == skeletonA.GetJointCount(), "both skeletons must have the same number of joints"); const Joint* jointsA = &skeletonA.m_impl->joints[0]; const Joint* jointsB = &skeletonB.m_impl->joints[0]; for (std::size_t i = 0; i < indiceCount; ++i) { std::size_t index = indices[i]; - - #if NAZARA_UTILITY_SAFE - if (index >= m_impl->joints.size()) - { - NazaraError("Index #" + NumberToString(i) + " out of range (" + NumberToString(index) + " >= " + NumberToString(m_impl->joints.size()) + ')'); - return; - } - #endif + NazaraAssert(index < m_impl->joints.size(), "joint index out of range"); m_impl->joints[index].Interpolate(jointsA[index], jointsB[index], interpolation, CoordSys_Local); } @@ -347,7 +194,7 @@ namespace Nz if (skeleton.m_impl) { - m_impl = new SkeletonImpl; + m_impl = std::make_unique(); m_impl->jointMap = skeleton.m_impl->jointMap; m_impl->jointMapUpdated = skeleton.m_impl->jointMapUpdated; m_impl->joints = skeleton.m_impl->joints; @@ -376,6 +223,8 @@ namespace Nz return *this; } + Skeleton& Skeleton::operator=(Skeleton&&) noexcept = default; + void Skeleton::InvalidateJoints() { m_impl->aabbUpdated = false; @@ -385,26 +234,13 @@ namespace Nz void Skeleton::InvalidateJointMap() { - #ifdef NAZARA_DEBUG - if (!m_impl) - { - NazaraError("Invalid skeleton"); - return; - } - #endif - + NazaraAssert(m_impl, "skeleton must have been created"); m_impl->jointMapUpdated = false; } void Skeleton::UpdateJointMap() const { - #ifdef NAZARA_DEBUG - if (!m_impl) - { - NazaraError("Invalid skeleton"); - return; - } - #endif + NazaraAssert(m_impl, "skeleton must have been created"); m_impl->jointMap.clear(); for (std::size_t i = 0; i < m_impl->joints.size(); ++i) @@ -420,22 +256,4 @@ namespace Nz m_impl->jointMapUpdated = true; } - - bool Skeleton::Initialize() - { - if (!SkeletonLibrary::Initialize()) - { - NazaraError("Failed to initialise library"); - return false; - } - - return true; - } - - void Skeleton::Uninitialize() - { - SkeletonLibrary::Uninitialize(); - } - - SkeletonLibrary::LibraryMap Skeleton::s_library; } diff --git a/src/Nazara/Utility/SoftwareBuffer.cpp b/src/Nazara/Utility/SoftwareBuffer.cpp index d5c9b1010..d2ecad060 100644 --- a/src/Nazara/Utility/SoftwareBuffer.cpp +++ b/src/Nazara/Utility/SoftwareBuffer.cpp @@ -52,7 +52,7 @@ namespace Nz DataStorage SoftwareBuffer::GetStorage() const { - return DataStorage_Software; + return DataStorage::Software; } void* SoftwareBuffer::Map(BufferAccess /*access*/, UInt64 offset, UInt64 /*size*/) diff --git a/src/Nazara/Utility/StaticMesh.cpp b/src/Nazara/Utility/StaticMesh.cpp index 3d17f3638..b8ac35661 100644 --- a/src/Nazara/Utility/StaticMesh.cpp +++ b/src/Nazara/Utility/StaticMesh.cpp @@ -10,32 +10,20 @@ namespace Nz { - StaticMesh::StaticMesh(VertexBuffer* vertexBuffer, const IndexBuffer* indexBuffer) : + StaticMesh::StaticMesh(std::shared_ptr vertexBuffer, std::shared_ptr indexBuffer) : m_aabb(Nz::Boxf::Zero()), - m_indexBuffer(indexBuffer), - m_vertexBuffer(vertexBuffer) + m_indexBuffer(std::move(indexBuffer)), + m_vertexBuffer(std::move(vertexBuffer)) { NazaraAssert(m_vertexBuffer, "Invalid vertex buffer"); } - StaticMesh::StaticMesh(const Mesh* /*parent*/) : - m_aabb(Nz::Boxf::Zero()) - { - } - - StaticMesh::~StaticMesh() - { - OnStaticMeshRelease(this); - - Destroy(); - } - void StaticMesh::Center() { Vector3f offset(m_aabb.x + m_aabb.width/2.f, m_aabb.y + m_aabb.height/2.f, m_aabb.z + m_aabb.depth/2.f); - VertexMapper mapper(m_vertexBuffer); - SparsePtr position = mapper.GetComponentPtr(VertexComponent_Position); + VertexMapper mapper(*m_vertexBuffer); + SparsePtr position = mapper.GetComponentPtr(VertexComponent::Position); unsigned int vertexCount = m_vertexBuffer->GetVertexCount(); for (unsigned int i = 0; i < vertexCount; ++i) @@ -46,38 +34,11 @@ namespace Nz m_aabb.z -= offset.z; } - bool StaticMesh::Create(VertexBuffer* vertexBuffer) - { - Destroy(); - - #if NAZARA_UTILITY_SAFE - if (!vertexBuffer) - { - NazaraError("Invalid vertex buffer"); - return false; - } - #endif - - m_vertexBuffer = vertexBuffer; - return true; - } - - void StaticMesh::Destroy() - { - if (m_vertexBuffer) - { - OnStaticMeshDestroy(this); - - m_indexBuffer.Reset(); - m_vertexBuffer.Reset(); - } - } - bool StaticMesh::GenerateAABB() { // On lock le buffer pour itérer sur toutes les positions et composer notre AABB - VertexMapper mapper(m_vertexBuffer, BufferAccess_ReadOnly); - SetAABB(ComputeAABB(mapper.GetComponentPtr(VertexComponent_Position), m_vertexBuffer->GetVertexCount())); + VertexMapper mapper(*m_vertexBuffer, BufferAccess::ReadOnly); + SetAABB(ComputeAABB(mapper.GetComponentPtr(VertexComponent::Position), m_vertexBuffer->GetVertexCount())); return true; } @@ -89,20 +50,15 @@ namespace Nz AnimationType StaticMesh::GetAnimationType() const { - return AnimationType_Static; + return AnimationType::Static; } - const IndexBuffer* StaticMesh::GetIndexBuffer() const + const std::shared_ptr& StaticMesh::GetIndexBuffer() const { return m_indexBuffer; } - VertexBuffer* StaticMesh::GetVertexBuffer() - { - return m_vertexBuffer; - } - - const VertexBuffer* StaticMesh::GetVertexBuffer() const + const std::shared_ptr& StaticMesh::GetVertexBuffer() const { return m_vertexBuffer; } @@ -129,8 +85,8 @@ namespace Nz OnSubMeshInvalidateAABB(this); } - void StaticMesh::SetIndexBuffer(const IndexBuffer* indexBuffer) + void StaticMesh::SetIndexBuffer(std::shared_ptr indexBuffer) { - m_indexBuffer = indexBuffer; + m_indexBuffer = std::move(indexBuffer); } } diff --git a/src/Nazara/Utility/SubMesh.cpp b/src/Nazara/Utility/SubMesh.cpp index 375fdebb2..c53489888 100644 --- a/src/Nazara/Utility/SubMesh.cpp +++ b/src/Nazara/Utility/SubMesh.cpp @@ -12,36 +12,27 @@ namespace Nz { SubMesh::SubMesh() : - RefCounted(false), // wut - m_primitiveMode(PrimitiveMode_TriangleList), + m_primitiveMode(PrimitiveMode::TriangleList), m_matIndex(0) { } - SubMesh::SubMesh(const Mesh* /*parent*/) : - SubMesh() - { - } - - SubMesh::~SubMesh() - { - OnSubMeshRelease(this); - } + SubMesh::~SubMesh() = default; void SubMesh::GenerateNormals() { - VertexMapper mapper(this); + VertexMapper mapper(*this); std::size_t vertexCount = mapper.GetVertexCount(); - SparsePtr normals = mapper.GetComponentPtr(VertexComponent_Normal); - SparsePtr positions = mapper.GetComponentPtr(VertexComponent_Position); + SparsePtr normals = mapper.GetComponentPtr(VertexComponent::Normal); + SparsePtr positions = mapper.GetComponentPtr(VertexComponent::Position); if (!normals || !positions) return; for (std::size_t i = 0; i < vertexCount; ++i) normals[i].MakeZero(); - TriangleIterator iterator(this); + TriangleIterator iterator(*this); do { Vector3f pos0 = positions[iterator[0]]; @@ -63,13 +54,13 @@ namespace Nz void SubMesh::GenerateNormalsAndTangents() { - VertexMapper mapper(this); + VertexMapper mapper(*this); std::size_t vertexCount = mapper.GetVertexCount(); - SparsePtr normals = mapper.GetComponentPtr(VertexComponent_Normal); - SparsePtr positions = mapper.GetComponentPtr(VertexComponent_Position); - SparsePtr tangents = mapper.GetComponentPtr(VertexComponent_Tangent); - SparsePtr texCoords = mapper.GetComponentPtr(VertexComponent_TexCoord); + SparsePtr normals = mapper.GetComponentPtr(VertexComponent::Normal); + SparsePtr positions = mapper.GetComponentPtr(VertexComponent::Position); + SparsePtr tangents = mapper.GetComponentPtr(VertexComponent::Tangent); + SparsePtr texCoords = mapper.GetComponentPtr(VertexComponent::TexCoord); if (!normals || !positions || !tangents || !texCoords) return; @@ -79,7 +70,7 @@ namespace Nz tangents[i].MakeZero(); } - TriangleIterator iterator(this); + TriangleIterator iterator(*this); do { Vector3f pos0 = positions[iterator[0]]; @@ -121,16 +112,16 @@ namespace Nz void SubMesh::GenerateTangents() { - VertexMapper mapper(this); + VertexMapper mapper(*this); - SparsePtr normals = mapper.GetComponentPtr(VertexComponent_Normal); - SparsePtr positions = mapper.GetComponentPtr(VertexComponent_Position); - SparsePtr tangents = mapper.GetComponentPtr(VertexComponent_Tangent); - SparsePtr texCoords = mapper.GetComponentPtr(VertexComponent_TexCoord); + SparsePtr normals = mapper.GetComponentPtr(VertexComponent::Normal); + SparsePtr positions = mapper.GetComponentPtr(VertexComponent::Position); + SparsePtr tangents = mapper.GetComponentPtr(VertexComponent::Tangent); + SparsePtr texCoords = mapper.GetComponentPtr(VertexComponent::TexCoord); if (!normals || !positions || !tangents || !texCoords) return; - TriangleIterator iterator(this); + TriangleIterator iterator(*this); do { Vector3f pos0 = positions[iterator[0]]; @@ -170,7 +161,7 @@ namespace Nz std::size_t SubMesh::GetTriangleCount() const { - const IndexBuffer* indexBuffer = GetIndexBuffer(); + const std::shared_ptr& indexBuffer = GetIndexBuffer(); std::size_t indexCount; if (indexBuffer) indexCount = indexBuffer->GetIndexCount(); @@ -179,22 +170,22 @@ namespace Nz switch (m_primitiveMode) { - case PrimitiveMode_LineList: - case PrimitiveMode_LineStrip: - case PrimitiveMode_PointList: + case PrimitiveMode::LineList: + case PrimitiveMode::LineStrip: + case PrimitiveMode::PointList: return 0; - case PrimitiveMode_TriangleFan: + case PrimitiveMode::TriangleFan: return (indexCount - 1) / 2; - case PrimitiveMode_TriangleList: + case PrimitiveMode::TriangleList: return indexCount / 3; - case PrimitiveMode_TriangleStrip: + case PrimitiveMode::TriangleStrip: return indexCount - 2; } - NazaraError("Primitive mode not handled (0x" + NumberToString(m_primitiveMode, 16) + ')'); + NazaraError("Primitive mode not handled (0x" + NumberToString(UnderlyingCast(m_primitiveMode), 16) + ')'); return 0; } diff --git a/src/Nazara/Utility/TriangleIterator.cpp b/src/Nazara/Utility/TriangleIterator.cpp index 66b085ac2..a5ce21e2d 100644 --- a/src/Nazara/Utility/TriangleIterator.cpp +++ b/src/Nazara/Utility/TriangleIterator.cpp @@ -8,9 +8,9 @@ namespace Nz { - TriangleIterator::TriangleIterator(PrimitiveMode primitiveMode, const IndexBuffer* indexBuffer) : + TriangleIterator::TriangleIterator(PrimitiveMode primitiveMode, const IndexBuffer& indexBuffer) : m_primitiveMode(primitiveMode), - m_indexMapper(indexBuffer, BufferAccess_ReadOnly) + m_indexMapper(indexBuffer, BufferAccess::ReadOnly) { m_currentIndex = 3; m_triangleIndices[0] = m_indexMapper.Get(0); @@ -20,9 +20,9 @@ namespace Nz m_indexCount = m_indexMapper.GetIndexCount(); } - TriangleIterator::TriangleIterator(const SubMesh* subMesh) : - m_primitiveMode(subMesh->GetPrimitiveMode()), - m_indexMapper(subMesh, BufferAccess_ReadOnly) + TriangleIterator::TriangleIterator(const SubMesh& subMesh) : + m_primitiveMode(subMesh.GetPrimitiveMode()), + m_indexMapper(subMesh, BufferAccess::ReadOnly) { m_currentIndex = 3; m_triangleIndices[0] = m_indexMapper.Get(0); @@ -42,18 +42,18 @@ namespace Nz switch (m_primitiveMode) { - case PrimitiveMode_TriangleFan: + case PrimitiveMode::TriangleFan: m_triangleIndices[1] = m_indexMapper.Get(m_currentIndex++); m_triangleIndices[2] = m_indexMapper.Get(m_currentIndex++); break; - case PrimitiveMode_TriangleList: + case PrimitiveMode::TriangleList: m_triangleIndices[0] = m_indexMapper.Get(m_currentIndex++); m_triangleIndices[1] = m_indexMapper.Get(m_currentIndex++); m_triangleIndices[2] = m_indexMapper.Get(m_currentIndex++); break; - case PrimitiveMode_TriangleStrip: + case PrimitiveMode::TriangleStrip: m_triangleIndices[2] = m_indexMapper.Get(m_currentIndex++); m_triangleIndices[0] = m_triangleIndices[1]; m_triangleIndices[1] = m_triangleIndices[2]; diff --git a/src/Nazara/Utility/UniformBuffer.cpp b/src/Nazara/Utility/UniformBuffer.cpp index 4e0d83f15..e5b69200e 100644 --- a/src/Nazara/Utility/UniformBuffer.cpp +++ b/src/Nazara/Utility/UniformBuffer.cpp @@ -10,13 +10,13 @@ namespace Nz { - UniformBuffer::UniformBuffer(BufferRef buffer) + UniformBuffer::UniformBuffer(std::shared_ptr buffer) { ErrorFlags(ErrorFlag_ThrowException, true); Reset(std::move(buffer)); } - UniformBuffer::UniformBuffer(BufferRef buffer, UInt32 offset, UInt32 size) + UniformBuffer::UniformBuffer(std::shared_ptr buffer, UInt32 offset, UInt32 size) { ErrorFlags(ErrorFlag_ThrowException, true); Reset(std::move(buffer), offset, size); @@ -28,19 +28,6 @@ namespace Nz Reset(length, storage, usage); } - UniformBuffer::UniformBuffer(const UniformBuffer& uniformBuffer) : - RefCounted(), - m_buffer(uniformBuffer.m_buffer), - m_endOffset(uniformBuffer.m_endOffset), - m_startOffset(uniformBuffer.m_startOffset) - { - } - - UniformBuffer::~UniformBuffer() - { - OnUniformBufferRelease(this); - } - bool UniformBuffer::Fill(const void* data, UInt32 offset, UInt32 size) { NazaraAssert(m_buffer && m_buffer->IsValid(), "Invalid buffer"); @@ -67,20 +54,20 @@ namespace Nz void UniformBuffer::Reset() { - m_buffer.Reset(); + m_buffer.reset(); } - void UniformBuffer::Reset(BufferRef buffer) + void UniformBuffer::Reset(std::shared_ptr buffer) { NazaraAssert(buffer && buffer->IsValid(), "Invalid buffer"); Reset(buffer, 0, buffer->GetSize()); } - void UniformBuffer::Reset(BufferRef buffer, UInt32 offset, UInt32 size) + void UniformBuffer::Reset(std::shared_ptr buffer, UInt32 offset, UInt32 size) { NazaraAssert(buffer && buffer->IsValid(), "Invalid buffer"); - NazaraAssert(buffer->GetType() == BufferType_Uniform, "Buffer must be an uniform buffer"); + NazaraAssert(buffer->GetType() == BufferType::Uniform, "Buffer must be an uniform buffer"); NazaraAssert(size > 0, "Invalid size"); NazaraAssert(offset + size > buffer->GetSize(), "Virtual buffer exceed buffer bounds"); @@ -94,7 +81,7 @@ namespace Nz m_endOffset = size; m_startOffset = 0; - m_buffer = Buffer::New(BufferType_Uniform, m_endOffset, storage, usage); + m_buffer = std::make_shared(BufferType::Uniform, m_endOffset, storage, usage); } void UniformBuffer::Reset(const UniformBuffer& uniformBuffer) @@ -108,11 +95,4 @@ namespace Nz { m_buffer->Unmap(); } - - UniformBuffer& UniformBuffer::operator=(const UniformBuffer& uniformBuffer) - { - Reset(uniformBuffer); - - return *this; - } } diff --git a/src/Nazara/Utility/Utility.cpp b/src/Nazara/Utility/Utility.cpp index f07f27fe5..b1ca74d80 100644 --- a/src/Nazara/Utility/Utility.cpp +++ b/src/Nazara/Utility/Utility.cpp @@ -39,27 +39,15 @@ namespace Nz Utility::Utility(Config /*config*/) : ModuleBase("Utility", this) { - if (!Animation::Initialize()) - throw std::runtime_error("failed to initialize animations"); - if (!Buffer::Initialize()) throw std::runtime_error("failed to initialize buffers"); if (!Font::Initialize()) throw std::runtime_error("failed to initialize fonts"); - if (!Image::Initialize()) - throw std::runtime_error("failed to initialize images"); - - if (!Mesh::Initialize()) - throw std::runtime_error("failed to initialize meshes"); - if (!PixelFormatInfo::Initialize()) throw std::runtime_error("failed to initialize pixel formats"); - if (!Skeleton::Initialize()) - throw std::runtime_error("failed to initialize skeletons"); - if (!VertexDeclaration::Initialize()) throw std::runtime_error("failed to initialize vertex declarations"); @@ -68,50 +56,99 @@ namespace Nz /// Loaders génériques // Font - Loaders::RegisterFreeType(); + if (Loaders::InitializeFreeType()) + m_fontLoader.RegisterLoader(Loaders::GetFontLoader_FreeType()); // Image - Loaders::RegisterDDSLoader(); // DDS Loader (DirectX format) - Loaders::RegisterSTBLoader(); // Generic loader (STB) - Loaders::RegisterSTBSaver(); // Generic saver (STB) + m_imageLoader.RegisterLoader(Loaders::GetImageLoader_STB()); // Generic loader (STB) + m_imageSaver.RegisterSaver(Loaders::GetImageSaver_STB()); // Generic saver (STB) /// Loaders spécialisés // Animation - Loaders::RegisterMD5Anim(); // Loader de fichiers .md5anim (v10) + m_animationLoader.RegisterLoader(Loaders::GetAnimationLoader_MD5Anim()); // Loader de fichiers .md5anim (v10) // Mesh (text) - Loaders::RegisterOBJLoader(); - Loaders::RegisterOBJSaver(); + m_meshLoader.RegisterLoader(Loaders::GetMeshLoader_OBJ()); + m_meshSaver.RegisterSaver(Loaders::GetMeshSaver_OBJ()); // Mesh - Loaders::RegisterMD2(); // Loader de fichiers .md2 (v8) - Loaders::RegisterMD5Mesh(); // Loader de fichiers .md5mesh (v10) - Loaders::RegisterOBJLoader(); // Loader de fichiers .md5mesh (v10) + m_meshLoader.RegisterLoader(Loaders::GetMeshLoader_MD2()); // .md2 (v8) + m_meshLoader.RegisterLoader(Loaders::GetMeshLoader_MD5Mesh()); // .md5mesh (v10) + m_meshLoader.RegisterLoader(Loaders::GetMeshLoader_OBJ()); // .obj // Image - Loaders::RegisterPCX(); // Loader de fichiers .pcx (1, 4, 8, 24 bits) + m_imageLoader.RegisterLoader(Loaders::GetImageLoader_DDS()); // DDS Loader (DirectX format) + m_imageLoader.RegisterLoader(Loaders::GetImageLoader_PCX()); // .pcx loader (1, 4, 8, 24 bits) } Utility::~Utility() { - Loaders::UnregisterFreeType(); - Loaders::UnregisterMD2(); - Loaders::UnregisterMD5Anim(); - Loaders::UnregisterMD5Mesh(); - Loaders::UnregisterOBJLoader(); - Loaders::UnregisterOBJSaver(); - Loaders::UnregisterPCX(); - Loaders::UnregisterSTBLoader(); - Loaders::UnregisterSTBSaver(); + Loaders::UninitializeFreeType(); VertexDeclaration::Uninitialize(); - Skeleton::Uninitialize(); PixelFormatInfo::Uninitialize(); - Mesh::Uninitialize(); - Image::Uninitialize(); Font::Uninitialize(); Buffer::Uninitialize(); - Animation::Uninitialize(); + } + + AnimationLoader& Utility::GetAnimationLoader() + { + return m_animationLoader; + } + + const AnimationLoader& Utility::GetAnimationLoader() const + { + return m_animationLoader; + } + + FontLoader& Utility::GetFontLoader() + { + return m_fontLoader; + } + + const FontLoader& Utility::GetFontLoader() const + { + return m_fontLoader; + } + + ImageLoader& Utility::GetImageLoader() + { + return m_imageLoader; + } + + const ImageLoader& Utility::GetImageLoader() const + { + return m_imageLoader; + } + + ImageSaver& Utility::GetImageSaver() + { + return m_imageSaver; + } + + const ImageSaver& Utility::GetImageSaver() const + { + return m_imageSaver; + } + + MeshLoader& Utility::GetMeshLoader() + { + return m_meshLoader; + } + + const MeshLoader& Utility::GetMeshLoader() const + { + return m_meshLoader; + } + + MeshSaver& Utility::GetMeshSaver() + { + return m_meshSaver; + } + + const MeshSaver& Utility::GetMeshSaver() const + { + return m_meshSaver; } Utility* Utility::s_instance = nullptr; diff --git a/src/Nazara/Utility/VertexBuffer.cpp b/src/Nazara/Utility/VertexBuffer.cpp index c4fff82fb..9632539ac 100644 --- a/src/Nazara/Utility/VertexBuffer.cpp +++ b/src/Nazara/Utility/VertexBuffer.cpp @@ -9,39 +9,24 @@ namespace Nz { - VertexBuffer::VertexBuffer(VertexDeclarationConstRef vertexDeclaration, BufferRef buffer) + VertexBuffer::VertexBuffer(std::shared_ptr vertexDeclaration, std::shared_ptr buffer) { ErrorFlags(ErrorFlag_ThrowException, true); Reset(std::move(vertexDeclaration), std::move(buffer)); } - VertexBuffer::VertexBuffer(VertexDeclarationConstRef vertexDeclaration, BufferRef buffer, std::size_t offset, std::size_t size) + VertexBuffer::VertexBuffer(std::shared_ptr vertexDeclaration, std::shared_ptr buffer, std::size_t offset, std::size_t size) { ErrorFlags(ErrorFlag_ThrowException, true); Reset(std::move(vertexDeclaration), std::move(buffer), offset, size); } - VertexBuffer::VertexBuffer(VertexDeclarationConstRef vertexDeclaration, std::size_t length, DataStorage storage, BufferUsageFlags usage) + VertexBuffer::VertexBuffer(std::shared_ptr vertexDeclaration, std::size_t length, DataStorage storage, BufferUsageFlags usage) { ErrorFlags(ErrorFlag_ThrowException, true); Reset(std::move(vertexDeclaration), length, storage, usage); } - VertexBuffer::VertexBuffer(const VertexBuffer& vertexBuffer) : - RefCounted(), - m_buffer(vertexBuffer.m_buffer), - m_endOffset(vertexBuffer.m_endOffset), - m_startOffset(vertexBuffer.m_startOffset), - m_vertexCount(vertexBuffer.m_vertexCount), - m_vertexDeclaration(vertexBuffer.m_vertexDeclaration) - { - } - - VertexBuffer::~VertexBuffer() - { - OnVertexBufferRelease(this); - } - bool VertexBuffer::Fill(const void* data, std::size_t startVertex, std::size_t length) { std::size_t stride = static_cast(m_vertexDeclaration->GetStride()); @@ -91,20 +76,20 @@ namespace Nz void VertexBuffer::Reset() { - m_buffer.Reset(); - m_vertexDeclaration.Reset(); + m_buffer.reset(); + m_vertexDeclaration.reset(); } - void VertexBuffer::Reset(VertexDeclarationConstRef vertexDeclaration, BufferRef buffer) + void VertexBuffer::Reset(std::shared_ptr vertexDeclaration, std::shared_ptr buffer) { NazaraAssert(buffer && buffer->IsValid(), "Invalid buffer"); - NazaraAssert(buffer->GetType() == BufferType_Vertex, "Buffer must be a vertex buffer"); + NazaraAssert(buffer->GetType() == BufferType::Vertex, "Buffer must be a vertex buffer"); std::size_t size = buffer->GetSize(); Reset(std::move(vertexDeclaration), std::move(buffer), 0, size); } - void VertexBuffer::Reset(VertexDeclarationConstRef vertexDeclaration, BufferRef buffer, std::size_t offset, std::size_t size) + void VertexBuffer::Reset(std::shared_ptr vertexDeclaration, std::shared_ptr buffer, std::size_t offset, std::size_t size) { NazaraAssert(buffer && buffer->IsValid(), "Invalid buffer"); NazaraAssert(size > 0, "Invalid size"); @@ -117,14 +102,14 @@ namespace Nz m_vertexDeclaration = vertexDeclaration; } - void VertexBuffer::Reset(VertexDeclarationConstRef vertexDeclaration, std::size_t length, DataStorage storage, BufferUsageFlags usage) + void VertexBuffer::Reset(std::shared_ptr vertexDeclaration, std::size_t length, DataStorage storage, BufferUsageFlags usage) { m_endOffset = length * ((vertexDeclaration) ? static_cast(vertexDeclaration->GetStride()) : 1); m_startOffset = 0; m_vertexCount = length; m_vertexDeclaration = std::move(vertexDeclaration); - m_buffer = Buffer::New(BufferType_Vertex, m_endOffset, storage, usage); + m_buffer = std::make_shared(BufferType::Vertex, m_endOffset, storage, usage); } void VertexBuffer::Reset(const VertexBuffer& vertexBuffer) @@ -136,7 +121,7 @@ namespace Nz m_vertexDeclaration = vertexBuffer.m_vertexDeclaration; } - void VertexBuffer::SetVertexDeclaration(VertexDeclarationConstRef vertexDeclaration) + void VertexBuffer::SetVertexDeclaration(std::shared_ptr vertexDeclaration) { NazaraAssert(vertexDeclaration, "Invalid vertex declaration"); @@ -148,11 +133,4 @@ namespace Nz { m_buffer->Unmap(); } - - VertexBuffer& VertexBuffer::operator=(const VertexBuffer& vertexBuffer) - { - Reset(vertexBuffer); - - return *this; - } } diff --git a/src/Nazara/Utility/VertexDeclaration.cpp b/src/Nazara/Utility/VertexDeclaration.cpp index 8fc49661b..53e284e9c 100644 --- a/src/Nazara/Utility/VertexDeclaration.cpp +++ b/src/Nazara/Utility/VertexDeclaration.cpp @@ -16,22 +16,22 @@ namespace Nz { namespace { - std::size_t s_componentStride[ComponentType_Max + 1] = + std::size_t s_componentStride[ComponentTypeCount] = { - 4 * sizeof(UInt8), // ComponentType_Color - 1 * sizeof(double), // ComponentType_Double1 - 2 * sizeof(double), // ComponentType_Double2 - 3 * sizeof(double), // ComponentType_Double3 - 4 * sizeof(double), // ComponentType_Double4 - 1 * sizeof(float), // ComponentType_Float1 - 2 * sizeof(float), // ComponentType_Float2 - 3 * sizeof(float), // ComponentType_Float3 - 4 * sizeof(float), // ComponentType_Float4 - 1 * sizeof(UInt32), // ComponentType_Int1 - 2 * sizeof(UInt32), // ComponentType_Int2 - 3 * sizeof(UInt32), // ComponentType_Int3 - 4 * sizeof(UInt32), // ComponentType_Int4 - 4 * sizeof(float) // ComponentType_Quaternion + 4 * sizeof(UInt8), // ComponentType::Color + 1 * sizeof(double), // ComponentType::Double1 + 2 * sizeof(double), // ComponentType::Double2 + 3 * sizeof(double), // ComponentType::Double3 + 4 * sizeof(double), // ComponentType::Double4 + 1 * sizeof(float), // ComponentType::Float1 + 2 * sizeof(float), // ComponentType::Float2 + 3 * sizeof(float), // ComponentType::Float3 + 4 * sizeof(float), // ComponentType::Float4 + 1 * sizeof(UInt32), // ComponentType::Int1 + 2 * sizeof(UInt32), // ComponentType::Int2 + 3 * sizeof(UInt32), // ComponentType::Int3 + 4 * sizeof(UInt32), // ComponentType::Int4 + 4 * sizeof(float) // ComponentType::Quaternion }; } VertexDeclaration::VertexDeclaration(VertexInputRate inputRate, std::initializer_list components) : @@ -43,10 +43,10 @@ namespace Nz m_components.reserve(components.size()); for (const ComponentEntry& entry : components) { - NazaraAssert(IsTypeSupported(entry.type), "Component type 0x" + NumberToString(entry.type, 16) + " is not supported by vertex declarations"); - NazaraAssert(entry.componentIndex == 0 || entry.component == VertexComponent_Userdata, "Only userdata components can have non-zero component indexes"); + NazaraAssert(IsTypeSupported(entry.type), "Component type 0x" + NumberToString(UnderlyingCast(entry.type), 16) + " is not supported by vertex declarations"); + NazaraAssert(entry.componentIndex == 0 || entry.component == VertexComponent::Userdata, "Only userdata components can have non-zero component indexes"); - if (entry.component != VertexComponent_Unused) + if (entry.component != VertexComponent::Unused) { // Check for duplicates for (const Component& component : m_components) @@ -62,7 +62,7 @@ namespace Nz component.offset = offset; component.type = entry.type; - offset += s_componentStride[component.type]; + offset += s_componentStride[UnderlyingCast(component.type)]; } m_stride = offset; @@ -72,281 +72,275 @@ namespace Nz { switch (type) { - case ComponentType_Color: - case ComponentType_Double1: - case ComponentType_Double2: - case ComponentType_Double3: - case ComponentType_Double4: - case ComponentType_Float1: - case ComponentType_Float2: - case ComponentType_Float3: - case ComponentType_Float4: - case ComponentType_Int1: - case ComponentType_Int2: - case ComponentType_Int3: - case ComponentType_Int4: + case ComponentType::Color: + case ComponentType::Double1: + case ComponentType::Double2: + case ComponentType::Double3: + case ComponentType::Double4: + case ComponentType::Float1: + case ComponentType::Float2: + case ComponentType::Float3: + case ComponentType::Float4: + case ComponentType::Int1: + case ComponentType::Int2: + case ComponentType::Int3: + case ComponentType::Int4: return true; - case ComponentType_Quaternion: + case ComponentType::Quaternion: return false; } - NazaraError("Component type not handled (0x" + NumberToString(type, 16) + ')'); + NazaraError("Component type not handled (0x" + NumberToString(UnderlyingCast(type), 16) + ')'); return false; } bool VertexDeclaration::Initialize() { - if (!VertexDeclarationLibrary::Initialize()) - { - NazaraError("Failed to initialise library"); - return false; - } - try { ErrorFlags flags(ErrorFlag_Silent | ErrorFlag_ThrowException); auto NewDeclaration = [](VertexInputRate inputRate, std::initializer_list components) { - return New(inputRate, std::move(components)); + return std::make_shared(inputRate, std::move(components)); }; - // VertexLayout_XY : VertexStruct_XY - s_declarations[VertexLayout_XY] = NewDeclaration(VertexInputRate::Vertex, { + // VertexLayout::XY : VertexStruct_XY + s_declarations[UnderlyingCast(VertexLayout::XY)] = NewDeclaration(VertexInputRate::Vertex, { { - VertexComponent_Position, - ComponentType_Float2, + VertexComponent::Position, + ComponentType::Float2, 0 } }); - NazaraAssert(s_declarations[VertexLayout_XY]->GetStride() == sizeof(VertexStruct_XY), "Invalid stride for declaration VertexLayout_XY"); + NazaraAssert(s_declarations[UnderlyingCast(VertexLayout::XY)]->GetStride() == sizeof(VertexStruct_XY), "Invalid stride for declaration VertexLayout::XY"); - s_declarations[VertexLayout_XY_Color] = NewDeclaration(VertexInputRate::Vertex, { + s_declarations[UnderlyingCast(VertexLayout::XY_Color)] = NewDeclaration(VertexInputRate::Vertex, { { - VertexComponent_Position, - ComponentType_Float2, + VertexComponent::Position, + ComponentType::Float2, 0 }, { - VertexComponent_Color, - ComponentType_Color, + VertexComponent::Color, + ComponentType::Color, 0 }, }); - NazaraAssert(s_declarations[VertexLayout_XY_Color]->GetStride() == sizeof(VertexStruct_XY_Color), "Invalid stride for declaration VertexLayout_XY_Color"); + NazaraAssert(s_declarations[UnderlyingCast(VertexLayout::XY_Color)]->GetStride() == sizeof(VertexStruct_XY_Color), "Invalid stride for declaration VertexLayout::XY_Color"); - // VertexLayout_XY_UV : VertexStruct_XY_UV - s_declarations[VertexLayout_XY_UV] = NewDeclaration(VertexInputRate::Vertex, { + // VertexLayout::XY_UV : VertexStruct_XY_UV + s_declarations[UnderlyingCast(VertexLayout::XY_UV)] = NewDeclaration(VertexInputRate::Vertex, { { - VertexComponent_Position, - ComponentType_Float2, + VertexComponent::Position, + ComponentType::Float2, 0 }, { - VertexComponent_TexCoord, - ComponentType_Float2, + VertexComponent::TexCoord, + ComponentType::Float2, 0 }, }); - NazaraAssert(s_declarations[VertexLayout_XY_UV]->GetStride() == sizeof(VertexStruct_XY_UV), "Invalid stride for declaration VertexLayout_XY_UV"); + NazaraAssert(s_declarations[UnderlyingCast(VertexLayout::XY_UV)]->GetStride() == sizeof(VertexStruct_XY_UV), "Invalid stride for declaration VertexLayout::XY_UV"); - // VertexLayout_XYZ : VertexStruct_XYZ - s_declarations[VertexLayout_XYZ] = NewDeclaration(VertexInputRate::Vertex, { + // VertexLayout::XYZ : VertexStruct_XYZ + s_declarations[UnderlyingCast(VertexLayout::XYZ)] = NewDeclaration(VertexInputRate::Vertex, { { - VertexComponent_Position, - ComponentType_Float3, + VertexComponent::Position, + ComponentType::Float3, 0 }, }); - NazaraAssert(s_declarations[VertexLayout_XYZ]->GetStride() == sizeof(VertexStruct_XYZ), "Invalid stride for declaration VertexLayout_XYZ"); + NazaraAssert(s_declarations[UnderlyingCast(VertexLayout::XYZ)]->GetStride() == sizeof(VertexStruct_XYZ), "Invalid stride for declaration VertexLayout::XYZ"); - // VertexLayout_XYZ_Color : VertexStruct_XYZ_Color - s_declarations[VertexLayout_XYZ_Color] = NewDeclaration(VertexInputRate::Vertex, { + // VertexLayout::XYZ_Color : VertexStruct_XYZ_Color + s_declarations[UnderlyingCast(VertexLayout::XYZ_Color)] = NewDeclaration(VertexInputRate::Vertex, { { - VertexComponent_Position, - ComponentType_Float3, + VertexComponent::Position, + ComponentType::Float3, 0 }, { - VertexComponent_Color, - ComponentType_Color, + VertexComponent::Color, + ComponentType::Color, 0 } }); - NazaraAssert(s_declarations[VertexLayout_XYZ_Color]->GetStride() == sizeof(VertexStruct_XYZ_Color), "Invalid stride for declaration VertexLayout_XYZ_Color"); + NazaraAssert(s_declarations[UnderlyingCast(VertexLayout::XYZ_Color)]->GetStride() == sizeof(VertexStruct_XYZ_Color), "Invalid stride for declaration VertexLayout::XYZ_Color"); - // VertexLayout_XYZ_Color_UV : VertexStruct_XYZ_Color_UV - s_declarations[VertexLayout_XYZ_Color_UV] = NewDeclaration(VertexInputRate::Vertex, { + // VertexLayout::XYZ_Color_UV : VertexStruct_XYZ_Color_UV + s_declarations[UnderlyingCast(VertexLayout::XYZ_Color_UV)] = NewDeclaration(VertexInputRate::Vertex, { { - VertexComponent_Position, - ComponentType_Float3, + VertexComponent::Position, + ComponentType::Float3, 0 }, { - VertexComponent_Color, - ComponentType_Color, + VertexComponent::Color, + ComponentType::Color, 0 }, { - VertexComponent_TexCoord, - ComponentType_Float2, + VertexComponent::TexCoord, + ComponentType::Float2, 0 }, }); - NazaraAssert(s_declarations[VertexLayout_XYZ_Color_UV]->GetStride() == sizeof(VertexStruct_XYZ_Color_UV), "Invalid stride for declaration VertexLayout_XYZ_Color_UV"); + NazaraAssert(s_declarations[UnderlyingCast(VertexLayout::XYZ_Color_UV)]->GetStride() == sizeof(VertexStruct_XYZ_Color_UV), "Invalid stride for declaration VertexLayout::XYZ_Color_UV"); - // VertexLayout_XYZ_Normal : VertexStruct_XYZ_Normal - s_declarations[VertexLayout_XYZ_Normal] = NewDeclaration(VertexInputRate::Vertex, { + // VertexLayout::XYZ_Normal : VertexStruct_XYZ_Normal + s_declarations[UnderlyingCast(VertexLayout::XYZ_Normal)] = NewDeclaration(VertexInputRate::Vertex, { { - VertexComponent_Position, - ComponentType_Float3, + VertexComponent::Position, + ComponentType::Float3, 0 }, { - VertexComponent_Normal, - ComponentType_Float3, + VertexComponent::Normal, + ComponentType::Float3, 0 } }); - NazaraAssert(s_declarations[VertexLayout_XYZ_Normal]->GetStride() == sizeof(VertexStruct_XYZ_Normal), "Invalid stride for declaration VertexLayout_XYZ_Normal"); + NazaraAssert(s_declarations[UnderlyingCast(VertexLayout::XYZ_Normal)]->GetStride() == sizeof(VertexStruct_XYZ_Normal), "Invalid stride for declaration VertexLayout::XYZ_Normal"); - // VertexLayout_XYZ_Normal_UV : VertexStruct_XYZ_Normal_UV - s_declarations[VertexLayout_XYZ_Normal_UV] = NewDeclaration(VertexInputRate::Vertex, { + // VertexLayout::XYZ_Normal_UV : VertexStruct_XYZ_Normal_UV + s_declarations[UnderlyingCast(VertexLayout::XYZ_Normal_UV)] = NewDeclaration(VertexInputRate::Vertex, { { - VertexComponent_Position, - ComponentType_Float3, + VertexComponent::Position, + ComponentType::Float3, 0 }, { - VertexComponent_Normal, - ComponentType_Float3, + VertexComponent::Normal, + ComponentType::Float3, 0 }, { - VertexComponent_TexCoord, - ComponentType_Float2, + VertexComponent::TexCoord, + ComponentType::Float2, 0 } }); - NazaraAssert(s_declarations[VertexLayout_XYZ_Normal_UV]->GetStride() == sizeof(VertexStruct_XYZ_Normal_UV), "Invalid stride for declaration VertexLayout_XYZ_Normal_UV"); + NazaraAssert(s_declarations[UnderlyingCast(VertexLayout::XYZ_Normal_UV)]->GetStride() == sizeof(VertexStruct_XYZ_Normal_UV), "Invalid stride for declaration VertexLayout::XYZ_Normal_UV"); - // VertexLayout_XYZ_Normal_UV_Tangent : VertexStruct_XYZ_Normal_UV_Tangent - s_declarations[VertexLayout_XYZ_Normal_UV_Tangent] = NewDeclaration(VertexInputRate::Vertex, { + // VertexLayout::XYZ_Normal_UV_Tangent : VertexStruct_XYZ_Normal_UV_Tangent + s_declarations[UnderlyingCast(VertexLayout::XYZ_Normal_UV_Tangent)] = NewDeclaration(VertexInputRate::Vertex, { { - VertexComponent_Position, - ComponentType_Float3, + VertexComponent::Position, + ComponentType::Float3, 0 }, { - VertexComponent_Normal, - ComponentType_Float3, + VertexComponent::Normal, + ComponentType::Float3, 0 }, { - VertexComponent_TexCoord, - ComponentType_Float2, + VertexComponent::TexCoord, + ComponentType::Float2, 0 }, { - VertexComponent_Tangent, - ComponentType_Float3, + VertexComponent::Tangent, + ComponentType::Float3, 0 } }); - NazaraAssert(s_declarations[VertexLayout_XYZ_Normal_UV_Tangent]->GetStride() == sizeof(VertexStruct_XYZ_Normal_UV_Tangent), "Invalid stride for declaration VertexLayout_XYZ_Normal_UV_Tangent"); + NazaraAssert(s_declarations[UnderlyingCast(VertexLayout::XYZ_Normal_UV_Tangent)]->GetStride() == sizeof(VertexStruct_XYZ_Normal_UV_Tangent), "Invalid stride for declaration VertexLayout::XYZ_Normal_UV_Tangent"); - // VertexLayout_XYZ_Normal_UV_Tangent_Skinning : VertexStruct_XYZ_Normal_UV_Tangent_Skinning - s_declarations[VertexLayout_XYZ_Normal_UV_Tangent_Skinning] = NewDeclaration(VertexInputRate::Vertex, { + // VertexLayout::XYZ_Normal_UV_Tangent_Skinning : VertexStruct_XYZ_Normal_UV_Tangent_Skinning + s_declarations[UnderlyingCast(VertexLayout::XYZ_Normal_UV_Tangent_Skinning)] = NewDeclaration(VertexInputRate::Vertex, { { - VertexComponent_Position, - ComponentType_Float3, + VertexComponent::Position, + ComponentType::Float3, 0 }, { - VertexComponent_Normal, - ComponentType_Float3, + VertexComponent::Normal, + ComponentType::Float3, 0 }, { - VertexComponent_TexCoord, - ComponentType_Float2, + VertexComponent::TexCoord, + ComponentType::Float2, 0 }, { - VertexComponent_Tangent, - ComponentType_Float3, + VertexComponent::Tangent, + ComponentType::Float3, 0 }, { - VertexComponent_Userdata, - ComponentType_Int1, + VertexComponent::Userdata, + ComponentType::Int1, 0 // Weight count }, { - VertexComponent_Userdata, - ComponentType_Float4, + VertexComponent::Userdata, + ComponentType::Float4, 1 // Weights }, { - VertexComponent_Userdata, - ComponentType_Int4, + VertexComponent::Userdata, + ComponentType::Int4, 2 // Joint indexes }, }); - NazaraAssert(s_declarations[VertexLayout_XYZ_Normal_UV_Tangent_Skinning]->GetStride() == sizeof(VertexStruct_XYZ_Normal_UV_Tangent_Skinning), "Invalid stride for declaration VertexLayout_XYZ_Normal_UV_Tangent_Skinning"); + NazaraAssert(s_declarations[UnderlyingCast(VertexLayout::XYZ_Normal_UV_Tangent_Skinning)]->GetStride() == sizeof(VertexStruct_XYZ_Normal_UV_Tangent_Skinning), "Invalid stride for declaration VertexLayout::XYZ_Normal_UV_Tangent_Skinning"); - // VertexLayout_XYZ_UV : VertexStruct_XYZ_UV - s_declarations[VertexLayout_XYZ_UV] = NewDeclaration(VertexInputRate::Vertex, { + // VertexLayout::XYZ_UV : VertexStruct_XYZ_UV + s_declarations[UnderlyingCast(VertexLayout::XYZ_UV)] = NewDeclaration(VertexInputRate::Vertex, { { - VertexComponent_Position, - ComponentType_Float3, + VertexComponent::Position, + ComponentType::Float3, 0 }, { - VertexComponent_TexCoord, - ComponentType_Float2, + VertexComponent::TexCoord, + ComponentType::Float2, 0 } }); - NazaraAssert(s_declarations[VertexLayout_XYZ_UV]->GetStride() == sizeof(VertexStruct_XYZ_UV), "Invalid stride for declaration VertexLayout_XYZ_UV"); + NazaraAssert(s_declarations[UnderlyingCast(VertexLayout::XYZ_UV)]->GetStride() == sizeof(VertexStruct_XYZ_UV), "Invalid stride for declaration VertexLayout::XYZ_UV"); - // VertexLayout_Matrix4 : Matrix4f - s_declarations[VertexLayout_Matrix4] = NewDeclaration(VertexInputRate::Vertex, { + // VertexLayout::Matrix4 : Matrix4f + s_declarations[UnderlyingCast(VertexLayout::Matrix4)] = NewDeclaration(VertexInputRate::Vertex, { { - VertexComponent_Userdata, - ComponentType_Float4, + VertexComponent::Userdata, + ComponentType::Float4, 0 }, { - VertexComponent_Userdata, - ComponentType_Float4, + VertexComponent::Userdata, + ComponentType::Float4, 1 }, { - VertexComponent_Userdata, - ComponentType_Float4, + VertexComponent::Userdata, + ComponentType::Float4, 2 }, { - VertexComponent_Userdata, - ComponentType_Float4, + VertexComponent::Userdata, + ComponentType::Float4, 3 } }); - NazaraAssert(s_declarations[VertexLayout_Matrix4]->GetStride() == sizeof(Matrix4f), "Invalid stride for declaration VertexLayout_Matrix4"); + NazaraAssert(s_declarations[UnderlyingCast(VertexLayout::Matrix4)]->GetStride() == sizeof(Matrix4f), "Invalid stride for declaration VertexLayout::Matrix4"); } catch (const std::exception& e) { @@ -359,11 +353,8 @@ namespace Nz void VertexDeclaration::Uninitialize() { - VertexDeclarationLibrary::Uninitialize(); - s_declarations.fill(nullptr); } - std::array VertexDeclaration::s_declarations; - VertexDeclarationLibrary::LibraryMap VertexDeclaration::s_library; + std::array, VertexLayoutCount> VertexDeclaration::s_declarations; } diff --git a/src/Nazara/Utility/VertexMapper.cpp b/src/Nazara/Utility/VertexMapper.cpp index 97bf6cbda..dd9a25235 100644 --- a/src/Nazara/Utility/VertexMapper.cpp +++ b/src/Nazara/Utility/VertexMapper.cpp @@ -12,73 +12,73 @@ namespace Nz { - VertexMapper::VertexMapper(SubMesh* subMesh, BufferAccess access) + VertexMapper::VertexMapper(SubMesh& subMesh, BufferAccess access) { ErrorFlags flags(ErrorFlag_ThrowException, true); - VertexBuffer* buffer = nullptr; - switch (subMesh->GetAnimationType()) + std::shared_ptr buffer = nullptr; + switch (subMesh.GetAnimationType()) { - case AnimationType_Skeletal: + case AnimationType::Skeletal: { - SkeletalMesh* skeletalMesh = static_cast(subMesh); - buffer = skeletalMesh->GetVertexBuffer(); + SkeletalMesh& skeletalMesh = static_cast(subMesh); + buffer = skeletalMesh.GetVertexBuffer(); break; } - case AnimationType_Static: + case AnimationType::Static: { - StaticMesh* staticMesh = static_cast(subMesh); - buffer = staticMesh->GetVertexBuffer(); + StaticMesh& staticMesh = static_cast(subMesh); + buffer = staticMesh.GetVertexBuffer(); break; } } if (!buffer) { - NazaraInternalError("Animation type not handled (0x" + NumberToString(subMesh->GetAnimationType(), 16) + ')'); + NazaraInternalError("Animation type not handled (0x" + NumberToString(UnderlyingCast(subMesh.GetAnimationType()), 16) + ')'); } - m_mapper.Map(buffer, access); + m_mapper.Map(*buffer, access); } - VertexMapper::VertexMapper(VertexBuffer* vertexBuffer, BufferAccess access) + VertexMapper::VertexMapper(VertexBuffer& vertexBuffer, BufferAccess access) { ErrorFlags flags(ErrorFlag_ThrowException, true); m_mapper.Map(vertexBuffer, access); } - VertexMapper::VertexMapper(const SubMesh* subMesh, BufferAccess access) + VertexMapper::VertexMapper(const SubMesh& subMesh, BufferAccess access) { ErrorFlags flags(ErrorFlag_ThrowException, true); - const VertexBuffer* buffer = nullptr; - switch (subMesh->GetAnimationType()) + std::shared_ptr buffer = nullptr; + switch (subMesh.GetAnimationType()) { - case AnimationType_Skeletal: + case AnimationType::Skeletal: { - const SkeletalMesh* skeletalMesh = static_cast(subMesh); - buffer = skeletalMesh->GetVertexBuffer(); + const SkeletalMesh& skeletalMesh = static_cast(subMesh); + buffer = skeletalMesh.GetVertexBuffer(); break; } - case AnimationType_Static: + case AnimationType::Static: { - const StaticMesh* staticMesh = static_cast(subMesh); - buffer = staticMesh->GetVertexBuffer(); + const StaticMesh& staticMesh = static_cast(subMesh); + buffer = staticMesh.GetVertexBuffer(); break; } } if (!buffer) { - NazaraInternalError("Animation type not handled (0x" + NumberToString(subMesh->GetAnimationType(), 16) + ')'); + NazaraInternalError("Animation type not handled (0x" + NumberToString(UnderlyingCast(subMesh.GetAnimationType()), 16) + ')'); } - m_mapper.Map(buffer, access); + m_mapper.Map(*buffer, access); } - VertexMapper::VertexMapper(const VertexBuffer* vertexBuffer, BufferAccess access) + VertexMapper::VertexMapper(const VertexBuffer& vertexBuffer, BufferAccess access) { ErrorFlags flags(ErrorFlag_ThrowException, true); m_mapper.Map(vertexBuffer, access); diff --git a/src/Nazara/VulkanRenderer/VkRenderWindow.cpp b/src/Nazara/VulkanRenderer/VkRenderWindow.cpp index 0950eba33..46aab0a8d 100644 --- a/src/Nazara/VulkanRenderer/VkRenderWindow.cpp +++ b/src/Nazara/VulkanRenderer/VkRenderWindow.cpp @@ -159,32 +159,32 @@ namespace Nz { switch (format) { - case PixelFormat_Depth16: + case PixelFormat::Depth16: m_depthStencilFormat = VK_FORMAT_D16_UNORM; break; - case PixelFormat_Depth24: - case PixelFormat_Depth24Stencil8: + case PixelFormat::Depth24: + case PixelFormat::Depth24Stencil8: m_depthStencilFormat = VK_FORMAT_D24_UNORM_S8_UINT; break; - case PixelFormat_Depth32: + case PixelFormat::Depth32: m_depthStencilFormat = VK_FORMAT_D32_SFLOAT; break; - case PixelFormat_Stencil1: - case PixelFormat_Stencil4: - case PixelFormat_Stencil8: + case PixelFormat::Stencil1: + case PixelFormat::Stencil4: + case PixelFormat::Stencil8: m_depthStencilFormat = VK_FORMAT_S8_UINT; break; - case PixelFormat_Stencil16: + case PixelFormat::Stencil16: continue; default: { PixelFormatContent formatContent = PixelFormatInfo::GetContent(format); - if (formatContent != PixelFormatContent_DepthStencil && formatContent != PixelFormatContent_Stencil) + if (formatContent != PixelFormatContent::DepthStencil && formatContent != PixelFormatContent::Stencil) NazaraWarning("Invalid format " + PixelFormatInfo::GetName(format) + " for depth-stencil attachment"); m_depthStencilFormat = VK_FORMAT_MAX_ENUM; diff --git a/src/Nazara/VulkanRenderer/VulkanBuffer.cpp b/src/Nazara/VulkanRenderer/VulkanBuffer.cpp index e3c90c8ac..430c40812 100644 --- a/src/Nazara/VulkanRenderer/VulkanBuffer.cpp +++ b/src/Nazara/VulkanRenderer/VulkanBuffer.cpp @@ -18,7 +18,7 @@ namespace Nz bool VulkanBuffer::Fill(const void* data, UInt64 offset, UInt64 size) { - void* ptr = Map(BufferAccess_WriteOnly, offset, size); + void* ptr = Map(BufferAccess::WriteOnly, offset, size); if (!ptr) return false; @@ -36,7 +36,7 @@ namespace Nz VkBufferUsageFlags bufferUsage = ToVulkan(m_type); - if ((usage & BufferUsage_DirectMapping) == 0) + if ((usage & BufferUsage::DirectMapping) == 0) bufferUsage |= VK_BUFFER_USAGE_TRANSFER_DST_BIT; VkBufferCreateInfo createInfo = {}; @@ -45,9 +45,9 @@ namespace Nz createInfo.usage = bufferUsage; VmaAllocationCreateInfo allocInfo = {}; - if (usage & BufferUsage_DeviceLocal) + if (usage & BufferUsage::DeviceLocal) { - if (usage & BufferUsage_DirectMapping) + if (usage & BufferUsage::DirectMapping) allocInfo.usage = VMA_MEMORY_USAGE_CPU_TO_GPU; else allocInfo.usage = VMA_MEMORY_USAGE_GPU_ONLY; @@ -55,7 +55,7 @@ namespace Nz else allocInfo.usage = VMA_MEMORY_USAGE_CPU_ONLY; - if (usage & BufferUsage_PersistentMapping) + if (usage & BufferUsage::PersistentMapping) allocInfo.flags |= VMA_ALLOCATION_CREATE_MAPPED_BIT; VkResult result = vmaCreateBuffer(m_device.GetMemoryAllocator(), &createInfo, &allocInfo, &m_buffer, &m_allocation, nullptr); @@ -75,12 +75,12 @@ namespace Nz DataStorage VulkanBuffer::GetStorage() const { - return DataStorage_Hardware; + return DataStorage::Hardware; } void* VulkanBuffer::Map(BufferAccess /*access*/, UInt64 offset, UInt64 size) { - if (m_usage & BufferUsage_DirectMapping) + if (m_usage & BufferUsage::DirectMapping) { void* mappedPtr; VkResult result = vmaMapMemory(m_device.GetMemoryAllocator(), m_allocation, &mappedPtr); @@ -118,7 +118,7 @@ namespace Nz bool VulkanBuffer::Unmap() { - if (m_usage & BufferUsage_DirectMapping) + if (m_usage & BufferUsage::DirectMapping) { vmaUnmapMemory(m_device.GetMemoryAllocator(), m_allocation); return true; diff --git a/src/Nazara/VulkanRenderer/VulkanCommandBufferBuilder.cpp b/src/Nazara/VulkanRenderer/VulkanCommandBufferBuilder.cpp index ed0103079..96e1ca51a 100644 --- a/src/Nazara/VulkanRenderer/VulkanCommandBufferBuilder.cpp +++ b/src/Nazara/VulkanRenderer/VulkanCommandBufferBuilder.cpp @@ -58,7 +58,7 @@ namespace Nz const auto& values = (i < clearValueCount) ? clearValues[i] : CommandBufferBuilder::ClearValues{}; auto& vkValues = vkClearValues[i]; - if (PixelFormatInfo::GetContent(vkRenderPass.GetAttachment(i).format) == PixelFormatContent_ColorRGBA) + if (PixelFormatInfo::GetContent(vkRenderPass.GetAttachment(i).format) == PixelFormatContent::ColorRGBA) { vkValues.color.float32[0] = values.color.r / 255.f; vkValues.color.float32[1] = values.color.g / 255.f; diff --git a/src/Nazara/VulkanRenderer/VulkanTexture.cpp b/src/Nazara/VulkanRenderer/VulkanTexture.cpp index 317cd8ada..588f3e879 100644 --- a/src/Nazara/VulkanRenderer/VulkanTexture.cpp +++ b/src/Nazara/VulkanRenderer/VulkanTexture.cpp @@ -39,7 +39,7 @@ namespace Nz switch (params.type) { - case ImageType_1D: + case ImageType::E1D: NazaraAssert(params.width > 0, "Width must be over zero"); createInfoView.viewType = VK_IMAGE_VIEW_TYPE_1D; @@ -51,7 +51,7 @@ namespace Nz createInfo.arrayLayers = 1; break; - case ImageType_1D_Array: + case ImageType::E1D_Array: NazaraAssert(params.width > 0, "Width must be over zero"); NazaraAssert(params.height > 0, "Height must be over zero"); @@ -64,7 +64,7 @@ namespace Nz createInfo.arrayLayers = params.height; break; - case ImageType_2D: + case ImageType::E2D: NazaraAssert(params.width > 0, "Width must be over zero"); NazaraAssert(params.height > 0, "Height must be over zero"); @@ -77,7 +77,7 @@ namespace Nz createInfo.arrayLayers = 1; break; - case ImageType_2D_Array: + case ImageType::E2D_Array: NazaraAssert(params.width > 0, "Width must be over zero"); NazaraAssert(params.height > 0, "Height must be over zero"); NazaraAssert(params.depth > 0, "Depth must be over zero"); @@ -91,7 +91,7 @@ namespace Nz createInfo.arrayLayers = params.depth; break; - case ImageType_3D: + case ImageType::E3D: NazaraAssert(params.width > 0, "Width must be over zero"); NazaraAssert(params.height > 0, "Height must be over zero"); NazaraAssert(params.depth > 0, "Depth must be over zero"); @@ -105,7 +105,7 @@ namespace Nz createInfo.arrayLayers = 1; break; - case ImageType_Cubemap: + case ImageType::Cubemap: NazaraAssert(params.width > 0, "Width must be over zero"); NazaraAssert(params.height > 0, "Height must be over zero"); @@ -230,22 +230,22 @@ namespace Nz // TODO: Fill this switch switch (pixelFormat) { - case PixelFormat_BGR8: - case PixelFormat_BGR8_SRGB: - case PixelFormat_BGRA8: - case PixelFormat_BGRA8_SRGB: - case PixelFormat_RGB8: - case PixelFormat_RGB8_SRGB: - case PixelFormat_RGBA8: - case PixelFormat_RGBA8_SRGB: - case PixelFormat_RGBA32F: + case PixelFormat::BGR8: + case PixelFormat::BGR8_SRGB: + case PixelFormat::BGRA8: + case PixelFormat::BGRA8_SRGB: + case PixelFormat::RGB8: + case PixelFormat::RGB8_SRGB: + case PixelFormat::RGBA8: + case PixelFormat::RGBA8_SRGB: + case PixelFormat::RGBA32F: { createImage.format = ToVulkan(pixelFormat); createImageView.format = createImage.format; break; } - case PixelFormat_Depth24Stencil8: + case PixelFormat::Depth24Stencil8: { createImage.format = VK_FORMAT_D24_UNORM_S8_UINT; createImageView.format = createImage.format; @@ -253,7 +253,7 @@ namespace Nz break; } - case PixelFormat_L8: + case PixelFormat::L8: { createImage.format = VK_FORMAT_R8_UNORM; createImageView.format = createImage.format; @@ -266,7 +266,7 @@ namespace Nz break; } - case PixelFormat_LA8: + case PixelFormat::LA8: { createImage.format = VK_FORMAT_R8G8_UNORM; createImageView.format = createImage.format; diff --git a/src/ShaderNode/ShaderGraph.cpp b/src/ShaderNode/ShaderGraph.cpp index 9b80b01dc..ef02bf7a2 100644 --- a/src/ShaderNode/ShaderGraph.cpp +++ b/src/ShaderNode/ShaderGraph.cpp @@ -463,7 +463,7 @@ Nz::ShaderAst::StatementPtr ShaderGraph::ToAst() const for (const auto& structInfo : m_structs) { Nz::ShaderAst::StructDescription structDesc; - structDesc.layout = Nz::StructLayout_Std140; + structDesc.layout = Nz::StructLayout::Std140; structDesc.name = structInfo.name; for (const auto& memberInfo : structInfo.members) @@ -701,7 +701,7 @@ Nz::ShaderAst::ExpressionType ShaderGraph::ToShaderExpressionType(TextureType ty { switch (type) { - case TextureType::Sampler2D: return Nz::ShaderAst::SamplerType{ Nz::ImageType_2D, Nz::ShaderAst::PrimitiveType::Float32 }; + case TextureType::Sampler2D: return Nz::ShaderAst::SamplerType{ Nz::ImageType::E2D, Nz::ShaderAst::PrimitiveType::Float32 }; } assert(false);