Struct ira::gltf::json::root::Root

pub struct Root {

    pub accessors: Vec<Accessor>,
    pub animations: Vec<Animation>,
    pub asset: Asset,
    pub buffers: Vec<Buffer>,
    pub buffer_views: Vec<View>,
    pub scene: Option<Index<Scene>>,
    pub extensions: Option<Root>,
    pub extras: Void,
    pub extensions_used: Vec<String>,
    pub extensions_required: Vec<String>,
    pub cameras: Vec<Camera>,
    pub images: Vec<Image>,
    pub materials: Vec<Material>,
    pub meshes: Vec<Mesh>,
    pub nodes: Vec<Node>,
    pub samplers: Vec<Sampler>,
    pub scenes: Vec<Scene>,
    pub skins: Vec<Skin>,
    pub textures: Vec<Texture>,
}

The root object of a glTF 2.0 asset.

Fields

accessors: Vec<Accessor>

An array of accessors.

animations: Vec<Animation>

An array of keyframe animations.

asset: Asset

Metadata about the glTF asset.

buffers: Vec<Buffer>

An array of buffers.

buffer_views: Vec<View>

An array of buffer views.

scene: Option<Index<Scene>>

The default scene.

extensions: Option<Root>

Extension specific data.

extras: Void

Optional application specific data.

extensions_used: Vec<String>

Names of glTF extensions used somewhere in this asset.

extensions_required: Vec<String>

Names of glTF extensions required to properly load this asset.

cameras: Vec<Camera>

An array of cameras.

images: Vec<Image>

An array of images.

materials: Vec<Material>

An array of materials.

meshes: Vec<Mesh>

An array of meshes.

nodes: Vec<Node>

An array of nodes.

samplers: Vec<Sampler>

An array of samplers.

scenes: Vec<Scene>

An array of scenes.

skins: Vec<Skin>

An array of skins.

textures: Vec<Texture>

An array of textures.

Implementations

impl Root

pub fn get<T>(&self, index: Index<T>) -> Option<&T>

where Root: Get<T>,

Returns a single item from the root object.

pub fn push<T>(&mut self, value: T) -> Index<T>

where Root: AsMut<Vec<T>>,

Insert the given value into this (as via Vec::push()), then return the Index to it.

This allows you to easily obtain Index values with the correct index and type when creating a glTF asset.

If you have a mutable borrow conflict when using this method, consider using the more explicit Index::push() method, passing it only the necessary vector.

Panics

Panics if there are already u32::MAX or more elements of this type, in which case an Index cannot be created.

pub fn from_str(str_: &str) -> Result<Root, Error>

Deserialize from a JSON string slice.

pub fn from_slice(slice: &[u8]) -> Result<Root, Error>

Deserialize from a JSON byte slice.

pub fn from_reader<R>(reader: R) -> Result<Root, Error>

where R: Read,

Deserialize from a stream of JSON.

pub fn to_string(&self) -> Result<String, Error>

Serialize as a String of JSON.

pub fn to_string_pretty(&self) -> Result<String, Error>

Serialize as a pretty-printed String of JSON.

pub fn to_value(&self) -> Result<Value, Error>

Serialize as a generic JSON value.

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

Serialize as a JSON byte vector.

pub fn to_vec_pretty(&self) -> Result<Vec<u8>, Error>

Serialize as a pretty-printed JSON byte vector.

pub fn to_writer<W>(&self, writer: W) -> Result<(), Error>

where W: Write,

Serialize as a JSON byte writertor.

pub fn to_writer_pretty<W>(&self, writer: W) -> Result<(), Error>

where W: Write,

Serialize as a pretty-printed JSON byte writertor.

Trait Implementations

impl AsMut<Vec<Accessor>> for Root

fn as_mut(&mut self) -> &mut Vec<Accessor>

Converts this type into a mutable reference of the (usually inferred) input type.

impl AsMut<Vec<Animation>> for Root

fn as_mut(&mut self) -> &mut Vec<Animation>

Converts this type into a mutable reference of the (usually inferred) input type.

impl AsMut<Vec<Buffer>> for Root

fn as_mut(&mut self) -> &mut Vec<Buffer>

Converts this type into a mutable reference of the (usually inferred) input type.

impl AsMut<Vec<Camera>> for Root

fn as_mut(&mut self) -> &mut Vec<Camera>

Converts this type into a mutable reference of the (usually inferred) input type.

impl AsMut<Vec<Image>> for Root

fn as_mut(&mut self) -> &mut Vec<Image>

Converts this type into a mutable reference of the (usually inferred) input type.

impl AsMut<Vec<Material>> for Root

fn as_mut(&mut self) -> &mut Vec<Material>

Converts this type into a mutable reference of the (usually inferred) input type.

impl AsMut<Vec<Mesh>> for Root

fn as_mut(&mut self) -> &mut Vec<Mesh>

Converts this type into a mutable reference of the (usually inferred) input type.

impl AsMut<Vec<Node>> for Root

fn as_mut(&mut self) -> &mut Vec<Node>

Converts this type into a mutable reference of the (usually inferred) input type.

impl AsMut<Vec<Sampler>> for Root

fn as_mut(&mut self) -> &mut Vec<Sampler>

