ShaderProgram.hpp

Go to the documentation of this file.

#ifndef DONUT_GRAPHICS_SHADER_PROGRAM_HPP
#define DONUT_GRAPHICS_SHADER_PROGRAM_HPP
 
#include <donut/UniqueHandle.hpp>
#include <donut/Variant.hpp>
#include <donut/graphics/Handle.hpp>
#include <donut/graphics/ShaderStage.hpp>
#include <donut/math.hpp>
 
#include <cstdint> // std::int32_t
#include <span>    // std::span
#include <utility> // std::pair
#include <vector>  // std::vector
 
namespace donut::graphics {
 
class Texture;         // Forward declaration, to avoid including Texture.hpp.
class ShaderParameter; // Forward declaration, to avoid a circular include of ShaderParameter.hpp.
 
struct ShaderProgramOptions {
    const char* definitions = nullptr;
 
    const char* vertexShaderSourceCode = nullptr;
 
    const char* fragmentShaderSourceCode = nullptr;
};
 
class ShaderProgram {
public:
    using UniformValue = Variant< //
        float,                    //
        vec2,                     //
        vec3,                     //
        vec4,                     //
        i32,                      //
        i32vec2,                  //
        i32vec3,                  //
        i32vec4,                  //
        u32,                      //
        u32vec2,                  //
        u32vec3,                  //
        u32vec4,                  //
        mat2,                     //
        mat3,                     //
        mat4>;
 
    explicit ShaderProgram(const ShaderProgramOptions& options);
 
    void setUniformFloat(const ShaderParameter& parameter, float value);
 
    void setUniformVec2(const ShaderParameter& parameter, vec2 value);
 
    void setUniformVec3(const ShaderParameter& parameter, vec3 value);
 
    void setUniformVec4(const ShaderParameter& parameter, vec4 value);
 
    void setUniformInt(const ShaderParameter& parameter, i32 value);
 
    void setUniformIVec2(const ShaderParameter& parameter, i32vec2 value);
 
    void setUniformIVec3(const ShaderParameter& parameter, i32vec3 value);
 
    void setUniformIVec4(const ShaderParameter& parameter, i32vec4 value);
 
    void setUniformUint(const ShaderParameter& parameter, u32 value);
 
    void setUniformUVec2(const ShaderParameter& parameter, u32vec2 value);
 
    void setUniformUVec3(const ShaderParameter& parameter, u32vec3 value);
 
    void setUniformUVec4(const ShaderParameter& parameter, u32vec4 value);
 
    void setUniformMat2(const ShaderParameter& parameter, const mat2& value);
 
    void setUniformMat3(const ShaderParameter& parameter, const mat3& value);
 
    void setUniformMat4(const ShaderParameter& parameter, const mat4& value);
 
    void setUniformSampler(const ShaderParameter& parameter, const Texture* texture);
 
    void clearUniformUploadQueue() noexcept {
        uniformUploadQueue.clear();
    }
 
    void clearTextureBindings() noexcept {
        textureBindings.clear();
    }
 
    [[nodiscard]] std::span<const std::pair<std::int32_t, UniformValue>> getUniformUploadQueue() const noexcept {
        return uniformUploadQueue;
    }
 
    [[nodiscard]] std::span<const std::pair<std::int32_t, const Texture*>> getTextureBindings() const noexcept {
        return textureBindings;
    }
 
    [[nodiscard]] Handle get() const noexcept {
        return program.get();
    }
 
private:
    struct ProgramDeleter {
        void operator()(Handle handle) const noexcept;
    };
 
    UniqueHandle<Handle, ProgramDeleter> program{};
    ShaderStage vertexShader;
    ShaderStage fragmentShader;
    std::vector<std::pair<std::int32_t, UniformValue>> uniformUploadQueue{};
    std::vector<std::pair<std::int32_t, const Texture*>> textureBindings{};
};
 
} // namespace donut::graphics
 
#endif