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
Eredita: Noise < Resource < RefCounted < Object
Genera noise tramite la libreria FastNoiseLite.
Descrizione
Questa classe genera un noise attraverso la libreria FastNoiseLite, che è una raccolta di diversi algoritmi di noise tra cui Cellular, Perlin, Value, e altri.
La maggior parte dei valori di noise generati rientra nell'intervallo [-1, 1], ma non sempre. Alcuni degli algoritmi di cellular noise restituiscono risultati superiori a 1.
Proprietà
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
Enumerazioni
enum NoiseType: 🔗
NoiseType TYPE_VALUE = 5
A un reticolo di punti sono assegnati valori casuali, quindi interpolati in base ai valori adiacenti.
NoiseType TYPE_VALUE_CUBIC = 4
Similar to value noise (TYPE_VALUE), 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
Un reticolo di gradienti casuali. I loro prodotti scalari sono interpolati per ottenere valori tra i reticoli.
NoiseType TYPE_CELLULAR = 2
Cellular include sia il Worley noise sia i diagrammi di Voronoi, che creano varie regioni con lo stesso valore.
NoiseType TYPE_SIMPLEX = 0
A differenza di TYPE_PERLIN, i gradienti esistono in un reticolo simplesso anziché in un reticolo a griglia, evitando artefatti direzionali. Utilizza internamente il tipo di rumore OpenSimplex2 di FastNoiseLite.
NoiseType TYPE_SIMPLEX_SMOOTH = 1
Versione modificata e di qualità superiore di TYPE_SIMPLEX, ma più lenta. Utilizza internamente il tipo di noise OpenSimplex2S di FastNoiseLite.
enum FractalType: 🔗
FractalType FRACTAL_NONE = 0
Nessun noise di frattale.
FractalType FRACTAL_FBM = 1
Metodo che utilizza il moto browniano frazionario per combinare le ottave in un frattale.
FractalType FRACTAL_RIDGED = 2
Metodo che combina le ottave in un frattale producendo un aspetto "increspato".
FractalType FRACTAL_PING_PONG = 3
Metodo che combina le ottave in un frattale con un effetto ping pong.
enum CellularDistanceFunction: 🔗
CellularDistanceFunction DISTANCE_EUCLIDEAN = 0
Distanza euclidea dal punto più vicino.
CellularDistanceFunction DISTANCE_EUCLIDEAN_SQUARED = 1
Distanza euclidea al quadrato dal punto più vicino.
CellularDistanceFunction DISTANCE_MANHATTAN = 2
Distanza di Manhattan (nel sistema metrico dei taxi) dal punto più vicino.
CellularDistanceFunction DISTANCE_HYBRID = 3
Fusione tra DISTANCE_EUCLIDEAN e DISTANCE_MANHATTAN per fornire bordi di celle curvi.
enum CellularReturnType: 🔗
CellularReturnType RETURN_CELL_VALUE = 0
La funzione di distanza cellulare restituirà lo stesso valore per tutti i punti all'interno di una cella.
CellularReturnType RETURN_DISTANCE = 1
La funzione di distanza cellulare restituirà un valore determinato dalla distanza dal punto più vicino.
CellularReturnType RETURN_DISTANCE2 = 2
La funzione di distanza cellulare restituisce la distanza dal secondo punto più vicino.
CellularReturnType RETURN_DISTANCE2_ADD = 3
La distanza dal punto più vicino è aggiunta alla distanza dal secondo punto più vicino.
CellularReturnType RETURN_DISTANCE2_SUB = 4
La distanza dal punto più vicino è sottratta dalla distanza dal secondo punto più vicino.
CellularReturnType RETURN_DISTANCE2_MUL = 5
La distanza dal punto più vicino è moltiplicata per la distanza dal secondo punto più vicino.
CellularReturnType RETURN_DISTANCE2_DIV = 6
La distanza dal punto più vicino è divisa per la distanza dal secondo punto più vicino.
enum DomainWarpType: 🔗
DomainWarpType DOMAIN_WARP_SIMPLEX = 0
Il dominio è deformato utilizzando l'algoritmo del noise simplesso.
DomainWarpType DOMAIN_WARP_SIMPLEX_REDUCED = 1
Il dominio è deformato utilizzando una versione semplificata dell'algoritmo del noise simplesso.
DomainWarpType DOMAIN_WARP_BASIC_GRID = 2
Il dominio è deformato attraverso una semplice griglia di noise (non così uniforme come gli altri metodi, ma più performante).
enum DomainWarpFractalType: 🔗
DomainWarpFractalType DOMAIN_WARP_FRACTAL_NONE = 0
Nessun noise di frattale per deformare lo spazio.
DomainWarpFractalType DOMAIN_WARP_FRACTAL_PROGRESSIVE = 1
Deforma lo spazio progressivamente, ottava per ottava, risultando in una distorsione più "liquefatta".
DomainWarpFractalType DOMAIN_WARP_FRACTAL_INDEPENDENT = 2
Deforma lo spazio indipendentemente per ogni ottava, risultando in una distorsione più caotica.
Descrizioni delle proprietà
CellularDistanceFunction cellular_distance_function = 0 🔗
void set_cellular_distance_function(value: CellularDistanceFunction)
CellularDistanceFunction get_cellular_distance_function()
Determina come viene calcolata la distanza dal punto più vicino, o secondo più vicino.
Distanza massima a cui un punto può spostarsi dalla sua posizione sulla griglia. Imposta su 0 per una griglia uniforme.
CellularReturnType cellular_return_type = 1 🔗
void set_cellular_return_type(value: CellularReturnType)
CellularReturnType get_cellular_return_type()
Tipo restituito dai calcoli di noise cellulare.
float domain_warp_amplitude = 30.0 🔗
Imposta la distanza massima di avvolgimento dall'origine.
bool domain_warp_enabled = false 🔗
Se abilitata, un'altra istanza di FastNoiseLite viene utilizzata per deformare lo spazio, provocando una distorsione del noise.
float domain_warp_fractal_gain = 0.5 🔗
Definisce l'intensità di ogni strato successivo del noise che è utilizzato per deformare lo spazio.
Un valore basso pone maggiore enfasi sugli strati base a frequenza più bassa, mentre un valore alto pone maggiore enfasi sugli strati a frequenza più alta.
float domain_warp_fractal_lacunarity = 6.0 🔗
Il cambiamento di frequenza tra le ottave, anche conosciuta come "lacunarità", del noise frattale che deforma lo spazio. Aumentando questo valore si ottengono ottave più alte, producendo noise con dettagli più fini e un aspetto più ruvido.
int domain_warp_fractal_octaves = 5 🔗
Il numero di strati campionati del noise per ottenere il valore finale del noise frattale che deforma lo spazio.
DomainWarpFractalType domain_warp_fractal_type = 1 🔗
void set_domain_warp_fractal_type(value: DomainWarpFractalType)
DomainWarpFractalType get_domain_warp_fractal_type()
Il metodo per combinare le ottave in un frattale che è utilizzato per deformare lo spazio.
float domain_warp_frequency = 0.05 🔗
Frequenza del noise che deforma lo spazio. Le basse frequenze producono un noise uniforme, mentre le alte frequenze producono un noise più ruvido e granulare.
DomainWarpType domain_warp_type = 0 🔗
void set_domain_warp_type(value: DomainWarpType)
DomainWarpType get_domain_warp_type()
L'algoritmo di avvolgimento.
Definisce l'intensità di ogni strato successivo di noise nel noise frattale.
Un valore basso pone maggiore enfasi sugli strati base a frequenza più bassa, mentre un valore alto pone maggiore enfasi sugli strati a frequenza più alta.
float fractal_lacunarity = 2.0 🔗
Moltiplicatore di frequenza tra le ottave successive. Aumentando questo valore si ottengono ottave più alte che producono noise con dettagli più fini e un aspetto più ruvido.
Il numero di strati di noise campionati per ottenere il valore finale per i tipi di noise frattali.
float fractal_ping_pong_strength = 2.0 🔗
Imposta l'intensità del tipo ping pong frattale.
FractalType fractal_type = 1 🔗
void set_fractal_type(value: FractalType)
FractalType get_fractal_type()
Il metodo per combinare ottave in un frattale.
float fractal_weighted_strength = 0.0 🔗
Un peso più elevato significa che le ottave più alte hanno un impatto minore se le ottave inferiori hanno un impatto elevato.
La frequenza per tutti i tipi di noise. Le frequenze basse producono un noise uniforme, mentre le frequenze alte producono un noise più ruvido e granulare.
L'algoritmo di noise utilizzato.
Vector3 offset = Vector3(0, 0, 0) 🔗
Traduce le coordinate di input del noise con il Vector3 fornito.
Il seed numerico casuale per tutti i tipi di noise.