3D Cellular Automata [Raylib/C++]

• Quick notes
  • Download
  • Raylib
• Definition of Cellular Automata
  • Uses of cellular automata
    • Epidemiology
    • Anthropology
    • Biology
    • Physics
    • Cryptography
• Cell rules explained
  • Survival
  • Spawn
  • State
  • Neighborhoods
  • Examples
• How to change the rules, colors, and settings (options.json)
  • Changing the rules
  • Changing the settings
    • cellBounds
    • aliveChanceOnSpawn
    • threads
    • targetFPS
• Simulation
  • Controls
    • Camera controls
    • Window controls
    • Simulation controls
  • Draw modes
    • Dual color
    • RGB
    • Dual color dying
    • Single color
    • Distance from center
  • Tick modes
    • Fast
    • Dynamic
    • Manual
• Optimizations
  • Indexing over iteration
  • 1 dimensional vector
  • Branching at the highest level
  • Branchless programing
  • Multithreading
    • Update at the same time as rendering
    • Multiple threads for updating
• Compiling

Quick notes

Download

To quickly download the latest executable and needed files (main.exe and the options.json), click here. Note: this was only build for Windows, but all libraries used are fully cross platform (I think). Information about compiling for non-Windows can be found here.

Raylib

For graphics, the Raylib library is used. At first I wanted to use wgpu with Rust because there were many tutorials online. (UPDATE: I did it! Running live on the web: https://lelserslasers.itch.io/3d-cellular-automata-wgpu-rust) However, I quickly found that it was overkill for what I needed and I wanted to focus on the simulation rather than writing complex shader code. Raylib is very simple to use, just DrawCube(pos, w, l, h, color); and a 3d cube appears. Raylib is written purely in C99, but has bindings to many languages, including Python, Java, and Rust. I was tempted to use one of the bindings, but many of the binding were converted to fit the languages paradigms and did not match 1 to 1 with the documentation or examples. The library itself without any bindings is fully compatible with C++, and I really am used to using classes, so I chose C++ over C. (Note: there is a C++ binding that follows the C++ paradigm rather than the C one, but I chose not to use it for simplicity.)

Definition of cellular automata

A cellular automaton is a collection of "colored" cells on a grid of specified shape that evolves through a number of discrete time steps according to a set of rules based on the states of neighboring cells. The rules are then applied iteratively for as many time steps as desired.

— Wolframe MathWorld

A cellular automaton consists of a regular grid of cells, each in one of a finite number of states, such as on and off (in contrast to a coupled map lattice). The grid can be in any finite number of dimensions. For each cell, a set of cells called its neighborhood is defined relative to the specified cell. An initial state (time t = 0) is selected by assigning a state for each cell. A new generation is created (advancing t by 1), according to some fixed rule (generally, a mathematical function) that determines the new state of each cell in terms of the current state of the cell and the states of the cells in its neighborhood. Typically, the rule for updating the state of cells is the same for each cell and does not change over time, and is applied to the whole grid simultaneously.

— Wikipedia

Cellular automata are discrete, abstract computational systems that have proved useful both as general models of complexity and as more specific representations of non-linear dynamics in a variety of scientific fields. Firstly, cellular automata are (typically) spatially and temporally discrete: they are composed of a finite or denumerable set of homogeneous, simple units, the atoms or cells. At each time unit, the cells instantiate one of a finite set of states. They evolve in parallel at discrete time steps, following state update functions or dynamical transition rules: the update of a cell state obtains by taking into account the states of cells in its local neighborhood (there are, therefore, no actions at a distance). Secondly, cellular automata are abstract: they can be specified in purely mathematical terms and physical structures can implement them. Thirdly, cellular automata are computational systems: they can compute functions and solve algorithmic problems. Despite functioning in a different way from traditional, Turing machine-like devices, cellular automata with suitable rules can emulate a universal Turing machine (see entry), and therefore compute, given Turing’s thesis (see entry), anything computable.

— Stanford Encyclopedia of Philosophy

A cellular automaton is a collection of cells arranged in a grid of specified shape, such that each cell changes state as a function of time, according to a defined set of rules driven by the states of neighboring cells.

— TechTarget

Uses of cellular automata

Epidemiology

Cellular automata are used to study the evolution of disease epidemics through computer modeling.

Anthropology

In anthropology, cellular automata with fundamental space-time representations are used to model the formation of civil societies.

Sociology

Cellular automata are used to study the causes and effects of civil violence.

Biology

Several biological processes and systems are simulated using cellular automata, including the patterns of some seashells, moving wave patterns on the skin of cephalopods and the behaviors of brain neurons.

Physics

Cellular automata are used to simulate and study physical phenomena, such as gas and fluid dynamics.

Cryptography

Cellular automata automata are proposed for use in public key cryptography. They can be utilized to construct pseudorandom number generators, and to design error correction codes.

Sources:

• https://www.techtarget.com/searchenterprisedesktop/definition/cellular-automaton#:~:text=A%20cellular%20automaton%20(CA)%20is,the%20states%20of%20neighboring%20cells.
• https://en.wikipedia.org/wiki/Cellular_automaton#Applications

Cell rules explained

There are 4 rules: survival, spawn, state, and neighborhoods. A cell can be in one of 3 states: alive, dying, or dead.

Survival

• [X, Y, ...]
  • Can be a list of numbers (ex: [2, 3, 6, 7, 10]) or a single number (ex: [2])
• If a cell is alive, it will remain alive if it has X, Y, or ... neighbors
• If it does not have X, Y, or ... neighbors, it will begin dying

Spawn

• [X, Y, ...]
  • Can be a list of numbers (ex: [2, 3, 6, 7, 10]) or a single number (ex: [2])
  • Can have any amount of overlap with survival
• If a cell is dead, it will come alive if it has X, Y, or ... neighbors

State

• X
  • Must be a single number (ex: 6)
• Once a cell begins dying, it has X simulation/update ticks to live before disappearing
• Both survival and spawn rules will no longer affect the cell while it decays

Neighborhoods

• "M" or "VN"
• How neighbors are counted
• "M" - Moore:
  • Neighbors are any cells where 1 away, including diagonals
  • Think like a Rubik's cube where the current cell is the middle, all the outside/colored cubes are the neighbors
  • 3^3 - 1 = 26 possible neighbors
• "VN" - Von Neumann:
  • Neighbors are only cells where the faces touch
  • 6 possible neighbors

Some examples

(Note: can just copy/replace in options.json)

• Slow build up: <9-18/5-7,12-13,15/6/M>

  "survival": [9, 10, 11, 12, 13, 14, 15, 16, 17, 18],
  "spawn": [5, 6, 7, 12, 13, 15],
  "state": 6,
  "neighborhood": "M",
  

• Outward expansion + hallow center: <2,6,9/4,6,8-9/10/M>

  "survival": [2, 6, 9],
  "spawn": [4, 6, 8, 9],
  "state": 10,
  "neighborhood": "M",
  

How to change the rules, colors, and settings

The rules, colors, and settings for the simulation can be found in options.json. When editing the file, make sure that all the keys/variables are still there, and that the types of the values (number, list of numbers, string) are not changed. The simulation loads the settings from the file when it is started, but they can be reloaded by pressing J.

Changing the rules

The first 4 options (survival, spawn, state, neighborhood) are the rules for the actually cellular automata. The explanations for these rules are above (as well as their types).

Changing the colors

Defaults:

    "dualColorAlive": [0, 228, 48],
    "dualColorDead": [230, 41, 55],
    "dualColorDyingAlive": [230, 41, 55],
    "singleColorAlive": [255, 20, 20],
    "centerDistMax": [255, 255, 255],

See draw modes for more information about how the colors work. The values are a list of three numbers, representing the RGB values of the color where 255 = 100% color intensity, and 0 = 0%. (So [255, 0, 0] is red, [0, 0, 0] is black, [255, 255, 255] is white, etc.)

Changing the settings

Defaults:

    "cellBounds": 96,
    "aliveChanceOnSpawn": 0.15,
    "threads": 8,
    "targetFPS": 15

cellBounds

• The number of cells in each direction (x, y, z)
• The total number of cells is cellBounds3
• Higher cellBounds will make the simulation slower, but the simulation will also be more complex and less likely to become static or fully die out
• Type: int

aliveChanceOnSpawn

• When the simulation starts, only the middle section will have a chance to spawn
  • The middle section is the middle 1/9 of the simulation (1/3 of each edge)
• This might need to be changed depending on the rules to make sure everything doesn't instantly die out
• 1.0 = 100% chance to spawn
• Type: float

threads

• It is not the total number of the treads used by the simulation
• The total number of threads used by the simulation is threads + 2 because the main thread and the update thread (which then creates 'threads' threads)
  • See the multithreading section for more info
• Type: int

targetFPS

• Used for dynamic tick mode
  • See the dynamic tick mode section for more info
• Type: int

Simulation

Controls

Keyboard and