Struct Nodes 

pub struct Nodes<'a> { /* private fields */ }

Nodes of a Model https://stereokit.net/Pages/StereoKit/ModelNodeCollection.html https://stereokit.net/Pages/StereoKit/ModelVisualCollection.html

see also Model::get_nodes

Examples

use stereokit_rust::{maths::{Vec3, Matrix} ,model::Model, util::Color128};

let model = Model::from_file("center.glb", None)
                          .expect("Could not load model").copy();
let transform = Matrix::t_r_s(Vec3::NEG_Y * 0.40, [0.0, 190.0, 0.0], Vec3::ONE * 0.25);

let mut nodes = model.get_nodes();

// Duplicate Suzanne ModelNode 5 times at different positions.
let original_node = nodes.find("Suzanne").expect("Could not find Suzanne");
let mesh = original_node.get_mesh().expect("Could not get Suzanne's mesh");
let material_original = original_node.get_material().expect("Could not get Suzanne's material");

for i in -1..4 {
    let coord = i as f32 * 1.25;
    let color_idx = ((i+5) * 13694856) as u32;
    let position = Matrix::t([coord, coord, coord]);
    let name = format!("Suzanne_{}", i);
    let mut material = material_original.copy();
    material.color_tint(Color128::hex(color_idx));

    nodes.add(name, position, Some(&mesh), Some(&material), true);
}

filename_scr = "screenshots/model_nodes.jpeg";
test_screenshot!( // !!!! Get a proper main loop !!!!
    model.draw(token, transform, None, None);
);

Implementations

impl<'a> Nodes<'a>

