Struct WfcModule 

pub struct WfcModule<TBitSet>
where
    TBitSet: BitSearch + BitEmpty + BitSet + BitIntersection + BitUnion + BitTestNone + Hash + Eq + Copy + BitIntersection<Output = TBitSet> + BitUnion<Output = TBitSet>,
{
    pub north_neighbours: TBitSet,
    pub south_neighbours: TBitSet,
    pub east_neighbours: TBitSet,
    pub west_neighbours: TBitSet,
}

A building block of WFC, which lets user to set adjacency rules for tiles

Each neighbours bitset are expected to hold indices of neighbour modules which will be hold in a &WfcModule used by WfcContext

Fields

north_neighbours: TBitSet

North neighbouring modules

south_neighbours: TBitSet

South neighbouring modules

east_neighbours: TBitSet

East neighbouring modules

west_neighbours: TBitSet

West neighbouring modules

Implementations

impl<TBitSet> WfcModule<TBitSet>

where TBitSet: BitSearch + BitEmpty + BitSet + BitIntersection + BitUnion + BitTestNone + Hash + Eq + Copy + BitIntersection<Output = TBitSet> + BitUnion<Output = TBitSet>,

pub fn new() -> Self

A constructor of a module with all neighbouring sets empty

Examples found in repository

examples/wang_corner_carpet.rs (line 116)

    pub async fn new(w: usize, h: usize) -> Self {
        let InternalGlContext {
            quad_context: ctx, ..
        } = unsafe { get_internal_gl() };

        let texture_bytes = load_file("assets/wang_4_corner.png").await.unwrap();

        let img = image::load_from_memory(&texture_bytes[..])
            .unwrap_or_else(|e| panic!("{}", e))
            .to_rgba8();

        let img_w = img.width();
        let img_h = img.height();

        let texture = Texture2D::from_miniquad_texture(
            miniquad::Texture::from_data_and_format(
                ctx,
                &img.into_raw(),
                TextureParams {
                    format: TextureFormat::RGBA8,
                    wrap: TextureWrap::Clamp,
                    filter: FilterMode::Nearest,
                    width: img_w,
                    height: img_h
                }
            )
        );

        let tiles = (0..=255)
            .map(|idx| {
                let width = 32;
                let height = 32;
                (
                    idx as u8,
                    SubRect {
                        x: (idx % 16) * width,
                        y: (idx / 16) * height,
                        width,
                        height
                    }
                )
            })
            .collect::<Vec<_>>();

        let modules = tiles
            .iter()
            .map(|tile| {
                let mut module: WfcModule<CustomBitSet> = WfcModule::new();
                for i in 0..tiles.len() {
                    let other_tile = &tiles[i];
                    if get_north_west(tile.0) == get_south_west(other_tile.0) &&
                        get_north_east(tile.0) == get_south_east(other_tile.0) {
                        module.add_north_neighbour(i);
                    }
                    if get_south_west(tile.0) == get_north_west(other_tile.0) &&
                        get_south_east(tile.0) == get_north_east(other_tile.0) {
                        module.add_south_neighbour(i);
                    }
                    if get_north_west(tile.0) == get_north_east(other_tile.0) &&
                        get_south_west(tile.0) == get_south_east(other_tile.0) {
                        module.add_west_neighbour(i);
                    }
                    if get_north_east(tile.0) == get_north_west(other_tile.0) &&
                        get_south_east(tile.0) == get_south_west(other_tile.0) {
                        module.add_east_neighbour(i);
                    }
                }
                module
            })
            .collect::<Vec<_>>();

        Self {
            w,
            h,
            tile_width: 32,
            tile_height: 32,
            tiles,
            modules,
            texture,
            map_data: vec![0; w*h]
        }
    }

examples/dungeon.rs (line 318)

    pub async fn new(w: usize, h: usize) -> Self {
        let InternalGlContext {
            quad_context: ctx, ..
        } = unsafe { get_internal_gl() };

        let dungeon_bytes = load_file("assets/dungeon_tiles.png").await.unwrap();

        let img = image::load_from_memory(&dungeon_bytes[..])
            .unwrap_or_else(|e| panic!("{}", e))
            .to_rgba8();

        let img_w = img.width();
        let img_h = img.height();

        let texture = Texture2D::from_miniquad_texture(
            miniquad::Texture::from_data_and_format(
                ctx,
                &img.into_raw(),
                TextureParams {
                    format: TextureFormat::RGBA8,
                    wrap: TextureWrap::Clamp,
                    filter: FilterMode::Nearest,
                    width: img_w,
                    height: img_h
                }
            )
        );

        let tiles_bytes = load_file("assets/dungeon_tiles.ron").await.unwrap();
        let dungeon_tiles: DungeonTiles = from_reader(&tiles_bytes[..]).unwrap();

        let mut tiles = Vec::new();
        for (kind_code, subrects) in dungeon_tiles.wang_4_corner_tiles.iter() {
            tiles.push(Tile {
                kind: TileKind::Wang4Corner(*kind_code),
                subrects: subrects.clone(),
                neighbours_east: Vec::new(),
                neighbours_west: Vec::new(),
                neighbours_north: Vec::new(),
                neighbours_south: Vec::new()
            });
        }
        // We need to be sure that zero tile is always a "void" tile, so we doing an extra sort step
        tiles.sort_by(|lhs, rhs| {
            match (lhs.kind, rhs.kind) {
                (TileKind::Wang4Corner(kind_lhs), TileKind::Wang4Corner(kind_rhs)) => kind_lhs.cmp(&kind_rhs),
                _ => Ordering::Equal
            }
        });

        for i in 0..tiles.len() {
            let current_kind = tiles[i].kind;
            for j in 0..tiles.len() {
                let candidate_kind = tiles[j].kind;
                let (matches_north, matches_south, matches_east, matches_west) = {
                    match (current_kind, candidate_kind) {
                        (TileKind::Wang4Corner(current), TileKind::Wang4Corner(candidate)) => {
                            (
                                get_north_east(current) == get_south_east(candidate) &&
                                    get_north_west(current) == get_south_west(candidate),

                                get_south_east(current) == get_north_east(candidate) &&
                                    get_south_west(current) == get_north_west(candidate),

                                get_north_east(current) == get_north_west(candidate) &&
                                    get_south_east(current) == get_south_west(candidate),

                                get_north_west(current) == get_north_east(candidate) &&
                                    get_south_west(current) == get_south_east(candidate),
                            )
                        },
                        _ => continue
                    }
                };
                if matches_east {
                    tiles[i].neighbours_east.push(candidate_kind);
                }
                if matches_west {
                    tiles[i].neighbours_west.push(candidate_kind);
                }
                if matches_north {
                    tiles[i].neighbours_north.push(candidate_kind);
                }
                if matches_south {
                    tiles[i].neighbours_south.push(candidate_kind);
                }
            }
        }

        //Add bridges:
        {
            let bridge_tiles_offset = tiles.len();
            tiles.extend_from_slice(&dungeon_tiles.extra_tiles[..]);

            let mut bridge_match_queue_south = VecDeque::new();
            let mut bridge_match_queue_north = VecDeque::new();
            let mut bridge_match_queue_east = VecDeque::new();
            let mut bridge_match_queue_west = VecDeque::new();

            for bridge_tile in &tiles[bridge_tiles_offset..] {
                for south_neighbour in bridge_tile.neighbours_south.iter() {
                    if let TileKind::Wang4Corner(kind) = south_neighbour {
                        for i in 0..bridge_tiles_offset {
                            match tiles[i].kind {
                                TileKind::Wang4Corner(kind_inner) if kind_inner == *kind => {
                                    bridge_match_queue_south.push_back((bridge_tile.kind, i))
                                },
                                _ => ()
                            };
                        }
                    }
                }
                for north_neighbour in bridge_tile.neighbours_north.iter() {
                    if let TileKind::Wang4Corner(kind) = north_neighbour {
                        for i in 0..bridge_tiles_offset {
                            match tiles[i].kind {
                                TileKind::Wang4Corner(kind_inner) if kind_inner == *kind => {
                                    bridge_match_queue_north.push_back((bridge_tile.kind, i))
                                },
                                _ => ()
                            };
                        }
                    }
                }
                for east_neighbour in bridge_tile.neighbours_east.iter() {
                    if let TileKind::Wang4Corner(kind) = east_neighbour {
                        for i in 0..bridge_tiles_offset {
                            match tiles[i].kind {
                                TileKind::Wang4Corner(kind_inner) if kind_inner == *kind => {
                                    bridge_match_queue_east.push_back((bridge_tile.kind, i))
                                },
                                _ => ()
                            };
                        }
                    }
                }
                for west_neighbour in bridge_tile.neighbours_west.iter() {
                    if let TileKind::Wang4Corner(kind) = west_neighbour {
                        for i in 0..bridge_tiles_offset {
                            match tiles[i].kind {
                                TileKind::Wang4Corner(kind_inner) if kind_inner == *kind => {
                                    bridge_match_queue_west.push_back((bridge_tile.kind, i))
                                },
                                _ => ()
                            };
                        }
                    }
                }
            }

            while !bridge_match_queue_south.is_empty() {
                let next_match = bridge_match_queue_south.pop_front().unwrap();
                tiles[next_match.1].neighbours_north.push(next_match.0);
            }

            while !bridge_match_queue_north.is_empty() {
                let next_match = bridge_match_queue_north.pop_front().unwrap();
                tiles[next_match.1].neighbours_south.push(next_match.0);
            }

            while !bridge_match_queue_east.is_empty() {
                let next_match = bridge_match_queue_east.pop_front().unwrap();
                tiles[next_match.1].neighbours_west.push(next_match.0);
            }

            while !bridge_match_queue_west.is_empty() {
                let next_match = bridge_match_queue_west.pop_front().unwrap();
                tiles[next_match.1].neighbours_east.push(next_match.0);
            }
        }

        let modules = tiles
            .iter()
            .map(|tile| {
                let mut module: WfcModule<CustomBitSet> = WfcModule::new();
                for i in 0..tiles.len() {
                    if tile.neighbours_north.contains(&tiles[i].kind) {
                        module.add_north_neighbour(i);
                    }
                    if tile.neighbours_south.contains(&tiles[i].kind) {
                        module.add_south_neighbour(i);
                    }
                    if tile.neighbours_west.contains(&tiles[i].kind) {
                        module.add_west_neighbour(i);
                    }
                    if tile.neighbours_east.contains(&tiles[i].kind) {
                        module.add_east_neighbour(i);
                    }
                }
                module
            })
            .collect::<Vec<_>>();
        
        Self {
            w,
            h,
            tile_width: dungeon_tiles.tile_width,
            tile_height: dungeon_tiles.tile_height,
            tiles,
            modules,
            texture,
            map_data: vec![(0, 0); w*h]
        }
    }

