deltamap 0.2.0

A simple map viewer 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80

use ::std::ffi::CStr;
use buffer::{Buffer, DrawMode};
use context::Context;
use orthografic_view::OrthograficView;
use program::{Program, UniformId};
use std::f32::consts::PI;
use vertex_attrib::VertexAttribParams;


#[derive(Debug)]
pub struct AtmosLayer {
    buffer: Buffer,
    program: Program,
    scale_uniform: UniformId,
}

impl AtmosLayer {
    pub fn new(cx: &mut Context) -> AtmosLayer {
        let vertex_data = {
            let mut vertex_data: Vec<f32> = Vec::with_capacity(17 * 4);

            let radius_a = 0.75;
            let radius_b = 1.25;
            for x in 0..17 {
                let angle = x as f32 * (PI * 2.0 / 16.0);
                vertex_data.extend(&[
                    angle.cos() * radius_a,
                    angle.sin() * radius_a,
                    angle.cos() * radius_b,
                    angle.sin() * radius_b,
                ]);
            }

            vertex_data
        };

        let buffer = Buffer::new(cx, &vertex_data, vertex_data.len() / 2);

        let mut program = Program::new(
            cx,
            include_bytes!("../shader/atmos.vert"),
            include_bytes!("../shader/atmos.frag"),
        ).unwrap();

        program.add_attribute(
            cx,
            CStr::from_bytes_with_nul(b"position\0").unwrap(),
            &VertexAttribParams::new(2, 2, 0)
        );

        let scale_uniform = program.get_uniform_id(cx, CStr::from_bytes_with_nul(b"scale\0").unwrap()).unwrap();

        AtmosLayer {
            buffer,
            program,
            scale_uniform,
        }
    }

    // Has to be called once before one or multiple calls to `draw`.
    pub fn prepare_draw(&mut self, cx: &mut Context) {
        self.program.enable_vertex_attribs(cx);
        self.program.set_vertex_attribs(cx, &self.buffer);
    }

    pub fn draw(
        &mut self,
        cx: &mut Context,
        ortho: &OrthograficView,
    ) {
        let (scale_x, scale_y) = {
            let diam = ortho.diameter_physical_pixels();
            ((diam / ortho.viewport_size.x) as f32, (diam / ortho.viewport_size.y) as f32)
        };

        self.program.set_uniform_2f(cx, self.scale_uniform, scale_x, scale_y);

        self.buffer.draw(cx, &self.program, DrawMode::TriangleStrip);
    }
}