1#[repr(C)]
2#[derive(Copy, Clone, Debug, Default, Eq, Hash, Ord, PartialEq, PartialOrd)]
3pub struct __BindgenBitfieldUnit<Storage> {
4 storage: Storage,
5}
6impl<Storage> __BindgenBitfieldUnit<Storage> {
7 #[inline]
8 pub const fn new(storage: Storage) -> Self {
9 Self { storage }
10 }
11}
12impl<Storage> __BindgenBitfieldUnit<Storage>
13where
14 Storage: AsRef<[u8]> + AsMut<[u8]>,
15{
16 #[inline]
17 pub fn get_bit(&self, index: usize) -> bool {
18 debug_assert!(index / 8 < self.storage.as_ref().len());
19 let byte_index = index / 8;
20 let byte = self.storage.as_ref()[byte_index];
21 let bit_index = if cfg!(target_endian = "big") {
22 7 - (index % 8)
23 } else {
24 index % 8
25 };
26 let mask = 1 << bit_index;
27 byte & mask == mask
28 }
29 #[inline]
30 pub fn set_bit(&mut self, index: usize, val: bool) {
31 debug_assert!(index / 8 < self.storage.as_ref().len());
32 let byte_index = index / 8;
33 let byte = &mut self.storage.as_mut()[byte_index];
34 let bit_index = if cfg!(target_endian = "big") {
35 7 - (index % 8)
36 } else {
37 index % 8
38 };
39 let mask = 1 << bit_index;
40 if val {
41 *byte |= mask;
42 } else {
43 *byte &= !mask;
44 }
45 }
46 #[inline]
47 pub fn get(&self, bit_offset: usize, bit_width: u8) -> u64 {
48 debug_assert!(bit_width <= 64);
49 debug_assert!(bit_offset / 8 < self.storage.as_ref().len());
50 debug_assert!((bit_offset + (bit_width as usize)) / 8 <= self.storage.as_ref().len());
51 let mut val = 0;
52 for i in 0..(bit_width as usize) {
53 if self.get_bit(i + bit_offset) {
54 let index = if cfg!(target_endian = "big") {
55 bit_width as usize - 1 - i
56 } else {
57 i
58 };
59 val |= 1 << index;
60 }
61 }
62 val
63 }
64 #[inline]
65 pub fn set(&mut self, bit_offset: usize, bit_width: u8, val: u64) {
66 debug_assert!(bit_width <= 64);
67 debug_assert!(bit_offset / 8 < self.storage.as_ref().len());
68 debug_assert!((bit_offset + (bit_width as usize)) / 8 <= self.storage.as_ref().len());
69 for i in 0..(bit_width as usize) {
70 let mask = 1 << i;
71 let val_bit_is_set = val & mask == mask;
72 let index = if cfg!(target_endian = "big") {
73 bit_width as usize - 1 - i
74 } else {
75 i
76 };
77 self.set_bit(index + bit_offset, val_bit_is_set);
78 }
79 }
80}
81pub const _VCRT_COMPILER_PREPROCESSOR: u32 = 1;
82pub const _SAL_VERSION: u32 = 20;
83pub const __SAL_H_VERSION: u32 = 180000000;
84pub const _USE_DECLSPECS_FOR_SAL: u32 = 0;
85pub const _USE_ATTRIBUTES_FOR_SAL: u32 = 0;
86pub const _CRT_PACKING: u32 = 8;
87pub const _HAS_NODISCARD: u32 = 0;
88pub const __bool_true_false_are_defined: u32 = 1;
89pub const TM_USE_STRHASH_TYPE: u32 = 1;
90pub const TM_PAGE_SIZE: u32 = 4096;
91pub const TM_JSON_ERROR_STRING_LENGTH: u32 = 79;
92pub const TM_DIRSEP: &'static [u8; 2usize] = b"/\0";
93pub const TM_MEMORY_TRACKER_SCOPE__NONE: u32 = 4294967295;
94pub const TM_DIRECTORY_SEPARATOR: u8 = 47u8;
95pub const TM_TT_TYPE__PLUGIN: &'static [u8; 10usize] = b"tm_plugin\0";
96pub const SHA1_DIGEST_SIZE: u32 = 20;
97pub const TM_TT_TYPE__ANYTHING: &'static [u8; 12usize] = b"tm_anything\0";
98pub const TM_THE_TRUTH_PROPERTY_NAME_LENGTH: u32 = 63;
99pub const TM_TT_TYPE__ASSET_ROOT: &'static [u8; 14usize] = b"tm_asset_root\0";
100pub const TM_TT_TYPE__ASSET: &'static [u8; 9usize] = b"tm_asset\0";
101pub const TM_TT_TYPE__ASSET_DIRECTORY: &'static [u8; 19usize] = b"tm_asset_directory\0";
102pub const TM_TT_TYPE__ASSET_LABEL: &'static [u8; 15usize] = b"tm_asset_label\0";
103pub const TM_TT_TYPE__ASSET_THUMBNAIL: &'static [u8; 19usize] = b"tm_asset_thumbnail\0";
104pub const TM_TT_TYPE__BOOL: &'static [u8; 8usize] = b"tm_bool\0";
105pub const TM_TT_TYPE__UINT32_T: &'static [u8; 12usize] = b"tm_uint32_t\0";
106pub const TM_TT_TYPE__UINT64_T: &'static [u8; 12usize] = b"tm_uint64_t\0";
107pub const TM_TT_TYPE__FLOAT: &'static [u8; 9usize] = b"tm_float\0";
108pub const TM_TT_TYPE__DOUBLE: &'static [u8; 10usize] = b"tm_double\0";
109pub const TM_TT_TYPE__STRING: &'static [u8; 10usize] = b"tm_string\0";
110pub const TM_TT_TYPE__VEC2: &'static [u8; 10usize] = b"tm_vec2_t\0";
111pub const TM_TT_TYPE__VEC3: &'static [u8; 10usize] = b"tm_vec3_t\0";
112pub const TM_TT_TYPE__VEC4: &'static [u8; 10usize] = b"tm_vec4_t\0";
113pub const TM_TT_TYPE__POSITION: &'static [u8; 12usize] = b"tm_position\0";
114pub const TM_TT_TYPE__ROTATION: &'static [u8; 12usize] = b"tm_rotation\0";
115pub const TM_TT_TYPE__SCALE: &'static [u8; 9usize] = b"tm_scale\0";
116pub const TM_TT_TYPE__COLOR_RGB: &'static [u8; 13usize] = b"tm_color_rgb\0";
117pub const TM_TT_TYPE__COLOR_RGBA: &'static [u8; 14usize] = b"tm_color_rgba\0";
118pub const TM_TT_TYPE__RECT: &'static [u8; 10usize] = b"tm_rect_t\0";
119pub const TM_TT_TYPE__UUID: &'static [u8; 10usize] = b"tm_uuid_t\0";
120pub const TM_TT_TYPE__VISIBILITY_FLAG: &'static [u8; 19usize] = b"tm_visibility_flag\0";
121pub type va_list = *mut ::std::os::raw::c_char;
122extern "C" {
123 pub fn __va_start(arg1: *mut *mut ::std::os::raw::c_char, ...);
124}
125pub type __vcrt_bool = bool;
126extern "C" {
127 pub fn __security_init_cookie();
128}
129extern "C" {
130 pub fn __security_check_cookie(_StackCookie: usize);
131}
132extern "C" {
133 pub fn __report_gsfailure(_StackCookie: usize);
134}
135extern "C" {
136 pub static mut __security_cookie: usize;
137}
138pub type int_least8_t = ::std::os::raw::c_schar;
139pub type int_least16_t = ::std::os::raw::c_short;
140pub type int_least32_t = ::std::os::raw::c_int;
141pub type int_least64_t = ::std::os::raw::c_longlong;
142pub type uint_least8_t = ::std::os::raw::c_uchar;
143pub type uint_least16_t = ::std::os::raw::c_ushort;
144pub type uint_least32_t = ::std::os::raw::c_uint;
145pub type uint_least64_t = ::std::os::raw::c_ulonglong;
146pub type int_fast8_t = ::std::os::raw::c_schar;
147pub type int_fast16_t = ::std::os::raw::c_int;
148pub type int_fast32_t = ::std::os::raw::c_int;
149pub type int_fast64_t = ::std::os::raw::c_longlong;
150pub type uint_fast8_t = ::std::os::raw::c_uchar;
151pub type uint_fast16_t = ::std::os::raw::c_uint;
152pub type uint_fast32_t = ::std::os::raw::c_uint;
153pub type uint_fast64_t = ::std::os::raw::c_ulonglong;
154pub type intmax_t = ::std::os::raw::c_longlong;
155pub type uintmax_t = ::std::os::raw::c_ulonglong;
156#[repr(C)]
157#[derive(Default, Copy, Clone)]
158pub struct Vec2T {
159 pub x: f32,
160 pub y: f32,
161}
162#[repr(C)]
163#[derive(Default, Copy, Clone)]
164pub struct Vec3T {
165 pub x: f32,
166 pub y: f32,
167 pub z: f32,
168}
169#[repr(C)]
170#[derive(Default, Copy, Clone)]
171pub struct Vec4T {
172 pub x: f32,
173 pub y: f32,
174 pub z: f32,
175 pub w: f32,
176}
177#[repr(C)]
178#[derive(Default, Copy, Clone)]
179pub struct Mat44T {
180 pub xx: f32,
181 pub xy: f32,
182 pub xz: f32,
183 pub xw: f32,
184 pub yx: f32,
185 pub yy: f32,
186 pub yz: f32,
187 pub yw: f32,
188 pub zx: f32,
189 pub zy: f32,
190 pub zz: f32,
191 pub zw: f32,
192 pub wx: f32,
193 pub wy: f32,
194 pub wz: f32,
195 pub ww: f32,
196}
197#[repr(C)]
198#[derive(Default, Copy, Clone)]
199pub struct TransformT {
200 pub pos: Vec3T,
201 pub rot: Vec4T,
202 pub scl: Vec3T,
203}
204#[repr(C)]
205#[derive(Default, Copy, Clone)]
206pub struct RectT {
207 pub x: f32,
208 pub y: f32,
209 pub w: f32,
210 pub h: f32,
211}
212#[repr(C)]
213#[derive(Copy, Clone)]
214pub struct StrT {
215 pub data: *const ::std::os::raw::c_char,
216 pub size: u32,
217 pub null_terminated: u32,
218}
219impl Default for StrT {
220 fn default() -> Self {
221 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
222 unsafe {
223 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
224 s.assume_init()
225 }
226 }
227}
228#[repr(C)]
229#[derive(Default, Copy, Clone)]
230pub struct ClockO {
231 pub opaque: u64,
232}
233#[repr(C)]
234#[derive(Default, Copy, Clone)]
235pub struct UuidT {
236 pub a: u64,
237 pub b: u64,
238}
239#[repr(C)]
240#[derive(Default, Copy, Clone)]
241pub struct ColorSrgbT {
242 pub r: u8,
243 pub g: u8,
244 pub b: u8,
245 pub a: u8,
246}
247#[repr(C)]
248#[derive(Default, Copy, Clone)]
249pub struct TtTypeT {
250 pub u64_: u64,
251}
252#[repr(C)]
253#[derive(Copy, Clone)]
254pub struct TtIdT {
255 pub __bindgen_anon_1: TtIdTBindgenTy1,
256}
257#[repr(C)]
258#[derive(Copy, Clone)]
259pub union TtIdTBindgenTy1 {
260 pub u64_: u64,
261 pub __bindgen_anon_1: TtIdTBindgenTy1BindgenTy1,
262}
263#[repr(C)]
264#[repr(align(8))]
265#[derive(Default, Copy, Clone)]
266pub struct TtIdTBindgenTy1BindgenTy1 {
267 pub _bitfield_align_1: [u32; 0],
268 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 8usize]>,
269}
270impl TtIdTBindgenTy1BindgenTy1 {
271 #[inline]
272 pub fn type_(&self) -> u64 {
273 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 10u8) as u64) }
274 }
275 #[inline]
276 pub fn set_type(&mut self, val: u64) {
277 unsafe {
278 let val: u64 = ::std::mem::transmute(val);
279 self._bitfield_1.set(0usize, 10u8, val as u64)
280 }
281 }
282 #[inline]
283 pub fn generation(&self) -> u64 {
284 unsafe { ::std::mem::transmute(self._bitfield_1.get(10usize, 22u8) as u64) }
285 }
286 #[inline]
287 pub fn set_generation(&mut self, val: u64) {
288 unsafe {
289 let val: u64 = ::std::mem::transmute(val);
290 self._bitfield_1.set(10usize, 22u8, val as u64)
291 }
292 }
293 #[inline]
294 pub fn index(&self) -> u64 {
295 unsafe { ::std::mem::transmute(self._bitfield_1.get(32usize, 32u8) as u64) }
296 }
297 #[inline]
298 pub fn set_index(&mut self, val: u64) {
299 unsafe {
300 let val: u64 = ::std::mem::transmute(val);
301 self._bitfield_1.set(32usize, 32u8, val as u64)
302 }
303 }
304 #[inline]
305 pub fn new_bitfield_1(
306 type_: u64,
307 generation: u64,
308 index: u64,
309 ) -> __BindgenBitfieldUnit<[u8; 8usize]> {
310 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 8usize]> = Default::default();
311 __bindgen_bitfield_unit.set(0usize, 10u8, {
312 let type_: u64 = unsafe { ::std::mem::transmute(type_) };
313 type_ as u64
314 });
315 __bindgen_bitfield_unit.set(10usize, 22u8, {
316 let generation: u64 = unsafe { ::std::mem::transmute(generation) };
317 generation as u64
318 });
319 __bindgen_bitfield_unit.set(32usize, 32u8, {
320 let index: u64 = unsafe { ::std::mem::transmute(index) };
321 index as u64
322 });
323 __bindgen_bitfield_unit
324 }
325}
326impl Default for TtIdTBindgenTy1 {
327 fn default() -> Self {
328 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
329 unsafe {
330 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
331 s.assume_init()
332 }
333 }
334}
335impl Default for TtIdT {
336 fn default() -> Self {
337 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
338 unsafe {
339 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
340 s.assume_init()
341 }
342 }
343}
344#[repr(C)]
345#[derive(Default, Copy, Clone)]
346pub struct TtUndoScopeT {
347 pub u64_: u64,
348}
349#[repr(C)]
350#[derive(Default, Copy, Clone)]
351pub struct VersionT {
352 pub major: u32,
353 pub minor: u32,
354 pub patch: u32,
355}
356#[repr(C)]
357#[derive(Default, Copy, Clone)]
358pub struct StrhashT {
359 pub u64_: u64,
360}
361#[repr(C)]
362#[derive(Copy, Clone)]
363pub struct AllocatorO {
364 _unused: [u8; 0],
365}
366#[repr(C)]
367#[derive(Copy, Clone)]
368pub struct AllocatorI {
369 pub inst: *mut AllocatorO,
370 pub mem_scope: u32,
371 pub _padding_16: [::std::os::raw::c_char; 4usize],
372 pub realloc: ::std::option::Option<
373 unsafe extern "C" fn(
374 a: *mut AllocatorI,
375 ptr: *mut ::std::os::raw::c_void,
376 old_size: u64,
377 new_size: u64,
378 file: *const ::std::os::raw::c_char,
379 line: u32,
380 ) -> *mut ::std::os::raw::c_void,
381 >,
382}
383impl Default for AllocatorI {
384 fn default() -> Self {
385 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
386 unsafe {
387 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
388 s.assume_init()
389 }
390 }
391}
392#[repr(C)]
393#[derive(Default, Copy, Clone)]
394pub struct AllocatorStatisticsT {
395 pub system_allocation_count: u64,
396 pub system_allocated_bytes: u64,
397 pub vm_reserved: u64,
398 pub vm_committed: u64,
399 pub system_churn_allocation_count: u64,
400 pub system_churn_allocated_bytes: u64,
401 pub vm_churn_committed: u64,
402}
403#[repr(C)]
404#[derive(Copy, Clone)]
405pub struct AllocatorApi {
406 pub system: *mut AllocatorI,
407 pub end_of_page: *mut AllocatorI,
408 pub vm: *mut AllocatorI,
409 pub statistics: *mut AllocatorStatisticsT,
410 pub create_child: ::std::option::Option<
411 unsafe extern "C" fn(
412 parent: *const AllocatorI,
413 desc: *const ::std::os::raw::c_char,
414 ) -> AllocatorI,
415 >,
416 pub destroy_child: ::std::option::Option<unsafe extern "C" fn(child: *const AllocatorI)>,
417 pub destroy_child_allowing_leaks: ::std::option::Option<
418 unsafe extern "C" fn(child: *const AllocatorI, max_leaked_bytes: u64),
419 >,
420 pub create_leaky_root_scope: ::std::option::Option<
421 unsafe extern "C" fn(
422 parent: *const AllocatorI,
423 desc: *const ::std::os::raw::c_char,
424 ) -> AllocatorI,
425 >,
426 pub create_fixed_vm: ::std::option::Option<
427 unsafe extern "C" fn(reserve_size: u64, mem_scope: u32) -> AllocatorI,
428 >,
429}
430impl Default for AllocatorApi {
431 fn default() -> Self {
432 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
433 unsafe {
434 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
435 s.assume_init()
436 }
437 }
438}
439#[repr(C)]
440#[derive(Copy, Clone)]
441pub struct ApiRegistryListenerI {
442 pub ud: *mut ::std::os::raw::c_void,
443 pub add_implementation: ::std::option::Option<
444 unsafe extern "C" fn(
445 ud: *mut ::std::os::raw::c_void,
446 name: *const ::std::os::raw::c_char,
447 version: VersionT,
448 implementation: *const ::std::os::raw::c_void,
449 ),
450 >,
451}
452impl Default for ApiRegistryListenerI {
453 fn default() -> Self {
454 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
455 unsafe {
456 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
457 s.assume_init()
458 }
459 }
460}
461#[repr(C)]
462#[derive(Default, Copy, Clone)]
463pub struct ApiRegistryApi {
464 pub api_registry_version: ::std::option::Option<unsafe extern "C" fn() -> VersionT>,
465 pub set: ::std::option::Option<
466 unsafe extern "C" fn(
467 name: *const ::std::os::raw::c_char,
468 version: VersionT,
469 api: *const ::std::os::raw::c_void,
470 bytes: u32,
471 ),
472 >,
473 pub remove: ::std::option::Option<unsafe extern "C" fn(api: *const ::std::os::raw::c_void)>,
474 pub get: ::std::option::Option<
475 unsafe extern "C" fn(
476 name: *const ::std::os::raw::c_char,
477 version: VersionT,
478 ) -> *mut ::std::os::raw::c_void,
479 >,
480 pub get_optional: ::std::option::Option<
481 unsafe extern "C" fn(
482 api: *mut *mut ::std::os::raw::c_void,
483 name: *const ::std::os::raw::c_char,
484 version: VersionT,
485 ),
486 >,
487 pub version:
488 ::std::option::Option<unsafe extern "C" fn(api: *mut ::std::os::raw::c_void) -> VersionT>,
489 pub add_implementation: ::std::option::Option<
490 unsafe extern "C" fn(
491 name: *const ::std::os::raw::c_char,
492 version: VersionT,
493 implementation: *const ::std::os::raw::c_void,
494 ),
495 >,
496 pub remove_implementation: ::std::option::Option<
497 unsafe extern "C" fn(
498 name: *const ::std::os::raw::c_char,
499 version: VersionT,
500 implementation: *const ::std::os::raw::c_void,
501 ),
502 >,
503 pub implementations: ::std::option::Option<
504 unsafe extern "C" fn(
505 name: *const ::std::os::raw::c_char,
506 version: VersionT,
507 ) -> *mut *mut ::std::os::raw::c_void,
508 >,
509 pub num_implementations: ::std::option::Option<
510 unsafe extern "C" fn(name: *const ::std::os::raw::c_char, version: VersionT) -> u32,
511 >,
512 pub first_implementation: ::std::option::Option<
513 unsafe extern "C" fn(
514 name: *const ::std::os::raw::c_char,
515 version: VersionT,
516 ) -> *mut ::std::os::raw::c_void,
517 >,
518 pub single_implementation: ::std::option::Option<
519 unsafe extern "C" fn(
520 name: *const ::std::os::raw::c_char,
521 version: VersionT,
522 ) -> *mut ::std::os::raw::c_void,
523 >,
524 pub add_listener:
525 ::std::option::Option<unsafe extern "C" fn(listener: *const ApiRegistryListenerI)>,
526 pub static_variable: ::std::option::Option<
527 unsafe extern "C" fn(
528 id: StrhashT,
529 size: u32,
530 file: *const ::std::os::raw::c_char,
531 line: u32,
532 ) -> *mut ::std::os::raw::c_void,
533 >,
534 pub begin_context:
535 ::std::option::Option<unsafe extern "C" fn(name: *const ::std::os::raw::c_char)>,
536 pub end_context:
537 ::std::option::Option<unsafe extern "C" fn(name: *const ::std::os::raw::c_char)>,
538 pub disable_apis_missing_dependencies: ::std::option::Option<unsafe extern "C" fn()>,
539 pub available_versions: ::std::option::Option<
540 unsafe extern "C" fn(
541 name: *const ::std::os::raw::c_char,
542 ta: *mut TempAllocatorI,
543 ) -> *mut VersionT,
544 >,
545}
546#[repr(C)]
547#[derive(Copy, Clone)]
548pub struct UiO {
549 _unused: [u8; 0],
550}
551#[repr(C)]
552#[derive(Copy, Clone)]
553pub struct ColorSpaceDescT {
554 _unused: [u8; 0],
555}
556#[repr(C)]
557#[derive(Copy, Clone)]
558pub struct ApplicationO {
559 _unused: [u8; 0],
560}
561pub type ApplicationModalF = ::std::option::Option<
562 unsafe extern "C" fn(
563 data: *mut ::std::os::raw::c_void,
564 ui: *mut UiO,
565 rect: RectT,
566 font: *const Draw2dFontT,
567 font_scale: f32,
568 delta_time: f32,
569 ) -> bool,
570>;
571#[repr(C)]
572#[derive(Default, Copy, Clone)]
573pub struct ApplicationApi {
574 pub application: ::std::option::Option<unsafe extern "C" fn() -> *mut ApplicationO>,
575 pub create: ::std::option::Option<
576 unsafe extern "C" fn(
577 argc: ::std::os::raw::c_int,
578 argv: *mut *mut ::std::os::raw::c_char,
579 ) -> *mut ApplicationO,
580 >,
581 pub tick: ::std::option::Option<unsafe extern "C" fn(app: *mut ApplicationO) -> bool>,
582 pub destroy: ::std::option::Option<unsafe extern "C" fn(app: *mut ApplicationO)>,
583 pub set_modal: ::std::option::Option<
584 unsafe extern "C" fn(
585 app: *mut ApplicationO,
586 f: ApplicationModalF,
587 data: *mut ::std::os::raw::c_void,
588 ),
589 >,
590 pub is_modal: ::std::option::Option<unsafe extern "C" fn(app: *const ApplicationO) -> bool>,
591 pub asset_root: ::std::option::Option<unsafe extern "C" fn(app: *const ApplicationO) -> TtIdT>,
592 pub load_core: ::std::option::Option<unsafe extern "C" fn(app: *const ApplicationO) -> bool>,
593 pub update_core: ::std::option::Option<
594 unsafe extern "C" fn(app: *const ApplicationO, include_skipped: bool) -> bool,
595 >,
596 pub exit: ::std::option::Option<unsafe extern "C" fn(app: *mut ApplicationO)>,
597 pub set_cursor_hidden:
598 ::std::option::Option<unsafe extern "C" fn(app: *mut ApplicationO, hidden: bool)>,
599 pub viewer_manager:
600 ::std::option::Option<unsafe extern "C" fn(app: *mut ApplicationO) -> *mut ViewerManagerO>,
601 pub default_render_pipeline_api: ::std::option::Option<
602 unsafe extern "C" fn(app: *mut ApplicationO) -> *mut RenderPipelineVt,
603 >,
604 pub custom_ui_scale_factor:
605 ::std::option::Option<unsafe extern "C" fn(app: *mut ApplicationO) -> f32>,
606 pub display_scale_factor:
607 ::std::option::Option<unsafe extern "C" fn(app: *mut ApplicationO, ui: *mut UiO) -> f32>,
608 pub data_dir: ::std::option::Option<
609 unsafe extern "C" fn(app: *mut ApplicationO) -> *const ::std::os::raw::c_char,
610 >,
611 pub color_space: ::std::option::Option<
612 unsafe extern "C" fn(
613 app: *const ApplicationO,
614 color_space: *mut ColorSpaceDescT,
615 format: *mut u32,
616 ),
617 >,
618 pub network:
619 ::std::option::Option<unsafe extern "C" fn(app: *mut ApplicationO) -> *mut NetworkO>,
620}
621#[repr(C)]
622#[derive(Copy, Clone)]
623pub struct TheTruthO {
624 _unused: [u8; 0],
625}
626#[repr(C)]
627#[derive(Copy, Clone)]
628pub struct AssetDatabaseConfigT {
629 pub allocator: *mut AllocatorI,
630 pub fs: *mut OsFileSystemApi,
631 pub file_io: *mut OsFileIoApi,
632}
633impl Default for AssetDatabaseConfigT {
634 fn default() -> Self {
635 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
636 unsafe {
637 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
638 s.assume_init()
639 }
640 }
641}
642#[repr(C)]
643#[derive(Default, Copy, Clone)]
644pub struct AssetDabaseSavedItemT {
645 pub uuid: UuidT,
646 pub is_directory: bool,
647 pub _padding_30: [::std::os::raw::c_char; 7usize],
648}
649#[repr(C)]
650#[derive(Copy, Clone)]
651pub struct AssetDatabaseO {
652 _unused: [u8; 0],
653}
654#[repr(C)]
655#[derive(Default, Copy, Clone)]
656pub struct AssetDatabaseApi {
657 pub create: ::std::option::Option<
658 unsafe extern "C" fn(
659 file: *const ::std::os::raw::c_char,
660 tt: *mut TheTruthO,
661 config: *const AssetDatabaseConfigT,
662 ) -> *mut AssetDatabaseO,
663 >,
664 pub open: ::std::option::Option<
665 unsafe extern "C" fn(
666 file: *const ::std::os::raw::c_char,
667 tt: *mut TheTruthO,
668 config: *const AssetDatabaseConfigT,
669 ) -> *mut AssetDatabaseO,
670 >,
671 pub close: ::std::option::Option<unsafe extern "C" fn(db: *mut AssetDatabaseO)>,
672 pub save_modified:
673 ::std::option::Option<unsafe extern "C" fn(db: *mut AssetDatabaseO, asset_root: TtIdT)>,
674 pub save_modified_except: ::std::option::Option<
675 unsafe extern "C" fn(
676 db: *mut AssetDatabaseO,
677 asset_root: TtIdT,
678 ignore: *mut TtIdT,
679 num_ignore: u32,
680 ),
681 >,
682 pub save_asset:
683 ::std::option::Option<unsafe extern "C" fn(db: *mut AssetDatabaseO, asset: TtIdT)>,
684 pub delete_asset:
685 ::std::option::Option<unsafe extern "C" fn(db: *mut AssetDatabaseO, asset: TtIdT)>,
686 pub revert_asset: ::std::option::Option<
687 unsafe extern "C" fn(
688 db: *mut AssetDatabaseO,
689 asset: TtIdT,
690 undo_scope: TtUndoScopeT,
691 ) -> bool,
692 >,
693 pub load: ::std::option::Option<
694 unsafe extern "C" fn(db: *mut AssetDatabaseO, load_fraction: *mut f32) -> TtIdT,
695 >,
696 pub saved_name: ::std::option::Option<
697 unsafe extern "C" fn(db: *mut AssetDatabaseO, item: UuidT) -> *const ::std::os::raw::c_char,
698 >,
699 pub saved_directory:
700 ::std::option::Option<unsafe extern "C" fn(db: *mut AssetDatabaseO, item: UuidT) -> UuidT>,
701 pub saved_version:
702 ::std::option::Option<unsafe extern "C" fn(db: *mut AssetDatabaseO, asset: UuidT) -> u64>,
703 pub all_saved_items: ::std::option::Option<
704 unsafe extern "C" fn(
705 db: *mut AssetDatabaseO,
706 ta: *mut TempAllocatorI,
707 ) -> *mut AssetDabaseSavedItemT,
708 >,
709}
710#[repr(C)]
711#[derive(Copy, Clone)]
712pub struct AssetIoImport {
713 pub allocator: *mut AllocatorI,
714 pub tt: *mut TheTruthO,
715 pub reimport_into: TtIdT,
716 pub target_dir: TtIdT,
717 pub asset_root: TtIdT,
718 pub ui: *mut UiO,
719 pub asset_browser: TtIdT,
720 pub asset_browser_version_at_start: u64,
721 pub undo_scope: TtUndoScopeT,
722}
723impl Default for AssetIoImport {
724 fn default() -> Self {
725 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
726 unsafe {
727 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
728 s.assume_init()
729 }
730 }
731}
732#[repr(C)]
733#[derive(Copy, Clone)]
734pub struct AssetIoI {
735 pub inst: *mut AssetIoO,
736 pub enabled: ::std::option::Option<unsafe extern "C" fn(inst: *mut AssetIoO) -> bool>,
737 pub can_import: ::std::option::Option<
738 unsafe extern "C" fn(inst: *mut AssetIoO, extension: *const ::std::os::raw::c_char) -> bool,
739 >,
740 pub can_reimport: ::std::option::Option<
741 unsafe extern "C" fn(inst: *mut AssetIoO, tt: *mut TheTruthO, asset: TtIdT) -> bool,
742 >,
743 pub importer_extensions_string: ::std::option::Option<
744 unsafe extern "C" fn(
745 inst: *mut AssetIoO,
746 output: *mut *mut ::std::os::raw::c_char,
747 ta: *mut TempAllocatorI,
748 separator: *const ::std::os::raw::c_char,
749 ),
750 >,
751 pub importer_description_string: ::std::option::Option<
752 unsafe extern "C" fn(
753 inst: *mut AssetIoO,
754 output: *mut *mut ::std::os::raw::c_char,
755 ta: *mut TempAllocatorI,
756 separator: *const ::std::os::raw::c_char,
757 ),
758 >,
759 pub import_asset: ::std::option::Option<
760 unsafe extern "C" fn(
761 inst: *mut AssetIoO,
762 file: *const ::std::os::raw::c_char,
763 import: *const AssetIoImport,
764 ) -> u64,
765 >,
766 pub can_export: ::std::option::Option<
767 unsafe extern "C" fn(inst: *mut AssetIoO, tt: *mut TheTruthO, asset: TtIdT) -> bool,
768 >,
769 pub exporter_extension: ::std::option::Option<
770 unsafe extern "C" fn(
771 inst: *mut AssetIoO,
772 tt: *mut TheTruthO,
773 asset: TtIdT,
774 ) -> *const ::std::os::raw::c_char,
775 >,
776 pub export_asset: ::std::option::Option<
777 unsafe extern "C" fn(
778 inst: *mut AssetIoO,
779 file: *const ::std::os::raw::c_char,
780 tt: *mut TheTruthO,
781 asset_root: TtIdT,
782 asset: TtIdT,
783 ),
784 >,
785}
786impl Default for AssetIoI {
787 fn default() -> Self {
788 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
789 unsafe {
790 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
791 s.assume_init()
792 }
793 }
794}
795#[repr(C)]
796#[derive(Default, Copy, Clone)]
797pub struct AssetIoApi {
798 pub add_asset_io: ::std::option::Option<unsafe extern "C" fn(loader: *mut AssetIoI)>,
799 pub remove_asset_io: ::std::option::Option<unsafe extern "C" fn(loader: *mut AssetIoI)>,
800 pub importer: ::std::option::Option<
801 unsafe extern "C" fn(extension: *const ::std::os::raw::c_char) -> *mut AssetIoI,
802 >,
803 pub reimporter: ::std::option::Option<
804 unsafe extern "C" fn(tt: *mut TheTruthO, asset: TtIdT) -> *mut AssetIoI,
805 >,
806 pub exporter: ::std::option::Option<
807 unsafe extern "C" fn(tt: *mut TheTruthO, asset: TtIdT) -> *mut AssetIoI,
808 >,
809 pub io_interfaces:
810 ::std::option::Option<unsafe extern "C" fn(interfaces: *mut *mut AssetIoI) -> u32>,
811}
812#[repr(C)]
813#[derive(Default, Copy, Clone)]
814pub struct Base64Api {
815 pub encoded_size: ::std::option::Option<unsafe extern "C" fn(raw_size: u64) -> u64>,
816 pub encode: ::std::option::Option<
817 unsafe extern "C" fn(
818 encoded: *mut ::std::os::raw::c_char,
819 raw: *const u8,
820 raw_size: u64,
821 ) -> u64,
822 >,
823 pub decoded_size: ::std::option::Option<
824 unsafe extern "C" fn(encoded: *const ::std::os::raw::c_char, encoded_size: u64) -> u64,
825 >,
826 pub decode: ::std::option::Option<
827 unsafe extern "C" fn(
828 raw: *mut u8,
829 encoded: *const ::std::os::raw::c_char,
830 encoded_size: u64,
831 ) -> u64,
832 >,
833}
834pub const TM_BOUNDING_VOLUME_TYPE_SPHERE: BoundingVolumeType = 0;
835pub const TM_BOUNDING_VOLUME_TYPE_BOX: BoundingVolumeType = 1;
836pub type BoundingVolumeType = ::std::os::raw::c_int;
837#[repr(C)]
838#[derive(Default, Copy, Clone)]
839pub struct BoundingVolumeSphereT {
840 pub visibility_mask: u64,
841 pub culling_disabled: bool,
842 pub _padding_18: [::std::os::raw::c_char; 3usize],
843 pub position: Vec3T,
844 pub radius: f32,
845 pub _padding_21: [::std::os::raw::c_char; 4usize],
846}
847#[repr(C)]
848#[derive(Default, Copy, Clone)]
849pub struct BoundingVolumeBoxT {
850 pub visibility_mask: u64,
851 pub culling_disabled: bool,
852 pub _padding_29: [::std::os::raw::c_char; 3usize],
853 pub tm: Mat44T,
854 pub min: Vec3T,
855 pub max: Vec3T,
856 pub _padding_33: [::std::os::raw::c_char; 4usize],
857}
858#[repr(C)]
859#[derive(Default, Copy, Clone)]
860pub struct BuddyAllocatorRawApi {
861 pub init:
862 ::std::option::Option<unsafe extern "C" fn(buffer: *mut u8, size: u32, block_size: u32)>,
863 pub realloc: ::std::option::Option<
864 unsafe extern "C" fn(
865 buffer: *mut u8,
866 ptr: *mut ::std::os::raw::c_void,
867 old_size: u64,
868 new_size: u64,
869 ) -> *mut ::std::os::raw::c_void,
870 >,
871}
872#[repr(C)]
873#[derive(Default, Copy, Clone)]
874pub struct BuddyAllocatorApi {
875 pub create: ::std::option::Option<
876 unsafe extern "C" fn(
877 backing: *mut AllocatorI,
878 initial_size: u32,
879 block_size: u32,
880 ) -> *mut AllocatorI,
881 >,
882 pub destroy: ::std::option::Option<unsafe extern "C" fn(a: *mut AllocatorI)>,
883}
884#[repr(C)]
885#[derive(Copy, Clone)]
886pub struct BuffersO {
887 _unused: [u8; 0],
888}
889#[repr(C)]
890#[derive(Copy, Clone)]
891pub struct BuffersI {
892 pub inst: *mut BuffersO,
893 pub allocate: ::std::option::Option<
894 unsafe extern "C" fn(
895 inst: *mut BuffersO,
896 size: u64,
897 initialize: *const ::std::os::raw::c_void,
898 ) -> *mut ::std::os::raw::c_void,
899 >,
900 pub add: ::std::option::Option<
901 unsafe extern "C" fn(
902 inst: *mut BuffersO,
903 data: *const ::std::os::raw::c_void,
904 size: u64,
905 hash: u64,
906 ) -> u32,
907 >,
908 pub retain: ::std::option::Option<unsafe extern "C" fn(inst: *mut BuffersO, id: u32)>,
909 pub release: ::std::option::Option<unsafe extern "C" fn(inst: *mut BuffersO, id: u32)>,
910 pub get: ::std::option::Option<
911 unsafe extern "C" fn(
912 inst: *const BuffersO,
913 id: u32,
914 size: *mut u64,
915 ) -> *const ::std::os::raw::c_void,
916 >,
917 pub size: ::std::option::Option<unsafe extern "C" fn(inst: *const BuffersO, id: u32) -> u64>,
918 pub hash: ::std::option::Option<unsafe extern "C" fn(inst: *const BuffersO, id: u32) -> u64>,
919 pub lookup:
920 ::std::option::Option<unsafe extern "C" fn(inst: *const BuffersO, hash: u64) -> u32>,
921 pub debug__refcount:
922 ::std::option::Option<unsafe extern "C" fn(inst: *const BuffersO, id: u32) -> u32>,
923}
924impl Default for BuffersI {
925 fn default() -> Self {
926 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
927 unsafe {
928 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
929 s.assume_init()
930 }
931 }
932}
933#[repr(C)]
934#[derive(Copy, Clone)]
935pub struct StreamableBuffersI {
936 pub super_: BuffersI,
937 pub map: ::std::option::Option<
938 unsafe extern "C" fn(
939 inst: *mut BuffersO,
940 path: *const ::std::os::raw::c_char,
941 offset: u64,
942 size: u64,
943 hash: u64,
944 ) -> u32,
945 >,
946 pub map_database: ::std::option::Option<
947 unsafe extern "C" fn(
948 inst: *mut BuffersO,
949 hash: u64,
950 size: u64,
951 file: *const FileO,
952 page_size: u32,
953 page_header_size: u32,
954 first_page: u32,
955 ) -> u32,
956 >,
957 pub is_mapped:
958 ::std::option::Option<unsafe extern "C" fn(inst: *const BuffersO, id: u32) -> bool>,
959 pub is_loaded:
960 ::std::option::Option<unsafe extern "C" fn(inst: *const BuffersO, id: u32) -> bool>,
961 pub unload: ::std::option::Option<unsafe extern "C" fn(inst: *mut BuffersO, id: u32)>,
962 pub save: ::std::option::Option<
963 unsafe extern "C" fn(
964 inst: *mut BuffersO,
965 id: u32,
966 path: *const ::std::os::raw::c_char,
967 offset: u64,
968 ),
969 >,
970 pub background_load_all:
971 ::std::option::Option<unsafe extern "C" fn(inst: *mut BuffersO, percentage: *mut f32)>,
972 pub ensure_all_loaded: ::std::option::Option<unsafe extern "C" fn(inst: *mut BuffersO)>,
973 pub set_io:
974 ::std::option::Option<unsafe extern "C" fn(inst: *mut BuffersO, io: *mut OsFileIoApi)>,
975}
976impl Default for StreamableBuffersI {
977 fn default() -> Self {
978 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
979 unsafe {
980 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
981 s.assume_init()
982 }
983 }
984}
985#[repr(C)]
986#[derive(Default, Copy, Clone)]
987pub struct BuffersApi {
988 pub create: ::std::option::Option<unsafe extern "C" fn(a: *mut AllocatorI) -> *mut BuffersI>,
989 pub destroy: ::std::option::Option<unsafe extern "C" fn(i: *mut BuffersI)>,
990 pub create_streamable: ::std::option::Option<
991 unsafe extern "C" fn(a: *mut AllocatorI, io: *mut OsFileIoApi) -> *mut StreamableBuffersI,
992 >,
993 pub destroy_streamable: ::std::option::Option<unsafe extern "C" fn(i: *mut StreamableBuffersI)>,
994}
995pub const TM_BUFFER_COMPONENT_TYPE_FLOAT: BufferComponentType = 0;
996pub const TM_BUFFER_COMPONENT_TYPE_NORMALIZED_INTEGER: BufferComponentType = 1;
997pub const TM_BUFFER_COMPONENT_TYPE_INTEGER: BufferComponentType = 2;
998pub const TM_BUFFER_COMPONENT_TYPE_DEPTH_STENCIL: BufferComponentType = 3;
999pub type BufferComponentType = ::std::os::raw::c_int;
1000pub const TM_BUFFER_COMPRESSION_FORMAT_BC1_RGB: BufferCompressionFormat = 0;
1001pub const TM_BUFFER_COMPRESSION_FORMAT_BC1_RGBA: BufferCompressionFormat = 1;
1002pub const TM_BUFFER_COMPRESSION_FORMAT_BC2: BufferCompressionFormat = 2;
1003pub const TM_BUFFER_COMPRESSION_FORMAT_BC3: BufferCompressionFormat = 3;
1004pub const TM_BUFFER_COMPRESSION_FORMAT_BC4: BufferCompressionFormat = 4;
1005pub const TM_BUFFER_COMPRESSION_FORMAT_BC5: BufferCompressionFormat = 5;
1006pub const TM_BUFFER_COMPRESSION_FORMAT_BC6H_U: BufferCompressionFormat = 6;
1007pub const TM_BUFFER_COMPRESSION_FORMAT_BC6H_S: BufferCompressionFormat = 7;
1008pub const TM_BUFFER_COMPRESSION_FORMAT_BC7: BufferCompressionFormat = 8;
1009pub const TM_BUFFER_COMPRESSION_FORMAT_ETC2_RGB: BufferCompressionFormat = 9;
1010pub const TM_BUFFER_COMPRESSION_FORMAT_ETC2_RGBA: BufferCompressionFormat = 10;
1011pub const TM_BUFFER_COMPRESSION_FORMAT_MAX_FORMATS: BufferCompressionFormat = 11;
1012pub type BufferCompressionFormat = ::std::os::raw::c_int;
1013#[repr(C)]
1014#[derive(Default, Copy, Clone)]
1015pub struct BufferFormatApi {
1016 pub encode_uncompressed_format: ::std::option::Option<
1017 unsafe extern "C" fn(
1018 component_type: BufferComponentType,
1019 sign: bool,
1020 bits_x: u8,
1021 bits_y: u8,
1022 bits_z: u8,
1023 bits_w: u8,
1024 ) -> u32,
1025 >,
1026 pub encode_compressed_format: ::std::option::Option<
1027 unsafe extern "C" fn(compression_type: BufferCompressionFormat) -> u32,
1028 >,
1029 pub is_compressed: ::std::option::Option<unsafe extern "C" fn(format: u32) -> bool>,
1030 pub decode_uncompressed: ::std::option::Option<
1031 unsafe extern "C" fn(
1032 format: u32,
1033 component_type: *mut BufferComponentType,
1034 sign: *mut bool,
1035 bits_x: *mut u8,
1036 bits_y: *mut u8,
1037 bits_z: *mut u8,
1038 bits_w: *mut u8,
1039 ) -> bool,
1040 >,
1041 pub decode_compression_format: ::std::option::Option<
1042 unsafe extern "C" fn(format: u32, compression_format: *mut BufferCompressionFormat) -> bool,
1043 >,
1044 pub bits_per_element: ::std::option::Option<unsafe extern "C" fn(format: u32) -> u32>,
1045 pub num_components: ::std::option::Option<unsafe extern "C" fn(format: u32) -> u32>,
1046 pub human_readable: ::std::option::Option<
1047 unsafe extern "C" fn(format: u32, ta: *mut TempAllocatorI) -> *const ::std::os::raw::c_char,
1048 >,
1049}
1050pub const TM_CAMERA_TRANSFORM_DEFAULT: CameraTransform = 0;
1051pub const TM_CAMERA_TRANSFORM_EYE_LEFT: CameraTransform = 1;
1052pub const TM_CAMERA_TRANSFORM_EYE_RIGHT: CameraTransform = 2;
1053pub const TM_CAMERA_TRANSFORM_MAX_TRANSFORMS: CameraTransform = 3;
1054pub type CameraTransform = ::std::os::raw::c_int;
1055pub const TM_CAMERA_MODE_PERSPECTIVE: CameraMode = 0;
1056pub const TM_CAMERA_MODE_ORTHOGRAPHIC: CameraMode = 1;
1057pub type CameraMode = ::std::os::raw::c_int;
1058pub const TM_CAMERA_FRUSTUM_PLANE_LEFT: CameraFrustumPlanes = 0;
1059pub const TM_CAMERA_FRUSTUM_PLANE_RIGHT: CameraFrustumPlanes = 1;
1060pub const TM_CAMERA_FRUSTUM_PLANE_BOTTOM: CameraFrustumPlanes = 2;
1061pub const TM_CAMERA_FRUSTUM_PLANE_TOP: CameraFrustumPlanes = 3;
1062pub const TM_CAMERA_FRUSTUM_PLANE_NEAR: CameraFrustumPlanes = 4;
1063pub const TM_CAMERA_FRUSTUM_PLANE_FAR: CameraFrustumPlanes = 5;
1064pub const TM_CAMERA_FRUSTUM_PLANE_MAX_PLANES: CameraFrustumPlanes = 6;
1065pub type CameraFrustumPlanes = ::std::os::raw::c_int;
1066#[repr(C)]
1067#[derive(Copy, Clone)]
1068pub struct CameraSettingsT {
1069 pub mode: CameraMode,
1070 pub near_plane: f32,
1071 pub far_plane: f32,
1072 pub __bindgen_anon_1: CameraSettingsTBindgenTy1,
1073 pub shutter_speed: f32,
1074 pub aperture: f32,
1075 pub iso: f32,
1076}
1077#[repr(C)]
1078#[derive(Copy, Clone)]
1079pub union CameraSettingsTBindgenTy1 {
1080 pub vertical_fov: f32,
1081 pub box_height: f32,
1082}
1083impl Default for CameraSettingsTBindgenTy1 {
1084 fn default() -> Self {
1085 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
1086 unsafe {
1087 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
1088 s.assume_init()
1089 }
1090 }
1091}
1092impl Default for CameraSettingsT {
1093 fn default() -> Self {
1094 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
1095 unsafe {
1096 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
1097 s.assume_init()
1098 }
1099 }
1100}
1101#[repr(C)]
1102#[derive(Copy, Clone)]
1103pub struct CameraT {
1104 pub projection: [Mat44T; 3usize],
1105 pub view: [Mat44T; 3usize],
1106 pub settings: CameraSettingsT,
1107}
1108impl Default for CameraT {
1109 fn default() -> Self {
1110 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
1111 unsafe {
1112 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
1113 s.assume_init()
1114 }
1115 }
1116}
1117#[repr(C)]
1118#[derive(Default, Copy, Clone)]
1119pub struct CameraApi {
1120 pub view_from_transform: ::std::option::Option<
1121 unsafe extern "C" fn(view: *mut Mat44T, tm: *const TransformT) -> *mut Mat44T,
1122 >,
1123 pub view_from_lookin: ::std::option::Option<
1124 unsafe extern "C" fn(
1125 view: *mut Mat44T,
1126 position: Vec3T,
1127 forward: Vec3T,
1128 up: Vec3T,
1129 ) -> *mut Mat44T,
1130 >,
1131 pub transform_from_view: ::std::option::Option<
1132 unsafe extern "C" fn(tm: *mut TransformT, view: *const Mat44T) -> *mut TransformT,
1133 >,
1134 pub projection_from_frustum: ::std::option::Option<
1135 unsafe extern "C" fn(
1136 proj: *mut Mat44T,
1137 left: f32,
1138 right: f32,
1139 bottom: f32,
1140 top: f32,
1141 near: f32,
1142 far: f32,
1143 ) -> *mut Mat44T,
1144 >,
1145 pub matrices_from_eyes: ::std::option::Option<
1146 unsafe extern "C" fn(
1147 camera: *mut CameraT,
1148 head_tm: *const Mat44T,
1149 head_to_left_eye: *const Mat44T,
1150 head_to_right_eye: *const Mat44T,
1151 left_eye_left: f32,
1152 left_eye_right: f32,
1153 left_eye_top: f32,
1154 left_eye_bottom: f32,
1155 right_eye_left: f32,
1156 right_eye_right: f32,
1157 right_eye_top: f32,
1158 right_eye_bottom: f32,
1159 ),
1160 >,
1161 pub projection_from_fov: ::std::option::Option<
1162 unsafe extern "C" fn(
1163 proj: *mut Mat44T,
1164 near_plane: f32,
1165 far_plane: f32,
1166 vertical_fov: f32,
1167 aspect: f32,
1168 ) -> *mut Mat44T,
1169 >,
1170 pub orthographic_from_frustum: ::std::option::Option<
1171 unsafe extern "C" fn(
1172 proj: *mut Mat44T,
1173 left: f32,
1174 right: f32,
1175 bottom: f32,
1176 top: f32,
1177 near: f32,
1178 far: f32,
1179 ) -> *mut Mat44T,
1180 >,
1181 pub orthographics_from_dimensions: ::std::option::Option<
1182 unsafe extern "C" fn(
1183 proj: *mut Mat44T,
1184 near_plane: f32,
1185 far_plane: f32,
1186 width: f32,
1187 height: f32,
1188 ) -> *mut Mat44T,
1189 >,
1190 pub projection_from_camera: ::std::option::Option<
1191 unsafe extern "C" fn(
1192 camera: *mut CameraT,
1193 transform: CameraTransform,
1194 aspect: f32,
1195 ) -> *mut Mat44T,
1196 >,
1197 pub update_free_flight:
1198 ::std::option::Option<unsafe extern "C" fn(tm: *mut TransformT, t: Vec3T, r: Vec2T)>,
1199 pub update_pan: ::std::option::Option<
1200 unsafe extern "C" fn(tm: *mut TransformT, focus_position: *mut Vec3T, pan: Vec2T),
1201 >,
1202 pub update_maya: ::std::option::Option<
1203 unsafe extern "C" fn(tm: *mut TransformT, focus_position: Vec3T, zoom: f32, rot: Vec2T),
1204 >,
1205 pub world_to_screen: ::std::option::Option<
1206 unsafe extern "C" fn(
1207 camera: *const CameraT,
1208 transform: CameraTransform,
1209 viewport: RectT,
1210 world: *const Vec3T,
1211 screen: *mut Vec3T,
1212 n: u32,
1213 ) -> *mut Vec3T,
1214 >,
1215 pub screen_to_world: ::std::option::Option<
1216 unsafe extern "C" fn(
1217 camera: *const CameraT,
1218 transform: CameraTransform,
1219 viewport: RectT,
1220 screen: *const Vec3T,
1221 world: *mut Vec3T,
1222 n: u32,
1223 ) -> *mut Vec3T,
1224 >,
1225 pub meters_per_pixel: ::std::option::Option<
1226 unsafe extern "C" fn(distance: f32, vertical_fov: f32, viewport_height: f32) -> f32,
1227 >,
1228 pub default_camera_settings:
1229 ::std::option::Option<unsafe extern "C" fn() -> *const CameraSettingsT>,
1230 pub frustum_planes_from_view_projection: ::std::option::Option<
1231 unsafe extern "C" fn(
1232 view: *const Mat44T,
1233 projection: *const Mat44T,
1234 frustum_planes: *mut Vec4T,
1235 ),
1236 >,
1237}
1238pub const TM_COLLABORATION_STATUS_DISCONNECTED: CollaborationStatus = 0;
1239pub const TM_COLLABORATION_STATUS_HOST_STARTING: CollaborationStatus = 1;
1240pub const TM_COLLABORATION_STATUS_HOST: CollaborationStatus = 2;
1241pub const TM_COLLABORATION_STATUS_CONNECTING: CollaborationStatus = 3;
1242pub const TM_COLLABORATION_STATUS_CLIENT: CollaborationStatus = 4;
1243pub const TM_COLLABORATION_STATUS_ERROR: CollaborationStatus = 5;
1244pub type CollaborationStatus = ::std::os::raw::c_int;
1245#[repr(C)]
1246#[derive(Copy, Clone)]
1247pub struct CollaborationConfigI {
1248 pub tt: *mut TheTruthO,
1249 pub ud: *mut ::std::os::raw::c_void,
1250 pub host_init: ::std::option::Option<unsafe extern "C" fn(ud: *mut ::std::os::raw::c_void)>,
1251 pub client_init: ::std::option::Option<unsafe extern "C" fn(ud: *mut ::std::os::raw::c_void)>,
1252 pub host_save_state: ::std::option::Option<
1253 unsafe extern "C" fn(
1254 ud: *mut ::std::os::raw::c_void,
1255 carray: *mut *mut ::std::os::raw::c_char,
1256 a: *mut AllocatorI,
1257 ),
1258 >,
1259 pub client_reset_truth: ::std::option::Option<
1260 unsafe extern "C" fn(ud: *mut ::std::os::raw::c_void) -> *mut TheTruthO,
1261 >,
1262 pub client_decompress_state: ::std::option::Option<
1263 unsafe extern "C" fn(
1264 app_ud: *mut ::std::os::raw::c_void,
1265 state: *const ::std::os::raw::c_char,
1266 size: u64,
1267 allocator: *mut AllocatorI,
1268 ) -> *mut ::std::os::raw::c_char,
1269 >,
1270 pub client_buffer_hashes: ::std::option::Option<
1271 unsafe extern "C" fn(
1272 ud: *mut ::std::os::raw::c_void,
1273 state: *const ::std::os::raw::c_char,
1274 size: u64,
1275 count: *mut u64,
1276 ) -> *const u64,
1277 >,
1278 pub client_load_state: ::std::option::Option<
1279 unsafe extern "C" fn(
1280 ud: *mut ::std::os::raw::c_void,
1281 state: *const ::std::os::raw::c_char,
1282 size: u64,
1283 ) -> bool,
1284 >,
1285 pub cache_dir: *const ::std::os::raw::c_char,
1286}
1287impl Default for CollaborationConfigI {
1288 fn default() -> Self {
1289 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
1290 unsafe {
1291 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
1292 s.assume_init()
1293 }
1294 }
1295}
1296pub const TM_COLLABORATION_SESSION_TYPE_NONE: CollaborationSessionType = 0;
1297pub const TM_COLLABORATION_SESSION_TYPE_HOST: CollaborationSessionType = 1;
1298pub const TM_COLLABORATION_SESSION_TYPE_CLIENT: CollaborationSessionType = 2;
1299pub type CollaborationSessionType = ::std::os::raw::c_int;
1300pub const TM_COLLABORATION_SESSION_STATUS_DISCONNECTED: CollaborationSessionStatus = 0;
1301pub const TM_COLLABORATION_SESSION_STATUS_CONNECTING: CollaborationSessionStatus = 1;
1302pub const TM_COLLABORATION_SESSION_STATUS_CONNECTED: CollaborationSessionStatus = 2;
1303pub const TM_COLLABORATION_SESSION_STATUS_ERROR: CollaborationSessionStatus = 3;
1304pub type CollaborationSessionStatus = ::std::os::raw::c_int;
1305#[repr(C)]
1306#[derive(Copy, Clone)]
1307pub struct CollaborationSessionO {
1308 _unused: [u8; 0],
1309}
1310#[repr(C)]
1311#[derive(Copy, Clone)]
1312pub struct CollaborationSessionI {
1313 pub inst: *mut CollaborationSessionO,
1314 pub destroy: ::std::option::Option<unsafe extern "C" fn(inst: *mut CollaborationSessionO)>,
1315 pub architecture:
1316 ::std::option::Option<unsafe extern "C" fn(inst: *mut CollaborationSessionO) -> StrhashT>,
1317 pub host_id:
1318 ::std::option::Option<unsafe extern "C" fn(inst: *mut CollaborationSessionO) -> u64>,
1319 pub get_client_request: ::std::option::Option<
1320 unsafe extern "C" fn(inst: *mut CollaborationSessionO, client_id: *mut u64) -> bool,
1321 >,
1322 pub accept_client: ::std::option::Option<
1323 unsafe extern "C" fn(inst: *mut CollaborationSessionO, client_id: u64),
1324 >,
1325 pub send: ::std::option::Option<
1326 unsafe extern "C" fn(
1327 inst: *mut CollaborationSessionO,
1328 client_id: u64,
1329 buf: *const u8,
1330 size: u64,
1331 ),
1332 >,
1333 pub flush: ::std::option::Option<unsafe extern "C" fn(inst: *mut CollaborationSessionO)>,
1334 pub update: ::std::option::Option<unsafe extern "C" fn(inst: *mut CollaborationSessionO)>,
1335 pub get_package_data: ::std::option::Option<
1336 unsafe extern "C" fn(
1337 inst: *mut CollaborationSessionO,
1338 client_id: u64,
1339 data: *mut u8,
1340 size: *mut u64,
1341 ) -> bool,
1342 >,
1343 pub close_client: ::std::option::Option<
1344 unsafe extern "C" fn(inst: *mut CollaborationSessionO, client_id: u64),
1345 >,
1346 pub send_ping: ::std::option::Option<
1347 unsafe extern "C" fn(inst: *mut CollaborationSessionO, client_id: u64),
1348 >,
1349 pub type_: ::std::option::Option<
1350 unsafe extern "C" fn(inst: *mut CollaborationSessionO) -> CollaborationSessionType,
1351 >,
1352 pub status: ::std::option::Option<
1353 unsafe extern "C" fn(inst: *mut CollaborationSessionO) -> CollaborationSessionStatus,
1354 >,
1355 pub is_client_alive: ::std::option::Option<
1356 unsafe extern "C" fn(inst: *mut CollaborationSessionO, client_id: u64) -> bool,
1357 >,
1358 pub receive_progress: ::std::option::Option<
1359 unsafe extern "C" fn(
1360 inst: *const CollaborationSessionO,
1361 bytes: *mut u64,
1362 total: *mut u64,
1363 ) -> bool,
1364 >,
1365 pub status_message: ::std::option::Option<
1366 unsafe extern "C" fn(
1367 inst: *mut CollaborationSessionO,
1368 buf: *mut ::std::os::raw::c_char,
1369 max_size: u32,
1370 ),
1371 >,
1372}
1373impl Default for CollaborationSessionI {
1374 fn default() -> Self {
1375 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
1376 unsafe {
1377 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
1378 s.assume_init()
1379 }
1380 }
1381}
1382#[repr(C)]
1383#[derive(Copy, Clone)]
1384pub struct CollaborationO {
1385 _unused: [u8; 0],
1386}
1387#[repr(C)]
1388#[derive(Default, Copy, Clone)]
1389pub struct CollaborationApi {
1390 pub create: ::std::option::Option<
1391 unsafe extern "C" fn(
1392 a: *mut AllocatorI,
1393 config: *const CollaborationConfigI,
1394 ) -> *mut CollaborationO,
1395 >,
1396 pub destroy: ::std::option::Option<unsafe extern "C" fn(coll: *mut CollaborationO)>,
1397 pub status: ::std::option::Option<
1398 unsafe extern "C" fn(coll: *const CollaborationO) -> CollaborationStatus,
1399 >,
1400 pub is_downloading: ::std::option::Option<
1401 unsafe extern "C" fn(coll: *const CollaborationO, bytes: *mut u64, total: *mut u64) -> bool,
1402 >,
1403 pub set_session: ::std::option::Option<
1404 unsafe extern "C" fn(coll: *mut CollaborationO, session: *const CollaborationSessionI),
1405 >,
1406 pub session: ::std::option::Option<
1407 unsafe extern "C" fn(coll: *mut CollaborationO) -> *mut CollaborationSessionI,
1408 >,
1409 pub disconnect: ::std::option::Option<unsafe extern "C" fn(coll: *mut CollaborationO)>,
1410 pub update: ::std::option::Option<unsafe extern "C" fn(coll: *mut CollaborationO)>,
1411 pub handle: ::std::option::Option<
1412 unsafe extern "C" fn(coll: *const CollaborationO) -> *const ::std::os::raw::c_char,
1413 >,
1414 pub set_handle: ::std::option::Option<
1415 unsafe extern "C" fn(c: *mut CollaborationO, handle: *mut ::std::os::raw::c_char),
1416 >,
1417 pub host_handle: ::std::option::Option<
1418 unsafe extern "C" fn(c: *const CollaborationO) -> *const ::std::os::raw::c_char,
1419 >,
1420 pub num_clients:
1421 ::std::option::Option<unsafe extern "C" fn(coll: *const CollaborationO) -> u32>,
1422 pub client_handle: ::std::option::Option<
1423 unsafe extern "C" fn(coll: *const CollaborationO, i: u32) -> *const ::std::os::raw::c_char,
1424 >,
1425 pub all_handles: ::std::option::Option<
1426 unsafe extern "C" fn(
1427 coll: *const CollaborationO,
1428 ta: *mut TempAllocatorI,
1429 ) -> *mut *const ::std::os::raw::c_char,
1430 >,
1431 pub send_chat: ::std::option::Option<
1432 unsafe extern "C" fn(coll: *mut CollaborationO, msg: *const ::std::os::raw::c_char),
1433 >,
1434 pub num_chat_messages:
1435 ::std::option::Option<unsafe extern "C" fn(coll: *const CollaborationO) -> u32>,
1436 pub chat_message: ::std::option::Option<
1437 unsafe extern "C" fn(
1438 coll: *const CollaborationO,
1439 i: u32,
1440 sender: *mut *const ::std::os::raw::c_char,
1441 ) -> *const ::std::os::raw::c_char,
1442 >,
1443 pub resynchronize_state:
1444 ::std::option::Option<unsafe extern "C" fn(coll: *mut CollaborationO, tt: *mut TheTruthO)>,
1445 pub send_test_packages:
1446 ::std::option::Option<unsafe extern "C" fn(coll: *mut CollaborationO, size: u64, num: u32)>,
1447}
1448#[repr(C)]
1449#[derive(Copy, Clone)]
1450pub struct CollaborationP2pO {
1451 _unused: [u8; 0],
1452}
1453#[repr(C)]
1454#[derive(Copy, Clone)]
1455pub struct CollaborationDiscoveredHostT {
1456 pub address: *const SocketAddressT,
1457 pub name: *const ::std::os::raw::c_char,
1458}
1459impl Default for CollaborationDiscoveredHostT {
1460 fn default() -> Self {
1461 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
1462 unsafe {
1463 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
1464 s.assume_init()
1465 }
1466 }
1467}
1468#[repr(C)]
1469#[derive(Default, Copy, Clone)]
1470pub struct CollaborationP2pApi {
1471 pub create: ::std::option::Option<
1472 unsafe extern "C" fn(
1473 coll: *mut CollaborationO,
1474 allocator: *mut AllocatorI,
1475 ) -> *mut CollaborationP2pO,
1476 >,
1477 pub destroy: ::std::option::Option<unsafe extern "C" fn(coll_p2p: *mut CollaborationP2pO)>,
1478 pub update: ::std::option::Option<unsafe extern "C" fn(coll_p2p: *mut CollaborationP2pO)>,
1479 pub host: ::std::option::Option<
1480 unsafe extern "C" fn(coll_p2p: *mut CollaborationP2pO, port: u32, use_upnp: bool),
1481 >,
1482 pub connect: ::std::option::Option<
1483 unsafe extern "C" fn(coll_p2p: *mut CollaborationP2pO, address: *const SocketAddressT),
1484 >,
1485 pub discovered_lan_hosts: ::std::option::Option<
1486 unsafe extern "C" fn(
1487 coll_p2p: *const CollaborationP2pO,
1488 hosts: *mut CollaborationDiscoveredHostT,
1489 max_hosts: u32,
1490 ) -> u32,
1491 >,
1492}
1493pub const TM_CONFIG_TYPE_NULL: ConfigType = 0;
1494pub const TM_CONFIG_TYPE_FALSE: ConfigType = 1;
1495pub const TM_CONFIG_TYPE_TRUE: ConfigType = 2;
1496pub const TM_CONFIG_TYPE_NUMBER: ConfigType = 3;
1497pub const TM_CONFIG_TYPE_STRING: ConfigType = 4;
1498pub const TM_CONFIG_TYPE_ARRAY: ConfigType = 5;
1499pub const TM_CONFIG_TYPE_OBJECT: ConfigType = 6;
1500pub type ConfigType = ::std::os::raw::c_int;
1501#[repr(C)]
1502#[repr(align(4))]
1503#[derive(Default, Copy, Clone)]
1504pub struct ConfigItemT {
1505 pub _bitfield_align_1: [u32; 0],
1506 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>,
1507}
1508impl ConfigItemT {
1509 #[inline]
1510 pub fn type_(&self) -> u32 {
1511 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 3u8) as u32) }
1512 }
1513 #[inline]
1514 pub fn set_type(&mut self, val: u32) {
1515 unsafe {
1516 let val: u32 = ::std::mem::transmute(val);
1517 self._bitfield_1.set(0usize, 3u8, val as u64)
1518 }
1519 }
1520 #[inline]
1521 pub fn offset(&self) -> u32 {
1522 unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 29u8) as u32) }
1523 }
1524 #[inline]
1525 pub fn set_offset(&mut self, val: u32) {
1526 unsafe {
1527 let val: u32 = ::std::mem::transmute(val);
1528 self._bitfield_1.set(3usize, 29u8, val as u64)
1529 }
1530 }
1531 #[inline]
1532 pub fn new_bitfield_1(type_: u32, offset: u32) -> __BindgenBitfieldUnit<[u8; 4usize]> {
1533 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default();
1534 __bindgen_bitfield_unit.set(0usize, 3u8, {
1535 let type_: u32 = unsafe { ::std::mem::transmute(type_) };
1536 type_ as u64
1537 });
1538 __bindgen_bitfield_unit.set(3usize, 29u8, {
1539 let offset: u32 = unsafe { ::std::mem::transmute(offset) };
1540 offset as u64
1541 });
1542 __bindgen_bitfield_unit
1543 }
1544}
1545#[repr(C)]
1546#[derive(Copy, Clone)]
1547pub struct ConfigO {
1548 _unused: [u8; 0],
1549}
1550#[repr(C)]
1551#[derive(Copy, Clone)]
1552pub struct ConfigI {
1553 pub inst: *mut ConfigO,
1554 pub root: ::std::option::Option<unsafe extern "C" fn(inst: *mut ConfigO) -> ConfigItemT>,
1555 pub to_number:
1556 ::std::option::Option<unsafe extern "C" fn(inst: *mut ConfigO, item: ConfigItemT) -> f64>,
1557 pub to_string: ::std::option::Option<
1558 unsafe extern "C" fn(
1559 inst: *mut ConfigO,
1560 item: ConfigItemT,
1561 ) -> *const ::std::os::raw::c_char,
1562 >,
1563 pub to_array: ::std::option::Option<
1564 unsafe extern "C" fn(
1565 inst: *mut ConfigO,
1566 item: ConfigItemT,
1567 items: *mut *mut ConfigItemT,
1568 ) -> u32,
1569 >,
1570 pub to_object: ::std::option::Option<
1571 unsafe extern "C" fn(
1572 inst: *mut ConfigO,
1573 item: ConfigItemT,
1574 keys: *mut *mut ConfigItemT,
1575 values: *mut *mut ConfigItemT,
1576 ) -> u32,
1577 >,
1578 pub array_count:
1579 ::std::option::Option<unsafe extern "C" fn(inst: *mut ConfigO, array: ConfigItemT) -> u32>,
1580 pub array_get: ::std::option::Option<
1581 unsafe extern "C" fn(inst: *mut ConfigO, array: ConfigItemT, index: u32) -> ConfigItemT,
1582 >,
1583 pub object_get: ::std::option::Option<
1584 unsafe extern "C" fn(
1585 inst: *mut ConfigO,
1586 object: ConfigItemT,
1587 key_hash: StrhashT,
1588 ) -> ConfigItemT,
1589 >,
1590 pub add_number:
1591 ::std::option::Option<unsafe extern "C" fn(inst: *mut ConfigO, n: f64) -> ConfigItemT>,
1592 pub add_string: ::std::option::Option<
1593 unsafe extern "C" fn(inst: *mut ConfigO, s: *const ::std::os::raw::c_char) -> ConfigItemT,
1594 >,
1595 pub add_array: ::std::option::Option<
1596 unsafe extern "C" fn(
1597 inst: *mut ConfigO,
1598 items: *const ConfigItemT,
1599 size: u32,
1600 ) -> ConfigItemT,
1601 >,
1602 pub add_object: ::std::option::Option<
1603 unsafe extern "C" fn(
1604 inst: *mut ConfigO,
1605 keys: *const ConfigItemT,
1606 values: *const ConfigItemT,
1607 size: u32,
1608 ) -> ConfigItemT,
1609 >,
1610 pub add_object_with_string_keys: ::std::option::Option<
1611 unsafe extern "C" fn(
1612 inst: *mut ConfigO,
1613 keys: *mut *const ::std::os::raw::c_char,
1614 values: *const ConfigItemT,
1615 size: u32,
1616 ) -> ConfigItemT,
1617 >,
1618 pub array_set: ::std::option::Option<
1619 unsafe extern "C" fn(inst: *mut ConfigO, array: ConfigItemT, i: u32, item: ConfigItemT),
1620 >,
1621 pub array_push: ::std::option::Option<
1622 unsafe extern "C" fn(inst: *mut ConfigO, array: ConfigItemT, item: ConfigItemT),
1623 >,
1624 pub object_update: ::std::option::Option<
1625 unsafe extern "C" fn(
1626 inst: *mut ConfigO,
1627 object: ConfigItemT,
1628 key_hash: StrhashT,
1629 value: ConfigItemT,
1630 ),
1631 >,
1632 pub object_add: ::std::option::Option<
1633 unsafe extern "C" fn(
1634 inst: *mut ConfigO,
1635 object: ConfigItemT,
1636 key: *const ::std::os::raw::c_char,
1637 value: ConfigItemT,
1638 ),
1639 >,
1640 pub set_root:
1641 ::std::option::Option<unsafe extern "C" fn(inst: *mut ConfigO, root: ConfigItemT)>,
1642 pub copy: ::std::option::Option<unsafe extern "C" fn(dst: *mut ConfigO, src: *mut ConfigO)>,
1643 pub allocator:
1644 ::std::option::Option<unsafe extern "C" fn(inst: *mut ConfigO) -> *mut AllocatorI>,
1645 pub validate_object: ::std::option::Option<
1646 unsafe extern "C" fn(
1647 inst: *mut ConfigO,
1648 object: ConfigItemT,
1649 object_display_name: *const ::std::os::raw::c_char,
1650 valid_child_keys: *mut *const ::std::os::raw::c_char,
1651 num_valid_child_keys: u32,
1652 ) -> bool,
1653 >,
1654}
1655impl Default for ConfigI {
1656 fn default() -> Self {
1657 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
1658 unsafe {
1659 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
1660 s.assume_init()
1661 }
1662 }
1663}
1664#[repr(C)]
1665#[derive(Default, Copy, Clone)]
1666pub struct ConfigApi {
1667 pub create: ::std::option::Option<unsafe extern "C" fn(a: *mut AllocatorI) -> *mut ConfigI>,
1668 pub destroy: ::std::option::Option<unsafe extern "C" fn(cdi: *mut ConfigI)>,
1669 pub c_null: ConfigItemT,
1670 pub c_false: ConfigItemT,
1671 pub c_true: ConfigItemT,
1672 pub _padding_189: [::std::os::raw::c_char; 4usize],
1673}
1674pub const TM_CORE_CREATE_POLICY__CREATE: CoreCreatePolicy = 0;
1675pub const TM_CORE_CREATE_POLICY__REMOVE: CoreCreatePolicy = 1;
1676pub const TM_CORE_CREATE_POLICY__IGNORE: CoreCreatePolicy = 2;
1677pub type CoreCreatePolicy = ::std::os::raw::c_int;
1678#[repr(C)]
1679#[derive(Copy, Clone)]
1680pub struct CoreAssetI {
1681 pub core_id: StrhashT,
1682 pub path: *const ::std::os::raw::c_char,
1683 pub create_policy: CoreCreatePolicy,
1684 pub _padding_59: [::std::os::raw::c_char; 4usize],
1685 pub version: u64,
1686 pub user_data: *const ::std::os::raw::c_void,
1687 pub create: ::std::option::Option<
1688 unsafe extern "C" fn(tt: *mut TheTruthO, user_data: *const ::std::os::raw::c_void) -> TtIdT,
1689 >,
1690 pub update: ::std::option::Option<
1691 unsafe extern "C" fn(
1692 tt: *mut TheTruthO,
1693 data_id: TtIdT,
1694 old_version: u64,
1695 user_data: *const ::std::os::raw::c_void,
1696 ),
1697 >,
1698 pub on_change: ::std::option::Option<
1699 unsafe extern "C" fn(
1700 tt: *mut TheTruthO,
1701 data_id: TtIdT,
1702 user_data: *const ::std::os::raw::c_void,
1703 ),
1704 >,
1705}
1706impl Default for CoreAssetI {
1707 fn default() -> Self {
1708 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
1709 unsafe {
1710 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
1711 s.assume_init()
1712 }
1713 }
1714}
1715#[repr(C)]
1716#[derive(Copy, Clone)]
1717pub struct CoreUpdateResultT {
1718 pub created_assets: *mut TtIdT,
1719 pub removed_assets: *mut TtIdT,
1720 pub updated_assets: *mut TtIdT,
1721}
1722impl Default for CoreUpdateResultT {
1723 fn default() -> Self {
1724 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
1725 unsafe {
1726 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
1727 s.assume_init()
1728 }
1729 }
1730}
1731#[repr(C)]
1732#[derive(Copy, Clone)]
1733pub struct CoreUpdatableAssetsT {
1734 pub to_create: *mut *mut CoreAssetI,
1735 pub to_remove: *mut *mut CoreAssetI,
1736 pub to_update: *mut *mut CoreAssetI,
1737}
1738impl Default for CoreUpdatableAssetsT {
1739 fn default() -> Self {
1740 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
1741 unsafe {
1742 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
1743 s.assume_init()
1744 }
1745 }
1746}
1747#[repr(C)]
1748#[derive(Default, Copy, Clone)]
1749pub struct CoreApi {
1750 pub create:
1751 ::std::option::Option<unsafe extern "C" fn(tt: *mut TheTruthO, asset_root_id: TtIdT)>,
1752 pub query_updatable: ::std::option::Option<
1753 unsafe extern "C" fn(
1754 tt: *mut TheTruthO,
1755 asset_root_id: TtIdT,
1756 include_skipped: bool,
1757 ta: *mut TempAllocatorI,
1758 ) -> CoreUpdatableAssetsT,
1759 >,
1760 pub update: ::std::option::Option<
1761 unsafe extern "C" fn(
1762 tt: *mut TheTruthO,
1763 asset_root_id: TtIdT,
1764 to_skip: *mut *mut CoreAssetI,
1765 num_to_skip: u32,
1766 include_skipped: bool,
1767 ta: *mut TempAllocatorI,
1768 ) -> CoreUpdateResultT,
1769 >,
1770 pub locate_asset: ::std::option::Option<
1771 unsafe extern "C" fn(tt: *mut TheTruthO, asset_root_id: TtIdT, core_id: StrhashT) -> TtIdT,
1772 >,
1773}
1774#[repr(C)]
1775#[derive(Copy, Clone)]
1776pub struct CoreImporterAssetT {
1777 pub id: StrhashT,
1778 pub version: u64,
1779 pub path: *const ::std::os::raw::c_char,
1780 pub create_policy: u32,
1781 pub _padding_50: [::std::os::raw::c_char; 4usize],
1782}
1783impl Default for CoreImporterAssetT {
1784 fn default() -> Self {
1785 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
1786 unsafe {
1787 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
1788 s.assume_init()
1789 }
1790 }
1791}
1792#[repr(C)]
1793#[derive(Copy, Clone)]
1794pub struct CoreImporterStateO {
1795 _unused: [u8; 0],
1796}
1797#[repr(C)]
1798#[derive(Default, Copy, Clone)]
1799pub struct CoreImporterApi {
1800 pub create: ::std::option::Option<
1801 unsafe extern "C" fn(
1802 a: *mut AllocatorI,
1803 user_tt: *mut TheTruthO,
1804 user_asset_root: TtIdT,
1805 core_project_path: *const ::std::os::raw::c_char,
1806 output_path: *const ::std::os::raw::c_char,
1807 ) -> *mut CoreImporterStateO,
1808 >,
1809 pub destroy: ::std::option::Option<unsafe extern "C" fn(state: *mut CoreImporterStateO)>,
1810 pub register_assets: ::std::option::Option<
1811 unsafe extern "C" fn(
1812 state: *mut CoreImporterStateO,
1813 to_register: *const CoreImporterAssetT,
1814 num_to_register: u32,
1815 ),
1816 >,
1817}
1818#[repr(C)]
1819#[derive(Copy, Clone)]
1820pub struct CrashRecoveryCanRecoverResultT {
1821 pub data: *const ::std::os::raw::c_char,
1822 pub data_bytes: u64,
1823 pub project: *const ::std::os::raw::c_char,
1824 pub root: *const UuidT,
1825}
1826impl Default for CrashRecoveryCanRecoverResultT {
1827 fn default() -> Self {
1828 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
1829 unsafe {
1830 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
1831 s.assume_init()
1832 }
1833 }
1834}
1835#[repr(C)]
1836#[derive(Copy, Clone)]
1837pub struct CrashRecoveryO {
1838 _unused: [u8; 0],
1839}
1840#[repr(C)]
1841#[derive(Default, Copy, Clone)]
1842pub struct CrashRecoveryApi {
1843 pub create: ::std::option::Option<
1844 unsafe extern "C" fn(
1845 a: *mut AllocatorI,
1846 recovery_path: *const ::std::os::raw::c_char,
1847 ) -> *mut CrashRecoveryO,
1848 >,
1849 pub destroy: ::std::option::Option<unsafe extern "C" fn(cr: *mut CrashRecoveryO)>,
1850 pub start_recording: ::std::option::Option<
1851 unsafe extern "C" fn(
1852 cr: *mut CrashRecoveryO,
1853 project: *const ::std::os::raw::c_char,
1854 tt: *mut TheTruthO,
1855 root: TtIdT,
1856 ),
1857 >,
1858 pub stop_recording: ::std::option::Option<unsafe extern "C" fn(cr: *mut CrashRecoveryO)>,
1859 pub update: ::std::option::Option<unsafe extern "C" fn(cr: *mut CrashRecoveryO)>,
1860 pub can_recover: ::std::option::Option<
1861 unsafe extern "C" fn(
1862 cr: *mut CrashRecoveryO,
1863 ta: *mut TempAllocatorI,
1864 ) -> CrashRecoveryCanRecoverResultT,
1865 >,
1866 pub recover: ::std::option::Option<
1867 unsafe extern "C" fn(
1868 cr: *mut CrashRecoveryO,
1869 rd: CrashRecoveryCanRecoverResultT,
1870 tt: *mut TheTruthO,
1871 ),
1872 >,
1873 pub delete_physical_file: ::std::option::Option<unsafe extern "C" fn(cr: *mut CrashRecoveryO)>,
1874}
1875#[repr(C)]
1876#[derive(Copy, Clone)]
1877pub struct ErrorO {
1878 _unused: [u8; 0],
1879}
1880#[repr(C)]
1881#[derive(Copy, Clone)]
1882pub struct ErrorI {
1883 pub inst: *mut ErrorO,
1884 pub errorf: ::std::option::Option<
1885 unsafe extern "C" fn(
1886 inst: *mut ErrorO,
1887 file: *const ::std::os::raw::c_char,
1888 line: u32,
1889 format: *const ::std::os::raw::c_char,
1890 ...
1891 ),
1892 >,
1893 pub fatal: ::std::option::Option<
1894 unsafe extern "C" fn(
1895 inst: *mut ErrorO,
1896 file: *const ::std::os::raw::c_char,
1897 line: u32,
1898 format: *const ::std::os::raw::c_char,
1899 ...
1900 ),
1901 >,
1902}
1903impl Default for ErrorI {
1904 fn default() -> Self {
1905 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
1906 unsafe {
1907 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
1908 s.assume_init()
1909 }
1910 }
1911}
1912#[repr(C)]
1913#[derive(Copy, Clone)]
1914pub struct ErrorRecordT {
1915 pub ta: *mut TempAllocatorI,
1916 pub errors: *mut *mut ::std::os::raw::c_char,
1917 pub backing: *mut ErrorI,
1918}
1919impl Default for ErrorRecordT {
1920 fn default() -> Self {
1921 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
1922 unsafe {
1923 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
1924 s.assume_init()
1925 }
1926 }
1927}
1928#[repr(C)]
1929#[derive(Copy, Clone)]
1930pub struct ErrorApi {
1931 pub log: *mut ErrorI,
1932 pub def: *mut ErrorI,
1933 pub create_record_handler:
1934 ::std::option::Option<unsafe extern "C" fn(mem: *mut ErrorRecordT) -> ErrorI>,
1935}
1936impl Default for ErrorApi {
1937 fn default() -> Self {
1938 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
1939 unsafe {
1940 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
1941 s.assume_init()
1942 }
1943 }
1944}
1945#[repr(C)]
1946#[derive(Default, Copy, Clone)]
1947pub struct FeatureFlagsApi {
1948 pub enabled: ::std::option::Option<unsafe extern "C" fn(flag: StrhashT) -> bool>,
1949 pub set_enabled: ::std::option::Option<unsafe extern "C" fn(flag: StrhashT, enabled: bool)>,
1950 pub all_enabled:
1951 ::std::option::Option<unsafe extern "C" fn(count: *mut u32) -> *const StrhashT>,
1952}
1953#[repr(C)]
1954#[derive(Default, Copy, Clone)]
1955pub struct GitIgnoreApi {
1956 pub match_: ::std::option::Option<
1957 unsafe extern "C" fn(
1958 patterns: *const ::std::os::raw::c_char,
1959 path: *const ::std::os::raw::c_char,
1960 ) -> bool,
1961 >,
1962}
1963pub const TM_IMAGE_TYPE_1D: ImageType = 0;
1964pub const TM_IMAGE_TYPE_2D: ImageType = 1;
1965pub const TM_IMAGE_TYPE_3D: ImageType = 2;
1966pub const TM_IMAGE_TYPE_CUBE: ImageType = 3;
1967pub type ImageType = ::std::os::raw::c_int;
1968#[repr(C)]
1969#[derive(Default, Copy, Clone)]
1970pub struct ImageT {
1971 pub type_: u32,
1972 pub pixel_format: u32,
1973 pub width: u32,
1974 pub height: u32,
1975 pub depth: u32,
1976 pub mip_levels: u32,
1977 pub layers: u32,
1978 pub size: u32,
1979}
1980#[repr(C)]
1981#[derive(Copy, Clone)]
1982pub struct ImageArchiveO {
1983 _unused: [u8; 0],
1984}
1985#[repr(C)]
1986#[derive(Copy, Clone)]
1987pub struct ImageArchiveI {
1988 pub inst: *mut ImageArchiveO,
1989 pub read: ::std::option::Option<
1990 unsafe extern "C" fn(
1991 inst: *mut ImageArchiveO,
1992 buffer: *mut ::std::os::raw::c_void,
1993 offset: u64,
1994 size: u32,
1995 ) -> u32,
1996 >,
1997 pub size: ::std::option::Option<unsafe extern "C" fn(inst: *mut ImageArchiveO) -> u64>,
1998}
1999impl Default for ImageArchiveI {
2000 fn default() -> Self {
2001 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
2002 unsafe {
2003 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
2004 s.assume_init()
2005 }
2006 }
2007}
2008#[repr(C)]
2009#[derive(Copy, Clone)]
2010pub struct ImageLoaderO {
2011 _unused: [u8; 0],
2012}
2013#[repr(C)]
2014#[derive(Copy, Clone)]
2015pub struct ImageLoaderI {
2016 pub inst: *mut ImageLoaderO,
2017 pub extensions_string: ::std::option::Option<
2018 unsafe extern "C" fn(
2019 inst: *mut ImageLoaderO,
2020 output: *mut *mut ::std::os::raw::c_char,
2021 ta: *mut TempAllocatorI,
2022 separator: *const ::std::os::raw::c_char,
2023 ),
2024 >,
2025 pub description_string: ::std::option::Option<
2026 unsafe extern "C" fn(
2027 inst: *mut ImageLoaderO,
2028 output: *mut *mut ::std::os::raw::c_char,
2029 ta: *mut TempAllocatorI,
2030 separator: *const ::std::os::raw::c_char,
2031 ),
2032 >,
2033 pub support_from_archive: ::std::option::Option<
2034 unsafe extern "C" fn(inst: *mut ImageLoaderO, image_archive: *mut ImageArchiveI) -> bool,
2035 >,
2036 pub support_from_extension: ::std::option::Option<
2037 unsafe extern "C" fn(
2038 inst: *mut ImageLoaderO,
2039 extension: *const ::std::os::raw::c_char,
2040 ) -> bool,
2041 >,
2042 pub load_image: ::std::option::Option<
2043 unsafe extern "C" fn(
2044 inst: *mut ImageLoaderO,
2045 image_archive: *mut ImageArchiveI,
2046 image: *mut ImageT,
2047 bits: *mut u8,
2048 ) -> bool,
2049 >,
2050}
2051impl Default for ImageLoaderI {
2052 fn default() -> Self {
2053 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
2054 unsafe {
2055 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
2056 s.assume_init()
2057 }
2058 }
2059}
2060#[repr(C)]
2061#[derive(Default, Copy, Clone)]
2062pub struct ImageLoaderApi {
2063 pub add_loader: ::std::option::Option<unsafe extern "C" fn(loader: *mut ImageLoaderI)>,
2064 pub remove_loader: ::std::option::Option<unsafe extern "C" fn(loader: *mut ImageLoaderI)>,
2065 pub loader_from_archive: ::std::option::Option<
2066 unsafe extern "C" fn(image_archive: *mut ImageArchiveI) -> *mut ImageLoaderI,
2067 >,
2068 pub loader_from_extension: ::std::option::Option<
2069 unsafe extern "C" fn(extension: *const ::std::os::raw::c_char) -> *mut ImageLoaderI,
2070 >,
2071 pub loaders:
2072 ::std::option::Option<unsafe extern "C" fn(loaders: *mut *mut ImageLoaderI) -> u32>,
2073}
2074pub const TM_INPUT_CONTROLLER_TYPE_NONE: InputControllerType = 0;
2075pub const TM_INPUT_CONTROLLER_TYPE_KEYBOARD: InputControllerType = 1;
2076pub const TM_INPUT_CONTROLLER_TYPE_MOUSE: InputControllerType = 2;
2077pub const TM_INPUT_CONTROLLER_TYPE_GAMEPAD: InputControllerType = 3;
2078pub const TM_INPUT_CONTROLLER_TYPE_TOUCH: InputControllerType = 4;
2079pub const TM_INPUT_CONTROLLER_TYPE_PEN: InputControllerType = 5;
2080pub const TM_INPUT_CONTROLLER_TYPE_OTHER: InputControllerType = -1;
2081pub type InputControllerType = ::std::os::raw::c_int;
2082pub const TM_INPUT_MOUSE_ITEM_NONE: InputMouseItem = 0;
2083pub const TM_INPUT_MOUSE_ITEM_BUTTON_LEFT: InputMouseItem = 1;
2084pub const TM_INPUT_MOUSE_ITEM_BUTTON_RIGHT: InputMouseItem = 2;
2085pub const TM_INPUT_MOUSE_ITEM_BUTTON_MIDDLE: InputMouseItem = 3;
2086pub const TM_INPUT_MOUSE_ITEM_BUTTON_4: InputMouseItem = 4;
2087pub const TM_INPUT_MOUSE_ITEM_BUTTON_5: InputMouseItem = 5;
2088pub const TM_INPUT_MOUSE_ITEM_WHEEL: InputMouseItem = 6;
2089pub const TM_INPUT_MOUSE_ITEM_MOVE: InputMouseItem = 7;
2090pub const TM_INPUT_MOUSE_ITEM_POSITION: InputMouseItem = 8;
2091pub const TM_INPUT_MOUSE_ITEM_COUNT: InputMouseItem = 9;
2092pub type InputMouseItem = ::std::os::raw::c_int;
2093pub const TM_INPUT_PEN_ITEM_NONE: InputPenItem = 0;
2094pub const TM_INPUT_PEN_ITEM_BUTTON_1: InputPenItem = 1;
2095pub const TM_INPUT_PEN_ITEM_BUTTON_2: InputPenItem = 2;
2096pub const TM_INPUT_PEN_ITEM_BUTTON_3: InputPenItem = 3;
2097pub const TM_INPUT_PEN_ITEM_BUTTON_4: InputPenItem = 4;
2098pub const TM_INPUT_PEN_ITEM_BUTTON_5: InputPenItem = 5;
2099pub const TM_INPUT_PEN_ITEM_WHEEL: InputPenItem = 6;
2100pub const TM_INPUT_PEN_ITEM_POSITION: InputPenItem = 7;
2101pub const TM_INPUT_PEN_ITEM_PRESSURE: InputPenItem = 8;
2102pub const TM_INPUT_PEN_ITEM_ROTATION: InputPenItem = 9;
2103pub const TM_INPUT_PEN_ITEM_TILT: InputPenItem = 10;
2104pub const TM_INPUT_PEN_ITEM_INVERTED: InputPenItem = 11;
2105pub const TM_INPUT_PEN_ITEM_ERASER: InputPenItem = 12;
2106pub const TM_INPUT_PEN_ITEM_COUNT: InputPenItem = 13;
2107pub type InputPenItem = ::std::os::raw::c_int;
2108pub const TM_INPUT_TOUCH_ITEM_NONE: InputTouchItem = 0;
2109pub const TM_INPUT_TOUCH_ITEM_TOUCH: InputTouchItem = 1;
2110pub const TM_INPUT_TOUCH_ITEM_POSITION: InputTouchItem = 2;
2111pub const TM_INPUT_TOUCH_ITEM_PRESSURE: InputTouchItem = 3;
2112pub const TM_INPUT_TOUCH_ITEM_ORIENTATION: InputTouchItem = 4;
2113pub const TM_INPUT_TOUCH_ITEM_COUNT: InputTouchItem = 5;
2114pub type InputTouchItem = ::std::os::raw::c_int;
2115pub const TM_INPUT_KEYBOARD_ITEM_NONE: InputKeyboardItem = 0;
2116pub const TM_INPUT_KEYBOARD_ITEM_LBUTTON: InputKeyboardItem = 1;
2117pub const TM_INPUT_KEYBOARD_ITEM_RBUTTON: InputKeyboardItem = 2;
2118pub const TM_INPUT_KEYBOARD_ITEM_CANCEL: InputKeyboardItem = 3;
2119pub const TM_INPUT_KEYBOARD_ITEM_MBUTTON: InputKeyboardItem = 4;
2120pub const TM_INPUT_KEYBOARD_ITEM_XBUTTON1: InputKeyboardItem = 5;
2121pub const TM_INPUT_KEYBOARD_ITEM_XBUTTON2: InputKeyboardItem = 6;
2122pub const TM_INPUT_KEYBOARD_ITEM_BACKSPACE: InputKeyboardItem = 8;
2123pub const TM_INPUT_KEYBOARD_ITEM_TAB: InputKeyboardItem = 9;
2124pub const TM_INPUT_KEYBOARD_ITEM_CLEAR: InputKeyboardItem = 12;
2125pub const TM_INPUT_KEYBOARD_ITEM_ENTER: InputKeyboardItem = 13;
2126pub const TM_INPUT_KEYBOARD_ITEM_SHIFT: InputKeyboardItem = 16;
2127pub const TM_INPUT_KEYBOARD_ITEM_CONTROL: InputKeyboardItem = 17;
2128pub const TM_INPUT_KEYBOARD_ITEM_MENU: InputKeyboardItem = 18;
2129pub const TM_INPUT_KEYBOARD_ITEM_PAUSE: InputKeyboardItem = 19;
2130pub const TM_INPUT_KEYBOARD_ITEM_CAPSLOCK: InputKeyboardItem = 20;
2131pub const TM_INPUT_KEYBOARD_ITEM_KANA: InputKeyboardItem = 21;
2132pub const TM_INPUT_KEYBOARD_ITEM_JUNJA: InputKeyboardItem = 23;
2133pub const TM_INPUT_KEYBOARD_ITEM_FINAL: InputKeyboardItem = 24;
2134pub const TM_INPUT_KEYBOARD_ITEM_HANJA: InputKeyboardItem = 25;
2135pub const TM_INPUT_KEYBOARD_ITEM_ESCAPE: InputKeyboardItem = 27;
2136pub const TM_INPUT_KEYBOARD_ITEM_CONVERT: InputKeyboardItem = 28;
2137pub const TM_INPUT_KEYBOARD_ITEM_NONCONVERT: InputKeyboardItem = 29;
2138pub const TM_INPUT_KEYBOARD_ITEM_ACCEPT: InputKeyboardItem = 30;
2139pub const TM_INPUT_KEYBOARD_ITEM_MODECHANGE: InputKeyboardItem = 31;
2140pub const TM_INPUT_KEYBOARD_ITEM_SPACE: InputKeyboardItem = 32;
2141pub const TM_INPUT_KEYBOARD_ITEM_PAGEUP: InputKeyboardItem = 33;
2142pub const TM_INPUT_KEYBOARD_ITEM_PAGEDOWN: InputKeyboardItem = 34;
2143pub const TM_INPUT_KEYBOARD_ITEM_END: InputKeyboardItem = 35;
2144pub const TM_INPUT_KEYBOARD_ITEM_HOME: InputKeyboardItem = 36;
2145pub const TM_INPUT_KEYBOARD_ITEM_LEFT: InputKeyboardItem = 37;
2146pub const TM_INPUT_KEYBOARD_ITEM_UP: InputKeyboardItem = 38;
2147pub const TM_INPUT_KEYBOARD_ITEM_RIGHT: InputKeyboardItem = 39;
2148pub const TM_INPUT_KEYBOARD_ITEM_DOWN: InputKeyboardItem = 40;
2149pub const TM_INPUT_KEYBOARD_ITEM_SELECT: InputKeyboardItem = 41;
2150pub const TM_INPUT_KEYBOARD_ITEM_PRINT: InputKeyboardItem = 42;
2151pub const TM_INPUT_KEYBOARD_ITEM_EXECUTE: InputKeyboardItem = 43;
2152pub const TM_INPUT_KEYBOARD_ITEM_PRINTSCREEN: InputKeyboardItem = 44;
2153pub const TM_INPUT_KEYBOARD_ITEM_INSERT: InputKeyboardItem = 45;
2154pub const TM_INPUT_KEYBOARD_ITEM_DELETE: InputKeyboardItem = 46;
2155pub const TM_INPUT_KEYBOARD_ITEM_HELP: InputKeyboardItem = 47;
2156pub const TM_INPUT_KEYBOARD_ITEM_0: InputKeyboardItem = 48;
2157pub const TM_INPUT_KEYBOARD_ITEM_1: InputKeyboardItem = 49;
2158pub const TM_INPUT_KEYBOARD_ITEM_2: InputKeyboardItem = 50;
2159pub const TM_INPUT_KEYBOARD_ITEM_3: InputKeyboardItem = 51;
2160pub const TM_INPUT_KEYBOARD_ITEM_4: InputKeyboardItem = 52;
2161pub const TM_INPUT_KEYBOARD_ITEM_5: InputKeyboardItem = 53;
2162pub const TM_INPUT_KEYBOARD_ITEM_6: InputKeyboardItem = 54;
2163pub const TM_INPUT_KEYBOARD_ITEM_7: InputKeyboardItem = 55;
2164pub const TM_INPUT_KEYBOARD_ITEM_8: InputKeyboardItem = 56;
2165pub const TM_INPUT_KEYBOARD_ITEM_9: InputKeyboardItem = 57;
2166pub const TM_INPUT_KEYBOARD_ITEM_A: InputKeyboardItem = 65;
2167pub const TM_INPUT_KEYBOARD_ITEM_B: InputKeyboardItem = 66;
2168pub const TM_INPUT_KEYBOARD_ITEM_C: InputKeyboardItem = 67;
2169pub const TM_INPUT_KEYBOARD_ITEM_D: InputKeyboardItem = 68;
2170pub const TM_INPUT_KEYBOARD_ITEM_E: InputKeyboardItem = 69;
2171pub const TM_INPUT_KEYBOARD_ITEM_F: InputKeyboardItem = 70;
2172pub const TM_INPUT_KEYBOARD_ITEM_G: InputKeyboardItem = 71;
2173pub const TM_INPUT_KEYBOARD_ITEM_H: InputKeyboardItem = 72;
2174pub const TM_INPUT_KEYBOARD_ITEM_I: InputKeyboardItem = 73;
2175pub const TM_INPUT_KEYBOARD_ITEM_J: InputKeyboardItem = 74;
2176pub const TM_INPUT_KEYBOARD_ITEM_K: InputKeyboardItem = 75;
2177pub const TM_INPUT_KEYBOARD_ITEM_L: InputKeyboardItem = 76;
2178pub const TM_INPUT_KEYBOARD_ITEM_M: InputKeyboardItem = 77;
2179pub const TM_INPUT_KEYBOARD_ITEM_N: InputKeyboardItem = 78;
2180pub const TM_INPUT_KEYBOARD_ITEM_O: InputKeyboardItem = 79;
2181pub const TM_INPUT_KEYBOARD_ITEM_P: InputKeyboardItem = 80;
2182pub const TM_INPUT_KEYBOARD_ITEM_Q: InputKeyboardItem = 81;
2183pub const TM_INPUT_KEYBOARD_ITEM_R: InputKeyboardItem = 82;
2184pub const TM_INPUT_KEYBOARD_ITEM_S: InputKeyboardItem = 83;
2185pub const TM_INPUT_KEYBOARD_ITEM_T: InputKeyboardItem = 84;
2186pub const TM_INPUT_KEYBOARD_ITEM_U: InputKeyboardItem = 85;
2187pub const TM_INPUT_KEYBOARD_ITEM_V: InputKeyboardItem = 86;
2188pub const TM_INPUT_KEYBOARD_ITEM_W: InputKeyboardItem = 87;
2189pub const TM_INPUT_KEYBOARD_ITEM_X: InputKeyboardItem = 88;
2190pub const TM_INPUT_KEYBOARD_ITEM_Y: InputKeyboardItem = 89;
2191pub const TM_INPUT_KEYBOARD_ITEM_Z: InputKeyboardItem = 90;
2192pub const TM_INPUT_KEYBOARD_ITEM_LWIN: InputKeyboardItem = 91;
2193pub const TM_INPUT_KEYBOARD_ITEM_RWIN: InputKeyboardItem = 92;
2194pub const TM_INPUT_KEYBOARD_ITEM_APPS: InputKeyboardItem = 93;
2195pub const TM_INPUT_KEYBOARD_ITEM_SLEEP: InputKeyboardItem = 95;
2196pub const TM_INPUT_KEYBOARD_ITEM_NUMPAD0: InputKeyboardItem = 96;
2197pub const TM_INPUT_KEYBOARD_ITEM_NUMPAD1: InputKeyboardItem = 97;
2198pub const TM_INPUT_KEYBOARD_ITEM_NUMPAD2: InputKeyboardItem = 98;
2199pub const TM_INPUT_KEYBOARD_ITEM_NUMPAD3: InputKeyboardItem = 99;
2200pub const TM_INPUT_KEYBOARD_ITEM_NUMPAD4: InputKeyboardItem = 100;
2201pub const TM_INPUT_KEYBOARD_ITEM_NUMPAD5: InputKeyboardItem = 101;
2202pub const TM_INPUT_KEYBOARD_ITEM_NUMPAD6: InputKeyboardItem = 102;
2203pub const TM_INPUT_KEYBOARD_ITEM_NUMPAD7: InputKeyboardItem = 103;
2204pub const TM_INPUT_KEYBOARD_ITEM_NUMPAD8: InputKeyboardItem = 104;
2205pub const TM_INPUT_KEYBOARD_ITEM_NUMPAD9: InputKeyboardItem = 105;
2206pub const TM_INPUT_KEYBOARD_ITEM_NUMPADASTERISK: InputKeyboardItem = 106;
2207pub const TM_INPUT_KEYBOARD_ITEM_NUMPADPLUS: InputKeyboardItem = 107;
2208pub const TM_INPUT_KEYBOARD_ITEM_NUMPADENTER: InputKeyboardItem = 108;
2209pub const TM_INPUT_KEYBOARD_ITEM_NUMPADMINUS: InputKeyboardItem = 109;
2210pub const TM_INPUT_KEYBOARD_ITEM_NUMPADDOT: InputKeyboardItem = 110;
2211pub const TM_INPUT_KEYBOARD_ITEM_NUMPADSLASH: InputKeyboardItem = 111;
2212pub const TM_INPUT_KEYBOARD_ITEM_F1: InputKeyboardItem = 112;
2213pub const TM_INPUT_KEYBOARD_ITEM_F2: InputKeyboardItem = 113;
2214pub const TM_INPUT_KEYBOARD_ITEM_F3: InputKeyboardItem = 114;
2215pub const TM_INPUT_KEYBOARD_ITEM_F4: InputKeyboardItem = 115;
2216pub const TM_INPUT_KEYBOARD_ITEM_F5: InputKeyboardItem = 116;
2217pub const TM_INPUT_KEYBOARD_ITEM_F6: InputKeyboardItem = 117;
2218pub const TM_INPUT_KEYBOARD_ITEM_F7: InputKeyboardItem = 118;
2219pub const TM_INPUT_KEYBOARD_ITEM_F8: InputKeyboardItem = 119;
2220pub const TM_INPUT_KEYBOARD_ITEM_F9: InputKeyboardItem = 120;
2221pub const TM_INPUT_KEYBOARD_ITEM_F10: InputKeyboardItem = 121;
2222pub const TM_INPUT_KEYBOARD_ITEM_F11: InputKeyboardItem = 122;
2223pub const TM_INPUT_KEYBOARD_ITEM_F12: InputKeyboardItem = 123;
2224pub const TM_INPUT_KEYBOARD_ITEM_F13: InputKeyboardItem = 124;
2225pub const TM_INPUT_KEYBOARD_ITEM_F14: InputKeyboardItem = 125;
2226pub const TM_INPUT_KEYBOARD_ITEM_F15: InputKeyboardItem = 126;
2227pub const TM_INPUT_KEYBOARD_ITEM_F16: InputKeyboardItem = 127;
2228pub const TM_INPUT_KEYBOARD_ITEM_F17: InputKeyboardItem = 128;
2229pub const TM_INPUT_KEYBOARD_ITEM_F18: InputKeyboardItem = 129;
2230pub const TM_INPUT_KEYBOARD_ITEM_F19: InputKeyboardItem = 130;
2231pub const TM_INPUT_KEYBOARD_ITEM_F20: InputKeyboardItem = 131;
2232pub const TM_INPUT_KEYBOARD_ITEM_F21: InputKeyboardItem = 132;
2233pub const TM_INPUT_KEYBOARD_ITEM_F22: InputKeyboardItem = 133;
2234pub const TM_INPUT_KEYBOARD_ITEM_F23: InputKeyboardItem = 134;
2235pub const TM_INPUT_KEYBOARD_ITEM_F24: InputKeyboardItem = 135;
2236pub const TM_INPUT_KEYBOARD_ITEM_NAVIGATION_VIEW: InputKeyboardItem = 136;
2237pub const TM_INPUT_KEYBOARD_ITEM_NAVIGATION_MENU: InputKeyboardItem = 137;
2238pub const TM_INPUT_KEYBOARD_ITEM_NAVIGATION_UP: InputKeyboardItem = 138;
2239pub const TM_INPUT_KEYBOARD_ITEM_NAVIGATION_DOWN: InputKeyboardItem = 139;
2240pub const TM_INPUT_KEYBOARD_ITEM_NAVIGATION_LEFT: InputKeyboardItem = 140;
2241pub const TM_INPUT_KEYBOARD_ITEM_NAVIGATION_RIGHT: InputKeyboardItem = 141;
2242pub const TM_INPUT_KEYBOARD_ITEM_NAVIGATION_ACCEPT: InputKeyboardItem = 142;
2243pub const TM_INPUT_KEYBOARD_ITEM_NAVIGATION_CANCEL: InputKeyboardItem = 143;
2244pub const TM_INPUT_KEYBOARD_ITEM_NUMLOCK: InputKeyboardItem = 144;
2245pub const TM_INPUT_KEYBOARD_ITEM_SCROLLLOCK: InputKeyboardItem = 145;
2246pub const TM_INPUT_KEYBOARD_ITEM_NUMPADEQUAL: InputKeyboardItem = 146;
2247pub const TM_INPUT_KEYBOARD_ITEM_OEM_FJ_MASSHOU: InputKeyboardItem = 147;
2248pub const TM_INPUT_KEYBOARD_ITEM_OEM_FJ_TOUROKU: InputKeyboardItem = 148;
2249pub const TM_INPUT_KEYBOARD_ITEM_OEM_FJ_LOYA: InputKeyboardItem = 149;
2250pub const TM_INPUT_KEYBOARD_ITEM_OEM_FJ_ROYA: InputKeyboardItem = 150;
2251pub const TM_INPUT_KEYBOARD_ITEM_LEFTSHIFT: InputKeyboardItem = 160;
2252pub const TM_INPUT_KEYBOARD_ITEM_RIGHTSHIFT: InputKeyboardItem = 161;
2253pub const TM_INPUT_KEYBOARD_ITEM_LEFTCONTROL: InputKeyboardItem = 162;
2254pub const TM_INPUT_KEYBOARD_ITEM_RIGHTCONTROL: InputKeyboardItem = 163;
2255pub const TM_INPUT_KEYBOARD_ITEM_LEFTALT: InputKeyboardItem = 164;
2256pub const TM_INPUT_KEYBOARD_ITEM_RIGHTALT: InputKeyboardItem = 165;
2257pub const TM_INPUT_KEYBOARD_ITEM_BROWSER_BACK: InputKeyboardItem = 166;
2258pub const TM_INPUT_KEYBOARD_ITEM_BROWSER_FORWARD: InputKeyboardItem = 167;
2259pub const TM_INPUT_KEYBOARD_ITEM_BROWSER_REFRESH: InputKeyboardItem = 168;
2260pub const TM_INPUT_KEYBOARD_ITEM_BROWSER_STOP: InputKeyboardItem = 169;
2261pub const TM_INPUT_KEYBOARD_ITEM_BROWSER_SEARCH: InputKeyboardItem = 170;
2262pub const TM_INPUT_KEYBOARD_ITEM_BROWSER_FAVORITES: InputKeyboardItem = 171;
2263pub const TM_INPUT_KEYBOARD_ITEM_BROWSER_HOME: InputKeyboardItem = 172;
2264pub const TM_INPUT_KEYBOARD_ITEM_VOLUME_MUTE: InputKeyboardItem = 173;
2265pub const TM_INPUT_KEYBOARD_ITEM_VOLUME_DOWN: InputKeyboardItem = 174;
2266pub const TM_INPUT_KEYBOARD_ITEM_VOLUME_UP: InputKeyboardItem = 175;
2267pub const TM_INPUT_KEYBOARD_ITEM_MEDIA_NEXT_TRACK: InputKeyboardItem = 176;
2268pub const TM_INPUT_KEYBOARD_ITEM_MEDIA_PREV_TRACK: InputKeyboardItem = 177;
2269pub const TM_INPUT_KEYBOARD_ITEM_MEDIA_STOP: InputKeyboardItem = 178;
2270pub const TM_INPUT_KEYBOARD_ITEM_MEDIA_PLAY_PAUSE: InputKeyboardItem = 179;
2271pub const TM_INPUT_KEYBOARD_ITEM_LAUNCH_MAIL: InputKeyboardItem = 180;
2272pub const TM_INPUT_KEYBOARD_ITEM_LAUNCH_MEDIA_SELECT: InputKeyboardItem = 181;
2273pub const TM_INPUT_KEYBOARD_ITEM_LAUNCH_APP1: InputKeyboardItem = 182;
2274pub const TM_INPUT_KEYBOARD_ITEM_LAUNCH_APP2: InputKeyboardItem = 183;
2275pub const TM_INPUT_KEYBOARD_ITEM_SEMICOLON: InputKeyboardItem = 186;
2276pub const TM_INPUT_KEYBOARD_ITEM_EQUAL: InputKeyboardItem = 187;
2277pub const TM_INPUT_KEYBOARD_ITEM_COMMA: InputKeyboardItem = 188;
2278pub const TM_INPUT_KEYBOARD_ITEM_MINUS: InputKeyboardItem = 189;
2279pub const TM_INPUT_KEYBOARD_ITEM_DOT: InputKeyboardItem = 190;
2280pub const TM_INPUT_KEYBOARD_ITEM_SLASH: InputKeyboardItem = 191;
2281pub const TM_INPUT_KEYBOARD_ITEM_GRAVE: InputKeyboardItem = 192;
2282pub const TM_INPUT_KEYBOARD_ITEM_GAMEPAD_A: InputKeyboardItem = 195;
2283pub const TM_INPUT_KEYBOARD_ITEM_GAMEPAD_B: InputKeyboardItem = 196;
2284pub const TM_INPUT_KEYBOARD_ITEM_GAMEPAD_X: InputKeyboardItem = 197;
2285pub const TM_INPUT_KEYBOARD_ITEM_GAMEPAD_Y: InputKeyboardItem = 198;
2286pub const TM_INPUT_KEYBOARD_ITEM_GAMEPAD_RIGHT_SHOULDER: InputKeyboardItem = 199;
2287pub const TM_INPUT_KEYBOARD_ITEM_GAMEPAD_LEFT_SHOULDER: InputKeyboardItem = 200;
2288pub const TM_INPUT_KEYBOARD_ITEM_GAMEPAD_LEFT_TRIGGER: InputKeyboardItem = 201;
2289pub const TM_INPUT_KEYBOARD_ITEM_GAMEPAD_RIGHT_TRIGGER: InputKeyboardItem = 202;
2290pub const TM_INPUT_KEYBOARD_ITEM_GAMEPAD_DPAD_UP: InputKeyboardItem = 203;
2291pub const TM_INPUT_KEYBOARD_ITEM_GAMEPAD_DPAD_DOWN: InputKeyboardItem = 204;
2292pub const TM_INPUT_KEYBOARD_ITEM_GAMEPAD_DPAD_LEFT: InputKeyboardItem = 205;
2293pub const TM_INPUT_KEYBOARD_ITEM_GAMEPAD_DPAD_RIGHT: InputKeyboardItem = 206;
2294pub const TM_INPUT_KEYBOARD_ITEM_GAMEPAD_MENU: InputKeyboardItem = 207;
2295pub const TM_INPUT_KEYBOARD_ITEM_GAMEPAD_VIEW: InputKeyboardItem = 208;
2296pub const TM_INPUT_KEYBOARD_ITEM_GAMEPAD_LEFT_THUMBSTICK_BUTTON: InputKeyboardItem = 209;
2297pub const TM_INPUT_KEYBOARD_ITEM_GAMEPAD_RIGHT_THUMBSTICK_BUTTON: InputKeyboardItem = 210;
2298pub const TM_INPUT_KEYBOARD_ITEM_GAMEPAD_LEFT_THUMBSTICK_UP: InputKeyboardItem = 211;
2299pub const TM_INPUT_KEYBOARD_ITEM_GAMEPAD_LEFT_THUMBSTICK_DOWN: InputKeyboardItem = 212;
2300pub const TM_INPUT_KEYBOARD_ITEM_GAMEPAD_LEFT_THUMBSTICK_RIGHT: InputKeyboardItem = 213;
2301pub const TM_INPUT_KEYBOARD_ITEM_GAMEPAD_LEFT_THUMBSTICK_LEFT: InputKeyboardItem = 214;
2302pub const TM_INPUT_KEYBOARD_ITEM_GAMEPAD_RIGHT_THUMBSTICK_UP: InputKeyboardItem = 215;
2303pub const TM_INPUT_KEYBOARD_ITEM_GAMEPAD_RIGHT_THUMBSTICK_DOWN: InputKeyboardItem = 216;
2304pub const TM_INPUT_KEYBOARD_ITEM_GAMEPAD_RIGHT_THUMBSTICK_RIGHT: InputKeyboardItem = 217;
2305pub const TM_INPUT_KEYBOARD_ITEM_GAMEPAD_RIGHT_THUMBSTICK_LEFT: InputKeyboardItem = 218;
2306pub const TM_INPUT_KEYBOARD_ITEM_LEFTBRACE: InputKeyboardItem = 219;
2307pub const TM_INPUT_KEYBOARD_ITEM_BACKSLASH: InputKeyboardItem = 220;
2308pub const TM_INPUT_KEYBOARD_ITEM_RIGHTBRACE: InputKeyboardItem = 221;
2309pub const TM_INPUT_KEYBOARD_ITEM_APOSTROPHE: InputKeyboardItem = 222;
2310pub const TM_INPUT_KEYBOARD_ITEM_OEM_8: InputKeyboardItem = 223;
2311pub const TM_INPUT_KEYBOARD_ITEM_OEM_AX: InputKeyboardItem = 225;
2312pub const TM_INPUT_KEYBOARD_ITEM_OEM_102: InputKeyboardItem = 226;
2313pub const TM_INPUT_KEYBOARD_ITEM_ICO_HELP: InputKeyboardItem = 227;
2314pub const TM_INPUT_KEYBOARD_ITEM_ICO_00: InputKeyboardItem = 228;
2315pub const TM_INPUT_KEYBOARD_ITEM_PROCESSKEY: InputKeyboardItem = 229;
2316pub const TM_INPUT_KEYBOARD_ITEM_ICO_CLEAR: InputKeyboardItem = 230;
2317pub const TM_INPUT_KEYBOARD_ITEM_PACKET: InputKeyboardItem = 231;
2318pub const TM_INPUT_KEYBOARD_ITEM_OEM_RESET: InputKeyboardItem = 233;
2319pub const TM_INPUT_KEYBOARD_ITEM_OEM_JUMP: InputKeyboardItem = 234;
2320pub const TM_INPUT_KEYBOARD_ITEM_OEM_PA1: InputKeyboardItem = 235;
2321pub const TM_INPUT_KEYBOARD_ITEM_OEM_PA2: InputKeyboardItem = 236;
2322pub const TM_INPUT_KEYBOARD_ITEM_OEM_PA3: InputKeyboardItem = 237;
2323pub const TM_INPUT_KEYBOARD_ITEM_OEM_WSCTRL: InputKeyboardItem = 238;
2324pub const TM_INPUT_KEYBOARD_ITEM_OEM_CUSEL: InputKeyboardItem = 239;
2325pub const TM_INPUT_KEYBOARD_ITEM_OEM_ATTN: InputKeyboardItem = 240;
2326pub const TM_INPUT_KEYBOARD_ITEM_OEM_FINISH: InputKeyboardItem = 241;
2327pub const TM_INPUT_KEYBOARD_ITEM_COPY: InputKeyboardItem = 242;
2328pub const TM_INPUT_KEYBOARD_ITEM_OEM_AUTO: InputKeyboardItem = 243;
2329pub const TM_INPUT_KEYBOARD_ITEM_OEM_ENLW: InputKeyboardItem = 244;
2330pub const TM_INPUT_KEYBOARD_ITEM_OEM_BACKTAB: InputKeyboardItem = 245;
2331pub const TM_INPUT_KEYBOARD_ITEM_ATTN: InputKeyboardItem = 246;
2332pub const TM_INPUT_KEYBOARD_ITEM_CRSEL: InputKeyboardItem = 247;
2333pub const TM_INPUT_KEYBOARD_ITEM_EXSEL: InputKeyboardItem = 248;
2334pub const TM_INPUT_KEYBOARD_ITEM_EREOF: InputKeyboardItem = 249;
2335pub const TM_INPUT_KEYBOARD_ITEM_PLAY: InputKeyboardItem = 250;
2336pub const TM_INPUT_KEYBOARD_ITEM_ZOOM: InputKeyboardItem = 251;
2337pub const TM_INPUT_KEYBOARD_ITEM_NONAME: InputKeyboardItem = 252;
2338pub const TM_INPUT_KEYBOARD_ITEM_PA1: InputKeyboardItem = 253;
2339pub const TM_INPUT_KEYBOARD_ITEM_OEM_CLEAR: InputKeyboardItem = 254;
2340pub const TM_INPUT_KEYBOARD_ITEM_KANJI: InputKeyboardItem = 25;
2341pub const TM_INPUT_KEYBOARD_ITEM_OEM_FJ_JISHO: InputKeyboardItem = 146;
2342pub const TM_INPUT_KEYBOARD_ITEM_HASHTILDE: InputKeyboardItem = 255;
2343pub const TM_INPUT_KEYBOARD_ITEM_102ND: InputKeyboardItem = 256;
2344pub const TM_INPUT_KEYBOARD_ITEM_COMPOSE: InputKeyboardItem = 257;
2345pub const TM_INPUT_KEYBOARD_ITEM_POWER: InputKeyboardItem = 258;
2346pub const TM_INPUT_KEYBOARD_ITEM_OPEN: InputKeyboardItem = 259;
2347pub const TM_INPUT_KEYBOARD_ITEM_PROPS: InputKeyboardItem = 260;
2348pub const TM_INPUT_KEYBOARD_ITEM_FRONT: InputKeyboardItem = 261;
2349pub const TM_INPUT_KEYBOARD_ITEM_STOP: InputKeyboardItem = 262;
2350pub const TM_INPUT_KEYBOARD_ITEM_AGAIN: InputKeyboardItem = 263;
2351pub const TM_INPUT_KEYBOARD_ITEM_UNDO: InputKeyboardItem = 264;
2352pub const TM_INPUT_KEYBOARD_ITEM_CUT: InputKeyboardItem = 265;
2353pub const TM_INPUT_KEYBOARD_ITEM_PASTE: InputKeyboardItem = 266;
2354pub const TM_INPUT_KEYBOARD_ITEM_FIND: InputKeyboardItem = 267;
2355pub const TM_INPUT_KEYBOARD_ITEM_NUMPADCOMMA: InputKeyboardItem = 268;
2356pub const TM_INPUT_KEYBOARD_ITEM_RO: InputKeyboardItem = 269;
2357pub const TM_INPUT_KEYBOARD_ITEM_KATAKANAHIRAGANA: InputKeyboardItem = 270;
2358pub const TM_INPUT_KEYBOARD_ITEM_YEN: InputKeyboardItem = 271;
2359pub const TM_INPUT_KEYBOARD_ITEM_HENKAN: InputKeyboardItem = 272;
2360pub const TM_INPUT_KEYBOARD_ITEM_MUHENKAN: InputKeyboardItem = 273;
2361pub const TM_INPUT_KEYBOARD_ITEM_NUMPADJPCOMMA: InputKeyboardItem = 274;
2362pub const TM_INPUT_KEYBOARD_ITEM_INTERNATIONAL_7: InputKeyboardItem = 275;
2363pub const TM_INPUT_KEYBOARD_ITEM_INTERNATIONAL_8: InputKeyboardItem = 276;
2364pub const TM_INPUT_KEYBOARD_ITEM_INTERNATIONAL_9: InputKeyboardItem = 277;
2365pub const TM_INPUT_KEYBOARD_ITEM_HANGEUL: InputKeyboardItem = 278;
2366pub const TM_INPUT_KEYBOARD_ITEM_KATAKANA: InputKeyboardItem = 279;
2367pub const TM_INPUT_KEYBOARD_ITEM_HIRAGANA: InputKeyboardItem = 280;
2368pub const TM_INPUT_KEYBOARD_ITEM_ZENKAKUHANKAKU: InputKeyboardItem = 281;
2369pub const TM_INPUT_KEYBOARD_ITEM_LANG_6: InputKeyboardItem = 282;
2370pub const TM_INPUT_KEYBOARD_ITEM_LANG_7: InputKeyboardItem = 283;
2371pub const TM_INPUT_KEYBOARD_ITEM_LANG_8: InputKeyboardItem = 284;
2372pub const TM_INPUT_KEYBOARD_ITEM_LANG_9: InputKeyboardItem = 285;
2373pub const TM_INPUT_KEYBOARD_ITEM_NUMPADLEFTPAREN: InputKeyboardItem = 286;
2374pub const TM_INPUT_KEYBOARD_ITEM_NUMPADRIGHTPAREN: InputKeyboardItem = 287;
2375pub const TM_INPUT_KEYBOARD_ITEM_LEFTMETA: InputKeyboardItem = 288;
2376pub const TM_INPUT_KEYBOARD_ITEM_RIGHTMETA: InputKeyboardItem = 289;
2377pub const TM_INPUT_KEYBOARD_ITEM_MEDIA_EJECT: InputKeyboardItem = 290;
2378pub const TM_INPUT_KEYBOARD_ITEM_MEDIA_VOLUME_UP: InputKeyboardItem = 291;
2379pub const TM_INPUT_KEYBOARD_ITEM_MEDIA_VOLUME_DOWN: InputKeyboardItem = 292;
2380pub const TM_INPUT_KEYBOARD_ITEM_MEDIA_MUTE: InputKeyboardItem = 293;
2381pub const TM_INPUT_KEYBOARD_ITEM_BROWSER_WWW: InputKeyboardItem = 294;
2382pub const TM_INPUT_KEYBOARD_ITEM_BROWSER_SCROLLUP: InputKeyboardItem = 295;
2383pub const TM_INPUT_KEYBOARD_ITEM_BROWSER_SCROLLDOWN: InputKeyboardItem = 296;
2384pub const TM_INPUT_KEYBOARD_ITEM_BROWSER_EDIT: InputKeyboardItem = 297;
2385pub const TM_INPUT_KEYBOARD_ITEM_BROWSER_SLEEP: InputKeyboardItem = 298;
2386pub const TM_INPUT_KEYBOARD_ITEM_BROWSER_COFFEE: InputKeyboardItem = 299;
2387pub const TM_INPUT_KEYBOARD_ITEM_BROWSER_CALC: InputKeyboardItem = 300;
2388pub const TM_INPUT_KEYBOARD_ITEM_COUNT: InputKeyboardItem = 301;
2389pub type InputKeyboardItem = ::std::os::raw::c_int;
2390pub const TM_INPUT_GAMEPAD_ITEM_NONE: InputGamepadItem = 0;
2391pub const TM_INPUT_GAMEPAD_ITEM_BUTTON_A: InputGamepadItem = 1;
2392pub const TM_INPUT_GAMEPAD_ITEM_BUTTON_B: InputGamepadItem = 2;
2393pub const TM_INPUT_GAMEPAD_ITEM_BUTTON_X: InputGamepadItem = 3;
2394pub const TM_INPUT_GAMEPAD_ITEM_BUTTON_Y: InputGamepadItem = 4;
2395pub const TM_INPUT_GAMEPAD_ITEM_BUTTON_LEFT_SHOULDER: InputGamepadItem = 5;
2396pub const TM_INPUT_GAMEPAD_ITEM_BUTTON_RIGHT_SHOULDER: InputGamepadItem = 6;
2397pub const TM_INPUT_GAMEPAD_ITEM_BUTTON_BACK: InputGamepadItem = 7;
2398pub const TM_INPUT_GAMEPAD_ITEM_BUTTON_START: InputGamepadItem = 8;
2399pub const TM_INPUT_GAMEPAD_ITEM_DPAD_LEFT: InputGamepadItem = 9;
2400pub const TM_INPUT_GAMEPAD_ITEM_DPAD_RIGHT: InputGamepadItem = 10;
2401pub const TM_INPUT_GAMEPAD_ITEM_DPAD_UP: InputGamepadItem = 11;
2402pub const TM_INPUT_GAMEPAD_ITEM_DPAD_DOWN: InputGamepadItem = 12;
2403pub const TM_INPUT_GAMEPAD_BUTTON_LEFT_THUMB: InputGamepadItem = 13;
2404pub const TM_INPUT_GAMEPAD_BUTTON_RIGHT_THUMB: InputGamepadItem = 14;
2405pub const TM_INPUT_GAMEPAD_ITEM_BUTTON_LEFT_TRIGGER: InputGamepadItem = 15;
2406pub const TM_INPUT_GAMEPAD_ITEM_BUTTON_RIGHT_TRIGGER: InputGamepadItem = 16;
2407pub const TM_INPUT_GAMEPAD_ITEM_LEFT_STICK: InputGamepadItem = 17;
2408pub const TM_INPUT_GAMEPAD_ITEM_RIGHT_STICK: InputGamepadItem = 18;
2409pub const TM_INPUT_GAMEPAD_ITEM_COUNT: InputGamepadItem = 19;
2410pub type InputGamepadItem = ::std::os::raw::c_int;
2411pub const TM_INPUT_EVENT_TYPE_NONE: InputEventType = 0;
2412pub const TM_INPUT_EVENT_TYPE_DATA_CHANGE: InputEventType = 1;
2413pub const TM_INPUT_EVENT_TYPE_TEXT: InputEventType = 2;
2414pub type InputEventType = ::std::os::raw::c_int;
2415#[repr(C)]
2416#[derive(Copy, Clone)]
2417pub struct InputItemT {
2418 pub id: u64,
2419 pub name: *const ::std::os::raw::c_char,
2420 pub components: u32,
2421 pub _padding_421: [::std::os::raw::c_char; 4usize],
2422}
2423impl Default for InputItemT {
2424 fn default() -> Self {
2425 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
2426 unsafe {
2427 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
2428 s.assume_init()
2429 }
2430 }
2431}
2432#[repr(C)]
2433#[derive(Copy, Clone)]
2434pub struct InputDataT {
2435 pub __bindgen_anon_1: InputDataTBindgenTy1,
2436}
2437#[repr(C)]
2438#[derive(Copy, Clone)]
2439pub union InputDataTBindgenTy1 {
2440 pub f: Vec4T,
2441 pub codepoint: u32,
2442}
2443impl Default for InputDataTBindgenTy1 {
2444 fn default() -> Self {
2445 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
2446 unsafe {
2447 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
2448 s.assume_init()
2449 }
2450 }
2451}
2452impl Default for InputDataT {
2453 fn default() -> Self {
2454 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
2455 unsafe {
2456 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
2457 s.assume_init()
2458 }
2459 }
2460}
2461#[repr(C)]
2462#[derive(Copy, Clone)]
2463pub struct InputEventT {
2464 pub time: u64,
2465 pub source: *mut InputSourceI,
2466 pub controller_id: u64,
2467 pub item_id: u64,
2468 pub type_: u64,
2469 pub data: InputDataT,
2470 pub extra: *mut ::std::os::raw::c_void,
2471}
2472impl Default for InputEventT {
2473 fn default() -> Self {
2474 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
2475 unsafe {
2476 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
2477 s.assume_init()
2478 }
2479 }
2480}
2481#[repr(C)]
2482#[derive(Copy, Clone)]
2483pub struct InputSourceI {
2484 pub controller_name: *const ::std::os::raw::c_char,
2485 pub controller_type: u32,
2486 pub _padding_479: [::std::os::raw::c_char; 4usize],
2487 pub controllers: ::std::option::Option<unsafe extern "C" fn(ids: *mut *mut u64) -> u32>,
2488 pub items: ::std::option::Option<unsafe extern "C" fn(items: *mut *mut InputItemT) -> u32>,
2489 pub events: ::std::option::Option<
2490 unsafe extern "C" fn(start: u64, events: *mut InputEventT, buffer_size: u64) -> u64,
2491 >,
2492 pub state:
2493 ::std::option::Option<unsafe extern "C" fn(controller: u64, item: u64) -> InputDataT>,
2494}
2495impl Default for InputSourceI {
2496 fn default() -> Self {
2497 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
2498 unsafe {
2499 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
2500 s.assume_init()
2501 }
2502 }
2503}
2504#[repr(C)]
2505#[derive(Default, Copy, Clone)]
2506pub struct InputApi {
2507 pub add_source: ::std::option::Option<unsafe extern "C" fn(source: *mut InputSourceI)>,
2508 pub remove_source: ::std::option::Option<unsafe extern "C" fn(source: *mut InputSourceI)>,
2509 pub sources:
2510 ::std::option::Option<unsafe extern "C" fn(sources: *mut *mut *mut InputSourceI) -> u32>,
2511 pub events: ::std::option::Option<
2512 unsafe extern "C" fn(start: u64, events: *mut InputEventT, buffer_size: u64) -> u64,
2513 >,
2514 pub keyboard_item_names:
2515 ::std::option::Option<unsafe extern "C" fn() -> *mut *const ::std::os::raw::c_char>,
2516}
2517#[repr(C)]
2518#[derive(Copy, Clone)]
2519pub struct IntegrationTestConfigT {
2520 pub config: *mut ConfigI,
2521 pub object: ConfigItemT,
2522 pub _padding_33: [::std::os::raw::c_char; 4usize],
2523}
2524impl Default for IntegrationTestConfigT {
2525 fn default() -> Self {
2526 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
2527 unsafe {
2528 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
2529 s.assume_init()
2530 }
2531 }
2532}
2533#[repr(C)]
2534#[derive(Copy, Clone)]
2535pub struct IntegrationTestRunnerO {
2536 _unused: [u8; 0],
2537}
2538#[repr(C)]
2539#[derive(Copy, Clone)]
2540pub struct IntegrationTestRunnerI {
2541 pub inst: *mut IntegrationTestRunnerO,
2542 pub context: StrhashT,
2543 pub config: IntegrationTestConfigT,
2544 pub app: *mut ApplicationO,
2545 pub wait: ::std::option::Option<
2546 unsafe extern "C" fn(inst: *mut IntegrationTestRunnerO, sec: f32, id: u64) -> bool,
2547 >,
2548 pub record: ::std::option::Option<
2549 unsafe extern "C" fn(
2550 inst: *mut IntegrationTestRunnerO,
2551 pass: bool,
2552 test_str: *const ::std::os::raw::c_char,
2553 file: *const ::std::os::raw::c_char,
2554 line: u32,
2555 ) -> bool,
2556 >,
2557 pub expect_error: ::std::option::Option<
2558 unsafe extern "C" fn(
2559 inst: *mut IntegrationTestRunnerO,
2560 err: *const ::std::os::raw::c_char,
2561 file: *const ::std::os::raw::c_char,
2562 line: u32,
2563 ),
2564 >,
2565 pub has_errors: ::std::option::Option<unsafe extern "C" fn() -> bool>,
2566 pub num_errors: ::std::option::Option<unsafe extern "C" fn() -> u32>,
2567}
2568impl Default for IntegrationTestRunnerI {
2569 fn default() -> Self {
2570 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
2571 unsafe {
2572 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
2573 s.assume_init()
2574 }
2575 }
2576}
2577#[repr(C)]
2578#[derive(Copy, Clone)]
2579pub struct IntegrationTestI {
2580 pub name: *const ::std::os::raw::c_char,
2581 pub path_config_json_file: *const ::std::os::raw::c_char,
2582 pub config_key: StrhashT,
2583 pub context: StrhashT,
2584 pub tick: ::std::option::Option<unsafe extern "C" fn(arg1: *mut IntegrationTestRunnerI)>,
2585}
2586impl Default for IntegrationTestI {
2587 fn default() -> Self {
2588 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
2589 unsafe {
2590 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
2591 s.assume_init()
2592 }
2593 }
2594}
2595#[repr(C)]
2596#[derive(Copy, Clone)]
2597pub struct AtomicCounterO {
2598 _unused: [u8; 0],
2599}
2600#[repr(C)]
2601#[derive(Copy, Clone)]
2602pub struct JobdeclT {
2603 pub task: ::std::option::Option<unsafe extern "C" fn(data: *mut ::std::os::raw::c_void)>,
2604 pub data: *mut ::std::os::raw::c_void,
2605 pub pin_thread_handle: u32,
2606 pub _padding_45: [::std::os::raw::c_char; 4usize],
2607}
2608impl Default for JobdeclT {
2609 fn default() -> Self {
2610 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
2611 unsafe {
2612 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
2613 s.assume_init()
2614 }
2615 }
2616}
2617#[repr(C)]
2618#[derive(Default, Copy, Clone)]
2619pub struct JobSystemApi {
2620 pub run_jobs: ::std::option::Option<
2621 unsafe extern "C" fn(jobs: *mut JobdeclT, num_jobs: u32) -> *mut AtomicCounterO,
2622 >,
2623 pub run_jobs_and_auto_free_counter:
2624 ::std::option::Option<unsafe extern "C" fn(jobs: *mut JobdeclT, num_jobs: u32)>,
2625 pub wait_for_counter:
2626 ::std::option::Option<unsafe extern "C" fn(counter: *mut AtomicCounterO, value: u32)>,
2627 pub wait_for_counter_and_free:
2628 ::std::option::Option<unsafe extern "C" fn(counter: *mut AtomicCounterO)>,
2629 pub wait_for_counter_and_free_no_fiber:
2630 ::std::option::Option<unsafe extern "C" fn(counter: *mut AtomicCounterO)>,
2631 pub pin_thread_handle:
2632 ::std::option::Option<unsafe extern "C" fn(worker_thread_index: u32) -> u32>,
2633 pub num_worker_threads: ::std::option::Option<unsafe extern "C" fn() -> u32>,
2634}
2635pub const TM_JSON_PARSE_EXT_ALLOW_UNQUOTED_KEYS: JsonParseExt = 1;
2636pub const TM_JSON_PARSE_EXT_ALLOW_COMMENTS: JsonParseExt = 2;
2637pub const TM_JSON_PARSE_EXT_IMPLICIT_ROOT_OBJECT: JsonParseExt = 4;
2638pub const TM_JSON_PARSE_EXT_OPTIONAL_COMMAS: JsonParseExt = 8;
2639pub const TM_JSON_PARSE_EXT_EQUALS_FOR_COLON: JsonParseExt = 16;
2640pub const TM_JSON_PARSE_EXT_LUA_QUOTING: JsonParseExt = 32;
2641pub type JsonParseExt = ::std::os::raw::c_int;
2642pub const TM_JSON_GENERATE_EXT_PREFER_UNQUOTED_KEYS: JsonGenerateExt = 1;
2643pub const TM_JSON_GENERATE_EXT_IMPLICIT_ROOT_OBJECT: JsonGenerateExt = 4;
2644pub const TM_JSON_GENERATE_EXT_NO_COMMAS: JsonGenerateExt = 8;
2645pub const TM_JSON_GENERATE_EXT_USE_EQUALS_INSTEAD_OF_COLON: JsonGenerateExt = 16;
2646pub const TM_JSON_GENERATE_EXT_USE_LUA_QUOTING: JsonGenerateExt = 32;
2647pub const TM_JSON_GENERATE_INLINE_SMALL_ARRAYS: JsonGenerateExt = 64;
2648pub const TM_JSON_GENERATE_INLINE_SMALL_OBJECTS: JsonGenerateExt = 128;
2649pub const TM_JSON_GENERATE_INDENT_WITH_TABS: JsonGenerateExt = 256;
2650pub type JsonGenerateExt = ::std::os::raw::c_int;
2651#[repr(C)]
2652#[derive(Default, Copy, Clone)]
2653pub struct JsonLineInfoT {
2654 pub config_item: u32,
2655 pub line_number: u32,
2656}
2657#[repr(C)]
2658#[derive(Copy, Clone)]
2659pub struct JsonParseInfoT {
2660 pub success: bool,
2661 pub error: [::std::os::raw::c_char; 80usize],
2662 pub _padding_128: [::std::os::raw::c_char; 3usize],
2663 pub num_line_info: u32,
2664 pub allocated_line_info: u32,
2665 pub line_info: [JsonLineInfoT; 1usize],
2666}
2667impl Default for JsonParseInfoT {
2668 fn default() -> Self {
2669 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
2670 unsafe {
2671 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
2672 s.assume_init()
2673 }
2674 }
2675}
2676#[repr(C)]
2677#[derive(Copy, Clone)]
2678pub struct JsonGenerateT {
2679 pub s: *mut ::std::os::raw::c_char,
2680 pub len: u32,
2681 pub allocated: u32,
2682}
2683impl Default for JsonGenerateT {
2684 fn default() -> Self {
2685 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
2686 unsafe {
2687 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
2688 s.assume_init()
2689 }
2690 }
2691}
2692#[repr(C)]
2693#[derive(Default, Copy, Clone)]
2694pub struct JsonApi {
2695 pub parse: ::std::option::Option<
2696 unsafe extern "C" fn(
2697 s: *const ::std::os::raw::c_char,
2698 config: *mut ConfigI,
2699 extensions: JsonParseExt,
2700 error: *mut ::std::os::raw::c_char,
2701 ) -> bool,
2702 >,
2703 pub parse_with_line_info: ::std::option::Option<
2704 unsafe extern "C" fn(
2705 s: *const ::std::os::raw::c_char,
2706 config: *mut ConfigI,
2707 extensions: JsonParseExt,
2708 ta: *mut TempAllocatorI,
2709 ) -> *mut JsonParseInfoT,
2710 >,
2711 pub line_number: ::std::option::Option<
2712 unsafe extern "C" fn(pi: *const JsonParseInfoT, item: *const ConfigItemT) -> u32,
2713 >,
2714 pub generate: ::std::option::Option<
2715 unsafe extern "C" fn(
2716 config: *mut ConfigI,
2717 flags: JsonGenerateExt,
2718 ta: *mut TempAllocatorI,
2719 ) -> JsonGenerateT,
2720 >,
2721}
2722#[repr(C)]
2723#[derive(Copy, Clone)]
2724pub struct LocalizerStringsT {
2725 pub num_strings: u32,
2726 pub stride_bytes: u32,
2727 pub strings: *const *const ::std::os::raw::c_char,
2728}
2729impl Default for LocalizerStringsT {
2730 fn default() -> Self {
2731 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
2732 unsafe {
2733 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
2734 s.assume_init()
2735 }
2736 }
2737}
2738pub type LocalizerStringsI =
2739 ::std::option::Option<unsafe extern "C" fn(language: StrhashT) -> LocalizerStringsT>;
2740#[repr(C)]
2741#[derive(Copy, Clone)]
2742pub struct LocalizerO {
2743 _unused: [u8; 0],
2744}
2745#[repr(C)]
2746#[derive(Copy, Clone)]
2747pub struct LocalizerI {
2748 pub inst: *mut LocalizerO,
2749 pub localize: ::std::option::Option<
2750 unsafe extern "C" fn(
2751 inst: *mut LocalizerO,
2752 s: *const ::std::os::raw::c_char,
2753 context: *const ::std::os::raw::c_char,
2754 ) -> *const ::std::os::raw::c_char,
2755 >,
2756}
2757impl Default for LocalizerI {
2758 fn default() -> Self {
2759 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
2760 unsafe {
2761 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
2762 s.assume_init()
2763 }
2764 }
2765}
2766#[repr(C)]
2767#[derive(Copy, Clone)]
2768pub struct LocalizerApi {
2769 pub def: *mut *mut LocalizerI,
2770 pub passthrough: *mut LocalizerI,
2771}
2772impl Default for LocalizerApi {
2773 fn default() -> Self {
2774 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
2775 unsafe {
2776 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
2777 s.assume_init()
2778 }
2779 }
2780}
2781pub const TM_LOG_TYPE_INFO: LogType = 0;
2782pub const TM_LOG_TYPE_DEBUG: LogType = 1;
2783pub const TM_LOG_TYPE_ERROR: LogType = 2;
2784pub type LogType = ::std::os::raw::c_int;
2785#[repr(C)]
2786#[derive(Copy, Clone)]
2787pub struct LoggerO {
2788 _unused: [u8; 0],
2789}
2790#[repr(C)]
2791#[derive(Copy, Clone)]
2792pub struct LoggerI {
2793 pub inst: *mut LoggerO,
2794 pub log: ::std::option::Option<
2795 unsafe extern "C" fn(
2796 inst: *mut LoggerO,
2797 log_type: LogType,
2798 msg: *const ::std::os::raw::c_char,
2799 ),
2800 >,
2801}
2802impl Default for LoggerI {
2803 fn default() -> Self {
2804 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
2805 unsafe {
2806 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
2807 s.assume_init()
2808 }
2809 }
2810}
2811#[repr(C)]
2812#[derive(Copy, Clone)]
2813pub struct LoggerApi {
2814 pub add_logger: ::std::option::Option<unsafe extern "C" fn(logger: *const LoggerI)>,
2815 pub remove_logger: ::std::option::Option<unsafe extern "C" fn(logger: *const LoggerI)>,
2816 pub print: ::std::option::Option<
2817 unsafe extern "C" fn(log_type: LogType, msg: *const ::std::os::raw::c_char),
2818 >,
2819 pub printf: ::std::option::Option<
2820 unsafe extern "C" fn(
2821 log_type: LogType,
2822 format: *const ::std::os::raw::c_char,
2823 ...
2824 ) -> ::std::os::raw::c_int,
2825 >,
2826 pub default_logger: *mut LoggerI,
2827}
2828impl Default for LoggerApi {
2829 fn default() -> Self {
2830 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
2831 unsafe {
2832 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
2833 s.assume_init()
2834 }
2835 }
2836}
2837#[repr(C)]
2838#[derive(Default, Copy, Clone)]
2839pub struct Lz4Api {
2840 pub compress: ::std::option::Option<
2841 unsafe extern "C" fn(
2842 src: *const ::std::os::raw::c_char,
2843 src_size: u32,
2844 dst: *mut ::std::os::raw::c_char,
2845 dst_capacity: u32,
2846 ) -> u32,
2847 >,
2848 pub decompress: ::std::option::Option<
2849 unsafe extern "C" fn(
2850 src: *const ::std::os::raw::c_char,
2851 src_size: u32,
2852 dst: *mut ::std::os::raw::c_char,
2853 dst_capacity: u32,
2854 ) -> u32,
2855 >,
2856 pub compress_bound: ::std::option::Option<unsafe extern "C" fn(src_size: u32) -> u32>,
2857}
2858#[repr(C)]
2859#[derive(Default, Copy, Clone)]
2860pub struct MathApi {
2861 pub mat44_multiply: ::std::option::Option<
2862 unsafe extern "C" fn(res: *mut Mat44T, lhs: *const Mat44T, rhs: *const Mat44T),
2863 >,
2864 pub mat44_inverse:
2865 ::std::option::Option<unsafe extern "C" fn(res: *mut Mat44T, m: *const Mat44T)>,
2866 pub mat44_determinant: ::std::option::Option<unsafe extern "C" fn(m: *const Mat44T) -> f32>,
2867 pub mat44_determinant33: ::std::option::Option<unsafe extern "C" fn(m: *const Mat44T) -> f32>,
2868 pub mat44_to_quaternion: ::std::option::Option<unsafe extern "C" fn(m: *const Mat44T) -> Vec4T>,
2869 pub mat44_to_translation_quaternion_scale: ::std::option::Option<
2870 unsafe extern "C" fn(t: *mut Vec3T, r: *mut Vec4T, s: *mut Vec3T, m: *const Mat44T),
2871 >,
2872}
2873#[repr(C)]
2874#[derive(Copy, Clone)]
2875pub struct MemoryTrackerScopeDataT {
2876 pub desc: *const ::std::os::raw::c_char,
2877 pub allocated_bytes: u64,
2878 pub allocation_count: u64,
2879 pub parent: u32,
2880 pub num_children: u32,
2881 pub tracing_enabled: bool,
2882 pub _padding_44: [::std::os::raw::c_char; 3usize],
2883 pub trace_count: u32,
2884}
2885impl Default for MemoryTrackerScopeDataT {
2886 fn default() -> Self {
2887 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
2888 unsafe {
2889 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
2890 s.assume_init()
2891 }
2892 }
2893}
2894#[repr(C)]
2895#[derive(Copy, Clone)]
2896pub struct MemoryTrackerTraceDataT {
2897 pub file: *const ::std::os::raw::c_char,
2898 pub line: u32,
2899 pub scope: u32,
2900 pub allocated_bytes: u64,
2901 pub allocation_count: u64,
2902}
2903impl Default for MemoryTrackerTraceDataT {
2904 fn default() -> Self {
2905 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
2906 unsafe {
2907 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
2908 s.assume_init()
2909 }
2910 }
2911}
2912#[repr(C)]
2913#[derive(Default, Copy, Clone)]
2914pub struct MemoryTrackerApi {
2915 pub check_for_leaked_scopes: ::std::option::Option<unsafe extern "C" fn()>,
2916 pub create_scope: ::std::option::Option<
2917 unsafe extern "C" fn(desc: *const ::std::os::raw::c_char, parent_scope: u32) -> u32,
2918 >,
2919 pub destroy_scope: ::std::option::Option<unsafe extern "C" fn(s: u32)>,
2920 pub destroy_scope_allowing_leaks:
2921 ::std::option::Option<unsafe extern "C" fn(scope: u32, max_leaked_bytes: u64)>,
2922 pub record_realloc: ::std::option::Option<
2923 unsafe extern "C" fn(
2924 old_ptr: *mut ::std::os::raw::c_void,
2925 old_size: u64,
2926 new_ptr: *mut ::std::os::raw::c_void,
2927 new_size: u64,
2928 file: *const ::std::os::raw::c_char,
2929 line: u32,
2930 scope: u32,
2931 ),
2932 >,
2933 pub allocated_bytes: ::std::option::Option<unsafe extern "C" fn(scope: u32) -> u64>,
2934 pub allocation_count: ::std::option::Option<unsafe extern "C" fn(scope: u32) -> u64>,
2935 pub set_scope_tracing: ::std::option::Option<unsafe extern "C" fn(scope: u32, enabled: bool)>,
2936 pub scope_data_snapshot: ::std::option::Option<
2937 unsafe extern "C" fn(ta: *mut TempAllocatorI) -> *mut MemoryTrackerScopeDataT,
2938 >,
2939 pub trace_data_snapshot: ::std::option::Option<
2940 unsafe extern "C" fn(ta: *mut TempAllocatorI) -> *mut MemoryTrackerTraceDataT,
2941 >,
2942}
2943#[repr(C)]
2944#[derive(Default, Copy, Clone)]
2945pub struct OsVirtualMemoryApi {
2946 pub map: ::std::option::Option<unsafe extern "C" fn(size: u64) -> *mut ::std::os::raw::c_void>,
2947 pub unmap:
2948 ::std::option::Option<unsafe extern "C" fn(p: *mut ::std::os::raw::c_void, size: u64)>,
2949 pub reserve:
2950 ::std::option::Option<unsafe extern "C" fn(size: u64) -> *mut ::std::os::raw::c_void>,
2951 pub commit:
2952 ::std::option::Option<unsafe extern "C" fn(p: *mut ::std::os::raw::c_void, size: u64)>,
2953}
2954#[repr(C)]
2955#[derive(Default, Copy, Clone)]
2956pub struct FileO {
2957 pub handle: u64,
2958 pub valid: bool,
2959 pub _padding_53: [::std::os::raw::c_char; 7usize],
2960}
2961#[repr(C)]
2962#[derive(Default, Copy, Clone)]
2963pub struct FileTimeO {
2964 pub opaque: u64,
2965}
2966#[repr(C)]
2967#[derive(Default, Copy, Clone)]
2968pub struct OsFileIoApi {
2969 pub open_input:
2970 ::std::option::Option<unsafe extern "C" fn(path: *const ::std::os::raw::c_char) -> FileO>,
2971 pub open_output:
2972 ::std::option::Option<unsafe extern "C" fn(path: *const ::std::os::raw::c_char) -> FileO>,
2973 pub open_append:
2974 ::std::option::Option<unsafe extern "C" fn(path: *const ::std::os::raw::c_char) -> FileO>,
2975 pub set_position: ::std::option::Option<unsafe extern "C" fn(file: FileO, pos: u64)>,
2976 pub size: ::std::option::Option<unsafe extern "C" fn(file: FileO) -> u64>,
2977 pub read: ::std::option::Option<
2978 unsafe extern "C" fn(file: FileO, buffer: *mut ::std::os::raw::c_void, size: u64) -> i64,
2979 >,
2980 pub write: ::std::option::Option<
2981 unsafe extern "C" fn(file: FileO, buffer: *const ::std::os::raw::c_void, size: u64) -> bool,
2982 >,
2983 pub read_at: ::std::option::Option<
2984 unsafe extern "C" fn(
2985 file: FileO,
2986 offset: u64,
2987 buffer: *mut ::std::os::raw::c_void,
2988 size: u64,
2989 ) -> i64,
2990 >,
2991 pub write_at: ::std::option::Option<
2992 unsafe extern "C" fn(
2993 file: FileO,
2994 offset: u64,
2995 buffer: *const ::std::os::raw::c_void,
2996 size: u64,
2997 ) -> bool,
2998 >,
2999 pub set_last_modified_time:
3000 ::std::option::Option<unsafe extern "C" fn(file: FileO, time: FileTimeO)>,
3001 pub close: ::std::option::Option<unsafe extern "C" fn(file: FileO)>,
3002}
3003#[repr(C)]
3004#[derive(Default, Copy, Clone)]
3005pub struct FileStatT {
3006 pub exists: bool,
3007 pub is_directory: bool,
3008 pub _padding_125: [::std::os::raw::c_char; 6usize],
3009 pub last_modified_time: FileTimeO,
3010 pub size: u64,
3011}
3012#[repr(C)]
3013#[derive(Default, Copy, Clone)]
3014pub struct StringsT {
3015 pub count: u32,
3016 pub bytes: u32,
3017}
3018#[repr(C)]
3019#[derive(Default, Copy, Clone)]
3020pub struct FileSystemWatcherO {
3021 pub opaque: u64,
3022}
3023#[repr(C)]
3024#[derive(Copy, Clone)]
3025pub struct FileSystemDetailedWatcherO {
3026 _unused: [u8; 0],
3027}
3028pub const TM_FILE_SYSTEM_CHANGE_ACTION__ADDED: FileSystemChangeAction = 0;
3029pub const TM_FILE_SYSTEM_CHANGE_ACTION__REMOVED: FileSystemChangeAction = 1;
3030pub const TM_FILE_SYSTEM_CHANGE_ACTION__MODIFIED: FileSystemChangeAction = 2;
3031pub type FileSystemChangeAction = ::std::os::raw::c_int;
3032#[repr(C)]
3033#[derive(Copy, Clone)]
3034pub struct FileSystemChangeT {
3035 pub relative_path: *const ::std::os::raw::c_char,
3036 pub action: FileSystemChangeAction,
3037 pub _padding_186: [::std::os::raw::c_char; 4usize],
3038}
3039impl Default for FileSystemChangeT {
3040 fn default() -> Self {
3041 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
3042 unsafe {
3043 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
3044 s.assume_init()
3045 }
3046 }
3047}
3048#[repr(C)]
3049#[derive(Default, Copy, Clone)]
3050pub struct OsFileSystemApi {
3051 pub stat: ::std::option::Option<
3052 unsafe extern "C" fn(path: *const ::std::os::raw::c_char) -> FileStatT,
3053 >,
3054 pub directory_entries: ::std::option::Option<
3055 unsafe extern "C" fn(
3056 path: *const ::std::os::raw::c_char,
3057 ta: *mut TempAllocatorI,
3058 ) -> *mut StringsT,
3059 >,
3060 pub make_directory:
3061 ::std::option::Option<unsafe extern "C" fn(path: *const ::std::os::raw::c_char) -> bool>,
3062 pub remove_file:
3063 ::std::option::Option<unsafe extern "C" fn(path: *const ::std::os::raw::c_char) -> bool>,
3064 pub remove_directory:
3065 ::std::option::Option<unsafe extern "C" fn(path: *const ::std::os::raw::c_char) -> bool>,
3066 pub rename: ::std::option::Option<
3067 unsafe extern "C" fn(
3068 old_name: *const ::std::os::raw::c_char,
3069 new_name: *const ::std::os::raw::c_char,
3070 ) -> bool,
3071 >,
3072 pub copy_file: ::std::option::Option<
3073 unsafe extern "C" fn(
3074 from: *const ::std::os::raw::c_char,
3075 to: *const ::std::os::raw::c_char,
3076 ) -> bool,
3077 >,
3078 pub getcwd: ::std::option::Option<
3079 unsafe extern "C" fn(ta: *mut TempAllocatorI) -> *const ::std::os::raw::c_char,
3080 >,
3081 pub chdir:
3082 ::std::option::Option<unsafe extern "C" fn(path: *const ::std::os::raw::c_char) -> bool>,
3083 pub is_absolute:
3084 ::std::option::Option<unsafe extern "C" fn(path: *const ::std::os::raw::c_char) -> bool>,
3085 pub absolute: ::std::option::Option<
3086 unsafe extern "C" fn(
3087 path: *const ::std::os::raw::c_char,
3088 ta: *mut TempAllocatorI,
3089 ) -> *const ::std::os::raw::c_char,
3090 >,
3091 pub temp_directory: ::std::option::Option<
3092 unsafe extern "C" fn(ta: *mut TempAllocatorI) -> *const ::std::os::raw::c_char,
3093 >,
3094 pub create_watcher: ::std::option::Option<
3095 unsafe extern "C" fn(subtree_path: *const ::std::os::raw::c_char) -> FileSystemWatcherO,
3096 >,
3097 pub any_changes:
3098 ::std::option::Option<unsafe extern "C" fn(watcher: FileSystemWatcherO) -> bool>,
3099 pub destroy_watcher: ::std::option::Option<unsafe extern "C" fn(watcher: FileSystemWatcherO)>,
3100 pub create_detailed_watcher: ::std::option::Option<
3101 unsafe extern "C" fn(
3102 subtree_path: *const ::std::os::raw::c_char,
3103 ) -> *mut FileSystemDetailedWatcherO,
3104 >,
3105 pub detailed_changes: ::std::option::Option<
3106 unsafe extern "C" fn(
3107 arg1: *mut FileSystemDetailedWatcherO,
3108 ta: *mut TempAllocatorI,
3109 ) -> *mut FileSystemChangeT,
3110 >,
3111 pub destroy_detailed_watcher:
3112 ::std::option::Option<unsafe extern "C" fn(watcher: *mut FileSystemDetailedWatcherO)>,
3113 pub app_folder: ::std::option::Option<
3114 unsafe extern "C" fn(ta: *mut TempAllocatorI) -> *const ::std::os::raw::c_char,
3115 >,
3116}
3117#[repr(C)]
3118#[derive(Default, Copy, Clone)]
3119pub struct DllO {
3120 pub handle: u64,
3121 pub valid: bool,
3122 pub _padding_282: [::std::os::raw::c_char; 7usize],
3123}
3124#[repr(C)]
3125#[derive(Default, Copy, Clone)]
3126pub struct OsDllApi {
3127 pub open:
3128 ::std::option::Option<unsafe extern "C" fn(path: *const ::std::os::raw::c_char) -> DllO>,
3129 pub get:
3130 ::std::option::Option<unsafe extern "C" fn(path: *const ::std::os::raw::c_char) -> DllO>,
3131 pub sym: ::std::option::Option<
3132 unsafe extern "C" fn(
3133 handle: DllO,
3134 name: *const ::std::os::raw::c_char,
3135 ) -> *mut ::std::os::raw::c_void,
3136 >,
3137 pub close: ::std::option::Option<unsafe extern "C" fn(handle: DllO)>,
3138}
3139#[repr(C)]
3140#[derive(Default, Copy, Clone)]
3141pub struct SocketO {
3142 pub handle: u64,
3143 pub valid: bool,
3144 pub _padding_313: [::std::os::raw::c_char; 7usize],
3145}
3146#[repr(C)]
3147#[derive(Copy, Clone)]
3148pub struct SocketAddressT {
3149 pub __bindgen_anon_1: SocketAddressTBindgenTy1,
3150 pub port: u32,
3151}
3152#[repr(C)]
3153#[derive(Copy, Clone)]
3154pub union SocketAddressTBindgenTy1 {
3155 pub ip: u32,
3156 pub ip_byte: [u8; 4usize],
3157}
3158impl Default for SocketAddressTBindgenTy1 {
3159 fn default() -> Self {
3160 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
3161 unsafe {
3162 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
3163 s.assume_init()
3164 }
3165 }
3166}
3167impl Default for SocketAddressT {
3168 fn default() -> Self {
3169 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
3170 unsafe {
3171 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
3172 s.assume_init()
3173 }
3174 }
3175}
3176pub const TM_OS_SOCKET_TYPE_TCP: OsSocketType = 1;
3177pub const TM_OS_SOCKET_TYPE_UDP: OsSocketType = 2;
3178pub type OsSocketType = ::std::os::raw::c_int;
3179pub const TM_OS_SOCKET_ERROR_WOULD_BLOCK: OsSocketError = -1000;
3180pub const TM_OS_SOCKET_ERROR_CLOSED: OsSocketError = -1001;
3181pub const TM_OS_SOCKET_ERROR_INVALID: OsSocketError = -1002;
3182pub const TM_OS_SOCKET_ERROR_OTHER: OsSocketError = -1;
3183pub type OsSocketError = ::std::os::raw::c_int;
3184pub const TM_OS_SOCKET_CONNECT_PENDING: OsSocketConnect = 0;
3185pub const TM_OS_SOCKET_CONNECT_ESTABLISHED: OsSocketConnect = 1;
3186pub const TM_OS_SOCKET_CONNECT_FAILED: OsSocketConnect = 2;
3187pub type OsSocketConnect = ::std::os::raw::c_int;
3188pub const TM_OS_SOCKET_GETADDRINFO_IN_PROGRESS: OsSocketGetaddrinfo = 0;
3189pub const TM_OS_SOCKET_GETADDRINFO_SUCCESS: OsSocketGetaddrinfo = 1;
3190pub const TM_OS_SOCKET_GETADDRINFO_ERROR: OsSocketGetaddrinfo = 2;
3191pub type OsSocketGetaddrinfo = ::std::os::raw::c_int;
3192pub const TM_SOCKET_OPTION__NODELAY: OsSocketOption = 0;
3193pub const TM_SOCKET_OPTION__NONBLOCK: OsSocketOption = 1;
3194pub type OsSocketOption = ::std::os::raw::c_int;
3195#[repr(C)]
3196#[derive(Default, Copy, Clone)]
3197pub struct OsSocketApi {
3198 pub init: ::std::option::Option<unsafe extern "C" fn()>,
3199 pub shutdown: ::std::option::Option<unsafe extern "C" fn()>,
3200 pub socket: ::std::option::Option<unsafe extern "C" fn(type_: OsSocketType) -> SocketO>,
3201 pub set_option: ::std::option::Option<
3202 unsafe extern "C" fn(socket: SocketO, option: OsSocketOption, enabled: bool),
3203 >,
3204 pub bind: ::std::option::Option<
3205 unsafe extern "C" fn(socket: SocketO, address: SocketAddressT) -> bool,
3206 >,
3207 pub getsockname: ::std::option::Option<
3208 unsafe extern "C" fn(socket: SocketO, address: *mut SocketAddressT) -> bool,
3209 >,
3210 pub listen:
3211 ::std::option::Option<unsafe extern "C" fn(socket: SocketO, queue_size: u32) -> bool>,
3212 pub accept: ::std::option::Option<
3213 unsafe extern "C" fn(socket: SocketO, address: *mut SocketAddressT) -> SocketO,
3214 >,
3215 pub connect: ::std::option::Option<
3216 unsafe extern "C" fn(socket: SocketO, target: SocketAddressT) -> OsSocketConnect,
3217 >,
3218 pub send: ::std::option::Option<
3219 unsafe extern "C" fn(
3220 socket: SocketO,
3221 buffer: *const ::std::os::raw::c_void,
3222 size: u32,
3223 ) -> i32,
3224 >,
3225 pub recv: ::std::option::Option<
3226 unsafe extern "C" fn(
3227 socket: SocketO,
3228 buffer: *mut ::std::os::raw::c_void,
3229 size: u32,
3230 ) -> i32,
3231 >,
3232 pub sendto: ::std::option::Option<
3233 unsafe extern "C" fn(
3234 socket: SocketO,
3235 buffer: *const ::std::os::raw::c_void,
3236 size: u32,
3237 target: SocketAddressT,
3238 ) -> i32,
3239 >,
3240 pub recvfrom: ::std::option::Option<
3241 unsafe extern "C" fn(
3242 socket: SocketO,
3243 buffer: *mut ::std::os::raw::c_void,
3244 size: u32,
3245 source: *mut SocketAddressT,
3246 ) -> i32,
3247 >,
3248 pub close: ::std::option::Option<unsafe extern "C" fn(socket: SocketO) -> bool>,
3249 pub getaddrinfo: ::std::option::Option<
3250 unsafe extern "C" fn(
3251 name: *const ::std::os::raw::c_char,
3252 service: *const ::std::os::raw::c_char,
3253 addresses: *mut SocketAddressT,
3254 size: u32,
3255 ) -> u32,
3256 >,
3257 pub getaddrinfo_async: ::std::option::Option<
3258 unsafe extern "C" fn(
3259 name: *const ::std::os::raw::c_char,
3260 service: *const ::std::os::raw::c_char,
3261 ) -> *mut ::std::os::raw::c_void,
3262 >,
3263 pub getaddrinfo_result: ::std::option::Option<
3264 unsafe extern "C" fn(
3265 query: *mut ::std::os::raw::c_void,
3266 addresses: *mut SocketAddressT,
3267 count: *mut u32,
3268 ) -> OsSocketGetaddrinfo,
3269 >,
3270}
3271pub const TM_OS_THREAD__PRIORITY__LOWEST: OsThreadPriority = 0;
3272pub const TM_OS_THREAD__PRIOIRTY__LOW: OsThreadPriority = 1;
3273pub const TM_OS_THREAD__PRIORITY__NORMAL: OsThreadPriority = 2;
3274pub const TM_OS_THREAD__PRIORITY__HIGH: OsThreadPriority = 3;
3275pub const TM_OS_THREAD__PRIORITY__HIGHEST: OsThreadPriority = 4;
3276pub const TM_OS_THREAD__PRIORITY__TIME_CRITICAL: OsThreadPriority = 5;
3277pub type OsThreadPriority = ::std::os::raw::c_int;
3278pub type ThreadEntryF =
3279 ::std::option::Option<unsafe extern "C" fn(user_data: *mut ::std::os::raw::c_void)>;
3280pub type FiberEntryF =
3281 ::std::option::Option<unsafe extern "C" fn(user_data: *mut ::std::os::raw::c_void)>;
3282#[repr(C)]
3283#[derive(Default, Copy, Clone)]
3284pub struct CriticalSectionO {
3285 pub opaque: [u64; 8usize],
3286}
3287#[repr(C)]
3288#[derive(Default, Copy, Clone)]
3289pub struct SemaphoreO {
3290 pub opaque: u64,
3291}
3292#[repr(C)]
3293#[derive(Default, Copy, Clone)]
3294pub struct ThreadO {
3295 pub opaque: [u64; 2usize],
3296}
3297#[repr(C)]
3298#[derive(Default, Copy, Clone)]
3299pub struct FiberO {
3300 pub opaque: u64,
3301}
3302#[repr(C)]
3303#[derive(Default, Copy, Clone)]
3304pub struct OsThreadApi {
3305 pub create_critical_section:
3306 ::std::option::Option<unsafe extern "C" fn(cs: *mut CriticalSectionO)>,
3307 pub enter_critical_section:
3308 ::std::option::Option<unsafe extern "C" fn(cs: *mut CriticalSectionO)>,
3309 pub leave_critical_section:
3310 ::std::option::Option<unsafe extern "C" fn(cs: *mut CriticalSectionO)>,
3311 pub destroy_critical_section:
3312 ::std::option::Option<unsafe extern "C" fn(cs: *mut CriticalSectionO)>,
3313 pub create_semaphore:
3314 ::std::option::Option<unsafe extern "C" fn(initial_count: u32) -> SemaphoreO>,
3315 pub semaphore_add: ::std::option::Option<unsafe extern "C" fn(sem: SemaphoreO, count: u32)>,
3316 pub semaphore_wait: ::std::option::Option<unsafe extern "C" fn(sem: SemaphoreO)>,
3317 pub semaphore_poll: ::std::option::Option<unsafe extern "C" fn(sem: SemaphoreO) -> bool>,
3318 pub destroy_semaphore: ::std::option::Option<unsafe extern "C" fn(sem: SemaphoreO)>,
3319 pub thread_id: ::std::option::Option<unsafe extern "C" fn() -> u32>,
3320 pub processor_id: ::std::option::Option<unsafe extern "C" fn() -> u32>,
3321 pub create_thread: ::std::option::Option<
3322 unsafe extern "C" fn(
3323 entry: ThreadEntryF,
3324 user_data: *mut ::std::os::raw::c_void,
3325 stack_size: u32,
3326 debug_name: *const ::std::os::raw::c_char,
3327 ) -> ThreadO,
3328 >,
3329 pub set_thread_priority:
3330 ::std::option::Option<unsafe extern "C" fn(thread: ThreadO, priority: OsThreadPriority)>,
3331 pub wait_for_thread: ::std::option::Option<unsafe extern "C" fn(thread: ThreadO)>,
3332 pub thread_id_from_tm_thread:
3333 ::std::option::Option<unsafe extern "C" fn(thread: ThreadO) -> u32>,
3334 pub convert_thread_to_fiber: ::std::option::Option<
3335 unsafe extern "C" fn(user_data: *mut ::std::os::raw::c_void) -> FiberO,
3336 >,
3337 pub convert_fiber_to_thread: ::std::option::Option<unsafe extern "C" fn()>,
3338 pub create_fiber: ::std::option::Option<
3339 unsafe extern "C" fn(
3340 entry: FiberEntryF,
3341 user_data: *mut ::std::os::raw::c_void,
3342 stack_size: u32,
3343 ) -> FiberO,
3344 >,
3345 pub destroy_fiber: ::std::option::Option<unsafe extern "C" fn(fiber: FiberO)>,
3346 pub switch_to_fiber: ::std::option::Option<unsafe extern "C" fn(fiber: FiberO)>,
3347 pub fiber_user_data:
3348 ::std::option::Option<unsafe extern "C" fn() -> *mut ::std::os::raw::c_void>,
3349 pub yield_processor: ::std::option::Option<unsafe extern "C" fn()>,
3350 pub sleep: ::std::option::Option<unsafe extern "C" fn(seconds: f64)>,
3351}
3352#[repr(C)]
3353#[derive(Default, Copy, Clone)]
3354pub struct OsTimeApi {
3355 pub now: ::std::option::Option<unsafe extern "C" fn() -> ClockO>,
3356 pub delta: ::std::option::Option<unsafe extern "C" fn(to: ClockO, from: ClockO) -> f64>,
3357 pub add: ::std::option::Option<unsafe extern "C" fn(from: ClockO, delta: f64) -> ClockO>,
3358 pub file_time_now: ::std::option::Option<unsafe extern "C" fn() -> FileTimeO>,
3359 pub file_time_delta:
3360 ::std::option::Option<unsafe extern "C" fn(to: FileTimeO, from: FileTimeO) -> f64>,
3361}
3362#[repr(C)]
3363#[derive(Copy, Clone)]
3364pub struct OsDialogsOpenT {
3365 pub extensions: *const ::std::os::raw::c_char,
3366 pub description: *const ::std::os::raw::c_char,
3367 pub allow_multi_select: bool,
3368 pub _padding_710: [::std::os::raw::c_char; 7usize],
3369}
3370impl Default for OsDialogsOpenT {
3371 fn default() -> Self {
3372 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
3373 unsafe {
3374 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
3375 s.assume_init()
3376 }
3377 }
3378}
3379#[repr(C)]
3380#[derive(Copy, Clone)]
3381pub struct OsDialogsOpenResT {
3382 pub num_files: u32,
3383 pub _padding_718: [::std::os::raw::c_char; 4usize],
3384 pub files: *mut *mut ::std::os::raw::c_char,
3385}
3386impl Default for OsDialogsOpenResT {
3387 fn default() -> Self {
3388 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
3389 unsafe {
3390 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
3391 s.assume_init()
3392 }
3393 }
3394}
3395#[repr(C)]
3396#[derive(Copy, Clone)]
3397pub struct OsDialogsSaveT {
3398 pub default_name: *const ::std::os::raw::c_char,
3399}
3400impl Default for OsDialogsSaveT {
3401 fn default() -> Self {
3402 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
3403 unsafe {
3404 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
3405 s.assume_init()
3406 }
3407 }
3408}
3409#[repr(C)]
3410#[derive(Default, Copy, Clone)]
3411pub struct OsDialogsApi {
3412 pub open: ::std::option::Option<
3413 unsafe extern "C" fn(
3414 s: *const OsDialogsOpenT,
3415 ta: *mut TempAllocatorI,
3416 ) -> OsDialogsOpenResT,
3417 >,
3418 pub open_folder: ::std::option::Option<
3419 unsafe extern "C" fn(ta: *mut TempAllocatorI) -> *mut ::std::os::raw::c_char,
3420 >,
3421 pub save: ::std::option::Option<
3422 unsafe extern "C" fn(
3423 s: *const OsDialogsSaveT,
3424 ta: *mut TempAllocatorI,
3425 ) -> *mut ::std::os::raw::c_char,
3426 >,
3427 pub message_box: ::std::option::Option<
3428 unsafe extern "C" fn(
3429 title: *const ::std::os::raw::c_char,
3430 text: *const ::std::os::raw::c_char,
3431 ),
3432 >,
3433 pub show_count: ::std::option::Option<unsafe extern "C" fn() -> u64>,
3434}
3435#[repr(C)]
3436#[derive(Default, Copy, Clone)]
3437pub struct OsInfoApi {
3438 pub num_logical_processors: ::std::option::Option<unsafe extern "C" fn() -> u32>,
3439 pub avx_support: ::std::option::Option<unsafe extern "C" fn() -> bool>,
3440}
3441#[repr(C)]
3442#[derive(Default, Copy, Clone)]
3443pub struct OsDebuggerApi {
3444 pub is_debugger_present: ::std::option::Option<unsafe extern "C" fn() -> bool>,
3445 pub debug_break: ::std::option::Option<unsafe extern "C" fn()>,
3446 pub print_stack_trace: ::std::option::Option<unsafe extern "C" fn()>,
3447}
3448#[repr(C)]
3449#[derive(Default, Copy, Clone)]
3450pub struct OsSystemApi {
3451 pub open_url: ::std::option::Option<unsafe extern "C" fn(url: *const ::std::os::raw::c_char)>,
3452 pub open_file:
3453 ::std::option::Option<unsafe extern "C" fn(file: *const ::std::os::raw::c_char) -> bool>,
3454 pub exe_path: ::std::option::Option<
3455 unsafe extern "C" fn(
3456 argv_0: *const ::std::os::raw::c_char,
3457 ) -> *const ::std::os::raw::c_char,
3458 >,
3459 pub execute: ::std::option::Option<
3460 unsafe extern "C" fn(command: *const ::std::os::raw::c_char) -> ::std::os::raw::c_int,
3461 >,
3462 pub execute_in_background: ::std::option::Option<
3463 unsafe extern "C" fn(command: *const ::std::os::raw::c_char) -> ::std::os::raw::c_int,
3464 >,
3465 pub execute_stdout: ::std::option::Option<
3466 unsafe extern "C" fn(
3467 command: *const ::std::os::raw::c_char,
3468 timeout_ms: u32,
3469 ta: *mut TempAllocatorI,
3470 exit_code: *mut ::std::os::raw::c_int,
3471 ) -> *mut ::std::os::raw::c_char,
3472 >,
3473}
3474#[repr(C)]
3475#[derive(Copy, Clone)]
3476pub struct OsApi {
3477 pub virtual_memory: *mut OsVirtualMemoryApi,
3478 pub file_io: *mut OsFileIoApi,
3479 pub file_system: *mut OsFileSystemApi,
3480 pub dll: *mut OsDllApi,
3481 pub socket: *mut OsSocketApi,
3482 pub thread: *mut OsThreadApi,
3483 pub time: *mut OsTimeApi,
3484 pub dialogs: *mut OsDialogsApi,
3485 pub info: *mut OsInfoApi,
3486 pub debugger: *mut OsDebuggerApi,
3487 pub system: *mut OsSystemApi,
3488}
3489impl Default for OsApi {
3490 fn default() -> Self {
3491 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
3492 unsafe {
3493 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
3494 s.assume_init()
3495 }
3496 }
3497}
3498#[repr(C)]
3499#[derive(Default, Copy, Clone)]
3500pub struct PathApi {
3501 pub extension: ::std::option::Option<unsafe extern "C" fn(path: StrT) -> StrT>,
3502 pub extension_cstr: ::std::option::Option<
3503 unsafe extern "C" fn(path: *const ::std::os::raw::c_char) -> *const ::std::os::raw::c_char,
3504 >,
3505 pub strip_extension: ::std::option::Option<unsafe extern "C" fn(path: StrT) -> StrT>,
3506 pub base: ::std::option::Option<unsafe extern "C" fn(path: StrT) -> StrT>,
3507 pub base_cstr: ::std::option::Option<
3508 unsafe extern "C" fn(path: *const ::std::os::raw::c_char) -> *const ::std::os::raw::c_char,
3509 >,
3510 pub directory: ::std::option::Option<unsafe extern "C" fn(path: StrT) -> StrT>,
3511 pub pop_last: ::std::option::Option<unsafe extern "C" fn(path: *mut StrT) -> StrT>,
3512 pub pop_first: ::std::option::Option<unsafe extern "C" fn(path: *mut StrT) -> StrT>,
3513 pub split_all: ::std::option::Option<
3514 unsafe extern "C" fn(path: StrT, ta: *mut TempAllocatorI) -> *mut StrT,
3515 >,
3516 pub join: ::std::option::Option<
3517 unsafe extern "C" fn(a: StrT, b: StrT, ta: *mut TempAllocatorI) -> StrT,
3518 >,
3519}
3520pub type PluginLoadF =
3521 ::std::option::Option<unsafe extern "C" fn(reg: *mut ApiRegistryApi, load: bool)>;
3522#[repr(C)]
3523#[derive(Default, Copy, Clone)]
3524pub struct PluginsApi {
3525 pub load: ::std::option::Option<
3526 unsafe extern "C" fn(path: *const ::std::os::raw::c_char, hot_reload: bool) -> u64,
3527 >,
3528 pub unload: ::std::option::Option<unsafe extern "C" fn(plugin: u64)>,
3529 pub reload: ::std::option::Option<unsafe extern "C" fn(plugin: u64)>,
3530 pub set_path: ::std::option::Option<
3531 unsafe extern "C" fn(plugin: u64, path: *const ::std::os::raw::c_char),
3532 >,
3533 pub check_hot_reload: ::std::option::Option<unsafe extern "C" fn() -> bool>,
3534 pub reload_count: ::std::option::Option<unsafe extern "C" fn() -> u64>,
3535 pub enumerate: ::std::option::Option<
3536 unsafe extern "C" fn(
3537 directory: *const ::std::os::raw::c_char,
3538 ta: *mut TempAllocatorI,
3539 ) -> *mut *const ::std::os::raw::c_char,
3540 >,
3541 pub plugin_dllpath: ::std::option::Option<
3542 unsafe extern "C" fn(
3543 ta: *mut TempAllocatorI,
3544 exe: *const ::std::os::raw::c_char,
3545 name: *const ::std::os::raw::c_char,
3546 ) -> *const ::std::os::raw::c_char,
3547 >,
3548 pub app_dllpath: ::std::option::Option<
3549 unsafe extern "C" fn(
3550 ta: *mut TempAllocatorI,
3551 exe: *const ::std::os::raw::c_char,
3552 name: *const ::std::os::raw::c_char,
3553 ) -> *const ::std::os::raw::c_char,
3554 >,
3555}
3556pub const TM_TT_PROP__PLUGIN__IMPORT_ON_CHANGE: TM_TT_PROP__PLUGIN = 0;
3557pub const TM_TT_PROP__PLUGIN__WINDOWS_DLL_IMPORT_PATH: TM_TT_PROP__PLUGIN = 1;
3558pub const TM_TT_PROP__PLUGIN__WINDOWS_DLL: TM_TT_PROP__PLUGIN = 2;
3559pub const TM_TT_PROP__PLUGIN__LINUX_DLL_IMPORT_PATH: TM_TT_PROP__PLUGIN = 3;
3560pub const TM_TT_PROP__PLUGIN__LINUX_DLL: TM_TT_PROP__PLUGIN = 4;
3561pub const TM_TT_PROP__PLUGIN__IS_HELPER: TM_TT_PROP__PLUGIN = 5;
3562pub type TM_TT_PROP__PLUGIN = ::std::os::raw::c_int;
3563#[repr(C)]
3564#[derive(Default, Copy, Clone)]
3565pub struct PluginAssetsApi {
3566 pub any_plugins: ::std::option::Option<unsafe extern "C" fn(tt: *mut TheTruthO) -> bool>,
3567 pub init_truth:
3568 ::std::option::Option<unsafe extern "C" fn(tt: *mut TheTruthO, allow_code_execution: bool)>,
3569 pub shutdown_truth: ::std::option::Option<unsafe extern "C" fn(tt: *mut TheTruthO)>,
3570 pub update_truth: ::std::option::Option<unsafe extern "C" fn(tt: *mut TheTruthO)>,
3571 pub allow_code_execution:
3572 ::std::option::Option<unsafe extern "C" fn(tt: *mut TheTruthO) -> bool>,
3573 pub set_allow_code_execution:
3574 ::std::option::Option<unsafe extern "C" fn(tt: *mut TheTruthO, allow_code_execution: bool)>,
3575}
3576#[repr(C)]
3577#[derive(Copy, Clone)]
3578pub struct PluginInitI {
3579 pub inst: *mut PluginO,
3580 pub init:
3581 ::std::option::Option<unsafe extern "C" fn(inst: *mut PluginO, allocator: *mut AllocatorI)>,
3582}
3583impl Default for PluginInitI {
3584 fn default() -> Self {
3585 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
3586 unsafe {
3587 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
3588 s.assume_init()
3589 }
3590 }
3591}
3592#[repr(C)]
3593#[derive(Copy, Clone)]
3594pub struct PluginShutdownI {
3595 pub inst: *mut PluginO,
3596 pub shutdown: ::std::option::Option<unsafe extern "C" fn(inst: *mut PluginO)>,
3597}
3598impl Default for PluginShutdownI {
3599 fn default() -> Self {
3600 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
3601 unsafe {
3602 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
3603 s.assume_init()
3604 }
3605 }
3606}
3607#[repr(C)]
3608#[derive(Copy, Clone)]
3609pub struct PluginTickI {
3610 pub inst: *mut PluginO,
3611 pub tick: ::std::option::Option<unsafe extern "C" fn(inst: *mut PluginO, dt: f32)>,
3612}
3613impl Default for PluginTickI {
3614 fn default() -> Self {
3615 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
3616 unsafe {
3617 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
3618 s.assume_init()
3619 }
3620 }
3621}
3622#[repr(C)]
3623#[derive(Copy, Clone)]
3624pub struct PluginReloadI {
3625 pub inst: *mut PluginO,
3626 pub reload: ::std::option::Option<unsafe extern "C" fn(inst: *mut PluginO)>,
3627}
3628impl Default for PluginReloadI {
3629 fn default() -> Self {
3630 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
3631 unsafe {
3632 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
3633 s.assume_init()
3634 }
3635 }
3636}
3637#[repr(C)]
3638#[derive(Copy, Clone)]
3639pub struct PluginSetTheTruthI {
3640 pub inst: *mut PluginO,
3641 pub set_the_truth:
3642 ::std::option::Option<unsafe extern "C" fn(inst: *mut PluginO, tt: *mut TheTruthO)>,
3643}
3644impl Default for PluginSetTheTruthI {
3645 fn default() -> Self {
3646 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
3647 unsafe {
3648 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
3649 s.assume_init()
3650 }
3651 }
3652}
3653pub const TM_PROFILER_EVENT_TYPE_BEGIN: ProfilerEventType = 0;
3654pub const TM_PROFILER_EVENT_TYPE_END: ProfilerEventType = 1;
3655pub const TM_PROFILER_EVENT_TYPE_INSTANT: ProfilerEventType = 2;
3656pub const TM_PROFILER_EVENT_TYPE_START: ProfilerEventType = 3;
3657pub const TM_PROFILER_EVENT_TYPE_FINISH: ProfilerEventType = 4;
3658pub const TM_PROFILER_EVENT_TYPE_FIBER_SWITCH: ProfilerEventType = 5;
3659pub type ProfilerEventType = ::std::os::raw::c_int;
3660#[repr(C)]
3661#[derive(Copy, Clone)]
3662pub struct ProfilerEventT {
3663 pub type_: u32,
3664 pub thread_id: u32,
3665 pub time_stamp: u64,
3666 pub __bindgen_anon_1: ProfilerEventTBindgenTy1,
3667}
3668#[repr(C)]
3669#[derive(Copy, Clone)]
3670pub union ProfilerEventTBindgenTy1 {
3671 pub __bindgen_anon_1: ProfilerEventTBindgenTy1BindgenTy1,
3672 pub __bindgen_anon_2: ProfilerEventTBindgenTy1BindgenTy2,
3673}
3674#[repr(C)]
3675#[derive(Copy, Clone)]
3676pub struct ProfilerEventTBindgenTy1BindgenTy1 {
3677 pub id: u32,
3678 pub _padding_51: [::std::os::raw::c_char; 4usize],
3679 pub category: *const ::std::os::raw::c_char,
3680 pub name: *const ::std::os::raw::c_char,
3681 pub object: *const ::std::os::raw::c_char,
3682}
3683impl Default for ProfilerEventTBindgenTy1BindgenTy1 {
3684 fn default() -> Self {
3685 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
3686 unsafe {
3687 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
3688 s.assume_init()
3689 }
3690 }
3691}
3692#[repr(C)]
3693#[derive(Default, Copy, Clone)]
3694pub struct ProfilerEventTBindgenTy1BindgenTy2 {
3695 pub from_fiber: u32,
3696 pub to_fiber: u32,
3697}
3698impl Default for ProfilerEventTBindgenTy1 {
3699 fn default() -> Self {
3700 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
3701 unsafe {
3702 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
3703 s.assume_init()
3704 }
3705 }
3706}
3707impl Default for ProfilerEventT {
3708 fn default() -> Self {
3709 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
3710 unsafe {
3711 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
3712 s.assume_init()
3713 }
3714 }
3715}
3716#[repr(C)]
3717#[derive(Copy, Clone)]
3718pub struct ProfilerBufferT {
3719 pub total_recorded: u64,
3720 pub start: [u64; 2usize],
3721 pub events: [*const ProfilerEventT; 2usize],
3722 pub count: [u32; 2usize],
3723}
3724impl Default for ProfilerBufferT {
3725 fn default() -> Self {
3726 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
3727 unsafe {
3728 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
3729 s.assume_init()
3730 }
3731 }
3732}
3733#[repr(C)]
3734#[derive(Copy, Clone)]
3735pub struct ProfilerApi {
3736 pub init: ::std::option::Option<
3737 unsafe extern "C" fn(allocator: *mut AllocatorI, event_buffer_size: u32),
3738 >,
3739 pub shutdown: ::std::option::Option<unsafe extern "C" fn()>,
3740 pub enabled: *mut bool,
3741 pub begin: ::std::option::Option<
3742 unsafe extern "C" fn(
3743 name: *const ::std::os::raw::c_char,
3744 category: *const ::std::os::raw::c_char,
3745 object: *const ::std::os::raw::c_char,
3746 ) -> u64,
3747 >,
3748 pub end: ::std::option::Option<unsafe extern "C" fn(begin_id: u64)>,
3749 pub instant: ::std::option::Option<
3750 unsafe extern "C" fn(
3751 name: *const ::std::os::raw::c_char,
3752 category: *const ::std::os::raw::c_char,
3753 object: *const ::std::os::raw::c_char,
3754 ),
3755 >,
3756 pub start: ::std::option::Option<
3757 unsafe extern "C" fn(
3758 name: *const ::std::os::raw::c_char,
3759 category: *const ::std::os::raw::c_char,
3760 object: *const ::std::os::raw::c_char,
3761 ) -> u64,
3762 >,
3763 pub finish: ::std::option::Option<unsafe extern "C" fn(start_id: u64)>,
3764 pub intern: ::std::option::Option<
3765 unsafe extern "C" fn(s: *const ::std::os::raw::c_char) -> *const ::std::os::raw::c_char,
3766 >,
3767 pub fiber_switch: ::std::option::Option<unsafe extern "C" fn(from_fiber: u32, to_fiber: u32)>,
3768 pub submit:
3769 ::std::option::Option<unsafe extern "C" fn(events: *mut ProfilerEventT, count: u32)>,
3770 pub copy: ::std::option::Option<
3771 unsafe extern "C" fn(
3772 dest: *mut ProfilerEventT,
3773 start: u64,
3774 count: u32,
3775 actual_start: *mut u64,
3776 actual_count: *mut u32,
3777 ),
3778 >,
3779 pub buffer: ::std::option::Option<unsafe extern "C" fn() -> ProfilerBufferT>,
3780}
3781impl Default for ProfilerApi {
3782 fn default() -> Self {
3783 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
3784 unsafe {
3785 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
3786 s.assume_init()
3787 }
3788 }
3789}
3790#[repr(C)]
3791#[derive(Copy, Clone)]
3792pub struct TaskProgressT {
3793 pub num_tasks: u32,
3794 pub task_index: u32,
3795 pub text: *const ::std::os::raw::c_char,
3796 pub fraction: f32,
3797 pub _padding_32: [::std::os::raw::c_char; 4usize],
3798}
3799impl Default for TaskProgressT {
3800 fn default() -> Self {
3801 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
3802 unsafe {
3803 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
3804 s.assume_init()
3805 }
3806 }
3807}
3808#[repr(C)]
3809#[derive(Copy, Clone)]
3810pub struct TaskStatusT {
3811 pub num_tasks: u32,
3812 pub _padding_40: [::std::os::raw::c_char; 4usize],
3813 pub task_id: *mut u64,
3814 pub text: *mut *const ::std::os::raw::c_char,
3815 pub fraction: *mut f32,
3816}
3817impl Default for TaskStatusT {
3818 fn default() -> Self {
3819 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
3820 unsafe {
3821 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
3822 s.assume_init()
3823 }
3824 }
3825}
3826#[repr(C)]
3827#[derive(Default, Copy, Clone)]
3828pub struct ProgressReportApi {
3829 pub create:
3830 ::std::option::Option<unsafe extern "C" fn(a: *mut AllocatorI, task_display_time: f32)>,
3831 pub destroy: ::std::option::Option<unsafe extern "C" fn()>,
3832 pub update: ::std::option::Option<
3833 unsafe extern "C" fn(dt: f64, ta: *mut TempAllocatorI) -> TaskProgressT,
3834 >,
3835 pub status: ::std::option::Option<unsafe extern "C" fn(ta: *mut TempAllocatorI) -> TaskStatusT>,
3836 pub idle: ::std::option::Option<unsafe extern "C" fn() -> bool>,
3837 pub set_task_progress: ::std::option::Option<
3838 unsafe extern "C" fn(task: u64, text: *const ::std::os::raw::c_char, fraction: f32),
3839 >,
3840}
3841#[repr(C)]
3842#[derive(Default, Copy, Clone)]
3843pub struct RandomApi {
3844 pub next: ::std::option::Option<unsafe extern "C" fn() -> u64>,
3845 pub next_n: ::std::option::Option<unsafe extern "C" fn(res: *mut u64, n: u32)>,
3846 pub seed_new_state: ::std::option::Option<unsafe extern "C" fn(s: *mut u64)>,
3847}
3848#[repr(C)]
3849#[derive(Copy, Clone)]
3850pub struct RuntimeDataT {
3851 pub version: u64,
3852 pub data: *mut ::std::os::raw::c_void,
3853}
3854impl Default for RuntimeDataT {
3855 fn default() -> Self {
3856 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
3857 unsafe {
3858 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
3859 s.assume_init()
3860 }
3861 }
3862}
3863#[repr(C)]
3864#[derive(Default, Copy, Clone)]
3865pub struct RuntimeDataIoI {
3866 pub load: ::std::option::Option<
3867 unsafe extern "C" fn(
3868 io_context: *mut ::std::os::raw::c_void,
3869 tt: *mut TheTruthO,
3870 id: TtIdT,
3871 result_runtime_data: *mut ::std::os::raw::c_void,
3872 ) -> bool,
3873 >,
3874 pub unload: ::std::option::Option<
3875 unsafe extern "C" fn(
3876 io_context: *mut ::std::os::raw::c_void,
3877 runtime_data: *mut ::std::os::raw::c_void,
3878 ),
3879 >,
3880}
3881#[repr(C)]
3882#[derive(Copy, Clone)]
3883pub struct RuntimeDataRepositoryO {
3884 _unused: [u8; 0],
3885}
3886#[repr(C)]
3887#[derive(Default, Copy, Clone)]
3888pub struct RuntimeDataRepositoryApi {
3889 pub create: ::std::option::Option<
3890 unsafe extern "C" fn(
3891 allocator: *mut AllocatorI,
3892 tt: *mut TheTruthO,
3893 type_: TtTypeT,
3894 runtime_data_size: u32,
3895 io_interface: *mut RuntimeDataIoI,
3896 ) -> *mut RuntimeDataRepositoryO,
3897 >,
3898 pub destroy: ::std::option::Option<
3899 unsafe extern "C" fn(
3900 inst: *mut RuntimeDataRepositoryO,
3901 io_context: *mut ::std::os::raw::c_void,
3902 ),
3903 >,
3904 pub lookup: ::std::option::Option<
3905 unsafe extern "C" fn(
3906 inst: *mut RuntimeDataRepositoryO,
3907 id: TtIdT,
3908 wanted_version: u64,
3909 io_context: *mut ::std::os::raw::c_void,
3910 ) -> RuntimeDataT,
3911 >,
3912 pub garbage_collect: ::std::option::Option<
3913 unsafe extern "C" fn(
3914 inst: *mut RuntimeDataRepositoryO,
3915 io_context: *mut ::std::os::raw::c_void,
3916 ),
3917 >,
3918}
3919#[repr(C)]
3920#[derive(Copy, Clone)]
3921pub struct SHA1_CTX {
3922 pub state: [u32; 5usize],
3923 pub count: [u32; 2usize],
3924 pub buffer: [u8; 64usize],
3925}
3926impl Default for SHA1_CTX {
3927 fn default() -> Self {
3928 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
3929 unsafe {
3930 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
3931 s.assume_init()
3932 }
3933 }
3934}
3935pub type SprintfPrinter = ::std::option::Option<
3936 unsafe extern "C" fn(
3937 buf: *mut ::std::os::raw::c_char,
3938 count: ::std::os::raw::c_int,
3939 type_: StrT,
3940 args: StrT,
3941 data: *const ::std::os::raw::c_void,
3942 ) -> ::std::os::raw::c_int,
3943>;
3944#[repr(C)]
3945#[derive(Default, Copy, Clone)]
3946pub struct SprintfApi {
3947 pub print_unsafe: ::std::option::Option<
3948 unsafe extern "C" fn(
3949 buf: *mut ::std::os::raw::c_char,
3950 fmt: *const ::std::os::raw::c_char,
3951 ...
3952 ) -> ::std::os::raw::c_int,
3953 >,
3954 pub print: ::std::option::Option<
3955 unsafe extern "C" fn(
3956 buf: *mut ::std::os::raw::c_char,
3957 count: ::std::os::raw::c_int,
3958 fmt: *const ::std::os::raw::c_char,
3959 ...
3960 ) -> ::std::os::raw::c_int,
3961 >,
3962 pub vprint_unsafe: ::std::option::Option<
3963 unsafe extern "C" fn(
3964 buf: *mut ::std::os::raw::c_char,
3965 fmt: *const ::std::os::raw::c_char,
3966 va: va_list,
3967 ) -> ::std::os::raw::c_int,
3968 >,
3969 pub vprint: ::std::option::Option<
3970 unsafe extern "C" fn(
3971 buf: *mut ::std::os::raw::c_char,
3972 count: ::std::os::raw::c_int,
3973 fmt: *const ::std::os::raw::c_char,
3974 va: va_list,
3975 ) -> ::std::os::raw::c_int,
3976 >,
3977 pub add_printer: ::std::option::Option<
3978 unsafe extern "C" fn(name: *const ::std::os::raw::c_char, printer: SprintfPrinter),
3979 >,
3980}
3981#[repr(C)]
3982#[derive(Copy, Clone)]
3983pub struct SetStrhashT {
3984 _unused: [u8; 0],
3985}
3986#[repr(C)]
3987#[derive(Default, Copy, Clone)]
3988pub struct StringApi {
3989 pub find_unique_name: ::std::option::Option<
3990 unsafe extern "C" fn(
3991 taken_names: *mut SetStrhashT,
3992 ignore_case: bool,
3993 desired_name: *const ::std::os::raw::c_char,
3994 separator: *const ::std::os::raw::c_char,
3995 ta: *mut TempAllocatorI,
3996 ) -> *const ::std::os::raw::c_char,
3997 >,
3998}
3999#[repr(C)]
4000#[derive(Copy, Clone)]
4001pub struct StringRepositoryI {
4002 pub inst: *mut StringRepositoryO,
4003 pub add: ::std::option::Option<
4004 unsafe extern "C" fn(
4005 inst: *mut StringRepositoryO,
4006 s: *const ::std::os::raw::c_char,
4007 ) -> StrhashT,
4008 >,
4009 pub add_str: ::std::option::Option<
4010 unsafe extern "C" fn(inst: *mut StringRepositoryO, s: StrT) -> StrhashT,
4011 >,
4012 pub retain:
4013 ::std::option::Option<unsafe extern "C" fn(inst: *mut StringRepositoryO, hash: StrhashT)>,
4014 pub remove:
4015 ::std::option::Option<unsafe extern "C" fn(inst: *mut StringRepositoryO, hash: StrhashT)>,
4016 pub lookup: ::std::option::Option<
4017 unsafe extern "C" fn(
4018 inst: *mut StringRepositoryO,
4019 hash: StrhashT,
4020 ) -> *const ::std::os::raw::c_char,
4021 >,
4022 pub intern: ::std::option::Option<
4023 unsafe extern "C" fn(
4024 inst: *mut StringRepositoryO,
4025 s: *const ::std::os::raw::c_char,
4026 ) -> *const ::std::os::raw::c_char,
4027 >,
4028 pub intern_str:
4029 ::std::option::Option<unsafe extern "C" fn(inst: *mut StringRepositoryO, s: StrT) -> StrT>,
4030}
4031impl Default for StringRepositoryI {
4032 fn default() -> Self {
4033 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
4034 unsafe {
4035 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
4036 s.assume_init()
4037 }
4038 }
4039}
4040#[repr(C)]
4041#[derive(Default, Copy, Clone)]
4042pub struct StringRepositoryApi {
4043 pub create:
4044 ::std::option::Option<unsafe extern "C" fn(a: *mut AllocatorI) -> *mut StringRepositoryI>,
4045 pub destroy: ::std::option::Option<unsafe extern "C" fn(i: *mut StringRepositoryI)>,
4046}
4047#[repr(C)]
4048#[derive(Default, Copy, Clone)]
4049pub struct TaskSystemApi {
4050 pub run_task: ::std::option::Option<
4051 unsafe extern "C" fn(
4052 f: ::std::option::Option<
4053 unsafe extern "C" fn(data: *mut ::std::os::raw::c_void, id: u64),
4054 >,
4055 data: *mut ::std::os::raw::c_void,
4056 debug_name: *const ::std::os::raw::c_char,
4057 ) -> u64,
4058 >,
4059 pub is_task_done: ::std::option::Option<unsafe extern "C" fn(id: u64) -> bool>,
4060 pub is_task_done_else_assist: ::std::option::Option<unsafe extern "C" fn(id: u64) -> bool>,
4061 pub cancel_task: ::std::option::Option<unsafe extern "C" fn(id: u64)>,
4062 pub is_task_canceled: ::std::option::Option<unsafe extern "C" fn(id: u64) -> bool>,
4063}
4064#[repr(C)]
4065#[derive(Copy, Clone)]
4066pub struct TempAllocatorI {
4067 pub inst: *mut TempAllocatorO,
4068 pub realloc: ::std::option::Option<
4069 unsafe extern "C" fn(
4070 inst: *mut TempAllocatorO,
4071 ptr: *mut ::std::os::raw::c_void,
4072 old_size: u64,
4073 new_size: u64,
4074 ) -> *mut ::std::os::raw::c_void,
4075 >,
4076}
4077impl Default for TempAllocatorI {
4078 fn default() -> Self {
4079 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
4080 unsafe {
4081 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
4082 s.assume_init()
4083 }
4084 }
4085}
4086#[repr(C)]
4087#[derive(Copy, Clone)]
4088pub struct TempAllocator1024O {
4089 pub buffer: [::std::os::raw::c_char; 1024usize],
4090}
4091impl Default for TempAllocator1024O {
4092 fn default() -> Self {
4093 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
4094 unsafe {
4095 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
4096 s.assume_init()
4097 }
4098 }
4099}
4100#[repr(C)]
4101#[derive(Default, Copy, Clone)]
4102pub struct TempAllocatorStatisticsT {
4103 pub temp_allocation_blocks: u64,
4104 pub temp_allocation_bytes: u64,
4105 pub frame_allocation_blocks: u64,
4106 pub frame_allocation_bytes: u64,
4107}
4108#[repr(C)]
4109#[derive(Copy, Clone)]
4110pub struct TempAllocatorApi {
4111 pub create: ::std::option::Option<
4112 unsafe extern "C" fn(backing: *mut AllocatorI) -> *mut TempAllocatorI,
4113 >,
4114 pub create_in_buffer: ::std::option::Option<
4115 unsafe extern "C" fn(
4116 buffer: *mut ::std::os::raw::c_char,
4117 size: u64,
4118 backing: *mut AllocatorI,
4119 ) -> *mut TempAllocatorI,
4120 >,
4121 pub destroy: ::std::option::Option<unsafe extern "C" fn(ta: *mut TempAllocatorI)>,
4122 pub allocator:
4123 ::std::option::Option<unsafe extern "C" fn(a: *mut AllocatorI, ta: *mut TempAllocatorI)>,
4124 pub frame_alloc:
4125 ::std::option::Option<unsafe extern "C" fn(size: u64) -> *mut ::std::os::raw::c_void>,
4126 pub frame_allocator: ::std::option::Option<unsafe extern "C" fn() -> *mut AllocatorI>,
4127 pub tick_frame: ::std::option::Option<unsafe extern "C" fn()>,
4128 pub printf: ::std::option::Option<
4129 unsafe extern "C" fn(
4130 ta: *mut TempAllocatorI,
4131 format: *const ::std::os::raw::c_char,
4132 ...
4133 ) -> *mut ::std::os::raw::c_char,
4134 >,
4135 pub vprintf: ::std::option::Option<
4136 unsafe extern "C" fn(
4137 ta: *mut TempAllocatorI,
4138 format: *const ::std::os::raw::c_char,
4139 args: va_list,
4140 ) -> *mut ::std::os::raw::c_char,
4141 >,
4142 pub frame_printf: ::std::option::Option<
4143 unsafe extern "C" fn(
4144 format: *const ::std::os::raw::c_char,
4145 ...
4146 ) -> *mut ::std::os::raw::c_char,
4147 >,
4148 pub frame_vprintf: ::std::option::Option<
4149 unsafe extern "C" fn(
4150 format: *const ::std::os::raw::c_char,
4151 args: va_list,
4152 ) -> *mut ::std::os::raw::c_char,
4153 >,
4154 pub statistics: *mut TempAllocatorStatisticsT,
4155}
4156impl Default for TempAllocatorApi {
4157 fn default() -> Self {
4158 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
4159 unsafe {
4160 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
4161 s.assume_init()
4162 }
4163 }
4164}
4165#[repr(C)]
4166#[derive(Copy, Clone)]
4167pub struct HashIdToIdT {
4168 _unused: [u8; 0],
4169}
4170#[repr(C)]
4171#[derive(Copy, Clone)]
4172pub struct SetT {
4173 _unused: [u8; 0],
4174}
4175pub const TM_THE_TRUTH_PROPERTY_TYPE_NONE: TheTruthPropertyType = 0;
4176pub const TM_THE_TRUTH_PROPERTY_TYPE_BOOL: TheTruthPropertyType = 1;
4177pub const TM_THE_TRUTH_PROPERTY_TYPE_UINT32_T: TheTruthPropertyType = 2;
4178pub const TM_THE_TRUTH_PROPERTY_TYPE_UINT64_T: TheTruthPropertyType = 3;
4179pub const TM_THE_TRUTH_PROPERTY_TYPE_FLOAT: TheTruthPropertyType = 4;
4180pub const TM_THE_TRUTH_PROPERTY_TYPE_DOUBLE: TheTruthPropertyType = 5;
4181pub const TM_THE_TRUTH_PROPERTY_TYPE_STRING: TheTruthPropertyType = 6;
4182pub const TM_THE_TRUTH_PROPERTY_TYPE_BUFFER: TheTruthPropertyType = 7;
4183pub const TM_THE_TRUTH_PROPERTY_TYPE_REFERENCE: TheTruthPropertyType = 8;
4184pub const TM_THE_TRUTH_PROPERTY_TYPE_SUBOBJECT: TheTruthPropertyType = 9;
4185pub const TM_THE_TRUTH_PROPERTY_TYPE_REFERENCE_SET: TheTruthPropertyType = 10;
4186pub const TM_THE_TRUTH_PROPERTY_TYPE_SUBOBJECT_SET: TheTruthPropertyType = 11;
4187pub const TM_THE_TRUTH_NUM_PROPERTY_TYPES: TheTruthPropertyType = 12;
4188pub type TheTruthPropertyType = ::std::os::raw::c_int;
4189pub const TM_THE_TRUTH__EDITOR__DEFAULT: TheTruthEditor = 0;
4190pub const TM_THE_TRUTH__EDITOR__HIDDEN: TheTruthEditor = 1;
4191pub const TM_THE_TRUTH__EDITOR__UINT32_T__ENUM: TheTruthEditor = 2;
4192pub const TM_THE_TRUTH__EDITOR__STRING__OPEN_PATH: TheTruthEditor = 3;
4193pub const TM_THE_TRUTH__EDITOR__STRING__SAVE_PATH: TheTruthEditor = 4;
4194pub type TheTruthEditor = ::std::os::raw::c_int;
4195#[repr(C)]
4196#[derive(Copy, Clone)]
4197pub struct TheTruthEditorEnumT {
4198 pub count: u32,
4199 pub _padding_357: [::std::os::raw::c_char; 4usize],
4200 pub names: *const *const ::std::os::raw::c_char,
4201 pub tooltips: *const *const ::std::os::raw::c_char,
4202}
4203impl Default for TheTruthEditorEnumT {
4204 fn default() -> Self {
4205 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
4206 unsafe {
4207 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
4208 s.assume_init()
4209 }
4210 }
4211}
4212#[repr(C)]
4213#[derive(Copy, Clone)]
4214pub struct TheTruthEditorStringOpenPathT {
4215 pub extensions: *const ::std::os::raw::c_char,
4216 pub description: *const ::std::os::raw::c_char,
4217}
4218impl Default for TheTruthEditorStringOpenPathT {
4219 fn default() -> Self {
4220 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
4221 unsafe {
4222 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
4223 s.assume_init()
4224 }
4225 }
4226}
4227#[repr(C)]
4228#[derive(Copy, Clone)]
4229pub struct TheTruthEditorStringSavePathT {
4230 pub default_file_name: *const ::std::os::raw::c_char,
4231}
4232impl Default for TheTruthEditorStringSavePathT {
4233 fn default() -> Self {
4234 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
4235 unsafe {
4236 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
4237 s.assume_init()
4238 }
4239 }
4240}
4241#[repr(C)]
4242#[derive(Copy, Clone)]
4243pub struct TheTruthObjectO {
4244 _unused: [u8; 0],
4245}
4246#[repr(C)]
4247#[derive(Copy, Clone)]
4248pub struct TheTruthPropertyDefinitionT {
4249 pub name: *const ::std::os::raw::c_char,
4250 pub type_: TheTruthPropertyType,
4251 pub editor: u32,
4252 pub __bindgen_anon_1: TheTruthPropertyDefinitionTBindgenTy1,
4253 pub type_hash: StrhashT,
4254 pub allow_other_types: bool,
4255 pub _padding_451: [::std::os::raw::c_char; 7usize],
4256 pub buffer_extension: *const ::std::os::raw::c_char,
4257 pub buffer_extension_f: ::std::option::Option<
4258 unsafe extern "C" fn(
4259 tt: *const TheTruthO,
4260 object: TtIdT,
4261 property: u32,
4262 ) -> *const ::std::os::raw::c_char,
4263 >,
4264 pub tooltip: *const ::std::os::raw::c_char,
4265 pub not_serialized: bool,
4266 pub _padding_469: [::std::os::raw::c_char; 7usize],
4267 pub ui_name: *const ::std::os::raw::c_char,
4268}
4269#[repr(C)]
4270#[derive(Copy, Clone)]
4271pub union TheTruthPropertyDefinitionTBindgenTy1 {
4272 pub enum_editor: TheTruthEditorEnumT,
4273 pub string_open_path_editor: TheTruthEditorStringOpenPathT,
4274 pub string_save_path_editor: TheTruthEditorStringSavePathT,
4275}
4276impl Default for TheTruthPropertyDefinitionTBindgenTy1 {
4277 fn default() -> Self {
4278 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
4279 unsafe {
4280 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
4281 s.assume_init()
4282 }
4283 }
4284}
4285impl Default for TheTruthPropertyDefinitionT {
4286 fn default() -> Self {
4287 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
4288 unsafe {
4289 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
4290 s.assume_init()
4291 }
4292 }
4293}
4294pub type TheTruthCreateTypesI = ::std::option::Option<unsafe extern "C" fn(tt: *mut TheTruthO)>;
4295pub type TheTruthDestroyedI = ::std::option::Option<unsafe extern "C" fn(tt: *mut TheTruthO)>;
4296pub const TM_THE_TRUTH_CREATE_TYPES_NONE: TheTruthCreateTypes = 0;
4297pub const TM_THE_TRUTH_CREATE_TYPES_ALL: TheTruthCreateTypes = 1;
4298pub type TheTruthCreateTypes = ::std::os::raw::c_int;
4299#[repr(C)]
4300#[derive(Copy, Clone)]
4301pub struct TheTruthGetTypesWithAspectT {
4302 pub type_: TtTypeT,
4303 pub data: *mut ::std::os::raw::c_void,
4304}
4305impl Default for TheTruthGetTypesWithAspectT {
4306 fn default() -> Self {
4307 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
4308 unsafe {
4309 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
4310 s.assume_init()
4311 }
4312 }
4313}
4314#[repr(C)]
4315#[derive(Copy, Clone)]
4316pub struct TheTruthGetAspectsT {
4317 pub id: StrhashT,
4318 pub data: *mut ::std::os::raw::c_void,
4319}
4320impl Default for TheTruthGetAspectsT {
4321 fn default() -> Self {
4322 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
4323 unsafe {
4324 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
4325 s.assume_init()
4326 }
4327 }
4328}
4329#[repr(C)]
4330#[derive(Copy, Clone)]
4331pub struct TheTruthLocalSetT {
4332 pub num_added: u32,
4333 pub _padding_524: [::std::os::raw::c_char; 4usize],
4334 pub added: *const TtIdT,
4335 pub num_removed: u32,
4336 pub _padding_529: [::std::os::raw::c_char; 4usize],
4337 pub removed: *const TtIdT,
4338 pub num_instantiated: u32,
4339 pub _padding_534: [::std::os::raw::c_char; 4usize],
4340 pub instantiated: *const TtIdT,
4341}
4342impl Default for TheTruthLocalSetT {
4343 fn default() -> Self {
4344 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
4345 unsafe {
4346 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
4347 s.assume_init()
4348 }
4349 }
4350}
4351#[repr(C)]
4352#[derive(Copy, Clone)]
4353pub struct TheTruthSetLocalSubobjectSetT {
4354 pub num_added: u32,
4355 pub _padding_543: [::std::os::raw::c_char; 4usize],
4356 pub added: *mut *mut TheTruthObjectO,
4357 pub num_removed: u32,
4358 pub _padding_548: [::std::os::raw::c_char; 4usize],
4359 pub removed: *const TtIdT,
4360 pub num_instantiated: u32,
4361 pub _padding_553: [::std::os::raw::c_char; 4usize],
4362 pub instantiated: *mut *mut TheTruthObjectO,
4363}
4364impl Default for TheTruthSetLocalSubobjectSetT {
4365 fn default() -> Self {
4366 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
4367 unsafe {
4368 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
4369 s.assume_init()
4370 }
4371 }
4372}
4373#[repr(C)]
4374#[derive(Copy, Clone)]
4375pub struct TheTruthChangedObjectsT {
4376 pub overflow: bool,
4377 pub _padding_563: [::std::os::raw::c_char; 3usize],
4378 pub num_objects: u32,
4379 pub objects: *mut TtIdT,
4380 pub version: u64,
4381}
4382impl Default for TheTruthChangedObjectsT {
4383 fn default() -> Self {
4384 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
4385 unsafe {
4386 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
4387 s.assume_init()
4388 }
4389 }
4390}
4391#[repr(C)]
4392#[derive(Copy, Clone)]
4393pub struct HashU64ToIdT {
4394 _unused: [u8; 0],
4395}
4396#[repr(C)]
4397#[derive(Copy, Clone)]
4398pub struct TheTruthInteropContextT {
4399 pub to_tt: *mut TheTruthO,
4400 pub from_tt: *mut TheTruthO,
4401 pub type_lookup: *mut Hash32T,
4402 pub property_lookup: *mut Hash32T,
4403 pub buffer_lookup: *mut Hash32T,
4404 pub object_lookup: *mut HashU64ToIdT,
4405}
4406impl Default for TheTruthInteropContextT {
4407 fn default() -> Self {
4408 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
4409 unsafe {
4410 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
4411 s.assume_init()
4412 }
4413 }
4414}
4415pub const TM_TT_PROTOTYPE_RELATION_ADDED: TheTruthPrototypeRelation = 0;
4416pub const TM_TT_PROTOTYPE_RELATION_ASSET: TheTruthPrototypeRelation = 1;
4417pub const TM_TT_PROTOTYPE_RELATION_INHERITED: TheTruthPrototypeRelation = 2;
4418pub const TM_TT_PROTOTYPE_RELATION_INSTANTIATED: TheTruthPrototypeRelation = 3;
4419pub const TM_TT_PROTOTYPE_RELATION_REMOVED: TheTruthPrototypeRelation = 4;
4420pub const TM_TT_PROTOTYPE_RELATION_NONE: TheTruthPrototypeRelation = 5;
4421pub type TheTruthPrototypeRelation = ::std::os::raw::c_int;
4422#[repr(C)]
4423#[derive(Copy, Clone)]
4424pub struct TtBufferT {
4425 pub id: u32,
4426 pub _padding_627: [::std::os::raw::c_char; 4usize],
4427 pub size: u64,
4428 pub data: *const ::std::os::raw::c_void,
4429 pub hash: u64,
4430}
4431impl Default for TtBufferT {
4432 fn default() -> Self {
4433 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
4434 unsafe {
4435 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
4436 s.assume_init()
4437 }
4438 }
4439}
4440#[repr(C)]
4441#[derive(Copy, Clone)]
4442pub struct TtPropValueT {
4443 pub type_: TheTruthPropertyType,
4444 pub _padding_643: [::std::os::raw::c_char; 4usize],
4445 pub __bindgen_anon_1: TtPropValueTBindgenTy1,
4446}
4447#[repr(C)]
4448#[derive(Copy, Clone)]
4449pub union TtPropValueTBindgenTy1 {
4450 pub b: bool,
4451 pub u32_: u32,
4452 pub u64_: u64,
4453 pub f32_: f32,
4454 pub f64_: f64,
4455 pub string: *const ::std::os::raw::c_char,
4456 pub buffer: TtBufferT,
4457 pub object: TtIdT,
4458 pub set: *const TtIdT,
4459}
4460impl Default for TtPropValueTBindgenTy1 {
4461 fn default() -> Self {
4462 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
4463 unsafe {
4464 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
4465 s.assume_init()
4466 }
4467 }
4468}
4469impl Default for TtPropValueT {
4470 fn default() -> Self {
4471 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
4472 unsafe {
4473 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
4474 s.assume_init()
4475 }
4476 }
4477}
4478#[repr(C)]
4479#[derive(Copy, Clone)]
4480pub struct TtUndoActionT {
4481 pub before: *const TheTruthObjectO,
4482 pub after: *const TheTruthObjectO,
4483}
4484impl Default for TtUndoActionT {
4485 fn default() -> Self {
4486 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
4487 unsafe {
4488 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
4489 s.assume_init()
4490 }
4491 }
4492}
4493#[repr(C)]
4494#[derive(Copy, Clone)]
4495pub struct TtSerializeOptionsT {
4496 pub serialize_buffers_as_hashes: bool,
4497 pub skip_type_index: bool,
4498 pub _padding_684: [::std::os::raw::c_char; 6usize],
4499 pub types: *mut SetT,
4500}
4501impl Default for TtSerializeOptionsT {
4502 fn default() -> Self {
4503 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
4504 unsafe {
4505 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
4506 s.assume_init()
4507 }
4508 }
4509}
4510pub const TM_THE_TRUTH_MAX_PROPERTIES: ::std::os::raw::c_int = 64;
4511pub type _bindgen_ty_1 = ::std::os::raw::c_int;
4512#[repr(C)]
4513#[derive(Copy, Clone)]
4514pub struct TheTruthSerializedTypeInfoT {
4515 pub runtime_type: TtTypeT,
4516 pub properties_differ: bool,
4517 pub _padding_706: [::std::os::raw::c_char; 3usize],
4518 pub num_properties: u32,
4519 pub serialized_property_to_runtime_property: [u32; 64usize],
4520 pub serialized_property_type: [u32; 64usize],
4521}
4522impl Default for TheTruthSerializedTypeInfoT {
4523 fn default() -> Self {
4524 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
4525 unsafe {
4526 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
4527 s.assume_init()
4528 }
4529 }
4530}
4531#[repr(C)]
4532#[derive(Copy, Clone)]
4533pub struct TtDeserializeOptionsT {
4534 pub buffers_preloaded: bool,
4535 pub skip_type_index: bool,
4536 pub _padding_731: [::std::os::raw::c_char; 6usize],
4537 pub type_infos: *const TheTruthSerializedTypeInfoT,
4538}
4539impl Default for TtDeserializeOptionsT {
4540 fn default() -> Self {
4541 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
4542 unsafe {
4543 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
4544 s.assume_init()
4545 }
4546 }
4547}
4548#[repr(C)]
4549#[derive(Default, Copy, Clone)]
4550pub struct TtSerializeChangesOptionsT {
4551 pub no_header: bool,
4552}
4553#[repr(C)]
4554#[derive(Copy, Clone)]
4555pub struct TtDeserializeChangesOptionsT {
4556 pub header: *const ::std::os::raw::c_char,
4557}
4558impl Default for TtDeserializeChangesOptionsT {
4559 fn default() -> Self {
4560 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
4561 unsafe {
4562 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
4563 s.assume_init()
4564 }
4565 }
4566}
4567#[repr(C)]
4568#[derive(Default, Copy, Clone)]
4569pub struct TtMemoryUseT {
4570 pub resident: u64,
4571 pub unloaded: u64,
4572}
4573#[repr(C)]
4574#[derive(Default, Copy, Clone)]
4575pub struct TheTruthApi {
4576 pub allocator:
4577 ::std::option::Option<unsafe extern "C" fn(tt: *mut TheTruthO) -> *mut AllocatorI>,
4578 pub buffers: ::std::option::Option<unsafe extern "C" fn(tt: *mut TheTruthO) -> *mut BuffersI>,
4579 pub streamable_buffers:
4580 ::std::option::Option<unsafe extern "C" fn(tt: *mut TheTruthO) -> *mut StreamableBuffersI>,
4581 pub create_object_type: ::std::option::Option<
4582 unsafe extern "C" fn(
4583 tt: *mut TheTruthO,
4584 name: *const ::std::os::raw::c_char,
4585 properties: *const TheTruthPropertyDefinitionT,
4586 num_properties: u32,
4587 ) -> TtTypeT,
4588 >,
4589 pub set_default_object: ::std::option::Option<
4590 unsafe extern "C" fn(tt: *mut TheTruthO, object_type: TtTypeT, object: TtIdT),
4591 >,
4592 pub set_default_object_to_create_subobjects:
4593 ::std::option::Option<unsafe extern "C" fn(tt: *mut TheTruthO, object_type: TtTypeT)>,
4594 pub default_object: ::std::option::Option<
4595 unsafe extern "C" fn(tt: *const TheTruthO, object_type: TtTypeT) -> TtIdT,
4596 >,
4597 pub is_default: ::std::option::Option<
4598 unsafe extern "C" fn(
4599 tt: *const TheTruthO,
4600 obj: *const TheTruthObjectO,
4601 property: u32,
4602 ) -> bool,
4603 >,
4604 pub set_aspect: ::std::option::Option<
4605 unsafe extern "C" fn(
4606 tt: *mut TheTruthO,
4607 object_type: TtTypeT,
4608 aspect: StrhashT,
4609 data: *const ::std::os::raw::c_void,
4610 ),
4611 >,
4612 pub set_default_aspect: ::std::option::Option<
4613 unsafe extern "C" fn(
4614 tt: *mut TheTruthO,
4615 aspect: StrhashT,
4616 data: *const ::std::os::raw::c_void,
4617 ),
4618 >,
4619 pub set_property_aspect: ::std::option::Option<
4620 unsafe extern "C" fn(
4621 tt: *mut TheTruthO,
4622 object_type: TtTypeT,
4623 property: u32,
4624 aspect: StrhashT,
4625 data: *const ::std::os::raw::c_void,
4626 ),
4627 >,
4628 pub reload_aspects: ::std::option::Option<unsafe extern "C" fn(tt: *mut TheTruthO)>,
4629 pub object_type_from_name_hash: ::std::option::Option<
4630 unsafe extern "C" fn(tt: *const TheTruthO, name_hash: StrhashT) -> TtTypeT,
4631 >,
4632 pub optional_object_type_from_name_hash: ::std::option::Option<
4633 unsafe extern "C" fn(tt: *const TheTruthO, name_hash: StrhashT) -> TtTypeT,
4634 >,
4635 pub num_types: ::std::option::Option<unsafe extern "C" fn(tt: *const TheTruthO) -> u32>,
4636 pub type_name: ::std::option::Option<
4637 unsafe extern "C" fn(
4638 tt: *const TheTruthO,
4639 object_type: TtTypeT,
4640 ) -> *const ::std::os::raw::c_char,
4641 >,
4642 pub type_name_hash: ::std::option::Option<
4643 unsafe extern "C" fn(tt: *const TheTruthO, object_type: TtTypeT) -> StrhashT,
4644 >,
4645 pub num_properties: ::std::option::Option<
4646 unsafe extern "C" fn(tt: *const TheTruthO, object_type: TtTypeT) -> u32,
4647 >,
4648 pub properties: ::std::option::Option<
4649 unsafe extern "C" fn(
4650 tt: *const TheTruthO,
4651 object_type: TtTypeT,
4652 ) -> *const TheTruthPropertyDefinitionT,
4653 >,
4654 pub find_property: ::std::option::Option<
4655 unsafe extern "C" fn(
4656 tt: *const TheTruthO,
4657 object_type: TtTypeT,
4658 name_hash: StrhashT,
4659 type_: TheTruthPropertyType,
4660 res: *mut u32,
4661 ) -> bool,
4662 >,
4663 pub property_index: ::std::option::Option<
4664 unsafe extern "C" fn(tt: *const TheTruthO, type_: TtTypeT, name_hash: StrhashT) -> u32,
4665 >,
4666 pub has_property: ::std::option::Option<
4667 unsafe extern "C" fn(tt: *const TheTruthO, type_: TtTypeT, name_hash: StrhashT) -> u32,
4668 >,
4669 pub get_aspect: ::std::option::Option<
4670 unsafe extern "C" fn(
4671 tt: *const TheTruthO,
4672 object_type: TtTypeT,
4673 aspect: StrhashT,
4674 ) -> *mut ::std::os::raw::c_void,
4675 >,
4676 pub get_types_with_aspect: ::std::option::Option<
4677 unsafe extern "C" fn(
4678 tt: *const TheTruthO,
4679 aspect: StrhashT,
4680 ta: *mut TempAllocatorI,
4681 ) -> *mut TheTruthGetTypesWithAspectT,
4682 >,
4683 pub get_aspects: ::std::option::Option<
4684 unsafe extern "C" fn(
4685 tt: *const TheTruthO,
4686 object_type: TtTypeT,
4687 ) -> *const TheTruthGetAspectsT,
4688 >,
4689 pub get_property_aspect: ::std::option::Option<
4690 unsafe extern "C" fn(
4691 tt: *const TheTruthO,
4692 object_type: TtTypeT,
4693 property: u32,
4694 aspect: StrhashT,
4695 ) -> *mut ::std::os::raw::c_void,
4696 >,
4697 pub all_objects_of_type: ::std::option::Option<
4698 unsafe extern "C" fn(
4699 tt: *const TheTruthO,
4700 object_type: TtTypeT,
4701 ta: *mut TempAllocatorI,
4702 ) -> *mut TtIdT,
4703 >,
4704 pub create_undo_scope: ::std::option::Option<
4705 unsafe extern "C" fn(
4706 tt: *mut TheTruthO,
4707 name: *const ::std::os::raw::c_char,
4708 ) -> TtUndoScopeT,
4709 >,
4710 pub create_thread_safe_undo_scope: ::std::option::Option<
4711 unsafe extern "C" fn(
4712 tt: *mut TheTruthO,
4713 name: *const ::std::os::raw::c_char,
4714 ) -> TtUndoScopeT,
4715 >,
4716 pub undo_scope_name: ::std::option::Option<
4717 unsafe extern "C" fn(
4718 tt: *mut TheTruthO,
4719 scope: TtUndoScopeT,
4720 ) -> *const ::std::os::raw::c_char,
4721 >,
4722 pub undo_scope_objects: ::std::option::Option<
4723 unsafe extern "C" fn(
4724 tt: *mut TheTruthO,
4725 scope: TtUndoScopeT,
4726 ta: *mut TempAllocatorI,
4727 ) -> *mut TtIdT,
4728 >,
4729 pub undo_scope_actions: ::std::option::Option<
4730 unsafe extern "C" fn(
4731 tt: *mut TheTruthO,
4732 scope: TtUndoScopeT,
4733 ta: *mut TempAllocatorI,
4734 ) -> *mut TtUndoActionT,
4735 >,
4736 pub undo: ::std::option::Option<unsafe extern "C" fn(tt: *mut TheTruthO, scope: TtUndoScopeT)>,
4737 pub redo: ::std::option::Option<unsafe extern "C" fn(tt: *mut TheTruthO, scope: TtUndoScopeT)>,
4738 pub create_object_of_type: ::std::option::Option<
4739 unsafe extern "C" fn(tt: *mut TheTruthO, type_: TtTypeT, undo_scope: TtUndoScopeT) -> TtIdT,
4740 >,
4741 pub create_object_of_hash: ::std::option::Option<
4742 unsafe extern "C" fn(
4743 tt: *mut TheTruthO,
4744 type_name_hash: StrhashT,
4745 undo_scope: TtUndoScopeT,
4746 ) -> TtIdT,
4747 >,
4748 pub create_object_from_prototype: ::std::option::Option<
4749 unsafe extern "C" fn(
4750 tt: *mut TheTruthO,
4751 prototype: TtIdT,
4752 undo_scope: TtUndoScopeT,
4753 ) -> TtIdT,
4754 >,
4755 pub clone_object: ::std::option::Option<
4756 unsafe extern "C" fn(tt: *mut TheTruthO, object: TtIdT, undo_scope: TtUndoScopeT) -> TtIdT,
4757 >,
4758 pub instantiate_subobject: ::std::option::Option<
4759 unsafe extern "C" fn(
4760 tt: *mut TheTruthO,
4761 obj: *mut TheTruthObjectO,
4762 property: u32,
4763 undo_scope: TtUndoScopeT,
4764 ) -> TtIdT,
4765 >,
4766 pub remove_instantiated_subobject: ::std::option::Option<
4767 unsafe extern "C" fn(
4768 tt: *mut TheTruthO,
4769 obj: *mut TheTruthObjectO,
4770 property: u32,
4771 undo_scope: TtUndoScopeT,
4772 ),
4773 >,
4774 pub instantiate_subobject_from_set: ::std::option::Option<
4775 unsafe extern "C" fn(
4776 tt: *mut TheTruthO,
4777 obj: *mut TheTruthObjectO,
4778 property: u32,
4779 subobject: TtIdT,
4780 undo_scope: TtUndoScopeT,
4781 ) -> TtIdT,
4782 >,
4783 pub remove_instantiated_subobject_from_set: ::std::option::Option<
4784 unsafe extern "C" fn(
4785 tt: *mut TheTruthO,
4786 obj: *mut TheTruthObjectO,
4787 property: u32,
4788 subobject: TtIdT,
4789 undo_scope: TtUndoScopeT,
4790 ),
4791 >,
4792 pub add_instantiated_subobject_back_to_set: ::std::option::Option<
4793 unsafe extern "C" fn(
4794 tt: *mut TheTruthO,
4795 obj: *mut TheTruthObjectO,
4796 property: u32,
4797 subobject: TtIdT,
4798 ),
4799 >,
4800 pub id: ::std::option::Option<unsafe extern "C" fn(obj: *const TheTruthObjectO) -> TtIdT>,
4801 pub destroy_object: ::std::option::Option<
4802 unsafe extern "C" fn(tt: *mut TheTruthO, object: TtIdT, undo_scope: TtUndoScopeT),
4803 >,
4804 pub destroy_objects: ::std::option::Option<
4805 unsafe extern "C" fn(
4806 tt: *mut TheTruthO,
4807 object: *const TtIdT,
4808 n: u32,
4809 undo_scope: TtUndoScopeT,
4810 ),
4811 >,
4812 pub garbage_collect: ::std::option::Option<unsafe extern "C" fn(tt: *mut TheTruthO)>,
4813 pub is_alive:
4814 ::std::option::Option<unsafe extern "C" fn(tt: *const TheTruthO, object: TtIdT) -> bool>,
4815 pub interop_ensure_compatibility:
4816 ::std::option::Option<unsafe extern "C" fn(ctx: *mut TheTruthInteropContextT)>,
4817 pub interop_clone_object: ::std::option::Option<
4818 unsafe extern "C" fn(ctx: *mut TheTruthInteropContextT, object: TtIdT) -> TtIdT,
4819 >,
4820 pub deep_clone_assets: ::std::option::Option<
4821 unsafe extern "C" fn(
4822 to_tt: *mut TheTruthO,
4823 from_tt: *const TheTruthO,
4824 assets: *const TtIdT,
4825 n: u32,
4826 undo_scope: TtUndoScopeT,
4827 ta: *mut TempAllocatorI,
4828 ) -> *mut TtIdT,
4829 >,
4830 pub uuid:
4831 ::std::option::Option<unsafe extern "C" fn(tt: *const TheTruthO, object: TtIdT) -> UuidT>,
4832 pub read: ::std::option::Option<
4833 unsafe extern "C" fn(tt: *const TheTruthO, object: TtIdT) -> *const TheTruthObjectO,
4834 >,
4835 pub get_bool: ::std::option::Option<
4836 unsafe extern "C" fn(
4837 tt: *const TheTruthO,
4838 obj: *const TheTruthObjectO,
4839 property: u32,
4840 ) -> bool,
4841 >,
4842 pub get_uint32_t: ::std::option::Option<
4843 unsafe extern "C" fn(
4844 tt: *const TheTruthO,
4845 obj: *const TheTruthObjectO,
4846 property: u32,
4847 ) -> u32,
4848 >,
4849 pub get_uint64_t: ::std::option::Option<
4850 unsafe extern "C" fn(
4851 tt: *const TheTruthO,
4852 obj: *const TheTruthObjectO,
4853 property: u32,
4854 ) -> u64,
4855 >,
4856 pub get_float: ::std::option::Option<
4857 unsafe extern "C" fn(
4858 tt: *const TheTruthO,
4859 obj: *const TheTruthObjectO,
4860 property: u32,
4861 ) -> f32,
4862 >,
4863 pub get_double: ::std::option::Option<
4864 unsafe extern "C" fn(
4865 tt: *const TheTruthO,
4866 obj: *const TheTruthObjectO,
4867 property: u32,
4868 ) -> f64,
4869 >,
4870 pub get_string: ::std::option::Option<
4871 unsafe extern "C" fn(
4872 tt: *const TheTruthO,
4873 obj: *const TheTruthObjectO,
4874 property: u32,
4875 ) -> *const ::std::os::raw::c_char,
4876 >,
4877 pub get_string_hash: ::std::option::Option<
4878 unsafe extern "C" fn(
4879 tt: *const TheTruthO,
4880 obj: *const TheTruthObjectO,
4881 property: u32,
4882 ) -> StrhashT,
4883 >,
4884 pub get_str: ::std::option::Option<
4885 unsafe extern "C" fn(
4886 tt: *const TheTruthO,
4887 obj: *const TheTruthObjectO,
4888 property: u32,
4889 ) -> StrT,
4890 >,
4891 pub get_buffer: ::std::option::Option<
4892 unsafe extern "C" fn(
4893 tt: *const TheTruthO,
4894 obj: *const TheTruthObjectO,
4895 property: u32,
4896 ) -> TtBufferT,
4897 >,
4898 pub get_buffer_id: ::std::option::Option<
4899 unsafe extern "C" fn(
4900 tt: *const TheTruthO,
4901 obj: *const TheTruthObjectO,
4902 property: u32,
4903 ) -> u32,
4904 >,
4905 pub get_reference: ::std::option::Option<
4906 unsafe extern "C" fn(
4907 tt: *const TheTruthO,
4908 obj: *const TheTruthObjectO,
4909 property: u32,
4910 ) -> TtIdT,
4911 >,
4912 pub get_subobject: ::std::option::Option<
4913 unsafe extern "C" fn(
4914 tt: *const TheTruthO,
4915 obj: *const TheTruthObjectO,
4916 property: u32,
4917 ) -> TtIdT,
4918 >,
4919 pub get_property_value: ::std::option::Option<
4920 unsafe extern "C" fn(
4921 tt: *const TheTruthO,
4922 obj: *const TheTruthObjectO,
4923 property: u32,
4924 ta: *mut TempAllocatorI,
4925 ) -> TtPropValueT,
4926 >,
4927 pub property_value_equal:
4928 ::std::option::Option<unsafe extern "C" fn(a: TtPropValueT, b: TtPropValueT) -> bool>,
4929 pub get_reference_set: ::std::option::Option<
4930 unsafe extern "C" fn(
4931 tt: *const TheTruthO,
4932 obj: *const TheTruthObjectO,
4933 property: u32,
4934 ta: *mut TempAllocatorI,
4935 ) -> *const TtIdT,
4936 >,
4937 pub get_subobject_set: ::std::option::Option<
4938 unsafe extern "C" fn(
4939 tt: *const TheTruthO,
4940 obj: *const TheTruthObjectO,
4941 property: u32,
4942 ta: *mut TempAllocatorI,
4943 ) -> *const TtIdT,
4944 >,
4945 pub get_reference_set_size: ::std::option::Option<
4946 unsafe extern "C" fn(
4947 tt: *const TheTruthO,
4948 obj: *const TheTruthObjectO,
4949 property: u32,
4950 ) -> u64,
4951 >,
4952 pub get_subobject_set_size: ::std::option::Option<
4953 unsafe extern "C" fn(
4954 tt: *const TheTruthO,
4955 obj: *const TheTruthObjectO,
4956 property: u32,
4957 ) -> u64,
4958 >,
4959 pub get_subobject_set_type: ::std::option::Option<
4960 unsafe extern "C" fn(
4961 tt: *const TheTruthO,
4962 obj: *const TheTruthObjectO,
4963 property: u32,
4964 ) -> TtTypeT,
4965 >,
4966 pub get_subobject_set_locally_removed: ::std::option::Option<
4967 unsafe extern "C" fn(
4968 tt: *const TheTruthO,
4969 obj: *const TheTruthObjectO,
4970 property: u32,
4971 ta: *mut TempAllocatorI,
4972 ) -> *const TtIdT,
4973 >,
4974 pub find_subobject_of_type: ::std::option::Option<
4975 unsafe extern "C" fn(
4976 tt: *const TheTruthO,
4977 obj: *const TheTruthObjectO,
4978 property: u32,
4979 type_: TtTypeT,
4980 ) -> TtIdT,
4981 >,
4982 pub is_subobject_of: ::std::option::Option<
4983 unsafe extern "C" fn(
4984 tt: *const TheTruthO,
4985 obj: *const TheTruthObjectO,
4986 property: u32,
4987 subobject: TtIdT,
4988 ) -> bool,
4989 >,
4990 pub is_in_reference_set: ::std::option::Option<
4991 unsafe extern "C" fn(
4992 tt: *const TheTruthO,
4993 obj: *const TheTruthObjectO,
4994 property: u32,
4995 object: TtIdT,
4996 ) -> bool,
4997 >,
4998 pub property_index_of_subobject: ::std::option::Option<
4999 unsafe extern "C" fn(tt: *const TheTruthO, object: TtIdT, subobject: TtIdT) -> u32,
5000 >,
5001 pub write: ::std::option::Option<
5002 unsafe extern "C" fn(tt: *mut TheTruthO, object: TtIdT) -> *mut TheTruthObjectO,
5003 >,
5004 pub commit: ::std::option::Option<
5005 unsafe extern "C" fn(
5006 tt: *mut TheTruthO,
5007 obj: *mut TheTruthObjectO,
5008 undo_scope: TtUndoScopeT,
5009 ),
5010 >,
5011 pub commit_range: ::std::option::Option<
5012 unsafe extern "C" fn(
5013 tt: *mut TheTruthO,
5014 obj: *mut *mut TheTruthObjectO,
5015 n: u32,
5016 undo_scope: TtUndoScopeT,
5017 ),
5018 >,
5019 pub retarget_write: ::std::option::Option<
5020 unsafe extern "C" fn(tt: *mut TheTruthO, obj: *mut TheTruthObjectO, object: TtIdT),
5021 >,
5022 pub try_write: ::std::option::Option<
5023 unsafe extern "C" fn(
5024 tt: *mut TheTruthO,
5025 object: TtIdT,
5026 original: *mut *const TheTruthObjectO,
5027 ) -> *mut TheTruthObjectO,
5028 >,
5029 pub try_commit: ::std::option::Option<
5030 unsafe extern "C" fn(
5031 tt: *mut TheTruthO,
5032 obj: *mut TheTruthObjectO,
5033 original: *const TheTruthObjectO,
5034 undo_scope: TtUndoScopeT,
5035 ) -> bool,
5036 >,
5037 pub set_bool: ::std::option::Option<
5038 unsafe extern "C" fn(
5039 tt: *mut TheTruthO,
5040 obj: *mut TheTruthObjectO,
5041 property: u32,
5042 value: bool,
5043 ),
5044 >,
5045 pub set_uint32_t: ::std::option::Option<
5046 unsafe extern "C" fn(
5047 tt: *mut TheTruthO,
5048 obj: *mut TheTruthObjectO,
5049 property: u32,
5050 value: u32,
5051 ),
5052 >,
5053 pub set_uint64_t: ::std::option::Option<
5054 unsafe extern "C" fn(
5055 tt: *mut TheTruthO,
5056 obj: *mut TheTruthObjectO,
5057 property: u32,
5058 value: u64,
5059 ),
5060 >,
5061 pub set_float: ::std::option::Option<
5062 unsafe extern "C" fn(
5063 tt: *mut TheTruthO,
5064 obj: *mut TheTruthObjectO,
5065 property: u32,
5066 value: f32,
5067 ),
5068 >,
5069 pub set_double: ::std::option::Option<
5070 unsafe extern "C" fn(
5071 tt: *mut TheTruthO,
5072 obj: *mut TheTruthObjectO,
5073 property: u32,
5074 value: f64,
5075 ),
5076 >,
5077 pub set_string: ::std::option::Option<
5078 unsafe extern "C" fn(
5079 tt: *mut TheTruthO,
5080 obj: *mut TheTruthObjectO,
5081 property: u32,
5082 value: *const ::std::os::raw::c_char,
5083 ),
5084 >,
5085 pub set_str: ::std::option::Option<
5086 unsafe extern "C" fn(
5087 tt: *mut TheTruthO,
5088 obj: *mut TheTruthObjectO,
5089 property: u32,
5090 value: StrT,
5091 ),
5092 >,
5093 pub set_buffer: ::std::option::Option<
5094 unsafe extern "C" fn(
5095 tt: *mut TheTruthO,
5096 obj: *mut TheTruthObjectO,
5097 property: u32,
5098 value: u32,
5099 ),
5100 >,
5101 pub set_buffer_content: ::std::option::Option<
5102 unsafe extern "C" fn(
5103 tt: *mut TheTruthO,
5104 obj: *mut TheTruthObjectO,
5105 property: u32,
5106 p: *mut ::std::os::raw::c_void,
5107 size: u64,
5108 ),
5109 >,
5110 pub set_reference: ::std::option::Option<
5111 unsafe extern "C" fn(
5112 tt: *mut TheTruthO,
5113 obj: *mut TheTruthObjectO,
5114 property: u32,
5115 value: TtIdT,
5116 ),
5117 >,
5118 pub set_subobject: ::std::option::Option<
5119 unsafe extern "C" fn(
5120 tt: *mut TheTruthO,
5121 obj: *mut TheTruthObjectO,
5122 property: u32,
5123 value: *mut TheTruthObjectO,
5124 ),
5125 >,
5126 pub set_subobject_id: ::std::option::Option<
5127 unsafe extern "C" fn(
5128 tt: *mut TheTruthO,
5129 obj: *mut TheTruthObjectO,
5130 property: u32,
5131 value: TtIdT,
5132 undo_scope: TtUndoScopeT,
5133 ),
5134 >,
5135 pub set_property_value: ::std::option::Option<
5136 unsafe extern "C" fn(
5137 tt: *mut TheTruthO,
5138 obj: *mut TheTruthObjectO,
5139 property: u32,
5140 value: TtPropValueT,
5141 undo_scope: TtUndoScopeT,
5142 ),
5143 >,
5144 pub clear: ::std::option::Option<
5145 unsafe extern "C" fn(tt: *mut TheTruthO, obj: *mut TheTruthObjectO, property: u32),
5146 >,
5147 pub clear_object:
5148 ::std::option::Option<unsafe extern "C" fn(tt: *mut TheTruthO, obj: *mut TheTruthObjectO)>,
5149 pub propagate_property: ::std::option::Option<
5150 unsafe extern "C" fn(
5151 tt: *mut TheTruthO,
5152 object: TtIdT,
5153 property: u32,
5154 undo_scope: TtUndoScopeT,
5155 ),
5156 >,
5157 pub propagate_property_except: ::std::option::Option<
5158 unsafe extern "C" fn(
5159 tt: *mut TheTruthO,
5160 object: TtIdT,
5161 property: u32,
5162 skip: *const TtIdT,
5163 num_skip: u32,
5164 undo_scope: TtUndoScopeT,
5165 ),
5166 >,
5167 pub propagate_property_subobject: ::std::option::Option<
5168 unsafe extern "C" fn(
5169 tt: *mut TheTruthO,
5170 object: TtIdT,
5171 property: u32,
5172 subobject: TtIdT,
5173 undo_scope: TtUndoScopeT,
5174 ),
5175 >,
5176 pub propagate_object: ::std::option::Option<
5177 unsafe extern "C" fn(tt: *mut TheTruthO, object: TtIdT, undo_scope: TtUndoScopeT),
5178 >,
5179 pub propagate_object_except: ::std::option::Option<
5180 unsafe extern "C" fn(
5181 tt: *mut TheTruthO,
5182 object: TtIdT,
5183 skip: *const TtIdT,
5184 num_skip: u32,
5185 undo_scope: TtUndoScopeT,
5186 ),
5187 >,
5188 pub add_to_reference_set: ::std::option::Option<
5189 unsafe extern "C" fn(
5190 tt: *mut TheTruthO,
5191 obj: *mut TheTruthObjectO,
5192 property: u32,
5193 items: *const TtIdT,
5194 count: u32,
5195 ),
5196 >,
5197 pub remove_from_reference_set: ::std::option::Option<
5198 unsafe extern "C" fn(
5199 tt: *mut TheTruthO,
5200 obj: *mut TheTruthObjectO,
5201 property: u32,
5202 items: *const TtIdT,
5203 count: u32,
5204 ),
5205 >,
5206 pub clear_reference_set: ::std::option::Option<
5207 unsafe extern "C" fn(tt: *mut TheTruthO, obj: *mut TheTruthObjectO, property: u32),
5208 >,
5209 pub remove_from_prototype_reference_set: ::std::option::Option<
5210 unsafe extern "C" fn(
5211 tt: *mut TheTruthO,
5212 obj: *mut TheTruthObjectO,
5213 property: u32,
5214 items: *const TtIdT,
5215 count: u32,
5216 ),
5217 >,
5218 pub cancel_remove_from_prototype_reference_set: ::std::option::Option<
5219 unsafe extern "C" fn(
5220 tt: *mut TheTruthO,
5221 obj: *mut TheTruthObjectO,
5222 property: u32,
5223 items: *const TtIdT,
5224 count: u32,
5225 ),
5226 >,
5227 pub add_to_subobject_set: ::std::option::Option<
5228 unsafe extern "C" fn(
5229 tt: *mut TheTruthO,
5230 obj: *mut TheTruthObjectO,
5231 property: u32,
5232 items: *mut *mut TheTruthObjectO,
5233 count: u32,
5234 ),
5235 >,
5236 pub add_to_subobject_set_id: ::std::option::Option<
5237 unsafe extern "C" fn(
5238 tt: *mut TheTruthO,
5239 obj: *mut TheTruthObjectO,
5240 property: u32,
5241 items: *const TtIdT,
5242 count: u32,
5243 undo_scope: TtUndoScopeT,
5244 ),
5245 >,
5246 pub remove_from_subobject_set: ::std::option::Option<
5247 unsafe extern "C" fn(
5248 tt: *mut TheTruthO,
5249 obj: *mut TheTruthObjectO,
5250 property: u32,
5251 items: *const TtIdT,
5252 count: u32,
5253 ),
5254 >,
5255 pub clear_subobject_set: ::std::option::Option<
5256 unsafe extern "C" fn(tt: *mut TheTruthO, obj: *mut TheTruthObjectO, property: u32),
5257 >,
5258 pub remove_from_prototype_subobject_set: ::std::option::Option<
5259 unsafe extern "C" fn(
5260 tt: *mut TheTruthO,
5261 obj: *mut TheTruthObjectO,
5262 property: u32,
5263 items: *const TtIdT,
5264 count: u32,
5265 ),
5266 >,
5267 pub cancel_remove_from_prototype_subobject_set: ::std::option::Option<
5268 unsafe extern "C" fn(
5269 tt: *mut TheTruthO,
5270 obj: *mut TheTruthObjectO,
5271 property: u32,
5272 items: *const TtIdT,
5273 count: u32,
5274 ),
5275 >,
5276 pub prototype:
5277 ::std::option::Option<unsafe extern "C" fn(tt: *const TheTruthO, object: TtIdT) -> TtIdT>,
5278 pub owner:
5279 ::std::option::Option<unsafe extern "C" fn(tt: *const TheTruthO, object: TtIdT) -> TtIdT>,
5280 pub is_currently_owner_of: ::std::option::Option<
5281 unsafe extern "C" fn(tt: *const TheTruthO, object: TtIdT, subobject: TtIdT) -> bool,
5282 >,
5283 pub is_overridden: ::std::option::Option<
5284 unsafe extern "C" fn(
5285 tt: *const TheTruthO,
5286 obj: *const TheTruthObjectO,
5287 property: u32,
5288 ) -> bool,
5289 >,
5290 pub has_data: ::std::option::Option<
5291 unsafe extern "C" fn(
5292 tt: *const TheTruthO,
5293 obj: *const TheTruthObjectO,
5294 property: u32,
5295 ) -> bool,
5296 >,
5297 pub prototype_relation: ::std::option::Option<
5298 unsafe extern "C" fn(
5299 tt: *const TheTruthO,
5300 parent: TtIdT,
5301 property: u32,
5302 object: TtIdT,
5303 ) -> TheTruthPrototypeRelation,
5304 >,
5305 pub version:
5306 ::std::option::Option<unsafe extern "C" fn(tt: *const TheTruthO, object: TtIdT) -> u32>,
5307 pub changed_objects: ::std::option::Option<
5308 unsafe extern "C" fn(
5309 tt: *const TheTruthO,
5310 type_: TtTypeT,
5311 since_version: u64,
5312 ta: *mut TempAllocatorI,
5313 ) -> TheTruthChangedObjectsT,
5314 >,
5315 pub request_changelog: ::std::option::Option<unsafe extern "C" fn(tt: *mut TheTruthO) -> u64>,
5316 pub relinquish_changelog:
5317 ::std::option::Option<unsafe extern "C" fn(tt: *mut TheTruthO, h: u64)>,
5318 pub disable_changelog_start_scope:
5319 ::std::option::Option<unsafe extern "C" fn(tt: *mut TheTruthO)>,
5320 pub disable_changelog_end_scope:
5321 ::std::option::Option<unsafe extern "C" fn(tt: *mut TheTruthO)>,
5322 pub changelog_size: ::std::option::Option<unsafe extern "C" fn(tt: *mut TheTruthO) -> u64>,
5323 pub serialize: ::std::option::Option<
5324 unsafe extern "C" fn(
5325 tt: *mut TheTruthO,
5326 o: TtIdT,
5327 carray: *mut *mut ::std::os::raw::c_char,
5328 a: *mut AllocatorI,
5329 opt: *const TtSerializeOptionsT,
5330 ),
5331 >,
5332 pub deserialize: ::std::option::Option<
5333 unsafe extern "C" fn(
5334 tt: *mut TheTruthO,
5335 buffer: *mut *const ::std::os::raw::c_char,
5336 opt: *const TtDeserializeOptionsT,
5337 ) -> TtIdT,
5338 >,
5339 pub buffer_hashes: ::std::option::Option<
5340 unsafe extern "C" fn(
5341 buffer: *mut *const ::std::os::raw::c_char,
5342 count: *mut u64,
5343 ) -> *const u64,
5344 >,
5345 pub deserialize_from_file: ::std::option::Option<
5346 unsafe extern "C" fn(tt: *mut TheTruthO, file: *const ::std::os::raw::c_char) -> TtIdT,
5347 >,
5348 pub migration_ids: ::std::option::Option<
5349 unsafe extern "C" fn(tt: *const TheTruthO, n: *mut u32) -> *mut StrhashT,
5350 >,
5351 pub serialize_changes_header: ::std::option::Option<
5352 unsafe extern "C" fn(
5353 tt: *mut TheTruthO,
5354 carray: *mut *mut ::std::os::raw::c_char,
5355 a: *mut AllocatorI,
5356 ),
5357 >,
5358 pub serialize_changes: ::std::option::Option<
5359 unsafe extern "C" fn(
5360 tt: *mut TheTruthO,
5361 begin: u64,
5362 end: u64,
5363 carray: *mut *mut ::std::os::raw::c_char,
5364 a: *mut AllocatorI,
5365 opt: *const TtSerializeChangesOptionsT,
5366 ),
5367 >,
5368 pub deserialize_changes: ::std::option::Option<
5369 unsafe extern "C" fn(
5370 tt: *mut TheTruthO,
5371 buffer: *mut *const ::std::os::raw::c_char,
5372 opt: *const TtDeserializeChangesOptionsT,
5373 ),
5374 >,
5375 pub serialize_patch: ::std::option::Option<
5376 unsafe extern "C" fn(
5377 from_tt: *mut TheTruthO,
5378 from_o: TtIdT,
5379 to_tt: *mut TheTruthO,
5380 to_o: TtIdT,
5381 carray: *mut *mut ::std::os::raw::c_char,
5382 a: *mut AllocatorI,
5383 ),
5384 >,
5385 pub deserialize_patch: ::std::option::Option<
5386 unsafe extern "C" fn(tt: *mut TheTruthO, buffer: *mut *const ::std::os::raw::c_char),
5387 >,
5388 pub deserialize_patch_from_file: ::std::option::Option<
5389 unsafe extern "C" fn(tt: *mut TheTruthO, file: *const ::std::os::raw::c_char),
5390 >,
5391 pub serialize_type: ::std::option::Option<
5392 unsafe extern "C" fn(
5393 tt: *mut TheTruthO,
5394 type_: u32,
5395 ta: *mut TempAllocatorI,
5396 ) -> *mut ::std::os::raw::c_char,
5397 >,
5398 pub deserialize_type: ::std::option::Option<
5399 unsafe extern "C" fn(
5400 tt: *mut TheTruthO,
5401 buf: *mut *const ::std::os::raw::c_char,
5402 type_info: *mut TheTruthSerializedTypeInfoT,
5403 ),
5404 >,
5405 pub memory_use: ::std::option::Option<
5406 unsafe extern "C" fn(tt: *mut TheTruthO, id: TtIdT, buffers: *mut SetT) -> TtMemoryUseT,
5407 >,
5408 pub add_properties: ::std::option::Option<
5409 unsafe extern "C" fn(
5410 tt: *mut TheTruthO,
5411 type_: TtTypeT,
5412 properties: *const TheTruthPropertyDefinitionT,
5413 num_properties: u32,
5414 ),
5415 >,
5416 pub resolve_or_create_placeholder: ::std::option::Option<
5417 unsafe extern "C" fn(
5418 tt: *mut TheTruthO,
5419 uuid: UuidT,
5420 type_: TtTypeT,
5421 default_initialize: bool,
5422 ) -> TtIdT,
5423 >,
5424 pub resolve_or_fail: ::std::option::Option<
5425 unsafe extern "C" fn(tt: *mut TheTruthO, uuid: UuidT, type_: TtTypeT) -> TtIdT,
5426 >,
5427 pub set_uuid:
5428 ::std::option::Option<unsafe extern "C" fn(tt: *mut TheTruthO, id: TtIdT, uuid: UuidT)>,
5429 pub set_prototype: ::std::option::Option<
5430 unsafe extern "C" fn(tt: *mut TheTruthO, obj: *mut TheTruthObjectO, id: TtIdT),
5431 >,
5432 pub detach_from_prototype: ::std::option::Option<
5433 unsafe extern "C" fn(
5434 tt: *mut TheTruthO,
5435 id: TtIdT,
5436 lookup: *mut HashIdToIdT,
5437 undo_scope: TtUndoScopeT,
5438 ),
5439 >,
5440 pub detach_all_instances: ::std::option::Option<
5441 unsafe extern "C" fn(tt: *mut TheTruthO, id: TtIdT, undo_scope: TtUndoScopeT),
5442 >,
5443 pub get_local_reference_set: ::std::option::Option<
5444 unsafe extern "C" fn(
5445 tt: *const TheTruthO,
5446 obj: *const TheTruthObjectO,
5447 property: u32,
5448 ) -> TheTruthLocalSetT,
5449 >,
5450 pub get_local_subobject_set: ::std::option::Option<
5451 unsafe extern "C" fn(
5452 tt: *const TheTruthO,
5453 obj: *const TheTruthObjectO,
5454 property: u32,
5455 ) -> TheTruthLocalSetT,
5456 >,
5457 pub set_local_reference_set: ::std::option::Option<
5458 unsafe extern "C" fn(
5459 tt: *mut TheTruthO,
5460 obj: *mut TheTruthObjectO,
5461 property: u32,
5462 set: TheTruthLocalSetT,
5463 ),
5464 >,
5465 pub set_local_subobject_set: ::std::option::Option<
5466 unsafe extern "C" fn(
5467 tt: *mut TheTruthO,
5468 obj: *mut TheTruthObjectO,
5469 property: u32,
5470 set: TheTruthSetLocalSubobjectSetT,
5471 ),
5472 >,
5473 pub string_repository:
5474 ::std::option::Option<unsafe extern "C" fn(tt: *mut TheTruthO) -> *mut StringRepositoryI>,
5475 pub set_migration_ids:
5476 ::std::option::Option<unsafe extern "C" fn(tt: *mut TheTruthO, ids: *mut StrhashT, n: u32)>,
5477 pub set_properties_to_default: ::std::option::Option<
5478 unsafe extern "C" fn(tt: *mut TheTruthO, obj: *mut TheTruthObjectO, mask: u64),
5479 >,
5480 pub instantiate_subobjects_recursively: ::std::option::Option<
5481 unsafe extern "C" fn(tt: *mut TheTruthO, object: TtIdT, undo_scope: TtUndoScopeT),
5482 >,
5483 pub quick_set_properties: ::std::option::Option<
5484 unsafe extern "C" fn(tt: *mut TheTruthO, undo_scope: TtUndoScopeT, id: TtIdT, ...),
5485 >,
5486 pub quick_create_object: ::std::option::Option<
5487 unsafe extern "C" fn(
5488 tt: *mut TheTruthO,
5489 undo_scope: TtUndoScopeT,
5490 type_hash: StrhashT,
5491 ...
5492 ) -> TtIdT,
5493 >,
5494 pub quick_get_property: ::std::option::Option<
5495 unsafe extern "C" fn(tt: *const TheTruthO, id: TtIdT, prop_1: u32, ...) -> TtPropValueT,
5496 >,
5497 pub copy_properties_by_name: ::std::option::Option<
5498 unsafe extern "C" fn(t: *mut TheTruthO, to: TtIdT, from: TtIdT, undo_scope: TtUndoScopeT),
5499 >,
5500 pub internal__make_into_pseudo_object_with_owner: ::std::option::Option<
5501 unsafe extern "C" fn(tt: *mut TheTruthO, obj: *mut TheTruthObjectO, owner: TtIdT),
5502 >,
5503 pub internal__convert_pseudo_object_back_to_regular_object:
5504 ::std::option::Option<unsafe extern "C" fn(tt: *mut TheTruthO, obj: *mut TheTruthObjectO)>,
5505 pub debug_inspect: ::std::option::Option<
5506 unsafe extern "C" fn(tt: *const TheTruthO, object: TtIdT) -> *const ::std::os::raw::c_char,
5507 >,
5508 pub internal__detect_overlapping_writes:
5509 ::std::option::Option<unsafe extern "C" fn(tt: *const TheTruthO) -> bool>,
5510 pub create: ::std::option::Option<
5511 unsafe extern "C" fn(a: *mut AllocatorI, types: TheTruthCreateTypes) -> *mut TheTruthO,
5512 >,
5513 pub destroy: ::std::option::Option<unsafe extern "C" fn(tt: *mut TheTruthO)>,
5514}
5515pub const TM_TT_PROP__ASSET_ROOT__ASSETS: ::std::os::raw::c_int = 0;
5516pub const TM_TT_PROP__ASSET_ROOT__DIRECTORIES: ::std::os::raw::c_int = 1;
5517pub type _bindgen_ty_2 = ::std::os::raw::c_int;
5518pub const TM_TT_PROP__ASSET__NAME: ::std::os::raw::c_int = 0;
5519pub const TM_TT_PROP__ASSET__DIRECTORY: ::std::os::raw::c_int = 1;
5520pub const TM_TT_PROP__ASSET__UUID_LABELS: ::std::os::raw::c_int = 2;
5521pub const TM_TT_PROP__ASSET__OBJECT: ::std::os::raw::c_int = 3;
5522pub const TM_TT_PROP__ASSET__THUMBNAIL: ::std::os::raw::c_int = 4;
5523pub type _bindgen_ty_3 = ::std::os::raw::c_int;
5524pub const TM_TT_PROP__ASSET_DIRECTORY__NAME: ::std::os::raw::c_int = 0;
5525pub const TM_TT_PROP__ASSET_DIRECTORY__PARENT: ::std::os::raw::c_int = 1;
5526pub type _bindgen_ty_4 = ::std::os::raw::c_int;
5527pub const TM_TT_PROP__ASSET_LABEL__UUID: ::std::os::raw::c_int = 0;
5528pub type _bindgen_ty_5 = ::std::os::raw::c_int;
5529#[repr(C)]
5530#[derive(Default, Copy, Clone)]
5531pub struct AssetLabelUuidT {
5532 pub uuid: u64,
5533}
5534#[repr(C)]
5535#[derive(Copy, Clone)]
5536pub struct AssetLabelT {
5537 pub uuid: AssetLabelUuidT,
5538 pub name: *const ::std::os::raw::c_char,
5539 pub icon: u32,
5540 pub icon_color: u32,
5541}
5542impl Default for AssetLabelT {
5543 fn default() -> Self {
5544 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
5545 unsafe {
5546 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
5547 s.assume_init()
5548 }
5549 }
5550}
5551pub type TtAssetsFileExtensionAspectI = ::std::os::raw::c_char;
5552pub const TM_TT_PROP__ASSET_THUMBNAIL__THUMBNAIL: ::std::os::raw::c_int = 0;
5553pub const TM_TT_PROP__ASSET_THUMBNAIL__VALIDITY_HASH: ::std::os::raw::c_int = 1;
5554pub type _bindgen_ty_6 = ::std::os::raw::c_int;
5555#[repr(C)]
5556#[derive(Copy, Clone)]
5557pub struct TtAssetsBufferWriteT {
5558 pub id: u32,
5559 pub _padding_126: [::std::os::raw::c_char; 4usize],
5560 pub hash: u64,
5561 pub ext: *const ::std::os::raw::c_char,
5562}
5563impl Default for TtAssetsBufferWriteT {
5564 fn default() -> Self {
5565 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
5566 unsafe {
5567 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
5568 s.assume_init()
5569 }
5570 }
5571}
5572#[repr(C)]
5573#[derive(Copy, Clone)]
5574pub struct TtAssetsBufferT {
5575 pub object_id: TtIdT,
5576 pub property_index: u32,
5577 pub _padding_143: [::std::os::raw::c_char; 4usize],
5578 pub hash: u64,
5579}
5580impl Default for TtAssetsBufferT {
5581 fn default() -> Self {
5582 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
5583 unsafe {
5584 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
5585 s.assume_init()
5586 }
5587 }
5588}
5589#[repr(C)]
5590#[derive(Copy, Clone)]
5591pub struct SavedTruthDataO {
5592 _unused: [u8; 0],
5593}
5594#[repr(C)]
5595#[derive(Default, Copy, Clone)]
5596pub struct TheTruthAssetsApi {
5597 pub get_asset_path: ::std::option::Option<
5598 unsafe extern "C" fn(
5599 tt: *const TheTruthO,
5600 asset: TtIdT,
5601 path: *mut ::std::os::raw::c_char,
5602 n: u32,
5603 ) -> u32,
5604 >,
5605 pub get_directory_path: ::std::option::Option<
5606 unsafe extern "C" fn(
5607 tt: *const TheTruthO,
5608 directory: TtIdT,
5609 path: *mut ::std::os::raw::c_char,
5610 n: u32,
5611 ) -> u32,
5612 >,
5613 pub get_asset_path_with_extension: ::std::option::Option<
5614 unsafe extern "C" fn(
5615 tt: *const TheTruthO,
5616 asset: TtIdT,
5617 path: *mut ::std::os::raw::c_char,
5618 n: u32,
5619 ) -> u32,
5620 >,
5621 pub asset_from_path: ::std::option::Option<
5622 unsafe extern "C" fn(
5623 tt: *const TheTruthO,
5624 asset_root: TtIdT,
5625 path: *const ::std::os::raw::c_char,
5626 ) -> TtIdT,
5627 >,
5628 pub asset_from_path_with_type: ::std::option::Option<
5629 unsafe extern "C" fn(
5630 tt: *const TheTruthO,
5631 asset_root: TtIdT,
5632 path: *const ::std::os::raw::c_char,
5633 type_: TtTypeT,
5634 ) -> TtIdT,
5635 >,
5636 pub asset_object_from_path: ::std::option::Option<
5637 unsafe extern "C" fn(
5638 tt: *const TheTruthO,
5639 asset_root: TtIdT,
5640 path: *const ::std::os::raw::c_char,
5641 ) -> TtIdT,
5642 >,
5643 pub asset_object_from_path_with_type: ::std::option::Option<
5644 unsafe extern "C" fn(
5645 tt: *const TheTruthO,
5646 asset_root: TtIdT,
5647 path: *const ::std::os::raw::c_char,
5648 type_: TtTypeT,
5649 ) -> TtIdT,
5650 >,
5651 pub directory_from_path: ::std::option::Option<
5652 unsafe extern "C" fn(
5653 tt: *const TheTruthO,
5654 asset_root: TtIdT,
5655 path: *const ::std::os::raw::c_char,
5656 ) -> TtIdT,
5657 >,
5658 pub find_subdirectory_by_name: ::std::option::Option<
5659 unsafe extern "C" fn(
5660 tt: *const TheTruthO,
5661 asset_root: TtIdT,
5662 parent_dir: TtIdT,
5663 subdir_name: *const ::std::os::raw::c_char,
5664 ) -> TtIdT,
5665 >,
5666 pub unique_asset_name: ::std::option::Option<
5667 unsafe extern "C" fn(
5668 tt: *mut TheTruthO,
5669 asset_root: TtIdT,
5670 asset_r: *const TheTruthObjectO,
5671 desired_name: *const ::std::os::raw::c_char,
5672 ) -> *const ::std::os::raw::c_char,
5673 >,
5674 pub unique_directory_name: ::std::option::Option<
5675 unsafe extern "C" fn(
5676 tt: *mut TheTruthO,
5677 asset_root: TtIdT,
5678 directory_r: *const TheTruthObjectO,
5679 desired_name: *const ::std::os::raw::c_char,
5680 ) -> *const ::std::os::raw::c_char,
5681 >,
5682 pub object_asset_name: ::std::option::Option<
5683 unsafe extern "C" fn(tt: *mut TheTruthO, object: TtIdT) -> *const ::std::os::raw::c_char,
5684 >,
5685 pub find_directory_settings: ::std::option::Option<
5686 unsafe extern "C" fn(
5687 tt: *mut TheTruthO,
5688 relative_to: TtIdT,
5689 target_type_hash: StrhashT,
5690 asset_root: TtIdT,
5691 ) -> TtIdT,
5692 >,
5693 pub object_to_config: ::std::option::Option<
5694 unsafe extern "C" fn(
5695 tt: *const TheTruthO,
5696 object: TtIdT,
5697 config: *mut ConfigI,
5698 buffers: *mut *mut TtAssetsBufferWriteT,
5699 buffers_ta: *mut TempAllocatorI,
5700 save_uuid: bool,
5701 ),
5702 >,
5703 pub create_object_from_config: ::std::option::Option<
5704 unsafe extern "C" fn(
5705 tt: *mut TheTruthO,
5706 config: *mut ConfigI,
5707 buffers: *mut *mut TtAssetsBufferT,
5708 buffers_ta: *mut TempAllocatorI,
5709 ) -> TtIdT,
5710 >,
5711 pub read_object_from_config: ::std::option::Option<
5712 unsafe extern "C" fn(
5713 tt: *mut TheTruthO,
5714 config: *mut ConfigI,
5715 buffers: *mut *mut TtAssetsBufferT,
5716 buffers_ta: *mut TempAllocatorI,
5717 id: TtIdT,
5718 ),
5719 >,
5720 pub save_to_directory: ::std::option::Option<
5721 unsafe extern "C" fn(
5722 tt: *mut TheTruthO,
5723 asset_root: TtIdT,
5724 dir: *const ::std::os::raw::c_char,
5725 ignore: *mut TtIdT,
5726 num_ignore: u32,
5727 old_std: *mut SavedTruthDataO,
5728 allocator: *mut AllocatorI,
5729 ) -> *mut SavedTruthDataO,
5730 >,
5731 pub load_from_directory: ::std::option::Option<
5732 unsafe extern "C" fn(
5733 tt: *mut TheTruthO,
5734 dir: *const ::std::os::raw::c_char,
5735 allocator: *mut AllocatorI,
5736 asset_root: *mut TtIdT,
5737 error: *mut ErrorI,
5738 ) -> *mut SavedTruthDataO,
5739 >,
5740 pub current_truth_data: ::std::option::Option<
5741 unsafe extern "C" fn(
5742 tt: *mut TheTruthO,
5743 asset_root: TtIdT,
5744 allocator: *mut AllocatorI,
5745 ) -> *mut SavedTruthDataO,
5746 >,
5747 pub revert_asset: ::std::option::Option<
5748 unsafe extern "C" fn(
5749 sd: *mut SavedTruthDataO,
5750 asset: TtIdT,
5751 undo_scope: TtUndoScopeT,
5752 ) -> bool,
5753 >,
5754 pub save_asset:
5755 ::std::option::Option<unsafe extern "C" fn(sd: *mut SavedTruthDataO, asset: TtIdT) -> bool>,
5756 pub saved_name: ::std::option::Option<
5757 unsafe extern "C" fn(
5758 sd: *mut SavedTruthDataO,
5759 item: TtIdT,
5760 ) -> *const ::std::os::raw::c_char,
5761 >,
5762 pub saved_directory:
5763 ::std::option::Option<unsafe extern "C" fn(sd: *mut SavedTruthDataO, item: TtIdT) -> TtIdT>,
5764 pub saved_version:
5765 ::std::option::Option<unsafe extern "C" fn(sd: *mut SavedTruthDataO, item: TtIdT) -> u64>,
5766 pub all_saved_items: ::std::option::Option<
5767 unsafe extern "C" fn(sd: *mut SavedTruthDataO, ta: *mut TempAllocatorI) -> *mut TtIdT,
5768 >,
5769 pub free_saved_data: ::std::option::Option<unsafe extern "C" fn(sd: *mut SavedTruthDataO)>,
5770 pub set_mock_file_system: ::std::option::Option<
5771 unsafe extern "C" fn(fs: *mut OsFileSystemApi, file_io: *mut OsFileIoApi),
5772 >,
5773 pub any_disk_changes: ::std::option::Option<
5774 unsafe extern "C" fn(sd: *mut SavedTruthDataO, dir: *const ::std::os::raw::c_char) -> bool,
5775 >,
5776}
5777#[repr(C)]
5778#[derive(Copy, Clone)]
5779pub struct TheTruthMigrationO {
5780 _unused: [u8; 0],
5781}
5782#[repr(C)]
5783#[derive(Copy, Clone)]
5784pub struct TheTruthMigrationI {
5785 pub inst: *mut TheTruthMigrationO,
5786 pub id: StrhashT,
5787 pub num_prerequisites: u32,
5788 pub _padding_81: [::std::os::raw::c_char; 4usize],
5789 pub prerequisites: *mut StrhashT,
5790 pub migrate: ::std::option::Option<
5791 unsafe extern "C" fn(inst: *mut TheTruthMigrationO, tt: *mut TheTruthO) -> bool,
5792 >,
5793}
5794impl Default for TheTruthMigrationI {
5795 fn default() -> Self {
5796 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
5797 unsafe {
5798 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
5799 s.assume_init()
5800 }
5801 }
5802}
5803#[repr(C)]
5804#[derive(Default, Copy, Clone)]
5805pub struct TheTruthMigrationApi {
5806 pub migrate: ::std::option::Option<unsafe extern "C" fn(tt: *mut TheTruthO) -> bool>,
5807}
5808pub const TM_TT_PROP__VEC2__X: ::std::os::raw::c_int = 0;
5809pub const TM_TT_PROP__VEC2__Y: ::std::os::raw::c_int = 1;
5810pub type _bindgen_ty_7 = ::std::os::raw::c_int;
5811pub const TM_TT_PROP__VEC3__X: ::std::os::raw::c_int = 0;
5812pub const TM_TT_PROP__VEC3__Y: ::std::os::raw::c_int = 1;
5813pub const TM_TT_PROP__VEC3__Z: ::std::os::raw::c_int = 2;
5814pub type _bindgen_ty_8 = ::std::os::raw::c_int;
5815pub const TM_TT_PROP__VEC4__X: ::std::os::raw::c_int = 0;
5816pub const TM_TT_PROP__VEC4__Y: ::std::os::raw::c_int = 1;
5817pub const TM_TT_PROP__VEC4__Z: ::std::os::raw::c_int = 2;
5818pub const TM_TT_PROP__VEC4__W: ::std::os::raw::c_int = 3;
5819pub type _bindgen_ty_9 = ::std::os::raw::c_int;
5820pub const TM_TT_PROP__POSITION__X: ::std::os::raw::c_int = 0;
5821pub const TM_TT_PROP__POSITION__Y: ::std::os::raw::c_int = 1;
5822pub const TM_TT_PROP__POSITION__Z: ::std::os::raw::c_int = 2;
5823pub type _bindgen_ty_10 = ::std::os::raw::c_int;
5824pub const TM_TT_PROP__ROTATION__X: ::std::os::raw::c_int = 0;
5825pub const TM_TT_PROP__ROTATION__Y: ::std::os::raw::c_int = 1;
5826pub const TM_TT_PROP__ROTATION__Z: ::std::os::raw::c_int = 2;
5827pub const TM_TT_PROP__ROTATION__W: ::std::os::raw::c_int = 3;
5828pub type _bindgen_ty_11 = ::std::os::raw::c_int;
5829pub const TM_TT_PROP__SCALE__X: ::std::os::raw::c_int = 0;
5830pub const TM_TT_PROP__SCALE__Y: ::std::os::raw::c_int = 1;
5831pub const TM_TT_PROP__SCALE__Z: ::std::os::raw::c_int = 2;
5832pub type _bindgen_ty_12 = ::std::os::raw::c_int;
5833pub const TM_TT_PROP__COLOR_RGB__R: ::std::os::raw::c_int = 0;
5834pub const TM_TT_PROP__COLOR_RGB__G: ::std::os::raw::c_int = 1;
5835pub const TM_TT_PROP__COLOR_RGB__B: ::std::os::raw::c_int = 2;
5836pub type _bindgen_ty_13 = ::std::os::raw::c_int;
5837pub const TM_TT_PROP__COLOR_RGBA__R: ::std::os::raw::c_int = 0;
5838pub const TM_TT_PROP__COLOR_RGBA__G: ::std::os::raw::c_int = 1;
5839pub const TM_TT_PROP__COLOR_RGBA__B: ::std::os::raw::c_int = 2;
5840pub const TM_TT_PROP__COLOR_RGBA__A: ::std::os::raw::c_int = 3;
5841pub type _bindgen_ty_14 = ::std::os::raw::c_int;
5842pub const TM_TT_PROP__RECT__X: ::std::os::raw::c_int = 0;
5843pub const TM_TT_PROP__RECT__Y: ::std::os::raw::c_int = 1;
5844pub const TM_TT_PROP__RECT__W: ::std::os::raw::c_int = 2;
5845pub const TM_TT_PROP__RECT__H: ::std::os::raw::c_int = 3;
5846pub type _bindgen_ty_15 = ::std::os::raw::c_int;
5847pub const TM_TT_PROP__UUID_A: ::std::os::raw::c_int = 0;
5848pub const TM_TT_PROP__UUID_B: ::std::os::raw::c_int = 1;
5849pub type _bindgen_ty_16 = ::std::os::raw::c_int;
5850#[repr(C)]
5851#[derive(Default, Copy, Clone)]
5852pub struct TheTruthCommonTypesApi {
5853 pub create_common_types: ::std::option::Option<unsafe extern "C" fn(tt: *mut TheTruthO)>,
5854 pub get_vec2: ::std::option::Option<
5855 unsafe extern "C" fn(
5856 tt: *const TheTruthO,
5857 object: *const TheTruthObjectO,
5858 property: u32,
5859 ) -> Vec2T,
5860 >,
5861 pub get_vec3: ::std::option::Option<
5862 unsafe extern "C" fn(
5863 tt: *const TheTruthO,
5864 object: *const TheTruthObjectO,
5865 property: u32,
5866 ) -> Vec3T,
5867 >,
5868 pub get_vec4: ::std::option::Option<
5869 unsafe extern "C" fn(
5870 tt: *const TheTruthO,
5871 object: *const TheTruthObjectO,
5872 property: u32,
5873 ) -> Vec4T,
5874 >,
5875 pub get_rect: ::std::option::Option<
5876 unsafe extern "C" fn(
5877 tt: *const TheTruthO,
5878 object: *const TheTruthObjectO,
5879 property: u32,
5880 ) -> RectT,
5881 >,
5882 pub get_position: ::std::option::Option<
5883 unsafe extern "C" fn(
5884 tt: *const TheTruthO,
5885 object: *const TheTruthObjectO,
5886 property: u32,
5887 ) -> Vec3T,
5888 >,
5889 pub get_rotation: ::std::option::Option<
5890 unsafe extern "C" fn(
5891 tt: *const TheTruthO,
5892 object: *const TheTruthObjectO,
5893 property: u32,
5894 ) -> Vec4T,
5895 >,
5896 pub get_scale: ::std::option::Option<
5897 unsafe extern "C" fn(
5898 tt: *const TheTruthO,
5899 object: *const TheTruthObjectO,
5900 property: u32,
5901 ) -> Vec3T,
5902 >,
5903 pub get_color_rgb: ::std::option::Option<
5904 unsafe extern "C" fn(
5905 tt: *const TheTruthO,
5906 object: *const TheTruthObjectO,
5907 property: u32,
5908 ) -> Vec3T,
5909 >,
5910 pub get_color_rgba: ::std::option::Option<
5911 unsafe extern "C" fn(
5912 tt: *const TheTruthO,
5913 object: *const TheTruthObjectO,
5914 property: u32,
5915 ) -> Vec4T,
5916 >,
5917 pub get_color_srgb: ::std::option::Option<
5918 unsafe extern "C" fn(
5919 tt: *const TheTruthO,
5920 object: *const TheTruthObjectO,
5921 property: u32,
5922 ) -> ColorSrgbT,
5923 >,
5924 pub get_color_srgba: ::std::option::Option<
5925 unsafe extern "C" fn(
5926 tt: *const TheTruthO,
5927 object: *const TheTruthObjectO,
5928 property: u32,
5929 ) -> ColorSrgbT,
5930 >,
5931 pub get_uuid: ::std::option::Option<
5932 unsafe extern "C" fn(
5933 tt: *const TheTruthO,
5934 object: *const TheTruthObjectO,
5935 property: u32,
5936 ) -> UuidT,
5937 >,
5938 pub set_vec2: ::std::option::Option<
5939 unsafe extern "C" fn(
5940 tt: *mut TheTruthO,
5941 object: *mut TheTruthObjectO,
5942 property: u32,
5943 vec2: Vec2T,
5944 undo_scope: TtUndoScopeT,
5945 ),
5946 >,
5947 pub set_vec3: ::std::option::Option<
5948 unsafe extern "C" fn(
5949 tt: *mut TheTruthO,
5950 object: *mut TheTruthObjectO,
5951 property: u32,
5952 vec3: Vec3T,
5953 undo_scope: TtUndoScopeT,
5954 ),
5955 >,
5956 pub set_vec4: ::std::option::Option<
5957 unsafe extern "C" fn(
5958 tt: *mut TheTruthO,
5959 object: *mut TheTruthObjectO,
5960 property: u32,
5961 vec4: Vec4T,
5962 undo_scope: TtUndoScopeT,
5963 ),
5964 >,
5965 pub set_rect: ::std::option::Option<
5966 unsafe extern "C" fn(
5967 tt: *mut TheTruthO,
5968 object: *mut TheTruthObjectO,
5969 property: u32,
5970 rect: RectT,
5971 undo_scope: TtUndoScopeT,
5972 ),
5973 >,
5974 pub set_position: ::std::option::Option<
5975 unsafe extern "C" fn(
5976 tt: *mut TheTruthO,
5977 object: *mut TheTruthObjectO,
5978 property: u32,
5979 vec3: Vec3T,
5980 undo_scope: TtUndoScopeT,
5981 ),
5982 >,
5983 pub set_rotation: ::std::option::Option<
5984 unsafe extern "C" fn(
5985 tt: *mut TheTruthO,
5986 object: *mut TheTruthObjectO,
5987 property: u32,
5988 vec4: Vec4T,
5989 undo_scope: TtUndoScopeT,
5990 ),
5991 >,
5992 pub set_scale: ::std::option::Option<
5993 unsafe extern "C" fn(
5994 tt: *mut TheTruthO,
5995 object: *mut TheTruthObjectO,
5996 property: u32,
5997 vec3: Vec3T,
5998 undo_scope: TtUndoScopeT,
5999 ),
6000 >,
6001 pub set_color_rgb: ::std::option::Option<
6002 unsafe extern "C" fn(
6003 tt: *mut TheTruthO,
6004 object: *mut TheTruthObjectO,
6005 property: u32,
6006 vec3: Vec3T,
6007 undo_scope: TtUndoScopeT,
6008 ),
6009 >,
6010 pub set_color_rgba: ::std::option::Option<
6011 unsafe extern "C" fn(
6012 tt: *mut TheTruthO,
6013 object: *mut TheTruthObjectO,
6014 property: u32,
6015 vec4: Vec4T,
6016 undo_scope: TtUndoScopeT,
6017 ),
6018 >,
6019 pub set_color_srgb: ::std::option::Option<
6020 unsafe extern "C" fn(
6021 tt: *mut TheTruthO,
6022 object: *mut TheTruthObjectO,
6023 property: u32,
6024 col: ColorSrgbT,
6025 undo_scope: TtUndoScopeT,
6026 ),
6027 >,
6028 pub set_color_srgba: ::std::option::Option<
6029 unsafe extern "C" fn(
6030 tt: *mut TheTruthO,
6031 object: *mut TheTruthObjectO,
6032 property: u32,
6033 col: ColorSrgbT,
6034 undo_scope: TtUndoScopeT,
6035 ),
6036 >,
6037 pub set_uuid: ::std::option::Option<
6038 unsafe extern "C" fn(
6039 tt: *mut TheTruthO,
6040 object: *mut TheTruthObjectO,
6041 property: u32,
6042 uuid: UuidT,
6043 undo_scope: TtUndoScopeT,
6044 ),
6045 >,
6046 pub read_floats: ::std::option::Option<
6047 unsafe extern "C" fn(
6048 tt: *const TheTruthO,
6049 obj: *const TheTruthObjectO,
6050 res: *mut f32,
6051 n: u32,
6052 ) -> *mut f32,
6053 >,
6054 pub write_floats: ::std::option::Option<
6055 unsafe extern "C" fn(
6056 tt: *mut TheTruthO,
6057 obj: *mut TheTruthObjectO,
6058 values: *const f32,
6059 n: u32,
6060 ),
6061 >,
6062}
6063#[repr(C)]
6064#[derive(Copy, Clone)]
6065pub struct UndoStackO {
6066 _unused: [u8; 0],
6067}
6068#[repr(C)]
6069#[derive(Copy, Clone)]
6070pub struct UndoStackI {
6071 pub inst: *mut UndoStackO,
6072 pub add: ::std::option::Option<
6073 unsafe extern "C" fn(inst: *mut UndoStackO, tt: *mut TheTruthO, scope: TtUndoScopeT),
6074 >,
6075 pub add_to_document: ::std::option::Option<
6076 unsafe extern "C" fn(
6077 inst: *mut UndoStackO,
6078 tt: *mut TheTruthO,
6079 scope: TtUndoScopeT,
6080 document_object: TtIdT,
6081 ),
6082 >,
6083}
6084impl Default for UndoStackI {
6085 fn default() -> Self {
6086 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
6087 unsafe {
6088 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
6089 s.assume_init()
6090 }
6091 }
6092}
6093#[repr(C)]
6094#[derive(Default, Copy, Clone)]
6095pub struct UnicodeApi {
6096 pub is_valid:
6097 ::std::option::Option<unsafe extern "C" fn(utf8: *const ::std::os::raw::c_char) -> bool>,
6098 pub truncate: ::std::option::Option<unsafe extern "C" fn(utf8: *mut ::std::os::raw::c_char)>,
6099 pub utf8_encode: ::std::option::Option<
6100 unsafe extern "C" fn(
6101 utf8: *mut ::std::os::raw::c_char,
6102 codepoint: u32,
6103 ) -> *mut ::std::os::raw::c_char,
6104 >,
6105 pub utf8_decode: ::std::option::Option<
6106 unsafe extern "C" fn(utf8: *mut *const ::std::os::raw::c_char) -> u32,
6107 >,
6108 pub utf8_num_codepoints:
6109 ::std::option::Option<unsafe extern "C" fn(utf8: *const ::std::os::raw::c_char) -> u32>,
6110 pub utf8_decode_n: ::std::option::Option<
6111 unsafe extern "C" fn(
6112 codepoints: *mut u32,
6113 n: u32,
6114 utf8: *const ::std::os::raw::c_char,
6115 ) -> u32,
6116 >,
6117 pub utf8_to_utf32: ::std::option::Option<
6118 unsafe extern "C" fn(
6119 utf8: *const ::std::os::raw::c_char,
6120 ta: *mut TempAllocatorI,
6121 ) -> *mut u32,
6122 >,
6123 pub utf8_to_utf32_n: ::std::option::Option<
6124 unsafe extern "C" fn(
6125 utf8: *const ::std::os::raw::c_char,
6126 n: u32,
6127 ta: *mut TempAllocatorI,
6128 ) -> *mut u32,
6129 >,
6130 pub utf32_to_utf8: ::std::option::Option<
6131 unsafe extern "C" fn(
6132 utf32: *const u32,
6133 ta: *mut TempAllocatorI,
6134 ) -> *mut ::std::os::raw::c_char,
6135 >,
6136 pub utf32_to_utf8_n: ::std::option::Option<
6137 unsafe extern "C" fn(
6138 utf32: *const u32,
6139 n: u32,
6140 ta: *mut TempAllocatorI,
6141 ) -> *mut ::std::os::raw::c_char,
6142 >,
6143 pub utf16_encode:
6144 ::std::option::Option<unsafe extern "C" fn(utf16: *mut u16, codepoint: u32) -> *mut u16>,
6145 pub utf16_decode: ::std::option::Option<unsafe extern "C" fn(utf16: *mut *const u16) -> u32>,
6146 pub utf8_to_utf16: ::std::option::Option<
6147 unsafe extern "C" fn(
6148 utf8: *const ::std::os::raw::c_char,
6149 ta: *mut TempAllocatorI,
6150 ) -> *mut u16,
6151 >,
6152 pub utf8_to_utf16_n: ::std::option::Option<
6153 unsafe extern "C" fn(
6154 utf8: *const ::std::os::raw::c_char,
6155 n: u32,
6156 ta: *mut TempAllocatorI,
6157 ) -> *mut u16,
6158 >,
6159 pub utf16_to_utf8: ::std::option::Option<
6160 unsafe extern "C" fn(
6161 utf16: *const u16,
6162 ta: *mut TempAllocatorI,
6163 ) -> *mut ::std::os::raw::c_char,
6164 >,
6165 pub utf16_to_utf8_n: ::std::option::Option<
6166 unsafe extern "C" fn(
6167 utf16: *const u16,
6168 n: u32,
6169 ta: *mut TempAllocatorI,
6170 ) -> *mut ::std::os::raw::c_char,
6171 >,
6172}
6173pub const TM_UNICODE__HORIZONTAL_ELLIPSIS: ::std::os::raw::c_int = 8230;
6174pub const TM_UNICODE__ARROW_UPWARDS: ::std::os::raw::c_int = 8593;
6175pub const TM_UNICODE__ARROW_DOWNWARDS: ::std::os::raw::c_int = 8595;
6176pub const TM_UNICODE__COPYRIGHT: ::std::os::raw::c_int = 169;
6177pub const TM_UNICODE__CROSS_MARK: ::std::os::raw::c_int = 10060;
6178pub const TM_UNICODE__DOUBLE_PRIME: ::std::os::raw::c_int = 8243;
6179pub type _bindgen_ty_17 = ::std::os::raw::c_int;
6180#[repr(C)]
6181#[derive(Copy, Clone)]
6182pub struct UnitTestRunnerO {
6183 _unused: [u8; 0],
6184}
6185#[repr(C)]
6186#[derive(Copy, Clone)]
6187pub struct UnitTestRunnerI {
6188 pub inst: *mut UnitTestRunnerO,
6189 pub test_file: ::std::option::Option<
6190 unsafe extern "C" fn(
6191 inst: *mut UnitTestRunnerO,
6192 name: *const ::std::os::raw::c_char,
6193 ) -> bool,
6194 >,
6195 pub test_custom: ::std::option::Option<
6196 unsafe extern "C" fn(
6197 inst: *mut UnitTestRunnerO,
6198 name: *const ::std::os::raw::c_char,
6199 ) -> bool,
6200 >,
6201 pub test_disk: ::std::option::Option<unsafe extern "C" fn(inst: *mut UnitTestRunnerO) -> bool>,
6202 pub test_network:
6203 ::std::option::Option<unsafe extern "C" fn(inst: *mut UnitTestRunnerO) -> bool>,
6204 pub test_slow_paths:
6205 ::std::option::Option<unsafe extern "C" fn(inst: *mut UnitTestRunnerO) -> bool>,
6206 pub record: ::std::option::Option<
6207 unsafe extern "C" fn(
6208 inst: *mut UnitTestRunnerO,
6209 pass: bool,
6210 test_str: *const ::std::os::raw::c_char,
6211 file: *const ::std::os::raw::c_char,
6212 line: u32,
6213 ) -> bool,
6214 >,
6215 pub expect_error: ::std::option::Option<
6216 unsafe extern "C" fn(
6217 inst: *mut UnitTestRunnerO,
6218 err: *const ::std::os::raw::c_char,
6219 file: *const ::std::os::raw::c_char,
6220 line: u32,
6221 ),
6222 >,
6223}
6224impl Default for UnitTestRunnerI {
6225 fn default() -> Self {
6226 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
6227 unsafe {
6228 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
6229 s.assume_init()
6230 }
6231 }
6232}
6233#[repr(C)]
6234#[derive(Copy, Clone)]
6235pub struct UnitTestI {
6236 pub name: *const ::std::os::raw::c_char,
6237 pub test:
6238 ::std::option::Option<unsafe extern "C" fn(tr: *mut UnitTestRunnerI, a: *mut AllocatorI)>,
6239}
6240impl Default for UnitTestI {
6241 fn default() -> Self {
6242 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
6243 unsafe {
6244 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
6245 s.assume_init()
6246 }
6247 }
6248}
6249pub const TM_VISIBILITY_FLAG_OPT_IN: VisibilityFlagBehaviour = 0;
6250pub const TM_VISIBILITY_FLAG_OPT_OUT: VisibilityFlagBehaviour = 1;
6251pub type VisibilityFlagBehaviour = ::std::os::raw::c_int;
6252#[repr(C)]
6253#[derive(Copy, Clone)]
6254pub struct VisibilityFlagDescI {
6255 pub name: StrhashT,
6256 pub description: *const ::std::os::raw::c_char,
6257 pub tooltip: *const ::std::os::raw::c_char,
6258 pub uuid: u32,
6259 pub behaviour: VisibilityFlagBehaviour,
6260}
6261impl Default for VisibilityFlagDescI {
6262 fn default() -> Self {
6263 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
6264 unsafe {
6265 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
6266 s.assume_init()
6267 }
6268 }
6269}
6270#[repr(C)]
6271#[derive(Default, Copy, Clone)]
6272pub struct VisibilityFlagEditorI {
6273 pub flag: u64,
6274}
6275#[repr(C)]
6276#[derive(Copy, Clone)]
6277pub struct VisibilityContextO {
6278 _unused: [u8; 0],
6279}
6280#[repr(C)]
6281#[derive(Default, Copy, Clone)]
6282pub struct VisibilityFlagsApi {
6283 pub create_context: ::std::option::Option<
6284 unsafe extern "C" fn(allocator: *mut AllocatorI, name: StrhashT) -> *mut VisibilityContextO,
6285 >,
6286 pub context_name:
6287 ::std::option::Option<unsafe extern "C" fn(context: *mut VisibilityContextO) -> StrhashT>,
6288 pub destroy_context:
6289 ::std::option::Option<unsafe extern "C" fn(context: *mut VisibilityContextO)>,
6290 pub register_visibility_flag: ::std::option::Option<
6291 unsafe extern "C" fn(
6292 context: *mut VisibilityContextO,
6293 desc: *const VisibilityFlagDescI,
6294 ) -> u64,
6295 >,
6296 pub name_from_visibility_flag: ::std::option::Option<
6297 unsafe extern "C" fn(context: *mut VisibilityContextO, visibility_flag: u64) -> StrhashT,
6298 >,
6299 pub visibility_flag_from_name: ::std::option::Option<
6300 unsafe extern "C" fn(context: *mut VisibilityContextO, name: StrhashT) -> u64,
6301 >,
6302 pub unregister_visibility_flag:
6303 ::std::option::Option<unsafe extern "C" fn(context: *mut VisibilityContextO, uuid: u32)>,
6304 pub enumerate_flags: ::std::option::Option<
6305 unsafe extern "C" fn(
6306 context: *mut VisibilityContextO,
6307 flags: *mut VisibilityFlagDescI,
6308 num_flags: *mut u32,
6309 ),
6310 >,
6311 pub build_visibility_mask: ::std::option::Option<
6312 unsafe extern "C" fn(
6313 context: *mut VisibilityContextO,
6314 uuids: *const u32,
6315 num_uuids: u32,
6316 ) -> u64,
6317 >,
6318}
6319pub const TM_TT_PROP__VISIBILITY_FLAG__UUID: ::std::os::raw::c_int = 0;
6320pub type _bindgen_ty_18 = ::std::os::raw::c_int;
6321pub const TM_WEB_SOCKET_OPCODE_CONTINUATION: WebSocketOpcode = 0;
6322pub const TM_WEB_SOCKET_OPCODE_TEXT: WebSocketOpcode = 1;
6323pub const TM_WEB_SOCKET_OPCODE_BINARY: WebSocketOpcode = 2;
6324pub const TM_WEB_SOCKET_OPCODE_CLOSE: WebSocketOpcode = 8;
6325pub const TM_WEB_SOCKET_OPCODE_PING: WebSocketOpcode = 9;
6326pub const TM_WEB_SOCKET_OPCODE_PONG: WebSocketOpcode = 10;
6327pub type WebSocketOpcode = ::std::os::raw::c_int;
6328#[repr(C)]
6329#[derive(Default, Copy, Clone)]
6330pub struct WebSocketProtocolApi {
6331 pub make_client_handshake: ::std::option::Option<
6332 unsafe extern "C" fn(
6333 buffer: *mut ::std::os::raw::c_char,
6334 size: u32,
6335 host: *const ::std::os::raw::c_char,
6336 port: u32,
6337 request: *const ::std::os::raw::c_char,
6338 key: *const ::std::os::raw::c_char,
6339 ),
6340 >,
6341 pub make_server_handshake: ::std::option::Option<
6342 unsafe extern "C" fn(
6343 buffer: *mut ::std::os::raw::c_char,
6344 size: u32,
6345 key: *const ::std::os::raw::c_char,
6346 key_size: u32,
6347 ),
6348 >,
6349 pub make_frame_header: ::std::option::Option<
6350 unsafe extern "C" fn(buffer: *mut u8, fin: bool, opcode: u8, size: u64, mask: u32) -> u32,
6351 >,
6352 pub parse_frame_header: ::std::option::Option<
6353 unsafe extern "C" fn(
6354 buffer: *mut u8,
6355 buf_size: u64,
6356 fin: *mut bool,
6357 opcode: *mut u8,
6358 size: *mut u64,
6359 mask: *mut u32,
6360 ) -> u32,
6361 >,
6362 pub mask_data: ::std::option::Option<
6363 unsafe extern "C" fn(data: *mut u8, size: u64, offset: u64, mask: u32),
6364 >,
6365 pub mask_segmented_buffer: ::std::option::Option<
6366 unsafe extern "C" fn(seg: *mut SegmentedBufferT, size: u64, mask: u32),
6367 >,
6368}
6369pub const TM_HTTP_REQUEST_STATUS_IN_PROGRESS: HttpRequestStatus = 0;
6370pub const TM_HTTP_REQUEST_STATUS_SUCCESS: HttpRequestStatus = 1;
6371pub const TM_HTTP_REQUEST_STATUS_ERROR: HttpRequestStatus = 2;
6372pub const TM_HTTP_REQUEST_STATUS_CLOSED: HttpRequestStatus = 3;
6373pub type HttpRequestStatus = ::std::os::raw::c_int;
6374#[repr(C)]
6375#[derive(Copy, Clone)]
6376pub struct HttpRequestT {
6377 pub id: u64,
6378 pub request_target: *const ::std::os::raw::c_char,
6379}
6380impl Default for HttpRequestT {
6381 fn default() -> Self {
6382 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
6383 unsafe {
6384 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
6385 s.assume_init()
6386 }
6387 }
6388}
6389#[repr(C)]
6390#[derive(Copy, Clone)]
6391pub struct SegmentedBufferT {
6392 pub data: *mut ::std::os::raw::c_void,
6393 pub size: u64,
6394 pub next: *mut SegmentedBufferT,
6395}
6396impl Default for SegmentedBufferT {
6397 fn default() -> Self {
6398 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
6399 unsafe {
6400 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
6401 s.assume_init()
6402 }
6403 }
6404}
6405pub const TM_WEB_SOCKET_PSEUDO_OPCODE_OPEN: WebSocketPseudoOpcode = 16;
6406pub const TM_WEB_SOCKET_PSEUDO_OPCODE_ERROR: WebSocketPseudoOpcode = 17;
6407pub type WebSocketPseudoOpcode = ::std::os::raw::c_int;
6408pub const TM_WEB_SOCKET_STATUS_CONNECTING: WebSocketStatus = 0;
6409pub const TM_WEB_SOCKET_STATUS_OPEN: WebSocketStatus = 1;
6410pub const TM_WEB_SOCKET_STATUS_CLOSING: WebSocketStatus = 2;
6411pub const TM_WEB_SOCKET_STATUS_CLOSED: WebSocketStatus = 3;
6412pub const TM_WEB_SOCKET_STATUS_ERROR: WebSocketStatus = 4;
6413pub type WebSocketStatus = ::std::os::raw::c_int;
6414#[repr(C)]
6415#[derive(Copy, Clone)]
6416pub struct WebSocketRequestT {
6417 pub id: u64,
6418 pub request_target: *const ::std::os::raw::c_char,
6419}
6420impl Default for WebSocketRequestT {
6421 fn default() -> Self {
6422 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
6423 unsafe {
6424 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
6425 s.assume_init()
6426 }
6427 }
6428}
6429#[repr(C)]
6430#[derive(Copy, Clone)]
6431pub struct WebSocketEventT {
6432 pub opcode: u32,
6433 pub _padding_107: [::std::os::raw::c_char; 4usize],
6434 pub payload_size: u64,
6435 pub payload: SegmentedBufferT,
6436 pub payload_reference: *mut ::std::os::raw::c_void,
6437}
6438impl Default for WebSocketEventT {
6439 fn default() -> Self {
6440 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
6441 unsafe {
6442 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
6443 s.assume_init()
6444 }
6445 }
6446}
6447#[repr(C)]
6448#[derive(Copy, Clone)]
6449pub struct WebTalkerO {
6450 _unused: [u8; 0],
6451}
6452#[repr(C)]
6453#[derive(Default, Copy, Clone)]
6454pub struct WebTalkerApi {
6455 pub create: ::std::option::Option<
6456 unsafe extern "C" fn(
6457 a: *mut AllocatorI,
6458 socket: *mut OsSocketApi,
6459 port: u32,
6460 ) -> *mut WebTalkerO,
6461 >,
6462 pub listening_address: ::std::option::Option<
6463 unsafe extern "C" fn(inst: *mut WebTalkerO, address: *mut SocketAddressT) -> bool,
6464 >,
6465 pub create_no_server: ::std::option::Option<
6466 unsafe extern "C" fn(a: *mut AllocatorI, socket: *mut OsSocketApi) -> *mut WebTalkerO,
6467 >,
6468 pub destroy: ::std::option::Option<unsafe extern "C" fn(arg1: *mut WebTalkerO)>,
6469 pub receive: ::std::option::Option<unsafe extern "C" fn(inst: *mut WebTalkerO)>,
6470 pub send: ::std::option::Option<unsafe extern "C" fn(inst: *mut WebTalkerO)>,
6471 pub http_get_requests: ::std::option::Option<
6472 unsafe extern "C" fn(
6473 inst: *mut WebTalkerO,
6474 buffer: *mut HttpRequestT,
6475 capacity: u32,
6476 ) -> u32,
6477 >,
6478 pub http_respond_raw: ::std::option::Option<
6479 unsafe extern "C" fn(
6480 inst: *mut WebTalkerO,
6481 id: u64,
6482 response: *const ::std::os::raw::c_char,
6483 ),
6484 >,
6485 pub http_respond_html: ::std::option::Option<
6486 unsafe extern "C" fn(inst: *mut WebTalkerO, id: u64, html: *const ::std::os::raw::c_char),
6487 >,
6488 pub http_request: ::std::option::Option<
6489 unsafe extern "C" fn(
6490 inst: *mut WebTalkerO,
6491 address: SocketAddressT,
6492 headers: *const ::std::os::raw::c_char,
6493 ) -> u64,
6494 >,
6495 pub http_request_status: ::std::option::Option<
6496 unsafe extern "C" fn(inst: *mut WebTalkerO, id: u64) -> HttpRequestStatus,
6497 >,
6498 pub http_response: ::std::option::Option<
6499 unsafe extern "C" fn(inst: *mut WebTalkerO, id: u64, size: *mut u64) -> SegmentedBufferT,
6500 >,
6501 pub http_close: ::std::option::Option<unsafe extern "C" fn(inst: *mut WebTalkerO, id: u64)>,
6502 pub ws_connect: ::std::option::Option<
6503 unsafe extern "C" fn(
6504 inst: *mut WebTalkerO,
6505 address: SocketAddressT,
6506 host: *const ::std::os::raw::c_char,
6507 request: *const ::std::os::raw::c_char,
6508 ) -> u64,
6509 >,
6510 pub ws_get_requests: ::std::option::Option<
6511 unsafe extern "C" fn(
6512 inst: *mut WebTalkerO,
6513 buffer: *mut WebSocketRequestT,
6514 capacity: u32,
6515 ) -> u32,
6516 >,
6517 pub ws_status: ::std::option::Option<
6518 unsafe extern "C" fn(inst: *mut WebTalkerO, id: u64) -> WebSocketStatus,
6519 >,
6520 pub ws_recv_progress: ::std::option::Option<
6521 unsafe extern "C" fn(
6522 inst: *mut WebTalkerO,
6523 id: u64,
6524 bytes: *mut u64,
6525 total: *mut u64,
6526 ) -> bool,
6527 >,
6528 pub ws_get_events: ::std::option::Option<
6529 unsafe extern "C" fn(
6530 inst: *mut WebTalkerO,
6531 id: u64,
6532 buffer: *mut WebSocketEventT,
6533 capacity: u32,
6534 ) -> u32,
6535 >,
6536 pub ws_send_text_frame: ::std::option::Option<
6537 unsafe extern "C" fn(inst: *mut WebTalkerO, id: u64, s: *const ::std::os::raw::c_char),
6538 >,
6539 pub ws_send_binary_frame: ::std::option::Option<
6540 unsafe extern "C" fn(inst: *mut WebTalkerO, id: u64, data: *const u8, size: u64),
6541 >,
6542 pub ws_send_segmented_binary_frame: ::std::option::Option<
6543 unsafe extern "C" fn(
6544 inst: *mut WebTalkerO,
6545 id: u64,
6546 buf: *const SegmentedBufferT,
6547 size: u64,
6548 ),
6549 >,
6550 pub ws_send_ping: ::std::option::Option<unsafe extern "C" fn(inst: *mut WebTalkerO, id: u64)>,
6551 pub ws_close: ::std::option::Option<unsafe extern "C" fn(inst: *mut WebTalkerO, id: u64)>,
6552 pub copy_segmented_buffer: ::std::option::Option<
6553 unsafe extern "C" fn(
6554 buffer: *mut ::std::os::raw::c_void,
6555 segments: *const SegmentedBufferT,
6556 size: u64,
6557 ),
6558 >,
6559}
6560#[repr(C)]
6561#[derive(Default, Copy, Clone)]
6562pub struct ViewerManagerO {
6563 pub _address: u8,
6564}
6565#[repr(C)]
6566#[derive(Default, Copy, Clone)]
6567pub struct RenderPipelineVt {
6568 pub _address: u8,
6569}
6570#[repr(C)]
6571#[derive(Default, Copy, Clone)]
6572pub struct NetworkO {
6573 pub _address: u8,
6574}
6575#[repr(C)]
6576#[derive(Default, Copy, Clone)]
6577pub struct AssetIoO {
6578 pub _address: u8,
6579}
6580#[repr(C)]
6581#[derive(Default, Copy, Clone)]
6582pub struct PluginO {
6583 pub _address: u8,
6584}
6585#[repr(C)]
6586#[derive(Default, Copy, Clone)]
6587pub struct StringRepositoryO {
6588 pub _address: u8,
6589}
6590#[repr(C)]
6591#[derive(Default, Copy, Clone)]
6592pub struct TempAllocatorO {
6593 pub _address: u8,
6594}
6595#[repr(C)]
6596#[derive(Default, Copy, Clone)]
6597pub struct Hash32T {
6598 pub _address: u8,
6599}
6600
6601use const_cstr::{const_cstr, ConstCStr};
6604
6605use crate::plugins::ui::Draw2dFontT;
6606
6607impl AllocatorApi {
6608 pub unsafe fn create_child(
6609 &self,
6610 parent: *const AllocatorI,
6611 desc: *const ::std::os::raw::c_char,
6612 ) -> AllocatorI {
6613 self.create_child.unwrap()(parent, desc)
6614 }
6615
6616 pub unsafe fn destroy_child(&self, child: *const AllocatorI) {
6617 self.destroy_child.unwrap()(child)
6618 }
6619
6620 pub unsafe fn destroy_child_allowing_leaks(
6621 &self,
6622 child: *const AllocatorI,
6623 max_leaked_bytes: u64,
6624 ) {
6625 self.destroy_child_allowing_leaks.unwrap()(child, max_leaked_bytes)
6626 }
6627
6628 pub unsafe fn create_leaky_root_scope(
6629 &self,
6630 parent: *const AllocatorI,
6631 desc: *const ::std::os::raw::c_char,
6632 ) -> AllocatorI {
6633 self.create_leaky_root_scope.unwrap()(parent, desc)
6634 }
6635
6636 pub unsafe fn create_fixed_vm(&self, reserve_size: u64, mem_scope: u32) -> AllocatorI {
6637 self.create_fixed_vm.unwrap()(reserve_size, mem_scope)
6638 }
6639}
6640
6641impl crate::Api for AllocatorApi {
6642 const NAME: ConstCStr = const_cstr!("tm_allocator_api");
6643 const VERSION: VersionT = VersionT {
6644 major: 1u32,
6645 minor: 0u32,
6646 patch: 0u32,
6647 };
6648}
6649
6650impl ApiRegistryApi {
6651 pub unsafe fn api_registry_version(&self) -> VersionT {
6652 self.api_registry_version.unwrap()()
6653 }
6654
6655 pub unsafe fn set(
6656 &self,
6657 name: *const ::std::os::raw::c_char,
6658 version: VersionT,
6659 api: *const ::std::os::raw::c_void,
6660 bytes: u32,
6661 ) {
6662 self.set.unwrap()(name, version, api, bytes)
6663 }
6664
6665 pub unsafe fn remove(&self, api: *const ::std::os::raw::c_void) {
6666 self.remove.unwrap()(api)
6667 }
6668
6669 pub unsafe fn get(
6670 &self,
6671 name: *const ::std::os::raw::c_char,
6672 version: VersionT,
6673 ) -> *mut ::std::os::raw::c_void {
6674 self.get.unwrap()(name, version)
6675 }
6676
6677 pub unsafe fn get_optional(
6678 &self,
6679 api: *mut *mut ::std::os::raw::c_void,
6680 name: *const ::std::os::raw::c_char,
6681 version: VersionT,
6682 ) {
6683 self.get_optional.unwrap()(api, name, version)
6684 }
6685
6686 pub unsafe fn version(&self, api: *mut ::std::os::raw::c_void) -> VersionT {
6687 self.version.unwrap()(api)
6688 }
6689
6690 pub unsafe fn add_implementation(
6691 &self,
6692 name: *const ::std::os::raw::c_char,
6693 version: VersionT,
6694 implementation: *const ::std::os::raw::c_void,
6695 ) {
6696 self.add_implementation.unwrap()(name, version, implementation)
6697 }
6698
6699 pub unsafe fn remove_implementation(
6700 &self,
6701 name: *const ::std::os::raw::c_char,
6702 version: VersionT,
6703 implementation: *const ::std::os::raw::c_void,
6704 ) {
6705 self.remove_implementation.unwrap()(name, version, implementation)
6706 }
6707
6708 pub unsafe fn implementations(
6709 &self,
6710 name: *const ::std::os::raw::c_char,
6711 version: VersionT,
6712 ) -> *mut *mut ::std::os::raw::c_void {
6713 self.implementations.unwrap()(name, version)
6714 }
6715
6716 pub unsafe fn num_implementations(
6717 &self,
6718 name: *const ::std::os::raw::c_char,
6719 version: VersionT,
6720 ) -> u32 {
6721 self.num_implementations.unwrap()(name, version)
6722 }
6723
6724 pub unsafe fn first_implementation(
6725 &self,
6726 name: *const ::std::os::raw::c_char,
6727 version: VersionT,
6728 ) -> *mut ::std::os::raw::c_void {
6729 self.first_implementation.unwrap()(name, version)
6730 }
6731
6732 pub unsafe fn single_implementation(
6733 &self,
6734 name: *const ::std::os::raw::c_char,
6735 version: VersionT,
6736 ) -> *mut ::std::os::raw::c_void {
6737 self.single_implementation.unwrap()(name, version)
6738 }
6739
6740 pub unsafe fn add_listener(&self, listener: *const ApiRegistryListenerI) {
6741 self.add_listener.unwrap()(listener)
6742 }
6743
6744 pub unsafe fn static_variable(
6745 &self,
6746 id: StrhashT,
6747 size: u32,
6748 file: *const ::std::os::raw::c_char,
6749 line: u32,
6750 ) -> *mut ::std::os::raw::c_void {
6751 self.static_variable.unwrap()(id, size, file, line)
6752 }
6753
6754 pub unsafe fn begin_context(&self, name: *const ::std::os::raw::c_char) {
6755 self.begin_context.unwrap()(name)
6756 }
6757
6758 pub unsafe fn end_context(&self, name: *const ::std::os::raw::c_char) {
6759 self.end_context.unwrap()(name)
6760 }
6761
6762 pub unsafe fn disable_apis_missing_dependencies(&self) {
6763 self.disable_apis_missing_dependencies.unwrap()()
6764 }
6765
6766 pub unsafe fn available_versions(
6767 &self,
6768 name: *const ::std::os::raw::c_char,
6769 ta: *mut TempAllocatorI,
6770 ) -> *mut VersionT {
6771 self.available_versions.unwrap()(name, ta)
6772 }
6773}
6774
6775impl crate::Api for ApiRegistryApi {
6776 const NAME: ConstCStr = const_cstr!("tm_api_registry_api");
6777 const VERSION: VersionT = VersionT {
6778 major: 1u32,
6779 minor: 0u32,
6780 patch: 0u32,
6781 };
6782}
6783
6784impl ApplicationApi {
6785 pub unsafe fn application(&self) -> *mut ApplicationO {
6786 self.application.unwrap()()
6787 }
6788
6789 pub unsafe fn create(
6790 &self,
6791 argc: ::std::os::raw::c_int,
6792 argv: *mut *mut ::std::os::raw::c_char,
6793 ) -> *mut ApplicationO {
6794 self.create.unwrap()(argc, argv)
6795 }
6796
6797 pub unsafe fn tick(&self, app: *mut ApplicationO) -> bool {
6798 self.tick.unwrap()(app)
6799 }
6800
6801 pub unsafe fn destroy(&self, app: *mut ApplicationO) {
6802 self.destroy.unwrap()(app)
6803 }
6804
6805 pub unsafe fn set_modal(
6806 &self,
6807 app: *mut ApplicationO,
6808 f: ApplicationModalF,
6809 data: *mut ::std::os::raw::c_void,
6810 ) {
6811 self.set_modal.unwrap()(app, f, data)
6812 }
6813
6814 pub unsafe fn is_modal(&self, app: *const ApplicationO) -> bool {
6815 self.is_modal.unwrap()(app)
6816 }
6817
6818 pub unsafe fn asset_root(&self, app: *const ApplicationO) -> TtIdT {
6819 self.asset_root.unwrap()(app)
6820 }
6821
6822 pub unsafe fn load_core(&self, app: *const ApplicationO) -> bool {
6823 self.load_core.unwrap()(app)
6824 }
6825
6826 pub unsafe fn update_core(&self, app: *const ApplicationO, include_skipped: bool) -> bool {
6827 self.update_core.unwrap()(app, include_skipped)
6828 }
6829
6830 pub unsafe fn exit(&self, app: *mut ApplicationO) {
6831 self.exit.unwrap()(app)
6832 }
6833
6834 pub unsafe fn set_cursor_hidden(&self, app: *mut ApplicationO, hidden: bool) {
6835 self.set_cursor_hidden.unwrap()(app, hidden)
6836 }
6837
6838 pub unsafe fn viewer_manager(&self, app: *mut ApplicationO) -> *mut ViewerManagerO {
6839 self.viewer_manager.unwrap()(app)
6840 }
6841
6842 pub unsafe fn default_render_pipeline_api(
6843 &self,
6844 app: *mut ApplicationO,
6845 ) -> *mut RenderPipelineVt {
6846 self.default_render_pipeline_api.unwrap()(app)
6847 }
6848
6849 pub unsafe fn custom_ui_scale_factor(&self, app: *mut ApplicationO) -> f32 {
6850 self.custom_ui_scale_factor.unwrap()(app)
6851 }
6852
6853 pub unsafe fn display_scale_factor(&self, app: *mut ApplicationO, ui: *mut UiO) -> f32 {
6854 self.display_scale_factor.unwrap()(app, ui)
6855 }
6856
6857 pub unsafe fn data_dir(&self, app: *mut ApplicationO) -> *const ::std::os::raw::c_char {
6858 self.data_dir.unwrap()(app)
6859 }
6860
6861 pub unsafe fn color_space(
6862 &self,
6863 app: *const ApplicationO,
6864 color_space: *mut ColorSpaceDescT,
6865 format: *mut u32,
6866 ) {
6867 self.color_space.unwrap()(app, color_space, format)
6868 }
6869
6870 pub unsafe fn network(&self, app: *mut ApplicationO) -> *mut NetworkO {
6871 self.network.unwrap()(app)
6872 }
6873}
6874
6875impl crate::Api for ApplicationApi {
6876 const NAME: ConstCStr = const_cstr!("tm_application_api");
6877 const VERSION: VersionT = VersionT {
6878 major: 1u32,
6879 minor: 1u32,
6880 patch: 0u32,
6881 };
6882}
6883
6884impl AssetDatabaseApi {
6885 pub unsafe fn create(
6886 &self,
6887 file: *const ::std::os::raw::c_char,
6888 tt: *mut TheTruthO,
6889 config: *const AssetDatabaseConfigT,
6890 ) -> *mut AssetDatabaseO {
6891 self.create.unwrap()(file, tt, config)
6892 }
6893
6894 pub unsafe fn open(
6895 &self,
6896 file: *const ::std::os::raw::c_char,
6897 tt: *mut TheTruthO,
6898 config: *const AssetDatabaseConfigT,
6899 ) -> *mut AssetDatabaseO {
6900 self.open.unwrap()(file, tt, config)
6901 }
6902
6903 pub unsafe fn close(&self, db: *mut AssetDatabaseO) {
6904 self.close.unwrap()(db)
6905 }
6906
6907 pub unsafe fn save_modified(&self, db: *mut AssetDatabaseO, asset_root: TtIdT) {
6908 self.save_modified.unwrap()(db, asset_root)
6909 }
6910
6911 pub unsafe fn save_modified_except(
6912 &self,
6913 db: *mut AssetDatabaseO,
6914 asset_root: TtIdT,
6915 ignore: *mut TtIdT,
6916 num_ignore: u32,
6917 ) {
6918 self.save_modified_except.unwrap()(db, asset_root, ignore, num_ignore)
6919 }
6920
6921 pub unsafe fn save_asset(&self, db: *mut AssetDatabaseO, asset: TtIdT) {
6922 self.save_asset.unwrap()(db, asset)
6923 }
6924
6925 pub unsafe fn delete_asset(&self, db: *mut AssetDatabaseO, asset: TtIdT) {
6926 self.delete_asset.unwrap()(db, asset)
6927 }
6928
6929 pub unsafe fn revert_asset(
6930 &self,
6931 db: *mut AssetDatabaseO,
6932 asset: TtIdT,
6933 undo_scope: TtUndoScopeT,
6934 ) -> bool {
6935 self.revert_asset.unwrap()(db, asset, undo_scope)
6936 }
6937
6938 pub unsafe fn load(&self, db: *mut AssetDatabaseO, load_fraction: *mut f32) -> TtIdT {
6939 self.load.unwrap()(db, load_fraction)
6940 }
6941
6942 pub unsafe fn saved_name(
6943 &self,
6944 db: *mut AssetDatabaseO,
6945 item: UuidT,
6946 ) -> *const ::std::os::raw::c_char {
6947 self.saved_name.unwrap()(db, item)
6948 }
6949
6950 pub unsafe fn saved_directory(&self, db: *mut AssetDatabaseO, item: UuidT) -> UuidT {
6951 self.saved_directory.unwrap()(db, item)
6952 }
6953
6954 pub unsafe fn saved_version(&self, db: *mut AssetDatabaseO, asset: UuidT) -> u64 {
6955 self.saved_version.unwrap()(db, asset)
6956 }
6957
6958 pub unsafe fn all_saved_items(
6959 &self,
6960 db: *mut AssetDatabaseO,
6961 ta: *mut TempAllocatorI,
6962 ) -> *mut AssetDabaseSavedItemT {
6963 self.all_saved_items.unwrap()(db, ta)
6964 }
6965}
6966
6967impl crate::Api for AssetDatabaseApi {
6968 const NAME: ConstCStr = const_cstr!("tm_asset_database_api");
6969 const VERSION: VersionT = VersionT {
6970 major: 1u32,
6971 minor: 0u32,
6972 patch: 0u32,
6973 };
6974}
6975
6976impl AssetIoApi {
6977 pub unsafe fn add_asset_io(&self, loader: *mut AssetIoI) {
6978 self.add_asset_io.unwrap()(loader)
6979 }
6980
6981 pub unsafe fn remove_asset_io(&self, loader: *mut AssetIoI) {
6982 self.remove_asset_io.unwrap()(loader)
6983 }
6984
6985 pub unsafe fn importer(&self, extension: *const ::std::os::raw::c_char) -> *mut AssetIoI {
6986 self.importer.unwrap()(extension)
6987 }
6988
6989 pub unsafe fn reimporter(&self, tt: *mut TheTruthO, asset: TtIdT) -> *mut AssetIoI {
6990 self.reimporter.unwrap()(tt, asset)
6991 }
6992
6993 pub unsafe fn exporter(&self, tt: *mut TheTruthO, asset: TtIdT) -> *mut AssetIoI {
6994 self.exporter.unwrap()(tt, asset)
6995 }
6996
6997 pub unsafe fn io_interfaces(&self, interfaces: *mut *mut AssetIoI) -> u32 {
6998 self.io_interfaces.unwrap()(interfaces)
6999 }
7000}
7001
7002impl crate::Api for AssetIoApi {
7003 const NAME: ConstCStr = const_cstr!("tm_asset_io_api");
7004 const VERSION: VersionT = VersionT {
7005 major: 1u32,
7006 minor: 0u32,
7007 patch: 0u32,
7008 };
7009}
7010
7011impl Base64Api {
7012 pub unsafe fn encoded_size(&self, raw_size: u64) -> u64 {
7013 self.encoded_size.unwrap()(raw_size)
7014 }
7015
7016 pub unsafe fn encode(
7017 &self,
7018 encoded: *mut ::std::os::raw::c_char,
7019 raw: *const u8,
7020 raw_size: u64,
7021 ) -> u64 {
7022 self.encode.unwrap()(encoded, raw, raw_size)
7023 }
7024
7025 pub unsafe fn decoded_size(
7026 &self,
7027 encoded: *const ::std::os::raw::c_char,
7028 encoded_size: u64,
7029 ) -> u64 {
7030 self.decoded_size.unwrap()(encoded, encoded_size)
7031 }
7032
7033 pub unsafe fn decode(
7034 &self,
7035 raw: *mut u8,
7036 encoded: *const ::std::os::raw::c_char,
7037 encoded_size: u64,
7038 ) -> u64 {
7039 self.decode.unwrap()(raw, encoded, encoded_size)
7040 }
7041}
7042
7043impl BuddyAllocatorRawApi {
7044 pub unsafe fn init(&self, buffer: *mut u8, size: u32, block_size: u32) {
7045 self.init.unwrap()(buffer, size, block_size)
7046 }
7047
7048 pub unsafe fn realloc(
7049 &self,
7050 buffer: *mut u8,
7051 ptr: *mut ::std::os::raw::c_void,
7052 old_size: u64,
7053 new_size: u64,
7054 ) -> *mut ::std::os::raw::c_void {
7055 self.realloc.unwrap()(buffer, ptr, old_size, new_size)
7056 }
7057}
7058
7059impl crate::Api for BuddyAllocatorRawApi {
7060 const NAME: ConstCStr = const_cstr!("tm_buddy_allocator_raw_api");
7061 const VERSION: VersionT = VersionT {
7062 major: 1u32,
7063 minor: 0u32,
7064 patch: 0u32,
7065 };
7066}
7067
7068impl BuddyAllocatorApi {
7069 pub unsafe fn create(
7070 &self,
7071 backing: *mut AllocatorI,
7072 initial_size: u32,
7073 block_size: u32,
7074 ) -> *mut AllocatorI {
7075 self.create.unwrap()(backing, initial_size, block_size)
7076 }
7077
7078 pub unsafe fn destroy(&self, a: *mut AllocatorI) {
7079 self.destroy.unwrap()(a)
7080 }
7081}
7082
7083impl crate::Api for BuddyAllocatorApi {
7084 const NAME: ConstCStr = const_cstr!("tm_buddy_allocator_api");
7085 const VERSION: VersionT = VersionT {
7086 major: 1u32,
7087 minor: 0u32,
7088 patch: 0u32,
7089 };
7090}
7091
7092impl BuffersApi {
7093 pub unsafe fn create(&self, a: *mut AllocatorI) -> *mut BuffersI {
7094 self.create.unwrap()(a)
7095 }
7096
7097 pub unsafe fn destroy(&self, i: *mut BuffersI) {
7098 self.destroy.unwrap()(i)
7099 }
7100
7101 pub unsafe fn create_streamable(
7102 &self,
7103 a: *mut AllocatorI,
7104 io: *mut OsFileIoApi,
7105 ) -> *mut StreamableBuffersI {
7106 self.create_streamable.unwrap()(a, io)
7107 }
7108
7109 pub unsafe fn destroy_streamable(&self, i: *mut StreamableBuffersI) {
7110 self.destroy_streamable.unwrap()(i)
7111 }
7112}
7113
7114impl crate::Api for BuffersApi {
7115 const NAME: ConstCStr = const_cstr!("tm_buffers_api");
7116 const VERSION: VersionT = VersionT {
7117 major: 1u32,
7118 minor: 0u32,
7119 patch: 0u32,
7120 };
7121}
7122
7123impl BufferFormatApi {
7124 pub unsafe fn encode_uncompressed_format(
7125 &self,
7126 component_type: BufferComponentType,
7127 sign: bool,
7128 bits_x: u8,
7129 bits_y: u8,
7130 bits_z: u8,
7131 bits_w: u8,
7132 ) -> u32 {
7133 self.encode_uncompressed_format.unwrap()(
7134 component_type,
7135 sign,
7136 bits_x,
7137 bits_y,
7138 bits_z,
7139 bits_w,
7140 )
7141 }
7142
7143 pub unsafe fn encode_compressed_format(
7144 &self,
7145 compression_type: BufferCompressionFormat,
7146 ) -> u32 {
7147 self.encode_compressed_format.unwrap()(compression_type)
7148 }
7149
7150 pub unsafe fn is_compressed(&self, format: u32) -> bool {
7151 self.is_compressed.unwrap()(format)
7152 }
7153
7154 pub unsafe fn decode_uncompressed(
7155 &self,
7156 format: u32,
7157 component_type: *mut BufferComponentType,
7158 sign: *mut bool,
7159 bits_x: *mut u8,
7160 bits_y: *mut u8,
7161 bits_z: *mut u8,
7162 bits_w: *mut u8,
7163 ) -> bool {
7164 self.decode_uncompressed.unwrap()(
7165 format,
7166 component_type,
7167 sign,
7168 bits_x,
7169 bits_y,
7170 bits_z,
7171 bits_w,
7172 )
7173 }
7174
7175 pub unsafe fn decode_compression_format(
7176 &self,
7177 format: u32,
7178 compression_format: *mut BufferCompressionFormat,
7179 ) -> bool {
7180 self.decode_compression_format.unwrap()(format, compression_format)
7181 }
7182
7183 pub unsafe fn bits_per_element(&self, format: u32) -> u32 {
7184 self.bits_per_element.unwrap()(format)
7185 }
7186
7187 pub unsafe fn num_components(&self, format: u32) -> u32 {
7188 self.num_components.unwrap()(format)
7189 }
7190
7191 pub unsafe fn human_readable(
7192 &self,
7193 format: u32,
7194 ta: *mut TempAllocatorI,
7195 ) -> *const ::std::os::raw::c_char {
7196 self.human_readable.unwrap()(format, ta)
7197 }
7198}
7199
7200impl crate::Api for BufferFormatApi {
7201 const NAME: ConstCStr = const_cstr!("tm_buffer_format_api");
7202 const VERSION: VersionT = VersionT {
7203 major: 1u32,
7204 minor: 0u32,
7205 patch: 0u32,
7206 };
7207}
7208
7209impl CameraApi {
7210 pub unsafe fn view_from_transform(
7211 &self,
7212 view: *mut Mat44T,
7213 tm: *const TransformT,
7214 ) -> *mut Mat44T {
7215 self.view_from_transform.unwrap()(view, tm)
7216 }
7217
7218 pub unsafe fn view_from_lookin(
7219 &self,
7220 view: *mut Mat44T,
7221 position: Vec3T,
7222 forward: Vec3T,
7223 up: Vec3T,
7224 ) -> *mut Mat44T {
7225 self.view_from_lookin.unwrap()(view, position, forward, up)
7226 }
7227
7228 pub unsafe fn transform_from_view(
7229 &self,
7230 tm: *mut TransformT,
7231 view: *const Mat44T,
7232 ) -> *mut TransformT {
7233 self.transform_from_view.unwrap()(tm, view)
7234 }
7235
7236 pub unsafe fn projection_from_frustum(
7237 &self,
7238 proj: *mut Mat44T,
7239 left: f32,
7240 right: f32,
7241 bottom: f32,
7242 top: f32,
7243 near: f32,
7244 far: f32,
7245 ) -> *mut Mat44T {
7246 self.projection_from_frustum.unwrap()(proj, left, right, bottom, top, near, far)
7247 }
7248
7249 pub unsafe fn matrices_from_eyes(
7250 &self,
7251 camera: *mut CameraT,
7252 head_tm: *const Mat44T,
7253 head_to_left_eye: *const Mat44T,
7254 head_to_right_eye: *const Mat44T,
7255 left_eye_left: f32,
7256 left_eye_right: f32,
7257 left_eye_top: f32,
7258 left_eye_bottom: f32,
7259 right_eye_left: f32,
7260 right_eye_right: f32,
7261 right_eye_top: f32,
7262 right_eye_bottom: f32,
7263 ) {
7264 self.matrices_from_eyes.unwrap()(
7265 camera,
7266 head_tm,
7267 head_to_left_eye,
7268 head_to_right_eye,
7269 left_eye_left,
7270 left_eye_right,
7271 left_eye_top,
7272 left_eye_bottom,
7273 right_eye_left,
7274 right_eye_right,
7275 right_eye_top,
7276 right_eye_bottom,
7277 )
7278 }
7279
7280 pub unsafe fn projection_from_fov(
7281 &self,
7282 proj: *mut Mat44T,
7283 near_plane: f32,
7284 far_plane: f32,
7285 vertical_fov: f32,
7286 aspect: f32,
7287 ) -> *mut Mat44T {
7288 self.projection_from_fov.unwrap()(proj, near_plane, far_plane, vertical_fov, aspect)
7289 }
7290
7291 pub unsafe fn orthographic_from_frustum(
7292 &self,
7293 proj: *mut Mat44T,
7294 left: f32,
7295 right: f32,
7296 bottom: f32,
7297 top: f32,
7298 near: f32,
7299 far: f32,
7300 ) -> *mut Mat44T {
7301 self.orthographic_from_frustum.unwrap()(proj, left, right, bottom, top, near, far)
7302 }
7303
7304 pub unsafe fn orthographics_from_dimensions(
7305 &self,
7306 proj: *mut Mat44T,
7307 near_plane: f32,
7308 far_plane: f32,
7309 width: f32,
7310 height: f32,
7311 ) -> *mut Mat44T {
7312 self.orthographics_from_dimensions.unwrap()(proj, near_plane, far_plane, width, height)
7313 }
7314
7315 pub unsafe fn projection_from_camera(
7316 &self,
7317 camera: *mut CameraT,
7318 transform: CameraTransform,
7319 aspect: f32,
7320 ) -> *mut Mat44T {
7321 self.projection_from_camera.unwrap()(camera, transform, aspect)
7322 }
7323
7324 pub unsafe fn update_free_flight(&self, tm: *mut TransformT, t: Vec3T, r: Vec2T) {
7325 self.update_free_flight.unwrap()(tm, t, r)
7326 }
7327
7328 pub unsafe fn update_pan(&self, tm: *mut TransformT, focus_position: *mut Vec3T, pan: Vec2T) {
7329 self.update_pan.unwrap()(tm, focus_position, pan)
7330 }
7331
7332 pub unsafe fn update_maya(
7333 &self,
7334 tm: *mut TransformT,
7335 focus_position: Vec3T,
7336 zoom: f32,
7337 rot: Vec2T,
7338 ) {
7339 self.update_maya.unwrap()(tm, focus_position, zoom, rot)
7340 }
7341
7342 pub unsafe fn world_to_screen(
7343 &self,
7344 camera: *const CameraT,
7345 transform: CameraTransform,
7346 viewport: RectT,
7347 world: *const Vec3T,
7348 screen: *mut Vec3T,
7349 n: u32,
7350 ) -> *mut Vec3T {
7351 self.world_to_screen.unwrap()(camera, transform, viewport, world, screen, n)
7352 }
7353
7354 pub unsafe fn screen_to_world(
7355 &self,
7356 camera: *const CameraT,
7357 transform: CameraTransform,
7358 viewport: RectT,
7359 screen: *const Vec3T,
7360 world: *mut Vec3T,
7361 n: u32,
7362 ) -> *mut Vec3T {
7363 self.screen_to_world.unwrap()(camera, transform, viewport, screen, world, n)
7364 }
7365
7366 pub unsafe fn meters_per_pixel(
7367 &self,
7368 distance: f32,
7369 vertical_fov: f32,
7370 viewport_height: f32,
7371 ) -> f32 {
7372 self.meters_per_pixel.unwrap()(distance, vertical_fov, viewport_height)
7373 }
7374
7375 pub unsafe fn default_camera_settings(&self) -> *const CameraSettingsT {
7376 self.default_camera_settings.unwrap()()
7377 }
7378
7379 pub unsafe fn frustum_planes_from_view_projection(
7380 &self,
7381 view: *const Mat44T,
7382 projection: *const Mat44T,
7383 frustum_planes: *mut Vec4T,
7384 ) {
7385 self.frustum_planes_from_view_projection.unwrap()(view, projection, frustum_planes)
7386 }
7387}
7388
7389impl crate::Api for CameraApi {
7390 const NAME: ConstCStr = const_cstr!("tm_camera_api");
7391 const VERSION: VersionT = VersionT {
7392 major: 1u32,
7393 minor: 0u32,
7394 patch: 0u32,
7395 };
7396}
7397
7398impl CollaborationApi {
7399 pub unsafe fn create(
7400 &self,
7401 a: *mut AllocatorI,
7402 config: *const CollaborationConfigI,
7403 ) -> *mut CollaborationO {
7404 self.create.unwrap()(a, config)
7405 }
7406
7407 pub unsafe fn destroy(&self, coll: *mut CollaborationO) {
7408 self.destroy.unwrap()(coll)
7409 }
7410
7411 pub unsafe fn status(&self, coll: *const CollaborationO) -> CollaborationStatus {
7412 self.status.unwrap()(coll)
7413 }
7414
7415 pub unsafe fn is_downloading(
7416 &self,
7417 coll: *const CollaborationO,
7418 bytes: *mut u64,
7419 total: *mut u64,
7420 ) -> bool {
7421 self.is_downloading.unwrap()(coll, bytes, total)
7422 }
7423
7424 pub unsafe fn set_session(
7425 &self,
7426 coll: *mut CollaborationO,
7427 session: *const CollaborationSessionI,
7428 ) {
7429 self.set_session.unwrap()(coll, session)
7430 }
7431
7432 pub unsafe fn session(&self, coll: *mut CollaborationO) -> *mut CollaborationSessionI {
7433 self.session.unwrap()(coll)
7434 }
7435
7436 pub unsafe fn disconnect(&self, coll: *mut CollaborationO) {
7437 self.disconnect.unwrap()(coll)
7438 }
7439
7440 pub unsafe fn update(&self, coll: *mut CollaborationO) {
7441 self.update.unwrap()(coll)
7442 }
7443
7444 pub unsafe fn handle(&self, coll: *const CollaborationO) -> *const ::std::os::raw::c_char {
7445 self.handle.unwrap()(coll)
7446 }
7447
7448 pub unsafe fn set_handle(&self, c: *mut CollaborationO, handle: *mut ::std::os::raw::c_char) {
7449 self.set_handle.unwrap()(c, handle)
7450 }
7451
7452 pub unsafe fn host_handle(&self, c: *const CollaborationO) -> *const ::std::os::raw::c_char {
7453 self.host_handle.unwrap()(c)
7454 }
7455
7456 pub unsafe fn num_clients(&self, coll: *const CollaborationO) -> u32 {
7457 self.num_clients.unwrap()(coll)
7458 }
7459
7460 pub unsafe fn client_handle(
7461 &self,
7462 coll: *const CollaborationO,
7463 i: u32,
7464 ) -> *const ::std::os::raw::c_char {
7465 self.client_handle.unwrap()(coll, i)
7466 }
7467
7468 pub unsafe fn all_handles(
7469 &self,
7470 coll: *const CollaborationO,
7471 ta: *mut TempAllocatorI,
7472 ) -> *mut *const ::std::os::raw::c_char {
7473 self.all_handles.unwrap()(coll, ta)
7474 }
7475
7476 pub unsafe fn send_chat(&self, coll: *mut CollaborationO, msg: *const ::std::os::raw::c_char) {
7477 self.send_chat.unwrap()(coll, msg)
7478 }
7479
7480 pub unsafe fn num_chat_messages(&self, coll: *const CollaborationO) -> u32 {
7481 self.num_chat_messages.unwrap()(coll)
7482 }
7483
7484 pub unsafe fn chat_message(
7485 &self,
7486 coll: *const CollaborationO,
7487 i: u32,
7488 sender: *mut *const ::std::os::raw::c_char,
7489 ) -> *const ::std::os::raw::c_char {
7490 self.chat_message.unwrap()(coll, i, sender)
7491 }
7492
7493 pub unsafe fn resynchronize_state(&self, coll: *mut CollaborationO, tt: *mut TheTruthO) {
7494 self.resynchronize_state.unwrap()(coll, tt)
7495 }
7496
7497 pub unsafe fn send_test_packages(&self, coll: *mut CollaborationO, size: u64, num: u32) {
7498 self.send_test_packages.unwrap()(coll, size, num)
7499 }
7500}
7501
7502impl crate::Api for CollaborationApi {
7503 const NAME: ConstCStr = const_cstr!("tm_collaboration_api");
7504 const VERSION: VersionT = VersionT {
7505 major: 1u32,
7506 minor: 0u32,
7507 patch: 0u32,
7508 };
7509}
7510
7511impl CollaborationP2pApi {
7512 pub unsafe fn create(
7513 &self,
7514 coll: *mut CollaborationO,
7515 allocator: *mut AllocatorI,
7516 ) -> *mut CollaborationP2pO {
7517 self.create.unwrap()(coll, allocator)
7518 }
7519
7520 pub unsafe fn destroy(&self, coll_p2p: *mut CollaborationP2pO) {
7521 self.destroy.unwrap()(coll_p2p)
7522 }
7523
7524 pub unsafe fn update(&self, coll_p2p: *mut CollaborationP2pO) {
7525 self.update.unwrap()(coll_p2p)
7526 }
7527
7528 pub unsafe fn host(&self, coll_p2p: *mut CollaborationP2pO, port: u32, use_upnp: bool) {
7529 self.host.unwrap()(coll_p2p, port, use_upnp)
7530 }
7531
7532 pub unsafe fn connect(&self, coll_p2p: *mut CollaborationP2pO, address: *const SocketAddressT) {
7533 self.connect.unwrap()(coll_p2p, address)
7534 }
7535
7536 pub unsafe fn discovered_lan_hosts(
7537 &self,
7538 coll_p2p: *const CollaborationP2pO,
7539 hosts: *mut CollaborationDiscoveredHostT,
7540 max_hosts: u32,
7541 ) -> u32 {
7542 self.discovered_lan_hosts.unwrap()(coll_p2p, hosts, max_hosts)
7543 }
7544}
7545
7546impl crate::Api for CollaborationP2pApi {
7547 const NAME: ConstCStr = const_cstr!("tm_collaboration_p2p_api");
7548 const VERSION: VersionT = VersionT {
7549 major: 1u32,
7550 minor: 0u32,
7551 patch: 0u32,
7552 };
7553}
7554
7555impl ConfigApi {
7556 pub unsafe fn create(&self, a: *mut AllocatorI) -> *mut ConfigI {
7557 self.create.unwrap()(a)
7558 }
7559
7560 pub unsafe fn destroy(&self, cdi: *mut ConfigI) {
7561 self.destroy.unwrap()(cdi)
7562 }
7563}
7564
7565impl crate::Api for ConfigApi {
7566 const NAME: ConstCStr = const_cstr!("tm_config_api");
7567 const VERSION: VersionT = VersionT {
7568 major: 1u32,
7569 minor: 0u32,
7570 patch: 0u32,
7571 };
7572}
7573
7574impl CoreApi {
7575 pub unsafe fn create(&self, tt: *mut TheTruthO, asset_root_id: TtIdT) {
7576 self.create.unwrap()(tt, asset_root_id)
7577 }
7578
7579 pub unsafe fn query_updatable(
7580 &self,
7581 tt: *mut TheTruthO,
7582 asset_root_id: TtIdT,
7583 include_skipped: bool,
7584 ta: *mut TempAllocatorI,
7585 ) -> CoreUpdatableAssetsT {
7586 self.query_updatable.unwrap()(tt, asset_root_id, include_skipped, ta)
7587 }
7588
7589 pub unsafe fn update(
7590 &self,
7591 tt: *mut TheTruthO,
7592 asset_root_id: TtIdT,
7593 to_skip: *mut *mut CoreAssetI,
7594 num_to_skip: u32,
7595 include_skipped: bool,
7596 ta: *mut TempAllocatorI,
7597 ) -> CoreUpdateResultT {
7598 self.update.unwrap()(tt, asset_root_id, to_skip, num_to_skip, include_skipped, ta)
7599 }
7600
7601 pub unsafe fn locate_asset(
7602 &self,
7603 tt: *mut TheTruthO,
7604 asset_root_id: TtIdT,
7605 core_id: StrhashT,
7606 ) -> TtIdT {
7607 self.locate_asset.unwrap()(tt, asset_root_id, core_id)
7608 }
7609}
7610
7611impl crate::Api for CoreApi {
7612 const NAME: ConstCStr = const_cstr!("tm_core_api");
7613 const VERSION: VersionT = VersionT {
7614 major: 2u32,
7615 minor: 0u32,
7616 patch: 0u32,
7617 };
7618}
7619
7620impl CoreImporterApi {
7621 pub unsafe fn create(
7622 &self,
7623 a: *mut AllocatorI,
7624 user_tt: *mut TheTruthO,
7625 user_asset_root: TtIdT,
7626 core_project_path: *const ::std::os::raw::c_char,
7627 output_path: *const ::std::os::raw::c_char,
7628 ) -> *mut CoreImporterStateO {
7629 self.create.unwrap()(a, user_tt, user_asset_root, core_project_path, output_path)
7630 }
7631
7632 pub unsafe fn destroy(&self, state: *mut CoreImporterStateO) {
7633 self.destroy.unwrap()(state)
7634 }
7635
7636 pub unsafe fn register_assets(
7637 &self,
7638 state: *mut CoreImporterStateO,
7639 to_register: *const CoreImporterAssetT,
7640 num_to_register: u32,
7641 ) {
7642 self.register_assets.unwrap()(state, to_register, num_to_register)
7643 }
7644}
7645
7646impl crate::Api for CoreImporterApi {
7647 const NAME: ConstCStr = const_cstr!("tm_core_importer_api");
7648 const VERSION: VersionT = VersionT {
7649 major: 1u32,
7650 minor: 0u32,
7651 patch: 0u32,
7652 };
7653}
7654
7655impl CrashRecoveryApi {
7656 pub unsafe fn create(
7657 &self,
7658 a: *mut AllocatorI,
7659 recovery_path: *const ::std::os::raw::c_char,
7660 ) -> *mut CrashRecoveryO {
7661 self.create.unwrap()(a, recovery_path)
7662 }
7663
7664 pub unsafe fn destroy(&self, cr: *mut CrashRecoveryO) {
7665 self.destroy.unwrap()(cr)
7666 }
7667
7668 pub unsafe fn start_recording(
7669 &self,
7670 cr: *mut CrashRecoveryO,
7671 project: *const ::std::os::raw::c_char,
7672 tt: *mut TheTruthO,
7673 root: TtIdT,
7674 ) {
7675 self.start_recording.unwrap()(cr, project, tt, root)
7676 }
7677
7678 pub unsafe fn stop_recording(&self, cr: *mut CrashRecoveryO) {
7679 self.stop_recording.unwrap()(cr)
7680 }
7681
7682 pub unsafe fn update(&self, cr: *mut CrashRecoveryO) {
7683 self.update.unwrap()(cr)
7684 }
7685
7686 pub unsafe fn can_recover(
7687 &self,
7688 cr: *mut CrashRecoveryO,
7689 ta: *mut TempAllocatorI,
7690 ) -> CrashRecoveryCanRecoverResultT {
7691 self.can_recover.unwrap()(cr, ta)
7692 }
7693
7694 pub unsafe fn recover(
7695 &self,
7696 cr: *mut CrashRecoveryO,
7697 rd: CrashRecoveryCanRecoverResultT,
7698 tt: *mut TheTruthO,
7699 ) {
7700 self.recover.unwrap()(cr, rd, tt)
7701 }
7702
7703 pub unsafe fn delete_physical_file(&self, cr: *mut CrashRecoveryO) {
7704 self.delete_physical_file.unwrap()(cr)
7705 }
7706}
7707
7708impl crate::Api for CrashRecoveryApi {
7709 const NAME: ConstCStr = const_cstr!("tm_crash_recovery_api");
7710 const VERSION: VersionT = VersionT {
7711 major: 2u32,
7712 minor: 0u32,
7713 patch: 0u32,
7714 };
7715}
7716
7717impl ErrorApi {
7718 pub unsafe fn create_record_handler(&self, mem: *mut ErrorRecordT) -> ErrorI {
7719 self.create_record_handler.unwrap()(mem)
7720 }
7721}
7722
7723impl crate::Api for ErrorApi {
7724 const NAME: ConstCStr = const_cstr!("tm_error_api");
7725 const VERSION: VersionT = VersionT {
7726 major: 1u32,
7727 minor: 0u32,
7728 patch: 0u32,
7729 };
7730}
7731
7732impl FeatureFlagsApi {
7733 pub unsafe fn enabled(&self, flag: StrhashT) -> bool {
7734 self.enabled.unwrap()(flag)
7735 }
7736
7737 pub unsafe fn set_enabled(&self, flag: StrhashT, enabled: bool) {
7738 self.set_enabled.unwrap()(flag, enabled)
7739 }
7740
7741 pub unsafe fn all_enabled(&self, count: *mut u32) -> *const StrhashT {
7742 self.all_enabled.unwrap()(count)
7743 }
7744}
7745
7746impl crate::Api for FeatureFlagsApi {
7747 const NAME: ConstCStr = const_cstr!("tm_feature_flags_api");
7748 const VERSION: VersionT = VersionT {
7749 major: 1u32,
7750 minor: 0u32,
7751 patch: 0u32,
7752 };
7753}
7754
7755impl GitIgnoreApi {
7756 pub unsafe fn match_(
7757 &self,
7758 patterns: *const ::std::os::raw::c_char,
7759 path: *const ::std::os::raw::c_char,
7760 ) -> bool {
7761 self.match_.unwrap()(patterns, path)
7762 }
7763}
7764
7765impl crate::Api for GitIgnoreApi {
7766 const NAME: ConstCStr = const_cstr!("tm_git_ignore_api");
7767 const VERSION: VersionT = VersionT {
7768 major: 1u32,
7769 minor: 0u32,
7770 patch: 0u32,
7771 };
7772}
7773
7774impl ImageLoaderApi {
7775 pub unsafe fn add_loader(&self, loader: *mut ImageLoaderI) {
7776 self.add_loader.unwrap()(loader)
7777 }
7778
7779 pub unsafe fn remove_loader(&self, loader: *mut ImageLoaderI) {
7780 self.remove_loader.unwrap()(loader)
7781 }
7782
7783 pub unsafe fn loader_from_archive(
7784 &self,
7785 image_archive: *mut ImageArchiveI,
7786 ) -> *mut ImageLoaderI {
7787 self.loader_from_archive.unwrap()(image_archive)
7788 }
7789
7790 pub unsafe fn loader_from_extension(
7791 &self,
7792 extension: *const ::std::os::raw::c_char,
7793 ) -> *mut ImageLoaderI {
7794 self.loader_from_extension.unwrap()(extension)
7795 }
7796
7797 pub unsafe fn loaders(&self, loaders: *mut *mut ImageLoaderI) -> u32 {
7798 self.loaders.unwrap()(loaders)
7799 }
7800}
7801
7802impl crate::Api for ImageLoaderApi {
7803 const NAME: ConstCStr = const_cstr!("tm_image_loader_api");
7804 const VERSION: VersionT = VersionT {
7805 major: 1u32,
7806 minor: 0u32,
7807 patch: 0u32,
7808 };
7809}
7810
7811impl InputApi {
7812 pub unsafe fn add_source(&self, source: *mut InputSourceI) {
7813 self.add_source.unwrap()(source)
7814 }
7815
7816 pub unsafe fn remove_source(&self, source: *mut InputSourceI) {
7817 self.remove_source.unwrap()(source)
7818 }
7819
7820 pub unsafe fn sources(&self, sources: *mut *mut *mut InputSourceI) -> u32 {
7821 self.sources.unwrap()(sources)
7822 }
7823
7824 pub unsafe fn events(&self, start: u64, events: *mut InputEventT, buffer_size: u64) -> u64 {
7825 self.events.unwrap()(start, events, buffer_size)
7826 }
7827
7828 pub unsafe fn keyboard_item_names(&self) -> *mut *const ::std::os::raw::c_char {
7829 self.keyboard_item_names.unwrap()()
7830 }
7831}
7832
7833impl crate::Api for InputApi {
7834 const NAME: ConstCStr = const_cstr!("tm_input_api");
7835 const VERSION: VersionT = VersionT {
7836 major: 1u32,
7837 minor: 0u32,
7838 patch: 0u32,
7839 };
7840}
7841
7842impl JobSystemApi {
7843 pub unsafe fn run_jobs(&self, jobs: *mut JobdeclT, num_jobs: u32) -> *mut AtomicCounterO {
7844 self.run_jobs.unwrap()(jobs, num_jobs)
7845 }
7846
7847 pub unsafe fn run_jobs_and_auto_free_counter(&self, jobs: *mut JobdeclT, num_jobs: u32) {
7848 self.run_jobs_and_auto_free_counter.unwrap()(jobs, num_jobs)
7849 }
7850
7851 pub unsafe fn wait_for_counter(&self, counter: *mut AtomicCounterO, value: u32) {
7852 self.wait_for_counter.unwrap()(counter, value)
7853 }
7854
7855 pub unsafe fn wait_for_counter_and_free(&self, counter: *mut AtomicCounterO) {
7856 self.wait_for_counter_and_free.unwrap()(counter)
7857 }
7858
7859 pub unsafe fn wait_for_counter_and_free_no_fiber(&self, counter: *mut AtomicCounterO) {
7860 self.wait_for_counter_and_free_no_fiber.unwrap()(counter)
7861 }
7862
7863 pub unsafe fn pin_thread_handle(&self, worker_thread_index: u32) -> u32 {
7864 self.pin_thread_handle.unwrap()(worker_thread_index)
7865 }
7866
7867 pub unsafe fn num_worker_threads(&self) -> u32 {
7868 self.num_worker_threads.unwrap()()
7869 }
7870}
7871
7872impl crate::Api for JobSystemApi {
7873 const NAME: ConstCStr = const_cstr!("tm_job_system_api");
7874 const VERSION: VersionT = VersionT {
7875 major: 1u32,
7876 minor: 0u32,
7877 patch: 0u32,
7878 };
7879}
7880
7881impl JsonApi {
7882 pub unsafe fn parse(
7883 &self,
7884 s: *const ::std::os::raw::c_char,
7885 config: *mut ConfigI,
7886 extensions: JsonParseExt,
7887 error: *mut ::std::os::raw::c_char,
7888 ) -> bool {
7889 self.parse.unwrap()(s, config, extensions, error)
7890 }
7891
7892 pub unsafe fn parse_with_line_info(
7893 &self,
7894 s: *const ::std::os::raw::c_char,
7895 config: *mut ConfigI,
7896 extensions: JsonParseExt,
7897 ta: *mut TempAllocatorI,
7898 ) -> *mut JsonParseInfoT {
7899 self.parse_with_line_info.unwrap()(s, config, extensions, ta)
7900 }
7901
7902 pub unsafe fn line_number(&self, pi: *const JsonParseInfoT, item: *const ConfigItemT) -> u32 {
7903 self.line_number.unwrap()(pi, item)
7904 }
7905
7906 pub unsafe fn generate(
7907 &self,
7908 config: *mut ConfigI,
7909 flags: JsonGenerateExt,
7910 ta: *mut TempAllocatorI,
7911 ) -> JsonGenerateT {
7912 self.generate.unwrap()(config, flags, ta)
7913 }
7914}
7915
7916impl crate::Api for JsonApi {
7917 const NAME: ConstCStr = const_cstr!("tm_json_api");
7918 const VERSION: VersionT = VersionT {
7919 major: 1u32,
7920 minor: 0u32,
7921 patch: 0u32,
7922 };
7923}
7924
7925impl LocalizerApi {}
7926
7927impl crate::Api for LocalizerApi {
7928 const NAME: ConstCStr = const_cstr!("tm_localizer_api");
7929 const VERSION: VersionT = VersionT {
7930 major: 1u32,
7931 minor: 0u32,
7932 patch: 0u32,
7933 };
7934}
7935
7936impl LoggerApi {
7937 pub unsafe fn add_logger(&self, logger: *const LoggerI) {
7938 self.add_logger.unwrap()(logger)
7939 }
7940
7941 pub unsafe fn remove_logger(&self, logger: *const LoggerI) {
7942 self.remove_logger.unwrap()(logger)
7943 }
7944
7945 pub unsafe fn print(&self, log_type: LogType, msg: *const ::std::os::raw::c_char) {
7946 self.print.unwrap()(log_type, msg)
7947 }
7948
7949 pub unsafe fn printf(
7950 &self,
7951 log_type: LogType,
7952 format: *const ::std::os::raw::c_char,
7953 ) -> ::std::os::raw::c_int {
7954 self.printf.unwrap()(log_type, format)
7955 }
7956}
7957
7958impl crate::Api for LoggerApi {
7959 const NAME: ConstCStr = const_cstr!("tm_logger_api");
7960 const VERSION: VersionT = VersionT {
7961 major: 1u32,
7962 minor: 0u32,
7963 patch: 0u32,
7964 };
7965}
7966
7967impl Lz4Api {
7968 pub unsafe fn compress(
7969 &self,
7970 src: *const ::std::os::raw::c_char,
7971 src_size: u32,
7972 dst: *mut ::std::os::raw::c_char,
7973 dst_capacity: u32,
7974 ) -> u32 {
7975 self.compress.unwrap()(src, src_size, dst, dst_capacity)
7976 }
7977
7978 pub unsafe fn decompress(
7979 &self,
7980 src: *const ::std::os::raw::c_char,
7981 src_size: u32,
7982 dst: *mut ::std::os::raw::c_char,
7983 dst_capacity: u32,
7984 ) -> u32 {
7985 self.decompress.unwrap()(src, src_size, dst, dst_capacity)
7986 }
7987
7988 pub unsafe fn compress_bound(&self, src_size: u32) -> u32 {
7989 self.compress_bound.unwrap()(src_size)
7990 }
7991}
7992
7993impl crate::Api for Lz4Api {
7994 const NAME: ConstCStr = const_cstr!("tm_lz4_api");
7995 const VERSION: VersionT = VersionT {
7996 major: 1u32,
7997 minor: 0u32,
7998 patch: 0u32,
7999 };
8000}
8001
8002impl MathApi {
8003 pub unsafe fn mat44_multiply(&self, res: *mut Mat44T, lhs: *const Mat44T, rhs: *const Mat44T) {
8004 self.mat44_multiply.unwrap()(res, lhs, rhs)
8005 }
8006
8007 pub unsafe fn mat44_inverse(&self, res: *mut Mat44T, m: *const Mat44T) {
8008 self.mat44_inverse.unwrap()(res, m)
8009 }
8010
8011 pub unsafe fn mat44_determinant(&self, m: *const Mat44T) -> f32 {
8012 self.mat44_determinant.unwrap()(m)
8013 }
8014
8015 pub unsafe fn mat44_determinant33(&self, m: *const Mat44T) -> f32 {
8016 self.mat44_determinant33.unwrap()(m)
8017 }
8018
8019 pub unsafe fn mat44_to_quaternion(&self, m: *const Mat44T) -> Vec4T {
8020 self.mat44_to_quaternion.unwrap()(m)
8021 }
8022
8023 pub unsafe fn mat44_to_translation_quaternion_scale(
8024 &self,
8025 t: *mut Vec3T,
8026 r: *mut Vec4T,
8027 s: *mut Vec3T,
8028 m: *const Mat44T,
8029 ) {
8030 self.mat44_to_translation_quaternion_scale.unwrap()(t, r, s, m)
8031 }
8032}
8033
8034impl crate::Api for MathApi {
8035 const NAME: ConstCStr = const_cstr!("tm_math_api");
8036 const VERSION: VersionT = VersionT {
8037 major: 1u32,
8038 minor: 0u32,
8039 patch: 0u32,
8040 };
8041}
8042
8043impl MemoryTrackerApi {
8044 pub unsafe fn check_for_leaked_scopes(&self) {
8045 self.check_for_leaked_scopes.unwrap()()
8046 }
8047
8048 pub unsafe fn create_scope(
8049 &self,
8050 desc: *const ::std::os::raw::c_char,
8051 parent_scope: u32,
8052 ) -> u32 {
8053 self.create_scope.unwrap()(desc, parent_scope)
8054 }
8055
8056 pub unsafe fn destroy_scope(&self, s: u32) {
8057 self.destroy_scope.unwrap()(s)
8058 }
8059
8060 pub unsafe fn destroy_scope_allowing_leaks(&self, scope: u32, max_leaked_bytes: u64) {
8061 self.destroy_scope_allowing_leaks.unwrap()(scope, max_leaked_bytes)
8062 }
8063
8064 pub unsafe fn record_realloc(
8065 &self,
8066 old_ptr: *mut ::std::os::raw::c_void,
8067 old_size: u64,
8068 new_ptr: *mut ::std::os::raw::c_void,
8069 new_size: u64,
8070 file: *const ::std::os::raw::c_char,
8071 line: u32,
8072 scope: u32,
8073 ) {
8074 self.record_realloc.unwrap()(old_ptr, old_size, new_ptr, new_size, file, line, scope)
8075 }
8076
8077 pub unsafe fn allocated_bytes(&self, scope: u32) -> u64 {
8078 self.allocated_bytes.unwrap()(scope)
8079 }
8080
8081 pub unsafe fn allocation_count(&self, scope: u32) -> u64 {
8082 self.allocation_count.unwrap()(scope)
8083 }
8084
8085 pub unsafe fn set_scope_tracing(&self, scope: u32, enabled: bool) {
8086 self.set_scope_tracing.unwrap()(scope, enabled)
8087 }
8088
8089 pub unsafe fn scope_data_snapshot(
8090 &self,
8091 ta: *mut TempAllocatorI,
8092 ) -> *mut MemoryTrackerScopeDataT {
8093 self.scope_data_snapshot.unwrap()(ta)
8094 }
8095
8096 pub unsafe fn trace_data_snapshot(
8097 &self,
8098 ta: *mut TempAllocatorI,
8099 ) -> *mut MemoryTrackerTraceDataT {
8100 self.trace_data_snapshot.unwrap()(ta)
8101 }
8102}
8103
8104impl crate::Api for MemoryTrackerApi {
8105 const NAME: ConstCStr = const_cstr!("tm_memory_tracker_api");
8106 const VERSION: VersionT = VersionT {
8107 major: 1u32,
8108 minor: 0u32,
8109 patch: 0u32,
8110 };
8111}
8112
8113impl OsVirtualMemoryApi {
8114 pub unsafe fn map(&self, size: u64) -> *mut ::std::os::raw::c_void {
8115 self.map.unwrap()(size)
8116 }
8117
8118 pub unsafe fn unmap(&self, p: *mut ::std::os::raw::c_void, size: u64) {
8119 self.unmap.unwrap()(p, size)
8120 }
8121
8122 pub unsafe fn reserve(&self, size: u64) -> *mut ::std::os::raw::c_void {
8123 self.reserve.unwrap()(size)
8124 }
8125
8126 pub unsafe fn commit(&self, p: *mut ::std::os::raw::c_void, size: u64) {
8127 self.commit.unwrap()(p, size)
8128 }
8129}
8130
8131impl crate::Api for OsVirtualMemoryApi {
8132 const NAME: ConstCStr = const_cstr!("tm_os_virtual_memory_api");
8133 const VERSION: VersionT = VersionT {
8134 major: 1u32,
8135 minor: 0u32,
8136 patch: 0u32,
8137 };
8138}
8139
8140impl OsFileIoApi {
8141 pub unsafe fn open_input(&self, path: *const ::std::os::raw::c_char) -> FileO {
8142 self.open_input.unwrap()(path)
8143 }
8144
8145 pub unsafe fn open_output(&self, path: *const ::std::os::raw::c_char) -> FileO {
8146 self.open_output.unwrap()(path)
8147 }
8148
8149 pub unsafe fn open_append(&self, path: *const ::std::os::raw::c_char) -> FileO {
8150 self.open_append.unwrap()(path)
8151 }
8152
8153 pub unsafe fn set_position(&self, file: FileO, pos: u64) {
8154 self.set_position.unwrap()(file, pos)
8155 }
8156
8157 pub unsafe fn size(&self, file: FileO) -> u64 {
8158 self.size.unwrap()(file)
8159 }
8160
8161 pub unsafe fn read(&self, file: FileO, buffer: *mut ::std::os::raw::c_void, size: u64) -> i64 {
8162 self.read.unwrap()(file, buffer, size)
8163 }
8164
8165 pub unsafe fn write(
8166 &self,
8167 file: FileO,
8168 buffer: *const ::std::os::raw::c_void,
8169 size: u64,
8170 ) -> bool {
8171 self.write.unwrap()(file, buffer, size)
8172 }
8173
8174 pub unsafe fn read_at(
8175 &self,
8176 file: FileO,
8177 offset: u64,
8178 buffer: *mut ::std::os::raw::c_void,
8179 size: u64,
8180 ) -> i64 {
8181 self.read_at.unwrap()(file, offset, buffer, size)
8182 }
8183
8184 pub unsafe fn write_at(
8185 &self,
8186 file: FileO,
8187 offset: u64,
8188 buffer: *const ::std::os::raw::c_void,
8189 size: u64,
8190 ) -> bool {
8191 self.write_at.unwrap()(file, offset, buffer, size)
8192 }
8193
8194 pub unsafe fn set_last_modified_time(&self, file: FileO, time: FileTimeO) {
8195 self.set_last_modified_time.unwrap()(file, time)
8196 }
8197
8198 pub unsafe fn close(&self, file: FileO) {
8199 self.close.unwrap()(file)
8200 }
8201}
8202
8203impl crate::Api for OsFileIoApi {
8204 const NAME: ConstCStr = const_cstr!("tm_os_file_io_api");
8205 const VERSION: VersionT = VersionT {
8206 major: 1u32,
8207 minor: 0u32,
8208 patch: 0u32,
8209 };
8210}
8211
8212impl OsFileSystemApi {
8213 pub unsafe fn stat(&self, path: *const ::std::os::raw::c_char) -> FileStatT {
8214 self.stat.unwrap()(path)
8215 }
8216
8217 pub unsafe fn directory_entries(
8218 &self,
8219 path: *const ::std::os::raw::c_char,
8220 ta: *mut TempAllocatorI,
8221 ) -> *mut StringsT {
8222 self.directory_entries.unwrap()(path, ta)
8223 }
8224
8225 pub unsafe fn make_directory(&self, path: *const ::std::os::raw::c_char) -> bool {
8226 self.make_directory.unwrap()(path)
8227 }
8228
8229 pub unsafe fn remove_file(&self, path: *const ::std::os::raw::c_char) -> bool {
8230 self.remove_file.unwrap()(path)
8231 }
8232
8233 pub unsafe fn remove_directory(&self, path: *const ::std::os::raw::c_char) -> bool {
8234 self.remove_directory.unwrap()(path)
8235 }
8236
8237 pub unsafe fn rename(
8238 &self,
8239 old_name: *const ::std::os::raw::c_char,
8240 new_name: *const ::std::os::raw::c_char,
8241 ) -> bool {
8242 self.rename.unwrap()(old_name, new_name)
8243 }
8244
8245 pub unsafe fn copy_file(
8246 &self,
8247 from: *const ::std::os::raw::c_char,
8248 to: *const ::std::os::raw::c_char,
8249 ) -> bool {
8250 self.copy_file.unwrap()(from, to)
8251 }
8252
8253 pub unsafe fn getcwd(&self, ta: *mut TempAllocatorI) -> *const ::std::os::raw::c_char {
8254 self.getcwd.unwrap()(ta)
8255 }
8256
8257 pub unsafe fn chdir(&self, path: *const ::std::os::raw::c_char) -> bool {
8258 self.chdir.unwrap()(path)
8259 }
8260
8261 pub unsafe fn is_absolute(&self, path: *const ::std::os::raw::c_char) -> bool {
8262 self.is_absolute.unwrap()(path)
8263 }
8264
8265 pub unsafe fn absolute(
8266 &self,
8267 path: *const ::std::os::raw::c_char,
8268 ta: *mut TempAllocatorI,
8269 ) -> *const ::std::os::raw::c_char {
8270 self.absolute.unwrap()(path, ta)
8271 }
8272
8273 pub unsafe fn temp_directory(&self, ta: *mut TempAllocatorI) -> *const ::std::os::raw::c_char {
8274 self.temp_directory.unwrap()(ta)
8275 }
8276
8277 pub unsafe fn create_watcher(
8278 &self,
8279 subtree_path: *const ::std::os::raw::c_char,
8280 ) -> FileSystemWatcherO {
8281 self.create_watcher.unwrap()(subtree_path)
8282 }
8283
8284 pub unsafe fn any_changes(&self, watcher: FileSystemWatcherO) -> bool {
8285 self.any_changes.unwrap()(watcher)
8286 }
8287
8288 pub unsafe fn destroy_watcher(&self, watcher: FileSystemWatcherO) {
8289 self.destroy_watcher.unwrap()(watcher)
8290 }
8291
8292 pub unsafe fn create_detailed_watcher(
8293 &self,
8294 subtree_path: *const ::std::os::raw::c_char,
8295 ) -> *mut FileSystemDetailedWatcherO {
8296 self.create_detailed_watcher.unwrap()(subtree_path)
8297 }
8298
8299 pub unsafe fn detailed_changes(
8300 &self,
8301 arg1: *mut FileSystemDetailedWatcherO,
8302 ta: *mut TempAllocatorI,
8303 ) -> *mut FileSystemChangeT {
8304 self.detailed_changes.unwrap()(arg1, ta)
8305 }
8306
8307 pub unsafe fn destroy_detailed_watcher(&self, watcher: *mut FileSystemDetailedWatcherO) {
8308 self.destroy_detailed_watcher.unwrap()(watcher)
8309 }
8310
8311 pub unsafe fn app_folder(&self, ta: *mut TempAllocatorI) -> *const ::std::os::raw::c_char {
8312 self.app_folder.unwrap()(ta)
8313 }
8314}
8315
8316impl crate::Api for OsFileSystemApi {
8317 const NAME: ConstCStr = const_cstr!("tm_os_file_system_api");
8318 const VERSION: VersionT = VersionT {
8319 major: 1u32,
8320 minor: 0u32,
8321 patch: 0u32,
8322 };
8323}
8324
8325impl OsDllApi {
8326 pub unsafe fn open(&self, path: *const ::std::os::raw::c_char) -> DllO {
8327 self.open.unwrap()(path)
8328 }
8329
8330 pub unsafe fn get(&self, path: *const ::std::os::raw::c_char) -> DllO {
8331 self.get.unwrap()(path)
8332 }
8333
8334 pub unsafe fn sym(
8335 &self,
8336 handle: DllO,
8337 name: *const ::std::os::raw::c_char,
8338 ) -> *mut ::std::os::raw::c_void {
8339 self.sym.unwrap()(handle, name)
8340 }
8341
8342 pub unsafe fn close(&self, handle: DllO) {
8343 self.close.unwrap()(handle)
8344 }
8345}
8346
8347impl OsSocketApi {
8348 pub unsafe fn init(&self) {
8349 self.init.unwrap()()
8350 }
8351
8352 pub unsafe fn shutdown(&self) {
8353 self.shutdown.unwrap()()
8354 }
8355
8356 pub unsafe fn socket(&self, type_: OsSocketType) -> SocketO {
8357 self.socket.unwrap()(type_)
8358 }
8359
8360 pub unsafe fn set_option(&self, socket: SocketO, option: OsSocketOption, enabled: bool) {
8361 self.set_option.unwrap()(socket, option, enabled)
8362 }
8363
8364 pub unsafe fn bind(&self, socket: SocketO, address: SocketAddressT) -> bool {
8365 self.bind.unwrap()(socket, address)
8366 }
8367
8368 pub unsafe fn getsockname(&self, socket: SocketO, address: *mut SocketAddressT) -> bool {
8369 self.getsockname.unwrap()(socket, address)
8370 }
8371
8372 pub unsafe fn listen(&self, socket: SocketO, queue_size: u32) -> bool {
8373 self.listen.unwrap()(socket, queue_size)
8374 }
8375
8376 pub unsafe fn accept(&self, socket: SocketO, address: *mut SocketAddressT) -> SocketO {
8377 self.accept.unwrap()(socket, address)
8378 }
8379
8380 pub unsafe fn connect(&self, socket: SocketO, target: SocketAddressT) -> OsSocketConnect {
8381 self.connect.unwrap()(socket, target)
8382 }
8383
8384 pub unsafe fn send(
8385 &self,
8386 socket: SocketO,
8387 buffer: *const ::std::os::raw::c_void,
8388 size: u32,
8389 ) -> i32 {
8390 self.send.unwrap()(socket, buffer, size)
8391 }
8392
8393 pub unsafe fn recv(
8394 &self,
8395 socket: SocketO,
8396 buffer: *mut ::std::os::raw::c_void,
8397 size: u32,
8398 ) -> i32 {
8399 self.recv.unwrap()(socket, buffer, size)
8400 }
8401
8402 pub unsafe fn sendto(
8403 &self,
8404 socket: SocketO,
8405 buffer: *const ::std::os::raw::c_void,
8406 size: u32,
8407 target: SocketAddressT,
8408 ) -> i32 {
8409 self.sendto.unwrap()(socket, buffer, size, target)
8410 }
8411
8412 pub unsafe fn recvfrom(
8413 &self,
8414 socket: SocketO,
8415 buffer: *mut ::std::os::raw::c_void,
8416 size: u32,
8417 source: *mut SocketAddressT,
8418 ) -> i32 {
8419 self.recvfrom.unwrap()(socket, buffer, size, source)
8420 }
8421
8422 pub unsafe fn close(&self, socket: SocketO) -> bool {
8423 self.close.unwrap()(socket)
8424 }
8425
8426 pub unsafe fn getaddrinfo(
8427 &self,
8428 name: *const ::std::os::raw::c_char,
8429 service: *const ::std::os::raw::c_char,
8430 addresses: *mut SocketAddressT,
8431 size: u32,
8432 ) -> u32 {
8433 self.getaddrinfo.unwrap()(name, service, addresses, size)
8434 }
8435
8436 pub unsafe fn getaddrinfo_async(
8437 &self,
8438 name: *const ::std::os::raw::c_char,
8439 service: *const ::std::os::raw::c_char,
8440 ) -> *mut ::std::os::raw::c_void {
8441 self.getaddrinfo_async.unwrap()(name, service)
8442 }
8443
8444 pub unsafe fn getaddrinfo_result(
8445 &self,
8446 query: *mut ::std::os::raw::c_void,
8447 addresses: *mut SocketAddressT,
8448 count: *mut u32,
8449 ) -> OsSocketGetaddrinfo {
8450 self.getaddrinfo_result.unwrap()(query, addresses, count)
8451 }
8452}
8453
8454impl crate::Api for OsSocketApi {
8455 const NAME: ConstCStr = const_cstr!("tm_os_socket_api");
8456 const VERSION: VersionT = VersionT {
8457 major: 1u32,
8458 minor: 0u32,
8459 patch: 0u32,
8460 };
8461}
8462
8463impl OsThreadApi {
8464 pub unsafe fn create_critical_section(&self, cs: *mut CriticalSectionO) {
8465 self.create_critical_section.unwrap()(cs)
8466 }
8467
8468 pub unsafe fn enter_critical_section(&self, cs: *mut CriticalSectionO) {
8469 self.enter_critical_section.unwrap()(cs)
8470 }
8471
8472 pub unsafe fn leave_critical_section(&self, cs: *mut CriticalSectionO) {
8473 self.leave_critical_section.unwrap()(cs)
8474 }
8475
8476 pub unsafe fn destroy_critical_section(&self, cs: *mut CriticalSectionO) {
8477 self.destroy_critical_section.unwrap()(cs)
8478 }
8479
8480 pub unsafe fn create_semaphore(&self, initial_count: u32) -> SemaphoreO {
8481 self.create_semaphore.unwrap()(initial_count)
8482 }
8483
8484 pub unsafe fn semaphore_add(&self, sem: SemaphoreO, count: u32) {
8485 self.semaphore_add.unwrap()(sem, count)
8486 }
8487
8488 pub unsafe fn semaphore_wait(&self, sem: SemaphoreO) {
8489 self.semaphore_wait.unwrap()(sem)
8490 }
8491
8492 pub unsafe fn semaphore_poll(&self, sem: SemaphoreO) -> bool {
8493 self.semaphore_poll.unwrap()(sem)
8494 }
8495
8496 pub unsafe fn destroy_semaphore(&self, sem: SemaphoreO) {
8497 self.destroy_semaphore.unwrap()(sem)
8498 }
8499
8500 pub unsafe fn thread_id(&self) -> u32 {
8501 self.thread_id.unwrap()()
8502 }
8503
8504 pub unsafe fn processor_id(&self) -> u32 {
8505 self.processor_id.unwrap()()
8506 }
8507
8508 pub unsafe fn create_thread(
8509 &self,
8510 entry: ThreadEntryF,
8511 user_data: *mut ::std::os::raw::c_void,
8512 stack_size: u32,
8513 debug_name: *const ::std::os::raw::c_char,
8514 ) -> ThreadO {
8515 self.create_thread.unwrap()(entry, user_data, stack_size, debug_name)
8516 }
8517
8518 pub unsafe fn set_thread_priority(&self, thread: ThreadO, priority: OsThreadPriority) {
8519 self.set_thread_priority.unwrap()(thread, priority)
8520 }
8521
8522 pub unsafe fn wait_for_thread(&self, thread: ThreadO) {
8523 self.wait_for_thread.unwrap()(thread)
8524 }
8525
8526 pub unsafe fn thread_id_from_tm_thread(&self, thread: ThreadO) -> u32 {
8527 self.thread_id_from_tm_thread.unwrap()(thread)
8528 }
8529
8530 pub unsafe fn convert_thread_to_fiber(&self, user_data: *mut ::std::os::raw::c_void) -> FiberO {
8531 self.convert_thread_to_fiber.unwrap()(user_data)
8532 }
8533
8534 pub unsafe fn convert_fiber_to_thread(&self) {
8535 self.convert_fiber_to_thread.unwrap()()
8536 }
8537
8538 pub unsafe fn create_fiber(
8539 &self,
8540 entry: FiberEntryF,
8541 user_data: *mut ::std::os::raw::c_void,
8542 stack_size: u32,
8543 ) -> FiberO {
8544 self.create_fiber.unwrap()(entry, user_data, stack_size)
8545 }
8546
8547 pub unsafe fn destroy_fiber(&self, fiber: FiberO) {
8548 self.destroy_fiber.unwrap()(fiber)
8549 }
8550
8551 pub unsafe fn switch_to_fiber(&self, fiber: FiberO) {
8552 self.switch_to_fiber.unwrap()(fiber)
8553 }
8554
8555 pub unsafe fn fiber_user_data(&self) -> *mut ::std::os::raw::c_void {
8556 self.fiber_user_data.unwrap()()
8557 }
8558
8559 pub unsafe fn yield_processor(&self) {
8560 self.yield_processor.unwrap()()
8561 }
8562
8563 pub unsafe fn sleep(&self, seconds: f64) {
8564 self.sleep.unwrap()(seconds)
8565 }
8566}
8567
8568impl OsTimeApi {
8569 pub unsafe fn now(&self) -> ClockO {
8570 self.now.unwrap()()
8571 }
8572
8573 pub unsafe fn delta(&self, to: ClockO, from: ClockO) -> f64 {
8574 self.delta.unwrap()(to, from)
8575 }
8576
8577 pub unsafe fn add(&self, from: ClockO, delta: f64) -> ClockO {
8578 self.add.unwrap()(from, delta)
8579 }
8580
8581 pub unsafe fn file_time_now(&self) -> FileTimeO {
8582 self.file_time_now.unwrap()()
8583 }
8584
8585 pub unsafe fn file_time_delta(&self, to: FileTimeO, from: FileTimeO) -> f64 {
8586 self.file_time_delta.unwrap()(to, from)
8587 }
8588}
8589
8590impl OsDialogsApi {
8591 pub unsafe fn open(
8592 &self,
8593 s: *const OsDialogsOpenT,
8594 ta: *mut TempAllocatorI,
8595 ) -> OsDialogsOpenResT {
8596 self.open.unwrap()(s, ta)
8597 }
8598
8599 pub unsafe fn open_folder(&self, ta: *mut TempAllocatorI) -> *mut ::std::os::raw::c_char {
8600 self.open_folder.unwrap()(ta)
8601 }
8602
8603 pub unsafe fn save(
8604 &self,
8605 s: *const OsDialogsSaveT,
8606 ta: *mut TempAllocatorI,
8607 ) -> *mut ::std::os::raw::c_char {
8608 self.save.unwrap()(s, ta)
8609 }
8610
8611 pub unsafe fn message_box(
8612 &self,
8613 title: *const ::std::os::raw::c_char,
8614 text: *const ::std::os::raw::c_char,
8615 ) {
8616 self.message_box.unwrap()(title, text)
8617 }
8618
8619 pub unsafe fn show_count(&self) -> u64 {
8620 self.show_count.unwrap()()
8621 }
8622}
8623
8624impl OsInfoApi {
8625 pub unsafe fn num_logical_processors(&self) -> u32 {
8626 self.num_logical_processors.unwrap()()
8627 }
8628
8629 pub unsafe fn avx_support(&self) -> bool {
8630 self.avx_support.unwrap()()
8631 }
8632}
8633
8634impl OsDebuggerApi {
8635 pub unsafe fn is_debugger_present(&self) -> bool {
8636 self.is_debugger_present.unwrap()()
8637 }
8638
8639 pub unsafe fn debug_break(&self) {
8640 self.debug_break.unwrap()()
8641 }
8642
8643 pub unsafe fn print_stack_trace(&self) {
8644 self.print_stack_trace.unwrap()()
8645 }
8646}
8647
8648impl OsSystemApi {
8649 pub unsafe fn open_url(&self, url: *const ::std::os::raw::c_char) {
8650 self.open_url.unwrap()(url)
8651 }
8652
8653 pub unsafe fn open_file(&self, file: *const ::std::os::raw::c_char) -> bool {
8654 self.open_file.unwrap()(file)
8655 }
8656
8657 pub unsafe fn exe_path(
8658 &self,
8659 argv_0: *const ::std::os::raw::c_char,
8660 ) -> *const ::std::os::raw::c_char {
8661 self.exe_path.unwrap()(argv_0)
8662 }
8663
8664 pub unsafe fn execute(&self, command: *const ::std::os::raw::c_char) -> ::std::os::raw::c_int {
8665 self.execute.unwrap()(command)
8666 }
8667
8668 pub unsafe fn execute_in_background(
8669 &self,
8670 command: *const ::std::os::raw::c_char,
8671 ) -> ::std::os::raw::c_int {
8672 self.execute_in_background.unwrap()(command)
8673 }
8674
8675 pub unsafe fn execute_stdout(
8676 &self,
8677 command: *const ::std::os::raw::c_char,
8678 timeout_ms: u32,
8679 ta: *mut TempAllocatorI,
8680 exit_code: *mut ::std::os::raw::c_int,
8681 ) -> *mut ::std::os::raw::c_char {
8682 self.execute_stdout.unwrap()(command, timeout_ms, ta, exit_code)
8683 }
8684}
8685
8686impl OsApi {}
8687
8688impl crate::Api for OsApi {
8689 const NAME: ConstCStr = const_cstr!("tm_os_api");
8690 const VERSION: VersionT = VersionT {
8691 major: 1u32,
8692 minor: 0u32,
8693 patch: 0u32,
8694 };
8695}
8696
8697impl PathApi {
8698 pub unsafe fn extension(&self, path: StrT) -> StrT {
8699 self.extension.unwrap()(path)
8700 }
8701
8702 pub unsafe fn extension_cstr(
8703 &self,
8704 path: *const ::std::os::raw::c_char,
8705 ) -> *const ::std::os::raw::c_char {
8706 self.extension_cstr.unwrap()(path)
8707 }
8708
8709 pub unsafe fn strip_extension(&self, path: StrT) -> StrT {
8710 self.strip_extension.unwrap()(path)
8711 }
8712
8713 pub unsafe fn base(&self, path: StrT) -> StrT {
8714 self.base.unwrap()(path)
8715 }
8716
8717 pub unsafe fn base_cstr(
8718 &self,
8719 path: *const ::std::os::raw::c_char,
8720 ) -> *const ::std::os::raw::c_char {
8721 self.base_cstr.unwrap()(path)
8722 }
8723
8724 pub unsafe fn directory(&self, path: StrT) -> StrT {
8725 self.directory.unwrap()(path)
8726 }
8727
8728 pub unsafe fn pop_last(&self, path: *mut StrT) -> StrT {
8729 self.pop_last.unwrap()(path)
8730 }
8731
8732 pub unsafe fn pop_first(&self, path: *mut StrT) -> StrT {
8733 self.pop_first.unwrap()(path)
8734 }
8735
8736 pub unsafe fn split_all(&self, path: StrT, ta: *mut TempAllocatorI) -> *mut StrT {
8737 self.split_all.unwrap()(path, ta)
8738 }
8739
8740 pub unsafe fn join(&self, a: StrT, b: StrT, ta: *mut TempAllocatorI) -> StrT {
8741 self.join.unwrap()(a, b, ta)
8742 }
8743}
8744
8745impl crate::Api for PathApi {
8746 const NAME: ConstCStr = const_cstr!("tm_path_api");
8747 const VERSION: VersionT = VersionT {
8748 major: 1u32,
8749 minor: 0u32,
8750 patch: 0u32,
8751 };
8752}
8753
8754impl PluginsApi {
8755 pub unsafe fn load(&self, path: *const ::std::os::raw::c_char, hot_reload: bool) -> u64 {
8756 self.load.unwrap()(path, hot_reload)
8757 }
8758
8759 pub unsafe fn unload(&self, plugin: u64) {
8760 self.unload.unwrap()(plugin)
8761 }
8762
8763 pub unsafe fn reload(&self, plugin: u64) {
8764 self.reload.unwrap()(plugin)
8765 }
8766
8767 pub unsafe fn set_path(&self, plugin: u64, path: *const ::std::os::raw::c_char) {
8768 self.set_path.unwrap()(plugin, path)
8769 }
8770
8771 pub unsafe fn check_hot_reload(&self) -> bool {
8772 self.check_hot_reload.unwrap()()
8773 }
8774
8775 pub unsafe fn reload_count(&self) -> u64 {
8776 self.reload_count.unwrap()()
8777 }
8778
8779 pub unsafe fn enumerate(
8780 &self,
8781 directory: *const ::std::os::raw::c_char,
8782 ta: *mut TempAllocatorI,
8783 ) -> *mut *const ::std::os::raw::c_char {
8784 self.enumerate.unwrap()(directory, ta)
8785 }
8786
8787 pub unsafe fn plugin_dllpath(
8788 &self,
8789 ta: *mut TempAllocatorI,
8790 exe: *const ::std::os::raw::c_char,
8791 name: *const ::std::os::raw::c_char,
8792 ) -> *const ::std::os::raw::c_char {
8793 self.plugin_dllpath.unwrap()(ta, exe, name)
8794 }
8795
8796 pub unsafe fn app_dllpath(
8797 &self,
8798 ta: *mut TempAllocatorI,
8799 exe: *const ::std::os::raw::c_char,
8800 name: *const ::std::os::raw::c_char,
8801 ) -> *const ::std::os::raw::c_char {
8802 self.app_dllpath.unwrap()(ta, exe, name)
8803 }
8804}
8805
8806impl crate::Api for PluginsApi {
8807 const NAME: ConstCStr = const_cstr!("tm_plugins_api");
8808 const VERSION: VersionT = VersionT {
8809 major: 3u32,
8810 minor: 0u32,
8811 patch: 0u32,
8812 };
8813}
8814
8815impl PluginAssetsApi {
8816 pub unsafe fn any_plugins(&self, tt: *mut TheTruthO) -> bool {
8817 self.any_plugins.unwrap()(tt)
8818 }
8819
8820 pub unsafe fn init_truth(&self, tt: *mut TheTruthO, allow_code_execution: bool) {
8821 self.init_truth.unwrap()(tt, allow_code_execution)
8822 }
8823
8824 pub unsafe fn shutdown_truth(&self, tt: *mut TheTruthO) {
8825 self.shutdown_truth.unwrap()(tt)
8826 }
8827
8828 pub unsafe fn update_truth(&self, tt: *mut TheTruthO) {
8829 self.update_truth.unwrap()(tt)
8830 }
8831
8832 pub unsafe fn allow_code_execution(&self, tt: *mut TheTruthO) -> bool {
8833 self.allow_code_execution.unwrap()(tt)
8834 }
8835
8836 pub unsafe fn set_allow_code_execution(&self, tt: *mut TheTruthO, allow_code_execution: bool) {
8837 self.set_allow_code_execution.unwrap()(tt, allow_code_execution)
8838 }
8839}
8840
8841impl crate::Api for PluginAssetsApi {
8842 const NAME: ConstCStr = const_cstr!("tm_plugin_assets_api");
8843 const VERSION: VersionT = VersionT {
8844 major: 1u32,
8845 minor: 0u32,
8846 patch: 0u32,
8847 };
8848}
8849
8850impl ProfilerApi {
8851 pub unsafe fn init(&self, allocator: *mut AllocatorI, event_buffer_size: u32) {
8852 self.init.unwrap()(allocator, event_buffer_size)
8853 }
8854
8855 pub unsafe fn shutdown(&self) {
8856 self.shutdown.unwrap()()
8857 }
8858
8859 pub unsafe fn begin(
8860 &self,
8861 name: *const ::std::os::raw::c_char,
8862 category: *const ::std::os::raw::c_char,
8863 object: *const ::std::os::raw::c_char,
8864 ) -> u64 {
8865 self.begin.unwrap()(name, category, object)
8866 }
8867
8868 pub unsafe fn end(&self, begin_id: u64) {
8869 self.end.unwrap()(begin_id)
8870 }
8871
8872 pub unsafe fn instant(
8873 &self,
8874 name: *const ::std::os::raw::c_char,
8875 category: *const ::std::os::raw::c_char,
8876 object: *const ::std::os::raw::c_char,
8877 ) {
8878 self.instant.unwrap()(name, category, object)
8879 }
8880
8881 pub unsafe fn start(
8882 &self,
8883 name: *const ::std::os::raw::c_char,
8884 category: *const ::std::os::raw::c_char,
8885 object: *const ::std::os::raw::c_char,
8886 ) -> u64 {
8887 self.start.unwrap()(name, category, object)
8888 }
8889
8890 pub unsafe fn finish(&self, start_id: u64) {
8891 self.finish.unwrap()(start_id)
8892 }
8893
8894 pub unsafe fn intern(&self, s: *const ::std::os::raw::c_char) -> *const ::std::os::raw::c_char {
8895 self.intern.unwrap()(s)
8896 }
8897
8898 pub unsafe fn fiber_switch(&self, from_fiber: u32, to_fiber: u32) {
8899 self.fiber_switch.unwrap()(from_fiber, to_fiber)
8900 }
8901
8902 pub unsafe fn submit(&self, events: *mut ProfilerEventT, count: u32) {
8903 self.submit.unwrap()(events, count)
8904 }
8905
8906 pub unsafe fn copy(
8907 &self,
8908 dest: *mut ProfilerEventT,
8909 start: u64,
8910 count: u32,
8911 actual_start: *mut u64,
8912 actual_count: *mut u32,
8913 ) {
8914 self.copy.unwrap()(dest, start, count, actual_start, actual_count)
8915 }
8916
8917 pub unsafe fn buffer(&self) -> ProfilerBufferT {
8918 self.buffer.unwrap()()
8919 }
8920}
8921
8922impl crate::Api for ProfilerApi {
8923 const NAME: ConstCStr = const_cstr!("tm_profiler_api");
8924 const VERSION: VersionT = VersionT {
8925 major: 1u32,
8926 minor: 0u32,
8927 patch: 0u32,
8928 };
8929}
8930
8931impl ProgressReportApi {
8932 pub unsafe fn create(&self, a: *mut AllocatorI, task_display_time: f32) {
8933 self.create.unwrap()(a, task_display_time)
8934 }
8935
8936 pub unsafe fn destroy(&self) {
8937 self.destroy.unwrap()()
8938 }
8939
8940 pub unsafe fn update(&self, dt: f64, ta: *mut TempAllocatorI) -> TaskProgressT {
8941 self.update.unwrap()(dt, ta)
8942 }
8943
8944 pub unsafe fn status(&self, ta: *mut TempAllocatorI) -> TaskStatusT {
8945 self.status.unwrap()(ta)
8946 }
8947
8948 pub unsafe fn idle(&self) -> bool {
8949 self.idle.unwrap()()
8950 }
8951
8952 pub unsafe fn set_task_progress(
8953 &self,
8954 task: u64,
8955 text: *const ::std::os::raw::c_char,
8956 fraction: f32,
8957 ) {
8958 self.set_task_progress.unwrap()(task, text, fraction)
8959 }
8960}
8961
8962impl crate::Api for ProgressReportApi {
8963 const NAME: ConstCStr = const_cstr!("tm_progress_report_api");
8964 const VERSION: VersionT = VersionT {
8965 major: 1u32,
8966 minor: 0u32,
8967 patch: 0u32,
8968 };
8969}
8970
8971impl RandomApi {
8972 pub unsafe fn next(&self) -> u64 {
8973 self.next.unwrap()()
8974 }
8975
8976 pub unsafe fn next_n(&self, res: *mut u64, n: u32) {
8977 self.next_n.unwrap()(res, n)
8978 }
8979
8980 pub unsafe fn seed_new_state(&self, s: *mut u64) {
8981 self.seed_new_state.unwrap()(s)
8982 }
8983}
8984
8985impl crate::Api for RandomApi {
8986 const NAME: ConstCStr = const_cstr!("tm_random_api");
8987 const VERSION: VersionT = VersionT {
8988 major: 1u32,
8989 minor: 0u32,
8990 patch: 0u32,
8991 };
8992}
8993
8994impl RuntimeDataRepositoryApi {
8995 pub unsafe fn create(
8996 &self,
8997 allocator: *mut AllocatorI,
8998 tt: *mut TheTruthO,
8999 type_: TtTypeT,
9000 runtime_data_size: u32,
9001 io_interface: *mut RuntimeDataIoI,
9002 ) -> *mut RuntimeDataRepositoryO {
9003 self.create.unwrap()(allocator, tt, type_, runtime_data_size, io_interface)
9004 }
9005
9006 pub unsafe fn destroy(
9007 &self,
9008 inst: *mut RuntimeDataRepositoryO,
9009 io_context: *mut ::std::os::raw::c_void,
9010 ) {
9011 self.destroy.unwrap()(inst, io_context)
9012 }
9013
9014 pub unsafe fn lookup(
9015 &self,
9016 inst: *mut RuntimeDataRepositoryO,
9017 id: TtIdT,
9018 wanted_version: u64,
9019 io_context: *mut ::std::os::raw::c_void,
9020 ) -> RuntimeDataT {
9021 self.lookup.unwrap()(inst, id, wanted_version, io_context)
9022 }
9023
9024 pub unsafe fn garbage_collect(
9025 &self,
9026 inst: *mut RuntimeDataRepositoryO,
9027 io_context: *mut ::std::os::raw::c_void,
9028 ) {
9029 self.garbage_collect.unwrap()(inst, io_context)
9030 }
9031}
9032
9033impl crate::Api for RuntimeDataRepositoryApi {
9034 const NAME: ConstCStr = const_cstr!("tm_runtime_data_repository_api");
9035 const VERSION: VersionT = VersionT {
9036 major: 1u32,
9037 minor: 0u32,
9038 patch: 0u32,
9039 };
9040}
9041
9042impl SprintfApi {
9043 pub unsafe fn print_unsafe(
9044 &self,
9045 buf: *mut ::std::os::raw::c_char,
9046 fmt: *const ::std::os::raw::c_char,
9047 ) -> ::std::os::raw::c_int {
9048 self.print_unsafe.unwrap()(buf, fmt)
9049 }
9050
9051 pub unsafe fn print(
9052 &self,
9053 buf: *mut ::std::os::raw::c_char,
9054 count: ::std::os::raw::c_int,
9055 fmt: *const ::std::os::raw::c_char,
9056 ) -> ::std::os::raw::c_int {
9057 self.print.unwrap()(buf, count, fmt)
9058 }
9059
9060 pub unsafe fn vprint_unsafe(
9061 &self,
9062 buf: *mut ::std::os::raw::c_char,
9063 fmt: *const ::std::os::raw::c_char,
9064 va: va_list,
9065 ) -> ::std::os::raw::c_int {
9066 self.vprint_unsafe.unwrap()(buf, fmt, va)
9067 }
9068
9069 pub unsafe fn vprint(
9070 &self,
9071 buf: *mut ::std::os::raw::c_char,
9072 count: ::std::os::raw::c_int,
9073 fmt: *const ::std::os::raw::c_char,
9074 va: va_list,
9075 ) -> ::std::os::raw::c_int {
9076 self.vprint.unwrap()(buf, count, fmt, va)
9077 }
9078
9079 pub unsafe fn add_printer(&self, name: *const ::std::os::raw::c_char, printer: SprintfPrinter) {
9080 self.add_printer.unwrap()(name, printer)
9081 }
9082}
9083
9084impl crate::Api for SprintfApi {
9085 const NAME: ConstCStr = const_cstr!("tm_sprintf_api");
9086 const VERSION: VersionT = VersionT {
9087 major: 1u32,
9088 minor: 0u32,
9089 patch: 0u32,
9090 };
9091}
9092
9093impl StringApi {
9094 pub unsafe fn find_unique_name(
9095 &self,
9096 taken_names: *mut SetStrhashT,
9097 ignore_case: bool,
9098 desired_name: *const ::std::os::raw::c_char,
9099 separator: *const ::std::os::raw::c_char,
9100 ta: *mut TempAllocatorI,
9101 ) -> *const ::std::os::raw::c_char {
9102 self.find_unique_name.unwrap()(taken_names, ignore_case, desired_name, separator, ta)
9103 }
9104}
9105
9106impl crate::Api for StringApi {
9107 const NAME: ConstCStr = const_cstr!("tm_string_api");
9108 const VERSION: VersionT = VersionT {
9109 major: 1u32,
9110 minor: 0u32,
9111 patch: 0u32,
9112 };
9113}
9114
9115impl StringRepositoryApi {
9116 pub unsafe fn create(&self, a: *mut AllocatorI) -> *mut StringRepositoryI {
9117 self.create.unwrap()(a)
9118 }
9119
9120 pub unsafe fn destroy(&self, i: *mut StringRepositoryI) {
9121 self.destroy.unwrap()(i)
9122 }
9123}
9124
9125impl crate::Api for StringRepositoryApi {
9126 const NAME: ConstCStr = const_cstr!("tm_string_repository_api");
9127 const VERSION: VersionT = VersionT {
9128 major: 1u32,
9129 minor: 0u32,
9130 patch: 0u32,
9131 };
9132}
9133
9134impl TaskSystemApi {
9135 pub unsafe fn run_task(
9136 &self,
9137 f: ::std::option::Option<unsafe extern "C" fn(data: *mut ::std::os::raw::c_void, id: u64)>,
9138 data: *mut ::std::os::raw::c_void,
9139 debug_name: *const ::std::os::raw::c_char,
9140 ) -> u64 {
9141 self.run_task.unwrap()(f, data, debug_name)
9142 }
9143
9144 pub unsafe fn is_task_done(&self, id: u64) -> bool {
9145 self.is_task_done.unwrap()(id)
9146 }
9147
9148 pub unsafe fn is_task_done_else_assist(&self, id: u64) -> bool {
9149 self.is_task_done_else_assist.unwrap()(id)
9150 }
9151
9152 pub unsafe fn cancel_task(&self, id: u64) {
9153 self.cancel_task.unwrap()(id)
9154 }
9155
9156 pub unsafe fn is_task_canceled(&self, id: u64) -> bool {
9157 self.is_task_canceled.unwrap()(id)
9158 }
9159}
9160
9161impl crate::Api for TaskSystemApi {
9162 const NAME: ConstCStr = const_cstr!("tm_task_system_api");
9163 const VERSION: VersionT = VersionT {
9164 major: 1u32,
9165 minor: 0u32,
9166 patch: 0u32,
9167 };
9168}
9169
9170impl TempAllocatorApi {
9171 pub unsafe fn create(&self, backing: *mut AllocatorI) -> *mut TempAllocatorI {
9172 self.create.unwrap()(backing)
9173 }
9174
9175 pub unsafe fn create_in_buffer(
9176 &self,
9177 buffer: *mut ::std::os::raw::c_char,
9178 size: u64,
9179 backing: *mut AllocatorI,
9180 ) -> *mut TempAllocatorI {
9181 self.create_in_buffer.unwrap()(buffer, size, backing)
9182 }
9183
9184 pub unsafe fn destroy(&self, ta: *mut TempAllocatorI) {
9185 self.destroy.unwrap()(ta)
9186 }
9187
9188 pub unsafe fn allocator(&self, a: *mut AllocatorI, ta: *mut TempAllocatorI) {
9189 self.allocator.unwrap()(a, ta)
9190 }
9191
9192 pub unsafe fn frame_alloc(&self, size: u64) -> *mut ::std::os::raw::c_void {
9193 self.frame_alloc.unwrap()(size)
9194 }
9195
9196 pub unsafe fn frame_allocator(&self) -> *mut AllocatorI {
9197 self.frame_allocator.unwrap()()
9198 }
9199
9200 pub unsafe fn tick_frame(&self) {
9201 self.tick_frame.unwrap()()
9202 }
9203
9204 pub unsafe fn printf(
9205 &self,
9206 ta: *mut TempAllocatorI,
9207 format: *const ::std::os::raw::c_char,
9208 ) -> *mut ::std::os::raw::c_char {
9209 self.printf.unwrap()(ta, format)
9210 }
9211
9212 pub unsafe fn vprintf(
9213 &self,
9214 ta: *mut TempAllocatorI,
9215 format: *const ::std::os::raw::c_char,
9216 args: va_list,
9217 ) -> *mut ::std::os::raw::c_char {
9218 self.vprintf.unwrap()(ta, format, args)
9219 }
9220
9221 pub unsafe fn frame_printf(
9222 &self,
9223 format: *const ::std::os::raw::c_char,
9224 ) -> *mut ::std::os::raw::c_char {
9225 self.frame_printf.unwrap()(format)
9226 }
9227
9228 pub unsafe fn frame_vprintf(
9229 &self,
9230 format: *const ::std::os::raw::c_char,
9231 args: va_list,
9232 ) -> *mut ::std::os::raw::c_char {
9233 self.frame_vprintf.unwrap()(format, args)
9234 }
9235}
9236
9237impl crate::Api for TempAllocatorApi {
9238 const NAME: ConstCStr = const_cstr!("tm_temp_allocator_api");
9239 const VERSION: VersionT = VersionT {
9240 major: 1u32,
9241 minor: 0u32,
9242 patch: 0u32,
9243 };
9244}
9245
9246impl TheTruthApi {
9247 pub unsafe fn allocator(&self, tt: *mut TheTruthO) -> *mut AllocatorI {
9248 self.allocator.unwrap()(tt)
9249 }
9250
9251 pub unsafe fn buffers(&self, tt: *mut TheTruthO) -> *mut BuffersI {
9252 self.buffers.unwrap()(tt)
9253 }
9254
9255 pub unsafe fn streamable_buffers(&self, tt: *mut TheTruthO) -> *mut StreamableBuffersI {
9256 self.streamable_buffers.unwrap()(tt)
9257 }
9258
9259 pub unsafe fn create_object_type(
9260 &self,
9261 tt: *mut TheTruthO,
9262 name: *const ::std::os::raw::c_char,
9263 properties: *const TheTruthPropertyDefinitionT,
9264 num_properties: u32,
9265 ) -> TtTypeT {
9266 self.create_object_type.unwrap()(tt, name, properties, num_properties)
9267 }
9268
9269 pub unsafe fn set_default_object(
9270 &self,
9271 tt: *mut TheTruthO,
9272 object_type: TtTypeT,
9273 object: TtIdT,
9274 ) {
9275 self.set_default_object.unwrap()(tt, object_type, object)
9276 }
9277
9278 pub unsafe fn set_default_object_to_create_subobjects(
9279 &self,
9280 tt: *mut TheTruthO,
9281 object_type: TtTypeT,
9282 ) {
9283 self.set_default_object_to_create_subobjects.unwrap()(tt, object_type)
9284 }
9285
9286 pub unsafe fn default_object(&self, tt: *const TheTruthO, object_type: TtTypeT) -> TtIdT {
9287 self.default_object.unwrap()(tt, object_type)
9288 }
9289
9290 pub unsafe fn is_default(
9291 &self,
9292 tt: *const TheTruthO,
9293 obj: *const TheTruthObjectO,
9294 property: u32,
9295 ) -> bool {
9296 self.is_default.unwrap()(tt, obj, property)
9297 }
9298
9299 pub unsafe fn set_aspect(
9300 &self,
9301 tt: *mut TheTruthO,
9302 object_type: TtTypeT,
9303 aspect: StrhashT,
9304 data: *const ::std::os::raw::c_void,
9305 ) {
9306 self.set_aspect.unwrap()(tt, object_type, aspect, data)
9307 }
9308
9309 pub unsafe fn set_default_aspect(
9310 &self,
9311 tt: *mut TheTruthO,
9312 aspect: StrhashT,
9313 data: *const ::std::os::raw::c_void,
9314 ) {
9315 self.set_default_aspect.unwrap()(tt, aspect, data)
9316 }
9317
9318 pub unsafe fn set_property_aspect(
9319 &self,
9320 tt: *mut TheTruthO,
9321 object_type: TtTypeT,
9322 property: u32,
9323 aspect: StrhashT,
9324 data: *const ::std::os::raw::c_void,
9325 ) {
9326 self.set_property_aspect.unwrap()(tt, object_type, property, aspect, data)
9327 }
9328
9329 pub unsafe fn reload_aspects(&self, tt: *mut TheTruthO) {
9330 self.reload_aspects.unwrap()(tt)
9331 }
9332
9333 pub unsafe fn object_type_from_name_hash(
9334 &self,
9335 tt: *const TheTruthO,
9336 name_hash: StrhashT,
9337 ) -> TtTypeT {
9338 self.object_type_from_name_hash.unwrap()(tt, name_hash)
9339 }
9340
9341 pub unsafe fn optional_object_type_from_name_hash(
9342 &self,
9343 tt: *const TheTruthO,
9344 name_hash: StrhashT,
9345 ) -> TtTypeT {
9346 self.optional_object_type_from_name_hash.unwrap()(tt, name_hash)
9347 }
9348
9349 pub unsafe fn num_types(&self, tt: *const TheTruthO) -> u32 {
9350 self.num_types.unwrap()(tt)
9351 }
9352
9353 pub unsafe fn type_name(
9354 &self,
9355 tt: *const TheTruthO,
9356 object_type: TtTypeT,
9357 ) -> *const ::std::os::raw::c_char {
9358 self.type_name.unwrap()(tt, object_type)
9359 }
9360
9361 pub unsafe fn type_name_hash(&self, tt: *const TheTruthO, object_type: TtTypeT) -> StrhashT {
9362 self.type_name_hash.unwrap()(tt, object_type)
9363 }
9364
9365 pub unsafe fn num_properties(&self, tt: *const TheTruthO, object_type: TtTypeT) -> u32 {
9366 self.num_properties.unwrap()(tt, object_type)
9367 }
9368
9369 pub unsafe fn properties(
9370 &self,
9371 tt: *const TheTruthO,
9372 object_type: TtTypeT,
9373 ) -> *const TheTruthPropertyDefinitionT {
9374 self.properties.unwrap()(tt, object_type)
9375 }
9376
9377 pub unsafe fn find_property(
9378 &self,
9379 tt: *const TheTruthO,
9380 object_type: TtTypeT,
9381 name_hash: StrhashT,
9382 type_: TheTruthPropertyType,
9383 res: *mut u32,
9384 ) -> bool {
9385 self.find_property.unwrap()(tt, object_type, name_hash, type_, res)
9386 }
9387
9388 pub unsafe fn property_index(
9389 &self,
9390 tt: *const TheTruthO,
9391 type_: TtTypeT,
9392 name_hash: StrhashT,
9393 ) -> u32 {
9394 self.property_index.unwrap()(tt, type_, name_hash)
9395 }
9396
9397 pub unsafe fn has_property(
9398 &self,
9399 tt: *const TheTruthO,
9400 type_: TtTypeT,
9401 name_hash: StrhashT,
9402 ) -> u32 {
9403 self.has_property.unwrap()(tt, type_, name_hash)
9404 }
9405
9406 pub unsafe fn get_aspect(
9407 &self,
9408 tt: *const TheTruthO,
9409 object_type: TtTypeT,
9410 aspect: StrhashT,
9411 ) -> *mut ::std::os::raw::c_void {
9412 self.get_aspect.unwrap()(tt, object_type, aspect)
9413 }
9414
9415 pub unsafe fn get_types_with_aspect(
9416 &self,
9417 tt: *const TheTruthO,
9418 aspect: StrhashT,
9419 ta: *mut TempAllocatorI,
9420 ) -> *mut TheTruthGetTypesWithAspectT {
9421 self.get_types_with_aspect.unwrap()(tt, aspect, ta)
9422 }
9423
9424 pub unsafe fn get_aspects(
9425 &self,
9426 tt: *const TheTruthO,
9427 object_type: TtTypeT,
9428 ) -> *const TheTruthGetAspectsT {
9429 self.get_aspects.unwrap()(tt, object_type)
9430 }
9431
9432 pub unsafe fn get_property_aspect(
9433 &self,
9434 tt: *const TheTruthO,
9435 object_type: TtTypeT,
9436 property: u32,
9437 aspect: StrhashT,
9438 ) -> *mut ::std::os::raw::c_void {
9439 self.get_property_aspect.unwrap()(tt, object_type, property, aspect)
9440 }
9441
9442 pub unsafe fn all_objects_of_type(
9443 &self,
9444 tt: *const TheTruthO,
9445 object_type: TtTypeT,
9446 ta: *mut TempAllocatorI,
9447 ) -> *mut TtIdT {
9448 self.all_objects_of_type.unwrap()(tt, object_type, ta)
9449 }
9450
9451 pub unsafe fn create_undo_scope(
9452 &self,
9453 tt: *mut TheTruthO,
9454 name: *const ::std::os::raw::c_char,
9455 ) -> TtUndoScopeT {
9456 self.create_undo_scope.unwrap()(tt, name)
9457 }
9458
9459 pub unsafe fn create_thread_safe_undo_scope(
9460 &self,
9461 tt: *mut TheTruthO,
9462 name: *const ::std::os::raw::c_char,
9463 ) -> TtUndoScopeT {
9464 self.create_thread_safe_undo_scope.unwrap()(tt, name)
9465 }
9466
9467 pub unsafe fn undo_scope_name(
9468 &self,
9469 tt: *mut TheTruthO,
9470 scope: TtUndoScopeT,
9471 ) -> *const ::std::os::raw::c_char {
9472 self.undo_scope_name.unwrap()(tt, scope)
9473 }
9474
9475 pub unsafe fn undo_scope_objects(
9476 &self,
9477 tt: *mut TheTruthO,
9478 scope: TtUndoScopeT,
9479 ta: *mut TempAllocatorI,
9480 ) -> *mut TtIdT {
9481 self.undo_scope_objects.unwrap()(tt, scope, ta)
9482 }
9483
9484 pub unsafe fn undo_scope_actions(
9485 &self,
9486 tt: *mut TheTruthO,
9487 scope: TtUndoScopeT,
9488 ta: *mut TempAllocatorI,
9489 ) -> *mut TtUndoActionT {
9490 self.undo_scope_actions.unwrap()(tt, scope, ta)
9491 }
9492
9493 pub unsafe fn undo(&self, tt: *mut TheTruthO, scope: TtUndoScopeT) {
9494 self.undo.unwrap()(tt, scope)
9495 }
9496
9497 pub unsafe fn redo(&self, tt: *mut TheTruthO, scope: TtUndoScopeT) {
9498 self.redo.unwrap()(tt, scope)
9499 }
9500
9501 pub unsafe fn create_object_of_type(
9502 &self,
9503 tt: *mut TheTruthO,
9504 type_: TtTypeT,
9505 undo_scope: TtUndoScopeT,
9506 ) -> TtIdT {
9507 self.create_object_of_type.unwrap()(tt, type_, undo_scope)
9508 }
9509
9510 pub unsafe fn create_object_of_hash(
9511 &self,
9512 tt: *mut TheTruthO,
9513 type_name_hash: StrhashT,
9514 undo_scope: TtUndoScopeT,
9515 ) -> TtIdT {
9516 self.create_object_of_hash.unwrap()(tt, type_name_hash, undo_scope)
9517 }
9518
9519 pub unsafe fn create_object_from_prototype(
9520 &self,
9521 tt: *mut TheTruthO,
9522 prototype: TtIdT,
9523 undo_scope: TtUndoScopeT,
9524 ) -> TtIdT {
9525 self.create_object_from_prototype.unwrap()(tt, prototype, undo_scope)
9526 }
9527
9528 pub unsafe fn clone_object(
9529 &self,
9530 tt: *mut TheTruthO,
9531 object: TtIdT,
9532 undo_scope: TtUndoScopeT,
9533 ) -> TtIdT {
9534 self.clone_object.unwrap()(tt, object, undo_scope)
9535 }
9536
9537 pub unsafe fn instantiate_subobject(
9538 &self,
9539 tt: *mut TheTruthO,
9540 obj: *mut TheTruthObjectO,
9541 property: u32,
9542 undo_scope: TtUndoScopeT,
9543 ) -> TtIdT {
9544 self.instantiate_subobject.unwrap()(tt, obj, property, undo_scope)
9545 }
9546
9547 pub unsafe fn remove_instantiated_subobject(
9548 &self,
9549 tt: *mut TheTruthO,
9550 obj: *mut TheTruthObjectO,
9551 property: u32,
9552 undo_scope: TtUndoScopeT,
9553 ) {
9554 self.remove_instantiated_subobject.unwrap()(tt, obj, property, undo_scope)
9555 }
9556
9557 pub unsafe fn instantiate_subobject_from_set(
9558 &self,
9559 tt: *mut TheTruthO,
9560 obj: *mut TheTruthObjectO,
9561 property: u32,
9562 subobject: TtIdT,
9563 undo_scope: TtUndoScopeT,
9564 ) -> TtIdT {
9565 self.instantiate_subobject_from_set.unwrap()(tt, obj, property, subobject, undo_scope)
9566 }
9567
9568 pub unsafe fn remove_instantiated_subobject_from_set(
9569 &self,
9570 tt: *mut TheTruthO,
9571 obj: *mut TheTruthObjectO,
9572 property: u32,
9573 subobject: TtIdT,
9574 undo_scope: TtUndoScopeT,
9575 ) {
9576 self.remove_instantiated_subobject_from_set.unwrap()(
9577 tt, obj, property, subobject, undo_scope,
9578 )
9579 }
9580
9581 pub unsafe fn add_instantiated_subobject_back_to_set(
9582 &self,
9583 tt: *mut TheTruthO,
9584 obj: *mut TheTruthObjectO,
9585 property: u32,
9586 subobject: TtIdT,
9587 ) {
9588 self.add_instantiated_subobject_back_to_set.unwrap()(tt, obj, property, subobject)
9589 }
9590
9591 pub unsafe fn id(&self, obj: *const TheTruthObjectO) -> TtIdT {
9592 self.id.unwrap()(obj)
9593 }
9594
9595 pub unsafe fn destroy_object(
9596 &self,
9597 tt: *mut TheTruthO,
9598 object: TtIdT,
9599 undo_scope: TtUndoScopeT,
9600 ) {
9601 self.destroy_object.unwrap()(tt, object, undo_scope)
9602 }
9603
9604 pub unsafe fn destroy_objects(
9605 &self,
9606 tt: *mut TheTruthO,
9607 object: *const TtIdT,
9608 n: u32,
9609 undo_scope: TtUndoScopeT,
9610 ) {
9611 self.destroy_objects.unwrap()(tt, object, n, undo_scope)
9612 }
9613
9614 pub unsafe fn garbage_collect(&self, tt: *mut TheTruthO) {
9615 self.garbage_collect.unwrap()(tt)
9616 }
9617
9618 pub unsafe fn is_alive(&self, tt: *const TheTruthO, object: TtIdT) -> bool {
9619 self.is_alive.unwrap()(tt, object)
9620 }
9621
9622 pub unsafe fn interop_ensure_compatibility(&self, ctx: *mut TheTruthInteropContextT) {
9623 self.interop_ensure_compatibility.unwrap()(ctx)
9624 }
9625
9626 pub unsafe fn interop_clone_object(
9627 &self,
9628 ctx: *mut TheTruthInteropContextT,
9629 object: TtIdT,
9630 ) -> TtIdT {
9631 self.interop_clone_object.unwrap()(ctx, object)
9632 }
9633
9634 pub unsafe fn deep_clone_assets(
9635 &self,
9636 to_tt: *mut TheTruthO,
9637 from_tt: *const TheTruthO,
9638 assets: *const TtIdT,
9639 n: u32,
9640 undo_scope: TtUndoScopeT,
9641 ta: *mut TempAllocatorI,
9642 ) -> *mut TtIdT {
9643 self.deep_clone_assets.unwrap()(to_tt, from_tt, assets, n, undo_scope, ta)
9644 }
9645
9646 pub unsafe fn uuid(&self, tt: *const TheTruthO, object: TtIdT) -> UuidT {
9647 self.uuid.unwrap()(tt, object)
9648 }
9649
9650 pub unsafe fn read(&self, tt: *const TheTruthO, object: TtIdT) -> *const TheTruthObjectO {
9651 self.read.unwrap()(tt, object)
9652 }
9653
9654 pub unsafe fn get_bool(
9655 &self,
9656 tt: *const TheTruthO,
9657 obj: *const TheTruthObjectO,
9658 property: u32,
9659 ) -> bool {
9660 self.get_bool.unwrap()(tt, obj, property)
9661 }
9662
9663 pub unsafe fn get_uint32_t(
9664 &self,
9665 tt: *const TheTruthO,
9666 obj: *const TheTruthObjectO,
9667 property: u32,
9668 ) -> u32 {
9669 self.get_uint32_t.unwrap()(tt, obj, property)
9670 }
9671
9672 pub unsafe fn get_uint64_t(
9673 &self,
9674 tt: *const TheTruthO,
9675 obj: *const TheTruthObjectO,
9676 property: u32,
9677 ) -> u64 {
9678 self.get_uint64_t.unwrap()(tt, obj, property)
9679 }
9680
9681 pub unsafe fn get_float(
9682 &self,
9683 tt: *const TheTruthO,
9684 obj: *const TheTruthObjectO,
9685 property: u32,
9686 ) -> f32 {
9687 self.get_float.unwrap()(tt, obj, property)
9688 }
9689
9690 pub unsafe fn get_double(
9691 &self,
9692 tt: *const TheTruthO,
9693 obj: *const TheTruthObjectO,
9694 property: u32,
9695 ) -> f64 {
9696 self.get_double.unwrap()(tt, obj, property)
9697 }
9698
9699 pub unsafe fn get_string(
9700 &self,
9701 tt: *const TheTruthO,
9702 obj: *const TheTruthObjectO,
9703 property: u32,
9704 ) -> *const ::std::os::raw::c_char {
9705 self.get_string.unwrap()(tt, obj, property)
9706 }
9707
9708 pub unsafe fn get_string_hash(
9709 &self,
9710 tt: *const TheTruthO,
9711 obj: *const TheTruthObjectO,
9712 property: u32,
9713 ) -> StrhashT {
9714 self.get_string_hash.unwrap()(tt, obj, property)
9715 }
9716
9717 pub unsafe fn get_str(
9718 &self,
9719 tt: *const TheTruthO,
9720 obj: *const TheTruthObjectO,
9721 property: u32,
9722 ) -> StrT {
9723 self.get_str.unwrap()(tt, obj, property)
9724 }
9725
9726 pub unsafe fn get_buffer(
9727 &self,
9728 tt: *const TheTruthO,
9729 obj: *const TheTruthObjectO,
9730 property: u32,
9731 ) -> TtBufferT {
9732 self.get_buffer.unwrap()(tt, obj, property)
9733 }
9734
9735 pub unsafe fn get_buffer_id(
9736 &self,
9737 tt: *const TheTruthO,
9738 obj: *const TheTruthObjectO,
9739 property: u32,
9740 ) -> u32 {
9741 self.get_buffer_id.unwrap()(tt, obj, property)
9742 }
9743
9744 pub unsafe fn get_reference(
9745 &self,
9746 tt: *const TheTruthO,
9747 obj: *const TheTruthObjectO,
9748 property: u32,
9749 ) -> TtIdT {
9750 self.get_reference.unwrap()(tt, obj, property)
9751 }
9752
9753 pub unsafe fn get_subobject(
9754 &self,
9755 tt: *const TheTruthO,
9756 obj: *const TheTruthObjectO,
9757 property: u32,
9758 ) -> TtIdT {
9759 self.get_subobject.unwrap()(tt, obj, property)
9760 }
9761
9762 pub unsafe fn get_property_value(
9763 &self,
9764 tt: *const TheTruthO,
9765 obj: *const TheTruthObjectO,
9766 property: u32,
9767 ta: *mut TempAllocatorI,
9768 ) -> TtPropValueT {
9769 self.get_property_value.unwrap()(tt, obj, property, ta)
9770 }
9771
9772 pub unsafe fn property_value_equal(&self, a: TtPropValueT, b: TtPropValueT) -> bool {
9773 self.property_value_equal.unwrap()(a, b)
9774 }
9775
9776 pub unsafe fn get_reference_set(
9777 &self,
9778 tt: *const TheTruthO,
9779 obj: *const TheTruthObjectO,
9780 property: u32,
9781 ta: *mut TempAllocatorI,
9782 ) -> *const TtIdT {
9783 self.get_reference_set.unwrap()(tt, obj, property, ta)
9784 }
9785
9786 pub unsafe fn get_subobject_set(
9787 &self,
9788 tt: *const TheTruthO,
9789 obj: *const TheTruthObjectO,
9790 property: u32,
9791 ta: *mut TempAllocatorI,
9792 ) -> *const TtIdT {
9793 self.get_subobject_set.unwrap()(tt, obj, property, ta)
9794 }
9795
9796 pub unsafe fn get_reference_set_size(
9797 &self,
9798 tt: *const TheTruthO,
9799 obj: *const TheTruthObjectO,
9800 property: u32,
9801 ) -> u64 {
9802 self.get_reference_set_size.unwrap()(tt, obj, property)
9803 }
9804
9805 pub unsafe fn get_subobject_set_size(
9806 &self,
9807 tt: *const TheTruthO,
9808 obj: *const TheTruthObjectO,
9809 property: u32,
9810 ) -> u64 {
9811 self.get_subobject_set_size.unwrap()(tt, obj, property)
9812 }
9813
9814 pub unsafe fn get_subobject_set_type(
9815 &self,
9816 tt: *const TheTruthO,
9817 obj: *const TheTruthObjectO,
9818 property: u32,
9819 ) -> TtTypeT {
9820 self.get_subobject_set_type.unwrap()(tt, obj, property)
9821 }
9822
9823 pub unsafe fn get_subobject_set_locally_removed(
9824 &self,
9825 tt: *const TheTruthO,
9826 obj: *const TheTruthObjectO,
9827 property: u32,
9828 ta: *mut TempAllocatorI,
9829 ) -> *const TtIdT {
9830 self.get_subobject_set_locally_removed.unwrap()(tt, obj, property, ta)
9831 }
9832
9833 pub unsafe fn find_subobject_of_type(
9834 &self,
9835 tt: *const TheTruthO,
9836 obj: *const TheTruthObjectO,
9837 property: u32,
9838 type_: TtTypeT,
9839 ) -> TtIdT {
9840 self.find_subobject_of_type.unwrap()(tt, obj, property, type_)
9841 }
9842
9843 pub unsafe fn is_subobject_of(
9844 &self,
9845 tt: *const TheTruthO,
9846 obj: *const TheTruthObjectO,
9847 property: u32,
9848 subobject: TtIdT,
9849 ) -> bool {
9850 self.is_subobject_of.unwrap()(tt, obj, property, subobject)
9851 }
9852
9853 pub unsafe fn is_in_reference_set(
9854 &self,
9855 tt: *const TheTruthO,
9856 obj: *const TheTruthObjectO,
9857 property: u32,
9858 object: TtIdT,
9859 ) -> bool {
9860 self.is_in_reference_set.unwrap()(tt, obj, property, object)
9861 }
9862
9863 pub unsafe fn property_index_of_subobject(
9864 &self,
9865 tt: *const TheTruthO,
9866 object: TtIdT,
9867 subobject: TtIdT,
9868 ) -> u32 {
9869 self.property_index_of_subobject.unwrap()(tt, object, subobject)
9870 }
9871
9872 pub unsafe fn write(&self, tt: *mut TheTruthO, object: TtIdT) -> *mut TheTruthObjectO {
9873 self.write.unwrap()(tt, object)
9874 }
9875
9876 pub unsafe fn commit(
9877 &self,
9878 tt: *mut TheTruthO,
9879 obj: *mut TheTruthObjectO,
9880 undo_scope: TtUndoScopeT,
9881 ) {
9882 self.commit.unwrap()(tt, obj, undo_scope)
9883 }
9884
9885 pub unsafe fn commit_range(
9886 &self,
9887 tt: *mut TheTruthO,
9888 obj: *mut *mut TheTruthObjectO,
9889 n: u32,
9890 undo_scope: TtUndoScopeT,
9891 ) {
9892 self.commit_range.unwrap()(tt, obj, n, undo_scope)
9893 }
9894
9895 pub unsafe fn retarget_write(
9896 &self,
9897 tt: *mut TheTruthO,
9898 obj: *mut TheTruthObjectO,
9899 object: TtIdT,
9900 ) {
9901 self.retarget_write.unwrap()(tt, obj, object)
9902 }
9903
9904 pub unsafe fn try_write(
9905 &self,
9906 tt: *mut TheTruthO,
9907 object: TtIdT,
9908 original: *mut *const TheTruthObjectO,
9909 ) -> *mut TheTruthObjectO {
9910 self.try_write.unwrap()(tt, object, original)
9911 }
9912
9913 pub unsafe fn try_commit(
9914 &self,
9915 tt: *mut TheTruthO,
9916 obj: *mut TheTruthObjectO,
9917 original: *const TheTruthObjectO,
9918 undo_scope: TtUndoScopeT,
9919 ) -> bool {
9920 self.try_commit.unwrap()(tt, obj, original, undo_scope)
9921 }
9922
9923 pub unsafe fn set_bool(
9924 &self,
9925 tt: *mut TheTruthO,
9926 obj: *mut TheTruthObjectO,
9927 property: u32,
9928 value: bool,
9929 ) {
9930 self.set_bool.unwrap()(tt, obj, property, value)
9931 }
9932
9933 pub unsafe fn set_uint32_t(
9934 &self,
9935 tt: *mut TheTruthO,
9936 obj: *mut TheTruthObjectO,
9937 property: u32,
9938 value: u32,
9939 ) {
9940 self.set_uint32_t.unwrap()(tt, obj, property, value)
9941 }
9942
9943 pub unsafe fn set_uint64_t(
9944 &self,
9945 tt: *mut TheTruthO,
9946 obj: *mut TheTruthObjectO,
9947 property: u32,
9948 value: u64,
9949 ) {
9950 self.set_uint64_t.unwrap()(tt, obj, property, value)
9951 }
9952
9953 pub unsafe fn set_float(
9954 &self,
9955 tt: *mut TheTruthO,
9956 obj: *mut TheTruthObjectO,
9957 property: u32,
9958 value: f32,
9959 ) {
9960 self.set_float.unwrap()(tt, obj, property, value)
9961 }
9962
9963 pub unsafe fn set_double(
9964 &self,
9965 tt: *mut TheTruthO,
9966 obj: *mut TheTruthObjectO,
9967 property: u32,
9968 value: f64,
9969 ) {
9970 self.set_double.unwrap()(tt, obj, property, value)
9971 }
9972
9973 pub unsafe fn set_string(
9974 &self,
9975 tt: *mut TheTruthO,
9976 obj: *mut TheTruthObjectO,
9977 property: u32,
9978 value: *const ::std::os::raw::c_char,
9979 ) {
9980 self.set_string.unwrap()(tt, obj, property, value)
9981 }
9982
9983 pub unsafe fn set_str(
9984 &self,
9985 tt: *mut TheTruthO,
9986 obj: *mut TheTruthObjectO,
9987 property: u32,
9988 value: StrT,
9989 ) {
9990 self.set_str.unwrap()(tt, obj, property, value)
9991 }
9992
9993 pub unsafe fn set_buffer(
9994 &self,
9995 tt: *mut TheTruthO,
9996 obj: *mut TheTruthObjectO,
9997 property: u32,
9998 value: u32,
9999 ) {
10000 self.set_buffer.unwrap()(tt, obj, property, value)
10001 }
10002
10003 pub unsafe fn set_buffer_content(
10004 &self,
10005 tt: *mut TheTruthO,
10006 obj: *mut TheTruthObjectO,
10007 property: u32,
10008 p: *mut ::std::os::raw::c_void,
10009 size: u64,
10010 ) {
10011 self.set_buffer_content.unwrap()(tt, obj, property, p, size)
10012 }
10013
10014 pub unsafe fn set_reference(
10015 &self,
10016 tt: *mut TheTruthO,
10017 obj: *mut TheTruthObjectO,
10018 property: u32,
10019 value: TtIdT,
10020 ) {
10021 self.set_reference.unwrap()(tt, obj, property, value)
10022 }
10023
10024 pub unsafe fn set_subobject(
10025 &self,
10026 tt: *mut TheTruthO,
10027 obj: *mut TheTruthObjectO,
10028 property: u32,
10029 value: *mut TheTruthObjectO,
10030 ) {
10031 self.set_subobject.unwrap()(tt, obj, property, value)
10032 }
10033
10034 pub unsafe fn set_subobject_id(
10035 &self,
10036 tt: *mut TheTruthO,
10037 obj: *mut TheTruthObjectO,
10038 property: u32,
10039 value: TtIdT,
10040 undo_scope: TtUndoScopeT,
10041 ) {
10042 self.set_subobject_id.unwrap()(tt, obj, property, value, undo_scope)
10043 }
10044
10045 pub unsafe fn set_property_value(
10046 &self,
10047 tt: *mut TheTruthO,
10048 obj: *mut TheTruthObjectO,
10049 property: u32,
10050 value: TtPropValueT,
10051 undo_scope: TtUndoScopeT,
10052 ) {
10053 self.set_property_value.unwrap()(tt, obj, property, value, undo_scope)
10054 }
10055
10056 pub unsafe fn clear(&self, tt: *mut TheTruthO, obj: *mut TheTruthObjectO, property: u32) {
10057 self.clear.unwrap()(tt, obj, property)
10058 }
10059
10060 pub unsafe fn clear_object(&self, tt: *mut TheTruthO, obj: *mut TheTruthObjectO) {
10061 self.clear_object.unwrap()(tt, obj)
10062 }
10063
10064 pub unsafe fn propagate_property(
10065 &self,
10066 tt: *mut TheTruthO,
10067 object: TtIdT,
10068 property: u32,
10069 undo_scope: TtUndoScopeT,
10070 ) {
10071 self.propagate_property.unwrap()(tt, object, property, undo_scope)
10072 }
10073
10074 pub unsafe fn propagate_property_except(
10075 &self,
10076 tt: *mut TheTruthO,
10077 object: TtIdT,
10078 property: u32,
10079 skip: *const TtIdT,
10080 num_skip: u32,
10081 undo_scope: TtUndoScopeT,
10082 ) {
10083 self.propagate_property_except.unwrap()(tt, object, property, skip, num_skip, undo_scope)
10084 }
10085
10086 pub unsafe fn propagate_property_subobject(
10087 &self,
10088 tt: *mut TheTruthO,
10089 object: TtIdT,
10090 property: u32,
10091 subobject: TtIdT,
10092 undo_scope: TtUndoScopeT,
10093 ) {
10094 self.propagate_property_subobject.unwrap()(tt, object, property, subobject, undo_scope)
10095 }
10096
10097 pub unsafe fn propagate_object(
10098 &self,
10099 tt: *mut TheTruthO,
10100 object: TtIdT,
10101 undo_scope: TtUndoScopeT,
10102 ) {
10103 self.propagate_object.unwrap()(tt, object, undo_scope)
10104 }
10105
10106 pub unsafe fn propagate_object_except(
10107 &self,
10108 tt: *mut TheTruthO,
10109 object: TtIdT,
10110 skip: *const TtIdT,
10111 num_skip: u32,
10112 undo_scope: TtUndoScopeT,
10113 ) {
10114 self.propagate_object_except.unwrap()(tt, object, skip, num_skip, undo_scope)
10115 }
10116
10117 pub unsafe fn add_to_reference_set(
10118 &self,
10119 tt: *mut TheTruthO,
10120 obj: *mut TheTruthObjectO,
10121 property: u32,
10122 items: *const TtIdT,
10123 count: u32,
10124 ) {
10125 self.add_to_reference_set.unwrap()(tt, obj, property, items, count)
10126 }
10127
10128 pub unsafe fn remove_from_reference_set(
10129 &self,
10130 tt: *mut TheTruthO,
10131 obj: *mut TheTruthObjectO,
10132 property: u32,
10133 items: *const TtIdT,
10134 count: u32,
10135 ) {
10136 self.remove_from_reference_set.unwrap()(tt, obj, property, items, count)
10137 }
10138
10139 pub unsafe fn clear_reference_set(
10140 &self,
10141 tt: *mut TheTruthO,
10142 obj: *mut TheTruthObjectO,
10143 property: u32,
10144 ) {
10145 self.clear_reference_set.unwrap()(tt, obj, property)
10146 }
10147
10148 pub unsafe fn remove_from_prototype_reference_set(
10149 &self,
10150 tt: *mut TheTruthO,
10151 obj: *mut TheTruthObjectO,
10152 property: u32,
10153 items: *const TtIdT,
10154 count: u32,
10155 ) {
10156 self.remove_from_prototype_reference_set.unwrap()(tt, obj, property, items, count)
10157 }
10158
10159 pub unsafe fn cancel_remove_from_prototype_reference_set(
10160 &self,
10161 tt: *mut TheTruthO,
10162 obj: *mut TheTruthObjectO,
10163 property: u32,
10164 items: *const TtIdT,
10165 count: u32,
10166 ) {
10167 self.cancel_remove_from_prototype_reference_set.unwrap()(tt, obj, property, items, count)
10168 }
10169
10170 pub unsafe fn add_to_subobject_set(
10171 &self,
10172 tt: *mut TheTruthO,
10173 obj: *mut TheTruthObjectO,
10174 property: u32,
10175 items: *mut *mut TheTruthObjectO,
10176 count: u32,
10177 ) {
10178 self.add_to_subobject_set.unwrap()(tt, obj, property, items, count)
10179 }
10180
10181 pub unsafe fn add_to_subobject_set_id(
10182 &self,
10183 tt: *mut TheTruthO,
10184 obj: *mut TheTruthObjectO,
10185 property: u32,
10186 items: *const TtIdT,
10187 count: u32,
10188 undo_scope: TtUndoScopeT,
10189 ) {
10190 self.add_to_subobject_set_id.unwrap()(tt, obj, property, items, count, undo_scope)
10191 }
10192
10193 pub unsafe fn remove_from_subobject_set(
10194 &self,
10195 tt: *mut TheTruthO,
10196 obj: *mut TheTruthObjectO,
10197 property: u32,
10198 items: *const TtIdT,
10199 count: u32,
10200 ) {
10201 self.remove_from_subobject_set.unwrap()(tt, obj, property, items, count)
10202 }
10203
10204 pub unsafe fn clear_subobject_set(
10205 &self,
10206 tt: *mut TheTruthO,
10207 obj: *mut TheTruthObjectO,
10208 property: u32,
10209 ) {
10210 self.clear_subobject_set.unwrap()(tt, obj, property)
10211 }
10212
10213 pub unsafe fn remove_from_prototype_subobject_set(
10214 &self,
10215 tt: *mut TheTruthO,
10216 obj: *mut TheTruthObjectO,
10217 property: u32,
10218 items: *const TtIdT,
10219 count: u32,
10220 ) {
10221 self.remove_from_prototype_subobject_set.unwrap()(tt, obj, property, items, count)
10222 }
10223
10224 pub unsafe fn cancel_remove_from_prototype_subobject_set(
10225 &self,
10226 tt: *mut TheTruthO,
10227 obj: *mut TheTruthObjectO,
10228 property: u32,
10229 items: *const TtIdT,
10230 count: u32,
10231 ) {
10232 self.cancel_remove_from_prototype_subobject_set.unwrap()(tt, obj, property, items, count)
10233 }
10234
10235 pub unsafe fn prototype(&self, tt: *const TheTruthO, object: TtIdT) -> TtIdT {
10236 self.prototype.unwrap()(tt, object)
10237 }
10238
10239 pub unsafe fn owner(&self, tt: *const TheTruthO, object: TtIdT) -> TtIdT {
10240 self.owner.unwrap()(tt, object)
10241 }
10242
10243 pub unsafe fn is_currently_owner_of(
10244 &self,
10245 tt: *const TheTruthO,
10246 object: TtIdT,
10247 subobject: TtIdT,
10248 ) -> bool {
10249 self.is_currently_owner_of.unwrap()(tt, object, subobject)
10250 }
10251
10252 pub unsafe fn is_overridden(
10253 &self,
10254 tt: *const TheTruthO,
10255 obj: *const TheTruthObjectO,
10256 property: u32,
10257 ) -> bool {
10258 self.is_overridden.unwrap()(tt, obj, property)
10259 }
10260
10261 pub unsafe fn has_data(
10262 &self,
10263 tt: *const TheTruthO,
10264 obj: *const TheTruthObjectO,
10265 property: u32,
10266 ) -> bool {
10267 self.has_data.unwrap()(tt, obj, property)
10268 }
10269
10270 pub unsafe fn prototype_relation(
10271 &self,
10272 tt: *const TheTruthO,
10273 parent: TtIdT,
10274 property: u32,
10275 object: TtIdT,
10276 ) -> TheTruthPrototypeRelation {
10277 self.prototype_relation.unwrap()(tt, parent, property, object)
10278 }
10279
10280 pub unsafe fn version(&self, tt: *const TheTruthO, object: TtIdT) -> u32 {
10281 self.version.unwrap()(tt, object)
10282 }
10283
10284 pub unsafe fn changed_objects(
10285 &self,
10286 tt: *const TheTruthO,
10287 type_: TtTypeT,
10288 since_version: u64,
10289 ta: *mut TempAllocatorI,
10290 ) -> TheTruthChangedObjectsT {
10291 self.changed_objects.unwrap()(tt, type_, since_version, ta)
10292 }
10293
10294 pub unsafe fn request_changelog(&self, tt: *mut TheTruthO) -> u64 {
10295 self.request_changelog.unwrap()(tt)
10296 }
10297
10298 pub unsafe fn relinquish_changelog(&self, tt: *mut TheTruthO, h: u64) {
10299 self.relinquish_changelog.unwrap()(tt, h)
10300 }
10301
10302 pub unsafe fn disable_changelog_start_scope(&self, tt: *mut TheTruthO) {
10303 self.disable_changelog_start_scope.unwrap()(tt)
10304 }
10305
10306 pub unsafe fn disable_changelog_end_scope(&self, tt: *mut TheTruthO) {
10307 self.disable_changelog_end_scope.unwrap()(tt)
10308 }
10309
10310 pub unsafe fn changelog_size(&self, tt: *mut TheTruthO) -> u64 {
10311 self.changelog_size.unwrap()(tt)
10312 }
10313
10314 pub unsafe fn serialize(
10315 &self,
10316 tt: *mut TheTruthO,
10317 o: TtIdT,
10318 carray: *mut *mut ::std::os::raw::c_char,
10319 a: *mut AllocatorI,
10320 opt: *const TtSerializeOptionsT,
10321 ) {
10322 self.serialize.unwrap()(tt, o, carray, a, opt)
10323 }
10324
10325 pub unsafe fn deserialize(
10326 &self,
10327 tt: *mut TheTruthO,
10328 buffer: *mut *const ::std::os::raw::c_char,
10329 opt: *const TtDeserializeOptionsT,
10330 ) -> TtIdT {
10331 self.deserialize.unwrap()(tt, buffer, opt)
10332 }
10333
10334 pub unsafe fn buffer_hashes(
10335 &self,
10336 buffer: *mut *const ::std::os::raw::c_char,
10337 count: *mut u64,
10338 ) -> *const u64 {
10339 self.buffer_hashes.unwrap()(buffer, count)
10340 }
10341
10342 pub unsafe fn deserialize_from_file(
10343 &self,
10344 tt: *mut TheTruthO,
10345 file: *const ::std::os::raw::c_char,
10346 ) -> TtIdT {
10347 self.deserialize_from_file.unwrap()(tt, file)
10348 }
10349
10350 pub unsafe fn migration_ids(&self, tt: *const TheTruthO, n: *mut u32) -> *mut StrhashT {
10351 self.migration_ids.unwrap()(tt, n)
10352 }
10353
10354 pub unsafe fn serialize_changes_header(
10355 &self,
10356 tt: *mut TheTruthO,
10357 carray: *mut *mut ::std::os::raw::c_char,
10358 a: *mut AllocatorI,
10359 ) {
10360 self.serialize_changes_header.unwrap()(tt, carray, a)
10361 }
10362
10363 pub unsafe fn serialize_changes(
10364 &self,
10365 tt: *mut TheTruthO,
10366 begin: u64,
10367 end: u64,
10368 carray: *mut *mut ::std::os::raw::c_char,
10369 a: *mut AllocatorI,
10370 opt: *const TtSerializeChangesOptionsT,
10371 ) {
10372 self.serialize_changes.unwrap()(tt, begin, end, carray, a, opt)
10373 }
10374
10375 pub unsafe fn deserialize_changes(
10376 &self,
10377 tt: *mut TheTruthO,
10378 buffer: *mut *const ::std::os::raw::c_char,
10379 opt: *const TtDeserializeChangesOptionsT,
10380 ) {
10381 self.deserialize_changes.unwrap()(tt, buffer, opt)
10382 }
10383
10384 pub unsafe fn serialize_patch(
10385 &self,
10386 from_tt: *mut TheTruthO,
10387 from_o: TtIdT,
10388 to_tt: *mut TheTruthO,
10389 to_o: TtIdT,
10390 carray: *mut *mut ::std::os::raw::c_char,
10391 a: *mut AllocatorI,
10392 ) {
10393 self.serialize_patch.unwrap()(from_tt, from_o, to_tt, to_o, carray, a)
10394 }
10395
10396 pub unsafe fn deserialize_patch(
10397 &self,
10398 tt: *mut TheTruthO,
10399 buffer: *mut *const ::std::os::raw::c_char,
10400 ) {
10401 self.deserialize_patch.unwrap()(tt, buffer)
10402 }
10403
10404 pub unsafe fn deserialize_patch_from_file(
10405 &self,
10406 tt: *mut TheTruthO,
10407 file: *const ::std::os::raw::c_char,
10408 ) {
10409 self.deserialize_patch_from_file.unwrap()(tt, file)
10410 }
10411
10412 pub unsafe fn serialize_type(
10413 &self,
10414 tt: *mut TheTruthO,
10415 type_: u32,
10416 ta: *mut TempAllocatorI,
10417 ) -> *mut ::std::os::raw::c_char {
10418 self.serialize_type.unwrap()(tt, type_, ta)
10419 }
10420
10421 pub unsafe fn deserialize_type(
10422 &self,
10423 tt: *mut TheTruthO,
10424 buf: *mut *const ::std::os::raw::c_char,
10425 type_info: *mut TheTruthSerializedTypeInfoT,
10426 ) {
10427 self.deserialize_type.unwrap()(tt, buf, type_info)
10428 }
10429
10430 pub unsafe fn memory_use(
10431 &self,
10432 tt: *mut TheTruthO,
10433 id: TtIdT,
10434 buffers: *mut SetT,
10435 ) -> TtMemoryUseT {
10436 self.memory_use.unwrap()(tt, id, buffers)
10437 }
10438
10439 pub unsafe fn add_properties(
10440 &self,
10441 tt: *mut TheTruthO,
10442 type_: TtTypeT,
10443 properties: *const TheTruthPropertyDefinitionT,
10444 num_properties: u32,
10445 ) {
10446 self.add_properties.unwrap()(tt, type_, properties, num_properties)
10447 }
10448
10449 pub unsafe fn resolve_or_create_placeholder(
10450 &self,
10451 tt: *mut TheTruthO,
10452 uuid: UuidT,
10453 type_: TtTypeT,
10454 default_initialize: bool,
10455 ) -> TtIdT {
10456 self.resolve_or_create_placeholder.unwrap()(tt, uuid, type_, default_initialize)
10457 }
10458
10459 pub unsafe fn resolve_or_fail(&self, tt: *mut TheTruthO, uuid: UuidT, type_: TtTypeT) -> TtIdT {
10460 self.resolve_or_fail.unwrap()(tt, uuid, type_)
10461 }
10462
10463 pub unsafe fn set_uuid(&self, tt: *mut TheTruthO, id: TtIdT, uuid: UuidT) {
10464 self.set_uuid.unwrap()(tt, id, uuid)
10465 }
10466
10467 pub unsafe fn set_prototype(&self, tt: *mut TheTruthO, obj: *mut TheTruthObjectO, id: TtIdT) {
10468 self.set_prototype.unwrap()(tt, obj, id)
10469 }
10470
10471 pub unsafe fn detach_from_prototype(
10472 &self,
10473 tt: *mut TheTruthO,
10474 id: TtIdT,
10475 lookup: *mut HashIdToIdT,
10476 undo_scope: TtUndoScopeT,
10477 ) {
10478 self.detach_from_prototype.unwrap()(tt, id, lookup, undo_scope)
10479 }
10480
10481 pub unsafe fn detach_all_instances(
10482 &self,
10483 tt: *mut TheTruthO,
10484 id: TtIdT,
10485 undo_scope: TtUndoScopeT,
10486 ) {
10487 self.detach_all_instances.unwrap()(tt, id, undo_scope)
10488 }
10489
10490 pub unsafe fn get_local_reference_set(
10491 &self,
10492 tt: *const TheTruthO,
10493 obj: *const TheTruthObjectO,
10494 property: u32,
10495 ) -> TheTruthLocalSetT {
10496 self.get_local_reference_set.unwrap()(tt, obj, property)
10497 }
10498
10499 pub unsafe fn get_local_subobject_set(
10500 &self,
10501 tt: *const TheTruthO,
10502 obj: *const TheTruthObjectO,
10503 property: u32,
10504 ) -> TheTruthLocalSetT {
10505 self.get_local_subobject_set.unwrap()(tt, obj, property)
10506 }
10507
10508 pub unsafe fn set_local_reference_set(
10509 &self,
10510 tt: *mut TheTruthO,
10511 obj: *mut TheTruthObjectO,
10512 property: u32,
10513 set: TheTruthLocalSetT,
10514 ) {
10515 self.set_local_reference_set.unwrap()(tt, obj, property, set)
10516 }
10517
10518 pub unsafe fn set_local_subobject_set(
10519 &self,
10520 tt: *mut TheTruthO,
10521 obj: *mut TheTruthObjectO,
10522 property: u32,
10523 set: TheTruthSetLocalSubobjectSetT,
10524 ) {
10525 self.set_local_subobject_set.unwrap()(tt, obj, property, set)
10526 }
10527
10528 pub unsafe fn string_repository(&self, tt: *mut TheTruthO) -> *mut StringRepositoryI {
10529 self.string_repository.unwrap()(tt)
10530 }
10531
10532 pub unsafe fn set_migration_ids(&self, tt: *mut TheTruthO, ids: *mut StrhashT, n: u32) {
10533 self.set_migration_ids.unwrap()(tt, ids, n)
10534 }
10535
10536 pub unsafe fn set_properties_to_default(
10537 &self,
10538 tt: *mut TheTruthO,
10539 obj: *mut TheTruthObjectO,
10540 mask: u64,
10541 ) {
10542 self.set_properties_to_default.unwrap()(tt, obj, mask)
10543 }
10544
10545 pub unsafe fn instantiate_subobjects_recursively(
10546 &self,
10547 tt: *mut TheTruthO,
10548 object: TtIdT,
10549 undo_scope: TtUndoScopeT,
10550 ) {
10551 self.instantiate_subobjects_recursively.unwrap()(tt, object, undo_scope)
10552 }
10553
10554 pub unsafe fn quick_set_properties(
10555 &self,
10556 tt: *mut TheTruthO,
10557 undo_scope: TtUndoScopeT,
10558 id: TtIdT,
10559 ) {
10560 self.quick_set_properties.unwrap()(tt, undo_scope, id)
10561 }
10562
10563 pub unsafe fn quick_create_object(
10564 &self,
10565 tt: *mut TheTruthO,
10566 undo_scope: TtUndoScopeT,
10567 type_hash: StrhashT,
10568 ) -> TtIdT {
10569 self.quick_create_object.unwrap()(tt, undo_scope, type_hash)
10570 }
10571
10572 pub unsafe fn quick_get_property(
10573 &self,
10574 tt: *const TheTruthO,
10575 id: TtIdT,
10576 prop_1: u32,
10577 ) -> TtPropValueT {
10578 self.quick_get_property.unwrap()(tt, id, prop_1)
10579 }
10580
10581 pub unsafe fn copy_properties_by_name(
10582 &self,
10583 t: *mut TheTruthO,
10584 to: TtIdT,
10585 from: TtIdT,
10586 undo_scope: TtUndoScopeT,
10587 ) {
10588 self.copy_properties_by_name.unwrap()(t, to, from, undo_scope)
10589 }
10590
10591 pub unsafe fn debug_inspect(
10592 &self,
10593 tt: *const TheTruthO,
10594 object: TtIdT,
10595 ) -> *const ::std::os::raw::c_char {
10596 self.debug_inspect.unwrap()(tt, object)
10597 }
10598
10599 pub unsafe fn create(&self, a: *mut AllocatorI, types: TheTruthCreateTypes) -> *mut TheTruthO {
10600 self.create.unwrap()(a, types)
10601 }
10602
10603 pub unsafe fn destroy(&self, tt: *mut TheTruthO) {
10604 self.destroy.unwrap()(tt)
10605 }
10606}
10607
10608impl crate::Api for TheTruthApi {
10609 const NAME: ConstCStr = const_cstr!("tm_the_truth_api");
10610 const VERSION: VersionT = VersionT {
10611 major: 1u32,
10612 minor: 0u32,
10613 patch: 0u32,
10614 };
10615}
10616
10617impl TheTruthAssetsApi {
10618 pub unsafe fn get_asset_path(
10619 &self,
10620 tt: *const TheTruthO,
10621 asset: TtIdT,
10622 path: *mut ::std::os::raw::c_char,
10623 n: u32,
10624 ) -> u32 {
10625 self.get_asset_path.unwrap()(tt, asset, path, n)
10626 }
10627
10628 pub unsafe fn get_directory_path(
10629 &self,
10630 tt: *const TheTruthO,
10631 directory: TtIdT,
10632 path: *mut ::std::os::raw::c_char,
10633 n: u32,
10634 ) -> u32 {
10635 self.get_directory_path.unwrap()(tt, directory, path, n)
10636 }
10637
10638 pub unsafe fn get_asset_path_with_extension(
10639 &self,
10640 tt: *const TheTruthO,
10641 asset: TtIdT,
10642 path: *mut ::std::os::raw::c_char,
10643 n: u32,
10644 ) -> u32 {
10645 self.get_asset_path_with_extension.unwrap()(tt, asset, path, n)
10646 }
10647
10648 pub unsafe fn asset_from_path(
10649 &self,
10650 tt: *const TheTruthO,
10651 asset_root: TtIdT,
10652 path: *const ::std::os::raw::c_char,
10653 ) -> TtIdT {
10654 self.asset_from_path.unwrap()(tt, asset_root, path)
10655 }
10656
10657 pub unsafe fn asset_from_path_with_type(
10658 &self,
10659 tt: *const TheTruthO,
10660 asset_root: TtIdT,
10661 path: *const ::std::os::raw::c_char,
10662 type_: TtTypeT,
10663 ) -> TtIdT {
10664 self.asset_from_path_with_type.unwrap()(tt, asset_root, path, type_)
10665 }
10666
10667 pub unsafe fn asset_object_from_path(
10668 &self,
10669 tt: *const TheTruthO,
10670 asset_root: TtIdT,
10671 path: *const ::std::os::raw::c_char,
10672 ) -> TtIdT {
10673 self.asset_object_from_path.unwrap()(tt, asset_root, path)
10674 }
10675
10676 pub unsafe fn asset_object_from_path_with_type(
10677 &self,
10678 tt: *const TheTruthO,
10679 asset_root: TtIdT,
10680 path: *const ::std::os::raw::c_char,
10681 type_: TtTypeT,
10682 ) -> TtIdT {
10683 self.asset_object_from_path_with_type.unwrap()(tt, asset_root, path, type_)
10684 }
10685
10686 pub unsafe fn directory_from_path(
10687 &self,
10688 tt: *const TheTruthO,
10689 asset_root: TtIdT,
10690 path: *const ::std::os::raw::c_char,
10691 ) -> TtIdT {
10692 self.directory_from_path.unwrap()(tt, asset_root, path)
10693 }
10694
10695 pub unsafe fn find_subdirectory_by_name(
10696 &self,
10697 tt: *const TheTruthO,
10698 asset_root: TtIdT,
10699 parent_dir: TtIdT,
10700 subdir_name: *const ::std::os::raw::c_char,
10701 ) -> TtIdT {
10702 self.find_subdirectory_by_name.unwrap()(tt, asset_root, parent_dir, subdir_name)
10703 }
10704
10705 pub unsafe fn unique_asset_name(
10706 &self,
10707 tt: *mut TheTruthO,
10708 asset_root: TtIdT,
10709 asset_r: *const TheTruthObjectO,
10710 desired_name: *const ::std::os::raw::c_char,
10711 ) -> *const ::std::os::raw::c_char {
10712 self.unique_asset_name.unwrap()(tt, asset_root, asset_r, desired_name)
10713 }
10714
10715 pub unsafe fn unique_directory_name(
10716 &self,
10717 tt: *mut TheTruthO,
10718 asset_root: TtIdT,
10719 directory_r: *const TheTruthObjectO,
10720 desired_name: *const ::std::os::raw::c_char,
10721 ) -> *const ::std::os::raw::c_char {
10722 self.unique_directory_name.unwrap()(tt, asset_root, directory_r, desired_name)
10723 }
10724
10725 pub unsafe fn object_asset_name(
10726 &self,
10727 tt: *mut TheTruthO,
10728 object: TtIdT,
10729 ) -> *const ::std::os::raw::c_char {
10730 self.object_asset_name.unwrap()(tt, object)
10731 }
10732
10733 pub unsafe fn find_directory_settings(
10734 &self,
10735 tt: *mut TheTruthO,
10736 relative_to: TtIdT,
10737 target_type_hash: StrhashT,
10738 asset_root: TtIdT,
10739 ) -> TtIdT {
10740 self.find_directory_settings.unwrap()(tt, relative_to, target_type_hash, asset_root)
10741 }
10742
10743 pub unsafe fn object_to_config(
10744 &self,
10745 tt: *const TheTruthO,
10746 object: TtIdT,
10747 config: *mut ConfigI,
10748 buffers: *mut *mut TtAssetsBufferWriteT,
10749 buffers_ta: *mut TempAllocatorI,
10750 save_uuid: bool,
10751 ) {
10752 self.object_to_config.unwrap()(tt, object, config, buffers, buffers_ta, save_uuid)
10753 }
10754
10755 pub unsafe fn create_object_from_config(
10756 &self,
10757 tt: *mut TheTruthO,
10758 config: *mut ConfigI,
10759 buffers: *mut *mut TtAssetsBufferT,
10760 buffers_ta: *mut TempAllocatorI,
10761 ) -> TtIdT {
10762 self.create_object_from_config.unwrap()(tt, config, buffers, buffers_ta)
10763 }
10764
10765 pub unsafe fn read_object_from_config(
10766 &self,
10767 tt: *mut TheTruthO,
10768 config: *mut ConfigI,
10769 buffers: *mut *mut TtAssetsBufferT,
10770 buffers_ta: *mut TempAllocatorI,
10771 id: TtIdT,
10772 ) {
10773 self.read_object_from_config.unwrap()(tt, config, buffers, buffers_ta, id)
10774 }
10775
10776 pub unsafe fn save_to_directory(
10777 &self,
10778 tt: *mut TheTruthO,
10779 asset_root: TtIdT,
10780 dir: *const ::std::os::raw::c_char,
10781 ignore: *mut TtIdT,
10782 num_ignore: u32,
10783 old_std: *mut SavedTruthDataO,
10784 allocator: *mut AllocatorI,
10785 ) -> *mut SavedTruthDataO {
10786 self.save_to_directory.unwrap()(tt, asset_root, dir, ignore, num_ignore, old_std, allocator)
10787 }
10788
10789 pub unsafe fn load_from_directory(
10790 &self,
10791 tt: *mut TheTruthO,
10792 dir: *const ::std::os::raw::c_char,
10793 allocator: *mut AllocatorI,
10794 asset_root: *mut TtIdT,
10795 error: *mut ErrorI,
10796 ) -> *mut SavedTruthDataO {
10797 self.load_from_directory.unwrap()(tt, dir, allocator, asset_root, error)
10798 }
10799
10800 pub unsafe fn current_truth_data(
10801 &self,
10802 tt: *mut TheTruthO,
10803 asset_root: TtIdT,
10804 allocator: *mut AllocatorI,
10805 ) -> *mut SavedTruthDataO {
10806 self.current_truth_data.unwrap()(tt, asset_root, allocator)
10807 }
10808
10809 pub unsafe fn revert_asset(
10810 &self,
10811 sd: *mut SavedTruthDataO,
10812 asset: TtIdT,
10813 undo_scope: TtUndoScopeT,
10814 ) -> bool {
10815 self.revert_asset.unwrap()(sd, asset, undo_scope)
10816 }
10817
10818 pub unsafe fn save_asset(&self, sd: *mut SavedTruthDataO, asset: TtIdT) -> bool {
10819 self.save_asset.unwrap()(sd, asset)
10820 }
10821
10822 pub unsafe fn saved_name(
10823 &self,
10824 sd: *mut SavedTruthDataO,
10825 item: TtIdT,
10826 ) -> *const ::std::os::raw::c_char {
10827 self.saved_name.unwrap()(sd, item)
10828 }
10829
10830 pub unsafe fn saved_directory(&self, sd: *mut SavedTruthDataO, item: TtIdT) -> TtIdT {
10831 self.saved_directory.unwrap()(sd, item)
10832 }
10833
10834 pub unsafe fn saved_version(&self, sd: *mut SavedTruthDataO, item: TtIdT) -> u64 {
10835 self.saved_version.unwrap()(sd, item)
10836 }
10837
10838 pub unsafe fn all_saved_items(
10839 &self,
10840 sd: *mut SavedTruthDataO,
10841 ta: *mut TempAllocatorI,
10842 ) -> *mut TtIdT {
10843 self.all_saved_items.unwrap()(sd, ta)
10844 }
10845
10846 pub unsafe fn free_saved_data(&self, sd: *mut SavedTruthDataO) {
10847 self.free_saved_data.unwrap()(sd)
10848 }
10849
10850 pub unsafe fn set_mock_file_system(&self, fs: *mut OsFileSystemApi, file_io: *mut OsFileIoApi) {
10851 self.set_mock_file_system.unwrap()(fs, file_io)
10852 }
10853
10854 pub unsafe fn any_disk_changes(
10855 &self,
10856 sd: *mut SavedTruthDataO,
10857 dir: *const ::std::os::raw::c_char,
10858 ) -> bool {
10859 self.any_disk_changes.unwrap()(sd, dir)
10860 }
10861}
10862
10863impl crate::Api for TheTruthAssetsApi {
10864 const NAME: ConstCStr = const_cstr!("tm_the_truth_assets_api");
10865 const VERSION: VersionT = VersionT {
10866 major: 1u32,
10867 minor: 0u32,
10868 patch: 0u32,
10869 };
10870}
10871
10872impl TheTruthMigrationApi {
10873 pub unsafe fn migrate(&self, tt: *mut TheTruthO) -> bool {
10874 self.migrate.unwrap()(tt)
10875 }
10876}
10877
10878impl crate::Api for TheTruthMigrationApi {
10879 const NAME: ConstCStr = const_cstr!("tm_the_truth_migration_api");
10880 const VERSION: VersionT = VersionT {
10881 major: 1u32,
10882 minor: 0u32,
10883 patch: 0u32,
10884 };
10885}
10886
10887impl TheTruthCommonTypesApi {
10888 pub unsafe fn create_common_types(&self, tt: *mut TheTruthO) {
10889 self.create_common_types.unwrap()(tt)
10890 }
10891
10892 pub unsafe fn get_vec2(
10893 &self,
10894 tt: *const TheTruthO,
10895 object: *const TheTruthObjectO,
10896 property: u32,
10897 ) -> Vec2T {
10898 self.get_vec2.unwrap()(tt, object, property)
10899 }
10900
10901 pub unsafe fn get_vec3(
10902 &self,
10903 tt: *const TheTruthO,
10904 object: *const TheTruthObjectO,
10905 property: u32,
10906 ) -> Vec3T {
10907 self.get_vec3.unwrap()(tt, object, property)
10908 }
10909
10910 pub unsafe fn get_vec4(
10911 &self,
10912 tt: *const TheTruthO,
10913 object: *const TheTruthObjectO,
10914 property: u32,
10915 ) -> Vec4T {
10916 self.get_vec4.unwrap()(tt, object, property)
10917 }
10918
10919 pub unsafe fn get_rect(
10920 &self,
10921 tt: *const TheTruthO,
10922 object: *const TheTruthObjectO,
10923 property: u32,
10924 ) -> RectT {
10925 self.get_rect.unwrap()(tt, object, property)
10926 }
10927
10928 pub unsafe fn get_position(
10929 &self,
10930 tt: *const TheTruthO,
10931 object: *const TheTruthObjectO,
10932 property: u32,
10933 ) -> Vec3T {
10934 self.get_position.unwrap()(tt, object, property)
10935 }
10936
10937 pub unsafe fn get_rotation(
10938 &self,
10939 tt: *const TheTruthO,
10940 object: *const TheTruthObjectO,
10941 property: u32,
10942 ) -> Vec4T {
10943 self.get_rotation.unwrap()(tt, object, property)
10944 }
10945
10946 pub unsafe fn get_scale(
10947 &self,
10948 tt: *const TheTruthO,
10949 object: *const TheTruthObjectO,
10950 property: u32,
10951 ) -> Vec3T {
10952 self.get_scale.unwrap()(tt, object, property)
10953 }
10954
10955 pub unsafe fn get_color_rgb(
10956 &self,
10957 tt: *const TheTruthO,
10958 object: *const TheTruthObjectO,
10959 property: u32,
10960 ) -> Vec3T {
10961 self.get_color_rgb.unwrap()(tt, object, property)
10962 }
10963
10964 pub unsafe fn get_color_rgba(
10965 &self,
10966 tt: *const TheTruthO,
10967 object: *const TheTruthObjectO,
10968 property: u32,
10969 ) -> Vec4T {
10970 self.get_color_rgba.unwrap()(tt, object, property)
10971 }
10972
10973 pub unsafe fn get_color_srgb(
10974 &self,
10975 tt: *const TheTruthO,
10976 object: *const TheTruthObjectO,
10977 property: u32,
10978 ) -> ColorSrgbT {
10979 self.get_color_srgb.unwrap()(tt, object, property)
10980 }
10981
10982 pub unsafe fn get_color_srgba(
10983 &self,
10984 tt: *const TheTruthO,
10985 object: *const TheTruthObjectO,
10986 property: u32,
10987 ) -> ColorSrgbT {
10988 self.get_color_srgba.unwrap()(tt, object, property)
10989 }
10990
10991 pub unsafe fn get_uuid(
10992 &self,
10993 tt: *const TheTruthO,
10994 object: *const TheTruthObjectO,
10995 property: u32,
10996 ) -> UuidT {
10997 self.get_uuid.unwrap()(tt, object, property)
10998 }
10999
11000 pub unsafe fn set_vec2(
11001 &self,
11002 tt: *mut TheTruthO,
11003 object: *mut TheTruthObjectO,
11004 property: u32,
11005 vec2: Vec2T,
11006 undo_scope: TtUndoScopeT,
11007 ) {
11008 self.set_vec2.unwrap()(tt, object, property, vec2, undo_scope)
11009 }
11010
11011 pub unsafe fn set_vec3(
11012 &self,
11013 tt: *mut TheTruthO,
11014 object: *mut TheTruthObjectO,
11015 property: u32,
11016 vec3: Vec3T,
11017 undo_scope: TtUndoScopeT,
11018 ) {
11019 self.set_vec3.unwrap()(tt, object, property, vec3, undo_scope)
11020 }
11021
11022 pub unsafe fn set_vec4(
11023 &self,
11024 tt: *mut TheTruthO,
11025 object: *mut TheTruthObjectO,
11026 property: u32,
11027 vec4: Vec4T,
11028 undo_scope: TtUndoScopeT,
11029 ) {
11030 self.set_vec4.unwrap()(tt, object, property, vec4, undo_scope)
11031 }
11032
11033 pub unsafe fn set_rect(
11034 &self,
11035 tt: *mut TheTruthO,
11036 object: *mut TheTruthObjectO,
11037 property: u32,
11038 rect: RectT,
11039 undo_scope: TtUndoScopeT,
11040 ) {
11041 self.set_rect.unwrap()(tt, object, property, rect, undo_scope)
11042 }
11043
11044 pub unsafe fn set_position(
11045 &self,
11046 tt: *mut TheTruthO,
11047 object: *mut TheTruthObjectO,
11048 property: u32,
11049 vec3: Vec3T,
11050 undo_scope: TtUndoScopeT,
11051 ) {
11052 self.set_position.unwrap()(tt, object, property, vec3, undo_scope)
11053 }
11054
11055 pub unsafe fn set_rotation(
11056 &self,
11057 tt: *mut TheTruthO,
11058 object: *mut TheTruthObjectO,
11059 property: u32,
11060 vec4: Vec4T,
11061 undo_scope: TtUndoScopeT,
11062 ) {
11063 self.set_rotation.unwrap()(tt, object, property, vec4, undo_scope)
11064 }
11065
11066 pub unsafe fn set_scale(
11067 &self,
11068 tt: *mut TheTruthO,
11069 object: *mut TheTruthObjectO,
11070 property: u32,
11071 vec3: Vec3T,
11072 undo_scope: TtUndoScopeT,
11073 ) {
11074 self.set_scale.unwrap()(tt, object, property, vec3, undo_scope)
11075 }
11076
11077 pub unsafe fn set_color_rgb(
11078 &self,
11079 tt: *mut TheTruthO,
11080 object: *mut TheTruthObjectO,
11081 property: u32,
11082 vec3: Vec3T,
11083 undo_scope: TtUndoScopeT,
11084 ) {
11085 self.set_color_rgb.unwrap()(tt, object, property, vec3, undo_scope)
11086 }
11087
11088 pub unsafe fn set_color_rgba(
11089 &self,
11090 tt: *mut TheTruthO,
11091 object: *mut TheTruthObjectO,
11092 property: u32,
11093 vec4: Vec4T,
11094 undo_scope: TtUndoScopeT,
11095 ) {
11096 self.set_color_rgba.unwrap()(tt, object, property, vec4, undo_scope)
11097 }
11098
11099 pub unsafe fn set_color_srgb(
11100 &self,
11101 tt: *mut TheTruthO,
11102 object: *mut TheTruthObjectO,
11103 property: u32,
11104 col: ColorSrgbT,
11105 undo_scope: TtUndoScopeT,
11106 ) {
11107 self.set_color_srgb.unwrap()(tt, object, property, col, undo_scope)
11108 }
11109
11110 pub unsafe fn set_color_srgba(
11111 &self,
11112 tt: *mut TheTruthO,
11113 object: *mut TheTruthObjectO,
11114 property: u32,
11115 col: ColorSrgbT,
11116 undo_scope: TtUndoScopeT,
11117 ) {
11118 self.set_color_srgba.unwrap()(tt, object, property, col, undo_scope)
11119 }
11120
11121 pub unsafe fn set_uuid(
11122 &self,
11123 tt: *mut TheTruthO,
11124 object: *mut TheTruthObjectO,
11125 property: u32,
11126 uuid: UuidT,
11127 undo_scope: TtUndoScopeT,
11128 ) {
11129 self.set_uuid.unwrap()(tt, object, property, uuid, undo_scope)
11130 }
11131
11132 pub unsafe fn read_floats(
11133 &self,
11134 tt: *const TheTruthO,
11135 obj: *const TheTruthObjectO,
11136 res: *mut f32,
11137 n: u32,
11138 ) -> *mut f32 {
11139 self.read_floats.unwrap()(tt, obj, res, n)
11140 }
11141
11142 pub unsafe fn write_floats(
11143 &self,
11144 tt: *mut TheTruthO,
11145 obj: *mut TheTruthObjectO,
11146 values: *const f32,
11147 n: u32,
11148 ) {
11149 self.write_floats.unwrap()(tt, obj, values, n)
11150 }
11151}
11152
11153impl crate::Api for TheTruthCommonTypesApi {
11154 const NAME: ConstCStr = const_cstr!("tm_the_truth_common_types_api");
11155 const VERSION: VersionT = VersionT {
11156 major: 1u32,
11157 minor: 0u32,
11158 patch: 0u32,
11159 };
11160}
11161
11162impl UnicodeApi {
11163 pub unsafe fn is_valid(&self, utf8: *const ::std::os::raw::c_char) -> bool {
11164 self.is_valid.unwrap()(utf8)
11165 }
11166
11167 pub unsafe fn truncate(&self, utf8: *mut ::std::os::raw::c_char) {
11168 self.truncate.unwrap()(utf8)
11169 }
11170
11171 pub unsafe fn utf8_encode(
11172 &self,
11173 utf8: *mut ::std::os::raw::c_char,
11174 codepoint: u32,
11175 ) -> *mut ::std::os::raw::c_char {
11176 self.utf8_encode.unwrap()(utf8, codepoint)
11177 }
11178
11179 pub unsafe fn utf8_decode(&self, utf8: *mut *const ::std::os::raw::c_char) -> u32 {
11180 self.utf8_decode.unwrap()(utf8)
11181 }
11182
11183 pub unsafe fn utf8_num_codepoints(&self, utf8: *const ::std::os::raw::c_char) -> u32 {
11184 self.utf8_num_codepoints.unwrap()(utf8)
11185 }
11186
11187 pub unsafe fn utf8_decode_n(
11188 &self,
11189 codepoints: *mut u32,
11190 n: u32,
11191 utf8: *const ::std::os::raw::c_char,
11192 ) -> u32 {
11193 self.utf8_decode_n.unwrap()(codepoints, n, utf8)
11194 }
11195
11196 pub unsafe fn utf8_to_utf32(
11197 &self,
11198 utf8: *const ::std::os::raw::c_char,
11199 ta: *mut TempAllocatorI,
11200 ) -> *mut u32 {
11201 self.utf8_to_utf32.unwrap()(utf8, ta)
11202 }
11203
11204 pub unsafe fn utf8_to_utf32_n(
11205 &self,
11206 utf8: *const ::std::os::raw::c_char,
11207 n: u32,
11208 ta: *mut TempAllocatorI,
11209 ) -> *mut u32 {
11210 self.utf8_to_utf32_n.unwrap()(utf8, n, ta)
11211 }
11212
11213 pub unsafe fn utf32_to_utf8(
11214 &self,
11215 utf32: *const u32,
11216 ta: *mut TempAllocatorI,
11217 ) -> *mut ::std::os::raw::c_char {
11218 self.utf32_to_utf8.unwrap()(utf32, ta)
11219 }
11220
11221 pub unsafe fn utf32_to_utf8_n(
11222 &self,
11223 utf32: *const u32,
11224 n: u32,
11225 ta: *mut TempAllocatorI,
11226 ) -> *mut ::std::os::raw::c_char {
11227 self.utf32_to_utf8_n.unwrap()(utf32, n, ta)
11228 }
11229
11230 pub unsafe fn utf16_encode(&self, utf16: *mut u16, codepoint: u32) -> *mut u16 {
11231 self.utf16_encode.unwrap()(utf16, codepoint)
11232 }
11233
11234 pub unsafe fn utf16_decode(&self, utf16: *mut *const u16) -> u32 {
11235 self.utf16_decode.unwrap()(utf16)
11236 }
11237
11238 pub unsafe fn utf8_to_utf16(
11239 &self,
11240 utf8: *const ::std::os::raw::c_char,
11241 ta: *mut TempAllocatorI,
11242 ) -> *mut u16 {
11243 self.utf8_to_utf16.unwrap()(utf8, ta)
11244 }
11245
11246 pub unsafe fn utf8_to_utf16_n(
11247 &self,
11248 utf8: *const ::std::os::raw::c_char,
11249 n: u32,
11250 ta: *mut TempAllocatorI,
11251 ) -> *mut u16 {
11252 self.utf8_to_utf16_n.unwrap()(utf8, n, ta)
11253 }
11254
11255 pub unsafe fn utf16_to_utf8(
11256 &self,
11257 utf16: *const u16,
11258 ta: *mut TempAllocatorI,
11259 ) -> *mut ::std::os::raw::c_char {
11260 self.utf16_to_utf8.unwrap()(utf16, ta)
11261 }
11262
11263 pub unsafe fn utf16_to_utf8_n(
11264 &self,
11265 utf16: *const u16,
11266 n: u32,
11267 ta: *mut TempAllocatorI,
11268 ) -> *mut ::std::os::raw::c_char {
11269 self.utf16_to_utf8_n.unwrap()(utf16, n, ta)
11270 }
11271}
11272
11273impl crate::Api for UnicodeApi {
11274 const NAME: ConstCStr = const_cstr!("tm_unicode_api");
11275 const VERSION: VersionT = VersionT {
11276 major: 1u32,
11277 minor: 0u32,
11278 patch: 0u32,
11279 };
11280}
11281
11282impl VisibilityFlagsApi {
11283 pub unsafe fn create_context(
11284 &self,
11285 allocator: *mut AllocatorI,
11286 name: StrhashT,
11287 ) -> *mut VisibilityContextO {
11288 self.create_context.unwrap()(allocator, name)
11289 }
11290
11291 pub unsafe fn context_name(&self, context: *mut VisibilityContextO) -> StrhashT {
11292 self.context_name.unwrap()(context)
11293 }
11294
11295 pub unsafe fn destroy_context(&self, context: *mut VisibilityContextO) {
11296 self.destroy_context.unwrap()(context)
11297 }
11298
11299 pub unsafe fn register_visibility_flag(
11300 &self,
11301 context: *mut VisibilityContextO,
11302 desc: *const VisibilityFlagDescI,
11303 ) -> u64 {
11304 self.register_visibility_flag.unwrap()(context, desc)
11305 }
11306
11307 pub unsafe fn name_from_visibility_flag(
11308 &self,
11309 context: *mut VisibilityContextO,
11310 visibility_flag: u64,
11311 ) -> StrhashT {
11312 self.name_from_visibility_flag.unwrap()(context, visibility_flag)
11313 }
11314
11315 pub unsafe fn visibility_flag_from_name(
11316 &self,
11317 context: *mut VisibilityContextO,
11318 name: StrhashT,
11319 ) -> u64 {
11320 self.visibility_flag_from_name.unwrap()(context, name)
11321 }
11322
11323 pub unsafe fn unregister_visibility_flag(&self, context: *mut VisibilityContextO, uuid: u32) {
11324 self.unregister_visibility_flag.unwrap()(context, uuid)
11325 }
11326
11327 pub unsafe fn enumerate_flags(
11328 &self,
11329 context: *mut VisibilityContextO,
11330 flags: *mut VisibilityFlagDescI,
11331 num_flags: *mut u32,
11332 ) {
11333 self.enumerate_flags.unwrap()(context, flags, num_flags)
11334 }
11335
11336 pub unsafe fn build_visibility_mask(
11337 &self,
11338 context: *mut VisibilityContextO,
11339 uuids: *const u32,
11340 num_uuids: u32,
11341 ) -> u64 {
11342 self.build_visibility_mask.unwrap()(context, uuids, num_uuids)
11343 }
11344}
11345
11346impl crate::Api for VisibilityFlagsApi {
11347 const NAME: ConstCStr = const_cstr!("tm_visibility_flags_api");
11348 const VERSION: VersionT = VersionT {
11349 major: 1u32,
11350 minor: 0u32,
11351 patch: 0u32,
11352 };
11353}
11354
11355impl WebSocketProtocolApi {
11356 pub unsafe fn make_client_handshake(
11357 &self,
11358 buffer: *mut ::std::os::raw::c_char,
11359 size: u32,
11360 host: *const ::std::os::raw::c_char,
11361 port: u32,
11362 request: *const ::std::os::raw::c_char,
11363 key: *const ::std::os::raw::c_char,
11364 ) {
11365 self.make_client_handshake.unwrap()(buffer, size, host, port, request, key)
11366 }
11367
11368 pub unsafe fn make_server_handshake(
11369 &self,
11370 buffer: *mut ::std::os::raw::c_char,
11371 size: u32,
11372 key: *const ::std::os::raw::c_char,
11373 key_size: u32,
11374 ) {
11375 self.make_server_handshake.unwrap()(buffer, size, key, key_size)
11376 }
11377
11378 pub unsafe fn make_frame_header(
11379 &self,
11380 buffer: *mut u8,
11381 fin: bool,
11382 opcode: u8,
11383 size: u64,
11384 mask: u32,
11385 ) -> u32 {
11386 self.make_frame_header.unwrap()(buffer, fin, opcode, size, mask)
11387 }
11388
11389 pub unsafe fn parse_frame_header(
11390 &self,
11391 buffer: *mut u8,
11392 buf_size: u64,
11393 fin: *mut bool,
11394 opcode: *mut u8,
11395 size: *mut u64,
11396 mask: *mut u32,
11397 ) -> u32 {
11398 self.parse_frame_header.unwrap()(buffer, buf_size, fin, opcode, size, mask)
11399 }
11400
11401 pub unsafe fn mask_data(&self, data: *mut u8, size: u64, offset: u64, mask: u32) {
11402 self.mask_data.unwrap()(data, size, offset, mask)
11403 }
11404
11405 pub unsafe fn mask_segmented_buffer(&self, seg: *mut SegmentedBufferT, size: u64, mask: u32) {
11406 self.mask_segmented_buffer.unwrap()(seg, size, mask)
11407 }
11408}
11409
11410impl crate::Api for WebSocketProtocolApi {
11411 const NAME: ConstCStr = const_cstr!("tm_web_socket_protocol_api");
11412 const VERSION: VersionT = VersionT {
11413 major: 1u32,
11414 minor: 0u32,
11415 patch: 0u32,
11416 };
11417}
11418
11419impl WebTalkerApi {
11420 pub unsafe fn create(
11421 &self,
11422 a: *mut AllocatorI,
11423 socket: *mut OsSocketApi,
11424 port: u32,
11425 ) -> *mut WebTalkerO {
11426 self.create.unwrap()(a, socket, port)
11427 }
11428
11429 pub unsafe fn listening_address(
11430 &self,
11431 inst: *mut WebTalkerO,
11432 address: *mut SocketAddressT,
11433 ) -> bool {
11434 self.listening_address.unwrap()(inst, address)
11435 }
11436
11437 pub unsafe fn create_no_server(
11438 &self,
11439 a: *mut AllocatorI,
11440 socket: *mut OsSocketApi,
11441 ) -> *mut WebTalkerO {
11442 self.create_no_server.unwrap()(a, socket)
11443 }
11444
11445 pub unsafe fn destroy(&self, arg1: *mut WebTalkerO) {
11446 self.destroy.unwrap()(arg1)
11447 }
11448
11449 pub unsafe fn receive(&self, inst: *mut WebTalkerO) {
11450 self.receive.unwrap()(inst)
11451 }
11452
11453 pub unsafe fn send(&self, inst: *mut WebTalkerO) {
11454 self.send.unwrap()(inst)
11455 }
11456
11457 pub unsafe fn http_get_requests(
11458 &self,
11459 inst: *mut WebTalkerO,
11460 buffer: *mut HttpRequestT,
11461 capacity: u32,
11462 ) -> u32 {
11463 self.http_get_requests.unwrap()(inst, buffer, capacity)
11464 }
11465
11466 pub unsafe fn http_respond_raw(
11467 &self,
11468 inst: *mut WebTalkerO,
11469 id: u64,
11470 response: *const ::std::os::raw::c_char,
11471 ) {
11472 self.http_respond_raw.unwrap()(inst, id, response)
11473 }
11474
11475 pub unsafe fn http_respond_html(
11476 &self,
11477 inst: *mut WebTalkerO,
11478 id: u64,
11479 html: *const ::std::os::raw::c_char,
11480 ) {
11481 self.http_respond_html.unwrap()(inst, id, html)
11482 }
11483
11484 pub unsafe fn http_request(
11485 &self,
11486 inst: *mut WebTalkerO,
11487 address: SocketAddressT,
11488 headers: *const ::std::os::raw::c_char,
11489 ) -> u64 {
11490 self.http_request.unwrap()(inst, address, headers)
11491 }
11492
11493 pub unsafe fn http_request_status(&self, inst: *mut WebTalkerO, id: u64) -> HttpRequestStatus {
11494 self.http_request_status.unwrap()(inst, id)
11495 }
11496
11497 pub unsafe fn http_response(
11498 &self,
11499 inst: *mut WebTalkerO,
11500 id: u64,
11501 size: *mut u64,
11502 ) -> SegmentedBufferT {
11503 self.http_response.unwrap()(inst, id, size)
11504 }
11505
11506 pub unsafe fn http_close(&self, inst: *mut WebTalkerO, id: u64) {
11507 self.http_close.unwrap()(inst, id)
11508 }
11509
11510 pub unsafe fn ws_connect(
11511 &self,
11512 inst: *mut WebTalkerO,
11513 address: SocketAddressT,
11514 host: *const ::std::os::raw::c_char,
11515 request: *const ::std::os::raw::c_char,
11516 ) -> u64 {
11517 self.ws_connect.unwrap()(inst, address, host, request)
11518 }
11519
11520 pub unsafe fn ws_get_requests(
11521 &self,
11522 inst: *mut WebTalkerO,
11523 buffer: *mut WebSocketRequestT,
11524 capacity: u32,
11525 ) -> u32 {
11526 self.ws_get_requests.unwrap()(inst, buffer, capacity)
11527 }
11528
11529 pub unsafe fn ws_status(&self, inst: *mut WebTalkerO, id: u64) -> WebSocketStatus {
11530 self.ws_status.unwrap()(inst, id)
11531 }
11532
11533 pub unsafe fn ws_recv_progress(
11534 &self,
11535 inst: *mut WebTalkerO,
11536 id: u64,
11537 bytes: *mut u64,
11538 total: *mut u64,
11539 ) -> bool {
11540 self.ws_recv_progress.unwrap()(inst, id, bytes, total)
11541 }
11542
11543 pub unsafe fn ws_get_events(
11544 &self,
11545 inst: *mut WebTalkerO,
11546 id: u64,
11547 buffer: *mut WebSocketEventT,
11548 capacity: u32,
11549 ) -> u32 {
11550 self.ws_get_events.unwrap()(inst, id, buffer, capacity)
11551 }
11552
11553 pub unsafe fn ws_send_text_frame(
11554 &self,
11555 inst: *mut WebTalkerO,
11556 id: u64,
11557 s: *const ::std::os::raw::c_char,
11558 ) {
11559 self.ws_send_text_frame.unwrap()(inst, id, s)
11560 }
11561
11562 pub unsafe fn ws_send_binary_frame(
11563 &self,
11564 inst: *mut WebTalkerO,
11565 id: u64,
11566 data: *const u8,
11567 size: u64,
11568 ) {
11569 self.ws_send_binary_frame.unwrap()(inst, id, data, size)
11570 }
11571
11572 pub unsafe fn ws_send_segmented_binary_frame(
11573 &self,
11574 inst: *mut WebTalkerO,
11575 id: u64,
11576 buf: *const SegmentedBufferT,
11577 size: u64,
11578 ) {
11579 self.ws_send_segmented_binary_frame.unwrap()(inst, id, buf, size)
11580 }
11581
11582 pub unsafe fn ws_send_ping(&self, inst: *mut WebTalkerO, id: u64) {
11583 self.ws_send_ping.unwrap()(inst, id)
11584 }
11585
11586 pub unsafe fn ws_close(&self, inst: *mut WebTalkerO, id: u64) {
11587 self.ws_close.unwrap()(inst, id)
11588 }
11589
11590 pub unsafe fn copy_segmented_buffer(
11591 &self,
11592 buffer: *mut ::std::os::raw::c_void,
11593 segments: *const SegmentedBufferT,
11594 size: u64,
11595 ) {
11596 self.copy_segmented_buffer.unwrap()(buffer, segments, size)
11597 }
11598}
11599
11600impl crate::Api for WebTalkerApi {
11601 const NAME: ConstCStr = const_cstr!("tm_web_talker_api");
11602 const VERSION: VersionT = VersionT {
11603 major: 1u32,
11604 minor: 0u32,
11605 patch: 0u32,
11606 };
11607}
11608
11609pub const TM_TYPE_HASH__BOOL: StrhashT = StrhashT {
11610 u64_: 16540862642162215401u64,
11611};
11612pub const TM_TYPE_HASH__UINT8_T: StrhashT = StrhashT {
11613 u64_: 8559580523335163012u64,
11614};
11615pub const TM_TYPE_HASH__UINT16_T: StrhashT = StrhashT {
11616 u64_: 15324894991619482704u64,
11617};
11618pub const TM_TYPE_HASH__UINT32_T: StrhashT = StrhashT {
11619 u64_: 7376399353478788036u64,
11620};
11621pub const TM_TYPE_HASH__UINT64_T: StrhashT = StrhashT {
11622 u64_: 18144472437779314990u64,
11623};
11624pub const TM_TYPE_HASH__FLOAT: StrhashT = StrhashT {
11625 u64_: 4361463899232155093u64,
11626};
11627pub const TM_TYPE_HASH__DOUBLE: StrhashT = StrhashT {
11628 u64_: 2716045784919460316u64,
11629};
11630pub const TM_TYPE_HASH__TM_VEC2_T: StrhashT = StrhashT {
11631 u64_: 6818937449469173318u64,
11632};
11633pub const TM_TYPE_HASH__TM_VEC3_T: StrhashT = StrhashT {
11634 u64_: 10165899445488706529u64,
11635};
11636pub const TM_TYPE_HASH__TM_VEC4_T: StrhashT = StrhashT {
11637 u64_: 16105198182785596086u64,
11638};
11639pub const TM_TYPE_HASH__TM_MAT44_T: StrhashT = StrhashT {
11640 u64_: 6274398046370934111u64,
11641};
11642pub const TM_COLLABORATION_SESSION_ARCHITECTURE__P2P: StrhashT = StrhashT {
11643 u64_: 3712735182291565690u64,
11644};
11645pub const TM_FEATURE_FLAG__INTERNAL_DEVELOPER_TOOLS: StrhashT = StrhashT {
11646 u64_: 11549283883340918408u64,
11647};
11648pub const TM_FEATURE_FLAG__UI_USES_VECTOR_FONT: StrhashT = StrhashT {
11649 u64_: 7354548536171183257u64,
11650};
11651pub const TM_FEATURE_FLAG__SCENE_COMMANDS: StrhashT = StrhashT {
11652 u64_: 4872997832008015268u64,
11653};
11654pub const TM_FEATURE_FLAG__VOXEL_ASSETS: StrhashT = StrhashT {
11655 u64_: 14684113058603897788u64,
11656};
11657pub const TM_FEATURE_FLAG__WATCH_WIRES: StrhashT = StrhashT {
11658 u64_: 6084627402685503047u64,
11659};
11660pub const TM_FEATURE_FLAG__BREAKPOINTS: StrhashT = StrhashT {
11661 u64_: 12171838945250017565u64,
11662};
11663pub const TM_FEATURE_FLAG__GLOBAL_ILLUMINATION: StrhashT = StrhashT {
11664 u64_: 14054475124752319158u64,
11665};
11666pub const TM_FEATURE_FLAG__NETWORKING: StrhashT = StrhashT {
11667 u64_: 14342885002789868064u64,
11668};
11669pub const TM_INTEGRATION_TEST_CONTEXT__THE_MACHINERY_EDITOR: StrhashT = StrhashT {
11670 u64_: 6564203205322320365u64,
11671};
11672pub const TM_LANGUAGE_ENGLISH: StrhashT = StrhashT {
11673 u64_: 7710216835639188562u64,
11674};
11675pub const TM_LANGUAGE_DUTCH: StrhashT = StrhashT {
11676 u64_: 1250082070672125555u64,
11677};
11678pub const TM_LANGUAGE_FRENCH: StrhashT = StrhashT {
11679 u64_: 18347935498605111012u64,
11680};
11681pub const TM_LANGUAGE_GERMAN: StrhashT = StrhashT {
11682 u64_: 13418971983228644420u64,
11683};
11684pub const TM_LANGUAGE_ITALIAN: StrhashT = StrhashT {
11685 u64_: 16355695940806680529u64,
11686};
11687pub const TM_LANGUAGE_PORTUGUESE: StrhashT = StrhashT {
11688 u64_: 5344833540692673681u64,
11689};
11690pub const TM_LANGUAGE_SPANISH: StrhashT = StrhashT {
11691 u64_: 3566965541708517290u64,
11692};
11693pub const TM_LANGUAGE_SWEDISH: StrhashT = StrhashT {
11694 u64_: 17821763756083510268u64,
11695};
11696pub const TM_LANGUAGE_TAGALOG: StrhashT = StrhashT {
11697 u64_: 15699795126974246192u64,
11698};
11699pub const TM_PSEUDO_LANGUAGE_GIBBERISH: StrhashT = StrhashT {
11700 u64_: 8182454343404938431u64,
11701};
11702pub const TM_PSEUDO_LANGUAGE_CONTEXT: StrhashT = StrhashT {
11703 u64_: 10587708927429250677u64,
11704};
11705pub const TM_TT_TYPE_HASH__PLUGIN: StrhashT = StrhashT {
11706 u64_: 14899577057384826377u64,
11707};
11708pub const TM_TT_TYPE_HASH__ANYTHING: StrhashT = StrhashT {
11709 u64_: 9891277735898990422u64,
11710};
11711pub const TM_TT_TYPE_HASH__ASSET_ROOT: StrhashT = StrhashT {
11712 u64_: 12427581353952698963u64,
11713};
11714pub const TM_TT_TYPE_HASH__ASSET: StrhashT = StrhashT {
11715 u64_: 14587460986374400352u64,
11716};
11717pub const TM_TT_TYPE_HASH__ASSET_DIRECTORY: StrhashT = StrhashT {
11718 u64_: 10890794697157403146u64,
11719};
11720pub const TM_TT_TYPE_HASH__ASSET_LABEL: StrhashT = StrhashT {
11721 u64_: 6843264115021824839u64,
11722};
11723pub const TM_TT_ASPECT__FILE_EXTENSION: StrhashT = StrhashT {
11724 u64_: 9567164115475830323u64,
11725};
11726pub const TM_TT_TYPE_HASH__ASSET_THUMBNAIL: StrhashT = StrhashT {
11727 u64_: 2983294151888264002u64,
11728};
11729pub const TM_TT_TYPE_HASH__BOOL: StrhashT = StrhashT {
11730 u64_: 12597635396010430865u64,
11731};
11732pub const TM_TT_TYPE_HASH__UINT32_T: StrhashT = StrhashT {
11733 u64_: 16929917001317266792u64,
11734};
11735pub const TM_TT_TYPE_HASH__UINT64_T: StrhashT = StrhashT {
11736 u64_: 12761691598820893534u64,
11737};
11738pub const TM_TT_TYPE_HASH__FLOAT: StrhashT = StrhashT {
11739 u64_: 7857178761304035899u64,
11740};
11741pub const TM_TT_TYPE_HASH__DOUBLE: StrhashT = StrhashT {
11742 u64_: 1077166915827059684u64,
11743};
11744pub const TM_TT_TYPE_HASH__STRING: StrhashT = StrhashT {
11745 u64_: 12126753421808361675u64,
11746};
11747pub const TM_TT_TYPE_HASH__VEC2: StrhashT = StrhashT {
11748 u64_: 6818937449469173318u64,
11749};
11750pub const TM_TT_TYPE_HASH__VEC3: StrhashT = StrhashT {
11751 u64_: 10165899445488706529u64,
11752};
11753pub const TM_TT_TYPE_HASH__VEC4: StrhashT = StrhashT {
11754 u64_: 16105198182785596086u64,
11755};
11756pub const TM_TT_TYPE_HASH__POSITION: StrhashT = StrhashT {
11757 u64_: 8802770316356633324u64,
11758};
11759pub const TM_TT_TYPE_HASH__ROTATION: StrhashT = StrhashT {
11760 u64_: 11876823908831844119u64,
11761};
11762pub const TM_TT_TYPE_HASH__SCALE: StrhashT = StrhashT {
11763 u64_: 2373204840714521648u64,
11764};
11765pub const TM_TT_TYPE_HASH__COLOR_RGB: StrhashT = StrhashT {
11766 u64_: 15044398031543779569u64,
11767};
11768pub const TM_TT_TYPE_HASH__COLOR_RGBA: StrhashT = StrhashT {
11769 u64_: 1289506825880340452u64,
11770};
11771pub const TM_TT_TYPE_HASH__RECT: StrhashT = StrhashT {
11772 u64_: 12027361935592340977u64,
11773};
11774pub const TM_TT_TYPE_HASH__UUID: StrhashT = StrhashT {
11775 u64_: 7193459200112519797u64,
11776};
11777pub const TM_TT_TYPE_HASH__VISIBILITY_FLAG: StrhashT = StrhashT {
11778 u64_: 5713385340038884041u64,
11779};
11780pub const TM_WEB_SOCKET_PROTOCOL_API_VERSION: VersionT = VersionT {
11781 major: 1u32,
11782 minor: 0u32,
11783 patch: 0u32,
11784};
11785pub const TM_JOB_SYSTEM_API_VERSION: VersionT = VersionT {
11786 major: 1u32,
11787 minor: 0u32,
11788 patch: 0u32,
11789};
11790pub const TM_CORE_IMPORTER_API_VERSION: VersionT = VersionT {
11791 major: 1u32,
11792 minor: 0u32,
11793 patch: 0u32,
11794};
11795pub const TM_BUDDY_ALLOCATOR_RAW_API_VERSION: VersionT = VersionT {
11796 major: 1u32,
11797 minor: 0u32,
11798 patch: 0u32,
11799};
11800pub const TM_TEMP_ALLOCATOR_API_VERSION: VersionT = VersionT {
11801 major: 1u32,
11802 minor: 0u32,
11803 patch: 0u32,
11804};
11805pub const TM_CONFIG_API_VERSION: VersionT = VersionT {
11806 major: 1u32,
11807 minor: 0u32,
11808 patch: 0u32,
11809};
11810pub const TM_THE_TRUTH_CREATE_TYPES_I_VERSION: VersionT = VersionT {
11811 major: 1u32,
11812 minor: 0u32,
11813 patch: 0u32,
11814};
11815pub const TM_ERROR_API_VERSION: VersionT = VersionT {
11816 major: 1u32,
11817 minor: 0u32,
11818 patch: 0u32,
11819};
11820pub const TM_APPLICATION_API_VERSION: VersionT = VersionT {
11821 major: 1u32,
11822 minor: 1u32,
11823 patch: 0u32,
11824};
11825pub const TM_MATH_API_VERSION: VersionT = VersionT {
11826 major: 1u32,
11827 minor: 0u32,
11828 patch: 0u32,
11829};
11830pub const TM_PLUGIN_TICK_I_VERSION: VersionT = VersionT {
11831 major: 1u32,
11832 minor: 0u32,
11833 patch: 0u32,
11834};
11835pub const TM_BUDDY_ALLOCATOR_API_VERSION: VersionT = VersionT {
11836 major: 1u32,
11837 minor: 0u32,
11838 patch: 0u32,
11839};
11840pub const TM_VISIBILITY_FLAG_EDITOR_I_VERSION: VersionT = VersionT {
11841 major: 1u32,
11842 minor: 0u32,
11843 patch: 0u32,
11844};
11845pub const TM_GIT_IGNORE_API_VERSION: VersionT = VersionT {
11846 major: 1u32,
11847 minor: 0u32,
11848 patch: 0u32,
11849};
11850pub const TM_LOCALIZER_STRINGS_I_VERSION: VersionT = VersionT {
11851 major: 1u32,
11852 minor: 0u32,
11853 patch: 0u32,
11854};
11855pub const TM_LOGGER_API_VERSION: VersionT = VersionT {
11856 major: 1u32,
11857 minor: 0u32,
11858 patch: 0u32,
11859};
11860pub const TM_PATH_API_VERSION: VersionT = VersionT {
11861 major: 1u32,
11862 minor: 0u32,
11863 patch: 0u32,
11864};
11865pub const TM_OS_VIRTUAL_MEMORY_API_VERSION: VersionT = VersionT {
11866 major: 1u32,
11867 minor: 0u32,
11868 patch: 0u32,
11869};
11870pub const TM_CAMERA_API_VERSION: VersionT = VersionT {
11871 major: 1u32,
11872 minor: 0u32,
11873 patch: 0u32,
11874};
11875pub const TM_SPRINTF_API_VERSION: VersionT = VersionT {
11876 major: 1u32,
11877 minor: 0u32,
11878 patch: 0u32,
11879};
11880pub const TM_VISIBILITY_CONTEXT_O_VERSION: VersionT = VersionT {
11881 major: 1u32,
11882 minor: 0u32,
11883 patch: 0u32,
11884};
11885pub const TM_CORE_ASSET_I_VERSION: VersionT = VersionT {
11886 major: 1u32,
11887 minor: 0u32,
11888 patch: 0u32,
11889};
11890pub const TM_ASSET_DATABASE_API_VERSION: VersionT = VersionT {
11891 major: 1u32,
11892 minor: 0u32,
11893 patch: 0u32,
11894};
11895pub const TM_TASK_SYSTEM_API_VERSION: VersionT = VersionT {
11896 major: 1u32,
11897 minor: 0u32,
11898 patch: 0u32,
11899};
11900pub const TM_MEMORY_TRACKER_API_VERSION: VersionT = VersionT {
11901 major: 1u32,
11902 minor: 0u32,
11903 patch: 0u32,
11904};
11905pub const TM_THE_TRUTH_DESTROYED_I_VERSION: VersionT = VersionT {
11906 major: 1u32,
11907 minor: 0u32,
11908 patch: 0u32,
11909};
11910pub const TM_INTEGRATION_TEST_I_VERSION: VersionT = VersionT {
11911 major: 1u32,
11912 minor: 0u32,
11913 patch: 0u32,
11914};
11915pub const TM_THE_TRUTH_COMMON_TYPES_API_VERSION: VersionT = VersionT {
11916 major: 1u32,
11917 minor: 0u32,
11918 patch: 0u32,
11919};
11920pub const TM_STRING_API_VERSION: VersionT = VersionT {
11921 major: 1u32,
11922 minor: 0u32,
11923 patch: 0u32,
11924};
11925pub const TM_JSON_API_VERSION: VersionT = VersionT {
11926 major: 1u32,
11927 minor: 0u32,
11928 patch: 0u32,
11929};
11930pub const TM_CRASH_RECOVERY_API_VERSION: VersionT = VersionT {
11931 major: 2u32,
11932 minor: 0u32,
11933 patch: 0u32,
11934};
11935pub const TM_LZ4_API_VERSION: VersionT = VersionT {
11936 major: 1u32,
11937 minor: 0u32,
11938 patch: 0u32,
11939};
11940pub const TM_BASE_64_API_VERSION: VersionT = VersionT {
11941 major: 1u32,
11942 minor: 0u32,
11943 patch: 0u32,
11944};
11945pub const TM_IMAGE_LOADER_API_VERSION: VersionT = VersionT {
11946 major: 1u32,
11947 minor: 0u32,
11948 patch: 0u32,
11949};
11950pub const TM_OS_SOCKET_API_VERSION: VersionT = VersionT {
11951 major: 1u32,
11952 minor: 0u32,
11953 patch: 0u32,
11954};
11955pub const TM_STRING_REPOSITORY_API_VERSION: VersionT = VersionT {
11956 major: 1u32,
11957 minor: 0u32,
11958 patch: 0u32,
11959};
11960pub const TM_PLUGIN_SHUTDOWN_I_VERSION: VersionT = VersionT {
11961 major: 1u32,
11962 minor: 0u32,
11963 patch: 0u32,
11964};
11965pub const TM_THE_TRUTH_ASSETS_API_VERSION: VersionT = VersionT {
11966 major: 1u32,
11967 minor: 0u32,
11968 patch: 0u32,
11969};
11970pub const TM_RANDOM_API_VERSION: VersionT = VersionT {
11971 major: 1u32,
11972 minor: 0u32,
11973 patch: 0u32,
11974};
11975pub const TM_THE_TRUTH_MIGRATION_API_VERSION: VersionT = VersionT {
11976 major: 1u32,
11977 minor: 0u32,
11978 patch: 0u32,
11979};
11980pub const TM_UNIT_TEST_I_VERSION: VersionT = VersionT {
11981 major: 1u32,
11982 minor: 0u32,
11983 patch: 0u32,
11984};
11985pub const TM_ASSET_LABEL_T_VERSION: VersionT = VersionT {
11986 major: 1u32,
11987 minor: 0u32,
11988 patch: 0u32,
11989};
11990pub const TM_PROFILER_API_VERSION: VersionT = VersionT {
11991 major: 1u32,
11992 minor: 0u32,
11993 patch: 0u32,
11994};
11995pub const TM_LOCALIZER_API_VERSION: VersionT = VersionT {
11996 major: 1u32,
11997 minor: 0u32,
11998 patch: 0u32,
11999};
12000pub const TM_VISIBILITY_FLAGS_API_VERSION: VersionT = VersionT {
12001 major: 1u32,
12002 minor: 0u32,
12003 patch: 0u32,
12004};
12005pub const TM_PLUGIN_RELOAD_I_VERSION: VersionT = VersionT {
12006 major: 1u32,
12007 minor: 0u32,
12008 patch: 0u32,
12009};
12010pub const TM_BUFFER_FORMAT_API_VERSION: VersionT = VersionT {
12011 major: 1u32,
12012 minor: 0u32,
12013 patch: 0u32,
12014};
12015pub const TM_ALLOCATOR_API_VERSION: VersionT = VersionT {
12016 major: 1u32,
12017 minor: 0u32,
12018 patch: 0u32,
12019};
12020pub const TM_ASSET_IO_API_VERSION: VersionT = VersionT {
12021 major: 1u32,
12022 minor: 0u32,
12023 patch: 0u32,
12024};
12025pub const TM_PROGRESS_REPORT_API_VERSION: VersionT = VersionT {
12026 major: 1u32,
12027 minor: 0u32,
12028 patch: 0u32,
12029};
12030pub const TM_FEATURE_FLAGS_API_VERSION: VersionT = VersionT {
12031 major: 1u32,
12032 minor: 0u32,
12033 patch: 0u32,
12034};
12035pub const TM_BUFFERS_API_VERSION: VersionT = VersionT {
12036 major: 1u32,
12037 minor: 0u32,
12038 patch: 0u32,
12039};
12040pub const TM_OS_FILE_IO_API_VERSION: VersionT = VersionT {
12041 major: 1u32,
12042 minor: 0u32,
12043 patch: 0u32,
12044};
12045pub const TM_UNICODE_API_VERSION: VersionT = VersionT {
12046 major: 1u32,
12047 minor: 0u32,
12048 patch: 0u32,
12049};
12050pub const TM_PLUGIN_SET_THE_TRUTH_I_VERSION: VersionT = VersionT {
12051 major: 1u32,
12052 minor: 0u32,
12053 patch: 0u32,
12054};
12055pub const TM_API_REGISTRY_API_VERSION: VersionT = VersionT {
12056 major: 1u32,
12057 minor: 0u32,
12058 patch: 0u32,
12059};
12060pub const TM_PLUGINS_API_VERSION: VersionT = VersionT {
12061 major: 3u32,
12062 minor: 0u32,
12063 patch: 0u32,
12064};
12065pub const TM_COLLABORATION_P2P_API_VERSION: VersionT = VersionT {
12066 major: 1u32,
12067 minor: 0u32,
12068 patch: 0u32,
12069};
12070pub const TM_INPUT_API_VERSION: VersionT = VersionT {
12071 major: 1u32,
12072 minor: 0u32,
12073 patch: 0u32,
12074};
12075pub const TM_IMAGE_LOADER_I_VERSION: VersionT = VersionT {
12076 major: 1u32,
12077 minor: 0u32,
12078 patch: 0u32,
12079};
12080pub const TM_RUNTIME_DATA_REPOSITORY_API_VERSION: VersionT = VersionT {
12081 major: 1u32,
12082 minor: 0u32,
12083 patch: 0u32,
12084};
12085pub const TM_WEB_TALKER_API_VERSION: VersionT = VersionT {
12086 major: 1u32,
12087 minor: 0u32,
12088 patch: 0u32,
12089};
12090pub const TM_THE_TRUTH_API_VERSION: VersionT = VersionT {
12091 major: 1u32,
12092 minor: 0u32,
12093 patch: 0u32,
12094};
12095pub const TM_PLUGIN_ASSETS_API_VERSION: VersionT = VersionT {
12096 major: 1u32,
12097 minor: 0u32,
12098 patch: 0u32,
12099};
12100pub const TM_CORE_API_VERSION: VersionT = VersionT {
12101 major: 2u32,
12102 minor: 0u32,
12103 patch: 0u32,
12104};
12105pub const TM_OS_API_VERSION: VersionT = VersionT {
12106 major: 1u32,
12107 minor: 0u32,
12108 patch: 0u32,
12109};
12110pub const TM_PLUGIN_INIT_I_VERSION: VersionT = VersionT {
12111 major: 1u32,
12112 minor: 0u32,
12113 patch: 0u32,
12114};
12115pub const TM_THE_TRUTH_MIGRATION_I_VERSION: VersionT = VersionT {
12116 major: 1u32,
12117 minor: 0u32,
12118 patch: 0u32,
12119};
12120pub const TM_OS_FILE_SYSTEM_API_VERSION: VersionT = VersionT {
12121 major: 1u32,
12122 minor: 0u32,
12123 patch: 0u32,
12124};
12125pub const TM_COLLABORATION_API_VERSION: VersionT = VersionT {
12126 major: 1u32,
12127 minor: 0u32,
12128 patch: 0u32,
12129};