RV_VKShaderCompile.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_VKShaderCompile.h ( RV Library, C++)
 *
 * COMMENTS:
 *        Helper for compiling glsl code into Vulkan SPIR-V
 */

#ifndef RV_VKShaderCompile_h
#define RV_VKShaderCompile_h

#include "RV_API.h"

#include <UT/UT_Array.h>
#include <UT/UT_NonCopyable.h>
#include <UT/UT_UniquePtr.h>

#include <RE/RE_UniformBlock.h>
#include <RE/RE_Shader.h>

#include <VE/VE_ShaderCompile.h>

#include "RV_Type.h"

struct RV_SpvProgramCompileImpl;
struct RV_SpvStageCompileImpl;
class RV_ShaderInput;
class RV_VKShaderModule;
class RV_VKShaderStageCompiler;
class RV_VKDescriptorSetInfo;
class UT_StringRef;

enum RV_DefaultAttributeLoc
{
    RV_LOC_UNDEF                = -2,
    RV_LOC_NONE                 = -1,

    RV_LOC_P                    = 0,
    RV_LOC_CD                   = 1,
    RV_LOC_ALPHA                = 2,
    RV_LOC_N                    = 3,
    RV_LOC_CE                   = RV_LOC_N,
    RV_LOC_INSTANCE_INDEX       = 4,
    RV_LOC_POINT_INDEX          = 5,
    RV_LOC_UV                   = 6,
    RV_LOC_PSCALE               = 7,
    RV_LOC_WIDTH                = RV_LOC_PSCALE,
    RV_LOC_POINT_SELECTION      = 8,
    RV_LOC_POINT_ID             = 9,

    RV_LOC_TAN                  = 10,
    RV_LOC_PRIM_SELECTION       = 11,
    RV_LOC_VERT_SELECTION       = 12,

    RV_LOC_FIRST_CUSTOM
};

// Helper functions for default-attribute-mapping
RV_API bool RVisDefaultAttrib(const RV_ShaderInput &input);
RV_API int  RVgetDefaultAttribLocation(const UT_StringRef&);
RV_API bool RVgetDefaultAttribFormat( int loc,
                                      RV_GPUType *out_type,
                                      int *out_vec_size);
// Helper functions to convert between VE and RE enums for shader type.
RV_API RE_ShaderType RVshaderTypeFromVE(VE_ShaderType type);
RV_API VE_ShaderType RVshaderTypeToVE(RE_ShaderType type);

// ~~ Overview
// takes a collection of GLSL shader files
// compiles them into SPIR-V modules
// optionally does linkage checks as well

// ~~ Shader Compiler Ownership
// Implemented using glslang library
// glslang interface has the quirks that:
//      - shaders cannot be detatched from a program
//      - shaders cannot be used in multiple programs
//      - shaders must be destroyed after program
// so, the program compiler takes ownership of any shaders
// added to it

class RV_API RV_VKShaderProgramCompiler : public VE_ShaderProgramCompiler
{
public:
    RV_VKShaderProgramCompiler() : VE_ShaderProgramCompiler()
    {}
    ~RV_VKShaderProgramCompiler()
    {}

    bool getSpvModules(UT_Map<RE_ShaderType, UT_Array<uint8_t>> &modules_out, 
                       UT_WorkBuffer &messages_out);
};

// Class for a single vulkan glsl shader
class RV_API RV_VKShaderStageCompiler : public VE_ShaderStageCompiler
{
public:
    RV_VKShaderStageCompiler(const char *source,
                             const char *name,
                             RE_ShaderType stage,
                             int version = 0)
        : VE_ShaderStageCompiler(source, name, RVshaderTypeToVE(stage),
                                 version) 
    {} 
    ~RV_VKShaderStageCompiler()
    {}

    RE_ShaderType getStage()
    {
        return RVshaderTypeFromVE(getStageType());
    }
};


