Struct PackedByteArray

pub struct PackedByteArray { /* private fields */ }

Implements Godot’s PackedByteArray type, which is a space-efficient array of u8s.

Check out the book for a tutorial on packed arrays.

Note that, unlike Array, this type has value semantics: each copy will be independent of the original. Under the hood, Godot uses copy-on-write, so copies are still cheap to make.

Registering properties

You can use both #[var] and #[export] with packed arrays. However, since they use copy-on-write, GDScript (for #[var]) and the editor (for #[export]) will effectively keep an independent copy of the array. Writes to the packed array from Rust are thus not reflected on the other side – you may need to replace the entire array.

See also godot/#76150 for details.

Thread safety

Usage is safe if the PackedByteArray is used on a single thread only. Concurrent reads on different threads are also safe, but any writes must be externally synchronized. The Rust compiler will enforce this as long as you use only Rust threads, but it cannot protect against concurrent modification on other threads (e.g. created through GDScript).

Implementations

impl PackedByteArray

pub fn new() -> PackedByteArray

Constructs an empty array.

pub fn get(&self, index: usize) -> Option<u8>

Returns a copy of the value at the specified index, or None if out-of-bounds.

If you know the index is valid, use the [] operator (Index/IndexMut traits) instead.

pub fn contains(&self, value: impl AsArg<u8>) -> bool

Returns true if the array contains the given value.

Godot equivalent: has

pub fn count(&self, value: impl AsArg<u8>) -> usize

Returns the number of times a value is in the array.

pub fn len(&self) -> usize

Returns the number of elements in the array. Equivalent of size() in Godot.

pub fn is_empty(&self) -> bool

Returns true if the array is empty.

pub fn clear(&mut self)

Clears the array, removing all elements.

pub fn push(&mut self, value: impl AsArg<u8>)

Appends an element to the end of the array. Equivalent of append and push_back in GDScript.

pub fn insert(&mut self, index: usize, value: impl AsArg<u8>)

Inserts a new element at a given index in the array. The index must be valid, or at the end of the array (index == len()).

Note: On large arrays, this method is much slower than push as it will move all the array’s elements after the inserted element. The larger the array, the slower insert will be.

pub fn remove(&mut self, index: usize) -> u8

Removes and returns the element at the specified index. Similar to remove_at in GDScript, but also returns the removed value.

On large arrays, this method is much slower than pop_back as it will move all the array’s elements after the removed element. The larger the array, the slower remove will be.

Panics

If index is out of bounds.

pub fn fill(&mut self, value: impl AsArg<u8>)

Assigns the given value to all elements in the array. This can be used together with resize to create an array with a given size and initialized elements.

pub fn resize(&mut self, size: usize)

Resizes the array to contain a different number of elements. If the new size is smaller, elements are removed from the end. If the new size is larger, new elements are set to Default::default().

pub fn extend_array(&mut self, other: &PackedByteArray)

Appends another array at the end of this array. Equivalent of append_array in GDScript.

pub fn to_vec(&self) -> Vec<u8>

Converts this array to a Rust vector, making a copy of its contents.

pub fn subarray(&self, begin: usize, end: usize) -> PackedByteArray

Returns a sub-range begin..end, as a new packed array.

This method is called slice() in Godot. The values of begin (inclusive) and end (exclusive) will be clamped to the array size.

To obtain Rust slices, see as_slice and as_mut_slice.

pub fn as_slice(&self) -> &[u8]

Returns a shared Rust slice of the array.

The resulting slice can be further subdivided or converted into raw pointers.

See also as_mut_slice to get exclusive slices, and subarray to get a sub-array as a copy.

pub fn as_mut_slice(&mut self) -> &mut [u8]

Returns an exclusive Rust slice of the array.

The resulting slice can be further subdivided or converted into raw pointers.

See also as_slice to get shared slices, and subarray to get a sub-array as a copy.

pub fn find(&self, value: impl AsArg<u8>, from: Option<usize>) -> Option<usize>

Searches the array for the first occurrence of a value and returns its index, or None if not found. Starts searching at index from; pass None to search the entire array.

pub fn rfind(&self, value: impl AsArg<u8>, from: Option<usize>) -> Option<usize>

