Subversion Repositories pdp1

#[macro_use]

extern crate glium;

extern crate rand;

extern crate time;

fn main() {

    use rand::Rng;

    let mut rng = rand::thread_rng();

    use glium::DisplayBuild;

    let builder = glium::glutin::WindowBuilder::new();

    let window = builder

        .with_dimensions(1024,1024)

        .with_title("GLscope")

        .with_vsync()

        .build_glium()

        .unwrap();

    let mut now: f32;

    // 2D vertex type for plot points

    #[derive(Copy, Clone, Debug)]

    struct Vertex {

        position: [f32; 2],

        time: f32  // Suggest using microseconds

    }

    implement_vertex!(Vertex, position, time);

    // Note: need to transform -1023..1023 to -1..1

    // Could extend PDP-1 display instruction to 18 bit

    // TODO: Set up OpenGL stuff to draw something

    //window.make_current().expect("Couldn't make context current");

    let mut frame = window.draw();

    use glium::Surface;

    // So far, so good. I can clear the image.

    // I can also plot points, using two shaders.

    // Those can be blended (additive in this case).

    // Time to extend the vertices with a timestamp for age?

    // Set up a random array of points

    /*

    let mut shape: Vec = Vec::new();

    for t in 0..20000 {

        shape.push(Vertex {

            position: [rng.next_f32()*2.0-1.0,

                       rng.next_f32()*2.0-1.0],

            time: t as f32 });

    }*/

    let vbmax = 20000;

    let mut vbindex = 0;

    // TODO: streaming suited vertexbuffer.

    // Docs say to use dynamic, persistent might be GL4?

    let mut vertex_buffer : glium::VertexBuffer =

        glium::VertexBuffer::empty_dynamic(&window, vbmax).unwrap();

    // Possible todo: add line support, perhaps modulated

    // by beam trace speed.

    let indices = glium::index::NoIndices(

        glium::index::PrimitiveType::Points);

    let vertex_shader_src = r#"

        #version 140

        in vec2 position;

        in float time;

        out float age;

        uniform float now;

        void main() {

            age = now-time;

            if (age >= 0) {

                gl_Position = vec4(position, 0.0, 1.0);

            }

        }

    "#;

    // Should use a uniform to indicate current time

    // Possibly add a timestamp per lit dot?

    let fragment_shader_src = r#"

        #version 140

        in float age;

        out vec4 color;

        void main() {

            float intensity = 1e1*exp(-8e-6*age);

            color = vec4(intensity, intensity, intensity, 1.0);

        }

    "#;

    let program =

       glium::Program::from_source(&window,

                                   vertex_shader_src,

                                   fragment_shader_src,

                                   None).unwrap();

    let drawparams = glium::DrawParameters {

        blend: glium::Blend {

            color: glium::BlendingFunction::Addition {

                source: glium::LinearBlendingFactor::One,

                destination: glium::LinearBlendingFactor::One },

            .. Default::default() },

        .. Default::default()

    };

    let t0 = time::get_time();

    use std::sync::mpsc::{channel, Receiver};

    let verts : Receiver = {

        use std::thread::spawn;

        let (tx, rx) = channel();

        spawn(move || {

            loop {

                let mut str = String::new();

                std::io::stdin().read_line(&mut str).unwrap();

                let now = (time::get_time() - t0)

                    .num_microseconds().unwrap() as f32;

                // FIXME: Parse line.

                let mut words = str.split_whitespace();

                let x = words.next().unwrap().parse().unwrap();

                let y = words.next().unwrap().parse().unwrap();

                let v = Vertex {position: [x, y], time: now };

                tx.send(v).unwrap();

                //println!("Vertex: {:?}", v);

            }

        });

        rx

    };

    loop {

        for event in window.poll_events() {

            // Simplest nowait: use poll_events()

            match event {

                glium::glutin::Event::Closed => {

                    frame.finish().unwrap();

                    return;

                },

                _ => ()

            }

        }

        now = (time::get_time() - t0).num_microseconds().unwrap()

            as f32;

        // Inject new points

        {

            let mut wvb = vertex_buffer.map_write();

            // Add 21 random points per frame

            for _ in 0..20 {

                wvb.set(vbindex, Vertex {

                    position: [rng.next_f32()*2.0-1.0,

                               rng.next_f32()*2.0-1.0],

                    time: now });

                vbindex = (vbindex+1) % vbmax;

            }

            // TODO: Read points from e.g. stdin

            for v in verts.try_iter() {

                //println!("Vertex: {:?} {} {}",

                //         v.position, v.time, now);

                wvb.set(vbindex, v);

                vbindex = (vbindex+1) % vbmax;

            }

        }

        // Closing the window closes the program.

        frame.clear_color(0.0, 0.0, 0.0, 1.0);

        frame.draw(&vertex_buffer, &indices, &program,

                   //&glium::uniforms::EmptyUniforms,

                   &uniform! { now: now },

                   &drawparams).unwrap();

        window.swap_buffers().unwrap();

    }

}