godotengine/godot-docs
1
0
Fork 0
mirror of https://github.com/godotengine/godot-docs.git synced 2025-12-31 17:49:03 +03:00
Code Issues Packages Projects Releases Wiki Activity

classref: Sync with current master branch (f87858a8f)

Browse Source
This commit is contained in:
Yuri Sizov
2022-12-05 20:38:58 +03:00
parent 913ff5e602
commit a7745c4cc4
843 changed files with 158186 additions and 80821 deletions
Download Patch File Download Diff File Expand all files Collapse all files

347
classes/class_packedvector2array.rst
View File

@@ -12,323 +12,470 @@ PackedVector2Array
A packed array of :ref:`Vector2<class_Vector2>`\ s.
.. rst-class:: classref-introduction-group
Description
-----------
An array specifically designed to hold :ref:`Vector2<class_Vector2>`. Packs data tightly, so it saves memory for large array sizes.
.. rst-class:: classref-introduction-group
Tutorials
---------
- `2D Navigation Astar Demo <https://godotengine.org/asset-library/asset/519>`__
.. rst-class:: classref-reftable-group
Constructors
------------
+-----------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`PackedVector2Array<class_PackedVector2Array>` | :ref:`PackedVector2Array<class_PackedVector2Array_constructor_PackedVector2Array>` **(** **)** |
+-----------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`PackedVector2Array<class_PackedVector2Array>` | :ref:`PackedVector2Array<class_PackedVector2Array_constructor_PackedVector2Array>` **(** :ref:`PackedVector2Array<class_PackedVector2Array>` from **)** |
+-----------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`PackedVector2Array<class_PackedVector2Array>` | :ref:`PackedVector2Array<class_PackedVector2Array_constructor_PackedVector2Array>` **(** :ref:`Array<class_Array>` from **)** |
+-----------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------+
.. table::
:widths: auto
+-----------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`PackedVector2Array<class_PackedVector2Array>` | :ref:`PackedVector2Array<class_PackedVector2Array_constructor_PackedVector2Array>` **(** **)** |
+-----------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`PackedVector2Array<class_PackedVector2Array>` | :ref:`PackedVector2Array<class_PackedVector2Array_constructor_PackedVector2Array>` **(** :ref:`PackedVector2Array<class_PackedVector2Array>` from **)** |
+-----------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`PackedVector2Array<class_PackedVector2Array>` | :ref:`PackedVector2Array<class_PackedVector2Array_constructor_PackedVector2Array>` **(** :ref:`Array<class_Array>` from **)** |
+-----------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------+
.. rst-class:: classref-reftable-group
Methods
-------
+-----------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`bool<class_bool>` | :ref:`append<class_PackedVector2Array_method_append>` **(** :ref:`Vector2<class_Vector2>` value **)** |
+-----------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------+
| void | :ref:`append_array<class_PackedVector2Array_method_append_array>` **(** :ref:`PackedVector2Array<class_PackedVector2Array>` array **)** |
+-----------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`int<class_int>` | :ref:`bsearch<class_PackedVector2Array_method_bsearch>` **(** :ref:`Vector2<class_Vector2>` value, :ref:`bool<class_bool>` before=true **)** |
+-----------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------+
| void | :ref:`clear<class_PackedVector2Array_method_clear>` **(** **)** |
+-----------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`int<class_int>` | :ref:`count<class_PackedVector2Array_method_count>` **(** :ref:`Vector2<class_Vector2>` value **)** |const| |
+-----------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`PackedVector2Array<class_PackedVector2Array>` | :ref:`duplicate<class_PackedVector2Array_method_duplicate>` **(** **)** |
+-----------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------+
| void | :ref:`fill<class_PackedVector2Array_method_fill>` **(** :ref:`Vector2<class_Vector2>` value **)** |
+-----------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`int<class_int>` | :ref:`find<class_PackedVector2Array_method_find>` **(** :ref:`Vector2<class_Vector2>` value, :ref:`int<class_int>` from=0 **)** |const| |
+-----------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`bool<class_bool>` | :ref:`has<class_PackedVector2Array_method_has>` **(** :ref:`Vector2<class_Vector2>` value **)** |const| |
+-----------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`int<class_int>` | :ref:`insert<class_PackedVector2Array_method_insert>` **(** :ref:`int<class_int>` at_index, :ref:`Vector2<class_Vector2>` value **)** |
+-----------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`bool<class_bool>` | :ref:`is_empty<class_PackedVector2Array_method_is_empty>` **(** **)** |const| |
+-----------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`bool<class_bool>` | :ref:`push_back<class_PackedVector2Array_method_push_back>` **(** :ref:`Vector2<class_Vector2>` value **)** |
+-----------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------+
| void | :ref:`remove_at<class_PackedVector2Array_method_remove_at>` **(** :ref:`int<class_int>` index **)** |
+-----------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`int<class_int>` | :ref:`resize<class_PackedVector2Array_method_resize>` **(** :ref:`int<class_int>` new_size **)** |
+-----------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------+
| void | :ref:`reverse<class_PackedVector2Array_method_reverse>` **(** **)** |
+-----------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`int<class_int>` | :ref:`rfind<class_PackedVector2Array_method_rfind>` **(** :ref:`Vector2<class_Vector2>` value, :ref:`int<class_int>` from=-1 **)** |const| |
+-----------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------+
| void | :ref:`set<class_PackedVector2Array_method_set>` **(** :ref:`int<class_int>` index, :ref:`Vector2<class_Vector2>` value **)** |
+-----------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`int<class_int>` | :ref:`size<class_PackedVector2Array_method_size>` **(** **)** |const| |
+-----------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`PackedVector2Array<class_PackedVector2Array>` | :ref:`slice<class_PackedVector2Array_method_slice>` **(** :ref:`int<class_int>` begin, :ref:`int<class_int>` end=2147483647 **)** |const| |
+-----------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------+
| void | :ref:`sort<class_PackedVector2Array_method_sort>` **(** **)** |
+-----------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`PackedByteArray<class_PackedByteArray>` | :ref:`to_byte_array<class_PackedVector2Array_method_to_byte_array>` **(** **)** |const| |
+-----------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------+
.. table::
:widths: auto
+-----------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`bool<class_bool>` | :ref:`append<class_PackedVector2Array_method_append>` **(** :ref:`Vector2<class_Vector2>` value **)** |
+-----------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------+
| void | :ref:`append_array<class_PackedVector2Array_method_append_array>` **(** :ref:`PackedVector2Array<class_PackedVector2Array>` array **)** |
+-----------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`int<class_int>` | :ref:`bsearch<class_PackedVector2Array_method_bsearch>` **(** :ref:`Vector2<class_Vector2>` value, :ref:`bool<class_bool>` before=true **)** |
+-----------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------+
| void | :ref:`clear<class_PackedVector2Array_method_clear>` **(** **)** |
+-----------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`int<class_int>` | :ref:`count<class_PackedVector2Array_method_count>` **(** :ref:`Vector2<class_Vector2>` value **)** |const| |
+-----------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`PackedVector2Array<class_PackedVector2Array>` | :ref:`duplicate<class_PackedVector2Array_method_duplicate>` **(** **)** |
+-----------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------+
| void | :ref:`fill<class_PackedVector2Array_method_fill>` **(** :ref:`Vector2<class_Vector2>` value **)** |
+-----------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`int<class_int>` | :ref:`find<class_PackedVector2Array_method_find>` **(** :ref:`Vector2<class_Vector2>` value, :ref:`int<class_int>` from=0 **)** |const| |
+-----------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`bool<class_bool>` | :ref:`has<class_PackedVector2Array_method_has>` **(** :ref:`Vector2<class_Vector2>` value **)** |const| |
+-----------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`int<class_int>` | :ref:`insert<class_PackedVector2Array_method_insert>` **(** :ref:`int<class_int>` at_index, :ref:`Vector2<class_Vector2>` value **)** |
+-----------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`bool<class_bool>` | :ref:`is_empty<class_PackedVector2Array_method_is_empty>` **(** **)** |const| |
+-----------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`bool<class_bool>` | :ref:`push_back<class_PackedVector2Array_method_push_back>` **(** :ref:`Vector2<class_Vector2>` value **)** |
+-----------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------+
| void | :ref:`remove_at<class_PackedVector2Array_method_remove_at>` **(** :ref:`int<class_int>` index **)** |
+-----------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`int<class_int>` | :ref:`resize<class_PackedVector2Array_method_resize>` **(** :ref:`int<class_int>` new_size **)** |
+-----------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------+
| void | :ref:`reverse<class_PackedVector2Array_method_reverse>` **(** **)** |
+-----------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`int<class_int>` | :ref:`rfind<class_PackedVector2Array_method_rfind>` **(** :ref:`Vector2<class_Vector2>` value, :ref:`int<class_int>` from=-1 **)** |const| |
+-----------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------+
| void | :ref:`set<class_PackedVector2Array_method_set>` **(** :ref:`int<class_int>` index, :ref:`Vector2<class_Vector2>` value **)** |
+-----------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`int<class_int>` | :ref:`size<class_PackedVector2Array_method_size>` **(** **)** |const| |
+-----------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`PackedVector2Array<class_PackedVector2Array>` | :ref:`slice<class_PackedVector2Array_method_slice>` **(** :ref:`int<class_int>` begin, :ref:`int<class_int>` end=2147483647 **)** |const| |
+-----------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------+
| void | :ref:`sort<class_PackedVector2Array_method_sort>` **(** **)** |
+-----------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`PackedByteArray<class_PackedByteArray>` | :ref:`to_byte_array<class_PackedVector2Array_method_to_byte_array>` **(** **)** |const| |
+-----------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------+
.. rst-class:: classref-reftable-group
Operators
---------
+-----------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`bool<class_bool>` | :ref:`operator !=<class_PackedVector2Array_operator_neq_bool>` **(** :ref:`PackedVector2Array<class_PackedVector2Array>` right **)** |
+-----------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`PackedVector2Array<class_PackedVector2Array>` | :ref:`operator *<class_PackedVector2Array_operator_mul_PackedVector2Array>` **(** :ref:`Transform2D<class_Transform2D>` right **)** |
+-----------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`PackedVector2Array<class_PackedVector2Array>` | :ref:`operator +<class_PackedVector2Array_operator_sum_PackedVector2Array>` **(** :ref:`PackedVector2Array<class_PackedVector2Array>` right **)** |
+-----------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`bool<class_bool>` | :ref:`operator ==<class_PackedVector2Array_operator_eq_bool>` **(** :ref:`PackedVector2Array<class_PackedVector2Array>` right **)** |
+-----------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Vector2<class_Vector2>` | :ref:`operator []<class_PackedVector2Array_operator_idx_Vector2>` **(** :ref:`int<class_int>` index **)** |
+-----------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------+
.. table::
:widths: auto
+-----------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`bool<class_bool>` | :ref:`operator !=<class_PackedVector2Array_operator_neq_PackedVector2Array>` **(** :ref:`PackedVector2Array<class_PackedVector2Array>` right **)** |
+-----------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`PackedVector2Array<class_PackedVector2Array>` | :ref:`operator *<class_PackedVector2Array_operator_mul_Transform2D>` **(** :ref:`Transform2D<class_Transform2D>` right **)** |
+-----------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`PackedVector2Array<class_PackedVector2Array>` | :ref:`operator +<class_PackedVector2Array_operator_sum_PackedVector2Array>` **(** :ref:`PackedVector2Array<class_PackedVector2Array>` right **)** |
+-----------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`bool<class_bool>` | :ref:`operator ==<class_PackedVector2Array_operator_eq_PackedVector2Array>` **(** :ref:`PackedVector2Array<class_PackedVector2Array>` right **)** |
+-----------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Vector2<class_Vector2>` | :ref:`operator []<class_PackedVector2Array_operator_idx_int>` **(** :ref:`int<class_int>` index **)** |
+-----------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------+
.. rst-class:: classref-section-separator
----
.. rst-class:: classref-descriptions-group
Constructor Descriptions
------------------------
.. _class_PackedVector2Array_constructor_PackedVector2Array:
- :ref:`PackedVector2Array<class_PackedVector2Array>` **PackedVector2Array** **(** **)**
.. rst-class:: classref-constructor
Constructs an empty ``PackedVector2Array``.
:ref:`PackedVector2Array<class_PackedVector2Array>` **PackedVector2Array** **(** **)**
Constructs an empty **PackedVector2Array**.
.. rst-class:: classref-item-separator
----
- :ref:`PackedVector2Array<class_PackedVector2Array>` **PackedVector2Array** **(** :ref:`PackedVector2Array<class_PackedVector2Array>` from **)**
.. rst-class:: classref-constructor
Constructs a ``PackedVector2Array`` as a copy of the given ``PackedVector2Array``.
:ref:`PackedVector2Array<class_PackedVector2Array>` **PackedVector2Array** **(** :ref:`PackedVector2Array<class_PackedVector2Array>` from **)**
Constructs a **PackedVector2Array** as a copy of the given **PackedVector2Array**.
.. rst-class:: classref-item-separator
----
- :ref:`PackedVector2Array<class_PackedVector2Array>` **PackedVector2Array** **(** :ref:`Array<class_Array>` from **)**
.. rst-class:: classref-constructor
Constructs a new ``PackedVector2Array``. Optionally, you can pass in a generic :ref:`Array<class_Array>` that will be converted.
:ref:`PackedVector2Array<class_PackedVector2Array>` **PackedVector2Array** **(** :ref:`Array<class_Array>` from **)**
Constructs a new **PackedVector2Array**. Optionally, you can pass in a generic :ref:`Array<class_Array>` that will be converted.
.. rst-class:: classref-section-separator
----
.. rst-class:: classref-descriptions-group
Method Descriptions
-------------------
.. _class_PackedVector2Array_method_append:
- :ref:`bool<class_bool>` **append** **(** :ref:`Vector2<class_Vector2>` value **)**
.. rst-class:: classref-method
:ref:`bool<class_bool>` **append** **(** :ref:`Vector2<class_Vector2>` value **)**
Appends an element at the end of the array (alias of :ref:`push_back<class_PackedVector2Array_method_push_back>`).
.. rst-class:: classref-item-separator
----
.. _class_PackedVector2Array_method_append_array:
- void **append_array** **(** :ref:`PackedVector2Array<class_PackedVector2Array>` array **)**
.. rst-class:: classref-method
Appends a ``PackedVector2Array`` at the end of this array.
void **append_array** **(** :ref:`PackedVector2Array<class_PackedVector2Array>` array **)**
Appends a **PackedVector2Array** at the end of this array.
.. rst-class:: classref-item-separator
----
.. _class_PackedVector2Array_method_bsearch:
- :ref:`int<class_int>` **bsearch** **(** :ref:`Vector2<class_Vector2>` value, :ref:`bool<class_bool>` before=true **)**
.. rst-class:: classref-method
:ref:`int<class_int>` **bsearch** **(** :ref:`Vector2<class_Vector2>` value, :ref:`bool<class_bool>` before=true **)**
Finds the index of an existing value (or the insertion index that maintains sorting order, if the value is not yet present in the array) using binary search. Optionally, a ``before`` specifier can be passed. If ``false``, the returned index comes after all existing entries of the value in the array.
\ **Note:** Calling :ref:`bsearch<class_PackedVector2Array_method_bsearch>` on an unsorted array results in unexpected behavior.
.. rst-class:: classref-item-separator
----
.. _class_PackedVector2Array_method_clear:
- void **clear** **(** **)**
.. rst-class:: classref-method
void **clear** **(** **)**
Clears the array. This is equivalent to using :ref:`resize<class_PackedVector2Array_method_resize>` with a size of ``0``.
.. rst-class:: classref-item-separator
----
.. _class_PackedVector2Array_method_count:
- :ref:`int<class_int>` **count** **(** :ref:`Vector2<class_Vector2>` value **)** |const|
.. rst-class:: classref-method
:ref:`int<class_int>` **count** **(** :ref:`Vector2<class_Vector2>` value **)** |const|
Returns the number of times an element is in the array.
.. rst-class:: classref-item-separator
----
.. _class_PackedVector2Array_method_duplicate:
- :ref:`PackedVector2Array<class_PackedVector2Array>` **duplicate** **(** **)**
.. rst-class:: classref-method
:ref:`PackedVector2Array<class_PackedVector2Array>` **duplicate** **(** **)**
Creates a copy of the array, and returns it.
.. rst-class:: classref-item-separator
----
.. _class_PackedVector2Array_method_fill:
- void **fill** **(** :ref:`Vector2<class_Vector2>` value **)**
.. rst-class:: classref-method
void **fill** **(** :ref:`Vector2<class_Vector2>` value **)**
Assigns the given value to all elements in the array. This can typically be used together with :ref:`resize<class_PackedVector2Array_method_resize>` to create an array with a given size and initialized elements.
.. rst-class:: classref-item-separator
----
.. _class_PackedVector2Array_method_find:
- :ref:`int<class_int>` **find** **(** :ref:`Vector2<class_Vector2>` value, :ref:`int<class_int>` from=0 **)** |const|
.. rst-class:: classref-method
:ref:`int<class_int>` **find** **(** :ref:`Vector2<class_Vector2>` value, :ref:`int<class_int>` from=0 **)** |const|
Searches the array for a value and returns its index or ``-1`` if not found. Optionally, the initial search index can be passed.
.. rst-class:: classref-item-separator
----
.. _class_PackedVector2Array_method_has:
- :ref:`bool<class_bool>` **has** **(** :ref:`Vector2<class_Vector2>` value **)** |const|
.. rst-class:: classref-method
:ref:`bool<class_bool>` **has** **(** :ref:`Vector2<class_Vector2>` value **)** |const|
Returns ``true`` if the array contains ``value``.
.. rst-class:: classref-item-separator
----
.. _class_PackedVector2Array_method_insert:
- :ref:`int<class_int>` **insert** **(** :ref:`int<class_int>` at_index, :ref:`Vector2<class_Vector2>` value **)**
.. rst-class:: classref-method
:ref:`int<class_int>` **insert** **(** :ref:`int<class_int>` at_index, :ref:`Vector2<class_Vector2>` value **)**
Inserts a new element at a given position in the array. The position must be valid, or at the end of the array (``idx == size()``).
.. rst-class:: classref-item-separator
----
.. _class_PackedVector2Array_method_is_empty:
- :ref:`bool<class_bool>` **is_empty** **(** **)** |const|
.. rst-class:: classref-method
:ref:`bool<class_bool>` **is_empty** **(** **)** |const|
Returns ``true`` if the array is empty.
.. rst-class:: classref-item-separator
----
.. _class_PackedVector2Array_method_push_back:
- :ref:`bool<class_bool>` **push_back** **(** :ref:`Vector2<class_Vector2>` value **)**
.. rst-class:: classref-method
:ref:`bool<class_bool>` **push_back** **(** :ref:`Vector2<class_Vector2>` value **)**
Inserts a :ref:`Vector2<class_Vector2>` at the end.
.. rst-class:: classref-item-separator
----
.. _class_PackedVector2Array_method_remove_at:
- void **remove_at** **(** :ref:`int<class_int>` index **)**
.. rst-class:: classref-method
void **remove_at** **(** :ref:`int<class_int>` index **)**
Removes an element from the array by index.
.. rst-class:: classref-item-separator
----
.. _class_PackedVector2Array_method_resize:
- :ref:`int<class_int>` **resize** **(** :ref:`int<class_int>` new_size **)**
.. rst-class:: classref-method
:ref:`int<class_int>` **resize** **(** :ref:`int<class_int>` new_size **)**
Sets the size of the array. If the array is grown, reserves elements at the end of the array. If the array is shrunk, truncates the array to the new size.
.. rst-class:: classref-item-separator
----
.. _class_PackedVector2Array_method_reverse:
- void **reverse** **(** **)**
.. rst-class:: classref-method
void **reverse** **(** **)**
Reverses the order of the elements in the array.
.. rst-class:: classref-item-separator
----
.. _class_PackedVector2Array_method_rfind:
- :ref:`int<class_int>` **rfind** **(** :ref:`Vector2<class_Vector2>` value, :ref:`int<class_int>` from=-1 **)** |const|
.. rst-class:: classref-method
:ref:`int<class_int>` **rfind** **(** :ref:`Vector2<class_Vector2>` value, :ref:`int<class_int>` from=-1 **)** |const|
Searches the array in reverse order. Optionally, a start search index can be passed. If negative, the start index is considered relative to the end of the array.
.. rst-class:: classref-item-separator
----
.. _class_PackedVector2Array_method_set:
- void **set** **(** :ref:`int<class_int>` index, :ref:`Vector2<class_Vector2>` value **)**
.. rst-class:: classref-method
void **set** **(** :ref:`int<class_int>` index, :ref:`Vector2<class_Vector2>` value **)**
Changes the :ref:`Vector2<class_Vector2>` at the given index.
.. rst-class:: classref-item-separator
----
.. _class_PackedVector2Array_method_size:
- :ref:`int<class_int>` **size** **(** **)** |const|
.. rst-class:: classref-method
:ref:`int<class_int>` **size** **(** **)** |const|
Returns the number of elements in the array.
.. rst-class:: classref-item-separator
----
.. _class_PackedVector2Array_method_slice:
- :ref:`PackedVector2Array<class_PackedVector2Array>` **slice** **(** :ref:`int<class_int>` begin, :ref:`int<class_int>` end=2147483647 **)** |const|
.. rst-class:: classref-method
Returns the slice of the ``PackedVector2Array``, from ``begin`` (inclusive) to ``end`` (exclusive), as a new ``PackedVector2Array``.
:ref:`PackedVector2Array<class_PackedVector2Array>` **slice** **(** :ref:`int<class_int>` begin, :ref:`int<class_int>` end=2147483647 **)** |const|
Returns the slice of the **PackedVector2Array**, from ``begin`` (inclusive) to ``end`` (exclusive), as a new **PackedVector2Array**.
The absolute value of ``begin`` and ``end`` will be clamped to the array size, so the default value for ``end`` makes it slice to the size of the array by default (i.e. ``arr.slice(1)`` is a shorthand for ``arr.slice(1, arr.size())``).
If either ``begin`` or ``end`` are negative, they will be relative to the end of the array (i.e. ``arr.slice(0, -2)`` is a shorthand for ``arr.slice(0, arr.size() - 2)``).
.. rst-class:: classref-item-separator
----
.. _class_PackedVector2Array_method_sort:
- void **sort** **(** **)**
.. rst-class:: classref-method
void **sort** **(** **)**
Sorts the elements of the array in ascending order.
.. rst-class:: classref-item-separator
----
.. _class_PackedVector2Array_method_to_byte_array:
- :ref:`PackedByteArray<class_PackedByteArray>` **to_byte_array** **(** **)** |const|
.. rst-class:: classref-method
:ref:`PackedByteArray<class_PackedByteArray>` **to_byte_array** **(** **)** |const|
Returns a :ref:`PackedByteArray<class_PackedByteArray>` with each vector encoded as bytes.
.. rst-class:: classref-section-separator
----
.. rst-class:: classref-descriptions-group
Operator Descriptions
---------------------
.. _class_PackedVector2Array_operator_neq_bool:
.. _class_PackedVector2Array_operator_neq_PackedVector2Array:
- :ref:`bool<class_bool>` **operator !=** **(** :ref:`PackedVector2Array<class_PackedVector2Array>` right **)**
.. rst-class:: classref-operator
:ref:`bool<class_bool>` **operator !=** **(** :ref:`PackedVector2Array<class_PackedVector2Array>` right **)**
Returns ``true`` if contents of the arrays differ.
.. rst-class:: classref-item-separator
----
.. _class_PackedVector2Array_operator_mul_PackedVector2Array:
.. _class_PackedVector2Array_operator_mul_Transform2D:
- :ref:`PackedVector2Array<class_PackedVector2Array>` **operator *** **(** :ref:`Transform2D<class_Transform2D>` right **)**
.. rst-class:: classref-operator
:ref:`PackedVector2Array<class_PackedVector2Array>` **operator *** **(** :ref:`Transform2D<class_Transform2D>` right **)**
Transforms (multiplies) all vectors in the array by the :ref:`Transform2D<class_Transform2D>` matrix.
.. rst-class:: classref-item-separator
----
.. _class_PackedVector2Array_operator_sum_PackedVector2Array:
- :ref:`PackedVector2Array<class_PackedVector2Array>` **operator +** **(** :ref:`PackedVector2Array<class_PackedVector2Array>` right **)**
.. rst-class:: classref-operator
Returns a new ``PackedVector2Array`` with contents of ``right`` added at the end of this array. For better performance, consider using :ref:`append_array<class_PackedVector2Array_method_append_array>` instead.
:ref:`PackedVector2Array<class_PackedVector2Array>` **operator +** **(** :ref:`PackedVector2Array<class_PackedVector2Array>` right **)**
Returns a new **PackedVector2Array** with contents of ``right`` added at the end of this array. For better performance, consider using :ref:`append_array<class_PackedVector2Array_method_append_array>` instead.
.. rst-class:: classref-item-separator
----
.. _class_PackedVector2Array_operator_eq_bool:
.. _class_PackedVector2Array_operator_eq_PackedVector2Array:
- :ref:`bool<class_bool>` **operator ==** **(** :ref:`PackedVector2Array<class_PackedVector2Array>` right **)**
.. rst-class:: classref-operator
:ref:`bool<class_bool>` **operator ==** **(** :ref:`PackedVector2Array<class_PackedVector2Array>` right **)**
Returns ``true`` if contents of both arrays are the same, i.e. they have all equal :ref:`Vector2<class_Vector2>`\ s at the corresponding indices.
.. rst-class:: classref-item-separator
----
.. _class_PackedVector2Array_operator_idx_Vector2:
.. _class_PackedVector2Array_operator_idx_int:
- :ref:`Vector2<class_Vector2>` **operator []** **(** :ref:`int<class_int>` index **)**
.. rst-class:: classref-operator
:ref:`Vector2<class_Vector2>` **operator []** **(** :ref:`int<class_int>` index **)**
Returns the :ref:`Vector2<class_Vector2>` at index ``index``. Negative indices can be used to access the elements starting from the end. Using index out of array's bounds will result in an error.