1#[repr(C)]
4pub struct __BindgenUnionField<T>(::std::marker::PhantomData<T>);
5impl <T> __BindgenUnionField<T> {
6 #[inline]
7 pub fn new() -> Self { __BindgenUnionField(::std::marker::PhantomData) }
8 #[inline]
9 pub unsafe fn as_ref(&self) -> &T { ::std::mem::transmute(self) }
10 #[inline]
11 pub unsafe fn as_mut(&mut self) -> &mut T { ::std::mem::transmute(self) }
12}
13impl <T> ::std::default::Default for __BindgenUnionField<T> {
14 #[inline]
15 fn default() -> Self { Self::new() }
16}
17impl <T> ::std::clone::Clone for __BindgenUnionField<T> {
18 #[inline]
19 fn clone(&self) -> Self { Self::new() }
20}
21impl <T> ::std::marker::Copy for __BindgenUnionField<T> { }
22impl <T> ::std::fmt::Debug for __BindgenUnionField<T> {
23 fn fmt(&self, fmt: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
24 fmt.write_str("__BindgenUnionField")
25 }
26}
27pub const true_: ::std::os::raw::c_uint = 1;
28pub const false_: ::std::os::raw::c_uint = 0;
29pub const __bool_true_false_are_defined: ::std::os::raw::c_uint = 1;
30pub const _STDINT_H: ::std::os::raw::c_uint = 1;
31pub const _FEATURES_H: ::std::os::raw::c_uint = 1;
32pub const _DEFAULT_SOURCE: ::std::os::raw::c_uint = 1;
33pub const __USE_ISOC11: ::std::os::raw::c_uint = 1;
34pub const __USE_ISOC99: ::std::os::raw::c_uint = 1;
35pub const __USE_ISOC95: ::std::os::raw::c_uint = 1;
36pub const __USE_POSIX_IMPLICITLY: ::std::os::raw::c_uint = 1;
37pub const _POSIX_SOURCE: ::std::os::raw::c_uint = 1;
38pub const _POSIX_C_SOURCE: ::std::os::raw::c_uint = 200809;
39pub const __USE_POSIX: ::std::os::raw::c_uint = 1;
40pub const __USE_POSIX2: ::std::os::raw::c_uint = 1;
41pub const __USE_POSIX199309: ::std::os::raw::c_uint = 1;
42pub const __USE_POSIX199506: ::std::os::raw::c_uint = 1;
43pub const __USE_XOPEN2K: ::std::os::raw::c_uint = 1;
44pub const __USE_XOPEN2K8: ::std::os::raw::c_uint = 1;
45pub const _ATFILE_SOURCE: ::std::os::raw::c_uint = 1;
46pub const __USE_MISC: ::std::os::raw::c_uint = 1;
47pub const __USE_ATFILE: ::std::os::raw::c_uint = 1;
48pub const __USE_FORTIFY_LEVEL: ::std::os::raw::c_uint = 0;
49pub const __GLIBC_USE_DEPRECATED_GETS: ::std::os::raw::c_uint = 0;
50pub const _STDC_PREDEF_H: ::std::os::raw::c_uint = 1;
51pub const __STDC_IEC_559__: ::std::os::raw::c_uint = 1;
52pub const __STDC_IEC_559_COMPLEX__: ::std::os::raw::c_uint = 1;
53pub const __STDC_ISO_10646__: ::std::os::raw::c_uint = 201706;
54pub const __STDC_NO_THREADS__: ::std::os::raw::c_uint = 1;
55pub const __GNU_LIBRARY__: ::std::os::raw::c_uint = 6;
56pub const __GLIBC__: ::std::os::raw::c_uint = 2;
57pub const __GLIBC_MINOR__: ::std::os::raw::c_uint = 26;
58pub const _SYS_CDEFS_H: ::std::os::raw::c_uint = 1;
59pub const __glibc_c99_flexarr_available: ::std::os::raw::c_uint = 1;
60pub const __WORDSIZE: ::std::os::raw::c_uint = 64;
61pub const __WORDSIZE_TIME64_COMPAT32: ::std::os::raw::c_uint = 1;
62pub const __SYSCALL_WORDSIZE: ::std::os::raw::c_uint = 64;
63pub const __HAVE_GENERIC_SELECTION: ::std::os::raw::c_uint = 1;
64pub const __GLIBC_USE_LIB_EXT2: ::std::os::raw::c_uint = 0;
65pub const __GLIBC_USE_IEC_60559_BFP_EXT: ::std::os::raw::c_uint = 0;
66pub const __GLIBC_USE_IEC_60559_FUNCS_EXT: ::std::os::raw::c_uint = 0;
67pub const __GLIBC_USE_IEC_60559_TYPES_EXT: ::std::os::raw::c_uint = 0;
68pub const _BITS_TYPES_H: ::std::os::raw::c_uint = 1;
69pub const _BITS_TYPESIZES_H: ::std::os::raw::c_uint = 1;
70pub const __OFF_T_MATCHES_OFF64_T: ::std::os::raw::c_uint = 1;
71pub const __INO_T_MATCHES_INO64_T: ::std::os::raw::c_uint = 1;
72pub const __RLIM_T_MATCHES_RLIM64_T: ::std::os::raw::c_uint = 1;
73pub const __FD_SETSIZE: ::std::os::raw::c_uint = 1024;
74pub const _BITS_WCHAR_H: ::std::os::raw::c_uint = 1;
75pub const _BITS_STDINT_INTN_H: ::std::os::raw::c_uint = 1;
76pub const _BITS_STDINT_UINTN_H: ::std::os::raw::c_uint = 1;
77pub const INT8_MIN: ::std::os::raw::c_int = -128;
78pub const INT16_MIN: ::std::os::raw::c_int = -32768;
79pub const INT32_MIN: ::std::os::raw::c_int = -2147483648;
80pub const INT8_MAX: ::std::os::raw::c_uint = 127;
81pub const INT16_MAX: ::std::os::raw::c_uint = 32767;
82pub const INT32_MAX: ::std::os::raw::c_uint = 2147483647;
83pub const UINT8_MAX: ::std::os::raw::c_uint = 255;
84pub const UINT16_MAX: ::std::os::raw::c_uint = 65535;
85pub const UINT32_MAX: ::std::os::raw::c_uint = 4294967295;
86pub const INT_LEAST8_MIN: ::std::os::raw::c_int = -128;
87pub const INT_LEAST16_MIN: ::std::os::raw::c_int = -32768;
88pub const INT_LEAST32_MIN: ::std::os::raw::c_int = -2147483648;
89pub const INT_LEAST8_MAX: ::std::os::raw::c_uint = 127;
90pub const INT_LEAST16_MAX: ::std::os::raw::c_uint = 32767;
91pub const INT_LEAST32_MAX: ::std::os::raw::c_uint = 2147483647;
92pub const UINT_LEAST8_MAX: ::std::os::raw::c_uint = 255;
93pub const UINT_LEAST16_MAX: ::std::os::raw::c_uint = 65535;
94pub const UINT_LEAST32_MAX: ::std::os::raw::c_uint = 4294967295;
95pub const INT_FAST8_MIN: ::std::os::raw::c_int = -128;
96pub const INT_FAST16_MIN: ::std::os::raw::c_longlong = -9223372036854775808;
97pub const INT_FAST32_MIN: ::std::os::raw::c_longlong = -9223372036854775808;
98pub const INT_FAST8_MAX: ::std::os::raw::c_uint = 127;
99pub const INT_FAST16_MAX: ::std::os::raw::c_ulonglong = 9223372036854775807;
100pub const INT_FAST32_MAX: ::std::os::raw::c_ulonglong = 9223372036854775807;
101pub const UINT_FAST8_MAX: ::std::os::raw::c_uint = 255;
102pub const UINT_FAST16_MAX: ::std::os::raw::c_int = -1;
103pub const UINT_FAST32_MAX: ::std::os::raw::c_int = -1;
104pub const INTPTR_MIN: ::std::os::raw::c_longlong = -9223372036854775808;
105pub const INTPTR_MAX: ::std::os::raw::c_ulonglong = 9223372036854775807;
106pub const UINTPTR_MAX: ::std::os::raw::c_int = -1;
107pub const PTRDIFF_MIN: ::std::os::raw::c_longlong = -9223372036854775808;
108pub const PTRDIFF_MAX: ::std::os::raw::c_ulonglong = 9223372036854775807;
109pub const SIG_ATOMIC_MIN: ::std::os::raw::c_int = -2147483648;
110pub const SIG_ATOMIC_MAX: ::std::os::raw::c_uint = 2147483647;
111pub const SIZE_MAX: ::std::os::raw::c_int = -1;
112pub const WINT_MIN: ::std::os::raw::c_uint = 0;
113pub const WINT_MAX: ::std::os::raw::c_uint = 4294967295;
114pub const GODOT_API_VERSION: ::std::os::raw::c_uint = 1;
115pub const GODOT_TRUE: ::std::os::raw::c_uint = 1;
116pub const GODOT_FALSE: ::std::os::raw::c_uint = 0;
117pub const _WCHAR_H: ::std::os::raw::c_uint = 1;
118pub const __HAVE_FLOAT128: ::std::os::raw::c_uint = 0;
119pub const __HAVE_DISTINCT_FLOAT128: ::std::os::raw::c_uint = 0;
120pub const __GNUC_VA_LIST: ::std::os::raw::c_uint = 1;
121pub const __wint_t_defined: ::std::os::raw::c_uint = 1;
122pub const _WINT_T: ::std::os::raw::c_uint = 1;
123pub const __mbstate_t_defined: ::std::os::raw::c_uint = 1;
124pub const ____mbstate_t_defined: ::std::os::raw::c_uint = 1;
125pub const ____FILE_defined: ::std::os::raw::c_uint = 1;
126pub const __FILE_defined: ::std::os::raw::c_uint = 1;
127pub const _BITS_TYPES_LOCALE_T_H: ::std::os::raw::c_uint = 1;
128pub const _BITS_TYPES___LOCALE_T_H: ::std::os::raw::c_uint = 1;
129pub const WEOF: ::std::os::raw::c_uint = 4294967295;
130pub const GODOT_STRING_SIZE: ::std::os::raw::c_uint = 8;
131pub const GODOT_VECTOR2_SIZE: ::std::os::raw::c_uint = 8;
132pub const GODOT_VECTOR3_SIZE: ::std::os::raw::c_uint = 12;
133pub const GODOT_BASIS_SIZE: ::std::os::raw::c_uint = 36;
134pub const GODOT_QUAT_SIZE: ::std::os::raw::c_uint = 16;
135pub const GODOT_TRANSFORM2D_SIZE: ::std::os::raw::c_uint = 24;
136pub const GODOT_VARIANT_SIZE: ::std::os::raw::c_uint = 24;
137pub const GODOT_ARRAY_SIZE: ::std::os::raw::c_uint = 8;
138pub const GODOT_POOL_BYTE_ARRAY_SIZE: ::std::os::raw::c_uint = 8;
139pub const GODOT_POOL_INT_ARRAY_SIZE: ::std::os::raw::c_uint = 8;
140pub const GODOT_POOL_REAL_ARRAY_SIZE: ::std::os::raw::c_uint = 8;
141pub const GODOT_POOL_STRING_ARRAY_SIZE: ::std::os::raw::c_uint = 8;
142pub const GODOT_POOL_VECTOR2_ARRAY_SIZE: ::std::os::raw::c_uint = 8;
143pub const GODOT_POOL_VECTOR3_ARRAY_SIZE: ::std::os::raw::c_uint = 8;
144pub const GODOT_POOL_COLOR_ARRAY_SIZE: ::std::os::raw::c_uint = 8;
145pub const GODOT_COLOR_SIZE: ::std::os::raw::c_uint = 16;
146pub const GODOT_DICTIONARY_SIZE: ::std::os::raw::c_uint = 8;
147pub const GODOT_NODE_PATH_SIZE: ::std::os::raw::c_uint = 8;
148pub const GODOT_PLANE_SIZE: ::std::os::raw::c_uint = 16;
149pub const GODOT_RECT3_SIZE: ::std::os::raw::c_uint = 24;
150pub const GODOT_RID_SIZE: ::std::os::raw::c_uint = 8;
151pub const GODOT_TRANSFORM_SIZE: ::std::os::raw::c_uint = 48;
152pub type __u_char = ::std::os::raw::c_uchar;
153pub type __u_short = ::std::os::raw::c_ushort;
154pub type __u_int = ::std::os::raw::c_uint;
155pub type __u_long = ::std::os::raw::c_ulong;
156pub type __int8_t = ::std::os::raw::c_char;
157pub type __uint8_t = ::std::os::raw::c_uchar;
158pub type __int16_t = ::std::os::raw::c_short;
159pub type __uint16_t = ::std::os::raw::c_ushort;
160pub type __int32_t = ::std::os::raw::c_int;
161pub type __uint32_t = ::std::os::raw::c_uint;
162pub type __int64_t = ::std::os::raw::c_long;
163pub type __uint64_t = ::std::os::raw::c_ulong;
164pub type __quad_t = ::std::os::raw::c_long;
165pub type __u_quad_t = ::std::os::raw::c_ulong;
166pub type __intmax_t = ::std::os::raw::c_long;
167pub type __uintmax_t = ::std::os::raw::c_ulong;
168pub type __dev_t = ::std::os::raw::c_ulong;
169pub type __uid_t = ::std::os::raw::c_uint;
170pub type __gid_t = ::std::os::raw::c_uint;
171pub type __ino_t = ::std::os::raw::c_ulong;
172pub type __ino64_t = ::std::os::raw::c_ulong;
173pub type __mode_t = ::std::os::raw::c_uint;
174pub type __nlink_t = ::std::os::raw::c_ulong;
175pub type __off_t = ::std::os::raw::c_long;
176pub type __off64_t = ::std::os::raw::c_long;
177pub type __pid_t = ::std::os::raw::c_int;
178#[repr(C)]
179#[derive(Debug, Copy)]
180pub struct __fsid_t {
181 pub __val: [::std::os::raw::c_int; 2usize],
182}
183#[test]
184fn bindgen_test_layout___fsid_t() {
185 assert_eq!(::std::mem::size_of::<__fsid_t>() , 8usize , concat ! (
186 "Size of: " , stringify ! ( __fsid_t ) ));
187 assert_eq! (::std::mem::align_of::<__fsid_t>() , 4usize , concat ! (
188 "Alignment of " , stringify ! ( __fsid_t ) ));
189 assert_eq! (unsafe {
190 & ( * ( 0 as * const __fsid_t ) ) . __val as * const _ as
191 usize } , 0usize , concat ! (
192 "Alignment of field: " , stringify ! ( __fsid_t ) , "::" ,
193 stringify ! ( __val ) ));
194}
195impl Clone for __fsid_t {
196 fn clone(&self) -> Self { *self }
197}
198pub type __clock_t = ::std::os::raw::c_long;
199pub type __rlim_t = ::std::os::raw::c_ulong;
200pub type __rlim64_t = ::std::os::raw::c_ulong;
201pub type __id_t = ::std::os::raw::c_uint;
202pub type __time_t = ::std::os::raw::c_long;
203pub type __useconds_t = ::std::os::raw::c_uint;
204pub type __suseconds_t = ::std::os::raw::c_long;
205pub type __daddr_t = ::std::os::raw::c_int;
206pub type __key_t = ::std::os::raw::c_int;
207pub type __clockid_t = ::std::os::raw::c_int;
208pub type __timer_t = *mut ::std::os::raw::c_void;
209pub type __blksize_t = ::std::os::raw::c_long;
210pub type __blkcnt_t = ::std::os::raw::c_long;
211pub type __blkcnt64_t = ::std::os::raw::c_long;
212pub type __fsblkcnt_t = ::std::os::raw::c_ulong;
213pub type __fsblkcnt64_t = ::std::os::raw::c_ulong;
214pub type __fsfilcnt_t = ::std::os::raw::c_ulong;
215pub type __fsfilcnt64_t = ::std::os::raw::c_ulong;
216pub type __fsword_t = ::std::os::raw::c_long;
217pub type __ssize_t = ::std::os::raw::c_long;
218pub type __syscall_slong_t = ::std::os::raw::c_long;
219pub type __syscall_ulong_t = ::std::os::raw::c_ulong;
220pub type __loff_t = __off64_t;
221pub type __qaddr_t = *mut __quad_t;
222pub type __caddr_t = *mut ::std::os::raw::c_char;
223pub type __intptr_t = ::std::os::raw::c_long;
224pub type __socklen_t = ::std::os::raw::c_uint;
225pub type __sig_atomic_t = ::std::os::raw::c_int;
226pub type int_least8_t = ::std::os::raw::c_char;
227pub type int_least16_t = ::std::os::raw::c_short;
228pub type int_least32_t = ::std::os::raw::c_int;
229pub type int_least64_t = ::std::os::raw::c_long;
230pub type uint_least8_t = ::std::os::raw::c_uchar;
231pub type uint_least16_t = ::std::os::raw::c_ushort;
232pub type uint_least32_t = ::std::os::raw::c_uint;
233pub type uint_least64_t = ::std::os::raw::c_ulong;
234pub type int_fast8_t = ::std::os::raw::c_char;
235pub type int_fast16_t = ::std::os::raw::c_long;
236pub type int_fast32_t = ::std::os::raw::c_long;
237pub type int_fast64_t = ::std::os::raw::c_long;
238pub type uint_fast8_t = ::std::os::raw::c_uchar;
239pub type uint_fast16_t = ::std::os::raw::c_ulong;
240pub type uint_fast32_t = ::std::os::raw::c_ulong;
241pub type uint_fast64_t = ::std::os::raw::c_ulong;
242pub type intmax_t = __intmax_t;
243pub type uintmax_t = __uintmax_t;
244pub const godot_error_GODOT_ERR_WTF: godot_error =
245 godot_error::GODOT_ERR_OMFG_THIS_IS_VERY_VERY_BAD;
246#[repr(u32)]
247#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
249pub enum godot_error {
250 GODOT_OK = 0,
251 GODOT_FAILED = 1,
252 GODOT_ERR_UNAVAILABLE = 2,
253 GODOT_ERR_UNCONFIGURED = 3,
254 GODOT_ERR_UNAUTHORIZED = 4,
255 GODOT_ERR_PARAMETER_RANGE_ERROR = 5,
256 GODOT_ERR_OUT_OF_MEMORY = 6,
257 GODOT_ERR_FILE_NOT_FOUND = 7,
258 GODOT_ERR_FILE_BAD_DRIVE = 8,
259 GODOT_ERR_FILE_BAD_PATH = 9,
260 GODOT_ERR_FILE_NO_PERMISSION = 10,
261 GODOT_ERR_FILE_ALREADY_IN_USE = 11,
262 GODOT_ERR_FILE_CANT_OPEN = 12,
263 GODOT_ERR_FILE_CANT_WRITE = 13,
264 GODOT_ERR_FILE_CANT_READ = 14,
265 GODOT_ERR_FILE_UNRECOGNIZED = 15,
266 GODOT_ERR_FILE_CORRUPT = 16,
267 GODOT_ERR_FILE_MISSING_DEPENDENCIES = 17,
268 GODOT_ERR_FILE_EOF = 18,
269 GODOT_ERR_CANT_OPEN = 19,
270 GODOT_ERR_CANT_CREATE = 20,
271 GODOT_ERR_QUERY_FAILED = 21,
272 GODOT_ERR_ALREADY_IN_USE = 22,
273 GODOT_ERR_LOCKED = 23,
274 GODOT_ERR_TIMEOUT = 24,
275 GODOT_ERR_CANT_CONNECT = 25,
276 GODOT_ERR_CANT_RESOLVE = 26,
277 GODOT_ERR_CONNECTION_ERROR = 27,
278 GODOT_ERR_CANT_AQUIRE_RESOURCE = 28,
279 GODOT_ERR_CANT_FORK = 29,
280 GODOT_ERR_INVALID_DATA = 30,
281 GODOT_ERR_INVALID_PARAMETER = 31,
282 GODOT_ERR_ALREADY_EXISTS = 32,
283 GODOT_ERR_DOES_NOT_EXIST = 33,
284 GODOT_ERR_DATABASE_CANT_READ = 34,
285 GODOT_ERR_DATABASE_CANT_WRITE = 35,
286 GODOT_ERR_COMPILATION_FAILED = 36,
287 GODOT_ERR_METHOD_NOT_FOUND = 37,
288 GODOT_ERR_LINK_FAILED = 38,
289 GODOT_ERR_SCRIPT_FAILED = 39,
290 GODOT_ERR_CYCLIC_LINK = 40,
291 GODOT_ERR_INVALID_DECLARATION = 41,
292 GODOT_ERR_DUPLICATE_SYMBOL = 42,
293 GODOT_ERR_PARSE_ERROR = 43,
294 GODOT_ERR_BUSY = 44,
295 GODOT_ERR_SKIP = 45,
296 GODOT_ERR_HELP = 46,
297 GODOT_ERR_BUG = 47,
298 GODOT_ERR_PRINTER_ON_FIRE = 48,
299 GODOT_ERR_OMFG_THIS_IS_VERY_VERY_BAD = 49,
300}
301pub type godot_bool = bool;
303pub type godot_int = ::std::os::raw::c_int;
305pub type godot_real = f32;
307pub type godot_object = ::std::os::raw::c_void;
309pub type wchar_t = ::std::os::raw::c_int;
310pub type va_list = __builtin_va_list;
311pub type __gnuc_va_list = __builtin_va_list;
312pub type wint_t = ::std::os::raw::c_uint;
313#[repr(C)]
314#[derive(Debug, Copy)]
315pub struct __mbstate_t {
316 pub __count: ::std::os::raw::c_int,
317 pub __value: __mbstate_t__bindgen_ty_1,
318}
319#[repr(C)]
320#[derive(Debug, Copy)]
321pub struct __mbstate_t__bindgen_ty_1 {
322 pub __wch: __BindgenUnionField<::std::os::raw::c_uint>,
323 pub __wchb: __BindgenUnionField<[::std::os::raw::c_char; 4usize]>,
324 pub bindgen_union_field: u32,
325}
326#[test]
327fn bindgen_test_layout___mbstate_t__bindgen_ty_1() {
328 assert_eq!(::std::mem::size_of::<__mbstate_t__bindgen_ty_1>() , 4usize ,
329 concat ! (
330 "Size of: " , stringify ! ( __mbstate_t__bindgen_ty_1 ) ));
331 assert_eq! (::std::mem::align_of::<__mbstate_t__bindgen_ty_1>() , 4usize ,
332 concat ! (
333 "Alignment of " , stringify ! ( __mbstate_t__bindgen_ty_1 )
334 ));
335 assert_eq! (unsafe {
336 & ( * ( 0 as * const __mbstate_t__bindgen_ty_1 ) ) . __wch as
337 * const _ as usize } , 0usize , concat ! (
338 "Alignment of field: " , stringify ! (
339 __mbstate_t__bindgen_ty_1 ) , "::" , stringify ! ( __wch ) ));
340 assert_eq! (unsafe {
341 & ( * ( 0 as * const __mbstate_t__bindgen_ty_1 ) ) . __wchb as
342 * const _ as usize } , 0usize , concat ! (
343 "Alignment of field: " , stringify ! (
344 __mbstate_t__bindgen_ty_1 ) , "::" , stringify ! ( __wchb )
345 ));
346}
347impl Clone for __mbstate_t__bindgen_ty_1 {
348 fn clone(&self) -> Self { *self }
349}
350#[test]
351fn bindgen_test_layout___mbstate_t() {
352 assert_eq!(::std::mem::size_of::<__mbstate_t>() , 8usize , concat ! (
353 "Size of: " , stringify ! ( __mbstate_t ) ));
354 assert_eq! (::std::mem::align_of::<__mbstate_t>() , 4usize , concat ! (
355 "Alignment of " , stringify ! ( __mbstate_t ) ));
356 assert_eq! (unsafe {
357 & ( * ( 0 as * const __mbstate_t ) ) . __count as * const _ as
358 usize } , 0usize , concat ! (
359 "Alignment of field: " , stringify ! ( __mbstate_t ) , "::" ,
360 stringify ! ( __count ) ));
361 assert_eq! (unsafe {
362 & ( * ( 0 as * const __mbstate_t ) ) . __value as * const _ as
363 usize } , 4usize , concat ! (
364 "Alignment of field: " , stringify ! ( __mbstate_t ) , "::" ,
365 stringify ! ( __value ) ));
366}
367impl Clone for __mbstate_t {
368 fn clone(&self) -> Self { *self }
369}
370pub type mbstate_t = __mbstate_t;
371#[repr(C)]
372#[derive(Debug, Copy, Clone)]
373pub struct _IO_FILE([u8; 0]);
374pub type __FILE = _IO_FILE;
375pub type FILE = _IO_FILE;
376#[repr(C)]
377#[derive(Debug, Copy)]
378pub struct __locale_struct {
379 pub __locales: [*mut __locale_data; 13usize],
380 pub __ctype_b: *const ::std::os::raw::c_ushort,
381 pub __ctype_tolower: *const ::std::os::raw::c_int,
382 pub __ctype_toupper: *const ::std::os::raw::c_int,
383 pub __names: [*const ::std::os::raw::c_char; 13usize],
384}
385#[test]
386fn bindgen_test_layout___locale_struct() {
387 assert_eq!(::std::mem::size_of::<__locale_struct>() , 232usize , concat !
388 ( "Size of: " , stringify ! ( __locale_struct ) ));
389 assert_eq! (::std::mem::align_of::<__locale_struct>() , 8usize , concat !
390 ( "Alignment of " , stringify ! ( __locale_struct ) ));
391 assert_eq! (unsafe {
392 & ( * ( 0 as * const __locale_struct ) ) . __locales as *
393 const _ as usize } , 0usize , concat ! (
394 "Alignment of field: " , stringify ! ( __locale_struct ) ,
395 "::" , stringify ! ( __locales ) ));
396 assert_eq! (unsafe {
397 & ( * ( 0 as * const __locale_struct ) ) . __ctype_b as *
398 const _ as usize } , 104usize , concat ! (
399 "Alignment of field: " , stringify ! ( __locale_struct ) ,
400 "::" , stringify ! ( __ctype_b ) ));
401 assert_eq! (unsafe {
402 & ( * ( 0 as * const __locale_struct ) ) . __ctype_tolower as
403 * const _ as usize } , 112usize , concat ! (
404 "Alignment of field: " , stringify ! ( __locale_struct ) ,
405 "::" , stringify ! ( __ctype_tolower ) ));
406 assert_eq! (unsafe {
407 & ( * ( 0 as * const __locale_struct ) ) . __ctype_toupper as
408 * const _ as usize } , 120usize , concat ! (
409 "Alignment of field: " , stringify ! ( __locale_struct ) ,
410 "::" , stringify ! ( __ctype_toupper ) ));
411 assert_eq! (unsafe {
412 & ( * ( 0 as * const __locale_struct ) ) . __names as * const
413 _ as usize } , 128usize , concat ! (
414 "Alignment of field: " , stringify ! ( __locale_struct ) ,
415 "::" , stringify ! ( __names ) ));
416}
417impl Clone for __locale_struct {
418 fn clone(&self) -> Self { *self }
419}
420pub type __locale_t = *mut __locale_struct;
421pub type locale_t = __locale_t;
422#[repr(C)]
423#[derive(Debug, Copy, Clone)]
424pub struct tm([u8; 0]);
425extern "C" {
426 pub fn wcscpy(__dest: *mut wchar_t, __src: *const wchar_t)
427 -> *mut wchar_t;
428}
429extern "C" {
430 pub fn wcsncpy(__dest: *mut wchar_t, __src: *const wchar_t, __n: usize)
431 -> *mut wchar_t;
432}
433extern "C" {
434 pub fn wcscat(__dest: *mut wchar_t, __src: *const wchar_t)
435 -> *mut wchar_t;
436}
437extern "C" {
438 pub fn wcsncat(__dest: *mut wchar_t, __src: *const wchar_t, __n: usize)
439 -> *mut wchar_t;
440}
441extern "C" {
442 pub fn wcscmp(__s1: *const wchar_t, __s2: *const wchar_t)
443 -> ::std::os::raw::c_int;
444}
445extern "C" {
446 pub fn wcsncmp(__s1: *const wchar_t, __s2: *const wchar_t, __n: usize)
447 -> ::std::os::raw::c_int;
448}
449extern "C" {
450 pub fn wcscasecmp(__s1: *const wchar_t, __s2: *const wchar_t)
451 -> ::std::os::raw::c_int;
452}
453extern "C" {
454 pub fn wcsncasecmp(__s1: *const wchar_t, __s2: *const wchar_t, __n: usize)
455 -> ::std::os::raw::c_int;
456}
457extern "C" {
458 pub fn wcscasecmp_l(__s1: *const wchar_t, __s2: *const wchar_t,
459 __loc: locale_t) -> ::std::os::raw::c_int;
460}
461extern "C" {
462 pub fn wcsncasecmp_l(__s1: *const wchar_t, __s2: *const wchar_t,
463 __n: usize, __loc: locale_t)
464 -> ::std::os::raw::c_int;
465}
466extern "C" {
467 pub fn wcscoll(__s1: *const wchar_t, __s2: *const wchar_t)
468 -> ::std::os::raw::c_int;
469}
470extern "C" {
471 pub fn wcsxfrm(__s1: *mut wchar_t, __s2: *const wchar_t, __n: usize)
472 -> usize;
473}
474extern "C" {
475 pub fn wcscoll_l(__s1: *const wchar_t, __s2: *const wchar_t,
476 __loc: locale_t) -> ::std::os::raw::c_int;
477}
478extern "C" {
479 pub fn wcsxfrm_l(__s1: *mut wchar_t, __s2: *const wchar_t, __n: usize,
480 __loc: locale_t) -> usize;
481}
482extern "C" {
483 pub fn wcsdup(__s: *const wchar_t) -> *mut wchar_t;
484}
485extern "C" {
486 pub fn wcschr(__wcs: *const wchar_t, __wc: wchar_t)
487 -> *mut ::std::os::raw::c_int;
488}
489extern "C" {
490 pub fn wcsrchr(__wcs: *const wchar_t, __wc: wchar_t) -> *mut wchar_t;
491}
492extern "C" {
493 pub fn wcscspn(__wcs: *const wchar_t, __reject: *const wchar_t) -> usize;
494}
495extern "C" {
496 pub fn wcsspn(__wcs: *const wchar_t, __accept: *const wchar_t) -> usize;
497}
498extern "C" {
499 pub fn wcspbrk(__wcs: *const wchar_t, __accept: *const wchar_t)
500 -> *mut wchar_t;
501}
502extern "C" {
503 pub fn wcsstr(__haystack: *const wchar_t, __needle: *const wchar_t)
504 -> *mut wchar_t;
505}
506extern "C" {
507 pub fn wcstok(__s: *mut wchar_t, __delim: *const wchar_t,
508 __ptr: *mut *mut wchar_t) -> *mut wchar_t;
509}
510extern "C" {
511 pub fn wcslen(__s: *const wchar_t) -> ::std::os::raw::c_ulong;
512}
513extern "C" {
514 pub fn wcsnlen(__s: *const wchar_t, __maxlen: usize) -> usize;
515}
516extern "C" {
517 pub fn wmemchr(__s: *const wchar_t, __c: wchar_t, __n: usize)
518 -> *mut ::std::os::raw::c_int;
519}
520extern "C" {
521 pub fn wmemcmp(__s1: *const wchar_t, __s2: *const wchar_t, __n: usize)
522 -> ::std::os::raw::c_int;
523}
524extern "C" {
525 pub fn wmemcpy(__s1: *mut wchar_t, __s2: *const wchar_t, __n: usize)
526 -> *mut wchar_t;
527}
528extern "C" {
529 pub fn wmemmove(__s1: *mut wchar_t, __s2: *const wchar_t, __n: usize)
530 -> *mut wchar_t;
531}
532extern "C" {
533 pub fn wmemset(__s: *mut wchar_t, __c: wchar_t, __n: usize)
534 -> *mut wchar_t;
535}
536extern "C" {
537 pub fn btowc(__c: ::std::os::raw::c_int) -> wint_t;
538}
539extern "C" {
540 pub fn wctob(__c: wint_t) -> ::std::os::raw::c_int;
541}
542extern "C" {
543 pub fn mbsinit(__ps: *const mbstate_t) -> ::std::os::raw::c_int;
544}
545extern "C" {
546 pub fn mbrtowc(__pwc: *mut wchar_t, __s: *const ::std::os::raw::c_char,
547 __n: usize, __p: *mut mbstate_t) -> usize;
548}
549extern "C" {
550 pub fn wcrtomb(__s: *mut ::std::os::raw::c_char, __wc: wchar_t,
551 __ps: *mut mbstate_t) -> usize;
552}
553extern "C" {
554 pub fn __mbrlen(__s: *const ::std::os::raw::c_char, __n: usize,
555 __ps: *mut mbstate_t) -> usize;
556}
557extern "C" {
558 pub fn mbrlen(__s: *const ::std::os::raw::c_char, __n: usize,
559 __ps: *mut mbstate_t) -> usize;
560}
561extern "C" {
562 pub fn mbsrtowcs(__dst: *mut wchar_t,
563 __src: *mut *const ::std::os::raw::c_char, __len: usize,
564 __ps: *mut mbstate_t) -> usize;
565}
566extern "C" {
567 pub fn wcsrtombs(__dst: *mut ::std::os::raw::c_char,
568 __src: *mut *const wchar_t, __len: usize,
569 __ps: *mut mbstate_t) -> usize;
570}
571extern "C" {
572 pub fn mbsnrtowcs(__dst: *mut wchar_t,
573 __src: *mut *const ::std::os::raw::c_char, __nmc: usize,
574 __len: usize, __ps: *mut mbstate_t) -> usize;
575}
576extern "C" {
577 pub fn wcsnrtombs(__dst: *mut ::std::os::raw::c_char,
578 __src: *mut *const wchar_t, __nwc: usize, __len: usize,
579 __ps: *mut mbstate_t) -> usize;
580}
581extern "C" {
582 pub fn wcstod(__nptr: *const wchar_t, __endptr: *mut *mut wchar_t) -> f64;
583}
584extern "C" {
585 pub fn wcstof(__nptr: *const wchar_t, __endptr: *mut *mut wchar_t) -> f32;
586}
587extern "C" {
588 pub fn wcstold(__nptr: *const wchar_t, __endptr: *mut *mut wchar_t)
589 -> f64;
590}
591extern "C" {
592 pub fn wcstol(__nptr: *const wchar_t, __endptr: *mut *mut wchar_t,
593 __base: ::std::os::raw::c_int) -> ::std::os::raw::c_long;
594}
595extern "C" {
596 pub fn wcstoul(__nptr: *const wchar_t, __endptr: *mut *mut wchar_t,
597 __base: ::std::os::raw::c_int) -> ::std::os::raw::c_ulong;
598}
599extern "C" {
600 pub fn wcstoll(__nptr: *const wchar_t, __endptr: *mut *mut wchar_t,
601 __base: ::std::os::raw::c_int)
602 -> ::std::os::raw::c_longlong;
603}
604extern "C" {
605 pub fn wcstoull(__nptr: *const wchar_t, __endptr: *mut *mut wchar_t,
606 __base: ::std::os::raw::c_int)
607 -> ::std::os::raw::c_ulonglong;
608}
609extern "C" {
610 pub fn wcpcpy(__dest: *mut wchar_t, __src: *const wchar_t)
611 -> *mut wchar_t;
612}
613extern "C" {
614 pub fn wcpncpy(__dest: *mut wchar_t, __src: *const wchar_t, __n: usize)
615 -> *mut wchar_t;
616}
617extern "C" {
618 pub fn open_wmemstream(__bufloc: *mut *mut wchar_t, __sizeloc: *mut usize)
619 -> *mut __FILE;
620}
621extern "C" {
622 pub fn fwide(__fp: *mut __FILE, __mode: ::std::os::raw::c_int)
623 -> ::std::os::raw::c_int;
624}
625extern "C" {
626 pub fn fwprintf(__stream: *mut __FILE, __format: *const wchar_t, ...)
627 -> ::std::os::raw::c_int;
628}
629extern "C" {
630 pub fn wprintf(__format: *const wchar_t, ...) -> ::std::os::raw::c_int;
631}
632extern "C" {
633 pub fn swprintf(__s: *mut wchar_t, __n: usize,
634 __format: *const wchar_t, ...) -> ::std::os::raw::c_int;
635}
636extern "C" {
637 pub fn vfwprintf(__s: *mut __FILE, __format: *const wchar_t,
638 __arg: *mut __va_list_tag) -> ::std::os::raw::c_int;
639}
640extern "C" {
641 pub fn vwprintf(__format: *const wchar_t, __arg: *mut __va_list_tag)
642 -> ::std::os::raw::c_int;
643}
644extern "C" {
645 pub fn vswprintf(__s: *mut wchar_t, __n: usize, __format: *const wchar_t,
646 __arg: *mut __va_list_tag) -> ::std::os::raw::c_int;
647}
648extern "C" {
649 pub fn fwscanf(__stream: *mut __FILE, __format: *const wchar_t, ...)
650 -> ::std::os::raw::c_int;
651}
652extern "C" {
653 pub fn wscanf(__format: *const wchar_t, ...) -> ::std::os::raw::c_int;
654}
655extern "C" {
656 pub fn swscanf(__s: *const wchar_t, __format: *const wchar_t, ...)
657 -> ::std::os::raw::c_int;
658}
659extern "C" {
660 #[link_name = "__isoc99_fwscanf"]
661 pub fn fwscanf1(__stream: *mut __FILE, __format: *const wchar_t, ...)
662 -> ::std::os::raw::c_int;
663}
664extern "C" {
665 #[link_name = "__isoc99_wscanf"]
666 pub fn wscanf1(__format: *const wchar_t, ...) -> ::std::os::raw::c_int;
667}
668extern "C" {
669 #[link_name = "__isoc99_swscanf"]
670 pub fn swscanf1(__s: *const wchar_t, __format: *const wchar_t, ...)
671 -> ::std::os::raw::c_int;
672}
673extern "C" {
674 pub fn vfwscanf(__s: *mut __FILE, __format: *const wchar_t,
675 __arg: *mut __va_list_tag) -> ::std::os::raw::c_int;
676}
677extern "C" {
678 pub fn vwscanf(__format: *const wchar_t, __arg: *mut __va_list_tag)
679 -> ::std::os::raw::c_int;
680}
681extern "C" {
682 pub fn vswscanf(__s: *const wchar_t, __format: *const wchar_t,
683 __arg: *mut __va_list_tag) -> ::std::os::raw::c_int;
684}
685extern "C" {
686 #[link_name = "__isoc99_vfwscanf"]
687 pub fn vfwscanf1(__s: *mut __FILE, __format: *const wchar_t,
688 __arg: *mut __va_list_tag) -> ::std::os::raw::c_int;
689}
690extern "C" {
691 #[link_name = "__isoc99_vwscanf"]
692 pub fn vwscanf1(__format: *const wchar_t, __arg: *mut __va_list_tag)
693 -> ::std::os::raw::c_int;
694}
695extern "C" {
696 #[link_name = "__isoc99_vswscanf"]
697 pub fn vswscanf1(__s: *const wchar_t, __format: *const wchar_t,
698 __arg: *mut __va_list_tag) -> ::std::os::raw::c_int;
699}
700extern "C" {
701 pub fn fgetwc(__stream: *mut __FILE) -> wint_t;
702}
703extern "C" {
704 pub fn getwc(__stream: *mut __FILE) -> wint_t;
705}
706extern "C" {
707 pub fn getwchar() -> wint_t;
708}
709extern "C" {
710 pub fn fputwc(__wc: wchar_t, __stream: *mut __FILE) -> wint_t;
711}
712extern "C" {
713 pub fn putwc(__wc: wchar_t, __stream: *mut __FILE) -> wint_t;
714}
715extern "C" {
716 pub fn putwchar(__wc: wchar_t) -> wint_t;
717}
718extern "C" {
719 pub fn fgetws(__ws: *mut wchar_t, __n: ::std::os::raw::c_int,
720 __stream: *mut __FILE) -> *mut wchar_t;
721}
722extern "C" {
723 pub fn fputws(__ws: *const wchar_t, __stream: *mut __FILE)
724 -> ::std::os::raw::c_int;
725}
726extern "C" {
727 pub fn ungetwc(__wc: wint_t, __stream: *mut __FILE) -> wint_t;
728}
729extern "C" {
730 pub fn wcsftime(__s: *mut wchar_t, __maxsize: usize,
731 __format: *const wchar_t, __tp: *const tm) -> usize;
732}
733#[repr(C)]
734#[derive(Debug, Copy)]
735pub struct godot_string {
736 pub _dont_touch_that: [u8; 8usize],
737}
738#[test]
739fn bindgen_test_layout_godot_string() {
740 assert_eq!(::std::mem::size_of::<godot_string>() , 8usize , concat ! (
741 "Size of: " , stringify ! ( godot_string ) ));
742 assert_eq! (::std::mem::align_of::<godot_string>() , 1usize , concat ! (
743 "Alignment of " , stringify ! ( godot_string ) ));
744 assert_eq! (unsafe {
745 & ( * ( 0 as * const godot_string ) ) . _dont_touch_that as *
746 const _ as usize } , 0usize , concat ! (
747 "Alignment of field: " , stringify ! ( godot_string ) , "::" ,
748 stringify ! ( _dont_touch_that ) ));
749}
750impl Clone for godot_string {
751 fn clone(&self) -> Self { *self }
752}
753extern "C" {
754 pub fn godot_string_new(r_dest: *mut godot_string);
755}
756extern "C" {
757 pub fn godot_string_new_copy(r_dest: *mut godot_string,
758 p_src: *const godot_string);
759}
760extern "C" {
761 pub fn godot_string_new_data(r_dest: *mut godot_string,
762 p_contents: *const ::std::os::raw::c_char,
763 p_size: ::std::os::raw::c_int);
764}
765extern "C" {
766 pub fn godot_string_new_unicode_data(r_dest: *mut godot_string,
767 p_contents: *const wchar_t,
768 p_size: ::std::os::raw::c_int);
769}
770extern "C" {
771 pub fn godot_string_get_data(p_self: *const godot_string,
772 p_dest: *mut ::std::os::raw::c_char,
773 p_size: *mut ::std::os::raw::c_int);
774}
775extern "C" {
776 pub fn godot_string_operator_index(p_self: *mut godot_string,
777 p_idx: godot_int) -> *mut wchar_t;
778}
779extern "C" {
780 pub fn godot_string_c_str(p_self: *const godot_string)
781 -> *const ::std::os::raw::c_char;
782}
783extern "C" {
784 pub fn godot_string_unicode_str(p_self: *const godot_string)
785 -> *const wchar_t;
786}
787extern "C" {
788 pub fn godot_string_operator_equal(p_self: *const godot_string,
789 p_b: *const godot_string)
790 -> godot_bool;
791}
792extern "C" {
793 pub fn godot_string_operator_less(p_self: *const godot_string,
794 p_b: *const godot_string) -> godot_bool;
795}
796extern "C" {
797 pub fn godot_string_operator_plus(p_self: *const godot_string,
798 p_b: *const godot_string)
799 -> godot_string;
800}
801extern "C" {
802 pub fn godot_string_destroy(p_self: *mut godot_string);
803}
804#[repr(C)]
805#[derive(Debug, Copy)]
806pub struct godot_vector2 {
807 pub _dont_touch_that: [u8; 8usize],
808}
809#[test]
810fn bindgen_test_layout_godot_vector2() {
811 assert_eq!(::std::mem::size_of::<godot_vector2>() , 8usize , concat ! (
812 "Size of: " , stringify ! ( godot_vector2 ) ));
813 assert_eq! (::std::mem::align_of::<godot_vector2>() , 1usize , concat ! (
814 "Alignment of " , stringify ! ( godot_vector2 ) ));
815 assert_eq! (unsafe {
816 & ( * ( 0 as * const godot_vector2 ) ) . _dont_touch_that as *
817 const _ as usize } , 0usize , concat ! (
818 "Alignment of field: " , stringify ! ( godot_vector2 ) , "::"
819 , stringify ! ( _dont_touch_that ) ));
820}
821impl Clone for godot_vector2 {
822 fn clone(&self) -> Self { *self }
823}
824extern "C" {
825 pub fn godot_vector2_new(r_dest: *mut godot_vector2, p_x: godot_real,
826 p_y: godot_real);
827}
828extern "C" {
829 pub fn godot_vector2_as_string(p_self: *const godot_vector2)
830 -> godot_string;
831}
832extern "C" {
833 pub fn godot_vector2_normalized(p_self: *const godot_vector2)
834 -> godot_vector2;
835}
836extern "C" {
837 pub fn godot_vector2_length(p_self: *const godot_vector2) -> godot_real;
838}
839extern "C" {
840 pub fn godot_vector2_angle(p_self: *const godot_vector2) -> godot_real;
841}
842extern "C" {
843 pub fn godot_vector2_length_squared(p_self: *const godot_vector2)
844 -> godot_real;
845}
846extern "C" {
847 pub fn godot_vector2_is_normalized(p_self: *const godot_vector2)
848 -> godot_bool;
849}
850extern "C" {
851 pub fn godot_vector2_distance_to(p_self: *const godot_vector2,
852 p_to: *const godot_vector2)
853 -> godot_real;
854}
855extern "C" {
856 pub fn godot_vector2_distance_squared_to(p_self: *const godot_vector2,
857 p_to: *const godot_vector2)
858 -> godot_real;
859}
860extern "C" {
861 pub fn godot_vector2_angle_to(p_self: *const godot_vector2,
862 p_to: *const godot_vector2) -> godot_real;
863}
864extern "C" {
865 pub fn godot_vector2_angle_to_point(p_self: *const godot_vector2,
866 p_to: *const godot_vector2)
867 -> godot_real;
868}
869extern "C" {
870 pub fn godot_vector2_linear_interpolate(p_self: *const godot_vector2,
871 p_b: *const godot_vector2,
872 p_t: godot_real) -> godot_vector2;
873}
874extern "C" {
875 pub fn godot_vector2_cubic_interpolate(p_self: *const godot_vector2,
876 p_b: *const godot_vector2,
877 p_pre_a: *const godot_vector2,
878 p_post_b: *const godot_vector2,
879 p_t: godot_real) -> godot_vector2;
880}
881extern "C" {
882 pub fn godot_vector2_rotated(p_self: *const godot_vector2,
883 p_phi: godot_real) -> godot_vector2;
884}
885extern "C" {
886 pub fn godot_vector2_tangent(p_self: *const godot_vector2)
887 -> godot_vector2;
888}
889extern "C" {
890 pub fn godot_vector2_floor(p_self: *const godot_vector2) -> godot_vector2;
891}
892extern "C" {
893 pub fn godot_vector2_snapped(p_self: *const godot_vector2,
894 p_by: *const godot_vector2) -> godot_vector2;
895}
896extern "C" {
897 pub fn godot_vector2_aspect(p_self: *const godot_vector2) -> godot_real;
898}
899extern "C" {
900 pub fn godot_vector2_dot(p_self: *const godot_vector2,
901 p_with: *const godot_vector2) -> godot_real;
902}
903extern "C" {
904 pub fn godot_vector2_slide(p_self: *const godot_vector2,
905 p_n: *const godot_vector2) -> godot_vector2;
906}
907extern "C" {
908 pub fn godot_vector2_bounce(p_self: *const godot_vector2,
909 p_n: *const godot_vector2) -> godot_vector2;
910}
911extern "C" {
912 pub fn godot_vector2_reflect(p_self: *const godot_vector2,
913 p_n: *const godot_vector2) -> godot_vector2;
914}
915extern "C" {
916 pub fn godot_vector2_abs(p_self: *const godot_vector2) -> godot_vector2;
917}
918extern "C" {
919 pub fn godot_vector2_clamped(p_self: *const godot_vector2,
920 p_length: godot_real) -> godot_vector2;
921}
922extern "C" {
923 pub fn godot_vector2_operator_add(p_self: *const godot_vector2,
924 p_b: *const godot_vector2)
925 -> godot_vector2;
926}
927extern "C" {
928 pub fn godot_vector2_operator_substract(p_self: *const godot_vector2,
929 p_b: *const godot_vector2)
930 -> godot_vector2;
931}
932extern "C" {
933 pub fn godot_vector2_operator_multiply_vector(p_self:
934 *const godot_vector2,
935 p_b: *const godot_vector2)
936 -> godot_vector2;
937}
938extern "C" {
939 pub fn godot_vector2_operator_multiply_scalar(p_self:
940 *const godot_vector2,
941 p_b: godot_real)
942 -> godot_vector2;
943}
944extern "C" {
945 pub fn godot_vector2_operator_divide_vector(p_self: *const godot_vector2,
946 p_b: *const godot_vector2)
947 -> godot_vector2;
948}
949extern "C" {
950 pub fn godot_vector2_operator_divide_scalar(p_self: *const godot_vector2,
951 p_b: godot_real)
952 -> godot_vector2;
953}
954extern "C" {
955 pub fn godot_vector2_operator_equal(p_self: *const godot_vector2,
956 p_b: *const godot_vector2)
957 -> godot_bool;
958}
959extern "C" {
960 pub fn godot_vector2_operator_less(p_self: *const godot_vector2,
961 p_b: *const godot_vector2)
962 -> godot_bool;
963}
964extern "C" {
965 pub fn godot_vector2_operator_neg(p_self: *const godot_vector2)
966 -> godot_vector2;
967}
968extern "C" {
969 pub fn godot_vector2_set_x(p_self: *mut godot_vector2, p_x: godot_real);
970}
971extern "C" {
972 pub fn godot_vector2_set_y(p_self: *mut godot_vector2, p_y: godot_real);
973}
974extern "C" {
975 pub fn godot_vector2_get_x(p_self: *const godot_vector2) -> godot_real;
976}
977extern "C" {
978 pub fn godot_vector2_get_y(p_self: *const godot_vector2) -> godot_real;
979}
980#[repr(C)]
981#[derive(Debug, Copy)]
982pub struct godot_rect2 {
983 pub _dont_touch_that: [u8; 16usize],
984}
985#[test]
986fn bindgen_test_layout_godot_rect2() {
987 assert_eq!(::std::mem::size_of::<godot_rect2>() , 16usize , concat ! (
988 "Size of: " , stringify ! ( godot_rect2 ) ));
989 assert_eq! (::std::mem::align_of::<godot_rect2>() , 1usize , concat ! (
990 "Alignment of " , stringify ! ( godot_rect2 ) ));
991 assert_eq! (unsafe {
992 & ( * ( 0 as * const godot_rect2 ) ) . _dont_touch_that as *
993 const _ as usize } , 0usize , concat ! (
994 "Alignment of field: " , stringify ! ( godot_rect2 ) , "::" ,
995 stringify ! ( _dont_touch_that ) ));
996}
997impl Clone for godot_rect2 {
998 fn clone(&self) -> Self { *self }
999}
1000extern "C" {
1001 pub fn godot_rect2_new_with_position_and_size(r_dest: *mut godot_rect2,
1002 p_pos: *const godot_vector2,
1003 p_size:
1004 *const godot_vector2);
1005}
1006extern "C" {
1007 pub fn godot_rect2_new(r_dest: *mut godot_rect2, p_x: godot_real,
1008 p_y: godot_real, p_width: godot_real,
1009 p_height: godot_real);
1010}
1011extern "C" {
1012 pub fn godot_rect2_as_string(p_self: *const godot_rect2) -> godot_string;
1013}
1014extern "C" {
1015 pub fn godot_rect2_get_area(p_self: *const godot_rect2) -> godot_real;
1016}
1017extern "C" {
1018 pub fn godot_rect2_intersects(p_self: *const godot_rect2,
1019 p_b: *const godot_rect2) -> godot_bool;
1020}
1021extern "C" {
1022 pub fn godot_rect2_encloses(p_self: *const godot_rect2,
1023 p_b: *const godot_rect2) -> godot_bool;
1024}
1025extern "C" {
1026 pub fn godot_rect2_has_no_area(p_self: *const godot_rect2) -> godot_bool;
1027}
1028extern "C" {
1029 pub fn godot_rect2_clip(p_self: *const godot_rect2,
1030 p_b: *const godot_rect2) -> godot_rect2;
1031}
1032extern "C" {
1033 pub fn godot_rect2_merge(p_self: *const godot_rect2,
1034 p_b: *const godot_rect2) -> godot_rect2;
1035}
1036extern "C" {
1037 pub fn godot_rect2_has_point(p_self: *const godot_rect2,
1038 p_point: *const godot_vector2) -> godot_bool;
1039}
1040extern "C" {
1041 pub fn godot_rect2_grow(p_self: *const godot_rect2, p_by: godot_real)
1042 -> godot_rect2;
1043}
1044extern "C" {
1045 pub fn godot_rect2_expand(p_self: *const godot_rect2,
1046 p_to: *const godot_vector2) -> godot_rect2;
1047}
1048extern "C" {
1049 pub fn godot_rect2_operator_equal(p_self: *const godot_rect2,
1050 p_b: *const godot_rect2) -> godot_bool;
1051}
1052extern "C" {
1053 pub fn godot_rect2_get_position(p_self: *const godot_rect2)
1054 -> godot_vector2;
1055}
1056extern "C" {
1057 pub fn godot_rect2_get_size(p_self: *const godot_rect2) -> godot_vector2;
1058}
1059extern "C" {
1060 pub fn godot_rect2_set_position(p_self: *mut godot_rect2,
1061 p_pos: *const godot_vector2);
1062}
1063extern "C" {
1064 pub fn godot_rect2_set_size(p_self: *mut godot_rect2,
1065 p_size: *const godot_vector2);
1066}
1067#[repr(C)]
1068#[derive(Debug, Copy)]
1069pub struct godot_vector3 {
1070 pub _dont_touch_that: [u8; 12usize],
1071}
1072#[test]
1073fn bindgen_test_layout_godot_vector3() {
1074 assert_eq!(::std::mem::size_of::<godot_vector3>() , 12usize , concat ! (
1075 "Size of: " , stringify ! ( godot_vector3 ) ));
1076 assert_eq! (::std::mem::align_of::<godot_vector3>() , 1usize , concat ! (
1077 "Alignment of " , stringify ! ( godot_vector3 ) ));
1078 assert_eq! (unsafe {
1079 & ( * ( 0 as * const godot_vector3 ) ) . _dont_touch_that as *
1080 const _ as usize } , 0usize , concat ! (
1081 "Alignment of field: " , stringify ! ( godot_vector3 ) , "::"
1082 , stringify ! ( _dont_touch_that ) ));
1083}
1084impl Clone for godot_vector3 {
1085 fn clone(&self) -> Self { *self }
1086}
1087#[repr(C)]
1088pub struct godot_basis {
1089 pub _dont_touch_that: [u8; 36usize],
1090}
1091#[test]
1092fn bindgen_test_layout_godot_basis() {
1093 assert_eq!(::std::mem::size_of::<godot_basis>() , 36usize , concat ! (
1094 "Size of: " , stringify ! ( godot_basis ) ));
1095 assert_eq! (::std::mem::align_of::<godot_basis>() , 1usize , concat ! (
1096 "Alignment of " , stringify ! ( godot_basis ) ));
1097 assert_eq! (unsafe {
1098 & ( * ( 0 as * const godot_basis ) ) . _dont_touch_that as *
1099 const _ as usize } , 0usize , concat ! (
1100 "Alignment of field: " , stringify ! ( godot_basis ) , "::" ,
1101 stringify ! ( _dont_touch_that ) ));
1102}
1103#[repr(C)]
1104#[derive(Debug, Copy)]
1105pub struct godot_quat {
1106 pub _dont_touch_that: [u8; 16usize],
1107}
1108#[test]
1109fn bindgen_test_layout_godot_quat() {
1110 assert_eq!(::std::mem::size_of::<godot_quat>() , 16usize , concat ! (
1111 "Size of: " , stringify ! ( godot_quat ) ));
1112 assert_eq! (::std::mem::align_of::<godot_quat>() , 1usize , concat ! (
1113 "Alignment of " , stringify ! ( godot_quat ) ));
1114 assert_eq! (unsafe {
1115 & ( * ( 0 as * const godot_quat ) ) . _dont_touch_that as *
1116 const _ as usize } , 0usize , concat ! (
1117 "Alignment of field: " , stringify ! ( godot_quat ) , "::" ,
1118 stringify ! ( _dont_touch_that ) ));
1119}
1120impl Clone for godot_quat {
1121 fn clone(&self) -> Self { *self }
1122}
1123extern "C" {
1124 pub fn godot_quat_new(r_dest: *mut godot_quat, p_x: godot_real,
1125 p_y: godot_real, p_z: godot_real, p_w: godot_real);
1126}
1127extern "C" {
1128 pub fn godot_quat_new_with_axis_angle(r_dest: *mut godot_quat,
1129 p_axis: *const godot_vector3,
1130 p_angle: godot_real);
1131}
1132extern "C" {
1133 pub fn godot_quat_get_x(p_self: *const godot_quat) -> godot_real;
1134}
1135extern "C" {
1136 pub fn godot_quat_set_x(p_self: *mut godot_quat, val: godot_real);
1137}
1138extern "C" {
1139 pub fn godot_quat_get_y(p_self: *const godot_quat) -> godot_real;
1140}
1141extern "C" {
1142 pub fn godot_quat_set_y(p_self: *mut godot_quat, val: godot_real);
1143}
1144extern "C" {
1145 pub fn godot_quat_get_z(p_self: *const godot_quat) -> godot_real;
1146}
1147extern "C" {
1148 pub fn godot_quat_set_z(p_self: *mut godot_quat, val: godot_real);
1149}
1150extern "C" {
1151 pub fn godot_quat_get_w(p_self: *const godot_quat) -> godot_real;
1152}
1153extern "C" {
1154 pub fn godot_quat_set_w(p_self: *mut godot_quat, val: godot_real);
1155}
1156extern "C" {
1157 pub fn godot_quat_as_string(p_self: *const godot_quat) -> godot_string;
1158}
1159extern "C" {
1160 pub fn godot_quat_length(p_self: *const godot_quat) -> godot_real;
1161}
1162extern "C" {
1163 pub fn godot_quat_length_squared(p_self: *const godot_quat) -> godot_real;
1164}
1165extern "C" {
1166 pub fn godot_quat_normalized(p_self: *const godot_quat) -> godot_quat;
1167}
1168extern "C" {
1169 pub fn godot_quat_is_normalized(p_self: *const godot_quat) -> godot_bool;
1170}
1171extern "C" {
1172 pub fn godot_quat_inverse(p_self: *const godot_quat) -> godot_quat;
1173}
1174extern "C" {
1175 pub fn godot_quat_dot(p_self: *const godot_quat, p_b: *const godot_quat)
1176 -> godot_real;
1177}
1178extern "C" {
1179 pub fn godot_quat_xform(p_self: *const godot_quat,
1180 p_v: *const godot_vector3) -> godot_vector3;
1181}
1182extern "C" {
1183 pub fn godot_quat_slerp(p_self: *const godot_quat, p_b: *const godot_quat,
1184 p_t: godot_real) -> godot_quat;
1185}
1186extern "C" {
1187 pub fn godot_quat_slerpni(p_self: *const godot_quat,
1188 p_b: *const godot_quat, p_t: godot_real)
1189 -> godot_quat;
1190}
1191extern "C" {
1192 pub fn godot_quat_cubic_slerp(p_self: *const godot_quat,
1193 p_b: *const godot_quat,
1194 p_pre_a: *const godot_quat,
1195 p_post_b: *const godot_quat,
1196 p_t: godot_real) -> godot_quat;
1197}
1198extern "C" {
1199 pub fn godot_quat_operator_multiply(p_self: *const godot_quat,
1200 p_b: godot_real) -> godot_quat;
1201}
1202extern "C" {
1203 pub fn godot_quat_operator_add(p_self: *const godot_quat,
1204 p_b: *const godot_quat) -> godot_quat;
1205}
1206extern "C" {
1207 pub fn godot_quat_operator_substract(p_self: *const godot_quat,
1208 p_b: *const godot_quat)
1209 -> godot_quat;
1210}
1211extern "C" {
1212 pub fn godot_quat_operator_divide(p_self: *const godot_quat,
1213 p_b: godot_real) -> godot_quat;
1214}
1215extern "C" {
1216 pub fn godot_quat_operator_equal(p_self: *const godot_quat,
1217 p_b: *const godot_quat) -> godot_bool;
1218}
1219extern "C" {
1220 pub fn godot_quat_operator_neg(p_self: *const godot_quat) -> godot_quat;
1221}
1222extern "C" {
1223 pub fn godot_basis_new_with_rows(r_dest: *mut godot_basis,
1224 p_x_axis: *const godot_vector3,
1225 p_y_axis: *const godot_vector3,
1226 p_z_axis: *const godot_vector3);
1227}
1228extern "C" {
1229 pub fn godot_basis_new_with_axis_and_angle(r_dest: *mut godot_basis,
1230 p_axis: *const godot_vector3,
1231 p_phi: godot_real);
1232}
1233extern "C" {
1234 pub fn godot_basis_new_with_euler(r_dest: *mut godot_basis,
1235 p_euler: *const godot_vector3);
1236}
1237extern "C" {
1238 pub fn godot_basis_as_string(p_self: *const godot_basis) -> godot_string;
1239}
1240extern "C" {
1241 pub fn godot_basis_inverse(p_self: *const godot_basis) -> godot_basis;
1242}
1243extern "C" {
1244 pub fn godot_basis_transposed(p_self: *const godot_basis) -> godot_basis;
1245}
1246extern "C" {
1247 pub fn godot_basis_orthonormalized(p_self: *const godot_basis)
1248 -> godot_basis;
1249}
1250extern "C" {
1251 pub fn godot_basis_determinant(p_self: *const godot_basis) -> godot_real;
1252}
1253extern "C" {
1254 pub fn godot_basis_rotated(p_self: *const godot_basis,
1255 p_axis: *const godot_vector3,
1256 p_phi: godot_real) -> godot_basis;
1257}
1258extern "C" {
1259 pub fn godot_basis_scaled(p_self: *const godot_basis,
1260 p_scale: *const godot_vector3) -> godot_basis;
1261}
1262extern "C" {
1263 pub fn godot_basis_set_scale(p_self: *mut godot_basis,
1264 p_scale: *const godot_vector3);
1265}
1266extern "C" {
1267 pub fn godot_basis_set_rotation_euler(p_self: *mut godot_basis,
1268 p_euler: *const godot_vector3);
1269}
1270extern "C" {
1271 pub fn godot_basis_set_rotation_axis_angle(p_self: *mut godot_basis,
1272 p_axis: *const godot_vector3,
1273 p_angle: godot_real);
1274}
1275extern "C" {
1276 pub fn godot_basis_get_scale(p_self: *const godot_basis) -> godot_vector3;
1277}
1278extern "C" {
1279 pub fn godot_basis_get_euler(p_self: *const godot_basis) -> godot_vector3;
1280}
1281extern "C" {
1282 pub fn godot_basis_tdotx(p_self: *const godot_basis,
1283 p_with: *const godot_vector3) -> godot_real;
1284}
1285extern "C" {
1286 pub fn godot_basis_tdoty(p_self: *const godot_basis,
1287 p_with: *const godot_vector3) -> godot_real;
1288}
1289extern "C" {
1290 pub fn godot_basis_tdotz(p_self: *const godot_basis,
1291 p_with: *const godot_vector3) -> godot_real;
1292}
1293extern "C" {
1294 pub fn godot_basis_xform(p_self: *const godot_basis,
1295 p_v: *const godot_vector3) -> godot_vector3;
1296}
1297extern "C" {
1298 pub fn godot_basis_xform_inv(p_self: *const godot_basis,
1299 p_v: *const godot_vector3) -> godot_vector3;
1300}
1301extern "C" {
1302 pub fn godot_basis_get_orthogonal_index(p_self: *const godot_basis)
1303 -> godot_int;
1304}
1305extern "C" {
1306 pub fn godot_basis_new(r_dest: *mut godot_basis);
1307}
1308extern "C" {
1309 pub fn godot_basis_new_with_euler_quat(r_dest: *mut godot_basis,
1310 p_euler: *const godot_quat);
1311}
1312extern "C" {
1313 pub fn godot_basis_get_elements(p_self: *mut godot_basis,
1314 p_elements: *mut godot_vector3);
1315}
1316extern "C" {
1317 pub fn godot_basis_get_axis(p_self: *const godot_basis, p_axis: godot_int)
1318 -> godot_vector3;
1319}
1320extern "C" {
1321 pub fn godot_basis_set_axis(p_self: *mut godot_basis, p_axis: godot_int,
1322 p_value: *const godot_vector3);
1323}
1324extern "C" {
1325 pub fn godot_basis_get_row(p_self: *const godot_basis, p_row: godot_int)
1326 -> godot_vector3;
1327}
1328extern "C" {
1329 pub fn godot_basis_set_row(p_self: *mut godot_basis, p_row: godot_int,
1330 p_value: *const godot_vector3);
1331}
1332extern "C" {
1333 pub fn godot_basis_operator_equal(p_self: *const godot_basis,
1334 p_b: *const godot_basis) -> godot_bool;
1335}
1336extern "C" {
1337 pub fn godot_basis_operator_add(p_self: *const godot_basis,
1338 p_b: *const godot_basis) -> godot_basis;
1339}
1340extern "C" {
1341 pub fn godot_basis_operator_substract(p_self: *const godot_basis,
1342 p_b: *const godot_basis)
1343 -> godot_basis;
1344}
1345extern "C" {
1346 pub fn godot_basis_operator_multiply_vector(p_self: *const godot_basis,
1347 p_b: *const godot_basis)
1348 -> godot_basis;
1349}
1350extern "C" {
1351 pub fn godot_basis_operator_multiply_scalar(p_self: *const godot_basis,
1352 p_b: godot_real)
1353 -> godot_basis;
1354}
1355#[repr(u32)]
1356#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
1357pub enum godot_vector3_axis {
1358 GODOT_VECTOR3_AXIS_X = 0,
1359 GODOT_VECTOR3_AXIS_Y = 1,
1360 GODOT_VECTOR3_AXIS_Z = 2,
1361}
1362extern "C" {
1363 pub fn godot_vector3_new(r_dest: *mut godot_vector3, p_x: godot_real,
1364 p_y: godot_real, p_z: godot_real);
1365}
1366extern "C" {
1367 pub fn godot_vector3_as_string(p_self: *const godot_vector3)
1368 -> godot_string;
1369}
1370extern "C" {
1371 pub fn godot_vector3_min_axis(p_self: *const godot_vector3) -> godot_int;
1372}
1373extern "C" {
1374 pub fn godot_vector3_max_axis(p_self: *const godot_vector3) -> godot_int;
1375}
1376extern "C" {
1377 pub fn godot_vector3_length(p_self: *const godot_vector3) -> godot_real;
1378}
1379extern "C" {
1380 pub fn godot_vector3_length_squared(p_self: *const godot_vector3)
1381 -> godot_real;
1382}
1383extern "C" {
1384 pub fn godot_vector3_is_normalized(p_self: *const godot_vector3)
1385 -> godot_bool;
1386}
1387extern "C" {
1388 pub fn godot_vector3_normalized(p_self: *const godot_vector3)
1389 -> godot_vector3;
1390}
1391extern "C" {
1392 pub fn godot_vector3_inverse(p_self: *const godot_vector3)
1393 -> godot_vector3;
1394}
1395extern "C" {
1396 pub fn godot_vector3_snapped(p_self: *const godot_vector3,
1397 p_by: *const godot_vector3) -> godot_vector3;
1398}
1399extern "C" {
1400 pub fn godot_vector3_rotated(p_self: *const godot_vector3,
1401 p_axis: *const godot_vector3,
1402 p_phi: godot_real) -> godot_vector3;
1403}
1404extern "C" {
1405 pub fn godot_vector3_linear_interpolate(p_self: *const godot_vector3,
1406 p_b: *const godot_vector3,
1407 p_t: godot_real) -> godot_vector3;
1408}
1409extern "C" {
1410 pub fn godot_vector3_cubic_interpolate(p_self: *const godot_vector3,
1411 p_b: *const godot_vector3,
1412 p_pre_a: *const godot_vector3,
1413 p_post_b: *const godot_vector3,
1414 p_t: godot_real) -> godot_vector3;
1415}
1416extern "C" {
1417 pub fn godot_vector3_dot(p_self: *const godot_vector3,
1418 p_b: *const godot_vector3) -> godot_real;
1419}
1420extern "C" {
1421 pub fn godot_vector3_cross(p_self: *const godot_vector3,
1422 p_b: *const godot_vector3) -> godot_vector3;
1423}
1424extern "C" {
1425 pub fn godot_vector3_outer(p_self: *const godot_vector3,
1426 p_b: *const godot_vector3) -> godot_basis;
1427}
1428extern "C" {
1429 pub fn godot_vector3_to_diagonal_matrix(p_self: *const godot_vector3)
1430 -> godot_basis;
1431}
1432extern "C" {
1433 pub fn godot_vector3_abs(p_self: *const godot_vector3) -> godot_vector3;
1434}
1435extern "C" {
1436 pub fn godot_vector3_floor(p_self: *const godot_vector3) -> godot_vector3;
1437}
1438extern "C" {
1439 pub fn godot_vector3_ceil(p_self: *const godot_vector3) -> godot_vector3;
1440}
1441extern "C" {
1442 pub fn godot_vector3_distance_to(p_self: *const godot_vector3,
1443 p_b: *const godot_vector3) -> godot_real;
1444}
1445extern "C" {
1446 pub fn godot_vector3_distance_squared_to(p_self: *const godot_vector3,
1447 p_b: *const godot_vector3)
1448 -> godot_real;
1449}
1450extern "C" {
1451 pub fn godot_vector3_angle_to(p_self: *const godot_vector3,
1452 p_to: *const godot_vector3) -> godot_real;
1453}
1454extern "C" {
1455 pub fn godot_vector3_slide(p_self: *const godot_vector3,
1456 p_n: *const godot_vector3) -> godot_vector3;
1457}
1458extern "C" {
1459 pub fn godot_vector3_bounce(p_self: *const godot_vector3,
1460 p_n: *const godot_vector3) -> godot_vector3;
1461}
1462extern "C" {
1463 pub fn godot_vector3_reflect(p_self: *const godot_vector3,
1464 p_n: *const godot_vector3) -> godot_vector3;
1465}
1466extern "C" {
1467 pub fn godot_vector3_operator_add(p_self: *const godot_vector3,
1468 p_b: *const godot_vector3)
1469 -> godot_vector3;
1470}
1471extern "C" {
1472 pub fn godot_vector3_operator_substract(p_self: *const godot_vector3,
1473 p_b: *const godot_vector3)
1474 -> godot_vector3;
1475}
1476extern "C" {
1477 pub fn godot_vector3_operator_multiply_vector(p_self:
1478 *const godot_vector3,
1479 p_b: *const godot_vector3)
1480 -> godot_vector3;
1481}
1482extern "C" {
1483 pub fn godot_vector3_operator_multiply_scalar(p_self:
1484 *const godot_vector3,
1485 p_b: godot_real)
1486 -> godot_vector3;
1487}
1488extern "C" {
1489 pub fn godot_vector3_operator_divide_vector(p_self: *const godot_vector3,
1490 p_b: *const godot_vector3)
1491 -> godot_vector3;
1492}
1493extern "C" {
1494 pub fn godot_vector3_operator_divide_scalar(p_self: *const godot_vector3,
1495 p_b: godot_real)
1496 -> godot_vector3;
1497}
1498extern "C" {
1499 pub fn godot_vector3_operator_equal(p_self: *const godot_vector3,
1500 p_b: *const godot_vector3)
1501 -> godot_bool;
1502}
1503extern "C" {
1504 pub fn godot_vector3_operator_less(p_self: *const godot_vector3,
1505 p_b: *const godot_vector3)
1506 -> godot_bool;
1507}
1508extern "C" {
1509 pub fn godot_vector3_operator_neg(p_self: *const godot_vector3)
1510 -> godot_vector3;
1511}
1512extern "C" {
1513 pub fn godot_vector3_set_axis(p_self: *mut godot_vector3,
1514 p_axis: godot_vector3_axis,
1515 p_val: godot_real);
1516}
1517extern "C" {
1518 pub fn godot_vector3_get_axis(p_self: *const godot_vector3,
1519 p_axis: godot_vector3_axis) -> godot_real;
1520}
1521#[repr(C)]
1522#[derive(Debug, Copy)]
1523pub struct godot_transform2d {
1524 pub _dont_touch_that: [u8; 24usize],
1525}
1526#[test]
1527fn bindgen_test_layout_godot_transform2d() {
1528 assert_eq!(::std::mem::size_of::<godot_transform2d>() , 24usize , concat !
1529 ( "Size of: " , stringify ! ( godot_transform2d ) ));
1530 assert_eq! (::std::mem::align_of::<godot_transform2d>() , 1usize , concat
1531 ! ( "Alignment of " , stringify ! ( godot_transform2d ) ));
1532 assert_eq! (unsafe {
1533 & ( * ( 0 as * const godot_transform2d ) ) . _dont_touch_that
1534 as * const _ as usize } , 0usize , concat ! (
1535 "Alignment of field: " , stringify ! ( godot_transform2d ) ,
1536 "::" , stringify ! ( _dont_touch_that ) ));
1537}
1538impl Clone for godot_transform2d {
1539 fn clone(&self) -> Self { *self }
1540}
1541#[repr(C)]
1542#[derive(Debug, Copy)]
1543pub struct godot_variant {
1544 pub _dont_touch_that: [u8; 24usize],
1545}
1546#[test]
1547fn bindgen_test_layout_godot_variant() {
1548 assert_eq!(::std::mem::size_of::<godot_variant>() , 24usize , concat ! (
1549 "Size of: " , stringify ! ( godot_variant ) ));
1550 assert_eq! (::std::mem::align_of::<godot_variant>() , 1usize , concat ! (
1551 "Alignment of " , stringify ! ( godot_variant ) ));
1552 assert_eq! (unsafe {
1553 & ( * ( 0 as * const godot_variant ) ) . _dont_touch_that as *
1554 const _ as usize } , 0usize , concat ! (
1555 "Alignment of field: " , stringify ! ( godot_variant ) , "::"
1556 , stringify ! ( _dont_touch_that ) ));
1557}
1558impl Clone for godot_variant {
1559 fn clone(&self) -> Self { *self }
1560}
1561#[repr(u32)]
1562#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
1563pub enum godot_variant_type {
1564 GODOT_VARIANT_TYPE_NIL = 0,
1565 GODOT_VARIANT_TYPE_BOOL = 1,
1566 GODOT_VARIANT_TYPE_INT = 2,
1567 GODOT_VARIANT_TYPE_REAL = 3,
1568 GODOT_VARIANT_TYPE_STRING = 4,
1569 GODOT_VARIANT_TYPE_VECTOR2 = 5,
1570 GODOT_VARIANT_TYPE_RECT2 = 6,
1571 GODOT_VARIANT_TYPE_VECTOR3 = 7,
1572 GODOT_VARIANT_TYPE_TRANSFORM2D = 8,
1573 GODOT_VARIANT_TYPE_PLANE = 9,
1574 GODOT_VARIANT_TYPE_QUAT = 10,
1575 GODOT_VARIANT_TYPE_RECT3 = 11,
1576 GODOT_VARIANT_TYPE_BASIS = 12,
1577 GODOT_VARIANT_TYPE_TRANSFORM = 13,
1578 GODOT_VARIANT_TYPE_COLOR = 14,
1579 GODOT_VARIANT_TYPE_NODE_PATH = 15,
1580 GODOT_VARIANT_TYPE_RID = 16,
1581 GODOT_VARIANT_TYPE_OBJECT = 17,
1582 GODOT_VARIANT_TYPE_DICTIONARY = 18,
1583 GODOT_VARIANT_TYPE_ARRAY = 19,
1584 GODOT_VARIANT_TYPE_POOL_BYTE_ARRAY = 20,
1585 GODOT_VARIANT_TYPE_POOL_INT_ARRAY = 21,
1586 GODOT_VARIANT_TYPE_POOL_REAL_ARRAY = 22,
1587 GODOT_VARIANT_TYPE_POOL_STRING_ARRAY = 23,
1588 GODOT_VARIANT_TYPE_POOL_VECTOR2_ARRAY = 24,
1589 GODOT_VARIANT_TYPE_POOL_VECTOR3_ARRAY = 25,
1590 GODOT_VARIANT_TYPE_POOL_COLOR_ARRAY = 26,
1591}
1592#[repr(u32)]
1593#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
1594pub enum godot_variant_call_error_error {
1595 GODOT_CALL_ERROR_CALL_OK = 0,
1596 GODOT_CALL_ERROR_CALL_ERROR_INVALID_METHOD = 1,
1597 GODOT_CALL_ERROR_CALL_ERROR_INVALID_ARGUMENT = 2,
1598 GODOT_CALL_ERROR_CALL_ERROR_TOO_MANY_ARGUMENTS = 3,
1599 GODOT_CALL_ERROR_CALL_ERROR_TOO_FEW_ARGUMENTS = 4,
1600 GODOT_CALL_ERROR_CALL_ERROR_INSTANCE_IS_NULL = 5,
1601}
1602#[repr(C)]
1603#[derive(Debug, Copy)]
1604pub struct godot_variant_call_error {
1605 pub error: godot_variant_call_error_error,
1606 pub argument: ::std::os::raw::c_int,
1607 pub expected: godot_variant_type,
1608}
1609#[test]
1610fn bindgen_test_layout_godot_variant_call_error() {
1611 assert_eq!(::std::mem::size_of::<godot_variant_call_error>() , 12usize ,
1612 concat ! (
1613 "Size of: " , stringify ! ( godot_variant_call_error ) ));
1614 assert_eq! (::std::mem::align_of::<godot_variant_call_error>() , 4usize ,
1615 concat ! (
1616 "Alignment of " , stringify ! ( godot_variant_call_error ) ));
1617 assert_eq! (unsafe {
1618 & ( * ( 0 as * const godot_variant_call_error ) ) . error as *
1619 const _ as usize } , 0usize , concat ! (
1620 "Alignment of field: " , stringify ! (
1621 godot_variant_call_error ) , "::" , stringify ! ( error ) ));
1622 assert_eq! (unsafe {
1623 & ( * ( 0 as * const godot_variant_call_error ) ) . argument
1624 as * const _ as usize } , 4usize , concat ! (
1625 "Alignment of field: " , stringify ! (
1626 godot_variant_call_error ) , "::" , stringify ! ( argument )
1627 ));
1628 assert_eq! (unsafe {
1629 & ( * ( 0 as * const godot_variant_call_error ) ) . expected
1630 as * const _ as usize } , 8usize , concat ! (
1631 "Alignment of field: " , stringify ! (
1632 godot_variant_call_error ) , "::" , stringify ! ( expected )
1633 ));
1634}
1635impl Clone for godot_variant_call_error {
1636 fn clone(&self) -> Self { *self }
1637}
1638#[repr(C)]
1639#[derive(Debug, Copy)]
1640pub struct godot_array {
1641 pub _dont_touch_that: [u8; 8usize],
1642}
1643#[test]
1644fn bindgen_test_layout_godot_array() {
1645 assert_eq!(::std::mem::size_of::<godot_array>() , 8usize , concat ! (
1646 "Size of: " , stringify ! ( godot_array ) ));
1647 assert_eq! (::std::mem::align_of::<godot_array>() , 1usize , concat ! (
1648 "Alignment of " , stringify ! ( godot_array ) ));
1649 assert_eq! (unsafe {
1650 & ( * ( 0 as * const godot_array ) ) . _dont_touch_that as *
1651 const _ as usize } , 0usize , concat ! (
1652 "Alignment of field: " , stringify ! ( godot_array ) , "::" ,
1653 stringify ! ( _dont_touch_that ) ));
1654}
1655impl Clone for godot_array {
1656 fn clone(&self) -> Self { *self }
1657}
1658#[repr(C)]
1659#[derive(Debug, Copy)]
1660pub struct godot_pool_byte_array {
1661 pub _dont_touch_that: [u8; 8usize],
1662}
1663#[test]
1664fn bindgen_test_layout_godot_pool_byte_array() {
1665 assert_eq!(::std::mem::size_of::<godot_pool_byte_array>() , 8usize ,
1666 concat ! ( "Size of: " , stringify ! ( godot_pool_byte_array )
1667 ));
1668 assert_eq! (::std::mem::align_of::<godot_pool_byte_array>() , 1usize ,
1669 concat ! (
1670 "Alignment of " , stringify ! ( godot_pool_byte_array ) ));
1671 assert_eq! (unsafe {
1672 & ( * ( 0 as * const godot_pool_byte_array ) ) .
1673 _dont_touch_that as * const _ as usize } , 0usize , concat ! (
1674 "Alignment of field: " , stringify ! ( godot_pool_byte_array )
1675 , "::" , stringify ! ( _dont_touch_that ) ));
1676}
1677impl Clone for godot_pool_byte_array {
1678 fn clone(&self) -> Self { *self }
1679}
1680#[repr(C)]
1681#[derive(Debug, Copy)]
1682pub struct godot_pool_int_array {
1683 pub _dont_touch_that: [u8; 8usize],
1684}
1685#[test]
1686fn bindgen_test_layout_godot_pool_int_array() {
1687 assert_eq!(::std::mem::size_of::<godot_pool_int_array>() , 8usize , concat
1688 ! ( "Size of: " , stringify ! ( godot_pool_int_array ) ));
1689 assert_eq! (::std::mem::align_of::<godot_pool_int_array>() , 1usize ,
1690 concat ! (
1691 "Alignment of " , stringify ! ( godot_pool_int_array ) ));
1692 assert_eq! (unsafe {
1693 & ( * ( 0 as * const godot_pool_int_array ) ) .
1694 _dont_touch_that as * const _ as usize } , 0usize , concat ! (
1695 "Alignment of field: " , stringify ! ( godot_pool_int_array )
1696 , "::" , stringify ! ( _dont_touch_that ) ));
1697}
1698impl Clone for godot_pool_int_array {
1699 fn clone(&self) -> Self { *self }
1700}
1701#[repr(C)]
1702#[derive(Debug, Copy)]
1703pub struct godot_pool_real_array {
1704 pub _dont_touch_that: [u8; 8usize],
1705}
1706#[test]
1707fn bindgen_test_layout_godot_pool_real_array() {
1708 assert_eq!(::std::mem::size_of::<godot_pool_real_array>() , 8usize ,
1709 concat ! ( "Size of: " , stringify ! ( godot_pool_real_array )
1710 ));
1711 assert_eq! (::std::mem::align_of::<godot_pool_real_array>() , 1usize ,
1712 concat ! (
1713 "Alignment of " , stringify ! ( godot_pool_real_array ) ));
1714 assert_eq! (unsafe {
1715 & ( * ( 0 as * const godot_pool_real_array ) ) .
1716 _dont_touch_that as * const _ as usize } , 0usize , concat ! (
1717 "Alignment of field: " , stringify ! ( godot_pool_real_array )
1718 , "::" , stringify ! ( _dont_touch_that ) ));
1719}
1720impl Clone for godot_pool_real_array {
1721 fn clone(&self) -> Self { *self }
1722}
1723#[repr(C)]
1724#[derive(Debug, Copy)]
1725pub struct godot_pool_string_array {
1726 pub _dont_touch_that: [u8; 8usize],
1727}
1728#[test]
1729fn bindgen_test_layout_godot_pool_string_array() {
1730 assert_eq!(::std::mem::size_of::<godot_pool_string_array>() , 8usize ,
1731 concat ! (
1732 "Size of: " , stringify ! ( godot_pool_string_array ) ));
1733 assert_eq! (::std::mem::align_of::<godot_pool_string_array>() , 1usize ,
1734 concat ! (
1735 "Alignment of " , stringify ! ( godot_pool_string_array ) ));
1736 assert_eq! (unsafe {
1737 & ( * ( 0 as * const godot_pool_string_array ) ) .
1738 _dont_touch_that as * const _ as usize } , 0usize , concat ! (
1739 "Alignment of field: " , stringify ! ( godot_pool_string_array
1740 ) , "::" , stringify ! ( _dont_touch_that ) ));
1741}
1742impl Clone for godot_pool_string_array {
1743 fn clone(&self) -> Self { *self }
1744}
1745#[repr(C)]
1746#[derive(Debug, Copy)]
1747pub struct godot_pool_vector2_array {
1748 pub _dont_touch_that: [u8; 8usize],
1749}
1750#[test]
1751fn bindgen_test_layout_godot_pool_vector2_array() {
1752 assert_eq!(::std::mem::size_of::<godot_pool_vector2_array>() , 8usize ,
1753 concat ! (
1754 "Size of: " , stringify ! ( godot_pool_vector2_array ) ));
1755 assert_eq! (::std::mem::align_of::<godot_pool_vector2_array>() , 1usize ,
1756 concat ! (
1757 "Alignment of " , stringify ! ( godot_pool_vector2_array ) ));
1758 assert_eq! (unsafe {
1759 & ( * ( 0 as * const godot_pool_vector2_array ) ) .
1760 _dont_touch_that as * const _ as usize } , 0usize , concat ! (
1761 "Alignment of field: " , stringify ! (
1762 godot_pool_vector2_array ) , "::" , stringify ! (
1763 _dont_touch_that ) ));
1764}
1765impl Clone for godot_pool_vector2_array {
1766 fn clone(&self) -> Self { *self }
1767}
1768#[repr(C)]
1769#[derive(Debug, Copy)]
1770pub struct godot_pool_vector3_array {
1771 pub _dont_touch_that: [u8; 8usize],
1772}
1773#[test]
1774fn bindgen_test_layout_godot_pool_vector3_array() {
1775 assert_eq!(::std::mem::size_of::<godot_pool_vector3_array>() , 8usize ,
1776 concat ! (
1777 "Size of: " , stringify ! ( godot_pool_vector3_array ) ));
1778 assert_eq! (::std::mem::align_of::<godot_pool_vector3_array>() , 1usize ,
1779 concat ! (
1780 "Alignment of " , stringify ! ( godot_pool_vector3_array ) ));
1781 assert_eq! (unsafe {
1782 & ( * ( 0 as * const godot_pool_vector3_array ) ) .
1783 _dont_touch_that as * const _ as usize } , 0usize , concat ! (
1784 "Alignment of field: " , stringify ! (
1785 godot_pool_vector3_array ) , "::" , stringify ! (
1786 _dont_touch_that ) ));
1787}
1788impl Clone for godot_pool_vector3_array {
1789 fn clone(&self) -> Self { *self }
1790}
1791#[repr(C)]
1792#[derive(Debug, Copy)]
1793pub struct godot_pool_color_array {
1794 pub _dont_touch_that: [u8; 8usize],
1795}
1796#[test]
1797fn bindgen_test_layout_godot_pool_color_array() {
1798 assert_eq!(::std::mem::size_of::<godot_pool_color_array>() , 8usize ,
1799 concat ! ( "Size of: " , stringify ! ( godot_pool_color_array )
1800 ));
1801 assert_eq! (::std::mem::align_of::<godot_pool_color_array>() , 1usize ,
1802 concat ! (
1803 "Alignment of " , stringify ! ( godot_pool_color_array ) ));
1804 assert_eq! (unsafe {
1805 & ( * ( 0 as * const godot_pool_color_array ) ) .
1806 _dont_touch_that as * const _ as usize } , 0usize , concat ! (
1807 "Alignment of field: " , stringify ! ( godot_pool_color_array
1808 ) , "::" , stringify ! ( _dont_touch_that ) ));
1809}
1810impl Clone for godot_pool_color_array {
1811 fn clone(&self) -> Self { *self }
1812}
1813#[repr(C)]
1814#[derive(Debug, Copy)]
1815pub struct godot_color {
1816 pub _dont_touch_that: [u8; 16usize],
1817}
1818#[test]
1819fn bindgen_test_layout_godot_color() {
1820 assert_eq!(::std::mem::size_of::<godot_color>() , 16usize , concat ! (
1821 "Size of: " , stringify ! ( godot_color ) ));
1822 assert_eq! (::std::mem::align_of::<godot_color>() , 1usize , concat ! (
1823 "Alignment of " , stringify ! ( godot_color ) ));
1824 assert_eq! (unsafe {
1825 & ( * ( 0 as * const godot_color ) ) . _dont_touch_that as *
1826 const _ as usize } , 0usize , concat ! (
1827 "Alignment of field: " , stringify ! ( godot_color ) , "::" ,
1828 stringify ! ( _dont_touch_that ) ));
1829}
1830impl Clone for godot_color {
1831 fn clone(&self) -> Self { *self }
1832}
1833extern "C" {
1834 pub fn godot_color_new_rgba(r_dest: *mut godot_color, p_r: godot_real,
1835 p_g: godot_real, p_b: godot_real,
1836 p_a: godot_real);
1837}
1838extern "C" {
1839 pub fn godot_color_new_rgb(r_dest: *mut godot_color, p_r: godot_real,
1840 p_g: godot_real, p_b: godot_real);
1841}
1842extern "C" {
1843 pub fn godot_color_get_r(p_self: *const godot_color) -> godot_real;
1844}
1845extern "C" {
1846 pub fn godot_color_set_r(p_self: *mut godot_color, r: godot_real);
1847}
1848extern "C" {
1849 pub fn godot_color_get_g(p_self: *const godot_color) -> godot_real;
1850}
1851extern "C" {
1852 pub fn godot_color_set_g(p_self: *mut godot_color, g: godot_real);
1853}
1854extern "C" {
1855 pub fn godot_color_get_b(p_self: *const godot_color) -> godot_real;
1856}
1857extern "C" {
1858 pub fn godot_color_set_b(p_self: *mut godot_color, b: godot_real);
1859}
1860extern "C" {
1861 pub fn godot_color_get_a(p_self: *const godot_color) -> godot_real;
1862}
1863extern "C" {
1864 pub fn godot_color_set_a(p_self: *mut godot_color, a: godot_real);
1865}
1866extern "C" {
1867 pub fn godot_color_get_h(p_self: *const godot_color) -> godot_real;
1868}
1869extern "C" {
1870 pub fn godot_color_get_s(p_self: *const godot_color) -> godot_real;
1871}
1872extern "C" {
1873 pub fn godot_color_get_v(p_self: *const godot_color) -> godot_real;
1874}
1875extern "C" {
1876 pub fn godot_color_as_string(p_self: *const godot_color) -> godot_string;
1877}
1878extern "C" {
1879 pub fn godot_color_to_32(p_self: *const godot_color) -> godot_int;
1880}
1881extern "C" {
1882 pub fn godot_color_to_ARGB32(p_self: *const godot_color) -> godot_int;
1883}
1884extern "C" {
1885 pub fn godot_color_gray(p_self: *const godot_color) -> godot_real;
1886}
1887extern "C" {
1888 pub fn godot_color_inverted(p_self: *const godot_color) -> godot_color;
1889}
1890extern "C" {
1891 pub fn godot_color_contrasted(p_self: *const godot_color) -> godot_color;
1892}
1893extern "C" {
1894 pub fn godot_color_linear_interpolate(p_self: *const godot_color,
1895 p_b: *const godot_color,
1896 p_t: godot_real) -> godot_color;
1897}
1898extern "C" {
1899 pub fn godot_color_blend(p_self: *const godot_color,
1900 p_over: *const godot_color) -> godot_color;
1901}
1902extern "C" {
1903 pub fn godot_color_to_html(p_self: *const godot_color,
1904 p_with_alpha: godot_bool) -> godot_string;
1905}
1906extern "C" {
1907 pub fn godot_color_operator_equal(p_self: *const godot_color,
1908 p_b: *const godot_color) -> godot_bool;
1909}
1910extern "C" {
1911 pub fn godot_color_operator_less(p_self: *const godot_color,
1912 p_b: *const godot_color) -> godot_bool;
1913}
1914extern "C" {
1915 pub fn godot_pool_byte_array_new(r_dest: *mut godot_pool_byte_array);
1916}
1917extern "C" {
1918 pub fn godot_pool_byte_array_new_copy(r_dest: *mut godot_pool_byte_array,
1919 p_src:
1920 *const godot_pool_byte_array);
1921}
1922extern "C" {
1923 pub fn godot_pool_byte_array_new_with_array(r_dest:
1924 *mut godot_pool_byte_array,
1925 p_a: *const godot_array);
1926}
1927extern "C" {
1928 pub fn godot_pool_byte_array_append(p_self: *mut godot_pool_byte_array,
1929 p_data: u8);
1930}
1931extern "C" {
1932 pub fn godot_pool_byte_array_append_array(p_self:
1933 *mut godot_pool_byte_array,
1934 p_array:
1935 *const godot_pool_byte_array);
1936}
1937extern "C" {
1938 pub fn godot_pool_byte_array_insert(p_self: *mut godot_pool_byte_array,
1939 p_idx: godot_int, p_data: u8)
1940 -> godot_error;
1941}
1942extern "C" {
1943 pub fn godot_pool_byte_array_invert(p_self: *mut godot_pool_byte_array);
1944}
1945extern "C" {
1946 pub fn godot_pool_byte_array_push_back(p_self: *mut godot_pool_byte_array,
1947 p_data: u8);
1948}
1949extern "C" {
1950 pub fn godot_pool_byte_array_remove(p_self: *mut godot_pool_byte_array,
1951 p_idx: godot_int);
1952}
1953extern "C" {
1954 pub fn godot_pool_byte_array_resize(p_self: *mut godot_pool_byte_array,
1955 p_size: godot_int);
1956}
1957extern "C" {
1958 pub fn godot_pool_byte_array_set(p_self: *mut godot_pool_byte_array,
1959 p_idx: godot_int, p_data: u8);
1960}
1961extern "C" {
1962 pub fn godot_pool_byte_array_get(p_self: *const godot_pool_byte_array,
1963 p_idx: godot_int) -> u8;
1964}
1965extern "C" {
1966 pub fn godot_pool_byte_array_size(p_self: *const godot_pool_byte_array)
1967 -> godot_int;
1968}
1969extern "C" {
1970 pub fn godot_pool_byte_array_destroy(p_self: *mut godot_pool_byte_array);
1971}
1972extern "C" {
1973 pub fn godot_pool_int_array_new(r_dest: *mut godot_pool_int_array);
1974}
1975extern "C" {
1976 pub fn godot_pool_int_array_new_copy(r_dest: *mut godot_pool_int_array,
1977 p_src: *const godot_pool_int_array);
1978}
1979extern "C" {
1980 pub fn godot_pool_int_array_new_with_array(r_dest:
1981 *mut godot_pool_int_array,
1982 p_a: *const godot_array);
1983}
1984extern "C" {
1985 pub fn godot_pool_int_array_append(p_self: *mut godot_pool_int_array,
1986 p_data: godot_int);
1987}
1988extern "C" {
1989 pub fn godot_pool_int_array_append_array(p_self:
1990 *mut godot_pool_int_array,
1991 p_array:
1992 *const godot_pool_int_array);
1993}
1994extern "C" {
1995 pub fn godot_pool_int_array_insert(p_self: *mut godot_pool_int_array,
1996 p_idx: godot_int, p_data: godot_int)
1997 -> godot_error;
1998}
1999extern "C" {
2000 pub fn godot_pool_int_array_invert(p_self: *mut godot_pool_int_array);
2001}
2002extern "C" {
2003 pub fn godot_pool_int_array_push_back(p_self: *mut godot_pool_int_array,
2004 p_data: godot_int);
2005}
2006extern "C" {
2007 pub fn godot_pool_int_array_remove(p_self: *mut godot_pool_int_array,
2008 p_idx: godot_int);
2009}
2010extern "C" {
2011 pub fn godot_pool_int_array_resize(p_self: *mut godot_pool_int_array,
2012 p_size: godot_int);
2013}
2014extern "C" {
2015 pub fn godot_pool_int_array_set(p_self: *mut godot_pool_int_array,
2016 p_idx: godot_int, p_data: godot_int);
2017}
2018extern "C" {
2019 pub fn godot_pool_int_array_get(p_self: *const godot_pool_int_array,
2020 p_idx: godot_int) -> godot_int;
2021}
2022extern "C" {
2023 pub fn godot_pool_int_array_size(p_self: *const godot_pool_int_array)
2024 -> godot_int;
2025}
2026extern "C" {
2027 pub fn godot_pool_int_array_destroy(p_self: *mut godot_pool_int_array);
2028}
2029extern "C" {
2030 pub fn godot_pool_real_array_new(r_dest: *mut godot_pool_real_array);
2031}
2032extern "C" {
2033 pub fn godot_pool_real_array_new_copy(r_dest: *mut godot_pool_real_array,
2034 p_src:
2035 *const godot_pool_real_array);
2036}
2037extern "C" {
2038 pub fn godot_pool_real_array_new_with_array(r_dest:
2039 *mut godot_pool_real_array,
2040 p_a: *const godot_array);
2041}
2042extern "C" {
2043 pub fn godot_pool_real_array_append(p_self: *mut godot_pool_real_array,
2044 p_data: godot_real);
2045}
2046extern "C" {
2047 pub fn godot_pool_real_array_append_array(p_self:
2048 *mut godot_pool_real_array,
2049 p_array:
2050 *const godot_pool_real_array);
2051}
2052extern "C" {
2053 pub fn godot_pool_real_array_insert(p_self: *mut godot_pool_real_array,
2054 p_idx: godot_int, p_data: godot_real)
2055 -> godot_error;
2056}
2057extern "C" {
2058 pub fn godot_pool_real_array_invert(p_self: *mut godot_pool_real_array);
2059}
2060extern "C" {
2061 pub fn godot_pool_real_array_push_back(p_self: *mut godot_pool_real_array,
2062 p_data: godot_real);
2063}
2064extern "C" {
2065 pub fn godot_pool_real_array_remove(p_self: *mut godot_pool_real_array,
2066 p_idx: godot_int);
2067}
2068extern "C" {
2069 pub fn godot_pool_real_array_resize(p_self: *mut godot_pool_real_array,
2070 p_size: godot_int);
2071}
2072extern "C" {
2073 pub fn godot_pool_real_array_set(p_self: *mut godot_pool_real_array,
2074 p_idx: godot_int, p_data: godot_real);
2075}
2076extern "C" {
2077 pub fn godot_pool_real_array_get(p_self: *const godot_pool_real_array,
2078 p_idx: godot_int) -> godot_real;
2079}
2080extern "C" {
2081 pub fn godot_pool_real_array_size(p_self: *const godot_pool_real_array)
2082 -> godot_int;
2083}
2084extern "C" {
2085 pub fn godot_pool_real_array_destroy(p_self: *mut godot_pool_real_array);
2086}
2087extern "C" {
2088 pub fn godot_pool_string_array_new(r_dest: *mut godot_pool_string_array);
2089}
2090extern "C" {
2091 pub fn godot_pool_string_array_new_copy(r_dest:
2092 *mut godot_pool_string_array,
2093 p_src:
2094 *const godot_pool_string_array);
2095}
2096extern "C" {
2097 pub fn godot_pool_string_array_new_with_array(r_dest:
2098 *mut godot_pool_string_array,
2099 p_a: *const godot_array);
2100}
2101extern "C" {
2102 pub fn godot_pool_string_array_append(p_self:
2103 *mut godot_pool_string_array,
2104 p_data: *const godot_string);
2105}
2106extern "C" {
2107 pub fn godot_pool_string_array_append_array(p_self:
2108 *mut godot_pool_string_array,
2109 p_array:
2110 *const godot_pool_string_array);
2111}
2112extern "C" {
2113 pub fn godot_pool_string_array_insert(p_self:
2114 *mut godot_pool_string_array,
2115 p_idx: godot_int,
2116 p_data: *const godot_string)
2117 -> godot_error;
2118}
2119extern "C" {
2120 pub fn godot_pool_string_array_invert(p_self:
2121 *mut godot_pool_string_array);
2122}
2123extern "C" {
2124 pub fn godot_pool_string_array_push_back(p_self:
2125 *mut godot_pool_string_array,
2126 p_data: *const godot_string);
2127}
2128extern "C" {
2129 pub fn godot_pool_string_array_remove(p_self:
2130 *mut godot_pool_string_array,
2131 p_idx: godot_int);
2132}
2133extern "C" {
2134 pub fn godot_pool_string_array_resize(p_self:
2135 *mut godot_pool_string_array,
2136 p_size: godot_int);
2137}
2138extern "C" {
2139 pub fn godot_pool_string_array_set(p_self: *mut godot_pool_string_array,
2140 p_idx: godot_int,
2141 p_data: *const godot_string);
2142}
2143extern "C" {
2144 pub fn godot_pool_string_array_get(p_self: *const godot_pool_string_array,
2145 p_idx: godot_int) -> godot_string;
2146}
2147extern "C" {
2148 pub fn godot_pool_string_array_size(p_self:
2149 *const godot_pool_string_array)
2150 -> godot_int;
2151}
2152extern "C" {
2153 pub fn godot_pool_string_array_destroy(p_self:
2154 *mut godot_pool_string_array);
2155}
2156extern "C" {
2157 pub fn godot_pool_vector2_array_new(r_dest:
2158 *mut godot_pool_vector2_array);
2159}
2160extern "C" {
2161 pub fn godot_pool_vector2_array_new_copy(r_dest:
2162 *mut godot_pool_vector2_array,
2163 p_src:
2164 *const godot_pool_vector2_array);
2165}
2166extern "C" {
2167 pub fn godot_pool_vector2_array_new_with_array(r_dest:
2168 *mut godot_pool_vector2_array,
2169 p_a: *const godot_array);
2170}
2171extern "C" {
2172 pub fn godot_pool_vector2_array_append(p_self:
2173 *mut godot_pool_vector2_array,
2174 p_data: *const godot_vector2);
2175}
2176extern "C" {
2177 pub fn godot_pool_vector2_array_append_array(p_self:
2178 *mut godot_pool_vector2_array,
2179 p_array:
2180 *const godot_pool_vector2_array);
2181}
2182extern "C" {
2183 pub fn godot_pool_vector2_array_insert(p_self:
2184 *mut godot_pool_vector2_array,
2185 p_idx: godot_int,
2186 p_data: *const godot_vector2)
2187 -> godot_error;
2188}
2189extern "C" {
2190 pub fn godot_pool_vector2_array_invert(p_self:
2191 *mut godot_pool_vector2_array);
2192}
2193extern "C" {
2194 pub fn godot_pool_vector2_array_push_back(p_self:
2195 *mut godot_pool_vector2_array,
2196 p_data: *const godot_vector2);
2197}
2198extern "C" {
2199 pub fn godot_pool_vector2_array_remove(p_self:
2200 *mut godot_pool_vector2_array,
2201 p_idx: godot_int);
2202}
2203extern "C" {
2204 pub fn godot_pool_vector2_array_resize(p_self:
2205 *mut godot_pool_vector2_array,
2206 p_size: godot_int);
2207}
2208extern "C" {
2209 pub fn godot_pool_vector2_array_set(p_self: *mut godot_pool_vector2_array,
2210 p_idx: godot_int,
2211 p_data: *const godot_vector2);
2212}
2213extern "C" {
2214 pub fn godot_pool_vector2_array_get(p_self:
2215 *const godot_pool_vector2_array,
2216 p_idx: godot_int) -> godot_vector2;
2217}
2218extern "C" {
2219 pub fn godot_pool_vector2_array_size(p_self:
2220 *const godot_pool_vector2_array)
2221 -> godot_int;
2222}
2223extern "C" {
2224 pub fn godot_pool_vector2_array_destroy(p_self:
2225 *mut godot_pool_vector2_array);
2226}
2227extern "C" {
2228 pub fn godot_pool_vector3_array_new(r_dest:
2229 *mut godot_pool_vector3_array);
2230}
2231extern "C" {
2232 pub fn godot_pool_vector3_array_new_copy(r_dest:
2233 *mut godot_pool_vector3_array,
2234 p_src:
2235 *const godot_pool_vector3_array);
2236}
2237extern "C" {
2238 pub fn godot_pool_vector3_array_new_with_array(r_dest:
2239 *mut godot_pool_vector3_array,
2240 p_a: *const godot_array);
2241}
2242extern "C" {
2243 pub fn godot_pool_vector3_array_append(p_self:
2244 *mut godot_pool_vector3_array,
2245 p_data: *const godot_vector3);
2246}
2247extern "C" {
2248 pub fn godot_pool_vector3_array_append_array(p_self:
2249 *mut godot_pool_vector3_array,
2250 p_array:
2251 *const godot_pool_vector3_array);
2252}
2253extern "C" {
2254 pub fn godot_pool_vector3_array_insert(p_self:
2255 *mut godot_pool_vector3_array,
2256 p_idx: godot_int,
2257 p_data: *const godot_vector3)
2258 -> godot_error;
2259}
2260extern "C" {
2261 pub fn godot_pool_vector3_array_invert(p_self:
2262 *mut godot_pool_vector3_array);
2263}
2264extern "C" {
2265 pub fn godot_pool_vector3_array_push_back(p_self:
2266 *mut godot_pool_vector3_array,
2267 p_data: *const godot_vector3);
2268}
2269extern "C" {
2270 pub fn godot_pool_vector3_array_remove(p_self:
2271 *mut godot_pool_vector3_array,
2272 p_idx: godot_int);
2273}
2274extern "C" {
2275 pub fn godot_pool_vector3_array_resize(p_self:
2276 *mut godot_pool_vector3_array,
2277 p_size: godot_int);
2278}
2279extern "C" {
2280 pub fn godot_pool_vector3_array_set(p_self: *mut godot_pool_vector3_array,
2281 p_idx: godot_int,
2282 p_data: *const godot_vector3);
2283}
2284extern "C" {
2285 pub fn godot_pool_vector3_array_get(p_self:
2286 *const godot_pool_vector3_array,
2287 p_idx: godot_int) -> godot_vector3;
2288}
2289extern "C" {
2290 pub fn godot_pool_vector3_array_size(p_self:
2291 *const godot_pool_vector3_array)
2292 -> godot_int;
2293}
2294extern "C" {
2295 pub fn godot_pool_vector3_array_destroy(p_self:
2296 *mut godot_pool_vector3_array);
2297}
2298extern "C" {
2299 pub fn godot_pool_color_array_new(r_dest: *mut godot_pool_color_array);
2300}
2301extern "C" {
2302 pub fn godot_pool_color_array_new_copy(r_dest:
2303 *mut godot_pool_color_array,
2304 p_src:
2305 *const godot_pool_color_array);
2306}
2307extern "C" {
2308 pub fn godot_pool_color_array_new_with_array(r_dest:
2309 *mut godot_pool_color_array,
2310 p_a: *const godot_array);
2311}
2312extern "C" {
2313 pub fn godot_pool_color_array_append(p_self: *mut godot_pool_color_array,
2314 p_data: *const godot_color);
2315}
2316extern "C" {
2317 pub fn godot_pool_color_array_append_array(p_self:
2318 *mut godot_pool_color_array,
2319 p_array:
2320 *const godot_pool_color_array);
2321}
2322extern "C" {
2323 pub fn godot_pool_color_array_insert(p_self: *mut godot_pool_color_array,
2324 p_idx: godot_int,
2325 p_data: *const godot_color)
2326 -> godot_error;
2327}
2328extern "C" {
2329 pub fn godot_pool_color_array_invert(p_self: *mut godot_pool_color_array);
2330}
2331extern "C" {
2332 pub fn godot_pool_color_array_push_back(p_self:
2333 *mut godot_pool_color_array,
2334 p_data: *const godot_color);
2335}
2336extern "C" {
2337 pub fn godot_pool_color_array_remove(p_self: *mut godot_pool_color_array,
2338 p_idx: godot_int);
2339}
2340extern "C" {
2341 pub fn godot_pool_color_array_resize(p_self: *mut godot_pool_color_array,
2342 p_size: godot_int);
2343}
2344extern "C" {
2345 pub fn godot_pool_color_array_set(p_self: *mut godot_pool_color_array,
2346 p_idx: godot_int,
2347 p_data: *const godot_color);
2348}
2349extern "C" {
2350 pub fn godot_pool_color_array_get(p_self: *const godot_pool_color_array,
2351 p_idx: godot_int) -> godot_color;
2352}
2353extern "C" {
2354 pub fn godot_pool_color_array_size(p_self: *const godot_pool_color_array)
2355 -> godot_int;
2356}
2357extern "C" {
2358 pub fn godot_pool_color_array_destroy(p_self:
2359 *mut godot_pool_color_array);
2360}
2361extern "C" {
2362 pub fn godot_array_new(r_dest: *mut godot_array);
2363}
2364extern "C" {
2365 pub fn godot_array_new_copy(r_dest: *mut godot_array,
2366 p_src: *const godot_array);
2367}
2368extern "C" {
2369 pub fn godot_array_new_pool_color_array(r_dest: *mut godot_array,
2370 p_pca:
2371 *const godot_pool_color_array);
2372}
2373extern "C" {
2374 pub fn godot_array_new_pool_vector3_array(r_dest: *mut godot_array,
2375 p_pv3a:
2376 *const godot_pool_vector3_array);
2377}
2378extern "C" {
2379 pub fn godot_array_new_pool_vector2_array(r_dest: *mut godot_array,
2380 p_pv2a:
2381 *const godot_pool_vector2_array);
2382}
2383extern "C" {
2384 pub fn godot_array_new_pool_string_array(r_dest: *mut godot_array,
2385 p_psa:
2386 *const godot_pool_string_array);
2387}
2388extern "C" {
2389 pub fn godot_array_new_pool_real_array(r_dest: *mut godot_array,
2390 p_pra:
2391 *const godot_pool_real_array);
2392}
2393extern "C" {
2394 pub fn godot_array_new_pool_int_array(r_dest: *mut godot_array,
2395 p_pia: *const godot_pool_int_array);
2396}
2397extern "C" {
2398 pub fn godot_array_new_pool_byte_array(r_dest: *mut godot_array,
2399 p_pba:
2400 *const godot_pool_byte_array);
2401}
2402extern "C" {
2403 pub fn godot_array_set(p_self: *mut godot_array, p_idx: godot_int,
2404 p_value: *const godot_variant);
2405}
2406extern "C" {
2407 pub fn godot_array_get(p_self: *const godot_array, p_idx: godot_int)
2408 -> godot_variant;
2409}
2410extern "C" {
2411 pub fn godot_array_operator_index(p_self: *mut godot_array,
2412 p_idx: godot_int) -> *mut godot_variant;
2413}
2414extern "C" {
2415 pub fn godot_array_append(p_self: *mut godot_array,
2416 p_value: *const godot_variant);
2417}
2418extern "C" {
2419 pub fn godot_array_clear(p_self: *mut godot_array);
2420}
2421extern "C" {
2422 pub fn godot_array_count(p_self: *const godot_array,
2423 p_value: *const godot_variant) -> godot_int;
2424}
2425extern "C" {
2426 pub fn godot_array_empty(p_self: *const godot_array) -> godot_bool;
2427}
2428extern "C" {
2429 pub fn godot_array_erase(p_self: *mut godot_array,
2430 p_value: *const godot_variant);
2431}
2432extern "C" {
2433 pub fn godot_array_front(p_self: *const godot_array) -> godot_variant;
2434}
2435extern "C" {
2436 pub fn godot_array_back(p_self: *const godot_array) -> godot_variant;
2437}
2438extern "C" {
2439 pub fn godot_array_find(p_self: *const godot_array,
2440 p_what: *const godot_variant, p_from: godot_int)
2441 -> godot_int;
2442}
2443extern "C" {
2444 pub fn godot_array_find_last(p_self: *const godot_array,
2445 p_what: *const godot_variant) -> godot_int;
2446}
2447extern "C" {
2448 pub fn godot_array_has(p_self: *const godot_array,
2449 p_value: *const godot_variant) -> godot_bool;
2450}
2451extern "C" {
2452 pub fn godot_array_hash(p_self: *const godot_array) -> godot_int;
2453}
2454extern "C" {
2455 pub fn godot_array_insert(p_self: *mut godot_array, p_pos: godot_int,
2456 p_value: *const godot_variant);
2457}
2458extern "C" {
2459 pub fn godot_array_invert(p_self: *mut godot_array);
2460}
2461extern "C" {
2462 pub fn godot_array_pop_back(p_self: *mut godot_array) -> godot_variant;
2463}
2464extern "C" {
2465 pub fn godot_array_pop_front(p_self: *mut godot_array) -> godot_variant;
2466}
2467extern "C" {
2468 pub fn godot_array_push_back(p_self: *mut godot_array,
2469 p_value: *const godot_variant);
2470}
2471extern "C" {
2472 pub fn godot_array_push_front(p_self: *mut godot_array,
2473 p_value: *const godot_variant);
2474}
2475extern "C" {
2476 pub fn godot_array_remove(p_self: *mut godot_array, p_idx: godot_int);
2477}
2478extern "C" {
2479 pub fn godot_array_resize(p_self: *mut godot_array, p_size: godot_int);
2480}
2481extern "C" {
2482 pub fn godot_array_rfind(p_self: *const godot_array,
2483 p_what: *const godot_variant, p_from: godot_int)
2484 -> godot_int;
2485}
2486extern "C" {
2487 pub fn godot_array_size(p_self: *const godot_array) -> godot_int;
2488}
2489extern "C" {
2490 pub fn godot_array_sort(p_self: *mut godot_array);
2491}
2492extern "C" {
2493 pub fn godot_array_sort_custom(p_self: *mut godot_array,
2494 p_obj: *mut godot_object,
2495 p_func: *const godot_string);
2496}
2497extern "C" {
2498 pub fn godot_array_destroy(p_self: *mut godot_array);
2499}
2500#[repr(C)]
2501#[derive(Debug, Copy)]
2502pub struct godot_dictionary {
2503 pub _dont_touch_that: [u8; 8usize],
2504}
2505#[test]
2506fn bindgen_test_layout_godot_dictionary() {
2507 assert_eq!(::std::mem::size_of::<godot_dictionary>() , 8usize , concat ! (
2508 "Size of: " , stringify ! ( godot_dictionary ) ));
2509 assert_eq! (::std::mem::align_of::<godot_dictionary>() , 1usize , concat !
2510 ( "Alignment of " , stringify ! ( godot_dictionary ) ));
2511 assert_eq! (unsafe {
2512 & ( * ( 0 as * const godot_dictionary ) ) . _dont_touch_that
2513 as * const _ as usize } , 0usize , concat ! (
2514 "Alignment of field: " , stringify ! ( godot_dictionary ) ,
2515 "::" , stringify ! ( _dont_touch_that ) ));
2516}
2517impl Clone for godot_dictionary {
2518 fn clone(&self) -> Self { *self }
2519}
2520extern "C" {
2521 pub fn godot_dictionary_new(r_dest: *mut godot_dictionary);
2522}
2523extern "C" {
2524 pub fn godot_dictionary_new_copy(r_dest: *mut godot_dictionary,
2525 p_src: *const godot_dictionary);
2526}
2527extern "C" {
2528 pub fn godot_dictionary_destroy(p_self: *mut godot_dictionary);
2529}
2530extern "C" {
2531 pub fn godot_dictionary_size(p_self: *const godot_dictionary)
2532 -> godot_int;
2533}
2534extern "C" {
2535 pub fn godot_dictionary_empty(p_self: *const godot_dictionary)
2536 -> godot_bool;
2537}
2538extern "C" {
2539 pub fn godot_dictionary_clear(p_self: *mut godot_dictionary);
2540}
2541extern "C" {
2542 pub fn godot_dictionary_has(p_self: *const godot_dictionary,
2543 p_key: *const godot_variant) -> godot_bool;
2544}
2545extern "C" {
2546 pub fn godot_dictionary_has_all(p_self: *const godot_dictionary,
2547 p_keys: *const godot_array) -> godot_bool;
2548}
2549extern "C" {
2550 pub fn godot_dictionary_erase(p_self: *mut godot_dictionary,
2551 p_key: *const godot_variant);
2552}
2553extern "C" {
2554 pub fn godot_dictionary_hash(p_self: *const godot_dictionary)
2555 -> godot_int;
2556}
2557extern "C" {
2558 pub fn godot_dictionary_keys(p_self: *const godot_dictionary)
2559 -> godot_array;
2560}
2561extern "C" {
2562 pub fn godot_dictionary_values(p_self: *const godot_dictionary)
2563 -> godot_array;
2564}
2565extern "C" {
2566 pub fn godot_dictionary_get(p_self: *const godot_dictionary,
2567 p_key: *const godot_variant) -> godot_variant;
2568}
2569extern "C" {
2570 pub fn godot_dictionary_set(p_self: *mut godot_dictionary,
2571 p_key: *const godot_variant,
2572 p_value: *const godot_variant);
2573}
2574extern "C" {
2575 pub fn godot_dictionary_operator_index(p_self: *mut godot_dictionary,
2576 p_key: *const godot_variant)
2577 -> *mut godot_variant;
2578}
2579extern "C" {
2580 pub fn godot_dictionary_next(p_self: *const godot_dictionary,
2581 p_key: *const godot_variant)
2582 -> *mut godot_variant;
2583}
2584extern "C" {
2585 pub fn godot_dictionary_operator_equal(p_self: *const godot_dictionary,
2586 p_b: *const godot_dictionary)
2587 -> godot_bool;
2588}
2589extern "C" {
2590 pub fn godot_dictionary_to_json(p_self: *const godot_dictionary)
2591 -> godot_string;
2592}
2593#[repr(C)]
2594#[derive(Debug, Copy)]
2595pub struct godot_node_path {
2596 pub _dont_touch_that: [u8; 8usize],
2597}
2598#[test]
2599fn bindgen_test_layout_godot_node_path() {
2600 assert_eq!(::std::mem::size_of::<godot_node_path>() , 8usize , concat ! (
2601 "Size of: " , stringify ! ( godot_node_path ) ));
2602 assert_eq! (::std::mem::align_of::<godot_node_path>() , 1usize , concat !
2603 ( "Alignment of " , stringify ! ( godot_node_path ) ));
2604 assert_eq! (unsafe {
2605 & ( * ( 0 as * const godot_node_path ) ) . _dont_touch_that as
2606 * const _ as usize } , 0usize , concat ! (
2607 "Alignment of field: " , stringify ! ( godot_node_path ) ,
2608 "::" , stringify ! ( _dont_touch_that ) ));
2609}
2610impl Clone for godot_node_path {
2611 fn clone(&self) -> Self { *self }
2612}
2613extern "C" {
2614 pub fn godot_node_path_new(r_dest: *mut godot_node_path,
2615 p_from: *const godot_string);
2616}
2617extern "C" {
2618 pub fn godot_node_path_new_copy(r_dest: *mut godot_node_path,
2619 p_src: *const godot_node_path);
2620}
2621extern "C" {
2622 pub fn godot_node_path_destroy(p_self: *mut godot_node_path);
2623}
2624extern "C" {
2625 pub fn godot_node_path_as_string(p_self: *const godot_node_path)
2626 -> godot_string;
2627}
2628extern "C" {
2629 pub fn godot_node_path_is_absolute(p_self: *const godot_node_path)
2630 -> godot_bool;
2631}
2632extern "C" {
2633 pub fn godot_node_path_get_name_count(p_self: *const godot_node_path)
2634 -> godot_int;
2635}
2636extern "C" {
2637 pub fn godot_node_path_get_name(p_self: *const godot_node_path,
2638 p_idx: godot_int) -> godot_string;
2639}
2640extern "C" {
2641 pub fn godot_node_path_get_subname_count(p_self: *const godot_node_path)
2642 -> godot_int;
2643}
2644extern "C" {
2645 pub fn godot_node_path_get_subname(p_self: *const godot_node_path,
2646 p_idx: godot_int) -> godot_string;
2647}
2648extern "C" {
2649 pub fn godot_node_path_get_property(p_self: *const godot_node_path)
2650 -> godot_string;
2651}
2652extern "C" {
2653 pub fn godot_node_path_is_empty(p_self: *const godot_node_path)
2654 -> godot_bool;
2655}
2656extern "C" {
2657 pub fn godot_node_path_operator_equal(p_self: *const godot_node_path,
2658 p_b: *const godot_node_path)
2659 -> godot_bool;
2660}
2661#[repr(C)]
2662#[derive(Debug, Copy)]
2663pub struct godot_plane {
2664 pub _dont_touch_that: [u8; 16usize],
2665}
2666#[test]
2667fn bindgen_test_layout_godot_plane() {
2668 assert_eq!(::std::mem::size_of::<godot_plane>() , 16usize , concat ! (
2669 "Size of: " , stringify ! ( godot_plane ) ));
2670 assert_eq! (::std::mem::align_of::<godot_plane>() , 1usize , concat ! (
2671 "Alignment of " , stringify ! ( godot_plane ) ));
2672 assert_eq! (unsafe {
2673 & ( * ( 0 as * const godot_plane ) ) . _dont_touch_that as *
2674 const _ as usize } , 0usize , concat ! (
2675 "Alignment of field: " , stringify ! ( godot_plane ) , "::" ,
2676 stringify ! ( _dont_touch_that ) ));
2677}
2678impl Clone for godot_plane {
2679 fn clone(&self) -> Self { *self }
2680}
2681extern "C" {
2682 pub fn godot_plane_new_with_reals(r_dest: *mut godot_plane,
2683 p_a: godot_real, p_b: godot_real,
2684 p_c: godot_real, p_d: godot_real);
2685}
2686extern "C" {
2687 pub fn godot_plane_new_with_vectors(r_dest: *mut godot_plane,
2688 p_v1: *const godot_vector3,
2689 p_v2: *const godot_vector3,
2690 p_v3: *const godot_vector3);
2691}
2692extern "C" {
2693 pub fn godot_plane_new_with_normal(r_dest: *mut godot_plane,
2694 p_normal: *const godot_vector3,
2695 p_d: godot_real);
2696}
2697extern "C" {
2698 pub fn godot_plane_as_string(p_self: *const godot_plane) -> godot_string;
2699}
2700extern "C" {
2701 pub fn godot_plane_normalized(p_self: *const godot_plane) -> godot_plane;
2702}
2703extern "C" {
2704 pub fn godot_plane_center(p_self: *const godot_plane) -> godot_vector3;
2705}
2706extern "C" {
2707 pub fn godot_plane_get_any_point(p_self: *const godot_plane)
2708 -> godot_vector3;
2709}
2710extern "C" {
2711 pub fn godot_plane_is_point_over(p_self: *const godot_plane,
2712 p_point: *const godot_vector3)
2713 -> godot_bool;
2714}
2715extern "C" {
2716 pub fn godot_plane_distance_to(p_self: *const godot_plane,
2717 p_point: *const godot_vector3)
2718 -> godot_real;
2719}
2720extern "C" {
2721 pub fn godot_plane_has_point(p_self: *const godot_plane,
2722 p_point: *const godot_vector3,
2723 p_epsilon: godot_real) -> godot_bool;
2724}
2725extern "C" {
2726 pub fn godot_plane_project(p_self: *const godot_plane,
2727 p_point: *const godot_vector3)
2728 -> godot_vector3;
2729}
2730extern "C" {
2731 pub fn godot_plane_intersect_3(p_self: *const godot_plane,
2732 r_dest: *mut godot_vector3,
2733 p_b: *const godot_plane,
2734 p_c: *const godot_plane) -> godot_bool;
2735}
2736extern "C" {
2737 pub fn godot_plane_intersects_ray(p_self: *const godot_plane,
2738 r_dest: *mut godot_vector3,
2739 p_from: *const godot_vector3,
2740 p_dir: *const godot_vector3)
2741 -> godot_bool;
2742}
2743extern "C" {
2744 pub fn godot_plane_intersects_segment(p_self: *const godot_plane,
2745 r_dest: *mut godot_vector3,
2746 p_begin: *const godot_vector3,
2747 p_end: *const godot_vector3)
2748 -> godot_bool;
2749}
2750extern "C" {
2751 pub fn godot_plane_operator_neg(p_self: *const godot_plane)
2752 -> godot_plane;
2753}
2754extern "C" {
2755 pub fn godot_plane_operator_equal(p_self: *const godot_plane,
2756 p_b: *const godot_plane) -> godot_bool;
2757}
2758extern "C" {
2759 pub fn godot_plane_set_normal(p_self: *mut godot_plane,
2760 p_normal: *const godot_vector3);
2761}
2762extern "C" {
2763 pub fn godot_plane_get_normal(p_self: *const godot_plane)
2764 -> godot_vector3;
2765}
2766extern "C" {
2767 pub fn godot_plane_get_d(p_self: *const godot_plane) -> godot_real;
2768}
2769extern "C" {
2770 pub fn godot_plane_set_d(p_self: *mut godot_plane, p_d: godot_real);
2771}
2772#[repr(C)]
2773#[derive(Debug, Copy)]
2774pub struct godot_rect3 {
2775 pub _dont_touch_that: [u8; 24usize],
2776}
2777#[test]
2778fn bindgen_test_layout_godot_rect3() {
2779 assert_eq!(::std::mem::size_of::<godot_rect3>() , 24usize , concat ! (
2780 "Size of: " , stringify ! ( godot_rect3 ) ));
2781 assert_eq! (::std::mem::align_of::<godot_rect3>() , 1usize , concat ! (
2782 "Alignment of " , stringify ! ( godot_rect3 ) ));
2783 assert_eq! (unsafe {
2784 & ( * ( 0 as * const godot_rect3 ) ) . _dont_touch_that as *
2785 const _ as usize } , 0usize , concat ! (
2786 "Alignment of field: " , stringify ! ( godot_rect3 ) , "::" ,
2787 stringify ! ( _dont_touch_that ) ));
2788}
2789impl Clone for godot_rect3 {
2790 fn clone(&self) -> Self { *self }
2791}
2792extern "C" {
2793 pub fn godot_rect3_new(r_dest: *mut godot_rect3,
2794 p_pos: *const godot_vector3,
2795 p_size: *const godot_vector3);
2796}
2797extern "C" {
2798 pub fn godot_rect3_get_position(p_self: *const godot_rect3)
2799 -> godot_vector3;
2800}
2801extern "C" {
2802 pub fn godot_rect3_set_position(p_self: *const godot_rect3,
2803 p_v: *const godot_vector3);
2804}
2805extern "C" {
2806 pub fn godot_rect3_get_size(p_self: *const godot_rect3) -> godot_vector3;
2807}
2808extern "C" {
2809 pub fn godot_rect3_set_size(p_self: *const godot_rect3,
2810 p_v: *const godot_vector3);
2811}
2812extern "C" {
2813 pub fn godot_rect3_as_string(p_self: *const godot_rect3) -> godot_string;
2814}
2815extern "C" {
2816 pub fn godot_rect3_get_area(p_self: *const godot_rect3) -> godot_real;
2817}
2818extern "C" {
2819 pub fn godot_rect3_has_no_area(p_self: *const godot_rect3) -> godot_bool;
2820}
2821extern "C" {
2822 pub fn godot_rect3_has_no_surface(p_self: *const godot_rect3)
2823 -> godot_bool;
2824}
2825extern "C" {
2826 pub fn godot_rect3_intersects(p_self: *const godot_rect3,
2827 p_with: *const godot_rect3) -> godot_bool;
2828}
2829extern "C" {
2830 pub fn godot_rect3_encloses(p_self: *const godot_rect3,
2831 p_with: *const godot_rect3) -> godot_bool;
2832}
2833extern "C" {
2834 pub fn godot_rect3_merge(p_self: *const godot_rect3,
2835 p_with: *const godot_rect3) -> godot_rect3;
2836}
2837extern "C" {
2838 pub fn godot_rect3_intersection(p_self: *const godot_rect3,
2839 p_with: *const godot_rect3)
2840 -> godot_rect3;
2841}
2842extern "C" {
2843 pub fn godot_rect3_intersects_plane(p_self: *const godot_rect3,
2844 p_plane: *const godot_plane)
2845 -> godot_bool;
2846}
2847extern "C" {
2848 pub fn godot_rect3_intersects_segment(p_self: *const godot_rect3,
2849 p_from: *const godot_vector3,
2850 p_to: *const godot_vector3)
2851 -> godot_bool;
2852}
2853extern "C" {
2854 pub fn godot_rect3_has_point(p_self: *const godot_rect3,
2855 p_point: *const godot_vector3) -> godot_bool;
2856}
2857extern "C" {
2858 pub fn godot_rect3_get_support(p_self: *const godot_rect3,
2859 p_dir: *const godot_vector3)
2860 -> godot_vector3;
2861}
2862extern "C" {
2863 pub fn godot_rect3_get_longest_axis(p_self: *const godot_rect3)
2864 -> godot_vector3;
2865}
2866extern "C" {
2867 pub fn godot_rect3_get_longest_axis_index(p_self: *const godot_rect3)
2868 -> godot_int;
2869}
2870extern "C" {
2871 pub fn godot_rect3_get_longest_axis_size(p_self: *const godot_rect3)
2872 -> godot_real;
2873}
2874extern "C" {
2875 pub fn godot_rect3_get_shortest_axis(p_self: *const godot_rect3)
2876 -> godot_vector3;
2877}
2878extern "C" {
2879 pub fn godot_rect3_get_shortest_axis_index(p_self: *const godot_rect3)
2880 -> godot_int;
2881}
2882extern "C" {
2883 pub fn godot_rect3_get_shortest_axis_size(p_self: *const godot_rect3)
2884 -> godot_real;
2885}
2886extern "C" {
2887 pub fn godot_rect3_expand(p_self: *const godot_rect3,
2888 p_to_point: *const godot_vector3)
2889 -> godot_rect3;
2890}
2891extern "C" {
2892 pub fn godot_rect3_grow(p_self: *const godot_rect3, p_by: godot_real)
2893 -> godot_rect3;
2894}
2895extern "C" {
2896 pub fn godot_rect3_get_endpoint(p_self: *const godot_rect3,
2897 p_idx: godot_int) -> godot_vector3;
2898}
2899extern "C" {
2900 pub fn godot_rect3_operator_equal(p_self: *const godot_rect3,
2901 p_b: *const godot_rect3) -> godot_bool;
2902}
2903#[repr(C)]
2904#[derive(Debug, Copy)]
2905pub struct godot_rid {
2906 pub _dont_touch_that: [u8; 8usize],
2907}
2908#[test]
2909fn bindgen_test_layout_godot_rid() {
2910 assert_eq!(::std::mem::size_of::<godot_rid>() , 8usize , concat ! (
2911 "Size of: " , stringify ! ( godot_rid ) ));
2912 assert_eq! (::std::mem::align_of::<godot_rid>() , 1usize , concat ! (
2913 "Alignment of " , stringify ! ( godot_rid ) ));
2914 assert_eq! (unsafe {
2915 & ( * ( 0 as * const godot_rid ) ) . _dont_touch_that as *
2916 const _ as usize } , 0usize , concat ! (
2917 "Alignment of field: " , stringify ! ( godot_rid ) , "::" ,
2918 stringify ! ( _dont_touch_that ) ));
2919}
2920impl Clone for godot_rid {
2921 fn clone(&self) -> Self { *self }
2922}
2923extern "C" {
2924 pub fn godot_rid_new(r_dest: *mut godot_rid);
2925}
2926extern "C" {
2927 pub fn godot_rid_get_id(p_self: *const godot_rid) -> godot_int;
2928}
2929extern "C" {
2930 pub fn godot_rid_new_with_resource(r_dest: *mut godot_rid,
2931 p_from: *const godot_object);
2932}
2933extern "C" {
2934 pub fn godot_rid_operator_equal(p_self: *const godot_rid,
2935 p_b: *const godot_rid) -> godot_bool;
2936}
2937extern "C" {
2938 pub fn godot_rid_operator_less(p_self: *const godot_rid,
2939 p_b: *const godot_rid) -> godot_bool;
2940}
2941#[repr(C)]
2942pub struct godot_transform {
2943 pub _dont_touch_that: [u8; 48usize],
2944}
2945#[test]
2946fn bindgen_test_layout_godot_transform() {
2947 assert_eq!(::std::mem::size_of::<godot_transform>() , 48usize , concat ! (
2948 "Size of: " , stringify ! ( godot_transform ) ));
2949 assert_eq! (::std::mem::align_of::<godot_transform>() , 1usize , concat !
2950 ( "Alignment of " , stringify ! ( godot_transform ) ));
2951 assert_eq! (unsafe {
2952 & ( * ( 0 as * const godot_transform ) ) . _dont_touch_that as
2953 * const _ as usize } , 0usize , concat ! (
2954 "Alignment of field: " , stringify ! ( godot_transform ) ,
2955 "::" , stringify ! ( _dont_touch_that ) ));
2956}
2957extern "C" {
2958 pub fn godot_transform_new_with_axis_origin(r_dest: *mut godot_transform,
2959 p_x_axis:
2960 *const godot_vector3,
2961 p_y_axis:
2962 *const godot_vector3,
2963 p_z_axis:
2964 *const godot_vector3,
2965 p_origin:
2966 *const godot_vector3);
2967}
2968extern "C" {
2969 pub fn godot_transform_new(r_dest: *mut godot_transform,
2970 p_basis: *const godot_basis,
2971 p_origin: *const godot_vector3);
2972}
2973extern "C" {
2974 pub fn godot_transform_get_basis(p_self: *const godot_transform)
2975 -> godot_basis;
2976}
2977extern "C" {
2978 pub fn godot_transform_set_basis(p_self: *mut godot_transform,
2979 p_v: *mut godot_basis);
2980}
2981extern "C" {
2982 pub fn godot_transform_get_origin(p_self: *const godot_transform)
2983 -> godot_vector3;
2984}
2985extern "C" {
2986 pub fn godot_transform_set_origin(p_self: *mut godot_transform,
2987 p_v: *mut godot_vector3);
2988}
2989extern "C" {
2990 pub fn godot_transform_as_string(p_self: *const godot_transform)
2991 -> godot_string;
2992}
2993extern "C" {
2994 pub fn godot_transform_inverse(p_self: *const godot_transform)
2995 -> godot_transform;
2996}
2997extern "C" {
2998 pub fn godot_transform_affine_inverse(p_self: *const godot_transform)
2999 -> godot_transform;
3000}
3001extern "C" {
3002 pub fn godot_transform_orthonormalized(p_self: *const godot_transform)
3003 -> godot_transform;
3004}
3005extern "C" {
3006 pub fn godot_transform_rotated(p_self: *const godot_transform,
3007 p_axis: *const godot_vector3,
3008 p_phi: godot_real) -> godot_transform;
3009}
3010extern "C" {
3011 pub fn godot_transform_scaled(p_self: *const godot_transform,
3012 p_scale: *const godot_vector3)
3013 -> godot_transform;
3014}
3015extern "C" {
3016 pub fn godot_transform_translated(p_self: *const godot_transform,
3017 p_ofs: *const godot_vector3)
3018 -> godot_transform;
3019}
3020extern "C" {
3021 pub fn godot_transform_looking_at(p_self: *const godot_transform,
3022 p_target: *const godot_vector3,
3023 p_up: *const godot_vector3)
3024 -> godot_transform;
3025}
3026extern "C" {
3027 pub fn godot_transform_xform_plane(p_self: *const godot_transform,
3028 p_v: *const godot_plane)
3029 -> godot_plane;
3030}
3031extern "C" {
3032 pub fn godot_transform_xform_inv_plane(p_self: *const godot_transform,
3033 p_v: *const godot_plane)
3034 -> godot_plane;
3035}
3036extern "C" {
3037 pub fn godot_transform_new_identity(r_dest: *mut godot_transform);
3038}
3039extern "C" {
3040 pub fn godot_transform_operator_equal(p_self: *const godot_transform,
3041 p_b: *const godot_transform)
3042 -> godot_bool;
3043}
3044extern "C" {
3045 pub fn godot_transform_operator_multiply(p_self: *const godot_transform,
3046 p_b: *const godot_transform)
3047 -> godot_transform;
3048}
3049extern "C" {
3050 pub fn godot_transform_xform_vector3(p_self: *const godot_transform,
3051 p_v: *const godot_vector3)
3052 -> godot_vector3;
3053}
3054extern "C" {
3055 pub fn godot_transform_xform_inv_vector3(p_self: *const godot_transform,
3056 p_v: *const godot_vector3)
3057 -> godot_vector3;
3058}
3059extern "C" {
3060 pub fn godot_transform_xform_rect3(p_self: *const godot_transform,
3061 p_v: *const godot_rect3)
3062 -> godot_rect3;
3063}
3064extern "C" {
3065 pub fn godot_transform_xform_inv_rect3(p_self: *const godot_transform,
3066 p_v: *const godot_rect3)
3067 -> godot_rect3;
3068}
3069extern "C" {
3070 pub fn godot_variant_get_type(p_v: *const godot_variant)
3071 -> godot_variant_type;
3072}
3073extern "C" {
3074 pub fn godot_variant_new_copy(r_dest: *mut godot_variant,
3075 p_src: *const godot_variant);
3076}
3077extern "C" {
3078 pub fn godot_variant_new_nil(r_dest: *mut godot_variant);
3079}
3080extern "C" {
3081 pub fn godot_variant_new_bool(p_v: *mut godot_variant, p_b: godot_bool);
3082}
3083extern "C" {
3084 pub fn godot_variant_new_uint(r_dest: *mut godot_variant, p_i: u64);
3085}
3086extern "C" {
3087 pub fn godot_variant_new_int(r_dest: *mut godot_variant, p_i: i64);
3088}
3089extern "C" {
3090 pub fn godot_variant_new_real(r_dest: *mut godot_variant, p_r: f64);
3091}
3092extern "C" {
3093 pub fn godot_variant_new_string(r_dest: *mut godot_variant,
3094 p_s: *const godot_string);
3095}
3096extern "C" {
3097 pub fn godot_variant_new_vector2(r_dest: *mut godot_variant,
3098 p_v2: *const godot_vector2);
3099}
3100extern "C" {
3101 pub fn godot_variant_new_rect2(r_dest: *mut godot_variant,
3102 p_rect2: *const godot_rect2);
3103}
3104extern "C" {
3105 pub fn godot_variant_new_vector3(r_dest: *mut godot_variant,
3106 p_v3: *const godot_vector3);
3107}
3108extern "C" {
3109 pub fn godot_variant_new_transform2d(r_dest: *mut godot_variant,
3110 p_t2d: *const godot_transform2d);
3111}
3112extern "C" {
3113 pub fn godot_variant_new_plane(r_dest: *mut godot_variant,
3114 p_plane: *const godot_plane);
3115}
3116extern "C" {
3117 pub fn godot_variant_new_quat(r_dest: *mut godot_variant,
3118 p_quat: *const godot_quat);
3119}
3120extern "C" {
3121 pub fn godot_variant_new_rect3(r_dest: *mut godot_variant,
3122 p_rect3: *const godot_rect3);
3123}
3124extern "C" {
3125 pub fn godot_variant_new_basis(r_dest: *mut godot_variant,
3126 p_basis: *const godot_basis);
3127}
3128extern "C" {
3129 pub fn godot_variant_new_transform(r_dest: *mut godot_variant,
3130 p_trans: *const godot_transform);
3131}
3132extern "C" {
3133 pub fn godot_variant_new_color(r_dest: *mut godot_variant,
3134 p_color: *const godot_color);
3135}
3136extern "C" {
3137 pub fn godot_variant_new_node_path(r_dest: *mut godot_variant,
3138 p_np: *const godot_node_path);
3139}
3140extern "C" {
3141 pub fn godot_variant_new_rid(r_dest: *mut godot_variant,
3142 p_rid: *const godot_rid);
3143}
3144extern "C" {
3145 pub fn godot_variant_new_object(r_dest: *mut godot_variant,
3146 p_obj: *const godot_object);
3147}
3148extern "C" {
3149 pub fn godot_variant_new_dictionary(r_dest: *mut godot_variant,
3150 p_dict: *const godot_dictionary);
3151}
3152extern "C" {
3153 pub fn godot_variant_new_array(r_dest: *mut godot_variant,
3154 p_arr: *const godot_array);
3155}
3156extern "C" {
3157 pub fn godot_variant_new_pool_byte_array(r_dest: *mut godot_variant,
3158 p_pba:
3159 *const godot_pool_byte_array);
3160}
3161extern "C" {
3162 pub fn godot_variant_new_pool_int_array(r_dest: *mut godot_variant,
3163 p_pia:
3164 *const godot_pool_int_array);
3165}
3166extern "C" {
3167 pub fn godot_variant_new_pool_real_array(r_dest: *mut godot_variant,
3168 p_pra:
3169 *const godot_pool_real_array);
3170}
3171extern "C" {
3172 pub fn godot_variant_new_pool_string_array(r_dest: *mut godot_variant,
3173 p_psa:
3174 *const godot_pool_string_array);
3175}
3176extern "C" {
3177 pub fn godot_variant_new_pool_vector2_array(r_dest: *mut godot_variant,
3178 p_pv2a:
3179 *const godot_pool_vector2_array);
3180}
3181extern "C" {
3182 pub fn godot_variant_new_pool_vector3_array(r_dest: *mut godot_variant,
3183 p_pv3a:
3184 *const godot_pool_vector3_array);
3185}
3186extern "C" {
3187 pub fn godot_variant_new_pool_color_array(r_dest: *mut godot_variant,
3188 p_pca:
3189 *const godot_pool_color_array);
3190}
3191extern "C" {
3192 pub fn godot_variant_as_bool(p_self: *const godot_variant) -> godot_bool;
3193}
3194extern "C" {
3195 pub fn godot_variant_as_uint(p_self: *const godot_variant) -> u64;
3196}
3197extern "C" {
3198 pub fn godot_variant_as_int(p_self: *const godot_variant) -> i64;
3199}
3200extern "C" {
3201 pub fn godot_variant_as_real(p_self: *const godot_variant) -> f64;
3202}
3203extern "C" {
3204 pub fn godot_variant_as_string(p_self: *const godot_variant)
3205 -> godot_string;
3206}
3207extern "C" {
3208 pub fn godot_variant_as_vector2(p_self: *const godot_variant)
3209 -> godot_vector2;
3210}
3211extern "C" {
3212 pub fn godot_variant_as_rect2(p_self: *const godot_variant)
3213 -> godot_rect2;
3214}
3215extern "C" {
3216 pub fn godot_variant_as_vector3(p_self: *const godot_variant)
3217 -> godot_vector3;
3218}
3219extern "C" {
3220 pub fn godot_variant_as_transform2d(p_self: *const godot_variant)
3221 -> godot_transform2d;
3222}
3223extern "C" {
3224 pub fn godot_variant_as_plane(p_self: *const godot_variant)
3225 -> godot_plane;
3226}
3227extern "C" {
3228 pub fn godot_variant_as_quat(p_self: *const godot_variant) -> godot_quat;
3229}
3230extern "C" {
3231 pub fn godot_variant_as_rect3(p_self: *const godot_variant)
3232 -> godot_rect3;
3233}
3234extern "C" {
3235 pub fn godot_variant_as_basis(p_self: *const godot_variant)
3236 -> godot_basis;
3237}
3238extern "C" {
3239 pub fn godot_variant_as_transform(p_self: *const godot_variant)
3240 -> godot_transform;
3241}
3242extern "C" {
3243 pub fn godot_variant_as_color(p_self: *const godot_variant)
3244 -> godot_color;
3245}
3246extern "C" {
3247 pub fn godot_variant_as_node_path(p_self: *const godot_variant)
3248 -> godot_node_path;
3249}
3250extern "C" {
3251 pub fn godot_variant_as_rid(p_self: *const godot_variant) -> godot_rid;
3252}
3253extern "C" {
3254 pub fn godot_variant_as_object(p_self: *const godot_variant)
3255 -> *mut godot_object;
3256}
3257extern "C" {
3258 pub fn godot_variant_as_dictionary(p_self: *const godot_variant)
3259 -> godot_dictionary;
3260}
3261extern "C" {
3262 pub fn godot_variant_as_array(p_self: *const godot_variant)
3263 -> godot_array;
3264}
3265extern "C" {
3266 pub fn godot_variant_as_pool_byte_array(p_self: *const godot_variant)
3267 -> godot_pool_byte_array;
3268}
3269extern "C" {
3270 pub fn godot_variant_as_pool_int_array(p_self: *const godot_variant)
3271 -> godot_pool_int_array;
3272}
3273extern "C" {
3274 pub fn godot_variant_as_pool_real_array(p_self: *const godot_variant)
3275 -> godot_pool_real_array;
3276}
3277extern "C" {
3278 pub fn godot_variant_as_pool_string_array(p_self: *const godot_variant)
3279 -> godot_pool_string_array;
3280}
3281extern "C" {
3282 pub fn godot_variant_as_pool_vector2_array(p_self: *const godot_variant)
3283 -> godot_pool_vector2_array;
3284}
3285extern "C" {
3286 pub fn godot_variant_as_pool_vector3_array(p_self: *const godot_variant)
3287 -> godot_pool_vector3_array;
3288}
3289extern "C" {
3290 pub fn godot_variant_as_pool_color_array(p_self: *const godot_variant)
3291 -> godot_pool_color_array;
3292}
3293extern "C" {
3294 pub fn godot_variant_call(p_self: *mut godot_variant,
3295 p_method: *const godot_string,
3296 p_args: *mut *const godot_variant,
3297 p_argcount: godot_int,
3298 r_error: *mut godot_variant_call_error)
3299 -> godot_variant;
3300}
3301extern "C" {
3302 pub fn godot_variant_has_method(p_self: *const godot_variant,
3303 p_method: *const godot_string)
3304 -> godot_bool;
3305}
3306extern "C" {
3307 pub fn godot_variant_operator_equal(p_self: *const godot_variant,
3308 p_other: *const godot_variant)
3309 -> godot_bool;
3310}
3311extern "C" {
3312 pub fn godot_variant_operator_less(p_self: *const godot_variant,
3313 p_other: *const godot_variant)
3314 -> godot_bool;
3315}
3316extern "C" {
3317 pub fn godot_variant_hash_compare(p_self: *const godot_variant,
3318 p_other: *const godot_variant)
3319 -> godot_bool;
3320}
3321extern "C" {
3322 pub fn godot_variant_booleanize(p_self: *const godot_variant,
3323 r_valid: *mut godot_bool) -> godot_bool;
3324}
3325extern "C" {
3326 pub fn godot_variant_destroy(p_self: *mut godot_variant);
3327}
3328extern "C" {
3329 pub fn godot_transform2d_new(r_dest: *mut godot_transform2d,
3330 p_rot: godot_real,
3331 p_pos: *const godot_vector2);
3332}
3333extern "C" {
3334 pub fn godot_transform2d_new_axis_origin(r_dest: *mut godot_transform2d,
3335 p_x_axis: *const godot_vector2,
3336 p_y_axis: *const godot_vector2,
3337 p_origin: *const godot_vector2);
3338}
3339extern "C" {
3340 pub fn godot_transform2d_as_string(p_self: *const godot_transform2d)
3341 -> godot_string;
3342}
3343extern "C" {
3344 pub fn godot_transform2d_inverse(p_self: *const godot_transform2d)
3345 -> godot_transform2d;
3346}
3347extern "C" {
3348 pub fn godot_transform2d_affine_inverse(p_self: *const godot_transform2d)
3349 -> godot_transform2d;
3350}
3351extern "C" {
3352 pub fn godot_transform2d_get_rotation(p_self: *const godot_transform2d)
3353 -> godot_real;
3354}
3355extern "C" {
3356 pub fn godot_transform2d_get_origin(p_self: *const godot_transform2d)
3357 -> godot_vector2;
3358}
3359extern "C" {
3360 pub fn godot_transform2d_get_scale(p_self: *const godot_transform2d)
3361 -> godot_vector2;
3362}
3363extern "C" {
3364 pub fn godot_transform2d_orthonormalized(p_self: *const godot_transform2d)
3365 -> godot_transform2d;
3366}
3367extern "C" {
3368 pub fn godot_transform2d_rotated(p_self: *const godot_transform2d,
3369 p_phi: godot_real) -> godot_transform2d;
3370}
3371extern "C" {
3372 pub fn godot_transform2d_scaled(p_self: *const godot_transform2d,
3373 p_scale: *const godot_vector2)
3374 -> godot_transform2d;
3375}
3376extern "C" {
3377 pub fn godot_transform2d_translated(p_self: *const godot_transform2d,
3378 p_offset: *const godot_vector2)
3379 -> godot_transform2d;
3380}
3381extern "C" {
3382 pub fn godot_transform2d_xform_vector2(p_self: *const godot_transform2d,
3383 p_v: *const godot_vector2)
3384 -> godot_vector2;
3385}
3386extern "C" {
3387 pub fn godot_transform2d_xform_inv_vector2(p_self:
3388 *const godot_transform2d,
3389 p_v: *const godot_vector2)
3390 -> godot_vector2;
3391}
3392extern "C" {
3393 pub fn godot_transform2d_basis_xform_vector2(p_self:
3394 *const godot_transform2d,
3395 p_v: *const godot_vector2)
3396 -> godot_vector2;
3397}
3398extern "C" {
3399 pub fn godot_transform2d_basis_xform_inv_vector2(p_self:
3400 *const godot_transform2d,
3401 p_v:
3402 *const godot_vector2)
3403 -> godot_vector2;
3404}
3405extern "C" {
3406 pub fn godot_transform2d_interpolate_with(p_self:
3407 *const godot_transform2d,
3408 p_m: *const godot_transform2d,
3409 p_c: godot_real)
3410 -> godot_transform2d;
3411}
3412extern "C" {
3413 pub fn godot_transform2d_operator_equal(p_self: *const godot_transform2d,
3414 p_b: *const godot_transform2d)
3415 -> godot_bool;
3416}
3417extern "C" {
3418 pub fn godot_transform2d_operator_multiply(p_self:
3419 *const godot_transform2d,
3420 p_b: *const godot_transform2d)
3421 -> godot_transform2d;
3422}
3423extern "C" {
3424 pub fn godot_transform2d_new_identity(r_dest: *mut godot_transform2d);
3425}
3426extern "C" {
3427 pub fn godot_transform2d_xform_rect2(p_self: *const godot_transform2d,
3428 p_v: *const godot_rect2)
3429 -> godot_rect2;
3430}
3431extern "C" {
3432 pub fn godot_transform2d_xform_inv_rect2(p_self: *const godot_transform2d,
3433 p_v: *const godot_rect2)
3434 -> godot_rect2;
3435}
3436extern "C" {
3437 pub fn godot_object_destroy(p_o: *mut godot_object);
3438}
3439extern "C" {
3440 pub fn godot_global_get_singleton(p_name: *mut ::std::os::raw::c_char)
3442 -> *mut godot_object;
3443}
3444#[repr(C)]
3446#[derive(Debug, Copy)]
3447pub struct godot_method_bind {
3448 pub _dont_touch_that: [u8; 1usize],
3449}
3450#[test]
3451fn bindgen_test_layout_godot_method_bind() {
3452 assert_eq!(::std::mem::size_of::<godot_method_bind>() , 1usize , concat !
3453 ( "Size of: " , stringify ! ( godot_method_bind ) ));
3454 assert_eq! (::std::mem::align_of::<godot_method_bind>() , 1usize , concat
3455 ! ( "Alignment of " , stringify ! ( godot_method_bind ) ));
3456 assert_eq! (unsafe {
3457 & ( * ( 0 as * const godot_method_bind ) ) . _dont_touch_that
3458 as * const _ as usize } , 0usize , concat ! (
3459 "Alignment of field: " , stringify ! ( godot_method_bind ) ,
3460 "::" , stringify ! ( _dont_touch_that ) ));
3461}
3462impl Clone for godot_method_bind {
3463 fn clone(&self) -> Self { *self }
3464}
3465extern "C" {
3466 pub fn godot_method_bind_get_method(p_classname:
3467 *const ::std::os::raw::c_char,
3468 p_methodname:
3469 *const ::std::os::raw::c_char)
3470 -> *mut godot_method_bind;
3471}
3472extern "C" {
3473 pub fn godot_method_bind_ptrcall(p_method_bind: *mut godot_method_bind,
3474 p_instance: *mut godot_object,
3475 p_args:
3476 *mut *const ::std::os::raw::c_void,
3477 p_ret: *mut ::std::os::raw::c_void);
3478}
3479extern "C" {
3480 pub fn godot_method_bind_call(p_method_bind: *mut godot_method_bind,
3481 p_instance: *mut godot_object,
3482 p_args: *mut *const godot_variant,
3483 p_arg_count: ::std::os::raw::c_int,
3484 p_call_error: *mut godot_variant_call_error)
3485 -> godot_variant;
3486}
3487#[repr(C)]
3489#[derive(Debug, Copy)]
3490pub struct godot_gdnative_init_options {
3491 pub in_editor: godot_bool,
3492 pub core_api_hash: u64,
3493 pub editor_api_hash: u64,
3494 pub no_api_hash: u64,
3495}
3496#[test]
3497fn bindgen_test_layout_godot_gdnative_init_options() {
3498 assert_eq!(::std::mem::size_of::<godot_gdnative_init_options>() , 32usize
3499 , concat ! (
3500 "Size of: " , stringify ! ( godot_gdnative_init_options ) ));
3501 assert_eq! (::std::mem::align_of::<godot_gdnative_init_options>() , 8usize
3502 , concat ! (
3503 "Alignment of " , stringify ! ( godot_gdnative_init_options )
3504 ));
3505 assert_eq! (unsafe {
3506 & ( * ( 0 as * const godot_gdnative_init_options ) ) .
3507 in_editor as * const _ as usize } , 0usize , concat ! (
3508 "Alignment of field: " , stringify ! (
3509 godot_gdnative_init_options ) , "::" , stringify ! ( in_editor
3510 ) ));
3511 assert_eq! (unsafe {
3512 & ( * ( 0 as * const godot_gdnative_init_options ) ) .
3513 core_api_hash as * const _ as usize } , 8usize , concat ! (
3514 "Alignment of field: " , stringify ! (
3515 godot_gdnative_init_options ) , "::" , stringify ! (
3516 core_api_hash ) ));
3517 assert_eq! (unsafe {
3518 & ( * ( 0 as * const godot_gdnative_init_options ) ) .
3519 editor_api_hash as * const _ as usize } , 16usize , concat ! (
3520 "Alignment of field: " , stringify ! (
3521 godot_gdnative_init_options ) , "::" , stringify ! (
3522 editor_api_hash ) ));
3523 assert_eq! (unsafe {
3524 & ( * ( 0 as * const godot_gdnative_init_options ) ) .
3525 no_api_hash as * const _ as usize } , 24usize , concat ! (
3526 "Alignment of field: " , stringify ! (
3527 godot_gdnative_init_options ) , "::" , stringify ! (
3528 no_api_hash ) ));
3529}
3530impl Clone for godot_gdnative_init_options {
3531 fn clone(&self) -> Self { *self }
3532}
3533#[repr(C)]
3534#[derive(Debug, Copy)]
3535pub struct godot_gdnative_terminate_options {
3536 pub in_editor: godot_bool,
3537}
3538#[test]
3539fn bindgen_test_layout_godot_gdnative_terminate_options() {
3540 assert_eq!(::std::mem::size_of::<godot_gdnative_terminate_options>() ,
3541 1usize , concat ! (
3542 "Size of: " , stringify ! ( godot_gdnative_terminate_options )
3543 ));
3544 assert_eq! (::std::mem::align_of::<godot_gdnative_terminate_options>() ,
3545 1usize , concat ! (
3546 "Alignment of " , stringify ! (
3547 godot_gdnative_terminate_options ) ));
3548 assert_eq! (unsafe {
3549 & ( * ( 0 as * const godot_gdnative_terminate_options ) ) .
3550 in_editor as * const _ as usize } , 0usize , concat ! (
3551 "Alignment of field: " , stringify ! (
3552 godot_gdnative_terminate_options ) , "::" , stringify ! (
3553 in_editor ) ));
3554}
3555impl Clone for godot_gdnative_terminate_options {
3556 fn clone(&self) -> Self { *self }
3557}
3558pub type godot_class_constructor =
3559::std::option::Option<unsafe extern "C" fn() -> *mut godot_object>;
3560extern "C" {
3561 pub fn godot_get_class_constructor(p_classname:
3562 *const ::std::os::raw::c_char)
3563 -> godot_class_constructor;
3564}
3565extern "C" {
3566 pub fn godot_get_global_constants() -> godot_dictionary;
3567}
3568pub type godot_gdnative_init_fn =
3570::std::option::Option<unsafe extern "C" fn(arg1:
3571 *mut godot_gdnative_init_options)>;
3572pub type godot_gdnative_terminate_fn =
3573::std::option::Option<unsafe extern "C" fn(arg1:
3574 *mut godot_gdnative_terminate_options)>;
3575pub type godot_gdnative_procedure_fn =
3576::std::option::Option<unsafe extern "C" fn(arg1:
3577 *mut ::std::os::raw::c_void,
3578 arg2: *mut godot_array)
3579 -> godot_variant>;
3580extern "C" {
3581 pub fn godot_alloc(p_bytes: ::std::os::raw::c_int)
3583 -> *mut ::std::os::raw::c_void;
3584}
3585extern "C" {
3586 pub fn godot_realloc(p_ptr: *mut ::std::os::raw::c_void,
3587 p_bytes: ::std::os::raw::c_int)
3588 -> *mut ::std::os::raw::c_void;
3589}
3590extern "C" {
3591 pub fn godot_free(p_ptr: *mut ::std::os::raw::c_void);
3592}
3593extern "C" {
3594 pub fn godot_print_error(p_description: *const ::std::os::raw::c_char,
3595 p_function: *const ::std::os::raw::c_char,
3596 p_file: *const ::std::os::raw::c_char,
3597 p_line: ::std::os::raw::c_int);
3598}
3599extern "C" {
3600 pub fn godot_print_warning(p_description: *const ::std::os::raw::c_char,
3601 p_function: *const ::std::os::raw::c_char,
3602 p_file: *const ::std::os::raw::c_char,
3603 p_line: ::std::os::raw::c_int);
3604}
3605extern "C" {
3606 pub fn godot_print(p_message: *const godot_string);
3607}
3608#[repr(u32)]
3609#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
3610pub enum godot_method_rpc_mode {
3611 GODOT_METHOD_RPC_MODE_DISABLED = 0,
3612 GODOT_METHOD_RPC_MODE_REMOTE = 1,
3613 GODOT_METHOD_RPC_MODE_SYNC = 2,
3614 GODOT_METHOD_RPC_MODE_MASTER = 3,
3615 GODOT_METHOD_RPC_MODE_SLAVE = 4,
3616}
3617#[repr(u32)]
3618#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
3619pub enum godot_property_hint {
3620 GODOT_PROPERTY_HINT_NONE = 0,
3621 GODOT_PROPERTY_HINT_RANGE = 1,
3622 GODOT_PROPERTY_HINT_EXP_RANGE = 2,
3623 GODOT_PROPERTY_HINT_ENUM = 3,
3624 GODOT_PROPERTY_HINT_EXP_EASING = 4,
3625 GODOT_PROPERTY_HINT_LENGTH = 5,
3626 GODOT_PROPERTY_HINT_SPRITE_FRAME = 6,
3627 GODOT_PROPERTY_HINT_KEY_ACCEL = 7,
3628 GODOT_PROPERTY_HINT_FLAGS = 8,
3629 GODOT_PROPERTY_HINT_LAYERS_2D_RENDER = 9,
3630 GODOT_PROPERTY_HINT_LAYERS_2D_PHYSICS = 10,
3631 GODOT_PROPERTY_HINT_LAYERS_3D_RENDER = 11,
3632 GODOT_PROPERTY_HINT_LAYERS_3D_PHYSICS = 12,
3633 GODOT_PROPERTY_HINT_FILE = 13,
3634 GODOT_PROPERTY_HINT_DIR = 14,
3635 GODOT_PROPERTY_HINT_GLOBAL_FILE = 15,
3636 GODOT_PROPERTY_HINT_GLOBAL_DIR = 16,
3637 GODOT_PROPERTY_HINT_RESOURCE_TYPE = 17,
3638 GODOT_PROPERTY_HINT_MULTILINE_TEXT = 18,
3639 GODOT_PROPERTY_HINT_COLOR_NO_ALPHA = 19,
3640 GODOT_PROPERTY_HINT_IMAGE_COMPRESS_LOSSY = 20,
3641 GODOT_PROPERTY_HINT_IMAGE_COMPRESS_LOSSLESS = 21,
3642 GODOT_PROPERTY_HINT_OBJECT_ID = 22,
3643 GODOT_PROPERTY_HINT_TYPE_STRING = 23,
3644 GODOT_PROPERTY_HINT_NODE_PATH_TO_EDITED_NODE = 24,
3645 GODOT_PROPERTY_HINT_METHOD_OF_VARIANT_TYPE = 25,
3646 GODOT_PROPERTY_HINT_METHOD_OF_BASE_TYPE = 26,
3647 GODOT_PROPERTY_HINT_METHOD_OF_INSTANCE = 27,
3648 GODOT_PROPERTY_HINT_METHOD_OF_SCRIPT = 28,
3649 GODOT_PROPERTY_HINT_PROPERTY_OF_VARIANT_TYPE = 29,
3650 GODOT_PROPERTY_HINT_PROPERTY_OF_BASE_TYPE = 30,
3651 GODOT_PROPERTY_HINT_PROPERTY_OF_INSTANCE = 31,
3652 GODOT_PROPERTY_HINT_PROPERTY_OF_SCRIPT = 32,
3653 GODOT_PROPERTY_HINT_MAX = 33,
3654}
3655#[repr(u32)]
3656#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
3657pub enum godot_property_usage_flags {
3658 GODOT_PROPERTY_USAGE_STORAGE = 1,
3659 GODOT_PROPERTY_USAGE_EDITOR = 2,
3660 GODOT_PROPERTY_USAGE_NETWORK = 4,
3661 GODOT_PROPERTY_USAGE_EDITOR_HELPER = 8,
3662 GODOT_PROPERTY_USAGE_CHECKABLE = 16,
3663 GODOT_PROPERTY_USAGE_CHECKED = 32,
3664 GODOT_PROPERTY_USAGE_INTERNATIONALIZED = 64,
3665 GODOT_PROPERTY_USAGE_GROUP = 128,
3666 GODOT_PROPERTY_USAGE_CATEGORY = 256,
3667 GODOT_PROPERTY_USAGE_STORE_IF_NONZERO = 512,
3668 GODOT_PROPERTY_USAGE_STORE_IF_NONONE = 1024,
3669 GODOT_PROPERTY_USAGE_NO_INSTANCE_STATE = 2048,
3670 GODOT_PROPERTY_USAGE_RESTART_IF_CHANGED = 4096,
3671 GODOT_PROPERTY_USAGE_SCRIPT_VARIABLE = 8192,
3672 GODOT_PROPERTY_USAGE_STORE_IF_NULL = 16384,
3673 GODOT_PROPERTY_USAGE_ANIMATE_AS_TRIGGER = 32768,
3674 GODOT_PROPERTY_USAGE_UPDATE_ALL_IF_MODIFIED = 65536,
3675 GODOT_PROPERTY_USAGE_DEFAULT = 7,
3676 GODOT_PROPERTY_USAGE_DEFAULT_INTL = 71,
3677 GODOT_PROPERTY_USAGE_NOEDITOR = 5,
3678}
3679#[repr(C)]
3680#[derive(Debug, Copy)]
3681pub struct godot_property_attributes {
3682 pub rset_type: godot_method_rpc_mode,
3683 pub type_: godot_int,
3684 pub hint: godot_property_hint,
3685 pub hint_string: godot_string,
3686 pub usage: godot_property_usage_flags,
3687 pub default_value: godot_variant,
3688}
3689#[test]
3690fn bindgen_test_layout_godot_property_attributes() {
3691 assert_eq!(::std::mem::size_of::<godot_property_attributes>() , 48usize ,
3692 concat ! (
3693 "Size of: " , stringify ! ( godot_property_attributes ) ));
3694 assert_eq! (::std::mem::align_of::<godot_property_attributes>() , 4usize ,
3695 concat ! (
3696 "Alignment of " , stringify ! ( godot_property_attributes )
3697 ));
3698 assert_eq! (unsafe {
3699 & ( * ( 0 as * const godot_property_attributes ) ) . rset_type
3700 as * const _ as usize } , 0usize , concat ! (
3701 "Alignment of field: " , stringify ! (
3702 godot_property_attributes ) , "::" , stringify ! ( rset_type )
3703 ));
3704 assert_eq! (unsafe {
3705 & ( * ( 0 as * const godot_property_attributes ) ) . type_ as
3706 * const _ as usize } , 4usize , concat ! (
3707 "Alignment of field: " , stringify ! (
3708 godot_property_attributes ) , "::" , stringify ! ( type_ ) ));
3709 assert_eq! (unsafe {
3710 & ( * ( 0 as * const godot_property_attributes ) ) . hint as *
3711 const _ as usize } , 8usize , concat ! (
3712 "Alignment of field: " , stringify ! (
3713 godot_property_attributes ) , "::" , stringify ! ( hint ) ));
3714 assert_eq! (unsafe {
3715 & ( * ( 0 as * const godot_property_attributes ) ) .
3716 hint_string as * const _ as usize } , 12usize , concat ! (
3717 "Alignment of field: " , stringify ! (
3718 godot_property_attributes ) , "::" , stringify ! ( hint_string
3719 ) ));
3720 assert_eq! (unsafe {
3721 & ( * ( 0 as * const godot_property_attributes ) ) . usage as
3722 * const _ as usize } , 20usize , concat ! (
3723 "Alignment of field: " , stringify ! (
3724 godot_property_attributes ) , "::" , stringify ! ( usage ) ));
3725 assert_eq! (unsafe {
3726 & ( * ( 0 as * const godot_property_attributes ) ) .
3727 default_value as * const _ as usize } , 24usize , concat ! (
3728 "Alignment of field: " , stringify ! (
3729 godot_property_attributes ) , "::" , stringify ! (
3730 default_value ) ));
3731}
3732impl Clone for godot_property_attributes {
3733 fn clone(&self) -> Self { *self }
3734}
3735#[repr(C)]
3736#[derive(Debug, Copy)]
3737pub struct godot_instance_create_func {
3738 pub create_func: ::std::option::Option<unsafe extern "C" fn(arg1:
3739 *mut godot_object,
3740 arg2:
3741 *mut ::std::os::raw::c_void)
3742 ->
3743 *mut ::std::os::raw::c_void>,
3744 pub method_data: *mut ::std::os::raw::c_void,
3745 pub free_func: ::std::option::Option<unsafe extern "C" fn(arg1:
3746 *mut ::std::os::raw::c_void)>,
3747}
3748#[test]
3749fn bindgen_test_layout_godot_instance_create_func() {
3750 assert_eq!(::std::mem::size_of::<godot_instance_create_func>() , 24usize ,
3751 concat ! (
3752 "Size of: " , stringify ! ( godot_instance_create_func ) ));
3753 assert_eq! (::std::mem::align_of::<godot_instance_create_func>() , 8usize
3754 , concat ! (
3755 "Alignment of " , stringify ! ( godot_instance_create_func )
3756 ));
3757 assert_eq! (unsafe {
3758 & ( * ( 0 as * const godot_instance_create_func ) ) .
3759 create_func as * const _ as usize } , 0usize , concat ! (
3760 "Alignment of field: " , stringify ! (
3761 godot_instance_create_func ) , "::" , stringify ! (
3762 create_func ) ));
3763 assert_eq! (unsafe {
3764 & ( * ( 0 as * const godot_instance_create_func ) ) .
3765 method_data as * const _ as usize } , 8usize , concat ! (
3766 "Alignment of field: " , stringify ! (
3767 godot_instance_create_func ) , "::" , stringify ! (
3768 method_data ) ));
3769 assert_eq! (unsafe {
3770 & ( * ( 0 as * const godot_instance_create_func ) ) .
3771 free_func as * const _ as usize } , 16usize , concat ! (
3772 "Alignment of field: " , stringify ! (
3773 godot_instance_create_func ) , "::" , stringify ! ( free_func
3774 ) ));
3775}
3776impl Clone for godot_instance_create_func {
3777 fn clone(&self) -> Self { *self }
3778}
3779#[repr(C)]
3780#[derive(Debug, Copy)]
3781pub struct godot_instance_destroy_func {
3782 pub destroy_func: ::std::option::Option<unsafe extern "C" fn(arg1:
3783 *mut godot_object,
3784 arg2:
3785 *mut ::std::os::raw::c_void,
3786 arg3:
3787 *mut ::std::os::raw::c_void)>,
3788 pub method_data: *mut ::std::os::raw::c_void,
3789 pub free_func: ::std::option::Option<unsafe extern "C" fn(arg1:
3790 *mut ::std::os::raw::c_void)>,
3791}
3792#[test]
3793fn bindgen_test_layout_godot_instance_destroy_func() {
3794 assert_eq!(::std::mem::size_of::<godot_instance_destroy_func>() , 24usize
3795 , concat ! (
3796 "Size of: " , stringify ! ( godot_instance_destroy_func ) ));
3797 assert_eq! (::std::mem::align_of::<godot_instance_destroy_func>() , 8usize
3798 , concat ! (
3799 "Alignment of " , stringify ! ( godot_instance_destroy_func )
3800 ));
3801 assert_eq! (unsafe {
3802 & ( * ( 0 as * const godot_instance_destroy_func ) ) .
3803 destroy_func as * const _ as usize } , 0usize , concat ! (
3804 "Alignment of field: " , stringify ! (
3805 godot_instance_destroy_func ) , "::" , stringify ! (
3806 destroy_func ) ));
3807 assert_eq! (unsafe {
3808 & ( * ( 0 as * const godot_instance_destroy_func ) ) .
3809 method_data as * const _ as usize } , 8usize , concat ! (
3810 "Alignment of field: " , stringify ! (
3811 godot_instance_destroy_func ) , "::" , stringify ! (
3812 method_data ) ));
3813 assert_eq! (unsafe {
3814 & ( * ( 0 as * const godot_instance_destroy_func ) ) .
3815 free_func as * const _ as usize } , 16usize , concat ! (
3816 "Alignment of field: " , stringify ! (
3817 godot_instance_destroy_func ) , "::" , stringify ! ( free_func
3818 ) ));
3819}
3820impl Clone for godot_instance_destroy_func {
3821 fn clone(&self) -> Self { *self }
3822}
3823extern "C" {
3824 pub fn godot_nativescript_register_class(p_gdnative_handle:
3825 *mut ::std::os::raw::c_void,
3826 p_name:
3827 *const ::std::os::raw::c_char,
3828 p_base:
3829 *const ::std::os::raw::c_char,
3830 p_create_func:
3831 godot_instance_create_func,
3832 p_destroy_func:
3833 godot_instance_destroy_func);
3834}
3835extern "C" {
3836 pub fn godot_nativescript_register_tool_class(p_gdnative_handle:
3837 *mut ::std::os::raw::c_void,
3838 p_name:
3839 *const ::std::os::raw::c_char,
3840 p_base:
3841 *const ::std::os::raw::c_char,
3842 p_create_func:
3843 godot_instance_create_func,
3844 p_destroy_func:
3845 godot_instance_destroy_func);
3846}
3847#[repr(C)]
3848#[derive(Debug, Copy)]
3849pub struct godot_method_attributes {
3850 pub rpc_type: godot_method_rpc_mode,
3851}
3852#[test]
3853fn bindgen_test_layout_godot_method_attributes() {
3854 assert_eq!(::std::mem::size_of::<godot_method_attributes>() , 4usize ,
3855 concat ! (
3856 "Size of: " , stringify ! ( godot_method_attributes ) ));
3857 assert_eq! (::std::mem::align_of::<godot_method_attributes>() , 4usize ,
3858 concat ! (
3859 "Alignment of " , stringify ! ( godot_method_attributes ) ));
3860 assert_eq! (unsafe {
3861 & ( * ( 0 as * const godot_method_attributes ) ) . rpc_type as
3862 * const _ as usize } , 0usize , concat ! (
3863 "Alignment of field: " , stringify ! ( godot_method_attributes
3864 ) , "::" , stringify ! ( rpc_type ) ));
3865}
3866impl Clone for godot_method_attributes {
3867 fn clone(&self) -> Self { *self }
3868}
3869#[repr(C)]
3870#[derive(Debug, Copy)]
3871pub struct godot_instance_method {
3872 pub method: ::std::option::Option<unsafe extern "C" fn(arg1:
3873 *mut godot_object,
3874 arg2:
3875 *mut ::std::os::raw::c_void,
3876 arg3:
3877 *mut ::std::os::raw::c_void,
3878 arg4:
3879 ::std::os::raw::c_int,
3880 arg5:
3881 *mut *mut godot_variant)
3882 -> godot_variant>,
3883 pub method_data: *mut ::std::os::raw::c_void,
3884 pub free_func: ::std::option::Option<unsafe extern "C" fn(arg1:
3885 *mut ::std::os::raw::c_void)>,
3886}
3887#[test]
3888fn bindgen_test_layout_godot_instance_method() {
3889 assert_eq!(::std::mem::size_of::<godot_instance_method>() , 24usize ,
3890 concat ! ( "Size of: " , stringify ! ( godot_instance_method )
3891 ));
3892 assert_eq! (::std::mem::align_of::<godot_instance_method>() , 8usize ,
3893 concat ! (
3894 "Alignment of " , stringify ! ( godot_instance_method ) ));
3895 assert_eq! (unsafe {
3896 & ( * ( 0 as * const godot_instance_method ) ) . method as *
3897 const _ as usize } , 0usize , concat ! (
3898 "Alignment of field: " , stringify ! ( godot_instance_method )
3899 , "::" , stringify ! ( method ) ));
3900 assert_eq! (unsafe {
3901 & ( * ( 0 as * const godot_instance_method ) ) . method_data
3902 as * const _ as usize } , 8usize , concat ! (
3903 "Alignment of field: " , stringify ! ( godot_instance_method )
3904 , "::" , stringify ! ( method_data ) ));
3905 assert_eq! (unsafe {
3906 & ( * ( 0 as * const godot_instance_method ) ) . free_func as
3907 * const _ as usize } , 16usize , concat ! (
3908 "Alignment of field: " , stringify ! ( godot_instance_method )
3909 , "::" , stringify ! ( free_func ) ));
3910}
3911impl Clone for godot_instance_method {
3912 fn clone(&self) -> Self { *self }
3913}
3914extern "C" {
3915 pub fn godot_nativescript_register_method(p_gdnative_handle:
3916 *mut ::std::os::raw::c_void,
3917 p_name:
3918 *const ::std::os::raw::c_char,
3919 p_function_name:
3920 *const ::std::os::raw::c_char,
3921 p_attr: godot_method_attributes,
3922 p_method:
3923 godot_instance_method);
3924}
3925#[repr(C)]
3926#[derive(Debug, Copy)]
3927pub struct godot_property_set_func {
3928 pub set_func: ::std::option::Option<unsafe extern "C" fn(arg1:
3929 *mut godot_object,
3930 arg2:
3931 *mut ::std::os::raw::c_void,
3932 arg3:
3933 *mut ::std::os::raw::c_void,
3934 arg4:
3935 *mut godot_variant)>,
3936 pub method_data: *mut ::std::os::raw::c_void,
3937 pub free_func: ::std::option::Option<unsafe extern "C" fn(arg1:
3938 *mut ::std::os::raw::c_void)>,
3939}
3940#[test]
3941fn bindgen_test_layout_godot_property_set_func() {
3942 assert_eq!(::std::mem::size_of::<godot_property_set_func>() , 24usize ,
3943 concat ! (
3944 "Size of: " , stringify ! ( godot_property_set_func ) ));
3945 assert_eq! (::std::mem::align_of::<godot_property_set_func>() , 8usize ,
3946 concat ! (
3947 "Alignment of " , stringify ! ( godot_property_set_func ) ));
3948 assert_eq! (unsafe {
3949 & ( * ( 0 as * const godot_property_set_func ) ) . set_func as
3950 * const _ as usize } , 0usize , concat ! (
3951 "Alignment of field: " , stringify ! ( godot_property_set_func
3952 ) , "::" , stringify ! ( set_func ) ));
3953 assert_eq! (unsafe {
3954 & ( * ( 0 as * const godot_property_set_func ) ) . method_data
3955 as * const _ as usize } , 8usize , concat ! (
3956 "Alignment of field: " , stringify ! ( godot_property_set_func
3957 ) , "::" , stringify ! ( method_data ) ));
3958 assert_eq! (unsafe {
3959 & ( * ( 0 as * const godot_property_set_func ) ) . free_func
3960 as * const _ as usize } , 16usize , concat ! (
3961 "Alignment of field: " , stringify ! ( godot_property_set_func
3962 ) , "::" , stringify ! ( free_func ) ));
3963}
3964impl Clone for godot_property_set_func {
3965 fn clone(&self) -> Self { *self }
3966}
3967#[repr(C)]
3968#[derive(Debug, Copy)]
3969pub struct godot_property_get_func {
3970 pub get_func: ::std::option::Option<unsafe extern "C" fn(arg1:
3971 *mut godot_object,
3972 arg2:
3973 *mut ::std::os::raw::c_void,
3974 arg3:
3975 *mut ::std::os::raw::c_void)
3976 -> godot_variant>,
3977 pub method_data: *mut ::std::os::raw::c_void,
3978 pub free_func: ::std::option::Option<unsafe extern "C" fn(arg1:
3979 *mut ::std::os::raw::c_void)>,
3980}
3981#[test]
3982fn bindgen_test_layout_godot_property_get_func() {
3983 assert_eq!(::std::mem::size_of::<godot_property_get_func>() , 24usize ,
3984 concat ! (
3985 "Size of: " , stringify ! ( godot_property_get_func ) ));
3986 assert_eq! (::std::mem::align_of::<godot_property_get_func>() , 8usize ,
3987 concat ! (
3988 "Alignment of " , stringify ! ( godot_property_get_func ) ));
3989 assert_eq! (unsafe {
3990 & ( * ( 0 as * const godot_property_get_func ) ) . get_func as
3991 * const _ as usize } , 0usize , concat ! (
3992 "Alignment of field: " , stringify ! ( godot_property_get_func
3993 ) , "::" , stringify ! ( get_func ) ));
3994 assert_eq! (unsafe {
3995 & ( * ( 0 as * const godot_property_get_func ) ) . method_data
3996 as * const _ as usize } , 8usize , concat ! (
3997 "Alignment of field: " , stringify ! ( godot_property_get_func
3998 ) , "::" , stringify ! ( method_data ) ));
3999 assert_eq! (unsafe {
4000 & ( * ( 0 as * const godot_property_get_func ) ) . free_func
4001 as * const _ as usize } , 16usize , concat ! (
4002 "Alignment of field: " , stringify ! ( godot_property_get_func
4003 ) , "::" , stringify ! ( free_func ) ));
4004}
4005impl Clone for godot_property_get_func {
4006 fn clone(&self) -> Self { *self }
4007}
4008extern "C" {
4009 pub fn godot_nativescript_register_property(p_gdnative_handle:
4010 *mut ::std::os::raw::c_void,
4011 p_name:
4012 *const ::std::os::raw::c_char,
4013 p_path:
4014 *const ::std::os::raw::c_char,
4015 p_attr:
4016 *mut godot_property_attributes,
4017 p_set_func:
4018 godot_property_set_func,
4019 p_get_func:
4020 godot_property_get_func);
4021}
4022#[repr(C)]
4023#[derive(Debug, Copy)]
4024pub struct godot_signal_argument {
4025 pub name: godot_string,
4026 pub type_: godot_int,
4027 pub hint: godot_property_hint,
4028 pub hint_string: godot_string,
4029 pub usage: godot_property_usage_flags,
4030 pub default_value: godot_variant,
4031}
4032#[test]
4033fn bindgen_test_layout_godot_signal_argument() {
4034 assert_eq!(::std::mem::size_of::<godot_signal_argument>() , 52usize ,
4035 concat ! ( "Size of: " , stringify ! ( godot_signal_argument )
4036 ));
4037 assert_eq! (::std::mem::align_of::<godot_signal_argument>() , 4usize ,
4038 concat ! (
4039 "Alignment of " , stringify ! ( godot_signal_argument ) ));
4040 assert_eq! (unsafe {
4041 & ( * ( 0 as * const godot_signal_argument ) ) . name as *
4042 const _ as usize } , 0usize , concat ! (
4043 "Alignment of field: " , stringify ! ( godot_signal_argument )
4044 , "::" , stringify ! ( name ) ));
4045 assert_eq! (unsafe {
4046 & ( * ( 0 as * const godot_signal_argument ) ) . type_ as *
4047 const _ as usize } , 8usize , concat ! (
4048 "Alignment of field: " , stringify ! ( godot_signal_argument )
4049 , "::" , stringify ! ( type_ ) ));
4050 assert_eq! (unsafe {
4051 & ( * ( 0 as * const godot_signal_argument ) ) . hint as *
4052 const _ as usize } , 12usize , concat ! (
4053 "Alignment of field: " , stringify ! ( godot_signal_argument )
4054 , "::" , stringify ! ( hint ) ));
4055 assert_eq! (unsafe {
4056 & ( * ( 0 as * const godot_signal_argument ) ) . hint_string
4057 as * const _ as usize } , 16usize , concat ! (
4058 "Alignment of field: " , stringify ! ( godot_signal_argument )
4059 , "::" , stringify ! ( hint_string ) ));
4060 assert_eq! (unsafe {
4061 & ( * ( 0 as * const godot_signal_argument ) ) . usage as *
4062 const _ as usize } , 24usize , concat ! (
4063 "Alignment of field: " , stringify ! ( godot_signal_argument )
4064 , "::" , stringify ! ( usage ) ));
4065 assert_eq! (unsafe {
4066 & ( * ( 0 as * const godot_signal_argument ) ) . default_value
4067 as * const _ as usize } , 28usize , concat ! (
4068 "Alignment of field: " , stringify ! ( godot_signal_argument )
4069 , "::" , stringify ! ( default_value ) ));
4070}
4071impl Clone for godot_signal_argument {
4072 fn clone(&self) -> Self { *self }
4073}
4074#[repr(C)]
4075#[derive(Debug, Copy)]
4076pub struct godot_signal {
4077 pub name: godot_string,
4078 pub num_args: ::std::os::raw::c_int,
4079 pub args: *mut godot_signal_argument,
4080 pub num_default_args: ::std::os::raw::c_int,
4081 pub default_args: *mut godot_variant,
4082}
4083#[test]
4084fn bindgen_test_layout_godot_signal() {
4085 assert_eq!(::std::mem::size_of::<godot_signal>() , 40usize , concat ! (
4086 "Size of: " , stringify ! ( godot_signal ) ));
4087 assert_eq! (::std::mem::align_of::<godot_signal>() , 8usize , concat ! (
4088 "Alignment of " , stringify ! ( godot_signal ) ));
4089 assert_eq! (unsafe {
4090 & ( * ( 0 as * const godot_signal ) ) . name as * const _ as
4091 usize } , 0usize , concat ! (
4092 "Alignment of field: " , stringify ! ( godot_signal ) , "::" ,
4093 stringify ! ( name ) ));
4094 assert_eq! (unsafe {
4095 & ( * ( 0 as * const godot_signal ) ) . num_args as * const _
4096 as usize } , 8usize , concat ! (
4097 "Alignment of field: " , stringify ! ( godot_signal ) , "::" ,
4098 stringify ! ( num_args ) ));
4099 assert_eq! (unsafe {
4100 & ( * ( 0 as * const godot_signal ) ) . args as * const _ as
4101 usize } , 16usize , concat ! (
4102 "Alignment of field: " , stringify ! ( godot_signal ) , "::" ,
4103 stringify ! ( args ) ));
4104 assert_eq! (unsafe {
4105 & ( * ( 0 as * const godot_signal ) ) . num_default_args as *
4106 const _ as usize } , 24usize , concat ! (
4107 "Alignment of field: " , stringify ! ( godot_signal ) , "::" ,
4108 stringify ! ( num_default_args ) ));
4109 assert_eq! (unsafe {
4110 & ( * ( 0 as * const godot_signal ) ) . default_args as *
4111 const _ as usize } , 32usize , concat ! (
4112 "Alignment of field: " , stringify ! ( godot_signal ) , "::" ,
4113 stringify ! ( default_args ) ));
4114}
4115impl Clone for godot_signal {
4116 fn clone(&self) -> Self { *self }
4117}
4118extern "C" {
4119 pub fn godot_nativescript_register_signal(p_gdnative_handle:
4120 *mut ::std::os::raw::c_void,
4121 p_name:
4122 *const ::std::os::raw::c_char,
4123 p_signal: *const godot_signal);
4124}
4125extern "C" {
4126 pub fn godot_nativescript_get_userdata(p_instance: *mut godot_object)
4127 -> *mut ::std::os::raw::c_void;
4128}
4129#[repr(C)]
4130#[derive(Debug, Copy)]
4131pub struct __va_list_tag {
4132 pub gp_offset: ::std::os::raw::c_uint,
4133 pub fp_offset: ::std::os::raw::c_uint,
4134 pub overflow_arg_area: *mut ::std::os::raw::c_void,
4135 pub reg_save_area: *mut ::std::os::raw::c_void,
4136}
4137#[test]
4138fn bindgen_test_layout___va_list_tag() {
4139 assert_eq!(::std::mem::size_of::<__va_list_tag>() , 24usize , concat ! (
4140 "Size of: " , stringify ! ( __va_list_tag ) ));
4141 assert_eq! (::std::mem::align_of::<__va_list_tag>() , 8usize , concat ! (
4142 "Alignment of " , stringify ! ( __va_list_tag ) ));
4143 assert_eq! (unsafe {
4144 & ( * ( 0 as * const __va_list_tag ) ) . gp_offset as * const
4145 _ as usize } , 0usize , concat ! (
4146 "Alignment of field: " , stringify ! ( __va_list_tag ) , "::"
4147 , stringify ! ( gp_offset ) ));
4148 assert_eq! (unsafe {
4149 & ( * ( 0 as * const __va_list_tag ) ) . fp_offset as * const
4150 _ as usize } , 4usize , concat ! (
4151 "Alignment of field: " , stringify ! ( __va_list_tag ) , "::"
4152 , stringify ! ( fp_offset ) ));
4153 assert_eq! (unsafe {
4154 & ( * ( 0 as * const __va_list_tag ) ) . overflow_arg_area as
4155 * const _ as usize } , 8usize , concat ! (
4156 "Alignment of field: " , stringify ! ( __va_list_tag ) , "::"
4157 , stringify ! ( overflow_arg_area ) ));
4158 assert_eq! (unsafe {
4159 & ( * ( 0 as * const __va_list_tag ) ) . reg_save_area as *
4160 const _ as usize } , 16usize , concat ! (
4161 "Alignment of field: " , stringify ! ( __va_list_tag ) , "::"
4162 , stringify ! ( reg_save_area ) ));
4163}
4164impl Clone for __va_list_tag {
4165 fn clone(&self) -> Self { *self }
4166}
4167pub type __builtin_va_list = [__va_list_tag; 1usize];
4168#[repr(C)]
4169#[derive(Debug, Copy)]
4170pub struct __locale_data {
4171 pub _address: u8,
4172}
4173impl Clone for __locale_data {
4174 fn clone(&self) -> Self { *self }
4175}