abstreet/ezgui/src/drawing.rs
2019-01-31 22:33:36 -08:00

182 lines
5.8 KiB
Rust

use crate::{
Canvas, Color, Drawable, HorizontalAlignment, Prerender, ScreenPt, Text, VerticalAlignment,
};
use geom::{Bounds, Circle, Distance, Line, Polygon, Pt2D};
use glium::{uniform, Surface};
const TRIANGLES_PER_CIRCLE: usize = 60;
type Uniforms<'a> = glium::uniforms::UniformsStorage<
'a,
[f32; 2],
glium::uniforms::UniformsStorage<'a, [f32; 3], glium::uniforms::EmptyUniforms>,
>;
pub struct GfxCtx<'a> {
display: &'a glium::Display,
target: &'a mut glium::Frame,
program: &'a glium::Program,
uniforms: Uniforms<'a>,
params: glium::DrawParameters<'a>,
// TODO Don't be pub. Delegate everything.
pub canvas: &'a Canvas,
pub num_new_uploads: usize,
pub num_draw_calls: usize,
}
impl<'a> GfxCtx<'a> {
pub fn new(
canvas: &'a Canvas,
display: &'a glium::Display,
target: &'a mut glium::Frame,
program: &'a glium::Program,
) -> GfxCtx<'a> {
let params = glium::DrawParameters {
blend: glium::Blend::alpha_blending(),
..Default::default()
};
let uniforms = uniform! {
transform: [canvas.cam_x as f32, canvas.cam_y as f32, canvas.cam_zoom as f32],
window: [canvas.window_width as f32, canvas.window_height as f32],
};
GfxCtx {
canvas,
display,
target,
program,
uniforms,
params,
num_new_uploads: 0,
num_draw_calls: 0,
}
}
// Up to the caller to call unfork()!
// TODO Canvas doesn't understand this change, so things like text drawing that use
// map_to_screen will just be confusing.
pub fn fork(&mut self, top_left_map: Pt2D, top_left_screen: ScreenPt, zoom: f64) {
// map_to_screen of top_left_map should be top_left_screen
let cam_x = (top_left_map.x() * zoom) - top_left_screen.x;
let cam_y = (top_left_map.y() * zoom) - top_left_screen.y;
self.uniforms = uniform! {
transform: [cam_x as f32, cam_y as f32, zoom as f32],
window: [self.canvas.window_width as f32, self.canvas.window_height as f32],
};
}
pub fn fork_screenspace(&mut self) {
self.uniforms = uniform! {
transform: [0.0, 0.0, 1.0],
window: [self.canvas.window_width as f32, self.canvas.window_height as f32],
};
}
pub fn unfork(&mut self) {
self.uniforms = uniform! {
transform: [self.canvas.cam_x as f32, self.canvas.cam_y as f32, self.canvas.cam_zoom as f32],
window: [self.canvas.window_width as f32, self.canvas.window_height as f32],
};
}
pub fn clear(&mut self, color: Color) {
// Without this, SRGB gets enabled and post-processes the color from the fragment shader.
self.target
.clear_color_srgb(color.0[0], color.0[1], color.0[2], color.0[3]);
}
// Use graphics::Line internally for now, but make it easy to switch to something else by
// picking this API now.
pub fn draw_line(&mut self, color: Color, thickness: Distance, line: &Line) {
self.draw_polygon(color, &line.make_polygons(thickness));
}
pub fn draw_rounded_line(&mut self, color: Color, thickness: Distance, line: &Line) {
self.draw_polygon_batch(vec![
(color, &line.make_polygons(thickness)),
(
color,
&Circle::new(line.pt1(), thickness / 2.0).to_polygon(TRIANGLES_PER_CIRCLE),
),
(
color,
&Circle::new(line.pt2(), thickness / 2.0).to_polygon(TRIANGLES_PER_CIRCLE),
),
]);
}
pub fn draw_arrow(&mut self, color: Color, thickness: Distance, line: &Line) {
let polygons = line.make_arrow(thickness);
self.draw_polygon_batch(polygons.iter().map(|poly| (color, poly)).collect());
}
pub fn draw_circle(&mut self, color: Color, circle: &Circle) {
self.draw_polygon(color, &circle.to_polygon(TRIANGLES_PER_CIRCLE));
}
pub fn draw_polygon(&mut self, color: Color, poly: &Polygon) {
let obj = Prerender {
display: self.display,
}
.upload_borrowed(vec![(color, poly)]);
self.num_new_uploads += 1;
self.redraw(&obj);
}
pub fn draw_polygon_batch(&mut self, list: Vec<(Color, &Polygon)>) {
let obj = Prerender {
display: self.display,
}
.upload_borrowed(list);
self.num_new_uploads += 1;
self.redraw(&obj);
}
pub fn redraw(&mut self, obj: &Drawable) {
self.target
.draw(
&obj.vertex_buffer,
&obj.index_buffer,
&self.program,
&self.uniforms,
&self.params,
)
.unwrap();
self.num_draw_calls += 1;
}
// Forwarded canvas stuff.
pub fn draw_blocking_text(
&mut self,
txt: Text,
(horiz, vert): (HorizontalAlignment, VerticalAlignment),
) {
self.canvas.draw_blocking_text(self, txt, (horiz, vert));
}
pub fn get_screen_bounds(&self) -> Bounds {
self.canvas.get_screen_bounds()
}
pub fn draw_text_at(&mut self, txt: Text, map_pt: Pt2D) {
self.canvas.draw_text_at(self, txt, map_pt);
}
pub fn text_dims(&self, txt: &Text) -> (f64, f64) {
self.canvas.text_dims(txt)
}
pub fn draw_text_at_screenspace_topleft(&mut self, txt: Text, pt: ScreenPt) {
self.canvas.draw_text_at_screenspace_topleft(self, txt, pt);
}
pub fn draw_mouse_tooltip(&mut self, txt: Text) {
self.canvas.draw_mouse_tooltip(self, txt);
}
pub fn screen_to_map(&self, pt: ScreenPt) -> Pt2D {
self.canvas.screen_to_map(pt)
}
pub fn get_cursor_in_map_space(&self) -> Option<Pt2D> {
self.canvas.get_cursor_in_map_space()
}
}