Struct PackedFloat32Array
pub struct PackedFloat32Array { /* private fields */ }
Expand description
Implements Godot’s PackedFloat32Array
type,
which is a space-efficient array of f32
s.
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
impl PackedFloat32Array
pub fn new() -> PackedFloat32Array
pub fn new() -> PackedFloat32Array
Constructs an empty array.
pub fn get(&self, index: usize) -> Option<f32>
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
pub fn contains(&self, value: &f32) -> bool
Returns true
if the array contains the given value.
Godot equivalent: has
pub fn len(&self) -> usize
pub fn len(&self) -> usize
Returns the number of elements in the array. Equivalent of size()
in Godot.
pub fn clear(&mut self)
pub fn clear(&mut self)
Clears the array, removing all elements.
pub fn push(&mut self, value: f32)
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)
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
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)
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)
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)
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>
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
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]
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]
pub fn as_mut_slice(&mut self) -> &mut [f32]
pub fn find(&self, value: &f32, from: Option<usize>) -> Option<usize>
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>
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
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)
pub fn reverse(&mut self)
Reverses the order of the elements in the array.
pub fn sort(&mut self)
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
pub fn to_byte_array(&self) -> PackedByteArray
Returns a PackedByteArray
with each value encoded as bytes.
Trait Implementations§
§impl ArrayElement for PackedFloat32Array
impl ArrayElement for PackedFloat32Array
fn debug_validate_elements(_array: &Array<Self>) -> Result<(), ConvertError>
§impl Clone for PackedFloat32Array
impl Clone for PackedFloat32Array
§fn clone(&self) -> PackedFloat32Array
fn clone(&self) -> PackedFloat32Array
1.0.0 · Source§fn clone_from(&mut self, source: &Self)
fn clone_from(&mut self, source: &Self)
source
. Read more§impl Debug for PackedFloat32Array
impl Debug for PackedFloat32Array
§impl Default for PackedFloat32Array
impl Default for PackedFloat32Array
§fn default() -> PackedFloat32Array
fn default() -> PackedFloat32Array
§impl Display for PackedFloat32Array
impl Display for PackedFloat32Array
§impl Drop for PackedFloat32Array
impl Drop for PackedFloat32Array
§impl Export for PackedFloat32Array
impl Export for PackedFloat32Array
§fn export_hint() -> PropertyHintInfo
fn export_hint() -> PropertyHintInfo
§fn as_node_class() -> Option<ClassName>
fn as_node_class() -> Option<ClassName>
§impl Extend<f32> for PackedFloat32Array
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>,
fn extend<I>(&mut self, iter: I)where
I: IntoIterator<Item = f32>,
Source§fn extend_one(&mut self, item: A)
fn extend_one(&mut self, item: A)
extend_one
)Source§fn extend_reserve(&mut self, additional: usize)
fn extend_reserve(&mut self, additional: usize)
extend_one
)§impl From<&[f32]> for PackedFloat32Array
impl From<&[f32]> for PackedFloat32Array
Creates a PackedFloat32Array
from the given slice.
§fn from(slice: &[f32]) -> PackedFloat32Array
fn from(slice: &[f32]) -> PackedFloat32Array
§impl<const N: usize> From<&[f32; N]> for PackedFloat32Array
impl<const N: usize> From<&[f32; N]> for PackedFloat32Array
Creates a PackedFloat32Array
from the given Rust array.
§fn from(arr: &[f32; N]) -> PackedFloat32Array
fn from(arr: &[f32; N]) -> PackedFloat32Array
§impl From<&Array<Variant>> for PackedFloat32Array
impl From<&Array<Variant>> for PackedFloat32Array
§fn from(other: &Array<Variant>) -> PackedFloat32Array
fn from(other: &Array<Variant>) -> PackedFloat32Array
§impl From<&PackedFloat32Array> for Array<Variant>
impl From<&PackedFloat32Array> for Array<Variant>
§fn from(other: &PackedFloat32Array) -> Array<Variant>
fn from(other: &PackedFloat32Array) -> Array<Variant>
§impl<const N: usize> From<[f32; N]> for PackedFloat32Array
impl<const N: usize> From<[f32; N]> for PackedFloat32Array
Creates a PackedFloat32Array
from the given Rust array.
§fn from(arr: [f32; N]) -> PackedFloat32Array
fn from(arr: [f32; N]) -> PackedFloat32Array
§impl From<Vec<f32>> for PackedFloat32Array
impl From<Vec<f32>> for PackedFloat32Array
Creates a PackedFloat32Array
from the given Rust vec.
§fn from(vec: Vec<f32>) -> PackedFloat32Array
fn from(vec: Vec<f32>) -> PackedFloat32Array
§impl FromGodot for PackedFloat32Array
impl FromGodot for PackedFloat32Array
§fn try_from_godot(
via: <PackedFloat32Array as GodotConvert>::Via,
) -> Result<PackedFloat32Array, ConvertError>
fn try_from_godot( via: <PackedFloat32Array as GodotConvert>::Via, ) -> Result<PackedFloat32Array, ConvertError>
Err
on failure.§fn from_godot(via: Self::Via) -> Self
fn from_godot(via: Self::Via) -> Self
§fn try_from_variant(variant: &Variant) -> Result<Self, ConvertError>
fn try_from_variant(variant: &Variant) -> Result<Self, ConvertError>
Variant
, returning Err
on failure.§fn from_variant(variant: &Variant) -> Self
fn from_variant(variant: &Variant) -> Self
§impl FromIterator<f32> for PackedFloat32Array
impl FromIterator<f32> for PackedFloat32Array
Creates a PackedFloat32Array
from an iterator.
§fn from_iter<I>(iter: I) -> PackedFloat32Arraywhere
I: IntoIterator<Item = f32>,
fn from_iter<I>(iter: I) -> PackedFloat32Arraywhere
I: IntoIterator<Item = f32>,
§impl GodotConvert for PackedFloat32Array
impl GodotConvert for PackedFloat32Array
§type Via = PackedFloat32Array
type Via = PackedFloat32Array
Self
is represented in Godot.§impl Index<usize> for PackedFloat32Array
impl Index<usize> for PackedFloat32Array
§impl IndexMut<usize> for PackedFloat32Array
impl IndexMut<usize> for PackedFloat32Array
§impl PartialEq for PackedFloat32Array
impl PartialEq for PackedFloat32Array
§impl ToGodot for PackedFloat32Array
impl ToGodot for PackedFloat32Array
§type ToVia<'v> = <PackedFloat32Array as GodotConvert>::Via
type ToVia<'v> = <PackedFloat32Array as GodotConvert>::Via
to_godot()
, which differs from Via
for pass-by-reference types.§fn to_godot(&self) -> <PackedFloat32Array as ToGodot>::ToVia<'_>
fn to_godot(&self) -> <PackedFloat32Array as ToGodot>::ToVia<'_>
§fn to_variant(&self) -> Variant
fn to_variant(&self) -> Variant
§impl Var for PackedFloat32Array
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
fn var_hint() -> PropertyHintInfo
GodotType::property_info
, e.g. for enums/newtypes.impl GodotType for PackedFloat32Array
Auto Trait Implementations§
impl Freeze for PackedFloat32Array
impl RefUnwindSafe for PackedFloat32Array
impl !Send for PackedFloat32Array
impl !Sync for PackedFloat32Array
impl Unpin for PackedFloat32Array
impl UnwindSafe for PackedFloat32Array
Blanket Implementations§
Source§impl<T> BorrowMut<T> for Twhere
T: ?Sized,
impl<T> BorrowMut<T> for Twhere
T: ?Sized,
Source§fn borrow_mut(&mut self) -> &mut T
fn borrow_mut(&mut self) -> &mut T
Source§impl<T> CloneToUninit for Twhere
T: Clone,
impl<T> CloneToUninit for Twhere
T: Clone,
Source§unsafe fn clone_to_uninit(&self, dst: *mut T)
unsafe fn clone_to_uninit(&self, dst: *mut T)
clone_to_uninit
)