1pub const RAYLIB_VERSION_MAJOR: u32 = 5;
2pub const RAYLIB_VERSION_MINOR: u32 = 5;
3pub const RAYLIB_VERSION_PATCH: u32 = 0;
4pub const RAYLIB_VERSION: &[u8; 8usize] = b"5.5-dev\0";
5pub const PI: f64 = 3.141592653589793;
6pub const DEG2RAD: f64 = 0.017453292519943295;
7pub const RAD2DEG: f64 = 57.29577951308232;
8pub const __bool_true_false_are_defined: u32 = 1;
9pub const true_: u32 = 1;
10pub const false_: u32 = 0;
11pub type __gnuc_va_list = __builtin_va_list;
12pub type va_list = __builtin_va_list;
13#[repr(C)]
14#[derive(Debug, Copy, Clone)]
15pub struct Vector2 {
16 pub x: f32,
17 pub y: f32,
18}
19#[test]
20fn bindgen_test_layout_Vector2() {
21 const UNINIT: ::std::mem::MaybeUninit<Vector2> = ::std::mem::MaybeUninit::uninit();
22 let ptr = UNINIT.as_ptr();
23 assert_eq!(
24 ::std::mem::size_of::<Vector2>(),
25 8usize,
26 concat!("Size of: ", stringify!(Vector2))
27 );
28 assert_eq!(
29 ::std::mem::align_of::<Vector2>(),
30 4usize,
31 concat!("Alignment of ", stringify!(Vector2))
32 );
33 assert_eq!(
34 unsafe { ::std::ptr::addr_of!((*ptr).x) as usize - ptr as usize },
35 0usize,
36 concat!(
37 "Offset of field: ",
38 stringify!(Vector2),
39 "::",
40 stringify!(x)
41 )
42 );
43 assert_eq!(
44 unsafe { ::std::ptr::addr_of!((*ptr).y) as usize - ptr as usize },
45 4usize,
46 concat!(
47 "Offset of field: ",
48 stringify!(Vector2),
49 "::",
50 stringify!(y)
51 )
52 );
53}
54#[repr(C)]
55#[derive(Debug, Copy, Clone)]
56pub struct Vector3 {
57 pub x: f32,
58 pub y: f32,
59 pub z: f32,
60}
61#[test]
62fn bindgen_test_layout_Vector3() {
63 const UNINIT: ::std::mem::MaybeUninit<Vector3> = ::std::mem::MaybeUninit::uninit();
64 let ptr = UNINIT.as_ptr();
65 assert_eq!(
66 ::std::mem::size_of::<Vector3>(),
67 12usize,
68 concat!("Size of: ", stringify!(Vector3))
69 );
70 assert_eq!(
71 ::std::mem::align_of::<Vector3>(),
72 4usize,
73 concat!("Alignment of ", stringify!(Vector3))
74 );
75 assert_eq!(
76 unsafe { ::std::ptr::addr_of!((*ptr).x) as usize - ptr as usize },
77 0usize,
78 concat!(
79 "Offset of field: ",
80 stringify!(Vector3),
81 "::",
82 stringify!(x)
83 )
84 );
85 assert_eq!(
86 unsafe { ::std::ptr::addr_of!((*ptr).y) as usize - ptr as usize },
87 4usize,
88 concat!(
89 "Offset of field: ",
90 stringify!(Vector3),
91 "::",
92 stringify!(y)
93 )
94 );
95 assert_eq!(
96 unsafe { ::std::ptr::addr_of!((*ptr).z) as usize - ptr as usize },
97 8usize,
98 concat!(
99 "Offset of field: ",
100 stringify!(Vector3),
101 "::",
102 stringify!(z)
103 )
104 );
105}
106#[repr(C)]
107#[derive(Debug, Copy, Clone)]
108pub struct Vector4 {
109 pub x: f32,
110 pub y: f32,
111 pub z: f32,
112 pub w: f32,
113}
114#[test]
115fn bindgen_test_layout_Vector4() {
116 const UNINIT: ::std::mem::MaybeUninit<Vector4> = ::std::mem::MaybeUninit::uninit();
117 let ptr = UNINIT.as_ptr();
118 assert_eq!(
119 ::std::mem::size_of::<Vector4>(),
120 16usize,
121 concat!("Size of: ", stringify!(Vector4))
122 );
123 assert_eq!(
124 ::std::mem::align_of::<Vector4>(),
125 4usize,
126 concat!("Alignment of ", stringify!(Vector4))
127 );
128 assert_eq!(
129 unsafe { ::std::ptr::addr_of!((*ptr).x) as usize - ptr as usize },
130 0usize,
131 concat!(
132 "Offset of field: ",
133 stringify!(Vector4),
134 "::",
135 stringify!(x)
136 )
137 );
138 assert_eq!(
139 unsafe { ::std::ptr::addr_of!((*ptr).y) as usize - ptr as usize },
140 4usize,
141 concat!(
142 "Offset of field: ",
143 stringify!(Vector4),
144 "::",
145 stringify!(y)
146 )
147 );
148 assert_eq!(
149 unsafe { ::std::ptr::addr_of!((*ptr).z) as usize - ptr as usize },
150 8usize,
151 concat!(
152 "Offset of field: ",
153 stringify!(Vector4),
154 "::",
155 stringify!(z)
156 )
157 );
158 assert_eq!(
159 unsafe { ::std::ptr::addr_of!((*ptr).w) as usize - ptr as usize },
160 12usize,
161 concat!(
162 "Offset of field: ",
163 stringify!(Vector4),
164 "::",
165 stringify!(w)
166 )
167 );
168}
169pub type Quaternion = Vector4;
170#[repr(C)]
171#[derive(Debug, Copy, Clone)]
172pub struct Matrix {
173 pub m0: f32,
174 pub m4: f32,
175 pub m8: f32,
176 pub m12: f32,
177 pub m1: f32,
178 pub m5: f32,
179 pub m9: f32,
180 pub m13: f32,
181 pub m2: f32,
182 pub m6: f32,
183 pub m10: f32,
184 pub m14: f32,
185 pub m3: f32,
186 pub m7: f32,
187 pub m11: f32,
188 pub m15: f32,
189}
190#[test]
191fn bindgen_test_layout_Matrix() {
192 const UNINIT: ::std::mem::MaybeUninit<Matrix> = ::std::mem::MaybeUninit::uninit();
193 let ptr = UNINIT.as_ptr();
194 assert_eq!(
195 ::std::mem::size_of::<Matrix>(),
196 64usize,
197 concat!("Size of: ", stringify!(Matrix))
198 );
199 assert_eq!(
200 ::std::mem::align_of::<Matrix>(),
201 4usize,
202 concat!("Alignment of ", stringify!(Matrix))
203 );
204 assert_eq!(
205 unsafe { ::std::ptr::addr_of!((*ptr).m0) as usize - ptr as usize },
206 0usize,
207 concat!(
208 "Offset of field: ",
209 stringify!(Matrix),
210 "::",
211 stringify!(m0)
212 )
213 );
214 assert_eq!(
215 unsafe { ::std::ptr::addr_of!((*ptr).m4) as usize - ptr as usize },
216 4usize,
217 concat!(
218 "Offset of field: ",
219 stringify!(Matrix),
220 "::",
221 stringify!(m4)
222 )
223 );
224 assert_eq!(
225 unsafe { ::std::ptr::addr_of!((*ptr).m8) as usize - ptr as usize },
226 8usize,
227 concat!(
228 "Offset of field: ",
229 stringify!(Matrix),
230 "::",
231 stringify!(m8)
232 )
233 );
234 assert_eq!(
235 unsafe { ::std::ptr::addr_of!((*ptr).m12) as usize - ptr as usize },
236 12usize,
237 concat!(
238 "Offset of field: ",
239 stringify!(Matrix),
240 "::",
241 stringify!(m12)
242 )
243 );
244 assert_eq!(
245 unsafe { ::std::ptr::addr_of!((*ptr).m1) as usize - ptr as usize },
246 16usize,
247 concat!(
248 "Offset of field: ",
249 stringify!(Matrix),
250 "::",
251 stringify!(m1)
252 )
253 );
254 assert_eq!(
255 unsafe { ::std::ptr::addr_of!((*ptr).m5) as usize - ptr as usize },
256 20usize,
257 concat!(
258 "Offset of field: ",
259 stringify!(Matrix),
260 "::",
261 stringify!(m5)
262 )
263 );
264 assert_eq!(
265 unsafe { ::std::ptr::addr_of!((*ptr).m9) as usize - ptr as usize },
266 24usize,
267 concat!(
268 "Offset of field: ",
269 stringify!(Matrix),
270 "::",
271 stringify!(m9)
272 )
273 );
274 assert_eq!(
275 unsafe { ::std::ptr::addr_of!((*ptr).m13) as usize - ptr as usize },
276 28usize,
277 concat!(
278 "Offset of field: ",
279 stringify!(Matrix),
280 "::",
281 stringify!(m13)
282 )
283 );
284 assert_eq!(
285 unsafe { ::std::ptr::addr_of!((*ptr).m2) as usize - ptr as usize },
286 32usize,
287 concat!(
288 "Offset of field: ",
289 stringify!(Matrix),
290 "::",
291 stringify!(m2)
292 )
293 );
294 assert_eq!(
295 unsafe { ::std::ptr::addr_of!((*ptr).m6) as usize - ptr as usize },
296 36usize,
297 concat!(
298 "Offset of field: ",
299 stringify!(Matrix),
300 "::",
301 stringify!(m6)
302 )
303 );
304 assert_eq!(
305 unsafe { ::std::ptr::addr_of!((*ptr).m10) as usize - ptr as usize },
306 40usize,
307 concat!(
308 "Offset of field: ",
309 stringify!(Matrix),
310 "::",
311 stringify!(m10)
312 )
313 );
314 assert_eq!(
315 unsafe { ::std::ptr::addr_of!((*ptr).m14) as usize - ptr as usize },
316 44usize,
317 concat!(
318 "Offset of field: ",
319 stringify!(Matrix),
320 "::",
321 stringify!(m14)
322 )
323 );
324 assert_eq!(
325 unsafe { ::std::ptr::addr_of!((*ptr).m3) as usize - ptr as usize },
326 48usize,
327 concat!(
328 "Offset of field: ",
329 stringify!(Matrix),
330 "::",
331 stringify!(m3)
332 )
333 );
334 assert_eq!(
335 unsafe { ::std::ptr::addr_of!((*ptr).m7) as usize - ptr as usize },
336 52usize,
337 concat!(
338 "Offset of field: ",
339 stringify!(Matrix),
340 "::",
341 stringify!(m7)
342 )
343 );
344 assert_eq!(
345 unsafe { ::std::ptr::addr_of!((*ptr).m11) as usize - ptr as usize },
346 56usize,
347 concat!(
348 "Offset of field: ",
349 stringify!(Matrix),
350 "::",
351 stringify!(m11)
352 )
353 );
354 assert_eq!(
355 unsafe { ::std::ptr::addr_of!((*ptr).m15) as usize - ptr as usize },
356 60usize,
357 concat!(
358 "Offset of field: ",
359 stringify!(Matrix),
360 "::",
361 stringify!(m15)
362 )
363 );
364}
365#[repr(C)]
366#[derive(Debug, Copy, Clone)]
367pub struct Color {
368 pub r: ::std::os::raw::c_uchar,
369 pub g: ::std::os::raw::c_uchar,
370 pub b: ::std::os::raw::c_uchar,
371 pub a: ::std::os::raw::c_uchar,
372}
373#[test]
374fn bindgen_test_layout_Color() {
375 const UNINIT: ::std::mem::MaybeUninit<Color> = ::std::mem::MaybeUninit::uninit();
376 let ptr = UNINIT.as_ptr();
377 assert_eq!(
378 ::std::mem::size_of::<Color>(),
379 4usize,
380 concat!("Size of: ", stringify!(Color))
381 );
382 assert_eq!(
383 ::std::mem::align_of::<Color>(),
384 1usize,
385 concat!("Alignment of ", stringify!(Color))
386 );
387 assert_eq!(
388 unsafe { ::std::ptr::addr_of!((*ptr).r) as usize - ptr as usize },
389 0usize,
390 concat!("Offset of field: ", stringify!(Color), "::", stringify!(r))
391 );
392 assert_eq!(
393 unsafe { ::std::ptr::addr_of!((*ptr).g) as usize - ptr as usize },
394 1usize,
395 concat!("Offset of field: ", stringify!(Color), "::", stringify!(g))
396 );
397 assert_eq!(
398 unsafe { ::std::ptr::addr_of!((*ptr).b) as usize - ptr as usize },
399 2usize,
400 concat!("Offset of field: ", stringify!(Color), "::", stringify!(b))
401 );
402 assert_eq!(
403 unsafe { ::std::ptr::addr_of!((*ptr).a) as usize - ptr as usize },
404 3usize,
405 concat!("Offset of field: ", stringify!(Color), "::", stringify!(a))
406 );
407}
408#[repr(C)]
409#[derive(Debug, Copy, Clone)]
410pub struct Rectangle {
411 pub x: f32,
412 pub y: f32,
413 pub width: f32,
414 pub height: f32,
415}
416#[test]
417fn bindgen_test_layout_Rectangle() {
418 const UNINIT: ::std::mem::MaybeUninit<Rectangle> = ::std::mem::MaybeUninit::uninit();
419 let ptr = UNINIT.as_ptr();
420 assert_eq!(
421 ::std::mem::size_of::<Rectangle>(),
422 16usize,
423 concat!("Size of: ", stringify!(Rectangle))
424 );
425 assert_eq!(
426 ::std::mem::align_of::<Rectangle>(),
427 4usize,
428 concat!("Alignment of ", stringify!(Rectangle))
429 );
430 assert_eq!(
431 unsafe { ::std::ptr::addr_of!((*ptr).x) as usize - ptr as usize },
432 0usize,
433 concat!(
434 "Offset of field: ",
435 stringify!(Rectangle),
436 "::",
437 stringify!(x)
438 )
439 );
440 assert_eq!(
441 unsafe { ::std::ptr::addr_of!((*ptr).y) as usize - ptr as usize },
442 4usize,
443 concat!(
444 "Offset of field: ",
445 stringify!(Rectangle),
446 "::",
447 stringify!(y)
448 )
449 );
450 assert_eq!(
451 unsafe { ::std::ptr::addr_of!((*ptr).width) as usize - ptr as usize },
452 8usize,
453 concat!(
454 "Offset of field: ",
455 stringify!(Rectangle),
456 "::",
457 stringify!(width)
458 )
459 );
460 assert_eq!(
461 unsafe { ::std::ptr::addr_of!((*ptr).height) as usize - ptr as usize },
462 12usize,
463 concat!(
464 "Offset of field: ",
465 stringify!(Rectangle),
466 "::",
467 stringify!(height)
468 )
469 );
470}
471#[repr(C)]
472#[derive(Debug, Copy, Clone)]
473pub struct Image {
474 pub data: *mut ::std::os::raw::c_void,
475 pub width: ::std::os::raw::c_int,
476 pub height: ::std::os::raw::c_int,
477 pub mipmaps: ::std::os::raw::c_int,
478 pub format: ::std::os::raw::c_int,
479}
480#[test]
481fn bindgen_test_layout_Image() {
482 const UNINIT: ::std::mem::MaybeUninit<Image> = ::std::mem::MaybeUninit::uninit();
483 let ptr = UNINIT.as_ptr();
484 assert_eq!(
485 ::std::mem::size_of::<Image>(),
486 24usize,
487 concat!("Size of: ", stringify!(Image))
488 );
489 assert_eq!(
490 ::std::mem::align_of::<Image>(),
491 8usize,
492 concat!("Alignment of ", stringify!(Image))
493 );
494 assert_eq!(
495 unsafe { ::std::ptr::addr_of!((*ptr).data) as usize - ptr as usize },
496 0usize,
497 concat!(
498 "Offset of field: ",
499 stringify!(Image),
500 "::",
501 stringify!(data)
502 )
503 );
504 assert_eq!(
505 unsafe { ::std::ptr::addr_of!((*ptr).width) as usize - ptr as usize },
506 8usize,
507 concat!(
508 "Offset of field: ",
509 stringify!(Image),
510 "::",
511 stringify!(width)
512 )
513 );
514 assert_eq!(
515 unsafe { ::std::ptr::addr_of!((*ptr).height) as usize - ptr as usize },
516 12usize,
517 concat!(
518 "Offset of field: ",
519 stringify!(Image),
520 "::",
521 stringify!(height)
522 )
523 );
524 assert_eq!(
525 unsafe { ::std::ptr::addr_of!((*ptr).mipmaps) as usize - ptr as usize },
526 16usize,
527 concat!(
528 "Offset of field: ",
529 stringify!(Image),
530 "::",
531 stringify!(mipmaps)
532 )
533 );
534 assert_eq!(
535 unsafe { ::std::ptr::addr_of!((*ptr).format) as usize - ptr as usize },
536 20usize,
537 concat!(
538 "Offset of field: ",
539 stringify!(Image),
540 "::",
541 stringify!(format)
542 )
543 );
544}
545#[repr(C)]
546#[derive(Debug, Copy, Clone)]
547pub struct Texture {
548 pub id: ::std::os::raw::c_uint,
549 pub width: ::std::os::raw::c_int,
550 pub height: ::std::os::raw::c_int,
551 pub mipmaps: ::std::os::raw::c_int,
552 pub format: ::std::os::raw::c_int,
553}
554#[test]
555fn bindgen_test_layout_Texture() {
556 const UNINIT: ::std::mem::MaybeUninit<Texture> = ::std::mem::MaybeUninit::uninit();
557 let ptr = UNINIT.as_ptr();
558 assert_eq!(
559 ::std::mem::size_of::<Texture>(),
560 20usize,
561 concat!("Size of: ", stringify!(Texture))
562 );
563 assert_eq!(
564 ::std::mem::align_of::<Texture>(),
565 4usize,
566 concat!("Alignment of ", stringify!(Texture))
567 );
568 assert_eq!(
569 unsafe { ::std::ptr::addr_of!((*ptr).id) as usize - ptr as usize },
570 0usize,
571 concat!(
572 "Offset of field: ",
573 stringify!(Texture),
574 "::",
575 stringify!(id)
576 )
577 );
578 assert_eq!(
579 unsafe { ::std::ptr::addr_of!((*ptr).width) as usize - ptr as usize },
580 4usize,
581 concat!(
582 "Offset of field: ",
583 stringify!(Texture),
584 "::",
585 stringify!(width)
586 )
587 );
588 assert_eq!(
589 unsafe { ::std::ptr::addr_of!((*ptr).height) as usize - ptr as usize },
590 8usize,
591 concat!(
592 "Offset of field: ",
593 stringify!(Texture),
594 "::",
595 stringify!(height)
596 )
597 );
598 assert_eq!(
599 unsafe { ::std::ptr::addr_of!((*ptr).mipmaps) as usize - ptr as usize },
600 12usize,
601 concat!(
602 "Offset of field: ",
603 stringify!(Texture),
604 "::",
605 stringify!(mipmaps)
606 )
607 );
608 assert_eq!(
609 unsafe { ::std::ptr::addr_of!((*ptr).format) as usize - ptr as usize },
610 16usize,
611 concat!(
612 "Offset of field: ",
613 stringify!(Texture),
614 "::",
615 stringify!(format)
616 )
617 );
618}
619pub type Texture2D = Texture;
620pub type TextureCubemap = Texture;
621#[repr(C)]
622#[derive(Debug, Copy, Clone)]
623pub struct RenderTexture {
624 pub id: ::std::os::raw::c_uint,
625 pub texture: Texture,
626 pub depth: Texture,
627}
628#[test]
629fn bindgen_test_layout_RenderTexture() {
630 const UNINIT: ::std::mem::MaybeUninit<RenderTexture> = ::std::mem::MaybeUninit::uninit();
631 let ptr = UNINIT.as_ptr();
632 assert_eq!(
633 ::std::mem::size_of::<RenderTexture>(),
634 44usize,
635 concat!("Size of: ", stringify!(RenderTexture))
636 );
637 assert_eq!(
638 ::std::mem::align_of::<RenderTexture>(),
639 4usize,
640 concat!("Alignment of ", stringify!(RenderTexture))
641 );
642 assert_eq!(
643 unsafe { ::std::ptr::addr_of!((*ptr).id) as usize - ptr as usize },
644 0usize,
645 concat!(
646 "Offset of field: ",
647 stringify!(RenderTexture),
648 "::",
649 stringify!(id)
650 )
651 );
652 assert_eq!(
653 unsafe { ::std::ptr::addr_of!((*ptr).texture) as usize - ptr as usize },
654 4usize,
655 concat!(
656 "Offset of field: ",
657 stringify!(RenderTexture),
658 "::",
659 stringify!(texture)
660 )
661 );
662 assert_eq!(
663 unsafe { ::std::ptr::addr_of!((*ptr).depth) as usize - ptr as usize },
664 24usize,
665 concat!(
666 "Offset of field: ",
667 stringify!(RenderTexture),
668 "::",
669 stringify!(depth)
670 )
671 );
672}
673pub type RenderTexture2D = RenderTexture;
674#[repr(C)]
675#[derive(Debug, Copy, Clone)]
676pub struct NPatchInfo {
677 pub source: Rectangle,
678 pub left: ::std::os::raw::c_int,
679 pub top: ::std::os::raw::c_int,
680 pub right: ::std::os::raw::c_int,
681 pub bottom: ::std::os::raw::c_int,
682 pub layout: ::std::os::raw::c_int,
683}
684#[test]
685fn bindgen_test_layout_NPatchInfo() {
686 const UNINIT: ::std::mem::MaybeUninit<NPatchInfo> = ::std::mem::MaybeUninit::uninit();
687 let ptr = UNINIT.as_ptr();
688 assert_eq!(
689 ::std::mem::size_of::<NPatchInfo>(),
690 36usize,
691 concat!("Size of: ", stringify!(NPatchInfo))
692 );
693 assert_eq!(
694 ::std::mem::align_of::<NPatchInfo>(),
695 4usize,
696 concat!("Alignment of ", stringify!(NPatchInfo))
697 );
698 assert_eq!(
699 unsafe { ::std::ptr::addr_of!((*ptr).source) as usize - ptr as usize },
700 0usize,
701 concat!(
702 "Offset of field: ",
703 stringify!(NPatchInfo),
704 "::",
705 stringify!(source)
706 )
707 );
708 assert_eq!(
709 unsafe { ::std::ptr::addr_of!((*ptr).left) as usize - ptr as usize },
710 16usize,
711 concat!(
712 "Offset of field: ",
713 stringify!(NPatchInfo),
714 "::",
715 stringify!(left)
716 )
717 );
718 assert_eq!(
719 unsafe { ::std::ptr::addr_of!((*ptr).top) as usize - ptr as usize },
720 20usize,
721 concat!(
722 "Offset of field: ",
723 stringify!(NPatchInfo),
724 "::",
725 stringify!(top)
726 )
727 );
728 assert_eq!(
729 unsafe { ::std::ptr::addr_of!((*ptr).right) as usize - ptr as usize },
730 24usize,
731 concat!(
732 "Offset of field: ",
733 stringify!(NPatchInfo),
734 "::",
735 stringify!(right)
736 )
737 );
738 assert_eq!(
739 unsafe { ::std::ptr::addr_of!((*ptr).bottom) as usize - ptr as usize },
740 28usize,
741 concat!(
742 "Offset of field: ",
743 stringify!(NPatchInfo),
744 "::",
745 stringify!(bottom)
746 )
747 );
748 assert_eq!(
749 unsafe { ::std::ptr::addr_of!((*ptr).layout) as usize - ptr as usize },
750 32usize,
751 concat!(
752 "Offset of field: ",
753 stringify!(NPatchInfo),
754 "::",
755 stringify!(layout)
756 )
757 );
758}
759#[repr(C)]
760#[derive(Debug, Copy, Clone)]
761pub struct GlyphInfo {
762 pub value: ::std::os::raw::c_int,
763 pub offsetX: ::std::os::raw::c_int,
764 pub offsetY: ::std::os::raw::c_int,
765 pub advanceX: ::std::os::raw::c_int,
766 pub image: Image,
767}
768#[test]
769fn bindgen_test_layout_GlyphInfo() {
770 const UNINIT: ::std::mem::MaybeUninit<GlyphInfo> = ::std::mem::MaybeUninit::uninit();
771 let ptr = UNINIT.as_ptr();
772 assert_eq!(
773 ::std::mem::size_of::<GlyphInfo>(),
774 40usize,
775 concat!("Size of: ", stringify!(GlyphInfo))
776 );
777 assert_eq!(
778 ::std::mem::align_of::<GlyphInfo>(),
779 8usize,
780 concat!("Alignment of ", stringify!(GlyphInfo))
781 );
782 assert_eq!(
783 unsafe { ::std::ptr::addr_of!((*ptr).value) as usize - ptr as usize },
784 0usize,
785 concat!(
786 "Offset of field: ",
787 stringify!(GlyphInfo),
788 "::",
789 stringify!(value)
790 )
791 );
792 assert_eq!(
793 unsafe { ::std::ptr::addr_of!((*ptr).offsetX) as usize - ptr as usize },
794 4usize,
795 concat!(
796 "Offset of field: ",
797 stringify!(GlyphInfo),
798 "::",
799 stringify!(offsetX)
800 )
801 );
802 assert_eq!(
803 unsafe { ::std::ptr::addr_of!((*ptr).offsetY) as usize - ptr as usize },
804 8usize,
805 concat!(
806 "Offset of field: ",
807 stringify!(GlyphInfo),
808 "::",
809 stringify!(offsetY)
810 )
811 );
812 assert_eq!(
813 unsafe { ::std::ptr::addr_of!((*ptr).advanceX) as usize - ptr as usize },
814 12usize,
815 concat!(
816 "Offset of field: ",
817 stringify!(GlyphInfo),
818 "::",
819 stringify!(advanceX)
820 )
821 );
822 assert_eq!(
823 unsafe { ::std::ptr::addr_of!((*ptr).image) as usize - ptr as usize },
824 16usize,
825 concat!(
826 "Offset of field: ",
827 stringify!(GlyphInfo),
828 "::",
829 stringify!(image)
830 )
831 );
832}
833#[repr(C)]
834#[derive(Debug, Copy, Clone)]
835pub struct Font {
836 pub baseSize: ::std::os::raw::c_int,
837 pub glyphCount: ::std::os::raw::c_int,
838 pub glyphPadding: ::std::os::raw::c_int,
839 pub texture: Texture2D,
840 pub recs: *mut Rectangle,
841 pub glyphs: *mut GlyphInfo,
842}
843#[test]
844fn bindgen_test_layout_Font() {
845 const UNINIT: ::std::mem::MaybeUninit<Font> = ::std::mem::MaybeUninit::uninit();
846 let ptr = UNINIT.as_ptr();
847 assert_eq!(
848 ::std::mem::size_of::<Font>(),
849 48usize,
850 concat!("Size of: ", stringify!(Font))
851 );
852 assert_eq!(
853 ::std::mem::align_of::<Font>(),
854 8usize,
855 concat!("Alignment of ", stringify!(Font))
856 );
857 assert_eq!(
858 unsafe { ::std::ptr::addr_of!((*ptr).baseSize) as usize - ptr as usize },
859 0usize,
860 concat!(
861 "Offset of field: ",
862 stringify!(Font),
863 "::",
864 stringify!(baseSize)
865 )
866 );
867 assert_eq!(
868 unsafe { ::std::ptr::addr_of!((*ptr).glyphCount) as usize - ptr as usize },
869 4usize,
870 concat!(
871 "Offset of field: ",
872 stringify!(Font),
873 "::",
874 stringify!(glyphCount)
875 )
876 );
877 assert_eq!(
878 unsafe { ::std::ptr::addr_of!((*ptr).glyphPadding) as usize - ptr as usize },
879 8usize,
880 concat!(
881 "Offset of field: ",
882 stringify!(Font),
883 "::",
884 stringify!(glyphPadding)
885 )
886 );
887 assert_eq!(
888 unsafe { ::std::ptr::addr_of!((*ptr).texture) as usize - ptr as usize },
889 12usize,
890 concat!(
891 "Offset of field: ",
892 stringify!(Font),
893 "::",
894 stringify!(texture)
895 )
896 );
897 assert_eq!(
898 unsafe { ::std::ptr::addr_of!((*ptr).recs) as usize - ptr as usize },
899 32usize,
900 concat!(
901 "Offset of field: ",
902 stringify!(Font),
903 "::",
904 stringify!(recs)
905 )
906 );
907 assert_eq!(
908 unsafe { ::std::ptr::addr_of!((*ptr).glyphs) as usize - ptr as usize },
909 40usize,
910 concat!(
911 "Offset of field: ",
912 stringify!(Font),
913 "::",
914 stringify!(glyphs)
915 )
916 );
917}
918#[repr(C)]
919#[derive(Debug, Copy, Clone)]
920pub struct Camera3D {
921 pub position: Vector3,
922 pub target: Vector3,
923 pub up: Vector3,
924 pub fovy: f32,
925 pub projection: ::std::os::raw::c_int,
926}
927#[test]
928fn bindgen_test_layout_Camera3D() {
929 const UNINIT: ::std::mem::MaybeUninit<Camera3D> = ::std::mem::MaybeUninit::uninit();
930 let ptr = UNINIT.as_ptr();
931 assert_eq!(
932 ::std::mem::size_of::<Camera3D>(),
933 44usize,
934 concat!("Size of: ", stringify!(Camera3D))
935 );
936 assert_eq!(
937 ::std::mem::align_of::<Camera3D>(),
938 4usize,
939 concat!("Alignment of ", stringify!(Camera3D))
940 );
941 assert_eq!(
942 unsafe { ::std::ptr::addr_of!((*ptr).position) as usize - ptr as usize },
943 0usize,
944 concat!(
945 "Offset of field: ",
946 stringify!(Camera3D),
947 "::",
948 stringify!(position)
949 )
950 );
951 assert_eq!(
952 unsafe { ::std::ptr::addr_of!((*ptr).target) as usize - ptr as usize },
953 12usize,
954 concat!(
955 "Offset of field: ",
956 stringify!(Camera3D),
957 "::",
958 stringify!(target)
959 )
960 );
961 assert_eq!(
962 unsafe { ::std::ptr::addr_of!((*ptr).up) as usize - ptr as usize },
963 24usize,
964 concat!(
965 "Offset of field: ",
966 stringify!(Camera3D),
967 "::",
968 stringify!(up)
969 )
970 );
971 assert_eq!(
972 unsafe { ::std::ptr::addr_of!((*ptr).fovy) as usize - ptr as usize },
973 36usize,
974 concat!(
975 "Offset of field: ",
976 stringify!(Camera3D),
977 "::",
978 stringify!(fovy)
979 )
980 );
981 assert_eq!(
982 unsafe { ::std::ptr::addr_of!((*ptr).projection) as usize - ptr as usize },
983 40usize,
984 concat!(
985 "Offset of field: ",
986 stringify!(Camera3D),
987 "::",
988 stringify!(projection)
989 )
990 );
991}
992pub type Camera = Camera3D;
993#[repr(C)]
994#[derive(Debug, Copy, Clone)]
995pub struct Camera2D {
996 pub offset: Vector2,
997 pub target: Vector2,
998 pub rotation: f32,
999 pub zoom: f32,
1000}
1001#[test]
1002fn bindgen_test_layout_Camera2D() {
1003 const UNINIT: ::std::mem::MaybeUninit<Camera2D> = ::std::mem::MaybeUninit::uninit();
1004 let ptr = UNINIT.as_ptr();
1005 assert_eq!(
1006 ::std::mem::size_of::<Camera2D>(),
1007 24usize,
1008 concat!("Size of: ", stringify!(Camera2D))
1009 );
1010 assert_eq!(
1011 ::std::mem::align_of::<Camera2D>(),
1012 4usize,
1013 concat!("Alignment of ", stringify!(Camera2D))
1014 );
1015 assert_eq!(
1016 unsafe { ::std::ptr::addr_of!((*ptr).offset) as usize - ptr as usize },
1017 0usize,
1018 concat!(
1019 "Offset of field: ",
1020 stringify!(Camera2D),
1021 "::",
1022 stringify!(offset)
1023 )
1024 );
1025 assert_eq!(
1026 unsafe { ::std::ptr::addr_of!((*ptr).target) as usize - ptr as usize },
1027 8usize,
1028 concat!(
1029 "Offset of field: ",
1030 stringify!(Camera2D),
1031 "::",
1032 stringify!(target)
1033 )
1034 );
1035 assert_eq!(
1036 unsafe { ::std::ptr::addr_of!((*ptr).rotation) as usize - ptr as usize },
1037 16usize,
1038 concat!(
1039 "Offset of field: ",
1040 stringify!(Camera2D),
1041 "::",
1042 stringify!(rotation)
1043 )
1044 );
1045 assert_eq!(
1046 unsafe { ::std::ptr::addr_of!((*ptr).zoom) as usize - ptr as usize },
1047 20usize,
1048 concat!(
1049 "Offset of field: ",
1050 stringify!(Camera2D),
1051 "::",
1052 stringify!(zoom)
1053 )
1054 );
1055}
1056#[repr(C)]
1057#[derive(Debug, Copy, Clone)]
1058pub struct Mesh {
1059 pub vertexCount: ::std::os::raw::c_int,
1060 pub triangleCount: ::std::os::raw::c_int,
1061 pub vertices: *mut f32,
1062 pub texcoords: *mut f32,
1063 pub texcoords2: *mut f32,
1064 pub normals: *mut f32,
1065 pub tangents: *mut f32,
1066 pub colors: *mut ::std::os::raw::c_uchar,
1067 pub indices: *mut ::std::os::raw::c_ushort,
1068 pub animVertices: *mut f32,
1069 pub animNormals: *mut f32,
1070 pub boneIds: *mut ::std::os::raw::c_uchar,
1071 pub boneWeights: *mut f32,
1072 pub boneMatrices: *mut Matrix,
1073 pub boneCount: ::std::os::raw::c_int,
1074 pub vaoId: ::std::os::raw::c_uint,
1075 pub vboId: *mut ::std::os::raw::c_uint,
1076}
1077#[test]
1078fn bindgen_test_layout_Mesh() {
1079 const UNINIT: ::std::mem::MaybeUninit<Mesh> = ::std::mem::MaybeUninit::uninit();
1080 let ptr = UNINIT.as_ptr();
1081 assert_eq!(
1082 ::std::mem::size_of::<Mesh>(),
1083 120usize,
1084 concat!("Size of: ", stringify!(Mesh))
1085 );
1086 assert_eq!(
1087 ::std::mem::align_of::<Mesh>(),
1088 8usize,
1089 concat!("Alignment of ", stringify!(Mesh))
1090 );
1091 assert_eq!(
1092 unsafe { ::std::ptr::addr_of!((*ptr).vertexCount) as usize - ptr as usize },
1093 0usize,
1094 concat!(
1095 "Offset of field: ",
1096 stringify!(Mesh),
1097 "::",
1098 stringify!(vertexCount)
1099 )
1100 );
1101 assert_eq!(
1102 unsafe { ::std::ptr::addr_of!((*ptr).triangleCount) as usize - ptr as usize },
1103 4usize,
1104 concat!(
1105 "Offset of field: ",
1106 stringify!(Mesh),
1107 "::",
1108 stringify!(triangleCount)
1109 )
1110 );
1111 assert_eq!(
1112 unsafe { ::std::ptr::addr_of!((*ptr).vertices) as usize - ptr as usize },
1113 8usize,
1114 concat!(
1115 "Offset of field: ",
1116 stringify!(Mesh),
1117 "::",
1118 stringify!(vertices)
1119 )
1120 );
1121 assert_eq!(
1122 unsafe { ::std::ptr::addr_of!((*ptr).texcoords) as usize - ptr as usize },
1123 16usize,
1124 concat!(
1125 "Offset of field: ",
1126 stringify!(Mesh),
1127 "::",
1128 stringify!(texcoords)
1129 )
1130 );
1131 assert_eq!(
1132 unsafe { ::std::ptr::addr_of!((*ptr).texcoords2) as usize - ptr as usize },
1133 24usize,
1134 concat!(
1135 "Offset of field: ",
1136 stringify!(Mesh),
1137 "::",
1138 stringify!(texcoords2)
1139 )
1140 );
1141 assert_eq!(
1142 unsafe { ::std::ptr::addr_of!((*ptr).normals) as usize - ptr as usize },
1143 32usize,
1144 concat!(
1145 "Offset of field: ",
1146 stringify!(Mesh),
1147 "::",
1148 stringify!(normals)
1149 )
1150 );
1151 assert_eq!(
1152 unsafe { ::std::ptr::addr_of!((*ptr).tangents) as usize - ptr as usize },
1153 40usize,
1154 concat!(
1155 "Offset of field: ",
1156 stringify!(Mesh),
1157 "::",
1158 stringify!(tangents)
1159 )
1160 );
1161 assert_eq!(
1162 unsafe { ::std::ptr::addr_of!((*ptr).colors) as usize - ptr as usize },
1163 48usize,
1164 concat!(
1165 "Offset of field: ",
1166 stringify!(Mesh),
1167 "::",
1168 stringify!(colors)
1169 )
1170 );
1171 assert_eq!(
1172 unsafe { ::std::ptr::addr_of!((*ptr).indices) as usize - ptr as usize },
1173 56usize,
1174 concat!(
1175 "Offset of field: ",
1176 stringify!(Mesh),
1177 "::",
1178 stringify!(indices)
1179 )
1180 );
1181 assert_eq!(
1182 unsafe { ::std::ptr::addr_of!((*ptr).animVertices) as usize - ptr as usize },
1183 64usize,
1184 concat!(
1185 "Offset of field: ",
1186 stringify!(Mesh),
1187 "::",
1188 stringify!(animVertices)
1189 )
1190 );
1191 assert_eq!(
1192 unsafe { ::std::ptr::addr_of!((*ptr).animNormals) as usize - ptr as usize },
1193 72usize,
1194 concat!(
1195 "Offset of field: ",
1196 stringify!(Mesh),
1197 "::",
1198 stringify!(animNormals)
1199 )
1200 );
1201 assert_eq!(
1202 unsafe { ::std::ptr::addr_of!((*ptr).boneIds) as usize - ptr as usize },
1203 80usize,
1204 concat!(
1205 "Offset of field: ",
1206 stringify!(Mesh),
1207 "::",
1208 stringify!(boneIds)
1209 )
1210 );
1211 assert_eq!(
1212 unsafe { ::std::ptr::addr_of!((*ptr).boneWeights) as usize - ptr as usize },
1213 88usize,
1214 concat!(
1215 "Offset of field: ",
1216 stringify!(Mesh),
1217 "::",
1218 stringify!(boneWeights)
1219 )
1220 );
1221 assert_eq!(
1222 unsafe { ::std::ptr::addr_of!((*ptr).boneMatrices) as usize - ptr as usize },
1223 96usize,
1224 concat!(
1225 "Offset of field: ",
1226 stringify!(Mesh),
1227 "::",
1228 stringify!(boneMatrices)
1229 )
1230 );
1231 assert_eq!(
1232 unsafe { ::std::ptr::addr_of!((*ptr).boneCount) as usize - ptr as usize },
1233 104usize,
1234 concat!(
1235 "Offset of field: ",
1236 stringify!(Mesh),
1237 "::",
1238 stringify!(boneCount)
1239 )
1240 );
1241 assert_eq!(
1242 unsafe { ::std::ptr::addr_of!((*ptr).vaoId) as usize - ptr as usize },
1243 108usize,
1244 concat!(
1245 "Offset of field: ",
1246 stringify!(Mesh),
1247 "::",
1248 stringify!(vaoId)
1249 )
1250 );
1251 assert_eq!(
1252 unsafe { ::std::ptr::addr_of!((*ptr).vboId) as usize - ptr as usize },
1253 112usize,
1254 concat!(
1255 "Offset of field: ",
1256 stringify!(Mesh),
1257 "::",
1258 stringify!(vboId)
1259 )
1260 );
1261}
1262#[repr(C)]
1263#[derive(Debug, Copy, Clone)]
1264pub struct Shader {
1265 pub id: ::std::os::raw::c_uint,
1266 pub locs: *mut ::std::os::raw::c_int,
1267}
1268#[test]
1269fn bindgen_test_layout_Shader() {
1270 const UNINIT: ::std::mem::MaybeUninit<Shader> = ::std::mem::MaybeUninit::uninit();
1271 let ptr = UNINIT.as_ptr();
1272 assert_eq!(
1273 ::std::mem::size_of::<Shader>(),
1274 16usize,
1275 concat!("Size of: ", stringify!(Shader))
1276 );
1277 assert_eq!(
1278 ::std::mem::align_of::<Shader>(),
1279 8usize,
1280 concat!("Alignment of ", stringify!(Shader))
1281 );
1282 assert_eq!(
1283 unsafe { ::std::ptr::addr_of!((*ptr).id) as usize - ptr as usize },
1284 0usize,
1285 concat!(
1286 "Offset of field: ",
1287 stringify!(Shader),
1288 "::",
1289 stringify!(id)
1290 )
1291 );
1292 assert_eq!(
1293 unsafe { ::std::ptr::addr_of!((*ptr).locs) as usize - ptr as usize },
1294 8usize,
1295 concat!(
1296 "Offset of field: ",
1297 stringify!(Shader),
1298 "::",
1299 stringify!(locs)
1300 )
1301 );
1302}
1303#[repr(C)]
1304#[derive(Debug, Copy, Clone)]
1305pub struct MaterialMap {
1306 pub texture: Texture2D,
1307 pub color: Color,
1308 pub value: f32,
1309}
1310#[test]
1311fn bindgen_test_layout_MaterialMap() {
1312 const UNINIT: ::std::mem::MaybeUninit<MaterialMap> = ::std::mem::MaybeUninit::uninit();
1313 let ptr = UNINIT.as_ptr();
1314 assert_eq!(
1315 ::std::mem::size_of::<MaterialMap>(),
1316 28usize,
1317 concat!("Size of: ", stringify!(MaterialMap))
1318 );
1319 assert_eq!(
1320 ::std::mem::align_of::<MaterialMap>(),
1321 4usize,
1322 concat!("Alignment of ", stringify!(MaterialMap))
1323 );
1324 assert_eq!(
1325 unsafe { ::std::ptr::addr_of!((*ptr).texture) as usize - ptr as usize },
1326 0usize,
1327 concat!(
1328 "Offset of field: ",
1329 stringify!(MaterialMap),
1330 "::",
1331 stringify!(texture)
1332 )
1333 );
1334 assert_eq!(
1335 unsafe { ::std::ptr::addr_of!((*ptr).color) as usize - ptr as usize },
1336 20usize,
1337 concat!(
1338 "Offset of field: ",
1339 stringify!(MaterialMap),
1340 "::",
1341 stringify!(color)
1342 )
1343 );
1344 assert_eq!(
1345 unsafe { ::std::ptr::addr_of!((*ptr).value) as usize - ptr as usize },
1346 24usize,
1347 concat!(
1348 "Offset of field: ",
1349 stringify!(MaterialMap),
1350 "::",
1351 stringify!(value)
1352 )
1353 );
1354}
1355#[repr(C)]
1356#[derive(Debug, Copy, Clone)]
1357pub struct Material {
1358 pub shader: Shader,
1359 pub maps: *mut MaterialMap,
1360 pub params: [f32; 4usize],
1361}
1362#[test]
1363fn bindgen_test_layout_Material() {
1364 const UNINIT: ::std::mem::MaybeUninit<Material> = ::std::mem::MaybeUninit::uninit();
1365 let ptr = UNINIT.as_ptr();
1366 assert_eq!(
1367 ::std::mem::size_of::<Material>(),
1368 40usize,
1369 concat!("Size of: ", stringify!(Material))
1370 );
1371 assert_eq!(
1372 ::std::mem::align_of::<Material>(),
1373 8usize,
1374 concat!("Alignment of ", stringify!(Material))
1375 );
1376 assert_eq!(
1377 unsafe { ::std::ptr::addr_of!((*ptr).shader) as usize - ptr as usize },
1378 0usize,
1379 concat!(
1380 "Offset of field: ",
1381 stringify!(Material),
1382 "::",
1383 stringify!(shader)
1384 )
1385 );
1386 assert_eq!(
1387 unsafe { ::std::ptr::addr_of!((*ptr).maps) as usize - ptr as usize },
1388 16usize,
1389 concat!(
1390 "Offset of field: ",
1391 stringify!(Material),
1392 "::",
1393 stringify!(maps)
1394 )
1395 );
1396 assert_eq!(
1397 unsafe { ::std::ptr::addr_of!((*ptr).params) as usize - ptr as usize },
1398 24usize,
1399 concat!(
1400 "Offset of field: ",
1401 stringify!(Material),
1402 "::",
1403 stringify!(params)
1404 )
1405 );
1406}
1407#[repr(C)]
1408#[derive(Debug, Copy, Clone)]
1409pub struct Transform {
1410 pub translation: Vector3,
1411 pub rotation: Quaternion,
1412 pub scale: Vector3,
1413}
1414#[test]
1415fn bindgen_test_layout_Transform() {
1416 const UNINIT: ::std::mem::MaybeUninit<Transform> = ::std::mem::MaybeUninit::uninit();
1417 let ptr = UNINIT.as_ptr();
1418 assert_eq!(
1419 ::std::mem::size_of::<Transform>(),
1420 40usize,
1421 concat!("Size of: ", stringify!(Transform))
1422 );
1423 assert_eq!(
1424 ::std::mem::align_of::<Transform>(),
1425 4usize,
1426 concat!("Alignment of ", stringify!(Transform))
1427 );
1428 assert_eq!(
1429 unsafe { ::std::ptr::addr_of!((*ptr).translation) as usize - ptr as usize },
1430 0usize,
1431 concat!(
1432 "Offset of field: ",
1433 stringify!(Transform),
1434 "::",
1435 stringify!(translation)
1436 )
1437 );
1438 assert_eq!(
1439 unsafe { ::std::ptr::addr_of!((*ptr).rotation) as usize - ptr as usize },
1440 12usize,
1441 concat!(
1442 "Offset of field: ",
1443 stringify!(Transform),
1444 "::",
1445 stringify!(rotation)
1446 )
1447 );
1448 assert_eq!(
1449 unsafe { ::std::ptr::addr_of!((*ptr).scale) as usize - ptr as usize },
1450 28usize,
1451 concat!(
1452 "Offset of field: ",
1453 stringify!(Transform),
1454 "::",
1455 stringify!(scale)
1456 )
1457 );
1458}
1459#[repr(C)]
1460#[derive(Debug, Copy, Clone)]
1461pub struct BoneInfo {
1462 pub name: [::std::os::raw::c_char; 32usize],
1463 pub parent: ::std::os::raw::c_int,
1464}
1465#[test]
1466fn bindgen_test_layout_BoneInfo() {
1467 const UNINIT: ::std::mem::MaybeUninit<BoneInfo> = ::std::mem::MaybeUninit::uninit();
1468 let ptr = UNINIT.as_ptr();
1469 assert_eq!(
1470 ::std::mem::size_of::<BoneInfo>(),
1471 36usize,
1472 concat!("Size of: ", stringify!(BoneInfo))
1473 );
1474 assert_eq!(
1475 ::std::mem::align_of::<BoneInfo>(),
1476 4usize,
1477 concat!("Alignment of ", stringify!(BoneInfo))
1478 );
1479 assert_eq!(
1480 unsafe { ::std::ptr::addr_of!((*ptr).name) as usize - ptr as usize },
1481 0usize,
1482 concat!(
1483 "Offset of field: ",
1484 stringify!(BoneInfo),
1485 "::",
1486 stringify!(name)
1487 )
1488 );
1489 assert_eq!(
1490 unsafe { ::std::ptr::addr_of!((*ptr).parent) as usize - ptr as usize },
1491 32usize,
1492 concat!(
1493 "Offset of field: ",
1494 stringify!(BoneInfo),
1495 "::",
1496 stringify!(parent)
1497 )
1498 );
1499}
1500#[repr(C)]
1501#[derive(Debug, Copy, Clone)]
1502pub struct Model {
1503 pub transform: Matrix,
1504 pub meshCount: ::std::os::raw::c_int,
1505 pub materialCount: ::std::os::raw::c_int,
1506 pub meshes: *mut Mesh,
1507 pub materials: *mut Material,
1508 pub meshMaterial: *mut ::std::os::raw::c_int,
1509 pub boneCount: ::std::os::raw::c_int,
1510 pub bones: *mut BoneInfo,
1511 pub bindPose: *mut Transform,
1512}
1513#[test]
1514fn bindgen_test_layout_Model() {
1515 const UNINIT: ::std::mem::MaybeUninit<Model> = ::std::mem::MaybeUninit::uninit();
1516 let ptr = UNINIT.as_ptr();
1517 assert_eq!(
1518 ::std::mem::size_of::<Model>(),
1519 120usize,
1520 concat!("Size of: ", stringify!(Model))
1521 );
1522 assert_eq!(
1523 ::std::mem::align_of::<Model>(),
1524 8usize,
1525 concat!("Alignment of ", stringify!(Model))
1526 );
1527 assert_eq!(
1528 unsafe { ::std::ptr::addr_of!((*ptr).transform) as usize - ptr as usize },
1529 0usize,
1530 concat!(
1531 "Offset of field: ",
1532 stringify!(Model),
1533 "::",
1534 stringify!(transform)
1535 )
1536 );
1537 assert_eq!(
1538 unsafe { ::std::ptr::addr_of!((*ptr).meshCount) as usize - ptr as usize },
1539 64usize,
1540 concat!(
1541 "Offset of field: ",
1542 stringify!(Model),
1543 "::",
1544 stringify!(meshCount)
1545 )
1546 );
1547 assert_eq!(
1548 unsafe { ::std::ptr::addr_of!((*ptr).materialCount) as usize - ptr as usize },
1549 68usize,
1550 concat!(
1551 "Offset of field: ",
1552 stringify!(Model),
1553 "::",
1554 stringify!(materialCount)
1555 )
1556 );
1557 assert_eq!(
1558 unsafe { ::std::ptr::addr_of!((*ptr).meshes) as usize - ptr as usize },
1559 72usize,
1560 concat!(
1561 "Offset of field: ",
1562 stringify!(Model),
1563 "::",
1564 stringify!(meshes)
1565 )
1566 );
1567 assert_eq!(
1568 unsafe { ::std::ptr::addr_of!((*ptr).materials) as usize - ptr as usize },
1569 80usize,
1570 concat!(
1571 "Offset of field: ",
1572 stringify!(Model),
1573 "::",
1574 stringify!(materials)
1575 )
1576 );
1577 assert_eq!(
1578 unsafe { ::std::ptr::addr_of!((*ptr).meshMaterial) as usize - ptr as usize },
1579 88usize,
1580 concat!(
1581 "Offset of field: ",
1582 stringify!(Model),
1583 "::",
1584 stringify!(meshMaterial)
1585 )
1586 );
1587 assert_eq!(
1588 unsafe { ::std::ptr::addr_of!((*ptr).boneCount) as usize - ptr as usize },
1589 96usize,
1590 concat!(
1591 "Offset of field: ",
1592 stringify!(Model),
1593 "::",
1594 stringify!(boneCount)
1595 )
1596 );
1597 assert_eq!(
1598 unsafe { ::std::ptr::addr_of!((*ptr).bones) as usize - ptr as usize },
1599 104usize,
1600 concat!(
1601 "Offset of field: ",
1602 stringify!(Model),
1603 "::",
1604 stringify!(bones)
1605 )
1606 );
1607 assert_eq!(
1608 unsafe { ::std::ptr::addr_of!((*ptr).bindPose) as usize - ptr as usize },
1609 112usize,
1610 concat!(
1611 "Offset of field: ",
1612 stringify!(Model),
1613 "::",
1614 stringify!(bindPose)
1615 )
1616 );
1617}
1618#[repr(C)]
1619#[derive(Debug, Copy, Clone)]
1620pub struct ModelAnimation {
1621 pub boneCount: ::std::os::raw::c_int,
1622 pub frameCount: ::std::os::raw::c_int,
1623 pub bones: *mut BoneInfo,
1624 pub framePoses: *mut *mut Transform,
1625 pub name: [::std::os::raw::c_char; 32usize],
1626}
1627#[test]
1628fn bindgen_test_layout_ModelAnimation() {
1629 const UNINIT: ::std::mem::MaybeUninit<ModelAnimation> = ::std::mem::MaybeUninit::uninit();
1630 let ptr = UNINIT.as_ptr();
1631 assert_eq!(
1632 ::std::mem::size_of::<ModelAnimation>(),
1633 56usize,
1634 concat!("Size of: ", stringify!(ModelAnimation))
1635 );
1636 assert_eq!(
1637 ::std::mem::align_of::<ModelAnimation>(),
1638 8usize,
1639 concat!("Alignment of ", stringify!(ModelAnimation))
1640 );
1641 assert_eq!(
1642 unsafe { ::std::ptr::addr_of!((*ptr).boneCount) as usize - ptr as usize },
1643 0usize,
1644 concat!(
1645 "Offset of field: ",
1646 stringify!(ModelAnimation),
1647 "::",
1648 stringify!(boneCount)
1649 )
1650 );
1651 assert_eq!(
1652 unsafe { ::std::ptr::addr_of!((*ptr).frameCount) as usize - ptr as usize },
1653 4usize,
1654 concat!(
1655 "Offset of field: ",
1656 stringify!(ModelAnimation),
1657 "::",
1658 stringify!(frameCount)
1659 )
1660 );
1661 assert_eq!(
1662 unsafe { ::std::ptr::addr_of!((*ptr).bones) as usize - ptr as usize },
1663 8usize,
1664 concat!(
1665 "Offset of field: ",
1666 stringify!(ModelAnimation),
1667 "::",
1668 stringify!(bones)
1669 )
1670 );
1671 assert_eq!(
1672 unsafe { ::std::ptr::addr_of!((*ptr).framePoses) as usize - ptr as usize },
1673 16usize,
1674 concat!(
1675 "Offset of field: ",
1676 stringify!(ModelAnimation),
1677 "::",
1678 stringify!(framePoses)
1679 )
1680 );
1681 assert_eq!(
1682 unsafe { ::std::ptr::addr_of!((*ptr).name) as usize - ptr as usize },
1683 24usize,
1684 concat!(
1685 "Offset of field: ",
1686 stringify!(ModelAnimation),
1687 "::",
1688 stringify!(name)
1689 )
1690 );
1691}
1692#[repr(C)]
1693#[derive(Debug, Copy, Clone)]
1694pub struct Ray {
1695 pub position: Vector3,
1696 pub direction: Vector3,
1697}
1698#[test]
1699fn bindgen_test_layout_Ray() {
1700 const UNINIT: ::std::mem::MaybeUninit<Ray> = ::std::mem::MaybeUninit::uninit();
1701 let ptr = UNINIT.as_ptr();
1702 assert_eq!(
1703 ::std::mem::size_of::<Ray>(),
1704 24usize,
1705 concat!("Size of: ", stringify!(Ray))
1706 );
1707 assert_eq!(
1708 ::std::mem::align_of::<Ray>(),
1709 4usize,
1710 concat!("Alignment of ", stringify!(Ray))
1711 );
1712 assert_eq!(
1713 unsafe { ::std::ptr::addr_of!((*ptr).position) as usize - ptr as usize },
1714 0usize,
1715 concat!(
1716 "Offset of field: ",
1717 stringify!(Ray),
1718 "::",
1719 stringify!(position)
1720 )
1721 );
1722 assert_eq!(
1723 unsafe { ::std::ptr::addr_of!((*ptr).direction) as usize - ptr as usize },
1724 12usize,
1725 concat!(
1726 "Offset of field: ",
1727 stringify!(Ray),
1728 "::",
1729 stringify!(direction)
1730 )
1731 );
1732}
1733#[repr(C)]
1734#[derive(Debug, Copy, Clone)]
1735pub struct RayCollision {
1736 pub hit: bool,
1737 pub distance: f32,
1738 pub point: Vector3,
1739 pub normal: Vector3,
1740}
1741#[test]
1742fn bindgen_test_layout_RayCollision() {
1743 const UNINIT: ::std::mem::MaybeUninit<RayCollision> = ::std::mem::MaybeUninit::uninit();
1744 let ptr = UNINIT.as_ptr();
1745 assert_eq!(
1746 ::std::mem::size_of::<RayCollision>(),
1747 32usize,
1748 concat!("Size of: ", stringify!(RayCollision))
1749 );
1750 assert_eq!(
1751 ::std::mem::align_of::<RayCollision>(),
1752 4usize,
1753 concat!("Alignment of ", stringify!(RayCollision))
1754 );
1755 assert_eq!(
1756 unsafe { ::std::ptr::addr_of!((*ptr).hit) as usize - ptr as usize },
1757 0usize,
1758 concat!(
1759 "Offset of field: ",
1760 stringify!(RayCollision),
1761 "::",
1762 stringify!(hit)
1763 )
1764 );
1765 assert_eq!(
1766 unsafe { ::std::ptr::addr_of!((*ptr).distance) as usize - ptr as usize },
1767 4usize,
1768 concat!(
1769 "Offset of field: ",
1770 stringify!(RayCollision),
1771 "::",
1772 stringify!(distance)
1773 )
1774 );
1775 assert_eq!(
1776 unsafe { ::std::ptr::addr_of!((*ptr).point) as usize - ptr as usize },
1777 8usize,
1778 concat!(
1779 "Offset of field: ",
1780 stringify!(RayCollision),
1781 "::",
1782 stringify!(point)
1783 )
1784 );
1785 assert_eq!(
1786 unsafe { ::std::ptr::addr_of!((*ptr).normal) as usize - ptr as usize },
1787 20usize,
1788 concat!(
1789 "Offset of field: ",
1790 stringify!(RayCollision),
1791 "::",
1792 stringify!(normal)
1793 )
1794 );
1795}
1796#[repr(C)]
1797#[derive(Debug, Copy, Clone)]
1798pub struct BoundingBox {
1799 pub min: Vector3,
1800 pub max: Vector3,
1801}
1802#[test]
1803fn bindgen_test_layout_BoundingBox() {
1804 const UNINIT: ::std::mem::MaybeUninit<BoundingBox> = ::std::mem::MaybeUninit::uninit();
1805 let ptr = UNINIT.as_ptr();
1806 assert_eq!(
1807 ::std::mem::size_of::<BoundingBox>(),
1808 24usize,
1809 concat!("Size of: ", stringify!(BoundingBox))
1810 );
1811 assert_eq!(
1812 ::std::mem::align_of::<BoundingBox>(),
1813 4usize,
1814 concat!("Alignment of ", stringify!(BoundingBox))
1815 );
1816 assert_eq!(
1817 unsafe { ::std::ptr::addr_of!((*ptr).min) as usize - ptr as usize },
1818 0usize,
1819 concat!(
1820 "Offset of field: ",
1821 stringify!(BoundingBox),
1822 "::",
1823 stringify!(min)
1824 )
1825 );
1826 assert_eq!(
1827 unsafe { ::std::ptr::addr_of!((*ptr).max) as usize - ptr as usize },
1828 12usize,
1829 concat!(
1830 "Offset of field: ",
1831 stringify!(BoundingBox),
1832 "::",
1833 stringify!(max)
1834 )
1835 );
1836}
1837#[repr(C)]
1838#[derive(Debug, Copy, Clone)]
1839pub struct Wave {
1840 pub frameCount: ::std::os::raw::c_uint,
1841 pub sampleRate: ::std::os::raw::c_uint,
1842 pub sampleSize: ::std::os::raw::c_uint,
1843 pub channels: ::std::os::raw::c_uint,
1844 pub data: *mut ::std::os::raw::c_void,
1845}
1846#[test]
1847fn bindgen_test_layout_Wave() {
1848 const UNINIT: ::std::mem::MaybeUninit<Wave> = ::std::mem::MaybeUninit::uninit();
1849 let ptr = UNINIT.as_ptr();
1850 assert_eq!(
1851 ::std::mem::size_of::<Wave>(),
1852 24usize,
1853 concat!("Size of: ", stringify!(Wave))
1854 );
1855 assert_eq!(
1856 ::std::mem::align_of::<Wave>(),
1857 8usize,
1858 concat!("Alignment of ", stringify!(Wave))
1859 );
1860 assert_eq!(
1861 unsafe { ::std::ptr::addr_of!((*ptr).frameCount) as usize - ptr as usize },
1862 0usize,
1863 concat!(
1864 "Offset of field: ",
1865 stringify!(Wave),
1866 "::",
1867 stringify!(frameCount)
1868 )
1869 );
1870 assert_eq!(
1871 unsafe { ::std::ptr::addr_of!((*ptr).sampleRate) as usize - ptr as usize },
1872 4usize,
1873 concat!(
1874 "Offset of field: ",
1875 stringify!(Wave),
1876 "::",
1877 stringify!(sampleRate)
1878 )
1879 );
1880 assert_eq!(
1881 unsafe { ::std::ptr::addr_of!((*ptr).sampleSize) as usize - ptr as usize },
1882 8usize,
1883 concat!(
1884 "Offset of field: ",
1885 stringify!(Wave),
1886 "::",
1887 stringify!(sampleSize)
1888 )
1889 );
1890 assert_eq!(
1891 unsafe { ::std::ptr::addr_of!((*ptr).channels) as usize - ptr as usize },
1892 12usize,
1893 concat!(
1894 "Offset of field: ",
1895 stringify!(Wave),
1896 "::",
1897 stringify!(channels)
1898 )
1899 );
1900 assert_eq!(
1901 unsafe { ::std::ptr::addr_of!((*ptr).data) as usize - ptr as usize },
1902 16usize,
1903 concat!(
1904 "Offset of field: ",
1905 stringify!(Wave),
1906 "::",
1907 stringify!(data)
1908 )
1909 );
1910}
1911#[repr(C)]
1912#[derive(Debug, Copy, Clone)]
1913pub struct rAudioBuffer {
1914 _unused: [u8; 0],
1915}
1916#[repr(C)]
1917#[derive(Debug, Copy, Clone)]
1918pub struct rAudioProcessor {
1919 _unused: [u8; 0],
1920}
1921#[repr(C)]
1922#[derive(Debug, Copy, Clone)]
1923pub struct AudioStream {
1924 pub buffer: *mut rAudioBuffer,
1925 pub processor: *mut rAudioProcessor,
1926 pub sampleRate: ::std::os::raw::c_uint,
1927 pub sampleSize: ::std::os::raw::c_uint,
1928 pub channels: ::std::os::raw::c_uint,
1929}
1930#[test]
1931fn bindgen_test_layout_AudioStream() {
1932 const UNINIT: ::std::mem::MaybeUninit<AudioStream> = ::std::mem::MaybeUninit::uninit();
1933 let ptr = UNINIT.as_ptr();
1934 assert_eq!(
1935 ::std::mem::size_of::<AudioStream>(),
1936 32usize,
1937 concat!("Size of: ", stringify!(AudioStream))
1938 );
1939 assert_eq!(
1940 ::std::mem::align_of::<AudioStream>(),
1941 8usize,
1942 concat!("Alignment of ", stringify!(AudioStream))
1943 );
1944 assert_eq!(
1945 unsafe { ::std::ptr::addr_of!((*ptr).buffer) as usize - ptr as usize },
1946 0usize,
1947 concat!(
1948 "Offset of field: ",
1949 stringify!(AudioStream),
1950 "::",
1951 stringify!(buffer)
1952 )
1953 );
1954 assert_eq!(
1955 unsafe { ::std::ptr::addr_of!((*ptr).processor) as usize - ptr as usize },
1956 8usize,
1957 concat!(
1958 "Offset of field: ",
1959 stringify!(AudioStream),
1960 "::",
1961 stringify!(processor)
1962 )
1963 );
1964 assert_eq!(
1965 unsafe { ::std::ptr::addr_of!((*ptr).sampleRate) as usize - ptr as usize },
1966 16usize,
1967 concat!(
1968 "Offset of field: ",
1969 stringify!(AudioStream),
1970 "::",
1971 stringify!(sampleRate)
1972 )
1973 );
1974 assert_eq!(
1975 unsafe { ::std::ptr::addr_of!((*ptr).sampleSize) as usize - ptr as usize },
1976 20usize,
1977 concat!(
1978 "Offset of field: ",
1979 stringify!(AudioStream),
1980 "::",
1981 stringify!(sampleSize)
1982 )
1983 );
1984 assert_eq!(
1985 unsafe { ::std::ptr::addr_of!((*ptr).channels) as usize - ptr as usize },
1986 24usize,
1987 concat!(
1988 "Offset of field: ",
1989 stringify!(AudioStream),
1990 "::",
1991 stringify!(channels)
1992 )
1993 );
1994}
1995#[repr(C)]
1996#[derive(Debug, Copy, Clone)]
1997pub struct Sound {
1998 pub stream: AudioStream,
1999 pub frameCount: ::std::os::raw::c_uint,
2000}
2001#[test]
2002fn bindgen_test_layout_Sound() {
2003 const UNINIT: ::std::mem::MaybeUninit<Sound> = ::std::mem::MaybeUninit::uninit();
2004 let ptr = UNINIT.as_ptr();
2005 assert_eq!(
2006 ::std::mem::size_of::<Sound>(),
2007 40usize,
2008 concat!("Size of: ", stringify!(Sound))
2009 );
2010 assert_eq!(
2011 ::std::mem::align_of::<Sound>(),
2012 8usize,
2013 concat!("Alignment of ", stringify!(Sound))
2014 );
2015 assert_eq!(
2016 unsafe { ::std::ptr::addr_of!((*ptr).stream) as usize - ptr as usize },
2017 0usize,
2018 concat!(
2019 "Offset of field: ",
2020 stringify!(Sound),
2021 "::",
2022 stringify!(stream)
2023 )
2024 );
2025 assert_eq!(
2026 unsafe { ::std::ptr::addr_of!((*ptr).frameCount) as usize - ptr as usize },
2027 32usize,
2028 concat!(
2029 "Offset of field: ",
2030 stringify!(Sound),
2031 "::",
2032 stringify!(frameCount)
2033 )
2034 );
2035}
2036#[repr(C)]
2037#[derive(Debug, Copy, Clone)]
2038pub struct Music {
2039 pub stream: AudioStream,
2040 pub frameCount: ::std::os::raw::c_uint,
2041 pub looping: bool,
2042 pub ctxType: ::std::os::raw::c_int,
2043 pub ctxData: *mut ::std::os::raw::c_void,
2044}
2045#[test]
2046fn bindgen_test_layout_Music() {
2047 const UNINIT: ::std::mem::MaybeUninit<Music> = ::std::mem::MaybeUninit::uninit();
2048 let ptr = UNINIT.as_ptr();
2049 assert_eq!(
2050 ::std::mem::size_of::<Music>(),
2051 56usize,
2052 concat!("Size of: ", stringify!(Music))
2053 );
2054 assert_eq!(
2055 ::std::mem::align_of::<Music>(),
2056 8usize,
2057 concat!("Alignment of ", stringify!(Music))
2058 );
2059 assert_eq!(
2060 unsafe { ::std::ptr::addr_of!((*ptr).stream) as usize - ptr as usize },
2061 0usize,
2062 concat!(
2063 "Offset of field: ",
2064 stringify!(Music),
2065 "::",
2066 stringify!(stream)
2067 )
2068 );
2069 assert_eq!(
2070 unsafe { ::std::ptr::addr_of!((*ptr).frameCount) as usize - ptr as usize },
2071 32usize,
2072 concat!(
2073 "Offset of field: ",
2074 stringify!(Music),
2075 "::",
2076 stringify!(frameCount)
2077 )
2078 );
2079 assert_eq!(
2080 unsafe { ::std::ptr::addr_of!((*ptr).looping) as usize - ptr as usize },
2081 36usize,
2082 concat!(
2083 "Offset of field: ",
2084 stringify!(Music),
2085 "::",
2086 stringify!(looping)
2087 )
2088 );
2089 assert_eq!(
2090 unsafe { ::std::ptr::addr_of!((*ptr).ctxType) as usize - ptr as usize },
2091 40usize,
2092 concat!(
2093 "Offset of field: ",
2094 stringify!(Music),
2095 "::",
2096 stringify!(ctxType)
2097 )
2098 );
2099 assert_eq!(
2100 unsafe { ::std::ptr::addr_of!((*ptr).ctxData) as usize - ptr as usize },
2101 48usize,
2102 concat!(
2103 "Offset of field: ",
2104 stringify!(Music),
2105 "::",
2106 stringify!(ctxData)
2107 )
2108 );
2109}
2110#[repr(C)]
2111#[derive(Debug, Copy, Clone)]
2112pub struct VrDeviceInfo {
2113 pub hResolution: ::std::os::raw::c_int,
2114 pub vResolution: ::std::os::raw::c_int,
2115 pub hScreenSize: f32,
2116 pub vScreenSize: f32,
2117 pub eyeToScreenDistance: f32,
2118 pub lensSeparationDistance: f32,
2119 pub interpupillaryDistance: f32,
2120 pub lensDistortionValues: [f32; 4usize],
2121 pub chromaAbCorrection: [f32; 4usize],
2122}
2123#[test]
2124fn bindgen_test_layout_VrDeviceInfo() {
2125 const UNINIT: ::std::mem::MaybeUninit<VrDeviceInfo> = ::std::mem::MaybeUninit::uninit();
2126 let ptr = UNINIT.as_ptr();
2127 assert_eq!(
2128 ::std::mem::size_of::<VrDeviceInfo>(),
2129 60usize,
2130 concat!("Size of: ", stringify!(VrDeviceInfo))
2131 );
2132 assert_eq!(
2133 ::std::mem::align_of::<VrDeviceInfo>(),
2134 4usize,
2135 concat!("Alignment of ", stringify!(VrDeviceInfo))
2136 );
2137 assert_eq!(
2138 unsafe { ::std::ptr::addr_of!((*ptr).hResolution) as usize - ptr as usize },
2139 0usize,
2140 concat!(
2141 "Offset of field: ",
2142 stringify!(VrDeviceInfo),
2143 "::",
2144 stringify!(hResolution)
2145 )
2146 );
2147 assert_eq!(
2148 unsafe { ::std::ptr::addr_of!((*ptr).vResolution) as usize - ptr as usize },
2149 4usize,
2150 concat!(
2151 "Offset of field: ",
2152 stringify!(VrDeviceInfo),
2153 "::",
2154 stringify!(vResolution)
2155 )
2156 );
2157 assert_eq!(
2158 unsafe { ::std::ptr::addr_of!((*ptr).hScreenSize) as usize - ptr as usize },
2159 8usize,
2160 concat!(
2161 "Offset of field: ",
2162 stringify!(VrDeviceInfo),
2163 "::",
2164 stringify!(hScreenSize)
2165 )
2166 );
2167 assert_eq!(
2168 unsafe { ::std::ptr::addr_of!((*ptr).vScreenSize) as usize - ptr as usize },
2169 12usize,
2170 concat!(
2171 "Offset of field: ",
2172 stringify!(VrDeviceInfo),
2173 "::",
2174 stringify!(vScreenSize)
2175 )
2176 );
2177 assert_eq!(
2178 unsafe { ::std::ptr::addr_of!((*ptr).eyeToScreenDistance) as usize - ptr as usize },
2179 16usize,
2180 concat!(
2181 "Offset of field: ",
2182 stringify!(VrDeviceInfo),
2183 "::",
2184 stringify!(eyeToScreenDistance)
2185 )
2186 );
2187 assert_eq!(
2188 unsafe { ::std::ptr::addr_of!((*ptr).lensSeparationDistance) as usize - ptr as usize },
2189 20usize,
2190 concat!(
2191 "Offset of field: ",
2192 stringify!(VrDeviceInfo),
2193 "::",
2194 stringify!(lensSeparationDistance)
2195 )
2196 );
2197 assert_eq!(
2198 unsafe { ::std::ptr::addr_of!((*ptr).interpupillaryDistance) as usize - ptr as usize },
2199 24usize,
2200 concat!(
2201 "Offset of field: ",
2202 stringify!(VrDeviceInfo),
2203 "::",
2204 stringify!(interpupillaryDistance)
2205 )
2206 );
2207 assert_eq!(
2208 unsafe { ::std::ptr::addr_of!((*ptr).lensDistortionValues) as usize - ptr as usize },
2209 28usize,
2210 concat!(
2211 "Offset of field: ",
2212 stringify!(VrDeviceInfo),
2213 "::",
2214 stringify!(lensDistortionValues)
2215 )
2216 );
2217 assert_eq!(
2218 unsafe { ::std::ptr::addr_of!((*ptr).chromaAbCorrection) as usize - ptr as usize },
2219 44usize,
2220 concat!(
2221 "Offset of field: ",
2222 stringify!(VrDeviceInfo),
2223 "::",
2224 stringify!(chromaAbCorrection)
2225 )
2226 );
2227}
2228#[repr(C)]
2229#[derive(Debug, Copy, Clone)]
2230pub struct VrStereoConfig {
2231 pub projection: [Matrix; 2usize],
2232 pub viewOffset: [Matrix; 2usize],
2233 pub leftLensCenter: [f32; 2usize],
2234 pub rightLensCenter: [f32; 2usize],
2235 pub leftScreenCenter: [f32; 2usize],
2236 pub rightScreenCenter: [f32; 2usize],
2237 pub scale: [f32; 2usize],
2238 pub scaleIn: [f32; 2usize],
2239}
2240#[test]
2241fn bindgen_test_layout_VrStereoConfig() {
2242 const UNINIT: ::std::mem::MaybeUninit<VrStereoConfig> = ::std::mem::MaybeUninit::uninit();
2243 let ptr = UNINIT.as_ptr();
2244 assert_eq!(
2245 ::std::mem::size_of::<VrStereoConfig>(),
2246 304usize,
2247 concat!("Size of: ", stringify!(VrStereoConfig))
2248 );
2249 assert_eq!(
2250 ::std::mem::align_of::<VrStereoConfig>(),
2251 4usize,
2252 concat!("Alignment of ", stringify!(VrStereoConfig))
2253 );
2254 assert_eq!(
2255 unsafe { ::std::ptr::addr_of!((*ptr).projection) as usize - ptr as usize },
2256 0usize,
2257 concat!(
2258 "Offset of field: ",
2259 stringify!(VrStereoConfig),
2260 "::",
2261 stringify!(projection)
2262 )
2263 );
2264 assert_eq!(
2265 unsafe { ::std::ptr::addr_of!((*ptr).viewOffset) as usize - ptr as usize },
2266 128usize,
2267 concat!(
2268 "Offset of field: ",
2269 stringify!(VrStereoConfig),
2270 "::",
2271 stringify!(viewOffset)
2272 )
2273 );
2274 assert_eq!(
2275 unsafe { ::std::ptr::addr_of!((*ptr).leftLensCenter) as usize - ptr as usize },
2276 256usize,
2277 concat!(
2278 "Offset of field: ",
2279 stringify!(VrStereoConfig),
2280 "::",
2281 stringify!(leftLensCenter)
2282 )
2283 );
2284 assert_eq!(
2285 unsafe { ::std::ptr::addr_of!((*ptr).rightLensCenter) as usize - ptr as usize },
2286 264usize,
2287 concat!(
2288 "Offset of field: ",
2289 stringify!(VrStereoConfig),
2290 "::",
2291 stringify!(rightLensCenter)
2292 )
2293 );
2294 assert_eq!(
2295 unsafe { ::std::ptr::addr_of!((*ptr).leftScreenCenter) as usize - ptr as usize },
2296 272usize,
2297 concat!(
2298 "Offset of field: ",
2299 stringify!(VrStereoConfig),
2300 "::",
2301 stringify!(leftScreenCenter)
2302 )
2303 );
2304 assert_eq!(
2305 unsafe { ::std::ptr::addr_of!((*ptr).rightScreenCenter) as usize - ptr as usize },
2306 280usize,
2307 concat!(
2308 "Offset of field: ",
2309 stringify!(VrStereoConfig),
2310 "::",
2311 stringify!(rightScreenCenter)
2312 )
2313 );
2314 assert_eq!(
2315 unsafe { ::std::ptr::addr_of!((*ptr).scale) as usize - ptr as usize },
2316 288usize,
2317 concat!(
2318 "Offset of field: ",
2319 stringify!(VrStereoConfig),
2320 "::",
2321 stringify!(scale)
2322 )
2323 );
2324 assert_eq!(
2325 unsafe { ::std::ptr::addr_of!((*ptr).scaleIn) as usize - ptr as usize },
2326 296usize,
2327 concat!(
2328 "Offset of field: ",
2329 stringify!(VrStereoConfig),
2330 "::",
2331 stringify!(scaleIn)
2332 )
2333 );
2334}
2335#[repr(C)]
2336#[derive(Debug, Copy, Clone)]
2337pub struct FilePathList {
2338 pub capacity: ::std::os::raw::c_uint,
2339 pub count: ::std::os::raw::c_uint,
2340 pub paths: *mut *mut ::std::os::raw::c_char,
2341}
2342#[test]
2343fn bindgen_test_layout_FilePathList() {
2344 const UNINIT: ::std::mem::MaybeUninit<FilePathList> = ::std::mem::MaybeUninit::uninit();
2345 let ptr = UNINIT.as_ptr();
2346 assert_eq!(
2347 ::std::mem::size_of::<FilePathList>(),
2348 16usize,
2349 concat!("Size of: ", stringify!(FilePathList))
2350 );
2351 assert_eq!(
2352 ::std::mem::align_of::<FilePathList>(),
2353 8usize,
2354 concat!("Alignment of ", stringify!(FilePathList))
2355 );
2356 assert_eq!(
2357 unsafe { ::std::ptr::addr_of!((*ptr).capacity) as usize - ptr as usize },
2358 0usize,
2359 concat!(
2360 "Offset of field: ",
2361 stringify!(FilePathList),
2362 "::",
2363 stringify!(capacity)
2364 )
2365 );
2366 assert_eq!(
2367 unsafe { ::std::ptr::addr_of!((*ptr).count) as usize - ptr as usize },
2368 4usize,
2369 concat!(
2370 "Offset of field: ",
2371 stringify!(FilePathList),
2372 "::",
2373 stringify!(count)
2374 )
2375 );
2376 assert_eq!(
2377 unsafe { ::std::ptr::addr_of!((*ptr).paths) as usize - ptr as usize },
2378 8usize,
2379 concat!(
2380 "Offset of field: ",
2381 stringify!(FilePathList),
2382 "::",
2383 stringify!(paths)
2384 )
2385 );
2386}
2387#[repr(C)]
2388#[derive(Debug, Copy, Clone)]
2389pub struct AutomationEvent {
2390 pub frame: ::std::os::raw::c_uint,
2391 pub type_: ::std::os::raw::c_uint,
2392 pub params: [::std::os::raw::c_int; 4usize],
2393}
2394#[test]
2395fn bindgen_test_layout_AutomationEvent() {
2396 const UNINIT: ::std::mem::MaybeUninit<AutomationEvent> = ::std::mem::MaybeUninit::uninit();
2397 let ptr = UNINIT.as_ptr();
2398 assert_eq!(
2399 ::std::mem::size_of::<AutomationEvent>(),
2400 24usize,
2401 concat!("Size of: ", stringify!(AutomationEvent))
2402 );
2403 assert_eq!(
2404 ::std::mem::align_of::<AutomationEvent>(),
2405 4usize,
2406 concat!("Alignment of ", stringify!(AutomationEvent))
2407 );
2408 assert_eq!(
2409 unsafe { ::std::ptr::addr_of!((*ptr).frame) as usize - ptr as usize },
2410 0usize,
2411 concat!(
2412 "Offset of field: ",
2413 stringify!(AutomationEvent),
2414 "::",
2415 stringify!(frame)
2416 )
2417 );
2418 assert_eq!(
2419 unsafe { ::std::ptr::addr_of!((*ptr).type_) as usize - ptr as usize },
2420 4usize,
2421 concat!(
2422 "Offset of field: ",
2423 stringify!(AutomationEvent),
2424 "::",
2425 stringify!(type_)
2426 )
2427 );
2428 assert_eq!(
2429 unsafe { ::std::ptr::addr_of!((*ptr).params) as usize - ptr as usize },
2430 8usize,
2431 concat!(
2432 "Offset of field: ",
2433 stringify!(AutomationEvent),
2434 "::",
2435 stringify!(params)
2436 )
2437 );
2438}
2439#[repr(C)]
2440#[derive(Debug, Copy, Clone)]
2441pub struct AutomationEventList {
2442 pub capacity: ::std::os::raw::c_uint,
2443 pub count: ::std::os::raw::c_uint,
2444 pub events: *mut AutomationEvent,
2445}
2446#[test]
2447fn bindgen_test_layout_AutomationEventList() {
2448 const UNINIT: ::std::mem::MaybeUninit<AutomationEventList> = ::std::mem::MaybeUninit::uninit();
2449 let ptr = UNINIT.as_ptr();
2450 assert_eq!(
2451 ::std::mem::size_of::<AutomationEventList>(),
2452 16usize,
2453 concat!("Size of: ", stringify!(AutomationEventList))
2454 );
2455 assert_eq!(
2456 ::std::mem::align_of::<AutomationEventList>(),
2457 8usize,
2458 concat!("Alignment of ", stringify!(AutomationEventList))
2459 );
2460 assert_eq!(
2461 unsafe { ::std::ptr::addr_of!((*ptr).capacity) as usize - ptr as usize },
2462 0usize,
2463 concat!(
2464 "Offset of field: ",
2465 stringify!(AutomationEventList),
2466 "::",
2467 stringify!(capacity)
2468 )
2469 );
2470 assert_eq!(
2471 unsafe { ::std::ptr::addr_of!((*ptr).count) as usize - ptr as usize },
2472 4usize,
2473 concat!(
2474 "Offset of field: ",
2475 stringify!(AutomationEventList),
2476 "::",
2477 stringify!(count)
2478 )
2479 );
2480 assert_eq!(
2481 unsafe { ::std::ptr::addr_of!((*ptr).events) as usize - ptr as usize },
2482 8usize,
2483 concat!(
2484 "Offset of field: ",
2485 stringify!(AutomationEventList),
2486 "::",
2487 stringify!(events)
2488 )
2489 );
2490}
2491pub const ConfigFlags_FLAG_VSYNC_HINT: ConfigFlags = 64;
2492pub const ConfigFlags_FLAG_FULLSCREEN_MODE: ConfigFlags = 2;
2493pub const ConfigFlags_FLAG_WINDOW_RESIZABLE: ConfigFlags = 4;
2494pub const ConfigFlags_FLAG_WINDOW_UNDECORATED: ConfigFlags = 8;
2495pub const ConfigFlags_FLAG_WINDOW_HIDDEN: ConfigFlags = 128;
2496pub const ConfigFlags_FLAG_WINDOW_MINIMIZED: ConfigFlags = 512;
2497pub const ConfigFlags_FLAG_WINDOW_MAXIMIZED: ConfigFlags = 1024;
2498pub const ConfigFlags_FLAG_WINDOW_UNFOCUSED: ConfigFlags = 2048;
2499pub const ConfigFlags_FLAG_WINDOW_TOPMOST: ConfigFlags = 4096;
2500pub const ConfigFlags_FLAG_WINDOW_ALWAYS_RUN: ConfigFlags = 256;
2501pub const ConfigFlags_FLAG_WINDOW_TRANSPARENT: ConfigFlags = 16;
2502pub const ConfigFlags_FLAG_WINDOW_HIGHDPI: ConfigFlags = 8192;
2503pub const ConfigFlags_FLAG_WINDOW_MOUSE_PASSTHROUGH: ConfigFlags = 16384;
2504pub const ConfigFlags_FLAG_BORDERLESS_WINDOWED_MODE: ConfigFlags = 32768;
2505pub const ConfigFlags_FLAG_MSAA_4X_HINT: ConfigFlags = 32;
2506pub const ConfigFlags_FLAG_INTERLACED_HINT: ConfigFlags = 65536;
2507pub type ConfigFlags = ::std::os::raw::c_uint;
2508pub const TraceLogLevel_LOG_ALL: TraceLogLevel = 0;
2509pub const TraceLogLevel_LOG_TRACE: TraceLogLevel = 1;
2510pub const TraceLogLevel_LOG_DEBUG: TraceLogLevel = 2;
2511pub const TraceLogLevel_LOG_INFO: TraceLogLevel = 3;
2512pub const TraceLogLevel_LOG_WARNING: TraceLogLevel = 4;
2513pub const TraceLogLevel_LOG_ERROR: TraceLogLevel = 5;
2514pub const TraceLogLevel_LOG_FATAL: TraceLogLevel = 6;
2515pub const TraceLogLevel_LOG_NONE: TraceLogLevel = 7;
2516pub type TraceLogLevel = ::std::os::raw::c_uint;
2517pub const KeyboardKey_KEY_NULL: KeyboardKey = 0;
2518pub const KeyboardKey_KEY_APOSTROPHE: KeyboardKey = 39;
2519pub const KeyboardKey_KEY_COMMA: KeyboardKey = 44;
2520pub const KeyboardKey_KEY_MINUS: KeyboardKey = 45;
2521pub const KeyboardKey_KEY_PERIOD: KeyboardKey = 46;
2522pub const KeyboardKey_KEY_SLASH: KeyboardKey = 47;
2523pub const KeyboardKey_KEY_ZERO: KeyboardKey = 48;
2524pub const KeyboardKey_KEY_ONE: KeyboardKey = 49;
2525pub const KeyboardKey_KEY_TWO: KeyboardKey = 50;
2526pub const KeyboardKey_KEY_THREE: KeyboardKey = 51;
2527pub const KeyboardKey_KEY_FOUR: KeyboardKey = 52;
2528pub const KeyboardKey_KEY_FIVE: KeyboardKey = 53;
2529pub const KeyboardKey_KEY_SIX: KeyboardKey = 54;
2530pub const KeyboardKey_KEY_SEVEN: KeyboardKey = 55;
2531pub const KeyboardKey_KEY_EIGHT: KeyboardKey = 56;
2532pub const KeyboardKey_KEY_NINE: KeyboardKey = 57;
2533pub const KeyboardKey_KEY_SEMICOLON: KeyboardKey = 59;
2534pub const KeyboardKey_KEY_EQUAL: KeyboardKey = 61;
2535pub const KeyboardKey_KEY_A: KeyboardKey = 65;
2536pub const KeyboardKey_KEY_B: KeyboardKey = 66;
2537pub const KeyboardKey_KEY_C: KeyboardKey = 67;
2538pub const KeyboardKey_KEY_D: KeyboardKey = 68;
2539pub const KeyboardKey_KEY_E: KeyboardKey = 69;
2540pub const KeyboardKey_KEY_F: KeyboardKey = 70;
2541pub const KeyboardKey_KEY_G: KeyboardKey = 71;
2542pub const KeyboardKey_KEY_H: KeyboardKey = 72;
2543pub const KeyboardKey_KEY_I: KeyboardKey = 73;
2544pub const KeyboardKey_KEY_J: KeyboardKey = 74;
2545pub const KeyboardKey_KEY_K: KeyboardKey = 75;
2546pub const KeyboardKey_KEY_L: KeyboardKey = 76;
2547pub const KeyboardKey_KEY_M: KeyboardKey = 77;
2548pub const KeyboardKey_KEY_N: KeyboardKey = 78;
2549pub const KeyboardKey_KEY_O: KeyboardKey = 79;
2550pub const KeyboardKey_KEY_P: KeyboardKey = 80;
2551pub const KeyboardKey_KEY_Q: KeyboardKey = 81;
2552pub const KeyboardKey_KEY_R: KeyboardKey = 82;
2553pub const KeyboardKey_KEY_S: KeyboardKey = 83;
2554pub const KeyboardKey_KEY_T: KeyboardKey = 84;
2555pub const KeyboardKey_KEY_U: KeyboardKey = 85;
2556pub const KeyboardKey_KEY_V: KeyboardKey = 86;
2557pub const KeyboardKey_KEY_W: KeyboardKey = 87;
2558pub const KeyboardKey_KEY_X: KeyboardKey = 88;
2559pub const KeyboardKey_KEY_Y: KeyboardKey = 89;
2560pub const KeyboardKey_KEY_Z: KeyboardKey = 90;
2561pub const KeyboardKey_KEY_LEFT_BRACKET: KeyboardKey = 91;
2562pub const KeyboardKey_KEY_BACKSLASH: KeyboardKey = 92;
2563pub const KeyboardKey_KEY_RIGHT_BRACKET: KeyboardKey = 93;
2564pub const KeyboardKey_KEY_GRAVE: KeyboardKey = 96;
2565pub const KeyboardKey_KEY_SPACE: KeyboardKey = 32;
2566pub const KeyboardKey_KEY_ESCAPE: KeyboardKey = 256;
2567pub const KeyboardKey_KEY_ENTER: KeyboardKey = 257;
2568pub const KeyboardKey_KEY_TAB: KeyboardKey = 258;
2569pub const KeyboardKey_KEY_BACKSPACE: KeyboardKey = 259;
2570pub const KeyboardKey_KEY_INSERT: KeyboardKey = 260;
2571pub const KeyboardKey_KEY_DELETE: KeyboardKey = 261;
2572pub const KeyboardKey_KEY_RIGHT: KeyboardKey = 262;
2573pub const KeyboardKey_KEY_LEFT: KeyboardKey = 263;
2574pub const KeyboardKey_KEY_DOWN: KeyboardKey = 264;
2575pub const KeyboardKey_KEY_UP: KeyboardKey = 265;
2576pub const KeyboardKey_KEY_PAGE_UP: KeyboardKey = 266;
2577pub const KeyboardKey_KEY_PAGE_DOWN: KeyboardKey = 267;
2578pub const KeyboardKey_KEY_HOME: KeyboardKey = 268;
2579pub const KeyboardKey_KEY_END: KeyboardKey = 269;
2580pub const KeyboardKey_KEY_CAPS_LOCK: KeyboardKey = 280;
2581pub const KeyboardKey_KEY_SCROLL_LOCK: KeyboardKey = 281;
2582pub const KeyboardKey_KEY_NUM_LOCK: KeyboardKey = 282;
2583pub const KeyboardKey_KEY_PRINT_SCREEN: KeyboardKey = 283;
2584pub const KeyboardKey_KEY_PAUSE: KeyboardKey = 284;
2585pub const KeyboardKey_KEY_F1: KeyboardKey = 290;
2586pub const KeyboardKey_KEY_F2: KeyboardKey = 291;
2587pub const KeyboardKey_KEY_F3: KeyboardKey = 292;
2588pub const KeyboardKey_KEY_F4: KeyboardKey = 293;
2589pub const KeyboardKey_KEY_F5: KeyboardKey = 294;
2590pub const KeyboardKey_KEY_F6: KeyboardKey = 295;
2591pub const KeyboardKey_KEY_F7: KeyboardKey = 296;
2592pub const KeyboardKey_KEY_F8: KeyboardKey = 297;
2593pub const KeyboardKey_KEY_F9: KeyboardKey = 298;
2594pub const KeyboardKey_KEY_F10: KeyboardKey = 299;
2595pub const KeyboardKey_KEY_F11: KeyboardKey = 300;
2596pub const KeyboardKey_KEY_F12: KeyboardKey = 301;
2597pub const KeyboardKey_KEY_LEFT_SHIFT: KeyboardKey = 340;
2598pub const KeyboardKey_KEY_LEFT_CONTROL: KeyboardKey = 341;
2599pub const KeyboardKey_KEY_LEFT_ALT: KeyboardKey = 342;
2600pub const KeyboardKey_KEY_LEFT_SUPER: KeyboardKey = 343;
2601pub const KeyboardKey_KEY_RIGHT_SHIFT: KeyboardKey = 344;
2602pub const KeyboardKey_KEY_RIGHT_CONTROL: KeyboardKey = 345;
2603pub const KeyboardKey_KEY_RIGHT_ALT: KeyboardKey = 346;
2604pub const KeyboardKey_KEY_RIGHT_SUPER: KeyboardKey = 347;
2605pub const KeyboardKey_KEY_KB_MENU: KeyboardKey = 348;
2606pub const KeyboardKey_KEY_KP_0: KeyboardKey = 320;
2607pub const KeyboardKey_KEY_KP_1: KeyboardKey = 321;
2608pub const KeyboardKey_KEY_KP_2: KeyboardKey = 322;
2609pub const KeyboardKey_KEY_KP_3: KeyboardKey = 323;
2610pub const KeyboardKey_KEY_KP_4: KeyboardKey = 324;
2611pub const KeyboardKey_KEY_KP_5: KeyboardKey = 325;
2612pub const KeyboardKey_KEY_KP_6: KeyboardKey = 326;
2613pub const KeyboardKey_KEY_KP_7: KeyboardKey = 327;
2614pub const KeyboardKey_KEY_KP_8: KeyboardKey = 328;
2615pub const KeyboardKey_KEY_KP_9: KeyboardKey = 329;
2616pub const KeyboardKey_KEY_KP_DECIMAL: KeyboardKey = 330;
2617pub const KeyboardKey_KEY_KP_DIVIDE: KeyboardKey = 331;
2618pub const KeyboardKey_KEY_KP_MULTIPLY: KeyboardKey = 332;
2619pub const KeyboardKey_KEY_KP_SUBTRACT: KeyboardKey = 333;
2620pub const KeyboardKey_KEY_KP_ADD: KeyboardKey = 334;
2621pub const KeyboardKey_KEY_KP_ENTER: KeyboardKey = 335;
2622pub const KeyboardKey_KEY_KP_EQUAL: KeyboardKey = 336;
2623pub const KeyboardKey_KEY_BACK: KeyboardKey = 4;
2624pub const KeyboardKey_KEY_MENU: KeyboardKey = 5;
2625pub const KeyboardKey_KEY_VOLUME_UP: KeyboardKey = 24;
2626pub const KeyboardKey_KEY_VOLUME_DOWN: KeyboardKey = 25;
2627pub type KeyboardKey = ::std::os::raw::c_uint;
2628pub const MouseButton_MOUSE_BUTTON_LEFT: MouseButton = 0;
2629pub const MouseButton_MOUSE_BUTTON_RIGHT: MouseButton = 1;
2630pub const MouseButton_MOUSE_BUTTON_MIDDLE: MouseButton = 2;
2631pub const MouseButton_MOUSE_BUTTON_SIDE: MouseButton = 3;
2632pub const MouseButton_MOUSE_BUTTON_EXTRA: MouseButton = 4;
2633pub const MouseButton_MOUSE_BUTTON_FORWARD: MouseButton = 5;
2634pub const MouseButton_MOUSE_BUTTON_BACK: MouseButton = 6;
2635pub type MouseButton = ::std::os::raw::c_uint;
2636pub const MouseCursor_MOUSE_CURSOR_DEFAULT: MouseCursor = 0;
2637pub const MouseCursor_MOUSE_CURSOR_ARROW: MouseCursor = 1;
2638pub const MouseCursor_MOUSE_CURSOR_IBEAM: MouseCursor = 2;
2639pub const MouseCursor_MOUSE_CURSOR_CROSSHAIR: MouseCursor = 3;
2640pub const MouseCursor_MOUSE_CURSOR_POINTING_HAND: MouseCursor = 4;
2641pub const MouseCursor_MOUSE_CURSOR_RESIZE_EW: MouseCursor = 5;
2642pub const MouseCursor_MOUSE_CURSOR_RESIZE_NS: MouseCursor = 6;
2643pub const MouseCursor_MOUSE_CURSOR_RESIZE_NWSE: MouseCursor = 7;
2644pub const MouseCursor_MOUSE_CURSOR_RESIZE_NESW: MouseCursor = 8;
2645pub const MouseCursor_MOUSE_CURSOR_RESIZE_ALL: MouseCursor = 9;
2646pub const MouseCursor_MOUSE_CURSOR_NOT_ALLOWED: MouseCursor = 10;
2647pub type MouseCursor = ::std::os::raw::c_uint;
2648pub const GamepadButton_GAMEPAD_BUTTON_UNKNOWN: GamepadButton = 0;
2649pub const GamepadButton_GAMEPAD_BUTTON_LEFT_FACE_UP: GamepadButton = 1;
2650pub const GamepadButton_GAMEPAD_BUTTON_LEFT_FACE_RIGHT: GamepadButton = 2;
2651pub const GamepadButton_GAMEPAD_BUTTON_LEFT_FACE_DOWN: GamepadButton = 3;
2652pub const GamepadButton_GAMEPAD_BUTTON_LEFT_FACE_LEFT: GamepadButton = 4;
2653pub const GamepadButton_GAMEPAD_BUTTON_RIGHT_FACE_UP: GamepadButton = 5;
2654pub const GamepadButton_GAMEPAD_BUTTON_RIGHT_FACE_RIGHT: GamepadButton = 6;
2655pub const GamepadButton_GAMEPAD_BUTTON_RIGHT_FACE_DOWN: GamepadButton = 7;
2656pub const GamepadButton_GAMEPAD_BUTTON_RIGHT_FACE_LEFT: GamepadButton = 8;
2657pub const GamepadButton_GAMEPAD_BUTTON_LEFT_TRIGGER_1: GamepadButton = 9;
2658pub const GamepadButton_GAMEPAD_BUTTON_LEFT_TRIGGER_2: GamepadButton = 10;
2659pub const GamepadButton_GAMEPAD_BUTTON_RIGHT_TRIGGER_1: GamepadButton = 11;
2660pub const GamepadButton_GAMEPAD_BUTTON_RIGHT_TRIGGER_2: GamepadButton = 12;
2661pub const GamepadButton_GAMEPAD_BUTTON_MIDDLE_LEFT: GamepadButton = 13;
2662pub const GamepadButton_GAMEPAD_BUTTON_MIDDLE: GamepadButton = 14;
2663pub const GamepadButton_GAMEPAD_BUTTON_MIDDLE_RIGHT: GamepadButton = 15;
2664pub const GamepadButton_GAMEPAD_BUTTON_LEFT_THUMB: GamepadButton = 16;
2665pub const GamepadButton_GAMEPAD_BUTTON_RIGHT_THUMB: GamepadButton = 17;
2666pub type GamepadButton = ::std::os::raw::c_uint;
2667pub const GamepadAxis_GAMEPAD_AXIS_LEFT_X: GamepadAxis = 0;
2668pub const GamepadAxis_GAMEPAD_AXIS_LEFT_Y: GamepadAxis = 1;
2669pub const GamepadAxis_GAMEPAD_AXIS_RIGHT_X: GamepadAxis = 2;
2670pub const GamepadAxis_GAMEPAD_AXIS_RIGHT_Y: GamepadAxis = 3;
2671pub const GamepadAxis_GAMEPAD_AXIS_LEFT_TRIGGER: GamepadAxis = 4;
2672pub const GamepadAxis_GAMEPAD_AXIS_RIGHT_TRIGGER: GamepadAxis = 5;
2673pub type GamepadAxis = ::std::os::raw::c_uint;
2674pub const MaterialMapIndex_MATERIAL_MAP_ALBEDO: MaterialMapIndex = 0;
2675pub const MaterialMapIndex_MATERIAL_MAP_METALNESS: MaterialMapIndex = 1;
2676pub const MaterialMapIndex_MATERIAL_MAP_NORMAL: MaterialMapIndex = 2;
2677pub const MaterialMapIndex_MATERIAL_MAP_ROUGHNESS: MaterialMapIndex = 3;
2678pub const MaterialMapIndex_MATERIAL_MAP_OCCLUSION: MaterialMapIndex = 4;
2679pub const MaterialMapIndex_MATERIAL_MAP_EMISSION: MaterialMapIndex = 5;
2680pub const MaterialMapIndex_MATERIAL_MAP_HEIGHT: MaterialMapIndex = 6;
2681pub const MaterialMapIndex_MATERIAL_MAP_CUBEMAP: MaterialMapIndex = 7;
2682pub const MaterialMapIndex_MATERIAL_MAP_IRRADIANCE: MaterialMapIndex = 8;
2683pub const MaterialMapIndex_MATERIAL_MAP_PREFILTER: MaterialMapIndex = 9;
2684pub const MaterialMapIndex_MATERIAL_MAP_BRDF: MaterialMapIndex = 10;
2685pub type MaterialMapIndex = ::std::os::raw::c_uint;
2686pub const ShaderLocationIndex_SHADER_LOC_VERTEX_POSITION: ShaderLocationIndex = 0;
2687pub const ShaderLocationIndex_SHADER_LOC_VERTEX_TEXCOORD01: ShaderLocationIndex = 1;
2688pub const ShaderLocationIndex_SHADER_LOC_VERTEX_TEXCOORD02: ShaderLocationIndex = 2;
2689pub const ShaderLocationIndex_SHADER_LOC_VERTEX_NORMAL: ShaderLocationIndex = 3;
2690pub const ShaderLocationIndex_SHADER_LOC_VERTEX_TANGENT: ShaderLocationIndex = 4;
2691pub const ShaderLocationIndex_SHADER_LOC_VERTEX_COLOR: ShaderLocationIndex = 5;
2692pub const ShaderLocationIndex_SHADER_LOC_MATRIX_MVP: ShaderLocationIndex = 6;
2693pub const ShaderLocationIndex_SHADER_LOC_MATRIX_VIEW: ShaderLocationIndex = 7;
2694pub const ShaderLocationIndex_SHADER_LOC_MATRIX_PROJECTION: ShaderLocationIndex = 8;
2695pub const ShaderLocationIndex_SHADER_LOC_MATRIX_MODEL: ShaderLocationIndex = 9;
2696pub const ShaderLocationIndex_SHADER_LOC_MATRIX_NORMAL: ShaderLocationIndex = 10;
2697pub const ShaderLocationIndex_SHADER_LOC_VECTOR_VIEW: ShaderLocationIndex = 11;
2698pub const ShaderLocationIndex_SHADER_LOC_COLOR_DIFFUSE: ShaderLocationIndex = 12;
2699pub const ShaderLocationIndex_SHADER_LOC_COLOR_SPECULAR: ShaderLocationIndex = 13;
2700pub const ShaderLocationIndex_SHADER_LOC_COLOR_AMBIENT: ShaderLocationIndex = 14;
2701pub const ShaderLocationIndex_SHADER_LOC_MAP_ALBEDO: ShaderLocationIndex = 15;
2702pub const ShaderLocationIndex_SHADER_LOC_MAP_METALNESS: ShaderLocationIndex = 16;
2703pub const ShaderLocationIndex_SHADER_LOC_MAP_NORMAL: ShaderLocationIndex = 17;
2704pub const ShaderLocationIndex_SHADER_LOC_MAP_ROUGHNESS: ShaderLocationIndex = 18;
2705pub const ShaderLocationIndex_SHADER_LOC_MAP_OCCLUSION: ShaderLocationIndex = 19;
2706pub const ShaderLocationIndex_SHADER_LOC_MAP_EMISSION: ShaderLocationIndex = 20;
2707pub const ShaderLocationIndex_SHADER_LOC_MAP_HEIGHT: ShaderLocationIndex = 21;
2708pub const ShaderLocationIndex_SHADER_LOC_MAP_CUBEMAP: ShaderLocationIndex = 22;
2709pub const ShaderLocationIndex_SHADER_LOC_MAP_IRRADIANCE: ShaderLocationIndex = 23;
2710pub const ShaderLocationIndex_SHADER_LOC_MAP_PREFILTER: ShaderLocationIndex = 24;
2711pub const ShaderLocationIndex_SHADER_LOC_MAP_BRDF: ShaderLocationIndex = 25;
2712pub const ShaderLocationIndex_SHADER_LOC_VERTEX_BONEIDS: ShaderLocationIndex = 26;
2713pub const ShaderLocationIndex_SHADER_LOC_VERTEX_BONEWEIGHTS: ShaderLocationIndex = 27;
2714pub const ShaderLocationIndex_SHADER_LOC_BONE_MATRICES: ShaderLocationIndex = 28;
2715pub type ShaderLocationIndex = ::std::os::raw::c_uint;
2716pub const ShaderUniformDataType_SHADER_UNIFORM_FLOAT: ShaderUniformDataType = 0;
2717pub const ShaderUniformDataType_SHADER_UNIFORM_VEC2: ShaderUniformDataType = 1;
2718pub const ShaderUniformDataType_SHADER_UNIFORM_VEC3: ShaderUniformDataType = 2;
2719pub const ShaderUniformDataType_SHADER_UNIFORM_VEC4: ShaderUniformDataType = 3;
2720pub const ShaderUniformDataType_SHADER_UNIFORM_INT: ShaderUniformDataType = 4;
2721pub const ShaderUniformDataType_SHADER_UNIFORM_IVEC2: ShaderUniformDataType = 5;
2722pub const ShaderUniformDataType_SHADER_UNIFORM_IVEC3: ShaderUniformDataType = 6;
2723pub const ShaderUniformDataType_SHADER_UNIFORM_IVEC4: ShaderUniformDataType = 7;
2724pub const ShaderUniformDataType_SHADER_UNIFORM_SAMPLER2D: ShaderUniformDataType = 8;
2725pub type ShaderUniformDataType = ::std::os::raw::c_uint;
2726pub const ShaderAttributeDataType_SHADER_ATTRIB_FLOAT: ShaderAttributeDataType = 0;
2727pub const ShaderAttributeDataType_SHADER_ATTRIB_VEC2: ShaderAttributeDataType = 1;
2728pub const ShaderAttributeDataType_SHADER_ATTRIB_VEC3: ShaderAttributeDataType = 2;
2729pub const ShaderAttributeDataType_SHADER_ATTRIB_VEC4: ShaderAttributeDataType = 3;
2730pub type ShaderAttributeDataType = ::std::os::raw::c_uint;
2731pub const PixelFormat_PIXELFORMAT_UNCOMPRESSED_GRAYSCALE: PixelFormat = 1;
2732pub const PixelFormat_PIXELFORMAT_UNCOMPRESSED_GRAY_ALPHA: PixelFormat = 2;
2733pub const PixelFormat_PIXELFORMAT_UNCOMPRESSED_R5G6B5: PixelFormat = 3;
2734pub const PixelFormat_PIXELFORMAT_UNCOMPRESSED_R8G8B8: PixelFormat = 4;
2735pub const PixelFormat_PIXELFORMAT_UNCOMPRESSED_R5G5B5A1: PixelFormat = 5;
2736pub const PixelFormat_PIXELFORMAT_UNCOMPRESSED_R4G4B4A4: PixelFormat = 6;
2737pub const PixelFormat_PIXELFORMAT_UNCOMPRESSED_R8G8B8A8: PixelFormat = 7;
2738pub const PixelFormat_PIXELFORMAT_UNCOMPRESSED_R32: PixelFormat = 8;
2739pub const PixelFormat_PIXELFORMAT_UNCOMPRESSED_R32G32B32: PixelFormat = 9;
2740pub const PixelFormat_PIXELFORMAT_UNCOMPRESSED_R32G32B32A32: PixelFormat = 10;
2741pub const PixelFormat_PIXELFORMAT_UNCOMPRESSED_R16: PixelFormat = 11;
2742pub const PixelFormat_PIXELFORMAT_UNCOMPRESSED_R16G16B16: PixelFormat = 12;
2743pub const PixelFormat_PIXELFORMAT_UNCOMPRESSED_R16G16B16A16: PixelFormat = 13;
2744pub const PixelFormat_PIXELFORMAT_COMPRESSED_DXT1_RGB: PixelFormat = 14;
2745pub const PixelFormat_PIXELFORMAT_COMPRESSED_DXT1_RGBA: PixelFormat = 15;
2746pub const PixelFormat_PIXELFORMAT_COMPRESSED_DXT3_RGBA: PixelFormat = 16;
2747pub const PixelFormat_PIXELFORMAT_COMPRESSED_DXT5_RGBA: PixelFormat = 17;
2748pub const PixelFormat_PIXELFORMAT_COMPRESSED_ETC1_RGB: PixelFormat = 18;
2749pub const PixelFormat_PIXELFORMAT_COMPRESSED_ETC2_RGB: PixelFormat = 19;
2750pub const PixelFormat_PIXELFORMAT_COMPRESSED_ETC2_EAC_RGBA: PixelFormat = 20;
2751pub const PixelFormat_PIXELFORMAT_COMPRESSED_PVRT_RGB: PixelFormat = 21;
2752pub const PixelFormat_PIXELFORMAT_COMPRESSED_PVRT_RGBA: PixelFormat = 22;
2753pub const PixelFormat_PIXELFORMAT_COMPRESSED_ASTC_4x4_RGBA: PixelFormat = 23;
2754pub const PixelFormat_PIXELFORMAT_COMPRESSED_ASTC_8x8_RGBA: PixelFormat = 24;
2755pub type PixelFormat = ::std::os::raw::c_uint;
2756pub const TextureFilter_TEXTURE_FILTER_POINT: TextureFilter = 0;
2757pub const TextureFilter_TEXTURE_FILTER_BILINEAR: TextureFilter = 1;
2758pub const TextureFilter_TEXTURE_FILTER_TRILINEAR: TextureFilter = 2;
2759pub const TextureFilter_TEXTURE_FILTER_ANISOTROPIC_4X: TextureFilter = 3;
2760pub const TextureFilter_TEXTURE_FILTER_ANISOTROPIC_8X: TextureFilter = 4;
2761pub const TextureFilter_TEXTURE_FILTER_ANISOTROPIC_16X: TextureFilter = 5;
2762pub type TextureFilter = ::std::os::raw::c_uint;
2763pub const TextureWrap_TEXTURE_WRAP_REPEAT: TextureWrap = 0;
2764pub const TextureWrap_TEXTURE_WRAP_CLAMP: TextureWrap = 1;
2765pub const TextureWrap_TEXTURE_WRAP_MIRROR_REPEAT: TextureWrap = 2;
2766pub const TextureWrap_TEXTURE_WRAP_MIRROR_CLAMP: TextureWrap = 3;
2767pub type TextureWrap = ::std::os::raw::c_uint;
2768pub const CubemapLayout_CUBEMAP_LAYOUT_AUTO_DETECT: CubemapLayout = 0;
2769pub const CubemapLayout_CUBEMAP_LAYOUT_LINE_VERTICAL: CubemapLayout = 1;
2770pub const CubemapLayout_CUBEMAP_LAYOUT_LINE_HORIZONTAL: CubemapLayout = 2;
2771pub const CubemapLayout_CUBEMAP_LAYOUT_CROSS_THREE_BY_FOUR: CubemapLayout = 3;
2772pub const CubemapLayout_CUBEMAP_LAYOUT_CROSS_FOUR_BY_THREE: CubemapLayout = 4;
2773pub const CubemapLayout_CUBEMAP_LAYOUT_PANORAMA: CubemapLayout = 5;
2774pub type CubemapLayout = ::std::os::raw::c_uint;
2775pub const FontType_FONT_DEFAULT: FontType = 0;
2776pub const FontType_FONT_BITMAP: FontType = 1;
2777pub const FontType_FONT_SDF: FontType = 2;
2778pub type FontType = ::std::os::raw::c_uint;
2779pub const BlendMode_BLEND_ALPHA: BlendMode = 0;
2780pub const BlendMode_BLEND_ADDITIVE: BlendMode = 1;
2781pub const BlendMode_BLEND_MULTIPLIED: BlendMode = 2;
2782pub const BlendMode_BLEND_ADD_COLORS: BlendMode = 3;
2783pub const BlendMode_BLEND_SUBTRACT_COLORS: BlendMode = 4;
2784pub const BlendMode_BLEND_ALPHA_PREMULTIPLY: BlendMode = 5;
2785pub const BlendMode_BLEND_CUSTOM: BlendMode = 6;
2786pub const BlendMode_BLEND_CUSTOM_SEPARATE: BlendMode = 7;
2787pub type BlendMode = ::std::os::raw::c_uint;
2788pub const Gesture_GESTURE_NONE: Gesture = 0;
2789pub const Gesture_GESTURE_TAP: Gesture = 1;
2790pub const Gesture_GESTURE_DOUBLETAP: Gesture = 2;
2791pub const Gesture_GESTURE_HOLD: Gesture = 4;
2792pub const Gesture_GESTURE_DRAG: Gesture = 8;
2793pub const Gesture_GESTURE_SWIPE_RIGHT: Gesture = 16;
2794pub const Gesture_GESTURE_SWIPE_LEFT: Gesture = 32;
2795pub const Gesture_GESTURE_SWIPE_UP: Gesture = 64;
2796pub const Gesture_GESTURE_SWIPE_DOWN: Gesture = 128;
2797pub const Gesture_GESTURE_PINCH_IN: Gesture = 256;
2798pub const Gesture_GESTURE_PINCH_OUT: Gesture = 512;
2799pub type Gesture = ::std::os::raw::c_uint;
2800pub const CameraMode_CAMERA_CUSTOM: CameraMode = 0;
2801pub const CameraMode_CAMERA_FREE: CameraMode = 1;
2802pub const CameraMode_CAMERA_ORBITAL: CameraMode = 2;
2803pub const CameraMode_CAMERA_FIRST_PERSON: CameraMode = 3;
2804pub const CameraMode_CAMERA_THIRD_PERSON: CameraMode = 4;
2805pub type CameraMode = ::std::os::raw::c_uint;
2806pub const CameraProjection_CAMERA_PERSPECTIVE: CameraProjection = 0;
2807pub const CameraProjection_CAMERA_ORTHOGRAPHIC: CameraProjection = 1;
2808pub type CameraProjection = ::std::os::raw::c_uint;
2809pub const NPatchLayout_NPATCH_NINE_PATCH: NPatchLayout = 0;
2810pub const NPatchLayout_NPATCH_THREE_PATCH_VERTICAL: NPatchLayout = 1;
2811pub const NPatchLayout_NPATCH_THREE_PATCH_HORIZONTAL: NPatchLayout = 2;
2812pub type NPatchLayout = ::std::os::raw::c_uint;
2813pub type TraceLogCallback = ::std::option::Option<
2814 unsafe extern "C" fn(
2815 logLevel: ::std::os::raw::c_int,
2816 text: *const ::std::os::raw::c_char,
2817 args: *mut __va_list_tag,
2818 ),
2819>;
2820pub type LoadFileDataCallback = ::std::option::Option<
2821 unsafe extern "C" fn(
2822 fileName: *const ::std::os::raw::c_char,
2823 dataSize: *mut ::std::os::raw::c_int,
2824 ) -> *mut ::std::os::raw::c_uchar,
2825>;
2826pub type SaveFileDataCallback = ::std::option::Option<
2827 unsafe extern "C" fn(
2828 fileName: *const ::std::os::raw::c_char,
2829 data: *mut ::std::os::raw::c_void,
2830 dataSize: ::std::os::raw::c_int,
2831 ) -> bool,
2832>;
2833pub type LoadFileTextCallback = ::std::option::Option<
2834 unsafe extern "C" fn(fileName: *const ::std::os::raw::c_char) -> *mut ::std::os::raw::c_char,
2835>;
2836pub type SaveFileTextCallback = ::std::option::Option<
2837 unsafe extern "C" fn(
2838 fileName: *const ::std::os::raw::c_char,
2839 text: *mut ::std::os::raw::c_char,
2840 ) -> bool,
2841>;
2842extern "C" {
2843 pub fn InitWindow(
2844 width: ::std::os::raw::c_int,
2845 height: ::std::os::raw::c_int,
2846 title: *const ::std::os::raw::c_char,
2847 );
2848}
2849extern "C" {
2850 pub fn CloseWindow();
2851}
2852extern "C" {
2853 pub fn WindowShouldClose() -> bool;
2854}
2855extern "C" {
2856 pub fn IsWindowReady() -> bool;
2857}
2858extern "C" {
2859 pub fn IsWindowFullscreen() -> bool;
2860}
2861extern "C" {
2862 pub fn IsWindowHidden() -> bool;
2863}
2864extern "C" {
2865 pub fn IsWindowMinimized() -> bool;
2866}
2867extern "C" {
2868 pub fn IsWindowMaximized() -> bool;
2869}
2870extern "C" {
2871 pub fn IsWindowFocused() -> bool;
2872}
2873extern "C" {
2874 pub fn IsWindowResized() -> bool;
2875}
2876extern "C" {
2877 pub fn IsWindowState(flag: ::std::os::raw::c_uint) -> bool;
2878}
2879extern "C" {
2880 pub fn SetWindowState(flags: ::std::os::raw::c_uint);
2881}
2882extern "C" {
2883 pub fn ClearWindowState(flags: ::std::os::raw::c_uint);
2884}
2885extern "C" {
2886 pub fn ToggleFullscreen();
2887}
2888extern "C" {
2889 pub fn ToggleBorderlessWindowed();
2890}
2891extern "C" {
2892 pub fn MaximizeWindow();
2893}
2894extern "C" {
2895 pub fn MinimizeWindow();
2896}
2897extern "C" {
2898 pub fn RestoreWindow();
2899}
2900extern "C" {
2901 pub fn SetWindowIcon(image: Image);
2902}
2903extern "C" {
2904 pub fn SetWindowIcons(images: *mut Image, count: ::std::os::raw::c_int);
2905}
2906extern "C" {
2907 pub fn SetWindowTitle(title: *const ::std::os::raw::c_char);
2908}
2909extern "C" {
2910 pub fn SetWindowPosition(x: ::std::os::raw::c_int, y: ::std::os::raw::c_int);
2911}
2912extern "C" {
2913 pub fn SetWindowMonitor(monitor: ::std::os::raw::c_int);
2914}
2915extern "C" {
2916 pub fn SetWindowMinSize(width: ::std::os::raw::c_int, height: ::std::os::raw::c_int);
2917}
2918extern "C" {
2919 pub fn SetWindowMaxSize(width: ::std::os::raw::c_int, height: ::std::os::raw::c_int);
2920}
2921extern "C" {
2922 pub fn SetWindowSize(width: ::std::os::raw::c_int, height: ::std::os::raw::c_int);
2923}
2924extern "C" {
2925 pub fn SetWindowOpacity(opacity: f32);
2926}
2927extern "C" {
2928 pub fn SetWindowFocused();
2929}
2930extern "C" {
2931 pub fn GetWindowHandle() -> *mut ::std::os::raw::c_void;
2932}
2933extern "C" {
2934 pub fn GetScreenWidth() -> ::std::os::raw::c_int;
2935}
2936extern "C" {
2937 pub fn GetScreenHeight() -> ::std::os::raw::c_int;
2938}
2939extern "C" {
2940 pub fn GetRenderWidth() -> ::std::os::raw::c_int;
2941}
2942extern "C" {
2943 pub fn GetRenderHeight() -> ::std::os::raw::c_int;
2944}
2945extern "C" {
2946 pub fn GetMonitorCount() -> ::std::os::raw::c_int;
2947}
2948extern "C" {
2949 pub fn GetCurrentMonitor() -> ::std::os::raw::c_int;
2950}
2951extern "C" {
2952 pub fn GetMonitorPosition(monitor: ::std::os::raw::c_int) -> Vector2;
2953}
2954extern "C" {
2955 pub fn GetMonitorWidth(monitor: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
2956}
2957extern "C" {
2958 pub fn GetMonitorHeight(monitor: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
2959}
2960extern "C" {
2961 pub fn GetMonitorPhysicalWidth(monitor: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
2962}
2963extern "C" {
2964 pub fn GetMonitorPhysicalHeight(monitor: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
2965}
2966extern "C" {
2967 pub fn GetMonitorRefreshRate(monitor: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
2968}
2969extern "C" {
2970 pub fn GetWindowPosition() -> Vector2;
2971}
2972extern "C" {
2973 pub fn GetWindowScaleDPI() -> Vector2;
2974}
2975extern "C" {
2976 pub fn GetMonitorName(monitor: ::std::os::raw::c_int) -> *const ::std::os::raw::c_char;
2977}
2978extern "C" {
2979 pub fn SetClipboardText(text: *const ::std::os::raw::c_char);
2980}
2981extern "C" {
2982 pub fn GetClipboardText() -> *const ::std::os::raw::c_char;
2983}
2984extern "C" {
2985 pub fn EnableEventWaiting();
2986}
2987extern "C" {
2988 pub fn DisableEventWaiting();
2989}
2990extern "C" {
2991 pub fn ShowCursor();
2992}
2993extern "C" {
2994 pub fn HideCursor();
2995}
2996extern "C" {
2997 pub fn IsCursorHidden() -> bool;
2998}
2999extern "C" {
3000 pub fn EnableCursor();
3001}
3002extern "C" {
3003 pub fn DisableCursor();
3004}
3005extern "C" {
3006 pub fn IsCursorOnScreen() -> bool;
3007}
3008extern "C" {
3009 pub fn ClearBackground(color: Color);
3010}
3011extern "C" {
3012 pub fn BeginDrawing();
3013}
3014extern "C" {
3015 pub fn EndDrawing();
3016}
3017extern "C" {
3018 pub fn BeginMode2D(camera: Camera2D);
3019}
3020extern "C" {
3021 pub fn EndMode2D();
3022}
3023extern "C" {
3024 pub fn BeginMode3D(camera: Camera3D);
3025}
3026extern "C" {
3027 pub fn EndMode3D();
3028}
3029extern "C" {
3030 pub fn BeginTextureMode(target: RenderTexture2D);
3031}
3032extern "C" {
3033 pub fn EndTextureMode();
3034}
3035extern "C" {
3036 pub fn BeginShaderMode(shader: Shader);
3037}
3038extern "C" {
3039 pub fn EndShaderMode();
3040}
3041extern "C" {
3042 pub fn BeginBlendMode(mode: ::std::os::raw::c_int);
3043}
3044extern "C" {
3045 pub fn EndBlendMode();
3046}
3047extern "C" {
3048 pub fn BeginScissorMode(
3049 x: ::std::os::raw::c_int,
3050 y: ::std::os::raw::c_int,
3051 width: ::std::os::raw::c_int,
3052 height: ::std::os::raw::c_int,
3053 );
3054}
3055extern "C" {
3056 pub fn EndScissorMode();
3057}
3058extern "C" {
3059 pub fn BeginVrStereoMode(config: VrStereoConfig);
3060}
3061extern "C" {
3062 pub fn EndVrStereoMode();
3063}
3064extern "C" {
3065 pub fn LoadVrStereoConfig(device: VrDeviceInfo) -> VrStereoConfig;
3066}
3067extern "C" {
3068 pub fn UnloadVrStereoConfig(config: VrStereoConfig);
3069}
3070extern "C" {
3071 pub fn LoadShader(
3072 vsFileName: *const ::std::os::raw::c_char,
3073 fsFileName: *const ::std::os::raw::c_char,
3074 ) -> Shader;
3075}
3076extern "C" {
3077 pub fn LoadShaderFromMemory(
3078 vsCode: *const ::std::os::raw::c_char,
3079 fsCode: *const ::std::os::raw::c_char,
3080 ) -> Shader;
3081}
3082extern "C" {
3083 pub fn IsShaderReady(shader: Shader) -> bool;
3084}
3085extern "C" {
3086 pub fn GetShaderLocation(
3087 shader: Shader,
3088 uniformName: *const ::std::os::raw::c_char,
3089 ) -> ::std::os::raw::c_int;
3090}
3091extern "C" {
3092 pub fn GetShaderLocationAttrib(
3093 shader: Shader,
3094 attribName: *const ::std::os::raw::c_char,
3095 ) -> ::std::os::raw::c_int;
3096}
3097extern "C" {
3098 pub fn SetShaderValue(
3099 shader: Shader,
3100 locIndex: ::std::os::raw::c_int,
3101 value: *const ::std::os::raw::c_void,
3102 uniformType: ::std::os::raw::c_int,
3103 );
3104}
3105extern "C" {
3106 pub fn SetShaderValueV(
3107 shader: Shader,
3108 locIndex: ::std::os::raw::c_int,
3109 value: *const ::std::os::raw::c_void,
3110 uniformType: ::std::os::raw::c_int,
3111 count: ::std::os::raw::c_int,
3112 );
3113}
3114extern "C" {
3115 pub fn SetShaderValueMatrix(shader: Shader, locIndex: ::std::os::raw::c_int, mat: Matrix);
3116}
3117extern "C" {
3118 pub fn SetShaderValueTexture(
3119 shader: Shader,
3120 locIndex: ::std::os::raw::c_int,
3121 texture: Texture2D,
3122 );
3123}
3124extern "C" {
3125 pub fn UnloadShader(shader: Shader);
3126}
3127extern "C" {
3128 pub fn GetScreenToWorldRay(position: Vector2, camera: Camera) -> Ray;
3129}
3130extern "C" {
3131 pub fn GetScreenToWorldRayEx(
3132 position: Vector2,
3133 camera: Camera,
3134 width: ::std::os::raw::c_int,
3135 height: ::std::os::raw::c_int,
3136 ) -> Ray;
3137}
3138extern "C" {
3139 pub fn GetWorldToScreen(position: Vector3, camera: Camera) -> Vector2;
3140}
3141extern "C" {
3142 pub fn GetWorldToScreenEx(
3143 position: Vector3,
3144 camera: Camera,
3145 width: ::std::os::raw::c_int,
3146 height: ::std::os::raw::c_int,
3147 ) -> Vector2;
3148}
3149extern "C" {
3150 pub fn GetWorldToScreen2D(position: Vector2, camera: Camera2D) -> Vector2;
3151}
3152extern "C" {
3153 pub fn GetScreenToWorld2D(position: Vector2, camera: Camera2D) -> Vector2;
3154}
3155extern "C" {
3156 pub fn GetCameraMatrix(camera: Camera) -> Matrix;
3157}
3158extern "C" {
3159 pub fn GetCameraMatrix2D(camera: Camera2D) -> Matrix;
3160}
3161extern "C" {
3162 pub fn SetTargetFPS(fps: ::std::os::raw::c_int);
3163}
3164extern "C" {
3165 pub fn GetFrameTime() -> f32;
3166}
3167extern "C" {
3168 pub fn GetTime() -> f64;
3169}
3170extern "C" {
3171 pub fn GetFPS() -> ::std::os::raw::c_int;
3172}
3173extern "C" {
3174 pub fn SwapScreenBuffer();
3175}
3176extern "C" {
3177 pub fn PollInputEvents();
3178}
3179extern "C" {
3180 pub fn WaitTime(seconds: f64);
3181}
3182extern "C" {
3183 pub fn SetRandomSeed(seed: ::std::os::raw::c_uint);
3184}
3185extern "C" {
3186 pub fn GetRandomValue(
3187 min: ::std::os::raw::c_int,
3188 max: ::std::os::raw::c_int,
3189 ) -> ::std::os::raw::c_int;
3190}
3191extern "C" {
3192 pub fn LoadRandomSequence(
3193 count: ::std::os::raw::c_uint,
3194 min: ::std::os::raw::c_int,
3195 max: ::std::os::raw::c_int,
3196 ) -> *mut ::std::os::raw::c_int;
3197}
3198extern "C" {
3199 pub fn UnloadRandomSequence(sequence: *mut ::std::os::raw::c_int);
3200}
3201extern "C" {
3202 pub fn TakeScreenshot(fileName: *const ::std::os::raw::c_char);
3203}
3204extern "C" {
3205 pub fn SetConfigFlags(flags: ::std::os::raw::c_uint);
3206}
3207extern "C" {
3208 pub fn OpenURL(url: *const ::std::os::raw::c_char);
3209}
3210extern "C" {
3211 pub fn TraceLog(logLevel: ::std::os::raw::c_int, text: *const ::std::os::raw::c_char, ...);
3212}
3213extern "C" {
3214 pub fn SetTraceLogLevel(logLevel: ::std::os::raw::c_int);
3215}
3216extern "C" {
3217 pub fn MemAlloc(size: ::std::os::raw::c_uint) -> *mut ::std::os::raw::c_void;
3218}
3219extern "C" {
3220 pub fn MemRealloc(
3221 ptr: *mut ::std::os::raw::c_void,
3222 size: ::std::os::raw::c_uint,
3223 ) -> *mut ::std::os::raw::c_void;
3224}
3225extern "C" {
3226 pub fn MemFree(ptr: *mut ::std::os::raw::c_void);
3227}
3228extern "C" {
3229 pub fn SetTraceLogCallback(callback: TraceLogCallback);
3230}
3231extern "C" {
3232 pub fn SetLoadFileDataCallback(callback: LoadFileDataCallback);
3233}
3234extern "C" {
3235 pub fn SetSaveFileDataCallback(callback: SaveFileDataCallback);
3236}
3237extern "C" {
3238 pub fn SetLoadFileTextCallback(callback: LoadFileTextCallback);
3239}
3240extern "C" {
3241 pub fn SetSaveFileTextCallback(callback: SaveFileTextCallback);
3242}
3243extern "C" {
3244 pub fn LoadFileData(
3245 fileName: *const ::std::os::raw::c_char,
3246 dataSize: *mut ::std::os::raw::c_int,
3247 ) -> *mut ::std::os::raw::c_uchar;
3248}
3249extern "C" {
3250 pub fn UnloadFileData(data: *mut ::std::os::raw::c_uchar);
3251}
3252extern "C" {
3253 pub fn SaveFileData(
3254 fileName: *const ::std::os::raw::c_char,
3255 data: *mut ::std::os::raw::c_void,
3256 dataSize: ::std::os::raw::c_int,
3257 ) -> bool;
3258}
3259extern "C" {
3260 pub fn ExportDataAsCode(
3261 data: *const ::std::os::raw::c_uchar,
3262 dataSize: ::std::os::raw::c_int,
3263 fileName: *const ::std::os::raw::c_char,
3264 ) -> bool;
3265}
3266extern "C" {
3267 pub fn LoadFileText(fileName: *const ::std::os::raw::c_char) -> *mut ::std::os::raw::c_char;
3268}
3269extern "C" {
3270 pub fn UnloadFileText(text: *mut ::std::os::raw::c_char);
3271}
3272extern "C" {
3273 pub fn SaveFileText(
3274 fileName: *const ::std::os::raw::c_char,
3275 text: *mut ::std::os::raw::c_char,
3276 ) -> bool;
3277}
3278extern "C" {
3279 pub fn FileExists(fileName: *const ::std::os::raw::c_char) -> bool;
3280}
3281extern "C" {
3282 pub fn DirectoryExists(dirPath: *const ::std::os::raw::c_char) -> bool;
3283}
3284extern "C" {
3285 pub fn IsFileExtension(
3286 fileName: *const ::std::os::raw::c_char,
3287 ext: *const ::std::os::raw::c_char,
3288 ) -> bool;
3289}
3290extern "C" {
3291 pub fn GetFileLength(fileName: *const ::std::os::raw::c_char) -> ::std::os::raw::c_int;
3292}
3293extern "C" {
3294 pub fn GetFileExtension(
3295 fileName: *const ::std::os::raw::c_char,
3296 ) -> *const ::std::os::raw::c_char;
3297}
3298extern "C" {
3299 pub fn GetFileName(filePath: *const ::std::os::raw::c_char) -> *const ::std::os::raw::c_char;
3300}
3301extern "C" {
3302 pub fn GetFileNameWithoutExt(
3303 filePath: *const ::std::os::raw::c_char,
3304 ) -> *const ::std::os::raw::c_char;
3305}
3306extern "C" {
3307 pub fn GetDirectoryPath(
3308 filePath: *const ::std::os::raw::c_char,
3309 ) -> *const ::std::os::raw::c_char;
3310}
3311extern "C" {
3312 pub fn GetPrevDirectoryPath(
3313 dirPath: *const ::std::os::raw::c_char,
3314 ) -> *const ::std::os::raw::c_char;
3315}
3316extern "C" {
3317 pub fn GetWorkingDirectory() -> *const ::std::os::raw::c_char;
3318}
3319extern "C" {
3320 pub fn GetApplicationDirectory() -> *const ::std::os::raw::c_char;
3321}
3322extern "C" {
3323 pub fn MakeDirectory(dirPath: *const ::std::os::raw::c_char) -> ::std::os::raw::c_int;
3324}
3325extern "C" {
3326 pub fn ChangeDirectory(dir: *const ::std::os::raw::c_char) -> bool;
3327}
3328extern "C" {
3329 pub fn IsPathFile(path: *const ::std::os::raw::c_char) -> bool;
3330}
3331extern "C" {
3332 pub fn IsFileNameValid(fileName: *const ::std::os::raw::c_char) -> bool;
3333}
3334extern "C" {
3335 pub fn LoadDirectoryFiles(dirPath: *const ::std::os::raw::c_char) -> FilePathList;
3336}
3337extern "C" {
3338 pub fn LoadDirectoryFilesEx(
3339 basePath: *const ::std::os::raw::c_char,
3340 filter: *const ::std::os::raw::c_char,
3341 scanSubdirs: bool,
3342 ) -> FilePathList;
3343}
3344extern "C" {
3345 pub fn UnloadDirectoryFiles(files: FilePathList);
3346}
3347extern "C" {
3348 pub fn IsFileDropped() -> bool;
3349}
3350extern "C" {
3351 pub fn LoadDroppedFiles() -> FilePathList;
3352}
3353extern "C" {
3354 pub fn UnloadDroppedFiles(files: FilePathList);
3355}
3356extern "C" {
3357 pub fn GetFileModTime(fileName: *const ::std::os::raw::c_char) -> ::std::os::raw::c_long;
3358}
3359extern "C" {
3360 pub fn CompressData(
3361 data: *const ::std::os::raw::c_uchar,
3362 dataSize: ::std::os::raw::c_int,
3363 compDataSize: *mut ::std::os::raw::c_int,
3364 ) -> *mut ::std::os::raw::c_uchar;
3365}
3366extern "C" {
3367 pub fn DecompressData(
3368 compData: *const ::std::os::raw::c_uchar,
3369 compDataSize: ::std::os::raw::c_int,
3370 dataSize: *mut ::std::os::raw::c_int,
3371 ) -> *mut ::std::os::raw::c_uchar;
3372}
3373extern "C" {
3374 pub fn EncodeDataBase64(
3375 data: *const ::std::os::raw::c_uchar,
3376 dataSize: ::std::os::raw::c_int,
3377 outputSize: *mut ::std::os::raw::c_int,
3378 ) -> *mut ::std::os::raw::c_char;
3379}
3380extern "C" {
3381 pub fn DecodeDataBase64(
3382 data: *const ::std::os::raw::c_uchar,
3383 outputSize: *mut ::std::os::raw::c_int,
3384 ) -> *mut ::std::os::raw::c_uchar;
3385}
3386extern "C" {
3387 pub fn LoadAutomationEventList(fileName: *const ::std::os::raw::c_char) -> AutomationEventList;
3388}
3389extern "C" {
3390 pub fn UnloadAutomationEventList(list: AutomationEventList);
3391}
3392extern "C" {
3393 pub fn ExportAutomationEventList(
3394 list: AutomationEventList,
3395 fileName: *const ::std::os::raw::c_char,
3396 ) -> bool;
3397}
3398extern "C" {
3399 pub fn SetAutomationEventList(list: *mut AutomationEventList);
3400}
3401extern "C" {
3402 pub fn SetAutomationEventBaseFrame(frame: ::std::os::raw::c_int);
3403}
3404extern "C" {
3405 pub fn StartAutomationEventRecording();
3406}
3407extern "C" {
3408 pub fn StopAutomationEventRecording();
3409}
3410extern "C" {
3411 pub fn PlayAutomationEvent(event: AutomationEvent);
3412}
3413extern "C" {
3414 pub fn IsKeyPressed(key: ::std::os::raw::c_int) -> bool;
3415}
3416extern "C" {
3417 pub fn IsKeyPressedRepeat(key: ::std::os::raw::c_int) -> bool;
3418}
3419extern "C" {
3420 pub fn IsKeyDown(key: ::std::os::raw::c_int) -> bool;
3421}
3422extern "C" {
3423 pub fn IsKeyReleased(key: ::std::os::raw::c_int) -> bool;
3424}
3425extern "C" {
3426 pub fn IsKeyUp(key: ::std::os::raw::c_int) -> bool;
3427}
3428extern "C" {
3429 pub fn GetKeyPressed() -> ::std::os::raw::c_int;
3430}
3431extern "C" {
3432 pub fn GetCharPressed() -> ::std::os::raw::c_int;
3433}
3434extern "C" {
3435 pub fn SetExitKey(key: ::std::os::raw::c_int);
3436}
3437extern "C" {
3438 pub fn IsGamepadAvailable(gamepad: ::std::os::raw::c_int) -> bool;
3439}
3440extern "C" {
3441 pub fn GetGamepadName(gamepad: ::std::os::raw::c_int) -> *const ::std::os::raw::c_char;
3442}
3443extern "C" {
3444 pub fn IsGamepadButtonPressed(
3445 gamepad: ::std::os::raw::c_int,
3446 button: ::std::os::raw::c_int,
3447 ) -> bool;
3448}
3449extern "C" {
3450 pub fn IsGamepadButtonDown(
3451 gamepad: ::std::os::raw::c_int,
3452 button: ::std::os::raw::c_int,
3453 ) -> bool;
3454}
3455extern "C" {
3456 pub fn IsGamepadButtonReleased(
3457 gamepad: ::std::os::raw::c_int,
3458 button: ::std::os::raw::c_int,
3459 ) -> bool;
3460}
3461extern "C" {
3462 pub fn IsGamepadButtonUp(gamepad: ::std::os::raw::c_int, button: ::std::os::raw::c_int)
3463 -> bool;
3464}
3465extern "C" {
3466 pub fn GetGamepadButtonPressed() -> ::std::os::raw::c_int;
3467}
3468extern "C" {
3469 pub fn GetGamepadAxisCount(gamepad: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
3470}
3471extern "C" {
3472 pub fn GetGamepadAxisMovement(
3473 gamepad: ::std::os::raw::c_int,
3474 axis: ::std::os::raw::c_int,
3475 ) -> f32;
3476}
3477extern "C" {
3478 pub fn SetGamepadMappings(mappings: *const ::std::os::raw::c_char) -> ::std::os::raw::c_int;
3479}
3480extern "C" {
3481 pub fn SetGamepadVibration(gamepad: ::std::os::raw::c_int, leftMotor: f32, rightMotor: f32);
3482}
3483extern "C" {
3484 pub fn IsMouseButtonPressed(button: ::std::os::raw::c_int) -> bool;
3485}
3486extern "C" {
3487 pub fn IsMouseButtonDown(button: ::std::os::raw::c_int) -> bool;
3488}
3489extern "C" {
3490 pub fn IsMouseButtonReleased(button: ::std::os::raw::c_int) -> bool;
3491}
3492extern "C" {
3493 pub fn IsMouseButtonUp(button: ::std::os::raw::c_int) -> bool;
3494}
3495extern "C" {
3496 pub fn GetMouseX() -> ::std::os::raw::c_int;
3497}
3498extern "C" {
3499 pub fn GetMouseY() -> ::std::os::raw::c_int;
3500}
3501extern "C" {
3502 pub fn GetMousePosition() -> Vector2;
3503}
3504extern "C" {
3505 pub fn GetMouseDelta() -> Vector2;
3506}
3507extern "C" {
3508 pub fn SetMousePosition(x: ::std::os::raw::c_int, y: ::std::os::raw::c_int);
3509}
3510extern "C" {
3511 pub fn SetMouseOffset(offsetX: ::std::os::raw::c_int, offsetY: ::std::os::raw::c_int);
3512}
3513extern "C" {
3514 pub fn SetMouseScale(scaleX: f32, scaleY: f32);
3515}
3516extern "C" {
3517 pub fn GetMouseWheelMove() -> f32;
3518}
3519extern "C" {
3520 pub fn GetMouseWheelMoveV() -> Vector2;
3521}
3522extern "C" {
3523 pub fn SetMouseCursor(cursor: ::std::os::raw::c_int);
3524}
3525extern "C" {
3526 pub fn GetTouchX() -> ::std::os::raw::c_int;
3527}
3528extern "C" {
3529 pub fn GetTouchY() -> ::std::os::raw::c_int;
3530}
3531extern "C" {
3532 pub fn GetTouchPosition(index: ::std::os::raw::c_int) -> Vector2;
3533}
3534extern "C" {
3535 pub fn GetTouchPointId(index: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
3536}
3537extern "C" {
3538 pub fn GetTouchPointCount() -> ::std::os::raw::c_int;
3539}
3540extern "C" {
3541 pub fn SetGesturesEnabled(flags: ::std::os::raw::c_uint);
3542}
3543extern "C" {
3544 pub fn IsGestureDetected(gesture: ::std::os::raw::c_uint) -> bool;
3545}
3546extern "C" {
3547 pub fn GetGestureDetected() -> ::std::os::raw::c_int;
3548}
3549extern "C" {
3550 pub fn GetGestureHoldDuration() -> f32;
3551}
3552extern "C" {
3553 pub fn GetGestureDragVector() -> Vector2;
3554}
3555extern "C" {
3556 pub fn GetGestureDragAngle() -> f32;
3557}
3558extern "C" {
3559 pub fn GetGesturePinchVector() -> Vector2;
3560}
3561extern "C" {
3562 pub fn GetGesturePinchAngle() -> f32;
3563}
3564extern "C" {
3565 pub fn UpdateCamera(camera: *mut Camera, mode: ::std::os::raw::c_int);
3566}
3567extern "C" {
3568 pub fn UpdateCameraPro(camera: *mut Camera, movement: Vector3, rotation: Vector3, zoom: f32);
3569}
3570extern "C" {
3571 pub fn SetShapesTexture(texture: Texture2D, source: Rectangle);
3572}
3573extern "C" {
3574 pub fn GetShapesTexture() -> Texture2D;
3575}
3576extern "C" {
3577 pub fn GetShapesTextureRectangle() -> Rectangle;
3578}
3579extern "C" {
3580 pub fn DrawPixel(posX: ::std::os::raw::c_int, posY: ::std::os::raw::c_int, color: Color);
3581}
3582extern "C" {
3583 pub fn DrawPixelV(position: Vector2, color: Color);
3584}
3585extern "C" {
3586 pub fn DrawLine(
3587 startPosX: ::std::os::raw::c_int,
3588 startPosY: ::std::os::raw::c_int,
3589 endPosX: ::std::os::raw::c_int,
3590 endPosY: ::std::os::raw::c_int,
3591 color: Color,
3592 );
3593}
3594extern "C" {
3595 pub fn DrawLineV(startPos: Vector2, endPos: Vector2, color: Color);
3596}
3597extern "C" {
3598 pub fn DrawLineEx(startPos: Vector2, endPos: Vector2, thick: f32, color: Color);
3599}
3600extern "C" {
3601 pub fn DrawLineStrip(points: *const Vector2, pointCount: ::std::os::raw::c_int, color: Color);
3602}
3603extern "C" {
3604 pub fn DrawLineBezier(startPos: Vector2, endPos: Vector2, thick: f32, color: Color);
3605}
3606extern "C" {
3607 pub fn DrawCircle(
3608 centerX: ::std::os::raw::c_int,
3609 centerY: ::std::os::raw::c_int,
3610 radius: f32,
3611 color: Color,
3612 );
3613}
3614extern "C" {
3615 pub fn DrawCircleSector(
3616 center: Vector2,
3617 radius: f32,
3618 startAngle: f32,
3619 endAngle: f32,
3620 segments: ::std::os::raw::c_int,
3621 color: Color,
3622 );
3623}
3624extern "C" {
3625 pub fn DrawCircleSectorLines(
3626 center: Vector2,
3627 radius: f32,
3628 startAngle: f32,
3629 endAngle: f32,
3630 segments: ::std::os::raw::c_int,
3631 color: Color,
3632 );
3633}
3634extern "C" {
3635 pub fn DrawCircleGradient(
3636 centerX: ::std::os::raw::c_int,
3637 centerY: ::std::os::raw::c_int,
3638 radius: f32,
3639 inner: Color,
3640 outer: Color,
3641 );
3642}
3643extern "C" {
3644 pub fn DrawCircleV(center: Vector2, radius: f32, color: Color);
3645}
3646extern "C" {
3647 pub fn DrawCircleLines(
3648 centerX: ::std::os::raw::c_int,
3649 centerY: ::std::os::raw::c_int,
3650 radius: f32,
3651 color: Color,
3652 );
3653}
3654extern "C" {
3655 pub fn DrawCircleLinesV(center: Vector2, radius: f32, color: Color);
3656}
3657extern "C" {
3658 pub fn DrawEllipse(
3659 centerX: ::std::os::raw::c_int,
3660 centerY: ::std::os::raw::c_int,
3661 radiusH: f32,
3662 radiusV: f32,
3663 color: Color,
3664 );
3665}
3666extern "C" {
3667 pub fn DrawEllipseLines(
3668 centerX: ::std::os::raw::c_int,
3669 centerY: ::std::os::raw::c_int,
3670 radiusH: f32,
3671 radiusV: f32,
3672 color: Color,
3673 );
3674}
3675extern "C" {
3676 pub fn DrawRing(
3677 center: Vector2,
3678 innerRadius: f32,
3679 outerRadius: f32,
3680 startAngle: f32,
3681 endAngle: f32,
3682 segments: ::std::os::raw::c_int,
3683 color: Color,
3684 );
3685}
3686extern "C" {
3687 pub fn DrawRingLines(
3688 center: Vector2,
3689 innerRadius: f32,
3690 outerRadius: f32,
3691 startAngle: f32,
3692 endAngle: f32,
3693 segments: ::std::os::raw::c_int,
3694 color: Color,
3695 );
3696}
3697extern "C" {
3698 pub fn DrawRectangle(
3699 posX: ::std::os::raw::c_int,
3700 posY: ::std::os::raw::c_int,
3701 width: ::std::os::raw::c_int,
3702 height: ::std::os::raw::c_int,
3703 color: Color,
3704 );
3705}
3706extern "C" {
3707 pub fn DrawRectangleV(position: Vector2, size: Vector2, color: Color);
3708}
3709extern "C" {
3710 pub fn DrawRectangleRec(rec: Rectangle, color: Color);
3711}
3712extern "C" {
3713 pub fn DrawRectanglePro(rec: Rectangle, origin: Vector2, rotation: f32, color: Color);
3714}
3715extern "C" {
3716 pub fn DrawRectangleGradientV(
3717 posX: ::std::os::raw::c_int,
3718 posY: ::std::os::raw::c_int,
3719 width: ::std::os::raw::c_int,
3720 height: ::std::os::raw::c_int,
3721 top: Color,
3722 bottom: Color,
3723 );
3724}
3725extern "C" {
3726 pub fn DrawRectangleGradientH(
3727 posX: ::std::os::raw::c_int,
3728 posY: ::std::os::raw::c_int,
3729 width: ::std::os::raw::c_int,
3730 height: ::std::os::raw::c_int,
3731 left: Color,
3732 right: Color,
3733 );
3734}
3735extern "C" {
3736 pub fn DrawRectangleGradientEx(
3737 rec: Rectangle,
3738 topLeft: Color,
3739 bottomLeft: Color,
3740 topRight: Color,
3741 bottomRight: Color,
3742 );
3743}
3744extern "C" {
3745 pub fn DrawRectangleLines(
3746 posX: ::std::os::raw::c_int,
3747 posY: ::std::os::raw::c_int,
3748 width: ::std::os::raw::c_int,
3749 height: ::std::os::raw::c_int,
3750 color: Color,
3751 );
3752}
3753extern "C" {
3754 pub fn DrawRectangleLinesEx(rec: Rectangle, lineThick: f32, color: Color);
3755}
3756extern "C" {
3757 pub fn DrawRectangleRounded(
3758 rec: Rectangle,
3759 roundness: f32,
3760 segments: ::std::os::raw::c_int,
3761 color: Color,
3762 );
3763}
3764extern "C" {
3765 pub fn DrawRectangleRoundedLines(
3766 rec: Rectangle,
3767 roundness: f32,
3768 segments: ::std::os::raw::c_int,
3769 color: Color,
3770 );
3771}
3772extern "C" {
3773 pub fn DrawRectangleRoundedLinesEx(
3774 rec: Rectangle,
3775 roundness: f32,
3776 segments: ::std::os::raw::c_int,
3777 lineThick: f32,
3778 color: Color,
3779 );
3780}
3781extern "C" {
3782 pub fn DrawTriangle(v1: Vector2, v2: Vector2, v3: Vector2, color: Color);
3783}
3784extern "C" {
3785 pub fn DrawTriangleLines(v1: Vector2, v2: Vector2, v3: Vector2, color: Color);
3786}
3787extern "C" {
3788 pub fn DrawTriangleFan(points: *const Vector2, pointCount: ::std::os::raw::c_int, color: Color);
3789}
3790extern "C" {
3791 pub fn DrawTriangleStrip(
3792 points: *const Vector2,
3793 pointCount: ::std::os::raw::c_int,
3794 color: Color,
3795 );
3796}
3797extern "C" {
3798 pub fn DrawPoly(
3799 center: Vector2,
3800 sides: ::std::os::raw::c_int,
3801 radius: f32,
3802 rotation: f32,
3803 color: Color,
3804 );
3805}
3806extern "C" {
3807 pub fn DrawPolyLines(
3808 center: Vector2,
3809 sides: ::std::os::raw::c_int,
3810 radius: f32,
3811 rotation: f32,
3812 color: Color,
3813 );
3814}
3815extern "C" {
3816 pub fn DrawPolyLinesEx(
3817 center: Vector2,
3818 sides: ::std::os::raw::c_int,
3819 radius: f32,
3820 rotation: f32,
3821 lineThick: f32,
3822 color: Color,
3823 );
3824}
3825extern "C" {
3826 pub fn DrawSplineLinear(
3827 points: *const Vector2,
3828 pointCount: ::std::os::raw::c_int,
3829 thick: f32,
3830 color: Color,
3831 );
3832}
3833extern "C" {
3834 pub fn DrawSplineBasis(
3835 points: *const Vector2,
3836 pointCount: ::std::os::raw::c_int,
3837 thick: f32,
3838 color: Color,
3839 );
3840}
3841extern "C" {
3842 pub fn DrawSplineCatmullRom(
3843 points: *const Vector2,
3844 pointCount: ::std::os::raw::c_int,
3845 thick: f32,
3846 color: Color,
3847 );
3848}
3849extern "C" {
3850 pub fn DrawSplineBezierQuadratic(
3851 points: *const Vector2,
3852 pointCount: ::std::os::raw::c_int,
3853 thick: f32,
3854 color: Color,
3855 );
3856}
3857extern "C" {
3858 pub fn DrawSplineBezierCubic(
3859 points: *const Vector2,
3860 pointCount: ::std::os::raw::c_int,
3861 thick: f32,
3862 color: Color,
3863 );
3864}
3865extern "C" {
3866 pub fn DrawSplineSegmentLinear(p1: Vector2, p2: Vector2, thick: f32, color: Color);
3867}
3868extern "C" {
3869 pub fn DrawSplineSegmentBasis(
3870 p1: Vector2,
3871 p2: Vector2,
3872 p3: Vector2,
3873 p4: Vector2,
3874 thick: f32,
3875 color: Color,
3876 );
3877}
3878extern "C" {
3879 pub fn DrawSplineSegmentCatmullRom(
3880 p1: Vector2,
3881 p2: Vector2,
3882 p3: Vector2,
3883 p4: Vector2,
3884 thick: f32,
3885 color: Color,
3886 );
3887}
3888extern "C" {
3889 pub fn DrawSplineSegmentBezierQuadratic(
3890 p1: Vector2,
3891 c2: Vector2,
3892 p3: Vector2,
3893 thick: f32,
3894 color: Color,
3895 );
3896}
3897extern "C" {
3898 pub fn DrawSplineSegmentBezierCubic(
3899 p1: Vector2,
3900 c2: Vector2,
3901 c3: Vector2,
3902 p4: Vector2,
3903 thick: f32,
3904 color: Color,
3905 );
3906}
3907extern "C" {
3908 pub fn GetSplinePointLinear(startPos: Vector2, endPos: Vector2, t: f32) -> Vector2;
3909}
3910extern "C" {
3911 pub fn GetSplinePointBasis(
3912 p1: Vector2,
3913 p2: Vector2,
3914 p3: Vector2,
3915 p4: Vector2,
3916 t: f32,
3917 ) -> Vector2;
3918}
3919extern "C" {
3920 pub fn GetSplinePointCatmullRom(
3921 p1: Vector2,
3922 p2: Vector2,
3923 p3: Vector2,
3924 p4: Vector2,
3925 t: f32,
3926 ) -> Vector2;
3927}
3928extern "C" {
3929 pub fn GetSplinePointBezierQuad(p1: Vector2, c2: Vector2, p3: Vector2, t: f32) -> Vector2;
3930}
3931extern "C" {
3932 pub fn GetSplinePointBezierCubic(
3933 p1: Vector2,
3934 c2: Vector2,
3935 c3: Vector2,
3936 p4: Vector2,
3937 t: f32,
3938 ) -> Vector2;
3939}
3940extern "C" {
3941 pub fn CheckCollisionRecs(rec1: Rectangle, rec2: Rectangle) -> bool;
3942}
3943extern "C" {
3944 pub fn CheckCollisionCircles(
3945 center1: Vector2,
3946 radius1: f32,
3947 center2: Vector2,
3948 radius2: f32,
3949 ) -> bool;
3950}
3951extern "C" {
3952 pub fn CheckCollisionCircleRec(center: Vector2, radius: f32, rec: Rectangle) -> bool;
3953}
3954extern "C" {
3955 pub fn CheckCollisionPointRec(point: Vector2, rec: Rectangle) -> bool;
3956}
3957extern "C" {
3958 pub fn CheckCollisionPointCircle(point: Vector2, center: Vector2, radius: f32) -> bool;
3959}
3960extern "C" {
3961 pub fn CheckCollisionPointTriangle(
3962 point: Vector2,
3963 p1: Vector2,
3964 p2: Vector2,
3965 p3: Vector2,
3966 ) -> bool;
3967}
3968extern "C" {
3969 pub fn CheckCollisionPointPoly(
3970 point: Vector2,
3971 points: *const Vector2,
3972 pointCount: ::std::os::raw::c_int,
3973 ) -> bool;
3974}
3975extern "C" {
3976 pub fn CheckCollisionLines(
3977 startPos1: Vector2,
3978 endPos1: Vector2,
3979 startPos2: Vector2,
3980 endPos2: Vector2,
3981 collisionPoint: *mut Vector2,
3982 ) -> bool;
3983}
3984extern "C" {
3985 pub fn CheckCollisionPointLine(
3986 point: Vector2,
3987 p1: Vector2,
3988 p2: Vector2,
3989 threshold: ::std::os::raw::c_int,
3990 ) -> bool;
3991}
3992extern "C" {
3993 pub fn CheckCollisionCircleLine(center: Vector2, radius: f32, p1: Vector2, p2: Vector2)
3994 -> bool;
3995}
3996extern "C" {
3997 pub fn GetCollisionRec(rec1: Rectangle, rec2: Rectangle) -> Rectangle;
3998}
3999extern "C" {
4000 pub fn LoadImage(fileName: *const ::std::os::raw::c_char) -> Image;
4001}
4002extern "C" {
4003 pub fn LoadImageRaw(
4004 fileName: *const ::std::os::raw::c_char,
4005 width: ::std::os::raw::c_int,
4006 height: ::std::os::raw::c_int,
4007 format: ::std::os::raw::c_int,
4008 headerSize: ::std::os::raw::c_int,
4009 ) -> Image;
4010}
4011extern "C" {
4012 pub fn LoadImageSvg(
4013 fileNameOrString: *const ::std::os::raw::c_char,
4014 width: ::std::os::raw::c_int,
4015 height: ::std::os::raw::c_int,
4016 ) -> Image;
4017}
4018extern "C" {
4019 pub fn LoadImageAnim(
4020 fileName: *const ::std::os::raw::c_char,
4021 frames: *mut ::std::os::raw::c_int,
4022 ) -> Image;
4023}
4024extern "C" {
4025 pub fn LoadImageAnimFromMemory(
4026 fileType: *const ::std::os::raw::c_char,
4027 fileData: *const ::std::os::raw::c_uchar,
4028 dataSize: ::std::os::raw::c_int,
4029 frames: *mut ::std::os::raw::c_int,
4030 ) -> Image;
4031}
4032extern "C" {
4033 pub fn LoadImageFromMemory(
4034 fileType: *const ::std::os::raw::c_char,
4035 fileData: *const ::std::os::raw::c_uchar,
4036 dataSize: ::std::os::raw::c_int,
4037 ) -> Image;
4038}
4039extern "C" {
4040 pub fn LoadImageFromTexture(texture: Texture2D) -> Image;
4041}
4042extern "C" {
4043 pub fn LoadImageFromScreen() -> Image;
4044}
4045extern "C" {
4046 pub fn IsImageReady(image: Image) -> bool;
4047}
4048extern "C" {
4049 pub fn UnloadImage(image: Image);
4050}
4051extern "C" {
4052 pub fn ExportImage(image: Image, fileName: *const ::std::os::raw::c_char) -> bool;
4053}
4054extern "C" {
4055 pub fn ExportImageToMemory(
4056 image: Image,
4057 fileType: *const ::std::os::raw::c_char,
4058 fileSize: *mut ::std::os::raw::c_int,
4059 ) -> *mut ::std::os::raw::c_uchar;
4060}
4061extern "C" {
4062 pub fn ExportImageAsCode(image: Image, fileName: *const ::std::os::raw::c_char) -> bool;
4063}
4064extern "C" {
4065 pub fn GenImageColor(
4066 width: ::std::os::raw::c_int,
4067 height: ::std::os::raw::c_int,
4068 color: Color,
4069 ) -> Image;
4070}
4071extern "C" {
4072 pub fn GenImageGradientLinear(
4073 width: ::std::os::raw::c_int,
4074 height: ::std::os::raw::c_int,
4075 direction: ::std::os::raw::c_int,
4076 start: Color,
4077 end: Color,
4078 ) -> Image;
4079}
4080extern "C" {
4081 pub fn GenImageGradientRadial(
4082 width: ::std::os::raw::c_int,
4083 height: ::std::os::raw::c_int,
4084 density: f32,
4085 inner: Color,
4086 outer: Color,
4087 ) -> Image;
4088}
4089extern "C" {
4090 pub fn GenImageGradientSquare(
4091 width: ::std::os::raw::c_int,
4092 height: ::std::os::raw::c_int,
4093 density: f32,
4094 inner: Color,
4095 outer: Color,
4096 ) -> Image;
4097}
4098extern "C" {
4099 pub fn GenImageChecked(
4100 width: ::std::os::raw::c_int,
4101 height: ::std::os::raw::c_int,
4102 checksX: ::std::os::raw::c_int,
4103 checksY: ::std::os::raw::c_int,
4104 col1: Color,
4105 col2: Color,
4106 ) -> Image;
4107}
4108extern "C" {
4109 pub fn GenImageWhiteNoise(
4110 width: ::std::os::raw::c_int,
4111 height: ::std::os::raw::c_int,
4112 factor: f32,
4113 ) -> Image;
4114}
4115extern "C" {
4116 pub fn GenImagePerlinNoise(
4117 width: ::std::os::raw::c_int,
4118 height: ::std::os::raw::c_int,
4119 offsetX: ::std::os::raw::c_int,
4120 offsetY: ::std::os::raw::c_int,
4121 scale: f32,
4122 ) -> Image;
4123}
4124extern "C" {
4125 pub fn GenImageCellular(
4126 width: ::std::os::raw::c_int,
4127 height: ::std::os::raw::c_int,
4128 tileSize: ::std::os::raw::c_int,
4129 ) -> Image;
4130}
4131extern "C" {
4132 pub fn GenImageText(
4133 width: ::std::os::raw::c_int,
4134 height: ::std::os::raw::c_int,
4135 text: *const ::std::os::raw::c_char,
4136 ) -> Image;
4137}
4138extern "C" {
4139 pub fn ImageCopy(image: Image) -> Image;
4140}
4141extern "C" {
4142 pub fn ImageFromImage(image: Image, rec: Rectangle) -> Image;
4143}
4144extern "C" {
4145 pub fn ImageFromChannel(image: Image, selectedChannel: ::std::os::raw::c_int) -> Image;
4146}
4147extern "C" {
4148 pub fn ImageText(
4149 text: *const ::std::os::raw::c_char,
4150 fontSize: ::std::os::raw::c_int,
4151 color: Color,
4152 ) -> Image;
4153}
4154extern "C" {
4155 pub fn ImageTextEx(
4156 font: Font,
4157 text: *const ::std::os::raw::c_char,
4158 fontSize: f32,
4159 spacing: f32,
4160 tint: Color,
4161 ) -> Image;
4162}
4163extern "C" {
4164 pub fn ImageFormat(image: *mut Image, newFormat: ::std::os::raw::c_int);
4165}
4166extern "C" {
4167 pub fn ImageToPOT(image: *mut Image, fill: Color);
4168}
4169extern "C" {
4170 pub fn ImageCrop(image: *mut Image, crop: Rectangle);
4171}
4172extern "C" {
4173 pub fn ImageAlphaCrop(image: *mut Image, threshold: f32);
4174}
4175extern "C" {
4176 pub fn ImageAlphaClear(image: *mut Image, color: Color, threshold: f32);
4177}
4178extern "C" {
4179 pub fn ImageAlphaMask(image: *mut Image, alphaMask: Image);
4180}
4181extern "C" {
4182 pub fn ImageAlphaPremultiply(image: *mut Image);
4183}
4184extern "C" {
4185 pub fn ImageBlurGaussian(image: *mut Image, blurSize: ::std::os::raw::c_int);
4186}
4187extern "C" {
4188 pub fn ImageKernelConvolution(
4189 image: *mut Image,
4190 kernel: *const f32,
4191 kernelSize: ::std::os::raw::c_int,
4192 );
4193}
4194extern "C" {
4195 pub fn ImageResize(
4196 image: *mut Image,
4197 newWidth: ::std::os::raw::c_int,
4198 newHeight: ::std::os::raw::c_int,
4199 );
4200}
4201extern "C" {
4202 pub fn ImageResizeNN(
4203 image: *mut Image,
4204 newWidth: ::std::os::raw::c_int,
4205 newHeight: ::std::os::raw::c_int,
4206 );
4207}
4208extern "C" {
4209 pub fn ImageResizeCanvas(
4210 image: *mut Image,
4211 newWidth: ::std::os::raw::c_int,
4212 newHeight: ::std::os::raw::c_int,
4213 offsetX: ::std::os::raw::c_int,
4214 offsetY: ::std::os::raw::c_int,
4215 fill: Color,
4216 );
4217}
4218extern "C" {
4219 pub fn ImageMipmaps(image: *mut Image);
4220}
4221extern "C" {
4222 pub fn ImageDither(
4223 image: *mut Image,
4224 rBpp: ::std::os::raw::c_int,
4225 gBpp: ::std::os::raw::c_int,
4226 bBpp: ::std::os::raw::c_int,
4227 aBpp: ::std::os::raw::c_int,
4228 );
4229}
4230extern "C" {
4231 pub fn ImageFlipVertical(image: *mut Image);
4232}
4233extern "C" {
4234 pub fn ImageFlipHorizontal(image: *mut Image);
4235}
4236extern "C" {
4237 pub fn ImageRotate(image: *mut Image, degrees: ::std::os::raw::c_int);
4238}
4239extern "C" {
4240 pub fn ImageRotateCW(image: *mut Image);
4241}
4242extern "C" {
4243 pub fn ImageRotateCCW(image: *mut Image);
4244}
4245extern "C" {
4246 pub fn ImageColorTint(image: *mut Image, color: Color);
4247}
4248extern "C" {
4249 pub fn ImageColorInvert(image: *mut Image);
4250}
4251extern "C" {
4252 pub fn ImageColorGrayscale(image: *mut Image);
4253}
4254extern "C" {
4255 pub fn ImageColorContrast(image: *mut Image, contrast: f32);
4256}
4257extern "C" {
4258 pub fn ImageColorBrightness(image: *mut Image, brightness: ::std::os::raw::c_int);
4259}
4260extern "C" {
4261 pub fn ImageColorReplace(image: *mut Image, color: Color, replace: Color);
4262}
4263extern "C" {
4264 pub fn LoadImageColors(image: Image) -> *mut Color;
4265}
4266extern "C" {
4267 pub fn LoadImagePalette(
4268 image: Image,
4269 maxPaletteSize: ::std::os::raw::c_int,
4270 colorCount: *mut ::std::os::raw::c_int,
4271 ) -> *mut Color;
4272}
4273extern "C" {
4274 pub fn UnloadImageColors(colors: *mut Color);
4275}
4276extern "C" {
4277 pub fn UnloadImagePalette(colors: *mut Color);
4278}
4279extern "C" {
4280 pub fn GetImageAlphaBorder(image: Image, threshold: f32) -> Rectangle;
4281}
4282extern "C" {
4283 pub fn GetImageColor(image: Image, x: ::std::os::raw::c_int, y: ::std::os::raw::c_int)
4284 -> Color;
4285}
4286extern "C" {
4287 pub fn ImageClearBackground(dst: *mut Image, color: Color);
4288}
4289extern "C" {
4290 pub fn ImageDrawPixel(
4291 dst: *mut Image,
4292 posX: ::std::os::raw::c_int,
4293 posY: ::std::os::raw::c_int,
4294 color: Color,
4295 );
4296}
4297extern "C" {
4298 pub fn ImageDrawPixelV(dst: *mut Image, position: Vector2, color: Color);
4299}
4300extern "C" {
4301 pub fn ImageDrawLine(
4302 dst: *mut Image,
4303 startPosX: ::std::os::raw::c_int,
4304 startPosY: ::std::os::raw::c_int,
4305 endPosX: ::std::os::raw::c_int,
4306 endPosY: ::std::os::raw::c_int,
4307 color: Color,
4308 );
4309}
4310extern "C" {
4311 pub fn ImageDrawLineV(dst: *mut Image, start: Vector2, end: Vector2, color: Color);
4312}
4313extern "C" {
4314 pub fn ImageDrawLineEx(
4315 dst: *mut Image,
4316 start: Vector2,
4317 end: Vector2,
4318 thick: ::std::os::raw::c_int,
4319 color: Color,
4320 );
4321}
4322extern "C" {
4323 pub fn ImageDrawCircle(
4324 dst: *mut Image,
4325 centerX: ::std::os::raw::c_int,
4326 centerY: ::std::os::raw::c_int,
4327 radius: ::std::os::raw::c_int,
4328 color: Color,
4329 );
4330}
4331extern "C" {
4332 pub fn ImageDrawCircleV(
4333 dst: *mut Image,
4334 center: Vector2,
4335 radius: ::std::os::raw::c_int,
4336 color: Color,
4337 );
4338}
4339extern "C" {
4340 pub fn ImageDrawCircleLines(
4341 dst: *mut Image,
4342 centerX: ::std::os::raw::c_int,
4343 centerY: ::std::os::raw::c_int,
4344 radius: ::std::os::raw::c_int,
4345 color: Color,
4346 );
4347}
4348extern "C" {
4349 pub fn ImageDrawCircleLinesV(
4350 dst: *mut Image,
4351 center: Vector2,
4352 radius: ::std::os::raw::c_int,
4353 color: Color,
4354 );
4355}
4356extern "C" {
4357 pub fn ImageDrawRectangle(
4358 dst: *mut Image,
4359 posX: ::std::os::raw::c_int,
4360 posY: ::std::os::raw::c_int,
4361 width: ::std::os::raw::c_int,
4362 height: ::std::os::raw::c_int,
4363 color: Color,
4364 );
4365}
4366extern "C" {
4367 pub fn ImageDrawRectangleV(dst: *mut Image, position: Vector2, size: Vector2, color: Color);
4368}
4369extern "C" {
4370 pub fn ImageDrawRectangleRec(dst: *mut Image, rec: Rectangle, color: Color);
4371}
4372extern "C" {
4373 pub fn ImageDrawRectangleLines(
4374 dst: *mut Image,
4375 rec: Rectangle,
4376 thick: ::std::os::raw::c_int,
4377 color: Color,
4378 );
4379}
4380extern "C" {
4381 pub fn ImageDrawTriangle(dst: *mut Image, v1: Vector2, v2: Vector2, v3: Vector2, color: Color);
4382}
4383extern "C" {
4384 pub fn ImageDrawTriangleEx(
4385 dst: *mut Image,
4386 v1: Vector2,
4387 v2: Vector2,
4388 v3: Vector2,
4389 c1: Color,
4390 c2: Color,
4391 c3: Color,
4392 );
4393}
4394extern "C" {
4395 pub fn ImageDrawTriangleLines(
4396 dst: *mut Image,
4397 v1: Vector2,
4398 v2: Vector2,
4399 v3: Vector2,
4400 color: Color,
4401 );
4402}
4403extern "C" {
4404 pub fn ImageDrawTriangleFan(
4405 dst: *mut Image,
4406 points: *mut Vector2,
4407 pointCount: ::std::os::raw::c_int,
4408 color: Color,
4409 );
4410}
4411extern "C" {
4412 pub fn ImageDrawTriangleStrip(
4413 dst: *mut Image,
4414 points: *mut Vector2,
4415 pointCount: ::std::os::raw::c_int,
4416 color: Color,
4417 );
4418}
4419extern "C" {
4420 pub fn ImageDraw(
4421 dst: *mut Image,
4422 src: Image,
4423 srcRec: Rectangle,
4424 dstRec: Rectangle,
4425 tint: Color,
4426 );
4427}
4428extern "C" {
4429 pub fn ImageDrawText(
4430 dst: *mut Image,
4431 text: *const ::std::os::raw::c_char,
4432 posX: ::std::os::raw::c_int,
4433 posY: ::std::os::raw::c_int,
4434 fontSize: ::std::os::raw::c_int,
4435 color: Color,
4436 );
4437}
4438extern "C" {
4439 pub fn ImageDrawTextEx(
4440 dst: *mut Image,
4441 font: Font,
4442 text: *const ::std::os::raw::c_char,
4443 position: Vector2,
4444 fontSize: f32,
4445 spacing: f32,
4446 tint: Color,
4447 );
4448}
4449extern "C" {
4450 pub fn LoadTexture(fileName: *const ::std::os::raw::c_char) -> Texture2D;
4451}
4452extern "C" {
4453 pub fn LoadTextureFromImage(image: Image) -> Texture2D;
4454}
4455extern "C" {
4456 pub fn LoadTextureCubemap(image: Image, layout: ::std::os::raw::c_int) -> TextureCubemap;
4457}
4458extern "C" {
4459 pub fn LoadRenderTexture(
4460 width: ::std::os::raw::c_int,
4461 height: ::std::os::raw::c_int,
4462 ) -> RenderTexture2D;
4463}
4464extern "C" {
4465 pub fn IsTextureReady(texture: Texture2D) -> bool;
4466}
4467extern "C" {
4468 pub fn UnloadTexture(texture: Texture2D);
4469}
4470extern "C" {
4471 pub fn IsRenderTextureReady(target: RenderTexture2D) -> bool;
4472}
4473extern "C" {
4474 pub fn UnloadRenderTexture(target: RenderTexture2D);
4475}
4476extern "C" {
4477 pub fn UpdateTexture(texture: Texture2D, pixels: *const ::std::os::raw::c_void);
4478}
4479extern "C" {
4480 pub fn UpdateTextureRec(
4481 texture: Texture2D,
4482 rec: Rectangle,
4483 pixels: *const ::std::os::raw::c_void,
4484 );
4485}
4486extern "C" {
4487 pub fn GenTextureMipmaps(texture: *mut Texture2D);
4488}
4489extern "C" {
4490 pub fn SetTextureFilter(texture: Texture2D, filter: ::std::os::raw::c_int);
4491}
4492extern "C" {
4493 pub fn SetTextureWrap(texture: Texture2D, wrap: ::std::os::raw::c_int);
4494}
4495extern "C" {
4496 pub fn DrawTexture(
4497 texture: Texture2D,
4498 posX: ::std::os::raw::c_int,
4499 posY: ::std::os::raw::c_int,
4500 tint: Color,
4501 );
4502}
4503extern "C" {
4504 pub fn DrawTextureV(texture: Texture2D, position: Vector2, tint: Color);
4505}
4506extern "C" {
4507 pub fn DrawTextureEx(
4508 texture: Texture2D,
4509 position: Vector2,
4510 rotation: f32,
4511 scale: f32,
4512 tint: Color,
4513 );
4514}
4515extern "C" {
4516 pub fn DrawTextureRec(texture: Texture2D, source: Rectangle, position: Vector2, tint: Color);
4517}
4518extern "C" {
4519 pub fn DrawTexturePro(
4520 texture: Texture2D,
4521 source: Rectangle,
4522 dest: Rectangle,
4523 origin: Vector2,
4524 rotation: f32,
4525 tint: Color,
4526 );
4527}
4528extern "C" {
4529 pub fn DrawTextureNPatch(
4530 texture: Texture2D,
4531 nPatchInfo: NPatchInfo,
4532 dest: Rectangle,
4533 origin: Vector2,
4534 rotation: f32,
4535 tint: Color,
4536 );
4537}
4538extern "C" {
4539 pub fn ColorIsEqual(col1: Color, col2: Color) -> bool;
4540}
4541extern "C" {
4542 pub fn Fade(color: Color, alpha: f32) -> Color;
4543}
4544extern "C" {
4545 pub fn ColorToInt(color: Color) -> ::std::os::raw::c_int;
4546}
4547extern "C" {
4548 pub fn ColorNormalize(color: Color) -> Vector4;
4549}
4550extern "C" {
4551 pub fn ColorFromNormalized(normalized: Vector4) -> Color;
4552}
4553extern "C" {
4554 pub fn ColorToHSV(color: Color) -> Vector3;
4555}
4556extern "C" {
4557 pub fn ColorFromHSV(hue: f32, saturation: f32, value: f32) -> Color;
4558}
4559extern "C" {
4560 pub fn ColorTint(color: Color, tint: Color) -> Color;
4561}
4562extern "C" {
4563 pub fn ColorBrightness(color: Color, factor: f32) -> Color;
4564}
4565extern "C" {
4566 pub fn ColorContrast(color: Color, contrast: f32) -> Color;
4567}
4568extern "C" {
4569 pub fn ColorAlpha(color: Color, alpha: f32) -> Color;
4570}
4571extern "C" {
4572 pub fn ColorAlphaBlend(dst: Color, src: Color, tint: Color) -> Color;
4573}
4574extern "C" {
4575 pub fn ColorLerp(color1: Color, color2: Color, factor: f32) -> Color;
4576}
4577extern "C" {
4578 pub fn GetColor(hexValue: ::std::os::raw::c_uint) -> Color;
4579}
4580extern "C" {
4581 pub fn GetPixelColor(
4582 srcPtr: *mut ::std::os::raw::c_void,
4583 format: ::std::os::raw::c_int,
4584 ) -> Color;
4585}
4586extern "C" {
4587 pub fn SetPixelColor(
4588 dstPtr: *mut ::std::os::raw::c_void,
4589 color: Color,
4590 format: ::std::os::raw::c_int,
4591 );
4592}
4593extern "C" {
4594 pub fn GetPixelDataSize(
4595 width: ::std::os::raw::c_int,
4596 height: ::std::os::raw::c_int,
4597 format: ::std::os::raw::c_int,
4598 ) -> ::std::os::raw::c_int;
4599}
4600extern "C" {
4601 pub fn GetFontDefault() -> Font;
4602}
4603extern "C" {
4604 pub fn LoadFont(fileName: *const ::std::os::raw::c_char) -> Font;
4605}
4606extern "C" {
4607 pub fn LoadFontEx(
4608 fileName: *const ::std::os::raw::c_char,
4609 fontSize: ::std::os::raw::c_int,
4610 codepoints: *mut ::std::os::raw::c_int,
4611 codepointCount: ::std::os::raw::c_int,
4612 ) -> Font;
4613}
4614extern "C" {
4615 pub fn LoadFontFromImage(image: Image, key: Color, firstChar: ::std::os::raw::c_int) -> Font;
4616}
4617extern "C" {
4618 pub fn LoadFontFromMemory(
4619 fileType: *const ::std::os::raw::c_char,
4620 fileData: *const ::std::os::raw::c_uchar,
4621 dataSize: ::std::os::raw::c_int,
4622 fontSize: ::std::os::raw::c_int,
4623 codepoints: *mut ::std::os::raw::c_int,
4624 codepointCount: ::std::os::raw::c_int,
4625 ) -> Font;
4626}
4627extern "C" {
4628 pub fn IsFontReady(font: Font) -> bool;
4629}
4630extern "C" {
4631 pub fn LoadFontData(
4632 fileData: *const ::std::os::raw::c_uchar,
4633 dataSize: ::std::os::raw::c_int,
4634 fontSize: ::std::os::raw::c_int,
4635 codepoints: *mut ::std::os::raw::c_int,
4636 codepointCount: ::std::os::raw::c_int,
4637 type_: ::std::os::raw::c_int,
4638 ) -> *mut GlyphInfo;
4639}
4640extern "C" {
4641 pub fn GenImageFontAtlas(
4642 glyphs: *const GlyphInfo,
4643 glyphRecs: *mut *mut Rectangle,
4644 glyphCount: ::std::os::raw::c_int,
4645 fontSize: ::std::os::raw::c_int,
4646 padding: ::std::os::raw::c_int,
4647 packMethod: ::std::os::raw::c_int,
4648 ) -> Image;
4649}
4650extern "C" {
4651 pub fn UnloadFontData(glyphs: *mut GlyphInfo, glyphCount: ::std::os::raw::c_int);
4652}
4653extern "C" {
4654 pub fn UnloadFont(font: Font);
4655}
4656extern "C" {
4657 pub fn ExportFontAsCode(font: Font, fileName: *const ::std::os::raw::c_char) -> bool;
4658}
4659extern "C" {
4660 pub fn DrawFPS(posX: ::std::os::raw::c_int, posY: ::std::os::raw::c_int);
4661}
4662extern "C" {
4663 pub fn DrawText(
4664 text: *const ::std::os::raw::c_char,
4665 posX: ::std::os::raw::c_int,
4666 posY: ::std::os::raw::c_int,
4667 fontSize: ::std::os::raw::c_int,
4668 color: Color,
4669 );
4670}
4671extern "C" {
4672 pub fn DrawTextEx(
4673 font: Font,
4674 text: *const ::std::os::raw::c_char,
4675 position: Vector2,
4676 fontSize: f32,
4677 spacing: f32,
4678 tint: Color,
4679 );
4680}
4681extern "C" {
4682 pub fn DrawTextPro(
4683 font: Font,
4684 text: *const ::std::os::raw::c_char,
4685 position: Vector2,
4686 origin: Vector2,
4687 rotation: f32,
4688 fontSize: f32,
4689 spacing: f32,
4690 tint: Color,
4691 );
4692}
4693extern "C" {
4694 pub fn DrawTextCodepoint(
4695 font: Font,
4696 codepoint: ::std::os::raw::c_int,
4697 position: Vector2,
4698 fontSize: f32,
4699 tint: Color,
4700 );
4701}
4702extern "C" {
4703 pub fn DrawTextCodepoints(
4704 font: Font,
4705 codepoints: *const ::std::os::raw::c_int,
4706 codepointCount: ::std::os::raw::c_int,
4707 position: Vector2,
4708 fontSize: f32,
4709 spacing: f32,
4710 tint: Color,
4711 );
4712}
4713extern "C" {
4714 pub fn SetTextLineSpacing(spacing: ::std::os::raw::c_int);
4715}
4716extern "C" {
4717 pub fn MeasureText(
4718 text: *const ::std::os::raw::c_char,
4719 fontSize: ::std::os::raw::c_int,
4720 ) -> ::std::os::raw::c_int;
4721}
4722extern "C" {
4723 pub fn MeasureTextEx(
4724 font: Font,
4725 text: *const ::std::os::raw::c_char,
4726 fontSize: f32,
4727 spacing: f32,
4728 ) -> Vector2;
4729}
4730extern "C" {
4731 pub fn GetGlyphIndex(font: Font, codepoint: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
4732}
4733extern "C" {
4734 pub fn GetGlyphInfo(font: Font, codepoint: ::std::os::raw::c_int) -> GlyphInfo;
4735}
4736extern "C" {
4737 pub fn GetGlyphAtlasRec(font: Font, codepoint: ::std::os::raw::c_int) -> Rectangle;
4738}
4739extern "C" {
4740 pub fn LoadUTF8(
4741 codepoints: *const ::std::os::raw::c_int,
4742 length: ::std::os::raw::c_int,
4743 ) -> *mut ::std::os::raw::c_char;
4744}
4745extern "C" {
4746 pub fn UnloadUTF8(text: *mut ::std::os::raw::c_char);
4747}
4748extern "C" {
4749 pub fn LoadCodepoints(
4750 text: *const ::std::os::raw::c_char,
4751 count: *mut ::std::os::raw::c_int,
4752 ) -> *mut ::std::os::raw::c_int;
4753}
4754extern "C" {
4755 pub fn UnloadCodepoints(codepoints: *mut ::std::os::raw::c_int);
4756}
4757extern "C" {
4758 pub fn GetCodepointCount(text: *const ::std::os::raw::c_char) -> ::std::os::raw::c_int;
4759}
4760extern "C" {
4761 pub fn GetCodepoint(
4762 text: *const ::std::os::raw::c_char,
4763 codepointSize: *mut ::std::os::raw::c_int,
4764 ) -> ::std::os::raw::c_int;
4765}
4766extern "C" {
4767 pub fn GetCodepointNext(
4768 text: *const ::std::os::raw::c_char,
4769 codepointSize: *mut ::std::os::raw::c_int,
4770 ) -> ::std::os::raw::c_int;
4771}
4772extern "C" {
4773 pub fn GetCodepointPrevious(
4774 text: *const ::std::os::raw::c_char,
4775 codepointSize: *mut ::std::os::raw::c_int,
4776 ) -> ::std::os::raw::c_int;
4777}
4778extern "C" {
4779 pub fn CodepointToUTF8(
4780 codepoint: ::std::os::raw::c_int,
4781 utf8Size: *mut ::std::os::raw::c_int,
4782 ) -> *const ::std::os::raw::c_char;
4783}
4784extern "C" {
4785 pub fn TextCopy(
4786 dst: *mut ::std::os::raw::c_char,
4787 src: *const ::std::os::raw::c_char,
4788 ) -> ::std::os::raw::c_int;
4789}
4790extern "C" {
4791 pub fn TextIsEqual(
4792 text1: *const ::std::os::raw::c_char,
4793 text2: *const ::std::os::raw::c_char,
4794 ) -> bool;
4795}
4796extern "C" {
4797 pub fn TextLength(text: *const ::std::os::raw::c_char) -> ::std::os::raw::c_uint;
4798}
4799extern "C" {
4800 pub fn TextFormat(text: *const ::std::os::raw::c_char, ...) -> *const ::std::os::raw::c_char;
4801}
4802extern "C" {
4803 pub fn TextSubtext(
4804 text: *const ::std::os::raw::c_char,
4805 position: ::std::os::raw::c_int,
4806 length: ::std::os::raw::c_int,
4807 ) -> *const ::std::os::raw::c_char;
4808}
4809extern "C" {
4810 pub fn TextReplace(
4811 text: *const ::std::os::raw::c_char,
4812 replace: *const ::std::os::raw::c_char,
4813 by: *const ::std::os::raw::c_char,
4814 ) -> *mut ::std::os::raw::c_char;
4815}
4816extern "C" {
4817 pub fn TextInsert(
4818 text: *const ::std::os::raw::c_char,
4819 insert: *const ::std::os::raw::c_char,
4820 position: ::std::os::raw::c_int,
4821 ) -> *mut ::std::os::raw::c_char;
4822}
4823extern "C" {
4824 pub fn TextJoin(
4825 textList: *mut *const ::std::os::raw::c_char,
4826 count: ::std::os::raw::c_int,
4827 delimiter: *const ::std::os::raw::c_char,
4828 ) -> *const ::std::os::raw::c_char;
4829}
4830extern "C" {
4831 pub fn TextSplit(
4832 text: *const ::std::os::raw::c_char,
4833 delimiter: ::std::os::raw::c_char,
4834 count: *mut ::std::os::raw::c_int,
4835 ) -> *mut *const ::std::os::raw::c_char;
4836}
4837extern "C" {
4838 pub fn TextAppend(
4839 text: *mut ::std::os::raw::c_char,
4840 append: *const ::std::os::raw::c_char,
4841 position: *mut ::std::os::raw::c_int,
4842 );
4843}
4844extern "C" {
4845 pub fn TextFindIndex(
4846 text: *const ::std::os::raw::c_char,
4847 find: *const ::std::os::raw::c_char,
4848 ) -> ::std::os::raw::c_int;
4849}
4850extern "C" {
4851 pub fn TextToUpper(text: *const ::std::os::raw::c_char) -> *const ::std::os::raw::c_char;
4852}
4853extern "C" {
4854 pub fn TextToLower(text: *const ::std::os::raw::c_char) -> *const ::std::os::raw::c_char;
4855}
4856extern "C" {
4857 pub fn TextToPascal(text: *const ::std::os::raw::c_char) -> *const ::std::os::raw::c_char;
4858}
4859extern "C" {
4860 pub fn TextToSnake(text: *const ::std::os::raw::c_char) -> *const ::std::os::raw::c_char;
4861}
4862extern "C" {
4863 pub fn TextToCamel(text: *const ::std::os::raw::c_char) -> *const ::std::os::raw::c_char;
4864}
4865extern "C" {
4866 pub fn TextToInteger(text: *const ::std::os::raw::c_char) -> ::std::os::raw::c_int;
4867}
4868extern "C" {
4869 pub fn TextToFloat(text: *const ::std::os::raw::c_char) -> f32;
4870}
4871extern "C" {
4872 pub fn DrawLine3D(startPos: Vector3, endPos: Vector3, color: Color);
4873}
4874extern "C" {
4875 pub fn DrawPoint3D(position: Vector3, color: Color);
4876}
4877extern "C" {
4878 pub fn DrawCircle3D(
4879 center: Vector3,
4880 radius: f32,
4881 rotationAxis: Vector3,
4882 rotationAngle: f32,
4883 color: Color,
4884 );
4885}
4886extern "C" {
4887 pub fn DrawTriangle3D(v1: Vector3, v2: Vector3, v3: Vector3, color: Color);
4888}
4889extern "C" {
4890 pub fn DrawTriangleStrip3D(
4891 points: *const Vector3,
4892 pointCount: ::std::os::raw::c_int,
4893 color: Color,
4894 );
4895}
4896extern "C" {
4897 pub fn DrawCube(position: Vector3, width: f32, height: f32, length: f32, color: Color);
4898}
4899extern "C" {
4900 pub fn DrawCubeV(position: Vector3, size: Vector3, color: Color);
4901}
4902extern "C" {
4903 pub fn DrawCubeWires(position: Vector3, width: f32, height: f32, length: f32, color: Color);
4904}
4905extern "C" {
4906 pub fn DrawCubeWiresV(position: Vector3, size: Vector3, color: Color);
4907}
4908extern "C" {
4909 pub fn DrawSphere(centerPos: Vector3, radius: f32, color: Color);
4910}
4911extern "C" {
4912 pub fn DrawSphereEx(
4913 centerPos: Vector3,
4914 radius: f32,
4915 rings: ::std::os::raw::c_int,
4916 slices: ::std::os::raw::c_int,
4917 color: Color,
4918 );
4919}
4920extern "C" {
4921 pub fn DrawSphereWires(
4922 centerPos: Vector3,
4923 radius: f32,
4924 rings: ::std::os::raw::c_int,
4925 slices: ::std::os::raw::c_int,
4926 color: Color,
4927 );
4928}
4929extern "C" {
4930 pub fn DrawCylinder(
4931 position: Vector3,
4932 radiusTop: f32,
4933 radiusBottom: f32,
4934 height: f32,
4935 slices: ::std::os::raw::c_int,
4936 color: Color,
4937 );
4938}
4939extern "C" {
4940 pub fn DrawCylinderEx(
4941 startPos: Vector3,
4942 endPos: Vector3,
4943 startRadius: f32,
4944 endRadius: f32,
4945 sides: ::std::os::raw::c_int,
4946 color: Color,
4947 );
4948}
4949extern "C" {
4950 pub fn DrawCylinderWires(
4951 position: Vector3,
4952 radiusTop: f32,
4953 radiusBottom: f32,
4954 height: f32,
4955 slices: ::std::os::raw::c_int,
4956 color: Color,
4957 );
4958}
4959extern "C" {
4960 pub fn DrawCylinderWiresEx(
4961 startPos: Vector3,
4962 endPos: Vector3,
4963 startRadius: f32,
4964 endRadius: f32,
4965 sides: ::std::os::raw::c_int,
4966 color: Color,
4967 );
4968}
4969extern "C" {
4970 pub fn DrawCapsule(
4971 startPos: Vector3,
4972 endPos: Vector3,
4973 radius: f32,
4974 slices: ::std::os::raw::c_int,
4975 rings: ::std::os::raw::c_int,
4976 color: Color,
4977 );
4978}
4979extern "C" {
4980 pub fn DrawCapsuleWires(
4981 startPos: Vector3,
4982 endPos: Vector3,
4983 radius: f32,
4984 slices: ::std::os::raw::c_int,
4985 rings: ::std::os::raw::c_int,
4986 color: Color,
4987 );
4988}
4989extern "C" {
4990 pub fn DrawPlane(centerPos: Vector3, size: Vector2, color: Color);
4991}
4992extern "C" {
4993 pub fn DrawRay(ray: Ray, color: Color);
4994}
4995extern "C" {
4996 pub fn DrawGrid(slices: ::std::os::raw::c_int, spacing: f32);
4997}
4998extern "C" {
4999 pub fn LoadModel(fileName: *const ::std::os::raw::c_char) -> Model;
5000}
5001extern "C" {
5002 pub fn LoadModelFromMesh(mesh: Mesh) -> Model;
5003}
5004extern "C" {
5005 pub fn IsModelReady(model: Model) -> bool;
5006}
5007extern "C" {
5008 pub fn UnloadModel(model: Model);
5009}
5010extern "C" {
5011 pub fn GetModelBoundingBox(model: Model) -> BoundingBox;
5012}
5013extern "C" {
5014 pub fn DrawModel(model: Model, position: Vector3, scale: f32, tint: Color);
5015}
5016extern "C" {
5017 pub fn DrawModelEx(
5018 model: Model,
5019 position: Vector3,
5020 rotationAxis: Vector3,
5021 rotationAngle: f32,
5022 scale: Vector3,
5023 tint: Color,
5024 );
5025}
5026extern "C" {
5027 pub fn DrawModelWires(model: Model, position: Vector3, scale: f32, tint: Color);
5028}
5029extern "C" {
5030 pub fn DrawModelWiresEx(
5031 model: Model,
5032 position: Vector3,
5033 rotationAxis: Vector3,
5034 rotationAngle: f32,
5035 scale: Vector3,
5036 tint: Color,
5037 );
5038}
5039extern "C" {
5040 pub fn DrawModelPoints(model: Model, position: Vector3, scale: f32, tint: Color);
5041}
5042extern "C" {
5043 pub fn DrawModelPointsEx(
5044 model: Model,
5045 position: Vector3,
5046 rotationAxis: Vector3,
5047 rotationAngle: f32,
5048 scale: Vector3,
5049 tint: Color,
5050 );
5051}
5052extern "C" {
5053 pub fn DrawBoundingBox(box_: BoundingBox, color: Color);
5054}
5055extern "C" {
5056 pub fn DrawBillboard(
5057 camera: Camera,
5058 texture: Texture2D,
5059 position: Vector3,
5060 scale: f32,
5061 tint: Color,
5062 );
5063}
5064extern "C" {
5065 pub fn DrawBillboardRec(
5066 camera: Camera,
5067 texture: Texture2D,
5068 source: Rectangle,
5069 position: Vector3,
5070 size: Vector2,
5071 tint: Color,
5072 );
5073}
5074extern "C" {
5075 pub fn DrawBillboardPro(
5076 camera: Camera,
5077 texture: Texture2D,
5078 source: Rectangle,
5079 position: Vector3,
5080 up: Vector3,
5081 size: Vector2,
5082 origin: Vector2,
5083 rotation: f32,
5084 tint: Color,
5085 );
5086}
5087extern "C" {
5088 pub fn UploadMesh(mesh: *mut Mesh, dynamic: bool);
5089}
5090extern "C" {
5091 pub fn UpdateMeshBuffer(
5092 mesh: Mesh,
5093 index: ::std::os::raw::c_int,
5094 data: *const ::std::os::raw::c_void,
5095 dataSize: ::std::os::raw::c_int,
5096 offset: ::std::os::raw::c_int,
5097 );
5098}
5099extern "C" {
5100 pub fn UnloadMesh(mesh: Mesh);
5101}
5102extern "C" {
5103 pub fn DrawMesh(mesh: Mesh, material: Material, transform: Matrix);
5104}
5105extern "C" {
5106 pub fn DrawMeshInstanced(
5107 mesh: Mesh,
5108 material: Material,
5109 transforms: *const Matrix,
5110 instances: ::std::os::raw::c_int,
5111 );
5112}
5113extern "C" {
5114 pub fn GetMeshBoundingBox(mesh: Mesh) -> BoundingBox;
5115}
5116extern "C" {
5117 pub fn GenMeshTangents(mesh: *mut Mesh);
5118}
5119extern "C" {
5120 pub fn ExportMesh(mesh: Mesh, fileName: *const ::std::os::raw::c_char) -> bool;
5121}
5122extern "C" {
5123 pub fn ExportMeshAsCode(mesh: Mesh, fileName: *const ::std::os::raw::c_char) -> bool;
5124}
5125extern "C" {
5126 pub fn GenMeshPoly(sides: ::std::os::raw::c_int, radius: f32) -> Mesh;
5127}
5128extern "C" {
5129 pub fn GenMeshPlane(
5130 width: f32,
5131 length: f32,
5132 resX: ::std::os::raw::c_int,
5133 resZ: ::std::os::raw::c_int,
5134 ) -> Mesh;
5135}
5136extern "C" {
5137 pub fn GenMeshCube(width: f32, height: f32, length: f32) -> Mesh;
5138}
5139extern "C" {
5140 pub fn GenMeshSphere(
5141 radius: f32,
5142 rings: ::std::os::raw::c_int,
5143 slices: ::std::os::raw::c_int,
5144 ) -> Mesh;
5145}
5146extern "C" {
5147 pub fn GenMeshHemiSphere(
5148 radius: f32,
5149 rings: ::std::os::raw::c_int,
5150 slices: ::std::os::raw::c_int,
5151 ) -> Mesh;
5152}
5153extern "C" {
5154 pub fn GenMeshCylinder(radius: f32, height: f32, slices: ::std::os::raw::c_int) -> Mesh;
5155}
5156extern "C" {
5157 pub fn GenMeshCone(radius: f32, height: f32, slices: ::std::os::raw::c_int) -> Mesh;
5158}
5159extern "C" {
5160 pub fn GenMeshTorus(
5161 radius: f32,
5162 size: f32,
5163 radSeg: ::std::os::raw::c_int,
5164 sides: ::std::os::raw::c_int,
5165 ) -> Mesh;
5166}
5167extern "C" {
5168 pub fn GenMeshKnot(
5169 radius: f32,
5170 size: f32,
5171 radSeg: ::std::os::raw::c_int,
5172 sides: ::std::os::raw::c_int,
5173 ) -> Mesh;
5174}
5175extern "C" {
5176 pub fn GenMeshHeightmap(heightmap: Image, size: Vector3) -> Mesh;
5177}
5178extern "C" {
5179 pub fn GenMeshCubicmap(cubicmap: Image, cubeSize: Vector3) -> Mesh;
5180}
5181extern "C" {
5182 pub fn LoadMaterials(
5183 fileName: *const ::std::os::raw::c_char,
5184 materialCount: *mut ::std::os::raw::c_int,
5185 ) -> *mut Material;
5186}
5187extern "C" {
5188 pub fn LoadMaterialDefault() -> Material;
5189}
5190extern "C" {
5191 pub fn IsMaterialReady(material: Material) -> bool;
5192}
5193extern "C" {
5194 pub fn UnloadMaterial(material: Material);
5195}
5196extern "C" {
5197 pub fn SetMaterialTexture(
5198 material: *mut Material,
5199 mapType: ::std::os::raw::c_int,
5200 texture: Texture2D,
5201 );
5202}
5203extern "C" {
5204 pub fn SetModelMeshMaterial(
5205 model: *mut Model,
5206 meshId: ::std::os::raw::c_int,
5207 materialId: ::std::os::raw::c_int,
5208 );
5209}
5210extern "C" {
5211 pub fn LoadModelAnimations(
5212 fileName: *const ::std::os::raw::c_char,
5213 animCount: *mut ::std::os::raw::c_int,
5214 ) -> *mut ModelAnimation;
5215}
5216extern "C" {
5217 pub fn UpdateModelAnimation(model: Model, anim: ModelAnimation, frame: ::std::os::raw::c_int);
5218}
5219extern "C" {
5220 pub fn UnloadModelAnimation(anim: ModelAnimation);
5221}
5222extern "C" {
5223 pub fn UnloadModelAnimations(animations: *mut ModelAnimation, animCount: ::std::os::raw::c_int);
5224}
5225extern "C" {
5226 pub fn IsModelAnimationValid(model: Model, anim: ModelAnimation) -> bool;
5227}
5228extern "C" {
5229 pub fn UpdateModelAnimationBoneMatrices(
5230 model: Model,
5231 anim: ModelAnimation,
5232 frame: ::std::os::raw::c_int,
5233 );
5234}
5235extern "C" {
5236 pub fn CheckCollisionSpheres(
5237 center1: Vector3,
5238 radius1: f32,
5239 center2: Vector3,
5240 radius2: f32,
5241 ) -> bool;
5242}
5243extern "C" {
5244 pub fn CheckCollisionBoxes(box1: BoundingBox, box2: BoundingBox) -> bool;
5245}
5246extern "C" {
5247 pub fn CheckCollisionBoxSphere(box_: BoundingBox, center: Vector3, radius: f32) -> bool;
5248}
5249extern "C" {
5250 pub fn GetRayCollisionSphere(ray: Ray, center: Vector3, radius: f32) -> RayCollision;
5251}
5252extern "C" {
5253 pub fn GetRayCollisionBox(ray: Ray, box_: BoundingBox) -> RayCollision;
5254}
5255extern "C" {
5256 pub fn GetRayCollisionMesh(ray: Ray, mesh: Mesh, transform: Matrix) -> RayCollision;
5257}
5258extern "C" {
5259 pub fn GetRayCollisionTriangle(ray: Ray, p1: Vector3, p2: Vector3, p3: Vector3)
5260 -> RayCollision;
5261}
5262extern "C" {
5263 pub fn GetRayCollisionQuad(
5264 ray: Ray,
5265 p1: Vector3,
5266 p2: Vector3,
5267 p3: Vector3,
5268 p4: Vector3,
5269 ) -> RayCollision;
5270}
5271pub type AudioCallback = ::std::option::Option<
5272 unsafe extern "C" fn(bufferData: *mut ::std::os::raw::c_void, frames: ::std::os::raw::c_uint),
5273>;
5274extern "C" {
5275 pub fn InitAudioDevice();
5276}
5277extern "C" {
5278 pub fn CloseAudioDevice();
5279}
5280extern "C" {
5281 pub fn IsAudioDeviceReady() -> bool;
5282}
5283extern "C" {
5284 pub fn SetMasterVolume(volume: f32);
5285}
5286extern "C" {
5287 pub fn GetMasterVolume() -> f32;
5288}
5289extern "C" {
5290 pub fn LoadWave(fileName: *const ::std::os::raw::c_char) -> Wave;
5291}
5292extern "C" {
5293 pub fn LoadWaveFromMemory(
5294 fileType: *const ::std::os::raw::c_char,
5295 fileData: *const ::std::os::raw::c_uchar,
5296 dataSize: ::std::os::raw::c_int,
5297 ) -> Wave;
5298}
5299extern "C" {
5300 pub fn IsWaveReady(wave: Wave) -> bool;
5301}
5302extern "C" {
5303 pub fn LoadSound(fileName: *const ::std::os::raw::c_char) -> Sound;
5304}
5305extern "C" {
5306 pub fn LoadSoundFromWave(wave: Wave) -> Sound;
5307}
5308extern "C" {
5309 pub fn LoadSoundAlias(source: Sound) -> Sound;
5310}
5311extern "C" {
5312 pub fn IsSoundReady(sound: Sound) -> bool;
5313}
5314extern "C" {
5315 pub fn UpdateSound(
5316 sound: Sound,
5317 data: *const ::std::os::raw::c_void,
5318 sampleCount: ::std::os::raw::c_int,
5319 );
5320}
5321extern "C" {
5322 pub fn UnloadWave(wave: Wave);
5323}
5324extern "C" {
5325 pub fn UnloadSound(sound: Sound);
5326}
5327extern "C" {
5328 pub fn UnloadSoundAlias(alias: Sound);
5329}
5330extern "C" {
5331 pub fn ExportWave(wave: Wave, fileName: *const ::std::os::raw::c_char) -> bool;
5332}
5333extern "C" {
5334 pub fn ExportWaveAsCode(wave: Wave, fileName: *const ::std::os::raw::c_char) -> bool;
5335}
5336extern "C" {
5337 pub fn PlaySound(sound: Sound);
5338}
5339extern "C" {
5340 pub fn StopSound(sound: Sound);
5341}
5342extern "C" {
5343 pub fn PauseSound(sound: Sound);
5344}
5345extern "C" {
5346 pub fn ResumeSound(sound: Sound);
5347}
5348extern "C" {
5349 pub fn IsSoundPlaying(sound: Sound) -> bool;
5350}
5351extern "C" {
5352 pub fn SetSoundVolume(sound: Sound, volume: f32);
5353}
5354extern "C" {
5355 pub fn SetSoundPitch(sound: Sound, pitch: f32);
5356}
5357extern "C" {
5358 pub fn SetSoundPan(sound: Sound, pan: f32);
5359}
5360extern "C" {
5361 pub fn WaveCopy(wave: Wave) -> Wave;
5362}
5363extern "C" {
5364 pub fn WaveCrop(
5365 wave: *mut Wave,
5366 initFrame: ::std::os::raw::c_int,
5367 finalFrame: ::std::os::raw::c_int,
5368 );
5369}
5370extern "C" {
5371 pub fn WaveFormat(
5372 wave: *mut Wave,
5373 sampleRate: ::std::os::raw::c_int,
5374 sampleSize: ::std::os::raw::c_int,
5375 channels: ::std::os::raw::c_int,
5376 );
5377}
5378extern "C" {
5379 pub fn LoadWaveSamples(wave: Wave) -> *mut f32;
5380}
5381extern "C" {
5382 pub fn UnloadWaveSamples(samples: *mut f32);
5383}
5384extern "C" {
5385 pub fn LoadMusicStream(fileName: *const ::std::os::raw::c_char) -> Music;
5386}
5387extern "C" {
5388 pub fn LoadMusicStreamFromMemory(
5389 fileType: *const ::std::os::raw::c_char,
5390 data: *const ::std::os::raw::c_uchar,
5391 dataSize: ::std::os::raw::c_int,
5392 ) -> Music;
5393}
5394extern "C" {
5395 pub fn IsMusicReady(music: Music) -> bool;
5396}
5397extern "C" {
5398 pub fn UnloadMusicStream(music: Music);
5399}
5400extern "C" {
5401 pub fn PlayMusicStream(music: Music);
5402}
5403extern "C" {
5404 pub fn IsMusicStreamPlaying(music: Music) -> bool;
5405}
5406extern "C" {
5407 pub fn UpdateMusicStream(music: Music);
5408}
5409extern "C" {
5410 pub fn StopMusicStream(music: Music);
5411}
5412extern "C" {
5413 pub fn PauseMusicStream(music: Music);
5414}
5415extern "C" {
5416 pub fn ResumeMusicStream(music: Music);
5417}
5418extern "C" {
5419 pub fn SeekMusicStream(music: Music, position: f32);
5420}
5421extern "C" {
5422 pub fn SetMusicVolume(music: Music, volume: f32);
5423}
5424extern "C" {
5425 pub fn SetMusicPitch(music: Music, pitch: f32);
5426}
5427extern "C" {
5428 pub fn SetMusicPan(music: Music, pan: f32);
5429}
5430extern "C" {
5431 pub fn GetMusicTimeLength(music: Music) -> f32;
5432}
5433extern "C" {
5434 pub fn GetMusicTimePlayed(music: Music) -> f32;
5435}
5436extern "C" {
5437 pub fn LoadAudioStream(
5438 sampleRate: ::std::os::raw::c_uint,
5439 sampleSize: ::std::os::raw::c_uint,
5440 channels: ::std::os::raw::c_uint,
5441 ) -> AudioStream;
5442}
5443extern "C" {
5444 pub fn IsAudioStreamReady(stream: AudioStream) -> bool;
5445}
5446extern "C" {
5447 pub fn UnloadAudioStream(stream: AudioStream);
5448}
5449extern "C" {
5450 pub fn UpdateAudioStream(
5451 stream: AudioStream,
5452 data: *const ::std::os::raw::c_void,
5453 frameCount: ::std::os::raw::c_int,
5454 );
5455}
5456extern "C" {
5457 pub fn IsAudioStreamProcessed(stream: AudioStream) -> bool;
5458}
5459extern "C" {
5460 pub fn PlayAudioStream(stream: AudioStream);
5461}
5462extern "C" {
5463 pub fn PauseAudioStream(stream: AudioStream);
5464}
5465extern "C" {
5466 pub fn ResumeAudioStream(stream: AudioStream);
5467}
5468extern "C" {
5469 pub fn IsAudioStreamPlaying(stream: AudioStream) -> bool;
5470}
5471extern "C" {
5472 pub fn StopAudioStream(stream: AudioStream);
5473}
5474extern "C" {
5475 pub fn SetAudioStreamVolume(stream: AudioStream, volume: f32);
5476}
5477extern "C" {
5478 pub fn SetAudioStreamPitch(stream: AudioStream, pitch: f32);
5479}
5480extern "C" {
5481 pub fn SetAudioStreamPan(stream: AudioStream, pan: f32);
5482}
5483extern "C" {
5484 pub fn SetAudioStreamBufferSizeDefault(size: ::std::os::raw::c_int);
5485}
5486extern "C" {
5487 pub fn SetAudioStreamCallback(stream: AudioStream, callback: AudioCallback);
5488}
5489extern "C" {
5490 pub fn AttachAudioStreamProcessor(stream: AudioStream, processor: AudioCallback);
5491}
5492extern "C" {
5493 pub fn DetachAudioStreamProcessor(stream: AudioStream, processor: AudioCallback);
5494}
5495extern "C" {
5496 pub fn AttachAudioMixedProcessor(processor: AudioCallback);
5497}
5498extern "C" {
5499 pub fn DetachAudioMixedProcessor(processor: AudioCallback);
5500}
5501pub type __builtin_va_list = [__va_list_tag; 1usize];
5502#[repr(C)]
5503#[derive(Debug, Copy, Clone)]
5504pub struct __va_list_tag {
5505 pub gp_offset: ::std::os::raw::c_uint,
5506 pub fp_offset: ::std::os::raw::c_uint,
5507 pub overflow_arg_area: *mut ::std::os::raw::c_void,
5508 pub reg_save_area: *mut ::std::os::raw::c_void,
5509}
5510#[test]
5511fn bindgen_test_layout___va_list_tag() {
5512 const UNINIT: ::std::mem::MaybeUninit<__va_list_tag> = ::std::mem::MaybeUninit::uninit();
5513 let ptr = UNINIT.as_ptr();
5514 assert_eq!(
5515 ::std::mem::size_of::<__va_list_tag>(),
5516 24usize,
5517 concat!("Size of: ", stringify!(__va_list_tag))
5518 );
5519 assert_eq!(
5520 ::std::mem::align_of::<__va_list_tag>(),
5521 8usize,
5522 concat!("Alignment of ", stringify!(__va_list_tag))
5523 );
5524 assert_eq!(
5525 unsafe { ::std::ptr::addr_of!((*ptr).gp_offset) as usize - ptr as usize },
5526 0usize,
5527 concat!(
5528 "Offset of field: ",
5529 stringify!(__va_list_tag),
5530 "::",
5531 stringify!(gp_offset)
5532 )
5533 );
5534 assert_eq!(
5535 unsafe { ::std::ptr::addr_of!((*ptr).fp_offset) as usize - ptr as usize },
5536 4usize,
5537 concat!(
5538 "Offset of field: ",
5539 stringify!(__va_list_tag),
5540 "::",
5541 stringify!(fp_offset)
5542 )
5543 );
5544 assert_eq!(
5545 unsafe { ::std::ptr::addr_of!((*ptr).overflow_arg_area) as usize - ptr as usize },
5546 8usize,
5547 concat!(
5548 "Offset of field: ",
5549 stringify!(__va_list_tag),
5550 "::",
5551 stringify!(overflow_arg_area)
5552 )
5553 );
5554 assert_eq!(
5555 unsafe { ::std::ptr::addr_of!((*ptr).reg_save_area) as usize - ptr as usize },
5556 16usize,
5557 concat!(
5558 "Offset of field: ",
5559 stringify!(__va_list_tag),
5560 "::",
5561 stringify!(reg_save_area)
5562 )
5563 );
5564}