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-20 22:20:23 +08:00
parent 89ea8239be
commit e67161c90d
60 changed files with 1920 additions and 458 deletions
Download Patch File Download Diff File Expand all files Collapse all files
render_2D/tests/Plottable_Migration_Test.cpp
+132
View File
@@ -0,0 +1,132 @@
#include <render_2D/plottable/Plottables.hpp>
#include <render_2D/scene/Render_Scene_2D.hpp>
#include <gtest/gtest.h>
#include <array>
namespace {
using namespace aethera;
using namespace aethera::render_2d;
template <typename Object, typename... Args>
std::unique_ptr<Object> build_object(Args&&... args) {
typename Object::Builder builder(std::forward<Args>(args)...);
auto result = builder.build();
if (!result) std::terminate();
return std::move(result).value();
}
template <typename Axis>
void configure_axis(Axis* axis, Axis_Orientation orientation, Point_F position, Axis_Pixel_Length length, Size canvas) {
axis->template update_state<&Abs_Axis::State::orientation>(orientation);
axis->template update_state<&Abs_Axis::State::position>(position);
axis->template update_state<&Abs_Axis::State::pixel_length>(length);
axis->template update_state<&Abs_Axis::State::canvas_size>(canvas);
}
}
TEST(plottable_migration, curve_plots_share_partitioned_rendering) {
using Scene = Impl<Render_Scene_2D>;
using Frequency = Impl<Frequency_Axis>;
using Numeric = Impl<Numeric_Axis>;
using Time = Impl<Time_Axis>;
using Trace = Impl<Frequency_Trace>;
using Sweep = Impl<Sweep_Spectrum>;
initialize_runtime(2);
const Size canvas{160, 120};
auto scene = build_object<Scene>();
auto frequency = build_object<Frequency>();
auto power = build_object<Numeric>();
auto time = build_object<Time>();
auto value = build_object<Numeric>();
configure_axis(frequency.get(), Axis_Orientation::horizontal, {20.0, 100.0}, 120.0, canvas);
configure_axis(power.get(), Axis_Orientation::vertical, {20.0, 100.0}, -80.0, canvas);
configure_axis(time.get(), Axis_Orientation::horizontal, {20.0, 100.0}, 120.0, canvas);
configure_axis(value.get(), Axis_Orientation::vertical, {20.0, 100.0}, -80.0, canvas);
frequency->update_state<&Numeric_Axis::State::coordinate_range>(Axis_Range{0.0, 100.0});
power->update_state<&Numeric_Axis::State::coordinate_range>(Axis_Range{-100.0, 0.0});
value->update_state<&Numeric_Axis::State::coordinate_range>(Axis_Range{0.0, 100.0});
auto trace = build_object<Trace>(scene.get(), time.get(), value.get());
auto sweep = build_object<Sweep>(scene.get(), frequency.get(), power.get());
trace->update_state<&Frequency_Trace::State::partition_mode>(Plot_Partition_Mode::fixed);
trace->update_state<&Frequency_Trace::State::partition_count>(2u);
trace->append_sample(0, 10.0);
trace->append_sample(1, 50.0);
trace->append_sample(2, 90.0);
sweep->update_state<&Sweep_Spectrum::State::frequency_range>(Axis_Range{0.0, 100.0});
sweep->update_state<&Sweep_Spectrum::State::partition_mode>(Plot_Partition_Mode::fixed);
sweep->update_state<&Sweep_Spectrum::State::partition_count>(2u);
const std::array<Plot_Value, 4> block{-90.0, -60.0, -30.0, -10.0};
sweep->append_block(block);
scene->update_state<&Render_Scene_2D::State::viewport>(canvas);
scene->activate_view();
EXPECT_EQ(scene->render_frame(), Render_Frame_Status::rendered);
EXPECT_EQ(trace->sample_count(), 3u);
EXPECT_GT(trace->rendered_point_count(), 0u);
EXPECT_EQ(sweep->stored_block_count(), 1u);
EXPECT_GT(sweep->rendered_point_count(), 0u);
}
TEST(plottable_migration, raster_plots_share_partitioned_color_blocks) {
using Scene = Impl<Render_Scene_2D>;
using Frequency = Impl<Frequency_Axis>;
using Numeric = Impl<Numeric_Axis>;
using Time = Impl<Time_Axis>;
using Glow = Impl<Afterglow>;
using Fall = Impl<Waterfall>;
initialize_runtime(2);
const Size canvas{160, 120};
auto scene = build_object<Scene>();
auto frequency = build_object<Frequency>();
auto power = build_object<Numeric>();
auto time = build_object<Time>();
configure_axis(frequency.get(), Axis_Orientation::horizontal, {20.0, 100.0}, 120.0, canvas);
configure_axis(power.get(), Axis_Orientation::vertical, {20.0, 100.0}, -80.0, canvas);
configure_axis(time.get(), Axis_Orientation::vertical, {20.0, 100.0}, -80.0, canvas);
frequency->update_state<&Numeric_Axis::State::coordinate_range>(Axis_Range{0.0, 100.0});
power->update_state<&Numeric_Axis::State::coordinate_range>(Axis_Range{-100.0, 0.0});
auto glow = build_object<Glow>(scene.get(), frequency.get(), power.get());
auto waterfall = build_object<Fall>(scene.get(), frequency.get(), time.get());
glow->update_state<&Afterglow::State::frequency_range>(Axis_Range{0.0, 100.0});
glow->update_state<&Afterglow::State::power_range>(Axis_Range{-100.0, 0.0});
glow->update_state<&Afterglow::State::power_point_size>(16u);
waterfall->update_state<&Waterfall::State::frequency_range>(Axis_Range{0.0, 100.0});
waterfall->update_state<&Waterfall::State::power_range>(Axis_Range{-100.0, 0.0});
const std::array<Plot_Value, 4> row{-90.0, -60.0, -30.0, -10.0};
glow->append_spectrum(row);
waterfall->append_row(0, row);
waterfall->append_row(1, row);
scene->update_state<&Render_Scene_2D::State::viewport>(canvas);
scene->activate_view();
EXPECT_EQ(scene->render_frame(), Render_Frame_Status::rendered);
EXPECT_EQ(glow->history_count(), 1u);
EXPECT_GT(glow->rendered_cell_count(), 0u);
EXPECT_EQ(waterfall->row_count(), 2u);
EXPECT_GT(waterfall->rendered_cell_count(), 0u);
}
TEST(plottable_migration, direct_overlay_and_constellation_build_and_render) {
using Scene = Impl<Render_Scene_2D>;
using Numeric = Impl<Numeric_Axis>;
using Diagram = Impl<Constellation_Diagram>;
using Overlay = Impl<Selection_Rectangle_Overlay>;
initialize_runtime(2);
const Size canvas{160, 120};
auto scene = build_object<Scene>();
auto horizontal = build_object<Numeric>();
auto vertical = build_object<Numeric>();
configure_axis(horizontal.get(), Axis_Orientation::horizontal, {20.0, 100.0}, 120.0, canvas);
configure_axis(vertical.get(), Axis_Orientation::vertical, {20.0, 100.0}, -80.0, canvas);
horizontal->update_state<&Numeric_Axis::State::coordinate_range>(Axis_Range{-1.0, 1.0});
vertical->update_state<&Numeric_Axis::State::coordinate_range>(Axis_Range{-1.0, 1.0});
auto diagram = build_object<Diagram>(scene.get(), horizontal.get(), vertical.get());
auto overlay = build_object<Overlay>(scene.get(), horizontal.get(), vertical.get());
diagram->update_state<&Constellation_Diagram::State::i_range>(Axis_Range{-1.0, 1.0});
diagram->update_state<&Constellation_Diagram::State::q_range>(Axis_Range{-1.0, 1.0});
diagram->append_point({0.25, -0.25});
scene->update_state<&Render_Scene_2D::State::viewport>(canvas);
scene->activate_view();
EXPECT_EQ(scene->render_frame(), Render_Frame_Status::rendered);
EXPECT_EQ(diagram->point_count(), 1u);
EXPECT_EQ(overlay->read_state<Renderable_State_Tag>().prepare_task_count, 0u);
EXPECT_EQ(overlay->read_state<Renderable_State_Tag>().paint_task_count, 1u);
}
render_2D/tests/Spectrum_Test.cpp
+65 -18
View File
@@ -24,18 +24,54 @@ TEST(spectrum_data, publishes_samples_and_interpolates_power) {
using Frequency = Impl<Frequency_Axis>;
using Power = Impl<Numeric_Axis>;
using Object = Impl<Spectrum>;
using Scene_Object = Impl<Render_Scene_2D>;
auto scene = build_object<Scene_Object>();
auto frequency = build_object<Frequency>();
auto power = build_object<Power>();
auto spectrum = build_object<Object>(frequency.get(), power.get());
auto spectrum = build_object<Object>(scene.get(), frequency.get(), power.get());
const auto missing = spectrum->power_at(25.0);
ASSERT_FALSE(missing.has_value());
EXPECT_EQ(missing.error(), Spectrum::Power_At_Result::no_samples);
spectrum->update_state<&Spectrum::State::frequency_range>(Axis_Range{0.0, 100.0});
const double samples[]{-100.0, -50.0, 0.0};
spectrum->update_samples(samples);
spectrum->advance();
EXPECT_EQ(spectrum->sample_count(), 3u);
double value{};
EXPECT_TRUE(spectrum->power_at(25.0, value));
EXPECT_DOUBLE_EQ(value, -75.0);
EXPECT_FALSE(spectrum->power_at(101.0, value));
const auto value = spectrum->power_at(25.0);
ASSERT_TRUE(value.has_value());
EXPECT_DOUBLE_EQ(*value, -75.0);
const auto outside = spectrum->power_at(101.0);
ASSERT_FALSE(outside.has_value());
EXPECT_EQ(outside.error(), Spectrum::Power_At_Result::frequency_out_of_range);
}
TEST(spectrum_markers, supports_selection_frequency_changes_and_known_results) {
using Frequency = Impl<Frequency_Axis>;
using Power = Impl<Numeric_Axis>;
using Object = Impl<Spectrum>;
using Scene_Object = Impl<Render_Scene_2D>;
auto scene = build_object<Scene_Object>();
auto frequency = build_object<Frequency>();
auto power = build_object<Power>();
auto spectrum = build_object<Object>(scene.get(), frequency.get(), power.get());
spectrum->add_custom_marker(10.0);
spectrum->add_custom_line_marker(20.0);
spectrum->advance();
EXPECT_EQ(spectrum->selectable_line_marker_count(), 2u);
spectrum->set_selected_marker_index(1);
spectrum->advance();
EXPECT_EQ(spectrum->selected_marker_index(), 1);
EXPECT_EQ(spectrum->set_current_marker_frequency(25.0), Spectrum::Set_Current_Marker_Frequency_Result::updated);
spectrum->advance();
const auto frequency_value = spectrum->marker_frequency(1);
ASSERT_TRUE(frequency_value.has_value());
EXPECT_DOUBLE_EQ(*frequency_value, 25.0);
const auto invalid = spectrum->marker_frequency(2);
ASSERT_FALSE(invalid.has_value());
EXPECT_EQ(invalid.error(), Spectrum::Marker_Frequency_Result::index_out_of_range);
spectrum->remove_selected_marker();
spectrum->advance();
EXPECT_EQ(spectrum->selectable_line_marker_count(), 1u);
EXPECT_EQ(spectrum->selected_marker_index(), -1);
}
TEST(render_scene_2d, composites_axes_and_spectrum_into_final_frame) {
using Frequency = Impl<Frequency_Axis>;
@@ -43,10 +79,10 @@ TEST(render_scene_2d, composites_axes_and_spectrum_into_final_frame) {
using Spectrum_Object = Impl<Spectrum>;
using Scene_Object = Impl<Render_Scene_2D>;
initialize_runtime(2);
auto scene = build_object<Scene_Object>();
auto frequency = build_object<Frequency>();
auto power = build_object<Power>();
auto spectrum = build_object<Spectrum_Object>(frequency.get(), power.get());
auto scene = build_object<Scene_Object>();
auto spectrum = build_object<Spectrum_Object>(scene.get(), frequency.get(), power.get());
const Size canvas{160, 120};
frequency->update_state<&Abs_Axis::State::position>(Point_F{20.0, 100.0});
frequency->update_state<&Abs_Axis::State::canvas_size>(canvas);
@@ -58,6 +94,8 @@ TEST(render_scene_2d, composites_axes_and_spectrum_into_final_frame) {
power->update_state<&Abs_Axis::State::orientation>(Axis_Orientation::vertical);
power->update_state<&Numeric_Axis::State::coordinate_range>(Axis_Range{-100.0, 0.0});
spectrum->update_state<&Spectrum::State::frequency_range>(Axis_Range{0.0, 100.0});
spectrum->update_state<&Spectrum::State::partition_mode>(Spectrum_Partition_Mode::fixed);
spectrum->update_state<&Spectrum::State::partition_count>(3u);
spectrum->update_state<&Spectrum::State::sweep_region_visible>(true);
spectrum->update_state<&Spectrum::State::max_hold_visible>(true);
const double samples[]{-90.0, -65.0, -20.0, -45.0, -75.0};
@@ -65,23 +103,32 @@ TEST(render_scene_2d, composites_axes_and_spectrum_into_final_frame) {
scene->update_state<&Render_Scene_2D::State::viewport>(canvas);
scene->update_state<&Render_Scene_2D::State::background>(Color::transparent());
scene->activate_view();
ASSERT_TRUE((scene->edit_dependency_graph<Prepare_Data_Tag, Paint_Tag>([&](auto& prepare, auto& paint) {
prepare.add(frequency.get());
prepare.add(power.get());
prepare.add(spectrum.get());
prepare.template add_dependency<&Numeric_Axis::State::coordinate_range>(spectrum.get(), frequency.get());
prepare.template add_dependency<&Numeric_Axis::State::coordinate_range>(spectrum.get(), power.get());
paint.add(frequency.get());
paint.add(power.get());
paint.add(spectrum.get());
}).has_value()));
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()));
EXPECT_EQ(scene->render_frame(), Render_Frame_Status::rendered);
EXPECT_GT(spectrum->rendered_point_count(), 0u);
const auto& render_state = spectrum->read_state<Renderable_State_Tag>();
EXPECT_EQ(render_state.prepare_task_count, 4u);
EXPECT_EQ(render_state.paint_task_count, 1u);
const Image_View frame = scene->frame_view();
ASSERT_FALSE(frame.empty());
EXPECT_TRUE(contains_color(frame));
spectrum->update_state<&Spectrum::State::partition_count>(2u);
spectrum->update_samples(samples);
EXPECT_EQ(scene->render_frame(), Render_Frame_Status::rendered);
const auto& rebuilt_state = spectrum->read_state<Renderable_State_Tag>();
EXPECT_TRUE(rebuilt_state.prepare_graph_rebuilt);
EXPECT_EQ(rebuilt_state.prepare_task_count, 3u);
EXPECT_TRUE(contains_color(scene->frame_view()));
const Size resized_canvas{200, 140};
scene->update_state<&Render_Scene_2D::State::viewport>(resized_canvas);
frequency->update_state<&Abs_Axis::State::canvas_size>(resized_canvas);
power->update_state<&Abs_Axis::State::canvas_size>(resized_canvas);
EXPECT_EQ(scene->render_frame(), Render_Frame_Status::rendered);
EXPECT_TRUE(contains_color(scene->frame_view()));
const Image_View resized_frame = scene->frame_view();
EXPECT_EQ(resized_frame.width, resized_canvas.width);
EXPECT_EQ(resized_frame.height, resized_canvas.height);
EXPECT_TRUE(contains_color(resized_frame));
}