revert unnecessary changes, cleanup

bevyengine · Oct 6, 2020 · 32b8ad9 · 32b8ad9
1 parent 2dd2c5d
commit 32b8ad9
Show file tree

Hide file tree

Showing 31 changed files with 138 additions and 187 deletions.
diff --git a/crates/bevy_pbr/src/render_graph/forward_pipeline/mod.rs b/crates/bevy_pbr/src/render_graph/forward_pipeline/mod.rs
@@ -51,12 +51,10 @@ pub(crate) fn build_forward_pipeline(shaders: &mut Assets<Shader>) -> PipelineDe
             vertex: shaders.add(Shader::from_glsl(
                 ShaderStage::Vertex,
                 include_str!("forward.vert"),
-                None,
             )),
             fragment: Some(shaders.add(Shader::from_glsl(
                 ShaderStage::Fragment,
                 include_str!("forward.frag"),
-                None,
             ))),
         })
     }

diff --git a/crates/bevy_render/src/pipeline/bind_group.rs b/crates/bevy_render/src/pipeline/bind_group.rs
@@ -10,7 +10,7 @@ pub struct BindGroupDescriptor {
 }
 
 #[derive(Hash, Copy, Clone, Eq, PartialEq, Debug)]
-pub struct BindGroupDescriptorId(pub u64);
+pub struct BindGroupDescriptorId(u64);
 
 impl BindGroupDescriptor {
     pub fn new(index: u32, bindings: Vec<BindingDescriptor>) -> Self {

diff --git a/crates/bevy_render/src/pipeline/pipeline.rs b/crates/bevy_render/src/pipeline/pipeline.rs
@@ -4,16 +4,10 @@ use super::{
         CompareFunction, CullMode, DepthStencilStateDescriptor, FrontFace, IndexFormat,
         PrimitiveTopology, RasterizationStateDescriptor, StencilStateFaceDescriptor,
     },
-    BindGroupDescriptor, BindType, BindingDescriptor, BindingShaderStage, DynamicBinding,
-    InputStepMode, PipelineLayout, StencilStateDescriptor, VertexAttributeDescriptor,
-    VertexBufferDescriptor, VertexBufferDescriptors, VertexFormat,
+    BindType, DynamicBinding, PipelineLayout, StencilStateDescriptor, VertexBufferDescriptors,
 };
-use crate::pipeline::pipeline_layout::UniformProperty;
-use crate::texture::{TextureComponentType, TextureViewDimension};
-use std::borrow::Cow;
-
 use crate::{
-    shader::{Shader, ShaderLayout, ShaderStages},
+    shader::{Shader, ShaderStages},
     texture::TextureFormat,
 };
 use bevy_asset::Assets;
@@ -145,16 +139,10 @@ impl PipelineDescriptor {
             .as_ref()
             .map(|handle| shaders.get(&handle).unwrap());
 
-        let mut layouts = {
-            let mut layouts = vec![vertex_spirv.reflect_layout(bevy_conventions).unwrap()];
-            log::info!("vertex shader layout: {:#?}", layouts[0]);
-            if let Some(ref fragment_spirv) = fragment_spirv {
-                layouts.push(fragment_spirv.reflect_layout(bevy_conventions).unwrap());
-                log::info!("fragment shader layout: {:#?}", layouts[1]);
-            };
-
-            layouts
-        };
+        let mut layouts = vec![vertex_spirv.reflect_layout(bevy_conventions).unwrap()];
+        if let Some(ref fragment_spirv) = fragment_spirv {
+            layouts.push(fragment_spirv.reflect_layout(bevy_conventions).unwrap());
+        }
 
         let mut layout = PipelineLayout::from_shader_layouts(&mut layouts);
         if let Some(vertex_buffer_descriptors) = vertex_buffer_descriptors {
@@ -187,6 +175,7 @@ impl PipelineDescriptor {
                 }
             }
         }
+
         self.layout = Some(layout);
     }
 }
