diff --git a/wgpu-hal/src/gles/conv.rs b/wgpu-hal/src/gles/conv.rs index 3d6bec6d83..ba89e26b8e 100644 --- a/wgpu-hal/src/gles/conv.rs +++ b/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, + } +} diff --git a/wgpu-hal/src/gles/device.rs b/wgpu-hal/src/gles/device.rs new file mode 100644 index 0000000000..3ad0e88a75 --- /dev/null +++ b/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 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 { + 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 { + 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(&self, buffer: &super::Buffer, ranges: I) + where + I: Iterator, + { + 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(&self, buffer: &super::Buffer, ranges: I) + where + I: Iterator, + { + 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 { + 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 { + 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 { + 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, + ) -> DeviceResult { + Ok(Encoder) + } + unsafe fn destroy_command_encoder(&self, encoder: Encoder) {} + + unsafe fn create_bind_group_layout( + &self, + desc: &crate::BindGroupLayoutDescriptor, + ) -> DeviceResult { + Ok(Resource) + } + unsafe fn destroy_bind_group_layout(&self, bg_layout: Resource) {} + unsafe fn create_pipeline_layout( + &self, + desc: &crate::PipelineLayoutDescriptor, + ) -> DeviceResult { + Ok(Resource) + } + unsafe fn destroy_pipeline_layout(&self, pipeline_layout: Resource) {} + unsafe fn create_bind_group( + &self, + desc: &crate::BindGroupDescriptor, + ) -> DeviceResult { + Ok(Resource) + } + unsafe fn destroy_bind_group(&self, group: Resource) {} + + unsafe fn create_shader_module( + &self, + desc: &crate::ShaderModuleDescriptor, + shader: crate::ShaderInput, + ) -> Result { + Ok(Resource) + } + unsafe fn destroy_shader_module(&self, module: Resource) {} + unsafe fn create_render_pipeline( + &self, + desc: &crate::RenderPipelineDescriptor, + ) -> Result { + Ok(Resource) + } + unsafe fn destroy_render_pipeline(&self, pipeline: Resource) {} + unsafe fn create_compute_pipeline( + &self, + desc: &crate::ComputePipelineDescriptor, + ) -> Result { + Ok(Resource) + } + unsafe fn destroy_compute_pipeline(&self, pipeline: Resource) {} + + unsafe fn create_query_set( + &self, + desc: &wgt::QuerySetDescriptor, + ) -> DeviceResult { + Ok(Resource) + } + unsafe fn destroy_query_set(&self, set: Resource) {} + unsafe fn create_fence(&self) -> DeviceResult { + Ok(Resource) + } + unsafe fn destroy_fence(&self, fence: Resource) {} + unsafe fn get_fence_value(&self, fence: &Resource) -> DeviceResult { + Ok(0) + } + unsafe fn wait( + &self, + fence: &Resource, + value: crate::FenceValue, + timeout_ms: u32, + ) -> DeviceResult { + Ok(true) + } + + unsafe fn start_capture(&self) -> bool { + false + } + unsafe fn stop_capture(&self) {} +} diff --git a/wgpu-hal/src/gles/egl.rs b/wgpu-hal/src/gles/egl.rs index e564bf0edf..ac5b60ac61 100644 --- a/wgpu-hal/src/gles/egl.rs +++ b/wgpu-hal/src/gles/egl.rs @@ -449,7 +449,7 @@ impl crate::Instance for Instance { crate::InstanceError }) } else { - let attributes_i32: Vec = attributes.iter().map(|a| (*a as i32).into()).collect(); + let attributes_i32: Vec = attributes.iter().map(|a| *a as i32).collect(); inner .egl .create_window_surface( @@ -581,10 +581,7 @@ impl crate::Surface 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 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) {} } diff --git a/wgpu-hal/src/gles/mod.rs b/wgpu-hal/src/gles/mod.rs index 98df9f8f98..557263d48a 100644 --- a/wgpu-hal/src/gles/mod.rs +++ b/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 for Queue { unsafe fn submit( &mut self, @@ -102,130 +232,12 @@ impl crate::Queue for Queue { unsafe fn present( &mut self, surface: &mut Surface, - texture: Resource, + texture: Texture, ) -> Result<(), crate::SurfaceError> { Ok(()) } } -impl crate::Device for Device { - unsafe fn exit(self) {} - unsafe fn create_buffer(&self, desc: &crate::BufferDescriptor) -> DeviceResult { - Ok(Resource) - } - unsafe fn destroy_buffer(&self, buffer: Resource) {} - unsafe fn map_buffer( - &self, - buffer: &Resource, - range: crate::MemoryRange, - ) -> DeviceResult { - Err(crate::DeviceError::Lost) - } - unsafe fn unmap_buffer(&self, buffer: &Resource) -> DeviceResult<()> { - Ok(()) - } - unsafe fn flush_mapped_ranges(&self, buffer: &Resource, ranges: I) {} - unsafe fn invalidate_mapped_ranges(&self, buffer: &Resource, ranges: I) {} - - unsafe fn create_texture(&self, desc: &crate::TextureDescriptor) -> DeviceResult { - Ok(Resource) - } - unsafe fn destroy_texture(&self, texture: Resource) {} - unsafe fn create_texture_view( - &self, - texture: &Resource, - desc: &crate::TextureViewDescriptor, - ) -> DeviceResult { - Ok(Resource) - } - unsafe fn destroy_texture_view(&self, view: Resource) {} - unsafe fn create_sampler(&self, desc: &crate::SamplerDescriptor) -> DeviceResult { - Ok(Resource) - } - unsafe fn destroy_sampler(&self, sampler: Resource) {} - - unsafe fn create_command_encoder( - &self, - desc: &crate::CommandEncoderDescriptor, - ) -> DeviceResult { - Ok(Encoder) - } - unsafe fn destroy_command_encoder(&self, encoder: Encoder) {} - - unsafe fn create_bind_group_layout( - &self, - desc: &crate::BindGroupLayoutDescriptor, - ) -> DeviceResult { - Ok(Resource) - } - unsafe fn destroy_bind_group_layout(&self, bg_layout: Resource) {} - unsafe fn create_pipeline_layout( - &self, - desc: &crate::PipelineLayoutDescriptor, - ) -> DeviceResult { - Ok(Resource) - } - unsafe fn destroy_pipeline_layout(&self, pipeline_layout: Resource) {} - unsafe fn create_bind_group( - &self, - desc: &crate::BindGroupDescriptor, - ) -> DeviceResult { - Ok(Resource) - } - unsafe fn destroy_bind_group(&self, group: Resource) {} - - unsafe fn create_shader_module( - &self, - desc: &crate::ShaderModuleDescriptor, - shader: crate::ShaderInput, - ) -> Result { - Ok(Resource) - } - unsafe fn destroy_shader_module(&self, module: Resource) {} - unsafe fn create_render_pipeline( - &self, - desc: &crate::RenderPipelineDescriptor, - ) -> Result { - Ok(Resource) - } - unsafe fn destroy_render_pipeline(&self, pipeline: Resource) {} - unsafe fn create_compute_pipeline( - &self, - desc: &crate::ComputePipelineDescriptor, - ) -> Result { - Ok(Resource) - } - unsafe fn destroy_compute_pipeline(&self, pipeline: Resource) {} - - unsafe fn create_query_set( - &self, - desc: &wgt::QuerySetDescriptor, - ) -> DeviceResult { - Ok(Resource) - } - unsafe fn destroy_query_set(&self, set: Resource) {} - unsafe fn create_fence(&self) -> DeviceResult { - Ok(Resource) - } - unsafe fn destroy_fence(&self, fence: Resource) {} - unsafe fn get_fence_value(&self, fence: &Resource) -> DeviceResult { - Ok(0) - } - unsafe fn wait( - &self, - fence: &Resource, - value: crate::FenceValue, - timeout_ms: u32, - ) -> DeviceResult { - Ok(true) - } - - unsafe fn start_capture(&self) -> bool { - false - } - unsafe fn stop_capture(&self) {} -} - impl crate::CommandEncoder for Encoder { unsafe fn begin_encoding(&mut self, label: crate::Label) -> DeviceResult<()> { Ok(()) @@ -248,26 +260,26 @@ impl crate::CommandEncoder 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(&mut self, src: &Resource, dst: &Resource, regions: T) {} + unsafe fn copy_buffer_to_buffer(&mut self, src: &Buffer, dst: &Buffer, regions: T) {} unsafe fn copy_texture_to_texture( &mut self, - src: &Resource, + src: &Texture, src_usage: crate::TextureUse, - dst: &Resource, + dst: &Texture, regions: T, ) { } - unsafe fn copy_buffer_to_texture(&mut self, src: &Resource, dst: &Resource, regions: T) {} + unsafe fn copy_buffer_to_texture(&mut self, src: &Buffer, dst: &Texture, regions: T) {} unsafe fn copy_texture_to_buffer( &mut self, - src: &Resource, + src: &Texture, src_usage: crate::TextureUse, - dst: &Resource, + dst: &Buffer, regions: T, ) { } @@ -280,7 +292,7 @@ impl crate::CommandEncoder for Encoder { &mut self, set: &Resource, range: Range, - buffer: &Resource, + buffer: &Buffer, offset: wgt::BufferAddress, ) { } @@ -345,32 +357,32 @@ impl crate::CommandEncoder 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 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) {} }