summaryrefslogtreecommitdiffstats
path: root/third_party/rust/wgpu-hal/src/empty.rs
diff options
context:
space:
mode:
authorDaniel Baumann <daniel.baumann@progress-linux.org>2024-04-07 09:22:09 +0000
committerDaniel Baumann <daniel.baumann@progress-linux.org>2024-04-07 09:22:09 +0000
commit43a97878ce14b72f0981164f87f2e35e14151312 (patch)
tree620249daf56c0258faa40cbdcf9cfba06de2a846 /third_party/rust/wgpu-hal/src/empty.rs
parentInitial commit. (diff)
downloadfirefox-upstream.tar.xz
firefox-upstream.zip
Adding upstream version 110.0.1.upstream/110.0.1upstream
Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>
Diffstat (limited to 'third_party/rust/wgpu-hal/src/empty.rs')
-rw-r--r--third_party/rust/wgpu-hal/src/empty.rs401
1 files changed, 401 insertions, 0 deletions
diff --git a/third_party/rust/wgpu-hal/src/empty.rs b/third_party/rust/wgpu-hal/src/empty.rs
new file mode 100644
index 0000000000..30e8156e84
--- /dev/null
+++ b/third_party/rust/wgpu-hal/src/empty.rs
@@ -0,0 +1,401 @@
+#![allow(unused_variables)]
+
+use std::ops::Range;
+
+#[derive(Clone)]
+pub struct Api;
+pub struct Context;
+#[derive(Debug)]
+pub struct Encoder;
+#[derive(Debug)]
+pub struct Resource;
+
+type DeviceResult<T> = Result<T, crate::DeviceError>;
+
+impl crate::Api for Api {
+ type Instance = Context;
+ type Surface = Context;
+ type Adapter = Context;
+ type Device = Context;
+
+ type Queue = Context;
+ type CommandEncoder = Encoder;
+ type CommandBuffer = Resource;
+
+ type Buffer = Resource;
+ type Texture = Resource;
+ type SurfaceTexture = Resource;
+ type TextureView = Resource;
+ type Sampler = Resource;
+ type QuerySet = Resource;
+ type Fence = Resource;
+
+ type BindGroupLayout = Resource;
+ type BindGroup = Resource;
+ type PipelineLayout = Resource;
+ type ShaderModule = Resource;
+ type RenderPipeline = Resource;
+ type ComputePipeline = Resource;
+}
+
+impl crate::Instance<Api> for Context {
+ unsafe fn init(desc: &crate::InstanceDescriptor) -> Result<Self, crate::InstanceError> {
+ Ok(Context)
+ }
+ unsafe fn create_surface(
+ &self,
+ _display_handle: raw_window_handle::RawDisplayHandle,
+ _window_handle: raw_window_handle::RawWindowHandle,
+ ) -> Result<Context, crate::InstanceError> {
+ Ok(Context)
+ }
+ unsafe fn destroy_surface(&self, surface: Context) {}
+ unsafe fn enumerate_adapters(&self) -> Vec<crate::ExposedAdapter<Api>> {
+ Vec::new()
+ }
+}
+
+impl crate::Surface<Api> for Context {
+ unsafe fn configure(
+ &mut self,
+ device: &Context,
+ config: &crate::SurfaceConfiguration,
+ ) -> Result<(), crate::SurfaceError> {
+ Ok(())
+ }
+
+ unsafe fn unconfigure(&mut self, device: &Context) {}
+
+ unsafe fn acquire_texture(
+ &mut self,
+ timeout: Option<std::time::Duration>,
+ ) -> Result<Option<crate::AcquiredSurfaceTexture<Api>>, crate::SurfaceError> {
+ Ok(None)
+ }
+ unsafe fn discard_texture(&mut self, texture: Resource) {}
+}
+
+impl crate::Adapter<Api> for Context {
+ unsafe fn open(
+ &self,
+ features: wgt::Features,
+ _limits: &wgt::Limits,
+ ) -> DeviceResult<crate::OpenDevice<Api>> {
+ Err(crate::DeviceError::Lost)
+ }
+ unsafe fn texture_format_capabilities(
+ &self,
+ format: wgt::TextureFormat,
+ ) -> crate::TextureFormatCapabilities {
+ crate::TextureFormatCapabilities::empty()
+ }
+
+ unsafe fn surface_capabilities(&self, surface: &Context) -> Option<crate::SurfaceCapabilities> {
+ None
+ }
+
+ unsafe fn get_presentation_timestamp(&self) -> wgt::PresentationTimestamp {
+ wgt::PresentationTimestamp::INVALID_TIMESTAMP
+ }
+}
+
+impl crate::Queue<Api> for Context {
+ unsafe fn submit(
+ &mut self,
+ command_buffers: &[&Resource],
+ signal_fence: Option<(&mut Resource, crate::FenceValue)>,
+ ) -> DeviceResult<()> {
+ Ok(())
+ }
+ unsafe fn present(
+ &mut self,
+ surface: &mut Context,
+ texture: Resource,
+ ) -> Result<(), crate::SurfaceError> {
+ Ok(())
+ }
+
+ unsafe fn get_timestamp_period(&self) -> f32 {
+ 1.0
+ }
+}
+
+impl crate::Device<Api> for Context {
+ unsafe fn exit(self, queue: Context) {}
+ unsafe fn create_buffer(&self, desc: &crate::BufferDescriptor) -> DeviceResult<Resource> {
+ Ok(Resource)
+ }
+ unsafe fn destroy_buffer(&self, buffer: Resource) {}
+ unsafe fn map_buffer(
+ &self,
+ buffer: &Resource,
+ range: crate::MemoryRange,
+ ) -> DeviceResult<crate::BufferMapping> {
+ Err(crate::DeviceError::Lost)
+ }
+ unsafe fn unmap_buffer(&self, buffer: &Resource) -> DeviceResult<()> {
+ Ok(())
+ }
+ unsafe fn flush_mapped_ranges<I>(&self, buffer: &Resource, ranges: I) {}
+ unsafe fn invalidate_mapped_ranges<I>(&self, buffer: &Resource, ranges: I) {}
+
+ unsafe fn create_texture(&self, desc: &crate::TextureDescriptor) -> DeviceResult<Resource> {
+ Ok(Resource)
+ }
+ unsafe fn destroy_texture(&self, texture: Resource) {}
+ unsafe fn create_texture_view(
+ &self,
+ texture: &Resource,
+ desc: &crate::TextureViewDescriptor,
+ ) -> DeviceResult<Resource> {
+ Ok(Resource)
+ }
+ unsafe fn destroy_texture_view(&self, view: Resource) {}
+ unsafe fn create_sampler(&self, desc: &crate::SamplerDescriptor) -> DeviceResult<Resource> {
+ Ok(Resource)
+ }
+ unsafe fn destroy_sampler(&self, sampler: Resource) {}
+
+ unsafe fn create_command_encoder(
+ &self,
+ desc: &crate::CommandEncoderDescriptor<Api>,
+ ) -> DeviceResult<Encoder> {
+ Ok(Encoder)
+ }
+ unsafe fn destroy_command_encoder(&self, encoder: Encoder) {}
+
+ unsafe fn create_bind_group_layout(
+ &self,
+ desc: &crate::BindGroupLayoutDescriptor,
+ ) -> DeviceResult<Resource> {
+ Ok(Resource)
+ }
+ unsafe fn destroy_bind_group_layout(&self, bg_layout: Resource) {}
+ unsafe fn create_pipeline_layout(
+ &self,
+ desc: &crate::PipelineLayoutDescriptor<Api>,
+ ) -> DeviceResult<Resource> {
+ Ok(Resource)
+ }
+ unsafe fn destroy_pipeline_layout(&self, pipeline_layout: Resource) {}
+ unsafe fn create_bind_group(
+ &self,
+ desc: &crate::BindGroupDescriptor<Api>,
+ ) -> DeviceResult<Resource> {
+ Ok(Resource)
+ }
+ unsafe fn destroy_bind_group(&self, group: Resource) {}
+
+ unsafe fn create_shader_module(
+ &self,
+ desc: &crate::ShaderModuleDescriptor,
+ shader: crate::ShaderInput,
+ ) -> Result<Resource, crate::ShaderError> {
+ Ok(Resource)
+ }
+ unsafe fn destroy_shader_module(&self, module: Resource) {}
+ unsafe fn create_render_pipeline(
+ &self,
+ desc: &crate::RenderPipelineDescriptor<Api>,
+ ) -> Result<Resource, crate::PipelineError> {
+ Ok(Resource)
+ }
+ unsafe fn destroy_render_pipeline(&self, pipeline: Resource) {}
+ unsafe fn create_compute_pipeline(
+ &self,
+ desc: &crate::ComputePipelineDescriptor<Api>,
+ ) -> Result<Resource, crate::PipelineError> {
+ Ok(Resource)
+ }
+ unsafe fn destroy_compute_pipeline(&self, pipeline: Resource) {}
+
+ unsafe fn create_query_set(
+ &self,
+ desc: &wgt::QuerySetDescriptor<crate::Label>,
+ ) -> DeviceResult<Resource> {
+ Ok(Resource)
+ }
+ unsafe fn destroy_query_set(&self, set: Resource) {}
+ unsafe fn create_fence(&self) -> DeviceResult<Resource> {
+ Ok(Resource)
+ }
+ unsafe fn destroy_fence(&self, fence: Resource) {}
+ unsafe fn get_fence_value(&self, fence: &Resource) -> DeviceResult<crate::FenceValue> {
+ Ok(0)
+ }
+ unsafe fn wait(
+ &self,
+ fence: &Resource,
+ value: crate::FenceValue,
+ timeout_ms: u32,
+ ) -> DeviceResult<bool> {
+ Ok(true)
+ }
+
+ unsafe fn start_capture(&self) -> bool {
+ false
+ }
+ unsafe fn stop_capture(&self) {}
+}
+
+impl crate::CommandEncoder<Api> for Encoder {
+ unsafe fn begin_encoding(&mut self, label: crate::Label) -> DeviceResult<()> {
+ Ok(())
+ }
+ unsafe fn discard_encoding(&mut self) {}
+ unsafe fn end_encoding(&mut self) -> DeviceResult<Resource> {
+ Ok(Resource)
+ }
+ unsafe fn reset_all<I>(&mut self, command_buffers: I) {}
+
+ unsafe fn transition_buffers<'a, T>(&mut self, barriers: T)
+ where
+ T: Iterator<Item = crate::BufferBarrier<'a, Api>>,
+ {
+ }
+
+ unsafe fn transition_textures<'a, T>(&mut self, barriers: T)
+ where
+ T: Iterator<Item = crate::TextureBarrier<'a, Api>>,
+ {
+ }
+
+ unsafe fn clear_buffer(&mut self, buffer: &Resource, range: crate::MemoryRange) {}
+
+ unsafe fn copy_buffer_to_buffer<T>(&mut self, src: &Resource, dst: &Resource, regions: T) {}
+
+ unsafe fn copy_texture_to_texture<T>(
+ &mut self,
+ src: &Resource,
+ src_usage: crate::TextureUses,
+ dst: &Resource,
+ regions: T,
+ ) {
+ }
+
+ unsafe fn copy_buffer_to_texture<T>(&mut self, src: &Resource, dst: &Resource, regions: T) {}
+
+ unsafe fn copy_texture_to_buffer<T>(
+ &mut self,
+ src: &Resource,
+ src_usage: crate::TextureUses,
+ dst: &Resource,
+ regions: T,
+ ) {
+ }
+
+ unsafe fn begin_query(&mut self, set: &Resource, index: u32) {}
+ unsafe fn end_query(&mut self, set: &Resource, index: u32) {}
+ unsafe fn write_timestamp(&mut self, set: &Resource, index: u32) {}
+ unsafe fn reset_queries(&mut self, set: &Resource, range: Range<u32>) {}
+ unsafe fn copy_query_results(
+ &mut self,
+ set: &Resource,
+ range: Range<u32>,
+ buffer: &Resource,
+ offset: wgt::BufferAddress,
+ stride: wgt::BufferSize,
+ ) {
+ }
+
+ // render
+
+ unsafe fn begin_render_pass(&mut self, desc: &crate::RenderPassDescriptor<Api>) {}
+ unsafe fn end_render_pass(&mut self) {}
+
+ unsafe fn set_bind_group(
+ &mut self,
+ layout: &Resource,
+ index: u32,
+ group: &Resource,
+ dynamic_offsets: &[wgt::DynamicOffset],
+ ) {
+ }
+ unsafe fn set_push_constants(
+ &mut self,
+ layout: &Resource,
+ stages: wgt::ShaderStages,
+ offset: u32,
+ data: &[u32],
+ ) {
+ }
+
+ unsafe fn insert_debug_marker(&mut self, label: &str) {}
+ unsafe fn begin_debug_marker(&mut self, group_label: &str) {}
+ unsafe fn end_debug_marker(&mut self) {}
+
+ unsafe fn set_render_pipeline(&mut self, pipeline: &Resource) {}
+
+ unsafe fn set_index_buffer<'a>(
+ &mut self,
+ binding: crate::BufferBinding<'a, Api>,
+ format: wgt::IndexFormat,
+ ) {
+ }
+ unsafe fn set_vertex_buffer<'a>(&mut self, index: u32, binding: crate::BufferBinding<'a, Api>) {
+ }
+ unsafe fn set_viewport(&mut self, rect: &crate::Rect<f32>, depth_range: Range<f32>) {}
+ unsafe fn set_scissor_rect(&mut self, rect: &crate::Rect<u32>) {}
+ unsafe fn set_stencil_reference(&mut self, value: u32) {}
+ unsafe fn set_blend_constants(&mut self, color: &[f32; 4]) {}
+
+ unsafe fn draw(
+ &mut self,
+ start_vertex: u32,
+ vertex_count: u32,
+ start_instance: u32,
+ instance_count: u32,
+ ) {
+ }
+ unsafe fn draw_indexed(
+ &mut self,
+ start_index: u32,
+ index_count: u32,
+ base_vertex: i32,
+ start_instance: u32,
+ instance_count: u32,
+ ) {
+ }
+ unsafe fn draw_indirect(
+ &mut self,
+ buffer: &Resource,
+ offset: wgt::BufferAddress,
+ draw_count: u32,
+ ) {
+ }
+ unsafe fn draw_indexed_indirect(
+ &mut self,
+ buffer: &Resource,
+ offset: wgt::BufferAddress,
+ draw_count: u32,
+ ) {
+ }
+ unsafe fn draw_indirect_count(
+ &mut self,
+ buffer: &Resource,
+ offset: wgt::BufferAddress,
+ count_buffer: &Resource,
+ count_offset: wgt::BufferAddress,
+ max_count: u32,
+ ) {
+ }
+ unsafe fn draw_indexed_indirect_count(
+ &mut self,
+ buffer: &Resource,
+ offset: wgt::BufferAddress,
+ count_buffer: &Resource,
+ count_offset: wgt::BufferAddress,
+ max_count: u32,
+ ) {
+ }
+
+ // compute
+
+ unsafe fn begin_compute_pass(&mut self, desc: &crate::ComputePassDescriptor) {}
+ unsafe fn end_compute_pass(&mut self) {}
+
+ unsafe fn set_compute_pipeline(&mut self, pipeline: &Resource) {}
+
+ unsafe fn dispatch(&mut self, count: [u32; 3]) {}
+ unsafe fn dispatch_indirect(&mut self, buffer: &Resource, offset: wgt::BufferAddress) {}
+}