1pub const _STDINT_H: u32 = 1;
4pub const _FEATURES_H: u32 = 1;
5pub const _DEFAULT_SOURCE: u32 = 1;
6pub const __GLIBC_USE_ISOC2Y: u32 = 0;
7pub const __GLIBC_USE_ISOC23: u32 = 0;
8pub const __USE_ISOC11: u32 = 1;
9pub const __USE_ISOC99: u32 = 1;
10pub const __USE_ISOC95: u32 = 1;
11pub const __USE_POSIX_IMPLICITLY: u32 = 1;
12pub const _POSIX_SOURCE: u32 = 1;
13pub const _POSIX_C_SOURCE: u32 = 200809;
14pub const __USE_POSIX: u32 = 1;
15pub const __USE_POSIX2: u32 = 1;
16pub const __USE_POSIX199309: u32 = 1;
17pub const __USE_POSIX199506: u32 = 1;
18pub const __USE_XOPEN2K: u32 = 1;
19pub const __USE_XOPEN2K8: u32 = 1;
20pub const _ATFILE_SOURCE: u32 = 1;
21pub const __WORDSIZE: u32 = 64;
22pub const __WORDSIZE_TIME64_COMPAT32: u32 = 1;
23pub const __SYSCALL_WORDSIZE: u32 = 64;
24pub const __TIMESIZE: u32 = 64;
25pub const __USE_TIME_BITS64: u32 = 1;
26pub const __USE_MISC: u32 = 1;
27pub const __USE_ATFILE: u32 = 1;
28pub const __USE_FORTIFY_LEVEL: u32 = 0;
29pub const __GLIBC_USE_DEPRECATED_GETS: u32 = 0;
30pub const __GLIBC_USE_DEPRECATED_SCANF: u32 = 0;
31pub const __GLIBC_USE_C23_STRTOL: u32 = 0;
32pub const _STDC_PREDEF_H: u32 = 1;
33pub const __STDC_IEC_559__: u32 = 1;
34pub const __STDC_IEC_60559_BFP__: u32 = 201404;
35pub const __STDC_IEC_559_COMPLEX__: u32 = 1;
36pub const __STDC_IEC_60559_COMPLEX__: u32 = 201404;
37pub const __STDC_ISO_10646__: u32 = 201706;
38pub const __GNU_LIBRARY__: u32 = 6;
39pub const __GLIBC__: u32 = 2;
40pub const __GLIBC_MINOR__: u32 = 42;
41pub const _SYS_CDEFS_H: u32 = 1;
42pub const __glibc_c99_flexarr_available: u32 = 1;
43pub const __LDOUBLE_REDIRECTS_TO_FLOAT128_ABI: u32 = 0;
44pub const __HAVE_GENERIC_SELECTION: u32 = 1;
45pub const __GLIBC_USE_LIB_EXT2: u32 = 0;
46pub const __GLIBC_USE_IEC_60559_BFP_EXT: u32 = 0;
47pub const __GLIBC_USE_IEC_60559_BFP_EXT_C23: u32 = 0;
48pub const __GLIBC_USE_IEC_60559_EXT: u32 = 0;
49pub const __GLIBC_USE_IEC_60559_FUNCS_EXT: u32 = 0;
50pub const __GLIBC_USE_IEC_60559_FUNCS_EXT_C23: u32 = 0;
51pub const __GLIBC_USE_IEC_60559_TYPES_EXT: u32 = 0;
52pub const _BITS_TYPES_H: u32 = 1;
53pub const _BITS_TYPESIZES_H: u32 = 1;
54pub const __OFF_T_MATCHES_OFF64_T: u32 = 1;
55pub const __INO_T_MATCHES_INO64_T: u32 = 1;
56pub const __RLIM_T_MATCHES_RLIM64_T: u32 = 1;
57pub const __STATFS_MATCHES_STATFS64: u32 = 1;
58pub const __KERNEL_OLD_TIMEVAL_MATCHES_TIMEVAL64: u32 = 1;
59pub const __FD_SETSIZE: u32 = 1024;
60pub const _BITS_TIME64_H: u32 = 1;
61pub const _BITS_WCHAR_H: u32 = 1;
62pub const _BITS_STDINT_INTN_H: u32 = 1;
63pub const _BITS_STDINT_UINTN_H: u32 = 1;
64pub const _BITS_STDINT_LEAST_H: u32 = 1;
65pub const INT8_MIN: i32 = -128;
66pub const INT16_MIN: i32 = -32768;
67pub const INT32_MIN: i32 = -2147483648;
68pub const INT8_MAX: u32 = 127;
69pub const INT16_MAX: u32 = 32767;
70pub const INT32_MAX: u32 = 2147483647;
71pub const UINT8_MAX: u32 = 255;
72pub const UINT16_MAX: u32 = 65535;
73pub const UINT32_MAX: u32 = 4294967295;
74pub const INT_LEAST8_MIN: i32 = -128;
75pub const INT_LEAST16_MIN: i32 = -32768;
76pub const INT_LEAST32_MIN: i32 = -2147483648;
77pub const INT_LEAST8_MAX: u32 = 127;
78pub const INT_LEAST16_MAX: u32 = 32767;
79pub const INT_LEAST32_MAX: u32 = 2147483647;
80pub const UINT_LEAST8_MAX: u32 = 255;
81pub const UINT_LEAST16_MAX: u32 = 65535;
82pub const UINT_LEAST32_MAX: u32 = 4294967295;
83pub const INT_FAST8_MIN: i32 = -128;
84pub const INT_FAST16_MIN: i64 = -9223372036854775808;
85pub const INT_FAST32_MIN: i64 = -9223372036854775808;
86pub const INT_FAST8_MAX: u32 = 127;
87pub const INT_FAST16_MAX: u64 = 9223372036854775807;
88pub const INT_FAST32_MAX: u64 = 9223372036854775807;
89pub const UINT_FAST8_MAX: u32 = 255;
90pub const UINT_FAST16_MAX: i32 = -1;
91pub const UINT_FAST32_MAX: i32 = -1;
92pub const INTPTR_MIN: i64 = -9223372036854775808;
93pub const INTPTR_MAX: u64 = 9223372036854775807;
94pub const UINTPTR_MAX: i32 = -1;
95pub const PTRDIFF_MIN: i64 = -9223372036854775808;
96pub const PTRDIFF_MAX: u64 = 9223372036854775807;
97pub const SIG_ATOMIC_MIN: i32 = -2147483648;
98pub const SIG_ATOMIC_MAX: u32 = 2147483647;
99pub const SIZE_MAX: i32 = -1;
100pub const WINT_MIN: u32 = 0;
101pub const WINT_MAX: u32 = 4294967295;
102pub const ChangeFlagNone: u32 = 0;
103pub const ChangeFlagPath: u32 = 1;
104pub const ChangeFlagPaint: u32 = 16;
105pub const ChangeFlagAll: u32 = 0;
106pub type wchar_t = ::core::ffi::c_int;
107#[repr(C)]
108#[repr(align(16))]
109#[derive(Debug, Copy, Clone)]
110pub struct max_align_t {
111 pub __clang_max_align_nonce1: ::core::ffi::c_longlong,
112 pub __bindgen_padding_0: u64,
113 pub __clang_max_align_nonce2: u128,
114}
115#[test]
116fn bindgen_test_layout_max_align_t() {
117 const UNINIT: ::core::mem::MaybeUninit<max_align_t> = ::core::mem::MaybeUninit::uninit();
118 let ptr = UNINIT.as_ptr();
119 assert_eq!(::core::mem::size_of::<max_align_t>(), 32usize, "Size of max_align_t");
120 assert_eq!(
121 ::core::mem::align_of::<max_align_t>(),
122 16usize,
123 "Alignment of max_align_t",
124 );
125 assert_eq!(
126 unsafe {
127 ::core::ptr::addr_of!((*ptr).__clang_max_align_nonce1) as usize
128 - ptr as usize
129 },
130 0usize,
131 "Offset of field: max_align_t::__clang_max_align_nonce1",
132 );
133 assert_eq!(
134 unsafe {
135 ::core::ptr::addr_of!((*ptr).__clang_max_align_nonce2) as usize
136 - ptr as usize
137 },
138 16usize,
139 "Offset of field: max_align_t::__clang_max_align_nonce2",
140 );
141}
142pub type __u_char = ::core::ffi::c_uchar;
143pub type __u_short = ::core::ffi::c_ushort;
144pub type __u_int = ::core::ffi::c_uint;
145pub type __u_long = ::core::ffi::c_ulong;
146pub type __int8_t = ::core::ffi::c_schar;
147pub type __uint8_t = ::core::ffi::c_uchar;
148pub type __int16_t = ::core::ffi::c_short;
149pub type __uint16_t = ::core::ffi::c_ushort;
150pub type __int32_t = ::core::ffi::c_int;
151pub type __uint32_t = ::core::ffi::c_uint;
152pub type __int64_t = ::core::ffi::c_long;
153pub type __uint64_t = ::core::ffi::c_ulong;
154pub type __int_least8_t = __int8_t;
155pub type __uint_least8_t = __uint8_t;
156pub type __int_least16_t = __int16_t;
157pub type __uint_least16_t = __uint16_t;
158pub type __int_least32_t = __int32_t;
159pub type __uint_least32_t = __uint32_t;
160pub type __int_least64_t = __int64_t;
161pub type __uint_least64_t = __uint64_t;
162pub type __quad_t = ::core::ffi::c_long;
163pub type __u_quad_t = ::core::ffi::c_ulong;
164pub type __intmax_t = ::core::ffi::c_long;
165pub type __uintmax_t = ::core::ffi::c_ulong;
166pub type __dev_t = ::core::ffi::c_ulong;
167pub type __uid_t = ::core::ffi::c_uint;
168pub type __gid_t = ::core::ffi::c_uint;
169pub type __ino_t = ::core::ffi::c_ulong;
170pub type __ino64_t = ::core::ffi::c_ulong;
171pub type __mode_t = ::core::ffi::c_uint;
172pub type __nlink_t = ::core::ffi::c_ulong;
173pub type __off_t = ::core::ffi::c_long;
174pub type __off64_t = ::core::ffi::c_long;
175pub type __pid_t = ::core::ffi::c_int;
176#[repr(C)]
177#[derive(Debug, Copy, Clone)]
178pub struct __fsid_t {
179 pub __val: [::core::ffi::c_int; 2usize],
180}
181#[test]
182fn bindgen_test_layout___fsid_t() {
183 const UNINIT: ::core::mem::MaybeUninit<__fsid_t> = ::core::mem::MaybeUninit::uninit();
184 let ptr = UNINIT.as_ptr();
185 assert_eq!(::core::mem::size_of::<__fsid_t>(), 8usize, "Size of __fsid_t");
186 assert_eq!(::core::mem::align_of::<__fsid_t>(), 4usize, "Alignment of __fsid_t");
187 assert_eq!(
188 unsafe { ::core::ptr::addr_of!((*ptr).__val) as usize - ptr as usize },
189 0usize,
190 "Offset of field: __fsid_t::__val",
191 );
192}
193pub type __clock_t = ::core::ffi::c_long;
194pub type __rlim_t = ::core::ffi::c_ulong;
195pub type __rlim64_t = ::core::ffi::c_ulong;
196pub type __id_t = ::core::ffi::c_uint;
197pub type __time_t = ::core::ffi::c_long;
198pub type __useconds_t = ::core::ffi::c_uint;
199pub type __suseconds_t = ::core::ffi::c_long;
200pub type __suseconds64_t = ::core::ffi::c_long;
201pub type __daddr_t = ::core::ffi::c_int;
202pub type __key_t = ::core::ffi::c_int;
203pub type __clockid_t = ::core::ffi::c_int;
204pub type __timer_t = *mut ::core::ffi::c_void;
205pub type __blksize_t = ::core::ffi::c_long;
206pub type __blkcnt_t = ::core::ffi::c_long;
207pub type __blkcnt64_t = ::core::ffi::c_long;
208pub type __fsblkcnt_t = ::core::ffi::c_ulong;
209pub type __fsblkcnt64_t = ::core::ffi::c_ulong;
210pub type __fsfilcnt_t = ::core::ffi::c_ulong;
211pub type __fsfilcnt64_t = ::core::ffi::c_ulong;
212pub type __fsword_t = ::core::ffi::c_long;
213pub type __ssize_t = ::core::ffi::c_long;
214pub type __syscall_slong_t = ::core::ffi::c_long;
215pub type __syscall_ulong_t = ::core::ffi::c_ulong;
216pub type __loff_t = __off64_t;
217pub type __caddr_t = *mut ::core::ffi::c_char;
218pub type __intptr_t = ::core::ffi::c_long;
219pub type __socklen_t = ::core::ffi::c_uint;
220pub type __sig_atomic_t = ::core::ffi::c_int;
221pub type int_least8_t = __int_least8_t;
222pub type int_least16_t = __int_least16_t;
223pub type int_least32_t = __int_least32_t;
224pub type int_least64_t = __int_least64_t;
225pub type uint_least8_t = __uint_least8_t;
226pub type uint_least16_t = __uint_least16_t;
227pub type uint_least32_t = __uint_least32_t;
228pub type uint_least64_t = __uint_least64_t;
229pub type int_fast8_t = ::core::ffi::c_schar;
230pub type int_fast16_t = ::core::ffi::c_long;
231pub type int_fast32_t = ::core::ffi::c_long;
232pub type int_fast64_t = ::core::ffi::c_long;
233pub type uint_fast8_t = ::core::ffi::c_uchar;
234pub type uint_fast16_t = ::core::ffi::c_ulong;
235pub type uint_fast32_t = ::core::ffi::c_ulong;
236pub type uint_fast64_t = ::core::ffi::c_ulong;
237pub type intmax_t = __intmax_t;
238pub type uintmax_t = __uintmax_t;
239impl LOTBrushType {
240 pub const BrushSolid: LOTBrushType = LOTBrushType(0);
241}
242impl LOTBrushType {
243 pub const BrushGradient: LOTBrushType = LOTBrushType(1);
244}
245#[repr(transparent)]
246#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
247pub struct LOTBrushType(pub ::core::ffi::c_uint);
248impl LOTFillRule {
249 pub const FillEvenOdd: LOTFillRule = LOTFillRule(0);
250}
251impl LOTFillRule {
252 pub const FillWinding: LOTFillRule = LOTFillRule(1);
253}
254#[repr(transparent)]
255#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
256pub struct LOTFillRule(pub ::core::ffi::c_uint);
257impl LOTJoinStyle {
258 pub const JoinMiter: LOTJoinStyle = LOTJoinStyle(0);
259}
260impl LOTJoinStyle {
261 pub const JoinBevel: LOTJoinStyle = LOTJoinStyle(1);
262}
263impl LOTJoinStyle {
264 pub const JoinRound: LOTJoinStyle = LOTJoinStyle(2);
265}
266#[repr(transparent)]
267#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
268pub struct LOTJoinStyle(pub ::core::ffi::c_uint);
269impl LOTCapStyle {
270 pub const CapFlat: LOTCapStyle = LOTCapStyle(0);
271}
272impl LOTCapStyle {
273 pub const CapSquare: LOTCapStyle = LOTCapStyle(1);
274}
275impl LOTCapStyle {
276 pub const CapRound: LOTCapStyle = LOTCapStyle(2);
277}
278#[repr(transparent)]
279#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
280pub struct LOTCapStyle(pub ::core::ffi::c_uint);
281impl LOTGradientType {
282 pub const GradientLinear: LOTGradientType = LOTGradientType(0);
283}
284impl LOTGradientType {
285 pub const GradientRadial: LOTGradientType = LOTGradientType(1);
286}
287#[repr(transparent)]
288#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
289pub struct LOTGradientType(pub ::core::ffi::c_uint);
290#[repr(C)]
291#[derive(Debug, Copy, Clone)]
292pub struct LOTGradientStop {
293 pub pos: f32,
294 pub r: ::core::ffi::c_uchar,
295 pub g: ::core::ffi::c_uchar,
296 pub b: ::core::ffi::c_uchar,
297 pub a: ::core::ffi::c_uchar,
298}
299#[test]
300fn bindgen_test_layout_LOTGradientStop() {
301 const UNINIT: ::core::mem::MaybeUninit<LOTGradientStop> = ::core::mem::MaybeUninit::uninit();
302 let ptr = UNINIT.as_ptr();
303 assert_eq!(
304 ::core::mem::size_of::<LOTGradientStop>(),
305 8usize,
306 "Size of LOTGradientStop",
307 );
308 assert_eq!(
309 ::core::mem::align_of::<LOTGradientStop>(),
310 4usize,
311 "Alignment of LOTGradientStop",
312 );
313 assert_eq!(
314 unsafe { ::core::ptr::addr_of!((*ptr).pos) as usize - ptr as usize },
315 0usize,
316 "Offset of field: LOTGradientStop::pos",
317 );
318 assert_eq!(
319 unsafe { ::core::ptr::addr_of!((*ptr).r) as usize - ptr as usize },
320 4usize,
321 "Offset of field: LOTGradientStop::r",
322 );
323 assert_eq!(
324 unsafe { ::core::ptr::addr_of!((*ptr).g) as usize - ptr as usize },
325 5usize,
326 "Offset of field: LOTGradientStop::g",
327 );
328 assert_eq!(
329 unsafe { ::core::ptr::addr_of!((*ptr).b) as usize - ptr as usize },
330 6usize,
331 "Offset of field: LOTGradientStop::b",
332 );
333 assert_eq!(
334 unsafe { ::core::ptr::addr_of!((*ptr).a) as usize - ptr as usize },
335 7usize,
336 "Offset of field: LOTGradientStop::a",
337 );
338}
339impl LOTMaskType {
340 pub const MaskAdd: LOTMaskType = LOTMaskType(0);
341}
342impl LOTMaskType {
343 pub const MaskSubstract: LOTMaskType = LOTMaskType(1);
344}
345impl LOTMaskType {
346 pub const MaskIntersect: LOTMaskType = LOTMaskType(2);
347}
348impl LOTMaskType {
349 pub const MaskDifference: LOTMaskType = LOTMaskType(3);
350}
351#[repr(transparent)]
352#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
353pub struct LOTMaskType(pub ::core::ffi::c_uint);
354#[repr(C)]
355#[derive(Debug, Copy, Clone)]
356pub struct LOTMask {
357 pub mPath: LOTMask__bindgen_ty_1,
358 pub mMode: LOTMaskType,
359 pub mAlpha: ::core::ffi::c_uchar,
360}
361#[repr(C)]
362#[derive(Debug, Copy, Clone)]
363pub struct LOTMask__bindgen_ty_1 {
364 pub ptPtr: *const f32,
365 pub ptCount: usize,
366 pub elmPtr: *const ::core::ffi::c_char,
367 pub elmCount: usize,
368}
369#[test]
370fn bindgen_test_layout_LOTMask__bindgen_ty_1() {
371 const UNINIT: ::core::mem::MaybeUninit<LOTMask__bindgen_ty_1> = ::core::mem::MaybeUninit::uninit();
372 let ptr = UNINIT.as_ptr();
373 assert_eq!(
374 ::core::mem::size_of::<LOTMask__bindgen_ty_1>(),
375 32usize,
376 "Size of LOTMask__bindgen_ty_1",
377 );
378 assert_eq!(
379 ::core::mem::align_of::<LOTMask__bindgen_ty_1>(),
380 8usize,
381 "Alignment of LOTMask__bindgen_ty_1",
382 );
383 assert_eq!(
384 unsafe { ::core::ptr::addr_of!((*ptr).ptPtr) as usize - ptr as usize },
385 0usize,
386 "Offset of field: LOTMask__bindgen_ty_1::ptPtr",
387 );
388 assert_eq!(
389 unsafe { ::core::ptr::addr_of!((*ptr).ptCount) as usize - ptr as usize },
390 8usize,
391 "Offset of field: LOTMask__bindgen_ty_1::ptCount",
392 );
393 assert_eq!(
394 unsafe { ::core::ptr::addr_of!((*ptr).elmPtr) as usize - ptr as usize },
395 16usize,
396 "Offset of field: LOTMask__bindgen_ty_1::elmPtr",
397 );
398 assert_eq!(
399 unsafe { ::core::ptr::addr_of!((*ptr).elmCount) as usize - ptr as usize },
400 24usize,
401 "Offset of field: LOTMask__bindgen_ty_1::elmCount",
402 );
403}
404#[test]
405fn bindgen_test_layout_LOTMask() {
406 const UNINIT: ::core::mem::MaybeUninit<LOTMask> = ::core::mem::MaybeUninit::uninit();
407 let ptr = UNINIT.as_ptr();
408 assert_eq!(::core::mem::size_of::<LOTMask>(), 40usize, "Size of LOTMask");
409 assert_eq!(::core::mem::align_of::<LOTMask>(), 8usize, "Alignment of LOTMask");
410 assert_eq!(
411 unsafe { ::core::ptr::addr_of!((*ptr).mPath) as usize - ptr as usize },
412 0usize,
413 "Offset of field: LOTMask::mPath",
414 );
415 assert_eq!(
416 unsafe { ::core::ptr::addr_of!((*ptr).mMode) as usize - ptr as usize },
417 32usize,
418 "Offset of field: LOTMask::mMode",
419 );
420 assert_eq!(
421 unsafe { ::core::ptr::addr_of!((*ptr).mAlpha) as usize - ptr as usize },
422 36usize,
423 "Offset of field: LOTMask::mAlpha",
424 );
425}
426impl LOTMatteType {
427 pub const MatteNone: LOTMatteType = LOTMatteType(0);
428}
429impl LOTMatteType {
430 pub const MatteAlpha: LOTMatteType = LOTMatteType(1);
431}
432impl LOTMatteType {
433 pub const MatteAlphaInv: LOTMatteType = LOTMatteType(2);
434}
435impl LOTMatteType {
436 pub const MatteLuma: LOTMatteType = LOTMatteType(3);
437}
438impl LOTMatteType {
439 pub const MatteLumaInv: LOTMatteType = LOTMatteType(4);
440}
441#[repr(transparent)]
442#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
443pub struct LOTMatteType(pub ::core::ffi::c_uint);
444#[repr(C)]
445#[derive(Debug, Copy, Clone)]
446pub struct LOTMarker {
447 pub name: *mut ::core::ffi::c_char,
448 pub startframe: usize,
449 pub endframe: usize,
450}
451#[test]
452fn bindgen_test_layout_LOTMarker() {
453 const UNINIT: ::core::mem::MaybeUninit<LOTMarker> = ::core::mem::MaybeUninit::uninit();
454 let ptr = UNINIT.as_ptr();
455 assert_eq!(::core::mem::size_of::<LOTMarker>(), 24usize, "Size of LOTMarker");
456 assert_eq!(::core::mem::align_of::<LOTMarker>(), 8usize, "Alignment of LOTMarker");
457 assert_eq!(
458 unsafe { ::core::ptr::addr_of!((*ptr).name) as usize - ptr as usize },
459 0usize,
460 "Offset of field: LOTMarker::name",
461 );
462 assert_eq!(
463 unsafe { ::core::ptr::addr_of!((*ptr).startframe) as usize - ptr as usize },
464 8usize,
465 "Offset of field: LOTMarker::startframe",
466 );
467 assert_eq!(
468 unsafe { ::core::ptr::addr_of!((*ptr).endframe) as usize - ptr as usize },
469 16usize,
470 "Offset of field: LOTMarker::endframe",
471 );
472}
473#[repr(C)]
474#[derive(Debug, Copy, Clone)]
475pub struct LOTMarkerList {
476 pub ptr: *mut LOTMarker,
477 pub size: usize,
478}
479#[test]
480fn bindgen_test_layout_LOTMarkerList() {
481 const UNINIT: ::core::mem::MaybeUninit<LOTMarkerList> = ::core::mem::MaybeUninit::uninit();
482 let ptr = UNINIT.as_ptr();
483 assert_eq!(
484 ::core::mem::size_of::<LOTMarkerList>(),
485 16usize,
486 "Size of LOTMarkerList",
487 );
488 assert_eq!(
489 ::core::mem::align_of::<LOTMarkerList>(),
490 8usize,
491 "Alignment of LOTMarkerList",
492 );
493 assert_eq!(
494 unsafe { ::core::ptr::addr_of!((*ptr).ptr) as usize - ptr as usize },
495 0usize,
496 "Offset of field: LOTMarkerList::ptr",
497 );
498 assert_eq!(
499 unsafe { ::core::ptr::addr_of!((*ptr).size) as usize - ptr as usize },
500 8usize,
501 "Offset of field: LOTMarkerList::size",
502 );
503}
504#[repr(C)]
505#[derive(Debug, Copy, Clone)]
506pub struct LOTNode {
507 pub mPath: LOTNode__bindgen_ty_1,
508 pub mColor: LOTNode__bindgen_ty_2,
509 pub mStroke: LOTNode__bindgen_ty_3,
510 pub mGradient: LOTNode__bindgen_ty_4,
511 pub mImageInfo: LOTNode__bindgen_ty_5,
512 pub mFlag: ::core::ffi::c_int,
513 pub mBrushType: LOTBrushType,
514 pub mFillRule: LOTFillRule,
515 pub keypath: *const ::core::ffi::c_char,
516}
517#[repr(C)]
518#[derive(Debug, Copy, Clone)]
519pub struct LOTNode__bindgen_ty_1 {
520 pub ptPtr: *const f32,
521 pub ptCount: usize,
522 pub elmPtr: *const ::core::ffi::c_char,
523 pub elmCount: usize,
524}
525#[test]
526fn bindgen_test_layout_LOTNode__bindgen_ty_1() {
527 const UNINIT: ::core::mem::MaybeUninit<LOTNode__bindgen_ty_1> = ::core::mem::MaybeUninit::uninit();
528 let ptr = UNINIT.as_ptr();
529 assert_eq!(
530 ::core::mem::size_of::<LOTNode__bindgen_ty_1>(),
531 32usize,
532 "Size of LOTNode__bindgen_ty_1",
533 );
534 assert_eq!(
535 ::core::mem::align_of::<LOTNode__bindgen_ty_1>(),
536 8usize,
537 "Alignment of LOTNode__bindgen_ty_1",
538 );
539 assert_eq!(
540 unsafe { ::core::ptr::addr_of!((*ptr).ptPtr) as usize - ptr as usize },
541 0usize,
542 "Offset of field: LOTNode__bindgen_ty_1::ptPtr",
543 );
544 assert_eq!(
545 unsafe { ::core::ptr::addr_of!((*ptr).ptCount) as usize - ptr as usize },
546 8usize,
547 "Offset of field: LOTNode__bindgen_ty_1::ptCount",
548 );
549 assert_eq!(
550 unsafe { ::core::ptr::addr_of!((*ptr).elmPtr) as usize - ptr as usize },
551 16usize,
552 "Offset of field: LOTNode__bindgen_ty_1::elmPtr",
553 );
554 assert_eq!(
555 unsafe { ::core::ptr::addr_of!((*ptr).elmCount) as usize - ptr as usize },
556 24usize,
557 "Offset of field: LOTNode__bindgen_ty_1::elmCount",
558 );
559}
560#[repr(C)]
561#[derive(Debug, Copy, Clone)]
562pub struct LOTNode__bindgen_ty_2 {
563 pub r: ::core::ffi::c_uchar,
564 pub g: ::core::ffi::c_uchar,
565 pub b: ::core::ffi::c_uchar,
566 pub a: ::core::ffi::c_uchar,
567}
568#[test]
569fn bindgen_test_layout_LOTNode__bindgen_ty_2() {
570 const UNINIT: ::core::mem::MaybeUninit<LOTNode__bindgen_ty_2> = ::core::mem::MaybeUninit::uninit();
571 let ptr = UNINIT.as_ptr();
572 assert_eq!(
573 ::core::mem::size_of::<LOTNode__bindgen_ty_2>(),
574 4usize,
575 "Size of LOTNode__bindgen_ty_2",
576 );
577 assert_eq!(
578 ::core::mem::align_of::<LOTNode__bindgen_ty_2>(),
579 1usize,
580 "Alignment of LOTNode__bindgen_ty_2",
581 );
582 assert_eq!(
583 unsafe { ::core::ptr::addr_of!((*ptr).r) as usize - ptr as usize },
584 0usize,
585 "Offset of field: LOTNode__bindgen_ty_2::r",
586 );
587 assert_eq!(
588 unsafe { ::core::ptr::addr_of!((*ptr).g) as usize - ptr as usize },
589 1usize,
590 "Offset of field: LOTNode__bindgen_ty_2::g",
591 );
592 assert_eq!(
593 unsafe { ::core::ptr::addr_of!((*ptr).b) as usize - ptr as usize },
594 2usize,
595 "Offset of field: LOTNode__bindgen_ty_2::b",
596 );
597 assert_eq!(
598 unsafe { ::core::ptr::addr_of!((*ptr).a) as usize - ptr as usize },
599 3usize,
600 "Offset of field: LOTNode__bindgen_ty_2::a",
601 );
602}
603#[repr(C)]
604#[derive(Debug, Copy, Clone)]
605pub struct LOTNode__bindgen_ty_3 {
606 pub enable: ::core::ffi::c_uchar,
607 pub width: f32,
608 pub cap: LOTCapStyle,
609 pub join: LOTJoinStyle,
610 pub miterLimit: f32,
611 pub dashArray: *mut f32,
612 pub dashArraySize: ::core::ffi::c_int,
613}
614#[test]
615fn bindgen_test_layout_LOTNode__bindgen_ty_3() {
616 const UNINIT: ::core::mem::MaybeUninit<LOTNode__bindgen_ty_3> = ::core::mem::MaybeUninit::uninit();
617 let ptr = UNINIT.as_ptr();
618 assert_eq!(
619 ::core::mem::size_of::<LOTNode__bindgen_ty_3>(),
620 40usize,
621 "Size of LOTNode__bindgen_ty_3",
622 );
623 assert_eq!(
624 ::core::mem::align_of::<LOTNode__bindgen_ty_3>(),
625 8usize,
626 "Alignment of LOTNode__bindgen_ty_3",
627 );
628 assert_eq!(
629 unsafe { ::core::ptr::addr_of!((*ptr).enable) as usize - ptr as usize },
630 0usize,
631 "Offset of field: LOTNode__bindgen_ty_3::enable",
632 );
633 assert_eq!(
634 unsafe { ::core::ptr::addr_of!((*ptr).width) as usize - ptr as usize },
635 4usize,
636 "Offset of field: LOTNode__bindgen_ty_3::width",
637 );
638 assert_eq!(
639 unsafe { ::core::ptr::addr_of!((*ptr).cap) as usize - ptr as usize },
640 8usize,
641 "Offset of field: LOTNode__bindgen_ty_3::cap",
642 );
643 assert_eq!(
644 unsafe { ::core::ptr::addr_of!((*ptr).join) as usize - ptr as usize },
645 12usize,
646 "Offset of field: LOTNode__bindgen_ty_3::join",
647 );
648 assert_eq!(
649 unsafe { ::core::ptr::addr_of!((*ptr).miterLimit) as usize - ptr as usize },
650 16usize,
651 "Offset of field: LOTNode__bindgen_ty_3::miterLimit",
652 );
653 assert_eq!(
654 unsafe { ::core::ptr::addr_of!((*ptr).dashArray) as usize - ptr as usize },
655 24usize,
656 "Offset of field: LOTNode__bindgen_ty_3::dashArray",
657 );
658 assert_eq!(
659 unsafe { ::core::ptr::addr_of!((*ptr).dashArraySize) as usize - ptr as usize },
660 32usize,
661 "Offset of field: LOTNode__bindgen_ty_3::dashArraySize",
662 );
663}
664#[repr(C)]
665#[derive(Debug, Copy, Clone)]
666pub struct LOTNode__bindgen_ty_4 {
667 pub type_: LOTGradientType,
668 pub stopPtr: *mut LOTGradientStop,
669 pub stopCount: usize,
670 pub start: LOTNode__bindgen_ty_4__bindgen_ty_1,
671 pub end: LOTNode__bindgen_ty_4__bindgen_ty_1,
672 pub center: LOTNode__bindgen_ty_4__bindgen_ty_1,
673 pub focal: LOTNode__bindgen_ty_4__bindgen_ty_1,
674 pub cradius: f32,
675 pub fradius: f32,
676}
677#[repr(C)]
678#[derive(Debug, Copy, Clone)]
679pub struct LOTNode__bindgen_ty_4__bindgen_ty_1 {
680 pub x: f32,
681 pub y: f32,
682}
683#[test]
684fn bindgen_test_layout_LOTNode__bindgen_ty_4__bindgen_ty_1() {
685 const UNINIT: ::core::mem::MaybeUninit<LOTNode__bindgen_ty_4__bindgen_ty_1> = ::core::mem::MaybeUninit::uninit();
686 let ptr = UNINIT.as_ptr();
687 assert_eq!(
688 ::core::mem::size_of::<LOTNode__bindgen_ty_4__bindgen_ty_1>(),
689 8usize,
690 "Size of LOTNode__bindgen_ty_4__bindgen_ty_1",
691 );
692 assert_eq!(
693 ::core::mem::align_of::<LOTNode__bindgen_ty_4__bindgen_ty_1>(),
694 4usize,
695 "Alignment of LOTNode__bindgen_ty_4__bindgen_ty_1",
696 );
697 assert_eq!(
698 unsafe { ::core::ptr::addr_of!((*ptr).x) as usize - ptr as usize },
699 0usize,
700 "Offset of field: LOTNode__bindgen_ty_4__bindgen_ty_1::x",
701 );
702 assert_eq!(
703 unsafe { ::core::ptr::addr_of!((*ptr).y) as usize - ptr as usize },
704 4usize,
705 "Offset of field: LOTNode__bindgen_ty_4__bindgen_ty_1::y",
706 );
707}
708#[test]
709fn bindgen_test_layout_LOTNode__bindgen_ty_4() {
710 const UNINIT: ::core::mem::MaybeUninit<LOTNode__bindgen_ty_4> = ::core::mem::MaybeUninit::uninit();
711 let ptr = UNINIT.as_ptr();
712 assert_eq!(
713 ::core::mem::size_of::<LOTNode__bindgen_ty_4>(),
714 64usize,
715 "Size of LOTNode__bindgen_ty_4",
716 );
717 assert_eq!(
718 ::core::mem::align_of::<LOTNode__bindgen_ty_4>(),
719 8usize,
720 "Alignment of LOTNode__bindgen_ty_4",
721 );
722 assert_eq!(
723 unsafe { ::core::ptr::addr_of!((*ptr).type_) as usize - ptr as usize },
724 0usize,
725 "Offset of field: LOTNode__bindgen_ty_4::type_",
726 );
727 assert_eq!(
728 unsafe { ::core::ptr::addr_of!((*ptr).stopPtr) as usize - ptr as usize },
729 8usize,
730 "Offset of field: LOTNode__bindgen_ty_4::stopPtr",
731 );
732 assert_eq!(
733 unsafe { ::core::ptr::addr_of!((*ptr).stopCount) as usize - ptr as usize },
734 16usize,
735 "Offset of field: LOTNode__bindgen_ty_4::stopCount",
736 );
737 assert_eq!(
738 unsafe { ::core::ptr::addr_of!((*ptr).start) as usize - ptr as usize },
739 24usize,
740 "Offset of field: LOTNode__bindgen_ty_4::start",
741 );
742 assert_eq!(
743 unsafe { ::core::ptr::addr_of!((*ptr).end) as usize - ptr as usize },
744 32usize,
745 "Offset of field: LOTNode__bindgen_ty_4::end",
746 );
747 assert_eq!(
748 unsafe { ::core::ptr::addr_of!((*ptr).center) as usize - ptr as usize },
749 40usize,
750 "Offset of field: LOTNode__bindgen_ty_4::center",
751 );
752 assert_eq!(
753 unsafe { ::core::ptr::addr_of!((*ptr).focal) as usize - ptr as usize },
754 48usize,
755 "Offset of field: LOTNode__bindgen_ty_4::focal",
756 );
757 assert_eq!(
758 unsafe { ::core::ptr::addr_of!((*ptr).cradius) as usize - ptr as usize },
759 56usize,
760 "Offset of field: LOTNode__bindgen_ty_4::cradius",
761 );
762 assert_eq!(
763 unsafe { ::core::ptr::addr_of!((*ptr).fradius) as usize - ptr as usize },
764 60usize,
765 "Offset of field: LOTNode__bindgen_ty_4::fradius",
766 );
767}
768#[repr(C)]
769#[derive(Debug, Copy, Clone)]
770pub struct LOTNode__bindgen_ty_5 {
771 pub data: *mut ::core::ffi::c_uchar,
772 pub width: usize,
773 pub height: usize,
774 pub mAlpha: ::core::ffi::c_uchar,
775 pub mMatrix: LOTNode__bindgen_ty_5__bindgen_ty_1,
776}
777#[repr(C)]
778#[derive(Debug, Copy, Clone)]
779pub struct LOTNode__bindgen_ty_5__bindgen_ty_1 {
780 pub m11: f32,
781 pub m12: f32,
782 pub m13: f32,
783 pub m21: f32,
784 pub m22: f32,
785 pub m23: f32,
786 pub m31: f32,
787 pub m32: f32,
788 pub m33: f32,
789}
790#[test]
791fn bindgen_test_layout_LOTNode__bindgen_ty_5__bindgen_ty_1() {
792 const UNINIT: ::core::mem::MaybeUninit<LOTNode__bindgen_ty_5__bindgen_ty_1> = ::core::mem::MaybeUninit::uninit();
793 let ptr = UNINIT.as_ptr();
794 assert_eq!(
795 ::core::mem::size_of::<LOTNode__bindgen_ty_5__bindgen_ty_1>(),
796 36usize,
797 "Size of LOTNode__bindgen_ty_5__bindgen_ty_1",
798 );
799 assert_eq!(
800 ::core::mem::align_of::<LOTNode__bindgen_ty_5__bindgen_ty_1>(),
801 4usize,
802 "Alignment of LOTNode__bindgen_ty_5__bindgen_ty_1",
803 );
804 assert_eq!(
805 unsafe { ::core::ptr::addr_of!((*ptr).m11) as usize - ptr as usize },
806 0usize,
807 "Offset of field: LOTNode__bindgen_ty_5__bindgen_ty_1::m11",
808 );
809 assert_eq!(
810 unsafe { ::core::ptr::addr_of!((*ptr).m12) as usize - ptr as usize },
811 4usize,
812 "Offset of field: LOTNode__bindgen_ty_5__bindgen_ty_1::m12",
813 );
814 assert_eq!(
815 unsafe { ::core::ptr::addr_of!((*ptr).m13) as usize - ptr as usize },
816 8usize,
817 "Offset of field: LOTNode__bindgen_ty_5__bindgen_ty_1::m13",
818 );
819 assert_eq!(
820 unsafe { ::core::ptr::addr_of!((*ptr).m21) as usize - ptr as usize },
821 12usize,
822 "Offset of field: LOTNode__bindgen_ty_5__bindgen_ty_1::m21",
823 );
824 assert_eq!(
825 unsafe { ::core::ptr::addr_of!((*ptr).m22) as usize - ptr as usize },
826 16usize,
827 "Offset of field: LOTNode__bindgen_ty_5__bindgen_ty_1::m22",
828 );
829 assert_eq!(
830 unsafe { ::core::ptr::addr_of!((*ptr).m23) as usize - ptr as usize },
831 20usize,
832 "Offset of field: LOTNode__bindgen_ty_5__bindgen_ty_1::m23",
833 );
834 assert_eq!(
835 unsafe { ::core::ptr::addr_of!((*ptr).m31) as usize - ptr as usize },
836 24usize,
837 "Offset of field: LOTNode__bindgen_ty_5__bindgen_ty_1::m31",
838 );
839 assert_eq!(
840 unsafe { ::core::ptr::addr_of!((*ptr).m32) as usize - ptr as usize },
841 28usize,
842 "Offset of field: LOTNode__bindgen_ty_5__bindgen_ty_1::m32",
843 );
844 assert_eq!(
845 unsafe { ::core::ptr::addr_of!((*ptr).m33) as usize - ptr as usize },
846 32usize,
847 "Offset of field: LOTNode__bindgen_ty_5__bindgen_ty_1::m33",
848 );
849}
850#[test]
851fn bindgen_test_layout_LOTNode__bindgen_ty_5() {
852 const UNINIT: ::core::mem::MaybeUninit<LOTNode__bindgen_ty_5> = ::core::mem::MaybeUninit::uninit();
853 let ptr = UNINIT.as_ptr();
854 assert_eq!(
855 ::core::mem::size_of::<LOTNode__bindgen_ty_5>(),
856 64usize,
857 "Size of LOTNode__bindgen_ty_5",
858 );
859 assert_eq!(
860 ::core::mem::align_of::<LOTNode__bindgen_ty_5>(),
861 8usize,
862 "Alignment of LOTNode__bindgen_ty_5",
863 );
864 assert_eq!(
865 unsafe { ::core::ptr::addr_of!((*ptr).data) as usize - ptr as usize },
866 0usize,
867 "Offset of field: LOTNode__bindgen_ty_5::data",
868 );
869 assert_eq!(
870 unsafe { ::core::ptr::addr_of!((*ptr).width) as usize - ptr as usize },
871 8usize,
872 "Offset of field: LOTNode__bindgen_ty_5::width",
873 );
874 assert_eq!(
875 unsafe { ::core::ptr::addr_of!((*ptr).height) as usize - ptr as usize },
876 16usize,
877 "Offset of field: LOTNode__bindgen_ty_5::height",
878 );
879 assert_eq!(
880 unsafe { ::core::ptr::addr_of!((*ptr).mAlpha) as usize - ptr as usize },
881 24usize,
882 "Offset of field: LOTNode__bindgen_ty_5::mAlpha",
883 );
884 assert_eq!(
885 unsafe { ::core::ptr::addr_of!((*ptr).mMatrix) as usize - ptr as usize },
886 28usize,
887 "Offset of field: LOTNode__bindgen_ty_5::mMatrix",
888 );
889}
890#[test]
891fn bindgen_test_layout_LOTNode() {
892 const UNINIT: ::core::mem::MaybeUninit<LOTNode> = ::core::mem::MaybeUninit::uninit();
893 let ptr = UNINIT.as_ptr();
894 assert_eq!(::core::mem::size_of::<LOTNode>(), 232usize, "Size of LOTNode");
895 assert_eq!(::core::mem::align_of::<LOTNode>(), 8usize, "Alignment of LOTNode");
896 assert_eq!(
897 unsafe { ::core::ptr::addr_of!((*ptr).mPath) as usize - ptr as usize },
898 0usize,
899 "Offset of field: LOTNode::mPath",
900 );
901 assert_eq!(
902 unsafe { ::core::ptr::addr_of!((*ptr).mColor) as usize - ptr as usize },
903 32usize,
904 "Offset of field: LOTNode::mColor",
905 );
906 assert_eq!(
907 unsafe { ::core::ptr::addr_of!((*ptr).mStroke) as usize - ptr as usize },
908 40usize,
909 "Offset of field: LOTNode::mStroke",
910 );
911 assert_eq!(
912 unsafe { ::core::ptr::addr_of!((*ptr).mGradient) as usize - ptr as usize },
913 80usize,
914 "Offset of field: LOTNode::mGradient",
915 );
916 assert_eq!(
917 unsafe { ::core::ptr::addr_of!((*ptr).mImageInfo) as usize - ptr as usize },
918 144usize,
919 "Offset of field: LOTNode::mImageInfo",
920 );
921 assert_eq!(
922 unsafe { ::core::ptr::addr_of!((*ptr).mFlag) as usize - ptr as usize },
923 208usize,
924 "Offset of field: LOTNode::mFlag",
925 );
926 assert_eq!(
927 unsafe { ::core::ptr::addr_of!((*ptr).mBrushType) as usize - ptr as usize },
928 212usize,
929 "Offset of field: LOTNode::mBrushType",
930 );
931 assert_eq!(
932 unsafe { ::core::ptr::addr_of!((*ptr).mFillRule) as usize - ptr as usize },
933 216usize,
934 "Offset of field: LOTNode::mFillRule",
935 );
936 assert_eq!(
937 unsafe { ::core::ptr::addr_of!((*ptr).keypath) as usize - ptr as usize },
938 224usize,
939 "Offset of field: LOTNode::keypath",
940 );
941}
942#[repr(C)]
943#[derive(Debug, Copy, Clone)]
944pub struct LOTLayerNode {
945 pub mMaskList: LOTLayerNode__bindgen_ty_1,
946 pub mClipPath: LOTLayerNode__bindgen_ty_2,
947 pub mLayerList: LOTLayerNode__bindgen_ty_3,
948 pub mNodeList: LOTLayerNode__bindgen_ty_4,
949 pub mMatte: LOTMatteType,
950 pub mVisible: ::core::ffi::c_int,
951 pub mAlpha: ::core::ffi::c_uchar,
952 pub keypath: *const ::core::ffi::c_char,
953}
954#[repr(C)]
955#[derive(Debug, Copy, Clone)]
956pub struct LOTLayerNode__bindgen_ty_1 {
957 pub ptr: *mut LOTMask,
958 pub size: usize,
959}
960#[test]
961fn bindgen_test_layout_LOTLayerNode__bindgen_ty_1() {
962 const UNINIT: ::core::mem::MaybeUninit<LOTLayerNode__bindgen_ty_1> = ::core::mem::MaybeUninit::uninit();
963 let ptr = UNINIT.as_ptr();
964 assert_eq!(
965 ::core::mem::size_of::<LOTLayerNode__bindgen_ty_1>(),
966 16usize,
967 "Size of LOTLayerNode__bindgen_ty_1",
968 );
969 assert_eq!(
970 ::core::mem::align_of::<LOTLayerNode__bindgen_ty_1>(),
971 8usize,
972 "Alignment of LOTLayerNode__bindgen_ty_1",
973 );
974 assert_eq!(
975 unsafe { ::core::ptr::addr_of!((*ptr).ptr) as usize - ptr as usize },
976 0usize,
977 "Offset of field: LOTLayerNode__bindgen_ty_1::ptr",
978 );
979 assert_eq!(
980 unsafe { ::core::ptr::addr_of!((*ptr).size) as usize - ptr as usize },
981 8usize,
982 "Offset of field: LOTLayerNode__bindgen_ty_1::size",
983 );
984}
985#[repr(C)]
986#[derive(Debug, Copy, Clone)]
987pub struct LOTLayerNode__bindgen_ty_2 {
988 pub ptPtr: *const f32,
989 pub ptCount: usize,
990 pub elmPtr: *const ::core::ffi::c_char,
991 pub elmCount: usize,
992}
993#[test]
994fn bindgen_test_layout_LOTLayerNode__bindgen_ty_2() {
995 const UNINIT: ::core::mem::MaybeUninit<LOTLayerNode__bindgen_ty_2> = ::core::mem::MaybeUninit::uninit();
996 let ptr = UNINIT.as_ptr();
997 assert_eq!(
998 ::core::mem::size_of::<LOTLayerNode__bindgen_ty_2>(),
999 32usize,
1000 "Size of LOTLayerNode__bindgen_ty_2",
1001 );
1002 assert_eq!(
1003 ::core::mem::align_of::<LOTLayerNode__bindgen_ty_2>(),
1004 8usize,
1005 "Alignment of LOTLayerNode__bindgen_ty_2",
1006 );
1007 assert_eq!(
1008 unsafe { ::core::ptr::addr_of!((*ptr).ptPtr) as usize - ptr as usize },
1009 0usize,
1010 "Offset of field: LOTLayerNode__bindgen_ty_2::ptPtr",
1011 );
1012 assert_eq!(
1013 unsafe { ::core::ptr::addr_of!((*ptr).ptCount) as usize - ptr as usize },
1014 8usize,
1015 "Offset of field: LOTLayerNode__bindgen_ty_2::ptCount",
1016 );
1017 assert_eq!(
1018 unsafe { ::core::ptr::addr_of!((*ptr).elmPtr) as usize - ptr as usize },
1019 16usize,
1020 "Offset of field: LOTLayerNode__bindgen_ty_2::elmPtr",
1021 );
1022 assert_eq!(
1023 unsafe { ::core::ptr::addr_of!((*ptr).elmCount) as usize - ptr as usize },
1024 24usize,
1025 "Offset of field: LOTLayerNode__bindgen_ty_2::elmCount",
1026 );
1027}
1028#[repr(C)]
1029#[derive(Debug, Copy, Clone)]
1030pub struct LOTLayerNode__bindgen_ty_3 {
1031 pub ptr: *mut *mut LOTLayerNode,
1032 pub size: usize,
1033}
1034#[test]
1035fn bindgen_test_layout_LOTLayerNode__bindgen_ty_3() {
1036 const UNINIT: ::core::mem::MaybeUninit<LOTLayerNode__bindgen_ty_3> = ::core::mem::MaybeUninit::uninit();
1037 let ptr = UNINIT.as_ptr();
1038 assert_eq!(
1039 ::core::mem::size_of::<LOTLayerNode__bindgen_ty_3>(),
1040 16usize,
1041 "Size of LOTLayerNode__bindgen_ty_3",
1042 );
1043 assert_eq!(
1044 ::core::mem::align_of::<LOTLayerNode__bindgen_ty_3>(),
1045 8usize,
1046 "Alignment of LOTLayerNode__bindgen_ty_3",
1047 );
1048 assert_eq!(
1049 unsafe { ::core::ptr::addr_of!((*ptr).ptr) as usize - ptr as usize },
1050 0usize,
1051 "Offset of field: LOTLayerNode__bindgen_ty_3::ptr",
1052 );
1053 assert_eq!(
1054 unsafe { ::core::ptr::addr_of!((*ptr).size) as usize - ptr as usize },
1055 8usize,
1056 "Offset of field: LOTLayerNode__bindgen_ty_3::size",
1057 );
1058}
1059#[repr(C)]
1060#[derive(Debug, Copy, Clone)]
1061pub struct LOTLayerNode__bindgen_ty_4 {
1062 pub ptr: *mut *mut LOTNode,
1063 pub size: usize,
1064}
1065#[test]
1066fn bindgen_test_layout_LOTLayerNode__bindgen_ty_4() {
1067 const UNINIT: ::core::mem::MaybeUninit<LOTLayerNode__bindgen_ty_4> = ::core::mem::MaybeUninit::uninit();
1068 let ptr = UNINIT.as_ptr();
1069 assert_eq!(
1070 ::core::mem::size_of::<LOTLayerNode__bindgen_ty_4>(),
1071 16usize,
1072 "Size of LOTLayerNode__bindgen_ty_4",
1073 );
1074 assert_eq!(
1075 ::core::mem::align_of::<LOTLayerNode__bindgen_ty_4>(),
1076 8usize,
1077 "Alignment of LOTLayerNode__bindgen_ty_4",
1078 );
1079 assert_eq!(
1080 unsafe { ::core::ptr::addr_of!((*ptr).ptr) as usize - ptr as usize },
1081 0usize,
1082 "Offset of field: LOTLayerNode__bindgen_ty_4::ptr",
1083 );
1084 assert_eq!(
1085 unsafe { ::core::ptr::addr_of!((*ptr).size) as usize - ptr as usize },
1086 8usize,
1087 "Offset of field: LOTLayerNode__bindgen_ty_4::size",
1088 );
1089}
1090#[test]
1091fn bindgen_test_layout_LOTLayerNode() {
1092 const UNINIT: ::core::mem::MaybeUninit<LOTLayerNode> = ::core::mem::MaybeUninit::uninit();
1093 let ptr = UNINIT.as_ptr();
1094 assert_eq!(::core::mem::size_of::<LOTLayerNode>(), 104usize, "Size of LOTLayerNode");
1095 assert_eq!(
1096 ::core::mem::align_of::<LOTLayerNode>(),
1097 8usize,
1098 "Alignment of LOTLayerNode",
1099 );
1100 assert_eq!(
1101 unsafe { ::core::ptr::addr_of!((*ptr).mMaskList) as usize - ptr as usize },
1102 0usize,
1103 "Offset of field: LOTLayerNode::mMaskList",
1104 );
1105 assert_eq!(
1106 unsafe { ::core::ptr::addr_of!((*ptr).mClipPath) as usize - ptr as usize },
1107 16usize,
1108 "Offset of field: LOTLayerNode::mClipPath",
1109 );
1110 assert_eq!(
1111 unsafe { ::core::ptr::addr_of!((*ptr).mLayerList) as usize - ptr as usize },
1112 48usize,
1113 "Offset of field: LOTLayerNode::mLayerList",
1114 );
1115 assert_eq!(
1116 unsafe { ::core::ptr::addr_of!((*ptr).mNodeList) as usize - ptr as usize },
1117 64usize,
1118 "Offset of field: LOTLayerNode::mNodeList",
1119 );
1120 assert_eq!(
1121 unsafe { ::core::ptr::addr_of!((*ptr).mMatte) as usize - ptr as usize },
1122 80usize,
1123 "Offset of field: LOTLayerNode::mMatte",
1124 );
1125 assert_eq!(
1126 unsafe { ::core::ptr::addr_of!((*ptr).mVisible) as usize - ptr as usize },
1127 84usize,
1128 "Offset of field: LOTLayerNode::mVisible",
1129 );
1130 assert_eq!(
1131 unsafe { ::core::ptr::addr_of!((*ptr).mAlpha) as usize - ptr as usize },
1132 88usize,
1133 "Offset of field: LOTLayerNode::mAlpha",
1134 );
1135 assert_eq!(
1136 unsafe { ::core::ptr::addr_of!((*ptr).keypath) as usize - ptr as usize },
1137 96usize,
1138 "Offset of field: LOTLayerNode::keypath",
1139 );
1140}
1141impl Lottie_Animation_Property {
1142 pub const LOTTIE_ANIMATION_PROPERTY_FILLCOLOR: Lottie_Animation_Property = Lottie_Animation_Property(
1143 0,
1144 );
1145}
1146impl Lottie_Animation_Property {
1147 pub const LOTTIE_ANIMATION_PROPERTY_FILLOPACITY: Lottie_Animation_Property = Lottie_Animation_Property(
1148 1,
1149 );
1150}
1151impl Lottie_Animation_Property {
1152 pub const LOTTIE_ANIMATION_PROPERTY_STROKECOLOR: Lottie_Animation_Property = Lottie_Animation_Property(
1153 2,
1154 );
1155}
1156impl Lottie_Animation_Property {
1157 pub const LOTTIE_ANIMATION_PROPERTY_STROKEOPACITY: Lottie_Animation_Property = Lottie_Animation_Property(
1158 3,
1159 );
1160}
1161impl Lottie_Animation_Property {
1162 pub const LOTTIE_ANIMATION_PROPERTY_STROKEWIDTH: Lottie_Animation_Property = Lottie_Animation_Property(
1163 4,
1164 );
1165}
1166impl Lottie_Animation_Property {
1167 pub const LOTTIE_ANIMATION_PROPERTY_TR_ANCHOR: Lottie_Animation_Property = Lottie_Animation_Property(
1168 5,
1169 );
1170}
1171impl Lottie_Animation_Property {
1172 pub const LOTTIE_ANIMATION_PROPERTY_TR_POSITION: Lottie_Animation_Property = Lottie_Animation_Property(
1173 6,
1174 );
1175}
1176impl Lottie_Animation_Property {
1177 pub const LOTTIE_ANIMATION_PROPERTY_TR_SCALE: Lottie_Animation_Property = Lottie_Animation_Property(
1178 7,
1179 );
1180}
1181impl Lottie_Animation_Property {
1182 pub const LOTTIE_ANIMATION_PROPERTY_TR_ROTATION: Lottie_Animation_Property = Lottie_Animation_Property(
1183 8,
1184 );
1185}
1186impl Lottie_Animation_Property {
1187 pub const LOTTIE_ANIMATION_PROPERTY_TR_OPACITY: Lottie_Animation_Property = Lottie_Animation_Property(
1188 9,
1189 );
1190}
1191#[repr(transparent)]
1192#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
1193pub struct Lottie_Animation_Property(pub ::core::ffi::c_uint);
1194#[repr(C)]
1195#[derive(Debug, Copy, Clone)]
1196pub struct Lottie_Animation_S {
1197 _unused: [u8; 0],
1198}
1199pub type Lottie_Animation = Lottie_Animation_S;
1200extern "C" {
1201 pub fn lottie_animation_from_file(
1202 path: *const ::core::ffi::c_char,
1203 ) -> *mut Lottie_Animation;
1204}
1205extern "C" {
1206 pub fn lottie_animation_from_data(
1207 data: *const ::core::ffi::c_char,
1208 key: *const ::core::ffi::c_char,
1209 resource_path: *const ::core::ffi::c_char,
1210 ) -> *mut Lottie_Animation;
1211}
1212extern "C" {
1213 pub fn lottie_animation_destroy(animation: *mut Lottie_Animation);
1214}
1215extern "C" {
1216 pub fn lottie_animation_get_size(
1217 animation: *const Lottie_Animation,
1218 width: *mut usize,
1219 height: *mut usize,
1220 );
1221}
1222extern "C" {
1223 pub fn lottie_animation_get_duration(animation: *const Lottie_Animation) -> f64;
1224}
1225extern "C" {
1226 pub fn lottie_animation_get_totalframe(animation: *const Lottie_Animation) -> usize;
1227}
1228extern "C" {
1229 pub fn lottie_animation_get_framerate(animation: *const Lottie_Animation) -> f64;
1230}
1231extern "C" {
1232 pub fn lottie_animation_render_tree(
1233 animation: *mut Lottie_Animation,
1234 frame_num: usize,
1235 width: usize,
1236 height: usize,
1237 ) -> *const LOTLayerNode;
1238}
1239extern "C" {
1240 pub fn lottie_animation_get_frame_at_pos(
1241 animation: *const Lottie_Animation,
1242 pos: f32,
1243 ) -> usize;
1244}
1245extern "C" {
1246 pub fn lottie_animation_render(
1247 animation: *mut Lottie_Animation,
1248 frame_num: usize,
1249 buffer: *mut u32,
1250 width: usize,
1251 height: usize,
1252 bytes_per_line: usize,
1253 );
1254}
1255extern "C" {
1256 pub fn lottie_animation_render_async(
1257 animation: *mut Lottie_Animation,
1258 frame_num: usize,
1259 buffer: *mut u32,
1260 width: usize,
1261 height: usize,
1262 bytes_per_line: usize,
1263 );
1264}
1265extern "C" {
1266 pub fn lottie_animation_render_flush(animation: *mut Lottie_Animation) -> *mut u32;
1267}
1268extern "C" {
1269 pub fn lottie_animation_property_override(
1270 animation: *mut Lottie_Animation,
1271 type_: Lottie_Animation_Property,
1272 keypath: *const ::core::ffi::c_char,
1273 ...
1274 );
1275}
1276extern "C" {
1277 pub fn lottie_animation_get_markerlist(
1278 animation: *mut Lottie_Animation,
1279 ) -> *const LOTMarkerList;
1280}