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 <UT/UT_NonCopyable.h>

#include <SYS/SYS_Hash.h>

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

class RV_Instance;
class RV_VKShaderModule;
class RV_VKShader;
class RV_VKShaderReflect;

class RV_Uniform;
class RV_VKDescriptorSet;
class RV_VKDescriptorLayout;
class RV_VKDescriptorSetInfo;
class RV_VKDescriptorSetUpdates;
struct RV_VKDescriptorBinding;

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

    bool operator== (const RV_VKAttributeInfo& other) const
    {
        return format == other.format
               && location == other.location
               && myName == other.myName;
    }
};

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

    bool operator==(const RV_VKPushConstantRange &other) const
    {
        return myOffset    == other.myOffset
               && mySize   == other.mySize
               && myStages == other.myStages;
    }
};


// -----------------------
// 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);

    bool operator== (const RV_VKPushConstantInfo & other) const
        { return myRanges == other.myRanges; }

    bool operator!= (const RV_VKPushConstantInfo & other) const
        { return !(myRanges == other.myRanges); }

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_API RV_VKPipelineLayoutInfo
{
public:
    UT_StringHolder                           myName;
    VkShaderStageFlagBits myShaderStages = (VkShaderStageFlagBits)0;

    // 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
    // NOTE: simliarily, some of the values here are only valid for either
    //       for graphices or compute shaders (i.e. workgroup size, inputs)
    RV_ShaderType                       myShaderType = RV_SHADER_UNKNOWN;
    
    UT_Array<RV_VKAttributeInfo>        myInputs;
    UT_Array<RV_VKDescriptorSetInfo>    myDescriptorSets;
    RV_VKPushConstantInfo               myPushConstants;

    UT_Vector3i     myWorkGroupSize = UT_Vector3i(0,0,0);
    bool            myWorkGroupIsSpecConst = false;

    // features requires
    VE_PhysicalDeviceFeatures myRequiredFeatures = {};

    // TODO: list of specialization constants
    //UT_Array<RV_SpecializaitonConstant>

    bool isInit() const;
    bool isValidForCompile(RV_Instance *inst) const;
    bool isGraphicsShader() const;
    bool isComputeShader() const;

    // Creation Structs
    bool hasShaderStage(VkShaderStageFlagBits stage) const;
    bool addShaderModule(RV_VKShaderModuleInfo *shader_module);
    bool addShaderModule(RV_VKShaderReflect& module_info, VkShaderStageFlagBits stage);

    bool operator==(const RV_VKPipelineLayoutInfo& other) const;

    SYS_HashType calcHash() const;
};

inline SYS_HashType hash_value(const RV_VKPipelineLayoutInfo& in)
{
    return in.calcHash();
}

// ----------------------
// RV_VKPipelineLayout
//
// RAII wrapper for VkPipelineLayout, created using RV_VKPipelineLayoutInfo
// Also takes ownership of the shader modules matching it, which are also
// needed to create pipelines
class RV_API RV_VKPipelineLayout
{
public:

    VkPipelineLayout getVkLayout() const { return myVkPipelineLayout; }

    const RV_VKPipelineLayoutInfo& getInfo() const { return *myInfo; }

    const UT_Array<RV_VKShaderModulePtr> &getShaderModules() const
            { return myShaderModules; }

    RV_VKPipelineLayout(
            RV_Instance* inst,
            VkPipelineLayout pipe_layout,
            UT_UniquePtr<RV_VKPipelineLayoutInfo> info,
            UT_Array<RV_VKShaderModulePtr> shader_modules);

    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;
    UT_Array<RV_VKShaderModulePtr> myShaderModules;
};

/// convenience function to fill out a pipeline layout info struct
/// matching the list of passed in shader modules. Returns null if
/// the modules are invalid, or there is an error
RV_API UT_UniquePtr<RV_VKPipelineLayoutInfo> RVfillPipelineLayoutInfo(
        const char* name,
        UT_Array<RV_VKShaderModuleInfoPtr>& shaders);

/// Create a pipeline layout loading a list of compiled SPIR-V files
/// and matching spirv modules. It is up to the caller to ensure that
/// the info struct matches the conde in the shader modules.
/// Failure to do so can result in errors or undefined behavior.
/// Takes ownership of the shader modules
RV_API RV_VKPipelineLayoutPtr RVcreatePipelineLayout(
        RV_Instance* inst,
        UT_UniquePtr<RV_VKPipelineLayoutInfo> info,
        UT_Array<RV_VKShaderModulePtr> shaders);

/// Create a pipeline layout from an RV_VKShader that compiled SPIR-V shaders
RV_API RV_VKPipelineLayoutPtr RVcreatePipelineLayout(
        RV_Instance* inst,
        const char* name,
        RV_VKShader &shader);

/// Create a pipeline layout from a list of SPIR-V VkShaderModules 
RV_API RV_VKPipelineLayoutPtr RVcreatePipelineLayout(
        RV_Instance* inst,
        const char* name,
        UT_Array<RV_VKShaderModuleInfoPtr> shaders);

/// Create a pipeline layout loading a list of compiled SPIR-V files
RV_API RV_VKPipelineLayoutPtr RVcreatePipelineLayout(
        RV_Instance* inst,
        const char* name,
        const UT_StringArray& filenames);

#endif