Initial DLSS implementation

Cargo.toml

@@ -327,6 +327,9 @@ spirv_shader_passthrough = ["bevy_internal/spirv_shader_passthrough"]
 # Statically linked DXC shader compiler for DirectX 12
 statically-linked-dxc = ["bevy_internal/statically-linked-dxc"]
 
+# Forces the wgpu instance to be initialized using the raw Vulkan HAL, enabling additional configuration
+raw_vulkan_init = ["bevy_internal/raw_vulkan_init"]
+
 # Tracing support, saving a file in Chrome Tracing format
 trace_chrome = ["trace", "bevy_internal/trace_chrome"]
 

crates/bevy_anti_aliasing/Cargo.toml

@@ -13,7 +13,7 @@ trace = []
 webgl = []
 webgpu = []
 smaa_luts = ["bevy_image/ktx2", "bevy_image/zstd"]
-dlss = ["dep:dlss_wgpu", "bevy_render/dlss"]
+dlss = ["dep:dlss_wgpu", "dep:uuid", "bevy_render/raw_vulkan_init"]
 force_disable_dlss = ["dlss_wgpu?/mock"]
 
 [dependencies]
@@ -35,6 +35,7 @@ bevy_diagnostic = { path = "../bevy_diagnostic", version = "0.17.0-dev" }
 # other
 tracing = { version = "0.1", default-features = false, features = ["std"] }
 dlss_wgpu = { git = "https://github.com/bevyengine/dlss_wgpu", optional = true }
+uuid = { version = "1", optional = true }
 
 [lints]
 workspace = true

crates/bevy_anti_aliasing/src/dlss/mod.rs

@@ -18,21 +18,23 @@ mod extract;
 mod node;
 mod prepare;
 
+pub use dlss_wgpu::DlssPerfQualityMode;
+
 use bevy_app::{App, Plugin};
 use bevy_core_pipeline::{
     core_3d::graph::{Core3d, Node3d},
     prepass::{DepthPrepass, MotionVectorPrepass},
 };
-use bevy_ecs::{
-    component::Component, prelude::ReflectComponent, resource::Resource,
-    schedule::IntoScheduleConfigs,
-};
+use bevy_ecs::prelude::*;
 use bevy_math::{UVec2, Vec2};
 use bevy_reflect::{reflect_remote, Reflect};
 use bevy_render::{
     camera::{MipBias, TemporalJitter},
     render_graph::{RenderGraphExt, ViewNodeRunner},
-    renderer::{RenderDevice, RenderQueue},
+    renderer::{
+        raw_vulkan_init::{AdditionalVulkanFeatures, RawVulkanInitSettings},
+        RenderDevice, RenderQueue,
+    },
     texture::CachedTexture,
     view::{prepare_view_targets, Hdr},
     ExtractSchedule, Render, RenderApp, RenderSystems,
@@ -42,52 +44,118 @@ use dlss_wgpu::{
         DlssRayReconstruction, DlssRayReconstructionDepthMode, DlssRayReconstructionRoughnessMode,
     },
     super_resolution::DlssSuperResolution,
+    FeatureSupport,
 };
 use std::{
     marker::PhantomData,
     ops::Deref,
     sync::{Arc, Mutex},
 };
 use tracing::info;
+use uuid::Uuid;
 
