diff --git a/Kernel/src/renderive/frame_control/concept/Manual_Refresh_Strategy.hpp b/Kernel/src/renderive/frame_control/concept/Manual_Refresh_Strategy.hpp index 436e07b..e58cf6b 100644 --- a/Kernel/src/renderive/frame_control/concept/Manual_Refresh_Strategy.hpp +++ b/Kernel/src/renderive/frame_control/concept/Manual_Refresh_Strategy.hpp @@ -3,5 +3,5 @@ #include "Frame_Control_Strategy.hpp" template concept Manual_Frame_Refresh_Strategy = Frame_Control_Strategy && requires(That& strategy) { - { strategy.refresh() } -> std::same_as; + { strategy.refresh() } -> std::same_as; }; diff --git a/Kernel/src/renderive/frame_control/strategy/manual/Manual_Refresh_Strategy.hpp b/Kernel/src/renderive/frame_control/strategy/manual/Manual_Refresh_Strategy.hpp index 7a6a011..e3da70a 100644 --- a/Kernel/src/renderive/frame_control/strategy/manual/Manual_Refresh_Strategy.hpp +++ b/Kernel/src/renderive/frame_control/strategy/manual/Manual_Refresh_Strategy.hpp @@ -6,14 +6,14 @@ #include "renderive/base/observer/Observer.hpp" #include "renderive/frame_control/base/Frame_Control_Strategy_Base.hpp" #include "renderive/real_time_data/Observation.hpp" -enum class Manual_Refresh_Error : std::uint8_t { +enum class Manual_Refresh_Result : std::uint8_t { none, no_pending_frame }; template > class Manual_Refresh_Strategy : public Frame_Control_Strategy_Base { public: - using Refresh_Error = Manual_Refresh_Error; + using Refresh_Result = Manual_Refresh_Result; enum class Observation_Event { prepared, prepared_replaced, @@ -101,7 +101,7 @@ public: Painter_Lease acquire_painter(); Render_Lease acquire_renderer(); void swap() override; - [[nodiscard]] Manual_Refresh_Error refresh(); + [[nodiscard]] Manual_Refresh_Result refresh(); bool discard_pending_frame(); State state() const; void on_real_time_data_update(const Real_Time_Data_Observation& observation) override; diff --git a/Kernel/src/renderive/frame_control/strategy/manual/Manual_Refresh_Strategy.inl b/Kernel/src/renderive/frame_control/strategy/manual/Manual_Refresh_Strategy.inl index d39f8ba..851225f 100644 --- a/Kernel/src/renderive/frame_control/strategy/manual/Manual_Refresh_Strategy.inl +++ b/Kernel/src/renderive/frame_control/strategy/manual/Manual_Refresh_Strategy.inl @@ -140,7 +140,7 @@ void Manual_Refresh_Strategy::swap() { publish_frame_control_state(invalid_frequency_hz(), 0); } template -Manual_Refresh_Error Manual_Refresh_Strategy::refresh() { +Manual_Refresh_Result Manual_Refresh_Strategy::refresh() { std::unique_lock render_lock(render_mutex_); Observation observation; bool refreshed{}; @@ -161,8 +161,8 @@ Manual_Refresh_Error Manual_Refresh_Strategy::refr } render_lock.unlock(); observe(observation); - return refreshed ? Manual_Refresh_Error::none - : Manual_Refresh_Error::no_pending_frame; + return refreshed ? Manual_Refresh_Result::none + : Manual_Refresh_Result::no_pending_frame; } template bool Manual_Refresh_Strategy::discard_pending_frame() { diff --git a/Kernel/src/renderive/real_time_data/base/Real_Time_Data_Base.cpp b/Kernel/src/renderive/real_time_data/base/Real_Time_Data_Base.cpp index 6f19f52..9a16729 100644 --- a/Kernel/src/renderive/real_time_data/base/Real_Time_Data_Base.cpp +++ b/Kernel/src/renderive/real_time_data/base/Real_Time_Data_Base.cpp @@ -33,7 +33,7 @@ Real_Time_Data_Binding Real_Time_Data_Base::bind_renderable(Renderable_Base& ren } return {renderable, *this}; } -void Real_Time_Data_Base::unbind_renderable(Renderable_Base& renderable) noexcept { +void Real_Time_Data_Base::unbind_renderable(Renderable_Base& renderable) { std::lock_guard lock(binding_mutex_); if (bound_renderable_ == &renderable) bound_renderable_ = nullptr; diff --git a/Kernel/src/renderive/real_time_data/base/Real_Time_Data_Base.hpp b/Kernel/src/renderive/real_time_data/base/Real_Time_Data_Base.hpp index 56cbccb..40dac1e 100644 --- a/Kernel/src/renderive/real_time_data/base/Real_Time_Data_Base.hpp +++ b/Kernel/src/renderive/real_time_data/base/Real_Time_Data_Base.hpp @@ -29,7 +29,7 @@ protected: private: friend class Real_Time_Data_Binding; friend class Renderable_Base; - void unbind_renderable(Renderable_Base& renderable) noexcept; + void unbind_renderable(Renderable_Base& renderable); virtual void publish_render_state() = 0; std::mutex binding_mutex_; Renderable_Base* bound_renderable_{}; diff --git a/Kernel/src/renderive/render_graph/External_Operation.cpp b/Kernel/src/renderive/render_graph/External_Operation.cpp index 6eca803..33a8c19 100644 --- a/Kernel/src/renderive/render_graph/External_Operation.cpp +++ b/Kernel/src/renderive/render_graph/External_Operation.cpp @@ -117,15 +117,15 @@ private: std::exception_ptr failure_; std::thread thread_; }; -External_Operation_Error checked_cancellation_error(External_Operation_Error error) { - if (error != External_Operation_Error::cancelled && - error != External_Operation_Error::deadline_exceeded) +External_Operation_Result checked_cancellation_error(External_Operation_Result error) { + if (error != External_Operation_Result::cancelled && + error != External_Operation_Result::deadline_exceeded) ::renderive::error::unexpected("external operation cancellation error is invalid"); return error; } } struct External_Operation::State { - bool finish(External_Operation_Status terminal, External_Operation_Error terminal_error, + bool finish(External_Operation_Status terminal, External_Operation_Result terminal_error, std::exception_ptr terminal_exception, std::function commit = {}) { Deadline_Service::Ticket deadline_ticket{}; @@ -142,7 +142,7 @@ struct External_Operation::State { commit(); } catch (...) { terminal = External_Operation_Status::failed; - terminal_error = External_Operation_Error::none; + terminal_error = External_Operation_Result::none; terminal_exception = ::renderive::error::capture( "finishing external operation", std::current_exception()); } @@ -166,7 +166,7 @@ struct External_Operation::State { } std::mutex mutex; Completion completion; - External_Operation_Error error{}; + External_Operation_Result error{}; std::exception_ptr exception; External_Operation_Status status{External_Operation_Status::pending}; bool subscribed{}; @@ -199,7 +199,7 @@ void External_Operation::on_complete(Completion completion) const { completion(std::move(result)); } } -bool External_Operation::cancel(External_Operation_Error error) const { +bool External_Operation::cancel(External_Operation_Result error) const { return state_ && state_->finish(External_Operation_Status::cancelled, checked_cancellation_error(error), {}); } @@ -219,11 +219,11 @@ External_Operation External_Operation_Source::operation() const noexcept { } bool External_Operation_Source::complete(std::function commit) { return state_ && state_->finish(External_Operation_Status::completed, - External_Operation_Error::none, {}, + External_Operation_Result::none, {}, std::move(commit)); } -bool External_Operation_Source::fail(External_Operation_Error error) { - if (error != External_Operation_Error::external_failure) +bool External_Operation_Source::fail(External_Operation_Result error) { + if (error != External_Operation_Result::external_failure) ::renderive::error::unexpected("external operation failure error is invalid"); return state_ && state_->finish(External_Operation_Status::failed, error, {}); } @@ -233,10 +233,10 @@ bool External_Operation_Source::fail(std::exception_ptr exception) { exception = ::renderive::error::capture( "failing external operation", std::move(exception)); return state_ && state_->finish(External_Operation_Status::failed, - External_Operation_Error::none, + External_Operation_Result::none, std::move(exception)); } -bool External_Operation_Source::cancel(External_Operation_Error error) { +bool External_Operation_Source::cancel(External_Operation_Result error) { return state_ && state_->finish(External_Operation_Status::cancelled, checked_cancellation_error(error), {}); } @@ -266,7 +266,7 @@ void External_Operation_Source::set_deadline(Clock::time_point deadline) { } static_cast(state->finish( External_Operation_Status::cancelled, - External_Operation_Error::deadline_exceeded, {})); + External_Operation_Result::deadline_exceeded, {})); }); previous_ticket = std::exchange(state_->deadline_ticket, ticket); state_->deadline = deadline; @@ -275,24 +275,24 @@ void External_Operation_Source::set_deadline(Clock::time_point deadline) { Deadline_Service::instance().cancel(previous_ticket); } Node_Execution_Result::Node_Execution_Result( - External_Operation_Error error, + External_Operation_Result result, std::optional operation) noexcept - : error_(error), operation_(std::move(operation)) {} + : result_(result), operation_(std::move(operation)) {} Node_Execution_Result Node_Execution_Result::completed() noexcept { - return Node_Execution_Result(External_Operation_Error::none, std::nullopt); + return Node_Execution_Result(External_Operation_Result::none, std::nullopt); } -Node_Execution_Result Node_Execution_Result::failed(External_Operation_Error error) { - if (error == External_Operation_Error::none) +Node_Execution_Result Node_Execution_Result::failed(External_Operation_Result error) { + if (error == External_Operation_Result::none) ::renderive::error::unexpected("failed node result has no error"); return Node_Execution_Result(error, std::nullopt); } Node_Execution_Result Node_Execution_Result::external(External_Operation operation) { if (!operation) ::renderive::error::unexpected("external node result has no operation"); - return Node_Execution_Result(External_Operation_Error::none, std::move(operation)); + return Node_Execution_Result(External_Operation_Result::none, std::move(operation)); } -External_Operation_Error Node_Execution_Result::error() const noexcept { - return error_; +External_Operation_Result Node_Execution_Result::result() const noexcept { + return result_; } bool Node_Execution_Result::is_external() const noexcept { return operation_.has_value(); diff --git a/Kernel/src/renderive/render_graph/External_Operation.hpp b/Kernel/src/renderive/render_graph/External_Operation.hpp index 3a0406a..655d9dd 100644 --- a/Kernel/src/renderive/render_graph/External_Operation.hpp +++ b/Kernel/src/renderive/render_graph/External_Operation.hpp @@ -6,7 +6,7 @@ #include #include class External_Operation_Source; -enum class External_Operation_Error : std::uint8_t { +enum class External_Operation_Result : std::uint8_t { none, cancelled, deadline_exceeded, @@ -19,10 +19,10 @@ enum class External_Operation_Status : std::uint8_t { cancelled }; struct External_Operation_Completion { - External_Operation_Error error{}; + External_Operation_Result result{}; std::exception_ptr exception; [[nodiscard]] explicit operator bool() const noexcept { - return error == External_Operation_Error::none && !exception; + return result == External_Operation_Result::none && !exception; } }; class External_Operation { @@ -30,7 +30,7 @@ public: using Completion = std::function; External_Operation() = default; void on_complete(Completion completion) const; - [[nodiscard]] bool cancel(External_Operation_Error error = External_Operation_Error::cancelled) const; + [[nodiscard]] bool cancel(External_Operation_Result error = External_Operation_Result::cancelled) const; [[nodiscard]] External_Operation_Status status() const; [[nodiscard]] explicit operator bool() const noexcept; private: @@ -49,9 +49,9 @@ public: External_Operation_Source& operator=(External_Operation_Source&&) noexcept = default; [[nodiscard]] External_Operation operation() const noexcept; [[nodiscard]] bool complete(std::function commit = {}); - [[nodiscard]] bool fail(External_Operation_Error error); + [[nodiscard]] bool fail(External_Operation_Result error); [[nodiscard]] bool fail(std::exception_ptr exception); - [[nodiscard]] bool cancel(External_Operation_Error error = External_Operation_Error::cancelled); + [[nodiscard]] bool cancel(External_Operation_Result error = External_Operation_Result::cancelled); void set_deadline(Clock::time_point deadline); private: std::shared_ptr state_; @@ -59,14 +59,14 @@ private: class Node_Execution_Result { public: [[nodiscard]] static Node_Execution_Result completed() noexcept; - [[nodiscard]] static Node_Execution_Result failed(External_Operation_Error error); + [[nodiscard]] static Node_Execution_Result failed(External_Operation_Result error); [[nodiscard]] static Node_Execution_Result external(External_Operation operation); - [[nodiscard]] External_Operation_Error error() const noexcept; + [[nodiscard]] External_Operation_Result result() const noexcept; [[nodiscard]] bool is_external() const noexcept; [[nodiscard]] const External_Operation& operation() const; private: - Node_Execution_Result(External_Operation_Error error, + Node_Execution_Result(External_Operation_Result result, std::optional operation) noexcept; - External_Operation_Error error_{}; + External_Operation_Result result_{}; std::optional operation_; }; diff --git a/Kernel/src/renderive/render_graph/detail/Render_Graph_Runtime.cpp b/Kernel/src/renderive/render_graph/detail/Render_Graph_Runtime.cpp index 1c3c0ff..baee5d2 100644 --- a/Kernel/src/renderive/render_graph/detail/Render_Graph_Runtime.cpp +++ b/Kernel/src/renderive/render_graph/detail/Render_Graph_Runtime.cpp @@ -11,16 +11,16 @@ #include "renderive/scheduling/detail/OneTBB_Runtime.hpp" namespace renderive::render_graph::detail { namespace { -Render_Graph_Execution_Error graph_error(External_Operation_Error error) { +Render_Graph_Execution_Result graph_error(External_Operation_Result error) { switch (error) { - case External_Operation_Error::none: - return Render_Graph_Execution_Error::none; - case External_Operation_Error::cancelled: - return Render_Graph_Execution_Error::cancelled; - case External_Operation_Error::deadline_exceeded: - return Render_Graph_Execution_Error::deadline_exceeded; - case External_Operation_Error::external_failure: - return Render_Graph_Execution_Error::external_failure; + case External_Operation_Result::none: + return Render_Graph_Execution_Result::none; + case External_Operation_Result::cancelled: + return Render_Graph_Execution_Result::cancelled; + case External_Operation_Result::deadline_exceeded: + return Render_Graph_Execution_Result::deadline_exceeded; + case External_Operation_Result::external_failure: + return Render_Graph_Execution_Result::external_failure; } ::renderive::error::unexpected("unknown external operation error"); } @@ -67,7 +67,7 @@ struct Render_Graph_Runtime::State *nodes[indices.at(edge.from)].execute, *nodes[indices.at(edge.to)].ready); } - Render_Graph_Execution_Error execute( + Render_Graph_Execution_Result execute( std::span execution_slots, Execute_Node execute) { { @@ -75,11 +75,11 @@ struct Render_Graph_Runtime::State if (running.load(std::memory_order_acquire)) ::renderive::error::unexpected("render graph runtime is already executing"); cancellation_requested.store(false, std::memory_order_release); - cancellation_error = External_Operation_Error::cancelled; + cancellation_error = External_Operation_Result::cancelled; running.store(true, std::memory_order_release); } std::exception_ptr execution_exception; - External_Operation_Error execution_error{}; + External_Operation_Result execution_error{}; try { if (!execute) ::renderive::error::unexpected("render graph node executor is empty"); @@ -95,7 +95,7 @@ struct Render_Graph_Runtime::State { std::lock_guard lock(error_mutex); first_exception = nullptr; - first_error = External_Operation_Error::none; + first_error = External_Operation_Result::none; } { std::lock_guard lock(external_mutex); @@ -138,12 +138,12 @@ struct Render_Graph_Runtime::State { std::lock_guard lock(lifecycle_mutex); cancellation_requested.store(false, std::memory_order_release); - cancellation_error = External_Operation_Error::cancelled; + cancellation_error = External_Operation_Result::cancelled; running.store(false, std::memory_order_release); } } - void cancel_pending(External_Operation_Error error) { - if (error == External_Operation_Error::none) + void cancel_pending(External_Operation_Result error) { + if (error == External_Operation_Result::none) ::renderive::error::unexpected("render graph cancellation error is none"); { std::lock_guard lifecycle_lock(lifecycle_mutex); @@ -155,7 +155,7 @@ struct Render_Graph_Runtime::State } cancel_external_operations(error); } - External_Operation_Error cancellation_reason() { + External_Operation_Result cancellation_reason() { std::lock_guard lock(lifecycle_mutex); return cancellation_error; } @@ -195,8 +195,8 @@ struct Render_Graph_Runtime::State return; } const std::uint64_t cpu_end = render_clock_now_ns(); - if (result.error() != External_Operation_Error::none) { - fail_expected(index, result.error(), cpu_end); + if (result.result() != External_Operation_Result::none) { + fail_expected(index, result.result(), cpu_end); return; } if (cancellation_requested.load(std::memory_order_acquire)) { @@ -236,8 +236,8 @@ struct Render_Graph_Runtime::State if (completion.exception) { self->fail_exception( index, std::move(completion.exception), end); - } else if (completion.error != External_Operation_Error::none) { - self->fail_expected(index, completion.error, end); + } else if (completion.result != External_Operation_Result::none) { + self->fail_expected(index, completion.result, end); } else { self->complete_external(index, end); static_cast(gateway_ptr->try_put(Message{})); @@ -274,7 +274,7 @@ struct Render_Graph_Runtime::State std::lock_guard lock(external_mutex); external_operations[index] = External_Operation{}; } - void cancel_external_operations(External_Operation_Error error) { + void cancel_external_operations(External_Operation_Result error) { std::vector active; { std::lock_guard lock(external_mutex); @@ -314,20 +314,20 @@ struct Render_Graph_Runtime::State execution->status = status; } } - void fail_expected(std::size_t index, External_Operation_Error error, + void fail_expected(std::size_t index, External_Operation_Result error, std::uint64_t end) { const bool first_failure = !failed.exchange(true, std::memory_order_acq_rel); - const auto status = error == External_Operation_Error::external_failure + const auto status = error == External_Operation_Result::external_failure ? Node_Execution_Status::failed : Node_Execution_Status::cancelled; set_failed_execution(index, end, status); { std::lock_guard lock(error_mutex); - if (first_error == External_Operation_Error::none && !first_exception) + if (first_error == External_Operation_Result::none && !first_exception) first_error = error; } if (first_failure) - cancel_pending(External_Operation_Error::cancelled); + cancel_pending(External_Operation_Result::cancelled); } void fail_exception(std::size_t index, std::exception_ptr exception, std::uint64_t end) { @@ -339,7 +339,7 @@ struct Render_Graph_Runtime::State first_exception = std::move(exception); } if (first_failure) - cancel_pending(External_Operation_Error::cancelled); + cancel_pending(External_Operation_Result::cancelled); } oneapi::tbb::flow::graph graph; std::vector nodes; @@ -348,11 +348,11 @@ struct Render_Graph_Runtime::State Execute_Node execute_node; std::mutex error_mutex; std::exception_ptr first_exception; - External_Operation_Error first_error{}; + External_Operation_Result first_error{}; std::mutex external_mutex; std::vector external_operations; std::mutex lifecycle_mutex; - External_Operation_Error cancellation_error{External_Operation_Error::cancelled}; + External_Operation_Result cancellation_error{External_Operation_Result::cancelled}; std::atomic_bool running{}; std::atomic_bool failed{}; std::atomic_bool cancellation_requested{}; @@ -360,13 +360,13 @@ struct Render_Graph_Runtime::State Render_Graph_Runtime::Render_Graph_Runtime(const Render_Plan& plan) : state_(std::make_shared(plan)) {} Render_Graph_Runtime::~Render_Graph_Runtime() noexcept(false) { - state_->cancel_pending(External_Operation_Error::cancelled); + state_->cancel_pending(External_Operation_Result::cancelled); } -Render_Graph_Execution_Error Render_Graph_Runtime::execute( +Render_Graph_Execution_Result Render_Graph_Runtime::execute( std::span executions, Execute_Node execute_node) { return state_->execute(executions, std::move(execute_node)); } -void Render_Graph_Runtime::cancel_pending(External_Operation_Error error) { +void Render_Graph_Runtime::cancel_pending(External_Operation_Result error) { state_->cancel_pending(error); } } diff --git a/Kernel/src/renderive/render_graph/detail/Render_Graph_Runtime.hpp b/Kernel/src/renderive/render_graph/detail/Render_Graph_Runtime.hpp index c844bc0..a240153 100644 --- a/Kernel/src/renderive/render_graph/detail/Render_Graph_Runtime.hpp +++ b/Kernel/src/renderive/render_graph/detail/Render_Graph_Runtime.hpp @@ -8,7 +8,7 @@ #include "renderive/render_graph/Render_Plan.hpp" #include "renderive/scene/base/Abstract_Frame.hpp" namespace renderive::render_graph::detail { -enum class Render_Graph_Execution_Error : std::uint8_t { +enum class Render_Graph_Execution_Result : std::uint8_t { none, cancelled, deadline_exceeded, @@ -24,9 +24,9 @@ public: Render_Graph_Runtime& operator=(const Render_Graph_Runtime&) = delete; Render_Graph_Runtime(Render_Graph_Runtime&&) = delete; Render_Graph_Runtime& operator=(Render_Graph_Runtime&&) = delete; - [[nodiscard]] Render_Graph_Execution_Error execute( + [[nodiscard]] Render_Graph_Execution_Result execute( std::span executions, Execute_Node execute_node); - void cancel_pending(External_Operation_Error error = External_Operation_Error::cancelled); + void cancel_pending(External_Operation_Result error = External_Operation_Result::cancelled); private: struct State; std::shared_ptr state_; diff --git a/Kernel/src/renderive/renderable/base/Renderable_Base.cpp b/Kernel/src/renderive/renderable/base/Renderable_Base.cpp index 694a9e3..f5d1be6 100644 --- a/Kernel/src/renderive/renderable/base/Renderable_Base.cpp +++ b/Kernel/src/renderive/renderable/base/Renderable_Base.cpp @@ -154,7 +154,7 @@ void Renderable_Base::Impl::discard_stale_frame_on_latest_data_update( enabled, std::memory_order_release); } -void Renderable_Base::Impl::notify_scene_model_dirty() noexcept { +void Renderable_Base::Impl::notify_scene_model_dirty() { const auto& state = real_time_data_state; if (!state->attached.load(std::memory_order_acquire) || !state->scene_lifetime) @@ -222,7 +222,7 @@ void Renderable_Base::Impl::register_real_time_data( } void Renderable_Base::Impl::unregister_real_time_data( - Real_Time_Data_Base& data) noexcept { + Real_Time_Data_Base& data) { std::lock_guard lock(real_time_data_mutex); std::erase(real_time_data, &data); } @@ -278,12 +278,12 @@ void Renderable_Base::discard_stale_frame_on_latest_data_update( d_func().discard_stale_frame_on_latest_data_update(enabled); } -void Renderable_Base::Impl::changed() noexcept { +void Renderable_Base::Impl::changed() { invalidate_prepare(); notify_scene_model_dirty(); } -void Renderable_Base::Impl::paint_changed() noexcept { +void Renderable_Base::Impl::paint_changed() { invalidate_paint(); notify_scene_model_dirty(); } diff --git a/Kernel/src/renderive/renderable/base/Renderable_Base_p.hpp b/Kernel/src/renderive/renderable/base/Renderable_Base_p.hpp index 402053e..88ef0ec 100644 --- a/Kernel/src/renderive/renderable/base/Renderable_Base_p.hpp +++ b/Kernel/src/renderive/renderable/base/Renderable_Base_p.hpp @@ -35,8 +35,8 @@ public: std::pmr::memory_resource& resource) noexcept; void invalidate_prepare() noexcept; void invalidate_paint() noexcept; - void changed() noexcept; - void paint_changed() noexcept; + void changed(); + void paint_changed(); void render_graph_changed(); void set_configuration(Renderable_Configuration value); void set_visible(bool value); @@ -48,14 +48,14 @@ public: [[nodiscard]] static Render_State_View render_state_view() noexcept; [[nodiscard]] Real_Time_Data_Binding bind_real_time_data( Real_Time_Data_Base& data); - void notify_scene_model_dirty() noexcept; + void notify_scene_model_dirty(); void bind_scene(std::shared_ptr lifetime); [[nodiscard]] std::shared_ptr render_graph_snapshot(); void mark_prepared(std::uint64_t revision) noexcept; void mark_painted(std::uint64_t paint_revision, std::uint64_t prepare_revision) noexcept; void register_real_time_data(Real_Time_Data_Base& data); - void unregister_real_time_data(Real_Time_Data_Base& data) noexcept; + void unregister_real_time_data(Real_Time_Data_Base& data); void publish_real_time_data(); void reset_render_graph(); void add_prepare_action(Prepare_Action action); diff --git a/Kernel/src/renderive/scene/base/Scene_Base.cpp b/Kernel/src/renderive/scene/base/Scene_Base.cpp index 3db2a99..8f9075b 100644 --- a/Kernel/src/renderive/scene/base/Scene_Base.cpp +++ b/Kernel/src/renderive/scene/base/Scene_Base.cpp @@ -53,18 +53,18 @@ Scene_Edit_Error relationship_error( } ::renderive::error::unexpected("unknown scene relationship mutation error"); } -Scene_Render_Error scene_render_error( - renderive::render_graph::detail::Render_Graph_Execution_Error error) { - using Error = renderive::render_graph::detail::Render_Graph_Execution_Error; +Scene_Render_Result scene_render_error( + renderive::render_graph::detail::Render_Graph_Execution_Result error) { + using Error = renderive::render_graph::detail::Render_Graph_Execution_Result; switch (error) { case Error::none: - return Scene_Render_Error::none; + return Scene_Render_Result::none; case Error::cancelled: - return Scene_Render_Error::cancelled; + return Scene_Render_Result::cancelled; case Error::deadline_exceeded: - return Scene_Render_Error::deadline_exceeded; + return Scene_Render_Result::deadline_exceeded; case Error::external_failure: - return Scene_Render_Error::external_failure; + return Scene_Render_Result::external_failure; } ::renderive::error::unexpected("unknown render graph execution error"); } @@ -609,21 +609,21 @@ Scene_Base::Edit_Operation Scene_3D_Base::edit_renderables(Renderable_Edit edit) }); } -Scene_Render_Error Scene_Base::render() { +Scene_Render_Result Scene_Base::render() { return submit_render(nullptr); } -Scene_Render_Error Scene_Base::render(Abstract_Frame& frame) { +Scene_Render_Result Scene_Base::render(Abstract_Frame& frame) { return submit_render(&frame); } -Scene_Render_Error Scene_Base::submit_render(Abstract_Frame* frame) { +Scene_Render_Result Scene_Base::submit_render(Abstract_Frame* frame) { if (active_submitted_observer_scene_ == this) { std::lock_guard lock(task_mutex_); ++deferred_render_count_; - return Scene_Render_Error::none; + return Scene_Render_Result::none; } auto task_lock = lock_render_idle(); if (shutting_down_) - return Scene_Render_Error::shutting_down; + return Scene_Render_Result::shutting_down; runtime_started_ = true; std::exception_ptr previous_exception; if (pending_exception_) @@ -711,15 +711,15 @@ Scene_Render_Error Scene_Base::submit_render(Abstract_Frame* frame) { } for (std::size_t index = 0; index < deferred_render_count; ++index) static_cast(render()); - return Scene_Render_Error::none; + return Scene_Render_Result::none; } -Scene_Render_Error Scene_Base::wait_for_render() { +Scene_Render_Result Scene_Base::wait_for_render() { if (is_render_execution_context() || active_submitted_observer_scene_ == this) - return Scene_Render_Error::none; + return Scene_Render_Result::none; std::unique_lock lock(task_mutex_); const auto completion = current_completion_; if (!completion) - return Scene_Render_Error::none; + return Scene_Render_Result::none; render_completed_.wait(lock, [&completion] { return completion->completed; }); std::exception_ptr exception; if (pending_exception_) @@ -757,7 +757,6 @@ Scene_Base::Edit_Operation Scene_Base::enqueue_renderable_edit( const auto exception = ::renderive::error::capture( "executing asynchronous renderable edit", std::current_exception()); - record_pending_exception(exception); promise->set_exception(exception); } complete_pending_operation(); @@ -1268,7 +1267,7 @@ Scene_Edit_Error Scene_Base::execute_renderable_edit( void Scene_Base::execute_render_task(std::shared_ptr task) { Render_Execution_Scope scope(*this); const auto& snapshot = *task->snapshot; - Scene_Render_Error error{}; + Scene_Render_Result error{}; std::exception_ptr exception; bool render_graph_entered{}; try { @@ -1277,7 +1276,7 @@ void Scene_Base::execute_render_task(std::shared_ptr task) { task->snapshot, task->compiled_plan->plan}); render_graph_entered = true; error = execute_render_graph(*task); - const auto event = error == Scene_Render_Error::none + const auto event = error == Scene_Render_Result::none ? Observation_Event::render_completed : Observation_Event::render_cancelled; d_func().dispatch({event, d_func().now_ns(), snapshot.render_sequence, @@ -1504,7 +1503,7 @@ std::shared_ptr Scene_Base::compile_render_pla return compiled; } -Scene_Render_Error Scene_Base::execute_render_graph(Render_Task& task) { +Scene_Render_Result Scene_Base::execute_render_graph(Render_Task& task) { if (!task.snapshot || !task.compiled_plan || !task.frame) ::renderive::error::unexpected("render task is incomplete"); auto& frame = *task.frame; @@ -1585,7 +1584,7 @@ Scene_Render_Error Scene_Base::execute_render_graph(Render_Task& task) { } ::renderive::error::unexpected("unknown render node kind"); }); - if (graph_error != renderive::render_graph::detail::Render_Graph_Execution_Error::none) { + if (graph_error != renderive::render_graph::detail::Render_Graph_Execution_Result::none) { Abstract_Frame::discard_render(frame); frame_active = false; capture_controller_.finish_frame(capture_ticket, false); @@ -1616,7 +1615,7 @@ Scene_Render_Error Scene_Base::execute_render_graph(Render_Task& task) { analyze_frame(*compiled.plan, *completed)); } capture_controller_.finish_frame(capture_ticket, true); - return Scene_Render_Error::none; + return Scene_Render_Result::none; } catch (...) { if (frame_active) Abstract_Frame::discard_render(frame); diff --git a/Kernel/src/renderive/scene/base/Scene_Base.hpp b/Kernel/src/renderive/scene/base/Scene_Base.hpp index 51e0791..ef654e2 100644 --- a/Kernel/src/renderive/scene/base/Scene_Base.hpp +++ b/Kernel/src/renderive/scene/base/Scene_Base.hpp @@ -35,7 +35,7 @@ class Color_Cache; -enum class Scene_Render_Error : std::uint8_t { +enum class Scene_Render_Result : std::uint8_t { none, cancelled, deadline_exceeded, @@ -198,9 +198,9 @@ public: Scene_Base& operator=(Scene_Base&&) = delete; virtual ~Scene_Base(); - Scene_Render_Error render(); - Scene_Render_Error render(Abstract_Frame& frame); - Scene_Render_Error wait_for_render(); + Scene_Render_Result render(); + Scene_Render_Result render(Abstract_Frame& frame); + Scene_Render_Result wait_for_render(); void publish_frame_state(); void publish_frame_state(Abstract_Frame& frame); void notify_model_dirty() noexcept; @@ -293,13 +293,13 @@ private: class Renderable_Edit_Transaction; struct Render_Completion { - Scene_Render_Error error{}; + Scene_Render_Result error{}; std::exception_ptr exception; bool completed{}; bool observed{}; }; - [[nodiscard]] Scene_Render_Error submit_render(Abstract_Frame* frame); + [[nodiscard]] Scene_Render_Result submit_render(Abstract_Frame* frame); void submit_operation(std::function operation); void complete_pending_operation(); void record_pending_exception(std::exception_ptr exception); @@ -313,7 +313,7 @@ private: const Frame_Render_Snapshot& snapshot); void execute_render_task(std::shared_ptr task); [[nodiscard]] Scene_Edit_Error execute_renderable_edit(std::function edit); - [[nodiscard]] Scene_Render_Error execute_render_graph(Render_Task& task); + [[nodiscard]] Scene_Render_Result execute_render_graph(Render_Task& task); [[nodiscard]] Scene_Edit_Error renderable_scene_error(const Renderable_Base& renderable) const noexcept; [[nodiscard]] bool is_renderable_attached_locked( const Renderable& renderable) const; diff --git a/Kernel/src/renderive/scene/base/Scene_Lifetime.hpp b/Kernel/src/renderive/scene/base/Scene_Lifetime.hpp index 10cc3ae..b16bc91 100644 --- a/Kernel/src/renderive/scene/base/Scene_Lifetime.hpp +++ b/Kernel/src/renderive/scene/base/Scene_Lifetime.hpp @@ -12,7 +12,7 @@ public: Lease(const Lease&) = delete; Lease& operator=(const Lease&) = delete; Lease(Lease&& other) noexcept : owner_(std::exchange(other.owner_, nullptr)), scene_(std::exchange(other.scene_, nullptr)) {} - Lease& operator=(Lease&& other) noexcept { + Lease& operator=(Lease&& other) { if (this == &other) { return *this; } @@ -21,7 +21,7 @@ public: scene_ = std::exchange(other.scene_, nullptr); return *this; } - ~Lease() { + ~Lease() noexcept(false) { release(); } explicit operator bool() const noexcept { @@ -33,7 +33,7 @@ public: private: friend class Scene_Lifetime; Lease(Scene_Lifetime* owner, Scene_Base* scene) noexcept : owner_(owner), scene_(scene) {} - void release() noexcept { + void release() { if (!owner_) { return; } @@ -45,7 +45,7 @@ public: Scene_Base* scene_{}; }; explicit Scene_Lifetime(Scene_Base& scene) noexcept : scene_(&scene) {} - Lease acquire() noexcept { + Lease acquire() { std::lock_guard lock(mutex_); if (!scene_) { return {}; @@ -53,7 +53,7 @@ public: ++lease_count_; return Lease(this, scene_); } - void invalidate() noexcept { + void invalidate() { std::unique_lock lock(mutex_); scene_ = nullptr; condition_.wait(lock, [this] { @@ -61,7 +61,7 @@ public: }); } private: - void release() noexcept { + void release() { std::lock_guard lock(mutex_); --lease_count_; if (lease_count_ == 0) { diff --git a/Kernel/src/renderive/scene/concept/Scene.hpp b/Kernel/src/renderive/scene/concept/Scene.hpp index 8a0a0c6..8379c2d 100644 --- a/Kernel/src/renderive/scene/concept/Scene.hpp +++ b/Kernel/src/renderive/scene/concept/Scene.hpp @@ -5,8 +5,8 @@ template concept Scene = std::derived_from && requires(That& scene, const That& const_scene) { { scene.frame_control_strategy() } -> std::same_as; { const_scene.frame_control_strategy() } -> std::same_as; - { scene.render() } -> std::same_as; - { scene.wait_for_render() } -> std::same_as; + { scene.render() } -> std::same_as; + { scene.wait_for_render() } -> std::same_as; }; template concept Scene_2D = Scene && std::derived_from; diff --git a/Kernel/tests/renderive/frame_control/strategy/manual/Manual_Refresh_Strategy_Test.cpp b/Kernel/tests/renderive/frame_control/strategy/manual/Manual_Refresh_Strategy_Test.cpp index 3c7da23..025f9c9 100644 --- a/Kernel/tests/renderive/frame_control/strategy/manual/Manual_Refresh_Strategy_Test.cpp +++ b/Kernel/tests/renderive/frame_control/strategy/manual/Manual_Refresh_Strategy_Test.cpp @@ -21,7 +21,7 @@ TEST(manual_refresh_strategy_test, publishes_only_after_manual_refresh) { auto frame = strategy.acquire_renderer(); EXPECT_FALSE(frame); } - EXPECT_EQ(strategy.refresh(), Manual_Refresh_Error::none); + EXPECT_EQ(strategy.refresh(), Manual_Refresh_Result::none); { auto frame = strategy.acquire_renderer(); ASSERT_TRUE(frame); @@ -39,14 +39,14 @@ TEST(manual_refresh_strategy_test, keeps_latest_prepared_frame) { frame->value = 2; } EXPECT_EQ(strategy.state().replaced_prepared_frame_count, 1); - ASSERT_EQ(strategy.refresh(), Manual_Refresh_Error::none); + ASSERT_EQ(strategy.refresh(), Manual_Refresh_Result::none); auto frame = strategy.acquire_renderer(); ASSERT_TRUE(frame); EXPECT_EQ(frame->value, 2); } TEST(manual_refresh_strategy_test, reports_failed_refresh_without_pending_frame) { Manual_Refresh_Test_Strategy strategy; - EXPECT_EQ(strategy.refresh(), Manual_Refresh_Error::no_pending_frame); + EXPECT_EQ(strategy.refresh(), Manual_Refresh_Result::no_pending_frame); EXPECT_EQ(strategy.state().failed_refresh_count, 1); } struct Manual_Refresh_Reentrant_Observer_Data { @@ -82,7 +82,7 @@ TEST(manual_refresh_strategy_test, refresh_observer_can_acquire_renderer_without observed_value.store(frame->value, std::memory_order_release); } }; - EXPECT_EQ(strategy.refresh(), Manual_Refresh_Error::none); + EXPECT_EQ(strategy.refresh(), Manual_Refresh_Result::none); EXPECT_EQ(observed_value.load(std::memory_order_acquire), 42); } diff --git a/Kernel/tests/renderive/render_graph/Render_Graph_Runtime_Test.cpp b/Kernel/tests/renderive/render_graph/Render_Graph_Runtime_Test.cpp index 078f4ab..d60a21d 100644 --- a/Kernel/tests/renderive/render_graph/Render_Graph_Runtime_Test.cpp +++ b/Kernel/tests/renderive/render_graph/Render_Graph_Runtime_Test.cpp @@ -52,7 +52,7 @@ TEST(external_operation_test, completion_before_subscription_is_delivered_once) int completion_count{}; operation.on_complete([&](External_Operation_Completion completion) { - EXPECT_EQ(completion.error, External_Operation_Error::none); + EXPECT_EQ(completion.result, External_Operation_Result::none); EXPECT_FALSE(completion.exception); ++completion_count; }); @@ -84,8 +84,8 @@ TEST(render_graph_runtime_test, reusable_topology_executes_multiple_frames) { ++execution_count.at(index); return Node_Execution_Result::completed(); }; - EXPECT_EQ(runtime.execute({}, execute_node), renderive::render_graph::detail::Render_Graph_Execution_Error::none); - EXPECT_EQ(runtime.execute({}, execute_node), renderive::render_graph::detail::Render_Graph_Execution_Error::none); + EXPECT_EQ(runtime.execute({}, execute_node), renderive::render_graph::detail::Render_Graph_Execution_Result::none); + EXPECT_EQ(runtime.execute({}, execute_node), renderive::render_graph::detail::Render_Graph_Execution_Result::none); EXPECT_EQ(execution_count[0], 2U); EXPECT_EQ(execution_count[1], 2U); } @@ -110,14 +110,14 @@ TEST(render_graph_runtime_test, return Node_Execution_Result::completed(); }; - auto graph_error = renderive::render_graph::detail::Render_Graph_Execution_Error::none; + auto graph_error = renderive::render_graph::detail::Render_Graph_Execution_Result::none; std::thread execution([&] { graph_error = runtime.execute(slots, execute_node); }); submit_started.wait(false, std::memory_order_acquire); EXPECT_FALSE(publish_executed.load(std::memory_order_acquire)); EXPECT_TRUE(source.complete()); execution.join(); - EXPECT_EQ(graph_error, renderive::render_graph::detail::Render_Graph_Execution_Error::none); + EXPECT_EQ(graph_error, renderive::render_graph::detail::Render_Graph_Execution_Result::none); EXPECT_TRUE(publish_executed.load(std::memory_order_acquire)); EXPECT_EQ(execution_storage[0].status, Node_Execution_Status::complete); EXPECT_EQ(execution_storage[1].status, Node_Execution_Status::complete); @@ -181,7 +181,7 @@ TEST(render_graph_runtime_test, return Node_Execution_Result::external(source.operation()); }; - auto graph_error = renderive::render_graph::detail::Render_Graph_Execution_Error::none; + auto graph_error = renderive::render_graph::detail::Render_Graph_Execution_Result::none; std::thread execution([&] { graph_error = runtime.execute({}, execute_node); }); external_started.wait(false, std::memory_order_acquire); renderive::scheduling::detail::OneTBB_Runtime::instance().enqueue([&] { @@ -198,7 +198,7 @@ TEST(render_graph_runtime_test, } EXPECT_TRUE(source.complete()); execution.join(); - EXPECT_EQ(graph_error, renderive::render_graph::detail::Render_Graph_Execution_Error::none); + EXPECT_EQ(graph_error, renderive::render_graph::detail::Render_Graph_Execution_Result::none); } TEST(external_operation_test, cancellation_is_terminal_and_delivered_once) { @@ -215,7 +215,7 @@ TEST(external_operation_test, cancellation_is_terminal_and_delivered_once) { ++completion_count; }); EXPECT_EQ(completion_count, 1); - EXPECT_EQ(completion.error, External_Operation_Error::cancelled); + EXPECT_EQ(completion.result, External_Operation_Result::cancelled); EXPECT_FALSE(completion.exception); } @@ -240,7 +240,7 @@ TEST(external_operation_test, deadline_cancels_pending_operation) { ASSERT_TRUE(condition.wait_for(lock, std::chrono::seconds(1), [&] { return completed; })); } - EXPECT_EQ(completion.error, External_Operation_Error::deadline_exceeded); + EXPECT_EQ(completion.result, External_Operation_Result::deadline_exceeded); EXPECT_FALSE(completion.exception); EXPECT_EQ(operation.status(), External_Operation_Status::cancelled); } @@ -253,7 +253,7 @@ TEST(render_graph_runtime_test, auto slots = execution_slots(*plan, execution_storage); std::atomic submit_started{}; std::atomic publish_executed{}; - auto graph_error = renderive::render_graph::detail::Render_Graph_Execution_Error::none; + auto graph_error = renderive::render_graph::detail::Render_Graph_Execution_Result::none; renderive::render_graph::detail::Render_Graph_Runtime runtime(*plan); const auto execute_node = [&](std::size_t index, Node_Execution_Metrics*) { @@ -273,7 +273,7 @@ TEST(render_graph_runtime_test, runtime.cancel_pending(); execution.join(); - EXPECT_EQ(graph_error, renderive::render_graph::detail::Render_Graph_Execution_Error::cancelled); + EXPECT_EQ(graph_error, renderive::render_graph::detail::Render_Graph_Execution_Result::cancelled); EXPECT_FALSE(publish_executed.load(std::memory_order_acquire)); EXPECT_EQ(execution_storage[0].status, Node_Execution_Status::cancelled); EXPECT_EQ(source.operation().status(), External_Operation_Status::cancelled); @@ -292,7 +292,7 @@ TEST(render_graph_runtime_test, idle_cancellation_does_not_arm_next_execution) { executed.fetch_add(1, std::memory_order_relaxed); return Node_Execution_Result::completed(); }), - renderive::render_graph::detail::Render_Graph_Execution_Error::none); + renderive::render_graph::detail::Render_Graph_Execution_Result::none); EXPECT_EQ(executed.load(std::memory_order_relaxed), 2); EXPECT_EQ(execution_storage[0].status, Node_Execution_Status::complete); @@ -316,7 +316,7 @@ TEST(external_operation_test, completion_commit_precedes_completion_notification std::atomic published{}; int observed{}; operation.on_complete([&](External_Operation_Completion completion) { - EXPECT_EQ(completion.error, External_Operation_Error::none); + EXPECT_EQ(completion.result, External_Operation_Result::none); EXPECT_FALSE(completion.exception); observed = published.load(std::memory_order_acquire); }); @@ -338,7 +338,7 @@ TEST(external_operation_test, completion_commit_failure_fails_operation) { }); EXPECT_TRUE(source.complete([] { throw std::runtime_error("publish failed"); })); - EXPECT_EQ(completion.error, External_Operation_Error::none); + EXPECT_EQ(completion.result, External_Operation_Result::none); ASSERT_TRUE(completion.exception); EXPECT_THROW(std::rethrow_exception(completion.exception), std::runtime_error); EXPECT_EQ(operation.status(), External_Operation_Status::failed); diff --git a/Project_naming_conventions.md b/Project_naming_conventions.md index 2dac19b..c6c047d 100644 --- a/Project_naming_conventions.md +++ b/Project_naming_conventions.md @@ -4,7 +4,7 @@ ```cpp Scene_Base -Frame_Request_Error +Frame_Request_Result Renderable_Id ``` @@ -26,7 +26,7 @@ pending_exception_ * 枚举值：`lower_snake_case` ```cpp -enum class Frame_Request_Error { +enum class Frame_Request_Result { none, cancelled, renderer_unavailable diff --git a/Qt/plot/Explicit_Plot.cpp b/Qt/plot/Explicit_Plot.cpp index 208ec1d..d268b37 100644 --- a/Qt/plot/Explicit_Plot.cpp +++ b/Qt/plot/Explicit_Plot.cpp @@ -8,7 +8,7 @@ Explicit_Plot::Explicit_Plot() : Abs_Plot(new Abs_Plot_Private(false)) {} Render_Ticket Explicit_Plot::replot() { - return {d->scene->render_frame(true) == Plot_Render_Error::none}; + return {d->scene->render_frame(true) == Plot_Render_Result::none}; } } // namespace renderive diff --git a/Qt/plot/Plot.cpp b/Qt/plot/Plot.cpp index 7f903e0..c626944 100644 --- a/Qt/plot/Plot.cpp +++ b/Qt/plot/Plot.cpp @@ -46,8 +46,8 @@ void Abs_Plot_Private::attach_widget(Abs_Plot* plot) { if (!scene->view_active()) return; const auto error = scene->render_frame(); - if (error == Plot_Render_Error::external_failure || - error == Plot_Render_Error::scene_shutting_down) + if (error == Plot_Render_Result::external_failure || + error == Plot_Render_Result::scene_shutting_down) timer->stop(); }); } diff --git a/render_2D/render_2D/renderable/Renderable.cpp b/render_2D/render_2D/renderable/Renderable.cpp index 91a1f6b..ec4c29b 100644 --- a/render_2D/render_2D/renderable/Renderable.cpp +++ b/render_2D/render_2D/renderable/Renderable.cpp @@ -25,7 +25,7 @@ void Renderable::set_cache_mode(Renderable_Cache_Mode mode) { d_func().set_configuration( {.cache_enabled = mode == Renderable_Cache_Mode::Local_Pixel}); } -Renderable_Observation Renderable::observation() const noexcept { +Renderable_Observation Renderable::observation() const { const auto& d = d_func(); std::lock_guard lock(d.observation_mutex); return d.observation; @@ -94,7 +94,7 @@ void Renderable::Impl::observe_state( } void Renderable::Impl::observe_data( std::uint64_t revision, std::size_t item_count, - std::size_t auxiliary_item_count) noexcept { + std::size_t auxiliary_item_count) { std::lock_guard lock(observation_mutex); observation.data_revision = revision; observation.item_count = item_count; diff --git a/render_2D/render_2D/renderable/Renderable.h b/render_2D/render_2D/renderable/Renderable.h index 3fdb36e..4f88273 100644 --- a/render_2D/render_2D/renderable/Renderable.h +++ b/render_2D/render_2D/renderable/Renderable.h @@ -39,7 +39,7 @@ struct LIB_DECL Renderable ~Renderable() override; [[nodiscard]] Renderable_Cache_Mode get_cache_mode() const noexcept; void set_cache_mode(Renderable_Cache_Mode mode); - [[nodiscard]] Renderable_Observation observation() const noexcept; + [[nodiscard]] Renderable_Observation observation() const; void dispatch_event(const Event& event); protected: struct Impl; diff --git a/render_2D/render_2D/renderable/Renderable_p.h b/render_2D/render_2D/renderable/Renderable_p.h index 1580863..b67278a 100644 --- a/render_2D/render_2D/renderable/Renderable_p.h +++ b/render_2D/render_2D/renderable/Renderable_p.h @@ -70,7 +70,7 @@ protected: dispatch(detail::renderable_event_view(payload, time_ns)); } void observe_data(std::uint64_t revision, std::size_t item_count, - std::size_t auxiliary_item_count = 0) noexcept; + std::size_t auxiliary_item_count = 0); using Prepare_Task_Function = std::function; using Paint_Task_Function = diff --git a/render_2D/render_2D/scene/Plot_Scene.cpp b/render_2D/render_2D/scene/Plot_Scene.cpp index 39cddbf..1cff1b6 100644 --- a/render_2D/render_2D/scene/Plot_Scene.cpp +++ b/render_2D/render_2D/scene/Plot_Scene.cpp @@ -93,7 +93,7 @@ void Plot_Scene::set_background_color(Color color) { impl_->apply([color](auto& scene) { scene.set_background_color(color); }); } -Color Plot_Scene::background_color() const noexcept { +Color Plot_Scene::background_color() const { return impl_->apply([](const auto& scene) { return scene.background_color(); }); } @@ -101,7 +101,7 @@ void Plot_Scene::set_viewport_size(Size size) { impl_->apply([size](auto& scene) { scene.set_viewport_size(size); }); } -Size Plot_Scene::viewport_size() const noexcept { +Size Plot_Scene::viewport_size() const { return impl_->apply([](const auto& scene) { return scene.viewport_size(); }); } @@ -109,15 +109,15 @@ void Plot_Scene::dispatch_event(const Event& event) { impl_->apply([&event](auto& scene) { scene.dispatch_event(event); }); } -Plot_Render_Error Plot_Scene::prepare_frame() { +Plot_Render_Result Plot_Scene::prepare_frame() { return impl_->apply([](auto& scene) { return scene.prepare_frame(); }); } -Plot_Render_Error Plot_Scene::refresh_manual_frame() { +Plot_Render_Result Plot_Scene::refresh_manual_frame() { return impl_->apply([](auto& scene) { return scene.refresh_manual_frame(); }); } -Plot_Render_Error Plot_Scene::render_prepared_frame() { +Plot_Render_Result Plot_Scene::render_prepared_frame() { return impl_->apply([](auto& scene) { return scene.render_prepared_frame(); }); } @@ -125,7 +125,7 @@ bool Plot_Scene::discard_pending_frame() { return impl_->apply([](auto& scene) { return scene.discard_pending_frame(); }); } -Plot_Render_Error Plot_Scene::render_frame(bool force) { +Plot_Render_Result Plot_Scene::render_frame(bool force) { return impl_->apply([force](auto& scene) { return scene.render_frame(force); }); } @@ -133,7 +133,7 @@ void Plot_Scene::with_frame(const std::function& consumer) { impl_->apply([&consumer](auto& scene) { scene.with_frame(consumer); }); } -void Plot_Scene::activate_view() noexcept { +void Plot_Scene::activate_view() { impl_->apply([](auto& scene) { scene.activate_view(); }); } @@ -154,7 +154,7 @@ Plot_Control_Error Plot_Scene::clear_max_render_fps() { return impl_->apply([](auto& scene) { return scene.clear_max_render_fps(); }); } -double Plot_Scene::max_render_fps() const noexcept { +double Plot_Scene::max_render_fps() const { return impl_->apply([](const auto& scene) { return scene.max_render_fps(); }); } diff --git a/render_2D/render_2D/scene/Plot_Scene.h b/render_2D/render_2D/scene/Plot_Scene.h index de38fcd..5a276de 100644 --- a/render_2D/render_2D/scene/Plot_Scene.h +++ b/render_2D/render_2D/scene/Plot_Scene.h @@ -27,7 +27,7 @@ enum class Plot_Control_Error : std::uint8_t { invalid_max_render_fps, invalid_consumer_feedback }; -enum class Plot_Render_Error : std::uint8_t { +enum class Plot_Render_Result : std::uint8_t { none, view_inactive, empty_viewport, @@ -65,26 +65,26 @@ public: [[nodiscard]] const Scene_Base& render_scene() const noexcept; void set_background_color(Color color); - [[nodiscard]] Color background_color() const noexcept; + [[nodiscard]] Color background_color() const; void set_viewport_size(Size size); - [[nodiscard]] Size viewport_size() const noexcept; + [[nodiscard]] Size viewport_size() const; void dispatch_event(const Event& event); - [[nodiscard]] Plot_Render_Error prepare_frame(); - [[nodiscard]] Plot_Render_Error refresh_manual_frame(); - [[nodiscard]] Plot_Render_Error render_prepared_frame(); + [[nodiscard]] Plot_Render_Result prepare_frame(); + [[nodiscard]] Plot_Render_Result refresh_manual_frame(); + [[nodiscard]] Plot_Render_Result render_prepared_frame(); [[nodiscard]] bool discard_pending_frame(); - [[nodiscard]] Plot_Render_Error render_frame(bool force = false); + [[nodiscard]] Plot_Render_Result render_frame(bool force = false); void with_frame(const std::function& consumer); - void activate_view() noexcept; + void activate_view(); void deactivate_view() noexcept; [[nodiscard]] bool view_active() const noexcept; void request_redraw() noexcept; [[nodiscard]] Plot_Control_Error set_max_render_fps(double fps); [[nodiscard]] Plot_Control_Error clear_max_render_fps(); - [[nodiscard]] double max_render_fps() const noexcept; + [[nodiscard]] double max_render_fps() const; [[nodiscard]] Plot_Control_Error set_consumer_feedback(Frame_Consumer_Feedback feedback); [[nodiscard]] Plot_Control_Error clear_consumer_feedback(); diff --git a/render_2D/render_2D/scene/detail/Plot_Scene_Model.hpp b/render_2D/render_2D/scene/detail/Plot_Scene_Model.hpp index 11ff7da..9376868 100644 --- a/render_2D/render_2D/scene/detail/Plot_Scene_Model.hpp +++ b/render_2D/render_2D/scene/detail/Plot_Scene_Model.hpp @@ -149,7 +149,7 @@ struct Plot_Scene_Model final : ::Scene2D_Context(*this).template set<&Scene_State::background>(color); this->notify_model_dirty(); } - [[nodiscard]] Color background_color() const noexcept { + [[nodiscard]] Color background_color() const { return static_cast(*this).template get<&Scene_State::background>(); } void set_viewport_size(Size size) { @@ -161,7 +161,7 @@ struct Plot_Scene_Model final : ::Scene2D_Context(*this).template set<&Scene_State::viewport>(viewport); this->invalidate_renderables(); } - [[nodiscard]] Size viewport_size() const noexcept { + [[nodiscard]] Size viewport_size() const { const auto viewport = static_cast(*this).template get<&Scene_State::viewport>(); return {viewport.width, viewport.height}; } @@ -178,36 +178,36 @@ struct Plot_Scene_Model final : ::Scene2D_Contextframe_control.acquire_painter(); if (!paint_frame) - return Plot_Render_Error::painter_unavailable; + return Plot_Render_Result::painter_unavailable; this->publish_frame_state(*paint_frame); - return Plot_Render_Error::none; + return Plot_Render_Result::none; } - [[nodiscard]] Plot_Render_Error refresh_manual_frame() { + [[nodiscard]] Plot_Render_Result refresh_manual_frame() { if constexpr (Mode == Plot_Frame_Mode::Manual) { - return this->frame_control.refresh() == Manual_Refresh_Error::none - ? Plot_Render_Error::none - : Plot_Render_Error::no_pending_frame; + return this->frame_control.refresh() == Manual_Refresh_Result::none + ? Plot_Render_Result::none + : Plot_Render_Result::no_pending_frame; } - return Plot_Render_Error::manual_refresh_not_supported; + return Plot_Render_Result::manual_refresh_not_supported; } - [[nodiscard]] Plot_Render_Error render_prepared_frame() { + [[nodiscard]] Plot_Render_Result render_prepared_frame() { auto render_frame = this->frame_control.acquire_renderer(); if (!render_frame) - return Plot_Render_Error::renderer_unavailable; + return Plot_Render_Result::renderer_unavailable; switch (Scene_Base::render(*render_frame)) { - case Scene_Render_Error::none: - return Plot_Render_Error::none; - case Scene_Render_Error::cancelled: - return Plot_Render_Error::cancelled; - case Scene_Render_Error::deadline_exceeded: - return Plot_Render_Error::deadline_exceeded; - case Scene_Render_Error::external_failure: - return Plot_Render_Error::external_failure; - case Scene_Render_Error::shutting_down: - return Plot_Render_Error::scene_shutting_down; + case Scene_Render_Result::none: + return Plot_Render_Result::none; + case Scene_Render_Result::cancelled: + return Plot_Render_Result::cancelled; + case Scene_Render_Result::deadline_exceeded: + return Plot_Render_Result::deadline_exceeded; + case Scene_Render_Result::external_failure: + return Plot_Render_Result::external_failure; + case Scene_Render_Result::shutting_down: + return Plot_Render_Result::scene_shutting_down; } ::renderive::error::unexpected("unknown scene render error"); } @@ -217,25 +217,25 @@ struct Plot_Scene_Model final : ::Scene2D_Contextframe_control.discard_pending_frame(); } - [[nodiscard]] Plot_Render_Error render_frame(bool force = false) { + [[nodiscard]] Plot_Render_Result render_frame(bool force = false) { if (!view_active() && !force) - return Plot_Render_Error::view_inactive; + return Plot_Render_Result::view_inactive; if (viewport_size().empty()) - return Plot_Render_Error::empty_viewport; + return Plot_Render_Result::empty_viewport; if (!this->consume_model_dirty() && !force) - return Plot_Render_Error::model_unchanged; + return Plot_Render_Result::model_unchanged; const auto started = std::chrono::steady_clock::now(); Size viewport; try { - if (const auto error = prepare_frame(); error != Plot_Render_Error::none) + if (const auto error = prepare_frame(); error != Plot_Render_Result::none) return error; const auto frame_viewport = this->Scene_State_Strategy::render_state_value().viewport; viewport = {frame_viewport.width, frame_viewport.height}; if constexpr (Mode == Plot_Frame_Mode::Manual) { - if (const auto error = refresh_manual_frame(); error != Plot_Render_Error::none) + if (const auto error = refresh_manual_frame(); error != Plot_Render_Result::none) return error; } - if (const auto error = render_prepared_frame(); error != Plot_Render_Error::none) + if (const auto error = render_prepared_frame(); error != Plot_Render_Result::none) return error; } catch (...) { @@ -256,7 +256,7 @@ struct Plot_Scene_Model final : ::Scene2D_Contextrenderable_count(), viewport); if (sink) sink->request_present(detail::full_rect(viewport)); - return Plot_Render_Error::none; + return Plot_Render_Result::none; } void with_frame(const std::function& consumer) { if (!consumer) @@ -265,7 +265,7 @@ struct Plot_Scene_Model final : ::Scene2D_Contextnotify_model_dirty(); } @@ -314,7 +314,7 @@ struct Plot_Scene_Model final : ::Scene2D_Contextframe_control.state().frequency_hz; return std::numeric_limits::quiet_NaN(); diff --git a/render_2D/tests/render_2D_Frame_Pipeline_Tests.cpp b/render_2D/tests/render_2D_Frame_Pipeline_Tests.cpp index 3fb2882..62cf944 100644 --- a/render_2D/tests/render_2D_Frame_Pipeline_Tests.cpp +++ b/render_2D/tests/render_2D_Frame_Pipeline_Tests.cpp @@ -9,7 +9,7 @@ TEST(Renderive_Core2_Frame_Pipeline, ManualLifecycleSeparatesPrepareRefreshAndRe Plot_Scene plot({.frame_mode = Plot_Frame_Mode::Manual}); plot.init(); plot.set_viewport_size({96, 54}); - ASSERT_EQ(plot.prepare_frame(), Plot_Render_Error::none); + ASSERT_EQ(plot.prepare_frame(), Plot_Render_Result::none); auto snapshot = plot.frame_status(); EXPECT_EQ(snapshot.mode, Plot_Frame_Mode::Manual); EXPECT_EQ(snapshot.last_event, "prepared"); @@ -18,14 +18,14 @@ TEST(Renderive_Core2_Frame_Pipeline, ManualLifecycleSeparatesPrepareRefreshAndRe EXPECT_EQ(snapshot.consumed_frame_count, 0u); EXPECT_EQ(snapshot.pending_frame_count, 1u); EXPECT_EQ(snapshot.latest_sequence, 1u); - ASSERT_EQ(plot.refresh_manual_frame(), Plot_Render_Error::none); + ASSERT_EQ(plot.refresh_manual_frame(), Plot_Render_Result::none); snapshot = plot.frame_status(); EXPECT_EQ(snapshot.last_event, "refresh_succeeded"); EXPECT_EQ(snapshot.produced_frame_count, 1u); EXPECT_EQ(snapshot.consumed_frame_count, 0u); EXPECT_EQ(snapshot.pending_frame_count, 0u); EXPECT_EQ(snapshot.latest_sequence, 1u); - ASSERT_EQ(plot.render_prepared_frame(), Plot_Render_Error::none); + ASSERT_EQ(plot.render_prepared_frame(), Plot_Render_Result::none); snapshot = plot.frame_status(); EXPECT_EQ(snapshot.last_event, "rendered"); EXPECT_EQ(snapshot.produced_frame_count, 1u); @@ -39,7 +39,7 @@ TEST(Renderive_Core2_Frame_Pipeline, HighFrequencyLowLatencyLifecycleExposesKern plot.init(); plot.set_viewport_size({96, 54}); EXPECT_EQ(plot.set_max_render_fps(1'000'000'000.0), Plot_Control_Error::none); - ASSERT_EQ(plot.prepare_frame(), Plot_Render_Error::none); + ASSERT_EQ(plot.prepare_frame(), Plot_Render_Result::none); auto snapshot = plot.frame_status(); EXPECT_EQ(snapshot.last_event, "published"); EXPECT_EQ(snapshot.limit_state, "frequency_limited"); @@ -48,7 +48,7 @@ TEST(Renderive_Core2_Frame_Pipeline, HighFrequencyLowLatencyLifecycleExposesKern EXPECT_EQ(snapshot.produced_frame_count, 1u); EXPECT_EQ(snapshot.consumed_frame_count, 0u); EXPECT_EQ(snapshot.pending_frame_count, 1u); - ASSERT_EQ(plot.render_prepared_frame(), Plot_Render_Error::none); + ASSERT_EQ(plot.render_prepared_frame(), Plot_Render_Result::none); snapshot = plot.frame_status(); EXPECT_EQ(snapshot.last_event, "lifecycle_completed"); EXPECT_DOUBLE_EQ(snapshot.frequency_hz, 1'000'000'000.0); @@ -73,8 +73,8 @@ TEST(Renderive_Core2_Frame_Pipeline, LowLatencyConsumerFeedbackFlowsThroughCore2 plot.set_viewport_size({96, 54}); EXPECT_EQ(plot.set_max_render_fps(100.0), Plot_Control_Error::none); EXPECT_EQ(plot.set_consumer_feedback({40'000'000}), Plot_Control_Error::none); - ASSERT_EQ(plot.prepare_frame(), Plot_Render_Error::none); - ASSERT_EQ(plot.render_prepared_frame(), Plot_Render_Error::none); + ASSERT_EQ(plot.prepare_frame(), Plot_Render_Result::none); + ASSERT_EQ(plot.render_prepared_frame(), Plot_Render_Result::none); const auto snapshot = plot.frame_status(); EXPECT_TRUE(snapshot.frequency_limit_enabled); EXPECT_TRUE(snapshot.consumer_feedback_enabled); @@ -96,8 +96,8 @@ TEST(Renderive_Core2_Frame_Pipeline, LowLatencyLimitsCanBeClearedIndependently) EXPECT_EQ(plot.set_consumer_feedback({40'000'000}), Plot_Control_Error::none); plot.clear_consumer_feedback(); plot.clear_max_render_fps(); - ASSERT_EQ(plot.prepare_frame(), Plot_Render_Error::none); - ASSERT_EQ(plot.render_prepared_frame(), Plot_Render_Error::none); + ASSERT_EQ(plot.prepare_frame(), Plot_Render_Result::none); + ASSERT_EQ(plot.render_prepared_frame(), Plot_Render_Result::none); const auto snapshot = plot.frame_status(); EXPECT_FALSE(snapshot.frequency_limit_enabled); EXPECT_FALSE(snapshot.consumer_feedback_enabled); @@ -110,15 +110,15 @@ TEST(Renderive_Core2_Frame_Pipeline, LowLatencyReplacementRetiresOldFrameWithout Plot_Scene plot; plot.init(); plot.set_viewport_size({64, 40}); - ASSERT_EQ(plot.prepare_frame(), Plot_Render_Error::none); - ASSERT_EQ(plot.prepare_frame(), Plot_Render_Error::none); + ASSERT_EQ(plot.prepare_frame(), Plot_Render_Result::none); + ASSERT_EQ(plot.prepare_frame(), Plot_Render_Result::none); auto snapshot = plot.frame_status(); EXPECT_EQ(snapshot.last_event, "published"); EXPECT_EQ(snapshot.produced_frame_count, 2u); EXPECT_EQ(snapshot.dropped_frame_count, 1u); EXPECT_EQ(snapshot.pending_frame_count, 1u); EXPECT_EQ(snapshot.latest_sequence, 2u); - ASSERT_EQ(plot.render_prepared_frame(), Plot_Render_Error::none); + ASSERT_EQ(plot.render_prepared_frame(), Plot_Render_Result::none); snapshot = plot.frame_status(); EXPECT_EQ(snapshot.last_event, "lifecycle_completed"); EXPECT_EQ(snapshot.produced_frame_count, 2u); @@ -131,7 +131,7 @@ TEST(Renderive_Core2_Frame_Pipeline, LowLatencyDiscardAndEmptyRenderRemainObserv Plot_Scene plot; plot.init(); plot.set_viewport_size({64, 40}); - ASSERT_EQ(plot.prepare_frame(), Plot_Render_Error::none); + ASSERT_EQ(plot.prepare_frame(), Plot_Render_Result::none); ASSERT_TRUE(plot.discard_pending_frame()); auto snapshot = plot.frame_status(); EXPECT_EQ(snapshot.last_event, "manually_discarded"); @@ -140,7 +140,7 @@ TEST(Renderive_Core2_Frame_Pipeline, LowLatencyDiscardAndEmptyRenderRemainObserv EXPECT_EQ(snapshot.dropped_frame_count, 1u); EXPECT_EQ(snapshot.pending_frame_count, 0u); EXPECT_EQ(snapshot.latest_sequence, 1u); - EXPECT_NE(plot.render_prepared_frame(), Plot_Render_Error::none); + EXPECT_NE(plot.render_prepared_frame(), Plot_Render_Result::none); snapshot = plot.frame_status(); EXPECT_EQ(snapshot.last_event, "swap_failed"); EXPECT_EQ(snapshot.failed_operation_count, 1u); @@ -151,7 +151,7 @@ TEST(Renderive_Core2_Frame_Pipeline, ManualDiscardAndFailedRefreshUpdateObserver Plot_Scene plot({.frame_mode = Plot_Frame_Mode::Manual}); plot.init(); plot.set_viewport_size({64, 40}); - ASSERT_EQ(plot.prepare_frame(), Plot_Render_Error::none); + ASSERT_EQ(plot.prepare_frame(), Plot_Render_Result::none); ASSERT_TRUE(plot.discard_pending_frame()); auto snapshot = plot.frame_status(); EXPECT_EQ(snapshot.last_event, "manually_discarded"); @@ -160,7 +160,7 @@ TEST(Renderive_Core2_Frame_Pipeline, ManualDiscardAndFailedRefreshUpdateObserver EXPECT_EQ(snapshot.pending_frame_count, 0u); EXPECT_EQ(snapshot.latest_sequence, 1u); const auto last_paint_duration_ns = snapshot.paint_duration_ns; - EXPECT_NE(plot.refresh_manual_frame(), Plot_Render_Error::none); + EXPECT_NE(plot.refresh_manual_frame(), Plot_Render_Result::none); snapshot = plot.frame_status(); EXPECT_EQ(snapshot.last_event, "refresh_failed"); EXPECT_EQ(snapshot.failed_operation_count, 1u); @@ -172,16 +172,16 @@ TEST(Renderive_Core2_Frame_Pipeline, PlaybackPreservesQueueDepthAndEmptyAcquireF Plot_Scene plot({.frame_mode = Plot_Frame_Mode::Playback}); plot.init(); plot.set_viewport_size({64, 40}); - ASSERT_EQ(plot.prepare_frame(), Plot_Render_Error::none); - ASSERT_EQ(plot.prepare_frame(), Plot_Render_Error::none); - ASSERT_EQ(plot.prepare_frame(), Plot_Render_Error::none); + ASSERT_EQ(plot.prepare_frame(), Plot_Render_Result::none); + ASSERT_EQ(plot.prepare_frame(), Plot_Render_Result::none); + ASSERT_EQ(plot.prepare_frame(), Plot_Render_Result::none); auto snapshot = plot.frame_status(); EXPECT_EQ(snapshot.produced_frame_count, 3u); EXPECT_EQ(snapshot.pending_frame_count, 3u); EXPECT_EQ(snapshot.latest_sequence, 3u); - ASSERT_EQ(plot.render_prepared_frame(), Plot_Render_Error::none); - ASSERT_EQ(plot.render_prepared_frame(), Plot_Render_Error::none); - ASSERT_EQ(plot.render_prepared_frame(), Plot_Render_Error::none); + ASSERT_EQ(plot.render_prepared_frame(), Plot_Render_Result::none); + ASSERT_EQ(plot.render_prepared_frame(), Plot_Render_Result::none); + ASSERT_EQ(plot.render_prepared_frame(), Plot_Render_Result::none); snapshot = plot.frame_status(); EXPECT_EQ(snapshot.last_event, "rendered"); EXPECT_EQ(snapshot.consumed_frame_count, 3u); @@ -190,7 +190,7 @@ TEST(Renderive_Core2_Frame_Pipeline, PlaybackPreservesQueueDepthAndEmptyAcquireF const auto last_paint_duration_ns = snapshot.paint_duration_ns; const auto last_render_duration_ns = snapshot.render_duration_ns; const auto last_queue_wait_ns = snapshot.queue_wait_ns; - EXPECT_NE(plot.render_prepared_frame(), Plot_Render_Error::none); + EXPECT_NE(plot.render_prepared_frame(), Plot_Render_Result::none); snapshot = plot.frame_status(); EXPECT_EQ(snapshot.last_event, "queue_empty"); EXPECT_EQ(snapshot.failed_operation_count, 1u); @@ -204,13 +204,13 @@ TEST(Renderive_Core2_Frame_Pipeline, PlaybackFullCyclePreservesPreviouslyQueuedF Plot_Scene plot({.frame_mode = Plot_Frame_Mode::Playback}); plot.init(); plot.set_viewport_size({96, 54}); - ASSERT_EQ(plot.prepare_frame(), Plot_Render_Error::none); - ASSERT_EQ(plot.prepare_frame(), Plot_Render_Error::none); - ASSERT_EQ(plot.prepare_frame(), Plot_Render_Error::none); + ASSERT_EQ(plot.prepare_frame(), Plot_Render_Result::none); + ASSERT_EQ(plot.prepare_frame(), Plot_Render_Result::none); + ASSERT_EQ(plot.prepare_frame(), Plot_Render_Result::none); auto snapshot = plot.frame_status(); ASSERT_EQ(snapshot.pending_frame_count, 3u); ASSERT_EQ(snapshot.produced_frame_count, 3u); - ASSERT_EQ(plot.render_frame(true), Plot_Render_Error::none); + ASSERT_EQ(plot.render_frame(true), Plot_Render_Result::none); snapshot = plot.frame_status(); EXPECT_EQ(snapshot.mode, Plot_Frame_Mode::Playback); EXPECT_EQ(snapshot.last_event, "rendered"); @@ -228,19 +228,19 @@ TEST(Renderive_Core2_Frame_Pipeline, EveryModeHonorsActiveDirtyAndForceRenderGat scene.init(); scene.set_viewport_size({80, 45}); EXPECT_FALSE(scene.view_active()); - EXPECT_NE(scene.render_frame(false), Plot_Render_Error::none); + EXPECT_NE(scene.render_frame(false), Plot_Render_Result::none); EXPECT_EQ(scene.frame_status().observation_count, 0u); scene.activate_view(); - ASSERT_EQ(scene.render_frame(false), Plot_Render_Error::none); + ASSERT_EQ(scene.render_frame(false), Plot_Render_Result::none); const auto completed = scene.frame_status(); EXPECT_EQ(completed.mode, mode); EXPECT_EQ(completed.consumed_frame_count, 1u); - EXPECT_NE(scene.render_frame(false), Plot_Render_Error::none); + EXPECT_NE(scene.render_frame(false), Plot_Render_Result::none); EXPECT_EQ(scene.frame_status().consumed_frame_count, 1u); scene.deactivate_view(); scene.set_background_color(Color{8, 16, 24, 255}); - EXPECT_NE(scene.render_frame(false), Plot_Render_Error::none); - ASSERT_EQ(scene.render_frame(true), Plot_Render_Error::none); + EXPECT_NE(scene.render_frame(false), Plot_Render_Result::none); + ASSERT_EQ(scene.render_frame(true), Plot_Render_Result::none); EXPECT_EQ(scene.frame_status().consumed_frame_count, 2u); }; verify(Plot_Frame_Mode::Manual); @@ -261,7 +261,7 @@ TEST(Renderive_Core2_Frame_Pipeline, FrequencyConfigurationRejectsInvalidValuesA Plot_Scene playback({.frame_mode = Plot_Frame_Mode::Playback}); EXPECT_EQ(manual.set_max_render_fps(60.0), Plot_Control_Error::unsupported_frame_mode); EXPECT_EQ(playback.set_max_render_fps(60.0), Plot_Control_Error::unsupported_frame_mode); - EXPECT_NE(playback.refresh_manual_frame(), Plot_Render_Error::none); + EXPECT_NE(playback.refresh_manual_frame(), Plot_Render_Result::none); EXPECT_FALSE(playback.discard_pending_frame()); } } // namespace diff --git a/render_2D/tests/render_2D_Integration_Tests.cpp b/render_2D/tests/render_2D_Integration_Tests.cpp index 8b89029..426adda 100644 --- a/render_2D/tests/render_2D_Integration_Tests.cpp +++ b/render_2D/tests/render_2D_Integration_Tests.cpp @@ -62,7 +62,7 @@ TEST(Renderive_Core2, RootIdentityAndRefreshDiagnosticsComeFromKernelState) { plot.set_viewport_size({32, 24}); plot.activate_view(); EXPECT_EQ(plot.set_max_render_fps(144.0), Plot_Control_Error::none); - ASSERT_EQ(plot.render_frame(), Plot_Render_Error::none); + ASSERT_EQ(plot.render_frame(), Plot_Render_Result::none); const auto diagnostics = plot.diagnostics(); EXPECT_DOUBLE_EQ(diagnostics.refresh.frequency_hz, 144.0); EXPECT_EQ(diagnostics.refresh.frame_count, 1u); @@ -194,7 +194,7 @@ TEST(Renderive_Core2, KernelSceneRendersBusinessObjectsIntoBlend2DFrame) { for (std::size_t index = 0; index < samples.size(); ++index) samples[index] = -100.0 + static_cast(index % 24) * 3.0; spectrum->update_samples(samples); - ASSERT_EQ(plot.render_frame(), Plot_Render_Error::none); + ASSERT_EQ(plot.render_frame(), Plot_Render_Result::none); bool saw_frame = false; bool saw_drawn_pixel = false; plot.with_frame([&](Image_View view) { @@ -214,10 +214,10 @@ TEST(Renderive_Core2, KernelSceneRendersBusinessObjectsIntoBlend2DFrame) { EXPECT_TRUE(saw_frame); EXPECT_TRUE(saw_drawn_pixel); EXPECT_EQ(plot.diagnostics().refresh.frame_count, 1u); - EXPECT_NE(plot.render_frame(), Plot_Render_Error::none); + EXPECT_NE(plot.render_frame(), Plot_Render_Result::none); samples.front() += 1.0; spectrum->update_samples(samples); - EXPECT_EQ(plot.render_frame(true), Plot_Render_Error::none); + EXPECT_EQ(plot.render_frame(true), Plot_Render_Result::none); frequency_axis->set<&Axis_Properties::wheel>(true); const Range before_zoom = frequency_axis->get<&Axis_Properties::coordinates>(); Wheel_Event wheel; @@ -226,7 +226,7 @@ TEST(Renderive_Core2, KernelSceneRendersBusinessObjectsIntoBlend2DFrame) { plot.dispatch_event(wheel); EXPECT_TRUE(wheel.is_accepted()); EXPECT_LT(frequency_axis->get<&Axis_Properties::coordinates>().size(), before_zoom.size()); - EXPECT_EQ(plot.render_frame(), Plot_Render_Error::none); + EXPECT_EQ(plot.render_frame(), Plot_Render_Result::none); apply_runtime_edit(plot, [root, frequency_axis, power_axis, spectrum](auto& editor) { editor.set_display_parent(frequency_axis, root); editor.set_display_parent(power_axis, root); @@ -234,8 +234,8 @@ TEST(Renderive_Core2, KernelSceneRendersBusinessObjectsIntoBlend2DFrame) { editor.clear_dependency_parent(spectrum); editor.detach(spectrum); }); - EXPECT_EQ(plot.render_frame(true), Plot_Render_Error::none); - EXPECT_NE(plot.render_frame(), Plot_Render_Error::none); + EXPECT_EQ(plot.render_frame(true), Plot_Render_Result::none); + EXPECT_NE(plot.render_frame(), Plot_Render_Result::none); } TEST(Renderive_Core2, StandaloneRenderableBuilderJoinsSceneOnlyInsideRuntimeEditor) { Plot_Scene plot; @@ -303,7 +303,7 @@ TEST(Renderive_Core2, PerformanceOverlayConsumesKernelFrameDiagnostics) { ASSERT_TRUE(overlay); set_performance_plot_name(plot, "integration"); set_performance_overlay_enabled(plot, true); - ASSERT_EQ(plot.render_frame(true), Plot_Render_Error::none); + ASSERT_EQ(plot.render_frame(true), Plot_Render_Result::none); const auto snapshot = overlay->display_snapshot(); ASSERT_TRUE(snapshot); EXPECT_EQ(snapshot->plot_name, "integration"); @@ -317,12 +317,12 @@ TEST(Renderive_Core2, AllFrameControlModesUseKernelStrategiesAndExposeObservers) manual.init(); manual.set_viewport_size({64, 40}); EXPECT_EQ(manual.frame_mode(), Plot_Frame_Mode::Manual); - ASSERT_EQ(manual.prepare_frame(), Plot_Render_Error::none); + ASSERT_EQ(manual.prepare_frame(), Plot_Render_Result::none); auto manual_observer = manual.frame_status(); EXPECT_EQ(manual_observer.last_event, "prepared"); EXPECT_EQ(manual_observer.pending_frame_count, 1u); - ASSERT_EQ(manual.refresh_manual_frame(), Plot_Render_Error::none); - ASSERT_EQ(manual.render_prepared_frame(), Plot_Render_Error::none); + ASSERT_EQ(manual.refresh_manual_frame(), Plot_Render_Result::none); + ASSERT_EQ(manual.render_prepared_frame(), Plot_Render_Result::none); manual_observer = manual.frame_status(); EXPECT_EQ(manual_observer.last_event, "rendered"); EXPECT_EQ(manual_observer.consumed_frame_count, 1u); @@ -330,7 +330,7 @@ TEST(Renderive_Core2, AllFrameControlModesUseKernelStrategiesAndExposeObservers) low_latency.init(); low_latency.set_viewport_size({64, 40}); low_latency.activate_view(); - ASSERT_EQ(low_latency.render_frame(true), Plot_Render_Error::none); + ASSERT_EQ(low_latency.render_frame(true), Plot_Render_Result::none); const auto low_observer = low_latency.frame_status(); EXPECT_EQ(low_latency.frame_mode(), Plot_Frame_Mode::Low_Latency); EXPECT_EQ(low_observer.last_event, "lifecycle_completed"); @@ -338,14 +338,14 @@ TEST(Renderive_Core2, AllFrameControlModesUseKernelStrategiesAndExposeObservers) Plot_Scene playback({.frame_mode = Plot_Frame_Mode::Playback}); playback.init(); playback.set_viewport_size({64, 40}); - ASSERT_EQ(playback.prepare_frame(), Plot_Render_Error::none); - ASSERT_EQ(playback.prepare_frame(), Plot_Render_Error::none); - ASSERT_EQ(playback.prepare_frame(), Plot_Render_Error::none); + ASSERT_EQ(playback.prepare_frame(), Plot_Render_Result::none); + ASSERT_EQ(playback.prepare_frame(), Plot_Render_Result::none); + ASSERT_EQ(playback.prepare_frame(), Plot_Render_Result::none); auto playback_observer = playback.frame_status(); EXPECT_EQ(playback.frame_mode(), Plot_Frame_Mode::Playback); EXPECT_EQ(playback_observer.last_event, "enqueued"); EXPECT_EQ(playback_observer.pending_frame_count, 3u); - ASSERT_EQ(playback.render_prepared_frame(), Plot_Render_Error::none); + ASSERT_EQ(playback.render_prepared_frame(), Plot_Render_Result::none); playback_observer = playback.frame_status(); EXPECT_EQ(playback_observer.last_event, "rendered"); EXPECT_EQ(playback_observer.pending_frame_count, 2u); @@ -520,7 +520,7 @@ TEST(Renderive_Core2, RetainedSpectrumApisRoundTripAndMarkersRemainObservable) { EXPECT_EQ(spectrum->selectable_line_marker_count(), 0); spectrum->clear_custom_markers(); EXPECT_EQ(spectrum->selected_marker_index(), -1); - EXPECT_EQ(plot.render_frame(true), Plot_Render_Error::none); + EXPECT_EQ(plot.render_frame(true), Plot_Render_Result::none); } TEST(Renderive_Core2, RetainedHeatmapSweepAndTraceApisPreserveDataShapes) { Plot_Scene plot; @@ -634,7 +634,7 @@ TEST(Renderive_Core2, RetainedHeatmapSweepAndTraceApisPreserveDataShapes) { trace->append_sample(Time_Of_Day{4000}, -70.0); EXPECT_EQ(trace->sample_count(), 2U); EXPECT_EQ(trace->rendered_point_count(), 2U); - EXPECT_EQ(plot.render_frame(true), Plot_Render_Error::none); + EXPECT_EQ(plot.render_frame(true), Plot_Render_Result::none); } TEST(Renderive_Core2, RetainedSelectionAndConstellationApisDriveInteractionAndLayout) { Plot_Scene plot; @@ -713,7 +713,7 @@ TEST(Renderive_Core2, RetainedSelectionAndConstellationApisDriveInteractionAndLa constellation->fit_square_to_axes(); EXPECT_EQ(horizontal->get<&Axis_Properties::coordinates>(), (Range{-3.0, 3.0})); EXPECT_EQ(vertical->get<&Axis_Properties::coordinates>(), (Range{3.0, -3.0})); - EXPECT_EQ(plot.render_frame(true), Plot_Render_Error::none); + EXPECT_EQ(plot.render_frame(true), Plot_Render_Result::none); } TEST(Renderive_Core2, PlottablePropertiesPublishOnlyAtFrameBoundary) { Plot_Scene plot; @@ -738,12 +738,12 @@ TEST(Renderive_Core2, PlottablePropertiesPublishOnlyAtFrameBoundary) { EXPECT_EQ(cached.event, Renderable_Observer_Event::Cache_Updated); EXPECT_EQ(cached.cache_update_count, 1U); EXPECT_EQ(cached.publish_count, 0U); - ASSERT_EQ(plot.prepare_frame(), Plot_Render_Error::none); + ASSERT_EQ(plot.prepare_frame(), Plot_Render_Result::none); const auto published = spectrum->observation(); EXPECT_EQ(published.event, Renderable_Observer_Event::Published); EXPECT_EQ(published.cache_update_count, 1U); EXPECT_EQ(published.publish_count, 1U); - ASSERT_EQ(plot.render_prepared_frame(), Plot_Render_Error::none); + ASSERT_EQ(plot.render_prepared_frame(), Plot_Render_Result::none); } TEST(Renderive_Core2, EveryStatefulRenderableOwnsItsStateObserver) { Plot_Scene plot; @@ -777,7 +777,7 @@ TEST(Renderive_Core2, EveryStatefulRenderableOwnsItsStateObserver) { EXPECT_EQ(spectrum_update.cache_update_count, 1U); EXPECT_EQ(power->observation().event, Renderable_Observer_Event::None); - ASSERT_EQ(plot.prepare_frame(), Plot_Render_Error::none); + ASSERT_EQ(plot.prepare_frame(), Plot_Render_Result::none); const auto frequency_publish = frequency->observation(); const auto power_publish = power->observation(); const auto spectrum_publish = spectrum->observation(); @@ -791,7 +791,7 @@ TEST(Renderive_Core2, EveryStatefulRenderableOwnsItsStateObserver) { EXPECT_EQ(power_publish.cache_update_count, 0U); EXPECT_EQ(spectrum_publish.cache_update_count, 1U); - ASSERT_EQ(plot.render_prepared_frame(), Plot_Render_Error::none); + ASSERT_EQ(plot.render_prepared_frame(), Plot_Render_Result::none); EXPECT_EQ(frequency->observation().event, Renderable_Observer_Event::Published); EXPECT_EQ(power->observation().event, Renderable_Observer_Event::Published); EXPECT_EQ(spectrum->observation().event, Renderable_Observer_Event::Published); @@ -922,7 +922,7 @@ TEST(Renderive_Core2, PartitionedPlotsBuildPropertyDrivenRenderGraphs) { EXPECT_EQ(spectrum->get<&Spectrum::Properties::partition_count>(), 4); EXPECT_EQ(waterfall->get<&Waterfall::Properties::partition_count>(), 4); EXPECT_EQ(afterglow->get<&Afterglow::Properties::partition_count>(), 4); - ASSERT_EQ(plot.render_frame(true), Plot_Render_Error::none); + ASSERT_EQ(plot.render_frame(true), Plot_Render_Result::none); const auto partitioned_plan = plot.render_scene().render_plan_snapshot(); ASSERT_TRUE(partitioned_plan); EXPECT_EQ(planned_node_count(*partitioned_plan, *spectrum), 6u); @@ -941,7 +941,7 @@ TEST(Renderive_Core2, PartitionedPlotsBuildPropertyDrivenRenderGraphs) { waterfall->set<&Waterfall::Properties::partition_count>(1); afterglow->set<&Afterglow::Properties::partition_count>(1); plot.render_scene().publish_frame_state(); - ASSERT_EQ(plot.render_frame(true), Plot_Render_Error::none); + ASSERT_EQ(plot.render_frame(true), Plot_Render_Result::none); const auto single_plan = plot.render_scene().render_plan_snapshot(); ASSERT_TRUE(single_plan); EXPECT_EQ(planned_node_count(*single_plan, *spectrum), 3u); @@ -952,7 +952,7 @@ TEST(Renderive_Core2, PartitionedPlotsBuildPropertyDrivenRenderGraphs) { waterfall->set<&Waterfall::Properties::partition_mode>(Render_Partition_Mode::Automatic); afterglow->set<&Afterglow::Properties::partition_mode>(Render_Partition_Mode::Automatic); plot.render_scene().publish_frame_state(); - ASSERT_EQ(plot.render_frame(true), Plot_Render_Error::none); + ASSERT_EQ(plot.render_frame(true), Plot_Render_Result::none); const auto automatic_plan = plot.render_scene().render_plan_snapshot(); ASSERT_TRUE(automatic_plan); EXPECT_EQ(planned_node_count(*automatic_plan, *spectrum), 3u); @@ -1028,9 +1028,9 @@ TEST(Renderive_Core2, DynamicWaterfallCaptureStressPreservesPlansSlotsAndExactSe } if (frame % 4 == 0) waterfall->append_row(static_cast(tick++), samples); - ASSERT_EQ(plot.render_frame(true), Plot_Render_Error::none); + ASSERT_EQ(plot.render_frame(true), Plot_Render_Result::none); } - ASSERT_EQ(scene.render_scene().wait_for_render(), Scene_Render_Error::none); + ASSERT_EQ(scene.render_scene().wait_for_render(), Scene_Render_Result::none); const auto session = scene.render_scene().capture_session(session_id); ASSERT_TRUE(session); ASSERT_EQ(session->captured_count(), 8u); @@ -1069,9 +1069,9 @@ TEST(Renderive_Core2, PaintOnlyStyleChangesPreservePrepareCache) { }); const std::array samples{-80.0, -70.0, -60.0, -50.0}; spectrum->update_samples(samples); - ASSERT_EQ(plot.render_frame(true), Plot_Render_Error::none); - ASSERT_EQ(plot.render_frame(true), Plot_Render_Error::none); - ASSERT_EQ(plot.render_scene().wait_for_render(), Scene_Render_Error::none); + ASSERT_EQ(plot.render_frame(true), Plot_Render_Result::none); + ASSERT_EQ(plot.render_frame(true), Plot_Render_Result::none); + ASSERT_EQ(plot.render_scene().wait_for_render(), Scene_Render_Result::none); const auto cached_plan = plot.render_scene().render_plan_snapshot(); ASSERT_TRUE(cached_plan); const auto cached_has_kind = [&](Render_Node_Kind kind) { @@ -1087,8 +1087,8 @@ TEST(Renderive_Core2, PaintOnlyStyleChangesPreservePrepareCache) { spectrum->set<&Spectrum::Properties::current_pen>( Pen{Color{12, 34, 56, 255}, 2.0}); - ASSERT_EQ(plot.render_frame(true), Plot_Render_Error::none); - ASSERT_EQ(plot.render_scene().wait_for_render(), Scene_Render_Error::none); + ASSERT_EQ(plot.render_frame(true), Plot_Render_Result::none); + ASSERT_EQ(plot.render_scene().wait_for_render(), Scene_Render_Result::none); const auto plan = plot.render_scene().render_plan_snapshot(); ASSERT_TRUE(plan); EXPECT_EQ(plan, cached_plan); @@ -1102,8 +1102,8 @@ TEST(Renderive_Core2, PaintOnlyStyleChangesPreservePrepareCache) { EXPECT_TRUE(has_kind(Render_Node_Kind::paint)); frequency->set<&Axis_Base_Properties::color>(Color{90, 100, 110, 255}); - ASSERT_EQ(plot.render_frame(true), Plot_Render_Error::none); - ASSERT_EQ(plot.render_scene().wait_for_render(), Scene_Render_Error::none); + ASSERT_EQ(plot.render_frame(true), Plot_Render_Result::none); + ASSERT_EQ(plot.render_scene().wait_for_render(), Scene_Render_Result::none); const auto axis_style_plan = plot.render_scene().render_plan_snapshot(); ASSERT_TRUE(axis_style_plan); EXPECT_EQ(axis_style_plan, cached_plan); diff --git a/render_3D/render_3D/Point_Scene.cpp b/render_3D/render_3D/Point_Scene.cpp index 06ec8a7..40a328b 100644 --- a/render_3D/render_3D/Point_Scene.cpp +++ b/render_3D/render_3D/Point_Scene.cpp @@ -97,11 +97,11 @@ struct Scene_Model { ::renderive::Keyboard_Modifier modifiers) = 0; [[nodiscard]] virtual Scene_Control_Error dispatch_key( const ::renderive::Key_Event& event) = 0; - [[nodiscard]] virtual Frame_Request_Error prepare_frame() = 0; - [[nodiscard]] virtual Frame_Request_Error refresh_manual_frame() = 0; + [[nodiscard]] virtual Frame_Request_Result prepare_frame() = 0; + [[nodiscard]] virtual Frame_Request_Result refresh_manual_frame() = 0; [[nodiscard]] virtual bool discard_pending_frame() = 0; - [[nodiscard]] virtual Frame_Request_Error render_prepared_frame() = 0; - [[nodiscard]] virtual Frame_Request_Error request_frame() = 0; + [[nodiscard]] virtual Frame_Request_Result render_prepared_frame() = 0; + [[nodiscard]] virtual Frame_Request_Result request_frame() = 0; [[nodiscard]] virtual std::shared_ptr latest_frame() const = 0; [[nodiscard]] virtual Frame_Status frame_status() const = 0; @@ -281,21 +281,21 @@ struct Basic_Point_Scene final return error; } - [[nodiscard]] Frame_Request_Error prepare_frame() override { + [[nodiscard]] Frame_Request_Result prepare_frame() override { auto painter = this->frame_control.acquire_painter(); if (!painter) - return Frame_Request_Error::painter_unavailable; + return Frame_Request_Result::painter_unavailable; this->publish_frame_state(*painter); - return Frame_Request_Error::none; + return Frame_Request_Result::none; } - [[nodiscard]] Frame_Request_Error refresh_manual_frame() override { + [[nodiscard]] Frame_Request_Result refresh_manual_frame() override { if constexpr (Mode == Frame_Mode::Manual) { - return this->frame_control.refresh() == Manual_Refresh_Error::none - ? Frame_Request_Error::none - : Frame_Request_Error::no_pending_frame; + return this->frame_control.refresh() == Manual_Refresh_Result::none + ? Frame_Request_Result::none + : Frame_Request_Result::no_pending_frame; } - return Frame_Request_Error::manual_refresh_not_supported; + return Frame_Request_Result::manual_refresh_not_supported; } [[nodiscard]] bool discard_pending_frame() override { @@ -305,30 +305,30 @@ struct Basic_Point_Scene final return this->frame_control.discard_pending_frame(); } - [[nodiscard]] Frame_Request_Error render_prepared_frame() override { + [[nodiscard]] Frame_Request_Result render_prepared_frame() override { auto renderer = this->frame_control.acquire_renderer(); if (!renderer) - return Frame_Request_Error::renderer_unavailable; + return Frame_Request_Result::renderer_unavailable; switch (Scene_Base::render(*renderer)) { - case Scene_Render_Error::none: - return Frame_Request_Error::none; - case Scene_Render_Error::cancelled: - return Frame_Request_Error::cancelled; - case Scene_Render_Error::deadline_exceeded: - return Frame_Request_Error::deadline_exceeded; - case Scene_Render_Error::external_failure: - return Frame_Request_Error::external_failure; - case Scene_Render_Error::shutting_down: - return Frame_Request_Error::scene_shutting_down; + case Scene_Render_Result::none: + return Frame_Request_Result::none; + case Scene_Render_Result::cancelled: + return Frame_Request_Result::cancelled; + case Scene_Render_Result::deadline_exceeded: + return Frame_Request_Result::deadline_exceeded; + case Scene_Render_Result::external_failure: + return Frame_Request_Result::external_failure; + case Scene_Render_Result::shutting_down: + return Frame_Request_Result::scene_shutting_down; } ::renderive::error::unexpected("unknown scene render error"); } - [[nodiscard]] Frame_Request_Error request_frame() override { - if (const auto error = prepare_frame(); error != Frame_Request_Error::none) + [[nodiscard]] Frame_Request_Result request_frame() override { + if (const auto error = prepare_frame(); error != Frame_Request_Result::none) return error; if constexpr (Mode == Frame_Mode::Manual) { - if (const auto error = refresh_manual_frame(); error != Frame_Request_Error::none) + if (const auto error = refresh_manual_frame(); error != Frame_Request_Result::none) return error; } return render_prepared_frame(); @@ -404,7 +404,7 @@ struct Basic_Point_Scene final const Scene_Render_Context& context) override { if (!backend_state->backend_available()) return Node_Execution_Result::failed( - External_Operation_Error::external_failure); + External_Operation_Result::external_failure); const auto prepared = context.prepared(point_id); if (!prepared) ::renderive::error::unexpected("Point_Visual did not publish prepared data"); @@ -446,7 +446,7 @@ struct Basic_Point_Scene final try { state->quarantine_backend(); static_cast(source->fail( - External_Operation_Error::external_failure)); + External_Operation_Result::external_failure)); } catch (...) { static_cast(source->fail( ::renderive::error::capture( @@ -500,7 +500,7 @@ struct Basic_Point_Scene final try { if (state->render_domain->post( std::move(*render_completion)) != - detail::Render_Domain::Error::none) + detail::Render_Domain::Admission_Result::none) static_cast(source->cancel()); } catch (...) { static_cast(source->fail( @@ -534,7 +534,7 @@ struct Basic_Point_Scene final return; if (!state->backend_available()) { static_cast(source->fail( - External_Operation_Error::external_failure)); + External_Operation_Result::external_failure)); return; } std::uint64_t queue_wait_ns{}; @@ -572,7 +572,7 @@ struct Basic_Point_Scene final }, [source](std::exception_ptr exception) { static_cast(source->fail(std::move(exception))); }); - if (post_error != detail::Render_Domain::Error::none) + if (post_error != detail::Render_Domain::Admission_Result::none) static_cast(source->cancel()); } catch (...) { static_cast(source->fail( @@ -679,17 +679,17 @@ Scene_Control_Error Point_Scene::dispatch(const ::renderive::Key_Event& event) { return impl_->model->dispatch_key(event); } -Frame_Request_Error Point_Scene::prepare_frame() { return impl_->model->prepare_frame(); } -Frame_Request_Error Point_Scene::refresh_manual_frame() { +Frame_Request_Result Point_Scene::prepare_frame() { return impl_->model->prepare_frame(); } +Frame_Request_Result Point_Scene::refresh_manual_frame() { return impl_->model->refresh_manual_frame(); } bool Point_Scene::discard_pending_frame() { return impl_->model->discard_pending_frame(); } -Frame_Request_Error Point_Scene::render_prepared_frame() { +Frame_Request_Result Point_Scene::render_prepared_frame() { return impl_->model->render_prepared_frame(); } -Frame_Request_Error Point_Scene::request_frame() { return impl_->model->request_frame(); } +Frame_Request_Result Point_Scene::request_frame() { return impl_->model->request_frame(); } std::shared_ptr Point_Scene::latest_frame() const { return impl_->model->latest_frame(); diff --git a/render_3D/render_3D/Point_Scene.h b/render_3D/render_3D/Point_Scene.h index 7f00f19..2567ce1 100644 --- a/render_3D/render_3D/Point_Scene.h +++ b/render_3D/render_3D/Point_Scene.h @@ -34,7 +34,7 @@ enum class Scene_Control_Error : std::uint8_t { invalid_event, backend_unavailable }; -enum class Frame_Request_Error : std::uint8_t { +enum class Frame_Request_Result : std::uint8_t { none, painter_unavailable, manual_refresh_not_supported, @@ -152,11 +152,11 @@ public: [[nodiscard]] Scene_Control_Error dispatch(const ::renderive::Key_Event& event); // Frame strategy operations. request_frame() is the complete low-latency path. - [[nodiscard]] Frame_Request_Error prepare_frame(); - [[nodiscard]] Frame_Request_Error refresh_manual_frame(); + [[nodiscard]] Frame_Request_Result prepare_frame(); + [[nodiscard]] Frame_Request_Result refresh_manual_frame(); [[nodiscard]] bool discard_pending_frame(); - [[nodiscard]] Frame_Request_Error render_prepared_frame(); - [[nodiscard]] Frame_Request_Error request_frame(); + [[nodiscard]] Frame_Request_Result render_prepared_frame(); + [[nodiscard]] Frame_Request_Result request_frame(); [[nodiscard]] std::shared_ptr latest_frame() const; [[nodiscard]] Frame_Status frame_status() const; diff --git a/render_3D/render_3D/detail/Gpu_Completion_Service.cpp b/render_3D/render_3D/detail/Gpu_Completion_Service.cpp index f68589d..f44c491 100644 --- a/render_3D/render_3D/detail/Gpu_Completion_Service.cpp +++ b/render_3D/render_3D/detail/Gpu_Completion_Service.cpp @@ -22,7 +22,7 @@ Gpu_Completion_Service::~Gpu_Completion_Service() { Gpu_Completion_Service::Reservation::Reservation( std::shared_ptr pending) noexcept : pending_(std::move(pending)) {} -Gpu_Completion_Service::Reservation::~Reservation() { cancel(); } +Gpu_Completion_Service::Reservation::~Reservation() noexcept(false) { cancel(); } Gpu_Completion_Service::Reservation::Reservation(Reservation&& other) noexcept : pending_(std::exchange(other.pending_, {})) {} void Gpu_Completion_Service::Reservation::watch(VkDevice device, @@ -47,7 +47,7 @@ void Gpu_Completion_Service::Reservation::watch(VkDevice device, } service->wake(); } -void Gpu_Completion_Service::Reservation::cancel() noexcept { +void Gpu_Completion_Service::Reservation::cancel() { if (!pending_) return; auto pending = std::exchange(pending_, {}); @@ -62,7 +62,7 @@ void Gpu_Completion_Service::update_peak(std::atomic_size_t& peak, std::memory_order_relaxed)) {} } void Gpu_Completion_Service::cancel_reserved( - const std::shared_ptr& pending) noexcept { + const std::shared_ptr& pending) { if (!pending) return; std::lock_guard lock(pending->mutex); @@ -97,7 +97,7 @@ Gpu_Completion_Service::Prepare_Result Gpu_Completion_Service::prepare( if (!on_exception) ::renderive::error::unexpected("GPU completion exception handler is empty"); if (stopping_.load(std::memory_order_acquire)) - return {{}, Error::stopping}; + return {{}, Admission_Result::stopping}; auto pending = std::make_shared(); pending->completion = std::move(completion); pending->on_exception = std::move(on_exception); @@ -106,14 +106,14 @@ Gpu_Completion_Service::Prepare_Result Gpu_Completion_Service::prepare( acquire_slot(); if (stopping_.load(std::memory_order_acquire)) { release_slot(); - return {{}, Error::stopping}; + return {{}, Admission_Result::stopping}; } if (!pending_.try_push(pending)) { release_slot(); ::renderive::error::unexpected("GPU completion admission invariant violated"); } wake(); - return {Reservation(std::move(pending)), Error::none}; + return {Reservation(std::move(pending)), Admission_Result::none}; } Gpu_Completion_Service::Statistics Gpu_Completion_Service::statistics() const noexcept { diff --git a/render_3D/render_3D/detail/Gpu_Completion_Service.h b/render_3D/render_3D/detail/Gpu_Completion_Service.h index 095d99b..f55332f 100644 --- a/render_3D/render_3D/detail/Gpu_Completion_Service.h +++ b/render_3D/render_3D/detail/Gpu_Completion_Service.h @@ -16,7 +16,7 @@ namespace renderive::render_3d::detail { class Gpu_Completion_Service final { struct Pending_Fence; public: - enum class Error : std::uint8_t { + enum class Admission_Result : std::uint8_t { none, stopping }; @@ -46,7 +46,7 @@ public: class Reservation final { public: Reservation() = default; - ~Reservation(); + ~Reservation() noexcept(false); Reservation(const Reservation&) = delete; Reservation& operator=(const Reservation&) = delete; Reservation(Reservation&& other) noexcept; @@ -54,15 +54,15 @@ public: void watch(VkDevice device, VkFence fence); private: explicit Reservation(std::shared_ptr pending) noexcept; - void cancel() noexcept; + void cancel(); std::shared_ptr pending_; friend class Gpu_Completion_Service; }; struct Prepare_Result { Reservation reservation; - Error error{}; + Admission_Result result{}; [[nodiscard]] explicit operator bool() const noexcept { - return error == Error::none; + return result == Admission_Result::none; } }; static Gpu_Completion_Service& instance(); @@ -92,7 +92,7 @@ private: Gpu_Completion_Service(); ~Gpu_Completion_Service(); static void update_peak(std::atomic_size_t& peak, std::size_t value) noexcept; - static void cancel_reserved(const std::shared_ptr& pending) noexcept; + static void cancel_reserved(const std::shared_ptr& pending); void acquire_slot(); void release_slot() noexcept; void wake() noexcept; diff --git a/render_3D/render_3D/detail/Render_Domain.cpp b/render_3D/render_3D/detail/Render_Domain.cpp index f69b53c..fc53644 100644 --- a/render_3D/render_3D/detail/Render_Domain.cpp +++ b/render_3D/render_3D/detail/Render_Domain.cpp @@ -100,39 +100,39 @@ Render_Domain::Prepare_Result Render_Domain::prepare( if (!on_exception) ::renderive::error::unexpected("render domain exception handler is empty"); if (stopping_.load(std::memory_order_acquire)) - return {{}, Error::stopping}; + return {{}, Admission_Result::stopping}; acquire_admission(); if (stopping_.load(std::memory_order_acquire)) { release_admission(); - return {{}, Error::stopping}; + return {{}, Admission_Result::stopping}; } try { return {Prepared_Task(shared_from_this(), std::make_unique( - std::move(function), std::move(on_exception))), Error::none}; + std::move(function), std::move(on_exception))), Admission_Result::none}; } catch (...) { release_admission(); ::renderive::error::unexpected( "preparing render domain task", std::current_exception()); } } -Render_Domain::Error Render_Domain::post( +Render_Domain::Admission_Result Render_Domain::post( std::function function, Exception_Handler on_exception) { auto prepared = prepare(std::move(function), std::move(on_exception)); if (!prepared) - return prepared.error; + return prepared.result; return post(std::move(prepared.task)); } -Render_Domain::Error Render_Domain::post(Prepared_Task task) { +Render_Domain::Admission_Result Render_Domain::post(Prepared_Task task) { if (!task.task_ || task.domain_.get() != this) ::renderive::error::unexpected("render domain prepared task is invalid"); if (stopping_.load(std::memory_order_acquire)) - return Error::stopping; + return Admission_Result::stopping; if (!tasks_.try_push(std::move(task.task_))) ::renderive::error::unexpected("render domain admission invariant violated"); const std::size_t queued = queued_.fetch_add(1, std::memory_order_relaxed) + 1; update_peak(peak_queued_, queued); task.domain_.reset(); - return Error::none; + return Admission_Result::none; } Render_Domain::Statistics Render_Domain::statistics() const noexcept { return { diff --git a/render_3D/render_3D/detail/Render_Domain.h b/render_3D/render_3D/detail/Render_Domain.h index d9d5f8c..bb1fbae 100644 --- a/render_3D/render_3D/detail/Render_Domain.h +++ b/render_3D/render_3D/detail/Render_Domain.h @@ -26,7 +26,7 @@ class Render_Domain final : public std::enable_shared_from_this { std::function on_exception; }; public: - enum class Error : std::uint8_t { + enum class Admission_Result : std::uint8_t { none, stopping }; @@ -57,9 +57,9 @@ public: }; struct Prepare_Result { Prepared_Task task; - Error error{}; + Admission_Result result{}; [[nodiscard]] explicit operator bool() const noexcept { - return error == Error::none; + return result == Admission_Result::none; } }; static std::shared_ptr acquire(std::uint32_t gpu_index); @@ -69,52 +69,57 @@ public: using Exception_Handler = std::function; [[nodiscard]] Prepare_Result prepare(std::function function, Exception_Handler on_exception); - [[nodiscard]] Error post(std::function function, - Exception_Handler on_exception); - [[nodiscard]] Error post(Prepared_Task task); + [[nodiscard]] Admission_Result post(std::function function, + Exception_Handler on_exception); + [[nodiscard]] Admission_Result post(Prepared_Task task); template struct Invoke_Result { using Value = std::conditional_t, std::monostate, Result>; std::optional value; - Error error{}; + Admission_Result result{}; [[nodiscard]] explicit operator bool() const noexcept { - return error == Error::none; + return result == Admission_Result::none; } }; template [[nodiscard]] auto invoke(Function&& function) -> Invoke_Result> { using Result = std::invoke_result_t; + using Value = typename Invoke_Result::Value; Invoke_Result output; if (current_domain_ == this) { - if constexpr (std::is_void_v) { - std::invoke(std::forward(function)); - output.value.emplace(); - } else { - output.value.emplace(std::invoke(std::forward(function))); + try { + if constexpr (std::is_void_v) { + std::invoke(std::forward(function)); + output.value.emplace(); + } else { + output.value.emplace(std::invoke(std::forward(function))); + } + } catch (...) { + ::renderive::error::unexpected( + "executing inline render domain invocation", + std::current_exception()); } return output; } - auto task = std::make_shared>(std::forward(function)); - auto result = task->get_future(); - output.error = post([task] { (*task)(); }, - [](std::exception_ptr exception) { - ::renderive::error::unexpected( - "render domain invocation", exception); - }); - if (output.error != Error::none) + auto promise = std::make_shared>(); + auto future = promise->get_future(); + auto callable = std::make_shared>( + std::forward(function)); + output.result = post( + [promise, callable] { + if constexpr (std::is_void_v) { + std::invoke(*callable); + promise->set_value(std::monostate{}); + } else { + promise->set_value(std::invoke(*callable)); + } + }, + [promise](std::exception_ptr exception) { + promise->set_exception(std::move(exception)); + }); + if (output.result != Admission_Result::none) return output; - try { - if constexpr (std::is_void_v) { - result.get(); - output.value.emplace(); - } else { - output.value.emplace(result.get()); - } - } catch (...) { - ::renderive::error::unexpected( - "collecting render domain invocation", - std::current_exception()); - } + output.value.emplace(future.get()); return output; } [[nodiscard]] Statistics statistics() const noexcept; diff --git a/render_3D/tests/Point_Render_Integration_Tests.cpp b/render_3D/tests/Point_Render_Integration_Tests.cpp index 11737eb..1446bfc 100644 --- a/render_3D/tests/Point_Render_Integration_Tests.cpp +++ b/render_3D/tests/Point_Render_Integration_Tests.cpp @@ -59,9 +59,9 @@ std::size_t colored_pixel_count(const Pixel_Frame& frame) { TEST(PointRenderIntegration, RendersRealRgbaAndResizes) { try { auto demo = make_test_scene(Scene_Options{.viewport = {320, 200}}); - ASSERT_EQ(demo.scene->request_frame(), Frame_Request_Error::none); + ASSERT_EQ(demo.scene->request_frame(), Frame_Request_Result::none); ASSERT_EQ(demo.scene->render_scene().wait_for_render(), - Scene_Render_Error::none); + Scene_Render_Result::none); auto first = demo.scene->latest_frame(); ASSERT_NE(first, nullptr); EXPECT_EQ(first->extent, (Extent{320, 200})); @@ -69,9 +69,9 @@ TEST(PointRenderIntegration, RendersRealRgbaAndResizes) { EXPECT_GT(colored_pixel_count(*first), 100U); demo.scene->resize({480, 270}); - ASSERT_EQ(demo.scene->request_frame(), Frame_Request_Error::none); + ASSERT_EQ(demo.scene->request_frame(), Frame_Request_Result::none); ASSERT_EQ(demo.scene->render_scene().wait_for_render(), - Scene_Render_Error::none); + Scene_Render_Result::none); auto resized = demo.scene->latest_frame(); ASSERT_NE(resized, nullptr); EXPECT_EQ(resized->extent, (Extent{480, 270})); @@ -85,9 +85,9 @@ TEST(PointRenderIntegration, RendersRealRgbaAndResizes) { TEST(PointRenderIntegration, KernelEventsReachDatovizArcballOnItsDomain) { try { auto demo = make_test_scene(Scene_Options{.viewport = {320, 200}}); - ASSERT_EQ(demo.scene->request_frame(), Frame_Request_Error::none); + ASSERT_EQ(demo.scene->request_frame(), Frame_Request_Result::none); ASSERT_EQ(demo.scene->render_scene().wait_for_render(), - Scene_Render_Error::none); + Scene_Render_Result::none); const auto before = demo.scene->latest_frame()->rgba8; ::renderive::Basic_Pointer_Event press( @@ -108,9 +108,9 @@ TEST(PointRenderIntegration, KernelEventsReachDatovizArcballOnItsDomain) { release.button = ::renderive::Mouse_Button::Left; demo.scene->dispatch(release); - ASSERT_EQ(demo.scene->request_frame(), Frame_Request_Error::none); + ASSERT_EQ(demo.scene->request_frame(), Frame_Request_Result::none); ASSERT_EQ(demo.scene->render_scene().wait_for_render(), - Scene_Render_Error::none); + Scene_Render_Result::none); const auto after_drag = demo.scene->latest_frame(); ASSERT_NE(after_drag, nullptr); EXPECT_NE(after_drag->rgba8, before); @@ -121,9 +121,9 @@ TEST(PointRenderIntegration, KernelEventsReachDatovizArcballOnItsDomain) { wheel.angle_delta_y = -216.0; demo.scene->dispatch(wheel); - ASSERT_EQ(demo.scene->request_frame(), Frame_Request_Error::none); + ASSERT_EQ(demo.scene->request_frame(), Frame_Request_Result::none); ASSERT_EQ(demo.scene->render_scene().wait_for_render(), - Scene_Render_Error::none); + Scene_Render_Result::none); const auto after_wheel = demo.scene->latest_frame(); ASSERT_NE(after_wheel, nullptr); EXPECT_GT(colored_pixel_count(*after_wheel), 100U); @@ -141,8 +141,8 @@ TEST(PointRenderIntegration, const auto request = kernel_scene.capture_next_frame(); ASSERT_TRUE(request); const Capture_Session_Id capture = request.session_id; - ASSERT_EQ(demo.scene->request_frame(), Frame_Request_Error::none); - ASSERT_EQ(kernel_scene.wait_for_render(), Scene_Render_Error::none); + ASSERT_EQ(demo.scene->request_frame(), Frame_Request_Result::none); + ASSERT_EQ(kernel_scene.wait_for_render(), Scene_Render_Result::none); const auto session = kernel_scene.capture_session(capture); ASSERT_TRUE(session); diff --git a/render_3D/tests/Point_State_Tests.cpp b/render_3D/tests/Point_State_Tests.cpp index 871ffa5..6388fdd 100644 --- a/render_3D/tests/Point_State_Tests.cpp +++ b/render_3D/tests/Point_State_Tests.cpp @@ -43,8 +43,8 @@ struct Test_Scene final } auto renderer = frame_control.acquire_renderer(); ASSERT_TRUE(renderer); - ASSERT_EQ(Scene_Base::render(*renderer), Scene_Render_Error::none); - ASSERT_EQ(wait_for_render(), Scene_Render_Error::none); + ASSERT_EQ(Scene_Base::render(*renderer), Scene_Render_Result::none); + ASSERT_EQ(wait_for_render(), Scene_Render_Result::none); } Node_Execution_Result render_scene( diff --git a/render_3D/tests/Render_Domain_Tests.cpp b/render_3D/tests/Render_Domain_Tests.cpp index c185523..635b796 100644 --- a/render_3D/tests/Render_Domain_Tests.cpp +++ b/render_3D/tests/Render_Domain_Tests.cpp @@ -22,7 +22,7 @@ TEST(RenderDomain, PreparedTaskRunsAfterNoThrowHandoff) { executed.store(true, std::memory_order_release); }, [](std::exception_ptr) {}); ASSERT_TRUE(prepared); - EXPECT_EQ(domain->post(std::move(prepared.task)), Render_Domain::Error::none); + EXPECT_EQ(domain->post(std::move(prepared.task)), Render_Domain::Admission_Result::none); EXPECT_TRUE(domain->invoke([] {})); EXPECT_TRUE(executed.load(std::memory_order_acquire)); } @@ -61,7 +61,7 @@ TEST(RenderDomain, DeliversFireAndForgetExceptionsAndKeepsRunning) { [&delivered](std::exception_ptr value) { delivered.set_value(std::move(value)); }), - Render_Domain::Error::none); + Render_Domain::Admission_Result::none); ASSERT_EQ(exception.wait_for(std::chrono::seconds(1)), std::future_status::ready); EXPECT_THROW(std::rethrow_exception(exception.get()), std::runtime_error); @@ -79,7 +79,7 @@ TEST(RenderDomain, FinalOwnerMayBeReleasedOnAffinityThread) { EXPECT_EQ(domain->post([owned = domain, &released]() mutable { owned.reset(); released.set_value(); - }, [](std::exception_ptr) {}), Render_Domain::Error::none); + }, [](std::exception_ptr) {}), Render_Domain::Admission_Result::none); domain.reset(); EXPECT_EQ(finished.wait_for(std::chrono::seconds(1)), std::future_status::ready); diff --git a/web_server/app/Gallery_Plot_Session.cpp b/web_server/app/Gallery_Plot_Session.cpp index 8259e88..ac52070 100644 --- a/web_server/app/Gallery_Plot_Session.cpp +++ b/web_server/app/Gallery_Plot_Session.cpp @@ -207,7 +207,7 @@ struct Gallery_Plot_Session::Impl : std::enable_shared_from_this acquire_foreground_lock() { return std::unique_lock(mutex); } - void disarm_automatic_render() noexcept { + void disarm_automatic_render() { ++automatic_timer_revision; if (automatic_timer == trantor::InvalidTimerId) return; @@ -264,7 +264,7 @@ struct Gallery_Plot_Session::Impl : std::enable_shared_from_thiscan_render_automatically()) { const auto error = scene->render_latest_frame(); - if (error == Gallery_Render_Error::none) + if (error == Gallery_Render_Result::none) last_render_started = started; } render_task_pending = false; diff --git a/web_server/app/Gallery_WebSocket_Controller.cpp b/web_server/app/Gallery_WebSocket_Controller.cpp index e4d640b..81a932c 100644 --- a/web_server/app/Gallery_WebSocket_Controller.cpp +++ b/web_server/app/Gallery_WebSocket_Controller.cpp @@ -2,6 +2,7 @@ #include "Gallery_Plot_Session.h" #include "Web_Event_Adapter.h" +#include #include @@ -58,8 +59,10 @@ void Gallery_WebSocket_Controller::handleNewMessage( connection->send(response->payload.data(), response->payload.size(), message_type); } - } catch (const std::exception& error) { - LOG_ERROR << "Renderive Gallery session failed: " << error.what(); + } catch (...) { + static_cast(::renderive::error::capture( + "handling Gallery WebSocket request", std::current_exception())); + LOG_ERROR << "Renderive Gallery session failed"; connection->shutdown(drogon::CloseCode::kUnexpectedCondition, "Renderive Gallery rendering failed"); } diff --git a/web_server/app/Renderive_WebSocket_Controller.cpp b/web_server/app/Renderive_WebSocket_Controller.cpp index b0a0ef3..6f78d22 100644 --- a/web_server/app/Renderive_WebSocket_Controller.cpp +++ b/web_server/app/Renderive_WebSocket_Controller.cpp @@ -2,6 +2,7 @@ #include "Web_Event_Adapter.h" #include "Web_Plot_Session.h" +#include #include @@ -57,8 +58,10 @@ void Renderive_WebSocket_Controller::handleNewMessage( connection->send(response->payload.data(), response->payload.size(), message_type); } - } catch (const std::exception& error) { - LOG_ERROR << "Renderive WebSocket session failed: " << error.what(); + } catch (...) { + static_cast(::renderive::error::capture( + "handling Renderive WebSocket request", std::current_exception())); + LOG_ERROR << "Renderive WebSocket session failed"; connection->shutdown(drogon::CloseCode::kUnexpectedCondition, "Renderive rendering failed"); } diff --git a/web_server/app/Web_Plot_Session.cpp b/web_server/app/Web_Plot_Session.cpp index aa2a3af..a0cf7b8 100644 --- a/web_server/app/Web_Plot_Session.cpp +++ b/web_server/app/Web_Plot_Session.cpp @@ -160,7 +160,7 @@ struct Web_Plot_Session::Impl { plot.activate_view(); update_model(); const auto initial_render = plot.render_frame(true); - if (initial_render != Plot_Render_Error::none) + if (initial_render != Plot_Render_Result::none) plot.request_redraw(); } ~Impl() { @@ -268,7 +268,7 @@ struct Web_Plot_Session::Impl { if (!plot.view_active()) return std::nullopt; update_model(); - if (plot.render_frame(true) != Plot_Render_Error::none) + if (plot.render_frame(true) != Plot_Render_Result::none) return std::nullopt; std::string pixels; const Color background = plot.background_color(); diff --git a/web_server/app/common/Gallery_Scene_Interface.h b/web_server/app/common/Gallery_Scene_Interface.h index 566c8da..a738691 100644 --- a/web_server/app/common/Gallery_Scene_Interface.h +++ b/web_server/app/common/Gallery_Scene_Interface.h @@ -11,7 +11,7 @@ #include #include namespace renderive::web { -enum class Gallery_Render_Error : std::uint8_t { +enum class Gallery_Render_Result : std::uint8_t { none, inactive, frame_unavailable, @@ -33,7 +33,7 @@ public: [[nodiscard]] virtual adminive::Update_Result apply_patch(std::string_view target, const nlohmann::json& patch) = 0; virtual void resize(int width, int height) = 0; virtual void dispatch(const Gallery_Input_Event& event) = 0; - [[nodiscard]] virtual Gallery_Render_Error render_latest_frame() = 0; + [[nodiscard]] virtual Gallery_Render_Result render_latest_frame() = 0; [[nodiscard]] virtual std::optional encode_latest_pixels() = 0; virtual void record_pixel_response(std::chrono::steady_clock::time_point request_started, std::chrono::steady_clock::time_point encode_started, std::chrono::steady_clock::time_point encode_finished, std::size_t pixel_bytes) = 0; [[nodiscard]] virtual std::string action(const Gallery_Action_Request& request, bool& recognized) = 0; diff --git a/web_server/app/render_2D/Gallery_Scene2D.cpp b/web_server/app/render_2D/Gallery_Scene2D.cpp index 2db5e48..820da3b 100644 --- a/web_server/app/render_2D/Gallery_Scene2D.cpp +++ b/web_server/app/render_2D/Gallery_Scene2D.cpp @@ -29,22 +29,22 @@ #include namespace renderive::web { namespace { -Gallery_Render_Error gallery_render_error(Plot_Render_Error error) { +Gallery_Render_Result gallery_render_error(Plot_Render_Result error) { switch (error) { - case Plot_Render_Error::none: - return Gallery_Render_Error::none; - case Plot_Render_Error::view_inactive: - return Gallery_Render_Error::inactive; - case Plot_Render_Error::cancelled: - return Gallery_Render_Error::cancelled; - case Plot_Render_Error::deadline_exceeded: - return Gallery_Render_Error::deadline_exceeded; - case Plot_Render_Error::external_failure: - return Gallery_Render_Error::backend_failure; - case Plot_Render_Error::scene_shutting_down: - return Gallery_Render_Error::shutting_down; + case Plot_Render_Result::none: + return Gallery_Render_Result::none; + case Plot_Render_Result::view_inactive: + return Gallery_Render_Result::inactive; + case Plot_Render_Result::cancelled: + return Gallery_Render_Result::cancelled; + case Plot_Render_Result::deadline_exceeded: + return Gallery_Render_Result::deadline_exceeded; + case Plot_Render_Result::external_failure: + return Gallery_Render_Result::backend_failure; + case Plot_Render_Result::scene_shutting_down: + return Gallery_Render_Result::shutting_down; default: - return Gallery_Render_Error::frame_unavailable; + return Gallery_Render_Result::frame_unavailable; } } template @@ -213,7 +213,7 @@ public: static_cast(plot_.set_max_render_fps(30.0)); plot_.activate_view(); update_model(); - if (plot_.render_frame(true) != Plot_Render_Error::none) + if (plot_.render_frame(true) != Plot_Render_Result::none) plot_.request_redraw(); } ~Gallery_Scene() { @@ -349,13 +349,13 @@ public: } }, event); } - Gallery_Render_Error render_latest_frame() override { + Gallery_Render_Result render_latest_frame() override { if (!plot_.view_active()) - return Gallery_Render_Error::inactive; + return Gallery_Render_Result::inactive; update_model(); const auto started = std::chrono::steady_clock::now(); const auto error = plot_.render_frame(true); - const bool rendered = error == Plot_Render_Error::none; + const bool rendered = error == Plot_Render_Result::none; record_performance(started, rendered); if (rendered) rendered_since_last_pixel_ = true; @@ -365,7 +365,7 @@ public: if (!plot_.view_active()) return std::nullopt; if (!rendered_since_last_pixel_ && !can_render_automatically() && - render_latest_frame() != Gallery_Render_Error::none) + render_latest_frame() != Gallery_Render_Result::none) return std::nullopt; rendered_since_last_pixel_ = false; std::string pixels; @@ -420,7 +420,7 @@ public: } if (request.id == "mode_prepare" || request.id == "mode_enqueue") { update_model(); - const bool prepared = plot_.prepare_frame() == Plot_Render_Error::none; + const bool prepared = plot_.prepare_frame() == Plot_Render_Result::none; last_action_result_ = prepared ? "frame prepared" : "prepare rejected"; return prepared ? "Kernel 帧已准备/入队" : "Kernel 拒绝准备帧"; } @@ -432,19 +432,19 @@ public: int prepared{}; for (int index = 0; index < count; ++index) { update_model(); - prepared += plot_.prepare_frame() == Plot_Render_Error::none ? 1 : 0; + prepared += plot_.prepare_frame() == Plot_Render_Result::none ? 1 : 0; } last_action_result_ = "enqueued=" + std::to_string(prepared); return "回放帧已批量压入 Flow 队列"; } if (request.id == "mode_refresh") { - const bool refreshed = plot_.refresh_manual_frame() == Plot_Render_Error::none; + const bool refreshed = plot_.refresh_manual_frame() == Plot_Render_Result::none; last_action_result_ = refreshed ? "manual refresh succeeded" : "manual refresh failed"; return refreshed ? "Manual 待处理帧已提交刷新" : "当前没有可刷新的 Manual 帧"; } if (request.id == "mode_render" || request.id == "mode_dequeue") { const auto started = std::chrono::steady_clock::now(); - const bool rendered = plot_.render_prepared_frame() == Plot_Render_Error::none; + const bool rendered = plot_.render_prepared_frame() == Plot_Render_Result::none; record_performance(started, rendered); rendered_since_last_pixel_ = rendered; last_action_result_ = rendered ? "prepared frame rendered" : "no prepared frame"; @@ -458,7 +458,7 @@ public: if (request.id == "mode_cycle") { update_model(); const auto started = std::chrono::steady_clock::now(); - const bool rendered = plot_.render_frame(true) == Plot_Render_Error::none; + const bool rendered = plot_.render_frame(true) == Plot_Render_Result::none; record_performance(started, rendered); rendered_since_last_pixel_ = rendered; last_action_result_ = rendered ? "full frame cycle rendered" : "frame cycle skipped"; diff --git a/web_server/app/render_3D/Gallery_Scene3D.cpp b/web_server/app/render_3D/Gallery_Scene3D.cpp index 5d2c701..bd44328 100644 --- a/web_server/app/render_3D/Gallery_Scene3D.cpp +++ b/web_server/app/render_3D/Gallery_Scene3D.cpp @@ -65,49 +65,49 @@ struct Type_Descriptor { namespace renderive::web { namespace { using namespace renderive::render_3d; -Gallery_Render_Error gallery_render_error(Frame_Request_Error error) { +Gallery_Render_Result gallery_render_error(Frame_Request_Result error) { switch (error) { - case Frame_Request_Error::none: - return Gallery_Render_Error::none; - case Frame_Request_Error::cancelled: - return Gallery_Render_Error::cancelled; - case Frame_Request_Error::deadline_exceeded: - return Gallery_Render_Error::deadline_exceeded; - case Frame_Request_Error::external_failure: - return Gallery_Render_Error::backend_failure; - case Frame_Request_Error::scene_shutting_down: - return Gallery_Render_Error::shutting_down; + case Frame_Request_Result::none: + return Gallery_Render_Result::none; + case Frame_Request_Result::cancelled: + return Gallery_Render_Result::cancelled; + case Frame_Request_Result::deadline_exceeded: + return Gallery_Render_Result::deadline_exceeded; + case Frame_Request_Result::external_failure: + return Gallery_Render_Result::backend_failure; + case Frame_Request_Result::scene_shutting_down: + return Gallery_Render_Result::shutting_down; default: - return Gallery_Render_Error::frame_unavailable; + return Gallery_Render_Result::frame_unavailable; } } -Gallery_Render_Error gallery_render_error(Scene_Render_Error error) { +Gallery_Render_Result gallery_render_error(Scene_Render_Result error) { switch (error) { - case Scene_Render_Error::none: - return Gallery_Render_Error::none; - case Scene_Render_Error::cancelled: - return Gallery_Render_Error::cancelled; - case Scene_Render_Error::deadline_exceeded: - return Gallery_Render_Error::deadline_exceeded; - case Scene_Render_Error::external_failure: - return Gallery_Render_Error::backend_failure; - case Scene_Render_Error::shutting_down: - return Gallery_Render_Error::shutting_down; + case Scene_Render_Result::none: + return Gallery_Render_Result::none; + case Scene_Render_Result::cancelled: + return Gallery_Render_Result::cancelled; + case Scene_Render_Result::deadline_exceeded: + return Gallery_Render_Result::deadline_exceeded; + case Scene_Render_Result::external_failure: + return Gallery_Render_Result::backend_failure; + case Scene_Render_Result::shutting_down: + return Gallery_Render_Result::shutting_down; } ::renderive::error::unexpected("unknown scene render error"); } -Frame_Request_Error frame_request_error(Scene_Render_Error error) { +Frame_Request_Result frame_request_error(Scene_Render_Result error) { switch (error) { - case Scene_Render_Error::none: - return Frame_Request_Error::none; - case Scene_Render_Error::cancelled: - return Frame_Request_Error::cancelled; - case Scene_Render_Error::deadline_exceeded: - return Frame_Request_Error::deadline_exceeded; - case Scene_Render_Error::external_failure: - return Frame_Request_Error::external_failure; - case Scene_Render_Error::shutting_down: - return Frame_Request_Error::scene_shutting_down; + case Scene_Render_Result::none: + return Frame_Request_Result::none; + case Scene_Render_Result::cancelled: + return Frame_Request_Result::cancelled; + case Scene_Render_Result::deadline_exceeded: + return Frame_Request_Result::deadline_exceeded; + case Scene_Render_Result::external_failure: + return Frame_Request_Result::external_failure; + case Scene_Render_Result::shutting_down: + return Frame_Request_Result::scene_shutting_down; } ::renderive::error::unexpected("unknown scene render error"); } @@ -359,9 +359,9 @@ public: last_event_ = "key_rejected"; } - Gallery_Render_Error render_latest_frame() override { + Gallery_Render_Result render_latest_frame() override { if (!can_render_automatically()) - return Gallery_Render_Error::inactive; + return Gallery_Render_Result::inactive; advance_blue_point(0.025F); const auto request_error = render_request(); return gallery_render_error(request_error); @@ -435,17 +435,17 @@ public: blue_offset_ = std::min(0.25F, blue_offset_ + 0.0125F); publish_points(); } - const bool prepared = scene_.prepare_frame() == Frame_Request_Error::none; + const bool prepared = scene_.prepare_frame() == Frame_Request_Result::none; last_event_ = prepared ? "frame_prepared" : "prepare_rejected"; return prepared ? "3D frame prepared" : "3D frame prepare rejected"; } if (request.id == "mode_refresh") { - const bool refreshed = scene_.refresh_manual_frame() == Frame_Request_Error::none; + const bool refreshed = scene_.refresh_manual_frame() == Frame_Request_Result::none; last_event_ = refreshed ? "manual_refreshed" : "manual_refresh_failed"; return refreshed ? "Manual 3D frame refreshed" : "No manual frame to refresh"; } if (request.id == "mode_render" || request.id == "mode_dequeue") { - const bool rendered = render_prepared() == Frame_Request_Error::none; + const bool rendered = render_prepared() == Frame_Request_Result::none; last_event_ = rendered ? "frame_rendered" : "render_rejected"; return rendered ? "3D frame rendered" : "No 3D frame to render"; } @@ -629,27 +629,27 @@ private: } void render_initial_frame() { - Frame_Request_Error error{Frame_Request_Error::none}; + Frame_Request_Result error{Frame_Request_Result::none}; if (frame_mode_ == Gallery_Frame_Mode::Manual) { - if (scene_.prepare_frame() == Frame_Request_Error::none && - scene_.refresh_manual_frame() == Frame_Request_Error::none) + if (scene_.prepare_frame() == Frame_Request_Result::none && + scene_.refresh_manual_frame() == Frame_Request_Result::none) error = render_prepared(); else - error = Frame_Request_Error::no_pending_frame; + error = Frame_Request_Result::no_pending_frame; } else { error = render_request(); } - if (error != Frame_Request_Error::none) + if (error != Frame_Request_Result::none) last_action_result_ = "initial frame is not available"; } - Frame_Request_Error render_request() { + Frame_Request_Result render_request() { const auto started = std::chrono::steady_clock::now(); ++render_attempt_count_; auto error = scene_.request_frame(); - if (error == Frame_Request_Error::none) + if (error == Frame_Request_Result::none) error = frame_request_error(scene_.render_scene().wait_for_render()); - const bool rendered = error == Frame_Request_Error::none; + const bool rendered = error == Frame_Request_Result::none; last_render_ms_ = std::chrono::duration( std::chrono::steady_clock::now() - started) .count(); @@ -659,13 +659,13 @@ private: return error; } - Frame_Request_Error render_prepared() { + Frame_Request_Result render_prepared() { const auto started = std::chrono::steady_clock::now(); ++render_attempt_count_; auto error = scene_.render_prepared_frame(); - if (error == Frame_Request_Error::none) + if (error == Frame_Request_Result::none) error = frame_request_error(scene_.render_scene().wait_for_render()); - const bool rendered = error == Frame_Request_Error::none; + const bool rendered = error == Frame_Request_Result::none; last_render_ms_ = std::chrono::duration( std::chrono::steady_clock::now() - started) .count();