ufbx

https://docs.rs/ufbx/0.9.0/ufbx/
Admin
ufbx is a Rust library for parsing and working with FBX (Autodesk FBX) 3D model files, providing...
Tokens:292,452
Snippets:2,661
Trust Score:9.7
Update:1 month ago
Show doc for...
Tokens:
Raw
### Trim start matches example

Source: https://docs.rs/ufbx/0.9.0/ufbx/prelude/struct.String.html?search=

Demonstrates removing a slice of characters from the start of a string.

```rust
let x: &[_] = &['1', '2'];
assert_eq!("12foo1bar12".trim_start_matches(x), "foo1bar12");
```

--------------------------------

### Trim Start and End Examples

Source: https://docs.rs/ufbx/0.9.0/ufbx/prelude/struct.String.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Demonstrates trimming whitespace from the start and end of strings, including handling of right-to-left languages.

```rust
let s = "  עברית  ";
assert!(Some('ע') == s.trim_start().chars().next());
```

```rust
let s = "\n Hello\tworld\t\n";
assert_eq!("\n Hello\tworld", s.trim_end());
```

```rust
let s = "  English  ";
assert!(Some('h') == s.trim_end().chars().rev().next());

let s = "  עברית  ";
assert!(Some('ת') == s.trim_end().chars().rev().next());
```

--------------------------------

### String Length Methods

Source: https://docs.rs/ufbx/0.9.0/ufbx/prelude/struct.String.html?search=u32+-%3E+bool

Examples for checking string length and emptiness.

```rust
let len = "foo".len();
assert_eq!(3, len);

assert_eq!("ƒoo".len(), 4); // fancy f!
assert_eq!("ƒoo".chars().count(), 3);
```

```rust
let s = "";
assert!(s.is_empty());

let s = "not empty";
assert!(!s.is_empty());
```

--------------------------------

### starts_with<P>(pat: P) -> bool

Source: https://docs.rs/ufbx/0.9.0/ufbx/prelude/struct.String.html?search=

Checks if the string starts with the given pattern.

```APIDOC
## pub fn starts_with<P>(&self, pat: P) -> bool

### Description
Returns `true` if the given pattern matches a prefix of this string slice.
```

--------------------------------

### starts_with

Source: https://docs.rs/ufbx/0.9.0/ufbx/prelude/struct.Blob.html?search=

Checks if the slice starts with the given prefix.

```APIDOC
## pub fn starts_with(&self, needle: &[T]) -> bool

### Description
Returns true if needle is a prefix of the slice or equal to the slice. Always returns true if needle is an empty slice.
```

--------------------------------

### Deprecated Trim Left and Right Examples

Source: https://docs.rs/ufbx/0.9.0/ufbx/prelude/struct.String.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Examples for deprecated trim_left and trim_right methods, which are superseded by trim_start and trim_end.

```rust
let s = " Hello\tworld\t";

assert_eq!("Hello\tworld\t", s.trim_left());
```

```rust
let s = "  English";
assert!(Some('E') == s.trim_left().chars().next());

let s = "  עברית";
assert!(Some('ע') == s.trim_left().chars().next());
```

```rust
let s = " Hello\tworld\t";

assert_eq!(" Hello\tworld", s.trim_right());
```

```rust
let s = "English  ";
assert!(Some('h') == s.trim_right().chars().rev().next());

let s = "עברית  ";
assert!(Some('ת') == s.trim_right().chars().rev().next());
```

--------------------------------

### starts_with

Source: https://docs.rs/ufbx/0.9.0/ufbx/prelude/struct.List.html?search=std%3A%3Avec

Returns true if the slice starts with the provided needle.

```APIDOC
## starts_with(&self, needle: &[T]) -> bool

### Description
Returns `true` if `needle` is a prefix of the slice or equal to the slice.
```

--------------------------------

### Trim start whitespace in Rust

Source: https://docs.rs/ufbx/0.9.0/ufbx/prelude/struct.String.html?search=

Demonstrates removing leading whitespace from a string slice, noting that 'start' refers to the first byte position regardless of text directionality.

```rust
let s = "  עברית  ";
assert!(Some('ע') == s.trim_start().chars().next());
```

--------------------------------

### Strip prefix example

Source: https://docs.rs/ufbx/0.9.0/ufbx/prelude/struct.String.html?search=

Removes a prefix exactly once if present, returning an Option.

```rust
assert_eq!("foo:bar".strip_prefix("foo:"), Some("bar"));
assert_eq!("foo:bar".strip_prefix("bar"), None);
assert_eq!("foofoo".strip_prefix("foo"), Some("foo"));
```

--------------------------------

### Check string prefix

Source: https://docs.rs/ufbx/0.9.0/ufbx/prelude/struct.String.html?search=

Returns true if the pattern matches the start of the string slice.

```rust
let bananas = "bananas";

assert!(bananas.starts_with("bana"));
assert!(!bananas.starts_with("nana"));
```

```rust
let bananas = "bananas";

// Note that both of these assert successfully.
assert!(bananas.starts_with(&['b', 'a', 'n', 'a']));
assert!(bananas.starts_with(&['a', 'b', 'c', 'd']));
```

--------------------------------

### Verify slice prefixes with starts_with

Source: https://docs.rs/ufbx/0.9.0/ufbx/prelude/struct.Blob.html

Checks if a slice starts with a given prefix. Always returns true for an empty needle.

```rust
let v = [10, 40, 30];
assert!(v.starts_with(&[10]));
assert!(v.starts_with(&[10, 40]));
assert!(v.starts_with(&v));
assert!(!v.starts_with(&[50]));
assert!(!v.starts_with(&[10, 50]));
```

```rust
let v = &[10, 40, 30];
assert!(v.starts_with(&[]));
let v: &[u8] = &[];
assert!(v.starts_with(&[]));
```

--------------------------------

### Trim prefix example

Source: https://docs.rs/ufbx/0.9.0/ufbx/prelude/struct.String.html?search=

Nightly-only API that removes a prefix if present, returning the original string otherwise.

