ufbx

https://docs.rs/ufbx/latest/ufbx/
Admin
ufbx is a Rust library for parsing and working with FBX (Autodesk FBX) 3D model files, providing...
Tokens:251,905
Snippets:2,392
Trust Score:9.7
Update:1 month ago
Show doc for...
Tokens:
Raw
### Trim Start Matches Examples

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

Demonstrates removing prefixes that match a pattern.

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

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

### Trim Start Matches Example

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

Demonstrates removing characters from the start of a string based on a pattern.

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

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

### Check string prefix

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

Determines if the string starts with the provided pattern.

```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']));
```

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

### Trim Start Whitespace Example

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

Demonstrates trimming leading whitespace from a string containing Hebrew characters.

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

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

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

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

Checks if the string starts with a 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.
```

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

### Split Inclusive Examples

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

Demonstrates splitting a string while keeping the delimiter as part of the resulting substrings.

```rust
let v: Vec<&str> = "Mary had a little lamb\nlittle lamb\nlittle lamb."
    .split_inclusive('\n').collect();
assert_eq!(v, ["Mary had a little lamb\n", "little lamb\n", "little lamb."]);
```

```rust
let v: Vec<&str> = "Mary had a little lamb\nlittle lamb\nlittle lamb.\n"
    .split_inclusive('\n').collect();
assert_eq!(v, ["Mary had a little lamb\n", "little lamb\n", "little lamb.\n"]);
```

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

### Reverse Split Examples

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

Demonstrates splitting a string in reverse order using various pattern types.

```rust
let v: Vec<&str> = "Mary had a little lamb".rsplit(' ').collect();
assert_eq!(v, ["lamb", "little", "a", "had", "Mary"]);

let v: Vec<&str> = "".rsplit('X').collect();
assert_eq!(v, [""]);

let v: Vec<&str> = "lionXXtigerXleopard".rsplit('X').collect();
assert_eq!(v, ["leopard", "tiger", "", "lion"]);

let v: Vec<&str> = "lion::tiger::leopard".rsplit("::").collect();
assert_eq!(v, ["leopard", "tiger", "lion"]);
```

```rust
let v: Vec<&str> = "abc1defXghi".rsplit(|c| c == '1' || c == 'X').collect();
assert_eq!(v, ["ghi", "def", "abc"]);
```

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

### Verify slice prefix with starts_with

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

Checks if a slice starts with a given prefix.

```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 Matches Examples

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

Demonstrates removing prefixes and suffixes that match a pattern, including characters, numeric checks, and closures.

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

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

```rust
assert_eq!("1foo1barXX".trim_matches(|c| c == '1' || c == 'X'), "foo1bar");
```

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

### starts_with

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

Checks if the slice starts with the given needle.

```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.
```

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

### Trim End Whitespace Examples

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

Demonstrates trimming trailing whitespace and how it interacts with text directionality.

```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());
```

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

### Split Terminator Examples

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

Demonstrates splitting a string where the trailing empty substring is skipped.

```rust
let v: Vec<&str> = "A.B.".split_terminator('.').collect();
assert_eq!(v, ["A", "B"]);

let v: Vec<&str> = "A..B..".split_terminator(".").collect();
assert_eq!(v, ["A", "", "B", ""]);

let v: Vec<&str> = "A.B:C.D".split_terminator(&['.', ':'][..]).collect();
assert_eq!(v, ["A", "B", "C", "D"]);
```

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

### Split strings into substrings

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

Examples of using the split method with various patterns including characters, strings, slices, and closures.

```rust
let v: Vec<&str> = "Mary had a little lamb".split(' ').collect();
assert_eq!(v, ["Mary", "had", "a", "little", "lamb"]);

let v: Vec<&str> = "".split('X').collect();
assert_eq!(v, [""]);

let v: Vec<&str> = "lionXXtigerXleopard".split('X').collect();
assert_eq!(v, ["lion", "", "tiger", "leopard"]);

let v: Vec<&str> = "lion::tiger::leopard".split("::").collect();
assert_eq!(v, ["lion", "tiger", "leopard"]);

let v: Vec<&str> = "AABBCC".split("DD").collect();
assert_eq!(v, ["AABBCC"]);

let v: Vec<&str> = "abc1def2ghi".split(char::is_numeric).collect();
assert_eq!(v, ["abc", "def", "ghi"]);

let v: Vec<&str> = "lionXtigerXleopard".split(char::is_uppercase).collect();
assert_eq!(v, ["lion", "tiger", "leopard"]);
```

