RV_VKCommandBuffer.h

Go to the documentation of this file.

/*
 * PROPRIETARY INFORMATION.  This software is proprietary to
 * Side Effects Software Inc., and is not to be reproduced,
 * transmitted, or disclosed in any way without written permission.
 *
 * NAME:        RV_VKCommandBuffer.h ( RV Library, C++)
 *
 * COMMENTS:
 *      Class for creating Vulkan Command Buffer
 *      and other resources used with it
 */

#ifndef RV_VKCommandBuffer_h
#define RV_VKCommandBuffer_h

#include "RV_API.h"
#include "RV_Instance.h"

#include <VE/VE_VK.h>
#include "RV_VKPipeline.h"

#include <UT/UT_Array.h>
#include <UT/UT_Function.h>
#include <UT/UT_SharedPtr.h>

#include <functional>
#include <utility>

class RV_Instance;
class RV_ShaderVariableSet;
class RV_VKBuffer;
class RV_VKCommandPool;
class RV_VKImage;
class RV_VKAccelerationStructure;
class RV_VKQueue;

class RV_API RV_VKCommandBuffer
{
public:    
    static RV_VKCommandBuffer* allocate(
            RV_Instance* inst,
            RV_VKCommandPool* cmd_pool);

    VkCommandBuffer getVkCmdBuf() 
        {   UT_ASSERT_MSG(myIsRecording, 
                "Using VKCommandBuffer that is not recording: "
                "check that you haven't flushed the buffer");
            return myVkCmdBuf; 
        }
    RV_VKCommandPool *getCmdPool()
        { return myCmdPool; }

    void beginRecording();
    void endRecording();

    bool waitForFinish();

    void addWaitSemaphore(VkSemaphore sem, VkPipelineStageFlags stage);
    void addSignalSemaphore(VkSemaphore sem, VkPipelineStageFlags stage);

    // TODO: replace with lifecycle enum?
    bool isRecording() const;
    bool isExecuting();

    // Callbacks to be run when the CommandBuffer is finished running
    //  Won't be run immediately, immediate synchronization should use
    //  `waitForFinish()` or wait on a timeline semaphore
    using Callback = UT_Function<void(RV_Instance*)>;

    void handleCompletionCallbacks(RV_Instance* inst)
    {
        // MUST be done executing
        UT_ASSERT(!isExecuting());
        if(isExecuting()) {
            return;
        }

        // run all callbacks
        for (auto& callback : myCompletionCallbacks)
        {
            callback(inst);
        }

        // clear list
        myCompletionCallbacks.clear();
    }

    void handleSubmissionCallbacks(RV_Instance* inst)
    {
        // run all callbacks
        for (auto& callback : mySubmissionCallbacks)
        {
            callback(inst);
        }

        // clear list
        mySubmissionCallbacks.clear();
    }

    void addCompletionCallback(const Callback &callback)
    {
        myCompletionCallbacks.append(callback);
    }

    void addSubmissionCallback(const Callback &callback)
    {
        mySubmissionCallbacks.append(callback);
    }

    // Reset bound state to default, to force re-binding
    // and setting dynamic state
    void invalidateState()
    {
        myPipeState = RV_VKPipelineStateInfo{};
    }


    // Functions used for logging and validation

    // Add a log to the CB, will be written out on errors
    void appendLog(const UT_StringHolder &log)
        { myLogEntries.append(log); }
    // record VkImage as being used by this CB
    void logImageUsage(const RV_VKImage* img);
    // record VkBuffer as being used by this CB
    void logBufferUsage(const RV_VKBuffer* buf);
    // record VkAccelerationStructureKHR as being used by this CB
    void logAccelStructUsage(const RV_VKAccelerationStructure* accel_struct);
    // record VkDescriptorSet as being used by this CB
    void logSetUsage(const RV_ShaderVariableSet* set);

    ~RV_VKCommandBuffer();

    // disable copy
    RV_VKCommandBuffer(const RV_VKCommandBuffer&) = delete;
    RV_VKCommandBuffer& operator=(const RV_VKCommandBuffer&) = delete;

public:
    // Rendering State
    RV_VKPipelineStateInfo myPipeState;
    // TODO: Current Pipeline
    // TODO: Vertex Buffer
    // TODO: Index Buffer
    // TODO: Transform Feedback Buffer
protected:
    // main resources
    VkCommandBuffer myVkCmdBuf;       
    class RV_VKCommandPool* myCmdPool;
    RV_Instance* myInst = nullptr;

    // Creation info
    VkCommandBufferLevel myLevel = VK_COMMAND_BUFFER_LEVEL_PRIMARY;

    // Current status
    bool myIsRecording = false;

    // Synchronization Primitives
    VkFence myCompleteFence;

    UT_Array<VkPipelineStageFlags> myWaitStages;
    UT_Array<VkSemaphore> myWaitSems;

    UT_Array<VkPipelineStageFlags> mySignalStages;
    UT_Array<VkSemaphore> mySignalSems;

    // Keep a list of callbacks
    UT_Array<Callback> myCompletionCallbacks;
    UT_Array<Callback> mySubmissionCallbacks;

    // Extra info used for validation, logging, debugging
    // log to be printed on error
    struct ResourceInfo
    {   
        // Id to validate for resource
        RV_ResourceID id;
        // Label for debugging when resource is invalid
        UT_StringHolder label;
        // Indication of when resource was bound
        exint log_place;
    };
    bool validateUsedResources(RV_Instance* inst, FILE* out = nullptr) const;
    UT_Array<ResourceInfo> myImageIDs;
    UT_Array<ResourceInfo> myBufferIDs;
    UT_Array<ResourceInfo> myAccelStructIDs;
    UT_Array<ResourceInfo> mySetIDs;
    fpreal                 mySubmitTime = 0.f;
    UT_Array<UT_StringHolder> myLogEntries;  

    RV_VKCommandBuffer(
            RV_Instance* inst,
            RV_VKCommandPool* cmd_pool,
            VkCommandBuffer cmd_buf,
            const VkCommandBufferAllocateInfo& info,
            VkFence fence)
        : myInst(inst)
        , myCmdPool(cmd_pool)
        , myVkCmdBuf(cmd_buf)
        , myLevel(info.level)
        , myCompleteFence(fence)
    {
    }

    friend class RV_Instance;
    friend class RV_VKCommandPool;
    friend class RV_VKQueue;
};

// Helper class for callback that owns UniquePtr
//  and destroys it when called

// default impl of templated var
template<typename, typename = void>
constexpr bool has_destroy_func = false;

// template specialization, to give true value if
// T has member func `void destroy(RV_Instance*)`
template <typename T>
constexpr bool has_destroy_func<T,
        std::void_t<decltype(std::declval<T>().destroy(
                std::declval<RV_Instance*>()))>>
        = true;

template<class T>
class RV_DestroyPtrTask
{
public:
    UT_SharedPtr<T> myObj;

    void operator()(RV_Instance* inst)
    {
        if constexpr (has_destroy_func<T>)
        {
            // destroy object before reseting ptr, if fcn exists.
            // Ensures object is destroyed, and not just queued
            // for deletion later again
            if (inst)
                myObj->destroy(inst);
        }
        myObj.reset();
    }

    RV_DestroyPtrTask(UT_UniquePtr<T> obj)
    : myObj(std::move(obj))
    {}
};

template<class T>
RV_VKCommandBuffer::Callback
RVmakeDestroyPtrTask(UT_UniquePtr<T> obj)
{
    return RV_VKCommandBuffer::Callback{RV_DestroyPtrTask<T>(std::move(obj))};
}

#endif