Adding upstream version 86.0.1.upstream/86.0.1upstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

7 files changed, 1305 insertions, 0 deletions

diff --git a/third_party/rust/gfx-backend-empty/.cargo-checksum.json b/third_party/rust/gfx-backend-empty/.cargo-checksum.json
new file mode 100644
index 0000000000..c4f97350ca
--- /dev/null
+++ b/third_party/rust/gfx-backend-empty/.cargo-checksum.json
@@ -0,0 +1 @@
+{"files":{"Cargo.toml":"4ee6acc22957e2bd938f900080a09dae45de68a7e28adc78bdce6638a09fd85f","src/buffer.rs":"1a275e7a1d4bebe594256709e7ee166222518178bd6112cd45c29d4aa6d002dd","src/descriptor.rs":"c0b3af678d82f20548af382e1840b4bd226c74525339449130f6e8d8f96c7aa2","src/image.rs":"83dba8bae97e06ced4f8030f208566dd773b773be14bc56f10da92dedec041f0","src/lib.rs":"416280a0252a5678ce18f5d8dba8a92973efc420a0742058b7d64ffb09bcd8de","src/memory.rs":"abba2a8943dccf79cc67de3ce33dc534606fe3838220504a1330f773c7bf0ac6"},"package":null}
\ No newline at end of file
diff --git a/third_party/rust/gfx-backend-empty/Cargo.toml b/third_party/rust/gfx-backend-empty/Cargo.toml
new file mode 100644
index 0000000000..b8eafc987a
--- /dev/null
+++ b/third_party/rust/gfx-backend-empty/Cargo.toml
@@ -0,0 +1,17 @@
+[package]
+name = "gfx-backend-empty"
+version = "0.6.0"
+description = "Empty backend for gfx-rs"
+license = "MIT OR Apache-2.0"
+authors = ["The Gfx-rs Developers"]
+documentation = "https://docs.rs/gfx-backend-empty"
+workspace = "../../.."
+edition = "2018"
+
+[lib]
+name = "gfx_backend_empty"
+
+[dependencies]
+gfx-hal = { path = "../../hal", version = "0.6" }
+raw-window-handle = "0.3"
+log = "0.4"
diff --git a/third_party/rust/gfx-backend-empty/src/buffer.rs b/third_party/rust/gfx-backend-empty/src/buffer.rs
new file mode 100644
index 0000000000..217bc83274
--- /dev/null
+++ b/third_party/rust/gfx-backend-empty/src/buffer.rs
@@ -0,0 +1,11 @@
+#[derive(Debug)]
+pub struct Buffer {
+    /// Size of this buffer
+    pub(crate) size: u64,
+}
+
+impl Buffer {
+    pub fn new(size: u64) -> Self {
+        Buffer { size }
+    }
+}
diff --git a/third_party/rust/gfx-backend-empty/src/descriptor.rs b/third_party/rust/gfx-backend-empty/src/descriptor.rs
new file mode 100644
index 0000000000..4368557ad3
--- /dev/null
+++ b/third_party/rust/gfx-backend-empty/src/descriptor.rs
@@ -0,0 +1,42 @@
+use hal::pso;
+use log::debug;
+
+/// Dummy descriptor pool.
+#[derive(Debug)]
+pub struct DescriptorPool;
+
+impl pso::DescriptorPool<crate::Backend> for DescriptorPool {
+    unsafe fn allocate_set(
+        &mut self,
+        _layout: &DescriptorSetLayout,
+    ) -> Result<DescriptorSet, pso::AllocationError> {
+        Ok(DescriptorSet {
+            name: String::new(),
+        })
+    }
+
+    unsafe fn free<I>(&mut self, descriptor_sets: I)
+    where
+        I: IntoIterator<Item = DescriptorSet>,
+    {
+        for _ in descriptor_sets {
+            // Let the descriptor set drop
+        }
+    }
+
+    unsafe fn reset(&mut self) {
+        debug!("Resetting descriptor pool");
+    }
+}
+
+#[derive(Debug)]
+pub struct DescriptorSetLayout {
+    /// User-defined name for this descriptor set layout
+    pub(crate) name: String,
+}
+
+#[derive(Debug)]
+pub struct DescriptorSet {
+    /// User-defined name for this descriptor set
+    pub(crate) name: String,
+}
diff --git a/third_party/rust/gfx-backend-empty/src/image.rs b/third_party/rust/gfx-backend-empty/src/image.rs
new file mode 100644
index 0000000000..c83af2366e
--- /dev/null
+++ b/third_party/rust/gfx-backend-empty/src/image.rs
@@ -0,0 +1,30 @@
+use hal::image::Kind;
+use hal::memory::Requirements as MemoryRequirements;
+
+#[derive(Debug)]
+pub struct Image {
+    /// What type of image this is, as well as its extent.
+    kind: Kind,
+}
+
+impl Image {
+    pub fn new(kind: Kind) -> Self {
+        Image { kind }
+    }
+
+    pub fn get_requirements(&self) -> MemoryRequirements {
+        let size = match self.kind {
+            Kind::D2(width, height, layers, samples) => {
+                assert_eq!(layers, 1, "Multi-layer images are not supported");
+                assert_eq!(samples, 1, "Multisampled images are not supported");
+                u64::from(width) * u64::from(height)
+            }
+            _ => unimplemented!("Unsupported image kind"),
+        };
+        MemoryRequirements {
+            size,
+            alignment: 1,
+            type_mask: !0,
+        }
+    }
+}
diff --git a/third_party/rust/gfx-backend-empty/src/lib.rs b/third_party/rust/gfx-backend-empty/src/lib.rs
new file mode 100644
index 0000000000..0ac826454b
--- /dev/null
+++ b/third_party/rust/gfx-backend-empty/src/lib.rs
@@ -0,0 +1,1146 @@
+//! Mock backend implementation to test the code for compile errors
+//! outside of the graphics development environment.
+
+extern crate gfx_hal as hal;
+
+use crate::{
+    buffer::Buffer,
+    descriptor::{DescriptorPool, DescriptorSet, DescriptorSetLayout},
+    image::Image,
+    memory::Memory,
+};
+
+use hal::{adapter, command, device, format, pass, pool, pso, query, queue, window};
+use log::debug;
+
+use std::{borrow::Borrow, ops::Range};
+
+mod buffer;
+mod descriptor;
+mod image;
+mod memory;
+
+const NOT_SUPPORTED_MESSAGE: &str = "This function is not currently mocked by the empty backend";
+
+/// Dummy backend.
+#[derive(Copy, Clone, Debug, PartialEq, Eq, Hash)]
+pub enum Backend {}
+impl hal::Backend for Backend {
+    type Instance = Instance;
+    type PhysicalDevice = PhysicalDevice;
+    type Device = Device;
+    type Surface = Surface;
+
+    type QueueFamily = QueueFamily;
+    type CommandQueue = CommandQueue;
+    type CommandBuffer = CommandBuffer;
+
+    type Memory = Memory;
+    type CommandPool = CommandPool;
+
+    type ShaderModule = ();
+    type RenderPass = ();
+    type Framebuffer = ();
+
+    type Buffer = Buffer;
+    type BufferView = ();
+    type Image = Image;
+    type ImageView = ();
+    type Sampler = ();
+
+    type ComputePipeline = ();
+    type GraphicsPipeline = ();
+    type PipelineCache = ();
+    type PipelineLayout = ();
+    type DescriptorSetLayout = DescriptorSetLayout;
+    type DescriptorPool = DescriptorPool;
+    type DescriptorSet = DescriptorSet;
+
+    type Fence = ();
+    type Semaphore = ();
+    type Event = ();
+    type QueryPool = ();
+}
+
+/// Dummy physical device.
+#[derive(Debug)]
+pub struct PhysicalDevice;
+impl adapter::PhysicalDevice<Backend> for PhysicalDevice {
+    unsafe fn open(
+        &self,
+        families: &[(&QueueFamily, &[queue::QueuePriority])],
+        _requested_features: hal::Features,
+    ) -> Result<adapter::Gpu<Backend>, device::CreationError> {
+        // Validate the arguments
+        assert_eq!(
+            families.len(),
+            1,
+            "Empty backend doesn't have multiple queue families"
+        );
+        let (_family, priorities) = families[0];
+        assert_eq!(
+            priorities.len(),
+            1,
+            "Empty backend doesn't support multiple queues"
+        );
+        let priority = priorities[0];
+        assert!(
+            0.0 <= priority && priority <= 1.0,
+            "Queue priority is out of range"
+        );
+
+        // Create the queues
+        let queue_groups = {
+            let mut queue_group = queue::QueueGroup::new(QUEUE_FAMILY_ID);
+            queue_group.add_queue(CommandQueue);
+            vec![queue_group]
+        };
+        let gpu = adapter::Gpu {
+            device: Device,
+            queue_groups,
+        };
+        Ok(gpu)
+    }
+
+    fn format_properties(&self, _: Option<format::Format>) -> format::Properties {
+        unimplemented!("{}", NOT_SUPPORTED_MESSAGE)
+    }
+
+    fn image_format_properties(
+        &self,
+        _: format::Format,
+        _dim: u8,
+        _: hal::image::Tiling,
+        _: hal::image::Usage,
+        _: hal::image::ViewCapabilities,
+    ) -> Option<hal::image::FormatProperties> {
+        unimplemented!("{}", NOT_SUPPORTED_MESSAGE)
+    }
+
+    fn memory_properties(&self) -> adapter::MemoryProperties {
+        let memory_types = {
+            use hal::memory::Properties;
+            let properties = Properties::DEVICE_LOCAL
+                | Properties::CPU_VISIBLE
+                | Properties::COHERENT
+                | Properties::CPU_CACHED;
+            let memory_type = adapter::MemoryType {
+                properties,
+                heap_index: 0,
+            };
+            vec![memory_type]
+        };
+        // TODO: perhaps get an estimate of free RAM to report here?
+        let memory_heaps = vec![adapter::MemoryHeap {
+            size: 64 * 1024,
+            flags: hal::memory::HeapFlags::empty(),
+        }];
+        adapter::MemoryProperties {
+            memory_types,
+            memory_heaps,
+        }
+    }
+
+    fn features(&self) -> hal::Features {
+        unimplemented!("{}", NOT_SUPPORTED_MESSAGE)
+    }
+
+    fn hints(&self) -> hal::Hints {
+        unimplemented!("{}", NOT_SUPPORTED_MESSAGE)
+    }
+
+    fn limits(&self) -> hal::Limits {
+        hal::Limits {
+            non_coherent_atom_size: 1,
+            optimal_buffer_copy_pitch_alignment: 1,
+            ..Default::default()
+        }
+    }
+}
+
+/// Dummy command queue doing nothing.
+#[derive(Debug)]
+pub struct CommandQueue;
+impl queue::CommandQueue<Backend> for CommandQueue {
+    unsafe fn submit<'a, T, Ic, S, Iw, Is>(
+        &mut self,
+        _: queue::Submission<Ic, Iw, Is>,
+        _: Option<&()>,
+    ) where
+        T: 'a + Borrow<CommandBuffer>,
+        Ic: IntoIterator<Item = &'a T>,
+        S: 'a + Borrow<()>,
+        Iw: IntoIterator<Item = (&'a S, pso::PipelineStage)>,
+        Is: IntoIterator<Item = &'a S>,
+    {
+    }
+
+    unsafe fn present(
+        &mut self,
+        _surface: &mut Surface,
+        _image: SwapchainImage,
+        _wait_semaphore: Option<&()>,
+    ) -> Result<Option<window::Suboptimal>, window::PresentError> {
+        Ok(None)
+    }
+
+    fn wait_idle(&self) -> Result<(), device::OutOfMemory> {
+        unimplemented!("{}", NOT_SUPPORTED_MESSAGE)
+    }
+}
+
+/// Dummy device doing nothing.
+#[derive(Debug)]
+pub struct Device;
+impl device::Device<Backend> for Device {
+    unsafe fn create_command_pool(
+        &self,
+        _: queue::QueueFamilyId,
+        _: pool::CommandPoolCreateFlags,
+    ) -> Result<CommandPool, device::OutOfMemory> {
+        Ok(CommandPool)
+    }
+
+    unsafe fn destroy_command_pool(&self, _: CommandPool) {}
+
+    unsafe fn allocate_memory(
+        &self,
+        memory_type: hal::MemoryTypeId,
+        size: u64,
+    ) -> Result<Memory, device::AllocationError> {
+        Memory::allocate(memory_type, size)
+    }
+
+    unsafe fn create_render_pass<'a, IA, IS, ID>(
+        &self,
+        _: IA,
+        _: IS,
+        _: ID,
+    ) -> Result<(), device::OutOfMemory>
+    where
+        IA: IntoIterator,
+        IA::Item: Borrow<pass::Attachment>,
+        IS: IntoIterator,
+        IS::Item: Borrow<pass::SubpassDesc<'a>>,
+        ID: IntoIterator,
+        ID::Item: Borrow<pass::SubpassDependency>,
+    {
+        Ok(())
+    }
+
+    unsafe fn create_pipeline_layout<IS, IR>(&self, _: IS, _: IR) -> Result<(), device::OutOfMemory>
+    where
+        IS: IntoIterator,
+        IS::Item: Borrow<DescriptorSetLayout>,
+        IR: IntoIterator,
+        IR::Item: Borrow<(pso::ShaderStageFlags, Range<u32>)>,
+    {
+        Ok(())
+    }
+
+    unsafe fn create_pipeline_cache(
+        &self,
+        _data: Option<&[u8]>,
+    ) -> Result<(), device::OutOfMemory> {
+        unimplemented!("{}", NOT_SUPPORTED_MESSAGE)
+    }
+
+    unsafe fn get_pipeline_cache_data(&self, _cache: &()) -> Result<Vec<u8>, device::OutOfMemory> {
+        unimplemented!("{}", NOT_SUPPORTED_MESSAGE)
+    }
+
+    unsafe fn destroy_pipeline_cache(&self, _: ()) {
+        unimplemented!("{}", NOT_SUPPORTED_MESSAGE)
+    }
+
+    unsafe fn create_graphics_pipeline<'a>(
+        &self,
+        _: &pso::GraphicsPipelineDesc<'a, Backend>,
+        _: Option<&()>,
+    ) -> Result<(), pso::CreationError> {
+        Ok(())
+    }
+
+    unsafe fn create_compute_pipeline<'a>(
+        &self,
+        _: &pso::ComputePipelineDesc<'a, Backend>,
+        _: Option<&()>,
+    ) -> Result<(), pso::CreationError> {
+        unimplemented!("{}", NOT_SUPPORTED_MESSAGE)
+    }
+
+    unsafe fn merge_pipeline_caches<I>(&self, _: &(), _: I) -> Result<(), device::OutOfMemory>
+    where
+        I: IntoIterator,
+        I::Item: Borrow<()>,
+    {
+        unimplemented!("{}", NOT_SUPPORTED_MESSAGE)
+    }
+
+    unsafe fn create_framebuffer<I>(
+        &self,
+        _: &(),
+        _: I,
+        _: hal::image::Extent,
+    ) -> Result<(), device::OutOfMemory>
+    where
+        I: IntoIterator,
+        I::Item: Borrow<()>,
+    {
+        Ok(())
+    }
+
+    unsafe fn create_shader_module(&self, _: &[u32]) -> Result<(), device::ShaderError> {
+        Ok(())
+    }
+
+    unsafe fn create_sampler(
+        &self,
+        _: &hal::image::SamplerDesc,
+    ) -> Result<(), device::AllocationError> {
+        Ok(())
+    }
+
+    unsafe fn create_buffer(
+        &self,
+        size: u64,
+        _: hal::buffer::Usage,
+    ) -> Result<Buffer, hal::buffer::CreationError> {
+        Ok(Buffer::new(size))
+    }
+
+    unsafe fn get_buffer_requirements(&self, buffer: &Buffer) -> hal::memory::Requirements {
+        hal::memory::Requirements {
+            size: buffer.size,
+            // TODO: perhaps require stronger alignments?
+            alignment: 1,
+            type_mask: !0,
+        }
+    }
+
+    unsafe fn bind_buffer_memory(
+        &self,
+        _memory: &Memory,
+        _: u64,
+        _: &mut Buffer,
+    ) -> Result<(), device::BindError> {
+        Ok(())
+    }
+
+    unsafe fn create_buffer_view(
+        &self,
+        _: &Buffer,
+        _: Option<format::Format>,
+        _: hal::buffer::SubRange,
+    ) -> Result<(), hal::buffer::ViewCreationError> {
+        unimplemented!("{}", NOT_SUPPORTED_MESSAGE)
+    }
+
+    unsafe fn create_image(
+        &self,
+        kind: hal::image::Kind,
+        _: hal::image::Level,
+        _: format::Format,
+        _: hal::image::Tiling,
+        _: hal::image::Usage,
+        _: hal::image::ViewCapabilities,
+    ) -> Result<Image, hal::image::CreationError> {
+        Ok(Image::new(kind))
+    }
+
+    unsafe fn get_image_requirements(&self, image: &Image) -> hal::memory::Requirements {
+        image.get_requirements()
+    }
+
+    unsafe fn get_image_subresource_footprint(
+        &self,
+        _: &Image,
+        _: hal::image::Subresource,
+    ) -> hal::image::SubresourceFootprint {
+        unimplemented!("{}", NOT_SUPPORTED_MESSAGE)
+    }
+
+    unsafe fn bind_image_memory(
+        &self,
+        _memory: &Memory,
+        _: u64,
+        _: &mut Image,
+    ) -> Result<(), device::BindError> {
+        Ok(())
+    }
+
+    unsafe fn create_image_view(
+        &self,
+        _: &Image,
+        _: hal::image::ViewKind,
+        _: format::Format,
+        _: format::Swizzle,
+        _: hal::image::SubresourceRange,
+    ) -> Result<(), hal::image::ViewCreationError> {
+        Ok(())
+    }
+
+    unsafe fn create_descriptor_pool<I>(
+        &self,
+        _: usize,
+        _: I,
+        _: pso::DescriptorPoolCreateFlags,
+    ) -> Result<DescriptorPool, device::OutOfMemory>
+    where
+        I: IntoIterator,
+        I::Item: Borrow<pso::DescriptorRangeDesc>,
+    {
+        Ok(DescriptorPool)
+    }
+
+    unsafe fn create_descriptor_set_layout<I, J>(
+        &self,
+        _bindings: I,
+        _samplers: J,
+    ) -> Result<DescriptorSetLayout, device::OutOfMemory>
+    where
+        I: IntoIterator,
+        I::Item: Borrow<pso::DescriptorSetLayoutBinding>,
+        J: IntoIterator,
+        J::Item: Borrow<()>,
+    {
+        let layout = DescriptorSetLayout {
+            name: String::new(),
+        };
+        Ok(layout)
+    }
+
+    unsafe fn write_descriptor_sets<'a, I, J>(&self, _: I)
+    where
+        I: IntoIterator<Item = pso::DescriptorSetWrite<'a, Backend, J>>,
+        J: IntoIterator,
+        J::Item: Borrow<pso::Descriptor<'a, Backend>>,
+    {
+    }
+
+    unsafe fn copy_descriptor_sets<'a, I>(&self, _: I)
+    where
+        I: IntoIterator,
+        I::Item: Borrow<pso::DescriptorSetCopy<'a, Backend>>,
+    {
+        unimplemented!("{}", NOT_SUPPORTED_MESSAGE)
+    }
+
+    fn create_semaphore(&self) -> Result<(), device::OutOfMemory> {
+        Ok(())
+    }
+
+    fn create_fence(&self, _: bool) -> Result<(), device::OutOfMemory> {
+        Ok(())
+    }
+
+    unsafe fn get_fence_status(&self, _: &()) -> Result<bool, device::DeviceLost> {
+        unimplemented!("{}", NOT_SUPPORTED_MESSAGE)
+    }
+
+    fn create_event(&self) -> Result<(), device::OutOfMemory> {
+        unimplemented!("{}", NOT_SUPPORTED_MESSAGE)
+    }
+
+    unsafe fn get_event_status(&self, _: &()) -> Result<bool, device::OomOrDeviceLost> {
+        unimplemented!("{}", NOT_SUPPORTED_MESSAGE)
+    }
+
+    unsafe fn set_event(&self, _: &()) -> Result<(), device::OutOfMemory> {
+        unimplemented!("{}", NOT_SUPPORTED_MESSAGE)
+    }
+
+    unsafe fn reset_event(&self, _: &()) -> Result<(), device::OutOfMemory> {
+        unimplemented!("{}", NOT_SUPPORTED_MESSAGE)
+    }
+
+    unsafe fn create_query_pool(&self, _: query::Type, _: u32) -> Result<(), query::CreationError> {
+        unimplemented!("{}", NOT_SUPPORTED_MESSAGE)
+    }
+
+    unsafe fn destroy_query_pool(&self, _: ()) {
+        unimplemented!("{}", NOT_SUPPORTED_MESSAGE)
+    }
+
+    unsafe fn get_query_pool_results(
+        &self,
+        _: &(),
+        _: Range<query::Id>,
+        _: &mut [u8],
+        _: hal::buffer::Offset,
+        _: query::ResultFlags,
+    ) -> Result<bool, device::OomOrDeviceLost> {
+        unimplemented!("{}", NOT_SUPPORTED_MESSAGE)
+    }
+
+    unsafe fn map_memory(
+        &self,
+        memory: &Memory,
+        segment: hal::memory::Segment,
+    ) -> Result<*mut u8, device::MapError> {
+        memory.map(segment)
+    }
+
+    unsafe fn unmap_memory(&self, _memory: &Memory) {}
+
+    unsafe fn flush_mapped_memory_ranges<'a, I>(&self, _: I) -> Result<(), device::OutOfMemory>
+    where
+        I: IntoIterator,
+        I::Item: Borrow<(&'a Memory, hal::memory::Segment)>,
+    {
+        Ok(())
+    }
+
+    unsafe fn invalidate_mapped_memory_ranges<'a, I>(&self, _: I) -> Result<(), device::OutOfMemory>
+    where
+        I: IntoIterator,
+        I::Item: Borrow<(&'a Memory, hal::memory::Segment)>,
+    {
+        unimplemented!("{}", NOT_SUPPORTED_MESSAGE)
+    }
+
+    unsafe fn free_memory(&self, _memory: Memory) {
+        // Let memory drop
+    }
+
+    unsafe fn destroy_shader_module(&self, _: ()) {}
+
+    unsafe fn destroy_render_pass(&self, _: ()) {}
+
+    unsafe fn destroy_pipeline_layout(&self, _: ()) {}
+
+    unsafe fn destroy_graphics_pipeline(&self, _: ()) {}
+
+    unsafe fn destroy_compute_pipeline(&self, _: ()) {
+        unimplemented!("{}", NOT_SUPPORTED_MESSAGE)
+    }
+    unsafe fn destroy_framebuffer(&self, _: ()) {}
+
+    unsafe fn destroy_buffer(&self, _: Buffer) {}
+
+    unsafe fn destroy_buffer_view(&self, _: ()) {
+        unimplemented!("{}", NOT_SUPPORTED_MESSAGE)
+    }
+
+    unsafe fn destroy_image(&self, _: Image) {}
+
+    unsafe fn destroy_image_view(&self, _: ()) {}
+
+    unsafe fn destroy_sampler(&self, _: ()) {}
+
+    unsafe fn destroy_descriptor_pool(&self, _: DescriptorPool) {}
+
+    unsafe fn destroy_descriptor_set_layout(&self, _: DescriptorSetLayout) {}
+
+    unsafe fn destroy_fence(&self, _: ()) {}
+
+    unsafe fn destroy_semaphore(&self, _: ()) {}
+
+    unsafe fn destroy_event(&self, _: ()) {
+        unimplemented!("{}", NOT_SUPPORTED_MESSAGE)
+    }
+
+    fn wait_idle(&self) -> Result<(), device::OutOfMemory> {
+        Ok(())
+    }
+
+    unsafe fn set_image_name(&self, _: &mut Image, _: &str) {
+        unimplemented!("{}", NOT_SUPPORTED_MESSAGE)
+    }
+
+    unsafe fn set_buffer_name(&self, _: &mut Buffer, _: &str) {
+        unimplemented!("{}", NOT_SUPPORTED_MESSAGE)
+    }
+
+    unsafe fn set_command_buffer_name(&self, _: &mut CommandBuffer, _: &str) {
+        unimplemented!("{}", NOT_SUPPORTED_MESSAGE)
+    }
+
+    unsafe fn set_semaphore_name(&self, _: &mut (), _: &str) {
+        unimplemented!("{}", NOT_SUPPORTED_MESSAGE)
+    }
+
+    unsafe fn set_fence_name(&self, _: &mut (), _: &str) {
+        unimplemented!("{}", NOT_SUPPORTED_MESSAGE)
+    }
+
+    unsafe fn set_framebuffer_name(&self, _: &mut (), _: &str) {
+        unimplemented!("{}", NOT_SUPPORTED_MESSAGE)
+    }
+
+    unsafe fn set_render_pass_name(&self, _: &mut (), _: &str) {
+        unimplemented!("{}", NOT_SUPPORTED_MESSAGE)
+    }
+
+    unsafe fn set_descriptor_set_name(&self, set: &mut DescriptorSet, name: &str) {
+        set.name = name.to_string();
+    }
+
+    unsafe fn set_descriptor_set_layout_name(&self, layout: &mut DescriptorSetLayout, name: &str) {
+        layout.name = name.to_string();
+    }
+
+    unsafe fn set_pipeline_layout_name(&self, _pipeline_layout: &mut (), _name: &str) {
+        unimplemented!("{}", NOT_SUPPORTED_MESSAGE)
+    }
+
+    unsafe fn set_compute_pipeline_name(&self, _compute_pipeline: &mut (), _name: &str) {
+        unimplemented!("{}", NOT_SUPPORTED_MESSAGE)
+    }
+
+    unsafe fn set_graphics_pipeline_name(&self, _graphics_pipeline: &mut (), _name: &str) {
+        unimplemented!("{}", NOT_SUPPORTED_MESSAGE)
+    }
+
+    unsafe fn reset_fence(&self, _: &()) -> Result<(), device::OutOfMemory> {
+        Ok(())
+    }
+
+    unsafe fn wait_for_fence(&self, _: &(), _: u64) -> Result<bool, device::OomOrDeviceLost> {
+        Ok(true)
+    }
+}
+
+#[derive(Debug)]
+pub struct QueueFamily;
+impl queue::QueueFamily for QueueFamily {
+    fn queue_type(&self) -> queue::QueueType {
+        queue::QueueType::General
+    }
+    fn max_queues(&self) -> usize {
+        1
+    }
+    fn id(&self) -> queue::QueueFamilyId {
+        QUEUE_FAMILY_ID
+    }
+}
+
+const QUEUE_FAMILY_ID: queue::QueueFamilyId = queue::QueueFamilyId(0);
+
+/// Dummy raw command pool.
+#[derive(Debug)]
+pub struct CommandPool;
+impl pool::CommandPool<Backend> for CommandPool {
+    unsafe fn allocate_one(&mut self, level: command::Level) -> CommandBuffer {
+        assert_eq!(
+            level,
+            command::Level::Primary,
+            "Only primary command buffers are supported"
+        );
+        CommandBuffer
+    }
+
+    unsafe fn reset(&mut self, _: bool) {}
+
+    unsafe fn free<I>(&mut self, _: I)
+    where
+        I: IntoIterator<Item = CommandBuffer>,
+    {
+        unimplemented!("{}", NOT_SUPPORTED_MESSAGE)
+    }
+}
+
+/// Dummy command buffer, which ignores all the calls.
+#[derive(Debug)]
+pub struct CommandBuffer;
+impl command::CommandBuffer<Backend> for CommandBuffer {
+    unsafe fn begin(
+        &mut self,
+        _: command::CommandBufferFlags,
+        _: command::CommandBufferInheritanceInfo<Backend>,
+    ) {
+    }
+
+    unsafe fn finish(&mut self) {}
+
+    unsafe fn reset(&mut self, _: bool) {
+        unimplemented!("{}", NOT_SUPPORTED_MESSAGE)
+    }
+
+    unsafe fn pipeline_barrier<'a, T>(
+        &mut self,
+        _: Range<pso::PipelineStage>,
+        _: hal::memory::Dependencies,
+        _: T,
+    ) where
+        T: IntoIterator,
+        T::Item: Borrow<hal::memory::Barrier<'a, Backend>>,
+    {
+    }
+
+    unsafe fn fill_buffer(&mut self, _: &Buffer, _: hal::buffer::SubRange, _: u32) {
+        unimplemented!("{}", NOT_SUPPORTED_MESSAGE)
+    }
+
+    unsafe fn update_buffer(&mut self, _: &Buffer, _: hal::buffer::Offset, _: &[u8]) {
+        unimplemented!("{}", NOT_SUPPORTED_MESSAGE)
+    }
+
+    unsafe fn clear_image<T>(
+        &mut self,
+        _: &Image,
+        _: hal::image::Layout,
+        _: command::ClearValue,
+        _: T,
+    ) where
+        T: IntoIterator,
+        T::Item: Borrow<hal::image::SubresourceRange>,
+    {
+        unimplemented!("{}", NOT_SUPPORTED_MESSAGE)
+    }
+
+    unsafe fn clear_attachments<T, U>(&mut self, _: T, _: U)
+    where
+        T: IntoIterator,
+        T::Item: Borrow<command::AttachmentClear>,
+        U: IntoIterator,
+        U::Item: Borrow<pso::ClearRect>,
+    {
+        unimplemented!("{}", NOT_SUPPORTED_MESSAGE)
+    }
+
+    unsafe fn resolve_image<T>(
+        &mut self,
+        _: &Image,
+        _: hal::image::Layout,
+        _: &Image,
+        _: hal::image::Layout,
+        _: T,
+    ) where
+        T: IntoIterator,
+        T::Item: Borrow<command::ImageResolve>,
+    {
+        unimplemented!("{}", NOT_SUPPORTED_MESSAGE)
+    }
+
+    unsafe fn blit_image<T>(
+        &mut self,
+        _: &Image,
+        _: hal::image::Layout,
+        _: &Image,
+        _: hal::image::Layout,
+        _: hal::image::Filter,
+        _: T,
+    ) where
+        T: IntoIterator,
+        T::Item: Borrow<command::ImageBlit>,
+    {
+        unimplemented!("{}", NOT_SUPPORTED_MESSAGE)
+    }
+
+    unsafe fn bind_index_buffer(
+        &mut self,
+        _: &Buffer,
+        _: hal::buffer::SubRange,
+        _: hal::IndexType,
+    ) {
+        unimplemented!("{}", NOT_SUPPORTED_MESSAGE)
+    }
+
+    unsafe fn bind_vertex_buffers<I, T>(&mut self, _: u32, _: I)
+    where
+        I: IntoIterator<Item = (T, hal::buffer::SubRange)>,
+        T: Borrow<Buffer>,
+    {
+    }
+
+    unsafe fn set_viewports<T>(&mut self, _: u32, _: T)
+    where
+        T: IntoIterator,
+        T::Item: Borrow<pso::Viewport>,
+    {
+    }
+
+    unsafe fn set_scissors<T>(&mut self, _: u32, _: T)
+    where
+        T: IntoIterator,
+        T::Item: Borrow<pso::Rect>,
+    {
+    }
+
+    unsafe fn set_stencil_reference(&mut self, _: pso::Face, _: pso::StencilValue) {
+        unimplemented!("{}", NOT_SUPPORTED_MESSAGE)
+    }
+
+    unsafe fn set_stencil_read_mask(&mut self, _: pso::Face, _: pso::StencilValue) {
+        unimplemented!("{}", NOT_SUPPORTED_MESSAGE)
+    }
+
+    unsafe fn set_stencil_write_mask(&mut self, _: pso::Face, _: pso::StencilValue) {
+        unimplemented!("{}", NOT_SUPPORTED_MESSAGE)
+    }
+
+    unsafe fn set_blend_constants(&mut self, _: pso::ColorValue) {
+        unimplemented!("{}", NOT_SUPPORTED_MESSAGE)
+    }
+
+    unsafe fn set_depth_bounds(&mut self, _: Range<f32>) {
+        unimplemented!("{}", NOT_SUPPORTED_MESSAGE)
+    }
+
+    unsafe fn set_line_width(&mut self, _: f32) {
+        unimplemented!("{}", NOT_SUPPORTED_MESSAGE)
+    }
+
+    unsafe fn set_depth_bias(&mut self, _: pso::DepthBias) {
+        unimplemented!("{}", NOT_SUPPORTED_MESSAGE)
+    }
+
+    unsafe fn begin_render_pass<T>(
+        &mut self,
+        _: &(),
+        _: &(),
+        _: pso::Rect,
+        _: T,
+        _: command::SubpassContents,
+    ) where
+        T: IntoIterator,
+        T::Item: Borrow<command::ClearValue>,
+    {
+    }
+
+    unsafe fn next_subpass(&mut self, _: command::SubpassContents) {
+        unimplemented!("{}", NOT_SUPPORTED_MESSAGE)
+    }
+
+    unsafe fn end_render_pass(&mut self) {}
+
+    unsafe fn bind_graphics_pipeline(&mut self, _: &()) {}
+
+    unsafe fn bind_graphics_descriptor_sets<I, J>(&mut self, _: &(), _: usize, _: I, _: J)
+    where
+        I: IntoIterator,
+        I::Item: Borrow<DescriptorSet>,
+        J: IntoIterator,
+        J::Item: Borrow<command::DescriptorSetOffset>,
+    {
+        // Do nothing
+    }
+
+    unsafe fn bind_compute_pipeline(&mut self, _: &()) {
+        unimplemented!("{}", NOT_SUPPORTED_MESSAGE)
+    }
+
+    unsafe fn bind_compute_descriptor_sets<I, J>(&mut self, _: &(), _: usize, _: I, _: J)
+    where
+        I: IntoIterator,
+        I::Item: Borrow<DescriptorSet>,
+        J: IntoIterator,
+        J::Item: Borrow<command::DescriptorSetOffset>,
+    {
+        // Do nothing
+    }
+
+    unsafe fn dispatch(&mut self, _: hal::WorkGroupCount) {
+        unimplemented!("{}", NOT_SUPPORTED_MESSAGE)
+    }
+
+    unsafe fn dispatch_indirect(&mut self, _: &Buffer, _: hal::buffer::Offset) {
+        unimplemented!("{}", NOT_SUPPORTED_MESSAGE)
+    }
+
+    unsafe fn copy_buffer<T>(&mut self, _: &Buffer, _: &Buffer, _: T)
+    where
+        T: IntoIterator,
+        T::Item: Borrow<command::BufferCopy>,
+    {
+        unimplemented!("{}", NOT_SUPPORTED_MESSAGE)
+    }
+
+    unsafe fn copy_image<T>(
+        &mut self,
+        _: &Image,
+        _: hal::image::Layout,
+        _: &Image,
+        _: hal::image::Layout,
+        _: T,
+    ) where
+        T: IntoIterator,
+        T::Item: Borrow<command::ImageCopy>,
+    {
+        unimplemented!("{}", NOT_SUPPORTED_MESSAGE)
+    }
+
+    unsafe fn copy_buffer_to_image<T>(&mut self, _: &Buffer, _: &Image, _: hal::image::Layout, _: T)
+    where
+        T: IntoIterator,
+        T::Item: Borrow<command::BufferImageCopy>,
+    {
+    }
+
+    unsafe fn copy_image_to_buffer<T>(&mut self, _: &Image, _: hal::image::Layout, _: &Buffer, _: T)
+    where
+        T: IntoIterator,
+        T::Item: Borrow<command::BufferImageCopy>,
+    {
+        unimplemented!("{}", NOT_SUPPORTED_MESSAGE)
+    }
+
+    unsafe fn draw(&mut self, _: Range<hal::VertexCount>, _: Range<hal::InstanceCount>) {}
+
+    unsafe fn draw_indexed(
+        &mut self,
+        _: Range<hal::IndexCount>,
+        _: hal::VertexOffset,
+        _: Range<hal::InstanceCount>,
+    ) {
+    }
+
+    unsafe fn draw_indirect(
+        &mut self,
+        _: &Buffer,
+        _: hal::buffer::Offset,
+        _: hal::DrawCount,
+        _: u32,
+    ) {
+    }
+
+    unsafe fn draw_indexed_indirect(
+        &mut self,
+        _: &Buffer,
+        _: hal::buffer::Offset,
+        _: hal::DrawCount,
+        _: u32,
+    ) {
+    }
+
+    unsafe fn draw_indirect_count(
+        &mut self,
+        _: &Buffer,
+        _: hal::buffer::Offset,
+        _: &Buffer,
+        _: hal::buffer::Offset,
+        _: u32,
+        _: u32,
+    ) {
+    }
+
+    unsafe fn draw_indexed_indirect_count(
+        &mut self,
+        _: &Buffer,
+        _: hal::buffer::Offset,
+        _: &Buffer,
+        _: hal::buffer::Offset,
+        _: u32,
+        _: u32,
+    ) {
+    }
+
+    unsafe fn draw_mesh_tasks(&mut self, _: u32, _: u32) {
+        unimplemented!("{}", NOT_SUPPORTED_MESSAGE)
+    }
+
+    unsafe fn draw_mesh_tasks_indirect(
+        &mut self,
+        _: &Buffer,
+        _: hal::buffer::Offset,
+        _: hal::DrawCount,
+        _: u32,
+    ) {
+        unimplemented!("{}", NOT_SUPPORTED_MESSAGE)
+    }
+
+    unsafe fn draw_mesh_tasks_indirect_count(
+        &mut self,
+        _: &Buffer,
+        _: hal::buffer::Offset,
+        _: &Buffer,
+        _: hal::buffer::Offset,
+        _: u32,
+        _: u32,
+    ) {
+        unimplemented!("{}", NOT_SUPPORTED_MESSAGE)
+    }
+
+    unsafe fn set_event(&mut self, _: &(), _: pso::PipelineStage) {
+        unimplemented!("{}", NOT_SUPPORTED_MESSAGE)
+    }
+
+    unsafe fn reset_event(&mut self, _: &(), _: pso::PipelineStage) {
+        unimplemented!("{}", NOT_SUPPORTED_MESSAGE)
+    }
+
+    unsafe fn wait_events<'a, I, J>(&mut self, _: I, _: Range<pso::PipelineStage>, _: J)
+    where
+        I: IntoIterator,
+        I::Item: Borrow<()>,
+        J: IntoIterator,
+        J::Item: Borrow<hal::memory::Barrier<'a, Backend>>,
+    {
+        unimplemented!("{}", NOT_SUPPORTED_MESSAGE)
+    }
+
+    unsafe fn begin_query(&mut self, _: query::Query<Backend>, _: query::ControlFlags) {
+        unimplemented!("{}", NOT_SUPPORTED_MESSAGE)
+    }
+
+    unsafe fn end_query(&mut self, _: query::Query<Backend>) {
+        unimplemented!("{}", NOT_SUPPORTED_MESSAGE)
+    }
+
+    unsafe fn reset_query_pool(&mut self, _: &(), _: Range<query::Id>) {
+        unimplemented!("{}", NOT_SUPPORTED_MESSAGE)
+    }
+
+    unsafe fn copy_query_pool_results(
+        &mut self,
+        _: &(),
+        _: Range<query::Id>,
+        _: &Buffer,
+        _: hal::buffer::Offset,
+        _: hal::buffer::Offset,
+        _: query::ResultFlags,
+    ) {
+        unimplemented!("{}", NOT_SUPPORTED_MESSAGE)
+    }
+
+    unsafe fn write_timestamp(&mut self, _: pso::PipelineStage, _: query::Query<Backend>) {
+        unimplemented!("{}", NOT_SUPPORTED_MESSAGE)
+    }
+
+    unsafe fn push_graphics_constants(
+        &mut self,
+        _: &(),
+        _: pso::ShaderStageFlags,
+        _: u32,
+        _: &[u32],
+    ) {
+        unimplemented!("{}", NOT_SUPPORTED_MESSAGE)
+    }
+
+    unsafe fn push_compute_constants(&mut self, _: &(), _: u32, _: &[u32]) {
+        unimplemented!("{}", NOT_SUPPORTED_MESSAGE)
+    }
+
+    unsafe fn execute_commands<'a, T, I>(&mut self, _: I)
+    where
+        T: 'a + Borrow<CommandBuffer>,
+        I: IntoIterator<Item = &'a T>,
+    {
+        unimplemented!("{}", NOT_SUPPORTED_MESSAGE)
+    }
+
+    unsafe fn insert_debug_marker(&mut self, _: &str, _: u32) {
+        unimplemented!("{}", NOT_SUPPORTED_MESSAGE)
+    }
+    unsafe fn begin_debug_marker(&mut self, _: &str, _: u32) {
+        unimplemented!("{}", NOT_SUPPORTED_MESSAGE)
+    }
+    unsafe fn end_debug_marker(&mut self) {
+        unimplemented!("{}", NOT_SUPPORTED_MESSAGE)
+    }
+}
+
+/// Dummy surface.
+#[derive(Debug)]
+pub struct Surface;
+impl window::Surface<Backend> for Surface {
+    fn supports_queue_family(&self, _: &QueueFamily) -> bool {
+        true
+    }
+
+    fn capabilities(&self, _: &PhysicalDevice) -> window::SurfaceCapabilities {
+        let extents = {
+            let min_extent = window::Extent2D {
+                width: 0,
+                height: 0,
+            };
+            let max_extent = window::Extent2D {
+                width: 8192,
+                height: 4096,
+            };
+            min_extent..=max_extent
+        };
+        let usage = hal::image::Usage::COLOR_ATTACHMENT;
+        let present_modes = window::PresentMode::all();
+        let composite_alpha_modes = window::CompositeAlphaMode::OPAQUE;
+        window::SurfaceCapabilities {
+            image_count: 1..=1,
+            current_extent: None,
+            extents,
+            max_image_layers: 1,
+            usage,
+            present_modes,
+            composite_alpha_modes,
+        }
+    }
+
+    fn supported_formats(&self, _: &PhysicalDevice) -> Option<Vec<format::Format>> {
+        None
+    }
+}
+
+#[derive(Debug)]
+pub struct SwapchainImage;
+impl Borrow<Image> for SwapchainImage {
+    fn borrow(&self) -> &Image {
+        unimplemented!()
+    }
+}
+impl Borrow<()> for SwapchainImage {
+    fn borrow(&self) -> &() {
+        unimplemented!()
+    }
+}
+
+impl window::PresentationSurface<Backend> for Surface {
+    type SwapchainImage = SwapchainImage;
+
+    unsafe fn configure_swapchain(
+        &mut self,
+        _: &Device,
+        _: window::SwapchainConfig,
+    ) -> Result<(), window::CreationError> {
+        Ok(())
+    }
+
+    unsafe fn unconfigure_swapchain(&mut self, _: &Device) {}
+
+    unsafe fn acquire_image(
+        &mut self,
+        _: u64,
+    ) -> Result<(SwapchainImage, Option<window::Suboptimal>), window::AcquireError> {
+        Ok((SwapchainImage, None))
+    }
+}
+
+#[derive(Debug)]
+pub struct Instance;
+
+impl hal::Instance<Backend> for Instance {
+    fn create(name: &str, version: u32) -> Result<Self, hal::UnsupportedBackend> {
+        debug!(
+            "Creating empty backend instance with name '{}' and version {}",
+            name, version
+        );
+        Ok(Instance)
+    }
+
+    fn enumerate_adapters(&self) -> Vec<adapter::Adapter<Backend>> {
+        // TODO: provide more mock adapters, with various qualities
+        let info = adapter::AdapterInfo {
+            name: "Mock Device".to_string(),
+            vendor: 0,
+            device: 1234,
+            device_type: adapter::DeviceType::Other,
+        };
+        let adapter = adapter::Adapter {
+            info,
+            physical_device: PhysicalDevice,
+            // TODO: multiple queue families
+            queue_families: vec![QueueFamily],
+        };
+        vec![adapter]
+    }
+
+    unsafe fn create_surface(
+        &self,
+        raw_window_handle: &impl raw_window_handle::HasRawWindowHandle,
+    ) -> Result<Surface, hal::window::InitError> {
+        // TODO: maybe check somehow that the given handle is valid?
+        let _handle = raw_window_handle.raw_window_handle();
+        Ok(Surface)
+    }
+
+    unsafe fn destroy_surface(&self, _surface: Surface) {}
+}
diff --git a/third_party/rust/gfx-backend-empty/src/memory.rs b/third_party/rust/gfx-backend-empty/src/memory.rs
new file mode 100644
index 0000000000..c7d6866703
--- /dev/null
+++ b/third_party/rust/gfx-backend-empty/src/memory.rs
@@ -0,0 +1,58 @@
+use hal::{
+    device::{AllocationError, MapError, OutOfMemory},
+    memory::Segment,
+    MemoryTypeId,
+};
+use std::cell::UnsafeCell;
+use std::convert::TryInto;
+
+/// A memory allocation.
+#[derive(Debug)]
+pub struct Memory {
+    /// The type of memory this block was allocated from.
+    memory_type: MemoryTypeId,
+    /// Size of the allocated memory block.
+    size: u64,
+    /// The backing memory allocation.
+    data: UnsafeCell<Box<[u8]>>,
+}
+
+impl Memory {
+    pub fn allocate(memory_type: MemoryTypeId, size: u64) -> Result<Self, AllocationError> {
+        assert_eq!(memory_type.0, 0, "We only support one memory type");
+
+        // Allocate a buffer in RAM
+        let data = {
+            let size = size
+                .try_into()
+                // If we're on 32-bit and the given size is greater than 2^32,
+                // we certainly can't allocate it.
+                .map_err(|_| AllocationError::OutOfMemory(OutOfMemory::Host))?;
+
+            vec![0u8; size].into_boxed_slice()
+        };
+
+        let memory = Memory {
+            memory_type,
+            size,
+            data: UnsafeCell::new(data),
+        };
+        Ok(memory)
+    }
+
+    pub fn map(&self, segment: Segment) -> Result<*mut u8, MapError> {
+        if segment.offset >= self.size {
+            return Err(MapError::OutOfBounds);
+        }
+        if let Some(size) = segment.size {
+            if segment.offset + size > self.size {
+                return Err(MapError::OutOfBounds);
+            }
+        }
+
+        let data = unsafe { &mut *self.data.get() };
+        Ok(data.as_mut_ptr())
+    }
+}
+
+unsafe impl Sync for Memory {}