Convert Figma logo to code with AI

mxgmn logoWaveFunctionCollapse

Bitmap & tilemap generation from a single example with the help of ideas from quantum mechanics

23,184
1,237
23,184
5
View on GitHub

Top Related Projects

mxgmn's avatar

MarkovJunior

7,406

Probabilistic language based on pattern matching and constraint propagation, 153 examples

Quick Overview

WaveFunctionCollapse is an algorithm that generates game levels, textures, and other 2D/3D content by example. It uses a technique called "Constraint Propagation" to generate new content that matches the statistical properties of a given input sample.

Pros

  • Procedural Content Generation: WaveFunctionCollapse allows for the generation of unique and varied content based on a small set of input samples, making it useful for creating game levels, textures, and other assets.
  • Constraint Propagation: The algorithm uses a constraint propagation technique to ensure that the generated content adheres to the statistical properties of the input, resulting in more coherent and realistic-looking output.
  • Versatility: The algorithm can be applied to a wide range of content types, including 2D and 3D, and can be customized to fit specific use cases.
  • Open-Source: The project is open-source, allowing for community contributions and further development.

Cons

  • Complexity: The underlying algorithm can be complex to understand and implement, especially for those new to the field of procedural content generation.
  • Performance: Depending on the size and complexity of the input samples, the algorithm can be computationally intensive and may require optimization for real-time applications.
  • Limitations: The algorithm may struggle to generate content that deviates significantly from the input samples, and it may not be suitable for all types of content generation tasks.
  • Lack of Documentation: The project's documentation could be more comprehensive, making it challenging for new users to get started.

Code Examples

Here are a few code examples demonstrating the usage of the WaveFunctionCollapse library:

from wfc import run_wfc
from PIL import Image

# Load the input image
input_image = Image.open("input.png")

# Generate a new image using the WaveFunctionCollapse algorithm
output_image = run_wfc(input_image, size=(64, 64))

# Save the generated image
output_image.save("output.png")

This example demonstrates how to use the run_wfc function to generate a new image based on an input image.

from wfc import run_wfc
from wfc.tiles import Tile

# Define the tiles
tiles = [
    Tile("A", [0, 0, 1, 1]),
    Tile("B", [1, 0, 0, 1]),
    Tile("C", [0, 1, 1, 0]),
    Tile("D", [1, 1, 0, 0]),
]

# Generate a new 2D grid using the WaveFunctionCollapse algorithm
output_grid = run_wfc(tiles, size=(8, 8))

# Print the generated grid
for row in output_grid:
    print(" ".join(tile.name for tile in row))

This example demonstrates how to use the run_wfc function to generate a 2D grid of tiles based on a set of predefined tiles.

using WaveFunctionCollapse;
using UnityEngine;

public class WFCExample : MonoBehaviour
{
    public Texture2D inputTexture;
    public int outputSize = 64;

    private void Start()
    {
        // Generate a new texture using the WaveFunctionCollapse algorithm
        Texture2D outputTexture = WFCGenerator.GenerateTexture(inputTexture, outputSize, outputSize);

        // Create a new GameObject with the generated texture
        GameObject go = new GameObject("Generated Texture");
        go.AddComponent<MeshFilter>().mesh = WFCGenerator.CreateMesh(outputTexture);
        go.AddComponent<MeshRenderer>().material.mainTexture = outputTexture;
    }
}

This C# example demonstrates how to use the WaveFunctionCollapse algorithm to generate a new texture and create a 3D mesh object with the generated texture in a Unity project.

Getting Started

To get started with the WaveFunctionCollapse project, follow these steps:

  1. Clone the repository:

    git clone https://github.com/mxgmn/WaveFunctionCollapse.git

  2. Navigate to the project directory:

Competitor Comparisons

mxgmn logo

MarkovJunior

7,406

Probabilistic language based on pattern matching and constraint propagation, 153 examples

Pros of MarkovJunior

  • More versatile and powerful, capable of generating a wider range of patterns and structures
  • Supports 3D generation, allowing for more complex and immersive outputs
  • Includes a visual editor for easier rule creation and experimentation

