gpu_program.h

Go to the documentation of this file.

#pragma once
#include <engine/engine_export.h>
 
#include <engine/assets/asset_handle.h>
 
#include <graphics/program.h>
#include <graphics/shader.h>
#include <math/math.h>
#include <unordered_set>
 
namespace unravel
{
class gpu_program
{
public:
    using ptr = std::shared_ptr<gpu_program>;
    using wptr = std::weak_ptr<gpu_program>;
    using uptr = std::unique_ptr<gpu_program>;
 
    gpu_program() = default;
 
    gpu_program(asset_handle<gfx::shader> compute_shader);
 
    gpu_program(asset_handle<gfx::shader> vertex_shader, asset_handle<gfx::shader> fragment_shader);
 
    auto begin() -> bool;
 
    void end();
 
    void set_texture(std::uint8_t stage,
                     const hpp::string_view& sampler,
                     const gfx::frame_buffer* handle,
                     uint8_t attachment = 0,
                     std::uint32_t flags = std::numeric_limits<std::uint32_t>::max());
 
    void set_texture(std::uint8_t stage,
                     const hpp::string_view& sampler,
                     const gfx::texture* texture,
                     std::uint32_t flags = std::numeric_limits<std::uint32_t>::max());
 
    void set_uniform(const hpp::string_view& name, const void* value, std::uint16_t num = 1);
 
    void set_uniform(const hpp::string_view& name, const math::vec4& value, std::uint16_t num = 1);
 
    void set_uniform(const hpp::string_view& name, const math::vec3& value, std::uint16_t num = 1);
 
    void set_uniform(const hpp::string_view& name, const math::vec2& value, std::uint16_t num = 1);
 
    auto get_uniform(const hpp::string_view& name) -> gfx::program::uniform_ptr;
 
    auto native_handle() const -> gfx::program::handle_type_t;
 
    auto get_shaders() const -> const std::vector<asset_handle<gfx::shader>>&;
 
    auto is_valid() const -> bool;
 
    auto was_repopulated() const -> bool;
 
    void populate();
 
    void attach_shader(asset_handle<gfx::shader> shader);
 
private:
    std::vector<asset_handle<gfx::shader>> shaders_; 
    std::array<gfx::shader::ptr, 2> shaders_cached_{nullptr, nullptr};      
    std::shared_ptr<gfx::program> program_;          
    bool repopulated_ = false;
};
 
struct uniforms_cache
{
    void cache_uniform(gpu_program* program, gfx::program::uniform_ptr& uniform, const hpp::string_view& name, gfx::uniform_type type, uint16_t num = 1)
    {
        program->begin();
        uniform = program->get_uniform(name);
 
        if(uniform == nullptr)
        {
            uniform = std::make_shared<gfx::uniform>(std::string(name), type, num);
        }
        
        program->end();
    }
};
 
} // namespace unravel
 
namespace gfx
{
 
void set_world_transform(const std::vector<math::transform::mat4_t>& matrices);
void set_transform(const std::vector<math::transform::mat4_t>& matrices);
 
void set_world_transform(const std::vector<math::transform>& matrices);
void set_transform(const std::vector<math::transform>& matrices);
 
void set_world_transform(const math::transform::mat4_t& matrix);
void set_transform(const math::transform::mat4_t& matrix);
 
void set_world_transform(const math::transform& matrix);
void set_transform(const math::transform& matrix);
 
void set_texture(const gfx::program::uniform_ptr& uniform,
                 std::uint8_t stage,
                 const gfx::frame_buffer::ptr& handle,
                 uint8_t attachment = 0,
                 std::uint32_t flags = std::numeric_limits<std::uint32_t>::max());
 
void set_texture(const gfx::program::uniform_ptr& uniform,
                 std::uint8_t stage,
                 const gfx::texture::ptr& texture,
                 std::uint32_t flags = std::numeric_limits<std::uint32_t>::max());
 
void set_texture(const gfx::program::uniform_ptr& uniform,
                 std::uint8_t stage,
                 const gfx::frame_buffer* handle,
                 uint8_t attachment = 0,
                 std::uint32_t flags = std::numeric_limits<std::uint32_t>::max());
 
void set_texture(const gfx::program::uniform_ptr& uniform,
                 std::uint8_t stage,
                 const gfx::texture* texture,
                 std::uint32_t flags = std::numeric_limits<std::uint32_t>::max());
 
void set_texture(const gfx::program::uniform_ptr& uniform,
                 std::uint8_t stage,
                 const asset_handle<gfx::texture>& texture,
                 std::uint32_t flags = std::numeric_limits<std::uint32_t>::max());
 
void set_uniform(const gfx::program::uniform_ptr& uniform, const void* value, std::uint16_t num = 1);
 
void set_uniform(const gfx::program::uniform_ptr& uniform, const math::mat4& value, std::uint16_t num = 1);
 
void set_uniform(const gfx::program::uniform_ptr& uniform, const math::vec4& value, std::uint16_t num = 1);
 
void set_uniform(const gfx::program::uniform_ptr& uniform, const math::vec3& value, std::uint16_t num = 1);
 
void set_uniform(const gfx::program::uniform_ptr& uniform, const math::vec2& value, std::uint16_t num = 1);
 
} // namespace gfx