```rust
let v: Vec<&str> = "2020-11-03 23:59".split(&['-', ' ', ':', '@'][..]).collect();
assert_eq!(v, ["2020", "11", "03", "23", "59"]);
```

```rust
let v: Vec<&str> = "abc1defXghi".split(|c| c == '1' || c == 'X').collect();
assert_eq!(v, ["abc", "def", "ghi"]);
```

```rust
let x = "||||a||b|c".to_string();
let d: Vec<_> = x.split('|').collect();

assert_eq!(d, &["", "", "", "", "a", "", "b", "c"]);
```

```rust
let x = "(///)".to_string();
let d: Vec<_> = x.split('/').collect();

assert_eq!(d, &["(", "", "", ")"]);
```

```rust
let d: Vec<_> = "010".split("0").collect();
assert_eq!(d, &["", "1", ""]);
```

```rust
let f: Vec<_> = "rust".split("").collect();
assert_eq!(f, &["", "r", "u", "s", "t", ""]);
```

```rust
let x = "    a  b c".to_string();
let d: Vec<_> = x.split(' ').collect();

assert_eq!(d, &["", "", "", "", "a", "", "b", "c"]);
```

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

### Strip Prefix Examples

Source: https://docs.rs/ufbx/latest/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"));
```

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

### Deprecated Trim Right Examples

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

Demonstrates the deprecated trim_right method and its behavior with different languages.

```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());
```

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

### Deprecated Trim Left Examples

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

Demonstrates the deprecated trim_left method and its behavior with different languages.

```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());
```

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

### Reverse Split Terminator Examples

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

Demonstrates reverse splitting a string while skipping the trailing empty substring.

```rust
let v: Vec<&str> = "A.B.".rsplit_terminator('.').collect();
assert_eq!(v, ["B", "A"]);

let v: Vec<&str> = "A..B..".rsplit_terminator(".").collect();
assert_eq!(v, ["", "B", "", "A"]);
```

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

### Strip Suffix Examples

Source: https://docs.rs/ufbx/latest/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"));
```

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

### Trim Suffix Examples

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

Nightly-only API that removes a suffix if present, returning the original string if not.

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

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

