diff --git a/assets/voxygen/shaders/sprite-vert.glsl b/assets/voxygen/shaders/sprite-vert.glsl index f59d6c3d22..14440833ac 100644 --- a/assets/voxygen/shaders/sprite-vert.glsl +++ b/assets/voxygen/shaders/sprite-vert.glsl @@ -86,6 +86,8 @@ const float SCALE = 1.0 / 11.0; const float SCALE_FACTOR = pow(SCALE, 1.3) * 0.2; const int EXTRA_NEG_Z = 32768; +//const int VERT_EXTRA_NEG_Z = 128; +//const int VERT_PAGE_SIZE = 256; void main() { // vec3 inst_chunk_pos = vec3(ivec3((uvec3(inst_pos_ori) >> uvec3(0, 6, 12)) & uvec3(0x3Fu, 0x3Fu, 0xFFFFu)) - ivec3(0, 0, EXTRA_NEG_Z)); diff --git a/voxygen/src/render/mesh.rs b/voxygen/src/render/mesh.rs index 65c8d43178..2da6c4698e 100644 --- a/voxygen/src/render/mesh.rs +++ b/voxygen/src/render/mesh.rs @@ -42,31 +42,48 @@ impl Mesh { pub fn push_quad(&mut self, quad: Quad) { // A quad is composed of two triangles. The code below converts the former to // the latter. + if V::QUADS_INDEX.is_some() { + // 0, 1, 2, 2, 1, 3 + // b, c, a, a, c, d + self.verts.push(quad.b); + self.verts.push(quad.c); + self.verts.push(quad.a); + self.verts.push(quad.d); + } else { + // Tri 1 + self.verts.push(quad.a.clone()); + self.verts.push(quad.b); + self.verts.push(quad.c.clone()); - // Tri 1 - self.verts.push(quad.a.clone()); - self.verts.push(quad.b); - self.verts.push(quad.c.clone()); - - // Tri 2 - self.verts.push(quad.c); - self.verts.push(quad.d); - self.verts.push(quad.a); + // Tri 2 + self.verts.push(quad.c); + self.verts.push(quad.d); + self.verts.push(quad.a); + } } /// Overwrite a quad pub fn replace_quad(&mut self, index: usize, quad: Quad) { - debug_assert!(index % 3 == 0); - assert!(index + 5 < self.verts.len()); - // Tri 1 - self.verts[index] = quad.a.clone(); - self.verts[index + 1] = quad.b; - self.verts[index + 2] = quad.c.clone(); + if V::QUADS_INDEX.is_some() { + debug_assert!(index % 4 == 0); + assert!(index + 3 < self.verts.len()); + self.verts[index] = quad.b; + self.verts[index + 1] = quad.c; + self.verts[index + 2] = quad.a; + self.verts[index + 3] = quad.d; + } else { + debug_assert!(index % 3 == 0); + assert!(index + 5 < self.verts.len()); + // Tri 1 + self.verts[index] = quad.a.clone(); + self.verts[index + 1] = quad.b; + self.verts[index + 2] = quad.c.clone(); - // Tri 2 - self.verts[index + 3] = quad.c; - self.verts[index + 4] = quad.d; - self.verts[index + 5] = quad.a; + // Tri 2 + self.verts[index + 3] = quad.c; + self.verts[index + 4] = quad.d; + self.verts[index + 5] = quad.a; + } } /// Push the vertices of another mesh onto the end of this mesh. diff --git a/voxygen/src/render/mod.rs b/voxygen/src/render/mod.rs index 19cb78d36d..cf7528c90c 100644 --- a/voxygen/src/render/mod.rs +++ b/voxygen/src/render/mod.rs @@ -55,6 +55,8 @@ pub use wgpu::{AddressMode, FilterMode}; pub trait Vertex: Clone + bytemuck::Pod { const STRIDE: wgpu::BufferAddress; + // Whether these types of verts use the quad index buffer for drawing them + const QUADS_INDEX: Option; } use serde::{Deserialize, Serialize}; diff --git a/voxygen/src/render/pipelines/fluid.rs b/voxygen/src/render/pipelines/fluid.rs index 116caa7b67..0624e90978 100644 --- a/voxygen/src/render/pipelines/fluid.rs +++ b/voxygen/src/render/pipelines/fluid.rs @@ -43,6 +43,7 @@ impl Vertex { } impl VertexTrait for Vertex { + const QUADS_INDEX: Option = Some(wgpu::IndexFormat::Uint16); const STRIDE: wgpu::BufferAddress = mem::size_of::() as wgpu::BufferAddress; } diff --git a/voxygen/src/render/pipelines/lod_terrain.rs b/voxygen/src/render/pipelines/lod_terrain.rs index 5da7fab84a..5d18ea8c02 100644 --- a/voxygen/src/render/pipelines/lod_terrain.rs +++ b/voxygen/src/render/pipelines/lod_terrain.rs @@ -27,6 +27,7 @@ impl Vertex { } impl VertexTrait for Vertex { + const QUADS_INDEX: Option = Some(wgpu::IndexFormat::Uint32); const STRIDE: wgpu::BufferAddress = mem::size_of::() as wgpu::BufferAddress; } diff --git a/voxygen/src/render/pipelines/particle.rs b/voxygen/src/render/pipelines/particle.rs index 756dbf968d..5b149d358d 100644 --- a/voxygen/src/render/pipelines/particle.rs +++ b/voxygen/src/render/pipelines/particle.rs @@ -44,6 +44,7 @@ impl Vertex { } impl VertexTrait for Vertex { + const QUADS_INDEX: Option = Some(wgpu::IndexFormat::Uint16); const STRIDE: wgpu::BufferAddress = mem::size_of::() as wgpu::BufferAddress; } diff --git a/voxygen/src/render/pipelines/skybox.rs b/voxygen/src/render/pipelines/skybox.rs index 8805140d79..83de768459 100644 --- a/voxygen/src/render/pipelines/skybox.rs +++ b/voxygen/src/render/pipelines/skybox.rs @@ -23,6 +23,7 @@ impl Vertex { } impl VertexTrait for Vertex { + const QUADS_INDEX: Option = None; const STRIDE: wgpu::BufferAddress = mem::size_of::() as wgpu::BufferAddress; } diff --git a/voxygen/src/render/pipelines/sprite.rs b/voxygen/src/render/pipelines/sprite.rs index 8d35afffb9..91cfebede8 100644 --- a/voxygen/src/render/pipelines/sprite.rs +++ b/voxygen/src/render/pipelines/sprite.rs @@ -4,6 +4,8 @@ use core::fmt; use std::mem; use vek::*; +// pub const VERT_PAGE_SIZE: u32 = 256; + #[repr(C)] #[derive(Copy, Clone, Debug, Zeroable, Pod)] pub struct Vertex { @@ -72,9 +74,72 @@ impl Vertex { } impl VertexTrait for Vertex { + const QUADS_INDEX: Option = Some(wgpu::IndexFormat::Uint16); const STRIDE: wgpu::BufferAddress = mem::size_of::() as wgpu::BufferAddress; } +/* pub fn create_verts_buffer(renderer: &mut Renderer, mut mesh: Mesh) -> Buffer { + renderer.ensure_sufficient_index_length::(VERT_PAGE_SIZE as usize); + // TODO: type buffer by Usage + Buffer::new( + &renderer.device, + wgpu::BufferUsage::STORAGE, + mesh.vertices(), + ) + //let mut verts = mesh.vertices_mut_vec(); + //let format = wgpu::TextureFormat::Rg32Uint; + + // TODO: temp + //const WIDTH: u32 = 8192; + //let height = verts.len() as u32 / WIDTH; + // Fill in verts to full texture size + //verts.resize_with(height as usize * WIDTH as usize, Vertex::default); + + /*let texture_info = wgpu::TextureDescriptor { + label: Some("Sprite verts"), + size: wgpu::Extent3d { + width: WIDTH, + height, + depth: 1, + }, + mip_level_count: 1, + sample_count: 1, + dimension: wgpu::TextureDimension::D2, + format, + usage: wgpu::TextureUsage::SAMPLED | wgpu::TextureUsage::COPY_DST, + }; + + let sampler_info = wgpu::SamplerDescriptor { + label: None, + address_mode_u: wgpu::AddressMode::Repeat, + address_mode_v: wgpu::AddressMode::Repeat, + address_mode_w: wgpu::AddressMode::Repeat, + mag_filter: wgpu::FilterMode::Nearest, + min_filter: wgpu::FilterMode::Nearest, + mipmap_filter: wgpu::FilterMode::Nearest, + ..Default::default() + }; + + let view_info = wgpu::TextureViewDescriptor { + label: None, + format: Some(format), + dimension: Some(wgpu::TextureViewDimension::D2), + aspect: wgpu::TextureAspect::All, + base_mip_level: 0, + level_count: None, + base_array_layer: 0, + array_layer_count: None, + }; + + renderer.create_texture_with_data_raw::<8>( + &texture_info, + &view_info, + &sampler_info, + bytemuck::cast_slice(verts), + )*/ +} +*/ + #[repr(C)] #[derive(Copy, Clone, Debug, Zeroable, Pod)] pub struct Instance { diff --git a/voxygen/src/render/pipelines/terrain.rs b/voxygen/src/render/pipelines/terrain.rs index d5b349f829..bc25d1c4b2 100644 --- a/voxygen/src/render/pipelines/terrain.rs +++ b/voxygen/src/render/pipelines/terrain.rs @@ -131,6 +131,9 @@ impl Vertex { } impl VertexTrait for Vertex { + // Note: I think it's u32 due to figures?? + // potentiall optimize by splitting + const QUADS_INDEX: Option = Some(wgpu::IndexFormat::Uint32); const STRIDE: wgpu::BufferAddress = mem::size_of::() as wgpu::BufferAddress; } diff --git a/voxygen/src/render/pipelines/ui.rs b/voxygen/src/render/pipelines/ui.rs index dab343f078..90beee96e4 100644 --- a/voxygen/src/render/pipelines/ui.rs +++ b/voxygen/src/render/pipelines/ui.rs @@ -27,6 +27,7 @@ impl Vertex { } impl VertexTrait for Vertex { + const QUADS_INDEX: Option = None; const STRIDE: wgpu::BufferAddress = mem::size_of::() as wgpu::BufferAddress; } diff --git a/voxygen/src/render/renderer.rs b/voxygen/src/render/renderer.rs index 175d536ebc..98e9c30b06 100644 --- a/voxygen/src/render/renderer.rs +++ b/voxygen/src/render/renderer.rs @@ -10,6 +10,7 @@ use shaders::Shaders; use shadow_map::{ShadowMap, ShadowMapRenderer}; use super::{ + buffer::Buffer, consts::Consts, instances::Instances, mesh::Mesh, @@ -34,6 +35,9 @@ use vek::*; // TODO: revert to u16 pub type ColLightInfo = (Vec<[u8; 4]>, Vec2); +const QUAD_INDEX_BUFFER_U16_START_VERT_LEN: u16 = 3000; +const QUAD_INDEX_BUFFER_U32_START_VERT_LEN: u32 = 3000; + /// A type that stores all the layouts associated with this renderer. struct Layouts { global: GlobalsLayouts, @@ -104,6 +108,9 @@ pub struct Renderer { views: Views, noise_tex: Texture, + quad_index_buffer_u16: Buffer, + quad_index_buffer_u32: Buffer, + shaders: AssetHandle, mode: RenderMode, @@ -330,6 +337,10 @@ impl Renderer { &depth_sampler, ); + let quad_index_buffer_u16 = + create_quad_index_buffer_u16(&device, QUAD_INDEX_BUFFER_U16_START_VERT_LEN as usize); + let quad_index_buffer_u32 = + create_quad_index_buffer_u32(&device, QUAD_INDEX_BUFFER_U32_START_VERT_LEN as usize); let mut profiler = wgpu_profiler::GpuProfiler::new(1, queue.get_timestamp_period()); profiler.enable_timer = mode.profiler_enabled; profiler.enable_debug_marker = mode.profiler_enabled; @@ -351,6 +362,9 @@ impl Renderer { depth_sampler, noise_tex, + quad_index_buffer_u16, + quad_index_buffer_u32, + shaders, mode, @@ -927,8 +941,50 @@ impl Renderer { Ok(instances) } + /// Ensure that the quad index buffer is large enough for a quad vertex + /// buffer with this many vertices + pub(super) fn ensure_sufficient_index_length( + &mut self, + // Length of the vert buffer with 4 verts per quad + length: usize, + ) { + match V::QUADS_INDEX { + Some(wgpu::IndexFormat::Uint16) => { + // Make sure the global quad index buffer is large enough + if self.quad_index_buffer_u16.len() < length { + // Make sure we aren't over the max + if length > u16::MAX as usize { + panic!( + "Vertex type: {} needs to use a larger index type, length: {}", + core::any::type_name::(), + length + ); + } + self.quad_index_buffer_u16 = create_quad_index_buffer_u16(&self.device, length); + } + }, + Some(wgpu::IndexFormat::Uint32) => { + // Make sure the global quad index buffer is large enough + if self.quad_index_buffer_u32.len() < length { + // Make sure we aren't over the max + if length > u32::MAX as usize { + panic!( + "More than u32::MAX({}) verts({}) for type({}) using an index buffer!", + u32::MAX, + length, + core::any::type_name::() + ); + } + self.quad_index_buffer_u32 = create_quad_index_buffer_u32(&self.device, length); + } + }, + None => {}, + } + } + /// Create a new model from the provided mesh. pub fn create_model(&mut self, mesh: &Mesh) -> Result, RenderError> { + self.ensure_sufficient_index_length::(mesh.vertices().len()); Ok(Model::new(&self.device, mesh)) } @@ -2171,3 +2227,31 @@ fn create_shader_module( flags: wgpu::ShaderFlags::empty(), // TODO: renable wgpu::ShaderFlags::VALIDATION, })) } + +fn create_quad_index_buffer_u16(device: &wgpu::Device, vert_length: usize) -> Buffer { + assert!(vert_length <= u16::MAX as usize); + let indices = [0, 1, 2, 2, 1, 3] + .iter() + .cycle() + .copied() + .take(vert_length / 4 * 6) + .enumerate() + .map(|(i, b)| (i / 6 * 4 + b) as u16) + .collect::>(); + + Buffer::new(device, wgpu::BufferUsage::INDEX, &indices) +} + +fn create_quad_index_buffer_u32(device: &wgpu::Device, vert_length: usize) -> Buffer { + assert!(vert_length <= u32::MAX as usize); + let indices = [0, 1, 2, 2, 1, 3] + .iter() + .cycle() + .copied() + .take(vert_length / 4 * 6) + .enumerate() + .map(|(i, b)| (i / 6 * 4 + b) as u32) + .collect::>(); + + Buffer::new(device, wgpu::BufferUsage::INDEX, &indices) +} diff --git a/voxygen/src/render/renderer/drawer.rs b/voxygen/src/render/renderer/drawer.rs index 1e82c3a0c5..059408f573 100644 --- a/voxygen/src/render/renderer/drawer.rs +++ b/voxygen/src/render/renderer/drawer.rs @@ -26,6 +26,8 @@ struct RendererBorrow<'frame> { locals: &'frame super::locals::Locals, views: &'frame super::Views, mode: &'frame super::super::RenderMode, + quad_index_buffer_u16: &'frame Buffer, + quad_index_buffer_u32: &'frame Buffer, } pub struct Drawer<'frame> { @@ -50,6 +52,8 @@ impl<'frame> Drawer<'frame> { locals: &renderer.locals, views: &renderer.views, mode: &renderer.mode, + quad_index_buffer_u16: &renderer.quad_index_buffer_u16, + quad_index_buffer_u32: &renderer.quad_index_buffer_u32, }; let mut encoder = @@ -233,6 +237,7 @@ impl<'frame> Drawer<'frame> { }); render_pass.set_pipeline(&shadow_renderer.point_pipeline.pipeline); + set_quad_index_buffer::(&mut render_pass, &self.borrow); render_pass.set_bind_group(0, &self.globals.bind_group, &[]); (0../*20*/1).for_each(|point_light| { @@ -245,7 +250,7 @@ impl<'frame> Drawer<'frame> { chunks.clone().for_each(|(model, locals)| { render_pass.set_bind_group(1, &locals.bind_group, &[]); render_pass.set_vertex_buffer(0, model.buf().slice(..)); - render_pass.draw(0..model.len() as u32, 0..1); + render_pass.draw_indexed(0..model.len() as u32 / 4 * 6, 0, 0..1); }); }); } @@ -346,6 +351,7 @@ impl<'pass> ShadowPassDrawer<'pass> { .scope(self.borrow.device, "direcred_figure_shadows"); render_pass.set_pipeline(&self.shadow_renderer.figure_directed_pipeline.pipeline); + set_quad_index_buffer::(&mut render_pass, &self.borrow); FigureShadowDrawer { render_pass } } @@ -356,6 +362,7 @@ impl<'pass> ShadowPassDrawer<'pass> { .scope(self.borrow.device, "direcred_terrain_shadows"); render_pass.set_pipeline(&self.shadow_renderer.terrain_directed_pipeline.pipeline); + set_quad_index_buffer::(&mut render_pass, &self.borrow); TerrainShadowDrawer { render_pass } } @@ -373,7 +380,8 @@ impl<'pass_ref, 'pass: 'pass_ref> FigureShadowDrawer<'pass_ref, 'pass> { ) { self.render_pass.set_bind_group(1, &locals.bind_group, &[]); self.render_pass.set_vertex_buffer(0, model.buf()); - self.render_pass.draw(0..model.len(), 0..1); + self.render_pass + .draw_indexed(0..model.len() as u32 / 4 * 6, 0, 0..1); } } @@ -389,7 +397,8 @@ impl<'pass_ref, 'pass: 'pass_ref> TerrainShadowDrawer<'pass_ref, 'pass> { ) { self.render_pass.set_bind_group(1, &locals.bind_group, &[]); self.render_pass.set_vertex_buffer(0, model.buf().slice(..)); - self.render_pass.draw(0..model.len() as u32, 0..1); + self.render_pass + .draw_indexed(0..model.len() as u32 / 4 * 6, 0, 0..1); } } @@ -404,6 +413,7 @@ impl<'pass> FirstPassDrawer<'pass> { let mut render_pass = self.render_pass.scope(self.borrow.device, "skybox"); render_pass.set_pipeline(&self.borrow.pipelines.skybox.pipeline); + set_quad_index_buffer::(&mut render_pass, &self.borrow); render_pass.set_vertex_buffer(0, model.buf().slice(..)); render_pass.draw(0..model.len() as u32, 0..1); } @@ -412,14 +422,16 @@ impl<'pass> FirstPassDrawer<'pass> { let mut render_pass = self.render_pass.scope(self.borrow.device, "lod_terrain"); render_pass.set_pipeline(&self.borrow.pipelines.lod_terrain.pipeline); + set_quad_index_buffer::(&mut render_pass, &self.borrow); render_pass.set_vertex_buffer(0, model.buf().slice(..)); - render_pass.draw(0..model.len() as u32, 0..1); + render_pass.draw_indexed(0..model.len() as u32 / 4 * 6, 0, 0..1); } pub fn draw_figures(&mut self) -> FigureDrawer<'_, 'pass> { let mut render_pass = self.render_pass.scope(self.borrow.device, "figures"); render_pass.set_pipeline(&self.borrow.pipelines.figure.pipeline); + set_quad_index_buffer::(&mut render_pass, &self.borrow); FigureDrawer { render_pass } } @@ -428,6 +440,7 @@ impl<'pass> FirstPassDrawer<'pass> { let mut render_pass = self.render_pass.scope(self.borrow.device, "terrain"); render_pass.set_pipeline(&self.borrow.pipelines.terrain.pipeline); + set_quad_index_buffer::(&mut render_pass, &self.borrow); TerrainDrawer { render_pass, @@ -439,6 +452,7 @@ impl<'pass> FirstPassDrawer<'pass> { let mut render_pass = self.render_pass.scope(self.borrow.device, "particles"); render_pass.set_pipeline(&self.borrow.pipelines.particle.pipeline); + set_quad_index_buffer::(&mut render_pass, &self.borrow); ParticleDrawer { render_pass } } @@ -450,6 +464,7 @@ impl<'pass> FirstPassDrawer<'pass> { let mut render_pass = self.render_pass.scope(self.borrow.device, "sprites"); render_pass.set_pipeline(&self.borrow.pipelines.sprite.pipeline); + set_quad_index_buffer::(&mut render_pass, &self.borrow); render_pass.set_bind_group(4, &col_lights.bind_group, &[]); SpriteDrawer { render_pass } @@ -462,6 +477,7 @@ impl<'pass> FirstPassDrawer<'pass> { let mut render_pass = self.render_pass.scope(self.borrow.device, "fluid"); render_pass.set_pipeline(&self.borrow.pipelines.fluid.pipeline); + set_quad_index_buffer::(&mut render_pass, &self.borrow); render_pass.set_bind_group(2, &waves.bind_group, &[]); FluidDrawer { render_pass } @@ -484,7 +500,8 @@ impl<'pass_ref, 'pass: 'pass_ref> FigureDrawer<'pass_ref, 'pass> { self.render_pass .set_bind_group(3, &col_lights.bind_group, &[]); self.render_pass.set_vertex_buffer(0, model.buf()); - self.render_pass.draw(0..model.len(), 0..1); + self.render_pass + .draw_indexed(0..model.len() as u32 / 4 * 6, 0, 0..1); } } @@ -516,7 +533,8 @@ impl<'pass_ref, 'pass: 'pass_ref> TerrainDrawer<'pass_ref, 'pass> { self.render_pass.set_bind_group(2, &locals.bind_group, &[]); // TODO: put this in slot 3 self.render_pass.set_vertex_buffer(0, model.buf().slice(..)); - self.render_pass.draw(0..model.len() as u32, 0..1) + self.render_pass + .draw_indexed(0..model.len() as u32 / 4 * 6, 0, 0..1); } } @@ -537,7 +555,7 @@ impl<'pass_ref, 'pass: 'pass_ref> ParticleDrawer<'pass_ref, 'pass> { .set_vertex_buffer(1, instances.buf().slice(..)); self.render_pass // TODO: since we cast to u32 maybe this should returned by the len/count functions? - .draw(0..model.len() as u32, 0..instances.count() as u32); + .draw_indexed(0..model.len() as u32 / 4 * 6, 0, 0..instances.count() as u32); } } @@ -556,6 +574,14 @@ impl<'pass_ref, 'pass: 'pass_ref> SpriteDrawer<'pass_ref, 'pass> { ChunkSpriteDrawer { render_pass: &mut self.render_pass, } + /* //self.render_pass.set_vertex_buffer(0, model.buf().slice(..)); + self.render_pass + .set_vertex_buffer(0, instances.buf().slice(..)); + self.render_pass.draw_indexed( + 0..sprite::VERT_PAGE_SIZE / 4 * 6, + 0, + 0..instances.count() as u32, + ); */ } } pub struct ChunkSpriteDrawer<'pass_ref, 'pass: 'pass_ref> { @@ -573,8 +599,11 @@ impl<'pass_ref, 'pass: 'pass_ref> ChunkSpriteDrawer<'pass_ref, 'pass> { self.render_pass .set_vertex_buffer(1, instances.buf().slice(..)); self.render_pass.set_bind_group(3, &locals.bind_group, &[]); - self.render_pass - .draw(0..model.len() as u32, 0..instances.count() as u32); + self.render_pass.draw_indexed( + 0..model.len() as u32 / 4 * 6, + 0, + 0..instances.count() as u32, + ); } } @@ -590,7 +619,8 @@ impl<'pass_ref, 'pass: 'pass_ref> FluidDrawer<'pass_ref, 'pass> { ) { self.render_pass.set_vertex_buffer(0, model.buf().slice(..)); self.render_pass.set_bind_group(3, &locals.bind_group, &[]); - self.render_pass.draw(0..model.len() as u32, 0..1); + self.render_pass + .draw_indexed(0..model.len() as u32 / 4 * 6, 0, 0..1); } } @@ -627,6 +657,7 @@ impl<'pass> ThirdPassDrawer<'pass> { pub fn draw_ui(&mut self) -> UiDrawer<'_, 'pass> { let mut render_pass = self.render_pass.scope(self.borrow.device, "ui"); render_pass.set_pipeline(&self.borrow.pipelines.ui.pipeline); + set_quad_index_buffer::(&mut render_pass, &self.borrow); UiDrawer { render_pass } } @@ -695,3 +726,20 @@ impl<'pass_ref, 'pass: 'pass_ref> PreparedUiDrawer<'pass_ref, 'pass> { self.render_pass.draw(verts, 0..1); } } + +fn set_quad_index_buffer<'a, V: super::super::Vertex>( + pass: &mut wgpu::RenderPass<'a>, + borrow: &RendererBorrow<'a>, +) { + match V::QUADS_INDEX { + Some(format) => { + let slice = match format { + wgpu::IndexFormat::Uint16 => borrow.quad_index_buffer_u16.buf.slice(..), + wgpu::IndexFormat::Uint32 => borrow.quad_index_buffer_u32.buf.slice(..), + }; + + pass.set_index_buffer(slice, format); + }, + None => {}, + } +}