Update Renderer to use new render_features code.

- The `RenderFeaturePlugin` has been expanded with additional functions for calculating and allocating frame or submit packets, creating each job type, and determining if a given `RenderView` and `RenderViewVisibilityQuery` is relevant to that feature.
- Added `RendererThreadPool` to allow the application to control the parallelization of different stages of the renderer pipeline. `RendererThreadPoolNone` is provided as a single-threaded default if the application does not provide their own implementation.
- Seperated `RendererAssetPlugin` from what was previously just a `RendererPlugin` containing both feature code (now moved to `RenderFeaturePlugin`) and asset code.
- Added many helper functions to `Renderer` and `RenderFrameJob` to make the implementation of the `RendererThreadPool` easier.

The `extract` stage can be seen in `Renderer::try_create_render_job` and the `prepare` or `write` stages are in `RenderFrameJob::do_render_async`.

rafx-renderer/Cargo.toml

@@ -22,6 +22,7 @@ glam = { version = "0.13.1", features = [ "serde" ] }
 crossbeam-channel = "0.5"
 log = "0.4"
 profiling = "1.0.1"
+fnv = "1.0"
 
 [features]
 no-render-thread = []

rafx-renderer/src/lib.rs

@@ -1,5 +1,8 @@
-mod renderer_plugin;
-pub use renderer_plugin::RendererPlugin;
+mod render_feature_plugin;
+pub use render_feature_plugin::RenderFeaturePlugin;
+
+mod renderer_asset_plugin;
+pub use renderer_asset_plugin::RendererAssetPlugin;
 
 mod render_graph_generator;
 pub use render_graph_generator::RenderGraphGenerator;
@@ -15,18 +18,23 @@ mod swapchain_resources;
 pub use swapchain_resources::SwapchainResources;
 
 mod render_frame_job;
-use render_frame_job::RenderFrameJob;
+pub use render_frame_job::RenderFrameJob;
 
 mod renderer_builder;
 pub use renderer_builder::AssetSource;
 pub use renderer_builder::RendererBuilder;
 pub use renderer_builder::RendererBuilderResult;
 
+mod renderer_thread_pool_none;
+
 //TODO: Find a way to not expose this
 mod swapchain_handling;
 pub use swapchain_handling::SwapchainHandler;
 
 mod renderer;
 pub use renderer::*;
 
+mod renderer_thread_pool;
+pub use renderer_thread_pool::*;
+
 pub mod daemon;

rafx-renderer/src/render_feature_plugin.rs

@@ -0,0 +1,130 @@
+use crate::Renderer;
+use rafx_api::extra::upload::RafxTransferUpload;
+use rafx_api::RafxResult;
+use rafx_assets::distill_impl::AssetResource;
+use rafx_assets::AssetManager;
+use rafx_base::resource_map::ResourceMap;
+use rafx_framework::render_features::render_features_prelude::*;
+use rafx_framework::RenderResources;
+use std::sync::Arc;
+
+pub trait RenderFeaturePlugin: Send + Sync {
+    fn feature_debug_name(&self) -> &'static str;
+    fn feature_index(&self) -> RenderFeatureIndex;
+
+    fn is_relevant(
+        &self,
+        view_visibility: &RenderViewVisibilityQuery,
+    ) -> bool {
+        let is_view_relevant = self.is_view_relevant(&view_visibility.view);
+
+        if is_view_relevant {
+            return if self.requires_visible_render_objects() {
+                view_visibility
+                    .render_object_instances_per_view(self.feature_index())
+                    .is_some()
+            } else {
+                true
+            };
+        }
+
+        false
+    }
+
+    fn is_view_relevant(
+        &self,
+        view: &RenderView,
+    ) -> bool;
+
+    fn requires_visible_render_objects(&self) -> bool;
+
+    fn configure_render_registry(
+        &self,
+        render_registry: RenderRegistryBuilder,
+    ) -> RenderRegistryBuilder {
+        render_registry
+    }
+
+    fn initialize_static_resources(
+        &self,
+        _asset_manager: &mut AssetManager,
+        _asset_resource: &mut AssetResource,
+        _extract_resources: &ExtractResources,
+        _render_resources: &mut ResourceMap,
+        _upload: &mut RafxTransferUpload,
+    ) -> RafxResult<()> {
+        Ok(())
+    }
+
+    fn add_render_views(
+        &self,
+        _extract_resources: &ExtractResources,
+        _render_resources: &RenderResources,
+        _render_view_set: &RenderViewSet,
+        _render_views: &mut Vec<RenderView>,
+    ) {
+    }
+
+    fn calculate_frame_packet_size<'extract>(
+        &self,
+        _extract_context: &RenderJobExtractContext<'extract>,
+        visibility_results: &Vec<RenderViewVisibilityQuery>,
+        render_object_instance_entity_ids: &mut RenderObjectInstanceEntityIds,
+        frame_packet_size: &mut FramePacketSize,
+    ) {
+        Renderer::calculate_frame_packet_size(
+            self.feature_debug_name(),
+            self.feature_index(),
+            |view_visibility| self.is_relevant(view_visibility),
+            visibility_results,
+            render_object_instance_entity_ids,
+            frame_packet_size,
+        );
+    }
+
+    fn new_frame_packet(
+        &self,
+        frame_packet_size: &FramePacketSize,
+    ) -> Box<dyn RenderFeatureFramePacket>;
+
+    fn populate_frame_packet<'extract>(
+        &self,
+        _extract_context: &RenderJobExtractContext<'extract>,
+        visibility_results: &Vec<RenderViewVisibilityQuery>,
+        _frame_packet_size: &FramePacketSize,
+        frame_packet: &mut Box<dyn RenderFeatureFramePacket>,
+    ) {
+        Renderer::populate_frame_packet(
+            self.feature_debug_name(),
+            self.feature_index(),
+            |view_visibility| self.is_relevant(view_visibility),
+            visibility_results,
+            frame_packet,
+        );
+    }
+
+    fn new_extract_job<'extract>(
+        &self,
+        extract_context: &RenderJobExtractContext<'extract>,
+        frame_packet: Box<dyn RenderFeatureFramePacket>,
+    ) -> Arc<dyn RenderFeatureExtractJob<'extract> + 'extract>;
+
+    fn new_submit_packet(
+        &self,
+        frame_packet: &Box<dyn RenderFeatureFramePacket>,
+    ) -> Box<dyn RenderFeatureSubmitPacket>;
+
+    fn new_prepare_job<'prepare>(
+        &self,
+        prepare_context: &RenderJobPrepareContext<'prepare>,
+        frame_packet: Box<dyn RenderFeatureFramePacket>,
+        submit_packet: Box<dyn RenderFeatureSubmitPacket>,
+    ) -> Arc<dyn RenderFeaturePrepareJob<'prepare> + 'prepare>;
+
+    fn new_write_job<'write>(
+        &self,
+        write_context: &RenderJobWriteContext<'write>,
+        frame_packet: Box<dyn RenderFeatureFramePacket>,
+        submit_packet: Box<dyn RenderFeatureSubmitPacket>,
+    ) -> Arc<dyn RenderFeatureWriteJob<'write> + 'write>;
+}