Searches the array backwards for the last occurrence of a value and returns its index, or None if not found. Starts searching at index from; pass None to search the entire array.

pub fn bsearch(&self, value: impl AsArg<u8>) -> usize

Finds the index of an existing value in a sorted array using binary search.

If the value is not present in the array, returns the insertion index that would maintain sorting order.

Calling bsearch() on an unsorted array results in unspecified (but safe) behavior.

pub fn reverse(&mut self)

Reverses the order of the elements in the array.

pub fn sort(&mut self)

Sorts the elements of the array in ascending order.

This sort is stable, since elements inside packed arrays are indistinguishable. Relative order between equal elements thus isn’t observable.

pub fn to_float32_array(&self) -> PackedFloat32Array

Returns a copy of the data converted to a PackedFloat32Array, where each block of 4 bytes has been converted to a 32-bit float.

The size of the input array must be a multiple of 4 (size of 32-bit float). The size of the new array will be byte_array.size() / 4.

If the original data can’t be converted to 32-bit floats, the resulting data is undefined.

pub fn to_float64_array(&self) -> PackedFloat64Array

Returns a copy of the data converted to a PackedFloat64Array, where each block of 8 bytes has been converted to a 64-bit float.

The size of the input array must be a multiple of 8 (size of 64-bit float). The size of the new array will be byte_array.size() / 8.

If the original data can’t be converted to 64-bit floats, the resulting data is undefined.

pub fn to_int32_array(&self) -> PackedInt32Array

Returns a copy of the data converted to a PackedInt32Array, where each block of 4 bytes has been converted to a 32-bit integer.

The size of the input array must be a multiple of 4 (size of 32-bit integer). The size of the new array will be byte_array.size() / 4.

If the original data can’t be converted to 32-bit integers, the resulting data is undefined.

pub fn to_int64_array(&self) -> PackedInt64Array

Returns a copy of the data converted to a PackedInt64Array, where each block of 8 bytes has been converted to a 64-bit integer.

The size of the input array must be a multiple of 8 (size of 64-bit integer). The size of the new array will be byte_array.size() / 8.

If the original data can’t be converted to 64-bit integers, the resulting data is undefined.

impl PackedByteArray

pub fn encode_u8(&mut self, byte_offset: usize, value: u8) -> Result<(), ()>

Encodes u8 as 1 byte(s) at position byte_offset.

Returns Err if there is not enough space left to write the value, and does nothing in that case.

Note: byte order and encoding pattern is an implementation detail. For portable byte representation and faster encoding, use as_mut_slice() and the various Rust standard APIs such as u8::to_be_bytes().

pub fn decode_u8(&self, byte_offset: usize) -> Result<u8, ()>

Decodes u8 from 1 byte(s) at position byte_offset.

Returns Err if there is not enough space left to read the value. In case Godot has other error conditions for decoding, it may return zero and print an error.

Note: byte order and encoding pattern is an implementation detail. For portable byte representation and faster decoding, use as_slice() and the various Rust standard APIs such as u8::from_be_bytes().

pub fn encode_s8(&mut self, byte_offset: usize, value: i8) -> Result<(), ()>

Encodes i8 as 1 byte(s) at position byte_offset.

Returns Err if there is not enough space left to write the value, and does nothing in that case.

Note: byte order and encoding pattern is an implementation detail. For portable byte representation and faster encoding, use as_mut_slice() and the various Rust standard APIs such as i8::to_be_bytes().

pub fn decode_s8(&self, byte_offset: usize) -> Result<i8, ()>

Decodes i8 from 1 byte(s) at position byte_offset.

Returns Err if there is not enough space left to read the value. In case Godot has other error conditions for decoding, it may return zero and print an error.

Note: byte order and encoding pattern is an implementation detail. For portable byte representation and faster decoding, use as_slice() and the various Rust standard APIs such as i8::from_be_bytes().

pub fn encode_u16(&mut self, byte_offset: usize, value: u16) -> Result<(), ()>

Encodes u16 as 2 byte(s) at position byte_offset.

Returns Err if there is not enough space left to write the value, and does nothing in that case.

Note: byte order and encoding pattern is an implementation detail. For portable byte representation and faster encoding, use as_mut_slice() and the various Rust standard APIs such as u16::to_be_bytes().

pub fn decode_u16(&self, byte_offset: usize) -> Result<u16, ()>

