加入3D

kernel/src/kernel/event.ipp

@@ -0,0 +1,20 @@
+#pragma once
+namespace aethera {
+inline Event::Event(Event_Type value) : type(value) {}
+inline Event::~Event() = default;
+inline void Event::accept() const noexcept { accepted = true; }
+inline bool Event::is_accepted() const noexcept { return accepted; }
+constexpr Keyboard_Modifier operator|(Keyboard_Modifier left, Keyboard_Modifier right) noexcept { return static_cast<Keyboard_Modifier>(static_cast<std::uint8_t>(left) | static_cast<std::uint8_t>(right)); }
+template <Event_Point Point> Basic_Pointer_Event<Point>::Basic_Pointer_Event(Event_Type value) : Event(value) {}
+template <Event_Point Point> double Basic_Pointer_Event<Point>::position_x() const noexcept { return static_cast<double>(position.x); }
+template <Event_Point Point> double Basic_Pointer_Event<Point>::position_y() const noexcept { return static_cast<double>(position.y); }
+template <Event_Point Point> Mouse_Button Basic_Pointer_Event<Point>::pointer_button() const noexcept { return button; }
+template <Event_Point Point> Keyboard_Modifier Basic_Pointer_Event<Point>::keyboard_modifiers() const noexcept { return modifiers; }
+template <Event_Point Point> Basic_Wheel_Event<Point>::Basic_Wheel_Event() : Basic_Pointer_Event<Point>(Event_Type::wheel) {}
+template <Event_Point Point> double Basic_Wheel_Event<Point>::pixel_delta_x_value() const noexcept { return pixel_delta_x; }
+template <Event_Point Point> double Basic_Wheel_Event<Point>::pixel_delta_y_value() const noexcept { return pixel_delta_y; }
+template <Event_Point Point> double Basic_Wheel_Event<Point>::angle_delta_x_value() const noexcept { return angle_delta_x; }
+template <Event_Point Point> double Basic_Wheel_Event<Point>::angle_delta_y_value() const noexcept { return angle_delta_y; }
+template <Event_Size Size> Basic_Resize_Event<Size>::Basic_Resize_Event() : Event(Event_Type::resize) {}
+inline Key_Event::Key_Event(Event_Type value) : Event(value) {}
+}

render_3D/tests/Visual_Tests.cpp

@@ -0,0 +1,69 @@
+#include <render_3D/Render_3D.hpp>
+#include <gtest/gtest.h>
+#include <chrono>
+#include <thread>
+namespace aethera::render_3d {
+namespace {
+template <typename Visual, typename Item>
+void verify_visual(Item valid, Item invalid) {
+    using Object = Impl<Visual>;
+    auto built = typename Object::Builder{}.build();
+    ASSERT_TRUE(built.has_value());
+    auto object = std::move(built).value();
+    EXPECT_EQ(object->update_items({valid}), Visual::Update_Items_Result::updated);
+    EXPECT_EQ(object->update_items({invalid}), Visual::Update_Items_Result::invalid_data);
+    object->advance();
+    EXPECT_EQ(object->item_count(), 1U);
+    EXPECT_EQ(object->template read_state<typename Visual::Base_Tag>().item_count, 1U);
+}
+}
+TEST(Render_3D_Visual, Migrated_Families_Build_And_Validate) {
+    verify_visual<Point_Visual>(Point{}, Point{.diameter_px = 0.0F});
+    verify_visual<Splat_Visual>(Splat{}, Splat{.sigma = {0.0F, 0.0F}});
+    verify_visual<Pixel_Visual>(Pixel{}, Pixel{.size_px = 0.0F});
+    verify_visual<Marker_Visual>(Marker{}, Marker{.diameter_px = 0.0F});
+    verify_visual<Sphere_Visual>(Sphere{}, Sphere{.radius = 0.0F});
+    verify_visual<Segment_Visual>(Segment{}, Segment{.width_px = 0.0F});
+    verify_visual<Vector_Visual>(Vector_Glyph{}, Vector_Glyph{.width_px = 0.0F});
+    verify_visual<Primitive_Visual>(Primitive_Vertex{}, Primitive_Vertex{.position = {NAN, 0.0F, 0.0F}});
+    verify_visual<Mesh_Visual>(Mesh_Vertex{}, Mesh_Vertex{.normal = {NAN, 0.0F, 0.0F}});
+    verify_visual<Path_Visual>(Path_Vertex{}, Path_Vertex{.width_px = 0.0F});
+    verify_visual<Image_Visual>(Image{}, Image{.extent = {0.0F, 0.0F}});
+    verify_visual<Labels_Visual>(Label{}, Label{.extent = {0.0F, 0.0F}});
+    verify_visual<Glyph_Visual>(Glyph{}, Glyph{.angle = NAN});
+    verify_visual<Text_Visual>(Text_Label{.text = "A"}, Text_Label{});
+    verify_visual<Volume_Visual>(Voxel{}, Voxel{.value = NAN});
+}
+TEST(Render_3D_Scene, Builder_Instantiates_Async_Paint_Contract) {
+    using Visual_Object = Impl<Point_Visual>;
+    using Scene_Object = Impl<Render_Scene_3D>;
+    auto visual_result = typename Visual_Object::Builder{}.build();
+    ASSERT_TRUE(visual_result.has_value());
+    auto visual = std::move(visual_result).value();
+    typename Scene_Object::Builder scene_builder(visual.get());
+    static_assert(std::same_as<decltype(scene_builder.build()), std::expected<std::unique_ptr<Scene_Object>, Dependency_Graph_Error>>);
+}
+TEST(Render_3D_Scene, Paint_Submits_Without_Waiting_For_Gpu) {
+    using Visual_Object = Impl<Point_Visual>;
+    using Scene_Object = Impl<Render_Scene_3D>;
+    auto visual_result = typename Visual_Object::Builder{}.build();
+    ASSERT_TRUE(visual_result.has_value());
+    auto visual = std::move(visual_result).value();
+    ASSERT_EQ(visual->update_items({Point{.position = {0.0F, 0.0F, 0.0F}, .color = Color::red_color(), .diameter_px = 8.0F}}), Point_Visual::Update_Items_Result::updated);
+    visual->advance();
+    try {
+        auto scene_result = typename Scene_Object::Builder(visual.get()).build();
+        ASSERT_TRUE(scene_result.has_value());
+        auto scene = std::move(scene_result).value();
+        const auto started = std::chrono::steady_clock::now();
+        EXPECT_EQ(scene->request_frame(), Render_Scene_3D::Request_Frame_Result::queued);
+        const auto submit_duration = std::chrono::steady_clock::now() - started;
+        EXPECT_LT(submit_duration, std::chrono::seconds(1));
+        for (std::size_t attempt = 0; attempt != 500 && !scene->latest_frame(); ++attempt) std::this_thread::sleep_for(std::chrono::milliseconds(10));
+        EXPECT_NE(scene->latest_frame(), nullptr);
+    }
+    catch (const std::exception& error) {
+        GTEST_SKIP() << "Vulkan/Datoviz unavailable: " << error.what();
+    }
+}
+}