From 066d802979e52edefd5921d6b71d519b18fffcef Mon Sep 17 00:00:00 2001 From: Robin Quint Date: Fri, 4 Mar 2022 13:09:59 +0100 Subject: [PATCH] Make sure imgui compiles with docking enabled and disabled --- imgui/src/context.rs | 239 +++++++++++++++++++++------------------ imgui/src/internal.rs | 2 +- imgui/src/io.rs | 4 +- imgui/src/lib.rs | 6 +- imgui/src/platform_io.rs | 168 ++++++++++++++++++--------- 5 files changed, 251 insertions(+), 168 deletions(-) diff --git a/imgui/src/context.rs b/imgui/src/context.rs index 1f843c8..75d018d 100644 --- a/imgui/src/context.rs +++ b/imgui/src/context.rs @@ -3,13 +3,13 @@ use std::cell::UnsafeCell; use std::ffi::{CStr, CString}; use std::ops::Drop; use std::path::PathBuf; -use std::ptr::{self, null_mut}; +use std::ptr; use crate::clipboard::{ClipboardBackend, ClipboardContext}; use crate::fonts::atlas::{FontAtlas, FontId, SharedFontAtlas}; use crate::io::Io; use crate::style::Style; -use crate::{sys, DrawData, PlatformIo, PlatformViewportContext, RendererViewportContext, PlatformViewportBackend, RendererViewportBackend, Viewport, Id}; +use crate::{sys, DrawData}; use crate::{MouseCursor, Ui}; /// An imgui-rs context. @@ -60,8 +60,10 @@ pub struct Context { // imgui a mutable pointer to it. clipboard_ctx: Box>, - platform_viewport_ctx: Box>, - renderer_viewport_ctx: Box>, + #[cfg(feature = "docking")] + platform_viewport_ctx: Box>, + #[cfg(feature = "docking")] + renderer_viewport_ctx: Box>, ui: Ui, } @@ -219,67 +221,6 @@ impl Context { io.clipboard_user_data = clipboard_ctx.get() as *mut _; self.clipboard_ctx = clipboard_ctx; } - pub fn set_platform_backend(&mut self, backend: T) { - let ctx = Box::new(UnsafeCell::new(PlatformViewportContext { - backend: Box::new(backend), - })); - - let io = self.io_mut(); - io.backend_platform_user_data = ctx.get() as *mut _; - - let pio = self.platform_io_mut(); - pio.platform_create_window = Some(crate::platform_io::platform_create_window); - pio.platform_destroy_window = Some(crate::platform_io::platform_destroy_window); - pio.platform_show_window = Some(crate::platform_io::platform_show_window); - pio.platform_set_window_pos = Some(crate::platform_io::platform_set_window_pos); - // pio.platform_get_window_pos = Some(crate::platform_io::platform_get_window_pos); - unsafe { - crate::platform_io::ImGuiPlatformIO_Set_Platform_GetWindowPos(pio, crate::platform_io::platform_get_window_pos); - } - pio.platform_set_window_size = Some(crate::platform_io::platform_set_window_size); - // pio.platform_get_window_size = Some(crate::platform_io::platform_get_window_size); - unsafe { - crate::platform_io::ImGuiPlatformIO_Set_Platform_GetWindowSize(pio, crate::platform_io::platform_get_window_size); - } - pio.platform_set_window_focus = Some(crate::platform_io::platform_set_window_focus); - pio.platform_get_window_focus = Some(crate::platform_io::platform_get_window_focus); - pio.platform_get_window_minimized = Some(crate::platform_io::platform_get_window_minimized); - pio.platform_set_window_title = Some(crate::platform_io::platform_set_window_title); - pio.platform_set_window_alpha = Some(crate::platform_io::platform_set_window_alpha); - pio.platform_update_window = Some(crate::platform_io::platform_update_window); - pio.platform_render_window = Some(crate::platform_io::platform_render_window); - pio.platform_swap_buffers = Some(crate::platform_io::platform_swap_buffers); - pio.platform_create_vk_surface = Some(crate::platform_io::platform_create_vk_surface); - - self.platform_viewport_ctx = ctx; - } - pub fn set_renderer_backend(&mut self, backend: T) { - let ctx = Box::new(UnsafeCell::new(RendererViewportContext { - backend: Box::new(backend), - })); - - let io = self.io_mut(); - io.backend_renderer_user_data = ctx.get() as *mut _; - - let pio = self.platform_io_mut(); - pio.renderer_create_window = Some(crate::platform_io::renderer_create_window); - pio.renderer_destroy_window = Some(crate::platform_io::renderer_destroy_window); - pio.renderer_set_window_size = Some(crate::platform_io::renderer_set_window_size); - pio.renderer_render_window = Some(crate::platform_io::renderer_render_window); - pio.renderer_swap_buffers = Some(crate::platform_io::renderer_swap_buffers); - - self.renderer_viewport_ctx = ctx; - } - pub fn update_platform_windows(&mut self) { - unsafe { - sys::igUpdatePlatformWindows(); - } - } - pub fn render_platform_windows_default(&mut self) { - unsafe { - sys::igRenderPlatformWindowsDefault(null_mut(), null_mut()); - } - } fn create_internal(mut shared_font_atlas: Option) -> Self { let _guard = CTX_MUTEX.lock(); assert!( @@ -303,8 +244,14 @@ impl Context { platform_name: None, renderer_name: None, clipboard_ctx: Box::new(ClipboardContext::dummy().into()), - platform_viewport_ctx: Box::new(UnsafeCell::new(PlatformViewportContext::dummy())), - renderer_viewport_ctx: Box::new(UnsafeCell::new(RendererViewportContext::dummy())), + #[cfg(feature = "docking")] + platform_viewport_ctx: Box::new(UnsafeCell::new( + crate::PlatformViewportContext::dummy(), + )), + #[cfg(feature = "docking")] + renderer_viewport_ctx: Box::new(UnsafeCell::new( + crate::RendererViewportContext::dummy(), + )), ui: Ui { buffer: UnsafeCell::new(crate::string::UiBuffer::new(1024)), }, @@ -394,8 +341,14 @@ impl SuspendedContext { platform_name: None, renderer_name: None, clipboard_ctx: Box::new(ClipboardContext::dummy().into()), - platform_viewport_ctx: Box::new(UnsafeCell::new(PlatformViewportContext::dummy())), - renderer_viewport_ctx: Box::new(UnsafeCell::new(RendererViewportContext::dummy())), + #[cfg(feature = "docking")] + platform_viewport_ctx: Box::new(UnsafeCell::new( + crate::PlatformViewportContext::dummy(), + )), + #[cfg(feature = "docking")] + renderer_viewport_ctx: Box::new(UnsafeCell::new( + crate::RendererViewportContext::dummy(), + )), ui: Ui { buffer: UnsafeCell::new(crate::string::UiBuffer::new(1024)), }, @@ -547,50 +500,6 @@ impl Context { &mut *(sys::igGetIO() as *mut Io) } } - pub fn platform_io(&self) -> &PlatformIo { - unsafe { - // safe because PlatformIo is a transparent wrapper around sys::ImGuiPlatformIO - &*(sys::igGetPlatformIO() as *const PlatformIo) - } - } - pub fn platform_io_mut(&mut self) -> &mut PlatformIo { - unsafe { - // safe because PlatformIo is a transparent wrapper around sys::ImGuiPlatformIO - &mut *(sys::igGetPlatformIO() as *mut PlatformIo) - } - } - pub fn main_viewport(&self) -> &Viewport { - unsafe { - &*(sys::igGetMainViewport() as *mut Viewport) - } - } - pub fn main_viewport_mut(&mut self) -> &mut Viewport { - unsafe { - &mut *(sys::igGetMainViewport() as *mut Viewport) - } - } - pub fn viewport_by_id(&self, id: Id) -> Option<&Viewport> { - unsafe { - (sys::igFindViewportByID(id.0) as *const Viewport).as_ref() - } - } - pub fn viewport_by_id_mut(&mut self, id: Id) -> Option<&mut Viewport> { - unsafe { - (sys::igFindViewportByID(id.0) as *mut Viewport).as_mut() - } - } - pub fn viewports(&self) -> impl Iterator { - let slice = self.platform_io().viewports.as_slice(); - unsafe { - slice.iter().map(|ptr| &**ptr) - } - } - pub fn viewports_mut(&mut self) -> impl Iterator { - let slice = self.platform_io_mut().viewports.as_slice(); - unsafe { - slice.iter().map(|ptr| &mut **ptr) - } - } /// Returns an immutable reference to the user interface style #[doc(alias = "GetStyle")] pub fn style(&self) -> &Style { @@ -680,3 +589,107 @@ impl Context { } } } + +#[cfg(feature = "docking")] +impl Context { + pub fn platform_io(&self) -> &crate::PlatformIo { + unsafe { + // safe because PlatformIo is a transparent wrapper around sys::ImGuiPlatformIO + &*(sys::igGetPlatformIO() as *const crate::PlatformIo) + } + } + pub fn platform_io_mut(&mut self) -> &mut crate::PlatformIo { + unsafe { + // safe because PlatformIo is a transparent wrapper around sys::ImGuiPlatformIO + &mut *(sys::igGetPlatformIO() as *mut crate::PlatformIo) + } + } + pub fn main_viewport(&self) -> &crate::Viewport { + unsafe { &*(sys::igGetMainViewport() as *mut crate::Viewport) } + } + pub fn main_viewport_mut(&mut self) -> &mut crate::Viewport { + unsafe { &mut *(sys::igGetMainViewport() as *mut crate::Viewport) } + } + pub fn viewport_by_id(&self, id: crate::Id) -> Option<&crate::Viewport> { + unsafe { (sys::igFindViewportByID(id.0) as *const crate::Viewport).as_ref() } + } + pub fn viewport_by_id_mut(&mut self, id: crate::Id) -> Option<&mut crate::Viewport> { + unsafe { (sys::igFindViewportByID(id.0) as *mut crate::Viewport).as_mut() } + } + pub fn viewports(&self) -> impl Iterator { + let slice = self.platform_io().viewports.as_slice(); + unsafe { slice.iter().map(|ptr| &**ptr) } + } + pub fn viewports_mut(&mut self) -> impl Iterator { + let slice = self.platform_io_mut().viewports.as_slice(); + unsafe { slice.iter().map(|ptr| &mut **ptr) } + } + + pub fn set_platform_backend(&mut self, backend: T) { + let ctx = Box::new(UnsafeCell::new(crate::PlatformViewportContext { + backend: Box::new(backend), + })); + + let io = self.io_mut(); + io.backend_platform_user_data = ctx.get() as *mut _; + + let pio = self.platform_io_mut(); + pio.platform_create_window = Some(crate::platform_io::platform_create_window); + pio.platform_destroy_window = Some(crate::platform_io::platform_destroy_window); + pio.platform_show_window = Some(crate::platform_io::platform_show_window); + pio.platform_set_window_pos = Some(crate::platform_io::platform_set_window_pos); + // pio.platform_get_window_pos = Some(crate::platform_io::platform_get_window_pos); + unsafe { + crate::platform_io::ImGuiPlatformIO_Set_Platform_GetWindowPos( + pio, + crate::platform_io::platform_get_window_pos, + ); + } + pio.platform_set_window_size = Some(crate::platform_io::platform_set_window_size); + // pio.platform_get_window_size = Some(crate::platform_io::platform_get_window_size); + unsafe { + crate::platform_io::ImGuiPlatformIO_Set_Platform_GetWindowSize( + pio, + crate::platform_io::platform_get_window_size, + ); + } + pio.platform_set_window_focus = Some(crate::platform_io::platform_set_window_focus); + pio.platform_get_window_focus = Some(crate::platform_io::platform_get_window_focus); + pio.platform_get_window_minimized = Some(crate::platform_io::platform_get_window_minimized); + pio.platform_set_window_title = Some(crate::platform_io::platform_set_window_title); + pio.platform_set_window_alpha = Some(crate::platform_io::platform_set_window_alpha); + pio.platform_update_window = Some(crate::platform_io::platform_update_window); + pio.platform_render_window = Some(crate::platform_io::platform_render_window); + pio.platform_swap_buffers = Some(crate::platform_io::platform_swap_buffers); + pio.platform_create_vk_surface = Some(crate::platform_io::platform_create_vk_surface); + + self.platform_viewport_ctx = ctx; + } + pub fn set_renderer_backend(&mut self, backend: T) { + let ctx = Box::new(UnsafeCell::new(crate::RendererViewportContext { + backend: Box::new(backend), + })); + + let io = self.io_mut(); + io.backend_renderer_user_data = ctx.get() as *mut _; + + let pio = self.platform_io_mut(); + pio.renderer_create_window = Some(crate::platform_io::renderer_create_window); + pio.renderer_destroy_window = Some(crate::platform_io::renderer_destroy_window); + pio.renderer_set_window_size = Some(crate::platform_io::renderer_set_window_size); + pio.renderer_render_window = Some(crate::platform_io::renderer_render_window); + pio.renderer_swap_buffers = Some(crate::platform_io::renderer_swap_buffers); + + self.renderer_viewport_ctx = ctx; + } + pub fn update_platform_windows(&mut self) { + unsafe { + sys::igUpdatePlatformWindows(); + } + } + pub fn render_platform_windows_default(&mut self) { + unsafe { + sys::igRenderPlatformWindowsDefault(std::ptr::null_mut(), std::ptr::null_mut()); + } + } +} diff --git a/imgui/src/internal.rs b/imgui/src/internal.rs index d7869a3..7116cda 100644 --- a/imgui/src/internal.rs +++ b/imgui/src/internal.rs @@ -1,6 +1,6 @@ //! Internal raw utilities (don't use unless you know what you're doing!) -use std::{slice, mem::size_of}; +use std::{mem::size_of, slice}; /// A generic version of the raw imgui-sys ImVector struct types #[repr(C)] diff --git a/imgui/src/io.rs b/imgui/src/io.rs index 7681ed8..46f933a 100644 --- a/imgui/src/io.rs +++ b/imgui/src/io.rs @@ -59,8 +59,10 @@ bitflags! { #[cfg(feature = "docking")] const VIEWPORTS_ENABLE = sys::ImGuiConfigFlags_ViewportsEnable; } +} - #[cfg(feature = "docking")] +#[cfg(feature = "docking")] +bitflags! { #[repr(transparent)] pub struct ViewportFlags: u32 { const IS_PLATFORM_WINDOW = sys::ImGuiViewportFlags_IsPlatformWindow; diff --git a/imgui/src/lib.rs b/imgui/src/lib.rs index 6958686..5edb9a2 100644 --- a/imgui/src/lib.rs +++ b/imgui/src/lib.rs @@ -20,9 +20,10 @@ pub use self::input::keyboard::*; pub use self::input::mouse::*; pub use self::input_widget::*; pub use self::io::*; -pub use self::platform_io::*; pub use self::layout::*; pub use self::list_clipper::ListClipper; +#[cfg(feature = "docking")] +pub use self::platform_io::*; pub use self::plothistogram::PlotHistogram; pub use self::plotlines::PlotLines; pub use self::popups::*; @@ -69,10 +70,11 @@ mod input; mod input_widget; pub mod internal; mod io; -mod platform_io; mod layout; mod list_clipper; mod math; +#[cfg(feature = "docking")] +mod platform_io; mod plothistogram; mod plotlines; mod popups; diff --git a/imgui/src/platform_io.rs b/imgui/src/platform_io.rs index 9e0c696..889cbf8 100644 --- a/imgui/src/platform_io.rs +++ b/imgui/src/platform_io.rs @@ -1,8 +1,13 @@ -use std::{os::raw::{c_char, c_int}, ffi::{c_void, CStr}}; +use std::{ + ffi::{c_void, CStr}, + os::raw::{c_char, c_int}, +}; -use crate::{internal::{ImVector, RawCast}, ViewportFlags, Io}; +use crate::{ + internal::{ImVector, RawCast}, + Io, ViewportFlags, +}; -#[cfg(feature = "docking")] #[repr(C)] pub struct PlatformIo { pub(crate) platform_create_window: Option, @@ -15,7 +20,8 @@ pub struct PlatformIo { pub(crate) platform_set_window_focus: Option, pub(crate) platform_get_window_focus: Option bool>, pub(crate) platform_get_window_minimized: Option bool>, - pub(crate) platform_set_window_title: Option, + pub(crate) platform_set_window_title: + Option, pub(crate) platform_set_window_alpha: Option, pub(crate) platform_update_window: Option, pub(crate) platform_render_window: Option, @@ -23,7 +29,8 @@ pub struct PlatformIo { pub(crate) platform_get_window_dpi_scale: Option f32>, pub(crate) platform_on_changed_viewport: Option, pub(crate) platform_set_ime_input_pos: Option, - pub(crate) platform_create_vk_surface: Option c_int>, + pub(crate) platform_create_vk_surface: + Option c_int>, pub(crate) renderer_create_window: Option, pub(crate) renderer_destroy_window: Option, @@ -42,8 +49,14 @@ unsafe impl RawCast for PlatformIo {} #[cfg(test)] fn test_platform_io_memory_layout() { use std::mem; - assert_eq!(mem::size_of::(), mem::size_of::()); - assert_eq!(mem::align_of::(), mem::align_of::()); + assert_eq!( + mem::size_of::(), + mem::size_of::() + ); + assert_eq!( + mem::align_of::(), + mem::align_of::() + ); use sys::ImGuiPlatformIO; macro_rules! assert_field_offset { ($l:ident, $r:ident) => { @@ -101,91 +114,116 @@ pub trait PlatformViewportBackend: 'static { fn update_window(&mut self, viewport: &mut Viewport); fn render_window(&mut self, viewport: &mut Viewport); fn swap_buffers(&mut self, viewport: &mut Viewport); - fn create_vk_surface(&mut self, viewport: &mut Viewport, instance: u64, out_surface: &mut u64) -> i32; + fn create_vk_surface( + &mut self, + viewport: &mut Viewport, + instance: u64, + out_surface: &mut u64, + ) -> i32; } fn get_platform_ctx() -> &'static mut PlatformViewportContext { unsafe { - &mut *((*(sys::igGetIO() as *const Io)).backend_platform_user_data as *mut PlatformViewportContext) + &mut *((*(sys::igGetIO() as *const Io)).backend_platform_user_data + as *mut PlatformViewportContext) } } fn get_renderer_ctx() -> &'static mut RendererViewportContext { unsafe { - &mut *((*(sys::igGetIO() as *const Io)).backend_platform_user_data as *mut RendererViewportContext) + &mut *((*(sys::igGetIO() as *const Io)).backend_platform_user_data + as *mut RendererViewportContext) } } pub(crate) extern "C" fn platform_create_window(viewport: *mut Viewport) { let ctx = get_platform_ctx(); - ctx.backend.create_window(unsafe{&mut *viewport}); + ctx.backend.create_window(unsafe { &mut *viewport }); } pub(crate) extern "C" fn platform_destroy_window(viewport: *mut Viewport) { let ctx = get_platform_ctx(); - ctx.backend.destroy_window(unsafe{&mut *viewport}); + ctx.backend.destroy_window(unsafe { &mut *viewport }); } pub(crate) extern "C" fn platform_show_window(viewport: *mut Viewport) { let ctx = get_platform_ctx(); - ctx.backend.show_window(unsafe{&mut *viewport}); + ctx.backend.show_window(unsafe { &mut *viewport }); } pub(crate) extern "C" fn platform_set_window_pos(viewport: *mut Viewport, pos: sys::ImVec2) { let ctx = get_platform_ctx(); - ctx.backend.set_window_pos(unsafe{&mut *viewport}, [pos.x, pos.y]); + ctx.backend + .set_window_pos(unsafe { &mut *viewport }, [pos.x, pos.y]); } -pub(crate) extern "C" fn platform_get_window_pos(viewport: *mut Viewport, out_pos: *mut sys::ImVec2) { +pub(crate) extern "C" fn platform_get_window_pos( + viewport: *mut Viewport, + out_pos: *mut sys::ImVec2, +) { let ctx = get_platform_ctx(); - let pos = ctx.backend.get_window_pos(unsafe{&mut *viewport}); + let pos = ctx.backend.get_window_pos(unsafe { &mut *viewport }); unsafe { *out_pos = sys::ImVec2::new(pos[0], pos[1]); } } pub(crate) extern "C" fn platform_set_window_size(viewport: *mut Viewport, size: sys::ImVec2) { let ctx = get_platform_ctx(); - ctx.backend.set_window_size(unsafe{&mut *viewport}, [size.x, size.y]); + ctx.backend + .set_window_size(unsafe { &mut *viewport }, [size.x, size.y]); } -pub(crate) extern "C" fn platform_get_window_size(viewport: *mut Viewport, out_size: *mut sys::ImVec2) { +pub(crate) extern "C" fn platform_get_window_size( + viewport: *mut Viewport, + out_size: *mut sys::ImVec2, +) { let ctx = get_platform_ctx(); - let size = ctx.backend.get_window_size(unsafe{&mut *viewport}); + let size = ctx.backend.get_window_size(unsafe { &mut *viewport }); unsafe { *out_size = sys::ImVec2::new(size[0], size[1]); } } pub(crate) extern "C" fn platform_set_window_focus(viewport: *mut Viewport) { let ctx = get_platform_ctx(); - ctx.backend.set_window_focus(unsafe{&mut *viewport}); + ctx.backend.set_window_focus(unsafe { &mut *viewport }); } pub(crate) extern "C" fn platform_get_window_focus(viewport: *mut Viewport) -> bool { let ctx = get_platform_ctx(); - ctx.backend.get_window_focus(unsafe{&mut *viewport}) + ctx.backend.get_window_focus(unsafe { &mut *viewport }) } pub(crate) extern "C" fn platform_get_window_minimized(viewport: *mut Viewport) -> bool { let ctx = get_platform_ctx(); - ctx.backend.get_window_minimized(unsafe{&mut *viewport}) + ctx.backend.get_window_minimized(unsafe { &mut *viewport }) } pub(crate) extern "C" fn platform_set_window_title(viewport: *mut Viewport, title: *const c_char) { let ctx = get_platform_ctx(); let title = unsafe { CStr::from_ptr(title).to_str().unwrap() }; - ctx.backend.set_window_title(unsafe{&mut *viewport}, title); + ctx.backend + .set_window_title(unsafe { &mut *viewport }, title); } pub(crate) extern "C" fn platform_set_window_alpha(viewport: *mut Viewport, alpha: f32) { let ctx = get_platform_ctx(); - ctx.backend.set_window_alpha(unsafe{&mut *viewport}, alpha); + ctx.backend + .set_window_alpha(unsafe { &mut *viewport }, alpha); } pub(crate) extern "C" fn platform_update_window(viewport: *mut Viewport) { let ctx = get_platform_ctx(); - ctx.backend.update_window(unsafe{&mut *viewport}); + ctx.backend.update_window(unsafe { &mut *viewport }); } pub(crate) extern "C" fn platform_render_window(viewport: *mut Viewport, _arg: *mut c_void) { let ctx = get_platform_ctx(); - ctx.backend.render_window(unsafe{&mut *viewport}); + ctx.backend.render_window(unsafe { &mut *viewport }); } pub(crate) extern "C" fn platform_swap_buffers(viewport: *mut Viewport, _arg: *mut c_void) { let ctx = get_platform_ctx(); - ctx.backend.swap_buffers(unsafe{&mut *viewport}); + ctx.backend.swap_buffers(unsafe { &mut *viewport }); } -pub(crate) extern "C" fn platform_create_vk_surface(viewport: *mut Viewport, instance: u64, _arg: *const c_void, out_surface: *mut u64) -> c_int { +pub(crate) extern "C" fn platform_create_vk_surface( + viewport: *mut Viewport, + instance: u64, + _arg: *const c_void, + out_surface: *mut u64, +) -> c_int { let ctx = get_platform_ctx(); - ctx.backend.create_vk_surface(unsafe{&mut *viewport}, instance, unsafe{&mut *out_surface}) + ctx.backend + .create_vk_surface(unsafe { &mut *viewport }, instance, unsafe { + &mut *out_surface + }) } pub(crate) struct DummyPlatformViewportBackend {} @@ -250,7 +288,12 @@ impl PlatformViewportBackend for DummyPlatformViewportBackend { unimplemented!() } - fn create_vk_surface(&mut self, _viewport: &mut Viewport, _instance: u64, _out_surface: &mut u64) -> i32 { + fn create_vk_surface( + &mut self, + _viewport: &mut Viewport, + _instance: u64, + _out_surface: &mut u64, + ) -> i32 { unimplemented!() } } @@ -262,7 +305,7 @@ pub(crate) struct PlatformViewportContext { impl PlatformViewportContext { pub(crate) fn dummy() -> Self { Self { - backend: Box::new(DummyPlatformViewportBackend{}), + backend: Box::new(DummyPlatformViewportBackend {}), } } } @@ -277,23 +320,24 @@ pub trait RendererViewportBackend: 'static { pub(crate) extern "C" fn renderer_create_window(viewport: *mut Viewport) { let ctx = get_renderer_ctx(); - ctx.backend.create_window(unsafe{&mut *viewport}); + ctx.backend.create_window(unsafe { &mut *viewport }); } pub(crate) extern "C" fn renderer_destroy_window(viewport: *mut Viewport) { let ctx = get_renderer_ctx(); - ctx.backend.destroy_window(unsafe{&mut *viewport}); + ctx.backend.destroy_window(unsafe { &mut *viewport }); } pub(crate) extern "C" fn renderer_set_window_size(viewport: *mut Viewport, size: sys::ImVec2) { let ctx = get_renderer_ctx(); - ctx.backend.set_window_size(unsafe{&mut *viewport}, [size.x, size.y]); + ctx.backend + .set_window_size(unsafe { &mut *viewport }, [size.x, size.y]); } pub(crate) extern "C" fn renderer_render_window(viewport: *mut Viewport, _arg: *mut c_void) { let ctx = get_renderer_ctx(); - ctx.backend.render_window(unsafe{&mut *viewport}); + ctx.backend.render_window(unsafe { &mut *viewport }); } pub(crate) extern "C" fn renderer_swap_buffers(viewport: *mut Viewport, _arg: *mut c_void) { let ctx = get_renderer_ctx(); - ctx.backend.swap_buffers(unsafe{&mut *viewport}); + ctx.backend.swap_buffers(unsafe { &mut *viewport }); } pub(crate) struct DummyRendererViewportBackend {} @@ -326,24 +370,23 @@ pub(crate) struct RendererViewportContext { impl RendererViewportContext { pub(crate) fn dummy() -> Self { Self { - backend: Box::new(DummyRendererViewportBackend{}), + backend: Box::new(DummyRendererViewportBackend {}), } } } -#[cfg(feature = "docking")] #[repr(C)] pub struct Viewport { pub id: crate::Id, pub flags: ViewportFlags, - pub(crate) pos: [f32; 2], - pub(crate) size: [f32; 2], - pub(crate) work_pos: [f32; 2], - pub(crate) work_size: [f32; 2], - pub(crate) dpi_scale: f32, + pub pos: [f32; 2], + pub size: [f32; 2], + pub work_pos: [f32; 2], + pub work_size: [f32; 2], + pub dpi_scale: f32, pub(crate) parent_viewport_id: crate::Id, pub(crate) draw_data: *mut crate::DrawData, - + pub renderer_user_data: *mut c_void, pub platform_user_data: *mut c_void, pub platform_handle: *mut c_void, @@ -353,12 +396,24 @@ pub struct Viewport { pub platform_request_close: bool, } +impl Viewport { + pub fn draw_data(&self) -> &crate::DrawData { + unsafe { &*self.draw_data } + } +} + #[test] #[cfg(test)] fn test_viewport_memory_layout() { use std::mem; - assert_eq!(mem::size_of::(), mem::size_of::()); - assert_eq!(mem::align_of::(), mem::align_of::()); + assert_eq!( + mem::size_of::(), + mem::size_of::() + ); + assert_eq!( + mem::align_of::(), + mem::align_of::() + ); use sys::ImGuiViewport; macro_rules! assert_field_offset { ($l:ident, $r:ident) => { @@ -388,7 +443,6 @@ fn test_viewport_memory_layout() { assert_field_offset!(platform_request_close, PlatformRequestClose); } -#[cfg(feature = "docking")] #[repr(C)] pub struct PlatformMonitor { pub main_pos: [f32; 2], @@ -402,8 +456,14 @@ pub struct PlatformMonitor { #[cfg(test)] fn test_platform_monitor_memory_layout() { use std::mem; - assert_eq!(mem::size_of::(), mem::size_of::()); - assert_eq!(mem::align_of::(), mem::align_of::()); + assert_eq!( + mem::size_of::(), + mem::size_of::() + ); + assert_eq!( + mem::align_of::(), + mem::align_of::() + ); use sys::ImGuiPlatformMonitor; macro_rules! assert_field_offset { ($l:ident, $r:ident) => { @@ -422,6 +482,12 @@ fn test_platform_monitor_memory_layout() { } extern "C" { - pub(crate) fn ImGuiPlatformIO_Set_Platform_GetWindowPos(pio: *mut PlatformIo, func: extern "C" fn(*mut Viewport, *mut sys::ImVec2)); - pub(crate) fn ImGuiPlatformIO_Set_Platform_GetWindowSize(pio: *mut PlatformIo, func: extern "C" fn(*mut Viewport, *mut sys::ImVec2)); + pub(crate) fn ImGuiPlatformIO_Set_Platform_GetWindowPos( + pio: *mut PlatformIo, + func: extern "C" fn(*mut Viewport, *mut sys::ImVec2), + ); + pub(crate) fn ImGuiPlatformIO_Set_Platform_GetWindowSize( + pio: *mut PlatformIo, + func: extern "C" fn(*mut Viewport, *mut sys::ImVec2), + ); }