class_packedvector4array.rst 28 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509
  1. :github_url: hide
  2. .. DO NOT EDIT THIS FILE!!!
  3. .. Generated automatically from Godot engine sources.
  4. .. Generator: https://github.com/godotengine/godot/tree/master/doc/tools/make_rst.py.
  5. .. XML source: https://github.com/godotengine/godot/tree/master/doc/classes/PackedVector4Array.xml.
  6. .. _class_PackedVector4Array:
  7. PackedVector4Array
  8. ==================
  9. A packed array of :ref:`Vector4<class_Vector4>`\ s.
  10. .. rst-class:: classref-introduction-group
  11. Description
  12. -----------
  13. An array specifically designed to hold :ref:`Vector4<class_Vector4>`. Packs data tightly, so it saves memory for large array sizes.
  14. \ **Differences between packed arrays, typed arrays, and untyped arrays:** Packed arrays are generally faster to iterate on and modify compared to a typed array of the same type (e.g. **PackedVector4Array** versus ``Array[Vector4]``). Also, packed arrays consume less memory. As a downside, packed arrays are less flexible as they don't offer as many convenience methods such as :ref:`Array.map<class_Array_method_map>`. Typed arrays are in turn faster to iterate on and modify than untyped arrays.
  15. \ **Note:** Packed arrays are always passed by reference. To get a copy of an array that can be modified independently of the original array, use :ref:`duplicate<class_PackedVector4Array_method_duplicate>`. This is *not* the case for built-in properties and methods. The returned packed array of these are a copies, and changing it will *not* affect the original value. To update a built-in property you need to modify the returned array, and then assign it to the property again.
  16. .. note::
  17. There are notable differences when using this API with C#. See :ref:`doc_c_sharp_differences` for more information.
  18. .. rst-class:: classref-reftable-group
  19. Constructors
  20. ------------
  21. .. table::
  22. :widths: auto
  23. +-----------------------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------+
  24. | :ref:`PackedVector4Array<class_PackedVector4Array>` | :ref:`PackedVector4Array<class_PackedVector4Array_constructor_PackedVector4Array>`\ (\ ) |
  25. +-----------------------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------+
  26. | :ref:`PackedVector4Array<class_PackedVector4Array>` | :ref:`PackedVector4Array<class_PackedVector4Array_constructor_PackedVector4Array>`\ (\ from\: :ref:`PackedVector4Array<class_PackedVector4Array>`\ ) |
  27. +-----------------------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------+
  28. | :ref:`PackedVector4Array<class_PackedVector4Array>` | :ref:`PackedVector4Array<class_PackedVector4Array_constructor_PackedVector4Array>`\ (\ from\: :ref:`Array<class_Array>`\ ) |
  29. +-----------------------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------+
  30. .. rst-class:: classref-reftable-group
  31. Methods
  32. -------
  33. .. table::
  34. :widths: auto
  35. +-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------+
  36. | :ref:`bool<class_bool>` | :ref:`append<class_PackedVector4Array_method_append>`\ (\ value\: :ref:`Vector4<class_Vector4>`\ ) |
  37. +-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------+
  38. | |void| | :ref:`append_array<class_PackedVector4Array_method_append_array>`\ (\ array\: :ref:`PackedVector4Array<class_PackedVector4Array>`\ ) |
  39. +-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------+
  40. | :ref:`int<class_int>` | :ref:`bsearch<class_PackedVector4Array_method_bsearch>`\ (\ value\: :ref:`Vector4<class_Vector4>`, before\: :ref:`bool<class_bool>` = true\ ) |
  41. +-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------+
  42. | |void| | :ref:`clear<class_PackedVector4Array_method_clear>`\ (\ ) |
  43. +-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------+
  44. | :ref:`int<class_int>` | :ref:`count<class_PackedVector4Array_method_count>`\ (\ value\: :ref:`Vector4<class_Vector4>`\ ) |const| |
  45. +-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------+
  46. | :ref:`PackedVector4Array<class_PackedVector4Array>` | :ref:`duplicate<class_PackedVector4Array_method_duplicate>`\ (\ ) |
  47. +-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------+
  48. | |void| | :ref:`fill<class_PackedVector4Array_method_fill>`\ (\ value\: :ref:`Vector4<class_Vector4>`\ ) |
  49. +-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------+
  50. | :ref:`int<class_int>` | :ref:`find<class_PackedVector4Array_method_find>`\ (\ value\: :ref:`Vector4<class_Vector4>`, from\: :ref:`int<class_int>` = 0\ ) |const| |
  51. +-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------+
  52. | :ref:`Vector4<class_Vector4>` | :ref:`get<class_PackedVector4Array_method_get>`\ (\ index\: :ref:`int<class_int>`\ ) |const| |
  53. +-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------+
  54. | :ref:`bool<class_bool>` | :ref:`has<class_PackedVector4Array_method_has>`\ (\ value\: :ref:`Vector4<class_Vector4>`\ ) |const| |
  55. +-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------+
  56. | :ref:`int<class_int>` | :ref:`insert<class_PackedVector4Array_method_insert>`\ (\ at_index\: :ref:`int<class_int>`, value\: :ref:`Vector4<class_Vector4>`\ ) |
  57. +-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------+
  58. | :ref:`bool<class_bool>` | :ref:`is_empty<class_PackedVector4Array_method_is_empty>`\ (\ ) |const| |
  59. +-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------+
  60. | :ref:`bool<class_bool>` | :ref:`push_back<class_PackedVector4Array_method_push_back>`\ (\ value\: :ref:`Vector4<class_Vector4>`\ ) |
  61. +-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------+
  62. | |void| | :ref:`remove_at<class_PackedVector4Array_method_remove_at>`\ (\ index\: :ref:`int<class_int>`\ ) |
  63. +-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------+
  64. | :ref:`int<class_int>` | :ref:`resize<class_PackedVector4Array_method_resize>`\ (\ new_size\: :ref:`int<class_int>`\ ) |
  65. +-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------+
  66. | |void| | :ref:`reverse<class_PackedVector4Array_method_reverse>`\ (\ ) |
  67. +-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------+
  68. | :ref:`int<class_int>` | :ref:`rfind<class_PackedVector4Array_method_rfind>`\ (\ value\: :ref:`Vector4<class_Vector4>`, from\: :ref:`int<class_int>` = -1\ ) |const| |
  69. +-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------+
  70. | |void| | :ref:`set<class_PackedVector4Array_method_set>`\ (\ index\: :ref:`int<class_int>`, value\: :ref:`Vector4<class_Vector4>`\ ) |
  71. +-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------+
  72. | :ref:`int<class_int>` | :ref:`size<class_PackedVector4Array_method_size>`\ (\ ) |const| |
  73. +-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------+
  74. | :ref:`PackedVector4Array<class_PackedVector4Array>` | :ref:`slice<class_PackedVector4Array_method_slice>`\ (\ begin\: :ref:`int<class_int>`, end\: :ref:`int<class_int>` = 2147483647\ ) |const| |
  75. +-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------+
  76. | |void| | :ref:`sort<class_PackedVector4Array_method_sort>`\ (\ ) |
  77. +-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------+
  78. | :ref:`PackedByteArray<class_PackedByteArray>` | :ref:`to_byte_array<class_PackedVector4Array_method_to_byte_array>`\ (\ ) |const| |
  79. +-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------+
  80. .. rst-class:: classref-reftable-group
  81. Operators
  82. ---------
  83. .. table::
  84. :widths: auto
  85. +-----------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------+
  86. | :ref:`bool<class_bool>` | :ref:`operator !=<class_PackedVector4Array_operator_neq_PackedVector4Array>`\ (\ right\: :ref:`PackedVector4Array<class_PackedVector4Array>`\ ) |
  87. +-----------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------+
  88. | :ref:`PackedVector4Array<class_PackedVector4Array>` | :ref:`operator +<class_PackedVector4Array_operator_sum_PackedVector4Array>`\ (\ right\: :ref:`PackedVector4Array<class_PackedVector4Array>`\ ) |
  89. +-----------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------+
  90. | :ref:`bool<class_bool>` | :ref:`operator ==<class_PackedVector4Array_operator_eq_PackedVector4Array>`\ (\ right\: :ref:`PackedVector4Array<class_PackedVector4Array>`\ ) |
  91. +-----------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------+
  92. | :ref:`Vector4<class_Vector4>` | :ref:`operator []<class_PackedVector4Array_operator_idx_int>`\ (\ index\: :ref:`int<class_int>`\ ) |
  93. +-----------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------+
  94. .. rst-class:: classref-section-separator
  95. ----
  96. .. rst-class:: classref-descriptions-group
  97. Constructor Descriptions
  98. ------------------------
  99. .. _class_PackedVector4Array_constructor_PackedVector4Array:
  100. .. rst-class:: classref-constructor
  101. :ref:`PackedVector4Array<class_PackedVector4Array>` **PackedVector4Array**\ (\ ) :ref:`🔗<class_PackedVector4Array_constructor_PackedVector4Array>`
  102. Constructs an empty **PackedVector4Array**.
  103. .. rst-class:: classref-item-separator
  104. ----
  105. .. rst-class:: classref-constructor
  106. :ref:`PackedVector4Array<class_PackedVector4Array>` **PackedVector4Array**\ (\ from\: :ref:`PackedVector4Array<class_PackedVector4Array>`\ )
  107. Constructs a **PackedVector4Array** as a copy of the given **PackedVector4Array**.
  108. .. rst-class:: classref-item-separator
  109. ----
  110. .. rst-class:: classref-constructor
  111. :ref:`PackedVector4Array<class_PackedVector4Array>` **PackedVector4Array**\ (\ from\: :ref:`Array<class_Array>`\ )
  112. Constructs a new **PackedVector4Array**. Optionally, you can pass in a generic :ref:`Array<class_Array>` that will be converted.
  113. \ **Note:** When initializing a **PackedVector4Array** with elements, it must be initialized with an :ref:`Array<class_Array>` of :ref:`Vector4<class_Vector4>` values:
  114. ::
  115. var array = PackedVector4Array([Vector4(12, 34, 56, 78), Vector4(90, 12, 34, 56)])
  116. .. rst-class:: classref-section-separator
  117. ----
  118. .. rst-class:: classref-descriptions-group
  119. Method Descriptions
  120. -------------------
  121. .. _class_PackedVector4Array_method_append:
  122. .. rst-class:: classref-method
  123. :ref:`bool<class_bool>` **append**\ (\ value\: :ref:`Vector4<class_Vector4>`\ ) :ref:`🔗<class_PackedVector4Array_method_append>`
  124. Appends an element at the end of the array (alias of :ref:`push_back<class_PackedVector4Array_method_push_back>`).
  125. .. rst-class:: classref-item-separator
  126. ----
  127. .. _class_PackedVector4Array_method_append_array:
  128. .. rst-class:: classref-method
  129. |void| **append_array**\ (\ array\: :ref:`PackedVector4Array<class_PackedVector4Array>`\ ) :ref:`🔗<class_PackedVector4Array_method_append_array>`
  130. Appends a **PackedVector4Array** at the end of this array.
  131. .. rst-class:: classref-item-separator
  132. ----
  133. .. _class_PackedVector4Array_method_bsearch:
  134. .. rst-class:: classref-method
  135. :ref:`int<class_int>` **bsearch**\ (\ value\: :ref:`Vector4<class_Vector4>`, before\: :ref:`bool<class_bool>` = true\ ) :ref:`🔗<class_PackedVector4Array_method_bsearch>`
  136. 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.
  137. \ **Note:** Calling :ref:`bsearch<class_PackedVector4Array_method_bsearch>` on an unsorted array results in unexpected behavior.
  138. \ **Note:** Vectors with :ref:`@GDScript.NAN<class_@GDScript_constant_NAN>` elements don't behave the same as other vectors. Therefore, the results from this method may not be accurate if NaNs are included.
  139. .. rst-class:: classref-item-separator
  140. ----
  141. .. _class_PackedVector4Array_method_clear:
  142. .. rst-class:: classref-method
  143. |void| **clear**\ (\ ) :ref:`🔗<class_PackedVector4Array_method_clear>`
  144. Clears the array. This is equivalent to using :ref:`resize<class_PackedVector4Array_method_resize>` with a size of ``0``.
  145. .. rst-class:: classref-item-separator
  146. ----
  147. .. _class_PackedVector4Array_method_count:
  148. .. rst-class:: classref-method
  149. :ref:`int<class_int>` **count**\ (\ value\: :ref:`Vector4<class_Vector4>`\ ) |const| :ref:`🔗<class_PackedVector4Array_method_count>`
  150. Returns the number of times an element is in the array.
  151. \ **Note:** Vectors with :ref:`@GDScript.NAN<class_@GDScript_constant_NAN>` elements don't behave the same as other vectors. Therefore, the results from this method may not be accurate if NaNs are included.
  152. .. rst-class:: classref-item-separator
  153. ----
  154. .. _class_PackedVector4Array_method_duplicate:
  155. .. rst-class:: classref-method
  156. :ref:`PackedVector4Array<class_PackedVector4Array>` **duplicate**\ (\ ) :ref:`🔗<class_PackedVector4Array_method_duplicate>`
  157. Creates a copy of the array, and returns it.
  158. .. rst-class:: classref-item-separator
  159. ----
  160. .. _class_PackedVector4Array_method_fill:
  161. .. rst-class:: classref-method
  162. |void| **fill**\ (\ value\: :ref:`Vector4<class_Vector4>`\ ) :ref:`🔗<class_PackedVector4Array_method_fill>`
  163. Assigns the given value to all elements in the array. This can typically be used together with :ref:`resize<class_PackedVector4Array_method_resize>` to create an array with a given size and initialized elements.
  164. .. rst-class:: classref-item-separator
  165. ----
  166. .. _class_PackedVector4Array_method_find:
  167. .. rst-class:: classref-method
  168. :ref:`int<class_int>` **find**\ (\ value\: :ref:`Vector4<class_Vector4>`, from\: :ref:`int<class_int>` = 0\ ) |const| :ref:`🔗<class_PackedVector4Array_method_find>`
  169. Searches the array for a value and returns its index or ``-1`` if not found. Optionally, the initial search index can be passed.
  170. \ **Note:** Vectors with :ref:`@GDScript.NAN<class_@GDScript_constant_NAN>` elements don't behave the same as other vectors. Therefore, the results from this method may not be accurate if NaNs are included.
  171. .. rst-class:: classref-item-separator
  172. ----
  173. .. _class_PackedVector4Array_method_get:
  174. .. rst-class:: classref-method
  175. :ref:`Vector4<class_Vector4>` **get**\ (\ index\: :ref:`int<class_int>`\ ) |const| :ref:`🔗<class_PackedVector4Array_method_get>`
  176. Returns the :ref:`Vector4<class_Vector4>` at the given ``index`` in the array. This is the same as using the ``[]`` operator (``array[index]``).
  177. .. rst-class:: classref-item-separator
  178. ----
  179. .. _class_PackedVector4Array_method_has:
  180. .. rst-class:: classref-method
  181. :ref:`bool<class_bool>` **has**\ (\ value\: :ref:`Vector4<class_Vector4>`\ ) |const| :ref:`🔗<class_PackedVector4Array_method_has>`
  182. Returns ``true`` if the array contains ``value``.
  183. \ **Note:** Vectors with :ref:`@GDScript.NAN<class_@GDScript_constant_NAN>` elements don't behave the same as other vectors. Therefore, the results from this method may not be accurate if NaNs are included.
  184. .. rst-class:: classref-item-separator
  185. ----
  186. .. _class_PackedVector4Array_method_insert:
  187. .. rst-class:: classref-method
  188. :ref:`int<class_int>` **insert**\ (\ at_index\: :ref:`int<class_int>`, value\: :ref:`Vector4<class_Vector4>`\ ) :ref:`🔗<class_PackedVector4Array_method_insert>`
  189. 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()``).
  190. .. rst-class:: classref-item-separator
  191. ----
  192. .. _class_PackedVector4Array_method_is_empty:
  193. .. rst-class:: classref-method
  194. :ref:`bool<class_bool>` **is_empty**\ (\ ) |const| :ref:`🔗<class_PackedVector4Array_method_is_empty>`
  195. Returns ``true`` if the array is empty.
  196. .. rst-class:: classref-item-separator
  197. ----
  198. .. _class_PackedVector4Array_method_push_back:
  199. .. rst-class:: classref-method
  200. :ref:`bool<class_bool>` **push_back**\ (\ value\: :ref:`Vector4<class_Vector4>`\ ) :ref:`🔗<class_PackedVector4Array_method_push_back>`
  201. Inserts a :ref:`Vector4<class_Vector4>` at the end.
  202. .. rst-class:: classref-item-separator
  203. ----
  204. .. _class_PackedVector4Array_method_remove_at:
  205. .. rst-class:: classref-method
  206. |void| **remove_at**\ (\ index\: :ref:`int<class_int>`\ ) :ref:`🔗<class_PackedVector4Array_method_remove_at>`
  207. Removes an element from the array by index.
  208. .. rst-class:: classref-item-separator
  209. ----
  210. .. _class_PackedVector4Array_method_resize:
  211. .. rst-class:: classref-method
  212. :ref:`int<class_int>` **resize**\ (\ new_size\: :ref:`int<class_int>`\ ) :ref:`🔗<class_PackedVector4Array_method_resize>`
  213. 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.
  214. .. rst-class:: classref-item-separator
  215. ----
  216. .. _class_PackedVector4Array_method_reverse:
  217. .. rst-class:: classref-method
  218. |void| **reverse**\ (\ ) :ref:`🔗<class_PackedVector4Array_method_reverse>`
  219. Reverses the order of the elements in the array.
  220. .. rst-class:: classref-item-separator
  221. ----
  222. .. _class_PackedVector4Array_method_rfind:
  223. .. rst-class:: classref-method
  224. :ref:`int<class_int>` **rfind**\ (\ value\: :ref:`Vector4<class_Vector4>`, from\: :ref:`int<class_int>` = -1\ ) |const| :ref:`🔗<class_PackedVector4Array_method_rfind>`
  225. 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.
  226. \ **Note:** Vectors with :ref:`@GDScript.NAN<class_@GDScript_constant_NAN>` elements don't behave the same as other vectors. Therefore, the results from this method may not be accurate if NaNs are included.
  227. .. rst-class:: classref-item-separator
  228. ----
  229. .. _class_PackedVector4Array_method_set:
  230. .. rst-class:: classref-method
  231. |void| **set**\ (\ index\: :ref:`int<class_int>`, value\: :ref:`Vector4<class_Vector4>`\ ) :ref:`🔗<class_PackedVector4Array_method_set>`
  232. Changes the :ref:`Vector4<class_Vector4>` at the given index.
  233. .. rst-class:: classref-item-separator
  234. ----
  235. .. _class_PackedVector4Array_method_size:
  236. .. rst-class:: classref-method
  237. :ref:`int<class_int>` **size**\ (\ ) |const| :ref:`🔗<class_PackedVector4Array_method_size>`
  238. Returns the number of elements in the array.
  239. .. rst-class:: classref-item-separator
  240. ----
  241. .. _class_PackedVector4Array_method_slice:
  242. .. rst-class:: classref-method
  243. :ref:`PackedVector4Array<class_PackedVector4Array>` **slice**\ (\ begin\: :ref:`int<class_int>`, end\: :ref:`int<class_int>` = 2147483647\ ) |const| :ref:`🔗<class_PackedVector4Array_method_slice>`
  244. Returns the slice of the **PackedVector4Array**, from ``begin`` (inclusive) to ``end`` (exclusive), as a new **PackedVector4Array**.
  245. 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())``).
  246. 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)``).
  247. .. rst-class:: classref-item-separator
  248. ----
  249. .. _class_PackedVector4Array_method_sort:
  250. .. rst-class:: classref-method
  251. |void| **sort**\ (\ ) :ref:`🔗<class_PackedVector4Array_method_sort>`
  252. Sorts the elements of the array in ascending order.
  253. \ **Note:** Vectors with :ref:`@GDScript.NAN<class_@GDScript_constant_NAN>` elements don't behave the same as other vectors. Therefore, the results from this method may not be accurate if NaNs are included.
  254. .. rst-class:: classref-item-separator
  255. ----
  256. .. _class_PackedVector4Array_method_to_byte_array:
  257. .. rst-class:: classref-method
  258. :ref:`PackedByteArray<class_PackedByteArray>` **to_byte_array**\ (\ ) |const| :ref:`🔗<class_PackedVector4Array_method_to_byte_array>`
  259. Returns a :ref:`PackedByteArray<class_PackedByteArray>` with each vector encoded as bytes.
  260. .. rst-class:: classref-section-separator
  261. ----
  262. .. rst-class:: classref-descriptions-group
  263. Operator Descriptions
  264. ---------------------
  265. .. _class_PackedVector4Array_operator_neq_PackedVector4Array:
  266. .. rst-class:: classref-operator
  267. :ref:`bool<class_bool>` **operator !=**\ (\ right\: :ref:`PackedVector4Array<class_PackedVector4Array>`\ ) :ref:`🔗<class_PackedVector4Array_operator_neq_PackedVector4Array>`
  268. Returns ``true`` if contents of the arrays differ.
  269. .. rst-class:: classref-item-separator
  270. ----
  271. .. _class_PackedVector4Array_operator_sum_PackedVector4Array:
  272. .. rst-class:: classref-operator
  273. :ref:`PackedVector4Array<class_PackedVector4Array>` **operator +**\ (\ right\: :ref:`PackedVector4Array<class_PackedVector4Array>`\ ) :ref:`🔗<class_PackedVector4Array_operator_sum_PackedVector4Array>`
  274. Returns a new **PackedVector4Array** with contents of ``right`` added at the end of this array. For better performance, consider using :ref:`append_array<class_PackedVector4Array_method_append_array>` instead.
  275. .. rst-class:: classref-item-separator
  276. ----
  277. .. _class_PackedVector4Array_operator_eq_PackedVector4Array:
  278. .. rst-class:: classref-operator
  279. :ref:`bool<class_bool>` **operator ==**\ (\ right\: :ref:`PackedVector4Array<class_PackedVector4Array>`\ ) :ref:`🔗<class_PackedVector4Array_operator_eq_PackedVector4Array>`
  280. Returns ``true`` if contents of both arrays are the same, i.e. they have all equal :ref:`Vector4<class_Vector4>`\ s at the corresponding indices.
  281. .. rst-class:: classref-item-separator
  282. ----
  283. .. _class_PackedVector4Array_operator_idx_int:
  284. .. rst-class:: classref-operator
  285. :ref:`Vector4<class_Vector4>` **operator []**\ (\ index\: :ref:`int<class_int>`\ ) :ref:`🔗<class_PackedVector4Array_operator_idx_int>`
  286. Returns the :ref:`Vector4<class_Vector4>` 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.
  287. .. |virtual| replace:: :abbr:`virtual (This method should typically be overridden by the user to have any effect.)`
  288. .. |const| replace:: :abbr:`const (This method has no side effects. It doesn't modify any of the instance's member variables.)`
  289. .. |vararg| replace:: :abbr:`vararg (This method accepts any number of arguments after the ones described here.)`
  290. .. |constructor| replace:: :abbr:`constructor (This method is used to construct a type.)`
  291. .. |static| replace:: :abbr:`static (This method doesn't need an instance to be called, so it can be called directly using the class name.)`
  292. .. |operator| replace:: :abbr:`operator (This method describes a valid operator to use with this type as left-hand operand.)`
  293. .. |bitfield| replace:: :abbr:`BitField (This value is an integer composed as a bitmask of the following flags.)`
  294. .. |void| replace:: :abbr:`void (No return value.)`