FastNoiseLite¶

Inherits: Noise < Resource < RefCounted < Object

Generates noise using the FastNoiseLite library.

Description¶

This class generates noise using the FastNoiseLite library, which is a collection of several noise algorithms including Cellular, Perlin, Value, and more.

Most generated noise values are in the range of [-1,1], however not always. Some of the cellular noise algorithms return results above 1.

Properties¶

CellularDistanceFunction	cellular_distance_function	`0`
float	cellular_jitter	`0.45`
CellularReturnType	cellular_return_type	`1`
float	domain_warp_amplitude	`30.0`
bool	domain_warp_enabled	`false`
float	domain_warp_fractal_gain	`0.5`
float	domain_warp_fractal_lacunarity	`6.0`
int	domain_warp_fractal_octaves	`5`
DomainWarpFractalType	domain_warp_fractal_type	`1`
float	domain_warp_frequency	`0.05`
DomainWarpType	domain_warp_type	`0`
float	fractal_gain	`0.5`
float	fractal_lacunarity	`2.0`
int	fractal_octaves	`5`
float	fractal_ping_pong_strength	`2.0`
FractalType	fractal_type	`1`
float	fractal_weighted_strength	`0.0`
float	frequency	`0.01`
NoiseType	noise_type	`1`
Vector3	offset	`Vector3(0, 0, 0)`
int	seed	`0`

Enumerations¶

enum NoiseType:

TYPE_VALUE = 5 --- A lattice of points are assigned random values then interpolated based on neighboring values.
TYPE_VALUE_CUBIC = 4 --- Similar to Value noise, but slower. Has more variance in peaks and valleys.

Cubic noise can be used to avoid certain artifacts when using value noise to create a bumpmap. In general, you should always use this mode if the value noise is being used for a heightmap or bumpmap.

TYPE_PERLIN = 3 --- A lattice of random gradients. Their dot products are interpolated to obtain values in between the lattices.
TYPE_CELLULAR = 2 --- Cellular includes both Worley noise and Voronoi diagrams which creates various regions of the same value.
TYPE_SIMPLEX = 0 --- As opposed to TYPE_PERLIN, gradients exist in a simplex lattice rather than a grid lattice, avoiding directional artifacts.
TYPE_SIMPLEX_SMOOTH = 1 --- Modified, higher quality version of TYPE_SIMPLEX, but slower.

enum FractalType:

FRACTAL_NONE = 0 --- No fractal noise.
FRACTAL_FBM = 1 --- Method using Fractional Brownian Motion to combine octaves into a fractal.
FRACTAL_RIDGED = 2 --- Method of combining octaves into a fractal resulting in a "ridged" look.
FRACTAL_PING_PONG = 3 --- Method of combining octaves into a fractal with a ping pong effect.

enum CellularDistanceFunction:

DISTANCE_EUCLIDEAN = 0 --- Euclidean distance to the nearest point.
DISTANCE_EUCLIDEAN_SQUARED = 1 --- Squared Euclidean distance to the nearest point.
DISTANCE_MANHATTAN = 2 --- Manhattan distance (taxicab metric) to the nearest point.
DISTANCE_HYBRID = 3 --- Blend of DISTANCE_EUCLIDEAN and DISTANCE_MANHATTAN to give curved cell boundaries

enum CellularReturnType:

RETURN_CELL_VALUE = 0 --- The cellular distance function will return the same value for all points within a cell.
RETURN_DISTANCE = 1 --- The cellular distance function will return a value determined by the distance to the nearest point.
RETURN_DISTANCE2 = 2 --- The cellular distance function returns the distance to the second-nearest point.
RETURN_DISTANCE2_ADD = 3 --- The distance to the nearest point is added to the distance to the second-nearest point.
RETURN_DISTANCE2_SUB = 4 --- The distance to the nearest point is subtracted from the distance to the second-nearest point.
RETURN_DISTANCE2_MUL = 5 --- The distance to the nearest point is multiplied with the distance to the second-nearest point.
RETURN_DISTANCE2_DIV = 6 --- The distance to the nearest point is divided by the distance to the second-nearest point.

enum DomainWarpType:

DOMAIN_WARP_SIMPLEX = 0 --- The domain is warped using the simplex noise algorithm.
DOMAIN_WARP_SIMPLEX_REDUCED = 1 --- The domain is warped using a simplified version of the simplex noise algorithm.
DOMAIN_WARP_BASIC_GRID = 2 --- The domain is warped using a simple noise grid (not as smooth as the other methods, but more performant).

enum DomainWarpFractalType:

DOMAIN_WARP_FRACTAL_NONE = 0 --- No fractal noise for warping the space.
DOMAIN_WARP_FRACTAL_PROGRESSIVE = 1 --- Warping the space progressively, octave for octave, resulting in a more "liquified" distortion.
DOMAIN_WARP_FRACTAL_INDEPENDENT = 2 --- Warping the space independently for each octave, resulting in a more chaotic distortion.

