Update bindgen dependency.

bindings_generator/src/methods.rs

@@ -426,13 +426,13 @@ fn generate_return_pre(w: &mut File, ty: &Ty) -> GeneratorResult {
         }
         &Ty::Result => {
             writeln!(w, r#"
-    let mut ret: sys::godot_error = sys::godot_error::GODOT_OK;
+    let mut ret: sys::godot_error = sys::godot_error_GODOT_OK;
     let ret_ptr = (&mut ret) as *mut _;"#
             )?;
         }
         &Ty::VariantType => {
             writeln!(w, r#"
-    let mut ret: sys::godot_variant_type = sys::godot_variant_type::GODOT_VARIANT_TYPE_NIL;
+    let mut ret: sys::godot_variant_type = sys::godot_variant_type_GODOT_VARIANT_TYPE_NIL;
     let ret_ptr = (&mut ret) as *mut _;"#
             )?;
         }

core/src/byte_array.rs

@@ -41,7 +41,7 @@ impl ByteArray {
     pub fn insert(&mut self, offset: i32, byte: u8) -> bool {
         unsafe {
             let status = (get_api().godot_pool_byte_array_insert)(&mut self.0, offset, byte);
-            status != sys::godot_error::GODOT_OK
+            status != sys::godot_error_GODOT_OK
         }
     }
 

core/src/color_array.rs

@@ -44,7 +44,7 @@ impl ColorArray {
     pub fn insert(&mut self, offset: i32, color: &Color) -> bool {
         unsafe {
             let status = (get_api().godot_pool_color_array_insert)(&mut self.0, offset, transmute(color));
-            status != sys::godot_error::GODOT_OK
+            status != sys::godot_error_GODOT_OK
         }
     }
 

core/src/float32_array.rs

@@ -41,7 +41,7 @@ impl Float32Array {
     pub fn insert(&mut self, offset: i32, val: f32) -> bool {
         unsafe {
             let status = (get_api().godot_pool_real_array_insert)(&mut self.0, offset, val);
-            status != sys::godot_error::GODOT_OK
+            status != sys::godot_error_GODOT_OK
         }
     }
 

core/src/init.rs

@@ -26,8 +26,6 @@ use get_api;
 use Variant;
 use ToVariant;
 use NativeClass;
-use sys::godot_property_usage_flags::*;
-use sys::godot_property_hint::*;
 use std::mem;
 use std::ops::Range;
 use std::ffi::CString;
@@ -146,7 +144,7 @@ impl<C: NativeClass> ClassBuilder<C> {
     pub fn add_method_advanced(&self, method: ScriptMethod) {
         let method_name = CString::new(method.name).unwrap();
         let attr = sys::godot_method_attributes {
-            rpc_type: sys::godot_method_rpc_mode::GODOT_METHOD_RPC_MODE_DISABLED
+            rpc_type: sys::godot_method_rpc_mode_GODOT_METHOD_RPC_MODE_DISABLED
         };
 
         let method_desc = sys::godot_instance_method {
@@ -209,7 +207,7 @@ impl<C: NativeClass> ClassBuilder<C> {
             let ty = default.get_type();
 
             let mut attr = sys::godot_property_attributes {
-                rset_type: sys::godot_method_rpc_mode::GODOT_METHOD_RPC_MODE_DISABLED, // TODO:
+                rset_type: sys::godot_method_rpc_mode_GODOT_METHOD_RPC_MODE_DISABLED, // TODO:
                 type_: mem::transmute(ty),
                 hint: property.hint.to_sys(),
                 hint_string: hint_string.to_sys(),
@@ -313,34 +311,34 @@ pub enum PropertyHint<'l> {
 impl<'l> PropertyHint<'l> {
     pub fn to_sys(&self) -> sys::godot_property_hint {
         match *self {
-            PropertyHint::None => GODOT_PROPERTY_HINT_NONE,
-            PropertyHint::Range { .. } => GODOT_PROPERTY_HINT_RANGE,
-            PropertyHint::Enum { .. } => GODOT_PROPERTY_HINT_ENUM,
-            PropertyHint::Flags { .. } => GODOT_PROPERTY_HINT_FLAGS,
-            PropertyHint::NodePathToEditedNode => GODOT_PROPERTY_HINT_NODE_PATH_TO_EDITED_NODE,
+            PropertyHint::None => sys::godot_property_hint_GODOT_PROPERTY_HINT_NONE,
+            PropertyHint::Range { .. } => sys::godot_property_hint_GODOT_PROPERTY_HINT_RANGE,
+            PropertyHint::Enum { .. } => sys::godot_property_hint_GODOT_PROPERTY_HINT_ENUM,
+            PropertyHint::Flags { .. } => sys::godot_property_hint_GODOT_PROPERTY_HINT_FLAGS,
+            PropertyHint::NodePathToEditedNode => sys::godot_property_hint_GODOT_PROPERTY_HINT_NODE_PATH_TO_EDITED_NODE,
         }
     }
 }
 
 bitflags! {
     pub struct PropertyUsage: u32 {
-        const STORAGE = GODOT_PROPERTY_USAGE_STORAGE as u32;
-        const EDITOR = GODOT_PROPERTY_USAGE_EDITOR as u32;
-        const NETWORK = GODOT_PROPERTY_USAGE_NETWORK as u32;
-        const EDITOR_HELPER = GODOT_PROPERTY_USAGE_EDITOR_HELPER as u32;
-        const CHECKABLE = GODOT_PROPERTY_USAGE_CHECKABLE as u32;
-        const CHECKED = GODOT_PROPERTY_USAGE_CHECKED as u32;
-        const INTERNATIONALIZED = GODOT_PROPERTY_USAGE_INTERNATIONALIZED as u32;
-        const GROUP = GODOT_PROPERTY_USAGE_GROUP as u32;
-        const CATEGORY = GODOT_PROPERTY_USAGE_CATEGORY as u32;
-        const STORE_IF_NONZERO = GODOT_PROPERTY_USAGE_STORE_IF_NONZERO as u32;
-        const STORE_IF_NONONE = GODOT_PROPERTY_USAGE_STORE_IF_NONONE as u32;
-        const NO_INSTANCE_STATE = GODOT_PROPERTY_USAGE_NO_INSTANCE_STATE as u32;
-        const RESTART_IF_CHANGED = GODOT_PROPERTY_USAGE_RESTART_IF_CHANGED as u32;
-        const SCRIPT_VARIABLE  = GODOT_PROPERTY_USAGE_SCRIPT_VARIABLE as u32;
-        const STORE_IF_NULL = GODOT_PROPERTY_USAGE_STORE_IF_NULL as u32;
-        const ANIMATE_AS_TRIGGER = GODOT_PROPERTY_USAGE_ANIMATE_AS_TRIGGER as u32;
-        const UPDATE_ALL_IF_MODIFIED = GODOT_PROPERTY_USAGE_UPDATE_ALL_IF_MODIFIED as u32;
+        const STORAGE = sys::godot_property_usage_flags_GODOT_PROPERTY_USAGE_STORAGE;
+        const EDITOR = sys::godot_property_usage_flags_GODOT_PROPERTY_USAGE_EDITOR;
+        const NETWORK = sys::godot_property_usage_flags_GODOT_PROPERTY_USAGE_NETWORK;
+        const EDITOR_HELPER = sys::godot_property_usage_flags_GODOT_PROPERTY_USAGE_EDITOR_HELPER;
+        const CHECKABLE = sys::godot_property_usage_flags_GODOT_PROPERTY_USAGE_CHECKABLE;
+        const CHECKED = sys::godot_property_usage_flags_GODOT_PROPERTY_USAGE_CHECKED;
+        const INTERNATIONALIZED = sys::godot_property_usage_flags_GODOT_PROPERTY_USAGE_INTERNATIONALIZED;
+        const GROUP = sys::godot_property_usage_flags_GODOT_PROPERTY_USAGE_GROUP;
+        const CATEGORY = sys::godot_property_usage_flags_GODOT_PROPERTY_USAGE_CATEGORY;
+        const STORE_IF_NONZERO = sys::godot_property_usage_flags_GODOT_PROPERTY_USAGE_STORE_IF_NONZERO;
+        const STORE_IF_NONONE = sys::godot_property_usage_flags_GODOT_PROPERTY_USAGE_STORE_IF_NONONE;
+        const NO_INSTANCE_STATE = sys::godot_property_usage_flags_GODOT_PROPERTY_USAGE_NO_INSTANCE_STATE;
+        const RESTART_IF_CHANGED = sys::godot_property_usage_flags_GODOT_PROPERTY_USAGE_RESTART_IF_CHANGED;
+        const SCRIPT_VARIABLE  = sys::godot_property_usage_flags_GODOT_PROPERTY_USAGE_SCRIPT_VARIABLE;
+        const STORE_IF_NULL = sys::godot_property_usage_flags_GODOT_PROPERTY_USAGE_STORE_IF_NULL;
+        const ANIMATE_AS_TRIGGER = sys::godot_property_usage_flags_GODOT_PROPERTY_USAGE_ANIMATE_AS_TRIGGER;
+        const UPDATE_ALL_IF_MODIFIED = sys::godot_property_usage_flags_GODOT_PROPERTY_USAGE_UPDATE_ALL_IF_MODIFIED;
 
         const DEFAULT = Self::STORAGE.bits | Self::EDITOR.bits | Self::NETWORK.bits;
         const DEFAULT_INTL = Self::DEFAULT.bits | Self::INTERNATIONALIZED.bits;

core/src/int32_array.rs

@@ -41,7 +41,7 @@ impl Int32Array {
     pub fn insert(&mut self, offset: i32, val: i32) -> bool {
         unsafe {
             let status = (get_api().godot_pool_int_array_insert)(&mut self.0, offset, val);
-            status != sys::godot_error::GODOT_OK
+            status != sys::godot_error_GODOT_OK
         }
     }
 

core/src/internal.rs

@@ -32,14 +32,14 @@ impl GodotApi {
         for i in 0 .. api.num_extensions {
             let ext = api.extensions.offset(i as _);
             $(
-                if (**ext).type_ == GDNATIVE_API_TYPES::$ty_key as u32 {
+                if (**ext).type_ == $ty_key as u32 {
                     $sub = Some(&*((*ext) as *const $st));
                 }
             )*
         }
 
         $(
-            if GDNATIVE_API_TYPES::GDNATIVE_CORE == GDNATIVE_API_TYPES::$ty_key {
+            if GDNATIVE_API_TYPES_GDNATIVE_CORE == $ty_key {
                 $sub = Some(&*(api_raw as *const $st));
             }
         )*
@@ -61,7 +61,7 @@ impl GodotApi {
 
 def_api! {
 struct GodotApi {
-    core(GDNATIVE_CORE, godot_gdnative_core_api_struct) {
+    core(GDNATIVE_API_TYPES_GDNATIVE_CORE, godot_gdnative_core_api_struct) {
         pub godot_color_new_rgba: ::std::option::Option<unsafe extern "C" fn(r_dest:
                                                                                 *mut godot_color,
                                                                             p_r:
@@ -3361,7 +3361,7 @@ struct GodotApi {
         pub godot_print: ::std::option::Option<unsafe extern "C" fn(p_message:
                                                                         *const godot_string)>,
     }
-    native_script(GDNATIVE_EXT_NATIVESCRIPT, godot_gdnative_ext_nativescript_api_struct) {
+    native_script(GDNATIVE_API_TYPES_GDNATIVE_EXT_NATIVESCRIPT, godot_gdnative_ext_nativescript_api_struct) {
         pub godot_nativescript_register_class: ::std::option::Option<unsafe extern "C" fn(p_gdnative_handle:
                                                                                             *mut libc::c_void,
                                                                                         p_name:

core/src/lib.rs

@@ -96,68 +96,68 @@ pub fn get_api() -> &'static GodotApi {
 #[derive(Copy, Clone, Debug, PartialEq, Eq)]
 #[repr(u32)]
 pub enum GodotError {
-    Failed = sys::godot_error::GODOT_FAILED as u32,
-    Unavailable = sys::godot_error::GODOT_ERR_UNAVAILABLE as u32,
-    Unconfigured = sys::godot_error::GODOT_ERR_UNCONFIGURED as u32,
-    Unothorized = sys::godot_error::GODOT_ERR_UNAUTHORIZED as u32,
-    PrameterRange = sys::godot_error::GODOT_ERR_PARAMETER_RANGE_ERROR as u32,
-    OutOfMemory = sys::godot_error::GODOT_ERR_OUT_OF_MEMORY as u32,
-    FileNotFound = sys::godot_error::GODOT_ERR_FILE_NOT_FOUND as u32,
-    FileBadDrive = sys::godot_error::GODOT_ERR_FILE_BAD_DRIVE as u32,
-    FileBadPath = sys::godot_error::GODOT_ERR_FILE_BAD_PATH as u32,
-    FileNoPermission = sys::godot_error::GODOT_ERR_FILE_NO_PERMISSION as u32,
-    FileAlreadyInUse = sys::godot_error::GODOT_ERR_FILE_ALREADY_IN_USE as u32,
-    FileCantOpen = sys::godot_error::GODOT_ERR_FILE_CANT_OPEN as u32,
-    FileCantWrite = sys::godot_error::GODOT_ERR_FILE_CANT_WRITE as u32,
-    FileCantRead = sys::godot_error::GODOT_ERR_FILE_CANT_READ as u32,
-    FileUnrecognized = sys::godot_error::GODOT_ERR_FILE_UNRECOGNIZED as u32,
-    FileCorrupt = sys::godot_error::GODOT_ERR_FILE_CORRUPT as u32,
-    FileMissingDependency = sys::godot_error::GODOT_ERR_FILE_MISSING_DEPENDENCIES as u32,
-    FileEof = sys::godot_error::GODOT_ERR_FILE_EOF as u32,
-    CantOpen = sys::godot_error::GODOT_ERR_CANT_OPEN as u32,
-    CantCreate = sys::godot_error::GODOT_ERR_CANT_CREATE as u32,
-    QueryFailed = sys::godot_error::GODOT_ERR_QUERY_FAILED as u32,
-    AlreadyInUse = sys::godot_error::GODOT_ERR_ALREADY_IN_USE as u32,
-    Locked = sys::godot_error::GODOT_ERR_LOCKED as u32,
-    TimeOut = sys::godot_error::GODOT_ERR_TIMEOUT as u32,
-    CantConnect = sys::godot_error::GODOT_ERR_CANT_CONNECT as u32,
-    CantResolve = sys::godot_error::GODOT_ERR_CANT_RESOLVE as u32,
-    ConnectionError = sys::godot_error::GODOT_ERR_CONNECTION_ERROR as u32,
-    CantAcquireResource = sys::godot_error::GODOT_ERR_CANT_ACQUIRE_RESOURCE as u32,
-    CantFork = sys::godot_error::GODOT_ERR_CANT_FORK as u32,
-    InvalidData = sys::godot_error::GODOT_ERR_INVALID_DATA as u32,
-    InvalidParameter = sys::godot_error::GODOT_ERR_INVALID_PARAMETER as u32,
-    AlreadyExists = sys::godot_error::GODOT_ERR_ALREADY_EXISTS as u32,
-    DoesNotExist = sys::godot_error::GODOT_ERR_DOES_NOT_EXIST as u32,
-    DatabaseCantRead = sys::godot_error::GODOT_ERR_DATABASE_CANT_READ as u32,
-    DatabaseCantWrite = sys::godot_error::GODOT_ERR_DATABASE_CANT_WRITE as u32,
-    CompilationFailed = sys::godot_error::GODOT_ERR_COMPILATION_FAILED as u32,
-    MethodNotFound = sys::godot_error::GODOT_ERR_METHOD_NOT_FOUND as u32,
-    LinkFailed = sys::godot_error::GODOT_ERR_LINK_FAILED as u32,
-    ScriptFailed = sys::godot_error::GODOT_ERR_SCRIPT_FAILED as u32,
-    CyclicLink = sys::godot_error::GODOT_ERR_CYCLIC_LINK as u32,
-    InvalidDeclaration = sys::godot_error::GODOT_ERR_INVALID_DECLARATION as u32,
-    DuplicateSymbol = sys::godot_error::GODOT_ERR_DUPLICATE_SYMBOL as u32,
-    ParseError = sys::godot_error::GODOT_ERR_PARSE_ERROR as u32,
-    Busy = sys::godot_error::GODOT_ERR_BUSY as u32,
-    Skip = sys::godot_error::GODOT_ERR_SKIP as u32,
-    Help = sys::godot_error::GODOT_ERR_HELP as u32,
-    Bug = sys::godot_error::GODOT_ERR_BUG as u32,
-    PrinterOnFire = sys::godot_error::GODOT_ERR_PRINTER_ON_FIRE as u32,
+    Failed = sys::godot_error_GODOT_FAILED,
+    Unavailable = sys::godot_error_GODOT_ERR_UNAVAILABLE,
+    Unconfigured = sys::godot_error_GODOT_ERR_UNCONFIGURED,
+    Unothorized = sys::godot_error_GODOT_ERR_UNAUTHORIZED,
+    PrameterRange = sys::godot_error_GODOT_ERR_PARAMETER_RANGE_ERROR,
+    OutOfMemory = sys::godot_error_GODOT_ERR_OUT_OF_MEMORY,
+    FileNotFound = sys::godot_error_GODOT_ERR_FILE_NOT_FOUND,
+    FileBadDrive = sys::godot_error_GODOT_ERR_FILE_BAD_DRIVE,
+    FileBadPath = sys::godot_error_GODOT_ERR_FILE_BAD_PATH,
+    FileNoPermission = sys::godot_error_GODOT_ERR_FILE_NO_PERMISSION,
+    FileAlreadyInUse = sys::godot_error_GODOT_ERR_FILE_ALREADY_IN_USE,
+    FileCantOpen = sys::godot_error_GODOT_ERR_FILE_CANT_OPEN,
+    FileCantWrite = sys::godot_error_GODOT_ERR_FILE_CANT_WRITE,
+    FileCantRead = sys::godot_error_GODOT_ERR_FILE_CANT_READ,
+    FileUnrecognized = sys::godot_error_GODOT_ERR_FILE_UNRECOGNIZED,
+    FileCorrupt = sys::godot_error_GODOT_ERR_FILE_CORRUPT,
+    FileMissingDependency = sys::godot_error_GODOT_ERR_FILE_MISSING_DEPENDENCIES,
+    FileEof = sys::godot_error_GODOT_ERR_FILE_EOF,
+    CantOpen = sys::godot_error_GODOT_ERR_CANT_OPEN,
+    CantCreate = sys::godot_error_GODOT_ERR_CANT_CREATE,
+    QueryFailed = sys::godot_error_GODOT_ERR_QUERY_FAILED,
+    AlreadyInUse = sys::godot_error_GODOT_ERR_ALREADY_IN_USE,
+    Locked = sys::godot_error_GODOT_ERR_LOCKED,
+    TimeOut = sys::godot_error_GODOT_ERR_TIMEOUT,
+    CantConnect = sys::godot_error_GODOT_ERR_CANT_CONNECT,
+    CantResolve = sys::godot_error_GODOT_ERR_CANT_RESOLVE,
+    ConnectionError = sys::godot_error_GODOT_ERR_CONNECTION_ERROR,
+    CantAcquireResource = sys::godot_error_GODOT_ERR_CANT_ACQUIRE_RESOURCE,
+    CantFork = sys::godot_error_GODOT_ERR_CANT_FORK,
+    InvalidData = sys::godot_error_GODOT_ERR_INVALID_DATA,
+    InvalidParameter = sys::godot_error_GODOT_ERR_INVALID_PARAMETER,
+    AlreadyExists = sys::godot_error_GODOT_ERR_ALREADY_EXISTS,
+    DoesNotExist = sys::godot_error_GODOT_ERR_DOES_NOT_EXIST,
+    DatabaseCantRead = sys::godot_error_GODOT_ERR_DATABASE_CANT_READ,
+    DatabaseCantWrite = sys::godot_error_GODOT_ERR_DATABASE_CANT_WRITE,
+    CompilationFailed = sys::godot_error_GODOT_ERR_COMPILATION_FAILED,
+    MethodNotFound = sys::godot_error_GODOT_ERR_METHOD_NOT_FOUND,
+    LinkFailed = sys::godot_error_GODOT_ERR_LINK_FAILED,
+    ScriptFailed = sys::godot_error_GODOT_ERR_SCRIPT_FAILED,
+    CyclicLink = sys::godot_error_GODOT_ERR_CYCLIC_LINK,
+    InvalidDeclaration = sys::godot_error_GODOT_ERR_INVALID_DECLARATION,
+    DuplicateSymbol = sys::godot_error_GODOT_ERR_DUPLICATE_SYMBOL,
+    ParseError = sys::godot_error_GODOT_ERR_PARSE_ERROR,
+    Busy = sys::godot_error_GODOT_ERR_BUSY,
+    Skip = sys::godot_error_GODOT_ERR_SKIP,
+    Help = sys::godot_error_GODOT_ERR_HELP,
+    Bug = sys::godot_error_GODOT_ERR_BUG,
+    PrinterOnFire = sys::godot_error_GODOT_ERR_PRINTER_ON_FIRE,
 }
 
 #[derive(Copy, Clone, Debug, PartialEq, Eq)]
 #[repr(u32)]
 pub enum Vector3Axis {
-    X = sys::godot_vector3_axis::GODOT_VECTOR3_AXIS_X as u32,
-    Y = sys::godot_vector3_axis::GODOT_VECTOR3_AXIS_Y as u32,
-    Z = sys::godot_vector3_axis::GODOT_VECTOR3_AXIS_Z as u32,
+    X = sys::godot_vector3_axis_GODOT_VECTOR3_AXIS_X,
+    Y = sys::godot_vector3_axis_GODOT_VECTOR3_AXIS_Y,
+    Z = sys::godot_vector3_axis_GODOT_VECTOR3_AXIS_Z,
 }
 
 pub type GodotResult = Result<(), GodotError>;
 
 pub fn result_from_sys(err: sys::godot_error) -> GodotResult {
-    if err == sys::godot_error::GODOT_OK {
+    if err == sys::godot_error_GODOT_OK {
         return Ok(());
     }
 

core/src/string_array.rs

@@ -42,7 +42,7 @@ impl StringArray {
     pub fn insert(&mut self, offset: i32, string: &GodotString) -> bool {
         unsafe {
             let status = (get_api().godot_pool_string_array_insert)(&mut self.0, offset, &string.0);
-            status != sys::godot_error::GODOT_OK
+            status != sys::godot_error_GODOT_OK
         }
     }