Attention: Here be dragons
This is the latest
(unstable) version of this documentation, which may document features
not available in or compatible with released stable versions of Godot.
Checking the stable version of the documentation...
FastNoiseLite
Hérite de : Noise < Resource < RefCounted < Object
Génère du bruit en utilisant la bibliothèque FastNoiseLite.
Description
Cette classe génère du bruit en utilisant la bibliothèque FastNoiseLite, qui est une collection de plusieurs algorithmes de bruit tels que Cellular, Perlin, Value et plus encore.
La plupart des valeurs de bruit généré sont dans l'intervalle [-1, 1], mais pas toujours. Certains algorithmes de bruit cellulaire renvoient des résultats au-dessus de 1.
Propriétés
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
Énumérations
enum NoiseType: 🔗
NoiseType TYPE_VALUE = 5
Des valeurs aléatoires sont attribuées à un maillage de points puis interpolées en fonction des valeurs voisines.
NoiseType TYPE_VALUE_CUBIC = 4
Similaire au bruit Value (TYPE_VALUE), mais plus lent. A plus de variance dans les crêtes et les vallées.
Le bruit cubique peut être utilisé pour éviter certains artéfacts lors de l'utilisation du bruit Value pour créer une bumpmap. En général, vous devriez toujours utiliser ce mode si le bruit Value est utilisé pour une heightmap ou une bumpmap.
NoiseType TYPE_PERLIN = 3
Un maillage de gradients aléatoires. Leurs produits scalaires sont interpolés pour obtenir des valeurs entre les points.
NoiseType TYPE_CELLULAR = 2
Cellular comprend à la fois le bruit de Worley et les diagrammes de Voronoi qui créent diverses régions de même valeur.
NoiseType TYPE_SIMPLEX = 0
Contrairement à TYPE_PERLIN, les gradients existent dans un maillage de simplexes plutôt qu'un maillage de grille, évitant les artéfacts directionnels. Utilise en interne le type de bruit OpenSimplex2 de FastNoiseLite.
NoiseType TYPE_SIMPLEX_SMOOTH = 1
Version modifiée et de qualité supérieure de TYPE_SIMPLEX, mais plus lente. Utilise en interne le type de bruit OpenSimplex2S de FastNoiseLite.
enum FractalType: 🔗
FractalType FRACTAL_NONE = 0
Pas de bruit fractal.
FractalType FRACTAL_FBM = 1
Méthode utilisant le Mouvement Brownien Fractionnel (FBW) pour combiner des octaves en une fractale.
FractalType FRACTAL_RIDGED = 2
Méthode de combinaison d'octaves en une fractale résultant en un look "strié".
FractalType FRACTAL_PING_PONG = 3
Méthode de combinaison des octaves en une fractale avec un effet ping pong.
enum CellularDistanceFunction: 🔗
CellularDistanceFunction DISTANCE_EUCLIDEAN = 0
Distance euclidienne jusqu'au point le plus proche.
CellularDistanceFunction DISTANCE_EUCLIDEAN_SQUARED = 1
Distance Euclidienne au carré jusqu'au point le plus proche.
CellularDistanceFunction DISTANCE_MANHATTAN = 2
Distance de Manhattan (métrique taxi-distance) jusqu'au point le plus proche.
CellularDistanceFunction DISTANCE_HYBRID = 3
Mélange de DISTANCE_EUCLIDEAN et DISTANCE_MANHATTAN pour obtenir des limites de cellule courbées.
enum CellularReturnType: 🔗
CellularReturnType RETURN_CELL_VALUE = 0
La fonction de distance cellulaire renverra la même valeur pour tous les points dans une cellule.
CellularReturnType RETURN_DISTANCE = 1
La fonction de distance cellulaire renverra une valeur déterminée par la distance jusqu'au point le plus proche.
CellularReturnType RETURN_DISTANCE2 = 2
La fonction de distance cellulaire renverra la distance jusqu'au second point le plus proche.
CellularReturnType RETURN_DISTANCE2_ADD = 3
La distance jusqu'au point le plus proche est additionnée à la distance jusqu'au second point le plus proche.
CellularReturnType RETURN_DISTANCE2_SUB = 4
La distance jusqu'au point le plus proche est soustraite à la distance jusqu'au second point le plus proche.
CellularReturnType RETURN_DISTANCE2_MUL = 5
La distance jusqu'au point le plus proche est multipliée avec la distance jusqu'au second point le plus proche.
CellularReturnType RETURN_DISTANCE2_DIV = 6
La distance jusqu'au point le plus proche est divisée par la distance jusqu'au second point le plus proche.
enum DomainWarpType: 🔗
DomainWarpType DOMAIN_WARP_SIMPLEX = 0
Le domaine est déformé en utilisant l'algorithme de bruit simplex.
DomainWarpType DOMAIN_WARP_SIMPLEX_REDUCED = 1
Le domaine est déformé en utilisant une version simplifiée de l'algorithme de bruit simplex.
DomainWarpType DOMAIN_WARP_BASIC_GRID = 2
Le domaine est déformé en utilisant une grille de bruit simple (pas aussi lisse que les autres méthodes, mais plus performant).
enum DomainWarpFractalType: 🔗
DomainWarpFractalType DOMAIN_WARP_FRACTAL_NONE = 0
Pas de bruit fractal pour déformer l'espace.
DomainWarpFractalType DOMAIN_WARP_FRACTAL_PROGRESSIVE = 1
Déformer l'espace progressivement, octave par octave, entraînant une distorsion plus «liquéfiée».
DomainWarpFractalType DOMAIN_WARP_FRACTAL_INDEPENDENT = 2
Déformer l'espace indépendamment pour chaque octave, ce qui entraîne une distorsion plus chaotique.
Descriptions des propriétés
CellularDistanceFunction cellular_distance_function = 0 🔗
void set_cellular_distance_function(value: CellularDistanceFunction)
CellularDistanceFunction get_cellular_distance_function()
Détermine comment la distance jusqu'au point le plus proche/le second plus proche est calculée.
Distance maximale à laquelle un point peut se déplacer hors de sa position sur la grille. Définir à 0 pour une grille uniforme.
CellularReturnType cellular_return_type = 1 🔗
void set_cellular_return_type(value: CellularReturnType)
CellularReturnType get_cellular_return_type()
Type de renvoi des calculs de bruit cellulaire.
float domain_warp_amplitude = 30.0 🔗
Définit la distance de distorsion maximale depuis l'origine.
bool domain_warp_enabled = false 🔗
Si activé, une autre instance FastNoiseLite est utilisée déforme l'espace, entraînant une distorsion du bruit.
float domain_warp_fractal_gain = 0.5 🔗
Détermine la force de chaque couche subséquente de bruit qui est utilisé pour déformer l'espace.
Une faible valeur met davantage l'accent sur les couches de base à basse fréquence, alors qu'une valeur élevée met davantage l'accent sur les couches de fréquences supérieures.
float domain_warp_fractal_lacunarity = 6.0 🔗
Le changement de fréquence entre les octaves, également connu sous le nom de « lacunarité », du bruit fractal qui déforme l'espace. Augmenter cette valeur résulte en eds octaves plus élevées, produisant du bruit avec des détails plus fins et une apparence plus rugueuse.
int domain_warp_fractal_octaves = 5 🔗
Le nombre de couches de bruit qui sont échantillonnées pour obtenir la valeur finale pour le bruit fractal qui déforme l'espace.
DomainWarpFractalType domain_warp_fractal_type = 1 🔗
void set_domain_warp_fractal_type(value: DomainWarpFractalType)
DomainWarpFractalType get_domain_warp_fractal_type()
La méthode pour combiner les octaves en une fractal qui est utilisée pour déformer l'espace.
float domain_warp_frequency = 0.05 🔗
Fréquence du bruit qui déforme l'espace. Une faible fréquence entraîne un bruit lisse tandis qu'une haute fréquence entraîne un bruit plus rugueux et plus granulaire.
DomainWarpType domain_warp_type = 0 🔗
void set_domain_warp_type(value: DomainWarpType)
DomainWarpType get_domain_warp_type()
L'algorithme de déformation.
Détermine la force de chaque couche subséquente de bruit dans le bruit fractal.
Une faible valeur met davantage l'accent sur les couches de base à basse fréquence, alors qu'une valeur élevée met davantage l'accent sur les couches de fréquences supérieures.
float fractal_lacunarity = 2.0 🔗
Multiplicateur de fréquence entre les octaves subséquentes. Augmenter cette valeur résulte en des octaves plus élevées produisant du bruit avec des détails plus fins et une apparence plus rugueuse.
Le nombre de couches de bruit qui sont échantillonnées pour obtenir la valeur finale des bruits type fractal.
float fractal_ping_pong_strength = 2.0 🔗
Définit la force du type ping pong de fractale.
FractalType fractal_type = 1 🔗
void set_fractal_type(value: FractalType)
FractalType get_fractal_type()
La méthode pour combiner les octaves en une fractale.
float fractal_weighted_strength = 0.0 🔗
Un poids plus élevé signifie que les octaves plus élevées ont moins d'impact si les octaves inférieures ont un impact important.
La fréquence pour tous les types de bruit. Une faible fréquence entraîne un bruit lisse tandis qu'une haute fréquence entraîne un bruit plus rugueux et plus granulaire.
L'algorithme de bruit utilisé.
Vector3 offset = Vector3(0, 0, 0) 🔗
Translate les coordonnées d'entrée du bruit par le Vector3 donné.
La graine de nombre aléatoire pour tous les types de bruit.