Fix and enforce line endings + stray whitespace (#1099)

Author: rukai

Diff for: .travis.yml

@@ -22,6 +22,7 @@ addons:
     - cmake-data
 
 script:
+    - git diff-tree --check $(git hash-object -t tree /dev/null) HEAD
     - travis_wait cargo test --all -j 1
     - cd examples
     - cargo build

Diff for: CHANGELOG.md

@@ -41,7 +41,7 @@ borrowed `str`s.
 - Allow `Surface` to own the window it references.
 - Clear value validation for `AutoCommandBufferBuilder::begin_render_pass()`
 - Fix occasional truncation of glslang_validator when glsl-to-spirv is rebuilt
-- Fix linking against MoltenVK >= 0.19.0 
+- Fix linking against MoltenVK >= 0.19.0
 - Fix panic on DeviceLost error after resizing swapchain on nvidia/amd hardware
 - Added `AutoCommandBufferBuilder::copy_image`
 - Added `VulkanObject::TYPE` to look up the `DebugReportObjectTypeEXT` of an object

Diff for: DESIGN.md

@@ -100,14 +100,14 @@ Vulkan is not natively supported by macOS and iOS. However, there exists [Molten
 a Vulkan implementation on top of Apple's Metal API. This allows vulkano to build and run on macOS
 and iOS platforms.
 
-The easiest way to get vulkano up and running on macOS is to install the 
+The easiest way to get vulkano up and running on macOS is to install the
 [Vulkan SDK for macOS](https://vulkan.lunarg.com/sdk/home). To install the SDK so that
 Vulkano will find it and dynamically link with `libvulkan.dylib`:
 
 1. Download the latest macOS release and unpack it somewhere, for the next step
 we'll assume that's `~/vulkan_sdk`.
-2. Modify your environment to contain the SDK bin directory in PATH and the SDK lib directory in 
-DYLD_LIBRARY_PATH. We also need to set VK_ICD_FILENAMES and VK_LAYER_PATH. When using the Bash 
+2. Modify your environment to contain the SDK bin directory in PATH and the SDK lib directory in
+DYLD_LIBRARY_PATH. We also need to set VK_ICD_FILENAMES and VK_LAYER_PATH. When using the Bash
 shell, which is the default for macOS, it's easiest to do this by appending the following to the
 `~/.bash_profile` file and then restarting the terminal.
 

Diff for: README.md

@@ -349,7 +349,7 @@ impl<'a> Frame<'a> {
                 // If we are in pass 2 then we have finished applying lighting.
                 // We take the builder, call `end_render_pass()`, and then `build()` it to obtain
                 // an actual command buffer.
-                let command_buffer = 
+                let command_buffer =
                     self.command_buffer
                         .take()
                         .unwrap()

Diff for: examples/src/bin/deferred/frame/system.rs

@@ -9,19 +9,19 @@
 
 
 // Welcome to the deferred lighting example!
-// 
+//
 // The idea behind deferred lighting is to render the scene in two steps.
-// 
+//
 // First you draw all the objects of the scene. But instead of calculating the color they will
 // have on the screen, you output their characteristics such as their diffuse color and their
 // normals, and write this to images.
-// 
+//
 // After all the objects are drawn, you should obtain several images that contain the
 // characteristics of each pixel.
-// 
+//
 // Then you apply lighting to the scene. In other words you draw to the final image by taking
 // these intermediate images and the various lights of the scene as input.
-// 
+//
 // This technique allows you to apply tons of light sources to a scene, which would be too
 // expensive otherwise. It has some drawbacks, which are the fact that transparent objects must be
 // drawn after the lighting, and that the whole process consumes more memory.
@@ -111,7 +111,7 @@ fn main() {
             } else {
                 return;
             };
-            
+
             let (new_swapchain, new_images) = match swapchain.recreate_with_dimension(dimensions) {
                 Ok(r) => r,
                 Err(SwapchainCreationError::UnsupportedDimensions) => {

Diff for: examples/src/bin/deferred/main.rs

@@ -10,53 +10,53 @@
 //! Multisampling anti-aliasing example, using a render pass resolve.
 //!
 //! # Introduction to multisampling
-//! 
+//!
 //! When you draw an object on an image, this object occupies a certain set of pixels. Each pixel
 //! of the image is either fully covered by the object, or not covered at all. There is no such
 //! thing as a pixel that is half-covered by the object that you're drawing. What this means is
 //! that you will sometimes see a "staircase effect" at the border of your object, also called
 //! aliasing.
-//! 
+//!
 //! The root cause of aliasing is that the resolution of the image is not high enough. If you
 //! increase the size of the image you're drawing to, this effect will still exist but will be
 //! much less visible.
-//! 
+//!
 //! In order to decrease aliasing, some games and programs use what we call "Super-Sampling Anti
 //! Aliasing" (SSAA). For example instead of drawing to an image of size 1024x1024, you draw to an
 //! image of size 4096x4096. Then at the end, you scale down your image to 1024x1024 by merging
 //! nearby pixels. Since the intermediate image is 4 times larger than the destination, this would
 //! be x4 SSAA.
-//! 
+//!
 //! However this technique is very expensive in terms of GPU power. The fragment shader and all
 //! its calculations has to run four times more often.
-//! 
+//!
 //! So instead of SSAA, a common alternative is MSAA (MultiSampling Anti Aliasing). The base
 //! principle is more or less the same: you draw to an image of a larger dimension, and then at
 //! the end you scale it down to the final size. The difference is that the fragment shader is
 //! only run once per pixel of the final size, and its value is duplicated to fill to all the
 //! pixels of the intermediate image that are covered by the object.
-//! 
+//!
 //! For example, let's say that you use x4 MSAA, you draw to an intermediate image of size
 //! 4096x4096, and your object covers the whole image. With MSAA, the fragment shader will only
 //! be 1,048,576 times (1024 * 1024), compared to 16,777,216 times (4096 * 4096) with 4x SSAA.
 //! Then the output of each fragment shader invocation is copied in each of the four pixels of the
 //! intermediate image that correspond to each pixel of the final image.
-//! 
+//!
 //! Now, let's say that your object doesn't cover the whole image. In this situation, only the
 //! pixels of the intermediate image that are covered by the object will receive the output of the
 //! fragment shader.
-//! 
+//!
 //! Because of the way it works, this technique requires direct support from the hardware,
 //! contrary to SSAA which can be done on any machine.
-//! 
+//!
 //! # Multisampled images
-//! 
+//!
 //! Using MSAA with Vulkan is done by creating a regular image, but with a number of samples per
 //! pixel different from 1. For example if you want to use 4x MSAA, you should create an image with
 //! 4 samples per pixel. Internally this image will have 4 times as many pixels as its dimensions
 //! would normally require, but this is handled transparently for you. Drawing to a multisampled
 //! image is exactly the same as drawing to a regular image.
-//! 
+//!
 //! However multisampled images have some restrictions, for example you can't show them on the
 //! screen (swapchain images are always single-sampled), and you can't copy them into a buffer.
 //! Therefore when you have finished drawing, you have to blit your multisampled image to a

Diff for: examples/src/bin/msaa-renderpass.rs

@@ -144,7 +144,7 @@ fn main() {
             } else {
                 return;
             };
-            
+
             let (new_swapchain, new_images) = match swapchain.recreate_with_dimension(dimensions) {
                 Ok(r) => r,
                 Err(SwapchainCreationError::UnsupportedDimensions) => continue,
@@ -205,11 +205,11 @@ fn main() {
             .draw_indexed(
                 pipeline.clone(),
                 &DynamicState::none(),
-                vec!(vertex_buffer.clone(), normals_buffer.clone()), 
+                vec!(vertex_buffer.clone(), normals_buffer.clone()),
                 index_buffer.clone(), set.clone(), ()).unwrap()
             .end_render_pass().unwrap()
             .build().unwrap();
-        
+
         let future = previous_frame.join(acquire_future)
             .then_execute(queue.clone(), command_buffer).unwrap()
             .then_swapchain_present(queue.clone(), swapchain.clone(), image_num)

Diff for: examples/src/bin/teapot/main.rs

@@ -255,7 +255,7 @@ void main() {
                 store: Store,
                 // `format: <ty>` indicates the type of the format of the image. This has to
                 // be one of the types of the `vulkano::format` module (or alternatively one
-                // of your structs that implements the `FormatDesc` trait). Here we use the 
+                // of your structs that implements the `FormatDesc` trait). Here we use the
                 // same format as the swapchain.
                 format: swapchain.format(),
                 // TODO:

Diff for: examples/src/bin/triangle.rs

@@ -33,9 +33,9 @@
 //! module like some normal macro crates do since derive macros cannot be used from
 //! the crate they are declared in. On the other hand, if you are looking for a
 //! high-level overview, you can see the below section.
-//! 
+//!
 //! # Generated code overview
-//! 
+//!
 //! The macro generates the following items of interest:
 //! * The `Shader` struct. This contains a single field, `shader`, which is an
 //! `Arc<ShaderModule>`.
@@ -61,11 +61,11 @@
 //! specialization constant found in the shader data. Implementations of
 //! `Default` and [`SpecializationConstants`][SpecializationConstants] are also
 //! generated for the struct.
-//! 
+//!
 //! All of these generated items will be accessed through the module specified
 //! by `mod_name: foo` If you wanted to store the `Shader` in a struct of your own,
 //! you could do something like this:
-//! 
+//!
 //! ```
 //! # extern crate vulkano_shaders;
 //! # extern crate vulkano;
@@ -89,11 +89,11 @@
 //! # }
 //! // various use statements
 //! // `vertex_shader` module with shader derive
-//! 
+//!
 //! pub struct Shaders {
 //!     pub vs: vs::Shader
 //! }
-//! 
+//!
 //! impl Shaders {
 //!     pub fn load(device: Arc<Device>) -> Result<Self, OomError> {
 //!         Ok(Self {
@@ -102,9 +102,9 @@
 //!     }
 //! }
 //! ```
-//! 
+//!
 //! # Options
-//! 
+//!
 //! The options available are in the form of the following attributes:
 //!
 //! ## `ty: "..."`
@@ -134,7 +134,7 @@
 //! ## `dump: true`
 //!
 //! The crate fails to compile but prints the generated rust code to stdout.
-//! 
+//!
 //! [reflect]: https://github.com/vulkano-rs/vulkano/blob/master/vulkano-shaders/src/lib.rs#L67
 //! [cargo-expand]: https://github.com/dtolnay/cargo-expand
 //! [ShaderModule::new]: https://docs.rs/vulkano/*/vulkano/pipeline/shader/struct.ShaderModule.html#method.new

Diff for: vulkano-shaders/src/lib.rs

@@ -1,20 +1,20 @@
-[package]
-name = "vulkano"
-version = "0.10.0"
-authors = ["Pierre Krieger <[email protected]>", "The vulkano contributors"]
-repository = "https://github.com/vulkano-rs/vulkano"
-description = "Safe wrapper for the Vulkan graphics API"
-license = "MIT/Apache-2.0"
-documentation = "https://docs.rs/vulkano"
-readme = "../README.md"
-categories = ["rendering::graphics-api"]
-build = "build.rs"
-
-[dependencies]
-crossbeam = "0.4"
-fnv = "1.0.6"
-shared_library = "0.1.7"
-smallvec = "0.6.0"
-lazy_static = "1"
-vk-sys = { version = "0.3.3", path = "../vk-sys" }
-half = "1"
+[package]
+name = "vulkano"
+version = "0.10.0"
+authors = ["Pierre Krieger <[email protected]>", "The vulkano contributors"]
+repository = "https://github.com/vulkano-rs/vulkano"
+description = "Safe wrapper for the Vulkan graphics API"
+license = "MIT/Apache-2.0"
+documentation = "https://docs.rs/vulkano"
+readme = "../README.md"
+categories = ["rendering::graphics-api"]
+build = "build.rs"
+
+[dependencies]
+crossbeam = "0.4"
+fnv = "1.0.6"
+shared_library = "0.1.7"
+smallvec = "0.6.0"
+lazy_static = "1"
+vk-sys = { version = "0.3.3", path = "../vk-sys" }
+half = "1"

Diff for: vulkano/Cargo.toml

@@ -547,7 +547,7 @@ impl<P> AutoCommandBufferBuilder<P> {
                     None => panic!("Not enough clear values")
                 }
             }
-            
+
             if clear_values_copy.count() != 0 {
                 panic!("Too many clear values")
             }

Diff for: vulkano/src/command_buffer/auto.rs

@@ -186,7 +186,7 @@ macro_rules! formats {
 
         impl Format {
             /*pub fn is_supported_for_vertex_attributes(&self) -> bool {
-                
+
             }
 
             .. other functions ..

Diff for: vulkano/src/format.rs

@@ -306,13 +306,13 @@ impl Dimensions {
     #[inline]
     pub fn to_view_type(&self) -> ViewType {
         match *self {
-            Dimensions::Dim1d { .. } => ViewType::Dim1d, 
-            Dimensions::Dim1dArray { .. } => ViewType::Dim1dArray, 
-            Dimensions::Dim2d { .. } => ViewType::Dim2d, 
-            Dimensions::Dim2dArray { .. } => ViewType::Dim2dArray, 
-            Dimensions::Dim3d { .. } => ViewType::Dim3d, 
-            Dimensions::Cubemap { .. } => ViewType::Cubemap, 
-            Dimensions::CubemapArray { .. } => ViewType::CubemapArray, 
+            Dimensions::Dim1d { .. } => ViewType::Dim1d,
+            Dimensions::Dim1dArray { .. } => ViewType::Dim1dArray,
+            Dimensions::Dim2d { .. } => ViewType::Dim2d,
+            Dimensions::Dim2dArray { .. } => ViewType::Dim2dArray,
+            Dimensions::Dim3d { .. } => ViewType::Dim3d,
+            Dimensions::Cubemap { .. } => ViewType::Cubemap,
+            Dimensions::CubemapArray { .. } => ViewType::CubemapArray,
         }
     }
 

Diff for: vulkano/src/image/mod.rs

@@ -26,7 +26,7 @@ macro_rules! limits_impl {
                     limits
                 }
             }
-            
+
             $(
                 #[inline]
                 pub fn $name(&self) -> $t {

Diff for: vulkano/src/instance/limits.rs

@@ -342,4 +342,3 @@ const BASIC_FS: [u8; 420] = [3, 2, 35, 7, 0, 0, 1, 0, 1, 0, 8, 0, 13, 0, 0, 0, 0
                              5, 0, 2, 0, 0, 0, 4, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 248, 0, 2,
                              0, 5, 0, 0, 0, 62, 0, 3, 0, 9, 0, 0, 0, 12, 0, 0, 0, 253, 0, 1,
                              0, 56, 0, 1, 0];
-

Diff for: vulkano/src/pipeline/graphics_pipeline/tests.rs

@@ -1020,7 +1020,7 @@ unsafe impl<P, W> GpuFuture for PresentFuture<P, W>
                    // submit the command buffer by flushing previous.
                    // Since the implementation should remember being flushed it's safe to call build_submission multiple times
                    self.previous.flush()?;
-                   
+
                    let mut builder = SubmitPresentBuilder::new();
                    builder.add_swapchain(&self.swapchain,
                                          self.image_id as u32,