Skip to main content

spirv_to_dxil/
runtime.rs

1//! Higher level helpers for runtime data.
2//!
3//! Builder structs should not be used directly. Instead, call [`build`](RuntimeDataBuilder::build) to consume
4//! the builder and yield an object referenceable as a byte buffer that can be uploaded to a mapped constant buffer.
5
6use spirv_to_dxil_sys::{
7    dxil_spirv_vertex_runtime_data__bindgen_ty_1,
8    dxil_spirv_vertex_runtime_data__bindgen_ty_1__bindgen_ty_1,
9};
10
11/// A vector of three items.
12#[repr(C)]
13#[derive(Debug, Default, Copy, Clone)]
14pub struct Vec3<T> {
15    pub x: T,
16    pub y: T,
17    pub z: T,
18}
19
20/// Trait for runtime data builders.
21pub trait RuntimeDataBuilder<T> {
22    /// Consumes the builder and finalizes the bytes.
23    fn build(self) -> T;
24}
25
26/// Runtime data builder for compute shaders.
27#[derive(Debug, Clone)]
28pub struct ComputeRuntimeDataBuilder {
29    pub group_count: Vec3<u32>,
30    pub base_group: Vec3<u32>,
31}
32
33/// Runtime data buffer for compute shaders.
34pub struct ComputeRuntimeData(spirv_to_dxil_sys::dxil_spirv_compute_runtime_data);
35
36impl RuntimeDataBuilder<ComputeRuntimeData> for ComputeRuntimeDataBuilder {
37    fn build(self) -> ComputeRuntimeData {
38        let data = spirv_to_dxil_sys::dxil_spirv_compute_runtime_data {
39            group_count_x: self.group_count.x,
40            group_count_y: self.group_count.y,
41            group_count_z: self.group_count.z,
42            padding0: 0,
43            base_group_x: self.base_group.x,
44            base_group_y: self.base_group.y,
45            base_group_z: self.base_group.z,
46        };
47
48        ComputeRuntimeData(data)
49    }
50}
51
52impl From<ComputeRuntimeDataBuilder> for ComputeRuntimeData {
53    fn from(value: ComputeRuntimeDataBuilder) -> Self {
54        value.build()
55    }
56}
57
58impl AsRef<[u8]> for ComputeRuntimeData {
59    fn as_ref(&self) -> &[u8] {
60        bytemuck::bytes_of(&self.0)
61    }
62}
63
64/// Runtime data builder for vertex shaders.
65#[derive(Debug, Clone)]
66pub struct VertexRuntimeDataBuilder {
67    pub first_vertex: u32,
68    pub base_instance: u32,
69    pub is_indexed_draw: bool,
70    pub y_flip_mask: u16,
71    pub z_flip_mask: u16,
72    pub draw_id: u32,
73    pub viewport_width: f32,
74    pub viewport_height: f32,
75    pub view_index: u32,
76    pub depth_bias: f32,
77}
78
79/// Runtime data buffer for vertex shaders.
80pub struct VertexRuntimeData(spirv_to_dxil_sys::dxil_spirv_vertex_runtime_data);
81
82impl RuntimeDataBuilder<VertexRuntimeData> for VertexRuntimeDataBuilder {
83    fn build(self) -> VertexRuntimeData {
84        let data = spirv_to_dxil_sys::dxil_spirv_vertex_runtime_data {
85            first_vertex: self.first_vertex,
86            base_instance: self.base_instance,
87            is_indexed_draw: self.is_indexed_draw,
88            _dxil_spirv_anon1: dxil_spirv_vertex_runtime_data__bindgen_ty_1 {
89                _dxil_spirv_anon1: dxil_spirv_vertex_runtime_data__bindgen_ty_1__bindgen_ty_1 {
90                    y_flip_mask: self.y_flip_mask,
91                    z_flip_mask: self.z_flip_mask,
92                },
93            },
94            draw_id: self.draw_id,
95            viewport_width: self.viewport_width,
96            viewport_height: self.viewport_height,
97            view_index: self.view_index,
98            depth_bias: self.depth_bias,
99        };
100
101        VertexRuntimeData(data)
102    }
103}
104
105impl From<VertexRuntimeDataBuilder> for VertexRuntimeData {
106    fn from(value: VertexRuntimeDataBuilder) -> Self {
107        value.build()
108    }
109}
110
111impl AsRef<[u8]> for VertexRuntimeData {
112    fn as_ref(&self) -> &[u8] {
113        bytemuck::bytes_of(&self.0)
114    }
115}