pub fn from(model: &'a impl AsRef<Model>) -> Nodes<'a>

pub fn add<S: AsRef<str>>( &mut self, name: S, local_transform: impl Into<Matrix>, mesh: Option<&Mesh>, material: Option<&Material>, solid: bool, ) -> &mut Self

This adds a root node to the Model’s node hierarchy! If There is already an initial root node, this node will still be a root node, but will be a Sibling of the Model’s RootNode. If this is the first root node added, you’ll be able to access it via Nodes::get_root_node. https://stereokit.net/Pages/StereoKit/Model/AddNode.html

see also ModelNode::add_child model_node_add

Examples

use stereokit_rust::{maths::{Vec3, Matrix}, model::Model, mesh::Mesh, material::Material};

let sphere =       Mesh::generate_sphere(0.6, None);
let cylinder =     Mesh::generate_cylinder(0.25, 0.6, Vec3::Z, None);

let transform1 = Matrix::t([-0.7,-0.5, 0.0]);
let transform2 = Matrix::t([ 0.0, 0.0, 0.0]);

let material = Material::pbr();

let model = Model::new();
let mut nodes = model.get_nodes();
nodes.add("sphere",   transform1 , Some(&sphere),       Some(&material), true)
     .add("cylinder", transform2 , Some(&cylinder),     Some(&material), true)
     .add("A matrix", Matrix::IDENTITY, None, None, false);

assert_eq!(nodes.get_count(), 3);
assert_eq!(nodes.get_root_node().unwrap().get_name(), Some("sphere"));

pub fn all(&self) -> NodeIter<'_>

Get an iterator of all the nodes https://stereokit.net/Pages/StereoKit/ModelNodeCollection.html

see also NodeIter::all_from

Examples

use stereokit_rust::{maths::{Vec3, Matrix}, model::Model, mesh::Mesh, material::Material};

let sphere =       Mesh::generate_sphere(0.6, None);
let cylinder =     Mesh::generate_cylinder(0.25, 0.6, Vec3::Z, None);

let transform1 = Matrix::t([-0.7,-0.5, 0.0]);
let transform2 = Matrix::t([ 0.0, 0.0, 0.0]);

let material = Material::pbr();

let model = Model::new();
let mut nodes = model.get_nodes();
nodes.add("sphere",   transform1 , Some(&sphere),       Some(&material), true)
     .add("cylinder", transform2 , Some(&cylinder),     Some(&material), true)
     .add("A matrix", Matrix::IDENTITY, None, None, false);

assert_eq!(nodes.get_count(), 3);
assert_eq!(nodes.all().count(), 3);

for (iter, node) in nodes.all().enumerate() {
    match iter {
        0 => assert_eq!(node.get_name(), Some("sphere")),
        1 => assert_eq!(node.get_name(), Some("cylinder")),
        _ => assert_eq!(node.get_name(), Some("A matrix")),
    }
}

pub fn visuals(&self) -> NodeIter<'_>

Get an iterator of all the visual nodes https://stereokit.net/Pages/StereoKit/ModelVisualCollection.html

see also NodeIter::visuals_from

Examples

use stereokit_rust::{maths::{Vec3, Matrix}, model::Model, mesh::Mesh, material::Material};

let sphere =       Mesh::generate_sphere(0.6, None);
let cylinder =     Mesh::generate_cylinder(0.25, 0.6, Vec3::Z, None);

let transform1 = Matrix::t([-0.7,-0.5, 0.0]);
let transform2 = Matrix::t([ 0.0, 0.0, 0.0]);

let material = Material::pbr();

let model = Model::new();
let mut nodes = model.get_nodes();
nodes.add("sphere",   transform1 , Some(&sphere),       Some(&material), true)
     .add("cylinder", transform2 , Some(&cylinder),     Some(&material), true)
     .add("A matrix", Matrix::IDENTITY, None, None, false);

assert_eq!(nodes.get_count(), 3);
assert_eq!(nodes.get_visual_count(), 2);
assert_eq!(nodes.visuals().count(), 2);

for (iter, node) in nodes.visuals().enumerate() {
    match iter {
        0 => assert_eq!(node.get_name(), Some("sphere")),
        _ => assert_eq!(node.get_name(), Some("cylinder")),
    }
}

pub fn find<S: AsRef<str>>(&self, name: S) -> Option<ModelNode<'_>>

get node by name https://stereokit.net/Pages/StereoKit/Model/FindNode.html

• name - Exact name to match against. ASCII only for now.

see also model_node_find

Examples

use stereokit_rust::{maths::{Vec3, Matrix}, model::Model, mesh::Mesh, material::Material};

let sphere =      Mesh::generate_sphere(0.6, None);
let cylinder =    Mesh::generate_cylinder(0.25, 0.6, Vec3::Z, None);

let transform1 = Matrix::t([-0.7,-0.5, 0.0]);
let transform2 = Matrix::t([ 0.0, 0.0, 0.0]);

let material = Material::pbr();

let model = Model::new();
let mut nodes = model.get_nodes();
nodes.add("sphere",   transform1 , Some(&sphere),      Some(&material), true)
     .add("cylinder", transform2 , Some(&cylinder),    Some(&material), true)
     .add("A matrix", Matrix::IDENTITY, None, None, false);

let found_sphere = nodes.find("sphere");
assert!(found_sphere.is_some());
assert_eq!(found_sphere.unwrap().get_name(), Some("sphere"));

let found_non_existent = nodes.find("non_existent");
assert!(found_non_existent.is_none());

pub fn get_count(&self) -> i32

Get the number of node. https://stereokit.net/Pages/StereoKit/ModelNodeCollection.html

see also NodeIter model_node_count

Examples

use stereokit_rust::{maths::Matrix, model::Model};

let model = Model::new();

let mut nodes = model.get_nodes();
assert_eq!(nodes.get_count(), 0);

nodes.add("root", Matrix::IDENTITY, None, None, false);
assert_eq!(nodes.get_count(), 1);

pub fn get_visual_count(&self) -> i32

Get the number of visual node https://stereokit.net/Pages/StereoKit/ModelVisualCollection.html

see also NodeIter model_node_visual_count

Examples

use stereokit_rust::{maths::Matrix, model::Model};

let model = Model::new();

let mut nodes = model.get_nodes();
assert_eq!(nodes.get_count(), 0);
assert_eq!(nodes.get_visual_count(), 0);

nodes.add("root", Matrix::IDENTITY, None, None, false);
assert_eq!(nodes.get_count(), 1);
assert_eq!(nodes.get_visual_count(), 0);

pub fn get_index(&self, index: i32) -> Option<ModelNode<'_>>

Get the node at index https://stereokit.net/Pages/StereoKit/ModelNodeCollection.html

see also NodeIter model_node_index

Examples

use stereokit_rust::{maths::Matrix, model::Model};

let model = Model::new();

let mut nodes = model.get_nodes();
let node = nodes.get_index(0);
assert!(node.is_none());

nodes.add("root", Matrix::IDENTITY, None, None, false);
let node = nodes.get_index(0).expect("Node should exist");
assert_eq!(node.get_name(), Some("root"));

pub fn get_visual_index(&self, index: i32) -> Option<ModelNode<'_>>

Get the visual node at index https://stereokit.net/Pages/StereoKit/ModelVisualCollection.html

see also NodeIter model_node_visual_index

Examples

use stereokit_rust::{maths::Matrix, model::Model};

let model = Model::new();

let mut nodes = model.get_nodes();
let node = nodes.get_visual_index(0);
assert!(node.is_none());

nodes.add("root", Matrix::IDENTITY, None, None, false);
let node = nodes.get_visual_index(0);
assert!(node.is_none());

pub fn get_root_node(&self) -> Option<ModelNode<'_>>

Get the root node https://stereokit.net/Pages/StereoKit/Model/RootNode.html

see also model_node_get_root

Examples

use stereokit_rust::{maths::Matrix, model::Model};

let model = Model::new();

let mut nodes = model.get_nodes();
let node = nodes.get_root_node();
assert!(node.is_none());

nodes.add("root", Matrix::IDENTITY, None, None, false);
let node = nodes.get_root_node().expect("Node should exist");
assert_eq!(node.get_name(), Some("root"));

Trait Implementations

impl<'a> Clone for Nodes<'a>

fn clone(&self) -> Nodes<'a>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<'a> Debug for Nodes<'a>

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

Formats the value using the given formatter.

impl<'a> Copy for Nodes<'a>