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 __SAL_H_VERSION: u32 = 180000000;
82pub const __bool_true_false_are_defined: u32 = 1;
83pub const TM_RENDERER_MEMORY_STATISTICS_MAX_ALLOCATOR_BLOCKS: u32 = 256;
84pub const TM_RENDERER_DEVICE_AFFINITY_MASK_ALL: u32 = 255;
85extern "C" {
86 pub fn __va_start(arg1: *mut *mut ::std::os::raw::c_char, ...);
87}
88pub type __vcrt_bool = bool;
89extern "C" {
90 pub fn __security_init_cookie();
91}
92extern "C" {
93 pub fn __security_check_cookie(_StackCookie: usize);
94}
95extern "C" {
96 pub fn __report_gsfailure(_StackCookie: usize);
97}
98extern "C" {
99 pub static mut __security_cookie: usize;
100}
101#[repr(C)]
102#[derive(Copy, Clone)]
103pub union TtIdTBindgenTy1 {
104 pub u64_: u64,
105 pub __bindgen_anon_1: TtIdTBindgenTy1BindgenTy1,
106}
107#[repr(C)]
108#[repr(align(8))]
109#[derive(Default, Copy, Clone)]
110pub struct TtIdTBindgenTy1BindgenTy1 {
111 pub _bitfield_align_1: [u32; 0],
112 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 8usize]>,
113}
114impl TtIdTBindgenTy1BindgenTy1 {
115 #[inline]
116 pub fn type_(&self) -> u64 {
117 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 10u8) as u64) }
118 }
119 #[inline]
120 pub fn set_type(&mut self, val: u64) {
121 unsafe {
122 let val: u64 = ::std::mem::transmute(val);
123 self._bitfield_1.set(0usize, 10u8, val as u64)
124 }
125 }
126 #[inline]
127 pub fn generation(&self) -> u64 {
128 unsafe { ::std::mem::transmute(self._bitfield_1.get(10usize, 22u8) as u64) }
129 }
130 #[inline]
131 pub fn set_generation(&mut self, val: u64) {
132 unsafe {
133 let val: u64 = ::std::mem::transmute(val);
134 self._bitfield_1.set(10usize, 22u8, val as u64)
135 }
136 }
137 #[inline]
138 pub fn index(&self) -> u64 {
139 unsafe { ::std::mem::transmute(self._bitfield_1.get(32usize, 32u8) as u64) }
140 }
141 #[inline]
142 pub fn set_index(&mut self, val: u64) {
143 unsafe {
144 let val: u64 = ::std::mem::transmute(val);
145 self._bitfield_1.set(32usize, 32u8, val as u64)
146 }
147 }
148 #[inline]
149 pub fn new_bitfield_1(
150 type_: u64,
151 generation: u64,
152 index: u64,
153 ) -> __BindgenBitfieldUnit<[u8; 8usize]> {
154 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 8usize]> = Default::default();
155 __bindgen_bitfield_unit.set(0usize, 10u8, {
156 let type_: u64 = unsafe { ::std::mem::transmute(type_) };
157 type_ as u64
158 });
159 __bindgen_bitfield_unit.set(10usize, 22u8, {
160 let generation: u64 = unsafe { ::std::mem::transmute(generation) };
161 generation as u64
162 });
163 __bindgen_bitfield_unit.set(32usize, 32u8, {
164 let index: u64 = unsafe { ::std::mem::transmute(index) };
165 index as u64
166 });
167 __bindgen_bitfield_unit
168 }
169}
170impl Default for TtIdTBindgenTy1 {
171 fn default() -> Self {
172 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
173 unsafe {
174 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
175 s.assume_init()
176 }
177 }
178}
179#[repr(C)]
180#[derive(Default, Copy, Clone)]
181pub struct RendererHandleT {
182 pub resource: u32,
183 pub bindless_srv: u32,
184 pub bindless_uav: u32,
185}
186pub const TM_RENDERER_SHADER_STAGE_VERTEX: RendererShaderStage = 0;
187pub const TM_RENDERER_SHADER_STAGE_HULL: RendererShaderStage = 1;
188pub const TM_RENDERER_SHADER_STAGE_DOMAIN: RendererShaderStage = 2;
189pub const TM_RENDERER_SHADER_STAGE_GEOMETRY: RendererShaderStage = 3;
190pub const TM_RENDERER_SHADER_STAGE_PIXEL: RendererShaderStage = 4;
191pub const TM_RENDERER_SHADER_STAGE_COMPUTE: RendererShaderStage = 5;
192pub const TM_RENDERER_SHADER_STAGE_RAYGEN: RendererShaderStage = 6;
193pub const TM_RENDERER_SHADER_STAGE_ANY_HIT: RendererShaderStage = 7;
194pub const TM_RENDERER_SHADER_STAGE_CLOSEST_HIT: RendererShaderStage = 8;
195pub const TM_RENDERER_SHADER_STAGE_MISS: RendererShaderStage = 9;
196pub const TM_RENDERER_SHADER_STAGE_INTERSECTION: RendererShaderStage = 10;
197pub const TM_RENDERER_SHADER_STAGE_MAX: RendererShaderStage = 11;
198pub type RendererShaderStage = ::std::os::raw::c_int;
199pub const TM_RENDERER_STATE_BLOCK_TYPE_TESSELLATION: RendererStateBlockType = 0;
200pub const TM_RENDERER_STATE_BLOCK_TYPE_RASTER: RendererStateBlockType = 1;
201pub const TM_RENDERER_STATE_BLOCK_TYPE_DEPTH_STENCIL: RendererStateBlockType = 2;
202pub const TM_RENDERER_STATE_BLOCK_TYPE_TEXTURE_SAMPLER: RendererStateBlockType = 3;
203pub const TM_RENDERER_STATE_BLOCK_TYPE_RENDER_TARGET_BLEND: RendererStateBlockType = 4;
204pub const TM_RENDERER_STATE_BLOCK_TYPE_BLEND: RendererStateBlockType = 5;
205pub const TM_RENDERER_STATE_BLOCK_TYPE_MULTI_SAMPLE: RendererStateBlockType = 6;
206pub const TM_RENDERER_STATE_BLOCK_TYPE_MAX_STATE_BLOCK_TYPES: RendererStateBlockType = 7;
207pub type RendererStateBlockType = ::std::os::raw::c_int;
208pub const TM_RENDERER_STATE_VALUE_TYPE_BOOL: RendererStateValueType = 0;
209pub const TM_RENDERER_STATE_VALUE_TYPE_UINT32: RendererStateValueType = 1;
210pub const TM_RENDERER_STATE_VALUE_TYPE_FLOAT32: RendererStateValueType = 2;
211pub const TM_RENDERER_STATE_VALUE_TYPE_COMPARE_OP: RendererStateValueType = 3;
212pub const TM_RENDERER_STATE_VALUE_TYPE_CULL: RendererStateValueType = 4;
213pub const TM_RENDERER_STATE_VALUE_TYPE_FRONT_FACE: RendererStateValueType = 5;
214pub const TM_RENDERER_STATE_VALUE_TYPE_POLYGON_MODE: RendererStateValueType = 6;
215pub const TM_RENDERER_STATE_VALUE_TYPE_STENCIL_OP: RendererStateValueType = 7;
216pub const TM_RENDERER_STATE_VALUE_TYPE_FILTER: RendererStateValueType = 8;
217pub const TM_RENDERER_STATE_VALUE_TYPE_MIP_MODE: RendererStateValueType = 9;
218pub const TM_RENDERER_STATE_VALUE_TYPE_ADDRESS_MODE: RendererStateValueType = 10;
219pub const TM_RENDERER_STATE_VALUE_TYPE_BORDER_COLOR: RendererStateValueType = 11;
220pub const TM_RENDERER_STATE_VALUE_TYPE_BLEND_FACTOR: RendererStateValueType = 12;
221pub const TM_RENDERER_STATE_VALUE_TYPE_BLEND_OPERATION: RendererStateValueType = 13;
222pub const TM_RENDERER_STATE_VALUE_TYPE_BLEND_WRITE_MASK: RendererStateValueType = 14;
223pub const TM_RENDERER_STATE_VALUE_TYPE_LOGICAL_OPERATION: RendererStateValueType = 15;
224pub const TM_RENDERER_STATE_VALUE_TYPE_STATE_BLOCK: RendererStateValueType = -16777216;
225pub const TM_RENDERER_STATE_VALUE_TYPE_MAX_VALUE_TYPES: RendererStateValueType = -16777215;
226pub type RendererStateValueType = ::std::os::raw::c_int;
227#[repr(C)]
228#[derive(Copy, Clone)]
229pub struct RendererShaderBlobT {
230 pub size: u64,
231 pub data: *mut u8,
232}
233impl Default for RendererShaderBlobT {
234 fn default() -> Self {
235 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
236 unsafe {
237 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
238 s.assume_init()
239 }
240 }
241}
242#[repr(C)]
243#[derive(Default, Copy, Clone)]
244pub struct RendererImageSubresourceLayersT {
245 pub first_layer: u16,
246 pub layer_count: u16,
247 pub first_mip: u16,
248 pub mip_levels: u16,
249}
250#[repr(C)]
251#[derive(Default, Copy, Clone)]
252pub struct RendererImageOffsetT {
253 pub x: u16,
254 pub y: u16,
255 pub z: u16,
256}
257#[repr(C)]
258#[derive(Default, Copy, Clone)]
259pub struct RendererImageExtentT {
260 pub width: u16,
261 pub height: u16,
262 pub depth: u16,
263}
264pub const TM_RENDERER_QUEUE_GRAPHICS: RendererQueue = 0;
265pub const TM_RENDERER_QUEUE_COMPUTE: RendererQueue = 1;
266pub const TM_RENDERER_QUEUE_TRANSFER: RendererQueue = 2;
267pub type RendererQueue = ::std::os::raw::c_int;
268pub const TM_RENDERER_RESOURCE_LOAD_OP_LOAD: RendererResourceLoadOp = 0;
269pub const TM_RENDERER_RESOURCE_LOAD_OP_CLEAR: RendererResourceLoadOp = 1;
270pub const TM_RENDERER_RESOURCE_LOAD_OP_DISCARD: RendererResourceLoadOp = 2;
271pub type RendererResourceLoadOp = ::std::os::raw::c_int;
272pub const TM_RENDERER_RESOURCE_STORE_OP_STORE: RendererResourceStoreOp = 0;
273pub const TM_RENDERER_RESOURCE_STORE_OP_DISCARD: RendererResourceStoreOp = 1;
274pub type RendererResourceStoreOp = ::std::os::raw::c_int;
275pub const TM_RENDERER_RESOURCE_STATE_VERTEX_INPUT: RendererResourceState = 1;
276pub const TM_RENDERER_RESOURCE_STATE_RENDER_TARGET: RendererResourceState = 2;
277pub const TM_RENDERER_RESOURCE_STATE_UAV: RendererResourceState = 4;
278pub const TM_RENDERER_RESOURCE_STATE_RESOURCE: RendererResourceState = 8;
279pub const TM_RENDERER_RESOURCE_STATE_VERTEX_SHADER: RendererResourceState = 16;
280pub const TM_RENDERER_RESOURCE_STATE_HULL_SHADER: RendererResourceState = 32;
281pub const TM_RENDERER_RESOURCE_STATE_DOMAIN_SHADER: RendererResourceState = 64;
282pub const TM_RENDERER_RESOURCE_STATE_GEOMETRY_SHADER: RendererResourceState = 128;
283pub const TM_RENDERER_RESOURCE_STATE_PIXEL_SHADER: RendererResourceState = 256;
284pub const TM_RENDERER_RESOURCE_STATE_COMPUTE_SHADER: RendererResourceState = 512;
285pub const TM_RENDERER_RESOURCE_STATE_RAY_TRACING_SHADER: RendererResourceState = 1024;
286pub const TM_RENDERER_RESOURCE_STATE_COPY_SOURCE: RendererResourceState = 2048;
287pub const TM_RENDERER_RESOURCE_STATE_COPY_DESTINATION: RendererResourceState = 4096;
288pub const TM_RENDERER_RESOURCE_STATE_INDIRECT_ARGUMENT: RendererResourceState = 8192;
289pub const TM_RENDERER_RESOURCE_STATE_PRESENT: RendererResourceState = 16384;
290pub type RendererResourceState = ::std::os::raw::c_int;
291#[repr(C)]
292#[derive(Copy, Clone)]
293pub struct RendererCommandBuffer {
294 _unused: [u8; 0],
295}
296#[repr(C)]
297#[derive(Default, Copy, Clone)]
298pub struct RendererRenderPassBindRenderTargetT {
299 pub resource: RendererHandleT,
300 pub aspect: u32,
301 pub initial_state: u16,
302 pub final_state: u16,
303 pub load_op: u8,
304 pub store_op: u8,
305 pub stencil_load_op: u8,
306 pub stencil_store_op: u8,
307}
308pub const TM_RENDERER_MAX_RENDER_TARGETS: ::std::os::raw::c_int = 8;
309pub type _bindgen_ty_1 = ::std::os::raw::c_int;
310pub const TM_RENDERER_MAX_QUEUE_FENCES: ::std::os::raw::c_int = 4;
311pub type _bindgen_ty_2 = ::std::os::raw::c_int;
312#[repr(C)]
313#[derive(Default, Copy, Clone)]
314pub struct RendererSchedulingT {
315 pub wait_queue_fences: [RendererHandleT; 4usize],
316 pub wait_device_affinity_masks: [u32; 4usize],
317 pub num_wait_fences: u32,
318 pub _padding_126: [::std::os::raw::c_char; 4usize],
319 pub signal_queue_fence: RendererHandleT,
320 pub signal_device_affinity_mask: u32,
321 pub _padding_133: [::std::os::raw::c_char; 4usize],
322}
323#[repr(C)]
324#[derive(Default, Copy, Clone)]
325pub struct RendererRenderPassBindT {
326 pub device_affinity_mask: u32,
327 pub _padding_141: [::std::os::raw::c_char; 4usize],
328 pub render_targets: [RendererRenderPassBindRenderTargetT; 8usize],
329 pub depth_stencil_target: RendererRenderPassBindRenderTargetT,
330 pub scheduling: RendererSchedulingT,
331}
332#[repr(C)]
333#[derive(Default, Copy, Clone)]
334pub struct RendererQueueBindT {
335 pub device_affinity_mask: u32,
336 pub queue_family: u8,
337 pub queue_index: u8,
338 pub _padding_159: [::std::os::raw::c_char; 2usize],
339 pub scheduling: RendererSchedulingT,
340}
341pub const TM_RENDERER_MAX_VIEWPORTS_SCISSOR_RECTS: ::std::os::raw::c_int = 8;
342pub type _bindgen_ty_3 = ::std::os::raw::c_int;
343#[repr(C)]
344#[derive(Default, Copy, Clone)]
345pub struct RendererSetViewportsT {
346 pub viewports: [RendererSetViewportsTBindgenTy1; 8usize],
347 pub num_viewports: u32,
348}
349#[repr(C)]
350#[derive(Default, Copy, Clone)]
351pub struct RendererSetViewportsTBindgenTy1 {
352 pub x: f32,
353 pub y: f32,
354 pub width: f32,
355 pub height: f32,
356 pub min_depth: f32,
357 pub max_depth: f32,
358}
359#[repr(C)]
360#[derive(Default, Copy, Clone)]
361pub struct RendererSetScissorRectsT {
362 pub rects: [RendererSetScissorRectsTBindgenTy1; 8usize],
363 pub num_rects: u32,
364}
365#[repr(C)]
366#[derive(Default, Copy, Clone)]
367pub struct RendererSetScissorRectsTBindgenTy1 {
368 pub x: i32,
369 pub y: i32,
370 pub width: u32,
371 pub height: u32,
372}
373#[repr(C)]
374#[derive(Copy, Clone)]
375pub struct RendererBeginStatisticsT {
376 pub category: *const ::std::os::raw::c_char,
377 pub name: *const ::std::os::raw::c_char,
378 pub flags: u32,
379 pub _padding_202: [::std::os::raw::c_char; 4usize],
380 pub uid: u64,
381 pub backend_data: [u32; 8usize],
382}
383impl Default for RendererBeginStatisticsT {
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 RendererEndStatisticsT {
395 pub uid: u64,
396 pub backend_data: [u32; 8usize],
397}
398pub const TM_RENDERER_DISPATCH_TYPE_NORMAL: RendererDispatchType = 0;
399pub const TM_RENDERER_DISPATCH_TYPE_INDIRECT: RendererDispatchType = 1;
400pub type RendererDispatchType = ::std::os::raw::c_int;
401#[repr(C)]
402#[derive(Default, Copy, Clone)]
403pub struct RendererDispatchCommandT {
404 pub group_count: [u32; 3usize],
405}
406#[repr(C)]
407#[derive(Default, Copy, Clone)]
408pub struct RendererDispatchIndirectCommandT {
409 pub indirect_buffer: RendererHandleT,
410 pub _padding_231: [::std::os::raw::c_char; 4usize],
411 pub offset: u64,
412}
413#[repr(C)]
414#[derive(Copy, Clone)]
415pub struct RendererComputeInfoT {
416 pub dispatch_type: u8,
417 pub _padding_240: [::std::os::raw::c_char; 7usize],
418 pub __bindgen_anon_1: RendererComputeInfoTBindgenTy1,
419}
420#[repr(C)]
421#[derive(Copy, Clone)]
422pub union RendererComputeInfoTBindgenTy1 {
423 pub dispatch: RendererDispatchCommandT,
424 pub indirect: RendererDispatchIndirectCommandT,
425}
426impl Default for RendererComputeInfoTBindgenTy1 {
427 fn default() -> Self {
428 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
429 unsafe {
430 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
431 s.assume_init()
432 }
433 }
434}
435impl Default for RendererComputeInfoT {
436 fn default() -> Self {
437 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
438 unsafe {
439 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
440 s.assume_init()
441 }
442 }
443}
444pub const TM_RENDERER_PRIMITIVE_TYPE_TRIANGLE_LIST: RendererPrimitiveType = 0;
445pub const TM_RENDERER_PRIMITIVE_TYPE_LINE_LIST: RendererPrimitiveType = 1;
446pub const TM_RENDERER_PRIMITIVE_TYPE_POINT_LIST: RendererPrimitiveType = 2;
447pub const TM_RENDERER_PRIMITIVE_TYPE_MAX_TYPES: RendererPrimitiveType = 3;
448pub type RendererPrimitiveType = ::std::os::raw::c_int;
449pub const TM_RENDERER_DRAW_TYPE_NON_INDEXED: RendererDrawType = 0;
450pub const TM_RENDERER_DRAW_TYPE_INDEXED: RendererDrawType = 1;
451pub const TM_RENDERER_DRAW_TYPE_NON_INDEXED_INDIRECT: RendererDrawType = 2;
452pub const TM_RENDERER_DRAW_TYPE_INDEXED_INDIRECT: RendererDrawType = 3;
453pub type RendererDrawType = ::std::os::raw::c_int;
454pub const TM_RENDERER_INDEX_TYPE_UINT16: RendererIndexType = 0;
455pub const TM_RENDERER_INDEX_TYPE_UINT32: RendererIndexType = 1;
456pub type RendererIndexType = ::std::os::raw::c_int;
457#[repr(C)]
458#[derive(Default, Copy, Clone)]
459pub struct RendererDrawCommandT {
460 pub num_vertices: u32,
461 pub num_instances: u32,
462 pub first_vertex: u32,
463 pub first_instance: u32,
464}
465#[repr(C)]
466#[derive(Default, Copy, Clone)]
467pub struct RendererDrawIndexedCommandT {
468 pub num_indices: u32,
469 pub num_instances: u32,
470 pub first_index: u32,
471 pub vertex_offset: i32,
472 pub first_instance: u32,
473}
474#[repr(C)]
475#[derive(Default, Copy, Clone)]
476pub struct RendererDrawIndirectCommandT {
477 pub indirect_buffer: RendererHandleT,
478 pub _padding_314: [::std::os::raw::c_char; 4usize],
479 pub offset: u64,
480 pub stride: u32,
481 pub num_draws: u32,
482}
483#[repr(C)]
484#[derive(Copy, Clone)]
485pub struct RendererDrawCallInfoT {
486 pub __bindgen_anon_1: RendererDrawCallInfoTBindgenTy1,
487 pub index_buffer: RendererHandleT,
488 pub primitive_type: u8,
489 pub draw_type: u8,
490 pub index_type: u8,
491 pub _padding_345: [::std::os::raw::c_char; 1usize],
492}
493#[repr(C)]
494#[derive(Copy, Clone)]
495pub union RendererDrawCallInfoTBindgenTy1 {
496 pub non_indexed: RendererDrawCommandT,
497 pub indexed: RendererDrawIndexedCommandT,
498 pub indirect: RendererDrawIndirectCommandT,
499}
500impl Default for RendererDrawCallInfoTBindgenTy1 {
501 fn default() -> Self {
502 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
503 unsafe {
504 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
505 s.assume_init()
506 }
507 }
508}
509impl Default for RendererDrawCallInfoT {
510 fn default() -> Self {
511 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
512 unsafe {
513 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
514 s.assume_init()
515 }
516 }
517}
518pub const TM_RENDERER_MAX_RESOURCE_BINDERS: ::std::os::raw::c_int = 8;
519pub const TM_RENDERER_MAX_PUSH_CONSTANTS: ::std::os::raw::c_int = 16;
520pub const TM_RENDERER_MAX_SHADER_STATE_OVERRIDE_BLOCKS: ::std::os::raw::c_int = 4;
521pub type _bindgen_ty_4 = ::std::os::raw::c_int;
522#[repr(C)]
523#[derive(Default, Copy, Clone)]
524pub struct RendererShaderStateOverrideBlocksT {
525 pub num_override_blocks: u8,
526 pub _padding_361: [::std::os::raw::c_char; 7usize],
527 pub shader_state_override_blocks: [RendererHandleT; 4usize],
528}
529#[repr(C)]
530#[derive(Default, Copy, Clone)]
531pub struct RendererShaderResourceBindersT {
532 pub num_resource_binders: u8,
533 pub _padding_370: [::std::os::raw::c_char; 7usize],
534 pub resource_binders: [RendererHandleT; 8usize],
535}
536#[repr(C)]
537#[derive(Default, Copy, Clone)]
538pub struct RendererShaderPushConstantsT {
539 pub num_constants: u8,
540 pub _padding_379: [::std::os::raw::c_char; 3usize],
541 pub data: [u32; 16usize],
542}
543#[repr(C)]
544#[derive(Default, Copy, Clone)]
545pub struct RendererShaderInfoT {
546 pub shader: RendererHandleT,
547 pub state_override_blocks: RendererShaderStateOverrideBlocksT,
548 pub binders: RendererShaderResourceBindersT,
549 pub constants: RendererShaderPushConstantsT,
550 pub sort_key: u64,
551}
552#[repr(C)]
553#[derive(Default, Copy, Clone)]
554pub struct RendererShaderHeaderT {
555 pub shader: RendererHandleT,
556 pub num_state_override_blocks: u16,
557 pub num_resource_binders: u16,
558 pub num_bytes_push_constants: u16,
559 pub _padding_406: [::std::os::raw::c_char; 2usize],
560}
561pub const TM_RENDERER_IMAGE_ASPECT_DEFAULT: RendererImageAspect = 0;
562pub const TM_RENDERER_IMAGE_ASPECT_SRGB: RendererImageAspect = 1;
563pub const TM_RENDERER_IMAGE_ASPECT_DEPTH: RendererImageAspect = 2;
564pub const TM_RENDERER_IMAGE_ASPECT_STENCIL: RendererImageAspect = 3;
565pub const TM_RENDERER_IMAGE_ASPECT_ADDITONAL_VIEW: RendererImageAspect = 134217728;
566pub type RendererImageAspect = ::std::os::raw::c_int;
567#[repr(C)]
568#[derive(Default, Copy, Clone)]
569pub struct RendererSetResourceT {
570 pub bind_point: u32,
571 pub _padding_434: [::std::os::raw::c_char; 4usize],
572 pub resource_handle: RendererHandleT,
573 pub resource_aspect_flag: u32,
574 pub _padding_439: [::std::os::raw::c_char; 4usize],
575}
576#[repr(C)]
577#[derive(Default, Copy, Clone)]
578pub struct RendererHandleAspectPairT {
579 pub handle: RendererHandleT,
580 pub aspect: u32,
581}
582#[repr(C)]
583#[derive(Default, Copy, Clone)]
584pub struct RendererSetArrayResourcesT {
585 pub bind_point: u32,
586 pub first_element: u32,
587 pub n_handles: u32,
588}
589#[repr(C)]
590#[derive(Default, Copy, Clone)]
591pub struct RendererUpdateBufferCommandT {
592 pub offset: u64,
593 pub size: u64,
594 pub device_affinity_mask: u32,
595 pub _padding_468: [::std::os::raw::c_char; 4usize],
596}
597#[repr(C)]
598#[derive(Default, Copy, Clone)]
599pub struct RendererFillBufferCommandT {
600 pub offset: u64,
601 pub size: u64,
602 pub data: u32,
603 pub device_affinity_mask: u32,
604}
605#[repr(C)]
606#[derive(Default, Copy, Clone)]
607pub struct RendererUpdateImageCommandT {
608 pub resource_state: u16,
609 pub subresource: RendererImageSubresourceLayersT,
610 pub offset: RendererImageOffsetT,
611 pub extent: RendererImageExtentT,
612 pub _padding_490: [::std::os::raw::c_char; 2usize],
613 pub size: u64,
614 pub device_affinity_mask: u32,
615 pub _padding_495: [::std::os::raw::c_char; 4usize],
616}
617#[repr(C)]
618#[derive(Default, Copy, Clone)]
619pub struct RendererResourceBarrierHeaderT {
620 pub num_barriers: u32,
621}
622pub const TM_RENDERER_RESOURCE_BARRIER_FLAG_IMAGE_ASPECT_STENCIL: RendererResourceBarrierFlag = 1;
623pub const TM_RENDERER_RESOURCE_BARRIER_FLAG_SUBRESOURCE: RendererResourceBarrierFlag = 2;
624pub type RendererResourceBarrierFlag = ::std::os::raw::c_int;
625#[repr(C)]
626#[derive(Copy, Clone)]
627pub struct RendererResourceBarrierT {
628 pub resource_handle: RendererHandleT,
629 pub source_state: u16,
630 pub destination_state: u16,
631 pub source_queue: u16,
632 pub destination_queue: u16,
633 pub barrier_flags: u16,
634 pub _padding_527: [::std::os::raw::c_char; 2usize],
635 pub __bindgen_anon_1: RendererResourceBarrierTBindgenTy1,
636}
637#[repr(C)]
638#[derive(Copy, Clone)]
639pub union RendererResourceBarrierTBindgenTy1 {
640 pub subresource_image: RendererResourceBarrierTBindgenTy1BindgenTy1,
641 pub subresource_buffer: RendererResourceBarrierTBindgenTy1BindgenTy2,
642}
643#[repr(C)]
644#[derive(Default, Copy, Clone)]
645pub struct RendererResourceBarrierTBindgenTy1BindgenTy1 {
646 pub first_layer: u16,
647 pub layer_count: u16,
648 pub first_mip_level: u16,
649 pub mip_count: u16,
650}
651#[repr(C)]
652#[derive(Default, Copy, Clone)]
653pub struct RendererResourceBarrierTBindgenTy1BindgenTy2 {
654 pub offset: u64,
655 pub size: u64,
656}
657impl Default for RendererResourceBarrierTBindgenTy1 {
658 fn default() -> Self {
659 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
660 unsafe {
661 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
662 s.assume_init()
663 }
664 }
665}
666impl Default for RendererResourceBarrierT {
667 fn default() -> Self {
668 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
669 unsafe {
670 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
671 s.assume_init()
672 }
673 }
674}
675pub const TM_RENDERER_COPY_IMAGE_FLAG_IMAGE_ASPECT_STENCIL: RendererCopyImageFlags = 1;
676pub const TM_RENDERER_COPY_IMAGE_FLAG_SUBRESOURCE: RendererCopyImageFlags = 2;
677pub type RendererCopyImageFlags = ::std::os::raw::c_int;
678#[repr(C)]
679#[derive(Default, Copy, Clone)]
680pub struct RendererCopyImageT {
681 pub source_resource: RendererHandleT,
682 pub destination_resource: RendererHandleT,
683 pub copy_flags: u16,
684 pub src_subresource_layers: RendererImageSubresourceLayersT,
685 pub src_offset: RendererImageOffsetT,
686 pub dst_subresource_layers: RendererImageSubresourceLayersT,
687 pub dst_offset: RendererImageOffsetT,
688 pub extent: RendererImageExtentT,
689}
690#[repr(C)]
691#[derive(Default, Copy, Clone)]
692pub struct RendererCopyBufferT {
693 pub source_resource: RendererHandleT,
694 pub destination_resource: RendererHandleT,
695 pub source_offset: u64,
696 pub destination_offset: u64,
697 pub size: u64,
698}
699pub const TM_RENDERER_READ_IMAGE_FLAG_IMAGE_ASPECT_STENCIL: RendererReadImageFlags = 1;
700pub const TM_RENDERER_READ_IMAGE_FLAG_SUBRESOURCE: RendererReadImageFlags = 2;
701pub type RendererReadImageFlags = ::std::os::raw::c_int;
702#[repr(C)]
703#[derive(Copy, Clone)]
704pub struct RendererReadImageT {
705 pub device_affinity_mask: u32,
706 pub _padding_606: [::std::os::raw::c_char; 4usize],
707 pub resource_handle: RendererHandleT,
708 pub resource_state: u16,
709 pub resource_queue: u16,
710 pub read_flags: u16,
711 pub subresource_layers: RendererImageSubresourceLayersT,
712 pub offset: RendererImageOffsetT,
713 pub extent: RendererImageExtentT,
714 pub _padding_619: [::std::os::raw::c_char; 2usize],
715 pub bits: *mut ::std::os::raw::c_void,
716 pub size_bits: u64,
717}
718impl Default for RendererReadImageT {
719 fn default() -> Self {
720 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
721 unsafe {
722 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
723 s.assume_init()
724 }
725 }
726}
727#[repr(C)]
728#[derive(Copy, Clone)]
729pub struct RendererReadBufferT {
730 pub device_affinity_mask: u32,
731 pub _padding_631: [::std::os::raw::c_char; 4usize],
732 pub resource_handle: RendererHandleT,
733 pub resource_state: u16,
734 pub resource_queue: u16,
735 pub offset: u64,
736 pub size: u64,
737 pub bits: *mut ::std::os::raw::c_void,
738}
739impl Default for RendererReadBufferT {
740 fn default() -> Self {
741 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
742 unsafe {
743 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
744 s.assume_init()
745 }
746 }
747}
748#[repr(C)]
749#[derive(Default, Copy, Clone)]
750pub struct RendererResizeBufferT {
751 pub bindless_srv: u32,
752 pub bindless_uav: u32,
753 pub size: u64,
754}
755#[repr(C)]
756#[derive(Default, Copy, Clone)]
757pub struct RendererTraceCallT {
758 pub pipeline: RendererHandleT,
759 pub raygen_sbt: RendererHandleT,
760 pub miss_sbt: RendererHandleT,
761 pub hit_sbt: RendererHandleT,
762 pub group_count: [u32; 3usize],
763 pub raygen_index: u32,
764 pub binders: RendererShaderResourceBindersT,
765}
766#[repr(C)]
767#[derive(Copy, Clone)]
768pub struct DeviceMemoryViewO {
769 _unused: [u8; 0],
770}
771#[repr(C)]
772#[derive(Default, Copy, Clone)]
773pub struct DeviceMemoryViewApi {
774 pub create: ::std::option::Option<
775 unsafe extern "C" fn(allocator: *mut AllocatorI) -> *mut DeviceMemoryViewO,
776 >,
777 pub destroy: ::std::option::Option<unsafe extern "C" fn(view: *mut DeviceMemoryViewO)>,
778 pub ui: ::std::option::Option<
779 unsafe extern "C" fn(
780 view: *mut DeviceMemoryViewO,
781 ui: *mut UiO,
782 uistyle: *const UiStyleT,
783 content_r: RectT,
784 tab_id: u64,
785 ),
786 >,
787}
788#[repr(C)]
789#[derive(Default, Copy, Clone)]
790pub struct NilRendererBackendApi {
791 pub create: ::std::option::Option<
792 unsafe extern "C" fn(allocator: *mut AllocatorI) -> *mut RendererBackendI,
793 >,
794 pub destroy: ::std::option::Option<unsafe extern "C" fn(backend: *mut RendererBackendI)>,
795}
796#[repr(C)]
797#[derive(Copy, Clone)]
798pub struct RendererApi {
799 pub tm_renderer_memory_block_pool_o: *mut RendererMemoryBlockPoolO,
800 pub tm_renderer_command_buffer_pool_o: *mut RendererCommandBufferPoolO,
801 pub tm_renderer_resource_command_buffer_pool_o: *mut RendererResourceCommandBufferPoolO,
802 pub tm_renderer_command_buffer_pool_api: *mut RendererCommandBufferPoolApi,
803 pub tm_renderer_command_buffer_api: *mut RendererCommandBufferApi,
804 pub tm_renderer_command_buffer_sort_api: *mut RendererCommandBufferSortApi,
805 pub tm_renderer_resource_command_buffer_pool_api: *mut RendererResourceCommandBufferPoolApi,
806 pub tm_renderer_resource_command_buffer_api: *mut RendererResourceCommandBufferApi,
807}
808impl Default for RendererApi {
809 fn default() -> Self {
810 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
811 unsafe {
812 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
813 s.assume_init()
814 }
815 }
816}
817#[repr(C)]
818#[derive(Default, Copy, Clone)]
819pub struct RendererInitApi {
820 pub init: ::std::option::Option<
821 unsafe extern "C" fn(allocator: *mut AllocatorI, user_data_size: u64) -> *mut RendererApi,
822 >,
823 pub shutdown: ::std::option::Option<unsafe extern "C" fn()>,
824}
825#[repr(C)]
826#[derive(Copy, Clone)]
827pub struct WindowPlatformDataO {
828 _unused: [u8; 0],
829}
830#[repr(C)]
831#[derive(Copy, Clone)]
832pub struct RendererCommandBufferO {
833 _unused: [u8; 0],
834}
835#[repr(C)]
836#[derive(Copy, Clone)]
837pub struct RendererResourceCommandBufferO {
838 _unused: [u8; 0],
839}
840#[repr(C)]
841#[derive(Copy, Clone)]
842pub struct RendererMemoryStatisticsAllocationT {
843 pub tag: *const ::std::os::raw::c_char,
844 pub offset: u64,
845 pub requested_size: u64,
846 pub aligned_size: u64,
847 pub allocated_size: u64,
848}
849impl Default for RendererMemoryStatisticsAllocationT {
850 fn default() -> Self {
851 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
852 unsafe {
853 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
854 s.assume_init()
855 }
856 }
857}
858#[repr(C)]
859#[derive(Copy, Clone)]
860pub struct RendererMemoryStatisticsAllocatorT {
861 pub name: *const ::std::os::raw::c_char,
862 pub num_blocks: u32,
863 pub _padding_39: [::std::os::raw::c_char; 4usize],
864 pub block_size: [u64; 256usize],
865}
866impl Default for RendererMemoryStatisticsAllocatorT {
867 fn default() -> Self {
868 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
869 unsafe {
870 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
871 s.assume_init()
872 }
873 }
874}
875#[repr(C)]
876#[derive(Default, Copy, Clone)]
877pub struct RendererSwapChainO {
878 pub opaque: u64,
879}
880#[repr(C)]
881#[derive(Default, Copy, Clone)]
882pub struct RendererDeviceMemoryO {
883 pub opaque: [u64; 8usize],
884}
885#[repr(C)]
886#[derive(Copy, Clone)]
887pub struct RendererBackendResourceAllocatorI {
888 pub inst: *mut ::std::os::raw::c_void,
889 pub command_buffer_size_buffer: ::std::option::Option<
890 unsafe extern "C" fn(inst: *mut ::std::os::raw::c_void, device_affinity_mask: u32) -> u32,
891 >,
892 pub command_buffer_size_image: ::std::option::Option<
893 unsafe extern "C" fn(inst: *mut ::std::os::raw::c_void, device_affinity_mask: u32) -> u32,
894 >,
895 pub command_buffer_size_image_views: ::std::option::Option<
896 unsafe extern "C" fn(inst: *mut ::std::os::raw::c_void, device_affinity_mask: u32) -> u32,
897 >,
898 pub command_buffer_size_shader: ::std::option::Option<
899 unsafe extern "C" fn(inst: *mut ::std::os::raw::c_void, device_affinity_mask: u32) -> u32,
900 >,
901 pub command_buffer_size_shader_state_override: ::std::option::Option<
902 unsafe extern "C" fn(inst: *mut ::std::os::raw::c_void, device_affinity_mask: u32) -> u32,
903 >,
904 pub command_buffer_size_sampler: ::std::option::Option<
905 unsafe extern "C" fn(inst: *mut ::std::os::raw::c_void, device_affinity_mask: u32) -> u32,
906 >,
907 pub command_buffer_size_queue_fence: ::std::option::Option<
908 unsafe extern "C" fn(inst: *mut ::std::os::raw::c_void, device_affinity_mask: u32) -> u32,
909 >,
910 pub command_buffer_size_resource_binder: ::std::option::Option<
911 unsafe extern "C" fn(
912 inst: *mut ::std::os::raw::c_void,
913 num_bind_points: u32,
914 device_affinity_mask: u32,
915 ) -> u32,
916 >,
917 pub command_buffer_size_ray_tracing_pipeline: ::std::option::Option<
918 unsafe extern "C" fn(inst: *mut ::std::os::raw::c_void, device_affinity_mask: u32) -> u32,
919 >,
920 pub command_buffer_size_acceleration_structure: ::std::option::Option<
921 unsafe extern "C" fn(inst: *mut ::std::os::raw::c_void, device_affinity_mask: u32) -> u32,
922 >,
923 pub create_buffer: ::std::option::Option<
924 unsafe extern "C" fn(
925 inst: *mut ::std::os::raw::c_void,
926 dest: *mut ::std::os::raw::c_void,
927 buffer: *const RendererBufferDescT,
928 device_affinity_mask: u32,
929 ) -> RendererHandleT,
930 >,
931 pub create_image: ::std::option::Option<
932 unsafe extern "C" fn(
933 inst: *mut ::std::os::raw::c_void,
934 dest: *mut ::std::os::raw::c_void,
935 image: *const RendererImageDescT,
936 device_affinity_mask: u32,
937 ) -> RendererHandleT,
938 >,
939 pub create_image_views: ::std::option::Option<
940 unsafe extern "C" fn(
941 inst: *mut ::std::os::raw::c_void,
942 dest: *mut ::std::os::raw::c_void,
943 image: RendererHandleT,
944 desc: *const RendererImageDescT,
945 views: *const RendererImageViewT,
946 num_views: u32,
947 device_affinity_mask: u32,
948 ) -> RendererHandleT,
949 >,
950 pub create_shader: ::std::option::Option<
951 unsafe extern "C" fn(
952 inst: *mut ::std::os::raw::c_void,
953 dest: *mut ::std::os::raw::c_void,
954 shader: *const RendererShaderT,
955 device_affinity_mask: u32,
956 ) -> RendererHandleT,
957 >,
958 pub create_shader_state_override: ::std::option::Option<
959 unsafe extern "C" fn(
960 inst: *mut ::std::os::raw::c_void,
961 dest: *mut ::std::os::raw::c_void,
962 state_override: *const RendererShaderStateOverrideT,
963 device_affinity_mask: u32,
964 ) -> RendererHandleT,
965 >,
966 pub create_sampler: ::std::option::Option<
967 unsafe extern "C" fn(
968 inst: *mut ::std::os::raw::c_void,
969 dest: *mut ::std::os::raw::c_void,
970 sampler: *const RendererSamplerT,
971 device_affinity_mask: u32,
972 ) -> RendererHandleT,
973 >,
974 pub create_queue_fence: ::std::option::Option<
975 unsafe extern "C" fn(
976 inst: *mut ::std::os::raw::c_void,
977 dest: *mut ::std::os::raw::c_void,
978 device_affinity_mask: u32,
979 ) -> RendererHandleT,
980 >,
981 pub create_resource_binder: ::std::option::Option<
982 unsafe extern "C" fn(
983 inst: *mut ::std::os::raw::c_void,
984 dest: *mut ::std::os::raw::c_void,
985 bind_points: *const RendererResourceBindPointT,
986 num_bind_points: u32,
987 device_affinity_mask: u32,
988 ) -> RendererHandleT,
989 >,
990 pub create_ray_tracing_pipeline: ::std::option::Option<
991 unsafe extern "C" fn(
992 inst: *mut ::std::os::raw::c_void,
993 dest: *mut ::std::os::raw::c_void,
994 pipeline: *const RendererRayTracingPipelineDescT,
995 device_affinity_mask: u32,
996 ) -> RendererHandleT,
997 >,
998 pub create_shader_binding_table: ::std::option::Option<
999 unsafe extern "C" fn(
1000 inst: *mut ::std::os::raw::c_void,
1001 dest: *mut ::std::os::raw::c_void,
1002 shader_binding_table: *const RendererShaderBindingTableDescT,
1003 device_affinity_mask: u32,
1004 staging_mem: *mut RendererDeviceMemoryO,
1005 ) -> RendererHandleT,
1006 >,
1007 pub create_top_level_acceleration_structure: ::std::option::Option<
1008 unsafe extern "C" fn(
1009 inst: *mut ::std::os::raw::c_void,
1010 dest: *mut ::std::os::raw::c_void,
1011 acceleration_structure: *const RendererTopLevelAccelerationStructureDescT,
1012 device_affinity_mask: u32,
1013 ) -> RendererHandleT,
1014 >,
1015 pub create_bottom_level_acceleration_structure: ::std::option::Option<
1016 unsafe extern "C" fn(
1017 inst: *mut ::std::os::raw::c_void,
1018 dest: *mut ::std::os::raw::c_void,
1019 acceleration_structure: *const RendererBottomLevelAccelerationStructureDescT,
1020 device_affinity_mask: u32,
1021 ) -> RendererHandleT,
1022 >,
1023 pub reallocate_bindless_handles: ::std::option::Option<
1024 unsafe extern "C" fn(inst: *mut ::std::os::raw::c_void, handle: *mut RendererHandleT),
1025 >,
1026}
1027impl Default for RendererBackendResourceAllocatorI {
1028 fn default() -> Self {
1029 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
1030 unsafe {
1031 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
1032 s.assume_init()
1033 }
1034 }
1035}
1036#[repr(C)]
1037#[derive(Copy, Clone)]
1038pub struct RendererDeviceMemoryAllocatorI {
1039 pub inst: *mut ::std::os::raw::c_void,
1040 pub allocate_staging_memory_command: ::std::option::Option<
1041 unsafe extern "C" fn(
1042 inst: *mut ::std::os::raw::c_void,
1043 cmd_type: u32,
1044 cmd_data: *mut ::std::os::raw::c_void,
1045 device_affinity_mask: u32,
1046 data: *mut *mut ::std::os::raw::c_void,
1047 ) -> RendererDeviceMemoryO,
1048 >,
1049 pub allocate_staging_memory: ::std::option::Option<
1050 unsafe extern "C" fn(
1051 inst: *mut ::std::os::raw::c_void,
1052 size: u64,
1053 device_affinity_mask: u32,
1054 data: *mut *mut ::std::os::raw::c_void,
1055 ) -> RendererDeviceMemoryO,
1056 >,
1057 pub allocate_resource_read_fence: ::std::option::Option<
1058 unsafe extern "C" fn(inst: *mut ::std::os::raw::c_void, device_affinity_mask: u32) -> u32,
1059 >,
1060 pub append_user_data: ::std::option::Option<
1061 unsafe extern "C" fn(
1062 inst: *mut ::std::os::raw::c_void,
1063 dest: *mut ::std::os::raw::c_void,
1064 src: *mut ::std::os::raw::c_void,
1065 ),
1066 >,
1067}
1068impl Default for RendererDeviceMemoryAllocatorI {
1069 fn default() -> Self {
1070 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
1071 unsafe {
1072 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
1073 s.assume_init()
1074 }
1075 }
1076}
1077#[repr(C)]
1078#[derive(Copy, Clone)]
1079pub struct RendererBackendO {
1080 _unused: [u8; 0],
1081}
1082#[repr(C)]
1083#[derive(Copy, Clone)]
1084pub struct RendererBackendI {
1085 pub inst: *mut RendererBackendO,
1086 pub create_swap_chain: ::std::option::Option<
1087 unsafe extern "C" fn(
1088 inst: *mut RendererBackendO,
1089 window: *const WindowPlatformDataO,
1090 color_space: *const ColorSpaceDescT,
1091 device_affinity: u32,
1092 ) -> RendererSwapChainO,
1093 >,
1094 pub destroy_swap_chain: ::std::option::Option<
1095 unsafe extern "C" fn(inst: *mut RendererBackendO, swap_chain: RendererSwapChainO),
1096 >,
1097 pub resize_swap_chain: ::std::option::Option<
1098 unsafe extern "C" fn(
1099 inst: *mut RendererBackendO,
1100 swap_chain: RendererSwapChainO,
1101 width: u32,
1102 height: u32,
1103 ),
1104 >,
1105 pub present_swap_chain: ::std::option::Option<
1106 unsafe extern "C" fn(inst: *mut RendererBackendO, swap_chain: RendererSwapChainO),
1107 >,
1108 pub swap_chain_resource: ::std::option::Option<
1109 unsafe extern "C" fn(
1110 inst: *mut RendererBackendO,
1111 swap_chain: RendererSwapChainO,
1112 ) -> RendererHandleT,
1113 >,
1114 pub create_command_buffers: ::std::option::Option<
1115 unsafe extern "C" fn(
1116 inst: *mut RendererBackendO,
1117 command_buffers: *mut *mut RendererCommandBufferO,
1118 num_buffers: u32,
1119 ),
1120 >,
1121 pub submit_command_buffers: ::std::option::Option<
1122 unsafe extern "C" fn(
1123 inst: *mut RendererBackendO,
1124 command_buffers: *mut *mut RendererCommandBufferO,
1125 num_buffers: u32,
1126 ),
1127 >,
1128 pub destroy_command_buffers: ::std::option::Option<
1129 unsafe extern "C" fn(
1130 inst: *mut RendererBackendO,
1131 command_buffers: *mut *mut RendererCommandBufferO,
1132 num_buffers: u32,
1133 ),
1134 >,
1135 pub num_command_queues: ::std::option::Option<
1136 unsafe extern "C" fn(
1137 inst: *mut RendererBackendO,
1138 queue_family: u8,
1139 device_affinity_mask: u32,
1140 ) -> u8,
1141 >,
1142 pub supports_buffer: ::std::option::Option<
1143 unsafe extern "C" fn(
1144 inst: *mut RendererBackendO,
1145 buffer: *const RendererBufferDescT,
1146 device_affinity_mask: u32,
1147 ) -> bool,
1148 >,
1149 pub supports_image: ::std::option::Option<
1150 unsafe extern "C" fn(
1151 inst: *mut RendererBackendO,
1152 image: *const RendererImageDescT,
1153 device_affinity_mask: u32,
1154 ) -> bool,
1155 >,
1156 pub supported_color_spaces: ::std::option::Option<
1157 unsafe extern "C" fn(
1158 inst: *mut RendererBackendO,
1159 window: *const WindowPlatformDataO,
1160 num_color_spaces: *mut u32,
1161 descs: *mut ColorSpaceDescT,
1162 formats: *mut u32,
1163 device_affinity_mask: u32,
1164 ) -> bool,
1165 >,
1166 pub supports_ray_tracing: ::std::option::Option<
1167 unsafe extern "C" fn(inst: *mut RendererBackendO, device_affinity_mask: u32) -> bool,
1168 >,
1169 pub create_resource_command_buffers: ::std::option::Option<
1170 unsafe extern "C" fn(
1171 inst: *mut RendererBackendO,
1172 resource_buffers: *mut *mut RendererResourceCommandBufferO,
1173 num_buffers: u32,
1174 ),
1175 >,
1176 pub submit_resource_command_buffers: ::std::option::Option<
1177 unsafe extern "C" fn(
1178 inst: *mut RendererBackendO,
1179 resource_buffers: *mut *mut RendererResourceCommandBufferO,
1180 num_buffers: u32,
1181 ),
1182 >,
1183 pub destroy_resource_command_buffers: ::std::option::Option<
1184 unsafe extern "C" fn(
1185 inst: *mut RendererBackendO,
1186 resource_buffers: *mut *mut RendererResourceCommandBufferO,
1187 num_buffers: u32,
1188 ),
1189 >,
1190 pub frame_begin: ::std::option::Option<unsafe extern "C" fn(inst: *mut RendererBackendO)>,
1191 pub recycle_buffers: ::std::option::Option<unsafe extern "C" fn(inst: *mut RendererBackendO)>,
1192 pub read_complete: ::std::option::Option<
1193 unsafe extern "C" fn(
1194 inst: *mut RendererBackendO,
1195 read_fence: u32,
1196 device_affinity_mask: u32,
1197 ) -> bool,
1198 >,
1199 pub hashed_backend_name:
1200 ::std::option::Option<unsafe extern "C" fn(inst: *mut RendererBackendO) -> StrhashT>,
1201 pub statistics_memory_allocators: ::std::option::Option<
1202 unsafe extern "C" fn(
1203 inst: *mut RendererBackendO,
1204 device_affinity: u32,
1205 allocators: *mut RendererMemoryStatisticsAllocatorT,
1206 ) -> u32,
1207 >,
1208 pub statistics_memory_allocations: ::std::option::Option<
1209 unsafe extern "C" fn(
1210 inst: *mut RendererBackendO,
1211 device_affinity: u32,
1212 allocator: u32,
1213 block: u32,
1214 allocators: *mut RendererMemoryStatisticsAllocationT,
1215 ) -> u32,
1216 >,
1217 pub statistics: ::std::option::Option<
1218 unsafe extern "C" fn(
1219 inst: *mut RendererBackendO,
1220 device_affinity: u32,
1221 stats: *mut RendererStatisticsT,
1222 ),
1223 >,
1224}
1225impl Default for RendererBackendI {
1226 fn default() -> Self {
1227 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
1228 unsafe {
1229 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
1230 s.assume_init()
1231 }
1232 }
1233}
1234#[repr(C)]
1235#[derive(Copy, Clone)]
1236pub struct RendererCommandBufferPoolO {
1237 _unused: [u8; 0],
1238}
1239#[repr(C)]
1240#[derive(Copy, Clone)]
1241pub struct RendererIndexBufferBindT {
1242 _unused: [u8; 0],
1243}
1244#[repr(C)]
1245#[derive(Copy, Clone)]
1246pub struct RendererMemoryBlockPoolO {
1247 _unused: [u8; 0],
1248}
1249#[repr(C)]
1250#[derive(Copy, Clone)]
1251pub struct RendererResourceCommandBufferPoolO {
1252 _unused: [u8; 0],
1253}
1254#[repr(C)]
1255#[derive(Copy, Clone)]
1256pub struct RendererBuildAccelerationStructureT {
1257 _unused: [u8; 0],
1258}
1259pub const TM_RENDERER_COMMAND_BIND_RENDER_PASS: RendererCommand = 0;
1260pub const TM_RENDERER_COMMAND_SET_VIEWPORTS: RendererCommand = 1;
1261pub const TM_RENDERER_COMMAND_SET_SCISSOR_RECTS: RendererCommand = 2;
1262pub const TM_RENDERER_COMMAND_DRAW_CALL: RendererCommand = 3;
1263pub const TM_RENDERER_COMMAND_BEGIN_STATISTICS: RendererCommand = 4;
1264pub const TM_RENDERER_COMMAND_END_STATISTICS: RendererCommand = 5;
1265pub const TM_RENDERER_COMMAND_BIND_QUEUE: RendererCommand = 6;
1266pub const TM_RENDERER_COMMAND_COMPUTE: RendererCommand = 7;
1267pub const TM_RENDERER_COMMAND_TRANSITION_RESOURCES: RendererCommand = 8;
1268pub const TM_RENDERER_COMMAND_COPY_IMAGE: RendererCommand = 9;
1269pub const TM_RENDERER_COMMAND_COPY_BUFFER: RendererCommand = 10;
1270pub const TM_RENDERER_COMMAND_READ_IMAGE: RendererCommand = 11;
1271pub const TM_RENDERER_COMMAND_READ_BUFFER: RendererCommand = 12;
1272pub const TM_RENDERER_COMMAND_TRACE: RendererCommand = 13;
1273pub type RendererCommand = ::std::os::raw::c_int;
1274pub const TM_RENDERER_MAP_FLAGS_CPU_CACHED: RendererMapFlags = 1;
1275pub type RendererMapFlags = ::std::os::raw::c_int;
1276pub const TM_RENDERER_GPU_TIMINGS: RendererStatisticsFlags = 1;
1277pub type RendererStatisticsFlags = ::std::os::raw::c_int;
1278#[repr(C)]
1279#[derive(Copy, Clone)]
1280pub struct RendererCommandsT {
1281 pub sort_keys: *mut u64,
1282 pub types: *mut u32,
1283 pub data: *mut *mut ::std::os::raw::c_void,
1284}
1285impl Default for RendererCommandsT {
1286 fn default() -> Self {
1287 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
1288 unsafe {
1289 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
1290 s.assume_init()
1291 }
1292 }
1293}
1294#[repr(C)]
1295#[derive(Default, Copy, Clone)]
1296pub struct RendererCommandBufferApi {
1297 pub bind_render_pass: ::std::option::Option<
1298 unsafe extern "C" fn(
1299 inst: *mut RendererCommandBufferO,
1300 sort_key: u64,
1301 render_pass: *const RendererRenderPassBindT,
1302 ),
1303 >,
1304 pub set_viewports: ::std::option::Option<
1305 unsafe extern "C" fn(
1306 inst: *mut RendererCommandBufferO,
1307 sort_key: u64,
1308 viewports: *const RendererSetViewportsT,
1309 ),
1310 >,
1311 pub set_scissor_rects: ::std::option::Option<
1312 unsafe extern "C" fn(
1313 inst: *mut RendererCommandBufferO,
1314 sort_key: u64,
1315 rects: *const RendererSetScissorRectsT,
1316 ),
1317 >,
1318 pub draw_calls: ::std::option::Option<
1319 unsafe extern "C" fn(
1320 inst: *mut RendererCommandBufferO,
1321 sort_keys: *const u64,
1322 draw_calls: *const RendererDrawCallInfoT,
1323 shaders: *const RendererShaderInfoT,
1324 num_draw_calls: u32,
1325 ),
1326 >,
1327 pub bind_queue: ::std::option::Option<
1328 unsafe extern "C" fn(
1329 inst: *mut RendererCommandBufferO,
1330 sort_key: u64,
1331 queue_bind: *const RendererQueueBindT,
1332 ),
1333 >,
1334 pub begin_statistics_scope: ::std::option::Option<
1335 unsafe extern "C" fn(
1336 inst: *mut RendererCommandBufferO,
1337 sort_key: u64,
1338 category: *const ::std::os::raw::c_char,
1339 name: *const ::std::os::raw::c_char,
1340 flags: u32,
1341 ) -> u64,
1342 >,
1343 pub end_statistics_scope: ::std::option::Option<
1344 unsafe extern "C" fn(
1345 inst: *mut RendererCommandBufferO,
1346 sort_key: u64,
1347 statistics_scope: u64,
1348 ),
1349 >,
1350 pub compute_dispatches: ::std::option::Option<
1351 unsafe extern "C" fn(
1352 inst: *mut RendererCommandBufferO,
1353 sort_keys: *const u64,
1354 compute_dispatches: *const RendererComputeInfoT,
1355 shaders: *const RendererShaderInfoT,
1356 num_compute_dispatches: u32,
1357 ),
1358 >,
1359 pub transition_resources: ::std::option::Option<
1360 unsafe extern "C" fn(
1361 inst: *mut RendererCommandBufferO,
1362 sort_key: u64,
1363 barriers: *const RendererResourceBarrierT,
1364 num_barriers: u32,
1365 ),
1366 >,
1367 pub copy_image: ::std::option::Option<
1368 unsafe extern "C" fn(
1369 inst: *mut RendererCommandBufferO,
1370 sort_key: u64,
1371 copy_image: *const RendererCopyImageT,
1372 ),
1373 >,
1374 pub copy_buffer: ::std::option::Option<
1375 unsafe extern "C" fn(
1376 inst: *mut RendererCommandBufferO,
1377 sort_key: u64,
1378 copy_buffer: *const RendererCopyBufferT,
1379 ),
1380 >,
1381 pub trace_dispatches: ::std::option::Option<
1382 unsafe extern "C" fn(
1383 inst: *mut RendererCommandBufferO,
1384 sort_keys: *const u64,
1385 trace_calls: *const RendererTraceCallT,
1386 num_trace_calls: u32,
1387 ),
1388 >,
1389 pub read_image: ::std::option::Option<
1390 unsafe extern "C" fn(
1391 inst: *mut RendererCommandBufferO,
1392 sort_key: u64,
1393 read_image: *const RendererReadImageT,
1394 ) -> u32,
1395 >,
1396 pub read_buffer: ::std::option::Option<
1397 unsafe extern "C" fn(
1398 inst: *mut RendererCommandBufferO,
1399 sort_key: u64,
1400 read_buffer: *const RendererReadBufferT,
1401 ) -> u32,
1402 >,
1403 pub num_commands:
1404 ::std::option::Option<unsafe extern "C" fn(inst: *const RendererCommandBufferO) -> u32>,
1405 pub commands: ::std::option::Option<
1406 unsafe extern "C" fn(inst: *const RendererCommandBufferO) -> RendererCommandsT,
1407 >,
1408 pub user_data: ::std::option::Option<
1409 unsafe extern "C" fn(inst: *mut RendererCommandBufferO) -> *mut ::std::os::raw::c_void,
1410 >,
1411 pub set_backend_allocator: ::std::option::Option<
1412 unsafe extern "C" fn(
1413 inst: *mut RendererCommandBufferO,
1414 memory_allocator: *mut RendererDeviceMemoryAllocatorI,
1415 ),
1416 >,
1417 pub append_buffers: ::std::option::Option<
1418 unsafe extern "C" fn(
1419 inst: *mut RendererCommandBufferO,
1420 buffers: *mut *mut RendererCommandBufferO,
1421 num_buffers: u32,
1422 ),
1423 >,
1424}
1425#[repr(C)]
1426#[derive(Default, Copy, Clone)]
1427pub struct RendererCommandBufferPoolApi {
1428 pub create: ::std::option::Option<
1429 unsafe extern "C" fn(inst: *mut RendererCommandBufferPoolO) -> *mut RendererCommandBufferO,
1430 >,
1431 pub destroy: ::std::option::Option<
1432 unsafe extern "C" fn(
1433 inst: *mut RendererCommandBufferPoolO,
1434 buffer: *mut RendererCommandBufferO,
1435 ),
1436 >,
1437 pub user_data_size:
1438 ::std::option::Option<unsafe extern "C" fn(inst: *mut RendererCommandBufferPoolO) -> u64>,
1439}
1440extern "C" {
1441 pub fn tm_renderer_create_command_buffer_pool(
1442 backing_memory_block_pool: *mut RendererMemoryBlockPoolO,
1443 user_data_size: u64,
1444 allocator: *mut AllocatorI,
1445 memory_tracker_scope: u32,
1446 ) -> *mut RendererCommandBufferPoolO;
1447}
1448extern "C" {
1449 pub fn tm_renderer_destroy_command_buffer_pool(
1450 pool: *mut RendererCommandBufferPoolO,
1451 allocator: *mut AllocatorI,
1452 memory_tracker_scope: u32,
1453 );
1454}
1455#[repr(C)]
1456#[derive(Default, Copy, Clone)]
1457pub struct RendererCommandBufferSortApi {
1458 pub sort_memory_needed: ::std::option::Option<
1459 unsafe extern "C" fn(buffers: *mut *const RendererCommandBufferO, num_buffers: u32) -> u64,
1460 >,
1461 pub sort_commands: ::std::option::Option<
1462 unsafe extern "C" fn(
1463 buffers: *mut *const RendererCommandBufferO,
1464 num_buffers: u32,
1465 sort_memory: *mut ::std::os::raw::c_void,
1466 sorted_output: *mut *mut RendererCommandsT,
1467 num_commands: *mut u32,
1468 ),
1469 >,
1470}
1471pub const TM_RENDERER_RESOURCE_CREATE_BUFFER: RendererResource = 0;
1472pub const TM_RENDERER_RESOURCE_MAP_CREATE_BUFFER: RendererResource = 1;
1473pub const TM_RENDERER_RESOURCE_RESIZE_BUFFER: RendererResource = 2;
1474pub const TM_RENDERER_RESOURCE_UPDATE_BUFFER: RendererResource = 3;
1475pub const TM_RENDERER_RESOURCE_FILL_BUFFER: RendererResource = 4;
1476pub const TM_RENDERER_RESOURCE_CREATE_IMAGE: RendererResource = 5;
1477pub const TM_RENDERER_RESOURCE_MAP_CREATE_IMAGE: RendererResource = 6;
1478pub const TM_RENDERER_RESOURCE_UPDATE_IMAGE: RendererResource = 7;
1479pub const TM_RENDERER_RESOURCE_CREATE_IMAGE_VIEWS: RendererResource = 8;
1480pub const TM_RENDERER_RESOURCE_CREATE_SHADER: RendererResource = 9;
1481pub const TM_RENDERER_RESOURCE_CREATE_SHADER_STATE_OVERRIDE: RendererResource = 10;
1482pub const TM_RENDERER_RESOURCE_CREATE_SAMPLER: RendererResource = 11;
1483pub const TM_RENDERER_RESOURCE_CREATE_QUEUE_FENCE: RendererResource = 12;
1484pub const TM_RENDERER_RESOURCE_CREATE_RESOURCE_BINDER: RendererResource = 13;
1485pub const TM_RENDERER_RESOURCE_CREATE_RAY_TRACING_PIPELINE: RendererResource = 14;
1486pub const TM_RENDERER_RESOURCE_CREATE_SHADER_BINDING_TABLE: RendererResource = 15;
1487pub const TM_RENDERER_RESOURCE_CREATE_TOP_LEVEL_ACCELERATION_STRUCTURE: RendererResource = 16;
1488pub const TM_RENDERER_RESOURCE_CREATE_BOTTOM_LEVEL_ACCELERATION_STRUCTURE: RendererResource = 17;
1489pub const TM_RENDERER_RESOURCE_SET_RESOURCE: RendererResource = 18;
1490pub const TM_RENDERER_RESOURCE_SET_ARRAY_RESOURCES: RendererResource = 19;
1491pub const TM_RENDERER_RESOURCE_DESTROY: RendererResource = 20;
1492pub const TM_RENDERER_RESOURCE_NUM_COMMAND_TYPES: RendererResource = 21;
1493pub type RendererResource = ::std::os::raw::c_int;
1494#[repr(C)]
1495#[derive(Copy, Clone)]
1496pub struct RendererResourceCommandsT {
1497 pub types: *mut u32,
1498 pub handles: *mut RendererHandleT,
1499 pub data: *mut *mut ::std::os::raw::c_void,
1500}
1501impl Default for RendererResourceCommandsT {
1502 fn default() -> Self {
1503 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
1504 unsafe {
1505 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
1506 s.assume_init()
1507 }
1508 }
1509}
1510#[repr(C)]
1511#[derive(Default, Copy, Clone)]
1512pub struct RendererResourceCommandBufferApi {
1513 pub create_buffer: ::std::option::Option<
1514 unsafe extern "C" fn(
1515 inst: *mut RendererResourceCommandBufferO,
1516 buffer: *const RendererBufferDescT,
1517 device_affinity_mask: u32,
1518 ) -> RendererHandleT,
1519 >,
1520 pub map_create_buffer: ::std::option::Option<
1521 unsafe extern "C" fn(
1522 inst: *mut RendererResourceCommandBufferO,
1523 buffer: *const RendererBufferDescT,
1524 device_affinity_mask: u32,
1525 map_flags: RendererMapFlags,
1526 data: *mut *mut ::std::os::raw::c_void,
1527 ) -> RendererHandleT,
1528 >,
1529 pub resize_buffer: ::std::option::Option<
1530 unsafe extern "C" fn(
1531 inst: *mut RendererResourceCommandBufferO,
1532 handle: *mut RendererHandleT,
1533 size: u64,
1534 ),
1535 >,
1536 pub update_buffer: ::std::option::Option<
1537 unsafe extern "C" fn(
1538 inst: *mut RendererResourceCommandBufferO,
1539 handle: RendererHandleT,
1540 offset: u64,
1541 size: u64,
1542 device_affinity_mask: u32,
1543 map_flags: RendererMapFlags,
1544 data: *mut *mut ::std::os::raw::c_void,
1545 ),
1546 >,
1547 pub fill_buffer: ::std::option::Option<
1548 unsafe extern "C" fn(
1549 inst: *mut RendererResourceCommandBufferO,
1550 handle: RendererHandleT,
1551 offset: u64,
1552 size: u64,
1553 data: u32,
1554 device_affinity_mask: u32,
1555 ),
1556 >,
1557 pub create_image: ::std::option::Option<
1558 unsafe extern "C" fn(
1559 inst: *mut RendererResourceCommandBufferO,
1560 image: *const RendererImageDescT,
1561 device_affinity_mask: u32,
1562 ) -> RendererHandleT,
1563 >,
1564 pub map_create_image: ::std::option::Option<
1565 unsafe extern "C" fn(
1566 inst: *mut RendererResourceCommandBufferO,
1567 image: *const RendererImageDescT,
1568 device_affinity_mask: u32,
1569 map_flags: RendererMapFlags,
1570 data: *mut *mut ::std::os::raw::c_void,
1571 ) -> RendererHandleT,
1572 >,
1573 pub update_image: ::std::option::Option<
1574 unsafe extern "C" fn(
1575 inst: *mut RendererResourceCommandBufferO,
1576 handle: RendererHandleT,
1577 resource_state: u16,
1578 format: u32,
1579 subresource: *const RendererImageSubresourceLayersT,
1580 offset: *const RendererImageOffsetT,
1581 extent: *const RendererImageExtentT,
1582 device_affinity_mask: u32,
1583 map_flags: RendererMapFlags,
1584 data: *mut *mut ::std::os::raw::c_void,
1585 ),
1586 >,
1587 pub create_image_views: ::std::option::Option<
1588 unsafe extern "C" fn(
1589 inst: *mut RendererResourceCommandBufferO,
1590 image: RendererHandleT,
1591 desc: *const RendererImageDescT,
1592 device_affinity_mask: u32,
1593 views: *const RendererImageViewT,
1594 num_views: u32,
1595 ) -> RendererHandleT,
1596 >,
1597 pub create_shader: ::std::option::Option<
1598 unsafe extern "C" fn(
1599 inst: *mut RendererResourceCommandBufferO,
1600 shader: *const RendererShaderT,
1601 device_affinity_mask: u32,
1602 ) -> RendererHandleT,
1603 >,
1604 pub create_sampler: ::std::option::Option<
1605 unsafe extern "C" fn(
1606 inst: *mut RendererResourceCommandBufferO,
1607 sampler: *const RendererSamplerT,
1608 device_affinity_mask: u32,
1609 ) -> RendererHandleT,
1610 >,
1611 pub create_shader_state_override: ::std::option::Option<
1612 unsafe extern "C" fn(
1613 inst: *mut RendererResourceCommandBufferO,
1614 state_override: *const RendererShaderStateOverrideT,
1615 device_affinity_mask: u32,
1616 ) -> RendererHandleT,
1617 >,
1618 pub create_queue_fence: ::std::option::Option<
1619 unsafe extern "C" fn(
1620 inst: *mut RendererResourceCommandBufferO,
1621 device_affinity_mask: u32,
1622 ) -> RendererHandleT,
1623 >,
1624 pub create_resource_binder: ::std::option::Option<
1625 unsafe extern "C" fn(
1626 inst: *mut RendererResourceCommandBufferO,
1627 bind_points: *const RendererResourceBindPointT,
1628 num_bind_points: u32,
1629 device_affinity_mask: u32,
1630 ) -> RendererHandleT,
1631 >,
1632 pub create_ray_tracing_pipeline: ::std::option::Option<
1633 unsafe extern "C" fn(
1634 inst: *mut RendererResourceCommandBufferO,
1635 pipeline: *const RendererRayTracingPipelineDescT,
1636 device_affinity_mask: u32,
1637 ) -> RendererHandleT,
1638 >,
1639 pub create_shader_binding_table: ::std::option::Option<
1640 unsafe extern "C" fn(
1641 inst: *mut RendererResourceCommandBufferO,
1642 shader_binding_table: *const RendererShaderBindingTableDescT,
1643 device_affinity_mask: u32,
1644 ) -> RendererHandleT,
1645 >,
1646 pub create_top_level_acceleration_structure: ::std::option::Option<
1647 unsafe extern "C" fn(
1648 inst: *mut RendererResourceCommandBufferO,
1649 acceleration_structure: *const RendererTopLevelAccelerationStructureDescT,
1650 device_affinity_mask: u32,
1651 ) -> RendererHandleT,
1652 >,
1653 pub create_bottom_level_acceleration_structure: ::std::option::Option<
1654 unsafe extern "C" fn(
1655 inst: *mut RendererResourceCommandBufferO,
1656 acceleration_structure: *const RendererBottomLevelAccelerationStructureDescT,
1657 device_affinity_mask: u32,
1658 ) -> RendererHandleT,
1659 >,
1660 pub set_resource: ::std::option::Option<
1661 unsafe extern "C" fn(
1662 inst: *mut RendererResourceCommandBufferO,
1663 resource_binder: RendererHandleT,
1664 bind_point: u32,
1665 resource_handles: RendererHandleT,
1666 reosource_aspect_flags: u32,
1667 ),
1668 >,
1669 pub set_array_resources: ::std::option::Option<
1670 unsafe extern "C" fn(
1671 inst: *mut RendererResourceCommandBufferO,
1672 resource_binder: RendererHandleT,
1673 bind_point: u32,
1674 first_element: u32,
1675 resource_handles: *const RendererHandleT,
1676 resource_aspect_flags: *const u32,
1677 n_handles: u32,
1678 ),
1679 >,
1680 pub destroy_resource: ::std::option::Option<
1681 unsafe extern "C" fn(inst: *mut RendererResourceCommandBufferO, handle: RendererHandleT),
1682 >,
1683 pub num_commands: ::std::option::Option<
1684 unsafe extern "C" fn(
1685 inst: *mut RendererResourceCommandBufferO,
1686 count_per_command_type: *mut u32,
1687 ) -> u32,
1688 >,
1689 pub commands: ::std::option::Option<
1690 unsafe extern "C" fn(
1691 inst: *mut RendererResourceCommandBufferO,
1692 ) -> RendererResourceCommandsT,
1693 >,
1694 pub user_data: ::std::option::Option<
1695 unsafe extern "C" fn(
1696 inst: *mut RendererResourceCommandBufferO,
1697 ) -> *mut ::std::os::raw::c_void,
1698 >,
1699 pub set_backend_allocators: ::std::option::Option<
1700 unsafe extern "C" fn(
1701 inst: *mut RendererResourceCommandBufferO,
1702 resource_allocator: *mut RendererBackendResourceAllocatorI,
1703 memory_allocator: *mut RendererDeviceMemoryAllocatorI,
1704 ),
1705 >,
1706 pub append_buffers: ::std::option::Option<
1707 unsafe extern "C" fn(
1708 inst: *mut RendererResourceCommandBufferO,
1709 buffers: *mut *mut RendererResourceCommandBufferO,
1710 num_buffers: u32,
1711 ),
1712 >,
1713}
1714#[repr(C)]
1715#[derive(Default, Copy, Clone)]
1716pub struct RendererResourceCommandBufferPoolApi {
1717 pub create: ::std::option::Option<
1718 unsafe extern "C" fn(
1719 inst: *mut RendererResourceCommandBufferPoolO,
1720 ) -> *mut RendererResourceCommandBufferO,
1721 >,
1722 pub destroy: ::std::option::Option<
1723 unsafe extern "C" fn(
1724 inst: *mut RendererResourceCommandBufferPoolO,
1725 buffer: *mut RendererResourceCommandBufferO,
1726 ),
1727 >,
1728 pub user_data_size: ::std::option::Option<
1729 unsafe extern "C" fn(inst: *mut RendererResourceCommandBufferPoolO) -> u64,
1730 >,
1731}
1732#[repr(C)]
1733#[derive(Default, Copy, Clone)]
1734pub struct RendererStatisticsT {
1735 pub non_indexed_draws: u64,
1736 pub indexed_draws: u64,
1737 pub non_indexed_indirect_draws: u64,
1738 pub indexed_indirect_draws: u64,
1739 pub compute_dispatches: u64,
1740 pub compute_indirect_dispatches: u64,
1741 pub trace_dispatches: u64,
1742 pub primitive_count: u64,
1743 pub pipeline_binds: u64,
1744 pub resource_barriers: u64,
1745 pub render_pass_binds: u64,
1746}
1747pub const TM_RENDERER_RESOURCE_TYPE_NOT_INITIALIZED: RendererResourceType = 0;
1748pub const TM_RENDERER_RESOURCE_TYPE_BUFFER: RendererResourceType = 1;
1749pub const TM_RENDERER_RESOURCE_TYPE_IMAGE: RendererResourceType = 2;
1750pub const TM_RENDERER_RESOURCE_TYPE_IMAGE_VIEWS: RendererResourceType = 3;
1751pub const TM_RENDERER_RESOURCE_TYPE_SAMPLER: RendererResourceType = 4;
1752pub const TM_RENDERER_RESOURCE_TYPE_QUEUE_FENCE: RendererResourceType = 5;
1753pub const TM_RENDERER_RESOURCE_TYPE_SHADER: RendererResourceType = 6;
1754pub const TM_RENDERER_RESOURCE_TYPE_SHADER_STATE_OVERRIDE: RendererResourceType = 7;
1755pub const TM_RENDERER_RESOURCE_TYPE_RESOURCE_BINDER: RendererResourceType = 8;
1756pub const TM_RENDERER_RESOURCE_TYPE_BACK_BUFFER: RendererResourceType = 9;
1757pub const TM_RENDERER_RESOURCE_TYPE_ACCELERATION_STRUCTURE: RendererResourceType = 10;
1758pub const TM_RENDERER_RESOURCE_TYPE_RAY_TRACING_PIPELINE: RendererResourceType = 11;
1759pub type RendererResourceType = ::std::os::raw::c_int;
1760pub const TM_RENDERER_BUFFER_USAGE_UNIFORM: RendererBufferUsageFlags = 1;
1761pub const TM_RENDERER_BUFFER_USAGE_STORAGE: RendererBufferUsageFlags = 2;
1762pub const TM_RENDERER_BUFFER_USAGE_UPDATABLE: RendererBufferUsageFlags = 4;
1763pub const TM_RENDERER_BUFFER_USAGE_UAV: RendererBufferUsageFlags = 8;
1764pub const TM_RENDERER_BUFFER_USAGE_INDEX: RendererBufferUsageFlags = 16;
1765pub const TM_RENDERER_BUFFER_USAGE_VERTEX: RendererBufferUsageFlags = 32;
1766pub const TM_RENDERER_BUFFER_USAGE_INDIRECT: RendererBufferUsageFlags = 64;
1767pub const TM_RENDERER_BUFFER_USAGE_ACCELERATION_STRUCTURE: RendererBufferUsageFlags = 128;
1768pub type RendererBufferUsageFlags = ::std::os::raw::c_int;
1769#[repr(C)]
1770#[derive(Copy, Clone)]
1771pub struct RendererBufferDescT {
1772 pub size: u32,
1773 pub usage_flags: RendererBufferUsageFlags,
1774 pub debug_tag: *const ::std::os::raw::c_char,
1775}
1776impl Default for RendererBufferDescT {
1777 fn default() -> Self {
1778 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
1779 unsafe {
1780 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
1781 s.assume_init()
1782 }
1783 }
1784}
1785pub const TM_RENDERER_IMAGE_USAGE_RENDER_TARGET: RendererImageUsageFlags = 1;
1786pub const TM_RENDERER_IMAGE_USAGE_UAV: RendererImageUsageFlags = 2;
1787pub type RendererImageUsageFlags = ::std::os::raw::c_int;
1788pub const TM_RENDERER_IMAGE_TYPE_1D: RendererImageType = 0;
1789pub const TM_RENDERER_IMAGE_TYPE_2D: RendererImageType = 1;
1790pub const TM_RENDERER_IMAGE_TYPE_3D: RendererImageType = 2;
1791pub const TM_RENDERER_IMAGE_TYPE_CUBE: RendererImageType = 3;
1792pub const TM_RENDERER_IMAGE_TYPE_MAX_VIEWS: RendererImageType = 4;
1793pub type RendererImageType = ::std::os::raw::c_int;
1794pub const TM_RENDERER_IMAGE_VIEW_TYPE_DEFAULT: RendererImageViewType = 0;
1795pub const TM_RENDERER_IMAGE_VIEW_TYPE_1D: RendererImageViewType = 1;
1796pub const TM_RENDERER_IMAGE_VIEW_TYPE_2D: RendererImageViewType = 2;
1797pub const TM_RENDERER_IMAGE_VIEW_TYPE_3D: RendererImageViewType = 3;
1798pub const TM_RENDERER_IMAGE_VIEW_TYPE_CUBE: RendererImageViewType = 4;
1799pub const TM_RENDERER_IMAGE_VIEW_TYPE_1D_ARRAY: RendererImageViewType = 5;
1800pub const TM_RENDERER_IMAGE_VIEW_TYPE_2D_ARRAY: RendererImageViewType = 6;
1801pub const TM_RENDERER_IMAGE_VIEW_TYPE_CUBE_ARRAY: RendererImageViewType = 7;
1802pub const TM_RENDERER_IMAGE_VIEW_TYPE_MAX_VIEWS: RendererImageViewType = 8;
1803pub type RendererImageViewType = ::std::os::raw::c_int;
1804#[repr(C)]
1805#[derive(Copy, Clone)]
1806pub union RendererClearValueT {
1807 pub color: RendererClearValueTColor,
1808 pub depth_stencil: RendererClearValueTDepthStencil,
1809}
1810#[repr(C)]
1811#[derive(Copy, Clone)]
1812pub struct RendererClearValueTColor {
1813 pub __bindgen_anon_1: RendererClearValueTColorBindgenTy1,
1814}
1815#[repr(C)]
1816#[derive(Copy, Clone)]
1817pub union RendererClearValueTColorBindgenTy1 {
1818 pub float32: [f32; 4usize],
1819 pub int32: [i32; 4usize],
1820 pub uint32: [u32; 4usize],
1821}
1822impl Default for RendererClearValueTColorBindgenTy1 {
1823 fn default() -> Self {
1824 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
1825 unsafe {
1826 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
1827 s.assume_init()
1828 }
1829 }
1830}
1831impl Default for RendererClearValueTColor {
1832 fn default() -> Self {
1833 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
1834 unsafe {
1835 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
1836 s.assume_init()
1837 }
1838 }
1839}
1840#[repr(C)]
1841#[derive(Default, Copy, Clone)]
1842pub struct RendererClearValueTDepthStencil {
1843 pub depth: f32,
1844 pub stencil: u32,
1845}
1846impl Default for RendererClearValueT {
1847 fn default() -> Self {
1848 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
1849 unsafe {
1850 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
1851 s.assume_init()
1852 }
1853 }
1854}
1855#[repr(C)]
1856#[derive(Copy, Clone)]
1857pub struct RendererImageDescT {
1858 pub type_: RendererImageType,
1859 pub usage_flags: RendererImageUsageFlags,
1860 pub format: u32,
1861 pub width: u32,
1862 pub height: u32,
1863 pub depth: u32,
1864 pub mip_levels: u32,
1865 pub layer_count: u32,
1866 pub sample_count: u32,
1867 pub clear_value: RendererClearValueT,
1868 pub _padding_153: [::std::os::raw::c_char; 4usize],
1869 pub debug_tag: *const ::std::os::raw::c_char,
1870}
1871impl Default for RendererImageDescT {
1872 fn default() -> Self {
1873 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
1874 unsafe {
1875 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
1876 s.assume_init()
1877 }
1878 }
1879}
1880#[repr(C)]
1881#[derive(Default, Copy, Clone)]
1882pub struct RendererImageViewT {
1883 pub first_layer: u16,
1884 pub layer_count: u16,
1885 pub first_mip: u8,
1886 pub mip_count: u8,
1887 pub _bitfield_align_1: [u8; 0],
1888 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>,
1889 pub _padding_190: [::std::os::raw::c_char; 1usize],
1890}
1891impl RendererImageViewT {
1892 #[inline]
1893 pub fn aspect(&self) -> u8 {
1894 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 4u8) as u8) }
1895 }
1896 #[inline]
1897 pub fn set_aspect(&mut self, val: u8) {
1898 unsafe {
1899 let val: u8 = ::std::mem::transmute(val);
1900 self._bitfield_1.set(0usize, 4u8, val as u64)
1901 }
1902 }
1903 #[inline]
1904 pub fn image_view_type(&self) -> u8 {
1905 unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 4u8) as u8) }
1906 }
1907 #[inline]
1908 pub fn set_image_view_type(&mut self, val: u8) {
1909 unsafe {
1910 let val: u8 = ::std::mem::transmute(val);
1911 self._bitfield_1.set(4usize, 4u8, val as u64)
1912 }
1913 }
1914 #[inline]
1915 pub fn new_bitfield_1(aspect: u8, image_view_type: u8) -> __BindgenBitfieldUnit<[u8; 1usize]> {
1916 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> = Default::default();
1917 __bindgen_bitfield_unit.set(0usize, 4u8, {
1918 let aspect: u8 = unsafe { ::std::mem::transmute(aspect) };
1919 aspect as u64
1920 });
1921 __bindgen_bitfield_unit.set(4usize, 4u8, {
1922 let image_view_type: u8 = unsafe { ::std::mem::transmute(image_view_type) };
1923 image_view_type as u64
1924 });
1925 __bindgen_bitfield_unit
1926 }
1927}
1928#[repr(C)]
1929#[derive(Copy, Clone)]
1930pub struct RendererShaderT {
1931 pub tessellation_states: RendererShaderBlobT,
1932 pub raster_states: RendererShaderBlobT,
1933 pub depth_stencil_states: RendererShaderBlobT,
1934 pub blend_states: RendererShaderBlobT,
1935 pub multi_sample_states: RendererShaderBlobT,
1936 pub stages: [RendererShaderBlobT; 11usize],
1937 pub debug_tag: *const ::std::os::raw::c_char,
1938}
1939impl Default for RendererShaderT {
1940 fn default() -> Self {
1941 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
1942 unsafe {
1943 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
1944 s.assume_init()
1945 }
1946 }
1947}
1948#[repr(C)]
1949#[derive(Copy, Clone)]
1950pub struct RendererSamplerT {
1951 pub sampler_states: RendererShaderBlobT,
1952}
1953impl Default for RendererSamplerT {
1954 fn default() -> Self {
1955 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
1956 unsafe {
1957 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
1958 s.assume_init()
1959 }
1960 }
1961}
1962pub const TM_RENDERER_ACCELERATION_STRUCTURE_TYPE_TOP_LEVEL: RendererAccelerationStructureType = 0;
1963pub const TM_RENDERER_ACCELERATION_STRUCTURE_TYPE_BOTTOM_LEVEL: RendererAccelerationStructureType =
1964 1;
1965pub type RendererAccelerationStructureType = ::std::os::raw::c_int;
1966pub const TM_RENDERER_ACCELERATION_STRUCTURE_BUILD_PREFER_FAST_TRACE:
1967 RendererAccelerationStructureBuildFlags = 1;
1968pub const TM_RENDERER_ACCELERATION_STRUCTURE_BUILD_PREFER_FAST_BUILD:
1969 RendererAccelerationStructureBuildFlags = 2;
1970pub const TM_RENDERER_ACCELERATION_STRUCTURE_BUILD_PREFER_LOW_MEMORY:
1971 RendererAccelerationStructureBuildFlags = 4;
1972pub const TM_RENDERER_ACCELERATION_STRUCTURE_BUILD_ALLOW_UPDATES:
1973 RendererAccelerationStructureBuildFlags = 8;
1974pub const TM_RENDERER_ACCELERATION_STRUCTURE_BUILD_ALLOW_COMPACTION:
1975 RendererAccelerationStructureBuildFlags = 16;
1976pub type RendererAccelerationStructureBuildFlags = ::std::os::raw::c_int;
1977pub const TM_RENDERER_GEOMETRY_TYPE_TRIANGLES: RendererGeometryType = 0;
1978pub const TM_RENDERER_GEOMETRY_TYPE_AABBS: RendererGeometryType = 1;
1979pub type RendererGeometryType = ::std::os::raw::c_int;
1980pub const TM_RENDERER_GEOMETRY_OPAQUE: RendererGeometryFlags = 1;
1981pub const TM_RENDERER_GEOMETRY_NO_DUPLICATE_ANY_HIT_INVOCATION: RendererGeometryFlags = 2;
1982pub type RendererGeometryFlags = ::std::os::raw::c_int;
1983pub const TM_RENDERER_GEOMETRY_INDEX_TYPE_NONE: RendererGeometryIndexType = 0;
1984pub const TM_RENDERER_GEOMETRY_INDEX_TYPE_UINT16: RendererGeometryIndexType = 1;
1985pub const TM_RENDERER_GEOMETRY_INDEX_TYPE_UINT32: RendererGeometryIndexType = 2;
1986pub type RendererGeometryIndexType = ::std::os::raw::c_int;
1987pub const TM_RENDERER_GEOMETRY_INSTANCE_DISABLE_TRIANGLE_CULL: RendererGeometryInstanceFlags = 1;
1988pub const TM_RENDERER_GEOMETRY_INSTANCE_COUNTERCLOCKWISE: RendererGeometryInstanceFlags = 2;
1989pub const TM_RENDERER_GEOMETRY_INSTANCE_FORCE_OPAQUE: RendererGeometryInstanceFlags = 4;
1990pub const TM_RENDERER_GEOMETRY_INSTANCE_FORCE_NO_OPQUE: RendererGeometryInstanceFlags = 8;
1991pub type RendererGeometryInstanceFlags = ::std::os::raw::c_int;
1992#[repr(C)]
1993#[derive(Copy, Clone)]
1994pub struct RendererGeometryTriangleDescT {
1995 pub format: u32,
1996 pub vertex_data: RendererHandleT,
1997 pub vertex_offset: u32,
1998 pub vertex_stride: u32,
1999 pub vertex_count: u32,
2000 pub primitive_count: u32,
2001 pub index_type: RendererGeometryIndexType,
2002 pub index_data: RendererHandleT,
2003 pub index_offset: u32,
2004 pub transform_data: RendererHandleT,
2005 pub transform_offset: u32,
2006}
2007impl Default for RendererGeometryTriangleDescT {
2008 fn default() -> Self {
2009 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
2010 unsafe {
2011 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
2012 s.assume_init()
2013 }
2014 }
2015}
2016#[repr(C)]
2017#[derive(Default, Copy, Clone)]
2018pub struct RendererGeometryAabbDescT {
2019 pub data: RendererHandleT,
2020 pub data_offset: u32,
2021}
2022#[repr(C)]
2023#[derive(Copy, Clone)]
2024pub struct RendererGeometryDescT {
2025 pub type_: RendererGeometryType,
2026 pub flags: RendererGeometryFlags,
2027 pub __bindgen_anon_1: RendererGeometryDescTBindgenTy1,
2028}
2029#[repr(C)]
2030#[derive(Copy, Clone)]
2031pub union RendererGeometryDescTBindgenTy1 {
2032 pub triangle_desc: RendererGeometryTriangleDescT,
2033 pub aabb_desc: RendererGeometryAabbDescT,
2034}
2035impl Default for RendererGeometryDescTBindgenTy1 {
2036 fn default() -> Self {
2037 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
2038 unsafe {
2039 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
2040 s.assume_init()
2041 }
2042 }
2043}
2044impl Default for RendererGeometryDescT {
2045 fn default() -> Self {
2046 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
2047 unsafe {
2048 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
2049 s.assume_init()
2050 }
2051 }
2052}
2053#[repr(C)]
2054#[derive(Copy, Clone)]
2055pub struct RendererBottomLevelAccelerationStructureDescT {
2056 pub build_flags: RendererAccelerationStructureBuildFlags,
2057 pub geometry_desc_count: u32,
2058 pub geometry_desc: *const RendererGeometryDescT,
2059 pub debug_tag: *const ::std::os::raw::c_char,
2060}
2061impl Default for RendererBottomLevelAccelerationStructureDescT {
2062 fn default() -> Self {
2063 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
2064 unsafe {
2065 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
2066 s.assume_init()
2067 }
2068 }
2069}
2070#[repr(C)]
2071pub struct RendererTopLevelAccelerationStructureInstanceT {
2072 pub transform: Mat44T,
2073 pub shader_info_idx: u32,
2074 pub _bitfield_align_1: [u32; 0],
2075 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 3usize]>,
2076 pub __bindgen_padding_0: u8,
2077 pub mask: u8,
2078 pub _padding_355: [::std::os::raw::c_char; 3usize],
2079 pub _bitfield_align_2: [u8; 0],
2080 pub _bitfield_2: __BindgenBitfieldUnit<[u8; 1usize]>,
2081 pub blas_handle: RendererHandleT,
2082}
2083impl Default for RendererTopLevelAccelerationStructureInstanceT {
2084 fn default() -> Self {
2085 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
2086 unsafe {
2087 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
2088 s.assume_init()
2089 }
2090 }
2091}
2092impl RendererTopLevelAccelerationStructureInstanceT {
2093 #[inline]
2094 pub fn instance_id(&self) -> u32 {
2095 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 24u8) as u32) }
2096 }
2097 #[inline]
2098 pub fn set_instance_id(&mut self, val: u32) {
2099 unsafe {
2100 let val: u32 = ::std::mem::transmute(val);
2101 self._bitfield_1.set(0usize, 24u8, val as u64)
2102 }
2103 }
2104 #[inline]
2105 pub fn new_bitfield_1(instance_id: u32) -> __BindgenBitfieldUnit<[u8; 3usize]> {
2106 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 3usize]> = Default::default();
2107 __bindgen_bitfield_unit.set(0usize, 24u8, {
2108 let instance_id: u32 = unsafe { ::std::mem::transmute(instance_id) };
2109 instance_id as u64
2110 });
2111 __bindgen_bitfield_unit
2112 }
2113 #[inline]
2114 pub fn flags(&self) -> RendererGeometryInstanceFlags {
2115 unsafe { ::std::mem::transmute(self._bitfield_2.get(0usize, 8u8) as u32) }
2116 }
2117 #[inline]
2118 pub fn set_flags(&mut self, val: RendererGeometryInstanceFlags) {
2119 unsafe {
2120 let val: u32 = ::std::mem::transmute(val);
2121 self._bitfield_2.set(0usize, 8u8, val as u64)
2122 }
2123 }
2124 #[inline]
2125 pub fn new_bitfield_2(
2126 flags: RendererGeometryInstanceFlags,
2127 ) -> __BindgenBitfieldUnit<[u8; 1usize]> {
2128 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> = Default::default();
2129 __bindgen_bitfield_unit.set(0usize, 8u8, {
2130 let flags: u32 = unsafe { ::std::mem::transmute(flags) };
2131 flags as u64
2132 });
2133 __bindgen_bitfield_unit
2134 }
2135}
2136#[repr(C)]
2137#[derive(Copy, Clone)]
2138pub struct RendererTopLevelAccelerationStructureDescT {
2139 pub build_flags: RendererAccelerationStructureBuildFlags,
2140 pub geometry_flags: RendererGeometryFlags,
2141 pub num_instances: u32,
2142 pub _padding_370: [::std::os::raw::c_char; 4usize],
2143 pub instaces: *const RendererTopLevelAccelerationStructureInstanceT,
2144 pub debug_tag: *const ::std::os::raw::c_char,
2145}
2146impl Default for RendererTopLevelAccelerationStructureDescT {
2147 fn default() -> Self {
2148 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
2149 unsafe {
2150 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
2151 s.assume_init()
2152 }
2153 }
2154}
2155#[repr(C)]
2156#[derive(Copy, Clone)]
2157pub struct RendererShaderBindingTableDescT {
2158 pub pipeline: RendererHandleT,
2159 pub num_shader_infos: u32,
2160 pub shader_infos: *const RendererShaderInfoT,
2161 pub debug_tag: *const ::std::os::raw::c_char,
2162}
2163impl Default for RendererShaderBindingTableDescT {
2164 fn default() -> Self {
2165 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
2166 unsafe {
2167 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
2168 s.assume_init()
2169 }
2170 }
2171}
2172#[repr(C)]
2173#[derive(Copy, Clone)]
2174pub struct RendererRayTracingPipelineDescT {
2175 pub max_recursion_depth: u32,
2176 pub num_shaders: u32,
2177 pub shader_infos: *const RendererShaderInfoT,
2178 pub debug_tag: *const ::std::os::raw::c_char,
2179}
2180impl Default for RendererRayTracingPipelineDescT {
2181 fn default() -> Self {
2182 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
2183 unsafe {
2184 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
2185 s.assume_init()
2186 }
2187 }
2188}
2189#[repr(C)]
2190#[derive(Copy, Clone)]
2191pub struct RendererShaderStateOverrideT {
2192 pub tessellation_states: RendererShaderBlobT,
2193 pub raster_states: RendererShaderBlobT,
2194 pub depth_stencil_states: RendererShaderBlobT,
2195 pub blend_states: RendererShaderBlobT,
2196 pub multi_sample_states: RendererShaderBlobT,
2197}
2198impl Default for RendererShaderStateOverrideT {
2199 fn default() -> Self {
2200 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
2201 unsafe {
2202 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
2203 s.assume_init()
2204 }
2205 }
2206}
2207pub const TM_RENDERER_SHADER_STAGE_FLAG_VERTEX: RendererShaderStageFlag = 1;
2208pub const TM_RENDERER_SHADER_STAGE_FLAG_HULL: RendererShaderStageFlag = 2;
2209pub const TM_RENDERER_SHADER_STAGE_FLAG_DOMAIN: RendererShaderStageFlag = 4;
2210pub const TM_RENDERER_SHADER_STAGE_FLAG_GEOMETRY: RendererShaderStageFlag = 8;
2211pub const TM_RENDERER_SHADER_STAGE_FLAG_PIXEL: RendererShaderStageFlag = 16;
2212pub const TM_RENDERER_SHADER_STAGE_FLAG_COMPUTE: RendererShaderStageFlag = 32;
2213pub const TM_RENDERER_SHADER_STAGE_FLAG_ALL: RendererShaderStageFlag = 63;
2214pub type RendererShaderStageFlag = ::std::os::raw::c_int;
2215pub const TM_RENDERER_RESOURCE_BIND_USAGE_FLAG_UAV: RendererResourceBindUsageFlag = 1;
2216pub type RendererResourceBindUsageFlag = ::std::os::raw::c_int;
2217#[repr(C)]
2218#[derive(Default, Copy, Clone)]
2219pub struct RendererResourceBindPointT {
2220 pub bind_point: u32,
2221 pub stage_flags: u32,
2222 pub type_: u32,
2223 pub view: u32,
2224 pub usage: u32,
2225 pub count: u32,
2226}
2227pub const TM_RENDERER_SHADER_SOURCE_LANGUAGE_HLSL: ::std::os::raw::c_int = 0;
2228pub type _bindgen_ty_5 = ::std::os::raw::c_int;
2229#[repr(C)]
2230#[derive(Copy, Clone)]
2231pub struct RendererShaderCompilerO {
2232 _unused: [u8; 0],
2233}
2234#[repr(C)]
2235#[derive(Copy, Clone)]
2236pub struct RendererStateValuePairT {
2237 pub state: u32,
2238 pub _padding_17: [::std::os::raw::c_char; 4usize],
2239 pub __bindgen_anon_1: RendererStateValuePairTBindgenTy1,
2240}
2241#[repr(C)]
2242#[derive(Copy, Clone)]
2243pub union RendererStateValuePairTBindgenTy1 {
2244 pub enum_value: u32,
2245 pub uint32_value: u32,
2246 pub float_value: f32,
2247 pub nested_states: *mut RendererStateValuePairT,
2248}
2249impl Default for RendererStateValuePairTBindgenTy1 {
2250 fn default() -> Self {
2251 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
2252 unsafe {
2253 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
2254 s.assume_init()
2255 }
2256 }
2257}
2258impl Default for RendererStateValuePairT {
2259 fn default() -> Self {
2260 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
2261 unsafe {
2262 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
2263 s.assume_init()
2264 }
2265 }
2266}
2267pub const TM_RENDERER_STATE_BLOCK_COMPLETE: ::std::os::raw::c_int = 0;
2268pub const TM_RENDERER_STATE_BLOCK_OVERRIDE: ::std::os::raw::c_int = 1;
2269pub type _bindgen_ty_6 = ::std::os::raw::c_int;
2270#[repr(C)]
2271#[derive(Default, Copy, Clone)]
2272pub struct RendererBindlessAccessorT {
2273 pub set: u16,
2274 pub slot: u16,
2275}
2276#[repr(C)]
2277#[derive(Default, Copy, Clone)]
2278pub struct RendererShaderCompilerApi {
2279 pub init: ::std::option::Option<
2280 unsafe extern "C" fn(allocator: *mut AllocatorI) -> *mut RendererShaderCompilerO,
2281 >,
2282 pub shutdown: ::std::option::Option<unsafe extern "C" fn(inst: *mut RendererShaderCompilerO)>,
2283 pub num_state_block_types:
2284 ::std::option::Option<unsafe extern "C" fn(inst: *mut RendererShaderCompilerO) -> u32>,
2285 pub state_block_type: ::std::option::Option<
2286 unsafe extern "C" fn(inst: *mut RendererShaderCompilerO, state_block_type_idx: u32) -> u32,
2287 >,
2288 pub state_block_name: ::std::option::Option<
2289 unsafe extern "C" fn(
2290 inst: *mut RendererShaderCompilerO,
2291 state_block_type: u32,
2292 ) -> *const ::std::os::raw::c_char,
2293 >,
2294 pub num_states: ::std::option::Option<
2295 unsafe extern "C" fn(inst: *mut RendererShaderCompilerO, state_block_type: u32) -> u32,
2296 >,
2297 pub state_name: ::std::option::Option<
2298 unsafe extern "C" fn(
2299 inst: *mut RendererShaderCompilerO,
2300 state_block_type: u32,
2301 state: u32,
2302 ) -> *const ::std::os::raw::c_char,
2303 >,
2304 pub value_type: ::std::option::Option<
2305 unsafe extern "C" fn(
2306 inst: *mut RendererShaderCompilerO,
2307 state_block_type: u32,
2308 state: u32,
2309 ) -> u32,
2310 >,
2311 pub num_values: ::std::option::Option<
2312 unsafe extern "C" fn(inst: *mut RendererShaderCompilerO, value_type: u32) -> u32,
2313 >,
2314 pub value_name: ::std::option::Option<
2315 unsafe extern "C" fn(
2316 inst: *mut RendererShaderCompilerO,
2317 value_type: u32,
2318 value: u32,
2319 ) -> *const ::std::os::raw::c_char,
2320 >,
2321 pub enum_value: ::std::option::Option<
2322 unsafe extern "C" fn(
2323 inst: *mut RendererShaderCompilerO,
2324 value_type: u32,
2325 value: u32,
2326 ) -> u32,
2327 >,
2328 pub compile_state_block: ::std::option::Option<
2329 unsafe extern "C" fn(
2330 inst: *mut RendererShaderCompilerO,
2331 bind_type: u32,
2332 block_type: u32,
2333 states: *const RendererStateValuePairT,
2334 num_raster_states: u32,
2335 ) -> RendererShaderBlobT,
2336 >,
2337 pub compile_shader: ::std::option::Option<
2338 unsafe extern "C" fn(
2339 inst: *mut RendererShaderCompilerO,
2340 source: *const ::std::os::raw::c_char,
2341 entry_point: *const ::std::os::raw::c_char,
2342 source_language: u32,
2343 stage: u32,
2344 ) -> RendererShaderBlobT,
2345 >,
2346 pub bindless:
2347 ::std::option::Option<unsafe extern "C" fn(inst: *mut RendererShaderCompilerO) -> bool>,
2348 pub bindless_access_buffer: ::std::option::Option<
2349 unsafe extern "C" fn(
2350 inst: *mut RendererShaderCompilerO,
2351 usage_flags: u32,
2352 ) -> RendererBindlessAccessorT,
2353 >,
2354 pub bindless_access_image: ::std::option::Option<
2355 unsafe extern "C" fn(
2356 inst: *mut RendererShaderCompilerO,
2357 type_: u32,
2358 usage_flags: u32,
2359 ) -> RendererBindlessAccessorT,
2360 >,
2361 pub bindless_access_sampler: ::std::option::Option<
2362 unsafe extern "C" fn(inst: *mut RendererShaderCompilerO) -> RendererBindlessAccessorT,
2363 >,
2364 pub bindless_access_acceleration_structure: ::std::option::Option<
2365 unsafe extern "C" fn(inst: *mut RendererShaderCompilerO) -> RendererBindlessAccessorT,
2366 >,
2367 pub release_blob: ::std::option::Option<
2368 unsafe extern "C" fn(inst: *mut RendererShaderCompilerO, blob: RendererShaderBlobT),
2369 >,
2370}
2371#[repr(C)]
2372#[derive(Copy, Clone)]
2373pub struct RendererShaderCompilerI {
2374 pub api: *mut RendererShaderCompilerApi,
2375 pub inst: *mut RendererShaderCompilerO,
2376}
2377impl Default for RendererShaderCompilerI {
2378 fn default() -> Self {
2379 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
2380 unsafe {
2381 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
2382 s.assume_init()
2383 }
2384 }
2385}
2386extern "C" {
2387 pub static mut tm_renderer_state_block_names: [*const ::std::os::raw::c_char; 7usize];
2388}
2389pub const TM_RENDERER_VALUE_BOOL_FALSE: ::std::os::raw::c_int = 0;
2390pub const TM_RENDERER_VALUE_BOOL_TRUE: ::std::os::raw::c_int = 1;
2391pub const TM_RENDERER_VALUE_BOOL_MAX_VALUES: ::std::os::raw::c_int = 2;
2392pub type _bindgen_ty_7 = ::std::os::raw::c_int;
2393extern "C" {
2394 pub static mut tm_renderer_value_bool_names: [*const ::std::os::raw::c_char; 2usize];
2395}
2396pub const TM_RENDERER_COMPARE_OP_NEVER: ::std::os::raw::c_int = 0;
2397pub const TM_RENDERER_COMPARE_OP_LESS: ::std::os::raw::c_int = 1;
2398pub const TM_RENDERER_COMPARE_OP_EQUAL: ::std::os::raw::c_int = 2;
2399pub const TM_RENDERER_COMPARE_OP_LESS_OR_EQUAL: ::std::os::raw::c_int = 3;
2400pub const TM_RENDERER_COMPARE_OP_GREATER: ::std::os::raw::c_int = 4;
2401pub const TM_RENDERER_COMPARE_OP_NOT_EQUAL: ::std::os::raw::c_int = 5;
2402pub const TM_RENDERER_COMPARE_OP_GREATER_OR_EQUAL: ::std::os::raw::c_int = 6;
2403pub const TM_RENDERER_COMPARE_OP_MAX_VALUES: ::std::os::raw::c_int = 7;
2404pub type _bindgen_ty_8 = ::std::os::raw::c_int;
2405extern "C" {
2406 pub static mut tm_renderer_value_compare_op_names: [*const ::std::os::raw::c_char; 7usize];
2407}
2408pub const TM_RENDERER_TESSELLATION_STATE_CONTROL_POINTS: ::std::os::raw::c_int = 0;
2409pub const TM_RENDERER_TESSELLATION_STATE_MAX_STATES: ::std::os::raw::c_int = 1;
2410pub type _bindgen_ty_9 = ::std::os::raw::c_int;
2411extern "C" {
2412 pub static mut tm_renderer_tessellation_state_names: [*const ::std::os::raw::c_char; 1usize];
2413}
2414extern "C" {
2415 pub static mut tm_renderer_tessellation_state_value_types: [u32; 1usize];
2416}
2417pub const TM_RENDERER_RASTER_STATE_CULL_MODE: ::std::os::raw::c_int = 0;
2418pub const TM_RENDERER_RASTER_STATE_FRONT_FACE: ::std::os::raw::c_int = 1;
2419pub const TM_RENDERER_RASTER_STATE_POLYGON_MODE: ::std::os::raw::c_int = 2;
2420pub const TM_RENDERER_RASTER_STATE_DEPTH_BIAS_ENABLE: ::std::os::raw::c_int = 3;
2421pub const TM_RENDERER_RASTER_STATE_DEPTH_BIAS_CONSTANT_FACTOR: ::std::os::raw::c_int = 4;
2422pub const TM_RENDERER_RASTER_STATE_DEPTH_BIAS_CLAMP: ::std::os::raw::c_int = 5;
2423pub const TM_RENDERER_RASTER_STATE_DEPTH_BIAS_SLOPE_FACTOR: ::std::os::raw::c_int = 6;
2424pub const TM_RENDERER_RASTER_STATE_MAX_STATES: ::std::os::raw::c_int = 7;
2425pub type _bindgen_ty_10 = ::std::os::raw::c_int;
2426extern "C" {
2427 pub static mut tm_renderer_raster_state_names: [*const ::std::os::raw::c_char; 7usize];
2428}
2429extern "C" {
2430 pub static mut tm_renderer_raster_state_value_types: [u32; 7usize];
2431}
2432pub const TM_RENDERER_RASTER_VALUE_CULL_NONE: ::std::os::raw::c_int = 0;
2433pub const TM_RENDERER_RASTER_VALUE_CULL_FRONT: ::std::os::raw::c_int = 1;
2434pub const TM_RENDERER_RASTER_VALUE_CULL_BACK: ::std::os::raw::c_int = 2;
2435pub const TM_RENDERER_RASTER_VALUE_CULL_MAX_VALUES: ::std::os::raw::c_int = 3;
2436pub type _bindgen_ty_11 = ::std::os::raw::c_int;
2437extern "C" {
2438 pub static mut tm_renderer_raster_value_cull_names: [*const ::std::os::raw::c_char; 3usize];
2439}
2440pub const TM_RENDERER_RASTER_VALUE_FRONT_FACE_CW: ::std::os::raw::c_int = 0;
2441pub const TM_RENDERER_RASTER_VALUE_FRONT_FACE_CCW: ::std::os::raw::c_int = 1;
2442pub const TM_RENDERER_RASTER_VALUE_FRONT_FACE_MAX_VALUES: ::std::os::raw::c_int = 2;
2443pub type _bindgen_ty_12 = ::std::os::raw::c_int;
2444extern "C" {
2445 pub static mut tm_renderer_raster_value_front_face_names:
2446 [*const ::std::os::raw::c_char; 2usize];
2447}
2448pub const TM_RENDERER_RASTER_VALUE_POLYGON_MODE_FILL: ::std::os::raw::c_int = 0;
2449pub const TM_RENDERER_RASTER_VALUE_POLYGON_MODE_LINE: ::std::os::raw::c_int = 1;
2450pub const TM_RENDERER_RASTER_VALUE_POLYGON_MODE_POINT: ::std::os::raw::c_int = 2;
2451pub const TM_RENDERER_RASTER_VALUE_POLYGON_MODE_MAX_VALUES: ::std::os::raw::c_int = 3;
2452pub type _bindgen_ty_13 = ::std::os::raw::c_int;
2453extern "C" {
2454 pub static mut tm_renderer_raster_value_polygon_names: [*const ::std::os::raw::c_char; 3usize];
2455}
2456pub const TM_RENDERER_DEPTH_STENCIL_STATE_DEPTH_TEST_ENABLE: ::std::os::raw::c_int = 0;
2457pub const TM_RENDERER_DEPTH_STENCIL_STATE_DEPTH_WRITE_ENABLE: ::std::os::raw::c_int = 1;
2458pub const TM_RENDERER_DEPTH_STENCIL_STATE_DEPTH_COMPARE_OP: ::std::os::raw::c_int = 2;
2459pub const TM_RENDERER_DEPTH_STENCIL_STATE_STENCIL_TEST_ENABLE: ::std::os::raw::c_int = 3;
2460pub const TM_RENDERER_DEPTH_STENCIL_STATE_STENCIL_FRONT_FAIL_OP: ::std::os::raw::c_int = 4;
2461pub const TM_RENDERER_DEPTH_STENCIL_STATE_STENCIL_FRONT_PASS_OP: ::std::os::raw::c_int = 5;
2462pub const TM_RENDERER_DEPTH_STENCIL_STATE_STENCIL_FRONT_DEPTH_FAIL_OP: ::std::os::raw::c_int = 6;
2463pub const TM_RENDERER_DEPTH_STENCIL_STATE_STENCIL_FRONT_COMPARE_OP: ::std::os::raw::c_int = 7;
2464pub const TM_RENDERER_DEPTH_STENCIL_STATE_STENCIL_FRONT_COMPARE_MASK: ::std::os::raw::c_int = 8;
2465pub const TM_RENDERER_DEPTH_STENCIL_STATE_STENCIL_FRONT_COMPARE_WRITE_MASK: ::std::os::raw::c_int =
2466 9;
2467pub const TM_RENDERER_DEPTH_STENCIL_STATE_STENCIL_FRONT_REFERENCE: ::std::os::raw::c_int = 10;
2468pub const TM_RENDERER_DEPTH_STENCIL_STATE_STENCIL_BACK_FAIL_OP: ::std::os::raw::c_int = 11;
2469pub const TM_RENDERER_DEPTH_STENCIL_STATE_STENCIL_BACK_PASS_OP: ::std::os::raw::c_int = 12;
2470pub const TM_RENDERER_DEPTH_STENCIL_STATE_STENCIL_BACK_DEPTH_FAIL_OP: ::std::os::raw::c_int = 13;
2471pub const TM_RENDERER_DEPTH_STENCIL_STATE_STENCIL_BACK_COMPARE_OP: ::std::os::raw::c_int = 14;
2472pub const TM_RENDERER_DEPTH_STENCIL_STATE_STENCIL_BACK_COMPARE_MASK: ::std::os::raw::c_int = 15;
2473pub const TM_RENDERER_DEPTH_STENCIL_STATE_STENCIL_BACK_COMPARE_WRITE_MASK: ::std::os::raw::c_int =
2474 16;
2475pub const TM_RENDERER_DEPTH_STENCIL_STATE_STENCIL_BACK_REFERENCE: ::std::os::raw::c_int = 17;
2476pub const TM_RENDERER_DEPTH_STENCIL_STATE_DEPTH_BOUND_TEST_ENABLE: ::std::os::raw::c_int = 18;
2477pub const TM_RENDERER_DEPTH_STENCIL_STATE_DEPTH_BOUND_MIN: ::std::os::raw::c_int = 19;
2478pub const TM_RENDERER_DEPTH_STENCIL_STATE_DEPTH_BOUND_MAX: ::std::os::raw::c_int = 20;
2479pub const TM_RENDERER_DEPTH_STENCIL_STATE_MAX_STATES: ::std::os::raw::c_int = 21;
2480pub type _bindgen_ty_14 = ::std::os::raw::c_int;
2481extern "C" {
2482 pub static mut tm_renderer_depth_stencil_state_names: [*const ::std::os::raw::c_char; 21usize];
2483}
2484extern "C" {
2485 pub static mut tm_renderer_depth_stencil_state_value_types: [u32; 21usize];
2486}
2487pub const TM_RENDERER_STENCIL_OP_KEEP: ::std::os::raw::c_int = 0;
2488pub const TM_RENDERER_STENCIL_OP_ZERO: ::std::os::raw::c_int = 1;
2489pub const TM_RENDERER_STENCIL_OP_REPLACE: ::std::os::raw::c_int = 2;
2490pub const TM_RENDERER_STENCIL_OP_INC_CLAMP: ::std::os::raw::c_int = 3;
2491pub const TM_RENDERER_STENCIL_OP_DEC_CLAMP: ::std::os::raw::c_int = 4;
2492pub const TM_RENDERER_STENCIL_OP_INVERT: ::std::os::raw::c_int = 5;
2493pub const TM_RENDERER_STENCIL_OP_INC_WRAP: ::std::os::raw::c_int = 6;
2494pub const TM_RENDERER_STENCIL_OP_DEC_WRAP: ::std::os::raw::c_int = 7;
2495pub const TM_RENDERER_STENCIL_OP_MAX_VALUES: ::std::os::raw::c_int = 8;
2496pub type _bindgen_ty_15 = ::std::os::raw::c_int;
2497extern "C" {
2498 pub static mut tm_renderer_value_stencil_op_names: [*const ::std::os::raw::c_char; 8usize];
2499}
2500pub const TM_RENDERER_SAMPLER_STATE_MIN_FILTER: ::std::os::raw::c_int = 0;
2501pub const TM_RENDERER_SAMPLER_STATE_MAG_FILTER: ::std::os::raw::c_int = 1;
2502pub const TM_RENDERER_SAMPLER_STATE_MIP_MODE: ::std::os::raw::c_int = 2;
2503pub const TM_RENDERER_SAMPLER_STATE_ADDRESS_U: ::std::os::raw::c_int = 3;
2504pub const TM_RENDERER_SAMPLER_STATE_ADDRESS_V: ::std::os::raw::c_int = 4;
2505pub const TM_RENDERER_SAMPLER_STATE_ADDRESS_W: ::std::os::raw::c_int = 5;
2506pub const TM_RENDERER_SAMPLER_STATE_MIP_LOD_BIAS: ::std::os::raw::c_int = 6;
2507pub const TM_RENDERER_SAMPLER_STATE_ANISOTROPY_ENABLE: ::std::os::raw::c_int = 7;
2508pub const TM_RENDERER_SAMPLER_STATE_MAX_ANISOTROPY: ::std::os::raw::c_int = 8;
2509pub const TM_RENDERER_SAMPLER_STATE_COMPARE_ENABLE: ::std::os::raw::c_int = 9;
2510pub const TM_RENDERER_SAMPLER_STATE_COMPARE_OP: ::std::os::raw::c_int = 10;
2511pub const TM_RENDERER_SAMPLER_STATE_MIN_LOD: ::std::os::raw::c_int = 11;
2512pub const TM_RENDERER_SAMPLER_STATE_MAX_LOD: ::std::os::raw::c_int = 12;
2513pub const TM_RENDERER_SAMPLER_STATE_BORDER_COLOR: ::std::os::raw::c_int = 13;
2514pub const TM_RENDERER_SAMPLER_STATE_MAX_STATES: ::std::os::raw::c_int = 14;
2515pub type _bindgen_ty_16 = ::std::os::raw::c_int;
2516extern "C" {
2517 pub static mut tm_renderer_sampler_state_names: [*const ::std::os::raw::c_char; 14usize];
2518}
2519extern "C" {
2520 pub static mut tm_renderer_sampler_state_types: [u32; 14usize];
2521}
2522pub const TM_RENDERER_FILTER_POINT: ::std::os::raw::c_int = 0;
2523pub const TM_RENDERER_FILTER_LINEAR: ::std::os::raw::c_int = 1;
2524pub const TM_RENDERER_FILTER_MAX_VALUES: ::std::os::raw::c_int = 2;
2525pub type _bindgen_ty_17 = ::std::os::raw::c_int;
2526extern "C" {
2527 pub static mut tm_renderer_value_filter_names: [*const ::std::os::raw::c_char; 2usize];
2528}
2529pub const TM_RENDERER_MIP_MODE_POINT: ::std::os::raw::c_int = 0;
2530pub const TM_RENDERER_MIP_MODE_LINEAR: ::std::os::raw::c_int = 1;
2531pub const TM_RENDERER_MIP_MODE_MAX_VALUES: ::std::os::raw::c_int = 2;
2532pub type _bindgen_ty_18 = ::std::os::raw::c_int;
2533extern "C" {
2534 pub static mut tm_renderer_value_mip_mode_names: [*const ::std::os::raw::c_char; 2usize];
2535}
2536pub const TM_RENDERER_ADDRESS_MODE_WRAP: ::std::os::raw::c_int = 0;
2537pub const TM_RENDERER_ADDRESS_MODE_MIRROR_WRAP: ::std::os::raw::c_int = 1;
2538pub const TM_RENDERER_ADDRESS_MODE_CLAMP: ::std::os::raw::c_int = 2;
2539pub const TM_RENDERER_ADDRESS_MODE_CLAMP_BORDER_COLOR: ::std::os::raw::c_int = 3;
2540pub const TM_RENDERER_ADDRESS_MODE_MIRROR_CLAMP: ::std::os::raw::c_int = 4;
2541pub const TM_RENDERER_ADDRESS_MODE_MAX_VALUES: ::std::os::raw::c_int = 5;
2542pub type _bindgen_ty_19 = ::std::os::raw::c_int;
2543extern "C" {
2544 pub static mut tm_renderer_value_address_mode_names: [*const ::std::os::raw::c_char; 5usize];
2545}
2546pub const TM_RENDERER_BORDER_COLOR_FLOAT_TRANSPARENT_BLACK: ::std::os::raw::c_int = 0;
2547pub const TM_RENDERER_BORDER_COLOR_INT_TRANSPARENT_BLACK: ::std::os::raw::c_int = 1;
2548pub const TM_RENDERER_BORDER_COLOR_FLOAT_OPAQUE_BLACK: ::std::os::raw::c_int = 2;
2549pub const TM_RENDERER_BORDER_COLOR_INT_OPAQUE_BLACK: ::std::os::raw::c_int = 3;
2550pub const TM_RENDERER_BORDER_COLOR_FLOAT_OPAQUE_WHITE: ::std::os::raw::c_int = 4;
2551pub const TM_RENDERER_BORDER_COLOR_INT_OPAQUE_WHITE: ::std::os::raw::c_int = 5;
2552pub const TM_RENDERER_BORDER_COLOR_MAX_VALUES: ::std::os::raw::c_int = 6;
2553pub type _bindgen_ty_20 = ::std::os::raw::c_int;
2554extern "C" {
2555 pub static mut tm_renderer_value_border_color_names: [*const ::std::os::raw::c_char; 6usize];
2556}
2557pub const TM_RENDERER_RENDER_TARGET_BLEND_STATE_BLEND_ENABLE: ::std::os::raw::c_int = 0;
2558pub const TM_RENDERER_RENDER_TARGET_BLEND_STATE_SOURCE_BLEND_FACTOR_COLOR: ::std::os::raw::c_int =
2559 1;
2560pub const TM_RENDERER_RENDER_TARGET_BLEND_STATE_DESTINATION_BLEND_FACTOR_COLOR:
2561 ::std::os::raw::c_int = 2;
2562pub const TM_RENDERER_RENDER_TARGET_BLEND_STATE_BLEND_OP_COLOR: ::std::os::raw::c_int = 3;
2563pub const TM_RENDERER_RENDER_TARGET_BLEND_STATE_SOURCE_BLEND_FACTOR_ALPHA: ::std::os::raw::c_int =
2564 4;
2565pub const TM_RENDERER_RENDER_TARGET_BLEND_STATE_DESTINATION_BLEND_FACTOR_ALPHA:
2566 ::std::os::raw::c_int = 5;
2567pub const TM_RENDERER_RENDER_TARGET_BLEND_STATE_BLEND_OP_ALPHA: ::std::os::raw::c_int = 6;
2568pub const TM_RENDERER_RENDER_TARGET_BLEND_STATE_WRITE_MASK: ::std::os::raw::c_int = 7;
2569pub const TM_RENDERER_RENDER_TARGET_BLEND_STATE_MAX_STATES: ::std::os::raw::c_int = 8;
2570pub type _bindgen_ty_21 = ::std::os::raw::c_int;
2571extern "C" {
2572 pub static mut tm_renderer_render_target_blend_state_names:
2573 [*const ::std::os::raw::c_char; 8usize];
2574}
2575extern "C" {
2576 pub static mut tm_renderer_render_target_blend_state_types: [u32; 8usize];
2577}
2578pub const TM_RENDERER_BLEND_FACTOR_ZERO: ::std::os::raw::c_int = 0;
2579pub const TM_RENDERER_BLEND_FACTOR_ONE: ::std::os::raw::c_int = 1;
2580pub const TM_RENDERER_BLEND_FACTOR_SOURCE_COLOR: ::std::os::raw::c_int = 2;
2581pub const TM_RENDERER_BLEND_FACTOR_ONE_MINUS_SOURCE_COLOR: ::std::os::raw::c_int = 3;
2582pub const TM_RENDERER_BLEND_FACTOR_DESTINATION_COLOR: ::std::os::raw::c_int = 4;
2583pub const TM_RENDERER_BLEND_FACTOR_ONE_MINUS_DESTINATION_COLOR: ::std::os::raw::c_int = 5;
2584pub const TM_RENDERER_BLEND_FACTOR_SOURCE_ALPHA: ::std::os::raw::c_int = 6;
2585pub const TM_RENDERER_BLEND_FACTOR_ONE_MINUS_SOURCE_ALPHA: ::std::os::raw::c_int = 7;
2586pub const TM_RENDERER_BLEND_FACTOR_DESTINATION_ALPHA: ::std::os::raw::c_int = 8;
2587pub const TM_RENDERER_BLEND_FACTOR_ONE_MINUS_DESTINATION_ALPHA: ::std::os::raw::c_int = 9;
2588pub const TM_RENDERER_BLEND_FACTOR_CONSTANT_COLOR: ::std::os::raw::c_int = 10;
2589pub const TM_RENDERER_BLEND_FACTOR_ONE_MINUS_CONSTANT_COLOR: ::std::os::raw::c_int = 11;
2590pub const TM_RENDERER_BLEND_FACTOR_CONSTANT_ALPHA: ::std::os::raw::c_int = 12;
2591pub const TM_RENDERER_BLEND_FACTOR_ONE_MINUS_CONSTANT_ALPHA: ::std::os::raw::c_int = 13;
2592pub const TM_RENDERER_BLEND_FACTOR_SOURCE_ALPHA_SATURATE: ::std::os::raw::c_int = 14;
2593pub const TM_RENDERER_BLEND_FACTOR_SOURCE1_COLOR: ::std::os::raw::c_int = 15;
2594pub const TM_RENDERER_BLEND_FACTOR_ONE_MINUS_SOURCE1_COLOR: ::std::os::raw::c_int = 16;
2595pub const TM_RENDERER_BLEND_FACTOR_SOURCE1_ALPHA: ::std::os::raw::c_int = 17;
2596pub const TM_RENDERER_BLEND_FACTOR_ONE_MINUS_SOURCE1_ALPHA: ::std::os::raw::c_int = 18;
2597pub const TM_RENDERER_BLEND_FACTOR_MAX_VALUES: ::std::os::raw::c_int = 19;
2598pub type _bindgen_ty_22 = ::std::os::raw::c_int;
2599extern "C" {
2600 pub static mut tm_renderer_value_blend_factor_names: [*const ::std::os::raw::c_char; 19usize];
2601}
2602pub const TM_RENDERER_LOGICAL_OP_CLEAR: ::std::os::raw::c_int = 0;
2603pub const TM_RENDERER_LOGICAL_OP_AND: ::std::os::raw::c_int = 1;
2604pub const TM_RENDERER_LOGICAL_OP_AND_REVERSE: ::std::os::raw::c_int = 2;
2605pub const TM_RENDERER_LOGICAL_OP_COPY: ::std::os::raw::c_int = 3;
2606pub const TM_RENDERER_LOGICAL_OP_AND_INVERTED: ::std::os::raw::c_int = 4;
2607pub const TM_RENDERER_LOGICAL_OP_NO_OP: ::std::os::raw::c_int = 5;
2608pub const TM_RENDERER_LOGICAL_OP_XOR: ::std::os::raw::c_int = 6;
2609pub const TM_RENDERER_LOGICAL_OP_OR: ::std::os::raw::c_int = 7;
2610pub const TM_RENDERER_LOGICAL_OP_NOR: ::std::os::raw::c_int = 8;
2611pub const TM_RENDERER_LOGICAL_OP_EQUIVALENT: ::std::os::raw::c_int = 9;
2612pub const TM_RENDERER_LOGICAL_OP_INVERT: ::std::os::raw::c_int = 10;
2613pub const TM_RENDERER_LOGICAL_OP_OR_REVERSE: ::std::os::raw::c_int = 11;
2614pub const TM_RENDERER_LOGICAL_OP_COPY_INVERTED: ::std::os::raw::c_int = 12;
2615pub const TM_RENDERER_LOGICAL_OP_OR_INVERTED: ::std::os::raw::c_int = 13;
2616pub const TM_RENDERER_LOGICAL_OP_NAND: ::std::os::raw::c_int = 14;
2617pub const TM_RENDERER_LOGICAL_OP_SET: ::std::os::raw::c_int = 15;
2618pub const TM_RENDERER_LOGICAL_OP_MAX_VALUES: ::std::os::raw::c_int = 16;
2619pub type _bindgen_ty_23 = ::std::os::raw::c_int;
2620extern "C" {
2621 pub static mut tm_renderer_value_logical_op_names: [*const ::std::os::raw::c_char; 16usize];
2622}
2623pub const TM_RENDERER_BLEND_OP_ADD: ::std::os::raw::c_int = 0;
2624pub const TM_RENDERER_BLEND_OP_SUBTRACT: ::std::os::raw::c_int = 1;
2625pub const TM_RENDERER_BLEND_OP_REVERSE_SUBTRACT: ::std::os::raw::c_int = 2;
2626pub const TM_RENDERER_BLEND_OP_MIN: ::std::os::raw::c_int = 3;
2627pub const TM_RENDERER_BLEND_OP_MAX: ::std::os::raw::c_int = 4;
2628pub const TM_RENDERER_BLEND_OP_MAX_VALUES: ::std::os::raw::c_int = 5;
2629pub type _bindgen_ty_24 = ::std::os::raw::c_int;
2630extern "C" {
2631 pub static mut tm_renderer_value_blend_op_names: [*const ::std::os::raw::c_char; 5usize];
2632}
2633pub const TM_RENDERER_BLEND_WRITE_MASK_DISABLED: ::std::os::raw::c_int = 0;
2634pub const TM_RENDERER_BLEND_WRITE_MASK_RED: ::std::os::raw::c_int = 1;
2635pub const TM_RENDERER_BLEND_WRITE_MASK_GREEN: ::std::os::raw::c_int = 2;
2636pub const TM_RENDERER_BLEND_WRITE_MASK_BLUE: ::std::os::raw::c_int = 4;
2637pub const TM_RENDERER_BLEND_WRITE_MASK_ALPHA: ::std::os::raw::c_int = 8;
2638pub const TM_RENDERER_BLEND_WRITE_MASK_RED_GREEN: ::std::os::raw::c_int = 3;
2639pub const TM_RENDERER_BLEND_WRITE_MASK_RED_BLUE: ::std::os::raw::c_int = 5;
2640pub const TM_RENDERER_BLEND_WRITE_MASK_GREEN_BLUE: ::std::os::raw::c_int = 6;
2641pub const TM_RENDERER_BLEND_WRITE_MASK_RED_GREEN_BLUE: ::std::os::raw::c_int = 7;
2642pub const TM_RENDERER_BLEND_WRITE_MASK_RED_ALPHA: ::std::os::raw::c_int = 9;
2643pub const TM_RENDERER_BLEND_WRITE_MASK_GREEN_ALPHA: ::std::os::raw::c_int = 10;
2644pub const TM_RENDERER_BLEND_WRITE_MASK_RED_GREEN_ALPHA: ::std::os::raw::c_int = 9;
2645pub const TM_RENDERER_BLEND_WRITE_MASK_BLUE_ALPHA: ::std::os::raw::c_int = 12;
2646pub const TM_RENDERER_BLEND_WRITE_MASK_RED_BLUE_ALPHA: ::std::os::raw::c_int = 13;
2647pub const TM_RENDERER_BLEND_WRITE_MASK_GREEN_BLUE_ALPHA: ::std::os::raw::c_int = 14;
2648pub const TM_RENDERER_BLEND_WRITE_MASK_RED_GREEN_BLUE_ALPHA: ::std::os::raw::c_int = 15;
2649pub const TM_RENDERER_BLEND_WRITE_MASK_MAX_VALUES: ::std::os::raw::c_int = 16;
2650pub type _bindgen_ty_25 = ::std::os::raw::c_int;
2651extern "C" {
2652 pub static mut tm_renderer_enum_value_write_mask: [u32; 16usize];
2653}
2654extern "C" {
2655 pub static mut tm_renderer_value_write_mask_names: [*const ::std::os::raw::c_char; 16usize];
2656}
2657pub const TM_RENDERER_BLEND_STATE_LOGICAL_OPERATION_ENABLE: ::std::os::raw::c_int = 0;
2658pub const TM_RENDERER_BLEND_STATE_LOGICAL_OPERATION: ::std::os::raw::c_int = 1;
2659pub const TM_RENDERER_BLEND_STATE_RENDER_TARGET_0: ::std::os::raw::c_int = 2;
2660pub const TM_RENDERER_BLEND_STATE_RENDER_TARGET_1: ::std::os::raw::c_int = 3;
2661pub const TM_RENDERER_BLEND_STATE_RENDER_TARGET_2: ::std::os::raw::c_int = 4;
2662pub const TM_RENDERER_BLEND_STATE_RENDER_TARGET_3: ::std::os::raw::c_int = 5;
2663pub const TM_RENDERER_BLEND_STATE_RENDER_TARGET_4: ::std::os::raw::c_int = 6;
2664pub const TM_RENDERER_BLEND_STATE_RENDER_TARGET_5: ::std::os::raw::c_int = 7;
2665pub const TM_RENDERER_BLEND_STATE_RENDER_TARGET_6: ::std::os::raw::c_int = 8;
2666pub const TM_RENDERER_BLEND_STATE_RENDER_TARGET_7: ::std::os::raw::c_int = 9;
2667pub const TM_RENDERER_BLEND_STATE_MAX_STATES: ::std::os::raw::c_int = 10;
2668pub type _bindgen_ty_26 = ::std::os::raw::c_int;
2669extern "C" {
2670 pub static mut tm_renderer_blend_state_names: [*const ::std::os::raw::c_char; 10usize];
2671}
2672extern "C" {
2673 pub static mut tm_renderer_blend_state_types: [u32; 10usize];
2674}
2675pub const TM_RENDERER_MULTI_SAMPLE_SHADING_ENABLE: ::std::os::raw::c_int = 0;
2676pub const TM_RENDERER_MULTI_MIN_SAMPLE_SHADING: ::std::os::raw::c_int = 1;
2677pub const TM_RENDERER_MULTI_SAMPLE_ALPHA_TO_COVERAGE_ENABLE: ::std::os::raw::c_int = 2;
2678pub const TM_RENDERER_MULTI_SAMPLE_ALPHA_TO_ONE_ENABLE: ::std::os::raw::c_int = 3;
2679pub const TM_RENDERER_MULTI_SAMPLE_MAX_STATES: ::std::os::raw::c_int = 4;
2680pub type _bindgen_ty_27 = ::std::os::raw::c_int;
2681extern "C" {
2682 pub static mut tm_renderer_multi_sample_state_names: [*const ::std::os::raw::c_char; 4usize];
2683}
2684extern "C" {
2685 pub static mut tm_renderer_multi_sample_state_types: [u32; 4usize];
2686}
2687
2688use const_cstr::{const_cstr, ConstCStr};
2691
2692use crate::foundation::VersionT;
2693
2694use crate::foundation::*;
2695use crate::plugins::ui::UiStyleT;
2696
2697impl DeviceMemoryViewApi {
2698 pub unsafe fn create(&self, allocator: *mut AllocatorI) -> *mut DeviceMemoryViewO {
2699 self.create.unwrap()(allocator)
2700 }
2701
2702 pub unsafe fn destroy(&self, view: *mut DeviceMemoryViewO) {
2703 self.destroy.unwrap()(view)
2704 }
2705
2706 pub unsafe fn ui(
2707 &self,
2708 view: *mut DeviceMemoryViewO,
2709 ui: *mut UiO,
2710 uistyle: *const UiStyleT,
2711 content_r: RectT,
2712 tab_id: u64,
2713 ) {
2714 self.ui.unwrap()(view, ui, uistyle, content_r, tab_id)
2715 }
2716}
2717
2718impl crate::Api for DeviceMemoryViewApi {
2719 const NAME: ConstCStr = const_cstr!("tm_device_memory_view_api");
2720 const VERSION: VersionT = VersionT {
2721 major: 1u32,
2722 minor: 0u32,
2723 patch: 0u32,
2724 };
2725}
2726
2727impl NilRendererBackendApi {
2728 pub unsafe fn create(&self, allocator: *mut AllocatorI) -> *mut RendererBackendI {
2729 self.create.unwrap()(allocator)
2730 }
2731
2732 pub unsafe fn destroy(&self, backend: *mut RendererBackendI) {
2733 self.destroy.unwrap()(backend)
2734 }
2735}
2736
2737impl crate::Api for NilRendererBackendApi {
2738 const NAME: ConstCStr = const_cstr!("tm_nil_renderer_backend_api");
2739 const VERSION: VersionT = VersionT {
2740 major: 1u32,
2741 minor: 0u32,
2742 patch: 0u32,
2743 };
2744}
2745
2746impl RendererApi {}
2747
2748impl crate::Api for RendererApi {
2749 const NAME: ConstCStr = const_cstr!("tm_renderer_api");
2750 const VERSION: VersionT = VersionT {
2751 major: 1u32,
2752 minor: 0u32,
2753 patch: 0u32,
2754 };
2755}
2756
2757impl RendererInitApi {
2758 pub unsafe fn init(&self, allocator: *mut AllocatorI, user_data_size: u64) -> *mut RendererApi {
2759 self.init.unwrap()(allocator, user_data_size)
2760 }
2761
2762 pub unsafe fn shutdown(&self) {
2763 self.shutdown.unwrap()()
2764 }
2765}
2766
2767impl crate::Api for RendererInitApi {
2768 const NAME: ConstCStr = const_cstr!("tm_renderer_init_api");
2769 const VERSION: VersionT = VersionT {
2770 major: 1u32,
2771 minor: 0u32,
2772 patch: 0u32,
2773 };
2774}
2775
2776impl RendererCommandBufferApi {
2777 pub unsafe fn bind_render_pass(
2778 &self,
2779 inst: *mut RendererCommandBufferO,
2780 sort_key: u64,
2781 render_pass: *const RendererRenderPassBindT,
2782 ) {
2783 self.bind_render_pass.unwrap()(inst, sort_key, render_pass)
2784 }
2785
2786 pub unsafe fn set_viewports(
2787 &self,
2788 inst: *mut RendererCommandBufferO,
2789 sort_key: u64,
2790 viewports: *const RendererSetViewportsT,
2791 ) {
2792 self.set_viewports.unwrap()(inst, sort_key, viewports)
2793 }
2794
2795 pub unsafe fn set_scissor_rects(
2796 &self,
2797 inst: *mut RendererCommandBufferO,
2798 sort_key: u64,
2799 rects: *const RendererSetScissorRectsT,
2800 ) {
2801 self.set_scissor_rects.unwrap()(inst, sort_key, rects)
2802 }
2803
2804 pub unsafe fn draw_calls(
2805 &self,
2806 inst: *mut RendererCommandBufferO,
2807 sort_keys: *const u64,
2808 draw_calls: *const RendererDrawCallInfoT,
2809 shaders: *const RendererShaderInfoT,
2810 num_draw_calls: u32,
2811 ) {
2812 self.draw_calls.unwrap()(inst, sort_keys, draw_calls, shaders, num_draw_calls)
2813 }
2814
2815 pub unsafe fn bind_queue(
2816 &self,
2817 inst: *mut RendererCommandBufferO,
2818 sort_key: u64,
2819 queue_bind: *const RendererQueueBindT,
2820 ) {
2821 self.bind_queue.unwrap()(inst, sort_key, queue_bind)
2822 }
2823
2824 pub unsafe fn begin_statistics_scope(
2825 &self,
2826 inst: *mut RendererCommandBufferO,
2827 sort_key: u64,
2828 category: *const ::std::os::raw::c_char,
2829 name: *const ::std::os::raw::c_char,
2830 flags: u32,
2831 ) -> u64 {
2832 self.begin_statistics_scope.unwrap()(inst, sort_key, category, name, flags)
2833 }
2834
2835 pub unsafe fn end_statistics_scope(
2836 &self,
2837 inst: *mut RendererCommandBufferO,
2838 sort_key: u64,
2839 statistics_scope: u64,
2840 ) {
2841 self.end_statistics_scope.unwrap()(inst, sort_key, statistics_scope)
2842 }
2843
2844 pub unsafe fn compute_dispatches(
2845 &self,
2846 inst: *mut RendererCommandBufferO,
2847 sort_keys: *const u64,
2848 compute_dispatches: *const RendererComputeInfoT,
2849 shaders: *const RendererShaderInfoT,
2850 num_compute_dispatches: u32,
2851 ) {
2852 self.compute_dispatches.unwrap()(
2853 inst,
2854 sort_keys,
2855 compute_dispatches,
2856 shaders,
2857 num_compute_dispatches,
2858 )
2859 }
2860
2861 pub unsafe fn transition_resources(
2862 &self,
2863 inst: *mut RendererCommandBufferO,
2864 sort_key: u64,
2865 barriers: *const RendererResourceBarrierT,
2866 num_barriers: u32,
2867 ) {
2868 self.transition_resources.unwrap()(inst, sort_key, barriers, num_barriers)
2869 }
2870
2871 pub unsafe fn copy_image(
2872 &self,
2873 inst: *mut RendererCommandBufferO,
2874 sort_key: u64,
2875 copy_image: *const RendererCopyImageT,
2876 ) {
2877 self.copy_image.unwrap()(inst, sort_key, copy_image)
2878 }
2879
2880 pub unsafe fn copy_buffer(
2881 &self,
2882 inst: *mut RendererCommandBufferO,
2883 sort_key: u64,
2884 copy_buffer: *const RendererCopyBufferT,
2885 ) {
2886 self.copy_buffer.unwrap()(inst, sort_key, copy_buffer)
2887 }
2888
2889 pub unsafe fn trace_dispatches(
2890 &self,
2891 inst: *mut RendererCommandBufferO,
2892 sort_keys: *const u64,
2893 trace_calls: *const RendererTraceCallT,
2894 num_trace_calls: u32,
2895 ) {
2896 self.trace_dispatches.unwrap()(inst, sort_keys, trace_calls, num_trace_calls)
2897 }
2898
2899 pub unsafe fn read_image(
2900 &self,
2901 inst: *mut RendererCommandBufferO,
2902 sort_key: u64,
2903 read_image: *const RendererReadImageT,
2904 ) -> u32 {
2905 self.read_image.unwrap()(inst, sort_key, read_image)
2906 }
2907
2908 pub unsafe fn read_buffer(
2909 &self,
2910 inst: *mut RendererCommandBufferO,
2911 sort_key: u64,
2912 read_buffer: *const RendererReadBufferT,
2913 ) -> u32 {
2914 self.read_buffer.unwrap()(inst, sort_key, read_buffer)
2915 }
2916
2917 pub unsafe fn num_commands(&self, inst: *const RendererCommandBufferO) -> u32 {
2918 self.num_commands.unwrap()(inst)
2919 }
2920
2921 pub unsafe fn commands(&self, inst: *const RendererCommandBufferO) -> RendererCommandsT {
2922 self.commands.unwrap()(inst)
2923 }
2924
2925 pub unsafe fn user_data(
2926 &self,
2927 inst: *mut RendererCommandBufferO,
2928 ) -> *mut ::std::os::raw::c_void {
2929 self.user_data.unwrap()(inst)
2930 }
2931
2932 pub unsafe fn set_backend_allocator(
2933 &self,
2934 inst: *mut RendererCommandBufferO,
2935 memory_allocator: *mut RendererDeviceMemoryAllocatorI,
2936 ) {
2937 self.set_backend_allocator.unwrap()(inst, memory_allocator)
2938 }
2939
2940 pub unsafe fn append_buffers(
2941 &self,
2942 inst: *mut RendererCommandBufferO,
2943 buffers: *mut *mut RendererCommandBufferO,
2944 num_buffers: u32,
2945 ) {
2946 self.append_buffers.unwrap()(inst, buffers, num_buffers)
2947 }
2948}
2949
2950impl crate::Api for RendererCommandBufferApi {
2951 const NAME: ConstCStr = const_cstr!("tm_renderer_command_buffer_api");
2952 const VERSION: VersionT = VersionT {
2953 major: 1u32,
2954 minor: 0u32,
2955 patch: 0u32,
2956 };
2957}
2958
2959impl RendererCommandBufferPoolApi {
2960 pub unsafe fn create(
2961 &self,
2962 inst: *mut RendererCommandBufferPoolO,
2963 ) -> *mut RendererCommandBufferO {
2964 self.create.unwrap()(inst)
2965 }
2966
2967 pub unsafe fn destroy(
2968 &self,
2969 inst: *mut RendererCommandBufferPoolO,
2970 buffer: *mut RendererCommandBufferO,
2971 ) {
2972 self.destroy.unwrap()(inst, buffer)
2973 }
2974
2975 pub unsafe fn user_data_size(&self, inst: *mut RendererCommandBufferPoolO) -> u64 {
2976 self.user_data_size.unwrap()(inst)
2977 }
2978}
2979
2980impl crate::Api for RendererCommandBufferPoolApi {
2981 const NAME: ConstCStr = const_cstr!("tm_renderer_command_buffer_pool_api");
2982 const VERSION: VersionT = VersionT {
2983 major: 1u32,
2984 minor: 0u32,
2985 patch: 0u32,
2986 };
2987}
2988
2989impl RendererCommandBufferSortApi {
2990 pub unsafe fn sort_memory_needed(
2991 &self,
2992 buffers: *mut *const RendererCommandBufferO,
2993 num_buffers: u32,
2994 ) -> u64 {
2995 self.sort_memory_needed.unwrap()(buffers, num_buffers)
2996 }
2997
2998 pub unsafe fn sort_commands(
2999 &self,
3000 buffers: *mut *const RendererCommandBufferO,
3001 num_buffers: u32,
3002 sort_memory: *mut ::std::os::raw::c_void,
3003 sorted_output: *mut *mut RendererCommandsT,
3004 num_commands: *mut u32,
3005 ) {
3006 self.sort_commands.unwrap()(
3007 buffers,
3008 num_buffers,
3009 sort_memory,
3010 sorted_output,
3011 num_commands,
3012 )
3013 }
3014}
3015
3016impl crate::Api for RendererCommandBufferSortApi {
3017 const NAME: ConstCStr = const_cstr!("tm_renderer_command_buffer_sort_api");
3018 const VERSION: VersionT = VersionT {
3019 major: 1u32,
3020 minor: 0u32,
3021 patch: 0u32,
3022 };
3023}
3024
3025impl RendererResourceCommandBufferApi {
3026 pub unsafe fn create_buffer(
3027 &self,
3028 inst: *mut RendererResourceCommandBufferO,
3029 buffer: *const RendererBufferDescT,
3030 device_affinity_mask: u32,
3031 ) -> RendererHandleT {
3032 self.create_buffer.unwrap()(inst, buffer, device_affinity_mask)
3033 }
3034
3035 pub unsafe fn map_create_buffer(
3036 &self,
3037 inst: *mut RendererResourceCommandBufferO,
3038 buffer: *const RendererBufferDescT,
3039 device_affinity_mask: u32,
3040 map_flags: RendererMapFlags,
3041 data: *mut *mut ::std::os::raw::c_void,
3042 ) -> RendererHandleT {
3043 self.map_create_buffer.unwrap()(inst, buffer, device_affinity_mask, map_flags, data)
3044 }
3045
3046 pub unsafe fn resize_buffer(
3047 &self,
3048 inst: *mut RendererResourceCommandBufferO,
3049 handle: *mut RendererHandleT,
3050 size: u64,
3051 ) {
3052 self.resize_buffer.unwrap()(inst, handle, size)
3053 }
3054
3055 pub unsafe fn update_buffer(
3056 &self,
3057 inst: *mut RendererResourceCommandBufferO,
3058 handle: RendererHandleT,
3059 offset: u64,
3060 size: u64,
3061 device_affinity_mask: u32,
3062 map_flags: RendererMapFlags,
3063 data: *mut *mut ::std::os::raw::c_void,
3064 ) {
3065 self.update_buffer.unwrap()(
3066 inst,
3067 handle,
3068 offset,
3069 size,
3070 device_affinity_mask,
3071 map_flags,
3072 data,
3073 )
3074 }
3075
3076 pub unsafe fn fill_buffer(
3077 &self,
3078 inst: *mut RendererResourceCommandBufferO,
3079 handle: RendererHandleT,
3080 offset: u64,
3081 size: u64,
3082 data: u32,
3083 device_affinity_mask: u32,
3084 ) {
3085 self.fill_buffer.unwrap()(inst, handle, offset, size, data, device_affinity_mask)
3086 }
3087
3088 pub unsafe fn create_image(
3089 &self,
3090 inst: *mut RendererResourceCommandBufferO,
3091 image: *const RendererImageDescT,
3092 device_affinity_mask: u32,
3093 ) -> RendererHandleT {
3094 self.create_image.unwrap()(inst, image, device_affinity_mask)
3095 }
3096
3097 pub unsafe fn map_create_image(
3098 &self,
3099 inst: *mut RendererResourceCommandBufferO,
3100 image: *const RendererImageDescT,
3101 device_affinity_mask: u32,
3102 map_flags: RendererMapFlags,
3103 data: *mut *mut ::std::os::raw::c_void,
3104 ) -> RendererHandleT {
3105 self.map_create_image.unwrap()(inst, image, device_affinity_mask, map_flags, data)
3106 }
3107
3108 pub unsafe fn update_image(
3109 &self,
3110 inst: *mut RendererResourceCommandBufferO,
3111 handle: RendererHandleT,
3112 resource_state: u16,
3113 format: u32,
3114 subresource: *const RendererImageSubresourceLayersT,
3115 offset: *const RendererImageOffsetT,
3116 extent: *const RendererImageExtentT,
3117 device_affinity_mask: u32,
3118 map_flags: RendererMapFlags,
3119 data: *mut *mut ::std::os::raw::c_void,
3120 ) {
3121 self.update_image.unwrap()(
3122 inst,
3123 handle,
3124 resource_state,
3125 format,
3126 subresource,
3127 offset,
3128 extent,
3129 device_affinity_mask,
3130 map_flags,
3131 data,
3132 )
3133 }
3134
3135 pub unsafe fn create_image_views(
3136 &self,
3137 inst: *mut RendererResourceCommandBufferO,
3138 image: RendererHandleT,
3139 desc: *const RendererImageDescT,
3140 device_affinity_mask: u32,
3141 views: *const RendererImageViewT,
3142 num_views: u32,
3143 ) -> RendererHandleT {
3144 self.create_image_views.unwrap()(inst, image, desc, device_affinity_mask, views, num_views)
3145 }
3146
3147 pub unsafe fn create_shader(
3148 &self,
3149 inst: *mut RendererResourceCommandBufferO,
3150 shader: *const RendererShaderT,
3151 device_affinity_mask: u32,
3152 ) -> RendererHandleT {
3153 self.create_shader.unwrap()(inst, shader, device_affinity_mask)
3154 }
3155
3156 pub unsafe fn create_sampler(
3157 &self,
3158 inst: *mut RendererResourceCommandBufferO,
3159 sampler: *const RendererSamplerT,
3160 device_affinity_mask: u32,
3161 ) -> RendererHandleT {
3162 self.create_sampler.unwrap()(inst, sampler, device_affinity_mask)
3163 }
3164
3165 pub unsafe fn create_shader_state_override(
3166 &self,
3167 inst: *mut RendererResourceCommandBufferO,
3168 state_override: *const RendererShaderStateOverrideT,
3169 device_affinity_mask: u32,
3170 ) -> RendererHandleT {
3171 self.create_shader_state_override.unwrap()(inst, state_override, device_affinity_mask)
3172 }
3173
3174 pub unsafe fn create_queue_fence(
3175 &self,
3176 inst: *mut RendererResourceCommandBufferO,
3177 device_affinity_mask: u32,
3178 ) -> RendererHandleT {
3179 self.create_queue_fence.unwrap()(inst, device_affinity_mask)
3180 }
3181
3182 pub unsafe fn create_resource_binder(
3183 &self,
3184 inst: *mut RendererResourceCommandBufferO,
3185 bind_points: *const RendererResourceBindPointT,
3186 num_bind_points: u32,
3187 device_affinity_mask: u32,
3188 ) -> RendererHandleT {
3189 self.create_resource_binder.unwrap()(
3190 inst,
3191 bind_points,
3192 num_bind_points,
3193 device_affinity_mask,
3194 )
3195 }
3196
3197 pub unsafe fn create_ray_tracing_pipeline(
3198 &self,
3199 inst: *mut RendererResourceCommandBufferO,
3200 pipeline: *const RendererRayTracingPipelineDescT,
3201 device_affinity_mask: u32,
3202 ) -> RendererHandleT {
3203 self.create_ray_tracing_pipeline.unwrap()(inst, pipeline, device_affinity_mask)
3204 }
3205
3206 pub unsafe fn create_shader_binding_table(
3207 &self,
3208 inst: *mut RendererResourceCommandBufferO,
3209 shader_binding_table: *const RendererShaderBindingTableDescT,
3210 device_affinity_mask: u32,
3211 ) -> RendererHandleT {
3212 self.create_shader_binding_table.unwrap()(inst, shader_binding_table, device_affinity_mask)
3213 }
3214
3215 pub unsafe fn create_top_level_acceleration_structure(
3216 &self,
3217 inst: *mut RendererResourceCommandBufferO,
3218 acceleration_structure: *const RendererTopLevelAccelerationStructureDescT,
3219 device_affinity_mask: u32,
3220 ) -> RendererHandleT {
3221 self.create_top_level_acceleration_structure.unwrap()(
3222 inst,
3223 acceleration_structure,
3224 device_affinity_mask,
3225 )
3226 }
3227
3228 pub unsafe fn create_bottom_level_acceleration_structure(
3229 &self,
3230 inst: *mut RendererResourceCommandBufferO,
3231 acceleration_structure: *const RendererBottomLevelAccelerationStructureDescT,
3232 device_affinity_mask: u32,
3233 ) -> RendererHandleT {
3234 self.create_bottom_level_acceleration_structure.unwrap()(
3235 inst,
3236 acceleration_structure,
3237 device_affinity_mask,
3238 )
3239 }
3240
3241 pub unsafe fn set_resource(
3242 &self,
3243 inst: *mut RendererResourceCommandBufferO,
3244 resource_binder: RendererHandleT,
3245 bind_point: u32,
3246 resource_handles: RendererHandleT,
3247 reosource_aspect_flags: u32,
3248 ) {
3249 self.set_resource.unwrap()(
3250 inst,
3251 resource_binder,
3252 bind_point,
3253 resource_handles,
3254 reosource_aspect_flags,
3255 )
3256 }
3257
3258 pub unsafe fn set_array_resources(
3259 &self,
3260 inst: *mut RendererResourceCommandBufferO,
3261 resource_binder: RendererHandleT,
3262 bind_point: u32,
3263 first_element: u32,
3264 resource_handles: *const RendererHandleT,
3265 resource_aspect_flags: *const u32,
3266 n_handles: u32,
3267 ) {
3268 self.set_array_resources.unwrap()(
3269 inst,
3270 resource_binder,
3271 bind_point,
3272 first_element,
3273 resource_handles,
3274 resource_aspect_flags,
3275 n_handles,
3276 )
3277 }
3278
3279 pub unsafe fn destroy_resource(
3280 &self,
3281 inst: *mut RendererResourceCommandBufferO,
3282 handle: RendererHandleT,
3283 ) {
3284 self.destroy_resource.unwrap()(inst, handle)
3285 }
3286
3287 pub unsafe fn num_commands(
3288 &self,
3289 inst: *mut RendererResourceCommandBufferO,
3290 count_per_command_type: *mut u32,
3291 ) -> u32 {
3292 self.num_commands.unwrap()(inst, count_per_command_type)
3293 }
3294
3295 pub unsafe fn commands(
3296 &self,
3297 inst: *mut RendererResourceCommandBufferO,
3298 ) -> RendererResourceCommandsT {
3299 self.commands.unwrap()(inst)
3300 }
3301
3302 pub unsafe fn user_data(
3303 &self,
3304 inst: *mut RendererResourceCommandBufferO,
3305 ) -> *mut ::std::os::raw::c_void {
3306 self.user_data.unwrap()(inst)
3307 }
3308
3309 pub unsafe fn set_backend_allocators(
3310 &self,
3311 inst: *mut RendererResourceCommandBufferO,
3312 resource_allocator: *mut RendererBackendResourceAllocatorI,
3313 memory_allocator: *mut RendererDeviceMemoryAllocatorI,
3314 ) {
3315 self.set_backend_allocators.unwrap()(inst, resource_allocator, memory_allocator)
3316 }
3317
3318 pub unsafe fn append_buffers(
3319 &self,
3320 inst: *mut RendererResourceCommandBufferO,
3321 buffers: *mut *mut RendererResourceCommandBufferO,
3322 num_buffers: u32,
3323 ) {
3324 self.append_buffers.unwrap()(inst, buffers, num_buffers)
3325 }
3326}
3327
3328impl crate::Api for RendererResourceCommandBufferApi {
3329 const NAME: ConstCStr = const_cstr!("tm_renderer_resource_command_buffer_api");
3330 const VERSION: VersionT = VersionT {
3331 major: 1u32,
3332 minor: 0u32,
3333 patch: 0u32,
3334 };
3335}
3336
3337impl RendererResourceCommandBufferPoolApi {
3338 pub unsafe fn create(
3339 &self,
3340 inst: *mut RendererResourceCommandBufferPoolO,
3341 ) -> *mut RendererResourceCommandBufferO {
3342 self.create.unwrap()(inst)
3343 }
3344
3345 pub unsafe fn destroy(
3346 &self,
3347 inst: *mut RendererResourceCommandBufferPoolO,
3348 buffer: *mut RendererResourceCommandBufferO,
3349 ) {
3350 self.destroy.unwrap()(inst, buffer)
3351 }
3352
3353 pub unsafe fn user_data_size(&self, inst: *mut RendererResourceCommandBufferPoolO) -> u64 {
3354 self.user_data_size.unwrap()(inst)
3355 }
3356}
3357
3358impl crate::Api for RendererResourceCommandBufferPoolApi {
3359 const NAME: ConstCStr = const_cstr!("tm_renderer_resource_command_buffer_pool_api");
3360 const VERSION: VersionT = VersionT {
3361 major: 1u32,
3362 minor: 0u32,
3363 patch: 0u32,
3364 };
3365}
3366
3367impl RendererShaderCompilerApi {
3368 pub unsafe fn init(&self, allocator: *mut AllocatorI) -> *mut RendererShaderCompilerO {
3369 self.init.unwrap()(allocator)
3370 }
3371
3372 pub unsafe fn shutdown(&self, inst: *mut RendererShaderCompilerO) {
3373 self.shutdown.unwrap()(inst)
3374 }
3375
3376 pub unsafe fn num_state_block_types(&self, inst: *mut RendererShaderCompilerO) -> u32 {
3377 self.num_state_block_types.unwrap()(inst)
3378 }
3379
3380 pub unsafe fn state_block_type(
3381 &self,
3382 inst: *mut RendererShaderCompilerO,
3383 state_block_type_idx: u32,
3384 ) -> u32 {
3385 self.state_block_type.unwrap()(inst, state_block_type_idx)
3386 }
3387
3388 pub unsafe fn state_block_name(
3389 &self,
3390 inst: *mut RendererShaderCompilerO,
3391 state_block_type: u32,
3392 ) -> *const ::std::os::raw::c_char {
3393 self.state_block_name.unwrap()(inst, state_block_type)
3394 }
3395
3396 pub unsafe fn num_states(
3397 &self,
3398 inst: *mut RendererShaderCompilerO,
3399 state_block_type: u32,
3400 ) -> u32 {
3401 self.num_states.unwrap()(inst, state_block_type)
3402 }
3403
3404 pub unsafe fn state_name(
3405 &self,
3406 inst: *mut RendererShaderCompilerO,
3407 state_block_type: u32,
3408 state: u32,
3409 ) -> *const ::std::os::raw::c_char {
3410 self.state_name.unwrap()(inst, state_block_type, state)
3411 }
3412
3413 pub unsafe fn value_type(
3414 &self,
3415 inst: *mut RendererShaderCompilerO,
3416 state_block_type: u32,
3417 state: u32,
3418 ) -> u32 {
3419 self.value_type.unwrap()(inst, state_block_type, state)
3420 }
3421
3422 pub unsafe fn num_values(&self, inst: *mut RendererShaderCompilerO, value_type: u32) -> u32 {
3423 self.num_values.unwrap()(inst, value_type)
3424 }
3425
3426 pub unsafe fn value_name(
3427 &self,
3428 inst: *mut RendererShaderCompilerO,
3429 value_type: u32,
3430 value: u32,
3431 ) -> *const ::std::os::raw::c_char {
3432 self.value_name.unwrap()(inst, value_type, value)
3433 }
3434
3435 pub unsafe fn enum_value(
3436 &self,
3437 inst: *mut RendererShaderCompilerO,
3438 value_type: u32,
3439 value: u32,
3440 ) -> u32 {
3441 self.enum_value.unwrap()(inst, value_type, value)
3442 }
3443
3444 pub unsafe fn compile_state_block(
3445 &self,
3446 inst: *mut RendererShaderCompilerO,
3447 bind_type: u32,
3448 block_type: u32,
3449 states: *const RendererStateValuePairT,
3450 num_raster_states: u32,
3451 ) -> RendererShaderBlobT {
3452 self.compile_state_block.unwrap()(inst, bind_type, block_type, states, num_raster_states)
3453 }
3454
3455 pub unsafe fn compile_shader(
3456 &self,
3457 inst: *mut RendererShaderCompilerO,
3458 source: *const ::std::os::raw::c_char,
3459 entry_point: *const ::std::os::raw::c_char,
3460 source_language: u32,
3461 stage: u32,
3462 ) -> RendererShaderBlobT {
3463 self.compile_shader.unwrap()(inst, source, entry_point, source_language, stage)
3464 }
3465
3466 pub unsafe fn bindless(&self, inst: *mut RendererShaderCompilerO) -> bool {
3467 self.bindless.unwrap()(inst)
3468 }
3469
3470 pub unsafe fn bindless_access_buffer(
3471 &self,
3472 inst: *mut RendererShaderCompilerO,
3473 usage_flags: u32,
3474 ) -> RendererBindlessAccessorT {
3475 self.bindless_access_buffer.unwrap()(inst, usage_flags)
3476 }
3477
3478 pub unsafe fn bindless_access_image(
3479 &self,
3480 inst: *mut RendererShaderCompilerO,
3481 type_: u32,
3482 usage_flags: u32,
3483 ) -> RendererBindlessAccessorT {
3484 self.bindless_access_image.unwrap()(inst, type_, usage_flags)
3485 }
3486
3487 pub unsafe fn bindless_access_sampler(
3488 &self,
3489 inst: *mut RendererShaderCompilerO,
3490 ) -> RendererBindlessAccessorT {
3491 self.bindless_access_sampler.unwrap()(inst)
3492 }
3493
3494 pub unsafe fn bindless_access_acceleration_structure(
3495 &self,
3496 inst: *mut RendererShaderCompilerO,
3497 ) -> RendererBindlessAccessorT {
3498 self.bindless_access_acceleration_structure.unwrap()(inst)
3499 }
3500
3501 pub unsafe fn release_blob(
3502 &self,
3503 inst: *mut RendererShaderCompilerO,
3504 blob: RendererShaderBlobT,
3505 ) {
3506 self.release_blob.unwrap()(inst, blob)
3507 }
3508}
3509
3510pub const TM_TYPE_HASH__RENDERER_COMPUTE_INFO_T: StrhashT = StrhashT {
3511 u64_: 14466277375278292668u64,
3512};
3513pub const TM_TYPE_HASH__RENDERER_DRAW_CALL_INFO_T: StrhashT = StrhashT {
3514 u64_: 10978780929728728095u64,
3515};
3516pub const TM_NIL_RENDER_BACKEND_INTERFACE_HASH: StrhashT = StrhashT {
3517 u64_: 11404379728544521701u64,
3518};
3519pub const TM_TYPE_HASH__RENDERER_BUFFER_DESC: StrhashT = StrhashT {
3520 u64_: 6564013608050018986u64,
3521};
3522pub const TM_TYPE_HASH__RENDERER_IMAGE_DESC: StrhashT = StrhashT {
3523 u64_: 11834704360853175208u64,
3524};
3525pub const TM_RENDERER_API_VERSION: VersionT = VersionT {
3526 major: 1u32,
3527 minor: 0u32,
3528 patch: 0u32,
3529};
3530pub const TM_RENDERER_BACKEND_I_VERSION: VersionT = VersionT {
3531 major: 1u32,
3532 minor: 0u32,
3533 patch: 0u32,
3534};
3535pub const TM_DEVICE_MEMORY_VIEW_API_VERSION: VersionT = VersionT {
3536 major: 1u32,
3537 minor: 0u32,
3538 patch: 0u32,
3539};
3540pub const TM_RENDERER_RESOURCE_COMMAND_BUFFER_POOL_API_VERSION: VersionT = VersionT {
3541 major: 1u32,
3542 minor: 0u32,
3543 patch: 0u32,
3544};
3545pub const TM_RENDERER_COMMAND_BUFFER_SORT_API_VERSION: VersionT = VersionT {
3546 major: 1u32,
3547 minor: 0u32,
3548 patch: 0u32,
3549};
3550pub const TM_RENDERER_RESOURCE_COMMAND_BUFFER_API_VERSION: VersionT = VersionT {
3551 major: 1u32,
3552 minor: 0u32,
3553 patch: 0u32,
3554};
3555pub const TM_NIL_RENDERER_BACKEND_API_VERSION: VersionT = VersionT {
3556 major: 1u32,
3557 minor: 0u32,
3558 patch: 0u32,
3559};
3560pub const TM_RENDERER_COMMAND_BUFFER_API_VERSION: VersionT = VersionT {
3561 major: 1u32,
3562 minor: 0u32,
3563 patch: 0u32,
3564};
3565pub const TM_RENDERER_COMMAND_BUFFER_POOL_API_VERSION: VersionT = VersionT {
3566 major: 1u32,
3567 minor: 0u32,
3568 patch: 0u32,
3569};
3570pub const TM_RENDERER_INIT_API_VERSION: VersionT = VersionT {
3571 major: 1u32,
3572 minor: 0u32,
3573 patch: 0u32,
3574};