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
render_2D/axis/Axis_Builder.h
+2 -2
View File
@@ -67,8 +67,8 @@ public:
auto result = renderive_Owner<Product>::make(properties_);
if (attach_builder_) {
attach_builder_->attach(result);
attach_builder_->add_parent(::Scene_Base::Relationship::display, result, parent_);
attach_builder_->add_parent(::Scene_Base::Relationship::dependency, result, parent_);
attach_builder_->add_display_parent(result, parent_);
attach_builder_->add_dependency_parent(result, parent_);
}
return result;
}
render_2D/renderable/Renderable_Builder.h
+5 -5
View File
@@ -16,11 +16,11 @@ requires std::derived_from<Renderable_Type, Renderable> && std::derived_from<Axi
void attach_renderable_dependency(::Scene_Base::Attach_Builder& builder, const renderive_Owner<Renderable_Type>& renderable, const renderive_Owner<Axis_Type>& axis) {
if (!axis)
return;
builder.add_parent(::Scene_Base::Relationship::dependency, renderable, axis);
builder.add_dependency_parent(renderable, axis);
if constexpr (std::derived_from<Renderable_Type, Paint_Overlay>)
builder.add_parent(::Scene_Base::Relationship::display, renderable, axis);
builder.add_display_parent(renderable, axis);
else
builder.add_parent(::Scene_Base::Relationship::display, axis, renderable);
builder.add_display_parent(axis, renderable);
}
template <class Renderable_Type, class Value>
void attach_renderable_dependency(::Scene_Base::Attach_Builder&, const renderive_Owner<Renderable_Type>&, const Value&) {}
@@ -28,8 +28,8 @@ template <class Control, class... Args>
requires std::derived_from<Control, Renderable>
void attach_renderable(::Scene_Base::Attach_Builder& builder, const renderive_Owner<Control>& renderable, const renderive_Owner<Renderable>& parent, const Args&... args) {
builder.attach(renderable);
builder.add_parent(::Scene_Base::Relationship::display, renderable, parent);
builder.add_parent(::Scene_Base::Relationship::dependency, renderable, parent);
builder.add_display_parent(renderable, parent);
builder.add_dependency_parent(renderable, parent);
(attach_renderable_dependency(builder, renderable, args), ...);
}
}
render_2D/tests/render_2D_Integration_Tests.cpp
+61 -39
View File
@@ -7,6 +7,7 @@
#include <chrono>
#include <cstddef>
#include <functional>
#include <future>
#include <memory_resource>
#include <set>
#include <thread>
@@ -20,6 +21,17 @@ decltype(auto) build_initial(Scene& scene, Build&& build) {
auto attach = scene.attach_builder();
return std::invoke(std::forward<Build>(build), attach);
}
template <class Scene, class Edit>
void apply_runtime_edit(Scene& scene, Edit&& edit) {
std::promise<void> completed;
auto future = completed.get_future();
scene.edit_renderables(
[edit = std::forward<Edit>(edit), &completed](auto& editor) mutable {
edit(editor);
completed.set_value();
});
future.wait();
}
template <class Axis_Type>
concept Legacy_Axis_Property_Api = requires(Axis_Type& axis) {
axis.x();
@@ -201,8 +213,9 @@ TEST(Renderive_Core2, KernelSceneRendersBusinessObjectsIntoBlend2DFrame) {
EXPECT_TRUE(saw_drawn_pixel);
EXPECT_EQ(plot.diagnostics().refresh.frame_count, 1u);
EXPECT_FALSE(plot.render_frame());
samples.front() += 1.0;
spectrum->update_samples(samples);
EXPECT_TRUE(plot.render_frame());
EXPECT_TRUE(plot.render_frame(true));
frequency_axis->set<&Axis_Properties::wheel>(true);
const Range before_zoom = frequency_axis->get<&Axis_Properties::coordinates>();
Wheel_Event wheel;
@@ -212,11 +225,11 @@ TEST(Renderive_Core2, KernelSceneRendersBusinessObjectsIntoBlend2DFrame) {
EXPECT_TRUE(wheel.is_accepted());
EXPECT_LT(frequency_axis->get<&Axis_Properties::coordinates>().size(), before_zoom.size());
EXPECT_TRUE(plot.render_frame());
plot.edit_renderables([root, frequency_axis, power_axis, spectrum](auto& editor) {
editor.set_parent(::Scene_Base::Relationship::display, frequency_axis, root);
editor.set_parent(::Scene_Base::Relationship::display, power_axis, root);
editor.clear_parents(::Scene_Base::Relationship::display, spectrum);
editor.clear_parents(::Scene_Base::Relationship::dependency, spectrum);
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);
editor.clear_display_parent(spectrum);
editor.clear_dependency_parent(spectrum);
editor.detach(spectrum);
});
EXPECT_TRUE(plot.render_frame(true));
@@ -234,18 +247,25 @@ TEST(Renderive_Core2, StandaloneRenderableBuilderJoinsSceneOnlyInsideRuntimeEdit
});
const auto spectrum = Spectrum::Builder{}.build(root, frequency, power);
ASSERT_TRUE(spectrum);
EXPECT_FALSE(spectrum->attached());
plot.edit_renderables([root, frequency, power, spectrum](auto& editor) {
EXPECT_TRUE(std::ranges::none_of(
plot.topology_snapshot().renderables,
[&](const auto& renderable) {
return renderable.get() == spectrum.get();
}));
apply_runtime_edit(plot, [root, frequency, power, spectrum](auto& editor) {
editor.attach(spectrum);
editor.add_parent(::Scene_Base::Relationship::display, spectrum, root);
editor.add_parent(::Scene_Base::Relationship::dependency, spectrum, root);
editor.add_parent(::Scene_Base::Relationship::dependency, spectrum, frequency);
editor.add_parent(::Scene_Base::Relationship::dependency, spectrum, power);
editor.add_parent(::Scene_Base::Relationship::display, frequency, spectrum);
editor.add_parent(::Scene_Base::Relationship::display, power, spectrum);
editor.add_display_parent(spectrum, root);
editor.add_dependency_parent(spectrum, root);
editor.add_dependency_parent(spectrum, frequency);
editor.add_dependency_parent(spectrum, power);
editor.add_display_parent(frequency, spectrum);
editor.add_display_parent(power, spectrum);
});
EXPECT_TRUE(plot.render_frame(true));
EXPECT_TRUE(spectrum->attached());
EXPECT_TRUE(std::ranges::any_of(
plot.topology_snapshot().renderables,
[&](const auto& renderable) {
return renderable.get() == spectrum.get();
}));
}
TEST(Renderive_Core2, TimeAxisUsesOneFontStateAndFormatsConfiguredLabels) {
Scene2D plot;
@@ -831,7 +851,7 @@ TEST(Renderive_Core2, PartitionedPlotsBuildPropertyDrivenRenderGraphs) {
spectrum->update_samples(samples);
waterfall->append_row(0, samples);
afterglow->append_spectrum(samples);
spectrum->scene().publish_frame_state();
plot.publish_frame_state();
const auto planned_node_count = [](const Render_Plan& plan,
const Renderable_Base& renderable) {
@@ -846,7 +866,7 @@ TEST(Renderive_Core2, PartitionedPlotsBuildPropertyDrivenRenderGraphs) {
EXPECT_EQ(waterfall->get<&Waterfall::Properties::partition_count>(), 4);
EXPECT_EQ(afterglow->get<&Afterglow::Properties::partition_count>(), 4);
ASSERT_TRUE(plot.render_frame(true));
const auto partitioned_plan = spectrum->scene().render_plan_snapshot();
const auto partitioned_plan = plot.render_plan_snapshot();
ASSERT_TRUE(partitioned_plan);
EXPECT_EQ(planned_node_count(*partitioned_plan, *spectrum), 6u);
EXPECT_EQ(std::count_if(
@@ -863,9 +883,9 @@ TEST(Renderive_Core2, PartitionedPlotsBuildPropertyDrivenRenderGraphs) {
spectrum->set<&Spectrum::Properties::partition_count>(1);
waterfall->set<&Waterfall::Properties::partition_count>(1);
afterglow->set<&Afterglow::Properties::partition_count>(1);
spectrum->scene().publish_frame_state();
plot.publish_frame_state();
ASSERT_TRUE(plot.render_frame(true));
const auto single_plan = spectrum->scene().render_plan_snapshot();
const auto single_plan = plot.render_plan_snapshot();
ASSERT_TRUE(single_plan);
EXPECT_EQ(planned_node_count(*single_plan, *spectrum), 3u);
EXPECT_EQ(planned_node_count(*single_plan, *waterfall), 3u);
@@ -874,9 +894,9 @@ TEST(Renderive_Core2, PartitionedPlotsBuildPropertyDrivenRenderGraphs) {
spectrum->set<&Spectrum::Properties::partition_mode>(Render_Partition_Mode::Automatic);
waterfall->set<&Waterfall::Properties::partition_mode>(Render_Partition_Mode::Automatic);
afterglow->set<&Afterglow::Properties::partition_mode>(Render_Partition_Mode::Automatic);
spectrum->scene().publish_frame_state();
plot.publish_frame_state();
ASSERT_TRUE(plot.render_frame(true));
const auto automatic_plan = spectrum->scene().render_plan_snapshot();
const auto automatic_plan = plot.render_plan_snapshot();
ASSERT_TRUE(automatic_plan);
EXPECT_EQ(planned_node_count(*automatic_plan, *spectrum), 3u);
EXPECT_EQ(planned_node_count(*automatic_plan, *waterfall), 3u);
@@ -935,7 +955,7 @@ TEST(Renderive_Core2, DynamicWaterfallCaptureStressPreservesPlansSlotsAndExactSe
for (std::size_t index = 0; index < samples.size(); ++index)
samples[index] = static_cast<double>(index % 256);
waterfall->append_row(0, samples);
auto& scene = waterfall->scene();
auto& scene = plot;
constexpr std::array partition_counts{64, 16, 1};
std::uint64_t tick{1};
for (std::size_t round = 0; round < 3; ++round) {
@@ -984,20 +1004,24 @@ TEST(Renderive_Core2, PaintOnlyStyleChangesPreservePrepareCache) {
const std::array samples{-80.0, -70.0, -60.0, -50.0};
spectrum->update_samples(samples);
ASSERT_TRUE(plot.render_frame(true));
ASSERT_TRUE(spectrum->prepare_cache_valid());
ASSERT_TRUE(spectrum->paint_cache_valid());
const auto prepare_revision = spectrum->prepare_revision();
const auto paint_revision = spectrum->paint_revision();
ASSERT_TRUE(plot.render_frame(true));
const auto cached_plan = plot.render_plan_snapshot();
ASSERT_TRUE(cached_plan);
const auto cached_has_kind = [&](Render_Node_Kind kind) {
return std::any_of(cached_plan->graph.nodes.begin(),
cached_plan->graph.nodes.end(),
[&](const Render_Node& node) {
return node.owner_id == spectrum->renderable_id() &&
node.kind == kind;
});
};
EXPECT_FALSE(cached_has_kind(Render_Node_Kind::prepare));
EXPECT_FALSE(cached_has_kind(Render_Node_Kind::paint));
spectrum->set<&Spectrum::Properties::current_pen>(
Pen{Color{12, 34, 56, 255}, 2.0});
EXPECT_EQ(spectrum->prepare_revision(), prepare_revision);
EXPECT_GT(spectrum->paint_revision(), paint_revision);
EXPECT_TRUE(spectrum->prepare_cache_valid());
EXPECT_FALSE(spectrum->paint_cache_valid());
ASSERT_TRUE(plot.render_frame(true));
const auto plan = spectrum->scene().render_plan_snapshot();
const auto plan = plot.render_plan_snapshot();
ASSERT_TRUE(plan);
const auto has_kind = [&](Render_Node_Kind kind) {
return std::any_of(plan->graph.nodes.begin(), plan->graph.nodes.end(),
@@ -1008,11 +1032,9 @@ TEST(Renderive_Core2, PaintOnlyStyleChangesPreservePrepareCache) {
EXPECT_FALSE(has_kind(Render_Node_Kind::prepare));
EXPECT_TRUE(has_kind(Render_Node_Kind::paint));
const auto spectrum_prepare = spectrum->prepare_revision();
frequency->set<&Axis_Base_Properties::color>(Color{90, 100, 110, 255});
EXPECT_EQ(spectrum->prepare_revision(), spectrum_prepare);
ASSERT_TRUE(plot.render_frame(true));
const auto axis_style_plan = spectrum->scene().render_plan_snapshot();
const auto axis_style_plan = plot.render_plan_snapshot();
ASSERT_TRUE(axis_style_plan);
EXPECT_FALSE(std::any_of(axis_style_plan->graph.nodes.begin(),
axis_style_plan->graph.nodes.end(),
@@ -1032,7 +1054,7 @@ TEST(Renderive_Core2, PlottableAxesAreDataDependenciesAndPaintOverlays) {
return std::tuple{frequency_axis, power_axis, value};
});
ASSERT_TRUE(spectrum);
const auto topology = spectrum->scene().topology_snapshot();
const auto topology = plot.topology_snapshot();
const auto has_relationship = [](const auto& relationships, const auto* child, const auto* parent) {
return std::any_of(relationships.begin(), relationships.end(), [child, parent](const auto& relationship) {
return relationship.child.get() == child && relationship.parent.get() == parent;
@@ -1042,7 +1064,7 @@ TEST(Renderive_Core2, PlottableAxesAreDataDependenciesAndPaintOverlays) {
EXPECT_TRUE(has_relationship(topology.dependency, spectrum.get(), power.get()));
EXPECT_TRUE(has_relationship(topology.display, frequency.get(), spectrum.get()));
EXPECT_TRUE(has_relationship(topology.display, power.get(), spectrum.get()));
const auto paint_order = spectrum->scene().paint_order_snapshot();
const auto paint_order = plot.paint_order_snapshot();
const auto spectrum_position = std::find_if(paint_order.begin(), paint_order.end(), [&spectrum](const auto& renderable) {
return renderable.get() == spectrum.get();
});
@@ -1069,7 +1091,7 @@ TEST(Renderive_Core2, InteractionOverlayPaintsAboveItsAxes) {
return std::tuple{horizontal_axis, vertical_axis, value};
});
ASSERT_TRUE(selection);
const auto paint_order = selection->scene().paint_order_snapshot();
const auto paint_order = plot.paint_order_snapshot();
const auto position = [&paint_order](const auto* target) {
return std::find_if(paint_order.begin(), paint_order.end(), [target](const auto& renderable) {
return renderable.get() == target;