diff --git a/crates/bevy_render/src/pipeline/render_pipelines.rs b/crates/bevy_render/src/pipeline/render_pipelines.rs
@@ -83,6 +83,7 @@ pub fn draw_render_pipelines_system(
         if !draw.is_visible {
             continue;
         }
+
         let mesh = meshes.get(mesh_handle).unwrap();
         let (index_range, index_format) = match mesh.indices.as_ref() {
             Some(Indices::U32(indices)) => (Some(0..indices.len() as u32), IndexFormat::Uint32),

diff --git a/crates/bevy_render/src/pipeline/vertex_format.rs b/crates/bevy_render/src/pipeline/vertex_format.rs
@@ -71,7 +71,7 @@ impl VertexFormat {
     }
     pub fn get_size(&self) -> u64 {
         let (component_size, components) = self.get_sizes();
-        return (component_size * components) as u64
+        return (component_size * components) as u64;
     }
 }
 

diff --git a/crates/bevy_render/src/render_graph/edge.rs b/crates/bevy_render/src/render_graph/edge.rs
@@ -1,6 +1,4 @@
-use super::{NodeId, NodeState};
-use bevy_utils::HashMap;
-use std::borrow::Cow;
+use super::NodeId;
 
 #[derive(Clone, Debug, Eq, PartialEq)]
 pub enum Edge {
@@ -30,30 +28,4 @@ impl Edge {
             Edge::NodeEdge { output_node, .. } => *output_node,
         }
     }
-
-    pub fn fmt_as_output_edge(
-        &self,
-        f: &mut std::fmt::Formatter<'_>,
-        nodes: &HashMap<NodeId, NodeState>,
-    ) -> std::fmt::Result {
-        match self {
-            Edge::SlotEdge { input_index, output_index, .. } => write!(f, " SlotEdge(in #{}, out #{}", input_index, output_index)?,
-            Edge::NodeEdge { .. } => write!(f, " NodeEdge(")?,
-        }
-        let node = nodes.get(&self.get_input_node()).unwrap();
-        write!(f, "{:?})", node)
-    }
-
-    pub fn fmt_as_input_edge(
-        &self,
-        f: &mut std::fmt::Formatter<'_>,
-        nodes: &HashMap<NodeId, NodeState>,
-    ) -> std::fmt::Result {
-        match self {
-            Edge::SlotEdge { input_index, output_index, .. } => write!(f, " SlotEdge( in #{}, out #{}, ", input_index, output_index)?,
-            Edge::NodeEdge {..} => write!(f, " NodeEdge(")?,
-        }
-        let node = nodes.get(&self.get_output_node()).unwrap();
-        write!(f, "{:?})", node)
-    }
 }
