VulkanMesh.hpp

Go to the documentation of this file.

#pragma once
#include "Engine/Utility/Defines.hpp"
#ifdef USING_VULKAN
#include "Engine/Mesh/Mesh.hpp"
#include <ThirdParty/Vulkan/Include/vulkan/vulkan.h>
#include <ThirdParty/assimp/include/assimp/Importer.hpp>
#include <ThirdParty/assimp/include/assimp/scene.h>

#include "Engine/Texture/VulkanTexture.hpp"
#include "Engine/Renderer/Vulkan/VulkanBuffer.hpp"
#include "Engine/Renderer/Vulkan/VulkanLogicalDevice.hpp"
#include "Engine/Renderer/Vulkan/VulkanDescriptorPool.hpp"
#include "Engine/Renderer/Vulkan/vk_mem_alloc.h"
#include "Engine/Animation/Skeleton.hpp"

#include <ThirdParty/EASTL-master/include/EASTL/map.h>
#include <ThirdParty/EASTL-master/include/EASTL/tuple.h>

namespace Engine
{

    class VulkanRenderer;

    class ENGINE_API VulkanMesh : public Mesh
    {
    public:
        // Should be called from renderer
        static void InitMeshes(VulkanRenderer* renderer, VulkanLogicalDevice* device, VulkanDescriptorPool* descriptorPool, VkCommandPool commandPool);

        void SetUpMesh() override;

        VkBuffer GetVertexBuffer() const;

        VkBuffer GetIndexBuffer() const;

        VkBuffer GetShadowIndexBuffer() const;

        uint32_t GetShadowIndexCount() const;

        uint32_t GetIndexCount();

        bool IsAnimated() const;

        VkDescriptorSet CreateBoneOffsetDescriptorSet(size_t threadID, size_t pipelineID, size_t set, VkDescriptorSetLayout layout);

        VkDescriptorSet GetBoneOffsetDescriptorSet(size_t threadID, size_t pipelineID, size_t set);


    private:

        friend class ResourceManager;

        VulkanMesh() = delete;
        VulkanMesh(aiMesh* mesh, eastl::shared_ptr<Skeleton> skeleton, eastl::vector<Vertex> vertices, eastl::vector<unsigned> indices);
        VulkanMesh(VulkanMesh const &other) = default;
    public:
        ~VulkanMesh();
    private:

        //eastl::vector<eastl::shared_ptr<Texture>> textures;

        struct Edge {
            uint32_t indices[2];

            Edge(uint32_t index1, uint32_t index2) {
                if (index1 > index2) {
                    indices[0] = index1;
                    indices[1] = index2;
                }
                else {
                    indices[0] = index2;
                    indices[1] = index1;
                }
            }

            bool operator<(const Edge& right) const {
                return eastl::tie(indices[0], indices[1]) <
                    eastl::tie(right.indices[0], right.indices[1]);
            }

        };

        struct Face {
            uint32_t indices[3];

            bool operator==(const Face& other)const {
                return (indices[0] == other.indices[0] &&
                    indices[1] == other.indices[1] &&
                    indices[2] == other.indices[2]);
            }

            uint32_t FindOpposingIndex(Edge edge) {
                for (int i = 0; i < 3; ++i) {
                    if (indices[i] != edge.indices[0] && indices[i] != edge.indices[1])
                        return indices[i];
                }
                return -1;
            }
        };

        eastl::shared_ptr<Skeleton> skeleton;

        eastl::vector<glm::mat4> boneOffsets;

        eastl::unique_ptr<VulkanBuffer> vertexBuffer;
        eastl::unique_ptr<VulkanBuffer> indexBuffer;
        eastl::unique_ptr<VulkanBuffer> offsetBuffer;

        eastl::unique_ptr<VulkanBuffer> shadowIndexBuffer;

        eastl::vector<eastl::vector<eastl::vector<VkDescriptorSet>>> offsetDescriptorSets;

        eastl::shared_ptr<VulkanTexture> diffuseMissing;

        const aiScene* scene;
        aiMesh* mesh;

        static VulkanRenderer* renderer;
        static VulkanLogicalDevice* device;
        static VkCommandPool commandPool;
        static VmaAllocator allocator;
        static VulkanDescriptorPool* descriptorPool;

        bool animated;

        uint32_t shadowIndicesCount;

    };

} //namespace Engine
#endif