package vendor:stb/rect_pack

Index

Constants (0)

This section is empty.

Variables (0)

This section is empty.

Procedure Groups (0)

This section is empty.

Types

Context ¶

Context :: struct {
	width:       i32,
	height:      i32,
	align:       i32,
	init_mode:   i32,
	heuristic:   Heuristic,
	num_nodes:   i32,
	active_head: ^Node,
	free_head:   ^Node,
	extra:       [2]Node,
}

Coord ¶

Coord :: distinct i32

Heuristic ¶

Heuristic :: enum i32 {
	Skyline_default       = 0, 
	Skyline_BL_sortHeight = 0, 
	Skyline_BF_sortHeight, 
}

Node ¶

Node :: struct {
	x,
	y:    Coord,
	next: ^Node,
}

Rect ¶

Rect :: struct {
	// reserved for your use:
	id:         i32,
	// input:
	w,
	h:          Coord,
	// output:
	x,
	y:          Coord,
	was_packed: b32,
}

Constants

This section is empty.

Variables

This section is empty.

Procedures

init_target ¶

init_target :: proc "cdecl" (ctx: ^Context, width, height: i32, nodes: [^]Node, num_nodes: i32) ---
 

Initialize a rectangle packer to: pack a rectangle that is 'width' by 'height' in dimensions using temporary storage provided by the array 'nodes', which is 'num_nodes' long

You must call this function every time you start packing into a new target.

There is no "shutdown" function. The 'nodes' memory must stay valid for the following pack_rects() call (or calls), but can be freed after the call (or calls) finish.

Note: to guarantee best results, either: 1. make sure 'num_nodes' >= 'width' or 2. call setup_allow_out_of_mem() defined below with 'allow_out_of_mem = 1'

If you don't do either of the above things, widths will be quantized to multiples of small integers to guarantee the algorithm doesn't run out of temporary storage.

If you do #2, then the non-quantized algorithm will be used, but the algorithm may run out of temporary storage and be unable to pack some rectangles.

pack_rects ¶

pack_rects :: proc "cdecl" (ctx: ^Context, rects: [^]Rect, num_rects: i32) -> i32 ---
 

Assign packed locations to rectangles. The rectangles are of type 'Rect' defined below, stored in the array 'rects', and there are 'num_rects' many of them.

Rectangles which are successfully packed have the 'was_packed' flag set to a non-zero value and 'x' and 'y' store the minimum location on each axis (i.e. bottom-left in cartesian coordinates, top-left if you imagine y increasing downwards). Rectangles which do not fit have the 'was_packed' flag set to 0.

You should not try to access the 'rects' array from another thread while this function is running, as the function temporarily reorders the array while it executes.

To pack into another rectangle, you need to call init_target again. To continue packing into the same rectangle, you can call this function again. Calling this multiple times with multiple rect arrays will probably produce worse packing results than calling it a single time with the full rectangle array, but the option is available.

The function returns 1 if all of the rectangles were successfully packed and 0 otherwise.

setup_allow_out_of_mem ¶

setup_allow_out_of_mem :: proc "cdecl" (ctx: ^Context, allow_out_of_mem: b32) ---
 

Optionally call this function after init but before doing any packing to change the handling of the out-of-temp-memory scenario, described above. If you call init again, this will be reset to the default (false).

setup_heuristic ¶

setup_heuristic :: proc "cdecl" (ctx: ^Context, heuristic: Heuristic) ---
 

Optionally select which packing heuristic the library should use. Different heuristics will produce better/worse results for different data sets. If you call init again, this will be reset to the default.

Procedure Groups

This section is empty.

Source Files

Generation Information

Generated with odin version dev-2022-12 (vendor "odin") Windows_amd64 @ 2022-12-06 21:08:55.296654300 +0000 UTC