Godot Engine module that wraps the FastNoiseSIMD library
MIT License
This module wraps the FastNoiseSIMD library for use with Godot Engine 3.2+.
It automatically detects the highest SIMD level available at runtime. It does not require SIMD to build or run, so your games can run on a variety of systems.
Many noise libraries provide singular lookups (e.g. get_nosie_3d(x, y, z). I have provided these singular functions, but they are approximately 3x slower than the same function in the original FastNoise library. The speed gains come from requesting a large block of noise all at once (e.g. 16x16x16 or 2048x2048).
These noise algorithms are provided:
thirdparty/FastNoiseSIMD.h
to disable or learn about patent issue.)Plus these features:
While FastNoiseSIMD does not require a processor that supports SIMD to run or build, it does require a modern compiler that supports SIMD instructions.
FastNosieSIMD has been tested on these compilers:
Mingw-64/gcc is not supported due to 1 2 3 4, etc. So cross compiling from Linux to Windows using this compiler is not an option. That's why this module has not been included in the main Godot repository.
However you should be able to build it without issue on your own system or you can use my prebuilt Godot binaries.
These SIMD instruction sets are supported.
FastNoiseSIMD will automatically use the highest SIMD level it detects at runtime, including no SIMD level. You can set it to a lower level.
This module requires PR #35144 for Godot 4, which has not yet been merged, or a backport to Godot 3.2 which hasn't been written yet.
Until those have been merged into the main repository, use these instructions:
or install the files manually:
godot/modules/opensimplex
, godot/thirdparty/misc/open-simplex-noise*
godot/modules/noise
: 3.2 modules, 4.0 modules
godot/thirdparty/noise
: 3.2 thirdparty, 4.0 thirdparty
cd ~/godot/modules
git clone https://github.com/tinmanjuggernaut/godot_fastnoise_simd.git
fastnoise_simd
: mv godot_fastnoise_simd fastnoise_simd
cd fastnoise_simd; git checkout 3.2
Noise
object, such as within a texture, you should see FastNoiseSIMD along with FastNoise and OpenSimplexNoise. You can also view the online help and search FastNoiseSIMD.Here you can see some benchmarks from FastNoiseSIMD compared to regular FastNoise and OpenSimplexNoise in Godot. These numbers are the time needed to generate a 2D image in ms. FastNoise Perlin Fractal is comparable to OpenSimplexNoise.
1k | 2k | 4k | |
---|---|---|---|
OpenSimplexNoise | 107 | 435 | 1730 |
FN Perlin Fractal | 104 | 400 | 1600 |
SIMD Perlin Fractal (singular) | 304 | 1210 | 4800 |
SIMD Perlin Fractal | 28 | 107 | 430 |
--- | --- | --- | --- |
FN Value | 74 | 294 | |
SIMD Value | 13 | 44 | |
--- | --- | --- | --- |
FN heavily tweaked Cellular | 2284 | ||
SIMD heavily tweaked Cellular | 229 |
This library provides singular lookup functions (e.g. get_noise_3d(x,y,z)), but they are 3x slower than regular FastNoise. Speed gains come from requesting large blocks at once, especially when Z is a multiple of 8.
Generating basic 2D textures with FastNoiseSIMD is 4-6x faster than FastNoise, and becomes even faster as the algorithms gets more complex, even into 3D. Generating large blocks of noise can be split up into multiple threads becoming another 3-7x faster or (up to 40x faster than FastNoise)! See pyFastNoiseSIMD for multithreaded benchmarks.
All new Intel 64-bit processors have SSE2 built in, so I can't turn it off for my system, but I have compared regular FastNoise with FastNoiseSIMD SSE2 and AVX2. I'd guess retrieving FastNoiseSIMD sets without using SIMD is on par with regular FastNoise. Or it may be better because the algorithm is working in one set, rather than being called for every individual pixel/voxel.
Here I generated a 1k image using the library author's demo app:
FN | SIMD SSE2 | SIMD AVX2 | |
---|---|---|---|
Value | 66 | 23 | 6 |
Perlin Fractal | 108 | 94 | 43 |
Cellular Noise Lookup to Simplex | 96 | 117 | 61 |
Cellular Distance2 Sub | 209 | 75 | 30 |