Cons of MarkovJunior

  • More complex to use and understand, requiring a deeper knowledge of Markov models
  • Slower execution time due to increased complexity and 3D capabilities
  • Less focused on texture synthesis, which is a strength of WaveFunctionCollapse

Code Comparison

WaveFunctionCollapse:

static int[] Observe(int[][] wave, double[] weights, int MX, int MY, int T)
{
    double min = double.PositiveInfinity;
    int argmin = -1;
    for (int i = 0; i < wave.Length; i++)
    {
        // ... (observation logic)
    }
    return new int[] { argmin % MX, argmin / MX };
}

MarkovJunior:

public static bool Run(int[] state, Rule[] rules, int steps, int seed)
{
    Random random = new Random(seed);
    for (int i = 0; i < steps; i++)
    {
        // ... (rule application logic)
    }
    return true;
}

The code snippets show that MarkovJunior focuses on rule-based generation, while WaveFunctionCollapse emphasizes observation and constraint satisfaction in its core algorithm.

Convert Figma logo designs to code with AI

Visual Copilot

Introducing Visual Copilot: A new AI model to turn Figma designs to high quality code using your components.

Try Visual Copilot

README

WaveFunctionCollapse

This program generates bitmaps that are locally similar to the input bitmap.

main collage

main gif

Local similarity means that

  • (C1) The output should contain only those NxN patterns of pixels that are present in the input.
  • (Weak C2) Distribution of NxN patterns in the input should be similar to the distribution of NxN patterns over a sufficiently large number of outputs. In other words, probability to meet a particular pattern in the output should be close to the density of such patterns in the input.

In the examples a typical value of N is 3.

local similarity

WFC initializes output bitmap in a completely unobserved state, where each pixel value is in superposition of colors of the input bitmap (so if the input was black & white then the unobserved states are shown in different shades of grey). The coefficients in these superpositions are real numbers, not complex numbers, so it doesn't do the actual quantum mechanics, but it was inspired by QM. Then the program goes into the observation-propagation cycle:

  • On each observation step an NxN region is chosen among the unobserved which has the lowest Shannon entropy. This region's state then collapses into a definite state according to its coefficients and the distribution of NxN patterns in the input.
  • On each propagation step new information gained from the collapse on the previous step propagates through the output.

On each step the number of non-zero coefficients decreases and in the end we have a completely observed state, the wave function has collapsed.

It may happen that during propagation all the coefficients for a certain pixel become zero. That means that the algorithm has run into a contradiction and can not continue. The problem of determining whether a certain bitmap allows other nontrivial bitmaps satisfying condition (C1) is NP-hard, so it's impossible to create a fast solution that always finishes. In practice, however, the algorithm runs into contradictions surprisingly rarely.

Wave Function Collapse algorithm has been implemented in C++, Python, Kotlin, Rust, Julia, Go, Haxe, Java, Clojure, Free Pascal, p5js, JavaScript and adapted to Unity, Unreal Engine 5 and Houdini. You can build WFC from source, download an official release for Windows, download an interactive graphical version from itch.io or run it in the browser. WFC generates levels in Bad North, Caves of Qud, Dead Static Drive, Townscaper, Matrix Awakens, several smaller games and many prototypes. It led to new research. For more related work, explanations, interactive demos, guides, tutorials and examples see the ports, forks and spinoffs section.

Watch a video demonstration of WFC algorithm on YouTube: https://youtu.be/DOQTr2Xmlz0

