Rust `rustfmt` on the GPU crate

gpu/src/lib.rs

@@ -35,44 +35,52 @@ pub trait Device {
 
     fn create_texture(&self, format: TextureFormat, size: Point2DI32) -> Self::Texture;
     fn create_texture_from_data(&self, size: Point2DI32, data: &[u8]) -> Self::Texture;
-    fn create_shader_from_source(&self,
+    fn create_shader_from_source(
+        &self,
         name: &str,
         source: &[u8],
         kind: ShaderKind,
-                                 template_input: HashBuilder)
+        template_input: HashBuilder,
-                                 -> Self::Shader;
+    ) -> Self::Shader;
     fn create_vertex_array(&self) -> Self::VertexArray;
-    fn create_program_from_shaders(&self,
+    fn create_program_from_shaders(
+        &self,
         name: &str,
         vertex_shader: Self::Shader,
-                                   fragment_shader: Self::Shader)
+        fragment_shader: Self::Shader,
-                                   -> Self::Program;
+    ) -> Self::Program;
     fn get_vertex_attr(&self, program: &Self::Program, name: &str) -> Self::VertexAttr;
     fn get_uniform(&self, program: &Self::Program, name: &str) -> Self::Uniform;
     fn use_program(&self, program: &Self::Program);
-    fn configure_float_vertex_attr(&self,
+    fn configure_float_vertex_attr(
+        &self,
         attr: &Self::VertexAttr,
         size: usize,
         attr_type: VertexAttrType,
         normalized: bool,
         stride: usize,
         offset: usize,
-                                   divisor: u32);
+        divisor: u32,
-    fn configure_int_vertex_attr(&self,
+    );
+    fn configure_int_vertex_attr(
+        &self,
         attr: &Self::VertexAttr,
         size: usize,
         attr_type: VertexAttrType,
         stride: usize,
         offset: usize,
-                                 divisor: u32);
+        divisor: u32,
+    );
     fn set_uniform(&self, uniform: &Self::Uniform, data: UniformData);
     fn create_framebuffer(&self, texture: Self::Texture) -> Self::Framebuffer;
     fn create_buffer(&self) -> Self::Buffer;
-    fn allocate_buffer<T>(&self,
+    fn allocate_buffer<T>(
+        &self,
         buffer: &Self::Buffer,
         data: BufferData<T>,
         target: BufferTarget,
-                          mode: BufferUploadMode);
+        mode: BufferUploadMode,
+    );
     fn framebuffer_texture<'f>(&self, framebuffer: &'f Self::Framebuffer) -> &'f Self::Texture;
     fn texture_size(&self, texture: &Self::Texture) -> Point2DI32;
     fn upload_to_texture(&self, texture: &Self::Texture, size: Point2DI32, data: &[u8]);
