diff --git a/.travis.yml b/.travis.yml index 3303ac5..254b074 100644 --- a/.travis.yml +++ b/.travis.yml @@ -5,7 +5,7 @@ rust: - stable - beta - nightly - - 1.15.1 + - 1.16.0 os: - linux - osx @@ -18,8 +18,5 @@ before_install: - git submodule update --init --recursive script: - # 1.15 doesn't yet support cargo build --all - - cd imgui-sys && cargo build --verbose && cd .. - - cd imgui-glium-renderer && cargo build --verbose && cd .. - - cargo build --verbose + - cargo build --all --verbose - cargo test --all --verbose diff --git a/CHANGELOG.markdown b/CHANGELOG.markdown index e100ba8..6404882 100644 --- a/CHANGELOG.markdown +++ b/CHANGELOG.markdown @@ -5,6 +5,8 @@ ### Added - ImString owned type for strings +- Experimental support for gfx-rs in imgui-sys +- Experimental renderer for gfx-rs ### Changed @@ -32,6 +34,8 @@ - Support for 2-4 -element float sliders - `ImVec4::zero()` - `Into` array and tuple conversions for ImVec2 and ImVec4 +- gfx 0.15 support in imgui-sys +- gfx 0.15 renderer implementation ### Changed diff --git a/Cargo.toml b/Cargo.toml index 12a5211..e0f1302 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -16,4 +16,4 @@ travis-ci = { repository = "gekkio/imgui-rs" } imgui-sys = { version = "0.0.14-pre", path = "imgui-sys" } [workspace] -members = ["imgui-examples", "imgui-sys", "imgui-glium-renderer"] +members = ["imgui-examples", "imgui-sys", "imgui-gfx-renderer", "imgui-glium-renderer"] diff --git a/README.markdown b/README.markdown index 93fda3a..c2bc5b0 100644 --- a/README.markdown +++ b/README.markdown @@ -2,7 +2,7 @@ **Still fairly experimental!** -Minimum Rust version: 1.15 +Minimum Rust version: 1.16 [![Build Status](https://travis-ci.org/Gekkio/imgui-rs.svg?branch=master)](https://travis-ci.org/Gekkio/imgui-rs) [![Latest release on crates.io](https://meritbadge.herokuapp.com/imgui)](https://crates.io/crates/imgui) diff --git a/imgui-examples/Cargo.toml b/imgui-examples/Cargo.toml index dd40129..b68457d 100644 --- a/imgui-examples/Cargo.toml +++ b/imgui-examples/Cargo.toml @@ -9,7 +9,11 @@ license = "MIT/Apache-2.0" publish = false [dev-dependencies] +gfx = "0.16" +gfx_window_glutin = "0.16" glium = { version = "0.16", default-features = true } +glutin = "0.8" imgui = { version = "0.0.14-pre", path = "../" } +imgui-gfx-renderer = { version = "0.0.14-pre", path = "../imgui-gfx-renderer" } imgui-glium-renderer = { version = "0.0.14-pre", path = "../imgui-glium-renderer" } -imgui-sys = { version = "0.0.14-pre", path = "../imgui-sys", features = ["glium"] } +imgui-sys = { version = "0.0.14-pre", path = "../imgui-sys", features = ["gfx", "glium"] } diff --git a/imgui-examples/examples/hello_gfx.rs b/imgui-examples/examples/hello_gfx.rs new file mode 100644 index 0000000..d1886de --- /dev/null +++ b/imgui-examples/examples/hello_gfx.rs @@ -0,0 +1,28 @@ +extern crate gfx; +extern crate gfx_window_glutin; +extern crate glutin; +#[macro_use] +extern crate imgui; +extern crate imgui_gfx_renderer; + +use imgui::*; + +mod support_gfx; + +const CLEAR_COLOR: [f32; 4] = [1.0, 1.0, 1.0, 1.0]; + +fn main() { + support_gfx::run("hello_gfx.rs".to_owned(), CLEAR_COLOR, hello_world); +} + +fn hello_world<'a>(ui: &Ui<'a>) { + ui.window(im_str!("Hello world")) + .size((300.0, 100.0), ImGuiSetCond_FirstUseEver) + .build(|| { + ui.text(im_str!("Hello world!")); + ui.text(im_str!("This...is...imgui-rs!")); + ui.separator(); + let mouse_pos = ui.imgui().mouse_pos(); + ui.text(im_str!("Mouse Position: ({:.1},{:.1})", mouse_pos.0, mouse_pos.1)); + }) +} diff --git a/imgui-examples/examples/support_gfx/mod.rs b/imgui-examples/examples/support_gfx/mod.rs new file mode 100644 index 0000000..6c93f35 --- /dev/null +++ b/imgui-examples/examples/support_gfx/mod.rs @@ -0,0 +1,161 @@ +use gfx; +use gfx::Device; +use gfx_window_glutin; +use glutin; +use glutin::{ElementState, MouseButton, MouseScrollDelta, VirtualKeyCode, TouchPhase, WindowEvent}; +use imgui::{ImGui, Ui, ImGuiKey}; +use imgui_gfx_renderer::Renderer; +use std::time::Instant; + +type ColorFormat = gfx::format::Rgba8; +type DepthFormat = gfx::format::DepthStencil; + +#[derive(Copy, Clone, PartialEq, Debug, Default)] +struct MouseState { + pos: (i32, i32), + pressed: (bool, bool, bool), + wheel: f32 +} + +pub fn run(title: String, clear_color: [f32; 4], mut run_ui: F) { + let mut imgui = ImGui::init(); + + let events_loop = glutin::EventsLoop::new(); + let builder = glutin::WindowBuilder::new() + .with_title(title) + .with_dimensions(1024, 768) + .with_vsync(); + let (window, mut device, mut factory, mut main_color, mut main_depth) = + gfx_window_glutin::init::(builder, &events_loop); + let mut encoder: gfx::Encoder<_, _> = factory.create_command_buffer().into(); + let mut renderer = Renderer::init(&mut imgui, &mut factory, main_color.clone()) + .expect("Failed to initialize renderer"); + + configure_keys(&mut imgui); + + let mut last_frame = Instant::now(); + let mut mouse_state = MouseState::default(); + let mut quit = false; + + loop { + events_loop.poll_events(|glutin::Event::WindowEvent{event, ..}| { + match event { + WindowEvent::Resized(_, _) => { + gfx_window_glutin::update_views(&window, &mut main_color, &mut main_depth); + renderer.update_render_target(main_color.clone()); + } + WindowEvent::Closed => quit = true, + WindowEvent::KeyboardInput(state, _, code, _) => { + let pressed = state == ElementState::Pressed; + match code { + Some(VirtualKeyCode::Tab) => imgui.set_key(0, pressed), + Some(VirtualKeyCode::Left) => imgui.set_key(1, pressed), + Some(VirtualKeyCode::Right) => imgui.set_key(2, pressed), + Some(VirtualKeyCode::Up) => imgui.set_key(3, pressed), + Some(VirtualKeyCode::Down) => imgui.set_key(4, pressed), + Some(VirtualKeyCode::PageUp) => imgui.set_key(5, pressed), + Some(VirtualKeyCode::PageDown) => imgui.set_key(6, pressed), + Some(VirtualKeyCode::Home) => imgui.set_key(7, pressed), + Some(VirtualKeyCode::End) => imgui.set_key(8, pressed), + Some(VirtualKeyCode::Delete) => imgui.set_key(9, pressed), + Some(VirtualKeyCode::Back) => imgui.set_key(10, pressed), + Some(VirtualKeyCode::Return) => imgui.set_key(11, pressed), + Some(VirtualKeyCode::Escape) => quit = true, + Some(VirtualKeyCode::A) => imgui.set_key(13, pressed), + Some(VirtualKeyCode::C) => imgui.set_key(14, pressed), + Some(VirtualKeyCode::V) => imgui.set_key(15, pressed), + Some(VirtualKeyCode::X) => imgui.set_key(16, pressed), + Some(VirtualKeyCode::Y) => imgui.set_key(17, pressed), + Some(VirtualKeyCode::Z) => imgui.set_key(18, pressed), + Some(VirtualKeyCode::LControl) | + Some(VirtualKeyCode::RControl) => imgui.set_key_ctrl(pressed), + Some(VirtualKeyCode::LShift) | + Some(VirtualKeyCode::RShift) => imgui.set_key_shift(pressed), + Some(VirtualKeyCode::LAlt) | + Some(VirtualKeyCode::RAlt) => imgui.set_key_alt(pressed), + Some(VirtualKeyCode::LWin) | + Some(VirtualKeyCode::RWin) => imgui.set_key_super(pressed), + _ => {} + } + } + WindowEvent::MouseMoved(x, y) => mouse_state.pos = (x, y), + WindowEvent::MouseInput(state, MouseButton::Left) => { + mouse_state.pressed.0 = state == ElementState::Pressed + } + WindowEvent::MouseInput(state, MouseButton::Right) => { + mouse_state.pressed.1 = state == ElementState::Pressed + } + WindowEvent::MouseInput(state, MouseButton::Middle) => { + mouse_state.pressed.2 = state == ElementState::Pressed + } + WindowEvent::MouseWheel(MouseScrollDelta::LineDelta(_, y), TouchPhase::Moved) => { + mouse_state.wheel = y + } + WindowEvent::MouseWheel(MouseScrollDelta::PixelDelta(_, y), TouchPhase::Moved) => { + mouse_state.wheel = y + } + WindowEvent::ReceivedCharacter(c) => imgui.add_input_character(c), + _ => () + } + }); + + let now = Instant::now(); + let delta = now - last_frame; + let delta_s = delta.as_secs() as f32 + delta.subsec_nanos() as f32 / 1_000_000_000.0; + last_frame = now; + + update_mouse(&mut imgui, &mut mouse_state); + + let size_points = window.get_inner_size_points().unwrap(); + let size_pixels = window.get_inner_size_pixels().unwrap(); + + let ui = imgui.frame(size_points, size_pixels, delta_s); + + run_ui(&ui); + + encoder.clear(&mut main_color, clear_color); + + renderer.render(ui, &mut factory, &mut encoder) + .expect("Rendering failed"); + encoder.flush(&mut device); + window.swap_buffers().unwrap(); + device.cleanup(); + + if quit { break } + }; +} + +fn configure_keys(imgui: &mut ImGui) { + imgui.set_imgui_key(ImGuiKey::Tab, 0); + imgui.set_imgui_key(ImGuiKey::LeftArrow, 1); + imgui.set_imgui_key(ImGuiKey::RightArrow, 2); + imgui.set_imgui_key(ImGuiKey::UpArrow, 3); + imgui.set_imgui_key(ImGuiKey::DownArrow, 4); + imgui.set_imgui_key(ImGuiKey::PageUp, 5); + imgui.set_imgui_key(ImGuiKey::PageDown, 6); + imgui.set_imgui_key(ImGuiKey::Home, 7); + imgui.set_imgui_key(ImGuiKey::End, 8); + imgui.set_imgui_key(ImGuiKey::Delete, 9); + imgui.set_imgui_key(ImGuiKey::Backspace, 10); + imgui.set_imgui_key(ImGuiKey::Enter, 11); + imgui.set_imgui_key(ImGuiKey::Escape, 12); + imgui.set_imgui_key(ImGuiKey::A, 13); + imgui.set_imgui_key(ImGuiKey::C, 14); + imgui.set_imgui_key(ImGuiKey::V, 15); + imgui.set_imgui_key(ImGuiKey::X, 16); + imgui.set_imgui_key(ImGuiKey::Y, 17); + imgui.set_imgui_key(ImGuiKey::Z, 18); +} + +fn update_mouse(imgui: &mut ImGui, mouse_state: &mut MouseState) { + let scale = imgui.display_framebuffer_scale(); + imgui.set_mouse_pos(mouse_state.pos.0 as f32 / scale.0, + mouse_state.pos.1 as f32 / scale.1); + imgui.set_mouse_down(&[mouse_state.pressed.0, + mouse_state.pressed.1, + mouse_state.pressed.2, + false, + false]); + imgui.set_mouse_wheel(mouse_state.wheel / scale.1); + mouse_state.wheel = 0.0; +} diff --git a/imgui-gfx-renderer/Cargo.toml b/imgui-gfx-renderer/Cargo.toml new file mode 100644 index 0000000..bc83f42 --- /dev/null +++ b/imgui-gfx-renderer/Cargo.toml @@ -0,0 +1,14 @@ +[package] +name = "imgui-gfx-renderer" +version = "0.0.14-pre" +authors = ["Joonas Javanainen ", "imgui-rs contributors"] +description = "gfx renderer for the imgui crate" +homepage = "https://github.com/gekkio/imgui-rs" +repository = "https://github.com/gekkio/imgui-rs" +license = "MIT/Apache-2.0" +categories = ["gui", "rendering"] + +[dependencies] +gfx = "0.16" +imgui = { version = "0.0.14-pre", path = "../" } +imgui-sys = { version = "0.0.14-pre", path = "../imgui-sys", features = ["gfx"] } diff --git a/imgui-gfx-renderer/src/lib.rs b/imgui-gfx-renderer/src/lib.rs new file mode 100644 index 0000000..67728d3 --- /dev/null +++ b/imgui-gfx-renderer/src/lib.rs @@ -0,0 +1,173 @@ +#[macro_use] +extern crate gfx; +extern crate imgui; + +use gfx::{Bind, Bundle, CommandBuffer, Encoder, Factory, IntoIndexBuffer, Rect, Resources, Slice}; +use gfx::handle::{Buffer, RenderTargetView}; +use gfx::traits::FactoryExt; +use imgui::{DrawList, ImDrawIdx, ImDrawVert, ImGui, Ui}; + +pub type RendererResult = Result; + +#[derive(Clone, Debug)] +pub enum RendererError { + Update(gfx::UpdateError), + Buffer(gfx::buffer::CreationError), + Pipeline(gfx::PipelineStateError), + Combined(gfx::CombinedError) +} + +impl From> for RendererError { + fn from(e: gfx::UpdateError) -> RendererError { RendererError::Update(e) } +} + +impl From for RendererError { + fn from(e: gfx::buffer::CreationError) -> RendererError { RendererError::Buffer(e) } +} + +impl From> for RendererError { + fn from(e: gfx::PipelineStateError) -> RendererError { RendererError::Pipeline(e) } +} + +impl From for RendererError { + fn from(e: gfx::CombinedError) -> RendererError { RendererError::Combined(e) } +} + +gfx_defines!{ + pipeline pipe { + vertex_buffer: gfx::VertexBuffer = (), + matrix: gfx::Global<[[f32; 4]; 4]> = "matrix", + tex: gfx::TextureSampler<[f32; 4]> = "tex", + out: gfx::BlendTarget = ("Target0", gfx::state::MASK_ALL, gfx::preset::blend::ALPHA), + scissor: gfx::Scissor = (), + } +} + +pub struct Renderer { + bundle: Bundle>, + index_buffer: Buffer, +} + +impl Renderer { + pub fn init>(imgui: &mut ImGui, + factory: &mut F, + out: RenderTargetView) + -> RendererResult> { + let pso = factory.create_pipeline_simple(include_bytes!("shader/vert_110.glsl"), + include_bytes!("shader/frag_110.glsl"), + pipe::new())?; + let vertex_buffer = factory.create_buffer::(256, + gfx::buffer::Role::Vertex, + gfx::memory::Usage::Dynamic, + Bind::empty())?; + let index_buffer = factory.create_buffer::(256, + gfx::buffer::Role::Index, + gfx::memory::Usage::Dynamic, + Bind::empty())?; + let (_, texture) = imgui.prepare_texture(|handle| { + factory.create_texture_immutable_u8::(gfx::texture::Kind::D2(handle.width as u16, handle.height as u16, gfx::texture::AaMode::Single), &[handle.pixels]) + })?; + // TODO: set texture id in imgui + let sampler = factory.create_sampler_linear(); + let data = pipe::Data { + vertex_buffer: vertex_buffer, + matrix: [[0.0, 0.0, 0.0, 0.0], + [0.0, 0.0, 0.0, 0.0], + [0.0, 0.0, -1.0, 0.0], + [-1.0, 1.0, 0.0, 1.0]], + tex: (texture, sampler), + out: out, + scissor: Rect { + x: 0, + y: 0, + w: 0, + h: 0, + }, + }; + let slice = Slice { + start: 0, + end: 0, + base_vertex: 0, + instances: None, + buffer: index_buffer.clone().into_index_buffer(factory), + }; + Ok(Renderer { + bundle: Bundle::new(slice, pso, data), + index_buffer: index_buffer, + }) + } + pub fn update_render_target(&mut self, out: RenderTargetView) { + self.bundle.data.out = out; + } + pub fn render<'a, F: Factory, C: CommandBuffer>(&mut self, + ui: Ui<'a>, + factory: &mut F, + encoder: &mut Encoder) + -> RendererResult<()> { + let (width, height) = ui.imgui().display_size(); + + if width == 0.0 || height == 0.0 { + return Ok(()); + } + self.bundle.data.matrix = [[2.0 / width as f32, 0.0, 0.0, 0.0], + [0.0, -2.0 / height as f32, 0.0, 0.0], + [0.0, 0.0, -1.0, 0.0], + [-1.0, 1.0, 0.0, 1.0]]; + + ui.render(|ui, draw_list| self.render_draw_list(ui, factory, encoder, draw_list)) + } + fn render_draw_list<'a, F: Factory, C: CommandBuffer>(&mut self, + ui: &'a Ui<'a>, + factory: &mut F, + encoder: &mut Encoder, + draw_list: DrawList<'a>) + -> RendererResult<()> { + let (scale_width, scale_height) = ui.imgui().display_framebuffer_scale(); + + self.bundle.slice.start = 0; + for cmd in draw_list.cmd_buffer { + // TODO: check cmd.texture_id + + self.upload_vertex_buffer(factory, encoder, draw_list.vtx_buffer)?; + self.upload_index_buffer(factory, encoder, draw_list.idx_buffer)?; + + self.bundle.slice.end = self.bundle.slice.start + cmd.elem_count; + self.bundle.data.scissor = Rect { + x: (cmd.clip_rect.x * scale_width) as u16, + y: (cmd.clip_rect.y * scale_height) as u16, + w: ((cmd.clip_rect.z - cmd.clip_rect.x).abs() * scale_width) as u16, + h: ((cmd.clip_rect.w - cmd.clip_rect.y).abs() * scale_height) as u16, + }; + self.bundle.encode(encoder); + self.bundle.slice.start = self.bundle.slice.end; + } + Ok(()) + } + fn upload_vertex_buffer, C: CommandBuffer>(&mut self, + factory: &mut F, + encoder: &mut Encoder, + vtx_buffer: &[ImDrawVert]) + -> RendererResult<()> { + if self.bundle.data.vertex_buffer.len() < vtx_buffer.len() { + self.bundle.data.vertex_buffer = factory.create_buffer::(vtx_buffer.len(), + gfx::buffer::Role::Vertex, + gfx::memory::Usage::Dynamic, + Bind::empty())?; + } + Ok(encoder.update_buffer(&self.bundle.data.vertex_buffer, vtx_buffer, 0)?) + } + fn upload_index_buffer, C: CommandBuffer>(&mut self, + factory: &mut F, + encoder: &mut Encoder, + idx_buffer: &[ImDrawIdx]) + -> RendererResult<()> { + if self.index_buffer.len() < idx_buffer.len() { + self.index_buffer = factory.create_buffer::(idx_buffer.len(), + gfx::buffer::Role::Index, + gfx::memory::Usage::Dynamic, + Bind::empty())?; + self.bundle.slice.buffer = self.index_buffer.clone().into_index_buffer(factory); + } + Ok(encoder.update_buffer(&self.index_buffer, idx_buffer, 0)?) + } +} diff --git a/imgui-gfx-renderer/src/shader/frag_110.glsl b/imgui-gfx-renderer/src/shader/frag_110.glsl new file mode 100644 index 0000000..8bdec78 --- /dev/null +++ b/imgui-gfx-renderer/src/shader/frag_110.glsl @@ -0,0 +1,10 @@ +#version 110 + +uniform sampler2D tex; + +varying vec2 f_uv; +varying vec4 f_color; + +void main() { + gl_FragColor = f_color * texture2D(tex, f_uv.st); +} diff --git a/imgui-gfx-renderer/src/shader/frag_140.glsl b/imgui-gfx-renderer/src/shader/frag_140.glsl new file mode 100644 index 0000000..7fbd223 --- /dev/null +++ b/imgui-gfx-renderer/src/shader/frag_140.glsl @@ -0,0 +1,12 @@ +#version 140 + +uniform sampler2D tex; + +in vec2 f_uv; +in vec4 f_color; + +out vec4 Target0; + +void main() { + Target0 = f_color * texture(tex, f_uv.st); +} diff --git a/imgui-gfx-renderer/src/shader/vert_110.glsl b/imgui-gfx-renderer/src/shader/vert_110.glsl new file mode 100644 index 0000000..99ee8a5 --- /dev/null +++ b/imgui-gfx-renderer/src/shader/vert_110.glsl @@ -0,0 +1,16 @@ +#version 110 + +uniform mat4 matrix; + +attribute vec2 pos; +attribute vec2 uv; +attribute vec4 col; + +varying vec2 f_uv; +varying vec4 f_color; + +void main() { + f_uv = uv; + f_color = col; + gl_Position = matrix * vec4(pos.xy, 0, 1); +} diff --git a/imgui-gfx-renderer/src/shader/vert_140.glsl b/imgui-gfx-renderer/src/shader/vert_140.glsl new file mode 100644 index 0000000..be63844 --- /dev/null +++ b/imgui-gfx-renderer/src/shader/vert_140.glsl @@ -0,0 +1,16 @@ +#version 140 + +uniform mat4 matrix; + +in vec2 pos; +in vec2 uv; +in vec4 col; + +out vec2 f_uv; +out vec4 f_color; + +void main() { + f_uv = uv; + f_color = col; + gl_Position = matrix * vec4(pos.xy, 0, 1); +} diff --git a/imgui-sys/Cargo.toml b/imgui-sys/Cargo.toml index cbeeeb1..8cf99c3 100644 --- a/imgui-sys/Cargo.toml +++ b/imgui-sys/Cargo.toml @@ -12,6 +12,7 @@ build = "build.rs" [dependencies] bitflags = "0.8" glium = { version = "0.16", default-features = false, optional = true } +gfx = { version = "0.16", optional = true } [build-dependencies] gcc = "0.3" diff --git a/imgui-sys/src/gfx_support.rs b/imgui-sys/src/gfx_support.rs new file mode 100644 index 0000000..e6adb53 --- /dev/null +++ b/imgui-sys/src/gfx_support.rs @@ -0,0 +1,58 @@ +use gfx::format::{Format, Formatted, U8Norm}; +use gfx::pso::buffer::{Element, ElemOffset, Structure}; +use gfx::traits::Pod; +use std::mem; + +use super::{ImDrawVert, ImVec2}; + +unsafe impl Pod for ImDrawVert {} + +impl Structure for ImDrawVert { + fn query(name: &str) -> Option> { + // array query hack from gfx_impl_struct_meta macro + let (sub_name, big_offset) = { + let mut split = name.split(|c| c == '[' || c == ']'); + let _ = split.next().unwrap(); + match split.next() { + Some(s) => { + let array_id: ElemOffset = s.parse().unwrap(); + let sub_name = match split.next() { + Some(s) if s.starts_with('.') => &s[1..], + _ => name, + }; + (sub_name, array_id * (mem::size_of::() as ElemOffset)) + } + None => (name, 0), + } + }; + let dummy: &ImDrawVert = unsafe { mem::transmute(0usize) }; + match sub_name { + "pos" => { + Some(Element { + format: ::get_format(), + offset: unsafe { mem::transmute::<_, usize>(&dummy.pos) } as ElemOffset + + big_offset, + }) + } + "uv" => { + Some(Element { + format: ::get_format(), + offset: unsafe { mem::transmute::<_, usize>(&dummy.uv) } as ElemOffset + + big_offset, + }) + } + "col" => { + Some(Element { + format: <[U8Norm; 4] as Formatted>::get_format(), + offset: unsafe { mem::transmute::<_, usize>(&dummy.col) } as ElemOffset + + big_offset, + }) + } + _ => None, + } + } +} + +gfx_format! { + ImVec2: R32_G32 = Vec2 +} diff --git a/imgui-sys/src/glium_support.rs b/imgui-sys/src/glium_support.rs index 492266c..0ec4248 100644 --- a/imgui-sys/src/glium_support.rs +++ b/imgui-sys/src/glium_support.rs @@ -1,7 +1,7 @@ use glium::vertex::{Attribute, AttributeType, Vertex, VertexFormat}; use std::borrow::Cow; use std::mem; -use std::os::raw::{c_float}; +use std::os::raw::c_float; use super::{ImDrawVert, ImVec2, ImVec4}; diff --git a/imgui-sys/src/lib.rs b/imgui-sys/src/lib.rs index c8e2cb3..d0e2d1d 100644 --- a/imgui-sys/src/lib.rs +++ b/imgui-sys/src/lib.rs @@ -3,6 +3,10 @@ #[macro_use] extern crate bitflags; +#[cfg(feature = "gfx")] +#[macro_use] +extern crate gfx; + #[cfg(feature = "glium")] extern crate glium; @@ -11,6 +15,9 @@ use std::mem; use std::os::raw::{c_char, c_float, c_int, c_short, c_uchar, c_uint, c_ushort, c_void}; use std::slice; +#[cfg(feature = "gfx")] +mod gfx_support; + #[cfg(feature = "glium")] mod glium_support;