Algorithm

  1. Read the input bitmap and count NxN patterns.
    1. (optional) Augment pattern data with rotations and reflections.
  2. Create an array with the dimensions of the output (called "wave" in the source). Each element of this array represents a state of an NxN region in the output. A state of an NxN region is a superposition of NxN patterns of the input with boolean coefficients (so a state of a pixel in the output is a superposition of input colors with real coefficients). False coefficient means that the corresponding pattern is forbidden, true coefficient means that the corresponding pattern is not yet forbidden.
  3. Initialize the wave in the completely unobserved state, i.e. with all the boolean coefficients being true.
  4. Repeat the following steps:
    1. Observation:
      1. Find a wave element with the minimal nonzero entropy. If there is no such elements (if all elements have zero or undefined entropy) then break the cycle (4) and go to step (5).
      2. Collapse this element into a definite state according to its coefficients and the distribution of NxN patterns in the input.
    2. Propagation: propagate information gained on the previous observation step.
  5. By now all the wave elements are either in a completely observed state (all the coefficients except one being zero) or in the contradictory state (all the coefficients being zero). In the first case return the output. In the second case finish the work without returning anything.

Tilemap generation

The simplest nontrivial case of the algorithm is when NxN=1x2 (well, NxM). If we simplify it even further by storing not the probabilities of pairs of colors but the probabilities of colors themselves, we get what we call a "simple tiled model". The propagation phase in this model is just adjacency constraint propagation. It's convenient to initialize the simple tiled model with a list of tiles and their adjacency data (adjacency data can be viewed as a large set of very small samples) rather than a sample bitmap.

Lists of all the possible pairs of adjacent tiles in practical tilesets can be quite long, so I implemented a symmetry system for tiles to shorten the enumeration. In this system each tile should be assigned with its symmetry type.

symmetries

Note that the tiles have the same symmetry type as their assigned letters (or, in other words, actions of the dihedral group D4 are isomorphic for tiles and their corresponding letters). With this system it's enough to enumerate pairs of adjacent tiles only up to symmetry, which makes lists of adjacencies for tilesets with many symmetrical tiles (even the summer tileset, despite drawings not being symmetrical the system considers such tiles to be symmetrical) several times shorter.

knots tiled rooms circuit 1 circuit 2 circles castle summer 1 summer 2

Note that the unrestrained knot tileset (with all 5 tiles being allowed) is not interesting for WFC, because you can't run into a situation where you can't place a tile. We call tilesets with this property "easy". Without special heuristics easy tilesets don't produce interesting global arrangements, because correlations of tiles in easy tilesets quickly fall off with a distance. Many easy tilesets can be found on Guy Walker's website. Consider the "Dual" 2-edge tileset there. How can it generate knots (without t-junctions, not easy) while being easy? The answer is, it can only generate a narrow class of knots, it can't produce an arbitrary knot.

Note also that Circuit, Summer and Rooms tilesets are non-Wang. That is, their adjacency data cannot be induced from edge labels. For example, in Circuit two Corners cannot be adjacent, yet they can be connected with a Connection tile, and diagonal tracks cannot change direction.

Higher dimensions

WFC algorithm in higher dimensions works completely the same way as in dimension 2, though performance becomes an issue. These voxel models were generated with N=2 overlapping tiled model using 5x5x5 and 5x5x2 blocks and additional heuristics (height, density, curvature, ...).

voxels

Higher resolution screenshots: 1, 2, 3.

MarkovJunior repository contains an implementation of the 3d simple tiled model with many tilesets and examples.

Constrained synthesis

WFC algorithm supports constraints. Therefore, it can be easily combined with other generative algorithms or with manual creation.

Here is WFC autocompleting a level started by a human:

ConvChain algorithm satisfies the strong version of the condition (C2): the limit distribution of NxN patterns in the outputs it is producing is exactly the same as the distributions of patterns in the input. However, ConvChain doesn't satisfy (C1): it often produces noticeable defects. It makes sense to run ConvChain first to get a well-sampled configuration and then run WFC to correct local defects. This is similar to a common strategy in optimization: first run a Monte-Carlo method to find a point close to a global optimum and then run a gradient descent from that point for greater accuracy.

P. F. Harrison's texture synthesis algorithm is significantly faster than WFC, but it has trouble with long correlations (for example, it's difficult for this algorithm to synthesize brick wall textures with correctly aligned bricks). But this is exactly where WFC shines, and Harrison's algorithm supports constraints. It makes sense first to generate a perfect brick wall blueprint with WFC and then run a constrained texture synthesis algorithm on that blueprint.

