SeanOMik
/
lyra-engine
1
0
Fork 0
Code Issues 5 Pull Requests Actions Packages Projects Releases Wiki Activity

game: run clippy

This commit is contained in:
SeanOMik 2024-06-28 13:25:48 -04:00
parent 96dea5b1f9
commit 2eeca335e2
Signed by: SeanOMik
GPG Key ID: FEC9E2FC15235964
15 changed files with 83 additions and 83 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
lyra-game/src/events.rs
View File

@ -160,6 +160,10 @@ impl<E: Event> EventReader<E> {
pub fn len(&self) -> usize { pub fn len(&self) -> usize {
self.buf.len() self.buf.len()
} }
pub fn is_empty(&self) -> bool {
self.len() == 0
}
} }
impl<E: Event> Iterator for EventReader<E> { impl<E: Event> Iterator for EventReader<E> {

10
lyra-game/src/input/buttons.rs
View File

@ -92,10 +92,7 @@ impl<T: Button> InputButtons<T> {
pub fn was_just_pressed(&self, button: T) -> bool { pub fn was_just_pressed(&self, button: T) -> bool {
let hash = Self::get_button_hash(&button); let hash = Self::get_button_hash(&button);
match self.button_events.get(&hash) { match self.button_events.get(&hash) {
Some(button_event) => match button_event { Some(button_event) => matches!(button_event, ButtonEvent::JustPressed(b) if button == *b),
ButtonEvent::JustPressed(b) if button == *b => true,
_ => false,
},
None => false None => false
} }
} }
@ -105,11 +102,8 @@ impl<T: Button> InputButtons<T> {
/// This must be done so that a key does not stay as JustPressed between multiple ticks /// This must be done so that a key does not stay as JustPressed between multiple ticks
pub fn update(&mut self) { pub fn update(&mut self) {
for bev in self.button_events.values_mut() { for bev in self.button_events.values_mut() {
match bev { if let ButtonEvent::JustPressed(btn) = bev {
ButtonEvent::JustPressed(btn) => {
*bev = ButtonEvent::Pressed(btn.clone()); *bev = ButtonEvent::Pressed(btn.clone());
},
_ => {},
} }
} }
} }

2
lyra-game/src/render/avec.rs
View File

@ -67,7 +67,7 @@ impl<T> AVec<T> {
#[inline(always)] #[inline(always)]
fn slot_size(&self) -> usize { fn slot_size(&self) -> usize {
let a = self.align - 1; let a = self.align - 1;
mem::align_of::<T>() + (a) & !a (mem::align_of::<T>() + (a)) & !a
} }
/// # Panics /// # Panics

17
lyra-game/src/render/graph/mod.rs
View File

@ -135,7 +135,7 @@ impl RenderGraph {
} }
pub fn device(&self) -> &wgpu::Device { pub fn device(&self) -> &wgpu::Device {
&*self.device &self.device
} }
/// Add a [`Node`] to the RenderGraph. /// Add a [`Node`] to the RenderGraph.
@ -252,7 +252,7 @@ impl RenderGraph {
let mut sorted: VecDeque<RenderGraphLabelValue> = petgraph::algo::toposort(&self.node_graph, None) let mut sorted: VecDeque<RenderGraphLabelValue> = petgraph::algo::toposort(&self.node_graph, None)
.expect("RenderGraph had cycled!") .expect("RenderGraph had cycled!")
.iter() .iter()
.map(|i| self.node_graph[i.clone()].clone()) .map(|i| self.node_graph[*i].clone())
.collect(); .collect();
while let Some(node_label) = sorted.pop_front() { while let Some(node_label) = sorted.pop_front() {
@ -277,14 +277,12 @@ impl RenderGraph {
let slot = self let slot = self
.slots .slots
.get(&bufwr.target_slot) .get(&bufwr.target_slot)
.expect(&format!( .unwrap_or_else(|| panic!("Failed to find slot '{:?}' for buffer write",
"Failed to find slot '{:?}' for buffer write", bufwr.target_slot));
bufwr.target_slot
));
let buf = slot let buf = slot
.value .value
.as_buffer() .as_buffer()
.expect(&format!("Slot '{:?}' is not a buffer", bufwr.target_slot)); .unwrap_or_else(|| panic!("Slot '{:?}' is not a buffer", bufwr.target_slot));
self.queue.write_buffer(buf, bufwr.offset, &bufwr.bytes); self.queue.write_buffer(buf, bufwr.offset, &bufwr.bytes);
} }
@ -302,7 +300,7 @@ impl RenderGraph {
let mut sorted: VecDeque<RenderGraphLabelValue> = petgraph::algo::toposort(&self.node_graph, None) let mut sorted: VecDeque<RenderGraphLabelValue> = petgraph::algo::toposort(&self.node_graph, None)
.expect("RenderGraph had cycled!") .expect("RenderGraph had cycled!")
.iter() .iter()
.map(|i| self.node_graph[i.clone()].clone()) .map(|i| self.node_graph[*i].clone())
.collect(); .collect();
// A bit of 'encoder hot potato' is played using this. // A bit of 'encoder hot potato' is played using this.
@ -361,6 +359,7 @@ impl RenderGraph {
.and_then(|p| { .and_then(|p| {
let v = p.pipeline.borrow(); let v = p.pipeline.borrow();
#[allow(clippy::manual_map)]
match &*v { match &*v {
Some(_) => Some(Ref::map(v, |p| p.as_ref().unwrap())), Some(_) => Some(Ref::map(v, |p| p.as_ref().unwrap())),
None => None, None => None,
@ -527,7 +526,7 @@ impl SubGraphNode {
} }
impl Node for SubGraphNode { impl Node for SubGraphNode {
fn desc<'a, 'b>(&'a mut self, _: &'b mut RenderGraph) -> NodeDesc { fn desc(&mut self, _: &mut RenderGraph) -> NodeDesc {
NodeDesc::new(NodeType::Graph, None, vec![]) NodeDesc::new(NodeType::Graph, None, vec![])
} }

4
lyra-game/src/render/graph/node.rs
View File

@ -161,7 +161,7 @@ impl RenderGraphPipelineInfo {
label: Some(label.to_string()), label: Some(label.to_string()),
bind_group_layouts: bind_group_layouts bind_group_layouts: bind_group_layouts
.into_iter() .into_iter()
.map(|bgl| Rc::new(bgl)) .map(Rc::new)
.collect(), .collect(),
vertex, vertex,
primitive, primitive,
@ -356,7 +356,7 @@ impl NodeDesc {
/// describes all resources the node requires for execution during the `execute` phase. /// describes all resources the node requires for execution during the `execute` phase.
pub trait Node: 'static { pub trait Node: 'static {
/// Retrieve a descriptor of the Node. /// Retrieve a descriptor of the Node.
fn desc<'a, 'b>(&'a mut self, graph: &'b mut RenderGraph) -> NodeDesc; fn desc(&mut self, graph: &mut RenderGraph) -> NodeDesc;
/// Prepare the node for rendering. /// Prepare the node for rendering.
/// ///

6
lyra-game/src/render/graph/passes/base.rs
View File

@ -55,7 +55,7 @@ impl Node for BasePass {
.visibility(wgpu::ShaderStages::COMPUTE) .visibility(wgpu::ShaderStages::COMPUTE)
.buffer_dynamic_offset(false) .buffer_dynamic_offset(false)
.contents(&[self.screen_size]) .contents(&[self.screen_size])
.finish_parts(&graph.device()); .finish_parts(graph.device());
let screen_size_bgl = Rc::new(screen_size_bgl); let screen_size_bgl = Rc::new(screen_size_bgl);
let screen_size_bg = Rc::new(screen_size_bg); let screen_size_bg = Rc::new(screen_size_bg);
@ -65,12 +65,12 @@ impl Node for BasePass {
.visibility(wgpu::ShaderStages::all()) .visibility(wgpu::ShaderStages::all())
.buffer_dynamic_offset(false) .buffer_dynamic_offset(false)
.contents(&[CameraUniform::default()]) .contents(&[CameraUniform::default()])
.finish_parts(&graph.device()); .finish_parts(graph.device());
let camera_bgl = Rc::new(camera_bgl); let camera_bgl = Rc::new(camera_bgl);
let camera_bg = Rc::new(camera_bg); let camera_bg = Rc::new(camera_bg);
// create the depth texture using the utility struct, then take all the required fields // create the depth texture using the utility struct, then take all the required fields
let mut depth_texture = RenderTexture::create_depth_texture(&graph.device(), self.screen_size, "depth_texture"); let mut depth_texture = RenderTexture::create_depth_texture(graph.device(), self.screen_size, "depth_texture");
depth_texture.create_bind_group(&graph.device); depth_texture.create_bind_group(&graph.device);
let dt_bg_pair = depth_texture.bindgroup_pair.unwrap(); let dt_bg_pair = depth_texture.bindgroup_pair.unwrap();

2
lyra-game/src/render/graph/passes/init.rs
View File

@ -10,7 +10,7 @@ pub struct InitNode {
} }
impl Node for InitNode { impl Node for InitNode {
fn desc<'a, 'b>(&'a mut self, _: &'b mut crate::render::graph::RenderGraph) -> crate::render::graph::NodeDesc { fn desc(&mut self, _: &mut crate::render::graph::RenderGraph) -> crate::render::graph::NodeDesc {
let mut desc = NodeDesc::new(NodeType::Node, None, vec![]); let mut desc = NodeDesc::new(NodeType::Node, None, vec![]);
// the slots can just be cloned since the slot attribute doesn't really matter much. // the slots can just be cloned since the slot attribute doesn't really matter much.
desc.slots = self.slots.clone(); desc.slots = self.slots.clone();

2
lyra-game/src/render/graph/passes/light_cull_compute.rs
View File

@ -59,7 +59,7 @@ impl Node for LightCullComputePass {
let light_index_counter_buffer = let light_index_counter_buffer =
device.create_buffer_init(&wgpu::util::BufferInitDescriptor { device.create_buffer_init(&wgpu::util::BufferInitDescriptor {
label: Some("light_index_counter_buffer"), label: Some("light_index_counter_buffer"),
contents: &bytemuck::cast_slice(&[0]), contents: bytemuck::cast_slice(&[0]),
usage: wgpu::BufferUsages::STORAGE | wgpu::BufferUsages::COPY_DST, usage: wgpu::BufferUsages::STORAGE | wgpu::BufferUsages::COPY_DST,
}); });

46
lyra-game/src/render/graph/passes/meshes.rs
View File

@ -174,12 +174,12 @@ impl MeshPass {
let material = self.material_buffers.entry(material.uuid()) let material = self.material_buffers.entry(material.uuid())
.or_insert_with(|| { .or_insert_with(|| {
debug!(uuid=material.uuid().to_string(), "Sending material to gpu"); debug!(uuid=material.uuid().to_string(), "Sending material to gpu");
Rc::new(Material::from_resource(&device, &queue, self.texture_bind_group_layout.clone().unwrap(), &material_ref)) Rc::new(Material::from_resource(device, queue, self.texture_bind_group_layout.clone().unwrap(), &material_ref))
}); });
// TODO: support material uniforms from multiple uniforms // TODO: support material uniforms from multiple uniforms
let uni = MaterialUniform::from(&**material); let uni = MaterialUniform::from(&**material);
queue.write_buffer(&self.material_buffer.as_ref().unwrap(), 0, bytemuck::bytes_of(&uni)); queue.write_buffer(self.material_buffer.as_ref().unwrap(), 0, bytemuck::bytes_of(&uni));
MeshBufferStorage { MeshBufferStorage {
buffer_vertex: vertex_buffer, buffer_vertex: vertex_buffer,
@ -215,7 +215,7 @@ impl Node for MeshPass {
//let transform_bgl = transforms.bindgroup_layout.clone(); //let transform_bgl = transforms.bindgroup_layout.clone();
self.transforms = Some(transforms); self.transforms = Some(transforms);
let texture_bind_group_layout = Rc::new(RenderTexture::create_layout(&device)); let texture_bind_group_layout = Rc::new(RenderTexture::create_layout(device));
self.texture_bind_group_layout = Some(texture_bind_group_layout.clone()); self.texture_bind_group_layout = Some(texture_bind_group_layout.clone());
let (material_bgl, material_bg, material_buf, _) = BufferWrapper::builder() let (material_bgl, material_bg, material_buf, _) = BufferWrapper::builder()
@ -232,7 +232,7 @@ impl Node for MeshPass {
// load the default texture // load the default texture
let bytes = include_bytes!("../../default_texture.png"); let bytes = include_bytes!("../../default_texture.png");
self.default_texture = Some(RenderTexture::from_bytes(&device, &graph.queue, texture_bind_group_layout.clone(), bytes, "default_texture").unwrap()); self.default_texture = Some(RenderTexture::from_bytes(device, &graph.queue, texture_bind_group_layout.clone(), bytes, "default_texture").unwrap());
// get surface config format // get surface config format
/* let main_rt = graph.slot_value(BasePassSlots::MainRenderTarget) /* let main_rt = graph.slot_value(BasePassSlots::MainRenderTarget)
@ -251,7 +251,9 @@ impl Node for MeshPass {
source: include_str!("../../shaders/base.wgsl").to_string(), source: include_str!("../../shaders/base.wgsl").to_string(),
}); */ }); */
let desc = NodeDesc::new(
NodeDesc::new(
NodeType::Render, NodeType::Render,
None, None,
/* Some(PipelineDescriptor::Render(RenderPipelineDescriptor { /* Some(PipelineDescriptor::Render(RenderPipelineDescriptor {
@ -296,9 +298,7 @@ impl Node for MeshPass {
vec![ vec![
(&MeshesPassSlots::Material, material_bg, Some(material_bgl)), (&MeshesPassSlots::Material, material_bg, Some(material_bgl)),
], ],
); )
desc
} }
#[instrument(skip(self, graph, world, context))] #[instrument(skip(self, graph, world, context))]
@ -368,7 +368,7 @@ impl Node for MeshPass {
let transforms = self.transforms.as_mut().unwrap(); let transforms = self.transforms.as_mut().unwrap();
if transforms.needs_expand() { if transforms.needs_expand() {
debug!("Expanding transform buffers"); debug!("Expanding transform buffers");
transforms.expand_buffers(&device); transforms.expand_buffers(device);
} }
} }
@ -377,14 +377,14 @@ impl Node for MeshPass {
// if process mesh did not just create a new mesh, and the epoch // if process mesh did not just create a new mesh, and the epoch
// shows that the scene has changed, verify that the mesh buffers // shows that the scene has changed, verify that the mesh buffers
// dont need to be resent to the gpu. // dont need to be resent to the gpu.
if !self.process_mesh(&device, &queue, entity, &*mesh, mesh_han.uuid()) if !self.process_mesh(device, queue, entity, &mesh, mesh_han.uuid())
&& mesh_epoch == last_epoch { && mesh_epoch == last_epoch {
self.check_mesh_buffers(&device, &queue, &mesh_han); self.check_mesh_buffers(device, queue, &mesh_han);
} }
let transforms = self.transforms.as_mut().unwrap(); let transforms = self.transforms.as_mut().unwrap();
let group = TransformGroup::EntityRes(entity, mesh_han.uuid()); let group = TransformGroup::EntityRes(entity, mesh_han.uuid());
let transform_id = transforms.update_or_push(&device, &queue, &render_limits, let transform_id = transforms.update_or_push(device, queue, &render_limits,
group, interp_transform.calculate_mat4(), glam::Mat3::from_quat(interp_transform.rotation)); group, interp_transform.calculate_mat4(), glam::Mat3::from_quat(interp_transform.rotation));
let material = mesh.material.as_ref().unwrap() let material = mesh.material.as_ref().unwrap()
@ -409,15 +409,15 @@ impl Node for MeshPass {
// if process mesh did not just create a new mesh, and the epoch // if process mesh did not just create a new mesh, and the epoch
// shows that the scene has changed, verify that the mesh buffers // shows that the scene has changed, verify that the mesh buffers
// dont need to be resent to the gpu. // dont need to be resent to the gpu.
if !self.process_mesh(&device, &queue, entity, &*mesh, mesh_han.uuid()) if !self.process_mesh(device, queue, entity, &mesh, mesh_han.uuid())
&& scene_epoch == last_epoch { && scene_epoch == last_epoch {
self.check_mesh_buffers(&device, &queue, &mesh_han); self.check_mesh_buffers(device, queue, &mesh_han);
} }
let transforms = self.transforms.as_mut().unwrap(); let transforms = self.transforms.as_mut().unwrap();
let scene_mesh_group = TransformGroup::Res(scene_han.uuid(), mesh_han.uuid()); let scene_mesh_group = TransformGroup::Res(scene_han.uuid(), mesh_han.uuid());
let group = TransformGroup::OwnedGroup(entity, scene_mesh_group.into()); let group = TransformGroup::OwnedGroup(entity, scene_mesh_group.into());
let transform_id = transforms.update_or_push(&device, &queue, &render_limits, let transform_id = transforms.update_or_push(device, queue, &render_limits,
group, mesh_interpo.calculate_mat4(), glam::Mat3::from_quat(mesh_interpo.rotation) ); group, mesh_interpo.calculate_mat4(), glam::Mat3::from_quat(mesh_interpo.rotation) );
let material = mesh.material.as_ref().unwrap() let material = mesh.material.as_ref().unwrap()
@ -436,7 +436,7 @@ impl Node for MeshPass {
} }
let transforms = self.transforms.as_mut().unwrap(); let transforms = self.transforms.as_mut().unwrap();
transforms.send_to_gpu(&queue); transforms.send_to_gpu(queue);
if self.pipeline.is_none() { if self.pipeline.is_none() {
let device = graph.device(); let device = graph.device();
@ -537,7 +537,7 @@ impl Node for MeshPass {
let mut pass = encoder.begin_render_pass(&wgpu::RenderPassDescriptor { let mut pass = encoder.begin_render_pass(&wgpu::RenderPassDescriptor {
label: Some("Render Pass"), label: Some("Render Pass"),
color_attachments: &[Some(wgpu::RenderPassColorAttachment { color_attachments: &[Some(wgpu::RenderPassColorAttachment {
view: &view, view,
resolve_target: None, resolve_target: None,
ops: wgpu::Operations { ops: wgpu::Operations {
load: wgpu::LoadOp::Clear(wgpu::Color { load: wgpu::LoadOp::Clear(wgpu::Color {
@ -551,7 +551,7 @@ impl Node for MeshPass {
})], })],
// enable depth buffer // enable depth buffer
depth_stencil_attachment: Some(wgpu::RenderPassDepthStencilAttachment { depth_stencil_attachment: Some(wgpu::RenderPassDepthStencilAttachment {
view: &depth_view, view: depth_view,
depth_ops: Some(wgpu::Operations { depth_ops: Some(wgpu::Operations {
load: wgpu::LoadOp::Clear(1.0), load: wgpu::LoadOp::Clear(1.0),
store: true, store: true,
@ -560,7 +560,7 @@ impl Node for MeshPass {
}), }),
}); });
pass.set_pipeline(&pipeline); pass.set_pipeline(pipeline);
//let material_buffer_bg = self.material_buffer.as_ref().unwrap().bindgroup(); //let material_buffer_bg = self.material_buffer.as_ref().unwrap().bindgroup();
let default_texture = self.default_texture.as_ref().unwrap(); let default_texture = self.default_texture.as_ref().unwrap();
@ -596,11 +596,11 @@ impl Node for MeshPass {
let offset = transforms.buffer_offset(job.transform_id); let offset = transforms.buffer_offset(job.transform_id);
pass.set_bind_group(1, bindgroup, &[ offset, ]); pass.set_bind_group(1, bindgroup, &[ offset, ]);
pass.set_bind_group(2, &camera_bg, &[]); pass.set_bind_group(2, camera_bg, &[]);
pass.set_bind_group(3, &lights_bg, &[]); pass.set_bind_group(3, lights_bg, &[]);
pass.set_bind_group(4, &material_bg, &[]); pass.set_bind_group(4, material_bg, &[]);
pass.set_bind_group(6, &light_grid_bg, &[]); pass.set_bind_group(6, light_grid_bg, &[]);
// if this mesh uses indices, use them to draw the mesh // if this mesh uses indices, use them to draw the mesh
if let Some((idx_type, indices)) = buffers.buffer_indices.as_ref() { if let Some((idx_type, indices)) = buffers.buffer_indices.as_ref() {

18
lyra-game/src/render/graph/passes/tint.rs
View File

@ -27,9 +27,9 @@ impl TintPass {
} }
impl Node for TintPass { impl Node for TintPass {
fn desc<'a, 'b>( fn desc(
&'a mut self, &mut self,
graph: &'b mut crate::render::graph::RenderGraph, graph: &mut crate::render::graph::RenderGraph,
) -> crate::render::graph::NodeDesc { ) -> crate::render::graph::NodeDesc {
let device = &graph.device; let device = &graph.device;
@ -64,7 +64,9 @@ impl Node for TintPass {
}); });
let vt = graph.view_target(); let vt = graph.view_target();
let desc = NodeDesc::new(
NodeDesc::new(
NodeType::Render, NodeType::Render,
Some(PipelineDescriptor::Render(RenderPipelineDescriptor { Some(PipelineDescriptor::Render(RenderPipelineDescriptor {
label: Some("tint_pass".into()), label: Some("tint_pass".into()),
@ -90,9 +92,7 @@ impl Node for TintPass {
multiview: None, multiview: None,
})), })),
vec![], vec![],
); )
desc
} }
fn prepare( fn prepare(
@ -148,7 +148,7 @@ impl Node for TintPass {
let mut pass = encoder.begin_render_pass(&wgpu::RenderPassDescriptor { let mut pass = encoder.begin_render_pass(&wgpu::RenderPassDescriptor {
label: Some("tint_pass"), label: Some("tint_pass"),
color_attachments: &[Some(wgpu::RenderPassColorAttachment { color_attachments: &[Some(wgpu::RenderPassColorAttachment {
view: &dest_view, view: dest_view,
resolve_target: None, resolve_target: None,
ops: wgpu::Operations { ops: wgpu::Operations {
load: wgpu::LoadOp::Load, load: wgpu::LoadOp::Load,
@ -157,7 +157,7 @@ impl Node for TintPass {
})], })],
depth_stencil_attachment: None, depth_stencil_attachment: None,
}); });
pass.set_pipeline(&pipeline.as_render()); pass.set_pipeline(pipeline.as_render());
pass.set_bind_group(0, bg, &[]); pass.set_bind_group(0, bg, &[]);
pass.draw(0..3, 0..1); pass.draw(0..3, 0..1);

4
lyra-game/src/render/render_buffer.rs
View File

@ -116,9 +116,9 @@ impl BufferWrapper {
/// match the layout of this bind group. /// match the layout of this bind group.
/// ///
/// See [`wgpu::RenderPass::set_bind_group`](https://docs.rs/wgpu/latest/wgpu/struct.RenderPass.html#method.set_bind_group). /// See [`wgpu::RenderPass::set_bind_group`](https://docs.rs/wgpu/latest/wgpu/struct.RenderPass.html#method.set_bind_group).
pub fn render_pass_bind_at<'a, 'b>( pub fn render_pass_bind_at<'a>(
&'a self, &'a self,
pass: &'b mut wgpu::RenderPass<'a>, pass: &mut wgpu::RenderPass<'a>,
index: u32, index: u32,
offsets: &[wgpu::DynamicOffset], offsets: &[wgpu::DynamicOffset],
) { ) {

2
lyra-game/src/render/resource/compute_pipeline.rs
View File

@ -74,7 +74,7 @@ impl ComputePipeline {
// they share the same shader. I tried to do it without an Rc but couldn't get past // they share the same shader. I tried to do it without an Rc but couldn't get past
// the borrow checker // the borrow checker
let compiled_shader = Rc::new(device.create_shader_module(wgpu::ShaderModuleDescriptor { let compiled_shader = Rc::new(device.create_shader_module(wgpu::ShaderModuleDescriptor {
label: desc.shader.label.as_ref().map(|s| s.as_str()), label: desc.shader.label.as_deref(),
source: wgpu::ShaderSource::Wgsl(std::borrow::Cow::Borrowed( source: wgpu::ShaderSource::Wgsl(std::borrow::Cow::Borrowed(
&desc.shader.source, &desc.shader.source,
)), )),

16
lyra-game/src/render/resource/pipeline.rs
View File

@ -27,19 +27,19 @@ pub enum Pipeline {
Compute(ComputePipeline), Compute(ComputePipeline),
} }
impl Into<RenderPipeline> for Pipeline { impl From<Pipeline> for RenderPipeline {
fn into(self) -> RenderPipeline { fn from(val: Pipeline) -> Self {
match self { match val {
Self::Render(r) => r, Pipeline::Render(r) => r,
_ => panic!("Pipeline is not a RenderPipeline"), _ => panic!("Pipeline is not a RenderPipeline"),
} }
} }
} }
impl Into<ComputePipeline> for Pipeline { impl From<Pipeline> for ComputePipeline {
fn into(self) -> ComputePipeline { fn from(val: Pipeline) -> Self {
match self { match val {
Self::Compute(c) => c, Pipeline::Compute(c) => c,
_ => panic!("Pipeline is not a RenderPipeline"), _ => panic!("Pipeline is not a RenderPipeline"),
} }
} }

6
lyra-game/src/render/resource/render_pipeline.rs
View File

@ -88,13 +88,13 @@ impl RenderPipeline {
// they share the same shader. I tried to do it without an Rc but couldn't get past // they share the same shader. I tried to do it without an Rc but couldn't get past
// the borrow checker // the borrow checker
let vrtx_shad = Rc::new(device.create_shader_module(wgpu::ShaderModuleDescriptor { let vrtx_shad = Rc::new(device.create_shader_module(wgpu::ShaderModuleDescriptor {
label: desc.vertex.module.label.as_ref().map(|s| s.as_str()), label: desc.vertex.module.label.as_deref(),
source: wgpu::ShaderSource::Wgsl(std::borrow::Cow::Borrowed( source: wgpu::ShaderSource::Wgsl(std::borrow::Cow::Borrowed(
&desc.vertex.module.source, &desc.vertex.module.source,
)), )),
})); }));
let vrtx_state = wgpu::VertexState { let vrtx_state = wgpu::VertexState {
module: &*vrtx_shad, module: &vrtx_shad,
entry_point: &desc.vertex.entry_point, entry_point: &desc.vertex.entry_point,
buffers: &vrtx_buffs, buffers: &vrtx_buffs,
}; };
@ -104,7 +104,7 @@ impl RenderPipeline {
vrtx_shad.clone() vrtx_shad.clone()
} else { } else {
Rc::new(device.create_shader_module(wgpu::ShaderModuleDescriptor { Rc::new(device.create_shader_module(wgpu::ShaderModuleDescriptor {
label: f.module.label.as_ref().map(|s| s.as_str()), label: f.module.label.as_deref(),
source: wgpu::ShaderSource::Wgsl(std::borrow::Cow::Borrowed(&f.module.source)), source: wgpu::ShaderSource::Wgsl(std::borrow::Cow::Borrowed(&f.module.source)),
})) }))
} }

17
lyra-game/src/render/transform_buffer_storage.rs
View File

@ -106,16 +106,19 @@ impl<K: Hash + Eq + PartialEq + Clone, V: Clone, S: BuildHasher> CachedValMap<K,
where where
F: FnMut() -> V F: FnMut() -> V
{ {
if self.latest.contains_key(&key) { match self.latest.entry(key) {
self.latest.insert(key, val_fn()); std::collections::hash_map::Entry::Occupied(mut e) => {
e.insert(val_fn());
None None
} else { }
std::collections::hash_map::Entry::Vacant(e) => {
let val = self.dead.pop_front() let val = self.dead.pop_front()
.unwrap_or_else(val_fn); .unwrap_or_else(val_fn);
self.latest.insert(key, val.clone()); e.insert(val.clone());
Some(val) Some(val)
} }
} }
}
/// Returns a reference to the value corresponding to the key. /// Returns a reference to the value corresponding to the key.
pub fn get(&mut self, key: K) -> Option<&V> { pub fn get(&mut self, key: K) -> Option<&V> {
@ -217,7 +220,7 @@ impl TransformBuffers {
entry.len = 0; entry.len = 0;
let p = entry.transforms.as_ptr(); let p = entry.transforms.as_ptr();
let bytes = unsafe { std::slice::from_raw_parts(p as *const u8, entry.transforms.len() * entry.transforms.align()) }; let bytes = unsafe { std::slice::from_raw_parts(p, entry.transforms.len() * entry.transforms.align()) };
queue.write_buffer(&entry.buffer, 0, bytes); queue.write_buffer(&entry.buffer, 0, bytes);
} }
@ -334,9 +337,9 @@ impl TransformBuffers {
pub fn buffer_offset(&self, transform_index: TransformIndex) -> u32 { pub fn buffer_offset(&self, transform_index: TransformIndex) -> u32 {
//Self::get_buffer_offset(&self.limits, transform_index) //Self::get_buffer_offset(&self.limits, transform_index)
let transform_index = transform_index.transform_index % self.max_transform_count; let transform_index = transform_index.transform_index % self.max_transform_count;
let t = transform_index as u32 * self.limits.min_uniform_buffer_offset_alignment as u32;
//debug!("offset: {t}"); //debug!("offset: {t}");
t transform_index as u32 * self.limits.min_uniform_buffer_offset_alignment
} }
/// Returns a boolean indicating if the buffers need to be expanded /// Returns a boolean indicating if the buffers need to be expanded