mod.rs

mod graph_runner;
mod render_device;

use bevy_utils::tracing::info_span;
pub use graph_runner::*;
pub use render_device::*;

use crate::{
    options::{WgpuOptions, WgpuOptionsPriority},
    render_graph::RenderGraph,
    view::{ExtractedWindows, ViewTarget},
};
use bevy_ecs::prelude::*;
use std::sync::Arc;
use wgpu::{Adapter, CommandEncoder, Instance, Queue};

/// Updates the [`RenderGraph`] with all of its nodes and then runs it to render the entire frame.
pub fn render_system(world: &mut World) {
    world.resource_scope(|world, mut graph: Mut<RenderGraph>| {
        graph.update(world);
    });
    let graph = world.get_resource::<RenderGraph>().unwrap();
    let render_device = world.get_resource::<RenderDevice>().unwrap();
    let render_queue = world.get_resource::<RenderQueue>().unwrap();
    RenderGraphRunner::run(
        graph,
        render_device.clone(), // TODO: is this clone really necessary?
        render_queue,
        world,
    )
    .unwrap();
    {
        let span = info_span!("present_frames");
        let _guard = span.enter();

        // Remove ViewTarget components to ensure swap chain TextureViews are dropped.
        // If all TextureViews aren't dropped before present, acquiring the next swap chain texture will fail.
        let view_entities = world
            .query_filtered::<Entity, With<ViewTarget>>()
            .iter(world)
            .collect::<Vec<_>>();
        for view_entity in view_entities {
            world.entity_mut(view_entity).remove::<ViewTarget>();
        }

        let mut windows = world.get_resource_mut::<ExtractedWindows>().unwrap();
        for window in windows.values_mut() {
            if let Some(texture_view) = window.swap_chain_texture.take() {
                if let Some(surface_texture) = texture_view.take_surface_texture() {
                    surface_texture.present();
                }
            }
        }
    }
}

/// This queue is used to enqueue tasks for the GPU to execute asynchronously.
pub type RenderQueue = Arc<Queue>;

pub type RenderAdapter = Arc<Adapter>;

/// The GPU instance is used to initialize the [`RenderQueue`] and [`RenderDevice`],
/// aswell as to create [`WindowSurfaces`](crate::view::window::WindowSurfaces).
pub type RenderInstance = Instance;

/// `wgpu::Features` that are not automatically enabled due to having possibly-negative side effects.
/// `MAPPABLE_PRIMARY_BUFFERS` can have a significant, negative performance impact so should not be
/// automatically enabled.
pub const DEFAULT_DISABLED_WGPU_FEATURES: wgpu::Features = wgpu::Features::MAPPABLE_PRIMARY_BUFFERS;

/// Initializes the renderer by retrieving and preparing the GPU instance, device and queue
/// for the specified backend.
pub async fn initialize_renderer(
    #[cfg_attr(not(target_arch = "wasm32"), allow(unused))] app: &mut bevy_app::App,
    instance: &wgpu::Instance,
    #[cfg_attr(target_arch = "wasm32", allow(unused))] backends: wgpu::Backends,
    options: &mut WgpuOptions,
) -> (RenderDevice, RenderAdapter, RenderQueue) {
    let adapter = {
        #[cfg(not(target_arch = "wasm32"))]
        {
            use crate::texture::{BevyDefault as _, DEFAULT_DEPTH_FORMAT};
            let mut adapters: Vec<wgpu::Adapter> = instance.enumerate_adapters(backends).collect();
            let (mut integrated, mut discrete, mut virt, mut cpu, mut other) =
                (None, None, None, None, None);

            for (i, adapter) in adapters.iter().enumerate() {
                let default_texture_format_features =
                    adapter.get_texture_format_features(wgpu::TextureFormat::bevy_default());
                let default_depth_format_features =
                    adapter.get_texture_format_features(DEFAULT_DEPTH_FORMAT);
                if default_texture_format_features
                    .allowed_usages
                    .contains(wgpu::TextureUsages::RENDER_ATTACHMENT)
                    && default_depth_format_features
                        .allowed_usages
                        .contains(wgpu::TextureUsages::RENDER_ATTACHMENT)
                {
                    let info = adapter.get_info();
                    match info.device_type {
                        wgpu::DeviceType::IntegratedGpu => {
                            integrated = integrated.or(Some(i));
                        }
                        wgpu::DeviceType::DiscreteGpu => {
                            discrete = discrete.or(Some(i));
                        }
                        wgpu::DeviceType::VirtualGpu => {
                            virt = virt.or(Some(i));
                        }
                        wgpu::DeviceType::Cpu => {
                            cpu = cpu.or(Some(i));
                        }
                        wgpu::DeviceType::Other => {
                            other = other.or(Some(i));
                        }
                    }
                }
            }

            let preferred_gpu_index = match options.power_preference {
                wgpu::PowerPreference::LowPower => {
                    integrated.or(other).or(discrete).or(virt).or(cpu)
                }
                wgpu::PowerPreference::HighPerformance => {
                    discrete.or(other).or(integrated).or(virt).or(cpu)
                }
            }
            .expect("Unable to find a GPU! Make sure you have installed required drivers!");

            adapters.swap_remove(preferred_gpu_index)
        }

        #[cfg(target_arch = "wasm32")]
        {
            let surface = {
                let world = app.world.cell();
                let windows = world.get_resource_mut::<bevy_window::Windows>().unwrap();
                let raw_handle = windows.get_primary().map(|window| unsafe {
                    let handle = window.raw_window_handle().get_handle();
                    instance.create_surface(&handle)
                });
                raw_handle
            };
            instance
                .request_adapter(&wgpu::RequestAdapterOptions {
                    power_preference: options.power_preference,
                    compatible_surface: surface.as_ref(),
                    ..Default::default()
                })
                .await
                .expect("Unable to find a GPU! Make sure you have installed required drivers!")
        }
    };

    #[cfg(feature = "wgpu_trace")]
    let trace_path = {
        let path = std::path::Path::new("wgpu_trace");
        // ignore potential error, wgpu will log it
        let _ = std::fs::create_dir(path);
        Some(path)
    };
    #[cfg(not(feature = "wgpu_trace"))]
    let trace_path = None;

    if matches!(options.priority, WgpuOptionsPriority::Functionality) {
        options.features = (adapter.features()
            | wgpu::Features::TEXTURE_ADAPTER_SPECIFIC_FORMAT_FEATURES)
            - DEFAULT_DISABLED_WGPU_FEATURES;
        options.limits = adapter.limits();
    }

    let (device, queue) = adapter
        .request_device(
            &wgpu::DeviceDescriptor {
                label: options.device_label.as_ref().map(|a| a.as_ref()),
                features: options.features,
                limits: options.limits.clone(),
            },
            trace_path,
        )
        .await
        .unwrap();
    let adapter = Arc::new(adapter);
    let device = Arc::new(device);
    let queue = Arc::new(queue);
    (RenderDevice::from(device), adapter, queue)
}

/// The context with all information required to interact with the GPU.
///
/// The [`RenderDevice`] is used to create render resources and the
/// the [`CommandEncoder`] is used to record a series of GPU operations.
pub struct RenderContext {
    pub render_device: RenderDevice,
    pub command_encoder: CommandEncoder,
}