FastNoiseLite
Hereda: Noise < Resource < RefCounted < Object
Genera ruido utilizando la librería FastNoiseLite.
Descripción
Esta clase genera ruido utilizando la librería FastNoiseLite, que es una colección de varios algoritmos de ruido incluyendo Celular, Perlin, Valor y más.
La mayoría de los valores de ruido generados están en el rango de [-1, 1], pero no siempre. Algunos de los algoritmos de ruido celular devuelven resultados por encima de 1.
Propiedades
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
Enumeraciones
enum NoiseType: 🔗
NoiseType TYPE_VALUE = 5
A una red de puntos se les asignan valores aleatorios y luego se interpolan en función de los valores vecinos.
NoiseType TYPE_VALUE_CUBIC = 4
Similar al ruido de valor (TYPE_VALUE), pero más lento. Tiene más varianza en los picos y valles.
El ruido cúbico se puede usar para evitar ciertos artefactos al usar el ruido de valor para crear un mapa de relieve. En general, siempre debes usar este modo si el ruido de valor se está utilizando para un mapa de altura o un mapa de relieve.
NoiseType TYPE_PERLIN = 3
Una red de gradientes aleatorios. Sus productos escalares se interpolan para obtener valores entre las redes.
NoiseType TYPE_CELLULAR = 2
Celular incluye tanto ruido de Worley como diagramas de Voronoi que crean varias regiones del mismo valor.
NoiseType TYPE_SIMPLEX = 0
A diferencia de TYPE_PERLIN, los gradientes existen en una red símplex en lugar de una red de cuadrícula, lo que evita artefactos direccionales. Internamente, utiliza el tipo de ruido OpenSimplex2 de FastNoiseLite.
NoiseType TYPE_SIMPLEX_SMOOTH = 1
Versión modificada de mayor calidad de TYPE_SIMPLEX, pero más lenta. Internamente utiliza el tipo de ruido OpenSimplex2S de FastNoiseLite.
enum FractalType: 🔗
FractalType FRACTAL_NONE = 0
Sin ruido fractal.
FractalType FRACTAL_FBM = 1
Método que utiliza el movimiento browniano fraccional para combinar octavas en un fractal.
FractalType FRACTAL_RIDGED = 2
Método de combinación de octavas en un fractal que da como resultado un aspecto "estriado".
FractalType FRACTAL_PING_PONG = 3
Método de combinación de octavas en un fractal con un efecto de ping pong.
enum CellularDistanceFunction: 🔗
CellularDistanceFunction DISTANCE_EUCLIDEAN = 0
Distancia euclidiana al punto más cercano.
CellularDistanceFunction DISTANCE_EUCLIDEAN_SQUARED = 1
Distancia euclidiana al cuadrado al punto más cercano.
CellularDistanceFunction DISTANCE_MANHATTAN = 2
Distancia de Manhattan (métrica de taxi) al punto más cercano.
CellularDistanceFunction DISTANCE_HYBRID = 3
Mezcla de DISTANCE_EUCLIDEAN y DISTANCE_MANHATTAN para dar límites de celda curvados.
enum CellularReturnType: 🔗
CellularReturnType RETURN_CELL_VALUE = 0
La función de distancia celular devolverá el mismo valor para todos los puntos dentro de una celda.
CellularReturnType RETURN_DISTANCE = 1
La función de distancia celular devolverá un valor determinado por la distancia al punto más cercano.
CellularReturnType RETURN_DISTANCE2 = 2
La función de distancia celular devuelve la distancia al segundo punto más cercano.
CellularReturnType RETURN_DISTANCE2_ADD = 3
La distancia al punto más cercano se suma a la distancia al segundo punto más cercano.
CellularReturnType RETURN_DISTANCE2_SUB = 4
La distancia al punto más cercano se resta de la distancia al segundo punto más cercano.
CellularReturnType RETURN_DISTANCE2_MUL = 5
La distancia al punto más cercano se multiplica por la distancia al segundo punto más cercano.
CellularReturnType RETURN_DISTANCE2_DIV = 6
La distancia al punto más cercano se divide por la distancia al segundo punto más cercano.
enum DomainWarpType: 🔗
DomainWarpType DOMAIN_WARP_SIMPLEX = 0
El dominio se distorsiona utilizando el algoritmo de ruido simplex.
DomainWarpType DOMAIN_WARP_SIMPLEX_REDUCED = 1
El dominio se distorsiona utilizando una versión simplificada del algoritmo de ruido simplex.
DomainWarpType DOMAIN_WARP_BASIC_GRID = 2
El dominio se distorsiona utilizando una simple rejilla de ruido (no tan suave como los otros métodos, pero más eficiente).
enum DomainWarpFractalType: 🔗
DomainWarpFractalType DOMAIN_WARP_FRACTAL_NONE = 0
Sin ruido fractal para distorsionar el espacio.
DomainWarpFractalType DOMAIN_WARP_FRACTAL_PROGRESSIVE = 1
Distorsionar el espacio progresivamente, octava por octava, resulta en una distorsión más "licuada".
DomainWarpFractalType DOMAIN_WARP_FRACTAL_INDEPENDENT = 2
Distorsionar el espacio independientemente para cada octava, resulta en una distorsión más caótica.
Descripciones de Propiedades
CellularDistanceFunction cellular_distance_function = 0 🔗
void set_cellular_distance_function(value: CellularDistanceFunction)
CellularDistanceFunction get_cellular_distance_function()
Determina cómo se calcula la distancia al punto más cercano/segundo más cercano.
Distancia máxima que un punto puede moverse fuera de su posición en la cuadrícula. Establecer en 0 para una cuadrícula uniforme.
CellularReturnType cellular_return_type = 1 🔗
void set_cellular_return_type(value: CellularReturnType)
CellularReturnType get_cellular_return_type()
Tipo de retorno de los cálculos de ruido celular.
float domain_warp_amplitude = 30.0 🔗
Establece la distancia máxima de deformación desde el origen.
bool domain_warp_enabled = false 🔗
Si está habilitado, se utiliza otra instancia de FastNoiseLite para deformar el espacio, lo que resulta en una distorsión del ruido.
float domain_warp_fractal_gain = 0.5 🔗
Determina la fuerza de cada capa subsiguiente del ruido que se utiliza para deformar el espacio.
Un valor bajo pone más énfasis en las capas base de baja frecuencia, mientras que un valor alto pone más énfasis en las capas de alta frecuencia.
float domain_warp_fractal_lacunarity = 6.0 🔗
El cambio en la frecuencia entre octavas, también conocido como "lacunaridad", del ruido fractal que deforma el espacio. Aumentar este valor resulta en octavas más altas, produciendo ruido con detalles más finos y una apariencia más áspera.
int domain_warp_fractal_octaves = 5 🔗
El número de capas de ruido que se muestrean para obtener el valor final para el ruido fractal que deforma el espacio.
DomainWarpFractalType domain_warp_fractal_type = 1 🔗
void set_domain_warp_fractal_type(value: DomainWarpFractalType)
DomainWarpFractalType get_domain_warp_fractal_type()
El método para combinar octavas en un fractal que se utiliza para deformar el espacio.
float domain_warp_frequency = 0.05 🔗
Frecuencia del ruido que deforma el espacio. La baja frecuencia resulta en un ruido suave, mientras que la alta frecuencia resulta en un ruido más áspero y granular.
DomainWarpType domain_warp_type = 0 🔗
void set_domain_warp_type(value: DomainWarpType)
DomainWarpType get_domain_warp_type()
El algoritmo de deformación.
Determina la fuerza de cada capa subsiguiente de ruido en el ruido fractal.
Un valor bajo da más importancia a las capas base de baja frecuencia, mientras que un valor alto da más importancia a las capas de alta frecuencia.
float fractal_lacunarity = 2.0 🔗
Multiplicador de frecuencia entre octavas subsiguientes. Aumentar este valor resulta en octavas más altas que producen ruido con detalles más finos y una apariencia más áspera.
El número de capas de ruido que se muestrean para obtener el valor final para los tipos de ruido fractal.
float fractal_ping_pong_strength = 2.0 🔗
Establece la fuerza del tipo fractal ping pong.
FractalType fractal_type = 1 🔗
void set_fractal_type(value: FractalType)
FractalType get_fractal_type()
El método para combinar octavas en un fractal.
float fractal_weighted_strength = 0.0 🔗
Una mayor ponderación significa que las octavas más altas tienen menos impacto si las octavas más bajas tienen un gran impacto.
La frecuencia para todos los tipos de ruido. Una frecuencia baja produce un ruido uniforme, mientras que una frecuencia alta produce un ruido más áspero y granular.
El algoritmo de ruido utilizado.
Vector3 offset = Vector3(0, 0, 0) 🔗
Traduce las coordenadas de entrada de ruido mediante el Vector3 dado.
La semilla numérica aleatoria para todos los tipos de ruido.