// Suffix absent - returns original string
assert_eq!("bar:foo".trim_suffix("bar"), "bar:foo");
```

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

### Trim Prefix Examples

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

Nightly-only API that removes a prefix if present, returning the original string if not. Useful for method chaining.

```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(file: *mut c_void, opts: LoadOpts<'_>) -> Result<SceneRoot>

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

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

```APIDOC
## Function: load_stdio

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

### 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.
```

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

### Asserting split results

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

Example of an assertion for a split operation.

```rust
assert_eq!(d, &["a", "b", "c"]);
```

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

### load_stdio_prefix_raw

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

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

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

### Description
Loads a scene from a standard I/O source using a provided prefix and raw loading options. This function is marked as unsafe.

### Parameters
- **file** (*mut c_void) - Required - A pointer to the standard I/O file source.
- **prefix** (&[u8]) - Required - A byte slice representing the prefix to use during loading.
- **opts** (&RawLoadOpts) - Required - The raw loading options to apply.

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

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

### strip_prefix

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

Returns a subslice with the prefix removed if the slice starts with the prefix.

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

### Description
If the slice starts with `prefix`, returns the subslice after the prefix, wrapped in `Some`. If `prefix` is empty, returns the original slice. If the slice does not start with `prefix`, returns `None`.
```

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

### pub fn load_stdio_prefix

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

Loads a scene from a standard I/O file pointer with a given 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) - The file pointer to load from.
- **prefix** (&[u8]) - The prefix to use during the load process.
- **opts** (LoadOpts<'_>) - Configuration options for the loading process.

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

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

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

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

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` reference into a `Video` reference. This is used to safely access video-specific properties from a generic element.

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

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

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

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

### Strip Circumfix Examples

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

Removes both a prefix and a suffix exactly once if both are present and non-overlapping.

```rust
assert_eq!("bar:hello:foo".strip_circumfix("bar:", ":foo"), Some("hello"));
assert_eq!("bar:foo".strip_circumfix("foo", "foo"), None);
assert_eq!("foo:bar;".strip_circumfix("foo:", ';'), Some("bar"));
assert_eq!("foo:bar:baz".strip_circumfix("foo:bar:", ":bar:baz"), None);
```

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

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

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

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

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

### Description
Creates a new String by repeating a string n times.

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

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

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

### pub unsafe fn load_stdio_prefix_raw

Source: https://docs.rs/ufbx/latest/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 loaded SceneRoot or an error.
```

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

### ufbx_load_stdio_prefix

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

Loads a scene from a file pointer with a provided prefix buffer.

```APIDOC
## ufbx_load_stdio_prefix

### 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`

### Description
Loads a scene from a standard I/O file pointer, optionally prepending data from a prefix buffer. This is useful for scenarios where the beginning of the file has already been read to identify the file type.

### Parameters
- **file** (*mut c_void) - The file pointer to read from.
- **prefix** (*const c_void) - Pointer to the buffer containing the prefix data.
- **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 the operation fails.

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

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

### get<I>

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

Returns a reference to an element or subslice based on the provided index or range.

```APIDOC
## pub fn get<I>(&self, index: I) -> Option<&<I as SliceIndex<[T]>>::Output>

### 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.
```

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

### Retrieve match indices with match_indices

Source: https://docs.rs/ufbx/latest/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`
```

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

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

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

Loads a scene from the specified file path with the provided loading options.

```APIDOC
## load_file

### Description
Loads a scene from a file path into a SceneRoot object.

### 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 Result containing the loaded SceneRoot on success, or an error if the file could not be loaded.
```

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

### Check character boundaries

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

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));
```

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

### rsplit

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

Returns an iterator over subslices separated by elements that match a predicate, starting from the end.

```APIDOC
## pub fn rsplit<F>(&self, pred: F) -> RSplit<'_, T, F>

### Description
Returns an iterator over subslices separated by elements that match `pred`, starting at the end of the slice and working backwards. The matched element is not contained in the subslices.
```

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

### ufbx_load_stdio_prefix

Source: https://docs.rs/ufbx/latest/ufbx/generated/fn.ufbx_load_stdio_prefix.html?search=

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

```APIDOC
## Function: ufbx_load_stdio_prefix

### Description
Loads a scene from a standard I/O file handle, applying a prefix of a specified size. This function is part of the ufbx library's C API.

### 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) - Pointer to the file handle.
- **prefix** (*const c_void) - Pointer to the prefix data.
- **prefix_size** (usize) - Size of the prefix 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.
```

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

### rchunks

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

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. If `chunk_size` does not divide the length of the slice, then the last chunk will not have length `chunk_size`.

### Parameters
- **chunk_size** (usize) - Required - The size of each chunk. Panics if zero.
```

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

### ufbx_load_stdio_prefix

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

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

```APIDOC
## Function: ufbx_load_stdio_prefix

### Description
Loads a scene from a file using a provided prefix and configuration options. This is an unsafe C-compatible function.

### 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) - Pointer to the file object.
- **prefix** (*const c_void) - Pointer to the prefix data.
- **prefix_size** (usize) - The size of the prefix in bytes.
- **opts** (*const RawLoadOpts) - Pointer to the raw load options.
- **error** (*mut Error) - Pointer to an error structure to populate if loading fails.

### Returns
- ***mut Scene** - A pointer to the loaded Scene object.
```

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

### ufbx_load_stdio_prefix

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

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

```APIDOC
## Function: ufbx_load_stdio_prefix

### Description
Loads a scene from a file pointer using a specified prefix and load options. This is an unsafe C-compatible function.

### 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) - Pointer to the file source.
- **prefix** (*const c_void) - Pointer to the prefix data.
- **prefix_size** (usize) - Size of the prefix in bytes.
- **opts** (*const RawLoadOpts) - Pointer to the load options.
- **error** (*mut Error) - Pointer to an error structure to populate if loading fails.

### Returns
- ***mut Scene** - A pointer to the loaded Scene object.
```

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

### Get subslice safely

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

Retrieves a subslice of the string, returning None if the index is invalid.

```rust
let v = String::from("🗻∈🌏");

assert_eq!(Some("🗻"), v.get(0..4));

// indices not on UTF-8 sequence boundaries
assert!(v.get(1..).is_none());
assert!(v.get(..8).is_none());

// out of bounds
assert!(v.get(..42).is_none());
```

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

### Trim ASCII whitespace from start

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

Removes leading ASCII whitespace characters, excluding U+000B.

```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(), "");
```

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

### ufbx_load_stdio

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

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

```APIDOC
## ufbx_load_stdio

