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 _STL_LANG: 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 = 0;
pub const WCHAR_MIN: u32 = 0;
pub const WCHAR_MAX: u32 = 65535;
pub const WINT_MIN: u32 = 0;
pub const WINT_MAX: u32 = 65535;
pub const GVOX_CHANNEL_ID_COLOR: u32 = 0;
pub const GVOX_CHANNEL_ID_NORMAL: u32 = 1;
pub const GVOX_CHANNEL_ID_MATERIAL_ID: u32 = 2;
pub const GVOX_CHANNEL_ID_ROUGHNESS: u32 = 3;
pub const GVOX_CHANNEL_ID_METALNESS: u32 = 4;
pub const GVOX_CHANNEL_ID_TRANSPARENCY: u32 = 5;
pub const GVOX_CHANNEL_ID_IOR: u32 = 6;
pub const GVOX_CHANNEL_ID_EMISSIVITY: u32 = 7;
pub const GVOX_CHANNEL_ID_HARDNESS: u32 = 8;
pub const GVOX_CHANNEL_ID_LAST_STANDARD: u32 = 23;
pub const GVOX_CHANNEL_ID_LAST: u32 = 31;
pub const GVOX_CHANNEL_BIT_COLOR: u32 = 1;
pub const GVOX_CHANNEL_BIT_NORMAL: u32 = 2;
pub const GVOX_CHANNEL_BIT_MATERIAL_ID: u32 = 4;
pub const GVOX_CHANNEL_BIT_ROUGHNESS: u32 = 8;
pub const GVOX_CHANNEL_BIT_METALNESS: u32 = 16;
pub const GVOX_CHANNEL_BIT_TRANSPARENCY: u32 = 32;
pub const GVOX_CHANNEL_BIT_IOR: u32 = 64;
pub const GVOX_CHANNEL_BIT_EMISSIVITY: u32 = 128;
pub const GVOX_CHANNEL_BIT_HARDNESS: u32 = 256;
pub const GVOX_CHANNEL_BIT_LAST_STANDARD: u32 = 8388608;
pub const GVOX_CHANNEL_BIT_LAST: u32 = 2147483648;
pub const GVOX_REGION_FLAG_UNIFORM: u32 = 1;
pub type wchar_t = ::std::os::raw::c_ushort;
pub type max_align_t = f64;
pub type va_list = *mut ::std::os::raw::c_char;
extern "C" {
pub fn __va_start(arg1: *mut *mut ::std::os::raw::c_char, ...);
}
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 int_least8_t = ::std::os::raw::c_schar;
pub type int_least16_t = ::std::os::raw::c_short;
pub type int_least32_t = ::std::os::raw::c_int;
pub type int_least64_t = ::std::os::raw::c_longlong;
pub type uint_least8_t = ::std::os::raw::c_uchar;
pub type uint_least16_t = ::std::os::raw::c_ushort;
pub type uint_least32_t = ::std::os::raw::c_uint;
pub type uint_least64_t = ::std::os::raw::c_ulonglong;
pub type int_fast8_t = ::std::os::raw::c_schar;
pub type int_fast16_t = ::std::os::raw::c_int;
pub type int_fast32_t = ::std::os::raw::c_int;
pub type int_fast64_t = ::std::os::raw::c_longlong;
pub type uint_fast8_t = ::std::os::raw::c_uchar;
pub type uint_fast16_t = ::std::os::raw::c_uint;
pub type uint_fast32_t = ::std::os::raw::c_uint;
pub type uint_fast64_t = ::std::os::raw::c_ulonglong;
pub type intmax_t = ::std::os::raw::c_longlong;
pub type uintmax_t = ::std::os::raw::c_ulonglong;
pub const GvoxResult_GVOX_RESULT_SUCCESS: GvoxResult = 0;
pub const GvoxResult_GVOX_RESULT_ERROR_UNKNOWN: GvoxResult = -1;
pub const GvoxResult_GVOX_RESULT_ERROR_INVALID_PARAMETER: GvoxResult = -2;
pub const GvoxResult_GVOX_RESULT_ERROR_INPUT_ADAPTER: GvoxResult = -3;
pub const GvoxResult_GVOX_RESULT_ERROR_OUTPUT_ADAPTER: GvoxResult = -4;
pub const GvoxResult_GVOX_RESULT_ERROR_PARSE_ADAPTER: GvoxResult = -5;
pub const GvoxResult_GVOX_RESULT_ERROR_SERIALIZE_ADAPTER: GvoxResult = -6;
pub const GvoxResult_GVOX_RESULT_ERROR_PARSE_ADAPTER_INVALID_INPUT: GvoxResult = -7;
pub const GvoxResult_GVOX_RESULT_ERROR_PARSE_ADAPTER_REQUESTED_CHANNEL_NOT_PRESENT: GvoxResult = -8;
pub const GvoxResult_GVOX_RESULT_ERROR_SERIALIZE_ADAPTER_UNREPRESENTABLE_DATA: GvoxResult = -9;
pub type GvoxResult = ::std::os::raw::c_int;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GvoxContext {
_unused: [u8; 0],
}
pub type GvoxContext = _GvoxContext;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GvoxAdapter {
_unused: [u8; 0],
}
pub type GvoxAdapter = _GvoxAdapter;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GvoxAdapterContext {
_unused: [u8; 0],
}
pub type GvoxAdapterContext = _GvoxAdapterContext;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct GvoxVersion {
pub major: u32,
pub minor: u32,
pub patch: u32,
}
#[test]
fn bindgen_test_layout_GvoxVersion() {
const UNINIT: ::std::mem::MaybeUninit<GvoxVersion> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<GvoxVersion>(),
12usize,
concat!("Size of: ", stringify!(GvoxVersion))
);
assert_eq!(
::std::mem::align_of::<GvoxVersion>(),
4usize,
concat!("Alignment of ", stringify!(GvoxVersion))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).major) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(GvoxVersion),
"::",
stringify!(major)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).minor) as usize - ptr as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(GvoxVersion),
"::",
stringify!(minor)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).patch) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(GvoxVersion),
"::",
stringify!(patch)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct GvoxOffset3D {
pub x: i32,
pub y: i32,
pub z: i32,
}
#[test]
fn bindgen_test_layout_GvoxOffset3D() {
const UNINIT: ::std::mem::MaybeUninit<GvoxOffset3D> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<GvoxOffset3D>(),
12usize,
concat!("Size of: ", stringify!(GvoxOffset3D))
);
assert_eq!(
::std::mem::align_of::<GvoxOffset3D>(),
4usize,
concat!("Alignment of ", stringify!(GvoxOffset3D))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).x) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(GvoxOffset3D),
"::",
stringify!(x)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).y) as usize - ptr as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(GvoxOffset3D),
"::",
stringify!(y)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).z) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(GvoxOffset3D),
"::",
stringify!(z)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct GvoxExtent3D {
pub x: u32,
pub y: u32,
pub z: u32,
}
#[test]
fn bindgen_test_layout_GvoxExtent3D() {
const UNINIT: ::std::mem::MaybeUninit<GvoxExtent3D> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<GvoxExtent3D>(),
12usize,
concat!("Size of: ", stringify!(GvoxExtent3D))
);
assert_eq!(
::std::mem::align_of::<GvoxExtent3D>(),
4usize,
concat!("Alignment of ", stringify!(GvoxExtent3D))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).x) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(GvoxExtent3D),
"::",
stringify!(x)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).y) as usize - ptr as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(GvoxExtent3D),
"::",
stringify!(y)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).z) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(GvoxExtent3D),
"::",
stringify!(z)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct GvoxRegionRange {
pub offset: GvoxOffset3D,
pub extent: GvoxExtent3D,
}
#[test]
fn bindgen_test_layout_GvoxRegionRange() {
const UNINIT: ::std::mem::MaybeUninit<GvoxRegionRange> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<GvoxRegionRange>(),
24usize,
concat!("Size of: ", stringify!(GvoxRegionRange))
);
assert_eq!(
::std::mem::align_of::<GvoxRegionRange>(),
4usize,
concat!("Alignment of ", stringify!(GvoxRegionRange))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).offset) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(GvoxRegionRange),
"::",
stringify!(offset)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).extent) as usize - ptr as usize },
12usize,
concat!(
"Offset of field: ",
stringify!(GvoxRegionRange),
"::",
stringify!(extent)
)
);
}
extern "C" {
pub fn gvox_get_version(version: *mut GvoxVersion);
}
extern "C" {
pub fn gvox_create_context() -> *mut GvoxContext;
}
extern "C" {
pub fn gvox_destroy_context(ctx: *mut GvoxContext);
}
extern "C" {
pub fn gvox_get_result(ctx: *mut GvoxContext) -> GvoxResult;
}
extern "C" {
pub fn gvox_get_result_message(
ctx: *mut GvoxContext,
str_buffer: *mut ::std::os::raw::c_char,
str_size: *mut usize,
);
}
extern "C" {
pub fn gvox_pop_result(ctx: *mut GvoxContext);
}
extern "C" {
pub fn gvox_get_input_adapter(
ctx: *mut GvoxContext,
adapter_name: *const ::std::os::raw::c_char,
) -> *mut GvoxAdapter;
}
extern "C" {
pub fn gvox_get_output_adapter(
ctx: *mut GvoxContext,
adapter_name: *const ::std::os::raw::c_char,
) -> *mut GvoxAdapter;
}
extern "C" {
pub fn gvox_get_parse_adapter(
ctx: *mut GvoxContext,
adapter_name: *const ::std::os::raw::c_char,
) -> *mut GvoxAdapter;
}
extern "C" {
pub fn gvox_get_serialize_adapter(
ctx: *mut GvoxContext,
adapter_name: *const ::std::os::raw::c_char,
) -> *mut GvoxAdapter;
}
extern "C" {
pub fn gvox_create_adapter_context(
gvox_ctx: *mut GvoxContext,
adapter: *mut GvoxAdapter,
config: *const ::std::os::raw::c_void,
) -> *mut GvoxAdapterContext;
}
extern "C" {
pub fn gvox_destroy_adapter_context(ctx: *mut GvoxAdapterContext);
}
extern "C" {
pub fn gvox_blit_region(
input_ctx: *mut GvoxAdapterContext,
output_ctx: *mut GvoxAdapterContext,
parse_ctx: *mut GvoxAdapterContext,
serialize_ctx: *mut GvoxAdapterContext,
requested_range: *const GvoxRegionRange,
channel_flags: u32,
);
}
extern "C" {
pub fn gvox_blit_region_parse_driven(
input_ctx: *mut GvoxAdapterContext,
output_ctx: *mut GvoxAdapterContext,
parse_ctx: *mut GvoxAdapterContext,
serialize_ctx: *mut GvoxAdapterContext,
requested_range: *const GvoxRegionRange,
channel_flags: u32,
);
}
extern "C" {
pub fn gvox_blit_region_serialize_driven(
input_ctx: *mut GvoxAdapterContext,
output_ctx: *mut GvoxAdapterContext,
parse_ctx: *mut GvoxAdapterContext,
serialize_ctx: *mut GvoxAdapterContext,
requested_range: *const GvoxRegionRange,
channel_flags: u32,
);
}
pub const GvoxBlitMode_GVOX_BLIT_MODE_DONT_CARE: GvoxBlitMode = 0;
pub const GvoxBlitMode_GVOX_BLIT_MODE_PARSE_DRIVEN: GvoxBlitMode = 1;
pub const GvoxBlitMode_GVOX_BLIT_MODE_SERIALIZE_DRIVEN: GvoxBlitMode = 2;
pub type GvoxBlitMode = ::std::os::raw::c_int;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GvoxBlitContext {
_unused: [u8; 0],
}
pub type GvoxBlitContext = _GvoxBlitContext;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct GvoxRegion {
pub range: GvoxRegionRange,
pub channels: u32,
pub flags: u32,
pub data: *const ::std::os::raw::c_void,
}
#[test]
fn bindgen_test_layout_GvoxRegion() {
const UNINIT: ::std::mem::MaybeUninit<GvoxRegion> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<GvoxRegion>(),
40usize,
concat!("Size of: ", stringify!(GvoxRegion))
);
assert_eq!(
::std::mem::align_of::<GvoxRegion>(),
8usize,
concat!("Alignment of ", stringify!(GvoxRegion))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).range) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(GvoxRegion),
"::",
stringify!(range)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).channels) as usize - ptr as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(GvoxRegion),
"::",
stringify!(channels)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).flags) as usize - ptr as usize },
28usize,
concat!(
"Offset of field: ",
stringify!(GvoxRegion),
"::",
stringify!(flags)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).data) as usize - ptr as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(GvoxRegion),
"::",
stringify!(data)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct GvoxSample {
pub data: u32,
pub is_present: u8,
}
#[test]
fn bindgen_test_layout_GvoxSample() {
const UNINIT: ::std::mem::MaybeUninit<GvoxSample> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<GvoxSample>(),
8usize,
concat!("Size of: ", stringify!(GvoxSample))
);
assert_eq!(
::std::mem::align_of::<GvoxSample>(),
4usize,
concat!("Alignment of ", stringify!(GvoxSample))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).data) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(GvoxSample),
"::",
stringify!(data)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).is_present) as usize - ptr as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(GvoxSample),
"::",
stringify!(is_present)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct GvoxParseAdapterDetails {
pub preferred_blit_mode: GvoxBlitMode,
}
#[test]
fn bindgen_test_layout_GvoxParseAdapterDetails() {
const UNINIT: ::std::mem::MaybeUninit<GvoxParseAdapterDetails> =
::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<GvoxParseAdapterDetails>(),
4usize,
concat!("Size of: ", stringify!(GvoxParseAdapterDetails))
);
assert_eq!(
::std::mem::align_of::<GvoxParseAdapterDetails>(),
4usize,
concat!("Alignment of ", stringify!(GvoxParseAdapterDetails))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).preferred_blit_mode) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(GvoxParseAdapterDetails),
"::",
stringify!(preferred_blit_mode)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct GvoxAdapterBaseInfo {
pub name_str: *const ::std::os::raw::c_char,
pub create: ::std::option::Option<
unsafe extern "C" fn(ctx: *mut GvoxAdapterContext, config: *const ::std::os::raw::c_void),
>,
pub destroy: ::std::option::Option<unsafe extern "C" fn(ctx: *mut GvoxAdapterContext)>,
pub blit_begin: ::std::option::Option<
unsafe extern "C" fn(
blit_ctx: *mut GvoxBlitContext,
ctx: *mut GvoxAdapterContext,
range: *const GvoxRegionRange,
channel_flags: u32,
),
>,
pub blit_end: ::std::option::Option<
unsafe extern "C" fn(blit_ctx: *mut GvoxBlitContext, ctx: *mut GvoxAdapterContext),
>,
}
#[test]
fn bindgen_test_layout_GvoxAdapterBaseInfo() {
const UNINIT: ::std::mem::MaybeUninit<GvoxAdapterBaseInfo> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<GvoxAdapterBaseInfo>(),
40usize,
concat!("Size of: ", stringify!(GvoxAdapterBaseInfo))
);
assert_eq!(
::std::mem::align_of::<GvoxAdapterBaseInfo>(),
8usize,
concat!("Alignment of ", stringify!(GvoxAdapterBaseInfo))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).name_str) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(GvoxAdapterBaseInfo),
"::",
stringify!(name_str)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).create) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(GvoxAdapterBaseInfo),
"::",
stringify!(create)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).destroy) as usize - ptr as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(GvoxAdapterBaseInfo),
"::",
stringify!(destroy)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).blit_begin) as usize - ptr as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(GvoxAdapterBaseInfo),
"::",
stringify!(blit_begin)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).blit_end) as usize - ptr as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(GvoxAdapterBaseInfo),
"::",
stringify!(blit_end)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct GvoxInputAdapterInfo {
pub base_info: GvoxAdapterBaseInfo,
pub read: ::std::option::Option<
unsafe extern "C" fn(
ctx: *mut GvoxAdapterContext,
position: usize,
size: usize,
data: *mut ::std::os::raw::c_void,
),
>,
}
#[test]
fn bindgen_test_layout_GvoxInputAdapterInfo() {
const UNINIT: ::std::mem::MaybeUninit<GvoxInputAdapterInfo> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<GvoxInputAdapterInfo>(),
48usize,
concat!("Size of: ", stringify!(GvoxInputAdapterInfo))
);
assert_eq!(
::std::mem::align_of::<GvoxInputAdapterInfo>(),
8usize,
concat!("Alignment of ", stringify!(GvoxInputAdapterInfo))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).base_info) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(GvoxInputAdapterInfo),
"::",
stringify!(base_info)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).read) as usize - ptr as usize },
40usize,
concat!(
"Offset of field: ",
stringify!(GvoxInputAdapterInfo),
"::",
stringify!(read)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct GvoxOutputAdapterInfo {
pub base_info: GvoxAdapterBaseInfo,
pub write: ::std::option::Option<
unsafe extern "C" fn(
ctx: *mut GvoxAdapterContext,
position: usize,
size: usize,
data: *const ::std::os::raw::c_void,
),
>,
pub reserve:
::std::option::Option<unsafe extern "C" fn(ctx: *mut GvoxAdapterContext, size: usize)>,
}
#[test]
fn bindgen_test_layout_GvoxOutputAdapterInfo() {
const UNINIT: ::std::mem::MaybeUninit<GvoxOutputAdapterInfo> =
::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<GvoxOutputAdapterInfo>(),
56usize,
concat!("Size of: ", stringify!(GvoxOutputAdapterInfo))
);
assert_eq!(
::std::mem::align_of::<GvoxOutputAdapterInfo>(),
8usize,
concat!("Alignment of ", stringify!(GvoxOutputAdapterInfo))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).base_info) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(GvoxOutputAdapterInfo),
"::",
stringify!(base_info)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).write) as usize - ptr as usize },
40usize,
concat!(
"Offset of field: ",
stringify!(GvoxOutputAdapterInfo),
"::",
stringify!(write)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).reserve) as usize - ptr as usize },
48usize,
concat!(
"Offset of field: ",
stringify!(GvoxOutputAdapterInfo),
"::",
stringify!(reserve)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct GvoxParseAdapterInfo {
pub base_info: GvoxAdapterBaseInfo,
pub query_details: ::std::option::Option<unsafe extern "C" fn() -> GvoxParseAdapterDetails>,
pub query_parsable_range: ::std::option::Option<
unsafe extern "C" fn(
blit_ctx: *mut GvoxBlitContext,
ctx: *mut GvoxAdapterContext,
) -> GvoxRegionRange,
>,
pub sample_region: ::std::option::Option<
unsafe extern "C" fn(
blit_ctx: *mut GvoxBlitContext,
ctx: *mut GvoxAdapterContext,
region: *const GvoxRegion,
offset: *const GvoxOffset3D,
channel_id: u32,
) -> GvoxSample,
>,
pub query_region_flags: ::std::option::Option<
unsafe extern "C" fn(
blit_ctx: *mut GvoxBlitContext,
ctx: *mut GvoxAdapterContext,
range: *const GvoxRegionRange,
channel_flags: u32,
) -> u32,
>,
pub load_region: ::std::option::Option<
unsafe extern "C" fn(
blit_ctx: *mut GvoxBlitContext,
ctx: *mut GvoxAdapterContext,
range: *const GvoxRegionRange,
channel_flags: u32,
) -> GvoxRegion,
>,
pub unload_region: ::std::option::Option<
unsafe extern "C" fn(
blit_ctx: *mut GvoxBlitContext,
ctx: *mut GvoxAdapterContext,
region: *mut GvoxRegion,
),
>,
pub parse_region: ::std::option::Option<
unsafe extern "C" fn(
blit_ctx: *mut GvoxBlitContext,
ctx: *mut GvoxAdapterContext,
range: *const GvoxRegionRange,
channel_flags: u32,
),
>,
}
#[test]
fn bindgen_test_layout_GvoxParseAdapterInfo() {
const UNINIT: ::std::mem::MaybeUninit<GvoxParseAdapterInfo> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<GvoxParseAdapterInfo>(),
96usize,
concat!("Size of: ", stringify!(GvoxParseAdapterInfo))
);
assert_eq!(
::std::mem::align_of::<GvoxParseAdapterInfo>(),
8usize,
concat!("Alignment of ", stringify!(GvoxParseAdapterInfo))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).base_info) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(GvoxParseAdapterInfo),
"::",
stringify!(base_info)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).query_details) as usize - ptr as usize },
40usize,
concat!(
"Offset of field: ",
stringify!(GvoxParseAdapterInfo),
"::",
stringify!(query_details)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).query_parsable_range) as usize - ptr as usize },
48usize,
concat!(
"Offset of field: ",
stringify!(GvoxParseAdapterInfo),
"::",
stringify!(query_parsable_range)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).sample_region) as usize - ptr as usize },
56usize,
concat!(
"Offset of field: ",
stringify!(GvoxParseAdapterInfo),
"::",
stringify!(sample_region)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).query_region_flags) as usize - ptr as usize },
64usize,
concat!(
"Offset of field: ",
stringify!(GvoxParseAdapterInfo),
"::",
stringify!(query_region_flags)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).load_region) as usize - ptr as usize },
72usize,
concat!(
"Offset of field: ",
stringify!(GvoxParseAdapterInfo),
"::",
stringify!(load_region)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).unload_region) as usize - ptr as usize },
80usize,
concat!(
"Offset of field: ",
stringify!(GvoxParseAdapterInfo),
"::",
stringify!(unload_region)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).parse_region) as usize - ptr as usize },
88usize,
concat!(
"Offset of field: ",
stringify!(GvoxParseAdapterInfo),
"::",
stringify!(parse_region)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct GvoxSerializeAdapterInfo {
pub base_info: GvoxAdapterBaseInfo,
pub serialize_region: ::std::option::Option<
unsafe extern "C" fn(
blit_ctx: *mut GvoxBlitContext,
ctx: *mut GvoxAdapterContext,
range: *const GvoxRegionRange,
channel_flags: u32,
),
>,
pub receive_region: ::std::option::Option<
unsafe extern "C" fn(
blit_ctx: *mut GvoxBlitContext,
ctx: *mut GvoxAdapterContext,
region: *const GvoxRegion,
),
>,
}
#[test]
fn bindgen_test_layout_GvoxSerializeAdapterInfo() {
const UNINIT: ::std::mem::MaybeUninit<GvoxSerializeAdapterInfo> =
::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<GvoxSerializeAdapterInfo>(),
56usize,
concat!("Size of: ", stringify!(GvoxSerializeAdapterInfo))
);
assert_eq!(
::std::mem::align_of::<GvoxSerializeAdapterInfo>(),
8usize,
concat!("Alignment of ", stringify!(GvoxSerializeAdapterInfo))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).base_info) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(GvoxSerializeAdapterInfo),
"::",
stringify!(base_info)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).serialize_region) as usize - ptr as usize },
40usize,
concat!(
"Offset of field: ",
stringify!(GvoxSerializeAdapterInfo),
"::",
stringify!(serialize_region)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).receive_region) as usize - ptr as usize },
48usize,
concat!(
"Offset of field: ",
stringify!(GvoxSerializeAdapterInfo),
"::",
stringify!(receive_region)
)
);
}
extern "C" {
pub fn gvox_register_input_adapter(
ctx: *mut GvoxContext,
adapter_info: *const GvoxInputAdapterInfo,
) -> *mut GvoxAdapter;
}
extern "C" {
pub fn gvox_register_output_adapter(
ctx: *mut GvoxContext,
adapter_info: *const GvoxOutputAdapterInfo,
) -> *mut GvoxAdapter;
}
extern "C" {
pub fn gvox_register_parse_adapter(
ctx: *mut GvoxContext,
adapter_info: *const GvoxParseAdapterInfo,
) -> *mut GvoxAdapter;
}
extern "C" {
pub fn gvox_register_serialize_adapter(
ctx: *mut GvoxContext,
adapter_info: *const GvoxSerializeAdapterInfo,
) -> *mut GvoxAdapter;
}
extern "C" {
pub fn gvox_query_region_flags(
blit_ctx: *mut GvoxBlitContext,
range: *const GvoxRegionRange,
channel_flags: u32,
) -> u32;
}
extern "C" {
pub fn gvox_load_region_range(
blit_ctx: *mut GvoxBlitContext,
range: *const GvoxRegionRange,
channel_flags: u32,
) -> GvoxRegion;
}
extern "C" {
pub fn gvox_unload_region_range(
blit_ctx: *mut GvoxBlitContext,
region: *mut GvoxRegion,
range: *const GvoxRegionRange,
);
}
extern "C" {
pub fn gvox_sample_region(
blit_ctx: *mut GvoxBlitContext,
region: *const GvoxRegion,
offset: *const GvoxOffset3D,
channel_id: u32,
) -> GvoxSample;
}
extern "C" {
pub fn gvox_adapter_push_error(
ctx: *mut GvoxAdapterContext,
result_code: GvoxResult,
message: *const ::std::os::raw::c_char,
);
}
extern "C" {
pub fn gvox_adapter_set_user_pointer(
ctx: *mut GvoxAdapterContext,
ptr: *mut ::std::os::raw::c_void,
);
}
extern "C" {
pub fn gvox_adapter_get_user_pointer(
ctx: *mut GvoxAdapterContext,
) -> *mut ::std::os::raw::c_void;
}
extern "C" {
pub fn gvox_input_read(
blit_ctx: *mut GvoxBlitContext,
position: usize,
size: usize,
data: *mut ::std::os::raw::c_void,
);
}
extern "C" {
pub fn gvox_output_write(
blit_ctx: *mut GvoxBlitContext,
position: usize,
size: usize,
data: *const ::std::os::raw::c_void,
);
}
extern "C" {
pub fn gvox_output_reserve(blit_ctx: *mut GvoxBlitContext, size: usize);
}
extern "C" {
pub fn gvox_emit_region(blit_ctx: *mut GvoxBlitContext, region: *const GvoxRegion);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct GvoxByteBufferInputAdapterConfig {
pub data: *const u8,
pub size: usize,
}
#[test]
fn bindgen_test_layout_GvoxByteBufferInputAdapterConfig() {
const UNINIT: ::std::mem::MaybeUninit<GvoxByteBufferInputAdapterConfig> =
::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<GvoxByteBufferInputAdapterConfig>(),
16usize,
concat!("Size of: ", stringify!(GvoxByteBufferInputAdapterConfig))
);
assert_eq!(
::std::mem::align_of::<GvoxByteBufferInputAdapterConfig>(),
8usize,
concat!(
"Alignment of ",
stringify!(GvoxByteBufferInputAdapterConfig)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).data) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(GvoxByteBufferInputAdapterConfig),
"::",
stringify!(data)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).size) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(GvoxByteBufferInputAdapterConfig),
"::",
stringify!(size)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct GvoxFileInputAdapterConfig {
pub filepath: *const ::std::os::raw::c_char,
pub byte_offset: usize,
}
#[test]
fn bindgen_test_layout_GvoxFileInputAdapterConfig() {
const UNINIT: ::std::mem::MaybeUninit<GvoxFileInputAdapterConfig> =
::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<GvoxFileInputAdapterConfig>(),
16usize,
concat!("Size of: ", stringify!(GvoxFileInputAdapterConfig))
);
assert_eq!(
::std::mem::align_of::<GvoxFileInputAdapterConfig>(),
8usize,
concat!("Alignment of ", stringify!(GvoxFileInputAdapterConfig))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).filepath) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(GvoxFileInputAdapterConfig),
"::",
stringify!(filepath)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).byte_offset) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(GvoxFileInputAdapterConfig),
"::",
stringify!(byte_offset)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct GvoxByteBufferOutputAdapterConfig {
pub out_size: *mut usize,
pub out_byte_buffer_ptr: *mut *mut u8,
pub allocate:
::std::option::Option<unsafe extern "C" fn(size: usize) -> *mut ::std::os::raw::c_void>,
}
#[test]
fn bindgen_test_layout_GvoxByteBufferOutputAdapterConfig() {
const UNINIT: ::std::mem::MaybeUninit<GvoxByteBufferOutputAdapterConfig> =
::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<GvoxByteBufferOutputAdapterConfig>(),
24usize,
concat!("Size of: ", stringify!(GvoxByteBufferOutputAdapterConfig))
);
assert_eq!(
::std::mem::align_of::<GvoxByteBufferOutputAdapterConfig>(),
8usize,
concat!(
"Alignment of ",
stringify!(GvoxByteBufferOutputAdapterConfig)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).out_size) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(GvoxByteBufferOutputAdapterConfig),
"::",
stringify!(out_size)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).out_byte_buffer_ptr) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(GvoxByteBufferOutputAdapterConfig),
"::",
stringify!(out_byte_buffer_ptr)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).allocate) as usize - ptr as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(GvoxByteBufferOutputAdapterConfig),
"::",
stringify!(allocate)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct GvoxFileOutputAdapterConfig {
pub filepath: *const ::std::os::raw::c_char,
}
#[test]
fn bindgen_test_layout_GvoxFileOutputAdapterConfig() {
const UNINIT: ::std::mem::MaybeUninit<GvoxFileOutputAdapterConfig> =
::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<GvoxFileOutputAdapterConfig>(),
8usize,
concat!("Size of: ", stringify!(GvoxFileOutputAdapterConfig))
);
assert_eq!(
::std::mem::align_of::<GvoxFileOutputAdapterConfig>(),
8usize,
concat!("Alignment of ", stringify!(GvoxFileOutputAdapterConfig))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).filepath) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(GvoxFileOutputAdapterConfig),
"::",
stringify!(filepath)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct GvoxVoxlapParseAdapterConfig {
pub size_x: u32,
pub size_y: u32,
pub size_z: u32,
pub make_solid: u8,
pub is_ace_of_spades: u8,
}
#[test]
fn bindgen_test_layout_GvoxVoxlapParseAdapterConfig() {
const UNINIT: ::std::mem::MaybeUninit<GvoxVoxlapParseAdapterConfig> =
::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<GvoxVoxlapParseAdapterConfig>(),
16usize,
concat!("Size of: ", stringify!(GvoxVoxlapParseAdapterConfig))
);
assert_eq!(
::std::mem::align_of::<GvoxVoxlapParseAdapterConfig>(),
4usize,
concat!("Alignment of ", stringify!(GvoxVoxlapParseAdapterConfig))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).size_x) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(GvoxVoxlapParseAdapterConfig),
"::",
stringify!(size_x)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).size_y) as usize - ptr as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(GvoxVoxlapParseAdapterConfig),
"::",
stringify!(size_y)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).size_z) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(GvoxVoxlapParseAdapterConfig),
"::",
stringify!(size_z)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).make_solid) as usize - ptr as usize },
12usize,
concat!(
"Offset of field: ",
stringify!(GvoxVoxlapParseAdapterConfig),
"::",
stringify!(make_solid)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).is_ace_of_spades) as usize - ptr as usize },
13usize,
concat!(
"Offset of field: ",
stringify!(GvoxVoxlapParseAdapterConfig),
"::",
stringify!(is_ace_of_spades)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct GvoxKvxParseAdapterConfig {
pub mipmaplevels: u8,
}
#[test]
fn bindgen_test_layout_GvoxKvxParseAdapterConfig() {
const UNINIT: ::std::mem::MaybeUninit<GvoxKvxParseAdapterConfig> =
::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<GvoxKvxParseAdapterConfig>(),
1usize,
concat!("Size of: ", stringify!(GvoxKvxParseAdapterConfig))
);
assert_eq!(
::std::mem::align_of::<GvoxKvxParseAdapterConfig>(),
1usize,
concat!("Alignment of ", stringify!(GvoxKvxParseAdapterConfig))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).mipmaplevels) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(GvoxKvxParseAdapterConfig),
"::",
stringify!(mipmaplevels)
)
);
}
pub const GvoxColoredTextSerializeAdapterDownscaleMode_GVOX_COLORED_TEXT_SERIALIZE_ADAPTER_DOWNSCALE_MODE_NEAREST : GvoxColoredTextSerializeAdapterDownscaleMode = 0 ;
pub const GvoxColoredTextSerializeAdapterDownscaleMode_GVOX_COLORED_TEXT_SERIALIZE_ADAPTER_DOWNSCALE_MODE_LINEAR : GvoxColoredTextSerializeAdapterDownscaleMode = 1 ;
pub type GvoxColoredTextSerializeAdapterDownscaleMode = ::std::os::raw::c_int;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct GvoxColoredTextSerializeAdapterConfig {
pub downscale_factor: u32,
pub downscale_mode: GvoxColoredTextSerializeAdapterDownscaleMode,
pub non_color_max_value: u32,
pub vertical: u8,
}
#[test]
fn bindgen_test_layout_GvoxColoredTextSerializeAdapterConfig() {
const UNINIT: ::std::mem::MaybeUninit<GvoxColoredTextSerializeAdapterConfig> =
::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<GvoxColoredTextSerializeAdapterConfig>(),
16usize,
concat!(
"Size of: ",
stringify!(GvoxColoredTextSerializeAdapterConfig)
)
);
assert_eq!(
::std::mem::align_of::<GvoxColoredTextSerializeAdapterConfig>(),
4usize,
concat!(
"Alignment of ",
stringify!(GvoxColoredTextSerializeAdapterConfig)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).downscale_factor) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(GvoxColoredTextSerializeAdapterConfig),
"::",
stringify!(downscale_factor)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).downscale_mode) as usize - ptr as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(GvoxColoredTextSerializeAdapterConfig),
"::",
stringify!(downscale_mode)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).non_color_max_value) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(GvoxColoredTextSerializeAdapterConfig),
"::",
stringify!(non_color_max_value)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).vertical) as usize - ptr as usize },
12usize,
concat!(
"Offset of field: ",
stringify!(GvoxColoredTextSerializeAdapterConfig),
"::",
stringify!(vertical)
)
);
}