Decodes u16 from 2 byte(s) at position byte_offset.

Returns Err if there is not enough space left to read the value. In case Godot has other error conditions for decoding, it may return zero and print an error.

Note: byte order and encoding pattern is an implementation detail. For portable byte representation and faster decoding, use as_slice() and the various Rust standard APIs such as u16::from_be_bytes().

pub fn encode_s16(&mut self, byte_offset: usize, value: i16) -> Result<(), ()>

Encodes i16 as 2 byte(s) at position byte_offset.

Returns Err if there is not enough space left to write the value, and does nothing in that case.

Note: byte order and encoding pattern is an implementation detail. For portable byte representation and faster encoding, use as_mut_slice() and the various Rust standard APIs such as i16::to_be_bytes().

pub fn decode_s16(&self, byte_offset: usize) -> Result<i16, ()>

Decodes i16 from 2 byte(s) at position byte_offset.

Returns Err if there is not enough space left to read the value. In case Godot has other error conditions for decoding, it may return zero and print an error.

Note: byte order and encoding pattern is an implementation detail. For portable byte representation and faster decoding, use as_slice() and the various Rust standard APIs such as i16::from_be_bytes().

pub fn encode_u32(&mut self, byte_offset: usize, value: u32) -> Result<(), ()>

Encodes u32 as 4 byte(s) at position byte_offset.

Returns Err if there is not enough space left to write the value, and does nothing in that case.

Note: byte order and encoding pattern is an implementation detail. For portable byte representation and faster encoding, use as_mut_slice() and the various Rust standard APIs such as u32::to_be_bytes().

pub fn decode_u32(&self, byte_offset: usize) -> Result<u32, ()>

Decodes u32 from 4 byte(s) at position byte_offset.

Returns Err if there is not enough space left to read the value. In case Godot has other error conditions for decoding, it may return zero and print an error.

Note: byte order and encoding pattern is an implementation detail. For portable byte representation and faster decoding, use as_slice() and the various Rust standard APIs such as u32::from_be_bytes().

pub fn encode_s32(&mut self, byte_offset: usize, value: i32) -> Result<(), ()>

Encodes i32 as 4 byte(s) at position byte_offset.

Returns Err if there is not enough space left to write the value, and does nothing in that case.

Note: byte order and encoding pattern is an implementation detail. For portable byte representation and faster encoding, use as_mut_slice() and the various Rust standard APIs such as i32::to_be_bytes().

pub fn decode_s32(&self, byte_offset: usize) -> Result<i32, ()>

Decodes i32 from 4 byte(s) at position byte_offset.

Returns Err if there is not enough space left to read the value. In case Godot has other error conditions for decoding, it may return zero and print an error.

Note: byte order and encoding pattern is an implementation detail. For portable byte representation and faster decoding, use as_slice() and the various Rust standard APIs such as i32::from_be_bytes().

pub fn encode_u64(&mut self, byte_offset: usize, value: u64) -> Result<(), ()>

Encodes u64 as 8 byte(s) at position byte_offset.

Returns Err if there is not enough space left to write the value, and does nothing in that case.

Note: byte order and encoding pattern is an implementation detail. For portable byte representation and faster encoding, use as_mut_slice() and the various Rust standard APIs such as u64::to_be_bytes().

pub fn decode_u64(&self, byte_offset: usize) -> Result<u64, ()>

Decodes u64 from 8 byte(s) at position byte_offset.

Returns Err if there is not enough space left to read the value. In case Godot has other error conditions for decoding, it may return zero and print an error.

Note: byte order and encoding pattern is an implementation detail. For portable byte representation and faster decoding, use as_slice() and the various Rust standard APIs such as u64::from_be_bytes().

pub fn encode_s64(&mut self, byte_offset: usize, value: i64) -> Result<(), ()>

Encodes i64 as 8 byte(s) at position byte_offset.

Returns Err if there is not enough space left to write the value, and does nothing in that case.

Note: byte order and encoding pattern is an implementation detail. For portable byte representation and faster encoding, use as_mut_slice() and the various Rust standard APIs such as i64::to_be_bytes().

pub fn decode_s64(&self, byte_offset: usize) -> Result<i64, ()>

Decodes i64 from 8 byte(s) at position byte_offset.

