Resources.hpp

Go to the documentation of this file.

 
#pragma once
#include "uniforms.hpp"
#include "context.hpp"
#include "components/ErrorUtils.hpp"
#include "components/VirtualFileSystem.hpp"
#include "components/ThreadPool.hpp"
#include "components/GameComponents/ParticleEmitterComponent.hpp"
 
#include <components/Types.hpp>
#include <string>
#include <array>
#include <vector>
#include <fstream>
 
namespace vex {
    class VulkanResources {
    public:
        VulkanResources(VulkanContext& context, VirtualFileSystem* vfs);

        ~VulkanResources();

        void createUniformBuffers();

        void updateSceneUBO(const SceneUBO& data);

        void updateLightUBO(uint32_t frameIndex, uint32_t modelIndex, const SceneLightsUBO& data);

        void createDefaultTexture();

        void updateTextureDescriptor(uint32_t frameIndex, VkImageView textureView, uint32_t textureIndex);

        const std::string& getDefaultTextureName() const {
            return defaultTextureName;
        }

        VkDescriptorSet getUBODescriptorSet(uint32_t frameIndex) const;

        bool loadTexture(const std::string& path, const std::string& name) ;

        void loadTexturesBatched(const std::vector<std::string>& paths);

        void unloadTexture(const std::string& name);

        VkImageView getTextureView(const std::string& name) const;

        void createTextureFromRaw(const std::vector<unsigned char>& rgba, int w, int h, const std::string& name);

        VkDescriptorSet getDescriptorSet(uint32_t frameIndex) const {
            if (frameIndex >= m_descriptorSets.size()) {
                log(LogLevel::ERROR,
                           "Invalid frame index %u (Max %zu)",
                           frameIndex, m_descriptorSets.size());
                return VK_NULL_HANDLE;
            }
            return m_descriptorSets[frameIndex];
        }

        VkDescriptorSet* getDescriptorSetPtr(uint32_t frameIndex) {
            if (frameIndex >= m_descriptorSets.size()) {
                log(LogLevel::ERROR,
                           "Invalid frame index %u (Max %zu). Returning nullptr.",
                           frameIndex, m_descriptorSets.size());
                return nullptr;
            }
            return &m_descriptorSets[frameIndex];
        }

        VkDescriptorSet getTextureDescriptorSet(uint32_t frameIndex, uint32_t textureIndex) const;

        VkDescriptorSetLayout getDescriptorLayout() const { return m_descriptorSetLayout; }

        bool textureExists(const std::string& name) const {
            return m_textures.find(name) != m_textures.end();
        }

        uint32_t getTextureIndex(const std::string& name);

        VkSampler getTextureSampler() const { return m_textureSampler; }

        VkDescriptorSet getBindlessDescriptorSet() const { return m_r_context.bindlessDescriptorSet; }

        VkDescriptorSetLayout getBindlessLayout() const { return m_r_context.bindlessDescriptorSetLayout; }

        VkDescriptorSet getParticleDescriptorSet(uint32_t frameIndex) const {
            if (frameIndex >= m_particleDescriptorSets.size()) {
                log(LogLevel::ERROR,
                           "Invalid frame index %u for particle descriptor set (Max %zu)",
                           frameIndex, m_particleDescriptorSets.size());
                return VK_NULL_HANDLE;
            }
            return m_particleDescriptorSets[frameIndex];
        }

        void* getParticleMappedData(uint32_t frameIndex) const {
            if (frameIndex >= m_particleMappedData.size()) {
                log(LogLevel::ERROR,
                           "Invalid frame index %u for particle mapped data (Max %zu)",
                           frameIndex, m_particleMappedData.size());
                return nullptr;
            }
            return m_particleMappedData[frameIndex];
        }

        void createColorLUT();
    private:
        const std::string defaultTextureName = "default";
 
        VulkanContext& m_r_context;
        VirtualFileSystem* m_vfs;
 
        std::vector<VkBuffer> m_sceneBuffers;
        std::vector<VkBuffer> m_lightBuffers;
        std::vector<VmaAllocation> m_sceneAllocs;
        std::vector<VmaAllocation> m_lightAllocs;
 
        std::vector<VkBuffer> m_particleSSBOs;
        std::vector<VmaAllocation> m_particleAllocs;
        std::vector<void*> m_particleMappedData;
        VkDescriptorPool m_particleDescriptorPool = VK_NULL_HANDLE;
        std::vector<VkDescriptorSet> m_particleDescriptorSets;
 
        VkDescriptorSetLayout m_descriptorSetLayout;
        std::vector<VkDescriptorSet> m_descriptorSets;
        VkDescriptorPool m_descriptorPool;
        std::vector<VkDescriptorSet> m_textureDescriptorSets;
 
        vex_map<std::string, VkImageView> m_textures;
        VkSampler m_textureSampler;
 
        vex_map<std::string, VkImage> m_textureImages;
        vex_map<std::string, VmaAllocation> m_textureAllocations;
        vex_map<std::string, VkImageView> m_textureViews;
 
        std::vector<std::string> m_ignoredTexturePaths;

        void createDescriptorResources();
        void createTextureSampler();
        void createPerMeshTextureSets();
        void createParticleSSBOs();
    };
}