wgpui 0.4.1

Independent wgpu + winit UI framework (community fork of GPUI / GPUI-CE 0.3.3)
Documentation
use std::sync::Arc;

use super::surface_registry::SurfaceRegistry;

pub struct WgpuContext {
    pub(super) adapter: wgpu::Adapter,
    pub(super) device: wgpu::Device,
    pub(super) queue: wgpu::Queue,
    pub(super) instance: wgpu::Instance,

    pub(super) globals_buffer: wgpu::Buffer,
    pub(super) quads_buffer: wgpu::Buffer,
    pub(super) shadows_buffer: wgpu::Buffer,
    pub(super) underlines_buffer: wgpu::Buffer,
    pub(super) mono_sprites_buffer: wgpu::Buffer,
    pub(super) poly_sprites_buffer: wgpu::Buffer,
    pub(super) color_adjustments_buffer: wgpu::Buffer,
    pub(super) path_vertices_buffer: wgpu::Buffer,
    pub(super) path_sprites_buffer: wgpu::Buffer,

    pub(crate) surface_registry: Arc<SurfaceRegistry>,
}

/// Format-only features: each makes a texture format usable without altering
/// anything that already works, so requesting them needs no decision from the
/// application that cannot reach this constructor.
const OPTIONAL_TEXTURE_FEATURES: wgpu::Features =
    wgpu::Features::TEXTURE_FORMAT_16BIT_NORM.union(wgpu::Features::FLOAT32_FILTERABLE);

/// Timestamp queries, for an application that times its own GPU work: they
/// cost nothing until it makes a query set.
const OPTIONAL_TIMING_FEATURES: wgpu::Features = wgpu::Features::TIMESTAMP_QUERY;

impl WgpuContext {
    pub fn new() -> anyhow::Result<Self> {
        let mut instance_descriptor = wgpu::InstanceDescriptor::new_without_display_handle();
        instance_descriptor.backends = wgpu::Backends::all();
        let instance = wgpu::Instance::new(instance_descriptor);

        let adapter = pollster::block_on(instance.request_adapter(&wgpu::RequestAdapterOptions {
            power_preference: wgpu::PowerPreference::HighPerformance,
            compatible_surface: None,
            force_fallback_adapter: false,
            apply_limit_buckets: false,
        }))?;

        // Intersected, so an adapter lacking them still yields a valid request.
        let available = (OPTIONAL_TEXTURE_FEATURES | OPTIONAL_TIMING_FEATURES) & adapter.features();

        let (device, queue) =
            pollster::block_on(adapter.request_device(&wgpu::DeviceDescriptor {
                label: None,
                required_features: available,
                required_limits: wgpu::Limits::default(),
                ..Default::default()
            }))?;

        let globals_buffer = device.create_buffer(&wgpu::BufferDescriptor {
            label: Some("Globals Buffer"),
            // FIXME(mdeand): Hack
            size: 16_u64,
            usage: wgpu::BufferUsages::UNIFORM | wgpu::BufferUsages::COPY_DST,
            mapped_at_creation: false,
        });

        let quads_buffer = device.create_buffer(&wgpu::BufferDescriptor {
            label: Some("Quads Buffer"),
            // TODO(mdeand): Determine appropriate size
            size: 16 * 1024 * 1024,
            usage: wgpu::BufferUsages::VERTEX
                | wgpu::BufferUsages::COPY_DST
                | wgpu::BufferUsages::STORAGE,
            mapped_at_creation: false,
        });

        let mono_sprites_buffer = device.create_buffer(&wgpu::BufferDescriptor {
            label: Some("Monosprites Buffer"),
            // TODO(mdeand): Determine appropriate size, or make resizable.
            size: 16 * 1024 * 1024,
            usage: wgpu::BufferUsages::VERTEX
                | wgpu::BufferUsages::COPY_DST
                | wgpu::BufferUsages::STORAGE,
            mapped_at_creation: false,
        });

        let shadows_buffer = device.create_buffer(&wgpu::BufferDescriptor {
            label: Some("Shadows Buffer"),
            size: 16 * 1024 * 1024,
            usage: wgpu::BufferUsages::VERTEX
                | wgpu::BufferUsages::COPY_DST
                | wgpu::BufferUsages::STORAGE,
            mapped_at_creation: false,
        });

        let underlines_buffer = device.create_buffer(&wgpu::BufferDescriptor {
            label: Some("Underlines Buffer"),
            size: 16 * 1024 * 1024,
            usage: wgpu::BufferUsages::VERTEX
                | wgpu::BufferUsages::COPY_DST
                | wgpu::BufferUsages::STORAGE,
            mapped_at_creation: false,
        });

        let poly_sprites_buffer = device.create_buffer(&wgpu::BufferDescriptor {
            label: Some("Poly Sprites Buffer"),
            size: 16 * 1024 * 1024,
            usage: wgpu::BufferUsages::VERTEX
                | wgpu::BufferUsages::COPY_DST
                | wgpu::BufferUsages::STORAGE,
            mapped_at_creation: false,
        });

        let color_adjustments_buffer = device.create_buffer(&wgpu::BufferDescriptor {
            label: Some("Color Adjustments Buffer"),
            size: 1024 * 16, // TODO(mdeand): 16 KB buffer for color adjustments, for now. (:
            usage: wgpu::BufferUsages::STORAGE
                | wgpu::BufferUsages::COPY_DST
                | wgpu::BufferUsages::UNIFORM,
            mapped_at_creation: false,
        });

        let path_vertices_buffer = device.create_buffer(&wgpu::BufferDescriptor {
            label: Some("Path Vertices Buffer"),
            size: 16 * 1024 * 1024,
            usage: wgpu::BufferUsages::STORAGE | wgpu::BufferUsages::COPY_DST,
            mapped_at_creation: false,
        });

        let path_sprites_buffer = device.create_buffer(&wgpu::BufferDescriptor {
            label: Some("Path Sprites Buffer"),
            size: 1024 * 1024,
            usage: wgpu::BufferUsages::STORAGE | wgpu::BufferUsages::COPY_DST,
            mapped_at_creation: false,
        });

        Ok(Self {
            adapter,
            device,
            queue,
            instance,

            globals_buffer,
            quads_buffer,
            shadows_buffer,
            underlines_buffer,
            mono_sprites_buffer,
            poly_sprites_buffer,
            color_adjustments_buffer,
            path_vertices_buffer,
            path_sprites_buffer,

            surface_registry: Arc::new(SurfaceRegistry::new()),
        })
    }
}