Struct Texture 

pub struct Texture {
    pub id: u32,
    /* private fields */
}

Texture structure

A texture is an id inside openGL that can contain a array of byte this array can be spreaded to drawable object

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

let window = Window::new(1080, 1920, "Test");
let leave = Rc::new(Texture::new("path/to/test"));
let sprite = Sprite::from(&leave);

Fields

id: u32

Implementations

impl Texture

pub fn new() -> Texture

Create an empty texture

pub unsafe fn from_data( data: *mut c_void, mode: RgbMode, width: u32, height: u32, ) -> Texture

Create a texture from a raw data pointer needed for Font handling unsafe version of from slice

Examples found in repository

examples/texture.rs (line 16)

fn main() {
    let mut window = Window::new(gust::WIDTH, gust::HEIGHT, "Hello");
    let mut pixels: Vec<u8> = vec![125; 200 * 200 * 4];
    let pix: Vec<u8> = vec![255; 100 * 100 * 3];
    let mut my_tex = Texture::from_path("examples/texture/New.png").unwrap();
    let blank;

    unsafe {
        use std::os::raw::c_void;
        blank = Texture::from_data(pixels.as_mut_ptr() as *mut c_void, RgbMode::RGBA, 200, 200);
    }

    my_tex
        .update_block(
            pix.as_slice(),
            Vector::new(100, 100),
            Vector::new(10, 10),
            None,
        )
        .unwrap();

    let blank_rc = Rc::new(blank);
    let tex_dirt = Rc::new(my_tex);
    let event_handler = EventHandler::new(&window);
    let mut sprite = Sprite::from(&tex_dirt);
    let mut leave = Sprite::from(&blank_rc);
    let mut sprite2 = Sprite::from(&tex_dirt);

    leave.set_position(Point::new(600.0, 100.0));
    sprite.set_position(Vector::new(100.0, 100.0));
    sprite2.set_position(Point::new(1000.0, 100.0));
    sprite.update();
    sprite2.update();
    leave.update();

    window.poll(None);
    window.enable_cursor();
    window.set_clear_color(Color::new(0.0, 0.0, 1.0));
    while window.is_open() {
        window.poll_events();

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

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

pub fn from_slice( data: &mut [u8], mode: RgbMode, width: u32, height: u32, ) -> Texture

Create a texture from a slice

pub fn from_color(color: Color, sizes: Vector<u32>) -> Texture

pub fn from_size(sizes: Vector<u32>) -> Texture

Create an empty texture with a size

pub fn from_image(img: DynamicImage) -> Result<Texture, TextureError>

Create a texture from an image

pub fn from_path<P: AsRef<Path>>( path_to_file: P, ) -> Result<Texture, TextureError>

Create new texture from file path

Examples found in repository

examples/threads.rs (line 42)

fn render(shared: &mut SharedWindow, recv: mpsc::Receiver<()>) {
    shared.active();
    let texture_rc =
        Rc::new(Texture::from_path("examples/texture/Dirt.png").expect("Cannot open New.png"));
    let sprite = Sprite::from(&texture_rc);

    loop {
        if recv.try_recv() == Ok(()) {
            break;
        }
        shared.clear(Color::red());
        shared.draw(&sprite);
        shared.display();
    }
}

examples/event.rs (line 17)

fn main() {
    let mut window = Window::new(gust::WIDTH, gust::HEIGHT, "Hello");
    let tex_dirt = Rc::new(Texture::from_path("examples/texture/Dirt.png").unwrap());
    let event_handler = EventHandler::new(&window);
    let mut sprites = HashMap::new();
    sprites.insert("dirt_1", Sprite::from(&tex_dirt));
    sprites.insert("dirt_2", Sprite::from(&tex_dirt));

    window.set_clear_color(Color::new(0.0, 0.0, 1.0));
    window.enable_cursor();
    window.poll(None);
    while window.is_open() {
        window.poll_events();

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

        draw(&mut window, &mut sprites);
    }
}

examples/batch.rs (line 18)

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

    let texture = Rc::new(Texture::from_path("examples/texture/Dirt.png").unwrap());
    let mut batch = SpriteBatch::from(&texture);
    for i in 0..1_000_000 {
        let mut data = SpriteData::new(Vector::new(i as f32 * 1.0, i as f32 * 10.0));
        data.set_texture_raw([Vector::new(0.0, 0.0), Vector::new(1.0, 1.0)]);
        batch.push_sprite(data);
    }

    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();
        for event in event_handler.fetch() {
            event_process(event, &mut window, &mut batch);
        }
        window.clear();
        window.draw_mut(&mut batch);
        window.display();
    }

    Ok(())
}