Returns Err if there is not enough space left to read the value. In case Godot has other error conditions for decoding, it may return zero and print an error.

Note: byte order and encoding pattern is an implementation detail. For portable byte representation and faster decoding, use as_slice() and the various Rust standard APIs such as i64::from_be_bytes().

pub fn encode_half(&mut self, byte_offset: usize, value: f32) -> Result<(), ()>

Encodes f32 as 2 byte(s) at position byte_offset.

Returns Err if there is not enough space left to write the value, and does nothing in that case.

Note: byte order and encoding pattern is an implementation detail. For portable byte representation and faster encoding, use as_mut_slice() and the various Rust standard APIs such as f32::to_be_bytes().

pub fn decode_half(&self, byte_offset: usize) -> Result<f32, ()>

Decodes f32 from 2 byte(s) at position byte_offset.

Returns Err if there is not enough space left to read the value. In case Godot has other error conditions for decoding, it may return zero and print an error.

Note: byte order and encoding pattern is an implementation detail. For portable byte representation and faster decoding, use as_slice() and the various Rust standard APIs such as f32::from_be_bytes().

pub fn encode_float(&mut self, byte_offset: usize, value: f32) -> Result<(), ()>

Encodes f32 as 4 byte(s) at position byte_offset.

Returns Err if there is not enough space left to write the value, and does nothing in that case.

Note: byte order and encoding pattern is an implementation detail. For portable byte representation and faster encoding, use as_mut_slice() and the various Rust standard APIs such as f32::to_be_bytes().

pub fn decode_float(&self, byte_offset: usize) -> Result<f32, ()>

Decodes f32 from 4 byte(s) at position byte_offset.

Returns Err if there is not enough space left to read the value. In case Godot has other error conditions for decoding, it may return zero and print an error.

Note: byte order and encoding pattern is an implementation detail. For portable byte representation and faster decoding, use as_slice() and the various Rust standard APIs such as f32::from_be_bytes().

pub fn encode_double( &mut self, byte_offset: usize, value: f64, ) -> Result<(), ()>

Encodes f64 as 8 byte(s) at position byte_offset.

Returns Err if there is not enough space left to write the value, and does nothing in that case.

Note: byte order and encoding pattern is an implementation detail. For portable byte representation and faster encoding, use as_mut_slice() and the various Rust standard APIs such as f64::to_be_bytes().

pub fn decode_double(&self, byte_offset: usize) -> Result<f64, ()>

Decodes f64 from 8 byte(s) at position byte_offset.

Returns Err if there is not enough space left to read the value. In case Godot has other error conditions for decoding, it may return zero and print an error.

Note: byte order and encoding pattern is an implementation detail. For portable byte representation and faster decoding, use as_slice() and the various Rust standard APIs such as f64::from_be_bytes().

pub fn encode_var( &mut self, byte_offset: usize, value: impl AsArg<Variant>, allow_objects: bool, ) -> Result<usize, ()>

Encodes a Variant as bytes. Returns number of bytes written, or Err on encoding failure.

Sufficient space must be allocated, depending on the encoded variant’s size. If allow_objects is false, VariantType::OBJECT values are not permitted and will instead be serialized as ID-only. You should set allow_objects to false by default.

pub fn decode_var( &self, byte_offset: usize, allow_objects: bool, ) -> Result<(Variant, usize), ()>

Decodes a Variant from bytes and returns it, alongside the number of bytes read.

Returns Err on decoding error. If you store legit NIL variants inside the byte array, use decode_var_allow_nil() instead.

API design

Godot offers three separate methods decode_var(), decode_var_size() and has_encoded_var(). That comes with several problems:

• has_encoded_var() is practically useless, because it performs the full decoding work and then throws away the variant. decode_var() can do all that and more.
• Both has_encoded_var() and decode_var_size() are unreliable. They don’t tell whether an actual variant has been written at the location. They interpret garbage as Variant::nil() and return true or 4, respectively. This can very easily cause bugs because surprisingly, some users may expect that has_encoded_var() returns whether a variant has been encoded.
• The underlying C++ implementation has all the necessary information (whether a variant is there, how big it is and its value) but the GDExtension API returns only one info at a time, requiring re-decoding on each call.

