1pub const MOJOSHADER_VERSION: i32 = -1;
4pub const MOJOSHADER_CHANGESET: &'static [u8; 4usize] = b"???\0";
5pub const MOJOSHADER_POSITION_NONE: i32 = -3;
6pub const MOJOSHADER_POSITION_BEFORE: i32 = -2;
7pub const MOJOSHADER_POSITION_AFTER: i32 = -1;
8pub const MOJOSHADER_PROFILE_D3D: &'static [u8; 4usize] = b"d3d\0";
9pub const MOJOSHADER_PROFILE_BYTECODE: &'static [u8; 9usize] = b"bytecode\0";
10pub const MOJOSHADER_PROFILE_HLSL: &'static [u8; 5usize] = b"hlsl\0";
11pub const MOJOSHADER_PROFILE_GLSL: &'static [u8; 5usize] = b"glsl\0";
12pub const MOJOSHADER_PROFILE_GLSL120: &'static [u8; 8usize] = b"glsl120\0";
13pub const MOJOSHADER_PROFILE_GLSLES: &'static [u8; 7usize] = b"glsles\0";
14pub const MOJOSHADER_PROFILE_ARB1: &'static [u8; 5usize] = b"arb1\0";
15pub const MOJOSHADER_PROFILE_NV2: &'static [u8; 4usize] = b"nv2\0";
16pub const MOJOSHADER_PROFILE_NV3: &'static [u8; 4usize] = b"nv3\0";
17pub const MOJOSHADER_PROFILE_NV4: &'static [u8; 4usize] = b"nv4\0";
18pub const MOJOSHADER_PROFILE_METAL: &'static [u8; 6usize] = b"metal\0";
19pub const MOJOSHADER_PROFILE_SPIRV: &'static [u8; 6usize] = b"spirv\0";
20pub const MOJOSHADER_PROFILE_GLSPIRV: &'static [u8; 8usize] = b"glspirv\0";
21pub const MOJOSHADER_SRC_PROFILE_HLSL_VS_1_1: &'static [u8; 12usize] = b"hlsl_vs_1_1\0";
22pub const MOJOSHADER_SRC_PROFILE_HLSL_VS_2_0: &'static [u8; 12usize] = b"hlsl_vs_2_0\0";
23pub const MOJOSHADER_SRC_PROFILE_HLSL_VS_3_0: &'static [u8; 12usize] = b"hlsl_vs_3_0\0";
24pub const MOJOSHADER_SRC_PROFILE_HLSL_PS_1_1: &'static [u8; 12usize] = b"hlsl_ps_1_1\0";
25pub const MOJOSHADER_SRC_PROFILE_HLSL_PS_1_2: &'static [u8; 12usize] = b"hlsl_ps_1_2\0";
26pub const MOJOSHADER_SRC_PROFILE_HLSL_PS_1_3: &'static [u8; 12usize] = b"hlsl_ps_1_3\0";
27pub const MOJOSHADER_SRC_PROFILE_HLSL_PS_1_4: &'static [u8; 12usize] = b"hlsl_ps_1_4\0";
28pub const MOJOSHADER_SRC_PROFILE_HLSL_PS_2_0: &'static [u8; 12usize] = b"hlsl_ps_2_0\0";
29pub const MOJOSHADER_SRC_PROFILE_HLSL_PS_3_0: &'static [u8; 12usize] = b"hlsl_ps_3_0\0";
30pub const MOJOSHADER_AST_DATATYPE_CONST: u32 = 2147483648;
31extern "C" {
32 pub fn MOJOSHADER_version() -> ::std::os::raw::c_int;
33}
34extern "C" {
35 pub fn MOJOSHADER_changeset() -> *const ::std::os::raw::c_char;
36}
37pub type MOJOSHADER_malloc = ::std::option::Option<
38 unsafe extern "C" fn(
39 bytes: ::std::os::raw::c_int,
40 data: *mut ::std::os::raw::c_void,
41 ) -> *mut ::std::os::raw::c_void,
42>;
43pub type MOJOSHADER_free = ::std::option::Option<
44 unsafe extern "C" fn(ptr: *mut ::std::os::raw::c_void, data: *mut ::std::os::raw::c_void),
45>;
46pub const MOJOSHADER_shaderType_MOJOSHADER_TYPE_UNKNOWN: MOJOSHADER_shaderType = 0;
47pub const MOJOSHADER_shaderType_MOJOSHADER_TYPE_PIXEL: MOJOSHADER_shaderType = 1;
48pub const MOJOSHADER_shaderType_MOJOSHADER_TYPE_VERTEX: MOJOSHADER_shaderType = 2;
49pub const MOJOSHADER_shaderType_MOJOSHADER_TYPE_GEOMETRY: MOJOSHADER_shaderType = 4;
50pub const MOJOSHADER_shaderType_MOJOSHADER_TYPE_ANY: MOJOSHADER_shaderType = 2147483647;
51pub type MOJOSHADER_shaderType = ::std::os::raw::c_uint;
52pub const MOJOSHADER_attributeType_MOJOSHADER_ATTRIBUTE_UNKNOWN: MOJOSHADER_attributeType = -1;
53pub const MOJOSHADER_attributeType_MOJOSHADER_ATTRIBUTE_BYTE: MOJOSHADER_attributeType = 0;
54pub const MOJOSHADER_attributeType_MOJOSHADER_ATTRIBUTE_UBYTE: MOJOSHADER_attributeType = 1;
55pub const MOJOSHADER_attributeType_MOJOSHADER_ATTRIBUTE_SHORT: MOJOSHADER_attributeType = 2;
56pub const MOJOSHADER_attributeType_MOJOSHADER_ATTRIBUTE_USHORT: MOJOSHADER_attributeType = 3;
57pub const MOJOSHADER_attributeType_MOJOSHADER_ATTRIBUTE_INT: MOJOSHADER_attributeType = 4;
58pub const MOJOSHADER_attributeType_MOJOSHADER_ATTRIBUTE_UINT: MOJOSHADER_attributeType = 5;
59pub const MOJOSHADER_attributeType_MOJOSHADER_ATTRIBUTE_FLOAT: MOJOSHADER_attributeType = 6;
60pub const MOJOSHADER_attributeType_MOJOSHADER_ATTRIBUTE_DOUBLE: MOJOSHADER_attributeType = 7;
61pub const MOJOSHADER_attributeType_MOJOSHADER_ATTRIBUTE_HALF_FLOAT: MOJOSHADER_attributeType = 8;
62pub type MOJOSHADER_attributeType = ::std::os::raw::c_int;
63pub const MOJOSHADER_uniformType_MOJOSHADER_UNIFORM_UNKNOWN: MOJOSHADER_uniformType = -1;
64pub const MOJOSHADER_uniformType_MOJOSHADER_UNIFORM_FLOAT: MOJOSHADER_uniformType = 0;
65pub const MOJOSHADER_uniformType_MOJOSHADER_UNIFORM_INT: MOJOSHADER_uniformType = 1;
66pub const MOJOSHADER_uniformType_MOJOSHADER_UNIFORM_BOOL: MOJOSHADER_uniformType = 2;
67pub type MOJOSHADER_uniformType = ::std::os::raw::c_int;
68#[repr(C)]
69#[derive(Debug, Copy, Clone)]
70pub struct MOJOSHADER_uniform {
71 pub type_: MOJOSHADER_uniformType,
72 pub index: ::std::os::raw::c_int,
73 pub array_count: ::std::os::raw::c_int,
74 pub constant: ::std::os::raw::c_int,
75 pub name: *const ::std::os::raw::c_char,
76}
77#[test]
78fn bindgen_test_layout_MOJOSHADER_uniform() {
79 assert_eq!(
80 ::std::mem::size_of::<MOJOSHADER_uniform>(),
81 24usize,
82 concat!("Size of: ", stringify!(MOJOSHADER_uniform))
83 );
84 assert_eq!(
85 ::std::mem::align_of::<MOJOSHADER_uniform>(),
86 8usize,
87 concat!("Alignment of ", stringify!(MOJOSHADER_uniform))
88 );
89 assert_eq!(
90 unsafe { &(*(::std::ptr::null::<MOJOSHADER_uniform>())).type_ as *const _ as usize },
91 0usize,
92 concat!(
93 "Offset of field: ",
94 stringify!(MOJOSHADER_uniform),
95 "::",
96 stringify!(type_)
97 )
98 );
99 assert_eq!(
100 unsafe { &(*(::std::ptr::null::<MOJOSHADER_uniform>())).index as *const _ as usize },
101 4usize,
102 concat!(
103 "Offset of field: ",
104 stringify!(MOJOSHADER_uniform),
105 "::",
106 stringify!(index)
107 )
108 );
109 assert_eq!(
110 unsafe { &(*(::std::ptr::null::<MOJOSHADER_uniform>())).array_count as *const _ as usize },
111 8usize,
112 concat!(
113 "Offset of field: ",
114 stringify!(MOJOSHADER_uniform),
115 "::",
116 stringify!(array_count)
117 )
118 );
119 assert_eq!(
120 unsafe { &(*(::std::ptr::null::<MOJOSHADER_uniform>())).constant as *const _ as usize },
121 12usize,
122 concat!(
123 "Offset of field: ",
124 stringify!(MOJOSHADER_uniform),
125 "::",
126 stringify!(constant)
127 )
128 );
129 assert_eq!(
130 unsafe { &(*(::std::ptr::null::<MOJOSHADER_uniform>())).name as *const _ as usize },
131 16usize,
132 concat!(
133 "Offset of field: ",
134 stringify!(MOJOSHADER_uniform),
135 "::",
136 stringify!(name)
137 )
138 );
139}
140#[repr(C)]
141#[derive(Copy, Clone)]
142pub struct MOJOSHADER_constant {
143 pub type_: MOJOSHADER_uniformType,
144 pub index: ::std::os::raw::c_int,
145 pub value: MOJOSHADER_constant__bindgen_ty_1,
146}
147#[repr(C)]
148#[derive(Copy, Clone)]
149pub union MOJOSHADER_constant__bindgen_ty_1 {
150 pub f: [f32; 4usize],
151 pub i: [::std::os::raw::c_int; 4usize],
152 pub b: ::std::os::raw::c_int,
153 _bindgen_union_align: [u32; 4usize],
154}
155#[test]
156fn bindgen_test_layout_MOJOSHADER_constant__bindgen_ty_1() {
157 assert_eq!(
158 ::std::mem::size_of::<MOJOSHADER_constant__bindgen_ty_1>(),
159 16usize,
160 concat!("Size of: ", stringify!(MOJOSHADER_constant__bindgen_ty_1))
161 );
162 assert_eq!(
163 ::std::mem::align_of::<MOJOSHADER_constant__bindgen_ty_1>(),
164 4usize,
165 concat!(
166 "Alignment of ",
167 stringify!(MOJOSHADER_constant__bindgen_ty_1)
168 )
169 );
170 assert_eq!(
171 unsafe {
172 &(*(::std::ptr::null::<MOJOSHADER_constant__bindgen_ty_1>())).f as *const _ as usize
173 },
174 0usize,
175 concat!(
176 "Offset of field: ",
177 stringify!(MOJOSHADER_constant__bindgen_ty_1),
178 "::",
179 stringify!(f)
180 )
181 );
182 assert_eq!(
183 unsafe {
184 &(*(::std::ptr::null::<MOJOSHADER_constant__bindgen_ty_1>())).i as *const _ as usize
185 },
186 0usize,
187 concat!(
188 "Offset of field: ",
189 stringify!(MOJOSHADER_constant__bindgen_ty_1),
190 "::",
191 stringify!(i)
192 )
193 );
194 assert_eq!(
195 unsafe {
196 &(*(::std::ptr::null::<MOJOSHADER_constant__bindgen_ty_1>())).b as *const _ as usize
197 },
198 0usize,
199 concat!(
200 "Offset of field: ",
201 stringify!(MOJOSHADER_constant__bindgen_ty_1),
202 "::",
203 stringify!(b)
204 )
205 );
206}
207#[test]
208fn bindgen_test_layout_MOJOSHADER_constant() {
209 assert_eq!(
210 ::std::mem::size_of::<MOJOSHADER_constant>(),
211 24usize,
212 concat!("Size of: ", stringify!(MOJOSHADER_constant))
213 );
214 assert_eq!(
215 ::std::mem::align_of::<MOJOSHADER_constant>(),
216 4usize,
217 concat!("Alignment of ", stringify!(MOJOSHADER_constant))
218 );
219 assert_eq!(
220 unsafe { &(*(::std::ptr::null::<MOJOSHADER_constant>())).type_ as *const _ as usize },
221 0usize,
222 concat!(
223 "Offset of field: ",
224 stringify!(MOJOSHADER_constant),
225 "::",
226 stringify!(type_)
227 )
228 );
229 assert_eq!(
230 unsafe { &(*(::std::ptr::null::<MOJOSHADER_constant>())).index as *const _ as usize },
231 4usize,
232 concat!(
233 "Offset of field: ",
234 stringify!(MOJOSHADER_constant),
235 "::",
236 stringify!(index)
237 )
238 );
239 assert_eq!(
240 unsafe { &(*(::std::ptr::null::<MOJOSHADER_constant>())).value as *const _ as usize },
241 8usize,
242 concat!(
243 "Offset of field: ",
244 stringify!(MOJOSHADER_constant),
245 "::",
246 stringify!(value)
247 )
248 );
249}
250pub const MOJOSHADER_samplerType_MOJOSHADER_SAMPLER_UNKNOWN: MOJOSHADER_samplerType = -1;
251pub const MOJOSHADER_samplerType_MOJOSHADER_SAMPLER_2D: MOJOSHADER_samplerType = 0;
252pub const MOJOSHADER_samplerType_MOJOSHADER_SAMPLER_CUBE: MOJOSHADER_samplerType = 1;
253pub const MOJOSHADER_samplerType_MOJOSHADER_SAMPLER_VOLUME: MOJOSHADER_samplerType = 2;
254pub type MOJOSHADER_samplerType = ::std::os::raw::c_int;
255#[repr(C)]
256#[derive(Debug, Copy, Clone)]
257pub struct MOJOSHADER_sampler {
258 pub type_: MOJOSHADER_samplerType,
259 pub index: ::std::os::raw::c_int,
260 pub name: *const ::std::os::raw::c_char,
261 pub texbem: ::std::os::raw::c_int,
262}
263#[test]
264fn bindgen_test_layout_MOJOSHADER_sampler() {
265 assert_eq!(
266 ::std::mem::size_of::<MOJOSHADER_sampler>(),
267 24usize,
268 concat!("Size of: ", stringify!(MOJOSHADER_sampler))
269 );
270 assert_eq!(
271 ::std::mem::align_of::<MOJOSHADER_sampler>(),
272 8usize,
273 concat!("Alignment of ", stringify!(MOJOSHADER_sampler))
274 );
275 assert_eq!(
276 unsafe { &(*(::std::ptr::null::<MOJOSHADER_sampler>())).type_ as *const _ as usize },
277 0usize,
278 concat!(
279 "Offset of field: ",
280 stringify!(MOJOSHADER_sampler),
281 "::",
282 stringify!(type_)
283 )
284 );
285 assert_eq!(
286 unsafe { &(*(::std::ptr::null::<MOJOSHADER_sampler>())).index as *const _ as usize },
287 4usize,
288 concat!(
289 "Offset of field: ",
290 stringify!(MOJOSHADER_sampler),
291 "::",
292 stringify!(index)
293 )
294 );
295 assert_eq!(
296 unsafe { &(*(::std::ptr::null::<MOJOSHADER_sampler>())).name as *const _ as usize },
297 8usize,
298 concat!(
299 "Offset of field: ",
300 stringify!(MOJOSHADER_sampler),
301 "::",
302 stringify!(name)
303 )
304 );
305 assert_eq!(
306 unsafe { &(*(::std::ptr::null::<MOJOSHADER_sampler>())).texbem as *const _ as usize },
307 16usize,
308 concat!(
309 "Offset of field: ",
310 stringify!(MOJOSHADER_sampler),
311 "::",
312 stringify!(texbem)
313 )
314 );
315}
316#[repr(C)]
317#[derive(Debug, Copy, Clone)]
318pub struct MOJOSHADER_samplerMap {
319 pub index: ::std::os::raw::c_int,
320 pub type_: MOJOSHADER_samplerType,
321}
322#[test]
323fn bindgen_test_layout_MOJOSHADER_samplerMap() {
324 assert_eq!(
325 ::std::mem::size_of::<MOJOSHADER_samplerMap>(),
326 8usize,
327 concat!("Size of: ", stringify!(MOJOSHADER_samplerMap))
328 );
329 assert_eq!(
330 ::std::mem::align_of::<MOJOSHADER_samplerMap>(),
331 4usize,
332 concat!("Alignment of ", stringify!(MOJOSHADER_samplerMap))
333 );
334 assert_eq!(
335 unsafe { &(*(::std::ptr::null::<MOJOSHADER_samplerMap>())).index as *const _ as usize },
336 0usize,
337 concat!(
338 "Offset of field: ",
339 stringify!(MOJOSHADER_samplerMap),
340 "::",
341 stringify!(index)
342 )
343 );
344 assert_eq!(
345 unsafe { &(*(::std::ptr::null::<MOJOSHADER_samplerMap>())).type_ as *const _ as usize },
346 4usize,
347 concat!(
348 "Offset of field: ",
349 stringify!(MOJOSHADER_samplerMap),
350 "::",
351 stringify!(type_)
352 )
353 );
354}
355pub const MOJOSHADER_usage_MOJOSHADER_USAGE_UNKNOWN: MOJOSHADER_usage = -1;
356pub const MOJOSHADER_usage_MOJOSHADER_USAGE_POSITION: MOJOSHADER_usage = 0;
357pub const MOJOSHADER_usage_MOJOSHADER_USAGE_BLENDWEIGHT: MOJOSHADER_usage = 1;
358pub const MOJOSHADER_usage_MOJOSHADER_USAGE_BLENDINDICES: MOJOSHADER_usage = 2;
359pub const MOJOSHADER_usage_MOJOSHADER_USAGE_NORMAL: MOJOSHADER_usage = 3;
360pub const MOJOSHADER_usage_MOJOSHADER_USAGE_POINTSIZE: MOJOSHADER_usage = 4;
361pub const MOJOSHADER_usage_MOJOSHADER_USAGE_TEXCOORD: MOJOSHADER_usage = 5;
362pub const MOJOSHADER_usage_MOJOSHADER_USAGE_TANGENT: MOJOSHADER_usage = 6;
363pub const MOJOSHADER_usage_MOJOSHADER_USAGE_BINORMAL: MOJOSHADER_usage = 7;
364pub const MOJOSHADER_usage_MOJOSHADER_USAGE_TESSFACTOR: MOJOSHADER_usage = 8;
365pub const MOJOSHADER_usage_MOJOSHADER_USAGE_POSITIONT: MOJOSHADER_usage = 9;
366pub const MOJOSHADER_usage_MOJOSHADER_USAGE_COLOR: MOJOSHADER_usage = 10;
367pub const MOJOSHADER_usage_MOJOSHADER_USAGE_FOG: MOJOSHADER_usage = 11;
368pub const MOJOSHADER_usage_MOJOSHADER_USAGE_DEPTH: MOJOSHADER_usage = 12;
369pub const MOJOSHADER_usage_MOJOSHADER_USAGE_SAMPLE: MOJOSHADER_usage = 13;
370pub const MOJOSHADER_usage_MOJOSHADER_USAGE_TOTAL: MOJOSHADER_usage = 14;
371pub type MOJOSHADER_usage = ::std::os::raw::c_int;
372#[repr(C)]
373#[derive(Debug, Copy, Clone)]
374pub struct MOJOSHADER_attribute {
375 pub usage: MOJOSHADER_usage,
376 pub index: ::std::os::raw::c_int,
377 pub name: *const ::std::os::raw::c_char,
378}
379#[test]
380fn bindgen_test_layout_MOJOSHADER_attribute() {
381 assert_eq!(
382 ::std::mem::size_of::<MOJOSHADER_attribute>(),
383 16usize,
384 concat!("Size of: ", stringify!(MOJOSHADER_attribute))
385 );
386 assert_eq!(
387 ::std::mem::align_of::<MOJOSHADER_attribute>(),
388 8usize,
389 concat!("Alignment of ", stringify!(MOJOSHADER_attribute))
390 );
391 assert_eq!(
392 unsafe { &(*(::std::ptr::null::<MOJOSHADER_attribute>())).usage as *const _ as usize },
393 0usize,
394 concat!(
395 "Offset of field: ",
396 stringify!(MOJOSHADER_attribute),
397 "::",
398 stringify!(usage)
399 )
400 );
401 assert_eq!(
402 unsafe { &(*(::std::ptr::null::<MOJOSHADER_attribute>())).index as *const _ as usize },
403 4usize,
404 concat!(
405 "Offset of field: ",
406 stringify!(MOJOSHADER_attribute),
407 "::",
408 stringify!(index)
409 )
410 );
411 assert_eq!(
412 unsafe { &(*(::std::ptr::null::<MOJOSHADER_attribute>())).name as *const _ as usize },
413 8usize,
414 concat!(
415 "Offset of field: ",
416 stringify!(MOJOSHADER_attribute),
417 "::",
418 stringify!(name)
419 )
420 );
421}
422#[repr(C)]
423#[derive(Debug, Copy, Clone)]
424pub struct MOJOSHADER_swizzle {
425 pub usage: MOJOSHADER_usage,
426 pub index: ::std::os::raw::c_uint,
427 pub swizzles: [::std::os::raw::c_uchar; 4usize],
428}
429#[test]
430fn bindgen_test_layout_MOJOSHADER_swizzle() {
431 assert_eq!(
432 ::std::mem::size_of::<MOJOSHADER_swizzle>(),
433 12usize,
434 concat!("Size of: ", stringify!(MOJOSHADER_swizzle))
435 );
436 assert_eq!(
437 ::std::mem::align_of::<MOJOSHADER_swizzle>(),
438 4usize,
439 concat!("Alignment of ", stringify!(MOJOSHADER_swizzle))
440 );
441 assert_eq!(
442 unsafe { &(*(::std::ptr::null::<MOJOSHADER_swizzle>())).usage as *const _ as usize },
443 0usize,
444 concat!(
445 "Offset of field: ",
446 stringify!(MOJOSHADER_swizzle),
447 "::",
448 stringify!(usage)
449 )
450 );
451 assert_eq!(
452 unsafe { &(*(::std::ptr::null::<MOJOSHADER_swizzle>())).index as *const _ as usize },
453 4usize,
454 concat!(
455 "Offset of field: ",
456 stringify!(MOJOSHADER_swizzle),
457 "::",
458 stringify!(index)
459 )
460 );
461 assert_eq!(
462 unsafe { &(*(::std::ptr::null::<MOJOSHADER_swizzle>())).swizzles as *const _ as usize },
463 8usize,
464 concat!(
465 "Offset of field: ",
466 stringify!(MOJOSHADER_swizzle),
467 "::",
468 stringify!(swizzles)
469 )
470 );
471}
472pub const MOJOSHADER_symbolRegisterSet_MOJOSHADER_SYMREGSET_BOOL: MOJOSHADER_symbolRegisterSet = 0;
473pub const MOJOSHADER_symbolRegisterSet_MOJOSHADER_SYMREGSET_INT4: MOJOSHADER_symbolRegisterSet = 1;
474pub const MOJOSHADER_symbolRegisterSet_MOJOSHADER_SYMREGSET_FLOAT4: MOJOSHADER_symbolRegisterSet =
475 2;
476pub const MOJOSHADER_symbolRegisterSet_MOJOSHADER_SYMREGSET_SAMPLER: MOJOSHADER_symbolRegisterSet =
477 3;
478pub const MOJOSHADER_symbolRegisterSet_MOJOSHADER_SYMREGSET_TOTAL: MOJOSHADER_symbolRegisterSet = 4;
479pub type MOJOSHADER_symbolRegisterSet = ::std::os::raw::c_uint;
480pub const MOJOSHADER_symbolClass_MOJOSHADER_SYMCLASS_SCALAR: MOJOSHADER_symbolClass = 0;
481pub const MOJOSHADER_symbolClass_MOJOSHADER_SYMCLASS_VECTOR: MOJOSHADER_symbolClass = 1;
482pub const MOJOSHADER_symbolClass_MOJOSHADER_SYMCLASS_MATRIX_ROWS: MOJOSHADER_symbolClass = 2;
483pub const MOJOSHADER_symbolClass_MOJOSHADER_SYMCLASS_MATRIX_COLUMNS: MOJOSHADER_symbolClass = 3;
484pub const MOJOSHADER_symbolClass_MOJOSHADER_SYMCLASS_OBJECT: MOJOSHADER_symbolClass = 4;
485pub const MOJOSHADER_symbolClass_MOJOSHADER_SYMCLASS_STRUCT: MOJOSHADER_symbolClass = 5;
486pub const MOJOSHADER_symbolClass_MOJOSHADER_SYMCLASS_TOTAL: MOJOSHADER_symbolClass = 6;
487pub type MOJOSHADER_symbolClass = ::std::os::raw::c_uint;
488pub const MOJOSHADER_symbolType_MOJOSHADER_SYMTYPE_VOID: MOJOSHADER_symbolType = 0;
489pub const MOJOSHADER_symbolType_MOJOSHADER_SYMTYPE_BOOL: MOJOSHADER_symbolType = 1;
490pub const MOJOSHADER_symbolType_MOJOSHADER_SYMTYPE_INT: MOJOSHADER_symbolType = 2;
491pub const MOJOSHADER_symbolType_MOJOSHADER_SYMTYPE_FLOAT: MOJOSHADER_symbolType = 3;
492pub const MOJOSHADER_symbolType_MOJOSHADER_SYMTYPE_STRING: MOJOSHADER_symbolType = 4;
493pub const MOJOSHADER_symbolType_MOJOSHADER_SYMTYPE_TEXTURE: MOJOSHADER_symbolType = 5;
494pub const MOJOSHADER_symbolType_MOJOSHADER_SYMTYPE_TEXTURE1D: MOJOSHADER_symbolType = 6;
495pub const MOJOSHADER_symbolType_MOJOSHADER_SYMTYPE_TEXTURE2D: MOJOSHADER_symbolType = 7;
496pub const MOJOSHADER_symbolType_MOJOSHADER_SYMTYPE_TEXTURE3D: MOJOSHADER_symbolType = 8;
497pub const MOJOSHADER_symbolType_MOJOSHADER_SYMTYPE_TEXTURECUBE: MOJOSHADER_symbolType = 9;
498pub const MOJOSHADER_symbolType_MOJOSHADER_SYMTYPE_SAMPLER: MOJOSHADER_symbolType = 10;
499pub const MOJOSHADER_symbolType_MOJOSHADER_SYMTYPE_SAMPLER1D: MOJOSHADER_symbolType = 11;
500pub const MOJOSHADER_symbolType_MOJOSHADER_SYMTYPE_SAMPLER2D: MOJOSHADER_symbolType = 12;
501pub const MOJOSHADER_symbolType_MOJOSHADER_SYMTYPE_SAMPLER3D: MOJOSHADER_symbolType = 13;
502pub const MOJOSHADER_symbolType_MOJOSHADER_SYMTYPE_SAMPLERCUBE: MOJOSHADER_symbolType = 14;
503pub const MOJOSHADER_symbolType_MOJOSHADER_SYMTYPE_PIXELSHADER: MOJOSHADER_symbolType = 15;
504pub const MOJOSHADER_symbolType_MOJOSHADER_SYMTYPE_VERTEXSHADER: MOJOSHADER_symbolType = 16;
505pub const MOJOSHADER_symbolType_MOJOSHADER_SYMTYPE_PIXELFRAGMENT: MOJOSHADER_symbolType = 17;
506pub const MOJOSHADER_symbolType_MOJOSHADER_SYMTYPE_VERTEXFRAGMENT: MOJOSHADER_symbolType = 18;
507pub const MOJOSHADER_symbolType_MOJOSHADER_SYMTYPE_UNSUPPORTED: MOJOSHADER_symbolType = 19;
508pub const MOJOSHADER_symbolType_MOJOSHADER_SYMTYPE_TOTAL: MOJOSHADER_symbolType = 20;
509pub type MOJOSHADER_symbolType = ::std::os::raw::c_uint;
510#[repr(C)]
511#[derive(Debug, Copy, Clone)]
512pub struct MOJOSHADER_symbolTypeInfo {
513 pub parameter_class: MOJOSHADER_symbolClass,
514 pub parameter_type: MOJOSHADER_symbolType,
515 pub rows: ::std::os::raw::c_uint,
516 pub columns: ::std::os::raw::c_uint,
517 pub elements: ::std::os::raw::c_uint,
518 pub member_count: ::std::os::raw::c_uint,
519 pub members: *mut MOJOSHADER_symbolStructMember,
520}
521#[test]
522fn bindgen_test_layout_MOJOSHADER_symbolTypeInfo() {
523 assert_eq!(
524 ::std::mem::size_of::<MOJOSHADER_symbolTypeInfo>(),
525 32usize,
526 concat!("Size of: ", stringify!(MOJOSHADER_symbolTypeInfo))
527 );
528 assert_eq!(
529 ::std::mem::align_of::<MOJOSHADER_symbolTypeInfo>(),
530 8usize,
531 concat!("Alignment of ", stringify!(MOJOSHADER_symbolTypeInfo))
532 );
533 assert_eq!(
534 unsafe {
535 &(*(::std::ptr::null::<MOJOSHADER_symbolTypeInfo>())).parameter_class as *const _
536 as usize
537 },
538 0usize,
539 concat!(
540 "Offset of field: ",
541 stringify!(MOJOSHADER_symbolTypeInfo),
542 "::",
543 stringify!(parameter_class)
544 )
545 );
546 assert_eq!(
547 unsafe {
548 &(*(::std::ptr::null::<MOJOSHADER_symbolTypeInfo>())).parameter_type as *const _
549 as usize
550 },
551 4usize,
552 concat!(
553 "Offset of field: ",
554 stringify!(MOJOSHADER_symbolTypeInfo),
555 "::",
556 stringify!(parameter_type)
557 )
558 );
559 assert_eq!(
560 unsafe { &(*(::std::ptr::null::<MOJOSHADER_symbolTypeInfo>())).rows as *const _ as usize },
561 8usize,
562 concat!(
563 "Offset of field: ",
564 stringify!(MOJOSHADER_symbolTypeInfo),
565 "::",
566 stringify!(rows)
567 )
568 );
569 assert_eq!(
570 unsafe {
571 &(*(::std::ptr::null::<MOJOSHADER_symbolTypeInfo>())).columns as *const _ as usize
572 },
573 12usize,
574 concat!(
575 "Offset of field: ",
576 stringify!(MOJOSHADER_symbolTypeInfo),
577 "::",
578 stringify!(columns)
579 )
580 );
581 assert_eq!(
582 unsafe {
583 &(*(::std::ptr::null::<MOJOSHADER_symbolTypeInfo>())).elements as *const _ as usize
584 },
585 16usize,
586 concat!(
587 "Offset of field: ",
588 stringify!(MOJOSHADER_symbolTypeInfo),
589 "::",
590 stringify!(elements)
591 )
592 );
593 assert_eq!(
594 unsafe {
595 &(*(::std::ptr::null::<MOJOSHADER_symbolTypeInfo>())).member_count as *const _ as usize
596 },
597 20usize,
598 concat!(
599 "Offset of field: ",
600 stringify!(MOJOSHADER_symbolTypeInfo),
601 "::",
602 stringify!(member_count)
603 )
604 );
605 assert_eq!(
606 unsafe {
607 &(*(::std::ptr::null::<MOJOSHADER_symbolTypeInfo>())).members as *const _ as usize
608 },
609 24usize,
610 concat!(
611 "Offset of field: ",
612 stringify!(MOJOSHADER_symbolTypeInfo),
613 "::",
614 stringify!(members)
615 )
616 );
617}
618#[repr(C)]
619#[derive(Debug, Copy, Clone)]
620pub struct MOJOSHADER_symbolStructMember {
621 pub name: *const ::std::os::raw::c_char,
622 pub info: MOJOSHADER_symbolTypeInfo,
623}
624#[test]
625fn bindgen_test_layout_MOJOSHADER_symbolStructMember() {
626 assert_eq!(
627 ::std::mem::size_of::<MOJOSHADER_symbolStructMember>(),
628 40usize,
629 concat!("Size of: ", stringify!(MOJOSHADER_symbolStructMember))
630 );
631 assert_eq!(
632 ::std::mem::align_of::<MOJOSHADER_symbolStructMember>(),
633 8usize,
634 concat!("Alignment of ", stringify!(MOJOSHADER_symbolStructMember))
635 );
636 assert_eq!(
637 unsafe {
638 &(*(::std::ptr::null::<MOJOSHADER_symbolStructMember>())).name as *const _ as usize
639 },
640 0usize,
641 concat!(
642 "Offset of field: ",
643 stringify!(MOJOSHADER_symbolStructMember),
644 "::",
645 stringify!(name)
646 )
647 );
648 assert_eq!(
649 unsafe {
650 &(*(::std::ptr::null::<MOJOSHADER_symbolStructMember>())).info as *const _ as usize
651 },
652 8usize,
653 concat!(
654 "Offset of field: ",
655 stringify!(MOJOSHADER_symbolStructMember),
656 "::",
657 stringify!(info)
658 )
659 );
660}
661#[repr(C)]
662#[derive(Debug, Copy, Clone)]
663pub struct MOJOSHADER_symbol {
664 pub name: *const ::std::os::raw::c_char,
665 pub register_set: MOJOSHADER_symbolRegisterSet,
666 pub register_index: ::std::os::raw::c_uint,
667 pub register_count: ::std::os::raw::c_uint,
668 pub info: MOJOSHADER_symbolTypeInfo,
669}
670#[test]
671fn bindgen_test_layout_MOJOSHADER_symbol() {
672 assert_eq!(
673 ::std::mem::size_of::<MOJOSHADER_symbol>(),
674 56usize,
675 concat!("Size of: ", stringify!(MOJOSHADER_symbol))
676 );
677 assert_eq!(
678 ::std::mem::align_of::<MOJOSHADER_symbol>(),
679 8usize,
680 concat!("Alignment of ", stringify!(MOJOSHADER_symbol))
681 );
682 assert_eq!(
683 unsafe { &(*(::std::ptr::null::<MOJOSHADER_symbol>())).name as *const _ as usize },
684 0usize,
685 concat!(
686 "Offset of field: ",
687 stringify!(MOJOSHADER_symbol),
688 "::",
689 stringify!(name)
690 )
691 );
692 assert_eq!(
693 unsafe { &(*(::std::ptr::null::<MOJOSHADER_symbol>())).register_set as *const _ as usize },
694 8usize,
695 concat!(
696 "Offset of field: ",
697 stringify!(MOJOSHADER_symbol),
698 "::",
699 stringify!(register_set)
700 )
701 );
702 assert_eq!(
703 unsafe {
704 &(*(::std::ptr::null::<MOJOSHADER_symbol>())).register_index as *const _ as usize
705 },
706 12usize,
707 concat!(
708 "Offset of field: ",
709 stringify!(MOJOSHADER_symbol),
710 "::",
711 stringify!(register_index)
712 )
713 );
714 assert_eq!(
715 unsafe {
716 &(*(::std::ptr::null::<MOJOSHADER_symbol>())).register_count as *const _ as usize
717 },
718 16usize,
719 concat!(
720 "Offset of field: ",
721 stringify!(MOJOSHADER_symbol),
722 "::",
723 stringify!(register_count)
724 )
725 );
726 assert_eq!(
727 unsafe { &(*(::std::ptr::null::<MOJOSHADER_symbol>())).info as *const _ as usize },
728 24usize,
729 concat!(
730 "Offset of field: ",
731 stringify!(MOJOSHADER_symbol),
732 "::",
733 stringify!(info)
734 )
735 );
736}
737#[repr(C)]
738#[derive(Debug, Copy, Clone)]
739pub struct MOJOSHADER_error {
740 pub error: *const ::std::os::raw::c_char,
741 pub filename: *const ::std::os::raw::c_char,
742 pub error_position: ::std::os::raw::c_int,
743}
744#[test]
745fn bindgen_test_layout_MOJOSHADER_error() {
746 assert_eq!(
747 ::std::mem::size_of::<MOJOSHADER_error>(),
748 24usize,
749 concat!("Size of: ", stringify!(MOJOSHADER_error))
750 );
751 assert_eq!(
752 ::std::mem::align_of::<MOJOSHADER_error>(),
753 8usize,
754 concat!("Alignment of ", stringify!(MOJOSHADER_error))
755 );
756 assert_eq!(
757 unsafe { &(*(::std::ptr::null::<MOJOSHADER_error>())).error as *const _ as usize },
758 0usize,
759 concat!(
760 "Offset of field: ",
761 stringify!(MOJOSHADER_error),
762 "::",
763 stringify!(error)
764 )
765 );
766 assert_eq!(
767 unsafe { &(*(::std::ptr::null::<MOJOSHADER_error>())).filename as *const _ as usize },
768 8usize,
769 concat!(
770 "Offset of field: ",
771 stringify!(MOJOSHADER_error),
772 "::",
773 stringify!(filename)
774 )
775 );
776 assert_eq!(
777 unsafe { &(*(::std::ptr::null::<MOJOSHADER_error>())).error_position as *const _ as usize },
778 16usize,
779 concat!(
780 "Offset of field: ",
781 stringify!(MOJOSHADER_error),
782 "::",
783 stringify!(error_position)
784 )
785 );
786}
787pub const MOJOSHADER_preshaderOpcode_MOJOSHADER_PRESHADEROP_NOP: MOJOSHADER_preshaderOpcode = 0;
788pub const MOJOSHADER_preshaderOpcode_MOJOSHADER_PRESHADEROP_MOV: MOJOSHADER_preshaderOpcode = 1;
789pub const MOJOSHADER_preshaderOpcode_MOJOSHADER_PRESHADEROP_NEG: MOJOSHADER_preshaderOpcode = 2;
790pub const MOJOSHADER_preshaderOpcode_MOJOSHADER_PRESHADEROP_RCP: MOJOSHADER_preshaderOpcode = 3;
791pub const MOJOSHADER_preshaderOpcode_MOJOSHADER_PRESHADEROP_FRC: MOJOSHADER_preshaderOpcode = 4;
792pub const MOJOSHADER_preshaderOpcode_MOJOSHADER_PRESHADEROP_EXP: MOJOSHADER_preshaderOpcode = 5;
793pub const MOJOSHADER_preshaderOpcode_MOJOSHADER_PRESHADEROP_LOG: MOJOSHADER_preshaderOpcode = 6;
794pub const MOJOSHADER_preshaderOpcode_MOJOSHADER_PRESHADEROP_RSQ: MOJOSHADER_preshaderOpcode = 7;
795pub const MOJOSHADER_preshaderOpcode_MOJOSHADER_PRESHADEROP_SIN: MOJOSHADER_preshaderOpcode = 8;
796pub const MOJOSHADER_preshaderOpcode_MOJOSHADER_PRESHADEROP_COS: MOJOSHADER_preshaderOpcode = 9;
797pub const MOJOSHADER_preshaderOpcode_MOJOSHADER_PRESHADEROP_ASIN: MOJOSHADER_preshaderOpcode = 10;
798pub const MOJOSHADER_preshaderOpcode_MOJOSHADER_PRESHADEROP_ACOS: MOJOSHADER_preshaderOpcode = 11;
799pub const MOJOSHADER_preshaderOpcode_MOJOSHADER_PRESHADEROP_ATAN: MOJOSHADER_preshaderOpcode = 12;
800pub const MOJOSHADER_preshaderOpcode_MOJOSHADER_PRESHADEROP_MIN: MOJOSHADER_preshaderOpcode = 13;
801pub const MOJOSHADER_preshaderOpcode_MOJOSHADER_PRESHADEROP_MAX: MOJOSHADER_preshaderOpcode = 14;
802pub const MOJOSHADER_preshaderOpcode_MOJOSHADER_PRESHADEROP_LT: MOJOSHADER_preshaderOpcode = 15;
803pub const MOJOSHADER_preshaderOpcode_MOJOSHADER_PRESHADEROP_GE: MOJOSHADER_preshaderOpcode = 16;
804pub const MOJOSHADER_preshaderOpcode_MOJOSHADER_PRESHADEROP_ADD: MOJOSHADER_preshaderOpcode = 17;
805pub const MOJOSHADER_preshaderOpcode_MOJOSHADER_PRESHADEROP_MUL: MOJOSHADER_preshaderOpcode = 18;
806pub const MOJOSHADER_preshaderOpcode_MOJOSHADER_PRESHADEROP_ATAN2: MOJOSHADER_preshaderOpcode = 19;
807pub const MOJOSHADER_preshaderOpcode_MOJOSHADER_PRESHADEROP_DIV: MOJOSHADER_preshaderOpcode = 20;
808pub const MOJOSHADER_preshaderOpcode_MOJOSHADER_PRESHADEROP_CMP: MOJOSHADER_preshaderOpcode = 21;
809pub const MOJOSHADER_preshaderOpcode_MOJOSHADER_PRESHADEROP_MOVC: MOJOSHADER_preshaderOpcode = 22;
810pub const MOJOSHADER_preshaderOpcode_MOJOSHADER_PRESHADEROP_DOT: MOJOSHADER_preshaderOpcode = 23;
811pub const MOJOSHADER_preshaderOpcode_MOJOSHADER_PRESHADEROP_NOISE: MOJOSHADER_preshaderOpcode = 24;
812pub const MOJOSHADER_preshaderOpcode_MOJOSHADER_PRESHADEROP_SCALAR_OPS: MOJOSHADER_preshaderOpcode =
813 25;
814pub const MOJOSHADER_preshaderOpcode_MOJOSHADER_PRESHADEROP_MIN_SCALAR: MOJOSHADER_preshaderOpcode =
815 25;
816pub const MOJOSHADER_preshaderOpcode_MOJOSHADER_PRESHADEROP_MAX_SCALAR: MOJOSHADER_preshaderOpcode =
817 26;
818pub const MOJOSHADER_preshaderOpcode_MOJOSHADER_PRESHADEROP_LT_SCALAR: MOJOSHADER_preshaderOpcode =
819 27;
820pub const MOJOSHADER_preshaderOpcode_MOJOSHADER_PRESHADEROP_GE_SCALAR: MOJOSHADER_preshaderOpcode =
821 28;
822pub const MOJOSHADER_preshaderOpcode_MOJOSHADER_PRESHADEROP_ADD_SCALAR: MOJOSHADER_preshaderOpcode =
823 29;
824pub const MOJOSHADER_preshaderOpcode_MOJOSHADER_PRESHADEROP_MUL_SCALAR: MOJOSHADER_preshaderOpcode =
825 30;
826pub const MOJOSHADER_preshaderOpcode_MOJOSHADER_PRESHADEROP_ATAN2_SCALAR:
827 MOJOSHADER_preshaderOpcode = 31;
828pub const MOJOSHADER_preshaderOpcode_MOJOSHADER_PRESHADEROP_DIV_SCALAR: MOJOSHADER_preshaderOpcode =
829 32;
830pub const MOJOSHADER_preshaderOpcode_MOJOSHADER_PRESHADEROP_DOT_SCALAR: MOJOSHADER_preshaderOpcode =
831 33;
832pub const MOJOSHADER_preshaderOpcode_MOJOSHADER_PRESHADEROP_NOISE_SCALAR:
833 MOJOSHADER_preshaderOpcode = 34;
834pub type MOJOSHADER_preshaderOpcode = ::std::os::raw::c_uint;
835pub const MOJOSHADER_preshaderOperandType_MOJOSHADER_PRESHADEROPERAND_INPUT:
836 MOJOSHADER_preshaderOperandType = 0;
837pub const MOJOSHADER_preshaderOperandType_MOJOSHADER_PRESHADEROPERAND_OUTPUT:
838 MOJOSHADER_preshaderOperandType = 1;
839pub const MOJOSHADER_preshaderOperandType_MOJOSHADER_PRESHADEROPERAND_LITERAL:
840 MOJOSHADER_preshaderOperandType = 2;
841pub const MOJOSHADER_preshaderOperandType_MOJOSHADER_PRESHADEROPERAND_TEMP:
842 MOJOSHADER_preshaderOperandType = 3;
843pub type MOJOSHADER_preshaderOperandType = ::std::os::raw::c_uint;
844#[repr(C)]
845#[derive(Debug, Copy, Clone)]
846pub struct MOJOSHADER_preshaderOperand {
847 pub type_: MOJOSHADER_preshaderOperandType,
848 pub index: ::std::os::raw::c_uint,
849 pub array_register_count: ::std::os::raw::c_uint,
850 pub array_registers: *mut ::std::os::raw::c_uint,
851}
852#[test]
853fn bindgen_test_layout_MOJOSHADER_preshaderOperand() {
854 assert_eq!(
855 ::std::mem::size_of::<MOJOSHADER_preshaderOperand>(),
856 24usize,
857 concat!("Size of: ", stringify!(MOJOSHADER_preshaderOperand))
858 );
859 assert_eq!(
860 ::std::mem::align_of::<MOJOSHADER_preshaderOperand>(),
861 8usize,
862 concat!("Alignment of ", stringify!(MOJOSHADER_preshaderOperand))
863 );
864 assert_eq!(
865 unsafe {
866 &(*(::std::ptr::null::<MOJOSHADER_preshaderOperand>())).type_ as *const _ as usize
867 },
868 0usize,
869 concat!(
870 "Offset of field: ",
871 stringify!(MOJOSHADER_preshaderOperand),
872 "::",
873 stringify!(type_)
874 )
875 );
876 assert_eq!(
877 unsafe {
878 &(*(::std::ptr::null::<MOJOSHADER_preshaderOperand>())).index as *const _ as usize
879 },
880 4usize,
881 concat!(
882 "Offset of field: ",
883 stringify!(MOJOSHADER_preshaderOperand),
884 "::",
885 stringify!(index)
886 )
887 );
888 assert_eq!(
889 unsafe {
890 &(*(::std::ptr::null::<MOJOSHADER_preshaderOperand>())).array_register_count as *const _
891 as usize
892 },
893 8usize,
894 concat!(
895 "Offset of field: ",
896 stringify!(MOJOSHADER_preshaderOperand),
897 "::",
898 stringify!(array_register_count)
899 )
900 );
901 assert_eq!(
902 unsafe {
903 &(*(::std::ptr::null::<MOJOSHADER_preshaderOperand>())).array_registers as *const _
904 as usize
905 },
906 16usize,
907 concat!(
908 "Offset of field: ",
909 stringify!(MOJOSHADER_preshaderOperand),
910 "::",
911 stringify!(array_registers)
912 )
913 );
914}
915#[repr(C)]
916#[derive(Debug, Copy, Clone)]
917pub struct MOJOSHADER_preshaderInstruction {
918 pub opcode: MOJOSHADER_preshaderOpcode,
919 pub element_count: ::std::os::raw::c_uint,
920 pub operand_count: ::std::os::raw::c_uint,
921 pub operands: [MOJOSHADER_preshaderOperand; 4usize],
922}
923#[test]
924fn bindgen_test_layout_MOJOSHADER_preshaderInstruction() {
925 assert_eq!(
926 ::std::mem::size_of::<MOJOSHADER_preshaderInstruction>(),
927 112usize,
928 concat!("Size of: ", stringify!(MOJOSHADER_preshaderInstruction))
929 );
930 assert_eq!(
931 ::std::mem::align_of::<MOJOSHADER_preshaderInstruction>(),
932 8usize,
933 concat!("Alignment of ", stringify!(MOJOSHADER_preshaderInstruction))
934 );
935 assert_eq!(
936 unsafe {
937 &(*(::std::ptr::null::<MOJOSHADER_preshaderInstruction>())).opcode as *const _ as usize
938 },
939 0usize,
940 concat!(
941 "Offset of field: ",
942 stringify!(MOJOSHADER_preshaderInstruction),
943 "::",
944 stringify!(opcode)
945 )
946 );
947 assert_eq!(
948 unsafe {
949 &(*(::std::ptr::null::<MOJOSHADER_preshaderInstruction>())).element_count as *const _
950 as usize
951 },
952 4usize,
953 concat!(
954 "Offset of field: ",
955 stringify!(MOJOSHADER_preshaderInstruction),
956 "::",
957 stringify!(element_count)
958 )
959 );
960 assert_eq!(
961 unsafe {
962 &(*(::std::ptr::null::<MOJOSHADER_preshaderInstruction>())).operand_count as *const _
963 as usize
964 },
965 8usize,
966 concat!(
967 "Offset of field: ",
968 stringify!(MOJOSHADER_preshaderInstruction),
969 "::",
970 stringify!(operand_count)
971 )
972 );
973 assert_eq!(
974 unsafe {
975 &(*(::std::ptr::null::<MOJOSHADER_preshaderInstruction>())).operands as *const _
976 as usize
977 },
978 16usize,
979 concat!(
980 "Offset of field: ",
981 stringify!(MOJOSHADER_preshaderInstruction),
982 "::",
983 stringify!(operands)
984 )
985 );
986}
987#[repr(C)]
988#[derive(Debug, Copy, Clone)]
989pub struct MOJOSHADER_preshader {
990 pub literal_count: ::std::os::raw::c_uint,
991 pub literals: *mut f64,
992 pub temp_count: ::std::os::raw::c_uint,
993 pub symbol_count: ::std::os::raw::c_uint,
994 pub symbols: *mut MOJOSHADER_symbol,
995 pub instruction_count: ::std::os::raw::c_uint,
996 pub instructions: *mut MOJOSHADER_preshaderInstruction,
997 pub register_count: ::std::os::raw::c_uint,
998 pub registers: *mut f32,
999 pub malloc: MOJOSHADER_malloc,
1000 pub free: MOJOSHADER_free,
1001 pub malloc_data: *mut ::std::os::raw::c_void,
1002}
1003#[test]
1004fn bindgen_test_layout_MOJOSHADER_preshader() {
1005 assert_eq!(
1006 ::std::mem::size_of::<MOJOSHADER_preshader>(),
1007 88usize,
1008 concat!("Size of: ", stringify!(MOJOSHADER_preshader))
1009 );
1010 assert_eq!(
1011 ::std::mem::align_of::<MOJOSHADER_preshader>(),
1012 8usize,
1013 concat!("Alignment of ", stringify!(MOJOSHADER_preshader))
1014 );
1015 assert_eq!(
1016 unsafe {
1017 &(*(::std::ptr::null::<MOJOSHADER_preshader>())).literal_count as *const _ as usize
1018 },
1019 0usize,
1020 concat!(
1021 "Offset of field: ",
1022 stringify!(MOJOSHADER_preshader),
1023 "::",
1024 stringify!(literal_count)
1025 )
1026 );
1027 assert_eq!(
1028 unsafe { &(*(::std::ptr::null::<MOJOSHADER_preshader>())).literals as *const _ as usize },
1029 8usize,
1030 concat!(
1031 "Offset of field: ",
1032 stringify!(MOJOSHADER_preshader),
1033 "::",
1034 stringify!(literals)
1035 )
1036 );
1037 assert_eq!(
1038 unsafe { &(*(::std::ptr::null::<MOJOSHADER_preshader>())).temp_count as *const _ as usize },
1039 16usize,
1040 concat!(
1041 "Offset of field: ",
1042 stringify!(MOJOSHADER_preshader),
1043 "::",
1044 stringify!(temp_count)
1045 )
1046 );
1047 assert_eq!(
1048 unsafe {
1049 &(*(::std::ptr::null::<MOJOSHADER_preshader>())).symbol_count as *const _ as usize
1050 },
1051 20usize,
1052 concat!(
1053 "Offset of field: ",
1054 stringify!(MOJOSHADER_preshader),
1055 "::",
1056 stringify!(symbol_count)
1057 )
1058 );
1059 assert_eq!(
1060 unsafe { &(*(::std::ptr::null::<MOJOSHADER_preshader>())).symbols as *const _ as usize },
1061 24usize,
1062 concat!(
1063 "Offset of field: ",
1064 stringify!(MOJOSHADER_preshader),
1065 "::",
1066 stringify!(symbols)
1067 )
1068 );
1069 assert_eq!(
1070 unsafe {
1071 &(*(::std::ptr::null::<MOJOSHADER_preshader>())).instruction_count as *const _ as usize
1072 },
1073 32usize,
1074 concat!(
1075 "Offset of field: ",
1076 stringify!(MOJOSHADER_preshader),
1077 "::",
1078 stringify!(instruction_count)
1079 )
1080 );
1081 assert_eq!(
1082 unsafe {
1083 &(*(::std::ptr::null::<MOJOSHADER_preshader>())).instructions as *const _ as usize
1084 },
1085 40usize,
1086 concat!(
1087 "Offset of field: ",
1088 stringify!(MOJOSHADER_preshader),
1089 "::",
1090 stringify!(instructions)
1091 )
1092 );
1093 assert_eq!(
1094 unsafe {
1095 &(*(::std::ptr::null::<MOJOSHADER_preshader>())).register_count as *const _ as usize
1096 },
1097 48usize,
1098 concat!(
1099 "Offset of field: ",
1100 stringify!(MOJOSHADER_preshader),
1101 "::",
1102 stringify!(register_count)
1103 )
1104 );
1105 assert_eq!(
1106 unsafe { &(*(::std::ptr::null::<MOJOSHADER_preshader>())).registers as *const _ as usize },
1107 56usize,
1108 concat!(
1109 "Offset of field: ",
1110 stringify!(MOJOSHADER_preshader),
1111 "::",
1112 stringify!(registers)
1113 )
1114 );
1115 assert_eq!(
1116 unsafe { &(*(::std::ptr::null::<MOJOSHADER_preshader>())).malloc as *const _ as usize },
1117 64usize,
1118 concat!(
1119 "Offset of field: ",
1120 stringify!(MOJOSHADER_preshader),
1121 "::",
1122 stringify!(malloc)
1123 )
1124 );
1125 assert_eq!(
1126 unsafe { &(*(::std::ptr::null::<MOJOSHADER_preshader>())).free as *const _ as usize },
1127 72usize,
1128 concat!(
1129 "Offset of field: ",
1130 stringify!(MOJOSHADER_preshader),
1131 "::",
1132 stringify!(free)
1133 )
1134 );
1135 assert_eq!(
1136 unsafe {
1137 &(*(::std::ptr::null::<MOJOSHADER_preshader>())).malloc_data as *const _ as usize
1138 },
1139 80usize,
1140 concat!(
1141 "Offset of field: ",
1142 stringify!(MOJOSHADER_preshader),
1143 "::",
1144 stringify!(malloc_data)
1145 )
1146 );
1147}
1148#[repr(C)]
1149#[derive(Debug, Copy, Clone)]
1150pub struct MOJOSHADER_parseData {
1151 pub error_count: ::std::os::raw::c_int,
1152 pub errors: *mut MOJOSHADER_error,
1153 pub profile: *const ::std::os::raw::c_char,
1154 pub output: *const ::std::os::raw::c_char,
1155 pub output_len: ::std::os::raw::c_int,
1156 pub instruction_count: ::std::os::raw::c_int,
1157 pub shader_type: MOJOSHADER_shaderType,
1158 pub major_ver: ::std::os::raw::c_int,
1159 pub minor_ver: ::std::os::raw::c_int,
1160 pub mainfn: *const ::std::os::raw::c_char,
1161 pub uniform_count: ::std::os::raw::c_int,
1162 pub uniforms: *mut MOJOSHADER_uniform,
1163 pub constant_count: ::std::os::raw::c_int,
1164 pub constants: *mut MOJOSHADER_constant,
1165 pub sampler_count: ::std::os::raw::c_int,
1166 pub samplers: *mut MOJOSHADER_sampler,
1167 pub attribute_count: ::std::os::raw::c_int,
1168 pub attributes: *mut MOJOSHADER_attribute,
1169 pub output_count: ::std::os::raw::c_int,
1170 pub outputs: *mut MOJOSHADER_attribute,
1171 pub swizzle_count: ::std::os::raw::c_int,
1172 pub swizzles: *mut MOJOSHADER_swizzle,
1173 pub symbol_count: ::std::os::raw::c_int,
1174 pub symbols: *mut MOJOSHADER_symbol,
1175 pub preshader: *mut MOJOSHADER_preshader,
1176 pub malloc: MOJOSHADER_malloc,
1177 pub free: MOJOSHADER_free,
1178 pub malloc_data: *mut ::std::os::raw::c_void,
1179}
1180#[test]
1181fn bindgen_test_layout_MOJOSHADER_parseData() {
1182 assert_eq!(
1183 ::std::mem::size_of::<MOJOSHADER_parseData>(),
1184 208usize,
1185 concat!("Size of: ", stringify!(MOJOSHADER_parseData))
1186 );
1187 assert_eq!(
1188 ::std::mem::align_of::<MOJOSHADER_parseData>(),
1189 8usize,
1190 concat!("Alignment of ", stringify!(MOJOSHADER_parseData))
1191 );
1192 assert_eq!(
1193 unsafe {
1194 &(*(::std::ptr::null::<MOJOSHADER_parseData>())).error_count as *const _ as usize
1195 },
1196 0usize,
1197 concat!(
1198 "Offset of field: ",
1199 stringify!(MOJOSHADER_parseData),
1200 "::",
1201 stringify!(error_count)
1202 )
1203 );
1204 assert_eq!(
1205 unsafe { &(*(::std::ptr::null::<MOJOSHADER_parseData>())).errors as *const _ as usize },
1206 8usize,
1207 concat!(
1208 "Offset of field: ",
1209 stringify!(MOJOSHADER_parseData),
1210 "::",
1211 stringify!(errors)
1212 )
1213 );
1214 assert_eq!(
1215 unsafe { &(*(::std::ptr::null::<MOJOSHADER_parseData>())).profile as *const _ as usize },
1216 16usize,
1217 concat!(
1218 "Offset of field: ",
1219 stringify!(MOJOSHADER_parseData),
1220 "::",
1221 stringify!(profile)
1222 )
1223 );
1224 assert_eq!(
1225 unsafe { &(*(::std::ptr::null::<MOJOSHADER_parseData>())).output as *const _ as usize },
1226 24usize,
1227 concat!(
1228 "Offset of field: ",
1229 stringify!(MOJOSHADER_parseData),
1230 "::",
1231 stringify!(output)
1232 )
1233 );
1234 assert_eq!(
1235 unsafe { &(*(::std::ptr::null::<MOJOSHADER_parseData>())).output_len as *const _ as usize },
1236 32usize,
1237 concat!(
1238 "Offset of field: ",
1239 stringify!(MOJOSHADER_parseData),
1240 "::",
1241 stringify!(output_len)
1242 )
1243 );
1244 assert_eq!(
1245 unsafe {
1246 &(*(::std::ptr::null::<MOJOSHADER_parseData>())).instruction_count as *const _ as usize
1247 },
1248 36usize,
1249 concat!(
1250 "Offset of field: ",
1251 stringify!(MOJOSHADER_parseData),
1252 "::",
1253 stringify!(instruction_count)
1254 )
1255 );
1256 assert_eq!(
1257 unsafe {
1258 &(*(::std::ptr::null::<MOJOSHADER_parseData>())).shader_type as *const _ as usize
1259 },
1260 40usize,
1261 concat!(
1262 "Offset of field: ",
1263 stringify!(MOJOSHADER_parseData),
1264 "::",
1265 stringify!(shader_type)
1266 )
1267 );
1268 assert_eq!(
1269 unsafe { &(*(::std::ptr::null::<MOJOSHADER_parseData>())).major_ver as *const _ as usize },
1270 44usize,
1271 concat!(
1272 "Offset of field: ",
1273 stringify!(MOJOSHADER_parseData),
1274 "::",
1275 stringify!(major_ver)
1276 )
1277 );
1278 assert_eq!(
1279 unsafe { &(*(::std::ptr::null::<MOJOSHADER_parseData>())).minor_ver as *const _ as usize },
1280 48usize,
1281 concat!(
1282 "Offset of field: ",
1283 stringify!(MOJOSHADER_parseData),
1284 "::",
1285 stringify!(minor_ver)
1286 )
1287 );
1288 assert_eq!(
1289 unsafe { &(*(::std::ptr::null::<MOJOSHADER_parseData>())).mainfn as *const _ as usize },
1290 56usize,
1291 concat!(
1292 "Offset of field: ",
1293 stringify!(MOJOSHADER_parseData),
1294 "::",
1295 stringify!(mainfn)
1296 )
1297 );
1298 assert_eq!(
1299 unsafe {
1300 &(*(::std::ptr::null::<MOJOSHADER_parseData>())).uniform_count as *const _ as usize
1301 },
1302 64usize,
1303 concat!(
1304 "Offset of field: ",
1305 stringify!(MOJOSHADER_parseData),
1306 "::",
1307 stringify!(uniform_count)
1308 )
1309 );
1310 assert_eq!(
1311 unsafe { &(*(::std::ptr::null::<MOJOSHADER_parseData>())).uniforms as *const _ as usize },
1312 72usize,
1313 concat!(
1314 "Offset of field: ",
1315 stringify!(MOJOSHADER_parseData),
1316 "::",
1317 stringify!(uniforms)
1318 )
1319 );
1320 assert_eq!(
1321 unsafe {
1322 &(*(::std::ptr::null::<MOJOSHADER_parseData>())).constant_count as *const _ as usize
1323 },
1324 80usize,
1325 concat!(
1326 "Offset of field: ",
1327 stringify!(MOJOSHADER_parseData),
1328 "::",
1329 stringify!(constant_count)
1330 )
1331 );
1332 assert_eq!(
1333 unsafe { &(*(::std::ptr::null::<MOJOSHADER_parseData>())).constants as *const _ as usize },
1334 88usize,
1335 concat!(
1336 "Offset of field: ",
1337 stringify!(MOJOSHADER_parseData),
1338 "::",
1339 stringify!(constants)
1340 )
1341 );
1342 assert_eq!(
1343 unsafe {
1344 &(*(::std::ptr::null::<MOJOSHADER_parseData>())).sampler_count as *const _ as usize
1345 },
1346 96usize,
1347 concat!(
1348 "Offset of field: ",
1349 stringify!(MOJOSHADER_parseData),
1350 "::",
1351 stringify!(sampler_count)
1352 )
1353 );
1354 assert_eq!(
1355 unsafe { &(*(::std::ptr::null::<MOJOSHADER_parseData>())).samplers as *const _ as usize },
1356 104usize,
1357 concat!(
1358 "Offset of field: ",
1359 stringify!(MOJOSHADER_parseData),
1360 "::",
1361 stringify!(samplers)
1362 )
1363 );
1364 assert_eq!(
1365 unsafe {
1366 &(*(::std::ptr::null::<MOJOSHADER_parseData>())).attribute_count as *const _ as usize
1367 },
1368 112usize,
1369 concat!(
1370 "Offset of field: ",
1371 stringify!(MOJOSHADER_parseData),
1372 "::",
1373 stringify!(attribute_count)
1374 )
1375 );
1376 assert_eq!(
1377 unsafe { &(*(::std::ptr::null::<MOJOSHADER_parseData>())).attributes as *const _ as usize },
1378 120usize,
1379 concat!(
1380 "Offset of field: ",
1381 stringify!(MOJOSHADER_parseData),
1382 "::",
1383 stringify!(attributes)
1384 )
1385 );
1386 assert_eq!(
1387 unsafe {
1388 &(*(::std::ptr::null::<MOJOSHADER_parseData>())).output_count as *const _ as usize
1389 },
1390 128usize,
1391 concat!(
1392 "Offset of field: ",
1393 stringify!(MOJOSHADER_parseData),
1394 "::",
1395 stringify!(output_count)
1396 )
1397 );
1398 assert_eq!(
1399 unsafe { &(*(::std::ptr::null::<MOJOSHADER_parseData>())).outputs as *const _ as usize },
1400 136usize,
1401 concat!(
1402 "Offset of field: ",
1403 stringify!(MOJOSHADER_parseData),
1404 "::",
1405 stringify!(outputs)
1406 )
1407 );
1408 assert_eq!(
1409 unsafe {
1410 &(*(::std::ptr::null::<MOJOSHADER_parseData>())).swizzle_count as *const _ as usize
1411 },
1412 144usize,
1413 concat!(
1414 "Offset of field: ",
1415 stringify!(MOJOSHADER_parseData),
1416 "::",
1417 stringify!(swizzle_count)
1418 )
1419 );
1420 assert_eq!(
1421 unsafe { &(*(::std::ptr::null::<MOJOSHADER_parseData>())).swizzles as *const _ as usize },
1422 152usize,
1423 concat!(
1424 "Offset of field: ",
1425 stringify!(MOJOSHADER_parseData),
1426 "::",
1427 stringify!(swizzles)
1428 )
1429 );
1430 assert_eq!(
1431 unsafe {
1432 &(*(::std::ptr::null::<MOJOSHADER_parseData>())).symbol_count as *const _ as usize
1433 },
1434 160usize,
1435 concat!(
1436 "Offset of field: ",
1437 stringify!(MOJOSHADER_parseData),
1438 "::",
1439 stringify!(symbol_count)
1440 )
1441 );
1442 assert_eq!(
1443 unsafe { &(*(::std::ptr::null::<MOJOSHADER_parseData>())).symbols as *const _ as usize },
1444 168usize,
1445 concat!(
1446 "Offset of field: ",
1447 stringify!(MOJOSHADER_parseData),
1448 "::",
1449 stringify!(symbols)
1450 )
1451 );
1452 assert_eq!(
1453 unsafe { &(*(::std::ptr::null::<MOJOSHADER_parseData>())).preshader as *const _ as usize },
1454 176usize,
1455 concat!(
1456 "Offset of field: ",
1457 stringify!(MOJOSHADER_parseData),
1458 "::",
1459 stringify!(preshader)
1460 )
1461 );
1462 assert_eq!(
1463 unsafe { &(*(::std::ptr::null::<MOJOSHADER_parseData>())).malloc as *const _ as usize },
1464 184usize,
1465 concat!(
1466 "Offset of field: ",
1467 stringify!(MOJOSHADER_parseData),
1468 "::",
1469 stringify!(malloc)
1470 )
1471 );
1472 assert_eq!(
1473 unsafe { &(*(::std::ptr::null::<MOJOSHADER_parseData>())).free as *const _ as usize },
1474 192usize,
1475 concat!(
1476 "Offset of field: ",
1477 stringify!(MOJOSHADER_parseData),
1478 "::",
1479 stringify!(free)
1480 )
1481 );
1482 assert_eq!(
1483 unsafe {
1484 &(*(::std::ptr::null::<MOJOSHADER_parseData>())).malloc_data as *const _ as usize
1485 },
1486 200usize,
1487 concat!(
1488 "Offset of field: ",
1489 stringify!(MOJOSHADER_parseData),
1490 "::",
1491 stringify!(malloc_data)
1492 )
1493 );
1494}
1495extern "C" {
1496 pub fn MOJOSHADER_maxShaderModel(
1497 profile: *const ::std::os::raw::c_char,
1498 ) -> ::std::os::raw::c_int;
1499}
1500extern "C" {
1501 pub fn MOJOSHADER_parse(
1502 profile: *const ::std::os::raw::c_char,
1503 mainfn: *const ::std::os::raw::c_char,
1504 tokenbuf: *const ::std::os::raw::c_uchar,
1505 bufsize: ::std::os::raw::c_uint,
1506 swiz: *const MOJOSHADER_swizzle,
1507 swizcount: ::std::os::raw::c_uint,
1508 smap: *const MOJOSHADER_samplerMap,
1509 smapcount: ::std::os::raw::c_uint,
1510 m: MOJOSHADER_malloc,
1511 f: MOJOSHADER_free,
1512 d: *mut ::std::os::raw::c_void,
1513 ) -> *const MOJOSHADER_parseData;
1514}
1515extern "C" {
1516 pub fn MOJOSHADER_freeParseData(data: *const MOJOSHADER_parseData);
1517}
1518extern "C" {
1519 pub fn MOJOSHADER_parsePreshader(
1520 buf: *const ::std::os::raw::c_uchar,
1521 len: ::std::os::raw::c_uint,
1522 m: MOJOSHADER_malloc,
1523 f: MOJOSHADER_free,
1524 d: *mut ::std::os::raw::c_void,
1525 ) -> *const MOJOSHADER_preshader;
1526}
1527extern "C" {
1528 pub fn MOJOSHADER_freePreshader(preshader: *const MOJOSHADER_preshader);
1529}
1530#[repr(C)]
1531#[derive(Debug, Copy, Clone)]
1532pub struct MOJOSHADER_preprocessorDefine {
1533 pub identifier: *const ::std::os::raw::c_char,
1534 pub definition: *const ::std::os::raw::c_char,
1535}
1536#[test]
1537fn bindgen_test_layout_MOJOSHADER_preprocessorDefine() {
1538 assert_eq!(
1539 ::std::mem::size_of::<MOJOSHADER_preprocessorDefine>(),
1540 16usize,
1541 concat!("Size of: ", stringify!(MOJOSHADER_preprocessorDefine))
1542 );
1543 assert_eq!(
1544 ::std::mem::align_of::<MOJOSHADER_preprocessorDefine>(),
1545 8usize,
1546 concat!("Alignment of ", stringify!(MOJOSHADER_preprocessorDefine))
1547 );
1548 assert_eq!(
1549 unsafe {
1550 &(*(::std::ptr::null::<MOJOSHADER_preprocessorDefine>())).identifier as *const _
1551 as usize
1552 },
1553 0usize,
1554 concat!(
1555 "Offset of field: ",
1556 stringify!(MOJOSHADER_preprocessorDefine),
1557 "::",
1558 stringify!(identifier)
1559 )
1560 );
1561 assert_eq!(
1562 unsafe {
1563 &(*(::std::ptr::null::<MOJOSHADER_preprocessorDefine>())).definition as *const _
1564 as usize
1565 },
1566 8usize,
1567 concat!(
1568 "Offset of field: ",
1569 stringify!(MOJOSHADER_preprocessorDefine),
1570 "::",
1571 stringify!(definition)
1572 )
1573 );
1574}
1575pub const MOJOSHADER_includeType_MOJOSHADER_INCLUDETYPE_LOCAL: MOJOSHADER_includeType = 0;
1576pub const MOJOSHADER_includeType_MOJOSHADER_INCLUDETYPE_SYSTEM: MOJOSHADER_includeType = 1;
1577pub type MOJOSHADER_includeType = ::std::os::raw::c_uint;
1578#[repr(C)]
1579#[derive(Debug, Copy, Clone)]
1580pub struct MOJOSHADER_preprocessData {
1581 pub error_count: ::std::os::raw::c_int,
1582 pub errors: *mut MOJOSHADER_error,
1583 pub output: *const ::std::os::raw::c_char,
1584 pub output_len: ::std::os::raw::c_int,
1585 pub malloc: MOJOSHADER_malloc,
1586 pub free: MOJOSHADER_free,
1587 pub malloc_data: *mut ::std::os::raw::c_void,
1588}
1589#[test]
1590fn bindgen_test_layout_MOJOSHADER_preprocessData() {
1591 assert_eq!(
1592 ::std::mem::size_of::<MOJOSHADER_preprocessData>(),
1593 56usize,
1594 concat!("Size of: ", stringify!(MOJOSHADER_preprocessData))
1595 );
1596 assert_eq!(
1597 ::std::mem::align_of::<MOJOSHADER_preprocessData>(),
1598 8usize,
1599 concat!("Alignment of ", stringify!(MOJOSHADER_preprocessData))
1600 );
1601 assert_eq!(
1602 unsafe {
1603 &(*(::std::ptr::null::<MOJOSHADER_preprocessData>())).error_count as *const _ as usize
1604 },
1605 0usize,
1606 concat!(
1607 "Offset of field: ",
1608 stringify!(MOJOSHADER_preprocessData),
1609 "::",
1610 stringify!(error_count)
1611 )
1612 );
1613 assert_eq!(
1614 unsafe {
1615 &(*(::std::ptr::null::<MOJOSHADER_preprocessData>())).errors as *const _ as usize
1616 },
1617 8usize,
1618 concat!(
1619 "Offset of field: ",
1620 stringify!(MOJOSHADER_preprocessData),
1621 "::",
1622 stringify!(errors)
1623 )
1624 );
1625 assert_eq!(
1626 unsafe {
1627 &(*(::std::ptr::null::<MOJOSHADER_preprocessData>())).output as *const _ as usize
1628 },
1629 16usize,
1630 concat!(
1631 "Offset of field: ",
1632 stringify!(MOJOSHADER_preprocessData),
1633 "::",
1634 stringify!(output)
1635 )
1636 );
1637 assert_eq!(
1638 unsafe {
1639 &(*(::std::ptr::null::<MOJOSHADER_preprocessData>())).output_len as *const _ as usize
1640 },
1641 24usize,
1642 concat!(
1643 "Offset of field: ",
1644 stringify!(MOJOSHADER_preprocessData),
1645 "::",
1646 stringify!(output_len)
1647 )
1648 );
1649 assert_eq!(
1650 unsafe {
1651 &(*(::std::ptr::null::<MOJOSHADER_preprocessData>())).malloc as *const _ as usize
1652 },
1653 32usize,
1654 concat!(
1655 "Offset of field: ",
1656 stringify!(MOJOSHADER_preprocessData),
1657 "::",
1658 stringify!(malloc)
1659 )
1660 );
1661 assert_eq!(
1662 unsafe { &(*(::std::ptr::null::<MOJOSHADER_preprocessData>())).free as *const _ as usize },
1663 40usize,
1664 concat!(
1665 "Offset of field: ",
1666 stringify!(MOJOSHADER_preprocessData),
1667 "::",
1668 stringify!(free)
1669 )
1670 );
1671 assert_eq!(
1672 unsafe {
1673 &(*(::std::ptr::null::<MOJOSHADER_preprocessData>())).malloc_data as *const _ as usize
1674 },
1675 48usize,
1676 concat!(
1677 "Offset of field: ",
1678 stringify!(MOJOSHADER_preprocessData),
1679 "::",
1680 stringify!(malloc_data)
1681 )
1682 );
1683}
1684pub type MOJOSHADER_includeOpen = ::std::option::Option<
1685 unsafe extern "C" fn(
1686 inctype: MOJOSHADER_includeType,
1687 fname: *const ::std::os::raw::c_char,
1688 parent: *const ::std::os::raw::c_char,
1689 outdata: *mut *const ::std::os::raw::c_char,
1690 outbytes: *mut ::std::os::raw::c_uint,
1691 m: MOJOSHADER_malloc,
1692 f: MOJOSHADER_free,
1693 d: *mut ::std::os::raw::c_void,
1694 ) -> ::std::os::raw::c_int,
1695>;
1696pub type MOJOSHADER_includeClose = ::std::option::Option<
1697 unsafe extern "C" fn(
1698 data: *const ::std::os::raw::c_char,
1699 m: MOJOSHADER_malloc,
1700 f: MOJOSHADER_free,
1701 d: *mut ::std::os::raw::c_void,
1702 ),
1703>;
1704extern "C" {
1705 pub fn MOJOSHADER_preprocess(
1706 filename: *const ::std::os::raw::c_char,
1707 source: *const ::std::os::raw::c_char,
1708 sourcelen: ::std::os::raw::c_uint,
1709 defines: *const MOJOSHADER_preprocessorDefine,
1710 define_count: ::std::os::raw::c_uint,
1711 include_open: MOJOSHADER_includeOpen,
1712 include_close: MOJOSHADER_includeClose,
1713 m: MOJOSHADER_malloc,
1714 f: MOJOSHADER_free,
1715 d: *mut ::std::os::raw::c_void,
1716 ) -> *const MOJOSHADER_preprocessData;
1717}
1718extern "C" {
1719 pub fn MOJOSHADER_freePreprocessData(data: *const MOJOSHADER_preprocessData);
1720}
1721extern "C" {
1722 pub fn MOJOSHADER_assemble(
1723 filename: *const ::std::os::raw::c_char,
1724 source: *const ::std::os::raw::c_char,
1725 sourcelen: ::std::os::raw::c_uint,
1726 comments: *mut *const ::std::os::raw::c_char,
1727 comment_count: ::std::os::raw::c_uint,
1728 symbols: *const MOJOSHADER_symbol,
1729 symbol_count: ::std::os::raw::c_uint,
1730 defines: *const MOJOSHADER_preprocessorDefine,
1731 define_count: ::std::os::raw::c_uint,
1732 include_open: MOJOSHADER_includeOpen,
1733 include_close: MOJOSHADER_includeClose,
1734 m: MOJOSHADER_malloc,
1735 f: MOJOSHADER_free,
1736 d: *mut ::std::os::raw::c_void,
1737 ) -> *const MOJOSHADER_parseData;
1738}
1739pub const MOJOSHADER_astDataTypeType_MOJOSHADER_AST_DATATYPE_NONE: MOJOSHADER_astDataTypeType = 0;
1740pub const MOJOSHADER_astDataTypeType_MOJOSHADER_AST_DATATYPE_BOOL: MOJOSHADER_astDataTypeType = 1;
1741pub const MOJOSHADER_astDataTypeType_MOJOSHADER_AST_DATATYPE_INT: MOJOSHADER_astDataTypeType = 2;
1742pub const MOJOSHADER_astDataTypeType_MOJOSHADER_AST_DATATYPE_UINT: MOJOSHADER_astDataTypeType = 3;
1743pub const MOJOSHADER_astDataTypeType_MOJOSHADER_AST_DATATYPE_FLOAT: MOJOSHADER_astDataTypeType = 4;
1744pub const MOJOSHADER_astDataTypeType_MOJOSHADER_AST_DATATYPE_FLOAT_SNORM:
1745 MOJOSHADER_astDataTypeType = 5;
1746pub const MOJOSHADER_astDataTypeType_MOJOSHADER_AST_DATATYPE_FLOAT_UNORM:
1747 MOJOSHADER_astDataTypeType = 6;
1748pub const MOJOSHADER_astDataTypeType_MOJOSHADER_AST_DATATYPE_HALF: MOJOSHADER_astDataTypeType = 7;
1749pub const MOJOSHADER_astDataTypeType_MOJOSHADER_AST_DATATYPE_DOUBLE: MOJOSHADER_astDataTypeType = 8;
1750pub const MOJOSHADER_astDataTypeType_MOJOSHADER_AST_DATATYPE_STRING: MOJOSHADER_astDataTypeType = 9;
1751pub const MOJOSHADER_astDataTypeType_MOJOSHADER_AST_DATATYPE_SAMPLER_1D:
1752 MOJOSHADER_astDataTypeType = 10;
1753pub const MOJOSHADER_astDataTypeType_MOJOSHADER_AST_DATATYPE_SAMPLER_2D:
1754 MOJOSHADER_astDataTypeType = 11;
1755pub const MOJOSHADER_astDataTypeType_MOJOSHADER_AST_DATATYPE_SAMPLER_3D:
1756 MOJOSHADER_astDataTypeType = 12;
1757pub const MOJOSHADER_astDataTypeType_MOJOSHADER_AST_DATATYPE_SAMPLER_CUBE:
1758 MOJOSHADER_astDataTypeType = 13;
1759pub const MOJOSHADER_astDataTypeType_MOJOSHADER_AST_DATATYPE_SAMPLER_STATE:
1760 MOJOSHADER_astDataTypeType = 14;
1761pub const MOJOSHADER_astDataTypeType_MOJOSHADER_AST_DATATYPE_SAMPLER_COMPARISON_STATE:
1762 MOJOSHADER_astDataTypeType = 15;
1763pub const MOJOSHADER_astDataTypeType_MOJOSHADER_AST_DATATYPE_STRUCT: MOJOSHADER_astDataTypeType =
1764 16;
1765pub const MOJOSHADER_astDataTypeType_MOJOSHADER_AST_DATATYPE_ARRAY: MOJOSHADER_astDataTypeType = 17;
1766pub const MOJOSHADER_astDataTypeType_MOJOSHADER_AST_DATATYPE_VECTOR: MOJOSHADER_astDataTypeType =
1767 18;
1768pub const MOJOSHADER_astDataTypeType_MOJOSHADER_AST_DATATYPE_MATRIX: MOJOSHADER_astDataTypeType =
1769 19;
1770pub const MOJOSHADER_astDataTypeType_MOJOSHADER_AST_DATATYPE_BUFFER: MOJOSHADER_astDataTypeType =
1771 20;
1772pub const MOJOSHADER_astDataTypeType_MOJOSHADER_AST_DATATYPE_FUNCTION: MOJOSHADER_astDataTypeType =
1773 21;
1774pub const MOJOSHADER_astDataTypeType_MOJOSHADER_AST_DATATYPE_USER: MOJOSHADER_astDataTypeType = 22;
1775pub type MOJOSHADER_astDataTypeType = ::std::os::raw::c_uint;
1776#[repr(C)]
1777#[derive(Debug, Copy, Clone)]
1778pub struct MOJOSHADER_astDataTypeStructMember {
1779 pub datatype: *const MOJOSHADER_astDataType,
1780 pub identifier: *const ::std::os::raw::c_char,
1781}
1782#[test]
1783fn bindgen_test_layout_MOJOSHADER_astDataTypeStructMember() {
1784 assert_eq!(
1785 ::std::mem::size_of::<MOJOSHADER_astDataTypeStructMember>(),
1786 16usize,
1787 concat!("Size of: ", stringify!(MOJOSHADER_astDataTypeStructMember))
1788 );
1789 assert_eq!(
1790 ::std::mem::align_of::<MOJOSHADER_astDataTypeStructMember>(),
1791 8usize,
1792 concat!(
1793 "Alignment of ",
1794 stringify!(MOJOSHADER_astDataTypeStructMember)
1795 )
1796 );
1797 assert_eq!(
1798 unsafe {
1799 &(*(::std::ptr::null::<MOJOSHADER_astDataTypeStructMember>())).datatype as *const _
1800 as usize
1801 },
1802 0usize,
1803 concat!(
1804 "Offset of field: ",
1805 stringify!(MOJOSHADER_astDataTypeStructMember),
1806 "::",
1807 stringify!(datatype)
1808 )
1809 );
1810 assert_eq!(
1811 unsafe {
1812 &(*(::std::ptr::null::<MOJOSHADER_astDataTypeStructMember>())).identifier as *const _
1813 as usize
1814 },
1815 8usize,
1816 concat!(
1817 "Offset of field: ",
1818 stringify!(MOJOSHADER_astDataTypeStructMember),
1819 "::",
1820 stringify!(identifier)
1821 )
1822 );
1823}
1824#[repr(C)]
1825#[derive(Debug, Copy, Clone)]
1826pub struct MOJOSHADER_astDataTypeStruct {
1827 pub type_: MOJOSHADER_astDataTypeType,
1828 pub members: *const MOJOSHADER_astDataTypeStructMember,
1829 pub member_count: ::std::os::raw::c_int,
1830}
1831#[test]
1832fn bindgen_test_layout_MOJOSHADER_astDataTypeStruct() {
1833 assert_eq!(
1834 ::std::mem::size_of::<MOJOSHADER_astDataTypeStruct>(),
1835 24usize,
1836 concat!("Size of: ", stringify!(MOJOSHADER_astDataTypeStruct))
1837 );
1838 assert_eq!(
1839 ::std::mem::align_of::<MOJOSHADER_astDataTypeStruct>(),
1840 8usize,
1841 concat!("Alignment of ", stringify!(MOJOSHADER_astDataTypeStruct))
1842 );
1843 assert_eq!(
1844 unsafe {
1845 &(*(::std::ptr::null::<MOJOSHADER_astDataTypeStruct>())).type_ as *const _ as usize
1846 },
1847 0usize,
1848 concat!(
1849 "Offset of field: ",
1850 stringify!(MOJOSHADER_astDataTypeStruct),
1851 "::",
1852 stringify!(type_)
1853 )
1854 );
1855 assert_eq!(
1856 unsafe {
1857 &(*(::std::ptr::null::<MOJOSHADER_astDataTypeStruct>())).members as *const _ as usize
1858 },
1859 8usize,
1860 concat!(
1861 "Offset of field: ",
1862 stringify!(MOJOSHADER_astDataTypeStruct),
1863 "::",
1864 stringify!(members)
1865 )
1866 );
1867 assert_eq!(
1868 unsafe {
1869 &(*(::std::ptr::null::<MOJOSHADER_astDataTypeStruct>())).member_count as *const _
1870 as usize
1871 },
1872 16usize,
1873 concat!(
1874 "Offset of field: ",
1875 stringify!(MOJOSHADER_astDataTypeStruct),
1876 "::",
1877 stringify!(member_count)
1878 )
1879 );
1880}
1881#[repr(C)]
1882#[derive(Debug, Copy, Clone)]
1883pub struct MOJOSHADER_astDataTypeArray {
1884 pub type_: MOJOSHADER_astDataTypeType,
1885 pub base: *const MOJOSHADER_astDataType,
1886 pub elements: ::std::os::raw::c_int,
1887}
1888#[test]
1889fn bindgen_test_layout_MOJOSHADER_astDataTypeArray() {
1890 assert_eq!(
1891 ::std::mem::size_of::<MOJOSHADER_astDataTypeArray>(),
1892 24usize,
1893 concat!("Size of: ", stringify!(MOJOSHADER_astDataTypeArray))
1894 );
1895 assert_eq!(
1896 ::std::mem::align_of::<MOJOSHADER_astDataTypeArray>(),
1897 8usize,
1898 concat!("Alignment of ", stringify!(MOJOSHADER_astDataTypeArray))
1899 );
1900 assert_eq!(
1901 unsafe {
1902 &(*(::std::ptr::null::<MOJOSHADER_astDataTypeArray>())).type_ as *const _ as usize
1903 },
1904 0usize,
1905 concat!(
1906 "Offset of field: ",
1907 stringify!(MOJOSHADER_astDataTypeArray),
1908 "::",
1909 stringify!(type_)
1910 )
1911 );
1912 assert_eq!(
1913 unsafe {
1914 &(*(::std::ptr::null::<MOJOSHADER_astDataTypeArray>())).base as *const _ as usize
1915 },
1916 8usize,
1917 concat!(
1918 "Offset of field: ",
1919 stringify!(MOJOSHADER_astDataTypeArray),
1920 "::",
1921 stringify!(base)
1922 )
1923 );
1924 assert_eq!(
1925 unsafe {
1926 &(*(::std::ptr::null::<MOJOSHADER_astDataTypeArray>())).elements as *const _ as usize
1927 },
1928 16usize,
1929 concat!(
1930 "Offset of field: ",
1931 stringify!(MOJOSHADER_astDataTypeArray),
1932 "::",
1933 stringify!(elements)
1934 )
1935 );
1936}
1937pub type MOJOSHADER_astDataTypeVector = MOJOSHADER_astDataTypeArray;
1938#[repr(C)]
1939#[derive(Debug, Copy, Clone)]
1940pub struct MOJOSHADER_astDataTypeMatrix {
1941 pub type_: MOJOSHADER_astDataTypeType,
1942 pub base: *const MOJOSHADER_astDataType,
1943 pub rows: ::std::os::raw::c_int,
1944 pub columns: ::std::os::raw::c_int,
1945}
1946#[test]
1947fn bindgen_test_layout_MOJOSHADER_astDataTypeMatrix() {
1948 assert_eq!(
1949 ::std::mem::size_of::<MOJOSHADER_astDataTypeMatrix>(),
1950 24usize,
1951 concat!("Size of: ", stringify!(MOJOSHADER_astDataTypeMatrix))
1952 );
1953 assert_eq!(
1954 ::std::mem::align_of::<MOJOSHADER_astDataTypeMatrix>(),
1955 8usize,
1956 concat!("Alignment of ", stringify!(MOJOSHADER_astDataTypeMatrix))
1957 );
1958 assert_eq!(
1959 unsafe {
1960 &(*(::std::ptr::null::<MOJOSHADER_astDataTypeMatrix>())).type_ as *const _ as usize
1961 },
1962 0usize,
1963 concat!(
1964 "Offset of field: ",
1965 stringify!(MOJOSHADER_astDataTypeMatrix),
1966 "::",
1967 stringify!(type_)
1968 )
1969 );
1970 assert_eq!(
1971 unsafe {
1972 &(*(::std::ptr::null::<MOJOSHADER_astDataTypeMatrix>())).base as *const _ as usize
1973 },
1974 8usize,
1975 concat!(
1976 "Offset of field: ",
1977 stringify!(MOJOSHADER_astDataTypeMatrix),
1978 "::",
1979 stringify!(base)
1980 )
1981 );
1982 assert_eq!(
1983 unsafe {
1984 &(*(::std::ptr::null::<MOJOSHADER_astDataTypeMatrix>())).rows as *const _ as usize
1985 },
1986 16usize,
1987 concat!(
1988 "Offset of field: ",
1989 stringify!(MOJOSHADER_astDataTypeMatrix),
1990 "::",
1991 stringify!(rows)
1992 )
1993 );
1994 assert_eq!(
1995 unsafe {
1996 &(*(::std::ptr::null::<MOJOSHADER_astDataTypeMatrix>())).columns as *const _ as usize
1997 },
1998 20usize,
1999 concat!(
2000 "Offset of field: ",
2001 stringify!(MOJOSHADER_astDataTypeMatrix),
2002 "::",
2003 stringify!(columns)
2004 )
2005 );
2006}
2007#[repr(C)]
2008#[derive(Debug, Copy, Clone)]
2009pub struct MOJOSHADER_astDataTypeBuffer {
2010 pub type_: MOJOSHADER_astDataTypeType,
2011 pub base: *const MOJOSHADER_astDataType,
2012}
2013#[test]
2014fn bindgen_test_layout_MOJOSHADER_astDataTypeBuffer() {
2015 assert_eq!(
2016 ::std::mem::size_of::<MOJOSHADER_astDataTypeBuffer>(),
2017 16usize,
2018 concat!("Size of: ", stringify!(MOJOSHADER_astDataTypeBuffer))
2019 );
2020 assert_eq!(
2021 ::std::mem::align_of::<MOJOSHADER_astDataTypeBuffer>(),
2022 8usize,
2023 concat!("Alignment of ", stringify!(MOJOSHADER_astDataTypeBuffer))
2024 );
2025 assert_eq!(
2026 unsafe {
2027 &(*(::std::ptr::null::<MOJOSHADER_astDataTypeBuffer>())).type_ as *const _ as usize
2028 },
2029 0usize,
2030 concat!(
2031 "Offset of field: ",
2032 stringify!(MOJOSHADER_astDataTypeBuffer),
2033 "::",
2034 stringify!(type_)
2035 )
2036 );
2037 assert_eq!(
2038 unsafe {
2039 &(*(::std::ptr::null::<MOJOSHADER_astDataTypeBuffer>())).base as *const _ as usize
2040 },
2041 8usize,
2042 concat!(
2043 "Offset of field: ",
2044 stringify!(MOJOSHADER_astDataTypeBuffer),
2045 "::",
2046 stringify!(base)
2047 )
2048 );
2049}
2050#[repr(C)]
2051#[derive(Debug, Copy, Clone)]
2052pub struct MOJOSHADER_astDataTypeFunction {
2053 pub type_: MOJOSHADER_astDataTypeType,
2054 pub retval: *const MOJOSHADER_astDataType,
2055 pub params: *mut *const MOJOSHADER_astDataType,
2056 pub num_params: ::std::os::raw::c_int,
2057 pub intrinsic: ::std::os::raw::c_int,
2058}
2059#[test]
2060fn bindgen_test_layout_MOJOSHADER_astDataTypeFunction() {
2061 assert_eq!(
2062 ::std::mem::size_of::<MOJOSHADER_astDataTypeFunction>(),
2063 32usize,
2064 concat!("Size of: ", stringify!(MOJOSHADER_astDataTypeFunction))
2065 );
2066 assert_eq!(
2067 ::std::mem::align_of::<MOJOSHADER_astDataTypeFunction>(),
2068 8usize,
2069 concat!("Alignment of ", stringify!(MOJOSHADER_astDataTypeFunction))
2070 );
2071 assert_eq!(
2072 unsafe {
2073 &(*(::std::ptr::null::<MOJOSHADER_astDataTypeFunction>())).type_ as *const _ as usize
2074 },
2075 0usize,
2076 concat!(
2077 "Offset of field: ",
2078 stringify!(MOJOSHADER_astDataTypeFunction),
2079 "::",
2080 stringify!(type_)
2081 )
2082 );
2083 assert_eq!(
2084 unsafe {
2085 &(*(::std::ptr::null::<MOJOSHADER_astDataTypeFunction>())).retval as *const _ as usize
2086 },
2087 8usize,
2088 concat!(
2089 "Offset of field: ",
2090 stringify!(MOJOSHADER_astDataTypeFunction),
2091 "::",
2092 stringify!(retval)
2093 )
2094 );
2095 assert_eq!(
2096 unsafe {
2097 &(*(::std::ptr::null::<MOJOSHADER_astDataTypeFunction>())).params as *const _ as usize
2098 },
2099 16usize,
2100 concat!(
2101 "Offset of field: ",
2102 stringify!(MOJOSHADER_astDataTypeFunction),
2103 "::",
2104 stringify!(params)
2105 )
2106 );
2107 assert_eq!(
2108 unsafe {
2109 &(*(::std::ptr::null::<MOJOSHADER_astDataTypeFunction>())).num_params as *const _
2110 as usize
2111 },
2112 24usize,
2113 concat!(
2114 "Offset of field: ",
2115 stringify!(MOJOSHADER_astDataTypeFunction),
2116 "::",
2117 stringify!(num_params)
2118 )
2119 );
2120 assert_eq!(
2121 unsafe {
2122 &(*(::std::ptr::null::<MOJOSHADER_astDataTypeFunction>())).intrinsic as *const _
2123 as usize
2124 },
2125 28usize,
2126 concat!(
2127 "Offset of field: ",
2128 stringify!(MOJOSHADER_astDataTypeFunction),
2129 "::",
2130 stringify!(intrinsic)
2131 )
2132 );
2133}
2134#[repr(C)]
2135#[derive(Debug, Copy, Clone)]
2136pub struct MOJOSHADER_astDataTypeUser {
2137 pub type_: MOJOSHADER_astDataTypeType,
2138 pub details: *const MOJOSHADER_astDataType,
2139 pub name: *const ::std::os::raw::c_char,
2140}
2141#[test]
2142fn bindgen_test_layout_MOJOSHADER_astDataTypeUser() {
2143 assert_eq!(
2144 ::std::mem::size_of::<MOJOSHADER_astDataTypeUser>(),
2145 24usize,
2146 concat!("Size of: ", stringify!(MOJOSHADER_astDataTypeUser))
2147 );
2148 assert_eq!(
2149 ::std::mem::align_of::<MOJOSHADER_astDataTypeUser>(),
2150 8usize,
2151 concat!("Alignment of ", stringify!(MOJOSHADER_astDataTypeUser))
2152 );
2153 assert_eq!(
2154 unsafe {
2155 &(*(::std::ptr::null::<MOJOSHADER_astDataTypeUser>())).type_ as *const _ as usize
2156 },
2157 0usize,
2158 concat!(
2159 "Offset of field: ",
2160 stringify!(MOJOSHADER_astDataTypeUser),
2161 "::",
2162 stringify!(type_)
2163 )
2164 );
2165 assert_eq!(
2166 unsafe {
2167 &(*(::std::ptr::null::<MOJOSHADER_astDataTypeUser>())).details as *const _ as usize
2168 },
2169 8usize,
2170 concat!(
2171 "Offset of field: ",
2172 stringify!(MOJOSHADER_astDataTypeUser),
2173 "::",
2174 stringify!(details)
2175 )
2176 );
2177 assert_eq!(
2178 unsafe { &(*(::std::ptr::null::<MOJOSHADER_astDataTypeUser>())).name as *const _ as usize },
2179 16usize,
2180 concat!(
2181 "Offset of field: ",
2182 stringify!(MOJOSHADER_astDataTypeUser),
2183 "::",
2184 stringify!(name)
2185 )
2186 );
2187}
2188#[repr(C)]
2189#[derive(Copy, Clone)]
2190pub union MOJOSHADER_astDataType {
2191 pub type_: MOJOSHADER_astDataTypeType,
2192 pub array: MOJOSHADER_astDataTypeArray,
2193 pub structure: MOJOSHADER_astDataTypeStruct,
2194 pub vector: MOJOSHADER_astDataTypeVector,
2195 pub matrix: MOJOSHADER_astDataTypeMatrix,
2196 pub buffer: MOJOSHADER_astDataTypeBuffer,
2197 pub user: MOJOSHADER_astDataTypeUser,
2198 pub function: MOJOSHADER_astDataTypeFunction,
2199 _bindgen_union_align: [u64; 4usize],
2200}
2201#[test]
2202fn bindgen_test_layout_MOJOSHADER_astDataType() {
2203 assert_eq!(
2204 ::std::mem::size_of::<MOJOSHADER_astDataType>(),
2205 32usize,
2206 concat!("Size of: ", stringify!(MOJOSHADER_astDataType))
2207 );
2208 assert_eq!(
2209 ::std::mem::align_of::<MOJOSHADER_astDataType>(),
2210 8usize,
2211 concat!("Alignment of ", stringify!(MOJOSHADER_astDataType))
2212 );
2213 assert_eq!(
2214 unsafe { &(*(::std::ptr::null::<MOJOSHADER_astDataType>())).type_ as *const _ as usize },
2215 0usize,
2216 concat!(
2217 "Offset of field: ",
2218 stringify!(MOJOSHADER_astDataType),
2219 "::",
2220 stringify!(type_)
2221 )
2222 );
2223 assert_eq!(
2224 unsafe { &(*(::std::ptr::null::<MOJOSHADER_astDataType>())).array as *const _ as usize },
2225 0usize,
2226 concat!(
2227 "Offset of field: ",
2228 stringify!(MOJOSHADER_astDataType),
2229 "::",
2230 stringify!(array)
2231 )
2232 );
2233 assert_eq!(
2234 unsafe {
2235 &(*(::std::ptr::null::<MOJOSHADER_astDataType>())).structure as *const _ as usize
2236 },
2237 0usize,
2238 concat!(
2239 "Offset of field: ",
2240 stringify!(MOJOSHADER_astDataType),
2241 "::",
2242 stringify!(structure)
2243 )
2244 );
2245 assert_eq!(
2246 unsafe { &(*(::std::ptr::null::<MOJOSHADER_astDataType>())).vector as *const _ as usize },
2247 0usize,
2248 concat!(
2249 "Offset of field: ",
2250 stringify!(MOJOSHADER_astDataType),
2251 "::",
2252 stringify!(vector)
2253 )
2254 );
2255 assert_eq!(
2256 unsafe { &(*(::std::ptr::null::<MOJOSHADER_astDataType>())).matrix as *const _ as usize },
2257 0usize,
2258 concat!(
2259 "Offset of field: ",
2260 stringify!(MOJOSHADER_astDataType),
2261 "::",
2262 stringify!(matrix)
2263 )
2264 );
2265 assert_eq!(
2266 unsafe { &(*(::std::ptr::null::<MOJOSHADER_astDataType>())).buffer as *const _ as usize },
2267 0usize,
2268 concat!(
2269 "Offset of field: ",
2270 stringify!(MOJOSHADER_astDataType),
2271 "::",
2272 stringify!(buffer)
2273 )
2274 );
2275 assert_eq!(
2276 unsafe { &(*(::std::ptr::null::<MOJOSHADER_astDataType>())).user as *const _ as usize },
2277 0usize,
2278 concat!(
2279 "Offset of field: ",
2280 stringify!(MOJOSHADER_astDataType),
2281 "::",
2282 stringify!(user)
2283 )
2284 );
2285 assert_eq!(
2286 unsafe { &(*(::std::ptr::null::<MOJOSHADER_astDataType>())).function as *const _ as usize },
2287 0usize,
2288 concat!(
2289 "Offset of field: ",
2290 stringify!(MOJOSHADER_astDataType),
2291 "::",
2292 stringify!(function)
2293 )
2294 );
2295}
2296pub const MOJOSHADER_astNodeType_MOJOSHADER_AST_OP_START_RANGE: MOJOSHADER_astNodeType = 0;
2297pub const MOJOSHADER_astNodeType_MOJOSHADER_AST_OP_START_RANGE_UNARY: MOJOSHADER_astNodeType = 1;
2298pub const MOJOSHADER_astNodeType_MOJOSHADER_AST_OP_PREINCREMENT: MOJOSHADER_astNodeType = 2;
2299pub const MOJOSHADER_astNodeType_MOJOSHADER_AST_OP_PREDECREMENT: MOJOSHADER_astNodeType = 3;
2300pub const MOJOSHADER_astNodeType_MOJOSHADER_AST_OP_NEGATE: MOJOSHADER_astNodeType = 4;
2301pub const MOJOSHADER_astNodeType_MOJOSHADER_AST_OP_COMPLEMENT: MOJOSHADER_astNodeType = 5;
2302pub const MOJOSHADER_astNodeType_MOJOSHADER_AST_OP_NOT: MOJOSHADER_astNodeType = 6;
2303pub const MOJOSHADER_astNodeType_MOJOSHADER_AST_OP_POSTINCREMENT: MOJOSHADER_astNodeType = 7;
2304pub const MOJOSHADER_astNodeType_MOJOSHADER_AST_OP_POSTDECREMENT: MOJOSHADER_astNodeType = 8;
2305pub const MOJOSHADER_astNodeType_MOJOSHADER_AST_OP_CAST: MOJOSHADER_astNodeType = 9;
2306pub const MOJOSHADER_astNodeType_MOJOSHADER_AST_OP_END_RANGE_UNARY: MOJOSHADER_astNodeType = 10;
2307pub const MOJOSHADER_astNodeType_MOJOSHADER_AST_OP_START_RANGE_BINARY: MOJOSHADER_astNodeType = 11;
2308pub const MOJOSHADER_astNodeType_MOJOSHADER_AST_OP_COMMA: MOJOSHADER_astNodeType = 12;
2309pub const MOJOSHADER_astNodeType_MOJOSHADER_AST_OP_MULTIPLY: MOJOSHADER_astNodeType = 13;
2310pub const MOJOSHADER_astNodeType_MOJOSHADER_AST_OP_DIVIDE: MOJOSHADER_astNodeType = 14;
2311pub const MOJOSHADER_astNodeType_MOJOSHADER_AST_OP_MODULO: MOJOSHADER_astNodeType = 15;
2312pub const MOJOSHADER_astNodeType_MOJOSHADER_AST_OP_ADD: MOJOSHADER_astNodeType = 16;
2313pub const MOJOSHADER_astNodeType_MOJOSHADER_AST_OP_SUBTRACT: MOJOSHADER_astNodeType = 17;
2314pub const MOJOSHADER_astNodeType_MOJOSHADER_AST_OP_LSHIFT: MOJOSHADER_astNodeType = 18;
2315pub const MOJOSHADER_astNodeType_MOJOSHADER_AST_OP_RSHIFT: MOJOSHADER_astNodeType = 19;
2316pub const MOJOSHADER_astNodeType_MOJOSHADER_AST_OP_LESSTHAN: MOJOSHADER_astNodeType = 20;
2317pub const MOJOSHADER_astNodeType_MOJOSHADER_AST_OP_GREATERTHAN: MOJOSHADER_astNodeType = 21;
2318pub const MOJOSHADER_astNodeType_MOJOSHADER_AST_OP_LESSTHANOREQUAL: MOJOSHADER_astNodeType = 22;
2319pub const MOJOSHADER_astNodeType_MOJOSHADER_AST_OP_GREATERTHANOREQUAL: MOJOSHADER_astNodeType = 23;
2320pub const MOJOSHADER_astNodeType_MOJOSHADER_AST_OP_EQUAL: MOJOSHADER_astNodeType = 24;
2321pub const MOJOSHADER_astNodeType_MOJOSHADER_AST_OP_NOTEQUAL: MOJOSHADER_astNodeType = 25;
2322pub const MOJOSHADER_astNodeType_MOJOSHADER_AST_OP_BINARYAND: MOJOSHADER_astNodeType = 26;
2323pub const MOJOSHADER_astNodeType_MOJOSHADER_AST_OP_BINARYXOR: MOJOSHADER_astNodeType = 27;
2324pub const MOJOSHADER_astNodeType_MOJOSHADER_AST_OP_BINARYOR: MOJOSHADER_astNodeType = 28;
2325pub const MOJOSHADER_astNodeType_MOJOSHADER_AST_OP_LOGICALAND: MOJOSHADER_astNodeType = 29;
2326pub const MOJOSHADER_astNodeType_MOJOSHADER_AST_OP_LOGICALOR: MOJOSHADER_astNodeType = 30;
2327pub const MOJOSHADER_astNodeType_MOJOSHADER_AST_OP_ASSIGN: MOJOSHADER_astNodeType = 31;
2328pub const MOJOSHADER_astNodeType_MOJOSHADER_AST_OP_MULASSIGN: MOJOSHADER_astNodeType = 32;
2329pub const MOJOSHADER_astNodeType_MOJOSHADER_AST_OP_DIVASSIGN: MOJOSHADER_astNodeType = 33;
2330pub const MOJOSHADER_astNodeType_MOJOSHADER_AST_OP_MODASSIGN: MOJOSHADER_astNodeType = 34;
2331pub const MOJOSHADER_astNodeType_MOJOSHADER_AST_OP_ADDASSIGN: MOJOSHADER_astNodeType = 35;
2332pub const MOJOSHADER_astNodeType_MOJOSHADER_AST_OP_SUBASSIGN: MOJOSHADER_astNodeType = 36;
2333pub const MOJOSHADER_astNodeType_MOJOSHADER_AST_OP_LSHIFTASSIGN: MOJOSHADER_astNodeType = 37;
2334pub const MOJOSHADER_astNodeType_MOJOSHADER_AST_OP_RSHIFTASSIGN: MOJOSHADER_astNodeType = 38;
2335pub const MOJOSHADER_astNodeType_MOJOSHADER_AST_OP_ANDASSIGN: MOJOSHADER_astNodeType = 39;
2336pub const MOJOSHADER_astNodeType_MOJOSHADER_AST_OP_XORASSIGN: MOJOSHADER_astNodeType = 40;
2337pub const MOJOSHADER_astNodeType_MOJOSHADER_AST_OP_ORASSIGN: MOJOSHADER_astNodeType = 41;
2338pub const MOJOSHADER_astNodeType_MOJOSHADER_AST_OP_DEREF_ARRAY: MOJOSHADER_astNodeType = 42;
2339pub const MOJOSHADER_astNodeType_MOJOSHADER_AST_OP_END_RANGE_BINARY: MOJOSHADER_astNodeType = 43;
2340pub const MOJOSHADER_astNodeType_MOJOSHADER_AST_OP_START_RANGE_TERNARY: MOJOSHADER_astNodeType = 44;
2341pub const MOJOSHADER_astNodeType_MOJOSHADER_AST_OP_CONDITIONAL: MOJOSHADER_astNodeType = 45;
2342pub const MOJOSHADER_astNodeType_MOJOSHADER_AST_OP_END_RANGE_TERNARY: MOJOSHADER_astNodeType = 46;
2343pub const MOJOSHADER_astNodeType_MOJOSHADER_AST_OP_START_RANGE_DATA: MOJOSHADER_astNodeType = 47;
2344pub const MOJOSHADER_astNodeType_MOJOSHADER_AST_OP_IDENTIFIER: MOJOSHADER_astNodeType = 48;
2345pub const MOJOSHADER_astNodeType_MOJOSHADER_AST_OP_INT_LITERAL: MOJOSHADER_astNodeType = 49;
2346pub const MOJOSHADER_astNodeType_MOJOSHADER_AST_OP_FLOAT_LITERAL: MOJOSHADER_astNodeType = 50;
2347pub const MOJOSHADER_astNodeType_MOJOSHADER_AST_OP_STRING_LITERAL: MOJOSHADER_astNodeType = 51;
2348pub const MOJOSHADER_astNodeType_MOJOSHADER_AST_OP_BOOLEAN_LITERAL: MOJOSHADER_astNodeType = 52;
2349pub const MOJOSHADER_astNodeType_MOJOSHADER_AST_OP_END_RANGE_DATA: MOJOSHADER_astNodeType = 53;
2350pub const MOJOSHADER_astNodeType_MOJOSHADER_AST_OP_START_RANGE_MISC: MOJOSHADER_astNodeType = 54;
2351pub const MOJOSHADER_astNodeType_MOJOSHADER_AST_OP_DEREF_STRUCT: MOJOSHADER_astNodeType = 55;
2352pub const MOJOSHADER_astNodeType_MOJOSHADER_AST_OP_CALLFUNC: MOJOSHADER_astNodeType = 56;
2353pub const MOJOSHADER_astNodeType_MOJOSHADER_AST_OP_CONSTRUCTOR: MOJOSHADER_astNodeType = 57;
2354pub const MOJOSHADER_astNodeType_MOJOSHADER_AST_OP_END_RANGE_MISC: MOJOSHADER_astNodeType = 58;
2355pub const MOJOSHADER_astNodeType_MOJOSHADER_AST_OP_END_RANGE: MOJOSHADER_astNodeType = 59;
2356pub const MOJOSHADER_astNodeType_MOJOSHADER_AST_COMPUNIT_START_RANGE: MOJOSHADER_astNodeType = 60;
2357pub const MOJOSHADER_astNodeType_MOJOSHADER_AST_COMPUNIT_FUNCTION: MOJOSHADER_astNodeType = 61;
2358pub const MOJOSHADER_astNodeType_MOJOSHADER_AST_COMPUNIT_TYPEDEF: MOJOSHADER_astNodeType = 62;
2359pub const MOJOSHADER_astNodeType_MOJOSHADER_AST_COMPUNIT_STRUCT: MOJOSHADER_astNodeType = 63;
2360pub const MOJOSHADER_astNodeType_MOJOSHADER_AST_COMPUNIT_VARIABLE: MOJOSHADER_astNodeType = 64;
2361pub const MOJOSHADER_astNodeType_MOJOSHADER_AST_COMPUNIT_END_RANGE: MOJOSHADER_astNodeType = 65;
2362pub const MOJOSHADER_astNodeType_MOJOSHADER_AST_STATEMENT_START_RANGE: MOJOSHADER_astNodeType = 66;
2363pub const MOJOSHADER_astNodeType_MOJOSHADER_AST_STATEMENT_EMPTY: MOJOSHADER_astNodeType = 67;
2364pub const MOJOSHADER_astNodeType_MOJOSHADER_AST_STATEMENT_BREAK: MOJOSHADER_astNodeType = 68;
2365pub const MOJOSHADER_astNodeType_MOJOSHADER_AST_STATEMENT_CONTINUE: MOJOSHADER_astNodeType = 69;
2366pub const MOJOSHADER_astNodeType_MOJOSHADER_AST_STATEMENT_DISCARD: MOJOSHADER_astNodeType = 70;
2367pub const MOJOSHADER_astNodeType_MOJOSHADER_AST_STATEMENT_BLOCK: MOJOSHADER_astNodeType = 71;
2368pub const MOJOSHADER_astNodeType_MOJOSHADER_AST_STATEMENT_EXPRESSION: MOJOSHADER_astNodeType = 72;
2369pub const MOJOSHADER_astNodeType_MOJOSHADER_AST_STATEMENT_IF: MOJOSHADER_astNodeType = 73;
2370pub const MOJOSHADER_astNodeType_MOJOSHADER_AST_STATEMENT_SWITCH: MOJOSHADER_astNodeType = 74;
2371pub const MOJOSHADER_astNodeType_MOJOSHADER_AST_STATEMENT_FOR: MOJOSHADER_astNodeType = 75;
2372pub const MOJOSHADER_astNodeType_MOJOSHADER_AST_STATEMENT_DO: MOJOSHADER_astNodeType = 76;
2373pub const MOJOSHADER_astNodeType_MOJOSHADER_AST_STATEMENT_WHILE: MOJOSHADER_astNodeType = 77;
2374pub const MOJOSHADER_astNodeType_MOJOSHADER_AST_STATEMENT_RETURN: MOJOSHADER_astNodeType = 78;
2375pub const MOJOSHADER_astNodeType_MOJOSHADER_AST_STATEMENT_TYPEDEF: MOJOSHADER_astNodeType = 79;
2376pub const MOJOSHADER_astNodeType_MOJOSHADER_AST_STATEMENT_STRUCT: MOJOSHADER_astNodeType = 80;
2377pub const MOJOSHADER_astNodeType_MOJOSHADER_AST_STATEMENT_VARDECL: MOJOSHADER_astNodeType = 81;
2378pub const MOJOSHADER_astNodeType_MOJOSHADER_AST_STATEMENT_END_RANGE: MOJOSHADER_astNodeType = 82;
2379pub const MOJOSHADER_astNodeType_MOJOSHADER_AST_MISC_START_RANGE: MOJOSHADER_astNodeType = 83;
2380pub const MOJOSHADER_astNodeType_MOJOSHADER_AST_FUNCTION_PARAMS: MOJOSHADER_astNodeType = 84;
2381pub const MOJOSHADER_astNodeType_MOJOSHADER_AST_FUNCTION_SIGNATURE: MOJOSHADER_astNodeType = 85;
2382pub const MOJOSHADER_astNodeType_MOJOSHADER_AST_SCALAR_OR_ARRAY: MOJOSHADER_astNodeType = 86;
2383pub const MOJOSHADER_astNodeType_MOJOSHADER_AST_TYPEDEF: MOJOSHADER_astNodeType = 87;
2384pub const MOJOSHADER_astNodeType_MOJOSHADER_AST_PACK_OFFSET: MOJOSHADER_astNodeType = 88;
2385pub const MOJOSHADER_astNodeType_MOJOSHADER_AST_VARIABLE_LOWLEVEL: MOJOSHADER_astNodeType = 89;
2386pub const MOJOSHADER_astNodeType_MOJOSHADER_AST_ANNOTATION: MOJOSHADER_astNodeType = 90;
2387pub const MOJOSHADER_astNodeType_MOJOSHADER_AST_VARIABLE_DECLARATION: MOJOSHADER_astNodeType = 91;
2388pub const MOJOSHADER_astNodeType_MOJOSHADER_AST_STRUCT_DECLARATION: MOJOSHADER_astNodeType = 92;
2389pub const MOJOSHADER_astNodeType_MOJOSHADER_AST_STRUCT_MEMBER: MOJOSHADER_astNodeType = 93;
2390pub const MOJOSHADER_astNodeType_MOJOSHADER_AST_SWITCH_CASE: MOJOSHADER_astNodeType = 94;
2391pub const MOJOSHADER_astNodeType_MOJOSHADER_AST_ARGUMENTS: MOJOSHADER_astNodeType = 95;
2392pub const MOJOSHADER_astNodeType_MOJOSHADER_AST_MISC_END_RANGE: MOJOSHADER_astNodeType = 96;
2393pub const MOJOSHADER_astNodeType_MOJOSHADER_AST_END_RANGE: MOJOSHADER_astNodeType = 97;
2394pub type MOJOSHADER_astNodeType = ::std::os::raw::c_uint;
2395#[repr(C)]
2396#[derive(Debug, Copy, Clone)]
2397pub struct MOJOSHADER_astNodeInfo {
2398 pub type_: MOJOSHADER_astNodeType,
2399 pub filename: *const ::std::os::raw::c_char,
2400 pub line: ::std::os::raw::c_uint,
2401}
2402#[test]
2403fn bindgen_test_layout_MOJOSHADER_astNodeInfo() {
2404 assert_eq!(
2405 ::std::mem::size_of::<MOJOSHADER_astNodeInfo>(),
2406 24usize,
2407 concat!("Size of: ", stringify!(MOJOSHADER_astNodeInfo))
2408 );
2409 assert_eq!(
2410 ::std::mem::align_of::<MOJOSHADER_astNodeInfo>(),
2411 8usize,
2412 concat!("Alignment of ", stringify!(MOJOSHADER_astNodeInfo))
2413 );
2414 assert_eq!(
2415 unsafe { &(*(::std::ptr::null::<MOJOSHADER_astNodeInfo>())).type_ as *const _ as usize },
2416 0usize,
2417 concat!(
2418 "Offset of field: ",
2419 stringify!(MOJOSHADER_astNodeInfo),
2420 "::",
2421 stringify!(type_)
2422 )
2423 );
2424 assert_eq!(
2425 unsafe { &(*(::std::ptr::null::<MOJOSHADER_astNodeInfo>())).filename as *const _ as usize },
2426 8usize,
2427 concat!(
2428 "Offset of field: ",
2429 stringify!(MOJOSHADER_astNodeInfo),
2430 "::",
2431 stringify!(filename)
2432 )
2433 );
2434 assert_eq!(
2435 unsafe { &(*(::std::ptr::null::<MOJOSHADER_astNodeInfo>())).line as *const _ as usize },
2436 16usize,
2437 concat!(
2438 "Offset of field: ",
2439 stringify!(MOJOSHADER_astNodeInfo),
2440 "::",
2441 stringify!(line)
2442 )
2443 );
2444}
2445pub const MOJOSHADER_astVariableAttributes_MOJOSHADER_AST_VARATTR_EXTERN:
2446 MOJOSHADER_astVariableAttributes = 1;
2447pub const MOJOSHADER_astVariableAttributes_MOJOSHADER_AST_VARATTR_NOINTERPOLATION:
2448 MOJOSHADER_astVariableAttributes = 2;
2449pub const MOJOSHADER_astVariableAttributes_MOJOSHADER_AST_VARATTR_SHARED:
2450 MOJOSHADER_astVariableAttributes = 4;
2451pub const MOJOSHADER_astVariableAttributes_MOJOSHADER_AST_VARATTR_STATIC:
2452 MOJOSHADER_astVariableAttributes = 8;
2453pub const MOJOSHADER_astVariableAttributes_MOJOSHADER_AST_VARATTR_UNIFORM:
2454 MOJOSHADER_astVariableAttributes = 16;
2455pub const MOJOSHADER_astVariableAttributes_MOJOSHADER_AST_VARATTR_VOLATILE:
2456 MOJOSHADER_astVariableAttributes = 32;
2457pub const MOJOSHADER_astVariableAttributes_MOJOSHADER_AST_VARATTR_CONST:
2458 MOJOSHADER_astVariableAttributes = 64;
2459pub const MOJOSHADER_astVariableAttributes_MOJOSHADER_AST_VARATTR_ROWMAJOR:
2460 MOJOSHADER_astVariableAttributes = 128;
2461pub const MOJOSHADER_astVariableAttributes_MOJOSHADER_AST_VARATTR_COLUMNMAJOR:
2462 MOJOSHADER_astVariableAttributes = 256;
2463pub type MOJOSHADER_astVariableAttributes = ::std::os::raw::c_uint;
2464pub const MOJOSHADER_astIfAttributes_MOJOSHADER_AST_IFATTR_NONE: MOJOSHADER_astIfAttributes = 0;
2465pub const MOJOSHADER_astIfAttributes_MOJOSHADER_AST_IFATTR_BRANCH: MOJOSHADER_astIfAttributes = 1;
2466pub const MOJOSHADER_astIfAttributes_MOJOSHADER_AST_IFATTR_FLATTEN: MOJOSHADER_astIfAttributes = 2;
2467pub const MOJOSHADER_astIfAttributes_MOJOSHADER_AST_IFATTR_IFALL: MOJOSHADER_astIfAttributes = 3;
2468pub const MOJOSHADER_astIfAttributes_MOJOSHADER_AST_IFATTR_IFANY: MOJOSHADER_astIfAttributes = 4;
2469pub const MOJOSHADER_astIfAttributes_MOJOSHADER_AST_IFATTR_PREDICATE: MOJOSHADER_astIfAttributes =
2470 5;
2471pub const MOJOSHADER_astIfAttributes_MOJOSHADER_AST_IFATTR_PREDICATEBLOCK:
2472 MOJOSHADER_astIfAttributes = 6;
2473pub type MOJOSHADER_astIfAttributes = ::std::os::raw::c_uint;
2474pub const MOJOSHADER_astSwitchAttributes_MOJOSHADER_AST_SWITCHATTR_NONE:
2475 MOJOSHADER_astSwitchAttributes = 0;
2476pub const MOJOSHADER_astSwitchAttributes_MOJOSHADER_AST_SWITCHATTR_FLATTEN:
2477 MOJOSHADER_astSwitchAttributes = 1;
2478pub const MOJOSHADER_astSwitchAttributes_MOJOSHADER_AST_SWITCHATTR_BRANCH:
2479 MOJOSHADER_astSwitchAttributes = 2;
2480pub const MOJOSHADER_astSwitchAttributes_MOJOSHADER_AST_SWITCHATTR_FORCECASE:
2481 MOJOSHADER_astSwitchAttributes = 3;
2482pub const MOJOSHADER_astSwitchAttributes_MOJOSHADER_AST_SWITCHATTR_CALL:
2483 MOJOSHADER_astSwitchAttributes = 4;
2484pub type MOJOSHADER_astSwitchAttributes = ::std::os::raw::c_uint;
2485#[repr(C)]
2486#[derive(Debug, Copy, Clone)]
2487pub struct MOJOSHADER_astGeneric {
2488 pub ast: MOJOSHADER_astNodeInfo,
2489}
2490#[test]
2491fn bindgen_test_layout_MOJOSHADER_astGeneric() {
2492 assert_eq!(
2493 ::std::mem::size_of::<MOJOSHADER_astGeneric>(),
2494 24usize,
2495 concat!("Size of: ", stringify!(MOJOSHADER_astGeneric))
2496 );
2497 assert_eq!(
2498 ::std::mem::align_of::<MOJOSHADER_astGeneric>(),
2499 8usize,
2500 concat!("Alignment of ", stringify!(MOJOSHADER_astGeneric))
2501 );
2502 assert_eq!(
2503 unsafe { &(*(::std::ptr::null::<MOJOSHADER_astGeneric>())).ast as *const _ as usize },
2504 0usize,
2505 concat!(
2506 "Offset of field: ",
2507 stringify!(MOJOSHADER_astGeneric),
2508 "::",
2509 stringify!(ast)
2510 )
2511 );
2512}
2513#[repr(C)]
2514#[derive(Debug, Copy, Clone)]
2515pub struct MOJOSHADER_astExpression {
2516 pub ast: MOJOSHADER_astNodeInfo,
2517 pub datatype: *const MOJOSHADER_astDataType,
2518}
2519#[test]
2520fn bindgen_test_layout_MOJOSHADER_astExpression() {
2521 assert_eq!(
2522 ::std::mem::size_of::<MOJOSHADER_astExpression>(),
2523 32usize,
2524 concat!("Size of: ", stringify!(MOJOSHADER_astExpression))
2525 );
2526 assert_eq!(
2527 ::std::mem::align_of::<MOJOSHADER_astExpression>(),
2528 8usize,
2529 concat!("Alignment of ", stringify!(MOJOSHADER_astExpression))
2530 );
2531 assert_eq!(
2532 unsafe { &(*(::std::ptr::null::<MOJOSHADER_astExpression>())).ast as *const _ as usize },
2533 0usize,
2534 concat!(
2535 "Offset of field: ",
2536 stringify!(MOJOSHADER_astExpression),
2537 "::",
2538 stringify!(ast)
2539 )
2540 );
2541 assert_eq!(
2542 unsafe {
2543 &(*(::std::ptr::null::<MOJOSHADER_astExpression>())).datatype as *const _ as usize
2544 },
2545 24usize,
2546 concat!(
2547 "Offset of field: ",
2548 stringify!(MOJOSHADER_astExpression),
2549 "::",
2550 stringify!(datatype)
2551 )
2552 );
2553}
2554#[repr(C)]
2555#[derive(Debug, Copy, Clone)]
2556pub struct MOJOSHADER_astArguments {
2557 pub ast: MOJOSHADER_astNodeInfo,
2558 pub argument: *mut MOJOSHADER_astExpression,
2559 pub next: *mut MOJOSHADER_astArguments,
2560}
2561#[test]
2562fn bindgen_test_layout_MOJOSHADER_astArguments() {
2563 assert_eq!(
2564 ::std::mem::size_of::<MOJOSHADER_astArguments>(),
2565 40usize,
2566 concat!("Size of: ", stringify!(MOJOSHADER_astArguments))
2567 );
2568 assert_eq!(
2569 ::std::mem::align_of::<MOJOSHADER_astArguments>(),
2570 8usize,
2571 concat!("Alignment of ", stringify!(MOJOSHADER_astArguments))
2572 );
2573 assert_eq!(
2574 unsafe { &(*(::std::ptr::null::<MOJOSHADER_astArguments>())).ast as *const _ as usize },
2575 0usize,
2576 concat!(
2577 "Offset of field: ",
2578 stringify!(MOJOSHADER_astArguments),
2579 "::",
2580 stringify!(ast)
2581 )
2582 );
2583 assert_eq!(
2584 unsafe {
2585 &(*(::std::ptr::null::<MOJOSHADER_astArguments>())).argument as *const _ as usize
2586 },
2587 24usize,
2588 concat!(
2589 "Offset of field: ",
2590 stringify!(MOJOSHADER_astArguments),
2591 "::",
2592 stringify!(argument)
2593 )
2594 );
2595 assert_eq!(
2596 unsafe { &(*(::std::ptr::null::<MOJOSHADER_astArguments>())).next as *const _ as usize },
2597 32usize,
2598 concat!(
2599 "Offset of field: ",
2600 stringify!(MOJOSHADER_astArguments),
2601 "::",
2602 stringify!(next)
2603 )
2604 );
2605}
2606#[repr(C)]
2607#[derive(Debug, Copy, Clone)]
2608pub struct MOJOSHADER_astExpressionUnary {
2609 pub ast: MOJOSHADER_astNodeInfo,
2610 pub datatype: *const MOJOSHADER_astDataType,
2611 pub operand: *mut MOJOSHADER_astExpression,
2612}
2613#[test]
2614fn bindgen_test_layout_MOJOSHADER_astExpressionUnary() {
2615 assert_eq!(
2616 ::std::mem::size_of::<MOJOSHADER_astExpressionUnary>(),
2617 40usize,
2618 concat!("Size of: ", stringify!(MOJOSHADER_astExpressionUnary))
2619 );
2620 assert_eq!(
2621 ::std::mem::align_of::<MOJOSHADER_astExpressionUnary>(),
2622 8usize,
2623 concat!("Alignment of ", stringify!(MOJOSHADER_astExpressionUnary))
2624 );
2625 assert_eq!(
2626 unsafe {
2627 &(*(::std::ptr::null::<MOJOSHADER_astExpressionUnary>())).ast as *const _ as usize
2628 },
2629 0usize,
2630 concat!(
2631 "Offset of field: ",
2632 stringify!(MOJOSHADER_astExpressionUnary),
2633 "::",
2634 stringify!(ast)
2635 )
2636 );
2637 assert_eq!(
2638 unsafe {
2639 &(*(::std::ptr::null::<MOJOSHADER_astExpressionUnary>())).datatype as *const _ as usize
2640 },
2641 24usize,
2642 concat!(
2643 "Offset of field: ",
2644 stringify!(MOJOSHADER_astExpressionUnary),
2645 "::",
2646 stringify!(datatype)
2647 )
2648 );
2649 assert_eq!(
2650 unsafe {
2651 &(*(::std::ptr::null::<MOJOSHADER_astExpressionUnary>())).operand as *const _ as usize
2652 },
2653 32usize,
2654 concat!(
2655 "Offset of field: ",
2656 stringify!(MOJOSHADER_astExpressionUnary),
2657 "::",
2658 stringify!(operand)
2659 )
2660 );
2661}
2662#[repr(C)]
2663#[derive(Debug, Copy, Clone)]
2664pub struct MOJOSHADER_astExpressionBinary {
2665 pub ast: MOJOSHADER_astNodeInfo,
2666 pub datatype: *const MOJOSHADER_astDataType,
2667 pub left: *mut MOJOSHADER_astExpression,
2668 pub right: *mut MOJOSHADER_astExpression,
2669}
2670#[test]
2671fn bindgen_test_layout_MOJOSHADER_astExpressionBinary() {
2672 assert_eq!(
2673 ::std::mem::size_of::<MOJOSHADER_astExpressionBinary>(),
2674 48usize,
2675 concat!("Size of: ", stringify!(MOJOSHADER_astExpressionBinary))
2676 );
2677 assert_eq!(
2678 ::std::mem::align_of::<MOJOSHADER_astExpressionBinary>(),
2679 8usize,
2680 concat!("Alignment of ", stringify!(MOJOSHADER_astExpressionBinary))
2681 );
2682 assert_eq!(
2683 unsafe {
2684 &(*(::std::ptr::null::<MOJOSHADER_astExpressionBinary>())).ast as *const _ as usize
2685 },
2686 0usize,
2687 concat!(
2688 "Offset of field: ",
2689 stringify!(MOJOSHADER_astExpressionBinary),
2690 "::",
2691 stringify!(ast)
2692 )
2693 );
2694 assert_eq!(
2695 unsafe {
2696 &(*(::std::ptr::null::<MOJOSHADER_astExpressionBinary>())).datatype as *const _ as usize
2697 },
2698 24usize,
2699 concat!(
2700 "Offset of field: ",
2701 stringify!(MOJOSHADER_astExpressionBinary),
2702 "::",
2703 stringify!(datatype)
2704 )
2705 );
2706 assert_eq!(
2707 unsafe {
2708 &(*(::std::ptr::null::<MOJOSHADER_astExpressionBinary>())).left as *const _ as usize
2709 },
2710 32usize,
2711 concat!(
2712 "Offset of field: ",
2713 stringify!(MOJOSHADER_astExpressionBinary),
2714 "::",
2715 stringify!(left)
2716 )
2717 );
2718 assert_eq!(
2719 unsafe {
2720 &(*(::std::ptr::null::<MOJOSHADER_astExpressionBinary>())).right as *const _ as usize
2721 },
2722 40usize,
2723 concat!(
2724 "Offset of field: ",
2725 stringify!(MOJOSHADER_astExpressionBinary),
2726 "::",
2727 stringify!(right)
2728 )
2729 );
2730}
2731#[repr(C)]
2732#[derive(Debug, Copy, Clone)]
2733pub struct MOJOSHADER_astExpressionTernary {
2734 pub ast: MOJOSHADER_astNodeInfo,
2735 pub datatype: *const MOJOSHADER_astDataType,
2736 pub left: *mut MOJOSHADER_astExpression,
2737 pub center: *mut MOJOSHADER_astExpression,
2738 pub right: *mut MOJOSHADER_astExpression,
2739}
2740#[test]
2741fn bindgen_test_layout_MOJOSHADER_astExpressionTernary() {
2742 assert_eq!(
2743 ::std::mem::size_of::<MOJOSHADER_astExpressionTernary>(),
2744 56usize,
2745 concat!("Size of: ", stringify!(MOJOSHADER_astExpressionTernary))
2746 );
2747 assert_eq!(
2748 ::std::mem::align_of::<MOJOSHADER_astExpressionTernary>(),
2749 8usize,
2750 concat!("Alignment of ", stringify!(MOJOSHADER_astExpressionTernary))
2751 );
2752 assert_eq!(
2753 unsafe {
2754 &(*(::std::ptr::null::<MOJOSHADER_astExpressionTernary>())).ast as *const _ as usize
2755 },
2756 0usize,
2757 concat!(
2758 "Offset of field: ",
2759 stringify!(MOJOSHADER_astExpressionTernary),
2760 "::",
2761 stringify!(ast)
2762 )
2763 );
2764 assert_eq!(
2765 unsafe {
2766 &(*(::std::ptr::null::<MOJOSHADER_astExpressionTernary>())).datatype as *const _
2767 as usize
2768 },
2769 24usize,
2770 concat!(
2771 "Offset of field: ",
2772 stringify!(MOJOSHADER_astExpressionTernary),
2773 "::",
2774 stringify!(datatype)
2775 )
2776 );
2777 assert_eq!(
2778 unsafe {
2779 &(*(::std::ptr::null::<MOJOSHADER_astExpressionTernary>())).left as *const _ as usize
2780 },
2781 32usize,
2782 concat!(
2783 "Offset of field: ",
2784 stringify!(MOJOSHADER_astExpressionTernary),
2785 "::",
2786 stringify!(left)
2787 )
2788 );
2789 assert_eq!(
2790 unsafe {
2791 &(*(::std::ptr::null::<MOJOSHADER_astExpressionTernary>())).center as *const _ as usize
2792 },
2793 40usize,
2794 concat!(
2795 "Offset of field: ",
2796 stringify!(MOJOSHADER_astExpressionTernary),
2797 "::",
2798 stringify!(center)
2799 )
2800 );
2801 assert_eq!(
2802 unsafe {
2803 &(*(::std::ptr::null::<MOJOSHADER_astExpressionTernary>())).right as *const _ as usize
2804 },
2805 48usize,
2806 concat!(
2807 "Offset of field: ",
2808 stringify!(MOJOSHADER_astExpressionTernary),
2809 "::",
2810 stringify!(right)
2811 )
2812 );
2813}
2814#[repr(C)]
2815#[derive(Debug, Copy, Clone)]
2816pub struct MOJOSHADER_astExpressionIdentifier {
2817 pub ast: MOJOSHADER_astNodeInfo,
2818 pub datatype: *const MOJOSHADER_astDataType,
2819 pub identifier: *const ::std::os::raw::c_char,
2820 pub index: ::std::os::raw::c_int,
2821}
2822#[test]
2823fn bindgen_test_layout_MOJOSHADER_astExpressionIdentifier() {
2824 assert_eq!(
2825 ::std::mem::size_of::<MOJOSHADER_astExpressionIdentifier>(),
2826 48usize,
2827 concat!("Size of: ", stringify!(MOJOSHADER_astExpressionIdentifier))
2828 );
2829 assert_eq!(
2830 ::std::mem::align_of::<MOJOSHADER_astExpressionIdentifier>(),
2831 8usize,
2832 concat!(
2833 "Alignment of ",
2834 stringify!(MOJOSHADER_astExpressionIdentifier)
2835 )
2836 );
2837 assert_eq!(
2838 unsafe {
2839 &(*(::std::ptr::null::<MOJOSHADER_astExpressionIdentifier>())).ast as *const _ as usize
2840 },
2841 0usize,
2842 concat!(
2843 "Offset of field: ",
2844 stringify!(MOJOSHADER_astExpressionIdentifier),
2845 "::",
2846 stringify!(ast)
2847 )
2848 );
2849 assert_eq!(
2850 unsafe {
2851 &(*(::std::ptr::null::<MOJOSHADER_astExpressionIdentifier>())).datatype as *const _
2852 as usize
2853 },
2854 24usize,
2855 concat!(
2856 "Offset of field: ",
2857 stringify!(MOJOSHADER_astExpressionIdentifier),
2858 "::",
2859 stringify!(datatype)
2860 )
2861 );
2862 assert_eq!(
2863 unsafe {
2864 &(*(::std::ptr::null::<MOJOSHADER_astExpressionIdentifier>())).identifier as *const _
2865 as usize
2866 },
2867 32usize,
2868 concat!(
2869 "Offset of field: ",
2870 stringify!(MOJOSHADER_astExpressionIdentifier),
2871 "::",
2872 stringify!(identifier)
2873 )
2874 );
2875 assert_eq!(
2876 unsafe {
2877 &(*(::std::ptr::null::<MOJOSHADER_astExpressionIdentifier>())).index as *const _
2878 as usize
2879 },
2880 40usize,
2881 concat!(
2882 "Offset of field: ",
2883 stringify!(MOJOSHADER_astExpressionIdentifier),
2884 "::",
2885 stringify!(index)
2886 )
2887 );
2888}
2889#[repr(C)]
2890#[derive(Debug, Copy, Clone)]
2891pub struct MOJOSHADER_astExpressionIntLiteral {
2892 pub ast: MOJOSHADER_astNodeInfo,
2893 pub datatype: *const MOJOSHADER_astDataType,
2894 pub value: ::std::os::raw::c_int,
2895}
2896#[test]
2897fn bindgen_test_layout_MOJOSHADER_astExpressionIntLiteral() {
2898 assert_eq!(
2899 ::std::mem::size_of::<MOJOSHADER_astExpressionIntLiteral>(),
2900 40usize,
2901 concat!("Size of: ", stringify!(MOJOSHADER_astExpressionIntLiteral))
2902 );
2903 assert_eq!(
2904 ::std::mem::align_of::<MOJOSHADER_astExpressionIntLiteral>(),
2905 8usize,
2906 concat!(
2907 "Alignment of ",
2908 stringify!(MOJOSHADER_astExpressionIntLiteral)
2909 )
2910 );
2911 assert_eq!(
2912 unsafe {
2913 &(*(::std::ptr::null::<MOJOSHADER_astExpressionIntLiteral>())).ast as *const _ as usize
2914 },
2915 0usize,
2916 concat!(
2917 "Offset of field: ",
2918 stringify!(MOJOSHADER_astExpressionIntLiteral),
2919 "::",
2920 stringify!(ast)
2921 )
2922 );
2923 assert_eq!(
2924 unsafe {
2925 &(*(::std::ptr::null::<MOJOSHADER_astExpressionIntLiteral>())).datatype as *const _
2926 as usize
2927 },
2928 24usize,
2929 concat!(
2930 "Offset of field: ",
2931 stringify!(MOJOSHADER_astExpressionIntLiteral),
2932 "::",
2933 stringify!(datatype)
2934 )
2935 );
2936 assert_eq!(
2937 unsafe {
2938 &(*(::std::ptr::null::<MOJOSHADER_astExpressionIntLiteral>())).value as *const _
2939 as usize
2940 },
2941 32usize,
2942 concat!(
2943 "Offset of field: ",
2944 stringify!(MOJOSHADER_astExpressionIntLiteral),
2945 "::",
2946 stringify!(value)
2947 )
2948 );
2949}
2950#[repr(C)]
2951#[derive(Debug, Copy, Clone)]
2952pub struct MOJOSHADER_astExpressionFloatLiteral {
2953 pub ast: MOJOSHADER_astNodeInfo,
2954 pub datatype: *const MOJOSHADER_astDataType,
2955 pub value: f64,
2956}
2957#[test]
2958fn bindgen_test_layout_MOJOSHADER_astExpressionFloatLiteral() {
2959 assert_eq!(
2960 ::std::mem::size_of::<MOJOSHADER_astExpressionFloatLiteral>(),
2961 40usize,
2962 concat!(
2963 "Size of: ",
2964 stringify!(MOJOSHADER_astExpressionFloatLiteral)
2965 )
2966 );
2967 assert_eq!(
2968 ::std::mem::align_of::<MOJOSHADER_astExpressionFloatLiteral>(),
2969 8usize,
2970 concat!(
2971 "Alignment of ",
2972 stringify!(MOJOSHADER_astExpressionFloatLiteral)
2973 )
2974 );
2975 assert_eq!(
2976 unsafe {
2977 &(*(::std::ptr::null::<MOJOSHADER_astExpressionFloatLiteral>())).ast as *const _
2978 as usize
2979 },
2980 0usize,
2981 concat!(
2982 "Offset of field: ",
2983 stringify!(MOJOSHADER_astExpressionFloatLiteral),
2984 "::",
2985 stringify!(ast)
2986 )
2987 );
2988 assert_eq!(
2989 unsafe {
2990 &(*(::std::ptr::null::<MOJOSHADER_astExpressionFloatLiteral>())).datatype as *const _
2991 as usize
2992 },
2993 24usize,
2994 concat!(
2995 "Offset of field: ",
2996 stringify!(MOJOSHADER_astExpressionFloatLiteral),
2997 "::",
2998 stringify!(datatype)
2999 )
3000 );
3001 assert_eq!(
3002 unsafe {
3003 &(*(::std::ptr::null::<MOJOSHADER_astExpressionFloatLiteral>())).value as *const _
3004 as usize
3005 },
3006 32usize,
3007 concat!(
3008 "Offset of field: ",
3009 stringify!(MOJOSHADER_astExpressionFloatLiteral),
3010 "::",
3011 stringify!(value)
3012 )
3013 );
3014}
3015#[repr(C)]
3016#[derive(Debug, Copy, Clone)]
3017pub struct MOJOSHADER_astExpressionStringLiteral {
3018 pub ast: MOJOSHADER_astNodeInfo,
3019 pub datatype: *const MOJOSHADER_astDataType,
3020 pub string: *const ::std::os::raw::c_char,
3021}
3022#[test]
3023fn bindgen_test_layout_MOJOSHADER_astExpressionStringLiteral() {
3024 assert_eq!(
3025 ::std::mem::size_of::<MOJOSHADER_astExpressionStringLiteral>(),
3026 40usize,
3027 concat!(
3028 "Size of: ",
3029 stringify!(MOJOSHADER_astExpressionStringLiteral)
3030 )
3031 );
3032 assert_eq!(
3033 ::std::mem::align_of::<MOJOSHADER_astExpressionStringLiteral>(),
3034 8usize,
3035 concat!(
3036 "Alignment of ",
3037 stringify!(MOJOSHADER_astExpressionStringLiteral)
3038 )
3039 );
3040 assert_eq!(
3041 unsafe {
3042 &(*(::std::ptr::null::<MOJOSHADER_astExpressionStringLiteral>())).ast as *const _
3043 as usize
3044 },
3045 0usize,
3046 concat!(
3047 "Offset of field: ",
3048 stringify!(MOJOSHADER_astExpressionStringLiteral),
3049 "::",
3050 stringify!(ast)
3051 )
3052 );
3053 assert_eq!(
3054 unsafe {
3055 &(*(::std::ptr::null::<MOJOSHADER_astExpressionStringLiteral>())).datatype as *const _
3056 as usize
3057 },
3058 24usize,
3059 concat!(
3060 "Offset of field: ",
3061 stringify!(MOJOSHADER_astExpressionStringLiteral),
3062 "::",
3063 stringify!(datatype)
3064 )
3065 );
3066 assert_eq!(
3067 unsafe {
3068 &(*(::std::ptr::null::<MOJOSHADER_astExpressionStringLiteral>())).string as *const _
3069 as usize
3070 },
3071 32usize,
3072 concat!(
3073 "Offset of field: ",
3074 stringify!(MOJOSHADER_astExpressionStringLiteral),
3075 "::",
3076 stringify!(string)
3077 )
3078 );
3079}
3080#[repr(C)]
3081#[derive(Debug, Copy, Clone)]
3082pub struct MOJOSHADER_astExpressionBooleanLiteral {
3083 pub ast: MOJOSHADER_astNodeInfo,
3084 pub datatype: *const MOJOSHADER_astDataType,
3085 pub value: ::std::os::raw::c_int,
3086}
3087#[test]
3088fn bindgen_test_layout_MOJOSHADER_astExpressionBooleanLiteral() {
3089 assert_eq!(
3090 ::std::mem::size_of::<MOJOSHADER_astExpressionBooleanLiteral>(),
3091 40usize,
3092 concat!(
3093 "Size of: ",
3094 stringify!(MOJOSHADER_astExpressionBooleanLiteral)
3095 )
3096 );
3097 assert_eq!(
3098 ::std::mem::align_of::<MOJOSHADER_astExpressionBooleanLiteral>(),
3099 8usize,
3100 concat!(
3101 "Alignment of ",
3102 stringify!(MOJOSHADER_astExpressionBooleanLiteral)
3103 )
3104 );
3105 assert_eq!(
3106 unsafe {
3107 &(*(::std::ptr::null::<MOJOSHADER_astExpressionBooleanLiteral>())).ast as *const _
3108 as usize
3109 },
3110 0usize,
3111 concat!(
3112 "Offset of field: ",
3113 stringify!(MOJOSHADER_astExpressionBooleanLiteral),
3114 "::",
3115 stringify!(ast)
3116 )
3117 );
3118 assert_eq!(
3119 unsafe {
3120 &(*(::std::ptr::null::<MOJOSHADER_astExpressionBooleanLiteral>())).datatype as *const _
3121 as usize
3122 },
3123 24usize,
3124 concat!(
3125 "Offset of field: ",
3126 stringify!(MOJOSHADER_astExpressionBooleanLiteral),
3127 "::",
3128 stringify!(datatype)
3129 )
3130 );
3131 assert_eq!(
3132 unsafe {
3133 &(*(::std::ptr::null::<MOJOSHADER_astExpressionBooleanLiteral>())).value as *const _
3134 as usize
3135 },
3136 32usize,
3137 concat!(
3138 "Offset of field: ",
3139 stringify!(MOJOSHADER_astExpressionBooleanLiteral),
3140 "::",
3141 stringify!(value)
3142 )
3143 );
3144}
3145#[repr(C)]
3146#[derive(Debug, Copy, Clone)]
3147pub struct MOJOSHADER_astExpressionConstructor {
3148 pub ast: MOJOSHADER_astNodeInfo,
3149 pub datatype: *const MOJOSHADER_astDataType,
3150 pub args: *mut MOJOSHADER_astArguments,
3151}
3152#[test]
3153fn bindgen_test_layout_MOJOSHADER_astExpressionConstructor() {
3154 assert_eq!(
3155 ::std::mem::size_of::<MOJOSHADER_astExpressionConstructor>(),
3156 40usize,
3157 concat!("Size of: ", stringify!(MOJOSHADER_astExpressionConstructor))
3158 );
3159 assert_eq!(
3160 ::std::mem::align_of::<MOJOSHADER_astExpressionConstructor>(),
3161 8usize,
3162 concat!(
3163 "Alignment of ",
3164 stringify!(MOJOSHADER_astExpressionConstructor)
3165 )
3166 );
3167 assert_eq!(
3168 unsafe {
3169 &(*(::std::ptr::null::<MOJOSHADER_astExpressionConstructor>())).ast as *const _ as usize
3170 },
3171 0usize,
3172 concat!(
3173 "Offset of field: ",
3174 stringify!(MOJOSHADER_astExpressionConstructor),
3175 "::",
3176 stringify!(ast)
3177 )
3178 );
3179 assert_eq!(
3180 unsafe {
3181 &(*(::std::ptr::null::<MOJOSHADER_astExpressionConstructor>())).datatype as *const _
3182 as usize
3183 },
3184 24usize,
3185 concat!(
3186 "Offset of field: ",
3187 stringify!(MOJOSHADER_astExpressionConstructor),
3188 "::",
3189 stringify!(datatype)
3190 )
3191 );
3192 assert_eq!(
3193 unsafe {
3194 &(*(::std::ptr::null::<MOJOSHADER_astExpressionConstructor>())).args as *const _
3195 as usize
3196 },
3197 32usize,
3198 concat!(
3199 "Offset of field: ",
3200 stringify!(MOJOSHADER_astExpressionConstructor),
3201 "::",
3202 stringify!(args)
3203 )
3204 );
3205}
3206#[repr(C)]
3207#[derive(Debug, Copy, Clone)]
3208pub struct MOJOSHADER_astExpressionDerefStruct {
3209 pub ast: MOJOSHADER_astNodeInfo,
3210 pub datatype: *const MOJOSHADER_astDataType,
3211 pub identifier: *mut MOJOSHADER_astExpression,
3212 pub member: *const ::std::os::raw::c_char,
3213 pub isswizzle: ::std::os::raw::c_int,
3214 pub member_index: ::std::os::raw::c_int,
3215}
3216#[test]
3217fn bindgen_test_layout_MOJOSHADER_astExpressionDerefStruct() {
3218 assert_eq!(
3219 ::std::mem::size_of::<MOJOSHADER_astExpressionDerefStruct>(),
3220 56usize,
3221 concat!("Size of: ", stringify!(MOJOSHADER_astExpressionDerefStruct))
3222 );
3223 assert_eq!(
3224 ::std::mem::align_of::<MOJOSHADER_astExpressionDerefStruct>(),
3225 8usize,
3226 concat!(
3227 "Alignment of ",
3228 stringify!(MOJOSHADER_astExpressionDerefStruct)
3229 )
3230 );
3231 assert_eq!(
3232 unsafe {
3233 &(*(::std::ptr::null::<MOJOSHADER_astExpressionDerefStruct>())).ast as *const _ as usize
3234 },
3235 0usize,
3236 concat!(
3237 "Offset of field: ",
3238 stringify!(MOJOSHADER_astExpressionDerefStruct),
3239 "::",
3240 stringify!(ast)
3241 )
3242 );
3243 assert_eq!(
3244 unsafe {
3245 &(*(::std::ptr::null::<MOJOSHADER_astExpressionDerefStruct>())).datatype as *const _
3246 as usize
3247 },
3248 24usize,
3249 concat!(
3250 "Offset of field: ",
3251 stringify!(MOJOSHADER_astExpressionDerefStruct),
3252 "::",
3253 stringify!(datatype)
3254 )
3255 );
3256 assert_eq!(
3257 unsafe {
3258 &(*(::std::ptr::null::<MOJOSHADER_astExpressionDerefStruct>())).identifier as *const _
3259 as usize
3260 },
3261 32usize,
3262 concat!(
3263 "Offset of field: ",
3264 stringify!(MOJOSHADER_astExpressionDerefStruct),
3265 "::",
3266 stringify!(identifier)
3267 )
3268 );
3269 assert_eq!(
3270 unsafe {
3271 &(*(::std::ptr::null::<MOJOSHADER_astExpressionDerefStruct>())).member as *const _
3272 as usize
3273 },
3274 40usize,
3275 concat!(
3276 "Offset of field: ",
3277 stringify!(MOJOSHADER_astExpressionDerefStruct),
3278 "::",
3279 stringify!(member)
3280 )
3281 );
3282 assert_eq!(
3283 unsafe {
3284 &(*(::std::ptr::null::<MOJOSHADER_astExpressionDerefStruct>())).isswizzle as *const _
3285 as usize
3286 },
3287 48usize,
3288 concat!(
3289 "Offset of field: ",
3290 stringify!(MOJOSHADER_astExpressionDerefStruct),
3291 "::",
3292 stringify!(isswizzle)
3293 )
3294 );
3295 assert_eq!(
3296 unsafe {
3297 &(*(::std::ptr::null::<MOJOSHADER_astExpressionDerefStruct>())).member_index as *const _
3298 as usize
3299 },
3300 52usize,
3301 concat!(
3302 "Offset of field: ",
3303 stringify!(MOJOSHADER_astExpressionDerefStruct),
3304 "::",
3305 stringify!(member_index)
3306 )
3307 );
3308}
3309#[repr(C)]
3310#[derive(Debug, Copy, Clone)]
3311pub struct MOJOSHADER_astExpressionCallFunction {
3312 pub ast: MOJOSHADER_astNodeInfo,
3313 pub datatype: *const MOJOSHADER_astDataType,
3314 pub identifier: *mut MOJOSHADER_astExpressionIdentifier,
3315 pub args: *mut MOJOSHADER_astArguments,
3316}
3317#[test]
3318fn bindgen_test_layout_MOJOSHADER_astExpressionCallFunction() {
3319 assert_eq!(
3320 ::std::mem::size_of::<MOJOSHADER_astExpressionCallFunction>(),
3321 48usize,
3322 concat!(
3323 "Size of: ",
3324 stringify!(MOJOSHADER_astExpressionCallFunction)
3325 )
3326 );
3327 assert_eq!(
3328 ::std::mem::align_of::<MOJOSHADER_astExpressionCallFunction>(),
3329 8usize,
3330 concat!(
3331 "Alignment of ",
3332 stringify!(MOJOSHADER_astExpressionCallFunction)
3333 )
3334 );
3335 assert_eq!(
3336 unsafe {
3337 &(*(::std::ptr::null::<MOJOSHADER_astExpressionCallFunction>())).ast as *const _
3338 as usize
3339 },
3340 0usize,
3341 concat!(
3342 "Offset of field: ",
3343 stringify!(MOJOSHADER_astExpressionCallFunction),
3344 "::",
3345 stringify!(ast)
3346 )
3347 );
3348 assert_eq!(
3349 unsafe {
3350 &(*(::std::ptr::null::<MOJOSHADER_astExpressionCallFunction>())).datatype as *const _
3351 as usize
3352 },
3353 24usize,
3354 concat!(
3355 "Offset of field: ",
3356 stringify!(MOJOSHADER_astExpressionCallFunction),
3357 "::",
3358 stringify!(datatype)
3359 )
3360 );
3361 assert_eq!(
3362 unsafe {
3363 &(*(::std::ptr::null::<MOJOSHADER_astExpressionCallFunction>())).identifier as *const _
3364 as usize
3365 },
3366 32usize,
3367 concat!(
3368 "Offset of field: ",
3369 stringify!(MOJOSHADER_astExpressionCallFunction),
3370 "::",
3371 stringify!(identifier)
3372 )
3373 );
3374 assert_eq!(
3375 unsafe {
3376 &(*(::std::ptr::null::<MOJOSHADER_astExpressionCallFunction>())).args as *const _
3377 as usize
3378 },
3379 40usize,
3380 concat!(
3381 "Offset of field: ",
3382 stringify!(MOJOSHADER_astExpressionCallFunction),
3383 "::",
3384 stringify!(args)
3385 )
3386 );
3387}
3388#[repr(C)]
3389#[derive(Debug, Copy, Clone)]
3390pub struct MOJOSHADER_astExpressionCast {
3391 pub ast: MOJOSHADER_astNodeInfo,
3392 pub datatype: *const MOJOSHADER_astDataType,
3393 pub operand: *mut MOJOSHADER_astExpression,
3394}
3395#[test]
3396fn bindgen_test_layout_MOJOSHADER_astExpressionCast() {
3397 assert_eq!(
3398 ::std::mem::size_of::<MOJOSHADER_astExpressionCast>(),
3399 40usize,
3400 concat!("Size of: ", stringify!(MOJOSHADER_astExpressionCast))
3401 );
3402 assert_eq!(
3403 ::std::mem::align_of::<MOJOSHADER_astExpressionCast>(),
3404 8usize,
3405 concat!("Alignment of ", stringify!(MOJOSHADER_astExpressionCast))
3406 );
3407 assert_eq!(
3408 unsafe {
3409 &(*(::std::ptr::null::<MOJOSHADER_astExpressionCast>())).ast as *const _ as usize
3410 },
3411 0usize,
3412 concat!(
3413 "Offset of field: ",
3414 stringify!(MOJOSHADER_astExpressionCast),
3415 "::",
3416 stringify!(ast)
3417 )
3418 );
3419 assert_eq!(
3420 unsafe {
3421 &(*(::std::ptr::null::<MOJOSHADER_astExpressionCast>())).datatype as *const _ as usize
3422 },
3423 24usize,
3424 concat!(
3425 "Offset of field: ",
3426 stringify!(MOJOSHADER_astExpressionCast),
3427 "::",
3428 stringify!(datatype)
3429 )
3430 );
3431 assert_eq!(
3432 unsafe {
3433 &(*(::std::ptr::null::<MOJOSHADER_astExpressionCast>())).operand as *const _ as usize
3434 },
3435 32usize,
3436 concat!(
3437 "Offset of field: ",
3438 stringify!(MOJOSHADER_astExpressionCast),
3439 "::",
3440 stringify!(operand)
3441 )
3442 );
3443}
3444#[repr(C)]
3445#[derive(Debug, Copy, Clone)]
3446pub struct MOJOSHADER_astCompilationUnit {
3447 pub ast: MOJOSHADER_astNodeInfo,
3448 pub next: *mut MOJOSHADER_astCompilationUnit,
3449}
3450#[test]
3451fn bindgen_test_layout_MOJOSHADER_astCompilationUnit() {
3452 assert_eq!(
3453 ::std::mem::size_of::<MOJOSHADER_astCompilationUnit>(),
3454 32usize,
3455 concat!("Size of: ", stringify!(MOJOSHADER_astCompilationUnit))
3456 );
3457 assert_eq!(
3458 ::std::mem::align_of::<MOJOSHADER_astCompilationUnit>(),
3459 8usize,
3460 concat!("Alignment of ", stringify!(MOJOSHADER_astCompilationUnit))
3461 );
3462 assert_eq!(
3463 unsafe {
3464 &(*(::std::ptr::null::<MOJOSHADER_astCompilationUnit>())).ast as *const _ as usize
3465 },
3466 0usize,
3467 concat!(
3468 "Offset of field: ",
3469 stringify!(MOJOSHADER_astCompilationUnit),
3470 "::",
3471 stringify!(ast)
3472 )
3473 );
3474 assert_eq!(
3475 unsafe {
3476 &(*(::std::ptr::null::<MOJOSHADER_astCompilationUnit>())).next as *const _ as usize
3477 },
3478 24usize,
3479 concat!(
3480 "Offset of field: ",
3481 stringify!(MOJOSHADER_astCompilationUnit),
3482 "::",
3483 stringify!(next)
3484 )
3485 );
3486}
3487pub const MOJOSHADER_astFunctionStorageClass_MOJOSHADER_AST_FNSTORECLS_NONE:
3488 MOJOSHADER_astFunctionStorageClass = 0;
3489pub const MOJOSHADER_astFunctionStorageClass_MOJOSHADER_AST_FNSTORECLS_INLINE:
3490 MOJOSHADER_astFunctionStorageClass = 1;
3491pub type MOJOSHADER_astFunctionStorageClass = ::std::os::raw::c_uint;
3492pub const MOJOSHADER_astInputModifier_MOJOSHADER_AST_INPUTMOD_NONE: MOJOSHADER_astInputModifier = 0;
3493pub const MOJOSHADER_astInputModifier_MOJOSHADER_AST_INPUTMOD_IN: MOJOSHADER_astInputModifier = 1;
3494pub const MOJOSHADER_astInputModifier_MOJOSHADER_AST_INPUTMOD_OUT: MOJOSHADER_astInputModifier = 2;
3495pub const MOJOSHADER_astInputModifier_MOJOSHADER_AST_INPUTMOD_INOUT: MOJOSHADER_astInputModifier =
3496 3;
3497pub const MOJOSHADER_astInputModifier_MOJOSHADER_AST_INPUTMOD_UNIFORM: MOJOSHADER_astInputModifier =
3498 4;
3499pub type MOJOSHADER_astInputModifier = ::std::os::raw::c_uint;
3500pub const MOJOSHADER_astInterpolationModifier_MOJOSHADER_AST_INTERPMOD_NONE:
3501 MOJOSHADER_astInterpolationModifier = 0;
3502pub const MOJOSHADER_astInterpolationModifier_MOJOSHADER_AST_INTERPMOD_LINEAR:
3503 MOJOSHADER_astInterpolationModifier = 1;
3504pub const MOJOSHADER_astInterpolationModifier_MOJOSHADER_AST_INTERPMOD_CENTROID:
3505 MOJOSHADER_astInterpolationModifier = 2;
3506pub const MOJOSHADER_astInterpolationModifier_MOJOSHADER_AST_INTERPMOD_NOINTERPOLATION:
3507 MOJOSHADER_astInterpolationModifier = 3;
3508pub const MOJOSHADER_astInterpolationModifier_MOJOSHADER_AST_INTERPMOD_NOPERSPECTIVE:
3509 MOJOSHADER_astInterpolationModifier = 4;
3510pub const MOJOSHADER_astInterpolationModifier_MOJOSHADER_AST_INTERPMOD_SAMPLE:
3511 MOJOSHADER_astInterpolationModifier = 5;
3512pub type MOJOSHADER_astInterpolationModifier = ::std::os::raw::c_uint;
3513#[repr(C)]
3514#[derive(Debug, Copy, Clone)]
3515pub struct MOJOSHADER_astFunctionParameters {
3516 pub ast: MOJOSHADER_astNodeInfo,
3517 pub datatype: *const MOJOSHADER_astDataType,
3518 pub input_modifier: MOJOSHADER_astInputModifier,
3519 pub identifier: *const ::std::os::raw::c_char,
3520 pub semantic: *const ::std::os::raw::c_char,
3521 pub interpolation_modifier: MOJOSHADER_astInterpolationModifier,
3522 pub initializer: *mut MOJOSHADER_astExpression,
3523 pub next: *mut MOJOSHADER_astFunctionParameters,
3524}
3525#[test]
3526fn bindgen_test_layout_MOJOSHADER_astFunctionParameters() {
3527 assert_eq!(
3528 ::std::mem::size_of::<MOJOSHADER_astFunctionParameters>(),
3529 80usize,
3530 concat!("Size of: ", stringify!(MOJOSHADER_astFunctionParameters))
3531 );
3532 assert_eq!(
3533 ::std::mem::align_of::<MOJOSHADER_astFunctionParameters>(),
3534 8usize,
3535 concat!(
3536 "Alignment of ",
3537 stringify!(MOJOSHADER_astFunctionParameters)
3538 )
3539 );
3540 assert_eq!(
3541 unsafe {
3542 &(*(::std::ptr::null::<MOJOSHADER_astFunctionParameters>())).ast as *const _ as usize
3543 },
3544 0usize,
3545 concat!(
3546 "Offset of field: ",
3547 stringify!(MOJOSHADER_astFunctionParameters),
3548 "::",
3549 stringify!(ast)
3550 )
3551 );
3552 assert_eq!(
3553 unsafe {
3554 &(*(::std::ptr::null::<MOJOSHADER_astFunctionParameters>())).datatype as *const _
3555 as usize
3556 },
3557 24usize,
3558 concat!(
3559 "Offset of field: ",
3560 stringify!(MOJOSHADER_astFunctionParameters),
3561 "::",
3562 stringify!(datatype)
3563 )
3564 );
3565 assert_eq!(
3566 unsafe {
3567 &(*(::std::ptr::null::<MOJOSHADER_astFunctionParameters>())).input_modifier as *const _
3568 as usize
3569 },
3570 32usize,
3571 concat!(
3572 "Offset of field: ",
3573 stringify!(MOJOSHADER_astFunctionParameters),
3574 "::",
3575 stringify!(input_modifier)
3576 )
3577 );
3578 assert_eq!(
3579 unsafe {
3580 &(*(::std::ptr::null::<MOJOSHADER_astFunctionParameters>())).identifier as *const _
3581 as usize
3582 },
3583 40usize,
3584 concat!(
3585 "Offset of field: ",
3586 stringify!(MOJOSHADER_astFunctionParameters),
3587 "::",
3588 stringify!(identifier)
3589 )
3590 );
3591 assert_eq!(
3592 unsafe {
3593 &(*(::std::ptr::null::<MOJOSHADER_astFunctionParameters>())).semantic as *const _
3594 as usize
3595 },
3596 48usize,
3597 concat!(
3598 "Offset of field: ",
3599 stringify!(MOJOSHADER_astFunctionParameters),
3600 "::",
3601 stringify!(semantic)
3602 )
3603 );
3604 assert_eq!(
3605 unsafe {
3606 &(*(::std::ptr::null::<MOJOSHADER_astFunctionParameters>())).interpolation_modifier
3607 as *const _ as usize
3608 },
3609 56usize,
3610 concat!(
3611 "Offset of field: ",
3612 stringify!(MOJOSHADER_astFunctionParameters),
3613 "::",
3614 stringify!(interpolation_modifier)
3615 )
3616 );
3617 assert_eq!(
3618 unsafe {
3619 &(*(::std::ptr::null::<MOJOSHADER_astFunctionParameters>())).initializer as *const _
3620 as usize
3621 },
3622 64usize,
3623 concat!(
3624 "Offset of field: ",
3625 stringify!(MOJOSHADER_astFunctionParameters),
3626 "::",
3627 stringify!(initializer)
3628 )
3629 );
3630 assert_eq!(
3631 unsafe {
3632 &(*(::std::ptr::null::<MOJOSHADER_astFunctionParameters>())).next as *const _ as usize
3633 },
3634 72usize,
3635 concat!(
3636 "Offset of field: ",
3637 stringify!(MOJOSHADER_astFunctionParameters),
3638 "::",
3639 stringify!(next)
3640 )
3641 );
3642}
3643#[repr(C)]
3644#[derive(Debug, Copy, Clone)]
3645pub struct MOJOSHADER_astFunctionSignature {
3646 pub ast: MOJOSHADER_astNodeInfo,
3647 pub datatype: *const MOJOSHADER_astDataType,
3648 pub identifier: *const ::std::os::raw::c_char,
3649 pub params: *mut MOJOSHADER_astFunctionParameters,
3650 pub storage_class: MOJOSHADER_astFunctionStorageClass,
3651 pub semantic: *const ::std::os::raw::c_char,
3652}
3653#[test]
3654fn bindgen_test_layout_MOJOSHADER_astFunctionSignature() {
3655 assert_eq!(
3656 ::std::mem::size_of::<MOJOSHADER_astFunctionSignature>(),
3657 64usize,
3658 concat!("Size of: ", stringify!(MOJOSHADER_astFunctionSignature))
3659 );
3660 assert_eq!(
3661 ::std::mem::align_of::<MOJOSHADER_astFunctionSignature>(),
3662 8usize,
3663 concat!("Alignment of ", stringify!(MOJOSHADER_astFunctionSignature))
3664 );
3665 assert_eq!(
3666 unsafe {
3667 &(*(::std::ptr::null::<MOJOSHADER_astFunctionSignature>())).ast as *const _ as usize
3668 },
3669 0usize,
3670 concat!(
3671 "Offset of field: ",
3672 stringify!(MOJOSHADER_astFunctionSignature),
3673 "::",
3674 stringify!(ast)
3675 )
3676 );
3677 assert_eq!(
3678 unsafe {
3679 &(*(::std::ptr::null::<MOJOSHADER_astFunctionSignature>())).datatype as *const _
3680 as usize
3681 },
3682 24usize,
3683 concat!(
3684 "Offset of field: ",
3685 stringify!(MOJOSHADER_astFunctionSignature),
3686 "::",
3687 stringify!(datatype)
3688 )
3689 );
3690 assert_eq!(
3691 unsafe {
3692 &(*(::std::ptr::null::<MOJOSHADER_astFunctionSignature>())).identifier as *const _
3693 as usize
3694 },
3695 32usize,
3696 concat!(
3697 "Offset of field: ",
3698 stringify!(MOJOSHADER_astFunctionSignature),
3699 "::",
3700 stringify!(identifier)
3701 )
3702 );
3703 assert_eq!(
3704 unsafe {
3705 &(*(::std::ptr::null::<MOJOSHADER_astFunctionSignature>())).params as *const _ as usize
3706 },
3707 40usize,
3708 concat!(
3709 "Offset of field: ",
3710 stringify!(MOJOSHADER_astFunctionSignature),
3711 "::",
3712 stringify!(params)
3713 )
3714 );
3715 assert_eq!(
3716 unsafe {
3717 &(*(::std::ptr::null::<MOJOSHADER_astFunctionSignature>())).storage_class as *const _
3718 as usize
3719 },
3720 48usize,
3721 concat!(
3722 "Offset of field: ",
3723 stringify!(MOJOSHADER_astFunctionSignature),
3724 "::",
3725 stringify!(storage_class)
3726 )
3727 );
3728 assert_eq!(
3729 unsafe {
3730 &(*(::std::ptr::null::<MOJOSHADER_astFunctionSignature>())).semantic as *const _
3731 as usize
3732 },
3733 56usize,
3734 concat!(
3735 "Offset of field: ",
3736 stringify!(MOJOSHADER_astFunctionSignature),
3737 "::",
3738 stringify!(semantic)
3739 )
3740 );
3741}
3742#[repr(C)]
3743#[derive(Debug, Copy, Clone)]
3744pub struct MOJOSHADER_astScalarOrArray {
3745 pub ast: MOJOSHADER_astNodeInfo,
3746 pub identifier: *const ::std::os::raw::c_char,
3747 pub isarray: ::std::os::raw::c_int,
3748 pub dimension: *mut MOJOSHADER_astExpression,
3749}
3750#[test]
3751fn bindgen_test_layout_MOJOSHADER_astScalarOrArray() {
3752 assert_eq!(
3753 ::std::mem::size_of::<MOJOSHADER_astScalarOrArray>(),
3754 48usize,
3755 concat!("Size of: ", stringify!(MOJOSHADER_astScalarOrArray))
3756 );
3757 assert_eq!(
3758 ::std::mem::align_of::<MOJOSHADER_astScalarOrArray>(),
3759 8usize,
3760 concat!("Alignment of ", stringify!(MOJOSHADER_astScalarOrArray))
3761 );
3762 assert_eq!(
3763 unsafe { &(*(::std::ptr::null::<MOJOSHADER_astScalarOrArray>())).ast as *const _ as usize },
3764 0usize,
3765 concat!(
3766 "Offset of field: ",
3767 stringify!(MOJOSHADER_astScalarOrArray),
3768 "::",
3769 stringify!(ast)
3770 )
3771 );
3772 assert_eq!(
3773 unsafe {
3774 &(*(::std::ptr::null::<MOJOSHADER_astScalarOrArray>())).identifier as *const _ as usize
3775 },
3776 24usize,
3777 concat!(
3778 "Offset of field: ",
3779 stringify!(MOJOSHADER_astScalarOrArray),
3780 "::",
3781 stringify!(identifier)
3782 )
3783 );
3784 assert_eq!(
3785 unsafe {
3786 &(*(::std::ptr::null::<MOJOSHADER_astScalarOrArray>())).isarray as *const _ as usize
3787 },
3788 32usize,
3789 concat!(
3790 "Offset of field: ",
3791 stringify!(MOJOSHADER_astScalarOrArray),
3792 "::",
3793 stringify!(isarray)
3794 )
3795 );
3796 assert_eq!(
3797 unsafe {
3798 &(*(::std::ptr::null::<MOJOSHADER_astScalarOrArray>())).dimension as *const _ as usize
3799 },
3800 40usize,
3801 concat!(
3802 "Offset of field: ",
3803 stringify!(MOJOSHADER_astScalarOrArray),
3804 "::",
3805 stringify!(dimension)
3806 )
3807 );
3808}
3809#[repr(C)]
3810#[derive(Debug, Copy, Clone)]
3811pub struct MOJOSHADER_astAnnotations {
3812 pub ast: MOJOSHADER_astNodeInfo,
3813 pub datatype: *const MOJOSHADER_astDataType,
3814 pub initializer: *mut MOJOSHADER_astExpression,
3815 pub next: *mut MOJOSHADER_astAnnotations,
3816}
3817#[test]
3818fn bindgen_test_layout_MOJOSHADER_astAnnotations() {
3819 assert_eq!(
3820 ::std::mem::size_of::<MOJOSHADER_astAnnotations>(),
3821 48usize,
3822 concat!("Size of: ", stringify!(MOJOSHADER_astAnnotations))
3823 );
3824 assert_eq!(
3825 ::std::mem::align_of::<MOJOSHADER_astAnnotations>(),
3826 8usize,
3827 concat!("Alignment of ", stringify!(MOJOSHADER_astAnnotations))
3828 );
3829 assert_eq!(
3830 unsafe { &(*(::std::ptr::null::<MOJOSHADER_astAnnotations>())).ast as *const _ as usize },
3831 0usize,
3832 concat!(
3833 "Offset of field: ",
3834 stringify!(MOJOSHADER_astAnnotations),
3835 "::",
3836 stringify!(ast)
3837 )
3838 );
3839 assert_eq!(
3840 unsafe {
3841 &(*(::std::ptr::null::<MOJOSHADER_astAnnotations>())).datatype as *const _ as usize
3842 },
3843 24usize,
3844 concat!(
3845 "Offset of field: ",
3846 stringify!(MOJOSHADER_astAnnotations),
3847 "::",
3848 stringify!(datatype)
3849 )
3850 );
3851 assert_eq!(
3852 unsafe {
3853 &(*(::std::ptr::null::<MOJOSHADER_astAnnotations>())).initializer as *const _ as usize
3854 },
3855 32usize,
3856 concat!(
3857 "Offset of field: ",
3858 stringify!(MOJOSHADER_astAnnotations),
3859 "::",
3860 stringify!(initializer)
3861 )
3862 );
3863 assert_eq!(
3864 unsafe { &(*(::std::ptr::null::<MOJOSHADER_astAnnotations>())).next as *const _ as usize },
3865 40usize,
3866 concat!(
3867 "Offset of field: ",
3868 stringify!(MOJOSHADER_astAnnotations),
3869 "::",
3870 stringify!(next)
3871 )
3872 );
3873}
3874#[repr(C)]
3875#[derive(Debug, Copy, Clone)]
3876pub struct MOJOSHADER_astPackOffset {
3877 pub ast: MOJOSHADER_astNodeInfo,
3878 pub ident1: *const ::std::os::raw::c_char,
3879 pub ident2: *const ::std::os::raw::c_char,
3880}
3881#[test]
3882fn bindgen_test_layout_MOJOSHADER_astPackOffset() {
3883 assert_eq!(
3884 ::std::mem::size_of::<MOJOSHADER_astPackOffset>(),
3885 40usize,
3886 concat!("Size of: ", stringify!(MOJOSHADER_astPackOffset))
3887 );
3888 assert_eq!(
3889 ::std::mem::align_of::<MOJOSHADER_astPackOffset>(),
3890 8usize,
3891 concat!("Alignment of ", stringify!(MOJOSHADER_astPackOffset))
3892 );
3893 assert_eq!(
3894 unsafe { &(*(::std::ptr::null::<MOJOSHADER_astPackOffset>())).ast as *const _ as usize },
3895 0usize,
3896 concat!(
3897 "Offset of field: ",
3898 stringify!(MOJOSHADER_astPackOffset),
3899 "::",
3900 stringify!(ast)
3901 )
3902 );
3903 assert_eq!(
3904 unsafe { &(*(::std::ptr::null::<MOJOSHADER_astPackOffset>())).ident1 as *const _ as usize },
3905 24usize,
3906 concat!(
3907 "Offset of field: ",
3908 stringify!(MOJOSHADER_astPackOffset),
3909 "::",
3910 stringify!(ident1)
3911 )
3912 );
3913 assert_eq!(
3914 unsafe { &(*(::std::ptr::null::<MOJOSHADER_astPackOffset>())).ident2 as *const _ as usize },
3915 32usize,
3916 concat!(
3917 "Offset of field: ",
3918 stringify!(MOJOSHADER_astPackOffset),
3919 "::",
3920 stringify!(ident2)
3921 )
3922 );
3923}
3924#[repr(C)]
3925#[derive(Debug, Copy, Clone)]
3926pub struct MOJOSHADER_astVariableLowLevel {
3927 pub ast: MOJOSHADER_astNodeInfo,
3928 pub packoffset: *mut MOJOSHADER_astPackOffset,
3929 pub register_name: *const ::std::os::raw::c_char,
3930}
3931#[test]
3932fn bindgen_test_layout_MOJOSHADER_astVariableLowLevel() {
3933 assert_eq!(
3934 ::std::mem::size_of::<MOJOSHADER_astVariableLowLevel>(),
3935 40usize,
3936 concat!("Size of: ", stringify!(MOJOSHADER_astVariableLowLevel))
3937 );
3938 assert_eq!(
3939 ::std::mem::align_of::<MOJOSHADER_astVariableLowLevel>(),
3940 8usize,
3941 concat!("Alignment of ", stringify!(MOJOSHADER_astVariableLowLevel))
3942 );
3943 assert_eq!(
3944 unsafe {
3945 &(*(::std::ptr::null::<MOJOSHADER_astVariableLowLevel>())).ast as *const _ as usize
3946 },
3947 0usize,
3948 concat!(
3949 "Offset of field: ",
3950 stringify!(MOJOSHADER_astVariableLowLevel),
3951 "::",
3952 stringify!(ast)
3953 )
3954 );
3955 assert_eq!(
3956 unsafe {
3957 &(*(::std::ptr::null::<MOJOSHADER_astVariableLowLevel>())).packoffset as *const _
3958 as usize
3959 },
3960 24usize,
3961 concat!(
3962 "Offset of field: ",
3963 stringify!(MOJOSHADER_astVariableLowLevel),
3964 "::",
3965 stringify!(packoffset)
3966 )
3967 );
3968 assert_eq!(
3969 unsafe {
3970 &(*(::std::ptr::null::<MOJOSHADER_astVariableLowLevel>())).register_name as *const _
3971 as usize
3972 },
3973 32usize,
3974 concat!(
3975 "Offset of field: ",
3976 stringify!(MOJOSHADER_astVariableLowLevel),
3977 "::",
3978 stringify!(register_name)
3979 )
3980 );
3981}
3982#[repr(C)]
3983#[derive(Debug, Copy, Clone)]
3984pub struct MOJOSHADER_astStructMembers {
3985 pub ast: MOJOSHADER_astNodeInfo,
3986 pub datatype: *const MOJOSHADER_astDataType,
3987 pub semantic: *const ::std::os::raw::c_char,
3988 pub details: *mut MOJOSHADER_astScalarOrArray,
3989 pub interpolation_mod: MOJOSHADER_astInterpolationModifier,
3990 pub next: *mut MOJOSHADER_astStructMembers,
3991}
3992#[test]
3993fn bindgen_test_layout_MOJOSHADER_astStructMembers() {
3994 assert_eq!(
3995 ::std::mem::size_of::<MOJOSHADER_astStructMembers>(),
3996 64usize,
3997 concat!("Size of: ", stringify!(MOJOSHADER_astStructMembers))
3998 );
3999 assert_eq!(
4000 ::std::mem::align_of::<MOJOSHADER_astStructMembers>(),
4001 8usize,
4002 concat!("Alignment of ", stringify!(MOJOSHADER_astStructMembers))
4003 );
4004 assert_eq!(
4005 unsafe { &(*(::std::ptr::null::<MOJOSHADER_astStructMembers>())).ast as *const _ as usize },
4006 0usize,
4007 concat!(
4008 "Offset of field: ",
4009 stringify!(MOJOSHADER_astStructMembers),
4010 "::",
4011 stringify!(ast)
4012 )
4013 );
4014 assert_eq!(
4015 unsafe {
4016 &(*(::std::ptr::null::<MOJOSHADER_astStructMembers>())).datatype as *const _ as usize
4017 },
4018 24usize,
4019 concat!(
4020 "Offset of field: ",
4021 stringify!(MOJOSHADER_astStructMembers),
4022 "::",
4023 stringify!(datatype)
4024 )
4025 );
4026 assert_eq!(
4027 unsafe {
4028 &(*(::std::ptr::null::<MOJOSHADER_astStructMembers>())).semantic as *const _ as usize
4029 },
4030 32usize,
4031 concat!(
4032 "Offset of field: ",
4033 stringify!(MOJOSHADER_astStructMembers),
4034 "::",
4035 stringify!(semantic)
4036 )
4037 );
4038 assert_eq!(
4039 unsafe {
4040 &(*(::std::ptr::null::<MOJOSHADER_astStructMembers>())).details as *const _ as usize
4041 },
4042 40usize,
4043 concat!(
4044 "Offset of field: ",
4045 stringify!(MOJOSHADER_astStructMembers),
4046 "::",
4047 stringify!(details)
4048 )
4049 );
4050 assert_eq!(
4051 unsafe {
4052 &(*(::std::ptr::null::<MOJOSHADER_astStructMembers>())).interpolation_mod as *const _
4053 as usize
4054 },
4055 48usize,
4056 concat!(
4057 "Offset of field: ",
4058 stringify!(MOJOSHADER_astStructMembers),
4059 "::",
4060 stringify!(interpolation_mod)
4061 )
4062 );
4063 assert_eq!(
4064 unsafe {
4065 &(*(::std::ptr::null::<MOJOSHADER_astStructMembers>())).next as *const _ as usize
4066 },
4067 56usize,
4068 concat!(
4069 "Offset of field: ",
4070 stringify!(MOJOSHADER_astStructMembers),
4071 "::",
4072 stringify!(next)
4073 )
4074 );
4075}
4076#[repr(C)]
4077#[derive(Debug, Copy, Clone)]
4078pub struct MOJOSHADER_astStructDeclaration {
4079 pub ast: MOJOSHADER_astNodeInfo,
4080 pub datatype: *const MOJOSHADER_astDataType,
4081 pub name: *const ::std::os::raw::c_char,
4082 pub members: *mut MOJOSHADER_astStructMembers,
4083}
4084#[test]
4085fn bindgen_test_layout_MOJOSHADER_astStructDeclaration() {
4086 assert_eq!(
4087 ::std::mem::size_of::<MOJOSHADER_astStructDeclaration>(),
4088 48usize,
4089 concat!("Size of: ", stringify!(MOJOSHADER_astStructDeclaration))
4090 );
4091 assert_eq!(
4092 ::std::mem::align_of::<MOJOSHADER_astStructDeclaration>(),
4093 8usize,
4094 concat!("Alignment of ", stringify!(MOJOSHADER_astStructDeclaration))
4095 );
4096 assert_eq!(
4097 unsafe {
4098 &(*(::std::ptr::null::<MOJOSHADER_astStructDeclaration>())).ast as *const _ as usize
4099 },
4100 0usize,
4101 concat!(
4102 "Offset of field: ",
4103 stringify!(MOJOSHADER_astStructDeclaration),
4104 "::",
4105 stringify!(ast)
4106 )
4107 );
4108 assert_eq!(
4109 unsafe {
4110 &(*(::std::ptr::null::<MOJOSHADER_astStructDeclaration>())).datatype as *const _
4111 as usize
4112 },
4113 24usize,
4114 concat!(
4115 "Offset of field: ",
4116 stringify!(MOJOSHADER_astStructDeclaration),
4117 "::",
4118 stringify!(datatype)
4119 )
4120 );
4121 assert_eq!(
4122 unsafe {
4123 &(*(::std::ptr::null::<MOJOSHADER_astStructDeclaration>())).name as *const _ as usize
4124 },
4125 32usize,
4126 concat!(
4127 "Offset of field: ",
4128 stringify!(MOJOSHADER_astStructDeclaration),
4129 "::",
4130 stringify!(name)
4131 )
4132 );
4133 assert_eq!(
4134 unsafe {
4135 &(*(::std::ptr::null::<MOJOSHADER_astStructDeclaration>())).members as *const _ as usize
4136 },
4137 40usize,
4138 concat!(
4139 "Offset of field: ",
4140 stringify!(MOJOSHADER_astStructDeclaration),
4141 "::",
4142 stringify!(members)
4143 )
4144 );
4145}
4146#[repr(C)]
4147#[derive(Debug, Copy, Clone)]
4148pub struct MOJOSHADER_astVariableDeclaration {
4149 pub ast: MOJOSHADER_astNodeInfo,
4150 pub attributes: ::std::os::raw::c_int,
4151 pub datatype: *const MOJOSHADER_astDataType,
4152 pub anonymous_datatype: *mut MOJOSHADER_astStructDeclaration,
4153 pub details: *mut MOJOSHADER_astScalarOrArray,
4154 pub semantic: *const ::std::os::raw::c_char,
4155 pub annotations: *mut MOJOSHADER_astAnnotations,
4156 pub initializer: *mut MOJOSHADER_astExpression,
4157 pub lowlevel: *mut MOJOSHADER_astVariableLowLevel,
4158 pub next: *mut MOJOSHADER_astVariableDeclaration,
4159}
4160#[test]
4161fn bindgen_test_layout_MOJOSHADER_astVariableDeclaration() {
4162 assert_eq!(
4163 ::std::mem::size_of::<MOJOSHADER_astVariableDeclaration>(),
4164 96usize,
4165 concat!("Size of: ", stringify!(MOJOSHADER_astVariableDeclaration))
4166 );
4167 assert_eq!(
4168 ::std::mem::align_of::<MOJOSHADER_astVariableDeclaration>(),
4169 8usize,
4170 concat!(
4171 "Alignment of ",
4172 stringify!(MOJOSHADER_astVariableDeclaration)
4173 )
4174 );
4175 assert_eq!(
4176 unsafe {
4177 &(*(::std::ptr::null::<MOJOSHADER_astVariableDeclaration>())).ast as *const _ as usize
4178 },
4179 0usize,
4180 concat!(
4181 "Offset of field: ",
4182 stringify!(MOJOSHADER_astVariableDeclaration),
4183 "::",
4184 stringify!(ast)
4185 )
4186 );
4187 assert_eq!(
4188 unsafe {
4189 &(*(::std::ptr::null::<MOJOSHADER_astVariableDeclaration>())).attributes as *const _
4190 as usize
4191 },
4192 24usize,
4193 concat!(
4194 "Offset of field: ",
4195 stringify!(MOJOSHADER_astVariableDeclaration),
4196 "::",
4197 stringify!(attributes)
4198 )
4199 );
4200 assert_eq!(
4201 unsafe {
4202 &(*(::std::ptr::null::<MOJOSHADER_astVariableDeclaration>())).datatype as *const _
4203 as usize
4204 },
4205 32usize,
4206 concat!(
4207 "Offset of field: ",
4208 stringify!(MOJOSHADER_astVariableDeclaration),
4209 "::",
4210 stringify!(datatype)
4211 )
4212 );
4213 assert_eq!(
4214 unsafe {
4215 &(*(::std::ptr::null::<MOJOSHADER_astVariableDeclaration>())).anonymous_datatype
4216 as *const _ as usize
4217 },
4218 40usize,
4219 concat!(
4220 "Offset of field: ",
4221 stringify!(MOJOSHADER_astVariableDeclaration),
4222 "::",
4223 stringify!(anonymous_datatype)
4224 )
4225 );
4226 assert_eq!(
4227 unsafe {
4228 &(*(::std::ptr::null::<MOJOSHADER_astVariableDeclaration>())).details as *const _
4229 as usize
4230 },
4231 48usize,
4232 concat!(
4233 "Offset of field: ",
4234 stringify!(MOJOSHADER_astVariableDeclaration),
4235 "::",
4236 stringify!(details)
4237 )
4238 );
4239 assert_eq!(
4240 unsafe {
4241 &(*(::std::ptr::null::<MOJOSHADER_astVariableDeclaration>())).semantic as *const _
4242 as usize
4243 },
4244 56usize,
4245 concat!(
4246 "Offset of field: ",
4247 stringify!(MOJOSHADER_astVariableDeclaration),
4248 "::",
4249 stringify!(semantic)
4250 )
4251 );
4252 assert_eq!(
4253 unsafe {
4254 &(*(::std::ptr::null::<MOJOSHADER_astVariableDeclaration>())).annotations as *const _
4255 as usize
4256 },
4257 64usize,
4258 concat!(
4259 "Offset of field: ",
4260 stringify!(MOJOSHADER_astVariableDeclaration),
4261 "::",
4262 stringify!(annotations)
4263 )
4264 );
4265 assert_eq!(
4266 unsafe {
4267 &(*(::std::ptr::null::<MOJOSHADER_astVariableDeclaration>())).initializer as *const _
4268 as usize
4269 },
4270 72usize,
4271 concat!(
4272 "Offset of field: ",
4273 stringify!(MOJOSHADER_astVariableDeclaration),
4274 "::",
4275 stringify!(initializer)
4276 )
4277 );
4278 assert_eq!(
4279 unsafe {
4280 &(*(::std::ptr::null::<MOJOSHADER_astVariableDeclaration>())).lowlevel as *const _
4281 as usize
4282 },
4283 80usize,
4284 concat!(
4285 "Offset of field: ",
4286 stringify!(MOJOSHADER_astVariableDeclaration),
4287 "::",
4288 stringify!(lowlevel)
4289 )
4290 );
4291 assert_eq!(
4292 unsafe {
4293 &(*(::std::ptr::null::<MOJOSHADER_astVariableDeclaration>())).next as *const _ as usize
4294 },
4295 88usize,
4296 concat!(
4297 "Offset of field: ",
4298 stringify!(MOJOSHADER_astVariableDeclaration),
4299 "::",
4300 stringify!(next)
4301 )
4302 );
4303}
4304#[repr(C)]
4305#[derive(Debug, Copy, Clone)]
4306pub struct MOJOSHADER_astStatement {
4307 pub ast: MOJOSHADER_astNodeInfo,
4308 pub next: *mut MOJOSHADER_astStatement,
4309}
4310#[test]
4311fn bindgen_test_layout_MOJOSHADER_astStatement() {
4312 assert_eq!(
4313 ::std::mem::size_of::<MOJOSHADER_astStatement>(),
4314 32usize,
4315 concat!("Size of: ", stringify!(MOJOSHADER_astStatement))
4316 );
4317 assert_eq!(
4318 ::std::mem::align_of::<MOJOSHADER_astStatement>(),
4319 8usize,
4320 concat!("Alignment of ", stringify!(MOJOSHADER_astStatement))
4321 );
4322 assert_eq!(
4323 unsafe { &(*(::std::ptr::null::<MOJOSHADER_astStatement>())).ast as *const _ as usize },
4324 0usize,
4325 concat!(
4326 "Offset of field: ",
4327 stringify!(MOJOSHADER_astStatement),
4328 "::",
4329 stringify!(ast)
4330 )
4331 );
4332 assert_eq!(
4333 unsafe { &(*(::std::ptr::null::<MOJOSHADER_astStatement>())).next as *const _ as usize },
4334 24usize,
4335 concat!(
4336 "Offset of field: ",
4337 stringify!(MOJOSHADER_astStatement),
4338 "::",
4339 stringify!(next)
4340 )
4341 );
4342}
4343pub type MOJOSHADER_astEmptyStatement = MOJOSHADER_astStatement;
4344pub type MOJOSHADER_astBreakStatement = MOJOSHADER_astStatement;
4345pub type MOJOSHADER_astContinueStatement = MOJOSHADER_astStatement;
4346pub type MOJOSHADER_astDiscardStatement = MOJOSHADER_astStatement;
4347#[repr(C)]
4348#[derive(Debug, Copy, Clone)]
4349pub struct MOJOSHADER_astBlockStatement {
4350 pub ast: MOJOSHADER_astNodeInfo,
4351 pub next: *mut MOJOSHADER_astStatement,
4352 pub statements: *mut MOJOSHADER_astStatement,
4353}
4354#[test]
4355fn bindgen_test_layout_MOJOSHADER_astBlockStatement() {
4356 assert_eq!(
4357 ::std::mem::size_of::<MOJOSHADER_astBlockStatement>(),
4358 40usize,
4359 concat!("Size of: ", stringify!(MOJOSHADER_astBlockStatement))
4360 );
4361 assert_eq!(
4362 ::std::mem::align_of::<MOJOSHADER_astBlockStatement>(),
4363 8usize,
4364 concat!("Alignment of ", stringify!(MOJOSHADER_astBlockStatement))
4365 );
4366 assert_eq!(
4367 unsafe {
4368 &(*(::std::ptr::null::<MOJOSHADER_astBlockStatement>())).ast as *const _ as usize
4369 },
4370 0usize,
4371 concat!(
4372 "Offset of field: ",
4373 stringify!(MOJOSHADER_astBlockStatement),
4374 "::",
4375 stringify!(ast)
4376 )
4377 );
4378 assert_eq!(
4379 unsafe {
4380 &(*(::std::ptr::null::<MOJOSHADER_astBlockStatement>())).next as *const _ as usize
4381 },
4382 24usize,
4383 concat!(
4384 "Offset of field: ",
4385 stringify!(MOJOSHADER_astBlockStatement),
4386 "::",
4387 stringify!(next)
4388 )
4389 );
4390 assert_eq!(
4391 unsafe {
4392 &(*(::std::ptr::null::<MOJOSHADER_astBlockStatement>())).statements as *const _ as usize
4393 },
4394 32usize,
4395 concat!(
4396 "Offset of field: ",
4397 stringify!(MOJOSHADER_astBlockStatement),
4398 "::",
4399 stringify!(statements)
4400 )
4401 );
4402}
4403#[repr(C)]
4404#[derive(Debug, Copy, Clone)]
4405pub struct MOJOSHADER_astReturnStatement {
4406 pub ast: MOJOSHADER_astNodeInfo,
4407 pub next: *mut MOJOSHADER_astStatement,
4408 pub expr: *mut MOJOSHADER_astExpression,
4409}
4410#[test]
4411fn bindgen_test_layout_MOJOSHADER_astReturnStatement() {
4412 assert_eq!(
4413 ::std::mem::size_of::<MOJOSHADER_astReturnStatement>(),
4414 40usize,
4415 concat!("Size of: ", stringify!(MOJOSHADER_astReturnStatement))
4416 );
4417 assert_eq!(
4418 ::std::mem::align_of::<MOJOSHADER_astReturnStatement>(),
4419 8usize,
4420 concat!("Alignment of ", stringify!(MOJOSHADER_astReturnStatement))
4421 );
4422 assert_eq!(
4423 unsafe {
4424 &(*(::std::ptr::null::<MOJOSHADER_astReturnStatement>())).ast as *const _ as usize
4425 },
4426 0usize,
4427 concat!(
4428 "Offset of field: ",
4429 stringify!(MOJOSHADER_astReturnStatement),
4430 "::",
4431 stringify!(ast)
4432 )
4433 );
4434 assert_eq!(
4435 unsafe {
4436 &(*(::std::ptr::null::<MOJOSHADER_astReturnStatement>())).next as *const _ as usize
4437 },
4438 24usize,
4439 concat!(
4440 "Offset of field: ",
4441 stringify!(MOJOSHADER_astReturnStatement),
4442 "::",
4443 stringify!(next)
4444 )
4445 );
4446 assert_eq!(
4447 unsafe {
4448 &(*(::std::ptr::null::<MOJOSHADER_astReturnStatement>())).expr as *const _ as usize
4449 },
4450 32usize,
4451 concat!(
4452 "Offset of field: ",
4453 stringify!(MOJOSHADER_astReturnStatement),
4454 "::",
4455 stringify!(expr)
4456 )
4457 );
4458}
4459#[repr(C)]
4460#[derive(Debug, Copy, Clone)]
4461pub struct MOJOSHADER_astExpressionStatement {
4462 pub ast: MOJOSHADER_astNodeInfo,
4463 pub next: *mut MOJOSHADER_astStatement,
4464 pub expr: *mut MOJOSHADER_astExpression,
4465}
4466#[test]
4467fn bindgen_test_layout_MOJOSHADER_astExpressionStatement() {
4468 assert_eq!(
4469 ::std::mem::size_of::<MOJOSHADER_astExpressionStatement>(),
4470 40usize,
4471 concat!("Size of: ", stringify!(MOJOSHADER_astExpressionStatement))
4472 );
4473 assert_eq!(
4474 ::std::mem::align_of::<MOJOSHADER_astExpressionStatement>(),
4475 8usize,
4476 concat!(
4477 "Alignment of ",
4478 stringify!(MOJOSHADER_astExpressionStatement)
4479 )
4480 );
4481 assert_eq!(
4482 unsafe {
4483 &(*(::std::ptr::null::<MOJOSHADER_astExpressionStatement>())).ast as *const _ as usize
4484 },
4485 0usize,
4486 concat!(
4487 "Offset of field: ",
4488 stringify!(MOJOSHADER_astExpressionStatement),
4489 "::",
4490 stringify!(ast)
4491 )
4492 );
4493 assert_eq!(
4494 unsafe {
4495 &(*(::std::ptr::null::<MOJOSHADER_astExpressionStatement>())).next as *const _ as usize
4496 },
4497 24usize,
4498 concat!(
4499 "Offset of field: ",
4500 stringify!(MOJOSHADER_astExpressionStatement),
4501 "::",
4502 stringify!(next)
4503 )
4504 );
4505 assert_eq!(
4506 unsafe {
4507 &(*(::std::ptr::null::<MOJOSHADER_astExpressionStatement>())).expr as *const _ as usize
4508 },
4509 32usize,
4510 concat!(
4511 "Offset of field: ",
4512 stringify!(MOJOSHADER_astExpressionStatement),
4513 "::",
4514 stringify!(expr)
4515 )
4516 );
4517}
4518#[repr(C)]
4519#[derive(Debug, Copy, Clone)]
4520pub struct MOJOSHADER_astIfStatement {
4521 pub ast: MOJOSHADER_astNodeInfo,
4522 pub next: *mut MOJOSHADER_astStatement,
4523 pub attributes: ::std::os::raw::c_int,
4524 pub expr: *mut MOJOSHADER_astExpression,
4525 pub statement: *mut MOJOSHADER_astStatement,
4526 pub else_statement: *mut MOJOSHADER_astStatement,
4527}
4528#[test]
4529fn bindgen_test_layout_MOJOSHADER_astIfStatement() {
4530 assert_eq!(
4531 ::std::mem::size_of::<MOJOSHADER_astIfStatement>(),
4532 64usize,
4533 concat!("Size of: ", stringify!(MOJOSHADER_astIfStatement))
4534 );
4535 assert_eq!(
4536 ::std::mem::align_of::<MOJOSHADER_astIfStatement>(),
4537 8usize,
4538 concat!("Alignment of ", stringify!(MOJOSHADER_astIfStatement))
4539 );
4540 assert_eq!(
4541 unsafe { &(*(::std::ptr::null::<MOJOSHADER_astIfStatement>())).ast as *const _ as usize },
4542 0usize,
4543 concat!(
4544 "Offset of field: ",
4545 stringify!(MOJOSHADER_astIfStatement),
4546 "::",
4547 stringify!(ast)
4548 )
4549 );
4550 assert_eq!(
4551 unsafe { &(*(::std::ptr::null::<MOJOSHADER_astIfStatement>())).next as *const _ as usize },
4552 24usize,
4553 concat!(
4554 "Offset of field: ",
4555 stringify!(MOJOSHADER_astIfStatement),
4556 "::",
4557 stringify!(next)
4558 )
4559 );
4560 assert_eq!(
4561 unsafe {
4562 &(*(::std::ptr::null::<MOJOSHADER_astIfStatement>())).attributes as *const _ as usize
4563 },
4564 32usize,
4565 concat!(
4566 "Offset of field: ",
4567 stringify!(MOJOSHADER_astIfStatement),
4568 "::",
4569 stringify!(attributes)
4570 )
4571 );
4572 assert_eq!(
4573 unsafe { &(*(::std::ptr::null::<MOJOSHADER_astIfStatement>())).expr as *const _ as usize },
4574 40usize,
4575 concat!(
4576 "Offset of field: ",
4577 stringify!(MOJOSHADER_astIfStatement),
4578 "::",
4579 stringify!(expr)
4580 )
4581 );
4582 assert_eq!(
4583 unsafe {
4584 &(*(::std::ptr::null::<MOJOSHADER_astIfStatement>())).statement as *const _ as usize
4585 },
4586 48usize,
4587 concat!(
4588 "Offset of field: ",
4589 stringify!(MOJOSHADER_astIfStatement),
4590 "::",
4591 stringify!(statement)
4592 )
4593 );
4594 assert_eq!(
4595 unsafe {
4596 &(*(::std::ptr::null::<MOJOSHADER_astIfStatement>())).else_statement as *const _
4597 as usize
4598 },
4599 56usize,
4600 concat!(
4601 "Offset of field: ",
4602 stringify!(MOJOSHADER_astIfStatement),
4603 "::",
4604 stringify!(else_statement)
4605 )
4606 );
4607}
4608#[repr(C)]
4609#[derive(Debug, Copy, Clone)]
4610pub struct MOJOSHADER_astSwitchCases {
4611 pub ast: MOJOSHADER_astNodeInfo,
4612 pub expr: *mut MOJOSHADER_astExpression,
4613 pub statement: *mut MOJOSHADER_astStatement,
4614 pub next: *mut MOJOSHADER_astSwitchCases,
4615}
4616#[test]
4617fn bindgen_test_layout_MOJOSHADER_astSwitchCases() {
4618 assert_eq!(
4619 ::std::mem::size_of::<MOJOSHADER_astSwitchCases>(),
4620 48usize,
4621 concat!("Size of: ", stringify!(MOJOSHADER_astSwitchCases))
4622 );
4623 assert_eq!(
4624 ::std::mem::align_of::<MOJOSHADER_astSwitchCases>(),
4625 8usize,
4626 concat!("Alignment of ", stringify!(MOJOSHADER_astSwitchCases))
4627 );
4628 assert_eq!(
4629 unsafe { &(*(::std::ptr::null::<MOJOSHADER_astSwitchCases>())).ast as *const _ as usize },
4630 0usize,
4631 concat!(
4632 "Offset of field: ",
4633 stringify!(MOJOSHADER_astSwitchCases),
4634 "::",
4635 stringify!(ast)
4636 )
4637 );
4638 assert_eq!(
4639 unsafe { &(*(::std::ptr::null::<MOJOSHADER_astSwitchCases>())).expr as *const _ as usize },
4640 24usize,
4641 concat!(
4642 "Offset of field: ",
4643 stringify!(MOJOSHADER_astSwitchCases),
4644 "::",
4645 stringify!(expr)
4646 )
4647 );
4648 assert_eq!(
4649 unsafe {
4650 &(*(::std::ptr::null::<MOJOSHADER_astSwitchCases>())).statement as *const _ as usize
4651 },
4652 32usize,
4653 concat!(
4654 "Offset of field: ",
4655 stringify!(MOJOSHADER_astSwitchCases),
4656 "::",
4657 stringify!(statement)
4658 )
4659 );
4660 assert_eq!(
4661 unsafe { &(*(::std::ptr::null::<MOJOSHADER_astSwitchCases>())).next as *const _ as usize },
4662 40usize,
4663 concat!(
4664 "Offset of field: ",
4665 stringify!(MOJOSHADER_astSwitchCases),
4666 "::",
4667 stringify!(next)
4668 )
4669 );
4670}
4671#[repr(C)]
4672#[derive(Debug, Copy, Clone)]
4673pub struct MOJOSHADER_astSwitchStatement {
4674 pub ast: MOJOSHADER_astNodeInfo,
4675 pub next: *mut MOJOSHADER_astStatement,
4676 pub attributes: ::std::os::raw::c_int,
4677 pub expr: *mut MOJOSHADER_astExpression,
4678 pub cases: *mut MOJOSHADER_astSwitchCases,
4679}
4680#[test]
4681fn bindgen_test_layout_MOJOSHADER_astSwitchStatement() {
4682 assert_eq!(
4683 ::std::mem::size_of::<MOJOSHADER_astSwitchStatement>(),
4684 56usize,
4685 concat!("Size of: ", stringify!(MOJOSHADER_astSwitchStatement))
4686 );
4687 assert_eq!(
4688 ::std::mem::align_of::<MOJOSHADER_astSwitchStatement>(),
4689 8usize,
4690 concat!("Alignment of ", stringify!(MOJOSHADER_astSwitchStatement))
4691 );
4692 assert_eq!(
4693 unsafe {
4694 &(*(::std::ptr::null::<MOJOSHADER_astSwitchStatement>())).ast as *const _ as usize
4695 },
4696 0usize,
4697 concat!(
4698 "Offset of field: ",
4699 stringify!(MOJOSHADER_astSwitchStatement),
4700 "::",
4701 stringify!(ast)
4702 )
4703 );
4704 assert_eq!(
4705 unsafe {
4706 &(*(::std::ptr::null::<MOJOSHADER_astSwitchStatement>())).next as *const _ as usize
4707 },
4708 24usize,
4709 concat!(
4710 "Offset of field: ",
4711 stringify!(MOJOSHADER_astSwitchStatement),
4712 "::",
4713 stringify!(next)
4714 )
4715 );
4716 assert_eq!(
4717 unsafe {
4718 &(*(::std::ptr::null::<MOJOSHADER_astSwitchStatement>())).attributes as *const _
4719 as usize
4720 },
4721 32usize,
4722 concat!(
4723 "Offset of field: ",
4724 stringify!(MOJOSHADER_astSwitchStatement),
4725 "::",
4726 stringify!(attributes)
4727 )
4728 );
4729 assert_eq!(
4730 unsafe {
4731 &(*(::std::ptr::null::<MOJOSHADER_astSwitchStatement>())).expr as *const _ as usize
4732 },
4733 40usize,
4734 concat!(
4735 "Offset of field: ",
4736 stringify!(MOJOSHADER_astSwitchStatement),
4737 "::",
4738 stringify!(expr)
4739 )
4740 );
4741 assert_eq!(
4742 unsafe {
4743 &(*(::std::ptr::null::<MOJOSHADER_astSwitchStatement>())).cases as *const _ as usize
4744 },
4745 48usize,
4746 concat!(
4747 "Offset of field: ",
4748 stringify!(MOJOSHADER_astSwitchStatement),
4749 "::",
4750 stringify!(cases)
4751 )
4752 );
4753}
4754#[repr(C)]
4755#[derive(Debug, Copy, Clone)]
4756pub struct MOJOSHADER_astWhileStatement {
4757 pub ast: MOJOSHADER_astNodeInfo,
4758 pub next: *mut MOJOSHADER_astStatement,
4759 pub unroll: ::std::os::raw::c_int,
4760 pub expr: *mut MOJOSHADER_astExpression,
4761 pub statement: *mut MOJOSHADER_astStatement,
4762}
4763#[test]
4764fn bindgen_test_layout_MOJOSHADER_astWhileStatement() {
4765 assert_eq!(
4766 ::std::mem::size_of::<MOJOSHADER_astWhileStatement>(),
4767 56usize,
4768 concat!("Size of: ", stringify!(MOJOSHADER_astWhileStatement))
4769 );
4770 assert_eq!(
4771 ::std::mem::align_of::<MOJOSHADER_astWhileStatement>(),
4772 8usize,
4773 concat!("Alignment of ", stringify!(MOJOSHADER_astWhileStatement))
4774 );
4775 assert_eq!(
4776 unsafe {
4777 &(*(::std::ptr::null::<MOJOSHADER_astWhileStatement>())).ast as *const _ as usize
4778 },
4779 0usize,
4780 concat!(
4781 "Offset of field: ",
4782 stringify!(MOJOSHADER_astWhileStatement),
4783 "::",
4784 stringify!(ast)
4785 )
4786 );
4787 assert_eq!(
4788 unsafe {
4789 &(*(::std::ptr::null::<MOJOSHADER_astWhileStatement>())).next as *const _ as usize
4790 },
4791 24usize,
4792 concat!(
4793 "Offset of field: ",
4794 stringify!(MOJOSHADER_astWhileStatement),
4795 "::",
4796 stringify!(next)
4797 )
4798 );
4799 assert_eq!(
4800 unsafe {
4801 &(*(::std::ptr::null::<MOJOSHADER_astWhileStatement>())).unroll as *const _ as usize
4802 },
4803 32usize,
4804 concat!(
4805 "Offset of field: ",
4806 stringify!(MOJOSHADER_astWhileStatement),
4807 "::",
4808 stringify!(unroll)
4809 )
4810 );
4811 assert_eq!(
4812 unsafe {
4813 &(*(::std::ptr::null::<MOJOSHADER_astWhileStatement>())).expr as *const _ as usize
4814 },
4815 40usize,
4816 concat!(
4817 "Offset of field: ",
4818 stringify!(MOJOSHADER_astWhileStatement),
4819 "::",
4820 stringify!(expr)
4821 )
4822 );
4823 assert_eq!(
4824 unsafe {
4825 &(*(::std::ptr::null::<MOJOSHADER_astWhileStatement>())).statement as *const _ as usize
4826 },
4827 48usize,
4828 concat!(
4829 "Offset of field: ",
4830 stringify!(MOJOSHADER_astWhileStatement),
4831 "::",
4832 stringify!(statement)
4833 )
4834 );
4835}
4836pub type MOJOSHADER_astDoStatement = MOJOSHADER_astWhileStatement;
4837#[repr(C)]
4838#[derive(Debug, Copy, Clone)]
4839pub struct MOJOSHADER_astForStatement {
4840 pub ast: MOJOSHADER_astNodeInfo,
4841 pub next: *mut MOJOSHADER_astStatement,
4842 pub unroll: ::std::os::raw::c_int,
4843 pub var_decl: *mut MOJOSHADER_astVariableDeclaration,
4844 pub initializer: *mut MOJOSHADER_astExpression,
4845 pub looptest: *mut MOJOSHADER_astExpression,
4846 pub counter: *mut MOJOSHADER_astExpression,
4847 pub statement: *mut MOJOSHADER_astStatement,
4848}
4849#[test]
4850fn bindgen_test_layout_MOJOSHADER_astForStatement() {
4851 assert_eq!(
4852 ::std::mem::size_of::<MOJOSHADER_astForStatement>(),
4853 80usize,
4854 concat!("Size of: ", stringify!(MOJOSHADER_astForStatement))
4855 );
4856 assert_eq!(
4857 ::std::mem::align_of::<MOJOSHADER_astForStatement>(),
4858 8usize,
4859 concat!("Alignment of ", stringify!(MOJOSHADER_astForStatement))
4860 );
4861 assert_eq!(
4862 unsafe { &(*(::std::ptr::null::<MOJOSHADER_astForStatement>())).ast as *const _ as usize },
4863 0usize,
4864 concat!(
4865 "Offset of field: ",
4866 stringify!(MOJOSHADER_astForStatement),
4867 "::",
4868 stringify!(ast)
4869 )
4870 );
4871 assert_eq!(
4872 unsafe { &(*(::std::ptr::null::<MOJOSHADER_astForStatement>())).next as *const _ as usize },
4873 24usize,
4874 concat!(
4875 "Offset of field: ",
4876 stringify!(MOJOSHADER_astForStatement),
4877 "::",
4878 stringify!(next)
4879 )
4880 );
4881 assert_eq!(
4882 unsafe {
4883 &(*(::std::ptr::null::<MOJOSHADER_astForStatement>())).unroll as *const _ as usize
4884 },
4885 32usize,
4886 concat!(
4887 "Offset of field: ",
4888 stringify!(MOJOSHADER_astForStatement),
4889 "::",
4890 stringify!(unroll)
4891 )
4892 );
4893 assert_eq!(
4894 unsafe {
4895 &(*(::std::ptr::null::<MOJOSHADER_astForStatement>())).var_decl as *const _ as usize
4896 },
4897 40usize,
4898 concat!(
4899 "Offset of field: ",
4900 stringify!(MOJOSHADER_astForStatement),
4901 "::",
4902 stringify!(var_decl)
4903 )
4904 );
4905 assert_eq!(
4906 unsafe {
4907 &(*(::std::ptr::null::<MOJOSHADER_astForStatement>())).initializer as *const _ as usize
4908 },
4909 48usize,
4910 concat!(
4911 "Offset of field: ",
4912 stringify!(MOJOSHADER_astForStatement),
4913 "::",
4914 stringify!(initializer)
4915 )
4916 );
4917 assert_eq!(
4918 unsafe {
4919 &(*(::std::ptr::null::<MOJOSHADER_astForStatement>())).looptest as *const _ as usize
4920 },
4921 56usize,
4922 concat!(
4923 "Offset of field: ",
4924 stringify!(MOJOSHADER_astForStatement),
4925 "::",
4926 stringify!(looptest)
4927 )
4928 );
4929 assert_eq!(
4930 unsafe {
4931 &(*(::std::ptr::null::<MOJOSHADER_astForStatement>())).counter as *const _ as usize
4932 },
4933 64usize,
4934 concat!(
4935 "Offset of field: ",
4936 stringify!(MOJOSHADER_astForStatement),
4937 "::",
4938 stringify!(counter)
4939 )
4940 );
4941 assert_eq!(
4942 unsafe {
4943 &(*(::std::ptr::null::<MOJOSHADER_astForStatement>())).statement as *const _ as usize
4944 },
4945 72usize,
4946 concat!(
4947 "Offset of field: ",
4948 stringify!(MOJOSHADER_astForStatement),
4949 "::",
4950 stringify!(statement)
4951 )
4952 );
4953}
4954#[repr(C)]
4955#[derive(Debug, Copy, Clone)]
4956pub struct MOJOSHADER_astTypedef {
4957 pub ast: MOJOSHADER_astNodeInfo,
4958 pub datatype: *const MOJOSHADER_astDataType,
4959 pub isconst: ::std::os::raw::c_int,
4960 pub details: *mut MOJOSHADER_astScalarOrArray,
4961}
4962#[test]
4963fn bindgen_test_layout_MOJOSHADER_astTypedef() {
4964 assert_eq!(
4965 ::std::mem::size_of::<MOJOSHADER_astTypedef>(),
4966 48usize,
4967 concat!("Size of: ", stringify!(MOJOSHADER_astTypedef))
4968 );
4969 assert_eq!(
4970 ::std::mem::align_of::<MOJOSHADER_astTypedef>(),
4971 8usize,
4972 concat!("Alignment of ", stringify!(MOJOSHADER_astTypedef))
4973 );
4974 assert_eq!(
4975 unsafe { &(*(::std::ptr::null::<MOJOSHADER_astTypedef>())).ast as *const _ as usize },
4976 0usize,
4977 concat!(
4978 "Offset of field: ",
4979 stringify!(MOJOSHADER_astTypedef),
4980 "::",
4981 stringify!(ast)
4982 )
4983 );
4984 assert_eq!(
4985 unsafe { &(*(::std::ptr::null::<MOJOSHADER_astTypedef>())).datatype as *const _ as usize },
4986 24usize,
4987 concat!(
4988 "Offset of field: ",
4989 stringify!(MOJOSHADER_astTypedef),
4990 "::",
4991 stringify!(datatype)
4992 )
4993 );
4994 assert_eq!(
4995 unsafe { &(*(::std::ptr::null::<MOJOSHADER_astTypedef>())).isconst as *const _ as usize },
4996 32usize,
4997 concat!(
4998 "Offset of field: ",
4999 stringify!(MOJOSHADER_astTypedef),
5000 "::",
5001 stringify!(isconst)
5002 )
5003 );
5004 assert_eq!(
5005 unsafe { &(*(::std::ptr::null::<MOJOSHADER_astTypedef>())).details as *const _ as usize },
5006 40usize,
5007 concat!(
5008 "Offset of field: ",
5009 stringify!(MOJOSHADER_astTypedef),
5010 "::",
5011 stringify!(details)
5012 )
5013 );
5014}
5015#[repr(C)]
5016#[derive(Debug, Copy, Clone)]
5017pub struct MOJOSHADER_astTypedefStatement {
5018 pub ast: MOJOSHADER_astNodeInfo,
5019 pub next: *mut MOJOSHADER_astStatement,
5020 pub type_info: *mut MOJOSHADER_astTypedef,
5021}
5022#[test]
5023fn bindgen_test_layout_MOJOSHADER_astTypedefStatement() {
5024 assert_eq!(
5025 ::std::mem::size_of::<MOJOSHADER_astTypedefStatement>(),
5026 40usize,
5027 concat!("Size of: ", stringify!(MOJOSHADER_astTypedefStatement))
5028 );
5029 assert_eq!(
5030 ::std::mem::align_of::<MOJOSHADER_astTypedefStatement>(),
5031 8usize,
5032 concat!("Alignment of ", stringify!(MOJOSHADER_astTypedefStatement))
5033 );
5034 assert_eq!(
5035 unsafe {
5036 &(*(::std::ptr::null::<MOJOSHADER_astTypedefStatement>())).ast as *const _ as usize
5037 },
5038 0usize,
5039 concat!(
5040 "Offset of field: ",
5041 stringify!(MOJOSHADER_astTypedefStatement),
5042 "::",
5043 stringify!(ast)
5044 )
5045 );
5046 assert_eq!(
5047 unsafe {
5048 &(*(::std::ptr::null::<MOJOSHADER_astTypedefStatement>())).next as *const _ as usize
5049 },
5050 24usize,
5051 concat!(
5052 "Offset of field: ",
5053 stringify!(MOJOSHADER_astTypedefStatement),
5054 "::",
5055 stringify!(next)
5056 )
5057 );
5058 assert_eq!(
5059 unsafe {
5060 &(*(::std::ptr::null::<MOJOSHADER_astTypedefStatement>())).type_info as *const _
5061 as usize
5062 },
5063 32usize,
5064 concat!(
5065 "Offset of field: ",
5066 stringify!(MOJOSHADER_astTypedefStatement),
5067 "::",
5068 stringify!(type_info)
5069 )
5070 );
5071}
5072#[repr(C)]
5073#[derive(Debug, Copy, Clone)]
5074pub struct MOJOSHADER_astVarDeclStatement {
5075 pub ast: MOJOSHADER_astNodeInfo,
5076 pub next: *mut MOJOSHADER_astStatement,
5077 pub declaration: *mut MOJOSHADER_astVariableDeclaration,
5078}
5079#[test]
5080fn bindgen_test_layout_MOJOSHADER_astVarDeclStatement() {
5081 assert_eq!(
5082 ::std::mem::size_of::<MOJOSHADER_astVarDeclStatement>(),
5083 40usize,
5084 concat!("Size of: ", stringify!(MOJOSHADER_astVarDeclStatement))
5085 );
5086 assert_eq!(
5087 ::std::mem::align_of::<MOJOSHADER_astVarDeclStatement>(),
5088 8usize,
5089 concat!("Alignment of ", stringify!(MOJOSHADER_astVarDeclStatement))
5090 );
5091 assert_eq!(
5092 unsafe {
5093 &(*(::std::ptr::null::<MOJOSHADER_astVarDeclStatement>())).ast as *const _ as usize
5094 },
5095 0usize,
5096 concat!(
5097 "Offset of field: ",
5098 stringify!(MOJOSHADER_astVarDeclStatement),
5099 "::",
5100 stringify!(ast)
5101 )
5102 );
5103 assert_eq!(
5104 unsafe {
5105 &(*(::std::ptr::null::<MOJOSHADER_astVarDeclStatement>())).next as *const _ as usize
5106 },
5107 24usize,
5108 concat!(
5109 "Offset of field: ",
5110 stringify!(MOJOSHADER_astVarDeclStatement),
5111 "::",
5112 stringify!(next)
5113 )
5114 );
5115 assert_eq!(
5116 unsafe {
5117 &(*(::std::ptr::null::<MOJOSHADER_astVarDeclStatement>())).declaration as *const _
5118 as usize
5119 },
5120 32usize,
5121 concat!(
5122 "Offset of field: ",
5123 stringify!(MOJOSHADER_astVarDeclStatement),
5124 "::",
5125 stringify!(declaration)
5126 )
5127 );
5128}
5129#[repr(C)]
5130#[derive(Debug, Copy, Clone)]
5131pub struct MOJOSHADER_astStructStatement {
5132 pub ast: MOJOSHADER_astNodeInfo,
5133 pub next: *mut MOJOSHADER_astStatement,
5134 pub struct_info: *mut MOJOSHADER_astStructDeclaration,
5135}
5136#[test]
5137fn bindgen_test_layout_MOJOSHADER_astStructStatement() {
5138 assert_eq!(
5139 ::std::mem::size_of::<MOJOSHADER_astStructStatement>(),
5140 40usize,
5141 concat!("Size of: ", stringify!(MOJOSHADER_astStructStatement))
5142 );
5143 assert_eq!(
5144 ::std::mem::align_of::<MOJOSHADER_astStructStatement>(),
5145 8usize,
5146 concat!("Alignment of ", stringify!(MOJOSHADER_astStructStatement))
5147 );
5148 assert_eq!(
5149 unsafe {
5150 &(*(::std::ptr::null::<MOJOSHADER_astStructStatement>())).ast as *const _ as usize
5151 },
5152 0usize,
5153 concat!(
5154 "Offset of field: ",
5155 stringify!(MOJOSHADER_astStructStatement),
5156 "::",
5157 stringify!(ast)
5158 )
5159 );
5160 assert_eq!(
5161 unsafe {
5162 &(*(::std::ptr::null::<MOJOSHADER_astStructStatement>())).next as *const _ as usize
5163 },
5164 24usize,
5165 concat!(
5166 "Offset of field: ",
5167 stringify!(MOJOSHADER_astStructStatement),
5168 "::",
5169 stringify!(next)
5170 )
5171 );
5172 assert_eq!(
5173 unsafe {
5174 &(*(::std::ptr::null::<MOJOSHADER_astStructStatement>())).struct_info as *const _
5175 as usize
5176 },
5177 32usize,
5178 concat!(
5179 "Offset of field: ",
5180 stringify!(MOJOSHADER_astStructStatement),
5181 "::",
5182 stringify!(struct_info)
5183 )
5184 );
5185}
5186#[repr(C)]
5187#[derive(Debug, Copy, Clone)]
5188pub struct MOJOSHADER_astCompilationUnitFunction {
5189 pub ast: MOJOSHADER_astNodeInfo,
5190 pub next: *mut MOJOSHADER_astCompilationUnit,
5191 pub declaration: *mut MOJOSHADER_astFunctionSignature,
5192 pub definition: *mut MOJOSHADER_astStatement,
5193 pub index: ::std::os::raw::c_int,
5194}
5195#[test]
5196fn bindgen_test_layout_MOJOSHADER_astCompilationUnitFunction() {
5197 assert_eq!(
5198 ::std::mem::size_of::<MOJOSHADER_astCompilationUnitFunction>(),
5199 56usize,
5200 concat!(
5201 "Size of: ",
5202 stringify!(MOJOSHADER_astCompilationUnitFunction)
5203 )
5204 );
5205 assert_eq!(
5206 ::std::mem::align_of::<MOJOSHADER_astCompilationUnitFunction>(),
5207 8usize,
5208 concat!(
5209 "Alignment of ",
5210 stringify!(MOJOSHADER_astCompilationUnitFunction)
5211 )
5212 );
5213 assert_eq!(
5214 unsafe {
5215 &(*(::std::ptr::null::<MOJOSHADER_astCompilationUnitFunction>())).ast as *const _
5216 as usize
5217 },
5218 0usize,
5219 concat!(
5220 "Offset of field: ",
5221 stringify!(MOJOSHADER_astCompilationUnitFunction),
5222 "::",
5223 stringify!(ast)
5224 )
5225 );
5226 assert_eq!(
5227 unsafe {
5228 &(*(::std::ptr::null::<MOJOSHADER_astCompilationUnitFunction>())).next as *const _
5229 as usize
5230 },
5231 24usize,
5232 concat!(
5233 "Offset of field: ",
5234 stringify!(MOJOSHADER_astCompilationUnitFunction),
5235 "::",
5236 stringify!(next)
5237 )
5238 );
5239 assert_eq!(
5240 unsafe {
5241 &(*(::std::ptr::null::<MOJOSHADER_astCompilationUnitFunction>())).declaration
5242 as *const _ as usize
5243 },
5244 32usize,
5245 concat!(
5246 "Offset of field: ",
5247 stringify!(MOJOSHADER_astCompilationUnitFunction),
5248 "::",
5249 stringify!(declaration)
5250 )
5251 );
5252 assert_eq!(
5253 unsafe {
5254 &(*(::std::ptr::null::<MOJOSHADER_astCompilationUnitFunction>())).definition as *const _
5255 as usize
5256 },
5257 40usize,
5258 concat!(
5259 "Offset of field: ",
5260 stringify!(MOJOSHADER_astCompilationUnitFunction),
5261 "::",
5262 stringify!(definition)
5263 )
5264 );
5265 assert_eq!(
5266 unsafe {
5267 &(*(::std::ptr::null::<MOJOSHADER_astCompilationUnitFunction>())).index as *const _
5268 as usize
5269 },
5270 48usize,
5271 concat!(
5272 "Offset of field: ",
5273 stringify!(MOJOSHADER_astCompilationUnitFunction),
5274 "::",
5275 stringify!(index)
5276 )
5277 );
5278}
5279#[repr(C)]
5280#[derive(Debug, Copy, Clone)]
5281pub struct MOJOSHADER_astCompilationUnitTypedef {
5282 pub ast: MOJOSHADER_astNodeInfo,
5283 pub next: *mut MOJOSHADER_astCompilationUnit,
5284 pub type_info: *mut MOJOSHADER_astTypedef,
5285}
5286#[test]
5287fn bindgen_test_layout_MOJOSHADER_astCompilationUnitTypedef() {
5288 assert_eq!(
5289 ::std::mem::size_of::<MOJOSHADER_astCompilationUnitTypedef>(),
5290 40usize,
5291 concat!(
5292 "Size of: ",
5293 stringify!(MOJOSHADER_astCompilationUnitTypedef)
5294 )
5295 );
5296 assert_eq!(
5297 ::std::mem::align_of::<MOJOSHADER_astCompilationUnitTypedef>(),
5298 8usize,
5299 concat!(
5300 "Alignment of ",
5301 stringify!(MOJOSHADER_astCompilationUnitTypedef)
5302 )
5303 );
5304 assert_eq!(
5305 unsafe {
5306 &(*(::std::ptr::null::<MOJOSHADER_astCompilationUnitTypedef>())).ast as *const _
5307 as usize
5308 },
5309 0usize,
5310 concat!(
5311 "Offset of field: ",
5312 stringify!(MOJOSHADER_astCompilationUnitTypedef),
5313 "::",
5314 stringify!(ast)
5315 )
5316 );
5317 assert_eq!(
5318 unsafe {
5319 &(*(::std::ptr::null::<MOJOSHADER_astCompilationUnitTypedef>())).next as *const _
5320 as usize
5321 },
5322 24usize,
5323 concat!(
5324 "Offset of field: ",
5325 stringify!(MOJOSHADER_astCompilationUnitTypedef),
5326 "::",
5327 stringify!(next)
5328 )
5329 );
5330 assert_eq!(
5331 unsafe {
5332 &(*(::std::ptr::null::<MOJOSHADER_astCompilationUnitTypedef>())).type_info as *const _
5333 as usize
5334 },
5335 32usize,
5336 concat!(
5337 "Offset of field: ",
5338 stringify!(MOJOSHADER_astCompilationUnitTypedef),
5339 "::",
5340 stringify!(type_info)
5341 )
5342 );
5343}
5344#[repr(C)]
5345#[derive(Debug, Copy, Clone)]
5346pub struct MOJOSHADER_astCompilationUnitStruct {
5347 pub ast: MOJOSHADER_astNodeInfo,
5348 pub next: *mut MOJOSHADER_astCompilationUnit,
5349 pub struct_info: *mut MOJOSHADER_astStructDeclaration,
5350}
5351#[test]
5352fn bindgen_test_layout_MOJOSHADER_astCompilationUnitStruct() {
5353 assert_eq!(
5354 ::std::mem::size_of::<MOJOSHADER_astCompilationUnitStruct>(),
5355 40usize,
5356 concat!("Size of: ", stringify!(MOJOSHADER_astCompilationUnitStruct))
5357 );
5358 assert_eq!(
5359 ::std::mem::align_of::<MOJOSHADER_astCompilationUnitStruct>(),
5360 8usize,
5361 concat!(
5362 "Alignment of ",
5363 stringify!(MOJOSHADER_astCompilationUnitStruct)
5364 )
5365 );
5366 assert_eq!(
5367 unsafe {
5368 &(*(::std::ptr::null::<MOJOSHADER_astCompilationUnitStruct>())).ast as *const _ as usize
5369 },
5370 0usize,
5371 concat!(
5372 "Offset of field: ",
5373 stringify!(MOJOSHADER_astCompilationUnitStruct),
5374 "::",
5375 stringify!(ast)
5376 )
5377 );
5378 assert_eq!(
5379 unsafe {
5380 &(*(::std::ptr::null::<MOJOSHADER_astCompilationUnitStruct>())).next as *const _
5381 as usize
5382 },
5383 24usize,
5384 concat!(
5385 "Offset of field: ",
5386 stringify!(MOJOSHADER_astCompilationUnitStruct),
5387 "::",
5388 stringify!(next)
5389 )
5390 );
5391 assert_eq!(
5392 unsafe {
5393 &(*(::std::ptr::null::<MOJOSHADER_astCompilationUnitStruct>())).struct_info as *const _
5394 as usize
5395 },
5396 32usize,
5397 concat!(
5398 "Offset of field: ",
5399 stringify!(MOJOSHADER_astCompilationUnitStruct),
5400 "::",
5401 stringify!(struct_info)
5402 )
5403 );
5404}
5405#[repr(C)]
5406#[derive(Debug, Copy, Clone)]
5407pub struct MOJOSHADER_astCompilationUnitVariable {
5408 pub ast: MOJOSHADER_astNodeInfo,
5409 pub next: *mut MOJOSHADER_astCompilationUnit,
5410 pub declaration: *mut MOJOSHADER_astVariableDeclaration,
5411}
5412#[test]
5413fn bindgen_test_layout_MOJOSHADER_astCompilationUnitVariable() {
5414 assert_eq!(
5415 ::std::mem::size_of::<MOJOSHADER_astCompilationUnitVariable>(),
5416 40usize,
5417 concat!(
5418 "Size of: ",
5419 stringify!(MOJOSHADER_astCompilationUnitVariable)
5420 )
5421 );
5422 assert_eq!(
5423 ::std::mem::align_of::<MOJOSHADER_astCompilationUnitVariable>(),
5424 8usize,
5425 concat!(
5426 "Alignment of ",
5427 stringify!(MOJOSHADER_astCompilationUnitVariable)
5428 )
5429 );
5430 assert_eq!(
5431 unsafe {
5432 &(*(::std::ptr::null::<MOJOSHADER_astCompilationUnitVariable>())).ast as *const _
5433 as usize
5434 },
5435 0usize,
5436 concat!(
5437 "Offset of field: ",
5438 stringify!(MOJOSHADER_astCompilationUnitVariable),
5439 "::",
5440 stringify!(ast)
5441 )
5442 );
5443 assert_eq!(
5444 unsafe {
5445 &(*(::std::ptr::null::<MOJOSHADER_astCompilationUnitVariable>())).next as *const _
5446 as usize
5447 },
5448 24usize,
5449 concat!(
5450 "Offset of field: ",
5451 stringify!(MOJOSHADER_astCompilationUnitVariable),
5452 "::",
5453 stringify!(next)
5454 )
5455 );
5456 assert_eq!(
5457 unsafe {
5458 &(*(::std::ptr::null::<MOJOSHADER_astCompilationUnitVariable>())).declaration
5459 as *const _ as usize
5460 },
5461 32usize,
5462 concat!(
5463 "Offset of field: ",
5464 stringify!(MOJOSHADER_astCompilationUnitVariable),
5465 "::",
5466 stringify!(declaration)
5467 )
5468 );
5469}
5470#[repr(C)]
5471#[derive(Copy, Clone)]
5472pub union MOJOSHADER_astNode {
5473 pub ast: MOJOSHADER_astNodeInfo,
5474 pub generic: MOJOSHADER_astGeneric,
5475 pub expression: MOJOSHADER_astExpression,
5476 pub arguments: MOJOSHADER_astArguments,
5477 pub unary: MOJOSHADER_astExpressionUnary,
5478 pub binary: MOJOSHADER_astExpressionBinary,
5479 pub ternary: MOJOSHADER_astExpressionTernary,
5480 pub identifier: MOJOSHADER_astExpressionIdentifier,
5481 pub intliteral: MOJOSHADER_astExpressionIntLiteral,
5482 pub floatliteral: MOJOSHADER_astExpressionFloatLiteral,
5483 pub stringliteral: MOJOSHADER_astExpressionStringLiteral,
5484 pub boolliteral: MOJOSHADER_astExpressionBooleanLiteral,
5485 pub constructor: MOJOSHADER_astExpressionConstructor,
5486 pub derefstruct: MOJOSHADER_astExpressionDerefStruct,
5487 pub callfunc: MOJOSHADER_astExpressionCallFunction,
5488 pub cast: MOJOSHADER_astExpressionCast,
5489 pub compunit: MOJOSHADER_astCompilationUnit,
5490 pub params: MOJOSHADER_astFunctionParameters,
5491 pub funcsig: MOJOSHADER_astFunctionSignature,
5492 pub soa: MOJOSHADER_astScalarOrArray,
5493 pub annotations: MOJOSHADER_astAnnotations,
5494 pub packoffset: MOJOSHADER_astPackOffset,
5495 pub varlowlevel: MOJOSHADER_astVariableLowLevel,
5496 pub structmembers: MOJOSHADER_astStructMembers,
5497 pub structdecl: MOJOSHADER_astStructDeclaration,
5498 pub vardecl: MOJOSHADER_astVariableDeclaration,
5499 pub stmt: MOJOSHADER_astStatement,
5500 pub emptystmt: MOJOSHADER_astEmptyStatement,
5501 pub breakstmt: MOJOSHADER_astBreakStatement,
5502 pub contstmt: MOJOSHADER_astContinueStatement,
5503 pub discardstmt: MOJOSHADER_astDiscardStatement,
5504 pub blockstmt: MOJOSHADER_astBlockStatement,
5505 pub returnstmt: MOJOSHADER_astReturnStatement,
5506 pub exprstmt: MOJOSHADER_astExpressionStatement,
5507 pub ifstmt: MOJOSHADER_astIfStatement,
5508 pub cases: MOJOSHADER_astSwitchCases,
5509 pub switchstmt: MOJOSHADER_astSwitchStatement,
5510 pub whilestmt: MOJOSHADER_astWhileStatement,
5511 pub dostmt: MOJOSHADER_astDoStatement,
5512 pub forstmt: MOJOSHADER_astForStatement,
5513 pub typdef: MOJOSHADER_astTypedef,
5514 pub typedefstmt: MOJOSHADER_astTypedefStatement,
5515 pub vardeclstmt: MOJOSHADER_astVarDeclStatement,
5516 pub structstmt: MOJOSHADER_astStructStatement,
5517 pub funcunit: MOJOSHADER_astCompilationUnitFunction,
5518 pub typedefunit: MOJOSHADER_astCompilationUnitTypedef,
5519 pub structunit: MOJOSHADER_astCompilationUnitStruct,
5520 pub varunit: MOJOSHADER_astCompilationUnitVariable,
5521 _bindgen_union_align: [u64; 12usize],
5522}
5523#[test]
5524fn bindgen_test_layout_MOJOSHADER_astNode() {
5525 assert_eq!(
5526 ::std::mem::size_of::<MOJOSHADER_astNode>(),
5527 96usize,
5528 concat!("Size of: ", stringify!(MOJOSHADER_astNode))
5529 );
5530 assert_eq!(
5531 ::std::mem::align_of::<MOJOSHADER_astNode>(),
5532 8usize,
5533 concat!("Alignment of ", stringify!(MOJOSHADER_astNode))
5534 );
5535 assert_eq!(
5536 unsafe { &(*(::std::ptr::null::<MOJOSHADER_astNode>())).ast as *const _ as usize },
5537 0usize,
5538 concat!(
5539 "Offset of field: ",
5540 stringify!(MOJOSHADER_astNode),
5541 "::",
5542 stringify!(ast)
5543 )
5544 );
5545 assert_eq!(
5546 unsafe { &(*(::std::ptr::null::<MOJOSHADER_astNode>())).generic as *const _ as usize },
5547 0usize,
5548 concat!(
5549 "Offset of field: ",
5550 stringify!(MOJOSHADER_astNode),
5551 "::",
5552 stringify!(generic)
5553 )
5554 );
5555 assert_eq!(
5556 unsafe { &(*(::std::ptr::null::<MOJOSHADER_astNode>())).expression as *const _ as usize },
5557 0usize,
5558 concat!(
5559 "Offset of field: ",
5560 stringify!(MOJOSHADER_astNode),
5561 "::",
5562 stringify!(expression)
5563 )
5564 );
5565 assert_eq!(
5566 unsafe { &(*(::std::ptr::null::<MOJOSHADER_astNode>())).arguments as *const _ as usize },
5567 0usize,
5568 concat!(
5569 "Offset of field: ",
5570 stringify!(MOJOSHADER_astNode),
5571 "::",
5572 stringify!(arguments)
5573 )
5574 );
5575 assert_eq!(
5576 unsafe { &(*(::std::ptr::null::<MOJOSHADER_astNode>())).unary as *const _ as usize },
5577 0usize,
5578 concat!(
5579 "Offset of field: ",
5580 stringify!(MOJOSHADER_astNode),
5581 "::",
5582 stringify!(unary)
5583 )
5584 );
5585 assert_eq!(
5586 unsafe { &(*(::std::ptr::null::<MOJOSHADER_astNode>())).binary as *const _ as usize },
5587 0usize,
5588 concat!(
5589 "Offset of field: ",
5590 stringify!(MOJOSHADER_astNode),
5591 "::",
5592 stringify!(binary)
5593 )
5594 );
5595 assert_eq!(
5596 unsafe { &(*(::std::ptr::null::<MOJOSHADER_astNode>())).ternary as *const _ as usize },
5597 0usize,
5598 concat!(
5599 "Offset of field: ",
5600 stringify!(MOJOSHADER_astNode),
5601 "::",
5602 stringify!(ternary)
5603 )
5604 );
5605 assert_eq!(
5606 unsafe { &(*(::std::ptr::null::<MOJOSHADER_astNode>())).identifier as *const _ as usize },
5607 0usize,
5608 concat!(
5609 "Offset of field: ",
5610 stringify!(MOJOSHADER_astNode),
5611 "::",
5612 stringify!(identifier)
5613 )
5614 );
5615 assert_eq!(
5616 unsafe { &(*(::std::ptr::null::<MOJOSHADER_astNode>())).intliteral as *const _ as usize },
5617 0usize,
5618 concat!(
5619 "Offset of field: ",
5620 stringify!(MOJOSHADER_astNode),
5621 "::",
5622 stringify!(intliteral)
5623 )
5624 );
5625 assert_eq!(
5626 unsafe { &(*(::std::ptr::null::<MOJOSHADER_astNode>())).floatliteral as *const _ as usize },
5627 0usize,
5628 concat!(
5629 "Offset of field: ",
5630 stringify!(MOJOSHADER_astNode),
5631 "::",
5632 stringify!(floatliteral)
5633 )
5634 );
5635 assert_eq!(
5636 unsafe {
5637 &(*(::std::ptr::null::<MOJOSHADER_astNode>())).stringliteral as *const _ as usize
5638 },
5639 0usize,
5640 concat!(
5641 "Offset of field: ",
5642 stringify!(MOJOSHADER_astNode),
5643 "::",
5644 stringify!(stringliteral)
5645 )
5646 );
5647 assert_eq!(
5648 unsafe { &(*(::std::ptr::null::<MOJOSHADER_astNode>())).boolliteral as *const _ as usize },
5649 0usize,
5650 concat!(
5651 "Offset of field: ",
5652 stringify!(MOJOSHADER_astNode),
5653 "::",
5654 stringify!(boolliteral)
5655 )
5656 );
5657 assert_eq!(
5658 unsafe { &(*(::std::ptr::null::<MOJOSHADER_astNode>())).constructor as *const _ as usize },
5659 0usize,
5660 concat!(
5661 "Offset of field: ",
5662 stringify!(MOJOSHADER_astNode),
5663 "::",
5664 stringify!(constructor)
5665 )
5666 );
5667 assert_eq!(
5668 unsafe { &(*(::std::ptr::null::<MOJOSHADER_astNode>())).derefstruct as *const _ as usize },
5669 0usize,
5670 concat!(
5671 "Offset of field: ",
5672 stringify!(MOJOSHADER_astNode),
5673 "::",
5674 stringify!(derefstruct)
5675 )
5676 );
5677 assert_eq!(
5678 unsafe { &(*(::std::ptr::null::<MOJOSHADER_astNode>())).callfunc as *const _ as usize },
5679 0usize,
5680 concat!(
5681 "Offset of field: ",
5682 stringify!(MOJOSHADER_astNode),
5683 "::",
5684 stringify!(callfunc)
5685 )
5686 );
5687 assert_eq!(
5688 unsafe { &(*(::std::ptr::null::<MOJOSHADER_astNode>())).cast as *const _ as usize },
5689 0usize,
5690 concat!(
5691 "Offset of field: ",
5692 stringify!(MOJOSHADER_astNode),
5693 "::",
5694 stringify!(cast)
5695 )
5696 );
5697 assert_eq!(
5698 unsafe { &(*(::std::ptr::null::<MOJOSHADER_astNode>())).compunit as *const _ as usize },
5699 0usize,
5700 concat!(
5701 "Offset of field: ",
5702 stringify!(MOJOSHADER_astNode),
5703 "::",
5704 stringify!(compunit)
5705 )
5706 );
5707 assert_eq!(
5708 unsafe { &(*(::std::ptr::null::<MOJOSHADER_astNode>())).params as *const _ as usize },
5709 0usize,
5710 concat!(
5711 "Offset of field: ",
5712 stringify!(MOJOSHADER_astNode),
5713 "::",
5714 stringify!(params)
5715 )
5716 );
5717 assert_eq!(
5718 unsafe { &(*(::std::ptr::null::<MOJOSHADER_astNode>())).funcsig as *const _ as usize },
5719 0usize,
5720 concat!(
5721 "Offset of field: ",
5722 stringify!(MOJOSHADER_astNode),
5723 "::",
5724 stringify!(funcsig)
5725 )
5726 );
5727 assert_eq!(
5728 unsafe { &(*(::std::ptr::null::<MOJOSHADER_astNode>())).soa as *const _ as usize },
5729 0usize,
5730 concat!(
5731 "Offset of field: ",
5732 stringify!(MOJOSHADER_astNode),
5733 "::",
5734 stringify!(soa)
5735 )
5736 );
5737 assert_eq!(
5738 unsafe { &(*(::std::ptr::null::<MOJOSHADER_astNode>())).annotations as *const _ as usize },
5739 0usize,
5740 concat!(
5741 "Offset of field: ",
5742 stringify!(MOJOSHADER_astNode),
5743 "::",
5744 stringify!(annotations)
5745 )
5746 );
5747 assert_eq!(
5748 unsafe { &(*(::std::ptr::null::<MOJOSHADER_astNode>())).packoffset as *const _ as usize },
5749 0usize,
5750 concat!(
5751 "Offset of field: ",
5752 stringify!(MOJOSHADER_astNode),
5753 "::",
5754 stringify!(packoffset)
5755 )
5756 );
5757 assert_eq!(
5758 unsafe { &(*(::std::ptr::null::<MOJOSHADER_astNode>())).varlowlevel as *const _ as usize },
5759 0usize,
5760 concat!(
5761 "Offset of field: ",
5762 stringify!(MOJOSHADER_astNode),
5763 "::",
5764 stringify!(varlowlevel)
5765 )
5766 );
5767 assert_eq!(
5768 unsafe {
5769 &(*(::std::ptr::null::<MOJOSHADER_astNode>())).structmembers as *const _ as usize
5770 },
5771 0usize,
5772 concat!(
5773 "Offset of field: ",
5774 stringify!(MOJOSHADER_astNode),
5775 "::",
5776 stringify!(structmembers)
5777 )
5778 );
5779 assert_eq!(
5780 unsafe { &(*(::std::ptr::null::<MOJOSHADER_astNode>())).structdecl as *const _ as usize },
5781 0usize,
5782 concat!(
5783 "Offset of field: ",
5784 stringify!(MOJOSHADER_astNode),
5785 "::",
5786 stringify!(structdecl)
5787 )
5788 );
5789 assert_eq!(
5790 unsafe { &(*(::std::ptr::null::<MOJOSHADER_astNode>())).vardecl as *const _ as usize },
5791 0usize,
5792 concat!(
5793 "Offset of field: ",
5794 stringify!(MOJOSHADER_astNode),
5795 "::",
5796 stringify!(vardecl)
5797 )
5798 );
5799 assert_eq!(
5800 unsafe { &(*(::std::ptr::null::<MOJOSHADER_astNode>())).stmt as *const _ as usize },
5801 0usize,
5802 concat!(
5803 "Offset of field: ",
5804 stringify!(MOJOSHADER_astNode),
5805 "::",
5806 stringify!(stmt)
5807 )
5808 );
5809 assert_eq!(
5810 unsafe { &(*(::std::ptr::null::<MOJOSHADER_astNode>())).emptystmt as *const _ as usize },
5811 0usize,
5812 concat!(
5813 "Offset of field: ",
5814 stringify!(MOJOSHADER_astNode),
5815 "::",
5816 stringify!(emptystmt)
5817 )
5818 );
5819 assert_eq!(
5820 unsafe { &(*(::std::ptr::null::<MOJOSHADER_astNode>())).breakstmt as *const _ as usize },
5821 0usize,
5822 concat!(
5823 "Offset of field: ",
5824 stringify!(MOJOSHADER_astNode),
5825 "::",
5826 stringify!(breakstmt)
5827 )
5828 );
5829 assert_eq!(
5830 unsafe { &(*(::std::ptr::null::<MOJOSHADER_astNode>())).contstmt as *const _ as usize },
5831 0usize,
5832 concat!(
5833 "Offset of field: ",
5834 stringify!(MOJOSHADER_astNode),
5835 "::",
5836 stringify!(contstmt)
5837 )
5838 );
5839 assert_eq!(
5840 unsafe { &(*(::std::ptr::null::<MOJOSHADER_astNode>())).discardstmt as *const _ as usize },
5841 0usize,
5842 concat!(
5843 "Offset of field: ",
5844 stringify!(MOJOSHADER_astNode),
5845 "::",
5846 stringify!(discardstmt)
5847 )
5848 );
5849 assert_eq!(
5850 unsafe { &(*(::std::ptr::null::<MOJOSHADER_astNode>())).blockstmt as *const _ as usize },
5851 0usize,
5852 concat!(
5853 "Offset of field: ",
5854 stringify!(MOJOSHADER_astNode),
5855 "::",
5856 stringify!(blockstmt)
5857 )
5858 );
5859 assert_eq!(
5860 unsafe { &(*(::std::ptr::null::<MOJOSHADER_astNode>())).returnstmt as *const _ as usize },
5861 0usize,
5862 concat!(
5863 "Offset of field: ",
5864 stringify!(MOJOSHADER_astNode),
5865 "::",
5866 stringify!(returnstmt)
5867 )
5868 );
5869 assert_eq!(
5870 unsafe { &(*(::std::ptr::null::<MOJOSHADER_astNode>())).exprstmt as *const _ as usize },
5871 0usize,
5872 concat!(
5873 "Offset of field: ",
5874 stringify!(MOJOSHADER_astNode),
5875 "::",
5876 stringify!(exprstmt)
5877 )
5878 );
5879 assert_eq!(
5880 unsafe { &(*(::std::ptr::null::<MOJOSHADER_astNode>())).ifstmt as *const _ as usize },
5881 0usize,
5882 concat!(
5883 "Offset of field: ",
5884 stringify!(MOJOSHADER_astNode),
5885 "::",
5886 stringify!(ifstmt)
5887 )
5888 );
5889 assert_eq!(
5890 unsafe { &(*(::std::ptr::null::<MOJOSHADER_astNode>())).cases as *const _ as usize },
5891 0usize,
5892 concat!(
5893 "Offset of field: ",
5894 stringify!(MOJOSHADER_astNode),
5895 "::",
5896 stringify!(cases)
5897 )
5898 );
5899 assert_eq!(
5900 unsafe { &(*(::std::ptr::null::<MOJOSHADER_astNode>())).switchstmt as *const _ as usize },
5901 0usize,
5902 concat!(
5903 "Offset of field: ",
5904 stringify!(MOJOSHADER_astNode),
5905 "::",
5906 stringify!(switchstmt)
5907 )
5908 );
5909 assert_eq!(
5910 unsafe { &(*(::std::ptr::null::<MOJOSHADER_astNode>())).whilestmt as *const _ as usize },
5911 0usize,
5912 concat!(
5913 "Offset of field: ",
5914 stringify!(MOJOSHADER_astNode),
5915 "::",
5916 stringify!(whilestmt)
5917 )
5918 );
5919 assert_eq!(
5920 unsafe { &(*(::std::ptr::null::<MOJOSHADER_astNode>())).dostmt as *const _ as usize },
5921 0usize,
5922 concat!(
5923 "Offset of field: ",
5924 stringify!(MOJOSHADER_astNode),
5925 "::",
5926 stringify!(dostmt)
5927 )
5928 );
5929 assert_eq!(
5930 unsafe { &(*(::std::ptr::null::<MOJOSHADER_astNode>())).forstmt as *const _ as usize },
5931 0usize,
5932 concat!(
5933 "Offset of field: ",
5934 stringify!(MOJOSHADER_astNode),
5935 "::",
5936 stringify!(forstmt)
5937 )
5938 );
5939 assert_eq!(
5940 unsafe { &(*(::std::ptr::null::<MOJOSHADER_astNode>())).typdef as *const _ as usize },
5941 0usize,
5942 concat!(
5943 "Offset of field: ",
5944 stringify!(MOJOSHADER_astNode),
5945 "::",
5946 stringify!(typdef)
5947 )
5948 );
5949 assert_eq!(
5950 unsafe { &(*(::std::ptr::null::<MOJOSHADER_astNode>())).typedefstmt as *const _ as usize },
5951 0usize,
5952 concat!(
5953 "Offset of field: ",
5954 stringify!(MOJOSHADER_astNode),
5955 "::",
5956 stringify!(typedefstmt)
5957 )
5958 );
5959 assert_eq!(
5960 unsafe { &(*(::std::ptr::null::<MOJOSHADER_astNode>())).vardeclstmt as *const _ as usize },
5961 0usize,
5962 concat!(
5963 "Offset of field: ",
5964 stringify!(MOJOSHADER_astNode),
5965 "::",
5966 stringify!(vardeclstmt)
5967 )
5968 );
5969 assert_eq!(
5970 unsafe { &(*(::std::ptr::null::<MOJOSHADER_astNode>())).structstmt as *const _ as usize },
5971 0usize,
5972 concat!(
5973 "Offset of field: ",
5974 stringify!(MOJOSHADER_astNode),
5975 "::",
5976 stringify!(structstmt)
5977 )
5978 );
5979 assert_eq!(
5980 unsafe { &(*(::std::ptr::null::<MOJOSHADER_astNode>())).funcunit as *const _ as usize },
5981 0usize,
5982 concat!(
5983 "Offset of field: ",
5984 stringify!(MOJOSHADER_astNode),
5985 "::",
5986 stringify!(funcunit)
5987 )
5988 );
5989 assert_eq!(
5990 unsafe { &(*(::std::ptr::null::<MOJOSHADER_astNode>())).typedefunit as *const _ as usize },
5991 0usize,
5992 concat!(
5993 "Offset of field: ",
5994 stringify!(MOJOSHADER_astNode),
5995 "::",
5996 stringify!(typedefunit)
5997 )
5998 );
5999 assert_eq!(
6000 unsafe { &(*(::std::ptr::null::<MOJOSHADER_astNode>())).structunit as *const _ as usize },
6001 0usize,
6002 concat!(
6003 "Offset of field: ",
6004 stringify!(MOJOSHADER_astNode),
6005 "::",
6006 stringify!(structunit)
6007 )
6008 );
6009 assert_eq!(
6010 unsafe { &(*(::std::ptr::null::<MOJOSHADER_astNode>())).varunit as *const _ as usize },
6011 0usize,
6012 concat!(
6013 "Offset of field: ",
6014 stringify!(MOJOSHADER_astNode),
6015 "::",
6016 stringify!(varunit)
6017 )
6018 );
6019}
6020#[repr(C)]
6021#[derive(Debug, Copy, Clone)]
6022pub struct MOJOSHADER_astData {
6023 pub error_count: ::std::os::raw::c_int,
6024 pub errors: *mut MOJOSHADER_error,
6025 pub source_profile: *const ::std::os::raw::c_char,
6026 pub ast: *const MOJOSHADER_astNode,
6027 pub malloc: MOJOSHADER_malloc,
6028 pub free: MOJOSHADER_free,
6029 pub malloc_data: *mut ::std::os::raw::c_void,
6030 pub opaque: *mut ::std::os::raw::c_void,
6031}
6032#[test]
6033fn bindgen_test_layout_MOJOSHADER_astData() {
6034 assert_eq!(
6035 ::std::mem::size_of::<MOJOSHADER_astData>(),
6036 64usize,
6037 concat!("Size of: ", stringify!(MOJOSHADER_astData))
6038 );
6039 assert_eq!(
6040 ::std::mem::align_of::<MOJOSHADER_astData>(),
6041 8usize,
6042 concat!("Alignment of ", stringify!(MOJOSHADER_astData))
6043 );
6044 assert_eq!(
6045 unsafe { &(*(::std::ptr::null::<MOJOSHADER_astData>())).error_count as *const _ as usize },
6046 0usize,
6047 concat!(
6048 "Offset of field: ",
6049 stringify!(MOJOSHADER_astData),
6050 "::",
6051 stringify!(error_count)
6052 )
6053 );
6054 assert_eq!(
6055 unsafe { &(*(::std::ptr::null::<MOJOSHADER_astData>())).errors as *const _ as usize },
6056 8usize,
6057 concat!(
6058 "Offset of field: ",
6059 stringify!(MOJOSHADER_astData),
6060 "::",
6061 stringify!(errors)
6062 )
6063 );
6064 assert_eq!(
6065 unsafe {
6066 &(*(::std::ptr::null::<MOJOSHADER_astData>())).source_profile as *const _ as usize
6067 },
6068 16usize,
6069 concat!(
6070 "Offset of field: ",
6071 stringify!(MOJOSHADER_astData),
6072 "::",
6073 stringify!(source_profile)
6074 )
6075 );
6076 assert_eq!(
6077 unsafe { &(*(::std::ptr::null::<MOJOSHADER_astData>())).ast as *const _ as usize },
6078 24usize,
6079 concat!(
6080 "Offset of field: ",
6081 stringify!(MOJOSHADER_astData),
6082 "::",
6083 stringify!(ast)
6084 )
6085 );
6086 assert_eq!(
6087 unsafe { &(*(::std::ptr::null::<MOJOSHADER_astData>())).malloc as *const _ as usize },
6088 32usize,
6089 concat!(
6090 "Offset of field: ",
6091 stringify!(MOJOSHADER_astData),
6092 "::",
6093 stringify!(malloc)
6094 )
6095 );
6096 assert_eq!(
6097 unsafe { &(*(::std::ptr::null::<MOJOSHADER_astData>())).free as *const _ as usize },
6098 40usize,
6099 concat!(
6100 "Offset of field: ",
6101 stringify!(MOJOSHADER_astData),
6102 "::",
6103 stringify!(free)
6104 )
6105 );
6106 assert_eq!(
6107 unsafe { &(*(::std::ptr::null::<MOJOSHADER_astData>())).malloc_data as *const _ as usize },
6108 48usize,
6109 concat!(
6110 "Offset of field: ",
6111 stringify!(MOJOSHADER_astData),
6112 "::",
6113 stringify!(malloc_data)
6114 )
6115 );
6116 assert_eq!(
6117 unsafe { &(*(::std::ptr::null::<MOJOSHADER_astData>())).opaque as *const _ as usize },
6118 56usize,
6119 concat!(
6120 "Offset of field: ",
6121 stringify!(MOJOSHADER_astData),
6122 "::",
6123 stringify!(opaque)
6124 )
6125 );
6126}
6127extern "C" {
6128 pub fn MOJOSHADER_parseAst(
6129 srcprofile: *const ::std::os::raw::c_char,
6130 filename: *const ::std::os::raw::c_char,
6131 source: *const ::std::os::raw::c_char,
6132 sourcelen: ::std::os::raw::c_uint,
6133 defs: *const MOJOSHADER_preprocessorDefine,
6134 define_count: ::std::os::raw::c_uint,
6135 include_open: MOJOSHADER_includeOpen,
6136 include_close: MOJOSHADER_includeClose,
6137 m: MOJOSHADER_malloc,
6138 f: MOJOSHADER_free,
6139 d: *mut ::std::os::raw::c_void,
6140 ) -> *const MOJOSHADER_astData;
6141}
6142extern "C" {
6143 pub fn MOJOSHADER_freeAstData(data: *const MOJOSHADER_astData);
6144}
6145pub const MOJOSHADER_irNodeType_MOJOSHADER_IR_START_RANGE_EXPR: MOJOSHADER_irNodeType = 0;
6146pub const MOJOSHADER_irNodeType_MOJOSHADER_IR_CONSTANT: MOJOSHADER_irNodeType = 1;
6147pub const MOJOSHADER_irNodeType_MOJOSHADER_IR_TEMP: MOJOSHADER_irNodeType = 2;
6148pub const MOJOSHADER_irNodeType_MOJOSHADER_IR_BINOP: MOJOSHADER_irNodeType = 3;
6149pub const MOJOSHADER_irNodeType_MOJOSHADER_IR_MEMORY: MOJOSHADER_irNodeType = 4;
6150pub const MOJOSHADER_irNodeType_MOJOSHADER_IR_CALL: MOJOSHADER_irNodeType = 5;
6151pub const MOJOSHADER_irNodeType_MOJOSHADER_IR_ESEQ: MOJOSHADER_irNodeType = 6;
6152pub const MOJOSHADER_irNodeType_MOJOSHADER_IR_ARRAY: MOJOSHADER_irNodeType = 7;
6153pub const MOJOSHADER_irNodeType_MOJOSHADER_IR_CONVERT: MOJOSHADER_irNodeType = 8;
6154pub const MOJOSHADER_irNodeType_MOJOSHADER_IR_SWIZZLE: MOJOSHADER_irNodeType = 9;
6155pub const MOJOSHADER_irNodeType_MOJOSHADER_IR_CONSTRUCT: MOJOSHADER_irNodeType = 10;
6156pub const MOJOSHADER_irNodeType_MOJOSHADER_IR_END_RANGE_EXPR: MOJOSHADER_irNodeType = 11;
6157pub const MOJOSHADER_irNodeType_MOJOSHADER_IR_START_RANGE_STMT: MOJOSHADER_irNodeType = 12;
6158pub const MOJOSHADER_irNodeType_MOJOSHADER_IR_MOVE: MOJOSHADER_irNodeType = 13;
6159pub const MOJOSHADER_irNodeType_MOJOSHADER_IR_EXPR_STMT: MOJOSHADER_irNodeType = 14;
6160pub const MOJOSHADER_irNodeType_MOJOSHADER_IR_JUMP: MOJOSHADER_irNodeType = 15;
6161pub const MOJOSHADER_irNodeType_MOJOSHADER_IR_CJUMP: MOJOSHADER_irNodeType = 16;
6162pub const MOJOSHADER_irNodeType_MOJOSHADER_IR_SEQ: MOJOSHADER_irNodeType = 17;
6163pub const MOJOSHADER_irNodeType_MOJOSHADER_IR_LABEL: MOJOSHADER_irNodeType = 18;
6164pub const MOJOSHADER_irNodeType_MOJOSHADER_IR_DISCARD: MOJOSHADER_irNodeType = 19;
6165pub const MOJOSHADER_irNodeType_MOJOSHADER_IR_END_RANGE_STMT: MOJOSHADER_irNodeType = 20;
6166pub const MOJOSHADER_irNodeType_MOJOSHADER_IR_START_RANGE_MISC: MOJOSHADER_irNodeType = 21;
6167pub const MOJOSHADER_irNodeType_MOJOSHADER_IR_EXPRLIST: MOJOSHADER_irNodeType = 22;
6168pub const MOJOSHADER_irNodeType_MOJOSHADER_IR_END_RANGE_MISC: MOJOSHADER_irNodeType = 23;
6169pub const MOJOSHADER_irNodeType_MOJOSHADER_IR_END_RANGE: MOJOSHADER_irNodeType = 24;
6170pub type MOJOSHADER_irNodeType = ::std::os::raw::c_uint;
6171#[repr(C)]
6172#[derive(Debug, Copy, Clone)]
6173pub struct MOJOSHADER_irNodeInfo {
6174 pub type_: MOJOSHADER_irNodeType,
6175 pub filename: *const ::std::os::raw::c_char,
6176 pub line: ::std::os::raw::c_uint,
6177}
6178#[test]
6179fn bindgen_test_layout_MOJOSHADER_irNodeInfo() {
6180 assert_eq!(
6181 ::std::mem::size_of::<MOJOSHADER_irNodeInfo>(),
6182 24usize,
6183 concat!("Size of: ", stringify!(MOJOSHADER_irNodeInfo))
6184 );
6185 assert_eq!(
6186 ::std::mem::align_of::<MOJOSHADER_irNodeInfo>(),
6187 8usize,
6188 concat!("Alignment of ", stringify!(MOJOSHADER_irNodeInfo))
6189 );
6190 assert_eq!(
6191 unsafe { &(*(::std::ptr::null::<MOJOSHADER_irNodeInfo>())).type_ as *const _ as usize },
6192 0usize,
6193 concat!(
6194 "Offset of field: ",
6195 stringify!(MOJOSHADER_irNodeInfo),
6196 "::",
6197 stringify!(type_)
6198 )
6199 );
6200 assert_eq!(
6201 unsafe { &(*(::std::ptr::null::<MOJOSHADER_irNodeInfo>())).filename as *const _ as usize },
6202 8usize,
6203 concat!(
6204 "Offset of field: ",
6205 stringify!(MOJOSHADER_irNodeInfo),
6206 "::",
6207 stringify!(filename)
6208 )
6209 );
6210 assert_eq!(
6211 unsafe { &(*(::std::ptr::null::<MOJOSHADER_irNodeInfo>())).line as *const _ as usize },
6212 16usize,
6213 concat!(
6214 "Offset of field: ",
6215 stringify!(MOJOSHADER_irNodeInfo),
6216 "::",
6217 stringify!(line)
6218 )
6219 );
6220}
6221#[repr(C)]
6222#[derive(Debug, Copy, Clone)]
6223pub struct MOJOSHADER_irGeneric {
6224 pub ir: MOJOSHADER_irNodeInfo,
6225}
6226#[test]
6227fn bindgen_test_layout_MOJOSHADER_irGeneric() {
6228 assert_eq!(
6229 ::std::mem::size_of::<MOJOSHADER_irGeneric>(),
6230 24usize,
6231 concat!("Size of: ", stringify!(MOJOSHADER_irGeneric))
6232 );
6233 assert_eq!(
6234 ::std::mem::align_of::<MOJOSHADER_irGeneric>(),
6235 8usize,
6236 concat!("Alignment of ", stringify!(MOJOSHADER_irGeneric))
6237 );
6238 assert_eq!(
6239 unsafe { &(*(::std::ptr::null::<MOJOSHADER_irGeneric>())).ir as *const _ as usize },
6240 0usize,
6241 concat!(
6242 "Offset of field: ",
6243 stringify!(MOJOSHADER_irGeneric),
6244 "::",
6245 stringify!(ir)
6246 )
6247 );
6248}
6249pub const MOJOSHADER_irBinOpType_MOJOSHADER_IR_BINOP_ADD: MOJOSHADER_irBinOpType = 0;
6250pub const MOJOSHADER_irBinOpType_MOJOSHADER_IR_BINOP_SUBTRACT: MOJOSHADER_irBinOpType = 1;
6251pub const MOJOSHADER_irBinOpType_MOJOSHADER_IR_BINOP_MULTIPLY: MOJOSHADER_irBinOpType = 2;
6252pub const MOJOSHADER_irBinOpType_MOJOSHADER_IR_BINOP_DIVIDE: MOJOSHADER_irBinOpType = 3;
6253pub const MOJOSHADER_irBinOpType_MOJOSHADER_IR_BINOP_MODULO: MOJOSHADER_irBinOpType = 4;
6254pub const MOJOSHADER_irBinOpType_MOJOSHADER_IR_BINOP_AND: MOJOSHADER_irBinOpType = 5;
6255pub const MOJOSHADER_irBinOpType_MOJOSHADER_IR_BINOP_OR: MOJOSHADER_irBinOpType = 6;
6256pub const MOJOSHADER_irBinOpType_MOJOSHADER_IR_BINOP_XOR: MOJOSHADER_irBinOpType = 7;
6257pub const MOJOSHADER_irBinOpType_MOJOSHADER_IR_BINOP_LSHIFT: MOJOSHADER_irBinOpType = 8;
6258pub const MOJOSHADER_irBinOpType_MOJOSHADER_IR_BINOP_RSHIFT: MOJOSHADER_irBinOpType = 9;
6259pub const MOJOSHADER_irBinOpType_MOJOSHADER_IR_BINOP_UNKNOWN: MOJOSHADER_irBinOpType = 10;
6260pub type MOJOSHADER_irBinOpType = ::std::os::raw::c_uint;
6261pub const MOJOSHADER_irConditionType_MOJOSHADER_IR_COND_EQL: MOJOSHADER_irConditionType = 0;
6262pub const MOJOSHADER_irConditionType_MOJOSHADER_IR_COND_NEQ: MOJOSHADER_irConditionType = 1;
6263pub const MOJOSHADER_irConditionType_MOJOSHADER_IR_COND_LT: MOJOSHADER_irConditionType = 2;
6264pub const MOJOSHADER_irConditionType_MOJOSHADER_IR_COND_GT: MOJOSHADER_irConditionType = 3;
6265pub const MOJOSHADER_irConditionType_MOJOSHADER_IR_COND_LEQ: MOJOSHADER_irConditionType = 4;
6266pub const MOJOSHADER_irConditionType_MOJOSHADER_IR_COND_GEQ: MOJOSHADER_irConditionType = 5;
6267pub const MOJOSHADER_irConditionType_MOJOSHADER_IR_COND_UNKNOWN: MOJOSHADER_irConditionType = 6;
6268pub type MOJOSHADER_irConditionType = ::std::os::raw::c_uint;
6269#[repr(C)]
6270#[derive(Debug, Copy, Clone)]
6271pub struct MOJOSHADER_irExprInfo {
6272 pub ir: MOJOSHADER_irNodeInfo,
6273 pub type_: MOJOSHADER_astDataTypeType,
6274 pub elements: ::std::os::raw::c_int,
6275}
6276#[test]
6277fn bindgen_test_layout_MOJOSHADER_irExprInfo() {
6278 assert_eq!(
6279 ::std::mem::size_of::<MOJOSHADER_irExprInfo>(),
6280 32usize,
6281 concat!("Size of: ", stringify!(MOJOSHADER_irExprInfo))
6282 );
6283 assert_eq!(
6284 ::std::mem::align_of::<MOJOSHADER_irExprInfo>(),
6285 8usize,
6286 concat!("Alignment of ", stringify!(MOJOSHADER_irExprInfo))
6287 );
6288 assert_eq!(
6289 unsafe { &(*(::std::ptr::null::<MOJOSHADER_irExprInfo>())).ir as *const _ as usize },
6290 0usize,
6291 concat!(
6292 "Offset of field: ",
6293 stringify!(MOJOSHADER_irExprInfo),
6294 "::",
6295 stringify!(ir)
6296 )
6297 );
6298 assert_eq!(
6299 unsafe { &(*(::std::ptr::null::<MOJOSHADER_irExprInfo>())).type_ as *const _ as usize },
6300 24usize,
6301 concat!(
6302 "Offset of field: ",
6303 stringify!(MOJOSHADER_irExprInfo),
6304 "::",
6305 stringify!(type_)
6306 )
6307 );
6308 assert_eq!(
6309 unsafe { &(*(::std::ptr::null::<MOJOSHADER_irExprInfo>())).elements as *const _ as usize },
6310 28usize,
6311 concat!(
6312 "Offset of field: ",
6313 stringify!(MOJOSHADER_irExprInfo),
6314 "::",
6315 stringify!(elements)
6316 )
6317 );
6318}
6319#[repr(C)]
6320#[derive(Copy, Clone)]
6321pub struct MOJOSHADER_irConstant {
6322 pub info: MOJOSHADER_irExprInfo,
6323 pub value: MOJOSHADER_irConstant__bindgen_ty_1,
6324}
6325#[repr(C)]
6326#[derive(Copy, Clone)]
6327pub union MOJOSHADER_irConstant__bindgen_ty_1 {
6328 pub ival: [::std::os::raw::c_int; 16usize],
6329 pub fval: [f32; 16usize],
6330 _bindgen_union_align: [u32; 16usize],
6331}
6332#[test]
6333fn bindgen_test_layout_MOJOSHADER_irConstant__bindgen_ty_1() {
6334 assert_eq!(
6335 ::std::mem::size_of::<MOJOSHADER_irConstant__bindgen_ty_1>(),
6336 64usize,
6337 concat!("Size of: ", stringify!(MOJOSHADER_irConstant__bindgen_ty_1))
6338 );
6339 assert_eq!(
6340 ::std::mem::align_of::<MOJOSHADER_irConstant__bindgen_ty_1>(),
6341 4usize,
6342 concat!(
6343 "Alignment of ",
6344 stringify!(MOJOSHADER_irConstant__bindgen_ty_1)
6345 )
6346 );
6347 assert_eq!(
6348 unsafe {
6349 &(*(::std::ptr::null::<MOJOSHADER_irConstant__bindgen_ty_1>())).ival as *const _
6350 as usize
6351 },
6352 0usize,
6353 concat!(
6354 "Offset of field: ",
6355 stringify!(MOJOSHADER_irConstant__bindgen_ty_1),
6356 "::",
6357 stringify!(ival)
6358 )
6359 );
6360 assert_eq!(
6361 unsafe {
6362 &(*(::std::ptr::null::<MOJOSHADER_irConstant__bindgen_ty_1>())).fval as *const _
6363 as usize
6364 },
6365 0usize,
6366 concat!(
6367 "Offset of field: ",
6368 stringify!(MOJOSHADER_irConstant__bindgen_ty_1),
6369 "::",
6370 stringify!(fval)
6371 )
6372 );
6373}
6374#[test]
6375fn bindgen_test_layout_MOJOSHADER_irConstant() {
6376 assert_eq!(
6377 ::std::mem::size_of::<MOJOSHADER_irConstant>(),
6378 96usize,
6379 concat!("Size of: ", stringify!(MOJOSHADER_irConstant))
6380 );
6381 assert_eq!(
6382 ::std::mem::align_of::<MOJOSHADER_irConstant>(),
6383 8usize,
6384 concat!("Alignment of ", stringify!(MOJOSHADER_irConstant))
6385 );
6386 assert_eq!(
6387 unsafe { &(*(::std::ptr::null::<MOJOSHADER_irConstant>())).info as *const _ as usize },
6388 0usize,
6389 concat!(
6390 "Offset of field: ",
6391 stringify!(MOJOSHADER_irConstant),
6392 "::",
6393 stringify!(info)
6394 )
6395 );
6396 assert_eq!(
6397 unsafe { &(*(::std::ptr::null::<MOJOSHADER_irConstant>())).value as *const _ as usize },
6398 32usize,
6399 concat!(
6400 "Offset of field: ",
6401 stringify!(MOJOSHADER_irConstant),
6402 "::",
6403 stringify!(value)
6404 )
6405 );
6406}
6407#[repr(C)]
6408#[derive(Debug, Copy, Clone)]
6409pub struct MOJOSHADER_irTemp {
6410 pub info: MOJOSHADER_irExprInfo,
6411 pub index: ::std::os::raw::c_int,
6412}
6413#[test]
6414fn bindgen_test_layout_MOJOSHADER_irTemp() {
6415 assert_eq!(
6416 ::std::mem::size_of::<MOJOSHADER_irTemp>(),
6417 40usize,
6418 concat!("Size of: ", stringify!(MOJOSHADER_irTemp))
6419 );
6420 assert_eq!(
6421 ::std::mem::align_of::<MOJOSHADER_irTemp>(),
6422 8usize,
6423 concat!("Alignment of ", stringify!(MOJOSHADER_irTemp))
6424 );
6425 assert_eq!(
6426 unsafe { &(*(::std::ptr::null::<MOJOSHADER_irTemp>())).info as *const _ as usize },
6427 0usize,
6428 concat!(
6429 "Offset of field: ",
6430 stringify!(MOJOSHADER_irTemp),
6431 "::",
6432 stringify!(info)
6433 )
6434 );
6435 assert_eq!(
6436 unsafe { &(*(::std::ptr::null::<MOJOSHADER_irTemp>())).index as *const _ as usize },
6437 32usize,
6438 concat!(
6439 "Offset of field: ",
6440 stringify!(MOJOSHADER_irTemp),
6441 "::",
6442 stringify!(index)
6443 )
6444 );
6445}
6446#[repr(C)]
6447#[derive(Debug, Copy, Clone)]
6448pub struct MOJOSHADER_irBinOp {
6449 pub info: MOJOSHADER_irExprInfo,
6450 pub op: MOJOSHADER_irBinOpType,
6451 pub left: *mut MOJOSHADER_irExpression,
6452 pub right: *mut MOJOSHADER_irExpression,
6453}
6454#[test]
6455fn bindgen_test_layout_MOJOSHADER_irBinOp() {
6456 assert_eq!(
6457 ::std::mem::size_of::<MOJOSHADER_irBinOp>(),
6458 56usize,
6459 concat!("Size of: ", stringify!(MOJOSHADER_irBinOp))
6460 );
6461 assert_eq!(
6462 ::std::mem::align_of::<MOJOSHADER_irBinOp>(),
6463 8usize,
6464 concat!("Alignment of ", stringify!(MOJOSHADER_irBinOp))
6465 );
6466 assert_eq!(
6467 unsafe { &(*(::std::ptr::null::<MOJOSHADER_irBinOp>())).info as *const _ as usize },
6468 0usize,
6469 concat!(
6470 "Offset of field: ",
6471 stringify!(MOJOSHADER_irBinOp),
6472 "::",
6473 stringify!(info)
6474 )
6475 );
6476 assert_eq!(
6477 unsafe { &(*(::std::ptr::null::<MOJOSHADER_irBinOp>())).op as *const _ as usize },
6478 32usize,
6479 concat!(
6480 "Offset of field: ",
6481 stringify!(MOJOSHADER_irBinOp),
6482 "::",
6483 stringify!(op)
6484 )
6485 );
6486 assert_eq!(
6487 unsafe { &(*(::std::ptr::null::<MOJOSHADER_irBinOp>())).left as *const _ as usize },
6488 40usize,
6489 concat!(
6490 "Offset of field: ",
6491 stringify!(MOJOSHADER_irBinOp),
6492 "::",
6493 stringify!(left)
6494 )
6495 );
6496 assert_eq!(
6497 unsafe { &(*(::std::ptr::null::<MOJOSHADER_irBinOp>())).right as *const _ as usize },
6498 48usize,
6499 concat!(
6500 "Offset of field: ",
6501 stringify!(MOJOSHADER_irBinOp),
6502 "::",
6503 stringify!(right)
6504 )
6505 );
6506}
6507#[repr(C)]
6508#[derive(Debug, Copy, Clone)]
6509pub struct MOJOSHADER_irMemory {
6510 pub info: MOJOSHADER_irExprInfo,
6511 pub index: ::std::os::raw::c_int,
6512}
6513#[test]
6514fn bindgen_test_layout_MOJOSHADER_irMemory() {
6515 assert_eq!(
6516 ::std::mem::size_of::<MOJOSHADER_irMemory>(),
6517 40usize,
6518 concat!("Size of: ", stringify!(MOJOSHADER_irMemory))
6519 );
6520 assert_eq!(
6521 ::std::mem::align_of::<MOJOSHADER_irMemory>(),
6522 8usize,
6523 concat!("Alignment of ", stringify!(MOJOSHADER_irMemory))
6524 );
6525 assert_eq!(
6526 unsafe { &(*(::std::ptr::null::<MOJOSHADER_irMemory>())).info as *const _ as usize },
6527 0usize,
6528 concat!(
6529 "Offset of field: ",
6530 stringify!(MOJOSHADER_irMemory),
6531 "::",
6532 stringify!(info)
6533 )
6534 );
6535 assert_eq!(
6536 unsafe { &(*(::std::ptr::null::<MOJOSHADER_irMemory>())).index as *const _ as usize },
6537 32usize,
6538 concat!(
6539 "Offset of field: ",
6540 stringify!(MOJOSHADER_irMemory),
6541 "::",
6542 stringify!(index)
6543 )
6544 );
6545}
6546#[repr(C)]
6547#[derive(Debug, Copy, Clone)]
6548pub struct MOJOSHADER_irCall {
6549 pub info: MOJOSHADER_irExprInfo,
6550 pub index: ::std::os::raw::c_int,
6551 pub args: *mut MOJOSHADER_irExprList,
6552}
6553#[test]
6554fn bindgen_test_layout_MOJOSHADER_irCall() {
6555 assert_eq!(
6556 ::std::mem::size_of::<MOJOSHADER_irCall>(),
6557 48usize,
6558 concat!("Size of: ", stringify!(MOJOSHADER_irCall))
6559 );
6560 assert_eq!(
6561 ::std::mem::align_of::<MOJOSHADER_irCall>(),
6562 8usize,
6563 concat!("Alignment of ", stringify!(MOJOSHADER_irCall))
6564 );
6565 assert_eq!(
6566 unsafe { &(*(::std::ptr::null::<MOJOSHADER_irCall>())).info as *const _ as usize },
6567 0usize,
6568 concat!(
6569 "Offset of field: ",
6570 stringify!(MOJOSHADER_irCall),
6571 "::",
6572 stringify!(info)
6573 )
6574 );
6575 assert_eq!(
6576 unsafe { &(*(::std::ptr::null::<MOJOSHADER_irCall>())).index as *const _ as usize },
6577 32usize,
6578 concat!(
6579 "Offset of field: ",
6580 stringify!(MOJOSHADER_irCall),
6581 "::",
6582 stringify!(index)
6583 )
6584 );
6585 assert_eq!(
6586 unsafe { &(*(::std::ptr::null::<MOJOSHADER_irCall>())).args as *const _ as usize },
6587 40usize,
6588 concat!(
6589 "Offset of field: ",
6590 stringify!(MOJOSHADER_irCall),
6591 "::",
6592 stringify!(args)
6593 )
6594 );
6595}
6596#[repr(C)]
6597#[derive(Debug, Copy, Clone)]
6598pub struct MOJOSHADER_irESeq {
6599 pub info: MOJOSHADER_irExprInfo,
6600 pub stmt: *mut MOJOSHADER_irStatement,
6601 pub expr: *mut MOJOSHADER_irExpression,
6602}
6603#[test]
6604fn bindgen_test_layout_MOJOSHADER_irESeq() {
6605 assert_eq!(
6606 ::std::mem::size_of::<MOJOSHADER_irESeq>(),
6607 48usize,
6608 concat!("Size of: ", stringify!(MOJOSHADER_irESeq))
6609 );
6610 assert_eq!(
6611 ::std::mem::align_of::<MOJOSHADER_irESeq>(),
6612 8usize,
6613 concat!("Alignment of ", stringify!(MOJOSHADER_irESeq))
6614 );
6615 assert_eq!(
6616 unsafe { &(*(::std::ptr::null::<MOJOSHADER_irESeq>())).info as *const _ as usize },
6617 0usize,
6618 concat!(
6619 "Offset of field: ",
6620 stringify!(MOJOSHADER_irESeq),
6621 "::",
6622 stringify!(info)
6623 )
6624 );
6625 assert_eq!(
6626 unsafe { &(*(::std::ptr::null::<MOJOSHADER_irESeq>())).stmt as *const _ as usize },
6627 32usize,
6628 concat!(
6629 "Offset of field: ",
6630 stringify!(MOJOSHADER_irESeq),
6631 "::",
6632 stringify!(stmt)
6633 )
6634 );
6635 assert_eq!(
6636 unsafe { &(*(::std::ptr::null::<MOJOSHADER_irESeq>())).expr as *const _ as usize },
6637 40usize,
6638 concat!(
6639 "Offset of field: ",
6640 stringify!(MOJOSHADER_irESeq),
6641 "::",
6642 stringify!(expr)
6643 )
6644 );
6645}
6646#[repr(C)]
6647#[derive(Debug, Copy, Clone)]
6648pub struct MOJOSHADER_irArray {
6649 pub info: MOJOSHADER_irExprInfo,
6650 pub array: *mut MOJOSHADER_irExpression,
6651 pub element: *mut MOJOSHADER_irExpression,
6652}
6653#[test]
6654fn bindgen_test_layout_MOJOSHADER_irArray() {
6655 assert_eq!(
6656 ::std::mem::size_of::<MOJOSHADER_irArray>(),
6657 48usize,
6658 concat!("Size of: ", stringify!(MOJOSHADER_irArray))
6659 );
6660 assert_eq!(
6661 ::std::mem::align_of::<MOJOSHADER_irArray>(),
6662 8usize,
6663 concat!("Alignment of ", stringify!(MOJOSHADER_irArray))
6664 );
6665 assert_eq!(
6666 unsafe { &(*(::std::ptr::null::<MOJOSHADER_irArray>())).info as *const _ as usize },
6667 0usize,
6668 concat!(
6669 "Offset of field: ",
6670 stringify!(MOJOSHADER_irArray),
6671 "::",
6672 stringify!(info)
6673 )
6674 );
6675 assert_eq!(
6676 unsafe { &(*(::std::ptr::null::<MOJOSHADER_irArray>())).array as *const _ as usize },
6677 32usize,
6678 concat!(
6679 "Offset of field: ",
6680 stringify!(MOJOSHADER_irArray),
6681 "::",
6682 stringify!(array)
6683 )
6684 );
6685 assert_eq!(
6686 unsafe { &(*(::std::ptr::null::<MOJOSHADER_irArray>())).element as *const _ as usize },
6687 40usize,
6688 concat!(
6689 "Offset of field: ",
6690 stringify!(MOJOSHADER_irArray),
6691 "::",
6692 stringify!(element)
6693 )
6694 );
6695}
6696#[repr(C)]
6697#[derive(Debug, Copy, Clone)]
6698pub struct MOJOSHADER_irConvert {
6699 pub info: MOJOSHADER_irExprInfo,
6700 pub expr: *mut MOJOSHADER_irExpression,
6701}
6702#[test]
6703fn bindgen_test_layout_MOJOSHADER_irConvert() {
6704 assert_eq!(
6705 ::std::mem::size_of::<MOJOSHADER_irConvert>(),
6706 40usize,
6707 concat!("Size of: ", stringify!(MOJOSHADER_irConvert))
6708 );
6709 assert_eq!(
6710 ::std::mem::align_of::<MOJOSHADER_irConvert>(),
6711 8usize,
6712 concat!("Alignment of ", stringify!(MOJOSHADER_irConvert))
6713 );
6714 assert_eq!(
6715 unsafe { &(*(::std::ptr::null::<MOJOSHADER_irConvert>())).info as *const _ as usize },
6716 0usize,
6717 concat!(
6718 "Offset of field: ",
6719 stringify!(MOJOSHADER_irConvert),
6720 "::",
6721 stringify!(info)
6722 )
6723 );
6724 assert_eq!(
6725 unsafe { &(*(::std::ptr::null::<MOJOSHADER_irConvert>())).expr as *const _ as usize },
6726 32usize,
6727 concat!(
6728 "Offset of field: ",
6729 stringify!(MOJOSHADER_irConvert),
6730 "::",
6731 stringify!(expr)
6732 )
6733 );
6734}
6735#[repr(C)]
6736#[derive(Debug, Copy, Clone)]
6737pub struct MOJOSHADER_irSwizzle {
6738 pub info: MOJOSHADER_irExprInfo,
6739 pub expr: *mut MOJOSHADER_irExpression,
6740 pub channels: [::std::os::raw::c_char; 4usize],
6741}
6742#[test]
6743fn bindgen_test_layout_MOJOSHADER_irSwizzle() {
6744 assert_eq!(
6745 ::std::mem::size_of::<MOJOSHADER_irSwizzle>(),
6746 48usize,
6747 concat!("Size of: ", stringify!(MOJOSHADER_irSwizzle))
6748 );
6749 assert_eq!(
6750 ::std::mem::align_of::<MOJOSHADER_irSwizzle>(),
6751 8usize,
6752 concat!("Alignment of ", stringify!(MOJOSHADER_irSwizzle))
6753 );
6754 assert_eq!(
6755 unsafe { &(*(::std::ptr::null::<MOJOSHADER_irSwizzle>())).info as *const _ as usize },
6756 0usize,
6757 concat!(
6758 "Offset of field: ",
6759 stringify!(MOJOSHADER_irSwizzle),
6760 "::",
6761 stringify!(info)
6762 )
6763 );
6764 assert_eq!(
6765 unsafe { &(*(::std::ptr::null::<MOJOSHADER_irSwizzle>())).expr as *const _ as usize },
6766 32usize,
6767 concat!(
6768 "Offset of field: ",
6769 stringify!(MOJOSHADER_irSwizzle),
6770 "::",
6771 stringify!(expr)
6772 )
6773 );
6774 assert_eq!(
6775 unsafe { &(*(::std::ptr::null::<MOJOSHADER_irSwizzle>())).channels as *const _ as usize },
6776 40usize,
6777 concat!(
6778 "Offset of field: ",
6779 stringify!(MOJOSHADER_irSwizzle),
6780 "::",
6781 stringify!(channels)
6782 )
6783 );
6784}
6785#[repr(C)]
6786#[derive(Debug, Copy, Clone)]
6787pub struct MOJOSHADER_irConstruct {
6788 pub info: MOJOSHADER_irExprInfo,
6789 pub args: *mut MOJOSHADER_irExprList,
6790}
6791#[test]
6792fn bindgen_test_layout_MOJOSHADER_irConstruct() {
6793 assert_eq!(
6794 ::std::mem::size_of::<MOJOSHADER_irConstruct>(),
6795 40usize,
6796 concat!("Size of: ", stringify!(MOJOSHADER_irConstruct))
6797 );
6798 assert_eq!(
6799 ::std::mem::align_of::<MOJOSHADER_irConstruct>(),
6800 8usize,
6801 concat!("Alignment of ", stringify!(MOJOSHADER_irConstruct))
6802 );
6803 assert_eq!(
6804 unsafe { &(*(::std::ptr::null::<MOJOSHADER_irConstruct>())).info as *const _ as usize },
6805 0usize,
6806 concat!(
6807 "Offset of field: ",
6808 stringify!(MOJOSHADER_irConstruct),
6809 "::",
6810 stringify!(info)
6811 )
6812 );
6813 assert_eq!(
6814 unsafe { &(*(::std::ptr::null::<MOJOSHADER_irConstruct>())).args as *const _ as usize },
6815 32usize,
6816 concat!(
6817 "Offset of field: ",
6818 stringify!(MOJOSHADER_irConstruct),
6819 "::",
6820 stringify!(args)
6821 )
6822 );
6823}
6824#[repr(C)]
6825#[derive(Copy, Clone)]
6826pub union MOJOSHADER_irExpression {
6827 pub ir: MOJOSHADER_irNodeInfo,
6828 pub info: MOJOSHADER_irExprInfo,
6829 pub constant: MOJOSHADER_irConstant,
6830 pub temp: MOJOSHADER_irTemp,
6831 pub binop: MOJOSHADER_irBinOp,
6832 pub memory: MOJOSHADER_irMemory,
6833 pub call: MOJOSHADER_irCall,
6834 pub eseq: MOJOSHADER_irESeq,
6835 pub array: MOJOSHADER_irArray,
6836 pub convert: MOJOSHADER_irConvert,
6837 pub swizzle: MOJOSHADER_irSwizzle,
6838 pub construct: MOJOSHADER_irConstruct,
6839 _bindgen_union_align: [u64; 12usize],
6840}
6841#[test]
6842fn bindgen_test_layout_MOJOSHADER_irExpression() {
6843 assert_eq!(
6844 ::std::mem::size_of::<MOJOSHADER_irExpression>(),
6845 96usize,
6846 concat!("Size of: ", stringify!(MOJOSHADER_irExpression))
6847 );
6848 assert_eq!(
6849 ::std::mem::align_of::<MOJOSHADER_irExpression>(),
6850 8usize,
6851 concat!("Alignment of ", stringify!(MOJOSHADER_irExpression))
6852 );
6853 assert_eq!(
6854 unsafe { &(*(::std::ptr::null::<MOJOSHADER_irExpression>())).ir as *const _ as usize },
6855 0usize,
6856 concat!(
6857 "Offset of field: ",
6858 stringify!(MOJOSHADER_irExpression),
6859 "::",
6860 stringify!(ir)
6861 )
6862 );
6863 assert_eq!(
6864 unsafe { &(*(::std::ptr::null::<MOJOSHADER_irExpression>())).info as *const _ as usize },
6865 0usize,
6866 concat!(
6867 "Offset of field: ",
6868 stringify!(MOJOSHADER_irExpression),
6869 "::",
6870 stringify!(info)
6871 )
6872 );
6873 assert_eq!(
6874 unsafe {
6875 &(*(::std::ptr::null::<MOJOSHADER_irExpression>())).constant as *const _ as usize
6876 },
6877 0usize,
6878 concat!(
6879 "Offset of field: ",
6880 stringify!(MOJOSHADER_irExpression),
6881 "::",
6882 stringify!(constant)
6883 )
6884 );
6885 assert_eq!(
6886 unsafe { &(*(::std::ptr::null::<MOJOSHADER_irExpression>())).temp as *const _ as usize },
6887 0usize,
6888 concat!(
6889 "Offset of field: ",
6890 stringify!(MOJOSHADER_irExpression),
6891 "::",
6892 stringify!(temp)
6893 )
6894 );
6895 assert_eq!(
6896 unsafe { &(*(::std::ptr::null::<MOJOSHADER_irExpression>())).binop as *const _ as usize },
6897 0usize,
6898 concat!(
6899 "Offset of field: ",
6900 stringify!(MOJOSHADER_irExpression),
6901 "::",
6902 stringify!(binop)
6903 )
6904 );
6905 assert_eq!(
6906 unsafe { &(*(::std::ptr::null::<MOJOSHADER_irExpression>())).memory as *const _ as usize },
6907 0usize,
6908 concat!(
6909 "Offset of field: ",
6910 stringify!(MOJOSHADER_irExpression),
6911 "::",
6912 stringify!(memory)
6913 )
6914 );
6915 assert_eq!(
6916 unsafe { &(*(::std::ptr::null::<MOJOSHADER_irExpression>())).call as *const _ as usize },
6917 0usize,
6918 concat!(
6919 "Offset of field: ",
6920 stringify!(MOJOSHADER_irExpression),
6921 "::",
6922 stringify!(call)
6923 )
6924 );
6925 assert_eq!(
6926 unsafe { &(*(::std::ptr::null::<MOJOSHADER_irExpression>())).eseq as *const _ as usize },
6927 0usize,
6928 concat!(
6929 "Offset of field: ",
6930 stringify!(MOJOSHADER_irExpression),
6931 "::",
6932 stringify!(eseq)
6933 )
6934 );
6935 assert_eq!(
6936 unsafe { &(*(::std::ptr::null::<MOJOSHADER_irExpression>())).array as *const _ as usize },
6937 0usize,
6938 concat!(
6939 "Offset of field: ",
6940 stringify!(MOJOSHADER_irExpression),
6941 "::",
6942 stringify!(array)
6943 )
6944 );
6945 assert_eq!(
6946 unsafe { &(*(::std::ptr::null::<MOJOSHADER_irExpression>())).convert as *const _ as usize },
6947 0usize,
6948 concat!(
6949 "Offset of field: ",
6950 stringify!(MOJOSHADER_irExpression),
6951 "::",
6952 stringify!(convert)
6953 )
6954 );
6955 assert_eq!(
6956 unsafe { &(*(::std::ptr::null::<MOJOSHADER_irExpression>())).swizzle as *const _ as usize },
6957 0usize,
6958 concat!(
6959 "Offset of field: ",
6960 stringify!(MOJOSHADER_irExpression),
6961 "::",
6962 stringify!(swizzle)
6963 )
6964 );
6965 assert_eq!(
6966 unsafe {
6967 &(*(::std::ptr::null::<MOJOSHADER_irExpression>())).construct as *const _ as usize
6968 },
6969 0usize,
6970 concat!(
6971 "Offset of field: ",
6972 stringify!(MOJOSHADER_irExpression),
6973 "::",
6974 stringify!(construct)
6975 )
6976 );
6977}
6978#[repr(C)]
6979#[derive(Debug, Copy, Clone)]
6980pub struct MOJOSHADER_irMove {
6981 pub ir: MOJOSHADER_irNodeInfo,
6982 pub dst: *mut MOJOSHADER_irExpression,
6983 pub src: *mut MOJOSHADER_irExpression,
6984 pub writemask: ::std::os::raw::c_int,
6985}
6986#[test]
6987fn bindgen_test_layout_MOJOSHADER_irMove() {
6988 assert_eq!(
6989 ::std::mem::size_of::<MOJOSHADER_irMove>(),
6990 48usize,
6991 concat!("Size of: ", stringify!(MOJOSHADER_irMove))
6992 );
6993 assert_eq!(
6994 ::std::mem::align_of::<MOJOSHADER_irMove>(),
6995 8usize,
6996 concat!("Alignment of ", stringify!(MOJOSHADER_irMove))
6997 );
6998 assert_eq!(
6999 unsafe { &(*(::std::ptr::null::<MOJOSHADER_irMove>())).ir as *const _ as usize },
7000 0usize,
7001 concat!(
7002 "Offset of field: ",
7003 stringify!(MOJOSHADER_irMove),
7004 "::",
7005 stringify!(ir)
7006 )
7007 );
7008 assert_eq!(
7009 unsafe { &(*(::std::ptr::null::<MOJOSHADER_irMove>())).dst as *const _ as usize },
7010 24usize,
7011 concat!(
7012 "Offset of field: ",
7013 stringify!(MOJOSHADER_irMove),
7014 "::",
7015 stringify!(dst)
7016 )
7017 );
7018 assert_eq!(
7019 unsafe { &(*(::std::ptr::null::<MOJOSHADER_irMove>())).src as *const _ as usize },
7020 32usize,
7021 concat!(
7022 "Offset of field: ",
7023 stringify!(MOJOSHADER_irMove),
7024 "::",
7025 stringify!(src)
7026 )
7027 );
7028 assert_eq!(
7029 unsafe { &(*(::std::ptr::null::<MOJOSHADER_irMove>())).writemask as *const _ as usize },
7030 40usize,
7031 concat!(
7032 "Offset of field: ",
7033 stringify!(MOJOSHADER_irMove),
7034 "::",
7035 stringify!(writemask)
7036 )
7037 );
7038}
7039#[repr(C)]
7040#[derive(Debug, Copy, Clone)]
7041pub struct MOJOSHADER_irExprStmt {
7042 pub ir: MOJOSHADER_irNodeInfo,
7043 pub expr: *mut MOJOSHADER_irExpression,
7044}
7045#[test]
7046fn bindgen_test_layout_MOJOSHADER_irExprStmt() {
7047 assert_eq!(
7048 ::std::mem::size_of::<MOJOSHADER_irExprStmt>(),
7049 32usize,
7050 concat!("Size of: ", stringify!(MOJOSHADER_irExprStmt))
7051 );
7052 assert_eq!(
7053 ::std::mem::align_of::<MOJOSHADER_irExprStmt>(),
7054 8usize,
7055 concat!("Alignment of ", stringify!(MOJOSHADER_irExprStmt))
7056 );
7057 assert_eq!(
7058 unsafe { &(*(::std::ptr::null::<MOJOSHADER_irExprStmt>())).ir as *const _ as usize },
7059 0usize,
7060 concat!(
7061 "Offset of field: ",
7062 stringify!(MOJOSHADER_irExprStmt),
7063 "::",
7064 stringify!(ir)
7065 )
7066 );
7067 assert_eq!(
7068 unsafe { &(*(::std::ptr::null::<MOJOSHADER_irExprStmt>())).expr as *const _ as usize },
7069 24usize,
7070 concat!(
7071 "Offset of field: ",
7072 stringify!(MOJOSHADER_irExprStmt),
7073 "::",
7074 stringify!(expr)
7075 )
7076 );
7077}
7078#[repr(C)]
7079#[derive(Debug, Copy, Clone)]
7080pub struct MOJOSHADER_irJump {
7081 pub ir: MOJOSHADER_irNodeInfo,
7082 pub label: ::std::os::raw::c_int,
7083}
7084#[test]
7085fn bindgen_test_layout_MOJOSHADER_irJump() {
7086 assert_eq!(
7087 ::std::mem::size_of::<MOJOSHADER_irJump>(),
7088 32usize,
7089 concat!("Size of: ", stringify!(MOJOSHADER_irJump))
7090 );
7091 assert_eq!(
7092 ::std::mem::align_of::<MOJOSHADER_irJump>(),
7093 8usize,
7094 concat!("Alignment of ", stringify!(MOJOSHADER_irJump))
7095 );
7096 assert_eq!(
7097 unsafe { &(*(::std::ptr::null::<MOJOSHADER_irJump>())).ir as *const _ as usize },
7098 0usize,
7099 concat!(
7100 "Offset of field: ",
7101 stringify!(MOJOSHADER_irJump),
7102 "::",
7103 stringify!(ir)
7104 )
7105 );
7106 assert_eq!(
7107 unsafe { &(*(::std::ptr::null::<MOJOSHADER_irJump>())).label as *const _ as usize },
7108 24usize,
7109 concat!(
7110 "Offset of field: ",
7111 stringify!(MOJOSHADER_irJump),
7112 "::",
7113 stringify!(label)
7114 )
7115 );
7116}
7117#[repr(C)]
7118#[derive(Debug, Copy, Clone)]
7119pub struct MOJOSHADER_irCJump {
7120 pub ir: MOJOSHADER_irNodeInfo,
7121 pub cond: MOJOSHADER_irConditionType,
7122 pub left: *mut MOJOSHADER_irExpression,
7123 pub right: *mut MOJOSHADER_irExpression,
7124 pub iftrue: ::std::os::raw::c_int,
7125 pub iffalse: ::std::os::raw::c_int,
7126}
7127#[test]
7128fn bindgen_test_layout_MOJOSHADER_irCJump() {
7129 assert_eq!(
7130 ::std::mem::size_of::<MOJOSHADER_irCJump>(),
7131 56usize,
7132 concat!("Size of: ", stringify!(MOJOSHADER_irCJump))
7133 );
7134 assert_eq!(
7135 ::std::mem::align_of::<MOJOSHADER_irCJump>(),
7136 8usize,
7137 concat!("Alignment of ", stringify!(MOJOSHADER_irCJump))
7138 );
7139 assert_eq!(
7140 unsafe { &(*(::std::ptr::null::<MOJOSHADER_irCJump>())).ir as *const _ as usize },
7141 0usize,
7142 concat!(
7143 "Offset of field: ",
7144 stringify!(MOJOSHADER_irCJump),
7145 "::",
7146 stringify!(ir)
7147 )
7148 );
7149 assert_eq!(
7150 unsafe { &(*(::std::ptr::null::<MOJOSHADER_irCJump>())).cond as *const _ as usize },
7151 24usize,
7152 concat!(
7153 "Offset of field: ",
7154 stringify!(MOJOSHADER_irCJump),
7155 "::",
7156 stringify!(cond)
7157 )
7158 );
7159 assert_eq!(
7160 unsafe { &(*(::std::ptr::null::<MOJOSHADER_irCJump>())).left as *const _ as usize },
7161 32usize,
7162 concat!(
7163 "Offset of field: ",
7164 stringify!(MOJOSHADER_irCJump),
7165 "::",
7166 stringify!(left)
7167 )
7168 );
7169 assert_eq!(
7170 unsafe { &(*(::std::ptr::null::<MOJOSHADER_irCJump>())).right as *const _ as usize },
7171 40usize,
7172 concat!(
7173 "Offset of field: ",
7174 stringify!(MOJOSHADER_irCJump),
7175 "::",
7176 stringify!(right)
7177 )
7178 );
7179 assert_eq!(
7180 unsafe { &(*(::std::ptr::null::<MOJOSHADER_irCJump>())).iftrue as *const _ as usize },
7181 48usize,
7182 concat!(
7183 "Offset of field: ",
7184 stringify!(MOJOSHADER_irCJump),
7185 "::",
7186 stringify!(iftrue)
7187 )
7188 );
7189 assert_eq!(
7190 unsafe { &(*(::std::ptr::null::<MOJOSHADER_irCJump>())).iffalse as *const _ as usize },
7191 52usize,
7192 concat!(
7193 "Offset of field: ",
7194 stringify!(MOJOSHADER_irCJump),
7195 "::",
7196 stringify!(iffalse)
7197 )
7198 );
7199}
7200#[repr(C)]
7201#[derive(Debug, Copy, Clone)]
7202pub struct MOJOSHADER_irSeq {
7203 pub ir: MOJOSHADER_irNodeInfo,
7204 pub first: *mut MOJOSHADER_irStatement,
7205 pub next: *mut MOJOSHADER_irStatement,
7206}
7207#[test]
7208fn bindgen_test_layout_MOJOSHADER_irSeq() {
7209 assert_eq!(
7210 ::std::mem::size_of::<MOJOSHADER_irSeq>(),
7211 40usize,
7212 concat!("Size of: ", stringify!(MOJOSHADER_irSeq))
7213 );
7214 assert_eq!(
7215 ::std::mem::align_of::<MOJOSHADER_irSeq>(),
7216 8usize,
7217 concat!("Alignment of ", stringify!(MOJOSHADER_irSeq))
7218 );
7219 assert_eq!(
7220 unsafe { &(*(::std::ptr::null::<MOJOSHADER_irSeq>())).ir as *const _ as usize },
7221 0usize,
7222 concat!(
7223 "Offset of field: ",
7224 stringify!(MOJOSHADER_irSeq),
7225 "::",
7226 stringify!(ir)
7227 )
7228 );
7229 assert_eq!(
7230 unsafe { &(*(::std::ptr::null::<MOJOSHADER_irSeq>())).first as *const _ as usize },
7231 24usize,
7232 concat!(
7233 "Offset of field: ",
7234 stringify!(MOJOSHADER_irSeq),
7235 "::",
7236 stringify!(first)
7237 )
7238 );
7239 assert_eq!(
7240 unsafe { &(*(::std::ptr::null::<MOJOSHADER_irSeq>())).next as *const _ as usize },
7241 32usize,
7242 concat!(
7243 "Offset of field: ",
7244 stringify!(MOJOSHADER_irSeq),
7245 "::",
7246 stringify!(next)
7247 )
7248 );
7249}
7250#[repr(C)]
7251#[derive(Debug, Copy, Clone)]
7252pub struct MOJOSHADER_irLabel {
7253 pub ir: MOJOSHADER_irNodeInfo,
7254 pub index: ::std::os::raw::c_int,
7255}
7256#[test]
7257fn bindgen_test_layout_MOJOSHADER_irLabel() {
7258 assert_eq!(
7259 ::std::mem::size_of::<MOJOSHADER_irLabel>(),
7260 32usize,
7261 concat!("Size of: ", stringify!(MOJOSHADER_irLabel))
7262 );
7263 assert_eq!(
7264 ::std::mem::align_of::<MOJOSHADER_irLabel>(),
7265 8usize,
7266 concat!("Alignment of ", stringify!(MOJOSHADER_irLabel))
7267 );
7268 assert_eq!(
7269 unsafe { &(*(::std::ptr::null::<MOJOSHADER_irLabel>())).ir as *const _ as usize },
7270 0usize,
7271 concat!(
7272 "Offset of field: ",
7273 stringify!(MOJOSHADER_irLabel),
7274 "::",
7275 stringify!(ir)
7276 )
7277 );
7278 assert_eq!(
7279 unsafe { &(*(::std::ptr::null::<MOJOSHADER_irLabel>())).index as *const _ as usize },
7280 24usize,
7281 concat!(
7282 "Offset of field: ",
7283 stringify!(MOJOSHADER_irLabel),
7284 "::",
7285 stringify!(index)
7286 )
7287 );
7288}
7289pub type MOJOSHADER_irDiscard = MOJOSHADER_irGeneric;
7290#[repr(C)]
7291#[derive(Copy, Clone)]
7292pub union MOJOSHADER_irStatement {
7293 pub ir: MOJOSHADER_irNodeInfo,
7294 pub generic: MOJOSHADER_irGeneric,
7295 pub move_: MOJOSHADER_irMove,
7296 pub expr: MOJOSHADER_irExprStmt,
7297 pub jump: MOJOSHADER_irJump,
7298 pub cjump: MOJOSHADER_irCJump,
7299 pub seq: MOJOSHADER_irSeq,
7300 pub label: MOJOSHADER_irLabel,
7301 pub discard: MOJOSHADER_irDiscard,
7302 _bindgen_union_align: [u64; 7usize],
7303}
7304#[test]
7305fn bindgen_test_layout_MOJOSHADER_irStatement() {
7306 assert_eq!(
7307 ::std::mem::size_of::<MOJOSHADER_irStatement>(),
7308 56usize,
7309 concat!("Size of: ", stringify!(MOJOSHADER_irStatement))
7310 );
7311 assert_eq!(
7312 ::std::mem::align_of::<MOJOSHADER_irStatement>(),
7313 8usize,
7314 concat!("Alignment of ", stringify!(MOJOSHADER_irStatement))
7315 );
7316 assert_eq!(
7317 unsafe { &(*(::std::ptr::null::<MOJOSHADER_irStatement>())).ir as *const _ as usize },
7318 0usize,
7319 concat!(
7320 "Offset of field: ",
7321 stringify!(MOJOSHADER_irStatement),
7322 "::",
7323 stringify!(ir)
7324 )
7325 );
7326 assert_eq!(
7327 unsafe { &(*(::std::ptr::null::<MOJOSHADER_irStatement>())).generic as *const _ as usize },
7328 0usize,
7329 concat!(
7330 "Offset of field: ",
7331 stringify!(MOJOSHADER_irStatement),
7332 "::",
7333 stringify!(generic)
7334 )
7335 );
7336 assert_eq!(
7337 unsafe { &(*(::std::ptr::null::<MOJOSHADER_irStatement>())).move_ as *const _ as usize },
7338 0usize,
7339 concat!(
7340 "Offset of field: ",
7341 stringify!(MOJOSHADER_irStatement),
7342 "::",
7343 stringify!(move_)
7344 )
7345 );
7346 assert_eq!(
7347 unsafe { &(*(::std::ptr::null::<MOJOSHADER_irStatement>())).expr as *const _ as usize },
7348 0usize,
7349 concat!(
7350 "Offset of field: ",
7351 stringify!(MOJOSHADER_irStatement),
7352 "::",
7353 stringify!(expr)
7354 )
7355 );
7356 assert_eq!(
7357 unsafe { &(*(::std::ptr::null::<MOJOSHADER_irStatement>())).jump as *const _ as usize },
7358 0usize,
7359 concat!(
7360 "Offset of field: ",
7361 stringify!(MOJOSHADER_irStatement),
7362 "::",
7363 stringify!(jump)
7364 )
7365 );
7366 assert_eq!(
7367 unsafe { &(*(::std::ptr::null::<MOJOSHADER_irStatement>())).cjump as *const _ as usize },
7368 0usize,
7369 concat!(
7370 "Offset of field: ",
7371 stringify!(MOJOSHADER_irStatement),
7372 "::",
7373 stringify!(cjump)
7374 )
7375 );
7376 assert_eq!(
7377 unsafe { &(*(::std::ptr::null::<MOJOSHADER_irStatement>())).seq as *const _ as usize },
7378 0usize,
7379 concat!(
7380 "Offset of field: ",
7381 stringify!(MOJOSHADER_irStatement),
7382 "::",
7383 stringify!(seq)
7384 )
7385 );
7386 assert_eq!(
7387 unsafe { &(*(::std::ptr::null::<MOJOSHADER_irStatement>())).label as *const _ as usize },
7388 0usize,
7389 concat!(
7390 "Offset of field: ",
7391 stringify!(MOJOSHADER_irStatement),
7392 "::",
7393 stringify!(label)
7394 )
7395 );
7396 assert_eq!(
7397 unsafe { &(*(::std::ptr::null::<MOJOSHADER_irStatement>())).discard as *const _ as usize },
7398 0usize,
7399 concat!(
7400 "Offset of field: ",
7401 stringify!(MOJOSHADER_irStatement),
7402 "::",
7403 stringify!(discard)
7404 )
7405 );
7406}
7407#[repr(C)]
7408#[derive(Debug, Copy, Clone)]
7409pub struct MOJOSHADER_irExprList {
7410 pub ir: MOJOSHADER_irNodeInfo,
7411 pub expr: *mut MOJOSHADER_irExpression,
7412 pub next: *mut MOJOSHADER_irExprList,
7413}
7414#[test]
7415fn bindgen_test_layout_MOJOSHADER_irExprList() {
7416 assert_eq!(
7417 ::std::mem::size_of::<MOJOSHADER_irExprList>(),
7418 40usize,
7419 concat!("Size of: ", stringify!(MOJOSHADER_irExprList))
7420 );
7421 assert_eq!(
7422 ::std::mem::align_of::<MOJOSHADER_irExprList>(),
7423 8usize,
7424 concat!("Alignment of ", stringify!(MOJOSHADER_irExprList))
7425 );
7426 assert_eq!(
7427 unsafe { &(*(::std::ptr::null::<MOJOSHADER_irExprList>())).ir as *const _ as usize },
7428 0usize,
7429 concat!(
7430 "Offset of field: ",
7431 stringify!(MOJOSHADER_irExprList),
7432 "::",
7433 stringify!(ir)
7434 )
7435 );
7436 assert_eq!(
7437 unsafe { &(*(::std::ptr::null::<MOJOSHADER_irExprList>())).expr as *const _ as usize },
7438 24usize,
7439 concat!(
7440 "Offset of field: ",
7441 stringify!(MOJOSHADER_irExprList),
7442 "::",
7443 stringify!(expr)
7444 )
7445 );
7446 assert_eq!(
7447 unsafe { &(*(::std::ptr::null::<MOJOSHADER_irExprList>())).next as *const _ as usize },
7448 32usize,
7449 concat!(
7450 "Offset of field: ",
7451 stringify!(MOJOSHADER_irExprList),
7452 "::",
7453 stringify!(next)
7454 )
7455 );
7456}
7457#[repr(C)]
7458#[derive(Copy, Clone)]
7459pub union MOJOSHADER_irMisc {
7460 pub ir: MOJOSHADER_irNodeInfo,
7461 pub generic: MOJOSHADER_irGeneric,
7462 pub exprlist: MOJOSHADER_irExprList,
7463 _bindgen_union_align: [u64; 5usize],
7464}
7465#[test]
7466fn bindgen_test_layout_MOJOSHADER_irMisc() {
7467 assert_eq!(
7468 ::std::mem::size_of::<MOJOSHADER_irMisc>(),
7469 40usize,
7470 concat!("Size of: ", stringify!(MOJOSHADER_irMisc))
7471 );
7472 assert_eq!(
7473 ::std::mem::align_of::<MOJOSHADER_irMisc>(),
7474 8usize,
7475 concat!("Alignment of ", stringify!(MOJOSHADER_irMisc))
7476 );
7477 assert_eq!(
7478 unsafe { &(*(::std::ptr::null::<MOJOSHADER_irMisc>())).ir as *const _ as usize },
7479 0usize,
7480 concat!(
7481 "Offset of field: ",
7482 stringify!(MOJOSHADER_irMisc),
7483 "::",
7484 stringify!(ir)
7485 )
7486 );
7487 assert_eq!(
7488 unsafe { &(*(::std::ptr::null::<MOJOSHADER_irMisc>())).generic as *const _ as usize },
7489 0usize,
7490 concat!(
7491 "Offset of field: ",
7492 stringify!(MOJOSHADER_irMisc),
7493 "::",
7494 stringify!(generic)
7495 )
7496 );
7497 assert_eq!(
7498 unsafe { &(*(::std::ptr::null::<MOJOSHADER_irMisc>())).exprlist as *const _ as usize },
7499 0usize,
7500 concat!(
7501 "Offset of field: ",
7502 stringify!(MOJOSHADER_irMisc),
7503 "::",
7504 stringify!(exprlist)
7505 )
7506 );
7507}
7508#[repr(C)]
7509#[derive(Copy, Clone)]
7510pub union MOJOSHADER_irNode {
7511 pub ir: MOJOSHADER_irNodeInfo,
7512 pub generic: MOJOSHADER_irGeneric,
7513 pub expr: MOJOSHADER_irExpression,
7514 pub stmt: MOJOSHADER_irStatement,
7515 pub misc: MOJOSHADER_irMisc,
7516 _bindgen_union_align: [u64; 12usize],
7517}
7518#[test]
7519fn bindgen_test_layout_MOJOSHADER_irNode() {
7520 assert_eq!(
7521 ::std::mem::size_of::<MOJOSHADER_irNode>(),
7522 96usize,
7523 concat!("Size of: ", stringify!(MOJOSHADER_irNode))
7524 );
7525 assert_eq!(
7526 ::std::mem::align_of::<MOJOSHADER_irNode>(),
7527 8usize,
7528 concat!("Alignment of ", stringify!(MOJOSHADER_irNode))
7529 );
7530 assert_eq!(
7531 unsafe { &(*(::std::ptr::null::<MOJOSHADER_irNode>())).ir as *const _ as usize },
7532 0usize,
7533 concat!(
7534 "Offset of field: ",
7535 stringify!(MOJOSHADER_irNode),
7536 "::",
7537 stringify!(ir)
7538 )
7539 );
7540 assert_eq!(
7541 unsafe { &(*(::std::ptr::null::<MOJOSHADER_irNode>())).generic as *const _ as usize },
7542 0usize,
7543 concat!(
7544 "Offset of field: ",
7545 stringify!(MOJOSHADER_irNode),
7546 "::",
7547 stringify!(generic)
7548 )
7549 );
7550 assert_eq!(
7551 unsafe { &(*(::std::ptr::null::<MOJOSHADER_irNode>())).expr as *const _ as usize },
7552 0usize,
7553 concat!(
7554 "Offset of field: ",
7555 stringify!(MOJOSHADER_irNode),
7556 "::",
7557 stringify!(expr)
7558 )
7559 );
7560 assert_eq!(
7561 unsafe { &(*(::std::ptr::null::<MOJOSHADER_irNode>())).stmt as *const _ as usize },
7562 0usize,
7563 concat!(
7564 "Offset of field: ",
7565 stringify!(MOJOSHADER_irNode),
7566 "::",
7567 stringify!(stmt)
7568 )
7569 );
7570 assert_eq!(
7571 unsafe { &(*(::std::ptr::null::<MOJOSHADER_irNode>())).misc as *const _ as usize },
7572 0usize,
7573 concat!(
7574 "Offset of field: ",
7575 stringify!(MOJOSHADER_irNode),
7576 "::",
7577 stringify!(misc)
7578 )
7579 );
7580}
7581#[repr(C)]
7582#[derive(Debug, Copy, Clone)]
7583pub struct MOJOSHADER_compileData {
7584 pub error_count: ::std::os::raw::c_int,
7585 pub errors: *mut MOJOSHADER_error,
7586 pub warning_count: ::std::os::raw::c_int,
7587 pub warnings: *mut MOJOSHADER_error,
7588 pub source_profile: *const ::std::os::raw::c_char,
7589 pub output: *const ::std::os::raw::c_char,
7590 pub output_len: ::std::os::raw::c_int,
7591 pub symbol_count: ::std::os::raw::c_int,
7592 pub symbols: *mut MOJOSHADER_symbol,
7593 pub malloc: MOJOSHADER_malloc,
7594 pub free: MOJOSHADER_free,
7595 pub malloc_data: *mut ::std::os::raw::c_void,
7596}
7597#[test]
7598fn bindgen_test_layout_MOJOSHADER_compileData() {
7599 assert_eq!(
7600 ::std::mem::size_of::<MOJOSHADER_compileData>(),
7601 88usize,
7602 concat!("Size of: ", stringify!(MOJOSHADER_compileData))
7603 );
7604 assert_eq!(
7605 ::std::mem::align_of::<MOJOSHADER_compileData>(),
7606 8usize,
7607 concat!("Alignment of ", stringify!(MOJOSHADER_compileData))
7608 );
7609 assert_eq!(
7610 unsafe {
7611 &(*(::std::ptr::null::<MOJOSHADER_compileData>())).error_count as *const _ as usize
7612 },
7613 0usize,
7614 concat!(
7615 "Offset of field: ",
7616 stringify!(MOJOSHADER_compileData),
7617 "::",
7618 stringify!(error_count)
7619 )
7620 );
7621 assert_eq!(
7622 unsafe { &(*(::std::ptr::null::<MOJOSHADER_compileData>())).errors as *const _ as usize },
7623 8usize,
7624 concat!(
7625 "Offset of field: ",
7626 stringify!(MOJOSHADER_compileData),
7627 "::",
7628 stringify!(errors)
7629 )
7630 );
7631 assert_eq!(
7632 unsafe {
7633 &(*(::std::ptr::null::<MOJOSHADER_compileData>())).warning_count as *const _ as usize
7634 },
7635 16usize,
7636 concat!(
7637 "Offset of field: ",
7638 stringify!(MOJOSHADER_compileData),
7639 "::",
7640 stringify!(warning_count)
7641 )
7642 );
7643 assert_eq!(
7644 unsafe { &(*(::std::ptr::null::<MOJOSHADER_compileData>())).warnings as *const _ as usize },
7645 24usize,
7646 concat!(
7647 "Offset of field: ",
7648 stringify!(MOJOSHADER_compileData),
7649 "::",
7650 stringify!(warnings)
7651 )
7652 );
7653 assert_eq!(
7654 unsafe {
7655 &(*(::std::ptr::null::<MOJOSHADER_compileData>())).source_profile as *const _ as usize
7656 },
7657 32usize,
7658 concat!(
7659 "Offset of field: ",
7660 stringify!(MOJOSHADER_compileData),
7661 "::",
7662 stringify!(source_profile)
7663 )
7664 );
7665 assert_eq!(
7666 unsafe { &(*(::std::ptr::null::<MOJOSHADER_compileData>())).output as *const _ as usize },
7667 40usize,
7668 concat!(
7669 "Offset of field: ",
7670 stringify!(MOJOSHADER_compileData),
7671 "::",
7672 stringify!(output)
7673 )
7674 );
7675 assert_eq!(
7676 unsafe {
7677 &(*(::std::ptr::null::<MOJOSHADER_compileData>())).output_len as *const _ as usize
7678 },
7679 48usize,
7680 concat!(
7681 "Offset of field: ",
7682 stringify!(MOJOSHADER_compileData),
7683 "::",
7684 stringify!(output_len)
7685 )
7686 );
7687 assert_eq!(
7688 unsafe {
7689 &(*(::std::ptr::null::<MOJOSHADER_compileData>())).symbol_count as *const _ as usize
7690 },
7691 52usize,
7692 concat!(
7693 "Offset of field: ",
7694 stringify!(MOJOSHADER_compileData),
7695 "::",
7696 stringify!(symbol_count)
7697 )
7698 );
7699 assert_eq!(
7700 unsafe { &(*(::std::ptr::null::<MOJOSHADER_compileData>())).symbols as *const _ as usize },
7701 56usize,
7702 concat!(
7703 "Offset of field: ",
7704 stringify!(MOJOSHADER_compileData),
7705 "::",
7706 stringify!(symbols)
7707 )
7708 );
7709 assert_eq!(
7710 unsafe { &(*(::std::ptr::null::<MOJOSHADER_compileData>())).malloc as *const _ as usize },
7711 64usize,
7712 concat!(
7713 "Offset of field: ",
7714 stringify!(MOJOSHADER_compileData),
7715 "::",
7716 stringify!(malloc)
7717 )
7718 );
7719 assert_eq!(
7720 unsafe { &(*(::std::ptr::null::<MOJOSHADER_compileData>())).free as *const _ as usize },
7721 72usize,
7722 concat!(
7723 "Offset of field: ",
7724 stringify!(MOJOSHADER_compileData),
7725 "::",
7726 stringify!(free)
7727 )
7728 );
7729 assert_eq!(
7730 unsafe {
7731 &(*(::std::ptr::null::<MOJOSHADER_compileData>())).malloc_data as *const _ as usize
7732 },
7733 80usize,
7734 concat!(
7735 "Offset of field: ",
7736 stringify!(MOJOSHADER_compileData),
7737 "::",
7738 stringify!(malloc_data)
7739 )
7740 );
7741}
7742extern "C" {
7743 pub fn MOJOSHADER_compile(
7744 srcprofile: *const ::std::os::raw::c_char,
7745 filename: *const ::std::os::raw::c_char,
7746 source: *const ::std::os::raw::c_char,
7747 sourcelen: ::std::os::raw::c_uint,
7748 defs: *const MOJOSHADER_preprocessorDefine,
7749 define_count: ::std::os::raw::c_uint,
7750 include_open: MOJOSHADER_includeOpen,
7751 include_close: MOJOSHADER_includeClose,
7752 m: MOJOSHADER_malloc,
7753 f: MOJOSHADER_free,
7754 d: *mut ::std::os::raw::c_void,
7755 ) -> *const MOJOSHADER_compileData;
7756}
7757extern "C" {
7758 pub fn MOJOSHADER_freeCompileData(data: *const MOJOSHADER_compileData);
7759}
7760pub type MOJOSHADER_glGetProcAddress = ::std::option::Option<
7761 unsafe extern "C" fn(
7762 fnname: *const ::std::os::raw::c_char,
7763 data: *mut ::std::os::raw::c_void,
7764 ) -> *mut ::std::os::raw::c_void,
7765>;
7766#[repr(C)]
7767#[derive(Debug, Copy, Clone)]
7768pub struct MOJOSHADER_glContext {
7769 _unused: [u8; 0],
7770}
7771#[repr(C)]
7772#[derive(Debug, Copy, Clone)]
7773pub struct MOJOSHADER_glShader {
7774 _unused: [u8; 0],
7775}
7776#[repr(C)]
7777#[derive(Debug, Copy, Clone)]
7778pub struct MOJOSHADER_glProgram {
7779 _unused: [u8; 0],
7780}
7781extern "C" {
7782 pub fn MOJOSHADER_glAvailableProfiles(
7783 lookup: MOJOSHADER_glGetProcAddress,
7784 lookup_d: *mut ::std::os::raw::c_void,
7785 profs: *mut *const ::std::os::raw::c_char,
7786 size: ::std::os::raw::c_int,
7787 m: MOJOSHADER_malloc,
7788 f: MOJOSHADER_free,
7789 malloc_d: *mut ::std::os::raw::c_void,
7790 ) -> ::std::os::raw::c_int;
7791}
7792extern "C" {
7793 pub fn MOJOSHADER_glBestProfile(
7794 lookup: MOJOSHADER_glGetProcAddress,
7795 lookup_d: *mut ::std::os::raw::c_void,
7796 m: MOJOSHADER_malloc,
7797 f: MOJOSHADER_free,
7798 malloc_d: *mut ::std::os::raw::c_void,
7799 ) -> *const ::std::os::raw::c_char;
7800}
7801extern "C" {
7802 pub fn MOJOSHADER_glCreateContext(
7803 profile: *const ::std::os::raw::c_char,
7804 lookup: MOJOSHADER_glGetProcAddress,
7805 lookup_d: *mut ::std::os::raw::c_void,
7806 m: MOJOSHADER_malloc,
7807 f: MOJOSHADER_free,
7808 malloc_d: *mut ::std::os::raw::c_void,
7809 ) -> *mut MOJOSHADER_glContext;
7810}
7811extern "C" {
7812 pub fn MOJOSHADER_glMakeContextCurrent(ctx: *mut MOJOSHADER_glContext);
7813}
7814extern "C" {
7815 pub fn MOJOSHADER_glGetError() -> *const ::std::os::raw::c_char;
7816}
7817extern "C" {
7818 pub fn MOJOSHADER_glMaxUniforms(shader_type: MOJOSHADER_shaderType) -> ::std::os::raw::c_int;
7819}
7820extern "C" {
7821 pub fn MOJOSHADER_glCompileShader(
7822 tokenbuf: *const ::std::os::raw::c_uchar,
7823 bufsize: ::std::os::raw::c_uint,
7824 swiz: *const MOJOSHADER_swizzle,
7825 swizcount: ::std::os::raw::c_uint,
7826 smap: *const MOJOSHADER_samplerMap,
7827 smapcount: ::std::os::raw::c_uint,
7828 ) -> *mut MOJOSHADER_glShader;
7829}
7830extern "C" {
7831 pub fn MOJOSHADER_glShaderAddRef(shader: *mut MOJOSHADER_glShader);
7832}
7833extern "C" {
7834 pub fn MOJOSHADER_glGetShaderParseData(
7835 shader: *mut MOJOSHADER_glShader,
7836 ) -> *const MOJOSHADER_parseData;
7837}
7838extern "C" {
7839 pub fn MOJOSHADER_glLinkProgram(
7840 vshader: *mut MOJOSHADER_glShader,
7841 pshader: *mut MOJOSHADER_glShader,
7842 ) -> *mut MOJOSHADER_glProgram;
7843}
7844extern "C" {
7845 pub fn MOJOSHADER_glBindProgram(program: *mut MOJOSHADER_glProgram);
7846}
7847extern "C" {
7848 pub fn MOJOSHADER_glBindShaders(
7849 vshader: *mut MOJOSHADER_glShader,
7850 pshader: *mut MOJOSHADER_glShader,
7851 );
7852}
7853extern "C" {
7854 pub fn MOJOSHADER_glGetBoundShaders(
7855 vshader: *mut *mut MOJOSHADER_glShader,
7856 pshader: *mut *mut MOJOSHADER_glShader,
7857 );
7858}
7859extern "C" {
7860 pub fn MOJOSHADER_glSetVertexShaderUniformF(
7861 idx: ::std::os::raw::c_uint,
7862 data: *const f32,
7863 vec4count: ::std::os::raw::c_uint,
7864 );
7865}
7866extern "C" {
7867 pub fn MOJOSHADER_glGetVertexShaderUniformF(
7868 idx: ::std::os::raw::c_uint,
7869 data: *mut f32,
7870 vec4count: ::std::os::raw::c_uint,
7871 );
7872}
7873extern "C" {
7874 pub fn MOJOSHADER_glSetVertexShaderUniformI(
7875 idx: ::std::os::raw::c_uint,
7876 data: *const ::std::os::raw::c_int,
7877 ivec4count: ::std::os::raw::c_uint,
7878 );
7879}
7880extern "C" {
7881 pub fn MOJOSHADER_glGetVertexShaderUniformI(
7882 idx: ::std::os::raw::c_uint,
7883 data: *mut ::std::os::raw::c_int,
7884 ivec4count: ::std::os::raw::c_uint,
7885 );
7886}
7887extern "C" {
7888 pub fn MOJOSHADER_glSetVertexShaderUniformB(
7889 idx: ::std::os::raw::c_uint,
7890 data: *const ::std::os::raw::c_int,
7891 bcount: ::std::os::raw::c_uint,
7892 );
7893}
7894extern "C" {
7895 pub fn MOJOSHADER_glGetVertexShaderUniformB(
7896 idx: ::std::os::raw::c_uint,
7897 data: *mut ::std::os::raw::c_int,
7898 bcount: ::std::os::raw::c_uint,
7899 );
7900}
7901extern "C" {
7902 pub fn MOJOSHADER_glSetPixelShaderUniformF(
7903 idx: ::std::os::raw::c_uint,
7904 data: *const f32,
7905 vec4count: ::std::os::raw::c_uint,
7906 );
7907}
7908extern "C" {
7909 pub fn MOJOSHADER_glGetPixelShaderUniformF(
7910 idx: ::std::os::raw::c_uint,
7911 data: *mut f32,
7912 vec4count: ::std::os::raw::c_uint,
7913 );
7914}
7915extern "C" {
7916 pub fn MOJOSHADER_glSetPixelShaderUniformI(
7917 idx: ::std::os::raw::c_uint,
7918 data: *const ::std::os::raw::c_int,
7919 ivec4count: ::std::os::raw::c_uint,
7920 );
7921}
7922extern "C" {
7923 pub fn MOJOSHADER_glGetPixelShaderUniformI(
7924 idx: ::std::os::raw::c_uint,
7925 data: *mut ::std::os::raw::c_int,
7926 ivec4count: ::std::os::raw::c_uint,
7927 );
7928}
7929extern "C" {
7930 pub fn MOJOSHADER_glSetPixelShaderUniformB(
7931 idx: ::std::os::raw::c_uint,
7932 data: *const ::std::os::raw::c_int,
7933 bcount: ::std::os::raw::c_uint,
7934 );
7935}
7936extern "C" {
7937 pub fn MOJOSHADER_glGetPixelShaderUniformB(
7938 idx: ::std::os::raw::c_uint,
7939 data: *mut ::std::os::raw::c_int,
7940 bcount: ::std::os::raw::c_uint,
7941 );
7942}
7943extern "C" {
7944 pub fn MOJOSHADER_glMapUniformBufferMemory(
7945 vsf: *mut *mut f32,
7946 vsi: *mut *mut ::std::os::raw::c_int,
7947 vsb: *mut *mut ::std::os::raw::c_uchar,
7948 psf: *mut *mut f32,
7949 psi: *mut *mut ::std::os::raw::c_int,
7950 psb: *mut *mut ::std::os::raw::c_uchar,
7951 );
7952}
7953extern "C" {
7954 pub fn MOJOSHADER_glUnmapUniformBufferMemory();
7955}
7956extern "C" {
7957 pub fn MOJOSHADER_glSetLegacyBumpMapEnv(
7958 sampler: ::std::os::raw::c_uint,
7959 mat00: f32,
7960 mat01: f32,
7961 mat10: f32,
7962 mat11: f32,
7963 lscale: f32,
7964 loffset: f32,
7965 );
7966}
7967extern "C" {
7968 pub fn MOJOSHADER_glGetVertexAttribLocation(
7969 usage: MOJOSHADER_usage,
7970 index: ::std::os::raw::c_int,
7971 ) -> ::std::os::raw::c_int;
7972}
7973extern "C" {
7974 pub fn MOJOSHADER_glSetVertexAttribute(
7975 usage: MOJOSHADER_usage,
7976 index: ::std::os::raw::c_int,
7977 size: ::std::os::raw::c_uint,
7978 type_: MOJOSHADER_attributeType,
7979 normalized: ::std::os::raw::c_int,
7980 stride: ::std::os::raw::c_uint,
7981 ptr: *const ::std::os::raw::c_void,
7982 );
7983}
7984extern "C" {
7985 pub fn MOJOSHADER_glSetVertexAttribDivisor(
7986 usage: MOJOSHADER_usage,
7987 index: ::std::os::raw::c_int,
7988 divisor: ::std::os::raw::c_uint,
7989 );
7990}
7991extern "C" {
7992 pub fn MOJOSHADER_glProgramReady();
7993}
7994extern "C" {
7995 pub fn MOJOSHADER_glProgramViewportInfo(
7996 viewportW: ::std::os::raw::c_int,
7997 viewportH: ::std::os::raw::c_int,
7998 backbufferW: ::std::os::raw::c_int,
7999 backbufferH: ::std::os::raw::c_int,
8000 renderTargetBound: ::std::os::raw::c_int,
8001 );
8002}
8003extern "C" {
8004 pub fn MOJOSHADER_glDeleteProgram(program: *mut MOJOSHADER_glProgram);
8005}
8006extern "C" {
8007 pub fn MOJOSHADER_glDeleteShader(shader: *mut MOJOSHADER_glShader);
8008}
8009extern "C" {
8010 pub fn MOJOSHADER_glDestroyContext(ctx: *mut MOJOSHADER_glContext);
8011}
8012#[repr(C)]
8013#[derive(Debug, Copy, Clone)]
8014pub struct MOJOSHADER_mtlContext {
8015 _unused: [u8; 0],
8016}
8017#[repr(C)]
8018#[derive(Debug, Copy, Clone)]
8019pub struct MOJOSHADER_mtlShader {
8020 _unused: [u8; 0],
8021}
8022extern "C" {
8023 pub fn MOJOSHADER_mtlCreateContext(
8024 mtlDevice: *mut ::std::os::raw::c_void,
8025 m: MOJOSHADER_malloc,
8026 f: MOJOSHADER_free,
8027 malloc_d: *mut ::std::os::raw::c_void,
8028 ) -> *mut MOJOSHADER_mtlContext;
8029}
8030extern "C" {
8031 pub fn MOJOSHADER_mtlMakeContextCurrent(ctx: *mut MOJOSHADER_mtlContext);
8032}
8033extern "C" {
8034 pub fn MOJOSHADER_mtlCompileShader(
8035 mainfn: *const ::std::os::raw::c_char,
8036 tokenbuf: *const ::std::os::raw::c_uchar,
8037 bufsize: ::std::os::raw::c_uint,
8038 swiz: *const MOJOSHADER_swizzle,
8039 swizcount: ::std::os::raw::c_uint,
8040 smap: *const MOJOSHADER_samplerMap,
8041 smapcount: ::std::os::raw::c_uint,
8042 ) -> *mut MOJOSHADER_mtlShader;
8043}
8044extern "C" {
8045 pub fn MOJOSHADER_mtlShaderAddRef(shader: *mut MOJOSHADER_mtlShader);
8046}
8047extern "C" {
8048 pub fn MOJOSHADER_mtlGetShaderParseData(
8049 shader: *mut MOJOSHADER_mtlShader,
8050 ) -> *const MOJOSHADER_parseData;
8051}
8052extern "C" {
8053 pub fn MOJOSHADER_mtlBindShaders(
8054 vshader: *mut MOJOSHADER_mtlShader,
8055 pshader: *mut MOJOSHADER_mtlShader,
8056 );
8057}
8058extern "C" {
8059 pub fn MOJOSHADER_mtlGetBoundShaders(
8060 vshader: *mut *mut MOJOSHADER_mtlShader,
8061 pshader: *mut *mut MOJOSHADER_mtlShader,
8062 );
8063}
8064extern "C" {
8065 pub fn MOJOSHADER_mtlMapUniformBufferMemory(
8066 vsf: *mut *mut f32,
8067 vsi: *mut *mut ::std::os::raw::c_int,
8068 vsb: *mut *mut ::std::os::raw::c_uchar,
8069 psf: *mut *mut f32,
8070 psi: *mut *mut ::std::os::raw::c_int,
8071 psb: *mut *mut ::std::os::raw::c_uchar,
8072 );
8073}
8074extern "C" {
8075 pub fn MOJOSHADER_mtlUnmapUniformBufferMemory();
8076}
8077extern "C" {
8078 pub fn MOJOSHADER_mtlGetUniformData(
8079 buf: *mut *mut ::std::os::raw::c_void,
8080 voff: *mut ::std::os::raw::c_int,
8081 poff: *mut ::std::os::raw::c_int,
8082 );
8083}
8084extern "C" {
8085 pub fn MOJOSHADER_mtlGetFunctionHandle(
8086 shader: *mut MOJOSHADER_mtlShader,
8087 ) -> *mut ::std::os::raw::c_void;
8088}
8089extern "C" {
8090 pub fn MOJOSHADER_mtlEndFrame();
8091}
8092extern "C" {
8093 pub fn MOJOSHADER_mtlGetVertexAttribLocation(
8094 vert: *mut MOJOSHADER_mtlShader,
8095 usage: MOJOSHADER_usage,
8096 index: ::std::os::raw::c_int,
8097 ) -> ::std::os::raw::c_int;
8098}
8099extern "C" {
8100 pub fn MOJOSHADER_mtlGetError() -> *const ::std::os::raw::c_char;
8101}
8102extern "C" {
8103 pub fn MOJOSHADER_mtlDeleteLibrary(library: *mut ::std::os::raw::c_void);
8104}
8105extern "C" {
8106 pub fn MOJOSHADER_mtlDeleteShader(shader: *mut MOJOSHADER_mtlShader);
8107}
8108extern "C" {
8109 pub fn MOJOSHADER_mtlDestroyContext(_ctx: *mut MOJOSHADER_mtlContext);
8110}
8111#[repr(C)]
8112#[derive(Debug, Copy, Clone)]
8113pub struct VkInstance_T {
8114 _unused: [u8; 0],
8115}
8116pub type VkInstance = *mut VkInstance_T;
8117#[repr(C)]
8118#[derive(Debug, Copy, Clone)]
8119pub struct VkDevice_T {
8120 _unused: [u8; 0],
8121}
8122pub type VkDevice = *mut VkDevice_T;
8123#[repr(C)]
8124#[derive(Debug, Copy, Clone)]
8125pub struct VkPhysicalDevice_T {
8126 _unused: [u8; 0],
8127}
8128pub type VkPhysicalDevice = *mut VkPhysicalDevice_T;
8129#[repr(C)]
8130#[derive(Debug, Copy, Clone)]
8131pub struct VkBuffer_T {
8132 _unused: [u8; 0],
8133}
8134pub type VkBuffer = *mut VkBuffer_T;
8135#[repr(C)]
8136#[derive(Debug, Copy, Clone)]
8137pub struct VkShaderModule_T {
8138 _unused: [u8; 0],
8139}
8140pub type VkShaderModule = *mut VkShaderModule_T;
8141pub type PFN_MOJOSHADER_vkVoidFunction = ::std::option::Option<unsafe extern "C" fn()>;
8142pub type PFN_MOJOSHADER_vkGetDeviceProcAddr = ::std::option::Option<
8143 unsafe extern "C" fn(
8144 device: VkDevice,
8145 pName: *const ::std::os::raw::c_char,
8146 ) -> PFN_MOJOSHADER_vkVoidFunction,
8147>;
8148pub type PFN_MOJOSHADER_vkGetInstanceProcAddr = ::std::option::Option<
8149 unsafe extern "C" fn(
8150 instance: VkInstance,
8151 pName: *const ::std::os::raw::c_char,
8152 ) -> PFN_MOJOSHADER_vkVoidFunction,
8153>;
8154#[repr(C)]
8155#[derive(Debug, Copy, Clone)]
8156pub struct MOJOSHADER_vkContext {
8157 _unused: [u8; 0],
8158}
8159#[repr(C)]
8160#[derive(Debug, Copy, Clone)]
8161pub struct MOJOSHADER_vkShader {
8162 _unused: [u8; 0],
8163}
8164#[repr(C)]
8165#[derive(Debug, Copy, Clone)]
8166pub struct MOJOSHADER_vkProgram {
8167 _unused: [u8; 0],
8168}
8169extern "C" {
8170 pub fn MOJOSHADER_vkCreateContext(
8171 instance: *mut VkInstance,
8172 physical_device: *mut VkPhysicalDevice,
8173 logical_device: *mut VkDevice,
8174 instance_lookup: PFN_MOJOSHADER_vkGetInstanceProcAddr,
8175 lookup: PFN_MOJOSHADER_vkGetDeviceProcAddr,
8176 graphics_queue_family_index: ::std::os::raw::c_uint,
8177 max_uniform_buffer_range: ::std::os::raw::c_uint,
8178 min_uniform_buffer_offset_alignment: ::std::os::raw::c_uint,
8179 m: MOJOSHADER_malloc,
8180 f: MOJOSHADER_free,
8181 malloc_d: *mut ::std::os::raw::c_void,
8182 ) -> *mut MOJOSHADER_vkContext;
8183}
8184extern "C" {
8185 pub fn MOJOSHADER_vkMakeContextCurrent(_ctx: *mut MOJOSHADER_vkContext);
8186}
8187extern "C" {
8188 pub fn MOJOSHADER_vkGetError() -> *const ::std::os::raw::c_char;
8189}
8190extern "C" {
8191 pub fn MOJOSHADER_vkDestroyContext(ctx: *mut MOJOSHADER_vkContext);
8192}
8193extern "C" {
8194 pub fn MOJOSHADER_vkCompileShader(
8195 mainfn: *const ::std::os::raw::c_char,
8196 tokenbuf: *const ::std::os::raw::c_uchar,
8197 bufsize: ::std::os::raw::c_uint,
8198 swiz: *const MOJOSHADER_swizzle,
8199 swizcount: ::std::os::raw::c_uint,
8200 smap: *const MOJOSHADER_samplerMap,
8201 smapcount: ::std::os::raw::c_uint,
8202 ) -> *mut MOJOSHADER_vkShader;
8203}
8204extern "C" {
8205 pub fn MOJOSHADER_vkShaderAddRef(shader: *mut MOJOSHADER_vkShader);
8206}
8207extern "C" {
8208 pub fn MOJOSHADER_vkDeleteShader(shader: *mut MOJOSHADER_vkShader);
8209}
8210extern "C" {
8211 pub fn MOJOSHADER_vkGetShaderParseData(
8212 shader: *mut MOJOSHADER_vkShader,
8213 ) -> *const MOJOSHADER_parseData;
8214}
8215extern "C" {
8216 pub fn MOJOSHADER_vkLinkProgram(
8217 vshader: *mut MOJOSHADER_vkShader,
8218 pshader: *mut MOJOSHADER_vkShader,
8219 ) -> *mut MOJOSHADER_vkProgram;
8220}
8221extern "C" {
8222 pub fn MOJOSHADER_vkBindProgram(program: *mut MOJOSHADER_vkProgram);
8223}
8224extern "C" {
8225 pub fn MOJOSHADER_vkDeleteProgram(program: *mut MOJOSHADER_vkProgram);
8226}
8227extern "C" {
8228 pub fn MOJOSHADER_vkBindShaders(
8229 vshader: *mut MOJOSHADER_vkShader,
8230 pshader: *mut MOJOSHADER_vkShader,
8231 );
8232}
8233extern "C" {
8234 pub fn MOJOSHADER_vkGetBoundShaders(
8235 vshader: *mut *mut MOJOSHADER_vkShader,
8236 pshader: *mut *mut MOJOSHADER_vkShader,
8237 );
8238}
8239extern "C" {
8240 pub fn MOJOSHADER_vkMapUniformBufferMemory(
8241 vsf: *mut *mut f32,
8242 vsi: *mut *mut ::std::os::raw::c_int,
8243 vsb: *mut *mut ::std::os::raw::c_uchar,
8244 psf: *mut *mut f32,
8245 psi: *mut *mut ::std::os::raw::c_int,
8246 psb: *mut *mut ::std::os::raw::c_uchar,
8247 );
8248}
8249extern "C" {
8250 pub fn MOJOSHADER_vkUnmapUniformBufferMemory();
8251}
8252extern "C" {
8253 pub fn MOJOSHADER_vkGetUniformBuffers(
8254 vbuf: *mut VkBuffer,
8255 voff: *mut ::std::os::raw::c_ulonglong,
8256 vsize: *mut ::std::os::raw::c_ulonglong,
8257 pbuf: *mut VkBuffer,
8258 poff: *mut ::std::os::raw::c_ulonglong,
8259 psize: *mut ::std::os::raw::c_ulonglong,
8260 );
8261}
8262extern "C" {
8263 pub fn MOJOSHADER_vkEndFrame();
8264}
8265extern "C" {
8266 pub fn MOJOSHADER_vkGetVertexAttribLocation(
8267 vert: *mut MOJOSHADER_vkShader,
8268 usage: MOJOSHADER_usage,
8269 index: ::std::os::raw::c_int,
8270 ) -> ::std::os::raw::c_int;
8271}
8272extern "C" {
8273 pub fn MOJOSHADER_vkGetShaderModules(
8274 vmodule: *mut VkShaderModule,
8275 pmodule: *mut VkShaderModule,
8276 );
8277}
8278#[repr(C)]
8279#[derive(Debug, Copy, Clone)]
8280pub struct MOJOSHADER_d3d11Shader {
8281 _unused: [u8; 0],
8282}
8283extern "C" {
8284 pub fn MOJOSHADER_d3d11CreateContext(
8285 device: *mut ::std::os::raw::c_void,
8286 deviceContext: *mut ::std::os::raw::c_void,
8287 m: MOJOSHADER_malloc,
8288 f: MOJOSHADER_free,
8289 malloc_d: *mut ::std::os::raw::c_void,
8290 ) -> ::std::os::raw::c_int;
8291}
8292extern "C" {
8293 pub fn MOJOSHADER_d3d11GetError() -> *const ::std::os::raw::c_char;
8294}
8295extern "C" {
8296 pub fn MOJOSHADER_d3d11CompileShader(
8297 mainfn: *const ::std::os::raw::c_char,
8298 tokenbuf: *const ::std::os::raw::c_uchar,
8299 bufsize: ::std::os::raw::c_uint,
8300 swiz: *const MOJOSHADER_swizzle,
8301 swizcount: ::std::os::raw::c_uint,
8302 smap: *const MOJOSHADER_samplerMap,
8303 smapcount: ::std::os::raw::c_uint,
8304 ) -> *mut MOJOSHADER_d3d11Shader;
8305}
8306extern "C" {
8307 pub fn MOJOSHADER_d3d11ShaderAddRef(shader: *mut MOJOSHADER_d3d11Shader);
8308}
8309extern "C" {
8310 pub fn MOJOSHADER_d3d11GetShaderParseData(
8311 shader: *mut MOJOSHADER_d3d11Shader,
8312 ) -> *const MOJOSHADER_parseData;
8313}
8314extern "C" {
8315 pub fn MOJOSHADER_d3d11BindShaders(
8316 vshader: *mut MOJOSHADER_d3d11Shader,
8317 pshader: *mut MOJOSHADER_d3d11Shader,
8318 );
8319}
8320extern "C" {
8321 pub fn MOJOSHADER_d3d11GetBoundShaders(
8322 vshader: *mut *mut MOJOSHADER_d3d11Shader,
8323 pshader: *mut *mut MOJOSHADER_d3d11Shader,
8324 );
8325}
8326extern "C" {
8327 pub fn MOJOSHADER_d3d11MapUniformBufferMemory(
8328 vsf: *mut *mut f32,
8329 vsi: *mut *mut ::std::os::raw::c_int,
8330 vsb: *mut *mut ::std::os::raw::c_uchar,
8331 psf: *mut *mut f32,
8332 psi: *mut *mut ::std::os::raw::c_int,
8333 psb: *mut *mut ::std::os::raw::c_uchar,
8334 );
8335}
8336extern "C" {
8337 pub fn MOJOSHADER_d3d11UnmapUniformBufferMemory();
8338}
8339extern "C" {
8340 pub fn MOJOSHADER_d3d11GetVertexAttribLocation(
8341 vert: *mut MOJOSHADER_d3d11Shader,
8342 usage: MOJOSHADER_usage,
8343 index: ::std::os::raw::c_int,
8344 ) -> ::std::os::raw::c_int;
8345}
8346extern "C" {
8347 pub fn MOJOSHADER_d3d11CompileVertexShader(
8348 inputLayoutHash: ::std::os::raw::c_ulonglong,
8349 elements: *mut ::std::os::raw::c_void,
8350 elementCount: ::std::os::raw::c_int,
8351 bytecode: *mut *mut ::std::os::raw::c_void,
8352 bytecodeLength: *mut ::std::os::raw::c_int,
8353 );
8354}
8355extern "C" {
8356 pub fn MOJOSHADER_d3d11ProgramReady(inputLayoutHash: ::std::os::raw::c_ulonglong);
8357}
8358extern "C" {
8359 pub fn MOJOSHADER_d3d11DeleteShader(shader: *mut MOJOSHADER_d3d11Shader);
8360}
8361extern "C" {
8362 pub fn MOJOSHADER_d3d11DestroyContext();
8363}
8364pub const MOJOSHADER_renderStateType_MOJOSHADER_RS_ZENABLE: MOJOSHADER_renderStateType = 0;
8365pub const MOJOSHADER_renderStateType_MOJOSHADER_RS_FILLMODE: MOJOSHADER_renderStateType = 1;
8366pub const MOJOSHADER_renderStateType_MOJOSHADER_RS_SHADEMODE: MOJOSHADER_renderStateType = 2;
8367pub const MOJOSHADER_renderStateType_MOJOSHADER_RS_ZWRITEENABLE: MOJOSHADER_renderStateType = 3;
8368pub const MOJOSHADER_renderStateType_MOJOSHADER_RS_ALPHATESTENABLE: MOJOSHADER_renderStateType = 4;
8369pub const MOJOSHADER_renderStateType_MOJOSHADER_RS_LASTPIXEL: MOJOSHADER_renderStateType = 5;
8370pub const MOJOSHADER_renderStateType_MOJOSHADER_RS_SRCBLEND: MOJOSHADER_renderStateType = 6;
8371pub const MOJOSHADER_renderStateType_MOJOSHADER_RS_DESTBLEND: MOJOSHADER_renderStateType = 7;
8372pub const MOJOSHADER_renderStateType_MOJOSHADER_RS_CULLMODE: MOJOSHADER_renderStateType = 8;
8373pub const MOJOSHADER_renderStateType_MOJOSHADER_RS_ZFUNC: MOJOSHADER_renderStateType = 9;
8374pub const MOJOSHADER_renderStateType_MOJOSHADER_RS_ALPHAREF: MOJOSHADER_renderStateType = 10;
8375pub const MOJOSHADER_renderStateType_MOJOSHADER_RS_ALPHAFUNC: MOJOSHADER_renderStateType = 11;
8376pub const MOJOSHADER_renderStateType_MOJOSHADER_RS_DITHERENABLE: MOJOSHADER_renderStateType = 12;
8377pub const MOJOSHADER_renderStateType_MOJOSHADER_RS_ALPHABLENDENABLE: MOJOSHADER_renderStateType =
8378 13;
8379pub const MOJOSHADER_renderStateType_MOJOSHADER_RS_FOGENABLE: MOJOSHADER_renderStateType = 14;
8380pub const MOJOSHADER_renderStateType_MOJOSHADER_RS_SPECULARENABLE: MOJOSHADER_renderStateType = 15;
8381pub const MOJOSHADER_renderStateType_MOJOSHADER_RS_FOGCOLOR: MOJOSHADER_renderStateType = 16;
8382pub const MOJOSHADER_renderStateType_MOJOSHADER_RS_FOGTABLEMODE: MOJOSHADER_renderStateType = 17;
8383pub const MOJOSHADER_renderStateType_MOJOSHADER_RS_FOGSTART: MOJOSHADER_renderStateType = 18;
8384pub const MOJOSHADER_renderStateType_MOJOSHADER_RS_FOGEND: MOJOSHADER_renderStateType = 19;
8385pub const MOJOSHADER_renderStateType_MOJOSHADER_RS_FOGDENSITY: MOJOSHADER_renderStateType = 20;
8386pub const MOJOSHADER_renderStateType_MOJOSHADER_RS_RANGEFOGENABLE: MOJOSHADER_renderStateType = 21;
8387pub const MOJOSHADER_renderStateType_MOJOSHADER_RS_STENCILENABLE: MOJOSHADER_renderStateType = 22;
8388pub const MOJOSHADER_renderStateType_MOJOSHADER_RS_STENCILFAIL: MOJOSHADER_renderStateType = 23;
8389pub const MOJOSHADER_renderStateType_MOJOSHADER_RS_STENCILZFAIL: MOJOSHADER_renderStateType = 24;
8390pub const MOJOSHADER_renderStateType_MOJOSHADER_RS_STENCILPASS: MOJOSHADER_renderStateType = 25;
8391pub const MOJOSHADER_renderStateType_MOJOSHADER_RS_STENCILFUNC: MOJOSHADER_renderStateType = 26;
8392pub const MOJOSHADER_renderStateType_MOJOSHADER_RS_STENCILREF: MOJOSHADER_renderStateType = 27;
8393pub const MOJOSHADER_renderStateType_MOJOSHADER_RS_STENCILMASK: MOJOSHADER_renderStateType = 28;
8394pub const MOJOSHADER_renderStateType_MOJOSHADER_RS_STENCILWRITEMASK: MOJOSHADER_renderStateType =
8395 29;
8396pub const MOJOSHADER_renderStateType_MOJOSHADER_RS_TEXTUREFACTOR: MOJOSHADER_renderStateType = 30;
8397pub const MOJOSHADER_renderStateType_MOJOSHADER_RS_WRAP0: MOJOSHADER_renderStateType = 31;
8398pub const MOJOSHADER_renderStateType_MOJOSHADER_RS_WRAP1: MOJOSHADER_renderStateType = 32;
8399pub const MOJOSHADER_renderStateType_MOJOSHADER_RS_WRAP2: MOJOSHADER_renderStateType = 33;
8400pub const MOJOSHADER_renderStateType_MOJOSHADER_RS_WRAP3: MOJOSHADER_renderStateType = 34;
8401pub const MOJOSHADER_renderStateType_MOJOSHADER_RS_WRAP4: MOJOSHADER_renderStateType = 35;
8402pub const MOJOSHADER_renderStateType_MOJOSHADER_RS_WRAP5: MOJOSHADER_renderStateType = 36;
8403pub const MOJOSHADER_renderStateType_MOJOSHADER_RS_WRAP6: MOJOSHADER_renderStateType = 37;
8404pub const MOJOSHADER_renderStateType_MOJOSHADER_RS_WRAP7: MOJOSHADER_renderStateType = 38;
8405pub const MOJOSHADER_renderStateType_MOJOSHADER_RS_WRAP8: MOJOSHADER_renderStateType = 39;
8406pub const MOJOSHADER_renderStateType_MOJOSHADER_RS_WRAP9: MOJOSHADER_renderStateType = 40;
8407pub const MOJOSHADER_renderStateType_MOJOSHADER_RS_WRAP10: MOJOSHADER_renderStateType = 41;
8408pub const MOJOSHADER_renderStateType_MOJOSHADER_RS_WRAP11: MOJOSHADER_renderStateType = 42;
8409pub const MOJOSHADER_renderStateType_MOJOSHADER_RS_WRAP12: MOJOSHADER_renderStateType = 43;
8410pub const MOJOSHADER_renderStateType_MOJOSHADER_RS_WRAP13: MOJOSHADER_renderStateType = 44;
8411pub const MOJOSHADER_renderStateType_MOJOSHADER_RS_WRAP14: MOJOSHADER_renderStateType = 45;
8412pub const MOJOSHADER_renderStateType_MOJOSHADER_RS_WRAP15: MOJOSHADER_renderStateType = 46;
8413pub const MOJOSHADER_renderStateType_MOJOSHADER_RS_CLIPPING: MOJOSHADER_renderStateType = 47;
8414pub const MOJOSHADER_renderStateType_MOJOSHADER_RS_LIGHTING: MOJOSHADER_renderStateType = 48;
8415pub const MOJOSHADER_renderStateType_MOJOSHADER_RS_AMBIENT: MOJOSHADER_renderStateType = 49;
8416pub const MOJOSHADER_renderStateType_MOJOSHADER_RS_FOGVERTEXMODE: MOJOSHADER_renderStateType = 50;
8417pub const MOJOSHADER_renderStateType_MOJOSHADER_RS_COLORVERTEX: MOJOSHADER_renderStateType = 51;
8418pub const MOJOSHADER_renderStateType_MOJOSHADER_RS_LOCALVIEWER: MOJOSHADER_renderStateType = 52;
8419pub const MOJOSHADER_renderStateType_MOJOSHADER_RS_NORMALIZENORMALS: MOJOSHADER_renderStateType =
8420 53;
8421pub const MOJOSHADER_renderStateType_MOJOSHADER_RS_DIFFUSEMATERIALSOURCE:
8422 MOJOSHADER_renderStateType = 54;
8423pub const MOJOSHADER_renderStateType_MOJOSHADER_RS_SPECULARMATERIALSOURCE:
8424 MOJOSHADER_renderStateType = 55;
8425pub const MOJOSHADER_renderStateType_MOJOSHADER_RS_AMBIENTMATERIALSOURCE:
8426 MOJOSHADER_renderStateType = 56;
8427pub const MOJOSHADER_renderStateType_MOJOSHADER_RS_EMISSIVEMATERIALSOURCE:
8428 MOJOSHADER_renderStateType = 57;
8429pub const MOJOSHADER_renderStateType_MOJOSHADER_RS_VERTEXBLEND: MOJOSHADER_renderStateType = 58;
8430pub const MOJOSHADER_renderStateType_MOJOSHADER_RS_CLIPPLANEENABLE: MOJOSHADER_renderStateType = 59;
8431pub const MOJOSHADER_renderStateType_MOJOSHADER_RS_POINTSIZE: MOJOSHADER_renderStateType = 60;
8432pub const MOJOSHADER_renderStateType_MOJOSHADER_RS_POINTSIZE_MIN: MOJOSHADER_renderStateType = 61;
8433pub const MOJOSHADER_renderStateType_MOJOSHADER_RS_POINTSPRITEENABLE: MOJOSHADER_renderStateType =
8434 62;
8435pub const MOJOSHADER_renderStateType_MOJOSHADER_RS_POINTSCALEENABLE: MOJOSHADER_renderStateType =
8436 63;
8437pub const MOJOSHADER_renderStateType_MOJOSHADER_RS_POINTSCALE_A: MOJOSHADER_renderStateType = 64;
8438pub const MOJOSHADER_renderStateType_MOJOSHADER_RS_POINTSCALE_B: MOJOSHADER_renderStateType = 65;
8439pub const MOJOSHADER_renderStateType_MOJOSHADER_RS_POINTSCALE_C: MOJOSHADER_renderStateType = 66;
8440pub const MOJOSHADER_renderStateType_MOJOSHADER_RS_MULTISAMPLEANTIALIAS:
8441 MOJOSHADER_renderStateType = 67;
8442pub const MOJOSHADER_renderStateType_MOJOSHADER_RS_MULTISAMPLEMASK: MOJOSHADER_renderStateType = 68;
8443pub const MOJOSHADER_renderStateType_MOJOSHADER_RS_PATCHEDGESTYLE: MOJOSHADER_renderStateType = 69;
8444pub const MOJOSHADER_renderStateType_MOJOSHADER_RS_DEBUGMONITORTOKEN: MOJOSHADER_renderStateType =
8445 70;
8446pub const MOJOSHADER_renderStateType_MOJOSHADER_RS_POINTSIZE_MAX: MOJOSHADER_renderStateType = 71;
8447pub const MOJOSHADER_renderStateType_MOJOSHADER_RS_INDEXEDVERTEXBLENDENABLE:
8448 MOJOSHADER_renderStateType = 72;
8449pub const MOJOSHADER_renderStateType_MOJOSHADER_RS_COLORWRITEENABLE: MOJOSHADER_renderStateType =
8450 73;
8451pub const MOJOSHADER_renderStateType_MOJOSHADER_RS_TWEENFACTOR: MOJOSHADER_renderStateType = 74;
8452pub const MOJOSHADER_renderStateType_MOJOSHADER_RS_BLENDOP: MOJOSHADER_renderStateType = 75;
8453pub const MOJOSHADER_renderStateType_MOJOSHADER_RS_POSITIONDEGREE: MOJOSHADER_renderStateType = 76;
8454pub const MOJOSHADER_renderStateType_MOJOSHADER_RS_NORMALDEGREE: MOJOSHADER_renderStateType = 77;
8455pub const MOJOSHADER_renderStateType_MOJOSHADER_RS_SCISSORTESTENABLE: MOJOSHADER_renderStateType =
8456 78;
8457pub const MOJOSHADER_renderStateType_MOJOSHADER_RS_SLOPESCALEDEPTHBIAS: MOJOSHADER_renderStateType =
8458 79;
8459pub const MOJOSHADER_renderStateType_MOJOSHADER_RS_ANTIALIASEDLINEENABLE:
8460 MOJOSHADER_renderStateType = 80;
8461pub const MOJOSHADER_renderStateType_MOJOSHADER_RS_MINTESSELLATIONLEVEL:
8462 MOJOSHADER_renderStateType = 81;
8463pub const MOJOSHADER_renderStateType_MOJOSHADER_RS_MAXTESSELLATIONLEVEL:
8464 MOJOSHADER_renderStateType = 82;
8465pub const MOJOSHADER_renderStateType_MOJOSHADER_RS_ADAPTIVETESS_X: MOJOSHADER_renderStateType = 83;
8466pub const MOJOSHADER_renderStateType_MOJOSHADER_RS_ADAPTIVETESS_Y: MOJOSHADER_renderStateType = 84;
8467pub const MOJOSHADER_renderStateType_MOJOSHADER_RS_ADAPTIVETESS_Z: MOJOSHADER_renderStateType = 85;
8468pub const MOJOSHADER_renderStateType_MOJOSHADER_RS_ADAPTIVETESS_W: MOJOSHADER_renderStateType = 86;
8469pub const MOJOSHADER_renderStateType_MOJOSHADER_RS_ENABLEADAPTIVETESSELLATION:
8470 MOJOSHADER_renderStateType = 87;
8471pub const MOJOSHADER_renderStateType_MOJOSHADER_RS_TWOSIDEDSTENCILMODE: MOJOSHADER_renderStateType =
8472 88;
8473pub const MOJOSHADER_renderStateType_MOJOSHADER_RS_CCW_STENCILFAIL: MOJOSHADER_renderStateType = 89;
8474pub const MOJOSHADER_renderStateType_MOJOSHADER_RS_CCW_STENCILZFAIL: MOJOSHADER_renderStateType =
8475 90;
8476pub const MOJOSHADER_renderStateType_MOJOSHADER_RS_CCW_STENCILPASS: MOJOSHADER_renderStateType = 91;
8477pub const MOJOSHADER_renderStateType_MOJOSHADER_RS_CCW_STENCILFUNC: MOJOSHADER_renderStateType = 92;
8478pub const MOJOSHADER_renderStateType_MOJOSHADER_RS_COLORWRITEENABLE1: MOJOSHADER_renderStateType =
8479 93;
8480pub const MOJOSHADER_renderStateType_MOJOSHADER_RS_COLORWRITEENABLE2: MOJOSHADER_renderStateType =
8481 94;
8482pub const MOJOSHADER_renderStateType_MOJOSHADER_RS_COLORWRITEENABLE3: MOJOSHADER_renderStateType =
8483 95;
8484pub const MOJOSHADER_renderStateType_MOJOSHADER_RS_BLENDFACTOR: MOJOSHADER_renderStateType = 96;
8485pub const MOJOSHADER_renderStateType_MOJOSHADER_RS_SRGBWRITEENABLE: MOJOSHADER_renderStateType = 97;
8486pub const MOJOSHADER_renderStateType_MOJOSHADER_RS_DEPTHBIAS: MOJOSHADER_renderStateType = 98;
8487pub const MOJOSHADER_renderStateType_MOJOSHADER_RS_SEPARATEALPHABLENDENABLE:
8488 MOJOSHADER_renderStateType = 99;
8489pub const MOJOSHADER_renderStateType_MOJOSHADER_RS_SRCBLENDALPHA: MOJOSHADER_renderStateType = 100;
8490pub const MOJOSHADER_renderStateType_MOJOSHADER_RS_DESTBLENDALPHA: MOJOSHADER_renderStateType = 101;
8491pub const MOJOSHADER_renderStateType_MOJOSHADER_RS_BLENDOPALPHA: MOJOSHADER_renderStateType = 102;
8492pub const MOJOSHADER_renderStateType_MOJOSHADER_RS_VERTEXSHADER: MOJOSHADER_renderStateType = 146;
8493pub const MOJOSHADER_renderStateType_MOJOSHADER_RS_PIXELSHADER: MOJOSHADER_renderStateType = 147;
8494pub type MOJOSHADER_renderStateType = ::std::os::raw::c_uint;
8495pub const MOJOSHADER_zBufferType_MOJOSHADER_ZB_FALSE: MOJOSHADER_zBufferType = 0;
8496pub const MOJOSHADER_zBufferType_MOJOSHADER_ZB_TRUE: MOJOSHADER_zBufferType = 1;
8497pub const MOJOSHADER_zBufferType_MOJOSHADER_ZB_USEW: MOJOSHADER_zBufferType = 2;
8498pub type MOJOSHADER_zBufferType = ::std::os::raw::c_uint;
8499pub const MOJOSHADER_fillMode_MOJOSHADER_FILL_POINT: MOJOSHADER_fillMode = 1;
8500pub const MOJOSHADER_fillMode_MOJOSHADER_FILL_WIREFRAME: MOJOSHADER_fillMode = 2;
8501pub const MOJOSHADER_fillMode_MOJOSHADER_FILL_SOLID: MOJOSHADER_fillMode = 3;
8502pub type MOJOSHADER_fillMode = ::std::os::raw::c_uint;
8503pub const MOJOSHADER_shadeMode_MOJOSHADER_SHADE_FLAT: MOJOSHADER_shadeMode = 1;
8504pub const MOJOSHADER_shadeMode_MOJOSHADER_SHADE_GOURAUD: MOJOSHADER_shadeMode = 2;
8505pub const MOJOSHADER_shadeMode_MOJOSHADER_SHADE_PHONG: MOJOSHADER_shadeMode = 3;
8506pub type MOJOSHADER_shadeMode = ::std::os::raw::c_uint;
8507pub const MOJOSHADER_blendMode_MOJOSHADER_BLEND_ZERO: MOJOSHADER_blendMode = 1;
8508pub const MOJOSHADER_blendMode_MOJOSHADER_BLEND_ONE: MOJOSHADER_blendMode = 2;
8509pub const MOJOSHADER_blendMode_MOJOSHADER_BLEND_SRCCOLOR: MOJOSHADER_blendMode = 3;
8510pub const MOJOSHADER_blendMode_MOJOSHADER_BLEND_INVSRCCOLOR: MOJOSHADER_blendMode = 4;
8511pub const MOJOSHADER_blendMode_MOJOSHADER_BLEND_SRCALPHA: MOJOSHADER_blendMode = 5;
8512pub const MOJOSHADER_blendMode_MOJOSHADER_BLEND_INVSRCALPHA: MOJOSHADER_blendMode = 6;
8513pub const MOJOSHADER_blendMode_MOJOSHADER_BLEND_DESTALPHA: MOJOSHADER_blendMode = 7;
8514pub const MOJOSHADER_blendMode_MOJOSHADER_BLEND_INVDESTALPHA: MOJOSHADER_blendMode = 8;
8515pub const MOJOSHADER_blendMode_MOJOSHADER_BLEND_DESTCOLOR: MOJOSHADER_blendMode = 9;
8516pub const MOJOSHADER_blendMode_MOJOSHADER_BLEND_INVDESTCOLOR: MOJOSHADER_blendMode = 10;
8517pub const MOJOSHADER_blendMode_MOJOSHADER_BLEND_SRCALPHASAT: MOJOSHADER_blendMode = 11;
8518pub const MOJOSHADER_blendMode_MOJOSHADER_BLEND_BOTHSRCALPHA: MOJOSHADER_blendMode = 12;
8519pub const MOJOSHADER_blendMode_MOJOSHADER_BLEND_BOTHINVSRCALPHA: MOJOSHADER_blendMode = 13;
8520pub const MOJOSHADER_blendMode_MOJOSHADER_BLEND_BLENDFACTOR: MOJOSHADER_blendMode = 14;
8521pub const MOJOSHADER_blendMode_MOJOSHADER_BLEND_INVBLENDFACTOR: MOJOSHADER_blendMode = 15;
8522pub const MOJOSHADER_blendMode_MOJOSHADER_BLEND_SRCCOLOR2: MOJOSHADER_blendMode = 16;
8523pub const MOJOSHADER_blendMode_MOJOSHADER_BLEND_INVSRCCOLOR2: MOJOSHADER_blendMode = 17;
8524pub type MOJOSHADER_blendMode = ::std::os::raw::c_uint;
8525pub const MOJOSHADER_cullMode_MOJOSHADER_CULL_NONE: MOJOSHADER_cullMode = 1;
8526pub const MOJOSHADER_cullMode_MOJOSHADER_CULL_CW: MOJOSHADER_cullMode = 2;
8527pub const MOJOSHADER_cullMode_MOJOSHADER_CULL_CCW: MOJOSHADER_cullMode = 3;
8528pub type MOJOSHADER_cullMode = ::std::os::raw::c_uint;
8529pub const MOJOSHADER_compareFunc_MOJOSHADER_CMP_NEVER: MOJOSHADER_compareFunc = 1;
8530pub const MOJOSHADER_compareFunc_MOJOSHADER_CMP_LESS: MOJOSHADER_compareFunc = 2;
8531pub const MOJOSHADER_compareFunc_MOJOSHADER_CMP_EQUAL: MOJOSHADER_compareFunc = 3;
8532pub const MOJOSHADER_compareFunc_MOJOSHADER_CMP_LESSEQUAL: MOJOSHADER_compareFunc = 4;
8533pub const MOJOSHADER_compareFunc_MOJOSHADER_CMP_GREATER: MOJOSHADER_compareFunc = 5;
8534pub const MOJOSHADER_compareFunc_MOJOSHADER_CMP_NOTEQUAL: MOJOSHADER_compareFunc = 6;
8535pub const MOJOSHADER_compareFunc_MOJOSHADER_CMP_GREATEREQUAL: MOJOSHADER_compareFunc = 7;
8536pub const MOJOSHADER_compareFunc_MOJOSHADER_CMP_ALWAYS: MOJOSHADER_compareFunc = 8;
8537pub type MOJOSHADER_compareFunc = ::std::os::raw::c_uint;
8538pub const MOJOSHADER_fogMode_MOJOSHADER_FOG_NONE: MOJOSHADER_fogMode = 0;
8539pub const MOJOSHADER_fogMode_MOJOSHADER_FOG_EXP: MOJOSHADER_fogMode = 1;
8540pub const MOJOSHADER_fogMode_MOJOSHADER_FOG_EXP2: MOJOSHADER_fogMode = 2;
8541pub const MOJOSHADER_fogMode_MOJOSHADER_FOG_LINEAR: MOJOSHADER_fogMode = 3;
8542pub type MOJOSHADER_fogMode = ::std::os::raw::c_uint;
8543pub const MOJOSHADER_stencilOp_MOJOSHADER_STENCILOP_KEEP: MOJOSHADER_stencilOp = 1;
8544pub const MOJOSHADER_stencilOp_MOJOSHADER_STENCILOP_ZERO: MOJOSHADER_stencilOp = 2;
8545pub const MOJOSHADER_stencilOp_MOJOSHADER_STENCILOP_REPLACE: MOJOSHADER_stencilOp = 3;
8546pub const MOJOSHADER_stencilOp_MOJOSHADER_STENCILOP_INCRSAT: MOJOSHADER_stencilOp = 4;
8547pub const MOJOSHADER_stencilOp_MOJOSHADER_STENCILOP_DECRSAT: MOJOSHADER_stencilOp = 5;
8548pub const MOJOSHADER_stencilOp_MOJOSHADER_STENCILOP_INVERT: MOJOSHADER_stencilOp = 6;
8549pub const MOJOSHADER_stencilOp_MOJOSHADER_STENCILOP_INCR: MOJOSHADER_stencilOp = 7;
8550pub const MOJOSHADER_stencilOp_MOJOSHADER_STENCILOP_DECR: MOJOSHADER_stencilOp = 8;
8551pub type MOJOSHADER_stencilOp = ::std::os::raw::c_uint;
8552pub const MOJOSHADER_materialColorSource_MOJOSHADER_MCS_MATERIAL: MOJOSHADER_materialColorSource =
8553 0;
8554pub const MOJOSHADER_materialColorSource_MOJOSHADER_MCS_COLOR1: MOJOSHADER_materialColorSource = 1;
8555pub const MOJOSHADER_materialColorSource_MOJOSHADER_MCS_COLOR2: MOJOSHADER_materialColorSource = 2;
8556pub type MOJOSHADER_materialColorSource = ::std::os::raw::c_uint;
8557pub const MOJOSHADER_vertexBlendFlags_MOJOSHADER_VBF_DISABLE: MOJOSHADER_vertexBlendFlags = 0;
8558pub const MOJOSHADER_vertexBlendFlags_MOJOSHADER_VBF_1WEIGHTS: MOJOSHADER_vertexBlendFlags = 1;
8559pub const MOJOSHADER_vertexBlendFlags_MOJOSHADER_VBF_2WEIGHTS: MOJOSHADER_vertexBlendFlags = 2;
8560pub const MOJOSHADER_vertexBlendFlags_MOJOSHADER_VBF_3WEIGHTS: MOJOSHADER_vertexBlendFlags = 3;
8561pub const MOJOSHADER_vertexBlendFlags_MOJOSHADER_VBF_TWEENING: MOJOSHADER_vertexBlendFlags = 255;
8562pub const MOJOSHADER_vertexBlendFlags_MOJOSHADER_VBF_0WEIGHTS: MOJOSHADER_vertexBlendFlags = 256;
8563pub type MOJOSHADER_vertexBlendFlags = ::std::os::raw::c_uint;
8564pub const MOJOSHADER_patchedEdgeStyle_MOJOSHADER_PATCHEDGE_DISCRETE: MOJOSHADER_patchedEdgeStyle =
8565 0;
8566pub const MOJOSHADER_patchedEdgeStyle_MOJOSHADER_PATCHEDGE_CONTINUOUS: MOJOSHADER_patchedEdgeStyle =
8567 1;
8568pub type MOJOSHADER_patchedEdgeStyle = ::std::os::raw::c_uint;
8569pub const MOJOSHADER_debugMonitorTokens_MOJOSHADER_DMT_ENABLE: MOJOSHADER_debugMonitorTokens = 0;
8570pub const MOJOSHADER_debugMonitorTokens_MOJOSHADER_DMT_DISABLE: MOJOSHADER_debugMonitorTokens = 1;
8571pub type MOJOSHADER_debugMonitorTokens = ::std::os::raw::c_uint;
8572pub const MOJOSHADER_blendOp_MOJOSHADER_BLENDOP_ADD: MOJOSHADER_blendOp = 1;
8573pub const MOJOSHADER_blendOp_MOJOSHADER_BLENDOP_SUBTRACT: MOJOSHADER_blendOp = 2;
8574pub const MOJOSHADER_blendOp_MOJOSHADER_BLENDOP_REVSUBTRACT: MOJOSHADER_blendOp = 3;
8575pub const MOJOSHADER_blendOp_MOJOSHADER_BLENDOP_MIN: MOJOSHADER_blendOp = 4;
8576pub const MOJOSHADER_blendOp_MOJOSHADER_BLENDOP_MAX: MOJOSHADER_blendOp = 5;
8577pub type MOJOSHADER_blendOp = ::std::os::raw::c_uint;
8578pub const MOJOSHADER_degreeType_MOJOSHADER_DEGREE_LINEAR: MOJOSHADER_degreeType = 1;
8579pub const MOJOSHADER_degreeType_MOJOSHADER_DEGREE_QUADRATIC: MOJOSHADER_degreeType = 2;
8580pub const MOJOSHADER_degreeType_MOJOSHADER_DEGREE_CUBIC: MOJOSHADER_degreeType = 3;
8581pub const MOJOSHADER_degreeType_MOJOSHADER_DEGREE_QUINTIC: MOJOSHADER_degreeType = 5;
8582pub type MOJOSHADER_degreeType = ::std::os::raw::c_uint;
8583pub const MOJOSHADER_samplerStateType_MOJOSHADER_SAMP_UNKNOWN0: MOJOSHADER_samplerStateType = 0;
8584pub const MOJOSHADER_samplerStateType_MOJOSHADER_SAMP_UNKNOWN1: MOJOSHADER_samplerStateType = 1;
8585pub const MOJOSHADER_samplerStateType_MOJOSHADER_SAMP_UNKNOWN2: MOJOSHADER_samplerStateType = 2;
8586pub const MOJOSHADER_samplerStateType_MOJOSHADER_SAMP_UNKNOWN3: MOJOSHADER_samplerStateType = 3;
8587pub const MOJOSHADER_samplerStateType_MOJOSHADER_SAMP_TEXTURE: MOJOSHADER_samplerStateType = 4;
8588pub const MOJOSHADER_samplerStateType_MOJOSHADER_SAMP_ADDRESSU: MOJOSHADER_samplerStateType = 5;
8589pub const MOJOSHADER_samplerStateType_MOJOSHADER_SAMP_ADDRESSV: MOJOSHADER_samplerStateType = 6;
8590pub const MOJOSHADER_samplerStateType_MOJOSHADER_SAMP_ADDRESSW: MOJOSHADER_samplerStateType = 7;
8591pub const MOJOSHADER_samplerStateType_MOJOSHADER_SAMP_BORDERCOLOR: MOJOSHADER_samplerStateType = 8;
8592pub const MOJOSHADER_samplerStateType_MOJOSHADER_SAMP_MAGFILTER: MOJOSHADER_samplerStateType = 9;
8593pub const MOJOSHADER_samplerStateType_MOJOSHADER_SAMP_MINFILTER: MOJOSHADER_samplerStateType = 10;
8594pub const MOJOSHADER_samplerStateType_MOJOSHADER_SAMP_MIPFILTER: MOJOSHADER_samplerStateType = 11;
8595pub const MOJOSHADER_samplerStateType_MOJOSHADER_SAMP_MIPMAPLODBIAS: MOJOSHADER_samplerStateType =
8596 12;
8597pub const MOJOSHADER_samplerStateType_MOJOSHADER_SAMP_MAXMIPLEVEL: MOJOSHADER_samplerStateType = 13;
8598pub const MOJOSHADER_samplerStateType_MOJOSHADER_SAMP_MAXANISOTROPY: MOJOSHADER_samplerStateType =
8599 14;
8600pub const MOJOSHADER_samplerStateType_MOJOSHADER_SAMP_SRGBTEXTURE: MOJOSHADER_samplerStateType = 15;
8601pub const MOJOSHADER_samplerStateType_MOJOSHADER_SAMP_ELEMENTINDEX: MOJOSHADER_samplerStateType =
8602 16;
8603pub const MOJOSHADER_samplerStateType_MOJOSHADER_SAMP_DMAPOFFSET: MOJOSHADER_samplerStateType = 17;
8604pub type MOJOSHADER_samplerStateType = ::std::os::raw::c_uint;
8605pub const MOJOSHADER_textureAddress_MOJOSHADER_TADDRESS_WRAP: MOJOSHADER_textureAddress = 1;
8606pub const MOJOSHADER_textureAddress_MOJOSHADER_TADDRESS_MIRROR: MOJOSHADER_textureAddress = 2;
8607pub const MOJOSHADER_textureAddress_MOJOSHADER_TADDRESS_CLAMP: MOJOSHADER_textureAddress = 3;
8608pub const MOJOSHADER_textureAddress_MOJOSHADER_TADDRESS_BORDER: MOJOSHADER_textureAddress = 4;
8609pub const MOJOSHADER_textureAddress_MOJOSHADER_TADDRESS_MIRRORONCE: MOJOSHADER_textureAddress = 5;
8610pub type MOJOSHADER_textureAddress = ::std::os::raw::c_uint;
8611pub const MOJOSHADER_textureFilterType_MOJOSHADER_TEXTUREFILTER_NONE: MOJOSHADER_textureFilterType =
8612 0;
8613pub const MOJOSHADER_textureFilterType_MOJOSHADER_TEXTUREFILTER_POINT:
8614 MOJOSHADER_textureFilterType = 1;
8615pub const MOJOSHADER_textureFilterType_MOJOSHADER_TEXTUREFILTER_LINEAR:
8616 MOJOSHADER_textureFilterType = 2;
8617pub const MOJOSHADER_textureFilterType_MOJOSHADER_TEXTUREFILTER_ANISOTROPIC:
8618 MOJOSHADER_textureFilterType = 3;
8619pub const MOJOSHADER_textureFilterType_MOJOSHADER_TEXTUREFILTER_PYRAMIDALQUAD:
8620 MOJOSHADER_textureFilterType = 4;
8621pub const MOJOSHADER_textureFilterType_MOJOSHADER_TEXTUREFILTER_GAUSSIANQUAD:
8622 MOJOSHADER_textureFilterType = 5;
8623pub const MOJOSHADER_textureFilterType_MOJOSHADER_TEXTUREFILTER_CONVOLUTIONMONO:
8624 MOJOSHADER_textureFilterType = 6;
8625pub type MOJOSHADER_textureFilterType = ::std::os::raw::c_uint;
8626#[repr(C)]
8627#[derive(Copy, Clone)]
8628pub struct MOJOSHADER_effectValue {
8629 pub name: *const ::std::os::raw::c_char,
8630 pub semantic: *const ::std::os::raw::c_char,
8631 pub type_: MOJOSHADER_symbolTypeInfo,
8632 pub value_count: ::std::os::raw::c_uint,
8633 pub __bindgen_anon_1: MOJOSHADER_effectValue__bindgen_ty_1,
8634}
8635#[repr(C)]
8636#[derive(Copy, Clone)]
8637pub union MOJOSHADER_effectValue__bindgen_ty_1 {
8638 pub values: *mut ::std::os::raw::c_void,
8639 pub valuesI: *mut ::std::os::raw::c_int,
8640 pub valuesF: *mut f32,
8641 pub valuesZBT: *mut MOJOSHADER_zBufferType,
8642 pub valuesFiM: *mut MOJOSHADER_fillMode,
8643 pub valuesSM: *mut MOJOSHADER_shadeMode,
8644 pub valuesBM: *mut MOJOSHADER_blendMode,
8645 pub valuesCM: *mut MOJOSHADER_cullMode,
8646 pub valuesCF: *mut MOJOSHADER_compareFunc,
8647 pub valuesFoM: *mut MOJOSHADER_fogMode,
8648 pub valuesSO: *mut MOJOSHADER_stencilOp,
8649 pub valuesMCS: *mut MOJOSHADER_materialColorSource,
8650 pub valuesVBF: *mut MOJOSHADER_vertexBlendFlags,
8651 pub valuesPES: *mut MOJOSHADER_patchedEdgeStyle,
8652 pub valuesDMT: *mut MOJOSHADER_debugMonitorTokens,
8653 pub valuesBO: *mut MOJOSHADER_blendOp,
8654 pub valuesDT: *mut MOJOSHADER_degreeType,
8655 pub valuesTA: *mut MOJOSHADER_textureAddress,
8656 pub valuesTFT: *mut MOJOSHADER_textureFilterType,
8657 pub valuesSS: *mut MOJOSHADER_effectSamplerState,
8658 _bindgen_union_align: u64,
8659}
8660#[test]
8661fn bindgen_test_layout_MOJOSHADER_effectValue__bindgen_ty_1() {
8662 assert_eq!(
8663 ::std::mem::size_of::<MOJOSHADER_effectValue__bindgen_ty_1>(),
8664 8usize,
8665 concat!(
8666 "Size of: ",
8667 stringify!(MOJOSHADER_effectValue__bindgen_ty_1)
8668 )
8669 );
8670 assert_eq!(
8671 ::std::mem::align_of::<MOJOSHADER_effectValue__bindgen_ty_1>(),
8672 8usize,
8673 concat!(
8674 "Alignment of ",
8675 stringify!(MOJOSHADER_effectValue__bindgen_ty_1)
8676 )
8677 );
8678 assert_eq!(
8679 unsafe {
8680 &(*(::std::ptr::null::<MOJOSHADER_effectValue__bindgen_ty_1>())).values as *const _
8681 as usize
8682 },
8683 0usize,
8684 concat!(
8685 "Offset of field: ",
8686 stringify!(MOJOSHADER_effectValue__bindgen_ty_1),
8687 "::",
8688 stringify!(values)
8689 )
8690 );
8691 assert_eq!(
8692 unsafe {
8693 &(*(::std::ptr::null::<MOJOSHADER_effectValue__bindgen_ty_1>())).valuesI as *const _
8694 as usize
8695 },
8696 0usize,
8697 concat!(
8698 "Offset of field: ",
8699 stringify!(MOJOSHADER_effectValue__bindgen_ty_1),
8700 "::",
8701 stringify!(valuesI)
8702 )
8703 );
8704 assert_eq!(
8705 unsafe {
8706 &(*(::std::ptr::null::<MOJOSHADER_effectValue__bindgen_ty_1>())).valuesF as *const _
8707 as usize
8708 },
8709 0usize,
8710 concat!(
8711 "Offset of field: ",
8712 stringify!(MOJOSHADER_effectValue__bindgen_ty_1),
8713 "::",
8714 stringify!(valuesF)
8715 )
8716 );
8717 assert_eq!(
8718 unsafe {
8719 &(*(::std::ptr::null::<MOJOSHADER_effectValue__bindgen_ty_1>())).valuesZBT as *const _
8720 as usize
8721 },
8722 0usize,
8723 concat!(
8724 "Offset of field: ",
8725 stringify!(MOJOSHADER_effectValue__bindgen_ty_1),
8726 "::",
8727 stringify!(valuesZBT)
8728 )
8729 );
8730 assert_eq!(
8731 unsafe {
8732 &(*(::std::ptr::null::<MOJOSHADER_effectValue__bindgen_ty_1>())).valuesFiM as *const _
8733 as usize
8734 },
8735 0usize,
8736 concat!(
8737 "Offset of field: ",
8738 stringify!(MOJOSHADER_effectValue__bindgen_ty_1),
8739 "::",
8740 stringify!(valuesFiM)
8741 )
8742 );
8743 assert_eq!(
8744 unsafe {
8745 &(*(::std::ptr::null::<MOJOSHADER_effectValue__bindgen_ty_1>())).valuesSM as *const _
8746 as usize
8747 },
8748 0usize,
8749 concat!(
8750 "Offset of field: ",
8751 stringify!(MOJOSHADER_effectValue__bindgen_ty_1),
8752 "::",
8753 stringify!(valuesSM)
8754 )
8755 );
8756 assert_eq!(
8757 unsafe {
8758 &(*(::std::ptr::null::<MOJOSHADER_effectValue__bindgen_ty_1>())).valuesBM as *const _
8759 as usize
8760 },
8761 0usize,
8762 concat!(
8763 "Offset of field: ",
8764 stringify!(MOJOSHADER_effectValue__bindgen_ty_1),
8765 "::",
8766 stringify!(valuesBM)
8767 )
8768 );
8769 assert_eq!(
8770 unsafe {
8771 &(*(::std::ptr::null::<MOJOSHADER_effectValue__bindgen_ty_1>())).valuesCM as *const _
8772 as usize
8773 },
8774 0usize,
8775 concat!(
8776 "Offset of field: ",
8777 stringify!(MOJOSHADER_effectValue__bindgen_ty_1),
8778 "::",
8779 stringify!(valuesCM)
8780 )
8781 );
8782 assert_eq!(
8783 unsafe {
8784 &(*(::std::ptr::null::<MOJOSHADER_effectValue__bindgen_ty_1>())).valuesCF as *const _
8785 as usize
8786 },
8787 0usize,
8788 concat!(
8789 "Offset of field: ",
8790 stringify!(MOJOSHADER_effectValue__bindgen_ty_1),
8791 "::",
8792 stringify!(valuesCF)
8793 )
8794 );
8795 assert_eq!(
8796 unsafe {
8797 &(*(::std::ptr::null::<MOJOSHADER_effectValue__bindgen_ty_1>())).valuesFoM as *const _
8798 as usize
8799 },
8800 0usize,
8801 concat!(
8802 "Offset of field: ",
8803 stringify!(MOJOSHADER_effectValue__bindgen_ty_1),
8804 "::",
8805 stringify!(valuesFoM)
8806 )
8807 );
8808 assert_eq!(
8809 unsafe {
8810 &(*(::std::ptr::null::<MOJOSHADER_effectValue__bindgen_ty_1>())).valuesSO as *const _
8811 as usize
8812 },
8813 0usize,
8814 concat!(
8815 "Offset of field: ",
8816 stringify!(MOJOSHADER_effectValue__bindgen_ty_1),
8817 "::",
8818 stringify!(valuesSO)
8819 )
8820 );
8821 assert_eq!(
8822 unsafe {
8823 &(*(::std::ptr::null::<MOJOSHADER_effectValue__bindgen_ty_1>())).valuesMCS as *const _
8824 as usize
8825 },
8826 0usize,
8827 concat!(
8828 "Offset of field: ",
8829 stringify!(MOJOSHADER_effectValue__bindgen_ty_1),
8830 "::",
8831 stringify!(valuesMCS)
8832 )
8833 );
8834 assert_eq!(
8835 unsafe {
8836 &(*(::std::ptr::null::<MOJOSHADER_effectValue__bindgen_ty_1>())).valuesVBF as *const _
8837 as usize
8838 },
8839 0usize,
8840 concat!(
8841 "Offset of field: ",
8842 stringify!(MOJOSHADER_effectValue__bindgen_ty_1),
8843 "::",
8844 stringify!(valuesVBF)
8845 )
8846 );
8847 assert_eq!(
8848 unsafe {
8849 &(*(::std::ptr::null::<MOJOSHADER_effectValue__bindgen_ty_1>())).valuesPES as *const _
8850 as usize
8851 },
8852 0usize,
8853 concat!(
8854 "Offset of field: ",
8855 stringify!(MOJOSHADER_effectValue__bindgen_ty_1),
8856 "::",
8857 stringify!(valuesPES)
8858 )
8859 );
8860 assert_eq!(
8861 unsafe {
8862 &(*(::std::ptr::null::<MOJOSHADER_effectValue__bindgen_ty_1>())).valuesDMT as *const _
8863 as usize
8864 },
8865 0usize,
8866 concat!(
8867 "Offset of field: ",
8868 stringify!(MOJOSHADER_effectValue__bindgen_ty_1),
8869 "::",
8870 stringify!(valuesDMT)
8871 )
8872 );
8873 assert_eq!(
8874 unsafe {
8875 &(*(::std::ptr::null::<MOJOSHADER_effectValue__bindgen_ty_1>())).valuesBO as *const _
8876 as usize
8877 },
8878 0usize,
8879 concat!(
8880 "Offset of field: ",
8881 stringify!(MOJOSHADER_effectValue__bindgen_ty_1),
8882 "::",
8883 stringify!(valuesBO)
8884 )
8885 );
8886 assert_eq!(
8887 unsafe {
8888 &(*(::std::ptr::null::<MOJOSHADER_effectValue__bindgen_ty_1>())).valuesDT as *const _
8889 as usize
8890 },
8891 0usize,
8892 concat!(
8893 "Offset of field: ",
8894 stringify!(MOJOSHADER_effectValue__bindgen_ty_1),
8895 "::",
8896 stringify!(valuesDT)
8897 )
8898 );
8899 assert_eq!(
8900 unsafe {
8901 &(*(::std::ptr::null::<MOJOSHADER_effectValue__bindgen_ty_1>())).valuesTA as *const _
8902 as usize
8903 },
8904 0usize,
8905 concat!(
8906 "Offset of field: ",
8907 stringify!(MOJOSHADER_effectValue__bindgen_ty_1),
8908 "::",
8909 stringify!(valuesTA)
8910 )
8911 );
8912 assert_eq!(
8913 unsafe {
8914 &(*(::std::ptr::null::<MOJOSHADER_effectValue__bindgen_ty_1>())).valuesTFT as *const _
8915 as usize
8916 },
8917 0usize,
8918 concat!(
8919 "Offset of field: ",
8920 stringify!(MOJOSHADER_effectValue__bindgen_ty_1),
8921 "::",
8922 stringify!(valuesTFT)
8923 )
8924 );
8925 assert_eq!(
8926 unsafe {
8927 &(*(::std::ptr::null::<MOJOSHADER_effectValue__bindgen_ty_1>())).valuesSS as *const _
8928 as usize
8929 },
8930 0usize,
8931 concat!(
8932 "Offset of field: ",
8933 stringify!(MOJOSHADER_effectValue__bindgen_ty_1),
8934 "::",
8935 stringify!(valuesSS)
8936 )
8937 );
8938}
8939#[test]
8940fn bindgen_test_layout_MOJOSHADER_effectValue() {
8941 assert_eq!(
8942 ::std::mem::size_of::<MOJOSHADER_effectValue>(),
8943 64usize,
8944 concat!("Size of: ", stringify!(MOJOSHADER_effectValue))
8945 );
8946 assert_eq!(
8947 ::std::mem::align_of::<MOJOSHADER_effectValue>(),
8948 8usize,
8949 concat!("Alignment of ", stringify!(MOJOSHADER_effectValue))
8950 );
8951 assert_eq!(
8952 unsafe { &(*(::std::ptr::null::<MOJOSHADER_effectValue>())).name as *const _ as usize },
8953 0usize,
8954 concat!(
8955 "Offset of field: ",
8956 stringify!(MOJOSHADER_effectValue),
8957 "::",
8958 stringify!(name)
8959 )
8960 );
8961 assert_eq!(
8962 unsafe { &(*(::std::ptr::null::<MOJOSHADER_effectValue>())).semantic as *const _ as usize },
8963 8usize,
8964 concat!(
8965 "Offset of field: ",
8966 stringify!(MOJOSHADER_effectValue),
8967 "::",
8968 stringify!(semantic)
8969 )
8970 );
8971 assert_eq!(
8972 unsafe { &(*(::std::ptr::null::<MOJOSHADER_effectValue>())).type_ as *const _ as usize },
8973 16usize,
8974 concat!(
8975 "Offset of field: ",
8976 stringify!(MOJOSHADER_effectValue),
8977 "::",
8978 stringify!(type_)
8979 )
8980 );
8981 assert_eq!(
8982 unsafe {
8983 &(*(::std::ptr::null::<MOJOSHADER_effectValue>())).value_count as *const _ as usize
8984 },
8985 48usize,
8986 concat!(
8987 "Offset of field: ",
8988 stringify!(MOJOSHADER_effectValue),
8989 "::",
8990 stringify!(value_count)
8991 )
8992 );
8993}
8994#[repr(C)]
8995#[derive(Copy, Clone)]
8996pub struct MOJOSHADER_effectState {
8997 pub type_: MOJOSHADER_renderStateType,
8998 pub value: MOJOSHADER_effectValue,
8999}
9000#[test]
9001fn bindgen_test_layout_MOJOSHADER_effectState() {
9002 assert_eq!(
9003 ::std::mem::size_of::<MOJOSHADER_effectState>(),
9004 72usize,
9005 concat!("Size of: ", stringify!(MOJOSHADER_effectState))
9006 );
9007 assert_eq!(
9008 ::std::mem::align_of::<MOJOSHADER_effectState>(),
9009 8usize,
9010 concat!("Alignment of ", stringify!(MOJOSHADER_effectState))
9011 );
9012 assert_eq!(
9013 unsafe { &(*(::std::ptr::null::<MOJOSHADER_effectState>())).type_ as *const _ as usize },
9014 0usize,
9015 concat!(
9016 "Offset of field: ",
9017 stringify!(MOJOSHADER_effectState),
9018 "::",
9019 stringify!(type_)
9020 )
9021 );
9022 assert_eq!(
9023 unsafe { &(*(::std::ptr::null::<MOJOSHADER_effectState>())).value as *const _ as usize },
9024 8usize,
9025 concat!(
9026 "Offset of field: ",
9027 stringify!(MOJOSHADER_effectState),
9028 "::",
9029 stringify!(value)
9030 )
9031 );
9032}
9033#[repr(C)]
9034#[derive(Copy, Clone)]
9035pub struct MOJOSHADER_effectSamplerState {
9036 pub type_: MOJOSHADER_samplerStateType,
9037 pub value: MOJOSHADER_effectValue,
9038}
9039#[test]
9040fn bindgen_test_layout_MOJOSHADER_effectSamplerState() {
9041 assert_eq!(
9042 ::std::mem::size_of::<MOJOSHADER_effectSamplerState>(),
9043 72usize,
9044 concat!("Size of: ", stringify!(MOJOSHADER_effectSamplerState))
9045 );
9046 assert_eq!(
9047 ::std::mem::align_of::<MOJOSHADER_effectSamplerState>(),
9048 8usize,
9049 concat!("Alignment of ", stringify!(MOJOSHADER_effectSamplerState))
9050 );
9051 assert_eq!(
9052 unsafe {
9053 &(*(::std::ptr::null::<MOJOSHADER_effectSamplerState>())).type_ as *const _ as usize
9054 },
9055 0usize,
9056 concat!(
9057 "Offset of field: ",
9058 stringify!(MOJOSHADER_effectSamplerState),
9059 "::",
9060 stringify!(type_)
9061 )
9062 );
9063 assert_eq!(
9064 unsafe {
9065 &(*(::std::ptr::null::<MOJOSHADER_effectSamplerState>())).value as *const _ as usize
9066 },
9067 8usize,
9068 concat!(
9069 "Offset of field: ",
9070 stringify!(MOJOSHADER_effectSamplerState),
9071 "::",
9072 stringify!(value)
9073 )
9074 );
9075}
9076pub type MOJOSHADER_effectAnnotation = MOJOSHADER_effectValue;
9077#[repr(C)]
9078#[derive(Copy, Clone)]
9079pub struct MOJOSHADER_effectParam {
9080 pub value: MOJOSHADER_effectValue,
9081 pub annotation_count: ::std::os::raw::c_uint,
9082 pub annotations: *mut MOJOSHADER_effectAnnotation,
9083}
9084#[test]
9085fn bindgen_test_layout_MOJOSHADER_effectParam() {
9086 assert_eq!(
9087 ::std::mem::size_of::<MOJOSHADER_effectParam>(),
9088 80usize,
9089 concat!("Size of: ", stringify!(MOJOSHADER_effectParam))
9090 );
9091 assert_eq!(
9092 ::std::mem::align_of::<MOJOSHADER_effectParam>(),
9093 8usize,
9094 concat!("Alignment of ", stringify!(MOJOSHADER_effectParam))
9095 );
9096 assert_eq!(
9097 unsafe { &(*(::std::ptr::null::<MOJOSHADER_effectParam>())).value as *const _ as usize },
9098 0usize,
9099 concat!(
9100 "Offset of field: ",
9101 stringify!(MOJOSHADER_effectParam),
9102 "::",
9103 stringify!(value)
9104 )
9105 );
9106 assert_eq!(
9107 unsafe {
9108 &(*(::std::ptr::null::<MOJOSHADER_effectParam>())).annotation_count as *const _ as usize
9109 },
9110 64usize,
9111 concat!(
9112 "Offset of field: ",
9113 stringify!(MOJOSHADER_effectParam),
9114 "::",
9115 stringify!(annotation_count)
9116 )
9117 );
9118 assert_eq!(
9119 unsafe {
9120 &(*(::std::ptr::null::<MOJOSHADER_effectParam>())).annotations as *const _ as usize
9121 },
9122 72usize,
9123 concat!(
9124 "Offset of field: ",
9125 stringify!(MOJOSHADER_effectParam),
9126 "::",
9127 stringify!(annotations)
9128 )
9129 );
9130}
9131#[repr(C)]
9132#[derive(Debug, Copy, Clone)]
9133pub struct MOJOSHADER_effectPass {
9134 pub name: *const ::std::os::raw::c_char,
9135 pub state_count: ::std::os::raw::c_uint,
9136 pub states: *mut MOJOSHADER_effectState,
9137 pub annotation_count: ::std::os::raw::c_uint,
9138 pub annotations: *mut MOJOSHADER_effectAnnotation,
9139}
9140#[test]
9141fn bindgen_test_layout_MOJOSHADER_effectPass() {
9142 assert_eq!(
9143 ::std::mem::size_of::<MOJOSHADER_effectPass>(),
9144 40usize,
9145 concat!("Size of: ", stringify!(MOJOSHADER_effectPass))
9146 );
9147 assert_eq!(
9148 ::std::mem::align_of::<MOJOSHADER_effectPass>(),
9149 8usize,
9150 concat!("Alignment of ", stringify!(MOJOSHADER_effectPass))
9151 );
9152 assert_eq!(
9153 unsafe { &(*(::std::ptr::null::<MOJOSHADER_effectPass>())).name as *const _ as usize },
9154 0usize,
9155 concat!(
9156 "Offset of field: ",
9157 stringify!(MOJOSHADER_effectPass),
9158 "::",
9159 stringify!(name)
9160 )
9161 );
9162 assert_eq!(
9163 unsafe {
9164 &(*(::std::ptr::null::<MOJOSHADER_effectPass>())).state_count as *const _ as usize
9165 },
9166 8usize,
9167 concat!(
9168 "Offset of field: ",
9169 stringify!(MOJOSHADER_effectPass),
9170 "::",
9171 stringify!(state_count)
9172 )
9173 );
9174 assert_eq!(
9175 unsafe { &(*(::std::ptr::null::<MOJOSHADER_effectPass>())).states as *const _ as usize },
9176 16usize,
9177 concat!(
9178 "Offset of field: ",
9179 stringify!(MOJOSHADER_effectPass),
9180 "::",
9181 stringify!(states)
9182 )
9183 );
9184 assert_eq!(
9185 unsafe {
9186 &(*(::std::ptr::null::<MOJOSHADER_effectPass>())).annotation_count as *const _ as usize
9187 },
9188 24usize,
9189 concat!(
9190 "Offset of field: ",
9191 stringify!(MOJOSHADER_effectPass),
9192 "::",
9193 stringify!(annotation_count)
9194 )
9195 );
9196 assert_eq!(
9197 unsafe {
9198 &(*(::std::ptr::null::<MOJOSHADER_effectPass>())).annotations as *const _ as usize
9199 },
9200 32usize,
9201 concat!(
9202 "Offset of field: ",
9203 stringify!(MOJOSHADER_effectPass),
9204 "::",
9205 stringify!(annotations)
9206 )
9207 );
9208}
9209#[repr(C)]
9210#[derive(Debug, Copy, Clone)]
9211pub struct MOJOSHADER_effectTechnique {
9212 pub name: *const ::std::os::raw::c_char,
9213 pub pass_count: ::std::os::raw::c_uint,
9214 pub passes: *mut MOJOSHADER_effectPass,
9215 pub annotation_count: ::std::os::raw::c_uint,
9216 pub annotations: *mut MOJOSHADER_effectAnnotation,
9217}
9218#[test]
9219fn bindgen_test_layout_MOJOSHADER_effectTechnique() {
9220 assert_eq!(
9221 ::std::mem::size_of::<MOJOSHADER_effectTechnique>(),
9222 40usize,
9223 concat!("Size of: ", stringify!(MOJOSHADER_effectTechnique))
9224 );
9225 assert_eq!(
9226 ::std::mem::align_of::<MOJOSHADER_effectTechnique>(),
9227 8usize,
9228 concat!("Alignment of ", stringify!(MOJOSHADER_effectTechnique))
9229 );
9230 assert_eq!(
9231 unsafe { &(*(::std::ptr::null::<MOJOSHADER_effectTechnique>())).name as *const _ as usize },
9232 0usize,
9233 concat!(
9234 "Offset of field: ",
9235 stringify!(MOJOSHADER_effectTechnique),
9236 "::",
9237 stringify!(name)
9238 )
9239 );
9240 assert_eq!(
9241 unsafe {
9242 &(*(::std::ptr::null::<MOJOSHADER_effectTechnique>())).pass_count as *const _ as usize
9243 },
9244 8usize,
9245 concat!(
9246 "Offset of field: ",
9247 stringify!(MOJOSHADER_effectTechnique),
9248 "::",
9249 stringify!(pass_count)
9250 )
9251 );
9252 assert_eq!(
9253 unsafe {
9254 &(*(::std::ptr::null::<MOJOSHADER_effectTechnique>())).passes as *const _ as usize
9255 },
9256 16usize,
9257 concat!(
9258 "Offset of field: ",
9259 stringify!(MOJOSHADER_effectTechnique),
9260 "::",
9261 stringify!(passes)
9262 )
9263 );
9264 assert_eq!(
9265 unsafe {
9266 &(*(::std::ptr::null::<MOJOSHADER_effectTechnique>())).annotation_count as *const _
9267 as usize
9268 },
9269 24usize,
9270 concat!(
9271 "Offset of field: ",
9272 stringify!(MOJOSHADER_effectTechnique),
9273 "::",
9274 stringify!(annotation_count)
9275 )
9276 );
9277 assert_eq!(
9278 unsafe {
9279 &(*(::std::ptr::null::<MOJOSHADER_effectTechnique>())).annotations as *const _ as usize
9280 },
9281 32usize,
9282 concat!(
9283 "Offset of field: ",
9284 stringify!(MOJOSHADER_effectTechnique),
9285 "::",
9286 stringify!(annotations)
9287 )
9288 );
9289}
9290#[repr(C)]
9291#[derive(Copy, Clone)]
9292pub struct MOJOSHADER_effectShader {
9293 pub type_: MOJOSHADER_symbolType,
9294 pub technique: ::std::os::raw::c_uint,
9295 pub pass: ::std::os::raw::c_uint,
9296 pub is_preshader: ::std::os::raw::c_uint,
9297 pub preshader_param_count: ::std::os::raw::c_uint,
9298 pub preshader_params: *mut ::std::os::raw::c_uint,
9299 pub param_count: ::std::os::raw::c_uint,
9300 pub params: *mut ::std::os::raw::c_uint,
9301 pub sampler_count: ::std::os::raw::c_uint,
9302 pub samplers: *mut MOJOSHADER_samplerStateRegister,
9303 pub __bindgen_anon_1: MOJOSHADER_effectShader__bindgen_ty_1,
9304}
9305#[repr(C)]
9306#[derive(Copy, Clone)]
9307pub union MOJOSHADER_effectShader__bindgen_ty_1 {
9308 pub shader: *mut ::std::os::raw::c_void,
9309 pub preshader: *const MOJOSHADER_preshader,
9310 _bindgen_union_align: u64,
9311}
9312#[test]
9313fn bindgen_test_layout_MOJOSHADER_effectShader__bindgen_ty_1() {
9314 assert_eq!(
9315 ::std::mem::size_of::<MOJOSHADER_effectShader__bindgen_ty_1>(),
9316 8usize,
9317 concat!(
9318 "Size of: ",
9319 stringify!(MOJOSHADER_effectShader__bindgen_ty_1)
9320 )
9321 );
9322 assert_eq!(
9323 ::std::mem::align_of::<MOJOSHADER_effectShader__bindgen_ty_1>(),
9324 8usize,
9325 concat!(
9326 "Alignment of ",
9327 stringify!(MOJOSHADER_effectShader__bindgen_ty_1)
9328 )
9329 );
9330 assert_eq!(
9331 unsafe {
9332 &(*(::std::ptr::null::<MOJOSHADER_effectShader__bindgen_ty_1>())).shader as *const _
9333 as usize
9334 },
9335 0usize,
9336 concat!(
9337 "Offset of field: ",
9338 stringify!(MOJOSHADER_effectShader__bindgen_ty_1),
9339 "::",
9340 stringify!(shader)
9341 )
9342 );
9343 assert_eq!(
9344 unsafe {
9345 &(*(::std::ptr::null::<MOJOSHADER_effectShader__bindgen_ty_1>())).preshader as *const _
9346 as usize
9347 },
9348 0usize,
9349 concat!(
9350 "Offset of field: ",
9351 stringify!(MOJOSHADER_effectShader__bindgen_ty_1),
9352 "::",
9353 stringify!(preshader)
9354 )
9355 );
9356}
9357#[test]
9358fn bindgen_test_layout_MOJOSHADER_effectShader() {
9359 assert_eq!(
9360 ::std::mem::size_of::<MOJOSHADER_effectShader>(),
9361 72usize,
9362 concat!("Size of: ", stringify!(MOJOSHADER_effectShader))
9363 );
9364 assert_eq!(
9365 ::std::mem::align_of::<MOJOSHADER_effectShader>(),
9366 8usize,
9367 concat!("Alignment of ", stringify!(MOJOSHADER_effectShader))
9368 );
9369 assert_eq!(
9370 unsafe { &(*(::std::ptr::null::<MOJOSHADER_effectShader>())).type_ as *const _ as usize },
9371 0usize,
9372 concat!(
9373 "Offset of field: ",
9374 stringify!(MOJOSHADER_effectShader),
9375 "::",
9376 stringify!(type_)
9377 )
9378 );
9379 assert_eq!(
9380 unsafe {
9381 &(*(::std::ptr::null::<MOJOSHADER_effectShader>())).technique as *const _ as usize
9382 },
9383 4usize,
9384 concat!(
9385 "Offset of field: ",
9386 stringify!(MOJOSHADER_effectShader),
9387 "::",
9388 stringify!(technique)
9389 )
9390 );
9391 assert_eq!(
9392 unsafe { &(*(::std::ptr::null::<MOJOSHADER_effectShader>())).pass as *const _ as usize },
9393 8usize,
9394 concat!(
9395 "Offset of field: ",
9396 stringify!(MOJOSHADER_effectShader),
9397 "::",
9398 stringify!(pass)
9399 )
9400 );
9401 assert_eq!(
9402 unsafe {
9403 &(*(::std::ptr::null::<MOJOSHADER_effectShader>())).is_preshader as *const _ as usize
9404 },
9405 12usize,
9406 concat!(
9407 "Offset of field: ",
9408 stringify!(MOJOSHADER_effectShader),
9409 "::",
9410 stringify!(is_preshader)
9411 )
9412 );
9413 assert_eq!(
9414 unsafe {
9415 &(*(::std::ptr::null::<MOJOSHADER_effectShader>())).preshader_param_count as *const _
9416 as usize
9417 },
9418 16usize,
9419 concat!(
9420 "Offset of field: ",
9421 stringify!(MOJOSHADER_effectShader),
9422 "::",
9423 stringify!(preshader_param_count)
9424 )
9425 );
9426 assert_eq!(
9427 unsafe {
9428 &(*(::std::ptr::null::<MOJOSHADER_effectShader>())).preshader_params as *const _
9429 as usize
9430 },
9431 24usize,
9432 concat!(
9433 "Offset of field: ",
9434 stringify!(MOJOSHADER_effectShader),
9435 "::",
9436 stringify!(preshader_params)
9437 )
9438 );
9439 assert_eq!(
9440 unsafe {
9441 &(*(::std::ptr::null::<MOJOSHADER_effectShader>())).param_count as *const _ as usize
9442 },
9443 32usize,
9444 concat!(
9445 "Offset of field: ",
9446 stringify!(MOJOSHADER_effectShader),
9447 "::",
9448 stringify!(param_count)
9449 )
9450 );
9451 assert_eq!(
9452 unsafe { &(*(::std::ptr::null::<MOJOSHADER_effectShader>())).params as *const _ as usize },
9453 40usize,
9454 concat!(
9455 "Offset of field: ",
9456 stringify!(MOJOSHADER_effectShader),
9457 "::",
9458 stringify!(params)
9459 )
9460 );
9461 assert_eq!(
9462 unsafe {
9463 &(*(::std::ptr::null::<MOJOSHADER_effectShader>())).sampler_count as *const _ as usize
9464 },
9465 48usize,
9466 concat!(
9467 "Offset of field: ",
9468 stringify!(MOJOSHADER_effectShader),
9469 "::",
9470 stringify!(sampler_count)
9471 )
9472 );
9473 assert_eq!(
9474 unsafe {
9475 &(*(::std::ptr::null::<MOJOSHADER_effectShader>())).samplers as *const _ as usize
9476 },
9477 56usize,
9478 concat!(
9479 "Offset of field: ",
9480 stringify!(MOJOSHADER_effectShader),
9481 "::",
9482 stringify!(samplers)
9483 )
9484 );
9485}
9486#[repr(C)]
9487#[derive(Debug, Copy, Clone)]
9488pub struct MOJOSHADER_effectSamplerMap {
9489 pub type_: MOJOSHADER_symbolType,
9490 pub name: *const ::std::os::raw::c_char,
9491}
9492#[test]
9493fn bindgen_test_layout_MOJOSHADER_effectSamplerMap() {
9494 assert_eq!(
9495 ::std::mem::size_of::<MOJOSHADER_effectSamplerMap>(),
9496 16usize,
9497 concat!("Size of: ", stringify!(MOJOSHADER_effectSamplerMap))
9498 );
9499 assert_eq!(
9500 ::std::mem::align_of::<MOJOSHADER_effectSamplerMap>(),
9501 8usize,
9502 concat!("Alignment of ", stringify!(MOJOSHADER_effectSamplerMap))
9503 );
9504 assert_eq!(
9505 unsafe {
9506 &(*(::std::ptr::null::<MOJOSHADER_effectSamplerMap>())).type_ as *const _ as usize
9507 },
9508 0usize,
9509 concat!(
9510 "Offset of field: ",
9511 stringify!(MOJOSHADER_effectSamplerMap),
9512 "::",
9513 stringify!(type_)
9514 )
9515 );
9516 assert_eq!(
9517 unsafe {
9518 &(*(::std::ptr::null::<MOJOSHADER_effectSamplerMap>())).name as *const _ as usize
9519 },
9520 8usize,
9521 concat!(
9522 "Offset of field: ",
9523 stringify!(MOJOSHADER_effectSamplerMap),
9524 "::",
9525 stringify!(name)
9526 )
9527 );
9528}
9529#[repr(C)]
9530#[derive(Debug, Copy, Clone)]
9531pub struct MOJOSHADER_effectString {
9532 pub type_: MOJOSHADER_symbolType,
9533 pub string: *const ::std::os::raw::c_char,
9534}
9535#[test]
9536fn bindgen_test_layout_MOJOSHADER_effectString() {
9537 assert_eq!(
9538 ::std::mem::size_of::<MOJOSHADER_effectString>(),
9539 16usize,
9540 concat!("Size of: ", stringify!(MOJOSHADER_effectString))
9541 );
9542 assert_eq!(
9543 ::std::mem::align_of::<MOJOSHADER_effectString>(),
9544 8usize,
9545 concat!("Alignment of ", stringify!(MOJOSHADER_effectString))
9546 );
9547 assert_eq!(
9548 unsafe { &(*(::std::ptr::null::<MOJOSHADER_effectString>())).type_ as *const _ as usize },
9549 0usize,
9550 concat!(
9551 "Offset of field: ",
9552 stringify!(MOJOSHADER_effectString),
9553 "::",
9554 stringify!(type_)
9555 )
9556 );
9557 assert_eq!(
9558 unsafe { &(*(::std::ptr::null::<MOJOSHADER_effectString>())).string as *const _ as usize },
9559 8usize,
9560 concat!(
9561 "Offset of field: ",
9562 stringify!(MOJOSHADER_effectString),
9563 "::",
9564 stringify!(string)
9565 )
9566 );
9567}
9568#[repr(C)]
9569#[derive(Debug, Copy, Clone)]
9570pub struct MOJOSHADER_effectTexture {
9571 pub type_: MOJOSHADER_symbolType,
9572}
9573#[test]
9574fn bindgen_test_layout_MOJOSHADER_effectTexture() {
9575 assert_eq!(
9576 ::std::mem::size_of::<MOJOSHADER_effectTexture>(),
9577 4usize,
9578 concat!("Size of: ", stringify!(MOJOSHADER_effectTexture))
9579 );
9580 assert_eq!(
9581 ::std::mem::align_of::<MOJOSHADER_effectTexture>(),
9582 4usize,
9583 concat!("Alignment of ", stringify!(MOJOSHADER_effectTexture))
9584 );
9585 assert_eq!(
9586 unsafe { &(*(::std::ptr::null::<MOJOSHADER_effectTexture>())).type_ as *const _ as usize },
9587 0usize,
9588 concat!(
9589 "Offset of field: ",
9590 stringify!(MOJOSHADER_effectTexture),
9591 "::",
9592 stringify!(type_)
9593 )
9594 );
9595}
9596#[repr(C)]
9597#[derive(Copy, Clone)]
9598pub union MOJOSHADER_effectObject {
9599 pub type_: MOJOSHADER_symbolType,
9600 pub __bindgen_anon_1: MOJOSHADER_effectObject__bindgen_ty_1,
9601 _bindgen_union_align: [u64; 9usize],
9602}
9603#[repr(C)]
9604#[derive(Copy, Clone)]
9605pub union MOJOSHADER_effectObject__bindgen_ty_1 {
9606 pub shader: MOJOSHADER_effectShader,
9607 pub mapping: MOJOSHADER_effectSamplerMap,
9608 pub string: MOJOSHADER_effectString,
9609 pub texture: MOJOSHADER_effectTexture,
9610 _bindgen_union_align: [u64; 9usize],
9611}
9612#[test]
9613fn bindgen_test_layout_MOJOSHADER_effectObject__bindgen_ty_1() {
9614 assert_eq!(
9615 ::std::mem::size_of::<MOJOSHADER_effectObject__bindgen_ty_1>(),
9616 72usize,
9617 concat!(
9618 "Size of: ",
9619 stringify!(MOJOSHADER_effectObject__bindgen_ty_1)
9620 )
9621 );
9622 assert_eq!(
9623 ::std::mem::align_of::<MOJOSHADER_effectObject__bindgen_ty_1>(),
9624 8usize,
9625 concat!(
9626 "Alignment of ",
9627 stringify!(MOJOSHADER_effectObject__bindgen_ty_1)
9628 )
9629 );
9630 assert_eq!(
9631 unsafe {
9632 &(*(::std::ptr::null::<MOJOSHADER_effectObject__bindgen_ty_1>())).shader as *const _
9633 as usize
9634 },
9635 0usize,
9636 concat!(
9637 "Offset of field: ",
9638 stringify!(MOJOSHADER_effectObject__bindgen_ty_1),
9639 "::",
9640 stringify!(shader)
9641 )
9642 );
9643 assert_eq!(
9644 unsafe {
9645 &(*(::std::ptr::null::<MOJOSHADER_effectObject__bindgen_ty_1>())).mapping as *const _
9646 as usize
9647 },
9648 0usize,
9649 concat!(
9650 "Offset of field: ",
9651 stringify!(MOJOSHADER_effectObject__bindgen_ty_1),
9652 "::",
9653 stringify!(mapping)
9654 )
9655 );
9656 assert_eq!(
9657 unsafe {
9658 &(*(::std::ptr::null::<MOJOSHADER_effectObject__bindgen_ty_1>())).string as *const _
9659 as usize
9660 },
9661 0usize,
9662 concat!(
9663 "Offset of field: ",
9664 stringify!(MOJOSHADER_effectObject__bindgen_ty_1),
9665 "::",
9666 stringify!(string)
9667 )
9668 );
9669 assert_eq!(
9670 unsafe {
9671 &(*(::std::ptr::null::<MOJOSHADER_effectObject__bindgen_ty_1>())).texture as *const _
9672 as usize
9673 },
9674 0usize,
9675 concat!(
9676 "Offset of field: ",
9677 stringify!(MOJOSHADER_effectObject__bindgen_ty_1),
9678 "::",
9679 stringify!(texture)
9680 )
9681 );
9682}
9683#[test]
9684fn bindgen_test_layout_MOJOSHADER_effectObject() {
9685 assert_eq!(
9686 ::std::mem::size_of::<MOJOSHADER_effectObject>(),
9687 72usize,
9688 concat!("Size of: ", stringify!(MOJOSHADER_effectObject))
9689 );
9690 assert_eq!(
9691 ::std::mem::align_of::<MOJOSHADER_effectObject>(),
9692 8usize,
9693 concat!("Alignment of ", stringify!(MOJOSHADER_effectObject))
9694 );
9695 assert_eq!(
9696 unsafe { &(*(::std::ptr::null::<MOJOSHADER_effectObject>())).type_ as *const _ as usize },
9697 0usize,
9698 concat!(
9699 "Offset of field: ",
9700 stringify!(MOJOSHADER_effectObject),
9701 "::",
9702 stringify!(type_)
9703 )
9704 );
9705}
9706#[repr(C)]
9707#[derive(Debug, Copy, Clone)]
9708pub struct MOJOSHADER_samplerStateRegister {
9709 pub sampler_name: *const ::std::os::raw::c_char,
9710 pub sampler_register: ::std::os::raw::c_uint,
9711 pub sampler_state_count: ::std::os::raw::c_uint,
9712 pub sampler_states: *const MOJOSHADER_effectSamplerState,
9713}
9714#[test]
9715fn bindgen_test_layout_MOJOSHADER_samplerStateRegister() {
9716 assert_eq!(
9717 ::std::mem::size_of::<MOJOSHADER_samplerStateRegister>(),
9718 24usize,
9719 concat!("Size of: ", stringify!(MOJOSHADER_samplerStateRegister))
9720 );
9721 assert_eq!(
9722 ::std::mem::align_of::<MOJOSHADER_samplerStateRegister>(),
9723 8usize,
9724 concat!("Alignment of ", stringify!(MOJOSHADER_samplerStateRegister))
9725 );
9726 assert_eq!(
9727 unsafe {
9728 &(*(::std::ptr::null::<MOJOSHADER_samplerStateRegister>())).sampler_name as *const _
9729 as usize
9730 },
9731 0usize,
9732 concat!(
9733 "Offset of field: ",
9734 stringify!(MOJOSHADER_samplerStateRegister),
9735 "::",
9736 stringify!(sampler_name)
9737 )
9738 );
9739 assert_eq!(
9740 unsafe {
9741 &(*(::std::ptr::null::<MOJOSHADER_samplerStateRegister>())).sampler_register as *const _
9742 as usize
9743 },
9744 8usize,
9745 concat!(
9746 "Offset of field: ",
9747 stringify!(MOJOSHADER_samplerStateRegister),
9748 "::",
9749 stringify!(sampler_register)
9750 )
9751 );
9752 assert_eq!(
9753 unsafe {
9754 &(*(::std::ptr::null::<MOJOSHADER_samplerStateRegister>())).sampler_state_count
9755 as *const _ as usize
9756 },
9757 12usize,
9758 concat!(
9759 "Offset of field: ",
9760 stringify!(MOJOSHADER_samplerStateRegister),
9761 "::",
9762 stringify!(sampler_state_count)
9763 )
9764 );
9765 assert_eq!(
9766 unsafe {
9767 &(*(::std::ptr::null::<MOJOSHADER_samplerStateRegister>())).sampler_states as *const _
9768 as usize
9769 },
9770 16usize,
9771 concat!(
9772 "Offset of field: ",
9773 stringify!(MOJOSHADER_samplerStateRegister),
9774 "::",
9775 stringify!(sampler_states)
9776 )
9777 );
9778}
9779#[repr(C)]
9780#[derive(Debug, Copy, Clone)]
9781pub struct MOJOSHADER_effectStateChanges {
9782 pub render_state_change_count: ::std::os::raw::c_uint,
9783 pub render_state_changes: *const MOJOSHADER_effectState,
9784 pub sampler_state_change_count: ::std::os::raw::c_uint,
9785 pub sampler_state_changes: *const MOJOSHADER_samplerStateRegister,
9786 pub vertex_sampler_state_change_count: ::std::os::raw::c_uint,
9787 pub vertex_sampler_state_changes: *const MOJOSHADER_samplerStateRegister,
9788}
9789#[test]
9790fn bindgen_test_layout_MOJOSHADER_effectStateChanges() {
9791 assert_eq!(
9792 ::std::mem::size_of::<MOJOSHADER_effectStateChanges>(),
9793 48usize,
9794 concat!("Size of: ", stringify!(MOJOSHADER_effectStateChanges))
9795 );
9796 assert_eq!(
9797 ::std::mem::align_of::<MOJOSHADER_effectStateChanges>(),
9798 8usize,
9799 concat!("Alignment of ", stringify!(MOJOSHADER_effectStateChanges))
9800 );
9801 assert_eq!(
9802 unsafe {
9803 &(*(::std::ptr::null::<MOJOSHADER_effectStateChanges>())).render_state_change_count
9804 as *const _ as usize
9805 },
9806 0usize,
9807 concat!(
9808 "Offset of field: ",
9809 stringify!(MOJOSHADER_effectStateChanges),
9810 "::",
9811 stringify!(render_state_change_count)
9812 )
9813 );
9814 assert_eq!(
9815 unsafe {
9816 &(*(::std::ptr::null::<MOJOSHADER_effectStateChanges>())).render_state_changes
9817 as *const _ as usize
9818 },
9819 8usize,
9820 concat!(
9821 "Offset of field: ",
9822 stringify!(MOJOSHADER_effectStateChanges),
9823 "::",
9824 stringify!(render_state_changes)
9825 )
9826 );
9827 assert_eq!(
9828 unsafe {
9829 &(*(::std::ptr::null::<MOJOSHADER_effectStateChanges>())).sampler_state_change_count
9830 as *const _ as usize
9831 },
9832 16usize,
9833 concat!(
9834 "Offset of field: ",
9835 stringify!(MOJOSHADER_effectStateChanges),
9836 "::",
9837 stringify!(sampler_state_change_count)
9838 )
9839 );
9840 assert_eq!(
9841 unsafe {
9842 &(*(::std::ptr::null::<MOJOSHADER_effectStateChanges>())).sampler_state_changes
9843 as *const _ as usize
9844 },
9845 24usize,
9846 concat!(
9847 "Offset of field: ",
9848 stringify!(MOJOSHADER_effectStateChanges),
9849 "::",
9850 stringify!(sampler_state_changes)
9851 )
9852 );
9853 assert_eq!(
9854 unsafe {
9855 &(*(::std::ptr::null::<MOJOSHADER_effectStateChanges>()))
9856 .vertex_sampler_state_change_count as *const _ as usize
9857 },
9858 32usize,
9859 concat!(
9860 "Offset of field: ",
9861 stringify!(MOJOSHADER_effectStateChanges),
9862 "::",
9863 stringify!(vertex_sampler_state_change_count)
9864 )
9865 );
9866 assert_eq!(
9867 unsafe {
9868 &(*(::std::ptr::null::<MOJOSHADER_effectStateChanges>())).vertex_sampler_state_changes
9869 as *const _ as usize
9870 },
9871 40usize,
9872 concat!(
9873 "Offset of field: ",
9874 stringify!(MOJOSHADER_effectStateChanges),
9875 "::",
9876 stringify!(vertex_sampler_state_changes)
9877 )
9878 );
9879}
9880pub type MOJOSHADER_compileShaderFunc = ::std::option::Option<
9881 unsafe extern "C" fn(
9882 mainfn: *const ::std::os::raw::c_char,
9883 tokenbuf: *const ::std::os::raw::c_uchar,
9884 bufsize: ::std::os::raw::c_uint,
9885 swiz: *const MOJOSHADER_swizzle,
9886 swizcount: ::std::os::raw::c_uint,
9887 smap: *const MOJOSHADER_samplerMap,
9888 smapcount: ::std::os::raw::c_uint,
9889 ) -> *mut ::std::os::raw::c_void,
9890>;
9891pub type MOJOSHADER_shaderAddRefFunc =
9892 ::std::option::Option<unsafe extern "C" fn(shader: *mut ::std::os::raw::c_void)>;
9893pub type MOJOSHADER_deleteShaderFunc =
9894 ::std::option::Option<unsafe extern "C" fn(shader: *mut ::std::os::raw::c_void)>;
9895pub type MOJOSHADER_getParseDataFunc = ::std::option::Option<
9896 unsafe extern "C" fn(shader: *mut ::std::os::raw::c_void) -> *mut MOJOSHADER_parseData,
9897>;
9898pub type MOJOSHADER_bindShadersFunc = ::std::option::Option<
9899 unsafe extern "C" fn(
9900 vshader: *mut ::std::os::raw::c_void,
9901 pshader: *mut ::std::os::raw::c_void,
9902 ),
9903>;
9904pub type MOJOSHADER_getBoundShadersFunc = ::std::option::Option<
9905 unsafe extern "C" fn(
9906 vshader: *mut *mut ::std::os::raw::c_void,
9907 pshader: *mut *mut ::std::os::raw::c_void,
9908 ),
9909>;
9910pub type MOJOSHADER_mapUniformBufferMemoryFunc = ::std::option::Option<
9911 unsafe extern "C" fn(
9912 vsf: *mut *mut f32,
9913 vsi: *mut *mut ::std::os::raw::c_int,
9914 vsb: *mut *mut ::std::os::raw::c_uchar,
9915 psf: *mut *mut f32,
9916 psi: *mut *mut ::std::os::raw::c_int,
9917 psb: *mut *mut ::std::os::raw::c_uchar,
9918 ),
9919>;
9920pub type MOJOSHADER_unmapUniformBufferMemoryFunc = ::std::option::Option<unsafe extern "C" fn()>;
9921pub type MOJOSHADER_getErrorFunc =
9922 ::std::option::Option<unsafe extern "C" fn() -> *const ::std::os::raw::c_char>;
9923#[repr(C)]
9924#[derive(Debug, Copy, Clone)]
9925pub struct MOJOSHADER_effectShaderContext {
9926 pub compileShader: MOJOSHADER_compileShaderFunc,
9927 pub shaderAddRef: MOJOSHADER_shaderAddRefFunc,
9928 pub deleteShader: MOJOSHADER_deleteShaderFunc,
9929 pub getParseData: MOJOSHADER_getParseDataFunc,
9930 pub bindShaders: MOJOSHADER_bindShadersFunc,
9931 pub getBoundShaders: MOJOSHADER_getBoundShadersFunc,
9932 pub mapUniformBufferMemory: MOJOSHADER_mapUniformBufferMemoryFunc,
9933 pub unmapUniformBufferMemory: MOJOSHADER_unmapUniformBufferMemoryFunc,
9934 pub getError: MOJOSHADER_getErrorFunc,
9935 pub m: MOJOSHADER_malloc,
9936 pub f: MOJOSHADER_free,
9937 pub malloc_data: *mut ::std::os::raw::c_void,
9938}
9939#[test]
9940fn bindgen_test_layout_MOJOSHADER_effectShaderContext() {
9941 assert_eq!(
9942 ::std::mem::size_of::<MOJOSHADER_effectShaderContext>(),
9943 96usize,
9944 concat!("Size of: ", stringify!(MOJOSHADER_effectShaderContext))
9945 );
9946 assert_eq!(
9947 ::std::mem::align_of::<MOJOSHADER_effectShaderContext>(),
9948 8usize,
9949 concat!("Alignment of ", stringify!(MOJOSHADER_effectShaderContext))
9950 );
9951 assert_eq!(
9952 unsafe {
9953 &(*(::std::ptr::null::<MOJOSHADER_effectShaderContext>())).compileShader as *const _
9954 as usize
9955 },
9956 0usize,
9957 concat!(
9958 "Offset of field: ",
9959 stringify!(MOJOSHADER_effectShaderContext),
9960 "::",
9961 stringify!(compileShader)
9962 )
9963 );
9964 assert_eq!(
9965 unsafe {
9966 &(*(::std::ptr::null::<MOJOSHADER_effectShaderContext>())).shaderAddRef as *const _
9967 as usize
9968 },
9969 8usize,
9970 concat!(
9971 "Offset of field: ",
9972 stringify!(MOJOSHADER_effectShaderContext),
9973 "::",
9974 stringify!(shaderAddRef)
9975 )
9976 );
9977 assert_eq!(
9978 unsafe {
9979 &(*(::std::ptr::null::<MOJOSHADER_effectShaderContext>())).deleteShader as *const _
9980 as usize
9981 },
9982 16usize,
9983 concat!(
9984 "Offset of field: ",
9985 stringify!(MOJOSHADER_effectShaderContext),
9986 "::",
9987 stringify!(deleteShader)
9988 )
9989 );
9990 assert_eq!(
9991 unsafe {
9992 &(*(::std::ptr::null::<MOJOSHADER_effectShaderContext>())).getParseData as *const _
9993 as usize
9994 },
9995 24usize,
9996 concat!(
9997 "Offset of field: ",
9998 stringify!(MOJOSHADER_effectShaderContext),
9999 "::",
10000 stringify!(getParseData)
10001 )
10002 );
10003 assert_eq!(
10004 unsafe {
10005 &(*(::std::ptr::null::<MOJOSHADER_effectShaderContext>())).bindShaders as *const _
10006 as usize
10007 },
10008 32usize,
10009 concat!(
10010 "Offset of field: ",
10011 stringify!(MOJOSHADER_effectShaderContext),
10012 "::",
10013 stringify!(bindShaders)
10014 )
10015 );
10016 assert_eq!(
10017 unsafe {
10018 &(*(::std::ptr::null::<MOJOSHADER_effectShaderContext>())).getBoundShaders as *const _
10019 as usize
10020 },
10021 40usize,
10022 concat!(
10023 "Offset of field: ",
10024 stringify!(MOJOSHADER_effectShaderContext),
10025 "::",
10026 stringify!(getBoundShaders)
10027 )
10028 );
10029 assert_eq!(
10030 unsafe {
10031 &(*(::std::ptr::null::<MOJOSHADER_effectShaderContext>())).mapUniformBufferMemory
10032 as *const _ as usize
10033 },
10034 48usize,
10035 concat!(
10036 "Offset of field: ",
10037 stringify!(MOJOSHADER_effectShaderContext),
10038 "::",
10039 stringify!(mapUniformBufferMemory)
10040 )
10041 );
10042 assert_eq!(
10043 unsafe {
10044 &(*(::std::ptr::null::<MOJOSHADER_effectShaderContext>())).unmapUniformBufferMemory
10045 as *const _ as usize
10046 },
10047 56usize,
10048 concat!(
10049 "Offset of field: ",
10050 stringify!(MOJOSHADER_effectShaderContext),
10051 "::",
10052 stringify!(unmapUniformBufferMemory)
10053 )
10054 );
10055 assert_eq!(
10056 unsafe {
10057 &(*(::std::ptr::null::<MOJOSHADER_effectShaderContext>())).getError as *const _ as usize
10058 },
10059 64usize,
10060 concat!(
10061 "Offset of field: ",
10062 stringify!(MOJOSHADER_effectShaderContext),
10063 "::",
10064 stringify!(getError)
10065 )
10066 );
10067 assert_eq!(
10068 unsafe {
10069 &(*(::std::ptr::null::<MOJOSHADER_effectShaderContext>())).m as *const _ as usize
10070 },
10071 72usize,
10072 concat!(
10073 "Offset of field: ",
10074 stringify!(MOJOSHADER_effectShaderContext),
10075 "::",
10076 stringify!(m)
10077 )
10078 );
10079 assert_eq!(
10080 unsafe {
10081 &(*(::std::ptr::null::<MOJOSHADER_effectShaderContext>())).f as *const _ as usize
10082 },
10083 80usize,
10084 concat!(
10085 "Offset of field: ",
10086 stringify!(MOJOSHADER_effectShaderContext),
10087 "::",
10088 stringify!(f)
10089 )
10090 );
10091 assert_eq!(
10092 unsafe {
10093 &(*(::std::ptr::null::<MOJOSHADER_effectShaderContext>())).malloc_data as *const _
10094 as usize
10095 },
10096 88usize,
10097 concat!(
10098 "Offset of field: ",
10099 stringify!(MOJOSHADER_effectShaderContext),
10100 "::",
10101 stringify!(malloc_data)
10102 )
10103 );
10104}
10105#[repr(C)]
10106#[derive(Debug, Copy, Clone)]
10107pub struct MOJOSHADER_effect {
10108 pub error_count: ::std::os::raw::c_int,
10109 pub errors: *mut MOJOSHADER_error,
10110 pub param_count: ::std::os::raw::c_int,
10111 pub params: *mut MOJOSHADER_effectParam,
10112 pub technique_count: ::std::os::raw::c_int,
10113 pub techniques: *mut MOJOSHADER_effectTechnique,
10114 pub object_count: ::std::os::raw::c_int,
10115 pub objects: *mut MOJOSHADER_effectObject,
10116 pub current_technique: *const MOJOSHADER_effectTechnique,
10117 pub current_pass: ::std::os::raw::c_int,
10118 pub restore_shader_state: ::std::os::raw::c_int,
10119 pub state_changes: *mut MOJOSHADER_effectStateChanges,
10120 pub current_vert_raw: *mut MOJOSHADER_effectShader,
10121 pub current_pixl_raw: *mut MOJOSHADER_effectShader,
10122 pub current_vert: *mut ::std::os::raw::c_void,
10123 pub current_pixl: *mut ::std::os::raw::c_void,
10124 pub prev_vertex_shader: *mut ::std::os::raw::c_void,
10125 pub prev_pixel_shader: *mut ::std::os::raw::c_void,
10126 pub ctx: MOJOSHADER_effectShaderContext,
10127}
10128#[test]
10129fn bindgen_test_layout_MOJOSHADER_effect() {
10130 assert_eq!(
10131 ::std::mem::size_of::<MOJOSHADER_effect>(),
10132 232usize,
10133 concat!("Size of: ", stringify!(MOJOSHADER_effect))
10134 );
10135 assert_eq!(
10136 ::std::mem::align_of::<MOJOSHADER_effect>(),
10137 8usize,
10138 concat!("Alignment of ", stringify!(MOJOSHADER_effect))
10139 );
10140 assert_eq!(
10141 unsafe { &(*(::std::ptr::null::<MOJOSHADER_effect>())).error_count as *const _ as usize },
10142 0usize,
10143 concat!(
10144 "Offset of field: ",
10145 stringify!(MOJOSHADER_effect),
10146 "::",
10147 stringify!(error_count)
10148 )
10149 );
10150 assert_eq!(
10151 unsafe { &(*(::std::ptr::null::<MOJOSHADER_effect>())).errors as *const _ as usize },
10152 8usize,
10153 concat!(
10154 "Offset of field: ",
10155 stringify!(MOJOSHADER_effect),
10156 "::",
10157 stringify!(errors)
10158 )
10159 );
10160 assert_eq!(
10161 unsafe { &(*(::std::ptr::null::<MOJOSHADER_effect>())).param_count as *const _ as usize },
10162 16usize,
10163 concat!(
10164 "Offset of field: ",
10165 stringify!(MOJOSHADER_effect),
10166 "::",
10167 stringify!(param_count)
10168 )
10169 );
10170 assert_eq!(
10171 unsafe { &(*(::std::ptr::null::<MOJOSHADER_effect>())).params as *const _ as usize },
10172 24usize,
10173 concat!(
10174 "Offset of field: ",
10175 stringify!(MOJOSHADER_effect),
10176 "::",
10177 stringify!(params)
10178 )
10179 );
10180 assert_eq!(
10181 unsafe {
10182 &(*(::std::ptr::null::<MOJOSHADER_effect>())).technique_count as *const _ as usize
10183 },
10184 32usize,
10185 concat!(
10186 "Offset of field: ",
10187 stringify!(MOJOSHADER_effect),
10188 "::",
10189 stringify!(technique_count)
10190 )
10191 );
10192 assert_eq!(
10193 unsafe { &(*(::std::ptr::null::<MOJOSHADER_effect>())).techniques as *const _ as usize },
10194 40usize,
10195 concat!(
10196 "Offset of field: ",
10197 stringify!(MOJOSHADER_effect),
10198 "::",
10199 stringify!(techniques)
10200 )
10201 );
10202 assert_eq!(
10203 unsafe { &(*(::std::ptr::null::<MOJOSHADER_effect>())).object_count as *const _ as usize },
10204 48usize,
10205 concat!(
10206 "Offset of field: ",
10207 stringify!(MOJOSHADER_effect),
10208 "::",
10209 stringify!(object_count)
10210 )
10211 );
10212 assert_eq!(
10213 unsafe { &(*(::std::ptr::null::<MOJOSHADER_effect>())).objects as *const _ as usize },
10214 56usize,
10215 concat!(
10216 "Offset of field: ",
10217 stringify!(MOJOSHADER_effect),
10218 "::",
10219 stringify!(objects)
10220 )
10221 );
10222 assert_eq!(
10223 unsafe {
10224 &(*(::std::ptr::null::<MOJOSHADER_effect>())).current_technique as *const _ as usize
10225 },
10226 64usize,
10227 concat!(
10228 "Offset of field: ",
10229 stringify!(MOJOSHADER_effect),
10230 "::",
10231 stringify!(current_technique)
10232 )
10233 );
10234 assert_eq!(
10235 unsafe { &(*(::std::ptr::null::<MOJOSHADER_effect>())).current_pass as *const _ as usize },
10236 72usize,
10237 concat!(
10238 "Offset of field: ",
10239 stringify!(MOJOSHADER_effect),
10240 "::",
10241 stringify!(current_pass)
10242 )
10243 );
10244 assert_eq!(
10245 unsafe {
10246 &(*(::std::ptr::null::<MOJOSHADER_effect>())).restore_shader_state as *const _ as usize
10247 },
10248 76usize,
10249 concat!(
10250 "Offset of field: ",
10251 stringify!(MOJOSHADER_effect),
10252 "::",
10253 stringify!(restore_shader_state)
10254 )
10255 );
10256 assert_eq!(
10257 unsafe { &(*(::std::ptr::null::<MOJOSHADER_effect>())).state_changes as *const _ as usize },
10258 80usize,
10259 concat!(
10260 "Offset of field: ",
10261 stringify!(MOJOSHADER_effect),
10262 "::",
10263 stringify!(state_changes)
10264 )
10265 );
10266 assert_eq!(
10267 unsafe {
10268 &(*(::std::ptr::null::<MOJOSHADER_effect>())).current_vert_raw as *const _ as usize
10269 },
10270 88usize,
10271 concat!(
10272 "Offset of field: ",
10273 stringify!(MOJOSHADER_effect),
10274 "::",
10275 stringify!(current_vert_raw)
10276 )
10277 );
10278 assert_eq!(
10279 unsafe {
10280 &(*(::std::ptr::null::<MOJOSHADER_effect>())).current_pixl_raw as *const _ as usize
10281 },
10282 96usize,
10283 concat!(
10284 "Offset of field: ",
10285 stringify!(MOJOSHADER_effect),
10286 "::",
10287 stringify!(current_pixl_raw)
10288 )
10289 );
10290 assert_eq!(
10291 unsafe { &(*(::std::ptr::null::<MOJOSHADER_effect>())).current_vert as *const _ as usize },
10292 104usize,
10293 concat!(
10294 "Offset of field: ",
10295 stringify!(MOJOSHADER_effect),
10296 "::",
10297 stringify!(current_vert)
10298 )
10299 );
10300 assert_eq!(
10301 unsafe { &(*(::std::ptr::null::<MOJOSHADER_effect>())).current_pixl as *const _ as usize },
10302 112usize,
10303 concat!(
10304 "Offset of field: ",
10305 stringify!(MOJOSHADER_effect),
10306 "::",
10307 stringify!(current_pixl)
10308 )
10309 );
10310 assert_eq!(
10311 unsafe {
10312 &(*(::std::ptr::null::<MOJOSHADER_effect>())).prev_vertex_shader as *const _ as usize
10313 },
10314 120usize,
10315 concat!(
10316 "Offset of field: ",
10317 stringify!(MOJOSHADER_effect),
10318 "::",
10319 stringify!(prev_vertex_shader)
10320 )
10321 );
10322 assert_eq!(
10323 unsafe {
10324 &(*(::std::ptr::null::<MOJOSHADER_effect>())).prev_pixel_shader as *const _ as usize
10325 },
10326 128usize,
10327 concat!(
10328 "Offset of field: ",
10329 stringify!(MOJOSHADER_effect),
10330 "::",
10331 stringify!(prev_pixel_shader)
10332 )
10333 );
10334 assert_eq!(
10335 unsafe { &(*(::std::ptr::null::<MOJOSHADER_effect>())).ctx as *const _ as usize },
10336 136usize,
10337 concat!(
10338 "Offset of field: ",
10339 stringify!(MOJOSHADER_effect),
10340 "::",
10341 stringify!(ctx)
10342 )
10343 );
10344}
10345extern "C" {
10346 pub fn MOJOSHADER_compileEffect(
10347 tokenbuf: *const ::std::os::raw::c_uchar,
10348 bufsize: ::std::os::raw::c_uint,
10349 swiz: *const MOJOSHADER_swizzle,
10350 swizcount: ::std::os::raw::c_uint,
10351 smap: *const MOJOSHADER_samplerMap,
10352 smapcount: ::std::os::raw::c_uint,
10353 ctx: *const MOJOSHADER_effectShaderContext,
10354 ) -> *mut MOJOSHADER_effect;
10355}
10356extern "C" {
10357 pub fn MOJOSHADER_deleteEffect(effect: *const MOJOSHADER_effect);
10358}
10359extern "C" {
10360 pub fn MOJOSHADER_cloneEffect(effect: *const MOJOSHADER_effect) -> *mut MOJOSHADER_effect;
10361}
10362extern "C" {
10363 pub fn MOJOSHADER_effectSetRawValueHandle(
10364 parameter: *const MOJOSHADER_effectParam,
10365 data: *const ::std::os::raw::c_void,
10366 offset: ::std::os::raw::c_uint,
10367 len: ::std::os::raw::c_uint,
10368 );
10369}
10370extern "C" {
10371 pub fn MOJOSHADER_effectSetRawValueName(
10372 effect: *const MOJOSHADER_effect,
10373 name: *const ::std::os::raw::c_char,
10374 data: *const ::std::os::raw::c_void,
10375 offset: ::std::os::raw::c_uint,
10376 len: ::std::os::raw::c_uint,
10377 );
10378}
10379extern "C" {
10380 pub fn MOJOSHADER_effectGetCurrentTechnique(
10381 effect: *const MOJOSHADER_effect,
10382 ) -> *const MOJOSHADER_effectTechnique;
10383}
10384extern "C" {
10385 pub fn MOJOSHADER_effectSetTechnique(
10386 effect: *mut MOJOSHADER_effect,
10387 technique: *const MOJOSHADER_effectTechnique,
10388 );
10389}
10390extern "C" {
10391 pub fn MOJOSHADER_effectFindNextValidTechnique(
10392 effect: *const MOJOSHADER_effect,
10393 technique: *const MOJOSHADER_effectTechnique,
10394 ) -> *const MOJOSHADER_effectTechnique;
10395}
10396extern "C" {
10397 pub fn MOJOSHADER_effectBegin(
10398 effect: *mut MOJOSHADER_effect,
10399 numPasses: *mut ::std::os::raw::c_uint,
10400 saveShaderState: ::std::os::raw::c_int,
10401 stateChanges: *mut MOJOSHADER_effectStateChanges,
10402 );
10403}
10404extern "C" {
10405 pub fn MOJOSHADER_effectBeginPass(effect: *mut MOJOSHADER_effect, pass: ::std::os::raw::c_uint);
10406}
10407extern "C" {
10408 pub fn MOJOSHADER_effectCommitChanges(effect: *mut MOJOSHADER_effect);
10409}
10410extern "C" {
10411 pub fn MOJOSHADER_effectEndPass(effect: *mut MOJOSHADER_effect);
10412}
10413extern "C" {
10414 pub fn MOJOSHADER_effectEnd(effect: *mut MOJOSHADER_effect);
10415}
10416extern "C" {
10417 pub fn MOJOSHADER_mtlCompileLibrary(
10418 effect: *mut MOJOSHADER_effect,
10419 ) -> *mut ::std::os::raw::c_void;
10420}