Inheritance #

FastNoiseLite #

is_refcounted, is_instantiable, resource, core, not_builtin_classes

Generates noise using the FastNoiseLite library.

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.

Members #

var cellular_distance_function = DISTANCE_EUCLIDEAN#

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

var cellular_jitter: float = 1.0#

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

var cellular_return_type = RETURN_DISTANCE#

Return type from cellular noise calculations. See CellularReturnType.

var domain_warp_amplitude: float = 30.0#

Sets the maximum warp distance from the origin.

var domain_warp_enabled: bool = false#

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

var domain_warp_fractal_gain: float = 0.5#

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.

var domain_warp_fractal_lacunarity: float = 6.0#

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.

var domain_warp_fractal_octaves: int = 5#

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

var domain_warp_fractal_type = DOMAIN_WARP_FRACTAL_PROGRESSIVE#

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

var domain_warp_frequency: float = 0.05#

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

var domain_warp_type = DOMAIN_WARP_SIMPLEX#

Sets the warp algorithm. See DomainWarpType.

var fractal_gain: float = 0.5#

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.

var fractal_lacunarity: float = 2.0#

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

var fractal_octaves: int = 5#

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

var fractal_ping_pong_strength: float = 2.0#

Sets the strength of the fractal ping pong type.

var fractal_type = FRACTAL_FBM#

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

var fractal_weighted_strength: float = 0.0#

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

var frequency: float = 0.01#

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

var noise_type = TYPE_SIMPLEX_SMOOTH#

The noise algorithm used. See NoiseType.

var offset: Vector3 = Vector3(0, 0, 0)#

Translate the noise input coordinates by the given Vector3.

var seed: int = 0#

The random number seed for all noise types.

Methods #

Annotations #

Constants #

const TYPE_VALUE = 5 enum NoiseType#

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

const TYPE_VALUE_CUBIC = 4 enum NoiseType#

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.

const TYPE_PERLIN = 3 enum NoiseType#

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

const TYPE_CELLULAR = 2 enum NoiseType#

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

const TYPE_SIMPLEX = 0 enum NoiseType#

As opposed to TYPE_PERLIN, gradients exist in a simplex lattice rather than a grid lattice, avoiding directional artifacts. Internally uses FastNoiseLite's OpenSimplex2 noise type.

const TYPE_SIMPLEX_SMOOTH = 1 enum NoiseType#

Modified, higher quality version of TYPE_SIMPLEX, but slower. Internally uses FastNoiseLite's OpenSimplex2S noise type.

const FRACTAL_NONE = 0 enum FractalType#

No fractal noise.

const FRACTAL_FBM = 1 enum FractalType#

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

const FRACTAL_RIDGED = 2 enum FractalType#

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

const FRACTAL_PING_PONG = 3 enum FractalType#

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

const DISTANCE_EUCLIDEAN = 0 enum CellularDistanceFunction#

Euclidean distance to the nearest point.

const DISTANCE_EUCLIDEAN_SQUARED = 1 enum CellularDistanceFunction#

Squared Euclidean distance to the nearest point.

const DISTANCE_MANHATTAN = 2 enum CellularDistanceFunction#

Manhattan distance (taxicab metric) to the nearest point.

const DISTANCE_HYBRID = 3 enum CellularDistanceFunction#

Blend of DISTANCE_EUCLIDEAN and DISTANCE_MANHATTAN to give curved cell boundaries.

const RETURN_CELL_VALUE = 0 enum CellularReturnType#

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

const RETURN_DISTANCE = 1 enum CellularReturnType#

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

const RETURN_DISTANCE2 = 2 enum CellularReturnType#

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

const RETURN_DISTANCE2_ADD = 3 enum CellularReturnType#

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

const RETURN_DISTANCE2_SUB = 4 enum CellularReturnType#

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

const RETURN_DISTANCE2_MUL = 5 enum CellularReturnType#

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

const RETURN_DISTANCE2_DIV = 6 enum CellularReturnType#

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

const DOMAIN_WARP_SIMPLEX = 0 enum DomainWarpType#

The domain is warped using the simplex noise algorithm.

const DOMAIN_WARP_SIMPLEX_REDUCED = 1 enum DomainWarpType#

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

const DOMAIN_WARP_BASIC_GRID = 2 enum DomainWarpType#

The domain is warped using a simple noise grid (not as smooth as the other methods, but more performant).

const DOMAIN_WARP_FRACTAL_NONE = 0 enum DomainWarpFractalType#

No fractal noise for warping the space.

const DOMAIN_WARP_FRACTAL_PROGRESSIVE = 1 enum DomainWarpFractalType#

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

const DOMAIN_WARP_FRACTAL_INDEPENDENT = 2 enum DomainWarpFractalType#

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

Constructors #

Enums #

NoiseType#

FractalType#

CellularDistanceFunction#

CellularReturnType#

DomainWarpType#

DomainWarpFractalType#

Operators #

Signals #

Theme Items #

Tutorials #