resource.hpp

#ifndef TOPAZ_GPU_RESOURCE_HPP
#define TOPAZ_GPU_RESOURCE_HPP
#include "tz/core/error.hpp"
#include "tz/core/handle.hpp"
#include <span>
#include <expected>
 
namespace tz::gpu
{
    enum buffer_flag
    {
        index = 0b0001,
        draw = 0b0010,
        dynamic_access = 0b0100,
    };
 
    constexpr buffer_flag operator|(buffer_flag lhs, buffer_flag rhs)
    {
        return static_cast<buffer_flag>(static_cast<int>(lhs) | static_cast<int>(rhs));
    }
 
    constexpr bool operator&(buffer_flag lhs, buffer_flag& rhs)
    {
        return static_cast<int>(lhs) & static_cast<int>(rhs);
    }
 
    struct buffer_info
    {
        std::span<const std::byte> data;
        const char* name = "<untitled buffer resource>";
        buffer_flag flags = static_cast<buffer_flag>(0);
    };
 
    enum class image_type
    {
        rgba,
        depth,
        floats,
    };
 
    enum image_flag
    {
        colour_target = 0b0001,
        depth_target = 0b0010,
        resize_to_match_window_resource = 0b0100,
    };
 
    constexpr image_flag operator|(image_flag lhs, image_flag rhs)
    {
        return static_cast<image_flag>(static_cast<int>(lhs) | static_cast<int>(rhs));
    }
 
    constexpr bool operator&(image_flag lhs, image_flag& rhs)
    {
        return static_cast<int>(lhs) & static_cast<int>(rhs);
    }
 
    struct image_info
    {
        unsigned int width;
        unsigned int height;
        image_type type;
        std::span<const std::byte> data;
        const char* name = "<untitled image resource>";
        image_flag flags = static_cast<image_flag>(0);
    };
 
    using resource_handle = tz::handle<buffer_info>;
    constexpr auto window_resource = static_cast<tz::hanval>(std::numeric_limits<std::underlying_type_t<tz::hanval>>::max() - 1);
 
    std::expected<resource_handle, tz::error_code> create_buffer(buffer_info);
    std::expected<resource_handle, tz::error_code> create_image(image_info);
 
    tz::error_code destroy_resource(resource_handle res);
 
    using index_t = std::uint32_t;
    struct draw_t
    {
        std::uint32_t vertex_count = 0;
        std::uint32_t instance_count = 1;
        std::uint32_t first_vertex = 0;
        std::uint32_t first_instance = 0;
    };
    struct draw_indexed_t
    {
        std::uint32_t index_count = 0;
        std::uint32_t instance_count = 1;
        std::uint32_t first_index = 0;
        std::int32_t vertex_offset = 0;
        std::uint32_t first_instance = 0;
    };
 
    tz::error_code resource_write(resource_handle res, std::span<const std::byte> new_data, std::size_t offset = 0);
    std::size_t resource_size(resource_handle res);
    unsigned int image_get_width(resource_handle res);
    unsigned int image_get_height(resource_handle res);
    std::span<const std::byte> resource_read(resource_handle res);
    void buffer_resize(resource_handle bufh, std::size_t new_size_bytes);
    void image_resize(resource_handle imgh, unsigned int new_width, unsigned int new_height);
    tz::error_code index_buffer_write(resource_handle index_buffer, std::span<const index_t> indices);
    tz::error_code draw_buffer_write(resource_handle draw_buffer, std::uint32_t count, std::span<const draw_t> draws);
    tz::error_code draw_buffer_indexed_write(resource_handle draw_buffer, std::uint32_t count, std::span<const draw_indexed_t> draws);
}
 
#endif // TOPAZ_GPU_RESOURCE_HPP