Struct TileSetWfcConstraint 

pub struct TileSetWfcConstraint(/* private fields */);

A hash table based wave function collapse constraint that maps PatternBits objects to sets of TileDefinitionHandle. Each handle refers to a tile, and each tile is assigned a pattern and a frequency. The sum of the frequencies of all a pattern’s tiles becomes the frequency of the pattern, which is then normalized into a probability between 0.0 and 1.0 for use as a constraint for a TileSetWfcPropagator which will perform the wave function collapse.

Implementations

impl TileSetWfcConstraint

pub fn fill_pattern_map( &mut self, tile_set: &TileSet, pattern_property: TileSetPropertyNine, frequency_property: Option<TileSetPropertyF32>, terrain_freq: &FxHashMap<TileTerrainId, f32>, ) -> Result<(), FillPatternMapError>

Clear the data from this constraint and replace it with new data based upon the given tile set and property UUIDs. All of the tiles of the tile set are searched and each one’s pattern property is checked for a center value that matches one of the keys of terrain_freq. When such a tile is found, it is inserted into the map using the pattern property value as the pattern and the frequency property value as the frequency.

• tile_set: The tile set to iterate through.
• pattern_property: The UUID of a nine-slice property in tile_set that will be used for the pattern of each tile. The center value of the nine-slice is the terrain, unless the center value is 0, in which case the tile is ignored.
• frequency_property: The UUID of a float property in tile_set that will be used for the frequency of each tile. If None, then every tile has frequency 1.0.
• terrain_freq: A hash map of the terrains that will be used in wave function collapse. Tiles whose center value are not keys in this hash map will be ignored. Tiles whose center value are keys in this hash map will have their frequency multiplied by the corresponding value in the hash map to calculate the final frequency of the tile. This allows terrains to have their frequency weighted, and allows unwanted terrains to be excluded.

Note: Terrain 0 is treated specially. It has one pattern, the all-zeros default PatternBits, and it corresponds to the empty tile. Tiles whose pattern value have 0 in the center are presumed to be not intended to be part of the wave function collapse, since 0 is the default value. The frequency of choosing empty tiles in wave function collapse can be controlled by setting terrain_freq[0] to some value.

Methods from Deref<Target = HashWfcConstraint<PatternBits, TileDefinitionHandle>>

pub fn is_empty(&self) -> bool

True if this constraint contains no patterns.

pub fn clear(&mut self)

Remove all data, reseting this object to empty so it is ready to be reused with new pattern data.

pub fn add(&mut self, pattern: Pat, frequency: f32, value: V)

where Pat: Debug, V: Debug,

Add a new value to the data with the given pattern and frequency. The frequency does not need to be between 0.0 and 1.0. Frequencies of 0.0 or less will be silently ignored, and frequencies will be automatically normalized into probabilities when finalize is called.

pub fn finalize(&mut self)

Calculate the probability of each pattern based on the frequencies of all values that were added with add. The sum of the frequencies is calculated and then each frequency is divided by the sum to normalize the frequencies into probabilities between 0.0 and 1.0.

pub fn finalize_with_terrain_normalization<Ter, F>(&mut self, terrain: F)

where Ter: Hash + Eq, F: Fn(&Pat) -> Ter,

Calculate the probability of each pattern based on the frequencies of all values that were added with add. Divide the frequency of each pattern by the total number of patterns in that pattern’s terrain so that terrains with many patterns are not given an advantage over terrains with few patterns. The terrain function is used to determine the terrain of each pattern. The sum of the frequencies is calculated and then each frequency is divided by the sum to normalize the frequencies into probabilities between 0.0 and 1.0.

pub fn get_random<R>(&self, rng: &mut R, pattern: &Pat) -> Option<&V>

where R: Rng + ?Sized,

A random value that matches the given pattern, based upon previous calls to add. Often there may be more than one tile that matches a particular pattern, and so this method helps with the final step after wave function collapse: converting the chosen patterns into actual tiles.

Trait Implementations

impl Default for TileSetWfcConstraint

fn default() -> TileSetWfcConstraint

Returns the “default value” for a type.

impl Deref for TileSetWfcConstraint

type Target = HashWfcConstraint<PatternBits, TileDefinitionHandle>

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl DerefMut for TileSetWfcConstraint

fn deref_mut(&mut self) -> &mut Self::Target

Mutably dereferences the value.