godot-rust mitigates this somewhat, with the following design:

• decode_var() treats all NILs as errors. This is most often the desired behavior, and if not, decode_var_allow_nil() can be used. It’s also the only way to detect errors at all – once you store legit NIL values, you can no longer differentiate them from garbage.
• decode_var() returns both the decoded variant and its size. This requires two decoding runs, but only if the variant is actually valid. Again, in many cases, a user needs the size to know where follow-up data in the buffer starts.
• decode_var_size() and has_encoded_var() are not exposed.

Security

You should set allow_objects to false unless you have a good reason not to. Decoding objects (e.g. coming from remote sources) can cause arbitrary code execution.

pub fn decode_var_allow_nil( &self, byte_offset: usize, allow_objects: bool, ) -> (Variant, usize)

Unreliable Variant decoding, allowing NIL.

This method is highly unreliable and will try to interpret anything into variants, even zeroed memory or random byte patterns. Only use it if you need a 1:1 equivalent of Godot's decode_var() and decode_var_size() functions.

In the majority of cases, decode_var() is the better choice, as it’s much easier to use correctly. See also its section about the rationale behind the current API design.

Returns a tuple of two elements:

1. the decoded variant. This is Variant::nil() if a valid variant can’t be decoded, or the value is of type VariantType::OBJECT and allow_objects is false.
2. The number of bytes the variant occupies. This is 0 if running out of space, but most other failures are not recognized.

Security

You should set allow_objects to false unless you have a good reason not to. Decoding objects (e.g. coming from remote sources) can cause arbitrary code execution.

pub fn compress( &self, compression_mode: CompressionMode, ) -> Result<PackedByteArray, ()>

Returns a new PackedByteArray, with the data of this array compressed.

On failure, Godot prints an error and this method returns Err. (Note that any empty results coming from Godot are mapped to Err in Rust.)

pub fn decompress( &self, buffer_size: usize, compression_mode: CompressionMode, ) -> Result<PackedByteArray, ()>

Returns a new PackedByteArray, with the data of this array decompressed.

Set buffer_size to the size of the uncompressed data.

On failure, Godot prints an error and this method returns Err. (Note that any empty results coming from Godot are mapped to Err in Rust.)

Note: Decompression is not guaranteed to work with data not compressed by Godot, for example if data compressed with the deflate compression mode lacks a checksum or header.

pub fn decompress_dynamic( &self, max_output_size: Option<usize>, compression_mode: CompressionMode, ) -> Result<PackedByteArray, ()>

Returns a new PackedByteArray, with the data of this array decompressed, and without fixed decompression buffer.

This method only accepts BROTLI, GZIP, and DEFLATE compression modes.

This method is potentially slower than decompress(), as it may have to re-allocate its output buffer multiple times while decompressing, whereas decompress() knows its output buffer size from the beginning.

GZIP has a maximal compression ratio of 1032:1, meaning it’s very possible for a small compressed payload to decompress to a potentially very large output. To guard against this, you may provide a maximum size this function is allowed to allocate in bytes via max_output_size. Passing None will allow for unbounded output. If any positive value is passed, and the decompression exceeds that amount in bytes, then an error will be returned.

On failure, Godot prints an error and this method returns Err. (Note that any empty results coming from Godot are mapped to Err in Rust.)

Note: Decompression is not guaranteed to work with data not compressed by Godot, for example if data compressed with the deflate compression mode lacks a checksum or header.

impl PackedByteArray

pub fn get_string_from_ascii(&self) -> GString

pub fn get_string_from_utf8(&self) -> GString

pub fn get_string_from_utf16(&self) -> GString

pub fn get_string_from_utf32(&self) -> GString

pub fn get_string_from_wchar(&self) -> GString

pub fn hex_encode(&self) -> GString

Trait Implementations

impl Clone for PackedByteArray

fn clone(&self) -> PackedByteArray

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for PackedByteArray

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.

impl Default for PackedByteArray

fn default() -> PackedByteArray

Returns the “default value” for a type.

impl Display for PackedByteArray

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats PackedArray to match Godot’s string representation.

impl Drop for PackedByteArray

fn drop(&mut self)

Executes the destructor for this type.

impl Export for PackedByteArray

fn export_hint() -> PropertyHintInfo