// Implementation of Shader Compiler 
// Inherits from RE_Shader, to use functions for shader file,
// loading, prog file loading, etc.
// Can be passed GLSL shaders and compile them into SPIR-V

// The compiler class has the requirements that
//      it takes ownership of the shader objects
//      and that objects cannot be detatched
//      So we must make new shaderCompiler + 
//      programCompilers as needed

class RV_API RV_VKShader : public RE_Shader
{
public:
    RV_VKShader(const char* name, int shader_version = 460);
    ~RV_VKShader() override;

    int64 getMemoryUsage(bool inclusive) const override
    {
        
        return 0;
    }

    bool getSpvModules(UT_Map<RE_ShaderType, UT_Array<uint8_t>> &modules_out, 
                        UT_WorkBuffer &messages_out)
    {
        if (!myProgram)
        {
            return false;
        }

        return myProgram->getSpvModules(modules_out, messages_out);
    }

    class Factory : public RE_Shader::Factory
    {
    public:
        RE_Shader* newShader(const char *name, int shader_version, RE_ShaderLanguage lang) override
        {
            UT_ASSERT(lang == RE_SHADER_LANGUAGE_VULKAN ||
                      lang == RE_SHADER_LANGUAGE_VULKAN_COMPUTE);
            return new RV_VKShader(name, shader_version);
        }
        ~Factory() override {}
    };

    // basic Shader handling
    bool attachShader(RE_Render *r,
                        RE_ShaderStage *shader,
                        UT_String *messages = nullptr) override;
    bool detachShader(RE_Render *r, RE_ShaderStage *shader) override;
    bool linkShaders(RE_Render *r, UT_String *messages_out = nullptr) override;

    
    void clearShaders(RE_Render *r,  RE_ShaderType stype = RE_SHADER_ALL) override;
    RE_ShaderStage *newShader(RE_ShaderType stage, const char* name=0) override;

    bool validateShader(RE_Render *r, UT_String *messages = nullptr) override
    {
        if (!myProgram)
        {
            return false;
        }

        return myProgram->isValid();
    }


    // pre-linking settings
    bool setGeometryParms(RE_Render *r,
                          int max_vertices,
                          RE_PrimType input,
                          RE_PrimType output) override
    { return false;}
    
    bool setVertexInput(RE_Render *r,
                        const char *name,
                        int vertex_index) override
    { return false;}
    
    bool setFragmentOutput(RE_Render *r,
                           const char *name,
                           int buffer_num) override
    { return false;}

    // variable binidng
    bool bindTextureMap(RE_Render *r,
                        const UT_StringHolder &name,
                        const char *mapname,
                        const char *relative_to) override
    { return false; }

    RE_TextureDimension getTextureMapType(RE_Render *r,
                                          const UT_StringHolder &name) override
    { return RE_TEXTURE_NONE; }

