gpu_capabilities.hpp

Go to the documentation of this file.

#pragma once

 
#include <cstdint>
#include <string_view>
#include <vector>
 
namespace pulp::render {

enum class GpuFormat : std::uint8_t {
    undefined,
    r8_unorm,
    rg8_unorm,
    rgba8_unorm,
    rgba8_unorm_srgb,
    bgra8_unorm,
    bgra8_unorm_srgb,
    rgb10a2_unorm,
    rg11b10_ufloat,
    r16_float,
    rg16_float,
    rgba16_float,
    r32_float,
    rg32_float,
    rgba32_float,
    r32_uint,
    rgba8_uint,
    depth16_unorm,
    depth24_plus,
    depth24_plus_stencil8,
    depth32_float,
};

const std::vector<GpuFormat>& all_gpu_formats();

std::string_view gpu_format_name(GpuFormat format);

std::uint32_t gpu_format_bytes_per_pixel(GpuFormat format);

bool gpu_format_is_depth(GpuFormat format);

struct GpuDeviceFeatures {
    bool rg11b10_ufloat_renderable = false;
    bool float32_filterable = false;
    bool float32_blendable = false;
    bool bgra8_unorm_storage = false;
    bool timestamp_query = false;
    bool shader_f16 = false;
};

struct GpuFormatSupport {
    GpuFormat format = GpuFormat::undefined;
    bool renderable = false;
    bool blendable = false;
    bool multisample = false;
    bool storage = false;
    bool filterable = false;
};

GpuFormatSupport gpu_format_support(GpuFormat format, const GpuDeviceFeatures& features);

enum class GpuAdapterKind : std::uint8_t { unknown, integrated, discrete, cpu };

struct GpuDeviceFacts {
    bool available = false;
    bool null_backend = false;
    GpuAdapterKind adapter = GpuAdapterKind::unknown;
    std::uint32_t max_texture_dimension_2d = 0;
    std::uint32_t max_color_attachments = 0;
    std::uint32_t max_storage_textures_per_shader_stage = 0;
    std::uint32_t max_compute_invocations_per_workgroup = 0;
    std::uint64_t max_buffer_size = 0;
    GpuDeviceFeatures features;
};

struct GpuDeviceCapabilities {
    GpuDeviceFacts facts;
    std::uint32_t max_texture_dimension_1d = 0;
    std::uint32_t max_texture_dimension_3d = 0;
    std::uint32_t max_texture_array_layers = 0;
    std::uint32_t max_bind_groups = 0;
    std::uint32_t max_bindings_per_bind_group = 0;
    std::uint32_t max_sampled_textures_per_shader_stage = 0;
    std::uint32_t max_samplers_per_shader_stage = 0;
    std::uint32_t max_uniform_buffers_per_shader_stage = 0;
    std::uint32_t max_storage_buffers_per_shader_stage = 0;
    std::uint64_t max_uniform_buffer_binding_size = 0;
    std::uint64_t max_storage_buffer_binding_size = 0;
    std::uint32_t max_vertex_buffers = 0;
    std::uint32_t max_vertex_attributes = 0;
    std::uint32_t max_color_attachment_bytes_per_sample = 0;
    std::uint32_t max_compute_workgroup_size_x = 0;
    std::uint32_t max_compute_workgroup_size_y = 0;
    std::uint32_t max_compute_workgroup_size_z = 0;
    std::uint32_t max_compute_workgroups_per_dimension = 0;
    std::uint32_t min_uniform_buffer_offset_alignment = 0;
    std::uint32_t min_storage_buffer_offset_alignment = 0;
    std::vector<GpuFormatSupport> formats;

    GpuFormatSupport support(GpuFormat format) const;
    std::vector<GpuFormat> renderable_color_formats() const;
    std::vector<GpuFormat> storage_formats() const;
    std::vector<std::uint32_t> sample_counts(GpuFormat format) const;
};

void fill_format_table(GpuDeviceCapabilities& caps);

enum class GpuRenderTier : std::uint8_t { none, basic, standard, high };
 
std::string_view gpu_render_tier_name(GpuRenderTier tier);

GpuRenderTier pick_tier(const GpuDeviceFacts& facts);
 
} // namespace pulp::render