Add renderer resource factory contract

src/renderer_api/recording_renderer.cpp

@@ -1,5 +1,8 @@
 #include "renderer_api/recording_renderer.h"
 
+#include <new>
+#include <utility>
+
 namespace pp::renderer {
 
 namespace {
@@ -18,6 +21,20 @@ void push_command(
     }
 }
 
+template <typename Resource, typename Interface, typename... Args>
+[[nodiscard]] pp::foundation::Result<std::unique_ptr<Interface>> make_recording_resource(
+    Args&&... args) noexcept
+{
+    auto resource = std::unique_ptr<Resource>(new (std::nothrow) Resource(std::forward<Args>(args)...));
+    if (!resource) {
+        return pp::foundation::Result<std::unique_ptr<Interface>>::failure(
+            pp::foundation::Status::out_of_range("renderer resource allocation failed"));
+    }
+
+    std::unique_ptr<Interface> erased = std::move(resource);
+    return pp::foundation::Result<std::unique_ptr<Interface>>::success(std::move(erased));
+}
+
 }
 
 RecordingTexture2D::RecordingTexture2D(TextureDesc desc) noexcept
@@ -457,6 +474,71 @@ const char* RecordingRenderDevice::backend_name() const noexcept
     return "recording";
 }
 
+pp::foundation::Result<std::unique_ptr<ITexture2D>> RecordingRenderDevice::create_texture(
+    TextureDesc desc) noexcept
+{
+    const auto bytes = texture_byte_size(desc);
+    if (!bytes.ok()) {
+        return pp::foundation::Result<std::unique_ptr<ITexture2D>>::failure(bytes.status());
+    }
+
+    return make_recording_resource<RecordingTexture2D, ITexture2D>(desc);
+}
+
+pp::foundation::Result<std::unique_ptr<IRenderTarget>> RecordingRenderDevice::create_render_target(
+    TextureDesc color_desc) noexcept
+{
+    if (!color_desc.render_target) {
+        return pp::foundation::Result<std::unique_ptr<IRenderTarget>>::failure(
+            pp::foundation::Status::invalid_argument("render target texture must be flagged as render_target"));
+    }
+
+    const auto bytes = texture_byte_size(color_desc);
+    if (!bytes.ok()) {
+        return pp::foundation::Result<std::unique_ptr<IRenderTarget>>::failure(bytes.status());
+    }
+
+    return make_recording_resource<RecordingRenderTarget, IRenderTarget>(color_desc);
+}
+
+pp::foundation::Result<std::unique_ptr<IShaderProgram>> RecordingRenderDevice::create_shader_program(
+    ShaderProgramDesc desc) noexcept
+{
+    const auto status = validate_shader_program_desc(desc);
+    if (!status.ok()) {
+        return pp::foundation::Result<std::unique_ptr<IShaderProgram>>::failure(status);
+    }
+
+    return make_recording_resource<RecordingShaderProgram, IShaderProgram>(desc.debug_name);
+}
+
+pp::foundation::Result<std::unique_ptr<IMesh>> RecordingRenderDevice::create_mesh(
+    MeshDesc desc) noexcept
+{
+    const auto status = validate_mesh_desc(desc);
+    if (!status.ok()) {
+        return pp::foundation::Result<std::unique_ptr<IMesh>>::failure(status);
+    }
+
+    return make_recording_resource<RecordingMesh, IMesh>(desc);
+}
+
+pp::foundation::Result<std::unique_ptr<IReadbackBuffer>> RecordingRenderDevice::create_readback_buffer(
+    std::uint64_t size_bytes) noexcept
+{
+    if (size_bytes == 0U) {
+        return pp::foundation::Result<std::unique_ptr<IReadbackBuffer>>::failure(
+            pp::foundation::Status::invalid_argument("readback buffer size must be greater than zero"));
+    }
+
+    if (size_bytes > max_texture_bytes) {
+        return pp::foundation::Result<std::unique_ptr<IReadbackBuffer>>::failure(
+            pp::foundation::Status::out_of_range("readback buffer size exceeds the configured limit"));
+    }
+
+    return make_recording_resource<RecordingReadbackBuffer, IReadbackBuffer>(size_bytes);
+}
+
 ICommandContext& RecordingRenderDevice::immediate_context() noexcept
 {
     return context_;