rhachis/

graphics.rs

//! Code specialised in handling graphics(). Most of this is universally applicable.

use std::ops::{Deref, DerefMut};

use downcast_rs::{impl_downcast, DowncastSync};
use fxhash::FxHashMap;
use glam::{Mat4, UVec2};
use wgpu::{
    util::{BufferInitDescriptor, DeviceExt},
    Buffer, CommandEncoder, Device, Queue, RenderPass, Sampler, Surface, SurfaceConfiguration,
    TextureView,
};
use winit::{dpi::PhysicalSize, window::Window};

use crate::{game_data, GameInit};

/// A handler over all core graphics components.
pub struct Graphics {
    pub device: Device,
    pub queue: Queue,
    pub surface: Surface,
    pub config: SurfaceConfiguration,
}

impl Graphics {
    pub(crate) async unsafe fn new(window: &Window, game_init: &GameInit) -> Self {
        let size = window.inner_size();

        let instance = wgpu::Instance::new(wgpu::InstanceDescriptor {
            backends: wgpu::Backends::all(),
            dx12_shader_compiler: wgpu::Dx12Compiler::default(),
        });
        let surface = unsafe {
            // SAFETY: The Window continues to exist for the duration of the game.
            instance.create_surface(&window)
        }
        .unwrap();
        let adapter = instance
            .request_adapter(&wgpu::RequestAdapterOptions {
                power_preference: wgpu::PowerPreference::default(),
                force_fallback_adapter: false,
                compatible_surface: Some(&surface),
            })
            .await
            .unwrap();

        let (device, queue) = adapter
            .request_device(
                &wgpu::DeviceDescriptor {
                    label: None,
                    features: game_init.features,
                    limits: wgpu::Limits::default(),
                },
                None,
            )
            .await
            .unwrap();

        let config = wgpu::SurfaceConfiguration {
            usage: wgpu::TextureUsages::RENDER_ATTACHMENT,
            format: surface
                .get_capabilities(&adapter)
                .formats
                .into_iter()
                .find(|f| f.describe().srgb)
                .expect("Could not get compatible surface format"),
            width: size.width,
            height: size.height,
            present_mode: game_init.present_mode,
            alpha_mode: wgpu::CompositeAlphaMode::Auto,
            view_formats: vec![],
        };
        surface.configure(&device, &config);

        Self {
            device,
            queue,
            surface,
            config,
        }
    }

    pub(crate) fn render(&self, renderer: &mut dyn Renderer) -> Result<(), wgpu::SurfaceError> {
        let output = self.surface.get_current_texture()?;
        let view = output
            .texture
            .create_view(&wgpu::TextureViewDescriptor::default());

        let mut encoder = self
            .device
            .create_command_encoder(&wgpu::CommandEncoderDescriptor { label: None });

        {
            renderer.render(&view, &mut encoder);
        }

        self.queue.submit(std::iter::once(encoder.finish()));
        output.present();

        Ok(())
    }

    pub(crate) fn resize(&mut self, size: UVec2) {
        let size = PhysicalSize::new(size.x, size.y);
        self.config.width = size.width;
        self.config.height = size.height;
        self.surface.configure(&self.device, &self.config);
    }
}

#[allow(unused)]
/// This trait must be implemented on all renderers. It exposes API for rendering a frame.
pub trait Renderer: DowncastSync {
    /// This is called every frame once the renderpass has been created.
    fn render(&mut self, view: &TextureView, encoder: &mut CommandEncoder) {}
    /// This is called when a render pass has already been created, especially as a result of
    /// being a child renderer (eg a `UiRenderer` in a `SimpleRenderer`).
    fn render_child<'a, 'b: 'a>(&'b self, render_pass: &mut RenderPass<'a>) {}
    /// This is called every frame after the game updates. This is for any state that the renderer
    /// itself will have to maintain.
    fn update(&mut self) {}
    /// This is called when the canvas is resized. This is for things such as updating the size of
    /// a perspective projection aspect ratio.
    fn resize(&mut self, size: UVec2) {}
}

impl_downcast!(sync Renderer);

/// A renderer that does nothing, useful for some tests.
pub struct EmptyRenderer;

impl Renderer for EmptyRenderer {}

#[derive(Debug, Default)]
pub struct SamplerManager {
    pub samplers: FxHashMap<SamplerType, Sampler>,
}

impl SamplerManager {
    #[must_use]
    pub fn new() -> Self {
        Self {
            samplers: FxHashMap::default(),
        }
    }

    pub fn get(&mut self, ty: SamplerType) -> &Sampler {
        self.samplers.entry(ty).or_insert_with(|| (&ty).into())
    }
}

#[derive(Clone, Copy, Debug, Hash, PartialEq, Eq)]
pub struct SamplerType {
    pub address_mode: wgpu::AddressMode,
    pub filter_mode: wgpu::FilterMode,
}

impl SamplerType {
    pub const LINEAR: Self = Self {
        address_mode: wgpu::AddressMode::Repeat,
        filter_mode: wgpu::FilterMode::Linear,
    };

    pub const NEAREST: Self = Self {
        address_mode: wgpu::AddressMode::Repeat,
        filter_mode: wgpu::FilterMode::Nearest,
    };
}

impl Default for SamplerType {
    fn default() -> Self {
        Self {
            address_mode: wgpu::AddressMode::Repeat,
            filter_mode: wgpu::FilterMode::Linear,
        }
    }
}

