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/uk/class_fastnoiselite.rst

731 lines
35 KiB
ReStructuredText
Raw Permalink Blame History

This file contains ambiguous Unicode characters

This file contains Unicode characters that might be confused with other characters. 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
=============
**Успадковує:** :ref:`Noise<class_Noise>` **<** :ref:`Resource<class_Resource>` **<** :ref:`RefCounted<class_RefCounted>` **<** :ref:`Object<class_Object>`
Бібліотека FastNoiseLite.
.. rst-class:: classref-introduction-group
Опис
--------
Цей клас генерує шум за допомогою бібліотеки FastNoiseLite, яка є сукупністю декількох алгоритмів шуму, включаючи стільниковий, Perlin, значення та багато іншого.
Найпопулярніші значення шуму в діапазоні ``[-1, 1]``, але не завжди. ``1``.
.. rst-class:: classref-reftable-group
Властивості
----------------------
.. 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
Переліки
----------------
.. _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``
На основі сусідніх значень призначають решітки випадкових значень.
.. _class_FastNoiseLite_constant_TYPE_VALUE_CUBIC:
.. rst-class:: classref-enumeration-constant
:ref:`NoiseType<enum_FastNoiseLite_NoiseType>` **TYPE_VALUE_CUBIC** = ``4``
Схожий на шум значень (:ref:`TYPE_VALUE<class_FastNoiseLite_constant_TYPE_VALUE>`), але повільніший. Має більшу дисперсію піків та западин.
Кубічний шум можна використовувати для уникнення певних артефактів під час використання шуму значень для створення карти рельєфу. Загалом, слід завжди використовувати цей режим, якщо шум значень використовується для карти висот або карти рельєфу.
.. _class_FastNoiseLite_constant_TYPE_PERLIN:
.. rst-class:: classref-enumeration-constant
:ref:`NoiseType<enum_FastNoiseLite_NoiseType>` **TYPE_PERLIN** = ``3``
Просування випадкових градієнтів. Їхні продукти з точки зору отримання значень між латтичних речовин.
.. _class_FastNoiseLite_constant_TYPE_CELLULAR:
.. rst-class:: classref-enumeration-constant
:ref:`NoiseType<enum_FastNoiseLite_NoiseType>` **TYPE_CELLULAR** = ``2``
У клітинку входить як шум у Worley і Voronoi діаграми, що створює різні регіони однакового значення.
.. _class_FastNoiseLite_constant_TYPE_SIMPLEX:
.. rst-class:: classref-enumeration-constant
:ref:`NoiseType<enum_FastNoiseLite_NoiseType>` **TYPE_SIMPLEX** = ``0``
На відміну від :ref:`TYPE_PERLIN<class_FastNoiseLite_constant_TYPE_PERLIN>`, градієнти існують у симплексній решітці, а не в сітці, уникаючи направлених артефактів. Внутрішньо використовує тип шуму OpenSimplex2 FastNoiseLite.
.. _class_FastNoiseLite_constant_TYPE_SIMPLEX_SMOOTH:
.. rst-class:: classref-enumeration-constant
:ref:`NoiseType<enum_FastNoiseLite_NoiseType>` **TYPE_SIMPLEX_SMOOTH** = ``1``
Модифікована, якісніша версія :ref:`TYPE_SIMPLEX<class_FastNoiseLite_constant_TYPE_SIMPLEX>`, але повільніша. Внутрішньо використовує тип шуму OpenSimplex2S 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``
Ні фрактальний шум.
.. _class_FastNoiseLite_constant_FRACTAL_FBM:
.. rst-class:: classref-enumeration-constant
:ref:`FractalType<enum_FastNoiseLite_FractalType>` **FRACTAL_FBM** = ``1``
Спосіб використання Фракційно-коричневого руху для об'єднання октаїв в фрактальну.
.. _class_FastNoiseLite_constant_FRACTAL_RIDGED:
.. rst-class:: classref-enumeration-constant
:ref:`FractalType<enum_FastNoiseLite_FractalType>` **FRACTAL_RIDGED** = ``2``
Спосіб поєднання восьмий в фрактальний отриманий в результаті «холодного» вигляду.
.. _class_FastNoiseLite_constant_FRACTAL_PING_PONG:
.. rst-class:: classref-enumeration-constant
:ref:`FractalType<enum_FastNoiseLite_FractalType>` **FRACTAL_PING_PONG** = ``3``
Спосіб поєднання восьмий в фрактальний з пінг-понговим ефектом.
.. 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``
Відстань Euclidean до найближчої точки.
.. _class_FastNoiseLite_constant_DISTANCE_EUCLIDEAN_SQUARED:
.. rst-class:: classref-enumeration-constant
:ref:`CellularDistanceFunction<enum_FastNoiseLite_CellularDistanceFunction>` **DISTANCE_EUCLIDEAN_SQUARED** = ``1``
Квадратний Euclidean відстань до найближчої точки.
.. _class_FastNoiseLite_constant_DISTANCE_MANHATTAN:
.. rst-class:: classref-enumeration-constant
:ref:`CellularDistanceFunction<enum_FastNoiseLite_CellularDistanceFunction>` **DISTANCE_MANHATTAN** = ``2``
Манхеттенська відстань (датчикометрика) до найближчої точки.
.. _class_FastNoiseLite_constant_DISTANCE_HYBRID:
.. rst-class:: classref-enumeration-constant
:ref:`CellularDistanceFunction<enum_FastNoiseLite_CellularDistanceFunction>` **DISTANCE_HYBRID** = ``3``
Поєднання :ref:`DISTANCE_EUCLIDEAN<class_FastNoiseLite_constant_DISTANCE_EUCLIDEAN>` і :ref:`DISTANCE_MANHATTAN<class_FastNoiseLite_constant_DISTANCE_MANHATTAN>`, щоб отримати вигнуті межі клітинок.
.. 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``
Функція клітинної відстані поверне однакове значення для всіх точок в комірці.
.. _class_FastNoiseLite_constant_RETURN_DISTANCE:
.. rst-class:: classref-enumeration-constant
:ref:`CellularReturnType<enum_FastNoiseLite_CellularReturnType>` **RETURN_DISTANCE** = ``1``
Функція клітинної дистанції поверне значення, визначене на відстані до найближчої точки.
.. _class_FastNoiseLite_constant_RETURN_DISTANCE2:
.. rst-class:: classref-enumeration-constant
:ref:`CellularReturnType<enum_FastNoiseLite_CellularReturnType>` **RETURN_DISTANCE2** = ``2``
Функція клітинної дистанції повертає відстань до другої точки.
.. _class_FastNoiseLite_constant_RETURN_DISTANCE2_ADD:
.. rst-class:: classref-enumeration-constant
:ref:`CellularReturnType<enum_FastNoiseLite_CellularReturnType>` **RETURN_DISTANCE2_ADD** = ``3``
Відстань до найближчої точки додається до відстані до другої точки.
.. _class_FastNoiseLite_constant_RETURN_DISTANCE2_SUB:
.. rst-class:: classref-enumeration-constant
:ref:`CellularReturnType<enum_FastNoiseLite_CellularReturnType>` **RETURN_DISTANCE2_SUB** = ``4``
Відстань до найближчої точки відраховується від відстані до другої точки.
.. _class_FastNoiseLite_constant_RETURN_DISTANCE2_MUL:
.. rst-class:: classref-enumeration-constant
:ref:`CellularReturnType<enum_FastNoiseLite_CellularReturnType>` **RETURN_DISTANCE2_MUL** = ``5``
Відстань до найближчої точки множиться на відстань до другої точки.
.. _class_FastNoiseLite_constant_RETURN_DISTANCE2_DIV:
.. rst-class:: classref-enumeration-constant
:ref:`CellularReturnType<enum_FastNoiseLite_CellularReturnType>` **RETURN_DISTANCE2_DIV** = ``6``
Відстань до найближчої точки поділяється на відстані до другої точки.
.. 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``
Домен вентилюється за допомогою алгоритму простого шуму.
.. _class_FastNoiseLite_constant_DOMAIN_WARP_SIMPLEX_REDUCED:
.. rst-class:: classref-enumeration-constant
:ref:`DomainWarpType<enum_FastNoiseLite_DomainWarpType>` **DOMAIN_WARP_SIMPLEX_REDUCED** = ``1``
Спрощена версія алгоритму простого шуму.
.. _class_FastNoiseLite_constant_DOMAIN_WARP_BASIC_GRID:
.. rst-class:: classref-enumeration-constant
:ref:`DomainWarpType<enum_FastNoiseLite_DomainWarpType>` **DOMAIN_WARP_BASIC_GRID** = ``2``
Домен вентильований за допомогою простої шумової сітки (не як гладкий, як інші методи, але більш виконавець).
.. 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``
Не вогнетривке шумотворення простору.
.. _class_FastNoiseLite_constant_DOMAIN_WARP_FRACTAL_PROGRESSIVE:
.. rst-class:: classref-enumeration-constant
:ref:`DomainWarpFractalType<enum_FastNoiseLite_DomainWarpFractalType>` **DOMAIN_WARP_FRACTAL_PROGRESSIVE** = ``1``
Війна простору прогресивно, октав для октава, що призводить до більш «лікіфікованих» спотворень.
.. _class_FastNoiseLite_constant_DOMAIN_WARP_FRACTAL_INDEPENDENT:
.. rst-class:: classref-enumeration-constant
:ref:`DomainWarpFractalType<enum_FastNoiseLite_DomainWarpFractalType>` **DOMAIN_WARP_FRACTAL_INDEPENDENT** = ``2``
Вимикаючи простір самостійно для кожного октава, в результаті чого більш хаотичне спотворення.
.. rst-class:: classref-section-separator
----
.. rst-class:: classref-descriptions-group
Описи властивостей
------------------------------------
.. _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**\ (\ )
Визначає, як обчислюється відстань до найближчої/другої найближчої точки.
.. 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**\ (\ )
Максимальна відстань точки може переходити з сітки. Набір до ``0`` для рівномірної сітки.
.. 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**\ (\ )
Тип повернення з розрахунків стільникового шуму.
.. 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**\ (\ )
Встановлює максимальну відстань від витоку.
.. 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**\ (\ )
Якщо увімкнено ще один приклад FastNoiseLite використовується для закріплення простору, що призводить до спотворення шуму.
.. 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**\ (\ )
Визначення міцності кожного наступного шару шуму, який використовується для закріплення простору.
Низьке значення розміщує більше акценту на шарах бази нижніх частот, при цьому висока вартість кладе більше акцентів на шарах більшої частоти.
.. 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**\ (\ )
Зміна частоти між октавами, також відома як «лакунарність», фрактального шуму, яка спотворює простір. Збільшення цього значення призводить до вищих октав, що створює шум з дрібнішими деталями та грубішим виглядом.
.. 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**\ (\ )
Кількість шарів шуму, які збираються отримати кінцеве значення для вогнетривкого шуму, який закріплює простір.
.. 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**\ (\ )
Метод об'єднання октав у фрактал, який використовується для деформації простору.
.. 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**\ (\ )
Частота шуму, що пригнічує простір. Низька частота призводить до гладкого шуму при високих частотах призводить до шорсткості, більш гранульованого шуму.
.. 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**\ (\ )
Алгоритм варпу.
.. 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**\ (\ )
Визначення міцності кожного наступного шару шуму в фрактальному шумі.
Низьке значення розміщує більше акценту на шарах бази нижніх частот, при цьому висока вартість кладе більше акцентів на шарах більшої частоти.
.. 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**\ (\ )
Частотний множник між наступними октаами. Підвищення результатів цього значення у вищих октаях, що виробляють шум з дрібними деталями та грубим зовнішнім виглядом.
.. 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**\ (\ )
Кількість шарів шуму, які збираються отримати кінцеве значення для фрактальних типів шуму.
.. 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**\ (\ )
Налаштовує міцність вогнетривкого пінг-понгового типу.
.. 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**\ (\ )
Метод об'єднання октав у фрактал.
.. 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**\ (\ )
Більша вага – це більш висока кількість октаїв, якщо нижні октави мають великий вплив.
.. 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**\ (\ )
Частота для всіх типів шуму. Низька частота призводить до гладкого шуму при високих частотах призводить до шорсткості, більш гранульованого шуму.
.. 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**\ (\ )
Використаний алгоритм шуму.
.. 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**\ (\ )
Перекласти координати шуму заданими :ref:`Vector3<class_Vector3>`.
.. 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**\ (\ )
Випадковий кількість насіння для всіх типів шуму.
.. |virtual| replace:: :abbr:`virtual (Зазвичай, цей метод перевизначається користувачем, щоб він мав вплив.)`
.. |required| replace:: :abbr:`required (This method is required to be overridden when extending its base class.)`
.. |const| replace:: :abbr:`const (Цей метод не має побічних ефектів. Не змінює ніяку змінну екземпляра об'єкта.)`
.. |vararg| replace:: :abbr:`vararg (Цей метод приймає будь-яке число аргументів після описаних тут.)`
.. |constructor| replace:: :abbr:`constructor (Цей метод використовується для побудови типів.)`
.. |static| replace:: :abbr:`static (Цей метод не потребує екземпляра для виклику, його можна викликати безпосередньо за допомогою назви класу.)`
.. |operator| replace:: :abbr:`operator (Цей метод описує дійсний оператор для взаємодії з цим типом як з лівим операндом.)`
.. |bitfield| replace:: :abbr:`BitField (Це значення є цілим числом, складеним у вигляді бітової маски з наступних прапорів.)`
.. |void| replace:: :abbr:`void (Значення не повертається.)`
Reference in New Issue View Git Blame Copy Permalink