Split bounding_box to its own module.

diff --git a/bounding_box.rs b/bounding_box.rs
new file mode 100644 (file)
index 0000000..657b206
--- /dev/null
+++ b/bounding_box.rs
@@ -0,0 +1,76 @@
+use cube::Cube;
+use glium;
+use glium::{Display, Program, Surface};
+use glium::index::{IndexBuffer, PrimitiveType};
+
+pub fn solid_fill_program(display: &Display) -> Program {
+    let vertex_shader_src = r#"
+        #version 140
+        in vec3 position;
+        uniform mat4 perspective;
+        uniform mat4 view;
+        uniform mat4 model;
+
+        void main() {
+            mat4 modelview = view * model;
+            gl_Position = perspective * modelview * vec4(position, 1.0);
+        }
+    "#;
+
+    let fragment_shader_src = r#"
+        #version 140
+
+        out vec4 color;
+
+        void main() {
+            color = vec4(1.0, 1.0, 1.0, 1.0);
+        }
+    "#;
+
+    return Program::from_source(display, vertex_shader_src, fragment_shader_src, None).unwrap();
+}
+
+pub fn draw<U>(display: &Display,
+               frame: &mut glium::Frame,
+               program: &Program,
+               uniforms: &U,
+               cube: &Cube) where U: glium::uniforms::Uniforms {
+
+    #[derive(Copy, Clone)]
+    struct Vertex { position: [f32; 3] }
+    implement_vertex!(Vertex, position);
+
+    let cube = [
+        Vertex { position: [cube.xmin, cube.ymin, cube.zmin] },
+        Vertex { position: [cube.xmax, cube.ymin, cube.zmin] },
+        Vertex { position: [cube.xmax, cube.ymax, cube.zmin] },
+        Vertex { position: [cube.xmin, cube.ymax, cube.zmin] },
+        Vertex { position: [cube.xmin, cube.ymin, cube.zmax] },
+        Vertex { position: [cube.xmax, cube.ymin, cube.zmax] },
+        Vertex { position: [cube.xmax, cube.ymax, cube.zmax] },
+        Vertex { position: [cube.xmin, cube.ymax, cube.zmax] },
+    ];
+    let vb = glium::VertexBuffer::new(display, &cube).unwrap();
+
+    let params = glium::DrawParameters {
+        depth: glium::Depth {
+            test: glium::draw_parameters::DepthTest::IfLess,
+            write: true,
+            ..Default::default()
+        },
+        blend: glium::Blend::alpha_blending(),
+        ..Default::default()
+    };
+
+    let front_indices = IndexBuffer::new(display, PrimitiveType::LineLoop,
+                                         &[0, 1, 2, 3u16]).unwrap();
+    frame.draw(&vb, &front_indices, program, uniforms, &params).unwrap();
+
+    let back_indices = IndexBuffer::new(display, PrimitiveType::LineLoop,
+                                        &[4, 5, 6, 7u16]).unwrap();
+    frame.draw(&vb, &back_indices, program, uniforms, &params).unwrap();
+
+    let sides_indices = IndexBuffer::new(display, PrimitiveType::LinesList,
+                                         &[0, 4, 1, 5, 2, 6, 3, 7u16]).unwrap();
+    frame.draw(&vb, &sides_indices, program, uniforms, &params).unwrap();
+}

diff --git a/main.rs b/main.rs
index 1b336887a10fbd99ece652cc71ffd12d72e84f35..71495b41d09f310d0d051ae51e5bff0b78b4677f 100644 (file)
--- a/main.rs
+++ b/main.rs
@@ -9,91 +9,16 @@ extern crate sdl2;
 
 use cube::Cube;
 use glium::{DisplayBuild, Surface};
-use glium::index::{IndexBuffer, PrimitiveType};
 use glutin::ElementState::Pressed;
 use glutin::Event::KeyboardInput;
 use glutin::VirtualKeyCode;
 
+mod bounding_box;
 mod cube;
 mod mandelwow;
 mod sound;
 mod support;
 
