Fix comment indentation style

pipelined/bevy_core_pipeline/src/main_pass_3d.rs

@@ -59,7 +59,7 @@ impl Node for MainPass3dNode {
             let pass_descriptor = RenderPassDescriptor {
                 label: Some("main_opaque_pass_3d"),
                 // NOTE: The opaque pass clears and initializes the color
-                //       buffer as well as writing to it.
+                // buffer as well as writing to it.
                 color_attachments: &[target.get_color_attachment(Operations {
                     load: LoadOp::Clear(clear_color.0.into()),
                     store: true,
@@ -135,8 +135,8 @@ impl Node for MainPass3dNode {
                 depth_stencil_attachment: Some(RenderPassDepthStencilAttachment {
                     view: &depth.view,
                     // NOTE: For the transparent pass we load the depth buffer but do not write to it.
-                    //       As the opaque and alpha mask passes run first, opaque meshes can occlude
-                    //       transparent ones.
+                    // As the opaque and alpha mask passes run first, opaque meshes can occlude
+                    // transparent ones.
                     depth_ops: Some(Operations {
                         load: LoadOp::Load,
                         store: false,

pipelined/bevy_pbr2/src/lib.rs

@@ -64,7 +64,7 @@ impl Plugin for PbrPlugin {
             .add_system_to_stage(
                 CoreStage::PostUpdate,
                 // NOTE: Clusters need to have been added before update_clusters is run so
-                //       add as an exclusive system
+                // add as an exclusive system
                 add_clusters
                     .exclusive_system()
                     .label(SimulationLightSystems::AddClusters),

pipelined/bevy_pbr2/src/light.rs

@@ -587,7 +587,7 @@ pub fn update_point_light_frusta(
 
 pub fn check_light_mesh_visibility(
     // NOTE: VisiblePointLights is an alias for VisibleEntities so the Without<DirectionalLight>
-    //       is needed to avoid an unnecessary QuerySet
+    // is needed to avoid an unnecessary QuerySet
     visible_point_lights: Query<&VisiblePointLights, Without<DirectionalLight>>,
     mut point_lights: Query<(
         &PointLight,

pipelined/bevy_pbr2/src/render/light.rs

@@ -139,7 +139,7 @@ pub struct GpuLights {
 // NOTE: this must be kept in sync with the same constants in pbr.frag
 pub const MAX_POINT_LIGHTS: usize = 256;
 // FIXME: How should we handle shadows for clustered forward? Limiting to maximum 10
-//        point light shadow maps for now
+// point light shadow maps for now
 pub const MAX_POINT_LIGHT_SHADOW_MAPS: usize = 10;
 pub const MAX_DIRECTIONAL_LIGHTS: usize = 1;
 pub const POINT_SHADOW_LAYERS: u32 = (6 * MAX_POINT_LIGHT_SHADOW_MAPS) as u32;
@@ -730,7 +730,7 @@ pub fn prepare_lights(
             let intensity = light.illuminance * exposure;
 
             // NOTE: A directional light seems to have to have an eye position on the line along the direction of the light
-            //       through the world origin. I (Rob Swain) do not yet understand why it cannot be translated away from this.
+            // through the world origin. I (Rob Swain) do not yet understand why it cannot be translated away from this.
             let view = Mat4::look_at_rh(Vec3::ZERO, light.direction, Vec3::Y);
             // NOTE: This orthographic projection defines the volume within which shadows from a directional light can be cast
             let projection = light.projection;
@@ -842,14 +842,14 @@ const CLUSTER_COUNT_MASK: u32 = (1 << 8) - 1;
 const POINT_LIGHT_INDEX_MASK: u32 = (1 << 8) - 1;
 
 // NOTE: With uniform buffer max binding size as 16384 bytes
-//       that means we can fit say 128 point lights in one uniform
-//       buffer, which means the count can be at most 128 so it
-//       needs 7 bits, use 8 for convenience.
-//       The array of indices can also use u8 and that means the
-//       offset in to the array of indices needs to be able to address
-//       16384 values. lod2(16384) = 21 bits.
-//       This means we can pack the offset into the upper 24 bits of a u32
-//       and the count into the lower 8 bits.
+// that means we can fit say 128 point lights in one uniform
+// buffer, which means the count can be at most 128 so it
+// needs 7 bits, use 8 for convenience.
+// The array of indices can also use u8 and that means the
+// offset in to the array of indices needs to be able to address
+// 16384 values. lod2(16384) = 21 bits.
+// This means we can pack the offset into the upper 24 bits of a u32
+// and the count into the lower 8 bits.
 // FIXME: Probably there are endianness concerns here????!!!!!
 fn pack_offset_and_count(offset: usize, count: usize) -> u32 {
     ((offset as u32 & CLUSTER_OFFSET_MASK) << CLUSTER_COUNT_SIZE)
@@ -1024,7 +1024,7 @@ pub fn queue_shadows(
                     .get(*face_index),
             };
             // NOTE: Lights with shadow mapping disabled will have no visible entities
-            //       so no meshes will be queued
+            // so no meshes will be queued
             for entity in visible_entities.iter().copied() {
                 let mut key = ShadowPipelineKey::empty();
                 if let Ok(mesh_handle) = casting_meshes.get(entity) {

pipelined/bevy_pbr2/src/render/mesh.rs

@@ -249,7 +249,7 @@ impl FromWorld for MeshPipeline {
                         ty: BufferBindingType::Uniform,
                         has_dynamic_offset: false,
                         // NOTE: Static size for uniform buffers. GpuPointLight has a padded
-                        //       size of 128 bytes, so 16384 / 128 = 128 point lights max
+                        // size of 128 bytes, so 16384 / 128 = 128 point lights max
                         min_binding_size: BufferSize::new(16384),
                     },
                     count: None,
@@ -262,7 +262,7 @@ impl FromWorld for MeshPipeline {
                         ty: BufferBindingType::Uniform,
                         has_dynamic_offset: false,
                         // NOTE: With 128 point lights max, indices need 7 bits. Use u8 for
-                        //       convenience.
+                        // convenience.
                         min_binding_size: BufferSize::new(16384),
                     },
                     count: None,
@@ -275,9 +275,9 @@ impl FromWorld for MeshPipeline {
                         ty: BufferBindingType::Uniform,
                         has_dynamic_offset: false,
                         // NOTE: The offset needs to address 16384 indices, which needs 21 bits.
-                        //       The count can be at most all 128 lights so 7 bits.
-                        //       Pack the offset into the upper 24 bits and the count into the
-                        //       lower 8 bits for convenience.
+                        // The count can be at most all 128 lights so 7 bits.
+                        // Pack the offset into the upper 24 bits and the count into the
+                        // lower 8 bits for convenience.
                         min_binding_size: BufferSize::new(16384),
                     },
                     count: None,

pipelined/bevy_pbr2/src/render/pbr.wgsl

@@ -365,18 +365,18 @@ fn fetch_point_shadow(light_id: u32, frag_position: vec4<f32>, surface_normal: v
     let major_axis_magnitude = max(abs_position_ls.x, max(abs_position_ls.y, abs_position_ls.z));
 
     // NOTE: These simplifications come from multiplying:
-    //       projection * vec4(0, 0, -major_axis_magnitude, 1.0)
-    //       and keeping only the terms that have any impact on the depth.
+    // projection * vec4(0, 0, -major_axis_magnitude, 1.0)
+    // and keeping only the terms that have any impact on the depth.
     // Projection-agnostic approach:
     let zw = -major_axis_magnitude * light.projection_lr.xy + light.projection_lr.zw;
     let depth = zw.x / zw.y;
 
     // do the lookup, using HW PCF and comparison
     // NOTE: Due to the non-uniform control flow above, we must use the Level variant of
-    //       textureSampleCompare to avoid undefined behaviour due to some of the fragments in
-    //       a quad (2x2 fragments) being processed not being sampled, and this messing with
-    //       mip-mapping functionality. The shadow maps have no mipmaps so Level just samples
-    //       from LOD 0.
+    // textureSampleCompare to avoid undefined behaviour due to some of the fragments in
+    // a quad (2x2 fragments) being processed not being sampled, and this messing with
+    // mip-mapping functionality. The shadow maps have no mipmaps so Level just samples
+    // from LOD 0.
     return textureSampleCompareLevel(point_shadow_textures, point_shadow_textures_sampler, frag_ls, i32(light_id), depth);
 }
 
@@ -407,7 +407,7 @@ fn fetch_directional_shadow(light_id: u32, frag_position: vec4<f32>, surface_nor
     let depth = offset_position_ndc.z;
     // do the lookup, using HW PCF and comparison
     // NOTE: Due to non-uniform control flow above, we must use the level variant of the texture
-    //       sampler to avoid use of implicit derivatives causing possible undefined behavior.
+    // sampler to avoid use of implicit derivatives causing possible undefined behavior.
     return textureSampleCompareLevel(directional_shadow_textures, directional_shadow_textures_sampler, light_local, i32(light_id), depth);
 }