pub(crate) mod math;
use crate::camera::Camera;
use crate::renderer::DEPTH_FORMAT;
use bytemuck::Zeroable;
use glam::DVec3;
use math::{
Candidate, FrameUniform, LineObject, MeshObject, Planned, frame_uniform, line_pipeline,
mesh_object, mesh_pipeline, pack_lines, pack_mesh, pack_slots, plan, slot_stride,
};
use std::collections::BTreeMap;
use wgpu::util::DeviceExt;
#[derive(Debug, Clone, Copy, PartialEq)]
pub struct Fog {
pub color: [f32; 3],
pub near: f32,
pub far: f32,
}
#[derive(Debug, Clone, Copy, PartialEq)]
pub struct FrameStyle {
pub clear: [f64; 4],
pub fog: Option<Fog>,
}
pub fn begin_pass<'e>(
encoder: &'e mut wgpu::CommandEncoder,
color: &wgpu::TextureView,
depth: &wgpu::TextureView,
style: &FrameStyle,
) -> wgpu::RenderPass<'e> {
let [r, g, b, a] = style.clear;
encoder.begin_render_pass(&wgpu::RenderPassDescriptor {
label: Some("pointblitz frame"),
color_attachments: &[Some(wgpu::RenderPassColorAttachment {
view: color,
depth_slice: None,
resolve_target: None,
ops: wgpu::Operations {
load: wgpu::LoadOp::Clear(wgpu::Color { r, g, b, a }),
store: wgpu::StoreOp::Store,
},
})],
depth_stencil_attachment: Some(wgpu::RenderPassDepthStencilAttachment {
view: depth,
depth_ops: Some(wgpu::Operations {
load: wgpu::LoadOp::Clear(0.0),
store: wgpu::StoreOp::Store,
}),
stencil_ops: None,
}),
..Default::default()
})
}
fn uniform_layout(device: &wgpu::Device, label: &str, dynamic: bool) -> wgpu::BindGroupLayout {
device.create_bind_group_layout(&wgpu::BindGroupLayoutDescriptor {
label: Some(label),
entries: &[wgpu::BindGroupLayoutEntry {
binding: 0,
visibility: wgpu::ShaderStages::VERTEX,
ty: wgpu::BindingType::Buffer {
ty: wgpu::BufferBindingType::Uniform,
has_dynamic_offset: dynamic,
min_binding_size: None,
},
count: None,
}],
})
}
struct FrameSlot {
layout: wgpu::BindGroupLayout,
buf: wgpu::Buffer,
bg: wgpu::BindGroup,
encode_srgb: bool,
}
impl FrameSlot {
fn new(device: &wgpu::Device, color_format: wgpu::TextureFormat) -> Self {
let layout = uniform_layout(device, "layer frame", false);
let buf = device.create_buffer(&wgpu::BufferDescriptor {
label: Some("layer frame"),
size: size_of::<FrameUniform>() as u64,
usage: wgpu::BufferUsages::UNIFORM | wgpu::BufferUsages::COPY_DST,
mapped_at_creation: false,
});
let bg = device.create_bind_group(&wgpu::BindGroupDescriptor {
label: Some("layer frame"),
layout: &layout,
entries: &[wgpu::BindGroupEntry {
binding: 0,
resource: buf.as_entire_binding(),
}],
});
Self {
layout,
buf,
bg,
encode_srgb: !color_format.is_srgb(),
}
}
fn write(&self, queue: &wgpu::Queue, size: [u32; 2], camera: &Camera, fog: Option<Fog>) {
let aspect = f64::from(size[0].max(1)) / f64::from(size[1].max(1));
let u = frame_uniform(
camera.view_proj(aspect).to_cols_array_2d(),
fog,
self.encode_srgb,
);
queue.write_buffer(&self.buf, 0, bytemuck::bytes_of(&u));
}
}
struct Slots {
layout: wgpu::BindGroupLayout,
buf: wgpu::Buffer,
bg: wgpu::BindGroup,
capacity: usize,
stride: u64,
size: u64,
}
impl Slots {
fn new(device: &wgpu::Device, label: &str, size: u64) -> Self {
let layout = uniform_layout(device, label, true);
let align = u64::from(device.limits().min_uniform_buffer_offset_alignment);
let stride = slot_stride(size, align);
let capacity = 16;
let (buf, bg) = Self::alloc(device, &layout, stride, size, capacity);
Self {
layout,
buf,
bg,
capacity,
stride,
size,
}
}
fn alloc(
device: &wgpu::Device,
layout: &wgpu::BindGroupLayout,
stride: u64,
size: u64,
capacity: usize,
) -> (wgpu::Buffer, wgpu::BindGroup) {
let buf = device.create_buffer(&wgpu::BufferDescriptor {
label: Some("layer objects"),
size: stride * capacity as u64,
usage: wgpu::BufferUsages::UNIFORM | wgpu::BufferUsages::COPY_DST,
mapped_at_creation: false,
});
let bg = device.create_bind_group(&wgpu::BindGroupDescriptor {
label: Some("layer objects"),
layout,
entries: &[wgpu::BindGroupEntry {
binding: 0,
resource: wgpu::BindingResource::Buffer(wgpu::BufferBinding {
buffer: &buf,
offset: 0,
size: wgpu::BufferSize::new(size),
}),
}],
});
(buf, bg)
}
fn reserve(&mut self, device: &wgpu::Device, n: usize) -> bool {
if n <= self.capacity {
return false;
}
self.capacity = n.next_power_of_two();
(self.buf, self.bg) =
Self::alloc(device, &self.layout, self.stride, self.size, self.capacity);
true
}
fn write<T: bytemuck::Pod>(&self, queue: &wgpu::Queue, items: &[T]) {
if !items.is_empty() {
queue.write_buffer(&self.buf, 0, &pack_slots(items, self.stride as usize));
}
}
fn offset(&self, slot: u32) -> u32 {
(u64::from(slot) * self.stride) as u32
}
}
fn blend_state(blend: Blend) -> Option<wgpu::BlendState> {
use wgpu::{BlendComponent, BlendFactor as F, BlendOperation::Add};
match blend {
Blend::Opaque => None,
Blend::Alpha => Some(wgpu::BlendState {
color: BlendComponent {
src_factor: F::SrcAlpha,
dst_factor: F::OneMinusSrcAlpha,
operation: Add,
},
alpha: BlendComponent {
src_factor: F::One,
dst_factor: F::OneMinusSrcAlpha,
operation: Add,
},
}),
Blend::Additive => Some(wgpu::BlendState {
color: BlendComponent {
src_factor: F::SrcAlpha,
dst_factor: F::One,
operation: Add,
},
alpha: BlendComponent {
src_factor: F::Zero,
dst_factor: F::One,
operation: Add,
},
}),
}
}
fn depth_state(test: bool, write: bool) -> wgpu::DepthStencilState {
wgpu::DepthStencilState {
format: DEPTH_FORMAT,
depth_write_enabled: Some(write),
depth_compare: Some(if test {
wgpu::CompareFunction::Greater
} else {
wgpu::CompareFunction::Always
}),
stencil: Default::default(),
bias: Default::default(),
}
}
fn shader(device: &wgpu::Device, label: &str, body: &str) -> wgpu::ShaderModule {
let source = format!("{}\n{}", include_str!("color.wgsl"), body);
device.create_shader_module(wgpu::ShaderModuleDescriptor {
label: Some(label),
source: wgpu::ShaderSource::Wgsl(source.into()),
})
}
fn non_empty<'a>(bytes: &'a [u8], fallback: &'a [u8]) -> &'a [u8] {
if bytes.is_empty() { fallback } else { bytes }
}
#[derive(Debug, Clone, Copy, PartialEq)]
pub enum Shading {
Unlit,
Lambert {
sky: [f32; 3],
ground: [f32; 3],
hemi_intensity: f32,
sun_dir: [f32; 3],
sun_color: [f32; 3],
sun_intensity: f32,
emissive: [f32; 3],
},
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum Blend {
Opaque,
Alpha,
Additive,
}
#[derive(Debug, Clone, Copy, PartialEq)]
pub struct Material {
pub shading: Shading,
pub tint: [f32; 4],
pub blend: Blend,
pub double_sided: bool,
}
#[derive(Debug, Clone)]
pub struct TextureImage {
pub width: u32,
pub height: u32,
pub rgba: Vec<u8>,
}
#[derive(Debug, Clone, Default)]
pub struct MeshData {
pub positions: Vec<[f64; 3]>,
pub normals: Option<Vec<[f32; 3]>>,
pub colors: Option<Vec<[u8; 4]>>,
pub uvs: Option<Vec<[f32; 2]>>,
pub indices: Vec<u32>,
pub flat: bool,
}
struct GpuMesh {
vertices: wgpu::Buffer,
indices: wgpu::Buffer,
index_count: u32,
origin: DVec3,
texture: Option<(wgpu::Texture, wgpu::BindGroup)>,
material: Material,
visible: bool,
version: u64,
}
pub struct MeshRenderer {
pipelines: Vec<wgpu::RenderPipeline>,
frame: FrameSlot,
slots: Slots,
texture_layout: wgpu::BindGroupLayout,
sampler: wgpu::Sampler,
white: Option<(wgpu::Texture, wgpu::BindGroup)>,
meshes: BTreeMap<u64, GpuMesh>,
next_version: u64,
opaque: Vec<Planned>,
transparent: Vec<Planned>,
}
impl MeshRenderer {
pub fn new(device: &wgpu::Device, color_format: wgpu::TextureFormat) -> Self {
let module = shader(device, "pointblitz meshes", include_str!("mesh.wgsl"));
let frame = FrameSlot::new(device, color_format);
let slots = Slots::new(device, "mesh objects", size_of::<MeshObject>() as u64);
let texture_layout = device.create_bind_group_layout(&wgpu::BindGroupLayoutDescriptor {
label: Some("mesh texture"),
entries: &[
wgpu::BindGroupLayoutEntry {
binding: 0,
visibility: wgpu::ShaderStages::FRAGMENT,
ty: wgpu::BindingType::Texture {
sample_type: wgpu::TextureSampleType::Float { filterable: true },
view_dimension: wgpu::TextureViewDimension::D2,
multisampled: false,
},
count: None,
},
wgpu::BindGroupLayoutEntry {
binding: 1,
visibility: wgpu::ShaderStages::FRAGMENT,
ty: wgpu::BindingType::Sampler(wgpu::SamplerBindingType::Filtering),
count: None,
},
],
});
let layout = device.create_pipeline_layout(&wgpu::PipelineLayoutDescriptor {
label: Some("meshes"),
bind_group_layouts: &[
Some(&frame.layout),
Some(&slots.layout),
Some(&texture_layout),
],
immediate_size: 0,
});
let attributes = wgpu::vertex_attr_array![
0 => Float32x3,
1 => Float32x3,
2 => Float32x2,
3 => Unorm8x4,
];
let mut pipelines = Vec::with_capacity(6);
for blend in [Blend::Opaque, Blend::Alpha, Blend::Additive] {
for double_sided in [false, true] {
debug_assert_eq!(pipelines.len(), mesh_pipeline(blend, double_sided));
pipelines.push(
device.create_render_pipeline(&wgpu::RenderPipelineDescriptor {
label: Some("meshes"),
layout: Some(&layout),
vertex: wgpu::VertexState {
module: &module,
entry_point: Some("vs"),
compilation_options: Default::default(),
buffers: &[Some(wgpu::VertexBufferLayout {
array_stride: size_of::<math::MeshVertex>() as u64,
step_mode: wgpu::VertexStepMode::Vertex,
attributes: &attributes,
})],
},
primitive: wgpu::PrimitiveState {
topology: wgpu::PrimitiveTopology::TriangleList,
front_face: wgpu::FrontFace::Ccw,
cull_mode: if double_sided {
None
} else {
Some(wgpu::Face::Back)
},
..Default::default()
},
depth_stencil: Some(depth_state(true, blend == Blend::Opaque)),
multisample: Default::default(),
fragment: Some(wgpu::FragmentState {
module: &module,
entry_point: Some("fs"),
compilation_options: Default::default(),
targets: &[Some(wgpu::ColorTargetState {
format: color_format,
blend: blend_state(blend),
write_mask: wgpu::ColorWrites::ALL,
})],
}),
multiview_mask: None,
cache: None,
}),
);
}
}
let sampler = device.create_sampler(&wgpu::SamplerDescriptor {
label: Some("mesh texture"),
address_mode_u: wgpu::AddressMode::ClampToEdge,
address_mode_v: wgpu::AddressMode::ClampToEdge,
address_mode_w: wgpu::AddressMode::ClampToEdge,
mag_filter: wgpu::FilterMode::Linear,
min_filter: wgpu::FilterMode::Linear,
mipmap_filter: wgpu::MipmapFilterMode::Linear,
..Default::default()
});
Self {
pipelines,
frame,
slots,
texture_layout,
sampler,
white: None,
meshes: BTreeMap::new(),
next_version: 0,
opaque: Vec::new(),
transparent: Vec::new(),
}
}
pub fn upsert(
&mut self,
device: &wgpu::Device,
queue: &wgpu::Queue,
id: u64,
mesh: &MeshData,
texture: Option<&TextureImage>,
material: Material,
) {
assert!(
texture.is_none() || mesh.uvs.is_some(),
"a textured mesh needs uvs"
);
let packed = pack_mesh(mesh);
let vertices = device.create_buffer_init(&wgpu::util::BufferInitDescriptor {
label: Some("mesh vertices"),
contents: non_empty(bytemuck::cast_slice(&packed.vertices), &[0; 36]),
usage: wgpu::BufferUsages::VERTEX,
});
let indices = device.create_buffer_init(&wgpu::util::BufferInitDescriptor {
label: Some("mesh indices"),
contents: non_empty(bytemuck::cast_slice(&packed.indices), &[0; 4]),
usage: wgpu::BufferUsages::INDEX,
});
let texture = texture.map(|img| self.upload_texture(device, queue, img));
if self.white.is_none() {
let white = math::MipChain {
width: 1,
height: 1,
levels: 1,
data: vec![255; 4],
};
self.white = Some(self.texture_from_chain(device, queue, &white));
}
self.next_version += 1;
let visible = self.meshes.get(&id).is_none_or(|m| m.visible);
self.meshes.insert(
id,
GpuMesh {
vertices,
indices,
index_count: packed.indices.len() as u32,
origin: packed.origin,
texture,
material,
visible,
version: self.next_version,
},
);
if self.slots.reserve(device, self.meshes.len()) {
self.opaque.clear();
self.transparent.clear();
}
}
fn upload_texture(
&self,
device: &wgpu::Device,
queue: &wgpu::Queue,
img: &TextureImage,
) -> (wgpu::Texture, wgpu::BindGroup) {
let chain = math::mip_chain(img, device.limits().max_texture_dimension_2d);
self.texture_from_chain(device, queue, &chain)
}
fn texture_from_chain(
&self,
device: &wgpu::Device,
queue: &wgpu::Queue,
chain: &math::MipChain,
) -> (wgpu::Texture, wgpu::BindGroup) {
let texture = device.create_texture_with_data(
queue,
&wgpu::TextureDescriptor {
label: Some("mesh texture"),
size: wgpu::Extent3d {
width: chain.width,
height: chain.height,
depth_or_array_layers: 1,
},
mip_level_count: chain.levels,
sample_count: 1,
dimension: wgpu::TextureDimension::D2,
format: wgpu::TextureFormat::Rgba8UnormSrgb,
usage: wgpu::TextureUsages::TEXTURE_BINDING | wgpu::TextureUsages::COPY_DST,
view_formats: &[],
},
wgpu::util::TextureDataOrder::LayerMajor,
&chain.data,
);
let view = texture.create_view(&Default::default());
let bg = device.create_bind_group(&wgpu::BindGroupDescriptor {
label: Some("mesh texture"),
layout: &self.texture_layout,
entries: &[
wgpu::BindGroupEntry {
binding: 0,
resource: wgpu::BindingResource::TextureView(&view),
},
wgpu::BindGroupEntry {
binding: 1,
resource: wgpu::BindingResource::Sampler(&self.sampler),
},
],
});
(texture, bg)
}
pub fn set_material(&mut self, id: u64, material: Material) {
if let Some(m) = self.meshes.get_mut(&id) {
m.material = material;
}
}
pub fn set_visible(&mut self, id: u64, visible: bool) {
if let Some(m) = self.meshes.get_mut(&id) {
m.visible = visible;
}
}
pub fn remove(&mut self, id: u64) {
self.meshes.remove(&id);
}
pub fn clear(&mut self) {
self.meshes.clear();
self.opaque.clear();
self.transparent.clear();
}
pub fn len(&self) -> usize {
self.meshes.len()
}
pub fn is_empty(&self) -> bool {
self.len() == 0
}
pub fn prepare(
&mut self,
queue: &wgpu::Queue,
size: [u32; 2],
camera: &Camera,
fog: Option<Fog>,
) {
self.frame.write(queue, size, camera, fog);
let candidates: Vec<Candidate> = self
.meshes
.iter()
.map(|(&id, m)| Candidate {
id,
version: m.version,
visible: m.visible && m.index_count > 0,
blend: m.material.blend,
pipeline: mesh_pipeline(m.material.blend, m.material.double_sided),
distance: (m.origin - camera.eye).length(),
})
.collect();
let (opaque, transparent) = plan(&candidates);
let mut objects = vec![MeshObject::zeroed(); opaque.len() + transparent.len()];
for p in opaque.iter().chain(&transparent) {
let m = &self.meshes[&p.id];
objects[p.slot as usize] = mesh_object(&m.material, m.origin - camera.eye);
}
self.slots.write(queue, &objects);
self.opaque = opaque;
self.transparent = transparent;
}
pub fn draw_opaque(&self, pass: &mut wgpu::RenderPass<'_>) {
self.draw_list(pass, &self.opaque);
}
pub fn draw_transparent(&self, pass: &mut wgpu::RenderPass<'_>) {
self.draw_list(pass, &self.transparent);
}
fn draw_list(&self, pass: &mut wgpu::RenderPass<'_>, list: &[Planned]) {
if list.is_empty() {
return;
}
pass.set_bind_group(0, &self.frame.bg, &[]);
let mut bound = None;
for p in list {
let Some(m) = self.meshes.get(&p.id) else {
continue;
};
if m.version != p.version || !m.visible || m.index_count == 0 {
continue;
}
if bound != Some(p.pipeline) {
pass.set_pipeline(&self.pipelines[p.pipeline]);
bound = Some(p.pipeline);
}
pass.set_bind_group(1, &self.slots.bg, &[self.slots.offset(p.slot)]);
let Some((_, texture)) = m.texture.as_ref().or(self.white.as_ref()) else {
continue;
};
pass.set_bind_group(2, texture, &[]);
pass.set_vertex_buffer(0, m.vertices.slice(..));
pass.set_index_buffer(m.indices.slice(..), wgpu::IndexFormat::Uint32);
pass.draw_indexed(0..m.index_count, 0, 0..1);
}
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum Topology {
List,
Strip,
}
#[derive(Debug, Clone)]
pub struct LineSet {
pub positions: Vec<[f64; 3]>,
pub topology: Topology,
pub colors: Option<Vec<[u8; 4]>>,
pub color: [f32; 4],
pub blend: Blend,
pub depth_test: bool,
}
struct GpuLines {
buffer: wgpu::Buffer,
draw_count: u32,
origin: DVec3,
tint: [f32; 4],
blend: Blend,
depth_test: bool,
topology: Topology,
visible: bool,
version: u64,
}
pub struct LineRenderer {
pipelines: Vec<wgpu::RenderPipeline>,
frame: FrameSlot,
slots: Slots,
sets: BTreeMap<u64, GpuLines>,
next_version: u64,
planned: Vec<Planned>,
}
impl LineRenderer {
pub fn new(device: &wgpu::Device, color_format: wgpu::TextureFormat) -> Self {
let module = shader(device, "pointblitz lines", include_str!("lines.wgsl"));
let frame = FrameSlot::new(device, color_format);
let slots = Slots::new(device, "line objects", size_of::<LineObject>() as u64);
let layout = device.create_pipeline_layout(&wgpu::PipelineLayoutDescriptor {
label: Some("lines"),
bind_group_layouts: &[Some(&frame.layout), Some(&slots.layout)],
immediate_size: 0,
});
let attributes = wgpu::vertex_attr_array![0 => Float32x3, 1 => Unorm8x4];
let mut pipelines = Vec::with_capacity(12);
for blend in [Blend::Opaque, Blend::Alpha, Blend::Additive] {
for depth_test in [false, true] {
for topology in [Topology::List, Topology::Strip] {
debug_assert_eq!(pipelines.len(), line_pipeline(blend, depth_test, topology));
pipelines.push(device.create_render_pipeline(
&wgpu::RenderPipelineDescriptor {
label: Some("lines"),
layout: Some(&layout),
vertex: wgpu::VertexState {
module: &module,
entry_point: Some("vs"),
compilation_options: Default::default(),
buffers: &[Some(wgpu::VertexBufferLayout {
array_stride: size_of::<math::LineVertex>() as u64,
step_mode: wgpu::VertexStepMode::Vertex,
attributes: &attributes,
})],
},
primitive: wgpu::PrimitiveState {
topology: match topology {
Topology::List => wgpu::PrimitiveTopology::LineList,
Topology::Strip => wgpu::PrimitiveTopology::LineStrip,
},
..Default::default()
},
depth_stencil: Some(depth_state(
depth_test,
depth_test && blend == Blend::Opaque,
)),
multisample: Default::default(),
fragment: Some(wgpu::FragmentState {
module: &module,
entry_point: Some("fs"),
compilation_options: Default::default(),
targets: &[Some(wgpu::ColorTargetState {
format: color_format,
blend: blend_state(blend),
write_mask: wgpu::ColorWrites::ALL,
})],
}),
multiview_mask: None,
cache: None,
},
));
}
}
}
Self {
pipelines,
frame,
slots,
sets: BTreeMap::new(),
next_version: 0,
planned: Vec::new(),
}
}
pub fn upsert(&mut self, device: &wgpu::Device, queue: &wgpu::Queue, id: u64, lines: &LineSet) {
let _ = queue;
let packed = pack_lines(lines);
let buffer = device.create_buffer_init(&wgpu::util::BufferInitDescriptor {
label: Some("line vertices"),
contents: non_empty(bytemuck::cast_slice(&packed.vertices), &[0; 16]),
usage: wgpu::BufferUsages::VERTEX,
});
self.next_version += 1;
let visible = self.sets.get(&id).is_none_or(|s| s.visible);
self.sets.insert(
id,
GpuLines {
buffer,
draw_count: packed.draw_count,
origin: packed.origin,
tint: packed.tint,
blend: lines.blend,
depth_test: lines.depth_test,
topology: lines.topology,
visible,
version: self.next_version,
},
);
if self.slots.reserve(device, self.sets.len()) {
self.planned.clear();
}
}
pub fn set_visible(&mut self, id: u64, visible: bool) {
if let Some(s) = self.sets.get_mut(&id) {
s.visible = visible;
}
}
pub fn remove(&mut self, id: u64) {
self.sets.remove(&id);
}
pub fn clear(&mut self) {
self.sets.clear();
self.planned.clear();
}
pub fn len(&self) -> usize {
self.sets.len()
}
pub fn is_empty(&self) -> bool {
self.sets.is_empty()
}
pub fn prepare(
&mut self,
queue: &wgpu::Queue,
size: [u32; 2],
camera: &Camera,
fog: Option<Fog>,
) {
self.frame.write(queue, size, camera, fog);
let candidates: Vec<Candidate> = self
.sets
.iter()
.map(|(&id, s)| Candidate {
id,
version: s.version,
visible: s.visible && s.draw_count > 0,
blend: s.blend,
pipeline: line_pipeline(s.blend, s.depth_test, s.topology),
distance: (s.origin - camera.eye).length(),
})
.collect();
let (opaque, blended) = plan(&candidates);
let mut objects = vec![LineObject::zeroed(); opaque.len() + blended.len()];
let mut planned: Vec<Planned> = opaque.into_iter().chain(blended).collect();
for p in &planned {
let s = &self.sets[&p.id];
let d = (s.origin - camera.eye).as_vec3();
objects[p.slot as usize] = LineObject {
offset: [d.x, d.y, d.z, 0.0],
tint: s.tint,
};
}
planned.sort_by_key(|p| !self.sets[&p.id].depth_test);
self.slots.write(queue, &objects);
self.planned = planned;
}
pub fn draw(&self, pass: &mut wgpu::RenderPass<'_>) {
if self.planned.is_empty() {
return;
}
pass.set_bind_group(0, &self.frame.bg, &[]);
let mut bound = None;
for p in &self.planned {
let Some(s) = self.sets.get(&p.id) else {
continue;
};
if s.version != p.version || !s.visible || s.draw_count == 0 {
continue;
}
if bound != Some(p.pipeline) {
pass.set_pipeline(&self.pipelines[p.pipeline]);
bound = Some(p.pipeline);
}
pass.set_bind_group(1, &self.slots.bg, &[self.slots.offset(p.slot)]);
pass.set_vertex_buffer(0, s.buffer.slice(..));
pass.draw(0..s.draw_count, 0..1);
}
}
}