Struct RenderScene

pub struct RenderScene {
    pub instances: Vec<Instance>,
    pub meshes: Vec<MeshBuffer>,
    pub lines: Vec<LineBuffer>,
    pub points: Vec<PointBuffer>,
    pub materials: Vec<Material>,
    pub bounds: Option<Bounds>,
    pub origin: Vec3,
    pub warnings: Vec<SceneWarning>,
}

A flat render scene; see the module docs.

Fields

instances: Vec<Instance>

Drawn geometry, parents before children.

meshes: Vec<MeshBuffer>

lines: Vec<LineBuffer>

points: Vec<PointBuffer>

materials: Vec<Material>

bounds: Option<Bounds>

World bounds of every instance, None for an empty scene.

origin: Vec3

World coordinates of the render origin; instance matrices map to world coordinates minus this point.

warnings: Vec<SceneWarning>

Implementations

impl RenderScene

pub fn from_composition( composition: &Composition, options: &SceneOptions, ) -> Self

Builds the scene of a composition under its artificial root ([Composition::root]).

use openbim_ifcx::{compose, flatten, IfcxNode};
use openbim_ifcx_geometry::scene::{GeometryRef, RenderScene, SceneOptions};

let nodes: Vec<IfcxNode> = serde_json::from_str(r#"[
    {"path": "panel", "attributes": {"usd::usdgeom::mesh": {
        "points": [[0, 0, 0], [1, 0, 0], [0, 1, 0]], "faceVertexIndices": [0, 1, 2]}}},
    {"path": "a", "inherits": {"type": "panel"}},
    {"path": "b", "inherits": {"type": "panel"}, "attributes": {"usd::xformop":
        {"transform": [[1, 0, 0, 0], [0, 1, 0, 0], [0, 0, 1, 0], [5, 0, 0, 1]]}}}
]"#)?;
let composition = compose(&flatten(&nodes))?;
let scene = RenderScene::from_composition(&composition, &SceneOptions::default());
assert_eq!(scene.meshes.len(), 1, "stored once");
let paths: Vec<_> = scene.instances.iter().map(|i| i.path.as_str()).collect();
assert_eq!(paths, ["a", "b"]);
assert_eq!(scene.instances[1].geometry, GeometryRef::Mesh(0));
let bounds = scene.bounds.unwrap();
assert_eq!((bounds.min, bounds.max), ([0.0; 3], [6.0, 1.0, 0.0]));
assert_eq!(scene.origin, [3.0, 0.5, 0.0]);

pub fn from_root(root: &ComposedNode, options: &SceneOptions) -> Self

Builds the scene of root and everything below it. Instance paths are relative to root, which itself has path ""; its own attributes, including a transform, apply like those of any node.

pub fn triangle_count(&self) -> usize

Number of triangles drawn, counting every instance.

pub fn segment_count(&self) -> usize

Number of line segments drawn, counting every instance.

pub fn point_count(&self) -> usize

Number of points drawn, counting every instance.

pub fn instances_at(&self, path: &str) -> &[Instance]

The instances drawn for the node at path, at most one per geometry kind. They are adjacent because instances are listed in walk order. Linear in the number of instances.

Trait Implementations

impl Clone for RenderScene

fn clone(&self) -> RenderScene

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for RenderScene

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

Formats the value using the given formatter.

impl Default for RenderScene

fn default() -> RenderScene

Returns the “default value” for a type.

impl PartialEq for RenderScene

fn eq(&self, other: &RenderScene) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl StructuralPartialEq for RenderScene