Struct micro_games_kit::pcg::NoiseGenerator

pub struct NoiseGenerator<T: NoiseFn<f64, 2>> {
    pub noise: T,
    pub transform: Mat4<f64>,
}

Fields

noise: T

transform: Mat4<f64>

Implementations

impl<T: NoiseFn<f64, 2>> NoiseGenerator<T>

pub fn new(noise: T) -> Self

Examples found in repository

examples/pcg_island.rs (line 35)

    fn default() -> Self {
        let mut height = Grid::<f64>::generate(
            SIZE.into(),
            NoiseGenerator::new(Fbm::<SuperSimplex>::default().set_frequency(0.025)),
        );
        height.apply_all(RemapGenerator {
            from: -1.0..1.0,
            to: 0.0..1.0,
        });
        let mut biome = Grid::<f64>::generate(
            SIZE.into(),
            NoiseGenerator::new(Fbm::<SuperSimplex>::new(42).set_frequency(0.05)),
        );
        biome.apply_all(RemapGenerator {
            from: -1.0..1.0,
            to: 0.0..1.0,
        });
        let buffer = height
            .into_inner()
            .1
            .into_iter()
            .zip(biome.into_inner().1)
            .map(|(height, biome)| {
                if height > 0.9 {
                    SNOW
                } else if height > 0.75 {
                    ROCK
                } else if height > 0.4 {
                    if biome > 0.9 {
                        SAND
                    } else if biome > 0.6 {
                        GRASS
                    } else {
                        FOREST
                    }
                } else {
                    WATER
                }
            })
            .collect();

        Self {
            world: GridWorld::new(
                10.0.into(),
                TileSet::default()
                    .shader(ShaderRef::name("color"))
                    .mapping(WATER, TileSetItem::default().tint(Rgba::blue()))
                    .mapping(
                        FOREST,
                        TileSetItem::default().tint(Rgba::new_opaque(0.0, 0.5, 0.0)),
                    )
                    .mapping(GRASS, TileSetItem::default().tint(Rgba::green()))
                    .mapping(
                        SAND,
                        TileSetItem::default().tint(Rgba::new_opaque(1.0, 1.0, 0.5)),
                    )
                    .mapping(ROCK, TileSetItem::default().tint(Rgba::gray(0.5)))
                    .mapping(SNOW, TileSetItem::default().tint(Rgba::white())),
                TileMap::with_buffer(SIZE.into(), buffer).unwrap(),
            ),
        }
    }

pub fn transform(self, transform: Mat4<f64>) -> Self

Trait Implementations

impl<T: NoiseFn<f64, 2>> GridGenetator<f64> for NoiseGenerator<T>

fn generate( &mut self, location: Vec2<usize>, _: Vec2<usize>, _: f64, _: &Grid<f64> ) -> f64