instance.h

Go to the documentation of this file.

#ifndef NNGN_GRAPHICS_VULKAN_INSTANCE_H
#define NNGN_GRAPHICS_VULKAN_INSTANCE_H
 
#include <cstdint>
#include <ranges>
#include <span>
#include <string_view>
#include <type_traits>
#include <vector>
 
#include "graphics/graphics.h"
 
#include "types.h"
#include "vulkan.h"
 
namespace nngn {
 
class Instance {
public:
    using ErrorFn = void(void*);
    NNGN_MOVE_ONLY(Instance)
    Instance(void) = default;
    ~Instance(void);
    bool init(
        Graphics::Version version,
        std::span<const char *const> extensions);
    bool init_debug(
        Graphics::Version version,
        std::span<const char *const> extensions,
        std::span<const char *const> layers,
        ErrorFn error_fn, void *error_data, Graphics::LogLevel log_level);
    VkInstance id() const { return this->h; }
    void set_error() { if(this->error_fn) this->error_fn(this->error_data); }
    template<typename R> R get_proc_addr(const char *name) const;
    template<typename T>
    bool set_obj_name(VkDevice dev, T obj, std::string_view name) const;
    template<typename T>
    bool set_obj_name(
        VkDevice d, T obj, std::string_view name, std::size_t n,
        std::string *buf) const;
    template<typename T>
    bool set_obj_name(
        VkDevice d, std::span<T> v, std::string_view name) const;
    template<typename T>
    bool set_obj_name(
        VkDevice d, T obj, std::string_view name, std::size_t n) const;
private:
    template<typename T> static auto obj_handle(T o);
    bool set_obj_name(
        VkDevice d, VkObjectType t,
        std::uint64_t obj, std::string_view name) const;
    bool set_obj_name(
        VkDevice d, VkObjectType t,
        std::uint64_t obj, std::string_view name, std::size_t n,
        std::string *buf) const;
    VkInstance h = {};
    VkDebugUtilsMessengerEXT messenger = {};
    PFN_vkSetDebugUtilsObjectNameEXT set_obj_name_f = {};
    ErrorFn *error_fn = {};
    void *error_data = {};
};
 
struct InstanceInfo {
public:
    std::uint32_t version = {};
    std::vector<Graphics::Extension> extensions = {};
    std::vector<Graphics::Layer> layers = {};
    std::vector<VkPhysicalDevice> physical_devs = {};
    bool init();
    void init_devices(VkInstance i);
    bool check_version(Graphics::Version v) const;
private:
    void init_extensions();
    void init_layers();
};
 
template<typename T> auto Instance::obj_handle(T obj) {
    if constexpr(std::is_base_of_v<Handle, T>)
        return obj.id;
    else
        return reinterpret_cast<std::uintptr_t>(obj);
}
 
template<typename T>
inline bool Instance::set_obj_name(
    VkDevice d, T obj, std::string_view name
) const {
    return this->set_obj_name(
        d, vk_obj_type<T>, Instance::obj_handle(obj), name);
}
 
template<typename T>
inline bool Instance::set_obj_name(
    VkDevice d, T obj, std::string_view name, std::size_t n
) const {
    return this->set_obj_name(
        d, vk_obj_type<T>, Instance::obj_handle(obj), name, n);
}
 
template<typename T>
inline bool Instance::set_obj_name(
    VkDevice d, T obj, std::string_view name, std::size_t n,
    std::string *buf
) const {
    return this->set_obj_name(
        d, vk_obj_type<T>, Instance::obj_handle(obj), name, n, buf);
}
 
template<typename T>
inline bool Instance::set_obj_name(
    VkDevice d, std::span<T> v, std::string_view name
) const {
    std::string buf = {};
    constexpr auto t = vk_obj_type<std::decay_t<T>>;
    for(std::size_t i = 0, n = v.size(); i < n; ++i)
        if(!this->set_obj_name(d, t, Instance::obj_handle(v[i]), name, i, &buf))
            return false;
    return true;
}
 
}
 
#endif