hal/gles: creation of buffers, textures, view, and samplers

wgpu-hal/src/gles/conv.rs

@@ -1,4 +1,4 @@
-impl super::PrivateCapability {
+impl super::AdapterShared {
     pub(super) fn describe_texture_format(
         &self,
         format: wgt::TextureFormat,
@@ -220,3 +220,49 @@ impl super::PrivateCapability {
         }
     }
 }
+
+pub fn map_filter_modes(
+    min: wgt::FilterMode,
+    mag: wgt::FilterMode,
+    mip: wgt::FilterMode,
+) -> (u32, u32) {
+    use wgt::FilterMode as Fm;
+
+    let mag_filter = match mag {
+        Fm::Nearest => glow::NEAREST,
+        Fm::Linear => glow::LINEAR,
+    };
+
+    let min_filter = match (min, mip) {
+        (Fm::Nearest, Fm::Nearest) => glow::NEAREST_MIPMAP_NEAREST,
+        (Fm::Nearest, Fm::Linear) => glow::NEAREST_MIPMAP_LINEAR,
+        (Fm::Linear, Fm::Nearest) => glow::LINEAR_MIPMAP_NEAREST,
+        (Fm::Linear, Fm::Linear) => glow::LINEAR_MIPMAP_LINEAR,
+    };
+
+    (min_filter, mag_filter)
+}
+
+pub fn map_address_mode(mode: wgt::AddressMode) -> u32 {
+    match mode {
+        wgt::AddressMode::Repeat => glow::REPEAT,
+        wgt::AddressMode::MirrorRepeat => glow::MIRRORED_REPEAT,
+        wgt::AddressMode::ClampToEdge => glow::CLAMP_TO_EDGE,
+        wgt::AddressMode::ClampToBorder => glow::CLAMP_TO_BORDER,
+        //wgt::AddressMode::MirrorClamp => glow::MIRROR_CLAMP_TO_EDGE,
+    }
+}
+
+pub fn map_compare_func(fun: wgt::CompareFunction) -> u32 {
+    use wgt::CompareFunction as Cf;
+    match fun {
+        Cf::Never => glow::NEVER,
+        Cf::Less => glow::LESS,
+        Cf::LessEqual => glow::LEQUAL,
+        Cf::Equal => glow::EQUAL,
+        Cf::GreaterEqual => glow::GEQUAL,
+        Cf::Greater => glow::GREATER,
+        Cf::NotEqual => glow::NOTEQUAL,
+        Cf::Always => glow::ALWAYS,
+    }
+}

wgpu-hal/src/gles/device.rs

@@ -0,0 +1,331 @@
+use super::{DeviceResult, Encoder, Resource}; //TEMP
+use glow::HasContext;
+use std::{convert::TryInto, ptr::NonNull};
+
+impl crate::Device<super::Api> for super::Device {
+    unsafe fn exit(self) {
+        let gl = &self.shared.context;
+        gl.delete_vertex_array(self.main_vao);
+    }
+
+    unsafe fn create_buffer(
+        &self,
+        desc: &crate::BufferDescriptor,
+    ) -> Result<super::Buffer, crate::DeviceError> {
+        let gl = &self.shared.context;
+
+        let target = if desc.usage.contains(crate::BufferUse::INDEX) {
+            glow::ELEMENT_ARRAY_BUFFER
+        } else {
+            glow::ARRAY_BUFFER
+        };
+        let map_coherent = false;
+        let map_flags = glow::MAP_PERSISTENT_BIT
+            | if map_coherent {
+                glow::MAP_COHERENT_BIT
+            } else {
+                0
+            };
+        let mut storage_flags = 0;
+        if desc.usage.contains(crate::BufferUse::MAP_READ) {
+            storage_flags |= map_flags | glow::MAP_READ_BIT;
+        }
+        if desc.usage.contains(crate::BufferUse::MAP_WRITE) {
+            storage_flags |= map_flags | glow::MAP_WRITE_BIT;
+        }
+
+        let raw = gl.create_buffer().unwrap();
+        gl.bind_buffer(target, Some(raw));
+        let raw_size = desc
+            .size
+            .try_into()
+            .map_err(|_| crate::DeviceError::OutOfMemory)?;
+        gl.buffer_storage(target, raw_size, None, storage_flags);
+        gl.bind_buffer(target, None);
+
+        Ok(super::Buffer {
+            raw,
+            target,
+            map_flags,
+        })
+    }
+    unsafe fn destroy_buffer(&self, buffer: super::Buffer) {
+        let gl = &self.shared.context;
+        gl.delete_buffer(buffer.raw);
+    }
+
+    unsafe fn map_buffer(
+        &self,
+        buffer: &super::Buffer,
+        range: crate::MemoryRange,
+    ) -> Result<crate::BufferMapping, crate::DeviceError> {
+        let gl = &self.shared.context;
+
+        gl.bind_buffer(buffer.target, Some(buffer.raw));
+        let ptr = gl.map_buffer_range(
+            buffer.target,
+            range.start as i32,
+            (range.end - range.start) as i32,
+            buffer.map_flags,
+        );
+        gl.bind_buffer(buffer.target, None);
+
+        Ok(crate::BufferMapping {
+            ptr: NonNull::new(ptr).ok_or(crate::DeviceError::Lost)?,
+            is_coherent: buffer.map_flags & glow::MAP_COHERENT_BIT != 0,
+        })
+    }
+    unsafe fn unmap_buffer(&self, buffer: &super::Buffer) -> DeviceResult<()> {
+        let gl = &self.shared.context;
+        gl.bind_buffer(buffer.target, Some(buffer.raw));
+        gl.unmap_buffer(buffer.target);
+        gl.bind_buffer(buffer.target, None);
+        Ok(())
+    }
+    unsafe fn flush_mapped_ranges<I>(&self, buffer: &super::Buffer, ranges: I)
+    where
+        I: Iterator<Item = crate::MemoryRange>,
+    {
+        let gl = &self.shared.context;
+        for range in ranges {
+            gl.flush_mapped_buffer_range(
+                buffer.target,
+                range.start as i32,
+                (range.end - range.start) as i32,
+            );
+        }
+    }
+    unsafe fn invalidate_mapped_ranges<I>(&self, buffer: &super::Buffer, ranges: I)
+    where
+        I: Iterator<Item = crate::MemoryRange>,
+    {
+        let gl = &self.shared.context;
+        for range in ranges {
+            gl.invalidate_buffer_sub_data(
+                buffer.target,
+                range.start as i32,
+                (range.end - range.start) as i32,
+            );
+        }
+    }
+
+    unsafe fn create_texture(
+        &self,
+        desc: &crate::TextureDescriptor,
+    ) -> Result<super::Texture, crate::DeviceError> {
+        let gl = &self.shared.context;
+
+        let render_usage = crate::TextureUse::COLOR_TARGET
+            | crate::TextureUse::DEPTH_STENCIL_WRITE
+            | crate::TextureUse::DEPTH_STENCIL_READ;
+        let format_desc = self.shared.describe_texture_format(desc.format);
+        Ok(
+            if render_usage.contains(desc.usage)
+                && desc.dimension == wgt::TextureDimension::D2
+                && desc.size.depth_or_array_layers == 1
+            {
+                let raw = gl.create_renderbuffer().unwrap();
+                gl.bind_renderbuffer(glow::RENDERBUFFER, Some(raw));
+                if desc.sample_count > 1 {
+                    gl.renderbuffer_storage_multisample(
+                        glow::RENDERBUFFER,
+                        desc.sample_count as i32,
+                        format_desc.tex_internal,
+                        desc.size.width as i32,
+                        desc.size.height as i32,
+                    );
+                } else {
+                    gl.renderbuffer_storage(
+                        glow::RENDERBUFFER,
+                        format_desc.tex_internal,
+                        desc.size.width as i32,
+                        desc.size.height as i32,
+                    );
+                }
+                super::Texture::Renderbuffer {
+                    raw,
+                    aspects: desc.format.into(),
+                }
+            } else {
+                let raw = gl.create_texture().unwrap();
+                let target = match desc.dimension {
+                    wgt::TextureDimension::D1 | wgt::TextureDimension::D2 => {
+                        if desc.sample_count > 1 {
+                            let target = glow::TEXTURE_2D;
+                            gl.bind_texture(target, Some(raw));
+                            // https://github.com/grovesNL/glow/issues/169
+                            //gl.tex_storage_2d_multisample(target, desc.sample_count as i32, format_desc.tex_internal, desc.size.width as i32, desc.size.height as i32, true);
+                            log::error!("TODO: support `tex_storage_2d_multisample` (https://github.com/grovesNL/glow/issues/169)");
+                            return Err(crate::DeviceError::Lost);
+                        } else if desc.size.depth_or_array_layers > 1 {
+                            let target = glow::TEXTURE_2D_ARRAY;
+                            gl.bind_texture(target, Some(raw));
+                            gl.tex_storage_3d(
+                                target,
+                                desc.mip_level_count as i32,
+                                format_desc.tex_internal,
+                                desc.size.width as i32,
+                                desc.size.height as i32,
+                                desc.size.depth_or_array_layers as i32,
+                            );
+                            target
+                        } else {
+                            let target = glow::TEXTURE_2D;
+                            gl.bind_texture(target, Some(raw));
+                            gl.tex_storage_2d(
+                                target,
+                                desc.mip_level_count as i32,
+                                format_desc.tex_internal,
+                                desc.size.width as i32,
+                                desc.size.height as i32,
+                            );
+                            target
+                        }
+                    }
+                    wgt::TextureDimension::D3 => {
+                        let target = glow::TEXTURE_3D;
+                        gl.bind_texture(target, Some(raw));
+                        gl.tex_storage_3d(
+                            target,
+                            desc.mip_level_count as i32,
+                            format_desc.tex_internal,
+                            desc.size.width as i32,
+                            desc.size.height as i32,
+                            desc.size.depth_or_array_layers as i32,
+                        );
+                        target
+                    }
+                };
+                super::Texture::Texture { raw, target }
+            },
+        )
+    }
+    unsafe fn destroy_texture(&self, texture: super::Texture) {
+        let gl = &self.shared.context;
+        match texture {
+            super::Texture::Renderbuffer { raw, .. } => {
+                gl.delete_renderbuffer(raw);
+            }
+            super::Texture::Texture { raw, target } => {
+                gl.delete_texture(raw);
+            }
+        }
+    }
+
+    unsafe fn create_texture_view(
+        &self,
+        texture: &super::Texture,
+        desc: &crate::TextureViewDescriptor,
+    ) -> Result<super::TextureView, crate::DeviceError> {
+        Ok(match *texture {
+            super::Texture::Renderbuffer { raw, aspects } => super::TextureView::Renderbuffer {
+                raw,
+                aspects: aspects & crate::FormatAspect::from(desc.range.aspect),
+            },
+            super::Texture::Texture { raw, target } => super::TextureView::Texture {
+                raw,
+                target,
+                range: desc.range.clone(),
+            },
+        })
+    }
+    unsafe fn destroy_texture_view(&self, view: super::TextureView) {}
+
+    unsafe fn create_sampler(
+        &self,
+        desc: &crate::SamplerDescriptor,
+    ) -> Result<super::Sampler, crate::DeviceError> {
+        use super::Sampled;
+        let gl = &self.shared.context;
+
+        let raw = gl.create_sampler().unwrap();
+        super::SamplerBinding(raw).configure_sampling(gl, desc);
+
+        Ok(super::Sampler { raw })
+    }
+    unsafe fn destroy_sampler(&self, sampler: super::Sampler) {
+        let gl = &self.shared.context;
+        gl.delete_sampler(sampler.raw);
+    }
+
+    unsafe fn create_command_encoder(
+        &self,
+        desc: &crate::CommandEncoderDescriptor<super::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<super::Api>,
+    ) -> DeviceResult<Resource> {
+        Ok(Resource)
+    }
+    unsafe fn destroy_pipeline_layout(&self, pipeline_layout: Resource) {}
+    unsafe fn create_bind_group(
+        &self,
+        desc: &crate::BindGroupDescriptor<super::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<super::Api>,
+    ) -> Result<Resource, crate::PipelineError> {
+        Ok(Resource)
+    }
+    unsafe fn destroy_render_pipeline(&self, pipeline: Resource) {}
+    unsafe fn create_compute_pipeline(
+        &self,
+        desc: &crate::ComputePipelineDescriptor<super::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) {}
+}

wgpu-hal/src/gles/egl.rs

@@ -449,7 +449,7 @@ impl crate::Instance<super::Api> for Instance {
                 crate::InstanceError
             })
         } else {
-            let attributes_i32: Vec<i32> = attributes.iter().map(|a| (*a as i32).into()).collect();
+            let attributes_i32: Vec<i32> = attributes.iter().map(|a| *a as i32).collect();
             inner
                 .egl
                 .create_window_surface(
@@ -581,10 +581,7 @@ impl crate::Surface<super::Api> for Surface {
             );
         }
 
-        let format_desc = device
-            .shared
-            .private_caps
-            .describe_texture_format(config.format);
+        let format_desc = device.shared.describe_texture_format(config.format);
         let gl = &device.shared.context;
         let renderbuffer = gl.create_renderbuffer().unwrap();
         gl.bind_renderbuffer(glow::RENDERBUFFER, Some(renderbuffer));
@@ -633,5 +630,5 @@ impl crate::Surface<super::Api> for Surface {
         //    native::SwapchainImage::new(sc.renderbuffer, sc.format, sc.extent, sc.channel);
         Ok(None)
     }
-    unsafe fn discard_texture(&mut self, _texture: super::Resource) {}
+    unsafe fn discard_texture(&mut self, _texture: super::Texture) {}
 }

