Struct webrender::texture_pack::BucketedShelfAllocator

pub struct BucketedShelfAllocator {
    shelves: Vec<Shelf, Global>,
    buckets: Vec<Bucket, Global>,
    available_height: u16,
    width: u16,
    height: u16,
    first_unallocated_bucket: BucketIndex,
    flip_xy: bool,
    alignment: Size2D<i32, UnknownUnit>,
    current_column: u16,
    column_width: u16,
    num_columns: u16,
    allocated_space: i32,
}

A faster but less precise Shelf-packing dynamic texture atlas allocator, inspired by https://github.com/mapbox/shelf-pack/

Items are accumulated into buckets which are laid out in rows (shelves) of variable height. When allocating we first look for a suitable bucket. If none is found, a new shelf of the desired height is pushed.

Lifetime isn’t tracked at item granularity. Instead, items are grouped into buckets and deallocation happens per bucket when all items of the buckets are removed. When the top-most shelf is empty, it is removed, potentially cascading into garbage-collecting the next shelf, etc.

This allocator works well when there are a lot of small items with similar sizes (typically, glyph atlases).

Fields

shelves: Vec<Shelf, Global>

buckets: Vec<Bucket, Global>

available_height: u16

width: u16

height: u16

first_unallocated_bucket: BucketIndex

flip_xy: bool

alignment: Size2D<i32, UnknownUnit>

current_column: u16

column_width: u16

num_columns: u16

allocated_space: i32

Implementations

impl BucketedAtlasAllocator

pub fn with_options( size: Size2D<i32, UnknownUnit>, options: &AllocatorOptions ) -> BucketedAtlasAllocator

Create an atlas allocator with provided options.

pub fn new(size: Size2D<i32, UnknownUnit>) -> BucketedAtlasAllocator

Create an atlas allocator with default options.

pub fn clear(&mut self)

pub fn size(&self) -> Size2D<i32, UnknownUnit>

pub fn grow(&mut self, new_size: Size2D<i32, UnknownUnit>)

pub fn is_empty(&self) -> bool

pub fn allocate( &mut self, requested_size: Size2D<i32, UnknownUnit> ) -> Option<Allocation>

Allocate a rectangle in the atlas.

pub fn deallocate(&mut self, id: AllocId)

Deallocate a rectangle in the atlas.

Space is only reclaimed when all items of the same bucket are deallocated.

pub fn allocated_space(&self) -> i32

Amount of occupied space in the atlas.

pub fn free_space(&self) -> i32

How much space is available for future allocations.

pub fn dump_svg(&self, output: &mut dyn Write) -> Result<(), Error>

Dump a visual representation of the atlas in SVG format.

pub fn dump_into_svg( &self, rect: Option<&Box2D<i32, UnknownUnit>>, output: &mut dyn Write ) -> Result<(), Error>

Dump a visual representation of the atlas in SVG, omitting the beginning and end of the SVG document, so that it can be included in a larger document.

If a rectangle is provided, translate and scale the output to fit it.

Trait Implementations

impl AtlasAllocator for BucketedShelfAllocator

type Parameters = AllocatorOptions

Specific parameters of the allocator.

fn new(size: i32, options: &Self::Parameters) -> Self

Constructor

fn allocate(&mut self, size: DeviceIntSize) -> Option<(AllocId, DeviceIntRect)>

Allocate a rectangle.

fn deallocate(&mut self, id: AllocId)

Deallocate a rectangle and return its size.

fn is_empty(&self) -> bool

Return true if there is no live allocations.

fn allocated_space(&self) -> i32

Allocated area in pixels.

fn dump_into_svg(&self, rect: &Box2D<f32>, output: &mut dyn Write) -> Result<()>

Write a debug visualization of the atlas fitting in the provided rectangle.

impl Clone for BucketedAtlasAllocator

fn clone(&self) -> BucketedAtlasAllocator

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<'de> Deserialize<'de> for BucketedAtlasAllocator

fn deserialize<__D>( __deserializer: __D ) -> Result<BucketedAtlasAllocator, <__D as Deserializer<'de>>::Error>where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Serialize for BucketedAtlasAllocator

fn serialize<__S>( &self, __serializer: __S ) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::Error>where __S: Serializer,

Serialize this value into the given Serde serializer.