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

删除realtime 的一个组件

Browse Source
This commit is contained in:
种太阳的热带美短
2026-08-14 12:27:12 +08:00
parent 38231dbc1c
commit dfb2de6bf7
24 changed files with 3972 additions and 421 deletions
Download Patch File Download Diff File Expand all files Collapse all files
render_3D/tests/Point_State_Tests.cpp
+50 -47
View File
@@ -13,9 +13,7 @@ namespace renderive::render_3d {
namespace {
TEST(PointState, UsesKernelDoubleStateAtFrameBoundary) {
auto data = std::make_shared<Point_Data>();
data->update(std::vector<Point>{{{1.0F, 2.0F, 3.0F}, {1, 2, 3, 255}, 7.0F}});
Point_Visual visual(data);
Point_Visual visual({{{1.0F, 2.0F, 3.0F}, {1, 2, 3, 255}, 7.0F}});
Point_State configured;
configured.visible = false;
@@ -24,15 +22,14 @@ TEST(PointState, UsesKernelDoubleStateAtFrameBoundary) {
const auto published = detail::Point_State_Access::publish(visual);
EXPECT_EQ(published.state, configured);
ASSERT_EQ(published.data.size(), 1U);
EXPECT_EQ(published.data.front().position, (Vec3{1.0F, 2.0F, 3.0F}));
ASSERT_EQ(published.data->size(), 1U);
EXPECT_EQ(published.data->front().position, (Vec3{1.0F, 2.0F, 3.0F}));
EXPECT_EQ(published.state_revision, 1U);
EXPECT_EQ(published.data_revision, 1U);
}
TEST(PointState, UsesKernelLatestRealTimeDataForBulkPayloads) {
auto data = std::make_shared<Point_Data>();
Point_Visual visual(data);
TEST(PointState, PublishesImmutableBulkPayloadsThroughDoubleBuffer) {
Point_Visual visual;
constexpr int update_count = 500;
std::atomic<bool> done{};
@@ -43,82 +40,88 @@ TEST(PointState, UsesKernelLatestRealTimeDataForBulkPayloads) {
point.position.x = static_cast<float>(value);
point.diameter_px = static_cast<float>(value % 12 + 1);
}
data->update(std::move(points));
visual.update_points(std::move(points));
}
done.store(true, std::memory_order_release);
});
do {
const auto published = detail::Point_State_Access::publish(visual);
if (!published.data.empty()) {
const float expected = published.data.front().position.x;
for (const auto& point : published.data)
if (!published.data->empty()) {
const float expected = published.data->front().position.x;
for (const auto& point : *published.data)
EXPECT_EQ(point.position.x, expected);
}
} while (!done.load(std::memory_order_acquire));
writer.join();
const auto published = detail::Point_State_Access::publish(visual);
EXPECT_EQ(published.data_revision, update_count);
ASSERT_FALSE(published.data.empty());
EXPECT_EQ(published.data.front().position.x, static_cast<float>(update_count));
EXPECT_GT(published.data_revision, 0U);
EXPECT_LE(published.data_revision, update_count);
ASSERT_FALSE(published.data->empty());
EXPECT_EQ(published.data->front().position.x, static_cast<float>(update_count));
}
TEST(PointState, RejectsInvalidStateAndPayloadAtTheOwningBoundary) {
auto data = std::make_shared<Point_Data>();
Point_Visual visual(data);
Point_Visual visual;
Point_State invalid;
invalid.style.stroke_width_px = -1.0F;
EXPECT_THROW(visual.configure(invalid), std::invalid_argument);
data->update(std::vector<Point>{{{}, {}, 0.0F}});
EXPECT_THROW((void)detail::Point_State_Access::publish(visual),
EXPECT_THROW(visual.update_points(std::vector<Point>{{{}, {}, 0.0F}}),
std::invalid_argument);
}
TEST(PointFrameControl, ReusesKernelManualAndPlaybackStrategies) {
auto data = std::make_shared<Point_Data>();
data->update(std::vector<Point>{{{}, {}, 8.0F}});
Point_Visual visual(data);
TEST(PointFrameControl, UsesDedicatedThreeDimensionalFrameStrategy) {
Point_Visual visual(std::vector<Point>{{{}, {}, 8.0F}});
detail::Scene_State_Buffer scene({{320, 180}, {}});
detail::Input_Collector input;
const auto prepare = [&](detail::Point_Frame_Strategy& strategy) {
auto lease = strategy.acquire_painter();
if (!lease)
return false;
auto published_scene = scene.publish_state();
lease->scene = std::move(published_scene.state);
lease->scene_revision = published_scene.revision;
lease->point = detail::Point_State_Access::publish(visual);
lease->input = input.drain();
return true;
};
detail::Frame_Scheduler manual(Frame_Mode::Manual, 60.0);
EXPECT_TRUE(manual.prepare(scene, visual, input));
detail::Point_Frame_Strategy manual(Frame_Mode::Manual, 60.0);
EXPECT_TRUE(prepare(manual));
auto manual_status = manual.status();
EXPECT_EQ(manual_status.mode, Frame_Mode::Manual);
EXPECT_EQ(manual_status.produced_frame_count, 1U);
EXPECT_EQ(manual_status.pending_frame_count, 1U);
bool rendered{};
EXPECT_FALSE(manual.render([&](const detail::Point_Frame_Data&) {
rendered = true;
return true;
}));
EXPECT_FALSE(rendered);
EXPECT_FALSE(static_cast<bool>(manual.acquire_renderer()));
EXPECT_TRUE(manual.refresh());
EXPECT_TRUE(manual.render([&](const detail::Point_Frame_Data& frame) {
rendered = true;
EXPECT_EQ(frame.point.data.size(), 1U);
return true;
}));
EXPECT_TRUE(rendered);
{
auto rendered = manual.acquire_renderer();
ASSERT_TRUE(rendered);
EXPECT_EQ(rendered->point.data->size(), 1U);
}
manual_status = manual.status();
EXPECT_EQ(manual_status.consumed_frame_count, 1U);
EXPECT_EQ(manual_status.pending_frame_count, 0U);
detail::Frame_Scheduler playback(Frame_Mode::Playback, 60.0);
EXPECT_TRUE(playback.prepare(scene, visual, input));
data->update(std::vector<Point>(2, Point{{}, {}, 8.0F}));
EXPECT_TRUE(playback.prepare(scene, visual, input));
detail::Point_Frame_Strategy playback(Frame_Mode::Playback, 60.0);
EXPECT_TRUE(prepare(playback));
visual.update_points(std::vector<Point>(2, Point{{}, {}, 8.0F}));
EXPECT_TRUE(prepare(playback));
auto playback_status = playback.status();
EXPECT_EQ(playback_status.produced_frame_count, 2U);
EXPECT_EQ(playback_status.pending_frame_count, 2U);
EXPECT_TRUE(playback.render([](const detail::Point_Frame_Data& frame) {
return frame.point.data.size() == 1U;
}));
EXPECT_TRUE(playback.render([](const detail::Point_Frame_Data& frame) {
return frame.point.data.size() == 2U;
}));
{
auto first = playback.acquire_renderer();
ASSERT_TRUE(first);
EXPECT_EQ(first->point.data->size(), 1U);
}
{
auto second = playback.acquire_renderer();
ASSERT_TRUE(second);
EXPECT_EQ(second->point.data->size(), 2U);
}
playback_status = playback.status();
EXPECT_EQ(playback_status.consumed_frame_count, 2U);
EXPECT_EQ(playback_status.pending_frame_count, 0U);