1use alloc::vec::Vec;
2
3use ash::vk;
4
5impl super::PrivateCapabilities {
6 pub fn map_texture_format(&self, format: wgt::TextureFormat) -> vk::Format {
7 use ash::vk::Format as F;
8 use wgt::TextureFormat as Tf;
9 use wgt::{AstcBlock, AstcChannel};
10 match format {
11 Tf::R8Unorm => F::R8_UNORM,
12 Tf::R8Snorm => F::R8_SNORM,
13 Tf::R8Uint => F::R8_UINT,
14 Tf::R8Sint => F::R8_SINT,
15 Tf::R16Uint => F::R16_UINT,
16 Tf::R16Sint => F::R16_SINT,
17 Tf::R16Unorm => F::R16_UNORM,
18 Tf::R16Snorm => F::R16_SNORM,
19 Tf::R16Float => F::R16_SFLOAT,
20 Tf::Rg8Unorm => F::R8G8_UNORM,
21 Tf::Rg8Snorm => F::R8G8_SNORM,
22 Tf::Rg8Uint => F::R8G8_UINT,
23 Tf::Rg8Sint => F::R8G8_SINT,
24 Tf::Rg16Unorm => F::R16G16_UNORM,
25 Tf::Rg16Snorm => F::R16G16_SNORM,
26 Tf::R32Uint => F::R32_UINT,
27 Tf::R32Sint => F::R32_SINT,
28 Tf::R32Float => F::R32_SFLOAT,
29 Tf::Rg16Uint => F::R16G16_UINT,
30 Tf::Rg16Sint => F::R16G16_SINT,
31 Tf::Rg16Float => F::R16G16_SFLOAT,
32 Tf::Rgba8Unorm => F::R8G8B8A8_UNORM,
33 Tf::Rgba8UnormSrgb => F::R8G8B8A8_SRGB,
34 Tf::Bgra8UnormSrgb => F::B8G8R8A8_SRGB,
35 Tf::Rgba8Snorm => F::R8G8B8A8_SNORM,
36 Tf::Bgra8Unorm => F::B8G8R8A8_UNORM,
37 Tf::Rgba8Uint => F::R8G8B8A8_UINT,
38 Tf::Rgba8Sint => F::R8G8B8A8_SINT,
39 Tf::Rgb10a2Uint => F::A2B10G10R10_UINT_PACK32,
40 Tf::Rgb10a2Unorm => F::A2B10G10R10_UNORM_PACK32,
41 Tf::Rg11b10Ufloat => F::B10G11R11_UFLOAT_PACK32,
42 Tf::R64Uint => F::R64_UINT,
43 Tf::Rg32Uint => F::R32G32_UINT,
44 Tf::Rg32Sint => F::R32G32_SINT,
45 Tf::Rg32Float => F::R32G32_SFLOAT,
46 Tf::Rgba16Uint => F::R16G16B16A16_UINT,
47 Tf::Rgba16Sint => F::R16G16B16A16_SINT,
48 Tf::Rgba16Unorm => F::R16G16B16A16_UNORM,
49 Tf::Rgba16Snorm => F::R16G16B16A16_SNORM,
50 Tf::Rgba16Float => F::R16G16B16A16_SFLOAT,
51 Tf::Rgba32Uint => F::R32G32B32A32_UINT,
52 Tf::Rgba32Sint => F::R32G32B32A32_SINT,
53 Tf::Rgba32Float => F::R32G32B32A32_SFLOAT,
54 Tf::Depth32Float => F::D32_SFLOAT,
55 Tf::Depth32FloatStencil8 => F::D32_SFLOAT_S8_UINT,
56 Tf::Depth24Plus => {
57 if self.texture_d24 {
58 F::X8_D24_UNORM_PACK32
59 } else {
60 F::D32_SFLOAT
61 }
62 }
63 Tf::Depth24PlusStencil8 => {
64 if self.texture_d24_s8 {
65 F::D24_UNORM_S8_UINT
66 } else {
67 F::D32_SFLOAT_S8_UINT
68 }
69 }
70 Tf::Stencil8 => {
71 if self.texture_s8 {
72 F::S8_UINT
73 } else if self.texture_d24_s8 {
74 F::D24_UNORM_S8_UINT
75 } else {
76 F::D32_SFLOAT_S8_UINT
77 }
78 }
79 Tf::Depth16Unorm => F::D16_UNORM,
80 Tf::NV12 => F::G8_B8R8_2PLANE_420_UNORM,
81 Tf::Rgb9e5Ufloat => F::E5B9G9R9_UFLOAT_PACK32,
82 Tf::Bc1RgbaUnorm => F::BC1_RGBA_UNORM_BLOCK,
83 Tf::Bc1RgbaUnormSrgb => F::BC1_RGBA_SRGB_BLOCK,
84 Tf::Bc2RgbaUnorm => F::BC2_UNORM_BLOCK,
85 Tf::Bc2RgbaUnormSrgb => F::BC2_SRGB_BLOCK,
86 Tf::Bc3RgbaUnorm => F::BC3_UNORM_BLOCK,
87 Tf::Bc3RgbaUnormSrgb => F::BC3_SRGB_BLOCK,
88 Tf::Bc4RUnorm => F::BC4_UNORM_BLOCK,
89 Tf::Bc4RSnorm => F::BC4_SNORM_BLOCK,
90 Tf::Bc5RgUnorm => F::BC5_UNORM_BLOCK,
91 Tf::Bc5RgSnorm => F::BC5_SNORM_BLOCK,
92 Tf::Bc6hRgbUfloat => F::BC6H_UFLOAT_BLOCK,
93 Tf::Bc6hRgbFloat => F::BC6H_SFLOAT_BLOCK,
94 Tf::Bc7RgbaUnorm => F::BC7_UNORM_BLOCK,
95 Tf::Bc7RgbaUnormSrgb => F::BC7_SRGB_BLOCK,
96 Tf::Etc2Rgb8Unorm => F::ETC2_R8G8B8_UNORM_BLOCK,
97 Tf::Etc2Rgb8UnormSrgb => F::ETC2_R8G8B8_SRGB_BLOCK,
98 Tf::Etc2Rgb8A1Unorm => F::ETC2_R8G8B8A1_UNORM_BLOCK,
99 Tf::Etc2Rgb8A1UnormSrgb => F::ETC2_R8G8B8A1_SRGB_BLOCK,
100 Tf::Etc2Rgba8Unorm => F::ETC2_R8G8B8A8_UNORM_BLOCK,
101 Tf::Etc2Rgba8UnormSrgb => F::ETC2_R8G8B8A8_SRGB_BLOCK,
102 Tf::EacR11Unorm => F::EAC_R11_UNORM_BLOCK,
103 Tf::EacR11Snorm => F::EAC_R11_SNORM_BLOCK,
104 Tf::EacRg11Unorm => F::EAC_R11G11_UNORM_BLOCK,
105 Tf::EacRg11Snorm => F::EAC_R11G11_SNORM_BLOCK,
106 Tf::Astc { block, channel } => match channel {
107 AstcChannel::Unorm => match block {
108 AstcBlock::B4x4 => F::ASTC_4X4_UNORM_BLOCK,
109 AstcBlock::B5x4 => F::ASTC_5X4_UNORM_BLOCK,
110 AstcBlock::B5x5 => F::ASTC_5X5_UNORM_BLOCK,
111 AstcBlock::B6x5 => F::ASTC_6X5_UNORM_BLOCK,
112 AstcBlock::B6x6 => F::ASTC_6X6_UNORM_BLOCK,
113 AstcBlock::B8x5 => F::ASTC_8X5_UNORM_BLOCK,
114 AstcBlock::B8x6 => F::ASTC_8X6_UNORM_BLOCK,
115 AstcBlock::B8x8 => F::ASTC_8X8_UNORM_BLOCK,
116 AstcBlock::B10x5 => F::ASTC_10X5_UNORM_BLOCK,
117 AstcBlock::B10x6 => F::ASTC_10X6_UNORM_BLOCK,
118 AstcBlock::B10x8 => F::ASTC_10X8_UNORM_BLOCK,
119 AstcBlock::B10x10 => F::ASTC_10X10_UNORM_BLOCK,
120 AstcBlock::B12x10 => F::ASTC_12X10_UNORM_BLOCK,
121 AstcBlock::B12x12 => F::ASTC_12X12_UNORM_BLOCK,
122 },
123 AstcChannel::UnormSrgb => match block {
124 AstcBlock::B4x4 => F::ASTC_4X4_SRGB_BLOCK,
125 AstcBlock::B5x4 => F::ASTC_5X4_SRGB_BLOCK,
126 AstcBlock::B5x5 => F::ASTC_5X5_SRGB_BLOCK,
127 AstcBlock::B6x5 => F::ASTC_6X5_SRGB_BLOCK,
128 AstcBlock::B6x6 => F::ASTC_6X6_SRGB_BLOCK,
129 AstcBlock::B8x5 => F::ASTC_8X5_SRGB_BLOCK,
130 AstcBlock::B8x6 => F::ASTC_8X6_SRGB_BLOCK,
131 AstcBlock::B8x8 => F::ASTC_8X8_SRGB_BLOCK,
132 AstcBlock::B10x5 => F::ASTC_10X5_SRGB_BLOCK,
133 AstcBlock::B10x6 => F::ASTC_10X6_SRGB_BLOCK,
134 AstcBlock::B10x8 => F::ASTC_10X8_SRGB_BLOCK,
135 AstcBlock::B10x10 => F::ASTC_10X10_SRGB_BLOCK,
136 AstcBlock::B12x10 => F::ASTC_12X10_SRGB_BLOCK,
137 AstcBlock::B12x12 => F::ASTC_12X12_SRGB_BLOCK,
138 },
139 AstcChannel::Hdr => match block {
140 AstcBlock::B4x4 => F::ASTC_4X4_SFLOAT_BLOCK_EXT,
141 AstcBlock::B5x4 => F::ASTC_5X4_SFLOAT_BLOCK_EXT,
142 AstcBlock::B5x5 => F::ASTC_5X5_SFLOAT_BLOCK_EXT,
143 AstcBlock::B6x5 => F::ASTC_6X5_SFLOAT_BLOCK_EXT,
144 AstcBlock::B6x6 => F::ASTC_6X6_SFLOAT_BLOCK_EXT,
145 AstcBlock::B8x5 => F::ASTC_8X5_SFLOAT_BLOCK_EXT,
146 AstcBlock::B8x6 => F::ASTC_8X6_SFLOAT_BLOCK_EXT,
147 AstcBlock::B8x8 => F::ASTC_8X8_SFLOAT_BLOCK_EXT,
148 AstcBlock::B10x5 => F::ASTC_10X5_SFLOAT_BLOCK_EXT,
149 AstcBlock::B10x6 => F::ASTC_10X6_SFLOAT_BLOCK_EXT,
150 AstcBlock::B10x8 => F::ASTC_10X8_SFLOAT_BLOCK_EXT,
151 AstcBlock::B10x10 => F::ASTC_10X10_SFLOAT_BLOCK_EXT,
152 AstcBlock::B12x10 => F::ASTC_12X10_SFLOAT_BLOCK_EXT,
153 AstcBlock::B12x12 => F::ASTC_12X12_SFLOAT_BLOCK_EXT,
154 },
155 },
156 }
157 }
158}
159
160pub fn map_vk_surface_formats(sf: vk::SurfaceFormatKHR) -> Option<wgt::TextureFormat> {
161 use ash::vk::Format as F;
162 use wgt::TextureFormat as Tf;
163 Some(match sf.color_space {
165 vk::ColorSpaceKHR::SRGB_NONLINEAR => match sf.format {
166 F::B8G8R8A8_UNORM => Tf::Bgra8Unorm,
167 F::B8G8R8A8_SRGB => Tf::Bgra8UnormSrgb,
168 F::R8G8B8A8_SNORM => Tf::Rgba8Snorm,
169 F::R8G8B8A8_UNORM => Tf::Rgba8Unorm,
170 F::R8G8B8A8_SRGB => Tf::Rgba8UnormSrgb,
171 _ => return None,
172 },
173 vk::ColorSpaceKHR::EXTENDED_SRGB_LINEAR_EXT => match sf.format {
174 F::R16G16B16A16_SFLOAT => Tf::Rgba16Float,
175 F::R16G16B16A16_SNORM => Tf::Rgba16Snorm,
176 F::R16G16B16A16_UNORM => Tf::Rgba16Unorm,
177 F::A2B10G10R10_UNORM_PACK32 => Tf::Rgb10a2Unorm,
178 _ => return None,
179 },
180 _ => return None,
181 })
182}
183
184impl crate::Attachment<'_, super::TextureView> {
185 pub(super) fn make_attachment_key(&self, ops: crate::AttachmentOps) -> super::AttachmentKey {
186 super::AttachmentKey {
187 format: self.view.raw_format,
188 layout: derive_image_layout(self.usage, self.view.format),
189 ops,
190 }
191 }
192}
193
194impl crate::ColorAttachment<'_, super::TextureView> {
195 pub(super) unsafe fn make_vk_clear_color(&self) -> vk::ClearColorValue {
196 let cv = &self.clear_value;
197 match self.target.view.format.sample_type(None, None).unwrap() {
198 wgt::TextureSampleType::Float { .. } => vk::ClearColorValue {
199 float32: [cv.r as f32, cv.g as f32, cv.b as f32, cv.a as f32],
200 },
201 wgt::TextureSampleType::Sint => vk::ClearColorValue {
202 int32: [cv.r as i32, cv.g as i32, cv.b as i32, cv.a as i32],
203 },
204 wgt::TextureSampleType::Uint => vk::ClearColorValue {
205 uint32: [cv.r as u32, cv.g as u32, cv.b as u32, cv.a as u32],
206 },
207 wgt::TextureSampleType::Depth => unreachable!(),
208 }
209 }
210}
211
212pub fn derive_image_layout(usage: wgt::TextureUses, format: wgt::TextureFormat) -> vk::ImageLayout {
213 let is_color = !format.is_depth_stencil_format();
215 match usage {
216 wgt::TextureUses::UNINITIALIZED => vk::ImageLayout::UNDEFINED,
217 wgt::TextureUses::COPY_SRC => vk::ImageLayout::TRANSFER_SRC_OPTIMAL,
218 wgt::TextureUses::COPY_DST => vk::ImageLayout::TRANSFER_DST_OPTIMAL,
219 wgt::TextureUses::RESOURCE if is_color => vk::ImageLayout::SHADER_READ_ONLY_OPTIMAL,
220 wgt::TextureUses::COLOR_TARGET => vk::ImageLayout::COLOR_ATTACHMENT_OPTIMAL,
221 wgt::TextureUses::DEPTH_STENCIL_WRITE => vk::ImageLayout::DEPTH_STENCIL_ATTACHMENT_OPTIMAL,
222 _ => {
223 if usage == wgt::TextureUses::PRESENT {
224 vk::ImageLayout::PRESENT_SRC_KHR
225 } else if is_color {
226 vk::ImageLayout::GENERAL
227 } else {
228 vk::ImageLayout::DEPTH_STENCIL_READ_ONLY_OPTIMAL
229 }
230 }
231 }
232}
233
234pub fn map_texture_usage(usage: wgt::TextureUses) -> vk::ImageUsageFlags {
235 let mut flags = vk::ImageUsageFlags::empty();
236 if usage.contains(wgt::TextureUses::COPY_SRC) {
237 flags |= vk::ImageUsageFlags::TRANSFER_SRC;
238 }
239 if usage.contains(wgt::TextureUses::COPY_DST) {
240 flags |= vk::ImageUsageFlags::TRANSFER_DST;
241 }
242 if usage.contains(wgt::TextureUses::RESOURCE) {
243 flags |= vk::ImageUsageFlags::SAMPLED;
244 }
245 if usage.contains(wgt::TextureUses::COLOR_TARGET) {
246 flags |= vk::ImageUsageFlags::COLOR_ATTACHMENT;
247 }
248 if usage
249 .intersects(wgt::TextureUses::DEPTH_STENCIL_READ | wgt::TextureUses::DEPTH_STENCIL_WRITE)
250 {
251 flags |= vk::ImageUsageFlags::DEPTH_STENCIL_ATTACHMENT;
252 }
253 if usage.intersects(
254 wgt::TextureUses::STORAGE_READ_ONLY
255 | wgt::TextureUses::STORAGE_WRITE_ONLY
256 | wgt::TextureUses::STORAGE_READ_WRITE
257 | wgt::TextureUses::STORAGE_ATOMIC,
258 ) {
259 flags |= vk::ImageUsageFlags::STORAGE;
260 }
261 flags
262}
263
264pub fn map_texture_usage_to_barrier(
265 usage: wgt::TextureUses,
266) -> (vk::PipelineStageFlags, vk::AccessFlags) {
267 let mut stages = vk::PipelineStageFlags::empty();
268 let mut access = vk::AccessFlags::empty();
269 let shader_stages = vk::PipelineStageFlags::VERTEX_SHADER
270 | vk::PipelineStageFlags::FRAGMENT_SHADER
271 | vk::PipelineStageFlags::COMPUTE_SHADER;
272
273 if usage.contains(wgt::TextureUses::COPY_SRC) {
274 stages |= vk::PipelineStageFlags::TRANSFER;
275 access |= vk::AccessFlags::TRANSFER_READ;
276 }
277 if usage.contains(wgt::TextureUses::COPY_DST) {
278 stages |= vk::PipelineStageFlags::TRANSFER;
279 access |= vk::AccessFlags::TRANSFER_WRITE;
280 }
281 if usage.contains(wgt::TextureUses::RESOURCE) {
282 stages |= shader_stages;
283 access |= vk::AccessFlags::SHADER_READ;
284 }
285 if usage.contains(wgt::TextureUses::COLOR_TARGET) {
286 stages |= vk::PipelineStageFlags::COLOR_ATTACHMENT_OUTPUT;
287 access |= vk::AccessFlags::COLOR_ATTACHMENT_READ | vk::AccessFlags::COLOR_ATTACHMENT_WRITE;
288 }
289 if usage.intersects(wgt::TextureUses::DEPTH_STENCIL_READ) {
290 stages |= vk::PipelineStageFlags::EARLY_FRAGMENT_TESTS
291 | vk::PipelineStageFlags::LATE_FRAGMENT_TESTS;
292 access |= vk::AccessFlags::DEPTH_STENCIL_ATTACHMENT_READ;
293 }
294 if usage.intersects(wgt::TextureUses::DEPTH_STENCIL_WRITE) {
295 stages |= vk::PipelineStageFlags::EARLY_FRAGMENT_TESTS
296 | vk::PipelineStageFlags::LATE_FRAGMENT_TESTS;
297 access |= vk::AccessFlags::DEPTH_STENCIL_ATTACHMENT_READ
298 | vk::AccessFlags::DEPTH_STENCIL_ATTACHMENT_WRITE;
299 }
300 if usage.intersects(
301 wgt::TextureUses::STORAGE_READ_ONLY
302 | wgt::TextureUses::STORAGE_READ_WRITE
303 | wgt::TextureUses::STORAGE_ATOMIC,
304 ) {
305 stages |= shader_stages;
306 access |= vk::AccessFlags::SHADER_READ;
307 }
308 if usage.intersects(
309 wgt::TextureUses::STORAGE_WRITE_ONLY
310 | wgt::TextureUses::STORAGE_READ_WRITE
311 | wgt::TextureUses::STORAGE_ATOMIC,
312 ) {
313 stages |= shader_stages;
314 access |= vk::AccessFlags::SHADER_WRITE;
315 }
316
317 if usage == wgt::TextureUses::UNINITIALIZED || usage == wgt::TextureUses::PRESENT {
318 (
319 vk::PipelineStageFlags::TOP_OF_PIPE,
320 vk::AccessFlags::empty(),
321 )
322 } else {
323 (stages, access)
324 }
325}
326
327pub fn map_vk_image_usage(usage: vk::ImageUsageFlags) -> wgt::TextureUses {
328 let mut bits = wgt::TextureUses::empty();
329 if usage.contains(vk::ImageUsageFlags::TRANSFER_SRC) {
330 bits |= wgt::TextureUses::COPY_SRC;
331 }
332 if usage.contains(vk::ImageUsageFlags::TRANSFER_DST) {
333 bits |= wgt::TextureUses::COPY_DST;
334 }
335 if usage.contains(vk::ImageUsageFlags::SAMPLED) {
336 bits |= wgt::TextureUses::RESOURCE;
337 }
338 if usage.contains(vk::ImageUsageFlags::COLOR_ATTACHMENT) {
339 bits |= wgt::TextureUses::COLOR_TARGET;
340 }
341 if usage.contains(vk::ImageUsageFlags::DEPTH_STENCIL_ATTACHMENT) {
342 bits |= wgt::TextureUses::DEPTH_STENCIL_READ | wgt::TextureUses::DEPTH_STENCIL_WRITE;
343 }
344 if usage.contains(vk::ImageUsageFlags::STORAGE) {
345 bits |= wgt::TextureUses::STORAGE_READ_ONLY
346 | wgt::TextureUses::STORAGE_WRITE_ONLY
347 | wgt::TextureUses::STORAGE_READ_WRITE
348 | wgt::TextureUses::STORAGE_ATOMIC;
349 }
350 bits
351}
352
353pub fn map_texture_dimension(dim: wgt::TextureDimension) -> vk::ImageType {
354 match dim {
355 wgt::TextureDimension::D1 => vk::ImageType::TYPE_1D,
356 wgt::TextureDimension::D2 => vk::ImageType::TYPE_2D,
357 wgt::TextureDimension::D3 => vk::ImageType::TYPE_3D,
358 }
359}
360
361pub fn map_index_format(index_format: wgt::IndexFormat) -> vk::IndexType {
362 match index_format {
363 wgt::IndexFormat::Uint16 => vk::IndexType::UINT16,
364 wgt::IndexFormat::Uint32 => vk::IndexType::UINT32,
365 }
366}
367
368pub fn map_vertex_format(vertex_format: wgt::VertexFormat) -> vk::Format {
369 use wgt::VertexFormat as Vf;
370 match vertex_format {
371 Vf::Uint8 => vk::Format::R8_UINT,
372 Vf::Uint8x2 => vk::Format::R8G8_UINT,
373 Vf::Uint8x4 => vk::Format::R8G8B8A8_UINT,
374 Vf::Sint8 => vk::Format::R8_SINT,
375 Vf::Sint8x2 => vk::Format::R8G8_SINT,
376 Vf::Sint8x4 => vk::Format::R8G8B8A8_SINT,
377 Vf::Unorm8 => vk::Format::R8_UNORM,
378 Vf::Unorm8x2 => vk::Format::R8G8_UNORM,
379 Vf::Unorm8x4 => vk::Format::R8G8B8A8_UNORM,
380 Vf::Snorm8 => vk::Format::R8_SNORM,
381 Vf::Snorm8x2 => vk::Format::R8G8_SNORM,
382 Vf::Snorm8x4 => vk::Format::R8G8B8A8_SNORM,
383 Vf::Uint16 => vk::Format::R16_UINT,
384 Vf::Uint16x2 => vk::Format::R16G16_UINT,
385 Vf::Uint16x4 => vk::Format::R16G16B16A16_UINT,
386 Vf::Sint16 => vk::Format::R16_SINT,
387 Vf::Sint16x2 => vk::Format::R16G16_SINT,
388 Vf::Sint16x4 => vk::Format::R16G16B16A16_SINT,
389 Vf::Unorm16 => vk::Format::R16_UNORM,
390 Vf::Unorm16x2 => vk::Format::R16G16_UNORM,
391 Vf::Unorm16x4 => vk::Format::R16G16B16A16_UNORM,
392 Vf::Snorm16 => vk::Format::R16_SNORM,
393 Vf::Snorm16x2 => vk::Format::R16G16_SNORM,
394 Vf::Snorm16x4 => vk::Format::R16G16B16A16_SNORM,
395 Vf::Float16 => vk::Format::R16_SFLOAT,
396 Vf::Float16x2 => vk::Format::R16G16_SFLOAT,
397 Vf::Float16x4 => vk::Format::R16G16B16A16_SFLOAT,
398 Vf::Float32 => vk::Format::R32_SFLOAT,
399 Vf::Float32x2 => vk::Format::R32G32_SFLOAT,
400 Vf::Float32x3 => vk::Format::R32G32B32_SFLOAT,
401 Vf::Float32x4 => vk::Format::R32G32B32A32_SFLOAT,
402 Vf::Uint32 => vk::Format::R32_UINT,
403 Vf::Uint32x2 => vk::Format::R32G32_UINT,
404 Vf::Uint32x3 => vk::Format::R32G32B32_UINT,
405 Vf::Uint32x4 => vk::Format::R32G32B32A32_UINT,
406 Vf::Sint32 => vk::Format::R32_SINT,
407 Vf::Sint32x2 => vk::Format::R32G32_SINT,
408 Vf::Sint32x3 => vk::Format::R32G32B32_SINT,
409 Vf::Sint32x4 => vk::Format::R32G32B32A32_SINT,
410 Vf::Float64 => vk::Format::R64_SFLOAT,
411 Vf::Float64x2 => vk::Format::R64G64_SFLOAT,
412 Vf::Float64x3 => vk::Format::R64G64B64_SFLOAT,
413 Vf::Float64x4 => vk::Format::R64G64B64A64_SFLOAT,
414 Vf::Unorm10_10_10_2 => vk::Format::A2B10G10R10_UNORM_PACK32,
415 Vf::Unorm8x4Bgra => vk::Format::B8G8R8A8_UNORM,
416 }
417}
418
419pub fn map_aspects(aspects: crate::FormatAspects) -> vk::ImageAspectFlags {
420 let mut flags = vk::ImageAspectFlags::empty();
421 if aspects.contains(crate::FormatAspects::COLOR) {
422 flags |= vk::ImageAspectFlags::COLOR;
423 }
424 if aspects.contains(crate::FormatAspects::DEPTH) {
425 flags |= vk::ImageAspectFlags::DEPTH;
426 }
427 if aspects.contains(crate::FormatAspects::STENCIL) {
428 flags |= vk::ImageAspectFlags::STENCIL;
429 }
430 if aspects.contains(crate::FormatAspects::PLANE_0) {
431 flags |= vk::ImageAspectFlags::PLANE_0;
432 }
433 if aspects.contains(crate::FormatAspects::PLANE_1) {
434 flags |= vk::ImageAspectFlags::PLANE_1;
435 }
436 if aspects.contains(crate::FormatAspects::PLANE_2) {
437 flags |= vk::ImageAspectFlags::PLANE_2;
438 }
439 flags
440}
441
442pub fn map_attachment_ops(
443 op: crate::AttachmentOps,
444) -> (vk::AttachmentLoadOp, vk::AttachmentStoreOp) {
445 let load_op = if op.contains(crate::AttachmentOps::LOAD) {
446 vk::AttachmentLoadOp::LOAD
447 } else {
448 vk::AttachmentLoadOp::CLEAR
449 };
450 let store_op = if op.contains(crate::AttachmentOps::STORE) {
451 vk::AttachmentStoreOp::STORE
452 } else {
453 vk::AttachmentStoreOp::DONT_CARE
454 };
455 (load_op, store_op)
456}
457
458pub fn map_present_mode(mode: wgt::PresentMode) -> vk::PresentModeKHR {
459 match mode {
460 wgt::PresentMode::Immediate => vk::PresentModeKHR::IMMEDIATE,
461 wgt::PresentMode::Mailbox => vk::PresentModeKHR::MAILBOX,
462 wgt::PresentMode::Fifo => vk::PresentModeKHR::FIFO,
463 wgt::PresentMode::FifoRelaxed => vk::PresentModeKHR::FIFO_RELAXED,
464 wgt::PresentMode::AutoNoVsync | wgt::PresentMode::AutoVsync => {
465 unreachable!("Cannot create swapchain with Auto PresentationMode")
466 }
467 }
468}
469
470pub fn map_vk_present_mode(mode: vk::PresentModeKHR) -> Option<wgt::PresentMode> {
471 const FIFO_LATEST_READY: vk::PresentModeKHR = vk::PresentModeKHR::from_raw(1_000_361_000);
473
474 match mode {
476 vk::PresentModeKHR::IMMEDIATE => Some(wgt::PresentMode::Immediate),
477 vk::PresentModeKHR::MAILBOX => Some(wgt::PresentMode::Mailbox),
478 vk::PresentModeKHR::FIFO => Some(wgt::PresentMode::Fifo),
479 vk::PresentModeKHR::FIFO_RELAXED => Some(wgt::PresentMode::FifoRelaxed),
480
481 vk::PresentModeKHR::SHARED_DEMAND_REFRESH => None,
483 vk::PresentModeKHR::SHARED_CONTINUOUS_REFRESH => None,
484 FIFO_LATEST_READY => None,
485
486 _ => {
487 log::debug!("Unrecognized present mode {mode:?}");
488 None
489 }
490 }
491}
492
493pub fn map_composite_alpha_mode(mode: wgt::CompositeAlphaMode) -> vk::CompositeAlphaFlagsKHR {
494 match mode {
495 wgt::CompositeAlphaMode::Opaque => vk::CompositeAlphaFlagsKHR::OPAQUE,
496 wgt::CompositeAlphaMode::PreMultiplied => vk::CompositeAlphaFlagsKHR::PRE_MULTIPLIED,
497 wgt::CompositeAlphaMode::PostMultiplied => vk::CompositeAlphaFlagsKHR::POST_MULTIPLIED,
498 wgt::CompositeAlphaMode::Inherit => vk::CompositeAlphaFlagsKHR::INHERIT,
499 wgt::CompositeAlphaMode::Auto => unreachable!(),
500 }
501}
502
503pub fn map_vk_composite_alpha(flags: vk::CompositeAlphaFlagsKHR) -> Vec<wgt::CompositeAlphaMode> {
504 let mut modes = Vec::new();
505 if flags.contains(vk::CompositeAlphaFlagsKHR::OPAQUE) {
506 modes.push(wgt::CompositeAlphaMode::Opaque);
507 }
508 if flags.contains(vk::CompositeAlphaFlagsKHR::PRE_MULTIPLIED) {
509 modes.push(wgt::CompositeAlphaMode::PreMultiplied);
510 }
511 if flags.contains(vk::CompositeAlphaFlagsKHR::POST_MULTIPLIED) {
512 modes.push(wgt::CompositeAlphaMode::PostMultiplied);
513 }
514 if flags.contains(vk::CompositeAlphaFlagsKHR::INHERIT) {
515 modes.push(wgt::CompositeAlphaMode::Inherit);
516 }
517 modes
518}
519
520pub fn map_buffer_usage(usage: wgt::BufferUses) -> vk::BufferUsageFlags {
521 let mut flags = vk::BufferUsageFlags::empty();
522 if usage.contains(wgt::BufferUses::COPY_SRC) {
523 flags |= vk::BufferUsageFlags::TRANSFER_SRC;
524 }
525 if usage.contains(wgt::BufferUses::COPY_DST) {
526 flags |= vk::BufferUsageFlags::TRANSFER_DST;
527 }
528 if usage.contains(wgt::BufferUses::UNIFORM) {
529 flags |= vk::BufferUsageFlags::UNIFORM_BUFFER;
530 }
531 if usage.intersects(wgt::BufferUses::STORAGE_READ_ONLY | wgt::BufferUses::STORAGE_READ_WRITE) {
532 flags |= vk::BufferUsageFlags::STORAGE_BUFFER;
533 }
534 if usage.contains(wgt::BufferUses::INDEX) {
535 flags |= vk::BufferUsageFlags::INDEX_BUFFER;
536 }
537 if usage.contains(wgt::BufferUses::VERTEX) {
538 flags |= vk::BufferUsageFlags::VERTEX_BUFFER;
539 }
540 if usage.contains(wgt::BufferUses::INDIRECT) {
541 flags |= vk::BufferUsageFlags::INDIRECT_BUFFER;
542 }
543 if usage.contains(wgt::BufferUses::ACCELERATION_STRUCTURE_SCRATCH) {
544 flags |= vk::BufferUsageFlags::STORAGE_BUFFER | vk::BufferUsageFlags::SHADER_DEVICE_ADDRESS;
545 }
546 if usage.intersects(
547 wgt::BufferUses::BOTTOM_LEVEL_ACCELERATION_STRUCTURE_INPUT
548 | wgt::BufferUses::TOP_LEVEL_ACCELERATION_STRUCTURE_INPUT,
549 ) {
550 flags |= vk::BufferUsageFlags::ACCELERATION_STRUCTURE_BUILD_INPUT_READ_ONLY_KHR
551 | vk::BufferUsageFlags::SHADER_DEVICE_ADDRESS;
552 }
553 if usage.intersects(wgt::BufferUses::ACCELERATION_STRUCTURE_QUERY) {
554 flags |= vk::BufferUsageFlags::TRANSFER_DST;
555 }
556 flags
557}
558
559pub fn map_buffer_usage_to_barrier(
560 usage: wgt::BufferUses,
561) -> (vk::PipelineStageFlags, vk::AccessFlags) {
562 let mut stages = vk::PipelineStageFlags::empty();
563 let mut access = vk::AccessFlags::empty();
564 let shader_stages = vk::PipelineStageFlags::VERTEX_SHADER
565 | vk::PipelineStageFlags::FRAGMENT_SHADER
566 | vk::PipelineStageFlags::COMPUTE_SHADER;
567
568 if usage.contains(wgt::BufferUses::MAP_READ) {
569 stages |= vk::PipelineStageFlags::HOST;
570 access |= vk::AccessFlags::HOST_READ;
571 }
572 if usage.contains(wgt::BufferUses::MAP_WRITE) {
573 stages |= vk::PipelineStageFlags::HOST;
574 access |= vk::AccessFlags::HOST_WRITE;
575 }
576 if usage.contains(wgt::BufferUses::COPY_SRC) {
577 stages |= vk::PipelineStageFlags::TRANSFER;
578 access |= vk::AccessFlags::TRANSFER_READ;
579 }
580 if usage.contains(wgt::BufferUses::COPY_DST) {
581 stages |= vk::PipelineStageFlags::TRANSFER;
582 access |= vk::AccessFlags::TRANSFER_WRITE;
583 }
584 if usage.contains(wgt::BufferUses::UNIFORM) {
585 stages |= shader_stages;
586 access |= vk::AccessFlags::UNIFORM_READ;
587 }
588 if usage.intersects(wgt::BufferUses::STORAGE_READ_ONLY) {
589 stages |= shader_stages;
590 access |= vk::AccessFlags::SHADER_READ;
591 }
592 if usage.intersects(wgt::BufferUses::STORAGE_READ_WRITE) {
593 stages |= shader_stages;
594 access |= vk::AccessFlags::SHADER_READ | vk::AccessFlags::SHADER_WRITE;
595 }
596 if usage.contains(wgt::BufferUses::INDEX) {
597 stages |= vk::PipelineStageFlags::VERTEX_INPUT;
598 access |= vk::AccessFlags::INDEX_READ;
599 }
600 if usage.contains(wgt::BufferUses::VERTEX) {
601 stages |= vk::PipelineStageFlags::VERTEX_INPUT;
602 access |= vk::AccessFlags::VERTEX_ATTRIBUTE_READ;
603 }
604 if usage.contains(wgt::BufferUses::INDIRECT) {
605 stages |= vk::PipelineStageFlags::DRAW_INDIRECT;
606 access |= vk::AccessFlags::INDIRECT_COMMAND_READ;
607 }
608 if usage.intersects(
609 wgt::BufferUses::BOTTOM_LEVEL_ACCELERATION_STRUCTURE_INPUT
610 | wgt::BufferUses::TOP_LEVEL_ACCELERATION_STRUCTURE_INPUT
611 | wgt::BufferUses::ACCELERATION_STRUCTURE_SCRATCH,
612 ) {
613 stages |= vk::PipelineStageFlags::ACCELERATION_STRUCTURE_BUILD_KHR;
614 access |= vk::AccessFlags::ACCELERATION_STRUCTURE_READ_KHR
615 | vk::AccessFlags::ACCELERATION_STRUCTURE_WRITE_KHR
616 | vk::AccessFlags::SHADER_READ;
617 }
618 if usage.contains(wgt::BufferUses::ACCELERATION_STRUCTURE_QUERY) {
619 stages |= vk::PipelineStageFlags::TRANSFER;
620 access |= vk::AccessFlags::TRANSFER_WRITE;
621 }
622
623 (stages, access)
624}
625
626pub fn map_view_dimension(dim: wgt::TextureViewDimension) -> vk::ImageViewType {
627 match dim {
628 wgt::TextureViewDimension::D1 => vk::ImageViewType::TYPE_1D,
629 wgt::TextureViewDimension::D2 => vk::ImageViewType::TYPE_2D,
630 wgt::TextureViewDimension::D2Array => vk::ImageViewType::TYPE_2D_ARRAY,
631 wgt::TextureViewDimension::Cube => vk::ImageViewType::CUBE,
632 wgt::TextureViewDimension::CubeArray => vk::ImageViewType::CUBE_ARRAY,
633 wgt::TextureViewDimension::D3 => vk::ImageViewType::TYPE_3D,
634 }
635}
636
637pub fn map_copy_extent(extent: &crate::CopyExtent) -> vk::Extent3D {
638 vk::Extent3D {
639 width: extent.width,
640 height: extent.height,
641 depth: extent.depth,
642 }
643}
644
645pub fn map_subresource_range(
646 range: &wgt::ImageSubresourceRange,
647 format: wgt::TextureFormat,
648) -> vk::ImageSubresourceRange {
649 vk::ImageSubresourceRange {
650 aspect_mask: map_aspects(crate::FormatAspects::new(format, range.aspect)),
651 base_mip_level: range.base_mip_level,
652 level_count: range.mip_level_count.unwrap_or(vk::REMAINING_MIP_LEVELS),
653 base_array_layer: range.base_array_layer,
654 layer_count: range
655 .array_layer_count
656 .unwrap_or(vk::REMAINING_ARRAY_LAYERS),
657 }
658}
659
660pub(super) fn map_subresource_range_combined_aspect(
663 range: &wgt::ImageSubresourceRange,
664 format: wgt::TextureFormat,
665 private_caps: &super::PrivateCapabilities,
666) -> vk::ImageSubresourceRange {
667 let mut range = map_subresource_range(range, format);
668 if !private_caps.texture_s8 && format == wgt::TextureFormat::Stencil8 {
669 range.aspect_mask |= vk::ImageAspectFlags::DEPTH;
670 }
671 range
672}
673
674pub fn map_subresource_layers(
675 base: &crate::TextureCopyBase,
676) -> (vk::ImageSubresourceLayers, vk::Offset3D) {
677 let offset = vk::Offset3D {
678 x: base.origin.x as i32,
679 y: base.origin.y as i32,
680 z: base.origin.z as i32,
681 };
682 let subresource = vk::ImageSubresourceLayers {
683 aspect_mask: map_aspects(base.aspect),
684 mip_level: base.mip_level,
685 base_array_layer: base.array_layer,
686 layer_count: 1,
687 };
688 (subresource, offset)
689}
690
691pub fn map_filter_mode(mode: wgt::FilterMode) -> vk::Filter {
692 match mode {
693 wgt::FilterMode::Nearest => vk::Filter::NEAREST,
694 wgt::FilterMode::Linear => vk::Filter::LINEAR,
695 }
696}
697
698pub fn map_mip_filter_mode(mode: wgt::FilterMode) -> vk::SamplerMipmapMode {
699 match mode {
700 wgt::FilterMode::Nearest => vk::SamplerMipmapMode::NEAREST,
701 wgt::FilterMode::Linear => vk::SamplerMipmapMode::LINEAR,
702 }
703}
704
705pub fn map_address_mode(mode: wgt::AddressMode) -> vk::SamplerAddressMode {
706 match mode {
707 wgt::AddressMode::ClampToEdge => vk::SamplerAddressMode::CLAMP_TO_EDGE,
708 wgt::AddressMode::Repeat => vk::SamplerAddressMode::REPEAT,
709 wgt::AddressMode::MirrorRepeat => vk::SamplerAddressMode::MIRRORED_REPEAT,
710 wgt::AddressMode::ClampToBorder => vk::SamplerAddressMode::CLAMP_TO_BORDER,
711 }
713}
714
715pub fn map_border_color(border_color: wgt::SamplerBorderColor) -> vk::BorderColor {
716 match border_color {
717 wgt::SamplerBorderColor::TransparentBlack | wgt::SamplerBorderColor::Zero => {
718 vk::BorderColor::FLOAT_TRANSPARENT_BLACK
719 }
720 wgt::SamplerBorderColor::OpaqueBlack => vk::BorderColor::FLOAT_OPAQUE_BLACK,
721 wgt::SamplerBorderColor::OpaqueWhite => vk::BorderColor::FLOAT_OPAQUE_WHITE,
722 }
723}
724
725pub fn map_comparison(fun: wgt::CompareFunction) -> vk::CompareOp {
726 use wgt::CompareFunction as Cf;
727 match fun {
728 Cf::Never => vk::CompareOp::NEVER,
729 Cf::Less => vk::CompareOp::LESS,
730 Cf::LessEqual => vk::CompareOp::LESS_OR_EQUAL,
731 Cf::Equal => vk::CompareOp::EQUAL,
732 Cf::GreaterEqual => vk::CompareOp::GREATER_OR_EQUAL,
733 Cf::Greater => vk::CompareOp::GREATER,
734 Cf::NotEqual => vk::CompareOp::NOT_EQUAL,
735 Cf::Always => vk::CompareOp::ALWAYS,
736 }
737}
738
739pub fn map_shader_stage(stage: wgt::ShaderStages) -> vk::ShaderStageFlags {
740 let mut flags = vk::ShaderStageFlags::empty();
741 if stage.contains(wgt::ShaderStages::VERTEX) {
742 flags |= vk::ShaderStageFlags::VERTEX;
743 }
744 if stage.contains(wgt::ShaderStages::FRAGMENT) {
745 flags |= vk::ShaderStageFlags::FRAGMENT;
746 }
747 if stage.contains(wgt::ShaderStages::COMPUTE) {
748 flags |= vk::ShaderStageFlags::COMPUTE;
749 }
750 flags
751}
752
753pub fn map_binding_type(ty: wgt::BindingType) -> vk::DescriptorType {
754 match ty {
755 wgt::BindingType::Buffer {
756 ty,
757 has_dynamic_offset,
758 ..
759 } => match ty {
760 wgt::BufferBindingType::Storage { .. } => match has_dynamic_offset {
761 true => vk::DescriptorType::STORAGE_BUFFER_DYNAMIC,
762 false => vk::DescriptorType::STORAGE_BUFFER,
763 },
764 wgt::BufferBindingType::Uniform => match has_dynamic_offset {
765 true => vk::DescriptorType::UNIFORM_BUFFER_DYNAMIC,
766 false => vk::DescriptorType::UNIFORM_BUFFER,
767 },
768 },
769 wgt::BindingType::Sampler { .. } => vk::DescriptorType::SAMPLER,
770 wgt::BindingType::Texture { .. } => vk::DescriptorType::SAMPLED_IMAGE,
771 wgt::BindingType::StorageTexture { .. } => vk::DescriptorType::STORAGE_IMAGE,
772 wgt::BindingType::AccelerationStructure { .. } => {
773 vk::DescriptorType::ACCELERATION_STRUCTURE_KHR
774 }
775 wgt::BindingType::ExternalTexture => unimplemented!(),
776 }
777}
778
779pub fn map_topology(topology: wgt::PrimitiveTopology) -> vk::PrimitiveTopology {
780 use wgt::PrimitiveTopology as Pt;
781 match topology {
782 Pt::PointList => vk::PrimitiveTopology::POINT_LIST,
783 Pt::LineList => vk::PrimitiveTopology::LINE_LIST,
784 Pt::LineStrip => vk::PrimitiveTopology::LINE_STRIP,
785 Pt::TriangleList => vk::PrimitiveTopology::TRIANGLE_LIST,
786 Pt::TriangleStrip => vk::PrimitiveTopology::TRIANGLE_STRIP,
787 }
788}
789
790pub fn map_polygon_mode(mode: wgt::PolygonMode) -> vk::PolygonMode {
791 match mode {
792 wgt::PolygonMode::Fill => vk::PolygonMode::FILL,
793 wgt::PolygonMode::Line => vk::PolygonMode::LINE,
794 wgt::PolygonMode::Point => vk::PolygonMode::POINT,
795 }
796}
797
798pub fn map_front_face(front_face: wgt::FrontFace) -> vk::FrontFace {
799 match front_face {
800 wgt::FrontFace::Cw => vk::FrontFace::CLOCKWISE,
801 wgt::FrontFace::Ccw => vk::FrontFace::COUNTER_CLOCKWISE,
802 }
803}
804
805pub fn map_cull_face(face: wgt::Face) -> vk::CullModeFlags {
806 match face {
807 wgt::Face::Front => vk::CullModeFlags::FRONT,
808 wgt::Face::Back => vk::CullModeFlags::BACK,
809 }
810}
811
812pub fn map_stencil_op(op: wgt::StencilOperation) -> vk::StencilOp {
813 use wgt::StencilOperation as So;
814 match op {
815 So::Keep => vk::StencilOp::KEEP,
816 So::Zero => vk::StencilOp::ZERO,
817 So::Replace => vk::StencilOp::REPLACE,
818 So::Invert => vk::StencilOp::INVERT,
819 So::IncrementClamp => vk::StencilOp::INCREMENT_AND_CLAMP,
820 So::IncrementWrap => vk::StencilOp::INCREMENT_AND_WRAP,
821 So::DecrementClamp => vk::StencilOp::DECREMENT_AND_CLAMP,
822 So::DecrementWrap => vk::StencilOp::DECREMENT_AND_WRAP,
823 }
824}
825
826pub fn map_stencil_face(
827 face: &wgt::StencilFaceState,
828 compare_mask: u32,
829 write_mask: u32,
830) -> vk::StencilOpState {
831 vk::StencilOpState {
832 fail_op: map_stencil_op(face.fail_op),
833 pass_op: map_stencil_op(face.pass_op),
834 depth_fail_op: map_stencil_op(face.depth_fail_op),
835 compare_op: map_comparison(face.compare),
836 compare_mask,
837 write_mask,
838 reference: 0,
839 }
840}
841
842fn map_blend_factor(factor: wgt::BlendFactor) -> vk::BlendFactor {
843 use wgt::BlendFactor as Bf;
844 match factor {
845 Bf::Zero => vk::BlendFactor::ZERO,
846 Bf::One => vk::BlendFactor::ONE,
847 Bf::Src => vk::BlendFactor::SRC_COLOR,
848 Bf::OneMinusSrc => vk::BlendFactor::ONE_MINUS_SRC_COLOR,
849 Bf::SrcAlpha => vk::BlendFactor::SRC_ALPHA,
850 Bf::OneMinusSrcAlpha => vk::BlendFactor::ONE_MINUS_SRC_ALPHA,
851 Bf::Dst => vk::BlendFactor::DST_COLOR,
852 Bf::OneMinusDst => vk::BlendFactor::ONE_MINUS_DST_COLOR,
853 Bf::DstAlpha => vk::BlendFactor::DST_ALPHA,
854 Bf::OneMinusDstAlpha => vk::BlendFactor::ONE_MINUS_DST_ALPHA,
855 Bf::SrcAlphaSaturated => vk::BlendFactor::SRC_ALPHA_SATURATE,
856 Bf::Constant => vk::BlendFactor::CONSTANT_COLOR,
857 Bf::OneMinusConstant => vk::BlendFactor::ONE_MINUS_CONSTANT_COLOR,
858 Bf::Src1 => vk::BlendFactor::SRC1_COLOR,
859 Bf::OneMinusSrc1 => vk::BlendFactor::ONE_MINUS_SRC1_COLOR,
860 Bf::Src1Alpha => vk::BlendFactor::SRC1_ALPHA,
861 Bf::OneMinusSrc1Alpha => vk::BlendFactor::ONE_MINUS_SRC1_ALPHA,
862 }
863}
864
865fn map_blend_op(operation: wgt::BlendOperation) -> vk::BlendOp {
866 use wgt::BlendOperation as Bo;
867 match operation {
868 Bo::Add => vk::BlendOp::ADD,
869 Bo::Subtract => vk::BlendOp::SUBTRACT,
870 Bo::ReverseSubtract => vk::BlendOp::REVERSE_SUBTRACT,
871 Bo::Min => vk::BlendOp::MIN,
872 Bo::Max => vk::BlendOp::MAX,
873 }
874}
875
876pub fn map_blend_component(
877 component: &wgt::BlendComponent,
878) -> (vk::BlendOp, vk::BlendFactor, vk::BlendFactor) {
879 let op = map_blend_op(component.operation);
880 let src = map_blend_factor(component.src_factor);
881 let dst = map_blend_factor(component.dst_factor);
882 (op, src, dst)
883}
884
885pub fn map_pipeline_statistics(
886 types: wgt::PipelineStatisticsTypes,
887) -> vk::QueryPipelineStatisticFlags {
888 use wgt::PipelineStatisticsTypes as Pst;
889 let mut flags = vk::QueryPipelineStatisticFlags::empty();
890 if types.contains(Pst::VERTEX_SHADER_INVOCATIONS) {
891 flags |= vk::QueryPipelineStatisticFlags::VERTEX_SHADER_INVOCATIONS;
892 }
893 if types.contains(Pst::CLIPPER_INVOCATIONS) {
894 flags |= vk::QueryPipelineStatisticFlags::CLIPPING_INVOCATIONS;
895 }
896 if types.contains(Pst::CLIPPER_PRIMITIVES_OUT) {
897 flags |= vk::QueryPipelineStatisticFlags::CLIPPING_PRIMITIVES;
898 }
899 if types.contains(Pst::FRAGMENT_SHADER_INVOCATIONS) {
900 flags |= vk::QueryPipelineStatisticFlags::FRAGMENT_SHADER_INVOCATIONS;
901 }
902 if types.contains(Pst::COMPUTE_SHADER_INVOCATIONS) {
903 flags |= vk::QueryPipelineStatisticFlags::COMPUTE_SHADER_INVOCATIONS;
904 }
905 flags
906}
907
908pub fn map_acceleration_structure_format(
909 format: crate::AccelerationStructureFormat,
910) -> vk::AccelerationStructureTypeKHR {
911 match format {
912 crate::AccelerationStructureFormat::TopLevel => vk::AccelerationStructureTypeKHR::TOP_LEVEL,
913 crate::AccelerationStructureFormat::BottomLevel => {
914 vk::AccelerationStructureTypeKHR::BOTTOM_LEVEL
915 }
916 }
917}
918
919pub fn map_acceleration_structure_build_mode(
920 format: crate::AccelerationStructureBuildMode,
921) -> vk::BuildAccelerationStructureModeKHR {
922 match format {
923 crate::AccelerationStructureBuildMode::Build => {
924 vk::BuildAccelerationStructureModeKHR::BUILD
925 }
926 crate::AccelerationStructureBuildMode::Update => {
927 vk::BuildAccelerationStructureModeKHR::UPDATE
928 }
929 }
930}
931
932pub fn map_acceleration_structure_flags(
933 flags: crate::AccelerationStructureBuildFlags,
934) -> vk::BuildAccelerationStructureFlagsKHR {
935 let mut vk_flags = vk::BuildAccelerationStructureFlagsKHR::empty();
936
937 if flags.contains(crate::AccelerationStructureBuildFlags::PREFER_FAST_TRACE) {
938 vk_flags |= vk::BuildAccelerationStructureFlagsKHR::PREFER_FAST_TRACE;
939 }
940
941 if flags.contains(crate::AccelerationStructureBuildFlags::PREFER_FAST_BUILD) {
942 vk_flags |= vk::BuildAccelerationStructureFlagsKHR::PREFER_FAST_BUILD;
943 }
944
945 if flags.contains(crate::AccelerationStructureBuildFlags::ALLOW_UPDATE) {
946 vk_flags |= vk::BuildAccelerationStructureFlagsKHR::ALLOW_UPDATE;
947 }
948
949 if flags.contains(crate::AccelerationStructureBuildFlags::LOW_MEMORY) {
950 vk_flags |= vk::BuildAccelerationStructureFlagsKHR::LOW_MEMORY;
951 }
952
953 if flags.contains(crate::AccelerationStructureBuildFlags::ALLOW_COMPACTION) {
954 vk_flags |= vk::BuildAccelerationStructureFlagsKHR::ALLOW_COMPACTION
955 }
956
957 if flags.contains(crate::AccelerationStructureBuildFlags::ALLOW_RAY_HIT_VERTEX_RETURN) {
958 vk_flags |= vk::BuildAccelerationStructureFlagsKHR::ALLOW_DATA_ACCESS
959 }
960
961 vk_flags
962}
963
964pub fn map_acceleration_structure_geometry_flags(
965 flags: crate::AccelerationStructureGeometryFlags,
966) -> vk::GeometryFlagsKHR {
967 let mut vk_flags = vk::GeometryFlagsKHR::empty();
968
969 if flags.contains(crate::AccelerationStructureGeometryFlags::OPAQUE) {
970 vk_flags |= vk::GeometryFlagsKHR::OPAQUE;
971 }
972
973 if flags.contains(crate::AccelerationStructureGeometryFlags::NO_DUPLICATE_ANY_HIT_INVOCATION) {
974 vk_flags |= vk::GeometryFlagsKHR::NO_DUPLICATE_ANY_HIT_INVOCATION;
975 }
976
977 vk_flags
978}
979
980pub fn map_acceleration_structure_usage_to_barrier(
981 usage: crate::AccelerationStructureUses,
982 features: wgt::Features,
983) -> (vk::PipelineStageFlags, vk::AccessFlags) {
984 let mut stages = vk::PipelineStageFlags::empty();
985 let mut access = vk::AccessFlags::empty();
986
987 if usage.contains(crate::AccelerationStructureUses::BUILD_INPUT) {
988 stages |= vk::PipelineStageFlags::ACCELERATION_STRUCTURE_BUILD_KHR;
989 access |= vk::AccessFlags::ACCELERATION_STRUCTURE_READ_KHR;
990 }
991 if usage.contains(crate::AccelerationStructureUses::QUERY_INPUT) {
992 stages |= vk::PipelineStageFlags::ACCELERATION_STRUCTURE_BUILD_KHR;
993 access |= vk::AccessFlags::ACCELERATION_STRUCTURE_READ_KHR;
994 }
995 if usage.contains(crate::AccelerationStructureUses::BUILD_OUTPUT) {
996 stages |= vk::PipelineStageFlags::ACCELERATION_STRUCTURE_BUILD_KHR;
997 access |= vk::AccessFlags::ACCELERATION_STRUCTURE_WRITE_KHR;
998 }
999 if usage.contains(crate::AccelerationStructureUses::SHADER_INPUT)
1000 && features.contains(wgt::Features::EXPERIMENTAL_RAY_QUERY)
1001 {
1002 stages |= vk::PipelineStageFlags::VERTEX_SHADER
1003 | vk::PipelineStageFlags::FRAGMENT_SHADER
1004 | vk::PipelineStageFlags::COMPUTE_SHADER;
1005 access |= vk::AccessFlags::ACCELERATION_STRUCTURE_READ_KHR;
1006 }
1007 if usage.contains(crate::AccelerationStructureUses::COPY_SRC) {
1008 stages |= vk::PipelineStageFlags::ACCELERATION_STRUCTURE_BUILD_KHR;
1009 access |= vk::AccessFlags::ACCELERATION_STRUCTURE_READ_KHR;
1010 }
1011 if usage.contains(crate::AccelerationStructureUses::COPY_DST) {
1012 stages |= vk::PipelineStageFlags::ACCELERATION_STRUCTURE_BUILD_KHR;
1013 access |= vk::AccessFlags::ACCELERATION_STRUCTURE_WRITE_KHR;
1014 }
1015
1016 (stages, access)
1017}