impl From<&SamplerType> for Sampler {
    fn from(value: &SamplerType) -> Self {
        game_data()
            .graphics()
            .device
            .create_sampler(&wgpu::SamplerDescriptor {
                address_mode_u: value.address_mode,
                address_mode_v: value.address_mode,
                address_mode_w: value.address_mode,
                mag_filter: value.filter_mode,
                min_filter: value.filter_mode,
                // TODO Make border color customisable
                border_color: match value.address_mode {
                    wgpu::AddressMode::ClampToBorder => Some(wgpu::SamplerBorderColor::OpaqueBlack),
                    _ => None,
                },
                ..Default::default()
            })
    }
}

#[must_use]
pub const fn size_to_uvec2(size: PhysicalSize<u32>) -> UVec2 {
    UVec2::new(size.width, size.height)
}

// TODO Add capacity to make enough space in one go
/// A representation of a collection of data that is linked to a buffer and automatically updates
/// when modified. Mutably dereferencing the struct allows modifications to `values` and stores
/// when these changes happen so they may be rewritten to the buffer. `T` is the type of the
/// values being stored, and `U` is the type that it gets converted to before put onto the buffer
/// (if any).
pub struct BufferData<T: BufferCompatible> {
    /// The values stored on the buffer.
    pub values: Vec<T>,
    /// The buffer in case direct access is needed.
    pub buffer: Buffer,
    /// Records if the buffer needs to be rewritten at another time. Can be modified to either
    /// avoid putting changes on the buffer or to force rewrite data to a buffer.
    pub modified: bool,
    pub buffer_len: u32,
}

impl<T: BufferCompatible> BufferData<T> {
    pub fn new(values: Vec<T>, usage: wgpu::BufferUsages) -> Self {
        let buffer = game_data()
            .graphics()
            .device
            .create_buffer_init(&BufferInitDescriptor {
                label: None,
                contents: bytemuck::cast_slice(&values.iter().map(T::as_pod).collect::<Vec<_>>()),
                usage,
            });

        Self {
            buffer_len: values.len() as u32,
            values,
            buffer,
            modified: false,
        }
    }

    pub fn update(&mut self) {
        // If the buffer is a different size a new buffer will be needed to be made
        if self.modified {
            if self.needs_new_buffer() {
                self.buffer =
                    game_data()
                        .graphics()
                        .device
                        .create_buffer_init(&BufferInitDescriptor {
                            label: None,
                            contents: bytemuck::cast_slice(
                                &self.values.iter().map(T::as_pod).collect::<Vec<_>>(),
                            ),
                            usage: self.buffer.usage(),
                        });
                self.buffer_len = self.values.len() as u32;
            } else {
                game_data().graphics().queue.write_buffer(
                    &self.buffer,
                    0,
                    bytemuck::cast_slice(&self.values.iter().map(T::as_pod).collect::<Vec<_>>()),
                );
            }
            self.modified = false;
        }
    }

    /// Returns whether the buffer needs to be recreated due to it not being able to fit all of the
    /// current data.
    pub fn needs_new_buffer(&self) -> bool {
        self.buffer_len < self.values.len() as u32
    }

    /// Returns the buffer, updating it if needed.
    pub fn get(&mut self) -> &Buffer {
        if self.modified {
            self.update();
            self.modified = false;
        }
        &self.buffer
    }

    pub fn push(&mut self, value: T) -> usize {
        self.modified = true;
        self.values.push(value);
        self.values.len() - 1
    }

    pub fn replace(&mut self, values: Vec<T>) {
        self.modified = true;
        self.values = values;
    }

    pub fn remove(&mut self, index: usize) -> T {
        self.modified = true;
        self.values.remove(index)
    }

    pub fn buffer_slice(&self) -> wgpu::BufferSlice {
        self.buffer.slice(..)
    }

    /// Returns an instance of `BufferData` with a single default element.
    pub fn default(usage: wgpu::BufferUsages) -> Self
    where
        T: Default,
    {
        Self::new(vec![T::default()], usage)
    }
}

impl<T: BufferCompatible> Deref for BufferData<T> {
    type Target = [T];

    fn deref(&self) -> &Self::Target {
        &self.values
    }
}

impl<T: BufferCompatible> DerefMut for BufferData<T> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        self.modified = true;
        &mut self.values
    }
}

// TODO Make it BufferCompatible<T> so they can have multiple PodFormats
/// Used for items stored on a `BufferData`.
pub trait BufferCompatible {
    /// The format the type will be converted to for writing to the buffer.
    type PodFormat: bytemuck::Pod;
    /// The method to convert the type into its plain-old-data format.
    fn as_pod(&self) -> Self::PodFormat;
}

impl<T> BufferCompatible for T
where
    T: bytemuck::Pod,
{
    type PodFormat = T;
    fn as_pod(&self) -> Self::PodFormat {
        *self
    }
}

/// Implemented for things that can be stored onto bind groups.
pub trait Bindable {
    fn bind_group_layout() -> wgpu::BindGroupLayout;
}

impl Bindable for Mat4 {
    fn bind_group_layout() -> wgpu::BindGroupLayout {
        game_data()
            .graphics()
            .device
            .create_bind_group_layout(&wgpu::BindGroupLayoutDescriptor {
                label: None,
                entries: &[wgpu::BindGroupLayoutEntry {
                    binding: 0,
                    visibility: wgpu::ShaderStages::VERTEX,
                    ty: wgpu::BindingType::Buffer {
                        ty: wgpu::BufferBindingType::Uniform,
                        has_dynamic_offset: false,
                        min_binding_size: None,
                    },
                    count: None,
                }],
            })
    }
}