1 use crate::native as n;
2
3 use ash::vk;
4
5 use hal::{
6 buffer, command, format, image, memory,
7 memory::Segment,
8 pass, pso, query,
9 window::{CompositeAlphaMode, PresentMode},
10 IndexType,
11 };
12
13 use std::mem;
14
map_format(format: format::Format) -> vk::Format15 pub fn map_format(format: format::Format) -> vk::Format {
16 vk::Format::from_raw(format as i32)
17 }
18
map_vk_format(vk_format: vk::Format) -> Option<format::Format>19 pub fn map_vk_format(vk_format: vk::Format) -> Option<format::Format> {
20 if (vk_format.as_raw() as usize) < format::NUM_FORMATS && vk_format != vk::Format::UNDEFINED {
21 Some(unsafe { mem::transmute(vk_format) })
22 } else {
23 None
24 }
25 }
26
map_tiling(tiling: image::Tiling) -> vk::ImageTiling27 pub fn map_tiling(tiling: image::Tiling) -> vk::ImageTiling {
28 vk::ImageTiling::from_raw(tiling as i32)
29 }
30
map_component(component: format::Component) -> vk::ComponentSwizzle31 pub fn map_component(component: format::Component) -> vk::ComponentSwizzle {
32 use hal::format::Component::*;
33 match component {
34 Zero => vk::ComponentSwizzle::ZERO,
35 One => vk::ComponentSwizzle::ONE,
36 R => vk::ComponentSwizzle::R,
37 G => vk::ComponentSwizzle::G,
38 B => vk::ComponentSwizzle::B,
39 A => vk::ComponentSwizzle::A,
40 }
41 }
42
map_swizzle(swizzle: format::Swizzle) -> vk::ComponentMapping43 pub fn map_swizzle(swizzle: format::Swizzle) -> vk::ComponentMapping {
44 vk::ComponentMapping {
45 r: map_component(swizzle.0),
46 g: map_component(swizzle.1),
47 b: map_component(swizzle.2),
48 a: map_component(swizzle.3),
49 }
50 }
51
map_index_type(index_type: IndexType) -> vk::IndexType52 pub fn map_index_type(index_type: IndexType) -> vk::IndexType {
53 match index_type {
54 IndexType::U16 => vk::IndexType::UINT16,
55 IndexType::U32 => vk::IndexType::UINT32,
56 }
57 }
58
map_image_layout(layout: image::Layout) -> vk::ImageLayout59 pub fn map_image_layout(layout: image::Layout) -> vk::ImageLayout {
60 use hal::image::Layout as Il;
61 match layout {
62 Il::General => vk::ImageLayout::GENERAL,
63 Il::ColorAttachmentOptimal => vk::ImageLayout::COLOR_ATTACHMENT_OPTIMAL,
64 Il::DepthStencilAttachmentOptimal => vk::ImageLayout::DEPTH_STENCIL_ATTACHMENT_OPTIMAL,
65 Il::DepthStencilReadOnlyOptimal => vk::ImageLayout::DEPTH_STENCIL_READ_ONLY_OPTIMAL,
66 Il::ShaderReadOnlyOptimal => vk::ImageLayout::SHADER_READ_ONLY_OPTIMAL,
67 Il::TransferSrcOptimal => vk::ImageLayout::TRANSFER_SRC_OPTIMAL,
68 Il::TransferDstOptimal => vk::ImageLayout::TRANSFER_DST_OPTIMAL,
69 Il::Undefined => vk::ImageLayout::UNDEFINED,
70 Il::Preinitialized => vk::ImageLayout::PREINITIALIZED,
71 Il::Present => vk::ImageLayout::PRESENT_SRC_KHR,
72 }
73 }
74
map_image_aspects(aspects: format::Aspects) -> vk::ImageAspectFlags75 pub fn map_image_aspects(aspects: format::Aspects) -> vk::ImageAspectFlags {
76 vk::ImageAspectFlags::from_raw(aspects.bits() as u32)
77 }
78
map_offset(offset: image::Offset) -> vk::Offset3D79 pub fn map_offset(offset: image::Offset) -> vk::Offset3D {
80 vk::Offset3D {
81 x: offset.x,
82 y: offset.y,
83 z: offset.z,
84 }
85 }
86
map_extent(offset: image::Extent) -> vk::Extent3D87 pub fn map_extent(offset: image::Extent) -> vk::Extent3D {
88 vk::Extent3D {
89 width: offset.width,
90 height: offset.height,
91 depth: offset.depth,
92 }
93 }
94
map_subresource(sub: &image::Subresource) -> vk::ImageSubresource95 pub fn map_subresource(sub: &image::Subresource) -> vk::ImageSubresource {
96 vk::ImageSubresource {
97 aspect_mask: map_image_aspects(sub.aspects),
98 mip_level: sub.level as _,
99 array_layer: sub.layer as _,
100 }
101 }
102
map_subresource_layers(sub: &image::SubresourceLayers) -> vk::ImageSubresourceLayers103 pub fn map_subresource_layers(sub: &image::SubresourceLayers) -> vk::ImageSubresourceLayers {
104 vk::ImageSubresourceLayers {
105 aspect_mask: map_image_aspects(sub.aspects),
106 mip_level: sub.level as _,
107 base_array_layer: sub.layers.start as _,
108 layer_count: (sub.layers.end - sub.layers.start) as _,
109 }
110 }
111
map_subresource_range(range: &image::SubresourceRange) -> vk::ImageSubresourceRange112 pub fn map_subresource_range(range: &image::SubresourceRange) -> vk::ImageSubresourceRange {
113 vk::ImageSubresourceRange {
114 aspect_mask: map_image_aspects(range.aspects),
115 base_mip_level: range.level_start as _,
116 level_count: range
117 .level_count
118 .map_or(vk::REMAINING_MIP_LEVELS, |c| c as _),
119 base_array_layer: range.layer_start as _,
120 layer_count: range
121 .layer_count
122 .map_or(vk::REMAINING_ARRAY_LAYERS, |c| c as _),
123 }
124 }
125
map_attachment_load_op(op: pass::AttachmentLoadOp) -> vk::AttachmentLoadOp126 pub fn map_attachment_load_op(op: pass::AttachmentLoadOp) -> vk::AttachmentLoadOp {
127 use hal::pass::AttachmentLoadOp as Alo;
128 match op {
129 Alo::Load => vk::AttachmentLoadOp::LOAD,
130 Alo::Clear => vk::AttachmentLoadOp::CLEAR,
131 Alo::DontCare => vk::AttachmentLoadOp::DONT_CARE,
132 }
133 }
134
map_attachment_store_op(op: pass::AttachmentStoreOp) -> vk::AttachmentStoreOp135 pub fn map_attachment_store_op(op: pass::AttachmentStoreOp) -> vk::AttachmentStoreOp {
136 use hal::pass::AttachmentStoreOp as Aso;
137 match op {
138 Aso::Store => vk::AttachmentStoreOp::STORE,
139 Aso::DontCare => vk::AttachmentStoreOp::DONT_CARE,
140 }
141 }
142
map_buffer_access(access: buffer::Access) -> vk::AccessFlags143 pub fn map_buffer_access(access: buffer::Access) -> vk::AccessFlags {
144 vk::AccessFlags::from_raw(access.bits())
145 }
146
map_image_access(access: image::Access) -> vk::AccessFlags147 pub fn map_image_access(access: image::Access) -> vk::AccessFlags {
148 vk::AccessFlags::from_raw(access.bits())
149 }
150
map_pipeline_stage(stage: pso::PipelineStage) -> vk::PipelineStageFlags151 pub fn map_pipeline_stage(stage: pso::PipelineStage) -> vk::PipelineStageFlags {
152 vk::PipelineStageFlags::from_raw(stage.bits())
153 }
154
map_buffer_usage(usage: buffer::Usage) -> vk::BufferUsageFlags155 pub fn map_buffer_usage(usage: buffer::Usage) -> vk::BufferUsageFlags {
156 vk::BufferUsageFlags::from_raw(usage.bits())
157 }
158
map_buffer_create_flags(sparse: memory::SparseFlags) -> vk::BufferCreateFlags159 pub fn map_buffer_create_flags(sparse: memory::SparseFlags) -> vk::BufferCreateFlags {
160 vk::BufferCreateFlags::from_raw(sparse.bits())
161 }
162
map_image_usage(usage: image::Usage) -> vk::ImageUsageFlags163 pub fn map_image_usage(usage: image::Usage) -> vk::ImageUsageFlags {
164 vk::ImageUsageFlags::from_raw(usage.bits())
165 }
166
map_vk_image_usage(usage: vk::ImageUsageFlags) -> image::Usage167 pub fn map_vk_image_usage(usage: vk::ImageUsageFlags) -> image::Usage {
168 image::Usage::from_bits_truncate(usage.as_raw())
169 }
170
map_descriptor_type(ty: pso::DescriptorType) -> vk::DescriptorType171 pub fn map_descriptor_type(ty: pso::DescriptorType) -> vk::DescriptorType {
172 match ty {
173 pso::DescriptorType::Sampler => vk::DescriptorType::SAMPLER,
174 pso::DescriptorType::Image { ty } => match ty {
175 pso::ImageDescriptorType::Sampled { with_sampler } => match with_sampler {
176 true => vk::DescriptorType::COMBINED_IMAGE_SAMPLER,
177 false => vk::DescriptorType::SAMPLED_IMAGE,
178 },
179 pso::ImageDescriptorType::Storage { .. } => vk::DescriptorType::STORAGE_IMAGE,
180 },
181 pso::DescriptorType::Buffer { ty, format } => match ty {
182 pso::BufferDescriptorType::Storage { .. } => match format {
183 pso::BufferDescriptorFormat::Structured { dynamic_offset } => {
184 match dynamic_offset {
185 true => vk::DescriptorType::STORAGE_BUFFER_DYNAMIC,
186 false => vk::DescriptorType::STORAGE_BUFFER,
187 }
188 }
189 pso::BufferDescriptorFormat::Texel => vk::DescriptorType::STORAGE_TEXEL_BUFFER,
190 },
191 pso::BufferDescriptorType::Uniform => match format {
192 pso::BufferDescriptorFormat::Structured { dynamic_offset } => {
193 match dynamic_offset {
194 true => vk::DescriptorType::UNIFORM_BUFFER_DYNAMIC,
195 false => vk::DescriptorType::UNIFORM_BUFFER,
196 }
197 }
198 pso::BufferDescriptorFormat::Texel => vk::DescriptorType::UNIFORM_TEXEL_BUFFER,
199 },
200 },
201 pso::DescriptorType::InputAttachment => vk::DescriptorType::INPUT_ATTACHMENT,
202 }
203 }
204
map_stage_flags(stages: pso::ShaderStageFlags) -> vk::ShaderStageFlags205 pub fn map_stage_flags(stages: pso::ShaderStageFlags) -> vk::ShaderStageFlags {
206 vk::ShaderStageFlags::from_raw(stages.bits())
207 }
208
map_filter(filter: image::Filter) -> vk::Filter209 pub fn map_filter(filter: image::Filter) -> vk::Filter {
210 vk::Filter::from_raw(filter as i32)
211 }
212
map_mip_filter(filter: image::Filter) -> vk::SamplerMipmapMode213 pub fn map_mip_filter(filter: image::Filter) -> vk::SamplerMipmapMode {
214 vk::SamplerMipmapMode::from_raw(filter as i32)
215 }
216
map_wrap(wrap: image::WrapMode) -> vk::SamplerAddressMode217 pub fn map_wrap(wrap: image::WrapMode) -> vk::SamplerAddressMode {
218 use hal::image::WrapMode as Wm;
219 match wrap {
220 Wm::Tile => vk::SamplerAddressMode::REPEAT,
221 Wm::Mirror => vk::SamplerAddressMode::MIRRORED_REPEAT,
222 Wm::Clamp => vk::SamplerAddressMode::CLAMP_TO_EDGE,
223 Wm::Border => vk::SamplerAddressMode::CLAMP_TO_BORDER,
224 Wm::MirrorClamp => vk::SamplerAddressMode::MIRROR_CLAMP_TO_EDGE,
225 }
226 }
227
map_reduction(reduction: image::ReductionMode) -> vk::SamplerReductionMode228 pub fn map_reduction(reduction: image::ReductionMode) -> vk::SamplerReductionMode {
229 use hal::image::ReductionMode as Rm;
230 match reduction {
231 Rm::WeightedAverage => vk::SamplerReductionMode::WEIGHTED_AVERAGE,
232 Rm::Minimum => vk::SamplerReductionMode::MIN,
233 Rm::Maximum => vk::SamplerReductionMode::MAX,
234 }
235 }
236
map_border_color(border_color: image::BorderColor) -> vk::BorderColor237 pub fn map_border_color(border_color: image::BorderColor) -> vk::BorderColor {
238 match border_color {
239 image::BorderColor::TransparentBlack => vk::BorderColor::FLOAT_TRANSPARENT_BLACK,
240 image::BorderColor::OpaqueBlack => vk::BorderColor::FLOAT_OPAQUE_BLACK,
241 image::BorderColor::OpaqueWhite => vk::BorderColor::FLOAT_OPAQUE_WHITE,
242 }
243 }
244
map_topology(ia: &pso::InputAssemblerDesc) -> vk::PrimitiveTopology245 pub fn map_topology(ia: &pso::InputAssemblerDesc) -> vk::PrimitiveTopology {
246 match (ia.primitive, ia.with_adjacency) {
247 (pso::Primitive::PointList, false) => vk::PrimitiveTopology::POINT_LIST,
248 (pso::Primitive::PointList, true) => panic!("Points can't have adjacency info"),
249 (pso::Primitive::LineList, false) => vk::PrimitiveTopology::LINE_LIST,
250 (pso::Primitive::LineList, true) => vk::PrimitiveTopology::LINE_LIST_WITH_ADJACENCY,
251 (pso::Primitive::LineStrip, false) => vk::PrimitiveTopology::LINE_STRIP,
252 (pso::Primitive::LineStrip, true) => vk::PrimitiveTopology::LINE_STRIP_WITH_ADJACENCY,
253 (pso::Primitive::TriangleList, false) => vk::PrimitiveTopology::TRIANGLE_LIST,
254 (pso::Primitive::TriangleList, true) => vk::PrimitiveTopology::TRIANGLE_LIST_WITH_ADJACENCY,
255 (pso::Primitive::TriangleStrip, false) => vk::PrimitiveTopology::TRIANGLE_STRIP,
256 (pso::Primitive::TriangleStrip, true) => {
257 vk::PrimitiveTopology::TRIANGLE_STRIP_WITH_ADJACENCY
258 }
259 (pso::Primitive::PatchList(_), false) => vk::PrimitiveTopology::PATCH_LIST,
260 (pso::Primitive::PatchList(_), true) => panic!("Patches can't have adjacency info"),
261 }
262 }
263
map_cull_face(cf: pso::Face) -> vk::CullModeFlags264 pub fn map_cull_face(cf: pso::Face) -> vk::CullModeFlags {
265 match cf {
266 pso::Face::NONE => vk::CullModeFlags::NONE,
267 pso::Face::FRONT => vk::CullModeFlags::FRONT,
268 pso::Face::BACK => vk::CullModeFlags::BACK,
269 _ => vk::CullModeFlags::FRONT_AND_BACK,
270 }
271 }
272
map_front_face(ff: pso::FrontFace) -> vk::FrontFace273 pub fn map_front_face(ff: pso::FrontFace) -> vk::FrontFace {
274 match ff {
275 pso::FrontFace::Clockwise => vk::FrontFace::CLOCKWISE,
276 pso::FrontFace::CounterClockwise => vk::FrontFace::COUNTER_CLOCKWISE,
277 }
278 }
279
map_comparison(fun: pso::Comparison) -> vk::CompareOp280 pub fn map_comparison(fun: pso::Comparison) -> vk::CompareOp {
281 use hal::pso::Comparison::*;
282 match fun {
283 Never => vk::CompareOp::NEVER,
284 Less => vk::CompareOp::LESS,
285 LessEqual => vk::CompareOp::LESS_OR_EQUAL,
286 Equal => vk::CompareOp::EQUAL,
287 GreaterEqual => vk::CompareOp::GREATER_OR_EQUAL,
288 Greater => vk::CompareOp::GREATER,
289 NotEqual => vk::CompareOp::NOT_EQUAL,
290 Always => vk::CompareOp::ALWAYS,
291 }
292 }
293
map_stencil_op(op: pso::StencilOp) -> vk::StencilOp294 pub fn map_stencil_op(op: pso::StencilOp) -> vk::StencilOp {
295 use hal::pso::StencilOp::*;
296 match op {
297 Keep => vk::StencilOp::KEEP,
298 Zero => vk::StencilOp::ZERO,
299 Replace => vk::StencilOp::REPLACE,
300 IncrementClamp => vk::StencilOp::INCREMENT_AND_CLAMP,
301 IncrementWrap => vk::StencilOp::INCREMENT_AND_WRAP,
302 DecrementClamp => vk::StencilOp::DECREMENT_AND_CLAMP,
303 DecrementWrap => vk::StencilOp::DECREMENT_AND_WRAP,
304 Invert => vk::StencilOp::INVERT,
305 }
306 }
307
map_stencil_side(side: &pso::StencilFace) -> vk::StencilOpState308 pub fn map_stencil_side(side: &pso::StencilFace) -> vk::StencilOpState {
309 vk::StencilOpState {
310 fail_op: map_stencil_op(side.op_fail),
311 pass_op: map_stencil_op(side.op_pass),
312 depth_fail_op: map_stencil_op(side.op_depth_fail),
313 compare_op: map_comparison(side.fun),
314 compare_mask: !0,
315 write_mask: !0,
316 reference: 0,
317 }
318 }
319
map_blend_factor(factor: pso::Factor) -> vk::BlendFactor320 pub fn map_blend_factor(factor: pso::Factor) -> vk::BlendFactor {
321 use hal::pso::Factor::*;
322 match factor {
323 Zero => vk::BlendFactor::ZERO,
324 One => vk::BlendFactor::ONE,
325 SrcColor => vk::BlendFactor::SRC_COLOR,
326 OneMinusSrcColor => vk::BlendFactor::ONE_MINUS_SRC_COLOR,
327 DstColor => vk::BlendFactor::DST_COLOR,
328 OneMinusDstColor => vk::BlendFactor::ONE_MINUS_DST_COLOR,
329 SrcAlpha => vk::BlendFactor::SRC_ALPHA,
330 OneMinusSrcAlpha => vk::BlendFactor::ONE_MINUS_SRC_ALPHA,
331 DstAlpha => vk::BlendFactor::DST_ALPHA,
332 OneMinusDstAlpha => vk::BlendFactor::ONE_MINUS_DST_ALPHA,
333 ConstColor => vk::BlendFactor::CONSTANT_COLOR,
334 OneMinusConstColor => vk::BlendFactor::ONE_MINUS_CONSTANT_COLOR,
335 ConstAlpha => vk::BlendFactor::CONSTANT_ALPHA,
336 OneMinusConstAlpha => vk::BlendFactor::ONE_MINUS_CONSTANT_ALPHA,
337 SrcAlphaSaturate => vk::BlendFactor::SRC_ALPHA_SATURATE,
338 Src1Color => vk::BlendFactor::SRC1_COLOR,
339 OneMinusSrc1Color => vk::BlendFactor::ONE_MINUS_SRC1_COLOR,
340 Src1Alpha => vk::BlendFactor::SRC1_ALPHA,
341 OneMinusSrc1Alpha => vk::BlendFactor::ONE_MINUS_SRC1_ALPHA,
342 }
343 }
344
map_blend_op(operation: pso::BlendOp) -> (vk::BlendOp, vk::BlendFactor, vk::BlendFactor)345 pub fn map_blend_op(operation: pso::BlendOp) -> (vk::BlendOp, vk::BlendFactor, vk::BlendFactor) {
346 use hal::pso::BlendOp::*;
347 match operation {
348 Add { src, dst } => (
349 vk::BlendOp::ADD,
350 map_blend_factor(src),
351 map_blend_factor(dst),
352 ),
353 Sub { src, dst } => (
354 vk::BlendOp::SUBTRACT,
355 map_blend_factor(src),
356 map_blend_factor(dst),
357 ),
358 RevSub { src, dst } => (
359 vk::BlendOp::REVERSE_SUBTRACT,
360 map_blend_factor(src),
361 map_blend_factor(dst),
362 ),
363 Min => (
364 vk::BlendOp::MIN,
365 vk::BlendFactor::ZERO,
366 vk::BlendFactor::ZERO,
367 ),
368 Max => (
369 vk::BlendOp::MAX,
370 vk::BlendFactor::ZERO,
371 vk::BlendFactor::ZERO,
372 ),
373 }
374 }
375
map_pipeline_statistics( statistics: query::PipelineStatistic, ) -> vk::QueryPipelineStatisticFlags376 pub fn map_pipeline_statistics(
377 statistics: query::PipelineStatistic,
378 ) -> vk::QueryPipelineStatisticFlags {
379 vk::QueryPipelineStatisticFlags::from_raw(statistics.bits())
380 }
381
map_query_control_flags(flags: query::ControlFlags) -> vk::QueryControlFlags382 pub fn map_query_control_flags(flags: query::ControlFlags) -> vk::QueryControlFlags {
383 // Safe due to equivalence of HAL values and Vulkan values
384 vk::QueryControlFlags::from_raw(flags.bits() & vk::QueryControlFlags::all().as_raw())
385 }
386
map_query_result_flags(flags: query::ResultFlags) -> vk::QueryResultFlags387 pub fn map_query_result_flags(flags: query::ResultFlags) -> vk::QueryResultFlags {
388 vk::QueryResultFlags::from_raw(flags.bits() & vk::QueryResultFlags::all().as_raw())
389 }
390
map_image_features( features: vk::FormatFeatureFlags, supports_transfer_bits: bool, supports_sampler_filter_minmax: bool, ) -> format::ImageFeature391 pub fn map_image_features(
392 features: vk::FormatFeatureFlags,
393 supports_transfer_bits: bool,
394 supports_sampler_filter_minmax: bool,
395 ) -> format::ImageFeature {
396 let mut mapped_flags = format::ImageFeature::empty();
397 if features.contains(vk::FormatFeatureFlags::SAMPLED_IMAGE) {
398 mapped_flags |= format::ImageFeature::SAMPLED;
399 }
400 if features.contains(vk::FormatFeatureFlags::SAMPLED_IMAGE_FILTER_LINEAR) {
401 mapped_flags |= format::ImageFeature::SAMPLED_LINEAR;
402 }
403 if supports_sampler_filter_minmax
404 && features.contains(vk::FormatFeatureFlags::SAMPLED_IMAGE_FILTER_MINMAX)
405 {
406 mapped_flags |= format::ImageFeature::SAMPLED_MINMAX;
407 }
408
409 if features.contains(vk::FormatFeatureFlags::STORAGE_IMAGE) {
410 mapped_flags |= format::ImageFeature::STORAGE;
411 mapped_flags |= format::ImageFeature::STORAGE_READ_WRITE;
412 }
413 if features.contains(vk::FormatFeatureFlags::STORAGE_IMAGE_ATOMIC) {
414 mapped_flags |= format::ImageFeature::STORAGE_ATOMIC;
415 }
416
417 if features.contains(vk::FormatFeatureFlags::COLOR_ATTACHMENT) {
418 mapped_flags |= format::ImageFeature::COLOR_ATTACHMENT;
419 }
420 if features.contains(vk::FormatFeatureFlags::COLOR_ATTACHMENT_BLEND) {
421 mapped_flags |= format::ImageFeature::COLOR_ATTACHMENT_BLEND;
422 }
423 if features.contains(vk::FormatFeatureFlags::DEPTH_STENCIL_ATTACHMENT) {
424 mapped_flags |= format::ImageFeature::DEPTH_STENCIL_ATTACHMENT;
425 }
426
427 if features.contains(vk::FormatFeatureFlags::BLIT_SRC) {
428 mapped_flags |= format::ImageFeature::BLIT_SRC;
429 if !supports_transfer_bits {
430 mapped_flags |= format::ImageFeature::TRANSFER_SRC;
431 }
432 }
433 if features.contains(vk::FormatFeatureFlags::BLIT_DST) {
434 mapped_flags |= format::ImageFeature::BLIT_DST;
435 if !supports_transfer_bits {
436 mapped_flags |= format::ImageFeature::TRANSFER_DST;
437 }
438 }
439 if supports_transfer_bits {
440 if features.contains(vk::FormatFeatureFlags::TRANSFER_SRC) {
441 mapped_flags |= format::ImageFeature::TRANSFER_SRC;
442 }
443 if features.contains(vk::FormatFeatureFlags::TRANSFER_DST) {
444 mapped_flags |= format::ImageFeature::TRANSFER_DST;
445 }
446 }
447
448 mapped_flags
449 }
450
map_buffer_features(features: vk::FormatFeatureFlags) -> format::BufferFeature451 pub fn map_buffer_features(features: vk::FormatFeatureFlags) -> format::BufferFeature {
452 format::BufferFeature::from_bits_truncate(features.as_raw())
453 }
454
map_memory_range<'a>((memory, segment): (&'a n::Memory, Segment)) -> vk::MappedMemoryRange455 pub fn map_memory_range<'a>((memory, segment): (&'a n::Memory, Segment)) -> vk::MappedMemoryRange {
456 vk::MappedMemoryRange::builder()
457 .memory(memory.raw)
458 .offset(segment.offset)
459 .size(segment.size.unwrap_or(vk::WHOLE_SIZE))
460 .build()
461 }
462
map_command_buffer_flags(flags: command::CommandBufferFlags) -> vk::CommandBufferUsageFlags463 pub fn map_command_buffer_flags(flags: command::CommandBufferFlags) -> vk::CommandBufferUsageFlags {
464 // Safe due to equivalence of HAL values and Vulkan values
465 vk::CommandBufferUsageFlags::from_raw(flags.bits())
466 }
467
map_command_buffer_level(level: command::Level) -> vk::CommandBufferLevel468 pub fn map_command_buffer_level(level: command::Level) -> vk::CommandBufferLevel {
469 match level {
470 command::Level::Primary => vk::CommandBufferLevel::PRIMARY,
471 command::Level::Secondary => vk::CommandBufferLevel::SECONDARY,
472 }
473 }
474
map_view_kind( kind: image::ViewKind, ty: vk::ImageType, is_cube: bool, ) -> Option<vk::ImageViewType>475 pub fn map_view_kind(
476 kind: image::ViewKind,
477 ty: vk::ImageType,
478 is_cube: bool,
479 ) -> Option<vk::ImageViewType> {
480 use crate::image::ViewKind::*;
481 use crate::vk::ImageType;
482
483 Some(match (ty, kind) {
484 (ImageType::TYPE_1D, D1) => vk::ImageViewType::TYPE_1D,
485 (ImageType::TYPE_1D, D1Array) => vk::ImageViewType::TYPE_1D_ARRAY,
486 (ImageType::TYPE_2D, D2) => vk::ImageViewType::TYPE_2D,
487 (ImageType::TYPE_2D, D2Array) => vk::ImageViewType::TYPE_2D_ARRAY,
488 (ImageType::TYPE_3D, D3) => vk::ImageViewType::TYPE_3D,
489 (ImageType::TYPE_2D, Cube) if is_cube => vk::ImageViewType::CUBE,
490 (ImageType::TYPE_2D, CubeArray) if is_cube => vk::ImageViewType::CUBE_ARRAY,
491 (ImageType::TYPE_3D, Cube) if is_cube => vk::ImageViewType::CUBE,
492 (ImageType::TYPE_3D, CubeArray) if is_cube => vk::ImageViewType::CUBE_ARRAY,
493 _ => return None,
494 })
495 }
496
map_rect(rect: &pso::Rect) -> vk::Rect2D497 pub fn map_rect(rect: &pso::Rect) -> vk::Rect2D {
498 vk::Rect2D {
499 offset: vk::Offset2D {
500 x: rect.x as _,
501 y: rect.y as _,
502 },
503 extent: vk::Extent2D {
504 width: rect.w as _,
505 height: rect.h as _,
506 },
507 }
508 }
509
map_clear_rect(rect: &pso::ClearRect) -> vk::ClearRect510 pub fn map_clear_rect(rect: &pso::ClearRect) -> vk::ClearRect {
511 vk::ClearRect {
512 base_array_layer: rect.layers.start as _,
513 layer_count: (rect.layers.end - rect.layers.start) as _,
514 rect: map_rect(&rect.rect),
515 }
516 }
517
map_viewport(vp: &pso::Viewport, flip_y: bool, shift_y: bool) -> vk::Viewport518 pub fn map_viewport(vp: &pso::Viewport, flip_y: bool, shift_y: bool) -> vk::Viewport {
519 vk::Viewport {
520 x: vp.rect.x as _,
521 y: if shift_y {
522 vp.rect.y + vp.rect.h
523 } else {
524 vp.rect.y
525 } as _,
526 width: vp.rect.w as _,
527 height: if flip_y { -vp.rect.h } else { vp.rect.h } as _,
528 min_depth: vp.depth.start,
529 max_depth: vp.depth.end,
530 }
531 }
532
map_view_capabilities(caps: image::ViewCapabilities) -> vk::ImageCreateFlags533 pub fn map_view_capabilities(caps: image::ViewCapabilities) -> vk::ImageCreateFlags {
534 vk::ImageCreateFlags::from_raw(caps.bits())
535 }
536
map_view_capabilities_sparse( sparse: memory::SparseFlags, caps: image::ViewCapabilities, ) -> vk::ImageCreateFlags537 pub fn map_view_capabilities_sparse(
538 sparse: memory::SparseFlags,
539 caps: image::ViewCapabilities,
540 ) -> vk::ImageCreateFlags {
541 vk::ImageCreateFlags::from_raw(sparse.bits() | caps.bits())
542 }
543
map_present_mode(mode: PresentMode) -> vk::PresentModeKHR544 pub fn map_present_mode(mode: PresentMode) -> vk::PresentModeKHR {
545 if mode == PresentMode::IMMEDIATE {
546 vk::PresentModeKHR::IMMEDIATE
547 } else if mode == PresentMode::MAILBOX {
548 vk::PresentModeKHR::MAILBOX
549 } else if mode == PresentMode::FIFO {
550 vk::PresentModeKHR::FIFO
551 } else if mode == PresentMode::RELAXED {
552 vk::PresentModeKHR::FIFO_RELAXED
553 } else {
554 panic!("Unexpected present mode {:?}", mode)
555 }
556 }
557
map_vk_present_mode(mode: vk::PresentModeKHR) -> PresentMode558 pub fn map_vk_present_mode(mode: vk::PresentModeKHR) -> PresentMode {
559 if mode == vk::PresentModeKHR::IMMEDIATE {
560 PresentMode::IMMEDIATE
561 } else if mode == vk::PresentModeKHR::MAILBOX {
562 PresentMode::MAILBOX
563 } else if mode == vk::PresentModeKHR::FIFO {
564 PresentMode::FIFO
565 } else if mode == vk::PresentModeKHR::FIFO_RELAXED {
566 PresentMode::RELAXED
567 } else {
568 warn!("Unrecognized present mode {:?}", mode);
569 PresentMode::IMMEDIATE
570 }
571 }
572
map_composite_alpha_mode( composite_alpha_mode: CompositeAlphaMode, ) -> vk::CompositeAlphaFlagsKHR573 pub fn map_composite_alpha_mode(
574 composite_alpha_mode: CompositeAlphaMode,
575 ) -> vk::CompositeAlphaFlagsKHR {
576 vk::CompositeAlphaFlagsKHR::from_raw(composite_alpha_mode.bits())
577 }
578
map_vk_composite_alpha(composite_alpha: vk::CompositeAlphaFlagsKHR) -> CompositeAlphaMode579 pub fn map_vk_composite_alpha(composite_alpha: vk::CompositeAlphaFlagsKHR) -> CompositeAlphaMode {
580 CompositeAlphaMode::from_bits_truncate(composite_alpha.as_raw())
581 }
582
map_descriptor_pool_create_flags( flags: pso::DescriptorPoolCreateFlags, ) -> vk::DescriptorPoolCreateFlags583 pub fn map_descriptor_pool_create_flags(
584 flags: pso::DescriptorPoolCreateFlags,
585 ) -> vk::DescriptorPoolCreateFlags {
586 vk::DescriptorPoolCreateFlags::from_raw(flags.bits())
587 }
588
map_sample_count_flags(samples: image::NumSamples) -> vk::SampleCountFlags589 pub fn map_sample_count_flags(samples: image::NumSamples) -> vk::SampleCountFlags {
590 vk::SampleCountFlags::from_raw((samples as u32) & vk::SampleCountFlags::all().as_raw())
591 }
592
map_vk_memory_properties(flags: vk::MemoryPropertyFlags) -> hal::memory::Properties593 pub fn map_vk_memory_properties(flags: vk::MemoryPropertyFlags) -> hal::memory::Properties {
594 use crate::memory::Properties;
595 let mut properties = Properties::empty();
596
597 if flags.contains(vk::MemoryPropertyFlags::DEVICE_LOCAL) {
598 properties |= Properties::DEVICE_LOCAL;
599 }
600 if flags.contains(vk::MemoryPropertyFlags::HOST_VISIBLE) {
601 properties |= Properties::CPU_VISIBLE;
602 }
603 if flags.contains(vk::MemoryPropertyFlags::HOST_COHERENT) {
604 properties |= Properties::COHERENT;
605 }
606 if flags.contains(vk::MemoryPropertyFlags::HOST_CACHED) {
607 properties |= Properties::CPU_CACHED;
608 }
609 if flags.contains(vk::MemoryPropertyFlags::LAZILY_ALLOCATED) {
610 properties |= Properties::LAZILY_ALLOCATED;
611 }
612
613 properties
614 }
615
map_vk_memory_heap_flags(flags: vk::MemoryHeapFlags) -> hal::memory::HeapFlags616 pub fn map_vk_memory_heap_flags(flags: vk::MemoryHeapFlags) -> hal::memory::HeapFlags {
617 use hal::memory::HeapFlags;
618 let mut hal_flags = HeapFlags::empty();
619
620 if flags.contains(vk::MemoryHeapFlags::DEVICE_LOCAL) {
621 hal_flags |= HeapFlags::DEVICE_LOCAL;
622 }
623
624 hal_flags
625 }
626