examples/summer_garden.rs (line 330)

    pub async fn new(w: usize, h: usize, draw_scale: f32) -> Self {
        let InternalGlContext {
            quad_context: ctx, ..
        } = unsafe { get_internal_gl() };

        let texture_bytes = load_file("assets/reduced_wang_scheme.png").await.unwrap();

        let img = image::load_from_memory(&texture_bytes[..])
            .unwrap_or_else(|e| panic!("{}", e))
            .to_rgba8();

        let img_w = img.width();
        let img_h = img.height();

        let texture = Texture2D::from_miniquad_texture(
            miniquad::Texture::from_data_and_format(
                ctx,
                &img.into_raw(),
                TextureParams {
                    format: TextureFormat::RGBA8,
                    wrap: TextureWrap::Clamp,
                    filter: FilterMode::Nearest,
                    width: img_w,
                    height: img_h
                }
            )
        );

        let atlas_bytes = load_file("assets/reduced_wang_scheme.ron").await.unwrap();
        let atlas: SummerGardenAtlas = from_reader(&atlas_bytes[..]).unwrap();

        let mut tile_sides = Vec::new();
        let mut neighbour_strategies = Vec::new();
        let mut tiles = Vec::new();

        {
            for tile_cfg in atlas.terrain_tile_configs.iter() {
                for pattern in &[
                    &atlas.reduced_wang_patterns[..],
                    &atlas.extended_set_1_patterns_north_west[..],
                    &atlas.extended_set_1_patterns_north_east[..],
                    &atlas.extended_set_1_patterns_south_west[..],
                    &atlas.extended_set_1_patterns_south_east[..],
                    &atlas.extended_set_2_patterns_north_west[..],
                    &atlas.extended_set_2_patterns_north_east[..],
                    &atlas.extended_set_2_patterns_south_west[..],
                    &atlas.extended_set_2_patterns_south_east[..],
                ] {
                    tile_sides.extend(
                        pattern.iter().map(
                            |pattern| {
                                TileSides {
                                    north_west: match pattern.north_west {
                                        TileKind::Inner => { tile_cfg.inner_type }
                                        TileKind::Outer => { tile_cfg.outer_type }
                                    },
                                    north_east: match pattern.north_east {
                                        TileKind::Inner => { tile_cfg.inner_type }
                                        TileKind::Outer => { tile_cfg.outer_type }
                                    },
                                    south_west: match pattern.south_west {
                                        TileKind::Inner => { tile_cfg.inner_type }
                                        TileKind::Outer => { tile_cfg.outer_type }
                                    },
                                    south_east: match pattern.south_east {
                                        TileKind::Inner => { tile_cfg.inner_type }
                                        TileKind::Outer => { tile_cfg.outer_type }
                                    }
                                }
                            }
                        )
                    );
                }
                for j in 0..4 {
                    for i in 0..4 {
                        tiles.push(SubRect{
                            x: i * 32 + tile_cfg.x_offset,
                            y: j * 32 + tile_cfg.y_offset,
                            width: 32,
                            height: 32
                        })
                    }
                }
                for jj in 0..2 {
                    for ii in 0..2 {
                        for j in 0..2 {
                            for i in 0..2 {
                                tiles.push(SubRect{
                                    x: (i + ii * 2) * 32 + tile_cfg.x_offset + 256,
                                    y: (j + jj * 2) * 32 + tile_cfg.y_offset,
                                    width: 32,
                                    height: 32
                                })
                            }
                        }
                    }
                }
                for jj in 0..2 {
                    for ii in 0..2 {
                        for j in 0..2 {
                            for i in 0..2 {
                                tiles.push(SubRect{
                                    x: (i + ii * 2) * 32 + tile_cfg.x_offset,
                                    y: (j + jj * 2) * 32 + tile_cfg.y_offset + 256,
                                    width: 32,
                                    height: 32
                                })
                            }
                        }
                    }
                }
                neighbour_strategies.extend_from_slice(&atlas.reduced_wang_neighbour_strategy[..]);
                for _ in 0..8 {
                    neighbour_strategies.extend_from_slice(&atlas.neighbour_strategy_2_x_2[..]);
                }
            }
            tile_sides.extend_from_slice(&atlas.vertical_bridge_sides[..]);
            tile_sides.extend_from_slice(&atlas.horizontal_bridge_sides[..]);
            for j in 0..3 {
                for i in 0..3 {
                    tiles.push(SubRect{
                        x: i * 32 + 256,
                        y: j * 32 + 256,
                        width: 32,
                        height: 32
                    })
                }
            }
            for j in 0..3 {
                for i in 0..3 {
                    tiles.push(SubRect{
                        x: i * 32 + 256 + 96,
                        y: j * 32 + 256,
                        width: 32,
                        height: 32
                    })
                }
            }
            neighbour_strategies.extend_from_slice(&atlas.neighbour_strategy_3_x_3[..]);
            neighbour_strategies.extend_from_slice(&atlas.neighbour_strategy_3_x_3[..]);

            assert_eq!(tile_sides.len(), neighbour_strategies.len());
        }

        let mut modules = Vec::new();
        for i in 0..tile_sides.len() {
            let current_sides = tile_sides[i];
            let mut module: WfcModule<CustomBitSet> = WfcModule::new();
            match neighbour_strategies[i].north {
                NeighbourKind::WangCorners => {
                    for j in 0..tile_sides.len() {
                        if neighbour_strategies[j].south != NeighbourKind::WangCorners {
                            continue;
                        }
                        if tile_sides[j].south_west == current_sides.north_west &&
                            tile_sides[j].south_east == current_sides.north_east {
                            module.add_north_neighbour(j);
                        }
                    }
                }
                NeighbourKind::RelOffset(offset) => {
                    let new_offset = (i as i32 + offset) as usize;
                    module.add_north_neighbour(new_offset);
                }
            }
            match neighbour_strategies[i].south {
                NeighbourKind::WangCorners => {
                    for j in 0..tile_sides.len() {
                        if neighbour_strategies[j].north != NeighbourKind::WangCorners {
                            continue;
                        }
                        if tile_sides[j].north_west == current_sides.south_west &&
                            tile_sides[j].north_east == current_sides.south_east {
                            module.add_south_neighbour(j);
                        }
                    }
                }
                NeighbourKind::RelOffset(offset) => {
                    let new_offset = (i as i32 + offset) as usize;
                    module.add_south_neighbour(new_offset);
                }
            }
            match neighbour_strategies[i].east {
                NeighbourKind::WangCorners => {
                    for j in 0..tile_sides.len() {
                        if neighbour_strategies[j].west != NeighbourKind::WangCorners {
                            continue;
                        }
                        if tile_sides[j].north_west == current_sides.north_east &&
                            tile_sides[j].south_west == current_sides.south_east {
                            module.add_east_neighbour(j);
                        }
                    }
                }
                NeighbourKind::RelOffset(offset) => {
                    let new_offset = (i as i32 + offset) as usize;
                    module.add_east_neighbour(new_offset);
                }
            }
            match neighbour_strategies[i].west {
                NeighbourKind::WangCorners => {
                    for j in 0..tile_sides.len() {
                        if neighbour_strategies[j].east != NeighbourKind::WangCorners {
                            continue;
                        }
                        if tile_sides[j].north_east == current_sides.north_west &&
                            tile_sides[j].south_east == current_sides.south_west {
                            module.add_west_neighbour(j);
                        }
                    }
                }
                NeighbourKind::RelOffset(offset) => {
                    let new_offset = (i as i32 + offset) as usize;
                    module.add_west_neighbour(new_offset);
                }
            }
            modules.push(module);
        }

        Self {
            w,
            h,
            draw_scale,
            atlas,
            tile_width: 32,
            tile_height: 32,
            tiles,
            modules,
            texture,
            map_data: vec![0; w*h],
            cell_tree_data: vec![TreeType::None; w*h],
            corner_tree_data: vec![TreeType::None; (w+1)*(h+1)]
        }
    }

pub fn add_north_neighbour(&mut self, idx: usize)

A function which adds a neighbour on a north side

Examples found in repository

examples/wang_corner_carpet.rs (line 121)

    pub async fn new(w: usize, h: usize) -> Self {
        let InternalGlContext {
            quad_context: ctx, ..
        } = unsafe { get_internal_gl() };

        let texture_bytes = load_file("assets/wang_4_corner.png").await.unwrap();

        let img = image::load_from_memory(&texture_bytes[..])
            .unwrap_or_else(|e| panic!("{}", e))
            .to_rgba8();

        let img_w = img.width();
        let img_h = img.height();

        let texture = Texture2D::from_miniquad_texture(
            miniquad::Texture::from_data_and_format(
                ctx,
                &img.into_raw(),
                TextureParams {
                    format: TextureFormat::RGBA8,
                    wrap: TextureWrap::Clamp,
                    filter: FilterMode::Nearest,
                    width: img_w,
                    height: img_h
                }
            )
        );

        let tiles = (0..=255)
            .map(|idx| {
                let width = 32;
                let height = 32;
                (
                    idx as u8,
                    SubRect {
                        x: (idx % 16) * width,
                        y: (idx / 16) * height,
                        width,
                        height
                    }
                )
            })
            .collect::<Vec<_>>();

        let modules = tiles
            .iter()
            .map(|tile| {
                let mut module: WfcModule<CustomBitSet> = WfcModule::new();
                for i in 0..tiles.len() {
                    let other_tile = &tiles[i];
                    if get_north_west(tile.0) == get_south_west(other_tile.0) &&
                        get_north_east(tile.0) == get_south_east(other_tile.0) {
                        module.add_north_neighbour(i);
                    }
                    if get_south_west(tile.0) == get_north_west(other_tile.0) &&
                        get_south_east(tile.0) == get_north_east(other_tile.0) {
                        module.add_south_neighbour(i);
                    }
                    if get_north_west(tile.0) == get_north_east(other_tile.0) &&
                        get_south_west(tile.0) == get_south_east(other_tile.0) {
                        module.add_west_neighbour(i);
                    }
                    if get_north_east(tile.0) == get_north_west(other_tile.0) &&
                        get_south_east(tile.0) == get_south_west(other_tile.0) {
                        module.add_east_neighbour(i);
                    }
                }
                module
            })
            .collect::<Vec<_>>();

        Self {
            w,
            h,
            tile_width: 32,
            tile_height: 32,
            tiles,
            modules,
            texture,
            map_data: vec![0; w*h]
        }
    }