Converts this type into a mutable reference of the (usually inferred) input type.

impl AsMut<Vec<Scene>> for Root

fn as_mut(&mut self) -> &mut Vec<Scene>

Converts this type into a mutable reference of the (usually inferred) input type.

impl AsMut<Vec<Skin>> for Root

fn as_mut(&mut self) -> &mut Vec<Skin>

Converts this type into a mutable reference of the (usually inferred) input type.

impl AsMut<Vec<Texture>> for Root

fn as_mut(&mut self) -> &mut Vec<Texture>

Converts this type into a mutable reference of the (usually inferred) input type.

impl AsMut<Vec<View>> for Root

fn as_mut(&mut self) -> &mut Vec<View>

Converts this type into a mutable reference of the (usually inferred) input type.

impl AsRef<[Accessor]> for Root

fn as_ref(&self) -> &[Accessor]

Converts this type into a shared reference of the (usually inferred) input type.

impl AsRef<[Animation]> for Root

fn as_ref(&self) -> &[Animation]

Converts this type into a shared reference of the (usually inferred) input type.

impl AsRef<[Buffer]> for Root

fn as_ref(&self) -> &[Buffer]

Converts this type into a shared reference of the (usually inferred) input type.

impl AsRef<[Camera]> for Root

fn as_ref(&self) -> &[Camera]

Converts this type into a shared reference of the (usually inferred) input type.

impl AsRef<[Image]> for Root

fn as_ref(&self) -> &[Image]

Converts this type into a shared reference of the (usually inferred) input type.

impl AsRef<[Material]> for Root

fn as_ref(&self) -> &[Material]

Converts this type into a shared reference of the (usually inferred) input type.

impl AsRef<[Mesh]> for Root

fn as_ref(&self) -> &[Mesh]

Converts this type into a shared reference of the (usually inferred) input type.

impl AsRef<[Node]> for Root

fn as_ref(&self) -> &[Node]

Converts this type into a shared reference of the (usually inferred) input type.

impl AsRef<[Sampler]> for Root

fn as_ref(&self) -> &[Sampler]

Converts this type into a shared reference of the (usually inferred) input type.

impl AsRef<[Scene]> for Root

fn as_ref(&self) -> &[Scene]

Converts this type into a shared reference of the (usually inferred) input type.

impl AsRef<[Skin]> for Root

fn as_ref(&self) -> &[Skin]

Converts this type into a shared reference of the (usually inferred) input type.

impl AsRef<[Texture]> for Root

fn as_ref(&self) -> &[Texture]

Converts this type into a shared reference of the (usually inferred) input type.

impl AsRef<[View]> for Root

fn as_ref(&self) -> &[View]

Converts this type into a shared reference of the (usually inferred) input type.

impl Clone for Root

fn clone(&self) -> Root

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Root

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

Formats the value using the given formatter.

impl Default for Root

fn default() -> Root

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for Root

fn deserialize<__D>( __deserializer: __D, ) -> Result<Root, <__D as Deserializer<'de>>::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<'a> Get<Accessor> for Root

fn get(&self, index: Index<Accessor>) -> Option<&Accessor>

Retrieves a single value at the given index.

impl<'a> Get<Animation> for Root

fn get(&self, index: Index<Animation>) -> Option<&Animation>

Retrieves a single value at the given index.

impl<'a> Get<Buffer> for Root

fn get(&self, index: Index<Buffer>) -> Option<&Buffer>

Retrieves a single value at the given index.

impl<'a> Get<Camera> for Root

fn get(&self, index: Index<Camera>) -> Option<&Camera>

Retrieves a single value at the given index.

impl<'a> Get<Image> for Root

fn get(&self, index: Index<Image>) -> Option<&Image>

Retrieves a single value at the given index.

impl<'a> Get<Material> for Root

fn get(&self, index: Index<Material>) -> Option<&Material>

Retrieves a single value at the given index.

impl<'a> Get<Mesh> for Root

fn get(&self, index: Index<Mesh>) -> Option<&Mesh>

Retrieves a single value at the given index.

impl<'a> Get<Node> for Root

fn get(&self, index: Index<Node>) -> Option<&Node>

Retrieves a single value at the given index.

impl<'a> Get<Sampler> for Root

fn get(&self, index: Index<Sampler>) -> Option<&Sampler>

Retrieves a single value at the given index.

impl<'a> Get<Scene> for Root

fn get(&self, index: Index<Scene>) -> Option<&Scene>

Retrieves a single value at the given index.

impl<'a> Get<Skin> for Root

fn get(&self, index: Index<Skin>) -> Option<&Skin>

Retrieves a single value at the given index.

impl<'a> Get<Texture> for Root

fn get(&self, index: Index<Texture>) -> Option<&Texture>

Retrieves a single value at the given index.

impl<'a> Get<View> for Root

fn get(&self, index: Index<View>) -> Option<&View>

Retrieves a single value at the given index.

impl Serialize for Root

fn serialize<__S>( &self, __serializer: __S, ) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Validate for Root

fn validate<P, R>(&self, _root: &Root, _path: P, _report: &mut R)

where P: Fn() -> Path, R: FnMut(&dyn Fn() -> Path, Error),

Validates the invariants required for the library to function safely.