From 36a0d1028ca1d741d0e31a94e163d62f6c8d0345 Mon Sep 17 00:00:00 2001 From: ocornut Date: Tue, 29 Jun 2021 15:34:54 +0200 Subject: [PATCH] Backends: Viewports: renamed viewport storage structures ImGuiViewportDataXXXX -> ImGui_ImplXXXX_ViewportData and locals (matching naming convention in 70c60385) --- backends/imgui_impl_dx10.cpp | 66 +++++++-------- backends/imgui_impl_dx11.cpp | 66 +++++++-------- backends/imgui_impl_dx12.cpp | 146 ++++++++++++++++---------------- backends/imgui_impl_dx9.cpp | 70 ++++++++-------- backends/imgui_impl_glfw.cpp | 130 ++++++++++++++--------------- backends/imgui_impl_sdl.cpp | 112 ++++++++++++------------- backends/imgui_impl_vulkan.cpp | 56 ++++++------- backends/imgui_impl_vulkan.h | 2 +- backends/imgui_impl_win32.cpp | 148 ++++++++++++++++----------------- 9 files changed, 398 insertions(+), 398 deletions(-) diff --git a/backends/imgui_impl_dx10.cpp b/backends/imgui_impl_dx10.cpp index ca8cb5da..973d2aa3 100644 --- a/backends/imgui_impl_dx10.cpp +++ b/backends/imgui_impl_dx10.cpp @@ -584,20 +584,20 @@ void ImGui_ImplDX10_NewFrame() //-------------------------------------------------------------------------------------------------------- // Helper structure we store in the void* RenderUserData field of each ImGuiViewport to easily retrieve our backend data. -struct ImGuiViewportDataDx10 +struct ImGui_ImplDX10_ViewportData { - IDXGISwapChain* SwapChain; - ID3D10RenderTargetView* RTView; + IDXGISwapChain* SwapChain; + ID3D10RenderTargetView* RTView; - ImGuiViewportDataDx10() { SwapChain = NULL; RTView = NULL; } - ~ImGuiViewportDataDx10() { IM_ASSERT(SwapChain == NULL && RTView == NULL); } + ImGui_ImplDX10_ViewportData() { SwapChain = NULL; RTView = NULL; } + ~ImGui_ImplDX10_ViewportData() { IM_ASSERT(SwapChain == NULL && RTView == NULL); } }; static void ImGui_ImplDX10_CreateWindow(ImGuiViewport* viewport) { ImGui_ImplDX10_Data* bd = ImGui_ImplDX10_GetBackendData(); - ImGuiViewportDataDx10* data = IM_NEW(ImGuiViewportDataDx10)(); - viewport->RendererUserData = data; + ImGui_ImplDX10_ViewportData* vd = IM_NEW(ImGui_ImplDX10_ViewportData)(); + viewport->RendererUserData = vd; // PlatformHandleRaw should always be a HWND, whereas PlatformHandle might be a higher-level handle (e.g. GLFWWindow*, SDL_Window*). // Some backends will leave PlatformHandleRaw NULL, in which case we assume PlatformHandle will contain the HWND. @@ -619,15 +619,15 @@ static void ImGui_ImplDX10_CreateWindow(ImGuiViewport* viewport) sd.SwapEffect = DXGI_SWAP_EFFECT_DISCARD; sd.Flags = 0; - IM_ASSERT(data->SwapChain == NULL && data->RTView == NULL); - bd->pFactory->CreateSwapChain(bd->pd3dDevice, &sd, &data->SwapChain); + IM_ASSERT(vd->SwapChain == NULL && vd->RTView == NULL); + bd->pFactory->CreateSwapChain(bd->pd3dDevice, &sd, &vd->SwapChain); // Create the render target - if (data->SwapChain) + if (vd->SwapChain) { ID3D10Texture2D* pBackBuffer; - data->SwapChain->GetBuffer(0, IID_PPV_ARGS(&pBackBuffer)); - bd->pd3dDevice->CreateRenderTargetView(pBackBuffer, NULL, &data->RTView); + vd->SwapChain->GetBuffer(0, IID_PPV_ARGS(&pBackBuffer)); + bd->pd3dDevice->CreateRenderTargetView(pBackBuffer, NULL, &vd->RTView); pBackBuffer->Release(); } } @@ -635,15 +635,15 @@ static void ImGui_ImplDX10_CreateWindow(ImGuiViewport* viewport) static void ImGui_ImplDX10_DestroyWindow(ImGuiViewport* viewport) { // The main viewport (owned by the application) will always have RendererUserData == NULL here since we didn't create the data for it. - if (ImGuiViewportDataDx10* data = (ImGuiViewportDataDx10*)viewport->RendererUserData) + if (ImGui_ImplDX10_ViewportData* vd = (ImGui_ImplDX10_ViewportData*)viewport->RendererUserData) { - if (data->SwapChain) - data->SwapChain->Release(); - data->SwapChain = NULL; - if (data->RTView) - data->RTView->Release(); - data->RTView = NULL; - IM_DELETE(data); + if (vd->SwapChain) + vd->SwapChain->Release(); + vd->SwapChain = NULL; + if (vd->RTView) + vd->RTView->Release(); + vd->RTView = NULL; + IM_DELETE(vd); } viewport->RendererUserData = NULL; } @@ -651,19 +651,19 @@ static void ImGui_ImplDX10_DestroyWindow(ImGuiViewport* viewport) static void ImGui_ImplDX10_SetWindowSize(ImGuiViewport* viewport, ImVec2 size) { ImGui_ImplDX10_Data* bd = ImGui_ImplDX10_GetBackendData(); - ImGuiViewportDataDx10* data = (ImGuiViewportDataDx10*)viewport->RendererUserData; - if (data->RTView) + ImGui_ImplDX10_ViewportData* vd = (ImGui_ImplDX10_ViewportData*)viewport->RendererUserData; + if (vd->RTView) { - data->RTView->Release(); - data->RTView = NULL; + vd->RTView->Release(); + vd->RTView = NULL; } - if (data->SwapChain) + if (vd->SwapChain) { ID3D10Texture2D* pBackBuffer = NULL; - data->SwapChain->ResizeBuffers(0, (UINT)size.x, (UINT)size.y, DXGI_FORMAT_UNKNOWN, 0); - data->SwapChain->GetBuffer(0, IID_PPV_ARGS(&pBackBuffer)); + vd->SwapChain->ResizeBuffers(0, (UINT)size.x, (UINT)size.y, DXGI_FORMAT_UNKNOWN, 0); + vd->SwapChain->GetBuffer(0, IID_PPV_ARGS(&pBackBuffer)); if (pBackBuffer == NULL) { fprintf(stderr, "ImGui_ImplDX10_SetWindowSize() failed creating buffers.\n"); return; } - bd->pd3dDevice->CreateRenderTargetView(pBackBuffer, NULL, &data->RTView); + bd->pd3dDevice->CreateRenderTargetView(pBackBuffer, NULL, &vd->RTView); pBackBuffer->Release(); } } @@ -671,18 +671,18 @@ static void ImGui_ImplDX10_SetWindowSize(ImGuiViewport* viewport, ImVec2 size) static void ImGui_ImplDX10_RenderViewport(ImGuiViewport* viewport, void*) { ImGui_ImplDX10_Data* bd = ImGui_ImplDX10_GetBackendData(); - ImGuiViewportDataDx10* data = (ImGuiViewportDataDx10*)viewport->RendererUserData; + ImGui_ImplDX10_ViewportData* vd = (ImGui_ImplDX10_ViewportData*)viewport->RendererUserData; ImVec4 clear_color = ImVec4(0.0f, 0.0f, 0.0f, 1.0f); - bd->pd3dDevice->OMSetRenderTargets(1, &data->RTView, NULL); + bd->pd3dDevice->OMSetRenderTargets(1, &vd->RTView, NULL); if (!(viewport->Flags & ImGuiViewportFlags_NoRendererClear)) - bd->pd3dDevice->ClearRenderTargetView(data->RTView, (float*)&clear_color); + bd->pd3dDevice->ClearRenderTargetView(vd->RTView, (float*)&clear_color); ImGui_ImplDX10_RenderDrawData(viewport->DrawData); } static void ImGui_ImplDX10_SwapBuffers(ImGuiViewport* viewport, void*) { - ImGuiViewportDataDx10* data = (ImGuiViewportDataDx10*)viewport->RendererUserData; - data->SwapChain->Present(0, 0); // Present without vsync + ImGui_ImplDX10_ViewportData* vd = (ImGui_ImplDX10_ViewportData*)viewport->RendererUserData; + vd->SwapChain->Present(0, 0); // Present without vsync } void ImGui_ImplDX10_InitPlatformInterface() diff --git a/backends/imgui_impl_dx11.cpp b/backends/imgui_impl_dx11.cpp index daeeb483..0aec8567 100644 --- a/backends/imgui_impl_dx11.cpp +++ b/backends/imgui_impl_dx11.cpp @@ -601,20 +601,20 @@ void ImGui_ImplDX11_NewFrame() //-------------------------------------------------------------------------------------------------------- // Helper structure we store in the void* RenderUserData field of each ImGuiViewport to easily retrieve our backend data. -struct ImGuiViewportDataDx11 +struct ImGui_ImplDX11_ViewportData { - IDXGISwapChain* SwapChain; - ID3D11RenderTargetView* RTView; + IDXGISwapChain* SwapChain; + ID3D11RenderTargetView* RTView; - ImGuiViewportDataDx11() { SwapChain = NULL; RTView = NULL; } - ~ImGuiViewportDataDx11() { IM_ASSERT(SwapChain == NULL && RTView == NULL); } + ImGui_ImplDX11_ViewportData() { SwapChain = NULL; RTView = NULL; } + ~ImGui_ImplDX11_ViewportData() { IM_ASSERT(SwapChain == NULL && RTView == NULL); } }; static void ImGui_ImplDX11_CreateWindow(ImGuiViewport* viewport) { ImGui_ImplDX11_Data* bd = ImGui_ImplDX11_GetBackendData(); - ImGuiViewportDataDx11* data = IM_NEW(ImGuiViewportDataDx11)(); - viewport->RendererUserData = data; + ImGui_ImplDX11_ViewportData* vd = IM_NEW(ImGui_ImplDX11_ViewportData)(); + viewport->RendererUserData = vd; // PlatformHandleRaw should always be a HWND, whereas PlatformHandle might be a higher-level handle (e.g. GLFWWindow*, SDL_Window*). // Some backend will leave PlatformHandleRaw NULL, in which case we assume PlatformHandle will contain the HWND. @@ -636,15 +636,15 @@ static void ImGui_ImplDX11_CreateWindow(ImGuiViewport* viewport) sd.SwapEffect = DXGI_SWAP_EFFECT_DISCARD; sd.Flags = 0; - IM_ASSERT(data->SwapChain == NULL && data->RTView == NULL); - bd->pFactory->CreateSwapChain(bd->pd3dDevice, &sd, &data->SwapChain); + IM_ASSERT(vd->SwapChain == NULL && vd->RTView == NULL); + bd->pFactory->CreateSwapChain(bd->pd3dDevice, &sd, &vd->SwapChain); // Create the render target - if (data->SwapChain) + if (vd->SwapChain) { ID3D11Texture2D* pBackBuffer; - data->SwapChain->GetBuffer(0, IID_PPV_ARGS(&pBackBuffer)); - bd->pd3dDevice->CreateRenderTargetView(pBackBuffer, NULL, &data->RTView); + vd->SwapChain->GetBuffer(0, IID_PPV_ARGS(&pBackBuffer)); + bd->pd3dDevice->CreateRenderTargetView(pBackBuffer, NULL, &vd->RTView); pBackBuffer->Release(); } } @@ -652,15 +652,15 @@ static void ImGui_ImplDX11_CreateWindow(ImGuiViewport* viewport) static void ImGui_ImplDX11_DestroyWindow(ImGuiViewport* viewport) { // The main viewport (owned by the application) will always have RendererUserData == NULL since we didn't create the data for it. - if (ImGuiViewportDataDx11* data = (ImGuiViewportDataDx11*)viewport->RendererUserData) + if (ImGui_ImplDX11_ViewportData* vd = (ImGui_ImplDX11_ViewportData*)viewport->RendererUserData) { - if (data->SwapChain) - data->SwapChain->Release(); - data->SwapChain = NULL; - if (data->RTView) - data->RTView->Release(); - data->RTView = NULL; - IM_DELETE(data); + if (vd->SwapChain) + vd->SwapChain->Release(); + vd->SwapChain = NULL; + if (vd->RTView) + vd->RTView->Release(); + vd->RTView = NULL; + IM_DELETE(vd); } viewport->RendererUserData = NULL; } @@ -668,19 +668,19 @@ static void ImGui_ImplDX11_DestroyWindow(ImGuiViewport* viewport) static void ImGui_ImplDX11_SetWindowSize(ImGuiViewport* viewport, ImVec2 size) { ImGui_ImplDX11_Data* bd = ImGui_ImplDX11_GetBackendData(); - ImGuiViewportDataDx11* data = (ImGuiViewportDataDx11*)viewport->RendererUserData; - if (data->RTView) + ImGui_ImplDX11_ViewportData* vd = (ImGui_ImplDX11_ViewportData*)viewport->RendererUserData; + if (vd->RTView) { - data->RTView->Release(); - data->RTView = NULL; + vd->RTView->Release(); + vd->RTView = NULL; } - if (data->SwapChain) + if (vd->SwapChain) { ID3D11Texture2D* pBackBuffer = NULL; - data->SwapChain->ResizeBuffers(0, (UINT)size.x, (UINT)size.y, DXGI_FORMAT_UNKNOWN, 0); - data->SwapChain->GetBuffer(0, IID_PPV_ARGS(&pBackBuffer)); + vd->SwapChain->ResizeBuffers(0, (UINT)size.x, (UINT)size.y, DXGI_FORMAT_UNKNOWN, 0); + vd->SwapChain->GetBuffer(0, IID_PPV_ARGS(&pBackBuffer)); if (pBackBuffer == NULL) { fprintf(stderr, "ImGui_ImplDX11_SetWindowSize() failed creating buffers.\n"); return; } - bd->pd3dDevice->CreateRenderTargetView(pBackBuffer, NULL, &data->RTView); + bd->pd3dDevice->CreateRenderTargetView(pBackBuffer, NULL, &vd->RTView); pBackBuffer->Release(); } } @@ -688,18 +688,18 @@ static void ImGui_ImplDX11_SetWindowSize(ImGuiViewport* viewport, ImVec2 size) static void ImGui_ImplDX11_RenderWindow(ImGuiViewport* viewport, void*) { ImGui_ImplDX11_Data* bd = ImGui_ImplDX11_GetBackendData(); - ImGuiViewportDataDx11* data = (ImGuiViewportDataDx11*)viewport->RendererUserData; + ImGui_ImplDX11_ViewportData* vd = (ImGui_ImplDX11_ViewportData*)viewport->RendererUserData; ImVec4 clear_color = ImVec4(0.0f, 0.0f, 0.0f, 1.0f); - bd->pd3dDeviceContext->OMSetRenderTargets(1, &data->RTView, NULL); + bd->pd3dDeviceContext->OMSetRenderTargets(1, &vd->RTView, NULL); if (!(viewport->Flags & ImGuiViewportFlags_NoRendererClear)) - bd->pd3dDeviceContext->ClearRenderTargetView(data->RTView, (float*)&clear_color); + bd->pd3dDeviceContext->ClearRenderTargetView(vd->RTView, (float*)&clear_color); ImGui_ImplDX11_RenderDrawData(viewport->DrawData); } static void ImGui_ImplDX11_SwapBuffers(ImGuiViewport* viewport, void*) { - ImGuiViewportDataDx11* data = (ImGuiViewportDataDx11*)viewport->RendererUserData; - data->SwapChain->Present(0, 0); // Present without vsync + ImGui_ImplDX11_ViewportData* vd = (ImGui_ImplDX11_ViewportData*)viewport->RendererUserData; + vd->SwapChain->Present(0, 0); // Present without vsync } static void ImGui_ImplDX11_InitPlatformInterface() diff --git a/backends/imgui_impl_dx12.cpp b/backends/imgui_impl_dx12.cpp index 5a984a2b..fb6777e5 100644 --- a/backends/imgui_impl_dx12.cpp +++ b/backends/imgui_impl_dx12.cpp @@ -93,7 +93,7 @@ struct ImGui_ImplDX12_FrameContext // Helper structure we store in the void* RendererUserData field of each ImGuiViewport to easily retrieve our backend data. // Main viewport created by application will only use the Resources field. // Secondary viewports created by this backend will use all the fields (including Window fields), -struct ImGuiViewportDataDx12 +struct ImGui_ImplDX12_ViewportData { // Window ID3D12CommandQueue* CommandQueue; @@ -110,7 +110,7 @@ struct ImGuiViewportDataDx12 UINT FrameIndex; ImGui_ImplDX12_RenderBuffers* FrameRenderBuffers; - ImGuiViewportDataDx12(UINT num_frames_in_flight) + ImGui_ImplDX12_ViewportData(UINT num_frames_in_flight) { CommandQueue = NULL; CommandList = NULL; @@ -136,7 +136,7 @@ struct ImGuiViewportDataDx12 FrameRenderBuffers[i].IndexBufferSize = 10000; } } - ~ImGuiViewportDataDx12() + ~ImGui_ImplDX12_ViewportData() { IM_ASSERT(CommandQueue == NULL && CommandList == NULL); IM_ASSERT(RtvDescHeap == NULL); @@ -245,9 +245,9 @@ void ImGui_ImplDX12_RenderDrawData(ImDrawData* draw_data, ID3D12GraphicsCommandL return; ImGui_ImplDX12_Data* bd = ImGui_ImplDX12_GetBackendData(); - ImGuiViewportDataDx12* render_data = (ImGuiViewportDataDx12*)draw_data->OwnerViewport->RendererUserData; - render_data->FrameIndex++; - ImGui_ImplDX12_RenderBuffers* fr = &render_data->FrameRenderBuffers[render_data->FrameIndex % bd->numFramesInFlight]; + ImGui_ImplDX12_ViewportData* vd = (ImGui_ImplDX12_ViewportData*)draw_data->OwnerViewport->RendererUserData; + vd->FrameIndex++; + ImGui_ImplDX12_RenderBuffers* fr = &vd->FrameRenderBuffers[vd->FrameIndex % bd->numFramesInFlight]; // Create and grow vertex/index buffers if needed if (fr->VertexBuffer == NULL || fr->VertexBufferSize < draw_data->TotalVtxCount) @@ -785,10 +785,10 @@ bool ImGui_ImplDX12_Init(ID3D12Device* device, int num_frames_in_flight, DXGI_FO if (io.ConfigFlags & ImGuiConfigFlags_ViewportsEnable) ImGui_ImplDX12_InitPlatformInterface(); - // Create a dummy ImGuiViewportDataDx12 holder for the main viewport, + // Create a dummy ImGui_ImplDX12_ViewportData holder for the main viewport, // Since this is created and managed by the application, we will only use the ->Resources[] fields. ImGuiViewport* main_viewport = ImGui::GetMainViewport(); - main_viewport->RendererUserData = IM_NEW(ImGuiViewportDataDx12)(bd->numFramesInFlight); + main_viewport->RendererUserData = IM_NEW(ImGui_ImplDX12_ViewportData)(bd->numFramesInFlight); return true; } @@ -800,12 +800,12 @@ void ImGui_ImplDX12_Shutdown() // Manually delete main viewport render resources in-case we haven't initialized for viewports ImGuiViewport* main_viewport = ImGui::GetMainViewport(); - if (ImGuiViewportDataDx12* data = (ImGuiViewportDataDx12*)main_viewport->RendererUserData) + if (ImGui_ImplDX12_ViewportData* vd = (ImGui_ImplDX12_ViewportData*)main_viewport->RendererUserData) { // We could just call ImGui_ImplDX12_DestroyWindow(main_viewport) as a convenience but that would be misleading since we only use data->Resources[] for (UINT i = 0; i < bd->numFramesInFlight; i++) - ImGui_ImplDX12_DestroyRenderBuffers(&data->FrameRenderBuffers[i]); - IM_DELETE(data); + ImGui_ImplDX12_DestroyRenderBuffers(&vd->FrameRenderBuffers[i]); + IM_DELETE(vd); main_viewport->RendererUserData = NULL; } @@ -834,15 +834,15 @@ void ImGui_ImplDX12_NewFrame() static void ImGui_ImplDX12_CreateWindow(ImGuiViewport* viewport) { ImGui_ImplDX12_Data* bd = ImGui_ImplDX12_GetBackendData(); - ImGuiViewportDataDx12* data = IM_NEW(ImGuiViewportDataDx12)(bd->numFramesInFlight); - viewport->RendererUserData = data; + ImGui_ImplDX12_ViewportData* vd = IM_NEW(ImGui_ImplDX12_ViewportData)(bd->numFramesInFlight); + viewport->RendererUserData = vd; // PlatformHandleRaw should always be a HWND, whereas PlatformHandle might be a higher-level handle (e.g. GLFWWindow*, SDL_Window*). // Some backends will leave PlatformHandleRaw NULL, in which case we assume PlatformHandle will contain the HWND. HWND hwnd = viewport->PlatformHandleRaw ? (HWND)viewport->PlatformHandleRaw : (HWND)viewport->PlatformHandle; IM_ASSERT(hwnd != 0); - data->FrameIndex = UINT_MAX; + vd->FrameIndex = UINT_MAX; // Create command queue. D3D12_COMMAND_QUEUE_DESC queue_desc = {}; @@ -850,27 +850,27 @@ static void ImGui_ImplDX12_CreateWindow(ImGuiViewport* viewport) queue_desc.Type = D3D12_COMMAND_LIST_TYPE_DIRECT; HRESULT res = S_OK; - res = bd->pd3dDevice->CreateCommandQueue(&queue_desc, IID_PPV_ARGS(&data->CommandQueue)); + res = bd->pd3dDevice->CreateCommandQueue(&queue_desc, IID_PPV_ARGS(&vd->CommandQueue)); IM_ASSERT(res == S_OK); // Create command allocator. for (UINT i = 0; i < bd->numFramesInFlight; ++i) { - res = bd->pd3dDevice->CreateCommandAllocator(D3D12_COMMAND_LIST_TYPE_DIRECT, IID_PPV_ARGS(&data->FrameCtx[i].CommandAllocator)); + res = bd->pd3dDevice->CreateCommandAllocator(D3D12_COMMAND_LIST_TYPE_DIRECT, IID_PPV_ARGS(&vd->FrameCtx[i].CommandAllocator)); IM_ASSERT(res == S_OK); } // Create command list. - res = bd->pd3dDevice->CreateCommandList(0, D3D12_COMMAND_LIST_TYPE_DIRECT, data->FrameCtx[0].CommandAllocator, NULL, IID_PPV_ARGS(&data->CommandList)); + res = bd->pd3dDevice->CreateCommandList(0, D3D12_COMMAND_LIST_TYPE_DIRECT, vd->FrameCtx[0].CommandAllocator, NULL, IID_PPV_ARGS(&vd->CommandList)); IM_ASSERT(res == S_OK); - data->CommandList->Close(); + vd->CommandList->Close(); // Create fence. - res = bd->pd3dDevice->CreateFence(0, D3D12_FENCE_FLAG_NONE, IID_PPV_ARGS(&data->Fence)); + res = bd->pd3dDevice->CreateFence(0, D3D12_FENCE_FLAG_NONE, IID_PPV_ARGS(&vd->Fence)); IM_ASSERT(res == S_OK); - data->FenceEvent = CreateEvent(NULL, FALSE, FALSE, NULL); - IM_ASSERT(data->FenceEvent != NULL); + vd->FenceEvent = CreateEvent(NULL, FALSE, FALSE, NULL); + IM_ASSERT(vd->FenceEvent != NULL); // Create swap chain // FIXME-VIEWPORT: May want to copy/inherit swap chain settings from the user/application. @@ -893,18 +893,18 @@ static void ImGui_ImplDX12_CreateWindow(ImGuiViewport* viewport) IM_ASSERT(res == S_OK); IDXGISwapChain1* swap_chain = NULL; - res = dxgi_factory->CreateSwapChainForHwnd(data->CommandQueue, hwnd, &sd1, NULL, NULL, &swap_chain); + res = dxgi_factory->CreateSwapChainForHwnd(vd->CommandQueue, hwnd, &sd1, NULL, NULL, &swap_chain); IM_ASSERT(res == S_OK); dxgi_factory->Release(); // Or swapChain.As(&mSwapChain) - IM_ASSERT(data->SwapChain == NULL); - swap_chain->QueryInterface(IID_PPV_ARGS(&data->SwapChain)); + IM_ASSERT(vd->SwapChain == NULL); + swap_chain->QueryInterface(IID_PPV_ARGS(&vd->SwapChain)); swap_chain->Release(); // Create the render targets - if (data->SwapChain) + if (vd->SwapChain) { D3D12_DESCRIPTOR_HEAP_DESC desc = {}; desc.Type = D3D12_DESCRIPTOR_HEAP_TYPE_RTV; @@ -912,42 +912,42 @@ static void ImGui_ImplDX12_CreateWindow(ImGuiViewport* viewport) desc.Flags = D3D12_DESCRIPTOR_HEAP_FLAG_NONE; desc.NodeMask = 1; - HRESULT hr = bd->pd3dDevice->CreateDescriptorHeap(&desc, IID_PPV_ARGS(&data->RtvDescHeap)); + HRESULT hr = bd->pd3dDevice->CreateDescriptorHeap(&desc, IID_PPV_ARGS(&vd->RtvDescHeap)); IM_ASSERT(hr == S_OK); SIZE_T rtv_descriptor_size = bd->pd3dDevice->GetDescriptorHandleIncrementSize(D3D12_DESCRIPTOR_HEAP_TYPE_RTV); - D3D12_CPU_DESCRIPTOR_HANDLE rtv_handle = data->RtvDescHeap->GetCPUDescriptorHandleForHeapStart(); + D3D12_CPU_DESCRIPTOR_HANDLE rtv_handle = vd->RtvDescHeap->GetCPUDescriptorHandleForHeapStart(); for (UINT i = 0; i < bd->numFramesInFlight; i++) { - data->FrameCtx[i].RenderTargetCpuDescriptors = rtv_handle; + vd->FrameCtx[i].RenderTargetCpuDescriptors = rtv_handle; rtv_handle.ptr += rtv_descriptor_size; } ID3D12Resource* back_buffer; for (UINT i = 0; i < bd->numFramesInFlight; i++) { - IM_ASSERT(data->FrameCtx[i].RenderTarget == NULL); - data->SwapChain->GetBuffer(i, IID_PPV_ARGS(&back_buffer)); - bd->pd3dDevice->CreateRenderTargetView(back_buffer, NULL, data->FrameCtx[i].RenderTargetCpuDescriptors); - data->FrameCtx[i].RenderTarget = back_buffer; + IM_ASSERT(vd->FrameCtx[i].RenderTarget == NULL); + vd->SwapChain->GetBuffer(i, IID_PPV_ARGS(&back_buffer)); + bd->pd3dDevice->CreateRenderTargetView(back_buffer, NULL, vd->FrameCtx[i].RenderTargetCpuDescriptors); + vd->FrameCtx[i].RenderTarget = back_buffer; } } for (UINT i = 0; i < bd->numFramesInFlight; i++) - ImGui_ImplDX12_DestroyRenderBuffers(&data->FrameRenderBuffers[i]); + ImGui_ImplDX12_DestroyRenderBuffers(&vd->FrameRenderBuffers[i]); } -static void ImGui_WaitForPendingOperations(ImGuiViewportDataDx12* data) +static void ImGui_WaitForPendingOperations(ImGui_ImplDX12_ViewportData* vd) { HRESULT hr = S_FALSE; - if (data && data->CommandQueue && data->Fence && data->FenceEvent) + if (vd && vd->CommandQueue && vd->Fence && vd->FenceEvent) { - hr = data->CommandQueue->Signal(data->Fence, ++data->FenceSignaledValue); + hr = vd->CommandQueue->Signal(vd->Fence, ++vd->FenceSignaledValue); IM_ASSERT(hr == S_OK); - ::WaitForSingleObject(data->FenceEvent, 0); // Reset any forgotten waits - hr = data->Fence->SetEventOnCompletion(data->FenceSignaledValue, data->FenceEvent); + ::WaitForSingleObject(vd->FenceEvent, 0); // Reset any forgotten waits + hr = vd->Fence->SetEventOnCompletion(vd->FenceSignaledValue, vd->FenceEvent); IM_ASSERT(hr == S_OK); - ::WaitForSingleObject(data->FenceEvent, INFINITE); + ::WaitForSingleObject(vd->FenceEvent, INFINITE); } } @@ -955,25 +955,25 @@ static void ImGui_ImplDX12_DestroyWindow(ImGuiViewport* viewport) { // The main viewport (owned by the application) will always have RendererUserData == NULL since we didn't create the data for it. ImGui_ImplDX12_Data* bd = ImGui_ImplDX12_GetBackendData(); - if (ImGuiViewportDataDx12* data = (ImGuiViewportDataDx12*)viewport->RendererUserData) + if (ImGui_ImplDX12_ViewportData* vd = (ImGui_ImplDX12_ViewportData*)viewport->RendererUserData) { - ImGui_WaitForPendingOperations(data); + ImGui_WaitForPendingOperations(vd); - SafeRelease(data->CommandQueue); - SafeRelease(data->CommandList); - SafeRelease(data->SwapChain); - SafeRelease(data->RtvDescHeap); - SafeRelease(data->Fence); - ::CloseHandle(data->FenceEvent); - data->FenceEvent = NULL; + SafeRelease(vd->CommandQueue); + SafeRelease(vd->CommandList); + SafeRelease(vd->SwapChain); + SafeRelease(vd->RtvDescHeap); + SafeRelease(vd->Fence); + ::CloseHandle(vd->FenceEvent); + vd->FenceEvent = NULL; for (UINT i = 0; i < bd->numFramesInFlight; i++) { - SafeRelease(data->FrameCtx[i].RenderTarget); - SafeRelease(data->FrameCtx[i].CommandAllocator); - ImGui_ImplDX12_DestroyRenderBuffers(&data->FrameRenderBuffers[i]); + SafeRelease(vd->FrameCtx[i].RenderTarget); + SafeRelease(vd->FrameCtx[i].CommandAllocator); + ImGui_ImplDX12_DestroyRenderBuffers(&vd->FrameRenderBuffers[i]); } - IM_DELETE(data); + IM_DELETE(vd); } viewport->RendererUserData = NULL; } @@ -981,22 +981,22 @@ static void ImGui_ImplDX12_DestroyWindow(ImGuiViewport* viewport) static void ImGui_ImplDX12_SetWindowSize(ImGuiViewport* viewport, ImVec2 size) { ImGui_ImplDX12_Data* bd = ImGui_ImplDX12_GetBackendData(); - ImGuiViewportDataDx12* data = (ImGuiViewportDataDx12*)viewport->RendererUserData; + ImGui_ImplDX12_ViewportData* vd = (ImGui_ImplDX12_ViewportData*)viewport->RendererUserData; - ImGui_WaitForPendingOperations(data); + ImGui_WaitForPendingOperations(vd); for (UINT i = 0; i < bd->numFramesInFlight; i++) - SafeRelease(data->FrameCtx[i].RenderTarget); + SafeRelease(vd->FrameCtx[i].RenderTarget); - if (data->SwapChain) + if (vd->SwapChain) { ID3D12Resource* back_buffer = NULL; - data->SwapChain->ResizeBuffers(0, (UINT)size.x, (UINT)size.y, DXGI_FORMAT_UNKNOWN, 0); + vd->SwapChain->ResizeBuffers(0, (UINT)size.x, (UINT)size.y, DXGI_FORMAT_UNKNOWN, 0); for (UINT i = 0; i < bd->numFramesInFlight; i++) { - data->SwapChain->GetBuffer(i, IID_PPV_ARGS(&back_buffer)); - bd->pd3dDevice->CreateRenderTargetView(back_buffer, NULL, data->FrameCtx[i].RenderTargetCpuDescriptors); - data->FrameCtx[i].RenderTarget = back_buffer; + vd->SwapChain->GetBuffer(i, IID_PPV_ARGS(&back_buffer)); + bd->pd3dDevice->CreateRenderTargetView(back_buffer, NULL, vd->FrameCtx[i].RenderTargetCpuDescriptors); + vd->FrameCtx[i].RenderTarget = back_buffer; } } } @@ -1004,29 +1004,29 @@ static void ImGui_ImplDX12_SetWindowSize(ImGuiViewport* viewport, ImVec2 size) static void ImGui_ImplDX12_RenderWindow(ImGuiViewport* viewport, void*) { ImGui_ImplDX12_Data* bd = ImGui_ImplDX12_GetBackendData(); - ImGuiViewportDataDx12* data = (ImGuiViewportDataDx12*)viewport->RendererUserData; + ImGui_ImplDX12_ViewportData* vd = (ImGui_ImplDX12_ViewportData*)viewport->RendererUserData; - ImGui_ImplDX12_FrameContext* frame_context = &data->FrameCtx[data->FrameIndex % bd->numFramesInFlight]; - UINT back_buffer_idx = data->SwapChain->GetCurrentBackBufferIndex(); + ImGui_ImplDX12_FrameContext* frame_context = &vd->FrameCtx[vd->FrameIndex % bd->numFramesInFlight]; + UINT back_buffer_idx = vd->SwapChain->GetCurrentBackBufferIndex(); const ImVec4 clear_color = ImVec4(0.0f, 0.0f, 0.0f, 1.0f); D3D12_RESOURCE_BARRIER barrier = {}; barrier.Type = D3D12_RESOURCE_BARRIER_TYPE_TRANSITION; barrier.Flags = D3D12_RESOURCE_BARRIER_FLAG_NONE; - barrier.Transition.pResource = data->FrameCtx[back_buffer_idx].RenderTarget; + barrier.Transition.pResource = vd->FrameCtx[back_buffer_idx].RenderTarget; barrier.Transition.Subresource = D3D12_RESOURCE_BARRIER_ALL_SUBRESOURCES; barrier.Transition.StateBefore = D3D12_RESOURCE_STATE_PRESENT; barrier.Transition.StateAfter = D3D12_RESOURCE_STATE_RENDER_TARGET; // Draw - ID3D12GraphicsCommandList* cmd_list = data->CommandList; + ID3D12GraphicsCommandList* cmd_list = vd->CommandList; frame_context->CommandAllocator->Reset(); cmd_list->Reset(frame_context->CommandAllocator, NULL); cmd_list->ResourceBarrier(1, &barrier); - cmd_list->OMSetRenderTargets(1, &data->FrameCtx[back_buffer_idx].RenderTargetCpuDescriptors, FALSE, NULL); + cmd_list->OMSetRenderTargets(1, &vd->FrameCtx[back_buffer_idx].RenderTargetCpuDescriptors, FALSE, NULL); if (!(viewport->Flags & ImGuiViewportFlags_NoRendererClear)) - cmd_list->ClearRenderTargetView(data->FrameCtx[back_buffer_idx].RenderTargetCpuDescriptors, (float*)&clear_color, 0, NULL); + cmd_list->ClearRenderTargetView(vd->FrameCtx[back_buffer_idx].RenderTargetCpuDescriptors, (float*)&clear_color, 0, NULL); cmd_list->SetDescriptorHeaps(1, &bd->pd3dSrvDescHeap); ImGui_ImplDX12_RenderDrawData(viewport->DrawData, cmd_list); @@ -1036,17 +1036,17 @@ static void ImGui_ImplDX12_RenderWindow(ImGuiViewport* viewport, void*) cmd_list->ResourceBarrier(1, &barrier); cmd_list->Close(); - data->CommandQueue->Wait(data->Fence, data->FenceSignaledValue); - data->CommandQueue->ExecuteCommandLists(1, (ID3D12CommandList* const*)&cmd_list); - data->CommandQueue->Signal(data->Fence, ++data->FenceSignaledValue); + vd->CommandQueue->Wait(vd->Fence, vd->FenceSignaledValue); + vd->CommandQueue->ExecuteCommandLists(1, (ID3D12CommandList* const*)&cmd_list); + vd->CommandQueue->Signal(vd->Fence, ++vd->FenceSignaledValue); } static void ImGui_ImplDX12_SwapBuffers(ImGuiViewport* viewport, void*) { - ImGuiViewportDataDx12* data = (ImGuiViewportDataDx12*)viewport->RendererUserData; + ImGui_ImplDX12_ViewportData* vd = (ImGui_ImplDX12_ViewportData*)viewport->RendererUserData; - data->SwapChain->Present(0, 0); - while (data->Fence->GetCompletedValue() < data->FenceSignaledValue) + vd->SwapChain->Present(0, 0); + while (vd->Fence->GetCompletedValue() < vd->FenceSignaledValue) ::SwitchToThread(); } diff --git a/backends/imgui_impl_dx9.cpp b/backends/imgui_impl_dx9.cpp index 98620c09..ac13c083 100644 --- a/backends/imgui_impl_dx9.cpp +++ b/backends/imgui_impl_dx9.cpp @@ -393,52 +393,52 @@ void ImGui_ImplDX9_NewFrame() //-------------------------------------------------------------------------------------------------------- // Helper structure we store in the void* RenderUserData field of each ImGuiViewport to easily retrieve our backend data. -struct ImGuiViewportDataDx9 +struct ImGui_ImplDX9_ViewportData { IDirect3DSwapChain9* SwapChain; D3DPRESENT_PARAMETERS d3dpp; - ImGuiViewportDataDx9() { SwapChain = NULL; ZeroMemory(&d3dpp, sizeof(D3DPRESENT_PARAMETERS)); } - ~ImGuiViewportDataDx9() { IM_ASSERT(SwapChain == NULL); } + ImGui_ImplDX9_ViewportData() { SwapChain = NULL; ZeroMemory(&d3dpp, sizeof(D3DPRESENT_PARAMETERS)); } + ~ImGui_ImplDX9_ViewportData() { IM_ASSERT(SwapChain == NULL); } }; static void ImGui_ImplDX9_CreateWindow(ImGuiViewport* viewport) { ImGui_ImplDX9_Data* bd = ImGui_ImplDX9_GetBackendData(); - ImGuiViewportDataDx9* data = IM_NEW(ImGuiViewportDataDx9)(); - viewport->RendererUserData = data; + ImGui_ImplDX9_ViewportData* vd = IM_NEW(ImGui_ImplDX9_ViewportData)(); + viewport->RendererUserData = vd; // PlatformHandleRaw should always be a HWND, whereas PlatformHandle might be a higher-level handle (e.g. GLFWWindow*, SDL_Window*). // Some backends will leave PlatformHandleRaw NULL, in which case we assume PlatformHandle will contain the HWND. HWND hwnd = viewport->PlatformHandleRaw ? (HWND)viewport->PlatformHandleRaw : (HWND)viewport->PlatformHandle; IM_ASSERT(hwnd != 0); - ZeroMemory(&data->d3dpp, sizeof(D3DPRESENT_PARAMETERS)); - data->d3dpp.Windowed = TRUE; - data->d3dpp.SwapEffect = D3DSWAPEFFECT_DISCARD; - data->d3dpp.BackBufferWidth = (UINT)viewport->Size.x; - data->d3dpp.BackBufferHeight = (UINT)viewport->Size.y; - data->d3dpp.BackBufferFormat = D3DFMT_UNKNOWN; - data->d3dpp.hDeviceWindow = hwnd; - data->d3dpp.EnableAutoDepthStencil = FALSE; - data->d3dpp.AutoDepthStencilFormat = D3DFMT_D16; - data->d3dpp.PresentationInterval = D3DPRESENT_INTERVAL_IMMEDIATE; // Present without vsync - - HRESULT hr = bd->pd3dDevice->CreateAdditionalSwapChain(&data->d3dpp, &data->SwapChain); IM_UNUSED(hr); + ZeroMemory(&vd->d3dpp, sizeof(D3DPRESENT_PARAMETERS)); + vd->d3dpp.Windowed = TRUE; + vd->d3dpp.SwapEffect = D3DSWAPEFFECT_DISCARD; + vd->d3dpp.BackBufferWidth = (UINT)viewport->Size.x; + vd->d3dpp.BackBufferHeight = (UINT)viewport->Size.y; + vd->d3dpp.BackBufferFormat = D3DFMT_UNKNOWN; + vd->d3dpp.hDeviceWindow = hwnd; + vd->d3dpp.EnableAutoDepthStencil = FALSE; + vd->d3dpp.AutoDepthStencilFormat = D3DFMT_D16; + vd->d3dpp.PresentationInterval = D3DPRESENT_INTERVAL_IMMEDIATE; // Present without vsync + + HRESULT hr = bd->pd3dDevice->CreateAdditionalSwapChain(&vd->d3dpp, &vd->SwapChain); IM_UNUSED(hr); IM_ASSERT(hr == D3D_OK); - IM_ASSERT(data->SwapChain != NULL); + IM_ASSERT(vd->SwapChain != NULL); } static void ImGui_ImplDX9_DestroyWindow(ImGuiViewport* viewport) { // The main viewport (owned by the application) will always have RendererUserData == NULL since we didn't create the data for it. - if (ImGuiViewportDataDx9* data = (ImGuiViewportDataDx9*)viewport->RendererUserData) + if (ImGui_ImplDX9_ViewportData* vd = (ImGui_ImplDX9_ViewportData*)viewport->RendererUserData) { - if (data->SwapChain) - data->SwapChain->Release(); - data->SwapChain = NULL; - ZeroMemory(&data->d3dpp, sizeof(D3DPRESENT_PARAMETERS)); - IM_DELETE(data); + if (vd->SwapChain) + vd->SwapChain->Release(); + vd->SwapChain = NULL; + ZeroMemory(&vd->d3dpp, sizeof(D3DPRESENT_PARAMETERS)); + IM_DELETE(vd); } viewport->RendererUserData = NULL; } @@ -446,14 +446,14 @@ static void ImGui_ImplDX9_DestroyWindow(ImGuiViewport* viewport) static void ImGui_ImplDX9_SetWindowSize(ImGuiViewport* viewport, ImVec2 size) { ImGui_ImplDX9_Data* bd = ImGui_ImplDX9_GetBackendData(); - ImGuiViewportDataDx9* data = (ImGuiViewportDataDx9*)viewport->RendererUserData; - if (data->SwapChain) + ImGui_ImplDX9_ViewportData* vd = (ImGui_ImplDX9_ViewportData*)viewport->RendererUserData; + if (vd->SwapChain) { - data->SwapChain->Release(); - data->SwapChain = NULL; - data->d3dpp.BackBufferWidth = (UINT)size.x; - data->d3dpp.BackBufferHeight = (UINT)size.y; - HRESULT hr = bd->pd3dDevice->CreateAdditionalSwapChain(&data->d3dpp, &data->SwapChain); IM_UNUSED(hr); + vd->SwapChain->Release(); + vd->SwapChain = NULL; + vd->d3dpp.BackBufferWidth = (UINT)size.x; + vd->d3dpp.BackBufferHeight = (UINT)size.y; + HRESULT hr = bd->pd3dDevice->CreateAdditionalSwapChain(&vd->d3dpp, &vd->SwapChain); IM_UNUSED(hr); IM_ASSERT(hr == D3D_OK); } } @@ -461,13 +461,13 @@ static void ImGui_ImplDX9_SetWindowSize(ImGuiViewport* viewport, ImVec2 size) static void ImGui_ImplDX9_RenderWindow(ImGuiViewport* viewport, void*) { ImGui_ImplDX9_Data* bd = ImGui_ImplDX9_GetBackendData(); - ImGuiViewportDataDx9* data = (ImGuiViewportDataDx9*)viewport->RendererUserData; + ImGui_ImplDX9_ViewportData* vd = (ImGui_ImplDX9_ViewportData*)viewport->RendererUserData; ImVec4 clear_color = ImVec4(0.0f, 0.0f, 0.0f, 1.0f); LPDIRECT3DSURFACE9 render_target = NULL; LPDIRECT3DSURFACE9 last_render_target = NULL; LPDIRECT3DSURFACE9 last_depth_stencil = NULL; - data->SwapChain->GetBackBuffer(0, D3DBACKBUFFER_TYPE_MONO, &render_target); + vd->SwapChain->GetBackBuffer(0, D3DBACKBUFFER_TYPE_MONO, &render_target); bd->pd3dDevice->GetRenderTarget(0, &last_render_target); bd->pd3dDevice->GetDepthStencilSurface(&last_depth_stencil); bd->pd3dDevice->SetRenderTarget(0, render_target); @@ -491,8 +491,8 @@ static void ImGui_ImplDX9_RenderWindow(ImGuiViewport* viewport, void*) static void ImGui_ImplDX9_SwapBuffers(ImGuiViewport* viewport, void*) { - ImGuiViewportDataDx9* data = (ImGuiViewportDataDx9*)viewport->RendererUserData; - HRESULT hr = data->SwapChain->Present(NULL, NULL, data->d3dpp.hDeviceWindow, NULL, 0); + ImGui_ImplDX9_ViewportData* vd = (ImGui_ImplDX9_ViewportData*)viewport->RendererUserData; + HRESULT hr = vd->SwapChain->Present(NULL, NULL, vd->d3dpp.hDeviceWindow, NULL, 0); // Let main application handle D3DERR_DEVICELOST by resetting the device. IM_ASSERT(hr == D3D_OK || hr == D3DERR_DEVICELOST); } diff --git a/backends/imgui_impl_glfw.cpp b/backends/imgui_impl_glfw.cpp index c20a3d6b..0a1712cc 100644 --- a/backends/imgui_impl_glfw.cpp +++ b/backends/imgui_impl_glfw.cpp @@ -545,15 +545,15 @@ void ImGui_ImplGlfw_NewFrame() //-------------------------------------------------------------------------------------------------------- // Helper structure we store in the void* RenderUserData field of each ImGuiViewport to easily retrieve our backend data. -struct ImGuiViewportDataGlfw +struct ImGui_ImplGlfw_ViewportData { GLFWwindow* Window; bool WindowOwned; int IgnoreWindowPosEventFrame; int IgnoreWindowSizeEventFrame; - ImGuiViewportDataGlfw() { Window = NULL; WindowOwned = false; IgnoreWindowSizeEventFrame = IgnoreWindowPosEventFrame = -1; } - ~ImGuiViewportDataGlfw() { IM_ASSERT(Window == NULL); } + ImGui_ImplGlfw_ViewportData() { Window = NULL; WindowOwned = false; IgnoreWindowSizeEventFrame = IgnoreWindowPosEventFrame = -1; } + ~ImGui_ImplGlfw_ViewportData() { IM_ASSERT(Window == NULL); } }; static void ImGui_ImplGlfw_WindowCloseCallback(GLFWwindow* window) @@ -572,9 +572,9 @@ static void ImGui_ImplGlfw_WindowPosCallback(GLFWwindow* window, int, int) { if (ImGuiViewport* viewport = ImGui::FindViewportByPlatformHandle(window)) { - if (ImGuiViewportDataGlfw* data = (ImGuiViewportDataGlfw*)viewport->PlatformUserData) + if (ImGui_ImplGlfw_ViewportData* vd = (ImGui_ImplGlfw_ViewportData*)viewport->PlatformUserData) { - bool ignore_event = (ImGui::GetFrameCount() <= data->IgnoreWindowPosEventFrame + 1); + bool ignore_event = (ImGui::GetFrameCount() <= vd->IgnoreWindowPosEventFrame + 1); //data->IgnoreWindowPosEventFrame = -1; if (ignore_event) return; @@ -587,9 +587,9 @@ static void ImGui_ImplGlfw_WindowSizeCallback(GLFWwindow* window, int, int) { if (ImGuiViewport* viewport = ImGui::FindViewportByPlatformHandle(window)) { - if (ImGuiViewportDataGlfw* data = (ImGuiViewportDataGlfw*)viewport->PlatformUserData) + if (ImGui_ImplGlfw_ViewportData* vd = (ImGui_ImplGlfw_ViewportData*)viewport->PlatformUserData) { - bool ignore_event = (ImGui::GetFrameCount() <= data->IgnoreWindowSizeEventFrame + 1); + bool ignore_event = (ImGui::GetFrameCount() <= vd->IgnoreWindowSizeEventFrame + 1); //data->IgnoreWindowSizeEventFrame = -1; if (ignore_event) return; @@ -601,8 +601,8 @@ static void ImGui_ImplGlfw_WindowSizeCallback(GLFWwindow* window, int, int) static void ImGui_ImplGlfw_CreateWindow(ImGuiViewport* viewport) { ImGui_ImplGlfw_Data* bd = ImGui_ImplGlfw_GetBackendData(); - ImGuiViewportDataGlfw* data = IM_NEW(ImGuiViewportDataGlfw)(); - viewport->PlatformUserData = data; + ImGui_ImplGlfw_ViewportData* vd = IM_NEW(ImGui_ImplGlfw_ViewportData)(); + viewport->PlatformUserData = vd; // GLFW 3.2 unfortunately always set focus on glfwCreateWindow() if GLFW_VISIBLE is set, regardless of GLFW_FOCUSED // With GLFW 3.3, the hint GLFW_FOCUS_ON_SHOW fixes this problem @@ -616,25 +616,25 @@ static void ImGui_ImplGlfw_CreateWindow(ImGuiViewport* viewport) glfwWindowHint(GLFW_FLOATING, (viewport->Flags & ImGuiViewportFlags_TopMost) ? true : false); #endif GLFWwindow* share_window = (bd->ClientApi == GlfwClientApi_OpenGL) ? bd->Window : NULL; - data->Window = glfwCreateWindow((int)viewport->Size.x, (int)viewport->Size.y, "No Title Yet", NULL, share_window); - data->WindowOwned = true; - viewport->PlatformHandle = (void*)data->Window; + vd->Window = glfwCreateWindow((int)viewport->Size.x, (int)viewport->Size.y, "No Title Yet", NULL, share_window); + vd->WindowOwned = true; + viewport->PlatformHandle = (void*)vd->Window; #ifdef _WIN32 - viewport->PlatformHandleRaw = glfwGetWin32Window(data->Window); + viewport->PlatformHandleRaw = glfwGetWin32Window(vd->Window); #endif - glfwSetWindowPos(data->Window, (int)viewport->Pos.x, (int)viewport->Pos.y); + glfwSetWindowPos(vd->Window, (int)viewport->Pos.x, (int)viewport->Pos.y); // Install GLFW callbacks for secondary viewports - glfwSetMouseButtonCallback(data->Window, ImGui_ImplGlfw_MouseButtonCallback); - glfwSetScrollCallback(data->Window, ImGui_ImplGlfw_ScrollCallback); - glfwSetKeyCallback(data->Window, ImGui_ImplGlfw_KeyCallback); - glfwSetCharCallback(data->Window, ImGui_ImplGlfw_CharCallback); - glfwSetWindowCloseCallback(data->Window, ImGui_ImplGlfw_WindowCloseCallback); - glfwSetWindowPosCallback(data->Window, ImGui_ImplGlfw_WindowPosCallback); - glfwSetWindowSizeCallback(data->Window, ImGui_ImplGlfw_WindowSizeCallback); + glfwSetMouseButtonCallback(vd->Window, ImGui_ImplGlfw_MouseButtonCallback); + glfwSetScrollCallback(vd->Window, ImGui_ImplGlfw_ScrollCallback); + glfwSetKeyCallback(vd->Window, ImGui_ImplGlfw_KeyCallback); + glfwSetCharCallback(vd->Window, ImGui_ImplGlfw_CharCallback); + glfwSetWindowCloseCallback(vd->Window, ImGui_ImplGlfw_WindowCloseCallback); + glfwSetWindowPosCallback(vd->Window, ImGui_ImplGlfw_WindowPosCallback); + glfwSetWindowSizeCallback(vd->Window, ImGui_ImplGlfw_WindowSizeCallback); if (bd->ClientApi == GlfwClientApi_OpenGL) { - glfwMakeContextCurrent(data->Window); + glfwMakeContextCurrent(vd->Window); glfwSwapInterval(0); } } @@ -642,9 +642,9 @@ static void ImGui_ImplGlfw_CreateWindow(ImGuiViewport* viewport) static void ImGui_ImplGlfw_DestroyWindow(ImGuiViewport* viewport) { ImGui_ImplGlfw_Data* bd = ImGui_ImplGlfw_GetBackendData(); - if (ImGuiViewportDataGlfw* data = (ImGuiViewportDataGlfw*)viewport->PlatformUserData) + if (ImGui_ImplGlfw_ViewportData* vd = (ImGui_ImplGlfw_ViewportData*)viewport->PlatformUserData) { - if (data->WindowOwned) + if (vd->WindowOwned) { #if !GLFW_HAS_MOUSE_PASSTHROUGH && GLFW_HAS_WINDOW_HOVERED && defined(_WIN32) HWND hwnd = (HWND)viewport->PlatformHandleRaw; @@ -654,13 +654,13 @@ static void ImGui_ImplGlfw_DestroyWindow(ImGuiViewport* viewport) // Release any keys that were pressed in the window being destroyed and are still held down, // because we will not receive any release events after window is destroyed. for (int i = 0; i < IM_ARRAYSIZE(bd->KeyOwnerWindows); i++) - if (bd->KeyOwnerWindows[i] == data->Window) - ImGui_ImplGlfw_KeyCallback(data->Window, i, 0, GLFW_RELEASE, 0); // Later params are only used for main viewport, on which this function is never called. + if (bd->KeyOwnerWindows[i] == vd->Window) + ImGui_ImplGlfw_KeyCallback(vd->Window, i, 0, GLFW_RELEASE, 0); // Later params are only used for main viewport, on which this function is never called. - glfwDestroyWindow(data->Window); + glfwDestroyWindow(vd->Window); } - data->Window = NULL; - IM_DELETE(data); + vd->Window = NULL; + IM_DELETE(vd); } viewport->PlatformUserData = viewport->PlatformHandle = NULL; } @@ -687,7 +687,7 @@ static LRESULT CALLBACK WndProcNoInputs(HWND hWnd, UINT msg, WPARAM wParam, LPAR static void ImGui_ImplGlfw_ShowWindow(ImGuiViewport* viewport) { - ImGuiViewportDataGlfw* data = (ImGuiViewportDataGlfw*)viewport->PlatformUserData; + ImGui_ImplGlfw_ViewportData* vd = (ImGui_ImplGlfw_ViewportData*)viewport->PlatformUserData; #if defined(_WIN32) // GLFW hack: Hide icon from task bar @@ -721,60 +721,60 @@ static void ImGui_ImplGlfw_ShowWindow(ImGuiViewport* viewport) #endif #endif - glfwShowWindow(data->Window); + glfwShowWindow(vd->Window); } static ImVec2 ImGui_ImplGlfw_GetWindowPos(ImGuiViewport* viewport) { - ImGuiViewportDataGlfw* data = (ImGuiViewportDataGlfw*)viewport->PlatformUserData; + ImGui_ImplGlfw_ViewportData* vd = (ImGui_ImplGlfw_ViewportData*)viewport->PlatformUserData; int x = 0, y = 0; - glfwGetWindowPos(data->Window, &x, &y); + glfwGetWindowPos(vd->Window, &x, &y); return ImVec2((float)x, (float)y); } static void ImGui_ImplGlfw_SetWindowPos(ImGuiViewport* viewport, ImVec2 pos) { - ImGuiViewportDataGlfw* data = (ImGuiViewportDataGlfw*)viewport->PlatformUserData; - data->IgnoreWindowPosEventFrame = ImGui::GetFrameCount(); - glfwSetWindowPos(data->Window, (int)pos.x, (int)pos.y); + ImGui_ImplGlfw_ViewportData* vd = (ImGui_ImplGlfw_ViewportData*)viewport->PlatformUserData; + vd->IgnoreWindowPosEventFrame = ImGui::GetFrameCount(); + glfwSetWindowPos(vd->Window, (int)pos.x, (int)pos.y); } static ImVec2 ImGui_ImplGlfw_GetWindowSize(ImGuiViewport* viewport) { - ImGuiViewportDataGlfw* data = (ImGuiViewportDataGlfw*)viewport->PlatformUserData; + ImGui_ImplGlfw_ViewportData* vd = (ImGui_ImplGlfw_ViewportData*)viewport->PlatformUserData; int w = 0, h = 0; - glfwGetWindowSize(data->Window, &w, &h); + glfwGetWindowSize(vd->Window, &w, &h); return ImVec2((float)w, (float)h); } static void ImGui_ImplGlfw_SetWindowSize(ImGuiViewport* viewport, ImVec2 size) { - ImGuiViewportDataGlfw* data = (ImGuiViewportDataGlfw*)viewport->PlatformUserData; + ImGui_ImplGlfw_ViewportData* vd = (ImGui_ImplGlfw_ViewportData*)viewport->PlatformUserData; #if __APPLE__ && !GLFW_HAS_OSX_WINDOW_POS_FIX // Native OS windows are positioned from the bottom-left corner on macOS, whereas on other platforms they are // positioned from the upper-left corner. GLFW makes an effort to convert macOS style coordinates, however it // doesn't handle it when changing size. We are manually moving the window in order for changes of size to be based // on the upper-left corner. int x, y, width, height; - glfwGetWindowPos(data->Window, &x, &y); - glfwGetWindowSize(data->Window, &width, &height); - glfwSetWindowPos(data->Window, x, y - height + size.y); + glfwGetWindowPos(vd->Window, &x, &y); + glfwGetWindowSize(vd->Window, &width, &height); + glfwSetWindowPos(vd->Window, x, y - height + size.y); #endif - data->IgnoreWindowSizeEventFrame = ImGui::GetFrameCount(); - glfwSetWindowSize(data->Window, (int)size.x, (int)size.y); + vd->IgnoreWindowSizeEventFrame = ImGui::GetFrameCount(); + glfwSetWindowSize(vd->Window, (int)size.x, (int)size.y); } static void ImGui_ImplGlfw_SetWindowTitle(ImGuiViewport* viewport, const char* title) { - ImGuiViewportDataGlfw* data = (ImGuiViewportDataGlfw*)viewport->PlatformUserData; - glfwSetWindowTitle(data->Window, title); + ImGui_ImplGlfw_ViewportData* vd = (ImGui_ImplGlfw_ViewportData*)viewport->PlatformUserData; + glfwSetWindowTitle(vd->Window, title); } static void ImGui_ImplGlfw_SetWindowFocus(ImGuiViewport* viewport) { #if GLFW_HAS_FOCUS_WINDOW - ImGuiViewportDataGlfw* data = (ImGuiViewportDataGlfw*)viewport->PlatformUserData; - glfwFocusWindow(data->Window); + ImGui_ImplGlfw_ViewportData* vd = (ImGui_ImplGlfw_ViewportData*)viewport->PlatformUserData; + glfwFocusWindow(vd->Window); #else // FIXME: What are the effect of not having this function? At the moment imgui doesn't actually call SetWindowFocus - we set that up ahead, will answer that question later. (void)viewport; @@ -783,40 +783,40 @@ static void ImGui_ImplGlfw_SetWindowFocus(ImGuiViewport* viewport) static bool ImGui_ImplGlfw_GetWindowFocus(ImGuiViewport* viewport) { - ImGuiViewportDataGlfw* data = (ImGuiViewportDataGlfw*)viewport->PlatformUserData; - return glfwGetWindowAttrib(data->Window, GLFW_FOCUSED) != 0; + ImGui_ImplGlfw_ViewportData* vd = (ImGui_ImplGlfw_ViewportData*)viewport->PlatformUserData; + return glfwGetWindowAttrib(vd->Window, GLFW_FOCUSED) != 0; } static bool ImGui_ImplGlfw_GetWindowMinimized(ImGuiViewport* viewport) { - ImGuiViewportDataGlfw* data = (ImGuiViewportDataGlfw*)viewport->PlatformUserData; - return glfwGetWindowAttrib(data->Window, GLFW_ICONIFIED) != 0; + ImGui_ImplGlfw_ViewportData* vd = (ImGui_ImplGlfw_ViewportData*)viewport->PlatformUserData; + return glfwGetWindowAttrib(vd->Window, GLFW_ICONIFIED) != 0; } #if GLFW_HAS_WINDOW_ALPHA static void ImGui_ImplGlfw_SetWindowAlpha(ImGuiViewport* viewport, float alpha) { - ImGuiViewportDataGlfw* data = (ImGuiViewportDataGlfw*)viewport->PlatformUserData; - glfwSetWindowOpacity(data->Window, alpha); + ImGui_ImplGlfw_ViewportData* vd = (ImGui_ImplGlfw_ViewportData*)viewport->PlatformUserData; + glfwSetWindowOpacity(vd->Window, alpha); } #endif static void ImGui_ImplGlfw_RenderWindow(ImGuiViewport* viewport, void*) { ImGui_ImplGlfw_Data* bd = ImGui_ImplGlfw_GetBackendData(); - ImGuiViewportDataGlfw* data = (ImGuiViewportDataGlfw*)viewport->PlatformUserData; + ImGui_ImplGlfw_ViewportData* vd = (ImGui_ImplGlfw_ViewportData*)viewport->PlatformUserData; if (bd->ClientApi == GlfwClientApi_OpenGL) - glfwMakeContextCurrent(data->Window); + glfwMakeContextCurrent(vd->Window); } static void ImGui_ImplGlfw_SwapBuffers(ImGuiViewport* viewport, void*) { ImGui_ImplGlfw_Data* bd = ImGui_ImplGlfw_GetBackendData(); - ImGuiViewportDataGlfw* data = (ImGuiViewportDataGlfw*)viewport->PlatformUserData; + ImGui_ImplGlfw_ViewportData* vd = (ImGui_ImplGlfw_ViewportData*)viewport->PlatformUserData; if (bd->ClientApi == GlfwClientApi_OpenGL) { - glfwMakeContextCurrent(data->Window); - glfwSwapBuffers(data->Window); + glfwMakeContextCurrent(vd->Window); + glfwSwapBuffers(vd->Window); } } @@ -867,9 +867,9 @@ extern "C" { extern GLFWAPI VkResult glfwCreateWindowSurface(VkInstance instance static int ImGui_ImplGlfw_CreateVkSurface(ImGuiViewport* viewport, ImU64 vk_instance, const void* vk_allocator, ImU64* out_vk_surface) { ImGui_ImplGlfw_Data* bd = ImGui_ImplGlfw_GetBackendData(); - ImGuiViewportDataGlfw* data = (ImGuiViewportDataGlfw*)viewport->PlatformUserData; + ImGui_ImplGlfw_ViewportData* vd = (ImGui_ImplGlfw_ViewportData*)viewport->PlatformUserData; IM_ASSERT(bd->ClientApi == GlfwClientApi_Vulkan); - VkResult err = glfwCreateWindowSurface((VkInstance)vk_instance, data->Window, (const VkAllocationCallbacks*)vk_allocator, (VkSurfaceKHR*)out_vk_surface); + VkResult err = glfwCreateWindowSurface((VkInstance)vk_instance, vd->Window, (const VkAllocationCallbacks*)vk_allocator, (VkSurfaceKHR*)out_vk_surface); return (int)err; } #endif // GLFW_HAS_VULKAN @@ -905,10 +905,10 @@ static void ImGui_ImplGlfw_InitPlatformInterface() // Register main window handle (which is owned by the main application, not by us) // This is mostly for simplicity and consistency, so that our code (e.g. mouse handling etc.) can use same logic for main and secondary viewports. ImGuiViewport* main_viewport = ImGui::GetMainViewport(); - ImGuiViewportDataGlfw* data = IM_NEW(ImGuiViewportDataGlfw)(); - data->Window = bd->Window; - data->WindowOwned = false; - main_viewport->PlatformUserData = data; + ImGui_ImplGlfw_ViewportData* vd = IM_NEW(ImGui_ImplGlfw_ViewportData)(); + vd->Window = bd->Window; + vd->WindowOwned = false; + main_viewport->PlatformUserData = vd; main_viewport->PlatformHandle = (void*)bd->Window; } diff --git a/backends/imgui_impl_sdl.cpp b/backends/imgui_impl_sdl.cpp index 7a882c4f..2fd748a1 100644 --- a/backends/imgui_impl_sdl.cpp +++ b/backends/imgui_impl_sdl.cpp @@ -522,25 +522,25 @@ void ImGui_ImplSDL2_NewFrame(SDL_Window* window) //-------------------------------------------------------------------------------------------------------- // Helper structure we store in the void* RenderUserData field of each ImGuiViewport to easily retrieve our backend data. -struct ImGuiViewportDataSDL2 +struct ImGui_ImplSDL2_ViewportData { SDL_Window* Window; Uint32 WindowID; bool WindowOwned; SDL_GLContext GLContext; - ImGuiViewportDataSDL2() { Window = NULL; WindowID = 0; WindowOwned = false; GLContext = NULL; } - ~ImGuiViewportDataSDL2() { IM_ASSERT(Window == NULL && GLContext == NULL); } + ImGui_ImplSDL2_ViewportData() { Window = NULL; WindowID = 0; WindowOwned = false; GLContext = NULL; } + ~ImGui_ImplSDL2_ViewportData() { IM_ASSERT(Window == NULL && GLContext == NULL); } }; static void ImGui_ImplSDL2_CreateWindow(ImGuiViewport* viewport) { ImGui_ImplSDL2_Data* bd = ImGui_ImplSDL2_GetBackendData(); - ImGuiViewportDataSDL2* data = IM_NEW(ImGuiViewportDataSDL2)(); - viewport->PlatformUserData = data; + ImGui_ImplSDL2_ViewportData* vd = IM_NEW(ImGui_ImplSDL2_ViewportData)(); + viewport->PlatformUserData = vd; ImGuiViewport* main_viewport = ImGui::GetMainViewport(); - ImGuiViewportDataSDL2* main_viewport_data = (ImGuiViewportDataSDL2*)main_viewport->PlatformUserData; + ImGui_ImplSDL2_ViewportData* main_viewport_data = (ImGui_ImplSDL2_ViewportData*)main_viewport->PlatformUserData; // Share GL resources with main context bool use_opengl = (main_viewport_data->GLContext != NULL); @@ -565,43 +565,43 @@ static void ImGui_ImplSDL2_CreateWindow(ImGuiViewport* viewport) #if SDL_HAS_ALWAYS_ON_TOP sdl_flags |= (viewport->Flags & ImGuiViewportFlags_TopMost) ? SDL_WINDOW_ALWAYS_ON_TOP : 0; #endif - data->Window = SDL_CreateWindow("No Title Yet", (int)viewport->Pos.x, (int)viewport->Pos.y, (int)viewport->Size.x, (int)viewport->Size.y, sdl_flags); - data->WindowOwned = true; + vd->Window = SDL_CreateWindow("No Title Yet", (int)viewport->Pos.x, (int)viewport->Pos.y, (int)viewport->Size.x, (int)viewport->Size.y, sdl_flags); + vd->WindowOwned = true; if (use_opengl) { - data->GLContext = SDL_GL_CreateContext(data->Window); + vd->GLContext = SDL_GL_CreateContext(vd->Window); SDL_GL_SetSwapInterval(0); } if (use_opengl && backup_context) - SDL_GL_MakeCurrent(data->Window, backup_context); + SDL_GL_MakeCurrent(vd->Window, backup_context); - viewport->PlatformHandle = (void*)data->Window; + viewport->PlatformHandle = (void*)vd->Window; #if defined(_WIN32) SDL_SysWMinfo info; SDL_VERSION(&info.version); - if (SDL_GetWindowWMInfo(data->Window, &info)) + if (SDL_GetWindowWMInfo(vd->Window, &info)) viewport->PlatformHandleRaw = info.info.win.window; #endif } static void ImGui_ImplSDL2_DestroyWindow(ImGuiViewport* viewport) { - if (ImGuiViewportDataSDL2* data = (ImGuiViewportDataSDL2*)viewport->PlatformUserData) + if (ImGui_ImplSDL2_ViewportData* vd = (ImGui_ImplSDL2_ViewportData*)viewport->PlatformUserData) { - if (data->GLContext && data->WindowOwned) - SDL_GL_DeleteContext(data->GLContext); - if (data->Window && data->WindowOwned) - SDL_DestroyWindow(data->Window); - data->GLContext = NULL; - data->Window = NULL; - IM_DELETE(data); + if (vd->GLContext && vd->WindowOwned) + SDL_GL_DeleteContext(vd->GLContext); + if (vd->Window && vd->WindowOwned) + SDL_DestroyWindow(vd->Window); + vd->GLContext = NULL; + vd->Window = NULL; + IM_DELETE(vd); } viewport->PlatformUserData = viewport->PlatformHandle = NULL; } static void ImGui_ImplSDL2_ShowWindow(ImGuiViewport* viewport) { - ImGuiViewportDataSDL2* data = (ImGuiViewportDataSDL2*)viewport->PlatformUserData; + ImGui_ImplSDL2_ViewportData* vd = (ImGui_ImplSDL2_ViewportData*)viewport->PlatformUserData; #if defined(_WIN32) HWND hwnd = (HWND)viewport->PlatformHandleRaw; @@ -623,83 +623,83 @@ static void ImGui_ImplSDL2_ShowWindow(ImGuiViewport* viewport) } #endif - SDL_ShowWindow(data->Window); + SDL_ShowWindow(vd->Window); } static ImVec2 ImGui_ImplSDL2_GetWindowPos(ImGuiViewport* viewport) { - ImGuiViewportDataSDL2* data = (ImGuiViewportDataSDL2*)viewport->PlatformUserData; + ImGui_ImplSDL2_ViewportData* vd = (ImGui_ImplSDL2_ViewportData*)viewport->PlatformUserData; int x = 0, y = 0; - SDL_GetWindowPosition(data->Window, &x, &y); + SDL_GetWindowPosition(vd->Window, &x, &y); return ImVec2((float)x, (float)y); } static void ImGui_ImplSDL2_SetWindowPos(ImGuiViewport* viewport, ImVec2 pos) { - ImGuiViewportDataSDL2* data = (ImGuiViewportDataSDL2*)viewport->PlatformUserData; - SDL_SetWindowPosition(data->Window, (int)pos.x, (int)pos.y); + ImGui_ImplSDL2_ViewportData* vd = (ImGui_ImplSDL2_ViewportData*)viewport->PlatformUserData; + SDL_SetWindowPosition(vd->Window, (int)pos.x, (int)pos.y); } static ImVec2 ImGui_ImplSDL2_GetWindowSize(ImGuiViewport* viewport) { - ImGuiViewportDataSDL2* data = (ImGuiViewportDataSDL2*)viewport->PlatformUserData; + ImGui_ImplSDL2_ViewportData* vd = (ImGui_ImplSDL2_ViewportData*)viewport->PlatformUserData; int w = 0, h = 0; - SDL_GetWindowSize(data->Window, &w, &h); + SDL_GetWindowSize(vd->Window, &w, &h); return ImVec2((float)w, (float)h); } static void ImGui_ImplSDL2_SetWindowSize(ImGuiViewport* viewport, ImVec2 size) { - ImGuiViewportDataSDL2* data = (ImGuiViewportDataSDL2*)viewport->PlatformUserData; - SDL_SetWindowSize(data->Window, (int)size.x, (int)size.y); + ImGui_ImplSDL2_ViewportData* vd = (ImGui_ImplSDL2_ViewportData*)viewport->PlatformUserData; + SDL_SetWindowSize(vd->Window, (int)size.x, (int)size.y); } static void ImGui_ImplSDL2_SetWindowTitle(ImGuiViewport* viewport, const char* title) { - ImGuiViewportDataSDL2* data = (ImGuiViewportDataSDL2*)viewport->PlatformUserData; - SDL_SetWindowTitle(data->Window, title); + ImGui_ImplSDL2_ViewportData* vd = (ImGui_ImplSDL2_ViewportData*)viewport->PlatformUserData; + SDL_SetWindowTitle(vd->Window, title); } #if SDL_HAS_WINDOW_ALPHA static void ImGui_ImplSDL2_SetWindowAlpha(ImGuiViewport* viewport, float alpha) { - ImGuiViewportDataSDL2* data = (ImGuiViewportDataSDL2*)viewport->PlatformUserData; - SDL_SetWindowOpacity(data->Window, alpha); + ImGui_ImplSDL2_ViewportData* vd = (ImGui_ImplSDL2_ViewportData*)viewport->PlatformUserData; + SDL_SetWindowOpacity(vd->Window, alpha); } #endif static void ImGui_ImplSDL2_SetWindowFocus(ImGuiViewport* viewport) { - ImGuiViewportDataSDL2* data = (ImGuiViewportDataSDL2*)viewport->PlatformUserData; - SDL_RaiseWindow(data->Window); + ImGui_ImplSDL2_ViewportData* vd = (ImGui_ImplSDL2_ViewportData*)viewport->PlatformUserData; + SDL_RaiseWindow(vd->Window); } static bool ImGui_ImplSDL2_GetWindowFocus(ImGuiViewport* viewport) { - ImGuiViewportDataSDL2* data = (ImGuiViewportDataSDL2*)viewport->PlatformUserData; - return (SDL_GetWindowFlags(data->Window) & SDL_WINDOW_INPUT_FOCUS) != 0; + ImGui_ImplSDL2_ViewportData* vd = (ImGui_ImplSDL2_ViewportData*)viewport->PlatformUserData; + return (SDL_GetWindowFlags(vd->Window) & SDL_WINDOW_INPUT_FOCUS) != 0; } static bool ImGui_ImplSDL2_GetWindowMinimized(ImGuiViewport* viewport) { - ImGuiViewportDataSDL2* data = (ImGuiViewportDataSDL2*)viewport->PlatformUserData; - return (SDL_GetWindowFlags(data->Window) & SDL_WINDOW_MINIMIZED) != 0; + ImGui_ImplSDL2_ViewportData* vd = (ImGui_ImplSDL2_ViewportData*)viewport->PlatformUserData; + return (SDL_GetWindowFlags(vd->Window) & SDL_WINDOW_MINIMIZED) != 0; } static void ImGui_ImplSDL2_RenderWindow(ImGuiViewport* viewport, void*) { - ImGuiViewportDataSDL2* data = (ImGuiViewportDataSDL2*)viewport->PlatformUserData; - if (data->GLContext) - SDL_GL_MakeCurrent(data->Window, data->GLContext); + ImGui_ImplSDL2_ViewportData* vd = (ImGui_ImplSDL2_ViewportData*)viewport->PlatformUserData; + if (vd->GLContext) + SDL_GL_MakeCurrent(vd->Window, vd->GLContext); } static void ImGui_ImplSDL2_SwapBuffers(ImGuiViewport* viewport, void*) { - ImGuiViewportDataSDL2* data = (ImGuiViewportDataSDL2*)viewport->PlatformUserData; - if (data->GLContext) + ImGui_ImplSDL2_ViewportData* vd = (ImGui_ImplSDL2_ViewportData*)viewport->PlatformUserData; + if (vd->GLContext) { - SDL_GL_MakeCurrent(data->Window, data->GLContext); - SDL_GL_SwapWindow(data->Window); + SDL_GL_MakeCurrent(vd->Window, vd->GLContext); + SDL_GL_SwapWindow(vd->Window); } } @@ -709,9 +709,9 @@ static void ImGui_ImplSDL2_SwapBuffers(ImGuiViewport* viewport, void*) #include static int ImGui_ImplSDL2_CreateVkSurface(ImGuiViewport* viewport, ImU64 vk_instance, const void* vk_allocator, ImU64* out_vk_surface) { - ImGuiViewportDataSDL2* data = (ImGuiViewportDataSDL2*)viewport->PlatformUserData; + ImGui_ImplSDL2_ViewportData* vd = (ImGui_ImplSDL2_ViewportData*)viewport->PlatformUserData; (void)vk_allocator; - SDL_bool ret = SDL_Vulkan_CreateSurface(data->Window, (VkInstance)vk_instance, (VkSurfaceKHR*)out_vk_surface); + SDL_bool ret = SDL_Vulkan_CreateSurface(vd->Window, (VkInstance)vk_instance, (VkSurfaceKHR*)out_vk_surface); return ret ? 0 : 1; // ret ? VK_SUCCESS : VK_NOT_READY } #endif // SDL_HAS_VULKAN @@ -748,13 +748,13 @@ static void ImGui_ImplSDL2_InitPlatformInterface(SDL_Window* window, void* sdl_g // Register main window handle (which is owned by the main application, not by us) // This is mostly for simplicity and consistency, so that our code (e.g. mouse handling etc.) can use same logic for main and secondary viewports. ImGuiViewport* main_viewport = ImGui::GetMainViewport(); - ImGuiViewportDataSDL2* data = IM_NEW(ImGuiViewportDataSDL2)(); - data->Window = window; - data->WindowID = SDL_GetWindowID(window); - data->WindowOwned = false; - data->GLContext = sdl_gl_context; - main_viewport->PlatformUserData = data; - main_viewport->PlatformHandle = data->Window; + ImGui_ImplSDL2_ViewportData* vd = IM_NEW(ImGui_ImplSDL2_ViewportData)(); + vd->Window = window; + vd->WindowID = SDL_GetWindowID(window); + vd->WindowOwned = false; + vd->GLContext = sdl_gl_context; + main_viewport->PlatformUserData = vd; + main_viewport->PlatformHandle = vd->Window; } static void ImGui_ImplSDL2_ShutdownPlatformInterface() diff --git a/backends/imgui_impl_vulkan.cpp b/backends/imgui_impl_vulkan.cpp index 49adee97..8ee9a3d3 100644 --- a/backends/imgui_impl_vulkan.cpp +++ b/backends/imgui_impl_vulkan.cpp @@ -81,14 +81,14 @@ struct ImGui_ImplVulkanH_WindowRenderBuffers // For multi-viewport support: // Helper structure we store in the void* RenderUserData field of each ImGuiViewport to easily retrieve our backend data. -struct ImGuiViewportDataVulkan +struct ImGui_ImplVulkan_ViewportData { bool WindowOwned; ImGui_ImplVulkanH_Window Window; // Used by secondary viewports only ImGui_ImplVulkanH_WindowRenderBuffers RenderBuffers; // Used by all viewports - ImGuiViewportDataVulkan() { WindowOwned = false; memset(&RenderBuffers, 0, sizeof(RenderBuffers)); } - ~ImGuiViewportDataVulkan() { } + ImGui_ImplVulkan_ViewportData() { WindowOwned = false; memset(&RenderBuffers, 0, sizeof(RenderBuffers)); } + ~ImGui_ImplVulkan_ViewportData() { } }; // Vulkan data @@ -114,7 +114,7 @@ struct ImGui_ImplVulkan_Data VkDeviceMemory UploadBufferMemory; VkBuffer UploadBuffer; - // Render buffers + // Render buffers for main window ImGui_ImplVulkanH_WindowRenderBuffers MainWindowRenderBuffers; ImGui_ImplVulkan_Data() @@ -460,7 +460,7 @@ void ImGui_ImplVulkan_RenderDrawData(ImDrawData* draw_data, VkCommandBuffer comm pipeline = bd->Pipeline; // Allocate array to store enough vertex/index buffers. Each unique viewport gets its own storage. - ImGuiViewportDataVulkan* viewport_renderer_data = (ImGuiViewportDataVulkan*)draw_data->OwnerViewport->RendererUserData; + ImGui_ImplVulkan_ViewportData* viewport_renderer_data = (ImGui_ImplVulkan_ViewportData*)draw_data->OwnerViewport->RendererUserData; IM_ASSERT(viewport_renderer_data != NULL); ImGui_ImplVulkanH_WindowRenderBuffers* wrb = &viewport_renderer_data->RenderBuffers; if (wrb->FrameRenderBuffers == NULL) @@ -1080,7 +1080,7 @@ bool ImGui_ImplVulkan_Init(ImGui_ImplVulkan_InitInfo* info, VkRenderPass rend // Our render function expect RendererUserData to be storing the window render buffer we need (for the main viewport we won't use ->Window) ImGuiViewport* main_viewport = ImGui::GetMainViewport(); - main_viewport->RendererUserData = IM_NEW(ImGuiViewportDataVulkan)(); + main_viewport->RendererUserData = IM_NEW(ImGui_ImplVulkan_ViewportData)(); if (io.ConfigFlags & ImGuiConfigFlags_ViewportsEnable) ImGui_ImplVulkan_InitPlatformInterface(); @@ -1095,8 +1095,8 @@ void ImGui_ImplVulkan_Shutdown() // Manually delete main viewport render data in-case we haven't initialized for viewports ImGuiViewport* main_viewport = ImGui::GetMainViewport(); - if (ImGuiViewportDataVulkan* data = (ImGuiViewportDataVulkan*)main_viewport->RendererUserData) - IM_DELETE(data); + if (ImGui_ImplVulkan_ViewportData* vd = (ImGui_ImplVulkan_ViewportData*)main_viewport->RendererUserData) + IM_DELETE(vd); main_viewport->RendererUserData = NULL; // Clean up windows @@ -1516,8 +1516,8 @@ void ImGui_ImplVulkanH_DestroyAllViewportsRenderBuffers(VkDevice device, const V { ImGuiPlatformIO& platform_io = ImGui::GetPlatformIO(); for (int n = 0; n < platform_io.Viewports.Size; n++) - if (ImGuiViewportDataVulkan* data = (ImGuiViewportDataVulkan*)platform_io.Viewports[n]->RendererUserData) - ImGui_ImplVulkanH_DestroyWindowRenderBuffers(device, &data->RenderBuffers, allocator); + if (ImGui_ImplVulkan_ViewportData* vd = (ImGui_ImplVulkan_ViewportData*)platform_io.Viewports[n]->RendererUserData) + ImGui_ImplVulkanH_DestroyWindowRenderBuffers(device, &vd->RenderBuffers, allocator); } //-------------------------------------------------------------------------------------------------------- @@ -1529,9 +1529,9 @@ void ImGui_ImplVulkanH_DestroyAllViewportsRenderBuffers(VkDevice device, const V static void ImGui_ImplVulkan_CreateWindow(ImGuiViewport* viewport) { ImGui_ImplVulkan_Data* bd = ImGui_ImplVulkan_GetBackendData(); - ImGuiViewportDataVulkan* data = IM_NEW(ImGuiViewportDataVulkan)(); - viewport->RendererUserData = data; - ImGui_ImplVulkanH_Window* wd = &data->Window; + ImGui_ImplVulkan_ViewportData* vd = IM_NEW(ImGui_ImplVulkan_ViewportData)(); + viewport->RendererUserData = vd; + ImGui_ImplVulkanH_Window* wd = &vd->Window; ImGui_ImplVulkan_InitInfo* v = &bd->VulkanInitInfo; // Create surface @@ -1562,20 +1562,20 @@ static void ImGui_ImplVulkan_CreateWindow(ImGuiViewport* viewport) // Create SwapChain, RenderPass, Framebuffer, etc. wd->ClearEnable = (viewport->Flags & ImGuiViewportFlags_NoRendererClear) ? false : true; ImGui_ImplVulkanH_CreateOrResizeWindow(v->Instance, v->PhysicalDevice, v->Device, wd, v->QueueFamily, v->Allocator, (int)viewport->Size.x, (int)viewport->Size.y, v->MinImageCount); - data->WindowOwned = true; + vd->WindowOwned = true; } static void ImGui_ImplVulkan_DestroyWindow(ImGuiViewport* viewport) { // The main viewport (owned by the application) will always have RendererUserData == NULL since we didn't create the data for it. ImGui_ImplVulkan_Data* bd = ImGui_ImplVulkan_GetBackendData(); - if (ImGuiViewportDataVulkan* data = (ImGuiViewportDataVulkan*)viewport->RendererUserData) + if (ImGui_ImplVulkan_ViewportData* vd = (ImGui_ImplVulkan_ViewportData*)viewport->RendererUserData) { ImGui_ImplVulkan_InitInfo* v = &bd->VulkanInitInfo; - if (data->WindowOwned) - ImGui_ImplVulkanH_DestroyWindow(v->Instance, v->Device, &data->Window, v->Allocator); - ImGui_ImplVulkanH_DestroyWindowRenderBuffers(v->Device, &data->RenderBuffers, v->Allocator); - IM_DELETE(data); + if (vd->WindowOwned) + ImGui_ImplVulkanH_DestroyWindow(v->Instance, v->Device, &vd->Window, v->Allocator); + ImGui_ImplVulkanH_DestroyWindowRenderBuffers(v->Device, &vd->RenderBuffers, v->Allocator); + IM_DELETE(vd); } viewport->RendererUserData = NULL; } @@ -1583,19 +1583,19 @@ static void ImGui_ImplVulkan_DestroyWindow(ImGuiViewport* viewport) static void ImGui_ImplVulkan_SetWindowSize(ImGuiViewport* viewport, ImVec2 size) { ImGui_ImplVulkan_Data* bd = ImGui_ImplVulkan_GetBackendData(); - ImGuiViewportDataVulkan* data = (ImGuiViewportDataVulkan*)viewport->RendererUserData; - if (data == NULL) // This is NULL for the main viewport (which is left to the user/app to handle) + ImGui_ImplVulkan_ViewportData* vd = (ImGui_ImplVulkan_ViewportData*)viewport->RendererUserData; + if (vd == NULL) // This is NULL for the main viewport (which is left to the user/app to handle) return; ImGui_ImplVulkan_InitInfo* v = &bd->VulkanInitInfo; - data->Window.ClearEnable = (viewport->Flags & ImGuiViewportFlags_NoRendererClear) ? false : true; - ImGui_ImplVulkanH_CreateOrResizeWindow(v->Instance, v->PhysicalDevice, v->Device, &data->Window, v->QueueFamily, v->Allocator, (int)size.x, (int)size.y, v->MinImageCount); + vd->Window.ClearEnable = (viewport->Flags & ImGuiViewportFlags_NoRendererClear) ? false : true; + ImGui_ImplVulkanH_CreateOrResizeWindow(v->Instance, v->PhysicalDevice, v->Device, &vd->Window, v->QueueFamily, v->Allocator, (int)size.x, (int)size.y, v->MinImageCount); } static void ImGui_ImplVulkan_RenderWindow(ImGuiViewport* viewport, void*) { ImGui_ImplVulkan_Data* bd = ImGui_ImplVulkan_GetBackendData(); - ImGuiViewportDataVulkan* data = (ImGuiViewportDataVulkan*)viewport->RendererUserData; - ImGui_ImplVulkanH_Window* wd = &data->Window; + ImGui_ImplVulkan_ViewportData* vd = (ImGui_ImplVulkan_ViewportData*)viewport->RendererUserData; + ImGui_ImplVulkanH_Window* wd = &vd->Window; ImGui_ImplVulkan_InitInfo* v = &bd->VulkanInitInfo; VkResult err; @@ -1668,8 +1668,8 @@ static void ImGui_ImplVulkan_RenderWindow(ImGuiViewport* viewport, void*) static void ImGui_ImplVulkan_SwapBuffers(ImGuiViewport* viewport, void*) { ImGui_ImplVulkan_Data* bd = ImGui_ImplVulkan_GetBackendData(); - ImGuiViewportDataVulkan* data = (ImGuiViewportDataVulkan*)viewport->RendererUserData; - ImGui_ImplVulkanH_Window* wd = &data->Window; + ImGui_ImplVulkan_ViewportData* vd = (ImGui_ImplVulkan_ViewportData*)viewport->RendererUserData; + ImGui_ImplVulkanH_Window* wd = &vd->Window; ImGui_ImplVulkan_InitInfo* v = &bd->VulkanInitInfo; VkResult err; @@ -1685,7 +1685,7 @@ static void ImGui_ImplVulkan_SwapBuffers(ImGuiViewport* viewport, void*) info.pImageIndices = &present_index; err = vkQueuePresentKHR(v->Queue, &info); if (err == VK_ERROR_OUT_OF_DATE_KHR || err == VK_SUBOPTIMAL_KHR) - ImGui_ImplVulkanH_CreateOrResizeWindow(v->Instance, v->PhysicalDevice, v->Device, &data->Window, v->QueueFamily, v->Allocator, (int)viewport->Size.x, (int)viewport->Size.y, v->MinImageCount); + ImGui_ImplVulkanH_CreateOrResizeWindow(v->Instance, v->PhysicalDevice, v->Device, &vd->Window, v->QueueFamily, v->Allocator, (int)viewport->Size.x, (int)viewport->Size.y, v->MinImageCount); else check_vk_result(err); diff --git a/backends/imgui_impl_vulkan.h b/backends/imgui_impl_vulkan.h index eaf7c65a..58b68f08 100644 --- a/backends/imgui_impl_vulkan.h +++ b/backends/imgui_impl_vulkan.h @@ -7,7 +7,7 @@ // [ ] Platform: Multi-viewport / platform windows. // [ ] Renderer: User texture binding. Changes of ImTextureID aren't supported by this backend! See https://github.com/ocornut/imgui/pull/914 -// You can use unmodified imgui_impl_* files in your project. See examples/ folder for examples of using this. +// You can use unmodified imgui_impl_* files in your project. See examples/ folder for examples of using this. // Prefer including the entire imgui/ repository into your project (either as a copy or as a submodule), and only build the backends you need. // If you are new to Dear ImGui, read documentation from the docs/ folder + read the top of imgui.cpp. // Read online: https://github.com/ocornut/imgui/tree/master/docs diff --git a/backends/imgui_impl_win32.cpp b/backends/imgui_impl_win32.cpp index 20e46f26..411edb5f 100644 --- a/backends/imgui_impl_win32.cpp +++ b/backends/imgui_impl_win32.cpp @@ -673,15 +673,15 @@ static void ImGui_ImplWin32_SetImeInputPos(ImGuiViewport* viewport, ImVec2 pos) //-------------------------------------------------------------------------------------------------------- // Helper structure we store in the void* RenderUserData field of each ImGuiViewport to easily retrieve our backend data. -struct ImGuiViewportDataWin32 +struct ImGui_ImplWin32_ViewportData { HWND Hwnd; bool HwndOwned; DWORD DwStyle; DWORD DwExStyle; - ImGuiViewportDataWin32() { Hwnd = NULL; HwndOwned = false; DwStyle = DwExStyle = 0; } - ~ImGuiViewportDataWin32() { IM_ASSERT(Hwnd == NULL); } + ImGui_ImplWin32_ViewportData() { Hwnd = NULL; HwndOwned = false; DwStyle = DwExStyle = 0; } + ~ImGui_ImplWin32_ViewportData() { IM_ASSERT(Hwnd == NULL); } }; static void ImGui_ImplWin32_GetWin32StyleFromViewportFlags(ImGuiViewportFlags flags, DWORD* out_style, DWORD* out_ex_style) @@ -702,11 +702,11 @@ static void ImGui_ImplWin32_GetWin32StyleFromViewportFlags(ImGuiViewportFlags fl static void ImGui_ImplWin32_CreateWindow(ImGuiViewport* viewport) { - ImGuiViewportDataWin32* data = IM_NEW(ImGuiViewportDataWin32)(); - viewport->PlatformUserData = data; + ImGui_ImplWin32_ViewportData* vd = IM_NEW(ImGui_ImplWin32_ViewportData)(); + viewport->PlatformUserData = vd; // Select style and parent window - ImGui_ImplWin32_GetWin32StyleFromViewportFlags(viewport->Flags, &data->DwStyle, &data->DwExStyle); + ImGui_ImplWin32_GetWin32StyleFromViewportFlags(viewport->Flags, &vd->DwStyle, &vd->DwExStyle); HWND parent_window = NULL; if (viewport->ParentViewportId != 0) if (ImGuiViewport* parent_viewport = ImGui::FindViewportByID(viewport->ParentViewportId)) @@ -714,170 +714,170 @@ static void ImGui_ImplWin32_CreateWindow(ImGuiViewport* viewport) // Create window RECT rect = { (LONG)viewport->Pos.x, (LONG)viewport->Pos.y, (LONG)(viewport->Pos.x + viewport->Size.x), (LONG)(viewport->Pos.y + viewport->Size.y) }; - ::AdjustWindowRectEx(&rect, data->DwStyle, FALSE, data->DwExStyle); - data->Hwnd = ::CreateWindowEx( - data->DwExStyle, _T("ImGui Platform"), _T("Untitled"), data->DwStyle, // Style, class name, window name + ::AdjustWindowRectEx(&rect, vd->DwStyle, FALSE, vd->DwExStyle); + vd->Hwnd = ::CreateWindowEx( + vd->DwExStyle, _T("ImGui Platform"), _T("Untitled"), vd->DwStyle, // Style, class name, window name rect.left, rect.top, rect.right - rect.left, rect.bottom - rect.top, // Window area parent_window, NULL, ::GetModuleHandle(NULL), NULL); // Parent window, Menu, Instance, Param - data->HwndOwned = true; + vd->HwndOwned = true; viewport->PlatformRequestResize = false; - viewport->PlatformHandle = viewport->PlatformHandleRaw = data->Hwnd; + viewport->PlatformHandle = viewport->PlatformHandleRaw = vd->Hwnd; } static void ImGui_ImplWin32_DestroyWindow(ImGuiViewport* viewport) { ImGui_ImplWin32_Data* bd = ImGui_ImplWin32_GetBackendData(); - if (ImGuiViewportDataWin32* data = (ImGuiViewportDataWin32*)viewport->PlatformUserData) + if (ImGui_ImplWin32_ViewportData* vd = (ImGui_ImplWin32_ViewportData*)viewport->PlatformUserData) { - if (::GetCapture() == data->Hwnd) + if (::GetCapture() == vd->Hwnd) { // Transfer capture so if we started dragging from a window that later disappears, we'll still receive the MOUSEUP event. ::ReleaseCapture(); ::SetCapture(bd->hWnd); } - if (data->Hwnd && data->HwndOwned) - ::DestroyWindow(data->Hwnd); - data->Hwnd = NULL; - IM_DELETE(data); + if (vd->Hwnd && vd->HwndOwned) + ::DestroyWindow(vd->Hwnd); + vd->Hwnd = NULL; + IM_DELETE(vd); } viewport->PlatformUserData = viewport->PlatformHandle = NULL; } static void ImGui_ImplWin32_ShowWindow(ImGuiViewport* viewport) { - ImGuiViewportDataWin32* data = (ImGuiViewportDataWin32*)viewport->PlatformUserData; - IM_ASSERT(data->Hwnd != 0); + ImGui_ImplWin32_ViewportData* vd = (ImGui_ImplWin32_ViewportData*)viewport->PlatformUserData; + IM_ASSERT(vd->Hwnd != 0); if (viewport->Flags & ImGuiViewportFlags_NoFocusOnAppearing) - ::ShowWindow(data->Hwnd, SW_SHOWNA); + ::ShowWindow(vd->Hwnd, SW_SHOWNA); else - ::ShowWindow(data->Hwnd, SW_SHOW); + ::ShowWindow(vd->Hwnd, SW_SHOW); } static void ImGui_ImplWin32_UpdateWindow(ImGuiViewport* viewport) { // (Optional) Update Win32 style if it changed _after_ creation. // Generally they won't change unless configuration flags are changed, but advanced uses (such as manually rewriting viewport flags) make this useful. - ImGuiViewportDataWin32* data = (ImGuiViewportDataWin32*)viewport->PlatformUserData; - IM_ASSERT(data->Hwnd != 0); + ImGui_ImplWin32_ViewportData* vd = (ImGui_ImplWin32_ViewportData*)viewport->PlatformUserData; + IM_ASSERT(vd->Hwnd != 0); DWORD new_style; DWORD new_ex_style; ImGui_ImplWin32_GetWin32StyleFromViewportFlags(viewport->Flags, &new_style, &new_ex_style); // Only reapply the flags that have been changed from our point of view (as other flags are being modified by Windows) - if (data->DwStyle != new_style || data->DwExStyle != new_ex_style) + if (vd->DwStyle != new_style || vd->DwExStyle != new_ex_style) { // (Optional) Update TopMost state if it changed _after_ creation - bool top_most_changed = (data->DwExStyle & WS_EX_TOPMOST) != (new_ex_style & WS_EX_TOPMOST); + bool top_most_changed = (vd->DwExStyle & WS_EX_TOPMOST) != (new_ex_style & WS_EX_TOPMOST); HWND insert_after = top_most_changed ? ((viewport->Flags & ImGuiViewportFlags_TopMost) ? HWND_TOPMOST : HWND_NOTOPMOST) : 0; UINT swp_flag = top_most_changed ? 0 : SWP_NOZORDER; // Apply flags and position (since it is affected by flags) - data->DwStyle = new_style; - data->DwExStyle = new_ex_style; - ::SetWindowLong(data->Hwnd, GWL_STYLE, data->DwStyle); - ::SetWindowLong(data->Hwnd, GWL_EXSTYLE, data->DwExStyle); + vd->DwStyle = new_style; + vd->DwExStyle = new_ex_style; + ::SetWindowLong(vd->Hwnd, GWL_STYLE, vd->DwStyle); + ::SetWindowLong(vd->Hwnd, GWL_EXSTYLE, vd->DwExStyle); RECT rect = { (LONG)viewport->Pos.x, (LONG)viewport->Pos.y, (LONG)(viewport->Pos.x + viewport->Size.x), (LONG)(viewport->Pos.y + viewport->Size.y) }; - ::AdjustWindowRectEx(&rect, data->DwStyle, FALSE, data->DwExStyle); // Client to Screen - ::SetWindowPos(data->Hwnd, insert_after, rect.left, rect.top, rect.right - rect.left, rect.bottom - rect.top, swp_flag | SWP_NOACTIVATE | SWP_FRAMECHANGED); - ::ShowWindow(data->Hwnd, SW_SHOWNA); // This is necessary when we alter the style + ::AdjustWindowRectEx(&rect, vd->DwStyle, FALSE, vd->DwExStyle); // Client to Screen + ::SetWindowPos(vd->Hwnd, insert_after, rect.left, rect.top, rect.right - rect.left, rect.bottom - rect.top, swp_flag | SWP_NOACTIVATE | SWP_FRAMECHANGED); + ::ShowWindow(vd->Hwnd, SW_SHOWNA); // This is necessary when we alter the style viewport->PlatformRequestMove = viewport->PlatformRequestResize = true; } } static ImVec2 ImGui_ImplWin32_GetWindowPos(ImGuiViewport* viewport) { - ImGuiViewportDataWin32* data = (ImGuiViewportDataWin32*)viewport->PlatformUserData; - IM_ASSERT(data->Hwnd != 0); + ImGui_ImplWin32_ViewportData* vd = (ImGui_ImplWin32_ViewportData*)viewport->PlatformUserData; + IM_ASSERT(vd->Hwnd != 0); POINT pos = { 0, 0 }; - ::ClientToScreen(data->Hwnd, &pos); + ::ClientToScreen(vd->Hwnd, &pos); return ImVec2((float)pos.x, (float)pos.y); } static void ImGui_ImplWin32_SetWindowPos(ImGuiViewport* viewport, ImVec2 pos) { - ImGuiViewportDataWin32* data = (ImGuiViewportDataWin32*)viewport->PlatformUserData; - IM_ASSERT(data->Hwnd != 0); + ImGui_ImplWin32_ViewportData* vd = (ImGui_ImplWin32_ViewportData*)viewport->PlatformUserData; + IM_ASSERT(vd->Hwnd != 0); RECT rect = { (LONG)pos.x, (LONG)pos.y, (LONG)pos.x, (LONG)pos.y }; - ::AdjustWindowRectEx(&rect, data->DwStyle, FALSE, data->DwExStyle); - ::SetWindowPos(data->Hwnd, NULL, rect.left, rect.top, 0, 0, SWP_NOZORDER | SWP_NOSIZE | SWP_NOACTIVATE); + ::AdjustWindowRectEx(&rect, vd->DwStyle, FALSE, vd->DwExStyle); + ::SetWindowPos(vd->Hwnd, NULL, rect.left, rect.top, 0, 0, SWP_NOZORDER | SWP_NOSIZE | SWP_NOACTIVATE); } static ImVec2 ImGui_ImplWin32_GetWindowSize(ImGuiViewport* viewport) { - ImGuiViewportDataWin32* data = (ImGuiViewportDataWin32*)viewport->PlatformUserData; - IM_ASSERT(data->Hwnd != 0); + ImGui_ImplWin32_ViewportData* vd = (ImGui_ImplWin32_ViewportData*)viewport->PlatformUserData; + IM_ASSERT(vd->Hwnd != 0); RECT rect; - ::GetClientRect(data->Hwnd, &rect); + ::GetClientRect(vd->Hwnd, &rect); return ImVec2(float(rect.right - rect.left), float(rect.bottom - rect.top)); } static void ImGui_ImplWin32_SetWindowSize(ImGuiViewport* viewport, ImVec2 size) { - ImGuiViewportDataWin32* data = (ImGuiViewportDataWin32*)viewport->PlatformUserData; - IM_ASSERT(data->Hwnd != 0); + ImGui_ImplWin32_ViewportData* vd = (ImGui_ImplWin32_ViewportData*)viewport->PlatformUserData; + IM_ASSERT(vd->Hwnd != 0); RECT rect = { 0, 0, (LONG)size.x, (LONG)size.y }; - ::AdjustWindowRectEx(&rect, data->DwStyle, FALSE, data->DwExStyle); // Client to Screen - ::SetWindowPos(data->Hwnd, NULL, 0, 0, rect.right - rect.left, rect.bottom - rect.top, SWP_NOZORDER | SWP_NOMOVE | SWP_NOACTIVATE); + ::AdjustWindowRectEx(&rect, vd->DwStyle, FALSE, vd->DwExStyle); // Client to Screen + ::SetWindowPos(vd->Hwnd, NULL, 0, 0, rect.right - rect.left, rect.bottom - rect.top, SWP_NOZORDER | SWP_NOMOVE | SWP_NOACTIVATE); } static void ImGui_ImplWin32_SetWindowFocus(ImGuiViewport* viewport) { - ImGuiViewportDataWin32* data = (ImGuiViewportDataWin32*)viewport->PlatformUserData; - IM_ASSERT(data->Hwnd != 0); - ::BringWindowToTop(data->Hwnd); - ::SetForegroundWindow(data->Hwnd); - ::SetFocus(data->Hwnd); + ImGui_ImplWin32_ViewportData* vd = (ImGui_ImplWin32_ViewportData*)viewport->PlatformUserData; + IM_ASSERT(vd->Hwnd != 0); + ::BringWindowToTop(vd->Hwnd); + ::SetForegroundWindow(vd->Hwnd); + ::SetFocus(vd->Hwnd); } static bool ImGui_ImplWin32_GetWindowFocus(ImGuiViewport* viewport) { - ImGuiViewportDataWin32* data = (ImGuiViewportDataWin32*)viewport->PlatformUserData; - IM_ASSERT(data->Hwnd != 0); - return ::GetForegroundWindow() == data->Hwnd; + ImGui_ImplWin32_ViewportData* vd = (ImGui_ImplWin32_ViewportData*)viewport->PlatformUserData; + IM_ASSERT(vd->Hwnd != 0); + return ::GetForegroundWindow() == vd->Hwnd; } static bool ImGui_ImplWin32_GetWindowMinimized(ImGuiViewport* viewport) { - ImGuiViewportDataWin32* data = (ImGuiViewportDataWin32*)viewport->PlatformUserData; - IM_ASSERT(data->Hwnd != 0); - return ::IsIconic(data->Hwnd) != 0; + ImGui_ImplWin32_ViewportData* vd = (ImGui_ImplWin32_ViewportData*)viewport->PlatformUserData; + IM_ASSERT(vd->Hwnd != 0); + return ::IsIconic(vd->Hwnd) != 0; } static void ImGui_ImplWin32_SetWindowTitle(ImGuiViewport* viewport, const char* title) { // ::SetWindowTextA() doesn't properly handle UTF-8 so we explicitely convert our string. - ImGuiViewportDataWin32* data = (ImGuiViewportDataWin32*)viewport->PlatformUserData; - IM_ASSERT(data->Hwnd != 0); + ImGui_ImplWin32_ViewportData* vd = (ImGui_ImplWin32_ViewportData*)viewport->PlatformUserData; + IM_ASSERT(vd->Hwnd != 0); int n = ::MultiByteToWideChar(CP_UTF8, 0, title, -1, NULL, 0); ImVector title_w; title_w.resize(n); ::MultiByteToWideChar(CP_UTF8, 0, title, -1, title_w.Data, n); - ::SetWindowTextW(data->Hwnd, title_w.Data); + ::SetWindowTextW(vd->Hwnd, title_w.Data); } static void ImGui_ImplWin32_SetWindowAlpha(ImGuiViewport* viewport, float alpha) { - ImGuiViewportDataWin32* data = (ImGuiViewportDataWin32*)viewport->PlatformUserData; - IM_ASSERT(data->Hwnd != 0); + ImGui_ImplWin32_ViewportData* vd = (ImGui_ImplWin32_ViewportData*)viewport->PlatformUserData; + IM_ASSERT(vd->Hwnd != 0); IM_ASSERT(alpha >= 0.0f && alpha <= 1.0f); if (alpha < 1.0f) { - DWORD style = ::GetWindowLongW(data->Hwnd, GWL_EXSTYLE) | WS_EX_LAYERED; - ::SetWindowLongW(data->Hwnd, GWL_EXSTYLE, style); - ::SetLayeredWindowAttributes(data->Hwnd, 0, (BYTE)(255 * alpha), LWA_ALPHA); + DWORD style = ::GetWindowLongW(vd->Hwnd, GWL_EXSTYLE) | WS_EX_LAYERED; + ::SetWindowLongW(vd->Hwnd, GWL_EXSTYLE, style); + ::SetLayeredWindowAttributes(vd->Hwnd, 0, (BYTE)(255 * alpha), LWA_ALPHA); } else { - DWORD style = ::GetWindowLongW(data->Hwnd, GWL_EXSTYLE) & ~WS_EX_LAYERED; - ::SetWindowLongW(data->Hwnd, GWL_EXSTYLE, style); + DWORD style = ::GetWindowLongW(vd->Hwnd, GWL_EXSTYLE) & ~WS_EX_LAYERED; + ::SetWindowLongW(vd->Hwnd, GWL_EXSTYLE, style); } } static float ImGui_ImplWin32_GetWindowDpiScale(ImGuiViewport* viewport) { - ImGuiViewportDataWin32* data = (ImGuiViewportDataWin32*)viewport->PlatformUserData; - IM_ASSERT(data->Hwnd != 0); - return ImGui_ImplWin32_GetDpiScaleForHwnd(data->Hwnd); + ImGui_ImplWin32_ViewportData* vd = (ImGui_ImplWin32_ViewportData*)viewport->PlatformUserData; + IM_ASSERT(vd->Hwnd != 0); + return ImGui_ImplWin32_GetDpiScaleForHwnd(vd->Hwnd); } // FIXME-DPI: Testing DPI related ideas @@ -976,10 +976,10 @@ static void ImGui_ImplWin32_InitPlatformInterface() // This is mostly for simplicity and consistency, so that our code (e.g. mouse handling etc.) can use same logic for main and secondary viewports. ImGuiViewport* main_viewport = ImGui::GetMainViewport(); ImGui_ImplWin32_Data* bd = ImGui_ImplWin32_GetBackendData(); - ImGuiViewportDataWin32* data = IM_NEW(ImGuiViewportDataWin32)(); - data->Hwnd = bd->hWnd; - data->HwndOwned = false; - main_viewport->PlatformUserData = data; + ImGui_ImplWin32_ViewportData* vd = IM_NEW(ImGui_ImplWin32_ViewportData)(); + vd->Hwnd = bd->hWnd; + vd->HwndOwned = false; + main_viewport->PlatformUserData = vd; main_viewport->PlatformHandle = (void*)bd->hWnd; }