The export info to use for an exported field of this type, if no other export info is specified.

impl Extend<u8> for PackedByteArray

Extends aPackedByteArray with the contents of an iterator

fn extend<I>(&mut self, iter: I)

where I: IntoIterator<Item = u8>,

Extends a collection with the contents of an iterator.

fn extend_one(&mut self, item: A)

🔬This is a nightly-only experimental API. (extend_one)

Extends a collection with exactly one element.

fn extend_reserve(&mut self, additional: usize)

🔬This is a nightly-only experimental API. (extend_one)

Reserves capacity in a collection for the given number of additional elements.

impl From<&[u8]> for PackedByteArray

Creates a PackedByteArray from the given slice.

fn from(slice: &[u8]) -> PackedByteArray

Converts to this type from the input type.

impl<const N: usize> From<&[u8; N]> for PackedByteArray

Creates a PackedByteArray from the given Rust array.

fn from(arr: &[u8; N]) -> PackedByteArray

Converts to this type from the input type.

impl From<&Array<Variant>> for PackedByteArray

fn from(other: &Array<Variant>) -> PackedByteArray

Converts to this type from the input type.

impl From<&PackedByteArray> for Array<Variant>

fn from(other: &PackedByteArray) -> Array<Variant>

Converts to this type from the input type.

impl<const N: usize> From<[u8; N]> for PackedByteArray

Creates a PackedByteArray from the given Rust array.

fn from(arr: [u8; N]) -> PackedByteArray

Converts to this type from the input type.

impl From<Vec<u8>> for PackedByteArray

Creates a PackedByteArray from the given Rust vec.

fn from(vec: Vec<u8>) -> PackedByteArray

Converts to this type from the input type.

impl FromGodot for PackedByteArray

fn try_from_godot( via: <PackedByteArray as GodotConvert>::Via, ) -> Result<PackedByteArray, ConvertError>

Converts the Godot representation to this type, returning Err on failure.

fn from_godot(via: Self::Via) -> Self

⚠️ Converts the Godot representation to this type.

fn try_from_variant(variant: &Variant) -> Result<Self, ConvertError>

Performs the conversion from a Variant, returning Err on failure.

fn from_variant(variant: &Variant) -> Self

⚠️ Performs the conversion from a Variant.

impl FromIterator<u8> for PackedByteArray

Creates a PackedByteArray from an iterator.

fn from_iter<I>(iter: I) -> PackedByteArray

where I: IntoIterator<Item = u8>,

Creates a value from an iterator.

impl GodotConvert for PackedByteArray

type Via = PackedByteArray

The type through which Self is represented in Godot.

impl Index<usize> for PackedByteArray

type Output = u8

The returned type after indexing.

fn index(&self, index: usize) -> &<PackedByteArray as Index<usize>>::Output

Performs the indexing (container[index]) operation.

impl IndexMut<usize> for PackedByteArray

fn index_mut( &mut self, index: usize, ) -> &mut <PackedByteArray as Index<usize>>::Output

Performs the mutable indexing (container[index]) operation.

impl ParamType for PackedByteArray

fn owned_to_arg<'v>(self) -> <PackedByteArray as ParamType>::Arg<'v>

Converts an owned value to the canonical argument type, which can be passed to impl AsArg<T>.

impl PartialEq for PackedByteArray

fn eq(&self, other: &PackedByteArray) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl ToGodot for PackedByteArray

type ToVia<'v> = <PackedByteArray as GodotConvert>::Via

Target type of to_godot(), which can differ from Via for pass-by-reference types.

fn to_godot(&self) -> <PackedByteArray as ToGodot>::ToVia<'_>

Converts this type to the Godot type by reference, usually by cloning.

fn to_variant(&self) -> Variant

Converts this type to a Variant.

impl Var for PackedByteArray

fn get_property(&self) -> <PackedByteArray as GodotConvert>::Via

fn set_property(&mut self, value: <PackedByteArray as GodotConvert>::Via)

fn var_hint() -> PropertyHintInfo

Specific property hints, only override if they deviate from GodotType::property_info, e.g. for enums/newtypes.

impl ArrayElement for PackedByteArray

impl<'r> AsArg<PackedByteArray> for &'r PackedByteArray

impl Eq for PackedByteArray

impl GodotType for PackedByteArray