pass.hpp

#ifndef TOPAZ_GPU_PASS_HPP
#define TOPAZ_GPU_PASS_HPP
#include "tz/core/handle.hpp"
#include "tz/core/vector.hpp"
#include "tz/gpu/resource.hpp"
#include "tz/gpu/shader.hpp"
 
namespace tz::gpu
{
    enum class pass_type
    {
        render,
        compute
    };
 
    enum pass_flag
    {
    };
 
    constexpr pass_flag operator|(pass_flag lhs, pass_flag rhs)
    {
        return static_cast<pass_flag>(static_cast<int>(lhs) | static_cast<int>(rhs));
    }
 
    constexpr bool operator&(pass_flag lhs, pass_flag& rhs)
    {
        return static_cast<int>(lhs) & static_cast<int>(rhs);
    }
 
    enum graphics_flag
    {
        dont_clear = 0b0001,
        no_depth_test = 0b0010,
        no_depth_write = 0b0100,
 
    };
 
    constexpr graphics_flag operator|(graphics_flag lhs, graphics_flag rhs)
    {
        return static_cast<graphics_flag>(static_cast<int>(lhs) | static_cast<int>(rhs));
    }
 
    constexpr bool operator&(graphics_flag lhs, graphics_flag& rhs)
    {
        return static_cast<int>(lhs) & static_cast<int>(rhs);
    }
 
    enum class cull
    {
        both,
        front,
        back,
        none
    };
 
    struct pass_graphics_state
    {
        tz::v4f clear_colour = {0.0f, 0.0f, 0.0f, 1.0f};
        tz::v4u scissor = tz::v4u::filled(-1);
        std::span<const resource_handle> colour_targets = {};
        resource_handle depth_target = tz::nullhand;
        resource_handle index_buffer = tz::nullhand;
        resource_handle draw_buffer = tz::nullhand;
        cull culling = cull::back;
        graphics_flag flags = static_cast<graphics_flag>(0);
        std::size_t triangle_count = 0;
    };
 
    struct pass_compute_state
    {
        tz::v3u kernel = tz::v3u::zero();
    };
 
    struct pass_info
    {
        pass_graphics_state graphics = {};
        pass_compute_state compute = {};
        shader_handle shader = tz::nullhand;
        std::span<const resource_handle> resources = {};
        pass_flag flags = static_cast<pass_flag>(0);
        const char* name = "<untitled pass>";
    };
 
    using pass_handle = tz::handle<pass_info>;
 
    constexpr auto present_pass = static_cast<tz::hanval>(std::numeric_limits<std::underlying_type_t<tz::hanval>>::max() - 1);
 
    std::expected<pass_handle, tz::error_code> create_pass(pass_info);
 
    void pass_set_triangle_count(pass_handle graphics_pass, std::size_t triangle_count);
 
    void pass_set_kernel(pass_handle compute_pass, tz::v3u kernel);
 
    void pass_set_scissor(pass_handle graphics_pass, tz::v4u scissor);
 
    tz::error_code pass_add_image_resource(pass_handle pass, resource_handle res);
 
    void destroy_pass(pass_handle);
}
 
#endif // TOPAZ_GPU_PASS_HPP