examples/dungeon.rs (line 321)

    pub async fn new(w: usize, h: usize) -> Self {
        let InternalGlContext {
            quad_context: ctx, ..
        } = unsafe { get_internal_gl() };

        let dungeon_bytes = load_file("assets/dungeon_tiles.png").await.unwrap();

        let img = image::load_from_memory(&dungeon_bytes[..])
            .unwrap_or_else(|e| panic!("{}", e))
            .to_rgba8();

        let img_w = img.width();
        let img_h = img.height();

        let texture = Texture2D::from_miniquad_texture(
            miniquad::Texture::from_data_and_format(
                ctx,
                &img.into_raw(),
                TextureParams {
                    format: TextureFormat::RGBA8,
                    wrap: TextureWrap::Clamp,
                    filter: FilterMode::Nearest,
                    width: img_w,
                    height: img_h
                }
            )
        );

        let tiles_bytes = load_file("assets/dungeon_tiles.ron").await.unwrap();
        let dungeon_tiles: DungeonTiles = from_reader(&tiles_bytes[..]).unwrap();

        let mut tiles = Vec::new();
        for (kind_code, subrects) in dungeon_tiles.wang_4_corner_tiles.iter() {
            tiles.push(Tile {
                kind: TileKind::Wang4Corner(*kind_code),
                subrects: subrects.clone(),
                neighbours_east: Vec::new(),
                neighbours_west: Vec::new(),
                neighbours_north: Vec::new(),
                neighbours_south: Vec::new()
            });
        }
        // We need to be sure that zero tile is always a "void" tile, so we doing an extra sort step
        tiles.sort_by(|lhs, rhs| {
            match (lhs.kind, rhs.kind) {
                (TileKind::Wang4Corner(kind_lhs), TileKind::Wang4Corner(kind_rhs)) => kind_lhs.cmp(&kind_rhs),
                _ => Ordering::Equal
            }
        });

        for i in 0..tiles.len() {
            let current_kind = tiles[i].kind;
            for j in 0..tiles.len() {
                let candidate_kind = tiles[j].kind;
                let (matches_north, matches_south, matches_east, matches_west) = {
                    match (current_kind, candidate_kind) {
                        (TileKind::Wang4Corner(current), TileKind::Wang4Corner(candidate)) => {
                            (
                                get_north_east(current) == get_south_east(candidate) &&
                                    get_north_west(current) == get_south_west(candidate),

                                get_south_east(current) == get_north_east(candidate) &&
                                    get_south_west(current) == get_north_west(candidate),

                                get_north_east(current) == get_north_west(candidate) &&
                                    get_south_east(current) == get_south_west(candidate),

                                get_north_west(current) == get_north_east(candidate) &&
                                    get_south_west(current) == get_south_east(candidate),
                            )
                        },
                        _ => continue
                    }
                };
                if matches_east {
                    tiles[i].neighbours_east.push(candidate_kind);
                }
                if matches_west {
                    tiles[i].neighbours_west.push(candidate_kind);
                }
                if matches_north {
                    tiles[i].neighbours_north.push(candidate_kind);
                }
                if matches_south {
                    tiles[i].neighbours_south.push(candidate_kind);
                }
            }
        }

        //Add bridges:
        {
            let bridge_tiles_offset = tiles.len();
            tiles.extend_from_slice(&dungeon_tiles.extra_tiles[..]);

            let mut bridge_match_queue_south = VecDeque::new();
            let mut bridge_match_queue_north = VecDeque::new();
            let mut bridge_match_queue_east = VecDeque::new();
            let mut bridge_match_queue_west = VecDeque::new();

            for bridge_tile in &tiles[bridge_tiles_offset..] {
                for south_neighbour in bridge_tile.neighbours_south.iter() {
                    if let TileKind::Wang4Corner(kind) = south_neighbour {
                        for i in 0..bridge_tiles_offset {
                            match tiles[i].kind {
                                TileKind::Wang4Corner(kind_inner) if kind_inner == *kind => {
                                    bridge_match_queue_south.push_back((bridge_tile.kind, i))
                                },
                                _ => ()
                            };
                        }
                    }
                }
                for north_neighbour in bridge_tile.neighbours_north.iter() {
                    if let TileKind::Wang4Corner(kind) = north_neighbour {
                        for i in 0..bridge_tiles_offset {
                            match tiles[i].kind {
                                TileKind::Wang4Corner(kind_inner) if kind_inner == *kind => {
                                    bridge_match_queue_north.push_back((bridge_tile.kind, i))
                                },
                                _ => ()
                            };
                        }
                    }
                }
                for east_neighbour in bridge_tile.neighbours_east.iter() {
                    if let TileKind::Wang4Corner(kind) = east_neighbour {
                        for i in 0..bridge_tiles_offset {
                            match tiles[i].kind {
                                TileKind::Wang4Corner(kind_inner) if kind_inner == *kind => {
                                    bridge_match_queue_east.push_back((bridge_tile.kind, i))
                                },
                                _ => ()
                            };
                        }
                    }
                }
                for west_neighbour in bridge_tile.neighbours_west.iter() {
                    if let TileKind::Wang4Corner(kind) = west_neighbour {
                        for i in 0..bridge_tiles_offset {
                            match tiles[i].kind {
                                TileKind::Wang4Corner(kind_inner) if kind_inner == *kind => {
                                    bridge_match_queue_west.push_back((bridge_tile.kind, i))
                                },
                                _ => ()
                            };
                        }
                    }
                }
            }

            while !bridge_match_queue_south.is_empty() {
                let next_match = bridge_match_queue_south.pop_front().unwrap();
                tiles[next_match.1].neighbours_north.push(next_match.0);
            }

            while !bridge_match_queue_north.is_empty() {
                let next_match = bridge_match_queue_north.pop_front().unwrap();
                tiles[next_match.1].neighbours_south.push(next_match.0);
            }

            while !bridge_match_queue_east.is_empty() {
                let next_match = bridge_match_queue_east.pop_front().unwrap();
                tiles[next_match.1].neighbours_west.push(next_match.0);
            }

            while !bridge_match_queue_west.is_empty() {
                let next_match = bridge_match_queue_west.pop_front().unwrap();
                tiles[next_match.1].neighbours_east.push(next_match.0);
            }
        }

        let modules = tiles
            .iter()
            .map(|tile| {
                let mut module: WfcModule<CustomBitSet> = WfcModule::new();
                for i in 0..tiles.len() {
                    if tile.neighbours_north.contains(&tiles[i].kind) {
                        module.add_north_neighbour(i);
                    }
                    if tile.neighbours_south.contains(&tiles[i].kind) {
                        module.add_south_neighbour(i);
                    }
                    if tile.neighbours_west.contains(&tiles[i].kind) {
                        module.add_west_neighbour(i);
                    }
                    if tile.neighbours_east.contains(&tiles[i].kind) {
                        module.add_east_neighbour(i);
                    }
                }
                module
            })
            .collect::<Vec<_>>();
        
        Self {
            w,
            h,
            tile_width: dungeon_tiles.tile_width,
            tile_height: dungeon_tiles.tile_height,
            tiles,
            modules,
            texture,
            map_data: vec![(0, 0); w*h]
        }
    }

examples/summer_garden.rs (line 339)

    pub async fn new(w: usize, h: usize, draw_scale: f32) -> Self {
        let InternalGlContext {
            quad_context: ctx, ..
        } = unsafe { get_internal_gl() };

        let texture_bytes = load_file("assets/reduced_wang_scheme.png").await.unwrap();

        let img = image::load_from_memory(&texture_bytes[..])
            .unwrap_or_else(|e| panic!("{}", e))
            .to_rgba8();

        let img_w = img.width();
        let img_h = img.height();

        let texture = Texture2D::from_miniquad_texture(
            miniquad::Texture::from_data_and_format(
                ctx,
                &img.into_raw(),
                TextureParams {
                    format: TextureFormat::RGBA8,
                    wrap: TextureWrap::Clamp,
                    filter: FilterMode::Nearest,
                    width: img_w,
                    height: img_h
                }
            )
        );

        let atlas_bytes = load_file("assets/reduced_wang_scheme.ron").await.unwrap();
        let atlas: SummerGardenAtlas = from_reader(&atlas_bytes[..]).unwrap();

        let mut tile_sides = Vec::new();
        let mut neighbour_strategies = Vec::new();
        let mut tiles = Vec::new();

        {
            for tile_cfg in atlas.terrain_tile_configs.iter() {
                for pattern in &[
                    &atlas.reduced_wang_patterns[..],
                    &atlas.extended_set_1_patterns_north_west[..],
                    &atlas.extended_set_1_patterns_north_east[..],
                    &atlas.extended_set_1_patterns_south_west[..],
                    &atlas.extended_set_1_patterns_south_east[..],
                    &atlas.extended_set_2_patterns_north_west[..],
                    &atlas.extended_set_2_patterns_north_east[..],
                    &atlas.extended_set_2_patterns_south_west[..],
                    &atlas.extended_set_2_patterns_south_east[..],
                ] {
                    tile_sides.extend(
                        pattern.iter().map(
                            |pattern| {
                                TileSides {
                                    north_west: match pattern.north_west {
                                        TileKind::Inner => { tile_cfg.inner_type }
                                        TileKind::Outer => { tile_cfg.outer_type }
                                    },
                                    north_east: match pattern.north_east {
                                        TileKind::Inner => { tile_cfg.inner_type }
                                        TileKind::Outer => { tile_cfg.outer_type }
                                    },
                                    south_west: match pattern.south_west {
                                        TileKind::Inner => { tile_cfg.inner_type }
                                        TileKind::Outer => { tile_cfg.outer_type }
                                    },
                                    south_east: match pattern.south_east {
                                        TileKind::Inner => { tile_cfg.inner_type }
                                        TileKind::Outer => { tile_cfg.outer_type }
                                    }
                                }
                            }
                        )
                    );
                }
                for j in 0..4 {
                    for i in 0..4 {
                        tiles.push(SubRect{
                            x: i * 32 + tile_cfg.x_offset,
                            y: j * 32 + tile_cfg.y_offset,
                            width: 32,
                            height: 32
                        })
                    }
                }
                for jj in 0..2 {
                    for ii in 0..2 {
                        for j in 0..2 {
                            for i in 0..2 {
                                tiles.push(SubRect{
                                    x: (i + ii * 2) * 32 + tile_cfg.x_offset + 256,
                                    y: (j + jj * 2) * 32 + tile_cfg.y_offset,
                                    width: 32,
                                    height: 32
                                })
                            }
                        }
                    }
                }
                for jj in 0..2 {
                    for ii in 0..2 {
                        for j in 0..2 {
                            for i in 0..2 {
                                tiles.push(SubRect{
                                    x: (i + ii * 2) * 32 + tile_cfg.x_offset,
                                    y: (j + jj * 2) * 32 + tile_cfg.y_offset + 256,
                                    width: 32,
                                    height: 32
                                })
                            }
                        }
                    }
                }
                neighbour_strategies.extend_from_slice(&atlas.reduced_wang_neighbour_strategy[..]);
                for _ in 0..8 {
                    neighbour_strategies.extend_from_slice(&atlas.neighbour_strategy_2_x_2[..]);
                }
            }
            tile_sides.extend_from_slice(&atlas.vertical_bridge_sides[..]);
            tile_sides.extend_from_slice(&atlas.horizontal_bridge_sides[..]);
            for j in 0..3 {
                for i in 0..3 {
                    tiles.push(SubRect{
                        x: i * 32 + 256,
                        y: j * 32 + 256,
                        width: 32,
                        height: 32
                    })
                }
            }
            for j in 0..3 {
                for i in 0..3 {
                    tiles.push(SubRect{
                        x: i * 32 + 256 + 96,
                        y: j * 32 + 256,
                        width: 32,
                        height: 32
                    })
                }
            }
            neighbour_strategies.extend_from_slice(&atlas.neighbour_strategy_3_x_3[..]);
            neighbour_strategies.extend_from_slice(&atlas.neighbour_strategy_3_x_3[..]);

            assert_eq!(tile_sides.len(), neighbour_strategies.len());
        }

        let mut modules = Vec::new();
        for i in 0..tile_sides.len() {
            let current_sides = tile_sides[i];
            let mut module: WfcModule<CustomBitSet> = WfcModule::new();
            match neighbour_strategies[i].north {
                NeighbourKind::WangCorners => {
                    for j in 0..tile_sides.len() {
                        if neighbour_strategies[j].south != NeighbourKind::WangCorners {
                            continue;
                        }
                        if tile_sides[j].south_west == current_sides.north_west &&
                            tile_sides[j].south_east == current_sides.north_east {
                            module.add_north_neighbour(j);
                        }
                    }
                }
                NeighbourKind::RelOffset(offset) => {
                    let new_offset = (i as i32 + offset) as usize;
                    module.add_north_neighbour(new_offset);
                }
            }
            match neighbour_strategies[i].south {
                NeighbourKind::WangCorners => {
                    for j in 0..tile_sides.len() {
                        if neighbour_strategies[j].north != NeighbourKind::WangCorners {
                            continue;
                        }
                        if tile_sides[j].north_west == current_sides.south_west &&
                            tile_sides[j].north_east == current_sides.south_east {
                            module.add_south_neighbour(j);
                        }
                    }
                }
                NeighbourKind::RelOffset(offset) => {
                    let new_offset = (i as i32 + offset) as usize;
                    module.add_south_neighbour(new_offset);
                }
            }
            match neighbour_strategies[i].east {
                NeighbourKind::WangCorners => {
                    for j in 0..tile_sides.len() {
                        if neighbour_strategies[j].west != NeighbourKind::WangCorners {
                            continue;
                        }
                        if tile_sides[j].north_west == current_sides.north_east &&
                            tile_sides[j].south_west == current_sides.south_east {
                            module.add_east_neighbour(j);
                        }
                    }
                }
                NeighbourKind::RelOffset(offset) => {
                    let new_offset = (i as i32 + offset) as usize;
                    module.add_east_neighbour(new_offset);
                }
            }
            match neighbour_strategies[i].west {
                NeighbourKind::WangCorners => {
                    for j in 0..tile_sides.len() {
                        if neighbour_strategies[j].east != NeighbourKind::WangCorners {
                            continue;
                        }
                        if tile_sides[j].north_east == current_sides.north_west &&
                            tile_sides[j].south_east == current_sides.south_west {
                            module.add_west_neighbour(j);
                        }
                    }
                }
                NeighbourKind::RelOffset(offset) => {
                    let new_offset = (i as i32 + offset) as usize;
                    module.add_west_neighbour(new_offset);
                }
            }
            modules.push(module);
        }

        Self {
            w,
            h,
            draw_scale,
            atlas,
            tile_width: 32,
            tile_height: 32,
            tiles,
            modules,
            texture,
            map_data: vec![0; w*h],
            cell_tree_data: vec![TreeType::None; w*h],
            corner_tree_data: vec![TreeType::None; (w+1)*(h+1)]
        }
    }

