Cleanup.

src/background.rs

@@ -1,7 +1,5 @@
 use crate::quad;
 use crate::render_gl::{Error, FrameBuffer, Program, Shader, Texture};
-use failure;
-use gl;
 use nalgebra as na;
 use std::rc::Rc;
 

src/config.rs

@@ -23,7 +23,7 @@ impl Config {
         match ini {
             Ok(ini) => ini
                 .get_from(None::<&str>, BACKGROUND_KEY)
-                .map(|s| PathBuf::from(s)),
+                .map(PathBuf::from),
             Err(_) => None,
         }
     }

src/debug.rs

@@ -16,7 +16,7 @@
         let _ = write!(&mut result, "{}", cause);
         if let Some(backtrace) = cause.backtrace() {
             let backtrace_str = format!("{}", backtrace);
-            if backtrace_str.len() > 0 {
+            if !backtrace_str.is_empty() {
                 let _ = writeln!(&mut result, " This happened at {}", backtrace);
             } else {
                 let _ = writeln!(&mut result);

src/droplet.rs

@@ -28,3 +28,9 @@ impl Droplet {
         }
     }
 }
+
+impl Default for Droplet {
+    fn default() -> Self {
+        Self::new()
+    }
+}

src/main.rs

@@ -20,7 +20,6 @@ mod droplets;
 mod quad;
 mod rain;
 pub mod render_gl;
-pub mod resources;
 mod vertex;
 
 use crate::config::Config;
@@ -201,7 +200,6 @@ fn run(
             }
             Event::LoopDestroyed => {
                 context.take(); // Make sure it drops first
-                return;
             }
             Event::WindowEvent { event, .. } => match event {
                 WindowEvent::CursorMoved { position, .. } => match initial_mouse_position {

src/quad.rs

@@ -1,6 +1,5 @@
 use crate::render_gl::buffer;
 use crate::vertex::Vertex;
-use gl;
 
 pub struct Quad {
     _vbo: buffer::ArrayBuffer,

src/rain.rs

@@ -128,9 +128,9 @@ impl Rain {
 
             let path = config
                 .cached_background()
-                .unwrap_or(fallback_background.clone());
+                .unwrap_or_else(|| fallback_background.clone());
 
-            let mut options = TextureLoadOptions::from_res_rgb(path.to_str().unwrap());
+            let mut options = TextureLoadOptions::rgb();
             options.gen_mipmaps = true;
 
             let image = image::open(&path)
@@ -484,7 +484,7 @@ impl Rain {
                 gl::FLOAT, // data type
                 gl::FALSE,
                 std::mem::size_of::<na::Vector3<f32>>() as gl::types::GLint,
-                0 as *const gl::types::GLvoid,
+                std::ptr::null(),
             );
         }
         instance_vbo.unbind();
@@ -533,7 +533,7 @@ impl Rain {
                 if droplet.seed <= 0 {
                     droplet.seed =
                         (droplet.size * 0.5 * rng.gen_range(0.0, 1.0) * fps).floor() as i32;
-                    droplet.skipping = droplet.skipping == false;
+                    droplet.skipping = !droplet.skipping;
                     droplet.slowing = true;
                 }
 

src/render_gl/buffer.rs

@@ -1,6 +1,4 @@
-use gl;
-
-pub trait BufferType {
+pub trait BufferType {
     const BUFFER_TYPE: gl::types::GLuint;
 }
 
@@ -96,14 +94,15 @@ where
             (size * ::std::mem::size_of::<T>()) as gl::types::GLsizeiptr,   //  length
             gl::MAP_WRITE_BIT | gl::MAP_INVALIDATE_RANGE_BIT,               // usage
         );
-        if ptr == ::std::ptr::null_mut() {
+        if ptr.is_null() {
             return None;
         }
-        return Some(MappedBuffer {
+
+        Some(MappedBuffer {
             gl: self.gl.clone(),
             data: ::std::slice::from_raw_parts_mut(ptr as *mut T, size),
             _marker: ::std::marker::PhantomData,
-        });
+        })
     }
 }
 
@@ -113,7 +112,7 @@ where
 {
     fn drop(&mut self) {
         unsafe {
-            self.gl.DeleteBuffers(1, &mut self.vbo);
+            self.gl.DeleteBuffers(1, &self.vbo);
         }
     }
 }
@@ -195,7 +194,7 @@ impl VertexArray {
 impl Drop for VertexArray {
     fn drop(&mut self) {
         unsafe {
-            self.gl.DeleteVertexArrays(1, &mut self.vao);
+            self.gl.DeleteVertexArrays(1, &self.vao);
         }
     }
 }

src/render_gl/color_buffer.rs

@@ -1,5 +1,4 @@
-use gl;
-use nalgebra as na;
+use nalgebra as na;
 
 pub struct ColorBuffer {
     pub color: na::Vector4<f32>,

src/render_gl/data.rs

@@ -1,7 +1,5 @@
 #![allow(non_camel_case_types)]
 
-use gl;
-
 #[derive(Copy, Clone, Debug)]
 #[repr(C, packed)]
 pub struct i8_ {

src/render_gl/shader.rs

@@ -1,19 +1,9 @@
-use gl;
-use nalgebra as na;
-use std;
+use nalgebra as na;
 use std::ffi::{CStr, CString};
 use std::iter::Iterator;
 
 #[derive(Debug, Fail)] // derive Fail, in addition to Debug
 pub enum Error {
-    #[fail(display = "Failed to load resource {}", name)]
-    ResourceLoad {
-        name: String,
-        #[cause]
-        inner: resources::Error,
-    },
-    #[fail(display = "Can not determine shader type for resource {}", name)]
-    CanNotDetermineShaderTypeForResource { name: String },
     #[fail(display = "Failed to compile shader {}: {}", name, message)]
     CompileError { name: String, message: String },
     #[fail(display = "Failed to link program {}: {}", name, message)]
@@ -76,20 +66,6 @@ impl Program {
         })
     }
 
-    pub fn from_res(gl: &gl::Gl, res: &Resources, name: &str) -> Result<Program, Error> {
-        const POSSIBLE_EXT: [&str; 2] = [".vert", ".frag"];
-
-        let shaders = POSSIBLE_EXT
-            .iter()
-            .map(|file_extension| Shader::from_res(gl, res, &format!("{}{}", name, file_extension)))
-            .collect::<Result<Vec<Shader>, Error>>()?;
-
-        Program::from_shaders(gl, &shaders[..]).map_err(|msg| Error::LinkError {
-            message: msg,
-            name: name.into(),
-        })
-    }
-
     pub fn id(&self) -> gl::types::GLuint {
         self.id
     }
@@ -178,9 +154,6 @@ pub struct Shader {
     gl: gl::Gl,
 }
 
-use crate::resources;
-use crate::resources::Resources;
-
 impl Shader {
     pub fn from_source(
         gl: &gl::Gl,
@@ -214,27 +187,6 @@ impl Shader {
         Shader::from_source(gl, source, gl::FRAGMENT_SHADER)
     }
 
-    pub fn from_res(gl: &gl::Gl, res: &Resources, name: &str) -> Result<Shader, Error> {
-        const POSSIBLE_EXT: [(&str, gl::types::GLenum); 2] =
-            [(".vert", gl::VERTEX_SHADER), (".frag", gl::FRAGMENT_SHADER)];
-
-        let shader_kind = POSSIBLE_EXT
-            .iter()
-            .find(|&&(file_extension, _)| name.ends_with(file_extension))
-            .map(|&(_, kind)| kind)
-            .ok_or_else(|| Error::CanNotDetermineShaderTypeForResource { name: name.into() })?;
-
-        let source = res.load_cstring(name).map_err(|e| Error::ResourceLoad {
-            name: name.into(),
-            inner: e,
-        })?;
-
-        Shader::from_source(gl, &source, shader_kind).map_err(|msg| Error::CompileError {
-            message: msg,
-            name: name.into(),
-        })
-    }
-
     pub fn id(&self) -> gl::types::GLuint {
         self.id
     }