Struct Mesh3D 

pub struct Mesh3D {
    pub vertex_positions: Option<SerializedComponentBatch>,
    pub triangle_indices: Option<SerializedComponentBatch>,
    pub vertex_normals: Option<SerializedComponentBatch>,
    pub vertex_colors: Option<SerializedComponentBatch>,
    pub vertex_texcoords: Option<SerializedComponentBatch>,
    pub albedo_factor: Option<SerializedComponentBatch>,
    pub albedo_texture_buffer: Option<SerializedComponentBatch>,
    pub albedo_texture_format: Option<SerializedComponentBatch>,
    pub class_ids: Option<SerializedComponentBatch>,
}

Archetype: A 3D triangle mesh as specified by its per-mesh and per-vertex properties.

See also archetypes::Asset3D.

If there are multiple archetypes::InstancePoses3D instances logged to the same entity as a mesh, an instance of the mesh will be drawn for each transform.

The viewer draws meshes always two-sided. However, for transparency ordering front faces are assumed to those with counter clockwise triangle winding order (this is the same as in the GLTF specification).

Examples

Simple indexed 3D mesh

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let rec = rerun::RecordingStreamBuilder::new("rerun_example_mesh3d_indexed").spawn()?;

    rec.log(
        "triangle",
        &rerun::Mesh3D::new([[0.0, 1.0, 0.0], [1.0, 0.0, 0.0], [0.0, 0.0, 0.0]])
            .with_vertex_normals([[0.0, 0.0, 1.0]])
            .with_vertex_colors([0x0000FFFF, 0x00FF00FF, 0xFF0000FF])
            .with_triangle_indices([[2, 1, 0]]),
    )?;

    Ok(())
}

3D mesh with instancing

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let rec = rerun::RecordingStreamBuilder::new("rerun_example_mesh3d_instancing").spawn()?;

    rec.set_time_sequence("frame", 0);
    rec.log(
        "shape",
        &rerun::Mesh3D::new([
            [1.0, 1.0, 1.0],
            [-1.0, -1.0, 1.0],
            [-1.0, 1.0, -1.0],
            [1.0, -1.0, -1.0],
        ])
        .with_triangle_indices([[0, 2, 1], [0, 3, 1], [0, 3, 2], [1, 3, 2]])
        .with_vertex_colors([0xFF0000FF, 0x00FF00FF, 0x00000FFFF, 0xFFFF00FF]),
    )?;
    // This box will not be affected by its parent's instance poses!
    rec.log(
        "shape/box",
        &rerun::Boxes3D::from_half_sizes([[5.0, 5.0, 5.0]]),
    )?;

    for i in 0..100 {
        rec.set_time_sequence("frame", i);
        rec.log(
            "shape",
            &rerun::InstancePoses3D::new()
                .with_translations([
                    [2.0, 0.0, 0.0],
                    [0.0, 2.0, 0.0],
                    [0.0, -2.0, 0.0],
                    [-2.0, 0.0, 0.0],
                ])
                .with_rotation_axis_angles([rerun::RotationAxisAngle::new(
                    [0.0, 0.0, 1.0],
                    rerun::Angle::from_degrees(i as f32 * 2.0),
                )]),
        )?;
    }

    Ok(())
}

Fields

vertex_positions: Option<SerializedComponentBatch>

The positions of each vertex.

If no triangle_indices are specified, then each triplet of positions is interpreted as a triangle.

triangle_indices: Option<SerializedComponentBatch>

Optional indices for the triangles that make up the mesh.

vertex_normals: Option<SerializedComponentBatch>

An optional normal for each vertex.

vertex_colors: Option<SerializedComponentBatch>

An optional color for each vertex.

The alpha channel is ignored.

vertex_texcoords: Option<SerializedComponentBatch>

An optional uv texture coordinate for each vertex.

albedo_factor: Option<SerializedComponentBatch>

A color multiplier applied to the whole mesh.

Alpha channel governs the overall mesh transparency.

albedo_texture_buffer: Option<SerializedComponentBatch>

Optional albedo texture.

Used with the components::Texcoord2D of the mesh.

Currently supports only sRGB(A) textures, ignoring alpha. (meaning that the tensor must have 3 or 4 channels and use the u8 format)

The alpha channel is ignored.

albedo_texture_format: Option<SerializedComponentBatch>

The format of the albedo_texture_buffer, if any.

class_ids: Option<SerializedComponentBatch>

Optional class Ids for the vertices.

The components::ClassId provides colors and labels if not specified explicitly.

Implementations

impl Mesh3D

pub fn descriptor_vertex_positions() -> ComponentDescriptor

Returns the ComponentDescriptor for Self::vertex_positions.

The corresponding component is crate::components::Position3D.