pub fn add_south_neighbour(&mut self, idx: usize)

A function which adds a neighbour on a south side

Examples found in repository

examples/wang_corner_carpet.rs (line 125)

    pub async fn new(w: usize, h: usize) -> Self {
        let InternalGlContext {
            quad_context: ctx, ..
        } = unsafe { get_internal_gl() };

        let texture_bytes = load_file("assets/wang_4_corner.png").await.unwrap();

        let img = image::load_from_memory(&texture_bytes[..])
            .unwrap_or_else(|e| panic!("{}", e))
            .to_rgba8();

        let img_w = img.width();
        let img_h = img.height();

        let texture = Texture2D::from_miniquad_texture(
            miniquad::Texture::from_data_and_format(
                ctx,
                &img.into_raw(),
                TextureParams {
                    format: TextureFormat::RGBA8,
                    wrap: TextureWrap::Clamp,
                    filter: FilterMode::Nearest,
                    width: img_w,
                    height: img_h
                }
            )
        );

        let tiles = (0..=255)
            .map(|idx| {
                let width = 32;
                let height = 32;
                (
                    idx as u8,
                    SubRect {
                        x: (idx % 16) * width,
                        y: (idx / 16) * height,
                        width,
                        height
                    }
                )
            })
            .collect::<Vec<_>>();

        let modules = tiles
            .iter()
            .map(|tile| {
                let mut module: WfcModule<CustomBitSet> = WfcModule::new();
                for i in 0..tiles.len() {
                    let other_tile = &tiles[i];
                    if get_north_west(tile.0) == get_south_west(other_tile.0) &&
                        get_north_east(tile.0) == get_south_east(other_tile.0) {
                        module.add_north_neighbour(i);
                    }
                    if get_south_west(tile.0) == get_north_west(other_tile.0) &&
                        get_south_east(tile.0) == get_north_east(other_tile.0) {
                        module.add_south_neighbour(i);
                    }
                    if get_north_west(tile.0) == get_north_east(other_tile.0) &&
                        get_south_west(tile.0) == get_south_east(other_tile.0) {
                        module.add_west_neighbour(i);
                    }
                    if get_north_east(tile.0) == get_north_west(other_tile.0) &&
                        get_south_east(tile.0) == get_south_west(other_tile.0) {
                        module.add_east_neighbour(i);
                    }
                }
                module
            })
            .collect::<Vec<_>>();

        Self {
            w,
            h,
            tile_width: 32,
            tile_height: 32,
            tiles,
            modules,
            texture,
            map_data: vec![0; w*h]
        }
    }

examples/dungeon.rs (line 324)

    pub async fn new(w: usize, h: usize) -> Self {
        let InternalGlContext {
            quad_context: ctx, ..
        } = unsafe { get_internal_gl() };

        let dungeon_bytes = load_file("assets/dungeon_tiles.png").await.unwrap();

        let img = image::load_from_memory(&dungeon_bytes[..])
            .unwrap_or_else(|e| panic!("{}", e))
            .to_rgba8();

        let img_w = img.width();
        let img_h = img.height();

        let texture = Texture2D::from_miniquad_texture(
            miniquad::Texture::from_data_and_format(
                ctx,
                &img.into_raw(),
                TextureParams {
                    format: TextureFormat::RGBA8,
                    wrap: TextureWrap::Clamp,
                    filter: FilterMode::Nearest,
                    width: img_w,
                    height: img_h
                }
            )
        );

        let tiles_bytes = load_file("assets/dungeon_tiles.ron").await.unwrap();
        let dungeon_tiles: DungeonTiles = from_reader(&tiles_bytes[..]).unwrap();

        let mut tiles = Vec::new();
        for (kind_code, subrects) in dungeon_tiles.wang_4_corner_tiles.iter() {
            tiles.push(Tile {
                kind: TileKind::Wang4Corner(*kind_code),
                subrects: subrects.clone(),
                neighbours_east: Vec::new(),
                neighbours_west: Vec::new(),
                neighbours_north: Vec::new(),
                neighbours_south: Vec::new()
            });
        }
        // We need to be sure that zero tile is always a "void" tile, so we doing an extra sort step
        tiles.sort_by(|lhs, rhs| {
            match (lhs.kind, rhs.kind) {
                (TileKind::Wang4Corner(kind_lhs), TileKind::Wang4Corner(kind_rhs)) => kind_lhs.cmp(&kind_rhs),
                _ => Ordering::Equal
            }
        });

        for i in 0..tiles.len() {
            let current_kind = tiles[i].kind;
            for j in 0..tiles.len() {
                let candidate_kind = tiles[j].kind;
                let (matches_north, matches_south, matches_east, matches_west) = {
                    match (current_kind, candidate_kind) {
                        (TileKind::Wang4Corner(current), TileKind::Wang4Corner(candidate)) => {
                            (
                                get_north_east(current) == get_south_east(candidate) &&
                                    get_north_west(current) == get_south_west(candidate),

                                get_south_east(current) == get_north_east(candidate) &&
                                    get_south_west(current) == get_north_west(candidate),

                                get_north_east(current) == get_north_west(candidate) &&
                                    get_south_east(current) == get_south_west(candidate),

                                get_north_west(current) == get_north_east(candidate) &&
                                    get_south_west(current) == get_south_east(candidate),
                            )
                        },
                        _ => continue
                    }
                };
                if matches_east {
                    tiles[i].neighbours_east.push(candidate_kind);
                }
                if matches_west {
                    tiles[i].neighbours_west.push(candidate_kind);
                }
                if matches_north {
                    tiles[i].neighbours_north.push(candidate_kind);
                }
                if matches_south {
                    tiles[i].neighbours_south.push(candidate_kind);
                }
            }
        }

        //Add bridges:
        {
            let bridge_tiles_offset = tiles.len();
            tiles.extend_from_slice(&dungeon_tiles.extra_tiles[..]);

            let mut bridge_match_queue_south = VecDeque::new();
            let mut bridge_match_queue_north = VecDeque::new();
            let mut bridge_match_queue_east = VecDeque::new();
            let mut bridge_match_queue_west = VecDeque::new();

            for bridge_tile in &tiles[bridge_tiles_offset..] {
                for south_neighbour in bridge_tile.neighbours_south.iter() {
                    if let TileKind::Wang4Corner(kind) = south_neighbour {
                        for i in 0..bridge_tiles_offset {
                            match tiles[i].kind {
                                TileKind::Wang4Corner(kind_inner) if kind_inner == *kind => {
                                    bridge_match_queue_south.push_back((bridge_tile.kind, i))
                                },
                                _ => ()
                            };
                        }
                    }
                }
                for north_neighbour in bridge_tile.neighbours_north.iter() {
                    if let TileKind::Wang4Corner(kind) = north_neighbour {
                        for i in 0..bridge_tiles_offset {
                            match tiles[i].kind {
                                TileKind::Wang4Corner(kind_inner) if kind_inner == *kind => {
                                    bridge_match_queue_north.push_back((bridge_tile.kind, i))
                                },
                                _ => ()
                            };
                        }
                    }
                }
                for east_neighbour in bridge_tile.neighbours_east.iter() {
                    if let TileKind::Wang4Corner(kind) = east_neighbour {
                        for i in 0..bridge_tiles_offset {
                            match tiles[i].kind {
                                TileKind::Wang4Corner(kind_inner) if kind_inner == *kind => {
                                    bridge_match_queue_east.push_back((bridge_tile.kind, i))
                                },
                                _ => ()
                            };
                        }
                    }
                }
                for west_neighbour in bridge_tile.neighbours_west.iter() {
                    if let TileKind::Wang4Corner(kind) = west_neighbour {
                        for i in 0..bridge_tiles_offset {
                            match tiles[i].kind {
                                TileKind::Wang4Corner(kind_inner) if kind_inner == *kind => {
                                    bridge_match_queue_west.push_back((bridge_tile.kind, i))
                                },
                                _ => ()
                            };
                        }
                    }
                }
            }

            while !bridge_match_queue_south.is_empty() {
                let next_match = bridge_match_queue_south.pop_front().unwrap();
                tiles[next_match.1].neighbours_north.push(next_match.0);
            }

            while !bridge_match_queue_north.is_empty() {
                let next_match = bridge_match_queue_north.pop_front().unwrap();
                tiles[next_match.1].neighbours_south.push(next_match.0);
            }

            while !bridge_match_queue_east.is_empty() {
                let next_match = bridge_match_queue_east.pop_front().unwrap();
                tiles[next_match.1].neighbours_west.push(next_match.0);
            }

            while !bridge_match_queue_west.is_empty() {
                let next_match = bridge_match_queue_west.pop_front().unwrap();
                tiles[next_match.1].neighbours_east.push(next_match.0);
            }
        }

        let modules = tiles
            .iter()
            .map(|tile| {
                let mut module: WfcModule<CustomBitSet> = WfcModule::new();
                for i in 0..tiles.len() {
                    if tile.neighbours_north.contains(&tiles[i].kind) {
                        module.add_north_neighbour(i);
                    }
                    if tile.neighbours_south.contains(&tiles[i].kind) {
                        module.add_south_neighbour(i);
                    }
                    if tile.neighbours_west.contains(&tiles[i].kind) {
                        module.add_west_neighbour(i);
                    }
                    if tile.neighbours_east.contains(&tiles[i].kind) {
                        module.add_east_neighbour(i);
                    }
                }
                module
            })
            .collect::<Vec<_>>();
        
        Self {
            w,
            h,
            tile_width: dungeon_tiles.tile_width,
            tile_height: dungeon_tiles.tile_height,
            tiles,
            modules,
            texture,
            map_data: vec![(0, 0); w*h]
        }
    }

