Struct piston_window::image::Image[][src]

pub struct Image {
    pub color: Option<[f32; 4]>,
    pub rectangle: Option<[f64; 4]>,
    pub source_rectangle: Option<[f64; 4]>,

An image


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(
				[600, 400]

	//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 {
		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);


color: Option<[f32; 4]>

The color

rectangle: Option<[f64; 4]>

The rectangle to draw image inside

source_rectangle: Option<[f64; 4]>

The image source rectangle


impl Image[src]

pub fn new() -> Image[src]

Creates a new image

pub fn new_color(color: [f32; 4]) -> Image[src]

Creates a new colored image

pub fn color(self, value: [f32; 4]) -> Image[src]

Sets color.

pub fn maybe_color(self, value: Option<[f32; 4]>) -> Image[src]

Sets optional color.

pub fn rect<R>(self, value: R) -> Image where
    R: Into<[f64; 4]>, 

Sets rectangle.

pub fn maybe_rect<R>(self, value: Option<R>) -> Image where
    R: Into<[f64; 4]>, 

Sets optional rectangle.

pub fn src_rect(self, value: [f64; 4]) -> Image[src]

Sets source rectangle.

pub fn maybe_src_rect(self, value: Option<[f64; 4]>) -> Image[src]

Sets optional source rectangle.

pub fn draw<G>(
    texture: &<G as Graphics>::Texture,
    draw_state: &DrawState,
    transform: [[f64; 3]; 2],
    g: &mut G
) where
    G: Graphics

Draws image using default method.

pub fn draw_tri<G>(
    texture: &<G as Graphics>::Texture,
    draw_state: &DrawState,
    transform: [[f64; 3]; 2],
    g: &mut G
) where
    G: Graphics

Draws image using triangulation.

Trait Implementations

impl Clone for Image[src]

impl Copy for Image[src]

Auto Trait Implementations

impl RefUnwindSafe for Image

impl Send for Image

impl Sync for Image

impl Unpin for Image

impl UnwindSafe for Image

Blanket Implementations

impl<T> Any for T where
    T: 'static + ?Sized

impl<T> Borrow<T> for T where
    T: ?Sized

impl<T> BorrowMut<T> for T where
    T: ?Sized

impl<T> From<T> for T[src]

impl<T, U> Into<U> for T where
    U: From<T>, 

impl<T> Pointable for T[src]

type Init = T

The type for initializers.

impl<T> ToOwned for T where
    T: Clone

type Owned = T

The resulting type after obtaining ownership.

impl<T, U> TryFrom<U> for T where
    U: Into<T>, 

type Error = Infallible

The type returned in the event of a conversion error.

impl<T, U> TryInto<U> for T where
    U: TryFrom<T>, 

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.