started implementing openxr stuff

src/graphics/mod.rs

@@ -0,0 +1 @@
+mod vulkan;

src/graphics/vulkan.rs

@@ -0,0 +1,13 @@
+use bevy::render::renderer::{RenderAdapter, RenderAdapterInfo, RenderQueue, RenderDevice};
+use bevy::render::settings::WgpuSettings;
+use openxr::Entry;
+use wgpu::Instance;
+
+/// Initializes the renderer by retrieving and preparing the GPU instance, device and queue
+/// for the specified backend.
+pub fn initialize_renderer(
+    options: &WgpuSettings,
+    entry: &Entry,
+) -> (RenderDevice, RenderQueue, RenderAdapterInfo, RenderAdapter, Instance) {
+    todo!()
+}

src/lib.rs

@@ -0,0 +1,54 @@
+use std::sync::{Arc, Mutex};
+
+use bevy::ecs::system::SystemState;
+use bevy::prelude::*;
+use bevy::render::settings::WgpuSettings;
+use bevy::render::FutureRendererResources;
+use bevy::window::{PrimaryWindow, RawHandleWrapper};
+use state::XrState;
+
+mod graphics;
+mod state;
+mod swapchain;
+
+pub struct OpenXrPlugin {
+    pub wgpu_settings: WgpuSettings,
+}
+
+#[derive(Resource)]
+struct FutureXrResources (
+    Arc<
+        Mutex<
+            Option<
+                XrState
+            >
+        >
+    >
+);
+
+impl Plugin for OpenXrPlugin {
+    fn build(&self, app: &mut App) {
+        if let Some(backends) = self.wgpu_settings.backends {
+            let future_renderer_resources_wrapper = Arc::new(Mutex::new(None));
+            let future_xr_resources_wrapper = Arc::new(Mutex::new(None));
+            app.insert_resource(FutureRendererResources(
+                future_renderer_resources_wrapper.clone(),
+            ));
+
+            app.insert_resource(FutureXrResources(
+                future_xr_resources_wrapper.clone(),
+            ));
+
+            let mut system_state: SystemState<Query<&RawHandleWrapper, With<PrimaryWindow>>> =
+                SystemState::new(&mut app.world);
+            let primary_window = system_state.get(&app.world).get_single().ok().cloned();
+
+            let settings = self.wgpu_settings.clone();
+            bevy::tasks::IoTaskPool::get()
+                .spawn_local(async move {
+                    
+                })
+                .detach();
+        }
+    }
+}

src/state.rs

@@ -0,0 +1,67 @@
+use std::sync::atomic::AtomicBool;
+use std::sync::Mutex;
+
+use bevy::prelude::*;
+use openxr as xr;
+use xr::Result as XrResult;
+
+#[derive(Resource)]
+pub struct XrState {
+    instance: xr::Instance,
+    session: xr::Session<xr::AnyGraphics>,
+    session_running: AtomicBool,
+    event_buffer: xr::EventDataBuffer,
+    views: Vec<xr::ViewConfigurationView>,
+    graphics: XrGraphics,
+}
+
+enum XrGraphics {
+    Vulkan(Mutex<XrGraphicsInner<xr::Vulkan>>)
+}
+
+impl XrGraphics {
+    fn begin(&self) -> XrResult<xr::FrameState> {
+        match self {
+            XrGraphics::Vulkan(inner) => inner.lock().unwrap().begin(),
+        }
+    }
+}
+
+struct XrGraphicsInner<G: xr::Graphics> {
+    wait: xr::FrameWaiter,
+    stream: xr::FrameStream<G>,
+    swapchain: xr::Swapchain<G>,
+    blend_mode: xr::EnvironmentBlendMode,
+    resolution: Extent2D,
+    buffers: Vec<wgpu::Texture>,
+}
+
+impl<G: xr::Graphics> XrGraphicsInner<G> {
+    fn begin(&mut self) -> XrResult<xr::FrameState> {
+        let frame_state = self.wait.wait()?;
+        self.stream.begin()?;
+        Ok(frame_state)
+    }
+
+    fn get_render_view(&mut self, layer: u32) -> wgpu::TextureView {
+        let image_index = self.swapchain.acquire_image().unwrap();
+        self.swapchain.wait_image(xr::Duration::INFINITE).unwrap();
+
+        let texture = &self.buffers[image_index as usize];
+
+        texture.create_view(&wgpu::TextureViewDescriptor {
+            dimension: Some(wgpu::TextureViewDimension::D2),
+            array_layer_count: Some(1),
+            base_array_layer: layer,
+            ..Default::default()
+        })
+    }
+}
+
+struct Extent2D {
+    width: u32,
+    height: u32,
+}
+
+unsafe impl Sync for XrState {}
+unsafe impl Send for XrState {}

src/swapchain.rs

@@ -0,0 +1,11 @@
+use std::sync::Mutex;
+
+use bevy::prelude::*;
+use openxr as xr;
+
+
+
+struct Extent2D {
+    width: u32,
+    height: u32,
+}