godotengine/godot-docs-l10n
1
0
Fork 0
mirror of https://github.com/godotengine/godot-docs-l10n.git synced 2025-12-31 09:49:22 +03:00
Code Issues Packages Projects Releases Wiki Activity
Files
4.x
godot-docs-l10n/classes/fr/class_fastnoiselite.rst

731 lines
32 KiB
ReStructuredText
Raw Permalink Blame History

This file contains invisible Unicode characters

This file contains invisible Unicode characters that are indistinguishable to humans but may be processed differently by a computer. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

:github_url: hide
.. _class_FastNoiseLite:
FastNoiseLite
=============
**Hérite de :** :ref:`Noise<class_Noise>` **<** :ref:`Resource<class_Resource>` **<** :ref:`RefCounted<class_RefCounted>` **<** :ref:`Object<class_Object>`
Génère du bruit en utilisant la bibliothèque FastNoiseLite.
.. rst-class:: classref-introduction-group
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``.
.. rst-class:: classref-reftable-group
Propriétés
--------------------
.. table::
:widths: auto
+------------------------------------------------------------------------------+----------------------------------------------------------------------------------------------------+----------------------+
| :ref:`CellularDistanceFunction<enum_FastNoiseLite_CellularDistanceFunction>` | :ref:`cellular_distance_function<class_FastNoiseLite_property_cellular_distance_function>` | ``0`` |
+------------------------------------------------------------------------------+----------------------------------------------------------------------------------------------------+----------------------+
| :ref:`float<class_float>` | :ref:`cellular_jitter<class_FastNoiseLite_property_cellular_jitter>` | ``1.0`` |
+------------------------------------------------------------------------------+----------------------------------------------------------------------------------------------------+----------------------+
| :ref:`CellularReturnType<enum_FastNoiseLite_CellularReturnType>` | :ref:`cellular_return_type<class_FastNoiseLite_property_cellular_return_type>` | ``1`` |
+------------------------------------------------------------------------------+----------------------------------------------------------------------------------------------------+----------------------+
| :ref:`float<class_float>` | :ref:`domain_warp_amplitude<class_FastNoiseLite_property_domain_warp_amplitude>` | ``30.0`` |
+------------------------------------------------------------------------------+----------------------------------------------------------------------------------------------------+----------------------+
| :ref:`bool<class_bool>` | :ref:`domain_warp_enabled<class_FastNoiseLite_property_domain_warp_enabled>` | ``false`` |
+------------------------------------------------------------------------------+----------------------------------------------------------------------------------------------------+----------------------+
| :ref:`float<class_float>` | :ref:`domain_warp_fractal_gain<class_FastNoiseLite_property_domain_warp_fractal_gain>` | ``0.5`` |
+------------------------------------------------------------------------------+----------------------------------------------------------------------------------------------------+----------------------+
| :ref:`float<class_float>` | :ref:`domain_warp_fractal_lacunarity<class_FastNoiseLite_property_domain_warp_fractal_lacunarity>` | ``6.0`` |
+------------------------------------------------------------------------------+----------------------------------------------------------------------------------------------------+----------------------+
| :ref:`int<class_int>` | :ref:`domain_warp_fractal_octaves<class_FastNoiseLite_property_domain_warp_fractal_octaves>` | ``5`` |
+------------------------------------------------------------------------------+----------------------------------------------------------------------------------------------------+----------------------+
| :ref:`DomainWarpFractalType<enum_FastNoiseLite_DomainWarpFractalType>` | :ref:`domain_warp_fractal_type<class_FastNoiseLite_property_domain_warp_fractal_type>` | ``1`` |
+------------------------------------------------------------------------------+----------------------------------------------------------------------------------------------------+----------------------+
| :ref:`float<class_float>` | :ref:`domain_warp_frequency<class_FastNoiseLite_property_domain_warp_frequency>` | ``0.05`` |
+------------------------------------------------------------------------------+----------------------------------------------------------------------------------------------------+----------------------+
| :ref:`DomainWarpType<enum_FastNoiseLite_DomainWarpType>` | :ref:`domain_warp_type<class_FastNoiseLite_property_domain_warp_type>` | ``0`` |
+------------------------------------------------------------------------------+----------------------------------------------------------------------------------------------------+----------------------+
| :ref:`float<class_float>` | :ref:`fractal_gain<class_FastNoiseLite_property_fractal_gain>` | ``0.5`` |
+------------------------------------------------------------------------------+----------------------------------------------------------------------------------------------------+----------------------+
| :ref:`float<class_float>` | :ref:`fractal_lacunarity<class_FastNoiseLite_property_fractal_lacunarity>` | ``2.0`` |
+------------------------------------------------------------------------------+----------------------------------------------------------------------------------------------------+----------------------+
| :ref:`int<class_int>` | :ref:`fractal_octaves<class_FastNoiseLite_property_fractal_octaves>` | ``5`` |
+------------------------------------------------------------------------------+----------------------------------------------------------------------------------------------------+----------------------+
| :ref:`float<class_float>` | :ref:`fractal_ping_pong_strength<class_FastNoiseLite_property_fractal_ping_pong_strength>` | ``2.0`` |
+------------------------------------------------------------------------------+----------------------------------------------------------------------------------------------------+----------------------+
| :ref:`FractalType<enum_FastNoiseLite_FractalType>` | :ref:`fractal_type<class_FastNoiseLite_property_fractal_type>` | ``1`` |
+------------------------------------------------------------------------------+----------------------------------------------------------------------------------------------------+----------------------+
| :ref:`float<class_float>` | :ref:`fractal_weighted_strength<class_FastNoiseLite_property_fractal_weighted_strength>` | ``0.0`` |
+------------------------------------------------------------------------------+----------------------------------------------------------------------------------------------------+----------------------+
| :ref:`float<class_float>` | :ref:`frequency<class_FastNoiseLite_property_frequency>` | ``0.01`` |
+------------------------------------------------------------------------------+----------------------------------------------------------------------------------------------------+----------------------+
| :ref:`NoiseType<enum_FastNoiseLite_NoiseType>` | :ref:`noise_type<class_FastNoiseLite_property_noise_type>` | ``1`` |
+------------------------------------------------------------------------------+----------------------------------------------------------------------------------------------------+----------------------+
| :ref:`Vector3<class_Vector3>` | :ref:`offset<class_FastNoiseLite_property_offset>` | ``Vector3(0, 0, 0)`` |
+------------------------------------------------------------------------------+----------------------------------------------------------------------------------------------------+----------------------+
| :ref:`int<class_int>` | :ref:`seed<class_FastNoiseLite_property_seed>` | ``0`` |
+------------------------------------------------------------------------------+----------------------------------------------------------------------------------------------------+----------------------+
.. rst-class:: classref-section-separator
----
.. rst-class:: classref-descriptions-group
Énumérations
------------------------
.. _enum_FastNoiseLite_NoiseType:
.. rst-class:: classref-enumeration
enum **NoiseType**: :ref:`🔗<enum_FastNoiseLite_NoiseType>`
.. _class_FastNoiseLite_constant_TYPE_VALUE:
.. rst-class:: classref-enumeration-constant
:ref:`NoiseType<enum_FastNoiseLite_NoiseType>` **TYPE_VALUE** = ``5``
Des valeurs aléatoires sont attribuées à un maillage de points puis interpolées en fonction des valeurs voisines.
.. _class_FastNoiseLite_constant_TYPE_VALUE_CUBIC:
.. rst-class:: classref-enumeration-constant
:ref:`NoiseType<enum_FastNoiseLite_NoiseType>` **TYPE_VALUE_CUBIC** = ``4``
Similaire au bruit Value (:ref:`TYPE_VALUE<class_FastNoiseLite_constant_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.
.. _class_FastNoiseLite_constant_TYPE_PERLIN:
.. rst-class:: classref-enumeration-constant
:ref:`NoiseType<enum_FastNoiseLite_NoiseType>` **TYPE_PERLIN** = ``3``
Un maillage de gradients aléatoires. Leurs produits scalaires sont interpolés pour obtenir des valeurs entre les points.
.. _class_FastNoiseLite_constant_TYPE_CELLULAR:
.. rst-class:: classref-enumeration-constant
:ref:`NoiseType<enum_FastNoiseLite_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.
.. _class_FastNoiseLite_constant_TYPE_SIMPLEX:
.. rst-class:: classref-enumeration-constant
:ref:`NoiseType<enum_FastNoiseLite_NoiseType>` **TYPE_SIMPLEX** = ``0``
Contrairement à :ref:`TYPE_PERLIN<class_FastNoiseLite_constant_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.
.. _class_FastNoiseLite_constant_TYPE_SIMPLEX_SMOOTH:
.. rst-class:: classref-enumeration-constant
:ref:`NoiseType<enum_FastNoiseLite_NoiseType>` **TYPE_SIMPLEX_SMOOTH** = ``1``
Version modifiée et de qualité supérieure de :ref:`TYPE_SIMPLEX<class_FastNoiseLite_constant_TYPE_SIMPLEX>`, mais plus lente. Utilise en interne le type de bruit OpenSimplex2S de FastNoiseLite.
.. rst-class:: classref-item-separator
----
.. _enum_FastNoiseLite_FractalType:
.. rst-class:: classref-enumeration
enum **FractalType**: :ref:`🔗<enum_FastNoiseLite_FractalType>`
.. _class_FastNoiseLite_constant_FRACTAL_NONE:
.. rst-class:: classref-enumeration-constant
:ref:`FractalType<enum_FastNoiseLite_FractalType>` **FRACTAL_NONE** = ``0``
Pas de bruit fractal.
.. _class_FastNoiseLite_constant_FRACTAL_FBM:
.. rst-class:: classref-enumeration-constant
:ref:`FractalType<enum_FastNoiseLite_FractalType>` **FRACTAL_FBM** = ``1``
Méthode utilisant le Mouvement Brownien Fractionnel (FBW) pour combiner des octaves en une fractale.
.. _class_FastNoiseLite_constant_FRACTAL_RIDGED:
.. rst-class:: classref-enumeration-constant
:ref:`FractalType<enum_FastNoiseLite_FractalType>` **FRACTAL_RIDGED** = ``2``
Méthode de combinaison d'octaves en une fractale résultant en un look "strié".
.. _class_FastNoiseLite_constant_FRACTAL_PING_PONG:
.. rst-class:: classref-enumeration-constant
:ref:`FractalType<enum_FastNoiseLite_FractalType>` **FRACTAL_PING_PONG** = ``3``
Méthode de combinaison des octaves en une fractale avec un effet ping pong.
.. rst-class:: classref-item-separator
----
.. _enum_FastNoiseLite_CellularDistanceFunction:
.. rst-class:: classref-enumeration
enum **CellularDistanceFunction**: :ref:`🔗<enum_FastNoiseLite_CellularDistanceFunction>`
.. _class_FastNoiseLite_constant_DISTANCE_EUCLIDEAN:
.. rst-class:: classref-enumeration-constant
:ref:`CellularDistanceFunction<enum_FastNoiseLite_CellularDistanceFunction>` **DISTANCE_EUCLIDEAN** = ``0``
Distance euclidienne jusqu'au point le plus proche.
.. _class_FastNoiseLite_constant_DISTANCE_EUCLIDEAN_SQUARED:
.. rst-class:: classref-enumeration-constant
:ref:`CellularDistanceFunction<enum_FastNoiseLite_CellularDistanceFunction>` **DISTANCE_EUCLIDEAN_SQUARED** = ``1``
Distance Euclidienne au carré jusqu'au point le plus proche.
.. _class_FastNoiseLite_constant_DISTANCE_MANHATTAN:
.. rst-class:: classref-enumeration-constant
:ref:`CellularDistanceFunction<enum_FastNoiseLite_CellularDistanceFunction>` **DISTANCE_MANHATTAN** = ``2``
Distance de Manhattan (métrique taxi-distance) jusqu'au point le plus proche.
.. _class_FastNoiseLite_constant_DISTANCE_HYBRID:
.. rst-class:: classref-enumeration-constant
:ref:`CellularDistanceFunction<enum_FastNoiseLite_CellularDistanceFunction>` **DISTANCE_HYBRID** = ``3``
Mélange de :ref:`DISTANCE_EUCLIDEAN<class_FastNoiseLite_constant_DISTANCE_EUCLIDEAN>` et :ref:`DISTANCE_MANHATTAN<class_FastNoiseLite_constant_DISTANCE_MANHATTAN>` pour obtenir des limites de cellule courbées.
.. rst-class:: classref-item-separator
----
.. _enum_FastNoiseLite_CellularReturnType:
.. rst-class:: classref-enumeration
enum **CellularReturnType**: :ref:`🔗<enum_FastNoiseLite_CellularReturnType>`
.. _class_FastNoiseLite_constant_RETURN_CELL_VALUE:
.. rst-class:: classref-enumeration-constant
:ref:`CellularReturnType<enum_FastNoiseLite_CellularReturnType>` **RETURN_CELL_VALUE** = ``0``
La fonction de distance cellulaire renverra la même valeur pour tous les points dans une cellule.
.. _class_FastNoiseLite_constant_RETURN_DISTANCE:
.. rst-class:: classref-enumeration-constant
:ref:`CellularReturnType<enum_FastNoiseLite_CellularReturnType>` **RETURN_DISTANCE** = ``1``
La fonction de distance cellulaire renverra une valeur déterminée par la distance jusqu'au point le plus proche.
.. _class_FastNoiseLite_constant_RETURN_DISTANCE2:
.. rst-class:: classref-enumeration-constant
:ref:`CellularReturnType<enum_FastNoiseLite_CellularReturnType>` **RETURN_DISTANCE2** = ``2``
La fonction de distance cellulaire renverra la distance jusqu'au second point le plus proche.
.. _class_FastNoiseLite_constant_RETURN_DISTANCE2_ADD:
.. rst-class:: classref-enumeration-constant
:ref:`CellularReturnType<enum_FastNoiseLite_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.
.. _class_FastNoiseLite_constant_RETURN_DISTANCE2_SUB:
.. rst-class:: classref-enumeration-constant
:ref:`CellularReturnType<enum_FastNoiseLite_CellularReturnType>` **RETURN_DISTANCE2_SUB** = ``4``
La distance jusqu'au point le plus proche est soustraite à la distance jusqu'au second point le plus proche.
.. _class_FastNoiseLite_constant_RETURN_DISTANCE2_MUL:
.. rst-class:: classref-enumeration-constant
:ref:`CellularReturnType<enum_FastNoiseLite_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.
.. _class_FastNoiseLite_constant_RETURN_DISTANCE2_DIV:
.. rst-class:: classref-enumeration-constant
:ref:`CellularReturnType<enum_FastNoiseLite_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.
.. rst-class:: classref-item-separator
----
.. _enum_FastNoiseLite_DomainWarpType:
.. rst-class:: classref-enumeration
enum **DomainWarpType**: :ref:`🔗<enum_FastNoiseLite_DomainWarpType>`
.. _class_FastNoiseLite_constant_DOMAIN_WARP_SIMPLEX:
.. rst-class:: classref-enumeration-constant
:ref:`DomainWarpType<enum_FastNoiseLite_DomainWarpType>` **DOMAIN_WARP_SIMPLEX** = ``0``
Le domaine est déformé en utilisant l'algorithme de bruit simplex.
.. _class_FastNoiseLite_constant_DOMAIN_WARP_SIMPLEX_REDUCED:
.. rst-class:: classref-enumeration-constant
:ref:`DomainWarpType<enum_FastNoiseLite_DomainWarpType>` **DOMAIN_WARP_SIMPLEX_REDUCED** = ``1``
Le domaine est déformé en utilisant une version simplifiée de l'algorithme de bruit simplex.
.. _class_FastNoiseLite_constant_DOMAIN_WARP_BASIC_GRID:
.. rst-class:: classref-enumeration-constant
:ref:`DomainWarpType<enum_FastNoiseLite_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).
.. rst-class:: classref-item-separator
----
.. _enum_FastNoiseLite_DomainWarpFractalType:
.. rst-class:: classref-enumeration
enum **DomainWarpFractalType**: :ref:`🔗<enum_FastNoiseLite_DomainWarpFractalType>`
.. _class_FastNoiseLite_constant_DOMAIN_WARP_FRACTAL_NONE:
.. rst-class:: classref-enumeration-constant
:ref:`DomainWarpFractalType<enum_FastNoiseLite_DomainWarpFractalType>` **DOMAIN_WARP_FRACTAL_NONE** = ``0``
Pas de bruit fractal pour déformer l'espace.
.. _class_FastNoiseLite_constant_DOMAIN_WARP_FRACTAL_PROGRESSIVE:
.. rst-class:: classref-enumeration-constant
:ref:`DomainWarpFractalType<enum_FastNoiseLite_DomainWarpFractalType>` **DOMAIN_WARP_FRACTAL_PROGRESSIVE** = ``1``
Déformer l'espace progressivement, octave par octave, entraînant une distorsion plus «liquéfiée».
.. _class_FastNoiseLite_constant_DOMAIN_WARP_FRACTAL_INDEPENDENT:
.. rst-class:: classref-enumeration-constant
:ref:`DomainWarpFractalType<enum_FastNoiseLite_DomainWarpFractalType>` **DOMAIN_WARP_FRACTAL_INDEPENDENT** = ``2``
Déformer l'espace indépendamment pour chaque octave, ce qui entraîne une distorsion plus chaotique.
.. rst-class:: classref-section-separator
----
.. rst-class:: classref-descriptions-group
Descriptions des propriétés
------------------------------------------------------
.. _class_FastNoiseLite_property_cellular_distance_function:
.. rst-class:: classref-property
:ref:`CellularDistanceFunction<enum_FastNoiseLite_CellularDistanceFunction>` **cellular_distance_function** = ``0`` :ref:`🔗<class_FastNoiseLite_property_cellular_distance_function>`
.. rst-class:: classref-property-setget
- |void| **set_cellular_distance_function**\ (\ value\: :ref:`CellularDistanceFunction<enum_FastNoiseLite_CellularDistanceFunction>`\ )
- :ref:`CellularDistanceFunction<enum_FastNoiseLite_CellularDistanceFunction>` **get_cellular_distance_function**\ (\ )
Détermine comment la distance jusqu'au point le plus proche/le second plus proche est calculée.
.. rst-class:: classref-item-separator
----
.. _class_FastNoiseLite_property_cellular_jitter:
.. rst-class:: classref-property
:ref:`float<class_float>` **cellular_jitter** = ``1.0`` :ref:`🔗<class_FastNoiseLite_property_cellular_jitter>`
.. rst-class:: classref-property-setget
- |void| **set_cellular_jitter**\ (\ value\: :ref:`float<class_float>`\ )
- :ref:`float<class_float>` **get_cellular_jitter**\ (\ )
Distance maximale à laquelle un point peut se déplacer hors de sa position sur la grille. Définir à ``0`` pour une grille uniforme.
.. rst-class:: classref-item-separator
----
.. _class_FastNoiseLite_property_cellular_return_type:
.. rst-class:: classref-property
:ref:`CellularReturnType<enum_FastNoiseLite_CellularReturnType>` **cellular_return_type** = ``1`` :ref:`🔗<class_FastNoiseLite_property_cellular_return_type>`
.. rst-class:: classref-property-setget
- |void| **set_cellular_return_type**\ (\ value\: :ref:`CellularReturnType<enum_FastNoiseLite_CellularReturnType>`\ )
- :ref:`CellularReturnType<enum_FastNoiseLite_CellularReturnType>` **get_cellular_return_type**\ (\ )
Type de renvoi des calculs de bruit cellulaire.
.. rst-class:: classref-item-separator
----
.. _class_FastNoiseLite_property_domain_warp_amplitude:
.. rst-class:: classref-property
:ref:`float<class_float>` **domain_warp_amplitude** = ``30.0`` :ref:`🔗<class_FastNoiseLite_property_domain_warp_amplitude>`
.. rst-class:: classref-property-setget
- |void| **set_domain_warp_amplitude**\ (\ value\: :ref:`float<class_float>`\ )
- :ref:`float<class_float>` **get_domain_warp_amplitude**\ (\ )
Définit la distance de distorsion maximale depuis l'origine.
.. rst-class:: classref-item-separator
----
.. _class_FastNoiseLite_property_domain_warp_enabled:
.. rst-class:: classref-property
:ref:`bool<class_bool>` **domain_warp_enabled** = ``false`` :ref:`🔗<class_FastNoiseLite_property_domain_warp_enabled>`
.. rst-class:: classref-property-setget
- |void| **set_domain_warp_enabled**\ (\ value\: :ref:`bool<class_bool>`\ )
- :ref:`bool<class_bool>` **is_domain_warp_enabled**\ (\ )
Si activé, une autre instance FastNoiseLite est utilisée déforme l'espace, entraînant une distorsion du bruit.
.. rst-class:: classref-item-separator
----
.. _class_FastNoiseLite_property_domain_warp_fractal_gain:
.. rst-class:: classref-property
:ref:`float<class_float>` **domain_warp_fractal_gain** = ``0.5`` :ref:`🔗<class_FastNoiseLite_property_domain_warp_fractal_gain>`
.. rst-class:: classref-property-setget
- |void| **set_domain_warp_fractal_gain**\ (\ value\: :ref:`float<class_float>`\ )
- :ref:`float<class_float>` **get_domain_warp_fractal_gain**\ (\ )
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.
.. rst-class:: classref-item-separator
----
.. _class_FastNoiseLite_property_domain_warp_fractal_lacunarity:
.. rst-class:: classref-property
:ref:`float<class_float>` **domain_warp_fractal_lacunarity** = ``6.0`` :ref:`🔗<class_FastNoiseLite_property_domain_warp_fractal_lacunarity>`
.. rst-class:: classref-property-setget
- |void| **set_domain_warp_fractal_lacunarity**\ (\ value\: :ref:`float<class_float>`\ )
- :ref:`float<class_float>` **get_domain_warp_fractal_lacunarity**\ (\ )
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.
.. rst-class:: classref-item-separator
----
.. _class_FastNoiseLite_property_domain_warp_fractal_octaves:
.. rst-class:: classref-property
:ref:`int<class_int>` **domain_warp_fractal_octaves** = ``5`` :ref:`🔗<class_FastNoiseLite_property_domain_warp_fractal_octaves>`
.. rst-class:: classref-property-setget
- |void| **set_domain_warp_fractal_octaves**\ (\ value\: :ref:`int<class_int>`\ )
- :ref:`int<class_int>` **get_domain_warp_fractal_octaves**\ (\ )
Le nombre de couches de bruit qui sont échantillonnées pour obtenir la valeur finale pour le bruit fractal qui déforme l'espace.
.. rst-class:: classref-item-separator
----
.. _class_FastNoiseLite_property_domain_warp_fractal_type:
.. rst-class:: classref-property
:ref:`DomainWarpFractalType<enum_FastNoiseLite_DomainWarpFractalType>` **domain_warp_fractal_type** = ``1`` :ref:`🔗<class_FastNoiseLite_property_domain_warp_fractal_type>`
.. rst-class:: classref-property-setget
- |void| **set_domain_warp_fractal_type**\ (\ value\: :ref:`DomainWarpFractalType<enum_FastNoiseLite_DomainWarpFractalType>`\ )
- :ref:`DomainWarpFractalType<enum_FastNoiseLite_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.
.. rst-class:: classref-item-separator
----
.. _class_FastNoiseLite_property_domain_warp_frequency:
.. rst-class:: classref-property
:ref:`float<class_float>` **domain_warp_frequency** = ``0.05`` :ref:`🔗<class_FastNoiseLite_property_domain_warp_frequency>`
.. rst-class:: classref-property-setget
- |void| **set_domain_warp_frequency**\ (\ value\: :ref:`float<class_float>`\ )
- :ref:`float<class_float>` **get_domain_warp_frequency**\ (\ )
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.
.. rst-class:: classref-item-separator
----
.. _class_FastNoiseLite_property_domain_warp_type:
.. rst-class:: classref-property
:ref:`DomainWarpType<enum_FastNoiseLite_DomainWarpType>` **domain_warp_type** = ``0`` :ref:`🔗<class_FastNoiseLite_property_domain_warp_type>`
.. rst-class:: classref-property-setget
- |void| **set_domain_warp_type**\ (\ value\: :ref:`DomainWarpType<enum_FastNoiseLite_DomainWarpType>`\ )
- :ref:`DomainWarpType<enum_FastNoiseLite_DomainWarpType>` **get_domain_warp_type**\ (\ )
L'algorithme de déformation.
.. rst-class:: classref-item-separator
----
.. _class_FastNoiseLite_property_fractal_gain:
.. rst-class:: classref-property
:ref:`float<class_float>` **fractal_gain** = ``0.5`` :ref:`🔗<class_FastNoiseLite_property_fractal_gain>`
.. rst-class:: classref-property-setget
- |void| **set_fractal_gain**\ (\ value\: :ref:`float<class_float>`\ )
- :ref:`float<class_float>` **get_fractal_gain**\ (\ )
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.
.. rst-class:: classref-item-separator
----
.. _class_FastNoiseLite_property_fractal_lacunarity:
.. rst-class:: classref-property
:ref:`float<class_float>` **fractal_lacunarity** = ``2.0`` :ref:`🔗<class_FastNoiseLite_property_fractal_lacunarity>`
.. rst-class:: classref-property-setget
- |void| **set_fractal_lacunarity**\ (\ value\: :ref:`float<class_float>`\ )
- :ref:`float<class_float>` **get_fractal_lacunarity**\ (\ )
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.
.. rst-class:: classref-item-separator
----
.. _class_FastNoiseLite_property_fractal_octaves:
.. rst-class:: classref-property
:ref:`int<class_int>` **fractal_octaves** = ``5`` :ref:`🔗<class_FastNoiseLite_property_fractal_octaves>`
.. rst-class:: classref-property-setget
- |void| **set_fractal_octaves**\ (\ value\: :ref:`int<class_int>`\ )
- :ref:`int<class_int>` **get_fractal_octaves**\ (\ )
Le nombre de couches de bruit qui sont échantillonnées pour obtenir la valeur finale des bruits type fractal.
.. rst-class:: classref-item-separator
----
.. _class_FastNoiseLite_property_fractal_ping_pong_strength:
.. rst-class:: classref-property
:ref:`float<class_float>` **fractal_ping_pong_strength** = ``2.0`` :ref:`🔗<class_FastNoiseLite_property_fractal_ping_pong_strength>`
.. rst-class:: classref-property-setget
- |void| **set_fractal_ping_pong_strength**\ (\ value\: :ref:`float<class_float>`\ )
- :ref:`float<class_float>` **get_fractal_ping_pong_strength**\ (\ )
Définit la force du type ping pong de fractale.
.. rst-class:: classref-item-separator
----
.. _class_FastNoiseLite_property_fractal_type:
.. rst-class:: classref-property
:ref:`FractalType<enum_FastNoiseLite_FractalType>` **fractal_type** = ``1`` :ref:`🔗<class_FastNoiseLite_property_fractal_type>`
.. rst-class:: classref-property-setget
- |void| **set_fractal_type**\ (\ value\: :ref:`FractalType<enum_FastNoiseLite_FractalType>`\ )
- :ref:`FractalType<enum_FastNoiseLite_FractalType>` **get_fractal_type**\ (\ )
La méthode pour combiner les octaves en une fractale.
.. rst-class:: classref-item-separator
----
.. _class_FastNoiseLite_property_fractal_weighted_strength:
.. rst-class:: classref-property
:ref:`float<class_float>` **fractal_weighted_strength** = ``0.0`` :ref:`🔗<class_FastNoiseLite_property_fractal_weighted_strength>`
.. rst-class:: classref-property-setget
- |void| **set_fractal_weighted_strength**\ (\ value\: :ref:`float<class_float>`\ )
- :ref:`float<class_float>` **get_fractal_weighted_strength**\ (\ )
Un poids plus élevé signifie que les octaves plus élevées ont moins d'impact si les octaves inférieures ont un impact important.
.. rst-class:: classref-item-separator
----
.. _class_FastNoiseLite_property_frequency:
.. rst-class:: classref-property
:ref:`float<class_float>` **frequency** = ``0.01`` :ref:`🔗<class_FastNoiseLite_property_frequency>`
.. rst-class:: classref-property-setget
- |void| **set_frequency**\ (\ value\: :ref:`float<class_float>`\ )
- :ref:`float<class_float>` **get_frequency**\ (\ )
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.
.. rst-class:: classref-item-separator
----
.. _class_FastNoiseLite_property_noise_type:
.. rst-class:: classref-property
:ref:`NoiseType<enum_FastNoiseLite_NoiseType>` **noise_type** = ``1`` :ref:`🔗<class_FastNoiseLite_property_noise_type>`
.. rst-class:: classref-property-setget
- |void| **set_noise_type**\ (\ value\: :ref:`NoiseType<enum_FastNoiseLite_NoiseType>`\ )
- :ref:`NoiseType<enum_FastNoiseLite_NoiseType>` **get_noise_type**\ (\ )
L'algorithme de bruit utilisé.
.. rst-class:: classref-item-separator
----
.. _class_FastNoiseLite_property_offset:
.. rst-class:: classref-property
:ref:`Vector3<class_Vector3>` **offset** = ``Vector3(0, 0, 0)`` :ref:`🔗<class_FastNoiseLite_property_offset>`
.. rst-class:: classref-property-setget
- |void| **set_offset**\ (\ value\: :ref:`Vector3<class_Vector3>`\ )
- :ref:`Vector3<class_Vector3>` **get_offset**\ (\ )
Translate les coordonnées d'entrée du bruit par le :ref:`Vector3<class_Vector3>` donné.
.. rst-class:: classref-item-separator
----
.. _class_FastNoiseLite_property_seed:
.. rst-class:: classref-property
:ref:`int<class_int>` **seed** = ``0`` :ref:`🔗<class_FastNoiseLite_property_seed>`
.. rst-class:: classref-property-setget
- |void| **set_seed**\ (\ value\: :ref:`int<class_int>`\ )
- :ref:`int<class_int>` **get_seed**\ (\ )
La graine de nombre aléatoire pour tous les types de bruit.
.. |virtual| replace:: :abbr:`virtual (Cette méthode doit typiquement être redéfinie par l'utilisateur pour avoir un effet.)`
.. |required| replace:: :abbr:`required (This method is required to be overridden when extending its base class.)`
.. |const| replace:: :abbr:`const (Cette méthode n'a pas d'effets de bord. Elle ne modifie aucune des variables membres de l'instance.)`
.. |vararg| replace:: :abbr:`vararg (Cette méthode accepte n'importe quel nombre d'arguments après ceux décris ici.)`
.. |constructor| replace:: :abbr:`constructor (Cette méthode est utilisée pour construire un type.)`
.. |static| replace:: :abbr:`static (Cette méthode n'a pas besoin d'instance pour être appelée, elle peut donc être directement appelée en utilisant le nom de la classe.)`
.. |operator| replace:: :abbr:`operator (Cette méthode décrit un opérateur valide à utiliser avec ce type en tant qu'opérande gauche.)`
.. |bitfield| replace:: :abbr:`BitField (Cette valeur est un nombre entier composé d'un masque de bits des options suivantes.)`
.. |void| replace:: :abbr:`void (Aucune valeur de retour.)`
Reference in New Issue View Git Blame Copy Permalink