psc/Aethera
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

优化

Browse Source
This commit is contained in:
种太阳的热带美短
2026-08-27 14:54:06 +08:00
parent ecf24cbe50
commit 63bb406a27
34 changed files with 690 additions and 1296 deletions
Download Patch File Download Diff File Expand all files Collapse all files
render_2D/tests/Async_Render_Contract_Test.cpp
+22 -31
View File
@@ -54,7 +54,7 @@ int main() {
power, q_axis, 3u);
auto* spectrum_painted = new std::atomic_bool{};
auto* topology_valid = new std::atomic_bool{true};
spectrum->paint_taskflow().add("test.spectrum.paint.complete", [spectrum_painted] {
spectrum->taskflow().add("test.spectrum.render.complete", [spectrum_painted] {
spectrum_painted->store(true, std::memory_order_release);
});
const auto verify_spectrum_precedes_axis =
@@ -62,9 +62,9 @@ int main() {
if (!spectrum_painted->load(std::memory_order_acquire))
topology_valid->store(false, std::memory_order_relaxed);
};
frequency->paint_taskflow().add("test.frequency.paint.order",
frequency->taskflow().add("test.frequency.render.order",
verify_spectrum_precedes_axis);
power->paint_taskflow().add("test.power.paint.order",
power->taskflow().add("test.power.render.order",
verify_spectrum_precedes_axis);
typename Scene_Object::template Builder<Scene_Object> scene_builder;
@@ -96,7 +96,7 @@ int main() {
Axis_Range{0.0, 100.0});
spectrum->pending_buffer<Spectrum_Frame_Tag>() =
Spectrum_Frame{std::vector<Spectrum_Power>(512, -50.0)};
spectrum->mark_dirty<Prepare_Data_Tag>();
spectrum->mark_dirty<Render_Graph_Tag>();
waterfall->set<&Waterfall::Prop::frequency_range>(
Axis_Range{0.0, 100.0});
waterfall->set<&Waterfall::Prop::power_range>(
@@ -109,14 +109,14 @@ int main() {
waterfall->submit_stream<Waterfall_Stream_Tag>(
std::make_shared<const Waterfall_Row>(Waterfall_Row{
second_tick, std::vector<Plot_Value>(64, -30.0)}));
waterfall->mark_dirty<Prepare_Data_Tag>();
waterfall->mark_dirty<Render_Graph_Tag>();
constellation->set<&Constellation_Diagram::Prop::i_range>(
Axis_Range{-1.0, 1.0});
constellation->set<&Constellation_Diagram::Prop::q_range>(
Axis_Range{-1.0, 1.0});
constellation->submit_stream<Constellation_Stream_Tag>(
Constellation_Point{{-50.0, 0.25}, monotonic_milliseconds()});
constellation->mark_dirty<Prepare_Data_Tag>();
constellation->mark_dirty<Render_Graph_Tag>();
scene->set<&Render_Scene_2D::Prop::viewport>(Size{160, 120});
scene->activate_view();
@@ -133,21 +133,16 @@ int main() {
const auto& constellation_state =
constellation->read_state<Renderable::Base_Tag>();
const bool valid = completed == frame &&
spectrum_state.prepare_executed &&
spectrum_state.paint_executed &&
spectrum_state.prepare_task_count == 5 &&
spectrum_state.paint_task_count == 6 &&
waterfall_state.prepare_executed &&
waterfall_state.paint_executed &&
waterfall_state.prepare_task_count == 5 &&
waterfall_state.paint_task_count == 5 &&
constellation_state.prepare_executed &&
constellation_state.paint_executed &&
constellation_state.paint_task_count == 4 &&
spectrum_state.render_executed &&
spectrum_state.task_count == 11 &&
waterfall_state.render_executed &&
waterfall_state.task_count == 10 &&
constellation_state.render_executed &&
constellation_state.task_count == 5 &&
spectrum->read_state<Spectrum::Base_Tag>().sample_count ==
512 &&
frequency->read_state<Renderable::Base_Tag>().paint_executed &&
power->read_state<Renderable::Base_Tag>().paint_executed &&
frequency->read_state<Renderable::Base_Tag>().render_executed &&
power->read_state<Renderable::Base_Tag>().render_executed &&
topology_valid->load(std::memory_order_relaxed) &&
contains_color(completed->image());
if (!valid) std::_Exit(1);
@@ -170,20 +165,16 @@ int main() {
constellation->read_state<Renderable::Base_Tag>();
const bool resized_valid =
next == resized_partition_frame &&
next_spectrum.prepare_graph_rebuilt &&
next_spectrum.paint_graph_rebuilt &&
next_spectrum.prepare_task_count == 3 &&
next_spectrum.paint_task_count == 4 &&
next_waterfall.prepare_graph_rebuilt &&
next_waterfall.paint_graph_rebuilt &&
next_waterfall.prepare_task_count == 7 &&
next_waterfall.paint_task_count == 7 &&
next_constellation.paint_graph_rebuilt &&
next_constellation.paint_task_count == 3 &&
next_spectrum.graph_rebuilt &&
next_spectrum.task_count == 7 &&
next_waterfall.graph_rebuilt &&
next_waterfall.task_count == 14 &&
next_constellation.graph_rebuilt &&
next_constellation.task_count == 4 &&
frequency->read_state<Renderable::Base_Tag>()
.paint_executed &&
.render_executed &&
power->read_state<Renderable::Base_Tag>()
.paint_executed &&
.render_executed &&
topology_valid->load(std::memory_order_relaxed) &&
contains_color(next->image());
std::_Exit(resized_valid ? 0 : 1);
render_2D/tests/Axis_Test.cpp
+14 -15
View File
@@ -89,14 +89,13 @@ TEST(axis_render, scene_prepares_and_paints_uncached_axis_into_frame) {
axis->set<&Abs_Axis::Prop::pixel_length>(120.0);
scene->set<&Render_Scene_2D::Prop::viewport>(Size{160, 64});
scene->activate_view();
ASSERT_TRUE((scene->edit_dependency_graph<Prepare_Data_Tag, Paint_Tag>([&](auto& prepare, auto& paint) {
prepare.add(axis.get());
paint.add(axis.get());
ASSERT_TRUE((scene->edit_dependency_graph<Render_Graph_Tag>([&](auto& graph) {
graph.add(axis.get());
}).has_value()));
int paint_extension_calls{};
int completion_calls{};
axis->paint_taskflow().add(
"test.axis.paint.extension", [&] { ++paint_extension_calls; });
axis->taskflow().add(
"test.axis.render.extension", [&] { ++paint_extension_calls; });
scene->completion_taskflow().add("test.scene_2d.completion", [&] {
EXPECT_EQ(paint_extension_calls, 1);
++completion_calls;
@@ -123,8 +122,8 @@ TEST(axis_event, numeric_axis_wheel_zoom_and_drag_update_authoritative_range) {
axis->set<&Abs_Axis::Prop::pixel_length>(100.0);
axis->set<&Numeric_Axis::Prop::coordinate_range>(Axis_Range{0.0, 10.0});
scene->set<&Render_Scene_2D::Prop::viewport>(Size{120, 64});
ASSERT_TRUE((scene->edit_dependency_graph<Prepare_Data_Tag, Paint_Tag>([&](auto& prepare, auto& paint) {
prepare.add(axis.get()); paint.add(axis.get());
ASSERT_TRUE((scene->edit_dependency_graph<Render_Graph_Tag>([&](auto& graph) {
graph.add(axis.get());
}).has_value()));
scene->activate_view();
render_once(scene.get());
@@ -159,9 +158,9 @@ TEST(axis_event, scene_routes_pointer_interaction_to_the_nearest_axis_segment) {
vertical->set<&Abs_Axis::Prop::orientation>(Axis_Orientation::vertical);
vertical->set<&Numeric_Axis::Prop::coordinate_range>(Axis_Range{0.0, 10.0});
scene->set<&Render_Scene_2D::Prop::viewport>(Size{200, 200});
ASSERT_TRUE((scene->edit_dependency_graph<Prepare_Data_Tag, Paint_Tag>([&](auto& prepare, auto& paint) {
prepare.add(horizontal.get()); prepare.add(vertical.get());
paint.add(horizontal.get()); paint.add(vertical.get());
ASSERT_TRUE((scene->edit_dependency_graph<Render_Graph_Tag>([&](auto& graph) {
graph.add(horizontal.get());
graph.add(vertical.get());
}).has_value()));
scene->activate_view();
render_once(scene.get());
@@ -217,14 +216,14 @@ TEST(axis_time, appending_each_time_sample_invalidates_tick_preparation) {
using Object = Time_Axis;
auto axis = build_axis<Object>();
axis->advance();
axis->template take_dirty<Prepare_Data_Tag>();
EXPECT_FALSE(axis->template dirty<Prepare_Data_Tag>());
axis->template take_dirty<Render_Graph_Tag>();
EXPECT_FALSE(axis->template dirty<Render_Graph_Tag>());
EXPECT_EQ(axis->append_time({1'000}), 0);
EXPECT_TRUE(axis->template dirty<Prepare_Data_Tag>());
EXPECT_TRUE(axis->template dirty<Render_Graph_Tag>());
axis->advance();
axis->template take_dirty<Prepare_Data_Tag>();
axis->template take_dirty<Render_Graph_Tag>();
EXPECT_EQ(axis->append_time({2'000}), 1);
EXPECT_TRUE(axis->template dirty<Prepare_Data_Tag>());
EXPECT_TRUE(axis->template dirty<Render_Graph_Tag>());
axis->advance();
EXPECT_EQ(axis->coordinate_range(), (Axis_Range{-98.5, 1.5}));
}
render_2D/tests/Plottable_Migration_Test.cpp
+10 -11
View File
@@ -68,7 +68,7 @@ TEST(plottable_migration, curve_plots_share_partitioned_rendering) {
Frequency_Trace_Sample{time->append_time({2'000}), 50.0});
trace->submit_stream<Frequency_Trace_Stream_Tag>(
Frequency_Trace_Sample{time->append_time({3'000}), 90.0});
trace->mark_dirty<Prepare_Data_Tag>();
trace->mark_dirty<Render_Graph_Tag>();
sweep->set<&Sweep_Spectrum::Prop::frequency_range>(Axis_Range{0.0, 100.0});
sweep->set<&Sweep_Spectrum::Prop::block_count>(2u);
const std::array<Plot_Value, 4> first_block{-90.0, -60.0, -30.0, -10.0};
@@ -80,7 +80,7 @@ TEST(plottable_migration, curve_plots_share_partitioned_rendering) {
sweep->submit_stream<Sweep_Spectrum_Stream_Tag>(
std::make_shared<const Sweep_Spectrum_Block>(Sweep_Spectrum_Block{
1, {second_block.begin(), second_block.end()}}));
sweep->mark_dirty<Prepare_Data_Tag>();
sweep->mark_dirty<Render_Graph_Tag>();
auto scene = build_scene<Scene>(trace.get(), sweep.get());
scene->set<&Render_Scene_2D::Prop::viewport>(canvas);
scene->activate_view();
@@ -94,8 +94,8 @@ TEST(plottable_migration, curve_plots_share_partitioned_rendering) {
0, {replacement_block.begin(), replacement_block.end()}}));
trace->submit_stream<Frequency_Trace_Stream_Tag>(
Frequency_Trace_Sample{time->append_time({4'000}), 60.0});
trace->mark_dirty<Prepare_Data_Tag>();
sweep->mark_dirty<Prepare_Data_Tag>();
trace->mark_dirty<Render_Graph_Tag>();
sweep->mark_dirty<Render_Graph_Tag>();
render_once(scene.get());
EXPECT_EQ(trace->access_rendering_stream<Frequency_Trace_Stream_Tag>(
[](std::span<Frequency_Trace_Sample> samples) { return samples.size(); }), 4u);
@@ -132,12 +132,12 @@ TEST(plottable_migration, raster_plots_share_partitioned_color_blocks) {
const std::array<Plot_Value, 4> row{-90.0, -60.0, -30.0, -10.0};
glow->submit_stream<Afterglow_Stream_Tag>(
std::make_shared<const std::vector<Plot_Value>>(row.begin(), row.end()));
glow->mark_dirty<Prepare_Data_Tag>();
glow->mark_dirty<Render_Graph_Tag>();
waterfall->submit_stream<Waterfall_Stream_Tag>(std::make_shared<const Waterfall_Row>(
Waterfall_Row{time->append_time({1'000}), {row.begin(), row.end()}}));
waterfall->submit_stream<Waterfall_Stream_Tag>(std::make_shared<const Waterfall_Row>(
Waterfall_Row{time->append_time({2'000}), {row.begin(), row.end()}}));
waterfall->mark_dirty<Prepare_Data_Tag>();
waterfall->mark_dirty<Render_Graph_Tag>();
auto scene = build_scene<Scene>(glow.get(), waterfall.get());
scene->set<&Render_Scene_2D::Prop::viewport>(canvas);
scene->activate_view();
@@ -148,10 +148,10 @@ TEST(plottable_migration, raster_plots_share_partitioned_color_blocks) {
[](std::span<std::shared_ptr<const Waterfall_Row>> rows) { return rows.size(); }), 2u);
glow->submit_stream<Afterglow_Stream_Tag>(
std::make_shared<const std::vector<Plot_Value>>(row.begin(), row.end()));
glow->mark_dirty<Prepare_Data_Tag>();
glow->mark_dirty<Render_Graph_Tag>();
waterfall->submit_stream<Waterfall_Stream_Tag>(std::make_shared<const Waterfall_Row>(
Waterfall_Row{time->append_time({3'000}), {row.begin(), row.end()}}));
waterfall->mark_dirty<Prepare_Data_Tag>();
waterfall->mark_dirty<Render_Graph_Tag>();
render_once(scene.get());
EXPECT_EQ(glow->access_rendering_stream<Afterglow_Stream_Tag>(
[](std::span<std::shared_ptr<const std::vector<Plot_Value>>> spectra) { return spectra.size(); }), 2u);
@@ -178,15 +178,14 @@ TEST(plottable_migration, direct_overlay_and_constellation_build_and_render) {
diagram->set<&Constellation_Diagram::Prop::q_range>(Axis_Range{-1.0, 1.0});
diagram->submit_stream<Constellation_Stream_Tag>(
Constellation_Point{{0.25, -0.25}, monotonic_milliseconds()});
diagram->mark_dirty<Prepare_Data_Tag>();
diagram->mark_dirty<Render_Graph_Tag>();
auto scene = build_scene<Scene>(diagram.get(), overlay.get());
scene->set<&Render_Scene_2D::Prop::viewport>(canvas);
scene->activate_view();
render_once(scene.get());
EXPECT_EQ(diagram->access_rendering_stream<Constellation_Stream_Tag>(
[](std::span<Constellation_Point> points) { return points.size(); }), 1u);
EXPECT_EQ(overlay->read_state<Renderable::Base_Tag>().prepare_task_count, 0u);
EXPECT_EQ(overlay->read_state<Renderable::Base_Tag>().paint_task_count, 1u);
EXPECT_EQ(overlay->read_state<Renderable::Base_Tag>().task_count, 1u);
}
TEST(selection_overlay, control_extends_selection_and_plain_click_clears_it) {
render_2D/tests/Spectrum_Test.cpp
+30 -34
View File
@@ -63,7 +63,7 @@ TEST(spectrum_data, publishes_samples_through_tagged_frame_buffer) {
const double samples[]{-100.0, -50.0, 0.0};
spectrum->pending_buffer<Spectrum_Frame_Tag>() =
Spectrum_Frame{std::vector<Spectrum_Power>(std::begin(samples), std::end(samples))};
spectrum->mark_dirty<Prepare_Data_Tag>();
spectrum->mark_dirty<Render_Graph_Tag>();
spectrum->advance();
EXPECT_EQ(spectrum->current_buffer<Spectrum_Frame_Tag>().samples,
(std::vector<Spectrum_Power>{-100.0, -50.0, 0.0}));
@@ -126,67 +126,64 @@ TEST(render_scene_2d, composites_axes_and_spectrum_into_final_frame) {
const double samples[]{-90.0, -65.0, -20.0, -45.0, -75.0};
spectrum->pending_buffer<Spectrum_Frame_Tag>() =
Spectrum_Frame{std::vector<Spectrum_Power>(std::begin(samples), std::end(samples))};
spectrum->mark_dirty<Prepare_Data_Tag>();
spectrum->mark_dirty<Render_Graph_Tag>();
scene->set<&Render_Scene_2D::Prop::viewport>(canvas);
scene->set<&Render_Scene_2D::Prop::background>(Color::transparent());
scene->activate_view();
const auto prepare_graph = scene->pending_dependency_graph<Prepare_Data_Tag>();
EXPECT_TRUE(prepare_graph.depends_on(spectrum.get(), scene.get()));
EXPECT_TRUE(prepare_graph.depends_on(spectrum.get(), frequency.get()));
EXPECT_TRUE(prepare_graph.depends_on(spectrum.get(), power.get()));
const auto paint_graph = scene->pending_dependency_graph<Paint_Tag>();
EXPECT_TRUE(paint_graph.depends_on(frequency.get(), spectrum.get()));
EXPECT_TRUE(paint_graph.depends_on(power.get(), spectrum.get()));
const auto cache_graph = scene->pending_dependency_graph<Paint_Cache_Tag>();
const auto render_graph = scene->pending_dependency_graph<Render_Graph_Tag>();
EXPECT_FALSE(render_graph.depends_on(spectrum.get(), scene.get()));
EXPECT_FALSE(render_graph.depends_on(spectrum.get(), frequency.get()));
EXPECT_FALSE(render_graph.depends_on(spectrum.get(), power.get()));
EXPECT_TRUE(render_graph.depends_on(frequency.get(), spectrum.get()));
EXPECT_TRUE(render_graph.depends_on(power.get(), spectrum.get()));
const auto cache_graph = scene->pending_dependency_graph<Render_Cache_Tag>();
EXPECT_TRUE(cache_graph.depends_on(spectrum.get(), scene.get()));
EXPECT_TRUE(cache_graph.depends_on(spectrum.get(), frequency.get()));
EXPECT_TRUE(cache_graph.depends_on(spectrum.get(), power.get()));
auto output_frame = render_frame(scene.get());
EXPECT_GT(spectrum->read_state<Spectrum::Base_Tag>().rendered_point_count, 0u);
const auto& render_state = spectrum->read_state<Renderable::Base_Tag>();
EXPECT_EQ(render_state.prepare_task_count, 4u);
EXPECT_EQ(render_state.paint_task_count, 5u);
EXPECT_EQ(render_state.task_count, 9u);
const Image_View frame = output_frame->image();
ASSERT_FALSE(frame.empty());
EXPECT_TRUE(contains_color(frame));
EXPECT_FALSE(spectrum->dirty<Paint_Cache_Tag>());
EXPECT_FALSE(spectrum->dirty<Paint_Tag>());
EXPECT_FALSE(frequency->dirty<Paint_Tag>());
EXPECT_FALSE(power->dirty<Paint_Tag>());
EXPECT_FALSE(spectrum->dirty<Render_Cache_Tag>());
EXPECT_FALSE(spectrum->dirty<Render_Graph_Tag>());
EXPECT_FALSE(frequency->dirty<Render_Graph_Tag>());
EXPECT_FALSE(power->dirty<Render_Graph_Tag>());
EXPECT_FALSE(spectrum->read_prop<Renderable_2D::Base_Tag>().cache_enabled);
spectrum->set<&Renderable_2D::Prop::cache_enabled>(true);
output_frame = render_frame(scene.get());
EXPECT_TRUE(contains_color(output_frame->image()));
frequency->set<&Numeric_Axis::Prop::precision>(3);
EXPECT_FALSE(spectrum->dirty<Paint_Cache_Tag>());
EXPECT_FALSE(spectrum->dirty<Render_Cache_Tag>());
output_frame = render_frame(scene.get());
EXPECT_TRUE(spectrum->read_state<Renderable::Base_Tag>().paint_executed);
EXPECT_TRUE(frequency->read_state<Renderable::Base_Tag>().paint_executed);
EXPECT_TRUE(power->read_state<Renderable::Base_Tag>().paint_executed);
EXPECT_TRUE(spectrum->read_state<Renderable::Base_Tag>().render_executed);
EXPECT_TRUE(frequency->read_state<Renderable::Base_Tag>().render_executed);
EXPECT_TRUE(power->read_state<Renderable::Base_Tag>().render_executed);
EXPECT_TRUE(contains_color(output_frame->image()));
frequency->set<&Numeric_Axis::Prop::coordinate_range>(Axis_Range{0.0, 120.0});
EXPECT_TRUE(spectrum->dirty<Paint_Cache_Tag>());
EXPECT_TRUE(spectrum->dirty<Render_Cache_Tag>());
output_frame = render_frame(scene.get());
EXPECT_FALSE(spectrum->dirty<Paint_Cache_Tag>());
EXPECT_TRUE(spectrum->read_state<Renderable::Base_Tag>().prepare_executed);
EXPECT_FALSE(spectrum->dirty<Render_Cache_Tag>());
EXPECT_TRUE(spectrum->read_state<Renderable::Base_Tag>().render_executed);
spectrum->set<&Spectrum::Prop::partition_count>(2u);
spectrum->pending_buffer<Spectrum_Frame_Tag>() =
Spectrum_Frame{std::vector<Spectrum_Power>(std::begin(samples), std::end(samples))};
spectrum->mark_dirty<Prepare_Data_Tag>();
spectrum->mark_dirty<Render_Graph_Tag>();
output_frame = render_frame(scene.get());
const auto& rebuilt_state = spectrum->read_state<Renderable::Base_Tag>();
EXPECT_TRUE(rebuilt_state.prepare_graph_rebuilt);
EXPECT_EQ(rebuilt_state.prepare_task_count, 3u);
EXPECT_TRUE(rebuilt_state.graph_rebuilt);
EXPECT_EQ(rebuilt_state.task_count, 7u);
EXPECT_TRUE(contains_color(output_frame->image()));
const Size resized_canvas{200, 140};
scene->set<&Render_Scene_2D::Prop::viewport>(resized_canvas);
EXPECT_TRUE(spectrum->dirty<Paint_Cache_Tag>());
EXPECT_FALSE(frequency->dirty<Prepare_Data_Tag>());
EXPECT_FALSE(power->dirty<Prepare_Data_Tag>());
EXPECT_TRUE(spectrum->dirty<Render_Cache_Tag>());
EXPECT_FALSE(frequency->dirty<Render_Graph_Tag>());
EXPECT_FALSE(power->dirty<Render_Graph_Tag>());
output_frame = render_frame(scene.get());
EXPECT_EQ(scene->read_prop<Render_Scene_2D::Base_Tag>().viewport, resized_canvas);
EXPECT_FALSE(frequency->read_state<Renderable::Base_Tag>().prepare_executed);
EXPECT_TRUE(frequency->read_state<Renderable::Base_Tag>().paint_executed);
EXPECT_TRUE(frequency->read_state<Renderable::Base_Tag>().render_executed);
const Image_View resized_frame = output_frame->image();
EXPECT_EQ(resized_frame.width, resized_canvas.width);
EXPECT_EQ(resized_frame.height, resized_canvas.height);
@@ -223,13 +220,12 @@ TEST(spectrum_data, repeatedly_publishes_new_samples_during_long_running_render)
samples[peak] = -15.0;
spectrum->pending_buffer<Spectrum_Frame_Tag>() =
Spectrum_Frame{std::move(samples)};
spectrum->mark_dirty<Prepare_Data_Tag>();
spectrum->mark_dirty<Render_Graph_Tag>();
auto frame = render_frame(scene.get());
const auto hash = image_hash(frame->image());
if (frame_index != 0 && hash != previous_hash) ++changed_frames;
previous_hash = hash;
EXPECT_TRUE(spectrum->read_state<Renderable::Base_Tag>().prepare_executed);
EXPECT_TRUE(spectrum->read_state<Renderable::Base_Tag>().paint_executed);
EXPECT_TRUE(spectrum->read_state<Renderable::Base_Tag>().render_executed);
EXPECT_EQ(spectrum->read_state<Spectrum::Base_Tag>().sample_count, 128u);
}
EXPECT_GT(changed_frames, 700u);