feat: wire the scene into the simulation engine

6 files changed, 46 insertions, 8 deletions

diff --git a/src/rendering/black_hole_renderer.cpp b/src/rendering/black_hole_renderer.cpp
index c7b58c5..55d0ff2 100644
--- a/src/rendering/black_hole_renderer.cpp
+++ b/src/rendering/black_hole_renderer.cpp
@@ -42,9 +42,6 @@ namespace Donut
         m_sim_ubo  = device.create_buffer(BufferType::Uniform, 16);
 
         std::vector<uint8_t> obj(800, 0);
-        int num_objects = 1;                          std::memcpy(obj.data() +   0, &num_objects, 4);
-        float pos_radius[4] = { 0, 0, 0, SagA_rs };   std::memcpy(obj.data() +  16, pos_radius, 16);
-        float color[4]      = { 0, 0, 0, 1 };         std::memcpy(obj.data() + 272, color, 16);
         m_obj_ubo->update(obj.data(), obj.size());
 
         {
@@ -78,7 +75,8 @@ namespace Donut
     }
 
     auto BlackHoleRenderer::render_geodesic(RHI::CommandList& cmd, const GeodesicView& view,
-                                            const BlackHoleParams& params, RHI::Texture* cubemap) -> void
+                                            const BlackHoleParams& params,
+                                            const std::vector<SceneObject>& objects, RHI::Texture* cubemap) -> void
     {
         CamUBO cam{};
         cam.pos = view.position; cam.right = view.right; cam.up = view.up; cam.fwd = view.forward;
@@ -106,6 +104,22 @@ namespace Donut
         };
         m_disk_ubo->update(disk, sizeof(disk));
 
+        {
+            const float k = SagA_rs / SCENE_UNITS_PER_RS;
+            std::vector<uint8_t> objbuf(800, 0);
+            int n = std::min((int)objects.size(), 16);
+            std::memcpy(objbuf.data(), &n, 4);
+            for (int i = 0; i < n; ++i)
+            {
+                const SceneObject& o = objects[i];
+                float pr[4]  = { o.position.x * k, o.position.y * k, o.position.z * k, o.radius * k };
+                float col[4] = { o.color.r, o.color.g, o.color.b, 1.0f };
+                std::memcpy(objbuf.data() + 16  + 16 * i, pr,  16);
+                std::memcpy(objbuf.data() + 272 + 16 * i, col, 16);
+            }
+            m_obj_ubo->update(objbuf.data(), objbuf.size());
+        }
+
         RenderTarget* target = view.moving ? m_geo_lo.get() : m_geo_hi.get();
         m_last_target = target;
 
diff --git a/src/rendering/black_hole_renderer.h b/src/rendering/black_hole_renderer.h
index b68a791..414cd0c 100644
--- a/src/rendering/black_hole_renderer.h
+++ b/src/rendering/black_hole_renderer.h
@@ -3,6 +3,7 @@
 #include "rhi.h"
 #include "scene/scene_types.h"
 #include <glm/glm.hpp>
+#include <vector>
 
 namespace Donut
 {
@@ -24,7 +25,8 @@ namespace Donut
         auto init(RHI::Device& device) -> bool;
 
         auto render_geodesic(RHI::CommandList& cmd, const GeodesicView& view,
-                             const BlackHoleParams& params, RHI::Texture* cubemap) -> void;
+                             const BlackHoleParams& params,
+                             const std::vector<SceneObject>& objects, RHI::Texture* cubemap) -> void;
 
         auto blit(RHI::CommandList& cmd, int fb_width, int fb_height) -> void;
 
