[*] Backup of work

include/inexor/vulkan-renderer/cubemap/cubemap_generator.hpp

@@ -1,6 +1,5 @@
 #pragma once
 
-#include "inexor/vulkan-renderer/cubemap/cubemap_cpu_texture.hpp"
 #include "inexor/vulkan-renderer/wrapper/descriptor_builder.hpp"
 #include "inexor/vulkan-renderer/wrapper/descriptor_pool.hpp"
 #include "inexor/vulkan-renderer/wrapper/device.hpp"
@@ -25,7 +24,7 @@ class CubemapGenerator {
     void render_cubemap();
 
 public:
-    CubemapGenerator(const wrapper::Device &device, const CubemapCpuTexture &texture);
+    CubemapGenerator(const wrapper::Device &device);
 
     [[nodiscard]] auto &image_wrapper() const {
         return m_cubemap_texture->image_wrapper();

include/inexor/vulkan-renderer/renderer.hpp

@@ -119,11 +119,11 @@ class VulkanRenderer {
     std::vector<UniformBufferSet> uniformBuffers;
 
     struct Textures {
-        std::unique_ptr<cubemap::CubemapCpuTexture> environmentCube;
+        std::unique_ptr<wrapper::GpuTexture> environmentCube;
         std::unique_ptr<wrapper::GpuTexture> empty;
         std::unique_ptr<pbr::BRDFLUTGenerator> lutBrdf;
-        std::unique_ptr<cubemap::CubemapCpuTexture> irradianceCube;
-        std::unique_ptr<cubemap::CubemapCpuTexture> prefilteredCube;
+        std::unique_ptr<wrapper::GpuTexture> irradianceCube;
+        std::unique_ptr<wrapper::GpuTexture> prefilteredCube;
     } textures;
 
     std::unique_ptr<wrapper::DescriptorPool> m_descriptor_pool;

include/inexor/vulkan-renderer/wrapper/command_buffer.hpp

@@ -54,7 +54,6 @@ class CommandBuffer {
     template <typename T>
     void push_constants(const T *data, VkPipelineLayout layout,
                         VkShaderStageFlags stage = VK_SHADER_STAGE_VERTEX_BIT) const {
-        static_assert(sizeof(T) > 0);
         assert(data);
         vkCmdPushConstants(m_cmd_buf, layout, stage, 0, sizeof(T), data);
     }

include/inexor/vulkan-renderer/wrapper/cpu_texture.hpp

@@ -1,25 +1,34 @@
 #pragma once
 
+#include "inexor/vulkan-renderer/exception.hpp"
+
+#include "inexor/vulkan-renderer/wrapper/texture_attributes.hpp"
+
+#include <cassert>
 #include <string>
 #include <vector>
 
 #include <stb_image.h>
 
+#include <vulkan/vulkan.h>
+
+#include <ktxvulkan.h>
+
 namespace inexor::vulkan_renderer::wrapper {
 
 /// @brief RAII wrapper class for texture data.
 /// TODO: Scan asset directory automatically.
 class CpuTexture {
 private:
-    std::string m_name;
-
-    int m_texture_width{0};
-    int m_texture_height{0};
-    int m_texture_channels{0};
-    int m_mip_levels{0};
+    TextureAttributes m_attributes;
 
     stbi_uc *m_texture_data{nullptr};
 
+    // Khronos texture format library (ktx)
+    ktxTexture *m_ktx_texture{nullptr};
+    ktx_uint8_t *m_ktx_texture_data{nullptr};
+    ktx_size_t m_ktx_texture_data_size{0};
+
     void load_texture(const std::string &file_name);
 
     void load_ktx_texture(const std::string &file_name);
@@ -33,7 +42,7 @@ class CpuTexture {
 
     /// @brief Read a texture from a file.
     /// @param file_name The file name of the texture.
-    /// @param name The internal debug marker name of the command buffer. This must not be an empty string.
+    /// @param name The internal debug marker name of the texture (must not be empty).
     CpuTexture(const std::string &file_name, std::string name);
 
     CpuTexture(const CpuTexture &) = delete;
@@ -44,34 +53,54 @@ class CpuTexture {
     CpuTexture &operator=(const CpuTexture &) = delete;
     CpuTexture &operator=(CpuTexture &&) = default;
 
-    [[nodiscard]] std::string name() const {
-        return m_name;
+    [[nodiscard]] const std::string &name() const {
+        return m_attributes.name;
     }
 
-    [[nodiscard]] int width() const {
-        return m_texture_width;
+    [[nodiscard]] std::uint32_t width() const {
+        return m_attributes.width;
     }
 
-    [[nodiscard]] int height() const {
-        return m_texture_height;
+    [[nodiscard]] std::uint32_t height() const {
+        return m_attributes.height;
     }
 
-    [[nodiscard]] int channels() const {
-        return m_texture_channels;
+    [[nodiscard]] std::uint32_t channels() const {
+        return m_attributes.channels;
     }
 
-    [[nodiscard]] int mip_levels() const {
-        return m_mip_levels;
+    [[nodiscard]] std::uint32_t mip_levels() const {
+        return m_attributes.mip_levels;
     }
 
-    [[nodiscard]] stbi_uc *data() const {
-        return m_texture_data;
+    [[nodiscard]] TextureAttributes attributes() const {
+        return m_attributes;
+    }
+
+    [[nodiscard]] const void *data() const {
+        // The texture data is either stored in stb_image or ktx wrapper
+        return (m_ktx_texture) ? m_ktx_texture_data : m_texture_data;
     }
 
     [[nodiscard]] std::size_t data_size() const {
-        // TODO: We will need to update this once we fully support mip levels.
-        return static_cast<std::size_t>(m_texture_width) * static_cast<std::size_t>(m_texture_height) *
-               static_cast<std::size_t>(m_texture_channels);
+        std::size_t data_size = 0;
+
+        // TODO: Is this correct now with mip level support?
+
+        if (m_texture_data) {
+            data_size = static_cast<std::size_t>(m_attributes.width) * static_cast<std::size_t>(m_attributes.height) *
+                        static_cast<std::size_t>(m_attributes.channels);
+        } else if (m_ktx_texture_data) {
+            data_size = m_ktx_texture_data_size;
+        } else {
+            throw std::runtime_error("Error: texture data size invalid!");
+        }
+
+        return data_size;
+    }
+
+    [[nodiscard]] const auto ktx_wrapper() const {
+        return m_ktx_texture;
     }
 };
 

include/inexor/vulkan-renderer/wrapper/gpu_texture.hpp

@@ -7,94 +7,69 @@
 #include "inexor/vulkan-renderer/wrapper/image.hpp"
 #include "inexor/vulkan-renderer/wrapper/once_command_buffer.hpp"
 
-#include <vulkan/vulkan_core.h>
+#include "inexor/vulkan-renderer/wrapper/texture_attributes.hpp"
+
+#include <vulkan/vulkan.h>
+
+#include <ktxvulkan.h>
 
 #include <memory>
 #include <string>
 
 namespace inexor::vulkan_renderer::wrapper {
 
-class Device;
-class GPUMemoryBuffer;
-class OnceCommandBuffer;
+/// TODO: Support texture arrays!
 
 /// @note The code which loads textures from files is wrapped in CpuTexture.
 /// @brief RAII wrapper class for textures which are stored in GPU memory.
-/// @todo Support 3D textures and cube maps (implement new and separate wrappers though).
 class GpuTexture {
+    const Device &m_device;
+    TextureAttributes m_attributes;
     std::unique_ptr<Image> m_texture_image;
-    OnceCommandBuffer m_copy_command_buffer;
+
     VkSampler m_sampler{VK_NULL_HANDLE};
     VkDescriptorImageInfo m_descriptor;
 
-    int m_texture_width{0};
-    int m_texture_height{0};
-    int m_texture_channels{0};
-    int m_miplevel_count{0};
-    VkFormat m_texture_image_format{VK_FORMAT_R8G8B8A8_UNORM};
-
-    std::string m_name;
-    const Device &m_device;
+    void create_image(const void *texture_data, std::size_t texture_size);
 
-    /// @brief Create the texture.
-    /// @param texture_data A pointer to the texture data.
-    /// @param texture_size The size of the texture.
-    void create_image_from_data(const void *texture_data, std::size_t texture_size);
+    void create_cubemap_image(const void *texture_data, std::size_t texture_size, ktxTexture* texture);
 
     /// @brief Transform the image layout.
-    /// @param image The image.
-    /// @param old_layout The old image layout.
-    /// @param new_layout The new image layout.
+    /// @param image The image
+    /// @param old_layout The old image layout
+    /// @param new_layout The new image layout
     void transition_image_layout(VkImage image, VkImageLayout old_layout, VkImageLayout new_layout);
 
-    /// @brief Create the default texture sampler.
     void create_default_texture_sampler();
 
-    ///
     void create_texture_sampler(VkSamplerCreateInfo sampler_ci);
 
-    ///
     void create_texture_sampler(const gltf::TextureSampler &sampler);
 
     void update_descriptor();
 
 public:
-    /// @brief Construct a texture from a file.
-    /// @param device A const reference to a device RAII wrapper instance
-    /// @param cpu_texture A const reference to the CPU texture
     GpuTexture(const Device &device, const CpuTexture &cpu_texture);
 
-    /// @brief Construct a texture from a file.
-    /// @param device A const reference to a device RAII wrapper instance
-    GpuTexture(const Device &device, const gltf::TextureSampler &sampler, const CpuTexture &cpu_texture);
+    GpuTexture(const Device &device, const CpuTexture &cpu_texture, std::uint32_t faces);
 
-    /// @brief Construct a texture from a block of memory.
-    /// @param device A const reference to a device RAII wrapper instance
+    // TODO: Support mip levels here!
     GpuTexture(const Device &device, const void *data, std::size_t data_size, std::uint32_t width, std::uint32_t height,
                std::uint32_t channel_count, std::uint32_t miplevel_count, std::string name);
 
-    /// @brief Construct a texture from a block of memory for a glTF2 model file texture.
-    /// @param device A const reference to a device RAII wrapper instance
+    GpuTexture(const Device &device, const gltf::TextureSampler &sampler, const CpuTexture &cpu_texture);
+
     GpuTexture(const Device &device, const gltf::TextureSampler &sampler, const void *data, std::size_t data_size,
                std::uint32_t width, std::uint32_t height, std::uint32_t channel_count, std::uint32_t miplevel_count,
                std::string name);
 
-    /// @brief
-    GpuTexture(const Device &device, VkImageCreateFlags image_create_flags, VkFormat format, std::uint32_t width,
-               std::uint32_t height, std::uint32_t miplevel_count, std::uint32_t array_layer_count,
-               VkImageUsageFlags image_usage, std::string name);
-
     GpuTexture(const GpuTexture &) = delete;
     GpuTexture(GpuTexture &&) noexcept;
     ~GpuTexture();
 
     GpuTexture &operator=(const GpuTexture &) = delete;
     GpuTexture &operator=(GpuTexture &&) = delete;
 
-    [[nodiscard]] const std::string &name() const {
-        return m_name;
-    }
-
     [[nodiscard]] VkImage image() const {
         return m_texture_image->image();
     }

include/inexor/vulkan-renderer/wrapper/texture_attributes.hpp

@@ -0,0 +1,18 @@
+#pragma once
+
+#include <vulkan/vulkan_core.h>
+
+#include <string>
+
+namespace inexor::vulkan_renderer::wrapper {
+
+struct TextureAttributes {
+    VkFormat format{VK_FORMAT_R8G8B8A8_UNORM};
+    std::string name;
+    std::uint32_t width{0};
+    std::uint32_t height{0};
+    std::uint32_t channels{0};
+    std::uint32_t mip_levels{0};
+};
+
+}

src/CMakeLists.txt

@@ -10,7 +10,6 @@ set(INEXOR_SOURCE_FILES
     vulkan-renderer/settings_decision_maker.cpp
     vulkan-renderer/time_step.cpp
 
-    vulkan-renderer/cubemap/cubemap_cpu_texture.cpp
     vulkan-renderer/cubemap/cubemap_generator.cpp
 
     vulkan-renderer/gltf/gltf_bbox.cpp
@@ -66,6 +65,7 @@ set(INEXOR_SOURCE_FILES
     vulkan-renderer/wrapper/shader_loader.cpp
     vulkan-renderer/wrapper/staging_buffer.cpp
     vulkan-renderer/wrapper/swapchain.cpp
+    vulkan-renderer/wrapper/texture_attributes.cpp
     vulkan-renderer/wrapper/uniform_buffer.cpp
     vulkan-renderer/wrapper/window.cpp
     vulkan-renderer/wrapper/window_surface.cpp

src/vulkan-renderer/application.cpp

@@ -742,7 +742,7 @@ Application::Application(int argc, char **argv) {
 
     m_pbr_brdf_lut = std::make_unique<pbr::BRDFLUTGenerator>(*m_device);
 
-    // m_cubemap = std::make_unique<cubemap::CubemapGenerator>(*m_device, "assets/environments/papermill.ktx");
+    // m_cubemap = std::make_unique<cubemap::CubemapGenerator>(*m_device);
 
     setup_descriptors();
 

src/vulkan-renderer/cubemap/cubemap_generator.cpp

@@ -24,7 +24,7 @@
 
 namespace inexor::vulkan_renderer::cubemap {
 
-CubemapGenerator::CubemapGenerator(const wrapper::Device &device, const CubemapCpuTexture &texture) {
+CubemapGenerator::CubemapGenerator(const wrapper::Device &device) {
 
     enum Target { IRRADIANCE = 0, PREFILTEREDENV = 1 };