pub const _VCRT_COMPILER_PREPROCESSOR: u32 = 1;
pub const _SAL_VERSION: u32 = 20;
pub const __SAL_H_VERSION: u32 = 180000000;
pub const _USE_DECLSPECS_FOR_SAL: u32 = 0;
pub const _USE_ATTRIBUTES_FOR_SAL: u32 = 0;
pub const _CRT_PACKING: u32 = 8;
pub const _HAS_EXCEPTIONS: u32 = 1;
pub const NULL: u32 = 0;
pub const _HAS_CXX17: u32 = 0;
pub const _HAS_CXX20: u32 = 0;
pub const _HAS_CXX23: u32 = 0;
pub const _HAS_NODISCARD: u32 = 1;
pub const _ARGMAX: u32 = 100;
pub const _CRT_INT_MAX: u32 = 2147483647;
pub const _CRT_FUNCTIONS_REQUIRED: u32 = 1;
pub const _CRT_HAS_CXX17: u32 = 0;
pub const _ARM_WINAPI_PARTITION_DESKTOP_SDK_AVAILABLE: u32 = 1;
pub const _CRT_BUILD_DESKTOP_APP: u32 = 1;
pub const _CRT_INTERNAL_NONSTDC_NAMES: u32 = 1;
pub const __STDC_SECURE_LIB__: u32 = 200411;
pub const __GOT_SECURE_LIB__: u32 = 200411;
pub const __STDC_WANT_SECURE_LIB__: u32 = 1;
pub const _SECURECRT_FILL_BUFFER_PATTERN: u32 = 254;
pub const _CRT_SECURE_CPP_OVERLOAD_STANDARD_NAMES: u32 = 0;
pub const _CRT_SECURE_CPP_OVERLOAD_STANDARD_NAMES_COUNT: u32 = 0;
pub const _CRT_SECURE_CPP_OVERLOAD_SECURE_NAMES: u32 = 1;
pub const _CRT_SECURE_CPP_OVERLOAD_STANDARD_NAMES_MEMORY: u32 = 0;
pub const _CRT_SECURE_CPP_OVERLOAD_SECURE_NAMES_MEMORY: u32 = 0;
pub const _CRT_INTERNAL_STDIO_SYMBOL_PREFIX: &[u8; 1usize] = b"\0";
pub const _CRT_INTERNAL_PRINTF_LEGACY_VSPRINTF_NULL_TERMINATION: u32 = 1;
pub const _CRT_INTERNAL_PRINTF_STANDARD_SNPRINTF_BEHAVIOR: u32 = 2;
pub const _CRT_INTERNAL_PRINTF_LEGACY_WIDE_SPECIFIERS: u32 = 4;
pub const _CRT_INTERNAL_PRINTF_LEGACY_MSVCRT_COMPATIBILITY: u32 = 8;
pub const _CRT_INTERNAL_PRINTF_LEGACY_THREE_DIGIT_EXPONENTS: u32 = 16;
pub const _CRT_INTERNAL_PRINTF_STANDARD_ROUNDING: u32 = 32;
pub const _CRT_INTERNAL_SCANF_SECURECRT: u32 = 1;
pub const _CRT_INTERNAL_SCANF_LEGACY_WIDE_SPECIFIERS: u32 = 2;
pub const _CRT_INTERNAL_SCANF_LEGACY_MSVCRT_COMPATIBILITY: u32 = 4;
pub const BUFSIZ: u32 = 512;
pub const _NSTREAM_: u32 = 512;
pub const _IOB_ENTRIES: u32 = 3;
pub const EOF: i32 = -1;
pub const _IOFBF: u32 = 0;
pub const _IOLBF: u32 = 64;
pub const _IONBF: u32 = 4;
pub const L_tmpnam: u32 = 260;
pub const L_tmpnam_s: u32 = 260;
pub const SEEK_CUR: u32 = 1;
pub const SEEK_END: u32 = 2;
pub const SEEK_SET: u32 = 0;
pub const FILENAME_MAX: u32 = 260;
pub const FOPEN_MAX: u32 = 20;
pub const _SYS_OPEN: u32 = 20;
pub const TMP_MAX: u32 = 2147483647;
pub const TMP_MAX_S: u32 = 2147483647;
pub const _TMP_MAX_S: u32 = 2147483647;
pub const SYS_OPEN: u32 = 20;
pub const _DOMAIN: u32 = 1;
pub const _SING: u32 = 2;
pub const _OVERFLOW: u32 = 3;
pub const _UNDERFLOW: u32 = 4;
pub const _TLOSS: u32 = 5;
pub const _PLOSS: u32 = 6;
pub const _HUGE_ENUF : f64 = 1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0 ;
pub const _DENORM: i32 = -2;
pub const _FINITE: i32 = -1;
pub const _INFCODE: u32 = 1;
pub const _NANCODE: u32 = 2;
pub const FP_INFINITE: u32 = 1;
pub const FP_NAN: u32 = 2;
pub const FP_NORMAL: i32 = -1;
pub const FP_SUBNORMAL: i32 = -2;
pub const FP_ZERO: u32 = 0;
pub const _C2: u32 = 1;
pub const FP_ILOGB0: i32 = -2147483648;
pub const FP_ILOGBNAN: u32 = 2147483647;
pub const MATH_ERRNO: u32 = 1;
pub const MATH_ERREXCEPT: u32 = 2;
pub const math_errhandling: u32 = 3;
pub const _FE_DIVBYZERO: u32 = 4;
pub const _FE_INEXACT: u32 = 32;
pub const _FE_INVALID: u32 = 1;
pub const _FE_OVERFLOW: u32 = 8;
pub const _FE_UNDERFLOW: u32 = 16;
pub const _D0_C: u32 = 3;
pub const _D1_C: u32 = 2;
pub const _D2_C: u32 = 1;
pub const _D3_C: u32 = 0;
pub const _DBIAS: u32 = 1022;
pub const _DOFF: u32 = 4;
pub const _F0_C: u32 = 1;
pub const _F1_C: u32 = 0;
pub const _FBIAS: u32 = 126;
pub const _FOFF: u32 = 7;
pub const _FRND: u32 = 1;
pub const _L0_C: u32 = 3;
pub const _L1_C: u32 = 2;
pub const _L2_C: u32 = 1;
pub const _L3_C: u32 = 0;
pub const _LBIAS: u32 = 1022;
pub const _LOFF: u32 = 4;
pub const _FP_LT: u32 = 1;
pub const _FP_EQ: u32 = 2;
pub const _FP_GT: u32 = 4;
pub const DOMAIN: u32 = 1;
pub const SING: u32 = 2;
pub const OVERFLOW: u32 = 3;
pub const UNDERFLOW: u32 = 4;
pub const TLOSS: u32 = 5;
pub const PLOSS: u32 = 6;
pub const TIME_UTC: u32 = 1;
pub type va_list = *mut ::std::os::raw::c_char;
extern "C" {
pub fn __va_start(arg1: *mut va_list, ...);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct __vcrt_va_list_is_reference {
pub _address: u8,
}
pub const __vcrt_va_list_is_reference___the_value: __vcrt_va_list_is_reference__bindgen_ty_1 =
false;
pub type __vcrt_va_list_is_reference__bindgen_ty_1 = bool;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct __vcrt_assert_va_start_is_not_reference {
pub _address: u8,
}
pub type __vcrt_bool = bool;
extern "C" {
pub fn __security_init_cookie();
}
extern "C" {
pub fn __security_check_cookie(_StackCookie: usize);
}
extern "C" {
pub fn __report_gsfailure(_StackCookie: usize) -> !;
}
extern "C" {
pub static mut __security_cookie: usize;
}
pub type __crt_bool = bool;
extern "C" {
pub fn _invalid_parameter_noinfo();
}
extern "C" {
pub fn _invalid_parameter_noinfo_noreturn() -> !;
}
extern "C" {
pub fn _invoke_watson(
_Expression: *const u16,
_FunctionName: *const u16,
_FileName: *const u16,
_LineNo: ::std::os::raw::c_uint,
_Reserved: usize,
) -> !;
}
pub type errno_t = ::std::os::raw::c_int;
pub type wint_t = ::std::os::raw::c_ushort;
pub type wctype_t = ::std::os::raw::c_ushort;
pub type __time32_t = ::std::os::raw::c_long;
pub type __time64_t = ::std::os::raw::c_longlong;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct __crt_locale_data_public {
pub _locale_pctype: *const ::std::os::raw::c_ushort,
pub _locale_mb_cur_max: ::std::os::raw::c_int,
pub _locale_lc_codepage: ::std::os::raw::c_uint,
}
#[test]
fn bindgen_test_layout___crt_locale_data_public() {
const UNINIT: ::std::mem::MaybeUninit<__crt_locale_data_public> =
::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<__crt_locale_data_public>(),
16usize,
concat!("Size of: ", stringify!(__crt_locale_data_public))
);
assert_eq!(
::std::mem::align_of::<__crt_locale_data_public>(),
8usize,
concat!("Alignment of ", stringify!(__crt_locale_data_public))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr)._locale_pctype) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(__crt_locale_data_public),
"::",
stringify!(_locale_pctype)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr)._locale_mb_cur_max) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(__crt_locale_data_public),
"::",
stringify!(_locale_mb_cur_max)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr)._locale_lc_codepage) as usize - ptr as usize },
12usize,
concat!(
"Offset of field: ",
stringify!(__crt_locale_data_public),
"::",
stringify!(_locale_lc_codepage)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct __crt_locale_pointers {
pub locinfo: *mut __crt_locale_data,
pub mbcinfo: *mut __crt_multibyte_data,
}
#[test]
fn bindgen_test_layout___crt_locale_pointers() {
const UNINIT: ::std::mem::MaybeUninit<__crt_locale_pointers> =
::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<__crt_locale_pointers>(),
16usize,
concat!("Size of: ", stringify!(__crt_locale_pointers))
);
assert_eq!(
::std::mem::align_of::<__crt_locale_pointers>(),
8usize,
concat!("Alignment of ", stringify!(__crt_locale_pointers))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).locinfo) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(__crt_locale_pointers),
"::",
stringify!(locinfo)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).mbcinfo) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(__crt_locale_pointers),
"::",
stringify!(mbcinfo)
)
);
}
pub type _locale_t = *mut __crt_locale_pointers;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _Mbstatet {
pub _Wchar: ::std::os::raw::c_ulong,
pub _Byte: ::std::os::raw::c_ushort,
pub _State: ::std::os::raw::c_ushort,
}
#[test]
fn bindgen_test_layout__Mbstatet() {
const UNINIT: ::std::mem::MaybeUninit<_Mbstatet> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<_Mbstatet>(),
8usize,
concat!("Size of: ", stringify!(_Mbstatet))
);
assert_eq!(
::std::mem::align_of::<_Mbstatet>(),
4usize,
concat!("Alignment of ", stringify!(_Mbstatet))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr)._Wchar) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_Mbstatet),
"::",
stringify!(_Wchar)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr)._Byte) as usize - ptr as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(_Mbstatet),
"::",
stringify!(_Byte)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr)._State) as usize - ptr as usize },
6usize,
concat!(
"Offset of field: ",
stringify!(_Mbstatet),
"::",
stringify!(_State)
)
);
}
pub type mbstate_t = _Mbstatet;
pub type time_t = __time64_t;
pub type rsize_t = usize;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _iobuf {
pub _Placeholder: *mut ::std::os::raw::c_void,
}
#[test]
fn bindgen_test_layout__iobuf() {
const UNINIT: ::std::mem::MaybeUninit<_iobuf> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<_iobuf>(),
8usize,
concat!("Size of: ", stringify!(_iobuf))
);
assert_eq!(
::std::mem::align_of::<_iobuf>(),
8usize,
concat!("Alignment of ", stringify!(_iobuf))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr)._Placeholder) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_iobuf),
"::",
stringify!(_Placeholder)
)
);
}
pub type FILE = _iobuf;
extern "C" {
pub fn __acrt_iob_func(_Ix: ::std::os::raw::c_uint) -> *mut FILE;
}
extern "C" {
pub fn fgetwc(_Stream: *mut FILE) -> wint_t;
}
extern "C" {
pub fn _fgetwchar() -> wint_t;
}
extern "C" {
pub fn fputwc(_Character: u16, _Stream: *mut FILE) -> wint_t;
}
extern "C" {
pub fn _fputwchar(_Character: u16) -> wint_t;
}
extern "C" {
pub fn getwc(_Stream: *mut FILE) -> wint_t;
}
extern "C" {
pub fn getwchar() -> wint_t;
}
extern "C" {
pub fn fgetws(
_Buffer: *mut u16,
_BufferCount: ::std::os::raw::c_int,
_Stream: *mut FILE,
) -> *mut u16;
}
extern "C" {
pub fn fputws(_Buffer: *const u16, _Stream: *mut FILE) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn _getws_s(_Buffer: *mut u16, _BufferCount: usize) -> *mut u16;
}
extern "C" {
pub fn putwc(_Character: u16, _Stream: *mut FILE) -> wint_t;
}
extern "C" {
pub fn putwchar(_Character: u16) -> wint_t;
}
extern "C" {
pub fn _putws(_Buffer: *const u16) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn ungetwc(_Character: wint_t, _Stream: *mut FILE) -> wint_t;
}
extern "C" {
pub fn _wfdopen(_FileHandle: ::std::os::raw::c_int, _Mode: *const u16) -> *mut FILE;
}
extern "C" {
pub fn _wfopen(_FileName: *const u16, _Mode: *const u16) -> *mut FILE;
}
extern "C" {
pub fn _wfopen_s(_Stream: *mut *mut FILE, _FileName: *const u16, _Mode: *const u16) -> errno_t;
}
extern "C" {
pub fn _wfreopen(_FileName: *const u16, _Mode: *const u16, _OldStream: *mut FILE) -> *mut FILE;
}
extern "C" {
pub fn _wfreopen_s(
_Stream: *mut *mut FILE,
_FileName: *const u16,
_Mode: *const u16,
_OldStream: *mut FILE,
) -> errno_t;
}
extern "C" {
pub fn _wfsopen(
_FileName: *const u16,
_Mode: *const u16,
_ShFlag: ::std::os::raw::c_int,
) -> *mut FILE;
}
extern "C" {
pub fn _wperror(_ErrorMessage: *const u16);
}
extern "C" {
pub fn _wpopen(_Command: *const u16, _Mode: *const u16) -> *mut FILE;
}
extern "C" {
pub fn _wremove(_FileName: *const u16) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn _wtempnam(_Directory: *const u16, _FilePrefix: *const u16) -> *mut u16;
}
extern "C" {
pub fn _wtmpnam_s(_Buffer: *mut u16, _BufferCount: usize) -> errno_t;
}
extern "C" {
pub fn _wtmpnam(_Buffer: *mut u16) -> *mut u16;
}
extern "C" {
pub fn _fgetwc_nolock(_Stream: *mut FILE) -> wint_t;
}
extern "C" {
pub fn _fputwc_nolock(_Character: u16, _Stream: *mut FILE) -> wint_t;
}
extern "C" {
pub fn _getwc_nolock(_Stream: *mut FILE) -> wint_t;
}
extern "C" {
pub fn _putwc_nolock(_Character: u16, _Stream: *mut FILE) -> wint_t;
}
extern "C" {
pub fn _ungetwc_nolock(_Character: wint_t, _Stream: *mut FILE) -> wint_t;
}
extern "C" {
pub fn __stdio_common_vfwprintf(
_Options: ::std::os::raw::c_ulonglong,
_Stream: *mut FILE,
_Format: *const u16,
_Locale: _locale_t,
_ArgList: va_list,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn __stdio_common_vfwprintf_s(
_Options: ::std::os::raw::c_ulonglong,
_Stream: *mut FILE,
_Format: *const u16,
_Locale: _locale_t,
_ArgList: va_list,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn __stdio_common_vfwprintf_p(
_Options: ::std::os::raw::c_ulonglong,
_Stream: *mut FILE,
_Format: *const u16,
_Locale: _locale_t,
_ArgList: va_list,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn __stdio_common_vfwscanf(
_Options: ::std::os::raw::c_ulonglong,
_Stream: *mut FILE,
_Format: *const u16,
_Locale: _locale_t,
_ArgList: va_list,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn __stdio_common_vswprintf(
_Options: ::std::os::raw::c_ulonglong,
_Buffer: *mut u16,
_BufferCount: usize,
_Format: *const u16,
_Locale: _locale_t,
_ArgList: va_list,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn __stdio_common_vswprintf_s(
_Options: ::std::os::raw::c_ulonglong,
_Buffer: *mut u16,
_BufferCount: usize,
_Format: *const u16,
_Locale: _locale_t,
_ArgList: va_list,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn __stdio_common_vsnwprintf_s(
_Options: ::std::os::raw::c_ulonglong,
_Buffer: *mut u16,
_BufferCount: usize,
_MaxCount: usize,
_Format: *const u16,
_Locale: _locale_t,
_ArgList: va_list,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn __stdio_common_vswprintf_p(
_Options: ::std::os::raw::c_ulonglong,
_Buffer: *mut u16,
_BufferCount: usize,
_Format: *const u16,
_Locale: _locale_t,
_ArgList: va_list,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn __stdio_common_vswscanf(
_Options: ::std::os::raw::c_ulonglong,
_Buffer: *const u16,
_BufferCount: usize,
_Format: *const u16,
_Locale: _locale_t,
_ArgList: va_list,
) -> ::std::os::raw::c_int;
}
pub type fpos_t = ::std::os::raw::c_longlong;
extern "C" {
pub fn _get_stream_buffer_pointers(
_Stream: *mut FILE,
_Base: *mut *mut *mut ::std::os::raw::c_char,
_Pointer: *mut *mut *mut ::std::os::raw::c_char,
_Count: *mut *mut ::std::os::raw::c_int,
) -> errno_t;
}
extern "C" {
pub fn clearerr_s(_Stream: *mut FILE) -> errno_t;
}
extern "C" {
pub fn fopen_s(
_Stream: *mut *mut FILE,
_FileName: *const ::std::os::raw::c_char,
_Mode: *const ::std::os::raw::c_char,
) -> errno_t;
}
extern "C" {
pub fn fread_s(
_Buffer: *mut ::std::os::raw::c_void,
_BufferSize: usize,
_ElementSize: usize,
_ElementCount: usize,
_Stream: *mut FILE,
) -> usize;
}
extern "C" {
pub fn freopen_s(
_Stream: *mut *mut FILE,
_FileName: *const ::std::os::raw::c_char,
_Mode: *const ::std::os::raw::c_char,
_OldStream: *mut FILE,
) -> errno_t;
}
extern "C" {
pub fn gets_s(
_Buffer: *mut ::std::os::raw::c_char,
_Size: rsize_t,
) -> *mut ::std::os::raw::c_char;
}
extern "C" {
pub fn tmpfile_s(_Stream: *mut *mut FILE) -> errno_t;
}
extern "C" {
pub fn tmpnam_s(_Buffer: *mut ::std::os::raw::c_char, _Size: rsize_t) -> errno_t;
}
extern "C" {
pub fn clearerr(_Stream: *mut FILE);
}
extern "C" {
pub fn fclose(_Stream: *mut FILE) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn _fcloseall() -> ::std::os::raw::c_int;
}
extern "C" {
pub fn _fdopen(
_FileHandle: ::std::os::raw::c_int,
_Mode: *const ::std::os::raw::c_char,
) -> *mut FILE;
}
extern "C" {
pub fn feof(_Stream: *mut FILE) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn ferror(_Stream: *mut FILE) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn fflush(_Stream: *mut FILE) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn fgetc(_Stream: *mut FILE) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn _fgetchar() -> ::std::os::raw::c_int;
}
extern "C" {
pub fn fgetpos(_Stream: *mut FILE, _Position: *mut fpos_t) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn fgets(
_Buffer: *mut ::std::os::raw::c_char,
_MaxCount: ::std::os::raw::c_int,
_Stream: *mut FILE,
) -> *mut ::std::os::raw::c_char;
}
extern "C" {
pub fn _fileno(_Stream: *mut FILE) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn _flushall() -> ::std::os::raw::c_int;
}
extern "C" {
pub fn fopen(
_FileName: *const ::std::os::raw::c_char,
_Mode: *const ::std::os::raw::c_char,
) -> *mut FILE;
}
extern "C" {
pub fn fputc(_Character: ::std::os::raw::c_int, _Stream: *mut FILE) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn _fputchar(_Character: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn fputs(
_Buffer: *const ::std::os::raw::c_char,
_Stream: *mut FILE,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn fread(
_Buffer: *mut ::std::os::raw::c_void,
_ElementSize: usize,
_ElementCount: usize,
_Stream: *mut FILE,
) -> usize;
}
extern "C" {
pub fn freopen(
_FileName: *const ::std::os::raw::c_char,
_Mode: *const ::std::os::raw::c_char,
_Stream: *mut FILE,
) -> *mut FILE;
}
extern "C" {
pub fn _fsopen(
_FileName: *const ::std::os::raw::c_char,
_Mode: *const ::std::os::raw::c_char,
_ShFlag: ::std::os::raw::c_int,
) -> *mut FILE;
}
extern "C" {
pub fn fsetpos(_Stream: *mut FILE, _Position: *const fpos_t) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn fseek(
_Stream: *mut FILE,
_Offset: ::std::os::raw::c_long,
_Origin: ::std::os::raw::c_int,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn _fseeki64(
_Stream: *mut FILE,
_Offset: ::std::os::raw::c_longlong,
_Origin: ::std::os::raw::c_int,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn ftell(_Stream: *mut FILE) -> ::std::os::raw::c_long;
}
extern "C" {
pub fn _ftelli64(_Stream: *mut FILE) -> ::std::os::raw::c_longlong;
}
extern "C" {
pub fn fwrite(
_Buffer: *const ::std::os::raw::c_void,
_ElementSize: usize,
_ElementCount: usize,
_Stream: *mut FILE,
) -> usize;
}
extern "C" {
pub fn getc(_Stream: *mut FILE) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn getchar() -> ::std::os::raw::c_int;
}
extern "C" {
pub fn _getmaxstdio() -> ::std::os::raw::c_int;
}
extern "C" {
pub fn _getw(_Stream: *mut FILE) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn perror(_ErrorMessage: *const ::std::os::raw::c_char);
}
extern "C" {
pub fn _pclose(_Stream: *mut FILE) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn _popen(
_Command: *const ::std::os::raw::c_char,
_Mode: *const ::std::os::raw::c_char,
) -> *mut FILE;
}
extern "C" {
pub fn putc(_Character: ::std::os::raw::c_int, _Stream: *mut FILE) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn putchar(_Character: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn puts(_Buffer: *const ::std::os::raw::c_char) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn _putw(_Word: ::std::os::raw::c_int, _Stream: *mut FILE) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn remove(_FileName: *const ::std::os::raw::c_char) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn rename(
_OldFileName: *const ::std::os::raw::c_char,
_NewFileName: *const ::std::os::raw::c_char,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn _unlink(_FileName: *const ::std::os::raw::c_char) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn unlink(_FileName: *const ::std::os::raw::c_char) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn rewind(_Stream: *mut FILE);
}
extern "C" {
pub fn _rmtmp() -> ::std::os::raw::c_int;
}
extern "C" {
pub fn setbuf(_Stream: *mut FILE, _Buffer: *mut ::std::os::raw::c_char);
}
extern "C" {
pub fn _setmaxstdio(_Maximum: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn setvbuf(
_Stream: *mut FILE,
_Buffer: *mut ::std::os::raw::c_char,
_Mode: ::std::os::raw::c_int,
_Size: usize,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn _tempnam(
_DirectoryName: *const ::std::os::raw::c_char,
_FilePrefix: *const ::std::os::raw::c_char,
) -> *mut ::std::os::raw::c_char;
}
extern "C" {
pub fn tmpfile() -> *mut FILE;
}
extern "C" {
pub fn tmpnam(_Buffer: *mut ::std::os::raw::c_char) -> *mut ::std::os::raw::c_char;
}
extern "C" {
pub fn ungetc(_Character: ::std::os::raw::c_int, _Stream: *mut FILE) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn _lock_file(_Stream: *mut FILE);
}
extern "C" {
pub fn _unlock_file(_Stream: *mut FILE);
}
extern "C" {
pub fn _fclose_nolock(_Stream: *mut FILE) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn _fflush_nolock(_Stream: *mut FILE) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn _fgetc_nolock(_Stream: *mut FILE) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn _fputc_nolock(
_Character: ::std::os::raw::c_int,
_Stream: *mut FILE,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn _fread_nolock(
_Buffer: *mut ::std::os::raw::c_void,
_ElementSize: usize,
_ElementCount: usize,
_Stream: *mut FILE,
) -> usize;
}
extern "C" {
pub fn _fread_nolock_s(
_Buffer: *mut ::std::os::raw::c_void,
_BufferSize: usize,
_ElementSize: usize,
_ElementCount: usize,
_Stream: *mut FILE,
) -> usize;
}
extern "C" {
pub fn _fseek_nolock(
_Stream: *mut FILE,
_Offset: ::std::os::raw::c_long,
_Origin: ::std::os::raw::c_int,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn _fseeki64_nolock(
_Stream: *mut FILE,
_Offset: ::std::os::raw::c_longlong,
_Origin: ::std::os::raw::c_int,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn _ftell_nolock(_Stream: *mut FILE) -> ::std::os::raw::c_long;
}
extern "C" {
pub fn _ftelli64_nolock(_Stream: *mut FILE) -> ::std::os::raw::c_longlong;
}
extern "C" {
pub fn _fwrite_nolock(
_Buffer: *const ::std::os::raw::c_void,
_ElementSize: usize,
_ElementCount: usize,
_Stream: *mut FILE,
) -> usize;
}
extern "C" {
pub fn _getc_nolock(_Stream: *mut FILE) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn _putc_nolock(
_Character: ::std::os::raw::c_int,
_Stream: *mut FILE,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn _ungetc_nolock(
_Character: ::std::os::raw::c_int,
_Stream: *mut FILE,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn __p__commode() -> *mut ::std::os::raw::c_int;
}
extern "C" {
pub fn __stdio_common_vfprintf(
_Options: ::std::os::raw::c_ulonglong,
_Stream: *mut FILE,
_Format: *const ::std::os::raw::c_char,
_Locale: _locale_t,
_ArgList: va_list,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn __stdio_common_vfprintf_s(
_Options: ::std::os::raw::c_ulonglong,
_Stream: *mut FILE,
_Format: *const ::std::os::raw::c_char,
_Locale: _locale_t,
_ArgList: va_list,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn __stdio_common_vfprintf_p(
_Options: ::std::os::raw::c_ulonglong,
_Stream: *mut FILE,
_Format: *const ::std::os::raw::c_char,
_Locale: _locale_t,
_ArgList: va_list,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn _set_printf_count_output(_Value: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn _get_printf_count_output() -> ::std::os::raw::c_int;
}
extern "C" {
pub fn __stdio_common_vfscanf(
_Options: ::std::os::raw::c_ulonglong,
_Stream: *mut FILE,
_Format: *const ::std::os::raw::c_char,
_Locale: _locale_t,
_Arglist: va_list,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn __stdio_common_vsprintf(
_Options: ::std::os::raw::c_ulonglong,
_Buffer: *mut ::std::os::raw::c_char,
_BufferCount: usize,
_Format: *const ::std::os::raw::c_char,
_Locale: _locale_t,
_ArgList: va_list,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn __stdio_common_vsprintf_s(
_Options: ::std::os::raw::c_ulonglong,
_Buffer: *mut ::std::os::raw::c_char,
_BufferCount: usize,
_Format: *const ::std::os::raw::c_char,
_Locale: _locale_t,
_ArgList: va_list,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn __stdio_common_vsnprintf_s(
_Options: ::std::os::raw::c_ulonglong,
_Buffer: *mut ::std::os::raw::c_char,
_BufferCount: usize,
_MaxCount: usize,
_Format: *const ::std::os::raw::c_char,
_Locale: _locale_t,
_ArgList: va_list,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn __stdio_common_vsprintf_p(
_Options: ::std::os::raw::c_ulonglong,
_Buffer: *mut ::std::os::raw::c_char,
_BufferCount: usize,
_Format: *const ::std::os::raw::c_char,
_Locale: _locale_t,
_ArgList: va_list,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn __stdio_common_vsscanf(
_Options: ::std::os::raw::c_ulonglong,
_Buffer: *const ::std::os::raw::c_char,
_BufferCount: usize,
_Format: *const ::std::os::raw::c_char,
_Locale: _locale_t,
_ArgList: va_list,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn tempnam(
_Directory: *const ::std::os::raw::c_char,
_FilePrefix: *const ::std::os::raw::c_char,
) -> *mut ::std::os::raw::c_char;
}
extern "C" {
pub fn fcloseall() -> ::std::os::raw::c_int;
}
extern "C" {
pub fn fdopen(
_FileHandle: ::std::os::raw::c_int,
_Format: *const ::std::os::raw::c_char,
) -> *mut FILE;
}
extern "C" {
pub fn fgetchar() -> ::std::os::raw::c_int;
}
extern "C" {
pub fn fileno(_Stream: *mut FILE) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn flushall() -> ::std::os::raw::c_int;
}
extern "C" {
pub fn fputchar(_Ch: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn getw(_Stream: *mut FILE) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn putw(_Ch: ::std::os::raw::c_int, _Stream: *mut FILE) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn rmtmp() -> ::std::os::raw::c_int;
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _exception {
pub type_: ::std::os::raw::c_int,
pub name: *mut ::std::os::raw::c_char,
pub arg1: f64,
pub arg2: f64,
pub retval: f64,
}
#[test]
fn bindgen_test_layout__exception() {
const UNINIT: ::std::mem::MaybeUninit<_exception> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<_exception>(),
40usize,
concat!("Size of: ", stringify!(_exception))
);
assert_eq!(
::std::mem::align_of::<_exception>(),
8usize,
concat!("Alignment of ", stringify!(_exception))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).type_) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_exception),
"::",
stringify!(type_)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).name) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(_exception),
"::",
stringify!(name)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).arg1) as usize - ptr as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(_exception),
"::",
stringify!(arg1)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).arg2) as usize - ptr as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(_exception),
"::",
stringify!(arg2)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).retval) as usize - ptr as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(_exception),
"::",
stringify!(retval)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _complex {
pub x: f64,
pub y: f64,
}
#[test]
fn bindgen_test_layout__complex() {
const UNINIT: ::std::mem::MaybeUninit<_complex> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<_complex>(),
16usize,
concat!("Size of: ", stringify!(_complex))
);
assert_eq!(
::std::mem::align_of::<_complex>(),
8usize,
concat!("Alignment of ", stringify!(_complex))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).x) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_complex),
"::",
stringify!(x)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).y) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(_complex),
"::",
stringify!(y)
)
);
}
pub type float_t = f32;
pub type double_t = f64;
extern "C" {
pub static _HUGE: f64;
}
extern "C" {
pub fn _fperrraise(_Except: ::std::os::raw::c_int);
}
extern "C" {
pub fn _dclass(_X: f64) -> ::std::os::raw::c_short;
}
extern "C" {
pub fn _ldclass(_X: f64) -> ::std::os::raw::c_short;
}
extern "C" {
pub fn _fdclass(_X: f32) -> ::std::os::raw::c_short;
}
extern "C" {
pub fn _dsign(_X: f64) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn _ldsign(_X: f64) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn _fdsign(_X: f32) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn _dpcomp(_X: f64, _Y: f64) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn _ldpcomp(_X: f64, _Y: f64) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn _fdpcomp(_X: f32, _Y: f32) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn _dtest(_Px: *mut f64) -> ::std::os::raw::c_short;
}
extern "C" {
pub fn _ldtest(_Px: *mut f64) -> ::std::os::raw::c_short;
}
extern "C" {
pub fn _fdtest(_Px: *mut f32) -> ::std::os::raw::c_short;
}
extern "C" {
pub fn _d_int(_Px: *mut f64, _Xexp: ::std::os::raw::c_short) -> ::std::os::raw::c_short;
}
extern "C" {
pub fn _ld_int(_Px: *mut f64, _Xexp: ::std::os::raw::c_short) -> ::std::os::raw::c_short;
}
extern "C" {
pub fn _fd_int(_Px: *mut f32, _Xexp: ::std::os::raw::c_short) -> ::std::os::raw::c_short;
}
extern "C" {
pub fn _dscale(_Px: *mut f64, _Lexp: ::std::os::raw::c_long) -> ::std::os::raw::c_short;
}
extern "C" {
pub fn _ldscale(_Px: *mut f64, _Lexp: ::std::os::raw::c_long) -> ::std::os::raw::c_short;
}
extern "C" {
pub fn _fdscale(_Px: *mut f32, _Lexp: ::std::os::raw::c_long) -> ::std::os::raw::c_short;
}
extern "C" {
pub fn _dunscale(_Pex: *mut ::std::os::raw::c_short, _Px: *mut f64) -> ::std::os::raw::c_short;
}
extern "C" {
pub fn _ldunscale(_Pex: *mut ::std::os::raw::c_short, _Px: *mut f64)
-> ::std::os::raw::c_short;
}
extern "C" {
pub fn _fdunscale(_Pex: *mut ::std::os::raw::c_short, _Px: *mut f32)
-> ::std::os::raw::c_short;
}
extern "C" {
pub fn _dexp(_Px: *mut f64, _Y: f64, _Eoff: ::std::os::raw::c_long) -> ::std::os::raw::c_short;
}
extern "C" {
pub fn _ldexp(_Px: *mut f64, _Y: f64, _Eoff: ::std::os::raw::c_long)
-> ::std::os::raw::c_short;
}
extern "C" {
pub fn _fdexp(_Px: *mut f32, _Y: f32, _Eoff: ::std::os::raw::c_long)
-> ::std::os::raw::c_short;
}
extern "C" {
pub fn _dnorm(_Ps: *mut ::std::os::raw::c_ushort) -> ::std::os::raw::c_short;
}
extern "C" {
pub fn _fdnorm(_Ps: *mut ::std::os::raw::c_ushort) -> ::std::os::raw::c_short;
}
extern "C" {
pub fn _dpoly(_X: f64, _Tab: *const f64, _N: ::std::os::raw::c_int) -> f64;
}
extern "C" {
pub fn _ldpoly(_X: f64, _Tab: *const f64, _N: ::std::os::raw::c_int) -> f64;
}
extern "C" {
pub fn _fdpoly(_X: f32, _Tab: *const f32, _N: ::std::os::raw::c_int) -> f32;
}
extern "C" {
pub fn _dlog(_X: f64, _Baseflag: ::std::os::raw::c_int) -> f64;
}
extern "C" {
pub fn _ldlog(_X: f64, _Baseflag: ::std::os::raw::c_int) -> f64;
}
extern "C" {
pub fn _fdlog(_X: f32, _Baseflag: ::std::os::raw::c_int) -> f32;
}
extern "C" {
pub fn _dsin(_X: f64, _Qoff: ::std::os::raw::c_uint) -> f64;
}
extern "C" {
pub fn _ldsin(_X: f64, _Qoff: ::std::os::raw::c_uint) -> f64;
}
extern "C" {
pub fn _fdsin(_X: f32, _Qoff: ::std::os::raw::c_uint) -> f32;
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union _double_val {
pub _Sh: [::std::os::raw::c_ushort; 4usize],
pub _Val: f64,
}
#[test]
fn bindgen_test_layout__double_val() {
const UNINIT: ::std::mem::MaybeUninit<_double_val> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<_double_val>(),
8usize,
concat!("Size of: ", stringify!(_double_val))
);
assert_eq!(
::std::mem::align_of::<_double_val>(),
8usize,
concat!("Alignment of ", stringify!(_double_val))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr)._Sh) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_double_val),
"::",
stringify!(_Sh)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr)._Val) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_double_val),
"::",
stringify!(_Val)
)
);
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union _float_val {
pub _Sh: [::std::os::raw::c_ushort; 2usize],
pub _Val: f32,
}
#[test]
fn bindgen_test_layout__float_val() {
const UNINIT: ::std::mem::MaybeUninit<_float_val> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<_float_val>(),
4usize,
concat!("Size of: ", stringify!(_float_val))
);
assert_eq!(
::std::mem::align_of::<_float_val>(),
4usize,
concat!("Alignment of ", stringify!(_float_val))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr)._Sh) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_float_val),
"::",
stringify!(_Sh)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr)._Val) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_float_val),
"::",
stringify!(_Val)
)
);
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union _ldouble_val {
pub _Sh: [::std::os::raw::c_ushort; 4usize],
pub _Val: f64,
}
#[test]
fn bindgen_test_layout__ldouble_val() {
const UNINIT: ::std::mem::MaybeUninit<_ldouble_val> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<_ldouble_val>(),
8usize,
concat!("Size of: ", stringify!(_ldouble_val))
);
assert_eq!(
::std::mem::align_of::<_ldouble_val>(),
8usize,
concat!("Alignment of ", stringify!(_ldouble_val))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr)._Sh) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_ldouble_val),
"::",
stringify!(_Sh)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr)._Val) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_ldouble_val),
"::",
stringify!(_Val)
)
);
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union _float_const {
pub _Word: [::std::os::raw::c_ushort; 4usize],
pub _Float: f32,
pub _Double: f64,
pub _Long_double: f64,
}
#[test]
fn bindgen_test_layout__float_const() {
const UNINIT: ::std::mem::MaybeUninit<_float_const> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<_float_const>(),
8usize,
concat!("Size of: ", stringify!(_float_const))
);
assert_eq!(
::std::mem::align_of::<_float_const>(),
8usize,
concat!("Alignment of ", stringify!(_float_const))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr)._Word) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_float_const),
"::",
stringify!(_Word)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr)._Float) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_float_const),
"::",
stringify!(_Float)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr)._Double) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_float_const),
"::",
stringify!(_Double)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr)._Long_double) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_float_const),
"::",
stringify!(_Long_double)
)
);
}
extern "C" {
pub static _Denorm_C: _float_const;
}
extern "C" {
pub static _Inf_C: _float_const;
}
extern "C" {
pub static _Nan_C: _float_const;
}
extern "C" {
pub static _Snan_C: _float_const;
}
extern "C" {
pub static _Hugeval_C: _float_const;
}
extern "C" {
pub static _FDenorm_C: _float_const;
}
extern "C" {
pub static _FInf_C: _float_const;
}
extern "C" {
pub static _FNan_C: _float_const;
}
extern "C" {
pub static _FSnan_C: _float_const;
}
extern "C" {
pub static _LDenorm_C: _float_const;
}
extern "C" {
pub static _LInf_C: _float_const;
}
extern "C" {
pub static _LNan_C: _float_const;
}
extern "C" {
pub static _LSnan_C: _float_const;
}
extern "C" {
pub static _Eps_C: _float_const;
}
extern "C" {
pub static _Rteps_C: _float_const;
}
extern "C" {
pub static _FEps_C: _float_const;
}
extern "C" {
pub static _FRteps_C: _float_const;
}
extern "C" {
pub static _LEps_C: _float_const;
}
extern "C" {
pub static _LRteps_C: _float_const;
}
extern "C" {
pub static _Zero_C: f64;
}
extern "C" {
pub static _Xbig_C: f64;
}
extern "C" {
pub static _FZero_C: f32;
}
extern "C" {
pub static _FXbig_C: f32;
}
extern "C" {
pub static _LZero_C: f64;
}
extern "C" {
pub static _LXbig_C: f64;
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _Combined_type {
pub _address: u8,
}
pub type _Combined_type__Type = f32;
#[test]
fn __bindgen_test_layout__Combined_type_open0_float_double_close0_instantiation() {
assert_eq!(
::std::mem::size_of::<_Combined_type>(),
1usize,
concat!(
"Size of template specialization: ",
stringify!(_Combined_type)
)
);
assert_eq!(
::std::mem::align_of::<_Combined_type>(),
1usize,
concat!(
"Alignment of template specialization: ",
stringify!(_Combined_type)
)
);
}
#[test]
fn __bindgen_test_layout__Combined_type_open0_float_long_double_close0_instantiation() {
assert_eq!(
::std::mem::size_of::<_Combined_type>(),
1usize,
concat!(
"Size of template specialization: ",
stringify!(_Combined_type)
)
);
assert_eq!(
::std::mem::align_of::<_Combined_type>(),
1usize,
concat!(
"Alignment of template specialization: ",
stringify!(_Combined_type)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _Real_widened {
pub _address: u8,
}
pub type _Real_widened__Type = f64;
#[test]
fn __bindgen_test_layout__Real_widened_open0_float_float_close0_instantiation() {
assert_eq!(
::std::mem::size_of::<_Real_widened>(),
1usize,
concat!(
"Size of template specialization: ",
stringify!(_Real_widened)
)
);
assert_eq!(
::std::mem::align_of::<_Real_widened>(),
1usize,
concat!(
"Alignment of template specialization: ",
stringify!(_Real_widened)
)
);
}
#[test]
fn __bindgen_test_layout__Real_widened_open0_float_double_close0_instantiation() {
assert_eq!(
::std::mem::size_of::<_Real_widened>(),
1usize,
concat!(
"Size of template specialization: ",
stringify!(_Real_widened)
)
);
assert_eq!(
::std::mem::align_of::<_Real_widened>(),
1usize,
concat!(
"Alignment of template specialization: ",
stringify!(_Real_widened)
)
);
}
#[test]
fn __bindgen_test_layout__Real_widened_open0_double_float_close0_instantiation() {
assert_eq!(
::std::mem::size_of::<_Real_widened>(),
1usize,
concat!(
"Size of template specialization: ",
stringify!(_Real_widened)
)
);
assert_eq!(
::std::mem::align_of::<_Real_widened>(),
1usize,
concat!(
"Alignment of template specialization: ",
stringify!(_Real_widened)
)
);
}
#[test]
fn __bindgen_test_layout__Real_widened_open0_double_double_close0_instantiation() {
assert_eq!(
::std::mem::size_of::<_Real_widened>(),
1usize,
concat!(
"Size of template specialization: ",
stringify!(_Real_widened)
)
);
assert_eq!(
::std::mem::align_of::<_Real_widened>(),
1usize,
concat!(
"Alignment of template specialization: ",
stringify!(_Real_widened)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _Real_type {
pub _address: u8,
}
pub type _Real_type__Type = f64;
#[test]
fn __bindgen_test_layout__Real_type_open0_float_close0_instantiation() {
assert_eq!(
::std::mem::size_of::<_Real_type>(),
1usize,
concat!("Size of template specialization: ", stringify!(_Real_type))
);
assert_eq!(
::std::mem::align_of::<_Real_type>(),
1usize,
concat!(
"Alignment of template specialization: ",
stringify!(_Real_type)
)
);
}
#[test]
fn __bindgen_test_layout__Real_type_open0_long_double_close0_instantiation() {
assert_eq!(
::std::mem::size_of::<_Real_type>(),
1usize,
concat!("Size of template specialization: ", stringify!(_Real_type))
);
assert_eq!(
::std::mem::align_of::<_Real_type>(),
1usize,
concat!(
"Alignment of template specialization: ",
stringify!(_Real_type)
)
);
}
extern "C" {
pub fn abs(_X: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn labs(_X: ::std::os::raw::c_long) -> ::std::os::raw::c_long;
}
extern "C" {
pub fn llabs(_X: ::std::os::raw::c_longlong) -> ::std::os::raw::c_longlong;
}
extern "C" {
pub fn acos(_X: f64) -> f64;
}
extern "C" {
pub fn asin(_X: f64) -> f64;
}
extern "C" {
pub fn atan(_X: f64) -> f64;
}
extern "C" {
pub fn atan2(_Y: f64, _X: f64) -> f64;
}
extern "C" {
pub fn cos(_X: f64) -> f64;
}
extern "C" {
pub fn cosh(_X: f64) -> f64;
}
extern "C" {
pub fn exp(_X: f64) -> f64;
}
extern "C" {
pub fn fabs(_X: f64) -> f64;
}
extern "C" {
pub fn fmod(_X: f64, _Y: f64) -> f64;
}
extern "C" {
pub fn log(_X: f64) -> f64;
}
extern "C" {
pub fn log10(_X: f64) -> f64;
}
extern "C" {
pub fn pow(_X: f64, _Y: f64) -> f64;
}
extern "C" {
pub fn sin(_X: f64) -> f64;
}
extern "C" {
pub fn sinh(_X: f64) -> f64;
}
extern "C" {
pub fn sqrt(_X: f64) -> f64;
}
extern "C" {
pub fn tan(_X: f64) -> f64;
}
extern "C" {
pub fn tanh(_X: f64) -> f64;
}
extern "C" {
pub fn acosh(_X: f64) -> f64;
}
extern "C" {
pub fn asinh(_X: f64) -> f64;
}
extern "C" {
pub fn atanh(_X: f64) -> f64;
}
extern "C" {
pub fn atof(_String: *const ::std::os::raw::c_char) -> f64;
}
extern "C" {
pub fn _atof_l(_String: *const ::std::os::raw::c_char, _Locale: _locale_t) -> f64;
}
extern "C" {
pub fn _cabs(_Complex_value: _complex) -> f64;
}
extern "C" {
pub fn cbrt(_X: f64) -> f64;
}
extern "C" {
pub fn ceil(_X: f64) -> f64;
}
extern "C" {
pub fn _chgsign(_X: f64) -> f64;
}
extern "C" {
pub fn copysign(_Number: f64, _Sign: f64) -> f64;
}
extern "C" {
pub fn _copysign(_Number: f64, _Sign: f64) -> f64;
}
extern "C" {
pub fn erf(_X: f64) -> f64;
}
extern "C" {
pub fn erfc(_X: f64) -> f64;
}
extern "C" {
pub fn exp2(_X: f64) -> f64;
}
extern "C" {
pub fn expm1(_X: f64) -> f64;
}
extern "C" {
pub fn fdim(_X: f64, _Y: f64) -> f64;
}
extern "C" {
pub fn floor(_X: f64) -> f64;
}
extern "C" {
pub fn fma(_X: f64, _Y: f64, _Z: f64) -> f64;
}
extern "C" {
pub fn fmax(_X: f64, _Y: f64) -> f64;
}
extern "C" {
pub fn fmin(_X: f64, _Y: f64) -> f64;
}
extern "C" {
pub fn frexp(_X: f64, _Y: *mut ::std::os::raw::c_int) -> f64;
}
extern "C" {
pub fn hypot(_X: f64, _Y: f64) -> f64;
}
extern "C" {
pub fn _hypot(_X: f64, _Y: f64) -> f64;
}
extern "C" {
pub fn ilogb(_X: f64) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn ldexp(_X: f64, _Y: ::std::os::raw::c_int) -> f64;
}
extern "C" {
pub fn lgamma(_X: f64) -> f64;
}
extern "C" {
pub fn llrint(_X: f64) -> ::std::os::raw::c_longlong;
}
extern "C" {
pub fn llround(_X: f64) -> ::std::os::raw::c_longlong;
}
extern "C" {
pub fn log1p(_X: f64) -> f64;
}
extern "C" {
pub fn log2(_X: f64) -> f64;
}
extern "C" {
pub fn logb(_X: f64) -> f64;
}
extern "C" {
pub fn lrint(_X: f64) -> ::std::os::raw::c_long;
}
extern "C" {
pub fn lround(_X: f64) -> ::std::os::raw::c_long;
}
extern "C" {
pub fn _matherr(_Except: *mut _exception) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn modf(_X: f64, _Y: *mut f64) -> f64;
}
extern "C" {
pub fn nan(_X: *const ::std::os::raw::c_char) -> f64;
}
extern "C" {
pub fn nearbyint(_X: f64) -> f64;
}
extern "C" {
pub fn nextafter(_X: f64, _Y: f64) -> f64;
}
extern "C" {
pub fn nexttoward(_X: f64, _Y: f64) -> f64;
}
extern "C" {
pub fn remainder(_X: f64, _Y: f64) -> f64;
}
extern "C" {
pub fn remquo(_X: f64, _Y: f64, _Z: *mut ::std::os::raw::c_int) -> f64;
}
extern "C" {
pub fn rint(_X: f64) -> f64;
}
extern "C" {
pub fn round(_X: f64) -> f64;
}
extern "C" {
pub fn scalbln(_X: f64, _Y: ::std::os::raw::c_long) -> f64;
}
extern "C" {
pub fn scalbn(_X: f64, _Y: ::std::os::raw::c_int) -> f64;
}
extern "C" {
pub fn tgamma(_X: f64) -> f64;
}
extern "C" {
pub fn trunc(_X: f64) -> f64;
}
extern "C" {
pub fn _j0(_X: f64) -> f64;
}
extern "C" {
pub fn _j1(_X: f64) -> f64;
}
extern "C" {
pub fn _jn(_X: ::std::os::raw::c_int, _Y: f64) -> f64;
}
extern "C" {
pub fn _y0(_X: f64) -> f64;
}
extern "C" {
pub fn _y1(_X: f64) -> f64;
}
extern "C" {
pub fn _yn(_X: ::std::os::raw::c_int, _Y: f64) -> f64;
}
extern "C" {
pub fn acoshf(_X: f32) -> f32;
}
extern "C" {
pub fn asinhf(_X: f32) -> f32;
}
extern "C" {
pub fn atanhf(_X: f32) -> f32;
}
extern "C" {
pub fn cbrtf(_X: f32) -> f32;
}
extern "C" {
pub fn _chgsignf(_X: f32) -> f32;
}
extern "C" {
pub fn copysignf(_Number: f32, _Sign: f32) -> f32;
}
extern "C" {
pub fn _copysignf(_Number: f32, _Sign: f32) -> f32;
}
extern "C" {
pub fn erff(_X: f32) -> f32;
}
extern "C" {
pub fn erfcf(_X: f32) -> f32;
}
extern "C" {
pub fn expm1f(_X: f32) -> f32;
}
extern "C" {
pub fn exp2f(_X: f32) -> f32;
}
extern "C" {
pub fn fdimf(_X: f32, _Y: f32) -> f32;
}
extern "C" {
pub fn fmaf(_X: f32, _Y: f32, _Z: f32) -> f32;
}
extern "C" {
pub fn fmaxf(_X: f32, _Y: f32) -> f32;
}
extern "C" {
pub fn fminf(_X: f32, _Y: f32) -> f32;
}
extern "C" {
pub fn _hypotf(_X: f32, _Y: f32) -> f32;
}
extern "C" {
pub fn ilogbf(_X: f32) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn lgammaf(_X: f32) -> f32;
}
extern "C" {
pub fn llrintf(_X: f32) -> ::std::os::raw::c_longlong;
}
extern "C" {
pub fn llroundf(_X: f32) -> ::std::os::raw::c_longlong;
}
extern "C" {
pub fn log1pf(_X: f32) -> f32;
}
extern "C" {
pub fn log2f(_X: f32) -> f32;
}
extern "C" {
pub fn logbf(_X: f32) -> f32;
}
extern "C" {
pub fn lrintf(_X: f32) -> ::std::os::raw::c_long;
}
extern "C" {
pub fn lroundf(_X: f32) -> ::std::os::raw::c_long;
}
extern "C" {
pub fn nanf(_X: *const ::std::os::raw::c_char) -> f32;
}
extern "C" {
pub fn nearbyintf(_X: f32) -> f32;
}
extern "C" {
pub fn nextafterf(_X: f32, _Y: f32) -> f32;
}
extern "C" {
pub fn nexttowardf(_X: f32, _Y: f64) -> f32;
}
extern "C" {
pub fn remainderf(_X: f32, _Y: f32) -> f32;
}
extern "C" {
pub fn remquof(_X: f32, _Y: f32, _Z: *mut ::std::os::raw::c_int) -> f32;
}
extern "C" {
pub fn rintf(_X: f32) -> f32;
}
extern "C" {
pub fn roundf(_X: f32) -> f32;
}
extern "C" {
pub fn scalblnf(_X: f32, _Y: ::std::os::raw::c_long) -> f32;
}
extern "C" {
pub fn scalbnf(_X: f32, _Y: ::std::os::raw::c_int) -> f32;
}
extern "C" {
pub fn tgammaf(_X: f32) -> f32;
}
extern "C" {
pub fn truncf(_X: f32) -> f32;
}
extern "C" {
pub fn _logbf(_X: f32) -> f32;
}
extern "C" {
pub fn _nextafterf(_X: f32, _Y: f32) -> f32;
}
extern "C" {
pub fn _finitef(_X: f32) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn _isnanf(_X: f32) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn _fpclassf(_X: f32) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn _set_FMA3_enable(_Flag: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn _get_FMA3_enable() -> ::std::os::raw::c_int;
}
extern "C" {
pub fn acosf(_X: f32) -> f32;
}
extern "C" {
pub fn asinf(_X: f32) -> f32;
}
extern "C" {
pub fn atan2f(_Y: f32, _X: f32) -> f32;
}
extern "C" {
pub fn atanf(_X: f32) -> f32;
}
extern "C" {
pub fn ceilf(_X: f32) -> f32;
}
extern "C" {
pub fn cosf(_X: f32) -> f32;
}
extern "C" {
pub fn coshf(_X: f32) -> f32;
}
extern "C" {
pub fn expf(_X: f32) -> f32;
}
extern "C" {
pub fn floorf(_X: f32) -> f32;
}
extern "C" {
pub fn fmodf(_X: f32, _Y: f32) -> f32;
}
extern "C" {
pub fn log10f(_X: f32) -> f32;
}
extern "C" {
pub fn logf(_X: f32) -> f32;
}
extern "C" {
pub fn modff(_X: f32, _Y: *mut f32) -> f32;
}
extern "C" {
pub fn powf(_X: f32, _Y: f32) -> f32;
}
extern "C" {
pub fn sinf(_X: f32) -> f32;
}
extern "C" {
pub fn sinhf(_X: f32) -> f32;
}
extern "C" {
pub fn sqrtf(_X: f32) -> f32;
}
extern "C" {
pub fn tanf(_X: f32) -> f32;
}
extern "C" {
pub fn tanhf(_X: f32) -> f32;
}
extern "C" {
pub fn acoshl(_X: f64) -> f64;
}
extern "C" {
pub fn asinhl(_X: f64) -> f64;
}
extern "C" {
pub fn atanhl(_X: f64) -> f64;
}
extern "C" {
pub fn cbrtl(_X: f64) -> f64;
}
extern "C" {
pub fn copysignl(_Number: f64, _Sign: f64) -> f64;
}
extern "C" {
pub fn erfl(_X: f64) -> f64;
}
extern "C" {
pub fn erfcl(_X: f64) -> f64;
}
extern "C" {
pub fn exp2l(_X: f64) -> f64;
}
extern "C" {
pub fn expm1l(_X: f64) -> f64;
}
extern "C" {
pub fn fdiml(_X: f64, _Y: f64) -> f64;
}
extern "C" {
pub fn fmal(_X: f64, _Y: f64, _Z: f64) -> f64;
}
extern "C" {
pub fn fmaxl(_X: f64, _Y: f64) -> f64;
}
extern "C" {
pub fn fminl(_X: f64, _Y: f64) -> f64;
}
extern "C" {
pub fn ilogbl(_X: f64) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn lgammal(_X: f64) -> f64;
}
extern "C" {
pub fn llrintl(_X: f64) -> ::std::os::raw::c_longlong;
}
extern "C" {
pub fn llroundl(_X: f64) -> ::std::os::raw::c_longlong;
}
extern "C" {
pub fn log1pl(_X: f64) -> f64;
}
extern "C" {
pub fn log2l(_X: f64) -> f64;
}
extern "C" {
pub fn logbl(_X: f64) -> f64;
}
extern "C" {
pub fn lrintl(_X: f64) -> ::std::os::raw::c_long;
}
extern "C" {
pub fn lroundl(_X: f64) -> ::std::os::raw::c_long;
}
extern "C" {
pub fn nanl(_X: *const ::std::os::raw::c_char) -> f64;
}
extern "C" {
pub fn nearbyintl(_X: f64) -> f64;
}
extern "C" {
pub fn nextafterl(_X: f64, _Y: f64) -> f64;
}
extern "C" {
pub fn nexttowardl(_X: f64, _Y: f64) -> f64;
}
extern "C" {
pub fn remainderl(_X: f64, _Y: f64) -> f64;
}
extern "C" {
pub fn remquol(_X: f64, _Y: f64, _Z: *mut ::std::os::raw::c_int) -> f64;
}
extern "C" {
pub fn rintl(_X: f64) -> f64;
}
extern "C" {
pub fn roundl(_X: f64) -> f64;
}
extern "C" {
pub fn scalblnl(_X: f64, _Y: ::std::os::raw::c_long) -> f64;
}
extern "C" {
pub fn scalbnl(_X: f64, _Y: ::std::os::raw::c_int) -> f64;
}
extern "C" {
pub fn tgammal(_X: f64) -> f64;
}
extern "C" {
pub fn truncl(_X: f64) -> f64;
}
extern "C" {
pub static mut HUGE: f64;
}
extern "C" {
pub fn j0(_X: f64) -> f64;
}
extern "C" {
pub fn j1(_X: f64) -> f64;
}
extern "C" {
pub fn jn(_X: ::std::os::raw::c_int, _Y: f64) -> f64;
}
extern "C" {
pub fn y0(_X: f64) -> f64;
}
extern "C" {
pub fn y1(_X: f64) -> f64;
}
extern "C" {
pub fn yn(_X: ::std::os::raw::c_int, _Y: f64) -> f64;
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct tm {
pub tm_sec: ::std::os::raw::c_int,
pub tm_min: ::std::os::raw::c_int,
pub tm_hour: ::std::os::raw::c_int,
pub tm_mday: ::std::os::raw::c_int,
pub tm_mon: ::std::os::raw::c_int,
pub tm_year: ::std::os::raw::c_int,
pub tm_wday: ::std::os::raw::c_int,
pub tm_yday: ::std::os::raw::c_int,
pub tm_isdst: ::std::os::raw::c_int,
}
#[test]
fn bindgen_test_layout_tm() {
const UNINIT: ::std::mem::MaybeUninit<tm> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<tm>(),
36usize,
concat!("Size of: ", stringify!(tm))
);
assert_eq!(
::std::mem::align_of::<tm>(),
4usize,
concat!("Alignment of ", stringify!(tm))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).tm_sec) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(tm),
"::",
stringify!(tm_sec)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).tm_min) as usize - ptr as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(tm),
"::",
stringify!(tm_min)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).tm_hour) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(tm),
"::",
stringify!(tm_hour)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).tm_mday) as usize - ptr as usize },
12usize,
concat!(
"Offset of field: ",
stringify!(tm),
"::",
stringify!(tm_mday)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).tm_mon) as usize - ptr as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(tm),
"::",
stringify!(tm_mon)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).tm_year) as usize - ptr as usize },
20usize,
concat!(
"Offset of field: ",
stringify!(tm),
"::",
stringify!(tm_year)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).tm_wday) as usize - ptr as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(tm),
"::",
stringify!(tm_wday)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).tm_yday) as usize - ptr as usize },
28usize,
concat!(
"Offset of field: ",
stringify!(tm),
"::",
stringify!(tm_yday)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).tm_isdst) as usize - ptr as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(tm),
"::",
stringify!(tm_isdst)
)
);
}
extern "C" {
pub fn _wasctime(_Tm: *const tm) -> *mut u16;
}
extern "C" {
pub fn _wasctime_s(_Buffer: *mut u16, _SizeInWords: usize, _Tm: *const tm) -> errno_t;
}
extern "C" {
pub fn wcsftime(
_Buffer: *mut u16,
_SizeInWords: usize,
_Format: *const u16,
_Tm: *const tm,
) -> usize;
}
extern "C" {
pub fn _wcsftime_l(
_Buffer: *mut u16,
_SizeInWords: usize,
_Format: *const u16,
_Tm: *const tm,
_Locale: _locale_t,
) -> usize;
}
extern "C" {
pub fn _wctime32(_Time: *const __time32_t) -> *mut u16;
}
extern "C" {
pub fn _wctime32_s(_Buffer: *mut u16, _SizeInWords: usize, _Time: *const __time32_t)
-> errno_t;
}
extern "C" {
pub fn _wctime64(_Time: *const __time64_t) -> *mut u16;
}
extern "C" {
pub fn _wctime64_s(_Buffer: *mut u16, _SizeInWords: usize, _Time: *const __time64_t)
-> errno_t;
}
extern "C" {
pub fn _wstrdate_s(_Buffer: *mut u16, _SizeInWords: usize) -> errno_t;
}
extern "C" {
pub fn _wstrdate(_Buffer: *mut u16) -> *mut u16;
}
extern "C" {
pub fn _wstrtime_s(_Buffer: *mut u16, _SizeInWords: usize) -> errno_t;
}
extern "C" {
pub fn _wstrtime(_Buffer: *mut u16) -> *mut u16;
}
pub type clock_t = ::std::os::raw::c_long;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _timespec32 {
pub tv_sec: __time32_t,
pub tv_nsec: ::std::os::raw::c_long,
}
#[test]
fn bindgen_test_layout__timespec32() {
const UNINIT: ::std::mem::MaybeUninit<_timespec32> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<_timespec32>(),
8usize,
concat!("Size of: ", stringify!(_timespec32))
);
assert_eq!(
::std::mem::align_of::<_timespec32>(),
4usize,
concat!("Alignment of ", stringify!(_timespec32))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).tv_sec) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_timespec32),
"::",
stringify!(tv_sec)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).tv_nsec) as usize - ptr as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(_timespec32),
"::",
stringify!(tv_nsec)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _timespec64 {
pub tv_sec: __time64_t,
pub tv_nsec: ::std::os::raw::c_long,
}
#[test]
fn bindgen_test_layout__timespec64() {
const UNINIT: ::std::mem::MaybeUninit<_timespec64> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<_timespec64>(),
16usize,
concat!("Size of: ", stringify!(_timespec64))
);
assert_eq!(
::std::mem::align_of::<_timespec64>(),
8usize,
concat!("Alignment of ", stringify!(_timespec64))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).tv_sec) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_timespec64),
"::",
stringify!(tv_sec)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).tv_nsec) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(_timespec64),
"::",
stringify!(tv_nsec)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct timespec {
pub tv_sec: time_t,
pub tv_nsec: ::std::os::raw::c_long,
}
#[test]
fn bindgen_test_layout_timespec() {
const UNINIT: ::std::mem::MaybeUninit<timespec> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<timespec>(),
16usize,
concat!("Size of: ", stringify!(timespec))
);
assert_eq!(
::std::mem::align_of::<timespec>(),
8usize,
concat!("Alignment of ", stringify!(timespec))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).tv_sec) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(timespec),
"::",
stringify!(tv_sec)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).tv_nsec) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(timespec),
"::",
stringify!(tv_nsec)
)
);
}
extern "C" {
pub fn __daylight() -> *mut ::std::os::raw::c_int;
}
extern "C" {
pub fn __dstbias() -> *mut ::std::os::raw::c_long;
}
extern "C" {
pub fn __timezone() -> *mut ::std::os::raw::c_long;
}
extern "C" {
pub fn __tzname() -> *mut *mut ::std::os::raw::c_char;
}
extern "C" {
pub fn _get_daylight(_Daylight: *mut ::std::os::raw::c_int) -> errno_t;
}
extern "C" {
pub fn _get_dstbias(_DaylightSavingsBias: *mut ::std::os::raw::c_long) -> errno_t;
}
extern "C" {
pub fn _get_timezone(_TimeZone: *mut ::std::os::raw::c_long) -> errno_t;
}
extern "C" {
pub fn _get_tzname(
_ReturnValue: *mut usize,
_Buffer: *mut ::std::os::raw::c_char,
_SizeInBytes: usize,
_Index: ::std::os::raw::c_int,
) -> errno_t;
}
extern "C" {
pub fn asctime(_Tm: *const tm) -> *mut ::std::os::raw::c_char;
}
extern "C" {
pub fn asctime_s(
_Buffer: *mut ::std::os::raw::c_char,
_SizeInBytes: usize,
_Tm: *const tm,
) -> errno_t;
}
extern "C" {
pub fn clock() -> clock_t;
}
extern "C" {
pub fn _ctime32(_Time: *const __time32_t) -> *mut ::std::os::raw::c_char;
}
extern "C" {
pub fn _ctime32_s(
_Buffer: *mut ::std::os::raw::c_char,
_SizeInBytes: usize,
_Time: *const __time32_t,
) -> errno_t;
}
extern "C" {
pub fn _ctime64(_Time: *const __time64_t) -> *mut ::std::os::raw::c_char;
}
extern "C" {
pub fn _ctime64_s(
_Buffer: *mut ::std::os::raw::c_char,
_SizeInBytes: usize,
_Time: *const __time64_t,
) -> errno_t;
}
extern "C" {
pub fn _difftime32(_Time1: __time32_t, _Time2: __time32_t) -> f64;
}
extern "C" {
pub fn _difftime64(_Time1: __time64_t, _Time2: __time64_t) -> f64;
}
extern "C" {
pub fn _gmtime32(_Time: *const __time32_t) -> *mut tm;
}
extern "C" {
pub fn _gmtime32_s(_Tm: *mut tm, _Time: *const __time32_t) -> errno_t;
}
extern "C" {
pub fn _gmtime64(_Time: *const __time64_t) -> *mut tm;
}
extern "C" {
pub fn _gmtime64_s(_Tm: *mut tm, _Time: *const __time64_t) -> errno_t;
}
extern "C" {
pub fn _localtime32(_Time: *const __time32_t) -> *mut tm;
}
extern "C" {
pub fn _localtime32_s(_Tm: *mut tm, _Time: *const __time32_t) -> errno_t;
}
extern "C" {
pub fn _localtime64(_Time: *const __time64_t) -> *mut tm;
}
extern "C" {
pub fn _localtime64_s(_Tm: *mut tm, _Time: *const __time64_t) -> errno_t;
}
extern "C" {
pub fn _mkgmtime32(_Tm: *mut tm) -> __time32_t;
}
extern "C" {
pub fn _mkgmtime64(_Tm: *mut tm) -> __time64_t;
}
extern "C" {
pub fn _mktime32(_Tm: *mut tm) -> __time32_t;
}
extern "C" {
pub fn _mktime64(_Tm: *mut tm) -> __time64_t;
}
extern "C" {
pub fn strftime(
_Buffer: *mut ::std::os::raw::c_char,
_SizeInBytes: usize,
_Format: *const ::std::os::raw::c_char,
_Tm: *const tm,
) -> usize;
}
extern "C" {
pub fn _strftime_l(
_Buffer: *mut ::std::os::raw::c_char,
_MaxSize: usize,
_Format: *const ::std::os::raw::c_char,
_Tm: *const tm,
_Locale: _locale_t,
) -> usize;
}
extern "C" {
pub fn _strdate_s(_Buffer: *mut ::std::os::raw::c_char, _SizeInBytes: usize) -> errno_t;
}
extern "C" {
pub fn _strdate(_Buffer: *mut ::std::os::raw::c_char) -> *mut ::std::os::raw::c_char;
}
extern "C" {
pub fn _strtime_s(_Buffer: *mut ::std::os::raw::c_char, _SizeInBytes: usize) -> errno_t;
}
extern "C" {
pub fn _strtime(_Buffer: *mut ::std::os::raw::c_char) -> *mut ::std::os::raw::c_char;
}
extern "C" {
pub fn _time32(_Time: *mut __time32_t) -> __time32_t;
}
extern "C" {
pub fn _time64(_Time: *mut __time64_t) -> __time64_t;
}
extern "C" {
pub fn _timespec32_get(
_Ts: *mut _timespec32,
_Base: ::std::os::raw::c_int,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn _timespec64_get(
_Ts: *mut _timespec64,
_Base: ::std::os::raw::c_int,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn _tzset();
}
extern "C" {
pub fn _getsystime(_Tm: *mut tm) -> ::std::os::raw::c_uint;
}
extern "C" {
pub fn _setsystime(
_Tm: *mut tm,
_Milliseconds: ::std::os::raw::c_uint,
) -> ::std::os::raw::c_uint;
}
extern "C" {
pub fn tzset();
}
pub type dint64 = ::std::os::raw::c_longlong;
pub type duint64 = ::std::os::raw::c_ulonglong;
pub type dint32 = ::std::os::raw::c_int;
pub type duint32 = ::std::os::raw::c_uint;
pub type dint16 = ::std::os::raw::c_short;
pub type duint16 = ::std::os::raw::c_ushort;
pub type dint8 = ::std::os::raw::c_schar;
pub type duint8 = ::std::os::raw::c_uchar;
pub type dintptr = dint64;
pub type duintptr = duint64;
pub type ddiffint = dint64;
pub type dsizeint = duint64;
pub type dReal = f64;
pub type dTriIndex = duint32;
pub const dInfinity: dReal = ::std::f64::INFINITY;
pub type dMessageFunction = ::std::option::Option<
unsafe extern "C" fn(
errnum: ::std::os::raw::c_int,
msg: *const ::std::os::raw::c_char,
ap: va_list,
),
>;
extern "C" {
pub fn dSetErrorHandler(fn_: dMessageFunction);
}
extern "C" {
pub fn dSetDebugHandler(fn_: dMessageFunction);
}
extern "C" {
pub fn dSetMessageHandler(fn_: dMessageFunction);
}
extern "C" {
pub fn dGetErrorHandler() -> dMessageFunction;
}
extern "C" {
pub fn dGetDebugHandler() -> dMessageFunction;
}
extern "C" {
pub fn dGetMessageHandler() -> dMessageFunction;
}
extern "C" {
pub fn dError(num: ::std::os::raw::c_int, msg: *const ::std::os::raw::c_char, ...);
}
extern "C" {
pub fn dDebug(num: ::std::os::raw::c_int, msg: *const ::std::os::raw::c_char, ...);
}
extern "C" {
pub fn dMessage(num: ::std::os::raw::c_int, msg: *const ::std::os::raw::c_char, ...);
}
pub const dSpaceAxis_dSA__MIN: dSpaceAxis = 0;
pub const dSpaceAxis_dSA_X: dSpaceAxis = 0;
pub const dSpaceAxis_dSA_Y: dSpaceAxis = 1;
pub const dSpaceAxis_dSA_Z: dSpaceAxis = 2;
pub const dSpaceAxis_dSA__MAX: dSpaceAxis = 3;
pub type dSpaceAxis = ::std::os::raw::c_int;
pub const dMotionDynamics_dMD__MIN: dMotionDynamics = 0;
pub const dMotionDynamics_dMD_LINEAR: dMotionDynamics = 0;
pub const dMotionDynamics_dMD_ANGULAR: dMotionDynamics = 1;
pub const dMotionDynamics_dMD__MAX: dMotionDynamics = 2;
pub type dMotionDynamics = ::std::os::raw::c_int;
pub const dDynamicsAxis_dDA__MIN: dDynamicsAxis = 0;
pub const dDynamicsAxis_dDA__L_MIN: dDynamicsAxis = 0;
pub const dDynamicsAxis_dDA_LX: dDynamicsAxis = 0;
pub const dDynamicsAxis_dDA_LY: dDynamicsAxis = 1;
pub const dDynamicsAxis_dDA_LZ: dDynamicsAxis = 2;
pub const dDynamicsAxis_dDA__L_MAX: dDynamicsAxis = 3;
pub const dDynamicsAxis_dDA__A_MIN: dDynamicsAxis = 3;
pub const dDynamicsAxis_dDA_AX: dDynamicsAxis = 3;
pub const dDynamicsAxis_dDA_AY: dDynamicsAxis = 4;
pub const dDynamicsAxis_dDA_AZ: dDynamicsAxis = 5;
pub const dDynamicsAxis_dDA__A_MAX: dDynamicsAxis = 6;
pub const dDynamicsAxis_dDA__MAX: dDynamicsAxis = 6;
pub type dDynamicsAxis = ::std::os::raw::c_int;
pub const dVec3Element_dV3E__MIN: dVec3Element = 0;
pub const dVec3Element_dV3E__AXES_MIN: dVec3Element = 0;
pub const dVec3Element_dV3E_X: dVec3Element = 0;
pub const dVec3Element_dV3E_Y: dVec3Element = 1;
pub const dVec3Element_dV3E_Z: dVec3Element = 2;
pub const dVec3Element_dV3E__AXES_MAX: dVec3Element = 3;
pub const dVec3Element_dV3E_PAD: dVec3Element = 3;
pub const dVec3Element_dV3E__MAX: dVec3Element = 4;
pub const dVec3Element_dV3E__AXES_COUNT: dVec3Element = 3;
pub type dVec3Element = ::std::os::raw::c_int;
pub const dVec4Element_dV4E__MIN: dVec4Element = 0;
pub const dVec4Element_dV4E_X: dVec4Element = 0;
pub const dVec4Element_dV4E_Y: dVec4Element = 1;
pub const dVec4Element_dV4E_Z: dVec4Element = 2;
pub const dVec4Element_dV4E_O: dVec4Element = 3;
pub const dVec4Element_dV4E__MAX: dVec4Element = 4;
pub type dVec4Element = ::std::os::raw::c_int;
pub const dMat3Element_dM3E__MIN: dMat3Element = 0;
pub const dMat3Element_dM3E__X_MIN: dMat3Element = 0;
pub const dMat3Element_dM3E__X_AXES_MIN: dMat3Element = 0;
pub const dMat3Element_dM3E_XX: dMat3Element = 0;
pub const dMat3Element_dM3E_XY: dMat3Element = 1;
pub const dMat3Element_dM3E_XZ: dMat3Element = 2;
pub const dMat3Element_dM3E__X_AXES_MAX: dMat3Element = 3;
pub const dMat3Element_dM3E_XPAD: dMat3Element = 3;
pub const dMat3Element_dM3E__X_MAX: dMat3Element = 4;
pub const dMat3Element_dM3E__Y_MIN: dMat3Element = 4;
pub const dMat3Element_dM3E__Y_AXES_MIN: dMat3Element = 4;
pub const dMat3Element_dM3E_YX: dMat3Element = 4;
pub const dMat3Element_dM3E_YY: dMat3Element = 5;
pub const dMat3Element_dM3E_YZ: dMat3Element = 6;
pub const dMat3Element_dM3E__Y_AXES_MAX: dMat3Element = 7;
pub const dMat3Element_dM3E_YPAD: dMat3Element = 7;
pub const dMat3Element_dM3E__Y_MAX: dMat3Element = 8;
pub const dMat3Element_dM3E__Z_MIN: dMat3Element = 8;
pub const dMat3Element_dM3E__Z_AXES_MIN: dMat3Element = 8;
pub const dMat3Element_dM3E_ZX: dMat3Element = 8;
pub const dMat3Element_dM3E_ZY: dMat3Element = 9;
pub const dMat3Element_dM3E_ZZ: dMat3Element = 10;
pub const dMat3Element_dM3E__Z_AXES_MAX: dMat3Element = 11;
pub const dMat3Element_dM3E_ZPAD: dMat3Element = 11;
pub const dMat3Element_dM3E__Z_MAX: dMat3Element = 12;
pub const dMat3Element_dM3E__MAX: dMat3Element = 12;
pub type dMat3Element = ::std::os::raw::c_int;
pub const dMat4Element_dM4E__MIN: dMat4Element = 0;
pub const dMat4Element_dM4E__X_MIN: dMat4Element = 0;
pub const dMat4Element_dM4E_XX: dMat4Element = 0;
pub const dMat4Element_dM4E_XY: dMat4Element = 1;
pub const dMat4Element_dM4E_XZ: dMat4Element = 2;
pub const dMat4Element_dM4E_XO: dMat4Element = 3;
pub const dMat4Element_dM4E__X_MAX: dMat4Element = 4;
pub const dMat4Element_dM4E__Y_MIN: dMat4Element = 4;
pub const dMat4Element_dM4E_YX: dMat4Element = 4;
pub const dMat4Element_dM4E_YY: dMat4Element = 5;
pub const dMat4Element_dM4E_YZ: dMat4Element = 6;
pub const dMat4Element_dM4E_YO: dMat4Element = 7;
pub const dMat4Element_dM4E__Y_MAX: dMat4Element = 8;
pub const dMat4Element_dM4E__Z_MIN: dMat4Element = 8;
pub const dMat4Element_dM4E_ZX: dMat4Element = 8;
pub const dMat4Element_dM4E_ZY: dMat4Element = 9;
pub const dMat4Element_dM4E_ZZ: dMat4Element = 10;
pub const dMat4Element_dM4E_ZO: dMat4Element = 11;
pub const dMat4Element_dM4E__Z_MAX: dMat4Element = 12;
pub const dMat4Element_dM4E__O_MIN: dMat4Element = 12;
pub const dMat4Element_dM4E_OX: dMat4Element = 12;
pub const dMat4Element_dM4E_OY: dMat4Element = 13;
pub const dMat4Element_dM4E_OZ: dMat4Element = 14;
pub const dMat4Element_dM4E_OO: dMat4Element = 15;
pub const dMat4Element_dM4E__O_MAX: dMat4Element = 16;
pub const dMat4Element_dM4E__MAX: dMat4Element = 16;
pub type dMat4Element = ::std::os::raw::c_int;
pub const dQuatElement_dQUE__MIN: dQuatElement = 0;
pub const dQuatElement_dQUE_R: dQuatElement = 0;
pub const dQuatElement_dQUE__AXIS_MIN: dQuatElement = 1;
pub const dQuatElement_dQUE_I: dQuatElement = 1;
pub const dQuatElement_dQUE_J: dQuatElement = 2;
pub const dQuatElement_dQUE_K: dQuatElement = 3;
pub const dQuatElement_dQUE__AXIS_MAX: dQuatElement = 4;
pub const dQuatElement_dQUE__MAX: dQuatElement = 4;
pub type dQuatElement = ::std::os::raw::c_int;
pub type dVector3 = [dReal; 4usize];
pub type dVector4 = [dReal; 4usize];
pub type dMatrix3 = [dReal; 12usize];
pub type dMatrix4 = [dReal; 16usize];
pub type dMatrix6 = [dReal; 48usize];
pub type dQuaternion = [dReal; 4usize];
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct dxWorld {
_unused: [u8; 0],
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct dxSpace {
_unused: [u8; 0],
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct dxBody {
_unused: [u8; 0],
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct dxGeom {
_unused: [u8; 0],
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct dxJoint {
_unused: [u8; 0],
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct dxJointGroup {
_unused: [u8; 0],
}
pub type dWorldID = *mut dxWorld;
pub type dSpaceID = *mut dxSpace;
pub type dBodyID = *mut dxBody;
pub type dGeomID = *mut dxGeom;
pub type dJointID = *mut dxJoint;
pub type dJointGroupID = *mut dxJointGroup;
pub const d_ERR_UNKNOWN: _bindgen_ty_1 = 0;
pub const d_ERR_IASSERT: _bindgen_ty_1 = 1;
pub const d_ERR_UASSERT: _bindgen_ty_1 = 2;
pub const d_ERR_LCP: _bindgen_ty_1 = 3;
pub type _bindgen_ty_1 = ::std::os::raw::c_int;
pub const dJointType_dJointTypeNone: dJointType = 0;
pub const dJointType_dJointTypeBall: dJointType = 1;
pub const dJointType_dJointTypeHinge: dJointType = 2;
pub const dJointType_dJointTypeSlider: dJointType = 3;
pub const dJointType_dJointTypeContact: dJointType = 4;
pub const dJointType_dJointTypeUniversal: dJointType = 5;
pub const dJointType_dJointTypeHinge2: dJointType = 6;
pub const dJointType_dJointTypeFixed: dJointType = 7;
pub const dJointType_dJointTypeNull: dJointType = 8;
pub const dJointType_dJointTypeAMotor: dJointType = 9;
pub const dJointType_dJointTypeLMotor: dJointType = 10;
pub const dJointType_dJointTypePlane2D: dJointType = 11;
pub const dJointType_dJointTypePR: dJointType = 12;
pub const dJointType_dJointTypePU: dJointType = 13;
pub const dJointType_dJointTypePiston: dJointType = 14;
pub const dJointType_dJointTypeDBall: dJointType = 15;
pub const dJointType_dJointTypeDHinge: dJointType = 16;
pub const dJointType_dJointTypeTransmission: dJointType = 17;
pub type dJointType = ::std::os::raw::c_int;
pub const dParamLoStop: _bindgen_ty_2 = 0;
pub const dParamHiStop: _bindgen_ty_2 = 1;
pub const dParamVel: _bindgen_ty_2 = 2;
pub const dParamLoVel: _bindgen_ty_2 = 3;
pub const dParamHiVel: _bindgen_ty_2 = 4;
pub const dParamFMax: _bindgen_ty_2 = 5;
pub const dParamFudgeFactor: _bindgen_ty_2 = 6;
pub const dParamBounce: _bindgen_ty_2 = 7;
pub const dParamCFM: _bindgen_ty_2 = 8;
pub const dParamStopERP: _bindgen_ty_2 = 9;
pub const dParamStopCFM: _bindgen_ty_2 = 10;
pub const dParamSuspensionERP: _bindgen_ty_2 = 11;
pub const dParamSuspensionCFM: _bindgen_ty_2 = 12;
pub const dParamERP: _bindgen_ty_2 = 13;
pub const dParamsInGroup: _bindgen_ty_2 = 14;
pub const dParamGroup1: _bindgen_ty_2 = 0;
pub const dParamLoStop1: _bindgen_ty_2 = 0;
pub const dParamHiStop1: _bindgen_ty_2 = 1;
pub const dParamVel1: _bindgen_ty_2 = 2;
pub const dParamLoVel1: _bindgen_ty_2 = 3;
pub const dParamHiVel1: _bindgen_ty_2 = 4;
pub const dParamFMax1: _bindgen_ty_2 = 5;
pub const dParamFudgeFactor1: _bindgen_ty_2 = 6;
pub const dParamBounce1: _bindgen_ty_2 = 7;
pub const dParamCFM1: _bindgen_ty_2 = 8;
pub const dParamStopERP1: _bindgen_ty_2 = 9;
pub const dParamStopCFM1: _bindgen_ty_2 = 10;
pub const dParamSuspensionERP1: _bindgen_ty_2 = 11;
pub const dParamSuspensionCFM1: _bindgen_ty_2 = 12;
pub const dParamERP1: _bindgen_ty_2 = 13;
pub const dParamGroup2: _bindgen_ty_2 = 256;
pub const dParamLoStop2: _bindgen_ty_2 = 256;
pub const dParamHiStop2: _bindgen_ty_2 = 257;
pub const dParamVel2: _bindgen_ty_2 = 258;
pub const dParamLoVel2: _bindgen_ty_2 = 259;
pub const dParamHiVel2: _bindgen_ty_2 = 260;
pub const dParamFMax2: _bindgen_ty_2 = 261;
pub const dParamFudgeFactor2: _bindgen_ty_2 = 262;
pub const dParamBounce2: _bindgen_ty_2 = 263;
pub const dParamCFM2: _bindgen_ty_2 = 264;
pub const dParamStopERP2: _bindgen_ty_2 = 265;
pub const dParamStopCFM2: _bindgen_ty_2 = 266;
pub const dParamSuspensionERP2: _bindgen_ty_2 = 267;
pub const dParamSuspensionCFM2: _bindgen_ty_2 = 268;
pub const dParamERP2: _bindgen_ty_2 = 269;
pub const dParamGroup3: _bindgen_ty_2 = 512;
pub const dParamLoStop3: _bindgen_ty_2 = 512;
pub const dParamHiStop3: _bindgen_ty_2 = 513;
pub const dParamVel3: _bindgen_ty_2 = 514;
pub const dParamLoVel3: _bindgen_ty_2 = 515;
pub const dParamHiVel3: _bindgen_ty_2 = 516;
pub const dParamFMax3: _bindgen_ty_2 = 517;
pub const dParamFudgeFactor3: _bindgen_ty_2 = 518;
pub const dParamBounce3: _bindgen_ty_2 = 519;
pub const dParamCFM3: _bindgen_ty_2 = 520;
pub const dParamStopERP3: _bindgen_ty_2 = 521;
pub const dParamStopCFM3: _bindgen_ty_2 = 522;
pub const dParamSuspensionERP3: _bindgen_ty_2 = 523;
pub const dParamSuspensionCFM3: _bindgen_ty_2 = 524;
pub const dParamERP3: _bindgen_ty_2 = 525;
pub const dParamGroup: _bindgen_ty_2 = 256;
pub type _bindgen_ty_2 = ::std::os::raw::c_int;
pub const dAMotorUser: _bindgen_ty_3 = 0;
pub const dAMotorEuler: _bindgen_ty_3 = 1;
pub type _bindgen_ty_3 = ::std::os::raw::c_int;
pub const dTransmissionParallelAxes: _bindgen_ty_4 = 0;
pub const dTransmissionIntersectingAxes: _bindgen_ty_4 = 1;
pub const dTransmissionChainDrive: _bindgen_ty_4 = 2;
pub type _bindgen_ty_4 = ::std::os::raw::c_int;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct dJointFeedback {
pub f1: dVector3,
pub t1: dVector3,
pub f2: dVector3,
pub t2: dVector3,
}
#[test]
fn bindgen_test_layout_dJointFeedback() {
const UNINIT: ::std::mem::MaybeUninit<dJointFeedback> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<dJointFeedback>(),
128usize,
concat!("Size of: ", stringify!(dJointFeedback))
);
assert_eq!(
::std::mem::align_of::<dJointFeedback>(),
8usize,
concat!("Alignment of ", stringify!(dJointFeedback))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).f1) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(dJointFeedback),
"::",
stringify!(f1)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).t1) as usize - ptr as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(dJointFeedback),
"::",
stringify!(t1)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).f2) as usize - ptr as usize },
64usize,
concat!(
"Offset of field: ",
stringify!(dJointFeedback),
"::",
stringify!(f2)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).t2) as usize - ptr as usize },
96usize,
concat!(
"Offset of field: ",
stringify!(dJointFeedback),
"::",
stringify!(t2)
)
);
}
extern "C" {
pub fn dGeomMoved(arg1: dGeomID);
}
extern "C" {
pub fn dGeomGetBodyNext(arg1: dGeomID) -> dGeomID;
}
extern "C" {
pub fn dGetConfiguration() -> *const ::std::os::raw::c_char;
}
extern "C" {
pub fn dCheckConfiguration(token: *const ::std::os::raw::c_char) -> ::std::os::raw::c_int;
}
pub const dInitODEFlags_dInitFlagManualThreadCleanup: dInitODEFlags = 1;
pub type dInitODEFlags = ::std::os::raw::c_int;
extern "C" {
pub fn dInitODE();
}
extern "C" {
pub fn dInitODE2(uiInitFlags: ::std::os::raw::c_uint) -> ::std::os::raw::c_int;
}
pub const dAllocateODEDataFlags_dAllocateFlagBasicData: dAllocateODEDataFlags = 0;
pub const dAllocateODEDataFlags_dAllocateFlagCollisionData: dAllocateODEDataFlags = 1;
pub const dAllocateODEDataFlags_dAllocateMaskAll: dAllocateODEDataFlags = -1;
pub type dAllocateODEDataFlags = ::std::os::raw::c_int;
extern "C" {
pub fn dAllocateODEDataForThread(
uiAllocateFlags: ::std::os::raw::c_uint,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn dCleanupODEAllDataForThread();
}
extern "C" {
pub fn dCloseODE();
}
pub const dContactMu2: _bindgen_ty_5 = 1;
pub const dContactAxisDep: _bindgen_ty_5 = 1;
pub const dContactFDir1: _bindgen_ty_5 = 2;
pub const dContactBounce: _bindgen_ty_5 = 4;
pub const dContactSoftERP: _bindgen_ty_5 = 8;
pub const dContactSoftCFM: _bindgen_ty_5 = 16;
pub const dContactMotion1: _bindgen_ty_5 = 32;
pub const dContactMotion2: _bindgen_ty_5 = 64;
pub const dContactMotionN: _bindgen_ty_5 = 128;
pub const dContactSlip1: _bindgen_ty_5 = 256;
pub const dContactSlip2: _bindgen_ty_5 = 512;
pub const dContactRolling: _bindgen_ty_5 = 1024;
pub const dContactApprox0: _bindgen_ty_5 = 0;
pub const dContactApprox1_1: _bindgen_ty_5 = 4096;
pub const dContactApprox1_2: _bindgen_ty_5 = 8192;
pub const dContactApprox1_N: _bindgen_ty_5 = 16384;
pub const dContactApprox1: _bindgen_ty_5 = 28672;
pub type _bindgen_ty_5 = ::std::os::raw::c_int;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct dSurfaceParameters {
pub mode: ::std::os::raw::c_int,
pub mu: dReal,
pub mu2: dReal,
pub rho: dReal,
pub rho2: dReal,
pub rhoN: dReal,
pub bounce: dReal,
pub bounce_vel: dReal,
pub soft_erp: dReal,
pub soft_cfm: dReal,
pub motion1: dReal,
pub motion2: dReal,
pub motionN: dReal,
pub slip1: dReal,
pub slip2: dReal,
}
#[test]
fn bindgen_test_layout_dSurfaceParameters() {
const UNINIT: ::std::mem::MaybeUninit<dSurfaceParameters> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<dSurfaceParameters>(),
120usize,
concat!("Size of: ", stringify!(dSurfaceParameters))
);
assert_eq!(
::std::mem::align_of::<dSurfaceParameters>(),
8usize,
concat!("Alignment of ", stringify!(dSurfaceParameters))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).mode) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(dSurfaceParameters),
"::",
stringify!(mode)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).mu) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(dSurfaceParameters),
"::",
stringify!(mu)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).mu2) as usize - ptr as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(dSurfaceParameters),
"::",
stringify!(mu2)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).rho) as usize - ptr as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(dSurfaceParameters),
"::",
stringify!(rho)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).rho2) as usize - ptr as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(dSurfaceParameters),
"::",
stringify!(rho2)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).rhoN) as usize - ptr as usize },
40usize,
concat!(
"Offset of field: ",
stringify!(dSurfaceParameters),
"::",
stringify!(rhoN)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).bounce) as usize - ptr as usize },
48usize,
concat!(
"Offset of field: ",
stringify!(dSurfaceParameters),
"::",
stringify!(bounce)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).bounce_vel) as usize - ptr as usize },
56usize,
concat!(
"Offset of field: ",
stringify!(dSurfaceParameters),
"::",
stringify!(bounce_vel)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).soft_erp) as usize - ptr as usize },
64usize,
concat!(
"Offset of field: ",
stringify!(dSurfaceParameters),
"::",
stringify!(soft_erp)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).soft_cfm) as usize - ptr as usize },
72usize,
concat!(
"Offset of field: ",
stringify!(dSurfaceParameters),
"::",
stringify!(soft_cfm)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).motion1) as usize - ptr as usize },
80usize,
concat!(
"Offset of field: ",
stringify!(dSurfaceParameters),
"::",
stringify!(motion1)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).motion2) as usize - ptr as usize },
88usize,
concat!(
"Offset of field: ",
stringify!(dSurfaceParameters),
"::",
stringify!(motion2)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).motionN) as usize - ptr as usize },
96usize,
concat!(
"Offset of field: ",
stringify!(dSurfaceParameters),
"::",
stringify!(motionN)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).slip1) as usize - ptr as usize },
104usize,
concat!(
"Offset of field: ",
stringify!(dSurfaceParameters),
"::",
stringify!(slip1)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).slip2) as usize - ptr as usize },
112usize,
concat!(
"Offset of field: ",
stringify!(dSurfaceParameters),
"::",
stringify!(slip2)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct dContactGeom {
pub pos: dVector3,
pub normal: dVector3,
pub depth: dReal,
pub g1: dGeomID,
pub g2: dGeomID,
pub side1: ::std::os::raw::c_int,
pub side2: ::std::os::raw::c_int,
}
#[test]
fn bindgen_test_layout_dContactGeom() {
const UNINIT: ::std::mem::MaybeUninit<dContactGeom> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<dContactGeom>(),
96usize,
concat!("Size of: ", stringify!(dContactGeom))
);
assert_eq!(
::std::mem::align_of::<dContactGeom>(),
8usize,
concat!("Alignment of ", stringify!(dContactGeom))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).pos) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(dContactGeom),
"::",
stringify!(pos)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).normal) as usize - ptr as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(dContactGeom),
"::",
stringify!(normal)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).depth) as usize - ptr as usize },
64usize,
concat!(
"Offset of field: ",
stringify!(dContactGeom),
"::",
stringify!(depth)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).g1) as usize - ptr as usize },
72usize,
concat!(
"Offset of field: ",
stringify!(dContactGeom),
"::",
stringify!(g1)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).g2) as usize - ptr as usize },
80usize,
concat!(
"Offset of field: ",
stringify!(dContactGeom),
"::",
stringify!(g2)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).side1) as usize - ptr as usize },
88usize,
concat!(
"Offset of field: ",
stringify!(dContactGeom),
"::",
stringify!(side1)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).side2) as usize - ptr as usize },
92usize,
concat!(
"Offset of field: ",
stringify!(dContactGeom),
"::",
stringify!(side2)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct dContact {
pub surface: dSurfaceParameters,
pub geom: dContactGeom,
pub fdir1: dVector3,
}
#[test]
fn bindgen_test_layout_dContact() {
const UNINIT: ::std::mem::MaybeUninit<dContact> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<dContact>(),
248usize,
concat!("Size of: ", stringify!(dContact))
);
assert_eq!(
::std::mem::align_of::<dContact>(),
8usize,
concat!("Alignment of ", stringify!(dContact))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).surface) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(dContact),
"::",
stringify!(surface)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).geom) as usize - ptr as usize },
120usize,
concat!(
"Offset of field: ",
stringify!(dContact),
"::",
stringify!(geom)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).fdir1) as usize - ptr as usize },
216usize,
concat!(
"Offset of field: ",
stringify!(dContact),
"::",
stringify!(fdir1)
)
);
}
pub type dAllocFunction =
::std::option::Option<unsafe extern "C" fn(size: dsizeint) -> *mut ::std::os::raw::c_void>;
pub type dReallocFunction = ::std::option::Option<
unsafe extern "C" fn(
ptr: *mut ::std::os::raw::c_void,
oldsize: dsizeint,
newsize: dsizeint,
) -> *mut ::std::os::raw::c_void,
>;
pub type dFreeFunction =
::std::option::Option<unsafe extern "C" fn(ptr: *mut ::std::os::raw::c_void, size: dsizeint)>;
extern "C" {
pub fn dSetAllocHandler(fn_: dAllocFunction);
}
extern "C" {
pub fn dSetReallocHandler(fn_: dReallocFunction);
}
extern "C" {
pub fn dSetFreeHandler(fn_: dFreeFunction);
}
extern "C" {
pub fn dGetAllocHandler() -> dAllocFunction;
}
extern "C" {
pub fn dGetReallocHandler() -> dReallocFunction;
}
extern "C" {
pub fn dGetFreeHandler() -> dFreeFunction;
}
extern "C" {
pub fn dAlloc(size: dsizeint) -> *mut ::std::os::raw::c_void;
}
extern "C" {
pub fn dRealloc(
ptr: *mut ::std::os::raw::c_void,
oldsize: dsizeint,
newsize: dsizeint,
) -> *mut ::std::os::raw::c_void;
}
extern "C" {
pub fn dFree(ptr: *mut ::std::os::raw::c_void, size: dsizeint);
}
extern "C" {
pub fn dSafeNormalize3(a: *mut dReal) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn dSafeNormalize4(a: *mut dReal) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn dNormalize3(a: *mut dReal);
}
extern "C" {
pub fn dNormalize4(a: *mut dReal);
}
extern "C" {
pub fn dPlaneSpace(n: *mut dReal, p: *mut dReal, q: *mut dReal);
}
extern "C" {
pub fn dOrthogonalizeR(m: *mut dReal) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn dSetZero(a: *mut dReal, n: ::std::os::raw::c_int);
}
extern "C" {
pub fn dSetValue(a: *mut dReal, n: ::std::os::raw::c_int, value: dReal);
}
extern "C" {
pub fn dDot(a: *const dReal, b: *const dReal, n: ::std::os::raw::c_int) -> dReal;
}
extern "C" {
pub fn dMultiply0(
A: *mut dReal,
B: *const dReal,
C: *const dReal,
p: ::std::os::raw::c_int,
q: ::std::os::raw::c_int,
r: ::std::os::raw::c_int,
);
}
extern "C" {
pub fn dMultiply1(
A: *mut dReal,
B: *const dReal,
C: *const dReal,
p: ::std::os::raw::c_int,
q: ::std::os::raw::c_int,
r: ::std::os::raw::c_int,
);
}
extern "C" {
pub fn dMultiply2(
A: *mut dReal,
B: *const dReal,
C: *const dReal,
p: ::std::os::raw::c_int,
q: ::std::os::raw::c_int,
r: ::std::os::raw::c_int,
);
}
extern "C" {
pub fn dFactorCholesky(A: *mut dReal, n: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn dSolveCholesky(L: *const dReal, b: *mut dReal, n: ::std::os::raw::c_int);
}
extern "C" {
pub fn dInvertPDMatrix(
A: *const dReal,
Ainv: *mut dReal,
n: ::std::os::raw::c_int,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn dIsPositiveDefinite(A: *const dReal, n: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn dFactorLDLT(
A: *mut dReal,
d: *mut dReal,
n: ::std::os::raw::c_int,
nskip: ::std::os::raw::c_int,
);
}
extern "C" {
pub fn dSolveL1(
L: *const dReal,
b: *mut dReal,
n: ::std::os::raw::c_int,
nskip: ::std::os::raw::c_int,
);
}
extern "C" {
pub fn dSolveL1T(
L: *const dReal,
b: *mut dReal,
n: ::std::os::raw::c_int,
nskip: ::std::os::raw::c_int,
);
}
extern "C" {
pub fn dScaleVector(a: *mut dReal, d: *const dReal, n: ::std::os::raw::c_int);
}
extern "C" {
pub fn dVectorScale(a: *mut dReal, d: *const dReal, n: ::std::os::raw::c_int);
}
extern "C" {
pub fn dSolveLDLT(
L: *const dReal,
d: *const dReal,
b: *mut dReal,
n: ::std::os::raw::c_int,
nskip: ::std::os::raw::c_int,
);
}
extern "C" {
pub fn dLDLTAddTL(
L: *mut dReal,
d: *mut dReal,
a: *const dReal,
n: ::std::os::raw::c_int,
nskip: ::std::os::raw::c_int,
);
}
extern "C" {
pub fn dLDLTRemove(
A: *mut *mut dReal,
p: *const ::std::os::raw::c_int,
L: *mut dReal,
d: *mut dReal,
n1: ::std::os::raw::c_int,
n2: ::std::os::raw::c_int,
r: ::std::os::raw::c_int,
nskip: ::std::os::raw::c_int,
);
}
extern "C" {
pub fn dRemoveRowCol(
A: *mut dReal,
n: ::std::os::raw::c_int,
nskip: ::std::os::raw::c_int,
r: ::std::os::raw::c_int,
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct dxThreadingImplementation {
_unused: [u8; 0],
}
pub type dThreadingImplementationID = *mut dxThreadingImplementation;
pub type dmutexindex_t = ::std::os::raw::c_uint;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct dxMutexGroup {
_unused: [u8; 0],
}
pub type dMutexGroupID = *mut dxMutexGroup;
pub type dMutexGroupAllocFunction = ::std::option::Option<
unsafe extern "C" fn(
impl_: dThreadingImplementationID,
Mutex_count: dmutexindex_t,
Mutex_names_ptr: *const *const ::std::os::raw::c_char,
) -> dMutexGroupID,
>;
pub type dMutexGroupFreeFunction = ::std::option::Option<
unsafe extern "C" fn(impl_: dThreadingImplementationID, mutex_group: dMutexGroupID),
>;
pub type dMutexGroupMutexLockFunction = ::std::option::Option<
unsafe extern "C" fn(
impl_: dThreadingImplementationID,
mutex_group: dMutexGroupID,
mutex_index: dmutexindex_t,
),
>;
pub type dMutexGroupMutexUnlockFunction = ::std::option::Option<
unsafe extern "C" fn(
impl_: dThreadingImplementationID,
mutex_group: dMutexGroupID,
mutex_index: dmutexindex_t,
),
>;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct dxCallReleasee {
_unused: [u8; 0],
}
pub type dCallReleaseeID = *mut dxCallReleasee;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct dxCallWait {
_unused: [u8; 0],
}
pub type dCallWaitID = *mut dxCallWait;
pub type ddependencycount_t = dsizeint;
pub type ddependencychange_t = ddiffint;
pub type dcallindex_t = dsizeint;
pub type dThreadedCallFunction = ::std::option::Option<
unsafe extern "C" fn(
call_context: *mut ::std::os::raw::c_void,
instance_index: dcallindex_t,
this_releasee: dCallReleaseeID,
) -> ::std::os::raw::c_int,
>;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct dxThreadedWaitTime {
pub wait_sec: time_t,
pub wait_nsec: ::std::os::raw::c_ulong,
}
#[test]
fn bindgen_test_layout_dxThreadedWaitTime() {
const UNINIT: ::std::mem::MaybeUninit<dxThreadedWaitTime> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<dxThreadedWaitTime>(),
16usize,
concat!("Size of: ", stringify!(dxThreadedWaitTime))
);
assert_eq!(
::std::mem::align_of::<dxThreadedWaitTime>(),
8usize,
concat!("Alignment of ", stringify!(dxThreadedWaitTime))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).wait_sec) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(dxThreadedWaitTime),
"::",
stringify!(wait_sec)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).wait_nsec) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(dxThreadedWaitTime),
"::",
stringify!(wait_nsec)
)
);
}
pub type dThreadedWaitTime = dxThreadedWaitTime;
pub type dThreadedCallWaitAllocFunction =
::std::option::Option<unsafe extern "C" fn(impl_: dThreadingImplementationID) -> dCallWaitID>;
pub type dThreadedCallWaitResetFunction = ::std::option::Option<
unsafe extern "C" fn(impl_: dThreadingImplementationID, call_wait: dCallWaitID),
>;
pub type dThreadedCallWaitFreeFunction = ::std::option::Option<
unsafe extern "C" fn(impl_: dThreadingImplementationID, call_wait: dCallWaitID),
>;
pub type dThreadedCallPostFunction = ::std::option::Option<
unsafe extern "C" fn(
impl_: dThreadingImplementationID,
out_summary_fault: *mut ::std::os::raw::c_int,
out_post_releasee: *mut dCallReleaseeID,
dependencies_count: ddependencycount_t,
dependent_releasee: dCallReleaseeID,
call_wait: dCallWaitID,
call_func: dThreadedCallFunction,
call_context: *mut ::std::os::raw::c_void,
instance_index: dcallindex_t,
call_name: *const ::std::os::raw::c_char,
),
>;
pub type dThreadedCallDependenciesCountAlterFunction = ::std::option::Option<
unsafe extern "C" fn(
impl_: dThreadingImplementationID,
target_releasee: dCallReleaseeID,
dependencies_count_change: ddependencychange_t,
),
>;
pub type dThreadedCallWaitFunction = ::std::option::Option<
unsafe extern "C" fn(
impl_: dThreadingImplementationID,
out_wait_status: *mut ::std::os::raw::c_int,
call_wait: dCallWaitID,
timeout_time_ptr: *const dThreadedWaitTime,
wait_name: *const ::std::os::raw::c_char,
),
>;
pub type dThreadingImplThreadCountRetrieveFunction = ::std::option::Option<
unsafe extern "C" fn(impl_: dThreadingImplementationID) -> ::std::os::raw::c_uint,
>;
pub type dThreadingImplResourcesForCallsPreallocateFunction = ::std::option::Option<
unsafe extern "C" fn(
impl_: dThreadingImplementationID,
max_simultaneous_calls_estimate: ddependencycount_t,
) -> ::std::os::raw::c_int,
>;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct dxThreadingFunctionsInfo {
pub struct_size: ::std::os::raw::c_uint,
pub alloc_mutex_group: dMutexGroupAllocFunction,
pub free_mutex_group: dMutexGroupFreeFunction,
pub lock_group_mutex: dMutexGroupMutexLockFunction,
pub unlock_group_mutex: dMutexGroupMutexUnlockFunction,
pub alloc_call_wait: dThreadedCallWaitAllocFunction,
pub reset_call_wait: dThreadedCallWaitResetFunction,
pub free_call_wait: dThreadedCallWaitFreeFunction,
pub post_call: dThreadedCallPostFunction,
pub alter_call_dependencies_count: dThreadedCallDependenciesCountAlterFunction,
pub wait_call: dThreadedCallWaitFunction,
pub retrieve_thread_count: dThreadingImplThreadCountRetrieveFunction,
pub preallocate_resources_for_calls: dThreadingImplResourcesForCallsPreallocateFunction,
}
#[test]
fn bindgen_test_layout_dxThreadingFunctionsInfo() {
const UNINIT: ::std::mem::MaybeUninit<dxThreadingFunctionsInfo> =
::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<dxThreadingFunctionsInfo>(),
104usize,
concat!("Size of: ", stringify!(dxThreadingFunctionsInfo))
);
assert_eq!(
::std::mem::align_of::<dxThreadingFunctionsInfo>(),
8usize,
concat!("Alignment of ", stringify!(dxThreadingFunctionsInfo))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).struct_size) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(dxThreadingFunctionsInfo),
"::",
stringify!(struct_size)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).alloc_mutex_group) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(dxThreadingFunctionsInfo),
"::",
stringify!(alloc_mutex_group)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).free_mutex_group) as usize - ptr as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(dxThreadingFunctionsInfo),
"::",
stringify!(free_mutex_group)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).lock_group_mutex) as usize - ptr as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(dxThreadingFunctionsInfo),
"::",
stringify!(lock_group_mutex)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).unlock_group_mutex) as usize - ptr as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(dxThreadingFunctionsInfo),
"::",
stringify!(unlock_group_mutex)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).alloc_call_wait) as usize - ptr as usize },
40usize,
concat!(
"Offset of field: ",
stringify!(dxThreadingFunctionsInfo),
"::",
stringify!(alloc_call_wait)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).reset_call_wait) as usize - ptr as usize },
48usize,
concat!(
"Offset of field: ",
stringify!(dxThreadingFunctionsInfo),
"::",
stringify!(reset_call_wait)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).free_call_wait) as usize - ptr as usize },
56usize,
concat!(
"Offset of field: ",
stringify!(dxThreadingFunctionsInfo),
"::",
stringify!(free_call_wait)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).post_call) as usize - ptr as usize },
64usize,
concat!(
"Offset of field: ",
stringify!(dxThreadingFunctionsInfo),
"::",
stringify!(post_call)
)
);
assert_eq!(
unsafe {
::std::ptr::addr_of!((*ptr).alter_call_dependencies_count) as usize - ptr as usize
},
72usize,
concat!(
"Offset of field: ",
stringify!(dxThreadingFunctionsInfo),
"::",
stringify!(alter_call_dependencies_count)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).wait_call) as usize - ptr as usize },
80usize,
concat!(
"Offset of field: ",
stringify!(dxThreadingFunctionsInfo),
"::",
stringify!(wait_call)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).retrieve_thread_count) as usize - ptr as usize },
88usize,
concat!(
"Offset of field: ",
stringify!(dxThreadingFunctionsInfo),
"::",
stringify!(retrieve_thread_count)
)
);
assert_eq!(
unsafe {
::std::ptr::addr_of!((*ptr).preallocate_resources_for_calls) as usize - ptr as usize
},
96usize,
concat!(
"Offset of field: ",
stringify!(dxThreadingFunctionsInfo),
"::",
stringify!(preallocate_resources_for_calls)
)
);
}
pub type dThreadingFunctionsInfo = dxThreadingFunctionsInfo;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct dxCooperative {
_unused: [u8; 0],
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct dxResourceRequirements {
_unused: [u8; 0],
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct dxResourceContainer {
_unused: [u8; 0],
}
pub type dCooperativeID = *mut dxCooperative;
pub type dResourceRequirementsID = *mut dxResourceRequirements;
pub type dResourceContainerID = *mut dxResourceContainer;
extern "C" {
pub fn dCooperativeCreate(
functionInfo: *const dThreadingFunctionsInfo,
threadingImpl: dThreadingImplementationID,
) -> dCooperativeID;
}
extern "C" {
pub fn dCooperativeDestroy(cooperative: dCooperativeID);
}
extern "C" {
pub fn dResourceRequirementsCreate(cooperative: dCooperativeID) -> dResourceRequirementsID;
}
extern "C" {
pub fn dResourceRequirementsDestroy(requirements: dResourceRequirementsID);
}
extern "C" {
pub fn dResourceRequirementsClone(
requirements: dResourceRequirementsID,
) -> dResourceRequirementsID;
}
extern "C" {
pub fn dResourceRequirementsMergeIn(
summaryRequirements: dResourceRequirementsID,
extraRequirements: dResourceRequirementsID,
);
}
extern "C" {
pub fn dResourceContainerAcquire(requirements: dResourceRequirementsID)
-> dResourceContainerID;
}
extern "C" {
pub fn dResourceContainerDestroy(resources: dResourceContainerID);
}
extern "C" {
pub fn dEstimateCooperativelyFactorLDLTResourceRequirements(
requirements: dResourceRequirementsID,
maximalAllowedThreadCount: ::std::os::raw::c_uint,
maximalRowCount: ::std::os::raw::c_uint,
);
}
extern "C" {
pub fn dCooperativelyFactorLDLT(
resources: dResourceContainerID,
allowedThreadCount: ::std::os::raw::c_uint,
A: *mut dReal,
d: *mut dReal,
rowCount: ::std::os::raw::c_uint,
rowSkip: ::std::os::raw::c_uint,
);
}
extern "C" {
pub fn dEstimateCooperativelySolveLDLTResourceRequirements(
requirements: dResourceRequirementsID,
maximalAllowedThreadCount: ::std::os::raw::c_uint,
maximalRowCount: ::std::os::raw::c_uint,
);
}
extern "C" {
pub fn dCooperativelySolveLDLT(
resources: dResourceContainerID,
allowedThreadCount: ::std::os::raw::c_uint,
L: *const dReal,
d: *const dReal,
b: *mut dReal,
rowCount: ::std::os::raw::c_uint,
rowSkip: ::std::os::raw::c_uint,
);
}
extern "C" {
pub fn dEstimateCooperativelySolveL1StraightResourceRequirements(
requirements: dResourceRequirementsID,
maximalAllowedThreadCount: ::std::os::raw::c_uint,
maximalRowCount: ::std::os::raw::c_uint,
);
}
extern "C" {
pub fn dCooperativelySolveL1Straight(
resources: dResourceContainerID,
allowedThreadCount: ::std::os::raw::c_uint,
L: *const dReal,
b: *mut dReal,
rowCount: ::std::os::raw::c_uint,
rowSkip: ::std::os::raw::c_uint,
);
}
extern "C" {
pub fn dEstimateCooperativelySolveL1TransposedResourceRequirements(
requirements: dResourceRequirementsID,
maximalAllowedThreadCount: ::std::os::raw::c_uint,
maximalRowCount: ::std::os::raw::c_uint,
);
}
extern "C" {
pub fn dCooperativelySolveL1Transposed(
resources: dResourceContainerID,
allowedThreadCount: ::std::os::raw::c_uint,
L: *const dReal,
b: *mut dReal,
rowCount: ::std::os::raw::c_uint,
rowSkip: ::std::os::raw::c_uint,
);
}
extern "C" {
pub fn dEstimateCooperativelyScaleVectorResourceRequirements(
requirements: dResourceRequirementsID,
maximalAllowedThreadCount: ::std::os::raw::c_uint,
maximalElementCount: ::std::os::raw::c_uint,
);
}
extern "C" {
pub fn dCooperativelyScaleVector(
resources: dResourceContainerID,
allowedThreadCount: ::std::os::raw::c_uint,
dataVector: *mut dReal,
scaleVector: *const dReal,
elementCount: ::std::os::raw::c_uint,
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct dStopwatch {
pub time: f64,
pub cc: [::std::os::raw::c_ulong; 2usize],
}
#[test]
fn bindgen_test_layout_dStopwatch() {
const UNINIT: ::std::mem::MaybeUninit<dStopwatch> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<dStopwatch>(),
16usize,
concat!("Size of: ", stringify!(dStopwatch))
);
assert_eq!(
::std::mem::align_of::<dStopwatch>(),
8usize,
concat!("Alignment of ", stringify!(dStopwatch))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).time) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(dStopwatch),
"::",
stringify!(time)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).cc) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(dStopwatch),
"::",
stringify!(cc)
)
);
}
extern "C" {
pub fn dStopwatchReset(arg1: *mut dStopwatch);
}
extern "C" {
pub fn dStopwatchStart(arg1: *mut dStopwatch);
}
extern "C" {
pub fn dStopwatchStop(arg1: *mut dStopwatch);
}
extern "C" {
pub fn dStopwatchTime(arg1: *mut dStopwatch) -> f64;
}
extern "C" {
pub fn dTimerStart(description: *const ::std::os::raw::c_char);
}
extern "C" {
pub fn dTimerNow(description: *const ::std::os::raw::c_char);
}
extern "C" {
pub fn dTimerEnd();
}
extern "C" {
pub fn dTimerReport(fout: *mut FILE, average: ::std::os::raw::c_int);
}
extern "C" {
pub fn dTimerTicksPerSecond() -> f64;
}
extern "C" {
pub fn dTimerResolution() -> f64;
}
extern "C" {
pub fn dRSetIdentity(R: *mut dReal);
}
extern "C" {
pub fn dRFromAxisAndAngle(R: *mut dReal, ax: dReal, ay: dReal, az: dReal, angle: dReal);
}
extern "C" {
pub fn dRFromEulerAngles(R: *mut dReal, phi: dReal, theta: dReal, psi: dReal);
}
extern "C" {
pub fn dRFrom2Axes(
R: *mut dReal,
ax: dReal,
ay: dReal,
az: dReal,
bx: dReal,
by: dReal,
bz: dReal,
);
}
extern "C" {
pub fn dRFromZAxis(R: *mut dReal, ax: dReal, ay: dReal, az: dReal);
}
extern "C" {
pub fn dQSetIdentity(q: *mut dReal);
}
extern "C" {
pub fn dQFromAxisAndAngle(q: *mut dReal, ax: dReal, ay: dReal, az: dReal, angle: dReal);
}
extern "C" {
pub fn dQMultiply0(qa: *mut dReal, qb: *mut dReal, qc: *mut dReal);
}
extern "C" {
pub fn dQMultiply1(qa: *mut dReal, qb: *mut dReal, qc: *mut dReal);
}
extern "C" {
pub fn dQMultiply2(qa: *mut dReal, qb: *mut dReal, qc: *mut dReal);
}
extern "C" {
pub fn dQMultiply3(qa: *mut dReal, qb: *mut dReal, qc: *mut dReal);
}
extern "C" {
pub fn dRfromQ(R: *mut dReal, q: *mut dReal);
}
extern "C" {
pub fn dQfromR(q: *mut dReal, R: *mut dReal);
}
extern "C" {
pub fn dDQfromW(dq: *mut dReal, w: *mut dReal, q: *mut dReal);
}
extern "C" {
pub fn dMassCheck(m: *const dMass) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn dMassSetZero(arg1: *mut dMass);
}
extern "C" {
pub fn dMassSetParameters(
arg1: *mut dMass,
themass: dReal,
cgx: dReal,
cgy: dReal,
cgz: dReal,
I11: dReal,
I22: dReal,
I33: dReal,
I12: dReal,
I13: dReal,
I23: dReal,
);
}
extern "C" {
pub fn dMassSetSphere(arg1: *mut dMass, density: dReal, radius: dReal);
}
extern "C" {
pub fn dMassSetSphereTotal(arg1: *mut dMass, total_mass: dReal, radius: dReal);
}
extern "C" {
pub fn dMassSetCapsule(
arg1: *mut dMass,
density: dReal,
direction: ::std::os::raw::c_int,
radius: dReal,
length: dReal,
);
}
extern "C" {
pub fn dMassSetCapsuleTotal(
arg1: *mut dMass,
total_mass: dReal,
direction: ::std::os::raw::c_int,
radius: dReal,
length: dReal,
);
}
extern "C" {
pub fn dMassSetCylinder(
arg1: *mut dMass,
density: dReal,
direction: ::std::os::raw::c_int,
radius: dReal,
length: dReal,
);
}
extern "C" {
pub fn dMassSetCylinderTotal(
arg1: *mut dMass,
total_mass: dReal,
direction: ::std::os::raw::c_int,
radius: dReal,
length: dReal,
);
}
extern "C" {
pub fn dMassSetBox(arg1: *mut dMass, density: dReal, lx: dReal, ly: dReal, lz: dReal);
}
extern "C" {
pub fn dMassSetBoxTotal(arg1: *mut dMass, total_mass: dReal, lx: dReal, ly: dReal, lz: dReal);
}
extern "C" {
pub fn dMassSetTrimesh(arg1: *mut dMass, density: dReal, g: dGeomID);
}
extern "C" {
pub fn dMassSetTrimeshTotal(m: *mut dMass, total_mass: dReal, g: dGeomID);
}
extern "C" {
pub fn dMassAdjust(arg1: *mut dMass, newmass: dReal);
}
extern "C" {
pub fn dMassTranslate(arg1: *mut dMass, x: dReal, y: dReal, z: dReal);
}
extern "C" {
pub fn dMassRotate(arg1: *mut dMass, R: *mut dReal);
}
extern "C" {
pub fn dMassAdd(a: *mut dMass, b: *const dMass);
}
extern "C" {
pub fn dMassSetCappedCylinder(
a: *mut dMass,
b: dReal,
c: ::std::os::raw::c_int,
d: dReal,
e: dReal,
);
}
extern "C" {
pub fn dMassSetCappedCylinderTotal(
a: *mut dMass,
b: dReal,
c: ::std::os::raw::c_int,
d: dReal,
e: dReal,
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct dMass {
pub mass: dReal,
pub c: dVector3,
pub I: dMatrix3,
}
#[test]
fn bindgen_test_layout_dMass() {
const UNINIT: ::std::mem::MaybeUninit<dMass> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<dMass>(),
136usize,
concat!("Size of: ", stringify!(dMass))
);
assert_eq!(
::std::mem::align_of::<dMass>(),
8usize,
concat!("Alignment of ", stringify!(dMass))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).mass) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(dMass),
"::",
stringify!(mass)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).c) as usize - ptr as usize },
8usize,
concat!("Offset of field: ", stringify!(dMass), "::", stringify!(c))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).I) as usize - ptr as usize },
40usize,
concat!("Offset of field: ", stringify!(dMass), "::", stringify!(I))
);
}
extern "C" {
pub fn dTestRand() -> ::std::os::raw::c_int;
}
extern "C" {
pub fn dRand() -> ::std::os::raw::c_ulong;
}
extern "C" {
pub fn dRandGetSeed() -> ::std::os::raw::c_ulong;
}
extern "C" {
pub fn dRandSetSeed(s: ::std::os::raw::c_ulong);
}
extern "C" {
pub fn dRandInt(n: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn dRandReal() -> dReal;
}
extern "C" {
pub fn dPrintMatrix(
A: *const dReal,
n: ::std::os::raw::c_int,
m: ::std::os::raw::c_int,
fmt: *const ::std::os::raw::c_char,
f: *mut FILE,
);
}
extern "C" {
pub fn dMakeRandomVector(A: *mut dReal, n: ::std::os::raw::c_int, range: dReal);
}
extern "C" {
pub fn dMakeRandomMatrix(
A: *mut dReal,
n: ::std::os::raw::c_int,
m: ::std::os::raw::c_int,
range: dReal,
);
}
extern "C" {
pub fn dClearUpperTriangle(A: *mut dReal, n: ::std::os::raw::c_int);
}
extern "C" {
pub fn dMaxDifference(
A: *const dReal,
B: *const dReal,
n: ::std::os::raw::c_int,
m: ::std::os::raw::c_int,
) -> dReal;
}
extern "C" {
pub fn dMaxDifferenceLowerTriangle(
A: *const dReal,
B: *const dReal,
n: ::std::os::raw::c_int,
) -> dReal;
}
extern "C" {
pub fn dWorldCreate() -> dWorldID;
}
extern "C" {
pub fn dWorldDestroy(world: dWorldID);
}
extern "C" {
pub fn dWorldSetData(world: dWorldID, data: *mut ::std::os::raw::c_void);
}
extern "C" {
pub fn dWorldGetData(world: dWorldID) -> *mut ::std::os::raw::c_void;
}
extern "C" {
pub fn dWorldSetGravity(arg1: dWorldID, x: dReal, y: dReal, z: dReal);
}
extern "C" {
pub fn dWorldGetGravity(arg1: dWorldID, gravity: *mut dReal);
}
extern "C" {
pub fn dWorldSetERP(arg1: dWorldID, erp: dReal);
}
extern "C" {
pub fn dWorldGetERP(arg1: dWorldID) -> dReal;
}
extern "C" {
pub fn dWorldSetCFM(arg1: dWorldID, cfm: dReal);
}
extern "C" {
pub fn dWorldGetCFM(arg1: dWorldID) -> dReal;
}
extern "C" {
pub fn dWorldSetStepIslandsProcessingMaxThreadCount(w: dWorldID, count: ::std::os::raw::c_uint);
}
extern "C" {
pub fn dWorldGetStepIslandsProcessingMaxThreadCount(w: dWorldID) -> ::std::os::raw::c_uint;
}
extern "C" {
pub fn dWorldUseSharedWorkingMemory(w: dWorldID, from_world: dWorldID)
-> ::std::os::raw::c_int;
}
extern "C" {
pub fn dWorldCleanupWorkingMemory(w: dWorldID);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct dWorldStepReserveInfo {
pub struct_size: ::std::os::raw::c_uint,
pub reserve_factor: f32,
pub reserve_minimum: ::std::os::raw::c_uint,
}
#[test]
fn bindgen_test_layout_dWorldStepReserveInfo() {
const UNINIT: ::std::mem::MaybeUninit<dWorldStepReserveInfo> =
::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<dWorldStepReserveInfo>(),
12usize,
concat!("Size of: ", stringify!(dWorldStepReserveInfo))
);
assert_eq!(
::std::mem::align_of::<dWorldStepReserveInfo>(),
4usize,
concat!("Alignment of ", stringify!(dWorldStepReserveInfo))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).struct_size) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(dWorldStepReserveInfo),
"::",
stringify!(struct_size)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).reserve_factor) as usize - ptr as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(dWorldStepReserveInfo),
"::",
stringify!(reserve_factor)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).reserve_minimum) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(dWorldStepReserveInfo),
"::",
stringify!(reserve_minimum)
)
);
}
extern "C" {
pub fn dWorldSetStepMemoryReservationPolicy(
w: dWorldID,
policyinfo: *const dWorldStepReserveInfo,
) -> ::std::os::raw::c_int;
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct dWorldStepMemoryFunctionsInfo {
pub struct_size: ::std::os::raw::c_uint,
pub alloc_block: ::std::option::Option<
unsafe extern "C" fn(block_size: dsizeint) -> *mut ::std::os::raw::c_void,
>,
pub shrink_block: ::std::option::Option<
unsafe extern "C" fn(
block_pointer: *mut ::std::os::raw::c_void,
block_current_size: dsizeint,
block_smaller_size: dsizeint,
) -> *mut ::std::os::raw::c_void,
>,
pub free_block: ::std::option::Option<
unsafe extern "C" fn(
block_pointer: *mut ::std::os::raw::c_void,
block_current_size: dsizeint,
),
>,
}
#[test]
fn bindgen_test_layout_dWorldStepMemoryFunctionsInfo() {
const UNINIT: ::std::mem::MaybeUninit<dWorldStepMemoryFunctionsInfo> =
::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<dWorldStepMemoryFunctionsInfo>(),
32usize,
concat!("Size of: ", stringify!(dWorldStepMemoryFunctionsInfo))
);
assert_eq!(
::std::mem::align_of::<dWorldStepMemoryFunctionsInfo>(),
8usize,
concat!("Alignment of ", stringify!(dWorldStepMemoryFunctionsInfo))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).struct_size) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(dWorldStepMemoryFunctionsInfo),
"::",
stringify!(struct_size)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).alloc_block) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(dWorldStepMemoryFunctionsInfo),
"::",
stringify!(alloc_block)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).shrink_block) as usize - ptr as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(dWorldStepMemoryFunctionsInfo),
"::",
stringify!(shrink_block)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).free_block) as usize - ptr as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(dWorldStepMemoryFunctionsInfo),
"::",
stringify!(free_block)
)
);
}
extern "C" {
pub fn dWorldSetStepMemoryManager(
w: dWorldID,
memfuncs: *const dWorldStepMemoryFunctionsInfo,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn dWorldSetStepThreadingImplementation(
w: dWorldID,
functions_info: *const dThreadingFunctionsInfo,
threading_impl: dThreadingImplementationID,
);
}
extern "C" {
pub fn dWorldStep(w: dWorldID, stepsize: dReal) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn dWorldQuickStep(w: dWorldID, stepsize: dReal) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn dWorldImpulseToForce(
arg1: dWorldID,
stepsize: dReal,
ix: dReal,
iy: dReal,
iz: dReal,
force: *mut dReal,
);
}
extern "C" {
pub fn dWorldSetQuickStepNumIterations(arg1: dWorldID, num: ::std::os::raw::c_int);
}
extern "C" {
pub fn dWorldGetQuickStepNumIterations(arg1: dWorldID) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn dWorldSetQuickStepW(arg1: dWorldID, over_relaxation: dReal);
}
extern "C" {
pub fn dWorldGetQuickStepW(arg1: dWorldID) -> dReal;
}
extern "C" {
pub fn dWorldSetContactMaxCorrectingVel(arg1: dWorldID, vel: dReal);
}
extern "C" {
pub fn dWorldGetContactMaxCorrectingVel(arg1: dWorldID) -> dReal;
}
extern "C" {
pub fn dWorldSetContactSurfaceLayer(arg1: dWorldID, depth: dReal);
}
extern "C" {
pub fn dWorldGetContactSurfaceLayer(arg1: dWorldID) -> dReal;
}
extern "C" {
pub fn dWorldGetAutoDisableLinearThreshold(arg1: dWorldID) -> dReal;
}
extern "C" {
pub fn dWorldSetAutoDisableLinearThreshold(arg1: dWorldID, linear_average_threshold: dReal);
}
extern "C" {
pub fn dWorldGetAutoDisableAngularThreshold(arg1: dWorldID) -> dReal;
}
extern "C" {
pub fn dWorldSetAutoDisableAngularThreshold(arg1: dWorldID, angular_average_threshold: dReal);
}
extern "C" {
pub fn dWorldGetAutoDisableAverageSamplesCount(arg1: dWorldID) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn dWorldSetAutoDisableAverageSamplesCount(
arg1: dWorldID,
average_samples_count: ::std::os::raw::c_uint,
);
}
extern "C" {
pub fn dWorldGetAutoDisableSteps(arg1: dWorldID) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn dWorldSetAutoDisableSteps(arg1: dWorldID, steps: ::std::os::raw::c_int);
}
extern "C" {
pub fn dWorldGetAutoDisableTime(arg1: dWorldID) -> dReal;
}
extern "C" {
pub fn dWorldSetAutoDisableTime(arg1: dWorldID, time: dReal);
}
extern "C" {
pub fn dWorldGetAutoDisableFlag(arg1: dWorldID) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn dWorldSetAutoDisableFlag(arg1: dWorldID, do_auto_disable: ::std::os::raw::c_int);
}
extern "C" {
pub fn dWorldGetLinearDampingThreshold(w: dWorldID) -> dReal;
}
extern "C" {
pub fn dWorldSetLinearDampingThreshold(w: dWorldID, threshold: dReal);
}
extern "C" {
pub fn dWorldGetAngularDampingThreshold(w: dWorldID) -> dReal;
}
extern "C" {
pub fn dWorldSetAngularDampingThreshold(w: dWorldID, threshold: dReal);
}
extern "C" {
pub fn dWorldGetLinearDamping(w: dWorldID) -> dReal;
}
extern "C" {
pub fn dWorldSetLinearDamping(w: dWorldID, scale: dReal);
}
extern "C" {
pub fn dWorldGetAngularDamping(w: dWorldID) -> dReal;
}
extern "C" {
pub fn dWorldSetAngularDamping(w: dWorldID, scale: dReal);
}
extern "C" {
pub fn dWorldSetDamping(w: dWorldID, linear_scale: dReal, angular_scale: dReal);
}
extern "C" {
pub fn dWorldGetMaxAngularSpeed(w: dWorldID) -> dReal;
}
extern "C" {
pub fn dWorldSetMaxAngularSpeed(w: dWorldID, max_speed: dReal);
}
extern "C" {
pub fn dBodyGetAutoDisableLinearThreshold(arg1: dBodyID) -> dReal;
}
extern "C" {
pub fn dBodySetAutoDisableLinearThreshold(arg1: dBodyID, linear_average_threshold: dReal);
}
extern "C" {
pub fn dBodyGetAutoDisableAngularThreshold(arg1: dBodyID) -> dReal;
}
extern "C" {
pub fn dBodySetAutoDisableAngularThreshold(arg1: dBodyID, angular_average_threshold: dReal);
}
extern "C" {
pub fn dBodyGetAutoDisableAverageSamplesCount(arg1: dBodyID) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn dBodySetAutoDisableAverageSamplesCount(
arg1: dBodyID,
average_samples_count: ::std::os::raw::c_uint,
);
}
extern "C" {
pub fn dBodyGetAutoDisableSteps(arg1: dBodyID) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn dBodySetAutoDisableSteps(arg1: dBodyID, steps: ::std::os::raw::c_int);
}
extern "C" {
pub fn dBodyGetAutoDisableTime(arg1: dBodyID) -> dReal;
}
extern "C" {
pub fn dBodySetAutoDisableTime(arg1: dBodyID, time: dReal);
}
extern "C" {
pub fn dBodyGetAutoDisableFlag(arg1: dBodyID) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn dBodySetAutoDisableFlag(arg1: dBodyID, do_auto_disable: ::std::os::raw::c_int);
}
extern "C" {
pub fn dBodySetAutoDisableDefaults(arg1: dBodyID);
}
extern "C" {
pub fn dBodyGetWorld(arg1: dBodyID) -> dWorldID;
}
extern "C" {
pub fn dBodyCreate(arg1: dWorldID) -> dBodyID;
}
extern "C" {
pub fn dBodyDestroy(arg1: dBodyID);
}
extern "C" {
pub fn dBodySetData(arg1: dBodyID, data: *mut ::std::os::raw::c_void);
}
extern "C" {
pub fn dBodyGetData(arg1: dBodyID) -> *mut ::std::os::raw::c_void;
}
extern "C" {
pub fn dBodySetPosition(arg1: dBodyID, x: dReal, y: dReal, z: dReal);
}
extern "C" {
pub fn dBodySetRotation(arg1: dBodyID, R: *mut dReal);
}
extern "C" {
pub fn dBodySetQuaternion(arg1: dBodyID, q: *mut dReal);
}
extern "C" {
pub fn dBodySetLinearVel(arg1: dBodyID, x: dReal, y: dReal, z: dReal);
}
extern "C" {
pub fn dBodySetAngularVel(arg1: dBodyID, x: dReal, y: dReal, z: dReal);
}
extern "C" {
pub fn dBodyGetPosition(arg1: dBodyID) -> *const dReal;
}
extern "C" {
pub fn dBodyCopyPosition(body: dBodyID, pos: *mut dReal);
}
extern "C" {
pub fn dBodyGetRotation(arg1: dBodyID) -> *const dReal;
}
extern "C" {
pub fn dBodyCopyRotation(arg1: dBodyID, R: *mut dReal);
}
extern "C" {
pub fn dBodyGetQuaternion(arg1: dBodyID) -> *const dReal;
}
extern "C" {
pub fn dBodyCopyQuaternion(body: dBodyID, quat: *mut dReal);
}
extern "C" {
pub fn dBodyGetLinearVel(arg1: dBodyID) -> *const dReal;
}
extern "C" {
pub fn dBodyGetAngularVel(arg1: dBodyID) -> *const dReal;
}
extern "C" {
pub fn dBodySetMass(arg1: dBodyID, mass: *const dMass);
}
extern "C" {
pub fn dBodyGetMass(arg1: dBodyID, mass: *mut dMass);
}
extern "C" {
pub fn dBodyAddForce(arg1: dBodyID, fx: dReal, fy: dReal, fz: dReal);
}
extern "C" {
pub fn dBodyAddTorque(arg1: dBodyID, fx: dReal, fy: dReal, fz: dReal);
}
extern "C" {
pub fn dBodyAddRelForce(arg1: dBodyID, fx: dReal, fy: dReal, fz: dReal);
}
extern "C" {
pub fn dBodyAddRelTorque(arg1: dBodyID, fx: dReal, fy: dReal, fz: dReal);
}
extern "C" {
pub fn dBodyAddForceAtPos(
arg1: dBodyID,
fx: dReal,
fy: dReal,
fz: dReal,
px: dReal,
py: dReal,
pz: dReal,
);
}
extern "C" {
pub fn dBodyAddForceAtRelPos(
arg1: dBodyID,
fx: dReal,
fy: dReal,
fz: dReal,
px: dReal,
py: dReal,
pz: dReal,
);
}
extern "C" {
pub fn dBodyAddRelForceAtPos(
arg1: dBodyID,
fx: dReal,
fy: dReal,
fz: dReal,
px: dReal,
py: dReal,
pz: dReal,
);
}
extern "C" {
pub fn dBodyAddRelForceAtRelPos(
arg1: dBodyID,
fx: dReal,
fy: dReal,
fz: dReal,
px: dReal,
py: dReal,
pz: dReal,
);
}
extern "C" {
pub fn dBodyGetForce(arg1: dBodyID) -> *const dReal;
}
extern "C" {
pub fn dBodyGetTorque(arg1: dBodyID) -> *const dReal;
}
extern "C" {
pub fn dBodySetForce(b: dBodyID, x: dReal, y: dReal, z: dReal);
}
extern "C" {
pub fn dBodySetTorque(b: dBodyID, x: dReal, y: dReal, z: dReal);
}
extern "C" {
pub fn dBodyGetRelPointPos(arg1: dBodyID, px: dReal, py: dReal, pz: dReal, result: *mut dReal);
}
extern "C" {
pub fn dBodyGetRelPointVel(arg1: dBodyID, px: dReal, py: dReal, pz: dReal, result: *mut dReal);
}
extern "C" {
pub fn dBodyGetPointVel(arg1: dBodyID, px: dReal, py: dReal, pz: dReal, result: *mut dReal);
}
extern "C" {
pub fn dBodyGetPosRelPoint(arg1: dBodyID, px: dReal, py: dReal, pz: dReal, result: *mut dReal);
}
extern "C" {
pub fn dBodyVectorToWorld(arg1: dBodyID, px: dReal, py: dReal, pz: dReal, result: *mut dReal);
}
extern "C" {
pub fn dBodyVectorFromWorld(arg1: dBodyID, px: dReal, py: dReal, pz: dReal, result: *mut dReal);
}
extern "C" {
pub fn dBodySetFiniteRotationMode(arg1: dBodyID, mode: ::std::os::raw::c_int);
}
extern "C" {
pub fn dBodySetFiniteRotationAxis(arg1: dBodyID, x: dReal, y: dReal, z: dReal);
}
extern "C" {
pub fn dBodyGetFiniteRotationMode(arg1: dBodyID) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn dBodyGetFiniteRotationAxis(arg1: dBodyID, result: *mut dReal);
}
extern "C" {
pub fn dBodyGetNumJoints(b: dBodyID) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn dBodyGetJoint(arg1: dBodyID, index: ::std::os::raw::c_int) -> dJointID;
}
extern "C" {
pub fn dBodySetDynamic(arg1: dBodyID);
}
extern "C" {
pub fn dBodySetKinematic(arg1: dBodyID);
}
extern "C" {
pub fn dBodyIsKinematic(arg1: dBodyID) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn dBodyEnable(arg1: dBodyID);
}
extern "C" {
pub fn dBodyDisable(arg1: dBodyID);
}
extern "C" {
pub fn dBodyIsEnabled(arg1: dBodyID) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn dBodySetGravityMode(b: dBodyID, mode: ::std::os::raw::c_int);
}
extern "C" {
pub fn dBodyGetGravityMode(b: dBodyID) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn dBodySetMovedCallback(
b: dBodyID,
callback: ::std::option::Option<unsafe extern "C" fn(arg1: dBodyID)>,
);
}
extern "C" {
pub fn dBodyGetFirstGeom(b: dBodyID) -> dGeomID;
}
extern "C" {
pub fn dBodyGetNextGeom(g: dGeomID) -> dGeomID;
}
extern "C" {
pub fn dBodySetDampingDefaults(b: dBodyID);
}
extern "C" {
pub fn dBodyGetLinearDamping(b: dBodyID) -> dReal;
}
extern "C" {
pub fn dBodySetLinearDamping(b: dBodyID, scale: dReal);
}
extern "C" {
pub fn dBodyGetAngularDamping(b: dBodyID) -> dReal;
}
extern "C" {
pub fn dBodySetAngularDamping(b: dBodyID, scale: dReal);
}
extern "C" {
pub fn dBodySetDamping(b: dBodyID, linear_scale: dReal, angular_scale: dReal);
}
extern "C" {
pub fn dBodyGetLinearDampingThreshold(b: dBodyID) -> dReal;
}
extern "C" {
pub fn dBodySetLinearDampingThreshold(b: dBodyID, threshold: dReal);
}
extern "C" {
pub fn dBodyGetAngularDampingThreshold(b: dBodyID) -> dReal;
}
extern "C" {
pub fn dBodySetAngularDampingThreshold(b: dBodyID, threshold: dReal);
}
extern "C" {
pub fn dBodyGetMaxAngularSpeed(b: dBodyID) -> dReal;
}
extern "C" {
pub fn dBodySetMaxAngularSpeed(b: dBodyID, max_speed: dReal);
}
extern "C" {
pub fn dBodyGetGyroscopicMode(b: dBodyID) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn dBodySetGyroscopicMode(b: dBodyID, enabled: ::std::os::raw::c_int);
}
extern "C" {
pub fn dJointCreateBall(arg1: dWorldID, arg2: dJointGroupID) -> dJointID;
}
extern "C" {
pub fn dJointCreateHinge(arg1: dWorldID, arg2: dJointGroupID) -> dJointID;
}
extern "C" {
pub fn dJointCreateSlider(arg1: dWorldID, arg2: dJointGroupID) -> dJointID;
}
extern "C" {
pub fn dJointCreateContact(
arg1: dWorldID,
arg2: dJointGroupID,
arg3: *const dContact,
) -> dJointID;
}
extern "C" {
pub fn dJointCreateHinge2(arg1: dWorldID, arg2: dJointGroupID) -> dJointID;
}
extern "C" {
pub fn dJointCreateUniversal(arg1: dWorldID, arg2: dJointGroupID) -> dJointID;
}
extern "C" {
pub fn dJointCreatePR(arg1: dWorldID, arg2: dJointGroupID) -> dJointID;
}
extern "C" {
pub fn dJointCreatePU(arg1: dWorldID, arg2: dJointGroupID) -> dJointID;
}
extern "C" {
pub fn dJointCreatePiston(arg1: dWorldID, arg2: dJointGroupID) -> dJointID;
}
extern "C" {
pub fn dJointCreateFixed(arg1: dWorldID, arg2: dJointGroupID) -> dJointID;
}
extern "C" {
pub fn dJointCreateNull(arg1: dWorldID, arg2: dJointGroupID) -> dJointID;
}
extern "C" {
pub fn dJointCreateAMotor(arg1: dWorldID, arg2: dJointGroupID) -> dJointID;
}
extern "C" {
pub fn dJointCreateLMotor(arg1: dWorldID, arg2: dJointGroupID) -> dJointID;
}
extern "C" {
pub fn dJointCreatePlane2D(arg1: dWorldID, arg2: dJointGroupID) -> dJointID;
}
extern "C" {
pub fn dJointCreateDBall(arg1: dWorldID, arg2: dJointGroupID) -> dJointID;
}
extern "C" {
pub fn dJointCreateDHinge(arg1: dWorldID, arg2: dJointGroupID) -> dJointID;
}
extern "C" {
pub fn dJointCreateTransmission(arg1: dWorldID, arg2: dJointGroupID) -> dJointID;
}
extern "C" {
pub fn dJointDestroy(arg1: dJointID);
}
extern "C" {
pub fn dJointGroupCreate(max_size: ::std::os::raw::c_int) -> dJointGroupID;
}
extern "C" {
pub fn dJointGroupDestroy(arg1: dJointGroupID);
}
extern "C" {
pub fn dJointGroupEmpty(arg1: dJointGroupID);
}
extern "C" {
pub fn dJointGetNumBodies(arg1: dJointID) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn dJointAttach(arg1: dJointID, body1: dBodyID, body2: dBodyID);
}
extern "C" {
pub fn dJointEnable(arg1: dJointID);
}
extern "C" {
pub fn dJointDisable(arg1: dJointID);
}
extern "C" {
pub fn dJointIsEnabled(arg1: dJointID) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn dJointSetData(arg1: dJointID, data: *mut ::std::os::raw::c_void);
}
extern "C" {
pub fn dJointGetData(arg1: dJointID) -> *mut ::std::os::raw::c_void;
}
extern "C" {
pub fn dJointGetType(arg1: dJointID) -> dJointType;
}
extern "C" {
pub fn dJointGetBody(arg1: dJointID, index: ::std::os::raw::c_int) -> dBodyID;
}
extern "C" {
pub fn dJointSetFeedback(arg1: dJointID, arg2: *mut dJointFeedback);
}
extern "C" {
pub fn dJointGetFeedback(arg1: dJointID) -> *mut dJointFeedback;
}
extern "C" {
pub fn dJointSetBallAnchor(arg1: dJointID, x: dReal, y: dReal, z: dReal);
}
extern "C" {
pub fn dJointSetBallAnchor2(arg1: dJointID, x: dReal, y: dReal, z: dReal);
}
extern "C" {
pub fn dJointSetBallParam(arg1: dJointID, parameter: ::std::os::raw::c_int, value: dReal);
}
extern "C" {
pub fn dJointSetHingeAnchor(arg1: dJointID, x: dReal, y: dReal, z: dReal);
}
extern "C" {
pub fn dJointSetHingeAnchorDelta(
arg1: dJointID,
x: dReal,
y: dReal,
z: dReal,
ax: dReal,
ay: dReal,
az: dReal,
);
}
extern "C" {
pub fn dJointSetHingeAxis(arg1: dJointID, x: dReal, y: dReal, z: dReal);
}
extern "C" {
pub fn dJointSetHingeAxisOffset(j: dJointID, x: dReal, y: dReal, z: dReal, angle: dReal);
}
extern "C" {
pub fn dJointSetHingeParam(arg1: dJointID, parameter: ::std::os::raw::c_int, value: dReal);
}
extern "C" {
pub fn dJointAddHingeTorque(joint: dJointID, torque: dReal);
}
extern "C" {
pub fn dJointSetSliderAxis(arg1: dJointID, x: dReal, y: dReal, z: dReal);
}
extern "C" {
pub fn dJointSetSliderAxisDelta(
arg1: dJointID,
x: dReal,
y: dReal,
z: dReal,
ax: dReal,
ay: dReal,
az: dReal,
);
}
extern "C" {
pub fn dJointSetSliderParam(arg1: dJointID, parameter: ::std::os::raw::c_int, value: dReal);
}
extern "C" {
pub fn dJointAddSliderForce(joint: dJointID, force: dReal);
}
extern "C" {
pub fn dJointSetHinge2Anchor(arg1: dJointID, x: dReal, y: dReal, z: dReal);
}
extern "C" {
pub fn dJointSetHinge2Axes(j: dJointID, axis1: *const dReal, axis2: *const dReal);
}
extern "C" {
pub fn dJointSetHinge2Axis1(j: dJointID, x: dReal, y: dReal, z: dReal);
}
extern "C" {
pub fn dJointSetHinge2Axis2(j: dJointID, x: dReal, y: dReal, z: dReal);
}
extern "C" {
pub fn dJointSetHinge2Param(arg1: dJointID, parameter: ::std::os::raw::c_int, value: dReal);
}
extern "C" {
pub fn dJointAddHinge2Torques(joint: dJointID, torque1: dReal, torque2: dReal);
}
extern "C" {
pub fn dJointSetUniversalAnchor(arg1: dJointID, x: dReal, y: dReal, z: dReal);
}
extern "C" {
pub fn dJointSetUniversalAxis1(arg1: dJointID, x: dReal, y: dReal, z: dReal);
}
extern "C" {
pub fn dJointSetUniversalAxis1Offset(
arg1: dJointID,
x: dReal,
y: dReal,
z: dReal,
offset1: dReal,
offset2: dReal,
);
}
extern "C" {
pub fn dJointSetUniversalAxis2(arg1: dJointID, x: dReal, y: dReal, z: dReal);
}
extern "C" {
pub fn dJointSetUniversalAxis2Offset(
arg1: dJointID,
x: dReal,
y: dReal,
z: dReal,
offset1: dReal,
offset2: dReal,
);
}
extern "C" {
pub fn dJointSetUniversalParam(arg1: dJointID, parameter: ::std::os::raw::c_int, value: dReal);
}
extern "C" {
pub fn dJointAddUniversalTorques(joint: dJointID, torque1: dReal, torque2: dReal);
}
extern "C" {
pub fn dJointSetPRAnchor(arg1: dJointID, x: dReal, y: dReal, z: dReal);
}
extern "C" {
pub fn dJointSetPRAxis1(arg1: dJointID, x: dReal, y: dReal, z: dReal);
}
extern "C" {
pub fn dJointSetPRAxis2(arg1: dJointID, x: dReal, y: dReal, z: dReal);
}
extern "C" {
pub fn dJointSetPRParam(arg1: dJointID, parameter: ::std::os::raw::c_int, value: dReal);
}
extern "C" {
pub fn dJointAddPRTorque(j: dJointID, torque: dReal);
}
extern "C" {
pub fn dJointSetPUAnchor(arg1: dJointID, x: dReal, y: dReal, z: dReal);
}
extern "C" {
pub fn dJointSetPUAnchorDelta(
arg1: dJointID,
x: dReal,
y: dReal,
z: dReal,
dx: dReal,
dy: dReal,
dz: dReal,
);
}
extern "C" {
pub fn dJointSetPUAnchorOffset(
arg1: dJointID,
x: dReal,
y: dReal,
z: dReal,
dx: dReal,
dy: dReal,
dz: dReal,
);
}
extern "C" {
pub fn dJointSetPUAxis1(arg1: dJointID, x: dReal, y: dReal, z: dReal);
}
extern "C" {
pub fn dJointSetPUAxis2(arg1: dJointID, x: dReal, y: dReal, z: dReal);
}
extern "C" {
pub fn dJointSetPUAxis3(arg1: dJointID, x: dReal, y: dReal, z: dReal);
}
extern "C" {
pub fn dJointSetPUAxisP(id: dJointID, x: dReal, y: dReal, z: dReal);
}
extern "C" {
pub fn dJointSetPUParam(arg1: dJointID, parameter: ::std::os::raw::c_int, value: dReal);
}
extern "C" {
pub fn dJointAddPUTorque(j: dJointID, torque: dReal);
}
extern "C" {
pub fn dJointSetPistonAnchor(arg1: dJointID, x: dReal, y: dReal, z: dReal);
}
extern "C" {
pub fn dJointSetPistonAnchorOffset(
j: dJointID,
x: dReal,
y: dReal,
z: dReal,
dx: dReal,
dy: dReal,
dz: dReal,
);
}
extern "C" {
pub fn dJointSetPistonAxis(arg1: dJointID, x: dReal, y: dReal, z: dReal);
}
extern "C" {
pub fn dJointSetPistonAxisDelta(
j: dJointID,
x: dReal,
y: dReal,
z: dReal,
ax: dReal,
ay: dReal,
az: dReal,
);
}
extern "C" {
pub fn dJointSetPistonParam(arg1: dJointID, parameter: ::std::os::raw::c_int, value: dReal);
}
extern "C" {
pub fn dJointAddPistonForce(joint: dJointID, force: dReal);
}
extern "C" {
pub fn dJointSetFixed(arg1: dJointID);
}
extern "C" {
pub fn dJointSetFixedParam(arg1: dJointID, parameter: ::std::os::raw::c_int, value: dReal);
}
extern "C" {
pub fn dJointSetAMotorNumAxes(arg1: dJointID, num: ::std::os::raw::c_int);
}
extern "C" {
pub fn dJointSetAMotorAxis(
arg1: dJointID,
anum: ::std::os::raw::c_int,
rel: ::std::os::raw::c_int,
x: dReal,
y: dReal,
z: dReal,
);
}
extern "C" {
pub fn dJointSetAMotorAngle(arg1: dJointID, anum: ::std::os::raw::c_int, angle: dReal);
}
extern "C" {
pub fn dJointSetAMotorParam(arg1: dJointID, parameter: ::std::os::raw::c_int, value: dReal);
}
extern "C" {
pub fn dJointSetAMotorMode(arg1: dJointID, mode: ::std::os::raw::c_int);
}
extern "C" {
pub fn dJointAddAMotorTorques(arg1: dJointID, torque1: dReal, torque2: dReal, torque3: dReal);
}
extern "C" {
pub fn dJointSetLMotorNumAxes(arg1: dJointID, num: ::std::os::raw::c_int);
}
extern "C" {
pub fn dJointSetLMotorAxis(
arg1: dJointID,
anum: ::std::os::raw::c_int,
rel: ::std::os::raw::c_int,
x: dReal,
y: dReal,
z: dReal,
);
}
extern "C" {
pub fn dJointSetLMotorParam(arg1: dJointID, parameter: ::std::os::raw::c_int, value: dReal);
}
extern "C" {
pub fn dJointSetPlane2DXParam(arg1: dJointID, parameter: ::std::os::raw::c_int, value: dReal);
}
extern "C" {
pub fn dJointSetPlane2DYParam(arg1: dJointID, parameter: ::std::os::raw::c_int, value: dReal);
}
extern "C" {
pub fn dJointSetPlane2DAngleParam(
arg1: dJointID,
parameter: ::std::os::raw::c_int,
value: dReal,
);
}
extern "C" {
pub fn dJointGetBallAnchor(arg1: dJointID, result: *mut dReal);
}
extern "C" {
pub fn dJointGetBallAnchor2(arg1: dJointID, result: *mut dReal);
}
extern "C" {
pub fn dJointGetBallParam(arg1: dJointID, parameter: ::std::os::raw::c_int) -> dReal;
}
extern "C" {
pub fn dJointGetHingeAnchor(arg1: dJointID, result: *mut dReal);
}
extern "C" {
pub fn dJointGetHingeAnchor2(arg1: dJointID, result: *mut dReal);
}
extern "C" {
pub fn dJointGetHingeAxis(arg1: dJointID, result: *mut dReal);
}
extern "C" {
pub fn dJointGetHingeParam(arg1: dJointID, parameter: ::std::os::raw::c_int) -> dReal;
}
extern "C" {
pub fn dJointGetHingeAngle(arg1: dJointID) -> dReal;
}
extern "C" {
pub fn dJointGetHingeAngleRate(arg1: dJointID) -> dReal;
}
extern "C" {
pub fn dJointGetSliderPosition(arg1: dJointID) -> dReal;
}
extern "C" {
pub fn dJointGetSliderPositionRate(arg1: dJointID) -> dReal;
}
extern "C" {
pub fn dJointGetSliderAxis(arg1: dJointID, result: *mut dReal);
}
extern "C" {
pub fn dJointGetSliderParam(arg1: dJointID, parameter: ::std::os::raw::c_int) -> dReal;
}
extern "C" {
pub fn dJointGetHinge2Anchor(arg1: dJointID, result: *mut dReal);
}
extern "C" {
pub fn dJointGetHinge2Anchor2(arg1: dJointID, result: *mut dReal);
}
extern "C" {
pub fn dJointGetHinge2Axis1(arg1: dJointID, result: *mut dReal);
}
extern "C" {
pub fn dJointGetHinge2Axis2(arg1: dJointID, result: *mut dReal);
}
extern "C" {
pub fn dJointGetHinge2Param(arg1: dJointID, parameter: ::std::os::raw::c_int) -> dReal;
}
extern "C" {
pub fn dJointGetHinge2Angle1(arg1: dJointID) -> dReal;
}
extern "C" {
pub fn dJointGetHinge2Angle2(arg1: dJointID) -> dReal;
}
extern "C" {
pub fn dJointGetHinge2Angle1Rate(arg1: dJointID) -> dReal;
}
extern "C" {
pub fn dJointGetHinge2Angle2Rate(arg1: dJointID) -> dReal;
}
extern "C" {
pub fn dJointGetUniversalAnchor(arg1: dJointID, result: *mut dReal);
}
extern "C" {
pub fn dJointGetUniversalAnchor2(arg1: dJointID, result: *mut dReal);
}
extern "C" {
pub fn dJointGetUniversalAxis1(arg1: dJointID, result: *mut dReal);
}
extern "C" {
pub fn dJointGetUniversalAxis2(arg1: dJointID, result: *mut dReal);
}
extern "C" {
pub fn dJointGetUniversalParam(arg1: dJointID, parameter: ::std::os::raw::c_int) -> dReal;
}
extern "C" {
pub fn dJointGetUniversalAngles(arg1: dJointID, angle1: *mut dReal, angle2: *mut dReal);
}
extern "C" {
pub fn dJointGetUniversalAngle1(arg1: dJointID) -> dReal;
}
extern "C" {
pub fn dJointGetUniversalAngle2(arg1: dJointID) -> dReal;
}
extern "C" {
pub fn dJointGetUniversalAngle1Rate(arg1: dJointID) -> dReal;
}
extern "C" {
pub fn dJointGetUniversalAngle2Rate(arg1: dJointID) -> dReal;
}
extern "C" {
pub fn dJointGetPRAnchor(arg1: dJointID, result: *mut dReal);
}
extern "C" {
pub fn dJointGetPRPosition(arg1: dJointID) -> dReal;
}
extern "C" {
pub fn dJointGetPRPositionRate(arg1: dJointID) -> dReal;
}
extern "C" {
pub fn dJointGetPRAngle(arg1: dJointID) -> dReal;
}
extern "C" {
pub fn dJointGetPRAngleRate(arg1: dJointID) -> dReal;
}
extern "C" {
pub fn dJointGetPRAxis1(arg1: dJointID, result: *mut dReal);
}
extern "C" {
pub fn dJointGetPRAxis2(arg1: dJointID, result: *mut dReal);
}
extern "C" {
pub fn dJointGetPRParam(arg1: dJointID, parameter: ::std::os::raw::c_int) -> dReal;
}
extern "C" {
pub fn dJointGetPUAnchor(arg1: dJointID, result: *mut dReal);
}
extern "C" {
pub fn dJointGetPUPosition(arg1: dJointID) -> dReal;
}
extern "C" {
pub fn dJointGetPUPositionRate(arg1: dJointID) -> dReal;
}
extern "C" {
pub fn dJointGetPUAxis1(arg1: dJointID, result: *mut dReal);
}
extern "C" {
pub fn dJointGetPUAxis2(arg1: dJointID, result: *mut dReal);
}
extern "C" {
pub fn dJointGetPUAxis3(arg1: dJointID, result: *mut dReal);
}
extern "C" {
pub fn dJointGetPUAxisP(id: dJointID, result: *mut dReal);
}
extern "C" {
pub fn dJointGetPUAngles(arg1: dJointID, angle1: *mut dReal, angle2: *mut dReal);
}
extern "C" {
pub fn dJointGetPUAngle1(arg1: dJointID) -> dReal;
}
extern "C" {
pub fn dJointGetPUAngle1Rate(arg1: dJointID) -> dReal;
}
extern "C" {
pub fn dJointGetPUAngle2(arg1: dJointID) -> dReal;
}
extern "C" {
pub fn dJointGetPUAngle2Rate(arg1: dJointID) -> dReal;
}
extern "C" {
pub fn dJointGetPUParam(arg1: dJointID, parameter: ::std::os::raw::c_int) -> dReal;
}
extern "C" {
pub fn dJointGetPistonPosition(arg1: dJointID) -> dReal;
}
extern "C" {
pub fn dJointGetPistonPositionRate(arg1: dJointID) -> dReal;
}
extern "C" {
pub fn dJointGetPistonAngle(arg1: dJointID) -> dReal;
}
extern "C" {
pub fn dJointGetPistonAngleRate(arg1: dJointID) -> dReal;
}
extern "C" {
pub fn dJointGetPistonAnchor(arg1: dJointID, result: *mut dReal);
}
extern "C" {
pub fn dJointGetPistonAnchor2(arg1: dJointID, result: *mut dReal);
}
extern "C" {
pub fn dJointGetPistonAxis(arg1: dJointID, result: *mut dReal);
}
extern "C" {
pub fn dJointGetPistonParam(arg1: dJointID, parameter: ::std::os::raw::c_int) -> dReal;
}
extern "C" {
pub fn dJointGetAMotorNumAxes(arg1: dJointID) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn dJointGetAMotorAxis(arg1: dJointID, anum: ::std::os::raw::c_int, result: *mut dReal);
}
extern "C" {
pub fn dJointGetAMotorAxisRel(
arg1: dJointID,
anum: ::std::os::raw::c_int,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn dJointGetAMotorAngle(arg1: dJointID, anum: ::std::os::raw::c_int) -> dReal;
}
extern "C" {
pub fn dJointGetAMotorAngleRate(arg1: dJointID, anum: ::std::os::raw::c_int) -> dReal;
}
extern "C" {
pub fn dJointGetAMotorParam(arg1: dJointID, parameter: ::std::os::raw::c_int) -> dReal;
}
extern "C" {
pub fn dJointGetAMotorMode(arg1: dJointID) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn dJointGetLMotorNumAxes(arg1: dJointID) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn dJointGetLMotorAxis(arg1: dJointID, anum: ::std::os::raw::c_int, result: *mut dReal);
}
extern "C" {
pub fn dJointGetLMotorParam(arg1: dJointID, parameter: ::std::os::raw::c_int) -> dReal;
}
extern "C" {
pub fn dJointGetFixedParam(arg1: dJointID, parameter: ::std::os::raw::c_int) -> dReal;
}
extern "C" {
pub fn dJointGetTransmissionContactPoint1(arg1: dJointID, result: *mut dReal);
}
extern "C" {
pub fn dJointGetTransmissionContactPoint2(arg1: dJointID, result: *mut dReal);
}
extern "C" {
pub fn dJointSetTransmissionAxis1(arg1: dJointID, x: dReal, y: dReal, z: dReal);
}
extern "C" {
pub fn dJointGetTransmissionAxis1(arg1: dJointID, result: *mut dReal);
}
extern "C" {
pub fn dJointSetTransmissionAxis2(arg1: dJointID, x: dReal, y: dReal, z: dReal);
}
extern "C" {
pub fn dJointGetTransmissionAxis2(arg1: dJointID, result: *mut dReal);
}
extern "C" {
pub fn dJointSetTransmissionAnchor1(arg1: dJointID, x: dReal, y: dReal, z: dReal);
}
extern "C" {
pub fn dJointGetTransmissionAnchor1(arg1: dJointID, result: *mut dReal);
}
extern "C" {
pub fn dJointSetTransmissionAnchor2(arg1: dJointID, x: dReal, y: dReal, z: dReal);
}
extern "C" {
pub fn dJointGetTransmissionAnchor2(arg1: dJointID, result: *mut dReal);
}
extern "C" {
pub fn dJointSetTransmissionParam(
arg1: dJointID,
parameter: ::std::os::raw::c_int,
value: dReal,
);
}
extern "C" {
pub fn dJointGetTransmissionParam(arg1: dJointID, parameter: ::std::os::raw::c_int) -> dReal;
}
extern "C" {
pub fn dJointSetTransmissionMode(j: dJointID, mode: ::std::os::raw::c_int);
}
extern "C" {
pub fn dJointGetTransmissionMode(j: dJointID) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn dJointSetTransmissionRatio(j: dJointID, ratio: dReal);
}
extern "C" {
pub fn dJointGetTransmissionRatio(j: dJointID) -> dReal;
}
extern "C" {
pub fn dJointSetTransmissionAxis(j: dJointID, x: dReal, y: dReal, z: dReal);
}
extern "C" {
pub fn dJointGetTransmissionAxis(j: dJointID, result: *mut dReal);
}
extern "C" {
pub fn dJointGetTransmissionAngle1(j: dJointID) -> dReal;
}
extern "C" {
pub fn dJointGetTransmissionAngle2(j: dJointID) -> dReal;
}
extern "C" {
pub fn dJointGetTransmissionRadius1(j: dJointID) -> dReal;
}
extern "C" {
pub fn dJointGetTransmissionRadius2(j: dJointID) -> dReal;
}
extern "C" {
pub fn dJointSetTransmissionRadius1(j: dJointID, radius: dReal);
}
extern "C" {
pub fn dJointSetTransmissionRadius2(j: dJointID, radius: dReal);
}
extern "C" {
pub fn dJointGetTransmissionBacklash(j: dJointID) -> dReal;
}
extern "C" {
pub fn dJointSetTransmissionBacklash(j: dJointID, backlash: dReal);
}
extern "C" {
pub fn dJointSetDBallAnchor1(arg1: dJointID, x: dReal, y: dReal, z: dReal);
}
extern "C" {
pub fn dJointSetDBallAnchor2(arg1: dJointID, x: dReal, y: dReal, z: dReal);
}
extern "C" {
pub fn dJointGetDBallAnchor1(arg1: dJointID, result: *mut dReal);
}
extern "C" {
pub fn dJointGetDBallAnchor2(arg1: dJointID, result: *mut dReal);
}
extern "C" {
pub fn dJointGetDBallDistance(arg1: dJointID) -> dReal;
}
extern "C" {
pub fn dJointSetDBallDistance(arg1: dJointID, dist: dReal);
}
extern "C" {
pub fn dJointSetDBallParam(arg1: dJointID, parameter: ::std::os::raw::c_int, value: dReal);
}
extern "C" {
pub fn dJointGetDBallParam(arg1: dJointID, parameter: ::std::os::raw::c_int) -> dReal;
}
extern "C" {
pub fn dJointSetDHingeAxis(arg1: dJointID, x: dReal, y: dReal, z: dReal);
}
extern "C" {
pub fn dJointGetDHingeAxis(arg1: dJointID, result: *mut dReal);
}
extern "C" {
pub fn dJointSetDHingeAnchor1(arg1: dJointID, x: dReal, y: dReal, z: dReal);
}
extern "C" {
pub fn dJointSetDHingeAnchor2(arg1: dJointID, x: dReal, y: dReal, z: dReal);
}
extern "C" {
pub fn dJointGetDHingeAnchor1(arg1: dJointID, result: *mut dReal);
}
extern "C" {
pub fn dJointGetDHingeAnchor2(arg1: dJointID, result: *mut dReal);
}
extern "C" {
pub fn dJointGetDHingeDistance(arg1: dJointID) -> dReal;
}
extern "C" {
pub fn dJointSetDHingeParam(arg1: dJointID, parameter: ::std::os::raw::c_int, value: dReal);
}
extern "C" {
pub fn dJointGetDHingeParam(arg1: dJointID, parameter: ::std::os::raw::c_int) -> dReal;
}
extern "C" {
pub fn dConnectingJoint(arg1: dBodyID, arg2: dBodyID) -> dJointID;
}
extern "C" {
pub fn dConnectingJointList(
arg1: dBodyID,
arg2: dBodyID,
arg3: *mut dJointID,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn dAreConnected(arg1: dBodyID, arg2: dBodyID) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn dAreConnectedExcluding(
body1: dBodyID,
body2: dBodyID,
joint_type: ::std::os::raw::c_int,
) -> ::std::os::raw::c_int;
}
pub type dNearCallback = ::std::option::Option<
unsafe extern "C" fn(data: *mut ::std::os::raw::c_void, o1: dGeomID, o2: dGeomID),
>;
extern "C" {
pub fn dSimpleSpaceCreate(space: dSpaceID) -> dSpaceID;
}
extern "C" {
pub fn dHashSpaceCreate(space: dSpaceID) -> dSpaceID;
}
extern "C" {
pub fn dQuadTreeSpaceCreate(
space: dSpaceID,
Center: *mut dReal,
Extents: *mut dReal,
Depth: ::std::os::raw::c_int,
) -> dSpaceID;
}
extern "C" {
pub fn dSweepAndPruneSpaceCreate(space: dSpaceID, axisorder: ::std::os::raw::c_int)
-> dSpaceID;
}
extern "C" {
pub fn dSpaceDestroy(arg1: dSpaceID);
}
extern "C" {
pub fn dHashSpaceSetLevels(
space: dSpaceID,
minlevel: ::std::os::raw::c_int,
maxlevel: ::std::os::raw::c_int,
);
}
extern "C" {
pub fn dHashSpaceGetLevels(
space: dSpaceID,
minlevel: *mut ::std::os::raw::c_int,
maxlevel: *mut ::std::os::raw::c_int,
);
}
extern "C" {
pub fn dSpaceSetCleanup(space: dSpaceID, mode: ::std::os::raw::c_int);
}
extern "C" {
pub fn dSpaceGetCleanup(space: dSpaceID) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn dSpaceSetSublevel(space: dSpaceID, sublevel: ::std::os::raw::c_int);
}
extern "C" {
pub fn dSpaceGetSublevel(space: dSpaceID) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn dSpaceSetManualCleanup(space: dSpaceID, mode: ::std::os::raw::c_int);
}
extern "C" {
pub fn dSpaceGetManualCleanup(space: dSpaceID) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn dSpaceAdd(arg1: dSpaceID, arg2: dGeomID);
}
extern "C" {
pub fn dSpaceRemove(arg1: dSpaceID, arg2: dGeomID);
}
extern "C" {
pub fn dSpaceQuery(arg1: dSpaceID, arg2: dGeomID) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn dSpaceClean(arg1: dSpaceID);
}
extern "C" {
pub fn dSpaceGetNumGeoms(arg1: dSpaceID) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn dSpaceGetGeom(arg1: dSpaceID, i: ::std::os::raw::c_int) -> dGeomID;
}
extern "C" {
pub fn dSpaceGetClass(space: dSpaceID) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn dGeomDestroy(geom: dGeomID);
}
extern "C" {
pub fn dGeomSetData(geom: dGeomID, data: *mut ::std::os::raw::c_void);
}
extern "C" {
pub fn dGeomGetData(geom: dGeomID) -> *mut ::std::os::raw::c_void;
}
extern "C" {
pub fn dGeomSetBody(geom: dGeomID, body: dBodyID);
}
extern "C" {
pub fn dGeomGetBody(geom: dGeomID) -> dBodyID;
}
extern "C" {
pub fn dGeomSetPosition(geom: dGeomID, x: dReal, y: dReal, z: dReal);
}
extern "C" {
pub fn dGeomSetRotation(geom: dGeomID, R: *mut dReal);
}
extern "C" {
pub fn dGeomSetQuaternion(geom: dGeomID, Q: *mut dReal);
}
extern "C" {
pub fn dGeomGetPosition(geom: dGeomID) -> *const dReal;
}
extern "C" {
pub fn dGeomCopyPosition(geom: dGeomID, pos: *mut dReal);
}
extern "C" {
pub fn dGeomGetRotation(geom: dGeomID) -> *const dReal;
}
extern "C" {
pub fn dGeomCopyRotation(geom: dGeomID, R: *mut dReal);
}
extern "C" {
pub fn dGeomGetQuaternion(geom: dGeomID, result: *mut dReal);
}
extern "C" {
pub fn dGeomGetAABB(geom: dGeomID, aabb: *mut dReal);
}
extern "C" {
pub fn dGeomIsSpace(geom: dGeomID) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn dGeomGetSpace(arg1: dGeomID) -> dSpaceID;
}
extern "C" {
pub fn dGeomGetClass(geom: dGeomID) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn dGeomSetCategoryBits(geom: dGeomID, bits: ::std::os::raw::c_ulong);
}
extern "C" {
pub fn dGeomSetCollideBits(geom: dGeomID, bits: ::std::os::raw::c_ulong);
}
extern "C" {
pub fn dGeomGetCategoryBits(arg1: dGeomID) -> ::std::os::raw::c_ulong;
}
extern "C" {
pub fn dGeomGetCollideBits(arg1: dGeomID) -> ::std::os::raw::c_ulong;
}
extern "C" {
pub fn dGeomEnable(geom: dGeomID);
}
extern "C" {
pub fn dGeomDisable(geom: dGeomID);
}
extern "C" {
pub fn dGeomIsEnabled(geom: dGeomID) -> ::std::os::raw::c_int;
}
pub const dGeomCommonControlClass: _bindgen_ty_6 = 0;
pub const dGeomColliderControlClass: _bindgen_ty_6 = 1;
pub type _bindgen_ty_6 = ::std::os::raw::c_int;
pub const dGeomCommonAnyControlCode: _bindgen_ty_7 = 0;
pub const dGeomColliderSetMergeSphereContactsControlCode: _bindgen_ty_7 = 1;
pub const dGeomColliderGetMergeSphereContactsControlCode: _bindgen_ty_7 = 2;
pub type _bindgen_ty_7 = ::std::os::raw::c_int;
pub const dGeomColliderMergeContactsValue__Default: _bindgen_ty_8 = 0;
pub const dGeomColliderMergeContactsValue_None: _bindgen_ty_8 = 1;
pub const dGeomColliderMergeContactsValue_Normals: _bindgen_ty_8 = 2;
pub const dGeomColliderMergeContactsValue_Full: _bindgen_ty_8 = 3;
pub type _bindgen_ty_8 = ::std::os::raw::c_int;
extern "C" {
pub fn dGeomLowLevelControl(
geom: dGeomID,
controlClass: ::std::os::raw::c_int,
controlCode: ::std::os::raw::c_int,
dataValue: *mut ::std::os::raw::c_void,
dataSize: *mut ::std::os::raw::c_int,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn dGeomGetRelPointPos(geom: dGeomID, px: dReal, py: dReal, pz: dReal, result: *mut dReal);
}
extern "C" {
pub fn dGeomGetPosRelPoint(geom: dGeomID, px: dReal, py: dReal, pz: dReal, result: *mut dReal);
}
extern "C" {
pub fn dGeomVectorToWorld(geom: dGeomID, px: dReal, py: dReal, pz: dReal, result: *mut dReal);
}
extern "C" {
pub fn dGeomVectorFromWorld(geom: dGeomID, px: dReal, py: dReal, pz: dReal, result: *mut dReal);
}
extern "C" {
pub fn dGeomSetOffsetPosition(geom: dGeomID, x: dReal, y: dReal, z: dReal);
}
extern "C" {
pub fn dGeomSetOffsetRotation(geom: dGeomID, R: *mut dReal);
}
extern "C" {
pub fn dGeomSetOffsetQuaternion(geom: dGeomID, Q: *mut dReal);
}
extern "C" {
pub fn dGeomSetOffsetWorldPosition(geom: dGeomID, x: dReal, y: dReal, z: dReal);
}
extern "C" {
pub fn dGeomSetOffsetWorldRotation(geom: dGeomID, R: *mut dReal);
}
extern "C" {
pub fn dGeomSetOffsetWorldQuaternion(geom: dGeomID, arg1: *mut dReal);
}
extern "C" {
pub fn dGeomClearOffset(geom: dGeomID);
}
extern "C" {
pub fn dGeomIsOffset(geom: dGeomID) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn dGeomGetOffsetPosition(geom: dGeomID) -> *const dReal;
}
extern "C" {
pub fn dGeomCopyOffsetPosition(geom: dGeomID, pos: *mut dReal);
}
extern "C" {
pub fn dGeomGetOffsetRotation(geom: dGeomID) -> *const dReal;
}
extern "C" {
pub fn dGeomCopyOffsetRotation(geom: dGeomID, R: *mut dReal);
}
extern "C" {
pub fn dGeomGetOffsetQuaternion(geom: dGeomID, result: *mut dReal);
}
extern "C" {
pub fn dCollide(
o1: dGeomID,
o2: dGeomID,
flags: ::std::os::raw::c_int,
contact: *mut dContactGeom,
skip: ::std::os::raw::c_int,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn dSpaceCollide(
space: dSpaceID,
data: *mut ::std::os::raw::c_void,
callback: dNearCallback,
);
}
extern "C" {
pub fn dSpaceCollide2(
space1: dGeomID,
space2: dGeomID,
data: *mut ::std::os::raw::c_void,
callback: dNearCallback,
);
}
pub const dMaxUserClasses: _bindgen_ty_9 = 4;
pub type _bindgen_ty_9 = ::std::os::raw::c_int;
pub const dSphereClass: _bindgen_ty_10 = 0;
pub const dBoxClass: _bindgen_ty_10 = 1;
pub const dCapsuleClass: _bindgen_ty_10 = 2;
pub const dCylinderClass: _bindgen_ty_10 = 3;
pub const dPlaneClass: _bindgen_ty_10 = 4;
pub const dRayClass: _bindgen_ty_10 = 5;
pub const dConvexClass: _bindgen_ty_10 = 6;
pub const dGeomTransformClass: _bindgen_ty_10 = 7;
pub const dTriMeshClass: _bindgen_ty_10 = 8;
pub const dHeightfieldClass: _bindgen_ty_10 = 9;
pub const dFirstSpaceClass: _bindgen_ty_10 = 10;
pub const dSimpleSpaceClass: _bindgen_ty_10 = 10;
pub const dHashSpaceClass: _bindgen_ty_10 = 11;
pub const dSweepAndPruneSpaceClass: _bindgen_ty_10 = 12;
pub const dQuadTreeSpaceClass: _bindgen_ty_10 = 13;
pub const dLastSpaceClass: _bindgen_ty_10 = 13;
pub const dFirstUserClass: _bindgen_ty_10 = 14;
pub const dLastUserClass: _bindgen_ty_10 = 17;
pub const dGeomNumClasses: _bindgen_ty_10 = 18;
pub type _bindgen_ty_10 = ::std::os::raw::c_int;
extern "C" {
pub fn dCreateSphere(space: dSpaceID, radius: dReal) -> dGeomID;
}
extern "C" {
pub fn dGeomSphereSetRadius(sphere: dGeomID, radius: dReal);
}
extern "C" {
pub fn dGeomSphereGetRadius(sphere: dGeomID) -> dReal;
}
extern "C" {
pub fn dGeomSpherePointDepth(sphere: dGeomID, x: dReal, y: dReal, z: dReal) -> dReal;
}
extern "C" {
pub fn dCreateConvex(
space: dSpaceID,
_planes: *const dReal,
_planecount: ::std::os::raw::c_uint,
_points: *const dReal,
_pointcount: ::std::os::raw::c_uint,
_polygons: *const ::std::os::raw::c_uint,
) -> dGeomID;
}
extern "C" {
pub fn dGeomSetConvex(
g: dGeomID,
_planes: *const dReal,
_count: ::std::os::raw::c_uint,
_points: *const dReal,
_pointcount: ::std::os::raw::c_uint,
_polygons: *const ::std::os::raw::c_uint,
);
}
extern "C" {
pub fn dCreateBox(space: dSpaceID, lx: dReal, ly: dReal, lz: dReal) -> dGeomID;
}
extern "C" {
pub fn dGeomBoxSetLengths(box_: dGeomID, lx: dReal, ly: dReal, lz: dReal);
}
extern "C" {
pub fn dGeomBoxGetLengths(box_: dGeomID, result: *mut dReal);
}
extern "C" {
pub fn dGeomBoxPointDepth(box_: dGeomID, x: dReal, y: dReal, z: dReal) -> dReal;
}
extern "C" {
pub fn dCreatePlane(space: dSpaceID, a: dReal, b: dReal, c: dReal, d: dReal) -> dGeomID;
}
extern "C" {
pub fn dGeomPlaneSetParams(plane: dGeomID, a: dReal, b: dReal, c: dReal, d: dReal);
}
extern "C" {
pub fn dGeomPlaneGetParams(plane: dGeomID, result: *mut dReal);
}
extern "C" {
pub fn dGeomPlanePointDepth(plane: dGeomID, x: dReal, y: dReal, z: dReal) -> dReal;
}
extern "C" {
pub fn dCreateCapsule(space: dSpaceID, radius: dReal, length: dReal) -> dGeomID;
}
extern "C" {
pub fn dGeomCapsuleSetParams(ccylinder: dGeomID, radius: dReal, length: dReal);
}
extern "C" {
pub fn dGeomCapsuleGetParams(ccylinder: dGeomID, radius: *mut dReal, length: *mut dReal);
}
extern "C" {
pub fn dGeomCapsulePointDepth(ccylinder: dGeomID, x: dReal, y: dReal, z: dReal) -> dReal;
}
extern "C" {
pub fn dCreateCylinder(space: dSpaceID, radius: dReal, length: dReal) -> dGeomID;
}
extern "C" {
pub fn dGeomCylinderSetParams(cylinder: dGeomID, radius: dReal, length: dReal);
}
extern "C" {
pub fn dGeomCylinderGetParams(cylinder: dGeomID, radius: *mut dReal, length: *mut dReal);
}
extern "C" {
pub fn dCreateRay(space: dSpaceID, length: dReal) -> dGeomID;
}
extern "C" {
pub fn dGeomRaySetLength(ray: dGeomID, length: dReal);
}
extern "C" {
pub fn dGeomRayGetLength(ray: dGeomID) -> dReal;
}
extern "C" {
pub fn dGeomRaySet(
ray: dGeomID,
px: dReal,
py: dReal,
pz: dReal,
dx: dReal,
dy: dReal,
dz: dReal,
);
}
extern "C" {
pub fn dGeomRayGet(ray: dGeomID, start: *mut dReal, dir: *mut dReal);
}
extern "C" {
pub fn dGeomRaySetParams(
g: dGeomID,
FirstContact: ::std::os::raw::c_int,
BackfaceCull: ::std::os::raw::c_int,
);
}
extern "C" {
pub fn dGeomRayGetParams(
g: dGeomID,
FirstContact: *mut ::std::os::raw::c_int,
BackfaceCull: *mut ::std::os::raw::c_int,
);
}
extern "C" {
pub fn dGeomRaySetFirstContact(g: dGeomID, firstContact: ::std::os::raw::c_int);
}
extern "C" {
pub fn dGeomRayGetFirstContact(g: dGeomID) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn dGeomRaySetBackfaceCull(g: dGeomID, backfaceCull: ::std::os::raw::c_int);
}
extern "C" {
pub fn dGeomRayGetBackfaceCull(g: dGeomID) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn dGeomRaySetClosestHit(g: dGeomID, closestHit: ::std::os::raw::c_int);
}
extern "C" {
pub fn dGeomRayGetClosestHit(g: dGeomID) -> ::std::os::raw::c_int;
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct dxTriMeshData {
_unused: [u8; 0],
}
pub type dTriMeshDataID = *mut dxTriMeshData;
pub const dMeshTriangleVertex_dMTV__MIN: dMeshTriangleVertex = 0;
pub const dMeshTriangleVertex_dMTV_FIRST: dMeshTriangleVertex = 0;
pub const dMeshTriangleVertex_dMTV_SECOND: dMeshTriangleVertex = 1;
pub const dMeshTriangleVertex_dMTV_THIRD: dMeshTriangleVertex = 2;
pub const dMeshTriangleVertex_dMTV__MAX: dMeshTriangleVertex = 3;
pub type dMeshTriangleVertex = ::std::os::raw::c_int;
extern "C" {
pub fn dGeomTriMeshDataCreate() -> dTriMeshDataID;
}
extern "C" {
pub fn dGeomTriMeshDataDestroy(g: dTriMeshDataID);
}
pub const dTRIMESHDATA__MIN: _bindgen_ty_11 = 0;
pub const dTRIMESHDATA_FACE_NORMALS: _bindgen_ty_11 = 0;
pub const dTRIMESHDATA_USE_FLAGS: _bindgen_ty_11 = 1;
pub const dTRIMESHDATA__MAX: _bindgen_ty_11 = 2;
pub const TRIMESH_FACE_NORMALS: _bindgen_ty_11 = 0;
pub type _bindgen_ty_11 = ::std::os::raw::c_int;
pub const dMESHDATAUSE_EDGE1: _bindgen_ty_12 = 1;
pub const dMESHDATAUSE_EDGE2: _bindgen_ty_12 = 2;
pub const dMESHDATAUSE_EDGE3: _bindgen_ty_12 = 4;
pub const dMESHDATAUSE_VERTEX1: _bindgen_ty_12 = 8;
pub const dMESHDATAUSE_VERTEX2: _bindgen_ty_12 = 16;
pub const dMESHDATAUSE_VERTEX3: _bindgen_ty_12 = 32;
pub type _bindgen_ty_12 = ::std::os::raw::c_int;
extern "C" {
pub fn dGeomTriMeshDataSet(
g: dTriMeshDataID,
data_id: ::std::os::raw::c_int,
in_data: *mut ::std::os::raw::c_void,
);
}
extern "C" {
pub fn dGeomTriMeshDataGet(
g: dTriMeshDataID,
data_id: ::std::os::raw::c_int,
) -> *mut ::std::os::raw::c_void;
}
extern "C" {
pub fn dGeomTriMeshDataGet2(
g: dTriMeshDataID,
data_id: ::std::os::raw::c_int,
pout_size: *mut dsizeint,
) -> *mut ::std::os::raw::c_void;
}
extern "C" {
pub fn dGeomTriMeshSetLastTransform(g: dGeomID, last_trans: *mut dReal);
}
extern "C" {
pub fn dGeomTriMeshGetLastTransform(g: dGeomID) -> *const dReal;
}
extern "C" {
pub fn dGeomTriMeshDataBuildSingle(
g: dTriMeshDataID,
Vertices: *const ::std::os::raw::c_void,
VertexStride: ::std::os::raw::c_int,
VertexCount: ::std::os::raw::c_int,
Indices: *const ::std::os::raw::c_void,
IndexCount: ::std::os::raw::c_int,
TriStride: ::std::os::raw::c_int,
);
}
extern "C" {
pub fn dGeomTriMeshDataBuildSingle1(
g: dTriMeshDataID,
Vertices: *const ::std::os::raw::c_void,
VertexStride: ::std::os::raw::c_int,
VertexCount: ::std::os::raw::c_int,
Indices: *const ::std::os::raw::c_void,
IndexCount: ::std::os::raw::c_int,
TriStride: ::std::os::raw::c_int,
Normals: *const ::std::os::raw::c_void,
);
}
extern "C" {
pub fn dGeomTriMeshDataBuildDouble(
g: dTriMeshDataID,
Vertices: *const ::std::os::raw::c_void,
VertexStride: ::std::os::raw::c_int,
VertexCount: ::std::os::raw::c_int,
Indices: *const ::std::os::raw::c_void,
IndexCount: ::std::os::raw::c_int,
TriStride: ::std::os::raw::c_int,
);
}
extern "C" {
pub fn dGeomTriMeshDataBuildDouble1(
g: dTriMeshDataID,
Vertices: *const ::std::os::raw::c_void,
VertexStride: ::std::os::raw::c_int,
VertexCount: ::std::os::raw::c_int,
Indices: *const ::std::os::raw::c_void,
IndexCount: ::std::os::raw::c_int,
TriStride: ::std::os::raw::c_int,
Normals: *const ::std::os::raw::c_void,
);
}
extern "C" {
pub fn dGeomTriMeshDataBuildSimple(
g: dTriMeshDataID,
Vertices: *const dReal,
VertexCount: ::std::os::raw::c_int,
Indices: *const dTriIndex,
IndexCount: ::std::os::raw::c_int,
);
}
extern "C" {
pub fn dGeomTriMeshDataBuildSimple1(
g: dTriMeshDataID,
Vertices: *const dReal,
VertexCount: ::std::os::raw::c_int,
Indices: *const dTriIndex,
IndexCount: ::std::os::raw::c_int,
Normals: *const ::std::os::raw::c_int,
);
}
pub const dTRIDATAPREPROCESS_BUILD__MIN: _bindgen_ty_13 = 0;
pub const dTRIDATAPREPROCESS_BUILD_CONCAVE_EDGES: _bindgen_ty_13 = 0;
pub const dTRIDATAPREPROCESS_BUILD_FACE_ANGLES: _bindgen_ty_13 = 1;
pub const dTRIDATAPREPROCESS_BUILD__MAX: _bindgen_ty_13 = 2;
pub type _bindgen_ty_13 = ::std::os::raw::c_int;
pub const dTRIDATAPREPROCESS_FACE_ANGLES_EXTRA__MIN: _bindgen_ty_14 = 0;
pub const dTRIDATAPREPROCESS_FACE_ANGLES_EXTRA_BYTE_POSITIVE: _bindgen_ty_14 = 0;
pub const dTRIDATAPREPROCESS_FACE_ANGLES_EXTRA_BYTE_ALL: _bindgen_ty_14 = 1;
pub const dTRIDATAPREPROCESS_FACE_ANGLES_EXTRA_WORD_ALL: _bindgen_ty_14 = 2;
pub const dTRIDATAPREPROCESS_FACE_ANGLES_EXTRA__MAX: _bindgen_ty_14 = 3;
pub const dTRIDATAPREPROCESS_FACE_ANGLES_EXTRA__DEFAULT: _bindgen_ty_14 = 0;
pub type _bindgen_ty_14 = ::std::os::raw::c_int;
extern "C" {
pub fn dGeomTriMeshDataPreprocess2(
g: dTriMeshDataID,
buildRequestFlags: ::std::os::raw::c_uint,
requestExtraData: *const dintptr,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn dGeomTriMeshDataPreprocess(g: dTriMeshDataID) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn dGeomTriMeshDataGetBuffer(
g: dTriMeshDataID,
buf: *mut *mut ::std::os::raw::c_uchar,
bufLen: *mut ::std::os::raw::c_int,
);
}
extern "C" {
pub fn dGeomTriMeshDataSetBuffer(g: dTriMeshDataID, buf: *mut ::std::os::raw::c_uchar);
}
pub type dTriCallback = ::std::option::Option<
unsafe extern "C" fn(
TriMesh: dGeomID,
RefObject: dGeomID,
TriangleIndex: ::std::os::raw::c_int,
) -> ::std::os::raw::c_int,
>;
extern "C" {
pub fn dGeomTriMeshSetCallback(g: dGeomID, Callback: dTriCallback);
}
extern "C" {
pub fn dGeomTriMeshGetCallback(g: dGeomID) -> dTriCallback;
}
pub type dTriArrayCallback = ::std::option::Option<
unsafe extern "C" fn(
TriMesh: dGeomID,
RefObject: dGeomID,
TriIndices: *const ::std::os::raw::c_int,
TriCount: ::std::os::raw::c_int,
),
>;
extern "C" {
pub fn dGeomTriMeshSetArrayCallback(g: dGeomID, ArrayCallback: dTriArrayCallback);
}
extern "C" {
pub fn dGeomTriMeshGetArrayCallback(g: dGeomID) -> dTriArrayCallback;
}
pub type dTriRayCallback = ::std::option::Option<
unsafe extern "C" fn(
TriMesh: dGeomID,
Ray: dGeomID,
TriangleIndex: ::std::os::raw::c_int,
u: dReal,
v: dReal,
) -> ::std::os::raw::c_int,
>;
extern "C" {
pub fn dGeomTriMeshSetRayCallback(g: dGeomID, Callback: dTriRayCallback);
}
extern "C" {
pub fn dGeomTriMeshGetRayCallback(g: dGeomID) -> dTriRayCallback;
}
pub type dTriTriMergeCallback = ::std::option::Option<
unsafe extern "C" fn(
TriMesh: dGeomID,
FirstTriangleIndex: ::std::os::raw::c_int,
SecondTriangleIndex: ::std::os::raw::c_int,
) -> ::std::os::raw::c_int,
>;
extern "C" {
pub fn dGeomTriMeshSetTriMergeCallback(g: dGeomID, Callback: dTriTriMergeCallback);
}
extern "C" {
pub fn dGeomTriMeshGetTriMergeCallback(g: dGeomID) -> dTriTriMergeCallback;
}
extern "C" {
pub fn dCreateTriMesh(
space: dSpaceID,
Data: dTriMeshDataID,
Callback: dTriCallback,
ArrayCallback: dTriArrayCallback,
RayCallback: dTriRayCallback,
) -> dGeomID;
}
extern "C" {
pub fn dGeomTriMeshSetData(g: dGeomID, Data: dTriMeshDataID);
}
extern "C" {
pub fn dGeomTriMeshGetData(g: dGeomID) -> dTriMeshDataID;
}
extern "C" {
pub fn dGeomTriMeshEnableTC(
g: dGeomID,
geomClass: ::std::os::raw::c_int,
enable: ::std::os::raw::c_int,
);
}
extern "C" {
pub fn dGeomTriMeshIsTCEnabled(
g: dGeomID,
geomClass: ::std::os::raw::c_int,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn dGeomTriMeshClearTCCache(g: dGeomID);
}
extern "C" {
pub fn dGeomTriMeshGetTriMeshDataID(g: dGeomID) -> dTriMeshDataID;
}
extern "C" {
pub fn dGeomTriMeshGetTriangle(
g: dGeomID,
Index: ::std::os::raw::c_int,
v0: *mut dVector3,
v1: *mut dVector3,
v2: *mut dVector3,
);
}
extern "C" {
pub fn dGeomTriMeshGetPoint(
g: dGeomID,
Index: ::std::os::raw::c_int,
u: dReal,
v: dReal,
Out: *mut dReal,
);
}
extern "C" {
pub fn dGeomTriMeshGetTriangleCount(g: dGeomID) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn dGeomTriMeshDataUpdate(g: dTriMeshDataID);
}
extern "C" {
pub fn dCreateGeomTransform(space: dSpaceID) -> dGeomID;
}
extern "C" {
pub fn dGeomTransformSetGeom(g: dGeomID, obj: dGeomID);
}
extern "C" {
pub fn dGeomTransformGetGeom(g: dGeomID) -> dGeomID;
}
extern "C" {
pub fn dGeomTransformSetCleanup(g: dGeomID, mode: ::std::os::raw::c_int);
}
extern "C" {
pub fn dGeomTransformGetCleanup(g: dGeomID) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn dGeomTransformSetInfo(g: dGeomID, mode: ::std::os::raw::c_int);
}
extern "C" {
pub fn dGeomTransformGetInfo(g: dGeomID) -> ::std::os::raw::c_int;
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct dxHeightfieldData {
_unused: [u8; 0],
}
pub type dHeightfieldDataID = *mut dxHeightfieldData;
pub type dHeightfieldGetHeight = ::std::option::Option<
unsafe extern "C" fn(
p_user_data: *mut ::std::os::raw::c_void,
x: ::std::os::raw::c_int,
z: ::std::os::raw::c_int,
) -> dReal,
>;
extern "C" {
pub fn dCreateHeightfield(
space: dSpaceID,
data: dHeightfieldDataID,
bPlaceable: ::std::os::raw::c_int,
) -> dGeomID;
}
extern "C" {
pub fn dGeomHeightfieldDataCreate() -> dHeightfieldDataID;
}
extern "C" {
pub fn dGeomHeightfieldDataDestroy(d: dHeightfieldDataID);
}
extern "C" {
pub fn dGeomHeightfieldDataBuildCallback(
d: dHeightfieldDataID,
pUserData: *mut ::std::os::raw::c_void,
pCallback: dHeightfieldGetHeight,
width: dReal,
depth: dReal,
widthSamples: ::std::os::raw::c_int,
depthSamples: ::std::os::raw::c_int,
scale: dReal,
offset: dReal,
thickness: dReal,
bWrap: ::std::os::raw::c_int,
);
}
extern "C" {
pub fn dGeomHeightfieldDataBuildByte(
d: dHeightfieldDataID,
pHeightData: *const ::std::os::raw::c_uchar,
bCopyHeightData: ::std::os::raw::c_int,
width: dReal,
depth: dReal,
widthSamples: ::std::os::raw::c_int,
depthSamples: ::std::os::raw::c_int,
scale: dReal,
offset: dReal,
thickness: dReal,
bWrap: ::std::os::raw::c_int,
);
}
extern "C" {
pub fn dGeomHeightfieldDataBuildShort(
d: dHeightfieldDataID,
pHeightData: *const ::std::os::raw::c_short,
bCopyHeightData: ::std::os::raw::c_int,
width: dReal,
depth: dReal,
widthSamples: ::std::os::raw::c_int,
depthSamples: ::std::os::raw::c_int,
scale: dReal,
offset: dReal,
thickness: dReal,
bWrap: ::std::os::raw::c_int,
);
}
extern "C" {
pub fn dGeomHeightfieldDataBuildSingle(
d: dHeightfieldDataID,
pHeightData: *const f32,
bCopyHeightData: ::std::os::raw::c_int,
width: dReal,
depth: dReal,
widthSamples: ::std::os::raw::c_int,
depthSamples: ::std::os::raw::c_int,
scale: dReal,
offset: dReal,
thickness: dReal,
bWrap: ::std::os::raw::c_int,
);
}
extern "C" {
pub fn dGeomHeightfieldDataBuildDouble(
d: dHeightfieldDataID,
pHeightData: *const f64,
bCopyHeightData: ::std::os::raw::c_int,
width: dReal,
depth: dReal,
widthSamples: ::std::os::raw::c_int,
depthSamples: ::std::os::raw::c_int,
scale: dReal,
offset: dReal,
thickness: dReal,
bWrap: ::std::os::raw::c_int,
);
}
extern "C" {
pub fn dGeomHeightfieldDataSetBounds(d: dHeightfieldDataID, minHeight: dReal, maxHeight: dReal);
}
extern "C" {
pub fn dGeomHeightfieldSetHeightfieldData(g: dGeomID, d: dHeightfieldDataID);
}
extern "C" {
pub fn dGeomHeightfieldGetHeightfieldData(g: dGeomID) -> dHeightfieldDataID;
}
extern "C" {
pub fn dClosestLineSegmentPoints(
a1: *mut dReal,
a2: *mut dReal,
b1: *mut dReal,
b2: *mut dReal,
cp1: *mut dReal,
cp2: *mut dReal,
);
}
extern "C" {
pub fn dBoxTouchesBox(
_p1: *mut dReal,
R1: *mut dReal,
side1: *mut dReal,
_p2: *mut dReal,
R2: *mut dReal,
side2: *mut dReal,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn dBoxBox(
p1: *mut dReal,
R1: *mut dReal,
side1: *mut dReal,
p2: *mut dReal,
R2: *mut dReal,
side2: *mut dReal,
normal: *mut dReal,
depth: *mut dReal,
return_code: *mut ::std::os::raw::c_int,
flags: ::std::os::raw::c_int,
contact: *mut dContactGeom,
skip: ::std::os::raw::c_int,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn dInfiniteAABB(geom: dGeomID, aabb: *mut dReal);
}
pub type dGetAABBFn = ::std::option::Option<unsafe extern "C" fn(arg1: dGeomID, aabb: *mut dReal)>;
pub type dColliderFn = ::std::option::Option<
unsafe extern "C" fn(
o1: dGeomID,
o2: dGeomID,
flags: ::std::os::raw::c_int,
contact: *mut dContactGeom,
skip: ::std::os::raw::c_int,
) -> ::std::os::raw::c_int,
>;
pub type dGetColliderFnFn =
::std::option::Option<unsafe extern "C" fn(num: ::std::os::raw::c_int) -> dColliderFn>;
pub type dGeomDtorFn = ::std::option::Option<unsafe extern "C" fn(o: dGeomID)>;
pub type dAABBTestFn = ::std::option::Option<
unsafe extern "C" fn(o1: dGeomID, o2: dGeomID, aabb: *mut dReal) -> ::std::os::raw::c_int,
>;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct dGeomClass {
pub bytes: ::std::os::raw::c_int,
pub collider: dGetColliderFnFn,
pub aabb: dGetAABBFn,
pub aabb_test: dAABBTestFn,
pub dtor: dGeomDtorFn,
}
#[test]
fn bindgen_test_layout_dGeomClass() {
const UNINIT: ::std::mem::MaybeUninit<dGeomClass> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<dGeomClass>(),
40usize,
concat!("Size of: ", stringify!(dGeomClass))
);
assert_eq!(
::std::mem::align_of::<dGeomClass>(),
8usize,
concat!("Alignment of ", stringify!(dGeomClass))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).bytes) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(dGeomClass),
"::",
stringify!(bytes)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).collider) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(dGeomClass),
"::",
stringify!(collider)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).aabb) as usize - ptr as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(dGeomClass),
"::",
stringify!(aabb)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).aabb_test) as usize - ptr as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(dGeomClass),
"::",
stringify!(aabb_test)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).dtor) as usize - ptr as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(dGeomClass),
"::",
stringify!(dtor)
)
);
}
extern "C" {
pub fn dCreateGeomClass(classptr: *const dGeomClass) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn dGeomGetClassData(arg1: dGeomID) -> *mut ::std::os::raw::c_void;
}
extern "C" {
pub fn dCreateGeom(classnum: ::std::os::raw::c_int) -> dGeomID;
}
extern "C" {
pub fn dSetColliderOverride(
i: ::std::os::raw::c_int,
j: ::std::os::raw::c_int,
fn_: dColliderFn,
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct dxThreadingThreadPool {
_unused: [u8; 0],
}
pub type dThreadingThreadPoolID = *mut dxThreadingThreadPool;
extern "C" {
pub fn dThreadingAllocateSelfThreadedImplementation() -> dThreadingImplementationID;
}
extern "C" {
pub fn dThreadingAllocateMultiThreadedImplementation() -> dThreadingImplementationID;
}
extern "C" {
pub fn dThreadingImplementationGetFunctions(
impl_: dThreadingImplementationID,
) -> *const dThreadingFunctionsInfo;
}
extern "C" {
pub fn dThreadingImplementationShutdownProcessing(impl_: dThreadingImplementationID);
}
extern "C" {
pub fn dThreadingImplementationCleanupForRestart(impl_: dThreadingImplementationID);
}
extern "C" {
pub fn dThreadingFreeImplementation(impl_: dThreadingImplementationID);
}
pub type dThreadReadyToServeCallback =
::std::option::Option<unsafe extern "C" fn(callback_context: *mut ::std::os::raw::c_void)>;
extern "C" {
pub fn dExternalThreadingServeMultiThreadedImplementation(
impl_: dThreadingImplementationID,
readiness_callback: dThreadReadyToServeCallback,
callback_context: *mut ::std::os::raw::c_void,
);
}
extern "C" {
pub fn dThreadingAllocateThreadPool(
thread_count: ::std::os::raw::c_uint,
stack_size: dsizeint,
ode_data_allocate_flags: ::std::os::raw::c_uint,
reserved: *mut ::std::os::raw::c_void,
) -> dThreadingThreadPoolID;
}
extern "C" {
pub fn dThreadingThreadPoolServeMultiThreadedImplementation(
pool: dThreadingThreadPoolID,
impl_: dThreadingImplementationID,
);
}
extern "C" {
pub fn dThreadingThreadPoolWaitIdleState(pool: dThreadingThreadPoolID);
}
extern "C" {
pub fn dThreadingFreeThreadPool(pool: dThreadingThreadPoolID);
}
extern "C" {
pub fn dWorldExportDIF(w: dWorldID, file: *mut FILE, world_name: *const ::std::os::raw::c_char);
}
#[repr(C)]
#[derive(Debug)]
pub struct dWorldSimpleIDContainer {
pub _id: dWorldID,
}
#[test]
fn bindgen_test_layout_dWorldSimpleIDContainer() {
const UNINIT: ::std::mem::MaybeUninit<dWorldSimpleIDContainer> =
::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<dWorldSimpleIDContainer>(),
8usize,
concat!("Size of: ", stringify!(dWorldSimpleIDContainer))
);
assert_eq!(
::std::mem::align_of::<dWorldSimpleIDContainer>(),
8usize,
concat!("Alignment of ", stringify!(dWorldSimpleIDContainer))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr)._id) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(dWorldSimpleIDContainer),
"::",
stringify!(_id)
)
);
}
#[repr(C)]
pub struct dWorldDynamicIDContainer__bindgen_vtable(::std::os::raw::c_void);
#[repr(C)]
#[derive(Debug)]
pub struct dWorldDynamicIDContainer {
pub vtable_: *const dWorldDynamicIDContainer__bindgen_vtable,
pub _base: dWorldSimpleIDContainer,
}
#[test]
fn bindgen_test_layout_dWorldDynamicIDContainer() {
assert_eq!(
::std::mem::size_of::<dWorldDynamicIDContainer>(),
16usize,
concat!("Size of: ", stringify!(dWorldDynamicIDContainer))
);
assert_eq!(
::std::mem::align_of::<dWorldDynamicIDContainer>(),
8usize,
concat!("Alignment of ", stringify!(dWorldDynamicIDContainer))
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct dWorldTemplate<dWorldTemplateBase> {
pub _base: dWorldTemplateBase,
pub _phantom_0: ::std::marker::PhantomData<::std::cell::UnsafeCell<dWorldTemplateBase>>,
}
#[repr(C)]
#[derive(Debug)]
pub struct dBodySimpleIDContainer {
pub _id: dBodyID,
}
#[test]
fn bindgen_test_layout_dBodySimpleIDContainer() {
const UNINIT: ::std::mem::MaybeUninit<dBodySimpleIDContainer> =
::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<dBodySimpleIDContainer>(),
8usize,
concat!("Size of: ", stringify!(dBodySimpleIDContainer))
);
assert_eq!(
::std::mem::align_of::<dBodySimpleIDContainer>(),
8usize,
concat!("Alignment of ", stringify!(dBodySimpleIDContainer))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr)._id) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(dBodySimpleIDContainer),
"::",
stringify!(_id)
)
);
}
#[repr(C)]
pub struct dBodyDynamicIDContainer__bindgen_vtable(::std::os::raw::c_void);
#[repr(C)]
#[derive(Debug)]
pub struct dBodyDynamicIDContainer {
pub vtable_: *const dBodyDynamicIDContainer__bindgen_vtable,
pub _base: dBodySimpleIDContainer,
}
#[test]
fn bindgen_test_layout_dBodyDynamicIDContainer() {
assert_eq!(
::std::mem::size_of::<dBodyDynamicIDContainer>(),
16usize,
concat!("Size of: ", stringify!(dBodyDynamicIDContainer))
);
assert_eq!(
::std::mem::align_of::<dBodyDynamicIDContainer>(),
8usize,
concat!("Alignment of ", stringify!(dBodyDynamicIDContainer))
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct dBodyTemplate<dBodyTemplateBase> {
pub _base: dBodyTemplateBase,
pub _phantom_0: ::std::marker::PhantomData<::std::cell::UnsafeCell<dBodyTemplateBase>>,
}
#[repr(C)]
#[derive(Debug)]
pub struct dJointGroupSimpleIDContainer {
pub _id: dJointGroupID,
}
#[test]
fn bindgen_test_layout_dJointGroupSimpleIDContainer() {
const UNINIT: ::std::mem::MaybeUninit<dJointGroupSimpleIDContainer> =
::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<dJointGroupSimpleIDContainer>(),
8usize,
concat!("Size of: ", stringify!(dJointGroupSimpleIDContainer))
);
assert_eq!(
::std::mem::align_of::<dJointGroupSimpleIDContainer>(),
8usize,
concat!("Alignment of ", stringify!(dJointGroupSimpleIDContainer))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr)._id) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(dJointGroupSimpleIDContainer),
"::",
stringify!(_id)
)
);
}
#[repr(C)]
pub struct dJointGroupDynamicIDContainer__bindgen_vtable(::std::os::raw::c_void);
#[repr(C)]
#[derive(Debug)]
pub struct dJointGroupDynamicIDContainer {
pub vtable_: *const dJointGroupDynamicIDContainer__bindgen_vtable,
pub _base: dJointGroupSimpleIDContainer,
}
#[test]
fn bindgen_test_layout_dJointGroupDynamicIDContainer() {
assert_eq!(
::std::mem::size_of::<dJointGroupDynamicIDContainer>(),
16usize,
concat!("Size of: ", stringify!(dJointGroupDynamicIDContainer))
);
assert_eq!(
::std::mem::align_of::<dJointGroupDynamicIDContainer>(),
8usize,
concat!("Alignment of ", stringify!(dJointGroupDynamicIDContainer))
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct dJointGroupTemplate<dJointGroupTemplateBase> {
pub _base: dJointGroupTemplateBase,
pub _phantom_0: ::std::marker::PhantomData<::std::cell::UnsafeCell<dJointGroupTemplateBase>>,
}
#[repr(C)]
#[derive(Debug)]
pub struct dJointSimpleIDContainer {
pub _id: dJointID,
}
#[test]
fn bindgen_test_layout_dJointSimpleIDContainer() {
const UNINIT: ::std::mem::MaybeUninit<dJointSimpleIDContainer> =
::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<dJointSimpleIDContainer>(),
8usize,
concat!("Size of: ", stringify!(dJointSimpleIDContainer))
);
assert_eq!(
::std::mem::align_of::<dJointSimpleIDContainer>(),
8usize,
concat!("Alignment of ", stringify!(dJointSimpleIDContainer))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr)._id) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(dJointSimpleIDContainer),
"::",
stringify!(_id)
)
);
}
#[repr(C)]
pub struct dJointDynamicIDContainer__bindgen_vtable(::std::os::raw::c_void);
#[repr(C)]
#[derive(Debug)]
pub struct dJointDynamicIDContainer {
pub vtable_: *const dJointDynamicIDContainer__bindgen_vtable,
pub _base: dJointSimpleIDContainer,
}
#[test]
fn bindgen_test_layout_dJointDynamicIDContainer() {
assert_eq!(
::std::mem::size_of::<dJointDynamicIDContainer>(),
16usize,
concat!("Size of: ", stringify!(dJointDynamicIDContainer))
);
assert_eq!(
::std::mem::align_of::<dJointDynamicIDContainer>(),
8usize,
concat!("Alignment of ", stringify!(dJointDynamicIDContainer))
);
}
#[repr(C)]
pub struct dJointTemplate__bindgen_vtable(::std::os::raw::c_void);
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct dJointTemplate<dJointTemplateBase> {
pub vtable_: *const dJointTemplate__bindgen_vtable,
pub _base: dJointTemplateBase,
pub _phantom_0: ::std::marker::PhantomData<::std::cell::UnsafeCell<dJointTemplateBase>>,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct dBallJointTemplate<dJointTemplateBase> {
pub _base: dJointTemplate<dJointTemplateBase>,
pub _phantom_0: ::std::marker::PhantomData<::std::cell::UnsafeCell<dJointTemplateBase>>,
}
pub type dBallJointTemplate_dBaseTemplate<dJointTemplateBase> = dJointTemplate<dJointTemplateBase>;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct dHingeJointTemplate<dJointTemplateBase> {
pub _base: dJointTemplate<dJointTemplateBase>,
pub _phantom_0: ::std::marker::PhantomData<::std::cell::UnsafeCell<dJointTemplateBase>>,
}
pub type dHingeJointTemplate_dBaseTemplate<dJointTemplateBase> = dJointTemplate<dJointTemplateBase>;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct dSliderJointTemplate<dJointTemplateBase> {
pub _base: dJointTemplate<dJointTemplateBase>,
pub _phantom_0: ::std::marker::PhantomData<::std::cell::UnsafeCell<dJointTemplateBase>>,
}
pub type dSliderJointTemplate_dBaseTemplate<dJointTemplateBase> =
dJointTemplate<dJointTemplateBase>;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct dUniversalJointTemplate<dJointTemplateBase> {
pub _base: dJointTemplate<dJointTemplateBase>,
pub _phantom_0: ::std::marker::PhantomData<::std::cell::UnsafeCell<dJointTemplateBase>>,
}
pub type dUniversalJointTemplate_dBaseTemplate<dJointTemplateBase> =
dJointTemplate<dJointTemplateBase>;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct dHinge2JointTemplate<dJointTemplateBase> {
pub _base: dJointTemplate<dJointTemplateBase>,
pub _phantom_0: ::std::marker::PhantomData<::std::cell::UnsafeCell<dJointTemplateBase>>,
}
pub type dHinge2JointTemplate_dBaseTemplate<dJointTemplateBase> =
dJointTemplate<dJointTemplateBase>;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct dPRJointTemplate<dJointTemplateBase> {
pub _base: dJointTemplate<dJointTemplateBase>,
pub _phantom_0: ::std::marker::PhantomData<::std::cell::UnsafeCell<dJointTemplateBase>>,
}
pub type dPRJointTemplate_dBaseTemplate<dJointTemplateBase> = dJointTemplate<dJointTemplateBase>;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct dPUJointTemplate<dJointTemplateBase> {
pub _base: dJointTemplate<dJointTemplateBase>,
pub _phantom_0: ::std::marker::PhantomData<::std::cell::UnsafeCell<dJointTemplateBase>>,
}
pub type dPUJointTemplate_dBaseTemplate<dJointTemplateBase> = dJointTemplate<dJointTemplateBase>;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct dPistonJointTemplate<dJointTemplateBase> {
pub _base: dJointTemplate<dJointTemplateBase>,
pub _phantom_0: ::std::marker::PhantomData<::std::cell::UnsafeCell<dJointTemplateBase>>,
}
pub type dPistonJointTemplate_dBaseTemplate<dJointTemplateBase> =
dJointTemplate<dJointTemplateBase>;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct dFixedJointTemplate<dJointTemplateBase> {
pub _base: dJointTemplate<dJointTemplateBase>,
pub _phantom_0: ::std::marker::PhantomData<::std::cell::UnsafeCell<dJointTemplateBase>>,
}
pub type dFixedJointTemplate_dBaseTemplate<dJointTemplateBase> = dJointTemplate<dJointTemplateBase>;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct dContactJointTemplate<dJointTemplateBase> {
pub _base: dJointTemplate<dJointTemplateBase>,
pub _phantom_0: ::std::marker::PhantomData<::std::cell::UnsafeCell<dJointTemplateBase>>,
}
pub type dContactJointTemplate_dBaseTemplate<dJointTemplateBase> =
dJointTemplate<dJointTemplateBase>;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct dNullJointTemplate<dJointTemplateBase> {
pub _base: dJointTemplate<dJointTemplateBase>,
pub _phantom_0: ::std::marker::PhantomData<::std::cell::UnsafeCell<dJointTemplateBase>>,
}
pub type dNullJointTemplate_dBaseTemplate<dJointTemplateBase> = dJointTemplate<dJointTemplateBase>;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct dAMotorJointTemplate<dJointTemplateBase> {
pub _base: dJointTemplate<dJointTemplateBase>,
pub _phantom_0: ::std::marker::PhantomData<::std::cell::UnsafeCell<dJointTemplateBase>>,
}
pub type dAMotorJointTemplate_dBaseTemplate<dJointTemplateBase> =
dJointTemplate<dJointTemplateBase>;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct dLMotorJointTemplate<dJointTemplateBase> {
pub _base: dJointTemplate<dJointTemplateBase>,
pub _phantom_0: ::std::marker::PhantomData<::std::cell::UnsafeCell<dJointTemplateBase>>,
}
pub type dLMotorJointTemplate_dBaseTemplate<dJointTemplateBase> =
dJointTemplate<dJointTemplateBase>;
pub type dWorld = dWorldTemplate<dWorldDynamicIDContainer>;
pub type dBody = dBodyTemplate<dBodyDynamicIDContainer>;
pub type dJointGroup = dJointGroupTemplate<dJointGroupDynamicIDContainer>;
pub type dJoint = dJointTemplate<dJointDynamicIDContainer>;
pub type dBallJoint = dBallJointTemplate<dJointDynamicIDContainer>;
pub type dHingeJoint = dHingeJointTemplate<dJointDynamicIDContainer>;
pub type dSliderJoint = dSliderJointTemplate<dJointDynamicIDContainer>;
pub type dUniversalJoint = dUniversalJointTemplate<dJointDynamicIDContainer>;
pub type dHinge2Joint = dHinge2JointTemplate<dJointDynamicIDContainer>;
pub type dPRJoint = dPRJointTemplate<dJointDynamicIDContainer>;
pub type dPUJoint = dPUJointTemplate<dJointDynamicIDContainer>;
pub type dPistonJoint = dPistonJointTemplate<dJointDynamicIDContainer>;
pub type dFixedJoint = dFixedJointTemplate<dJointDynamicIDContainer>;
pub type dContactJoint = dContactJointTemplate<dJointDynamicIDContainer>;
pub type dNullJoint = dNullJointTemplate<dJointDynamicIDContainer>;
pub type dAMotorJoint = dAMotorJointTemplate<dJointDynamicIDContainer>;
pub type dLMotorJoint = dLMotorJointTemplate<dJointDynamicIDContainer>;
#[repr(C)]
#[derive(Debug)]
pub struct dGeom {
pub _id: dGeomID,
}
#[test]
fn bindgen_test_layout_dGeom() {
const UNINIT: ::std::mem::MaybeUninit<dGeom> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<dGeom>(),
8usize,
concat!("Size of: ", stringify!(dGeom))
);
assert_eq!(
::std::mem::align_of::<dGeom>(),
8usize,
concat!("Alignment of ", stringify!(dGeom))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr)._id) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(dGeom),
"::",
stringify!(_id)
)
);
}
#[repr(C)]
#[derive(Debug)]
pub struct dSpace {
pub _base: dGeom,
}
#[test]
fn bindgen_test_layout_dSpace() {
assert_eq!(
::std::mem::size_of::<dSpace>(),
8usize,
concat!("Size of: ", stringify!(dSpace))
);
assert_eq!(
::std::mem::align_of::<dSpace>(),
8usize,
concat!("Alignment of ", stringify!(dSpace))
);
}
#[repr(C)]
#[derive(Debug)]
pub struct dSimpleSpace {
pub _base: dSpace,
}
#[test]
fn bindgen_test_layout_dSimpleSpace() {
assert_eq!(
::std::mem::size_of::<dSimpleSpace>(),
8usize,
concat!("Size of: ", stringify!(dSimpleSpace))
);
assert_eq!(
::std::mem::align_of::<dSimpleSpace>(),
8usize,
concat!("Alignment of ", stringify!(dSimpleSpace))
);
}
#[repr(C)]
#[derive(Debug)]
pub struct dHashSpace {
pub _base: dSpace,
}
#[test]
fn bindgen_test_layout_dHashSpace() {
assert_eq!(
::std::mem::size_of::<dHashSpace>(),
8usize,
concat!("Size of: ", stringify!(dHashSpace))
);
assert_eq!(
::std::mem::align_of::<dHashSpace>(),
8usize,
concat!("Alignment of ", stringify!(dHashSpace))
);
}
#[repr(C)]
#[derive(Debug)]
pub struct dQuadTreeSpace {
pub _base: dSpace,
}
#[test]
fn bindgen_test_layout_dQuadTreeSpace() {
assert_eq!(
::std::mem::size_of::<dQuadTreeSpace>(),
8usize,
concat!("Size of: ", stringify!(dQuadTreeSpace))
);
assert_eq!(
::std::mem::align_of::<dQuadTreeSpace>(),
8usize,
concat!("Alignment of ", stringify!(dQuadTreeSpace))
);
}
#[repr(C)]
#[derive(Debug)]
pub struct dSphere {
pub _base: dGeom,
}
#[test]
fn bindgen_test_layout_dSphere() {
assert_eq!(
::std::mem::size_of::<dSphere>(),
8usize,
concat!("Size of: ", stringify!(dSphere))
);
assert_eq!(
::std::mem::align_of::<dSphere>(),
8usize,
concat!("Alignment of ", stringify!(dSphere))
);
}
#[repr(C)]
#[derive(Debug)]
pub struct dBox {
pub _base: dGeom,
}
#[test]
fn bindgen_test_layout_dBox() {
assert_eq!(
::std::mem::size_of::<dBox>(),
8usize,
concat!("Size of: ", stringify!(dBox))
);
assert_eq!(
::std::mem::align_of::<dBox>(),
8usize,
concat!("Alignment of ", stringify!(dBox))
);
}
#[repr(C)]
#[derive(Debug)]
pub struct dPlane {
pub _base: dGeom,
}
#[test]
fn bindgen_test_layout_dPlane() {
assert_eq!(
::std::mem::size_of::<dPlane>(),
8usize,
concat!("Size of: ", stringify!(dPlane))
);
assert_eq!(
::std::mem::align_of::<dPlane>(),
8usize,
concat!("Alignment of ", stringify!(dPlane))
);
}
#[repr(C)]
#[derive(Debug)]
pub struct dCapsule {
pub _base: dGeom,
}
#[test]
fn bindgen_test_layout_dCapsule() {
assert_eq!(
::std::mem::size_of::<dCapsule>(),
8usize,
concat!("Size of: ", stringify!(dCapsule))
);
assert_eq!(
::std::mem::align_of::<dCapsule>(),
8usize,
concat!("Alignment of ", stringify!(dCapsule))
);
}
#[repr(C)]
#[derive(Debug)]
pub struct dCylinder {
pub _base: dGeom,
}
#[test]
fn bindgen_test_layout_dCylinder() {
assert_eq!(
::std::mem::size_of::<dCylinder>(),
8usize,
concat!("Size of: ", stringify!(dCylinder))
);
assert_eq!(
::std::mem::align_of::<dCylinder>(),
8usize,
concat!("Alignment of ", stringify!(dCylinder))
);
}
#[repr(C)]
#[derive(Debug)]
pub struct dRay {
pub _base: dGeom,
}
#[test]
fn bindgen_test_layout_dRay() {
assert_eq!(
::std::mem::size_of::<dRay>(),
8usize,
concat!("Size of: ", stringify!(dRay))
);
assert_eq!(
::std::mem::align_of::<dRay>(),
8usize,
concat!("Alignment of ", stringify!(dRay))
);
}
#[repr(C)]
#[derive(Debug)]
pub struct dGeomTransform {
pub _base: dGeom,
}
#[test]
fn bindgen_test_layout_dGeomTransform() {
assert_eq!(
::std::mem::size_of::<dGeomTransform>(),
8usize,
concat!("Size of: ", stringify!(dGeomTransform))
);
assert_eq!(
::std::mem::align_of::<dGeomTransform>(),
8usize,
concat!("Alignment of ", stringify!(dGeomTransform))
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct __crt_locale_data {
pub _address: u8,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct __crt_multibyte_data {
pub _address: u8,
}