Struct Rect 

pub struct Rect { /* private fields */ }

Utilies for working with Image type. As with other APIs, the (0, 0) position is left top of the screen, then it grows downward and rightward.

Implementations

impl Rect

pub fn new(x: i32, y: i32, w: u32, h: u32) -> Rect

Examples found in repository

examples/image_bench.rs (line 66)

fn main() {
    //let (width, height) = orbclient::get_display_size().unwrap();

    let mut window = Window::new(10, 10, 800, 600, "IMAGE BENCHMARK").unwrap();

    window.set(Color::rgb(255, 255, 255));

    //create image data : a green square
    let data = vec![Color::rgba(100, 200, 10, 3); 412500];
    let mut data2 = vec![Color::rgba(200, 100, 10, 3); 412500];
    let mut data3 = vec![Color::rgba(10, 100, 100, 3); 412500];
    let mut data4 = vec![Color::rgba(10, 100, 200, 3); 800 * 400];

    //draw image benchmarking
    println!("Benchmarking implementations to draw an image on window:");

    time!("image_legacy", {
        for _i in 0..TIMES {
            window.image_legacy(15, 15, 750, 550, &data[..]);
        }
    });

    time!("image_over", {
        for _i in 0..TIMES {
            window.image_over(50, &data4[..]);
        }
    });

    time!("image_fast", {
        for _i in 0..TIMES {
            window.image_fast(20, 20, 750, 550, &data2[..]);
        }
    });

    time!("image_opaque", {
        for _i in 0..TIMES {
            window.image_opaque(30, 30, 750, 550, &data3[..]);
        }
    });

    time!("image_roi_mut_blend", {
        let data2_roi = ImageRef::from_data(750, 550, &mut data2[..]);
        for _i in 0..TIMES {
            ImageRef::from_renderer(&mut window)
                .roi_mut(&Rect::new(40, 40, 750, 550))
                .blend(&data2_roi.roi(&Rect::new(0, 0, 750, 550)));
        }
    });

    time!("image_roi_mut_blit_mask", {
        let data2_roi = ImageRef::from_data(750, 550, &mut data2[..]);
        for _i in 0..TIMES {
            ImageRef::from_renderer(&mut window)
                .roi_mut(&Rect::new(40, 40, 750, 550))
                .blit_mask(&data2_roi.roi(&Rect::new(0, 0, 750, 550)));
        }
    });

    time!("image_roi_mut_blit", {
        let data3_roi = ImageRef::from_data(750, 550, &mut data3[..]);
        for _i in 0..TIMES {
            ImageRef::from_renderer(&mut window)
                .roi_mut(&Rect::new(50, 50, 750, 550))
                .blit(&data3_roi.roi(&Rect::new(0, 0, 750, 550)));
        }
    });

    time!("image_roi_mut_blit_over", {
        let data4_roi = ImageRef::from_data(800, 400, &mut data4[..]);
        for _i in 0..TIMES {
            ImageRef::from_renderer(&mut window)
                // .roi_mut(&Rect::new(10, 120, 790, 400)) // to test blit_over does not trigger
                .roi_mut(&Rect::new(0, 120, 800, 400))
                .blit(&data4_roi.roi(&Rect::new(0, 0, 800, 400)));
        }
    });

    println!("------------------------------------------------");

    window.sync();

    'events: loop {
        for event in window.events() {
            match event.to_option() {
                EventOption::Quit(_quit_event) => break 'events,
                EventOption::Mouse(evt) => println!(
                    "At position {:?} pixel color is : {:?}",
                    (evt.x, evt.y),
                    window.getpixel(evt.x, evt.y)
                ),
                event_option => println!("{:?}", event_option),
            }
        }
    }
}

pub fn area(&self) -> usize

Return (width * height) as usize, which you can use it as a buffer length in an array.

pub fn left(&self) -> i32

pub fn right(&self) -> i32

pub fn top(&self) -> i32

pub fn bottom(&self) -> i32

pub fn width(&self) -> u32

pub fn height(&self) -> u32

pub fn iwidth(&self) -> i32

A convenient type for width() with i32 for rect calculations. Consider to use other utilities functions if it suitable.

pub fn iheight(&self) -> i32

A convenient type for height() with i32 for rect calculations. Consider to use other utilities functions if it suitable.

pub fn container(&self, other: &Rect) -> Rect

Create a union between two Rectangles. If the two does not overlap, the returned Rect will be larger than two rectangle areas.

pub fn contains(&self, x: i32, y: i32) -> bool

Check if a point is in or at the edge of Rectangle. To check if two Rectangle overlaps, use !a.intersection(b).is_empty().

pub fn is_empty(&self) -> bool

Check if this rectangle is not empty.

pub fn intersection(&self, other: &Rect) -> Rect

Create an intersection between two Rectangles. If the two does not overlap, the returned Rect will be empty.

pub fn translate(self, x: i32, y: i32) -> Rect

Return a new Rect with new moved position

pub fn resize(self, w: u32, h: u32, align: RectAlignment) -> Rect

Return a new Rect with new size. The position will be adjusted depending to alignment. If you want to leave the position unchanged, use RectAlignment::TopLeft

pub fn edge(self, inset: u32, outset: u32, align: RectEdge) -> Rect

Return a new Rect with new width or height depending on alignment edge. The new width or height is calculated as (inset + outset), the difference between the two is whether you want the rectangle grows inward or outward.

Trait Implementations

impl Clone for Rect

fn clone(&self) -> Rect

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for Rect

impl Debug for Rect

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

Formats the value using the given formatter.

impl Default for Rect

fn default() -> Rect

Returns the “default value” for a type.