Frame.hpp

/*
** ETIB PROJECT, 2026
** evan
** File description:
** Frame
*/
 
#pragma once
 
#include "evan/EvanPlatform.hpp"
 
#include "evan/ADeviceBackend.hpp"
#include "evan/DeviceContext.hpp"
 
#include <utility/logging/loggable.hpp>
#include <utility/logging/default_logger.hpp>
 
#include <vector>
 
namespace evan
{
    class Frame:
        protected utility::logging::Loggable<Frame,
                                             utility::logging::DefaultLogger>
    {
        public:
        struct ViewUniform {
            glm::mat4 view;
 
            glm::mat4 proj;
        };
 
        struct UniformBufferObject {
            glm::mat4 model;
 
            ViewUniform views[MAX_MULTIVIEW_VIEWS];
        };
 
        Frame(std::shared_ptr<DeviceContext> deviceContext,
              std::size_t perFrameSlotCount);
 
        ~Frame();
 
        void destroy(VkDevice device);
 
        void resetCommandBuffer(std::size_t viewSlot);
 
        VkCommandBuffer getCommandBuffer(std::size_t viewSlot) const;
 
        std::size_t getPerFrameSlotCount() const;
 
        VkBuffer getUniformBuffer() const;
 
        VkDeviceSize getUniformBufferAlignedSize() const;
 
        void *getUniformBufferMapped(std::size_t viewSlot) const;
 
        VkBuffer getInstanceBuffer() const;
 
        void *getInstanceBufferMapped(std::size_t viewSlot) const;
 
        VkDeviceSize getInstanceBufferAlignedSize() const;
 
        std::size_t getInstanceCapacity() const;
 
        bool ensureInstanceCapacity(std::size_t transforms);
 
        VkBuffer getIndirectBuffer() const;
 
        void *getIndirectBufferMapped(std::size_t viewSlot) const;
 
        VkDeviceSize getIndirectBufferAlignedSize() const;
 
        [[nodiscard]] bool hasTimestampQueries() const noexcept
        {
            return _timestampQueryPool != VK_NULL_HANDLE;
        }
 
        [[nodiscard]] VkQueryPool getTimestampQueryPool() const noexcept
        {
            return _timestampQueryPool;
        }
 
        VkFence _inFlight = VK_NULL_HANDLE;
 
        VkQueryPool _timestampQueryPool = VK_NULL_HANDLE;
 
        std::vector<VkSemaphore> _imageAvailable;
 
        std::vector<VkCommandBuffer> _commandBuffers;
 
        std::vector<VkSemaphore> _renderFinished;
 
        std::size_t _perFrameSlotCount = 1;
 
        void *_uniformBufferMapped = nullptr;
 
        protected:
        void cleanup();
        void createCommandBuffer(VkDevice device, VkCommandPool commandPool);
 
        void createSyncObjects(VkDevice device);
 
        void createUniformBuffer(const ADeviceBackend &deviceBackend);
 
        void createInstanceBuffer(const ADeviceBackend &deviceBackend);
 
        void createIndirectBuffer(const ADeviceBackend &deviceBackend);
 
        void createTimestampQueryPool(VkDevice device);
 
        VkBuffer _uniformBuffer = VK_NULL_HANDLE;
 
        VkDeviceMemory _uniformBufferMemory = VK_NULL_HANDLE;
 
        VkDeviceSize _uniformBufferAlignedSize = 0;
 
        VkBuffer _instanceBuffer = VK_NULL_HANDLE;
 
        VkDeviceMemory _instanceBufferMemory = VK_NULL_HANDLE;
 
        void *_instanceBufferMapped = nullptr;
 
        VkDeviceSize _instanceBufferAlignedSize = 0;
 
        std::size_t _instanceCapacity = 0;
 
        VkBuffer _indirectBuffer = VK_NULL_HANDLE;
 
        VkDeviceMemory _indirectBufferMemory = VK_NULL_HANDLE;
 
        void *_indirectBufferMapped = nullptr;
 
        VkDeviceSize _indirectBufferAlignedSize = 0;
 
        std::shared_ptr<DeviceContext> _deviceContext;
    };
}    // namespace evan