rendering code and api crate

crates/bevy_openxr/src/layer_builder.rs

@@ -0,0 +1,169 @@
+use std::mem;
+
+use openxr::{sys, CompositionLayerFlags, Fovf, Posef, Rect2Di, Space};
+
+use crate::graphics::graphics_match;
+use crate::resources::XrSwapchain;
+
+#[derive(Copy, Clone)]
+pub struct SwapchainSubImage<'a> {
+    inner: sys::SwapchainSubImage,
+    swapchain: Option<&'a XrSwapchain>,
+}
+
+impl<'a> SwapchainSubImage<'a> {
+    #[inline]
+    pub fn new() -> Self {
+        Self {
+            inner: sys::SwapchainSubImage {
+                ..unsafe { mem::zeroed() }
+            },
+            swapchain: None,
+        }
+    }
+    #[inline]
+    pub fn into_raw(self) -> sys::SwapchainSubImage {
+        self.inner
+    }
+    #[inline]
+    pub fn as_raw(&self) -> &sys::SwapchainSubImage {
+        &self.inner
+    }
+    #[inline]
+    pub fn swapchain(mut self, value: &'a XrSwapchain) -> Self {
+        graphics_match!(
+            &value.0;
+            swap => self.inner.swapchain = swap.as_raw()
+        );
+        self.swapchain = Some(value);
+        self
+    }
+    #[inline]
+    pub fn image_rect(mut self, value: Rect2Di) -> Self {
+        self.inner.image_rect = value;
+        self
+    }
+    #[inline]
+    pub fn image_array_index(mut self, value: u32) -> Self {
+        self.inner.image_array_index = value;
+        self
+    }
+}
+
+impl<'a> Default for SwapchainSubImage<'a> {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+#[derive(Copy, Clone)]
+pub struct CompositionLayerProjectionView<'a> {
+    inner: sys::CompositionLayerProjectionView,
+    swapchain: Option<&'a XrSwapchain>,
+}
+
+impl<'a> CompositionLayerProjectionView<'a> {
+    #[inline]
+    pub fn new() -> Self {
+        Self {
+            inner: sys::CompositionLayerProjectionView {
+                ty: sys::StructureType::COMPOSITION_LAYER_PROJECTION_VIEW,
+                ..unsafe { mem::zeroed() }
+            },
+            swapchain: None,
+        }
+    }
+    #[inline]
+    pub fn into_raw(self) -> sys::CompositionLayerProjectionView {
+        self.inner
+    }
+    #[inline]
+    pub fn as_raw(&self) -> &sys::CompositionLayerProjectionView {
+        &self.inner
+    }
+    #[inline]
+    pub fn pose(mut self, value: Posef) -> Self {
+        self.inner.pose = value;
+        self
+    }
+    #[inline]
+    pub fn fov(mut self, value: Fovf) -> Self {
+        self.inner.fov = value;
+        self
+    }
+    #[inline]
+    pub fn sub_image(mut self, value: SwapchainSubImage<'a>) -> Self {
+        self.inner.sub_image = value.inner;
+        self.swapchain = value.swapchain;
+        self
+    }
+}
+impl<'a> Default for CompositionLayerProjectionView<'a> {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+pub unsafe trait CompositionLayer<'a> {
+    fn swapchain(&self) -> Option<&'a XrSwapchain>;
+    fn header(&self) -> &'a sys::CompositionLayerBaseHeader;
+}
+#[derive(Clone)]
+pub struct CompositionLayerProjection<'a> {
+    inner: sys::CompositionLayerProjection,
+    swapchain: Option<&'a XrSwapchain>,
+    views: Vec<sys::CompositionLayerProjectionView>,
+}
+impl<'a> CompositionLayerProjection<'a> {
+    #[inline]
+    pub fn new() -> Self {
+        Self {
+            inner: sys::CompositionLayerProjection {
+                ty: sys::StructureType::COMPOSITION_LAYER_PROJECTION,
+                ..unsafe { mem::zeroed() }
+            },
+            swapchain: None,
+            views: Vec::new(),
+        }
+    }
+    #[inline]
+    pub fn into_raw(self) -> sys::CompositionLayerProjection {
+        self.inner
+    }
+    #[inline]
+    pub fn as_raw(&self) -> &sys::CompositionLayerProjection {
+        &self.inner
+    }
+    #[inline]
+    pub fn layer_flags(mut self, value: CompositionLayerFlags) -> Self {
+        self.inner.layer_flags = value;
+        self
+    }
+    #[inline]
+    pub fn space(mut self, value: &'a Space) -> Self {
+        self.inner.space = value.as_raw();
+        self
+    }
+    #[inline]
+    pub fn views(mut self, value: &'a [CompositionLayerProjectionView<'a>]) -> Self {
+        for view in value {
+            self.views.push(view.inner.clone());
+        }
+        self.inner.views = self.views.as_slice().as_ptr() as *const _ as _;
+        self.inner.view_count = value.len() as u32;
+        self
+    }
+}
+unsafe impl<'a> CompositionLayer<'a> for CompositionLayerProjection<'a> {
+    fn swapchain(&self) -> Option<&'a XrSwapchain> {
+        self.swapchain
+    }
+
+    fn header(&self) -> &'a sys::CompositionLayerBaseHeader {
+        unsafe { std::mem::transmute(&self.inner) }
+    }
+}
+impl<'a> Default for CompositionLayerProjection<'a> {
+    fn default() -> Self {
+        Self::new()
+    }
+}