-pub use bevy_render::{
-    DlssProjectId, DlssRayReconstructionSupported, DlssSuperResolutionSupported,
-};
-pub use dlss_wgpu::DlssPerfQualityMode;
+/// Initializes DLSS support in the renderer. This must be registered before [`RenderPlugin`](bevy_render::RenderPlugin) because
+/// it configures render init code.
+#[derive(Default)]
+pub struct DlssInitPlugin;
+
+impl Plugin for DlssInitPlugin {
+    fn build(&self, app: &mut App) {
+        let dlss_project_id = app.world().get_resource::<DlssProjectId>()
+                        .expect("The `dlss` feature is enabled, but DlssProjectId was not added to the App before DlssPlugin.").0;
+        let mut raw_vulkan_settings = app
+            .world_mut()
+            .get_resource_or_init::<RawVulkanInitSettings>();
+
+        raw_vulkan_settings.create_instance_callbacks.push(Arc::new(
+            move |mut args, additional_vulkan_features| {
+                let mut feature_support = FeatureSupport::default();
+                match dlss_wgpu::register_instance_extensions(
+                    dlss_project_id,
+                    &mut args,
+                    &mut feature_support,
+                ) {
+                    Ok(_) => {
+                        if feature_support.ray_reconstruction_supported {
+                            additional_vulkan_features.register::<DlssRayReconstructionSupported>();
+                        }
+                        if feature_support.super_resolution_supported {
+                            additional_vulkan_features.register::<DlssSuperResolutionSupported>();
+                        }
+                    }
+                    Err(_) => todo!(),
+                }
+            },
+        ));
+
+        raw_vulkan_settings.create_device_callbacks.push(Arc::new(
+            move |mut args, adapter, additional_vulkan_features| {
+                let mut feature_support = FeatureSupport::default();
+                match dlss_wgpu::register_device_extensions(
+                    dlss_project_id,
+                    &mut args,
+                    adapter,
+                    &mut feature_support,
+                ) {
+                    Ok(_) => {
+                        if feature_support.ray_reconstruction_supported {
+                            additional_vulkan_features.register::<DlssRayReconstructionSupported>();
+                        }
+                        if feature_support.super_resolution_supported {
+                            additional_vulkan_features.register::<DlssSuperResolutionSupported>();
+                        }
+                    }
+                    Err(_) => todo!(),
+                }
+            },
+        ));
+    }
+}
 
