C_context.hpp

/*
 * Copyright 2025 Guillaume Guillet
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
 
#ifndef _FGE_VULKAN_C_CONTEXT_HPP_INCLUDED
#define _FGE_VULKAN_C_CONTEXT_HPP_INCLUDED
 
#include "FastEngine/fge_extern.hpp"
 
#include "FastEngine/vulkan/vulkanGlobal.hpp"
#include <array>
#include <unordered_map>
#include <vector>
 
#include "FastEngine/vulkan/C_commandBuffer.hpp"
#include "FastEngine/vulkan/C_descriptorPool.hpp"
#include "FastEngine/vulkan/C_descriptorSetLayout.hpp"
#include "FastEngine/vulkan/C_garbageCollector.hpp"
#include "FastEngine/vulkan/C_graphicPipeline.hpp"
#include "FastEngine/vulkan/C_instance.hpp"
#include "FastEngine/vulkan/C_logicalDevice.hpp"
#include "FastEngine/vulkan/C_physicalDevice.hpp"
#include "FastEngine/vulkan/C_surface.hpp"
#include "FastEngine/vulkan/C_textureImage.hpp"
#include "FastEngine/vulkan/C_uniformBuffer.hpp"

#define FGE_VULKAN_USE_STRICT_LAYOUT_BINDINGS_STAGE 0
 
#define FGE_VULKAN_TEXTURE_BINDING 0
#define FGE_VULKAN_TRANSFORM_BINDING 0
#define FGE_MULTIUSE_POOL_MAX_COMBINED_IMAGE_SAMPLER FGE_SHADER_MAX_BINDING_VARIABLE_DESCRIPTOR_COUNT
 
#define FGE_CONTEXT_OUTSIDE_RENDER_SCOPE_COMMAND_WAITSTAGE VK_PIPELINE_STAGE_VERTEX_INPUT_BIT
 
#define FGE_CONTEXT_GLOBALTRANSFORMS_COUNT_START 200
 
namespace fge
{
 
struct TransformUboData;
class RenderTarget;
 
} // namespace fge
 
namespace fge::vulkan
{

class FGE_API Context
{
public:
    enum class SubmitTypes
    {
        DIRECT_WAIT_EXECUTION, 
        INDIRECT_EXECUTION 
    };
 
    class SubmitableCommandBuffer : public CommandBuffer
    {
    public:
        using CommandBuffer::CommandBuffer;
 
        [[nodiscard]] inline SubmitTypes getSubmitType() const { return g_submitType; }
 
    private:
        inline void setSubmitType(SubmitTypes type) { this->g_submitType = type; }
 
        SubmitTypes g_submitType;
 
        friend class Context;
    };
 
    struct GlobalTransform
    {
        GlobalTransform(vulkan::Context const& context);
 
        void init(vulkan::Context const& context);
        void update();
 
        vulkan::UniformBuffer _transforms;
        vulkan::DescriptorSet _descriptorSet;
        uint32_t _transformsCount;
        bool _needUpdate;
    };
 
    Context();
    explicit Context(Surface const& surface);
    Context(Context const& r) = delete;
    Context(Context&& r) noexcept = delete;
    ~Context();
 
    Context& operator=(Context const& r) = delete;
    Context& operator=(Context&& r) noexcept = delete;
 
    void destroy();

    [[nodiscard]] SubmitableCommandBuffer beginCommands(SubmitTypes type,
                                                        CommandBuffer::RenderPassScopes wantedRenderPassScope,
                                                        CommandBuffer::SupportedQueueTypes_t wantedQueue) const;
    bool submitCommands(SubmitableCommandBuffer&& buffer) const;

    [[nodiscard]] VkSemaphore getIndirectSemaphore() const;
    void submit() const;

    [[nodiscard]] static Instance init(uint32_t sdlFlag,
                                       std::string_view applicationName,
                                       uint16_t versionMajor = 1,
                                       uint16_t versionMinor = 0,
                                       uint16_t versionPatch = 0);

    static void initVolk();

    void initVulkan(Surface const& surface);
    void initVulkanSurfaceless(Instance const& instance);

    static void enumerateExtensions();
    [[nodiscard]] static std::vector<std::string> retrieveExtensions();

    void waitIdle();
 
    [[nodiscard]] Instance const& getInstance() const;
    [[nodiscard]] Surface const& getSurface() const;
    [[nodiscard]] LogicalDevice const& getLogicalDevice() const;
    [[nodiscard]] PhysicalDevice const& getPhysicalDevice() const;

    [[nodiscard]] VkCommandPool getGraphicsCommandPool() const;
    void allocateGraphicsCommandBuffers(VkCommandBufferLevel level,
                                        VkCommandBuffer commandBuffers[],
                                        uint32_t commandBufferCount) const;

    [[nodiscard]] DescriptorPool const& getMultiUseDescriptorPool() const;

    [[nodiscard]] DescriptorSetLayout const& getTextureLayout() const;
    [[nodiscard]] DescriptorSetLayout const& getTransformLayout() const;
    [[nodiscard]] DescriptorPool const& getTextureDescriptorPool() const;
    [[nodiscard]] DescriptorPool const& getTransformDescriptorPool() const;

    [[nodiscard]] VmaAllocator getAllocator() const;
 
    [[nodiscard]] std::optional<BufferInfo> createBuffer(VkDeviceSize size,
                                                         VkBufferUsageFlags usage,
                                                         VmaAllocationCreateFlags flags,
                                                         VkMemoryPropertyFlags requiredProperties = 0) const;
    [[nodiscard]] std::optional<ImageInfo> createImage(uint32_t width,
                                                       uint32_t height,
                                                       VkFormat format,
                                                       VkImageTiling tiling,
                                                       uint32_t mipLevels,
                                                       VkImageUsageFlags usage,
                                                       VmaAllocationCreateFlags flags,
                                                       VkMemoryPropertyFlags requiredProperties = 0) const;

    void pushGraphicsCommandBuffer(VkCommandBuffer commandBuffer) const;
    [[nodiscard]] std::vector<VkCommandBuffer> const& getGraphicsCommandBuffers() const;
    void clearGraphicsCommandBuffers() const;
 
    void startMainRenderTarget(RenderTarget& renderTarget) const;
    [[nodiscard]] RenderTarget* getMainRenderTarget() const;
    [[nodiscard]] bool isMainRenderTarget(RenderTarget const& renderTarget) const;
    void endMainRenderTarget(RenderTarget const& renderTarget) const;
 
    [[nodiscard]] GlobalTransform const& getGlobalTransform() const;
    [[nodiscard]] fge::TransformUboData const* getGlobalTransform(uint32_t index) const;
    [[nodiscard]] std::pair<uint32_t, fge::TransformUboData*> requestGlobalTransform() const;
 
    void clearLayoutPipelineCache() const;
    [[nodiscard]] LayoutPipeline&
    requestLayoutPipeline(Shader const* vertexShader, Shader const* geometryShader, Shader const* fragmentShader) const;
    void clearDescriptorLayoutCache() const;
    [[nodiscard]] std::vector<DescriptorSetLayout> const* requestDescriptorLayout(Shader const* vertexShader,
                                                                                  Shader const* geometryShader,
                                                                                  Shader const* fragmentShader) const;
    [[nodiscard]] std::vector<DescriptorSetLayout> const* requestDescriptorLayout(Shader const* shader) const;

    [[nodiscard]] std::optional<DescriptorSet>
    createDescriptorSet(std::string_view shaderName, uint32_t setIndex, uint32_t variableElements = 0) const;
 
    GarbageCollector _garbageCollector;
 
private:
    void createCommandPool();
    void createMultiUseDescriptorPool();
    void createTextureDescriptorPool();
    void createTransformDescriptorPool();
    void createSyncObjects();
 
    mutable GlobalTransform g_globalTransform;
 
    struct ReusableCommandBuffer
    {
        constexpr ReusableCommandBuffer() = default;
        constexpr ReusableCommandBuffer(VkCommandBuffer commandBuffer, bool isRecording) :
                _commandBuffer(commandBuffer),
                _isRecording(isRecording)
        {}
 
        VkCommandBuffer _commandBuffer{VK_NULL_HANDLE};
        bool _isRecording{false};
    };
 
    PhysicalDevice g_physicalDevice;
    LogicalDevice g_logicalDevice;
    Surface const* g_surface;
    Instance const* g_instance;
 
    mutable std::unordered_map<LayoutPipeline::Key,
                               std::vector<DescriptorSetLayout>,
                               LayoutPipeline::Key::Hash,
                               LayoutPipeline::Key::Compare>
            g_cacheDescriptorLayouts;
    mutable std::
            unordered_map<LayoutPipeline::Key, LayoutPipeline, LayoutPipeline::Key::Hash, LayoutPipeline::Key::Compare>
                    g_cachePipelineLayouts;
    DescriptorPool g_multiUseDescriptorPool;
 
    DescriptorSetLayout g_textureLayout;
    DescriptorSetLayout g_transformLayout;
    DescriptorPool g_textureDescriptorPool;
    DescriptorPool g_transformDescriptorPool;
 
    mutable RenderTarget* g_mainRenderTarget;
 
    mutable VmaAllocator g_allocator;
 
    mutable uint32_t g_currentFrame;
 
    mutable std::vector<VkCommandBuffer> g_graphicsSubmitableCommandBuffers;
 
    std::array<VkSemaphore, FGE_MAX_FRAMES_IN_FLIGHT> g_indirectFinishedSemaphores{};
    mutable std::array<std::vector<CommandBuffer>, FGE_MAX_FRAMES_IN_FLIGHT> g_indirectSubmitableCommandBuffers{};
    mutable std::array<ReusableCommandBuffer, FGE_MAX_FRAMES_IN_FLIGHT>
            g_indirectOutsideRenderScopeGraphicsSubmitableCommandBuffers{};
 
    VkCommandPool g_graphicsCommandPool;
    bool g_isCreated;
};
 
} // namespace fge::vulkan
 
#endif //_FGE_VULKAN_C_CONTEXT_HPP_INCLUDED