examples/summer_garden.rs (line 356)

    pub async fn new(w: usize, h: usize, draw_scale: f32) -> Self {
        let InternalGlContext {
            quad_context: ctx, ..
        } = unsafe { get_internal_gl() };

        let texture_bytes = load_file("assets/reduced_wang_scheme.png").await.unwrap();

        let img = image::load_from_memory(&texture_bytes[..])
            .unwrap_or_else(|e| panic!("{}", e))
            .to_rgba8();

        let img_w = img.width();
        let img_h = img.height();

        let texture = Texture2D::from_miniquad_texture(
            miniquad::Texture::from_data_and_format(
                ctx,
                &img.into_raw(),
                TextureParams {
                    format: TextureFormat::RGBA8,
                    wrap: TextureWrap::Clamp,
                    filter: FilterMode::Nearest,
                    width: img_w,
                    height: img_h
                }
            )
        );

        let atlas_bytes = load_file("assets/reduced_wang_scheme.ron").await.unwrap();
        let atlas: SummerGardenAtlas = from_reader(&atlas_bytes[..]).unwrap();

        let mut tile_sides = Vec::new();
        let mut neighbour_strategies = Vec::new();
        let mut tiles = Vec::new();

        {
            for tile_cfg in atlas.terrain_tile_configs.iter() {
                for pattern in &[
                    &atlas.reduced_wang_patterns[..],
                    &atlas.extended_set_1_patterns_north_west[..],
                    &atlas.extended_set_1_patterns_north_east[..],
                    &atlas.extended_set_1_patterns_south_west[..],
                    &atlas.extended_set_1_patterns_south_east[..],
                    &atlas.extended_set_2_patterns_north_west[..],
                    &atlas.extended_set_2_patterns_north_east[..],
                    &atlas.extended_set_2_patterns_south_west[..],
                    &atlas.extended_set_2_patterns_south_east[..],
                ] {
                    tile_sides.extend(
                        pattern.iter().map(
                            |pattern| {
                                TileSides {
                                    north_west: match pattern.north_west {
                                        TileKind::Inner => { tile_cfg.inner_type }
                                        TileKind::Outer => { tile_cfg.outer_type }
                                    },
                                    north_east: match pattern.north_east {
                                        TileKind::Inner => { tile_cfg.inner_type }
                                        TileKind::Outer => { tile_cfg.outer_type }
                                    },
                                    south_west: match pattern.south_west {
                                        TileKind::Inner => { tile_cfg.inner_type }
                                        TileKind::Outer => { tile_cfg.outer_type }
                                    },
                                    south_east: match pattern.south_east {
                                        TileKind::Inner => { tile_cfg.inner_type }
                                        TileKind::Outer => { tile_cfg.outer_type }
                                    }
                                }
                            }
                        )
                    );
                }
                for j in 0..4 {
                    for i in 0..4 {
                        tiles.push(SubRect{
                            x: i * 32 + tile_cfg.x_offset,
                            y: j * 32 + tile_cfg.y_offset,
                            width: 32,
                            height: 32
                        })
                    }
                }
                for jj in 0..2 {
                    for ii in 0..2 {
                        for j in 0..2 {
                            for i in 0..2 {
                                tiles.push(SubRect{
                                    x: (i + ii * 2) * 32 + tile_cfg.x_offset + 256,
                                    y: (j + jj * 2) * 32 + tile_cfg.y_offset,
                                    width: 32,
                                    height: 32
                                })
                            }
                        }
                    }
                }
                for jj in 0..2 {
                    for ii in 0..2 {
                        for j in 0..2 {
                            for i in 0..2 {
                                tiles.push(SubRect{
                                    x: (i + ii * 2) * 32 + tile_cfg.x_offset,
                                    y: (j + jj * 2) * 32 + tile_cfg.y_offset + 256,
                                    width: 32,
                                    height: 32
                                })
                            }
                        }
                    }
                }
                neighbour_strategies.extend_from_slice(&atlas.reduced_wang_neighbour_strategy[..]);
                for _ in 0..8 {
                    neighbour_strategies.extend_from_slice(&atlas.neighbour_strategy_2_x_2[..]);
                }
            }
            tile_sides.extend_from_slice(&atlas.vertical_bridge_sides[..]);
            tile_sides.extend_from_slice(&atlas.horizontal_bridge_sides[..]);
            for j in 0..3 {
                for i in 0..3 {
                    tiles.push(SubRect{
                        x: i * 32 + 256,
                        y: j * 32 + 256,
                        width: 32,
                        height: 32
                    })
                }
            }
            for j in 0..3 {
                for i in 0..3 {
                    tiles.push(SubRect{
                        x: i * 32 + 256 + 96,
                        y: j * 32 + 256,
                        width: 32,
                        height: 32
                    })
                }
            }
            neighbour_strategies.extend_from_slice(&atlas.neighbour_strategy_3_x_3[..]);
            neighbour_strategies.extend_from_slice(&atlas.neighbour_strategy_3_x_3[..]);

            assert_eq!(tile_sides.len(), neighbour_strategies.len());
        }

        let mut modules = Vec::new();
        for i in 0..tile_sides.len() {
            let current_sides = tile_sides[i];
            let mut module: WfcModule<CustomBitSet> = WfcModule::new();
            match neighbour_strategies[i].north {
                NeighbourKind::WangCorners => {
                    for j in 0..tile_sides.len() {
                        if neighbour_strategies[j].south != NeighbourKind::WangCorners {
                            continue;
                        }
                        if tile_sides[j].south_west == current_sides.north_west &&
                            tile_sides[j].south_east == current_sides.north_east {
                            module.add_north_neighbour(j);
                        }
                    }
                }
                NeighbourKind::RelOffset(offset) => {
                    let new_offset = (i as i32 + offset) as usize;
                    module.add_north_neighbour(new_offset);
                }
            }
            match neighbour_strategies[i].south {
                NeighbourKind::WangCorners => {
                    for j in 0..tile_sides.len() {
                        if neighbour_strategies[j].north != NeighbourKind::WangCorners {
                            continue;
                        }
                        if tile_sides[j].north_west == current_sides.south_west &&
                            tile_sides[j].north_east == current_sides.south_east {
                            module.add_south_neighbour(j);
                        }
                    }
                }
                NeighbourKind::RelOffset(offset) => {
                    let new_offset = (i as i32 + offset) as usize;
                    module.add_south_neighbour(new_offset);
                }
            }
            match neighbour_strategies[i].east {
                NeighbourKind::WangCorners => {
                    for j in 0..tile_sides.len() {
                        if neighbour_strategies[j].west != NeighbourKind::WangCorners {
                            continue;
                        }
                        if tile_sides[j].north_west == current_sides.north_east &&
                            tile_sides[j].south_west == current_sides.south_east {
                            module.add_east_neighbour(j);
                        }
                    }
                }
                NeighbourKind::RelOffset(offset) => {
                    let new_offset = (i as i32 + offset) as usize;
                    module.add_east_neighbour(new_offset);
                }
            }
            match neighbour_strategies[i].west {
                NeighbourKind::WangCorners => {
                    for j in 0..tile_sides.len() {
                        if neighbour_strategies[j].east != NeighbourKind::WangCorners {
                            continue;
                        }
                        if tile_sides[j].north_east == current_sides.north_west &&
                            tile_sides[j].south_east == current_sides.south_west {
                            module.add_west_neighbour(j);
                        }
                    }
                }
                NeighbourKind::RelOffset(offset) => {
                    let new_offset = (i as i32 + offset) as usize;
                    module.add_west_neighbour(new_offset);
                }
            }
            modules.push(module);
        }

        Self {
            w,
            h,
            draw_scale,
            atlas,
            tile_width: 32,
            tile_height: 32,
            tiles,
            modules,
            texture,
            map_data: vec![0; w*h],
            cell_tree_data: vec![TreeType::None; w*h],
            corner_tree_data: vec![TreeType::None; (w+1)*(h+1)]
        }
    }

pub fn add_east_neighbour(&mut self, idx: usize)

A function which adds a neighbour on an east side

Examples found in repository

examples/wang_corner_carpet.rs (line 133)

    pub async fn new(w: usize, h: usize) -> Self {
        let InternalGlContext {
            quad_context: ctx, ..
        } = unsafe { get_internal_gl() };

        let texture_bytes = load_file("assets/wang_4_corner.png").await.unwrap();

        let img = image::load_from_memory(&texture_bytes[..])
            .unwrap_or_else(|e| panic!("{}", e))
            .to_rgba8();

        let img_w = img.width();
        let img_h = img.height();

        let texture = Texture2D::from_miniquad_texture(
            miniquad::Texture::from_data_and_format(
                ctx,
                &img.into_raw(),
                TextureParams {
                    format: TextureFormat::RGBA8,
                    wrap: TextureWrap::Clamp,
                    filter: FilterMode::Nearest,
                    width: img_w,
                    height: img_h
                }
            )
        );

        let tiles = (0..=255)
            .map(|idx| {
                let width = 32;
                let height = 32;
                (
                    idx as u8,
                    SubRect {
                        x: (idx % 16) * width,
                        y: (idx / 16) * height,
                        width,
                        height
                    }
                )
            })
            .collect::<Vec<_>>();

        let modules = tiles
            .iter()
            .map(|tile| {
                let mut module: WfcModule<CustomBitSet> = WfcModule::new();
                for i in 0..tiles.len() {
                    let other_tile = &tiles[i];
                    if get_north_west(tile.0) == get_south_west(other_tile.0) &&
                        get_north_east(tile.0) == get_south_east(other_tile.0) {
                        module.add_north_neighbour(i);
                    }
                    if get_south_west(tile.0) == get_north_west(other_tile.0) &&
                        get_south_east(tile.0) == get_north_east(other_tile.0) {
                        module.add_south_neighbour(i);
                    }
                    if get_north_west(tile.0) == get_north_east(other_tile.0) &&
                        get_south_west(tile.0) == get_south_east(other_tile.0) {
                        module.add_west_neighbour(i);
                    }
                    if get_north_east(tile.0) == get_north_west(other_tile.0) &&
                        get_south_east(tile.0) == get_south_west(other_tile.0) {
                        module.add_east_neighbour(i);
                    }
                }
                module
            })
            .collect::<Vec<_>>();

        Self {
            w,
            h,
            tile_width: 32,
            tile_height: 32,
            tiles,
            modules,
            texture,
            map_data: vec![0; w*h]
        }
    }

