mirror of
https://github.com/godotengine/godot-docs-l10n.git
synced 2025-12-31 09:49:22 +03:00
1204 lines
89 KiB
ReStructuredText
1204 lines
89 KiB
ReStructuredText
:github_url: hide
|
||
|
||
.. _class_PackedByteArray:
|
||
|
||
PackedByteArray
|
||
===============
|
||
|
||
Упакований масив байтів.
|
||
|
||
.. rst-class:: classref-introduction-group
|
||
|
||
Опис
|
||
--------
|
||
|
||
Масив, спеціально розроблений для зберігання байтів. Щільно упаковує дані, що економить пам'ять для масивів великого розміру.
|
||
|
||
\ **PackedByteArray** також надає методи для кодування/декодування різних типів у/з байтів. Спосіб кодування значень є деталлю реалізації і не повинен використовуватися під час взаємодії із зовнішніми програмами.
|
||
|
||
\ **Примітка:** Упаковані масиви завжди передаються за посиланням. Щоб отримати копію масиву, яку можна змінювати незалежно від оригінального масиву, використовуйте :ref:`duplicate()<class_PackedByteArray_method_duplicate>`. Це *не* стосується вбудованих властивостей і методів. У цих випадках повернений упакований масив є копією, і його зміна *не* вплине на оригінальне значення. Щоб оновити вбудовану властивість цього типу, змініть повернений масив, а потім знову призначте його властивості.
|
||
|
||
.. note::
|
||
|
||
Існують значні відмінності при використанні цього API із С#. Більше інформації: ref:`doc_c_sharp_differences`.
|
||
|
||
.. rst-class:: classref-reftable-group
|
||
|
||
Конструктори
|
||
------------------------
|
||
|
||
.. table::
|
||
:widths: auto
|
||
|
||
+-----------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------+
|
||
| :ref:`PackedByteArray<class_PackedByteArray>` | :ref:`PackedByteArray<class_PackedByteArray_constructor_PackedByteArray>`\ (\ ) |
|
||
+-----------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------+
|
||
| :ref:`PackedByteArray<class_PackedByteArray>` | :ref:`PackedByteArray<class_PackedByteArray_constructor_PackedByteArray>`\ (\ from\: :ref:`PackedByteArray<class_PackedByteArray>`\ ) |
|
||
+-----------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------+
|
||
| :ref:`PackedByteArray<class_PackedByteArray>` | :ref:`PackedByteArray<class_PackedByteArray_constructor_PackedByteArray>`\ (\ from\: :ref:`Array<class_Array>`\ ) |
|
||
+-----------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------+
|
||
|
||
.. rst-class:: classref-reftable-group
|
||
|
||
Методи
|
||
------------
|
||
|
||
.. table::
|
||
:widths: auto
|
||
|
||
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
||
| :ref:`bool<class_bool>` | :ref:`append<class_PackedByteArray_method_append>`\ (\ value\: :ref:`int<class_int>`\ ) |
|
||
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
||
| |void| | :ref:`append_array<class_PackedByteArray_method_append_array>`\ (\ array\: :ref:`PackedByteArray<class_PackedByteArray>`\ ) |
|
||
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
||
| :ref:`int<class_int>` | :ref:`bsearch<class_PackedByteArray_method_bsearch>`\ (\ value\: :ref:`int<class_int>`, before\: :ref:`bool<class_bool>` = true\ ) |const| |
|
||
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
||
| |void| | :ref:`bswap16<class_PackedByteArray_method_bswap16>`\ (\ offset\: :ref:`int<class_int>` = 0, count\: :ref:`int<class_int>` = -1\ ) |
|
||
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
||
| |void| | :ref:`bswap32<class_PackedByteArray_method_bswap32>`\ (\ offset\: :ref:`int<class_int>` = 0, count\: :ref:`int<class_int>` = -1\ ) |
|
||
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
||
| |void| | :ref:`bswap64<class_PackedByteArray_method_bswap64>`\ (\ offset\: :ref:`int<class_int>` = 0, count\: :ref:`int<class_int>` = -1\ ) |
|
||
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
||
| |void| | :ref:`clear<class_PackedByteArray_method_clear>`\ (\ ) |
|
||
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
||
| :ref:`PackedByteArray<class_PackedByteArray>` | :ref:`compress<class_PackedByteArray_method_compress>`\ (\ compression_mode\: :ref:`int<class_int>` = 0\ ) |const| |
|
||
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
||
| :ref:`int<class_int>` | :ref:`count<class_PackedByteArray_method_count>`\ (\ value\: :ref:`int<class_int>`\ ) |const| |
|
||
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
||
| :ref:`float<class_float>` | :ref:`decode_double<class_PackedByteArray_method_decode_double>`\ (\ byte_offset\: :ref:`int<class_int>`\ ) |const| |
|
||
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
||
| :ref:`float<class_float>` | :ref:`decode_float<class_PackedByteArray_method_decode_float>`\ (\ byte_offset\: :ref:`int<class_int>`\ ) |const| |
|
||
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
||
| :ref:`float<class_float>` | :ref:`decode_half<class_PackedByteArray_method_decode_half>`\ (\ byte_offset\: :ref:`int<class_int>`\ ) |const| |
|
||
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
||
| :ref:`int<class_int>` | :ref:`decode_s8<class_PackedByteArray_method_decode_s8>`\ (\ byte_offset\: :ref:`int<class_int>`\ ) |const| |
|
||
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
||
| :ref:`int<class_int>` | :ref:`decode_s16<class_PackedByteArray_method_decode_s16>`\ (\ byte_offset\: :ref:`int<class_int>`\ ) |const| |
|
||
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
||
| :ref:`int<class_int>` | :ref:`decode_s32<class_PackedByteArray_method_decode_s32>`\ (\ byte_offset\: :ref:`int<class_int>`\ ) |const| |
|
||
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
||
| :ref:`int<class_int>` | :ref:`decode_s64<class_PackedByteArray_method_decode_s64>`\ (\ byte_offset\: :ref:`int<class_int>`\ ) |const| |
|
||
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
||
| :ref:`int<class_int>` | :ref:`decode_u8<class_PackedByteArray_method_decode_u8>`\ (\ byte_offset\: :ref:`int<class_int>`\ ) |const| |
|
||
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
||
| :ref:`int<class_int>` | :ref:`decode_u16<class_PackedByteArray_method_decode_u16>`\ (\ byte_offset\: :ref:`int<class_int>`\ ) |const| |
|
||
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
||
| :ref:`int<class_int>` | :ref:`decode_u32<class_PackedByteArray_method_decode_u32>`\ (\ byte_offset\: :ref:`int<class_int>`\ ) |const| |
|
||
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
||
| :ref:`int<class_int>` | :ref:`decode_u64<class_PackedByteArray_method_decode_u64>`\ (\ byte_offset\: :ref:`int<class_int>`\ ) |const| |
|
||
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
||
| :ref:`Variant<class_Variant>` | :ref:`decode_var<class_PackedByteArray_method_decode_var>`\ (\ byte_offset\: :ref:`int<class_int>`, allow_objects\: :ref:`bool<class_bool>` = false\ ) |const| |
|
||
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
||
| :ref:`int<class_int>` | :ref:`decode_var_size<class_PackedByteArray_method_decode_var_size>`\ (\ byte_offset\: :ref:`int<class_int>`, allow_objects\: :ref:`bool<class_bool>` = false\ ) |const| |
|
||
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
||
| :ref:`PackedByteArray<class_PackedByteArray>` | :ref:`decompress<class_PackedByteArray_method_decompress>`\ (\ buffer_size\: :ref:`int<class_int>`, compression_mode\: :ref:`int<class_int>` = 0\ ) |const| |
|
||
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
||
| :ref:`PackedByteArray<class_PackedByteArray>` | :ref:`decompress_dynamic<class_PackedByteArray_method_decompress_dynamic>`\ (\ max_output_size\: :ref:`int<class_int>`, compression_mode\: :ref:`int<class_int>` = 0\ ) |const| |
|
||
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
||
| :ref:`PackedByteArray<class_PackedByteArray>` | :ref:`duplicate<class_PackedByteArray_method_duplicate>`\ (\ ) |const| |
|
||
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
||
| |void| | :ref:`encode_double<class_PackedByteArray_method_encode_double>`\ (\ byte_offset\: :ref:`int<class_int>`, value\: :ref:`float<class_float>`\ ) |
|
||
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
||
| |void| | :ref:`encode_float<class_PackedByteArray_method_encode_float>`\ (\ byte_offset\: :ref:`int<class_int>`, value\: :ref:`float<class_float>`\ ) |
|
||
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
||
| |void| | :ref:`encode_half<class_PackedByteArray_method_encode_half>`\ (\ byte_offset\: :ref:`int<class_int>`, value\: :ref:`float<class_float>`\ ) |
|
||
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
||
| |void| | :ref:`encode_s8<class_PackedByteArray_method_encode_s8>`\ (\ byte_offset\: :ref:`int<class_int>`, value\: :ref:`int<class_int>`\ ) |
|
||
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
||
| |void| | :ref:`encode_s16<class_PackedByteArray_method_encode_s16>`\ (\ byte_offset\: :ref:`int<class_int>`, value\: :ref:`int<class_int>`\ ) |
|
||
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
||
| |void| | :ref:`encode_s32<class_PackedByteArray_method_encode_s32>`\ (\ byte_offset\: :ref:`int<class_int>`, value\: :ref:`int<class_int>`\ ) |
|
||
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
||
| |void| | :ref:`encode_s64<class_PackedByteArray_method_encode_s64>`\ (\ byte_offset\: :ref:`int<class_int>`, value\: :ref:`int<class_int>`\ ) |
|
||
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
||
| |void| | :ref:`encode_u8<class_PackedByteArray_method_encode_u8>`\ (\ byte_offset\: :ref:`int<class_int>`, value\: :ref:`int<class_int>`\ ) |
|
||
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
||
| |void| | :ref:`encode_u16<class_PackedByteArray_method_encode_u16>`\ (\ byte_offset\: :ref:`int<class_int>`, value\: :ref:`int<class_int>`\ ) |
|
||
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
||
| |void| | :ref:`encode_u32<class_PackedByteArray_method_encode_u32>`\ (\ byte_offset\: :ref:`int<class_int>`, value\: :ref:`int<class_int>`\ ) |
|
||
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
||
| |void| | :ref:`encode_u64<class_PackedByteArray_method_encode_u64>`\ (\ byte_offset\: :ref:`int<class_int>`, value\: :ref:`int<class_int>`\ ) |
|
||
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
||
| :ref:`int<class_int>` | :ref:`encode_var<class_PackedByteArray_method_encode_var>`\ (\ byte_offset\: :ref:`int<class_int>`, value\: :ref:`Variant<class_Variant>`, allow_objects\: :ref:`bool<class_bool>` = false\ ) |
|
||
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
||
| :ref:`bool<class_bool>` | :ref:`erase<class_PackedByteArray_method_erase>`\ (\ value\: :ref:`int<class_int>`\ ) |
|
||
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
||
| |void| | :ref:`fill<class_PackedByteArray_method_fill>`\ (\ value\: :ref:`int<class_int>`\ ) |
|
||
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
||
| :ref:`int<class_int>` | :ref:`find<class_PackedByteArray_method_find>`\ (\ value\: :ref:`int<class_int>`, from\: :ref:`int<class_int>` = 0\ ) |const| |
|
||
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
||
| :ref:`int<class_int>` | :ref:`get<class_PackedByteArray_method_get>`\ (\ index\: :ref:`int<class_int>`\ ) |const| |
|
||
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
||
| :ref:`String<class_String>` | :ref:`get_string_from_ascii<class_PackedByteArray_method_get_string_from_ascii>`\ (\ ) |const| |
|
||
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
||
| :ref:`String<class_String>` | :ref:`get_string_from_multibyte_char<class_PackedByteArray_method_get_string_from_multibyte_char>`\ (\ encoding\: :ref:`String<class_String>` = ""\ ) |const| |
|
||
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
||
| :ref:`String<class_String>` | :ref:`get_string_from_utf8<class_PackedByteArray_method_get_string_from_utf8>`\ (\ ) |const| |
|
||
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
||
| :ref:`String<class_String>` | :ref:`get_string_from_utf16<class_PackedByteArray_method_get_string_from_utf16>`\ (\ ) |const| |
|
||
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
||
| :ref:`String<class_String>` | :ref:`get_string_from_utf32<class_PackedByteArray_method_get_string_from_utf32>`\ (\ ) |const| |
|
||
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
||
| :ref:`String<class_String>` | :ref:`get_string_from_wchar<class_PackedByteArray_method_get_string_from_wchar>`\ (\ ) |const| |
|
||
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
||
| :ref:`bool<class_bool>` | :ref:`has<class_PackedByteArray_method_has>`\ (\ value\: :ref:`int<class_int>`\ ) |const| |
|
||
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
||
| :ref:`bool<class_bool>` | :ref:`has_encoded_var<class_PackedByteArray_method_has_encoded_var>`\ (\ byte_offset\: :ref:`int<class_int>`, allow_objects\: :ref:`bool<class_bool>` = false\ ) |const| |
|
||
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
||
| :ref:`String<class_String>` | :ref:`hex_encode<class_PackedByteArray_method_hex_encode>`\ (\ ) |const| |
|
||
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
||
| :ref:`int<class_int>` | :ref:`insert<class_PackedByteArray_method_insert>`\ (\ at_index\: :ref:`int<class_int>`, value\: :ref:`int<class_int>`\ ) |
|
||
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
||
| :ref:`bool<class_bool>` | :ref:`is_empty<class_PackedByteArray_method_is_empty>`\ (\ ) |const| |
|
||
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
||
| :ref:`bool<class_bool>` | :ref:`push_back<class_PackedByteArray_method_push_back>`\ (\ value\: :ref:`int<class_int>`\ ) |
|
||
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
||
| |void| | :ref:`remove_at<class_PackedByteArray_method_remove_at>`\ (\ index\: :ref:`int<class_int>`\ ) |
|
||
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
||
| :ref:`int<class_int>` | :ref:`resize<class_PackedByteArray_method_resize>`\ (\ new_size\: :ref:`int<class_int>`\ ) |
|
||
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
||
| |void| | :ref:`reverse<class_PackedByteArray_method_reverse>`\ (\ ) |
|
||
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
||
| :ref:`int<class_int>` | :ref:`rfind<class_PackedByteArray_method_rfind>`\ (\ value\: :ref:`int<class_int>`, from\: :ref:`int<class_int>` = -1\ ) |const| |
|
||
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
||
| |void| | :ref:`set<class_PackedByteArray_method_set>`\ (\ index\: :ref:`int<class_int>`, value\: :ref:`int<class_int>`\ ) |
|
||
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
||
| :ref:`int<class_int>` | :ref:`size<class_PackedByteArray_method_size>`\ (\ ) |const| |
|
||
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
||
| :ref:`PackedByteArray<class_PackedByteArray>` | :ref:`slice<class_PackedByteArray_method_slice>`\ (\ begin\: :ref:`int<class_int>`, end\: :ref:`int<class_int>` = 2147483647\ ) |const| |
|
||
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
||
| |void| | :ref:`sort<class_PackedByteArray_method_sort>`\ (\ ) |
|
||
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
||
| :ref:`PackedColorArray<class_PackedColorArray>` | :ref:`to_color_array<class_PackedByteArray_method_to_color_array>`\ (\ ) |const| |
|
||
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
||
| :ref:`PackedFloat32Array<class_PackedFloat32Array>` | :ref:`to_float32_array<class_PackedByteArray_method_to_float32_array>`\ (\ ) |const| |
|
||
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
||
| :ref:`PackedFloat64Array<class_PackedFloat64Array>` | :ref:`to_float64_array<class_PackedByteArray_method_to_float64_array>`\ (\ ) |const| |
|
||
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
||
| :ref:`PackedInt32Array<class_PackedInt32Array>` | :ref:`to_int32_array<class_PackedByteArray_method_to_int32_array>`\ (\ ) |const| |
|
||
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
||
| :ref:`PackedInt64Array<class_PackedInt64Array>` | :ref:`to_int64_array<class_PackedByteArray_method_to_int64_array>`\ (\ ) |const| |
|
||
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
||
| :ref:`PackedVector2Array<class_PackedVector2Array>` | :ref:`to_vector2_array<class_PackedByteArray_method_to_vector2_array>`\ (\ ) |const| |
|
||
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
||
| :ref:`PackedVector3Array<class_PackedVector3Array>` | :ref:`to_vector3_array<class_PackedByteArray_method_to_vector3_array>`\ (\ ) |const| |
|
||
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
||
| :ref:`PackedVector4Array<class_PackedVector4Array>` | :ref:`to_vector4_array<class_PackedByteArray_method_to_vector4_array>`\ (\ ) |const| |
|
||
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
||
|
||
.. rst-class:: classref-reftable-group
|
||
|
||
Оператори
|
||
------------------
|
||
|
||
.. table::
|
||
:widths: auto
|
||
|
||
+-----------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------+
|
||
| :ref:`bool<class_bool>` | :ref:`operator !=<class_PackedByteArray_operator_neq_PackedByteArray>`\ (\ right\: :ref:`PackedByteArray<class_PackedByteArray>`\ ) |
|
||
+-----------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------+
|
||
| :ref:`PackedByteArray<class_PackedByteArray>` | :ref:`operator +<class_PackedByteArray_operator_sum_PackedByteArray>`\ (\ right\: :ref:`PackedByteArray<class_PackedByteArray>`\ ) |
|
||
+-----------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------+
|
||
| :ref:`bool<class_bool>` | :ref:`operator ==<class_PackedByteArray_operator_eq_PackedByteArray>`\ (\ right\: :ref:`PackedByteArray<class_PackedByteArray>`\ ) |
|
||
+-----------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------+
|
||
| :ref:`int<class_int>` | :ref:`operator []<class_PackedByteArray_operator_idx_int>`\ (\ index\: :ref:`int<class_int>`\ ) |
|
||
+-----------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------+
|
||
|
||
.. rst-class:: classref-section-separator
|
||
|
||
----
|
||
|
||
.. rst-class:: classref-descriptions-group
|
||
|
||
Описи конструкторів
|
||
--------------------------------------
|
||
|
||
.. _class_PackedByteArray_constructor_PackedByteArray:
|
||
|
||
.. rst-class:: classref-constructor
|
||
|
||
:ref:`PackedByteArray<class_PackedByteArray>` **PackedByteArray**\ (\ ) :ref:`🔗<class_PackedByteArray_constructor_PackedByteArray>`
|
||
|
||
Будуємо порожній **PackedByteArray**.
|
||
|
||
.. rst-class:: classref-item-separator
|
||
|
||
----
|
||
|
||
.. rst-class:: classref-constructor
|
||
|
||
:ref:`PackedByteArray<class_PackedByteArray>` **PackedByteArray**\ (\ from\: :ref:`PackedByteArray<class_PackedByteArray>`\ )
|
||
|
||
Constructs a **PackedByteArray** як копія даної **PackedByteArray**.
|
||
|
||
.. rst-class:: classref-item-separator
|
||
|
||
----
|
||
|
||
.. rst-class:: classref-constructor
|
||
|
||
:ref:`PackedByteArray<class_PackedByteArray>` **PackedByteArray**\ (\ from\: :ref:`Array<class_Array>`\ )
|
||
|
||
Будуємо новий **PackedByteArray**. Додатково ви можете пройти в загальній :ref:`Array<class_Array>`, яка буде перетворена.
|
||
|
||
.. rst-class:: classref-section-separator
|
||
|
||
----
|
||
|
||
.. rst-class:: classref-descriptions-group
|
||
|
||
Описи методів
|
||
--------------------------
|
||
|
||
.. _class_PackedByteArray_method_append:
|
||
|
||
.. rst-class:: classref-method
|
||
|
||
:ref:`bool<class_bool>` **append**\ (\ value\: :ref:`int<class_int>`\ ) :ref:`🔗<class_PackedByteArray_method_append>`
|
||
|
||
Додає елемент у кінець масиву (псевдонім :ref:`push_back()<class_PackedByteArray_method_push_back>`).
|
||
|
||
.. rst-class:: classref-item-separator
|
||
|
||
----
|
||
|
||
.. _class_PackedByteArray_method_append_array:
|
||
|
||
.. rst-class:: classref-method
|
||
|
||
|void| **append_array**\ (\ array\: :ref:`PackedByteArray<class_PackedByteArray>`\ ) :ref:`🔗<class_PackedByteArray_method_append_array>`
|
||
|
||
Додаток **PackedByteArray** в кінці цього масиву.
|
||
|
||
.. rst-class:: classref-item-separator
|
||
|
||
----
|
||
|
||
.. _class_PackedByteArray_method_bsearch:
|
||
|
||
.. rst-class:: classref-method
|
||
|
||
:ref:`int<class_int>` **bsearch**\ (\ value\: :ref:`int<class_int>`, before\: :ref:`bool<class_bool>` = true\ ) |const| :ref:`🔗<class_PackedByteArray_method_bsearch>`
|
||
|
||
Знаходить індекс існуючого значення (або індекс вставки, який підтримує порядок сортування, якщо значення ще не присутнє в масиві) за допомогою бінарного пошуку. За бажанням можна передати специфікатор ``before``. Якщо ``false``, індекс, що повертається, йде після всіх існуючих записів значення в масиві.
|
||
|
||
\ **Примітка:** Виклик :ref:`bsearch()<class_PackedByteArray_method_bsearch>` на невідсортованому масиві призводить до неочікуваної поведінки.
|
||
|
||
.. rst-class:: classref-item-separator
|
||
|
||
----
|
||
|
||
.. _class_PackedByteArray_method_bswap16:
|
||
|
||
.. rst-class:: classref-method
|
||
|
||
|void| **bswap16**\ (\ offset\: :ref:`int<class_int>` = 0, count\: :ref:`int<class_int>` = -1\ ) :ref:`🔗<class_PackedByteArray_method_bswap16>`
|
||
|
||
Міняє місцями порядок байтів 16-бітних сегментів масиву з параметром ``count``, починаючи з параметра ``offset``. Заміна виконується на місці. Якщо параметр ``count`` менше нуля, обробляються всі сегменти до кінця масиву, якщо розмір оброблених даних не кратний 2, байт після останнього обробленого 16-бітного сегмента не змінюється.
|
||
|
||
.. rst-class:: classref-item-separator
|
||
|
||
----
|
||
|
||
.. _class_PackedByteArray_method_bswap32:
|
||
|
||
.. rst-class:: classref-method
|
||
|
||
|void| **bswap32**\ (\ offset\: :ref:`int<class_int>` = 0, count\: :ref:`int<class_int>` = -1\ ) :ref:`🔗<class_PackedByteArray_method_bswap32>`
|
||
|
||
Міняє місцями порядок байтів 32-бітних сегментів масиву з параметром ``count``, починаючи з параметра ``offset``. Заміна виконується на місці. Якщо параметр ``count`` менше нуля, обробляються всі сегменти до кінця масиву, якщо розмір оброблених даних не кратний 4, байти після останнього обробленого 32-бітного сегмента не змінюються.
|
||
|
||
.. rst-class:: classref-item-separator
|
||
|
||
----
|
||
|
||
.. _class_PackedByteArray_method_bswap64:
|
||
|
||
.. rst-class:: classref-method
|
||
|
||
|void| **bswap64**\ (\ offset\: :ref:`int<class_int>` = 0, count\: :ref:`int<class_int>` = -1\ ) :ref:`🔗<class_PackedByteArray_method_bswap64>`
|
||
|
||
Міняє місцями порядок байтів 64-бітних сегментів масиву з параметром ``count``, починаючи з параметра ``offset``. Заміна виконується на місці. Якщо параметр ``count`` менше нуля, обробляються всі сегменти до кінця масиву, якщо розмір оброблених даних не кратний 8, байти після останнього обробленого 64-бітного сегмента не змінюються.
|
||
|
||
.. rst-class:: classref-item-separator
|
||
|
||
----
|
||
|
||
.. _class_PackedByteArray_method_clear:
|
||
|
||
.. rst-class:: classref-method
|
||
|
||
|void| **clear**\ (\ ) :ref:`🔗<class_PackedByteArray_method_clear>`
|
||
|
||
Очищає масив. Еквівалентно використанню :ref:`resize()<class_PackedByteArray_method_resize>` з розміром ``0``.
|
||
|
||
.. rst-class:: classref-item-separator
|
||
|
||
----
|
||
|
||
.. _class_PackedByteArray_method_compress:
|
||
|
||
.. rst-class:: classref-method
|
||
|
||
:ref:`PackedByteArray<class_PackedByteArray>` **compress**\ (\ compression_mode\: :ref:`int<class_int>` = 0\ ) |const| :ref:`🔗<class_PackedByteArray_method_compress>`
|
||
|
||
Повертає нову **PackedByteArray** з стисненими даними. Встановіть режим стиснення за допомогою одного з :ref:`CompressionMode<enum_FileAccess_CompressionMode>`.
|
||
|
||
.. rst-class:: classref-item-separator
|
||
|
||
----
|
||
|
||
.. _class_PackedByteArray_method_count:
|
||
|
||
.. rst-class:: classref-method
|
||
|
||
:ref:`int<class_int>` **count**\ (\ value\: :ref:`int<class_int>`\ ) |const| :ref:`🔗<class_PackedByteArray_method_count>`
|
||
|
||
Повертає кількість повторень елемента в масиві.
|
||
|
||
.. rst-class:: classref-item-separator
|
||
|
||
----
|
||
|
||
.. _class_PackedByteArray_method_decode_double:
|
||
|
||
.. rst-class:: classref-method
|
||
|
||
:ref:`float<class_float>` **decode_double**\ (\ byte_offset\: :ref:`int<class_int>`\ ) |const| :ref:`🔗<class_PackedByteArray_method_decode_double>`
|
||
|
||
Декодує 64-розрядний плаваючий номер точки від байтів, починаючи від ``byte_offset``. Недостатня кількість байтів. Повернення ``0.0`` якщо дійсний номер не може бути декодований.
|
||
|
||
.. rst-class:: classref-item-separator
|
||
|
||
----
|
||
|
||
.. _class_PackedByteArray_method_decode_float:
|
||
|
||
.. rst-class:: classref-method
|
||
|
||
:ref:`float<class_float>` **decode_float**\ (\ byte_offset\: :ref:`int<class_int>`\ ) |const| :ref:`🔗<class_PackedByteArray_method_decode_float>`
|
||
|
||
Коди 32-розрядного діапазону від байтів від ``byte_offset``. Недостатня кількість байтів. Повернення ``0.0`` якщо дійсний номер не може бути декодований.
|
||
|
||
.. rst-class:: classref-item-separator
|
||
|
||
----
|
||
|
||
.. _class_PackedByteArray_method_decode_half:
|
||
|
||
.. rst-class:: classref-method
|
||
|
||
:ref:`float<class_float>` **decode_half**\ (\ byte_offset\: :ref:`int<class_int>`\ ) |const| :ref:`🔗<class_PackedByteArray_method_decode_half>`
|
||
|
||
Декодує 16-бітовий плаваючий номер точки від байтів, починаючи від ``byte_offset``. Недостатня кількість байтів. Повернення ``0.0`` якщо дійсний номер не може бути декодований.
|
||
|
||
.. rst-class:: classref-item-separator
|
||
|
||
----
|
||
|
||
.. _class_PackedByteArray_method_decode_s8:
|
||
|
||
.. rst-class:: classref-method
|
||
|
||
:ref:`int<class_int>` **decode_s8**\ (\ byte_offset\: :ref:`int<class_int>`\ ) |const| :ref:`🔗<class_PackedByteArray_method_decode_s8>`
|
||
|
||
Decodes a 8-bit підписано ціле число з байтів від ``byte_offset``. Недостатня кількість байтів. Повернення ``0`` якщо дійсний номер не може бути декодований.
|
||
|
||
.. rst-class:: classref-item-separator
|
||
|
||
----
|
||
|
||
.. _class_PackedByteArray_method_decode_s16:
|
||
|
||
.. rst-class:: classref-method
|
||
|
||
:ref:`int<class_int>` **decode_s16**\ (\ byte_offset\: :ref:`int<class_int>`\ ) |const| :ref:`🔗<class_PackedByteArray_method_decode_s16>`
|
||
|
||
Коди 16-біту підписано ціле число з байтів, починаючи від ``byte_offset``. Недостатня кількість байтів. Повернення ``0`` якщо дійсний номер не може бути декодований.
|
||
|
||
.. rst-class:: classref-item-separator
|
||
|
||
----
|
||
|
||
.. _class_PackedByteArray_method_decode_s32:
|
||
|
||
.. rst-class:: classref-method
|
||
|
||
:ref:`int<class_int>` **decode_s32**\ (\ byte_offset\: :ref:`int<class_int>`\ ) |const| :ref:`🔗<class_PackedByteArray_method_decode_s32>`
|
||
|
||
Decodes a 32-bit підписано ціле число з байтів від ``byte_offset``. Недостатня кількість байтів. Повернення ``0`` якщо дійсний номер не може бути декодований.
|
||
|
||
.. rst-class:: classref-item-separator
|
||
|
||
----
|
||
|
||
.. _class_PackedByteArray_method_decode_s64:
|
||
|
||
.. rst-class:: classref-method
|
||
|
||
:ref:`int<class_int>` **decode_s64**\ (\ byte_offset\: :ref:`int<class_int>`\ ) |const| :ref:`🔗<class_PackedByteArray_method_decode_s64>`
|
||
|
||
Видаляє 64-біт, підписаний ціле число з байтів, починаючи від ``byte_offset``. Недостатня кількість байтів. Повернення ``0`` якщо дійсний номер не може бути декодований.
|
||
|
||
.. rst-class:: classref-item-separator
|
||
|
||
----
|
||
|
||
.. _class_PackedByteArray_method_decode_u8:
|
||
|
||
.. rst-class:: classref-method
|
||
|
||
:ref:`int<class_int>` **decode_u8**\ (\ byte_offset\: :ref:`int<class_int>`\ ) |const| :ref:`🔗<class_PackedByteArray_method_decode_u8>`
|
||
|
||
Видаляє 8-біт не позначений число з байтів, починаючи від ``byte_offset``. Недостатня кількість байтів. Повернення ``0`` якщо дійсний номер не може бути декодований.
|
||
|
||
.. rst-class:: classref-item-separator
|
||
|
||
----
|
||
|
||
.. _class_PackedByteArray_method_decode_u16:
|
||
|
||
.. rst-class:: classref-method
|
||
|
||
:ref:`int<class_int>` **decode_u16**\ (\ byte_offset\: :ref:`int<class_int>`\ ) |const| :ref:`🔗<class_PackedByteArray_method_decode_u16>`
|
||
|
||
Коди 16-біту не позначено ціле число з байтів, починаючи від ``byte_offset``. Недостатня кількість байтів. Повернення ``0`` якщо дійсний номер не може бути декодований.
|
||
|
||
.. rst-class:: classref-item-separator
|
||
|
||
----
|
||
|
||
.. _class_PackedByteArray_method_decode_u32:
|
||
|
||
.. rst-class:: classref-method
|
||
|
||
:ref:`int<class_int>` **decode_u32**\ (\ byte_offset\: :ref:`int<class_int>`\ ) |const| :ref:`🔗<class_PackedByteArray_method_decode_u32>`
|
||
|
||
Коди 32-розрядного цілого числа від байтів, починаючи від ``byte_offset``. Недостатня кількість байтів. Повернення ``0`` якщо дійсний номер не може бути декодований.
|
||
|
||
.. rst-class:: classref-item-separator
|
||
|
||
----
|
||
|
||
.. _class_PackedByteArray_method_decode_u64:
|
||
|
||
.. rst-class:: classref-method
|
||
|
||
:ref:`int<class_int>` **decode_u64**\ (\ byte_offset\: :ref:`int<class_int>`\ ) |const| :ref:`🔗<class_PackedByteArray_method_decode_u64>`
|
||
|
||
Видаляє 64-розрядне ціле число з байтів, починаючи від ``byte_offset``. Недостатня кількість байтів. Повернення ``0`` якщо дійсний номер не може бути декодований.
|
||
|
||
.. rst-class:: classref-item-separator
|
||
|
||
----
|
||
|
||
.. _class_PackedByteArray_method_decode_var:
|
||
|
||
.. rst-class:: classref-method
|
||
|
||
:ref:`Variant<class_Variant>` **decode_var**\ (\ byte_offset\: :ref:`int<class_int>`, allow_objects\: :ref:`bool<class_bool>` = false\ ) |const| :ref:`🔗<class_PackedByteArray_method_decode_var>`
|
||
|
||
Видаляє :ref:`Variant<class_Variant>` від байтів від ``byte_offset``. Повернення ``null`` якщо дійсний варіант не може бути декодовано або значення :ref:`Object<class_Object>`-derived і ``allow_objects`` ``false``.
|
||
|
||
.. rst-class:: classref-item-separator
|
||
|
||
----
|
||
|
||
.. _class_PackedByteArray_method_decode_var_size:
|
||
|
||
.. rst-class:: classref-method
|
||
|
||
:ref:`int<class_int>` **decode_var_size**\ (\ byte_offset\: :ref:`int<class_int>`, allow_objects\: :ref:`bool<class_bool>` = false\ ) |const| :ref:`🔗<class_PackedByteArray_method_decode_var_size>`
|
||
|
||
Видаляє розмір :ref:`Variant<class_Variant>` від байтів, починаючи від ``byte_offset``. Вимагає принаймні 4 байти даних, починаючи від офсету, інакше не виходить.
|
||
|
||
.. rst-class:: classref-item-separator
|
||
|
||
----
|
||
|
||
.. _class_PackedByteArray_method_decompress:
|
||
|
||
.. rst-class:: classref-method
|
||
|
||
:ref:`PackedByteArray<class_PackedByteArray>` **decompress**\ (\ buffer_size\: :ref:`int<class_int>`, compression_mode\: :ref:`int<class_int>` = 0\ ) |const| :ref:`🔗<class_PackedByteArray_method_decompress>`
|
||
|
||
Повертає нову **PackedByteArray** з декомпресованими даними. Встановіть ``buffer_size`` на розмір некомпресованих даних. Встановіть режим стиснення за допомогою одного з :ref:`CompressionMode<enum_FileAccess_CompressionMode>`\
|
||
|
||
\ **Примітка:** Декомпресія не гарантує роботу з даними, які не стиснені Godot, наприклад, якщо дані стиснені з режимом стиснення Deflate не вистачає чекусу або заголовка.
|
||
|
||
.. rst-class:: classref-item-separator
|
||
|
||
----
|
||
|
||
.. _class_PackedByteArray_method_decompress_dynamic:
|
||
|
||
.. rst-class:: classref-method
|
||
|
||
:ref:`PackedByteArray<class_PackedByteArray>` **decompress_dynamic**\ (\ max_output_size\: :ref:`int<class_int>`, compression_mode\: :ref:`int<class_int>` = 0\ ) |const| :ref:`🔗<class_PackedByteArray_method_decompress_dynamic>`
|
||
|
||
Повертає нову **PackedByteArray** з декомпресованими даними. Встановіть режим стиснення за допомогою одного з :ref:`CompressionMode<enum_FileAccess_CompressionMode>` **Цей метод приймає тільки brotli, gzip, і deflate стиснення режимів **\
|
||
|
||
Цей метод є потенційно повільним, ніж :ref:`decompress()<class_PackedByteArray_method_decompress>`, оскільки він може мати можливість перерозподілити його вихідний буфер кілька разів при декомппресуванні, тоді як :ref:`decompress()<class_PackedByteArray_method_decompress>` знає його вихідний розмір буфера від початку.
|
||
|
||
GZIP має максимальний коефіцієнт стиснення 1032:1, що означає, що це дуже можливо для невеликого компресованого корисного навантаження, щоб декомпресувати потенційно дуже великий вихід. Щоб охороняти це, ви можете забезпечити максимальний розмір цієї функції можна виділити в байтах за допомогою ``max_output_size``. Передача -1 дозволить непідйомний вихід. Якщо пропущено позитивне значення, а декомпресія перевищує суму в байтах, після чого буде повернена помилка.
|
||
|
||
\ **Примітка:** Декомпресія не гарантує роботу з даними, що не стиснені Godot, наприклад, якщо дані стиснені з режимом стиснення дефлата не вистачає чекусу або заголовка.
|
||
|
||
.. rst-class:: classref-item-separator
|
||
|
||
----
|
||
|
||
.. _class_PackedByteArray_method_duplicate:
|
||
|
||
.. rst-class:: classref-method
|
||
|
||
:ref:`PackedByteArray<class_PackedByteArray>` **duplicate**\ (\ ) |const| :ref:`🔗<class_PackedByteArray_method_duplicate>`
|
||
|
||
Створює копію масиву і повертає його.
|
||
|
||
.. rst-class:: classref-item-separator
|
||
|
||
----
|
||
|
||
.. _class_PackedByteArray_method_encode_double:
|
||
|
||
.. rst-class:: classref-method
|
||
|
||
|void| **encode_double**\ (\ byte_offset\: :ref:`int<class_int>`, value\: :ref:`float<class_float>`\ ) :ref:`🔗<class_PackedByteArray_method_encode_double>`
|
||
|
||
Кодує 64-розрядний плаваючий номер точки як байтів в індексі ``byte_offset`` байтів. масив повинен мати щонайменше 8 байтів виділеного простору, починаючи від офсету.
|
||
|
||
.. rst-class:: classref-item-separator
|
||
|
||
----
|
||
|
||
.. _class_PackedByteArray_method_encode_float:
|
||
|
||
.. rst-class:: classref-method
|
||
|
||
|void| **encode_float**\ (\ byte_offset\: :ref:`int<class_int>`, value\: :ref:`float<class_float>`\ ) :ref:`🔗<class_PackedByteArray_method_encode_float>`
|
||
|
||
Кодує 32-розрядний плаваючий номер точки як байтів в індексі ``byte_offset`` байтів. масив повинен мати щонайменше 4 байти простору, починаючи від офсету.
|
||
|
||
.. rst-class:: classref-item-separator
|
||
|
||
----
|
||
|
||
.. _class_PackedByteArray_method_encode_half:
|
||
|
||
.. rst-class:: classref-method
|
||
|
||
|void| **encode_half**\ (\ byte_offset\: :ref:`int<class_int>`, value\: :ref:`float<class_float>`\ ) :ref:`🔗<class_PackedByteArray_method_encode_half>`
|
||
|
||
Кодує 16-бітовий плаваючий номер точки як байтів в індексі ``byte_offset`` байтів. масив повинен мати щонайменше 2 байти простору, починаючи від офсету.
|
||
|
||
.. rst-class:: classref-item-separator
|
||
|
||
----
|
||
|
||
.. _class_PackedByteArray_method_encode_s8:
|
||
|
||
.. rst-class:: classref-method
|
||
|
||
|void| **encode_s8**\ (\ byte_offset\: :ref:`int<class_int>`, value\: :ref:`int<class_int>`\ ) :ref:`🔗<class_PackedByteArray_method_encode_s8>`
|
||
|
||
Кодує 8-біт, підписаний цілковитим числом (призначений байт) в індексі ``byte_offset`` байтів. масив повинен мати щонайменше 1 байт простору, починаючи від офсету.
|
||
|
||
.. rst-class:: classref-item-separator
|
||
|
||
----
|
||
|
||
.. _class_PackedByteArray_method_encode_s16:
|
||
|
||
.. rst-class:: classref-method
|
||
|
||
|void| **encode_s16**\ (\ byte_offset\: :ref:`int<class_int>`, value\: :ref:`int<class_int>`\ ) :ref:`🔗<class_PackedByteArray_method_encode_s16>`
|
||
|
||
Кодує 16-біт, підписаний цілим числом, як байтів в індексі ``byte_offset`` байтів. масив повинен мати щонайменше 2 байти простору, починаючи від офсету.
|
||
|
||
.. rst-class:: classref-item-separator
|
||
|
||
----
|
||
|
||
.. _class_PackedByteArray_method_encode_s32:
|
||
|
||
.. rst-class:: classref-method
|
||
|
||
|void| **encode_s32**\ (\ byte_offset\: :ref:`int<class_int>`, value\: :ref:`int<class_int>`\ ) :ref:`🔗<class_PackedByteArray_method_encode_s32>`
|
||
|
||
Коди 32-розрядного підписаного цілого числа як байтів в індексі ``byte_offset`` байтів. масив повинен мати щонайменше 4 байти простору, починаючи від офсету.
|
||
|
||
.. rst-class:: classref-item-separator
|
||
|
||
----
|
||
|
||
.. _class_PackedByteArray_method_encode_s64:
|
||
|
||
.. rst-class:: classref-method
|
||
|
||
|void| **encode_s64**\ (\ byte_offset\: :ref:`int<class_int>`, value\: :ref:`int<class_int>`\ ) :ref:`🔗<class_PackedByteArray_method_encode_s64>`
|
||
|
||
Коди 64-розрядного підписаного цілого числа як байтів в індексі ``byte_offset`` байтів. масив повинен мати щонайменше 8 байтів простору, починаючи від офсету.
|
||
|
||
.. rst-class:: classref-item-separator
|
||
|
||
----
|
||
|
||
.. _class_PackedByteArray_method_encode_u8:
|
||
|
||
.. rst-class:: classref-method
|
||
|
||
|void| **encode_u8**\ (\ byte_offset\: :ref:`int<class_int>`, value\: :ref:`int<class_int>`\ ) :ref:`🔗<class_PackedByteArray_method_encode_u8>`
|
||
|
||
Кодує 8-бітний не позначений число цілого (байт) в індексі ``byte_offset`` байтів. масив повинен мати щонайменше 1 байт простору, починаючи від офсету.
|
||
|
||
.. rst-class:: classref-item-separator
|
||
|
||
----
|
||
|
||
.. _class_PackedByteArray_method_encode_u16:
|
||
|
||
.. rst-class:: classref-method
|
||
|
||
|void| **encode_u16**\ (\ byte_offset\: :ref:`int<class_int>`, value\: :ref:`int<class_int>`\ ) :ref:`🔗<class_PackedByteArray_method_encode_u16>`
|
||
|
||
Коди 16-біту не позначено ціле число як байтів в індексі ``byte_offset`` байтів. масив повинен мати щонайменше 2 байти простору, починаючи від офсету.
|
||
|
||
.. rst-class:: classref-item-separator
|
||
|
||
----
|
||
|
||
.. _class_PackedByteArray_method_encode_u32:
|
||
|
||
.. rst-class:: classref-method
|
||
|
||
|void| **encode_u32**\ (\ byte_offset\: :ref:`int<class_int>`, value\: :ref:`int<class_int>`\ ) :ref:`🔗<class_PackedByteArray_method_encode_u32>`
|
||
|
||
Коди 32-bit не позначено ціле число як байтів в індексі ``byte_offset`` байтів. масив повинен мати щонайменше 4 байти простору, починаючи від офсету.
|
||
|
||
.. rst-class:: classref-item-separator
|
||
|
||
----
|
||
|
||
.. _class_PackedByteArray_method_encode_u64:
|
||
|
||
.. rst-class:: classref-method
|
||
|
||
|void| **encode_u64**\ (\ byte_offset\: :ref:`int<class_int>`, value\: :ref:`int<class_int>`\ ) :ref:`🔗<class_PackedByteArray_method_encode_u64>`
|
||
|
||
Коди 64-розрядного цілого числа як байтів в індексі ``byte_offset`` байтів. масив повинен мати щонайменше 8 байтів простору, починаючи від офсету.
|
||
|
||
.. rst-class:: classref-item-separator
|
||
|
||
----
|
||
|
||
.. _class_PackedByteArray_method_encode_var:
|
||
|
||
.. rst-class:: classref-method
|
||
|
||
:ref:`int<class_int>` **encode_var**\ (\ byte_offset\: :ref:`int<class_int>`, value\: :ref:`Variant<class_Variant>`, allow_objects\: :ref:`bool<class_bool>` = false\ ) :ref:`🔗<class_PackedByteArray_method_encode_var>`
|
||
|
||
Коди :ref:`Variant<class_Variant>` в індексі ``byte_offset`` байтів. Приблизний простір повинен бути виділений в залежності від розміру закодованого варіанту. Якщо ``allow_objects`` є ``false``, :ref:`Object<class_Object>`-derived значення не дозволені, а замість того, як він послідовний як ID-only.
|
||
|
||
.. rst-class:: classref-item-separator
|
||
|
||
----
|
||
|
||
.. _class_PackedByteArray_method_erase:
|
||
|
||
.. rst-class:: classref-method
|
||
|
||
:ref:`bool<class_bool>` **erase**\ (\ value\: :ref:`int<class_int>`\ ) :ref:`🔗<class_PackedByteArray_method_erase>`
|
||
|
||
Видаляє перше входження значення з масиву та повертає ``true``. Якщо значення не існує в масиві, нічого не відбувається, і повертається ``false``. Щоб видалити елемент за індексом, використовуйте метод :ref:`remove_at()<class_PackedByteArray_method_remove_at>`.
|
||
|
||
.. rst-class:: classref-item-separator
|
||
|
||
----
|
||
|
||
.. _class_PackedByteArray_method_fill:
|
||
|
||
.. rst-class:: classref-method
|
||
|
||
|void| **fill**\ (\ value\: :ref:`int<class_int>`\ ) :ref:`🔗<class_PackedByteArray_method_fill>`
|
||
|
||
Присвоює задане значення всім елементам масиву. Зазвичай це можна використовувати разом з :ref:`resize()<class_PackedByteArray_method_resize>` для створення масиву заданого розміру та ініціалізованих елементів.
|
||
|
||
.. rst-class:: classref-item-separator
|
||
|
||
----
|
||
|
||
.. _class_PackedByteArray_method_find:
|
||
|
||
.. rst-class:: classref-method
|
||
|
||
:ref:`int<class_int>` **find**\ (\ value\: :ref:`int<class_int>`, from\: :ref:`int<class_int>` = 0\ ) |const| :ref:`🔗<class_PackedByteArray_method_find>`
|
||
|
||
Шукає в масиві значення і повертає його індекс або ``-1``, якщо таке не знайдено. За бажанням можна передати початковий індекс пошуку.
|
||
|
||
.. rst-class:: classref-item-separator
|
||
|
||
----
|
||
|
||
.. _class_PackedByteArray_method_get:
|
||
|
||
.. rst-class:: classref-method
|
||
|
||
:ref:`int<class_int>` **get**\ (\ index\: :ref:`int<class_int>`\ ) |const| :ref:`🔗<class_PackedByteArray_method_get>`
|
||
|
||
Returns the byte at the given ``index`` in the array. If ``index`` is out-of-bounds or negative, this method fails and returns ``0``.
|
||
|
||
This method is similar (but not identical) to the ``[]`` operator. Most notably, when this method fails, it doesn't pause project execution if run from the editor.
|
||
|
||
.. rst-class:: classref-item-separator
|
||
|
||
----
|
||
|
||
.. _class_PackedByteArray_method_get_string_from_ascii:
|
||
|
||
.. rst-class:: classref-method
|
||
|
||
:ref:`String<class_String>` **get_string_from_ascii**\ (\ ) |const| :ref:`🔗<class_PackedByteArray_method_get_string_from_ascii>`
|
||
|
||
Перетворює ASCII/Latin-1 кодований масив :ref:`String<class_String>`. Швидка альтернатива :ref:`get_string_from_utf8()<class_PackedByteArray_method_get_string_from_utf8>` якщо вміст ASCII/Latin-1 тільки. На відміну від функції UTF-8, ця функція малює кожну байт до персонажа в масиві. Багатобайтні послідовності не будуть тлумачені правильно. Для входу користувача завжди використовуйте :ref:`get_string_from_utf8()<class_PackedByteArray_method_get_string_from_utf8>`. Це вірші :ref:`String.to_ascii_buffer()<class_String_method_to_ascii_buffer>`.
|
||
|
||
.. rst-class:: classref-item-separator
|
||
|
||
----
|
||
|
||
.. _class_PackedByteArray_method_get_string_from_multibyte_char:
|
||
|
||
.. rst-class:: classref-method
|
||
|
||
:ref:`String<class_String>` **get_string_from_multibyte_char**\ (\ encoding\: :ref:`String<class_String>` = ""\ ) |const| :ref:`🔗<class_PackedByteArray_method_get_string_from_multibyte_char>`
|
||
|
||
Перетворює системний масив, закодований багатобайтовими кодовими сторінками, на :ref:`String<class_String>`. Якщо перетворення не вдається, повертається порожній рядок. Це обернена дія до :ref:`String.to_multibyte_char_buffer()<class_String_method_to_multibyte_char_buffer>`.
|
||
|
||
Дозволені значення для ``encoding`` залежать від системи. Якщо ``encoding`` є порожнім рядком, використовується системне кодування за замовчуванням.
|
||
|
||
- Для Windows див. `Ідентифікатори кодових сторінок <https://learn.microsoft.com/en-us/windows/win32/Intl/code-page-identifiers>`__ імена .NET.
|
||
|
||
- Для macOS та Linux/BSD див. документацію до бібліотеки ``libiconv`` та ``iconv --list`` для списку підтримуваних кодувань.
|
||
|
||
.. rst-class:: classref-item-separator
|
||
|
||
----
|
||
|
||
.. _class_PackedByteArray_method_get_string_from_utf8:
|
||
|
||
.. rst-class:: classref-method
|
||
|
||
:ref:`String<class_String>` **get_string_from_utf8**\ (\ ) |const| :ref:`🔗<class_PackedByteArray_method_get_string_from_utf8>`
|
||
|
||
Перетворює масив у кодуванні UTF-8 на :ref:`String<class_String>`. Повільніше, ніж :ref:`get_string_from_ascii()<class_PackedByteArray_method_get_string_from_ascii>`, але підтримує дані в кодуванні UTF-8. Використовуйте цю функцію, якщо ви не впевнені щодо джерела даних. Для введення користувачем цій функції завжди слід надавати перевагу. Повертає порожній рядок, якщо вихідний масив не є дійсним рядком UTF-8. Це зворотний метод :ref:`String.to_utf8_buffer()<class_String_method_to_utf8_buffer>`.
|
||
|
||
.. rst-class:: classref-item-separator
|
||
|
||
----
|
||
|
||
.. _class_PackedByteArray_method_get_string_from_utf16:
|
||
|
||
.. rst-class:: classref-method
|
||
|
||
:ref:`String<class_String>` **get_string_from_utf16**\ (\ ) |const| :ref:`🔗<class_PackedByteArray_method_get_string_from_utf16>`
|
||
|
||
Перетворює масив у кодуванні UTF-16 на :ref:`String<class_String>`. Якщо BOM відсутній, передбачається прямий порядок байтів. Повертає порожній рядок, якщо вихідний масив не є коректним рядком UTF-16. Це інверсія методу :ref:`String.to_utf16_buffer()<class_String_method_to_utf16_buffer>`.
|
||
|
||
.. rst-class:: classref-item-separator
|
||
|
||
----
|
||
|
||
.. _class_PackedByteArray_method_get_string_from_utf32:
|
||
|
||
.. rst-class:: classref-method
|
||
|
||
:ref:`String<class_String>` **get_string_from_utf32**\ (\ ) |const| :ref:`🔗<class_PackedByteArray_method_get_string_from_utf32>`
|
||
|
||
Перетворює масив у кодуванні UTF-32 на :ref:`String<class_String>`. Повертає порожній рядок, якщо вихідний масив не є коректним рядком UTF-32. Це обернена дія. :ref:`String.to_utf32_buffer()<class_String_method_to_utf32_buffer>`.
|
||
|
||
.. rst-class:: classref-item-separator
|
||
|
||
----
|
||
|
||
.. _class_PackedByteArray_method_get_string_from_wchar:
|
||
|
||
.. rst-class:: classref-method
|
||
|
||
:ref:`String<class_String>` **get_string_from_wchar**\ (\ ) |const| :ref:`🔗<class_PackedByteArray_method_get_string_from_wchar>`
|
||
|
||
Перетворює широкий характер (``wchar_t``, UTF-16 на Windows, UTF-32 на інших платформах) закодовано масив :ref:`String<class_String>`. Повертає порожній рядок, якщо вихідний масив не діє широкий рядок. Це інверс :ref:`String.to_wchar_buffer()<class_String_method_to_wchar_buffer>`.
|
||
|
||
.. rst-class:: classref-item-separator
|
||
|
||
----
|
||
|
||
.. _class_PackedByteArray_method_has:
|
||
|
||
.. rst-class:: classref-method
|
||
|
||
:ref:`bool<class_bool>` **has**\ (\ value\: :ref:`int<class_int>`\ ) |const| :ref:`🔗<class_PackedByteArray_method_has>`
|
||
|
||
Повертає ``true``, якщо масив містить ``value``.
|
||
|
||
.. rst-class:: classref-item-separator
|
||
|
||
----
|
||
|
||
.. _class_PackedByteArray_method_has_encoded_var:
|
||
|
||
.. rst-class:: classref-method
|
||
|
||
:ref:`bool<class_bool>` **has_encoded_var**\ (\ byte_offset\: :ref:`int<class_int>`, allow_objects\: :ref:`bool<class_bool>` = false\ ) |const| :ref:`🔗<class_PackedByteArray_method_has_encoded_var>`
|
||
|
||
Повернення ``true``, якщо дійсна :ref:`Variant<class_Variant>` значення може бути вилучена в ``byte_offset``. ``false`` інакше або коли значення :ref:`Object<class_Object>`-derived і ``allow_objects`` ``false``.
|
||
|
||
.. rst-class:: classref-item-separator
|
||
|
||
----
|
||
|
||
.. _class_PackedByteArray_method_hex_encode:
|
||
|
||
.. rst-class:: classref-method
|
||
|
||
:ref:`String<class_String>` **hex_encode**\ (\ ) |const| :ref:`🔗<class_PackedByteArray_method_hex_encode>`
|
||
|
||
Повертає шістнадцяткове представлення цього масиву як :ref:`String<class_String>`.
|
||
|
||
|
||
.. tabs::
|
||
|
||
.. code-tab:: gdscript
|
||
|
||
var array = PackedByteArray([11, 46, 255])
|
||
print(array.hex_encode()) # Виводить "0b2eff"
|
||
|
||
.. code-tab:: csharp
|
||
|
||
byte[] array = [11, 46, 255];
|
||
GD.Print(array.HexEncode()); // Виводить "0b2eff"
|
||
|
||
|
||
|
||
.. rst-class:: classref-item-separator
|
||
|
||
----
|
||
|
||
.. _class_PackedByteArray_method_insert:
|
||
|
||
.. rst-class:: classref-method
|
||
|
||
:ref:`int<class_int>` **insert**\ (\ at_index\: :ref:`int<class_int>`, value\: :ref:`int<class_int>`\ ) :ref:`🔗<class_PackedByteArray_method_insert>`
|
||
|
||
Вставте новий елемент на даній позиції в масиві. Посада повинна бути дійсна, або в кінці масиву (``idx == розмір()``).
|
||
|
||
.. rst-class:: classref-item-separator
|
||
|
||
----
|
||
|
||
.. _class_PackedByteArray_method_is_empty:
|
||
|
||
.. rst-class:: classref-method
|
||
|
||
:ref:`bool<class_bool>` **is_empty**\ (\ ) |const| :ref:`🔗<class_PackedByteArray_method_is_empty>`
|
||
|
||
Повертає ``true``, якщо масив порожній.
|
||
|
||
.. rst-class:: classref-item-separator
|
||
|
||
----
|
||
|
||
.. _class_PackedByteArray_method_push_back:
|
||
|
||
.. rst-class:: classref-method
|
||
|
||
:ref:`bool<class_bool>` **push_back**\ (\ value\: :ref:`int<class_int>`\ ) :ref:`🔗<class_PackedByteArray_method_push_back>`
|
||
|
||
Додаток елемента в кінці масиву.
|
||
|
||
.. rst-class:: classref-item-separator
|
||
|
||
----
|
||
|
||
.. _class_PackedByteArray_method_remove_at:
|
||
|
||
.. rst-class:: classref-method
|
||
|
||
|void| **remove_at**\ (\ index\: :ref:`int<class_int>`\ ) :ref:`🔗<class_PackedByteArray_method_remove_at>`
|
||
|
||
Видаляє елемент з масиву за індексом.
|
||
|
||
.. rst-class:: classref-item-separator
|
||
|
||
----
|
||
|
||
.. _class_PackedByteArray_method_resize:
|
||
|
||
.. rst-class:: classref-method
|
||
|
||
:ref:`int<class_int>` **resize**\ (\ new_size\: :ref:`int<class_int>`\ ) :ref:`🔗<class_PackedByteArray_method_resize>`
|
||
|
||
Встановлює розмір масиву. Якщо масив збільшується, резервує елементи в кінці масиву. Якщо масив скорочується, обрізає масив до нового розміру. Виклик методу :ref:`resize()<class_PackedByteArray_method_resize>` один раз і призначення нових значень відбувається швидше, ніж додавання нових елементів по одному.
|
||
|
||
Повертає :ref:`@GlobalScope.OK<class_@GlobalScope_constant_OK>` у разі успіху або одну з наступних констант :ref:`Error<enum_@GlobalScope_Error>`, якщо цей метод не працює: :ref:`@GlobalScope.ERR_INVALID_PARAMETER<class_@GlobalScope_constant_ERR_INVALID_PARAMETER>`, якщо розмір від'ємний, або :ref:`@GlobalScope.ERR_OUT_OF_MEMORY<class_@GlobalScope_constant_ERR_OUT_OF_MEMORY>`, якщо розподіл пам'яті не вдається. Використовуйте метод :ref:`size()<class_PackedByteArray_method_size>`, щоб знайти фактичний розмір масиву після зміни розміру.
|
||
|
||
.. rst-class:: classref-item-separator
|
||
|
||
----
|
||
|
||
.. _class_PackedByteArray_method_reverse:
|
||
|
||
.. rst-class:: classref-method
|
||
|
||
|void| **reverse**\ (\ ) :ref:`🔗<class_PackedByteArray_method_reverse>`
|
||
|
||
Змінює порядок елементів у масиві на протилежний.
|
||
|
||
.. rst-class:: classref-item-separator
|
||
|
||
----
|
||
|
||
.. _class_PackedByteArray_method_rfind:
|
||
|
||
.. rst-class:: classref-method
|
||
|
||
:ref:`int<class_int>` **rfind**\ (\ value\: :ref:`int<class_int>`, from\: :ref:`int<class_int>` = -1\ ) |const| :ref:`🔗<class_PackedByteArray_method_rfind>`
|
||
|
||
Здійснює пошук у масиві у зворотному порядку. За бажанням можна передати початковий індекс пошуку. Якщо він від'ємний, то початковий індекс береться відносно кінця масиву.
|
||
|
||
.. rst-class:: classref-item-separator
|
||
|
||
----
|
||
|
||
.. _class_PackedByteArray_method_set:
|
||
|
||
.. rst-class:: classref-method
|
||
|
||
|void| **set**\ (\ index\: :ref:`int<class_int>`, value\: :ref:`int<class_int>`\ ) :ref:`🔗<class_PackedByteArray_method_set>`
|
||
|
||
Змінює байт за вказаним індексом.
|
||
|
||
.. rst-class:: classref-item-separator
|
||
|
||
----
|
||
|
||
.. _class_PackedByteArray_method_size:
|
||
|
||
.. rst-class:: classref-method
|
||
|
||
:ref:`int<class_int>` **size**\ (\ ) |const| :ref:`🔗<class_PackedByteArray_method_size>`
|
||
|
||
Повертає кількість елементів у масиві.
|
||
|
||
.. rst-class:: classref-item-separator
|
||
|
||
----
|
||
|
||
.. _class_PackedByteArray_method_slice:
|
||
|
||
.. rst-class:: classref-method
|
||
|
||
:ref:`PackedByteArray<class_PackedByteArray>` **slice**\ (\ begin\: :ref:`int<class_int>`, end\: :ref:`int<class_int>` = 2147483647\ ) |const| :ref:`🔗<class_PackedByteArray_method_slice>`
|
||
|
||
Повертає розріз **PackedByteArray**, з ``start`` (включно) до ``end`` (виключно), як новий **PackedByteArray**.
|
||
|
||
Абсолютне значення ``start`` і ``end`` буде зафіксовано до розміру масиву, тому значення за замовчуванням для ``end`` робить кінець розрізу кінцем масиву за замовчуванням (тобто ``arr.slice(1)`` є скороченим записом для ``arr.slice(1, arr.size())``).
|
||
|
||
Якщо ж ``start`` або ``end`` є негативними, вони будуть відносно кінця масиву (тобто ``arr.slice(0, -2)`` є скороченим записом для ``arr.slice(0, arr.size() - 2)``).
|
||
|
||
.. rst-class:: classref-item-separator
|
||
|
||
----
|
||
|
||
.. _class_PackedByteArray_method_sort:
|
||
|
||
.. rst-class:: classref-method
|
||
|
||
|void| **sort**\ (\ ) :ref:`🔗<class_PackedByteArray_method_sort>`
|
||
|
||
Сорти елементів масиву в порядку закріплення.
|
||
|
||
.. rst-class:: classref-item-separator
|
||
|
||
----
|
||
|
||
.. _class_PackedByteArray_method_to_color_array:
|
||
|
||
.. rst-class:: classref-method
|
||
|
||
:ref:`PackedColorArray<class_PackedColorArray>` **to_color_array**\ (\ ) |const| :ref:`🔗<class_PackedByteArray_method_to_color_array>`
|
||
|
||
Повертає копію даних, перетворених на :ref:`PackedColorArray<class_PackedColorArray>`, де кожен блок з 16 байтів було перетворено на варіант :ref:`Color<class_Color>`.
|
||
|
||
\ **Примітка:** Розмір вхідного масиву має бути кратним 16 (розмір чотирьох 32-бітних змінних з плаваючою комою). Розмір нового масиву буде ``byte_array.size() / 16``. Якщо вихідні дані неможливо перетворити на варіанти :ref:`Color<class_Color>`, результуючі дані будуть невизначеними.
|
||
|
||
.. rst-class:: classref-item-separator
|
||
|
||
----
|
||
|
||
.. _class_PackedByteArray_method_to_float32_array:
|
||
|
||
.. rst-class:: classref-method
|
||
|
||
:ref:`PackedFloat32Array<class_PackedFloat32Array>` **to_float32_array**\ (\ ) |const| :ref:`🔗<class_PackedByteArray_method_to_float32_array>`
|
||
|
||
Повертає копію даних, що перетворюються на :ref:`PackedFloat32Array<class_PackedFloat32Array>`, де кожен блок 4 байтів перетворений на 32-бітну плавку (C++ ``]float``).
|
||
|
||
Розмір вхідного масиву повинен бути декількома з 4 (розмір 32-bit float). Розмір нового масиву буде ``byte_array.size() / 4``.
|
||
|
||
Якщо оригінальні дані не можуть бути перетворені на 32-розрядні плавки, отримані дані не визначені.
|
||
|
||
.. rst-class:: classref-item-separator
|
||
|
||
----
|
||
|
||
.. _class_PackedByteArray_method_to_float64_array:
|
||
|
||
.. rst-class:: classref-method
|
||
|
||
:ref:`PackedFloat64Array<class_PackedFloat64Array>` **to_float64_array**\ (\ ) |const| :ref:`🔗<class_PackedByteArray_method_to_float64_array>`
|
||
|
||
Повертає копію даних, що перетворюються на :ref:`PackedFloat64Array<class_PackedFloat64Array>`, де кожен блок 8 байтів перетворений на 64-бітну плавучу (C++ ``double``, Godot :ref:`float<class_float>`).
|
||
|
||
Розмір вхідного масиву повинен бути декількома з 8 (розмір 64-розрядного подвійний). Розмір нового масиву буде ``byte_array.size() / 8``.
|
||
|
||
Якщо оригінальні дані не можуть бути перетворені на 64-розрядні плавки, отримані дані не визначені.
|
||
|
||
.. rst-class:: classref-item-separator
|
||
|
||
----
|
||
|
||
.. _class_PackedByteArray_method_to_int32_array:
|
||
|
||
.. rst-class:: classref-method
|
||
|
||
:ref:`PackedInt32Array<class_PackedInt32Array>` **to_int32_array**\ (\ ) |const| :ref:`🔗<class_PackedByteArray_method_to_int32_array>`
|
||
|
||
Повертає копію даних, що перетворюються на :ref:`PackedInt32Array<class_PackedInt32Array>`, де кожен блок 4 байтів перетворений на підписане 32-бітне ціле (C++ ``int32_t``).
|
||
|
||
Розмір вхідного масиву повинен бути декількома з 4 (розмір 32-бітного цілого). Розмір нового масиву буде ``byte_array.size() / 4``.
|
||
|
||
Якщо оригінальні дані не можуть бути перетворені на підписані 32-бітні цілі, отримані дані не визначені.
|
||
|
||
.. rst-class:: classref-item-separator
|
||
|
||
----
|
||
|
||
.. _class_PackedByteArray_method_to_int64_array:
|
||
|
||
.. rst-class:: classref-method
|
||
|
||
:ref:`PackedInt64Array<class_PackedInt64Array>` **to_int64_array**\ (\ ) |const| :ref:`🔗<class_PackedByteArray_method_to_int64_array>`
|
||
|
||
Повертає копію даних, що перетворюються на :ref:`PackedInt64Array<class_PackedInt64Array>`, де кожен блок 8 байтів перетворено на підписане число 64-біт (C++ ``int64_t``, Godot :ref:`int<class_int>`.
|
||
|
||
Розмір вхідного масиву повинен бути декількома з 8 (розмір 64-бітного цілого). Розмір нового масиву буде ``byte_array.size() / 8``.
|
||
|
||
Якщо оригінальні дані не можуть бути перетворені на підписані 64-розрядні цілі, отримані дані не визначені.
|
||
|
||
.. rst-class:: classref-item-separator
|
||
|
||
----
|
||
|
||
.. _class_PackedByteArray_method_to_vector2_array:
|
||
|
||
.. rst-class:: classref-method
|
||
|
||
:ref:`PackedVector2Array<class_PackedVector2Array>` **to_vector2_array**\ (\ ) |const| :ref:`🔗<class_PackedByteArray_method_to_vector2_array>`
|
||
|
||
Повертає копію даних, перетворених на :ref:`PackedVector2Array<class_PackedVector2Array>`, де кожен блок з 8 байт або 16 байт (32-бітний або 64-бітний) був перетворений на варіант :ref:`Vector2<class_Vector2>`.
|
||
|
||
\ **Примітка:** Розмір вхідного масиву має бути кратним 8 або 16 (залежно від налаштувань збірки, див. :ref:`Vector2<class_Vector2>` для отримання додаткової інформації). Розмір нового масиву буде ``byte_array.size() / (8 або 16)``. Якщо вихідні дані не можна перетворити на варіанти :ref:`Vector2<class_Vector2>`, результуючі дані будуть невизначеними.
|
||
|
||
.. rst-class:: classref-item-separator
|
||
|
||
----
|
||
|
||
.. _class_PackedByteArray_method_to_vector3_array:
|
||
|
||
.. rst-class:: classref-method
|
||
|
||
:ref:`PackedVector3Array<class_PackedVector3Array>` **to_vector3_array**\ (\ ) |const| :ref:`🔗<class_PackedByteArray_method_to_vector3_array>`
|
||
|
||
Повертає копію даних, перетворених на :ref:`PackedVector3Array<class_PackedVector3Array>`, де кожен блок з 12 або 24 байтів (32-бітний або 64-бітний) був перетворений на варіант :ref:`Vector3<class_Vector3>`.
|
||
|
||
\ **Примітка:** Розмір вхідного масиву має бути кратним 12 або 24 (залежно від налаштувань збірки, див. :ref:`Vector3<class_Vector3>` для отримання додаткової інформації). Розмір нового масиву буде ``byte_array.size() / (12 або 24)``. Якщо вихідні дані не можна перетворити на варіанти :ref:`Vector3<class_Vector3>`, результуючі дані є невизначеними.
|
||
|
||
.. rst-class:: classref-item-separator
|
||
|
||
----
|
||
|
||
.. _class_PackedByteArray_method_to_vector4_array:
|
||
|
||
.. rst-class:: classref-method
|
||
|
||
:ref:`PackedVector4Array<class_PackedVector4Array>` **to_vector4_array**\ (\ ) |const| :ref:`🔗<class_PackedByteArray_method_to_vector4_array>`
|
||
|
||
Повертає копію даних, перетворених на :ref:`PackedVector4Array<class_PackedVector4Array>`, де кожен блок з 16 або 32 байтів (32-бітний або 64-бітний) був перетворений на варіант :ref:`Vector4<class_Vector4>`.
|
||
|
||
\ **Примітка:** Розмір вхідного масиву має бути кратним 16 або 32 (залежно від налаштувань збірки, див. :ref:`Vector4<class_Vector4>` для отримання додаткової інформації). Розмір нового масиву буде ``byte_array.size() / (16 або 32)``. Якщо вихідні дані не можна перетворити на варіанти :ref:`Vector4<class_Vector4>`, результуючі дані є невизначеними.
|
||
|
||
.. rst-class:: classref-section-separator
|
||
|
||
----
|
||
|
||
.. rst-class:: classref-descriptions-group
|
||
|
||
Описи операторів
|
||
--------------------------------
|
||
|
||
.. _class_PackedByteArray_operator_neq_PackedByteArray:
|
||
|
||
.. rst-class:: classref-operator
|
||
|
||
:ref:`bool<class_bool>` **operator !=**\ (\ right\: :ref:`PackedByteArray<class_PackedByteArray>`\ ) :ref:`🔗<class_PackedByteArray_operator_neq_PackedByteArray>`
|
||
|
||
Повертає ``true``, якщо вміст масивів відрізняється.
|
||
|
||
.. rst-class:: classref-item-separator
|
||
|
||
----
|
||
|
||
.. _class_PackedByteArray_operator_sum_PackedByteArray:
|
||
|
||
.. rst-class:: classref-operator
|
||
|
||
:ref:`PackedByteArray<class_PackedByteArray>` **operator +**\ (\ right\: :ref:`PackedByteArray<class_PackedByteArray>`\ ) :ref:`🔗<class_PackedByteArray_operator_sum_PackedByteArray>`
|
||
|
||
Повертає новий **PackedByteArray** з вмістом ``right`` додано в кінці цього масиву. Для кращої роботи розглянемо використання :ref:`append_array()<class_PackedByteArray_method_append_array>` замість.
|
||
|
||
.. rst-class:: classref-item-separator
|
||
|
||
----
|
||
|
||
.. _class_PackedByteArray_operator_eq_PackedByteArray:
|
||
|
||
.. rst-class:: classref-operator
|
||
|
||
:ref:`bool<class_bool>` **operator ==**\ (\ right\: :ref:`PackedByteArray<class_PackedByteArray>`\ ) :ref:`🔗<class_PackedByteArray_operator_eq_PackedByteArray>`
|
||
|
||
Повертає ``true``, якщо вміст обох масивів однаково, тобто вони мають всі рівні байти за відповідними показниками.
|
||
|
||
.. rst-class:: classref-item-separator
|
||
|
||
----
|
||
|
||
.. _class_PackedByteArray_operator_idx_int:
|
||
|
||
.. rst-class:: classref-operator
|
||
|
||
:ref:`int<class_int>` **operator []**\ (\ index\: :ref:`int<class_int>`\ ) :ref:`🔗<class_PackedByteArray_operator_idx_int>`
|
||
|
||
Повернення байтів за індексом ``index``. Негативні індекси можуть використовуватися для доступу до елементів з кінця. Використання індексу з меж масиву призведе до помилки.
|
||
|
||
Зауважте, що байт повертається як 64-розрядний.
|
||
|
||
.. |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 (Значення не повертається.)`
|