1#![allow(non_snake_case, non_camel_case_types, non_upper_case_globals)]
5
6extern crate csfml_system_sys;
7extern crate csfml_window_sys;
8use csfml_system_sys::*;
9use csfml_window_sys::*;
10pub const sfBlendFactor_sfBlendFactorZero: sfBlendFactor = 0;
13pub const sfBlendFactor_sfBlendFactorOne: sfBlendFactor = 1;
14pub const sfBlendFactor_sfBlendFactorSrcColor: sfBlendFactor = 2;
15pub const sfBlendFactor_sfBlendFactorOneMinusSrcColor: sfBlendFactor = 3;
16pub const sfBlendFactor_sfBlendFactorDstColor: sfBlendFactor = 4;
17pub const sfBlendFactor_sfBlendFactorOneMinusDstColor: sfBlendFactor = 5;
18pub const sfBlendFactor_sfBlendFactorSrcAlpha: sfBlendFactor = 6;
19pub const sfBlendFactor_sfBlendFactorOneMinusSrcAlpha: sfBlendFactor = 7;
20pub const sfBlendFactor_sfBlendFactorDstAlpha: sfBlendFactor = 8;
21pub const sfBlendFactor_sfBlendFactorOneMinusDstAlpha: sfBlendFactor = 9;
22pub type sfBlendFactor = ::std::os::raw::c_uint;
23pub const sfBlendEquation_sfBlendEquationAdd: sfBlendEquation = 0;
24pub const sfBlendEquation_sfBlendEquationSubtract: sfBlendEquation = 1;
25pub const sfBlendEquation_sfBlendEquationReverseSubtract: sfBlendEquation = 2;
26pub type sfBlendEquation = ::std::os::raw::c_uint;
27#[repr(C)]
28#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
29pub struct sfBlendMode {
30 pub colorSrcFactor: sfBlendFactor,
31 pub colorDstFactor: sfBlendFactor,
32 pub colorEquation: sfBlendEquation,
33 pub alphaSrcFactor: sfBlendFactor,
34 pub alphaDstFactor: sfBlendFactor,
35 pub alphaEquation: sfBlendEquation,
36}
37#[test]
38fn bindgen_test_layout_sfBlendMode() {
39 assert_eq!(
40 ::std::mem::size_of::<sfBlendMode>(),
41 24usize,
42 concat!("Size of: ", stringify!(sfBlendMode))
43 );
44 assert_eq!(
45 ::std::mem::align_of::<sfBlendMode>(),
46 4usize,
47 concat!("Alignment of ", stringify!(sfBlendMode))
48 );
49 assert_eq!(
50 unsafe { &(*(::std::ptr::null::<sfBlendMode>())).colorSrcFactor as *const _ as usize },
51 0usize,
52 concat!(
53 "Offset of field: ",
54 stringify!(sfBlendMode),
55 "::",
56 stringify!(colorSrcFactor)
57 )
58 );
59 assert_eq!(
60 unsafe { &(*(::std::ptr::null::<sfBlendMode>())).colorDstFactor as *const _ as usize },
61 4usize,
62 concat!(
63 "Offset of field: ",
64 stringify!(sfBlendMode),
65 "::",
66 stringify!(colorDstFactor)
67 )
68 );
69 assert_eq!(
70 unsafe { &(*(::std::ptr::null::<sfBlendMode>())).colorEquation as *const _ as usize },
71 8usize,
72 concat!(
73 "Offset of field: ",
74 stringify!(sfBlendMode),
75 "::",
76 stringify!(colorEquation)
77 )
78 );
79 assert_eq!(
80 unsafe { &(*(::std::ptr::null::<sfBlendMode>())).alphaSrcFactor as *const _ as usize },
81 12usize,
82 concat!(
83 "Offset of field: ",
84 stringify!(sfBlendMode),
85 "::",
86 stringify!(alphaSrcFactor)
87 )
88 );
89 assert_eq!(
90 unsafe { &(*(::std::ptr::null::<sfBlendMode>())).alphaDstFactor as *const _ as usize },
91 16usize,
92 concat!(
93 "Offset of field: ",
94 stringify!(sfBlendMode),
95 "::",
96 stringify!(alphaDstFactor)
97 )
98 );
99 assert_eq!(
100 unsafe { &(*(::std::ptr::null::<sfBlendMode>())).alphaEquation as *const _ as usize },
101 20usize,
102 concat!(
103 "Offset of field: ",
104 stringify!(sfBlendMode),
105 "::",
106 stringify!(alphaEquation)
107 )
108 );
109}
110extern "C" {
111 pub static sfBlendAlpha: sfBlendMode;
112}
113extern "C" {
114 pub static sfBlendAdd: sfBlendMode;
115}
116extern "C" {
117 pub static sfBlendMultiply: sfBlendMode;
118}
119extern "C" {
120 pub static sfBlendNone: sfBlendMode;
121}
122#[repr(C)]
123#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
124pub struct sfColor {
125 pub r: sfUint8,
126 pub g: sfUint8,
127 pub b: sfUint8,
128 pub a: sfUint8,
129}
130#[test]
131fn bindgen_test_layout_sfColor() {
132 assert_eq!(
133 ::std::mem::size_of::<sfColor>(),
134 4usize,
135 concat!("Size of: ", stringify!(sfColor))
136 );
137 assert_eq!(
138 ::std::mem::align_of::<sfColor>(),
139 1usize,
140 concat!("Alignment of ", stringify!(sfColor))
141 );
142 assert_eq!(
143 unsafe { &(*(::std::ptr::null::<sfColor>())).r as *const _ as usize },
144 0usize,
145 concat!(
146 "Offset of field: ",
147 stringify!(sfColor),
148 "::",
149 stringify!(r)
150 )
151 );
152 assert_eq!(
153 unsafe { &(*(::std::ptr::null::<sfColor>())).g as *const _ as usize },
154 1usize,
155 concat!(
156 "Offset of field: ",
157 stringify!(sfColor),
158 "::",
159 stringify!(g)
160 )
161 );
162 assert_eq!(
163 unsafe { &(*(::std::ptr::null::<sfColor>())).b as *const _ as usize },
164 2usize,
165 concat!(
166 "Offset of field: ",
167 stringify!(sfColor),
168 "::",
169 stringify!(b)
170 )
171 );
172 assert_eq!(
173 unsafe { &(*(::std::ptr::null::<sfColor>())).a as *const _ as usize },
174 3usize,
175 concat!(
176 "Offset of field: ",
177 stringify!(sfColor),
178 "::",
179 stringify!(a)
180 )
181 );
182}
183extern "C" {
184 pub static mut sfBlack: sfColor;
185}
186extern "C" {
187 pub static mut sfWhite: sfColor;
188}
189extern "C" {
190 pub static mut sfRed: sfColor;
191}
192extern "C" {
193 pub static mut sfGreen: sfColor;
194}
195extern "C" {
196 pub static mut sfBlue: sfColor;
197}
198extern "C" {
199 pub static mut sfYellow: sfColor;
200}
201extern "C" {
202 pub static mut sfMagenta: sfColor;
203}
204extern "C" {
205 pub static mut sfCyan: sfColor;
206}
207extern "C" {
208 pub static mut sfTransparent: sfColor;
209}
210extern "C" {
211 pub fn sfColor_fromRGB(red: sfUint8, green: sfUint8, blue: sfUint8) -> sfColor;
212}
213extern "C" {
214 pub fn sfColor_fromRGBA(red: sfUint8, green: sfUint8, blue: sfUint8, alpha: sfUint8)
215 -> sfColor;
216}
217extern "C" {
218 pub fn sfColor_fromInteger(color: sfUint32) -> sfColor;
219}
220extern "C" {
221 pub fn sfColor_toInteger(color: sfColor) -> sfUint32;
222}
223extern "C" {
224 pub fn sfColor_add(color1: sfColor, color2: sfColor) -> sfColor;
225}
226extern "C" {
227 pub fn sfColor_subtract(color1: sfColor, color2: sfColor) -> sfColor;
228}
229extern "C" {
230 pub fn sfColor_modulate(color1: sfColor, color2: sfColor) -> sfColor;
231}
232#[repr(C)]
233#[derive(Debug, Copy, Clone, PartialOrd, PartialEq)]
234pub struct sfFloatRect {
235 pub left: f32,
236 pub top: f32,
237 pub width: f32,
238 pub height: f32,
239}
240#[test]
241fn bindgen_test_layout_sfFloatRect() {
242 assert_eq!(
243 ::std::mem::size_of::<sfFloatRect>(),
244 16usize,
245 concat!("Size of: ", stringify!(sfFloatRect))
246 );
247 assert_eq!(
248 ::std::mem::align_of::<sfFloatRect>(),
249 4usize,
250 concat!("Alignment of ", stringify!(sfFloatRect))
251 );
252 assert_eq!(
253 unsafe { &(*(::std::ptr::null::<sfFloatRect>())).left as *const _ as usize },
254 0usize,
255 concat!(
256 "Offset of field: ",
257 stringify!(sfFloatRect),
258 "::",
259 stringify!(left)
260 )
261 );
262 assert_eq!(
263 unsafe { &(*(::std::ptr::null::<sfFloatRect>())).top as *const _ as usize },
264 4usize,
265 concat!(
266 "Offset of field: ",
267 stringify!(sfFloatRect),
268 "::",
269 stringify!(top)
270 )
271 );
272 assert_eq!(
273 unsafe { &(*(::std::ptr::null::<sfFloatRect>())).width as *const _ as usize },
274 8usize,
275 concat!(
276 "Offset of field: ",
277 stringify!(sfFloatRect),
278 "::",
279 stringify!(width)
280 )
281 );
282 assert_eq!(
283 unsafe { &(*(::std::ptr::null::<sfFloatRect>())).height as *const _ as usize },
284 12usize,
285 concat!(
286 "Offset of field: ",
287 stringify!(sfFloatRect),
288 "::",
289 stringify!(height)
290 )
291 );
292}
293#[repr(C)]
294#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
295pub struct sfIntRect {
296 pub left: ::std::os::raw::c_int,
297 pub top: ::std::os::raw::c_int,
298 pub width: ::std::os::raw::c_int,
299 pub height: ::std::os::raw::c_int,
300}
301#[test]
302fn bindgen_test_layout_sfIntRect() {
303 assert_eq!(
304 ::std::mem::size_of::<sfIntRect>(),
305 16usize,
306 concat!("Size of: ", stringify!(sfIntRect))
307 );
308 assert_eq!(
309 ::std::mem::align_of::<sfIntRect>(),
310 4usize,
311 concat!("Alignment of ", stringify!(sfIntRect))
312 );
313 assert_eq!(
314 unsafe { &(*(::std::ptr::null::<sfIntRect>())).left as *const _ as usize },
315 0usize,
316 concat!(
317 "Offset of field: ",
318 stringify!(sfIntRect),
319 "::",
320 stringify!(left)
321 )
322 );
323 assert_eq!(
324 unsafe { &(*(::std::ptr::null::<sfIntRect>())).top as *const _ as usize },
325 4usize,
326 concat!(
327 "Offset of field: ",
328 stringify!(sfIntRect),
329 "::",
330 stringify!(top)
331 )
332 );
333 assert_eq!(
334 unsafe { &(*(::std::ptr::null::<sfIntRect>())).width as *const _ as usize },
335 8usize,
336 concat!(
337 "Offset of field: ",
338 stringify!(sfIntRect),
339 "::",
340 stringify!(width)
341 )
342 );
343 assert_eq!(
344 unsafe { &(*(::std::ptr::null::<sfIntRect>())).height as *const _ as usize },
345 12usize,
346 concat!(
347 "Offset of field: ",
348 stringify!(sfIntRect),
349 "::",
350 stringify!(height)
351 )
352 );
353}
354extern "C" {
355 pub fn sfFloatRect_contains(rect: *const sfFloatRect, x: f32, y: f32) -> sfBool;
356}
357extern "C" {
358 pub fn sfIntRect_contains(
359 rect: *const sfIntRect,
360 x: ::std::os::raw::c_int,
361 y: ::std::os::raw::c_int,
362 ) -> sfBool;
363}
364extern "C" {
365 pub fn sfFloatRect_intersects(
366 rect1: *const sfFloatRect,
367 rect2: *const sfFloatRect,
368 intersection: *mut sfFloatRect,
369 ) -> sfBool;
370}
371extern "C" {
372 pub fn sfIntRect_intersects(
373 rect1: *const sfIntRect,
374 rect2: *const sfIntRect,
375 intersection: *mut sfIntRect,
376 ) -> sfBool;
377}
378#[repr(C)]
379#[derive(Debug, Copy, Clone)]
380pub struct sfCircleShape {
381 _unused: [u8; 0],
382}
383#[repr(C)]
384#[derive(Debug, Copy, Clone)]
385pub struct sfConvexShape {
386 _unused: [u8; 0],
387}
388#[repr(C)]
389#[derive(Debug, Copy, Clone)]
390pub struct sfFont {
391 _unused: [u8; 0],
392}
393#[repr(C)]
394#[derive(Debug, Copy, Clone)]
395pub struct sfImage {
396 _unused: [u8; 0],
397}
398#[repr(C)]
399#[derive(Debug, Copy, Clone)]
400pub struct sfShader {
401 _unused: [u8; 0],
402}
403#[repr(C)]
404#[derive(Debug, Copy, Clone)]
405pub struct sfRectangleShape {
406 _unused: [u8; 0],
407}
408#[repr(C)]
409#[derive(Debug, Copy, Clone)]
410pub struct sfRenderTexture {
411 _unused: [u8; 0],
412}
413#[repr(C)]
414#[derive(Debug, Copy, Clone)]
415pub struct sfRenderWindow {
416 _unused: [u8; 0],
417}
418#[repr(C)]
419#[derive(Debug, Copy, Clone)]
420pub struct sfShape {
421 _unused: [u8; 0],
422}
423#[repr(C)]
424#[derive(Debug, Copy, Clone)]
425pub struct sfSprite {
426 _unused: [u8; 0],
427}
428#[repr(C)]
429#[derive(Debug, Copy, Clone)]
430pub struct sfText {
431 _unused: [u8; 0],
432}
433#[repr(C)]
434#[derive(Debug, Copy, Clone)]
435pub struct sfTexture {
436 _unused: [u8; 0],
437}
438#[repr(C)]
439#[derive(Debug, Copy, Clone)]
440pub struct sfTransformable {
441 _unused: [u8; 0],
442}
443#[repr(C)]
444#[derive(Debug, Copy, Clone)]
445pub struct sfVertexArray {
446 _unused: [u8; 0],
447}
448#[repr(C)]
449#[derive(Debug, Copy, Clone)]
450pub struct sfVertexBuffer {
451 _unused: [u8; 0],
452}
453#[repr(C)]
454#[derive(Debug, Copy, Clone)]
455pub struct sfView {
456 _unused: [u8; 0],
457}
458#[repr(C)]
459#[derive(Debug, Copy, Clone, PartialOrd, PartialEq)]
460pub struct sfTransform {
461 pub matrix: [f32; 9usize],
462}
463#[test]
464fn bindgen_test_layout_sfTransform() {
465 assert_eq!(
466 ::std::mem::size_of::<sfTransform>(),
467 36usize,
468 concat!("Size of: ", stringify!(sfTransform))
469 );
470 assert_eq!(
471 ::std::mem::align_of::<sfTransform>(),
472 4usize,
473 concat!("Alignment of ", stringify!(sfTransform))
474 );
475 assert_eq!(
476 unsafe { &(*(::std::ptr::null::<sfTransform>())).matrix as *const _ as usize },
477 0usize,
478 concat!(
479 "Offset of field: ",
480 stringify!(sfTransform),
481 "::",
482 stringify!(matrix)
483 )
484 );
485}
486extern "C" {
487 pub static sfTransform_Identity: sfTransform;
488}
489extern "C" {
490 pub fn sfTransform_fromMatrix(
491 a00: f32,
492 a01: f32,
493 a02: f32,
494 a10: f32,
495 a11: f32,
496 a12: f32,
497 a20: f32,
498 a21: f32,
499 a22: f32,
500 ) -> sfTransform;
501}
502extern "C" {
503 pub fn sfTransform_getMatrix(transform: *const sfTransform, matrix: *mut f32);
504}
505extern "C" {
506 pub fn sfTransform_getInverse(transform: *const sfTransform) -> sfTransform;
507}
508extern "C" {
509 pub fn sfTransform_transformPoint(
510 transform: *const sfTransform,
511 point: sfVector2f,
512 ) -> sfVector2f;
513}
514extern "C" {
515 pub fn sfTransform_transformRect(
516 transform: *const sfTransform,
517 rectangle: sfFloatRect,
518 ) -> sfFloatRect;
519}
520extern "C" {
521 pub fn sfTransform_combine(transform: *mut sfTransform, other: *const sfTransform);
522}
523extern "C" {
524 pub fn sfTransform_translate(transform: *mut sfTransform, x: f32, y: f32);
525}
526extern "C" {
527 pub fn sfTransform_rotate(transform: *mut sfTransform, angle: f32);
528}
529extern "C" {
530 pub fn sfTransform_rotateWithCenter(
531 transform: *mut sfTransform,
532 angle: f32,
533 centerX: f32,
534 centerY: f32,
535 );
536}
537extern "C" {
538 pub fn sfTransform_scale(transform: *mut sfTransform, scaleX: f32, scaleY: f32);
539}
540extern "C" {
541 pub fn sfTransform_scaleWithCenter(
542 transform: *mut sfTransform,
543 scaleX: f32,
544 scaleY: f32,
545 centerX: f32,
546 centerY: f32,
547 );
548}
549extern "C" {
550 pub fn sfTransform_equal(left: *mut sfTransform, right: *mut sfTransform) -> sfBool;
551}
552extern "C" {
553 pub fn sfCircleShape_create() -> *mut sfCircleShape;
554}
555extern "C" {
556 pub fn sfCircleShape_copy(shape: *const sfCircleShape) -> *mut sfCircleShape;
557}
558extern "C" {
559 pub fn sfCircleShape_destroy(shape: *mut sfCircleShape);
560}
561extern "C" {
562 pub fn sfCircleShape_setPosition(shape: *mut sfCircleShape, position: sfVector2f);
563}
564extern "C" {
565 pub fn sfCircleShape_setRotation(shape: *mut sfCircleShape, angle: f32);
566}
567extern "C" {
568 pub fn sfCircleShape_setScale(shape: *mut sfCircleShape, scale: sfVector2f);
569}
570extern "C" {
571 pub fn sfCircleShape_setOrigin(shape: *mut sfCircleShape, origin: sfVector2f);
572}
573extern "C" {
574 pub fn sfCircleShape_getPosition(shape: *const sfCircleShape) -> sfVector2f;
575}
576extern "C" {
577 pub fn sfCircleShape_getRotation(shape: *const sfCircleShape) -> f32;
578}
579extern "C" {
580 pub fn sfCircleShape_getScale(shape: *const sfCircleShape) -> sfVector2f;
581}
582extern "C" {
583 pub fn sfCircleShape_getOrigin(shape: *const sfCircleShape) -> sfVector2f;
584}
585extern "C" {
586 pub fn sfCircleShape_move(shape: *mut sfCircleShape, offset: sfVector2f);
587}
588extern "C" {
589 pub fn sfCircleShape_rotate(shape: *mut sfCircleShape, angle: f32);
590}
591extern "C" {
592 pub fn sfCircleShape_scale(shape: *mut sfCircleShape, factors: sfVector2f);
593}
594extern "C" {
595 pub fn sfCircleShape_getTransform(shape: *const sfCircleShape) -> sfTransform;
596}
597extern "C" {
598 pub fn sfCircleShape_getInverseTransform(shape: *const sfCircleShape) -> sfTransform;
599}
600extern "C" {
601 pub fn sfCircleShape_setTexture(
602 shape: *mut sfCircleShape,
603 texture: *const sfTexture,
604 resetRect: sfBool,
605 );
606}
607extern "C" {
608 pub fn sfCircleShape_setTextureRect(shape: *mut sfCircleShape, rect: sfIntRect);
609}
610extern "C" {
611 pub fn sfCircleShape_setFillColor(shape: *mut sfCircleShape, color: sfColor);
612}
613extern "C" {
614 pub fn sfCircleShape_setOutlineColor(shape: *mut sfCircleShape, color: sfColor);
615}
616extern "C" {
617 pub fn sfCircleShape_setOutlineThickness(shape: *mut sfCircleShape, thickness: f32);
618}
619extern "C" {
620 pub fn sfCircleShape_getTexture(shape: *const sfCircleShape) -> *const sfTexture;
621}
622extern "C" {
623 pub fn sfCircleShape_getTextureRect(shape: *const sfCircleShape) -> sfIntRect;
624}
625extern "C" {
626 pub fn sfCircleShape_getFillColor(shape: *const sfCircleShape) -> sfColor;
627}
628extern "C" {
629 pub fn sfCircleShape_getOutlineColor(shape: *const sfCircleShape) -> sfColor;
630}
631extern "C" {
632 pub fn sfCircleShape_getOutlineThickness(shape: *const sfCircleShape) -> f32;
633}
634extern "C" {
635 pub fn sfCircleShape_getPointCount(shape: *const sfCircleShape) -> usize;
636}
637extern "C" {
638 pub fn sfCircleShape_getPoint(shape: *const sfCircleShape, index: usize) -> sfVector2f;
639}
640extern "C" {
641 pub fn sfCircleShape_setRadius(shape: *mut sfCircleShape, radius: f32);
642}
643extern "C" {
644 pub fn sfCircleShape_getRadius(shape: *const sfCircleShape) -> f32;
645}
646extern "C" {
647 pub fn sfCircleShape_setPointCount(shape: *mut sfCircleShape, count: usize);
648}
649extern "C" {
650 pub fn sfCircleShape_getLocalBounds(shape: *const sfCircleShape) -> sfFloatRect;
651}
652extern "C" {
653 pub fn sfCircleShape_getGlobalBounds(shape: *const sfCircleShape) -> sfFloatRect;
654}
655extern "C" {
656 pub fn sfConvexShape_create() -> *mut sfConvexShape;
657}
658extern "C" {
659 pub fn sfConvexShape_copy(shape: *const sfConvexShape) -> *mut sfConvexShape;
660}
661extern "C" {
662 pub fn sfConvexShape_destroy(shape: *mut sfConvexShape);
663}
664extern "C" {
665 pub fn sfConvexShape_setPosition(shape: *mut sfConvexShape, position: sfVector2f);
666}
667extern "C" {
668 pub fn sfConvexShape_setRotation(shape: *mut sfConvexShape, angle: f32);
669}
670extern "C" {
671 pub fn sfConvexShape_setScale(shape: *mut sfConvexShape, scale: sfVector2f);
672}
673extern "C" {
674 pub fn sfConvexShape_setOrigin(shape: *mut sfConvexShape, origin: sfVector2f);
675}
676extern "C" {
677 pub fn sfConvexShape_getPosition(shape: *const sfConvexShape) -> sfVector2f;
678}
679extern "C" {
680 pub fn sfConvexShape_getRotation(shape: *const sfConvexShape) -> f32;
681}
682extern "C" {
683 pub fn sfConvexShape_getScale(shape: *const sfConvexShape) -> sfVector2f;
684}
685extern "C" {
686 pub fn sfConvexShape_getOrigin(shape: *const sfConvexShape) -> sfVector2f;
687}
688extern "C" {
689 pub fn sfConvexShape_move(shape: *mut sfConvexShape, offset: sfVector2f);
690}
691extern "C" {
692 pub fn sfConvexShape_rotate(shape: *mut sfConvexShape, angle: f32);
693}
694extern "C" {
695 pub fn sfConvexShape_scale(shape: *mut sfConvexShape, factors: sfVector2f);
696}
697extern "C" {
698 pub fn sfConvexShape_getTransform(shape: *const sfConvexShape) -> sfTransform;
699}
700extern "C" {
701 pub fn sfConvexShape_getInverseTransform(shape: *const sfConvexShape) -> sfTransform;
702}
703extern "C" {
704 pub fn sfConvexShape_setTexture(
705 shape: *mut sfConvexShape,
706 texture: *const sfTexture,
707 resetRect: sfBool,
708 );
709}
710extern "C" {
711 pub fn sfConvexShape_setTextureRect(shape: *mut sfConvexShape, rect: sfIntRect);
712}
713extern "C" {
714 pub fn sfConvexShape_setFillColor(shape: *mut sfConvexShape, color: sfColor);
715}
716extern "C" {
717 pub fn sfConvexShape_setOutlineColor(shape: *mut sfConvexShape, color: sfColor);
718}
719extern "C" {
720 pub fn sfConvexShape_setOutlineThickness(shape: *mut sfConvexShape, thickness: f32);
721}
722extern "C" {
723 pub fn sfConvexShape_getTexture(shape: *const sfConvexShape) -> *const sfTexture;
724}
725extern "C" {
726 pub fn sfConvexShape_getTextureRect(shape: *const sfConvexShape) -> sfIntRect;
727}
728extern "C" {
729 pub fn sfConvexShape_getFillColor(shape: *const sfConvexShape) -> sfColor;
730}
731extern "C" {
732 pub fn sfConvexShape_getOutlineColor(shape: *const sfConvexShape) -> sfColor;
733}
734extern "C" {
735 pub fn sfConvexShape_getOutlineThickness(shape: *const sfConvexShape) -> f32;
736}
737extern "C" {
738 pub fn sfConvexShape_getPointCount(shape: *const sfConvexShape) -> usize;
739}
740extern "C" {
741 pub fn sfConvexShape_getPoint(shape: *const sfConvexShape, index: usize) -> sfVector2f;
742}
743extern "C" {
744 pub fn sfConvexShape_setPointCount(shape: *mut sfConvexShape, count: usize);
745}
746extern "C" {
747 pub fn sfConvexShape_setPoint(shape: *mut sfConvexShape, index: usize, point: sfVector2f);
748}
749extern "C" {
750 pub fn sfConvexShape_getLocalBounds(shape: *const sfConvexShape) -> sfFloatRect;
751}
752extern "C" {
753 pub fn sfConvexShape_getGlobalBounds(shape: *const sfConvexShape) -> sfFloatRect;
754}
755#[repr(C)]
756#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
757pub struct sfFontInfo {
758 pub family: *const ::std::os::raw::c_char,
759}
760#[test]
761fn bindgen_test_layout_sfFontInfo() {
762 assert_eq!(
763 ::std::mem::size_of::<sfFontInfo>(),
764 8usize,
765 concat!("Size of: ", stringify!(sfFontInfo))
766 );
767 assert_eq!(
768 ::std::mem::align_of::<sfFontInfo>(),
769 8usize,
770 concat!("Alignment of ", stringify!(sfFontInfo))
771 );
772 assert_eq!(
773 unsafe { &(*(::std::ptr::null::<sfFontInfo>())).family as *const _ as usize },
774 0usize,
775 concat!(
776 "Offset of field: ",
777 stringify!(sfFontInfo),
778 "::",
779 stringify!(family)
780 )
781 );
782}
783#[repr(C)]
784#[derive(Debug, Copy, Clone, PartialOrd, PartialEq)]
785pub struct sfGlyph {
786 pub advance: f32,
787 pub bounds: sfFloatRect,
788 pub textureRect: sfIntRect,
789}
790#[test]
791fn bindgen_test_layout_sfGlyph() {
792 assert_eq!(
793 ::std::mem::size_of::<sfGlyph>(),
794 36usize,
795 concat!("Size of: ", stringify!(sfGlyph))
796 );
797 assert_eq!(
798 ::std::mem::align_of::<sfGlyph>(),
799 4usize,
800 concat!("Alignment of ", stringify!(sfGlyph))
801 );
802 assert_eq!(
803 unsafe { &(*(::std::ptr::null::<sfGlyph>())).advance as *const _ as usize },
804 0usize,
805 concat!(
806 "Offset of field: ",
807 stringify!(sfGlyph),
808 "::",
809 stringify!(advance)
810 )
811 );
812 assert_eq!(
813 unsafe { &(*(::std::ptr::null::<sfGlyph>())).bounds as *const _ as usize },
814 4usize,
815 concat!(
816 "Offset of field: ",
817 stringify!(sfGlyph),
818 "::",
819 stringify!(bounds)
820 )
821 );
822 assert_eq!(
823 unsafe { &(*(::std::ptr::null::<sfGlyph>())).textureRect as *const _ as usize },
824 20usize,
825 concat!(
826 "Offset of field: ",
827 stringify!(sfGlyph),
828 "::",
829 stringify!(textureRect)
830 )
831 );
832}
833extern "C" {
834 pub fn sfFont_createFromFile(filename: *const ::std::os::raw::c_char) -> *mut sfFont;
835}
836extern "C" {
837 pub fn sfFont_createFromMemory(
838 data: *const ::std::os::raw::c_void,
839 sizeInBytes: usize,
840 ) -> *mut sfFont;
841}
842extern "C" {
843 pub fn sfFont_createFromStream(stream: *mut sfInputStream) -> *mut sfFont;
844}
845extern "C" {
846 pub fn sfFont_copy(font: *const sfFont) -> *mut sfFont;
847}
848extern "C" {
849 pub fn sfFont_destroy(font: *mut sfFont);
850}
851extern "C" {
852 pub fn sfFont_getGlyph(
853 font: *const sfFont,
854 codePoint: sfUint32,
855 characterSize: ::std::os::raw::c_uint,
856 bold: sfBool,
857 outlineThickness: f32,
858 ) -> sfGlyph;
859}
860extern "C" {
861 pub fn sfFont_getKerning(
862 font: *const sfFont,
863 first: sfUint32,
864 second: sfUint32,
865 characterSize: ::std::os::raw::c_uint,
866 ) -> f32;
867}
868extern "C" {
869 pub fn sfFont_getLineSpacing(font: *const sfFont, characterSize: ::std::os::raw::c_uint)
870 -> f32;
871}
872extern "C" {
873 pub fn sfFont_getUnderlinePosition(
874 font: *const sfFont,
875 characterSize: ::std::os::raw::c_uint,
876 ) -> f32;
877}
878extern "C" {
879 pub fn sfFont_getUnderlineThickness(
880 font: *const sfFont,
881 characterSize: ::std::os::raw::c_uint,
882 ) -> f32;
883}
884extern "C" {
885 pub fn sfFont_getTexture(
886 font: *mut sfFont,
887 characterSize: ::std::os::raw::c_uint,
888 ) -> *const sfTexture;
889}
890extern "C" {
891 pub fn sfFont_getInfo(font: *const sfFont) -> sfFontInfo;
892}
893extern "C" {
894 pub fn sfImage_create(
895 width: ::std::os::raw::c_uint,
896 height: ::std::os::raw::c_uint,
897 ) -> *mut sfImage;
898}
899extern "C" {
900 pub fn sfImage_createFromColor(
901 width: ::std::os::raw::c_uint,
902 height: ::std::os::raw::c_uint,
903 color: sfColor,
904 ) -> *mut sfImage;
905}
906extern "C" {
907 pub fn sfImage_createFromPixels(
908 width: ::std::os::raw::c_uint,
909 height: ::std::os::raw::c_uint,
910 pixels: *const sfUint8,
911 ) -> *mut sfImage;
912}
913extern "C" {
914 pub fn sfImage_createFromFile(filename: *const ::std::os::raw::c_char) -> *mut sfImage;
915}
916extern "C" {
917 pub fn sfImage_createFromMemory(
918 data: *const ::std::os::raw::c_void,
919 size: usize,
920 ) -> *mut sfImage;
921}
922extern "C" {
923 pub fn sfImage_createFromStream(stream: *mut sfInputStream) -> *mut sfImage;
924}
925extern "C" {
926 pub fn sfImage_copy(image: *const sfImage) -> *mut sfImage;
927}
928extern "C" {
929 pub fn sfImage_destroy(image: *mut sfImage);
930}
931extern "C" {
932 pub fn sfImage_saveToFile(
933 image: *const sfImage,
934 filename: *const ::std::os::raw::c_char,
935 ) -> sfBool;
936}
937extern "C" {
938 pub fn sfImage_getSize(image: *const sfImage) -> sfVector2u;
939}
940extern "C" {
941 pub fn sfImage_createMaskFromColor(image: *mut sfImage, color: sfColor, alpha: sfUint8);
942}
943extern "C" {
944 pub fn sfImage_copyImage(
945 image: *mut sfImage,
946 source: *const sfImage,
947 destX: ::std::os::raw::c_uint,
948 destY: ::std::os::raw::c_uint,
949 sourceRect: sfIntRect,
950 applyAlpha: sfBool,
951 );
952}
953extern "C" {
954 pub fn sfImage_setPixel(
955 image: *mut sfImage,
956 x: ::std::os::raw::c_uint,
957 y: ::std::os::raw::c_uint,
958 color: sfColor,
959 );
960}
961extern "C" {
962 pub fn sfImage_getPixel(
963 image: *const sfImage,
964 x: ::std::os::raw::c_uint,
965 y: ::std::os::raw::c_uint,
966 ) -> sfColor;
967}
968extern "C" {
969 pub fn sfImage_getPixelsPtr(image: *const sfImage) -> *const sfUint8;
970}
971extern "C" {
972 pub fn sfImage_flipHorizontally(image: *mut sfImage);
973}
974extern "C" {
975 pub fn sfImage_flipVertically(image: *mut sfImage);
976}
977pub const sfPrimitiveType_sfPoints: sfPrimitiveType = 0;
978pub const sfPrimitiveType_sfLines: sfPrimitiveType = 1;
979pub const sfPrimitiveType_sfLineStrip: sfPrimitiveType = 2;
980pub const sfPrimitiveType_sfTriangles: sfPrimitiveType = 3;
981pub const sfPrimitiveType_sfTriangleStrip: sfPrimitiveType = 4;
982pub const sfPrimitiveType_sfTriangleFan: sfPrimitiveType = 5;
983pub const sfPrimitiveType_sfQuads: sfPrimitiveType = 6;
984pub const sfPrimitiveType_sfLinesStrip: sfPrimitiveType = 2;
985pub const sfPrimitiveType_sfTrianglesStrip: sfPrimitiveType = 4;
986pub const sfPrimitiveType_sfTrianglesFan: sfPrimitiveType = 5;
987pub type sfPrimitiveType = ::std::os::raw::c_uint;
988extern "C" {
989 pub fn sfRectangleShape_create() -> *mut sfRectangleShape;
990}
991extern "C" {
992 pub fn sfRectangleShape_copy(shape: *const sfRectangleShape) -> *mut sfRectangleShape;
993}
994extern "C" {
995 pub fn sfRectangleShape_destroy(shape: *mut sfRectangleShape);
996}
997extern "C" {
998 pub fn sfRectangleShape_setPosition(shape: *mut sfRectangleShape, position: sfVector2f);
999}
1000extern "C" {
1001 pub fn sfRectangleShape_setRotation(shape: *mut sfRectangleShape, angle: f32);
1002}
1003extern "C" {
1004 pub fn sfRectangleShape_setScale(shape: *mut sfRectangleShape, scale: sfVector2f);
1005}
1006extern "C" {
1007 pub fn sfRectangleShape_setOrigin(shape: *mut sfRectangleShape, origin: sfVector2f);
1008}
1009extern "C" {
1010 pub fn sfRectangleShape_getPosition(shape: *const sfRectangleShape) -> sfVector2f;
1011}
1012extern "C" {
1013 pub fn sfRectangleShape_getRotation(shape: *const sfRectangleShape) -> f32;
1014}
1015extern "C" {
1016 pub fn sfRectangleShape_getScale(shape: *const sfRectangleShape) -> sfVector2f;
1017}
1018extern "C" {
1019 pub fn sfRectangleShape_getOrigin(shape: *const sfRectangleShape) -> sfVector2f;
1020}
1021extern "C" {
1022 pub fn sfRectangleShape_move(shape: *mut sfRectangleShape, offset: sfVector2f);
1023}
1024extern "C" {
1025 pub fn sfRectangleShape_rotate(shape: *mut sfRectangleShape, angle: f32);
1026}
1027extern "C" {
1028 pub fn sfRectangleShape_scale(shape: *mut sfRectangleShape, factors: sfVector2f);
1029}
1030extern "C" {
1031 pub fn sfRectangleShape_getTransform(shape: *const sfRectangleShape) -> sfTransform;
1032}
1033extern "C" {
1034 pub fn sfRectangleShape_getInverseTransform(shape: *const sfRectangleShape) -> sfTransform;
1035}
1036extern "C" {
1037 pub fn sfRectangleShape_setTexture(
1038 shape: *mut sfRectangleShape,
1039 texture: *const sfTexture,
1040 resetRect: sfBool,
1041 );
1042}
1043extern "C" {
1044 pub fn sfRectangleShape_setTextureRect(shape: *mut sfRectangleShape, rect: sfIntRect);
1045}
1046extern "C" {
1047 pub fn sfRectangleShape_setFillColor(shape: *mut sfRectangleShape, color: sfColor);
1048}
1049extern "C" {
1050 pub fn sfRectangleShape_setOutlineColor(shape: *mut sfRectangleShape, color: sfColor);
1051}
1052extern "C" {
1053 pub fn sfRectangleShape_setOutlineThickness(shape: *mut sfRectangleShape, thickness: f32);
1054}
1055extern "C" {
1056 pub fn sfRectangleShape_getTexture(shape: *const sfRectangleShape) -> *const sfTexture;
1057}
1058extern "C" {
1059 pub fn sfRectangleShape_getTextureRect(shape: *const sfRectangleShape) -> sfIntRect;
1060}
1061extern "C" {
1062 pub fn sfRectangleShape_getFillColor(shape: *const sfRectangleShape) -> sfColor;
1063}
1064extern "C" {
1065 pub fn sfRectangleShape_getOutlineColor(shape: *const sfRectangleShape) -> sfColor;
1066}
1067extern "C" {
1068 pub fn sfRectangleShape_getOutlineThickness(shape: *const sfRectangleShape) -> f32;
1069}
1070extern "C" {
1071 pub fn sfRectangleShape_getPointCount(shape: *const sfRectangleShape) -> usize;
1072}
1073extern "C" {
1074 pub fn sfRectangleShape_getPoint(shape: *const sfRectangleShape, index: usize) -> sfVector2f;
1075}
1076extern "C" {
1077 pub fn sfRectangleShape_setSize(shape: *mut sfRectangleShape, size: sfVector2f);
1078}
1079extern "C" {
1080 pub fn sfRectangleShape_getSize(shape: *const sfRectangleShape) -> sfVector2f;
1081}
1082extern "C" {
1083 pub fn sfRectangleShape_getLocalBounds(shape: *const sfRectangleShape) -> sfFloatRect;
1084}
1085extern "C" {
1086 pub fn sfRectangleShape_getGlobalBounds(shape: *const sfRectangleShape) -> sfFloatRect;
1087}
1088#[repr(C)]
1089#[derive(Debug, Copy, Clone, PartialOrd, PartialEq)]
1090pub struct sfRenderStates {
1091 pub blendMode: sfBlendMode,
1092 pub transform: sfTransform,
1093 pub texture: *const sfTexture,
1094 pub shader: *const sfShader,
1095}
1096#[test]
1097fn bindgen_test_layout_sfRenderStates() {
1098 assert_eq!(
1099 ::std::mem::size_of::<sfRenderStates>(),
1100 80usize,
1101 concat!("Size of: ", stringify!(sfRenderStates))
1102 );
1103 assert_eq!(
1104 ::std::mem::align_of::<sfRenderStates>(),
1105 8usize,
1106 concat!("Alignment of ", stringify!(sfRenderStates))
1107 );
1108 assert_eq!(
1109 unsafe { &(*(::std::ptr::null::<sfRenderStates>())).blendMode as *const _ as usize },
1110 0usize,
1111 concat!(
1112 "Offset of field: ",
1113 stringify!(sfRenderStates),
1114 "::",
1115 stringify!(blendMode)
1116 )
1117 );
1118 assert_eq!(
1119 unsafe { &(*(::std::ptr::null::<sfRenderStates>())).transform as *const _ as usize },
1120 24usize,
1121 concat!(
1122 "Offset of field: ",
1123 stringify!(sfRenderStates),
1124 "::",
1125 stringify!(transform)
1126 )
1127 );
1128 assert_eq!(
1129 unsafe { &(*(::std::ptr::null::<sfRenderStates>())).texture as *const _ as usize },
1130 64usize,
1131 concat!(
1132 "Offset of field: ",
1133 stringify!(sfRenderStates),
1134 "::",
1135 stringify!(texture)
1136 )
1137 );
1138 assert_eq!(
1139 unsafe { &(*(::std::ptr::null::<sfRenderStates>())).shader as *const _ as usize },
1140 72usize,
1141 concat!(
1142 "Offset of field: ",
1143 stringify!(sfRenderStates),
1144 "::",
1145 stringify!(shader)
1146 )
1147 );
1148}
1149#[repr(C)]
1150#[derive(Debug, Copy, Clone, PartialOrd, PartialEq)]
1151pub struct sfVertex {
1152 pub position: sfVector2f,
1153 pub color: sfColor,
1154 pub texCoords: sfVector2f,
1155}
1156#[test]
1157fn bindgen_test_layout_sfVertex() {
1158 assert_eq!(
1159 ::std::mem::size_of::<sfVertex>(),
1160 20usize,
1161 concat!("Size of: ", stringify!(sfVertex))
1162 );
1163 assert_eq!(
1164 ::std::mem::align_of::<sfVertex>(),
1165 4usize,
1166 concat!("Alignment of ", stringify!(sfVertex))
1167 );
1168 assert_eq!(
1169 unsafe { &(*(::std::ptr::null::<sfVertex>())).position as *const _ as usize },
1170 0usize,
1171 concat!(
1172 "Offset of field: ",
1173 stringify!(sfVertex),
1174 "::",
1175 stringify!(position)
1176 )
1177 );
1178 assert_eq!(
1179 unsafe { &(*(::std::ptr::null::<sfVertex>())).color as *const _ as usize },
1180 8usize,
1181 concat!(
1182 "Offset of field: ",
1183 stringify!(sfVertex),
1184 "::",
1185 stringify!(color)
1186 )
1187 );
1188 assert_eq!(
1189 unsafe { &(*(::std::ptr::null::<sfVertex>())).texCoords as *const _ as usize },
1190 12usize,
1191 concat!(
1192 "Offset of field: ",
1193 stringify!(sfVertex),
1194 "::",
1195 stringify!(texCoords)
1196 )
1197 );
1198}
1199extern "C" {
1200 pub fn sfRenderTexture_create(
1201 width: ::std::os::raw::c_uint,
1202 height: ::std::os::raw::c_uint,
1203 depthBuffer: sfBool,
1204 ) -> *mut sfRenderTexture;
1205}
1206extern "C" {
1207 pub fn sfRenderTexture_createWithSettings(
1208 width: ::std::os::raw::c_uint,
1209 height: ::std::os::raw::c_uint,
1210 settings: sfContextSettings,
1211 ) -> *mut sfRenderTexture;
1212}
1213extern "C" {
1214 pub fn sfRenderTexture_destroy(renderTexture: *mut sfRenderTexture);
1215}
1216extern "C" {
1217 pub fn sfRenderTexture_getSize(renderTexture: *const sfRenderTexture) -> sfVector2u;
1218}
1219extern "C" {
1220 pub fn sfRenderTexture_setActive(renderTexture: *mut sfRenderTexture, active: sfBool)
1221 -> sfBool;
1222}
1223extern "C" {
1224 pub fn sfRenderTexture_display(renderTexture: *mut sfRenderTexture);
1225}
1226extern "C" {
1227 pub fn sfRenderTexture_clear(renderTexture: *mut sfRenderTexture, color: sfColor);
1228}
1229extern "C" {
1230 pub fn sfRenderTexture_setView(renderTexture: *mut sfRenderTexture, view: *const sfView);
1231}
1232extern "C" {
1233 pub fn sfRenderTexture_getView(renderTexture: *const sfRenderTexture) -> *const sfView;
1234}
1235extern "C" {
1236 pub fn sfRenderTexture_getDefaultView(renderTexture: *const sfRenderTexture) -> *const sfView;
1237}
1238extern "C" {
1239 pub fn sfRenderTexture_getViewport(
1240 renderTexture: *const sfRenderTexture,
1241 view: *const sfView,
1242 ) -> sfIntRect;
1243}
1244extern "C" {
1245 pub fn sfRenderTexture_mapPixelToCoords(
1246 renderTexture: *const sfRenderTexture,
1247 point: sfVector2i,
1248 view: *const sfView,
1249 ) -> sfVector2f;
1250}
1251extern "C" {
1252 pub fn sfRenderTexture_mapCoordsToPixel(
1253 renderTexture: *const sfRenderTexture,
1254 point: sfVector2f,
1255 view: *const sfView,
1256 ) -> sfVector2i;
1257}
1258extern "C" {
1259 pub fn sfRenderTexture_drawSprite(
1260 renderTexture: *mut sfRenderTexture,
1261 object: *const sfSprite,
1262 states: *const sfRenderStates,
1263 );
1264}
1265extern "C" {
1266 pub fn sfRenderTexture_drawText(
1267 renderTexture: *mut sfRenderTexture,
1268 object: *const sfText,
1269 states: *const sfRenderStates,
1270 );
1271}
1272extern "C" {
1273 pub fn sfRenderTexture_drawShape(
1274 renderTexture: *mut sfRenderTexture,
1275 object: *const sfShape,
1276 states: *const sfRenderStates,
1277 );
1278}
1279extern "C" {
1280 pub fn sfRenderTexture_drawCircleShape(
1281 renderTexture: *mut sfRenderTexture,
1282 object: *const sfCircleShape,
1283 states: *const sfRenderStates,
1284 );
1285}
1286extern "C" {
1287 pub fn sfRenderTexture_drawConvexShape(
1288 renderTexture: *mut sfRenderTexture,
1289 object: *const sfConvexShape,
1290 states: *const sfRenderStates,
1291 );
1292}
1293extern "C" {
1294 pub fn sfRenderTexture_drawRectangleShape(
1295 renderTexture: *mut sfRenderTexture,
1296 object: *const sfRectangleShape,
1297 states: *const sfRenderStates,
1298 );
1299}
1300extern "C" {
1301 pub fn sfRenderTexture_drawVertexArray(
1302 renderTexture: *mut sfRenderTexture,
1303 object: *const sfVertexArray,
1304 states: *const sfRenderStates,
1305 );
1306}
1307extern "C" {
1308 pub fn sfRenderTexture_drawVertexBuffer(
1309 renderTexture: *mut sfRenderTexture,
1310 object: *const sfVertexBuffer,
1311 states: *const sfRenderStates,
1312 );
1313}
1314extern "C" {
1315 pub fn sfRenderTexture_drawPrimitives(
1316 renderTexture: *mut sfRenderTexture,
1317 vertices: *const sfVertex,
1318 vertexCount: usize,
1319 type_: sfPrimitiveType,
1320 states: *const sfRenderStates,
1321 );
1322}
1323extern "C" {
1324 pub fn sfRenderTexture_pushGLStates(renderTexture: *mut sfRenderTexture);
1325}
1326extern "C" {
1327 pub fn sfRenderTexture_popGLStates(renderTexture: *mut sfRenderTexture);
1328}
1329extern "C" {
1330 pub fn sfRenderTexture_resetGLStates(renderTexture: *mut sfRenderTexture);
1331}
1332extern "C" {
1333 pub fn sfRenderTexture_getTexture(renderTexture: *const sfRenderTexture) -> *const sfTexture;
1334}
1335extern "C" {
1336 pub fn sfRenderTexture_getMaximumAntialiasingLevel() -> ::std::os::raw::c_uint;
1337}
1338extern "C" {
1339 pub fn sfRenderTexture_setSmooth(renderTexture: *mut sfRenderTexture, smooth: sfBool);
1340}
1341extern "C" {
1342 pub fn sfRenderTexture_isSmooth(renderTexture: *const sfRenderTexture) -> sfBool;
1343}
1344extern "C" {
1345 pub fn sfRenderTexture_setRepeated(renderTexture: *mut sfRenderTexture, repeated: sfBool);
1346}
1347extern "C" {
1348 pub fn sfRenderTexture_isRepeated(renderTexture: *const sfRenderTexture) -> sfBool;
1349}
1350extern "C" {
1351 pub fn sfRenderTexture_generateMipmap(renderTexture: *mut sfRenderTexture) -> sfBool;
1352}
1353extern "C" {
1354 pub fn sfRenderWindow_create(
1355 mode: sfVideoMode,
1356 title: *const ::std::os::raw::c_char,
1357 style: sfUint32,
1358 settings: *const sfContextSettings,
1359 ) -> *mut sfRenderWindow;
1360}
1361extern "C" {
1362 pub fn sfRenderWindow_createUnicode(
1363 mode: sfVideoMode,
1364 title: *const sfUint32,
1365 style: sfUint32,
1366 settings: *const sfContextSettings,
1367 ) -> *mut sfRenderWindow;
1368}
1369extern "C" {
1370 pub fn sfRenderWindow_createFromHandle(
1371 handle: sfWindowHandle,
1372 settings: *const sfContextSettings,
1373 ) -> *mut sfRenderWindow;
1374}
1375extern "C" {
1376 pub fn sfRenderWindow_destroy(renderWindow: *mut sfRenderWindow);
1377}
1378extern "C" {
1379 pub fn sfRenderWindow_close(renderWindow: *mut sfRenderWindow);
1380}
1381extern "C" {
1382 pub fn sfRenderWindow_isOpen(renderWindow: *const sfRenderWindow) -> sfBool;
1383}
1384extern "C" {
1385 pub fn sfRenderWindow_getSettings(renderWindow: *const sfRenderWindow) -> sfContextSettings;
1386}
1387extern "C" {
1388 pub fn sfRenderWindow_pollEvent(
1389 renderWindow: *mut sfRenderWindow,
1390 event: *mut sfEvent,
1391 ) -> sfBool;
1392}
1393extern "C" {
1394 pub fn sfRenderWindow_waitEvent(
1395 renderWindow: *mut sfRenderWindow,
1396 event: *mut sfEvent,
1397 ) -> sfBool;
1398}
1399extern "C" {
1400 pub fn sfRenderWindow_getPosition(renderWindow: *const sfRenderWindow) -> sfVector2i;
1401}
1402extern "C" {
1403 pub fn sfRenderWindow_setPosition(renderWindow: *mut sfRenderWindow, position: sfVector2i);
1404}
1405extern "C" {
1406 pub fn sfRenderWindow_getSize(renderWindow: *const sfRenderWindow) -> sfVector2u;
1407}
1408extern "C" {
1409 pub fn sfRenderWindow_setSize(renderWindow: *mut sfRenderWindow, size: sfVector2u);
1410}
1411extern "C" {
1412 pub fn sfRenderWindow_setTitle(
1413 renderWindow: *mut sfRenderWindow,
1414 title: *const ::std::os::raw::c_char,
1415 );
1416}
1417extern "C" {
1418 pub fn sfRenderWindow_setUnicodeTitle(
1419 renderWindow: *mut sfRenderWindow,
1420 title: *const sfUint32,
1421 );
1422}
1423extern "C" {
1424 pub fn sfRenderWindow_setIcon(
1425 renderWindow: *mut sfRenderWindow,
1426 width: ::std::os::raw::c_uint,
1427 height: ::std::os::raw::c_uint,
1428 pixels: *const sfUint8,
1429 );
1430}
1431extern "C" {
1432 pub fn sfRenderWindow_setVisible(renderWindow: *mut sfRenderWindow, visible: sfBool);
1433}
1434extern "C" {
1435 pub fn sfRenderWindow_setVerticalSyncEnabled(
1436 renderWindow: *mut sfRenderWindow,
1437 enabled: sfBool,
1438 );
1439}
1440extern "C" {
1441 pub fn sfRenderWindow_setMouseCursorVisible(renderWindow: *mut sfRenderWindow, show: sfBool);
1442}
1443extern "C" {
1444 pub fn sfRenderWindow_setMouseCursorGrabbed(renderWindow: *mut sfRenderWindow, grabbed: sfBool);
1445}
1446extern "C" {
1447 pub fn sfRenderWindow_setMouseCursor(window: *mut sfRenderWindow, cursor: *const sfCursor);
1448}
1449extern "C" {
1450 pub fn sfRenderWindow_setKeyRepeatEnabled(renderWindow: *mut sfRenderWindow, enabled: sfBool);
1451}
1452extern "C" {
1453 pub fn sfRenderWindow_setFramerateLimit(
1454 renderWindow: *mut sfRenderWindow,
1455 limit: ::std::os::raw::c_uint,
1456 );
1457}
1458extern "C" {
1459 pub fn sfRenderWindow_setJoystickThreshold(renderWindow: *mut sfRenderWindow, threshold: f32);
1460}
1461extern "C" {
1462 pub fn sfRenderWindow_setActive(renderWindow: *mut sfRenderWindow, active: sfBool) -> sfBool;
1463}
1464extern "C" {
1465 pub fn sfRenderWindow_requestFocus(renderWindow: *mut sfRenderWindow);
1466}
1467extern "C" {
1468 pub fn sfRenderWindow_hasFocus(renderWindow: *const sfRenderWindow) -> sfBool;
1469}
1470extern "C" {
1471 pub fn sfRenderWindow_display(renderWindow: *mut sfRenderWindow);
1472}
1473extern "C" {
1474 pub fn sfRenderWindow_getSystemHandle(renderWindow: *const sfRenderWindow) -> sfWindowHandle;
1475}
1476extern "C" {
1477 pub fn sfRenderWindow_clear(renderWindow: *mut sfRenderWindow, color: sfColor);
1478}
1479extern "C" {
1480 pub fn sfRenderWindow_setView(renderWindow: *mut sfRenderWindow, view: *const sfView);
1481}
1482extern "C" {
1483 pub fn sfRenderWindow_getView(renderWindow: *const sfRenderWindow) -> *const sfView;
1484}
1485extern "C" {
1486 pub fn sfRenderWindow_getDefaultView(renderWindow: *const sfRenderWindow) -> *const sfView;
1487}
1488extern "C" {
1489 pub fn sfRenderWindow_getViewport(
1490 renderWindow: *const sfRenderWindow,
1491 view: *const sfView,
1492 ) -> sfIntRect;
1493}
1494extern "C" {
1495 pub fn sfRenderWindow_mapPixelToCoords(
1496 renderWindow: *const sfRenderWindow,
1497 point: sfVector2i,
1498 view: *const sfView,
1499 ) -> sfVector2f;
1500}
1501extern "C" {
1502 pub fn sfRenderWindow_mapCoordsToPixel(
1503 renderWindow: *const sfRenderWindow,
1504 point: sfVector2f,
1505 view: *const sfView,
1506 ) -> sfVector2i;
1507}
1508extern "C" {
1509 pub fn sfRenderWindow_drawSprite(
1510 renderWindow: *mut sfRenderWindow,
1511 object: *const sfSprite,
1512 states: *const sfRenderStates,
1513 );
1514}
1515extern "C" {
1516 pub fn sfRenderWindow_drawText(
1517 renderWindow: *mut sfRenderWindow,
1518 object: *const sfText,
1519 states: *const sfRenderStates,
1520 );
1521}
1522extern "C" {
1523 pub fn sfRenderWindow_drawShape(
1524 renderWindow: *mut sfRenderWindow,
1525 object: *const sfShape,
1526 states: *const sfRenderStates,
1527 );
1528}
1529extern "C" {
1530 pub fn sfRenderWindow_drawCircleShape(
1531 renderWindow: *mut sfRenderWindow,
1532 object: *const sfCircleShape,
1533 states: *const sfRenderStates,
1534 );
1535}
1536extern "C" {
1537 pub fn sfRenderWindow_drawConvexShape(
1538 renderWindow: *mut sfRenderWindow,
1539 object: *const sfConvexShape,
1540 states: *const sfRenderStates,
1541 );
1542}
1543extern "C" {
1544 pub fn sfRenderWindow_drawRectangleShape(
1545 renderWindow: *mut sfRenderWindow,
1546 object: *const sfRectangleShape,
1547 states: *const sfRenderStates,
1548 );
1549}
1550extern "C" {
1551 pub fn sfRenderWindow_drawVertexArray(
1552 renderWindow: *mut sfRenderWindow,
1553 object: *const sfVertexArray,
1554 states: *const sfRenderStates,
1555 );
1556}
1557extern "C" {
1558 pub fn sfRenderWindow_drawVertexBuffer(
1559 renderWindow: *mut sfRenderWindow,
1560 object: *const sfVertexBuffer,
1561 states: *const sfRenderStates,
1562 );
1563}
1564extern "C" {
1565 pub fn sfRenderWindow_drawPrimitives(
1566 renderWindow: *mut sfRenderWindow,
1567 vertices: *const sfVertex,
1568 vertexCount: usize,
1569 type_: sfPrimitiveType,
1570 states: *const sfRenderStates,
1571 );
1572}
1573extern "C" {
1574 pub fn sfRenderWindow_pushGLStates(renderWindow: *mut sfRenderWindow);
1575}
1576extern "C" {
1577 pub fn sfRenderWindow_popGLStates(renderWindow: *mut sfRenderWindow);
1578}
1579extern "C" {
1580 pub fn sfRenderWindow_resetGLStates(renderWindow: *mut sfRenderWindow);
1581}
1582extern "C" {
1583 pub fn sfRenderWindow_capture(renderWindow: *const sfRenderWindow) -> *mut sfImage;
1584}
1585extern "C" {
1586 pub fn sfMouse_getPositionRenderWindow(relativeTo: *const sfRenderWindow) -> sfVector2i;
1587}
1588extern "C" {
1589 pub fn sfMouse_setPositionRenderWindow(position: sfVector2i, relativeTo: *const sfRenderWindow);
1590}
1591extern "C" {
1592 pub fn sfTouch_getPositionRenderWindow(
1593 finger: ::std::os::raw::c_uint,
1594 relativeTo: *const sfRenderWindow,
1595 ) -> sfVector2i;
1596}
1597pub type sfGlslVec2 = sfVector2f;
1598pub type sfGlslIvec2 = sfVector2i;
1599#[repr(C)]
1600#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
1601pub struct sfGlslBvec2 {
1602 pub x: sfBool,
1603 pub y: sfBool,
1604}
1605#[test]
1606fn bindgen_test_layout_sfGlslBvec2() {
1607 assert_eq!(
1608 ::std::mem::size_of::<sfGlslBvec2>(),
1609 8usize,
1610 concat!("Size of: ", stringify!(sfGlslBvec2))
1611 );
1612 assert_eq!(
1613 ::std::mem::align_of::<sfGlslBvec2>(),
1614 4usize,
1615 concat!("Alignment of ", stringify!(sfGlslBvec2))
1616 );
1617 assert_eq!(
1618 unsafe { &(*(::std::ptr::null::<sfGlslBvec2>())).x as *const _ as usize },
1619 0usize,
1620 concat!(
1621 "Offset of field: ",
1622 stringify!(sfGlslBvec2),
1623 "::",
1624 stringify!(x)
1625 )
1626 );
1627 assert_eq!(
1628 unsafe { &(*(::std::ptr::null::<sfGlslBvec2>())).y as *const _ as usize },
1629 4usize,
1630 concat!(
1631 "Offset of field: ",
1632 stringify!(sfGlslBvec2),
1633 "::",
1634 stringify!(y)
1635 )
1636 );
1637}
1638pub type sfGlslVec3 = sfVector3f;
1639#[repr(C)]
1640#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
1641pub struct sfGlslIvec3 {
1642 pub x: ::std::os::raw::c_int,
1643 pub y: ::std::os::raw::c_int,
1644 pub z: ::std::os::raw::c_int,
1645}
1646#[test]
1647fn bindgen_test_layout_sfGlslIvec3() {
1648 assert_eq!(
1649 ::std::mem::size_of::<sfGlslIvec3>(),
1650 12usize,
1651 concat!("Size of: ", stringify!(sfGlslIvec3))
1652 );
1653 assert_eq!(
1654 ::std::mem::align_of::<sfGlslIvec3>(),
1655 4usize,
1656 concat!("Alignment of ", stringify!(sfGlslIvec3))
1657 );
1658 assert_eq!(
1659 unsafe { &(*(::std::ptr::null::<sfGlslIvec3>())).x as *const _ as usize },
1660 0usize,
1661 concat!(
1662 "Offset of field: ",
1663 stringify!(sfGlslIvec3),
1664 "::",
1665 stringify!(x)
1666 )
1667 );
1668 assert_eq!(
1669 unsafe { &(*(::std::ptr::null::<sfGlslIvec3>())).y as *const _ as usize },
1670 4usize,
1671 concat!(
1672 "Offset of field: ",
1673 stringify!(sfGlslIvec3),
1674 "::",
1675 stringify!(y)
1676 )
1677 );
1678 assert_eq!(
1679 unsafe { &(*(::std::ptr::null::<sfGlslIvec3>())).z as *const _ as usize },
1680 8usize,
1681 concat!(
1682 "Offset of field: ",
1683 stringify!(sfGlslIvec3),
1684 "::",
1685 stringify!(z)
1686 )
1687 );
1688}
1689#[repr(C)]
1690#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
1691pub struct sfGlslBvec3 {
1692 pub x: sfBool,
1693 pub y: sfBool,
1694 pub z: sfBool,
1695}
1696#[test]
1697fn bindgen_test_layout_sfGlslBvec3() {
1698 assert_eq!(
1699 ::std::mem::size_of::<sfGlslBvec3>(),
1700 12usize,
1701 concat!("Size of: ", stringify!(sfGlslBvec3))
1702 );
1703 assert_eq!(
1704 ::std::mem::align_of::<sfGlslBvec3>(),
1705 4usize,
1706 concat!("Alignment of ", stringify!(sfGlslBvec3))
1707 );
1708 assert_eq!(
1709 unsafe { &(*(::std::ptr::null::<sfGlslBvec3>())).x as *const _ as usize },
1710 0usize,
1711 concat!(
1712 "Offset of field: ",
1713 stringify!(sfGlslBvec3),
1714 "::",
1715 stringify!(x)
1716 )
1717 );
1718 assert_eq!(
1719 unsafe { &(*(::std::ptr::null::<sfGlslBvec3>())).y as *const _ as usize },
1720 4usize,
1721 concat!(
1722 "Offset of field: ",
1723 stringify!(sfGlslBvec3),
1724 "::",
1725 stringify!(y)
1726 )
1727 );
1728 assert_eq!(
1729 unsafe { &(*(::std::ptr::null::<sfGlslBvec3>())).z as *const _ as usize },
1730 8usize,
1731 concat!(
1732 "Offset of field: ",
1733 stringify!(sfGlslBvec3),
1734 "::",
1735 stringify!(z)
1736 )
1737 );
1738}
1739#[repr(C)]
1740#[derive(Debug, Copy, Clone, PartialOrd, PartialEq)]
1741pub struct sfGlslVec4 {
1742 pub x: f32,
1743 pub y: f32,
1744 pub z: f32,
1745 pub w: f32,
1746}
1747#[test]
1748fn bindgen_test_layout_sfGlslVec4() {
1749 assert_eq!(
1750 ::std::mem::size_of::<sfGlslVec4>(),
1751 16usize,
1752 concat!("Size of: ", stringify!(sfGlslVec4))
1753 );
1754 assert_eq!(
1755 ::std::mem::align_of::<sfGlslVec4>(),
1756 4usize,
1757 concat!("Alignment of ", stringify!(sfGlslVec4))
1758 );
1759 assert_eq!(
1760 unsafe { &(*(::std::ptr::null::<sfGlslVec4>())).x as *const _ as usize },
1761 0usize,
1762 concat!(
1763 "Offset of field: ",
1764 stringify!(sfGlslVec4),
1765 "::",
1766 stringify!(x)
1767 )
1768 );
1769 assert_eq!(
1770 unsafe { &(*(::std::ptr::null::<sfGlslVec4>())).y as *const _ as usize },
1771 4usize,
1772 concat!(
1773 "Offset of field: ",
1774 stringify!(sfGlslVec4),
1775 "::",
1776 stringify!(y)
1777 )
1778 );
1779 assert_eq!(
1780 unsafe { &(*(::std::ptr::null::<sfGlslVec4>())).z as *const _ as usize },
1781 8usize,
1782 concat!(
1783 "Offset of field: ",
1784 stringify!(sfGlslVec4),
1785 "::",
1786 stringify!(z)
1787 )
1788 );
1789 assert_eq!(
1790 unsafe { &(*(::std::ptr::null::<sfGlslVec4>())).w as *const _ as usize },
1791 12usize,
1792 concat!(
1793 "Offset of field: ",
1794 stringify!(sfGlslVec4),
1795 "::",
1796 stringify!(w)
1797 )
1798 );
1799}
1800#[repr(C)]
1801#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
1802pub struct sfGlslIvec4 {
1803 pub x: ::std::os::raw::c_int,
1804 pub y: ::std::os::raw::c_int,
1805 pub z: ::std::os::raw::c_int,
1806 pub w: ::std::os::raw::c_int,
1807}
1808#[test]
1809fn bindgen_test_layout_sfGlslIvec4() {
1810 assert_eq!(
1811 ::std::mem::size_of::<sfGlslIvec4>(),
1812 16usize,
1813 concat!("Size of: ", stringify!(sfGlslIvec4))
1814 );
1815 assert_eq!(
1816 ::std::mem::align_of::<sfGlslIvec4>(),
1817 4usize,
1818 concat!("Alignment of ", stringify!(sfGlslIvec4))
1819 );
1820 assert_eq!(
1821 unsafe { &(*(::std::ptr::null::<sfGlslIvec4>())).x as *const _ as usize },
1822 0usize,
1823 concat!(
1824 "Offset of field: ",
1825 stringify!(sfGlslIvec4),
1826 "::",
1827 stringify!(x)
1828 )
1829 );
1830 assert_eq!(
1831 unsafe { &(*(::std::ptr::null::<sfGlslIvec4>())).y as *const _ as usize },
1832 4usize,
1833 concat!(
1834 "Offset of field: ",
1835 stringify!(sfGlslIvec4),
1836 "::",
1837 stringify!(y)
1838 )
1839 );
1840 assert_eq!(
1841 unsafe { &(*(::std::ptr::null::<sfGlslIvec4>())).z as *const _ as usize },
1842 8usize,
1843 concat!(
1844 "Offset of field: ",
1845 stringify!(sfGlslIvec4),
1846 "::",
1847 stringify!(z)
1848 )
1849 );
1850 assert_eq!(
1851 unsafe { &(*(::std::ptr::null::<sfGlslIvec4>())).w as *const _ as usize },
1852 12usize,
1853 concat!(
1854 "Offset of field: ",
1855 stringify!(sfGlslIvec4),
1856 "::",
1857 stringify!(w)
1858 )
1859 );
1860}
1861#[repr(C)]
1862#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
1863pub struct sfGlslBvec4 {
1864 pub x: sfBool,
1865 pub y: sfBool,
1866 pub z: sfBool,
1867 pub w: sfBool,
1868}
1869#[test]
1870fn bindgen_test_layout_sfGlslBvec4() {
1871 assert_eq!(
1872 ::std::mem::size_of::<sfGlslBvec4>(),
1873 16usize,
1874 concat!("Size of: ", stringify!(sfGlslBvec4))
1875 );
1876 assert_eq!(
1877 ::std::mem::align_of::<sfGlslBvec4>(),
1878 4usize,
1879 concat!("Alignment of ", stringify!(sfGlslBvec4))
1880 );
1881 assert_eq!(
1882 unsafe { &(*(::std::ptr::null::<sfGlslBvec4>())).x as *const _ as usize },
1883 0usize,
1884 concat!(
1885 "Offset of field: ",
1886 stringify!(sfGlslBvec4),
1887 "::",
1888 stringify!(x)
1889 )
1890 );
1891 assert_eq!(
1892 unsafe { &(*(::std::ptr::null::<sfGlslBvec4>())).y as *const _ as usize },
1893 4usize,
1894 concat!(
1895 "Offset of field: ",
1896 stringify!(sfGlslBvec4),
1897 "::",
1898 stringify!(y)
1899 )
1900 );
1901 assert_eq!(
1902 unsafe { &(*(::std::ptr::null::<sfGlslBvec4>())).z as *const _ as usize },
1903 8usize,
1904 concat!(
1905 "Offset of field: ",
1906 stringify!(sfGlslBvec4),
1907 "::",
1908 stringify!(z)
1909 )
1910 );
1911 assert_eq!(
1912 unsafe { &(*(::std::ptr::null::<sfGlslBvec4>())).w as *const _ as usize },
1913 12usize,
1914 concat!(
1915 "Offset of field: ",
1916 stringify!(sfGlslBvec4),
1917 "::",
1918 stringify!(w)
1919 )
1920 );
1921}
1922#[repr(C)]
1923#[derive(Debug, Copy, Clone, PartialOrd, PartialEq)]
1924pub struct sfGlslMat3 {
1925 pub array: [f32; 9usize],
1926}
1927#[test]
1928fn bindgen_test_layout_sfGlslMat3() {
1929 assert_eq!(
1930 ::std::mem::size_of::<sfGlslMat3>(),
1931 36usize,
1932 concat!("Size of: ", stringify!(sfGlslMat3))
1933 );
1934 assert_eq!(
1935 ::std::mem::align_of::<sfGlslMat3>(),
1936 4usize,
1937 concat!("Alignment of ", stringify!(sfGlslMat3))
1938 );
1939 assert_eq!(
1940 unsafe { &(*(::std::ptr::null::<sfGlslMat3>())).array as *const _ as usize },
1941 0usize,
1942 concat!(
1943 "Offset of field: ",
1944 stringify!(sfGlslMat3),
1945 "::",
1946 stringify!(array)
1947 )
1948 );
1949}
1950#[repr(C)]
1951#[derive(Debug, Copy, Clone, PartialOrd, PartialEq)]
1952pub struct sfGlslMat4 {
1953 pub array: [f32; 16usize],
1954}
1955#[test]
1956fn bindgen_test_layout_sfGlslMat4() {
1957 assert_eq!(
1958 ::std::mem::size_of::<sfGlslMat4>(),
1959 64usize,
1960 concat!("Size of: ", stringify!(sfGlslMat4))
1961 );
1962 assert_eq!(
1963 ::std::mem::align_of::<sfGlslMat4>(),
1964 4usize,
1965 concat!("Alignment of ", stringify!(sfGlslMat4))
1966 );
1967 assert_eq!(
1968 unsafe { &(*(::std::ptr::null::<sfGlslMat4>())).array as *const _ as usize },
1969 0usize,
1970 concat!(
1971 "Offset of field: ",
1972 stringify!(sfGlslMat4),
1973 "::",
1974 stringify!(array)
1975 )
1976 );
1977}
1978extern "C" {
1979 pub fn sfShader_createFromFile(
1980 vertexShaderFilename: *const ::std::os::raw::c_char,
1981 geometryShaderFilename: *const ::std::os::raw::c_char,
1982 fragmentShaderFilename: *const ::std::os::raw::c_char,
1983 ) -> *mut sfShader;
1984}
1985extern "C" {
1986 pub fn sfShader_createFromMemory(
1987 vertexShader: *const ::std::os::raw::c_char,
1988 geometryShader: *const ::std::os::raw::c_char,
1989 fragmentShader: *const ::std::os::raw::c_char,
1990 ) -> *mut sfShader;
1991}
1992extern "C" {
1993 pub fn sfShader_createFromStream(
1994 vertexShaderStream: *mut sfInputStream,
1995 geometryShaderStream: *mut sfInputStream,
1996 fragmentShaderStream: *mut sfInputStream,
1997 ) -> *mut sfShader;
1998}
1999extern "C" {
2000 pub fn sfShader_destroy(shader: *mut sfShader);
2001}
2002extern "C" {
2003 pub fn sfShader_setFloatUniform(
2004 shader: *mut sfShader,
2005 name: *const ::std::os::raw::c_char,
2006 x: f32,
2007 );
2008}
2009extern "C" {
2010 pub fn sfShader_setVec2Uniform(
2011 shader: *mut sfShader,
2012 name: *const ::std::os::raw::c_char,
2013 vector: sfGlslVec2,
2014 );
2015}
2016extern "C" {
2017 pub fn sfShader_setVec3Uniform(
2018 shader: *mut sfShader,
2019 name: *const ::std::os::raw::c_char,
2020 vector: sfGlslVec3,
2021 );
2022}
2023extern "C" {
2024 pub fn sfShader_setVec4Uniform(
2025 shader: *mut sfShader,
2026 name: *const ::std::os::raw::c_char,
2027 vector: sfGlslVec4,
2028 );
2029}
2030extern "C" {
2031 pub fn sfShader_setColorUniform(
2032 shader: *mut sfShader,
2033 name: *const ::std::os::raw::c_char,
2034 color: sfColor,
2035 );
2036}
2037extern "C" {
2038 pub fn sfShader_setIntUniform(
2039 shader: *mut sfShader,
2040 name: *const ::std::os::raw::c_char,
2041 x: ::std::os::raw::c_int,
2042 );
2043}
2044extern "C" {
2045 pub fn sfShader_setIvec2Uniform(
2046 shader: *mut sfShader,
2047 name: *const ::std::os::raw::c_char,
2048 vector: sfGlslIvec2,
2049 );
2050}
2051extern "C" {
2052 pub fn sfShader_setIvec3Uniform(
2053 shader: *mut sfShader,
2054 name: *const ::std::os::raw::c_char,
2055 vector: sfGlslIvec3,
2056 );
2057}
2058extern "C" {
2059 pub fn sfShader_setIvec4Uniform(
2060 shader: *mut sfShader,
2061 name: *const ::std::os::raw::c_char,
2062 vector: sfGlslIvec4,
2063 );
2064}
2065extern "C" {
2066 pub fn sfShader_setIntColorUniform(
2067 shader: *mut sfShader,
2068 name: *const ::std::os::raw::c_char,
2069 color: sfColor,
2070 );
2071}
2072extern "C" {
2073 pub fn sfShader_setBoolUniform(
2074 shader: *mut sfShader,
2075 name: *const ::std::os::raw::c_char,
2076 x: sfBool,
2077 );
2078}
2079extern "C" {
2080 pub fn sfShader_setBvec2Uniform(
2081 shader: *mut sfShader,
2082 name: *const ::std::os::raw::c_char,
2083 vector: sfGlslBvec2,
2084 );
2085}
2086extern "C" {
2087 pub fn sfShader_setBvec3Uniform(
2088 shader: *mut sfShader,
2089 name: *const ::std::os::raw::c_char,
2090 vector: sfGlslBvec3,
2091 );
2092}
2093extern "C" {
2094 pub fn sfShader_setBvec4Uniform(
2095 shader: *mut sfShader,
2096 name: *const ::std::os::raw::c_char,
2097 vector: sfGlslBvec4,
2098 );
2099}
2100extern "C" {
2101 pub fn sfShader_setMat3Uniform(
2102 shader: *mut sfShader,
2103 name: *const ::std::os::raw::c_char,
2104 matrix: *const sfGlslMat3,
2105 );
2106}
2107extern "C" {
2108 pub fn sfShader_setMat4Uniform(
2109 shader: *mut sfShader,
2110 name: *const ::std::os::raw::c_char,
2111 matrix: *const sfGlslMat4,
2112 );
2113}
2114extern "C" {
2115 pub fn sfShader_setTextureUniform(
2116 shader: *mut sfShader,
2117 name: *const ::std::os::raw::c_char,
2118 texture: *const sfTexture,
2119 );
2120}
2121extern "C" {
2122 pub fn sfShader_setCurrentTextureUniform(
2123 shader: *mut sfShader,
2124 name: *const ::std::os::raw::c_char,
2125 );
2126}
2127extern "C" {
2128 pub fn sfShader_setFloatUniformArray(
2129 shader: *mut sfShader,
2130 name: *const ::std::os::raw::c_char,
2131 scalarArray: *const f32,
2132 length: usize,
2133 );
2134}
2135extern "C" {
2136 pub fn sfShader_setVec2UniformArray(
2137 shader: *mut sfShader,
2138 name: *const ::std::os::raw::c_char,
2139 vectorArray: *const sfGlslVec2,
2140 length: usize,
2141 );
2142}
2143extern "C" {
2144 pub fn sfShader_setVec3UniformArray(
2145 shader: *mut sfShader,
2146 name: *const ::std::os::raw::c_char,
2147 vectorArray: *const sfGlslVec3,
2148 length: usize,
2149 );
2150}
2151extern "C" {
2152 pub fn sfShader_setVec4UniformArray(
2153 shader: *mut sfShader,
2154 name: *const ::std::os::raw::c_char,
2155 vectorArray: *const sfGlslVec4,
2156 length: usize,
2157 );
2158}
2159extern "C" {
2160 pub fn sfShader_setMat3UniformArray(
2161 shader: *mut sfShader,
2162 name: *const ::std::os::raw::c_char,
2163 matrixArray: *const sfGlslMat3,
2164 length: usize,
2165 );
2166}
2167extern "C" {
2168 pub fn sfShader_setMat4UniformArray(
2169 shader: *mut sfShader,
2170 name: *const ::std::os::raw::c_char,
2171 matrixArray: *const sfGlslMat4,
2172 length: usize,
2173 );
2174}
2175extern "C" {
2176 pub fn sfShader_setFloatParameter(
2177 shader: *mut sfShader,
2178 name: *const ::std::os::raw::c_char,
2179 x: f32,
2180 );
2181}
2182extern "C" {
2183 pub fn sfShader_setFloat2Parameter(
2184 shader: *mut sfShader,
2185 name: *const ::std::os::raw::c_char,
2186 x: f32,
2187 y: f32,
2188 );
2189}
2190extern "C" {
2191 pub fn sfShader_setFloat3Parameter(
2192 shader: *mut sfShader,
2193 name: *const ::std::os::raw::c_char,
2194 x: f32,
2195 y: f32,
2196 z: f32,
2197 );
2198}
2199extern "C" {
2200 pub fn sfShader_setFloat4Parameter(
2201 shader: *mut sfShader,
2202 name: *const ::std::os::raw::c_char,
2203 x: f32,
2204 y: f32,
2205 z: f32,
2206 w: f32,
2207 );
2208}
2209extern "C" {
2210 pub fn sfShader_setVector2Parameter(
2211 shader: *mut sfShader,
2212 name: *const ::std::os::raw::c_char,
2213 vector: sfVector2f,
2214 );
2215}
2216extern "C" {
2217 pub fn sfShader_setVector3Parameter(
2218 shader: *mut sfShader,
2219 name: *const ::std::os::raw::c_char,
2220 vector: sfVector3f,
2221 );
2222}
2223extern "C" {
2224 pub fn sfShader_setColorParameter(
2225 shader: *mut sfShader,
2226 name: *const ::std::os::raw::c_char,
2227 color: sfColor,
2228 );
2229}
2230extern "C" {
2231 pub fn sfShader_setTransformParameter(
2232 shader: *mut sfShader,
2233 name: *const ::std::os::raw::c_char,
2234 transform: sfTransform,
2235 );
2236}
2237extern "C" {
2238 pub fn sfShader_setTextureParameter(
2239 shader: *mut sfShader,
2240 name: *const ::std::os::raw::c_char,
2241 texture: *const sfTexture,
2242 );
2243}
2244extern "C" {
2245 pub fn sfShader_setCurrentTextureParameter(
2246 shader: *mut sfShader,
2247 name: *const ::std::os::raw::c_char,
2248 );
2249}
2250extern "C" {
2251 pub fn sfShader_getNativeHandle(shader: *const sfShader) -> ::std::os::raw::c_uint;
2252}
2253extern "C" {
2254 pub fn sfShader_bind(shader: *const sfShader);
2255}
2256extern "C" {
2257 pub fn sfShader_isAvailable() -> sfBool;
2258}
2259extern "C" {
2260 pub fn sfShader_isGeometryAvailable() -> sfBool;
2261}
2262pub type sfShapeGetPointCountCallback =
2263 ::std::option::Option<unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void) -> usize>;
2264pub type sfShapeGetPointCallback = ::std::option::Option<
2265 unsafe extern "C" fn(arg1: usize, arg2: *mut ::std::os::raw::c_void) -> sfVector2f,
2266>;
2267extern "C" {
2268 pub fn sfShape_create(
2269 getPointCount: sfShapeGetPointCountCallback,
2270 getPoint: sfShapeGetPointCallback,
2271 userData: *mut ::std::os::raw::c_void,
2272 ) -> *mut sfShape;
2273}
2274extern "C" {
2275 pub fn sfShape_destroy(shape: *mut sfShape);
2276}
2277extern "C" {
2278 pub fn sfShape_setPosition(shape: *mut sfShape, position: sfVector2f);
2279}
2280extern "C" {
2281 pub fn sfShape_setRotation(shape: *mut sfShape, angle: f32);
2282}
2283extern "C" {
2284 pub fn sfShape_setScale(shape: *mut sfShape, scale: sfVector2f);
2285}
2286extern "C" {
2287 pub fn sfShape_setOrigin(shape: *mut sfShape, origin: sfVector2f);
2288}
2289extern "C" {
2290 pub fn sfShape_getPosition(shape: *const sfShape) -> sfVector2f;
2291}
2292extern "C" {
2293 pub fn sfShape_getRotation(shape: *const sfShape) -> f32;
2294}
2295extern "C" {
2296 pub fn sfShape_getScale(shape: *const sfShape) -> sfVector2f;
2297}
2298extern "C" {
2299 pub fn sfShape_getOrigin(shape: *const sfShape) -> sfVector2f;
2300}
2301extern "C" {
2302 pub fn sfShape_move(shape: *mut sfShape, offset: sfVector2f);
2303}
2304extern "C" {
2305 pub fn sfShape_rotate(shape: *mut sfShape, angle: f32);
2306}
2307extern "C" {
2308 pub fn sfShape_scale(shape: *mut sfShape, factors: sfVector2f);
2309}
2310extern "C" {
2311 pub fn sfShape_getTransform(shape: *const sfShape) -> sfTransform;
2312}
2313extern "C" {
2314 pub fn sfShape_getInverseTransform(shape: *const sfShape) -> sfTransform;
2315}
2316extern "C" {
2317 pub fn sfShape_setTexture(shape: *mut sfShape, texture: *const sfTexture, resetRect: sfBool);
2318}
2319extern "C" {
2320 pub fn sfShape_setTextureRect(shape: *mut sfShape, rect: sfIntRect);
2321}
2322extern "C" {
2323 pub fn sfShape_setFillColor(shape: *mut sfShape, color: sfColor);
2324}
2325extern "C" {
2326 pub fn sfShape_setOutlineColor(shape: *mut sfShape, color: sfColor);
2327}
2328extern "C" {
2329 pub fn sfShape_setOutlineThickness(shape: *mut sfShape, thickness: f32);
2330}
2331extern "C" {
2332 pub fn sfShape_getTexture(shape: *const sfShape) -> *const sfTexture;
2333}
2334extern "C" {
2335 pub fn sfShape_getTextureRect(shape: *const sfShape) -> sfIntRect;
2336}
2337extern "C" {
2338 pub fn sfShape_getFillColor(shape: *const sfShape) -> sfColor;
2339}
2340extern "C" {
2341 pub fn sfShape_getOutlineColor(shape: *const sfShape) -> sfColor;
2342}
2343extern "C" {
2344 pub fn sfShape_getOutlineThickness(shape: *const sfShape) -> f32;
2345}
2346extern "C" {
2347 pub fn sfShape_getPointCount(shape: *const sfShape) -> usize;
2348}
2349extern "C" {
2350 pub fn sfShape_getPoint(shape: *const sfShape, index: usize) -> sfVector2f;
2351}
2352extern "C" {
2353 pub fn sfShape_getLocalBounds(shape: *const sfShape) -> sfFloatRect;
2354}
2355extern "C" {
2356 pub fn sfShape_getGlobalBounds(shape: *const sfShape) -> sfFloatRect;
2357}
2358extern "C" {
2359 pub fn sfShape_update(shape: *mut sfShape);
2360}
2361extern "C" {
2362 pub fn sfSprite_create() -> *mut sfSprite;
2363}
2364extern "C" {
2365 pub fn sfSprite_copy(sprite: *const sfSprite) -> *mut sfSprite;
2366}
2367extern "C" {
2368 pub fn sfSprite_destroy(sprite: *mut sfSprite);
2369}
2370extern "C" {
2371 pub fn sfSprite_setPosition(sprite: *mut sfSprite, position: sfVector2f);
2372}
2373extern "C" {
2374 pub fn sfSprite_setRotation(sprite: *mut sfSprite, angle: f32);
2375}
2376extern "C" {
2377 pub fn sfSprite_setScale(sprite: *mut sfSprite, scale: sfVector2f);
2378}
2379extern "C" {
2380 pub fn sfSprite_setOrigin(sprite: *mut sfSprite, origin: sfVector2f);
2381}
2382extern "C" {
2383 pub fn sfSprite_getPosition(sprite: *const sfSprite) -> sfVector2f;
2384}
2385extern "C" {
2386 pub fn sfSprite_getRotation(sprite: *const sfSprite) -> f32;
2387}
2388extern "C" {
2389 pub fn sfSprite_getScale(sprite: *const sfSprite) -> sfVector2f;
2390}
2391extern "C" {
2392 pub fn sfSprite_getOrigin(sprite: *const sfSprite) -> sfVector2f;
2393}
2394extern "C" {
2395 pub fn sfSprite_move(sprite: *mut sfSprite, offset: sfVector2f);
2396}
2397extern "C" {
2398 pub fn sfSprite_rotate(sprite: *mut sfSprite, angle: f32);
2399}
2400extern "C" {
2401 pub fn sfSprite_scale(sprite: *mut sfSprite, factors: sfVector2f);
2402}
2403extern "C" {
2404 pub fn sfSprite_getTransform(sprite: *const sfSprite) -> sfTransform;
2405}
2406extern "C" {
2407 pub fn sfSprite_getInverseTransform(sprite: *const sfSprite) -> sfTransform;
2408}
2409extern "C" {
2410 pub fn sfSprite_setTexture(sprite: *mut sfSprite, texture: *const sfTexture, resetRect: sfBool);
2411}
2412extern "C" {
2413 pub fn sfSprite_setTextureRect(sprite: *mut sfSprite, rectangle: sfIntRect);
2414}
2415extern "C" {
2416 pub fn sfSprite_setColor(sprite: *mut sfSprite, color: sfColor);
2417}
2418extern "C" {
2419 pub fn sfSprite_getTexture(sprite: *const sfSprite) -> *const sfTexture;
2420}
2421extern "C" {
2422 pub fn sfSprite_getTextureRect(sprite: *const sfSprite) -> sfIntRect;
2423}
2424extern "C" {
2425 pub fn sfSprite_getColor(sprite: *const sfSprite) -> sfColor;
2426}
2427extern "C" {
2428 pub fn sfSprite_getLocalBounds(sprite: *const sfSprite) -> sfFloatRect;
2429}
2430extern "C" {
2431 pub fn sfSprite_getGlobalBounds(sprite: *const sfSprite) -> sfFloatRect;
2432}
2433pub const sfTextStyle_sfTextRegular: sfTextStyle = 0;
2434pub const sfTextStyle_sfTextBold: sfTextStyle = 1;
2435pub const sfTextStyle_sfTextItalic: sfTextStyle = 2;
2436pub const sfTextStyle_sfTextUnderlined: sfTextStyle = 4;
2437pub const sfTextStyle_sfTextStrikeThrough: sfTextStyle = 8;
2438pub type sfTextStyle = ::std::os::raw::c_uint;
2439extern "C" {
2440 pub fn sfText_create() -> *mut sfText;
2441}
2442extern "C" {
2443 pub fn sfText_copy(text: *const sfText) -> *mut sfText;
2444}
2445extern "C" {
2446 pub fn sfText_destroy(text: *mut sfText);
2447}
2448extern "C" {
2449 pub fn sfText_setPosition(text: *mut sfText, position: sfVector2f);
2450}
2451extern "C" {
2452 pub fn sfText_setRotation(text: *mut sfText, angle: f32);
2453}
2454extern "C" {
2455 pub fn sfText_setScale(text: *mut sfText, scale: sfVector2f);
2456}
2457extern "C" {
2458 pub fn sfText_setOrigin(text: *mut sfText, origin: sfVector2f);
2459}
2460extern "C" {
2461 pub fn sfText_getPosition(text: *const sfText) -> sfVector2f;
2462}
2463extern "C" {
2464 pub fn sfText_getRotation(text: *const sfText) -> f32;
2465}
2466extern "C" {
2467 pub fn sfText_getScale(text: *const sfText) -> sfVector2f;
2468}
2469extern "C" {
2470 pub fn sfText_getOrigin(text: *const sfText) -> sfVector2f;
2471}
2472extern "C" {
2473 pub fn sfText_move(text: *mut sfText, offset: sfVector2f);
2474}
2475extern "C" {
2476 pub fn sfText_rotate(text: *mut sfText, angle: f32);
2477}
2478extern "C" {
2479 pub fn sfText_scale(text: *mut sfText, factors: sfVector2f);
2480}
2481extern "C" {
2482 pub fn sfText_getTransform(text: *const sfText) -> sfTransform;
2483}
2484extern "C" {
2485 pub fn sfText_getInverseTransform(text: *const sfText) -> sfTransform;
2486}
2487extern "C" {
2488 pub fn sfText_setString(text: *mut sfText, string: *const ::std::os::raw::c_char);
2489}
2490extern "C" {
2491 pub fn sfText_setUnicodeString(text: *mut sfText, string: *const sfUint32);
2492}
2493extern "C" {
2494 pub fn sfText_setFont(text: *mut sfText, font: *const sfFont);
2495}
2496extern "C" {
2497 pub fn sfText_setCharacterSize(text: *mut sfText, size: ::std::os::raw::c_uint);
2498}
2499extern "C" {
2500 pub fn sfText_setLineSpacing(text: *mut sfText, spacingFactor: f32);
2501}
2502extern "C" {
2503 pub fn sfText_setLetterSpacing(text: *mut sfText, spacingFactor: f32);
2504}
2505extern "C" {
2506 pub fn sfText_setStyle(text: *mut sfText, style: sfUint32);
2507}
2508extern "C" {
2509 pub fn sfText_setColor(text: *mut sfText, color: sfColor);
2510}
2511extern "C" {
2512 pub fn sfText_setFillColor(text: *mut sfText, color: sfColor);
2513}
2514extern "C" {
2515 pub fn sfText_setOutlineColor(text: *mut sfText, color: sfColor);
2516}
2517extern "C" {
2518 pub fn sfText_setOutlineThickness(text: *mut sfText, thickness: f32);
2519}
2520extern "C" {
2521 pub fn sfText_getString(text: *const sfText) -> *const ::std::os::raw::c_char;
2522}
2523extern "C" {
2524 pub fn sfText_getUnicodeString(text: *const sfText) -> *const sfUint32;
2525}
2526extern "C" {
2527 pub fn sfText_getFont(text: *const sfText) -> *const sfFont;
2528}
2529extern "C" {
2530 pub fn sfText_getCharacterSize(text: *const sfText) -> ::std::os::raw::c_uint;
2531}
2532extern "C" {
2533 pub fn sfText_getLetterSpacing(text: *const sfText) -> f32;
2534}
2535extern "C" {
2536 pub fn getLineSpacing(text: *const sfText) -> f32;
2537}
2538extern "C" {
2539 pub fn sfText_getStyle(text: *const sfText) -> sfUint32;
2540}
2541extern "C" {
2542 pub fn sfText_getColor(text: *const sfText) -> sfColor;
2543}
2544extern "C" {
2545 pub fn sfText_getFillColor(text: *const sfText) -> sfColor;
2546}
2547extern "C" {
2548 pub fn sfText_getOutlineColor(text: *const sfText) -> sfColor;
2549}
2550extern "C" {
2551 pub fn sfText_getOutlineThickness(text: *const sfText) -> f32;
2552}
2553extern "C" {
2554 pub fn sfText_findCharacterPos(text: *const sfText, index: usize) -> sfVector2f;
2555}
2556extern "C" {
2557 pub fn sfText_getLocalBounds(text: *const sfText) -> sfFloatRect;
2558}
2559extern "C" {
2560 pub fn sfText_getGlobalBounds(text: *const sfText) -> sfFloatRect;
2561}
2562extern "C" {
2563 pub fn sfTexture_create(
2564 width: ::std::os::raw::c_uint,
2565 height: ::std::os::raw::c_uint,
2566 ) -> *mut sfTexture;
2567}
2568extern "C" {
2569 pub fn sfTexture_createFromFile(
2570 filename: *const ::std::os::raw::c_char,
2571 area: *const sfIntRect,
2572 ) -> *mut sfTexture;
2573}
2574extern "C" {
2575 pub fn sfTexture_createFromMemory(
2576 data: *const ::std::os::raw::c_void,
2577 sizeInBytes: usize,
2578 area: *const sfIntRect,
2579 ) -> *mut sfTexture;
2580}
2581extern "C" {
2582 pub fn sfTexture_createFromStream(
2583 stream: *mut sfInputStream,
2584 area: *const sfIntRect,
2585 ) -> *mut sfTexture;
2586}
2587extern "C" {
2588 pub fn sfTexture_createFromImage(
2589 image: *const sfImage,
2590 area: *const sfIntRect,
2591 ) -> *mut sfTexture;
2592}
2593extern "C" {
2594 pub fn sfTexture_copy(texture: *const sfTexture) -> *mut sfTexture;
2595}
2596extern "C" {
2597 pub fn sfTexture_destroy(texture: *mut sfTexture);
2598}
2599extern "C" {
2600 pub fn sfTexture_getSize(texture: *const sfTexture) -> sfVector2u;
2601}
2602extern "C" {
2603 pub fn sfTexture_copyToImage(texture: *const sfTexture) -> *mut sfImage;
2604}
2605extern "C" {
2606 pub fn sfTexture_updateFromPixels(
2607 texture: *mut sfTexture,
2608 pixels: *const sfUint8,
2609 width: ::std::os::raw::c_uint,
2610 height: ::std::os::raw::c_uint,
2611 x: ::std::os::raw::c_uint,
2612 y: ::std::os::raw::c_uint,
2613 );
2614}
2615extern "C" {
2616 pub fn sfTexture_updateFromTexture(
2617 destination: *mut sfTexture,
2618 source: *const sfTexture,
2619 x: ::std::os::raw::c_uint,
2620 y: ::std::os::raw::c_uint,
2621 );
2622}
2623extern "C" {
2624 pub fn sfTexture_updateFromImage(
2625 texture: *mut sfTexture,
2626 image: *const sfImage,
2627 x: ::std::os::raw::c_uint,
2628 y: ::std::os::raw::c_uint,
2629 );
2630}
2631extern "C" {
2632 pub fn sfTexture_updateFromWindow(
2633 texture: *mut sfTexture,
2634 window: *const sfWindow,
2635 x: ::std::os::raw::c_uint,
2636 y: ::std::os::raw::c_uint,
2637 );
2638}
2639extern "C" {
2640 pub fn sfTexture_updateFromRenderWindow(
2641 texture: *mut sfTexture,
2642 renderWindow: *const sfRenderWindow,
2643 x: ::std::os::raw::c_uint,
2644 y: ::std::os::raw::c_uint,
2645 );
2646}
2647extern "C" {
2648 pub fn sfTexture_setSmooth(texture: *mut sfTexture, smooth: sfBool);
2649}
2650extern "C" {
2651 pub fn sfTexture_isSmooth(texture: *const sfTexture) -> sfBool;
2652}
2653extern "C" {
2654 pub fn sfTexture_setSrgb(texture: *mut sfTexture, sRgb: sfBool);
2655}
2656extern "C" {
2657 pub fn sfTexture_isSrgb(texture: *const sfTexture) -> sfBool;
2658}
2659extern "C" {
2660 pub fn sfTexture_setRepeated(texture: *mut sfTexture, repeated: sfBool);
2661}
2662extern "C" {
2663 pub fn sfTexture_isRepeated(texture: *const sfTexture) -> sfBool;
2664}
2665extern "C" {
2666 pub fn sfTexture_generateMipmap(texture: *mut sfTexture) -> sfBool;
2667}
2668extern "C" {
2669 pub fn sfTexture_swap(left: *mut sfTexture, right: *mut sfTexture);
2670}
2671extern "C" {
2672 pub fn sfTexture_getNativeHandle(texture: *const sfTexture) -> ::std::os::raw::c_uint;
2673}
2674extern "C" {
2675 pub fn sfTexture_bind(texture: *const sfTexture);
2676}
2677extern "C" {
2678 pub fn sfTexture_getMaximumSize() -> ::std::os::raw::c_uint;
2679}
2680extern "C" {
2681 pub fn sfTransformable_create() -> *mut sfTransformable;
2682}
2683extern "C" {
2684 pub fn sfTransformable_copy(transformable: *const sfTransformable) -> *mut sfTransformable;
2685}
2686extern "C" {
2687 pub fn sfTransformable_destroy(transformable: *mut sfTransformable);
2688}
2689extern "C" {
2690 pub fn sfTransformable_setPosition(transformable: *mut sfTransformable, position: sfVector2f);
2691}
2692extern "C" {
2693 pub fn sfTransformable_setRotation(transformable: *mut sfTransformable, angle: f32);
2694}
2695extern "C" {
2696 pub fn sfTransformable_setScale(transformable: *mut sfTransformable, scale: sfVector2f);
2697}
2698extern "C" {
2699 pub fn sfTransformable_setOrigin(transformable: *mut sfTransformable, origin: sfVector2f);
2700}
2701extern "C" {
2702 pub fn sfTransformable_getPosition(transformable: *const sfTransformable) -> sfVector2f;
2703}
2704extern "C" {
2705 pub fn sfTransformable_getRotation(transformable: *const sfTransformable) -> f32;
2706}
2707extern "C" {
2708 pub fn sfTransformable_getScale(transformable: *const sfTransformable) -> sfVector2f;
2709}
2710extern "C" {
2711 pub fn sfTransformable_getOrigin(transformable: *const sfTransformable) -> sfVector2f;
2712}
2713extern "C" {
2714 pub fn sfTransformable_move(transformable: *mut sfTransformable, offset: sfVector2f);
2715}
2716extern "C" {
2717 pub fn sfTransformable_rotate(transformable: *mut sfTransformable, angle: f32);
2718}
2719extern "C" {
2720 pub fn sfTransformable_scale(transformable: *mut sfTransformable, factors: sfVector2f);
2721}
2722extern "C" {
2723 pub fn sfTransformable_getTransform(transformable: *const sfTransformable) -> sfTransform;
2724}
2725extern "C" {
2726 pub fn sfTransformable_getInverseTransform(
2727 transformable: *const sfTransformable,
2728 ) -> sfTransform;
2729}
2730extern "C" {
2731 pub fn sfVertexArray_create() -> *mut sfVertexArray;
2732}
2733extern "C" {
2734 pub fn sfVertexArray_copy(vertexArray: *const sfVertexArray) -> *mut sfVertexArray;
2735}
2736extern "C" {
2737 pub fn sfVertexArray_destroy(vertexArray: *mut sfVertexArray);
2738}
2739extern "C" {
2740 pub fn sfVertexArray_getVertexCount(vertexArray: *const sfVertexArray) -> usize;
2741}
2742extern "C" {
2743 pub fn sfVertexArray_getVertex(vertexArray: *mut sfVertexArray, index: usize) -> *mut sfVertex;
2744}
2745extern "C" {
2746 pub fn sfVertexArray_clear(vertexArray: *mut sfVertexArray);
2747}
2748extern "C" {
2749 pub fn sfVertexArray_resize(vertexArray: *mut sfVertexArray, vertexCount: usize);
2750}
2751extern "C" {
2752 pub fn sfVertexArray_append(vertexArray: *mut sfVertexArray, vertex: sfVertex);
2753}
2754extern "C" {
2755 pub fn sfVertexArray_setPrimitiveType(vertexArray: *mut sfVertexArray, type_: sfPrimitiveType);
2756}
2757extern "C" {
2758 pub fn sfVertexArray_getPrimitiveType(vertexArray: *mut sfVertexArray) -> sfPrimitiveType;
2759}
2760extern "C" {
2761 pub fn sfVertexArray_getBounds(vertexArray: *mut sfVertexArray) -> sfFloatRect;
2762}
2763pub const sfVertexBufferUsage_sfVertexBufferStream: sfVertexBufferUsage = 0;
2764pub const sfVertexBufferUsage_sfVertexBufferDynamic: sfVertexBufferUsage = 1;
2765pub const sfVertexBufferUsage_sfVertexBufferStatic: sfVertexBufferUsage = 2;
2766pub type sfVertexBufferUsage = ::std::os::raw::c_uint;
2767extern "C" {
2768 pub fn sfVertexBuffer_create(
2769 vertexCount: ::std::os::raw::c_uint,
2770 type_: sfPrimitiveType,
2771 usage: sfVertexBufferUsage,
2772 ) -> *mut sfVertexBuffer;
2773}
2774extern "C" {
2775 pub fn sfVertexBuffer_copy(vertexBuffer: *const sfVertexBuffer) -> *mut sfVertexBuffer;
2776}
2777extern "C" {
2778 pub fn sfVertexBuffer_destroy(vertexBuffer: *mut sfVertexBuffer);
2779}
2780extern "C" {
2781 pub fn sfVertexBuffer_getVertexCount(
2782 vertexBuffer: *const sfVertexBuffer,
2783 ) -> ::std::os::raw::c_uint;
2784}
2785extern "C" {
2786 pub fn sfVertexBuffer_update(
2787 vertexBuffer: *mut sfVertexBuffer,
2788 vertices: *const sfVertex,
2789 vertexCount: ::std::os::raw::c_uint,
2790 offset: ::std::os::raw::c_uint,
2791 ) -> sfBool;
2792}
2793extern "C" {
2794 pub fn sfVertexBuffer_updateFromVertexBuffer(
2795 vertexBuffer: *mut sfVertexBuffer,
2796 other: *const sfVertexBuffer,
2797 ) -> sfBool;
2798}
2799extern "C" {
2800 pub fn sfVertexBuffer_swap(left: *mut sfVertexBuffer, right: *mut sfVertexBuffer);
2801}
2802extern "C" {
2803 pub fn sfVertexBuffer_getNativeHandle(
2804 vertexBuffer: *mut sfVertexBuffer,
2805 ) -> ::std::os::raw::c_uint;
2806}
2807extern "C" {
2808 pub fn sfVertexBuffer_setPrimitiveType(
2809 vertexBuffer: *mut sfVertexBuffer,
2810 type_: sfPrimitiveType,
2811 );
2812}
2813extern "C" {
2814 pub fn sfVertexBuffer_getPrimitiveType(vertexBuffer: *const sfVertexBuffer) -> sfPrimitiveType;
2815}
2816extern "C" {
2817 pub fn sfVertexBuffer_setUsage(vertexBuffer: *mut sfVertexBuffer, usage: sfVertexBufferUsage);
2818}
2819extern "C" {
2820 pub fn sfVertexBuffer_getUsage(vertexBuffer: *const sfVertexBuffer) -> sfVertexBufferUsage;
2821}
2822extern "C" {
2823 pub fn sfVertexBuffer_bind(vertexBuffer: *const sfVertexBuffer);
2824}
2825extern "C" {
2826 pub fn sfVertexBuffer_isAvailable() -> sfBool;
2827}
2828extern "C" {
2829 pub fn sfView_create() -> *mut sfView;
2830}
2831extern "C" {
2832 pub fn sfView_createFromRect(rectangle: sfFloatRect) -> *mut sfView;
2833}
2834extern "C" {
2835 pub fn sfView_copy(view: *const sfView) -> *mut sfView;
2836}
2837extern "C" {
2838 pub fn sfView_destroy(view: *mut sfView);
2839}
2840extern "C" {
2841 pub fn sfView_setCenter(view: *mut sfView, center: sfVector2f);
2842}
2843extern "C" {
2844 pub fn sfView_setSize(view: *mut sfView, size: sfVector2f);
2845}
2846extern "C" {
2847 pub fn sfView_setRotation(view: *mut sfView, angle: f32);
2848}
2849extern "C" {
2850 pub fn sfView_setViewport(view: *mut sfView, viewport: sfFloatRect);
2851}
2852extern "C" {
2853 pub fn sfView_reset(view: *mut sfView, rectangle: sfFloatRect);
2854}
2855extern "C" {
2856 pub fn sfView_getCenter(view: *const sfView) -> sfVector2f;
2857}
2858extern "C" {
2859 pub fn sfView_getSize(view: *const sfView) -> sfVector2f;
2860}
2861extern "C" {
2862 pub fn sfView_getRotation(view: *const sfView) -> f32;
2863}
2864extern "C" {
2865 pub fn sfView_getViewport(view: *const sfView) -> sfFloatRect;
2866}
2867extern "C" {
2868 pub fn sfView_move(view: *mut sfView, offset: sfVector2f);
2869}
2870extern "C" {
2871 pub fn sfView_rotate(view: *mut sfView, angle: f32);
2872}
2873extern "C" {
2874 pub fn sfView_zoom(view: *mut sfView, factor: f32);
2875}