examples/dungeon.rs (line 330)

    pub async fn new(w: usize, h: usize) -> Self {
        let InternalGlContext {
            quad_context: ctx, ..
        } = unsafe { get_internal_gl() };

        let dungeon_bytes = load_file("assets/dungeon_tiles.png").await.unwrap();

        let img = image::load_from_memory(&dungeon_bytes[..])
            .unwrap_or_else(|e| panic!("{}", e))
            .to_rgba8();

        let img_w = img.width();
        let img_h = img.height();

        let texture = Texture2D::from_miniquad_texture(
            miniquad::Texture::from_data_and_format(
                ctx,
                &img.into_raw(),
                TextureParams {
                    format: TextureFormat::RGBA8,
                    wrap: TextureWrap::Clamp,
                    filter: FilterMode::Nearest,
                    width: img_w,
                    height: img_h
                }
            )
        );

        let tiles_bytes = load_file("assets/dungeon_tiles.ron").await.unwrap();
        let dungeon_tiles: DungeonTiles = from_reader(&tiles_bytes[..]).unwrap();

        let mut tiles = Vec::new();
        for (kind_code, subrects) in dungeon_tiles.wang_4_corner_tiles.iter() {
            tiles.push(Tile {
                kind: TileKind::Wang4Corner(*kind_code),
                subrects: subrects.clone(),
                neighbours_east: Vec::new(),
                neighbours_west: Vec::new(),
                neighbours_north: Vec::new(),
                neighbours_south: Vec::new()
            });
        }
        // We need to be sure that zero tile is always a "void" tile, so we doing an extra sort step
        tiles.sort_by(|lhs, rhs| {
            match (lhs.kind, rhs.kind) {
                (TileKind::Wang4Corner(kind_lhs), TileKind::Wang4Corner(kind_rhs)) => kind_lhs.cmp(&kind_rhs),
                _ => Ordering::Equal
            }
        });

        for i in 0..tiles.len() {
            let current_kind = tiles[i].kind;
            for j in 0..tiles.len() {
                let candidate_kind = tiles[j].kind;
                let (matches_north, matches_south, matches_east, matches_west) = {
                    match (current_kind, candidate_kind) {
                        (TileKind::Wang4Corner(current), TileKind::Wang4Corner(candidate)) => {
                            (
                                get_north_east(current) == get_south_east(candidate) &&
                                    get_north_west(current) == get_south_west(candidate),

                                get_south_east(current) == get_north_east(candidate) &&
                                    get_south_west(current) == get_north_west(candidate),

                                get_north_east(current) == get_north_west(candidate) &&
                                    get_south_east(current) == get_south_west(candidate),

                                get_north_west(current) == get_north_east(candidate) &&
                                    get_south_west(current) == get_south_east(candidate),
                            )
                        },
                        _ => continue
                    }
                };
                if matches_east {
                    tiles[i].neighbours_east.push(candidate_kind);
                }
                if matches_west {
                    tiles[i].neighbours_west.push(candidate_kind);
                }
                if matches_north {
                    tiles[i].neighbours_north.push(candidate_kind);
                }
                if matches_south {
                    tiles[i].neighbours_south.push(candidate_kind);
                }
            }
        }

        //Add bridges:
        {
            let bridge_tiles_offset = tiles.len();
            tiles.extend_from_slice(&dungeon_tiles.extra_tiles[..]);

            let mut bridge_match_queue_south = VecDeque::new();
            let mut bridge_match_queue_north = VecDeque::new();
            let mut bridge_match_queue_east = VecDeque::new();
            let mut bridge_match_queue_west = VecDeque::new();

            for bridge_tile in &tiles[bridge_tiles_offset..] {
                for south_neighbour in bridge_tile.neighbours_south.iter() {
                    if let TileKind::Wang4Corner(kind) = south_neighbour {
                        for i in 0..bridge_tiles_offset {
                            match tiles[i].kind {
                                TileKind::Wang4Corner(kind_inner) if kind_inner == *kind => {
                                    bridge_match_queue_south.push_back((bridge_tile.kind, i))
                                },
                                _ => ()
                            };
                        }
                    }
                }
                for north_neighbour in bridge_tile.neighbours_north.iter() {
                    if let TileKind::Wang4Corner(kind) = north_neighbour {
                        for i in 0..bridge_tiles_offset {
                            match tiles[i].kind {
                                TileKind::Wang4Corner(kind_inner) if kind_inner == *kind => {
                                    bridge_match_queue_north.push_back((bridge_tile.kind, i))
                                },
                                _ => ()
                            };
                        }
                    }
                }
                for east_neighbour in bridge_tile.neighbours_east.iter() {
                    if let TileKind::Wang4Corner(kind) = east_neighbour {
                        for i in 0..bridge_tiles_offset {
                            match tiles[i].kind {
                                TileKind::Wang4Corner(kind_inner) if kind_inner == *kind => {
                                    bridge_match_queue_east.push_back((bridge_tile.kind, i))
                                },
                                _ => ()
                            };
                        }
                    }
                }
                for west_neighbour in bridge_tile.neighbours_west.iter() {
                    if let TileKind::Wang4Corner(kind) = west_neighbour {
                        for i in 0..bridge_tiles_offset {
                            match tiles[i].kind {
                                TileKind::Wang4Corner(kind_inner) if kind_inner == *kind => {
                                    bridge_match_queue_west.push_back((bridge_tile.kind, i))
                                },
                                _ => ()
                            };
                        }
                    }
                }
            }

            while !bridge_match_queue_south.is_empty() {
                let next_match = bridge_match_queue_south.pop_front().unwrap();
                tiles[next_match.1].neighbours_north.push(next_match.0);
            }

            while !bridge_match_queue_north.is_empty() {
                let next_match = bridge_match_queue_north.pop_front().unwrap();
                tiles[next_match.1].neighbours_south.push(next_match.0);
            }

            while !bridge_match_queue_east.is_empty() {
                let next_match = bridge_match_queue_east.pop_front().unwrap();
                tiles[next_match.1].neighbours_west.push(next_match.0);
            }

            while !bridge_match_queue_west.is_empty() {
                let next_match = bridge_match_queue_west.pop_front().unwrap();
                tiles[next_match.1].neighbours_east.push(next_match.0);
            }
        }

        let modules = tiles
            .iter()
            .map(|tile| {
                let mut module: WfcModule<CustomBitSet> = WfcModule::new();
                for i in 0..tiles.len() {
                    if tile.neighbours_north.contains(&tiles[i].kind) {
                        module.add_north_neighbour(i);
                    }
                    if tile.neighbours_south.contains(&tiles[i].kind) {
                        module.add_south_neighbour(i);
                    }
                    if tile.neighbours_west.contains(&tiles[i].kind) {
                        module.add_west_neighbour(i);
                    }
                    if tile.neighbours_east.contains(&tiles[i].kind) {
                        module.add_east_neighbour(i);
                    }
                }
                module
            })
            .collect::<Vec<_>>();
        
        Self {
            w,
            h,
            tile_width: dungeon_tiles.tile_width,
            tile_height: dungeon_tiles.tile_height,
            tiles,
            modules,
            texture,
            map_data: vec![(0, 0); w*h]
        }
    }