Comments

Why the minimal entropy heuristic? I noticed that when humans draw something they often follow the minimal entropy heuristic themselves. That's why the algorithm is so enjoyable to watch.

The overlapping model relates to the simple tiled model the same way higher order Markov chains relate to order one Markov chains.

WFC's propagation phase is very similar to the loopy belief propagation algorithm. In fact, I first programmed belief propagation, but then switched to constraint propagation with a saved stationary distribution, because BP is significantly slower without a massive parallelization (on a CPU) and didn't produce significantly better results in my problems.

Note that the "Simple Knot" and "Trick Knot" samples have 3 colors, not 2.

One of the dimensions can be time. In particular, d-dimensional WFC captures the behaviour of any (d-1)-dimensional cellular automata.

Used work

  1. Alexei A. Efros and Thomas K. Leung, Texture Synthesis by Non-parametric Sampling, 1999. WaveFunctionCollapse is a texture synthesis algorithm. Compared to the earlier texture synthesis algorithms, WFC guarantees that the output contains only those NxN patterns that are present in the input. This makes WFC perfect for level generation in games and pixel art, and less suited for large full-color textures.
  2. Paul C. Merrell, Model Synthesis, 2009. Merrell derives adjacency constraints between tiles from an example model and generates a new larger model with the AC-3 algorithm. We generalize his approach to work with NxN overlapping patterns of tiles instead of individual tiles. This allows to use a single image as the input to the algorithm. By varying N, we can make the output look more like the input or less. We introduce the lowest entropy heuristic that removes the directional bias in generated results, is defined for irregular grids and is better suited for pre-constrained problems. We implement a tile symmetry system to reduce the sizes of inputs. We visualize partially observed states, either with color averaging or per-voxel voting. Merrell also introduced a method of incrementally modifying the model in parts to reduce the failure rate (which we don't use here). Recently the author created a page for model synthesis and published code.
  3. Alan K. Mackworth, Consistency in Networks of Relations, 1977. WFC translates a texture synthesis problem into a constraint satisfaction problem. Currently it uses the AC-4 algorithm by Roger Mohr and Thomas C. Henderson, 1986.
  4. Paul F. Harrison, Image Texture Tools, 2005. WFC was also influenced by the declarative texture synthesis chapter of Paul Harrison's dissertation. The author defines adjacency data of tiles by labeling their borders and uses backtracking search to fill the tilemap. A demonstration of the algorithm is available on the web.

How to build

WFC is a console application that depends only on the standard library. Get .NET Core for Windows, Linux or macOS and run

dotnet run --configuration Release WaveFunctionCollapse.csproj

Generated results are saved into the output folder. Edit samples.xml to change model parameters.

Alternatively, use build instructions from the community for various platforms from the relevant issue. Casey Marshall made a pull request that makes using the program with the command line more convenient and includes snap packaging.

Notable ports, forks and spinoffs

Credits

Circles tileset is taken from Mario Klingemann. FloorPlan tileset is taken from Lingdong Huang. Summer tiles were drawn by Hermann Hillmann. Cat overlapping sample is taken from the Nyan Cat video, Water + Forest + Mountains samples are taken from Ultima IV, 3Bricks sample is taken from Dungeon Crawl Stone Soup, Qud sample was made by Brian Bucklew, MagicOffice + Spirals samples - by rid5x, ColoredCity + Link + Link 2 + Mazelike + RedDot + SmileCity samples - by Arvi Teikari, Wall sample - by Arcaniax, NotKnot + Sand + Wrinkles samples - by Krystian Samp, Circle sample - by Noah Buddy. The rest of the examples and tilesets were made by me. Idea of generating integrated circuits was suggested to me by Moonasaur and their style was taken from Zachtronics' Ruckingenur II. Voxel models were rendered in MagicaVoxel.

second collage

voxel perspective