### Description
Loads a scene from a standard I/O file pointer using the provided load options. This function is unsafe and requires careful management of the file pointer and memory.

### 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 standard I/O file.
- **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 object, or null if an error occurred.
```

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

### Accessing slice chunks

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

Methods for retrieving fixed-size array references from the start or end of a slice.

```rust
let u = [10, 40, 30];
assert_eq!(Some(&[10, 40]), u.first_chunk::<2>());

let v: &[i32] = &[10];
assert_eq!(None, v.first_chunk::<2>());

let w: &[i32] = &[];
assert_eq!(Some(&[]), w.first_chunk::<0>());
```

```rust
let x = &[0, 1, 2];

if let Some((first, elements)) = x.split_first_chunk::<2>() {
    assert_eq!(first, &[0, 1]);
    assert_eq!(elements, &[2]);
}

assert_eq!(None, x.split_first_chunk::<4>());
```

```rust
let x = &[0, 1, 2];

if let Some((elements, last)) = x.split_last_chunk::<2>() {
    assert_eq!(elements, &[0]);
    assert_eq!(last, &[1, 2]);
}

assert_eq!(None, x.split_last_chunk::<4>());
```

```rust
let u = [10, 40, 30];
assert_eq!(Some(&[40, 30]), u.last_chunk::<2>());

let v: &[i32] = &[10];
assert_eq!(None, v.last_chunk::<2>());

let w: &[i32] = &[];
assert_eq!(Some(&[]), w.last_chunk::<0>());
```

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

### ufbx_load_stdio

Source: https://docs.rs/ufbx/latest/ufbx/generated/fn.ufbx_load_stdio.html?search=

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

```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 ufbx library's C-compatible interface.

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

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

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

### Create contiguous windows

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

Shows how to create overlapping windows of a specific size from a slice, noting that it panics if the size is zero.

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

```rust
let slice = ['f', 'o', 'o'];
let mut iter = slice.windows(4);
assert!(iter.next().is_none());
```

```rust
use std::cell::Cell;

let mut array = ['R', 'u', 's', 't', ' ', '2', '0', '1', '5'];
let slice = &mut array[..];
let slice_of_cells: &[Cell<char>] = Cell::from_mut(slice).as_slice_of_cells();
for w in slice_of_cells.windows(3) {
    Cell::swap(&w[0], &w[2]);
}
assert_eq!(array, ['s', 't', ' ', '2', '0', '1', '5', 'u', 'R']);
```

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

### ufbx_load_stdio_prefix

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

Loads a scene from a file pointer with an optional prefix, using the provided load options and error handling structure.

```APIDOC
## Function: ufbx_load_stdio_prefix

### Description
Loads a scene from a standard I/O file pointer, applying a prefix of a specified size. This function is an unsafe C-compatible interface.

### 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) - Pointer to the input file source.
- **prefix** (*const c_void) - Pointer to the prefix data.
- **prefix_size** (usize) - The size of the prefix in bytes.
- **opts** (*const RawLoadOpts) - Pointer to the load options configuration.
- **error** (*mut Error) - Pointer to an error structure to populate if the operation fails.

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

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

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

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

Loads a scene from a memory buffer containing FBX data.

```APIDOC
## load_memory

