1pub const _VCRT_COMPILER_PREPROCESSOR: u32 = 1;
4pub const _SAL_VERSION: u32 = 20;
5pub const __SAL_H_VERSION: u32 = 180000000;
6pub const _USE_DECLSPECS_FOR_SAL: u32 = 0;
7pub const _USE_ATTRIBUTES_FOR_SAL: u32 = 0;
8pub const _CRT_PACKING: u32 = 8;
9pub const _HAS_EXCEPTIONS: u32 = 1;
10pub const _STL_LANG: u32 = 0;
11pub const _HAS_CXX17: u32 = 0;
12pub const _HAS_CXX20: u32 = 0;
13pub const _HAS_CXX23: u32 = 0;
14pub const _HAS_NODISCARD: u32 = 0;
15pub const WCHAR_MIN: u32 = 0;
16pub const WCHAR_MAX: u32 = 65535;
17pub const WINT_MIN: u32 = 0;
18pub const WINT_MAX: u32 = 65535;
19pub const GVOX_CHANNEL_ID_COLOR: u32 = 0;
20pub const GVOX_CHANNEL_ID_NORMAL: u32 = 1;
21pub const GVOX_CHANNEL_ID_MATERIAL_ID: u32 = 2;
22pub const GVOX_CHANNEL_ID_ROUGHNESS: u32 = 3;
23pub const GVOX_CHANNEL_ID_METALNESS: u32 = 4;
24pub const GVOX_CHANNEL_ID_TRANSPARENCY: u32 = 5;
25pub const GVOX_CHANNEL_ID_IOR: u32 = 6;
26pub const GVOX_CHANNEL_ID_EMISSIVITY: u32 = 7;
27pub const GVOX_CHANNEL_ID_HARDNESS: u32 = 8;
28pub const GVOX_CHANNEL_ID_LAST_STANDARD: u32 = 23;
29pub const GVOX_CHANNEL_ID_LAST: u32 = 31;
30pub const GVOX_CHANNEL_BIT_COLOR: u32 = 1;
31pub const GVOX_CHANNEL_BIT_NORMAL: u32 = 2;
32pub const GVOX_CHANNEL_BIT_MATERIAL_ID: u32 = 4;
33pub const GVOX_CHANNEL_BIT_ROUGHNESS: u32 = 8;
34pub const GVOX_CHANNEL_BIT_METALNESS: u32 = 16;
35pub const GVOX_CHANNEL_BIT_TRANSPARENCY: u32 = 32;
36pub const GVOX_CHANNEL_BIT_IOR: u32 = 64;
37pub const GVOX_CHANNEL_BIT_EMISSIVITY: u32 = 128;
38pub const GVOX_CHANNEL_BIT_HARDNESS: u32 = 256;
39pub const GVOX_CHANNEL_BIT_LAST_STANDARD: u32 = 8388608;
40pub const GVOX_CHANNEL_BIT_LAST: u32 = 2147483648;
41pub const GVOX_REGION_FLAG_UNIFORM: u32 = 1;
42pub type wchar_t = ::std::os::raw::c_ushort;
43pub type max_align_t = f64;
44pub type va_list = *mut ::std::os::raw::c_char;
45extern "C" {
46 pub fn __va_start(arg1: *mut *mut ::std::os::raw::c_char, ...);
47}
48pub type __vcrt_bool = bool;
49extern "C" {
50 pub fn __security_init_cookie();
51}
52extern "C" {
53 pub fn __security_check_cookie(_StackCookie: usize);
54}
55extern "C" {
56 pub fn __report_gsfailure(_StackCookie: usize) -> !;
57}
58extern "C" {
59 pub static mut __security_cookie: usize;
60}
61pub type int_least8_t = ::std::os::raw::c_schar;
62pub type int_least16_t = ::std::os::raw::c_short;
63pub type int_least32_t = ::std::os::raw::c_int;
64pub type int_least64_t = ::std::os::raw::c_longlong;
65pub type uint_least8_t = ::std::os::raw::c_uchar;
66pub type uint_least16_t = ::std::os::raw::c_ushort;
67pub type uint_least32_t = ::std::os::raw::c_uint;
68pub type uint_least64_t = ::std::os::raw::c_ulonglong;
69pub type int_fast8_t = ::std::os::raw::c_schar;
70pub type int_fast16_t = ::std::os::raw::c_int;
71pub type int_fast32_t = ::std::os::raw::c_int;
72pub type int_fast64_t = ::std::os::raw::c_longlong;
73pub type uint_fast8_t = ::std::os::raw::c_uchar;
74pub type uint_fast16_t = ::std::os::raw::c_uint;
75pub type uint_fast32_t = ::std::os::raw::c_uint;
76pub type uint_fast64_t = ::std::os::raw::c_ulonglong;
77pub type intmax_t = ::std::os::raw::c_longlong;
78pub type uintmax_t = ::std::os::raw::c_ulonglong;
79pub const GvoxResult_GVOX_RESULT_SUCCESS: GvoxResult = 0;
80pub const GvoxResult_GVOX_RESULT_ERROR_UNKNOWN: GvoxResult = -1;
81pub const GvoxResult_GVOX_RESULT_ERROR_INVALID_PARAMETER: GvoxResult = -2;
82pub const GvoxResult_GVOX_RESULT_ERROR_INPUT_ADAPTER: GvoxResult = -3;
83pub const GvoxResult_GVOX_RESULT_ERROR_OUTPUT_ADAPTER: GvoxResult = -4;
84pub const GvoxResult_GVOX_RESULT_ERROR_PARSE_ADAPTER: GvoxResult = -5;
85pub const GvoxResult_GVOX_RESULT_ERROR_SERIALIZE_ADAPTER: GvoxResult = -6;
86pub const GvoxResult_GVOX_RESULT_ERROR_PARSE_ADAPTER_INVALID_INPUT: GvoxResult = -7;
87pub const GvoxResult_GVOX_RESULT_ERROR_PARSE_ADAPTER_REQUESTED_CHANNEL_NOT_PRESENT: GvoxResult = -8;
88pub const GvoxResult_GVOX_RESULT_ERROR_SERIALIZE_ADAPTER_UNREPRESENTABLE_DATA: GvoxResult = -9;
89pub type GvoxResult = ::std::os::raw::c_int;
90#[repr(C)]
91#[derive(Debug, Copy, Clone)]
92pub struct _GvoxContext {
93 _unused: [u8; 0],
94}
95pub type GvoxContext = _GvoxContext;
96#[repr(C)]
97#[derive(Debug, Copy, Clone)]
98pub struct _GvoxAdapter {
99 _unused: [u8; 0],
100}
101pub type GvoxAdapter = _GvoxAdapter;
102#[repr(C)]
103#[derive(Debug, Copy, Clone)]
104pub struct _GvoxAdapterContext {
105 _unused: [u8; 0],
106}
107pub type GvoxAdapterContext = _GvoxAdapterContext;
108#[repr(C)]
109#[derive(Debug, Copy, Clone)]
110pub struct GvoxVersion {
111 pub major: u32,
112 pub minor: u32,
113 pub patch: u32,
114}
115#[test]
116fn bindgen_test_layout_GvoxVersion() {
117 const UNINIT: ::std::mem::MaybeUninit<GvoxVersion> = ::std::mem::MaybeUninit::uninit();
118 let ptr = UNINIT.as_ptr();
119 assert_eq!(
120 ::std::mem::size_of::<GvoxVersion>(),
121 12usize,
122 concat!("Size of: ", stringify!(GvoxVersion))
123 );
124 assert_eq!(
125 ::std::mem::align_of::<GvoxVersion>(),
126 4usize,
127 concat!("Alignment of ", stringify!(GvoxVersion))
128 );
129 assert_eq!(
130 unsafe { ::std::ptr::addr_of!((*ptr).major) as usize - ptr as usize },
131 0usize,
132 concat!(
133 "Offset of field: ",
134 stringify!(GvoxVersion),
135 "::",
136 stringify!(major)
137 )
138 );
139 assert_eq!(
140 unsafe { ::std::ptr::addr_of!((*ptr).minor) as usize - ptr as usize },
141 4usize,
142 concat!(
143 "Offset of field: ",
144 stringify!(GvoxVersion),
145 "::",
146 stringify!(minor)
147 )
148 );
149 assert_eq!(
150 unsafe { ::std::ptr::addr_of!((*ptr).patch) as usize - ptr as usize },
151 8usize,
152 concat!(
153 "Offset of field: ",
154 stringify!(GvoxVersion),
155 "::",
156 stringify!(patch)
157 )
158 );
159}
160#[repr(C)]
161#[derive(Debug, Copy, Clone)]
162pub struct GvoxOffset3D {
163 pub x: i32,
164 pub y: i32,
165 pub z: i32,
166}
167#[test]
168fn bindgen_test_layout_GvoxOffset3D() {
169 const UNINIT: ::std::mem::MaybeUninit<GvoxOffset3D> = ::std::mem::MaybeUninit::uninit();
170 let ptr = UNINIT.as_ptr();
171 assert_eq!(
172 ::std::mem::size_of::<GvoxOffset3D>(),
173 12usize,
174 concat!("Size of: ", stringify!(GvoxOffset3D))
175 );
176 assert_eq!(
177 ::std::mem::align_of::<GvoxOffset3D>(),
178 4usize,
179 concat!("Alignment of ", stringify!(GvoxOffset3D))
180 );
181 assert_eq!(
182 unsafe { ::std::ptr::addr_of!((*ptr).x) as usize - ptr as usize },
183 0usize,
184 concat!(
185 "Offset of field: ",
186 stringify!(GvoxOffset3D),
187 "::",
188 stringify!(x)
189 )
190 );
191 assert_eq!(
192 unsafe { ::std::ptr::addr_of!((*ptr).y) as usize - ptr as usize },
193 4usize,
194 concat!(
195 "Offset of field: ",
196 stringify!(GvoxOffset3D),
197 "::",
198 stringify!(y)
199 )
200 );
201 assert_eq!(
202 unsafe { ::std::ptr::addr_of!((*ptr).z) as usize - ptr as usize },
203 8usize,
204 concat!(
205 "Offset of field: ",
206 stringify!(GvoxOffset3D),
207 "::",
208 stringify!(z)
209 )
210 );
211}
212#[repr(C)]
213#[derive(Debug, Copy, Clone)]
214pub struct GvoxExtent3D {
215 pub x: u32,
216 pub y: u32,
217 pub z: u32,
218}
219#[test]
220fn bindgen_test_layout_GvoxExtent3D() {
221 const UNINIT: ::std::mem::MaybeUninit<GvoxExtent3D> = ::std::mem::MaybeUninit::uninit();
222 let ptr = UNINIT.as_ptr();
223 assert_eq!(
224 ::std::mem::size_of::<GvoxExtent3D>(),
225 12usize,
226 concat!("Size of: ", stringify!(GvoxExtent3D))
227 );
228 assert_eq!(
229 ::std::mem::align_of::<GvoxExtent3D>(),
230 4usize,
231 concat!("Alignment of ", stringify!(GvoxExtent3D))
232 );
233 assert_eq!(
234 unsafe { ::std::ptr::addr_of!((*ptr).x) as usize - ptr as usize },
235 0usize,
236 concat!(
237 "Offset of field: ",
238 stringify!(GvoxExtent3D),
239 "::",
240 stringify!(x)
241 )
242 );
243 assert_eq!(
244 unsafe { ::std::ptr::addr_of!((*ptr).y) as usize - ptr as usize },
245 4usize,
246 concat!(
247 "Offset of field: ",
248 stringify!(GvoxExtent3D),
249 "::",
250 stringify!(y)
251 )
252 );
253 assert_eq!(
254 unsafe { ::std::ptr::addr_of!((*ptr).z) as usize - ptr as usize },
255 8usize,
256 concat!(
257 "Offset of field: ",
258 stringify!(GvoxExtent3D),
259 "::",
260 stringify!(z)
261 )
262 );
263}
264#[repr(C)]
265#[derive(Debug, Copy, Clone)]
266pub struct GvoxRegionRange {
267 pub offset: GvoxOffset3D,
268 pub extent: GvoxExtent3D,
269}
270#[test]
271fn bindgen_test_layout_GvoxRegionRange() {
272 const UNINIT: ::std::mem::MaybeUninit<GvoxRegionRange> = ::std::mem::MaybeUninit::uninit();
273 let ptr = UNINIT.as_ptr();
274 assert_eq!(
275 ::std::mem::size_of::<GvoxRegionRange>(),
276 24usize,
277 concat!("Size of: ", stringify!(GvoxRegionRange))
278 );
279 assert_eq!(
280 ::std::mem::align_of::<GvoxRegionRange>(),
281 4usize,
282 concat!("Alignment of ", stringify!(GvoxRegionRange))
283 );
284 assert_eq!(
285 unsafe { ::std::ptr::addr_of!((*ptr).offset) as usize - ptr as usize },
286 0usize,
287 concat!(
288 "Offset of field: ",
289 stringify!(GvoxRegionRange),
290 "::",
291 stringify!(offset)
292 )
293 );
294 assert_eq!(
295 unsafe { ::std::ptr::addr_of!((*ptr).extent) as usize - ptr as usize },
296 12usize,
297 concat!(
298 "Offset of field: ",
299 stringify!(GvoxRegionRange),
300 "::",
301 stringify!(extent)
302 )
303 );
304}
305extern "C" {
306 pub fn gvox_get_version(version: *mut GvoxVersion);
307}
308extern "C" {
309 pub fn gvox_create_context() -> *mut GvoxContext;
310}
311extern "C" {
312 pub fn gvox_destroy_context(ctx: *mut GvoxContext);
313}
314extern "C" {
315 pub fn gvox_get_result(ctx: *mut GvoxContext) -> GvoxResult;
316}
317extern "C" {
318 pub fn gvox_get_result_message(
319 ctx: *mut GvoxContext,
320 str_buffer: *mut ::std::os::raw::c_char,
321 str_size: *mut usize,
322 );
323}
324extern "C" {
325 pub fn gvox_pop_result(ctx: *mut GvoxContext);
326}
327extern "C" {
328 pub fn gvox_get_input_adapter(
329 ctx: *mut GvoxContext,
330 adapter_name: *const ::std::os::raw::c_char,
331 ) -> *mut GvoxAdapter;
332}
333extern "C" {
334 pub fn gvox_get_output_adapter(
335 ctx: *mut GvoxContext,
336 adapter_name: *const ::std::os::raw::c_char,
337 ) -> *mut GvoxAdapter;
338}
339extern "C" {
340 pub fn gvox_get_parse_adapter(
341 ctx: *mut GvoxContext,
342 adapter_name: *const ::std::os::raw::c_char,
343 ) -> *mut GvoxAdapter;
344}
345extern "C" {
346 pub fn gvox_get_serialize_adapter(
347 ctx: *mut GvoxContext,
348 adapter_name: *const ::std::os::raw::c_char,
349 ) -> *mut GvoxAdapter;
350}
351extern "C" {
352 pub fn gvox_create_adapter_context(
353 gvox_ctx: *mut GvoxContext,
354 adapter: *mut GvoxAdapter,
355 config: *const ::std::os::raw::c_void,
356 ) -> *mut GvoxAdapterContext;
357}
358extern "C" {
359 pub fn gvox_destroy_adapter_context(ctx: *mut GvoxAdapterContext);
360}
361extern "C" {
362 pub fn gvox_blit_region(
363 input_ctx: *mut GvoxAdapterContext,
364 output_ctx: *mut GvoxAdapterContext,
365 parse_ctx: *mut GvoxAdapterContext,
366 serialize_ctx: *mut GvoxAdapterContext,
367 requested_range: *const GvoxRegionRange,
368 channel_flags: u32,
369 );
370}
371extern "C" {
372 pub fn gvox_blit_region_parse_driven(
373 input_ctx: *mut GvoxAdapterContext,
374 output_ctx: *mut GvoxAdapterContext,
375 parse_ctx: *mut GvoxAdapterContext,
376 serialize_ctx: *mut GvoxAdapterContext,
377 requested_range: *const GvoxRegionRange,
378 channel_flags: u32,
379 );
380}
381extern "C" {
382 pub fn gvox_blit_region_serialize_driven(
383 input_ctx: *mut GvoxAdapterContext,
384 output_ctx: *mut GvoxAdapterContext,
385 parse_ctx: *mut GvoxAdapterContext,
386 serialize_ctx: *mut GvoxAdapterContext,
387 requested_range: *const GvoxRegionRange,
388 channel_flags: u32,
389 );
390}
391pub const GvoxBlitMode_GVOX_BLIT_MODE_DONT_CARE: GvoxBlitMode = 0;
392pub const GvoxBlitMode_GVOX_BLIT_MODE_PARSE_DRIVEN: GvoxBlitMode = 1;
393pub const GvoxBlitMode_GVOX_BLIT_MODE_SERIALIZE_DRIVEN: GvoxBlitMode = 2;
394pub type GvoxBlitMode = ::std::os::raw::c_int;
395#[repr(C)]
396#[derive(Debug, Copy, Clone)]
397pub struct _GvoxBlitContext {
398 _unused: [u8; 0],
399}
400pub type GvoxBlitContext = _GvoxBlitContext;
401#[repr(C)]
402#[derive(Debug, Copy, Clone)]
403pub struct GvoxRegion {
404 pub range: GvoxRegionRange,
405 pub channels: u32,
406 pub flags: u32,
407 pub data: *const ::std::os::raw::c_void,
408}
409#[test]
410fn bindgen_test_layout_GvoxRegion() {
411 const UNINIT: ::std::mem::MaybeUninit<GvoxRegion> = ::std::mem::MaybeUninit::uninit();
412 let ptr = UNINIT.as_ptr();
413 assert_eq!(
414 ::std::mem::size_of::<GvoxRegion>(),
415 40usize,
416 concat!("Size of: ", stringify!(GvoxRegion))
417 );
418 assert_eq!(
419 ::std::mem::align_of::<GvoxRegion>(),
420 8usize,
421 concat!("Alignment of ", stringify!(GvoxRegion))
422 );
423 assert_eq!(
424 unsafe { ::std::ptr::addr_of!((*ptr).range) as usize - ptr as usize },
425 0usize,
426 concat!(
427 "Offset of field: ",
428 stringify!(GvoxRegion),
429 "::",
430 stringify!(range)
431 )
432 );
433 assert_eq!(
434 unsafe { ::std::ptr::addr_of!((*ptr).channels) as usize - ptr as usize },
435 24usize,
436 concat!(
437 "Offset of field: ",
438 stringify!(GvoxRegion),
439 "::",
440 stringify!(channels)
441 )
442 );
443 assert_eq!(
444 unsafe { ::std::ptr::addr_of!((*ptr).flags) as usize - ptr as usize },
445 28usize,
446 concat!(
447 "Offset of field: ",
448 stringify!(GvoxRegion),
449 "::",
450 stringify!(flags)
451 )
452 );
453 assert_eq!(
454 unsafe { ::std::ptr::addr_of!((*ptr).data) as usize - ptr as usize },
455 32usize,
456 concat!(
457 "Offset of field: ",
458 stringify!(GvoxRegion),
459 "::",
460 stringify!(data)
461 )
462 );
463}
464#[repr(C)]
465#[derive(Debug, Copy, Clone)]
466pub struct GvoxSample {
467 pub data: u32,
468 pub is_present: u8,
469}
470#[test]
471fn bindgen_test_layout_GvoxSample() {
472 const UNINIT: ::std::mem::MaybeUninit<GvoxSample> = ::std::mem::MaybeUninit::uninit();
473 let ptr = UNINIT.as_ptr();
474 assert_eq!(
475 ::std::mem::size_of::<GvoxSample>(),
476 8usize,
477 concat!("Size of: ", stringify!(GvoxSample))
478 );
479 assert_eq!(
480 ::std::mem::align_of::<GvoxSample>(),
481 4usize,
482 concat!("Alignment of ", stringify!(GvoxSample))
483 );
484 assert_eq!(
485 unsafe { ::std::ptr::addr_of!((*ptr).data) as usize - ptr as usize },
486 0usize,
487 concat!(
488 "Offset of field: ",
489 stringify!(GvoxSample),
490 "::",
491 stringify!(data)
492 )
493 );
494 assert_eq!(
495 unsafe { ::std::ptr::addr_of!((*ptr).is_present) as usize - ptr as usize },
496 4usize,
497 concat!(
498 "Offset of field: ",
499 stringify!(GvoxSample),
500 "::",
501 stringify!(is_present)
502 )
503 );
504}
505#[repr(C)]
506#[derive(Debug, Copy, Clone)]
507pub struct GvoxParseAdapterDetails {
508 pub preferred_blit_mode: GvoxBlitMode,
509}
510#[test]
511fn bindgen_test_layout_GvoxParseAdapterDetails() {
512 const UNINIT: ::std::mem::MaybeUninit<GvoxParseAdapterDetails> =
513 ::std::mem::MaybeUninit::uninit();
514 let ptr = UNINIT.as_ptr();
515 assert_eq!(
516 ::std::mem::size_of::<GvoxParseAdapterDetails>(),
517 4usize,
518 concat!("Size of: ", stringify!(GvoxParseAdapterDetails))
519 );
520 assert_eq!(
521 ::std::mem::align_of::<GvoxParseAdapterDetails>(),
522 4usize,
523 concat!("Alignment of ", stringify!(GvoxParseAdapterDetails))
524 );
525 assert_eq!(
526 unsafe { ::std::ptr::addr_of!((*ptr).preferred_blit_mode) as usize - ptr as usize },
527 0usize,
528 concat!(
529 "Offset of field: ",
530 stringify!(GvoxParseAdapterDetails),
531 "::",
532 stringify!(preferred_blit_mode)
533 )
534 );
535}
536#[repr(C)]
537#[derive(Debug, Copy, Clone)]
538pub struct GvoxAdapterBaseInfo {
539 pub name_str: *const ::std::os::raw::c_char,
540 pub create: ::std::option::Option<
541 unsafe extern "C" fn(ctx: *mut GvoxAdapterContext, config: *const ::std::os::raw::c_void),
542 >,
543 pub destroy: ::std::option::Option<unsafe extern "C" fn(ctx: *mut GvoxAdapterContext)>,
544 pub blit_begin: ::std::option::Option<
545 unsafe extern "C" fn(
546 blit_ctx: *mut GvoxBlitContext,
547 ctx: *mut GvoxAdapterContext,
548 range: *const GvoxRegionRange,
549 channel_flags: u32,
550 ),
551 >,
552 pub blit_end: ::std::option::Option<
553 unsafe extern "C" fn(blit_ctx: *mut GvoxBlitContext, ctx: *mut GvoxAdapterContext),
554 >,
555}
556#[test]
557fn bindgen_test_layout_GvoxAdapterBaseInfo() {
558 const UNINIT: ::std::mem::MaybeUninit<GvoxAdapterBaseInfo> = ::std::mem::MaybeUninit::uninit();
559 let ptr = UNINIT.as_ptr();
560 assert_eq!(
561 ::std::mem::size_of::<GvoxAdapterBaseInfo>(),
562 40usize,
563 concat!("Size of: ", stringify!(GvoxAdapterBaseInfo))
564 );
565 assert_eq!(
566 ::std::mem::align_of::<GvoxAdapterBaseInfo>(),
567 8usize,
568 concat!("Alignment of ", stringify!(GvoxAdapterBaseInfo))
569 );
570 assert_eq!(
571 unsafe { ::std::ptr::addr_of!((*ptr).name_str) as usize - ptr as usize },
572 0usize,
573 concat!(
574 "Offset of field: ",
575 stringify!(GvoxAdapterBaseInfo),
576 "::",
577 stringify!(name_str)
578 )
579 );
580 assert_eq!(
581 unsafe { ::std::ptr::addr_of!((*ptr).create) as usize - ptr as usize },
582 8usize,
583 concat!(
584 "Offset of field: ",
585 stringify!(GvoxAdapterBaseInfo),
586 "::",
587 stringify!(create)
588 )
589 );
590 assert_eq!(
591 unsafe { ::std::ptr::addr_of!((*ptr).destroy) as usize - ptr as usize },
592 16usize,
593 concat!(
594 "Offset of field: ",
595 stringify!(GvoxAdapterBaseInfo),
596 "::",
597 stringify!(destroy)
598 )
599 );
600 assert_eq!(
601 unsafe { ::std::ptr::addr_of!((*ptr).blit_begin) as usize - ptr as usize },
602 24usize,
603 concat!(
604 "Offset of field: ",
605 stringify!(GvoxAdapterBaseInfo),
606 "::",
607 stringify!(blit_begin)
608 )
609 );
610 assert_eq!(
611 unsafe { ::std::ptr::addr_of!((*ptr).blit_end) as usize - ptr as usize },
612 32usize,
613 concat!(
614 "Offset of field: ",
615 stringify!(GvoxAdapterBaseInfo),
616 "::",
617 stringify!(blit_end)
618 )
619 );
620}
621#[repr(C)]
622#[derive(Debug, Copy, Clone)]
623pub struct GvoxInputAdapterInfo {
624 pub base_info: GvoxAdapterBaseInfo,
625 pub read: ::std::option::Option<
626 unsafe extern "C" fn(
627 ctx: *mut GvoxAdapterContext,
628 position: usize,
629 size: usize,
630 data: *mut ::std::os::raw::c_void,
631 ),
632 >,
633}
634#[test]
635fn bindgen_test_layout_GvoxInputAdapterInfo() {
636 const UNINIT: ::std::mem::MaybeUninit<GvoxInputAdapterInfo> = ::std::mem::MaybeUninit::uninit();
637 let ptr = UNINIT.as_ptr();
638 assert_eq!(
639 ::std::mem::size_of::<GvoxInputAdapterInfo>(),
640 48usize,
641 concat!("Size of: ", stringify!(GvoxInputAdapterInfo))
642 );
643 assert_eq!(
644 ::std::mem::align_of::<GvoxInputAdapterInfo>(),
645 8usize,
646 concat!("Alignment of ", stringify!(GvoxInputAdapterInfo))
647 );
648 assert_eq!(
649 unsafe { ::std::ptr::addr_of!((*ptr).base_info) as usize - ptr as usize },
650 0usize,
651 concat!(
652 "Offset of field: ",
653 stringify!(GvoxInputAdapterInfo),
654 "::",
655 stringify!(base_info)
656 )
657 );
658 assert_eq!(
659 unsafe { ::std::ptr::addr_of!((*ptr).read) as usize - ptr as usize },
660 40usize,
661 concat!(
662 "Offset of field: ",
663 stringify!(GvoxInputAdapterInfo),
664 "::",
665 stringify!(read)
666 )
667 );
668}
669#[repr(C)]
670#[derive(Debug, Copy, Clone)]
671pub struct GvoxOutputAdapterInfo {
672 pub base_info: GvoxAdapterBaseInfo,
673 pub write: ::std::option::Option<
674 unsafe extern "C" fn(
675 ctx: *mut GvoxAdapterContext,
676 position: usize,
677 size: usize,
678 data: *const ::std::os::raw::c_void,
679 ),
680 >,
681 pub reserve:
682 ::std::option::Option<unsafe extern "C" fn(ctx: *mut GvoxAdapterContext, size: usize)>,
683}
684#[test]
685fn bindgen_test_layout_GvoxOutputAdapterInfo() {
686 const UNINIT: ::std::mem::MaybeUninit<GvoxOutputAdapterInfo> =
687 ::std::mem::MaybeUninit::uninit();
688 let ptr = UNINIT.as_ptr();
689 assert_eq!(
690 ::std::mem::size_of::<GvoxOutputAdapterInfo>(),
691 56usize,
692 concat!("Size of: ", stringify!(GvoxOutputAdapterInfo))
693 );
694 assert_eq!(
695 ::std::mem::align_of::<GvoxOutputAdapterInfo>(),
696 8usize,
697 concat!("Alignment of ", stringify!(GvoxOutputAdapterInfo))
698 );
699 assert_eq!(
700 unsafe { ::std::ptr::addr_of!((*ptr).base_info) as usize - ptr as usize },
701 0usize,
702 concat!(
703 "Offset of field: ",
704 stringify!(GvoxOutputAdapterInfo),
705 "::",
706 stringify!(base_info)
707 )
708 );
709 assert_eq!(
710 unsafe { ::std::ptr::addr_of!((*ptr).write) as usize - ptr as usize },
711 40usize,
712 concat!(
713 "Offset of field: ",
714 stringify!(GvoxOutputAdapterInfo),
715 "::",
716 stringify!(write)
717 )
718 );
719 assert_eq!(
720 unsafe { ::std::ptr::addr_of!((*ptr).reserve) as usize - ptr as usize },
721 48usize,
722 concat!(
723 "Offset of field: ",
724 stringify!(GvoxOutputAdapterInfo),
725 "::",
726 stringify!(reserve)
727 )
728 );
729}
730#[repr(C)]
731#[derive(Debug, Copy, Clone)]
732pub struct GvoxParseAdapterInfo {
733 pub base_info: GvoxAdapterBaseInfo,
734 pub query_details: ::std::option::Option<unsafe extern "C" fn() -> GvoxParseAdapterDetails>,
735 pub query_parsable_range: ::std::option::Option<
736 unsafe extern "C" fn(
737 blit_ctx: *mut GvoxBlitContext,
738 ctx: *mut GvoxAdapterContext,
739 ) -> GvoxRegionRange,
740 >,
741 pub sample_region: ::std::option::Option<
742 unsafe extern "C" fn(
743 blit_ctx: *mut GvoxBlitContext,
744 ctx: *mut GvoxAdapterContext,
745 region: *const GvoxRegion,
746 offset: *const GvoxOffset3D,
747 channel_id: u32,
748 ) -> GvoxSample,
749 >,
750 pub query_region_flags: ::std::option::Option<
751 unsafe extern "C" fn(
752 blit_ctx: *mut GvoxBlitContext,
753 ctx: *mut GvoxAdapterContext,
754 range: *const GvoxRegionRange,
755 channel_flags: u32,
756 ) -> u32,
757 >,
758 pub load_region: ::std::option::Option<
759 unsafe extern "C" fn(
760 blit_ctx: *mut GvoxBlitContext,
761 ctx: *mut GvoxAdapterContext,
762 range: *const GvoxRegionRange,
763 channel_flags: u32,
764 ) -> GvoxRegion,
765 >,
766 pub unload_region: ::std::option::Option<
767 unsafe extern "C" fn(
768 blit_ctx: *mut GvoxBlitContext,
769 ctx: *mut GvoxAdapterContext,
770 region: *mut GvoxRegion,
771 ),
772 >,
773 pub parse_region: ::std::option::Option<
774 unsafe extern "C" fn(
775 blit_ctx: *mut GvoxBlitContext,
776 ctx: *mut GvoxAdapterContext,
777 range: *const GvoxRegionRange,
778 channel_flags: u32,
779 ),
780 >,
781}
782#[test]
783fn bindgen_test_layout_GvoxParseAdapterInfo() {
784 const UNINIT: ::std::mem::MaybeUninit<GvoxParseAdapterInfo> = ::std::mem::MaybeUninit::uninit();
785 let ptr = UNINIT.as_ptr();
786 assert_eq!(
787 ::std::mem::size_of::<GvoxParseAdapterInfo>(),
788 96usize,
789 concat!("Size of: ", stringify!(GvoxParseAdapterInfo))
790 );
791 assert_eq!(
792 ::std::mem::align_of::<GvoxParseAdapterInfo>(),
793 8usize,
794 concat!("Alignment of ", stringify!(GvoxParseAdapterInfo))
795 );
796 assert_eq!(
797 unsafe { ::std::ptr::addr_of!((*ptr).base_info) as usize - ptr as usize },
798 0usize,
799 concat!(
800 "Offset of field: ",
801 stringify!(GvoxParseAdapterInfo),
802 "::",
803 stringify!(base_info)
804 )
805 );
806 assert_eq!(
807 unsafe { ::std::ptr::addr_of!((*ptr).query_details) as usize - ptr as usize },
808 40usize,
809 concat!(
810 "Offset of field: ",
811 stringify!(GvoxParseAdapterInfo),
812 "::",
813 stringify!(query_details)
814 )
815 );
816 assert_eq!(
817 unsafe { ::std::ptr::addr_of!((*ptr).query_parsable_range) as usize - ptr as usize },
818 48usize,
819 concat!(
820 "Offset of field: ",
821 stringify!(GvoxParseAdapterInfo),
822 "::",
823 stringify!(query_parsable_range)
824 )
825 );
826 assert_eq!(
827 unsafe { ::std::ptr::addr_of!((*ptr).sample_region) as usize - ptr as usize },
828 56usize,
829 concat!(
830 "Offset of field: ",
831 stringify!(GvoxParseAdapterInfo),
832 "::",
833 stringify!(sample_region)
834 )
835 );
836 assert_eq!(
837 unsafe { ::std::ptr::addr_of!((*ptr).query_region_flags) as usize - ptr as usize },
838 64usize,
839 concat!(
840 "Offset of field: ",
841 stringify!(GvoxParseAdapterInfo),
842 "::",
843 stringify!(query_region_flags)
844 )
845 );
846 assert_eq!(
847 unsafe { ::std::ptr::addr_of!((*ptr).load_region) as usize - ptr as usize },
848 72usize,
849 concat!(
850 "Offset of field: ",
851 stringify!(GvoxParseAdapterInfo),
852 "::",
853 stringify!(load_region)
854 )
855 );
856 assert_eq!(
857 unsafe { ::std::ptr::addr_of!((*ptr).unload_region) as usize - ptr as usize },
858 80usize,
859 concat!(
860 "Offset of field: ",
861 stringify!(GvoxParseAdapterInfo),
862 "::",
863 stringify!(unload_region)
864 )
865 );
866 assert_eq!(
867 unsafe { ::std::ptr::addr_of!((*ptr).parse_region) as usize - ptr as usize },
868 88usize,
869 concat!(
870 "Offset of field: ",
871 stringify!(GvoxParseAdapterInfo),
872 "::",
873 stringify!(parse_region)
874 )
875 );
876}
877#[repr(C)]
878#[derive(Debug, Copy, Clone)]
879pub struct GvoxSerializeAdapterInfo {
880 pub base_info: GvoxAdapterBaseInfo,
881 pub serialize_region: ::std::option::Option<
882 unsafe extern "C" fn(
883 blit_ctx: *mut GvoxBlitContext,
884 ctx: *mut GvoxAdapterContext,
885 range: *const GvoxRegionRange,
886 channel_flags: u32,
887 ),
888 >,
889 pub receive_region: ::std::option::Option<
890 unsafe extern "C" fn(
891 blit_ctx: *mut GvoxBlitContext,
892 ctx: *mut GvoxAdapterContext,
893 region: *const GvoxRegion,
894 ),
895 >,
896}
897#[test]
898fn bindgen_test_layout_GvoxSerializeAdapterInfo() {
899 const UNINIT: ::std::mem::MaybeUninit<GvoxSerializeAdapterInfo> =
900 ::std::mem::MaybeUninit::uninit();
901 let ptr = UNINIT.as_ptr();
902 assert_eq!(
903 ::std::mem::size_of::<GvoxSerializeAdapterInfo>(),
904 56usize,
905 concat!("Size of: ", stringify!(GvoxSerializeAdapterInfo))
906 );
907 assert_eq!(
908 ::std::mem::align_of::<GvoxSerializeAdapterInfo>(),
909 8usize,
910 concat!("Alignment of ", stringify!(GvoxSerializeAdapterInfo))
911 );
912 assert_eq!(
913 unsafe { ::std::ptr::addr_of!((*ptr).base_info) as usize - ptr as usize },
914 0usize,
915 concat!(
916 "Offset of field: ",
917 stringify!(GvoxSerializeAdapterInfo),
918 "::",
919 stringify!(base_info)
920 )
921 );
922 assert_eq!(
923 unsafe { ::std::ptr::addr_of!((*ptr).serialize_region) as usize - ptr as usize },
924 40usize,
925 concat!(
926 "Offset of field: ",
927 stringify!(GvoxSerializeAdapterInfo),
928 "::",
929 stringify!(serialize_region)
930 )
931 );
932 assert_eq!(
933 unsafe { ::std::ptr::addr_of!((*ptr).receive_region) as usize - ptr as usize },
934 48usize,
935 concat!(
936 "Offset of field: ",
937 stringify!(GvoxSerializeAdapterInfo),
938 "::",
939 stringify!(receive_region)
940 )
941 );
942}
943extern "C" {
944 pub fn gvox_register_input_adapter(
945 ctx: *mut GvoxContext,
946 adapter_info: *const GvoxInputAdapterInfo,
947 ) -> *mut GvoxAdapter;
948}
949extern "C" {
950 pub fn gvox_register_output_adapter(
951 ctx: *mut GvoxContext,
952 adapter_info: *const GvoxOutputAdapterInfo,
953 ) -> *mut GvoxAdapter;
954}
955extern "C" {
956 pub fn gvox_register_parse_adapter(
957 ctx: *mut GvoxContext,
958 adapter_info: *const GvoxParseAdapterInfo,
959 ) -> *mut GvoxAdapter;
960}
961extern "C" {
962 pub fn gvox_register_serialize_adapter(
963 ctx: *mut GvoxContext,
964 adapter_info: *const GvoxSerializeAdapterInfo,
965 ) -> *mut GvoxAdapter;
966}
967extern "C" {
968 pub fn gvox_query_region_flags(
969 blit_ctx: *mut GvoxBlitContext,
970 range: *const GvoxRegionRange,
971 channel_flags: u32,
972 ) -> u32;
973}
974extern "C" {
975 pub fn gvox_load_region_range(
976 blit_ctx: *mut GvoxBlitContext,
977 range: *const GvoxRegionRange,
978 channel_flags: u32,
979 ) -> GvoxRegion;
980}
981extern "C" {
982 pub fn gvox_unload_region_range(
983 blit_ctx: *mut GvoxBlitContext,
984 region: *mut GvoxRegion,
985 range: *const GvoxRegionRange,
986 );
987}
988extern "C" {
989 pub fn gvox_sample_region(
990 blit_ctx: *mut GvoxBlitContext,
991 region: *const GvoxRegion,
992 offset: *const GvoxOffset3D,
993 channel_id: u32,
994 ) -> GvoxSample;
995}
996extern "C" {
997 pub fn gvox_adapter_push_error(
998 ctx: *mut GvoxAdapterContext,
999 result_code: GvoxResult,
1000 message: *const ::std::os::raw::c_char,
1001 );
1002}
1003extern "C" {
1004 pub fn gvox_adapter_set_user_pointer(
1005 ctx: *mut GvoxAdapterContext,
1006 ptr: *mut ::std::os::raw::c_void,
1007 );
1008}
1009extern "C" {
1010 pub fn gvox_adapter_get_user_pointer(
1011 ctx: *mut GvoxAdapterContext,
1012 ) -> *mut ::std::os::raw::c_void;
1013}
1014extern "C" {
1015 pub fn gvox_input_read(
1016 blit_ctx: *mut GvoxBlitContext,
1017 position: usize,
1018 size: usize,
1019 data: *mut ::std::os::raw::c_void,
1020 );
1021}
1022extern "C" {
1023 pub fn gvox_output_write(
1024 blit_ctx: *mut GvoxBlitContext,
1025 position: usize,
1026 size: usize,
1027 data: *const ::std::os::raw::c_void,
1028 );
1029}
1030extern "C" {
1031 pub fn gvox_output_reserve(blit_ctx: *mut GvoxBlitContext, size: usize);
1032}
1033extern "C" {
1034 pub fn gvox_emit_region(blit_ctx: *mut GvoxBlitContext, region: *const GvoxRegion);
1035}
1036#[repr(C)]
1037#[derive(Debug, Copy, Clone)]
1038pub struct GvoxByteBufferInputAdapterConfig {
1039 pub data: *const u8,
1040 pub size: usize,
1041}
1042#[test]
1043fn bindgen_test_layout_GvoxByteBufferInputAdapterConfig() {
1044 const UNINIT: ::std::mem::MaybeUninit<GvoxByteBufferInputAdapterConfig> =
1045 ::std::mem::MaybeUninit::uninit();
1046 let ptr = UNINIT.as_ptr();
1047 assert_eq!(
1048 ::std::mem::size_of::<GvoxByteBufferInputAdapterConfig>(),
1049 16usize,
1050 concat!("Size of: ", stringify!(GvoxByteBufferInputAdapterConfig))
1051 );
1052 assert_eq!(
1053 ::std::mem::align_of::<GvoxByteBufferInputAdapterConfig>(),
1054 8usize,
1055 concat!(
1056 "Alignment of ",
1057 stringify!(GvoxByteBufferInputAdapterConfig)
1058 )
1059 );
1060 assert_eq!(
1061 unsafe { ::std::ptr::addr_of!((*ptr).data) as usize - ptr as usize },
1062 0usize,
1063 concat!(
1064 "Offset of field: ",
1065 stringify!(GvoxByteBufferInputAdapterConfig),
1066 "::",
1067 stringify!(data)
1068 )
1069 );
1070 assert_eq!(
1071 unsafe { ::std::ptr::addr_of!((*ptr).size) as usize - ptr as usize },
1072 8usize,
1073 concat!(
1074 "Offset of field: ",
1075 stringify!(GvoxByteBufferInputAdapterConfig),
1076 "::",
1077 stringify!(size)
1078 )
1079 );
1080}
1081#[repr(C)]
1082#[derive(Debug, Copy, Clone)]
1083pub struct GvoxFileInputAdapterConfig {
1084 pub filepath: *const ::std::os::raw::c_char,
1085 pub byte_offset: usize,
1086}
1087#[test]
1088fn bindgen_test_layout_GvoxFileInputAdapterConfig() {
1089 const UNINIT: ::std::mem::MaybeUninit<GvoxFileInputAdapterConfig> =
1090 ::std::mem::MaybeUninit::uninit();
1091 let ptr = UNINIT.as_ptr();
1092 assert_eq!(
1093 ::std::mem::size_of::<GvoxFileInputAdapterConfig>(),
1094 16usize,
1095 concat!("Size of: ", stringify!(GvoxFileInputAdapterConfig))
1096 );
1097 assert_eq!(
1098 ::std::mem::align_of::<GvoxFileInputAdapterConfig>(),
1099 8usize,
1100 concat!("Alignment of ", stringify!(GvoxFileInputAdapterConfig))
1101 );
1102 assert_eq!(
1103 unsafe { ::std::ptr::addr_of!((*ptr).filepath) as usize - ptr as usize },
1104 0usize,
1105 concat!(
1106 "Offset of field: ",
1107 stringify!(GvoxFileInputAdapterConfig),
1108 "::",
1109 stringify!(filepath)
1110 )
1111 );
1112 assert_eq!(
1113 unsafe { ::std::ptr::addr_of!((*ptr).byte_offset) as usize - ptr as usize },
1114 8usize,
1115 concat!(
1116 "Offset of field: ",
1117 stringify!(GvoxFileInputAdapterConfig),
1118 "::",
1119 stringify!(byte_offset)
1120 )
1121 );
1122}
1123#[repr(C)]
1124#[derive(Debug, Copy, Clone)]
1125pub struct GvoxByteBufferOutputAdapterConfig {
1126 pub out_size: *mut usize,
1127 pub out_byte_buffer_ptr: *mut *mut u8,
1128 pub allocate:
1129 ::std::option::Option<unsafe extern "C" fn(size: usize) -> *mut ::std::os::raw::c_void>,
1130}
1131#[test]
1132fn bindgen_test_layout_GvoxByteBufferOutputAdapterConfig() {
1133 const UNINIT: ::std::mem::MaybeUninit<GvoxByteBufferOutputAdapterConfig> =
1134 ::std::mem::MaybeUninit::uninit();
1135 let ptr = UNINIT.as_ptr();
1136 assert_eq!(
1137 ::std::mem::size_of::<GvoxByteBufferOutputAdapterConfig>(),
1138 24usize,
1139 concat!("Size of: ", stringify!(GvoxByteBufferOutputAdapterConfig))
1140 );
1141 assert_eq!(
1142 ::std::mem::align_of::<GvoxByteBufferOutputAdapterConfig>(),
1143 8usize,
1144 concat!(
1145 "Alignment of ",
1146 stringify!(GvoxByteBufferOutputAdapterConfig)
1147 )
1148 );
1149 assert_eq!(
1150 unsafe { ::std::ptr::addr_of!((*ptr).out_size) as usize - ptr as usize },
1151 0usize,
1152 concat!(
1153 "Offset of field: ",
1154 stringify!(GvoxByteBufferOutputAdapterConfig),
1155 "::",
1156 stringify!(out_size)
1157 )
1158 );
1159 assert_eq!(
1160 unsafe { ::std::ptr::addr_of!((*ptr).out_byte_buffer_ptr) as usize - ptr as usize },
1161 8usize,
1162 concat!(
1163 "Offset of field: ",
1164 stringify!(GvoxByteBufferOutputAdapterConfig),
1165 "::",
1166 stringify!(out_byte_buffer_ptr)
1167 )
1168 );
1169 assert_eq!(
1170 unsafe { ::std::ptr::addr_of!((*ptr).allocate) as usize - ptr as usize },
1171 16usize,
1172 concat!(
1173 "Offset of field: ",
1174 stringify!(GvoxByteBufferOutputAdapterConfig),
1175 "::",
1176 stringify!(allocate)
1177 )
1178 );
1179}
1180#[repr(C)]
1181#[derive(Debug, Copy, Clone)]
1182pub struct GvoxFileOutputAdapterConfig {
1183 pub filepath: *const ::std::os::raw::c_char,
1184}
1185#[test]
1186fn bindgen_test_layout_GvoxFileOutputAdapterConfig() {
1187 const UNINIT: ::std::mem::MaybeUninit<GvoxFileOutputAdapterConfig> =
1188 ::std::mem::MaybeUninit::uninit();
1189 let ptr = UNINIT.as_ptr();
1190 assert_eq!(
1191 ::std::mem::size_of::<GvoxFileOutputAdapterConfig>(),
1192 8usize,
1193 concat!("Size of: ", stringify!(GvoxFileOutputAdapterConfig))
1194 );
1195 assert_eq!(
1196 ::std::mem::align_of::<GvoxFileOutputAdapterConfig>(),
1197 8usize,
1198 concat!("Alignment of ", stringify!(GvoxFileOutputAdapterConfig))
1199 );
1200 assert_eq!(
1201 unsafe { ::std::ptr::addr_of!((*ptr).filepath) as usize - ptr as usize },
1202 0usize,
1203 concat!(
1204 "Offset of field: ",
1205 stringify!(GvoxFileOutputAdapterConfig),
1206 "::",
1207 stringify!(filepath)
1208 )
1209 );
1210}
1211#[repr(C)]
1212#[derive(Debug, Copy, Clone)]
1213pub struct GvoxVoxlapParseAdapterConfig {
1214 pub size_x: u32,
1215 pub size_y: u32,
1216 pub size_z: u32,
1217 pub make_solid: u8,
1218 pub is_ace_of_spades: u8,
1219}
1220#[test]
1221fn bindgen_test_layout_GvoxVoxlapParseAdapterConfig() {
1222 const UNINIT: ::std::mem::MaybeUninit<GvoxVoxlapParseAdapterConfig> =
1223 ::std::mem::MaybeUninit::uninit();
1224 let ptr = UNINIT.as_ptr();
1225 assert_eq!(
1226 ::std::mem::size_of::<GvoxVoxlapParseAdapterConfig>(),
1227 16usize,
1228 concat!("Size of: ", stringify!(GvoxVoxlapParseAdapterConfig))
1229 );
1230 assert_eq!(
1231 ::std::mem::align_of::<GvoxVoxlapParseAdapterConfig>(),
1232 4usize,
1233 concat!("Alignment of ", stringify!(GvoxVoxlapParseAdapterConfig))
1234 );
1235 assert_eq!(
1236 unsafe { ::std::ptr::addr_of!((*ptr).size_x) as usize - ptr as usize },
1237 0usize,
1238 concat!(
1239 "Offset of field: ",
1240 stringify!(GvoxVoxlapParseAdapterConfig),
1241 "::",
1242 stringify!(size_x)
1243 )
1244 );
1245 assert_eq!(
1246 unsafe { ::std::ptr::addr_of!((*ptr).size_y) as usize - ptr as usize },
1247 4usize,
1248 concat!(
1249 "Offset of field: ",
1250 stringify!(GvoxVoxlapParseAdapterConfig),
1251 "::",
1252 stringify!(size_y)
1253 )
1254 );
1255 assert_eq!(
1256 unsafe { ::std::ptr::addr_of!((*ptr).size_z) as usize - ptr as usize },
1257 8usize,
1258 concat!(
1259 "Offset of field: ",
1260 stringify!(GvoxVoxlapParseAdapterConfig),
1261 "::",
1262 stringify!(size_z)
1263 )
1264 );
1265 assert_eq!(
1266 unsafe { ::std::ptr::addr_of!((*ptr).make_solid) as usize - ptr as usize },
1267 12usize,
1268 concat!(
1269 "Offset of field: ",
1270 stringify!(GvoxVoxlapParseAdapterConfig),
1271 "::",
1272 stringify!(make_solid)
1273 )
1274 );
1275 assert_eq!(
1276 unsafe { ::std::ptr::addr_of!((*ptr).is_ace_of_spades) as usize - ptr as usize },
1277 13usize,
1278 concat!(
1279 "Offset of field: ",
1280 stringify!(GvoxVoxlapParseAdapterConfig),
1281 "::",
1282 stringify!(is_ace_of_spades)
1283 )
1284 );
1285}
1286#[repr(C)]
1287#[derive(Debug, Copy, Clone)]
1288pub struct GvoxKvxParseAdapterConfig {
1289 pub mipmaplevels: u8,
1290}
1291#[test]
1292fn bindgen_test_layout_GvoxKvxParseAdapterConfig() {
1293 const UNINIT: ::std::mem::MaybeUninit<GvoxKvxParseAdapterConfig> =
1294 ::std::mem::MaybeUninit::uninit();
1295 let ptr = UNINIT.as_ptr();
1296 assert_eq!(
1297 ::std::mem::size_of::<GvoxKvxParseAdapterConfig>(),
1298 1usize,
1299 concat!("Size of: ", stringify!(GvoxKvxParseAdapterConfig))
1300 );
1301 assert_eq!(
1302 ::std::mem::align_of::<GvoxKvxParseAdapterConfig>(),
1303 1usize,
1304 concat!("Alignment of ", stringify!(GvoxKvxParseAdapterConfig))
1305 );
1306 assert_eq!(
1307 unsafe { ::std::ptr::addr_of!((*ptr).mipmaplevels) as usize - ptr as usize },
1308 0usize,
1309 concat!(
1310 "Offset of field: ",
1311 stringify!(GvoxKvxParseAdapterConfig),
1312 "::",
1313 stringify!(mipmaplevels)
1314 )
1315 );
1316}
1317pub const GvoxColoredTextSerializeAdapterDownscaleMode_GVOX_COLORED_TEXT_SERIALIZE_ADAPTER_DOWNSCALE_MODE_NEAREST : GvoxColoredTextSerializeAdapterDownscaleMode = 0 ;
1318pub const GvoxColoredTextSerializeAdapterDownscaleMode_GVOX_COLORED_TEXT_SERIALIZE_ADAPTER_DOWNSCALE_MODE_LINEAR : GvoxColoredTextSerializeAdapterDownscaleMode = 1 ;
1319pub type GvoxColoredTextSerializeAdapterDownscaleMode = ::std::os::raw::c_int;
1320#[repr(C)]
1321#[derive(Debug, Copy, Clone)]
1322pub struct GvoxColoredTextSerializeAdapterConfig {
1323 pub downscale_factor: u32,
1324 pub downscale_mode: GvoxColoredTextSerializeAdapterDownscaleMode,
1325 pub non_color_max_value: u32,
1326 pub vertical: u8,
1327}
1328#[test]
1329fn bindgen_test_layout_GvoxColoredTextSerializeAdapterConfig() {
1330 const UNINIT: ::std::mem::MaybeUninit<GvoxColoredTextSerializeAdapterConfig> =
1331 ::std::mem::MaybeUninit::uninit();
1332 let ptr = UNINIT.as_ptr();
1333 assert_eq!(
1334 ::std::mem::size_of::<GvoxColoredTextSerializeAdapterConfig>(),
1335 16usize,
1336 concat!(
1337 "Size of: ",
1338 stringify!(GvoxColoredTextSerializeAdapterConfig)
1339 )
1340 );
1341 assert_eq!(
1342 ::std::mem::align_of::<GvoxColoredTextSerializeAdapterConfig>(),
1343 4usize,
1344 concat!(
1345 "Alignment of ",
1346 stringify!(GvoxColoredTextSerializeAdapterConfig)
1347 )
1348 );
1349 assert_eq!(
1350 unsafe { ::std::ptr::addr_of!((*ptr).downscale_factor) as usize - ptr as usize },
1351 0usize,
1352 concat!(
1353 "Offset of field: ",
1354 stringify!(GvoxColoredTextSerializeAdapterConfig),
1355 "::",
1356 stringify!(downscale_factor)
1357 )
1358 );
1359 assert_eq!(
1360 unsafe { ::std::ptr::addr_of!((*ptr).downscale_mode) as usize - ptr as usize },
1361 4usize,
1362 concat!(
1363 "Offset of field: ",
1364 stringify!(GvoxColoredTextSerializeAdapterConfig),
1365 "::",
1366 stringify!(downscale_mode)
1367 )
1368 );
1369 assert_eq!(
1370 unsafe { ::std::ptr::addr_of!((*ptr).non_color_max_value) as usize - ptr as usize },
1371 8usize,
1372 concat!(
1373 "Offset of field: ",
1374 stringify!(GvoxColoredTextSerializeAdapterConfig),
1375 "::",
1376 stringify!(non_color_max_value)
1377 )
1378 );
1379 assert_eq!(
1380 unsafe { ::std::ptr::addr_of!((*ptr).vertical) as usize - ptr as usize },
1381 12usize,
1382 concat!(
1383 "Offset of field: ",
1384 stringify!(GvoxColoredTextSerializeAdapterConfig),
1385 "::",
1386 stringify!(vertical)
1387 )
1388 );
1389}