VE_ShaderCompile.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: VE_ShaderCompile.h ( VE Library, C++)
 *
 * COMMENTS:
 */

#ifndef __VE_SHADER_COMPILE_H__
#define __VE_SHADER_COMPILE_H__

#include "VE_API.h"

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

class  UT_WorkBuffer;
struct VE_SpvProgramCompileImpl;
struct VE_SpvStageCompileImpl;
class  VE_ShaderStageCompiler;

// Values of this enum must be in sync with RE_ShaderType!
enum VE_ShaderType
{
    VE_SHADER_VERTEX                            = 0x1,
    VE_SHADER_GEOMETRY                          = 0x2,
    VE_SHADER_FRAGMENT                          = 0x4,
    VE_SHADER_TESSCONTROL                       = 0x8,
    VE_SHADER_TESSEVAL                          = 0x10,

    VE_SHADER_COMPUTE                           = 0x20

    // RE_SHADER_ALL isn't an actual stage, so we don't need a corresponding
    // value here.
};

// ~~ 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 VE_API VE_ShaderProgramCompiler
{
public:
    VE_ShaderProgramCompiler();
    ~VE_ShaderProgramCompiler();

    VE_ShaderProgramCompiler(const VE_ShaderProgramCompiler&) = delete;

    // Must be called in order:
    // add shaders, compile, link, get modules
    bool addShader(UT_UniquePtr<VE_ShaderStageCompiler>&& shr);
    bool compileShaders(UT_WorkBuffer& messages_out);
    bool linkShaders(UT_WorkBuffer& messages_out);
    // T can be uint8_t or uint32_t.
    template <typename T>
    bool getSpvModules(UT_Map<VE_ShaderType, UT_Array<T>>& modules_out,
                       UT_WorkBuffer& messages_out);

    bool isValid() const;

private:
    UT_UniquePtr<VE_SpvProgramCompileImpl>      myImpl;
    friend       VE_SpvProgramCompileImpl;
};

class VE_API VE_ShaderStageCompiler
{
public:
    VE_ShaderStageCompiler(const char* source, const char* name,
                           VE_ShaderType stage, int version = 0);
    ~VE_ShaderStageCompiler();

    bool compile(UT_WorkBuffer& messages_out);

    bool isCompiled();
    bool isValid();

    VE_ShaderType getStageType();
    void getString(UT_WorkBuffer& string);
    const char* getname()
    {
        return myName;
    }

private:
    UT_StringHolder                             myName;
    UT_StringHolder                             mySource;
    VE_ShaderType                               myStage;
    UT_UniquePtr<VE_SpvStageCompileImpl>        myImpl;
    int                                         myVersion;

    friend       VE_SpvStageCompileImpl;
    friend       VE_ShaderProgramCompiler;
};

#endif