### Description
Loads an FBX scene from a provided byte slice in memory. Returns a Result containing the SceneRoot on success.

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

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

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

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

### ufbx_open_file_ctx

Source: https://docs.rs/ufbx/latest/ufbx/generated/fn.ufbx_open_file_ctx.html

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

```APIDOC
## ufbx_open_file_ctx

### Description
Opens a file with the specified context and options. This function is an unsafe C-compatible function.

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

### Parameters
- **stream** (*mut RawStream) - The stream to associate with the file.
- **ctx** (OpenFileContext) - The context for opening the file.
- **path** (*const u8) - Pointer to the file path string.
- **path_len** (usize) - Length of the path string.
- **opts** (*const RawOpenFileOpts) - Pointer to the options for opening the file.
- **error** (*mut Error) - Pointer to an error structure to populate if an error occurs.

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

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

### Get raw pointer to string

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

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

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

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

### Calculate string length

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

Demonstrates how to get the length of a string in bytes using the len() method.

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

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

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

### pub unsafe fn load_stream_prefix_raw

Source: https://docs.rs/ufbx/latest/ufbx/generated/fn.load_stream_prefix_raw.html?search=

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

```APIDOC
## pub unsafe fn load_stream_prefix_raw

### Description
Loads a scene from a raw stream by providing a prefix and load options.

### 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 prefix to use during loading.
- **opts** (&RawLoadOpts) - The options for the raw load operation.

### Returns
- **Result<SceneRoot>** - Returns a Result containing the SceneRoot on success.
```

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

### Reverse split string into at most n parts

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

Splits a string into a maximum of n substrings starting from the end.

```rust
let v: Vec<&str> = "Mary had a little lamb".rsplitn(3, ' ').collect();
assert_eq!(v, ["lamb", "little", "Mary had a"]);

let v: Vec<&str> = "lionXXtigerXleopard".rsplitn(3, 'X').collect();
assert_eq!(v, ["leopard", "tiger", "lionX"]);

let v: Vec<&str> = "lion::tiger::leopard".rsplitn(2, "::").collect();
assert_eq!(v, ["leopard", "lion::tiger"]);
```

```rust
let v: Vec<&str> = "abc1defXghi".rsplitn(2, |c| c == '1' || c == 'X').collect();
assert_eq!(v, ["ghi", "abc1def"]);
```

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

### Split slice from the end with rsplitn

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

Splits a slice into at most n items starting from the end based on a predicate.

```rust
let v = [10, 40, 30, 20, 60, 50];

for group in v.rsplitn(2, |num| *num % 3 == 0) {
    println!("{group:?}");
}
```

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

### rchunks_exact

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

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 iterator's remainder function.

### Parameters
- **chunk_size** (usize) - Required - The size of each chunk. Panics if zero.
```

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

### ufbx_default_open_file

Source: https://docs.rs/ufbx/latest/ufbx/generated/fn.ufbx_default_open_file.html

A C-compatible function signature for opening files in the ufbx library.

```APIDOC
## ufbx_default_open_file

### Description
Opens a file using the default ufbx implementation. This function is intended for use with file streams.

### Signature
`pub unsafe extern "C" fn ufbx_default_open_file(user: *mut c_void, stream: *mut RawStream, path: *const u8, path_len: usize, info: *const OpenFileInfo) -> bool`

### Parameters
- **user** (*mut c_void) - User-provided context pointer.
- **stream** (*mut RawStream) - Pointer to the raw stream structure.
- **path** (*const u8) - Pointer to the file path string.
- **path_len** (usize) - Length of the file path.
- **info** (*const OpenFileInfo) - Pointer to additional open file information.

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

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

### ufbx_catch_topo_prev_vertex_edge

Source: https://docs.rs/ufbx/latest/ufbx/generated/fn.ufbx_catch_topo_prev_vertex_edge.html?search=

Retrieves the previous vertex edge index given a topology edge array and a starting index.

```APIDOC
## Function: ufbx_catch_topo_prev_vertex_edge

