WIP: Feature multiview

examples/colour-uniform/main.rs

@@ -686,12 +686,13 @@ impl<B: Backend> RenderPassState<B> {
  inputs: &[],
  resolves: &[],
  preserves: &[],
+ view_mask: 0,
  };
 
  device
  .borrow()
  .device
- .create_render_pass(&[attachment], &[subpass], &[])
+ .create_render_pass(&[attachment], &[subpass], &[], None)
  .ok()
  };
 

examples/mesh-shading/main.rs

@@ -379,10 +379,11 @@ where
  inputs: &[],
  resolves: &[],
  preserves: &[],
+ view_mask: 0,
  };
 
  ManuallyDrop::new(
- unsafe { device.create_render_pass(&[attachment], &[subpass], &[]) }
+ unsafe { device.create_render_pass(&[attachment], &[subpass], &[], None) }
  .expect("Can't create render pass"),
  )
  };

examples/quad/main.rs

@@ -584,10 +584,11 @@ where
  inputs: &[],
  resolves: &[],
  preserves: &[],
+ view_mask: 0,
  };
 
  ManuallyDrop::new(
- unsafe { device.create_render_pass(&[attachment], &[subpass], &[]) }
+ unsafe { device.create_render_pass(&[attachment], &[subpass], &[], None) }
  .expect("Can't create render pass"),
  )
  };

src/backend/dx11/src/device.rs

@@ -812,6 +812,7 @@ impl device::Device<Backend> for Device {
  attachments: IA,
  subpasses: IS,
  _dependencies: ID,
+ _correlation_masks: Option<&[u32]>,
  ) -> Result<RenderPass, device::OutOfMemory>
  where
  IA: IntoIterator,

src/backend/dx12/src/device.rs

@@ -1249,6 +1249,7 @@ impl d::Device<B> for Device {
  attachments: IA,
  subpasses: IS,
  dependencies: ID,
+ _correlation_masks: Option<&[u32]>,
  ) -> Result<r::RenderPass, d::OutOfMemory>
  where
  IA: IntoIterator,

src/backend/empty/src/lib.rs

@@ -230,6 +230,7 @@ impl device::Device<Backend> for Device {
  _: IA,
  _: IS,
  _: ID,
+ _: Option<&[u32]>,
  ) -> Result<(), device::OutOfMemory>
  where
  IA: IntoIterator,

src/backend/gl/src/device.rs

@@ -605,6 +605,7 @@ impl d::Device<B> for Device {
  attachments: IA,
  subpasses: IS,
  _dependencies: ID,
+ correlation_masks: Option<&[u32]>,
  ) -> Result<n::RenderPass, d::OutOfMemory>
  where
  IA: IntoIterator,

src/backend/metal/src/device.rs

@@ -971,6 +971,7 @@ impl hal::device::Device<Backend> for Device {
  attachments: IA,
  subpasses: IS,
  _dependencies: ID,
+ _correlation_masks: Option<&[u32]>,
  ) -> Result<n::RenderPass, OutOfMemory>
  where
  IA: IntoIterator,

src/backend/vulkan/src/device.rs

@@ -555,6 +555,7 @@ impl d::Device<B> for Device {
  attachments: IA,
  subpasses: IS,
  dependencies: ID,
+ correlation_masks: Option<&[u32]>,
  ) -> Result<n::RenderPass, d::OutOfMemory>
  where
  IA: IntoIterator,
@@ -587,109 +588,146 @@ impl d::Device<B> for Device {
  final_layout: conv::map_image_layout(attachment.layouts.end),
  }
  });
+ let dependencies = dependencies.into_iter();
 
