[RendererVK] Implement multi-viewport

src/app.cpp

@@ -180,6 +180,30 @@ static void register_events() {
     AppEvent::audio_device_removed_event = SDL_RegisterEvents(1);
 }
 
+static void imgui_renderer_create_window(ImGuiViewport* viewport) {
+    g_renderer->add_viewport(viewport);
+}
+
+static void imgui_renderer_destroy_window(ImGuiViewport* viewport) {
+    g_renderer->remove_viewport(viewport);
+}
+
+static void imgui_renderer_set_window_size(ImGuiViewport* viewport, ImVec2 size) {
+
+}
+
+static void imgui_renderer_render_window(ImGuiViewport* viewport, void* userdata) {
+    Framebuffer* fb = (Framebuffer*)viewport->RendererUserData;
+    //Log::info("{} {}", fb->width, fb->height);
+    g_renderer->begin_draw((Framebuffer*)viewport->RendererUserData, {0.0f, 0.0f, 0.0f, 1.0f});
+    g_renderer->render_imgui_draw_data(viewport->DrawData);
+    g_renderer->finish_draw();
+}
+
+static void imgui_renderer_swap_buffers(ImGuiViewport* viewport, void* userdata) {
+
+}
+
 void app_init() {
     // Init SDL & create main window
     if (SDL_Init(SDL_INIT_VIDEO | SDL_INIT_EVENTS) < 0) {
@@ -213,14 +237,22 @@ void app_init() {
 
     ImGuiIO& io = ImGui::GetIO();
     // io.ConfigFlags |= ImGuiConfigFlags_NavEnableKeyboard;
-    // io.ConfigFlags |= ImGuiConfigFlags_ViewportsEnable;
+    io.ConfigFlags |= ImGuiConfigFlags_ViewportsEnable;
     io.ConfigFlags |= ImGuiConfigFlags_DockingEnable;
     io.ConfigViewportsNoTaskBarIcon = false;
     io.IniFilename = ".whitebox/ui.ini";
 
     init_font_assets();
     apply_theme(ImGui::GetStyle());
-    init_renderer(new_window);
+    init_renderer(main_window);
+
+    ImGuiPlatformIO& platform_io = ImGui::GetPlatformIO();
+    platform_io.Renderer_CreateWindow = imgui_renderer_create_window;
+    platform_io.Renderer_DestroyWindow = imgui_renderer_destroy_window;
+    platform_io.Renderer_SetWindowSize = imgui_renderer_set_window_size;
+    platform_io.Renderer_RenderWindow = imgui_renderer_render_window;
+    platform_io.Renderer_SwapBuffers = imgui_renderer_swap_buffers;
+
     g_cmd_manager.init(10);
     g_timeline.init();
     g_engine.set_bpm(150.0f);
@@ -466,10 +498,10 @@ void app_render() {
     g_renderer->begin_draw(nullptr, {0.0f, 0.0f, 0.0f, 1.0f});
     g_renderer->render_imgui_draw_data(ImGui::GetDrawData());
     g_renderer->finish_draw();
+    ImGui::UpdatePlatformWindows();
+    ImGui::RenderPlatformWindowsDefault();
     g_renderer->end_frame();
     g_renderer->present();
-    // ImGui::UpdatePlatformWindows();
-    // ImGui::RenderPlatformWindowsDefault();
 
     if (!g_file_drop.empty()) {
         g_file_drop.clear();

src/gfx/renderer.cpp

@@ -7,9 +7,9 @@ namespace wb {
 
 Renderer* g_renderer = nullptr;
 
-void init_renderer(SDL_Window* main_window) {
+void init_renderer(SDL_Window* window) {
     Log::info("Initializing renderer...");
-    g_renderer = RendererVK::create(main_window);
+    g_renderer = RendererVK::create(window);
     if (!g_renderer)
         Log::error("Failed to create renderer");
 }

src/gfx/renderer.h

@@ -2,12 +2,12 @@
 
 #include "core/common.h"
 #include "core/vector.h"
+#include "draw.h"
 #include "engine/clip.h"
 #include "engine/sample.h"
 #include "engine/sample_peaks.h"
-#include "draw.h"
-#include <imgui.h>
 #include <SDL_video.h>
+#include <imgui.h>
 #include <memory>
 
 namespace wb {
@@ -69,32 +69,29 @@ struct Renderer {
 
     virtual ~Renderer() {}
     virtual std::shared_ptr<Framebuffer> create_framebuffer(uint32_t width, uint32_t height) = 0;
-    virtual std::shared_ptr<SamplePeaks> create_sample_peaks(const Sample& sample,
-                                                             SamplePeaksPrecision precision) = 0;
+    virtual std::shared_ptr<SamplePeaks> create_sample_peaks(const Sample& sample, SamplePeaksPrecision precision) = 0;
     virtual void resize_swapchain() = 0;
     virtual void new_frame() = 0;
     virtual void end_frame() = 0;
     virtual void set_framebuffer(const std::shared_ptr<Framebuffer>& framebuffer) = 0;
-    virtual void begin_draw(const std::shared_ptr<Framebuffer>& framebuffer,
-                            const ImVec4& clear_color) = 0;
+    virtual void begin_draw(Framebuffer* framebuffer, const ImVec4& clear_color) = 0;
     virtual void finish_draw() = 0;
     virtual void clear(float r, float g, float b, float a) = 0;
-    virtual ImTextureID
-    prepare_as_imgui_texture(const std::shared_ptr<Framebuffer>& framebuffer) = 0;
+    virtual ImTextureID prepare_as_imgui_texture(const std::shared_ptr<Framebuffer>& framebuffer) = 0;
     virtual void fill_polygon(const ImVec2* points, uint32_t count) = 0;
     virtual void fill_path(const Path& path, uint32_t color) = 0;
     virtual void draw_waveforms(const ImVector<ClipContentDrawCmd>& clips) = 0;
     virtual void render_draw_command_list(DrawCommandList* command_list) = 0;
     virtual void render_imgui_draw_data(ImDrawData* draw_data) = 0;
+    virtual bool add_viewport(ImGuiViewport* viewport) { return false; }
+    virtual bool remove_viewport(ImGuiViewport* viewport) { return false; }
     virtual void present() = 0;
 
-    inline void clear(const ImColor& color) {
-        clear(color.Value.x, color.Value.y, color.Value.z, color.Value.w);
-    }
+    inline void clear(const ImColor& color) { clear(color.Value.x, color.Value.y, color.Value.z, color.Value.w); }
 };
 
 extern Renderer* g_renderer;
-void init_renderer(SDL_Window* main_window);
+void init_renderer(SDL_Window* window);
 void shutdown_renderer();
 
 } // namespace wb

src/gfx/renderer_d3d11.cpp

@@ -2,8 +2,8 @@
 
 #ifdef WB_PLATFORM_WINDOWS
 
-#include "renderer_d3d11.h"
 #include "core/debug.h"
+#include "renderer_d3d11.h"
 #include <SDL_loadso.h>
 #include <SDL_syswm.h>
 #include <imgui_impl_dx11.h>
@@ -48,8 +48,7 @@ static ID3D11PixelShader* load_ps(ID3D11Device* device, const char* file) {
     return shader.Detach();
 }
 
-RendererD3D11::RendererD3D11(IDXGISwapChain2* swapchain, ID3D11Device* device,
-                             ID3D11DeviceContext* ctx) :
+RendererD3D11::RendererD3D11(IDXGISwapChain2* swapchain, ID3D11Device* device, ID3D11DeviceContext* ctx) :
     swapchain_(swapchain), device_(device), ctx_(ctx) {
     swapchain_->SetMaximumFrameLatency(1);
     frame_latency_waitable_handle_ = swapchain->GetFrameLatencyWaitableObject();
@@ -185,8 +184,7 @@ std::shared_ptr<Framebuffer> RendererD3D11::create_framebuffer(uint32_t width, u
     return ret;
 }
 
-std::shared_ptr<SamplePeaks> RendererD3D11::create_sample_peaks(const Sample& sample,
-                                                                SamplePeaksPrecision precision) {
+std::shared_ptr<SamplePeaks> RendererD3D11::create_sample_peaks(const Sample& sample, SamplePeaksPrecision precision) {
     size_t sample_count = sample.count;
     uint32_t current_mip = 1;
     uint32_t max_mip = 0;
@@ -234,8 +232,8 @@ std::shared_ptr<SamplePeaks> RendererD3D11::create_sample_peaks(const Sample& sa
         D3D11_MAPPED_SUBRESOURCE staging;
         ctx_->Map(staging_buffer.Get(), 0, D3D11_MAP_WRITE, 0, &staging);
         for (uint32_t i = 0; i < sample.channels; i++) {
-            sample.summarize_for_mipmaps(precision, i, current_mip, required_length * i,
-                                         &required_length, staging.pData);
+            sample.summarize_for_mipmaps(precision, i, current_mip, required_length * i, &required_length,
+                                         staging.pData);
         }
         ctx_->Unmap(staging_buffer.Get(), 0);
 
@@ -374,8 +372,7 @@ void RendererD3D11::set_framebuffer(const std::shared_ptr<Framebuffer>& framebuf
     // vmask_target_ = impl->rtv;
 }
 
-void RendererD3D11::begin_draw(const std::shared_ptr<Framebuffer>& framebuffer,
-                               const ImVec4& clear_color) {
+void RendererD3D11::begin_draw(Framebuffer* framebuffer, const ImVec4& clear_color) {
 }
 
 void RendererD3D11::finish_draw() {
@@ -477,8 +474,7 @@ Renderer* RendererD3D11::create(SDL_Window* window) {
 
     // Manually link d3d11 library
     PFN_D3D11_CREATE_DEVICE_AND_SWAP_CHAIN d3d11_create_device_and_swap_chain =
-        (PFN_D3D11_CREATE_DEVICE_AND_SWAP_CHAIN)SDL_LoadFunction(d3d11_dll,
-                                                                 "D3D11CreateDeviceAndSwapChain");
+        (PFN_D3D11_CREATE_DEVICE_AND_SWAP_CHAIN)SDL_LoadFunction(d3d11_dll, "D3D11CreateDeviceAndSwapChain");
 
     HWND hwnd;
     SDL_SysWMinfo wm_info {};
@@ -508,8 +504,7 @@ Renderer* RendererD3D11::create(SDL_Window* window) {
         .OutputWindow = hwnd,
         .Windowed = TRUE,
         .SwapEffect = DXGI_SWAP_EFFECT_FLIP_DISCARD,
-        .Flags = DXGI_SWAP_CHAIN_FLAG_ALLOW_MODE_SWITCH |
-                 DXGI_SWAP_CHAIN_FLAG_FRAME_LATENCY_WAITABLE_OBJECT,
+        .Flags = DXGI_SWAP_CHAIN_FLAG_ALLOW_MODE_SWITCH | DXGI_SWAP_CHAIN_FLAG_FRAME_LATENCY_WAITABLE_OBJECT,
     };
 
     static const D3D_FEATURE_LEVEL feature_level = D3D_FEATURE_LEVEL_11_0;
@@ -519,9 +514,9 @@ Renderer* RendererD3D11::create(SDL_Window* window) {
     ID3D11Device* device;
     ID3D11DeviceContext* ctx;
 
-    HRESULT result = d3d11_create_device_and_swap_chain(
-        nullptr, D3D_DRIVER_TYPE_HARDWARE, nullptr, device_flags, &feature_level, 1,
-        D3D11_SDK_VERSION, &swapchain_desc, &swapchain, &device, nullptr, &ctx);
+    HRESULT result =
+        d3d11_create_device_and_swap_chain(nullptr, D3D_DRIVER_TYPE_HARDWARE, nullptr, device_flags, &feature_level, 1,
+                                           D3D11_SDK_VERSION, &swapchain_desc, &swapchain, &device, nullptr, &ctx);
 
     if (FAILED(result))
         return {};

src/gfx/renderer_d3d11.h

@@ -4,10 +4,10 @@
 
 #ifdef WB_PLATFORM_WINDOWS
 #include "renderer.h"
+#include <SDL_video.h>
 #include <d3d11.h>
 #include <dxgi1_3.h>
 #include <vector>
-#include <SDL_video.h>
 
 #undef min
 #undef max
@@ -79,14 +79,12 @@ struct RendererD3D11 : public Renderer {
     ~RendererD3D11();
     bool init();
     std::shared_ptr<Framebuffer> create_framebuffer(uint32_t width, uint32_t height) override;
-    std::shared_ptr<SamplePeaks> create_sample_peaks(const Sample& sample,
-                                                     SamplePeaksPrecision precision) override;
+    std::shared_ptr<SamplePeaks> create_sample_peaks(const Sample& sample, SamplePeaksPrecision precision) override;
     void new_frame() override;
     void end_frame() override;
     void resize_swapchain() override;
     void set_framebuffer(const std::shared_ptr<Framebuffer>& framebuffer) override;
-    void begin_draw(const std::shared_ptr<Framebuffer>& framebuffer,
-                    const ImVec4& clear_color) override;
+    void begin_draw(Framebuffer* framebuffer, const ImVec4& clear_color) override;
     void finish_draw() override;
     void clear(float r, float g, float b, float a) override;
     ImTextureID prepare_as_imgui_texture(const std::shared_ptr<Framebuffer>& framebuffer) override;