pub fn descriptor_triangle_indices() -> ComponentDescriptor

Returns the ComponentDescriptor for Self::triangle_indices.

The corresponding component is crate::components::TriangleIndices.

pub fn descriptor_vertex_normals() -> ComponentDescriptor

Returns the ComponentDescriptor for Self::vertex_normals.

The corresponding component is crate::components::Vector3D.

pub fn descriptor_vertex_colors() -> ComponentDescriptor

Returns the ComponentDescriptor for Self::vertex_colors.

The corresponding component is crate::components::Color.

pub fn descriptor_vertex_texcoords() -> ComponentDescriptor

Returns the ComponentDescriptor for Self::vertex_texcoords.

The corresponding component is crate::components::Texcoord2D.

pub fn descriptor_albedo_factor() -> ComponentDescriptor

Returns the ComponentDescriptor for Self::albedo_factor.

The corresponding component is crate::components::AlbedoFactor.

pub fn descriptor_albedo_texture_buffer() -> ComponentDescriptor

Returns the ComponentDescriptor for Self::albedo_texture_buffer.

The corresponding component is crate::components::ImageBuffer.

pub fn descriptor_albedo_texture_format() -> ComponentDescriptor

Returns the ComponentDescriptor for Self::albedo_texture_format.

The corresponding component is crate::components::ImageFormat.

pub fn descriptor_class_ids() -> ComponentDescriptor

Returns the ComponentDescriptor for Self::class_ids.

The corresponding component is crate::components::ClassId.

impl Mesh3D

pub const NUM_COMPONENTS: usize = 9usize

The total number of components in the archetype: 1 required, 2 recommended, 6 optional

impl Mesh3D

pub fn new( vertex_positions: impl IntoIterator<Item = impl Into<Position3D>>, ) -> Mesh3D

Create a new Mesh3D.

pub fn update_fields() -> Mesh3D

Update only some specific fields of a Mesh3D.

pub fn clear_fields() -> Mesh3D

Clear all the fields of a Mesh3D.

pub fn columns<I>( self, _lengths: I, ) -> Result<impl Iterator<Item = SerializedComponentColumn>, SerializationError>

where I: IntoIterator<Item = usize> + Clone,

Partitions the component data into multiple sub-batches.

Specifically, this transforms the existing SerializedComponentBatches data into SerializedComponentColumns instead, via SerializedComponentBatch::partitioned.

This makes it possible to use RecordingStream::send_columns to send columnar data directly into Rerun.

The specified lengths must sum to the total length of the component batch.

pub fn columns_of_unit_batches( self, ) -> Result<impl Iterator<Item = SerializedComponentColumn>, SerializationError>

Helper to partition the component data into unit-length sub-batches.

This is semantically similar to calling Self::columns with std::iter::take(1).repeat(n), where n is automatically guessed.

pub fn with_vertex_positions( self, vertex_positions: impl IntoIterator<Item = impl Into<Position3D>>, ) -> Mesh3D

The positions of each vertex.

If no triangle_indices are specified, then each triplet of positions is interpreted as a triangle.

pub fn with_triangle_indices( self, triangle_indices: impl IntoIterator<Item = impl Into<TriangleIndices>>, ) -> Mesh3D

Optional indices for the triangles that make up the mesh.

pub fn with_vertex_normals( self, vertex_normals: impl IntoIterator<Item = impl Into<Vector3D>>, ) -> Mesh3D

An optional normal for each vertex.

pub fn with_vertex_colors( self, vertex_colors: impl IntoIterator<Item = impl Into<Color>>, ) -> Mesh3D

An optional color for each vertex.

The alpha channel is ignored.

pub fn with_vertex_texcoords( self, vertex_texcoords: impl IntoIterator<Item = impl Into<Texcoord2D>>, ) -> Mesh3D

An optional uv texture coordinate for each vertex.

pub fn with_albedo_factor( self, albedo_factor: impl Into<AlbedoFactor>, ) -> Mesh3D

A color multiplier applied to the whole mesh.

Alpha channel governs the overall mesh transparency.

pub fn with_many_albedo_factor( self, albedo_factor: impl IntoIterator<Item = impl Into<AlbedoFactor>>, ) -> Mesh3D

This method makes it possible to pack multiple crate::components::AlbedoFactor in a single component batch.

This only makes sense when used in conjunction with Self::columns. Self::with_albedo_factor should be used when logging a single row’s worth of data.

pub fn with_albedo_texture_buffer( self, albedo_texture_buffer: impl Into<ImageBuffer>, ) -> Mesh3D

Optional albedo texture.

Used with the components::Texcoord2D of the mesh.

Currently supports only sRGB(A) textures, ignoring alpha. (meaning that the tensor must have 3 or 4 channels and use the u8 format)