- let dependencies = dependencies
- .into_iter()
- .map(|subpass_dep| {
- let sdep = subpass_dep.borrow();
- // TODO: checks
- vk::SubpassDependency {
- src_subpass: sdep
- .passes
- .start
- .map_or(vk::SUBPASS_EXTERNAL, |id| id as u32),
- dst_subpass: sdep.passes.end.map_or(vk::SUBPASS_EXTERNAL, |id| id as u32),
- src_stage_mask: conv::map_pipeline_stage(sdep.stages.start),
- dst_stage_mask: conv::map_pipeline_stage(sdep.stages.end),
- src_access_mask: conv::map_image_access(sdep.accesses.start),
- dst_access_mask: conv::map_image_access(sdep.accesses.end),
- dependency_flags: mem::transmute(sdep.flags),
- }
- });
+ let (clear_attachments_mask, result) = inplace_it::inplace_or_alloc_array(dependencies.len(), |uninit_guard_dependencies| {
+ let dependencies = uninit_guard_dependencies.init_with_iter(dependencies);
 
- let (clear_attachments_mask, result) = inplace_it::inplace_or_alloc_array(attachments.len(), |uninit_guard| {
- let attachments = uninit_guard.init_with_iter(attachments);
-
- let clear_attachments_mask = attachments
+ let vk_dependencies = dependencies
  .iter()
- .enumerate()
- .filter_map(|(i, at)| {
- if at.load_op == vk::AttachmentLoadOp::CLEAR
- || at.stencil_load_op == vk::AttachmentLoadOp::CLEAR
- {
- Some(1 << i as u64)
- } else {
- None
+ .map(|subpass_dep| {
+ let sdep = subpass_dep.borrow();
+ // TODO: checks
+ vk::SubpassDependency {
+ src_subpass: sdep
+ .passes
+ .start
+ .map_or(vk::SUBPASS_EXTERNAL, |id| id as u32),
+ dst_subpass: sdep.passes.end.map_or(vk::SUBPASS_EXTERNAL, |id| id as u32),
+ src_stage_mask: conv::map_pipeline_stage(sdep.stages.start),
+ dst_stage_mask: conv::map_pipeline_stage(sdep.stages.end),
+ src_access_mask: conv::map_image_access(sdep.accesses.start),
+ dst_access_mask: conv::map_image_access(sdep.accesses.end),
+ dependency_flags: mem::transmute(sdep.flags),
  }
- })
- .sum();
+ });
 
- let attachment_refs = subpasses
- .into_iter()
- .map(|subpass| {
- let subpass = subpass.borrow();
- fn make_ref(&(id, layout): &pass::AttachmentRef) -> vk::AttachmentReference {
- vk::AttachmentReference {
- attachment: id as _,
- layout: conv::map_image_layout(layout),
- }
- }
- let colors = subpass.colors.iter().map(make_ref).collect::<Box<[_]>>();
- let depth_stencil = subpass.depth_stencil.map(make_ref);
- let inputs = subpass.inputs.iter().map(make_ref).collect::<Box<[_]>>();
- let preserves = subpass
- .preserves
- .iter()
- .map(|&id| id as u32)
- .collect::<Box<[_]>>();
- let resolves = subpass.resolves.iter().map(make_ref).collect::<Box<[_]>>();
-
- (colors, depth_stencil, inputs, preserves, resolves)
- })
- .collect::<Box<[_]>>();
+ let (clear_attachments_mask, result) = inplace_it::inplace_or_alloc_array(attachments.len(), |uninit_guard_attachments| {
+ let attachments = uninit_guard_attachments.init_with_iter(attachments);
 
- let subpasses = attachment_refs
- .iter()
- .map(|(colors, depth_stencil, inputs, preserves, resolves)| {
- vk::SubpassDescription {
- flags: vk::SubpassDescriptionFlags::empty(),
- pipeline_bind_point: vk::PipelineBindPoint::GRAPHICS,
- input_attachment_count: inputs.len() as u32,
- p_input_attachments: inputs.as_ptr(),
- color_attachment_count: colors.len() as u32,
- p_color_attachments: colors.as_ptr(),
- p_resolve_attachments: if resolves.is_empty() {
- ptr::null()
+ let clear_attachments_mask = attachments
+ .iter()
+ .enumerate()
+ .filter_map(|(i, at)| {
+ if at.load_op == vk::AttachmentLoadOp::CLEAR
+ || at.stencil_load_op == vk::AttachmentLoadOp::CLEAR
+ {
+ Some(1 << i as u64)
  } else {
- resolves.as_ptr()
- },
- p_depth_stencil_attachment: match depth_stencil {
- Some(ref aref) => aref as *const _,
- None => ptr::null(),
- },
- preserve_attachment_count: preserves.len() as u32,
- p_preserve_attachments: preserves.as_ptr(),
- }
- })
- .collect::<Box<[_]>>();
+ None
+ }
+ })
+ .sum();
+
+ let attachment_refs = subpasses
+ .into_iter()
+ .map(|subpass| {
+ let subpass = subpass.borrow();
+ fn make_ref(&(id, layout): &pass::AttachmentRef) -> vk::AttachmentReference {
+ vk::AttachmentReference {
+ attachment: id as _,
+ layout: conv::map_image_layout(layout),
+ }
+ }
+ let colors = subpass.colors.iter().map(make_ref).collect::<Box<[_]>>();
+ let depth_stencil = subpass.depth_stencil.map(make_ref);
+ let inputs = subpass.inputs.iter().map(make_ref).collect::<Box<[_]>>();
+ let preserves = subpass
+ .preserves
+ .iter()
+ .map(|&id| id as u32)
+ .collect::<Box<[_]>>();
+ let resolves = subpass.resolves.iter().map(make_ref).collect::<Box<[_]>>();
+
+ (colors, depth_stencil, inputs, preserves, resolves, subpass.view_mask)
+ })
+ .collect::<Box<[_]>>();
 
- let result = inplace_it::inplace_or_alloc_array(dependencies.len(), |uninit_guard| {
- let dependencies =
- uninit_guard.init_with_iter(dependencies);
+ let subpasses = attachment_refs
+ .iter()
+ .map(|(colors, depth_stencil, inputs, preserves, resolves, _view_mask)| {
+ vk::SubpassDescription {
+ flags: vk::SubpassDescriptionFlags::empty(),
+ pipeline_bind_point: vk::PipelineBindPoint::GRAPHICS,
+ input_attachment_count: inputs.len() as u32,
+ p_input_attachments: inputs.as_ptr(),
+ color_attachment_count: colors.len() as u32,
+ p_color_attachments: colors.as_ptr(),
+ p_resolve_attachments: if resolves.is_empty() {
+ ptr::null()
+ } else {
+ resolves.as_ptr()
+ },
+ p_depth_stencil_attachment: match depth_stencil {
+ Some(ref aref) => aref as *const _,
+ None => ptr::null(),
+ },
+ preserve_attachment_count: preserves.len() as u32,
+ p_preserve_attachments: preserves.as_ptr(),
+ }
+ })
+ .collect::<Box<[_]>>();
+
+ let multiview_enabled = self.shared.features.contains(Features::MULTIVIEW);
+
+ let view_masks = if multiview_enabled {
+ Some(
+ attachment_refs
+ .iter()
+ .map(|(_colors, _depth_stencil, _inputs, _preserves, _resolves, view_mask)| {
+ *view_mask
+ })
+ .collect::<Vec<u32>>()
+ )
+ } else {
+ None
+ };
 
- let info = vk::RenderPassCreateInfo {
- s_type: vk::StructureType::RENDER_PASS_CREATE_INFO,
- p_next: ptr::null(),
- flags: vk::RenderPassCreateFlags::empty(),
- attachment_count: attachments.len() as u32,
- p_attachments: attachments.as_ptr(),
- subpass_count: subpasses.len() as u32,
- p_subpasses: subpasses.as_ptr(),
- dependency_count: dependencies.len() as u32,
- p_dependencies: dependencies.as_ptr(),
+ let view_offsets = if multiview_enabled {
+ Some(
+ dependencies
+ .iter()
+ .map(|dependency| dependency.borrow().view_offset)
+ .collect::<Vec<i32>>(),
+ )
+ } else {
+ None
  };
 
- self.shared.raw.create_render_pass(&info, None)
+ let result = inplace_it::inplace_or_alloc_array(vk_dependencies.len(), |uninit_guard| {
+ let vk_dependencies = uninit_guard.init_with_iter(vk_dependencies);
+
+ let mut info_builder = vk::RenderPassCreateInfo::builder()
+ .flags(vk::RenderPassCreateFlags::empty())
+ .attachments(&attachments)
+ .subpasses(&subpasses)
+ .dependencies(&vk_dependencies);
+ let mut multiview;
+
+ if multiview_enabled {
+ multiview = vk::RenderPassMultiviewCreateInfo::builder()
+ .view_masks(&view_masks.unwrap())
+ .view_offsets(&view_offsets.unwrap())
+ .correlation_masks(correlation_masks.unwrap())
+ .build();
+
+ info_builder = info_builder.push_next(&mut multiview);
+ }
+
+ self.shared.raw.create_render_pass(&info_builder.build(), None)
+ });
+
+ (clear_attachments_mask, result)
  });
 
  (clear_attachments_mask, result)