[feat]: implement ui layer arch

24 files changed, 1937 insertions, 1621 deletions

diff --git a/src/core/application.cpp b/src/core/application.cpp
index 9cd19ec..1541e34 100644
--- a/src/core/application.cpp
+++ b/src/core/application.cpp
@@ -2,25 +2,21 @@
 
 #include "rendering/render_api.h"    // RendererAPI
 #include "settings_manager.h"
-#include "hdri_manager.h"
 
 #include "platform/opengl/opengl_device.h"
 #include "platform/vulkan/vulkan_device.h"
 
 #include <GLFW/glfw3.h>
 #include <imgui.h>
-
-#include <glm/gtc/matrix_transform.hpp>
+#include <glm/glm.hpp>
 #include <algorithm>
-#include <cmath>
-#include <numbers>
 
 namespace Donut
 {
     Application* Application::s_instance = nullptr;
 
     // Scroll is delivered through a GLFW callback; accumulate it here and drain it
-    // once per frame in process_input (chaining ImGui's own scroll handler).
+    // once per frame in update_input (chaining ImGui's own scroll handler).
     static double        g_scroll_accum = 0.0;
     static GLFWscrollfun g_prev_scroll  = nullptr;
     static void donut_scroll_callback(GLFWwindow* w, double x, double y)
@@ -30,7 +26,6 @@ namespace Donut
     }
 
     Application::Application(const std::string& name, int width, int height)
-        : m_running(true), m_minimized(false)
     {
         s_instance = this;
 
@@ -76,34 +71,10 @@ namespace Donut
             return;
         }
 
-        m_hdri_path = "assets/hdri/hdr_blue_nebulae_1.hdr";
-        m_cubemap = m_device->create_cubemap_from_hdri(m_hdri_path);
-
-        m_scene_renderer = create_scope<SceneRenderer>();
-        m_scene_renderer->init(*m_device);
-        m_black_hole_renderer = create_scope<BlackHoleRenderer>();
-        m_black_hole_renderer->init(*m_device);
-
-        // Black-hole camera: large-scale orbital viewer outside the disk.
-        m_camera.set_camera_mode(CameraMode::Orbital);
-        m_camera.set_orbital_target(glm::vec3(0.0f));
-        m_camera.set_orbital_radius(4e11);          // ~31 r_s: outside the 12 r_s disk
-        m_camera.set_orbital_limits(2.2e11, 1.5e12);
-        m_camera.set_orbital_speed(0.01f);
-        m_camera.set_zoom_speed(3e10);
-        m_camera.set_azimuth(0.0f);
-        m_camera.set_elevation(1.25f);
-
-        // Scene camera: normal-scale orbital world-builder viewer.
-        m_scene_camera.set_camera_mode(CameraMode::Orbital);
-        m_scene_camera.set_orbital_target(glm::vec3(0.0f));
-        m_scene_camera.set_orbital_radius(15.0);
-        m_scene_camera.set_orbital_limits(2.0, 200.0);
-        m_scene_camera.set_orbital_speed(0.01f);
-        m_scene_camera.set_zoom_speed(2.0);
-        m_scene_camera.set_azimuth(0.0f);
-        m_scene_camera.set_elevation((float)std::numbers::pi / 3.0f);
-        m_scene_camera.update_orbital();
+        m_scene = create_scope<Scene>();
+        m_render_path = create_scope<RenderPath>();
+        m_render_path->init(*m_device, m_scene->hdri_path);
+        m_ui = create_scope<UILayer>();
 
         m_device->init_imgui();
         // Load the UI font into the device-created ImGui context (backend-agnostic;
@@ -134,60 +105,19 @@ namespace Donut
         if (!cmd) return;   // frame skipped (e.g. swapchain recreation)
 
         m_device->imgui_new_frame();
-        build_ui();
-        process_input();
+        View view = m_ui->draw(UIContext{ *m_scene, m_device->device_name() });
+        update_input(view);
+        m_render_path->sync_hdri(m_scene->hdri_path);
 
-        const glm::vec4 clear(0.05f, 0.06f, 0.10f, 1.0f);
         int w = 0, h = 0;
         glfwGetFramebufferSize((GLFWwindow*)m_window->get_native_window(), &w, &h);
-
-        if (m_scene_mode)
-        {
-            float aspect = (float)w / (float)std::max(h, 1);
-            m_scene_camera.set_projection(45.0f, aspect, 0.1f, 1000.0f);
-            CameraView cv;
-            cv.view       = m_scene_camera.get_view_matrix();
-            cv.projection = m_scene_camera.get_projection_matrix();
-            cv.position   = m_scene_camera.get_orbital_position();
-            cv.fb_width   = w; cv.fb_height = h;
-
-            cmd->begin_render_pass(nullptr, clear);
-            m_scene_renderer->render(*cmd, cv, m_scene_objects, m_selected_object, m_cubemap.get());
-            m_device->imgui_render(*cmd);
-            cmd->end_render_pass();
-        }
-        else
-        {
-            GeodesicView gv;
-            glm::vec3 pos, fwd;
-            if (m_camera.get_camera_mode() == CameraMode::FPS)
-            {
-                pos = m_camera.get_position();
-                fwd = m_camera.get_forward_direction();
-            }
-            else
-            {
-                pos = m_camera.get_orbital_position();
-                fwd = glm::normalize(m_camera.get_orbital_target() - pos);
-            }
-            glm::vec3 right = glm::normalize(glm::cross(fwd, glm::vec3(0, 1, 0)));
-            gv.position = pos; gv.right = right; gv.up = glm::cross(right, fwd); gv.forward = fwd;
-            gv.tan_half_fov = (float)tan(glm::radians(m_bh_params.fov_degrees * 0.5f));
-            gv.aspect = (float)BlackHoleRenderer::GEO_HI_W / (float)BlackHoleRenderer::GEO_HI_H;
-            gv.moving = m_user_moving;
-            gv.time = (float)(glfwGetTime() - m_start_time);
-
-            m_black_hole_renderer->render_geodesic(*cmd, gv, m_bh_params, m_cubemap.get());
-            cmd->begin_render_pass(nullptr, clear);
-            m_black_hole_renderer->blit(*cmd, w, h);
-            m_device->imgui_render(*cmd);
-            cmd->end_render_pass();
-        }
+        float time = (float)(glfwGetTime() - m_start_time);
+        m_render_path->render(*cmd, *m_scene, view, w, h, m_user_moving, time);
 
         m_device->end_frame();
     }
 
-    auto Application::process_input() -> void
+    auto Application::update_input(View view) -> void
     {
         GLFWwindow* window = (GLFWwindow*)m_window->get_native_window();
         bool over_ui = ImGui::GetCurrentContext() && ImGui::GetIO().WantCaptureMouse;
@@ -200,11 +130,23 @@ namespace Donut
         glfwGetCursorPos(window, &mx, &my);
         bool left_down = glfwGetMouseButton(window, GLFW_MOUSE_BUTTON_LEFT) == GLFW_PRESS;
 
-        if (!m_scene_mode && m_camera.get_camera_mode() == CameraMode::FPS)
+        // Tabs without a live viewport (Setup / Export) have no camera to drive.
+        if (view == View::None)
         {
+            m_left_was_down = left_down;   // keep the drag-edge state coherent
+            g_scroll_accum = 0.0;          // discard scroll over inert tabs
+            m_user_moving = false;
+            return;
+        }
+
+        const bool scene_view = view == View::Scene;
+
+        if (!scene_view && m_scene->sim_camera.get_camera_mode() == CameraMode::FPS)
+        {
+            Camera& cam = m_scene->sim_camera;
             if (left_down && !m_left_was_down) { m_fps_last_x = mx; m_fps_last_y = my; }
             if (left_down && !over_ui)
-                m_camera.on_mouse_move(float(mx - m_fps_last_x), float(m_fps_last_y - my));
+                cam.on_mouse_move(float(mx - m_fps_last_x), float(m_fps_last_y - my));
             m_fps_last_x = mx; m_fps_last_y = my;
             m_left_was_down = left_down;
 
@@ -213,19 +155,19 @@ namespace Donut
             if (!over_kb && dt > 0.0f)
             {
                 float mdt = dt * (glfwGetKey(window, GLFW_KEY_LEFT_SHIFT) == GLFW_PRESS ? 4.0f : 1.0f);
-                if (glfwGetKey(window, GLFW_KEY_W) == GLFW_PRESS) { m_camera.move_forward(mdt);  moved = true; }
-                if (glfwGetKey(window, GLFW_KEY_S) == GLFW_PRESS) { m_camera.move_backward(mdt); moved = true; }
-                if (glfwGetKey(window, GLFW_KEY_A) == GLFW_PRESS) { m_camera.move_left(mdt);     moved = true; }
-                if (glfwGetKey(window, GLFW_KEY_D) == GLFW_PRESS) { m_camera.move_right(mdt);    moved = true; }
-                if (glfwGetKey(window, GLFW_KEY_E) == GLFW_PRESS) { m_camera.move_up(mdt);       moved = true; }
-                if (glfwGetKey(window, GLFW_KEY_Q) == GLFW_PRESS) { m_camera.move_down(mdt);     moved = true; }
+                if (glfwGetKey(window, GLFW_KEY_W) == GLFW_PRESS) { cam.move_forward(mdt);  moved = true; }
+                if (glfwGetKey(window, GLFW_KEY_S) == GLFW_PRESS) { cam.move_backward(mdt); moved = true; }
+                if (glfwGetKey(window, GLFW_KEY_A) == GLFW_PRESS) { cam.move_left(mdt);     moved = true; }
+                if (glfwGetKey(window, GLFW_KEY_D) == GLFW_PRESS) { cam.move_right(mdt);    moved = true; }
+                if (glfwGetKey(window, GLFW_KEY_E) == GLFW_PRESS) { cam.move_up(mdt);       moved = true; }
+                if (glfwGetKey(window, GLFW_KEY_Q) == GLFW_PRESS) { cam.move_down(mdt);     moved = true; }
             }
             g_scroll_accum = 0.0;
             m_user_moving = moved || (left_down && !over_ui);
         }
         else
         {
-            Camera& cam = m_scene_mode ? m_scene_camera : m_camera;
+            Camera& cam = scene_view ? m_scene->scene_camera : m_scene->sim_camera;
             if (left_down && !m_left_was_down && !over_ui)
                 cam.process_orbital_mouse_button(GLFW_MOUSE_BUTTON_LEFT, GLFW_PRESS, 0);
             else if (!left_down && m_left_was_down)
@@ -242,227 +184,6 @@ namespace Donut
         }
     }
 
-    auto Application::set_free_fly(bool enabled) -> void
-    {
-        const bool is_fps = m_camera.get_camera_mode() == CameraMode::FPS;
-        if (enabled == is_fps) return;
-        if (enabled)
-        {
-            // Seed the fly pose from the current orbital framing so the view is continuous.
-            glm::vec3 pos = m_camera.get_orbital_position();
-            glm::vec3 fwd = glm::normalize(m_camera.get_orbital_target() - pos);
-            float pitch = glm::degrees(asin(glm::clamp(fwd.y, -1.0f, 1.0f)));
-            float yaw   = glm::degrees(atan2(fwd.z, fwd.x));
-            m_camera.set_camera_mode(CameraMode::FPS);
-            m_camera.set_movement_speed(2.0e10f);
-            m_camera.set_mouse_sensitivity(0.15f);
-            m_camera.set_position(pos);
-            m_camera.set_rotation(glm::vec3(pitch, yaw, 0.0f));
-        }
-        else
-        {
-            m_camera.set_camera_mode(CameraMode::Orbital);  // orbital state was left intact
-        }
-    }
-
-    auto Application::reset_camera() -> void
-    {
-        m_camera.set_camera_mode(CameraMode::Orbital);
-        m_camera.set_orbital_radius(4e11);
-        m_camera.set_azimuth(0.0f);
-        m_camera.set_elevation(1.25f);
-    }
-
-    auto Application::set_hdri(const std::string& path) -> void
-    {
-        if (m_hdri_path == path || !m_device) return;
-        m_device->wait_idle();
-        m_cubemap = m_device->create_cubemap_from_hdri(path);   // old cube freed after idle
-        m_hdri_path = path;
-    }
-
-    // One-time ImGui theme: rounded, roomy, dark with a warm accretion-disk accent.
-    static auto apply_donut_style() -> void
-    {
-        ImGuiStyle& s = ImGui::GetStyle();
-        s.WindowRounding = 7.0f; s.ChildRounding = 5.0f; s.FrameRounding = 4.0f;
-        s.GrabRounding = 4.0f; s.PopupRounding = 4.0f; s.ScrollbarRounding = 5.0f; s.TabRounding = 4.0f;
-        s.WindowPadding = ImVec2(12, 12); s.FramePadding = ImVec2(9, 5);
-        s.ItemSpacing = ImVec2(9, 8); s.ItemInnerSpacing = ImVec2(7, 5);
-        s.WindowBorderSize = 0.0f; s.FrameBorderSize = 0.0f; s.WindowTitleAlign = ImVec2(0.02f, 0.5f);
-
-        const ImVec4 amber   = ImVec4(0.98f, 0.62f, 0.20f, 1.00f);
-        const ImVec4 amberHi = ImVec4(1.00f, 0.73f, 0.36f, 1.00f);
-        ImVec4* c = s.Colors;
-        c[ImGuiCol_WindowBg]        = ImVec4(0.07f, 0.08f, 0.10f, 0.97f);
-        c[ImGuiCol_ChildBg]         = ImVec4(0.10f, 0.11f, 0.13f, 0.55f);
-        c[ImGuiCol_PopupBg]         = ImVec4(0.09f, 0.10f, 0.12f, 0.98f);
-        c[ImGuiCol_TitleBg]         = ImVec4(0.09f, 0.10f, 0.12f, 1.00f);
-        c[ImGuiCol_TitleBgActive]   = ImVec4(0.13f, 0.14f, 0.17f, 1.00f);
-        c[ImGuiCol_Text]            = ImVec4(0.90f, 0.91f, 0.93f, 1.00f);
-        c[ImGuiCol_TextDisabled]    = ImVec4(0.48f, 0.50f, 0.54f, 1.00f);
-        c[ImGuiCol_FrameBg]         = ImVec4(0.16f, 0.17f, 0.20f, 1.00f);
-        c[ImGuiCol_FrameBgHovered]  = ImVec4(0.22f, 0.24f, 0.28f, 1.00f);
-        c[ImGuiCol_FrameBgActive]   = ImVec4(0.26f, 0.28f, 0.33f, 1.00f);
-        c[ImGuiCol_Header]          = ImVec4(0.17f, 0.19f, 0.23f, 1.00f);
-        c[ImGuiCol_HeaderHovered]   = ImVec4(0.24f, 0.27f, 0.32f, 1.00f);
-        c[ImGuiCol_HeaderActive]    = ImVec4(0.28f, 0.31f, 0.37f, 1.00f);
-        c[ImGuiCol_Button]          = ImVec4(0.20f, 0.22f, 0.26f, 1.00f);
-        c[ImGuiCol_ButtonHovered]   = ImVec4(0.27f, 0.30f, 0.35f, 1.00f);
-        c[ImGuiCol_ButtonActive]    = amber;
-        c[ImGuiCol_SliderGrab]      = amber;
-        c[ImGuiCol_SliderGrabActive]= amberHi;
-        c[ImGuiCol_CheckMark]       = amberHi;
-        c[ImGuiCol_Separator]       = ImVec4(0.20f, 0.22f, 0.26f, 1.00f);
-        c[ImGuiCol_ScrollbarGrab]   = ImVec4(0.24f, 0.26f, 0.30f, 1.00f);
-    }
-
-    auto Application::build_ui() -> void
-    {
-        static bool styled = false;
-        if (!styled) { apply_donut_style(); styled = true; }
-        if (!m_device) return;
-
-        // Full-viewport dock space with a pass-through centre, so the panel can be
-        // docked to any edge while the render shows through the middle.
-        ImGui::DockSpaceOverViewport(0, ImGui::GetMainViewport(), ImGuiDockNodeFlags_PassthruCentralNode);
-
-        ImGui::SetNextWindowSize(ImVec2(340, 580), ImGuiCond_FirstUseEver);
-        ImGui::Begin("Donut  \xc2\xb7  Black Hole");
-
-        ImGuiIO& io = ImGui::GetIO();
-        ImGui::TextDisabled("%s", m_device->device_name().empty() ? "GPU" : m_device->device_name().c_str());
-        ImGui::Text("%.0f FPS", io.Framerate);
-        ImGui::SameLine(); ImGui::TextDisabled("%.1f ms/frame", io.Framerate > 0 ? 1000.0f / io.Framerate : 0.0f);
-        ImGui::Spacing();
-
-        if (ImGui::CollapsingHeader("Renderer", ImGuiTreeNodeFlags_DefaultOpen))
-        {
-            auto& s = SettingsManager::get_settings();
-            const char* apis[] = { "OpenGL", "Vulkan" };
-            int cur = (s.graphics.render_api == "Vulkan") ? 1 : 0;
-            if (ImGui::Combo("Graphics API", &cur, apis, 2))
-            {
-                s.graphics.render_api = apis[cur];
-                SettingsManager::save_settings();
-            }
-            const char* running = (RendererAPI::get_api() == RendererAPI::API::Vulkan) ? "Vulkan" : "OpenGL";
-            if (s.graphics.render_api != running)
-                ImGui::TextColored(ImVec4(0.98f, 0.62f, 0.20f, 1.0f), "Restart to apply (%s running)", running);
-            else
-                ImGui::TextDisabled("Active backend: %s", running);
-        }
-
-        ImGui::Spacing();
-        ImGui::TextDisabled("VIEW");
-        if (ImGui::RadioButton("Black hole", !m_scene_mode)) m_scene_mode = false;
-        ImGui::SameLine();
-        if (ImGui::RadioButton("Scene", m_scene_mode))       m_scene_mode = true;
-        ImGui::Separator();
-
-        if (m_scene_mode)
-        {
-            build_scene_ui();
-        }
-        else
-        {
-            BlackHoleParams& bh = m_bh_params;
-
-            if (ImGui::CollapsingHeader("Camera", ImGuiTreeNodeFlags_DefaultOpen))
-            {
-                bool ff = m_camera.get_camera_mode() == CameraMode::FPS;
-                if (ImGui::RadioButton("Orbital", !ff)) set_free_fly(false);
-                ImGui::SameLine();
-                if (ImGui::RadioButton("Free-fly", ff)) set_free_fly(true);
-                ImGui::SameLine();
-                if (ImGui::Button("Reset view")) reset_camera();
-                ImGui::SliderFloat("FOV", &bh.fov_degrees, 20.0f, 90.0f, "%.0f\xc2\xb0");
-                ImGui::TextDisabled(ff ? "WASD move | Q/E down-up | Shift boost | drag look"
-                                       : "Drag to orbit | scroll to zoom");
-            }
-
-            if (ImGui::CollapsingHeader("Accretion disk", ImGuiTreeNodeFlags_DefaultOpen))
-            {
-                ImGui::SliderFloat("Temperature", &bh.temperature, 2000.0f, 15000.0f, "%.0f K");
-                ImGui::SliderFloat("Brightness",  &bh.brightness, 0.0f, 3.0f, "%.2f");
-                ImGui::SliderFloat("Inner radius", &bh.disk_inner_rs, 3.0f, 12.0f, "%.1f r_s");
-                if (bh.disk_outer_rs < bh.disk_inner_rs + 0.5f) bh.disk_outer_rs = bh.disk_inner_rs + 0.5f;
-                ImGui::SliderFloat("Outer radius", &bh.disk_outer_rs, bh.disk_inner_rs + 0.5f, 25.0f, "%.1f r_s");
-                ImGui::SliderFloat("Turbulence",  &bh.turbulence, 0.0f, 2.0f, "%.2f");
-                ImGui::TextDisabled("Inner edge is the ISCO (3 r_s). Novikov-Thorne profile.");
-            }
-
-            if (ImGui::CollapsingHeader("Quality"))
-            {
-                ImGui::SliderInt("Integration steps", &bh.quality_steps, 2000, 15000);
-                ImGui::TextDisabled("Deeper lensing at higher cost. Settled frame is 4x supersampled.");
-            }
-
-            if (ImGui::CollapsingHeader("Environment", ImGuiTreeNodeFlags_DefaultOpen))
-            {
-                auto& hdri = HDRIManager::get();
-                std::string preview = hdri.get_hdri_name(m_hdri_path);
-                if (ImGui::BeginCombo("Starfield", preview.c_str()))
-                {
-                    for (const auto& path : hdri.get_available_hdri())
-                    {
-                        bool selected = (path == m_hdri_path);
-                        if (ImGui::Selectable(hdri.get_hdri_name(path).c_str(), selected))
-                            set_hdri(path);
-                        if (selected) ImGui::SetItemDefaultFocus();
-                    }
-                    ImGui::EndCombo();
-                }
-                ImGui::TextDisabled("Switching rebuilds the cubemap (brief pause).");
-            }
-        }
-
-        ImGui::End();
-    }
-
-    auto Application::build_scene_ui() -> void
-    {
-        if (!ImGui::CollapsingHeader("Objects", ImGuiTreeNodeFlags_DefaultOpen))
-            return;
-
-        ImGui::TextDisabled("Drag to orbit, scroll to zoom. HDRI skybox behind.");
-        auto& objs = m_scene_objects;
-        if (m_selected_object >= (int)objs.size()) m_selected_object = (int)objs.size() - 1;
-
-        ImGui::Text("Spheres (%d)", (int)objs.size());
-        if (ImGui::Button("Add") && objs.size() < 64)
-        {
-            SceneObject o;
-            o.position = glm::vec3(((int)objs.size() % 5) * 5.0f - 10.0f, 2.0f, ((int)objs.size() / 5) * 5.0f);
-            o.radius   = 1.5f;
-            o.color    = glm::vec3(0.35f + 0.12f * (objs.size() % 5), 0.55f, 0.9f - 0.12f * (objs.size() % 4));
-            objs.push_back(o);
-            m_selected_object = (int)objs.size() - 1;
-        }
-        ImGui::SameLine();
-        if (ImGui::Button("Delete") && !objs.empty())
-        {
-            objs.erase(objs.begin() + m_selected_object);
-            if (m_selected_object >= (int)objs.size()) m_selected_object = (int)objs.size() - 1;
-        }
-
-        ImGui::BeginChild("obj_list", ImVec2(0, 90), true);
-        for (int i = 0; i < (int)objs.size(); ++i)
-        {
-            std::string label = "Sphere " + std::to_string(i);
-            if (ImGui::Selectable(label.c_str(), m_selected_object == i)) m_selected_object = i;
-        }
-        ImGui::EndChild();
-
-        if (m_selected_object >= 0 && m_selected_object < (int)objs.size())
-        {
-            SceneObject& o = objs[m_selected_object];
-            ImGui::DragFloat3("Position", &o.position.x, 0.1f);
-            ImGui::DragFloat("Radius", &o.radius, 0.05f, 0.1f, 20.0f);
-            ImGui::ColorEdit3("Color", &o.color.x);
-        }
-    }
-
     auto Application::close() -> void
     {
         m_running = false;
@@ -492,18 +213,14 @@ namespace Donut
         if (m_device)
         {
             m_device->wait_idle();
-            m_scene_renderer.reset();
-            m_black_hole_renderer.reset();
-            m_cubemap.reset();
-            // Free HDRIManager's cached GPU textures now, while the render context
-            // is still alive. On OpenGL these are GL textures owned by a static
-            // singleton; letting them destruct at program exit would call
-            // glDeleteTextures after the GL context is gone and crash on close.
-            HDRIManager::get().clear_cache();
+            if (m_render_path) m_render_path->shutdown();
+            m_render_path.reset();
+            m_ui.reset();
+            m_scene.reset();
             m_device->shutdown();
             m_device.reset();
         }
         SettingsManager::shutdown();
         Logger::shutdown();
     }
-};
+}
diff --git a/src/core/application.h b/src/core/application.h
index 4b67c84..cbd741d 100644
--- a/src/core/application.h
+++ b/src/core/application.h
@@ -4,22 +4,21 @@
 #include "window.h"
 #include "event.h"
 #include "log.h"
-#include "camera.h"
 
 #include "rendering/rhi.h"
-#include "rendering/scene_renderer.h"
-#include "rendering/black_hole_renderer.h"
+#include "rendering/render_path.h"
+#include "rendering/view.h"
+#include "scene/scene.h"
+#include "ui/ui_layer.h"
 
 #include <string>
-#include <vector>
 
 namespace Donut
 {
-    // The application owns ONE RHI::Device (OpenGL or Vulkan, chosen at startup)
-    // and the two portable renderers written on top of it, plus all the shared
-    // state (cameras, scene objects, disk parameters, HDRI). Because the rendering
-    // lives in the RHI and the shared renderers, the app behaves identically no
-    // matter which backend is active.
+    // Thin shell: owns the window, the RHI device, the Scene (document), the
+    // RenderPath (device-side rendering) and the UILayer (tabbed workspaces), and
+    // runs the frame loop that wires them together. All the rendering lives in the
+    // RHI + shared renderers; all the editing lives in the Scene + workspaces.
     class Application
     {
     public:
@@ -38,43 +37,25 @@ namespace Donut
         auto on_shutdown() -> void;
         auto on_event(Event& event) -> void;
 
-        auto build_ui() -> void;         // shared ImGui panel
-        auto build_scene_ui() -> void;   // scene-view (object list) section
-
-        auto process_input() -> void;    // orbit / free-fly / zoom, was per-backend
-        auto set_free_fly(bool enabled) -> void;
-        auto reset_camera() -> void;
-        auto set_hdri(const std::string& path) -> void;
-
         auto render_frame() -> void;
+        auto update_input(View view) -> void;   // orbit / free-fly / zoom for the active camera
 
     private:
-        Scope<Window> m_window;
-
-        // The unified renderer: one device + the shared renderers on top of it.
-        Scope<RHI::Device>        m_device;
-        Scope<SceneRenderer>      m_scene_renderer;
-        Scope<BlackHoleRenderer>  m_black_hole_renderer;
-        Ref<RHI::Texture>         m_cubemap;          // shared HDRI environment
-
-        Camera m_camera{ 60.0f, 16.0f / 9.0f, 0.1f, 100.0f };        // black-hole view
-        Camera m_scene_camera{ 45.0f, 16.0f / 9.0f, 0.1f, 1000.0f }; // world-builder view
-
-        BlackHoleParams m_bh_params;
-        std::vector<SceneObject> m_scene_objects{ SceneObject{} };
-        int  m_selected_object = 0;
-        bool m_scene_mode = false;
-        std::string m_hdri_path;
+        Scope<Window>      m_window;
+        Scope<RHI::Device> m_device;
+        Scope<Scene>       m_scene;
+        Scope<RenderPath>  m_render_path;
+        Scope<UILayer>     m_ui;
 
-        // input tracking (mirrors the old per-backend process_input)
+        // input tracking (per-frame transient state)
         bool   m_left_was_down = false;
         double m_fps_last_x = 0.0, m_fps_last_y = 0.0;
         double m_last_frame_time = 0.0;
         double m_start_time = 0.0;
         bool   m_user_moving = false;
 
-        bool m_running;
-        bool m_minimized;
+        bool m_running   = true;
+        bool m_minimized = false;
 
         static Application* s_instance;
     };
diff --git a/src/core/hdri_manager.h b/src/core/hdri_manager.h
index d98830f..6b3df1e 100644
--- a/src/core/hdri_manager.h
+++ b/src/core/hdri_manager.h
@@ -1,7 +1,7 @@
 #pragma once
 
 #include "core/log.h"
-#include "rendering/texture.h"
+#include "platform/opengl/texture.h"
 
 #include <string>
 #include <unordered_map>
diff --git a/src/platform/opengl/opengl_device.cpp b/src/platform/opengl/opengl_device.cpp
index c4332fa..8516a3c 100644
--- a/src/platform/opengl/opengl_device.cpp
+++ b/src/platform/opengl/opengl_device.cpp
@@ -2,8 +2,8 @@
 
 #include "core/log.h"
 #include "core/hdri_manager.h"
-#include "rendering/shader.h"
-#include "rendering/texture.h"
+#include "shader.h"
+#include "texture.h"
 
 #include <glad/glad.h>
 #include <GLFW/glfw3.h>
@@ -220,6 +220,11 @@ namespace Donut::RHI
             }
             auto shutdown() -> void override
             {
+                // Free the HDRIManager's cached GL cubemaps while our context is
+                // still current (they are static-singleton-owned; letting them
+                // destruct at program exit would glDeleteTextures after the context
+                // is gone and crash on close).
+                HDRIManager::get().clear_cache();
                 if (m_imgui) { ImGui_ImplOpenGL3_Shutdown(); ImGui_ImplGlfw_Shutdown(); ImGui::DestroyContext(); m_imgui = false; }
                 if (m_vao) { glDeleteVertexArrays(1, &m_vao); m_vao = 0; }
             }