@@ -80,11 +88,13 @@ pub trait Device {
     fn clear(&self, params: &ClearParams);
     fn draw_arrays(&self, primitive: Primitive, index_count: u32, render_state: &RenderState);
     fn draw_elements(&self, primitive: Primitive, index_count: u32, render_state: &RenderState);
-    fn draw_arrays_instanced(&self,
+    fn draw_arrays_instanced(
+        &self,
         primitive: Primitive,
         index_count: u32,
         instance_count: u32,
-                             render_state: &RenderState);
+        render_state: &RenderState,
+    );
     fn create_timer_query(&self) -> Self::TimerQuery;
     fn begin_timer_query(&self, query: &Self::TimerQuery);
     fn end_timer_query(&self, query: &Self::TimerQuery);
@@ -98,18 +108,28 @@ pub trait Device {
     fn bind_framebuffer(&self, framebuffer: &Self::Framebuffer);
     fn bind_texture(&self, texture: &Self::Texture, unit: u32);
 
-    fn create_texture_from_png(&self, resources: &dyn ResourceLoader, name: &str)
+    fn create_texture_from_png(&self, resources: &dyn ResourceLoader, name: &str) -> Self::Texture {
-                               -> Self::Texture {
         let data = resources.slurp(&format!("textures/{}.png", name)).unwrap();
-        let image = image::load_from_memory_with_format(&data, ImageFormat::PNG).unwrap().to_luma();
+        let image = image::load_from_memory_with_format(&data, ImageFormat::PNG)
+            .unwrap()
+            .to_luma();
         let size = Point2DI32::new(image.width() as i32, image.height() as i32);
         self.create_texture_from_data(size, &image)
     }
 
-    fn create_shader(&self, resources: &dyn ResourceLoader, name: &str, kind: ShaderKind)
+    fn create_shader(
-                     -> Self::Shader {
+        &self,
-        let suffix = match kind { ShaderKind::Vertex => 'v', ShaderKind::Fragment => 'f' };
+        resources: &dyn ResourceLoader,
-        let source = resources.slurp(&format!("shaders/{}.{}s.glsl", name, suffix)).unwrap();
+        name: &str,
+        kind: ShaderKind,
+    ) -> Self::Shader {
+        let suffix = match kind {
+            ShaderKind::Vertex => 'v',
+            ShaderKind::Fragment => 'f',
+        };
+        let source = resources
+            .slurp(&format!("shaders/{}.{}s.glsl", name, suffix))
+            .unwrap();
 
         let mut load_include_tile_alpha_vertex =
             |_| load_shader_include(resources, "tile_alpha_vertex");
@@ -122,33 +142,36 @@ pub trait Device {
         let mut load_include_post_convolve = |_| load_shader_include(resources, "post_convolve");
         let mut load_include_post_gamma_correct =
             |_| load_shader_include(resources, "post_gamma_correct");
-        let template_input =
+        let template_input = HashBuilder::new()
-            HashBuilder::new().insert_lambda("include_tile_alpha_vertex",
+            .insert_lambda(
-                                             &mut load_include_tile_alpha_vertex)
+                "include_tile_alpha_vertex",
-                              .insert_lambda("include_tile_monochrome",
+                &mut load_include_tile_alpha_vertex,
-                                             &mut load_include_tile_monochrome)
+            )
-                              .insert_lambda("include_tile_multicolor",
+            .insert_lambda("include_tile_monochrome", &mut load_include_tile_monochrome)
-                                             &mut load_include_tile_multicolor)
+            .insert_lambda("include_tile_multicolor", &mut load_include_tile_multicolor)
-                              .insert_lambda("include_tile_solid_vertex",
+            .insert_lambda(
-                                             &mut load_include_tile_solid_vertex)
+                "include_tile_solid_vertex",
-                              .insert_lambda("include_post_convolve",
+                &mut load_include_tile_solid_vertex,
-                                             &mut load_include_post_convolve)
+            )
-                              .insert_lambda("include_post_gamma_correct",
+            .insert_lambda("include_post_convolve", &mut load_include_post_convolve)
-                                             &mut load_include_post_gamma_correct);
+            .insert_lambda(
+                "include_post_gamma_correct",
+                &mut load_include_post_gamma_correct,
+            );
 
         self.create_shader_from_source(name, &source, kind, template_input)
     }
 
-    fn create_program_from_shader_names(&self,
+    fn create_program_from_shader_names(
+        &self,
         resources: &dyn ResourceLoader,
         program_name: &str,
         vertex_shader_name: &str,
-                                        fragment_shader_name: &str)
+        fragment_shader_name: &str,
-                                        -> Self::Program {
+    ) -> Self::Program {
         let vertex_shader = self.create_shader(resources, vertex_shader_name, ShaderKind::Vertex);
-        let fragment_shader = self.create_shader(resources,
+        let fragment_shader =
-                                                 fragment_shader_name,
+            self.create_shader(resources, fragment_shader_name, ShaderKind::Fragment);
-                                                 ShaderKind::Fragment);
         self.create_program_from_shaders(program_name, vertex_shader, fragment_shader)
     }
 
@@ -268,7 +291,12 @@ pub enum StencilFunc {
 impl Default for RenderState {
     #[inline]
     fn default() -> RenderState {
-        RenderState { blend: BlendState::default(), depth: None, stencil: None, color_mask: true }
+        RenderState {
+            blend: BlendState::default(),
+            depth: None,
+            stencil: None,
+            color_mask: true,
+        }
     }
 }
 
@@ -282,7 +310,12 @@ impl Default for BlendState {
 impl Default for StencilState {
     #[inline]
     fn default() -> StencilState {
-        StencilState { func: StencilFunc::default(), reference: 0, mask: !0, write: false }
+        StencilState {
+            func: StencilFunc::default(),
+            reference: 0,
+            mask: !0,
+            write: false,
+        }
     }
 }
 
@@ -308,6 +341,8 @@ impl UniformData {
 }
 
 fn load_shader_include(resources: &dyn ResourceLoader, include_name: &str) -> String {
-    let resource = resources.slurp(&format!("shaders/{}.inc.glsl", include_name)).unwrap();
+    let resource = resources
+        .slurp(&format!("shaders/{}.inc.glsl", include_name))
+        .unwrap();
     String::from_utf8_lossy(&resource).to_string()
 }

gpu/src/resources.rs

@@ -40,7 +40,9 @@ impl FilesystemResourceLoader {
                 shaders_directory.push("shaders");
                 textures_directory.push("textures");
                 if shaders_directory.is_dir() && textures_directory.is_dir() {
-                    return FilesystemResourceLoader { directory: resources_directory };
+                    return FilesystemResourceLoader {
+                        directory: resources_directory,
+                    };
                 }
             }
 
@@ -56,7 +58,9 @@ impl FilesystemResourceLoader {
 impl ResourceLoader for FilesystemResourceLoader {
     fn slurp(&self, virtual_path: &str) -> Result<Vec<u8>, IOError> {
         let mut path = self.directory.clone();
-        virtual_path.split('/').for_each(|segment| path.push(segment));
+        virtual_path
+            .split('/')
+            .for_each(|segment| path.push(segment));
 
         let mut data = vec![];
         File::open(&path)?.read_to_end(&mut data)?;