Check validity of builder structs

openxr/examples/vulkan.rs

@@ -710,28 +710,30 @@ pub fn main() {
  .end(
  xr_frame_state.predicted_display_time,
  environment_blend_mode,
- &[
- &xr::CompositionLayerProjection::new().space(&stage).views(&[
- xr::CompositionLayerProjectionView::new()
- .pose(views[0].pose)
- .fov(views[0].fov)
- .sub_image(
- xr::SwapchainSubImage::new()
- .swapchain(&swapchain.handle)
- .image_array_index(0)
- .image_rect(rect),
- ),
- xr::CompositionLayerProjectionView::new()
- .pose(views[1].pose)
- .fov(views[1].fov)
- .sub_image(
- xr::SwapchainSubImage::new()
- .swapchain(&swapchain.handle)
- .image_array_index(1)
- .image_rect(rect),
- ),
- ]),
- ],
+ &[&xr::CompositionLayer::Projection {
+ layer_flags: Default::default(),
+ space: &stage,
+ views: &[
+ xr::CompositionLayerProjectionView {
+ pose: views[0].pose,
+ fov: views[0].fov,
+ sub_image: xr::SwapchainSubImage {
+ swapchain: &swapchain.handle,
+ image_array_index: 0,
+ image_rect: rect,
+ },
+ },
+ xr::CompositionLayerProjectionView {
+ pose: views[1].pose,
+ fov: views[1].fov,
+ sub_image: xr::SwapchainSubImage {
+ swapchain: &swapchain.handle,
+ image_array_index: 1,
+ image_rect: rect,
+ },
+ },
+ ],
+ }],
  )
  .unwrap();
  frame = (frame + 1) % PIPELINE_DEPTH as usize;

openxr/src/action.rs

@@ -126,8 +126,44 @@ impl Action<Haptic> {
  &self,
  session: &Session<G>,
  subaction_path: Path,
- event: &HapticBase,
+ data: HapticData,
  ) -> Result<()> {
+ self.assert_event_validity(&data);
+
+ // There is no generated `as_raw` function because `samples_consumed` is a mut reference,
+ // which can't be safely converted to `*mut u32` though a `&HapticData`.
+ let data = match data {
+ HapticData::Vibration {
+ duration,
+ frequency,
+ amplitude,
+ } => builder::HapticDataRaw {
+ vibration: sys::HapticVibration {
+ ty: sys::HapticVibration::TYPE,
+ next: ptr::null_mut(),
+ duration,
+ frequency,
+ amplitude,
+ },
+ },
+ HapticData::PcmVibrationFB {
+ buffer,
+ sample_rate,
+ append,
+ samples_consumed,
+ } => builder::HapticDataRaw {
+ pcm_vibration_fb: sys::HapticPcmVibrationFB {
+ ty: sys::HapticPcmVibrationFB::TYPE,
+ next: ptr::null_mut(),
+ buffer_size: buffer.len() as _,
+ buffer: buffer.as_ptr(),
+ sample_rate,
+ append: append.into(),
+ samples_consumed,
+ },
+ },
+ };
+
  let info = sys::HapticActionInfo {
  ty: sys::HapticActionInfo::TYPE,
  next: ptr::null(),
@@ -138,12 +174,29 @@ impl Action<Haptic> {
  cvt((self.fp().apply_haptic_feedback)(
  session.as_raw(),
  &info,
- event as *const _ as _,
+ data.as_base(),
  ))?;
  }
  Ok(())
  }
 
+ /// Check the invariants of the passed haptic `event`.
+ /// The lifetime guarantees the validity of the non-null pointers.
+ fn assert_event_validity(&self, data: &HapticData) {
+ match data {
+ HapticData::Vibration { .. } => {
+ // nothing to check
+ }
+ HapticData::PcmVibrationFB { buffer, .. } => {
+ assert!(
+ self.instance().exts().fb_haptic_pcm.is_some(),
+ "XR_FB_haptic_pcm not loaded"
+ );
+ assert!(!buffer.is_empty(), "PCM Vibration buffer can't be empty");
+ }
+ }
+ }
+
  pub fn stop_feedback<G>(&self, session: &Session<G>, subaction_path: Path) -> Result<()> {
  let info = sys::HapticActionInfo {
  ty: sys::HapticActionInfo::TYPE,

openxr/src/action_set.rs

@@ -46,16 +46,17 @@ impl ActionSet {
  localized_name: &str,
  subaction_paths: &[Path],
  ) -> Result<Action<T>> {
- let info = builder::ActionCreateInfo::new()
- .action_name(name)
- .localized_action_name(localized_name)
- .subaction_paths(subaction_paths)
- .action_type(T::TYPE);
+ let info = builder::ActionCreateInfo {
+ action_name: name,
+ localized_action_name: localized_name,
+ subaction_paths,
+ action_type: T::TYPE,
+ };
  unsafe {
  let mut out = sys::Action::NULL;
  cvt((self.fp().create_action)(
  self.as_raw(),
- info.as_raw(),
+ &info.as_raw(),
  &mut out,
  ))?;
  Ok(Action::from_raw(self.clone(), out))

openxr/src/frame_stream.rs

@@ -46,34 +46,36 @@ use crate::*;
 /// .end(
 /// state.predicted_display_time,
 /// openxr::EnvironmentBlendMode::OPAQUE,
-/// &[&openxr::CompositionLayerProjection::new()
-/// .space(world_space)
-/// .views(&[
-/// openxr::CompositionLayerProjectionView::new()
-/// .pose(views[0].pose)
-/// .fov(views[0].fov)
-/// .sub_image(
-/// openxr::SwapchainSubImage::new()
-/// .swapchain(swapchain)
-/// .image_array_index(0)
-/// .image_rect(openxr::Rect2Di {
-/// offset: openxr::Offset2Di { x: 0, y: 0 },
-/// extent: view_resolution[0],
-/// }),
-/// ),
-/// openxr::CompositionLayerProjectionView::new()
-/// .pose(views[1].pose)
-/// .fov(views[1].fov)
-/// .sub_image(
-/// openxr::SwapchainSubImage::new()
-/// .swapchain(swapchain)
-/// .image_array_index(1)
-/// .image_rect(openxr::Rect2Di {
-/// offset: openxr::Offset2Di { x: 0, y: 0 },
-/// extent: view_resolution[1],
-/// }),
-/// ),
-/// ])],
+/// &[&openxr::CompositionLayer::Projection {
+/// layer_flags: Default::default(),
+/// space: world_space,
+/// views: &[
+/// openxr::CompositionLayerProjectionView {
+/// pose: views[0].pose,
+/// fov: views[0].fov,
+/// sub_image: openxr::SwapchainSubImage {
+/// swapchain,
+/// image_array_index: 0,
+/// image_rect: openxr::Rect2Di {
+/// offset: openxr::Offset2Di { x: 0, y: 0 },
+/// extent: view_resolution[0],
+/// },
+/// },
+/// },
+/// openxr::CompositionLayerProjectionView {
+/// pose: views[1].pose,
+/// fov: views[1].fov,
+/// sub_image: openxr::SwapchainSubImage {
+/// swapchain,
+/// image_array_index: 1,
+/// image_rect: openxr::Rect2Di {
+/// offset: openxr::Offset2Di { x: 0, y: 0 },
+/// extent: view_resolution[1],
+/// },
+/// },
+/// },
+/// ],
+/// }],
 /// )
 /// .unwrap();
 /// # }
@@ -105,8 +107,13 @@ impl<G: Graphics> FrameStream<G> {
  &mut self,
  display_time: Time,
  environment_blend_mode: EnvironmentBlendMode,
- layers: &[&CompositionLayerBase<'_, G>],
+ layers: &[&CompositionLayer<'_, G>],
  ) -> Result<()> {
+ let layers = layers
+ .iter()
+ .inspect(|layer| self.assert_layer_validity(layer))
+ .map(|layer| layer.as_raw())
+ .collect::<Vec<_>>();
  assert!(layers.len() <= u32::MAX as usize);
  let info = sys::FrameEndInfo {
  ty: sys::FrameEndInfo::TYPE,
@@ -136,18 +143,29 @@ impl<G: Graphics> FrameStream<G> {
  &mut self,
  display_time: Time,
  environment_blend_mode: EnvironmentBlendMode,
- layers: &[&CompositionLayerBase<'_, G>],
+ layers: &[&CompositionLayer<'_, G>],
  secondary_info: SecondaryEndInfo<'_, '_, '_, G>,
  ) -> Result<()> {
+ let layers = layers
+ .iter()
+ .inspect(|layer| self.assert_layer_validity(layer))
+ .map(|layer| layer.as_raw())
+ .collect::<Vec<_>>();
  assert!(layers.len() <= u32::MAX as usize);
- assert!(secondary_info.layers.len() <= u32::MAX as usize);
+ let secondary_layers = secondary_info
+ .layers
+ .iter()
+ .inspect(|layer| self.assert_layer_validity(layer))
+ .map(|layer| layer.as_raw())
+ .collect::<Vec<_>>();
+ assert!(secondary_layers.len() <= u32::MAX as usize);
  let single_secondary_info = [sys::SecondaryViewConfigurationLayerInfoMSFT {
  ty: sys::SecondaryViewConfigurationLayerInfoMSFT::TYPE,
  next: ptr::null(),
  view_configuration_type: secondary_info.ty,
  environment_blend_mode: secondary_info.environment_blend_mode,
- layer_count: secondary_info.layers.len() as u32,
- layers: secondary_info.layers.as_ptr() as *const _,
+ layer_count: secondary_layers.len() as u32,
+ layers: secondary_layers.as_ptr() as *const _,
  }];
  let secondary_info = sys::SecondaryViewConfigurationFrameEndInfoMSFT {
  ty: sys::SecondaryViewConfigurationFrameEndInfoMSFT::TYPE,
@@ -174,4 +192,77 @@ impl<G: Graphics> FrameStream<G> {
  fn fp(&self) -> &raw::Instance {
  self.session.instance().fp()
  }
+
+ /// Check the invariants of the passed `layer`.
+ /// The lifetimes guarantee the validity of non-null handles.
+ fn assert_layer_validity(&self, layer: &CompositionLayer<'_, G>) {
+ match layer {
+ CompositionLayer::Projection { space, views, .. } => {
+ assert!(!views.is_empty());
+ assert_eq!(self.session.as_raw(), space.session_handle());
+ for CompositionLayerProjectionView { sub_image, .. } in *views {
+ assert_eq!(self.session.as_raw(), sub_image.swapchain.session_handle());
+ }
+ }
+ CompositionLayer::Quad {
+ space, sub_image, ..
+ } => {
+ assert_eq!(space.session_handle(), self.session.as_raw());
+ assert_eq!(sub_image.swapchain.session_handle(), self.session.as_raw());
+ assert_eq!(sub_image.swapchain.face_count(), 1);
+ }
+ CompositionLayer::CylinderKHR {
+ space, sub_image, ..
+ } => {
+ assert!(self
+ .session
+ .instance()
+ .exts()
+ .khr_composition_layer_cylinder
+ .is_some());
+ assert_eq!(space.session_handle(), self.session.as_raw());
+ assert_eq!(sub_image.swapchain.session_handle(), self.session.as_raw());
+ assert_eq!(sub_image.swapchain.face_count(), 1);
+ }
+ CompositionLayer::CubeKHR {
+ space, swapchain, ..
+ } => {
+ assert!(self
+ .session
+ .instance()
+ .exts()
+ .khr_composition_layer_cube
+ .is_some());
+ assert_eq!(space.session_handle(), self.session.as_raw());
+ assert_eq!(swapchain.session_handle(), self.session.as_raw());
+ assert_eq!(swapchain.face_count(), 6);
+ }
+ CompositionLayer::EquirectKHR {
+ space, sub_image, ..
+ } => {
+ assert!(self
+ .session
+ .instance()
+ .exts()
+ .khr_composition_layer_equirect
+ .is_some());
+ assert_eq!(space.session_handle(), self.session.as_raw());
+ assert_eq!(sub_image.swapchain.session_handle(), self.session.as_raw());
+ assert_eq!(sub_image.swapchain.face_count(), 1);
+ }
+ CompositionLayer::Equirect2KHR {
+ space, sub_image, ..
+ } => {
+ assert!(self
+ .session
+ .instance()
+ .exts()
+ .khr_composition_layer_equirect2
+ .is_some());
+ assert_eq!(space.session_handle(), self.session.as_raw());
+ assert_eq!(sub_image.swapchain.session_handle(), self.session.as_raw());
+ assert_eq!(sub_image.swapchain.face_count(), 1);
+ }
+ }
+ }
 }