        bool bindVariableInt(RE_Render *r,
                         const UT_StringHolder &name, const int *val,
                         int array_size=1, int *saved_idx = nullptr) override
    { return false;}
    bool bindVariableInt2(RE_Render *r,
                          const UT_StringHolder &name, const int *val,
                          int array_size=1, int *saved_idx = nullptr) override
    { return false;}
    bool bindVariableInt3(RE_Render *r,
                          const UT_StringHolder &name, const int *val,
                          int array_size=1, int *saved_idx = nullptr) override
    { return false;}
    bool bindVariableInt4(RE_Render *r,
                          const UT_StringHolder &name, const int *val,
                          int array_size=1, int *saved_idx = nullptr) override
    { return false;}
    bool bindUint64(RE_Render *r,
                    const UT_StringHolder &name, uint64 *val,
                    int array_size = 1, int *saved_idx = nullptr) override
    { return false;}
    bool bindVariable1(RE_Render *r,
                       const UT_StringHolder &name, const fpreal32 *val,
                       int array_size=1, int *saved_idx = nullptr) override
    { return false;}
    bool bindVariable2(RE_Render *r,
                       const UT_StringHolder &name, const fpreal32 *val,
                       int array_size=1, int *saved_idx = nullptr) override
    { return false;}
    bool bindVariable3(RE_Render *r,
                       const UT_StringHolder &name, const fpreal32 *val,
                       int array_size=1, int *saved_idx = nullptr) override
    { return false;}
    bool bindVariable4(RE_Render *r,
                       const UT_StringHolder &name, const fpreal32 *val,
                       int array_size=1, int *saved_idx = nullptr) override
    { return false;}
    bool bindVariable1(RE_Render *r,
                       const UT_StringHolder &name, const fpreal64 *val,
                       int array_size=1, int *saved_idx = nullptr) override
    { return false;}
    bool bindVariable2(RE_Render *r,
                       const UT_StringHolder &name, const fpreal64 *val,
                       int array_size=1, int *saved_idx = nullptr) override
    { return false;}
    bool bindVariable3(RE_Render *r,
                       const UT_StringHolder &name, const fpreal64 *val,
                       int array_size=1, int *saved_idx = nullptr) override
    { return false;}
    bool bindVariable4(RE_Render *r,
                       const UT_StringHolder &name, const fpreal64 *val,
                       int array_size=1, int *saved_idx = nullptr) override
    { return false;}

    bool bindMatrix2(RE_Render *r,
                     const UT_StringHolder &name, const fpreal32 *val,
                     int array_size=1, int *saved_idx = nullptr) override
    { return false;}
    bool bindMatrix3(RE_Render *r,
                     const UT_StringHolder &name, const fpreal32 *val,
                     int array_size=1, int *saved_idx = nullptr) override
    { return false;}
    bool bindMatrix4(RE_Render *r,
                     const UT_StringHolder &name, const fpreal32 *val,
                     int array_size=1, int *saved_idx = nullptr) override
    { return false;}
    bool bindMatrix2(RE_Render *r,
                     const UT_StringHolder &name, const fpreal64 *val,
                     int array_size=1, int *saved_idx = nullptr) override
    { return false;}
    bool bindMatrix3(RE_Render *r,
                     const UT_StringHolder &name, const fpreal64 *val,
                     int array_size=1, int *saved_idx = nullptr) override
    { return false;}
    bool bindMatrix4(RE_Render *r,
                     const UT_StringHolder &name, const fpreal64 *val,
                     int array_size=1, int *saved_idx = nullptr) override
    { return false;}
    bool bindTexture(RE_Render *r,
                     const UT_StringHolder &name,
                     RE_Texture *tex,
                     int *saved_idx = nullptr) override
    { return false;}
    bool bindImage(RE_Render *r,
                   const UT_StringHolder &name,
                   RE_Texture *image,
                   RE_BufferAccess image_access) override
    { return false;}
    bool bindImageLayer(RE_Render *r,
                        const UT_StringHolder &name,
                        RE_Texture *image,
                        RE_BufferAccess image_access,
                        int layer) override
    { return false;}
    void printUniforms(RE_Render *r,
                     std::ostream *os = nullptr) const override
    { }
    void         loadShaderTexMaps(RE_Render *r) override {}
    void         loadBoundTextures(RE_Render *r) override {}
    void         unloadBoundTextures(RE_Render *r) override {}

    // This should set the shader as current.
    void         applyShader(RE_Render *r, bool update_re = true) override {}
    // This should do a cleanup and unset any current shader.
    void         removeShader(RE_Render *r, bool update_re = true) override {}
    // This should cleanup after the shader, but leave it set as current.
    void         cleanup(RE_Render *r) override {}

    re_LibFunc* getShaderLibrary() const override;

    const char* getPlatformDefines(RE_Render* r) const override;

private:
    void createInternalProgram();
    UT_UniquePtr<RV_VKShaderProgramCompiler> myProgram;
};

