C_commandBuffer.hpp

/*
 * Copyright 2024 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_COMMANDBUFFER_HPP_INCLUDED
#define _FGE_VULKAN_C_COMMANDBUFFER_HPP_INCLUDED
 
#include "FastEngine/fge_extern.hpp"
 
#include "FastEngine/vulkan/C_contextAware.hpp"
#include "FastEngine/vulkan/vulkanGlobal.hpp"
#include <unordered_map>
#include <utility>
 
namespace fge::vulkan
{
 
class FGE_API CommandBuffer : public ContextAware
{
public:
    enum class RenderPassScopes
    {
        INSIDE,
        OUTSIDE,
        BOTH
    };
 
    enum SupportedQueueTypes : uint32_t
    {
        SUPPORTED_QUEUE_GRAPHICS = 1 << 0,
        SUPPORTED_QUEUE_COMPUTE = 1 << 1,
        SUPPORTED_QUEUE_TRANSFER = 1 << 2,
 
        SUPPORTED_QUEUE_ALL = SUPPORTED_QUEUE_GRAPHICS | SUPPORTED_QUEUE_COMPUTE | SUPPORTED_QUEUE_TRANSFER
    };
    using SupportedQueueTypes_t = std::underlying_type_t<SupportedQueueTypes>;
 
    CommandBuffer(Context const& context);
    CommandBuffer(Context const& context, VkCommandBufferLevel level, VkCommandPool commandPool);
    CommandBuffer(Context const& context,
                  VkCommandBufferLevel level,
                  VkCommandBuffer commandBuffer,
                  VkCommandPool commandPool);
    CommandBuffer(CommandBuffer const& r) = delete;
    CommandBuffer(CommandBuffer&& r) noexcept;
    ~CommandBuffer() override;
 
    CommandBuffer& operator=(CommandBuffer const& r) = delete;
    CommandBuffer& operator=(CommandBuffer&& r) noexcept;
 
    void create(VkCommandBufferLevel level, VkCommandPool commandPool);
    void create(VkCommandBufferLevel level, VkCommandBuffer commandBuffer, VkCommandPool commandPool);
    void destroy() final;
    [[nodiscard]] std::pair<VkCommandBuffer, VkCommandPool> release();
 
    void reset();
    void begin(VkCommandBufferUsageFlags flags, VkCommandBufferInheritanceInfo const* inheritanceInfo = nullptr);
    void end();
 
    [[nodiscard]] VkCommandBuffer get() const;
    [[nodiscard]] VkCommandBuffer const* getPtr() const;
    [[nodiscard]] VkCommandPool getPool() const;
    [[nodiscard]] VkCommandBufferLevel getLevel() const;
    [[nodiscard]] RenderPassScopes getRenderPassScope() const;
    [[nodiscard]] SupportedQueueTypes_t getSupportedQueues() const;
    [[nodiscard]] uint32_t getRecordedCommandsCount() const;
    [[nodiscard]] bool isEnded() const;
 
    void forceEnd();
    void forceRenderPassScope(RenderPassScopes scope);
    void forceSupportedQueues(SupportedQueueTypes_t queues);
    void forceRecordedCommandsCount(uint32_t count);
 
    void copyBuffer(VkBuffer srcBuffer, VkBuffer dstBuffer, VkDeviceSize size);
    void transitionImageLayout(VkImage image,
                               VkFormat format,
                               VkImageLayout oldLayout,
                               VkImageLayout newLayout,
                               uint32_t mipLevels);
    void copyBufferToImage(VkBuffer buffer,
                           VkImage image,
                           uint32_t width,
                           uint32_t height,
                           int32_t offsetX = 0,
                           int32_t offsetY = 0);
    void copyImageToBuffer(VkImage image, VkBuffer buffer, uint32_t width, uint32_t height);
    void copyImageToImage(VkImage srcImage,
                          VkImage dstImage,
                          uint32_t width,
                          uint32_t height,
                          int32_t offsetX = 0,
                          int32_t offsetY = 0);
 
    void pushConstants(VkPipelineLayout pipelineLayout,
                       VkShaderStageFlags stageFlags,
                       uint32_t offset,
                       uint32_t size,
                       void const* pValues);
 
    void beginRenderPass(VkRenderPass renderPass,
                         VkFramebuffer framebuffer,
                         VkExtent2D extent,
                         VkClearValue clearColor,
                         VkSubpassContents contents);
 
    void endRenderPass();
 
    void bindDescriptorSets(VkPipelineLayout pipelineLayout,
                            VkPipelineBindPoint pipelineBindPoint,
                            VkDescriptorSet const* descriptorSet,
                            uint32_t descriptorCount,
                            uint32_t firstSet);
 
    void bindDescriptorSets(VkPipelineLayout pipelineLayout,
                            VkPipelineBindPoint pipelineBindPoint,
                            VkDescriptorSet const* descriptorSet,
                            uint32_t descriptorCount,
                            uint32_t dynamicOffsetCount,
                            uint32_t const* pDynamicOffsets,
                            uint32_t firstSet);
 
    void bindPipeline(VkPipelineBindPoint pipelineBindPoint, VkPipeline pipeline);
 
    void setViewport(uint32_t firstViewport, uint32_t viewportCount, VkViewport const* pViewports);
    void setScissor(uint32_t firstScissor, uint32_t scissorCount, VkRect2D const* pScissors);
 
    void bindVertexBuffers(uint32_t firstBinding,
                           uint32_t bindingCount,
                           VkBuffer const* pBuffers,
                           VkDeviceSize const* pOffsets);
    void bindIndexBuffer(VkBuffer buffer, VkDeviceSize offset, VkIndexType indexType);
 
    void draw(uint32_t vertexCount, uint32_t instanceCount, uint32_t firstVertex, uint32_t firstInstance);
    void drawIndexed(uint32_t indexCount,
                     uint32_t instanceCount,
                     uint32_t firstIndex,
                     int32_t vertexOffset,
                     uint32_t firstInstance);
    void drawIndirect(VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride);
 
private:
    VkCommandBuffer g_commandBuffer;
    VkCommandPool g_commandPool;
    VkCommandBufferLevel g_level;
    RenderPassScopes g_renderPassScope;
    SupportedQueueTypes_t g_queueType;
    uint32_t g_recordedCommands;
    bool g_isEnded;
 
    //Cache
    struct CacheDescriptorSets
    {
        constexpr CacheDescriptorSets(VkPipelineLayout pipelineLayout,
                                      VkPipelineBindPoint pipelineBindPoint,
                                      VkDescriptorSet descriptorSet) :
                _pipelineLayout(pipelineLayout),
                _pipelineBindPoint(pipelineBindPoint),
                _descriptorSet(descriptorSet)
        {}
 
        VkPipelineLayout _pipelineLayout;
        VkPipelineBindPoint _pipelineBindPoint;
        VkDescriptorSet _descriptorSet;
 
        [[nodiscard]] constexpr bool operator==(CacheDescriptorSets const& r) const
        {
            return this->_pipelineLayout == r._pipelineLayout && this->_pipelineBindPoint == r._pipelineBindPoint &&
                   this->_descriptorSet == r._descriptorSet;
        }
    };
 
    VkPipeline g_lastBoundPipeline{VK_NULL_HANDLE};
    VkViewport g_lastSetViewport{};
    VkRect2D g_lastSetScissor{};
    std::unordered_map<uint32_t, CacheDescriptorSets> g_lastBoundDescriptorSets;
};
 
} // namespace fge::vulkan
 
#endif //_FGE_VULKAN_C_COMMANDBUFFER_HPP_INCLUDED