alex/ash
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity

using builders and Defaults in texture example

Browse source
This commit is contained in:
colin 2018-12-06 08:58:12 -06:00
parent c1dc88e199
commit bac3a5bc21
2 changed files with 348 additions and 515 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

470
examples/src/bin/texture.rs
View file

@ -33,30 +33,27 @@ pub struct Vector3 {
fn main() { fn main() {
unsafe { unsafe {
let base = ExampleBase::new(1920, 1080); let base = ExampleBase::new(1920, 1080);
let renderpass_attachments = [ let renderpass_attachments = [
vk::AttachmentDescription { vk::AttachmentDescription {
format: base.surface_format.format, format: base.surface_format.format,
flags: vk::AttachmentDescriptionFlags::empty(),
samples: vk::SampleCountFlags::TYPE_1, samples: vk::SampleCountFlags::TYPE_1,
load_op: vk::AttachmentLoadOp::CLEAR, load_op: vk::AttachmentLoadOp::CLEAR,
store_op: vk::AttachmentStoreOp::STORE, store_op: vk::AttachmentStoreOp::STORE,
stencil_load_op: vk::AttachmentLoadOp::DONT_CARE,
stencil_store_op: vk::AttachmentStoreOp::DONT_CARE,
initial_layout: vk::ImageLayout::UNDEFINED,
final_layout: vk::ImageLayout::PRESENT_SRC_KHR, final_layout: vk::ImageLayout::PRESENT_SRC_KHR,
.. Default::default()
}, },
vk::AttachmentDescription { vk::AttachmentDescription {
format: vk::Format::D16_UNORM, format: vk::Format::D16_UNORM,
flags: vk::AttachmentDescriptionFlags::empty(),
samples: vk::SampleCountFlags::TYPE_1, samples: vk::SampleCountFlags::TYPE_1,
load_op: vk::AttachmentLoadOp::CLEAR, load_op: vk::AttachmentLoadOp::CLEAR,
store_op: vk::AttachmentStoreOp::DONT_CARE,
stencil_load_op: vk::AttachmentLoadOp::DONT_CARE,
stencil_store_op: vk::AttachmentStoreOp::DONT_CARE,
initial_layout: vk::ImageLayout::DEPTH_STENCIL_ATTACHMENT_OPTIMAL, initial_layout: vk::ImageLayout::DEPTH_STENCIL_ATTACHMENT_OPTIMAL,
final_layout: vk::ImageLayout::DEPTH_STENCIL_ATTACHMENT_OPTIMAL, final_layout: vk::ImageLayout::DEPTH_STENCIL_ATTACHMENT_OPTIMAL,
.. Default::default()
}, },
]; ];
let color_attachment_ref = vk::AttachmentReference { let color_attachment_ref = vk::AttachmentReference {
attachment: 0, attachment: 0,
layout: vk::ImageLayout::COLOR_ATTACHMENT_OPTIMAL, layout: vk::ImageLayout::COLOR_ATTACHMENT_OPTIMAL,
@ -65,73 +62,59 @@ fn main() {
attachment: 1, attachment: 1,
layout: vk::ImageLayout::DEPTH_STENCIL_ATTACHMENT_OPTIMAL, layout: vk::ImageLayout::DEPTH_STENCIL_ATTACHMENT_OPTIMAL,
}; };
let dependency = vk::SubpassDependency { let dependency = vk::SubpassDependency {
dependency_flags: Default::default(),
src_subpass: vk::SUBPASS_EXTERNAL, src_subpass: vk::SUBPASS_EXTERNAL,
dst_subpass: Default::default(),
src_stage_mask: vk::PipelineStageFlags::COLOR_ATTACHMENT_OUTPUT, src_stage_mask: vk::PipelineStageFlags::COLOR_ATTACHMENT_OUTPUT,
src_access_mask: Default::default(),
dst_access_mask: vk::AccessFlags::COLOR_ATTACHMENT_READ dst_access_mask: vk::AccessFlags::COLOR_ATTACHMENT_READ
| vk::AccessFlags::COLOR_ATTACHMENT_WRITE, | vk::AccessFlags::COLOR_ATTACHMENT_WRITE,
dst_stage_mask: vk::PipelineStageFlags::COLOR_ATTACHMENT_OUTPUT, dst_stage_mask: vk::PipelineStageFlags::COLOR_ATTACHMENT_OUTPUT,
.. Default::default()
}; };
let subpass = vk::SubpassDescription {
color_attachment_count: 1,
p_color_attachments: &color_attachment_ref,
p_depth_stencil_attachment: &depth_attachment_ref, let subpass = vk::SubpassDescription::builder()
flags: Default::default(), .color_attachments(&[color_attachment_ref])
pipeline_bind_point: vk::PipelineBindPoint::GRAPHICS, .depth_stencil_attachment(&depth_attachment_ref)
input_attachment_count: 0, .pipeline_bind_point(vk::PipelineBindPoint::GRAPHICS)
p_input_attachments: ptr::null(), .build();
p_resolve_attachments: ptr::null(),
preserve_attachment_count: 0,
p_preserve_attachments: ptr::null(), let renderpass_create_info = vk::RenderPassCreateInfo::builder()
}; .attachments(&renderpass_attachments)
let renderpass_create_info = vk::RenderPassCreateInfo { .subpasses( &[subpass])
s_type: vk::StructureType::RENDER_PASS_CREATE_INFO, .dependencies(&[dependency])
flags: Default::default(), .build();
p_next: ptr::null(),
attachment_count: renderpass_attachments.len() as u32,
p_attachments: renderpass_attachments.as_ptr(),
subpass_count: 1,
p_subpasses: &subpass,
dependency_count: 1,
p_dependencies: &dependency,
};
let renderpass = base let renderpass = base
.device .device
.create_render_pass(&renderpass_create_info, None) .create_render_pass(&renderpass_create_info, None)
.unwrap(); .unwrap();
let framebuffers: Vec<vk::Framebuffer> = base let framebuffers: Vec<vk::Framebuffer> = base
.present_image_views .present_image_views
.iter() .iter()
.map(|&present_image_view| { .map(|&present_image_view| {
let framebuffer_attachments = [present_image_view, base.depth_image_view]; let framebuffer_attachments = [present_image_view, base.depth_image_view];
let frame_buffer_create_info = vk::FramebufferCreateInfo { let frame_buffer_create_info = vk::FramebufferCreateInfo::builder()
s_type: vk::StructureType::FRAMEBUFFER_CREATE_INFO, .render_pass(renderpass)
p_next: ptr::null(), .attachments(&framebuffer_attachments)
flags: Default::default(), .width( base.surface_resolution.width)
render_pass: renderpass, .height( base.surface_resolution.height)
attachment_count: framebuffer_attachments.len() as u32, .layers( 1)
p_attachments: framebuffer_attachments.as_ptr(), .build();
width: base.surface_resolution.width,
height: base.surface_resolution.height,
layers: 1,
};
base.device base.device
.create_framebuffer(&frame_buffer_create_info, None) .create_framebuffer(&frame_buffer_create_info, None)
.unwrap() .unwrap()
}).collect(); }).collect();
let index_buffer_data = [0u32, 1, 2, 2, 3, 0]; let index_buffer_data = [0u32, 1, 2, 2, 3, 0];
let index_buffer_info = vk::BufferCreateInfo { let index_buffer_info = vk::BufferCreateInfo {
s_type: vk::StructureType::BUFFER_CREATE_INFO,
p_next: ptr::null(),
flags: vk::BufferCreateFlags::empty(),
size: std::mem::size_of_val(&index_buffer_data) as u64, size: std::mem::size_of_val(&index_buffer_data) as u64,
usage: vk::BufferUsageFlags::INDEX_BUFFER, usage: vk::BufferUsageFlags::INDEX_BUFFER,
sharing_mode: vk::SharingMode::EXCLUSIVE, sharing_mode: vk::SharingMode::EXCLUSIVE,
queue_family_index_count: 0, .. Default::default()
p_queue_family_indices: ptr::null(),
}; };
let index_buffer = base.device.create_buffer(&index_buffer_info, None).unwrap(); let index_buffer = base.device.create_buffer(&index_buffer_info, None).unwrap();
let index_buffer_memory_req = base.device.get_buffer_memory_requirements(index_buffer); let index_buffer_memory_req = base.device.get_buffer_memory_requirements(index_buffer);
@ -141,10 +124,9 @@ fn main() {
vk::MemoryPropertyFlags::HOST_VISIBLE, vk::MemoryPropertyFlags::HOST_VISIBLE,
).expect("Unable to find suitable memorytype for the index buffer."); ).expect("Unable to find suitable memorytype for the index buffer.");
let index_allocate_info = vk::MemoryAllocateInfo { let index_allocate_info = vk::MemoryAllocateInfo {
s_type: vk::StructureType::MEMORY_ALLOCATE_INFO,
p_next: ptr::null(),
allocation_size: index_buffer_memory_req.size, allocation_size: index_buffer_memory_req.size,
memory_type_index: index_buffer_memory_index, memory_type_index: index_buffer_memory_index,
.. Default::default()
}; };
let index_buffer_memory = base let index_buffer_memory = base
.device .device
@ -188,14 +170,10 @@ fn main() {
}, },
]; ];
let vertex_input_buffer_info = vk::BufferCreateInfo { let vertex_input_buffer_info = vk::BufferCreateInfo {
s_type: vk::StructureType::BUFFER_CREATE_INFO,
p_next: ptr::null(),
flags: vk::BufferCreateFlags::empty(),
size: std::mem::size_of_val(&vertices) as u64, size: std::mem::size_of_val(&vertices) as u64,
usage: vk::BufferUsageFlags::VERTEX_BUFFER, usage: vk::BufferUsageFlags::VERTEX_BUFFER,
sharing_mode: vk::SharingMode::EXCLUSIVE, sharing_mode: vk::SharingMode::EXCLUSIVE,
queue_family_index_count: 0, .. Default::default()
p_queue_family_indices: ptr::null(),
}; };
let vertex_input_buffer = base let vertex_input_buffer = base
.device .device
@ -211,15 +189,15 @@ fn main() {
).expect("Unable to find suitable memorytype for the vertex buffer."); ).expect("Unable to find suitable memorytype for the vertex buffer.");
let vertex_buffer_allocate_info = vk::MemoryAllocateInfo { let vertex_buffer_allocate_info = vk::MemoryAllocateInfo {
s_type: vk::StructureType::MEMORY_ALLOCATE_INFO,
p_next: ptr::null(),
allocation_size: vertex_input_buffer_memory_req.size, allocation_size: vertex_input_buffer_memory_req.size,
memory_type_index: vertex_input_buffer_memory_index, memory_type_index: vertex_input_buffer_memory_index,
.. Default::default()
}; };
let vertex_input_buffer_memory = base let vertex_input_buffer_memory = base
.device .device
.allocate_memory(&vertex_buffer_allocate_info, None) .allocate_memory(&vertex_buffer_allocate_info, None)
.unwrap(); .unwrap();
let vert_ptr = base let vert_ptr = base
.device .device
.map_memory( .map_memory(
@ -246,14 +224,10 @@ fn main() {
_pad: 0.0, _pad: 0.0,
}; };
let uniform_color_buffer_info = vk::BufferCreateInfo { let uniform_color_buffer_info = vk::BufferCreateInfo {
s_type: vk::StructureType::BUFFER_CREATE_INFO,
p_next: ptr::null(),
flags: vk::BufferCreateFlags::empty(),
size: std::mem::size_of_val(&uniform_color_buffer_data) as u64, size: std::mem::size_of_val(&uniform_color_buffer_data) as u64,
usage: vk::BufferUsageFlags::UNIFORM_BUFFER, usage: vk::BufferUsageFlags::UNIFORM_BUFFER,
sharing_mode: vk::SharingMode::EXCLUSIVE, sharing_mode: vk::SharingMode::EXCLUSIVE,
queue_family_index_count: 0, .. Default::default()
p_queue_family_indices: ptr::null(),
}; };
let uniform_color_buffer = base let uniform_color_buffer = base
.device .device
@ -269,10 +243,9 @@ fn main() {
).expect("Unable to find suitable memorytype for the vertex buffer."); ).expect("Unable to find suitable memorytype for the vertex buffer.");
let uniform_color_buffer_allocate_info = vk::MemoryAllocateInfo { let uniform_color_buffer_allocate_info = vk::MemoryAllocateInfo {
s_type: vk::StructureType::MEMORY_ALLOCATE_INFO,
p_next: ptr::null(),
allocation_size: uniform_color_buffer_memory_req.size, allocation_size: uniform_color_buffer_memory_req.size,
memory_type_index: uniform_color_buffer_memory_index, memory_type_index: uniform_color_buffer_memory_index,
.. Default::default()
}; };
let uniform_color_buffer_memory = base let uniform_color_buffer_memory = base
.device .device
@ -301,14 +274,10 @@ fn main() {
let image_dimensions = image.dimensions(); let image_dimensions = image.dimensions();
let image_data = image.into_raw(); let image_data = image.into_raw();
let image_buffer_info = vk::BufferCreateInfo { let image_buffer_info = vk::BufferCreateInfo {
s_type: vk::StructureType::BUFFER_CREATE_INFO,
p_next: ptr::null(),
flags: vk::BufferCreateFlags::empty(),
size: (std::mem::size_of::<u8>() * image_data.len()) as u64, size: (std::mem::size_of::<u8>() * image_data.len()) as u64,
usage: vk::BufferUsageFlags::TRANSFER_SRC, usage: vk::BufferUsageFlags::TRANSFER_SRC,
sharing_mode: vk::SharingMode::EXCLUSIVE, sharing_mode: vk::SharingMode::EXCLUSIVE,
queue_family_index_count: 0, .. Default::default()
p_queue_family_indices: ptr::null(),
}; };
let image_buffer = base.device.create_buffer(&image_buffer_info, None).unwrap(); let image_buffer = base.device.create_buffer(&image_buffer_info, None).unwrap();
let image_buffer_memory_req = base.device.get_buffer_memory_requirements(image_buffer); let image_buffer_memory_req = base.device.get_buffer_memory_requirements(image_buffer);
@ -319,10 +288,9 @@ fn main() {
).expect("Unable to find suitable memorytype for the vertex buffer."); ).expect("Unable to find suitable memorytype for the vertex buffer.");
let image_buffer_allocate_info = vk::MemoryAllocateInfo { let image_buffer_allocate_info = vk::MemoryAllocateInfo {
s_type: vk::StructureType::MEMORY_ALLOCATE_INFO,
p_next: ptr::null(),
allocation_size: image_buffer_memory_req.size, allocation_size: image_buffer_memory_req.size,
memory_type_index: image_buffer_memory_index, memory_type_index: image_buffer_memory_index,
.. Default::default()
}; };
let image_buffer_memory = base let image_buffer_memory = base
.device .device
@ -348,9 +316,6 @@ fn main() {
.unwrap(); .unwrap();
let texture_create_info = vk::ImageCreateInfo { let texture_create_info = vk::ImageCreateInfo {
s_type: vk::StructureType::IMAGE_CREATE_INFO,
p_next: ptr::null(),
flags: Default::default(),
image_type: vk::ImageType::TYPE_2D, image_type: vk::ImageType::TYPE_2D,
format: vk::Format::R8G8B8A8_UNORM, format: vk::Format::R8G8B8A8_UNORM,
extent: vk::Extent3D { extent: vk::Extent3D {
@ -364,9 +329,7 @@ fn main() {
tiling: vk::ImageTiling::OPTIMAL, tiling: vk::ImageTiling::OPTIMAL,
usage: vk::ImageUsageFlags::TRANSFER_DST | vk::ImageUsageFlags::SAMPLED, usage: vk::ImageUsageFlags::TRANSFER_DST | vk::ImageUsageFlags::SAMPLED,
sharing_mode: vk::SharingMode::EXCLUSIVE, sharing_mode: vk::SharingMode::EXCLUSIVE,
queue_family_index_count: 0, .. Default::default()
p_queue_family_indices: ptr::null(),
initial_layout: vk::ImageLayout::UNDEFINED,
}; };
let texture_image = base let texture_image = base
.device .device
@ -380,10 +343,9 @@ fn main() {
).expect("Unable to find suitable memory index for depth image."); ).expect("Unable to find suitable memory index for depth image.");
let texture_allocate_info = vk::MemoryAllocateInfo { let texture_allocate_info = vk::MemoryAllocateInfo {
s_type: vk::StructureType::MEMORY_ALLOCATE_INFO,
p_next: ptr::null(),
allocation_size: texture_memory_req.size, allocation_size: texture_memory_req.size,
memory_type_index: texture_memory_index, memory_type_index: texture_memory_index,
.. Default::default()
}; };
let texture_memory = base let texture_memory = base
.device .device
@ -397,27 +359,21 @@ fn main() {
&base.device, &base.device,
base.setup_command_buffer, base.setup_command_buffer,
base.present_queue, base.present_queue,
&[vk::PipelineStageFlags::TOP_OF_PIPE], &[],
&[], &[],
&[], &[],
|device, texture_command_buffer| { |device, texture_command_buffer| {
let texture_barrier = vk::ImageMemoryBarrier { let texture_barrier = vk::ImageMemoryBarrier {
s_type: vk::StructureType::IMAGE_MEMORY_BARRIER,
p_next: ptr::null(),
src_access_mask: Default::default(),
dst_access_mask: vk::AccessFlags::TRANSFER_WRITE, dst_access_mask: vk::AccessFlags::TRANSFER_WRITE,
old_layout: vk::ImageLayout::UNDEFINED,
new_layout: vk::ImageLayout::TRANSFER_DST_OPTIMAL, new_layout: vk::ImageLayout::TRANSFER_DST_OPTIMAL,
src_queue_family_index: vk::QUEUE_FAMILY_IGNORED,
dst_queue_family_index: vk::QUEUE_FAMILY_IGNORED,
image: texture_image, image: texture_image,
subresource_range: vk::ImageSubresourceRange { subresource_range: vk::ImageSubresourceRange {
aspect_mask: vk::ImageAspectFlags::COLOR, aspect_mask: vk::ImageAspectFlags::COLOR,
base_mip_level: 0,
level_count: 1, level_count: 1,
base_array_layer: 0,
layer_count: 1, layer_count: 1,
.. Default::default()
}, },
.. Default::default()
}; };
device.cmd_pipeline_barrier( device.cmd_pipeline_barrier(
texture_command_buffer, texture_command_buffer,
@ -428,24 +384,22 @@ fn main() {
&[], &[],
&[texture_barrier], &[texture_barrier],
); );
let buffer_copy_regions = [vk::BufferImageCopy { let buffer_copy_regions = [
image_subresource: vk::ImageSubresourceLayers { vk::BufferImageCopy::builder()
aspect_mask: vk::ImageAspectFlags::COLOR, .image_subresource(
mip_level: 0, vk::ImageSubresourceLayers::builder()
base_array_layer: 0, .aspect_mask( vk::ImageAspectFlags::COLOR)
layer_count: 1, .layer_count(1)
}, .build()
image_extent: vk::Extent3D { )
.image_extent(
vk::Extent3D {
width: image_dimensions.0, width: image_dimensions.0,
height: image_dimensions.1, height: image_dimensions.1,
depth: 1, depth: 1,
}, })
buffer_offset: 0, .build()
// FIX ME ];
buffer_image_height: 0,
buffer_row_length: 0,
image_offset: vk::Offset3D { x: 0, y: 0, z: 0 },
}];
device.cmd_copy_buffer_to_image( device.cmd_copy_buffer_to_image(
texture_command_buffer, texture_command_buffer,
image_buffer, image_buffer,
@ -454,22 +408,18 @@ fn main() {
&buffer_copy_regions, &buffer_copy_regions,
); );
let texture_barrier_end = vk::ImageMemoryBarrier { let texture_barrier_end = vk::ImageMemoryBarrier {
s_type: vk::StructureType::IMAGE_MEMORY_BARRIER,
p_next: ptr::null(),
src_access_mask: vk::AccessFlags::TRANSFER_WRITE, src_access_mask: vk::AccessFlags::TRANSFER_WRITE,
dst_access_mask: vk::AccessFlags::SHADER_READ, dst_access_mask: vk::AccessFlags::SHADER_READ,
old_layout: vk::ImageLayout::TRANSFER_DST_OPTIMAL, old_layout: vk::ImageLayout::TRANSFER_DST_OPTIMAL,
new_layout: vk::ImageLayout::SHADER_READ_ONLY_OPTIMAL, new_layout: vk::ImageLayout::SHADER_READ_ONLY_OPTIMAL,
src_queue_family_index: vk::QUEUE_FAMILY_IGNORED,
dst_queue_family_index: vk::QUEUE_FAMILY_IGNORED,
image: texture_image, image: texture_image,
subresource_range: vk::ImageSubresourceRange { subresource_range: vk::ImageSubresourceRange {
aspect_mask: vk::ImageAspectFlags::COLOR, aspect_mask: vk::ImageAspectFlags::COLOR,
base_mip_level: 0,
level_count: 1, level_count: 1,
base_array_layer: 0,
layer_count: 1, layer_count: 1,
.. Default::default()
}, },
.. Default::default()
}; };
device.cmd_pipeline_barrier( device.cmd_pipeline_barrier(
texture_command_buffer, texture_command_buffer,
@ -484,32 +434,19 @@ fn main() {
); );
let sampler_info = vk::SamplerCreateInfo { let sampler_info = vk::SamplerCreateInfo {
s_type: vk::StructureType::SAMPLER_CREATE_INFO,
p_next: ptr::null(),
flags: Default::default(),
mag_filter: vk::Filter::LINEAR, mag_filter: vk::Filter::LINEAR,
min_filter: vk::Filter::LINEAR, min_filter: vk::Filter::LINEAR,
mipmap_mode: vk::SamplerMipmapMode::LINEAR, mipmap_mode: vk::SamplerMipmapMode::LINEAR,
address_mode_u: vk::SamplerAddressMode::MIRRORED_REPEAT, address_mode_u: vk::SamplerAddressMode::MIRRORED_REPEAT,
address_mode_v: vk::SamplerAddressMode::MIRRORED_REPEAT, address_mode_v: vk::SamplerAddressMode::MIRRORED_REPEAT,
address_mode_w: vk::SamplerAddressMode::MIRRORED_REPEAT, address_mode_w: vk::SamplerAddressMode::MIRRORED_REPEAT,
mip_lod_bias: 0.0,
min_lod: 0.0,
max_lod: 0.0,
anisotropy_enable: 0,
max_anisotropy: 1.0, max_anisotropy: 1.0,
border_color: vk::BorderColor::FLOAT_OPAQUE_WHITE, .. Default::default()
compare_enable: 0,
compare_op: vk::CompareOp::NEVER,
unnormalized_coordinates: 0,
}; };
let sampler = base.device.create_sampler(&sampler_info, None).unwrap(); let sampler = base.device.create_sampler(&sampler_info, None).unwrap();
let tex_image_view_info = vk::ImageViewCreateInfo { let tex_image_view_info = vk::ImageViewCreateInfo {
s_type: vk::StructureType::IMAGE_VIEW_CREATE_INFO,
p_next: ptr::null(),
flags: Default::default(),
view_type: vk::ImageViewType::TYPE_2D, view_type: vk::ImageViewType::TYPE_2D,
format: texture_create_info.format, format: texture_create_info.format,
components: vk::ComponentMapping { components: vk::ComponentMapping {
@ -520,12 +457,12 @@ fn main() {
}, },
subresource_range: vk::ImageSubresourceRange { subresource_range: vk::ImageSubresourceRange {
aspect_mask: vk::ImageAspectFlags::COLOR, aspect_mask: vk::ImageAspectFlags::COLOR,
base_mip_level: 0,
level_count: 1, level_count: 1,
base_array_layer: 0,
layer_count: 1, layer_count: 1,
.. Default::default()
}, },
image: texture_image, image: texture_image,
.. Default::default()
}; };
let tex_image_view = base let tex_image_view = base
.device .device
@ -541,53 +478,41 @@ fn main() {
descriptor_count: 1, descriptor_count: 1,
}, },
]; ];
let descriptor_pool_info = vk::DescriptorPoolCreateInfo { let descriptor_pool_info = vk::DescriptorPoolCreateInfo::builder()
s_type: vk::StructureType::DESCRIPTOR_POOL_CREATE_INFO, .pool_sizes(&descriptor_sizes)
p_next: ptr::null(), .max_sets(1)
flags: Default::default(), .build();
pool_size_count: descriptor_sizes.len() as u32,
p_pool_sizes: descriptor_sizes.as_ptr(),
max_sets: 1,
};
let descriptor_pool = base let descriptor_pool = base
.device .device
.create_descriptor_pool(&descriptor_pool_info, None) .create_descriptor_pool(&descriptor_pool_info, None)
.unwrap(); .unwrap();
let desc_layout_bindings = [ let desc_layout_bindings = [
vk::DescriptorSetLayoutBinding { vk::DescriptorSetLayoutBinding {
binding: 0,
descriptor_type: vk::DescriptorType::UNIFORM_BUFFER, descriptor_type: vk::DescriptorType::UNIFORM_BUFFER,
descriptor_count: 1, descriptor_count: 1,
stage_flags: vk::ShaderStageFlags::FRAGMENT, stage_flags: vk::ShaderStageFlags::FRAGMENT,
p_immutable_samplers: ptr::null(), .. Default::default()
}, },
vk::DescriptorSetLayoutBinding { vk::DescriptorSetLayoutBinding {
binding: 1, binding: 1,
descriptor_type: vk::DescriptorType::COMBINED_IMAGE_SAMPLER, descriptor_type: vk::DescriptorType::COMBINED_IMAGE_SAMPLER,
descriptor_count: 1, descriptor_count: 1,
stage_flags: vk::ShaderStageFlags::FRAGMENT, stage_flags: vk::ShaderStageFlags::FRAGMENT,
p_immutable_samplers: ptr::null(), .. Default::default()
}, },
]; ];
let descriptor_info = vk::DescriptorSetLayoutCreateInfo { let descriptor_info = vk::DescriptorSetLayoutCreateInfo::builder()
s_type: vk::StructureType::DESCRIPTOR_SET_LAYOUT_CREATE_INFO, .bindings(&desc_layout_bindings)
p_next: ptr::null(), .build();
flags: Default::default(),
binding_count: desc_layout_bindings.len() as u32,
p_bindings: desc_layout_bindings.as_ptr(),
};
let desc_set_layouts = [base let desc_set_layouts = [base
.device .device
.create_descriptor_set_layout(&descriptor_info, None) .create_descriptor_set_layout(&descriptor_info, None)
.unwrap()]; .unwrap()];
let desc_alloc_info = vk::DescriptorSetAllocateInfo { let desc_alloc_info = vk::DescriptorSetAllocateInfo::builder()
s_type: vk::StructureType::DESCRIPTOR_SET_ALLOCATE_INFO, .descriptor_pool(descriptor_pool)
p_next: ptr::null(), .set_layouts(&desc_set_layouts)
descriptor_pool: descriptor_pool, .build();
descriptor_set_count: desc_set_layouts.len() as u32,
p_set_layouts: desc_set_layouts.as_ptr(),
};
let descriptor_sets = base let descriptor_sets = base
.device .device
.allocate_descriptor_sets(&desc_alloc_info) .allocate_descriptor_sets(&desc_alloc_info)
@ -607,28 +532,19 @@ fn main() {
let write_desc_sets = [ let write_desc_sets = [
vk::WriteDescriptorSet { vk::WriteDescriptorSet {
s_type: vk::StructureType::WRITE_DESCRIPTOR_SET,
p_next: ptr::null(),
dst_set: descriptor_sets[0], dst_set: descriptor_sets[0],
dst_binding: 0,
dst_array_element: 0,
descriptor_count: 1, descriptor_count: 1,
descriptor_type: vk::DescriptorType::UNIFORM_BUFFER, descriptor_type: vk::DescriptorType::UNIFORM_BUFFER,
p_image_info: ptr::null(),
p_buffer_info: &uniform_color_buffer_descriptor, p_buffer_info: &uniform_color_buffer_descriptor,
p_texel_buffer_view: ptr::null(), .. Default::default()
}, },
vk::WriteDescriptorSet { vk::WriteDescriptorSet {
s_type: vk::StructureType::WRITE_DESCRIPTOR_SET,
p_next: ptr::null(),
dst_set: descriptor_sets[0], dst_set: descriptor_sets[0],
dst_binding: 1, dst_binding: 1,
dst_array_element: 0,
descriptor_count: 1, descriptor_count: 1,
descriptor_type: vk::DescriptorType::COMBINED_IMAGE_SAMPLER, descriptor_type: vk::DescriptorType::COMBINED_IMAGE_SAMPLER,
p_image_info: &tex_descriptor, p_image_info: &tex_descriptor,
p_buffer_info: ptr::null(), .. Default::default()
p_texel_buffer_view: ptr::null(),
}, },
]; ];
base.device.update_descriptor_sets(&write_desc_sets, &[]); base.device.update_descriptor_sets(&write_desc_sets, &[]);
@ -642,21 +558,22 @@ fn main() {
.bytes() .bytes()
.filter_map(|byte| byte.ok()) .filter_map(|byte| byte.ok())
.collect(); .collect();
let vertex_shader_info = vk::ShaderModuleCreateInfo { let vertex_bytes = examples::bytes_to_u32_vec(vertex_bytes.iter().cloned());
s_type: vk::StructureType::SHADER_MODULE_CREATE_INFO,
p_next: ptr::null(), let vertex_shader_info = vk::ShaderModuleCreateInfo::builder()
flags: Default::default(), .code(&vertex_bytes)
code_size: vertex_bytes.len(), .build();
p_code: vertex_bytes.as_ptr() as *const u32,
}; let frag_bytes: Vec<u8> = frag_spv_file.bytes()
let frag_bytes: Vec<u8> = frag_spv_file.bytes().filter_map(|byte| byte.ok()).collect(); .filter_map(|byte| byte.ok())
let frag_shader_info = vk::ShaderModuleCreateInfo { .collect();
s_type: vk::StructureType::SHADER_MODULE_CREATE_INFO,
p_next: ptr::null(), let frag_bytes = examples::bytes_to_u32_vec(frag_bytes.iter().cloned());
flags: Default::default(),
code_size: frag_bytes.len(), let frag_shader_info = vk::ShaderModuleCreateInfo::builder()
p_code: frag_bytes.as_ptr() as *const u32, .code(&frag_bytes)
}; .build();
let vertex_shader_module = base let vertex_shader_module = base
.device .device
.create_shader_module(&vertex_shader_info, None) .create_shader_module(&vertex_shader_info, None)
@ -667,15 +584,9 @@ fn main() {
.create_shader_module(&frag_shader_info, None) .create_shader_module(&frag_shader_info, None)
.expect("Fragment shader module error"); .expect("Fragment shader module error");
let layout_create_info = vk::PipelineLayoutCreateInfo { let layout_create_info = vk::PipelineLayoutCreateInfo::builder()
s_type: vk::StructureType::PIPELINE_LAYOUT_CREATE_INFO, .set_layouts(&desc_set_layouts)
p_next: ptr::null(), .build();
flags: Default::default(),
set_layout_count: desc_set_layouts.len() as u32,
p_set_layouts: desc_set_layouts.as_ptr(),
push_constant_range_count: 0,
p_push_constant_ranges: ptr::null(),
};
let pipeline_layout = base let pipeline_layout = base
.device .device
@ -685,22 +596,16 @@ fn main() {
let shader_entry_name = CString::new("main").unwrap(); let shader_entry_name = CString::new("main").unwrap();
let shader_stage_create_infos = [ let shader_stage_create_infos = [
vk::PipelineShaderStageCreateInfo { vk::PipelineShaderStageCreateInfo {
s_type: vk::StructureType::PIPELINE_SHADER_STAGE_CREATE_INFO,
p_next: ptr::null(),
flags: Default::default(),
module: vertex_shader_module, module: vertex_shader_module,
p_name: shader_entry_name.as_ptr(), p_name: shader_entry_name.as_ptr(),
p_specialization_info: ptr::null(),
stage: vk::ShaderStageFlags::VERTEX, stage: vk::ShaderStageFlags::VERTEX,
.. Default::default()
}, },
vk::PipelineShaderStageCreateInfo { vk::PipelineShaderStageCreateInfo {
s_type: vk::StructureType::PIPELINE_SHADER_STAGE_CREATE_INFO,
p_next: ptr::null(),
flags: Default::default(),
module: fragment_shader_module, module: fragment_shader_module,
p_name: shader_entry_name.as_ptr(), p_name: shader_entry_name.as_ptr(),
p_specialization_info: ptr::null(),
stage: vk::ShaderStageFlags::FRAGMENT, stage: vk::ShaderStageFlags::FRAGMENT,
.. Default::default()
}, },
]; ];
let vertex_input_binding_descriptions = [vk::VertexInputBindingDescription { let vertex_input_binding_descriptions = [vk::VertexInputBindingDescription {
@ -722,22 +627,15 @@ fn main() {
offset: offset_of!(Vertex, uv) as u32, offset: offset_of!(Vertex, uv) as u32,
}, },
]; ];
let vertex_input_state_info = vk::PipelineVertexInputStateCreateInfo { let vertex_input_state_info = vk::PipelineVertexInputStateCreateInfo::builder()
s_type: vk::StructureType::PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO, .vertex_attribute_descriptions(&vertex_input_attribute_descriptions)
p_next: ptr::null(), .vertex_binding_descriptions(&vertex_input_binding_descriptions)
flags: Default::default(), .build();
vertex_attribute_description_count: vertex_input_attribute_descriptions.len() as u32,
p_vertex_attribute_descriptions: vertex_input_attribute_descriptions.as_ptr(), let vertex_input_assembly_state_info = vk::PipelineInputAssemblyStateCreateInfo::builder()
vertex_binding_description_count: vertex_input_binding_descriptions.len() as u32, .topology(vk::PrimitiveTopology::TRIANGLE_LIST)
p_vertex_binding_descriptions: vertex_input_binding_descriptions.as_ptr(), .build();
};
let vertex_input_assembly_state_info = vk::PipelineInputAssemblyStateCreateInfo {
s_type: vk::StructureType::PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO,
flags: Default::default(),
p_next: ptr::null(),
primitive_restart_enable: 0,
topology: vk::PrimitiveTopology::TRIANGLE_LIST,
};
let viewports = [vk::Viewport { let viewports = [vk::Viewport {
x: 0.0, x: 0.0,
y: 0.0, y: 0.0,
@ -750,64 +648,40 @@ fn main() {
offset: vk::Offset2D { x: 0, y: 0 }, offset: vk::Offset2D { x: 0, y: 0 },
extent: base.surface_resolution.clone(), extent: base.surface_resolution.clone(),
}]; }];
let viewport_state_info = vk::PipelineViewportStateCreateInfo {
s_type: vk::StructureType::PIPELINE_VIEWPORT_STATE_CREATE_INFO, let viewport_state_info = vk::PipelineViewportStateCreateInfo::builder()
p_next: ptr::null(), .scissors(&scissors)
flags: Default::default(), .viewports(&viewports)
scissor_count: scissors.len() as u32, .build();
p_scissors: scissors.as_ptr(),
viewport_count: viewports.len() as u32,
p_viewports: viewports.as_ptr(),
};
let rasterization_info = vk::PipelineRasterizationStateCreateInfo { let rasterization_info = vk::PipelineRasterizationStateCreateInfo {
s_type: vk::StructureType::PIPELINE_RASTERIZATION_STATE_CREATE_INFO,
p_next: ptr::null(),
flags: Default::default(),
cull_mode: vk::CullModeFlags::NONE,
depth_bias_clamp: 0.0,
depth_bias_constant_factor: 0.0,
depth_bias_enable: 0,
depth_bias_slope_factor: 0.0,
depth_clamp_enable: 0,
front_face: vk::FrontFace::COUNTER_CLOCKWISE, front_face: vk::FrontFace::COUNTER_CLOCKWISE,
line_width: 1.0, line_width: 1.0,
polygon_mode: vk::PolygonMode::FILL, polygon_mode: vk::PolygonMode::FILL,
rasterizer_discard_enable: 0, .. Default::default()
};
let multisample_state_info = vk::PipelineMultisampleStateCreateInfo {
s_type: vk::StructureType::PIPELINE_MULTISAMPLE_STATE_CREATE_INFO,
flags: Default::default(),
p_next: ptr::null(),
rasterization_samples: vk::SampleCountFlags::TYPE_1,
sample_shading_enable: 0,
min_sample_shading: 0.0,
p_sample_mask: ptr::null(),
alpha_to_one_enable: 0,
alpha_to_coverage_enable: 0,
}; };
let multisample_state_info = vk::PipelineMultisampleStateCreateInfo::builder()
.rasterization_samples( vk::SampleCountFlags::TYPE_1)
.build();
let noop_stencil_state = vk::StencilOpState { let noop_stencil_state = vk::StencilOpState {
fail_op: vk::StencilOp::KEEP, fail_op: vk::StencilOp::KEEP,
pass_op: vk::StencilOp::KEEP, pass_op: vk::StencilOp::KEEP,
depth_fail_op: vk::StencilOp::KEEP, depth_fail_op: vk::StencilOp::KEEP,
compare_op: vk::CompareOp::ALWAYS, compare_op: vk::CompareOp::ALWAYS,
compare_mask: 0, .. Default::default()
write_mask: 0,
reference: 0,
}; };
let depth_state_info = vk::PipelineDepthStencilStateCreateInfo { let depth_state_info = vk::PipelineDepthStencilStateCreateInfo {
s_type: vk::StructureType::PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO,
p_next: ptr::null(),
flags: Default::default(),
depth_test_enable: 1, depth_test_enable: 1,
depth_write_enable: 1, depth_write_enable: 1,
depth_compare_op: vk::CompareOp::LESS_OR_EQUAL, depth_compare_op: vk::CompareOp::LESS_OR_EQUAL,
depth_bounds_test_enable: 0,
stencil_test_enable: 0,
front: noop_stencil_state.clone(), front: noop_stencil_state.clone(),
back: noop_stencil_state.clone(), back: noop_stencil_state.clone(),
max_depth_bounds: 1.0, max_depth_bounds: 1.0,
min_depth_bounds: 0.0, .. Default::default()
}; };
let color_blend_attachment_states = [vk::PipelineColorBlendAttachmentState { let color_blend_attachment_states = [vk::PipelineColorBlendAttachmentState {
blend_enable: 0, blend_enable: 0,
src_color_blend_factor: vk::BlendFactor::SRC_COLOR, src_color_blend_factor: vk::BlendFactor::SRC_COLOR,
@ -818,45 +692,30 @@ fn main() {
alpha_blend_op: vk::BlendOp::ADD, alpha_blend_op: vk::BlendOp::ADD,
color_write_mask: vk::ColorComponentFlags::all(), color_write_mask: vk::ColorComponentFlags::all(),
}]; }];
let color_blend_state = vk::PipelineColorBlendStateCreateInfo { let color_blend_state = vk::PipelineColorBlendStateCreateInfo::builder()
s_type: vk::StructureType::PIPELINE_COLOR_BLEND_STATE_CREATE_INFO, .logic_op(vk::LogicOp::CLEAR)
p_next: ptr::null(), .attachments(&color_blend_attachment_states)
flags: Default::default(), .build();
logic_op_enable: 0,
logic_op: vk::LogicOp::CLEAR,
attachment_count: color_blend_attachment_states.len() as u32,
p_attachments: color_blend_attachment_states.as_ptr(),
blend_constants: [0.0, 0.0, 0.0, 0.0],
};
let dynamic_state = [vk::DynamicState::VIEWPORT, vk::DynamicState::SCISSOR]; let dynamic_state = [vk::DynamicState::VIEWPORT, vk::DynamicState::SCISSOR];
let dynamic_state_info = vk::PipelineDynamicStateCreateInfo { let dynamic_state_info = vk::PipelineDynamicStateCreateInfo::builder()
s_type: vk::StructureType::PIPELINE_DYNAMIC_STATE_CREATE_INFO, .dynamic_states(&dynamic_state)
p_next: ptr::null(), .build();
flags: Default::default(),
dynamic_state_count: dynamic_state.len() as u32, let graphic_pipeline_info = vk::GraphicsPipelineCreateInfo::builder()
p_dynamic_states: dynamic_state.as_ptr(), .stages(&shader_stage_create_infos)
}; .vertex_input_state(&vertex_input_state_info)
let graphic_pipeline_info = vk::GraphicsPipelineCreateInfo { .input_assembly_state(&vertex_input_assembly_state_info)
s_type: vk::StructureType::GRAPHICS_PIPELINE_CREATE_INFO, .viewport_state(&viewport_state_info)
p_next: ptr::null(), .rasterization_state(&rasterization_info)
flags: vk::PipelineCreateFlags::empty(), .multisample_state(&multisample_state_info)
stage_count: shader_stage_create_infos.len() as u32, .depth_stencil_state(&depth_state_info)
p_stages: shader_stage_create_infos.as_ptr(), .color_blend_state(&color_blend_state)
p_vertex_input_state: &vertex_input_state_info, .dynamic_state(&dynamic_state_info)
p_input_assembly_state: &vertex_input_assembly_state_info, .layout(pipeline_layout)
p_tessellation_state: ptr::null(), .render_pass(renderpass)
p_viewport_state: &viewport_state_info, .build();
p_rasterization_state: &rasterization_info,
p_multisample_state: &multisample_state_info,
p_depth_stencil_state: &depth_state_info,
p_color_blend_state: &color_blend_state,
p_dynamic_state: &dynamic_state_info,
layout: pipeline_layout,
render_pass: renderpass,
subpass: 0,
base_pipeline_handle: vk::Pipeline::null(),
base_pipeline_index: 0,
};
let graphics_pipelines = base let graphics_pipelines = base
.device .device
.create_graphics_pipelines(vk::PipelineCache::null(), &[graphic_pipeline_info], None) .create_graphics_pipelines(vk::PipelineCache::null(), &[graphic_pipeline_info], None)
@ -887,18 +746,16 @@ fn main() {
}, },
]; ];
let render_pass_begin_info = vk::RenderPassBeginInfo { let render_pass_begin_info = vk::RenderPassBeginInfo::builder()
s_type: vk::StructureType::RENDER_PASS_BEGIN_INFO, .render_pass(renderpass)
p_next: ptr::null(), .framebuffer(framebuffers[present_index as usize])
render_pass: renderpass, .render_area(vk::Rect2D {
framebuffer: framebuffers[present_index as usize],
render_area: vk::Rect2D {
offset: vk::Offset2D { x: 0, y: 0 }, offset: vk::Offset2D { x: 0, y: 0 },
extent: base.surface_resolution.clone(), extent: base.surface_resolution.clone(),
}, })
clear_value_count: clear_values.len() as u32, .clear_values(&clear_values)
p_clear_values: clear_values.as_ptr(), .build();
};
record_submit_commandbuffer( record_submit_commandbuffer(
&base.device, &base.device,
base.draw_command_buffer, base.draw_command_buffer,
@ -953,16 +810,13 @@ fn main() {
}, },
); );
//let mut present_info_err = mem::uninitialized(); //let mut present_info_err = mem::uninitialized();
let present_info = vk::PresentInfoKHR {
s_type: vk::StructureType::PRESENT_INFO_KHR, let present_info = vk::PresentInfoKHR::builder()
p_next: ptr::null(), .wait_semaphores(&[base.rendering_complete_semaphore])
wait_semaphore_count: 1, .swapchains( &[base.swapchain])
p_wait_semaphores: &base.rendering_complete_semaphore, .image_indices( &[present_index])
swapchain_count: 1, .build();
p_swapchains: &base.swapchain,
p_image_indices: &present_index,
p_results: ptr::null_mut(),
};
base.swapchain_loader base.swapchain_loader
.queue_present_khr(base.present_queue, &present_info) .queue_present_khr(base.present_queue, &present_info)
.unwrap(); .unwrap();

385
examples/src/lib.rs
View file

@ -2,6 +2,7 @@
extern crate ash; extern crate ash;
#[cfg(target_os = "windows")] #[cfg(target_os = "windows")]
extern crate winapi; extern crate winapi;
extern crate winit; extern crate winit;
#[cfg(target_os = "macos")] #[cfg(target_os = "macos")]
@ -38,7 +39,7 @@ use std::default::Default;
use std::ffi::{CStr, CString}; use std::ffi::{CStr, CString};
use std::ops::Drop; use std::ops::Drop;
use std::os::raw::{c_char, c_void}; use std::os::raw::{c_char, c_void};
use std::ptr;
// Simple offset_of macro akin to C++ offsetof // Simple offset_of macro akin to C++ offsetof
#[macro_export] #[macro_export]
@ -52,6 +53,34 @@ macro_rules! offset_of {
}}; }};
} }
fn u32_from_bytes(bytes: &[u8; 4]) -> u32 {
unsafe {
std::mem::transmute(*bytes)
}
}
pub fn bytes_to_u32_vec<B>(bytes:B) -> Vec<u32>
where B: Iterator<Item=u8>
{
let mut output = vec![];
let mut buffer: [u8;4] = [0,0,0,0];
for (i,b) in bytes.enumerate() {
match i % 4 {
3 => {
buffer[3] = b;
output.push(u32_from_bytes(&buffer));
buffer = [0,0,0,0];
},
idx => buffer[idx] = b
}
}
if buffer != [0,0,0,0] {
output.push(u32_from_bytes(&buffer));
}
output
}
pub fn record_submit_commandbuffer<D: DeviceV1_0, F: FnOnce(&D, vk::CommandBuffer)>( pub fn record_submit_commandbuffer<D: DeviceV1_0, F: FnOnce(&D, vk::CommandBuffer)>(
device: &D, device: &D,
command_buffer: vk::CommandBuffer, command_buffer: vk::CommandBuffer,
@ -67,12 +96,9 @@ pub fn record_submit_commandbuffer<D: DeviceV1_0, F: FnOnce(&D, vk::CommandBuffe
command_buffer, command_buffer,
vk::CommandBufferResetFlags::RELEASE_RESOURCES, vk::CommandBufferResetFlags::RELEASE_RESOURCES,
).expect("Reset command buffer failed."); ).expect("Reset command buffer failed.");
let command_buffer_begin_info = vk::CommandBufferBeginInfo {
s_type: vk::StructureType::COMMAND_BUFFER_BEGIN_INFO, let command_buffer_begin_info = vk::CommandBufferBeginInfo::default();
p_next: ptr::null(),
p_inheritance_info: ptr::null(),
flags: vk::CommandBufferUsageFlags::ONE_TIME_SUBMIT,
};
device device
.begin_command_buffer(command_buffer, &command_buffer_begin_info) .begin_command_buffer(command_buffer, &command_buffer_begin_info)
.expect("Begin commandbuffer"); .expect("Begin commandbuffer");
@ -80,25 +106,20 @@ pub fn record_submit_commandbuffer<D: DeviceV1_0, F: FnOnce(&D, vk::CommandBuffe
device device
.end_command_buffer(command_buffer) .end_command_buffer(command_buffer)
.expect("End commandbuffer"); .expect("End commandbuffer");
let fence_create_info = vk::FenceCreateInfo {
s_type: vk::StructureType::FENCE_CREATE_INFO, let fence_create_info = vk::FenceCreateInfo::default();
p_next: ptr::null(),
flags: vk::FenceCreateFlags::empty(),
};
let submit_fence = device let submit_fence = device
.create_fence(&fence_create_info, None) .create_fence(&fence_create_info, None)
.expect("Create fence failed."); .expect("Create fence failed.");
let submit_info = vk::SubmitInfo {
s_type: vk::StructureType::SUBMIT_INFO, let submit_info = vk::SubmitInfo::builder()
p_next: ptr::null(), .wait_semaphores(wait_semaphores)
wait_semaphore_count: wait_semaphores.len() as u32, .command_buffers(&[command_buffer])
p_wait_semaphores: wait_semaphores.as_ptr(), .signal_semaphores(signal_semaphores)
p_wait_dst_stage_mask: wait_mask.as_ptr(), .wait_dst_stage_mask(wait_mask)
command_buffer_count: 1, .build();
p_command_buffers: &command_buffer,
signal_semaphore_count: signal_semaphores.len() as u32,
p_signal_semaphores: signal_semaphores.as_ptr(),
};
device device
.queue_submit(submit_queue, &[submit_info], submit_fence) .queue_submit(submit_queue, &[submit_info], submit_fence)
.expect("queue submit failed."); .expect("queue submit failed.");
@ -118,13 +139,10 @@ unsafe fn create_surface<E: EntryV1_0, I: InstanceV1_0>(
use winit::os::unix::WindowExt; use winit::os::unix::WindowExt;
let x11_display = window.get_xlib_display().unwrap(); let x11_display = window.get_xlib_display().unwrap();
let x11_window = window.get_xlib_window().unwrap(); let x11_window = window.get_xlib_window().unwrap();
let x11_create_info = vk::XlibSurfaceCreateInfoKHR { let x11_create_info = vk::XlibSurfaceCreateInfoKHR::builder()
s_type: vk::StructureType::XLIB_SURFACE_CREATE_INFO_KHR, .window(x11_window as vk::Window)
p_next: ptr::null(), .dpy(x11_display as *mut vk::Display)
flags: Default::default(), .build();
window: x11_window as vk::Window,
dpy: x11_display as *mut vk::Display,
};
let xlib_surface_loader = XlibSurface::new(entry, instance); let xlib_surface_loader = XlibSurface::new(entry, instance);
xlib_surface_loader.create_xlib_surface_khr(&x11_create_info, None) xlib_surface_loader.create_xlib_surface_khr(&x11_create_info, None)
} }
@ -333,7 +351,6 @@ impl ExampleBase {
.unwrap(); .unwrap();
let entry = Entry::new().unwrap(); let entry = Entry::new().unwrap();
let app_name = CString::new("VulkanTriangle").unwrap(); let app_name = CString::new("VulkanTriangle").unwrap();
let raw_name = app_name.as_ptr();
let layer_names = [CString::new("VK_LAYER_LUNARG_standard_validation").unwrap()]; let layer_names = [CString::new("VK_LAYER_LUNARG_standard_validation").unwrap()];
let layers_names_raw: Vec<*const i8> = layer_names let layers_names_raw: Vec<*const i8> = layer_names
@ -342,37 +359,34 @@ impl ExampleBase {
.collect(); .collect();
let extension_names_raw = extension_names(); let extension_names_raw = extension_names();
let appinfo = vk::ApplicationInfo {
p_application_name: raw_name, let appinfo = vk::ApplicationInfo::builder()
s_type: vk::StructureType::APPLICATION_INFO, .application_name(&app_name )
p_next: ptr::null(), .application_version(0)
application_version: 0, .engine_name(&app_name)
p_engine_name: raw_name, .engine_version(0)
engine_version: 0, .api_version(vk_make_version!(1,0,36))
api_version: vk_make_version!(1, 0, 36), .build();
};
let create_info = vk::InstanceCreateInfo { let create_info = vk::InstanceCreateInfo::builder()
s_type: vk::StructureType::INSTANCE_CREATE_INFO, .application_info(&appinfo)
p_next: ptr::null(), .enabled_layer_names(&layers_names_raw)
flags: Default::default(), .enabled_extension_names(&extension_names_raw )
p_application_info: &appinfo, .build();
pp_enabled_layer_names: layers_names_raw.as_ptr(),
enabled_layer_count: layers_names_raw.len() as u32,
pp_enabled_extension_names: extension_names_raw.as_ptr(),
enabled_extension_count: extension_names_raw.len() as u32,
};
let instance: Instance = entry let instance: Instance = entry
.create_instance(&create_info, None) .create_instance(&create_info, None)
.expect("Instance creation error"); .expect("Instance creation error");
let debug_info = vk::DebugReportCallbackCreateInfoEXT {
s_type: vk::StructureType::DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT, let debug_info = vk::DebugReportCallbackCreateInfoEXT::builder()
p_next: ptr::null(), .pfn_callback(Some(vulkan_debug_callback))
flags: vk::DebugReportFlagsEXT::ERROR .flags(
vk::DebugReportFlagsEXT::ERROR
| vk::DebugReportFlagsEXT::WARNING | vk::DebugReportFlagsEXT::WARNING
| vk::DebugReportFlagsEXT::PERFORMANCE_WARNING, | vk::DebugReportFlagsEXT::PERFORMANCE_WARNING
pfn_callback: Some(vulkan_debug_callback), )
p_user_data: ptr::null_mut(), .build();
};
let debug_report_loader = DebugReport::new(&entry, &instance); let debug_report_loader = DebugReport::new(&entry, &instance);
let debug_call_back = debug_report_loader let debug_call_back = debug_report_loader
.create_debug_report_callback_ext(&debug_info, None) .create_debug_report_callback_ext(&debug_info, None)
@ -412,26 +426,18 @@ impl ExampleBase {
..Default::default() ..Default::default()
}; };
let priorities = [1.0]; let priorities = [1.0];
let queue_info = vk::DeviceQueueCreateInfo {
s_type: vk::StructureType::DEVICE_QUEUE_CREATE_INFO, let queue_info = vk::DeviceQueueCreateInfo::builder()
p_next: ptr::null(), .queue_family_index(queue_family_index as u32 )
flags: Default::default(), .queue_priorities(&priorities)
queue_family_index: queue_family_index as u32, .build();
p_queue_priorities: priorities.as_ptr(),
queue_count: priorities.len() as u32, let device_create_info = vk::DeviceCreateInfo::builder()
}; .queue_create_infos(&[queue_info])
let device_create_info = vk::DeviceCreateInfo { .enabled_extension_names(&device_extension_names_raw)
s_type: vk::StructureType::DEVICE_CREATE_INFO, .enabled_features(&features)
p_next: ptr::null(), .build();
flags: Default::default(),
queue_create_info_count: 1,
p_queue_create_infos: &queue_info,
enabled_layer_count: 0,
pp_enabled_layer_names: ptr::null(),
enabled_extension_count: device_extension_names_raw.len() as u32,
pp_enabled_extension_names: device_extension_names_raw.as_ptr(),
p_enabled_features: &features,
};
let device: Device = instance let device: Device = instance
.create_device(pdevice, &device_create_info, None) .create_device(pdevice, &device_create_info, None)
.unwrap(); .unwrap();
@ -483,43 +489,38 @@ impl ExampleBase {
.find(|&mode| mode == vk::PresentModeKHR::MAILBOX) .find(|&mode| mode == vk::PresentModeKHR::MAILBOX)
.unwrap_or(vk::PresentModeKHR::FIFO); .unwrap_or(vk::PresentModeKHR::FIFO);
let swapchain_loader = Swapchain::new(&instance, &device); let swapchain_loader = Swapchain::new(&instance, &device);
let swapchain_create_info = vk::SwapchainCreateInfoKHR {
s_type: vk::StructureType::SWAPCHAIN_CREATE_INFO_KHR, let swapchain_create_info = vk::SwapchainCreateInfoKHR::builder()
p_next: ptr::null(), .surface(surface)
flags: Default::default(), .min_image_count(desired_image_count)
surface: surface, .image_color_space(surface_format.color_space)
min_image_count: desired_image_count, .image_format(surface_format.format)
image_color_space: surface_format.color_space, .image_extent(surface_resolution.clone())
image_format: surface_format.format, .image_usage(vk::ImageUsageFlags::COLOR_ATTACHMENT)
image_extent: surface_resolution.clone(), .pre_transform(pre_transform)
image_usage: vk::ImageUsageFlags::COLOR_ATTACHMENT, .composite_alpha(vk::CompositeAlphaFlagsKHR::OPAQUE)
image_sharing_mode: vk::SharingMode::EXCLUSIVE, .present_mode(present_mode)
pre_transform: pre_transform, // .clipped(true)
composite_alpha: vk::CompositeAlphaFlagsKHR::OPAQUE, .image_array_layers(1)
present_mode: present_mode, .build();
clipped: 1,
old_swapchain: vk::SwapchainKHR::null(),
image_array_layers: 1,
p_queue_family_indices: ptr::null(),
queue_family_index_count: 0,
};
let swapchain = swapchain_loader let swapchain = swapchain_loader
.create_swapchain_khr(&swapchain_create_info, None) .create_swapchain_khr(&swapchain_create_info, None)
.unwrap(); .unwrap();
let pool_create_info = vk::CommandPoolCreateInfo {
s_type: vk::StructureType::COMMAND_POOL_CREATE_INFO, let pool_create_info = vk::CommandPoolCreateInfo::builder()
p_next: ptr::null(), .queue_family_index(queue_family_index)
flags: vk::CommandPoolCreateFlags::RESET_COMMAND_BUFFER, .flags(vk::CommandPoolCreateFlags::RESET_COMMAND_BUFFER)
queue_family_index: queue_family_index, .build();
};
let pool = device.create_command_pool(&pool_create_info, None).unwrap(); let pool = device.create_command_pool(&pool_create_info, None).unwrap();
let command_buffer_allocate_info = vk::CommandBufferAllocateInfo {
s_type: vk::StructureType::COMMAND_BUFFER_ALLOCATE_INFO, let command_buffer_allocate_info = vk::CommandBufferAllocateInfo::builder()
p_next: ptr::null(), .command_buffer_count(2)
command_buffer_count: 2, .command_pool(pool)
command_pool: pool, .level(vk::CommandBufferLevel::PRIMARY)
level: vk::CommandBufferLevel::PRIMARY, .build();
};
let command_buffers = device let command_buffers = device
.allocate_command_buffers(&command_buffer_allocate_info) .allocate_command_buffers(&command_buffer_allocate_info)
.unwrap(); .unwrap();
@ -532,51 +533,37 @@ impl ExampleBase {
let present_image_views: Vec<vk::ImageView> = present_images let present_image_views: Vec<vk::ImageView> = present_images
.iter() .iter()
.map(|&image| { .map(|&image| {
let create_view_info = vk::ImageViewCreateInfo { let create_view_info = vk::ImageViewCreateInfo::builder()
s_type: vk::StructureType::IMAGE_VIEW_CREATE_INFO, .subresource_range(
p_next: ptr::null(), vk::ImageSubresourceRange::builder()
flags: Default::default(), .aspect_mask(vk::ImageAspectFlags::COLOR)
view_type: vk::ImageViewType::TYPE_2D, .level_count(1)
format: surface_format.format, .layer_count(1)
components: vk::ComponentMapping { .build()
r: vk::ComponentSwizzle::R, )
g: vk::ComponentSwizzle::G, .image(image)
b: vk::ComponentSwizzle::B, .format(surface_format.format)
a: vk::ComponentSwizzle::A, .view_type(vk::ImageViewType::TYPE_2D)
}, .build();
subresource_range: vk::ImageSubresourceRange {
aspect_mask: vk::ImageAspectFlags::COLOR,
base_mip_level: 0,
level_count: 1,
base_array_layer: 0,
layer_count: 1,
},
image: image,
};
device.create_image_view(&create_view_info, None).unwrap() device.create_image_view(&create_view_info, None).unwrap()
}).collect(); }).collect();
let device_memory_properties = instance.get_physical_device_memory_properties(pdevice); let device_memory_properties = instance.get_physical_device_memory_properties(pdevice);
let depth_image_create_info = vk::ImageCreateInfo {
s_type: vk::StructureType::IMAGE_CREATE_INFO, let depth_image_create_info = vk::ImageCreateInfo::builder()
p_next: ptr::null(), .image_type(vk::ImageType::TYPE_2D)
flags: Default::default(), .format(vk::Format::D16_UNORM)
image_type: vk::ImageType::TYPE_2D, .extent(vk::Extent3D {
format: vk::Format::D16_UNORM,
extent: vk::Extent3D {
width: surface_resolution.width, width: surface_resolution.width,
height: surface_resolution.height, height: surface_resolution.height,
depth: 1, depth: 1
}, })
mip_levels: 1, .mip_levels(1)
array_layers: 1, .array_layers(1)
samples: vk::SampleCountFlags::TYPE_1, .samples(vk::SampleCountFlags::TYPE_1)
tiling: vk::ImageTiling::OPTIMAL, .usage(vk::ImageUsageFlags::DEPTH_STENCIL_ATTACHMENT)
usage: vk::ImageUsageFlags::DEPTH_STENCIL_ATTACHMENT, .build();
sharing_mode: vk::SharingMode::EXCLUSIVE,
queue_family_index_count: 0,
p_queue_family_indices: ptr::null(),
initial_layout: vk::ImageLayout::UNDEFINED,
};
let depth_image = device.create_image(&depth_image_create_info, None).unwrap(); let depth_image = device.create_image(&depth_image_create_info, None).unwrap();
let depth_image_memory_req = device.get_image_memory_requirements(depth_image); let depth_image_memory_req = device.get_image_memory_requirements(depth_image);
let depth_image_memory_index = find_memorytype_index( let depth_image_memory_index = find_memorytype_index(
@ -585,45 +572,45 @@ impl ExampleBase {
vk::MemoryPropertyFlags::DEVICE_LOCAL, vk::MemoryPropertyFlags::DEVICE_LOCAL,
).expect("Unable to find suitable memory index for depth image."); ).expect("Unable to find suitable memory index for depth image.");
let depth_image_allocate_info = vk::MemoryAllocateInfo {
s_type: vk::StructureType::MEMORY_ALLOCATE_INFO, let depth_image_allocate_info = vk::MemoryAllocateInfo::builder()
p_next: ptr::null(), .allocation_size(depth_image_memory_req.size)
allocation_size: depth_image_memory_req.size, .memory_type_index(depth_image_memory_index)
memory_type_index: depth_image_memory_index, .build();
};
let depth_image_memory = device let depth_image_memory = device
.allocate_memory(&depth_image_allocate_info, None) .allocate_memory(&depth_image_allocate_info, None)
.unwrap(); .unwrap();
device device
.bind_image_memory(depth_image, depth_image_memory, 0) .bind_image_memory(depth_image, depth_image_memory, 0)
.expect("Unable to bind depth image memory"); .expect("Unable to bind depth image memory");
record_submit_commandbuffer( record_submit_commandbuffer(
&device, &device,
setup_command_buffer, setup_command_buffer,
present_queue, present_queue,
&[vk::PipelineStageFlags::BOTTOM_OF_PIPE], &[],
&[], &[],
&[], &[],
|device, setup_command_buffer| { |device, setup_command_buffer| {
let layout_transition_barrier = vk::ImageMemoryBarrier { let layout_transition_barrier = vk::ImageMemoryBarrier::builder()
s_type: vk::StructureType::IMAGE_MEMORY_BARRIER, .image(depth_image)
p_next: ptr::null(), .dst_access_mask(
src_access_mask: Default::default(), vk::AccessFlags::DEPTH_STENCIL_ATTACHMENT_READ
dst_access_mask: vk::AccessFlags::DEPTH_STENCIL_ATTACHMENT_READ | vk::AccessFlags::DEPTH_STENCIL_ATTACHMENT_WRITE
| vk::AccessFlags::DEPTH_STENCIL_ATTACHMENT_WRITE, )
old_layout: vk::ImageLayout::UNDEFINED, .new_layout(vk::ImageLayout::DEPTH_STENCIL_ATTACHMENT_OPTIMAL)
new_layout: vk::ImageLayout::DEPTH_STENCIL_ATTACHMENT_OPTIMAL, .old_layout(vk::ImageLayout::UNDEFINED)
src_queue_family_index: vk::QUEUE_FAMILY_IGNORED, .subresource_range(
dst_queue_family_index: vk::QUEUE_FAMILY_IGNORED, vk::ImageSubresourceRange::builder()
image: depth_image, .aspect_mask(vk::ImageAspectFlags::DEPTH)
subresource_range: vk::ImageSubresourceRange { .layer_count(1)
aspect_mask: vk::ImageAspectFlags::DEPTH, .level_count(1)
base_mip_level: 0, .build()
level_count: 1, )
base_array_layer: 0, .build();
layer_count: 1,
},
};
device.cmd_pipeline_barrier( device.cmd_pipeline_barrier(
setup_command_buffer, setup_command_buffer,
vk::PipelineStageFlags::BOTTOM_OF_PIPE, vk::PipelineStageFlags::BOTTOM_OF_PIPE,
@ -635,35 +622,27 @@ impl ExampleBase {
); );
}, },
); );
let depth_image_view_info = vk::ImageViewCreateInfo {
s_type: vk::StructureType::IMAGE_VIEW_CREATE_INFO, let depth_image_view_info = vk::ImageViewCreateInfo::builder()
p_next: ptr::null(), .subresource_range(
flags: Default::default(), vk::ImageSubresourceRange::builder()
view_type: vk::ImageViewType::TYPE_2D, .aspect_mask(vk::ImageAspectFlags::DEPTH)
format: depth_image_create_info.format, .level_count(1)
components: vk::ComponentMapping { .layer_count(1)
r: vk::ComponentSwizzle::IDENTITY, .build()
g: vk::ComponentSwizzle::IDENTITY, )
b: vk::ComponentSwizzle::IDENTITY, .image(depth_image)
a: vk::ComponentSwizzle::IDENTITY, .format(depth_image_create_info.format)
}, .view_type(vk::ImageViewType::TYPE_2D)
subresource_range: vk::ImageSubresourceRange { .build();
aspect_mask: vk::ImageAspectFlags::DEPTH,
base_mip_level: 0,
level_count: 1,
base_array_layer: 0,
layer_count: 1,
},
image: depth_image,
};
let depth_image_view = device let depth_image_view = device
.create_image_view(&depth_image_view_info, None) .create_image_view(&depth_image_view_info, None)
.unwrap(); .unwrap();
let semaphore_create_info = vk::SemaphoreCreateInfo {
s_type: vk::StructureType::SEMAPHORE_CREATE_INFO,
p_next: ptr::null(), let semaphore_create_info = vk::SemaphoreCreateInfo::default();
flags: Default::default(),
};
let present_complete_semaphore = device let present_complete_semaphore = device
.create_semaphore(&semaphore_create_info, None) .create_semaphore(&semaphore_create_info, None)
.unwrap(); .unwrap();