Added float array inputs

examples/test_window_impl.rs

@@ -34,8 +34,9 @@ struct State {
     wrap_width: f32,
     buf: String,
     text: String,
-    int: i32,
+    i0: i32,
-    float: f32,
+    f0: f32,
+    vec3: [f32;3],
     auto_resize_state: AutoResizeState,
     file_menu: FileMenuState
 }
@@ -72,8 +73,9 @@ impl Default for State {
             wrap_width: 200.0,
             buf: buf,
             text: text,
-            int: 123,
+            i0: 123,
-            float: 0.001,
+            f0: 0.001,
+            vec3: [0.10, 0.20, 0.30],
             auto_resize_state: Default::default(),
             file_menu: Default::default()
         }
@@ -294,9 +296,10 @@ fn show_test_window<'a>(ui: &Ui<'a>, state: &mut State, opened: &mut bool) {
                 ui.separator();
                 ui.label_text(im_str!("label"), im_str!("Value"));
                 ui.input_text(im_str!("input text"), &mut state.text).build();
-                ui.input_int(im_str!("input int"), &mut state.int).build();
+                ui.input_int(im_str!("input int"), &mut state.i0).build();
-                ui.input_float(im_str!("input float"), &mut state.float)
+                ui.input_float(im_str!("input float"), &mut state.f0)
                     .step(0.01).step_fast(1.0).build();
+                ui.input_float3(im_str!("input float3"), &mut state.vec3).build();
             }
         })
 }

src/input.rs

@@ -152,6 +152,18 @@ macro_rules! impl_step_params {
     }
 }
 
+macro_rules! impl_precision_params {
+    ($InputType:ident) => {
+        #[inline]
+        pub fn decimal_precision(self, value: i32) -> Self {
+            $InputType {
+                decimal_precision: value,
+                .. self
+            }
+        }
+    }
+}
+
 #[must_use]
 pub struct InputText<'ui, 'p> {
     label: ImStr<'p>,
@@ -250,13 +262,6 @@ impl<'ui, 'p> InputFloat<'ui, 'p> {
         }
     }
 
-    pub fn decimal_precision(self, value: i32) -> Self {
-        InputFloat {
-            decimal_precision: value,
-            .. self
-        }
-    }
-
     pub fn build(self) -> bool {
         unsafe {
             imgui_sys::igInputFloat(
@@ -270,6 +275,48 @@ impl<'ui, 'p> InputFloat<'ui, 'p> {
     }
 
     impl_step_params!(InputFloat, f32);
+    impl_precision_params!(InputFloat);
     impl_text_flags!(InputFloat);
-
 }
+
+macro_rules! impl_input_floatn {
+    ($InputFloatN:ident, $N:expr, $igInputFloatN:ident) => {
+        #[must_use]
+        pub struct $InputFloatN<'ui, 'p> {
+            label: ImStr<'p>,
+            value: &'p mut [f32;$N],
+            decimal_precision: i32,
+            flags: ImGuiInputTextFlags,
+            _phantom: PhantomData<&'ui Ui<'ui>>
+        }
+
+        impl<'ui, 'p> $InputFloatN<'ui, 'p> {
+            pub fn new(label: ImStr<'p>, value: &'p mut [f32;$N]) -> Self {
+                $InputFloatN {
+                    label: label,
+                    value: value,
+                    decimal_precision: -1,
+                    flags: ImGuiInputTextFlags::empty(),
+                    _phantom: PhantomData
+                }
+            }
+
+            pub fn build(self) -> bool {
+                unsafe {
+                    imgui_sys::$igInputFloatN(
+                        self.label.as_ptr(),
+                        self.value.as_mut_ptr(),
+                        self.decimal_precision,
+                        self.flags)
+                }
+            }
+
+            impl_precision_params!($InputFloatN);
+            impl_text_flags!($InputFloatN);
+        }
+    }
+}
+
+impl_input_floatn!(InputFloat2, 2, igInputFloat2);
+impl_input_floatn!(InputFloat3, 3, igInputFloat3);
+impl_input_floatn!(InputFloat4, 4, igInputFloat4);

src/lib.rs

@@ -39,7 +39,7 @@ pub use imgui_sys::{
     ImVec2, ImVec4,
     ImGuiKey
 };
-pub use input::{InputFloat, InputInt, InputText};
+pub use input::{InputFloat, InputFloat2, InputFloat3, InputFloat4, InputInt, InputText};
 pub use menus::{Menu, MenuItem};
 pub use sliders::{SliderFloat, SliderInt};
 pub use trees::{TreeNode};
@@ -453,6 +453,15 @@ impl<'ui> Ui<'ui> {
     pub fn input_float<'p>(&self, label: ImStr<'p>, value: &'p mut f32) -> InputFloat<'ui, 'p> {
         InputFloat::new(label, value)
     }
+    pub fn input_float2<'p>(&self, label: ImStr<'p>, value: &'p mut [f32;2]) -> InputFloat2<'ui, 'p> {
+        InputFloat2::new(label, value)
+    }
+    pub fn input_float3<'p>(&self, label: ImStr<'p>, value: &'p mut [f32;3]) -> InputFloat3<'ui, 'p> {
+        InputFloat3::new(label, value)
+    }
+    pub fn input_float4<'p>(&self, label: ImStr<'p>, value: &'p mut [f32;4]) -> InputFloat4<'ui, 'p> {
+        InputFloat4::new(label, value)
+    }
     pub fn input_int<'p>(&self, label: ImStr<'p>, value: &'p mut i32) -> InputInt<'ui, 'p> {
         InputInt::new(label, value)
     }