Up to date

This page is up to date for Redot 4.3. If you still find outdated information, please create an issue.

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], but not always. Some of the cellular noise algorithms return results above 1.

Properties¶

CellularDistanceFunction	cellular_distance_function	`0`
float	cellular_jitter	`1.0`
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: 🔗

NoiseType TYPE_VALUE = 5

A lattice of points are assigned random values then interpolated based on neighboring values.

NoiseType 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.

NoiseType TYPE_PERLIN = 3

A lattice of random gradients. Their dot products are interpolated to obtain values in between the lattices.

NoiseType TYPE_CELLULAR = 2

Cellular includes both Worley noise and Voronoi diagrams which creates various regions of the same value.

NoiseType TYPE_SIMPLEX = 0

As opposed to TYPE_PERLIN, gradients exist in a simplex lattice rather than a grid lattice, avoiding directional artifacts.

NoiseType TYPE_SIMPLEX_SMOOTH = 1

Modified, higher quality version of TYPE_SIMPLEX, but slower.

enum FractalType: 🔗

FractalType FRACTAL_NONE = 0

No fractal noise.

FractalType FRACTAL_FBM = 1

Method using Fractional Brownian Motion to combine octaves into a fractal.

FractalType FRACTAL_RIDGED = 2

Method of combining octaves into a fractal resulting in a "ridged" look.

FractalType FRACTAL_PING_PONG = 3

Method of combining octaves into a fractal with a ping pong effect.

enum CellularDistanceFunction: 🔗

CellularDistanceFunction DISTANCE_EUCLIDEAN = 0

Euclidean distance to the nearest point.

CellularDistanceFunction DISTANCE_EUCLIDEAN_SQUARED = 1

Squared Euclidean distance to the nearest point.

CellularDistanceFunction DISTANCE_MANHATTAN = 2

Manhattan distance (taxicab metric) to the nearest point.

CellularDistanceFunction DISTANCE_HYBRID = 3

Blend of DISTANCE_EUCLIDEAN and DISTANCE_MANHATTAN to give curved cell boundaries

enum CellularReturnType: 🔗

CellularReturnType RETURN_CELL_VALUE = 0

The cellular distance function will return the same value for all points within a cell.

CellularReturnType RETURN_DISTANCE = 1

The cellular distance function will return a value determined by the distance to the nearest point.

CellularReturnType RETURN_DISTANCE2 = 2

The cellular distance function returns the distance to the second-nearest point.

CellularReturnType RETURN_DISTANCE2_ADD = 3

The distance to the nearest point is added to the distance to the second-nearest point.

CellularReturnType RETURN_DISTANCE2_SUB = 4

The distance to the nearest point is subtracted from the distance to the second-nearest point.

CellularReturnType RETURN_DISTANCE2_MUL = 5

The distance to the nearest point is multiplied with the distance to the second-nearest point.

CellularReturnType RETURN_DISTANCE2_DIV = 6

The distance to the nearest point is divided by the distance to the second-nearest point.

enum DomainWarpType: 🔗

DomainWarpType DOMAIN_WARP_SIMPLEX = 0

The domain is warped using the simplex noise algorithm.

DomainWarpType DOMAIN_WARP_SIMPLEX_REDUCED = 1

The domain is warped using a simplified version of the simplex noise algorithm.

DomainWarpType 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: 🔗

DomainWarpFractalType DOMAIN_WARP_FRACTAL_NONE = 0

No fractal noise for warping the space.

DomainWarpFractalType DOMAIN_WARP_FRACTAL_PROGRESSIVE = 1

Warping the space progressively, octave for octave, resulting in a more "liquified" distortion.

DomainWarpFractalType DOMAIN_WARP_FRACTAL_INDEPENDENT = 2

Warping the space independently for each octave, resulting in a more chaotic distortion.

Property Descriptions¶

CellularDistanceFunction cellular_distance_function = 0 🔗

void set_cellular_distance_function(value: CellularDistanceFunction)
CellularDistanceFunction get_cellular_distance_function()

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

float cellular_jitter = 1.0 🔗

void set_cellular_jitter(value: float)
float 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 = 1 🔗

void set_cellular_return_type(value: CellularReturnType)
CellularReturnType get_cellular_return_type()

Return type from cellular noise calculations. See CellularReturnType.

float domain_warp_amplitude = 30.0 🔗

void set_domain_warp_amplitude(value: float)
float get_domain_warp_amplitude()

Sets the maximum warp distance from the origin.

bool domain_warp_enabled = false 🔗

void set_domain_warp_enabled(value: bool)
bool 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 = 0.5 🔗

void set_domain_warp_fractal_gain(value: float)
float 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 = 6.0 🔗

void set_domain_warp_fractal_lacunarity(value: float)
float 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 = 5 🔗

void set_domain_warp_fractal_octaves(value: int)
int 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 = 1 🔗

void set_domain_warp_fractal_type(value: DomainWarpFractalType)
DomainWarpFractalType 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 = 0.05 🔗

void set_domain_warp_frequency(value: float)
float 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 = 0 🔗

void set_domain_warp_type(value: DomainWarpType)
DomainWarpType get_domain_warp_type()

Sets the warp algorithm. See DomainWarpType.

float fractal_gain = 0.5 🔗

void set_fractal_gain(value: float)
float 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 = 2.0 🔗

void set_fractal_lacunarity(value: float)
float 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 = 5 🔗

void set_fractal_octaves(value: int)
int 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 = 2.0 🔗

void set_fractal_ping_pong_strength(value: float)
float get_fractal_ping_pong_strength()

Sets the strength of the fractal ping pong type.

FractalType fractal_type = 1 🔗

void set_fractal_type(value: FractalType)
FractalType get_fractal_type()

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

float fractal_weighted_strength = 0.0 🔗

void set_fractal_weighted_strength(value: float)
float get_fractal_weighted_strength()

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

float frequency = 0.01 🔗

void set_frequency(value: float)
float 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 = 1 🔗

void set_noise_type(value: NoiseType)
NoiseType get_noise_type()

The noise algorithm used. See NoiseType.

Vector3 offset = Vector3(0, 0, 0) 🔗

void set_offset(value: Vector3)
Vector3 get_offset()

Translate the noise input coordinates by the given Vector3.

int seed = 0 🔗

void set_seed(value: int)
int get_seed()

The random number seed for all noise types.