1050 lines
34 KiB
C++
1050 lines
34 KiB
C++
#include "renderer_api/renderer_api.h"
|
|
|
|
#include <cmath>
|
|
#include <limits>
|
|
|
|
namespace pp::renderer {
|
|
|
|
namespace {
|
|
|
|
[[nodiscard]] bool is_empty_c_string(const char* text) noexcept
|
|
{
|
|
return text == nullptr || text[0] == '\0';
|
|
}
|
|
|
|
[[nodiscard]] std::size_t bounded_c_string_length(const char* text, std::size_t limit) noexcept
|
|
{
|
|
if (text == nullptr) {
|
|
return 0;
|
|
}
|
|
|
|
std::size_t length = 0;
|
|
while (length <= limit && text[length] != '\0') {
|
|
++length;
|
|
}
|
|
|
|
return length;
|
|
}
|
|
|
|
[[nodiscard]] pp::foundation::Status validate_shader_stage_source(
|
|
ShaderStageSource source,
|
|
const char* stage_name) noexcept
|
|
{
|
|
if (is_empty_c_string(source.entry_point)) {
|
|
return pp::foundation::Status::invalid_argument(stage_name);
|
|
}
|
|
|
|
if (source.source == nullptr || source.source_size == 0U) {
|
|
return pp::foundation::Status::invalid_argument("shader source must not be empty");
|
|
}
|
|
|
|
if (source.source_size > max_shader_source_bytes) {
|
|
return pp::foundation::Status::out_of_range("shader source exceeds the configured limit");
|
|
}
|
|
|
|
return pp::foundation::Status::success();
|
|
}
|
|
|
|
[[nodiscard]] Extent2D mip_level_extent(Extent2D extent, std::uint32_t level) noexcept
|
|
{
|
|
auto width = extent.width;
|
|
auto height = extent.height;
|
|
for (std::uint32_t index = 0; index < level; ++index) {
|
|
width = width > 1U ? width / 2U : 1U;
|
|
height = height > 1U ? height / 2U : 1U;
|
|
}
|
|
|
|
return Extent2D { .width = width, .height = height };
|
|
}
|
|
|
|
}
|
|
|
|
std::uint32_t bytes_per_pixel(TextureFormat format) noexcept
|
|
{
|
|
switch (format) {
|
|
case TextureFormat::rgba8:
|
|
return 4;
|
|
case TextureFormat::r8:
|
|
return 1;
|
|
case TextureFormat::depth24_stencil8:
|
|
return 4;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
std::uint32_t max_mip_levels_for_extent(Extent2D extent) noexcept
|
|
{
|
|
if (extent.width == 0U || extent.height == 0U) {
|
|
return 0;
|
|
}
|
|
|
|
auto dimension = extent.width > extent.height ? extent.width : extent.height;
|
|
std::uint32_t levels = 1;
|
|
while (dimension > 1U && levels < max_texture_mip_levels) {
|
|
dimension /= 2U;
|
|
++levels;
|
|
}
|
|
|
|
return levels;
|
|
}
|
|
|
|
bool has_texture_usage(TextureUsage usage, TextureUsage required) noexcept
|
|
{
|
|
const auto usage_bits = static_cast<std::uint32_t>(usage);
|
|
const auto required_bits = static_cast<std::uint32_t>(required);
|
|
return required_bits != 0U && (usage_bits & required_bits) == required_bits;
|
|
}
|
|
|
|
pp::foundation::Status validate_extent(Extent2D extent) noexcept
|
|
{
|
|
if (extent.width == 0 || extent.height == 0) {
|
|
return pp::foundation::Status::invalid_argument("texture extent must be greater than zero");
|
|
}
|
|
|
|
if (extent.width > max_texture_dimension || extent.height > max_texture_dimension) {
|
|
return pp::foundation::Status::out_of_range("texture extent exceeds the configured limit");
|
|
}
|
|
|
|
return pp::foundation::Status::success();
|
|
}
|
|
|
|
pp::foundation::Status validate_texture_usage(TextureUsage usage) noexcept
|
|
{
|
|
constexpr auto allowed_usage = TextureUsage::sampled
|
|
| TextureUsage::render_target
|
|
| TextureUsage::upload_destination
|
|
| TextureUsage::readback_source
|
|
| TextureUsage::copy_source
|
|
| TextureUsage::copy_destination;
|
|
|
|
const auto usage_bits = static_cast<std::uint32_t>(usage);
|
|
const auto allowed_bits = static_cast<std::uint32_t>(allowed_usage);
|
|
if (usage_bits == 0U) {
|
|
return pp::foundation::Status::invalid_argument("texture usage must not be empty");
|
|
}
|
|
|
|
if ((usage_bits & ~allowed_bits) != 0U) {
|
|
return pp::foundation::Status::invalid_argument("texture usage contains unsupported flags");
|
|
}
|
|
|
|
return pp::foundation::Status::success();
|
|
}
|
|
|
|
pp::foundation::Status validate_resource_label(const char* label) noexcept
|
|
{
|
|
if (label == nullptr) {
|
|
return pp::foundation::Status::invalid_argument("resource label must not be null");
|
|
}
|
|
|
|
if (bounded_c_string_length(label, max_resource_label_bytes) > max_resource_label_bytes) {
|
|
return pp::foundation::Status::out_of_range("resource label exceeds the configured limit");
|
|
}
|
|
|
|
return pp::foundation::Status::success();
|
|
}
|
|
|
|
pp::foundation::Status validate_texture_desc(TextureDesc desc) noexcept
|
|
{
|
|
const auto extent_status = validate_extent(desc.extent);
|
|
if (!extent_status.ok()) {
|
|
return extent_status;
|
|
}
|
|
|
|
if (bytes_per_pixel(desc.format) == 0U) {
|
|
return pp::foundation::Status::invalid_argument("texture format is not supported");
|
|
}
|
|
|
|
if (desc.mip_levels == 0U) {
|
|
return pp::foundation::Status::invalid_argument("texture mip level count must be greater than zero");
|
|
}
|
|
|
|
if (desc.mip_levels > max_mip_levels_for_extent(desc.extent)) {
|
|
return pp::foundation::Status::out_of_range("texture mip level count exceeds the texture extent");
|
|
}
|
|
|
|
const auto usage_status = validate_texture_usage(desc.usage);
|
|
if (!usage_status.ok()) {
|
|
return usage_status;
|
|
}
|
|
|
|
return validate_resource_label(desc.debug_name);
|
|
}
|
|
|
|
pp::foundation::Result<std::uint64_t> texture_byte_size(TextureDesc desc) noexcept
|
|
{
|
|
const auto desc_status = validate_texture_desc(desc);
|
|
if (!desc_status.ok()) {
|
|
return pp::foundation::Result<std::uint64_t>::failure(desc_status);
|
|
}
|
|
|
|
const auto bpp = static_cast<std::uint64_t>(bytes_per_pixel(desc.format));
|
|
std::uint64_t bytes = 0;
|
|
for (std::uint32_t level = 0; level < desc.mip_levels; ++level) {
|
|
const auto level_extent = mip_level_extent(desc.extent, level);
|
|
const auto width = static_cast<std::uint64_t>(level_extent.width);
|
|
const auto height = static_cast<std::uint64_t>(level_extent.height);
|
|
if (width > std::numeric_limits<std::uint64_t>::max() / height) {
|
|
return pp::foundation::Result<std::uint64_t>::failure(
|
|
pp::foundation::Status::out_of_range("texture size overflows uint64"));
|
|
}
|
|
|
|
const auto pixels = width * height;
|
|
if (pixels > std::numeric_limits<std::uint64_t>::max() / bpp) {
|
|
return pp::foundation::Result<std::uint64_t>::failure(
|
|
pp::foundation::Status::out_of_range("texture byte size overflows uint64"));
|
|
}
|
|
|
|
const auto level_bytes = pixels * bpp;
|
|
if (bytes > std::numeric_limits<std::uint64_t>::max() - level_bytes) {
|
|
return pp::foundation::Result<std::uint64_t>::failure(
|
|
pp::foundation::Status::out_of_range("texture byte size overflows uint64"));
|
|
}
|
|
bytes += level_bytes;
|
|
}
|
|
|
|
if (bytes > max_texture_bytes) {
|
|
return pp::foundation::Result<std::uint64_t>::failure(
|
|
pp::foundation::Status::out_of_range("texture byte size exceeds the configured limit"));
|
|
}
|
|
|
|
return pp::foundation::Result<std::uint64_t>::success(bytes);
|
|
}
|
|
|
|
pp::foundation::Status validate_viewport(Viewport viewport, Extent2D target_extent) noexcept
|
|
{
|
|
const auto extent_status = validate_extent(target_extent);
|
|
if (!extent_status.ok()) {
|
|
return extent_status;
|
|
}
|
|
|
|
if (viewport.x < 0 || viewport.y < 0) {
|
|
return pp::foundation::Status::invalid_argument("viewport origin must be non-negative");
|
|
}
|
|
|
|
if (viewport.width == 0 || viewport.height == 0) {
|
|
return pp::foundation::Status::invalid_argument("viewport size must be greater than zero");
|
|
}
|
|
|
|
if (!std::isfinite(viewport.min_depth) || !std::isfinite(viewport.max_depth)) {
|
|
return pp::foundation::Status::invalid_argument("viewport depth range must be finite");
|
|
}
|
|
|
|
if (viewport.min_depth < 0.0F || viewport.max_depth > 1.0F || viewport.min_depth > viewport.max_depth) {
|
|
return pp::foundation::Status::out_of_range("viewport depth range must be within 0..1 and ordered");
|
|
}
|
|
|
|
const auto x = static_cast<std::uint32_t>(viewport.x);
|
|
const auto y = static_cast<std::uint32_t>(viewport.y);
|
|
if (x > target_extent.width || y > target_extent.height) {
|
|
return pp::foundation::Status::out_of_range("viewport origin is outside the render target");
|
|
}
|
|
|
|
if (viewport.width > target_extent.width - x || viewport.height > target_extent.height - y) {
|
|
return pp::foundation::Status::out_of_range("viewport exceeds render target bounds");
|
|
}
|
|
|
|
return pp::foundation::Status::success();
|
|
}
|
|
|
|
pp::foundation::Status validate_scissor(ScissorRect scissor, Extent2D target_extent) noexcept
|
|
{
|
|
const auto extent_status = validate_extent(target_extent);
|
|
if (!extent_status.ok()) {
|
|
return extent_status;
|
|
}
|
|
|
|
if (!scissor.enabled) {
|
|
return pp::foundation::Status::success();
|
|
}
|
|
|
|
if (scissor.x < 0 || scissor.y < 0) {
|
|
return pp::foundation::Status::invalid_argument("scissor origin must be non-negative");
|
|
}
|
|
|
|
if (scissor.width == 0 || scissor.height == 0) {
|
|
return pp::foundation::Status::invalid_argument("scissor size must be greater than zero");
|
|
}
|
|
|
|
const auto x = static_cast<std::uint32_t>(scissor.x);
|
|
const auto y = static_cast<std::uint32_t>(scissor.y);
|
|
if (x > target_extent.width || y > target_extent.height) {
|
|
return pp::foundation::Status::out_of_range("scissor origin is outside the render target");
|
|
}
|
|
|
|
if (scissor.width > target_extent.width - x || scissor.height > target_extent.height - y) {
|
|
return pp::foundation::Status::out_of_range("scissor exceeds render target bounds");
|
|
}
|
|
|
|
return pp::foundation::Status::success();
|
|
}
|
|
|
|
pp::foundation::Status validate_render_pass_desc(RenderPassDesc desc) noexcept
|
|
{
|
|
if (desc.clear_color_enabled
|
|
&& (!std::isfinite(desc.clear_color.r)
|
|
|| !std::isfinite(desc.clear_color.g)
|
|
|| !std::isfinite(desc.clear_color.b)
|
|
|| !std::isfinite(desc.clear_color.a))) {
|
|
return pp::foundation::Status::invalid_argument("render pass clear color must be finite");
|
|
}
|
|
|
|
if (desc.clear_depth_enabled && !std::isfinite(desc.clear_depth)) {
|
|
return pp::foundation::Status::invalid_argument("render pass clear depth must be finite");
|
|
}
|
|
|
|
if (desc.clear_depth_enabled && (desc.clear_depth < 0.0F || desc.clear_depth > 1.0F)) {
|
|
return pp::foundation::Status::out_of_range("render pass clear depth must be within 0..1");
|
|
}
|
|
|
|
return pp::foundation::Status::success();
|
|
}
|
|
|
|
pp::foundation::Status validate_blend_factor(BlendFactor factor) noexcept
|
|
{
|
|
switch (factor) {
|
|
case BlendFactor::zero:
|
|
case BlendFactor::one:
|
|
case BlendFactor::source_alpha:
|
|
case BlendFactor::one_minus_source_alpha:
|
|
case BlendFactor::destination_alpha:
|
|
case BlendFactor::one_minus_destination_alpha:
|
|
return pp::foundation::Status::success();
|
|
}
|
|
|
|
return pp::foundation::Status::invalid_argument("blend factor is not supported");
|
|
}
|
|
|
|
pp::foundation::Status validate_blend_op(BlendOp op) noexcept
|
|
{
|
|
switch (op) {
|
|
case BlendOp::add:
|
|
case BlendOp::subtract:
|
|
case BlendOp::reverse_subtract:
|
|
return pp::foundation::Status::success();
|
|
}
|
|
|
|
return pp::foundation::Status::invalid_argument("blend operation is not supported");
|
|
}
|
|
|
|
pp::foundation::Status validate_blend_state(BlendState state) noexcept
|
|
{
|
|
const auto source_color = validate_blend_factor(state.source_color);
|
|
if (!source_color.ok()) {
|
|
return source_color;
|
|
}
|
|
|
|
const auto destination_color = validate_blend_factor(state.destination_color);
|
|
if (!destination_color.ok()) {
|
|
return destination_color;
|
|
}
|
|
|
|
const auto color_op = validate_blend_op(state.color_op);
|
|
if (!color_op.ok()) {
|
|
return color_op;
|
|
}
|
|
|
|
const auto source_alpha = validate_blend_factor(state.source_alpha);
|
|
if (!source_alpha.ok()) {
|
|
return source_alpha;
|
|
}
|
|
|
|
const auto destination_alpha = validate_blend_factor(state.destination_alpha);
|
|
if (!destination_alpha.ok()) {
|
|
return destination_alpha;
|
|
}
|
|
|
|
return validate_blend_op(state.alpha_op);
|
|
}
|
|
|
|
pp::foundation::Status validate_compare_op(CompareOp op) noexcept
|
|
{
|
|
switch (op) {
|
|
case CompareOp::never:
|
|
case CompareOp::less:
|
|
case CompareOp::equal:
|
|
case CompareOp::less_or_equal:
|
|
case CompareOp::greater:
|
|
case CompareOp::not_equal:
|
|
case CompareOp::greater_or_equal:
|
|
case CompareOp::always:
|
|
return pp::foundation::Status::success();
|
|
}
|
|
|
|
return pp::foundation::Status::invalid_argument("depth compare operation is not supported");
|
|
}
|
|
|
|
pp::foundation::Status validate_depth_state(DepthState state) noexcept
|
|
{
|
|
return validate_compare_op(state.compare);
|
|
}
|
|
|
|
pp::foundation::Status validate_sampler_filter(SamplerFilter filter) noexcept
|
|
{
|
|
switch (filter) {
|
|
case SamplerFilter::nearest:
|
|
case SamplerFilter::linear:
|
|
return pp::foundation::Status::success();
|
|
}
|
|
|
|
return pp::foundation::Status::invalid_argument("sampler filter is not supported");
|
|
}
|
|
|
|
pp::foundation::Status validate_sampler_address_mode(SamplerAddressMode mode) noexcept
|
|
{
|
|
switch (mode) {
|
|
case SamplerAddressMode::clamp_to_edge:
|
|
case SamplerAddressMode::repeat:
|
|
case SamplerAddressMode::mirrored_repeat:
|
|
case SamplerAddressMode::clamp_to_border:
|
|
return pp::foundation::Status::success();
|
|
}
|
|
|
|
return pp::foundation::Status::invalid_argument("sampler address mode is not supported");
|
|
}
|
|
|
|
pp::foundation::Status validate_sampler_desc(SamplerDesc desc) noexcept
|
|
{
|
|
const auto min_filter = validate_sampler_filter(desc.min_filter);
|
|
if (!min_filter.ok()) {
|
|
return min_filter;
|
|
}
|
|
|
|
const auto mag_filter = validate_sampler_filter(desc.mag_filter);
|
|
if (!mag_filter.ok()) {
|
|
return mag_filter;
|
|
}
|
|
|
|
const auto mip_filter = validate_sampler_filter(desc.mip_filter);
|
|
if (!mip_filter.ok()) {
|
|
return mip_filter;
|
|
}
|
|
|
|
const auto address_u = validate_sampler_address_mode(desc.address_u);
|
|
if (!address_u.ok()) {
|
|
return address_u;
|
|
}
|
|
|
|
const auto address_v = validate_sampler_address_mode(desc.address_v);
|
|
if (!address_v.ok()) {
|
|
return address_v;
|
|
}
|
|
|
|
return validate_sampler_address_mode(desc.address_w);
|
|
}
|
|
|
|
pp::foundation::Status validate_mesh_desc(MeshDesc desc) noexcept
|
|
{
|
|
const auto label_status = validate_resource_label(desc.debug_name);
|
|
if (!label_status.ok()) {
|
|
return label_status;
|
|
}
|
|
|
|
if (desc.vertex_count == 0) {
|
|
return pp::foundation::Status::invalid_argument("mesh must contain at least one vertex");
|
|
}
|
|
|
|
if (desc.vertex_count > max_mesh_vertices || desc.index_count > max_mesh_vertices) {
|
|
return pp::foundation::Status::out_of_range("mesh vertex or index count exceeds the configured limit");
|
|
}
|
|
|
|
switch (desc.topology) {
|
|
case PrimitiveTopology::triangles:
|
|
case PrimitiveTopology::triangle_strip:
|
|
case PrimitiveTopology::lines:
|
|
return pp::foundation::Status::success();
|
|
}
|
|
|
|
return pp::foundation::Status::invalid_argument("mesh topology is not supported");
|
|
}
|
|
|
|
pp::foundation::Status validate_draw_desc(MeshDesc mesh, DrawDesc draw) noexcept
|
|
{
|
|
const auto mesh_status = validate_mesh_desc(mesh);
|
|
if (!mesh_status.ok()) {
|
|
return mesh_status;
|
|
}
|
|
|
|
if (draw.instance_count == 0) {
|
|
return pp::foundation::Status::invalid_argument("draw instance count must be greater than zero");
|
|
}
|
|
|
|
if (draw.vertex_count == 0 && draw.index_count == 0) {
|
|
return pp::foundation::Status::invalid_argument("draw must include vertices or indices");
|
|
}
|
|
|
|
if (draw.index_count > 0) {
|
|
if (mesh.index_count == 0) {
|
|
return pp::foundation::Status::invalid_argument("indexed draw requires an indexed mesh");
|
|
}
|
|
|
|
if (draw.first_index > mesh.index_count || draw.index_count > mesh.index_count - draw.first_index) {
|
|
return pp::foundation::Status::out_of_range("draw index range exceeds the bound mesh");
|
|
}
|
|
|
|
return pp::foundation::Status::success();
|
|
}
|
|
|
|
if (draw.first_vertex > mesh.vertex_count || draw.vertex_count > mesh.vertex_count - draw.first_vertex) {
|
|
return pp::foundation::Status::out_of_range("draw vertex range exceeds the bound mesh");
|
|
}
|
|
|
|
return pp::foundation::Status::success();
|
|
}
|
|
|
|
pp::foundation::Status validate_texture_slot(std::uint32_t slot) noexcept
|
|
{
|
|
if (slot >= max_texture_slots) {
|
|
return pp::foundation::Status::out_of_range("texture slot exceeds the configured limit");
|
|
}
|
|
|
|
return pp::foundation::Status::success();
|
|
}
|
|
|
|
pp::foundation::Status validate_shader_program_desc(ShaderProgramDesc desc) noexcept
|
|
{
|
|
const auto label_status = validate_resource_label(desc.debug_name);
|
|
if (!label_status.ok()) {
|
|
return label_status;
|
|
}
|
|
|
|
const auto vertex_status = validate_shader_stage_source(
|
|
desc.vertex,
|
|
"vertex shader entry point must not be empty");
|
|
if (!vertex_status.ok()) {
|
|
return vertex_status;
|
|
}
|
|
|
|
const auto fragment_status = validate_shader_stage_source(
|
|
desc.fragment,
|
|
"fragment shader entry point must not be empty");
|
|
if (!fragment_status.ok()) {
|
|
return fragment_status;
|
|
}
|
|
|
|
return pp::foundation::Status::success();
|
|
}
|
|
|
|
pp::foundation::Status validate_shader_uniform_write(
|
|
const char* name,
|
|
std::span<const std::byte> bytes) noexcept
|
|
{
|
|
if (is_empty_c_string(name)) {
|
|
return pp::foundation::Status::invalid_argument("shader uniform name must not be empty");
|
|
}
|
|
|
|
if (bytes.empty()) {
|
|
return pp::foundation::Status::invalid_argument("shader uniform bytes must not be empty");
|
|
}
|
|
|
|
if (bytes.size() > max_shader_uniform_bytes) {
|
|
return pp::foundation::Status::out_of_range("shader uniform bytes exceed the configured limit");
|
|
}
|
|
|
|
return pp::foundation::Status::success();
|
|
}
|
|
|
|
pp::foundation::Status validate_trace_label(const char* component, const char* name) noexcept
|
|
{
|
|
if (is_empty_c_string(component)) {
|
|
return pp::foundation::Status::invalid_argument("trace component must not be empty");
|
|
}
|
|
|
|
if (is_empty_c_string(name)) {
|
|
return pp::foundation::Status::invalid_argument("trace name must not be empty");
|
|
}
|
|
|
|
if (bounded_c_string_length(component, max_trace_label_bytes) > max_trace_label_bytes) {
|
|
return pp::foundation::Status::out_of_range("trace component exceeds the configured limit");
|
|
}
|
|
|
|
if (bounded_c_string_length(name, max_trace_label_bytes) > max_trace_label_bytes) {
|
|
return pp::foundation::Status::out_of_range("trace name exceeds the configured limit");
|
|
}
|
|
|
|
return pp::foundation::Status::success();
|
|
}
|
|
|
|
pp::foundation::Status validate_readback_region(TextureDesc desc, ReadbackRegion region) noexcept
|
|
{
|
|
const auto desc_status = validate_texture_desc(desc);
|
|
if (!desc_status.ok()) {
|
|
return desc_status;
|
|
}
|
|
|
|
if (region.width == 0 || region.height == 0) {
|
|
return pp::foundation::Status::invalid_argument("readback region must be greater than zero");
|
|
}
|
|
|
|
if (region.x > desc.extent.width || region.y > desc.extent.height) {
|
|
return pp::foundation::Status::out_of_range("readback origin is outside the texture");
|
|
}
|
|
|
|
if (region.width > desc.extent.width - region.x || region.height > desc.extent.height - region.y) {
|
|
return pp::foundation::Status::out_of_range("readback region exceeds texture bounds");
|
|
}
|
|
|
|
return pp::foundation::Status::success();
|
|
}
|
|
|
|
pp::foundation::Result<std::uint64_t> readback_byte_size(TextureDesc desc, ReadbackRegion region) noexcept
|
|
{
|
|
const auto region_status = validate_readback_region(desc, region);
|
|
if (!region_status.ok()) {
|
|
return pp::foundation::Result<std::uint64_t>::failure(region_status);
|
|
}
|
|
|
|
const auto bpp = static_cast<std::uint64_t>(bytes_per_pixel(desc.format));
|
|
if (bpp == 0) {
|
|
return pp::foundation::Result<std::uint64_t>::failure(
|
|
pp::foundation::Status::invalid_argument("texture format is not supported"));
|
|
}
|
|
|
|
const auto width = static_cast<std::uint64_t>(region.width);
|
|
const auto height = static_cast<std::uint64_t>(region.height);
|
|
if (width > std::numeric_limits<std::uint64_t>::max() / height) {
|
|
return pp::foundation::Result<std::uint64_t>::failure(
|
|
pp::foundation::Status::out_of_range("readback pixel count overflows uint64"));
|
|
}
|
|
|
|
const auto pixels = width * height;
|
|
if (pixels > std::numeric_limits<std::uint64_t>::max() / bpp) {
|
|
return pp::foundation::Result<std::uint64_t>::failure(
|
|
pp::foundation::Status::out_of_range("readback byte size overflows uint64"));
|
|
}
|
|
|
|
const auto bytes = pixels * bpp;
|
|
if (bytes > max_texture_bytes) {
|
|
return pp::foundation::Result<std::uint64_t>::failure(
|
|
pp::foundation::Status::out_of_range("readback byte size exceeds the configured limit"));
|
|
}
|
|
|
|
return pp::foundation::Result<std::uint64_t>::success(bytes);
|
|
}
|
|
|
|
pp::foundation::Result<std::uint64_t> frame_capture_byte_size(TextureDesc desc) noexcept
|
|
{
|
|
const auto desc_status = validate_texture_desc(desc);
|
|
if (!desc_status.ok()) {
|
|
return pp::foundation::Result<std::uint64_t>::failure(desc_status);
|
|
}
|
|
|
|
if (!has_texture_usage(desc.usage, TextureUsage::render_target)) {
|
|
return pp::foundation::Result<std::uint64_t>::failure(
|
|
pp::foundation::Status::invalid_argument("frame capture source must be a render target"));
|
|
}
|
|
|
|
if (!has_texture_usage(desc.usage, TextureUsage::readback_source)) {
|
|
return pp::foundation::Result<std::uint64_t>::failure(
|
|
pp::foundation::Status::invalid_argument("frame capture source must allow readback"));
|
|
}
|
|
|
|
return texture_byte_size(desc);
|
|
}
|
|
|
|
pp::foundation::Status validate_texture_copy_descs(
|
|
TextureDesc source,
|
|
ReadbackRegion source_region,
|
|
TextureDesc destination,
|
|
ReadbackRegion destination_region) noexcept
|
|
{
|
|
if (!has_texture_usage(source.usage, TextureUsage::copy_source)) {
|
|
return pp::foundation::Status::invalid_argument("texture copy source must allow copy_source usage");
|
|
}
|
|
|
|
if (!has_texture_usage(destination.usage, TextureUsage::copy_destination)) {
|
|
return pp::foundation::Status::invalid_argument("texture copy destination must allow copy_destination usage");
|
|
}
|
|
|
|
if (source.format != destination.format) {
|
|
return pp::foundation::Status::invalid_argument("texture copy endpoints must use matching formats");
|
|
}
|
|
|
|
if (source_region.width != destination_region.width || source_region.height != destination_region.height) {
|
|
return pp::foundation::Status::invalid_argument("texture copy regions must have matching dimensions");
|
|
}
|
|
|
|
const auto source_status = validate_readback_region(source, source_region);
|
|
if (!source_status.ok()) {
|
|
return source_status;
|
|
}
|
|
|
|
return validate_readback_region(destination, destination_region);
|
|
}
|
|
|
|
pp::foundation::Status validate_mipmap_generation_desc(TextureDesc desc) noexcept
|
|
{
|
|
const auto desc_status = validate_texture_desc(desc);
|
|
if (!desc_status.ok()) {
|
|
return desc_status;
|
|
}
|
|
|
|
if (desc.mip_levels <= 1U) {
|
|
return pp::foundation::Status::invalid_argument("mipmap generation requires more than one mip level");
|
|
}
|
|
|
|
if (!has_texture_usage(desc.usage, TextureUsage::sampled)) {
|
|
return pp::foundation::Status::invalid_argument("mipmap texture must allow sampled usage");
|
|
}
|
|
|
|
if (!has_texture_usage(desc.usage, TextureUsage::copy_source)) {
|
|
return pp::foundation::Status::invalid_argument("mipmap texture must allow copy_source usage");
|
|
}
|
|
|
|
if (!has_texture_usage(desc.usage, TextureUsage::copy_destination)) {
|
|
return pp::foundation::Status::invalid_argument("mipmap texture must allow copy_destination usage");
|
|
}
|
|
|
|
return pp::foundation::Status::success();
|
|
}
|
|
|
|
pp::foundation::Status validate_texture_state(TextureState state) noexcept
|
|
{
|
|
switch (state) {
|
|
case TextureState::undefined:
|
|
case TextureState::shader_read:
|
|
case TextureState::render_target:
|
|
case TextureState::upload_destination:
|
|
case TextureState::copy_source:
|
|
case TextureState::copy_destination:
|
|
case TextureState::readback_source:
|
|
case TextureState::present:
|
|
return pp::foundation::Status::success();
|
|
}
|
|
|
|
return pp::foundation::Status::invalid_argument("texture state is not supported");
|
|
}
|
|
|
|
pp::foundation::Status validate_texture_transition_desc(
|
|
TextureDesc desc,
|
|
TextureState before,
|
|
TextureState after) noexcept
|
|
{
|
|
const auto desc_status = validate_texture_desc(desc);
|
|
if (!desc_status.ok()) {
|
|
return desc_status;
|
|
}
|
|
|
|
const auto before_status = validate_texture_state(before);
|
|
if (!before_status.ok()) {
|
|
return before_status;
|
|
}
|
|
|
|
const auto after_status = validate_texture_state(after);
|
|
if (!after_status.ok()) {
|
|
return after_status;
|
|
}
|
|
|
|
if (before == after) {
|
|
return pp::foundation::Status::invalid_argument("texture transition must change state");
|
|
}
|
|
|
|
if (after == TextureState::undefined) {
|
|
return pp::foundation::Status::invalid_argument("texture transition destination must not be undefined");
|
|
}
|
|
|
|
if (after == TextureState::shader_read && !has_texture_usage(desc.usage, TextureUsage::sampled)) {
|
|
return pp::foundation::Status::invalid_argument("shader-read transition requires sampled usage");
|
|
}
|
|
|
|
if (after == TextureState::render_target && !has_texture_usage(desc.usage, TextureUsage::render_target)) {
|
|
return pp::foundation::Status::invalid_argument("render-target transition requires render_target usage");
|
|
}
|
|
|
|
if (after == TextureState::upload_destination && !has_texture_usage(desc.usage, TextureUsage::upload_destination)) {
|
|
return pp::foundation::Status::invalid_argument("upload transition requires upload_destination usage");
|
|
}
|
|
|
|
if (after == TextureState::copy_source && !has_texture_usage(desc.usage, TextureUsage::copy_source)) {
|
|
return pp::foundation::Status::invalid_argument("copy-source transition requires copy_source usage");
|
|
}
|
|
|
|
if (after == TextureState::copy_destination && !has_texture_usage(desc.usage, TextureUsage::copy_destination)) {
|
|
return pp::foundation::Status::invalid_argument("copy-destination transition requires copy_destination usage");
|
|
}
|
|
|
|
if (after == TextureState::readback_source && !has_texture_usage(desc.usage, TextureUsage::readback_source)) {
|
|
return pp::foundation::Status::invalid_argument("readback transition requires readback_source usage");
|
|
}
|
|
|
|
return pp::foundation::Status::success();
|
|
}
|
|
|
|
pp::foundation::Status validate_blit_filter(BlitFilter filter) noexcept
|
|
{
|
|
switch (filter) {
|
|
case BlitFilter::nearest:
|
|
case BlitFilter::linear:
|
|
return pp::foundation::Status::success();
|
|
}
|
|
|
|
return pp::foundation::Status::invalid_argument("blit filter is not supported");
|
|
}
|
|
|
|
pp::foundation::Status validate_blit_descs(TextureDesc source, TextureDesc destination) noexcept
|
|
{
|
|
const auto source_status = validate_texture_desc(source);
|
|
if (!source_status.ok()) {
|
|
return source_status;
|
|
}
|
|
|
|
const auto destination_status = validate_texture_desc(destination);
|
|
if (!destination_status.ok()) {
|
|
return destination_status;
|
|
}
|
|
|
|
if (!has_texture_usage(source.usage, TextureUsage::render_target)
|
|
|| !has_texture_usage(destination.usage, TextureUsage::render_target)) {
|
|
return pp::foundation::Status::invalid_argument("blit endpoints must be render targets");
|
|
}
|
|
|
|
if (!has_texture_usage(source.usage, TextureUsage::copy_source)) {
|
|
return pp::foundation::Status::invalid_argument("blit source must allow copy_source usage");
|
|
}
|
|
|
|
if (!has_texture_usage(destination.usage, TextureUsage::copy_destination)) {
|
|
return pp::foundation::Status::invalid_argument("blit destination must allow copy_destination usage");
|
|
}
|
|
|
|
if (source.format != destination.format) {
|
|
return pp::foundation::Status::invalid_argument("blit endpoints must use matching texture formats");
|
|
}
|
|
|
|
const auto source_bytes = texture_byte_size(source);
|
|
if (!source_bytes.ok()) {
|
|
return source_bytes.status();
|
|
}
|
|
|
|
const auto destination_bytes = texture_byte_size(destination);
|
|
if (!destination_bytes.ok()) {
|
|
return destination_bytes.status();
|
|
}
|
|
|
|
return pp::foundation::Status::success();
|
|
}
|
|
|
|
pp::foundation::Result<PaintFeedbackPlan> plan_paint_feedback(
|
|
RenderDeviceFeatures features,
|
|
TextureDesc target_desc,
|
|
bool complex_blend) noexcept
|
|
{
|
|
const auto target_status = validate_texture_desc(target_desc);
|
|
if (!target_status.ok()) {
|
|
return pp::foundation::Result<PaintFeedbackPlan>::failure(target_status);
|
|
}
|
|
|
|
if (!has_texture_usage(target_desc.usage, TextureUsage::render_target)) {
|
|
return pp::foundation::Result<PaintFeedbackPlan>::failure(
|
|
pp::foundation::Status::invalid_argument("paint feedback target must allow render_target usage"));
|
|
}
|
|
|
|
if (target_desc.format == TextureFormat::depth24_stencil8) {
|
|
return pp::foundation::Result<PaintFeedbackPlan>::failure(
|
|
pp::foundation::Status::invalid_argument("paint feedback target must be a color texture"));
|
|
}
|
|
|
|
const auto target_bytes = texture_byte_size(target_desc);
|
|
if (!target_bytes.ok()) {
|
|
return pp::foundation::Result<PaintFeedbackPlan>::failure(target_bytes.status());
|
|
}
|
|
|
|
PaintFeedbackPlan plan;
|
|
plan.target_desc = target_desc;
|
|
plan.target_bytes = target_bytes.value();
|
|
plan.complex_blend = complex_blend;
|
|
if (!complex_blend) {
|
|
return pp::foundation::Result<PaintFeedbackPlan>::success(plan);
|
|
}
|
|
|
|
plan.reads_destination_color = true;
|
|
if (features.framebuffer_fetch) {
|
|
plan.path = PaintFeedbackPath::framebuffer_fetch;
|
|
plan.requires_explicit_transition = features.explicit_texture_transitions;
|
|
return pp::foundation::Result<PaintFeedbackPlan>::success(plan);
|
|
}
|
|
|
|
const bool can_ping_pong = has_texture_usage(target_desc.usage, TextureUsage::sampled)
|
|
&& has_texture_usage(target_desc.usage, TextureUsage::copy_source)
|
|
&& has_texture_usage(target_desc.usage, TextureUsage::copy_destination)
|
|
&& (features.texture_copy || features.render_target_blit);
|
|
if (!can_ping_pong) {
|
|
return pp::foundation::Result<PaintFeedbackPlan>::failure(
|
|
pp::foundation::Status::invalid_argument(
|
|
"complex paint feedback requires framebuffer fetch or sampled copy-capable render targets"));
|
|
}
|
|
|
|
plan.path = PaintFeedbackPath::ping_pong_textures;
|
|
plan.requires_auxiliary_texture = true;
|
|
plan.requires_texture_copy = features.texture_copy;
|
|
plan.requires_render_target_blit = !features.texture_copy && features.render_target_blit;
|
|
plan.requires_explicit_transition = features.explicit_texture_transitions;
|
|
plan.auxiliary_desc = target_desc;
|
|
return pp::foundation::Result<PaintFeedbackPlan>::success(plan);
|
|
}
|
|
|
|
const char* texture_format_name(TextureFormat format) noexcept
|
|
{
|
|
switch (format) {
|
|
case TextureFormat::rgba8:
|
|
return "rgba8";
|
|
case TextureFormat::r8:
|
|
return "r8";
|
|
case TextureFormat::depth24_stencil8:
|
|
return "depth24_stencil8";
|
|
}
|
|
|
|
return "unknown";
|
|
}
|
|
|
|
const char* texture_state_name(TextureState state) noexcept
|
|
{
|
|
switch (state) {
|
|
case TextureState::undefined:
|
|
return "undefined";
|
|
case TextureState::shader_read:
|
|
return "shader_read";
|
|
case TextureState::render_target:
|
|
return "render_target";
|
|
case TextureState::upload_destination:
|
|
return "upload_destination";
|
|
case TextureState::copy_source:
|
|
return "copy_source";
|
|
case TextureState::copy_destination:
|
|
return "copy_destination";
|
|
case TextureState::readback_source:
|
|
return "readback_source";
|
|
case TextureState::present:
|
|
return "present";
|
|
}
|
|
|
|
return "unknown";
|
|
}
|
|
|
|
const char* primitive_topology_name(PrimitiveTopology topology) noexcept
|
|
{
|
|
switch (topology) {
|
|
case PrimitiveTopology::triangles:
|
|
return "triangles";
|
|
case PrimitiveTopology::triangle_strip:
|
|
return "triangle_strip";
|
|
case PrimitiveTopology::lines:
|
|
return "lines";
|
|
}
|
|
|
|
return "unknown";
|
|
}
|
|
|
|
const char* blit_filter_name(BlitFilter filter) noexcept
|
|
{
|
|
switch (filter) {
|
|
case BlitFilter::nearest:
|
|
return "nearest";
|
|
case BlitFilter::linear:
|
|
return "linear";
|
|
}
|
|
|
|
return "unknown";
|
|
}
|
|
|
|
const char* paint_feedback_path_name(PaintFeedbackPath path) noexcept
|
|
{
|
|
switch (path) {
|
|
case PaintFeedbackPath::none:
|
|
return "none";
|
|
case PaintFeedbackPath::framebuffer_fetch:
|
|
return "framebuffer_fetch";
|
|
case PaintFeedbackPath::ping_pong_textures:
|
|
return "ping_pong_textures";
|
|
}
|
|
|
|
return "unknown";
|
|
}
|
|
|
|
const char* blend_factor_name(BlendFactor factor) noexcept
|
|
{
|
|
switch (factor) {
|
|
case BlendFactor::zero:
|
|
return "zero";
|
|
case BlendFactor::one:
|
|
return "one";
|
|
case BlendFactor::source_alpha:
|
|
return "source_alpha";
|
|
case BlendFactor::one_minus_source_alpha:
|
|
return "one_minus_source_alpha";
|
|
case BlendFactor::destination_alpha:
|
|
return "destination_alpha";
|
|
case BlendFactor::one_minus_destination_alpha:
|
|
return "one_minus_destination_alpha";
|
|
}
|
|
|
|
return "unknown";
|
|
}
|
|
|
|
const char* blend_op_name(BlendOp op) noexcept
|
|
{
|
|
switch (op) {
|
|
case BlendOp::add:
|
|
return "add";
|
|
case BlendOp::subtract:
|
|
return "subtract";
|
|
case BlendOp::reverse_subtract:
|
|
return "reverse_subtract";
|
|
}
|
|
|
|
return "unknown";
|
|
}
|
|
|
|
const char* compare_op_name(CompareOp op) noexcept
|
|
{
|
|
switch (op) {
|
|
case CompareOp::never:
|
|
return "never";
|
|
case CompareOp::less:
|
|
return "less";
|
|
case CompareOp::equal:
|
|
return "equal";
|
|
case CompareOp::less_or_equal:
|
|
return "less_or_equal";
|
|
case CompareOp::greater:
|
|
return "greater";
|
|
case CompareOp::not_equal:
|
|
return "not_equal";
|
|
case CompareOp::greater_or_equal:
|
|
return "greater_or_equal";
|
|
case CompareOp::always:
|
|
return "always";
|
|
}
|
|
|
|
return "unknown";
|
|
}
|
|
|
|
const char* sampler_filter_name(SamplerFilter filter) noexcept
|
|
{
|
|
switch (filter) {
|
|
case SamplerFilter::nearest:
|
|
return "nearest";
|
|
case SamplerFilter::linear:
|
|
return "linear";
|
|
}
|
|
|
|
return "unknown";
|
|
}
|
|
|
|
const char* sampler_address_mode_name(SamplerAddressMode mode) noexcept
|
|
{
|
|
switch (mode) {
|
|
case SamplerAddressMode::clamp_to_edge:
|
|
return "clamp_to_edge";
|
|
case SamplerAddressMode::repeat:
|
|
return "repeat";
|
|
case SamplerAddressMode::mirrored_repeat:
|
|
return "mirrored_repeat";
|
|
case SamplerAddressMode::clamp_to_border:
|
|
return "clamp_to_border";
|
|
}
|
|
|
|
return "unknown";
|
|
}
|
|
|
|
}
|