RV_VKPipelineLayout.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_VKPipelineLayout.h ( RV Library, C++)
 *
 * COMMENTS:
 *      Class Representing a Vulkan Graphics Pipeline Layout
 *      And sub-classes used in layout creation
 */

#ifndef RV_VKPipelineLayout_h
#define RV_VKPipelineLayout_h

#include "RV_API.h"

#include <UT/UT_Array.h>
#include <UT/UT_Map.h>
#include <UT/UT_StringHolder.h>
#include <UT/UT_UniquePtr.h>

#include <VE/VE_VK.h>
#include "RV_Type.h"
#include "RV_TypePtrs.h"
#include "RV_VKDescriptorSet.h"

class RV_Instance;
class RV_VKShaderModule;

class RV_VKAttributeInfo
{
public:
    VkFormat format = VK_FORMAT_UNDEFINED;
    int location = -1;
    UT_StringHolder myName;
};

// ------------------------
// RV_VKPushConstantRange
struct RV_VKPushConstantRange
{
    UT_Array<RV_Uniform> myMembers;
    VkShaderStageFlags myStages;
    int myOffset;
    int mySize;
};

// -----------------------
// Push Constant info
class RV_API RV_VKPushConstantInfo
{
public:
    RV_VKPushConstantInfo() = default;
    RV_VKPushConstantInfo(
            UT_Array<RV_Uniform>&& members,
            VkShaderStageFlagBits stage,
            int offset,
            int size);

    const UT_Array<RV_VKPushConstantRange> &getRanges() const
            { return myRanges; }

    bool merge(const RV_VKPushConstantInfo& other);
    bool merge(const RV_VKPushConstantRange& new_range);

private:
    UT_Array<RV_VKPushConstantRange> myRanges;
    friend class RV_VKPipelineLayout;
};

// -----------------------
// RV_VKPipelineLayoutInfo
//
// NOTE: unlike other info classes, this one owns resource handles
//       so can't be directly copied
//       It shouldn't need to be, as shader layouts are unique
//
//      tracks Pipeline create info that will be constant accross all pipelines
//      created from the same set of shaders. This includes all of the data for creating the 
//      pipeline layout, and SOME of the structs for the final pipeline
//      Effectively just the pipeline layout + the vertex attribute formats
class RV_VKPipelineLayoutInfo
{
public:
    UT_StringHolder                           myName;
    UT_Array<UT_UniquePtr<RV_VKShaderModule>> myShaderModules;
    // Maps shader stage to idx in `myShaderModules`
    UT_Map<VkShaderStageFlagBits, uint32_t>     myShaderStageMap; 

    // NOTE: currently, since pipeline layouts are built from shader
    //       files, they must be a specific shader type, and we
    //       will not have layouts that can be used with multiple
    //       pipeline types (e.g. graphics + compute) .. if changing
    //       this, pipeline type will need to be provided at higher
    //       level
    RV_ShaderType                       myShaderType = RV_SHADER_UNKNOWN;
    
    UT_Array<RV_VKAttributeInfo>        myInputs;
    UT_Array<RV_VKDescriptorSetInfo>    myDescriptorSets;
    RV_VKPushConstantInfo               myPushConstants;
    
    // TODO: list of specialization constants
    //UT_Array<RV_SpecializaitonConstant>

    // Creation Structs
    bool hasShaderStage(VkShaderStageFlagBits stage) const;
    bool addShaderModule(UT_UniquePtr<RV_VKShaderModule> shader_module);
};

// ----------------------
// RV_VKPipelineLayout
//
// RAII wrapper for VkPipelineLayout, created using RV_VKPipelineLayoutInfo
class RV_API  RV_VKPipelineLayout
{
public:
    VkPipelineLayout getVkLayout() const { return myVkPipelineLayout; }
    const RV_VKPipelineLayoutInfo& getInfo() const { return *myInfo; }

    RV_VKPipelineLayout(
            RV_Instance* inst,
            VkPipelineLayout pipe_layout,
            RV_VKPipelineLayoutInfo&& info);

    RV_VKPipelineLayout(const RV_VKPipelineLayout&) = delete;
    RV_VKPipelineLayout &operator=(const RV_VKPipelineLayout&) = delete;

    ~RV_VKPipelineLayout();
protected:
    RV_Instance*     myInst = nullptr;
    VkPipelineLayout myVkPipelineLayout = VK_NULL_HANDLE;

    UT_UniquePtr<RV_VKPipelineLayoutInfo> myInfo;
};

RV_API RV_VKPipelineLayoutPtr RVcreatePipelineLayout(
        RV_Instance* inst,
        const char* name,
        UT_Array<UT_UniquePtr<RV_VKShaderModule>> shaders);

RV_API RV_VKPipelineLayoutPtr RVcreatePipelineLayout(
        RV_Instance* inst,
        const char* name,
        const UT_StringArray& filenames);

#endif