examples/summer_garden.rs (line 373)

    pub async fn new(w: usize, h: usize, draw_scale: f32) -> Self {
        let InternalGlContext {
            quad_context: ctx, ..
        } = unsafe { get_internal_gl() };

        let texture_bytes = load_file("assets/reduced_wang_scheme.png").await.unwrap();

        let img = image::load_from_memory(&texture_bytes[..])
            .unwrap_or_else(|e| panic!("{}", e))
            .to_rgba8();

        let img_w = img.width();
        let img_h = img.height();

        let texture = Texture2D::from_miniquad_texture(
            miniquad::Texture::from_data_and_format(
                ctx,
                &img.into_raw(),
                TextureParams {
                    format: TextureFormat::RGBA8,
                    wrap: TextureWrap::Clamp,
                    filter: FilterMode::Nearest,
                    width: img_w,
                    height: img_h
                }
            )
        );

        let atlas_bytes = load_file("assets/reduced_wang_scheme.ron").await.unwrap();
        let atlas: SummerGardenAtlas = from_reader(&atlas_bytes[..]).unwrap();

        let mut tile_sides = Vec::new();
        let mut neighbour_strategies = Vec::new();
        let mut tiles = Vec::new();

        {
            for tile_cfg in atlas.terrain_tile_configs.iter() {
                for pattern in &[
                    &atlas.reduced_wang_patterns[..],
                    &atlas.extended_set_1_patterns_north_west[..],
                    &atlas.extended_set_1_patterns_north_east[..],
                    &atlas.extended_set_1_patterns_south_west[..],
                    &atlas.extended_set_1_patterns_south_east[..],
                    &atlas.extended_set_2_patterns_north_west[..],
                    &atlas.extended_set_2_patterns_north_east[..],
                    &atlas.extended_set_2_patterns_south_west[..],
                    &atlas.extended_set_2_patterns_south_east[..],
                ] {
                    tile_sides.extend(
                        pattern.iter().map(
                            |pattern| {
                                TileSides {
                                    north_west: match pattern.north_west {
                                        TileKind::Inner => { tile_cfg.inner_type }
                                        TileKind::Outer => { tile_cfg.outer_type }
                                    },
                                    north_east: match pattern.north_east {
                                        TileKind::Inner => { tile_cfg.inner_type }
                                        TileKind::Outer => { tile_cfg.outer_type }
                                    },
                                    south_west: match pattern.south_west {
                                        TileKind::Inner => { tile_cfg.inner_type }
                                        TileKind::Outer => { tile_cfg.outer_type }
                                    },
                                    south_east: match pattern.south_east {
                                        TileKind::Inner => { tile_cfg.inner_type }
                                        TileKind::Outer => { tile_cfg.outer_type }
                                    }
                                }
                            }
                        )
                    );
                }
                for j in 0..4 {
                    for i in 0..4 {
                        tiles.push(SubRect{
                            x: i * 32 + tile_cfg.x_offset,
                            y: j * 32 + tile_cfg.y_offset,
                            width: 32,
                            height: 32
                        })
                    }
                }
                for jj in 0..2 {
                    for ii in 0..2 {
                        for j in 0..2 {
                            for i in 0..2 {
                                tiles.push(SubRect{
                                    x: (i + ii * 2) * 32 + tile_cfg.x_offset + 256,
                                    y: (j + jj * 2) * 32 + tile_cfg.y_offset,
                                    width: 32,
                                    height: 32
                                })
                            }
                        }
                    }
                }
                for jj in 0..2 {
                    for ii in 0..2 {
                        for j in 0..2 {
                            for i in 0..2 {
                                tiles.push(SubRect{
                                    x: (i + ii * 2) * 32 + tile_cfg.x_offset,
                                    y: (j + jj * 2) * 32 + tile_cfg.y_offset + 256,
                                    width: 32,
                                    height: 32
                                })
                            }
                        }
                    }
                }
                neighbour_strategies.extend_from_slice(&atlas.reduced_wang_neighbour_strategy[..]);
                for _ in 0..8 {
                    neighbour_strategies.extend_from_slice(&atlas.neighbour_strategy_2_x_2[..]);
                }
            }
            tile_sides.extend_from_slice(&atlas.vertical_bridge_sides[..]);
            tile_sides.extend_from_slice(&atlas.horizontal_bridge_sides[..]);
            for j in 0..3 {
                for i in 0..3 {
                    tiles.push(SubRect{
                        x: i * 32 + 256,
                        y: j * 32 + 256,
                        width: 32,
                        height: 32
                    })
                }
            }
            for j in 0..3 {
                for i in 0..3 {
                    tiles.push(SubRect{
                        x: i * 32 + 256 + 96,
                        y: j * 32 + 256,
                        width: 32,
                        height: 32
                    })
                }
            }
            neighbour_strategies.extend_from_slice(&atlas.neighbour_strategy_3_x_3[..]);
            neighbour_strategies.extend_from_slice(&atlas.neighbour_strategy_3_x_3[..]);

            assert_eq!(tile_sides.len(), neighbour_strategies.len());
        }

        let mut modules = Vec::new();
        for i in 0..tile_sides.len() {
            let current_sides = tile_sides[i];
            let mut module: WfcModule<CustomBitSet> = WfcModule::new();
            match neighbour_strategies[i].north {
                NeighbourKind::WangCorners => {
                    for j in 0..tile_sides.len() {
                        if neighbour_strategies[j].south != NeighbourKind::WangCorners {
                            continue;
                        }
                        if tile_sides[j].south_west == current_sides.north_west &&
                            tile_sides[j].south_east == current_sides.north_east {
                            module.add_north_neighbour(j);
                        }
                    }
                }
                NeighbourKind::RelOffset(offset) => {
                    let new_offset = (i as i32 + offset) as usize;
                    module.add_north_neighbour(new_offset);
                }
            }
            match neighbour_strategies[i].south {
                NeighbourKind::WangCorners => {
                    for j in 0..tile_sides.len() {
                        if neighbour_strategies[j].north != NeighbourKind::WangCorners {
                            continue;
                        }
                        if tile_sides[j].north_west == current_sides.south_west &&
                            tile_sides[j].north_east == current_sides.south_east {
                            module.add_south_neighbour(j);
                        }
                    }
                }
                NeighbourKind::RelOffset(offset) => {
                    let new_offset = (i as i32 + offset) as usize;
                    module.add_south_neighbour(new_offset);
                }
            }
            match neighbour_strategies[i].east {
                NeighbourKind::WangCorners => {
                    for j in 0..tile_sides.len() {
                        if neighbour_strategies[j].west != NeighbourKind::WangCorners {
                            continue;
                        }
                        if tile_sides[j].north_west == current_sides.north_east &&
                            tile_sides[j].south_west == current_sides.south_east {
                            module.add_east_neighbour(j);
                        }
                    }
                }
                NeighbourKind::RelOffset(offset) => {
                    let new_offset = (i as i32 + offset) as usize;
                    module.add_east_neighbour(new_offset);
                }
            }
            match neighbour_strategies[i].west {
                NeighbourKind::WangCorners => {
                    for j in 0..tile_sides.len() {
                        if neighbour_strategies[j].east != NeighbourKind::WangCorners {
                            continue;
                        }
                        if tile_sides[j].north_east == current_sides.north_west &&
                            tile_sides[j].south_east == current_sides.south_west {
                            module.add_west_neighbour(j);
                        }
                    }
                }
                NeighbourKind::RelOffset(offset) => {
                    let new_offset = (i as i32 + offset) as usize;
                    module.add_west_neighbour(new_offset);
                }
            }
            modules.push(module);
        }

        Self {
            w,
            h,
            draw_scale,
            atlas,
            tile_width: 32,
            tile_height: 32,
            tiles,
            modules,
            texture,
            map_data: vec![0; w*h],
            cell_tree_data: vec![TreeType::None; w*h],
            corner_tree_data: vec![TreeType::None; (w+1)*(h+1)]
        }
    }

pub fn add_west_neighbour(&mut self, idx: usize)

A function which adds a neighbour on a west side

Examples found in repository

examples/wang_corner_carpet.rs (line 129)

    pub async fn new(w: usize, h: usize) -> Self {
        let InternalGlContext {
            quad_context: ctx, ..
        } = unsafe { get_internal_gl() };

        let texture_bytes = load_file("assets/wang_4_corner.png").await.unwrap();

        let img = image::load_from_memory(&texture_bytes[..])
            .unwrap_or_else(|e| panic!("{}", e))
            .to_rgba8();

        let img_w = img.width();
        let img_h = img.height();

        let texture = Texture2D::from_miniquad_texture(
            miniquad::Texture::from_data_and_format(
                ctx,
                &img.into_raw(),
                TextureParams {
                    format: TextureFormat::RGBA8,
                    wrap: TextureWrap::Clamp,
                    filter: FilterMode::Nearest,
                    width: img_w,
                    height: img_h
                }
            )
        );

        let tiles = (0..=255)
            .map(|idx| {
                let width = 32;
                let height = 32;
                (
                    idx as u8,
                    SubRect {
                        x: (idx % 16) * width,
                        y: (idx / 16) * height,
                        width,
                        height
                    }
                )
            })
            .collect::<Vec<_>>();

        let modules = tiles
            .iter()
            .map(|tile| {
                let mut module: WfcModule<CustomBitSet> = WfcModule::new();
                for i in 0..tiles.len() {
                    let other_tile = &tiles[i];
                    if get_north_west(tile.0) == get_south_west(other_tile.0) &&
                        get_north_east(tile.0) == get_south_east(other_tile.0) {
                        module.add_north_neighbour(i);
                    }
                    if get_south_west(tile.0) == get_north_west(other_tile.0) &&
                        get_south_east(tile.0) == get_north_east(other_tile.0) {
                        module.add_south_neighbour(i);
                    }
                    if get_north_west(tile.0) == get_north_east(other_tile.0) &&
                        get_south_west(tile.0) == get_south_east(other_tile.0) {
                        module.add_west_neighbour(i);
                    }
                    if get_north_east(tile.0) == get_north_west(other_tile.0) &&
                        get_south_east(tile.0) == get_south_west(other_tile.0) {
                        module.add_east_neighbour(i);
                    }
                }
                module
            })
            .collect::<Vec<_>>();

        Self {
            w,
            h,
            tile_width: 32,
            tile_height: 32,
            tiles,
            modules,
            texture,
            map_data: vec![0; w*h]
        }
    }

examples/dungeon.rs (line 327)

    pub async fn new(w: usize, h: usize) -> Self {
        let InternalGlContext {
            quad_context: ctx, ..
        } = unsafe { get_internal_gl() };

        let dungeon_bytes = load_file("assets/dungeon_tiles.png").await.unwrap();

        let img = image::load_from_memory(&dungeon_bytes[..])
            .unwrap_or_else(|e| panic!("{}", e))
            .to_rgba8();

        let img_w = img.width();
        let img_h = img.height();

        let texture = Texture2D::from_miniquad_texture(
            miniquad::Texture::from_data_and_format(
                ctx,
                &img.into_raw(),
                TextureParams {
                    format: TextureFormat::RGBA8,
                    wrap: TextureWrap::Clamp,
                    filter: FilterMode::Nearest,
                    width: img_w,
                    height: img_h
                }
            )
        );

        let tiles_bytes = load_file("assets/dungeon_tiles.ron").await.unwrap();
        let dungeon_tiles: DungeonTiles = from_reader(&tiles_bytes[..]).unwrap();

        let mut tiles = Vec::new();
        for (kind_code, subrects) in dungeon_tiles.wang_4_corner_tiles.iter() {
            tiles.push(Tile {
                kind: TileKind::Wang4Corner(*kind_code),
                subrects: subrects.clone(),
                neighbours_east: Vec::new(),
                neighbours_west: Vec::new(),
                neighbours_north: Vec::new(),
                neighbours_south: Vec::new()
            });
        }
        // We need to be sure that zero tile is always a "void" tile, so we doing an extra sort step
        tiles.sort_by(|lhs, rhs| {
            match (lhs.kind, rhs.kind) {
                (TileKind::Wang4Corner(kind_lhs), TileKind::Wang4Corner(kind_rhs)) => kind_lhs.cmp(&kind_rhs),
                _ => Ordering::Equal
            }
        });

        for i in 0..tiles.len() {
            let current_kind = tiles[i].kind;
            for j in 0..tiles.len() {
                let candidate_kind = tiles[j].kind;
                let (matches_north, matches_south, matches_east, matches_west) = {
                    match (current_kind, candidate_kind) {
                        (TileKind::Wang4Corner(current), TileKind::Wang4Corner(candidate)) => {
                            (
                                get_north_east(current) == get_south_east(candidate) &&
                                    get_north_west(current) == get_south_west(candidate),

                                get_south_east(current) == get_north_east(candidate) &&
                                    get_south_west(current) == get_north_west(candidate),

                                get_north_east(current) == get_north_west(candidate) &&
                                    get_south_east(current) == get_south_west(candidate),

                                get_north_west(current) == get_north_east(candidate) &&
                                    get_south_west(current) == get_south_east(candidate),
                            )
                        },
                        _ => continue
                    }
                };
                if matches_east {
                    tiles[i].neighbours_east.push(candidate_kind);
                }
                if matches_west {
                    tiles[i].neighbours_west.push(candidate_kind);
                }
                if matches_north {
                    tiles[i].neighbours_north.push(candidate_kind);
                }
                if matches_south {
                    tiles[i].neighbours_south.push(candidate_kind);
                }
            }
        }

        //Add bridges:
        {
            let bridge_tiles_offset = tiles.len();
            tiles.extend_from_slice(&dungeon_tiles.extra_tiles[..]);

            let mut bridge_match_queue_south = VecDeque::new();
            let mut bridge_match_queue_north = VecDeque::new();
            let mut bridge_match_queue_east = VecDeque::new();
            let mut bridge_match_queue_west = VecDeque::new();

            for bridge_tile in &tiles[bridge_tiles_offset..] {
                for south_neighbour in bridge_tile.neighbours_south.iter() {
                    if let TileKind::Wang4Corner(kind) = south_neighbour {
                        for i in 0..bridge_tiles_offset {
                            match tiles[i].kind {
                                TileKind::Wang4Corner(kind_inner) if kind_inner == *kind => {
                                    bridge_match_queue_south.push_back((bridge_tile.kind, i))
                                },
                                _ => ()
                            };
                        }
                    }
                }
                for north_neighbour in bridge_tile.neighbours_north.iter() {
                    if let TileKind::Wang4Corner(kind) = north_neighbour {
                        for i in 0..bridge_tiles_offset {
                            match tiles[i].kind {
                                TileKind::Wang4Corner(kind_inner) if kind_inner == *kind => {
                                    bridge_match_queue_north.push_back((bridge_tile.kind, i))
                                },
                                _ => ()
                            };
                        }
                    }
                }
                for east_neighbour in bridge_tile.neighbours_east.iter() {
                    if let TileKind::Wang4Corner(kind) = east_neighbour {
                        for i in 0..bridge_tiles_offset {
                            match tiles[i].kind {
                                TileKind::Wang4Corner(kind_inner) if kind_inner == *kind => {
                                    bridge_match_queue_east.push_back((bridge_tile.kind, i))
                                },
                                _ => ()
                            };
                        }
                    }
                }
                for west_neighbour in bridge_tile.neighbours_west.iter() {
                    if let TileKind::Wang4Corner(kind) = west_neighbour {
                        for i in 0..bridge_tiles_offset {
                            match tiles[i].kind {
                                TileKind::Wang4Corner(kind_inner) if kind_inner == *kind => {
                                    bridge_match_queue_west.push_back((bridge_tile.kind, i))
                                },
                                _ => ()
                            };
                        }
                    }
                }
            }

            while !bridge_match_queue_south.is_empty() {
                let next_match = bridge_match_queue_south.pop_front().unwrap();
                tiles[next_match.1].neighbours_north.push(next_match.0);
            }

            while !bridge_match_queue_north.is_empty() {
                let next_match = bridge_match_queue_north.pop_front().unwrap();
                tiles[next_match.1].neighbours_south.push(next_match.0);
            }

            while !bridge_match_queue_east.is_empty() {
                let next_match = bridge_match_queue_east.pop_front().unwrap();
                tiles[next_match.1].neighbours_west.push(next_match.0);
            }

            while !bridge_match_queue_west.is_empty() {
                let next_match = bridge_match_queue_west.pop_front().unwrap();
                tiles[next_match.1].neighbours_east.push(next_match.0);
            }
        }

        let modules = tiles
            .iter()
            .map(|tile| {
                let mut module: WfcModule<CustomBitSet> = WfcModule::new();
                for i in 0..tiles.len() {
                    if tile.neighbours_north.contains(&tiles[i].kind) {
                        module.add_north_neighbour(i);
                    }
                    if tile.neighbours_south.contains(&tiles[i].kind) {
                        module.add_south_neighbour(i);
                    }
                    if tile.neighbours_west.contains(&tiles[i].kind) {
                        module.add_west_neighbour(i);
                    }
                    if tile.neighbours_east.contains(&tiles[i].kind) {
                        module.add_east_neighbour(i);
                    }
                }
                module
            })
            .collect::<Vec<_>>();
        
        Self {
            w,
            h,
            tile_width: dungeon_tiles.tile_width,
            tile_height: dungeon_tiles.tile_height,
            tiles,
            modules,
            texture,
            map_data: vec![(0, 0); w*h]
        }
    }

