VulkanMesh.hpp

Go to the documentation of this file.

 
#pragma once
#include "context.hpp"
#include "components/Mesh.hpp"
#include "components/ErrorUtils.hpp"
#include "Resources.hpp"
 
#include "components/GameComponents/BasicComponents.hpp"
 
#include <sys/types.h>
 
namespace vex {
    struct TransparentTriangle;

    struct DrawIndexedIndirectCommand;

    class VulkanMesh {
    public:
        VulkanMesh(VulkanContext& context);
        ~VulkanMesh();

        void upload(const MeshData& meshData);
 
        // @brief Function to extract transparent triangles
        // @details Transforms triangle centers to world space, calculates distance to camera, and populates `outTriangles` with render data.
        // @param const glm::mat4& modelMatrix - Model matrix for the mesh.
        // @param const glm::vec3& cameraPos - Position of the camera.
        // @param uint32_t modelIndex - Index of the current model.
        // @param uint32_t frameIndex - Index of the current frame.
        // @param vex::Entity entity - Entity associated with the mesh.
        // @param std::vector<TransparentTriangle>& outTriangles - Vector to store extracted transparent triangles.
        void extractTransparentTriangles(
            const glm::mat4& modelMatrix,
            const glm::vec3& cameraPos,
            uint32_t modelIndex,
            uint32_t frameIndex,
            vex::Entity entity,
            std::vector<TransparentTriangle>& outTriangles
        );

        void draw(VkCommandBuffer cmd, VkPipelineLayout pipelineLayout,
                VulkanResources& resources, uint32_t frameIndex, uint32_t modelIndex, glm::mat4 modelMatrix, const MeshComponent& mc) const;

        void bindAndDrawBatched(
                VkCommandBuffer cmd,
                VkPipelineLayout pipelineLayout,
                VulkanResources& resources,
                uint32_t frameIndex,
                uint32_t modelIndex,
                uint32_t submeshIndex,
                glm::mat4 modelMatrix,
                bool modelChanged,
                bool submeshChanged,
                const MeshComponent& mc
            ) const;

        int getNumOfInstances() const { return numOfInstances; }

        void addInstance() { numOfInstances++; }

        void removeInstance() { numOfInstances--; }
 
    private:
        struct SubmeshBuffers {
            VkBuffer vertexBuffer;
            VmaAllocation vertexAlloc;
            VkBuffer indexBuffer;
            VmaAllocation indexAlloc;
            uint32_t indexCount;
        };

        void StreamToGPU(void* dst, const void* src, size_t sizeBytes);
 
        VulkanContext& m_r_context;
        std::vector<SubmeshBuffers> m_submeshBuffers;
        std::vector<std::string> m_submeshTextures;
        int numOfInstances = 0;
 
        std::vector<Submesh> m_cpuSubmeshData;
    };

struct TransparentTriangle {
        // @brief Distance from the camera to the triangle's center (for sorting)
        float distanceToCamera;
 
        // @brief Data needed to render the triangle after sorting
        uint32_t modelIndex;
        uint32_t frameIndex;
        uint32_t firstIndex;
        uint32_t submeshIndex;
        VulkanMesh* mesh;
        vex::Entity entity;
 
        //glm::mat4 modelMatrix;
    };
}