diff --git a/src/rendering/render_path.cpp b/src/rendering/render_path.cpp
index b096302..0963d2a 100644
--- a/src/rendering/render_path.cpp
+++ b/src/rendering/render_path.cpp
@@ -39,8 +39,6 @@ namespace Donut
             cmd.begin_render_pass(nullptr, clear);
             if (view == View::Scene)
             {
-                float aspect = (float)fb_width / (float)std::max(fb_height, 1);
-                scene.scene_camera.set_projection(45.0f, aspect, 0.1f, 1000.0f);
                 CameraView cv;
                 cv.view       = scene.scene_camera.get_view_matrix();
                 cv.projection = scene.scene_camera.get_projection_matrix();
@@ -72,7 +70,7 @@ namespace Donut
             gv.moving = moving;
             gv.time = time;
 
-            m_black_hole_renderer->render_geodesic(cmd, gv, scene.black_hole, m_cubemap.get());
+            m_black_hole_renderer->render_geodesic(cmd, gv, scene.black_hole, scene.objects, m_cubemap.get());
             cmd.begin_render_pass(nullptr, clear);
             m_black_hole_renderer->blit(cmd, fb_width, fb_height);
             m_device->imgui_render(cmd);
diff --git a/src/rendering/rhi.h b/src/rendering/rhi.h
index 7684aa0..db0711b 100644
--- a/src/rendering/rhi.h
+++ b/src/rendering/rhi.h
@@ -102,6 +102,8 @@ namespace Donut::RHI
         virtual auto resize(int width, int height) -> void = 0;
         virtual auto wait_idle() -> void = 0;
 
+        virtual auto set_vsync(bool enabled) -> void { (void)enabled; }
+
         virtual auto create_buffer(BufferType type, size_t size, const void* data = nullptr) -> Ref<Buffer> = 0;
         virtual auto create_texture(int width, int height, Format format, Filter filter, const void* data = nullptr) -> Ref<Texture> = 0;
         virtual auto create_cubemap_from_hdri(const std::string& equirect_path) -> Ref<Texture> = 0;
diff --git a/src/rendering/scene_renderer.cpp b/src/rendering/scene_renderer.cpp
index c9da332..c2dd9d1 100644
--- a/src/rendering/scene_renderer.cpp
+++ b/src/rendering/scene_renderer.cpp
@@ -38,6 +38,8 @@ namespace Donut
 
         struct SkyboxUBO { glm::mat4 projection; glm::mat4 view; };
         static_assert(sizeof(SkyboxUBO) == 128, "SkyboxUBO std140 layout mismatch");
+
+        constexpr float BH_SCENE_RADIUS = SCENE_UNITS_PER_RS;
     }
 
     auto SceneRenderer::init(RHI::Device& device) -> bool
@@ -128,6 +130,8 @@ namespace Donut
             m_skybox_pipeline = device.create_pipeline(d);
         }
 
+        m_bh_ubo = device.create_buffer(BufferType::Uniform, sizeof(SphereUBO));
+
         DONUT_INFO("SceneRenderer ready ({} grid verts, {} sphere indices, skybox)",
                    m_grid_vertex_count, m_sphere_index_count);
         return true;
@@ -182,6 +186,23 @@ namespace Donut
                 cmd.bind_index_buffer(m_sphere_ib.get());
                 cmd.draw_indexed(m_sphere_index_count);
             }
+
+            SphereUBO bh{};
+            bh.view_projection = vp;
+            bh.transform       = glm::scale(glm::mat4(1.0f), glm::vec3(BH_SCENE_RADIUS));
+            bh.color           = glm::vec3(0.02f);
+            bh.specular        = 0.10f;
+            bh.light_pos       = glm::vec3(10.0f, 20.0f, 10.0f);
+            bh.camera_pos      = cam.position;
+            bh.is_selected     = 1;
+            bh.outline_color   = glm::vec3(0.98f, 0.62f, 0.20f);
+            bh.outline_width   = 0.30f;
+            m_bh_ubo->update(&bh, sizeof(bh));
+            cmd.bind_uniform(0, m_bh_ubo.get());
+            cmd.bind_texture(1, cubemap);
+            cmd.bind_vertex_buffer(m_sphere_vb.get());
+            cmd.bind_index_buffer(m_sphere_ib.get());
+            cmd.draw_indexed(m_sphere_index_count);
         }
 
         {
diff --git a/src/rendering/scene_renderer.h b/src/rendering/scene_renderer.h
index 06d9d49..4939d43 100644
--- a/src/rendering/scene_renderer.h
+++ b/src/rendering/scene_renderer.h
@@ -40,6 +40,7 @@ namespace Donut
         Ref<RHI::Buffer>   m_sphere_ib;
         int                m_sphere_index_count = 0;
         std::vector<Ref<RHI::Buffer>> m_sphere_ubos;
+        Ref<RHI::Buffer>   m_bh_ubo;
 
         Ref<RHI::Pipeline> m_skybox_pipeline;
         Ref<RHI::Buffer>   m_skybox_vb;