add headless render resource context

crates/bevy_render/src/renderer/headless_render_resource_context.rs

@@ -0,0 +1,109 @@
+use super::RenderResourceContext;
+use crate::{
+    render_resource::{BufferInfo, RenderResource, ResourceInfo},
+    shader::Shader,
+    texture::{SamplerDescriptor, TextureDescriptor},
+};
+use bevy_asset::{AssetStorage, Handle, HandleUntyped};
+use bevy_window::{Window, WindowId};
+use std::{
+    collections::HashMap,
+    sync::{Arc, RwLock},
+};
+
+#[derive(Default)]
+pub struct HeadlessRenderResourceContext {
+    resource_info: Arc<RwLock<HashMap<RenderResource, ResourceInfo>>>,
+    pub asset_resources: Arc<RwLock<HashMap<(HandleUntyped, usize), RenderResource>>>,
+}
+
+impl HeadlessRenderResourceContext {
+    pub fn add_resource_info(&self, resource: RenderResource, resource_info: ResourceInfo) {
+        self.resource_info
+            .write()
+            .unwrap()
+            .insert(resource, resource_info);
+    }
+}
+
+impl RenderResourceContext for HeadlessRenderResourceContext {
+    fn create_swap_chain(&self, _window: &Window) {}
+    fn next_swap_chain_texture(&self, _window_id: WindowId) -> RenderResource {
+        RenderResource::new()
+    }
+    fn drop_swap_chain_texture(&self, _render_resource: RenderResource) {}
+    fn drop_all_swap_chain_textures(&self) {}
+    fn create_sampler(&self, _sampler_descriptor: &SamplerDescriptor) -> RenderResource {
+        let resource = RenderResource::new();
+        self.add_resource_info(resource, ResourceInfo::Sampler);
+        resource
+    }
+    fn create_texture(&self, _texture_descriptor: &TextureDescriptor) -> RenderResource {
+        let resource = RenderResource::new();
+        self.add_resource_info(resource, ResourceInfo::Texture);
+        resource
+    }
+    fn create_buffer(&self, buffer_info: BufferInfo) -> RenderResource {
+        let resource = RenderResource::new();
+        self.add_resource_info(resource, ResourceInfo::Buffer(buffer_info));
+        resource
+    }
+    fn create_buffer_mapped(
+        &self,
+        buffer_info: BufferInfo,
+        setup_data: &mut dyn FnMut(&mut [u8], &dyn RenderResourceContext),
+    ) -> RenderResource {
+        let mut buffer = vec![0; buffer_info.size];
+        setup_data(&mut buffer, self);
+        RenderResource::new()
+    }
+    fn create_buffer_with_data(&self, buffer_info: BufferInfo, _data: &[u8]) -> RenderResource {
+        let resource = RenderResource::new();
+        self.add_resource_info(resource, ResourceInfo::Buffer(buffer_info));
+        resource
+    }
+    fn create_shader_module(
+        &mut self,
+        _shader_handle: Handle<Shader>,
+        _shader_storage: &AssetStorage<Shader>,
+    ) {
+    }
+    fn remove_buffer(&self, resource: RenderResource) {
+        self.resource_info.write().unwrap().remove(&resource);
+    }
+    fn remove_texture(&self, resource: RenderResource) {
+        self.resource_info.write().unwrap().remove(&resource);
+    }
+    fn remove_sampler(&self, resource: RenderResource) {
+        self.resource_info.write().unwrap().remove(&resource);
+    }
+    fn get_resource_info(
+        &self,
+        resource: RenderResource,
+        handle_info: &mut dyn FnMut(Option<&ResourceInfo>),
+    ) {
+        handle_info(self.resource_info.read().unwrap().get(&resource));
+    }
+    fn set_asset_resource_untyped(
+        &self,
+        handle: HandleUntyped,
+        render_resource: RenderResource,
+        index: usize,
+    ) {
+        self.asset_resources
+            .write()
+            .unwrap()
+            .insert((handle, index), render_resource);
+    }
+    fn get_asset_resource_untyped(
+        &self,
+        handle: HandleUntyped,
+        index: usize,
+    ) -> Option<RenderResource> {
+        self.asset_resources
+            .write()
+            .unwrap()
+            .get(&(handle, index))
+            .cloned()
+    }
+}

crates/bevy_render/src/renderer/mod.rs

@@ -1,5 +1,7 @@
 mod render_context;
 mod render_resource_context;
+mod headless_render_resource_context;
 
 pub use render_context::*;
 pub use render_resource_context::*;
+pub use headless_render_resource_context::*;

crates/bevy_wgpu/src/wgpu_resources.rs

@@ -72,7 +72,7 @@ pub struct WgpuResourceRefs<'a> {
 
 #[derive(Default, Clone)]
 pub struct WgpuResources {
-    // TODO: remove this from WgpuResources. it doesn't need to be here
+    pub resource_info: Arc<RwLock<HashMap<RenderResource, ResourceInfo>>>,
     pub window_surfaces: Arc<RwLock<HashMap<WindowId, wgpu::Surface>>>,
     pub window_swap_chains: Arc<RwLock<HashMap<WindowId, wgpu::SwapChain>>>,
     pub swap_chain_outputs: Arc<RwLock<HashMap<RenderResource, wgpu::SwapChainOutput>>>,
@@ -80,7 +80,6 @@ pub struct WgpuResources {
     pub texture_views: Arc<RwLock<HashMap<RenderResource, wgpu::TextureView>>>,
     pub textures: Arc<RwLock<HashMap<RenderResource, wgpu::Texture>>>,
     pub samplers: Arc<RwLock<HashMap<RenderResource, wgpu::Sampler>>>,
-    pub resource_info: Arc<RwLock<HashMap<RenderResource, ResourceInfo>>>,
     pub shader_modules: Arc<RwLock<HashMap<Handle<Shader>, wgpu::ShaderModule>>>,
     pub render_pipelines: Arc<RwLock<HashMap<Handle<PipelineDescriptor>, wgpu::RenderPipeline>>>,
     pub bind_groups: Arc<RwLock<HashMap<BindGroupDescriptorId, WgpuBindGroupInfo>>>,