piston2d-graphics 0.16.0

//! Draw an image

use types::{ Color, Rectangle, SourceRectangle };
use triangulation;
use Graphics;
use ImageSize;
use DrawState;
use math::Matrix2d;


/// An image
///
/// # Example
///
/// ```ignore
/// extern crate piston;
/// extern crate graphics;
/// extern crate glutin_window;
/// extern crate opengl_graphics;
///
/// use piston::window::WindowSettings;
/// use piston::event::*;
/// use glutin_window::GlutinWindow as Window;
/// use opengl_graphics::{GlGraphics, OpenGL, Texture};
/// use graphics::{Image, clear, default_draw_state};
/// use graphics::rectangle::square;
/// use std::path::Path;
///
/// fn main() {
/// 	let opengl  = OpenGL::_3_2;
/// 	let mut gl  = GlGraphics::new(opengl);
/// 	let window  = Window::new(
/// 			opengl,
/// 			WindowSettings::new(
/// 				"Example",
/// 				[600, 400]
/// 			).exit_on_esc(true));
///
/// 	//Create the image object and attach a square Rectangle object inside.
/// 	let image   = Image::new().rect(square(0.0, 0.0, 200.0));
/// 	//A texture to use with the image
/// 	let texture = Texture::from_path(Path::new("Example.png")).unwrap();
///
/// 	//Main loop
/// 	for e in window.events() {
/// 		if let Some(r) = e.render_args() {
/// 			gl.draw(r.viewport(), |c, gl| {
/// 				//Clear the screen
/// 				clear([0.0, 0.0, 0.0, 1.0], gl);
/// 				//Draw the image with the texture
/// 				image.draw(&texture, default_draw_state(), c.transform, gl);
/// 			});
/// 		}
/// 	}
/// }
/// ```
#[derive(Copy, Clone)]
pub struct Image {
    /// The color
    pub color: Option<Color>,
    /// The rectangle to draw image inside
    pub rectangle: Option<Rectangle>,
    /// The image source rectangle
    pub source_rectangle: Option<SourceRectangle>,
}

impl Image {
    /// Creates a new image
    pub fn new() -> Image {
        Image {
            color: None,
            source_rectangle: None,
            rectangle: None,
        }
    }

    /// Creates a new colored image
    pub fn new_color(color: Color) -> Image {
        Image {
            color: Some(color),
            source_rectangle: None,
            rectangle: None
        }
    }

    /// Sets color.
    pub fn color(mut self, value: Color) -> Self {
        self.color = Some(value);
        self
    }

    /// Sets optional color.
    pub fn maybe_color(mut self, value: Option<Color>) -> Self {
        self.color = value;
        self
    }

    /// Sets rectangle.
    pub fn rect<R: Into<Rectangle>>(mut self, value: R) -> Self {
        self.rectangle = Some(value.into());
        self
    }

    /// Sets optional rectangle.
    pub fn maybe_rect<R: Into<Rectangle>>(mut self, value: Option<R>) -> Self {
        self.rectangle = value.map(|v| v.into());
        self
    }

    /// Sets source rectangle.
    pub fn src_rect(mut self, value: SourceRectangle) -> Self {
        self.source_rectangle = Some(value);
        self
    }

    /// Sets optional source rectangle.
    pub fn maybe_src_rect(mut self, value: Option<SourceRectangle>) -> Self {
        self.source_rectangle = value;
        self
    }

    /// Draws image using default method.
    #[inline(always)]
    pub fn draw<G>(
        &self,
        texture: &<G as Graphics>::Texture,
        draw_state: &DrawState,
        transform: Matrix2d,
        g: &mut G
    )
        where G: Graphics
    {
        g.image(self, texture, draw_state, transform);
    }

    /// Draws image using triangulation.
    pub fn draw_tri<G>(
        &self,
        texture: &<G as Graphics>::Texture,
        draw_state: &DrawState,
        transform: Matrix2d,
        g: &mut G
    )
        where G: Graphics
    {
        use math::Scalar;

        let color = self.color.unwrap_or([1.0; 4]);
        let source_rectangle = self.source_rectangle.unwrap_or({
            let (w, h) = texture.get_size();
            [0, 0, w as i32, h as i32]
        });
        let rectangle = self.rectangle.unwrap_or([
            0.0,
            0.0,
            source_rectangle[2] as Scalar,
            source_rectangle[3] as Scalar
        ]);
        g.tri_list_uv(
            draw_state,
            &color,
            texture,
            |f| f(
                &triangulation::rect_tri_list_xy(transform, rectangle),
                &triangulation::rect_tri_list_uv(texture, source_rectangle)
            )
        );
    }
}

/// Draws many images.
pub fn draw_many<G>(
    rects: &[(Rectangle, SourceRectangle)],
    color: Color,
    texture: &<G as Graphics>::Texture,
    draw_state: &DrawState,
    transform: Matrix2d,
    g: &mut G
) where G: Graphics {
    g.tri_list_uv(
        draw_state,
        &color,
        texture,
            |f|
            for r in rects {
                f(
                &triangulation::rect_tri_list_xy(transform, r.0),
                &triangulation::rect_tri_list_uv(texture, r.1)
                )
            }
    );
}

#[cfg(test)]
mod test {
    use super::Image;

    #[test]
    fn test_image() {
        let _img = Image::new()
            .color([1.0; 4])
            .rect([0.0, 0.0, 100.0, 100.0])
            .src_rect([0, 0, 32, 32]);
    }
}