stb_rect_pack 0.3.0

Wrapper over stb_rect_pack_sys, offering a cleaner abstraction than the bindgen generated interface
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114

use std::error::Error;

#[derive(thiserror::Error, Debug)]
pub enum PackError {
    #[error("No input given")]
    NoInput,
    #[error("Unexpected input dimension")]
    Dimension(String),
    #[error("Failed to pack")]
    FailedToPack,
}

#[derive(Debug, Clone, PartialEq, Eq)]
pub struct Rect {
    pub width: i32,
    pub height: i32,
    pub packed_top_left_x: i32,
    pub packed_top_left_y: i32,
}

impl Rect {
    pub fn new(width: i32, height: i32) -> Rect {
        Self {
            width,
            height,
            packed_top_left_x: 0,
            packed_top_left_y: 0,
        }
    }
}

/// Pack rects into width x height output rect.
/// See [stb_rect_pack](https://github.com/nothings/stb/blob/master/stb_rect_pack.h) for algorithm details.
pub fn pack(rects: &mut [Rect], width: i32, height: i32) -> Result<(), Box<dyn Error>> {
    if rects.is_empty() {
        Err(PackError::NoInput)?
    }

    let mut stb_rects = Vec::new();

    for (i, rect) in rects.iter().enumerate() {
        if rect.width <= 0 || rect.height <= 0 {
            Err(PackError::Dimension("Zero-sized input rect".to_owned()))?
        }
        stb_rects.push(stb_rect_pack_sys::stbrp_rect {
            id: i as i32,
            w: rect.width,
            h: rect.height,
            x: 0,
            y: 0,
            was_packed: 0,
        });
    }

    let mut context = stb_rect_pack_sys::stbrp_context::default();
    let mut tmp_nodes: Vec<stb_rect_pack_sys::stbrp_node> =
        vec![stb_rect_pack_sys::stbrp_node::default(); 4 * rects.len()];

    unsafe {
        stb_rect_pack_sys::stbrp_init_target(
            &mut context as *mut _,
            width,
            height,
            tmp_nodes.as_mut_ptr(),
            tmp_nodes.len() as _,
        )
    }

    let pack_result = unsafe {
        stb_rect_pack_sys::stbrp_pack_rects(
            &mut context as *mut _,
            stb_rects.as_mut_ptr(),
            stb_rects.len() as i32,
        )
    };

    if pack_result != 1 {
        Err(PackError::FailedToPack)?
    }

    'outer: for (i, rect) in rects.iter_mut().enumerate() {
        for stb_rect in &stb_rects {
            if stb_rect.id == i as i32 {
                rect.packed_top_left_x = stb_rect.x;
                rect.packed_top_left_y = stb_rect.y;
                continue 'outer;
            }
        }
        Err("Internal error")?
    }

    Ok(())
}

#[test]
fn test_basic_packing() {
    for _ in 0..10 {
        let mut rects = vec![Rect::new(1280, 720); 4];

        pack(&mut rects, 2560, 1440).unwrap();

        assert_eq!(rects[0].packed_top_left_x, 1280);
        assert_eq!(rects[0].packed_top_left_y, 720);

        assert_eq!(rects[1].packed_top_left_x, 0);
        assert_eq!(rects[1].packed_top_left_y, 0);

        assert_eq!(rects[2].packed_top_left_x, 1280);
        assert_eq!(rects[2].packed_top_left_y, 0);

        assert_eq!(rects[3].packed_top_left_x, 0);
        assert_eq!(rects[3].packed_top_left_y, 720);
    }
}