Struct webrender::texture_pack::ShelfAllocator

pub struct ShelfAllocator {
    shelves: Vec<Shelf, Global>,
    items: Vec<Item, Global>,
    alignment: Size2D<i32, UnknownUnit>,
    flip_xy: bool,
    size: Size2D<i32, UnknownUnit>,
    first_shelf: ShelfIndex,
    free_items: ItemIndex,
    free_shelves: ShelfIndex,
    shelf_width: u16,
    allocated_space: i32,
}

A shelf-packing dynamic texture atlas allocator tracking each allocation individually and with support for coalescing empty shelves.

Fields

shelves: Vec<Shelf, Global>

items: Vec<Item, Global>

alignment: Size2D<i32, UnknownUnit>

flip_xy: bool

size: Size2D<i32, UnknownUnit>

first_shelf: ShelfIndex

free_items: ItemIndex

free_shelves: ShelfIndex

shelf_width: u16

allocated_space: i32

Implementations

impl AtlasAllocator

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

Create an atlas allocator with provided options.

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

Create an atlas allocator with default options.

pub fn clear(&mut self)

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

pub fn allocate(&mut self, 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.

pub fn is_empty(&self) -> bool

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 iter(&self) -> Iter<'_>

pub fn get_index(&self, id: AllocId) -> u32

Turn a valid AllocId into an index that can be used as a key for external storage.

The allocator internally stores all items in a single vector. In addition allocations stay at the same index in the vector until they are deallocated. As a result the index of an item can be used as a key for external storage using vectors. Note that:

• The provided ID must correspond to an item that is currently allocated in the atlas.
• After an item is deallocated, its index may be reused by a future allocation, so the returned index should only be considered valid during the lifetime of the its associated item.
• indices are expected to be “reasonable” with respect to the number of allocated items, in other words it is never larger than the maximum number of allocated items in the atlas (making it a good fit for indexing within a sparsely populated vector).

pub fn get(&self, id: AllocId) -> Box2D<i32, UnknownUnit>

Returns the allocation info associated to the allocation ID.

The id must correspond to an existing allocation in the atlas.

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 ShelfAllocator

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 AtlasAllocator

fn clone(&self) -> AtlasAllocator

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<'de> Deserialize<'de> for AtlasAllocator

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

Deserialize this value from the given Serde deserializer.

impl<'l> IntoIterator for &'l AtlasAllocator

type Item = Allocation

The type of the elements being iterated over.

type IntoIter = Iter<'l>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Iter<'l>

Creates an iterator from a value.

impl Serialize for AtlasAllocator

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.