examples/summer_garden.rs (line 390)

    pub async fn new(w: usize, h: usize, draw_scale: f32) -> Self {
        let InternalGlContext {
            quad_context: ctx, ..
        } = unsafe { get_internal_gl() };

        let texture_bytes = load_file("assets/reduced_wang_scheme.png").await.unwrap();

        let img = image::load_from_memory(&texture_bytes[..])
            .unwrap_or_else(|e| panic!("{}", e))
            .to_rgba8();

        let img_w = img.width();
        let img_h = img.height();

        let texture = Texture2D::from_miniquad_texture(
            miniquad::Texture::from_data_and_format(
                ctx,
                &img.into_raw(),
                TextureParams {
                    format: TextureFormat::RGBA8,
                    wrap: TextureWrap::Clamp,
                    filter: FilterMode::Nearest,
                    width: img_w,
                    height: img_h
                }
            )
        );

        let atlas_bytes = load_file("assets/reduced_wang_scheme.ron").await.unwrap();
        let atlas: SummerGardenAtlas = from_reader(&atlas_bytes[..]).unwrap();

        let mut tile_sides = Vec::new();
        let mut neighbour_strategies = Vec::new();
        let mut tiles = Vec::new();

        {
            for tile_cfg in atlas.terrain_tile_configs.iter() {
                for pattern in &[
                    &atlas.reduced_wang_patterns[..],
                    &atlas.extended_set_1_patterns_north_west[..],
                    &atlas.extended_set_1_patterns_north_east[..],
                    &atlas.extended_set_1_patterns_south_west[..],
                    &atlas.extended_set_1_patterns_south_east[..],
                    &atlas.extended_set_2_patterns_north_west[..],
                    &atlas.extended_set_2_patterns_north_east[..],
                    &atlas.extended_set_2_patterns_south_west[..],
                    &atlas.extended_set_2_patterns_south_east[..],
                ] {
                    tile_sides.extend(
                        pattern.iter().map(
                            |pattern| {
                                TileSides {
                                    north_west: match pattern.north_west {
                                        TileKind::Inner => { tile_cfg.inner_type }
                                        TileKind::Outer => { tile_cfg.outer_type }
                                    },
                                    north_east: match pattern.north_east {
                                        TileKind::Inner => { tile_cfg.inner_type }
                                        TileKind::Outer => { tile_cfg.outer_type }
                                    },
                                    south_west: match pattern.south_west {
                                        TileKind::Inner => { tile_cfg.inner_type }
                                        TileKind::Outer => { tile_cfg.outer_type }
                                    },
                                    south_east: match pattern.south_east {
                                        TileKind::Inner => { tile_cfg.inner_type }
                                        TileKind::Outer => { tile_cfg.outer_type }
                                    }
                                }
                            }
                        )
                    );
                }
                for j in 0..4 {
                    for i in 0..4 {
                        tiles.push(SubRect{
                            x: i * 32 + tile_cfg.x_offset,
                            y: j * 32 + tile_cfg.y_offset,
                            width: 32,
                            height: 32
                        })
                    }
                }
                for jj in 0..2 {
                    for ii in 0..2 {
                        for j in 0..2 {
                            for i in 0..2 {
                                tiles.push(SubRect{
                                    x: (i + ii * 2) * 32 + tile_cfg.x_offset + 256,
                                    y: (j + jj * 2) * 32 + tile_cfg.y_offset,
                                    width: 32,
                                    height: 32
                                })
                            }
                        }
                    }
                }
                for jj in 0..2 {
                    for ii in 0..2 {
                        for j in 0..2 {
                            for i in 0..2 {
                                tiles.push(SubRect{
                                    x: (i + ii * 2) * 32 + tile_cfg.x_offset,
                                    y: (j + jj * 2) * 32 + tile_cfg.y_offset + 256,
                                    width: 32,
                                    height: 32
                                })
                            }
                        }
                    }
                }
                neighbour_strategies.extend_from_slice(&atlas.reduced_wang_neighbour_strategy[..]);
                for _ in 0..8 {
                    neighbour_strategies.extend_from_slice(&atlas.neighbour_strategy_2_x_2[..]);
                }
            }
            tile_sides.extend_from_slice(&atlas.vertical_bridge_sides[..]);
            tile_sides.extend_from_slice(&atlas.horizontal_bridge_sides[..]);
            for j in 0..3 {
                for i in 0..3 {
                    tiles.push(SubRect{
                        x: i * 32 + 256,
                        y: j * 32 + 256,
                        width: 32,
                        height: 32
                    })
                }
            }
            for j in 0..3 {
                for i in 0..3 {
                    tiles.push(SubRect{
                        x: i * 32 + 256 + 96,
                        y: j * 32 + 256,
                        width: 32,
                        height: 32
                    })
                }
            }
            neighbour_strategies.extend_from_slice(&atlas.neighbour_strategy_3_x_3[..]);
            neighbour_strategies.extend_from_slice(&atlas.neighbour_strategy_3_x_3[..]);

            assert_eq!(tile_sides.len(), neighbour_strategies.len());
        }

        let mut modules = Vec::new();
        for i in 0..tile_sides.len() {
            let current_sides = tile_sides[i];
            let mut module: WfcModule<CustomBitSet> = WfcModule::new();
            match neighbour_strategies[i].north {
                NeighbourKind::WangCorners => {
                    for j in 0..tile_sides.len() {
                        if neighbour_strategies[j].south != NeighbourKind::WangCorners {
                            continue;
                        }
                        if tile_sides[j].south_west == current_sides.north_west &&
                            tile_sides[j].south_east == current_sides.north_east {
                            module.add_north_neighbour(j);
                        }
                    }
                }
                NeighbourKind::RelOffset(offset) => {
                    let new_offset = (i as i32 + offset) as usize;
                    module.add_north_neighbour(new_offset);
                }
            }
            match neighbour_strategies[i].south {
                NeighbourKind::WangCorners => {
                    for j in 0..tile_sides.len() {
                        if neighbour_strategies[j].north != NeighbourKind::WangCorners {
                            continue;
                        }
                        if tile_sides[j].north_west == current_sides.south_west &&
                            tile_sides[j].north_east == current_sides.south_east {
                            module.add_south_neighbour(j);
                        }
                    }
                }
                NeighbourKind::RelOffset(offset) => {
                    let new_offset = (i as i32 + offset) as usize;
                    module.add_south_neighbour(new_offset);
                }
            }
            match neighbour_strategies[i].east {
                NeighbourKind::WangCorners => {
                    for j in 0..tile_sides.len() {
                        if neighbour_strategies[j].west != NeighbourKind::WangCorners {
                            continue;
                        }
                        if tile_sides[j].north_west == current_sides.north_east &&
                            tile_sides[j].south_west == current_sides.south_east {
                            module.add_east_neighbour(j);
                        }
                    }
                }
                NeighbourKind::RelOffset(offset) => {
                    let new_offset = (i as i32 + offset) as usize;
                    module.add_east_neighbour(new_offset);
                }
            }
            match neighbour_strategies[i].west {
                NeighbourKind::WangCorners => {
                    for j in 0..tile_sides.len() {
                        if neighbour_strategies[j].east != NeighbourKind::WangCorners {
                            continue;
                        }
                        if tile_sides[j].north_east == current_sides.north_west &&
                            tile_sides[j].south_east == current_sides.south_west {
                            module.add_west_neighbour(j);
                        }
                    }
                }
                NeighbourKind::RelOffset(offset) => {
                    let new_offset = (i as i32 + offset) as usize;
                    module.add_west_neighbour(new_offset);
                }
            }
            modules.push(module);
        }

        Self {
            w,
            h,
            draw_scale,
            atlas,
            tile_width: 32,
            tile_height: 32,
            tiles,
            modules,
            texture,
            map_data: vec![0; w*h],
            cell_tree_data: vec![TreeType::None; w*h],
            corner_tree_data: vec![TreeType::None; (w+1)*(h+1)]
        }
    }

Trait Implementations

impl<TBitSet> Clone for WfcModule<TBitSet>

where TBitSet: BitSearch + BitEmpty + BitSet + BitIntersection + BitUnion + BitTestNone + Hash + Eq + Copy + BitIntersection<Output = TBitSet> + BitUnion<Output = TBitSet> + Clone,

fn clone(&self) -> WfcModule<TBitSet>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<TBitSet> Copy for WfcModule<TBitSet>

where TBitSet: BitSearch + BitEmpty + BitSet + BitIntersection + BitUnion + BitTestNone + Hash + Eq + Copy + BitIntersection<Output = TBitSet> + BitUnion<Output = TBitSet> + Copy,