+/// Enables DLSS support. This requires [`DlssInitPlugin`] to function, which must be manually registered in the correct order
+/// prior to registering this plugin.
+#[derive(Default)]
 pub struct DlssPlugin;
 
 impl Plugin for DlssPlugin {
     fn build(&self, app: &mut App) {
         app.register_type::<Dlss<DlssSuperResolutionFeature>>()
             .register_type::<Dlss<DlssRayReconstructionFeature>>();
     }
-
     fn finish(&self, app: &mut App) {
-        if app
-            .world()
-            .get_resource::<DlssSuperResolutionSupported>()
-            .is_none()
-        {
-            info!("DLSS is not supported on this system");
+        let (super_resolution_supported, ray_reconstruction_supported) = {
+            let features = app
+                .sub_app_mut(RenderApp)
+                .world()
+                .resource::<AdditionalVulkanFeatures>();
+            (
+                features.has::<DlssSuperResolutionSupported>(),
+                features.has::<DlssRayReconstructionSupported>(),
+            )
+        };
+        if !super_resolution_supported {
             return;
         }
 
-        let dlss_project_id = app.world().resource::<DlssProjectId>().0;
-
-        let render_app = app.get_sub_app_mut(RenderApp).unwrap();
-        let render_device = render_app.world().resource::<RenderDevice>().clone();
-
-        let dlss_sdk =
-            dlss_wgpu::DlssSdk::new(dlss_project_id, render_device.wgpu_device().clone());
+        let wgpu_device = {
+            let render_world = app.sub_app(RenderApp).world();
+            let render_device = render_world.resource::<RenderDevice>().wgpu_device();
+            render_device.clone()
+        };
+        let project_id = app.world().get_resource::<DlssProjectId>()
+            .expect("The `dlss` feature is enabled, but DlssProjectId was not added to the App before DlssPlugin.");
+        let dlss_sdk = dlss_wgpu::DlssSdk::new(project_id.0, wgpu_device);
         if dlss_sdk.is_err() {
-            app.world_mut()
-                .remove_resource::<DlssSuperResolutionSupported>();
             info!("DLSS is not supported on this system");
             return;
         }
 
-        render_app
+        app.insert_resource(DlssSuperResolutionSupported);
+        if ray_reconstruction_supported {
+            app.insert_resource(DlssRayReconstructionSupported);
+        }
+
+        app.sub_app_mut(RenderApp)
             .insert_resource(DlssSdk(dlss_sdk.unwrap()))
             .add_systems(
                 ExtractSchedule,
@@ -303,3 +371,19 @@ enum DlssPerfQualityModeRemoteReflect {
 
 #[derive(Resource)]
 struct DlssSdk(Arc<Mutex<dlss_wgpu::DlssSdk>>);
+
+/// Application-specific ID for DLSS.
+///
+/// See the DLSS programming guide for more info.
+#[derive(Resource, Clone)]
+pub struct DlssProjectId(pub Uuid);
+
+/// When DLSS Super Resolution is supported by the current system, this resource will exist in the main world.
+/// Otherwise this resource will be absent.
+#[derive(Resource, Clone, Copy)]
+pub struct DlssSuperResolutionSupported;
+
+/// When DLSS Ray Reconstruction is supported by the current system, this resource will exist in the main world.
+/// Otherwise this resource will be absent.
+#[derive(Resource, Clone, Copy)]
+pub struct DlssRayReconstructionSupported;

crates/bevy_internal/Cargo.toml

@@ -62,6 +62,9 @@ spirv_shader_passthrough = ["bevy_render/spirv_shader_passthrough"]
 # TODO: When wgpu switches to DirectX 12 instead of Vulkan by default on windows, make this a default feature
 statically-linked-dxc = ["bevy_render/statically-linked-dxc"]
 
+# Forces the wgpu instance to be initialized using the raw Vulkan HAL, enabling additional configuration
+raw_vulkan_init = ["bevy_render/raw_vulkan_init"]
+
 # Include tonemapping LUT KTX2 files.
 tonemapping_luts = ["bevy_core_pipeline/tonemapping_luts"]
 # Include Bluenoise texture for environment map generation.

crates/bevy_internal/src/default_plugins.rs

@@ -27,6 +27,8 @@ plugin_group! {
         bevy_scene:::ScenePlugin,
         #[cfg(feature = "bevy_winit")]
         bevy_winit:::WinitPlugin,
+        #[custom(cfg(all(feature = "dlss", not(feature = "force_disable_dlss"))))]
+        bevy_anti_aliasing::dlss:::DlssInitPlugin,
         #[cfg(feature = "bevy_render")]
         bevy_render:::RenderPlugin,
         // NOTE: Load this after renderer initialization so that it knows about the supported

crates/bevy_render/Cargo.toml

@@ -32,6 +32,9 @@ spirv_shader_passthrough = ["wgpu/spirv"]
 # TODO: When wgpu switches to DirectX 12 instead of Vulkan by default on windows, make this a default feature
 statically-linked-dxc = ["wgpu/static-dxc"]
 
+# Forces the wgpu instance to be initialized using the raw Vulkan HAL, enabling additional configuration
+raw_vulkan_init = ["wgpu/vulkan"]
+
 trace = ["profiling"]
 tracing-tracy = ["dep:tracy-client"]
 ci_limits = []
@@ -91,7 +94,6 @@ wgpu = { version = "26", default-features = false, features = [
   "fragile-send-sync-non-atomic-wasm",
 ] }
 naga = { version = "26", features = ["wgsl-in"] }
-dlss_wgpu = { git = "https://github.com/bevyengine/dlss_wgpu", optional = true }
 bytemuck = { version = "1.5", features = ["derive", "must_cast"] }
 downcast-rs = { version = "2", default-features = false, features = ["std"] }
 thiserror = { version = "2", default-features = false }

crates/bevy_render/src/lib.rs

@@ -332,20 +332,20 @@ impl Plugin for RenderPlugin {
 
                     let settings = render_creation.clone();
 
-                    #[cfg(all(feature = "dlss", not(feature = "force_disable_dlss")))]
-                    let dlss_project_id = app
-                        .world()
-                        .get_resource::<DlssProjectId>()
-                        .expect("The `dlss` feature is enabled, but DlssProjectId was not added to the App before DefaultPlugins.")
-                        .0;
+                    #[cfg(feature = "raw_vulkan_init")]
+                    let raw_vulkan_init_settings = app
+                        .world_mut()
+                        .get_resource::<renderer::raw_vulkan_init::RawVulkanInitSettings>()
+                        .cloned()
+                        .unwrap_or_default();
 
                     let async_renderer = async move {
                         let render_resources = renderer::initialize_renderer(
                             backends,
                             primary_window,
                             &settings,
-                            #[cfg(all(feature = "dlss", not(feature = "force_disable_dlss")))]
-                            dlss_project_id,
+                            #[cfg(feature = "raw_vulkan_init")]
+                            raw_vulkan_init_settings,
                         )
                         .await;
 
@@ -414,19 +414,9 @@ impl Plugin for RenderPlugin {
         if let Some(future_render_resources) =
             app.world_mut().remove_resource::<FutureRenderResources>()
         {
-            #[cfg(all(feature = "dlss", not(feature = "force_disable_dlss")))]
-            let RenderResources(
-                device,
-                queue,
-                adapter_info,
-                render_adapter,
-                instance,
-                dlss_super_resolution_supported,
-                dlss_ray_reconstruction_supported,
-            ) = future_render_resources.0.lock().unwrap().take().unwrap();
-            #[cfg(any(not(feature = "dlss"), feature = "force_disable_dlss"))]
-            let RenderResources(device, queue, adapter_info, render_adapter, instance) =
-                future_render_resources.0.lock().unwrap().take().unwrap();
+            let render_resources = future_render_resources.0.lock().unwrap().take().unwrap();
+            let RenderResources(device, queue, adapter_info, render_adapter, instance, ..) =
+                render_resources;
 
             let compressed_image_format_support = CompressedImageFormatSupport(
                 CompressedImageFormats::from_features(device.features()),
@@ -438,17 +428,15 @@ impl Plugin for RenderPlugin {
                 .insert_resource(render_adapter.clone())
                 .insert_resource(compressed_image_format_support);
 
-            #[cfg(all(feature = "dlss", not(feature = "force_disable_dlss")))]
-            if let Some(dlss_super_resolution_supported) = dlss_super_resolution_supported {
-                app.insert_resource(dlss_super_resolution_supported);
-            }
-            #[cfg(all(feature = "dlss", not(feature = "force_disable_dlss")))]
-            if let Some(dlss_ray_reconstruction_supported) = dlss_ray_reconstruction_supported {
-                app.insert_resource(dlss_ray_reconstruction_supported);
-            }
-
             let render_app = app.sub_app_mut(RenderApp);
 
+            #[cfg(feature = "raw_vulkan_init")]
+            {
+                let additional_vulkan_features: renderer::raw_vulkan_init::AdditionalVulkanFeatures =
+                    render_resources.5;
+                render_app.insert_resource(additional_vulkan_features);
+            }
+
             render_app
                 .insert_resource(instance)
                 .insert_resource(PipelineCache::new(
@@ -603,22 +591,3 @@ pub fn get_mali_driver_version(adapter: &RenderAdapter) -> Option<u32> {
 
     None
 }
-
-/// Application-specific ID for DLSS.
-///
-/// See the DLSS programming guide for more info.
-#[cfg(all(feature = "dlss", not(feature = "force_disable_dlss")))]
-#[derive(Resource)]
-pub struct DlssProjectId(pub bevy_asset::uuid::Uuid);
-
-/// When DLSS Super Resolution is supported by the current system, this resource will exist in the main world.
-/// Otherwise this resource will be absent.
-#[cfg(all(feature = "dlss", not(feature = "force_disable_dlss")))]
-#[derive(Resource, Clone, Copy)]
-pub struct DlssSuperResolutionSupported;
-
-/// When DLSS Ray Reconstruction is supported by the current system, this resource will exist in the main world.
-/// Otherwise this resource will be absent.
-#[cfg(all(feature = "dlss", not(feature = "force_disable_dlss")))]
-#[derive(Resource, Clone, Copy)]
-pub struct DlssRayReconstructionSupported;