Property Descriptions¶

CellularDistanceFunction cellular_distance_function

Default	`0`
Setter	set_cellular_distance_function(value)
Getter	get_cellular_distance_function()

Determines how the distance to the nearest/second-nearest point is computed. See CellularDistanceFunction for options.

float cellular_jitter

Default	`0.45`
Setter	set_cellular_jitter(value)
Getter	get_cellular_jitter()

Maximum distance a point can move off of its grid position. Set to 0 for an even grid.

CellularReturnType cellular_return_type

Default	`1`
Setter	set_cellular_return_type(value)
Getter	get_cellular_return_type()

Return type from cellular noise calculations. See CellularReturnType.

float domain_warp_amplitude

Default	`30.0`
Setter	set_domain_warp_amplitude(value)
Getter	get_domain_warp_amplitude()

Sets the maximum warp distance from the origin.

bool domain_warp_enabled

Default	`false`
Setter	set_domain_warp_enabled(value)
Getter	is_domain_warp_enabled()

If enabled, another FastNoiseLite instance is used to warp the space, resulting in a distortion of the noise.

float domain_warp_fractal_gain

Default	`0.5`
Setter	set_domain_warp_fractal_gain(value)
Getter	get_domain_warp_fractal_gain()

Determines the strength of each subsequent layer of the noise which is used to warp the space.

A low value places more emphasis on the lower frequency base layers, while a high value puts more emphasis on the higher frequency layers.

float domain_warp_fractal_lacunarity

Default	`6.0`
Setter	set_domain_warp_fractal_lacunarity(value)
Getter	get_domain_warp_fractal_lacunarity()

Octave lacunarity of the fractal noise which warps the space. Increasing this value results in higher octaves producing noise with finer details and a rougher appearance.

int domain_warp_fractal_octaves

Default	`5`
Setter	set_domain_warp_fractal_octaves(value)
Getter	get_domain_warp_fractal_octaves()

The number of noise layers that are sampled to get the final value for the fractal noise which warps the space.

DomainWarpFractalType domain_warp_fractal_type

Default	`1`
Setter	set_domain_warp_fractal_type(value)
Getter	get_domain_warp_fractal_type()

The method for combining octaves into a fractal which is used to warp the space. See DomainWarpFractalType.

float domain_warp_frequency

Default	`0.05`
Setter	set_domain_warp_frequency(value)
Getter	get_domain_warp_frequency()

Frequency of the noise which warps the space. Low frequency results in smooth noise while high frequency results in rougher, more granular noise.

DomainWarpType domain_warp_type

Default	`0`
Setter	set_domain_warp_type(value)
Getter	get_domain_warp_type()

Sets the warp algorithm. See DomainWarpType.

float fractal_gain

Default	`0.5`
Setter	set_fractal_gain(value)
Getter	get_fractal_gain()

Determines the strength of each subsequent layer of noise in fractal noise.

A low value places more emphasis on the lower frequency base layers, while a high value puts more emphasis on the higher frequency layers.

float fractal_lacunarity

Default	`2.0`
Setter	set_fractal_lacunarity(value)
Getter	get_fractal_lacunarity()

Frequency multiplier between subsequent octaves. Increasing this value results in higher octaves producing noise with finer details and a rougher appearance.

int fractal_octaves

Default	`5`
Setter	set_fractal_octaves(value)
Getter	get_fractal_octaves()

The number of noise layers that are sampled to get the final value for fractal noise types.

float fractal_ping_pong_strength

Default	`2.0`
Setter	set_fractal_ping_pong_strength(value)
Getter	get_fractal_ping_pong_strength()

Sets the strength of the fractal ping pong type.

FractalType fractal_type

Default	`1`
Setter	set_fractal_type(value)
Getter	get_fractal_type()

The method for combining octaves into a fractal. See FractalType.

float fractal_weighted_strength

Default	`0.0`
Setter	set_fractal_weighted_strength(value)
Getter	get_fractal_weighted_strength()

Higher weighting means higher octaves have less impact if lower octaves have a large impact.

float frequency

Default	`0.01`
Setter	set_frequency(value)
Getter	get_frequency()

The frequency for all noise types. Low frequency results in smooth noise while high frequency results in rougher, more granular noise.

NoiseType noise_type

Default	`1`
Setter	set_noise_type(value)
Getter	get_noise_type()

The noise algorithm used. See NoiseType.

Vector3 offset

Default	`Vector3(0, 0, 0)`
Setter	set_offset(value)
Getter	get_offset()

Translate the noise input coordinates by the given Vector3.

int seed

Default	`0`
Setter	set_seed(value)
Getter	get_seed()

The random number seed for all noise types.