Struct Sprite 

pub struct Sprite { /* private fields */ }

A sprite is a transformable drawable sprite

Display a sprite from a texture

use texture::Texture;
use sprite::Sprite;

let texture = Texture::new("assets/texture.jpg");
let sprite = Sprite::from_texture(Rc::clone(&texutre));
sprite.rotate(45.0);
sprite.set_position(Vector2::new(100.0, 200.0));

A sprite is just attributes for textures to become printable …

Implementations

impl Sprite

pub fn new() -> Sprite

Create a empty sprite It’s not very useful but you can assign texture later

pub fn set_color(&mut self, color: &Color)

Set texture color

Examples found in repository

examples/event.rs (line 83)

fn event_process(event: Event, window: &mut Window, sprites: &mut HashMap<&'static str, Sprite>) {
    match event.1 {
        pressed!(Escape) => window.close(),
        pressed!(Space) => {
            sprites.get_mut("dirt_1").unwrap().rotate(45.0);
        }
        pressed!(W) => {
            sprites
                .get_mut("dirt_2")
                .unwrap()
                .translate(Vector::new(0.0, -10.0));
        }
        pressed!(A) => {
            sprites
                .get_mut("dirt_2")
                .unwrap()
                .translate(Vector::new(-10.0, 0.0));
        }
        pressed!(S) => {
            sprites
                .get_mut("dirt_2")
                .unwrap()
                .translate(Vector::new(0.0, 10.0));
        }
        pressed!(D) => {
            sprites
                .get_mut("dirt_2")
                .unwrap()
                .translate(Vector::new(10.0, 0.0));
        }
        Events::MouseButton(glfw::MouseButtonLeft, Action::Press, _) => {
            let mouse_pos = window.mouse_pos();

            if let Some(sprite) = sprites.get_mut("dirt_1") {
                if sprite.contain(mouse_pos) {
                    sprite.set_color(&Color::blue());
                }
            }
        }
        _ => {}
    }
}

pub fn get_sizes(&self) -> Vector2<u32>

Get texture sizes

pub fn set_origin_to_center(&mut self) -> Result<(), SpriteError>

Set origin to center of the sprite. Can fail because a sprite sizes are defined by it’s texture, sometimes it can happend that there isn’t one. So it return an SpriteError::NoTexture

Examples found in repository

examples/multi_window.rs (line 18)

fn window1() -> Result<(), Box<Error>> {
    let mut window = Window::new(600, 600, "Hello1");
    let tex_leave = Rc::new(Texture::from_path("examples/texture/Z.png").unwrap());
    let tex_dirt = Rc::new(Texture::from_path("examples/texture/Dirt.png").unwrap());
    let mut sprite = Sprite::from(&tex_dirt);
    let mut leave = Sprite::from(&tex_leave);
    leave.set_position(Point::new(500.0, 500.0));
    sprite.set_position(Point::new(10.0, 10.0));
    leave.set_scale(Vector::new(0.5, 0.5));
    leave.set_origin_to_center()?;

    let event_handler = EventHandler::new(&window);

    window.set_clear_color(Color::new(0.45, 0.0, 1.0));
    window.enable_cursor();
    window.poll(None);

    while window.is_open() {
        window.poll_events();
        leave.rotate(1.0);
        leave.update();
        sprite.update();

        for event in event_handler.fetch() {
            event_process(event, &mut window);
        }

        window.clear();
        window.draw(&mut sprite);
        window.draw(&mut leave);
        window.display();
    }
    Ok(())
}

examples/basic.rs (line 18)

fn main() -> Result<(), Box<Error>> {
    let mut window = Window::new(gust::WIDTH, gust::HEIGHT, "Hello");

    let tex_leave = Rc::new(Texture::from_path("examples/texture/Z.png").unwrap());
    let tex_dirt = Rc::new(Texture::from_path("examples/texture/Dirt.png").unwrap());
    let mut sprite = Sprite::from(&tex_dirt);
    let mut leave = Sprite::from(&tex_leave);
    leave.set_position(Point::new(500.0, 500.0));
    sprite.set_position(Point::new(10.0, 10.0));
    leave.set_scale(Vector::new(0.5, 0.5));
    leave.set_origin_to_center()?;

    let event_handler = EventHandler::new(&window);

    window.set_clear_color(Color::new(0.45, 0.0, 1.0));
    window.enable_cursor();
    window.poll(None);

    while window.is_open() {
        window.poll_events();
        leave.rotate(1.0);
        leave.update();
        sprite.update();

        for event in event_handler.fetch() {
            event_process(event, &mut window);
        }

        window.clear();
        window.draw(&sprite);
        window.draw(&leave);
        window.display();
    }

    Ok(())
}

