godot::prelude

Struct PackedFloat32Array

pub struct PackedFloat32Array { /* private fields */ }
Expand description

Implements Godot’s PackedFloat32Array type, which is a space-efficient array of f32s.

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 PackedFloat32Array 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 PackedFloat32Array

pub fn new() -> PackedFloat32Array

Constructs an empty array.

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

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: &f32) -> bool

Returns true if the array contains the given value.

Godot equivalent: has

pub fn count(&self, value: &f32) -> 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: f32)

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: f32)

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) -> f32

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: f32)

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: &PackedFloat32Array)

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

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

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

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

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) -> &[f32]

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 [f32]

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: &f32, 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: &f32, 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: &f32) -> 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_byte_array(&self) -> PackedByteArray

Returns a PackedByteArray with each value encoded as bytes.

Trait Implementations§

§

impl ArrayElement for PackedFloat32Array

§

impl Clone for PackedFloat32Array

§

fn clone(&self) -> PackedFloat32Array

Returns a copy of the value. Read more
1.0.0 · Source§

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

Performs copy-assignment from source. Read more
§

impl Debug for PackedFloat32Array

§

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

Formats the value using the given formatter. Read more
§

impl Default for PackedFloat32Array

§

fn default() -> PackedFloat32Array

Returns the “default value” for a type. Read more
§

impl Display for PackedFloat32Array

§

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

Formats PackedArray to match Godot’s string representation.

§

impl Drop for PackedFloat32Array

§

fn drop(&mut self)

Executes the destructor for this type. Read more
§

impl Export for PackedFloat32Array

§

fn export_hint() -> PropertyHintInfo

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

fn as_node_class() -> Option<ClassName>

If this is a class inheriting Node, returns the ClassName; otherwise None. Read more
§

impl Extend<f32> for PackedFloat32Array

Extends aPackedFloat32Array with the contents of an iterator

§

fn extend<I>(&mut self, iter: I)
where I: IntoIterator<Item = f32>,

Extends a collection with the contents of an iterator. Read more
Source§

fn extend_one(&mut self, item: A)

🔬This is a nightly-only experimental API. (extend_one)
Extends a collection with exactly one element.
Source§

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. Read more
§

impl From<&[f32]> for PackedFloat32Array

Creates a PackedFloat32Array from the given slice.

§

fn from(slice: &[f32]) -> PackedFloat32Array

Converts to this type from the input type.
§

impl<const N: usize> From<&[f32; N]> for PackedFloat32Array

Creates a PackedFloat32Array from the given Rust array.

§

fn from(arr: &[f32; N]) -> PackedFloat32Array

Converts to this type from the input type.
§

impl From<&Array<Variant>> for PackedFloat32Array

§

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

Converts to this type from the input type.
§

impl From<&PackedFloat32Array> for Array<Variant>

§

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

Converts to this type from the input type.
§

impl<const N: usize> From<[f32; N]> for PackedFloat32Array

Creates a PackedFloat32Array from the given Rust array.

§

fn from(arr: [f32; N]) -> PackedFloat32Array

Converts to this type from the input type.
§

impl From<Vec<f32>> for PackedFloat32Array

Creates a PackedFloat32Array from the given Rust vec.

§

fn from(vec: Vec<f32>) -> PackedFloat32Array

Converts to this type from the input type.
§

impl FromGodot for PackedFloat32Array

§

fn try_from_godot( via: <PackedFloat32Array as GodotConvert>::Via, ) -> Result<PackedFloat32Array, 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. Read more
§

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. Read more
§

impl FromIterator<f32> for PackedFloat32Array

Creates a PackedFloat32Array from an iterator.

§

fn from_iter<I>(iter: I) -> PackedFloat32Array
where I: IntoIterator<Item = f32>,

Creates a value from an iterator. Read more
§

impl GodotConvert for PackedFloat32Array

§

type Via = PackedFloat32Array

The type through which Self is represented in Godot.
§

impl Index<usize> for PackedFloat32Array

§

type Output = f32

The returned type after indexing.
§

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

Performs the indexing (container[index]) operation. Read more
§

impl IndexMut<usize> for PackedFloat32Array

§

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

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

impl PartialEq for PackedFloat32Array

§

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

Tests for self and other values to be equal, and is used by ==.
1.0.0 · Source§

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 PackedFloat32Array

§

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

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

fn to_godot(&self) -> <PackedFloat32Array 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 PackedFloat32Array

§

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

§

fn set_property(&mut self, value: <PackedFloat32Array 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 GodotType for PackedFloat32Array

Auto Trait Implementations§

Blanket Implementations§

Source§

impl<T> Any for T
where T: 'static + ?Sized,

Source§

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more
Source§

impl<T> Borrow<T> for T
where T: ?Sized,

Source§

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more
Source§

impl<T> BorrowMut<T> for T
where T: ?Sized,

Source§

fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more
Source§

impl<T> CloneToUninit for T
where T: Clone,

Source§

unsafe fn clone_to_uninit(&self, dst: *mut T)

🔬This is a nightly-only experimental API. (clone_to_uninit)
Performs copy-assignment from self to dst. Read more
Source§

impl<T> From<T> for T

Source§

fn from(t: T) -> T

Returns the argument unchanged.

Source§

impl<T, U> Into<U> for T
where U: From<T>,

Source§

fn into(self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of From<T> for U chooses to do.

Source§

impl<T> ToOwned for T
where T: Clone,

Source§

type Owned = T

The resulting type after obtaining ownership.
Source§

fn to_owned(&self) -> T

Creates owned data from borrowed data, usually by cloning. Read more
Source§

fn clone_into(&self, target: &mut T)

Uses borrowed data to replace owned data, usually by cloning. Read more
Source§

impl<T> ToString for T
where T: Display + ?Sized,

Source§

default fn to_string(&self) -> String

Converts the given value to a String. Read more
Source§

impl<T, U> TryFrom<U> for T
where U: Into<T>,

Source§

type Error = Infallible

The type returned in the event of a conversion error.
Source§

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

Performs the conversion.
Source§

impl<T, U> TryInto<U> for T
where U: TryFrom<T>,

Source§

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.
Source§

fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.