ae/Renderive
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

结构优化

Browse Source
This commit is contained in:
种太阳的热带美短
2026-08-13 15:17:02 +08:00
parent 65cf786e2d
commit e8e8b29806
25 changed files with 822 additions and 461 deletions
Download Patch File Download Diff File Expand all files Collapse all files
Kernel/tests/renderive/scene/Dynamic_Renderable_Lifecycle_Test.cpp
+26 -24
View File
@@ -9,6 +9,7 @@
#include <thread>
#include <vector>
#include "renderive/renderable/Renderable.hpp"
#include "renderive/renderable/Renderable_Test_Harness.hpp"
#include "renderive/scene/Scene.hpp"
#include "Scene_Test_Helpers.hpp"
namespace {
@@ -46,12 +47,13 @@ bool wait_until(Predicate&& predicate) {
}
return true;
}
class Counting_Renderable : public Renderable_Base {
class Counting_Renderable : public Renderable_Test_Harness {
public:
Counting_Renderable() : Renderable_Base({.cache_enabled = false}) {}
Counting_Renderable()
: Renderable_Test_Harness({.cache_enabled = false}) {}
std::atomic<int> prepare_count{};
protected:
void prepare(const Prepare_Render_Context&) override {
void prepare_for_test(const Prepare_Render_Context&) override {
prepare_count.fetch_add(1, std::memory_order_release);
}
};
@@ -64,7 +66,7 @@ public:
destroyed_->store(true, std::memory_order_release);
}
protected:
void prepare(const Prepare_Render_Context&) override {
void prepare_for_test(const Prepare_Render_Context&) override {
const int call = prepare_count.fetch_add(1, std::memory_order_acq_rel) + 1;
if (call == block_on_call_)
gate_->arrive_and_wait();
@@ -131,13 +133,13 @@ TEST(dynamic_renderable_lifecycle_test, reparent_edit_changes_only_the_next_fram
attach.attach(first_parent);
attach.attach(second_parent);
attach.attach(child);
attach.set_parent(Scene_Base::Relationship::dependency, child, first_parent);
attach.set_dependency_parent(child, first_parent);
}
scene.render();
first_gate->wait_until_arrived();
std::atomic<bool> edited{};
scene.edit_renderables([child, second_parent, &edited](auto& editor) {
editor.set_parent(Scene_Base::Relationship::dependency, child, second_parent);
editor.set_dependency_parent(child, second_parent);
edited.store(true, std::memory_order_release);
});
EXPECT_EQ(child->prepare_count.load(std::memory_order_acquire), 0);
@@ -152,20 +154,20 @@ TEST(dynamic_renderable_lifecycle_test, reparent_edit_changes_only_the_next_fram
scene.wait_for_render();
EXPECT_EQ(child->prepare_count.load(std::memory_order_acquire), 2);
}
class Rebuildable_Renderable final : public Renderable_Base {
class Rebuildable_Renderable final : public Renderable_Test_Harness {
public:
explicit Rebuildable_Renderable(std::shared_ptr<Gate> first_graph_gate)
: Renderable_Base({.cache_enabled = false}), first_graph_gate_(std::move(first_graph_gate)) {}
: Renderable_Test_Harness({.cache_enabled = false}), first_graph_gate_(std::move(first_graph_gate)) {}
void publish_second_graph() {
graph_version_.store(2, std::memory_order_release);
rebuild_render_graph();
rebuild_render_graph_for_test();
}
std::vector<int> executions() const {
std::lock_guard lock(executions_mutex_);
return executions_;
}
protected:
void build_prepare_graph(Renderable_Graph_Builder& builder) override {
void build_prepare_graph_for_test(Renderable_Graph_Builder& builder) override {
const int version = graph_version_.load(std::memory_order_acquire);
builder.emplace("versioned_prepare", version == 1 ? "Graph A" : "Graph B", [this, version](const Prepare_Render_Context&) {
if (version == 1)
@@ -195,23 +197,23 @@ TEST(dynamic_renderable_lifecycle_test, graph_rebuild_uses_the_same_no_inflight_
scene.wait_for_render();
EXPECT_EQ(renderable->executions(), std::vector<int>({1, 2}));
}
class Sequence_Parent final : public Renderable_Base {
class Sequence_Parent final : public Renderable_Test_Harness {
public:
explicit Sequence_Parent(std::atomic<std::uint64_t>& completed_sequence)
: Renderable_Base({.cache_enabled = false}), completed_sequence_(completed_sequence) {}
: Renderable_Test_Harness({.cache_enabled = false}), completed_sequence_(completed_sequence) {}
protected:
void prepare(const Prepare_Render_Context& context) override {
void prepare_for_test(const Prepare_Render_Context& context) override {
completed_sequence_.store(context.frame.render_sequence, std::memory_order_release);
}
private:
std::atomic<std::uint64_t>& completed_sequence_;
};
class Sequence_Child final : public Renderable_Base {
class Sequence_Child final : public Renderable_Test_Harness {
public:
Sequence_Child(std::atomic<std::uint64_t>& parent_sequence, std::atomic<int>& violations)
: Renderable_Base({.cache_enabled = false}), parent_sequence_(parent_sequence), violations_(violations) {}
: Renderable_Test_Harness({.cache_enabled = false}), parent_sequence_(parent_sequence), violations_(violations) {}
protected:
void prepare(const Prepare_Render_Context& context) override {
void prepare_for_test(const Prepare_Render_Context& context) override {
if (parent_sequence_.load(std::memory_order_acquire) != context.frame.render_sequence)
violations_.fetch_add(1, std::memory_order_relaxed);
}
@@ -228,15 +230,15 @@ TEST(dynamic_renderable_lifecycle_test, one_runtime_callback_can_apply_a_complet
attach_initial(scene, parent);
wait_renderable_edit(scene, [parent, child](auto& editor) {
editor.attach(child);
editor.set_parent(Scene_Base::Relationship::dependency, child, parent);
editor.set_parent(Scene_Base::Relationship::display, child, parent);
editor.set_dependency_parent(child, parent);
editor.set_display_parent(child, parent);
});
scene.render();
scene.wait_for_render();
EXPECT_EQ(violations.load(std::memory_order_acquire), 0);
wait_renderable_edit(scene, [child](auto& editor) {
editor.clear_parents(Scene_Base::Relationship::dependency, child);
editor.clear_parents(Scene_Base::Relationship::display, child);
editor.clear_dependency_parent(child);
editor.clear_display_parent(child);
editor.detach(child);
});
EXPECT_EQ(scene.renderable_count(), 1u);
@@ -252,12 +254,12 @@ TEST(dynamic_renderable_lifecycle_test, queued_edits_and_render_submission_prese
auto child = renderive_Owner<Sequence_Child>::make(parent_sequence, violations);
scene.edit_renderables([parent, child](auto& editor) {
editor.attach(child);
editor.set_parent(Scene_Base::Relationship::dependency, child, parent);
editor.set_parent(Scene_Base::Relationship::display, child, parent);
editor.set_dependency_parent(child, parent);
editor.set_display_parent(child, parent);
});
scene.edit_renderables([child](auto& editor) {
editor.clear_parents(Scene_Base::Relationship::dependency, child);
editor.clear_parents(Scene_Base::Relationship::display, child);
editor.clear_dependency_parent(child);
editor.clear_display_parent(child);
editor.detach(child);
});
}