Struct GreedyMesh 

pub struct GreedyMesh<'a, A: AtlasData, Allocator: AtlasAllocator = SimpleAtlasAllocator> {
    atlas: Allocator,
    tex_size: Vec2<u16>,
    max_size: Vec2<u16>,
    suspended: Vec<Box<SuspendedMesh<'a, A>>>,
}

Shared state for a greedy mesh, potentially passed along to multiple models.

For an explanation of why we want this, see SuspendedMesh.

Fields

atlas: Allocator

tex_size: Vec2<u16>

max_size: Vec2<u16>

suspended: Vec<Box<SuspendedMesh<'a, A>>>

Implementations

impl<'a, A: AtlasData, Allocator: AtlasAllocator> GreedyMesh<'a, A, Allocator>

pub fn new(max_size: Vec2<u16>, config: Allocator::Config) -> Self

Construct a new greedy mesher.

Takes as input the maximum allowable size of the texture atlas used to store the light/color data for this mesh.

NOTE: It is an error to pass any size > u16::MAX (this is now enforced by the type being u16).

Even aside from the above limitation, this will not necessarily always be the same as the maximum atlas size supported by the hardware. For instance, since we want to reserve 4 bits for a bone index for figures in their shadow vertex, the atlas parameter for figures has to have at least 2 bits of the normal; thus, it can only take up at most 30 bits total, meaning we are restricted to “only” at most 2^15 × 2^15 atlases even if the hardware supports larger ones.

pub fn push<M: PartialEq, D: 'a, FA, FL, FG, FO, FS, FP, FT>( &mut self, config: GreedyConfig<D, FA, FL, FG, FO, FS, FP, FT>, )

where FA: for<'r> FnMut(&'r mut D, Vec3<i32>) -> f32 + 'a, FL: for<'r> FnMut(&'r mut D, Vec3<i32>) -> f32 + 'a, FG: for<'r> FnMut(&'r mut D, Vec3<i32>) -> f32 + 'a, FO: for<'r> FnMut(&'r mut D, Vec3<i32>) -> bool + 'a, FS: for<'r> FnMut(&'r mut D, Vec3<i32>, Vec3<i32>, Vec2<Vec3<i32>>) -> Option<(bool, M)>, FP: FnMut(Vec2<u16>, Vec2<Vec2<u16>>, Vec3<f32>, Vec2<Vec3<f32>>, Vec3<f32>, &M), FT: for<'r> FnMut(<A::SliceMut<'_> as Iterator>::Item, &'r mut D, Vec3<i32>, u8, u8, bool) + 'a,

Perform greedy meshing on a model, separately producing “pure” model data (the opaque mesh, together with atlas positions connecting each rectangle with texture information), and raw light and color data ready to be used as a texture (accessible with finalize). Texture data built up within the same greedy mesh will be inserted into the same atlas, which can be used to group texture data for things like figures that are the result of meshing multiple models.

Returns an estimate of the bounds of the current meshed model.

For more information on the config parameter, see GreedyConfig.

pub fn finalize(self) -> (A, Vec2<u16>)

Finalize the mesh, producing texture color data for the whole model.

By delaying finalization until the contents of the whole texture atlas are known, we can perform just a single allocation to construct a precisely fitting atlas. This will also let us (in the future) suspend meshing partway through in order to meet frame budget, and potentially use a single staged upload to the GPU.

Returns the ColLightsInfo corresponding to the constructed atlas.

pub fn max_size(&self) -> Vec2<u16>