1#[repr(C)]
2#[derive(Debug, Copy, Clone)]
3pub struct Vector2 {
4 pub x: f32,
5 pub y: f32,
6}
7#[test]
8fn bindgen_test_layout_Vector2() {
9 const UNINIT: ::std::mem::MaybeUninit<Vector2> = ::std::mem::MaybeUninit::uninit();
10 let ptr = UNINIT.as_ptr();
11 assert_eq!(
12 ::std::mem::size_of::<Vector2>(),
13 8usize,
14 concat!("Size of: ", stringify!(Vector2))
15 );
16 assert_eq!(
17 ::std::mem::align_of::<Vector2>(),
18 4usize,
19 concat!("Alignment of ", stringify!(Vector2))
20 );
21 assert_eq!(
22 unsafe { ::std::ptr::addr_of!((*ptr).x) as usize - ptr as usize },
23 0usize,
24 concat!(
25 "Offset of field: ",
26 stringify!(Vector2),
27 "::",
28 stringify!(x)
29 )
30 );
31 assert_eq!(
32 unsafe { ::std::ptr::addr_of!((*ptr).y) as usize - ptr as usize },
33 4usize,
34 concat!(
35 "Offset of field: ",
36 stringify!(Vector2),
37 "::",
38 stringify!(y)
39 )
40 );
41}
42#[repr(C)]
43#[derive(Debug, Copy, Clone)]
44pub struct Vector3 {
45 pub x: f32,
46 pub y: f32,
47 pub z: f32,
48}
49#[test]
50fn bindgen_test_layout_Vector3() {
51 const UNINIT: ::std::mem::MaybeUninit<Vector3> = ::std::mem::MaybeUninit::uninit();
52 let ptr = UNINIT.as_ptr();
53 assert_eq!(
54 ::std::mem::size_of::<Vector3>(),
55 12usize,
56 concat!("Size of: ", stringify!(Vector3))
57 );
58 assert_eq!(
59 ::std::mem::align_of::<Vector3>(),
60 4usize,
61 concat!("Alignment of ", stringify!(Vector3))
62 );
63 assert_eq!(
64 unsafe { ::std::ptr::addr_of!((*ptr).x) as usize - ptr as usize },
65 0usize,
66 concat!(
67 "Offset of field: ",
68 stringify!(Vector3),
69 "::",
70 stringify!(x)
71 )
72 );
73 assert_eq!(
74 unsafe { ::std::ptr::addr_of!((*ptr).y) as usize - ptr as usize },
75 4usize,
76 concat!(
77 "Offset of field: ",
78 stringify!(Vector3),
79 "::",
80 stringify!(y)
81 )
82 );
83 assert_eq!(
84 unsafe { ::std::ptr::addr_of!((*ptr).z) as usize - ptr as usize },
85 8usize,
86 concat!(
87 "Offset of field: ",
88 stringify!(Vector3),
89 "::",
90 stringify!(z)
91 )
92 );
93}
94#[repr(C)]
95#[derive(Debug, Copy, Clone)]
96pub struct Vector4 {
97 pub x: f32,
98 pub y: f32,
99 pub z: f32,
100 pub w: f32,
101}
102#[test]
103fn bindgen_test_layout_Vector4() {
104 const UNINIT: ::std::mem::MaybeUninit<Vector4> = ::std::mem::MaybeUninit::uninit();
105 let ptr = UNINIT.as_ptr();
106 assert_eq!(
107 ::std::mem::size_of::<Vector4>(),
108 16usize,
109 concat!("Size of: ", stringify!(Vector4))
110 );
111 assert_eq!(
112 ::std::mem::align_of::<Vector4>(),
113 4usize,
114 concat!("Alignment of ", stringify!(Vector4))
115 );
116 assert_eq!(
117 unsafe { ::std::ptr::addr_of!((*ptr).x) as usize - ptr as usize },
118 0usize,
119 concat!(
120 "Offset of field: ",
121 stringify!(Vector4),
122 "::",
123 stringify!(x)
124 )
125 );
126 assert_eq!(
127 unsafe { ::std::ptr::addr_of!((*ptr).y) as usize - ptr as usize },
128 4usize,
129 concat!(
130 "Offset of field: ",
131 stringify!(Vector4),
132 "::",
133 stringify!(y)
134 )
135 );
136 assert_eq!(
137 unsafe { ::std::ptr::addr_of!((*ptr).z) as usize - ptr as usize },
138 8usize,
139 concat!(
140 "Offset of field: ",
141 stringify!(Vector4),
142 "::",
143 stringify!(z)
144 )
145 );
146 assert_eq!(
147 unsafe { ::std::ptr::addr_of!((*ptr).w) as usize - ptr as usize },
148 12usize,
149 concat!(
150 "Offset of field: ",
151 stringify!(Vector4),
152 "::",
153 stringify!(w)
154 )
155 );
156}
157pub type Quaternion = Vector4;
158#[repr(C)]
159#[derive(Debug, Copy, Clone)]
160pub struct Matrix {
161 pub m0: f32,
162 pub m4: f32,
163 pub m8: f32,
164 pub m12: f32,
165 pub m1: f32,
166 pub m5: f32,
167 pub m9: f32,
168 pub m13: f32,
169 pub m2: f32,
170 pub m6: f32,
171 pub m10: f32,
172 pub m14: f32,
173 pub m3: f32,
174 pub m7: f32,
175 pub m11: f32,
176 pub m15: f32,
177}
178#[test]
179fn bindgen_test_layout_Matrix() {
180 const UNINIT: ::std::mem::MaybeUninit<Matrix> = ::std::mem::MaybeUninit::uninit();
181 let ptr = UNINIT.as_ptr();
182 assert_eq!(
183 ::std::mem::size_of::<Matrix>(),
184 64usize,
185 concat!("Size of: ", stringify!(Matrix))
186 );
187 assert_eq!(
188 ::std::mem::align_of::<Matrix>(),
189 4usize,
190 concat!("Alignment of ", stringify!(Matrix))
191 );
192 assert_eq!(
193 unsafe { ::std::ptr::addr_of!((*ptr).m0) as usize - ptr as usize },
194 0usize,
195 concat!(
196 "Offset of field: ",
197 stringify!(Matrix),
198 "::",
199 stringify!(m0)
200 )
201 );
202 assert_eq!(
203 unsafe { ::std::ptr::addr_of!((*ptr).m4) as usize - ptr as usize },
204 4usize,
205 concat!(
206 "Offset of field: ",
207 stringify!(Matrix),
208 "::",
209 stringify!(m4)
210 )
211 );
212 assert_eq!(
213 unsafe { ::std::ptr::addr_of!((*ptr).m8) as usize - ptr as usize },
214 8usize,
215 concat!(
216 "Offset of field: ",
217 stringify!(Matrix),
218 "::",
219 stringify!(m8)
220 )
221 );
222 assert_eq!(
223 unsafe { ::std::ptr::addr_of!((*ptr).m12) as usize - ptr as usize },
224 12usize,
225 concat!(
226 "Offset of field: ",
227 stringify!(Matrix),
228 "::",
229 stringify!(m12)
230 )
231 );
232 assert_eq!(
233 unsafe { ::std::ptr::addr_of!((*ptr).m1) as usize - ptr as usize },
234 16usize,
235 concat!(
236 "Offset of field: ",
237 stringify!(Matrix),
238 "::",
239 stringify!(m1)
240 )
241 );
242 assert_eq!(
243 unsafe { ::std::ptr::addr_of!((*ptr).m5) as usize - ptr as usize },
244 20usize,
245 concat!(
246 "Offset of field: ",
247 stringify!(Matrix),
248 "::",
249 stringify!(m5)
250 )
251 );
252 assert_eq!(
253 unsafe { ::std::ptr::addr_of!((*ptr).m9) as usize - ptr as usize },
254 24usize,
255 concat!(
256 "Offset of field: ",
257 stringify!(Matrix),
258 "::",
259 stringify!(m9)
260 )
261 );
262 assert_eq!(
263 unsafe { ::std::ptr::addr_of!((*ptr).m13) as usize - ptr as usize },
264 28usize,
265 concat!(
266 "Offset of field: ",
267 stringify!(Matrix),
268 "::",
269 stringify!(m13)
270 )
271 );
272 assert_eq!(
273 unsafe { ::std::ptr::addr_of!((*ptr).m2) as usize - ptr as usize },
274 32usize,
275 concat!(
276 "Offset of field: ",
277 stringify!(Matrix),
278 "::",
279 stringify!(m2)
280 )
281 );
282 assert_eq!(
283 unsafe { ::std::ptr::addr_of!((*ptr).m6) as usize - ptr as usize },
284 36usize,
285 concat!(
286 "Offset of field: ",
287 stringify!(Matrix),
288 "::",
289 stringify!(m6)
290 )
291 );
292 assert_eq!(
293 unsafe { ::std::ptr::addr_of!((*ptr).m10) as usize - ptr as usize },
294 40usize,
295 concat!(
296 "Offset of field: ",
297 stringify!(Matrix),
298 "::",
299 stringify!(m10)
300 )
301 );
302 assert_eq!(
303 unsafe { ::std::ptr::addr_of!((*ptr).m14) as usize - ptr as usize },
304 44usize,
305 concat!(
306 "Offset of field: ",
307 stringify!(Matrix),
308 "::",
309 stringify!(m14)
310 )
311 );
312 assert_eq!(
313 unsafe { ::std::ptr::addr_of!((*ptr).m3) as usize - ptr as usize },
314 48usize,
315 concat!(
316 "Offset of field: ",
317 stringify!(Matrix),
318 "::",
319 stringify!(m3)
320 )
321 );
322 assert_eq!(
323 unsafe { ::std::ptr::addr_of!((*ptr).m7) as usize - ptr as usize },
324 52usize,
325 concat!(
326 "Offset of field: ",
327 stringify!(Matrix),
328 "::",
329 stringify!(m7)
330 )
331 );
332 assert_eq!(
333 unsafe { ::std::ptr::addr_of!((*ptr).m11) as usize - ptr as usize },
334 56usize,
335 concat!(
336 "Offset of field: ",
337 stringify!(Matrix),
338 "::",
339 stringify!(m11)
340 )
341 );
342 assert_eq!(
343 unsafe { ::std::ptr::addr_of!((*ptr).m15) as usize - ptr as usize },
344 60usize,
345 concat!(
346 "Offset of field: ",
347 stringify!(Matrix),
348 "::",
349 stringify!(m15)
350 )
351 );
352}
353#[repr(C)]
354#[derive(Debug, Copy, Clone)]
355pub struct Color {
356 pub r: u8,
357 pub g: u8,
358 pub b: u8,
359 pub a: u8,
360}
361#[test]
362fn bindgen_test_layout_Color() {
363 const UNINIT: ::std::mem::MaybeUninit<Color> = ::std::mem::MaybeUninit::uninit();
364 let ptr = UNINIT.as_ptr();
365 assert_eq!(
366 ::std::mem::size_of::<Color>(),
367 4usize,
368 concat!("Size of: ", stringify!(Color))
369 );
370 assert_eq!(
371 ::std::mem::align_of::<Color>(),
372 1usize,
373 concat!("Alignment of ", stringify!(Color))
374 );
375 assert_eq!(
376 unsafe { ::std::ptr::addr_of!((*ptr).r) as usize - ptr as usize },
377 0usize,
378 concat!("Offset of field: ", stringify!(Color), "::", stringify!(r))
379 );
380 assert_eq!(
381 unsafe { ::std::ptr::addr_of!((*ptr).g) as usize - ptr as usize },
382 1usize,
383 concat!("Offset of field: ", stringify!(Color), "::", stringify!(g))
384 );
385 assert_eq!(
386 unsafe { ::std::ptr::addr_of!((*ptr).b) as usize - ptr as usize },
387 2usize,
388 concat!("Offset of field: ", stringify!(Color), "::", stringify!(b))
389 );
390 assert_eq!(
391 unsafe { ::std::ptr::addr_of!((*ptr).a) as usize - ptr as usize },
392 3usize,
393 concat!("Offset of field: ", stringify!(Color), "::", stringify!(a))
394 );
395}
396#[repr(C)]
397#[derive(Debug, Copy, Clone)]
398pub struct Rectangle {
399 pub x: f32,
400 pub y: f32,
401 pub width: f32,
402 pub height: f32,
403}
404#[test]
405fn bindgen_test_layout_Rectangle() {
406 const UNINIT: ::std::mem::MaybeUninit<Rectangle> = ::std::mem::MaybeUninit::uninit();
407 let ptr = UNINIT.as_ptr();
408 assert_eq!(
409 ::std::mem::size_of::<Rectangle>(),
410 16usize,
411 concat!("Size of: ", stringify!(Rectangle))
412 );
413 assert_eq!(
414 ::std::mem::align_of::<Rectangle>(),
415 4usize,
416 concat!("Alignment of ", stringify!(Rectangle))
417 );
418 assert_eq!(
419 unsafe { ::std::ptr::addr_of!((*ptr).x) as usize - ptr as usize },
420 0usize,
421 concat!(
422 "Offset of field: ",
423 stringify!(Rectangle),
424 "::",
425 stringify!(x)
426 )
427 );
428 assert_eq!(
429 unsafe { ::std::ptr::addr_of!((*ptr).y) as usize - ptr as usize },
430 4usize,
431 concat!(
432 "Offset of field: ",
433 stringify!(Rectangle),
434 "::",
435 stringify!(y)
436 )
437 );
438 assert_eq!(
439 unsafe { ::std::ptr::addr_of!((*ptr).width) as usize - ptr as usize },
440 8usize,
441 concat!(
442 "Offset of field: ",
443 stringify!(Rectangle),
444 "::",
445 stringify!(width)
446 )
447 );
448 assert_eq!(
449 unsafe { ::std::ptr::addr_of!((*ptr).height) as usize - ptr as usize },
450 12usize,
451 concat!(
452 "Offset of field: ",
453 stringify!(Rectangle),
454 "::",
455 stringify!(height)
456 )
457 );
458}
459#[repr(C)]
460#[derive(Debug, Copy, Clone)]
461pub struct Image {
462 pub data: *mut ::std::os::raw::c_void,
463 pub width: i32,
464 pub height: i32,
465 pub mipmaps: i32,
466 pub format: i32,
467}
468#[test]
469fn bindgen_test_layout_Image() {
470 const UNINIT: ::std::mem::MaybeUninit<Image> = ::std::mem::MaybeUninit::uninit();
471 let ptr = UNINIT.as_ptr();
472 assert_eq!(
473 ::std::mem::size_of::<Image>(),
474 24usize,
475 concat!("Size of: ", stringify!(Image))
476 );
477 assert_eq!(
478 ::std::mem::align_of::<Image>(),
479 8usize,
480 concat!("Alignment of ", stringify!(Image))
481 );
482 assert_eq!(
483 unsafe { ::std::ptr::addr_of!((*ptr).data) as usize - ptr as usize },
484 0usize,
485 concat!(
486 "Offset of field: ",
487 stringify!(Image),
488 "::",
489 stringify!(data)
490 )
491 );
492 assert_eq!(
493 unsafe { ::std::ptr::addr_of!((*ptr).width) as usize - ptr as usize },
494 8usize,
495 concat!(
496 "Offset of field: ",
497 stringify!(Image),
498 "::",
499 stringify!(width)
500 )
501 );
502 assert_eq!(
503 unsafe { ::std::ptr::addr_of!((*ptr).height) as usize - ptr as usize },
504 12usize,
505 concat!(
506 "Offset of field: ",
507 stringify!(Image),
508 "::",
509 stringify!(height)
510 )
511 );
512 assert_eq!(
513 unsafe { ::std::ptr::addr_of!((*ptr).mipmaps) as usize - ptr as usize },
514 16usize,
515 concat!(
516 "Offset of field: ",
517 stringify!(Image),
518 "::",
519 stringify!(mipmaps)
520 )
521 );
522 assert_eq!(
523 unsafe { ::std::ptr::addr_of!((*ptr).format) as usize - ptr as usize },
524 20usize,
525 concat!(
526 "Offset of field: ",
527 stringify!(Image),
528 "::",
529 stringify!(format)
530 )
531 );
532}
533#[repr(C)]
534#[derive(Debug, Copy, Clone)]
535pub struct Texture {
536 pub id: u32,
537 pub width: i32,
538 pub height: i32,
539 pub mipmaps: i32,
540 pub format: i32,
541}
542#[test]
543fn bindgen_test_layout_Texture() {
544 const UNINIT: ::std::mem::MaybeUninit<Texture> = ::std::mem::MaybeUninit::uninit();
545 let ptr = UNINIT.as_ptr();
546 assert_eq!(
547 ::std::mem::size_of::<Texture>(),
548 20usize,
549 concat!("Size of: ", stringify!(Texture))
550 );
551 assert_eq!(
552 ::std::mem::align_of::<Texture>(),
553 4usize,
554 concat!("Alignment of ", stringify!(Texture))
555 );
556 assert_eq!(
557 unsafe { ::std::ptr::addr_of!((*ptr).id) as usize - ptr as usize },
558 0usize,
559 concat!(
560 "Offset of field: ",
561 stringify!(Texture),
562 "::",
563 stringify!(id)
564 )
565 );
566 assert_eq!(
567 unsafe { ::std::ptr::addr_of!((*ptr).width) as usize - ptr as usize },
568 4usize,
569 concat!(
570 "Offset of field: ",
571 stringify!(Texture),
572 "::",
573 stringify!(width)
574 )
575 );
576 assert_eq!(
577 unsafe { ::std::ptr::addr_of!((*ptr).height) as usize - ptr as usize },
578 8usize,
579 concat!(
580 "Offset of field: ",
581 stringify!(Texture),
582 "::",
583 stringify!(height)
584 )
585 );
586 assert_eq!(
587 unsafe { ::std::ptr::addr_of!((*ptr).mipmaps) as usize - ptr as usize },
588 12usize,
589 concat!(
590 "Offset of field: ",
591 stringify!(Texture),
592 "::",
593 stringify!(mipmaps)
594 )
595 );
596 assert_eq!(
597 unsafe { ::std::ptr::addr_of!((*ptr).format) as usize - ptr as usize },
598 16usize,
599 concat!(
600 "Offset of field: ",
601 stringify!(Texture),
602 "::",
603 stringify!(format)
604 )
605 );
606}
607pub type Texture2D = Texture;
608pub type TextureCubemap = Texture;
609#[repr(C)]
610#[derive(Debug, Copy, Clone)]
611pub struct RenderTexture {
612 pub id: u32,
613 pub texture: Texture,
614 pub depth: Texture,
615}
616#[test]
617fn bindgen_test_layout_RenderTexture() {
618 const UNINIT: ::std::mem::MaybeUninit<RenderTexture> = ::std::mem::MaybeUninit::uninit();
619 let ptr = UNINIT.as_ptr();
620 assert_eq!(
621 ::std::mem::size_of::<RenderTexture>(),
622 44usize,
623 concat!("Size of: ", stringify!(RenderTexture))
624 );
625 assert_eq!(
626 ::std::mem::align_of::<RenderTexture>(),
627 4usize,
628 concat!("Alignment of ", stringify!(RenderTexture))
629 );
630 assert_eq!(
631 unsafe { ::std::ptr::addr_of!((*ptr).id) as usize - ptr as usize },
632 0usize,
633 concat!(
634 "Offset of field: ",
635 stringify!(RenderTexture),
636 "::",
637 stringify!(id)
638 )
639 );
640 assert_eq!(
641 unsafe { ::std::ptr::addr_of!((*ptr).texture) as usize - ptr as usize },
642 4usize,
643 concat!(
644 "Offset of field: ",
645 stringify!(RenderTexture),
646 "::",
647 stringify!(texture)
648 )
649 );
650 assert_eq!(
651 unsafe { ::std::ptr::addr_of!((*ptr).depth) as usize - ptr as usize },
652 24usize,
653 concat!(
654 "Offset of field: ",
655 stringify!(RenderTexture),
656 "::",
657 stringify!(depth)
658 )
659 );
660}
661pub type RenderTexture2D = RenderTexture;
662#[repr(C)]
663#[derive(Debug, Copy, Clone)]
664pub struct NPatchInfo {
665 pub source: Rectangle,
666 pub left: i32,
667 pub top: i32,
668 pub right: i32,
669 pub bottom: i32,
670 pub layout: i32,
671}
672#[test]
673fn bindgen_test_layout_NPatchInfo() {
674 const UNINIT: ::std::mem::MaybeUninit<NPatchInfo> = ::std::mem::MaybeUninit::uninit();
675 let ptr = UNINIT.as_ptr();
676 assert_eq!(
677 ::std::mem::size_of::<NPatchInfo>(),
678 36usize,
679 concat!("Size of: ", stringify!(NPatchInfo))
680 );
681 assert_eq!(
682 ::std::mem::align_of::<NPatchInfo>(),
683 4usize,
684 concat!("Alignment of ", stringify!(NPatchInfo))
685 );
686 assert_eq!(
687 unsafe { ::std::ptr::addr_of!((*ptr).source) as usize - ptr as usize },
688 0usize,
689 concat!(
690 "Offset of field: ",
691 stringify!(NPatchInfo),
692 "::",
693 stringify!(source)
694 )
695 );
696 assert_eq!(
697 unsafe { ::std::ptr::addr_of!((*ptr).left) as usize - ptr as usize },
698 16usize,
699 concat!(
700 "Offset of field: ",
701 stringify!(NPatchInfo),
702 "::",
703 stringify!(left)
704 )
705 );
706 assert_eq!(
707 unsafe { ::std::ptr::addr_of!((*ptr).top) as usize - ptr as usize },
708 20usize,
709 concat!(
710 "Offset of field: ",
711 stringify!(NPatchInfo),
712 "::",
713 stringify!(top)
714 )
715 );
716 assert_eq!(
717 unsafe { ::std::ptr::addr_of!((*ptr).right) as usize - ptr as usize },
718 24usize,
719 concat!(
720 "Offset of field: ",
721 stringify!(NPatchInfo),
722 "::",
723 stringify!(right)
724 )
725 );
726 assert_eq!(
727 unsafe { ::std::ptr::addr_of!((*ptr).bottom) as usize - ptr as usize },
728 28usize,
729 concat!(
730 "Offset of field: ",
731 stringify!(NPatchInfo),
732 "::",
733 stringify!(bottom)
734 )
735 );
736 assert_eq!(
737 unsafe { ::std::ptr::addr_of!((*ptr).layout) as usize - ptr as usize },
738 32usize,
739 concat!(
740 "Offset of field: ",
741 stringify!(NPatchInfo),
742 "::",
743 stringify!(layout)
744 )
745 );
746}
747#[repr(C)]
748#[derive(Debug, Copy, Clone)]
749pub struct GlyphInfo {
750 pub value: i32,
751 pub offsetX: i32,
752 pub offsetY: i32,
753 pub advanceX: i32,
754 pub image: Image,
755}
756#[test]
757fn bindgen_test_layout_GlyphInfo() {
758 const UNINIT: ::std::mem::MaybeUninit<GlyphInfo> = ::std::mem::MaybeUninit::uninit();
759 let ptr = UNINIT.as_ptr();
760 assert_eq!(
761 ::std::mem::size_of::<GlyphInfo>(),
762 40usize,
763 concat!("Size of: ", stringify!(GlyphInfo))
764 );
765 assert_eq!(
766 ::std::mem::align_of::<GlyphInfo>(),
767 8usize,
768 concat!("Alignment of ", stringify!(GlyphInfo))
769 );
770 assert_eq!(
771 unsafe { ::std::ptr::addr_of!((*ptr).value) as usize - ptr as usize },
772 0usize,
773 concat!(
774 "Offset of field: ",
775 stringify!(GlyphInfo),
776 "::",
777 stringify!(value)
778 )
779 );
780 assert_eq!(
781 unsafe { ::std::ptr::addr_of!((*ptr).offsetX) as usize - ptr as usize },
782 4usize,
783 concat!(
784 "Offset of field: ",
785 stringify!(GlyphInfo),
786 "::",
787 stringify!(offsetX)
788 )
789 );
790 assert_eq!(
791 unsafe { ::std::ptr::addr_of!((*ptr).offsetY) as usize - ptr as usize },
792 8usize,
793 concat!(
794 "Offset of field: ",
795 stringify!(GlyphInfo),
796 "::",
797 stringify!(offsetY)
798 )
799 );
800 assert_eq!(
801 unsafe { ::std::ptr::addr_of!((*ptr).advanceX) as usize - ptr as usize },
802 12usize,
803 concat!(
804 "Offset of field: ",
805 stringify!(GlyphInfo),
806 "::",
807 stringify!(advanceX)
808 )
809 );
810 assert_eq!(
811 unsafe { ::std::ptr::addr_of!((*ptr).image) as usize - ptr as usize },
812 16usize,
813 concat!(
814 "Offset of field: ",
815 stringify!(GlyphInfo),
816 "::",
817 stringify!(image)
818 )
819 );
820}
821#[repr(C)]
822#[derive(Debug, Copy, Clone)]
823pub struct Font {
824 pub baseSize: i32,
825 pub glyphCount: i32,
826 pub glyphPadding: i32,
827 pub texture: Texture2D,
828 pub recs: *mut Rectangle,
829 pub glyphs: *mut GlyphInfo,
830}
831#[test]
832fn bindgen_test_layout_Font() {
833 const UNINIT: ::std::mem::MaybeUninit<Font> = ::std::mem::MaybeUninit::uninit();
834 let ptr = UNINIT.as_ptr();
835 assert_eq!(
836 ::std::mem::size_of::<Font>(),
837 48usize,
838 concat!("Size of: ", stringify!(Font))
839 );
840 assert_eq!(
841 ::std::mem::align_of::<Font>(),
842 8usize,
843 concat!("Alignment of ", stringify!(Font))
844 );
845 assert_eq!(
846 unsafe { ::std::ptr::addr_of!((*ptr).baseSize) as usize - ptr as usize },
847 0usize,
848 concat!(
849 "Offset of field: ",
850 stringify!(Font),
851 "::",
852 stringify!(baseSize)
853 )
854 );
855 assert_eq!(
856 unsafe { ::std::ptr::addr_of!((*ptr).glyphCount) as usize - ptr as usize },
857 4usize,
858 concat!(
859 "Offset of field: ",
860 stringify!(Font),
861 "::",
862 stringify!(glyphCount)
863 )
864 );
865 assert_eq!(
866 unsafe { ::std::ptr::addr_of!((*ptr).glyphPadding) as usize - ptr as usize },
867 8usize,
868 concat!(
869 "Offset of field: ",
870 stringify!(Font),
871 "::",
872 stringify!(glyphPadding)
873 )
874 );
875 assert_eq!(
876 unsafe { ::std::ptr::addr_of!((*ptr).texture) as usize - ptr as usize },
877 12usize,
878 concat!(
879 "Offset of field: ",
880 stringify!(Font),
881 "::",
882 stringify!(texture)
883 )
884 );
885 assert_eq!(
886 unsafe { ::std::ptr::addr_of!((*ptr).recs) as usize - ptr as usize },
887 32usize,
888 concat!(
889 "Offset of field: ",
890 stringify!(Font),
891 "::",
892 stringify!(recs)
893 )
894 );
895 assert_eq!(
896 unsafe { ::std::ptr::addr_of!((*ptr).glyphs) as usize - ptr as usize },
897 40usize,
898 concat!(
899 "Offset of field: ",
900 stringify!(Font),
901 "::",
902 stringify!(glyphs)
903 )
904 );
905}
906#[repr(C)]
907#[derive(Debug, Copy, Clone)]
908pub struct Camera3D {
909 pub position: Vector3,
910 pub target: Vector3,
911 pub up: Vector3,
912 pub fovy: f32,
913 pub projection: i32,
914}
915#[test]
916fn bindgen_test_layout_Camera3D() {
917 const UNINIT: ::std::mem::MaybeUninit<Camera3D> = ::std::mem::MaybeUninit::uninit();
918 let ptr = UNINIT.as_ptr();
919 assert_eq!(
920 ::std::mem::size_of::<Camera3D>(),
921 44usize,
922 concat!("Size of: ", stringify!(Camera3D))
923 );
924 assert_eq!(
925 ::std::mem::align_of::<Camera3D>(),
926 4usize,
927 concat!("Alignment of ", stringify!(Camera3D))
928 );
929 assert_eq!(
930 unsafe { ::std::ptr::addr_of!((*ptr).position) as usize - ptr as usize },
931 0usize,
932 concat!(
933 "Offset of field: ",
934 stringify!(Camera3D),
935 "::",
936 stringify!(position)
937 )
938 );
939 assert_eq!(
940 unsafe { ::std::ptr::addr_of!((*ptr).target) as usize - ptr as usize },
941 12usize,
942 concat!(
943 "Offset of field: ",
944 stringify!(Camera3D),
945 "::",
946 stringify!(target)
947 )
948 );
949 assert_eq!(
950 unsafe { ::std::ptr::addr_of!((*ptr).up) as usize - ptr as usize },
951 24usize,
952 concat!(
953 "Offset of field: ",
954 stringify!(Camera3D),
955 "::",
956 stringify!(up)
957 )
958 );
959 assert_eq!(
960 unsafe { ::std::ptr::addr_of!((*ptr).fovy) as usize - ptr as usize },
961 36usize,
962 concat!(
963 "Offset of field: ",
964 stringify!(Camera3D),
965 "::",
966 stringify!(fovy)
967 )
968 );
969 assert_eq!(
970 unsafe { ::std::ptr::addr_of!((*ptr).projection) as usize - ptr as usize },
971 40usize,
972 concat!(
973 "Offset of field: ",
974 stringify!(Camera3D),
975 "::",
976 stringify!(projection)
977 )
978 );
979}
980pub type Camera = Camera3D;
981#[repr(C)]
982#[derive(Debug, Copy, Clone)]
983pub struct Camera2D {
984 pub offset: Vector2,
985 pub target: Vector2,
986 pub rotation: f32,
987 pub zoom: f32,
988}
989#[test]
990fn bindgen_test_layout_Camera2D() {
991 const UNINIT: ::std::mem::MaybeUninit<Camera2D> = ::std::mem::MaybeUninit::uninit();
992 let ptr = UNINIT.as_ptr();
993 assert_eq!(
994 ::std::mem::size_of::<Camera2D>(),
995 24usize,
996 concat!("Size of: ", stringify!(Camera2D))
997 );
998 assert_eq!(
999 ::std::mem::align_of::<Camera2D>(),
1000 4usize,
1001 concat!("Alignment of ", stringify!(Camera2D))
1002 );
1003 assert_eq!(
1004 unsafe { ::std::ptr::addr_of!((*ptr).offset) as usize - ptr as usize },
1005 0usize,
1006 concat!(
1007 "Offset of field: ",
1008 stringify!(Camera2D),
1009 "::",
1010 stringify!(offset)
1011 )
1012 );
1013 assert_eq!(
1014 unsafe { ::std::ptr::addr_of!((*ptr).target) as usize - ptr as usize },
1015 8usize,
1016 concat!(
1017 "Offset of field: ",
1018 stringify!(Camera2D),
1019 "::",
1020 stringify!(target)
1021 )
1022 );
1023 assert_eq!(
1024 unsafe { ::std::ptr::addr_of!((*ptr).rotation) as usize - ptr as usize },
1025 16usize,
1026 concat!(
1027 "Offset of field: ",
1028 stringify!(Camera2D),
1029 "::",
1030 stringify!(rotation)
1031 )
1032 );
1033 assert_eq!(
1034 unsafe { ::std::ptr::addr_of!((*ptr).zoom) as usize - ptr as usize },
1035 20usize,
1036 concat!(
1037 "Offset of field: ",
1038 stringify!(Camera2D),
1039 "::",
1040 stringify!(zoom)
1041 )
1042 );
1043}
1044#[repr(C)]
1045#[derive(Debug, Copy, Clone)]
1046pub struct Mesh {
1047 pub vertexCount: i32,
1048 pub triangleCount: i32,
1049 pub vertices: *mut f32,
1050 pub texcoords: *mut f32,
1051 pub texcoords2: *mut f32,
1052 pub normals: *mut f32,
1053 pub tangents: *mut f32,
1054 pub colors: *mut u8,
1055 pub indices: *mut ::std::os::raw::c_ushort,
1056 pub animVertices: *mut f32,
1057 pub animNormals: *mut f32,
1058 pub boneIds: *mut u8,
1059 pub boneWeights: *mut f32,
1060 pub vaoId: u32,
1061 pub vboId: *mut u32,
1062}
1063#[test]
1064fn bindgen_test_layout_Mesh() {
1065 const UNINIT: ::std::mem::MaybeUninit<Mesh> = ::std::mem::MaybeUninit::uninit();
1066 let ptr = UNINIT.as_ptr();
1067 assert_eq!(
1068 ::std::mem::size_of::<Mesh>(),
1069 112usize,
1070 concat!("Size of: ", stringify!(Mesh))
1071 );
1072 assert_eq!(
1073 ::std::mem::align_of::<Mesh>(),
1074 8usize,
1075 concat!("Alignment of ", stringify!(Mesh))
1076 );
1077 assert_eq!(
1078 unsafe { ::std::ptr::addr_of!((*ptr).vertexCount) as usize - ptr as usize },
1079 0usize,
1080 concat!(
1081 "Offset of field: ",
1082 stringify!(Mesh),
1083 "::",
1084 stringify!(vertexCount)
1085 )
1086 );
1087 assert_eq!(
1088 unsafe { ::std::ptr::addr_of!((*ptr).triangleCount) as usize - ptr as usize },
1089 4usize,
1090 concat!(
1091 "Offset of field: ",
1092 stringify!(Mesh),
1093 "::",
1094 stringify!(triangleCount)
1095 )
1096 );
1097 assert_eq!(
1098 unsafe { ::std::ptr::addr_of!((*ptr).vertices) as usize - ptr as usize },
1099 8usize,
1100 concat!(
1101 "Offset of field: ",
1102 stringify!(Mesh),
1103 "::",
1104 stringify!(vertices)
1105 )
1106 );
1107 assert_eq!(
1108 unsafe { ::std::ptr::addr_of!((*ptr).texcoords) as usize - ptr as usize },
1109 16usize,
1110 concat!(
1111 "Offset of field: ",
1112 stringify!(Mesh),
1113 "::",
1114 stringify!(texcoords)
1115 )
1116 );
1117 assert_eq!(
1118 unsafe { ::std::ptr::addr_of!((*ptr).texcoords2) as usize - ptr as usize },
1119 24usize,
1120 concat!(
1121 "Offset of field: ",
1122 stringify!(Mesh),
1123 "::",
1124 stringify!(texcoords2)
1125 )
1126 );
1127 assert_eq!(
1128 unsafe { ::std::ptr::addr_of!((*ptr).normals) as usize - ptr as usize },
1129 32usize,
1130 concat!(
1131 "Offset of field: ",
1132 stringify!(Mesh),
1133 "::",
1134 stringify!(normals)
1135 )
1136 );
1137 assert_eq!(
1138 unsafe { ::std::ptr::addr_of!((*ptr).tangents) as usize - ptr as usize },
1139 40usize,
1140 concat!(
1141 "Offset of field: ",
1142 stringify!(Mesh),
1143 "::",
1144 stringify!(tangents)
1145 )
1146 );
1147 assert_eq!(
1148 unsafe { ::std::ptr::addr_of!((*ptr).colors) as usize - ptr as usize },
1149 48usize,
1150 concat!(
1151 "Offset of field: ",
1152 stringify!(Mesh),
1153 "::",
1154 stringify!(colors)
1155 )
1156 );
1157 assert_eq!(
1158 unsafe { ::std::ptr::addr_of!((*ptr).indices) as usize - ptr as usize },
1159 56usize,
1160 concat!(
1161 "Offset of field: ",
1162 stringify!(Mesh),
1163 "::",
1164 stringify!(indices)
1165 )
1166 );
1167 assert_eq!(
1168 unsafe { ::std::ptr::addr_of!((*ptr).animVertices) as usize - ptr as usize },
1169 64usize,
1170 concat!(
1171 "Offset of field: ",
1172 stringify!(Mesh),
1173 "::",
1174 stringify!(animVertices)
1175 )
1176 );
1177 assert_eq!(
1178 unsafe { ::std::ptr::addr_of!((*ptr).animNormals) as usize - ptr as usize },
1179 72usize,
1180 concat!(
1181 "Offset of field: ",
1182 stringify!(Mesh),
1183 "::",
1184 stringify!(animNormals)
1185 )
1186 );
1187 assert_eq!(
1188 unsafe { ::std::ptr::addr_of!((*ptr).boneIds) as usize - ptr as usize },
1189 80usize,
1190 concat!(
1191 "Offset of field: ",
1192 stringify!(Mesh),
1193 "::",
1194 stringify!(boneIds)
1195 )
1196 );
1197 assert_eq!(
1198 unsafe { ::std::ptr::addr_of!((*ptr).boneWeights) as usize - ptr as usize },
1199 88usize,
1200 concat!(
1201 "Offset of field: ",
1202 stringify!(Mesh),
1203 "::",
1204 stringify!(boneWeights)
1205 )
1206 );
1207 assert_eq!(
1208 unsafe { ::std::ptr::addr_of!((*ptr).vaoId) as usize - ptr as usize },
1209 96usize,
1210 concat!(
1211 "Offset of field: ",
1212 stringify!(Mesh),
1213 "::",
1214 stringify!(vaoId)
1215 )
1216 );
1217 assert_eq!(
1218 unsafe { ::std::ptr::addr_of!((*ptr).vboId) as usize - ptr as usize },
1219 104usize,
1220 concat!(
1221 "Offset of field: ",
1222 stringify!(Mesh),
1223 "::",
1224 stringify!(vboId)
1225 )
1226 );
1227}
1228#[repr(C)]
1229#[derive(Debug, Copy, Clone)]
1230pub struct Shader {
1231 pub id: u32,
1232 pub locs: *mut i32,
1233}
1234#[test]
1235fn bindgen_test_layout_Shader() {
1236 const UNINIT: ::std::mem::MaybeUninit<Shader> = ::std::mem::MaybeUninit::uninit();
1237 let ptr = UNINIT.as_ptr();
1238 assert_eq!(
1239 ::std::mem::size_of::<Shader>(),
1240 16usize,
1241 concat!("Size of: ", stringify!(Shader))
1242 );
1243 assert_eq!(
1244 ::std::mem::align_of::<Shader>(),
1245 8usize,
1246 concat!("Alignment of ", stringify!(Shader))
1247 );
1248 assert_eq!(
1249 unsafe { ::std::ptr::addr_of!((*ptr).id) as usize - ptr as usize },
1250 0usize,
1251 concat!(
1252 "Offset of field: ",
1253 stringify!(Shader),
1254 "::",
1255 stringify!(id)
1256 )
1257 );
1258 assert_eq!(
1259 unsafe { ::std::ptr::addr_of!((*ptr).locs) as usize - ptr as usize },
1260 8usize,
1261 concat!(
1262 "Offset of field: ",
1263 stringify!(Shader),
1264 "::",
1265 stringify!(locs)
1266 )
1267 );
1268}
1269#[repr(C)]
1270#[derive(Debug, Copy, Clone)]
1271pub struct MaterialMap {
1272 pub texture: Texture2D,
1273 pub color: Color,
1274 pub value: f32,
1275}
1276#[test]
1277fn bindgen_test_layout_MaterialMap() {
1278 const UNINIT: ::std::mem::MaybeUninit<MaterialMap> = ::std::mem::MaybeUninit::uninit();
1279 let ptr = UNINIT.as_ptr();
1280 assert_eq!(
1281 ::std::mem::size_of::<MaterialMap>(),
1282 28usize,
1283 concat!("Size of: ", stringify!(MaterialMap))
1284 );
1285 assert_eq!(
1286 ::std::mem::align_of::<MaterialMap>(),
1287 4usize,
1288 concat!("Alignment of ", stringify!(MaterialMap))
1289 );
1290 assert_eq!(
1291 unsafe { ::std::ptr::addr_of!((*ptr).texture) as usize - ptr as usize },
1292 0usize,
1293 concat!(
1294 "Offset of field: ",
1295 stringify!(MaterialMap),
1296 "::",
1297 stringify!(texture)
1298 )
1299 );
1300 assert_eq!(
1301 unsafe { ::std::ptr::addr_of!((*ptr).color) as usize - ptr as usize },
1302 20usize,
1303 concat!(
1304 "Offset of field: ",
1305 stringify!(MaterialMap),
1306 "::",
1307 stringify!(color)
1308 )
1309 );
1310 assert_eq!(
1311 unsafe { ::std::ptr::addr_of!((*ptr).value) as usize - ptr as usize },
1312 24usize,
1313 concat!(
1314 "Offset of field: ",
1315 stringify!(MaterialMap),
1316 "::",
1317 stringify!(value)
1318 )
1319 );
1320}
1321#[repr(C)]
1322#[derive(Debug, Copy, Clone)]
1323pub struct Material {
1324 pub shader: Shader,
1325 pub maps: *mut MaterialMap,
1326 pub params: [f32; 4usize],
1327}
1328#[test]
1329fn bindgen_test_layout_Material() {
1330 const UNINIT: ::std::mem::MaybeUninit<Material> = ::std::mem::MaybeUninit::uninit();
1331 let ptr = UNINIT.as_ptr();
1332 assert_eq!(
1333 ::std::mem::size_of::<Material>(),
1334 40usize,
1335 concat!("Size of: ", stringify!(Material))
1336 );
1337 assert_eq!(
1338 ::std::mem::align_of::<Material>(),
1339 8usize,
1340 concat!("Alignment of ", stringify!(Material))
1341 );
1342 assert_eq!(
1343 unsafe { ::std::ptr::addr_of!((*ptr).shader) as usize - ptr as usize },
1344 0usize,
1345 concat!(
1346 "Offset of field: ",
1347 stringify!(Material),
1348 "::",
1349 stringify!(shader)
1350 )
1351 );
1352 assert_eq!(
1353 unsafe { ::std::ptr::addr_of!((*ptr).maps) as usize - ptr as usize },
1354 16usize,
1355 concat!(
1356 "Offset of field: ",
1357 stringify!(Material),
1358 "::",
1359 stringify!(maps)
1360 )
1361 );
1362 assert_eq!(
1363 unsafe { ::std::ptr::addr_of!((*ptr).params) as usize - ptr as usize },
1364 24usize,
1365 concat!(
1366 "Offset of field: ",
1367 stringify!(Material),
1368 "::",
1369 stringify!(params)
1370 )
1371 );
1372}
1373#[repr(C)]
1374#[derive(Debug, Copy, Clone)]
1375pub struct Transform {
1376 pub translation: Vector3,
1377 pub rotation: Quaternion,
1378 pub scale: Vector3,
1379}
1380#[test]
1381fn bindgen_test_layout_Transform() {
1382 const UNINIT: ::std::mem::MaybeUninit<Transform> = ::std::mem::MaybeUninit::uninit();
1383 let ptr = UNINIT.as_ptr();
1384 assert_eq!(
1385 ::std::mem::size_of::<Transform>(),
1386 40usize,
1387 concat!("Size of: ", stringify!(Transform))
1388 );
1389 assert_eq!(
1390 ::std::mem::align_of::<Transform>(),
1391 4usize,
1392 concat!("Alignment of ", stringify!(Transform))
1393 );
1394 assert_eq!(
1395 unsafe { ::std::ptr::addr_of!((*ptr).translation) as usize - ptr as usize },
1396 0usize,
1397 concat!(
1398 "Offset of field: ",
1399 stringify!(Transform),
1400 "::",
1401 stringify!(translation)
1402 )
1403 );
1404 assert_eq!(
1405 unsafe { ::std::ptr::addr_of!((*ptr).rotation) as usize - ptr as usize },
1406 12usize,
1407 concat!(
1408 "Offset of field: ",
1409 stringify!(Transform),
1410 "::",
1411 stringify!(rotation)
1412 )
1413 );
1414 assert_eq!(
1415 unsafe { ::std::ptr::addr_of!((*ptr).scale) as usize - ptr as usize },
1416 28usize,
1417 concat!(
1418 "Offset of field: ",
1419 stringify!(Transform),
1420 "::",
1421 stringify!(scale)
1422 )
1423 );
1424}
1425#[repr(C)]
1426#[derive(Debug, Copy, Clone)]
1427pub struct BoneInfo {
1428 pub name: [u8; 32usize],
1429 pub parent: i32,
1430}
1431#[test]
1432fn bindgen_test_layout_BoneInfo() {
1433 const UNINIT: ::std::mem::MaybeUninit<BoneInfo> = ::std::mem::MaybeUninit::uninit();
1434 let ptr = UNINIT.as_ptr();
1435 assert_eq!(
1436 ::std::mem::size_of::<BoneInfo>(),
1437 36usize,
1438 concat!("Size of: ", stringify!(BoneInfo))
1439 );
1440 assert_eq!(
1441 ::std::mem::align_of::<BoneInfo>(),
1442 4usize,
1443 concat!("Alignment of ", stringify!(BoneInfo))
1444 );
1445 assert_eq!(
1446 unsafe { ::std::ptr::addr_of!((*ptr).name) as usize - ptr as usize },
1447 0usize,
1448 concat!(
1449 "Offset of field: ",
1450 stringify!(BoneInfo),
1451 "::",
1452 stringify!(name)
1453 )
1454 );
1455 assert_eq!(
1456 unsafe { ::std::ptr::addr_of!((*ptr).parent) as usize - ptr as usize },
1457 32usize,
1458 concat!(
1459 "Offset of field: ",
1460 stringify!(BoneInfo),
1461 "::",
1462 stringify!(parent)
1463 )
1464 );
1465}
1466#[repr(C)]
1467#[derive(Debug, Copy, Clone)]
1468pub struct Model {
1469 pub transform: Matrix,
1470 pub meshCount: i32,
1471 pub materialCount: i32,
1472 pub meshes: *mut Mesh,
1473 pub materials: *mut Material,
1474 pub meshMaterial: *mut i32,
1475 pub boneCount: i32,
1476 pub bones: *mut BoneInfo,
1477 pub bindPose: *mut Transform,
1478}
1479#[test]
1480fn bindgen_test_layout_Model() {
1481 const UNINIT: ::std::mem::MaybeUninit<Model> = ::std::mem::MaybeUninit::uninit();
1482 let ptr = UNINIT.as_ptr();
1483 assert_eq!(
1484 ::std::mem::size_of::<Model>(),
1485 120usize,
1486 concat!("Size of: ", stringify!(Model))
1487 );
1488 assert_eq!(
1489 ::std::mem::align_of::<Model>(),
1490 8usize,
1491 concat!("Alignment of ", stringify!(Model))
1492 );
1493 assert_eq!(
1494 unsafe { ::std::ptr::addr_of!((*ptr).transform) as usize - ptr as usize },
1495 0usize,
1496 concat!(
1497 "Offset of field: ",
1498 stringify!(Model),
1499 "::",
1500 stringify!(transform)
1501 )
1502 );
1503 assert_eq!(
1504 unsafe { ::std::ptr::addr_of!((*ptr).meshCount) as usize - ptr as usize },
1505 64usize,
1506 concat!(
1507 "Offset of field: ",
1508 stringify!(Model),
1509 "::",
1510 stringify!(meshCount)
1511 )
1512 );
1513 assert_eq!(
1514 unsafe { ::std::ptr::addr_of!((*ptr).materialCount) as usize - ptr as usize },
1515 68usize,
1516 concat!(
1517 "Offset of field: ",
1518 stringify!(Model),
1519 "::",
1520 stringify!(materialCount)
1521 )
1522 );
1523 assert_eq!(
1524 unsafe { ::std::ptr::addr_of!((*ptr).meshes) as usize - ptr as usize },
1525 72usize,
1526 concat!(
1527 "Offset of field: ",
1528 stringify!(Model),
1529 "::",
1530 stringify!(meshes)
1531 )
1532 );
1533 assert_eq!(
1534 unsafe { ::std::ptr::addr_of!((*ptr).materials) as usize - ptr as usize },
1535 80usize,
1536 concat!(
1537 "Offset of field: ",
1538 stringify!(Model),
1539 "::",
1540 stringify!(materials)
1541 )
1542 );
1543 assert_eq!(
1544 unsafe { ::std::ptr::addr_of!((*ptr).meshMaterial) as usize - ptr as usize },
1545 88usize,
1546 concat!(
1547 "Offset of field: ",
1548 stringify!(Model),
1549 "::",
1550 stringify!(meshMaterial)
1551 )
1552 );
1553 assert_eq!(
1554 unsafe { ::std::ptr::addr_of!((*ptr).boneCount) as usize - ptr as usize },
1555 96usize,
1556 concat!(
1557 "Offset of field: ",
1558 stringify!(Model),
1559 "::",
1560 stringify!(boneCount)
1561 )
1562 );
1563 assert_eq!(
1564 unsafe { ::std::ptr::addr_of!((*ptr).bones) as usize - ptr as usize },
1565 104usize,
1566 concat!(
1567 "Offset of field: ",
1568 stringify!(Model),
1569 "::",
1570 stringify!(bones)
1571 )
1572 );
1573 assert_eq!(
1574 unsafe { ::std::ptr::addr_of!((*ptr).bindPose) as usize - ptr as usize },
1575 112usize,
1576 concat!(
1577 "Offset of field: ",
1578 stringify!(Model),
1579 "::",
1580 stringify!(bindPose)
1581 )
1582 );
1583}
1584#[repr(C)]
1585#[derive(Debug, Copy, Clone)]
1586pub struct ModelAnimation {
1587 pub boneCount: i32,
1588 pub frameCount: i32,
1589 pub bones: *mut BoneInfo,
1590 pub framePoses: *mut *mut Transform,
1591 pub name: [u8; 32usize],
1592}
1593#[test]
1594fn bindgen_test_layout_ModelAnimation() {
1595 const UNINIT: ::std::mem::MaybeUninit<ModelAnimation> = ::std::mem::MaybeUninit::uninit();
1596 let ptr = UNINIT.as_ptr();
1597 assert_eq!(
1598 ::std::mem::size_of::<ModelAnimation>(),
1599 56usize,
1600 concat!("Size of: ", stringify!(ModelAnimation))
1601 );
1602 assert_eq!(
1603 ::std::mem::align_of::<ModelAnimation>(),
1604 8usize,
1605 concat!("Alignment of ", stringify!(ModelAnimation))
1606 );
1607 assert_eq!(
1608 unsafe { ::std::ptr::addr_of!((*ptr).boneCount) as usize - ptr as usize },
1609 0usize,
1610 concat!(
1611 "Offset of field: ",
1612 stringify!(ModelAnimation),
1613 "::",
1614 stringify!(boneCount)
1615 )
1616 );
1617 assert_eq!(
1618 unsafe { ::std::ptr::addr_of!((*ptr).frameCount) as usize - ptr as usize },
1619 4usize,
1620 concat!(
1621 "Offset of field: ",
1622 stringify!(ModelAnimation),
1623 "::",
1624 stringify!(frameCount)
1625 )
1626 );
1627 assert_eq!(
1628 unsafe { ::std::ptr::addr_of!((*ptr).bones) as usize - ptr as usize },
1629 8usize,
1630 concat!(
1631 "Offset of field: ",
1632 stringify!(ModelAnimation),
1633 "::",
1634 stringify!(bones)
1635 )
1636 );
1637 assert_eq!(
1638 unsafe { ::std::ptr::addr_of!((*ptr).framePoses) as usize - ptr as usize },
1639 16usize,
1640 concat!(
1641 "Offset of field: ",
1642 stringify!(ModelAnimation),
1643 "::",
1644 stringify!(framePoses)
1645 )
1646 );
1647 assert_eq!(
1648 unsafe { ::std::ptr::addr_of!((*ptr).name) as usize - ptr as usize },
1649 24usize,
1650 concat!(
1651 "Offset of field: ",
1652 stringify!(ModelAnimation),
1653 "::",
1654 stringify!(name)
1655 )
1656 );
1657}
1658#[repr(C)]
1659#[derive(Debug, Copy, Clone)]
1660pub struct Ray {
1661 pub position: Vector3,
1662 pub direction: Vector3,
1663}
1664#[test]
1665fn bindgen_test_layout_Ray() {
1666 const UNINIT: ::std::mem::MaybeUninit<Ray> = ::std::mem::MaybeUninit::uninit();
1667 let ptr = UNINIT.as_ptr();
1668 assert_eq!(
1669 ::std::mem::size_of::<Ray>(),
1670 24usize,
1671 concat!("Size of: ", stringify!(Ray))
1672 );
1673 assert_eq!(
1674 ::std::mem::align_of::<Ray>(),
1675 4usize,
1676 concat!("Alignment of ", stringify!(Ray))
1677 );
1678 assert_eq!(
1679 unsafe { ::std::ptr::addr_of!((*ptr).position) as usize - ptr as usize },
1680 0usize,
1681 concat!(
1682 "Offset of field: ",
1683 stringify!(Ray),
1684 "::",
1685 stringify!(position)
1686 )
1687 );
1688 assert_eq!(
1689 unsafe { ::std::ptr::addr_of!((*ptr).direction) as usize - ptr as usize },
1690 12usize,
1691 concat!(
1692 "Offset of field: ",
1693 stringify!(Ray),
1694 "::",
1695 stringify!(direction)
1696 )
1697 );
1698}
1699#[repr(C)]
1700#[derive(Debug, Copy, Clone)]
1701pub struct RayCollision {
1702 pub hit: bool,
1703 pub distance: f32,
1704 pub point: Vector3,
1705 pub normal: Vector3,
1706}
1707#[test]
1708fn bindgen_test_layout_RayCollision() {
1709 const UNINIT: ::std::mem::MaybeUninit<RayCollision> = ::std::mem::MaybeUninit::uninit();
1710 let ptr = UNINIT.as_ptr();
1711 assert_eq!(
1712 ::std::mem::size_of::<RayCollision>(),
1713 32usize,
1714 concat!("Size of: ", stringify!(RayCollision))
1715 );
1716 assert_eq!(
1717 ::std::mem::align_of::<RayCollision>(),
1718 4usize,
1719 concat!("Alignment of ", stringify!(RayCollision))
1720 );
1721 assert_eq!(
1722 unsafe { ::std::ptr::addr_of!((*ptr).hit) as usize - ptr as usize },
1723 0usize,
1724 concat!(
1725 "Offset of field: ",
1726 stringify!(RayCollision),
1727 "::",
1728 stringify!(hit)
1729 )
1730 );
1731 assert_eq!(
1732 unsafe { ::std::ptr::addr_of!((*ptr).distance) as usize - ptr as usize },
1733 4usize,
1734 concat!(
1735 "Offset of field: ",
1736 stringify!(RayCollision),
1737 "::",
1738 stringify!(distance)
1739 )
1740 );
1741 assert_eq!(
1742 unsafe { ::std::ptr::addr_of!((*ptr).point) as usize - ptr as usize },
1743 8usize,
1744 concat!(
1745 "Offset of field: ",
1746 stringify!(RayCollision),
1747 "::",
1748 stringify!(point)
1749 )
1750 );
1751 assert_eq!(
1752 unsafe { ::std::ptr::addr_of!((*ptr).normal) as usize - ptr as usize },
1753 20usize,
1754 concat!(
1755 "Offset of field: ",
1756 stringify!(RayCollision),
1757 "::",
1758 stringify!(normal)
1759 )
1760 );
1761}
1762#[repr(C)]
1763#[derive(Debug, Copy, Clone)]
1764pub struct BoundingBox {
1765 pub min: Vector3,
1766 pub max: Vector3,
1767}
1768#[test]
1769fn bindgen_test_layout_BoundingBox() {
1770 const UNINIT: ::std::mem::MaybeUninit<BoundingBox> = ::std::mem::MaybeUninit::uninit();
1771 let ptr = UNINIT.as_ptr();
1772 assert_eq!(
1773 ::std::mem::size_of::<BoundingBox>(),
1774 24usize,
1775 concat!("Size of: ", stringify!(BoundingBox))
1776 );
1777 assert_eq!(
1778 ::std::mem::align_of::<BoundingBox>(),
1779 4usize,
1780 concat!("Alignment of ", stringify!(BoundingBox))
1781 );
1782 assert_eq!(
1783 unsafe { ::std::ptr::addr_of!((*ptr).min) as usize - ptr as usize },
1784 0usize,
1785 concat!(
1786 "Offset of field: ",
1787 stringify!(BoundingBox),
1788 "::",
1789 stringify!(min)
1790 )
1791 );
1792 assert_eq!(
1793 unsafe { ::std::ptr::addr_of!((*ptr).max) as usize - ptr as usize },
1794 12usize,
1795 concat!(
1796 "Offset of field: ",
1797 stringify!(BoundingBox),
1798 "::",
1799 stringify!(max)
1800 )
1801 );
1802}
1803#[repr(C)]
1804#[derive(Debug, Copy, Clone)]
1805pub struct Wave {
1806 pub frameCount: u32,
1807 pub sampleRate: u32,
1808 pub sampleSize: u32,
1809 pub channels: u32,
1810 pub data: *mut ::std::os::raw::c_void,
1811}
1812#[test]
1813fn bindgen_test_layout_Wave() {
1814 const UNINIT: ::std::mem::MaybeUninit<Wave> = ::std::mem::MaybeUninit::uninit();
1815 let ptr = UNINIT.as_ptr();
1816 assert_eq!(
1817 ::std::mem::size_of::<Wave>(),
1818 24usize,
1819 concat!("Size of: ", stringify!(Wave))
1820 );
1821 assert_eq!(
1822 ::std::mem::align_of::<Wave>(),
1823 8usize,
1824 concat!("Alignment of ", stringify!(Wave))
1825 );
1826 assert_eq!(
1827 unsafe { ::std::ptr::addr_of!((*ptr).frameCount) as usize - ptr as usize },
1828 0usize,
1829 concat!(
1830 "Offset of field: ",
1831 stringify!(Wave),
1832 "::",
1833 stringify!(frameCount)
1834 )
1835 );
1836 assert_eq!(
1837 unsafe { ::std::ptr::addr_of!((*ptr).sampleRate) as usize - ptr as usize },
1838 4usize,
1839 concat!(
1840 "Offset of field: ",
1841 stringify!(Wave),
1842 "::",
1843 stringify!(sampleRate)
1844 )
1845 );
1846 assert_eq!(
1847 unsafe { ::std::ptr::addr_of!((*ptr).sampleSize) as usize - ptr as usize },
1848 8usize,
1849 concat!(
1850 "Offset of field: ",
1851 stringify!(Wave),
1852 "::",
1853 stringify!(sampleSize)
1854 )
1855 );
1856 assert_eq!(
1857 unsafe { ::std::ptr::addr_of!((*ptr).channels) as usize - ptr as usize },
1858 12usize,
1859 concat!(
1860 "Offset of field: ",
1861 stringify!(Wave),
1862 "::",
1863 stringify!(channels)
1864 )
1865 );
1866 assert_eq!(
1867 unsafe { ::std::ptr::addr_of!((*ptr).data) as usize - ptr as usize },
1868 16usize,
1869 concat!(
1870 "Offset of field: ",
1871 stringify!(Wave),
1872 "::",
1873 stringify!(data)
1874 )
1875 );
1876}
1877#[repr(C)]
1878#[derive(Debug, Copy, Clone)]
1879pub struct rAudioBuffer {
1880 _unused: [u8; 0],
1881}
1882#[repr(C)]
1883#[derive(Debug, Copy, Clone)]
1884pub struct rAudioProcessor {
1885 _unused: [u8; 0],
1886}
1887#[repr(C)]
1888#[derive(Debug, Copy, Clone)]
1889pub struct AudioStream {
1890 pub buffer: *mut rAudioBuffer,
1891 pub processor: *mut rAudioProcessor,
1892 pub sampleRate: u32,
1893 pub sampleSize: u32,
1894 pub channels: u32,
1895}
1896#[test]
1897fn bindgen_test_layout_AudioStream() {
1898 const UNINIT: ::std::mem::MaybeUninit<AudioStream> = ::std::mem::MaybeUninit::uninit();
1899 let ptr = UNINIT.as_ptr();
1900 assert_eq!(
1901 ::std::mem::size_of::<AudioStream>(),
1902 32usize,
1903 concat!("Size of: ", stringify!(AudioStream))
1904 );
1905 assert_eq!(
1906 ::std::mem::align_of::<AudioStream>(),
1907 8usize,
1908 concat!("Alignment of ", stringify!(AudioStream))
1909 );
1910 assert_eq!(
1911 unsafe { ::std::ptr::addr_of!((*ptr).buffer) as usize - ptr as usize },
1912 0usize,
1913 concat!(
1914 "Offset of field: ",
1915 stringify!(AudioStream),
1916 "::",
1917 stringify!(buffer)
1918 )
1919 );
1920 assert_eq!(
1921 unsafe { ::std::ptr::addr_of!((*ptr).processor) as usize - ptr as usize },
1922 8usize,
1923 concat!(
1924 "Offset of field: ",
1925 stringify!(AudioStream),
1926 "::",
1927 stringify!(processor)
1928 )
1929 );
1930 assert_eq!(
1931 unsafe { ::std::ptr::addr_of!((*ptr).sampleRate) as usize - ptr as usize },
1932 16usize,
1933 concat!(
1934 "Offset of field: ",
1935 stringify!(AudioStream),
1936 "::",
1937 stringify!(sampleRate)
1938 )
1939 );
1940 assert_eq!(
1941 unsafe { ::std::ptr::addr_of!((*ptr).sampleSize) as usize - ptr as usize },
1942 20usize,
1943 concat!(
1944 "Offset of field: ",
1945 stringify!(AudioStream),
1946 "::",
1947 stringify!(sampleSize)
1948 )
1949 );
1950 assert_eq!(
1951 unsafe { ::std::ptr::addr_of!((*ptr).channels) as usize - ptr as usize },
1952 24usize,
1953 concat!(
1954 "Offset of field: ",
1955 stringify!(AudioStream),
1956 "::",
1957 stringify!(channels)
1958 )
1959 );
1960}
1961#[repr(C)]
1962#[derive(Debug, Copy, Clone)]
1963pub struct Sound {
1964 pub stream: AudioStream,
1965 pub frameCount: u32,
1966}
1967#[test]
1968fn bindgen_test_layout_Sound() {
1969 const UNINIT: ::std::mem::MaybeUninit<Sound> = ::std::mem::MaybeUninit::uninit();
1970 let ptr = UNINIT.as_ptr();
1971 assert_eq!(
1972 ::std::mem::size_of::<Sound>(),
1973 40usize,
1974 concat!("Size of: ", stringify!(Sound))
1975 );
1976 assert_eq!(
1977 ::std::mem::align_of::<Sound>(),
1978 8usize,
1979 concat!("Alignment of ", stringify!(Sound))
1980 );
1981 assert_eq!(
1982 unsafe { ::std::ptr::addr_of!((*ptr).stream) as usize - ptr as usize },
1983 0usize,
1984 concat!(
1985 "Offset of field: ",
1986 stringify!(Sound),
1987 "::",
1988 stringify!(stream)
1989 )
1990 );
1991 assert_eq!(
1992 unsafe { ::std::ptr::addr_of!((*ptr).frameCount) as usize - ptr as usize },
1993 32usize,
1994 concat!(
1995 "Offset of field: ",
1996 stringify!(Sound),
1997 "::",
1998 stringify!(frameCount)
1999 )
2000 );
2001}
2002#[repr(C)]
2003#[derive(Debug, Copy, Clone)]
2004pub struct Music {
2005 pub stream: AudioStream,
2006 pub frameCount: u32,
2007 pub looping: bool,
2008 pub ctxType: i32,
2009 pub ctxData: *mut ::std::os::raw::c_void,
2010}
2011#[test]
2012fn bindgen_test_layout_Music() {
2013 const UNINIT: ::std::mem::MaybeUninit<Music> = ::std::mem::MaybeUninit::uninit();
2014 let ptr = UNINIT.as_ptr();
2015 assert_eq!(
2016 ::std::mem::size_of::<Music>(),
2017 56usize,
2018 concat!("Size of: ", stringify!(Music))
2019 );
2020 assert_eq!(
2021 ::std::mem::align_of::<Music>(),
2022 8usize,
2023 concat!("Alignment of ", stringify!(Music))
2024 );
2025 assert_eq!(
2026 unsafe { ::std::ptr::addr_of!((*ptr).stream) as usize - ptr as usize },
2027 0usize,
2028 concat!(
2029 "Offset of field: ",
2030 stringify!(Music),
2031 "::",
2032 stringify!(stream)
2033 )
2034 );
2035 assert_eq!(
2036 unsafe { ::std::ptr::addr_of!((*ptr).frameCount) as usize - ptr as usize },
2037 32usize,
2038 concat!(
2039 "Offset of field: ",
2040 stringify!(Music),
2041 "::",
2042 stringify!(frameCount)
2043 )
2044 );
2045 assert_eq!(
2046 unsafe { ::std::ptr::addr_of!((*ptr).looping) as usize - ptr as usize },
2047 36usize,
2048 concat!(
2049 "Offset of field: ",
2050 stringify!(Music),
2051 "::",
2052 stringify!(looping)
2053 )
2054 );
2055 assert_eq!(
2056 unsafe { ::std::ptr::addr_of!((*ptr).ctxType) as usize - ptr as usize },
2057 40usize,
2058 concat!(
2059 "Offset of field: ",
2060 stringify!(Music),
2061 "::",
2062 stringify!(ctxType)
2063 )
2064 );
2065 assert_eq!(
2066 unsafe { ::std::ptr::addr_of!((*ptr).ctxData) as usize - ptr as usize },
2067 48usize,
2068 concat!(
2069 "Offset of field: ",
2070 stringify!(Music),
2071 "::",
2072 stringify!(ctxData)
2073 )
2074 );
2075}
2076#[repr(C)]
2077#[derive(Debug, Copy, Clone)]
2078pub struct VrDeviceInfo {
2079 pub hResolution: i32,
2080 pub vResolution: i32,
2081 pub hScreenSize: f32,
2082 pub vScreenSize: f32,
2083 pub vScreenCenter: f32,
2084 pub eyeToScreenDistance: f32,
2085 pub lensSeparationDistance: f32,
2086 pub interpupillaryDistance: f32,
2087 pub lensDistortionValues: [f32; 4usize],
2088 pub chromaAbCorrection: [f32; 4usize],
2089}
2090#[test]
2091fn bindgen_test_layout_VrDeviceInfo() {
2092 const UNINIT: ::std::mem::MaybeUninit<VrDeviceInfo> = ::std::mem::MaybeUninit::uninit();
2093 let ptr = UNINIT.as_ptr();
2094 assert_eq!(
2095 ::std::mem::size_of::<VrDeviceInfo>(),
2096 64usize,
2097 concat!("Size of: ", stringify!(VrDeviceInfo))
2098 );
2099 assert_eq!(
2100 ::std::mem::align_of::<VrDeviceInfo>(),
2101 4usize,
2102 concat!("Alignment of ", stringify!(VrDeviceInfo))
2103 );
2104 assert_eq!(
2105 unsafe { ::std::ptr::addr_of!((*ptr).hResolution) as usize - ptr as usize },
2106 0usize,
2107 concat!(
2108 "Offset of field: ",
2109 stringify!(VrDeviceInfo),
2110 "::",
2111 stringify!(hResolution)
2112 )
2113 );
2114 assert_eq!(
2115 unsafe { ::std::ptr::addr_of!((*ptr).vResolution) as usize - ptr as usize },
2116 4usize,
2117 concat!(
2118 "Offset of field: ",
2119 stringify!(VrDeviceInfo),
2120 "::",
2121 stringify!(vResolution)
2122 )
2123 );
2124 assert_eq!(
2125 unsafe { ::std::ptr::addr_of!((*ptr).hScreenSize) as usize - ptr as usize },
2126 8usize,
2127 concat!(
2128 "Offset of field: ",
2129 stringify!(VrDeviceInfo),
2130 "::",
2131 stringify!(hScreenSize)
2132 )
2133 );
2134 assert_eq!(
2135 unsafe { ::std::ptr::addr_of!((*ptr).vScreenSize) as usize - ptr as usize },
2136 12usize,
2137 concat!(
2138 "Offset of field: ",
2139 stringify!(VrDeviceInfo),
2140 "::",
2141 stringify!(vScreenSize)
2142 )
2143 );
2144 assert_eq!(
2145 unsafe { ::std::ptr::addr_of!((*ptr).vScreenCenter) as usize - ptr as usize },
2146 16usize,
2147 concat!(
2148 "Offset of field: ",
2149 stringify!(VrDeviceInfo),
2150 "::",
2151 stringify!(vScreenCenter)
2152 )
2153 );
2154 assert_eq!(
2155 unsafe { ::std::ptr::addr_of!((*ptr).eyeToScreenDistance) as usize - ptr as usize },
2156 20usize,
2157 concat!(
2158 "Offset of field: ",
2159 stringify!(VrDeviceInfo),
2160 "::",
2161 stringify!(eyeToScreenDistance)
2162 )
2163 );
2164 assert_eq!(
2165 unsafe { ::std::ptr::addr_of!((*ptr).lensSeparationDistance) as usize - ptr as usize },
2166 24usize,
2167 concat!(
2168 "Offset of field: ",
2169 stringify!(VrDeviceInfo),
2170 "::",
2171 stringify!(lensSeparationDistance)
2172 )
2173 );
2174 assert_eq!(
2175 unsafe { ::std::ptr::addr_of!((*ptr).interpupillaryDistance) as usize - ptr as usize },
2176 28usize,
2177 concat!(
2178 "Offset of field: ",
2179 stringify!(VrDeviceInfo),
2180 "::",
2181 stringify!(interpupillaryDistance)
2182 )
2183 );
2184 assert_eq!(
2185 unsafe { ::std::ptr::addr_of!((*ptr).lensDistortionValues) as usize - ptr as usize },
2186 32usize,
2187 concat!(
2188 "Offset of field: ",
2189 stringify!(VrDeviceInfo),
2190 "::",
2191 stringify!(lensDistortionValues)
2192 )
2193 );
2194 assert_eq!(
2195 unsafe { ::std::ptr::addr_of!((*ptr).chromaAbCorrection) as usize - ptr as usize },
2196 48usize,
2197 concat!(
2198 "Offset of field: ",
2199 stringify!(VrDeviceInfo),
2200 "::",
2201 stringify!(chromaAbCorrection)
2202 )
2203 );
2204}
2205#[repr(C)]
2206#[derive(Debug, Copy, Clone)]
2207pub struct VrStereoConfig {
2208 pub projection: [Matrix; 2usize],
2209 pub viewOffset: [Matrix; 2usize],
2210 pub leftLensCenter: [f32; 2usize],
2211 pub rightLensCenter: [f32; 2usize],
2212 pub leftScreenCenter: [f32; 2usize],
2213 pub rightScreenCenter: [f32; 2usize],
2214 pub scale: [f32; 2usize],
2215 pub scaleIn: [f32; 2usize],
2216}
2217#[test]
2218fn bindgen_test_layout_VrStereoConfig() {
2219 const UNINIT: ::std::mem::MaybeUninit<VrStereoConfig> = ::std::mem::MaybeUninit::uninit();
2220 let ptr = UNINIT.as_ptr();
2221 assert_eq!(
2222 ::std::mem::size_of::<VrStereoConfig>(),
2223 304usize,
2224 concat!("Size of: ", stringify!(VrStereoConfig))
2225 );
2226 assert_eq!(
2227 ::std::mem::align_of::<VrStereoConfig>(),
2228 4usize,
2229 concat!("Alignment of ", stringify!(VrStereoConfig))
2230 );
2231 assert_eq!(
2232 unsafe { ::std::ptr::addr_of!((*ptr).projection) as usize - ptr as usize },
2233 0usize,
2234 concat!(
2235 "Offset of field: ",
2236 stringify!(VrStereoConfig),
2237 "::",
2238 stringify!(projection)
2239 )
2240 );
2241 assert_eq!(
2242 unsafe { ::std::ptr::addr_of!((*ptr).viewOffset) as usize - ptr as usize },
2243 128usize,
2244 concat!(
2245 "Offset of field: ",
2246 stringify!(VrStereoConfig),
2247 "::",
2248 stringify!(viewOffset)
2249 )
2250 );
2251 assert_eq!(
2252 unsafe { ::std::ptr::addr_of!((*ptr).leftLensCenter) as usize - ptr as usize },
2253 256usize,
2254 concat!(
2255 "Offset of field: ",
2256 stringify!(VrStereoConfig),
2257 "::",
2258 stringify!(leftLensCenter)
2259 )
2260 );
2261 assert_eq!(
2262 unsafe { ::std::ptr::addr_of!((*ptr).rightLensCenter) as usize - ptr as usize },
2263 264usize,
2264 concat!(
2265 "Offset of field: ",
2266 stringify!(VrStereoConfig),
2267 "::",
2268 stringify!(rightLensCenter)
2269 )
2270 );
2271 assert_eq!(
2272 unsafe { ::std::ptr::addr_of!((*ptr).leftScreenCenter) as usize - ptr as usize },
2273 272usize,
2274 concat!(
2275 "Offset of field: ",
2276 stringify!(VrStereoConfig),
2277 "::",
2278 stringify!(leftScreenCenter)
2279 )
2280 );
2281 assert_eq!(
2282 unsafe { ::std::ptr::addr_of!((*ptr).rightScreenCenter) as usize - ptr as usize },
2283 280usize,
2284 concat!(
2285 "Offset of field: ",
2286 stringify!(VrStereoConfig),
2287 "::",
2288 stringify!(rightScreenCenter)
2289 )
2290 );
2291 assert_eq!(
2292 unsafe { ::std::ptr::addr_of!((*ptr).scale) as usize - ptr as usize },
2293 288usize,
2294 concat!(
2295 "Offset of field: ",
2296 stringify!(VrStereoConfig),
2297 "::",
2298 stringify!(scale)
2299 )
2300 );
2301 assert_eq!(
2302 unsafe { ::std::ptr::addr_of!((*ptr).scaleIn) as usize - ptr as usize },
2303 296usize,
2304 concat!(
2305 "Offset of field: ",
2306 stringify!(VrStereoConfig),
2307 "::",
2308 stringify!(scaleIn)
2309 )
2310 );
2311}
2312#[repr(C)]
2313#[derive(Debug, Copy, Clone)]
2314pub struct FilePathList {
2315 pub capacity: u32,
2316 pub count: u32,
2317 pub paths: *mut *mut u8,
2318}
2319#[test]
2320fn bindgen_test_layout_FilePathList() {
2321 const UNINIT: ::std::mem::MaybeUninit<FilePathList> = ::std::mem::MaybeUninit::uninit();
2322 let ptr = UNINIT.as_ptr();
2323 assert_eq!(
2324 ::std::mem::size_of::<FilePathList>(),
2325 16usize,
2326 concat!("Size of: ", stringify!(FilePathList))
2327 );
2328 assert_eq!(
2329 ::std::mem::align_of::<FilePathList>(),
2330 8usize,
2331 concat!("Alignment of ", stringify!(FilePathList))
2332 );
2333 assert_eq!(
2334 unsafe { ::std::ptr::addr_of!((*ptr).capacity) as usize - ptr as usize },
2335 0usize,
2336 concat!(
2337 "Offset of field: ",
2338 stringify!(FilePathList),
2339 "::",
2340 stringify!(capacity)
2341 )
2342 );
2343 assert_eq!(
2344 unsafe { ::std::ptr::addr_of!((*ptr).count) as usize - ptr as usize },
2345 4usize,
2346 concat!(
2347 "Offset of field: ",
2348 stringify!(FilePathList),
2349 "::",
2350 stringify!(count)
2351 )
2352 );
2353 assert_eq!(
2354 unsafe { ::std::ptr::addr_of!((*ptr).paths) as usize - ptr as usize },
2355 8usize,
2356 concat!(
2357 "Offset of field: ",
2358 stringify!(FilePathList),
2359 "::",
2360 stringify!(paths)
2361 )
2362 );
2363}
2364#[repr(C)]
2365#[derive(Debug, Copy, Clone)]
2366pub struct AutomationEvent {
2367 pub frame: u32,
2368 pub type_: u32,
2369 pub params: [i32; 4usize],
2370}
2371#[test]
2372fn bindgen_test_layout_AutomationEvent() {
2373 const UNINIT: ::std::mem::MaybeUninit<AutomationEvent> = ::std::mem::MaybeUninit::uninit();
2374 let ptr = UNINIT.as_ptr();
2375 assert_eq!(
2376 ::std::mem::size_of::<AutomationEvent>(),
2377 24usize,
2378 concat!("Size of: ", stringify!(AutomationEvent))
2379 );
2380 assert_eq!(
2381 ::std::mem::align_of::<AutomationEvent>(),
2382 4usize,
2383 concat!("Alignment of ", stringify!(AutomationEvent))
2384 );
2385 assert_eq!(
2386 unsafe { ::std::ptr::addr_of!((*ptr).frame) as usize - ptr as usize },
2387 0usize,
2388 concat!(
2389 "Offset of field: ",
2390 stringify!(AutomationEvent),
2391 "::",
2392 stringify!(frame)
2393 )
2394 );
2395 assert_eq!(
2396 unsafe { ::std::ptr::addr_of!((*ptr).type_) as usize - ptr as usize },
2397 4usize,
2398 concat!(
2399 "Offset of field: ",
2400 stringify!(AutomationEvent),
2401 "::",
2402 stringify!(type_)
2403 )
2404 );
2405 assert_eq!(
2406 unsafe { ::std::ptr::addr_of!((*ptr).params) as usize - ptr as usize },
2407 8usize,
2408 concat!(
2409 "Offset of field: ",
2410 stringify!(AutomationEvent),
2411 "::",
2412 stringify!(params)
2413 )
2414 );
2415}
2416#[repr(C)]
2417#[derive(Debug, Copy, Clone)]
2418pub struct AutomationEventList {
2419 pub capacity: u32,
2420 pub count: u32,
2421 pub events: *mut AutomationEvent,
2422}
2423#[test]
2424fn bindgen_test_layout_AutomationEventList() {
2425 const UNINIT: ::std::mem::MaybeUninit<AutomationEventList> = ::std::mem::MaybeUninit::uninit();
2426 let ptr = UNINIT.as_ptr();
2427 assert_eq!(
2428 ::std::mem::size_of::<AutomationEventList>(),
2429 16usize,
2430 concat!("Size of: ", stringify!(AutomationEventList))
2431 );
2432 assert_eq!(
2433 ::std::mem::align_of::<AutomationEventList>(),
2434 8usize,
2435 concat!("Alignment of ", stringify!(AutomationEventList))
2436 );
2437 assert_eq!(
2438 unsafe { ::std::ptr::addr_of!((*ptr).capacity) as usize - ptr as usize },
2439 0usize,
2440 concat!(
2441 "Offset of field: ",
2442 stringify!(AutomationEventList),
2443 "::",
2444 stringify!(capacity)
2445 )
2446 );
2447 assert_eq!(
2448 unsafe { ::std::ptr::addr_of!((*ptr).count) as usize - ptr as usize },
2449 4usize,
2450 concat!(
2451 "Offset of field: ",
2452 stringify!(AutomationEventList),
2453 "::",
2454 stringify!(count)
2455 )
2456 );
2457 assert_eq!(
2458 unsafe { ::std::ptr::addr_of!((*ptr).events) as usize - ptr as usize },
2459 8usize,
2460 concat!(
2461 "Offset of field: ",
2462 stringify!(AutomationEventList),
2463 "::",
2464 stringify!(events)
2465 )
2466 );
2467}