wgpu-hal/src/gles/mod.rs

@@ -5,10 +5,13 @@ mod egl;
 
 mod adapter;
 mod conv;
+mod device;
 
 #[cfg(not(target_arch = "wasm32"))]
 use self::egl::{Instance, Surface};
 
+use glow::HasContext;
+
 use std::{ops::Range, sync::Arc};
 
 #[derive(Clone)]
@@ -30,11 +33,11 @@ impl crate::Api for Api {
     type CommandEncoder = Encoder;
     type CommandBuffer = Resource;
 
-    type Buffer = Resource;
-    type Texture = Resource;
-    type SurfaceTexture = Resource;
-    type TextureView = Resource;
-    type Sampler = Resource;
+    type Buffer = Buffer;
+    type Texture = Texture;
+    type SurfaceTexture = Texture;
+    type TextureView = TextureView;
+    type Sampler = Sampler;
     type QuerySet = Resource;
     type Fence = Resource;
 
@@ -55,8 +58,98 @@ bitflags::bitflags! {
     }
 }
 
+type BindTarget = u32;
 type TextureFormat = u32;
 
+trait Sampled {
+    unsafe fn set_param_float(&self, gl: &glow::Context, key: u32, value: f32);
+    // see https://github.com/grovesNL/glow/issues/170
+    unsafe fn set_param_float_vec(&self, gl: &glow::Context, key: u32, values: &mut [f32]);
+    unsafe fn set_param_int(&self, gl: &glow::Context, key: u32, value: i32);
+
+    unsafe fn configure_sampling(&self, gl: &glow::Context, desc: &crate::SamplerDescriptor) {
+        let (min, mag) =
+            conv::map_filter_modes(desc.min_filter, desc.mag_filter, desc.mipmap_filter);
+
+        self.set_param_int(gl, glow::TEXTURE_MIN_FILTER, min as i32);
+        self.set_param_int(gl, glow::TEXTURE_MAG_FILTER, mag as i32);
+
+        self.set_param_int(
+            gl,
+            glow::TEXTURE_WRAP_S,
+            conv::map_address_mode(desc.address_modes[0]) as i32,
+        );
+        self.set_param_int(
+            gl,
+            glow::TEXTURE_WRAP_T,
+            conv::map_address_mode(desc.address_modes[1]) as i32,
+        );
+        self.set_param_int(
+            gl,
+            glow::TEXTURE_WRAP_R,
+            conv::map_address_mode(desc.address_modes[2]) as i32,
+        );
+
+        if let Some(border_color) = desc.border_color {
+            let mut border = match border_color {
+                wgt::SamplerBorderColor::TransparentBlack => [0.0; 4],
+                wgt::SamplerBorderColor::OpaqueBlack => [0.0, 0.0, 0.0, 1.0],
+                wgt::SamplerBorderColor::OpaqueWhite => [1.0; 4],
+            };
+            self.set_param_float_vec(gl, glow::TEXTURE_BORDER_COLOR, &mut border);
+        }
+
+        if let Some(ref range) = desc.lod_clamp {
+            self.set_param_float(gl, glow::TEXTURE_MIN_LOD, range.start);
+            self.set_param_float(gl, glow::TEXTURE_MAX_LOD, range.end);
+        }
+
+        //TODO: `desc.anisotropy_clamp` depends on the downlevel flag
+        // self.set_param_float(glow::TEXTURE_MAX_ANISOTROPY, aniso as f32);
+
+        //set_param_float(glow::TEXTURE_LOD_BIAS, info.lod_bias.0);
+
+        if let Some(compare) = desc.compare {
+            self.set_param_int(
+                gl,
+                glow::TEXTURE_COMPARE_MODE,
+                glow::COMPARE_REF_TO_TEXTURE as i32,
+            );
+            self.set_param_int(
+                gl,
+                glow::TEXTURE_COMPARE_FUNC,
+                conv::map_compare_func(compare) as i32,
+            );
+        }
+    }
+}
+
+struct SamplerBinding(glow::Sampler);
+impl Sampled for SamplerBinding {
+    unsafe fn set_param_float(&self, gl: &glow::Context, key: u32, value: f32) {
+        gl.sampler_parameter_f32(self.0, key, value);
+    }
+    unsafe fn set_param_float_vec(&self, gl: &glow::Context, key: u32, values: &mut [f32]) {
+        gl.sampler_parameter_f32_slice(self.0, key, values);
+    }
+    unsafe fn set_param_int(&self, gl: &glow::Context, key: u32, value: i32) {
+        gl.sampler_parameter_i32(self.0, key, value);
+    }
+}
+
+struct SampledTextureBinding(BindTarget);
+impl Sampled for SampledTextureBinding {
+    unsafe fn set_param_float(&self, gl: &glow::Context, key: u32, value: f32) {
+        gl.tex_parameter_f32(self.0, key, value);
+    }
+    unsafe fn set_param_float_vec(&self, gl: &glow::Context, key: u32, values: &mut [f32]) {
+        gl.tex_parameter_f32_slice(self.0, key, values);
+    }
+    unsafe fn set_param_int(&self, gl: &glow::Context, key: u32, value: i32) {
+        gl.tex_parameter_i32(self.0, key, value);
+    }
+}
+
 #[derive(Debug, Clone, Copy)]
 enum VertexAttribKind {
     Float,   // glVertexAttribPointer
@@ -91,6 +184,43 @@ pub struct Queue {
     features: wgt::Features,
 }
 
+#[derive(Debug)]
+pub struct Buffer {
+    raw: glow::Buffer,
+    target: BindTarget,
+    map_flags: u32,
+}
+
+#[derive(Debug)]
+pub enum Texture {
+    Renderbuffer {
+        raw: glow::Renderbuffer,
+        aspects: crate::FormatAspect,
+    },
+    Texture {
+        raw: glow::Texture,
+        target: BindTarget,
+    },
+}
+
+#[derive(Debug)]
+pub enum TextureView {
+    Renderbuffer {
+        raw: glow::Renderbuffer,
+        aspects: crate::FormatAspect,
+    },
+    Texture {
+        raw: glow::Texture,
+        target: BindTarget,
+        range: wgt::ImageSubresourceRange,
+    },
+}
+
+#[derive(Debug)]
+pub struct Sampler {
+    raw: glow::Sampler,
+}
+
 impl crate::Queue<Api> for Queue {
     unsafe fn submit(
         &mut self,
@@ -102,130 +232,12 @@ impl crate::Queue<Api> for Queue {
     unsafe fn present(
         &mut self,
         surface: &mut Surface,
-        texture: Resource,
+        texture: Texture,
     ) -> Result<(), crate::SurfaceError> {
         Ok(())
     }
 }
 
-impl crate::Device<Api> for Device {
-    unsafe fn exit(self) {}
-    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(())
@@ -248,26 +260,26 @@ impl crate::CommandEncoder<Api> for Encoder {
     {
     }
 
-    unsafe fn fill_buffer(&mut self, buffer: &Resource, range: crate::MemoryRange, value: u8) {}
+    unsafe fn fill_buffer(&mut self, buffer: &Buffer, range: crate::MemoryRange, value: u8) {}
 
-    unsafe fn copy_buffer_to_buffer<T>(&mut self, src: &Resource, dst: &Resource, regions: T) {}
+    unsafe fn copy_buffer_to_buffer<T>(&mut self, src: &Buffer, dst: &Buffer, regions: T) {}
 
     unsafe fn copy_texture_to_texture<T>(
         &mut self,
-        src: &Resource,
+        src: &Texture,
         src_usage: crate::TextureUse,
-        dst: &Resource,
+        dst: &Texture,
         regions: T,
     ) {
     }
 
-    unsafe fn copy_buffer_to_texture<T>(&mut self, src: &Resource, dst: &Resource, regions: T) {}
+    unsafe fn copy_buffer_to_texture<T>(&mut self, src: &Buffer, dst: &Texture, regions: T) {}
 
     unsafe fn copy_texture_to_buffer<T>(
         &mut self,
-        src: &Resource,
+        src: &Texture,
         src_usage: crate::TextureUse,
-        dst: &Resource,
+        dst: &Buffer,
         regions: T,
     ) {
     }
@@ -280,7 +292,7 @@ impl crate::CommandEncoder<Api> for Encoder {
         &mut self,
         set: &Resource,
         range: Range<u32>,
-        buffer: &Resource,
+        buffer: &Buffer,
         offset: wgt::BufferAddress,
     ) {
     }
@@ -345,32 +357,32 @@ impl crate::CommandEncoder<Api> for Encoder {
     }
     unsafe fn draw_indirect(
         &mut self,
-        buffer: &Resource,
+        buffer: &Buffer,
         offset: wgt::BufferAddress,
         draw_count: u32,
     ) {
     }
     unsafe fn draw_indexed_indirect(
         &mut self,
-        buffer: &Resource,
+        buffer: &Buffer,
         offset: wgt::BufferAddress,
         draw_count: u32,
     ) {
     }
     unsafe fn draw_indirect_count(
         &mut self,
-        buffer: &Resource,
+        buffer: &Buffer,
         offset: wgt::BufferAddress,
-        count_buffer: &Resource,
+        count_buffer: &Buffer,
         count_offset: wgt::BufferAddress,
         max_count: u32,
     ) {
     }
     unsafe fn draw_indexed_indirect_count(
         &mut self,
-        buffer: &Resource,
+        buffer: &Buffer,
         offset: wgt::BufferAddress,
-        count_buffer: &Resource,
+        count_buffer: &Buffer,
         count_offset: wgt::BufferAddress,
         max_count: u32,
     ) {
@@ -384,5 +396,5 @@ impl crate::CommandEncoder<Api> for Encoder {
     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) {}
+    unsafe fn dispatch_indirect(&mut self, buffer: &Buffer, offset: wgt::BufferAddress) {}
 }