diff --git a/crates/bevy_render/src/render_graph/graph.rs b/crates/bevy_render/src/render_graph/graph.rs
@@ -283,19 +283,9 @@ impl RenderGraph {
 impl Debug for RenderGraph {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         for node in self.iter_nodes() {
-            writeln!(f, "node: {:?} {:?}", node.id, node.name)?;
+            writeln!(f, "{:?}", node.id)?;
             writeln!(f, "  in: {:?}", node.input_slots)?;
             writeln!(f, "  out: {:?}", node.output_slots)?;
-            write!(f, "  in edges:");
-            for edge in &node.edges.input_edges {
-                edge.fmt_as_input_edge(f, &self.nodes);
-            };
-            writeln!(f, "");
-            write!(f, "  out edges:");
-            for edge in &node.edges.output_edges {
-                edge.fmt_as_output_edge(f, &self.nodes);
-            };
-            writeln!(f, "");
         }
 
         Ok(())

diff --git a/crates/bevy_render/src/render_graph/nodes/camera_node.rs b/crates/bevy_render/src/render_graph/nodes/camera_node.rs
@@ -86,6 +86,7 @@ pub fn camera_node_system(
         } else {
             return;
         };
+
     let staging_buffer = if let Some(staging_buffer) = state.staging_buffer {
         render_resource_context.map_buffer(staging_buffer);
         staging_buffer

diff --git a/crates/bevy_render/src/render_graph/nodes/pass_node.rs b/crates/bevy_render/src/render_graph/nodes/pass_node.rs
@@ -182,14 +182,14 @@ where
                     } else {
                         continue;
                     };
+
                     // get an ordered list of entities visible to the camera
                     let visible_entities = if let Some(camera_entity) = active_cameras.get(&camera_info.name) {
                         world.get::<VisibleEntities>(camera_entity).unwrap()
                     } else {
                         continue;
                     };
-                    let cnt = visible_entities.iter().count();
-                    // log::info!("visible entities:{:?}", cnt);
+
                     // attempt to draw each visible entity
                     let mut draw_state = DrawState::default();
                     for visible_entity in visible_entities.iter() {
@@ -209,7 +209,7 @@ where
                         if !draw.is_visible {
                             continue;
                         }
-                        // log::info!("render_commands: {:?}", draw.render_commands);
+
                         // each Draw component contains an ordered list of render commands. we turn those into actual render commands here
                         for render_command in draw.render_commands.iter() {
                             match render_command {
@@ -245,14 +245,14 @@ where
                                             instances.clone(),
                                         );
                                     } else {
-                                        log::info!("Could not draw indexed because the pipeline layout wasn't fully set for pipeline: {:?}", draw_state);
+                                        log::info!("Could not draw indexed because the pipeline layout wasn't fully set for pipeline: {:?}", draw_state.pipeline);
                                     }
                                 }
                                 RenderCommand::Draw { vertices, instances } => {
                                     if draw_state.can_draw() {
                                         render_pass.draw(vertices.clone(), instances.clone());
                                     } else {
-                                        log::info!("Could not draw because the pipeline layout wasn't fully set for pipeline: {:?}", draw_state);
+                                        log::info!("Could not draw because the pipeline layout wasn't fully set for pipeline: {:?}", draw_state.pipeline);
                                     }
                                 }
                                 RenderCommand::SetVertexBuffer {
@@ -295,7 +295,7 @@ where
 }
 
 /// Tracks the current pipeline state to ensure draw calls are valid.
-#[derive(Default, Debug)]
+#[derive(Default)]
 struct DrawState {
     pipeline: Option<Handle<PipelineDescriptor>>,
     bind_groups: Vec<Option<BindGroupId>>,
@@ -306,17 +306,14 @@ struct DrawState {
 impl DrawState {
     pub fn set_bind_group(&mut self, index: u32, bind_group: BindGroupId) {
         self.bind_groups[index as usize] = Some(bind_group);
-//        log::info!("draw_state: {:?}",  self);
     }
 
     pub fn set_vertex_buffer(&mut self, index: u32, buffer: BufferId) {
         self.vertex_buffers[index as usize] = Some(buffer);
-//        log::info!("draw_state: {:?}",  self);
     }
 
     pub fn set_index_buffer(&mut self, buffer: BufferId) {
         self.index_buffer = Some(buffer);
-//        log::info!("draw_state: {:?}",  self);
     }
 
     pub fn can_draw(&self) -> bool {

diff --git a/crates/bevy_render/src/render_graph/nodes/render_resources_node.rs b/crates/bevy_render/src/render_graph/nodes/render_resources_node.rs
@@ -244,13 +244,6 @@ where
         render_resource_bindings: &mut RenderResourceBindings,
         staging_buffer: &mut [u8],
     ) {
-        // log::info!(
-        //     "write uniform buffer for {:?}, dynamic: {:?}, uniforms.len: {}",
-        //     std::any::type_name::<T>(),
-        //     dynamic_uniforms,
-        //     uniforms.iter().count(),
-        // );
-        // log::info!("render_resource_bindings: {:#?}", render_resource_bindings);
         for (i, render_resource) in uniforms.iter().enumerate() {
             match render_resource.resource_type() {
                 Some(RenderResourceType::Buffer) => {
@@ -305,10 +298,7 @@ where
                                 uniforms.get_render_resource_hints(i)
                             {
                                 if render_resource_hints.contains(RenderResourceHints::BUFFER) {
-                                    usage = BufferUsage::STORAGE;
-                                    // if min_size == 112 {
-                                    //     min_size = 4096;
-                                    // }
+                                    usage = BufferUsage::STORAGE
                                 }
                             }
 
@@ -410,7 +400,7 @@ where
 
 impl<T> SystemNode for RenderResourcesNode<T>
 where
-    T: renderer::RenderResources + std::fmt::Debug,
+    T: renderer::RenderResources,
 {
     fn get_system(&self, commands: &mut Commands) -> Box<dyn System> {
         let system = render_resources_node_system::<T>.system();
@@ -447,9 +437,7 @@ fn render_resources_node_system<T: RenderResources>(
     mut state: Local<RenderResourcesNodeState<Entity, T>>,
     render_resource_context: Res<Box<dyn RenderResourceContext>>,
     mut query: Query<(Entity, &T, &Draw, &mut RenderPipelines)>,
-) where
-    T: std::fmt::Debug,
-{
+) {
     let state = state.deref_mut();
     let uniform_buffer_arrays = &mut state.uniform_buffer_arrays;
     let render_resource_context = &**render_resource_context;

diff --git a/crates/bevy_render/src/renderer/render_resource/bind_group.rs b/crates/bevy_render/src/renderer/render_resource/bind_group.rs
@@ -72,6 +72,23 @@ impl BindGroupBuilder {
         )
     }
 
+    pub fn add_dynamic_buffer(
+        self,
+        index: u32,
+        buffer: BufferId,
+        range: Range<u64>,
+        dynamic_index: u32,
+    ) -> Self {
+        self.add_binding(
+            index,
+            RenderResourceBinding::Buffer {
+                buffer,
+                range,
+                dynamic_index: Some(dynamic_index),
+            },
+        )
+    }
+
     pub fn finish(mut self) -> BindGroup {
         // this sort ensures that RenderResourceSets are insertion-order independent
         self.indexed_bindings.sort_by_key(|i| i.index);

diff --git a/crates/bevy_render/src/shader/shader.rs b/crates/bevy_render/src/shader/shader.rs
@@ -118,9 +118,16 @@ impl Shader {
         Shader { stage, source }
     }
 
-    pub fn from_glsl(stage: ShaderStage, glsl: &str, layout: Option<ShaderLayout>) -> Shader {
+    pub fn from_glsl(stage: ShaderStage, glsl: &str) -> Shader {
         Shader {
-            source: ShaderSource::Glsl(glsl.to_string(), layout),
+            source: ShaderSource::Glsl(glsl.to_string(), None),
+            stage,
+        }
+    }
+
+    pub fn from_glsl_and_layout(stage: ShaderStage, glsl: &str, layout: ShaderLayout) -> Shader {
+        Shader {
+            source: ShaderSource::Glsl(glsl.to_string(), Some(layout)),
             stage,
         }
     }

diff --git a/crates/bevy_render/src/shader/shader_reflect.rs b/crates/bevy_render/src/shader/shader_reflect.rs
@@ -404,7 +404,6 @@ mod tests {
                 gl_Position = ViewProj * v_Position;
             }
         "#,
-            None,
         )
         .get_spirv_shader(None);
 
@@ -498,7 +497,6 @@ mod tests {
                 gl_Position = ViewProj * v_Position;
             }
         "#,
-            None,
         )
         .get_spirv_shader(None);
 

diff --git a/crates/bevy_sprite/src/render/mod.rs b/crates/bevy_sprite/src/render/mod.rs
@@ -204,15 +204,15 @@ pub fn build_sprite_sheet_pipeline(shaders: &mut Assets<Shader>) -> PipelineDesc
             write_mask: ColorWrite::ALL,
         }],
         ..PipelineDescriptor::new(ShaderStages {
-            vertex: shaders.add(Shader::from_glsl(
+            vertex: shaders.add(Shader::from_glsl_and_layout(
                 ShaderStage::Vertex,
                 glsl_source!("sprite_sheet.vert"),
-                Some(vert_layout),
+                vert_layout,
             )),
-            fragment: Some(shaders.add(Shader::from_glsl(
+            fragment: Some(shaders.add(Shader::from_glsl_and_layout(
                 ShaderStage::Fragment,
                 glsl_source!("sprite_sheet.frag"),
-                Some(frag_layout),
+                frag_layout,
             ))),
         })
     }
@@ -364,15 +364,15 @@ pub fn build_sprite_pipeline(shaders: &mut Assets<Shader>) -> PipelineDescriptor
             write_mask: ColorWrite::ALL,
         }],
         ..PipelineDescriptor::new(ShaderStages {
-            vertex: shaders.add(Shader::from_glsl(
+            vertex: shaders.add(Shader::from_glsl_and_layout(
                 ShaderStage::Vertex,
                 glsl_source!("sprite.vert"),
-                Some(vert_layout),
+                vert_layout,
             )),
-            fragment: Some(shaders.add(Shader::from_glsl(
+            fragment: Some(shaders.add(Shader::from_glsl_and_layout(
                 ShaderStage::Fragment,
                 glsl_source!("sprite.frag"),
-                Some(frag_layout),
+                frag_layout,
             ))),
         })
     }

diff --git a/crates/bevy_sprite/src/render/sprite_sheet.vert b/crates/bevy_sprite/src/render/sprite_sheet.vert
@@ -42,7 +42,7 @@ void main() {
     vec2 atlas_positions[4] = vec2[](
         vec2(sprite_rect.begin.x, sprite_rect.end.y),
         sprite_rect.begin,
-        vec2(sprite_rect.end.x, sprite_rect.begin.y),
+        vec2(sprite_rect.end.x, sprite_rect.begin.y), 
         sprite_rect.end
     );
     v_Uv = (atlas_positions[gl_VertexIndex] + vec2(0.01, 0.01)) / AtlasSize;

diff --git a/crates/bevy_sprite/src/render/v300/sprite.frag b/crates/bevy_sprite/src/render/v300/sprite.frag
@@ -19,4 +19,4 @@ void main() {
         v_Uv
     );
     o_Target = color;
-}
+}
diff --git a/crates/bevy_sprite/src/render/v300/sprite_sheet.frag b/crates/bevy_sprite/src/render/v300/sprite_sheet.frag
@@ -14,4 +14,4 @@ void main() {
     o_Target = v_Color * texture(
         TextureAtlas_texture,
         v_Uv);
-}
+}
diff --git a/crates/bevy_sprite/src/render/v300/sprite_sheet.vert b/crates/bevy_sprite/src/render/v300/sprite_sheet.vert
@@ -48,4 +48,4 @@ void main() {
     v_Uv = (atlas_positions[gl_VertexID] + vec2(0.01, 0.01)) / AtlasSize;
     v_Color = TextureAtlasSprite_color;
     gl_Position = ViewProj * SpriteTransform * vec4(ceil(vertex_position), 1.0);
-}
+}