+// Wow. Such fractal.
+
#[macro_use]
extern crate glium;
extern crate glutin;
+extern crate libxm;
-use glium::DisplayBuild;
-use glium::Surface;
-use glium::index::PrimitiveType;
-use glium::index::IndexBuffer;
+use glium::{DisplayBuild, Surface};
+use glium::index::{IndexBuffer, PrimitiveType};
+use glutin::ElementState::Pressed;
+use glutin::Event::KeyboardInput;
+use glutin::VirtualKeyCode;
+use libxm::XMContext;
+use std::fs::File;
+use std::io::Read;
-mod support;
-#[derive(Copy, Clone)]
-struct Vertex {
- position: [f32; 3],
- color: [f32; 3],
-}
-implement_vertex!(Vertex, position, color);
+mod support;
#[derive(Copy, Clone)]
struct Cube {
program: &glium::Program,
uniforms: &U,
cube: &Cube) where U: glium::uniforms::Uniforms {
- // Draw the bounding box
#[derive(Copy, Clone)]
struct Vertex { position: [f32; 3] }
];
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, &Default::default()).unwrap();
+ frame.draw(&vb, &front_indices, program, uniforms, ¶ms).unwrap();
let back_indices = IndexBuffer::new(display, PrimitiveType::LineLoop,
&[4, 5, 6, 7u16]).unwrap();
- frame.draw(&vb, &back_indices, program, uniforms, &Default::default()).unwrap();
+ frame.draw(&vb, &back_indices, program, uniforms, ¶ms).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, &Default::default()).unwrap();
+ frame.draw(&vb, &sides_indices, program, uniforms, ¶ms).unwrap();
}
fn mandel<U>(display: &glium::Display,
frame: &mut glium::Frame,
program: &glium::Program,
uniforms: &U,
+ bounds: &Cube,
z: [f32; 2]) where U: glium::uniforms::Uniforms {
- let xmin = -2.0;
- let xmax = 0.7;
- let ymin = -1.0;
- let ymax = 1.0;
- let zmin = -1.2;
- let zmax = 1.2;
+
+ #[derive(Copy, Clone)]
+ struct Vertex {
+ position: [f32; 3],
+ color: [f32; 3],
+ }
+ implement_vertex!(Vertex, position, color);
+
+ let xmin = bounds.xmin;
+ let xmax = bounds.xmax;
+ let ymin = bounds.ymin;
+ let ymax = bounds.ymax;
+
let width = xmax - xmin;
let height = ymax - ymin;
let xres: usize = 1;
program: &glium::Program,
model: [[f32; 4]; 4],
camera: &support::camera::CameraState,
- cube: &Cube,
+ bounds: &Cube,
mandel_w: f32) {
let mut z0 = [mandel_w, 0f32];
let zres = 50;
- let zmin = cube.zmin;
- let zmax = cube.zmax;
+ let zmin = bounds.zmin;
+ let zmax = bounds.zmax;
let zstep = (zmax - zmin) / zres as f32;
let mut zy = zmin;
for _ in 0..zres {
perspective: camera.get_perspective(),
};
- mandel(&display, &mut frame, &program, &uniforms, z0);
+ mandel(&display, &mut frame, &program, &uniforms, bounds, z0);
}
}
+fn play_xm(raw_xm: &[u8]) {
+ let freq = 48000u32;
+ let mut xm = XMContext::new(&raw_xm, freq).unwrap();
+}
fn main() {
+ let mut xm = Vec::new();
+ File::open("flora.xm").unwrap().read_to_end(&mut xm).unwrap();
+ play_xm(&xm);
+
let display = glium::glutin::WindowBuilder::new()
- .with_dimensions(1024, 768)
+ //.with_dimensions(1024, 768)
+ .with_fullscreen(glutin::get_primary_monitor())
.with_depth_buffer(24)
+ .with_vsync()
.with_title(format!("MandelWow"))
.build_glium()
.unwrap();
+ let program = mandelwow_program(&display);
+ let bounding_box_program = solid_fill_program(&display);
+
let mut camera = support::camera::CameraState::new();
let mut t: f32 = 0.0;
- let mut z = [ 0.0, 0.0f32 ];
let mut pause = false;
+ let mut bounding_box_enabled = true;
+ let mut fullscreen = true;
support::start_loop(|| {
camera.update();
t += 0.01;
}
- // Compute a sine wave slicing the Mandelwow along its 4th dimension.
+ // 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.2,
+ zmax: 1.2,
+ };
+
+ // Vary the wow factor to slice the Mandelwow along its 4th dimension.
let wmin = -0.8;
let wmax = 0.8;
let wsize = wmax - wmin;
- let mandel_w = ((t.sin() + 1.0) / 2.0) * wsize + wmin;
+ let wow = (((t * 0.7).sin() + 1.0) / 2.0) * wsize + wmin;
- //println!("t={} z={:?} camera={:?}", t, z, camera.get_pos());
+ //println!("t={} w={:?} camera={:?}", t, w, camera.get_pos());
let mut frame = display.draw();
frame.clear_color_and_depth((0.0, 0.0, 0.0, 1.0), 1.0);
- let z_trans = -2.0; // How far back to move the model
+ let z_trans = -2.0; // Send the model back a little bit so it fits the screen.
let model = [
[ t.cos(), t.sin(), 0.0, 0.0],
[-t.sin(), t.cos(), 0.0, 0.0],
[ 0.0, 0.0, z_trans, 1.0f32]
];
- let program = mandelwow_program(&display);
- let bounding_box_program = solid_fill_program(&display);
-
- let bounds = Cube {
- xmin: -2.0,
- xmax: 0.7,
- ymin: -1.0,
- ymax: 1.0,
- zmin: -1.2,
- zmax: 1.2,
- };
-
- mandelwow(&display, &mut frame, &program, model, &camera, &bounds, mandel_w);
+ // Draw the bounding box before the fractal, when the Z-buffer is still clear, so the lines
+ // behind the semi-translucent areas will be drawn.
+ if bounding_box_enabled {
+ let uniforms = uniform! {
+ model: model,
+ view: camera.get_view(),
+ perspective: camera.get_perspective(),
+ };
+ bounding_box(&display, &mut frame, &bounding_box_program, &uniforms, &bounds);
+ }
- let uniforms = uniform! {
- model: model,
- view: camera.get_view(),
- perspective: camera.get_perspective(),
- };
- bounding_box(&display, &mut frame, &bounding_box_program, &uniforms, &bounds);
+ mandelwow(&display, &mut frame, &program, model, &camera, &bounds, wow);
+ frame.finish().unwrap();
for ev in display.poll_events() {
match ev {
- glium::glutin::Event::Closed => {
- frame.finish().unwrap();
+ glium::glutin::Event::Closed |
+ KeyboardInput(Pressed, _, Some(VirtualKeyCode::Escape)) |
+ KeyboardInput(Pressed, _, Some(VirtualKeyCode::Q)) => {
return support::Action::Stop
},
- glutin::Event::KeyboardInput(glutin::ElementState::Pressed, _, Some(glutin::VirtualKeyCode::PageUp)) => {
- t += 0.01;
+ KeyboardInput(Pressed, _, Some(VirtualKeyCode::B)) => {
+ bounding_box_enabled ^= true;
},
- glutin::Event::KeyboardInput(glutin::ElementState::Pressed, _, Some(glutin::VirtualKeyCode::PageDown)) => {
- t -= 0.01;
+ KeyboardInput(Pressed, _, Some(VirtualKeyCode::F)) => {
+ fullscreen ^= true;
+ if fullscreen {
+ glutin::WindowBuilder::new()
+ .with_fullscreen(glutin::get_primary_monitor())
+ .rebuild_glium(&display).unwrap();
+ } else {
+ glutin::WindowBuilder::new()
+ .rebuild_glium(&display).unwrap();
+ }
},
- glutin::Event::KeyboardInput(glutin::ElementState::Pressed, _, Some(glutin::VirtualKeyCode::P)) => {
+ KeyboardInput(Pressed, _, Some(VirtualKeyCode::P)) => {
pause ^= true;
},
+ KeyboardInput(Pressed, _, Some(VirtualKeyCode::PageUp)) => {
+ t += 0.01;
+ },
+ KeyboardInput(Pressed, _, Some(VirtualKeyCode::PageDown)) => {
+ t -= 0.01;
+ },
ev => camera.process_input(&ev),
}
}
- frame.finish().unwrap();
support::Action::Continue
});
+
}