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

Add renderer readback command contract

Browse Source
This commit is contained in:
omigamedev
2026-06-02 15:10:44 +02:00
parent a6a4e7b249
commit c58b9a3718
9 changed files with 255 additions and 11 deletions
Download Patch File Download Diff File Expand all files Collapse all files

130
tests/renderer_api/renderer_api_tests.cpp
View File

@@ -20,9 +20,11 @@ using pp::renderer::PrimitiveTopology;
using pp::renderer::ReadbackRegion;
using pp::renderer::RecordedRenderCommandKind;
using pp::renderer::RecordingMesh;
using pp::renderer::RecordingReadbackBuffer;
using pp::renderer::RecordingRenderDevice;
using pp::renderer::RecordingRenderTarget;
using pp::renderer::RecordingShaderProgram;
using pp::renderer::RecordingTexture2D;
using pp::renderer::ShaderProgramDesc;
using pp::renderer::ShaderStageSource;
using pp::renderer::TextureDesc;
@@ -32,6 +34,7 @@ using pp::renderer::max_shader_source_bytes;
using pp::renderer::max_texture_dimension;
using pp::renderer::panopainter_shader_catalog;
using pp::renderer::primitive_topology_name;
using pp::renderer::readback_byte_size;
using pp::renderer::recorded_render_command_kind_name;
using pp::renderer::ShaderCatalogEntry;
using pp::renderer::texture_byte_size;
@@ -73,6 +76,34 @@ public:
}
};
class FakeTexture final : public pp::renderer::ITexture2D {
public:
[[nodiscard]] TextureDesc desc() const noexcept override
{
return TextureDesc {
.extent = Extent2D { .width = 64, .height = 32 },
.format = TextureFormat::rgba8,
.render_target = true,
};
}
};
class FakeReadbackBuffer final : public pp::renderer::IReadbackBuffer {
public:
explicit FakeReadbackBuffer(std::uint64_t size) noexcept
: size_(size)
{
}
[[nodiscard]] std::uint64_t size_bytes() const noexcept override
{
return size_;
}
private:
std::uint64_t size_ = 0;
};
class FakeTrace final : public IRenderTrace {
public:
void marker(const char* component, const char* name) noexcept override
@@ -120,6 +151,22 @@ public:
: pp::foundation::Status::invalid_argument("render pass has not begun");
}
[[nodiscard]] pp::foundation::Status read_texture(
pp::renderer::ITexture2D& texture,
ReadbackRegion region,
pp::renderer::IReadbackBuffer& destination) noexcept override
{
const auto bytes = readback_byte_size(texture.desc(), region);
if (!bytes) {
return bytes.status();
}
if (destination.size_bytes() < bytes.value()) {
return pp::foundation::Status::out_of_range("readback buffer is too small");
}
last_readback_bytes = bytes.value();
return pp::foundation::Status::success();
}
void end_render_pass() noexcept override
{
in_render_pass = false;
@@ -127,6 +174,7 @@ public:
bool in_render_pass = false;
const char* shader_name = nullptr;
std::uint64_t last_readback_bytes = 0;
};
class FakeRenderDevice final : public IRenderDevice {
@@ -208,6 +256,31 @@ void validates_readback_bounds(pp::tests::Harness& h)
PP_EXPECT(h, overrun.code == StatusCode::out_of_range);
}
void computes_readback_byte_sizes(pp::tests::Harness& h)
{
const TextureDesc rgba_desc {
.extent = Extent2D { .width = 64, .height = 32 },
.format = TextureFormat::rgba8,
.render_target = true,
};
const TextureDesc r8_desc {
.extent = Extent2D { .width = 64, .height = 32 },
.format = TextureFormat::r8,
.render_target = true,
};
const auto rgba = readback_byte_size(rgba_desc, ReadbackRegion { .x = 4, .y = 2, .width = 8, .height = 3 });
const auto r8 = readback_byte_size(r8_desc, ReadbackRegion { .x = 0, .y = 0, .width = 5, .height = 7 });
const auto overrun = readback_byte_size(rgba_desc, ReadbackRegion { .x = 63, .y = 0, .width = 2, .height = 1 });
PP_EXPECT(h, rgba.ok());
PP_EXPECT(h, rgba.value() == 96U);
PP_EXPECT(h, r8.ok());
PP_EXPECT(h, r8.value() == 35U);
PP_EXPECT(h, !overrun.ok());
PP_EXPECT(h, overrun.status().code == StatusCode::out_of_range);
}
void validates_viewports_and_mesh_descriptors(pp::tests::Harness& h)
{
const Extent2D target { .width = 64, .height = 32 };
@@ -349,6 +422,8 @@ void renderer_interfaces_support_backend_neutral_dispatch(pp::tests::Harness& h)
{
FakeRenderDevice device;
FakeRenderTarget target;
FakeTexture texture;
FakeReadbackBuffer readback_buffer(64U * 32U * 4U);
FakeShaderProgram shader;
FakeMesh mesh;
@@ -368,12 +443,24 @@ void renderer_interfaces_support_backend_neutral_dispatch(pp::tests::Harness& h)
const auto draw_after_end = context.draw();
PP_EXPECT(h, !draw_after_end.ok());
PP_EXPECT(h, draw_after_end.code == StatusCode::invalid_argument);
PP_EXPECT(h, context.read_texture(
texture,
ReadbackRegion { .x = 2, .y = 3, .width = 4, .height = 5 },
readback_buffer)
.ok());
PP_EXPECT(h, device.context.shader_name == std::string_view("fake-shader"));
PP_EXPECT(h, device.context.last_readback_bytes == 80U);
}
void recording_renderer_records_valid_command_sequences(pp::tests::Harness& h)
{
RecordingRenderDevice device;
RecordingTexture2D texture(TextureDesc {
.extent = Extent2D { .width = 64, .height = 32 },
.format = TextureFormat::rgba8,
.render_target = true,
});
RecordingReadbackBuffer readback_buffer(64U * 32U * 4U);
RecordingRenderTarget target(TextureDesc {
.extent = Extent2D { .width = 64, .height = 32 },
.format = TextureFormat::rgba8,
@@ -411,6 +498,20 @@ void recording_renderer_records_valid_command_sequences(pp::tests::Harness& h)
PP_EXPECT(h, commands[6].kind == RecordedRenderCommandKind::end_render_pass);
PP_EXPECT(h, recorded_render_command_kind_name(commands[5].kind) == std::string_view("draw"));
PP_EXPECT(h, context.read_texture(
texture,
ReadbackRegion { .x = 4, .y = 5, .width = 8, .height = 3 },
readback_buffer)
.ok());
const auto commands_after_readback = device.commands();
PP_EXPECT(h, commands_after_readback.size() == 8U);
PP_EXPECT(h, commands_after_readback[7].kind == RecordedRenderCommandKind::read_texture);
PP_EXPECT(h, commands_after_readback[7].texture_desc.extent.width == 64U);
PP_EXPECT(h, commands_after_readback[7].readback_region.x == 4U);
PP_EXPECT(h, commands_after_readback[7].readback_region.height == 3U);
PP_EXPECT(h, commands_after_readback[7].readback_bytes == 96U);
PP_EXPECT(h, recorded_render_command_kind_name(commands_after_readback[7].kind) == std::string_view("read_texture"));
device.clear();
PP_EXPECT(h, device.commands().empty());
}
@@ -428,6 +529,13 @@ void recording_renderer_rejects_invalid_command_order_and_targets(pp::tests::Har
.format = TextureFormat::rgba8,
.render_target = false,
});
RecordingTexture2D texture(TextureDesc {
.extent = Extent2D { .width = 32, .height = 16 },
.format = TextureFormat::rgba8,
.render_target = true,
});
RecordingReadbackBuffer small_readback_buffer(3U);
RecordingReadbackBuffer full_readback_buffer(32U * 16U * 4U);
RecordingShaderProgram shader("strict-shader");
RecordingMesh mesh(MeshDesc { .vertex_count = 3, .topology = PrimitiveTopology::triangles });
RecordingMesh empty_mesh(MeshDesc {});
@@ -443,6 +551,13 @@ void recording_renderer_rejects_invalid_command_order_and_targets(pp::tests::Har
PP_EXPECT(h, device.commands().empty());
PP_EXPECT(h, context.begin_render_pass(target, ClearColor {}).ok());
const auto read_during_render_pass = context.read_texture(
texture,
ReadbackRegion { .x = 0, .y = 0, .width = 1, .height = 1 },
full_readback_buffer);
PP_EXPECT(h, !read_during_render_pass.ok());
PP_EXPECT(h, read_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);
@@ -467,6 +582,20 @@ void recording_renderer_rejects_invalid_command_order_and_targets(pp::tests::Har
const auto viewport_after_end = context.set_viewport(Viewport { .x = 0, .y = 0, .width = 1, .height = 1 });
PP_EXPECT(h, !viewport_after_end.ok());
PP_EXPECT(h, viewport_after_end.code == StatusCode::invalid_argument);
const auto read_outside_bounds = context.read_texture(
texture,
ReadbackRegion { .x = 31, .y = 15, .width = 2, .height = 1 },
full_readback_buffer);
PP_EXPECT(h, !read_outside_bounds.ok());
PP_EXPECT(h, read_outside_bounds.code == StatusCode::out_of_range);
const auto read_into_small_buffer = context.read_texture(
texture,
ReadbackRegion { .x = 0, .y = 0, .width = 1, .height = 1 },
small_readback_buffer);
PP_EXPECT(h, !read_into_small_buffer.ok());
PP_EXPECT(h, read_into_small_buffer.code == StatusCode::out_of_range);
}
}
@@ -477,6 +606,7 @@ int main()
harness.run("computes_texture_sizes", computes_texture_sizes);
harness.run("rejects_invalid_or_excessive_extents", rejects_invalid_or_excessive_extents);
harness.run("validates_readback_bounds", validates_readback_bounds);
harness.run("computes_readback_byte_sizes", computes_readback_byte_sizes);
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);