The alpha channel is ignored.

pub fn with_many_albedo_texture_buffer( self, albedo_texture_buffer: impl IntoIterator<Item = impl Into<ImageBuffer>>, ) -> Mesh3D

This method makes it possible to pack multiple crate::components::ImageBuffer in a single component batch.

This only makes sense when used in conjunction with Self::columns. Self::with_albedo_texture_buffer should be used when logging a single row’s worth of data.

pub fn with_albedo_texture_format( self, albedo_texture_format: impl Into<ImageFormat>, ) -> Mesh3D

The format of the albedo_texture_buffer, if any.

pub fn with_many_albedo_texture_format( self, albedo_texture_format: impl IntoIterator<Item = impl Into<ImageFormat>>, ) -> Mesh3D

This method makes it possible to pack multiple crate::components::ImageFormat in a single component batch.

This only makes sense when used in conjunction with Self::columns. Self::with_albedo_texture_format should be used when logging a single row’s worth of data.

pub fn with_class_ids( self, class_ids: impl IntoIterator<Item = impl Into<ClassId>>, ) -> Mesh3D

Optional class Ids for the vertices.

The components::ClassId provides colors and labels if not specified explicitly.

impl Mesh3D

pub fn with_albedo_texture_image(self, image: impl Into<Image>) -> Mesh3D

Use this image as the albedo texture.

pub fn with_albedo_texture( self, image_format: impl Into<ImageFormat>, image_buffer: impl Into<ImageBuffer>, ) -> Mesh3D

Use this image as the albedo texture.

pub fn sanity_check(&self) -> Result<(), Mesh3DError>

Check that this is a valid mesh, e.g. that the vertex indices are within bounds and that we have the same number of positions and normals (if any).

Only use this when logging a whole new mesh. Not meaningful for field updates!

pub fn num_vertices(&self) -> usize

The total number of vertices.

pub fn num_triangles(&self) -> usize

The total number of triangles.

Trait Implementations

impl Archetype for Mesh3D

fn name() -> ArchetypeName

The fully-qualified name of this archetype, e.g. rerun.archetypes.Points2D.

fn display_name() -> &'static str

Readable name for displaying in UI.

fn required_components() -> Cow<'static, [ComponentDescriptor]>

Returns all component descriptors that must be provided by the user when constructing this archetype.

fn recommended_components() -> Cow<'static, [ComponentDescriptor]>

Returns all component descriptors that should be provided by the user when constructing this archetype.

fn optional_components() -> Cow<'static, [ComponentDescriptor]>

Returns all component descriptors that may be provided by the user when constructing this archetype.

fn all_components() -> Cow<'static, [ComponentDescriptor]>

Returns all component descriptors that must, should and may be provided by the user when constructing this archetype.

fn from_arrow_components( arrow_data: impl IntoIterator<Item = (ComponentDescriptor, Arc<dyn Array>)>, ) -> Result<Mesh3D, DeserializationError>

Given an iterator of Arrow arrays and their respective ComponentDescriptors, deserializes them into this archetype.

fn all_component_identifiers() -> impl Iterator<Item = ComponentIdentifier>

Utility method based on Self::all_components to return all component identifiers.

fn from_arrow( data: impl IntoIterator<Item = (Field, Arc<dyn Array>)>, ) -> Result<Self, DeserializationError>

where Self: Sized,

Given an iterator of Arrow arrays and their respective field metadata, deserializes them into this archetype.

impl AsComponents for Mesh3D

fn as_serialized_batches(&self) -> Vec<SerializedComponentBatch>

Exposes the object’s contents as a set of SerializedComponentBatches.

fn to_arrow(&self) -> Result<Vec<(Field, Arc<dyn Array>)>, SerializationError>

Serializes all non-null Components of this bundle into Arrow arrays.

impl Clone for Mesh3D

fn clone(&self) -> Mesh3D

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Mesh3D

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

Formats the value using the given formatter.

impl Default for Mesh3D

fn default() -> Mesh3D

Returns the “default value” for a type.

impl PartialEq for Mesh3D

fn eq(&self, other: &Mesh3D) -> 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 SizeBytes for Mesh3D

fn heap_size_bytes(&self) -> u64

Returns how many bytes self uses on the heap.

fn total_size_bytes(&self) -> u64

Returns the total size of self in bytes, accounting for both stack and heap space.

fn stack_size_bytes(&self) -> u64

Returns the total size of self on the stack, in bytes.

fn is_pod() -> bool

Is Self just plain old data?

impl VisualizableArchetype for Mesh3D

fn visualizer(&self) -> Visualizer

Create a visualizer for this archetype, using all currently set values as overrides.

impl ArchetypeReflectionMarker for Mesh3D

impl StructuralPartialEq for Mesh3D