examples/multi_window.rs (line 11)

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 11)

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 9)

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();
    }
}

Additional examples can be found in:

• examples/texture.rs

pub fn to_file<P: AsRef<Path>>(&self, path: P) -> Result<(), Box<dyn Error>>

Examples found in repository

examples/texture.rs (line 67)

fn event_process(event: Event, window: &mut Window, texture: &Texture, sprite: &mut Sprite) {
    match event.1 {
        Events::Key(Key::Escape, _, _, _) => {
            window.close();
        }
        Events::MouseButton(_, _, _) => {
            println!("Dumping texture to test.png");
            texture.to_file("test.png").unwrap();
        }
        Events::CursorPos(x, y) => {
            sprite.set_position(Vector::new(x as f32, y as f32));
        }
        _ => {}
    }
}

pub fn update_block<T, U>( &mut self, data: &[u8], sizes: Vector<u32>, pos: T, rgb_mode: U, ) -> Result<(), TextureError>

where T: Into<Option<Vector<u32>>>, U: Into<Option<RgbMode>>,

Update a block of a texture with an offset and a size return TextureError if the sizes are not correct.

Examples found in repository

examples/texture.rs (lines 20-25)

fn main() {
    let mut window = Window::new(gust::WIDTH, gust::HEIGHT, "Hello");
    let mut pixels: Vec<u8> = vec![125; 200 * 200 * 4];
    let pix: Vec<u8> = vec![255; 100 * 100 * 3];
    let mut my_tex = Texture::from_path("examples/texture/New.png").unwrap();
    let blank;

    unsafe {
        use std::os::raw::c_void;
        blank = Texture::from_data(pixels.as_mut_ptr() as *mut c_void, RgbMode::RGBA, 200, 200);
    }

    my_tex
        .update_block(
            pix.as_slice(),
            Vector::new(100, 100),
            Vector::new(10, 10),
            None,
        )
        .unwrap();

    let blank_rc = Rc::new(blank);
    let tex_dirt = Rc::new(my_tex);
    let event_handler = EventHandler::new(&window);
    let mut sprite = Sprite::from(&tex_dirt);
    let mut leave = Sprite::from(&blank_rc);
    let mut sprite2 = Sprite::from(&tex_dirt);

    leave.set_position(Point::new(600.0, 100.0));
    sprite.set_position(Vector::new(100.0, 100.0));
    sprite2.set_position(Point::new(1000.0, 100.0));
    sprite.update();
    sprite2.update();
    leave.update();

    window.poll(None);
    window.enable_cursor();
    window.set_clear_color(Color::new(0.0, 0.0, 1.0));
    while window.is_open() {
        window.poll_events();

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

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

pub fn get_rawsize(&self) -> usize

pub fn get_data(&self) -> Vec<u8>

Get a Vec representing pixels of the texture

pub fn update_from_texture( &mut self, texture: &Texture, pos: Vector<u32>, ) -> Result<(), TextureError>

Nicely working efficiently legacy fb deleted

pub fn update<T>(&mut self, data: &[u8], mode: T) -> Result<(), TextureError>

where T: Into<Option<RgbMode>>,

Update the data of the texture

pub fn repeat_mode(&self)

Repeat mode texture wrap

pub fn linear_mode(&self)

Linear mode for filter

pub fn unbind(&self)

Unbind the texture

pub fn active(&self, num: i32)

Active texture num

pub fn rgb_mode(&self) -> &RgbMode

Getter for color mode

pub fn width(&self) -> u32

Simple getter for width

pub fn height(&self) -> u32

Simple getter for height

Trait Implementations

impl Clone for Texture

fn clone(&self) -> Texture

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Texture

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

Formats the value using the given formatter.

impl Default for Texture

fn default() -> Texture

Create a 1 white pixel texture

impl Drop for Texture

fn drop(&mut self)

Executes the destructor for this type.

impl PartialEq for Texture

fn eq(&self, other: &Texture) -> 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 Eq for Texture

impl StructuralPartialEq for Texture