-fn solid_fill_program(display: &glium::Display) -> glium::Program {
-    let vertex_shader_src = r#"
-        #version 140
-        in vec3 position;
-        uniform mat4 perspective;
-        uniform mat4 view;
-        uniform mat4 model;
-
-        void main() {
-            mat4 modelview = view * model;
-            gl_Position = perspective * modelview * vec4(position, 1.0);
-        }
-    "#;
-
-    let fragment_shader_src = r#"
-        #version 140
-
-        out vec4 color;
-
-        void main() {
-            color = vec4(1.0, 1.0, 1.0, 1.0);
-        }
-    "#;
-
-    return glium::Program::from_source(display,
-                                       vertex_shader_src,
-                                       fragment_shader_src,
-                                       None).unwrap();
-}
-
-fn bounding_box<U>(display: &glium::Display,
-                   frame: &mut glium::Frame,
-                   program: &glium::Program,
-                   uniforms: &U,
-                   cube: &Cube) where U: glium::uniforms::Uniforms {
-
-    #[derive(Copy, Clone)]
-    struct Vertex { position: [f32; 3] }
-    implement_vertex!(Vertex, position);
-
-    let cube = [
-        Vertex { position: [cube.xmin, cube.ymin, cube.zmin] },
-        Vertex { position: [cube.xmax, cube.ymin, cube.zmin] },
-        Vertex { position: [cube.xmax, cube.ymax, cube.zmin] },
-        Vertex { position: [cube.xmin, cube.ymax, cube.zmin] },
-        Vertex { position: [cube.xmin, cube.ymin, cube.zmax] },
-        Vertex { position: [cube.xmax, cube.ymin, cube.zmax] },
-        Vertex { position: [cube.xmax, cube.ymax, cube.zmax] },
-        Vertex { position: [cube.xmin, cube.ymax, cube.zmax] },
-    ];
-    let vb = glium::VertexBuffer::new(display, &cube).unwrap();
-
-    let params = glium::DrawParameters {
-        depth: glium::Depth {
-            test: glium::draw_parameters::DepthTest::IfLess,
-            write: true,
-            ..Default::default()
-        },
-        blend: glium::Blend::alpha_blending(),
-        ..Default::default()
-    };
-
-    let front_indices = IndexBuffer::new(display, PrimitiveType::LineLoop,
-                                         &[0, 1, 2, 3u16]).unwrap();
-    frame.draw(&vb, &front_indices, program, uniforms, &params).unwrap();
-
-    let back_indices = IndexBuffer::new(display, PrimitiveType::LineLoop,
-                                        &[4, 5, 6, 7u16]).unwrap();
-    frame.draw(&vb, &back_indices, program, uniforms, &params).unwrap();
-
-    let sides_indices = IndexBuffer::new(display, PrimitiveType::LinesList,
-                                         &[0, 4, 1, 5, 2, 6, 3, 7u16]).unwrap();
-    frame.draw(&vb, &sides_indices, program, uniforms, &params).unwrap();
-}
-
 fn main() {
     let _soundplayer = sound::start();
 
@@ -107,7 +32,7 @@ fn main() {
         .unwrap();
 
     let mandelwow_program = mandelwow::program(&display);
-    let bounding_box_program = solid_fill_program(&display);
+    let bounding_box_program = bounding_box::solid_fill_program(&display);
 
     let mut camera = support::camera::CameraState::new();
     let mut t: f32 = 0.0;
@@ -115,6 +40,16 @@ fn main() {
     let mut bounding_box_enabled = true;
     let mut fullscreen = true;
 
+    // These are the bounds of the 3D Mandelwow section which we render in 3-space.
+    let bounds = Cube {
+        xmin: -2.0,
+        xmax:  0.7,
+        ymin: -1.0,
+        ymax:  1.0,
+        zmin: -1.1,
+        zmax:  1.1,
+    };
+
     support::start_loop(|| {
         camera.update();
 
@@ -123,16 +58,6 @@ fn main() {
             t += 0.01;
         }
 
-        // These are the bounds of the 3D Mandelwow section which we render in 3-space.
-        let bounds = Cube {
-            xmin: -2.0,
-            xmax:  0.7,
-            ymin: -1.0,
-            ymax:  1.0,
-            zmin: -1.1,
-            zmax:  1.1,
-        };
-
         // Vary the wow factor to slice the Mandelwow along its 4th dimension.
         let wmin = -0.8;
         let wmax =  0.8;
@@ -160,7 +85,7 @@ fn main() {
                 view:  camera.get_view(),
                 perspective: camera.get_perspective(),
             };
-            bounding_box(&display, &mut frame, &bounding_box_program, &uniforms, &bounds);
+            bounding_box::draw(&display, &mut frame, &bounding_box_program, &uniforms, &bounds);
         }
 
         mandelwow::draw(&display, &mut frame, &mandelwow_program, model, &camera, &bounds, wow);