// RV_VKShaderStage
// A glsl shader stage to be compiled by RV_VKShader
//  internally holds an RV_VKShaderStageCompiler
//  created when the source is set.
//
// The RV_VKShaderProgramCompiler takes ownership
// of the stage when it's added, so we have 
// functions to recreate it, as needed

class RV_VKShaderStage : public RE_ShaderStage
{
public:
    RV_VKShaderStage(RE_ShaderType stage, const char *name = nullptr);

    ~RV_VKShaderStage() override;

    bool setSource(RE_Render *r,
                   const char *source_code,
                   int version,
                   UT_String *messages = nullptr,
                   bool dump_source_on_error = true) override;
    bool getSource(RE_Render *r, UT_String &source) override
    {
        if (!mySource.isstring())
        {
            return false;
        }

        source = mySource;
        return true;
    }

    // return valid if we have valid shader code
    bool isValid() const
    {
        if (myStageCompiler)
        {
            return myStageCompiler->isValid();
        }
        else if (mySource.isstring())
        {
            // Source is only stored if compilation succeeds
            // so having source means we are valid
            // but must regen impl before use
            return mySource;
        }
        return false;
    }
private:
     // recreate the compiler impl object, with the same
     // source, stage, and settings
    void resetImpl();

    UT_StringHolder mySource;
    UT_UniquePtr<RV_VKShaderStageCompiler> myStageCompiler;

    friend class RV_VKShader;
};

#include <RE/RE_ShaderHandle.h>
#include <RE/RE_ShaderAtlas.h>

// --------------------
// RV_ShaderHandle
//
// Shader handle used to compile a GLSL shader or Houdini Prog file
//  into SPIR-V. Does not handle compiling SPIR-V into a Vulkan pipeline
class RV_API RV_ShaderHandle : public RE_ShaderHandle
{
public:
    RV_ShaderHandle(const char *program_file, bool reg_sh, const char *defines)
        : RE_ShaderHandle(program_file, reg_sh, defines,
                          RE_SHADER_LANGUAGE_VULKAN)
    {}
    ~RV_ShaderHandle() override;

    UT_NON_COPYABLE(RV_ShaderHandle)

    // Get what the filename for compiled spv stage should be
    // NOTE: this should only be used for individually loaded Shaders,
    //       shaders loaded through an Atlas should use 
    //       `RV_ShaderAtlas::getSpirvPath()` instead
    UT_StringHolder getSpirvPath(RE_ShaderType stage = RE_SHADER_ALL);

private:
    UT_UniquePtr<RE_Shader> compileImpl(RE_Render *r, 
                                        UT_String *errors) 
                                        const override;

};

// --------------------
// RV_ShaderAtlas
//
// Shader handle used to compile a Houdini Shader Atlas into SPIR-V
// modules. Does not handle compiling SPIR-V into Vulkan pipelines
class RV_API RV_ShaderAtlas : public RE_ShaderAtlas
{
public:
    RV_ShaderAtlas(const UT_StringRef &shader_atlas_file)
    : RE_ShaderAtlas(shader_atlas_file)
    {
    }
    ~RV_ShaderAtlas() override
    {}

    // Get what the filename for compiled spv stage should be
    UT_StringHolder getSpirvPath(exint shbits, RE_ShaderType stage);
    UT_StringHolder getCompiledPath();

    struct CompiledAtlas
    {
        // All shader keys, separated into lists of which
        // ones have identical pipeline layouts
        UT_Array<UT_Array<exint>> SharedLayouts;

        // Map of shader module binaries, for each program
        UT_Map<exint,UT_Map<RE_ShaderType, UT_Array<uint8_t>>> Programs;
    };

    // Read and write to compiled atlas files
    static void writeCompiled(const UT_StringRef &filename,
                              RV_ShaderAtlas &atlas);

    static bool readCompiled(const UT_StringRef &filename,
                             CompiledAtlas &out);

protected:
    RE_ShaderHandlePtr
    createShaderImpl(const char* program, const char* defines) override;
};
#endif