omar/panopainter
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Add renderer blit command contract

Browse Source
This commit is contained in:
omigamedev
2026-06-02 15:31:01 +02:00
parent 1c40602744
commit ee3fb36047
9 changed files with 338 additions and 16 deletions
Download Patch File Download Diff File Expand all files Collapse all files

160
tests/renderer_api/renderer_api_tests.cpp
View File

@@ -8,6 +8,8 @@
#include <string_view>
using pp::foundation::StatusCode;
using pp::renderer::BlitFilter;
using pp::renderer::blit_filter_name;
using pp::renderer::ClearColor;
using pp::renderer::Extent2D;
using pp::renderer::frame_capture_byte_size;
@@ -42,6 +44,8 @@ using pp::renderer::ShaderCatalogEntry;
using pp::renderer::texture_byte_size;
using pp::renderer::texture_format_name;
using pp::renderer::validate_extent;
using pp::renderer::validate_blit_descs;
using pp::renderer::validate_blit_filter;
using pp::renderer::validate_mesh_desc;
using pp::renderer::validate_readback_region;
using pp::renderer::validate_shader_catalog;
@@ -200,6 +204,38 @@ public:
return pp::foundation::Status::success();
}
[[nodiscard]] pp::foundation::Status blit_render_target(
IRenderTarget& source,
ReadbackRegion source_region,
IRenderTarget& destination,
ReadbackRegion destination_region,
BlitFilter filter) noexcept override
{
const auto source_desc = source.color_desc();
const auto destination_desc = destination.color_desc();
const auto desc_status = validate_blit_descs(source_desc, destination_desc);
if (!desc_status.ok()) {
return desc_status;
}
const auto filter_status = validate_blit_filter(filter);
if (!filter_status.ok()) {
return filter_status;
}
const auto source_bytes = readback_byte_size(source_desc, source_region);
if (!source_bytes) {
return source_bytes.status();
}
const auto destination_bytes = readback_byte_size(destination_desc, destination_region);
if (!destination_bytes) {
return destination_bytes.status();
}
last_blit_source_bytes = source_bytes.value();
last_blit_destination_bytes = destination_bytes.value();
last_blit_filter = filter;
return pp::foundation::Status::success();
}
void end_render_pass() noexcept override
{
in_render_pass = false;
@@ -210,6 +246,9 @@ public:
std::uint64_t last_upload_bytes = 0;
std::uint64_t last_readback_bytes = 0;
std::uint64_t last_capture_bytes = 0;
std::uint64_t last_blit_source_bytes = 0;
std::uint64_t last_blit_destination_bytes = 0;
BlitFilter last_blit_filter = BlitFilter::nearest;
};
class FakeRenderDevice final : public IRenderDevice {
@@ -338,6 +377,42 @@ void computes_frame_capture_byte_sizes(pp::tests::Harness& h)
PP_EXPECT(h, non_target.status().code == StatusCode::invalid_argument);
}
void validates_blit_contract(pp::tests::Harness& h)
{
const TextureDesc target_desc {
.extent = Extent2D { .width = 16, .height = 8 },
.format = TextureFormat::rgba8,
.render_target = true,
};
const TextureDesc r8_target_desc {
.extent = Extent2D { .width = 16, .height = 8 },
.format = TextureFormat::r8,
.render_target = true,
};
const TextureDesc texture_desc {
.extent = Extent2D { .width = 16, .height = 8 },
.format = TextureFormat::rgba8,
.render_target = false,
};
PP_EXPECT(h, validate_blit_descs(target_desc, target_desc).ok());
PP_EXPECT(h, validate_blit_filter(BlitFilter::nearest).ok());
PP_EXPECT(h, validate_blit_filter(BlitFilter::linear).ok());
PP_EXPECT(h, blit_filter_name(BlitFilter::linear) == std::string_view("linear"));
const auto non_target = validate_blit_descs(texture_desc, target_desc);
const auto mismatched_format = validate_blit_descs(target_desc, r8_target_desc);
const auto bad_filter = validate_blit_filter(static_cast<BlitFilter>(255));
PP_EXPECT(h, !non_target.ok());
PP_EXPECT(h, non_target.code == StatusCode::invalid_argument);
PP_EXPECT(h, !mismatched_format.ok());
PP_EXPECT(h, mismatched_format.code == StatusCode::invalid_argument);
PP_EXPECT(h, !bad_filter.ok());
PP_EXPECT(h, bad_filter.code == StatusCode::invalid_argument);
PP_EXPECT(h, blit_filter_name(static_cast<BlitFilter>(255)) == std::string_view("unknown"));
}
void validates_viewports_and_mesh_descriptors(pp::tests::Harness& h)
{
const Extent2D target { .width = 64, .height = 32 };
@@ -512,10 +587,20 @@ void renderer_interfaces_support_backend_neutral_dispatch(pp::tests::Harness& h)
readback_buffer)
.ok());
PP_EXPECT(h, context.capture_frame(target, readback_buffer).ok());
PP_EXPECT(h, context.blit_render_target(
target,
ReadbackRegion { .x = 2, .y = 3, .width = 4, .height = 5 },
target,
ReadbackRegion { .x = 0, .y = 0, .width = 8, .height = 10 },
BlitFilter::linear)
.ok());
PP_EXPECT(h, device.context.shader_name == std::string_view("fake-shader"));
PP_EXPECT(h, device.context.last_upload_bytes == 80U);
PP_EXPECT(h, device.context.last_readback_bytes == 80U);
PP_EXPECT(h, device.context.last_capture_bytes == 8192U);
PP_EXPECT(h, device.context.last_blit_source_bytes == 80U);
PP_EXPECT(h, device.context.last_blit_destination_bytes == 320U);
PP_EXPECT(h, device.context.last_blit_filter == BlitFilter::linear);
}
void recording_renderer_records_valid_command_sequences(pp::tests::Harness& h)
@@ -533,6 +618,11 @@ void recording_renderer_records_valid_command_sequences(pp::tests::Harness& h)
.format = TextureFormat::rgba8,
.render_target = true,
});
RecordingRenderTarget blit_target(TextureDesc {
.extent = Extent2D { .width = 64, .height = 32 },
.format = TextureFormat::rgba8,
.render_target = true,
});
RecordingShaderProgram shader("recorded-shader");
RecordingMesh mesh(MeshDesc { .vertex_count = 3, .index_count = 0, .topology = PrimitiveTopology::triangles });
@@ -601,6 +691,25 @@ void recording_renderer_records_valid_command_sequences(pp::tests::Harness& h)
PP_EXPECT(h, commands_after_capture[9].capture_bytes == 8192U);
PP_EXPECT(h, recorded_render_command_kind_name(commands_after_capture[9].kind) == std::string_view("capture_frame"));
PP_EXPECT(h, context.blit_render_target(
target,
ReadbackRegion { .x = 0, .y = 0, .width = 16, .height = 8 },
blit_target,
ReadbackRegion { .x = 2, .y = 3, .width = 8, .height = 4 },
BlitFilter::linear)
.ok());
const auto commands_after_blit = device.commands();
PP_EXPECT(h, commands_after_blit.size() == 11U);
PP_EXPECT(h, commands_after_blit[10].kind == RecordedRenderCommandKind::blit_render_target);
PP_EXPECT(h, commands_after_blit[10].source_desc.extent.width == 64U);
PP_EXPECT(h, commands_after_blit[10].destination_desc.extent.height == 32U);
PP_EXPECT(h, commands_after_blit[10].source_region.width == 16U);
PP_EXPECT(h, commands_after_blit[10].destination_region.x == 2U);
PP_EXPECT(h, commands_after_blit[10].blit_filter == BlitFilter::linear);
PP_EXPECT(h, commands_after_blit[10].blit_source_bytes == 512U);
PP_EXPECT(h, commands_after_blit[10].blit_destination_bytes == 128U);
PP_EXPECT(h, recorded_render_command_kind_name(commands_after_blit[10].kind) == std::string_view("blit_render_target"));
device.clear();
PP_EXPECT(h, device.commands().empty());
}
@@ -618,6 +727,11 @@ void recording_renderer_rejects_invalid_command_order_and_targets(pp::tests::Har
.format = TextureFormat::rgba8,
.render_target = false,
});
RecordingRenderTarget r8_target(TextureDesc {
.extent = Extent2D { .width = 32, .height = 16 },
.format = TextureFormat::r8,
.render_target = true,
});
RecordingTexture2D texture(TextureDesc {
.extent = Extent2D { .width = 32, .height = 16 },
.format = TextureFormat::rgba8,
@@ -660,6 +774,15 @@ void recording_renderer_rejects_invalid_command_order_and_targets(pp::tests::Har
PP_EXPECT(h, !capture_during_render_pass.ok());
PP_EXPECT(h, capture_during_render_pass.code == StatusCode::invalid_argument);
const auto blit_during_render_pass = context.blit_render_target(
target,
ReadbackRegion { .x = 0, .y = 0, .width = 1, .height = 1 },
target,
ReadbackRegion { .x = 0, .y = 0, .width = 1, .height = 1 },
BlitFilter::nearest);
PP_EXPECT(h, !blit_during_render_pass.ok());
PP_EXPECT(h, blit_during_render_pass.code == StatusCode::invalid_argument);
const auto nested_begin = context.begin_render_pass(target, ClearColor {});
PP_EXPECT(h, !nested_begin.ok());
PP_EXPECT(h, nested_begin.code == StatusCode::invalid_argument);
@@ -720,6 +843,42 @@ void recording_renderer_rejects_invalid_command_order_and_targets(pp::tests::Har
const auto capture_non_target = context.capture_frame(non_render_target, full_readback_buffer);
PP_EXPECT(h, !capture_non_target.ok());
PP_EXPECT(h, capture_non_target.code == StatusCode::invalid_argument);
const auto blit_non_target = context.blit_render_target(
non_render_target,
ReadbackRegion { .x = 0, .y = 0, .width = 1, .height = 1 },
target,
ReadbackRegion { .x = 0, .y = 0, .width = 1, .height = 1 },
BlitFilter::nearest);
PP_EXPECT(h, !blit_non_target.ok());
PP_EXPECT(h, blit_non_target.code == StatusCode::invalid_argument);
const auto blit_mismatched_format = context.blit_render_target(
target,
ReadbackRegion { .x = 0, .y = 0, .width = 1, .height = 1 },
r8_target,
ReadbackRegion { .x = 0, .y = 0, .width = 1, .height = 1 },
BlitFilter::nearest);
PP_EXPECT(h, !blit_mismatched_format.ok());
PP_EXPECT(h, blit_mismatched_format.code == StatusCode::invalid_argument);
const auto blit_outside_bounds = context.blit_render_target(
target,
ReadbackRegion { .x = 31, .y = 15, .width = 2, .height = 1 },
target,
ReadbackRegion { .x = 0, .y = 0, .width = 1, .height = 1 },
BlitFilter::nearest);
PP_EXPECT(h, !blit_outside_bounds.ok());
PP_EXPECT(h, blit_outside_bounds.code == StatusCode::out_of_range);
const auto blit_bad_filter = context.blit_render_target(
target,
ReadbackRegion { .x = 0, .y = 0, .width = 1, .height = 1 },
target,
ReadbackRegion { .x = 0, .y = 0, .width = 1, .height = 1 },
static_cast<BlitFilter>(255));
PP_EXPECT(h, !blit_bad_filter.ok());
PP_EXPECT(h, blit_bad_filter.code == StatusCode::invalid_argument);
}
}
@@ -732,6 +891,7 @@ int main()
harness.run("validates_readback_bounds", validates_readback_bounds);
harness.run("computes_readback_byte_sizes", computes_readback_byte_sizes);
harness.run("computes_frame_capture_byte_sizes", computes_frame_capture_byte_sizes);
harness.run("validates_blit_contract", validates_blit_contract);
harness.run("validates_viewports_and_mesh_descriptors", validates_viewports_and_mesh_descriptors);
harness.run("validates_shader_program_descriptors", validates_shader_program_descriptors);
harness.run("validates_panopainter_shader_catalog", validates_panopainter_shader_catalog);