elias/imgui-rs
1
0
Fork 0
mirror of https://github.com/eliasstepanik/imgui-rs.git synced 2026-01-13 22:48:34 +00:00
Code Issues Packages Projects Releases Wiki Activity

Make sure imgui compiles with docking enabled and disabled

Browse Source
This commit is contained in:
Robin Quint 2022-03-04 13:09:59 +01:00
parent 07503ff500
commit 066d802979
5 changed files with 251 additions and 168 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

239
imgui/src/context.rs
View File

@ -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<UnsafeCell<ClipboardContext>>,
platform_viewport_ctx: Box<UnsafeCell<PlatformViewportContext>>,
renderer_viewport_ctx: Box<UnsafeCell<RendererViewportContext>>,
#[cfg(feature = "docking")]
platform_viewport_ctx: Box<UnsafeCell<crate::PlatformViewportContext>>,
#[cfg(feature = "docking")]
renderer_viewport_ctx: Box<UnsafeCell<crate::RendererViewportContext>>,
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<T: PlatformViewportBackend>(&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<T: RendererViewportBackend>(&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<SharedFontAtlas>) -> 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<Item = &Viewport> {
let slice = self.platform_io().viewports.as_slice();
unsafe {
slice.iter().map(|ptr| &**ptr)
}
}
pub fn viewports_mut(&mut self) -> impl Iterator<Item = &mut Viewport> {
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<Item = &crate::Viewport> {
let slice = self.platform_io().viewports.as_slice();
unsafe { slice.iter().map(|ptr| &**ptr) }
}
pub fn viewports_mut(&mut self) -> impl Iterator<Item = &mut crate::Viewport> {
let slice = self.platform_io_mut().viewports.as_slice();
unsafe { slice.iter().map(|ptr| &mut **ptr) }
}
pub fn set_platform_backend<T: crate::PlatformViewportBackend>(&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<T: crate::RendererViewportBackend>(&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());
}
}
}

2
imgui/src/internal.rs
View File

@ -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)]

4
imgui/src/io.rs
View File

@ -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;

6
imgui/src/lib.rs
View File

@ -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;

168
imgui/src/platform_io.rs
View File

@ -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<unsafe extern "C" fn(*mut Viewport)>,
@ -15,7 +20,8 @@ pub struct PlatformIo {
pub(crate) platform_set_window_focus: Option<unsafe extern "C" fn(*mut Viewport)>,
pub(crate) platform_get_window_focus: Option<unsafe extern "C" fn(*mut Viewport) -> bool>,
pub(crate) platform_get_window_minimized: Option<unsafe extern "C" fn(*mut Viewport) -> bool>,
pub(crate) platform_set_window_title: Option<unsafe extern "C" fn(*mut Viewport, *const c_char)>,
pub(crate) platform_set_window_title:
Option<unsafe extern "C" fn(*mut Viewport, *const c_char)>,
pub(crate) platform_set_window_alpha: Option<unsafe extern "C" fn(*mut Viewport, f32)>,
pub(crate) platform_update_window: Option<unsafe extern "C" fn(*mut Viewport)>,
pub(crate) platform_render_window: Option<unsafe extern "C" fn(*mut Viewport, *mut c_void)>,
@ -23,7 +29,8 @@ pub struct PlatformIo {
pub(crate) platform_get_window_dpi_scale: Option<unsafe extern "C" fn(*mut Viewport) -> f32>,
pub(crate) platform_on_changed_viewport: Option<unsafe extern "C" fn(*mut Viewport)>,
pub(crate) platform_set_ime_input_pos: Option<unsafe extern "C" fn(*mut Viewport, sys::ImVec2)>,
pub(crate) platform_create_vk_surface: Option<unsafe extern "C" fn(*mut Viewport, u64, *const c_void, *mut u64) -> c_int>,
pub(crate) platform_create_vk_surface:
Option<unsafe extern "C" fn(*mut Viewport, u64, *const c_void, *mut u64) -> c_int>,
pub(crate) renderer_create_window: Option<unsafe extern "C" fn(*mut Viewport)>,
pub(crate) renderer_destroy_window: Option<unsafe extern "C" fn(*mut Viewport)>,
@ -42,8 +49,14 @@ unsafe impl RawCast<sys::ImGuiPlatformIO> for PlatformIo {}
#[cfg(test)]
fn test_platform_io_memory_layout() {
use std::mem;
assert_eq!(mem::size_of::<PlatformIo>(), mem::size_of::<sys::ImGuiPlatformIO>());
assert_eq!(mem::align_of::<PlatformIo>(), mem::align_of::<sys::ImGuiPlatformIO>());
assert_eq!(
mem::size_of::<PlatformIo>(),
mem::size_of::<sys::ImGuiPlatformIO>()
);
assert_eq!(
mem::align_of::<PlatformIo>(),
mem::align_of::<sys::ImGuiPlatformIO>()
);
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::<Viewport>(), mem::size_of::<sys::ImGuiViewport>());
assert_eq!(mem::align_of::<Viewport>(), mem::align_of::<sys::ImGuiViewport>());
assert_eq!(
mem::size_of::<Viewport>(),
mem::size_of::<sys::ImGuiViewport>()
);
assert_eq!(
mem::align_of::<Viewport>(),
mem::align_of::<sys::ImGuiViewport>()
);
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::<PlatformMonitor>(), mem::size_of::<sys::ImGuiPlatformMonitor>());
assert_eq!(mem::align_of::<PlatformMonitor>(), mem::align_of::<sys::ImGuiPlatformMonitor>());
assert_eq!(
mem::size_of::<PlatformMonitor>(),
mem::size_of::<sys::ImGuiPlatformMonitor>()
);
assert_eq!(
mem::align_of::<PlatformMonitor>(),
mem::align_of::<sys::ImGuiPlatformMonitor>()
);
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),
);
}