Package org.lwjgl.stb

Class STBRectPack


  • public class STBRectPack
extends java.lang.Object
    Native bindings to stb_rect_pack.h from the stb library.

    Useful for e.g. packing rectangular textures into an atlas. Does not do rotation.

    This library currently uses the Skyline Bottom-Left algorithm. Not necessarily the awesomest packing method, but better than the totally naive one in stb_truetype (which is primarily what this is meant to replace).

    • Method Detail

      • stbrp_pack_rects

        public static void stbrp_pack_rects(STBRPContext context,
                                    STBRPRect.Buffer rects)
        Assigns packed locations to rectangles. The rectangles are of type STBRPRect, 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.

        Parameters:
        context - an STBRPContext struct
        rects - an array of STBRPRect structs

      • stbrp_init_target

        public static void stbrp_init_target(STBRPContext context,
                                     int width,
                                     int height,
                                     STBRPNode.Buffer nodes)
        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
        2. or, call setup_allow_out_of_mem 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.

        Parameters:
        context - an STBRPContext struct
        width - the rectangle width
        height - the rectangle height
        nodes - an array of STBRPNode structs

      • stbrp_setup_allow_out_of_mem

        public static void stbrp_setup_allow_out_of_mem(STBRPContext context,
                                                boolean allow_out_of_mem)
        Optionally call this function after init but before doing any packing to change the handling of the out-of-temp-memory scenario, described in init_target. If you call init again, this will be reset to the default (false).
        Parameters:
        context - an STBRPContext struct
        allow_out_of_mem - 1 to allow running out of temporary storage

      • stbrp_setup_heuristic

        public static void stbrp_setup_heuristic(STBRPContext context,
                                         int 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.
        Parameters:
        context - an STBRPContext struct
        heuristic - the packing heuristic