diff --git a/src/rendering/shader.cpp b/src/platform/opengl/shader.cpp
index 80015e6..80015e6 100644
--- a/src/rendering/shader.cpp
+++ b/src/platform/opengl/shader.cpp
diff --git a/src/rendering/shader.h b/src/platform/opengl/shader.h
index 409aca3..409aca3 100644
--- a/src/rendering/shader.h
+++ b/src/platform/opengl/shader.h
diff --git a/src/rendering/texture.cpp b/src/platform/opengl/texture.cpp
index 12e07f1..12e07f1 100644
--- a/src/rendering/texture.cpp
+++ b/src/platform/opengl/texture.cpp
diff --git a/src/rendering/texture.h b/src/platform/opengl/texture.h
index 5f68c78..5f68c78 100644
--- a/src/rendering/texture.h
+++ b/src/platform/opengl/texture.h
diff --git a/src/platform/vulkan/vulkan_common.h b/src/platform/vulkan/vulkan_common.h
new file mode 100644
index 0000000..0faa107
--- /dev/null
+++ b/src/platform/vulkan/vulkan_common.h
@@ -0,0 +1,343 @@
+#pragma once
+
+// Shared internals of the Vulkan RHI backend: the enum-mapping helpers, the
+// opaque resource classes (Buffer/Texture/RenderTarget/Pipeline/CommandList), and
+// the VulkanDevice declaration. The implementation is split across vulkan_device
+// (lifecycle + frame loop), vulkan_swapchain (instance/device/swapchain/passes),
+// vulkan_resources (buffer/texture/target/pipeline) and vulkan_cubemap. This
+// header is private to platform/vulkan/ — nothing outside includes it.
+
+#include "vulkan_device.h"   // rendering/rhi.h (base classes + factory decls)
+
+#define GLFW_INCLUDE_VULKAN
+#include <GLFW/glfw3.h>
+#include <glm/glm.hpp>
+
+#include <vector>
+#include <array>
+#include <string>
+#include <unordered_map>
+#include <cstdint>
+#include <cstring>
+#include <algorithm>
+
+#include "core/log.h"
+
+namespace Donut::RHI
+{
+    constexpr int MAX_FRAMES_IN_FLIGHT = 2;
+    constexpr uint32_t MAX_BINDINGS = 8;
+
+    #define VKD_CHECK(expr)                                            \
+        do {                                                           \
+            VkResult _r = (expr);                                      \
+            if (_r != VK_SUCCESS) {                                    \
+                DONUT_ERROR("Vulkan RHI: {} failed ({})", #expr, (int)_r); \
+                return false;                                          \
+            }                                                          \
+        } while (0)
+
+    inline auto vk_format(Format f) -> VkFormat
+    {
+        switch (f) {
+            case Format::RGBA16F: return VK_FORMAT_R16G16B16A16_SFLOAT;
+            case Format::D32:     return VK_FORMAT_D32_SFLOAT;
+            default:              return VK_FORMAT_R8G8B8A8_UNORM;
+        }
+    }
+    inline auto vk_attr_format(uint32_t comps) -> VkFormat
+    {
+        switch (comps) {
+            case 1:  return VK_FORMAT_R32_SFLOAT;
+            case 2:  return VK_FORMAT_R32G32_SFLOAT;
+            case 3:  return VK_FORMAT_R32G32B32_SFLOAT;
+            default: return VK_FORMAT_R32G32B32A32_SFLOAT;
+        }
+    }
+    inline auto vk_topology(Topology t) -> VkPrimitiveTopology
+    { return t == Topology::Lines ? VK_PRIMITIVE_TOPOLOGY_LINE_LIST : VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST; }
+    inline auto vk_compare(CompareOp o) -> VkCompareOp
+    { return o == CompareOp::Always ? VK_COMPARE_OP_ALWAYS : o == CompareOp::LessEqual ? VK_COMPARE_OP_LESS_OR_EQUAL : VK_COMPARE_OP_LESS; }
+    inline auto vk_filter(Filter f) -> VkFilter { return f == Filter::Nearest ? VK_FILTER_NEAREST : VK_FILTER_LINEAR; }
+    inline auto vk_cull(CullMode c) -> VkCullModeFlags
+    { return c == CullMode::None ? VK_CULL_MODE_NONE : c == CullMode::Back ? VK_CULL_MODE_BACK_BIT : VK_CULL_MODE_FRONT_BIT; }
+
+    // Buffer: host-visible + coherent, persistently mapped.
+    class VkBufferR : public Buffer
+    {
+    public:
+        VkBufferR(VkDevice d, VkBuffer b, VkDeviceMemory m, void* mapped, size_t size)
+            : m_device(d), m_buf(b), m_mem(m), m_mapped(mapped), m_size(size) {}
+        ~VkBufferR() override
+        {
+            if (m_mapped) vkUnmapMemory(m_device, m_mem);
+            if (m_buf) vkDestroyBuffer(m_device, m_buf, nullptr);
+            if (m_mem) vkFreeMemory(m_device, m_mem, nullptr);
+        }
+        auto update(const void* data, size_t size) -> void override
+        { if (m_mapped) std::memcpy(m_mapped, data, std::min(size, m_size)); }
+
+        VkDevice m_device; VkBuffer m_buf; VkDeviceMemory m_mem; void* m_mapped; size_t m_size;
+    };
+
+    // Texture: sampled image (2D or cube). Owns its handles unless it is a borrowed
+    // wrapper around a render-target view.
+    class VkTextureR : public Texture
+    {
+    public:
+        VkTextureR() = default;
+        ~VkTextureR() override
+        {
+            if (!m_owns) return;
+            if (m_sampler) vkDestroySampler(m_device, m_sampler, nullptr);
+            if (m_view)    vkDestroyImageView(m_device, m_view, nullptr);
+            if (m_image)   vkDestroyImage(m_device, m_image, nullptr);
+            if (m_mem)     vkFreeMemory(m_device, m_mem, nullptr);
+        }
+        VkDevice      m_device  = VK_NULL_HANDLE;
+        VkImage       m_image   = VK_NULL_HANDLE;
+        VkDeviceMemory m_mem    = VK_NULL_HANDLE;
+        VkImageView   m_view    = VK_NULL_HANDLE;
+        VkSampler     m_sampler = VK_NULL_HANDLE;
+        bool          m_owns    = true;
+    };
+
+    // RenderTarget: off-screen colour image (+ optional depth) + framebuffer.
+    class VkRenderTargetR : public RenderTarget
+    {
+    public:
+        ~VkRenderTargetR() override
+        {
+            if (m_fb)          vkDestroyFramebuffer(m_device, m_fb, nullptr);
+            if (m_sampler)     vkDestroySampler(m_device, m_sampler, nullptr);
+            if (m_view)        vkDestroyImageView(m_device, m_view, nullptr);
+            if (m_image)       vkDestroyImage(m_device, m_image, nullptr);
+            if (m_mem)         vkFreeMemory(m_device, m_mem, nullptr);
+            if (m_depth_view)  vkDestroyImageView(m_device, m_depth_view, nullptr);
+            if (m_depth_image) vkDestroyImage(m_device, m_depth_image, nullptr);
+            if (m_depth_mem)   vkFreeMemory(m_device, m_depth_mem, nullptr);
+            // m_pass is owned by the device's render-pass cache, not by us.
+        }
+        auto width()  const -> int override { return m_w; }
+        auto height() const -> int override { return m_h; }
+        auto color_texture() -> Texture* override { return &m_color; }
+
+        VkDevice       m_device  = VK_NULL_HANDLE;
+        int            m_w = 0, m_h = 0;
+        VkImage        m_image   = VK_NULL_HANDLE;
+        VkDeviceMemory m_mem     = VK_NULL_HANDLE;
+        VkImageView    m_view    = VK_NULL_HANDLE;
+        VkSampler      m_sampler = VK_NULL_HANDLE;
+        VkFramebuffer  m_fb      = VK_NULL_HANDLE;
+        VkRenderPass   m_pass    = VK_NULL_HANDLE;   // borrowed (device pass cache)
+        bool           m_has_depth = false;
+        VkImage        m_depth_image = VK_NULL_HANDLE;
+        VkDeviceMemory m_depth_mem   = VK_NULL_HANDLE;
+        VkImageView    m_depth_view  = VK_NULL_HANDLE;
+        VkTextureR     m_color;   // borrowed wrapper (view+sampler) for sampling
+    };
+
+    // Pipeline: the graphics pipeline + its (set-0) descriptor layout.
+    class VkPipelineR : public Pipeline
+    {
+    public:
+        ~VkPipelineR() override
+        {
+            if (m_pipeline)   vkDestroyPipeline(m_device, m_pipeline, nullptr);
+            if (m_layout)     vkDestroyPipelineLayout(m_device, m_layout, nullptr);
+            if (m_set_layout) vkDestroyDescriptorSetLayout(m_device, m_set_layout, nullptr);
+        }
+        VkDevice              m_device      = VK_NULL_HANDLE;
+        VkPipeline            m_pipeline    = VK_NULL_HANDLE;
+        VkPipelineLayout      m_layout      = VK_NULL_HANDLE;
+        VkDescriptorSetLayout m_set_layout  = VK_NULL_HANDLE;
+        std::vector<ResourceSlot> m_resources;
+    };
+
+    // CommandList: records into the frame's command buffer. Per-draw descriptor
+    // sets are allocated from a per-frame pool (no push-descriptor extension).
+    class VkCommandListR : public CommandList
+    {
+    public:
+        auto begin_render_pass(RenderTarget* target, const glm::vec4& clear) -> void override
+        {
+            VkClearValue cvs[2]{};
+            cvs[0].color = { { clear.r, clear.g, clear.b, clear.a } };
+            cvs[1].depthStencil = { 1.0f, 0 };
+            VkRenderPassBeginInfo rpbi{ VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO };
+            if (target)
+            {
+                auto* rt = static_cast<VkRenderTargetR*>(target);
+                rpbi.renderPass = rt->m_pass; rpbi.framebuffer = rt->m_fb;
+                rpbi.renderArea = { { 0, 0 }, { (uint32_t)rt->m_w, (uint32_t)rt->m_h } };
+                rpbi.clearValueCount = rt->m_has_depth ? 2 : 1; rpbi.pClearValues = cvs;
+            }
+            else
+            {
+                rpbi.renderPass = m_swapchain_rp; rpbi.framebuffer = m_swapchain_fb;
+                rpbi.renderArea = { { 0, 0 }, m_extent };
+                rpbi.clearValueCount = 2; rpbi.pClearValues = cvs;
+            }
+            vkCmdBeginRenderPass(m_cmd, &rpbi, VK_SUBPASS_CONTENTS_INLINE);
+        }
+        auto end_render_pass() -> void override { vkCmdEndRenderPass(m_cmd); }
+
+        auto bind_pipeline(Pipeline* p) -> void override
+        {
+            m_pipe = static_cast<VkPipelineR*>(p);
+            vkCmdBindPipeline(m_cmd, VK_PIPELINE_BIND_POINT_GRAPHICS, m_pipe->m_pipeline);
+        }
+        auto set_viewport(int x, int y, int w, int h, bool flip_y) -> void override
+        {
+            VkViewport vp{ (float)x, flip_y ? (float)(y + h) : (float)y,
+                           (float)w, flip_y ? -(float)h : (float)h, 0.0f, 1.0f };
+            VkRect2D sc{ { x, y }, { (uint32_t)w, (uint32_t)h } };
+            vkCmdSetViewport(m_cmd, 0, 1, &vp);
+            vkCmdSetScissor(m_cmd, 0, 1, &sc);
+        }
+        auto bind_uniform(uint32_t binding, Buffer* ubo) -> void override
+        {
+            if (binding >= MAX_BINDINGS) return;
+            m_buf_info[binding] = { static_cast<VkBufferR*>(ubo)->m_buf, 0, VK_WHOLE_SIZE };
+        }
+        auto bind_texture(uint32_t binding, Texture* texture) -> void override
+        {
+            if (binding >= MAX_BINDINGS) return;
+            auto* t = static_cast<VkTextureR*>(texture);
+            m_img_info[binding] = { t->m_sampler, t->m_view, VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL };
+        }
+        auto bind_vertex_buffer(Buffer* vb) -> void override
+        {
+            VkBuffer b = static_cast<VkBufferR*>(vb)->m_buf; VkDeviceSize off = 0;
+            vkCmdBindVertexBuffers(m_cmd, 0, 1, &b, &off);
+        }
+        auto bind_index_buffer(Buffer* ib) -> void override
+        { vkCmdBindIndexBuffer(m_cmd, static_cast<VkBufferR*>(ib)->m_buf, 0, VK_INDEX_TYPE_UINT32); }
+        auto draw(uint32_t vertex_count) -> void override
+        { flush_descriptors(); vkCmdDraw(m_cmd, vertex_count, 1, 0, 0); }
+        auto draw_indexed(uint32_t index_count) -> void override
+        { flush_descriptors(); vkCmdDrawIndexed(m_cmd, index_count, 1, 0, 0, 0); }
+
+        // Allocate + write + bind a descriptor set for the current pipeline's
+        // declared resources, using whatever was bound since bind_pipeline.
+        auto flush_descriptors() -> void
+        {
+            if (!m_pipe || m_pipe->m_resources.empty()) return;
+            VkDescriptorSetAllocateInfo ai{ VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO };
+            ai.descriptorPool = m_frame_pool; ai.descriptorSetCount = 1; ai.pSetLayouts = &m_pipe->m_set_layout;
+            VkDescriptorSet set = VK_NULL_HANDLE;
+            if (vkAllocateDescriptorSets(m_device, &ai, &set) != VK_SUCCESS)
+            { DONUT_ERROR("Vulkan RHI: descriptor set allocation failed"); return; }
+
+            std::array<VkWriteDescriptorSet, MAX_BINDINGS> writes{};
+            uint32_t n = 0;
+            for (const auto& r : m_pipe->m_resources)
+            {
+                VkWriteDescriptorSet& w = writes[n++];
+                w.sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET;
+                w.dstSet = set; w.dstBinding = r.binding; w.descriptorCount = 1;
+                if (r.kind == ResourceKind::UniformBuffer)
+                { w.descriptorType = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER; w.pBufferInfo = &m_buf_info[r.binding]; }
+                else
+                { w.descriptorType = VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER; w.pImageInfo = &m_img_info[r.binding]; }
+            }
+            vkUpdateDescriptorSets(m_device, n, writes.data(), 0, nullptr);
+            vkCmdBindDescriptorSets(m_cmd, VK_PIPELINE_BIND_POINT_GRAPHICS, m_pipe->m_layout, 0, 1, &set, 0, nullptr);
+        }
+
+        // Set by the device at begin_frame:
+        VkDevice        m_device       = VK_NULL_HANDLE;
+        VkCommandBuffer m_cmd          = VK_NULL_HANDLE;
+        VkRenderPass    m_swapchain_rp = VK_NULL_HANDLE;
+        VkFramebuffer   m_swapchain_fb = VK_NULL_HANDLE;
+        VkExtent2D      m_extent{};
+        VkDescriptorPool m_frame_pool  = VK_NULL_HANDLE;
+
+        VkPipelineR* m_pipe = nullptr;
+        VkDescriptorBufferInfo m_buf_info[MAX_BINDINGS]{};
+        VkDescriptorImageInfo  m_img_info[MAX_BINDINGS]{};
+    };
+
+    // The backend device. Its methods are defined across vulkan_device.cpp,
+    // vulkan_swapchain.cpp, vulkan_resources.cpp and vulkan_cubemap.cpp.
+    class VulkanDevice : public Device
+    {
+    public:
+        auto init(const NativeWindow& window) -> bool override;
+        auto shutdown() -> void override;
+        auto resize(int width, int height) -> void override { m_framebuffer_resized = true; m_width = width; m_height = height; }
+        auto wait_idle() -> void override { if (m_device) vkDeviceWaitIdle(m_device); }
+
+        auto create_buffer(BufferType type, size_t size, const void* data) -> Ref<Buffer> override;
+        auto create_texture(int w, int h, Format format, Filter filter, const void* data) -> Ref<Texture> override;
+        auto create_cubemap_from_hdri(const std::string& path) -> Ref<Texture> override;
+        auto create_render_target(int w, int h, Format color, Format depth, Filter filter, int mips) -> Ref<RenderTarget> override;
+        auto create_pipeline(const PipelineDesc& desc) -> Ref<Pipeline> override;
+
+        auto begin_frame(const glm::vec4& clear) -> CommandList* override;
+        auto end_frame() -> void override;
+
+        auto init_imgui() -> void override;
+        auto imgui_new_frame() -> void override;
+        auto imgui_render(CommandList& cmds) -> void override;
+
+        auto device_name() const -> const std::string& override { return m_gpu_name; }
+
+        // internals (implemented across the vulkan_*.cpp files)
+        auto find_memory_type(uint32_t filter, VkMemoryPropertyFlags flags) const -> uint32_t;
+        auto create_buffer_raw(VkDeviceSize size, VkBufferUsageFlags usage, VkMemoryPropertyFlags props, VkBuffer& buf, VkDeviceMemory& mem) const -> bool;
+        auto load_spirv(const std::string& path) const -> std::vector<uint32_t>;
+        auto create_shader_module(const std::string& path, VkShaderModule& out) const -> bool;
+
+        auto create_instance() -> bool;
+        auto pick_physical_and_device() -> bool;
+        auto create_swapchain() -> bool;
+        auto create_image_views() -> bool;
+        // Render passes are format-driven and cached: a pipeline/target's
+        // attachment signature (colour + optional depth, present vs sampled)
+        // maps to one pass. `present` = presented swapchain image.
+        auto get_render_pass(VkFormat color, VkFormat depth, bool present) -> VkRenderPass;
+        auto create_depth_and_framebuffers() -> bool;
+        auto create_command_and_sync() -> bool;
+        auto recreate_swapchain() -> bool;
+        auto cleanup_swapchain() -> void;
+
+        GLFWwindow* m_window = nullptr;
+        int m_width = 0, m_height = 0;
+        bool m_framebuffer_resized = false;
+        std::string m_gpu_name;
+
+        VkInstance       m_instance = VK_NULL_HANDLE;
+        VkSurfaceKHR     m_surface  = VK_NULL_HANDLE;
+        VkPhysicalDevice m_physical = VK_NULL_HANDLE;
+        VkDevice         m_device   = VK_NULL_HANDLE;
+        uint32_t         m_graphics_family = 0, m_present_family = 0;
+        VkQueue          m_graphics_queue = VK_NULL_HANDLE, m_present_queue = VK_NULL_HANDLE;
+        VkPhysicalDeviceMemoryProperties m_mem_props{};
+
+        VkSwapchainKHR m_swapchain = VK_NULL_HANDLE;
+        VkFormat       m_swapchain_format = VK_FORMAT_B8G8R8A8_UNORM;
+        VkExtent2D     m_extent{};
+        std::vector<VkImage>       m_images;
+        std::vector<VkImageView>   m_image_views;
+        VkRenderPass               m_swapchain_rp = VK_NULL_HANDLE;   // also lives in m_pass_cache
+        std::unordered_map<uint64_t, VkRenderPass> m_pass_cache;      // keyed by (color,depth,present)
+        std::vector<VkFramebuffer> m_framebuffers;
+        VkImage m_depth_image = VK_NULL_HANDLE; VkDeviceMemory m_depth_mem = VK_NULL_HANDLE; VkImageView m_depth_view = VK_NULL_HANDLE;
+
+        VkCommandPool m_command_pool = VK_NULL_HANDLE;
+        std::vector<VkCommandBuffer> m_command_buffers;
+        std::vector<VkSemaphore> m_image_available;
+        std::vector<VkSemaphore> m_render_finished;
+        std::vector<VkFence>     m_in_flight;
+        std::vector<VkFence>     m_images_in_flight;
+        VkFence m_geo_in_use = VK_NULL_HANDLE;
+        uint32_t m_current_frame = 0, m_image_index = 0;
+
+        std::vector<VkDescriptorPool> m_frame_pools;    // one per frame in flight
+        VkDescriptorPool m_imgui_pool = VK_NULL_HANDLE;
+        bool m_imgui = false;
+
+        VkCommandListR m_cmds;
+    };
+}
diff --git a/src/platform/vulkan/vulkan_cubemap.cpp b/src/platform/vulkan/vulkan_cubemap.cpp
new file mode 100644
index 0000000..3ffc496
--- /dev/null
+++ b/src/platform/vulkan/vulkan_cubemap.cpp
@@ -0,0 +1,288 @@
+#include "vulkan_common.h"
+
+#include "stb_image.h"
+#include <glm/gtc/matrix_transform.hpp>
+
+namespace Donut::RHI
+{
+    auto VulkanDevice::create_cubemap_from_hdri(const std::string& path) -> Ref<Texture>
+    {
+        auto tex = create_ref<VkTextureR>(); tex->m_device = m_device;
+        const VkMemoryPropertyFlags host_vis = VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT;
+        const uint32_t FACE = 1024;
+        const VkFormat cube_fmt = VK_FORMAT_R16G16B16A16_SFLOAT;
+        uint32_t CUBE_MIPS = 1; for (uint32_t s = FACE; s > 1; s >>= 1) ++CUBE_MIPS;
+
+        VkImageCreateInfo cci{ VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO };
+        cci.flags = VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT;
+        cci.imageType = VK_IMAGE_TYPE_2D; cci.format = cube_fmt; cci.extent = { FACE, FACE, 1 };
+        cci.mipLevels = CUBE_MIPS; cci.arrayLayers = 6; cci.samples = VK_SAMPLE_COUNT_1_BIT;
+        cci.tiling = VK_IMAGE_TILING_OPTIMAL;
+        cci.usage = VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT | VK_IMAGE_USAGE_SAMPLED_BIT
+                  | VK_IMAGE_USAGE_TRANSFER_SRC_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT;
+        vkCreateImage(m_device, &cci, nullptr, &tex->m_image);
+        VkMemoryRequirements creq{}; vkGetImageMemoryRequirements(m_device, tex->m_image, &creq);
+        VkMemoryAllocateInfo cai{ VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO };
+        cai.allocationSize = creq.size; cai.memoryTypeIndex = find_memory_type(creq.memoryTypeBits, VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT);
+        vkAllocateMemory(m_device, &cai, nullptr, &tex->m_mem);
+        vkBindImageMemory(m_device, tex->m_image, tex->m_mem, 0);
+        VkImageViewCreateInfo cvci{ VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO };
+        cvci.image = tex->m_image; cvci.viewType = VK_IMAGE_VIEW_TYPE_CUBE; cvci.format = cube_fmt;
+        cvci.subresourceRange = { VK_IMAGE_ASPECT_COLOR_BIT, 0, CUBE_MIPS, 0, 6 };
+        vkCreateImageView(m_device, &cvci, nullptr, &tex->m_view);
+        VkSamplerCreateInfo csm{ VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO };
+        csm.magFilter = VK_FILTER_LINEAR; csm.minFilter = VK_FILTER_LINEAR;
+        csm.mipmapMode = VK_SAMPLER_MIPMAP_MODE_LINEAR; csm.minLod = 0.0f; csm.maxLod = (float)CUBE_MIPS;
+        csm.addressModeU = csm.addressModeV = csm.addressModeW = VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE;
+        vkCreateSampler(m_device, &csm, nullptr, &tex->m_sampler);
+
+        int w = 0, h = 0, ch = 0;
+        float* pixels = stbi_loadf(path.c_str(), &w, &h, &ch, 4);
+        if (!pixels)
+        {
+            DONUT_WARN("Vulkan RHI: HDRI '{}' could not be loaded; using a dark background", path);
+            VkCommandBufferAllocateInfo cbai{ VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO };
+            cbai.commandPool = m_command_pool; cbai.level = VK_COMMAND_BUFFER_LEVEL_PRIMARY; cbai.commandBufferCount = 1;
+            VkCommandBuffer cmd; vkAllocateCommandBuffers(m_device, &cbai, &cmd);
+            VkCommandBufferBeginInfo bi{ VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO }; bi.flags = VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT;
+            vkBeginCommandBuffer(cmd, &bi);
+            VkImageMemoryBarrier tb{ VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER };
+            tb.oldLayout = VK_IMAGE_LAYOUT_UNDEFINED; tb.newLayout = VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL;
+            tb.image = tex->m_image; tb.subresourceRange = { VK_IMAGE_ASPECT_COLOR_BIT, 0, CUBE_MIPS, 0, 6 };
+            tb.srcAccessMask = 0; tb.dstAccessMask = VK_ACCESS_TRANSFER_WRITE_BIT;
+            vkCmdPipelineBarrier(cmd, VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT, 0, 0, nullptr, 0, nullptr, 1, &tb);
+            VkClearColorValue dark{}; dark.float32[0] = 0.02f; dark.float32[1] = 0.02f; dark.float32[2] = 0.05f; dark.float32[3] = 1.0f;
+            VkImageSubresourceRange rng{ VK_IMAGE_ASPECT_COLOR_BIT, 0, CUBE_MIPS, 0, 6 };
+            vkCmdClearColorImage(cmd, tex->m_image, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, &dark, 1, &rng);
+            VkImageMemoryBarrier rb = tb; rb.oldLayout = VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL; rb.newLayout = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL;
+            rb.srcAccessMask = VK_ACCESS_TRANSFER_WRITE_BIT; rb.dstAccessMask = VK_ACCESS_SHADER_READ_BIT;
+            vkCmdPipelineBarrier(cmd, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT, 0, 0, nullptr, 0, nullptr, 1, &rb);
+            vkEndCommandBuffer(cmd);
+            VkSubmitInfo si{ VK_STRUCTURE_TYPE_SUBMIT_INFO }; si.commandBufferCount = 1; si.pCommandBuffers = &cmd;
+            vkQueueSubmit(m_graphics_queue, 1, &si, VK_NULL_HANDLE); vkQueueWaitIdle(m_graphics_queue);
+            vkFreeCommandBuffers(m_device, m_command_pool, 1, &cmd);
+            return tex;
+        }
+
+        const VkFormat eq_fmt = VK_FORMAT_R16G16B16A16_SFLOAT;
+        size_t texel_count = (size_t)w * h * 4;
+        VkDeviceSize eq_size = (VkDeviceSize)texel_count * sizeof(uint16_t);
+        VkBuffer eq_staging; VkDeviceMemory eq_staging_mem;
+        create_buffer_raw(eq_size, VK_BUFFER_USAGE_TRANSFER_SRC_BIT, host_vis, eq_staging, eq_staging_mem);
+        void* mp = nullptr; vkMapMemory(m_device, eq_staging_mem, 0, eq_size, 0, &mp);
+        uint16_t* dst = (uint16_t*)mp;
+        for (size_t i = 0; i < texel_count; ++i) { __fp16 hf = (__fp16)pixels[i]; std::memcpy(&dst[i], &hf, sizeof(uint16_t)); }
+        vkUnmapMemory(m_device, eq_staging_mem);
+        stbi_image_free(pixels);
+
+        VkImage eq_image; VkDeviceMemory eq_mem;
+        VkImageCreateInfo eci{ VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO };
+        eci.imageType = VK_IMAGE_TYPE_2D; eci.format = eq_fmt; eci.extent = { (uint32_t)w, (uint32_t)h, 1 };
+        eci.mipLevels = 1; eci.arrayLayers = 1; eci.samples = VK_SAMPLE_COUNT_1_BIT;
+        eci.tiling = VK_IMAGE_TILING_OPTIMAL; eci.usage = VK_IMAGE_USAGE_TRANSFER_DST_BIT | VK_IMAGE_USAGE_SAMPLED_BIT;
+        vkCreateImage(m_device, &eci, nullptr, &eq_image);
+        VkMemoryRequirements ereq{}; vkGetImageMemoryRequirements(m_device, eq_image, &ereq);
+        VkMemoryAllocateInfo eai{ VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO };
+        eai.allocationSize = ereq.size; eai.memoryTypeIndex = find_memory_type(ereq.memoryTypeBits, VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT);
+        vkAllocateMemory(m_device, &eai, nullptr, &eq_mem);
+        vkBindImageMemory(m_device, eq_image, eq_mem, 0);
+        VkImageView eq_view;
+        VkImageViewCreateInfo evci{ VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO };
+        evci.image = eq_image; evci.viewType = VK_IMAGE_VIEW_TYPE_2D; evci.format = eq_fmt;
+        evci.subresourceRange = { VK_IMAGE_ASPECT_COLOR_BIT, 0, 1, 0, 1 };
+        vkCreateImageView(m_device, &evci, nullptr, &eq_view);
+        VkSampler eq_sampler;
+        VkSamplerCreateInfo esm{ VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO };
+        esm.magFilter = VK_FILTER_LINEAR; esm.minFilter = VK_FILTER_LINEAR;
+        esm.addressModeU = VK_SAMPLER_ADDRESS_MODE_REPEAT;
+        esm.addressModeV = VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE;
+        esm.addressModeW = VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE;
+        vkCreateSampler(m_device, &esm, nullptr, &eq_sampler);
+
+        VkImageView face_views[6];
+        for (uint32_t i = 0; i < 6; ++i)
+        {
+            VkImageViewCreateInfo fvci{ VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO };
+            fvci.image = tex->m_image; fvci.viewType = VK_IMAGE_VIEW_TYPE_2D; fvci.format = cube_fmt;
+            fvci.subresourceRange = { VK_IMAGE_ASPECT_COLOR_BIT, 0, 1, i, 1 };
+            vkCreateImageView(m_device, &fvci, nullptr, &face_views[i]);
+        }
+
+        VkAttachmentDescription color{};
+        color.format = cube_fmt; color.samples = VK_SAMPLE_COUNT_1_BIT;
+        color.loadOp = VK_ATTACHMENT_LOAD_OP_CLEAR; color.storeOp = VK_ATTACHMENT_STORE_OP_STORE;
+        color.stencilLoadOp = VK_ATTACHMENT_LOAD_OP_DONT_CARE; color.stencilStoreOp = VK_ATTACHMENT_STORE_OP_DONT_CARE;
+        color.initialLayout = VK_IMAGE_LAYOUT_UNDEFINED; color.finalLayout = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL;
+        VkAttachmentReference ref{ 0, VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL };
+        VkSubpassDescription subpass{}; subpass.pipelineBindPoint = VK_PIPELINE_BIND_POINT_GRAPHICS; subpass.colorAttachmentCount = 1; subpass.pColorAttachments = &ref;
+        VkSubpassDependency dep{}; dep.srcSubpass = 0; dep.dstSubpass = VK_SUBPASS_EXTERNAL;
+        dep.srcStageMask = VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT; dep.srcAccessMask = VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT;
+        dep.dstStageMask = VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT; dep.dstAccessMask = VK_ACCESS_SHADER_READ_BIT;
+        VkRenderPass rp;
+        VkRenderPassCreateInfo rpci{ VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO };
+        rpci.attachmentCount = 1; rpci.pAttachments = &color; rpci.subpassCount = 1; rpci.pSubpasses = &subpass; rpci.dependencyCount = 1; rpci.pDependencies = &dep;
+        vkCreateRenderPass(m_device, &rpci, nullptr, &rp);
+        VkFramebuffer face_fb[6];
+        for (uint32_t i = 0; i < 6; ++i)
+        {
+            VkFramebufferCreateInfo fbci{ VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO };
+            fbci.renderPass = rp; fbci.attachmentCount = 1; fbci.pAttachments = &face_views[i]; fbci.width = FACE; fbci.height = FACE; fbci.layers = 1;
+            vkCreateFramebuffer(m_device, &fbci, nullptr, &face_fb[i]);
+        }
+
+        VkDescriptorSetLayoutBinding binds[2]{};
+        binds[0].binding = 0; binds[0].descriptorType = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER; binds[0].descriptorCount = 1; binds[0].stageFlags = VK_SHADER_STAGE_VERTEX_BIT;
+        binds[1].binding = 1; binds[1].descriptorType = VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER; binds[1].descriptorCount = 1; binds[1].stageFlags = VK_SHADER_STAGE_FRAGMENT_BIT;
+        VkDescriptorSetLayout set_layout;
+        VkDescriptorSetLayoutCreateInfo dslci{ VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO }; dslci.bindingCount = 2; dslci.pBindings = binds;
+        vkCreateDescriptorSetLayout(m_device, &dslci, nullptr, &set_layout);
+        VkDescriptorPoolSize psizes[2] = { { VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, 6 }, { VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, 6 } };
+        VkDescriptorPool pool;
+        VkDescriptorPoolCreateInfo dpci{ VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO }; dpci.maxSets = 6; dpci.poolSizeCount = 2; dpci.pPoolSizes = psizes;
+        vkCreateDescriptorPool(m_device, &dpci, nullptr, &pool);
+
+        VkShaderModule vmod, fmod;
+        create_shader_module("assets/shaders/generated/equirect_to_cubemap.vertexMain.spv", vmod);
+        create_shader_module("assets/shaders/generated/equirect_to_cubemap.fragmentMain.spv", fmod);
+        VkPipelineLayout playout;
+        VkPipelineLayoutCreateInfo plci{ VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO }; plci.setLayoutCount = 1; plci.pSetLayouts = &set_layout;
+        vkCreatePipelineLayout(m_device, &plci, nullptr, &playout);
+        VkPipelineShaderStageCreateInfo stages[2]{};
+        stages[0].sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO; stages[0].stage = VK_SHADER_STAGE_VERTEX_BIT;   stages[0].module = vmod; stages[0].pName = "main";
+        stages[1].sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO; stages[1].stage = VK_SHADER_STAGE_FRAGMENT_BIT; stages[1].module = fmod; stages[1].pName = "main";
+        VkVertexInputBindingDescription vib{ 0, 12, VK_VERTEX_INPUT_RATE_VERTEX };
+        VkVertexInputAttributeDescription via{ 0, 0, VK_FORMAT_R32G32B32_SFLOAT, 0 };
+        VkPipelineVertexInputStateCreateInfo vin{ VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO };
+        vin.vertexBindingDescriptionCount = 1; vin.pVertexBindingDescriptions = &vib; vin.vertexAttributeDescriptionCount = 1; vin.pVertexAttributeDescriptions = &via;
+        VkPipelineInputAssemblyStateCreateInfo ia{ VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO }; ia.topology = VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST;
+        VkViewport vp{ 0, 0, (float)FACE, (float)FACE, 0, 1 }; VkRect2D sc{ { 0, 0 }, { FACE, FACE } };
+        VkPipelineViewportStateCreateInfo vps{ VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO }; vps.viewportCount = 1; vps.pViewports = &vp; vps.scissorCount = 1; vps.pScissors = &sc;
+        VkPipelineRasterizationStateCreateInfo rs{ VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO }; rs.polygonMode = VK_POLYGON_MODE_FILL; rs.cullMode = VK_CULL_MODE_NONE; rs.frontFace = VK_FRONT_FACE_COUNTER_CLOCKWISE; rs.lineWidth = 1.0f;
+        VkPipelineMultisampleStateCreateInfo ms{ VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO }; ms.rasterizationSamples = VK_SAMPLE_COUNT_1_BIT;
+        VkPipelineColorBlendAttachmentState cba{}; cba.colorWriteMask = VK_COLOR_COMPONENT_R_BIT | VK_COLOR_COMPONENT_G_BIT | VK_COLOR_COMPONENT_B_BIT | VK_COLOR_COMPONENT_A_BIT;
+        VkPipelineColorBlendStateCreateInfo cb{ VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO }; cb.attachmentCount = 1; cb.pAttachments = &cba;
+        VkPipeline pipeline;
+        VkGraphicsPipelineCreateInfo gpci{ VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO };
+        gpci.stageCount = 2; gpci.pStages = stages; gpci.pVertexInputState = &vin; gpci.pInputAssemblyState = &ia; gpci.pViewportState = &vps;
+        gpci.pRasterizationState = &rs; gpci.pMultisampleState = &ms; gpci.pColorBlendState = &cb; gpci.layout = playout; gpci.renderPass = rp; gpci.subpass = 0;
+        vkCreateGraphicsPipelines(m_device, VK_NULL_HANDLE, 1, &gpci, nullptr, &pipeline);
+        vkDestroyShaderModule(m_device, vmod, nullptr); vkDestroyShaderModule(m_device, fmod, nullptr);
+
+        float cube_verts[] = {
+            -1,1,-1, -1,-1,-1, 1,-1,-1, 1,-1,-1, 1,1,-1, -1,1,-1,
+            -1,-1,1, -1,-1,-1, -1,1,-1, -1,1,-1, -1,1,1, -1,-1,1,
+             1,-1,-1, 1,-1,1, 1,1,1, 1,1,1, 1,1,-1, 1,-1,-1,
+            -1,-1,1, -1,1,1, 1,1,1, 1,1,1, 1,-1,1, -1,-1,1,
+            -1,1,-1, 1,1,-1, 1,1,1, 1,1,1, -1,1,1, -1,1,-1,
+            -1,-1,-1, -1,-1,1, 1,-1,-1, 1,-1,-1, -1,-1,1, 1,-1,1,
+        };
+        VkBuffer cube_vb; VkDeviceMemory cube_vb_mem;
+        create_buffer_raw(sizeof(cube_verts), VK_BUFFER_USAGE_VERTEX_BUFFER_BIT, host_vis, cube_vb, cube_vb_mem);
+        vkMapMemory(m_device, cube_vb_mem, 0, sizeof(cube_verts), 0, &mp); std::memcpy(mp, cube_verts, sizeof(cube_verts)); vkUnmapMemory(m_device, cube_vb_mem);
+
+        glm::mat4 proj = glm::perspective(glm::radians(90.0f), 1.0f, 0.1f, 10.0f);
+        proj[1][1] *= -1.0f;
+        glm::mat4 views[6] = {
+            glm::lookAt(glm::vec3(0), glm::vec3( 1, 0, 0), glm::vec3(0, -1, 0)),
+            glm::lookAt(glm::vec3(0), glm::vec3(-1, 0, 0), glm::vec3(0, -1, 0)),
+            glm::lookAt(glm::vec3(0), glm::vec3( 0, 1, 0), glm::vec3(0, 0, 1)),
+            glm::lookAt(glm::vec3(0), glm::vec3( 0, -1, 0), glm::vec3(0, 0, -1)),
+            glm::lookAt(glm::vec3(0), glm::vec3( 0, 0, 1), glm::vec3(0, -1, 0)),
+            glm::lookAt(glm::vec3(0), glm::vec3( 0, 0, -1), glm::vec3(0, -1, 0)),
+        };
+        VkBuffer ubo[6]; VkDeviceMemory ubo_mem[6]; VkDescriptorSet sets[6];
+        for (uint32_t i = 0; i < 6; ++i)
+        {
+            create_buffer_raw(128, VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT, host_vis, ubo[i], ubo_mem[i]);
+            glm::mat4 mats[2] = { glm::transpose(proj), glm::transpose(views[i]) };
+            vkMapMemory(m_device, ubo_mem[i], 0, 128, 0, &mp); std::memcpy(mp, mats, 128); vkUnmapMemory(m_device, ubo_mem[i]);
+            VkDescriptorSetAllocateInfo dsai{ VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO }; dsai.descriptorPool = pool; dsai.descriptorSetCount = 1; dsai.pSetLayouts = &set_layout;
+            vkAllocateDescriptorSets(m_device, &dsai, &sets[i]);
+            VkDescriptorBufferInfo buf_info{ ubo[i], 0, VK_WHOLE_SIZE };
+            VkDescriptorImageInfo img_info{ eq_sampler, eq_view, VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL };
+            VkWriteDescriptorSet ws[2]{};
+            ws[0].sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET; ws[0].dstSet = sets[i]; ws[0].dstBinding = 0; ws[0].descriptorCount = 1; ws[0].descriptorType = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER; ws[0].pBufferInfo = &buf_info;
+            ws[1].sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET; ws[1].dstSet = sets[i]; ws[1].dstBinding = 1; ws[1].descriptorCount = 1; ws[1].descriptorType = VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER; ws[1].pImageInfo = &img_info;
+            vkUpdateDescriptorSets(m_device, 2, ws, 0, nullptr);
+        }
+
+        VkCommandBufferAllocateInfo cbai{ VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO };
+        cbai.commandPool = m_command_pool; cbai.level = VK_COMMAND_BUFFER_LEVEL_PRIMARY; cbai.commandBufferCount = 1;
+        VkCommandBuffer cmd; vkAllocateCommandBuffers(m_device, &cbai, &cmd);
+        VkCommandBufferBeginInfo bi{ VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO }; bi.flags = VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT;
+        vkBeginCommandBuffer(cmd, &bi);
+        VkImageMemoryBarrier to_dst{ VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER };
+        to_dst.oldLayout = VK_IMAGE_LAYOUT_UNDEFINED; to_dst.newLayout = VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL;
+        to_dst.image = eq_image; to_dst.subresourceRange = { VK_IMAGE_ASPECT_COLOR_BIT, 0, 1, 0, 1 };
+        to_dst.srcAccessMask = 0; to_dst.dstAccessMask = VK_ACCESS_TRANSFER_WRITE_BIT;
+        vkCmdPipelineBarrier(cmd, VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT, 0, 0, nullptr, 0, nullptr, 1, &to_dst);
+        VkBufferImageCopy copy{}; copy.imageSubresource = { VK_IMAGE_ASPECT_COLOR_BIT, 0, 0, 1 }; copy.imageExtent = { (uint32_t)w, (uint32_t)h, 1 };
+        vkCmdCopyBufferToImage(cmd, eq_staging, eq_image, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, 1, &copy);
+        VkImageMemoryBarrier to_read = to_dst; to_read.oldLayout = VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL; to_read.newLayout = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL;
+        to_read.srcAccessMask = VK_ACCESS_TRANSFER_WRITE_BIT; to_read.dstAccessMask = VK_ACCESS_SHADER_READ_BIT;
+        vkCmdPipelineBarrier(cmd, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT, 0, 0, nullptr, 0, nullptr, 1, &to_read);
+
+        VkClearValue clear{}; clear.color = { { 0, 0, 0, 1 } };
+        for (uint32_t i = 0; i < 6; ++i)
+        {
+            VkRenderPassBeginInfo rpbi{ VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO };
+            rpbi.renderPass = rp; rpbi.framebuffer = face_fb[i]; rpbi.renderArea = { { 0, 0 }, { FACE, FACE } }; rpbi.clearValueCount = 1; rpbi.pClearValues = &clear;
+            vkCmdBeginRenderPass(cmd, &rpbi, VK_SUBPASS_CONTENTS_INLINE);
+            vkCmdBindPipeline(cmd, VK_PIPELINE_BIND_POINT_GRAPHICS, pipeline);
+            vkCmdBindDescriptorSets(cmd, VK_PIPELINE_BIND_POINT_GRAPHICS, playout, 0, 1, &sets[i], 0, nullptr);
+            VkDeviceSize off = 0; vkCmdBindVertexBuffers(cmd, 0, 1, &cube_vb, &off);
+            vkCmdDraw(cmd, 36, 1, 0, 0);
+            vkCmdEndRenderPass(cmd);
+        }
+
+        {
+            VkImageMemoryBarrier src0{ VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER };
+            src0.image = tex->m_image; src0.subresourceRange = { VK_IMAGE_ASPECT_COLOR_BIT, 0, 1, 0, 6 };
+            src0.oldLayout = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL; src0.newLayout = VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL;
+            src0.srcAccessMask = VK_ACCESS_SHADER_READ_BIT; src0.dstAccessMask = VK_ACCESS_TRANSFER_READ_BIT;
+            vkCmdPipelineBarrier(cmd, VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT, 0, 0, nullptr, 0, nullptr, 1, &src0);
+            int32_t mipW = (int32_t)FACE, mipH = (int32_t)FACE;
+            for (uint32_t m = 1; m < CUBE_MIPS; ++m)
+            {
+                int32_t nW = mipW > 1 ? mipW / 2 : 1, nH = mipH > 1 ? mipH / 2 : 1;
+                VkImageMemoryBarrier bd{ VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER };
+                bd.image = tex->m_image; bd.subresourceRange = { VK_IMAGE_ASPECT_COLOR_BIT, m, 1, 0, 6 };
+                bd.oldLayout = VK_IMAGE_LAYOUT_UNDEFINED; bd.newLayout = VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL;
+                bd.srcAccessMask = 0; bd.dstAccessMask = VK_ACCESS_TRANSFER_WRITE_BIT;
+                vkCmdPipelineBarrier(cmd, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT, 0, 0, nullptr, 0, nullptr, 1, &bd);
+                VkImageBlit blit{};
+                blit.srcOffsets[1] = { mipW, mipH, 1 }; blit.srcSubresource = { VK_IMAGE_ASPECT_COLOR_BIT, m - 1, 0, 6 };
+                blit.dstOffsets[1] = { nW, nH, 1 };     blit.dstSubresource = { VK_IMAGE_ASPECT_COLOR_BIT, m, 0, 6 };
+                vkCmdBlitImage(cmd, tex->m_image, VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, tex->m_image, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, 1, &blit, VK_FILTER_LINEAR);
+                VkImageMemoryBarrier bs{ VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER };
+                bs.image = tex->m_image; bs.subresourceRange = { VK_IMAGE_ASPECT_COLOR_BIT, m, 1, 0, 6 };
+                bs.oldLayout = VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL; bs.newLayout = VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL;
+                bs.srcAccessMask = VK_ACCESS_TRANSFER_WRITE_BIT; bs.dstAccessMask = VK_ACCESS_TRANSFER_READ_BIT;
+                vkCmdPipelineBarrier(cmd, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT, 0, 0, nullptr, 0, nullptr, 1, &bs);
+                mipW = nW; mipH = nH;
+            }
+            VkImageMemoryBarrier fin{ VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER };
+            fin.image = tex->m_image; fin.subresourceRange = { VK_IMAGE_ASPECT_COLOR_BIT, 0, CUBE_MIPS, 0, 6 };
+            fin.oldLayout = VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL; fin.newLayout = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL;
+            fin.srcAccessMask = VK_ACCESS_TRANSFER_READ_BIT; fin.dstAccessMask = VK_ACCESS_SHADER_READ_BIT;
+            vkCmdPipelineBarrier(cmd, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT, 0, 0, nullptr, 0, nullptr, 1, &fin);
+        }
+
+        vkEndCommandBuffer(cmd);
+        VkSubmitInfo si{ VK_STRUCTURE_TYPE_SUBMIT_INFO }; si.commandBufferCount = 1; si.pCommandBuffers = &cmd;
+        vkQueueSubmit(m_graphics_queue, 1, &si, VK_NULL_HANDLE); vkQueueWaitIdle(m_graphics_queue);
+
+        vkFreeCommandBuffers(m_device, m_command_pool, 1, &cmd);
+        for (uint32_t i = 0; i < 6; ++i) { vkDestroyBuffer(m_device, ubo[i], nullptr); vkFreeMemory(m_device, ubo_mem[i], nullptr); vkDestroyFramebuffer(m_device, face_fb[i], nullptr); vkDestroyImageView(m_device, face_views[i], nullptr); }
+        vkDestroyBuffer(m_device, cube_vb, nullptr); vkFreeMemory(m_device, cube_vb_mem, nullptr);
+        vkDestroyPipeline(m_device, pipeline, nullptr); vkDestroyPipelineLayout(m_device, playout, nullptr);
+        vkDestroyDescriptorPool(m_device, pool, nullptr); vkDestroyDescriptorSetLayout(m_device, set_layout, nullptr);
+        vkDestroyRenderPass(m_device, rp, nullptr);
+        vkDestroySampler(m_device, eq_sampler, nullptr); vkDestroyImageView(m_device, eq_view, nullptr);
+        vkDestroyImage(m_device, eq_image, nullptr); vkFreeMemory(m_device, eq_mem, nullptr);
+        vkDestroyBuffer(m_device, eq_staging, nullptr); vkFreeMemory(m_device, eq_staging_mem, nullptr);
+        DONUT_INFO("Vulkan RHI: HDRI cubemap built from {} ({}x{} equirect -> {}^2 cube)", path, w, h, (int)FACE);
+        return tex;
+    }
+
+}
diff --git a/src/platform/vulkan/vulkan_device.cpp b/src/platform/vulkan/vulkan_device.cpp
index 45e773e..5d80cff 100644
--- a/src/platform/vulkan/vulkan_device.cpp
+++ b/src/platform/vulkan/vulkan_device.cpp
@@ -1,1290 +1,183 @@
-#include "vulkan_device.h"
-
-#include "core/log.h"
-
-#define GLFW_INCLUDE_VULKAN
-#include <GLFW/glfw3.h>
+#include "vulkan_common.h"
 
 #include <imgui.h>
 #include <imgui_impl_glfw.h>
 #include <imgui_impl_vulkan.h>
 
-#include <glm/glm.hpp>
-#include <glm/gtc/matrix_transform.hpp>
-#include "stb_image.h"
-
-#include <vector>
-#include <array>
-#include <algorithm>
-#include <cstring>
-#include <cstdlib>
 #include <fstream>
-#include <unordered_map>
+#include <cstdlib>
 
 namespace Donut::RHI
 {
-    namespace
+    auto VulkanDevice::find_memory_type(uint32_t filter, VkMemoryPropertyFlags flags) const -> uint32_t
     {
-        constexpr int MAX_FRAMES_IN_FLIGHT = 2;
-        constexpr uint32_t MAX_BINDINGS = 8;
-
-        #define VKD_CHECK(expr)                                            \
-            do {                                                           \
-                VkResult _r = (expr);                                      \
-                if (_r != VK_SUCCESS) {                                    \
-                    DONUT_ERROR("Vulkan RHI: {} failed ({})", #expr, (int)_r); \
-                    return false;                                          \
-                }                                                          \
-            } while (0)
-
-        auto vk_format(Format f) -> VkFormat
-        {
-            switch (f) {
-                case Format::RGBA16F: return VK_FORMAT_R16G16B16A16_SFLOAT;
-                case Format::D32:     return VK_FORMAT_D32_SFLOAT;
-                default:              return VK_FORMAT_R8G8B8A8_UNORM;
-            }
-        }
-        auto vk_attr_format(uint32_t comps) -> VkFormat
-        {
-            switch (comps) {
-                case 1:  return VK_FORMAT_R32_SFLOAT;
-                case 2:  return VK_FORMAT_R32G32_SFLOAT;
-                case 3:  return VK_FORMAT_R32G32B32_SFLOAT;
-                default: return VK_FORMAT_R32G32B32A32_SFLOAT;
-            }
-        }
-        auto vk_topology(Topology t) -> VkPrimitiveTopology
-        { return t == Topology::Lines ? VK_PRIMITIVE_TOPOLOGY_LINE_LIST : VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST; }
-        auto vk_compare(CompareOp o) -> VkCompareOp
-        { return o == CompareOp::Always ? VK_COMPARE_OP_ALWAYS : o == CompareOp::LessEqual ? VK_COMPARE_OP_LESS_OR_EQUAL : VK_COMPARE_OP_LESS; }
-        auto vk_filter(Filter f) -> VkFilter { return f == Filter::Nearest ? VK_FILTER_NEAREST : VK_FILTER_LINEAR; }
-        auto vk_cull(CullMode c) -> VkCullModeFlags
-        { return c == CullMode::None ? VK_CULL_MODE_NONE : c == CullMode::Back ? VK_CULL_MODE_BACK_BIT : VK_CULL_MODE_FRONT_BIT; }
-
-        class VulkanDevice;
-
-        // ---- Buffer: host-visible + coherent, persistently mapped -----------
-        class VkBufferR : public Buffer
-        {
-        public:
-            VkBufferR(VkDevice d, VkBuffer b, VkDeviceMemory m, void* mapped, size_t size)
-                : m_device(d), m_buf(b), m_mem(m), m_mapped(mapped), m_size(size) {}
-            ~VkBufferR() override
-            {
-                if (m_mapped) vkUnmapMemory(m_device, m_mem);
-                if (m_buf) vkDestroyBuffer(m_device, m_buf, nullptr);
-                if (m_mem) vkFreeMemory(m_device, m_mem, nullptr);
-            }
-            auto update(const void* data, size_t size) -> void override
-            { if (m_mapped) std::memcpy(m_mapped, data, std::min(size, m_size)); }
-
-            VkDevice m_device; VkBuffer m_buf; VkDeviceMemory m_mem; void* m_mapped; size_t m_size;
-        };
-
-        // ---- Texture: sampled image (2D or cube). Owns its handles unless it is
-        //      a borrowed wrapper around a render-target view. ------------------
-        class VkTextureR : public Texture
-        {
-        public:
-            VkTextureR() = default;
-            ~VkTextureR() override
-            {
-                if (!m_owns) return;
-                if (m_sampler) vkDestroySampler(m_device, m_sampler, nullptr);
-                if (m_view)    vkDestroyImageView(m_device, m_view, nullptr);
-                if (m_image)   vkDestroyImage(m_device, m_image, nullptr);
-                if (m_mem)     vkFreeMemory(m_device, m_mem, nullptr);
-            }
-            VkDevice      m_device  = VK_NULL_HANDLE;
-            VkImage       m_image   = VK_NULL_HANDLE;
-            VkDeviceMemory m_mem    = VK_NULL_HANDLE;
-            VkImageView   m_view    = VK_NULL_HANDLE;
-            VkSampler     m_sampler = VK_NULL_HANDLE;
-            bool          m_owns    = true;
-        };
-
-        // ---- RenderTarget: off-screen colour image + framebuffer ------------
-        class VkRenderTargetR : public RenderTarget
-        {
-        public:
-            ~VkRenderTargetR() override
-            {
-                if (m_fb)          vkDestroyFramebuffer(m_device, m_fb, nullptr);
-                if (m_sampler)     vkDestroySampler(m_device, m_sampler, nullptr);
-                if (m_view)        vkDestroyImageView(m_device, m_view, nullptr);
-                if (m_image)       vkDestroyImage(m_device, m_image, nullptr);
-                if (m_mem)         vkFreeMemory(m_device, m_mem, nullptr);
-                if (m_depth_view)  vkDestroyImageView(m_device, m_depth_view, nullptr);
-                if (m_depth_image) vkDestroyImage(m_device, m_depth_image, nullptr);
-                if (m_depth_mem)   vkFreeMemory(m_device, m_depth_mem, nullptr);
-                // m_pass is owned by the device's render-pass cache, not by us.
-            }
-            auto width()  const -> int override { return m_w; }
-            auto height() const -> int override { return m_h; }
-            auto color_texture() -> Texture* override { return &m_color; }
-
-            VkDevice       m_device  = VK_NULL_HANDLE;
-            int            m_w = 0, m_h = 0;
-            VkImage        m_image   = VK_NULL_HANDLE;
-            VkDeviceMemory m_mem     = VK_NULL_HANDLE;
-            VkImageView    m_view    = VK_NULL_HANDLE;
-            VkSampler      m_sampler = VK_NULL_HANDLE;
-            VkFramebuffer  m_fb      = VK_NULL_HANDLE;
-            VkRenderPass   m_pass    = VK_NULL_HANDLE;   // borrowed (device pass cache)
-            bool           m_has_depth = false;
-            VkImage        m_depth_image = VK_NULL_HANDLE;
-            VkDeviceMemory m_depth_mem   = VK_NULL_HANDLE;
-            VkImageView    m_depth_view  = VK_NULL_HANDLE;
-            VkTextureR     m_color;   // borrowed wrapper (view+sampler) for sampling
-        };
-
-        // ---- Pipeline -------------------------------------------------------
-        class VkPipelineR : public Pipeline
-        {
-        public:
-            ~VkPipelineR() override
-            {
-                if (m_pipeline)   vkDestroyPipeline(m_device, m_pipeline, nullptr);
-                if (m_layout)     vkDestroyPipelineLayout(m_device, m_layout, nullptr);
-                if (m_set_layout) vkDestroyDescriptorSetLayout(m_device, m_set_layout, nullptr);
-            }
-            VkDevice              m_device      = VK_NULL_HANDLE;
-            VkPipeline            m_pipeline    = VK_NULL_HANDLE;
-            VkPipelineLayout      m_layout      = VK_NULL_HANDLE;
-            VkDescriptorSetLayout m_set_layout  = VK_NULL_HANDLE;
-            std::vector<ResourceSlot> m_resources;
-        };
-
-        // ---- CommandList ----------------------------------------------------
-        class VkCommandListR : public CommandList
-        {
-        public:
-            auto begin_render_pass(RenderTarget* target, const glm::vec4& clear) -> void override
-            {
-                VkClearValue cvs[2]{};
-                cvs[0].color = { { clear.r, clear.g, clear.b, clear.a } };
-                cvs[1].depthStencil = { 1.0f, 0 };
-                VkRenderPassBeginInfo rpbi{ VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO };
-                if (target)
-                {
-                    auto* rt = static_cast<VkRenderTargetR*>(target);
-                    rpbi.renderPass = rt->m_pass; rpbi.framebuffer = rt->m_fb;
-                    rpbi.renderArea = { { 0, 0 }, { (uint32_t)rt->m_w, (uint32_t)rt->m_h } };
-                    rpbi.clearValueCount = rt->m_has_depth ? 2 : 1; rpbi.pClearValues = cvs;
-                }
-                else
-                {
-                    rpbi.renderPass = m_swapchain_rp; rpbi.framebuffer = m_swapchain_fb;
-                    rpbi.renderArea = { { 0, 0 }, m_extent };
-                    rpbi.clearValueCount = 2; rpbi.pClearValues = cvs;
-                }
-                vkCmdBeginRenderPass(m_cmd, &rpbi, VK_SUBPASS_CONTENTS_INLINE);
-            }
-            auto end_render_pass() -> void override { vkCmdEndRenderPass(m_cmd); }
-
-            auto bind_pipeline(Pipeline* p) -> void override
-            {
-                m_pipe = static_cast<VkPipelineR*>(p);
-                vkCmdBindPipeline(m_cmd, VK_PIPELINE_BIND_POINT_GRAPHICS, m_pipe->m_pipeline);
-            }
-            auto set_viewport(int x, int y, int w, int h, bool flip_y) -> void override
-            {
-                VkViewport vp{ (float)x, flip_y ? (float)(y + h) : (float)y,
-                               (float)w, flip_y ? -(float)h : (float)h, 0.0f, 1.0f };
-                VkRect2D sc{ { x, y }, { (uint32_t)w, (uint32_t)h } };
-                vkCmdSetViewport(m_cmd, 0, 1, &vp);
-                vkCmdSetScissor(m_cmd, 0, 1, &sc);
-            }
-            auto bind_uniform(uint32_t binding, Buffer* ubo) -> void override
-            {
-                if (binding >= MAX_BINDINGS) return;
-                m_buf_info[binding] = { static_cast<VkBufferR*>(ubo)->m_buf, 0, VK_WHOLE_SIZE };
-            }
-            auto bind_texture(uint32_t binding, Texture* texture) -> void override
-            {
-                if (binding >= MAX_BINDINGS) return;
-                auto* t = static_cast<VkTextureR*>(texture);
-                m_img_info[binding] = { t->m_sampler, t->m_view, VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL };
-            }
-            auto bind_vertex_buffer(Buffer* vb) -> void override
-            {
-                VkBuffer b = static_cast<VkBufferR*>(vb)->m_buf; VkDeviceSize off = 0;
-                vkCmdBindVertexBuffers(m_cmd, 0, 1, &b, &off);
-            }
-            auto bind_index_buffer(Buffer* ib) -> void override
-            { vkCmdBindIndexBuffer(m_cmd, static_cast<VkBufferR*>(ib)->m_buf, 0, VK_INDEX_TYPE_UINT32); }
-            auto draw(uint32_t vertex_count) -> void override
-            { flush_descriptors(); vkCmdDraw(m_cmd, vertex_count, 1, 0, 0); }
-            auto draw_indexed(uint32_t index_count) -> void override
-            { flush_descriptors(); vkCmdDrawIndexed(m_cmd, index_count, 1, 0, 0, 0); }
-
-            // Allocate + write + bind a descriptor set for the current pipeline's
-            // declared resources, using whatever was bound since bind_pipeline.
-            auto flush_descriptors() -> void
-            {
-                if (!m_pipe || m_pipe->m_resources.empty()) return;
-                VkDescriptorSetAllocateInfo ai{ VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO };
-                ai.descriptorPool = m_frame_pool; ai.descriptorSetCount = 1; ai.pSetLayouts = &m_pipe->m_set_layout;
-                VkDescriptorSet set = VK_NULL_HANDLE;
-                if (vkAllocateDescriptorSets(m_device, &ai, &set) != VK_SUCCESS)
-                { DONUT_ERROR("Vulkan RHI: descriptor set allocation failed"); return; }
-
-                std::array<VkWriteDescriptorSet, MAX_BINDINGS> writes{};
-                uint32_t n = 0;
-                for (const auto& r : m_pipe->m_resources)
-                {
-                    VkWriteDescriptorSet& w = writes[n++];
-                    w.sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET;
-                    w.dstSet = set; w.dstBinding = r.binding; w.descriptorCount = 1;
-                    if (r.kind == ResourceKind::UniformBuffer)
-                    { w.descriptorType = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER; w.pBufferInfo = &m_buf_info[r.binding]; }
-                    else
-                    { w.descriptorType = VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER; w.pImageInfo = &m_img_info[r.binding]; }
-                }
-                vkUpdateDescriptorSets(m_device, n, writes.data(), 0, nullptr);
-                vkCmdBindDescriptorSets(m_cmd, VK_PIPELINE_BIND_POINT_GRAPHICS, m_pipe->m_layout, 0, 1, &set, 0, nullptr);
-            }
-
-            // Set by the device at begin_frame:
-            VkDevice        m_device       = VK_NULL_HANDLE;
-            VkCommandBuffer m_cmd          = VK_NULL_HANDLE;
-            VkRenderPass    m_swapchain_rp = VK_NULL_HANDLE;
-            VkFramebuffer   m_swapchain_fb = VK_NULL_HANDLE;
-            VkExtent2D      m_extent{};
-            VkDescriptorPool m_frame_pool  = VK_NULL_HANDLE;
-
-            VkPipelineR* m_pipe = nullptr;
-            VkDescriptorBufferInfo m_buf_info[MAX_BINDINGS]{};
-            VkDescriptorImageInfo  m_img_info[MAX_BINDINGS]{};
-        };
-
-        // ---- Device ---------------------------------------------------------
-        class VulkanDevice : public Device
-        {
-        public:
-            auto init(const NativeWindow& window) -> bool override;
-            auto shutdown() -> void override;
-            auto resize(int width, int height) -> void override { m_framebuffer_resized = true; m_width = width; m_height = height; }
-            auto wait_idle() -> void override { if (m_device) vkDeviceWaitIdle(m_device); }
-
-            auto create_buffer(BufferType type, size_t size, const void* data) -> Ref<Buffer> override;
-            auto create_texture(int w, int h, Format format, Filter filter, const void* data) -> Ref<Texture> override;
-            auto create_cubemap_from_hdri(const std::string& path) -> Ref<Texture> override;
-            auto create_render_target(int w, int h, Format color, Format depth, Filter filter, int mips) -> Ref<RenderTarget> override;
-            auto create_pipeline(const PipelineDesc& desc) -> Ref<Pipeline> override;
-
-            auto begin_frame(const glm::vec4& clear) -> CommandList* override;
-            auto end_frame() -> void override;
-
-            auto init_imgui() -> void override;
-            auto imgui_new_frame() -> void override;
-            auto imgui_render(CommandList& cmds) -> void override;
-
-            auto device_name() const -> const std::string& override { return m_gpu_name; }
-
-            // --- internals ---
-            auto find_memory_type(uint32_t filter, VkMemoryPropertyFlags flags) const -> uint32_t;
-            auto create_buffer_raw(VkDeviceSize size, VkBufferUsageFlags usage, VkMemoryPropertyFlags props, VkBuffer& buf, VkDeviceMemory& mem) const -> bool;
-            auto load_spirv(const std::string& path) const -> std::vector<uint32_t>;
-            auto create_shader_module(const std::string& path, VkShaderModule& out) const -> bool;
-
-            auto create_instance() -> bool;
-            auto pick_physical_and_device() -> bool;
-            auto create_swapchain() -> bool;
-            auto create_image_views() -> bool;
-            // Render passes are format-driven and cached: a pipeline/target's
-            // attachment signature (colour + optional depth, present vs sampled)
-            // maps to one pass. `present` = presented swapchain image.
-            auto get_render_pass(VkFormat color, VkFormat depth, bool present) -> VkRenderPass;
-            auto create_depth_and_framebuffers() -> bool;
-            auto create_command_and_sync() -> bool;
-            auto recreate_swapchain() -> bool;
-            auto cleanup_swapchain() -> void;
-
-            GLFWwindow* m_window = nullptr;
-            int m_width = 0, m_height = 0;
-            bool m_framebuffer_resized = false;
-            std::string m_gpu_name;
-
-            VkInstance       m_instance = VK_NULL_HANDLE;
-            VkSurfaceKHR     m_surface  = VK_NULL_HANDLE;
-            VkPhysicalDevice m_physical = VK_NULL_HANDLE;
-            VkDevice         m_device   = VK_NULL_HANDLE;
-            uint32_t         m_graphics_family = 0, m_present_family = 0;
-            VkQueue          m_graphics_queue = VK_NULL_HANDLE, m_present_queue = VK_NULL_HANDLE;
-            VkPhysicalDeviceMemoryProperties m_mem_props{};
-
-            VkSwapchainKHR m_swapchain = VK_NULL_HANDLE;
-            VkFormat       m_swapchain_format = VK_FORMAT_B8G8R8A8_UNORM;
-            VkExtent2D     m_extent{};
-            std::vector<VkImage>       m_images;
-            std::vector<VkImageView>   m_image_views;
-            VkRenderPass               m_swapchain_rp = VK_NULL_HANDLE;   // also lives in m_pass_cache
-            std::unordered_map<uint64_t, VkRenderPass> m_pass_cache;      // keyed by (color,depth,present)
-            std::vector<VkFramebuffer> m_framebuffers;
-            VkImage m_depth_image = VK_NULL_HANDLE; VkDeviceMemory m_depth_mem = VK_NULL_HANDLE; VkImageView m_depth_view = VK_NULL_HANDLE;
-
-            VkCommandPool m_command_pool = VK_NULL_HANDLE;
-            std::vector<VkCommandBuffer> m_command_buffers;
-            std::vector<VkSemaphore> m_image_available;
-            std::vector<VkSemaphore> m_render_finished;
-            std::vector<VkFence>     m_in_flight;
-            std::vector<VkFence>     m_images_in_flight;
-            VkFence m_geo_in_use = VK_NULL_HANDLE;
-            uint32_t m_current_frame = 0, m_image_index = 0;
-
-            std::vector<VkDescriptorPool> m_frame_pools;    // one per frame in flight
-            VkDescriptorPool m_imgui_pool = VK_NULL_HANDLE;
-            bool m_imgui = false;
-
-            VkCommandListR m_cmds;
-        };
-
-        // ==================================================================
-        auto VulkanDevice::find_memory_type(uint32_t filter, VkMemoryPropertyFlags flags) const -> uint32_t
-        {
-            for (uint32_t i = 0; i < m_mem_props.memoryTypeCount; ++i)
-                if ((filter & (1u << i)) && (m_mem_props.memoryTypes[i].propertyFlags & flags) == flags)
-                    return i;
-            return UINT32_MAX;
-        }
-
-        auto VulkanDevice::create_buffer_raw(VkDeviceSize size, VkBufferUsageFlags usage, VkMemoryPropertyFlags props,
-                                             VkBuffer& buf, VkDeviceMemory& mem) const -> bool
-        {
-            VkBufferCreateInfo bci{ VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO };
-            bci.size = size; bci.usage = usage; bci.sharingMode = VK_SHARING_MODE_EXCLUSIVE;
-            if (vkCreateBuffer(m_device, &bci, nullptr, &buf) != VK_SUCCESS) return false;
-            VkMemoryRequirements req{}; vkGetBufferMemoryRequirements(m_device, buf, &req);
-            VkMemoryAllocateInfo ai{ VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO };
-            ai.allocationSize = req.size; ai.memoryTypeIndex = find_memory_type(req.memoryTypeBits, props);
-            if (vkAllocateMemory(m_device, &ai, nullptr, &mem) != VK_SUCCESS) return false;
-            vkBindBufferMemory(m_device, buf, mem, 0);
-            return true;
-        }
-
-        auto VulkanDevice::load_spirv(const std::string& path) const -> std::vector<uint32_t>
-        {
-            std::ifstream file(path, std::ios::ate | std::ios::binary);
-            if (!file.is_open()) return {};
-            size_t size = (size_t)file.tellg();
-            std::vector<uint32_t> data(size / 4);
-            file.seekg(0); file.read(reinterpret_cast<char*>(data.data()), size);
-            return data;
-        }
-
-        auto VulkanDevice::create_shader_module(const std::string& path, VkShaderModule& out) const -> bool
-        {
-            auto spv = load_spirv(path);
-            if (spv.empty()) { DONUT_ERROR("Vulkan RHI: failed to load SPIR-V {}", path); return false; }
-            VkShaderModuleCreateInfo ci{ VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO };
-            ci.codeSize = spv.size() * 4; ci.pCode = spv.data();
-            return vkCreateShaderModule(m_device, &ci, nullptr, &out) == VK_SUCCESS;
-        }
-
-        auto VulkanDevice::create_instance() -> bool
-        {
-            VkApplicationInfo app{ VK_STRUCTURE_TYPE_APPLICATION_INFO };
-            app.pApplicationName = "Donut"; app.apiVersion = VK_API_VERSION_1_2;
-
-            uint32_t glfwExtCount = 0;
-            const char** glfwExts = glfwGetRequiredInstanceExtensions(&glfwExtCount);
-            if (!glfwExts) { DONUT_ERROR("Vulkan RHI: GLFW reports no surface support"); return false; }
-            std::vector<const char*> exts(glfwExts, glfwExts + glfwExtCount);
-            exts.push_back(VK_KHR_PORTABILITY_ENUMERATION_EXTENSION_NAME);
-            exts.push_back(VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME);
-
-            std::vector<const char*> layers;
-            uint32_t layer_count = 0; vkEnumerateInstanceLayerProperties(&layer_count, nullptr);
-            std::vector<VkLayerProperties> avail(layer_count);
-            vkEnumerateInstanceLayerProperties(&layer_count, avail.data());
-            for (const auto& l : avail)
-                if (std::strcmp(l.layerName, "VK_LAYER_KHRONOS_validation") == 0)
-                    layers.push_back("VK_LAYER_KHRONOS_validation");
-
-            VkInstanceCreateInfo ici{ VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO };
-            ici.flags = VK_INSTANCE_CREATE_ENUMERATE_PORTABILITY_BIT_KHR;
-            ici.pApplicationInfo = &app;
-            ici.enabledExtensionCount = (uint32_t)exts.size(); ici.ppEnabledExtensionNames = exts.data();
-            ici.enabledLayerCount = (uint32_t)layers.size(); ici.ppEnabledLayerNames = layers.data();
-            VkResult r = vkCreateInstance(&ici, nullptr, &m_instance);
-            if (r != VK_SUCCESS && !layers.empty())
-            {
-                DONUT_WARN("Vulkan RHI: validation layer unavailable, continuing without it");
-                ici.enabledLayerCount = 0; ici.ppEnabledLayerNames = nullptr;
-                r = vkCreateInstance(&ici, nullptr, &m_instance);
-            }
-            if (r != VK_SUCCESS) { DONUT_ERROR("Vulkan RHI: vkCreateInstance failed ({})", (int)r); return false; }
-            VKD_CHECK(glfwCreateWindowSurface(m_instance, m_window, nullptr, &m_surface));
-            DONUT_INFO("Vulkan RHI: instance + surface created (validation {})", layers.empty() ? "off" : "on");
-            return true;
-        }
-
-        auto VulkanDevice::pick_physical_and_device() -> bool
-        {
-            uint32_t count = 0; vkEnumeratePhysicalDevices(m_instance, &count, nullptr);
-            if (count == 0) { DONUT_ERROR("Vulkan RHI: no physical devices"); return false; }
-            std::vector<VkPhysicalDevice> devices(count);
-            vkEnumeratePhysicalDevices(m_instance, &count, devices.data());
-            m_physical = devices[0];
-
-            uint32_t q = 0; vkGetPhysicalDeviceQueueFamilyProperties(m_physical, &q, nullptr);
-            std::vector<VkQueueFamilyProperties> qfams(q);
-            vkGetPhysicalDeviceQueueFamilyProperties(m_physical, &q, qfams.data());
-            bool fg = false, fp = false;
-            for (uint32_t i = 0; i < q; ++i)
-            {
-                if (!fg && (qfams[i].queueFlags & VK_QUEUE_GRAPHICS_BIT)) { m_graphics_family = i; fg = true; }
-                VkBool32 present = VK_FALSE; vkGetPhysicalDeviceSurfaceSupportKHR(m_physical, i, m_surface, &present);
-                if (!fp && present) { m_present_family = i; fp = true; }
-            }
-            if (!fg || !fp) { DONUT_ERROR("Vulkan RHI: no graphics/present queue"); return false; }
-
-            std::vector<const char*> dev_exts = { VK_KHR_SWAPCHAIN_EXTENSION_NAME };
-            uint32_t dec = 0; vkEnumerateDeviceExtensionProperties(m_physical, nullptr, &dec, nullptr);
-            std::vector<VkExtensionProperties> dep(dec);
-            vkEnumerateDeviceExtensionProperties(m_physical, nullptr, &dec, dep.data());
-            for (const auto& e : dep)
-                if (std::strcmp(e.extensionName, "VK_KHR_portability_subset") == 0)
-                    dev_exts.push_back("VK_KHR_portability_subset");
-
-            float priority = 1.0f;
-            std::vector<VkDeviceQueueCreateInfo> qcis;
-            uint32_t families[2] = { m_graphics_family, m_present_family };
-            for (uint32_t i = 0; i < (m_graphics_family == m_present_family ? 1u : 2u); ++i)
-            {
-                VkDeviceQueueCreateInfo qci{ VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO };
-                qci.queueFamilyIndex = families[i]; qci.queueCount = 1; qci.pQueuePriorities = &priority;
-                qcis.push_back(qci);
-            }
-            VkDeviceCreateInfo dci{ VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO };
-            dci.queueCreateInfoCount = (uint32_t)qcis.size(); dci.pQueueCreateInfos = qcis.data();
-            dci.enabledExtensionCount = (uint32_t)dev_exts.size(); dci.ppEnabledExtensionNames = dev_exts.data();
-            VKD_CHECK(vkCreateDevice(m_physical, &dci, nullptr, &m_device));
-            vkGetDeviceQueue(m_device, m_graphics_family, 0, &m_graphics_queue);
-            vkGetDeviceQueue(m_device, m_present_family, 0, &m_present_queue);
-
-            VkPhysicalDeviceProperties props{}; vkGetPhysicalDeviceProperties(m_physical, &props);
-            vkGetPhysicalDeviceMemoryProperties(m_physical, &m_mem_props);
-            m_gpu_name = props.deviceName;
-            DONUT_INFO("Vulkan RHI device: {}", m_gpu_name);
-            return true;
-        }
-
-        auto VulkanDevice::create_swapchain() -> bool
-        {
-            VkSurfaceCapabilitiesKHR caps{};
-            vkGetPhysicalDeviceSurfaceCapabilitiesKHR(m_physical, m_surface, &caps);
-            uint32_t fc = 0; vkGetPhysicalDeviceSurfaceFormatsKHR(m_physical, m_surface, &fc, nullptr);
-            std::vector<VkSurfaceFormatKHR> formats(fc);
-            vkGetPhysicalDeviceSurfaceFormatsKHR(m_physical, m_surface, &fc, formats.data());
-            VkSurfaceFormatKHR chosen = formats[0];
-            for (const auto& f : formats)
-                if (f.format == VK_FORMAT_B8G8R8A8_UNORM && f.colorSpace == VK_COLOR_SPACE_SRGB_NONLINEAR_KHR) chosen = f;
-            m_swapchain_format = chosen.format;
-
-            if (caps.currentExtent.width != UINT32_MAX) m_extent = caps.currentExtent;
-            else {
-                m_extent.width  = std::clamp((uint32_t)m_width,  caps.minImageExtent.width,  caps.maxImageExtent.width);
-                m_extent.height = std::clamp((uint32_t)m_height, caps.minImageExtent.height, caps.maxImageExtent.height);
-            }
-            uint32_t image_count = caps.minImageCount + 1;
-            if (caps.maxImageCount > 0 && image_count > caps.maxImageCount) image_count = caps.maxImageCount;
-
-            VkSwapchainCreateInfoKHR sci{ VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR };
-            sci.surface = m_surface; sci.minImageCount = image_count;
-            sci.imageFormat = chosen.format; sci.imageColorSpace = chosen.colorSpace;
-            sci.imageExtent = m_extent; sci.imageArrayLayers = 1;
-            sci.imageUsage = VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT;
-            sci.preTransform = caps.currentTransform; sci.compositeAlpha = VK_COMPOSITE_ALPHA_OPAQUE_BIT_KHR;
-            sci.presentMode = VK_PRESENT_MODE_FIFO_KHR; sci.clipped = VK_TRUE;
-            uint32_t fam[2] = { m_graphics_family, m_present_family };
-            if (m_graphics_family != m_present_family)
-            { sci.imageSharingMode = VK_SHARING_MODE_CONCURRENT; sci.queueFamilyIndexCount = 2; sci.pQueueFamilyIndices = fam; }
-            else sci.imageSharingMode = VK_SHARING_MODE_EXCLUSIVE;
-            VKD_CHECK(vkCreateSwapchainKHR(m_device, &sci, nullptr, &m_swapchain));
-            uint32_t n = 0; vkGetSwapchainImagesKHR(m_device, m_swapchain, &n, nullptr);
-            m_images.resize(n); vkGetSwapchainImagesKHR(m_device, m_swapchain, &n, m_images.data());
-            return true;
-        }
-
-        auto VulkanDevice::create_image_views() -> bool
-        {
-            m_image_views.resize(m_images.size());
-            for (size_t i = 0; i < m_images.size(); ++i)
-            {
-                VkImageViewCreateInfo vci{ VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO };
-                vci.image = m_images[i]; vci.viewType = VK_IMAGE_VIEW_TYPE_2D; vci.format = m_swapchain_format;
-                vci.subresourceRange = { VK_IMAGE_ASPECT_COLOR_BIT, 0, 1, 0, 1 };
-                VKD_CHECK(vkCreateImageView(m_device, &vci, nullptr, &m_image_views[i]));
-            }
-            return true;
-        }
-
-        // A render pass for one attachment signature, created once and cached.
-        // `present` targets (the swapchain) finish PRESENT_SRC and sync on the
-        // colour-output stage; `sampled` targets (off-screen) finish
-        // SHADER_READ_ONLY and round-trip through the fragment shader so the next
-        // pass can sample them. Depth (VK_FORMAT_UNDEFINED = none) is optional.
-        auto VulkanDevice::get_render_pass(VkFormat color, VkFormat depth, bool present) -> VkRenderPass
-        {
-            uint64_t key = (uint64_t)(uint32_t)color
-                         | ((uint64_t)(uint32_t)depth << 24)
-                         | ((uint64_t)(present ? 1 : 0) << 48);
-            auto it = m_pass_cache.find(key);
-            if (it != m_pass_cache.end()) return it->second;
-
-            const bool has_depth = depth != VK_FORMAT_UNDEFINED;
-            VkAttachmentDescription atts[2]{};
-            atts[0].format = color; atts[0].samples = VK_SAMPLE_COUNT_1_BIT;
-            atts[0].loadOp = VK_ATTACHMENT_LOAD_OP_CLEAR; atts[0].storeOp = VK_ATTACHMENT_STORE_OP_STORE;
-            atts[0].stencilLoadOp = VK_ATTACHMENT_LOAD_OP_DONT_CARE; atts[0].stencilStoreOp = VK_ATTACHMENT_STORE_OP_DONT_CARE;
-            atts[0].initialLayout = VK_IMAGE_LAYOUT_UNDEFINED;
-            atts[0].finalLayout = present ? VK_IMAGE_LAYOUT_PRESENT_SRC_KHR : VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL;
-            atts[1].format = depth; atts[1].samples = VK_SAMPLE_COUNT_1_BIT;
-            atts[1].loadOp = VK_ATTACHMENT_LOAD_OP_CLEAR; atts[1].storeOp = VK_ATTACHMENT_STORE_OP_DONT_CARE;
-            atts[1].stencilLoadOp = VK_ATTACHMENT_LOAD_OP_DONT_CARE; atts[1].stencilStoreOp = VK_ATTACHMENT_STORE_OP_DONT_CARE;
-            atts[1].initialLayout = VK_IMAGE_LAYOUT_UNDEFINED; atts[1].finalLayout = VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL;
-            VkAttachmentReference color_ref{ 0, VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL };
-            VkAttachmentReference depth_ref{ 1, VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL };
-            VkSubpassDescription subpass{}; subpass.pipelineBindPoint = VK_PIPELINE_BIND_POINT_GRAPHICS;
-            subpass.colorAttachmentCount = 1; subpass.pColorAttachments = &color_ref;
-            if (has_depth) subpass.pDepthStencilAttachment = &depth_ref;
-
-            VkSubpassDependency deps[2]{};
-            uint32_t dep_count;
-            if (present)
-            {
-                deps[0].srcSubpass = VK_SUBPASS_EXTERNAL; deps[0].dstSubpass = 0;
-                deps[0].srcStageMask = VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT | VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT;
-                deps[0].dstStageMask = VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT | VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT;
-                deps[0].dstAccessMask = VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT | VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT;
-                dep_count = 1;
-            }
-            else
-            {
-                deps[0].srcSubpass = VK_SUBPASS_EXTERNAL; deps[0].dstSubpass = 0;
-                deps[0].srcStageMask = VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT; deps[0].srcAccessMask = VK_ACCESS_SHADER_READ_BIT;
-                deps[0].dstStageMask = VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT; deps[0].dstAccessMask = VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT;
-                deps[1].srcSubpass = 0; deps[1].dstSubpass = VK_SUBPASS_EXTERNAL;
-                deps[1].srcStageMask = VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT; deps[1].srcAccessMask = VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT;
-                deps[1].dstStageMask = VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT; deps[1].dstAccessMask = VK_ACCESS_SHADER_READ_BIT;
-                dep_count = 2;
-            }
-
-            VkRenderPassCreateInfo rpci{ VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO };
-            rpci.attachmentCount = has_depth ? 2 : 1; rpci.pAttachments = atts;
-            rpci.subpassCount = 1; rpci.pSubpasses = &subpass;
-            rpci.dependencyCount = dep_count; rpci.pDependencies = deps;
-            VkRenderPass rp = VK_NULL_HANDLE;
-            if (vkCreateRenderPass(m_device, &rpci, nullptr, &rp) != VK_SUCCESS)
-            { DONUT_ERROR("Vulkan RHI: render pass creation failed"); return VK_NULL_HANDLE; }
-            m_pass_cache[key] = rp;
-            return rp;
-        }
-
-        auto VulkanDevice::create_depth_and_framebuffers() -> bool
-        {
-            VkImageCreateInfo dici{ VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO };
-            dici.imageType = VK_IMAGE_TYPE_2D; dici.format = VK_FORMAT_D32_SFLOAT;
-            dici.extent = { m_extent.width, m_extent.height, 1 };
-            dici.mipLevels = 1; dici.arrayLayers = 1; dici.samples = VK_SAMPLE_COUNT_1_BIT;
-            dici.tiling = VK_IMAGE_TILING_OPTIMAL; dici.usage = VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT;
-            VKD_CHECK(vkCreateImage(m_device, &dici, nullptr, &m_depth_image));
-            VkMemoryRequirements dreq{}; vkGetImageMemoryRequirements(m_device, m_depth_image, &dreq);
-            VkMemoryAllocateInfo dai{ VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO };
-            dai.allocationSize = dreq.size; dai.memoryTypeIndex = find_memory_type(dreq.memoryTypeBits, VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT);
-            VKD_CHECK(vkAllocateMemory(m_device, &dai, nullptr, &m_depth_mem));
-            VKD_CHECK(vkBindImageMemory(m_device, m_depth_image, m_depth_mem, 0));
-            VkImageViewCreateInfo dvci{ VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO };
-            dvci.image = m_depth_image; dvci.viewType = VK_IMAGE_VIEW_TYPE_2D; dvci.format = VK_FORMAT_D32_SFLOAT;
-            dvci.subresourceRange = { VK_IMAGE_ASPECT_DEPTH_BIT, 0, 1, 0, 1 };
-            VKD_CHECK(vkCreateImageView(m_device, &dvci, nullptr, &m_depth_view));
-
-            m_framebuffers.resize(m_image_views.size());
-            for (size_t i = 0; i < m_image_views.size(); ++i)
-            {
-                VkImageView att[2] = { m_image_views[i], m_depth_view };
-                VkFramebufferCreateInfo fbci{ VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO };
-                fbci.renderPass = m_swapchain_rp; fbci.attachmentCount = 2; fbci.pAttachments = att;
-                fbci.width = m_extent.width; fbci.height = m_extent.height; fbci.layers = 1;
-                VKD_CHECK(vkCreateFramebuffer(m_device, &fbci, nullptr, &m_framebuffers[i]));
-            }
-            return true;
-        }
-
-        auto VulkanDevice::create_command_and_sync() -> bool
-        {
-            VkCommandPoolCreateInfo pci{ VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO };
-            pci.flags = VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT; pci.queueFamilyIndex = m_graphics_family;
-            VKD_CHECK(vkCreateCommandPool(m_device, &pci, nullptr, &m_command_pool));
-            m_command_buffers.resize(MAX_FRAMES_IN_FLIGHT);
-            VkCommandBufferAllocateInfo cbai{ VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO };
-            cbai.commandPool = m_command_pool; cbai.level = VK_COMMAND_BUFFER_LEVEL_PRIMARY; cbai.commandBufferCount = MAX_FRAMES_IN_FLIGHT;
-            VKD_CHECK(vkAllocateCommandBuffers(m_device, &cbai, m_command_buffers.data()));
-
-            m_image_available.resize(MAX_FRAMES_IN_FLIGHT);
-            m_in_flight.resize(MAX_FRAMES_IN_FLIGHT);
-            m_render_finished.resize(m_images.size());
-            m_images_in_flight.assign(m_images.size(), VK_NULL_HANDLE);
-            VkSemaphoreCreateInfo sci{ VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO };
-            VkFenceCreateInfo fci{ VK_STRUCTURE_TYPE_FENCE_CREATE_INFO }; fci.flags = VK_FENCE_CREATE_SIGNALED_BIT;
-            for (int i = 0; i < MAX_FRAMES_IN_FLIGHT; ++i)
-            { VKD_CHECK(vkCreateSemaphore(m_device, &sci, nullptr, &m_image_available[i])); VKD_CHECK(vkCreateFence(m_device, &fci, nullptr, &m_in_flight[i])); }
-            for (size_t i = 0; i < m_images.size(); ++i)
-                VKD_CHECK(vkCreateSemaphore(m_device, &sci, nullptr, &m_render_finished[i]));
-
-            m_frame_pools.resize(MAX_FRAMES_IN_FLIGHT);
-            VkDescriptorPoolSize sizes[2] = {
-                { VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, 512 },
-                { VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, 256 },
-            };
-            for (int i = 0; i < MAX_FRAMES_IN_FLIGHT; ++i)
-            {
-                VkDescriptorPoolCreateInfo dpci{ VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO };
-                dpci.maxSets = 256; dpci.poolSizeCount = 2; dpci.pPoolSizes = sizes;
-                VKD_CHECK(vkCreateDescriptorPool(m_device, &dpci, nullptr, &m_frame_pools[i]));
-            }
-            return true;
-        }
-
-        auto VulkanDevice::init(const NativeWindow& window) -> bool
-        {
-            m_window = (GLFWwindow*)window.glfw_handle; m_width = window.width; m_height = window.height;
-            if (!create_instance())              return false;
-            if (!pick_physical_and_device())     return false;
-            if (!create_swapchain())             return false;
-            if (!create_image_views())           return false;
-            // The swapchain is a "present" target: its colour format + a D32 depth.
-            m_swapchain_rp = get_render_pass(m_swapchain_format, VK_FORMAT_D32_SFLOAT, true);
-            if (!m_swapchain_rp)                 return false;
-            if (!create_depth_and_framebuffers())return false;
-            if (!create_command_and_sync())      return false;
-            DONUT_INFO("Vulkan RHI device ready: {} swapchain images, {}x{}", (int)m_images.size(), m_extent.width, m_extent.height);
-            return true;
-        }
-
-        auto VulkanDevice::cleanup_swapchain() -> void
-        {
-            for (auto fb : m_framebuffers) vkDestroyFramebuffer(m_device, fb, nullptr);
-            m_framebuffers.clear();
-            if (m_depth_view)  { vkDestroyImageView(m_device, m_depth_view, nullptr); m_depth_view = VK_NULL_HANDLE; }
-            if (m_depth_image) { vkDestroyImage(m_device, m_depth_image, nullptr); m_depth_image = VK_NULL_HANDLE; }
-            if (m_depth_mem)   { vkFreeMemory(m_device, m_depth_mem, nullptr); m_depth_mem = VK_NULL_HANDLE; }
-            for (auto iv : m_image_views) vkDestroyImageView(m_device, iv, nullptr);
-            m_image_views.clear();
-            if (m_swapchain) { vkDestroySwapchainKHR(m_device, m_swapchain, nullptr); m_swapchain = VK_NULL_HANDLE; }
-        }
-
-        auto VulkanDevice::recreate_swapchain() -> bool
-        {
-            int w = 0, h = 0; glfwGetFramebufferSize(m_window, &w, &h);
-            while (w == 0 || h == 0) { glfwGetFramebufferSize(m_window, &w, &h); glfwWaitEvents(); }
-            m_width = w; m_height = h;
-            vkDeviceWaitIdle(m_device);
-            cleanup_swapchain();
-            if (!create_swapchain())             return false;
-            if (!create_image_views())           return false;
-            if (!create_depth_and_framebuffers())return false;
-            m_images_in_flight.assign(m_images.size(), VK_NULL_HANDLE);
-            return true;
-        }
-
-        auto VulkanDevice::create_buffer(BufferType type, size_t size, const void* data) -> Ref<Buffer>
-        {
-            VkBufferUsageFlags usage = type == BufferType::Index ? VK_BUFFER_USAGE_INDEX_BUFFER_BIT
-                                     : type == BufferType::Uniform ? VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT
-                                     : VK_BUFFER_USAGE_VERTEX_BUFFER_BIT;
-            VkBuffer buf = VK_NULL_HANDLE; VkDeviceMemory mem = VK_NULL_HANDLE;
-            create_buffer_raw(size, usage, VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT, buf, mem);
-            void* mapped = nullptr; vkMapMemory(m_device, mem, 0, size, 0, &mapped);
-            if (data && mapped) std::memcpy(mapped, data, size);
-            return create_ref<VkBufferR>(m_device, buf, mem, mapped, size);
-        }
-
-        auto VulkanDevice::create_texture(int w, int h, Format format, Filter filter, const void* data) -> Ref<Texture>
-        {
-            auto tex = create_ref<VkTextureR>(); tex->m_device = m_device;
-            VkFormat fmt = vk_format(format);
-            VkImageCreateInfo ici{ VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO };
-            ici.imageType = VK_IMAGE_TYPE_2D; ici.format = fmt; ici.extent = { (uint32_t)w, (uint32_t)h, 1 };
-            ici.mipLevels = 1; ici.arrayLayers = 1; ici.samples = VK_SAMPLE_COUNT_1_BIT;
-            ici.tiling = VK_IMAGE_TILING_OPTIMAL; ici.usage = VK_IMAGE_USAGE_TRANSFER_DST_BIT | VK_IMAGE_USAGE_SAMPLED_BIT;
-            vkCreateImage(m_device, &ici, nullptr, &tex->m_image);
-            VkMemoryRequirements req{}; vkGetImageMemoryRequirements(m_device, tex->m_image, &req);
-            VkMemoryAllocateInfo ai{ VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO };
-            ai.allocationSize = req.size; ai.memoryTypeIndex = find_memory_type(req.memoryTypeBits, VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT);
-            vkAllocateMemory(m_device, &ai, nullptr, &tex->m_mem);
-            vkBindImageMemory(m_device, tex->m_image, tex->m_mem, 0);
-
-            size_t bpp = format == Format::RGBA16F ? 8 : 4;
-            VkDeviceSize sz = (VkDeviceSize)w * h * bpp;
-            VkBuffer staging = VK_NULL_HANDLE; VkDeviceMemory staging_mem = VK_NULL_HANDLE;
-            create_buffer_raw(sz, VK_BUFFER_USAGE_TRANSFER_SRC_BIT, VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT, staging, staging_mem);
-            void* mp = nullptr; vkMapMemory(m_device, staging_mem, 0, sz, 0, &mp);
-            if (data) std::memcpy(mp, data, sz); else std::memset(mp, 0, sz);
-            vkUnmapMemory(m_device, staging_mem);
-
-            VkCommandBufferAllocateInfo cbai{ VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO };
-            cbai.commandPool = m_command_pool; cbai.level = VK_COMMAND_BUFFER_LEVEL_PRIMARY; cbai.commandBufferCount = 1;
-            VkCommandBuffer cmd; vkAllocateCommandBuffers(m_device, &cbai, &cmd);
-            VkCommandBufferBeginInfo bi{ VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO }; bi.flags = VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT;
-            vkBeginCommandBuffer(cmd, &bi);
-            VkImageMemoryBarrier b{ VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER };
-            b.oldLayout = VK_IMAGE_LAYOUT_UNDEFINED; b.newLayout = VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL;
-            b.image = tex->m_image; b.subresourceRange = { VK_IMAGE_ASPECT_COLOR_BIT, 0, 1, 0, 1 };
-            b.srcAccessMask = 0; b.dstAccessMask = VK_ACCESS_TRANSFER_WRITE_BIT;
-            vkCmdPipelineBarrier(cmd, VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT, 0, 0, nullptr, 0, nullptr, 1, &b);
-            VkBufferImageCopy copy{}; copy.imageSubresource = { VK_IMAGE_ASPECT_COLOR_BIT, 0, 0, 1 }; copy.imageExtent = { (uint32_t)w, (uint32_t)h, 1 };
-            vkCmdCopyBufferToImage(cmd, staging, tex->m_image, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, 1, &copy);
-            VkImageMemoryBarrier r = b; r.oldLayout = VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL; r.newLayout = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL;
-            r.srcAccessMask = VK_ACCESS_TRANSFER_WRITE_BIT; r.dstAccessMask = VK_ACCESS_SHADER_READ_BIT;
-            vkCmdPipelineBarrier(cmd, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT, 0, 0, nullptr, 0, nullptr, 1, &r);
-            vkEndCommandBuffer(cmd);
-            VkSubmitInfo si{ VK_STRUCTURE_TYPE_SUBMIT_INFO }; si.commandBufferCount = 1; si.pCommandBuffers = &cmd;
-            vkQueueSubmit(m_graphics_queue, 1, &si, VK_NULL_HANDLE); vkQueueWaitIdle(m_graphics_queue);
-            vkFreeCommandBuffers(m_device, m_command_pool, 1, &cmd);
-            vkDestroyBuffer(m_device, staging, nullptr); vkFreeMemory(m_device, staging_mem, nullptr);
-
-            VkImageViewCreateInfo vci{ VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO };
-            vci.image = tex->m_image; vci.viewType = VK_IMAGE_VIEW_TYPE_2D; vci.format = fmt;
-            vci.subresourceRange = { VK_IMAGE_ASPECT_COLOR_BIT, 0, 1, 0, 1 };
-            vkCreateImageView(m_device, &vci, nullptr, &tex->m_view);
-            VkSamplerCreateInfo smci{ VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO };
-            smci.magFilter = vk_filter(filter); smci.minFilter = vk_filter(filter);
-            smci.addressModeU = smci.addressModeV = smci.addressModeW = VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE;
-            vkCreateSampler(m_device, &smci, nullptr, &tex->m_sampler);
-            return tex;
-        }
-
-        auto VulkanDevice::create_render_target(int w, int h, Format color, Format depth, Filter filter, int /*mips*/) -> Ref<RenderTarget>
-        {
-            auto rt = create_ref<VkRenderTargetR>();
-            rt->m_device = m_device; rt->m_w = w; rt->m_h = h;
-            VkFormat cfmt = (color == Format::Swapchain) ? m_swapchain_format : vk_format(color);
-            VkImageCreateInfo ici{ VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO };
-            ici.imageType = VK_IMAGE_TYPE_2D; ici.format = cfmt; ici.extent = { (uint32_t)w, (uint32_t)h, 1 };
-            ici.mipLevels = 1; ici.arrayLayers = 1; ici.samples = VK_SAMPLE_COUNT_1_BIT;
-            ici.tiling = VK_IMAGE_TILING_OPTIMAL; ici.usage = VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT | VK_IMAGE_USAGE_SAMPLED_BIT;
-            vkCreateImage(m_device, &ici, nullptr, &rt->m_image);
-            VkMemoryRequirements req{}; vkGetImageMemoryRequirements(m_device, rt->m_image, &req);
-            VkMemoryAllocateInfo ai{ VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO };
-            ai.allocationSize = req.size; ai.memoryTypeIndex = find_memory_type(req.memoryTypeBits, VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT);
-            vkAllocateMemory(m_device, &ai, nullptr, &rt->m_mem);
-            vkBindImageMemory(m_device, rt->m_image, rt->m_mem, 0);
-            VkImageViewCreateInfo vci{ VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO };
-            vci.image = rt->m_image; vci.viewType = VK_IMAGE_VIEW_TYPE_2D; vci.format = cfmt;
-            vci.subresourceRange = { VK_IMAGE_ASPECT_COLOR_BIT, 0, 1, 0, 1 };
-            vkCreateImageView(m_device, &vci, nullptr, &rt->m_view);
-            VkSamplerCreateInfo smci{ VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO };
-            smci.magFilter = vk_filter(filter); smci.minFilter = vk_filter(filter);
-            smci.addressModeU = smci.addressModeV = smci.addressModeW = VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE;
-            vkCreateSampler(m_device, &smci, nullptr, &rt->m_sampler);
-
-            // Optional depth attachment (for off-screen passes that need a depth test).
-            rt->m_has_depth = depth != Format::None;
-            VkFormat dfmt = VK_FORMAT_UNDEFINED;
-            if (rt->m_has_depth)
-            {
-                dfmt = vk_format(depth);
-                VkImageCreateInfo dici{ VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO };
-                dici.imageType = VK_IMAGE_TYPE_2D; dici.format = dfmt; dici.extent = { (uint32_t)w, (uint32_t)h, 1 };
-                dici.mipLevels = 1; dici.arrayLayers = 1; dici.samples = VK_SAMPLE_COUNT_1_BIT;
-                dici.tiling = VK_IMAGE_TILING_OPTIMAL; dici.usage = VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT;
-                vkCreateImage(m_device, &dici, nullptr, &rt->m_depth_image);
-                VkMemoryRequirements dreq{}; vkGetImageMemoryRequirements(m_device, rt->m_depth_image, &dreq);
-                VkMemoryAllocateInfo dai{ VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO };
-                dai.allocationSize = dreq.size; dai.memoryTypeIndex = find_memory_type(dreq.memoryTypeBits, VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT);
-                vkAllocateMemory(m_device, &dai, nullptr, &rt->m_depth_mem);
-                vkBindImageMemory(m_device, rt->m_depth_image, rt->m_depth_mem, 0);
-                VkImageViewCreateInfo dvci{ VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO };
-                dvci.image = rt->m_depth_image; dvci.viewType = VK_IMAGE_VIEW_TYPE_2D; dvci.format = dfmt;
-                dvci.subresourceRange = { VK_IMAGE_ASPECT_DEPTH_BIT, 0, 1, 0, 1 };
-                vkCreateImageView(m_device, &dvci, nullptr, &rt->m_depth_view);
-            }
-
-            rt->m_pass = get_render_pass(cfmt, dfmt, false);   // off-screen (sampled) target
-            VkImageView atts[2] = { rt->m_view, rt->m_depth_view };
-            VkFramebufferCreateInfo fbci{ VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO };
-            fbci.renderPass = rt->m_pass; fbci.attachmentCount = rt->m_has_depth ? 2u : 1u; fbci.pAttachments = atts;
-            fbci.width = w; fbci.height = h; fbci.layers = 1;
-            vkCreateFramebuffer(m_device, &fbci, nullptr, &rt->m_fb);
-
-            rt->m_color.m_device = m_device; rt->m_color.m_view = rt->m_view; rt->m_color.m_sampler = rt->m_sampler; rt->m_color.m_owns = false;
-            return rt;
-        }
-
-        // Builds an environment cubemap from an equirectangular HDRI: render the 6
-        // faces with the EquirectToCubemap pipeline, then a full mip chain by
-        // linear down-blits (so divergence-based LOD reads a blurred sky). Returns
-        // a Texture owning the cube image/view/sampler.
-        auto VulkanDevice::create_cubemap_from_hdri(const std::string& path) -> Ref<Texture>
-        {
-            auto tex = create_ref<VkTextureR>(); tex->m_device = m_device;
-            const VkMemoryPropertyFlags host_vis = VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT;
-            const uint32_t FACE = 1024;
-            const VkFormat cube_fmt = VK_FORMAT_R16G16B16A16_SFLOAT;
-            uint32_t CUBE_MIPS = 1; for (uint32_t s = FACE; s > 1; s >>= 1) ++CUBE_MIPS;
-
-            VkImageCreateInfo cci{ VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO };
-            cci.flags = VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT;
-            cci.imageType = VK_IMAGE_TYPE_2D; cci.format = cube_fmt; cci.extent = { FACE, FACE, 1 };
-            cci.mipLevels = CUBE_MIPS; cci.arrayLayers = 6; cci.samples = VK_SAMPLE_COUNT_1_BIT;
-            cci.tiling = VK_IMAGE_TILING_OPTIMAL;
-            cci.usage = VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT | VK_IMAGE_USAGE_SAMPLED_BIT
-                      | VK_IMAGE_USAGE_TRANSFER_SRC_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT;
-            vkCreateImage(m_device, &cci, nullptr, &tex->m_image);
-            VkMemoryRequirements creq{}; vkGetImageMemoryRequirements(m_device, tex->m_image, &creq);
-            VkMemoryAllocateInfo cai{ VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO };
-            cai.allocationSize = creq.size; cai.memoryTypeIndex = find_memory_type(creq.memoryTypeBits, VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT);
-            vkAllocateMemory(m_device, &cai, nullptr, &tex->m_mem);
-            vkBindImageMemory(m_device, tex->m_image, tex->m_mem, 0);
-            VkImageViewCreateInfo cvci{ VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO };
-            cvci.image = tex->m_image; cvci.viewType = VK_IMAGE_VIEW_TYPE_CUBE; cvci.format = cube_fmt;
-            cvci.subresourceRange = { VK_IMAGE_ASPECT_COLOR_BIT, 0, CUBE_MIPS, 0, 6 };
-            vkCreateImageView(m_device, &cvci, nullptr, &tex->m_view);
-            VkSamplerCreateInfo csm{ VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO };
-            csm.magFilter = VK_FILTER_LINEAR; csm.minFilter = VK_FILTER_LINEAR;
-            csm.mipmapMode = VK_SAMPLER_MIPMAP_MODE_LINEAR; csm.minLod = 0.0f; csm.maxLod = (float)CUBE_MIPS;
-            csm.addressModeU = csm.addressModeV = csm.addressModeW = VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE;
-            vkCreateSampler(m_device, &csm, nullptr, &tex->m_sampler);
-
-            int w = 0, h = 0, ch = 0;
-            float* pixels = stbi_loadf(path.c_str(), &w, &h, &ch, 4);
-            if (!pixels)
-            {
-                DONUT_WARN("Vulkan RHI: HDRI '{}' could not be loaded; using a dark background", path);
-                VkCommandBufferAllocateInfo cbai{ VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO };
-                cbai.commandPool = m_command_pool; cbai.level = VK_COMMAND_BUFFER_LEVEL_PRIMARY; cbai.commandBufferCount = 1;
-                VkCommandBuffer cmd; vkAllocateCommandBuffers(m_device, &cbai, &cmd);
-                VkCommandBufferBeginInfo bi{ VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO }; bi.flags = VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT;
-                vkBeginCommandBuffer(cmd, &bi);
-                VkImageMemoryBarrier tb{ VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER };
-                tb.oldLayout = VK_IMAGE_LAYOUT_UNDEFINED; tb.newLayout = VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL;
-                tb.image = tex->m_image; tb.subresourceRange = { VK_IMAGE_ASPECT_COLOR_BIT, 0, CUBE_MIPS, 0, 6 };
-                tb.srcAccessMask = 0; tb.dstAccessMask = VK_ACCESS_TRANSFER_WRITE_BIT;
-                vkCmdPipelineBarrier(cmd, VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT, 0, 0, nullptr, 0, nullptr, 1, &tb);
-                VkClearColorValue dark{}; dark.float32[0] = 0.02f; dark.float32[1] = 0.02f; dark.float32[2] = 0.05f; dark.float32[3] = 1.0f;
-                VkImageSubresourceRange rng{ VK_IMAGE_ASPECT_COLOR_BIT, 0, CUBE_MIPS, 0, 6 };
-                vkCmdClearColorImage(cmd, tex->m_image, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, &dark, 1, &rng);
-                VkImageMemoryBarrier rb = tb; rb.oldLayout = VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL; rb.newLayout = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL;
-                rb.srcAccessMask = VK_ACCESS_TRANSFER_WRITE_BIT; rb.dstAccessMask = VK_ACCESS_SHADER_READ_BIT;
-                vkCmdPipelineBarrier(cmd, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT, 0, 0, nullptr, 0, nullptr, 1, &rb);
-                vkEndCommandBuffer(cmd);
-                VkSubmitInfo si{ VK_STRUCTURE_TYPE_SUBMIT_INFO }; si.commandBufferCount = 1; si.pCommandBuffers = &cmd;
-                vkQueueSubmit(m_graphics_queue, 1, &si, VK_NULL_HANDLE); vkQueueWaitIdle(m_graphics_queue);
-                vkFreeCommandBuffers(m_device, m_command_pool, 1, &cmd);
-                return tex;
-            }
-
-            const VkFormat eq_fmt = VK_FORMAT_R16G16B16A16_SFLOAT;
-            size_t texel_count = (size_t)w * h * 4;
-            VkDeviceSize eq_size = (VkDeviceSize)texel_count * sizeof(uint16_t);
-            VkBuffer eq_staging; VkDeviceMemory eq_staging_mem;
-            create_buffer_raw(eq_size, VK_BUFFER_USAGE_TRANSFER_SRC_BIT, host_vis, eq_staging, eq_staging_mem);
-            void* mp = nullptr; vkMapMemory(m_device, eq_staging_mem, 0, eq_size, 0, &mp);
-            uint16_t* dst = (uint16_t*)mp;
-            for (size_t i = 0; i < texel_count; ++i) { __fp16 hf = (__fp16)pixels[i]; std::memcpy(&dst[i], &hf, sizeof(uint16_t)); }
-            vkUnmapMemory(m_device, eq_staging_mem);
-            stbi_image_free(pixels);
-
-            VkImage eq_image; VkDeviceMemory eq_mem;
-            VkImageCreateInfo eci{ VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO };
-            eci.imageType = VK_IMAGE_TYPE_2D; eci.format = eq_fmt; eci.extent = { (uint32_t)w, (uint32_t)h, 1 };
-            eci.mipLevels = 1; eci.arrayLayers = 1; eci.samples = VK_SAMPLE_COUNT_1_BIT;
-            eci.tiling = VK_IMAGE_TILING_OPTIMAL; eci.usage = VK_IMAGE_USAGE_TRANSFER_DST_BIT | VK_IMAGE_USAGE_SAMPLED_BIT;
-            vkCreateImage(m_device, &eci, nullptr, &eq_image);
-            VkMemoryRequirements ereq{}; vkGetImageMemoryRequirements(m_device, eq_image, &ereq);
-            VkMemoryAllocateInfo eai{ VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO };
-            eai.allocationSize = ereq.size; eai.memoryTypeIndex = find_memory_type(ereq.memoryTypeBits, VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT);
-            vkAllocateMemory(m_device, &eai, nullptr, &eq_mem);
-            vkBindImageMemory(m_device, eq_image, eq_mem, 0);
-            VkImageView eq_view;
-            VkImageViewCreateInfo evci{ VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO };
-            evci.image = eq_image; evci.viewType = VK_IMAGE_VIEW_TYPE_2D; evci.format = eq_fmt;
-            evci.subresourceRange = { VK_IMAGE_ASPECT_COLOR_BIT, 0, 1, 0, 1 };
-            vkCreateImageView(m_device, &evci, nullptr, &eq_view);
-            VkSampler eq_sampler;
-            VkSamplerCreateInfo esm{ VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO };
-            esm.magFilter = VK_FILTER_LINEAR; esm.minFilter = VK_FILTER_LINEAR;
-            esm.addressModeU = VK_SAMPLER_ADDRESS_MODE_REPEAT;
-            esm.addressModeV = VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE;
-            esm.addressModeW = VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE;
-            vkCreateSampler(m_device, &esm, nullptr, &eq_sampler);
-
-            VkImageView face_views[6];
-            for (uint32_t i = 0; i < 6; ++i)
-            {
-                VkImageViewCreateInfo fvci{ VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO };
-                fvci.image = tex->m_image; fvci.viewType = VK_IMAGE_VIEW_TYPE_2D; fvci.format = cube_fmt;
-                fvci.subresourceRange = { VK_IMAGE_ASPECT_COLOR_BIT, 0, 1, i, 1 };
-                vkCreateImageView(m_device, &fvci, nullptr, &face_views[i]);
-            }
-
-            VkAttachmentDescription color{};
-            color.format = cube_fmt; color.samples = VK_SAMPLE_COUNT_1_BIT;
-            color.loadOp = VK_ATTACHMENT_LOAD_OP_CLEAR; color.storeOp = VK_ATTACHMENT_STORE_OP_STORE;
-            color.stencilLoadOp = VK_ATTACHMENT_LOAD_OP_DONT_CARE; color.stencilStoreOp = VK_ATTACHMENT_STORE_OP_DONT_CARE;
-            color.initialLayout = VK_IMAGE_LAYOUT_UNDEFINED; color.finalLayout = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL;
-            VkAttachmentReference ref{ 0, VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL };
-            VkSubpassDescription subpass{}; subpass.pipelineBindPoint = VK_PIPELINE_BIND_POINT_GRAPHICS; subpass.colorAttachmentCount = 1; subpass.pColorAttachments = &ref;
-            VkSubpassDependency dep{}; dep.srcSubpass = 0; dep.dstSubpass = VK_SUBPASS_EXTERNAL;
-            dep.srcStageMask = VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT; dep.srcAccessMask = VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT;
-            dep.dstStageMask = VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT; dep.dstAccessMask = VK_ACCESS_SHADER_READ_BIT;
-            VkRenderPass rp;
-            VkRenderPassCreateInfo rpci{ VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO };
-            rpci.attachmentCount = 1; rpci.pAttachments = &color; rpci.subpassCount = 1; rpci.pSubpasses = &subpass; rpci.dependencyCount = 1; rpci.pDependencies = &dep;
-            vkCreateRenderPass(m_device, &rpci, nullptr, &rp);
-            VkFramebuffer face_fb[6];
-            for (uint32_t i = 0; i < 6; ++i)
-            {
-                VkFramebufferCreateInfo fbci{ VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO };
-                fbci.renderPass = rp; fbci.attachmentCount = 1; fbci.pAttachments = &face_views[i]; fbci.width = FACE; fbci.height = FACE; fbci.layers = 1;
-                vkCreateFramebuffer(m_device, &fbci, nullptr, &face_fb[i]);
-            }
-
-            VkDescriptorSetLayoutBinding binds[2]{};
-            binds[0].binding = 0; binds[0].descriptorType = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER; binds[0].descriptorCount = 1; binds[0].stageFlags = VK_SHADER_STAGE_VERTEX_BIT;
-            binds[1].binding = 1; binds[1].descriptorType = VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER; binds[1].descriptorCount = 1; binds[1].stageFlags = VK_SHADER_STAGE_FRAGMENT_BIT;
-            VkDescriptorSetLayout set_layout;
-            VkDescriptorSetLayoutCreateInfo dslci{ VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO }; dslci.bindingCount = 2; dslci.pBindings = binds;
-            vkCreateDescriptorSetLayout(m_device, &dslci, nullptr, &set_layout);
-            VkDescriptorPoolSize psizes[2] = { { VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, 6 }, { VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, 6 } };
-            VkDescriptorPool pool;
-            VkDescriptorPoolCreateInfo dpci{ VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO }; dpci.maxSets = 6; dpci.poolSizeCount = 2; dpci.pPoolSizes = psizes;
-            vkCreateDescriptorPool(m_device, &dpci, nullptr, &pool);
-
-            VkShaderModule vmod, fmod;
-            create_shader_module("assets/shaders/generated/equirect_to_cubemap.vertexMain.spv", vmod);
-            create_shader_module("assets/shaders/generated/equirect_to_cubemap.fragmentMain.spv", fmod);
-            VkPipelineLayout playout;
-            VkPipelineLayoutCreateInfo plci{ VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO }; plci.setLayoutCount = 1; plci.pSetLayouts = &set_layout;
-            vkCreatePipelineLayout(m_device, &plci, nullptr, &playout);
-            VkPipelineShaderStageCreateInfo stages[2]{};
-            stages[0].sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO; stages[0].stage = VK_SHADER_STAGE_VERTEX_BIT;   stages[0].module = vmod; stages[0].pName = "main";
-            stages[1].sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO; stages[1].stage = VK_SHADER_STAGE_FRAGMENT_BIT; stages[1].module = fmod; stages[1].pName = "main";
-            VkVertexInputBindingDescription vib{ 0, 12, VK_VERTEX_INPUT_RATE_VERTEX };
-            VkVertexInputAttributeDescription via{ 0, 0, VK_FORMAT_R32G32B32_SFLOAT, 0 };
-            VkPipelineVertexInputStateCreateInfo vin{ VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO };
-            vin.vertexBindingDescriptionCount = 1; vin.pVertexBindingDescriptions = &vib; vin.vertexAttributeDescriptionCount = 1; vin.pVertexAttributeDescriptions = &via;
-            VkPipelineInputAssemblyStateCreateInfo ia{ VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO }; ia.topology = VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST;
-            VkViewport vp{ 0, 0, (float)FACE, (float)FACE, 0, 1 }; VkRect2D sc{ { 0, 0 }, { FACE, FACE } };
-            VkPipelineViewportStateCreateInfo vps{ VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO }; vps.viewportCount = 1; vps.pViewports = &vp; vps.scissorCount = 1; vps.pScissors = &sc;
-            VkPipelineRasterizationStateCreateInfo rs{ VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO }; rs.polygonMode = VK_POLYGON_MODE_FILL; rs.cullMode = VK_CULL_MODE_NONE; rs.frontFace = VK_FRONT_FACE_COUNTER_CLOCKWISE; rs.lineWidth = 1.0f;
-            VkPipelineMultisampleStateCreateInfo ms{ VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO }; ms.rasterizationSamples = VK_SAMPLE_COUNT_1_BIT;
-            VkPipelineColorBlendAttachmentState cba{}; cba.colorWriteMask = VK_COLOR_COMPONENT_R_BIT | VK_COLOR_COMPONENT_G_BIT | VK_COLOR_COMPONENT_B_BIT | VK_COLOR_COMPONENT_A_BIT;
-            VkPipelineColorBlendStateCreateInfo cb{ VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO }; cb.attachmentCount = 1; cb.pAttachments = &cba;
-            VkPipeline pipeline;
-            VkGraphicsPipelineCreateInfo gpci{ VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO };
-            gpci.stageCount = 2; gpci.pStages = stages; gpci.pVertexInputState = &vin; gpci.pInputAssemblyState = &ia; gpci.pViewportState = &vps;
-            gpci.pRasterizationState = &rs; gpci.pMultisampleState = &ms; gpci.pColorBlendState = &cb; gpci.layout = playout; gpci.renderPass = rp; gpci.subpass = 0;
-            vkCreateGraphicsPipelines(m_device, VK_NULL_HANDLE, 1, &gpci, nullptr, &pipeline);
-            vkDestroyShaderModule(m_device, vmod, nullptr); vkDestroyShaderModule(m_device, fmod, nullptr);
-
-            float cube_verts[] = {
-                -1,1,-1, -1,-1,-1, 1,-1,-1, 1,-1,-1, 1,1,-1, -1,1,-1,
-                -1,-1,1, -1,-1,-1, -1,1,-1, -1,1,-1, -1,1,1, -1,-1,1,
-                 1,-1,-1, 1,-1,1, 1,1,1, 1,1,1, 1,1,-1, 1,-1,-1,
-                -1,-1,1, -1,1,1, 1,1,1, 1,1,1, 1,-1,1, -1,-1,1,
-                -1,1,-1, 1,1,-1, 1,1,1, 1,1,1, -1,1,1, -1,1,-1,
-                -1,-1,-1, -1,-1,1, 1,-1,-1, 1,-1,-1, -1,-1,1, 1,-1,1,
-            };
-            VkBuffer cube_vb; VkDeviceMemory cube_vb_mem;
-            create_buffer_raw(sizeof(cube_verts), VK_BUFFER_USAGE_VERTEX_BUFFER_BIT, host_vis, cube_vb, cube_vb_mem);
-            vkMapMemory(m_device, cube_vb_mem, 0, sizeof(cube_verts), 0, &mp); std::memcpy(mp, cube_verts, sizeof(cube_verts)); vkUnmapMemory(m_device, cube_vb_mem);
-
-            glm::mat4 proj = glm::perspective(glm::radians(90.0f), 1.0f, 0.1f, 10.0f);
-            proj[1][1] *= -1.0f;
-            glm::mat4 views[6] = {
-                glm::lookAt(glm::vec3(0), glm::vec3( 1, 0, 0), glm::vec3(0, -1, 0)),
-                glm::lookAt(glm::vec3(0), glm::vec3(-1, 0, 0), glm::vec3(0, -1, 0)),
-                glm::lookAt(glm::vec3(0), glm::vec3( 0, 1, 0), glm::vec3(0, 0, 1)),
-                glm::lookAt(glm::vec3(0), glm::vec3( 0, -1, 0), glm::vec3(0, 0, -1)),
-                glm::lookAt(glm::vec3(0), glm::vec3( 0, 0, 1), glm::vec3(0, -1, 0)),
-                glm::lookAt(glm::vec3(0), glm::vec3( 0, 0, -1), glm::vec3(0, -1, 0)),
-            };
-            VkBuffer ubo[6]; VkDeviceMemory ubo_mem[6]; VkDescriptorSet sets[6];
-            for (uint32_t i = 0; i < 6; ++i)
-            {
-                create_buffer_raw(128, VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT, host_vis, ubo[i], ubo_mem[i]);
-                glm::mat4 mats[2] = { glm::transpose(proj), glm::transpose(views[i]) };
-                vkMapMemory(m_device, ubo_mem[i], 0, 128, 0, &mp); std::memcpy(mp, mats, 128); vkUnmapMemory(m_device, ubo_mem[i]);
-                VkDescriptorSetAllocateInfo dsai{ VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO }; dsai.descriptorPool = pool; dsai.descriptorSetCount = 1; dsai.pSetLayouts = &set_layout;
-                vkAllocateDescriptorSets(m_device, &dsai, &sets[i]);
-                VkDescriptorBufferInfo buf_info{ ubo[i], 0, VK_WHOLE_SIZE };
-                VkDescriptorImageInfo img_info{ eq_sampler, eq_view, VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL };
-                VkWriteDescriptorSet ws[2]{};
-                ws[0].sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET; ws[0].dstSet = sets[i]; ws[0].dstBinding = 0; ws[0].descriptorCount = 1; ws[0].descriptorType = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER; ws[0].pBufferInfo = &buf_info;
-                ws[1].sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET; ws[1].dstSet = sets[i]; ws[1].dstBinding = 1; ws[1].descriptorCount = 1; ws[1].descriptorType = VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER; ws[1].pImageInfo = &img_info;
-                vkUpdateDescriptorSets(m_device, 2, ws, 0, nullptr);
-            }
-
-            VkCommandBufferAllocateInfo cbai{ VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO };
-            cbai.commandPool = m_command_pool; cbai.level = VK_COMMAND_BUFFER_LEVEL_PRIMARY; cbai.commandBufferCount = 1;
-            VkCommandBuffer cmd; vkAllocateCommandBuffers(m_device, &cbai, &cmd);
-            VkCommandBufferBeginInfo bi{ VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO }; bi.flags = VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT;
-            vkBeginCommandBuffer(cmd, &bi);
-            VkImageMemoryBarrier to_dst{ VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER };
-            to_dst.oldLayout = VK_IMAGE_LAYOUT_UNDEFINED; to_dst.newLayout = VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL;
-            to_dst.image = eq_image; to_dst.subresourceRange = { VK_IMAGE_ASPECT_COLOR_BIT, 0, 1, 0, 1 };
-            to_dst.srcAccessMask = 0; to_dst.dstAccessMask = VK_ACCESS_TRANSFER_WRITE_BIT;
-            vkCmdPipelineBarrier(cmd, VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT, 0, 0, nullptr, 0, nullptr, 1, &to_dst);
-            VkBufferImageCopy copy{}; copy.imageSubresource = { VK_IMAGE_ASPECT_COLOR_BIT, 0, 0, 1 }; copy.imageExtent = { (uint32_t)w, (uint32_t)h, 1 };
-            vkCmdCopyBufferToImage(cmd, eq_staging, eq_image, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, 1, &copy);
-            VkImageMemoryBarrier to_read = to_dst; to_read.oldLayout = VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL; to_read.newLayout = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL;
-            to_read.srcAccessMask = VK_ACCESS_TRANSFER_WRITE_BIT; to_read.dstAccessMask = VK_ACCESS_SHADER_READ_BIT;
-            vkCmdPipelineBarrier(cmd, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT, 0, 0, nullptr, 0, nullptr, 1, &to_read);
-
-            VkClearValue clear{}; clear.color = { { 0, 0, 0, 1 } };
-            for (uint32_t i = 0; i < 6; ++i)
-            {
-                VkRenderPassBeginInfo rpbi{ VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO };
-                rpbi.renderPass = rp; rpbi.framebuffer = face_fb[i]; rpbi.renderArea = { { 0, 0 }, { FACE, FACE } }; rpbi.clearValueCount = 1; rpbi.pClearValues = &clear;
-                vkCmdBeginRenderPass(cmd, &rpbi, VK_SUBPASS_CONTENTS_INLINE);
-                vkCmdBindPipeline(cmd, VK_PIPELINE_BIND_POINT_GRAPHICS, pipeline);
-                vkCmdBindDescriptorSets(cmd, VK_PIPELINE_BIND_POINT_GRAPHICS, playout, 0, 1, &sets[i], 0, nullptr);
-                VkDeviceSize off = 0; vkCmdBindVertexBuffers(cmd, 0, 1, &cube_vb, &off);
-                vkCmdDraw(cmd, 36, 1, 0, 0);
-                vkCmdEndRenderPass(cmd);
-            }
-
-            {
-                VkImageMemoryBarrier src0{ VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER };
-                src0.image = tex->m_image; src0.subresourceRange = { VK_IMAGE_ASPECT_COLOR_BIT, 0, 1, 0, 6 };
-                src0.oldLayout = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL; src0.newLayout = VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL;
-                src0.srcAccessMask = VK_ACCESS_SHADER_READ_BIT; src0.dstAccessMask = VK_ACCESS_TRANSFER_READ_BIT;
-                vkCmdPipelineBarrier(cmd, VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT, 0, 0, nullptr, 0, nullptr, 1, &src0);
-                int32_t mipW = (int32_t)FACE, mipH = (int32_t)FACE;
-                for (uint32_t m = 1; m < CUBE_MIPS; ++m)
-                {
-                    int32_t nW = mipW > 1 ? mipW / 2 : 1, nH = mipH > 1 ? mipH / 2 : 1;
-                    VkImageMemoryBarrier bd{ VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER };
-                    bd.image = tex->m_image; bd.subresourceRange = { VK_IMAGE_ASPECT_COLOR_BIT, m, 1, 0, 6 };
-                    bd.oldLayout = VK_IMAGE_LAYOUT_UNDEFINED; bd.newLayout = VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL;
-                    bd.srcAccessMask = 0; bd.dstAccessMask = VK_ACCESS_TRANSFER_WRITE_BIT;
-                    vkCmdPipelineBarrier(cmd, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT, 0, 0, nullptr, 0, nullptr, 1, &bd);
-                    VkImageBlit blit{};
-                    blit.srcOffsets[1] = { mipW, mipH, 1 }; blit.srcSubresource = { VK_IMAGE_ASPECT_COLOR_BIT, m - 1, 0, 6 };
-                    blit.dstOffsets[1] = { nW, nH, 1 };     blit.dstSubresource = { VK_IMAGE_ASPECT_COLOR_BIT, m, 0, 6 };
-                    vkCmdBlitImage(cmd, tex->m_image, VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, tex->m_image, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, 1, &blit, VK_FILTER_LINEAR);
-                    VkImageMemoryBarrier bs{ VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER };
-                    bs.image = tex->m_image; bs.subresourceRange = { VK_IMAGE_ASPECT_COLOR_BIT, m, 1, 0, 6 };
-                    bs.oldLayout = VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL; bs.newLayout = VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL;
-                    bs.srcAccessMask = VK_ACCESS_TRANSFER_WRITE_BIT; bs.dstAccessMask = VK_ACCESS_TRANSFER_READ_BIT;
-                    vkCmdPipelineBarrier(cmd, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT, 0, 0, nullptr, 0, nullptr, 1, &bs);
-                    mipW = nW; mipH = nH;
-                }
-                VkImageMemoryBarrier fin{ VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER };
-                fin.image = tex->m_image; fin.subresourceRange = { VK_IMAGE_ASPECT_COLOR_BIT, 0, CUBE_MIPS, 0, 6 };
-                fin.oldLayout = VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL; fin.newLayout = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL;
-                fin.srcAccessMask = VK_ACCESS_TRANSFER_READ_BIT; fin.dstAccessMask = VK_ACCESS_SHADER_READ_BIT;
-                vkCmdPipelineBarrier(cmd, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT, 0, 0, nullptr, 0, nullptr, 1, &fin);
-            }
-
-            vkEndCommandBuffer(cmd);
-            VkSubmitInfo si{ VK_STRUCTURE_TYPE_SUBMIT_INFO }; si.commandBufferCount = 1; si.pCommandBuffers = &cmd;
-            vkQueueSubmit(m_graphics_queue, 1, &si, VK_NULL_HANDLE); vkQueueWaitIdle(m_graphics_queue);
-
-            vkFreeCommandBuffers(m_device, m_command_pool, 1, &cmd);
-            for (uint32_t i = 0; i < 6; ++i) { vkDestroyBuffer(m_device, ubo[i], nullptr); vkFreeMemory(m_device, ubo_mem[i], nullptr); vkDestroyFramebuffer(m_device, face_fb[i], nullptr); vkDestroyImageView(m_device, face_views[i], nullptr); }
-            vkDestroyBuffer(m_device, cube_vb, nullptr); vkFreeMemory(m_device, cube_vb_mem, nullptr);
-            vkDestroyPipeline(m_device, pipeline, nullptr); vkDestroyPipelineLayout(m_device, playout, nullptr);
-            vkDestroyDescriptorPool(m_device, pool, nullptr); vkDestroyDescriptorSetLayout(m_device, set_layout, nullptr);
-            vkDestroyRenderPass(m_device, rp, nullptr);
-            vkDestroySampler(m_device, eq_sampler, nullptr); vkDestroyImageView(m_device, eq_view, nullptr);
-            vkDestroyImage(m_device, eq_image, nullptr); vkFreeMemory(m_device, eq_mem, nullptr);
-            vkDestroyBuffer(m_device, eq_staging, nullptr); vkFreeMemory(m_device, eq_staging_mem, nullptr);
-            DONUT_INFO("Vulkan RHI: HDRI cubemap built from {} ({}x{} equirect -> {}^2 cube)", path, w, h, (int)FACE);
-            return tex;
-        }
+        for (uint32_t i = 0; i < m_mem_props.memoryTypeCount; ++i)
+            if ((filter & (1u << i)) && (m_mem_props.memoryTypes[i].propertyFlags & flags) == flags)
+                return i;
+        return UINT32_MAX;
+    }
 
-        auto VulkanDevice::create_pipeline(const PipelineDesc& desc) -> Ref<Pipeline>
-        {
-            auto p = create_ref<VkPipelineR>(); p->m_device = m_device; p->m_resources = desc.resources;
+    auto VulkanDevice::create_buffer_raw(VkDeviceSize size, VkBufferUsageFlags usage, VkMemoryPropertyFlags props,
+                                         VkBuffer& buf, VkDeviceMemory& mem) const -> bool
+    {
+        VkBufferCreateInfo bci{ VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO };
+        bci.size = size; bci.usage = usage; bci.sharingMode = VK_SHARING_MODE_EXCLUSIVE;
+        if (vkCreateBuffer(m_device, &bci, nullptr, &buf) != VK_SUCCESS) return false;
+        VkMemoryRequirements req{}; vkGetBufferMemoryRequirements(m_device, buf, &req);
+        VkMemoryAllocateInfo ai{ VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO };
+        ai.allocationSize = req.size; ai.memoryTypeIndex = find_memory_type(req.memoryTypeBits, props);
+        if (vkAllocateMemory(m_device, &ai, nullptr, &mem) != VK_SUCCESS) return false;
+        vkBindBufferMemory(m_device, buf, mem, 0);
+        return true;
+    }
 
-            std::vector<VkDescriptorSetLayoutBinding> binds;
-            for (const auto& r : desc.resources)
-            {
-                VkDescriptorSetLayoutBinding b{};
-                b.binding = r.binding; b.descriptorCount = 1;
-                b.descriptorType = r.kind == ResourceKind::UniformBuffer ? VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER : VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER;
-                b.stageFlags = VK_SHADER_STAGE_VERTEX_BIT | VK_SHADER_STAGE_FRAGMENT_BIT;
-                binds.push_back(b);
-            }
-            VkDescriptorSetLayoutCreateInfo dslci{ VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO };
-            dslci.bindingCount = (uint32_t)binds.size(); dslci.pBindings = binds.data();
-            vkCreateDescriptorSetLayout(m_device, &dslci, nullptr, &p->m_set_layout);
-            VkPipelineLayoutCreateInfo plci{ VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO };
-            plci.setLayoutCount = 1; plci.pSetLayouts = &p->m_set_layout;
-            vkCreatePipelineLayout(m_device, &plci, nullptr, &p->m_layout);
+    auto VulkanDevice::load_spirv(const std::string& path) const -> std::vector<uint32_t>
+    {
+        std::ifstream file(path, std::ios::ate | std::ios::binary);
+        if (!file.is_open()) return {};
+        size_t size = (size_t)file.tellg();
+        std::vector<uint32_t> data(size / 4);
+        file.seekg(0); file.read(reinterpret_cast<char*>(data.data()), size);
+        return data;
+    }
 
-            VkShaderModule vmod = VK_NULL_HANDLE, fmod = VK_NULL_HANDLE;
-            if (!create_shader_module("assets/shaders/generated/" + desc.shader + ".vertexMain.spv", vmod) ||
-                !create_shader_module("assets/shaders/generated/" + desc.shader + ".fragmentMain.spv", fmod))
-            { DONUT_ERROR("Vulkan RHI: shader '{}' modules failed", desc.shader); return p; }
-            VkPipelineShaderStageCreateInfo stages[2]{};
-            stages[0].sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO; stages[0].stage = VK_SHADER_STAGE_VERTEX_BIT;   stages[0].module = vmod; stages[0].pName = "main";
-            stages[1].sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO; stages[1].stage = VK_SHADER_STAGE_FRAGMENT_BIT; stages[1].module = fmod; stages[1].pName = "main";
+    auto VulkanDevice::create_shader_module(const std::string& path, VkShaderModule& out) const -> bool
+    {
+        auto spv = load_spirv(path);
+        if (spv.empty()) { DONUT_ERROR("Vulkan RHI: failed to load SPIR-V {}", path); return false; }
+        VkShaderModuleCreateInfo ci{ VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO };
+        ci.codeSize = spv.size() * 4; ci.pCode = spv.data();
+        return vkCreateShaderModule(m_device, &ci, nullptr, &out) == VK_SUCCESS;
+    }
 
-            VkVertexInputBindingDescription vib{ 0, desc.vertex_layout.stride, VK_VERTEX_INPUT_RATE_VERTEX };
-            std::vector<VkVertexInputAttributeDescription> vias;
-            for (const auto& a : desc.vertex_layout.attributes)
-                vias.push_back({ a.location, 0, vk_attr_format(a.components), a.offset });
-            VkPipelineVertexInputStateCreateInfo vin{ VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO };
-            vin.vertexBindingDescriptionCount = desc.vertex_layout.stride ? 1 : 0; vin.pVertexBindingDescriptions = &vib;
-            vin.vertexAttributeDescriptionCount = (uint32_t)vias.size(); vin.pVertexAttributeDescriptions = vias.data();
 
-            VkPipelineInputAssemblyStateCreateInfo ia{ VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO }; ia.topology = vk_topology(desc.topology);
-            VkPipelineViewportStateCreateInfo vps{ VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO }; vps.viewportCount = 1; vps.scissorCount = 1;
-            VkDynamicState dyn[2] = { VK_DYNAMIC_STATE_VIEWPORT, VK_DYNAMIC_STATE_SCISSOR };
-            VkPipelineDynamicStateCreateInfo dsci{ VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO }; dsci.dynamicStateCount = 2; dsci.pDynamicStates = dyn;
-            VkPipelineRasterizationStateCreateInfo rs{ VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO };
-            rs.polygonMode = VK_POLYGON_MODE_FILL; rs.cullMode = vk_cull(desc.cull); rs.frontFace = VK_FRONT_FACE_COUNTER_CLOCKWISE; rs.lineWidth = 1.0f;
-            VkPipelineMultisampleStateCreateInfo ms{ VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO }; ms.rasterizationSamples = VK_SAMPLE_COUNT_1_BIT;
-            VkPipelineDepthStencilStateCreateInfo ds{ VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO };
-            ds.depthTestEnable = desc.depth_test ? VK_TRUE : VK_FALSE; ds.depthWriteEnable = desc.depth_write ? VK_TRUE : VK_FALSE; ds.depthCompareOp = vk_compare(desc.depth_op);
-            VkPipelineColorBlendAttachmentState cba{};
-            cba.colorWriteMask = VK_COLOR_COMPONENT_R_BIT | VK_COLOR_COMPONENT_G_BIT | VK_COLOR_COMPONENT_B_BIT | VK_COLOR_COMPONENT_A_BIT;
-            if (desc.blend == BlendMode::AlphaBlend)
-            {
-                cba.blendEnable = VK_TRUE;
-                cba.srcColorBlendFactor = VK_BLEND_FACTOR_SRC_ALPHA; cba.dstColorBlendFactor = VK_BLEND_FACTOR_ONE_MINUS_SRC_ALPHA; cba.colorBlendOp = VK_BLEND_OP_ADD;
-                cba.srcAlphaBlendFactor = VK_BLEND_FACTOR_ONE; cba.dstAlphaBlendFactor = VK_BLEND_FACTOR_ZERO; cba.alphaBlendOp = VK_BLEND_OP_ADD;
-            }
-            VkPipelineColorBlendStateCreateInfo cb{ VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO }; cb.attachmentCount = 1; cb.pAttachments = &cba;
+    auto VulkanDevice::init(const NativeWindow& window) -> bool
+    {
+        m_window = (GLFWwindow*)window.glfw_handle; m_width = window.width; m_height = window.height;
+        if (!create_instance())              return false;
+        if (!pick_physical_and_device())     return false;
+        if (!create_swapchain())             return false;
+        if (!create_image_views())           return false;
+        // The swapchain is a "present" target: its colour format + a D32 depth.
+        m_swapchain_rp = get_render_pass(m_swapchain_format, VK_FORMAT_D32_SFLOAT, true);
+        if (!m_swapchain_rp)                 return false;
+        if (!create_depth_and_framebuffers())return false;
+        if (!create_command_and_sync())      return false;
+        DONUT_INFO("Vulkan RHI device ready: {} swapchain images, {}x{}", (int)m_images.size(), m_extent.width, m_extent.height);
+        return true;
+    }
 
-            VkGraphicsPipelineCreateInfo gpci{ VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO };
-            gpci.stageCount = 2; gpci.pStages = stages;
-            gpci.pVertexInputState = &vin; gpci.pInputAssemblyState = &ia; gpci.pViewportState = &vps;
-            gpci.pRasterizationState = &rs; gpci.pMultisampleState = &ms; gpci.pColorBlendState = &cb; gpci.pDynamicState = &dsci;
-            // Resolve the target's attachment signature to a (cached) render pass.
-            // Pipeline<->pass compatibility is by attachment format, so this is the
-            // same pass the matching swapchain / render target renders into.
-            VkFormat pcolor = (desc.target.color == Format::Swapchain) ? m_swapchain_format : vk_format(desc.target.color);
-            VkFormat pdepth = (desc.target.depth == Format::None) ? VK_FORMAT_UNDEFINED : vk_format(desc.target.depth);
-            bool present = desc.target.color == Format::Swapchain;
-            if (pdepth != VK_FORMAT_UNDEFINED) gpci.pDepthStencilState = &ds;
-            gpci.layout = p->m_layout;
-            gpci.renderPass = get_render_pass(pcolor, pdepth, present);
-            gpci.subpass = 0;
-            VkResult pr = vkCreateGraphicsPipelines(m_device, VK_NULL_HANDLE, 1, &gpci, nullptr, &p->m_pipeline);
-            vkDestroyShaderModule(m_device, vmod, nullptr); vkDestroyShaderModule(m_device, fmod, nullptr);
-            if (pr != VK_SUCCESS) DONUT_ERROR("Vulkan RHI: pipeline '{}' creation failed ({})", desc.shader, (int)pr);
-            return p;
-        }
 
-        auto VulkanDevice::begin_frame(const glm::vec4&) -> CommandList*
-        {
-            if (m_device == VK_NULL_HANDLE) return nullptr;
-            vkWaitForFences(m_device, 1, &m_in_flight[m_current_frame], VK_TRUE, UINT64_MAX);
-            VkResult r = vkAcquireNextImageKHR(m_device, m_swapchain, UINT64_MAX, m_image_available[m_current_frame], VK_NULL_HANDLE, &m_image_index);
-            if (r == VK_ERROR_OUT_OF_DATE_KHR) { recreate_swapchain(); return nullptr; }
-            if (r != VK_SUCCESS && r != VK_SUBOPTIMAL_KHR) { DONUT_ERROR("Vulkan RHI: acquire failed ({})", (int)r); return nullptr; }
-            if (m_images_in_flight[m_image_index] != VK_NULL_HANDLE)
-                vkWaitForFences(m_device, 1, &m_images_in_flight[m_image_index], VK_TRUE, UINT64_MAX);
-            m_images_in_flight[m_image_index] = m_in_flight[m_current_frame];
-            if (m_geo_in_use != VK_NULL_HANDLE)
-                vkWaitForFences(m_device, 1, &m_geo_in_use, VK_TRUE, UINT64_MAX);
+    auto VulkanDevice::begin_frame(const glm::vec4&) -> CommandList*
+    {
+        if (m_device == VK_NULL_HANDLE) return nullptr;
+        vkWaitForFences(m_device, 1, &m_in_flight[m_current_frame], VK_TRUE, UINT64_MAX);
+        VkResult r = vkAcquireNextImageKHR(m_device, m_swapchain, UINT64_MAX, m_image_available[m_current_frame], VK_NULL_HANDLE, &m_image_index);
+        if (r == VK_ERROR_OUT_OF_DATE_KHR) { recreate_swapchain(); return nullptr; }
+        if (r != VK_SUCCESS && r != VK_SUBOPTIMAL_KHR) { DONUT_ERROR("Vulkan RHI: acquire failed ({})", (int)r); return nullptr; }
+        if (m_images_in_flight[m_image_index] != VK_NULL_HANDLE)
+            vkWaitForFences(m_device, 1, &m_images_in_flight[m_image_index], VK_TRUE, UINT64_MAX);
+        m_images_in_flight[m_image_index] = m_in_flight[m_current_frame];
+        if (m_geo_in_use != VK_NULL_HANDLE)
+            vkWaitForFences(m_device, 1, &m_geo_in_use, VK_TRUE, UINT64_MAX);
 
-            vkResetDescriptorPool(m_device, m_frame_pools[m_current_frame], 0);
-            VkCommandBuffer cmd = m_command_buffers[m_current_frame];
-            vkResetCommandBuffer(cmd, 0);
-            VkCommandBufferBeginInfo bi{ VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO };
-            vkBeginCommandBuffer(cmd, &bi);
+        vkResetDescriptorPool(m_device, m_frame_pools[m_current_frame], 0);
+        VkCommandBuffer cmd = m_command_buffers[m_current_frame];
+        vkResetCommandBuffer(cmd, 0);
+        VkCommandBufferBeginInfo bi{ VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO };
+        vkBeginCommandBuffer(cmd, &bi);
 
-            m_cmds.m_device = m_device; m_cmds.m_cmd = cmd;
-            m_cmds.m_swapchain_rp = m_swapchain_rp;
-            m_cmds.m_swapchain_fb = m_framebuffers[m_image_index]; m_cmds.m_extent = m_extent;
-            m_cmds.m_frame_pool = m_frame_pools[m_current_frame]; m_cmds.m_pipe = nullptr;
-            return &m_cmds;
-        }
+        m_cmds.m_device = m_device; m_cmds.m_cmd = cmd;
+        m_cmds.m_swapchain_rp = m_swapchain_rp;
+        m_cmds.m_swapchain_fb = m_framebuffers[m_image_index]; m_cmds.m_extent = m_extent;
+        m_cmds.m_frame_pool = m_frame_pools[m_current_frame]; m_cmds.m_pipe = nullptr;
+        return &m_cmds;
+    }
 
-        auto VulkanDevice::end_frame() -> void
-        {
-            VkCommandBuffer cmd = m_command_buffers[m_current_frame];
-            vkEndCommandBuffer(cmd);
-            VkPipelineStageFlags wait_stage = VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT;
-            VkSubmitInfo submit{ VK_STRUCTURE_TYPE_SUBMIT_INFO };
-            submit.waitSemaphoreCount = 1; submit.pWaitSemaphores = &m_image_available[m_current_frame]; submit.pWaitDstStageMask = &wait_stage;
-            submit.commandBufferCount = 1; submit.pCommandBuffers = &cmd;
-            submit.signalSemaphoreCount = 1; submit.pSignalSemaphores = &m_render_finished[m_image_index];
-            vkResetFences(m_device, 1, &m_in_flight[m_current_frame]);
-            if (vkQueueSubmit(m_graphics_queue, 1, &submit, m_in_flight[m_current_frame]) != VK_SUCCESS)
-            { DONUT_ERROR("Vulkan RHI: queue submit failed"); return; }
-            m_geo_in_use = m_in_flight[m_current_frame];
+    auto VulkanDevice::end_frame() -> void
+    {
+        VkCommandBuffer cmd = m_command_buffers[m_current_frame];
+        vkEndCommandBuffer(cmd);
+        VkPipelineStageFlags wait_stage = VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT;
+        VkSubmitInfo submit{ VK_STRUCTURE_TYPE_SUBMIT_INFO };
+        submit.waitSemaphoreCount = 1; submit.pWaitSemaphores = &m_image_available[m_current_frame]; submit.pWaitDstStageMask = &wait_stage;
+        submit.commandBufferCount = 1; submit.pCommandBuffers = &cmd;
+        submit.signalSemaphoreCount = 1; submit.pSignalSemaphores = &m_render_finished[m_image_index];
+        vkResetFences(m_device, 1, &m_in_flight[m_current_frame]);
+        if (vkQueueSubmit(m_graphics_queue, 1, &submit, m_in_flight[m_current_frame]) != VK_SUCCESS)
+        { DONUT_ERROR("Vulkan RHI: queue submit failed"); return; }
+        m_geo_in_use = m_in_flight[m_current_frame];
 
-            VkPresentInfoKHR present{ VK_STRUCTURE_TYPE_PRESENT_INFO_KHR };
-            present.waitSemaphoreCount = 1; present.pWaitSemaphores = &m_render_finished[m_image_index];
-            present.swapchainCount = 1; present.pSwapchains = &m_swapchain; present.pImageIndices = &m_image_index;
-            VkResult r = vkQueuePresentKHR(m_present_queue, &present);
-            if (r == VK_ERROR_OUT_OF_DATE_KHR || r == VK_SUBOPTIMAL_KHR || m_framebuffer_resized)
-            { m_framebuffer_resized = false; recreate_swapchain(); }
-            m_current_frame = (m_current_frame + 1) % MAX_FRAMES_IN_FLIGHT;
-        }
+        VkPresentInfoKHR present{ VK_STRUCTURE_TYPE_PRESENT_INFO_KHR };
+        present.waitSemaphoreCount = 1; present.pWaitSemaphores = &m_render_finished[m_image_index];
+        present.swapchainCount = 1; present.pSwapchains = &m_swapchain; present.pImageIndices = &m_image_index;
+        VkResult r = vkQueuePresentKHR(m_present_queue, &present);
+        if (r == VK_ERROR_OUT_OF_DATE_KHR || r == VK_SUBOPTIMAL_KHR || m_framebuffer_resized)
+        { m_framebuffer_resized = false; recreate_swapchain(); }
+        m_current_frame = (m_current_frame + 1) % MAX_FRAMES_IN_FLIGHT;
+    }
 
-        auto VulkanDevice::init_imgui() -> void
-        {
-            VkDescriptorPoolSize pool_size{ VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, 1000 };
-            VkDescriptorPoolCreateInfo dpci{ VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO };
-            dpci.flags = VK_DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT; dpci.maxSets = 1000;
-            dpci.poolSizeCount = 1; dpci.pPoolSizes = &pool_size;
-            vkCreateDescriptorPool(m_device, &dpci, nullptr, &m_imgui_pool);
+    auto VulkanDevice::init_imgui() -> void
+    {
+        VkDescriptorPoolSize pool_size{ VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, 1000 };
+        VkDescriptorPoolCreateInfo dpci{ VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO };
+        dpci.flags = VK_DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT; dpci.maxSets = 1000;
+        dpci.poolSizeCount = 1; dpci.pPoolSizes = &pool_size;
+        vkCreateDescriptorPool(m_device, &dpci, nullptr, &m_imgui_pool);
 
-            IMGUI_CHECKVERSION(); ImGui::CreateContext();
-            ImGui::GetIO().ConfigFlags |= ImGuiConfigFlags_NavEnableKeyboard;
-            ImGui::GetIO().ConfigFlags |= ImGuiConfigFlags_DockingEnable;
-            ImGui::StyleColorsDark();
-            ImGui_ImplGlfw_InitForVulkan(m_window, true);
-            ImGui_ImplVulkan_InitInfo info{};
-            info.ApiVersion = VK_API_VERSION_1_2; info.Instance = m_instance; info.PhysicalDevice = m_physical;
-            info.Device = m_device; info.QueueFamily = m_graphics_family; info.Queue = m_graphics_queue;
-            info.DescriptorPool = m_imgui_pool; info.RenderPass = m_swapchain_rp;
-            info.MinImageCount = 2; info.ImageCount = (uint32_t)m_images.size(); info.MSAASamples = VK_SAMPLE_COUNT_1_BIT;
-            if (!ImGui_ImplVulkan_Init(&info)) { DONUT_ERROR("Vulkan RHI: ImGui_ImplVulkan_Init failed"); return; }
-            m_imgui = true;
-            DONUT_INFO("Vulkan RHI: ImGui backend initialized");
-        }
+        IMGUI_CHECKVERSION(); ImGui::CreateContext();
+        ImGui::GetIO().ConfigFlags |= ImGuiConfigFlags_NavEnableKeyboard;
+        ImGui::GetIO().ConfigFlags |= ImGuiConfigFlags_DockingEnable;
+        ImGui::StyleColorsDark();
+        ImGui_ImplGlfw_InitForVulkan(m_window, true);
+        ImGui_ImplVulkan_InitInfo info{};
+        info.ApiVersion = VK_API_VERSION_1_2; info.Instance = m_instance; info.PhysicalDevice = m_physical;
+        info.Device = m_device; info.QueueFamily = m_graphics_family; info.Queue = m_graphics_queue;
+        info.DescriptorPool = m_imgui_pool; info.RenderPass = m_swapchain_rp;
+        info.MinImageCount = 2; info.ImageCount = (uint32_t)m_images.size(); info.MSAASamples = VK_SAMPLE_COUNT_1_BIT;
+        if (!ImGui_ImplVulkan_Init(&info)) { DONUT_ERROR("Vulkan RHI: ImGui_ImplVulkan_Init failed"); return; }
+        m_imgui = true;
+        DONUT_INFO("Vulkan RHI: ImGui backend initialized");
+    }
 
-        auto VulkanDevice::imgui_new_frame() -> void
-        {
-            if (!m_imgui) return;
-            ImGui_ImplVulkan_NewFrame(); ImGui_ImplGlfw_NewFrame(); ImGui::NewFrame();
-        }
+    auto VulkanDevice::imgui_new_frame() -> void
+    {
+        if (!m_imgui) return;
+        ImGui_ImplVulkan_NewFrame(); ImGui_ImplGlfw_NewFrame(); ImGui::NewFrame();
+    }
 
-        auto VulkanDevice::imgui_render(CommandList& cmds) -> void
-        {
-            if (!m_imgui) return;
-            ImGui::Render();
-            ImGui_ImplVulkan_RenderDrawData(ImGui::GetDrawData(), static_cast<VkCommandListR&>(cmds).m_cmd);
-        }
+    auto VulkanDevice::imgui_render(CommandList& cmds) -> void
+    {
+        if (!m_imgui) return;
+        ImGui::Render();
+        ImGui_ImplVulkan_RenderDrawData(ImGui::GetDrawData(), static_cast<VkCommandListR&>(cmds).m_cmd);
+    }
 
-        auto VulkanDevice::shutdown() -> void
+    auto VulkanDevice::shutdown() -> void
+    {
+        if (m_device == VK_NULL_HANDLE)
         {
-            if (m_device == VK_NULL_HANDLE)
-            {
-                if (m_instance && m_surface) { vkDestroySurfaceKHR(m_instance, m_surface, nullptr); m_surface = VK_NULL_HANDLE; }
-                if (m_instance) { vkDestroyInstance(m_instance, nullptr); m_instance = VK_NULL_HANDLE; }
-                return;
-            }
-            vkDeviceWaitIdle(m_device);
-            if (m_imgui) { ImGui_ImplVulkan_Shutdown(); ImGui_ImplGlfw_Shutdown(); ImGui::DestroyContext(); m_imgui = false; }
-            if (m_imgui_pool) vkDestroyDescriptorPool(m_device, m_imgui_pool, nullptr);
-            for (auto p : m_frame_pools) vkDestroyDescriptorPool(m_device, p, nullptr);
-            m_frame_pools.clear();
-            for (auto s : m_render_finished) vkDestroySemaphore(m_device, s, nullptr);
-            for (auto s : m_image_available) vkDestroySemaphore(m_device, s, nullptr);
-            for (auto f : m_in_flight)       vkDestroyFence(m_device, f, nullptr);
-            m_render_finished.clear(); m_image_available.clear(); m_in_flight.clear();
-            if (m_command_pool) vkDestroyCommandPool(m_device, m_command_pool, nullptr);
-            for (auto& [key, rp] : m_pass_cache) vkDestroyRenderPass(m_device, rp, nullptr);
-            m_pass_cache.clear(); m_swapchain_rp = VK_NULL_HANDLE;
-            cleanup_swapchain();
-            vkDestroyDevice(m_device, nullptr); m_device = VK_NULL_HANDLE;
-            if (m_surface)  vkDestroySurfaceKHR(m_instance, m_surface, nullptr);
-            if (m_instance) vkDestroyInstance(m_instance, nullptr);
-            m_surface = VK_NULL_HANDLE; m_instance = VK_NULL_HANDLE;
+            if (m_instance && m_surface) { vkDestroySurfaceKHR(m_instance, m_surface, nullptr); m_surface = VK_NULL_HANDLE; }
+            if (m_instance) { vkDestroyInstance(m_instance, nullptr); m_instance = VK_NULL_HANDLE; }
+            return;
         }
+        vkDeviceWaitIdle(m_device);
+        if (m_imgui) { ImGui_ImplVulkan_Shutdown(); ImGui_ImplGlfw_Shutdown(); ImGui::DestroyContext(); m_imgui = false; }
+        if (m_imgui_pool) vkDestroyDescriptorPool(m_device, m_imgui_pool, nullptr);
+        for (auto p : m_frame_pools) vkDestroyDescriptorPool(m_device, p, nullptr);
+        m_frame_pools.clear();
+        for (auto s : m_render_finished) vkDestroySemaphore(m_device, s, nullptr);
+        for (auto s : m_image_available) vkDestroySemaphore(m_device, s, nullptr);
+        for (auto f : m_in_flight)       vkDestroyFence(m_device, f, nullptr);
+        m_render_finished.clear(); m_image_available.clear(); m_in_flight.clear();
+        if (m_command_pool) vkDestroyCommandPool(m_device, m_command_pool, nullptr);
+        for (auto& [key, rp] : m_pass_cache) vkDestroyRenderPass(m_device, rp, nullptr);
+        m_pass_cache.clear(); m_swapchain_rp = VK_NULL_HANDLE;
+        cleanup_swapchain();
+        vkDestroyDevice(m_device, nullptr); m_device = VK_NULL_HANDLE;
+        if (m_surface)  vkDestroySurfaceKHR(m_instance, m_surface, nullptr);
+        if (m_instance) vkDestroyInstance(m_instance, nullptr);
+        m_surface = VK_NULL_HANDLE; m_instance = VK_NULL_HANDLE;
     }
 
     auto create_vulkan_device() -> Scope<Device> { return create_scope<VulkanDevice>(); }
diff --git a/src/platform/vulkan/vulkan_resources.cpp b/src/platform/vulkan/vulkan_resources.cpp
new file mode 100644
index 0000000..e40ded3
--- /dev/null
+++ b/src/platform/vulkan/vulkan_resources.cpp
@@ -0,0 +1,209 @@
+#include "vulkan_common.h"
+
+namespace Donut::RHI
+{
+    auto VulkanDevice::create_buffer(BufferType type, size_t size, const void* data) -> Ref<Buffer>
+    {
+        VkBufferUsageFlags usage = type == BufferType::Index ? VK_BUFFER_USAGE_INDEX_BUFFER_BIT
+                                 : type == BufferType::Uniform ? VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT
+                                 : VK_BUFFER_USAGE_VERTEX_BUFFER_BIT;
+        VkBuffer buf = VK_NULL_HANDLE; VkDeviceMemory mem = VK_NULL_HANDLE;
+        create_buffer_raw(size, usage, VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT, buf, mem);
+        void* mapped = nullptr; vkMapMemory(m_device, mem, 0, size, 0, &mapped);
+        if (data && mapped) std::memcpy(mapped, data, size);
+        return create_ref<VkBufferR>(m_device, buf, mem, mapped, size);
+    }
+
+    auto VulkanDevice::create_texture(int w, int h, Format format, Filter filter, const void* data) -> Ref<Texture>
+    {
+        auto tex = create_ref<VkTextureR>(); tex->m_device = m_device;
+        VkFormat fmt = vk_format(format);
+        VkImageCreateInfo ici{ VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO };
+        ici.imageType = VK_IMAGE_TYPE_2D; ici.format = fmt; ici.extent = { (uint32_t)w, (uint32_t)h, 1 };
+        ici.mipLevels = 1; ici.arrayLayers = 1; ici.samples = VK_SAMPLE_COUNT_1_BIT;
+        ici.tiling = VK_IMAGE_TILING_OPTIMAL; ici.usage = VK_IMAGE_USAGE_TRANSFER_DST_BIT | VK_IMAGE_USAGE_SAMPLED_BIT;
+        vkCreateImage(m_device, &ici, nullptr, &tex->m_image);
+        VkMemoryRequirements req{}; vkGetImageMemoryRequirements(m_device, tex->m_image, &req);
+        VkMemoryAllocateInfo ai{ VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO };
+        ai.allocationSize = req.size; ai.memoryTypeIndex = find_memory_type(req.memoryTypeBits, VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT);
+        vkAllocateMemory(m_device, &ai, nullptr, &tex->m_mem);
+        vkBindImageMemory(m_device, tex->m_image, tex->m_mem, 0);
+
+        size_t bpp = format == Format::RGBA16F ? 8 : 4;
+        VkDeviceSize sz = (VkDeviceSize)w * h * bpp;
+        VkBuffer staging = VK_NULL_HANDLE; VkDeviceMemory staging_mem = VK_NULL_HANDLE;
+        create_buffer_raw(sz, VK_BUFFER_USAGE_TRANSFER_SRC_BIT, VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT, staging, staging_mem);
+        void* mp = nullptr; vkMapMemory(m_device, staging_mem, 0, sz, 0, &mp);
+        if (data) std::memcpy(mp, data, sz); else std::memset(mp, 0, sz);
+        vkUnmapMemory(m_device, staging_mem);
+
+        VkCommandBufferAllocateInfo cbai{ VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO };
+        cbai.commandPool = m_command_pool; cbai.level = VK_COMMAND_BUFFER_LEVEL_PRIMARY; cbai.commandBufferCount = 1;
+        VkCommandBuffer cmd; vkAllocateCommandBuffers(m_device, &cbai, &cmd);
+        VkCommandBufferBeginInfo bi{ VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO }; bi.flags = VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT;
+        vkBeginCommandBuffer(cmd, &bi);
+        VkImageMemoryBarrier b{ VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER };
+        b.oldLayout = VK_IMAGE_LAYOUT_UNDEFINED; b.newLayout = VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL;
+        b.image = tex->m_image; b.subresourceRange = { VK_IMAGE_ASPECT_COLOR_BIT, 0, 1, 0, 1 };
+        b.srcAccessMask = 0; b.dstAccessMask = VK_ACCESS_TRANSFER_WRITE_BIT;
+        vkCmdPipelineBarrier(cmd, VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT, 0, 0, nullptr, 0, nullptr, 1, &b);
+        VkBufferImageCopy copy{}; copy.imageSubresource = { VK_IMAGE_ASPECT_COLOR_BIT, 0, 0, 1 }; copy.imageExtent = { (uint32_t)w, (uint32_t)h, 1 };
+        vkCmdCopyBufferToImage(cmd, staging, tex->m_image, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, 1, &copy);
+        VkImageMemoryBarrier r = b; r.oldLayout = VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL; r.newLayout = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL;
+        r.srcAccessMask = VK_ACCESS_TRANSFER_WRITE_BIT; r.dstAccessMask = VK_ACCESS_SHADER_READ_BIT;
+        vkCmdPipelineBarrier(cmd, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT, 0, 0, nullptr, 0, nullptr, 1, &r);
+        vkEndCommandBuffer(cmd);
+        VkSubmitInfo si{ VK_STRUCTURE_TYPE_SUBMIT_INFO }; si.commandBufferCount = 1; si.pCommandBuffers = &cmd;
+        vkQueueSubmit(m_graphics_queue, 1, &si, VK_NULL_HANDLE); vkQueueWaitIdle(m_graphics_queue);
+        vkFreeCommandBuffers(m_device, m_command_pool, 1, &cmd);
+        vkDestroyBuffer(m_device, staging, nullptr); vkFreeMemory(m_device, staging_mem, nullptr);
+
+        VkImageViewCreateInfo vci{ VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO };
+        vci.image = tex->m_image; vci.viewType = VK_IMAGE_VIEW_TYPE_2D; vci.format = fmt;
+        vci.subresourceRange = { VK_IMAGE_ASPECT_COLOR_BIT, 0, 1, 0, 1 };
+        vkCreateImageView(m_device, &vci, nullptr, &tex->m_view);
+        VkSamplerCreateInfo smci{ VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO };
+        smci.magFilter = vk_filter(filter); smci.minFilter = vk_filter(filter);
+        smci.addressModeU = smci.addressModeV = smci.addressModeW = VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE;
+        vkCreateSampler(m_device, &smci, nullptr, &tex->m_sampler);
+        return tex;
+    }
+
+    auto VulkanDevice::create_render_target(int w, int h, Format color, Format depth, Filter filter, int /*mips*/) -> Ref<RenderTarget>
+    {
+        auto rt = create_ref<VkRenderTargetR>();
+        rt->m_device = m_device; rt->m_w = w; rt->m_h = h;
+        VkFormat cfmt = (color == Format::Swapchain) ? m_swapchain_format : vk_format(color);
+        VkImageCreateInfo ici{ VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO };
+        ici.imageType = VK_IMAGE_TYPE_2D; ici.format = cfmt; ici.extent = { (uint32_t)w, (uint32_t)h, 1 };
+        ici.mipLevels = 1; ici.arrayLayers = 1; ici.samples = VK_SAMPLE_COUNT_1_BIT;
+        ici.tiling = VK_IMAGE_TILING_OPTIMAL; ici.usage = VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT | VK_IMAGE_USAGE_SAMPLED_BIT;
+        vkCreateImage(m_device, &ici, nullptr, &rt->m_image);
+        VkMemoryRequirements req{}; vkGetImageMemoryRequirements(m_device, rt->m_image, &req);
+        VkMemoryAllocateInfo ai{ VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO };
+        ai.allocationSize = req.size; ai.memoryTypeIndex = find_memory_type(req.memoryTypeBits, VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT);
+        vkAllocateMemory(m_device, &ai, nullptr, &rt->m_mem);
+        vkBindImageMemory(m_device, rt->m_image, rt->m_mem, 0);
+        VkImageViewCreateInfo vci{ VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO };
+        vci.image = rt->m_image; vci.viewType = VK_IMAGE_VIEW_TYPE_2D; vci.format = cfmt;
+        vci.subresourceRange = { VK_IMAGE_ASPECT_COLOR_BIT, 0, 1, 0, 1 };
+        vkCreateImageView(m_device, &vci, nullptr, &rt->m_view);
+        VkSamplerCreateInfo smci{ VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO };
+        smci.magFilter = vk_filter(filter); smci.minFilter = vk_filter(filter);
+        smci.addressModeU = smci.addressModeV = smci.addressModeW = VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE;
+        vkCreateSampler(m_device, &smci, nullptr, &rt->m_sampler);
+
+        // Optional depth attachment (for off-screen passes that need a depth test).
+        rt->m_has_depth = depth != Format::None;
+        VkFormat dfmt = VK_FORMAT_UNDEFINED;
+        if (rt->m_has_depth)
+        {
+            dfmt = vk_format(depth);
+            VkImageCreateInfo dici{ VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO };
+            dici.imageType = VK_IMAGE_TYPE_2D; dici.format = dfmt; dici.extent = { (uint32_t)w, (uint32_t)h, 1 };
+            dici.mipLevels = 1; dici.arrayLayers = 1; dici.samples = VK_SAMPLE_COUNT_1_BIT;
+            dici.tiling = VK_IMAGE_TILING_OPTIMAL; dici.usage = VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT;
+            vkCreateImage(m_device, &dici, nullptr, &rt->m_depth_image);
+            VkMemoryRequirements dreq{}; vkGetImageMemoryRequirements(m_device, rt->m_depth_image, &dreq);
+            VkMemoryAllocateInfo dai{ VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO };
+            dai.allocationSize = dreq.size; dai.memoryTypeIndex = find_memory_type(dreq.memoryTypeBits, VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT);
+            vkAllocateMemory(m_device, &dai, nullptr, &rt->m_depth_mem);
+            vkBindImageMemory(m_device, rt->m_depth_image, rt->m_depth_mem, 0);
+            VkImageViewCreateInfo dvci{ VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO };
+            dvci.image = rt->m_depth_image; dvci.viewType = VK_IMAGE_VIEW_TYPE_2D; dvci.format = dfmt;
+            dvci.subresourceRange = { VK_IMAGE_ASPECT_DEPTH_BIT, 0, 1, 0, 1 };
+            vkCreateImageView(m_device, &dvci, nullptr, &rt->m_depth_view);
+        }
+
+        rt->m_pass = get_render_pass(cfmt, dfmt, false);   // off-screen (sampled) target
+        VkImageView atts[2] = { rt->m_view, rt->m_depth_view };
+        VkFramebufferCreateInfo fbci{ VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO };
+        fbci.renderPass = rt->m_pass; fbci.attachmentCount = rt->m_has_depth ? 2u : 1u; fbci.pAttachments = atts;
+        fbci.width = w; fbci.height = h; fbci.layers = 1;
+        vkCreateFramebuffer(m_device, &fbci, nullptr, &rt->m_fb);
+
+        rt->m_color.m_device = m_device; rt->m_color.m_view = rt->m_view; rt->m_color.m_sampler = rt->m_sampler; rt->m_color.m_owns = false;
+        return rt;
+    }
+
+    // Builds an environment cubemap from an equirectangular HDRI: render the 6
+    // faces with the EquirectToCubemap pipeline, then a full mip chain by
+    // linear down-blits (so divergence-based LOD reads a blurred sky). Returns
+    // a Texture owning the cube image/view/sampler.
+
+    auto VulkanDevice::create_pipeline(const PipelineDesc& desc) -> Ref<Pipeline>
+    {
+        auto p = create_ref<VkPipelineR>(); p->m_device = m_device; p->m_resources = desc.resources;
+
+        std::vector<VkDescriptorSetLayoutBinding> binds;
+        for (const auto& r : desc.resources)
+        {
+            VkDescriptorSetLayoutBinding b{};
+            b.binding = r.binding; b.descriptorCount = 1;
+            b.descriptorType = r.kind == ResourceKind::UniformBuffer ? VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER : VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER;
+            b.stageFlags = VK_SHADER_STAGE_VERTEX_BIT | VK_SHADER_STAGE_FRAGMENT_BIT;
+            binds.push_back(b);
+        }
+        VkDescriptorSetLayoutCreateInfo dslci{ VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO };
+        dslci.bindingCount = (uint32_t)binds.size(); dslci.pBindings = binds.data();
+        vkCreateDescriptorSetLayout(m_device, &dslci, nullptr, &p->m_set_layout);
+        VkPipelineLayoutCreateInfo plci{ VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO };
+        plci.setLayoutCount = 1; plci.pSetLayouts = &p->m_set_layout;
+        vkCreatePipelineLayout(m_device, &plci, nullptr, &p->m_layout);
+
+        VkShaderModule vmod = VK_NULL_HANDLE, fmod = VK_NULL_HANDLE;
+        if (!create_shader_module("assets/shaders/generated/" + desc.shader + ".vertexMain.spv", vmod) ||
+            !create_shader_module("assets/shaders/generated/" + desc.shader + ".fragmentMain.spv", fmod))
+        { DONUT_ERROR("Vulkan RHI: shader '{}' modules failed", desc.shader); return p; }
+        VkPipelineShaderStageCreateInfo stages[2]{};
+        stages[0].sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO; stages[0].stage = VK_SHADER_STAGE_VERTEX_BIT;   stages[0].module = vmod; stages[0].pName = "main";
+        stages[1].sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO; stages[1].stage = VK_SHADER_STAGE_FRAGMENT_BIT; stages[1].module = fmod; stages[1].pName = "main";
+
+        VkVertexInputBindingDescription vib{ 0, desc.vertex_layout.stride, VK_VERTEX_INPUT_RATE_VERTEX };
+        std::vector<VkVertexInputAttributeDescription> vias;
+        for (const auto& a : desc.vertex_layout.attributes)
+            vias.push_back({ a.location, 0, vk_attr_format(a.components), a.offset });
+        VkPipelineVertexInputStateCreateInfo vin{ VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO };
+        vin.vertexBindingDescriptionCount = desc.vertex_layout.stride ? 1 : 0; vin.pVertexBindingDescriptions = &vib;
+        vin.vertexAttributeDescriptionCount = (uint32_t)vias.size(); vin.pVertexAttributeDescriptions = vias.data();
+
+        VkPipelineInputAssemblyStateCreateInfo ia{ VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO }; ia.topology = vk_topology(desc.topology);
+        VkPipelineViewportStateCreateInfo vps{ VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO }; vps.viewportCount = 1; vps.scissorCount = 1;
+        VkDynamicState dyn[2] = { VK_DYNAMIC_STATE_VIEWPORT, VK_DYNAMIC_STATE_SCISSOR };
+        VkPipelineDynamicStateCreateInfo dsci{ VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO }; dsci.dynamicStateCount = 2; dsci.pDynamicStates = dyn;
+        VkPipelineRasterizationStateCreateInfo rs{ VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO };
+        rs.polygonMode = VK_POLYGON_MODE_FILL; rs.cullMode = vk_cull(desc.cull); rs.frontFace = VK_FRONT_FACE_COUNTER_CLOCKWISE; rs.lineWidth = 1.0f;
+        VkPipelineMultisampleStateCreateInfo ms{ VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO }; ms.rasterizationSamples = VK_SAMPLE_COUNT_1_BIT;
+        VkPipelineDepthStencilStateCreateInfo ds{ VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO };
+        ds.depthTestEnable = desc.depth_test ? VK_TRUE : VK_FALSE; ds.depthWriteEnable = desc.depth_write ? VK_TRUE : VK_FALSE; ds.depthCompareOp = vk_compare(desc.depth_op);
+        VkPipelineColorBlendAttachmentState cba{};
+        cba.colorWriteMask = VK_COLOR_COMPONENT_R_BIT | VK_COLOR_COMPONENT_G_BIT | VK_COLOR_COMPONENT_B_BIT | VK_COLOR_COMPONENT_A_BIT;
+        if (desc.blend == BlendMode::AlphaBlend)
+        {
+            cba.blendEnable = VK_TRUE;
+            cba.srcColorBlendFactor = VK_BLEND_FACTOR_SRC_ALPHA; cba.dstColorBlendFactor = VK_BLEND_FACTOR_ONE_MINUS_SRC_ALPHA; cba.colorBlendOp = VK_BLEND_OP_ADD;
+            cba.srcAlphaBlendFactor = VK_BLEND_FACTOR_ONE; cba.dstAlphaBlendFactor = VK_BLEND_FACTOR_ZERO; cba.alphaBlendOp = VK_BLEND_OP_ADD;
+        }
+        VkPipelineColorBlendStateCreateInfo cb{ VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO }; cb.attachmentCount = 1; cb.pAttachments = &cba;
+
+        VkGraphicsPipelineCreateInfo gpci{ VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO };
+        gpci.stageCount = 2; gpci.pStages = stages;
+        gpci.pVertexInputState = &vin; gpci.pInputAssemblyState = &ia; gpci.pViewportState = &vps;
+        gpci.pRasterizationState = &rs; gpci.pMultisampleState = &ms; gpci.pColorBlendState = &cb; gpci.pDynamicState = &dsci;
+        // Resolve the target's attachment signature to a (cached) render pass.
+        // Pipeline<->pass compatibility is by attachment format, so this is the
+        // same pass the matching swapchain / render target renders into.
+        VkFormat pcolor = (desc.target.color == Format::Swapchain) ? m_swapchain_format : vk_format(desc.target.color);
+        VkFormat pdepth = (desc.target.depth == Format::None) ? VK_FORMAT_UNDEFINED : vk_format(desc.target.depth);
+        bool present = desc.target.color == Format::Swapchain;
+        if (pdepth != VK_FORMAT_UNDEFINED) gpci.pDepthStencilState = &ds;
+        gpci.layout = p->m_layout;
+        gpci.renderPass = get_render_pass(pcolor, pdepth, present);
+        gpci.subpass = 0;
+        VkResult pr = vkCreateGraphicsPipelines(m_device, VK_NULL_HANDLE, 1, &gpci, nullptr, &p->m_pipeline);
+        vkDestroyShaderModule(m_device, vmod, nullptr); vkDestroyShaderModule(m_device, fmod, nullptr);
+        if (pr != VK_SUCCESS) DONUT_ERROR("Vulkan RHI: pipeline '{}' creation failed ({})", desc.shader, (int)pr);
+        return p;
+    }
+
+}
diff --git a/src/platform/vulkan/vulkan_swapchain.cpp b/src/platform/vulkan/vulkan_swapchain.cpp
new file mode 100644
index 0000000..fe5bd38
--- /dev/null
+++ b/src/platform/vulkan/vulkan_swapchain.cpp
@@ -0,0 +1,298 @@
+#include "vulkan_common.h"
+
+namespace Donut::RHI
+{
+    auto VulkanDevice::create_instance() -> bool
+    {
+        VkApplicationInfo app{ VK_STRUCTURE_TYPE_APPLICATION_INFO };
+        app.pApplicationName = "Donut"; app.apiVersion = VK_API_VERSION_1_2;
+
+        uint32_t glfwExtCount = 0;
+        const char** glfwExts = glfwGetRequiredInstanceExtensions(&glfwExtCount);
+        if (!glfwExts) { DONUT_ERROR("Vulkan RHI: GLFW reports no surface support"); return false; }
+        std::vector<const char*> exts(glfwExts, glfwExts + glfwExtCount);
+        exts.push_back(VK_KHR_PORTABILITY_ENUMERATION_EXTENSION_NAME);
+        exts.push_back(VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME);
+
+        std::vector<const char*> layers;
+        uint32_t layer_count = 0; vkEnumerateInstanceLayerProperties(&layer_count, nullptr);
+        std::vector<VkLayerProperties> avail(layer_count);
+        vkEnumerateInstanceLayerProperties(&layer_count, avail.data());
+        for (const auto& l : avail)
+            if (std::strcmp(l.layerName, "VK_LAYER_KHRONOS_validation") == 0)
+                layers.push_back("VK_LAYER_KHRONOS_validation");
+
+        VkInstanceCreateInfo ici{ VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO };
+        ici.flags = VK_INSTANCE_CREATE_ENUMERATE_PORTABILITY_BIT_KHR;
+        ici.pApplicationInfo = &app;
+        ici.enabledExtensionCount = (uint32_t)exts.size(); ici.ppEnabledExtensionNames = exts.data();
+        ici.enabledLayerCount = (uint32_t)layers.size(); ici.ppEnabledLayerNames = layers.data();
+        VkResult r = vkCreateInstance(&ici, nullptr, &m_instance);
+        if (r != VK_SUCCESS && !layers.empty())
+        {
+            DONUT_WARN("Vulkan RHI: validation layer unavailable, continuing without it");
+            ici.enabledLayerCount = 0; ici.ppEnabledLayerNames = nullptr;
+            r = vkCreateInstance(&ici, nullptr, &m_instance);
+        }
+        if (r != VK_SUCCESS) { DONUT_ERROR("Vulkan RHI: vkCreateInstance failed ({})", (int)r); return false; }
+        VKD_CHECK(glfwCreateWindowSurface(m_instance, m_window, nullptr, &m_surface));
+        DONUT_INFO("Vulkan RHI: instance + surface created (validation {})", layers.empty() ? "off" : "on");
+        return true;
+    }
+
+    auto VulkanDevice::pick_physical_and_device() -> bool
+    {
+        uint32_t count = 0; vkEnumeratePhysicalDevices(m_instance, &count, nullptr);
+        if (count == 0) { DONUT_ERROR("Vulkan RHI: no physical devices"); return false; }
+        std::vector<VkPhysicalDevice> devices(count);
+        vkEnumeratePhysicalDevices(m_instance, &count, devices.data());
+        m_physical = devices[0];
+
+        uint32_t q = 0; vkGetPhysicalDeviceQueueFamilyProperties(m_physical, &q, nullptr);
+        std::vector<VkQueueFamilyProperties> qfams(q);
+        vkGetPhysicalDeviceQueueFamilyProperties(m_physical, &q, qfams.data());
+        bool fg = false, fp = false;
+        for (uint32_t i = 0; i < q; ++i)
+        {
+            if (!fg && (qfams[i].queueFlags & VK_QUEUE_GRAPHICS_BIT)) { m_graphics_family = i; fg = true; }
+            VkBool32 present = VK_FALSE; vkGetPhysicalDeviceSurfaceSupportKHR(m_physical, i, m_surface, &present);
+            if (!fp && present) { m_present_family = i; fp = true; }
+        }
+        if (!fg || !fp) { DONUT_ERROR("Vulkan RHI: no graphics/present queue"); return false; }
+
+        std::vector<const char*> dev_exts = { VK_KHR_SWAPCHAIN_EXTENSION_NAME };
+        uint32_t dec = 0; vkEnumerateDeviceExtensionProperties(m_physical, nullptr, &dec, nullptr);
+        std::vector<VkExtensionProperties> dep(dec);
+        vkEnumerateDeviceExtensionProperties(m_physical, nullptr, &dec, dep.data());
+        for (const auto& e : dep)
+            if (std::strcmp(e.extensionName, "VK_KHR_portability_subset") == 0)
+                dev_exts.push_back("VK_KHR_portability_subset");
+
+        float priority = 1.0f;
+        std::vector<VkDeviceQueueCreateInfo> qcis;
+        uint32_t families[2] = { m_graphics_family, m_present_family };
+        for (uint32_t i = 0; i < (m_graphics_family == m_present_family ? 1u : 2u); ++i)
+        {
+            VkDeviceQueueCreateInfo qci{ VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO };
+            qci.queueFamilyIndex = families[i]; qci.queueCount = 1; qci.pQueuePriorities = &priority;
+            qcis.push_back(qci);
+        }
+        VkDeviceCreateInfo dci{ VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO };
+        dci.queueCreateInfoCount = (uint32_t)qcis.size(); dci.pQueueCreateInfos = qcis.data();
+        dci.enabledExtensionCount = (uint32_t)dev_exts.size(); dci.ppEnabledExtensionNames = dev_exts.data();
+        VKD_CHECK(vkCreateDevice(m_physical, &dci, nullptr, &m_device));
+        vkGetDeviceQueue(m_device, m_graphics_family, 0, &m_graphics_queue);
+        vkGetDeviceQueue(m_device, m_present_family, 0, &m_present_queue);
+
+        VkPhysicalDeviceProperties props{}; vkGetPhysicalDeviceProperties(m_physical, &props);
+        vkGetPhysicalDeviceMemoryProperties(m_physical, &m_mem_props);
+        m_gpu_name = props.deviceName;
+        DONUT_INFO("Vulkan RHI device: {}", m_gpu_name);
+        return true;
+    }
+
+    auto VulkanDevice::create_swapchain() -> bool
+    {
+        VkSurfaceCapabilitiesKHR caps{};
+        vkGetPhysicalDeviceSurfaceCapabilitiesKHR(m_physical, m_surface, &caps);
+        uint32_t fc = 0; vkGetPhysicalDeviceSurfaceFormatsKHR(m_physical, m_surface, &fc, nullptr);
+        std::vector<VkSurfaceFormatKHR> formats(fc);
+        vkGetPhysicalDeviceSurfaceFormatsKHR(m_physical, m_surface, &fc, formats.data());
+        VkSurfaceFormatKHR chosen = formats[0];
+        for (const auto& f : formats)
+            if (f.format == VK_FORMAT_B8G8R8A8_UNORM && f.colorSpace == VK_COLOR_SPACE_SRGB_NONLINEAR_KHR) chosen = f;
+        m_swapchain_format = chosen.format;
+
+        if (caps.currentExtent.width != UINT32_MAX) m_extent = caps.currentExtent;
+        else {
+            m_extent.width  = std::clamp((uint32_t)m_width,  caps.minImageExtent.width,  caps.maxImageExtent.width);
+            m_extent.height = std::clamp((uint32_t)m_height, caps.minImageExtent.height, caps.maxImageExtent.height);
+        }
+        uint32_t image_count = caps.minImageCount + 1;
+        if (caps.maxImageCount > 0 && image_count > caps.maxImageCount) image_count = caps.maxImageCount;
+
+        VkSwapchainCreateInfoKHR sci{ VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR };
+        sci.surface = m_surface; sci.minImageCount = image_count;
+        sci.imageFormat = chosen.format; sci.imageColorSpace = chosen.colorSpace;
+        sci.imageExtent = m_extent; sci.imageArrayLayers = 1;
+        sci.imageUsage = VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT;
+        sci.preTransform = caps.currentTransform; sci.compositeAlpha = VK_COMPOSITE_ALPHA_OPAQUE_BIT_KHR;
+        sci.presentMode = VK_PRESENT_MODE_FIFO_KHR; sci.clipped = VK_TRUE;
+        uint32_t fam[2] = { m_graphics_family, m_present_family };
+        if (m_graphics_family != m_present_family)
+        { sci.imageSharingMode = VK_SHARING_MODE_CONCURRENT; sci.queueFamilyIndexCount = 2; sci.pQueueFamilyIndices = fam; }
+        else sci.imageSharingMode = VK_SHARING_MODE_EXCLUSIVE;
+        VKD_CHECK(vkCreateSwapchainKHR(m_device, &sci, nullptr, &m_swapchain));
+        uint32_t n = 0; vkGetSwapchainImagesKHR(m_device, m_swapchain, &n, nullptr);
+        m_images.resize(n); vkGetSwapchainImagesKHR(m_device, m_swapchain, &n, m_images.data());
+        return true;
+    }
+
+    auto VulkanDevice::create_image_views() -> bool
+    {
+        m_image_views.resize(m_images.size());
+        for (size_t i = 0; i < m_images.size(); ++i)
+        {
+            VkImageViewCreateInfo vci{ VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO };
+            vci.image = m_images[i]; vci.viewType = VK_IMAGE_VIEW_TYPE_2D; vci.format = m_swapchain_format;
+            vci.subresourceRange = { VK_IMAGE_ASPECT_COLOR_BIT, 0, 1, 0, 1 };
+            VKD_CHECK(vkCreateImageView(m_device, &vci, nullptr, &m_image_views[i]));
+        }
+        return true;
+    }
+
+    // A render pass for one attachment signature, created once and cached.
+    // `present` targets (the swapchain) finish PRESENT_SRC and sync on the
+    // colour-output stage; `sampled` targets (off-screen) finish
+    // SHADER_READ_ONLY and round-trip through the fragment shader so the next
+    // pass can sample them. Depth (VK_FORMAT_UNDEFINED = none) is optional.
+    auto VulkanDevice::get_render_pass(VkFormat color, VkFormat depth, bool present) -> VkRenderPass
+    {
+        uint64_t key = (uint64_t)(uint32_t)color
+                     | ((uint64_t)(uint32_t)depth << 24)
+                     | ((uint64_t)(present ? 1 : 0) << 48);
+        auto it = m_pass_cache.find(key);
+        if (it != m_pass_cache.end()) return it->second;
+
+        const bool has_depth = depth != VK_FORMAT_UNDEFINED;
+        VkAttachmentDescription atts[2]{};
+        atts[0].format = color; atts[0].samples = VK_SAMPLE_COUNT_1_BIT;
+        atts[0].loadOp = VK_ATTACHMENT_LOAD_OP_CLEAR; atts[0].storeOp = VK_ATTACHMENT_STORE_OP_STORE;
+        atts[0].stencilLoadOp = VK_ATTACHMENT_LOAD_OP_DONT_CARE; atts[0].stencilStoreOp = VK_ATTACHMENT_STORE_OP_DONT_CARE;
+        atts[0].initialLayout = VK_IMAGE_LAYOUT_UNDEFINED;
+        atts[0].finalLayout = present ? VK_IMAGE_LAYOUT_PRESENT_SRC_KHR : VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL;
+        atts[1].format = depth; atts[1].samples = VK_SAMPLE_COUNT_1_BIT;
+        atts[1].loadOp = VK_ATTACHMENT_LOAD_OP_CLEAR; atts[1].storeOp = VK_ATTACHMENT_STORE_OP_DONT_CARE;
+        atts[1].stencilLoadOp = VK_ATTACHMENT_LOAD_OP_DONT_CARE; atts[1].stencilStoreOp = VK_ATTACHMENT_STORE_OP_DONT_CARE;
+        atts[1].initialLayout = VK_IMAGE_LAYOUT_UNDEFINED; atts[1].finalLayout = VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL;
+        VkAttachmentReference color_ref{ 0, VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL };
+        VkAttachmentReference depth_ref{ 1, VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL };
+        VkSubpassDescription subpass{}; subpass.pipelineBindPoint = VK_PIPELINE_BIND_POINT_GRAPHICS;
+        subpass.colorAttachmentCount = 1; subpass.pColorAttachments = &color_ref;
+        if (has_depth) subpass.pDepthStencilAttachment = &depth_ref;
+
+        VkSubpassDependency deps[2]{};
+        uint32_t dep_count;
+        if (present)
+        {
+            deps[0].srcSubpass = VK_SUBPASS_EXTERNAL; deps[0].dstSubpass = 0;
+            deps[0].srcStageMask = VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT | VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT;
+            deps[0].dstStageMask = VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT | VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT;
+            deps[0].dstAccessMask = VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT | VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT;
+            dep_count = 1;
+        }
+        else
+        {
+            deps[0].srcSubpass = VK_SUBPASS_EXTERNAL; deps[0].dstSubpass = 0;
+            deps[0].srcStageMask = VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT; deps[0].srcAccessMask = VK_ACCESS_SHADER_READ_BIT;
+            deps[0].dstStageMask = VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT; deps[0].dstAccessMask = VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT;
+            deps[1].srcSubpass = 0; deps[1].dstSubpass = VK_SUBPASS_EXTERNAL;
+            deps[1].srcStageMask = VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT; deps[1].srcAccessMask = VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT;
+            deps[1].dstStageMask = VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT; deps[1].dstAccessMask = VK_ACCESS_SHADER_READ_BIT;
+            dep_count = 2;
+        }
+
+        VkRenderPassCreateInfo rpci{ VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO };
+        rpci.attachmentCount = has_depth ? 2 : 1; rpci.pAttachments = atts;
+        rpci.subpassCount = 1; rpci.pSubpasses = &subpass;
+        rpci.dependencyCount = dep_count; rpci.pDependencies = deps;
+        VkRenderPass rp = VK_NULL_HANDLE;
+        if (vkCreateRenderPass(m_device, &rpci, nullptr, &rp) != VK_SUCCESS)
+        { DONUT_ERROR("Vulkan RHI: render pass creation failed"); return VK_NULL_HANDLE; }
+        m_pass_cache[key] = rp;
+        return rp;
+    }
+
+    auto VulkanDevice::create_depth_and_framebuffers() -> bool
+    {
+        VkImageCreateInfo dici{ VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO };
+        dici.imageType = VK_IMAGE_TYPE_2D; dici.format = VK_FORMAT_D32_SFLOAT;
+        dici.extent = { m_extent.width, m_extent.height, 1 };
+        dici.mipLevels = 1; dici.arrayLayers = 1; dici.samples = VK_SAMPLE_COUNT_1_BIT;
+        dici.tiling = VK_IMAGE_TILING_OPTIMAL; dici.usage = VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT;
+        VKD_CHECK(vkCreateImage(m_device, &dici, nullptr, &m_depth_image));
+        VkMemoryRequirements dreq{}; vkGetImageMemoryRequirements(m_device, m_depth_image, &dreq);
+        VkMemoryAllocateInfo dai{ VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO };
+        dai.allocationSize = dreq.size; dai.memoryTypeIndex = find_memory_type(dreq.memoryTypeBits, VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT);
+        VKD_CHECK(vkAllocateMemory(m_device, &dai, nullptr, &m_depth_mem));
+        VKD_CHECK(vkBindImageMemory(m_device, m_depth_image, m_depth_mem, 0));
+        VkImageViewCreateInfo dvci{ VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO };
+        dvci.image = m_depth_image; dvci.viewType = VK_IMAGE_VIEW_TYPE_2D; dvci.format = VK_FORMAT_D32_SFLOAT;
+        dvci.subresourceRange = { VK_IMAGE_ASPECT_DEPTH_BIT, 0, 1, 0, 1 };
+        VKD_CHECK(vkCreateImageView(m_device, &dvci, nullptr, &m_depth_view));
+
+        m_framebuffers.resize(m_image_views.size());
+        for (size_t i = 0; i < m_image_views.size(); ++i)
+        {
+            VkImageView att[2] = { m_image_views[i], m_depth_view };
+            VkFramebufferCreateInfo fbci{ VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO };
+            fbci.renderPass = m_swapchain_rp; fbci.attachmentCount = 2; fbci.pAttachments = att;
+            fbci.width = m_extent.width; fbci.height = m_extent.height; fbci.layers = 1;
+            VKD_CHECK(vkCreateFramebuffer(m_device, &fbci, nullptr, &m_framebuffers[i]));
+        }
+        return true;
+    }
+
+    auto VulkanDevice::create_command_and_sync() -> bool
+    {
+        VkCommandPoolCreateInfo pci{ VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO };
+        pci.flags = VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT; pci.queueFamilyIndex = m_graphics_family;
+        VKD_CHECK(vkCreateCommandPool(m_device, &pci, nullptr, &m_command_pool));
+        m_command_buffers.resize(MAX_FRAMES_IN_FLIGHT);
+        VkCommandBufferAllocateInfo cbai{ VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO };
+        cbai.commandPool = m_command_pool; cbai.level = VK_COMMAND_BUFFER_LEVEL_PRIMARY; cbai.commandBufferCount = MAX_FRAMES_IN_FLIGHT;
+        VKD_CHECK(vkAllocateCommandBuffers(m_device, &cbai, m_command_buffers.data()));
+
+        m_image_available.resize(MAX_FRAMES_IN_FLIGHT);
+        m_in_flight.resize(MAX_FRAMES_IN_FLIGHT);
+        m_render_finished.resize(m_images.size());
+        m_images_in_flight.assign(m_images.size(), VK_NULL_HANDLE);
+        VkSemaphoreCreateInfo sci{ VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO };
+        VkFenceCreateInfo fci{ VK_STRUCTURE_TYPE_FENCE_CREATE_INFO }; fci.flags = VK_FENCE_CREATE_SIGNALED_BIT;
+        for (int i = 0; i < MAX_FRAMES_IN_FLIGHT; ++i)
+        { VKD_CHECK(vkCreateSemaphore(m_device, &sci, nullptr, &m_image_available[i])); VKD_CHECK(vkCreateFence(m_device, &fci, nullptr, &m_in_flight[i])); }
+        for (size_t i = 0; i < m_images.size(); ++i)
+            VKD_CHECK(vkCreateSemaphore(m_device, &sci, nullptr, &m_render_finished[i]));
+
+        m_frame_pools.resize(MAX_FRAMES_IN_FLIGHT);
+        VkDescriptorPoolSize sizes[2] = {
+            { VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, 512 },
+            { VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, 256 },
+        };
+        for (int i = 0; i < MAX_FRAMES_IN_FLIGHT; ++i)
+        {
+            VkDescriptorPoolCreateInfo dpci{ VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO };
+            dpci.maxSets = 256; dpci.poolSizeCount = 2; dpci.pPoolSizes = sizes;
+            VKD_CHECK(vkCreateDescriptorPool(m_device, &dpci, nullptr, &m_frame_pools[i]));
+        }
+        return true;
+    }
+
+
+    auto VulkanDevice::cleanup_swapchain() -> void
+    {
+        for (auto fb : m_framebuffers) vkDestroyFramebuffer(m_device, fb, nullptr);
+        m_framebuffers.clear();
+        if (m_depth_view)  { vkDestroyImageView(m_device, m_depth_view, nullptr); m_depth_view = VK_NULL_HANDLE; }
+        if (m_depth_image) { vkDestroyImage(m_device, m_depth_image, nullptr); m_depth_image = VK_NULL_HANDLE; }
+        if (m_depth_mem)   { vkFreeMemory(m_device, m_depth_mem, nullptr); m_depth_mem = VK_NULL_HANDLE; }
+        for (auto iv : m_image_views) vkDestroyImageView(m_device, iv, nullptr);
+        m_image_views.clear();
+        if (m_swapchain) { vkDestroySwapchainKHR(m_device, m_swapchain, nullptr); m_swapchain = VK_NULL_HANDLE; }
+    }
+
+    auto VulkanDevice::recreate_swapchain() -> bool
+    {
+        int w = 0, h = 0; glfwGetFramebufferSize(m_window, &w, &h);
+        while (w == 0 || h == 0) { glfwGetFramebufferSize(m_window, &w, &h); glfwWaitEvents(); }
+        m_width = w; m_height = h;
+        vkDeviceWaitIdle(m_device);
+        cleanup_swapchain();
+        if (!create_swapchain())             return false;
+        if (!create_image_views())           return false;
+        if (!create_depth_and_framebuffers())return false;
+        m_images_in_flight.assign(m_images.size(), VK_NULL_HANDLE);
+        return true;
+    }
+
+}
diff --git a/src/rendering/black_hole_renderer.h b/src/rendering/black_hole_renderer.h
index b9c158b..63c5aa2 100644
--- a/src/rendering/black_hole_renderer.h
+++ b/src/rendering/black_hole_renderer.h
@@ -1,7 +1,7 @@
 #pragma once
 
 #include "rhi.h"
-#include "renderer_backend.h"   // BlackHoleParams
+#include "scene/scene_types.h"   // BlackHoleParams
 #include <glm/glm.hpp>
 
 namespace Donut
diff --git a/src/rendering/render_path.cpp b/src/rendering/render_path.cpp
new file mode 100644
index 0000000..172e13c
--- /dev/null
+++ b/src/rendering/render_path.cpp
@@ -0,0 +1,94 @@
+#include "render_path.h"
+
+#include "scene/scene.h"
+
+#include <glm/gtc/matrix_transform.hpp>
+#include <algorithm>
+#include <cmath>
+
+namespace Donut
+{
+    auto RenderPath::init(RHI::Device& device, const std::string& hdri_path) -> bool
+    {
+        m_device = &device;
+        m_hdri_path = hdri_path;
+        m_cubemap = device.create_cubemap_from_hdri(hdri_path);
+
+        m_scene_renderer = create_scope<SceneRenderer>();
+        m_scene_renderer->init(device);
+        m_black_hole_renderer = create_scope<BlackHoleRenderer>();
+        m_black_hole_renderer->init(device);
+        return true;
+    }
+
+    auto RenderPath::sync_hdri(const std::string& hdri_path) -> void
+    {
+        if (hdri_path == m_hdri_path || !m_device) return;
+        m_device->wait_idle();
+        m_cubemap = m_device->create_cubemap_from_hdri(hdri_path);   // old cube freed after idle
+        m_hdri_path = hdri_path;
+    }
+
+    auto RenderPath::render(RHI::CommandList& cmd, Scene& scene, View view,
+                            int fb_width, int fb_height, bool moving, float time) -> void
+    {
+        const glm::vec4 clear(0.05f, 0.06f, 0.10f, 1.0f);
+
+        // The black hole is the only view with an off-screen pass; it renders (and
+        // runs the expensive geodesic) ONLY on the Simulation tab. Scene and None
+        // are a single swapchain pass — None draws nothing (empty viewport).
+        if (view != View::BlackHole)
+        {
+            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();
+                cv.position   = scene.scene_camera.get_orbital_position();
+                cv.fb_width   = fb_width; cv.fb_height = fb_height;
+                m_scene_renderer->render(cmd, cv, scene.objects, scene.selected_object, m_cubemap.get());
+            }
+            m_device->imgui_render(cmd);
+            cmd.end_render_pass();
+        }
+        else
+        {
+            GeodesicView gv;
+            glm::vec3 pos, fwd;
+            if (scene.sim_camera.get_camera_mode() == CameraMode::FPS)
+            {
+                pos = scene.sim_camera.get_position();
+                fwd = scene.sim_camera.get_forward_direction();
+            }
+            else
+            {
+                pos = scene.sim_camera.get_orbital_position();
+                fwd = glm::normalize(scene.sim_camera.get_orbital_target() - pos);
+            }
+            glm::vec3 right = glm::normalize(glm::cross(fwd, glm::vec3(0, 1, 0)));
+            gv.position = pos; gv.right = right; gv.up = glm::cross(right, fwd); gv.forward = fwd;
+            gv.tan_half_fov = (float)tan(glm::radians(scene.black_hole.fov_degrees * 0.5f));
+            gv.aspect = (float)BlackHoleRenderer::GEO_HI_W / (float)BlackHoleRenderer::GEO_HI_H;
+            gv.moving = moving;
+            gv.time = time;
+
+            m_black_hole_renderer->render_geodesic(cmd, gv, scene.black_hole, m_cubemap.get());
+            cmd.begin_render_pass(nullptr, clear);
+            m_black_hole_renderer->blit(cmd, fb_width, fb_height);
+            m_device->imgui_render(cmd);
+            cmd.end_render_pass();
+        }
+    }
+
+    auto RenderPath::shutdown() -> void
+    {
+        m_scene_renderer.reset();
+        m_black_hole_renderer.reset();
+        m_cubemap.reset();
+        // Backend-specific HDRI/GPU resource cleanup is the device's job (see e.g.
+        // the OpenGL device clearing the HDRIManager texture cache on shutdown).
+    }
+}
diff --git a/src/rendering/render_path.h b/src/rendering/render_path.h
new file mode 100644
index 0000000..0d97395
--- /dev/null
+++ b/src/rendering/render_path.h
@@ -0,0 +1,40 @@
+#pragma once
+
+#include "rhi.h"
+#include "view.h"
+#include "scene_renderer.h"
+#include "black_hole_renderer.h"
+#include "core/memory.h"
+
+#include <string>
+
+namespace Donut
+{
+    class Scene;
+
+    // Owns the device-side rendering: the two portable renderers, the shared HDRI
+    // cubemap, and the per-frame composition (off-screen geodesic pass -> present,
+    // or the scene pass), with ImGui drawn on top inside the swapchain pass. The
+    // Application hands it a Scene + View each frame; it knows nothing about the UI.
+    class RenderPath
+    {
+    public:
+        auto init(RHI::Device& device, const std::string& hdri_path) -> bool;
+        auto shutdown() -> void;
+
+        // Rebuilds the environment cubemap if the path changed (device-idle).
+        auto sync_hdri(const std::string& hdri_path) -> void;
+
+        // Composes one frame's viewport into the swapchain command list. `moving`
+        // drives the black hole's progressive resolution; `time` animates the disk.
+        auto render(RHI::CommandList& cmd, Scene& scene, View view,
+                    int fb_width, int fb_height, bool moving, float time) -> void;
+
+    private:
+        RHI::Device*             m_device = nullptr;
+        Scope<SceneRenderer>     m_scene_renderer;
+        Scope<BlackHoleRenderer> m_black_hole_renderer;
+        Ref<RHI::Texture>        m_cubemap;
+        std::string              m_hdri_path;
+    };
+}
diff --git a/src/rendering/scene_renderer.h b/src/rendering/scene_renderer.h
index eafd56e..c3ee02f 100644
--- a/src/rendering/scene_renderer.h
+++ b/src/rendering/scene_renderer.h
@@ -1,7 +1,7 @@
 #pragma once
 
 #include "rhi.h"
-#include "renderer_backend.h"   // SceneObject
+#include "scene/scene_types.h"   // SceneObject
 #include <glm/glm.hpp>
 #include <vector>
 
diff --git a/src/rendering/view.h b/src/rendering/view.h
new file mode 100644
index 0000000..0ac6ae0
--- /dev/null
+++ b/src/rendering/view.h
@@ -0,0 +1,13 @@
+#pragma once
+
+namespace Donut
+{
+    // What the RenderPath draws in the viewport this frame. Each UI workspace
+    // (tab) declares which one it wants, so switching tabs switches the view.
+    enum class View
+    {
+        None,       // empty viewport (tabs that aren't a live view, e.g. Setup / Export)
+        Scene,      // world-builder: grid + placed objects + skybox
+        BlackHole,  // the ray-traced accretion-disk simulation (only the Simulation tab)
+    };
+}
diff --git a/src/scene/scene.cpp b/src/scene/scene.cpp
new file mode 100644
index 0000000..db70a8d
--- /dev/null
+++ b/src/scene/scene.cpp
@@ -0,0 +1,65 @@
+#include "scene.h"
+
+#include <glm/glm.hpp>
+#include <glm/gtc/matrix_transform.hpp>
+#include <algorithm>
+#include <cmath>
+#include <numbers>
+
+namespace Donut
+{
+    Scene::Scene()
+    {
+        // Black-hole camera: large-scale orbital viewer outside the disk.
+        sim_camera.set_camera_mode(CameraMode::Orbital);
+        sim_camera.set_orbital_target(glm::vec3(0.0f));
+        sim_camera.set_orbital_radius(4e11);          // ~31 r_s: outside the 12 r_s disk
+        sim_camera.set_orbital_limits(2.2e11, 1.5e12);
+        sim_camera.set_orbital_speed(0.01f);
+        sim_camera.set_zoom_speed(3e10);
+        sim_camera.set_azimuth(0.0f);
+        sim_camera.set_elevation(1.25f);
+
+        // Scene camera: normal-scale orbital world-builder viewer.
+        scene_camera.set_camera_mode(CameraMode::Orbital);
+        scene_camera.set_orbital_target(glm::vec3(0.0f));
+        scene_camera.set_orbital_radius(15.0);
+        scene_camera.set_orbital_limits(2.0, 200.0);
+        scene_camera.set_orbital_speed(0.01f);
+        scene_camera.set_zoom_speed(2.0);
+        scene_camera.set_azimuth(0.0f);
+        scene_camera.set_elevation((float)std::numbers::pi / 3.0f);
+        scene_camera.update_orbital();
+    }
+
+    auto Scene::reset_sim_camera() -> void
+    {
+        sim_camera.set_camera_mode(CameraMode::Orbital);
+        sim_camera.set_orbital_radius(4e11);
+        sim_camera.set_azimuth(0.0f);
+        sim_camera.set_elevation(1.25f);
+    }
+
+    auto Scene::set_free_fly(bool enabled) -> void
+    {
+        const bool is_fps = sim_camera.get_camera_mode() == CameraMode::FPS;
+        if (enabled == is_fps) return;
+        if (enabled)
+        {
+            // Seed the fly pose from the current orbital framing so the view is continuous.
+            glm::vec3 pos = sim_camera.get_orbital_position();
+            glm::vec3 fwd = glm::normalize(sim_camera.get_orbital_target() - pos);
+            float pitch = glm::degrees(asin(glm::clamp(fwd.y, -1.0f, 1.0f)));
+            float yaw   = glm::degrees(atan2(fwd.z, fwd.x));
+            sim_camera.set_camera_mode(CameraMode::FPS);
+            sim_camera.set_movement_speed(2.0e10f);
+            sim_camera.set_mouse_sensitivity(0.15f);
+            sim_camera.set_position(pos);
+            sim_camera.set_rotation(glm::vec3(pitch, yaw, 0.0f));
+        }
+        else
+        {
+            sim_camera.set_camera_mode(CameraMode::Orbital);  // orbital state was left intact
+        }
+    }
+}
diff --git a/src/scene/scene.h b/src/scene/scene.h
new file mode 100644
index 0000000..27d1327
--- /dev/null
+++ b/src/scene/scene.h
@@ -0,0 +1,39 @@
+#pragma once
+
+#include "scene_types.h"
+#include "core/camera.h"
+
+#include <string>
+#include <vector>
+
+namespace Donut
+{
+    // The document: everything the app edits and renders, independent of any
+    // backend or UI. Workspaces (tabs) read and mutate this; the RenderPath reads
+    // it to draw. It owns the two viewpoints (cameras) as scene state, plus small
+    // camera-framing helpers, since a viewpoint is part of the document.
+    class Scene
+    {
+    public:
+        Scene();
+
+        // world-builder content
+        std::vector<SceneObject> objects{ SceneObject{} };
+        int selected_object = 0;
+
+        // black hole / accretion disk
+        BlackHoleParams black_hole;
+
+        // environment
+        std::string hdri_path = "assets/hdri/hdr_blue_nebulae_1.hdr";
+
+        // viewpoints
+        Camera sim_camera{ 60.0f, 16.0f / 9.0f, 0.1f, 100.0f };     // black-hole view
+        Camera scene_camera{ 45.0f, 16.0f / 9.0f, 0.1f, 1000.0f };  // world-builder view
+
+        // Camera framing helpers (the sim view supports orbital + free-fly).
+        auto reset_sim_camera() -> void;
+        auto set_free_fly(bool enabled) -> void;
+        auto is_free_fly() const -> bool { return sim_camera.get_camera_mode() == CameraMode::FPS; }
+    };
+}
diff --git a/src/rendering/renderer_backend.h b/src/scene/scene_types.h
index d34983f..d34983f 100644
--- a/src/rendering/renderer_backend.h
+++ b/src/scene/scene_types.h
diff --git a/src/ui/ui_layer.cpp b/src/ui/ui_layer.cpp
new file mode 100644
index 0000000..6748be2
--- /dev/null
+++ b/src/ui/ui_layer.cpp
@@ -0,0 +1,275 @@
+#include "ui_layer.h"
+
+#include "scene/scene.h"
+#include "core/settings_manager.h"
+#include "core/hdri_manager.h"
+#include "rendering/render_api.h"
+
+#include <imgui.h>
+#include <glm/glm.hpp>
+#include <string>
+
+namespace Donut
+{
+    // One-time ImGui theme: rounded, roomy, dark with a warm accretion-disk accent.
+    static auto apply_donut_style() -> void
+    {
+        ImGuiStyle& s = ImGui::GetStyle();
+        s.WindowRounding = 7.0f; s.ChildRounding = 5.0f; s.FrameRounding = 4.0f;
+        s.GrabRounding = 4.0f; s.PopupRounding = 4.0f; s.ScrollbarRounding = 5.0f; s.TabRounding = 4.0f;
+        s.WindowPadding = ImVec2(12, 12); s.FramePadding = ImVec2(9, 5);
+        s.ItemSpacing = ImVec2(9, 8); s.ItemInnerSpacing = ImVec2(7, 5);
+        s.WindowBorderSize = 0.0f; s.FrameBorderSize = 0.0f; s.WindowTitleAlign = ImVec2(0.02f, 0.5f);
+
+        const ImVec4 amber   = ImVec4(0.98f, 0.62f, 0.20f, 1.00f);
+        const ImVec4 amberHi = ImVec4(1.00f, 0.73f, 0.36f, 1.00f);
+        ImVec4* c = s.Colors;
+        c[ImGuiCol_WindowBg]        = ImVec4(0.07f, 0.08f, 0.10f, 0.97f);
+        c[ImGuiCol_ChildBg]         = ImVec4(0.10f, 0.11f, 0.13f, 0.55f);
+        c[ImGuiCol_PopupBg]         = ImVec4(0.09f, 0.10f, 0.12f, 0.98f);
+        c[ImGuiCol_TitleBg]         = ImVec4(0.09f, 0.10f, 0.12f, 1.00f);
+        c[ImGuiCol_TitleBgActive]   = ImVec4(0.13f, 0.14f, 0.17f, 1.00f);
+        c[ImGuiCol_Text]            = ImVec4(0.90f, 0.91f, 0.93f, 1.00f);
+        c[ImGuiCol_TextDisabled]    = ImVec4(0.48f, 0.50f, 0.54f, 1.00f);
+        c[ImGuiCol_FrameBg]         = ImVec4(0.16f, 0.17f, 0.20f, 1.00f);
+        c[ImGuiCol_FrameBgHovered]  = ImVec4(0.22f, 0.24f, 0.28f, 1.00f);
+        c[ImGuiCol_FrameBgActive]   = ImVec4(0.26f, 0.28f, 0.33f, 1.00f);
+        c[ImGuiCol_Header]          = ImVec4(0.17f, 0.19f, 0.23f, 1.00f);
+        c[ImGuiCol_HeaderHovered]   = ImVec4(0.24f, 0.27f, 0.32f, 1.00f);
+        c[ImGuiCol_HeaderActive]    = ImVec4(0.28f, 0.31f, 0.37f, 1.00f);
+        c[ImGuiCol_Button]          = ImVec4(0.20f, 0.22f, 0.26f, 1.00f);
+        c[ImGuiCol_ButtonHovered]   = ImVec4(0.27f, 0.30f, 0.35f, 1.00f);
+        c[ImGuiCol_ButtonActive]    = amber;
+        c[ImGuiCol_SliderGrab]      = amber;
+        c[ImGuiCol_SliderGrabActive]= amberHi;
+        c[ImGuiCol_CheckMark]       = amberHi;
+        c[ImGuiCol_Tab]             = ImVec4(0.13f, 0.14f, 0.17f, 1.00f);
+        c[ImGuiCol_TabHovered]      = ImVec4(0.28f, 0.31f, 0.37f, 1.00f);
+        c[ImGuiCol_TabActive]       = ImVec4(0.22f, 0.24f, 0.28f, 1.00f);
+        c[ImGuiCol_Separator]       = ImVec4(0.20f, 0.22f, 0.26f, 1.00f);
+        c[ImGuiCol_ScrollbarGrab]   = ImVec4(0.24f, 0.26f, 0.30f, 1.00f);
+    }
+
+    namespace
+    {
+        // Setup: renderer backend + environment
+        class SetupWorkspace : public Workspace
+        {
+        public:
+            auto name() const -> const char* override { return "Setup"; }
+            auto view() const -> View override { return View::None; }
+            auto on_ui(const UIContext& ctx) -> void override
+            {
+                if (ImGui::CollapsingHeader("Renderer", ImGuiTreeNodeFlags_DefaultOpen))
+                {
+                    auto& s = SettingsManager::get_settings();
+                    const char* apis[] = { "OpenGL", "Vulkan" };
+                    int cur = (s.graphics.render_api == "Vulkan") ? 1 : 0;
+                    if (ImGui::Combo("Graphics API", &cur, apis, 2))
+                    {
+                        s.graphics.render_api = apis[cur];
+                        SettingsManager::save_settings();
+                    }
+                    const char* running = (RendererAPI::get_api() == RendererAPI::API::Vulkan) ? "Vulkan" : "OpenGL";
+                    if (s.graphics.render_api != running)
+                        ImGui::TextColored(ImVec4(0.98f, 0.62f, 0.20f, 1.0f), "Restart to apply (%s running)", running);
+                    else
+                        ImGui::TextDisabled("Active backend: %s", running);
+                }
+
+                if (ImGui::CollapsingHeader("Environment", ImGuiTreeNodeFlags_DefaultOpen))
+                {
+                    auto& hdri = HDRIManager::get();
+                    std::string preview = hdri.get_hdri_name(ctx.scene.hdri_path);
+                    if (ImGui::BeginCombo("Starfield", preview.c_str()))
+                    {
+                        for (const auto& path : hdri.get_available_hdri())
+                        {
+                            bool selected = (path == ctx.scene.hdri_path);
+                            if (ImGui::Selectable(hdri.get_hdri_name(path).c_str(), selected))
+                                ctx.scene.hdri_path = path;   // RenderPath rebuilds the cubemap next frame
+                            if (selected) ImGui::SetItemDefaultFocus();
+                        }
+                        ImGui::EndCombo();
+                    }
+                    ImGui::TextDisabled("Switching rebuilds the cubemap (brief pause).");
+                }
+            }
+        };
+
+        // Scene: place and edit objects
+        class SceneWorkspace : public Workspace
+        {
+        public:
+            auto name() const -> const char* override { return "Scene"; }
+            auto view() const -> View override { return View::Scene; }
+            auto on_ui(const UIContext& ctx) -> void override
+            {
+                Scene& sc = ctx.scene;
+                ImGui::TextDisabled("Drag to orbit, scroll to zoom. HDRI skybox behind.");
+                auto& objs = sc.objects;
+                if (sc.selected_object >= (int)objs.size()) sc.selected_object = (int)objs.size() - 1;
+
+                ImGui::Text("Spheres (%d)", (int)objs.size());
+                if (ImGui::Button("Add") && objs.size() < 64)
+                {
+                    SceneObject o;
+                    o.position = glm::vec3(((int)objs.size() % 5) * 5.0f - 10.0f, 2.0f, ((int)objs.size() / 5) * 5.0f);
+                    o.radius   = 1.5f;
+                    o.color    = glm::vec3(0.35f + 0.12f * (objs.size() % 5), 0.55f, 0.9f - 0.12f * (objs.size() % 4));
+                    objs.push_back(o);
+                    sc.selected_object = (int)objs.size() - 1;
+                }
+                ImGui::SameLine();
+                if (ImGui::Button("Delete") && !objs.empty())
+                {
+                    objs.erase(objs.begin() + sc.selected_object);
+                    if (sc.selected_object >= (int)objs.size()) sc.selected_object = (int)objs.size() - 1;
+                }
+
+                ImGui::BeginChild("obj_list", ImVec2(0, 120), true);
+                for (int i = 0; i < (int)objs.size(); ++i)
+                {
+                    std::string label = "Sphere " + std::to_string(i);
+                    if (ImGui::Selectable(label.c_str(), sc.selected_object == i)) sc.selected_object = i;
+                }
+                ImGui::EndChild();
+
+                if (sc.selected_object >= 0 && sc.selected_object < (int)objs.size())
+                {
+                    SceneObject& o = objs[sc.selected_object];
+                    ImGui::DragFloat3("Position", &o.position.x, 0.1f);
+                    ImGui::DragFloat("Radius", &o.radius, 0.05f, 0.1f, 20.0f);
+                    ImGui::ColorEdit3("Color", &o.color.x);
+                }
+            }
+        };
+
+        // Simulation: camera + accretion disk + quality
+        class SimulationWorkspace : public Workspace
+        {
+        public:
+            auto name() const -> const char* override { return "Simulation"; }
+            auto view() const -> View override { return View::BlackHole; }
+            auto on_ui(const UIContext& ctx) -> void override
+            {
+                Scene& sc = ctx.scene;
+                BlackHoleParams& bh = sc.black_hole;
+
+                if (ImGui::CollapsingHeader("Camera", ImGuiTreeNodeFlags_DefaultOpen))
+                {
+                    bool ff = sc.is_free_fly();
+                    if (ImGui::RadioButton("Orbital", !ff)) sc.set_free_fly(false);
+                    ImGui::SameLine();
+                    if (ImGui::RadioButton("Free-fly", ff)) sc.set_free_fly(true);
+                    ImGui::SameLine();
+                    if (ImGui::Button("Reset view")) sc.reset_sim_camera();
+                    ImGui::SliderFloat("FOV", &bh.fov_degrees, 20.0f, 90.0f, "%.0f\xc2\xb0");
+                    ImGui::TextDisabled(ff ? "WASD move | Q/E down-up | Shift boost | drag look"
+                                           : "Drag to orbit | scroll to zoom");
+                }
+
+                if (ImGui::CollapsingHeader("Accretion disk", ImGuiTreeNodeFlags_DefaultOpen))
+                {
+                    ImGui::SliderFloat("Temperature", &bh.temperature, 2000.0f, 15000.0f, "%.0f K");
+                    ImGui::SliderFloat("Brightness",  &bh.brightness, 0.0f, 3.0f, "%.2f");
+                    ImGui::SliderFloat("Inner radius", &bh.disk_inner_rs, 3.0f, 12.0f, "%.1f r_s");
+                    if (bh.disk_outer_rs < bh.disk_inner_rs + 0.5f) bh.disk_outer_rs = bh.disk_inner_rs + 0.5f;
+                    ImGui::SliderFloat("Outer radius", &bh.disk_outer_rs, bh.disk_inner_rs + 0.5f, 25.0f, "%.1f r_s");
+                    ImGui::SliderFloat("Turbulence",  &bh.turbulence, 0.0f, 2.0f, "%.2f");
+                    ImGui::TextDisabled("Inner edge is the ISCO (3 r_s). Novikov-Thorne profile.");
+                }
+
+                if (ImGui::CollapsingHeader("Quality"))
+                {
+                    ImGui::SliderInt("Integration steps", &bh.quality_steps, 2000, 15000);
+                    ImGui::TextDisabled("Deeper lensing at higher cost. Settled frame is 4x supersampled.");
+                }
+            }
+        };
+
+        // Export: pick what to render out (not wired up yet)
+        class ExportWorkspace : public Workspace
+        {
+        public:
+            auto name() const -> const char* override { return "Export"; }
+            auto view() const -> View override { return View::None; }
+            auto on_ui(const UIContext&) -> void override
+            {
+                ImGui::TextDisabled("Render observables to disk for analysis.");
+                ImGui::Spacing();
+                if (ImGui::CollapsingHeader("Channels", ImGuiTreeNodeFlags_DefaultOpen))
+                {
+                    ImGui::Checkbox("Colour (tonemapped)",   &m_color);
+                    ImGui::Checkbox("Redshift (g)",          &m_redshift);
+                    ImGui::Checkbox("Emission temperature",  &m_temperature);
+                    ImGui::Checkbox("Impact parameter",      &m_impact);
+                }
+                if (ImGui::CollapsingHeader("Output", ImGuiTreeNodeFlags_DefaultOpen))
+                {
+                    ImGui::Combo("Resolution", &m_resolution, "960 x 540\0" "1920 x 1080\0" "3840 x 2160\0");
+                    ImGui::Combo("Format",     &m_format,     "PNG\0" "EXR (HDR)\0" "CSV (data)\0");
+                }
+                ImGui::Spacing();
+                ImGui::BeginDisabled();
+                ImGui::Button("Export frame", ImVec2(-1.0f, 0.0f));
+                ImGui::EndDisabled();
+                ImGui::TextDisabled("Not wired up yet: needs the RHI readback path + G-buffer shader outputs.");
+            }
+        private:
+            bool m_color = true, m_redshift = false, m_temperature = false, m_impact = false;
+            int  m_resolution = 1, m_format = 0;
+        };
+    }
+
+    UILayer::UILayer()
+    {
+        m_workspaces.push_back(create_scope<SetupWorkspace>());
+        m_workspaces.push_back(create_scope<SceneWorkspace>());
+        m_workspaces.push_back(create_scope<SimulationWorkspace>());
+        m_workspaces.push_back(create_scope<ExportWorkspace>());
+
+        // Open on Simulation so the black hole greets the user on launch.
+        for (int i = 0; i < (int)m_workspaces.size(); ++i)
+            if (std::string(m_workspaces[i]->name()) == "Simulation") { m_landing = i; m_active = i; }
+    }
+
+    auto UILayer::draw(const UIContext& ctx) -> View
+    {
+        static bool styled = false;
+        if (!styled) { apply_donut_style(); styled = true; }
+
+        // Full-viewport dock space with a pass-through centre, so the panel docks to
+        // any edge while the render shows through the middle.
+        ImGui::DockSpaceOverViewport(0, ImGui::GetMainViewport(), ImGuiDockNodeFlags_PassthruCentralNode);
+
+        ImGui::SetNextWindowSize(ImVec2(360, 620), ImGuiCond_FirstUseEver);
+        ImGui::Begin("Donut");
+
+        ImGuiIO& io = ImGui::GetIO();
+        ImGui::TextDisabled("%s", ctx.device_name.empty() ? "GPU" : ctx.device_name.c_str());
+        ImGui::Text("%.0f FPS", io.Framerate);
+        ImGui::SameLine(); ImGui::TextDisabled("%.1f ms/frame", io.Framerate > 0 ? 1000.0f / io.Framerate : 0.0f);
+        ImGui::Spacing();
+
+        if (ImGui::BeginTabBar("workspaces"))
+        {
+            for (int i = 0; i < (int)m_workspaces.size(); ++i)
+            {
+                ImGuiTabItemFlags flags = (!m_landed && i == m_landing) ? ImGuiTabItemFlags_SetSelected : 0;
+                if (ImGui::BeginTabItem(m_workspaces[i]->name(), nullptr, flags))
+                {
+                    m_active = i;
+                    ImGui::Spacing();
+                    m_workspaces[i]->on_ui(ctx);
+                    ImGui::EndTabItem();
+                }
+            }
+            ImGui::EndTabBar();
+            m_landed = true;
+        }
+        ImGui::End();
+
+        return m_workspaces[m_active]->view();
+    }
+}
diff --git a/src/ui/ui_layer.h b/src/ui/ui_layer.h
new file mode 100644
index 0000000..67c9d8f
--- /dev/null
+++ b/src/ui/ui_layer.h
@@ -0,0 +1,27 @@
+#pragma once
+
+#include "workspace.h"
+#include "rendering/view.h"
+#include "core/memory.h"
+
+#include <vector>
+
+namespace Donut
+{
+    // The Dorico-style tab strip. Owns the workspaces (Setup / Scene / Simulation
+    // / Export); each frame it draws the dock space, the shared header, the tab
+    // bar, and delegates the active tab's panels. Returns the active workspace's
+    // View so the Application knows what the RenderPath should draw.
+    class UILayer
+    {
+    public:
+        UILayer();
+        auto draw(const UIContext& ctx) -> View;
+
+    private:
+        std::vector<Scope<Workspace>> m_workspaces;
+        int  m_active  = 0;
+        int  m_landing = 0;      // tab selected on the first frame
+        bool m_landed  = false;
+    };
+}
diff --git a/src/ui/workspace.h b/src/ui/workspace.h
new file mode 100644
index 0000000..134d517
--- /dev/null
+++ b/src/ui/workspace.h
@@ -0,0 +1,29 @@
+#pragma once
+
+#include "rendering/view.h"
+#include <string>
+
+namespace Donut
+{
+    class Scene;
+
+    // What a workspace gets each frame to build its panels. `scene` is mutable —
+    // workspaces edit the document through it.
+    struct UIContext
+    {
+        Scene&      scene;
+        std::string device_name;
+    };
+
+    // A Dorico-style workspace: one tab that owns its side panels and declares
+    // which viewport View it shows. Switching tabs switches both. Concrete
+    // workspaces (Setup / Scene / Simulation / Export) live in ui_layer.cpp.
+    class Workspace
+    {
+    public:
+        virtual ~Workspace() = default;
+        virtual auto name() const -> const char* = 0;
+        virtual auto view() const -> View = 0;
+        virtual auto on_ui(const UIContext& ctx) -> void = 0;
+    };
+}