```rust
#![feature(trim_prefix_suffix)]

// Prefix present - removes it
assert_eq!("foo:bar".trim_prefix("foo:"), "bar");
assert_eq!("foofoo".trim_prefix("foo"), "foo");

// Prefix absent - returns original string
assert_eq!("foo:bar".trim_prefix("bar"), "foo:bar");

// Method chaining example
assert_eq!("<https://example.com/>".trim_prefix('<').trim_suffix('>'), "https://example.com/");
```

--------------------------------

### pub fn load_stdio_prefix

Source: https://docs.rs/ufbx/0.9.0/ufbx/generated/fn.load_stdio_prefix.html?search=

Loads a scene from a standard I/O file pointer with a prefix.

```APIDOC
## pub fn load_stdio_prefix

### Description
Loads a scene from a file pointer with a given prefix and load options.

### Signature
`pub fn load_stdio_prefix(file: *mut c_void, prefix: &[u8], opts: LoadOpts<'_>) -> Result<SceneRoot>`

### Parameters
- **file** (*mut c_void) - The file pointer to load from.
- **prefix** (&[u8]) - The prefix to apply during loading.
- **opts** (LoadOpts<'_>) - Configuration options for the load operation.

### Returns
- **Result<SceneRoot>** - Returns a Result containing the SceneRoot on success, or an error.
```

--------------------------------

### pub fn load_stdio_prefix

Source: https://docs.rs/ufbx/0.9.0/ufbx/generated/fn.load_stdio_prefix.html

Loads a scene from a file pointer with a prefix and load options.

```APIDOC
## Function: load_stdio_prefix

### Description
Loads a scene from a file pointer with a specified prefix and load options.

### Signature
`pub fn load_stdio_prefix(file: *mut c_void, prefix: &[u8], opts: LoadOpts<'_>) -> Result<SceneRoot>`

### Parameters
- **file** (*mut c_void) - A pointer to the file source.
- **prefix** (&[u8]) - The prefix to apply during loading.
- **opts** (LoadOpts<'_>) - Configuration options for the loading process.

### Returns
- **Result<SceneRoot>** - Returns a Result containing the SceneRoot on success, or an error.
```

--------------------------------

### get

Source: https://docs.rs/ufbx/0.9.0/ufbx/prelude/struct.String.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Safely retrieves a subslice of the string.

```APIDOC
## pub fn get<I>(&self, i: I) -> Option<&<I as SliceIndex<str>>::Output>

Returns a subslice of the string, or None if the index is out of bounds or not on a UTF-8 boundary.
```

--------------------------------

### as_array

Source: https://docs.rs/ufbx/0.9.0/ufbx/prelude/struct.List.html?search=std%3A%3Avec

Gets a reference to the underlying array.

```APIDOC
## pub fn as_array<const N: usize>(&self) -> Option<&[T; N]>

### Description
Gets a reference to the underlying array. If N is not exactly equal to the length of the slice, this method returns None.
```

--------------------------------

### pub fn load_stdio(file: *mut c_void, opts: LoadOpts<'_>) -> Result<SceneRoot>

Source: https://docs.rs/ufbx/0.9.0/ufbx/generated/fn.load_stdio.html

Loads a scene from a provided file pointer using the specified load options.

```APIDOC
## Function: load_stdio

### Description
Loads a scene from a standard I/O file pointer. This function returns a `Result` containing the `SceneRoot` upon success.

### Signature
`pub fn load_stdio(file: *mut c_void, opts: LoadOpts<'_>) -> Result<SceneRoot>`

### Parameters
- **file** (*mut c_void) - A pointer to the file source.
- **opts** (LoadOpts<'_>) - Configuration options for the loading process.

### Returns
- **Result<SceneRoot>** - The loaded scene root or an error if the operation fails.
```

--------------------------------

### pub unsafe fn load_stdio_prefix_raw

Source: https://docs.rs/ufbx/0.9.0/ufbx/generated/fn.load_stdio_prefix_raw.html?search=

Loads a scene from a raw standard I/O file pointer with a byte prefix and configuration options.

```APIDOC
## Function: load_stdio_prefix_raw

### Description
Loads a scene from a raw standard I/O file pointer, applying a byte prefix and specific loading options.

### Signature
`pub unsafe fn load_stdio_prefix_raw(file: *mut c_void, prefix: &[u8], opts: &RawLoadOpts) -> Result<SceneRoot>`

### Parameters
- **file** (*mut c_void) - A pointer to the standard I/O file source.
- **prefix** (&[u8]) - A byte slice representing the prefix to be used during the load process.
- **opts** (&RawLoadOpts) - Configuration options for the raw load operation.

### Returns
- **Result<SceneRoot>** - Returns a Result containing the loaded SceneRoot on success, or an error.
```

--------------------------------

### as_array

Source: https://docs.rs/ufbx/0.9.0/ufbx/prelude/struct.RefList.html?search=std%3A%3Avec

Gets a reference to the underlying array if the length matches.

```APIDOC
## pub fn as_array<const N: usize>(&self) -> Option<&[T; N]>

### Description
Gets a reference to the underlying array. If N is not exactly equal to the length of self, then this method returns None.
```

--------------------------------

### pub fn as_video<'a>(element: &'a Element) -> Option<&'a Video>

Source: https://docs.rs/ufbx/0.9.0/ufbx/generated/fn.as_video.html?search=

Attempts to interpret the given Element as a Video. Returns Some(&Video) if the element is a video, otherwise returns None.

```APIDOC
## Function: as_video

### Description
Attempts to cast a generic `Element` to a `Video` type. This is a safe way to check if an element is a video and retrieve a reference to it.

### Signature
`pub fn as_video<'a>(element: &'a Element) -> Option<&'a Video>`

### Parameters
- **element** (&'a Element) - Required - The element to attempt to cast to a video.

### Returns
- **Option<&'a Video>** - Returns `Some(&Video)` if the element is a video, otherwise `None`.
```

--------------------------------

### load_stdio_prefix_raw

Source: https://docs.rs/ufbx/0.9.0/ufbx/generated/fn.load_stdio_prefix_raw.html?search=std%3A%3Avec

Loads a scene from a standard I/O file pointer with a prefix and raw options.

```APIDOC
## Function: load_stdio_prefix_raw

### Description
Loads a scene from a raw file pointer using a specified prefix and load options.

### Signature
`pub unsafe fn load_stdio_prefix_raw(file: *mut c_void, prefix: &[u8], opts: &RawLoadOpts) -> Result<SceneRoot>`

### Parameters
- **file** (*mut c_void) - A pointer to the file source.
- **prefix** (&[u8]) - A byte slice representing the prefix to use during loading.
- **opts** (&RawLoadOpts) - Configuration options for the raw load process.

### Returns
- **Result<SceneRoot>** - Returns a Result containing the loaded SceneRoot or an error.
```

--------------------------------

### Checking Result Status

Source: https://docs.rs/ufbx/0.9.0/ufbx/generated/type.Result.html

Examples of checking if a Result is Ok or Err.

```rust
let x: Result<i32, &str> = Ok(-3);
assert_eq!(x.is_ok(), true);

let x: Result<i32, &str> = Err("Some error message");
assert_eq!(x.is_ok(), false);
```

```rust
let x: Result<i32, &str> = Ok(-3);
assert_eq!(x.is_err(), false);

let x: Result<i32, &str> = Err("Some error message");
assert_eq!(x.is_err(), true);
```

--------------------------------

### pub fn as_video<'a>(element: &'a Element) -> Option<&'a Video>

Source: https://docs.rs/ufbx/0.9.0/ufbx/generated/fn.as_video.html

Attempts to interpret a generic Element as a Video. Returns Some(&Video) if the element is a video, otherwise returns None.

```APIDOC
## Function: as_video

### Description
Attempts to cast a generic `Element` reference to a `Video` reference. This is used to safely access video-specific properties when the underlying element type is known to be a video.

### Signature
`pub fn as_video<'a>(element: &'a Element) -> Option<&'a Video>`

### Parameters
- **element** (&'a Element) - Required - A reference to the generic element to be converted.

### Returns
- **Option<&'a Video>** - Returns `Some(&Video)` if the element is a video, otherwise `None`.
```

--------------------------------

### as_array<const N: usize>

Source: https://docs.rs/ufbx/0.9.0/ufbx/prelude/struct.Blob.html?search=u32+-%3E+bool

Gets a reference to the underlying array.

```APIDOC
## as_array<const N: usize>

### Description
Gets a reference to the underlying array. If N is not exactly equal to the length of the slice, this method returns None.
```

--------------------------------

### pub unsafe fn load_stdio_prefix_raw

Source: https://docs.rs/ufbx/0.9.0/ufbx/generated/fn.load_stdio_prefix_raw.html

Loads a scene from a standard I/O file pointer using a byte prefix and raw load options.

```APIDOC
## Function: load_stdio_prefix_raw

### Description
Loads a scene from a standard I/O file pointer with a specified prefix and raw load options. This function is marked as unsafe.

### Signature
`pub unsafe fn load_stdio_prefix_raw(file: *mut c_void, prefix: &[u8], opts: &RawLoadOpts) -> Result<SceneRoot>`

### Parameters
- **file** (*mut c_void) - A pointer to the standard I/O file.
- **prefix** (&[u8]) - A byte slice representing the prefix.
- **opts** (&RawLoadOpts) - Configuration options for the raw load process.

### Returns
- **Result<SceneRoot>** - Returns a Result containing the SceneRoot on success, or an error.
```

--------------------------------

### get<I>

Source: https://docs.rs/ufbx/0.9.0/ufbx/prelude/struct.Blob.html?search=u32+-%3E+bool

Returns a reference to an element or subslice depending on the type of index.

```APIDOC
## get<I>

### Description
Returns a reference to an element or subslice depending on the type of index. If given a position, returns a reference to the element at that position or None if out of bounds. If given a range, returns the subslice corresponding to that range, or None if out of bounds.
```

--------------------------------

### ufbx::load_stdio_prefix

Source: https://docs.rs/ufbx/0.9.0/ufbx/generated/fn.load_stdio_prefix.html?search=u32+-%3E+bool

Loads a scene from a standard I/O file pointer using the provided prefix and load options.

```APIDOC
## Function: load_stdio_prefix

### Description
Loads a scene from a standard I/O file pointer with a specified prefix and load options.

### Signature
`pub fn load_stdio_prefix(file: *mut c_void, prefix: &[u8], opts: LoadOpts<'_>) -> Result<SceneRoot>`

### Parameters
- **file** (*mut c_void) - The file pointer to load from.
- **prefix** (&[u8]) - The prefix to use during loading.
- **opts** (LoadOpts<'_>) - The loading options.

### Returns
- **Result<SceneRoot>** - Returns a Result containing the SceneRoot on success, or an error.
```

--------------------------------

### pub fn load_file(filename: &str, opts: LoadOpts<'_>) -> Result<SceneRoot>

Source: https://docs.rs/ufbx/0.9.0/ufbx/generated/fn.load_file.html

Loads a file from the specified path using the provided load options and returns a Result containing the SceneRoot or an error.

```APIDOC
## load_file

### Description
Loads a 3D scene file from the given path into a `SceneRoot` structure. This function uses the provided `LoadOpts` to configure the loading process.

### Signature
`pub fn load_file(filename: &str, opts: LoadOpts<'_>) -> Result<SceneRoot>`

### Parameters
- **filename** (&str) - The path to the file to be loaded.
- **opts** (LoadOpts<'_>) - Configuration options for the loading process.

### Returns
- **Result<SceneRoot>** - Returns a `SceneRoot` object on success, or an error if the file could not be loaded.
```

--------------------------------

### Iterate over slice

Source: https://docs.rs/ufbx/0.9.0/ufbx/prelude/struct.Blob.html

Returns an iterator over the slice yielding all items from start to end.

```rust
let x = &[1, 2, 4];
let mut iterator = x.iter();

assert_eq!(iterator.next(), Some(&1));
assert_eq!(iterator.next(), Some(&2));
assert_eq!(iterator.next(), Some(&4));
assert_eq!(iterator.next(), None);
```

--------------------------------

### Trim end matches example

Source: https://docs.rs/ufbx/0.9.0/ufbx/prelude/struct.String.html?search=

Repeatedly removes suffixes that match a pattern.

```rust
assert_eq!("11foo1bar11".trim_end_matches('1'), "11foo1bar");
assert_eq!("123foo1bar123".trim_end_matches(char::is_numeric), "123foo1bar");
```

--------------------------------

### pub fn repeat(&self, n: usize) -> String

Source: https://docs.rs/ufbx/0.9.0/ufbx/prelude/struct.String.html?search=std%3A%3Avec

Creates a new String by repeating the string slice n times.

```APIDOC
## pub fn repeat(&self, n: usize) -> String

### Description
Creates a new String by concatenating the string slice n times.

### Parameters
- **n** (usize) - The number of times to repeat the string.

### Returns
- **String** - The repeated string.

### Panics
- Panics if the resulting capacity would overflow.
```

--------------------------------

### Strip suffix example

Source: https://docs.rs/ufbx/0.9.0/ufbx/prelude/struct.String.html?search=

Removes a suffix exactly once if present, returning an Option.

```rust
assert_eq!("bar:foo".strip_suffix(":foo"), Some("bar"));
assert_eq!("bar:foo".strip_suffix("bar"), None);
assert_eq!("foofoo".strip_suffix("foo"), Some("foo"));
```

--------------------------------

### load_stdio_prefix_raw

Source: https://docs.rs/ufbx/0.9.0/ufbx/generated/fn.load_stdio_prefix_raw.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Loads a scene from a raw file pointer using the provided prefix and options.

```APIDOC
## Function: load_stdio_prefix_raw

### Description
Loads a scene from a standard I/O file pointer with a specified prefix and raw load options. This is an unsafe function.

### Signature
`pub unsafe fn load_stdio_prefix_raw(file: *mut c_void, prefix: &[u8], opts: &RawLoadOpts) -> Result<SceneRoot>`

### Parameters
- **file** (*mut c_void) - A pointer to the file source.
- **prefix** (&[u8]) - The prefix to apply during loading.
- **opts** (&RawLoadOpts) - Configuration options for the raw load process.

### Returns
- **Result<SceneRoot>** - Returns a Result containing the loaded SceneRoot or an error.
```

--------------------------------

### load_stdio_prefix_raw

Source: https://docs.rs/ufbx/0.9.0/ufbx/generated/fn.load_stdio_prefix_raw.html?search=u32+-%3E+bool

Loads a scene from a raw file pointer using the provided prefix and options.

```APIDOC
## Function: load_stdio_prefix_raw

### Description
Loads a scene from a raw file pointer (`*mut c_void`) with a specified byte prefix and `RawLoadOpts` configuration. This is an unsafe function.

### Signature
`pub unsafe fn load_stdio_prefix_raw(file: *mut c_void, prefix: &[u8], opts: &RawLoadOpts) -> Result<SceneRoot>`

### Parameters
- **file** (*mut c_void) - A raw pointer to the file source.
- **prefix** (&[u8]) - A byte slice representing the prefix to be used during loading.
- **opts** (&RawLoadOpts) - Configuration options for the raw load process.

### Returns
- **Result<SceneRoot>** - Returns a `Result` containing the `SceneRoot` on success, or an error if the loading fails.
```

--------------------------------

### ufbx_load_stdio_prefix

Source: https://docs.rs/ufbx/0.9.0/ufbx/generated/fn.ufbx_load_stdio_prefix.html

Loads a scene from a standard I/O file pointer with a specified prefix buffer.

```APIDOC
## ufbx_load_stdio_prefix

### Description
Loads a scene from a provided file pointer, optionally prepending a buffer (prefix) to the stream. This is an unsafe C function used for low-level file loading.

### Signature
`pub unsafe extern "C" fn ufbx_load_stdio_prefix(file: *mut c_void, prefix: *const c_void, prefix_size: usize, opts: *const RawLoadOpts, error: *mut Error) -> *mut Scene`

### Parameters
- **file** (*mut c_void) - A pointer to the file stream.
- **prefix** (*const c_void) - A pointer to the prefix data buffer.
- **prefix_size** (usize) - The size of the prefix buffer in bytes.
- **opts** (*const RawLoadOpts) - Pointer to the load options structure.
- **error** (*mut Error) - Pointer to an error structure to populate if loading fails.

### Returns
- ***mut Scene** - A pointer to the loaded Scene object, or null if an error occurred.
```

--------------------------------

### Find match indices with match_indices()

Source: https://docs.rs/ufbx/0.9.0/ufbx/prelude/struct.String.html?search=

Returns an iterator over disjoint matches and their starting indices.

```rust
let v: Vec<_> = "abcXXXabcYYYabc".match_indices("abc").collect();
assert_eq!(v, [(0, "abc"), (6, "abc"), (12, "abc")]);

let v: Vec<_> = "1abcabc2".match_indices("abc").collect();
assert_eq!(v, [(1, "abc"), (4, "abc")]);

let v: Vec<_> = "ababa".match_indices("aba").collect();
assert_eq!(v, [(0, "aba")]); // only the first `aba`
```

--------------------------------

### ufbx::load_stdio

Source: https://docs.rs/ufbx/0.9.0/ufbx/generated/fn.load_stdio.html?search=std%3A%3Avec

Loads a scene from a standard I/O file pointer.

```APIDOC
## Function: ufbx::load_stdio

### Description
Loads a scene from a provided file pointer with the given load options.

### Signature
`pub fn load_stdio(file: *mut c_void, opts: LoadOpts<'_>) -> Result<SceneRoot>`

### Parameters
- **file** (*mut c_void) - A pointer to the file to be loaded.
- **opts** (LoadOpts<'_>) - Configuration options for the loading process.

### Returns
- **Result<SceneRoot>** - Returns a Result containing the loaded SceneRoot on success, or an error if the operation fails.
```

--------------------------------

### pub unsafe fn load_stream_prefix_raw

Source: https://docs.rs/ufbx/0.9.0/ufbx/generated/fn.load_stream_prefix_raw.html

Loads a scene from a raw stream with a prefix and options.

```APIDOC
## Function: load_stream_prefix_raw

### Description
Loads a scene from a raw stream, applying a specific prefix and load options. This function is marked as unsafe.

### Signature
`pub unsafe fn load_stream_prefix_raw(stream: &RawStream, prefix: &[u8], opts: &RawLoadOpts) -> Result<SceneRoot>`

### Parameters
- **stream** (&RawStream) - The raw stream to load from.
- **prefix** (&[u8]) - The byte prefix to apply.
- **opts** (&RawLoadOpts) - The options for the raw load operation.

### Returns
- **Result<SceneRoot>** - Returns a Result containing the SceneRoot on success, or an error.
```

--------------------------------

### rchunks

Source: https://docs.rs/ufbx/0.9.0/ufbx/prelude/struct.List.html

Returns an iterator over chunk_size elements of the slice at a time, starting at the end of the slice.

```APIDOC
## pub fn rchunks(&self, chunk_size: usize) -> RChunks<'_, T>

### Description
Returns an iterator over chunk_size elements of the slice at a time, starting at the end of the slice. The chunks are slices and do not overlap. Panics if chunk_size is zero.
```

--------------------------------

### chunks

Source: https://docs.rs/ufbx/0.9.0/ufbx/prelude/struct.Blob.html

Returns an iterator over chunk_size elements of the slice at a time, starting at the beginning of the slice.

```APIDOC
## pub fn chunks(&self, chunk_size: usize) -> Chunks<'_, T>

### Description
Returns an iterator over `chunk_size` elements of the slice at a time, starting at the beginning of the slice. The chunks are slices and do not overlap. If `chunk_size` does not divide the length of the slice, then the last chunk will not have length `chunk_size`.

### Panics
Panics if `chunk_size` is zero.
```

--------------------------------

### pub fn as_light<'a>(element: &'a Element) -> Option<&'a Light>

Source: https://docs.rs/ufbx/0.9.0/ufbx/generated/fn.as_light.html

Attempts to interpret the given element as a light source. Returns Some(&Light) if the element is a light, otherwise returns None.

```APIDOC
## Function: as_light

### Description
Attempts to cast a generic `Element` to a `Light` reference. This is used to safely access light-specific properties if the element type is confirmed to be a light.

### Signature
`pub fn as_light<'a>(element: &'a Element) -> Option<&'a Light>`

### Parameters
- **element** (&'a Element) - The element to attempt to cast to a light.

### Returns
- **Option<&'a Light>** - Returns `Some` containing a reference to the `Light` if the element is a light, otherwise `None`.
```

--------------------------------

### Cloning Result Contents

Source: https://docs.rs/ufbx/0.9.0/ufbx/generated/type.Result.html?search=

Examples of using .cloned() to clone the contents of an Ok variant.

```rust
let val = 12;
let x: Result<&i32, i32> = Ok(&val);
assert_eq!(x, Ok(&12));
let cloned = x.cloned();
assert_eq!(cloned, Ok(12));
```

```rust
let mut val = 12;
let x: Result<&mut i32, i32> = Ok(&mut val);
assert_eq!(x, Ok(&mut 12));
let cloned = x.cloned();
assert_eq!(cloned, Ok(12));
```

--------------------------------

### pub fn load_memory(data: &[u8], opts: LoadOpts<'_>) -> Result<SceneRoot>

Source: https://docs.rs/ufbx/0.9.0/ufbx/generated/fn.load_memory.html

Loads a scene from a byte slice in memory. Returns a Result containing the SceneRoot on success.

```APIDOC
## load_memory

### Description
Loads a scene from a byte slice in memory using the provided load options.

### Signature
`pub fn load_memory(data: &[u8], opts: LoadOpts<'_>) -> Result<SceneRoot>`

### Parameters
- **data** (&[u8]) - The raw byte data of the file to load.
- **opts** (LoadOpts<'_>) - Configuration options for the loading process.

### Returns
- **Result<SceneRoot>** - Returns a Result containing the loaded SceneRoot or an error if the operation fails.
```

--------------------------------

### ufbx_load_stdio

Source: https://docs.rs/ufbx/0.9.0/ufbx/generated/fn.ufbx_load_stdio.html

Loads a scene from a standard I/O file pointer using the provided options and error handling structure.

```APIDOC
## ufbx_load_stdio

### Signature
`pub unsafe extern "C" fn ufbx_load_stdio(file: *mut c_void, opts: *const RawLoadOpts, error: *mut Error) -> *mut Scene`

### Description
Loads a scene from a standard I/O file pointer. This function is part of the C-compatible API for the ufbx library.

### Parameters
- **file** (*mut c_void) - Required - A pointer to the file stream to load from.
- **opts** (*const RawLoadOpts) - Required - A pointer to the load options configuration.
- **error** (*mut Error) - Required - A pointer to an error structure to populate if the operation fails.

### Returns
- ***mut Scene** - A pointer to the loaded Scene object, or null if an error occurred.
```

--------------------------------

### Copying Result Contents

Source: https://docs.rs/ufbx/0.9.0/ufbx/generated/type.Result.html?search=

Examples of using .copied() to copy the contents of an Ok variant.

```rust
let val = 12;
let x: Result<&i32, i32> = Ok(&val);
assert_eq!(x, Ok(&12));
let copied = x.copied();
assert_eq!(copied, Ok(12));
```

```rust
let mut val = 12;
let x: Result<&mut i32, i32> = Ok(&mut val);
assert_eq!(x, Ok(&mut 12));
let copied = x.copied();
assert_eq!(copied, Ok(12));
```

--------------------------------

### Get Raw Pointer

Source: https://docs.rs/ufbx/0.9.0/ufbx/prelude/struct.String.html?search=

Retrieves a raw pointer to the first byte of the string slice.

```rust
let s = "Hello";
let ptr = s.as_ptr();
```

--------------------------------

### open_file_ctx_raw

Source: https://docs.rs/ufbx/0.9.0/ufbx/generated/fn.open_file_ctx_raw.html?search=std%3A%3Avec

Opens a file using the provided raw stream, context, path, and options.

```APIDOC
## Function: open_file_ctx_raw

### Signature
`pub unsafe fn open_file_ctx_raw(stream: &mut RawStream, ctx: OpenFileContext, path: &str, opts: &OpenFileOpts) -> Result<bool>`

### Description
This function is used to open a file within the ufbx library. It requires a mutable reference to a `RawStream`, an `OpenFileContext`, a file path string, and `OpenFileOpts` configuration.

### Parameters
- **stream** (&mut RawStream) - The raw stream to be used for file operations.
- **ctx** (OpenFileContext) - The context for opening the file.
- **path** (&str) - The path to the file.
- **opts** (&OpenFileOpts) - Options for opening the file.

### Returns
- **Result<bool>** - Returns a result indicating success or failure, with a boolean value.
```

--------------------------------

### open_file_ctx_raw

Source: https://docs.rs/ufbx/0.9.0/ufbx/generated/fn.open_file_ctx_raw.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Opens a file context using a raw stream, context, path, and options.

```APIDOC
## Function: open_file_ctx_raw

### Description
Opens a file context using the provided raw stream, context, path, and options. This function is marked as unsafe.

### Signature
`pub unsafe fn open_file_ctx_raw(stream: &mut RawStream, ctx: OpenFileContext, path: &str, opts: &OpenFileOpts) -> Result<bool>`

### Parameters
- **stream** (&mut RawStream) - The raw stream to read from.
- **ctx** (OpenFileContext) - The context for opening the file.
- **path** (&str) - The file path.
- **opts** (&OpenFileOpts) - Options for opening the file.

### Returns
- **Result<bool>** - Returns Ok(true) on success, or an error.
```

--------------------------------

### Trim ASCII whitespace from start

Source: https://docs.rs/ufbx/0.9.0/ufbx/prelude/struct.String.html

Remove leading ASCII whitespace characters from a string slice.

```rust
assert_eq!(" \t \u{3000}hello world\n".trim_ascii_start(), "\u{3000}hello world\n");
assert_eq!("  ".trim_ascii_start(), "");
assert_eq!("".trim_ascii_start(), "");
```

--------------------------------

### Trim start matching patterns in Rust

Source: https://docs.rs/ufbx/0.9.0/ufbx/prelude/struct.String.html?search=

Removes prefixes that match a provided pattern repeatedly.

```rust
assert_eq!("11foo1bar11".trim_start_matches('1'), "foo1bar11");
assert_eq!("123foo1bar123".trim_start_matches(char::is_numeric), "foo1bar123");
```

--------------------------------

### ufbx_open_file_ctx

Source: https://docs.rs/ufbx/0.9.0/ufbx/generated/fn.ufbx_open_file_ctx.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Opens a file context using the provided stream, path, and options.

```APIDOC
## ufbx_open_file_ctx

### Description
Opens a file context for processing. This is a low-level C-compatible function used to initialize file access within the ufbx library.

### Signature
`pub unsafe extern "C" fn ufbx_open_file_ctx(stream: *mut RawStream, ctx: OpenFileContext, path: *const u8, path_len: usize, opts: *const OpenFileOpts, error: *mut Error) -> bool`

### Parameters
- **stream** (*mut RawStream) - Pointer to the raw stream.
- **ctx** (OpenFileContext) - The file context to initialize.
- **path** (*const u8) - Pointer to the file path string.
- **path_len** (usize) - Length of the file path.
- **opts** (*const OpenFileOpts) - Pointer to the open file options.
- **error** (*mut Error) - Pointer to an error structure to populate if the operation fails.

### Returns
- **bool** - Returns true if the file context was opened successfully, false otherwise.
```

--------------------------------

### ufbx_load_file

Source: https://docs.rs/ufbx/0.9.0/ufbx/generated/fn.ufbx_load_file.html

Loads a scene from a file path using the provided options and returns a pointer to the loaded scene.

```APIDOC
## Function: ufbx_load_file

### Description
Loads a scene from a specified file path. This function is an unsafe C-compatible interface.

### Signature
`pub unsafe extern "C" fn ufbx_load_file(filename: *const u8, opts: *const RawLoadOpts, error: *mut Error) -> *mut Scene`

### Parameters
- **filename** (*const u8) - A pointer to a null-terminated string representing the path to the file.
- **opts** (*const RawLoadOpts) - A pointer to the load options structure.
- **error** (*mut Error) - A pointer to an error structure that will be populated if the operation fails.

### Returns
- ***mut Scene** - A pointer to the loaded scene object, or null if the operation failed.
```

--------------------------------

### UTF-8 Character Boundary Check

Source: https://docs.rs/ufbx/0.9.0/ufbx/prelude/struct.String.html?search=

Verifies if a byte index corresponds to the start of a UTF-8 character.

```rust
let s = "Löwe 老虎 Léopard";
assert!(s.is_char_boundary(0));
// start of `老`
assert!(s.is_char_boundary(6));
assert!(s.is_char_boundary(s.len()));

// second byte of `ö`
assert!(!s.is_char_boundary(2));

// third byte of `老`
assert!(!s.is_char_boundary(8));
```

--------------------------------

### pub fn as_display_layer<'a>(element: &'a Element) -> Option<&'a DisplayLayer>

Source: https://docs.rs/ufbx/0.9.0/ufbx/generated/fn.as_display_layer.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Attempts to interpret the provided Element as a DisplayLayer. Returns Some(&DisplayLayer) if successful, otherwise None.

```APIDOC
## Function: as_display_layer

### Description
Converts a reference to an `Element` into an `Option` containing a reference to a `DisplayLayer`. This is used to safely access display layer properties from a generic element.

### Signature
`pub fn as_display_layer<'a>(element: &'a Element) -> Option<&'a DisplayLayer>`

### Parameters
- **element** (&'a Element) - The element to attempt to cast to a display layer.

### Returns
- **Option<&'a DisplayLayer>** - Returns `Some` with the display layer reference if the element is a display layer, otherwise `None`.
```

--------------------------------

### chunks_exact

Source: https://docs.rs/ufbx/0.9.0/ufbx/prelude/struct.Blob.html

Returns an iterator over chunk_size elements of the slice at a time, starting at the beginning of the slice, with no remainder.

```APIDOC
## pub fn chunks_exact(&self, chunk_size: usize) -> ChunksExact<'_, T>

### Description
Returns an iterator over `chunk_size` elements of the slice at a time, starting at the beginning of the slice. The chunks are slices and do not overlap. If `chunk_size` does not divide the length of the slice, then the last up to `chunk_size-1` elements will be omitted and can be retrieved from the `remainder` function of the iterator.

### Panics
Panics if `chunk_size` is zero.
```

--------------------------------

### Checking Result with Predicate

Source: https://docs.rs/ufbx/0.9.0/ufbx/generated/type.Result.html

Example of using is_ok_and to check if a Result is Ok and matches a predicate.

```rust
let x: Result<u32, &str> = Ok(2);
assert_eq!(x.is_ok_and(|x| x > 1), true);

let x: Result<u32, &str> = Ok(0);
assert_eq!(x.is_ok_and(|x| x > 1), false);

let x: Result<u32, &str> = Err("hey");
assert_eq!(x.is_ok_and(|x| x > 1), false);

let x: Result<String, &str> = Ok("ownership".to_string());
assert_eq!(x.as_ref().is_ok_and(|x| x.len() > 1), true);
println!("still alive {:?}", x);
```

--------------------------------

### ufbx_open_file

Source: https://docs.rs/ufbx/0.9.0/ufbx/generated/fn.ufbx_open_file.html?search=

Opens a file using the provided stream, path, and options.

```APIDOC
## ufbx_open_file

### Description
Opens a file for reading using the specified stream and path. Returns a boolean indicating success or failure.

### Signature
`pub unsafe extern "C" fn ufbx_open_file(stream: *mut RawStream, path: *const u8, path_len: usize, opts: *const OpenFileOpts, error: *mut Error) -> bool`

### Parameters
- **stream** (*mut RawStream) - Pointer to the raw stream object.
- **path** (*const u8) - Pointer to the file path string.
- **path_len** (usize) - Length of the file path.
- **opts** (*const OpenFileOpts) - Pointer to the open file options.
- **error** (*mut Error) - Pointer to an error structure to populate in case of failure.

### Returns
- **bool** - Returns true if the file was opened successfully, false otherwise.
```

--------------------------------

### Get substring range

Source: https://docs.rs/ufbx/0.9.0/ufbx/prelude/struct.String.html?search=

Find the range of a substring within a string using pointer arithmetic.

```rust
#![feature(substr_range)]

let data = "a, b, b, a";
let mut iter = data.split(", ").map(|s| data.substr_range(s).unwrap());
```

--------------------------------

### Get subslice range

Source: https://docs.rs/ufbx/0.9.0/ufbx/prelude/struct.Blob.html

Finds the range of indices corresponding to a subslice. Requires the substr_range feature.

```rust
#![feature(substr_range)]

let nums = &[0, 5, 10, 0, 0, 5];

let mut iter = nums
    .split(|t| *t == 0)
    .map(|n| nums.subslice_range(n).unwrap());

assert_eq!(iter.next(), Some(0..0));
assert_eq!(iter.next(), Some(1..3));
assert_eq!(iter.next(), Some(4..4));
assert_eq!(iter.next(), Some(5..6));
```

--------------------------------

### pub fn as_light<'a>(element: &'a Element) -> Option<&'a Light>

Source: https://docs.rs/ufbx/0.9.0/ufbx/generated/fn.as_light.html?search=

Attempts to convert a reference to a generic Element into a reference to a Light. Returns Some(&Light) if the element is a light, otherwise returns None.

```APIDOC
## pub fn as_light<'a>(element: &'a Element) -> Option<&'a Light>

### Description
Attempts to cast a generic `Element` to a `Light` type. This is a safe downcasting operation provided by the ufbx library.

### Signature
`pub fn as_light<'a>(element: &'a Element) -> Option<&'a Light>`

### Parameters
- **element** (&'a Element) - Required - The element to attempt to cast to a light.

### Returns
- **Option<&'a Light>** - Returns `Some(&Light)` if the element is a light, otherwise `None`.
```

--------------------------------

### ufbx_load_stdio

Source: https://docs.rs/ufbx/0.9.0/ufbx/generated/fn.ufbx_load_stdio.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Loads a scene from a file pointer using the provided load options.

```APIDOC
## Function: ufbx_load_stdio

### Description
Loads a scene from a standard I/O file pointer. This function is an unsafe C-compatible interface.

### Signature
`pub unsafe extern "C" fn ufbx_load_stdio(file: *mut c_void, opts: *const RawLoadOpts, error: *mut Error) -> *mut Scene`

### Parameters
- **file** (*mut c_void) - A pointer to the file object.
- **opts** (*const RawLoadOpts) - A pointer to the load options configuration.
- **error** (*mut Error) - A pointer to an error structure to populate if loading fails.

### Returns
- ***mut Scene** - A pointer to the loaded scene, or null if an error occurred.
```

--------------------------------

### rchunks_exact

Source: https://docs.rs/ufbx/0.9.0/ufbx/prelude/struct.List.html

Returns an iterator over chunk_size elements of the slice at a time, starting at the end of the slice, with exact sizing.

```APIDOC
## pub fn rchunks_exact(&self, chunk_size: usize) -> RChunksExact<'_, T>

### Description
Returns an iterator over chunk_size elements of the slice at a time, starting at the end of the slice. If chunk_size does not divide the length of the slice, the remainder is omitted and can be retrieved via the remainder() method. Panics if chunk_size is zero.
```

--------------------------------

### trim_prefix

Source: https://docs.rs/ufbx/0.9.0/ufbx/prelude/struct.Blob.html?search=

Returns a subslice with the optional prefix removed. If the slice starts with the prefix, the subslice after the prefix is returned.

```APIDOC
## pub fn trim_prefix<P>(&self, prefix: &P) -> &[T]

### Description
Returns a subslice with the optional prefix removed. If the slice starts with `prefix`, returns the subslice after the prefix. If `prefix` is empty or the slice does not start with `prefix`, simply returns the original slice.

### Parameters
- **prefix** (&P) - Required - The prefix pattern to remove from the slice.
```

--------------------------------

### pub fn trim_start_matches<P>(&self, pat: P) -> &str

Source: https://docs.rs/ufbx/0.9.0/ufbx/prelude/struct.String.html?search=

Returns a string slice with all prefixes that match a pattern repeatedly removed.

```APIDOC
## pub fn trim_start_matches<P>(&self, pat: P) -> &str

### Description
Returns a string slice with all prefixes that match a pattern repeatedly removed. The pattern can be a &str, char, a slice of chars, or a function or closure that determines if a character matches.
```

--------------------------------

### Reverse split a slice using a predicate

Source: https://docs.rs/ufbx/0.9.0/ufbx/prelude/struct.Blob.html

Splits a slice starting from the end, excluding the matched element.

```rust
let slice = [11, 22, 33, 0, 44, 55];
let mut iter = slice.rsplit(|num| *num == 0);

assert_eq!(iter.next().unwrap(), &[44, 55]);
assert_eq!(iter.next().unwrap(), &[11, 22, 33]);
assert_eq!(iter.next(), None);
```

```rust
let v = &[0, 1, 1, 2, 3, 5, 8];
let mut it = v.rsplit(|n| *n % 2 == 0);
assert_eq!(it.next().unwrap(), &[]);
assert_eq!(it.next().unwrap(), &[3, 5]);
assert_eq!(it.next().unwrap(), &[1, 1]);
assert_eq!(it.next().unwrap(), &[]);
assert_eq!(it.next(), None);
```

--------------------------------

### as_ref

Source: https://docs.rs/ufbx/0.9.0/ufbx/prelude/struct.OptionRef.html

Converts the OptionRef to a standard Rust Option reference.

```APIDOC
## pub fn as_ref(&self) -> Option<&T>

### Description
Converts the OptionRef into an Option containing a reference to the inner value.

### Returns
- **Option<&T>** - An Option containing the reference if present.
```

--------------------------------

### Iterate over chunks from the end with rchunks

Source: https://docs.rs/ufbx/0.9.0/ufbx/prelude/struct.Blob.html

Returns an iterator over chunks of a specified size starting from the end of the slice.

```rust
let slice = ['l', 'o', 'r', 'e', 'm'];
let mut iter = slice.rchunks(2);
assert_eq!(iter.next().unwrap(), &['e', 'm']);
assert_eq!(iter.next().unwrap(), &['o', 'r']);
assert_eq!(iter.next().unwrap(), &['l']);
assert!(iter.next().is_none());
```

--------------------------------

### ufbx::load_stdio

Source: https://docs.rs/ufbx/0.9.0/ufbx/generated/fn.load_stdio.html?search=

Loads a scene from a file pointer using the provided load options.

```APIDOC
## Function: ufbx::load_stdio

### Description
Loads a scene from a file pointer using the provided load options.

### Signature
`pub fn load_stdio(file: *mut c_void, opts: LoadOpts<'_>) -> Result<SceneRoot>`

### Parameters
- **file** (*mut c_void) - A pointer to the file to be loaded.
- **opts** (LoadOpts<'_>) - Configuration options for the loading process.

### Returns
- **Result<SceneRoot>** - Returns a Result containing the loaded SceneRoot or an error if the operation fails.
```

--------------------------------

### pub unsafe fn load_stdio_raw

Source: https://docs.rs/ufbx/0.9.0/ufbx/generated/fn.load_stdio_raw.html

Loads a scene from a raw stdio file pointer with the provided options.

```APIDOC
## load_stdio_raw

### Signature
`pub unsafe fn load_stdio_raw(file: *mut c_void, opts: &RawLoadOpts) -> Result<SceneRoot>`

### Description
Loads a scene from a raw stdio file pointer. This function is unsafe as it interacts with raw pointers.

### Parameters
- **file** (*mut c_void) - A pointer to the stdio file.
- **opts** (&RawLoadOpts) - Configuration options for the loading process.

### Returns
- **Result<SceneRoot>** - Returns a Result containing the loaded SceneRoot or an error if the operation fails.
```

--------------------------------

### Split slice into chunks from the end with as_rchunks

Source: https://docs.rs/ufbx/0.9.0/ufbx/prelude/struct.Blob.html

Splits a slice into N-element arrays starting from the end of the slice.

```rust
let slice = ['l', 'o', 'r', 'e', 'm'];
let (remainder, chunks) = slice.as_rchunks();
assert_eq!(remainder, &['l']);
assert_eq!(chunks, &[['o', 'r'], ['e', 'm']]);
```

--------------------------------

### SubdivisionWeightRange struct definition

Source: https://docs.rs/ufbx/0.9.0/ufbx/generated/struct.SubdivisionWeightRange.html

The structure is defined with C-compatible representation, containing the starting index and the number of weights.

```rust
#[repr(C)]
pub struct SubdivisionWeightRange {
    pub weight_begin: u32,
    pub num_weights: u32,
}
```

--------------------------------

### pub fn source_version() -> u32

Source: https://docs.rs/ufbx/0.9.0/ufbx/generated/fn.source_version.html

Retrieves the version of the ufbx source code.

```APIDOC
## Function: source_version

### Description
Returns the version of the ufbx source code as a `u32` integer.

### Signature
`pub fn source_version() -> u32`

### Returns
- **u32** - The version identifier of the ufbx source.
```

--------------------------------

### LineSegment Struct Definition

Source: https://docs.rs/ufbx/0.9.0/ufbx/generated/struct.LineSegment.html?search=u32+-%3E+bool

The definition of the LineSegment struct, which contains the starting index and the number of indices in the segment.

```rust
#[repr(C)]
pub struct LineSegment {
    pub index_begin: u32,
    pub num_indices: u32,
}
```

--------------------------------

### pub fn as_cache_file<'a>(element: &'a Element) -> Option<&'a CacheFile>

Source: https://docs.rs/ufbx/0.9.0/ufbx/generated/fn.as_cache_file.html?search=

Attempts to interpret the given element as a cache file. Returns an Option containing a reference to the CacheFile if successful, or None if the element is not a cache file.

```APIDOC
## Function: as_cache_file

### Description
Attempts to cast a generic `Element` to a `CacheFile` reference. This is used to safely access cache file specific data from a generic element.

### Signature
`pub fn as_cache_file<'a>(element: &'a Element) -> Option<&'a CacheFile>`

### Parameters
- **element** (&'a Element) - Required - The element to be cast to a cache file.

### Returns
- **Option<&'a CacheFile>** - Returns `Some(&CacheFile)` if the element is a cache file, otherwise `None`.
```
Tokens:
Raw