examples/view.rs (line 21)

fn main() {
    let mut window = Window::new(gust::WIDTH, gust::HEIGHT, "Hello");
    let tex_leave = Rc::new(Texture::from_path("examples/texture/Z.png").unwrap());
    let tex_dirt = Rc::new(Texture::from_path("examples/texture/Dirt.png").unwrap());
    let event_handler = EventHandler::new(&window);
    let mut sprite = Sprite::from(&tex_dirt);
    let mut leave = Sprite::from(&tex_leave);

    leave.set_position(Point::new(300.0, 300.0));
    window.set_clear_color(Color::new(0.0, 0.0, 1.0));
    window.enable_cursor();
    window.poll(None);
    leave.set_scale(Vector::new(0.5, 0.5));
    leave
        .set_origin_to_center()
        .unwrap_or_else(|e| println!("{}", e));
    while window.is_open() {
        window.poll_events();
        leave.rotate(1.0);
        leave.update();
        sprite.update();
        window.view_mut().update();

        for event in event_handler.fetch() {
            event_process(event, &mut window);
        }

        window.clear();
        window.draw(&mut sprite);
        window.draw(&mut leave);
        window.display();
    }
}

pub fn set_texture(&mut self, texture: &Resource<Texture>)

Set a new texture and set the sprite to update state.

Trait Implementations

impl Clone for Sprite

fn clone(&self) -> Sprite

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Sprite

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for Sprite

fn default() -> Self

Returns the “default value” for a type.

impl Drawable for Sprite

Drawing trait for sprite sturct

fn draw<T: Drawer>(&self, window: &mut T)

Draw the actual sprite on a context

fn draw_with_context<'a>(&self, context: &'a mut Context<'_>)

Draw the actual sprite with your own context.

fn update(&mut self)

Update the sprite, this is a heavy operation because it’s an operation that reconstruct the model matrix (that represent transformation of the sprite) from scratch. However this function is computed only when it’s necessary. (self.need_update == true) TODO: Make this computation in shader program.

fn setup_draw(&self, context: &mut Context<'_>)

Setup the draw for the final system you don’t have to implement it in a normal drawable

impl DrawableMut for Sprite

fn draw_mut<T: Drawer>(&mut self, window: &mut T)

Draw the actual sprite on a context

fn draw_with_context_mut<'a>(&mut self, context: &'a mut Context<'_>)

Mutable draw context function.

impl<'a> From<&'a Rc<Texture>> for Sprite

fn from(tex: &'a Resource<Texture>) -> Sprite

You can create sprite from texture (precisly Rc)

use gust::texture::Texture;
use gust::sprite::Sprite;
use std::rc::Rc;

let texture = Rc::new(Texture::new("My great texture"));
let personnage = Sprite::from(&texture);

impl Movable for Sprite

fn translate<T>(&mut self, vec: Vector2<T>)

where T: Scalar + Into<f32>,

Move the sprite off the offset

fn get_position(&self) -> Vector2<f32>

Get current position

fn set_position<T>(&mut self, vec: Vector2<T>)

where T: Scalar + Into<f32>,

Set position of the sprite

impl PartialEq for Sprite

fn eq(&self, other: &Sprite) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Rotable for Sprite

fn rotate<T>(&mut self, angle: T)

where T: Scalar + Into<f32>,

Rotate from the actual angle with the angle given in argument.

fn set_rotation<T>(&mut self, angle: T)

where T: Scalar + Into<f32>,

Set the rotation of the Rotable struct.

fn get_rotation(&self) -> f32

Return the rotation of the struct.

impl Scalable for Sprite

fn set_scale<T>(&mut self, vec: Vector2<T>)

where T: Scalar + Into<f32>,

Set the scale of the sprite

fn get_scale(&self) -> Vector2<f32>

Get the current scale

fn scale<T>(&mut self, factor: Vector2<T>)

where T: Scalar + Into<f32>,

Scale the sprite from a factor

impl Transformable for Sprite

fn contain<T: Scalar + Into<f32>>(&self, _point: Point<T>) -> bool

TODO: Transform the point tested.

fn set_origin<T: Scalar + Into<f32>>(&mut self, origin: Vector2<T>)

Set the origin of the object.

fn get_origin(&self) -> Vector2<f32>

Get the origin of the transformable.

impl StructuralPartialEq for Sprite