GraphicsObjectManager.hpp

Go to the documentation of this file.

#pragma once
#include "DescriptorBuilder.hpp"
#include "GraphicsTypes.hpp"
#include "Mesh.hpp"
 
#include <array>
#include <mutex>
#include <optional>
#include <shared_mutex>
#include <unordered_map>
#include <utility>
#include <vector>
 
class GraphicsObjectManager
{
public:
    GraphicsObjectManager(VkInstance instance, VkPhysicalDevice gpu, VkDevice logDevice, VkQueue graphicsQueue, std::shared_mutex& graphicsMutex, uint32_t graphicsQueueFamily, const uint32_t frameCount);
 
    ~GraphicsObjectManager();
 
    void addTransferQueueFamilyAccess(const uint32_t transferQueueFamily, VkQueue transferQueue);
 
    bool addCharacter(int characterID, const std::vector<CharacterVertex>& vertices, const std::vector<uint32_t>& indices, ImageData& texture, glm::mat4 transformation, glm::mat4 bindPose[MAX_BONES], VkSampler imgSampler, PhongMaterial material = PhongMaterial::getDefaultMaterial());
 
    bool addGameObject(int objectId, const std::vector<Vertex>& vertices, const std::vector<uint32_t>& indices, ImageData& texture, glm::mat4 transformation, VkSampler imgSampler, PhongMaterial material = PhongMaterial::getDefaultMaterial());
 
    bool addTestObject(int id, const std::vector<SimpleVertex>& vertices, const std::vector<uint32_t>& indices, glm::mat4 transformation);
 
    bool addArea(const std::vector<Vertex>& vertices, const std::vector<uint32_t>& indices, std::array<ImageData, 6> textures, VkSampler texSampler);
 
    bool cleanResources(int id, ObjectType type);
 
    void updateTestObject(int id, const void* srcData, uint32_t frame);
 
    void updateObjectDescriptor(int id, const void* srcData, uint32_t frame);
 
    void updateCharacterDescriptor(int id, const void* transformSrcData, const void* boneSrcData, uint32_t frame);
 
    VkDescriptorSet getSunDescriptorSet(uint32_t frame) const;
 
    VkDescriptorSetLayout getSunLayout() const;
 
    void updateSunDescriptor(const void* srcData, uint32_t frame);
 
    void updateCameraDescriptor(const void* srcData, uint32_t frame);
 
    AllocatedImage createDepthImage(uint32_t width, uint32_t height, VkFormat depthFormat);
 
    void destroyImage(AllocatedImage image);
 
    void transitionDepthImageLayout(AllocatedImage depthImage, VkFormat depthFormat, VkImageLayout srcLayout, VkImageLayout dstLayout);
 
    VkImageView createImageView(VkImage image, VkFormat format, VkImageAspectFlags aspectFlags = VK_IMAGE_ASPECT_COLOR_BIT);
 
    CombinedImage createCombinedImage(uint32_t width, uint32_t height, VkFormat format);
 
    void copyBuffer(AllocatedBuffer allocBuffer, const void* srcData);
 
    void copyImage(AllocatedImage allocImage, const ImageData& srcData);
 
    VkDescriptorSetLayout getLayout(ObjectType type) const;
 
    uint32_t getLayoutCount(ObjectType type) const;
 
    std::vector<DrawableObject> getDrawableObjects(ObjectType type, uint32_t frame) const;
 
private:
    struct CommandUnit
    {
        VkQueue queue;             
        VkCommandPool commandPool; 
        uint32_t queueFamilyIndex; 
        VkCommandBuffer startCommandBuffer(VkDevice logDevice);
        bool endCommandBuffer(VkDevice logDevice, VkCommandBuffer commandBuffer, VkFence fence = VK_NULL_HANDLE);
    };
 
    AllocatedBuffer createBuffer(VkDeviceSize size, VkBufferUsageFlags usage, VmaAllocationInfo& info, VmaMemoryUsage memUsage = VMA_MEMORY_USAGE_AUTO, VmaAllocationCreateFlags vmaCreationFlags = 0, VkMemoryPropertyFlags requiredFlags = 0, VkMemoryPropertyFlags preferredFlags = 0);
    AllocatedBuffer createBuffer(VkDeviceSize size, VkBufferUsageFlags usage, VmaMemoryUsage memUsage = VMA_MEMORY_USAGE_AUTO, VmaAllocationCreateFlags vmaCreationFlags = 0, VkMemoryPropertyFlags requiredFlags = 0, VkMemoryPropertyFlags preferredFlags = 0);
 
    AllocatedImage createImage(uint32_t width, uint32_t height, VkFormat format, VkImageTiling tiling = VK_IMAGE_TILING_OPTIMAL, VkImageUsageFlags usage = VK_IMAGE_USAGE_TRANSFER_DST_BIT | VK_IMAGE_USAGE_SAMPLED_BIT, VmaMemoryUsage memUsage = VMA_MEMORY_USAGE_AUTO, VmaAllocationCreateFlags vmaCreationFlags = 0, VkMemoryPropertyFlags requiredFlags = 0, VkMemoryPropertyFlags preferredFlags = 0);
 
    void createDescriptorBuilder();
 
    uint32_t getQueueFamilyCount();
 
    VkSharingMode getSharingMode();
 
    VkCommandBuffer startCommandBuffer(bool preferTransfer);
 
    bool endCommandBuffer(VkCommandBuffer commandBuffer, VkFence fence = VK_NULL_HANDLE);
 
    void transitionImageLayout(VkImage image, VkFormat format, VkImageLayout oldLayout, VkImageLayout newLayout, VkCommandBuffer commandBuffer, VkImageAspectFlags aspectFlags = VK_IMAGE_ASPECT_COLOR_BIT, std::pair<uint32_t, uint32_t> srcAndDstQueueFamilies = {VK_QUEUE_FAMILY_IGNORED, VK_QUEUE_FAMILY_IGNORED});
 
    std::pair<uint32_t, uint32_t> getQueueTransitionFamilies();
 
    bool getPipelineAndAccessFlags(VkImageLayout srcLayout, VkImageLayout dstLayout, std::pair<VkAccessFlags, VkAccessFlags>& srcAndDstAccessMasks, std::pair<VkPipelineStageFlags, VkPipelineStageFlags>& srcAndDstStages);
 
    AllocatedBuffer createStagingBuffer(VkDeviceSize size, VmaAllocationInfo& allocInfo);
 
    void createSun();
 
    // Required Vulkan handles
    VkDevice logDeviceM;
    VmaAllocator allocatorM;
    VkDeviceSize minOffsetM; 
 
    std::shared_mutex& graphicsQueueMutexM;
    CommandUnit graphicsCommandUnitM;
    std::optional<CommandUnit> transferCommandUnitM;
    // Todo make a better system
    std::optional<CommandUnit> activeCommandUnitM;
    // Builder
    std::unique_ptr<DescriptorBuilder> pBuilderM;
    // Data maps
    std::unordered_map<int, CharacterObject> characterObjectsM;
    std::unordered_map<int, GameObject> gameObjectsM;
    std::unordered_map<int, TestObject> testObjectsM;
    std::vector<AreaObject> areaObjectsM;
    LightObject sunM;
    VkDescriptorSetLayout sunLayoutM;
 
    std::vector<CombinedImage> allocatedImagesM;
 
    // Frame count
    uint32_t frameCountM;
    // Descriptor set layouts for common objects
    std::array<VkDescriptorSetLayout, OBJECT_TYPE_COUNT> descriptorSetLayoutsM;
};