### Signature
`pub unsafe extern "C" fn ufbx_catch_topo_prev_vertex_edge(panic: *mut Panic, topo: *const TopoEdge, num_topo: usize, index: u32) -> u32`

### Description
This function retrieves the index of the previous vertex edge within the provided topology edge structure. It is an unsafe C-compatible function.

### Parameters
- **panic** (*mut Panic) - Pointer to a panic structure for error handling.
- **topo** (*const TopoEdge) - Pointer to the array of TopoEdge structures.
- **num_topo** (usize) - The number of elements in the topo array.
- **index** (u32) - The current edge index.

### Returns
- **u32** - The index of the previous vertex edge.
```

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

### as_ref

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

Converts the OptionRef to a standard Rust Option.

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

### Description
Converts the OptionRef into a standard Rust Option containing a reference to the inner value.
```

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

### Iterate over slice chunks from the end

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

Uses rchunks to iterate over a slice in chunks of a specified size starting from the end.

```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());
```

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

### Trim Prefix and Suffix

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

Demonstrates chaining trim_prefix and trim_suffix methods.

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

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

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

Source: https://docs.rs/ufbx/latest/ufbx/generated/fn.as_display_layer.html

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

```APIDOC
## Function: as_display_layer

### Description
Attempts to cast a generic `Element` to a `DisplayLayer`. This is used to access display layer-specific properties from a generic element reference.

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

### Parameters
- **element** (&Element) - Required - A reference to the element to be cast.

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

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

### Get subslice unchecked

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

Retrieves a subslice without bounds or UTF-8 boundary checks. Requires unsafe block.

```rust
let v = "🗻∈🌏";
unsafe {
    assert_eq!("🗻", v.get_unchecked(0..4));
    assert_eq!("∈", v.get_unchecked(4..7));
    assert_eq!("🌏", v.get_unchecked(7..11));
}
```

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

### ufbx_open_file

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

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

```APIDOC
## Function: ufbx_open_file

### Description
Opens a file stream for processing. This is an unsafe C-compatible function.

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

### Parameters
- **stream** (*mut RawStream) - Pointer to the raw stream.
- **path** (*const u8) - Pointer to the file path string.
- **path_len** (usize) - Length of the path string.
- **opts** (*const RawOpenFileOpts) - Pointer to the open file options.
- **error** (*mut Error) - Pointer to an error structure to populate if an error occurs.

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

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

### Split a slice in reverse by a predicate

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

Returns an iterator over subslices separated by elements that match a predicate, starting from the end of the slice.

```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);
```

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

### open_file_ctx_raw

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

Opens a file using a raw stream and a provided context.

```APIDOC
## Function: open_file_ctx_raw

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

### Description
This function opens a file based on the provided raw stream, context, file path, and options. It is an unsafe function used for low-level file operations.

### Parameters
- **stream** (&mut RawStream) - The raw stream to be used for the file operation.
- **ctx** (OpenFileContext) - The context in which the file is opened.
- **path** (&str) - The path to the file to be opened.
- **opts** (&RawOpenFileOpts) - Configuration options for opening the file.

### Returns
- **Result<bool>** - Returns Ok(true) if the file was opened successfully, or an error if the operation failed.
```

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

### pub unsafe fn load_stream_prefix_raw

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

Loads a scene from a raw stream with a prefix.

```APIDOC
## Function: load_stream_prefix_raw

### Description
Loads a scene from a raw stream given a specific prefix and load options.

### 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 prefix to use for the stream.
- **opts** (&RawLoadOpts) - The options for the raw load operation.

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

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

### get<I>(&self, index: I) -> Option<&<I as SliceIndex<[T]>>::Output>

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

Returns a reference to an element or subslice based on the provided index or range.

```APIDOC
## get<I>(&self, index: 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.
```

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

### Get skin vertex matrix method

Source: https://docs.rs/ufbx/latest/ufbx/generated/struct.SkinDeformer.html?search=

Retrieves the transformation matrix for a specific vertex, using a fallback matrix if necessary.

```rust
pub fn get_skin_vertex_matrix(&self, vertex: usize, fallback: &Matrix) -> Matrix
```
Tokens:
Raw