#![allow(unused_imports)]
#![allow(unused_parens)]
#![allow(clippy::clone_on_copy)]
#![allow(clippy::cloned_instead_of_copied)]
#![allow(clippy::map_flatten)]
#![allow(clippy::needless_question_mark)]
#![allow(clippy::new_without_default)]
#![allow(clippy::redundant_closure)]
#![allow(clippy::too_many_arguments)]
#![allow(clippy::too_many_lines)]
use ::re_types_core::try_serialize_field;
use ::re_types_core::SerializationResult;
use ::re_types_core::{ComponentBatch, SerializedComponentBatch};
use ::re_types_core::{ComponentDescriptor, ComponentName};
use ::re_types_core::{DeserializationError, DeserializationResult};
#[derive(Clone, Debug, PartialEq, Default)]
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>,
}
impl Mesh3D {
#[inline]
pub fn descriptor_vertex_positions() -> ComponentDescriptor {
ComponentDescriptor {
archetype_name: Some("rerun.archetypes.Mesh3D".into()),
component_name: "rerun.components.Position3D".into(),
archetype_field_name: Some("vertex_positions".into()),
}
}
#[inline]
pub fn descriptor_triangle_indices() -> ComponentDescriptor {
ComponentDescriptor {
archetype_name: Some("rerun.archetypes.Mesh3D".into()),
component_name: "rerun.components.TriangleIndices".into(),
archetype_field_name: Some("triangle_indices".into()),
}
}
#[inline]
pub fn descriptor_vertex_normals() -> ComponentDescriptor {
ComponentDescriptor {
archetype_name: Some("rerun.archetypes.Mesh3D".into()),
component_name: "rerun.components.Vector3D".into(),
archetype_field_name: Some("vertex_normals".into()),
}
}
#[inline]
pub fn descriptor_vertex_colors() -> ComponentDescriptor {
ComponentDescriptor {
archetype_name: Some("rerun.archetypes.Mesh3D".into()),
component_name: "rerun.components.Color".into(),
archetype_field_name: Some("vertex_colors".into()),
}
}
#[inline]
pub fn descriptor_vertex_texcoords() -> ComponentDescriptor {
ComponentDescriptor {
archetype_name: Some("rerun.archetypes.Mesh3D".into()),
component_name: "rerun.components.Texcoord2D".into(),
archetype_field_name: Some("vertex_texcoords".into()),
}
}
#[inline]
pub fn descriptor_albedo_factor() -> ComponentDescriptor {
ComponentDescriptor {
archetype_name: Some("rerun.archetypes.Mesh3D".into()),
component_name: "rerun.components.AlbedoFactor".into(),
archetype_field_name: Some("albedo_factor".into()),
}
}
#[inline]
pub fn descriptor_albedo_texture_buffer() -> ComponentDescriptor {
ComponentDescriptor {
archetype_name: Some("rerun.archetypes.Mesh3D".into()),
component_name: "rerun.components.ImageBuffer".into(),
archetype_field_name: Some("albedo_texture_buffer".into()),
}
}
#[inline]
pub fn descriptor_albedo_texture_format() -> ComponentDescriptor {
ComponentDescriptor {
archetype_name: Some("rerun.archetypes.Mesh3D".into()),
component_name: "rerun.components.ImageFormat".into(),
archetype_field_name: Some("albedo_texture_format".into()),
}
}
#[inline]
pub fn descriptor_class_ids() -> ComponentDescriptor {
ComponentDescriptor {
archetype_name: Some("rerun.archetypes.Mesh3D".into()),
component_name: "rerun.components.ClassId".into(),
archetype_field_name: Some("class_ids".into()),
}
}
#[inline]
pub fn descriptor_indicator() -> ComponentDescriptor {
ComponentDescriptor {
archetype_name: Some("rerun.archetypes.Mesh3D".into()),
component_name: "rerun.components.Mesh3DIndicator".into(),
archetype_field_name: None,
}
}
}
static REQUIRED_COMPONENTS: once_cell::sync::Lazy<[ComponentDescriptor; 1usize]> =
once_cell::sync::Lazy::new(|| [Mesh3D::descriptor_vertex_positions()]);
static RECOMMENDED_COMPONENTS: once_cell::sync::Lazy<[ComponentDescriptor; 3usize]> =
once_cell::sync::Lazy::new(|| {
[
Mesh3D::descriptor_triangle_indices(),
Mesh3D::descriptor_vertex_normals(),
Mesh3D::descriptor_indicator(),
]
});
static OPTIONAL_COMPONENTS: once_cell::sync::Lazy<[ComponentDescriptor; 6usize]> =
once_cell::sync::Lazy::new(|| {
[
Mesh3D::descriptor_vertex_colors(),
Mesh3D::descriptor_vertex_texcoords(),
Mesh3D::descriptor_albedo_factor(),
Mesh3D::descriptor_albedo_texture_buffer(),
Mesh3D::descriptor_albedo_texture_format(),
Mesh3D::descriptor_class_ids(),
]
});
static ALL_COMPONENTS: once_cell::sync::Lazy<[ComponentDescriptor; 10usize]> =
once_cell::sync::Lazy::new(|| {
[
Mesh3D::descriptor_vertex_positions(),
Mesh3D::descriptor_triangle_indices(),
Mesh3D::descriptor_vertex_normals(),
Mesh3D::descriptor_indicator(),
Mesh3D::descriptor_vertex_colors(),
Mesh3D::descriptor_vertex_texcoords(),
Mesh3D::descriptor_albedo_factor(),
Mesh3D::descriptor_albedo_texture_buffer(),
Mesh3D::descriptor_albedo_texture_format(),
Mesh3D::descriptor_class_ids(),
]
});
impl Mesh3D {
pub const NUM_COMPONENTS: usize = 10usize;
}
pub type Mesh3DIndicator = ::re_types_core::GenericIndicatorComponent<Mesh3D>;
impl ::re_types_core::Archetype for Mesh3D {
type Indicator = Mesh3DIndicator;
#[inline]
fn name() -> ::re_types_core::ArchetypeName {
"rerun.archetypes.Mesh3D".into()
}
#[inline]
fn display_name() -> &'static str {
"Mesh 3D"
}
#[inline]
fn indicator() -> SerializedComponentBatch {
#[allow(clippy::unwrap_used)]
Mesh3DIndicator::DEFAULT.serialized().unwrap()
}
#[inline]
fn required_components() -> ::std::borrow::Cow<'static, [ComponentDescriptor]> {
REQUIRED_COMPONENTS.as_slice().into()
}
#[inline]
fn recommended_components() -> ::std::borrow::Cow<'static, [ComponentDescriptor]> {
RECOMMENDED_COMPONENTS.as_slice().into()
}
#[inline]
fn optional_components() -> ::std::borrow::Cow<'static, [ComponentDescriptor]> {
OPTIONAL_COMPONENTS.as_slice().into()
}
#[inline]
fn all_components() -> ::std::borrow::Cow<'static, [ComponentDescriptor]> {
ALL_COMPONENTS.as_slice().into()
}
#[inline]
fn from_arrow_components(
arrow_data: impl IntoIterator<Item = (ComponentDescriptor, arrow::array::ArrayRef)>,
) -> DeserializationResult<Self> {
re_tracing::profile_function!();
use ::re_types_core::{Loggable as _, ResultExt as _};
let arrays_by_descr: ::nohash_hasher::IntMap<_, _> = arrow_data.into_iter().collect();
let vertex_positions = arrays_by_descr
.get(&Self::descriptor_vertex_positions())
.map(|array| {
SerializedComponentBatch::new(array.clone(), Self::descriptor_vertex_positions())
});
let triangle_indices = arrays_by_descr
.get(&Self::descriptor_triangle_indices())
.map(|array| {
SerializedComponentBatch::new(array.clone(), Self::descriptor_triangle_indices())
});
let vertex_normals = arrays_by_descr
.get(&Self::descriptor_vertex_normals())
.map(|array| {
SerializedComponentBatch::new(array.clone(), Self::descriptor_vertex_normals())
});
let vertex_colors = arrays_by_descr
.get(&Self::descriptor_vertex_colors())
.map(|array| {
SerializedComponentBatch::new(array.clone(), Self::descriptor_vertex_colors())
});
let vertex_texcoords = arrays_by_descr
.get(&Self::descriptor_vertex_texcoords())
.map(|array| {
SerializedComponentBatch::new(array.clone(), Self::descriptor_vertex_texcoords())
});
let albedo_factor = arrays_by_descr
.get(&Self::descriptor_albedo_factor())
.map(|array| {
SerializedComponentBatch::new(array.clone(), Self::descriptor_albedo_factor())
});
let albedo_texture_buffer = arrays_by_descr
.get(&Self::descriptor_albedo_texture_buffer())
.map(|array| {
SerializedComponentBatch::new(
array.clone(),
Self::descriptor_albedo_texture_buffer(),
)
});
let albedo_texture_format = arrays_by_descr
.get(&Self::descriptor_albedo_texture_format())
.map(|array| {
SerializedComponentBatch::new(
array.clone(),
Self::descriptor_albedo_texture_format(),
)
});
let class_ids = arrays_by_descr
.get(&Self::descriptor_class_ids())
.map(|array| {
SerializedComponentBatch::new(array.clone(), Self::descriptor_class_ids())
});
Ok(Self {
vertex_positions,
triangle_indices,
vertex_normals,
vertex_colors,
vertex_texcoords,
albedo_factor,
albedo_texture_buffer,
albedo_texture_format,
class_ids,
})
}
}
impl ::re_types_core::AsComponents for Mesh3D {
#[inline]
fn as_serialized_batches(&self) -> Vec<SerializedComponentBatch> {
use ::re_types_core::Archetype as _;
[
Some(Self::indicator()),
self.vertex_positions.clone(),
self.triangle_indices.clone(),
self.vertex_normals.clone(),
self.vertex_colors.clone(),
self.vertex_texcoords.clone(),
self.albedo_factor.clone(),
self.albedo_texture_buffer.clone(),
self.albedo_texture_format.clone(),
self.class_ids.clone(),
]
.into_iter()
.flatten()
.collect()
}
}
impl ::re_types_core::ArchetypeReflectionMarker for Mesh3D {}
impl Mesh3D {
#[inline]
pub fn new(
vertex_positions: impl IntoIterator<Item = impl Into<crate::components::Position3D>>,
) -> Self {
Self {
vertex_positions: try_serialize_field(
Self::descriptor_vertex_positions(),
vertex_positions,
),
triangle_indices: None,
vertex_normals: None,
vertex_colors: None,
vertex_texcoords: None,
albedo_factor: None,
albedo_texture_buffer: None,
albedo_texture_format: None,
class_ids: None,
}
}
#[inline]
pub fn update_fields() -> Self {
Self::default()
}
#[inline]
pub fn clear_fields() -> Self {
use ::re_types_core::Loggable as _;
Self {
vertex_positions: Some(SerializedComponentBatch::new(
crate::components::Position3D::arrow_empty(),
Self::descriptor_vertex_positions(),
)),
triangle_indices: Some(SerializedComponentBatch::new(
crate::components::TriangleIndices::arrow_empty(),
Self::descriptor_triangle_indices(),
)),
vertex_normals: Some(SerializedComponentBatch::new(
crate::components::Vector3D::arrow_empty(),
Self::descriptor_vertex_normals(),
)),
vertex_colors: Some(SerializedComponentBatch::new(
crate::components::Color::arrow_empty(),
Self::descriptor_vertex_colors(),
)),
vertex_texcoords: Some(SerializedComponentBatch::new(
crate::components::Texcoord2D::arrow_empty(),
Self::descriptor_vertex_texcoords(),
)),
albedo_factor: Some(SerializedComponentBatch::new(
crate::components::AlbedoFactor::arrow_empty(),
Self::descriptor_albedo_factor(),
)),
albedo_texture_buffer: Some(SerializedComponentBatch::new(
crate::components::ImageBuffer::arrow_empty(),
Self::descriptor_albedo_texture_buffer(),
)),
albedo_texture_format: Some(SerializedComponentBatch::new(
crate::components::ImageFormat::arrow_empty(),
Self::descriptor_albedo_texture_format(),
)),
class_ids: Some(SerializedComponentBatch::new(
crate::components::ClassId::arrow_empty(),
Self::descriptor_class_ids(),
)),
}
}
#[inline]
pub fn columns<I>(
self,
_lengths: I,
) -> SerializationResult<impl Iterator<Item = ::re_types_core::SerializedComponentColumn>>
where
I: IntoIterator<Item = usize> + Clone,
{
let columns = [
self.vertex_positions
.map(|vertex_positions| vertex_positions.partitioned(_lengths.clone()))
.transpose()?,
self.triangle_indices
.map(|triangle_indices| triangle_indices.partitioned(_lengths.clone()))
.transpose()?,
self.vertex_normals
.map(|vertex_normals| vertex_normals.partitioned(_lengths.clone()))
.transpose()?,
self.vertex_colors
.map(|vertex_colors| vertex_colors.partitioned(_lengths.clone()))
.transpose()?,
self.vertex_texcoords
.map(|vertex_texcoords| vertex_texcoords.partitioned(_lengths.clone()))
.transpose()?,
self.albedo_factor
.map(|albedo_factor| albedo_factor.partitioned(_lengths.clone()))
.transpose()?,
self.albedo_texture_buffer
.map(|albedo_texture_buffer| albedo_texture_buffer.partitioned(_lengths.clone()))
.transpose()?,
self.albedo_texture_format
.map(|albedo_texture_format| albedo_texture_format.partitioned(_lengths.clone()))
.transpose()?,
self.class_ids
.map(|class_ids| class_ids.partitioned(_lengths.clone()))
.transpose()?,
];
Ok(columns
.into_iter()
.flatten()
.chain([::re_types_core::indicator_column::<Self>(
_lengths.into_iter().count(),
)?]))
}
#[inline]
pub fn columns_of_unit_batches(
self,
) -> SerializationResult<impl Iterator<Item = ::re_types_core::SerializedComponentColumn>> {
let len_vertex_positions = self.vertex_positions.as_ref().map(|b| b.array.len());
let len_triangle_indices = self.triangle_indices.as_ref().map(|b| b.array.len());
let len_vertex_normals = self.vertex_normals.as_ref().map(|b| b.array.len());
let len_vertex_colors = self.vertex_colors.as_ref().map(|b| b.array.len());
let len_vertex_texcoords = self.vertex_texcoords.as_ref().map(|b| b.array.len());
let len_albedo_factor = self.albedo_factor.as_ref().map(|b| b.array.len());
let len_albedo_texture_buffer = self.albedo_texture_buffer.as_ref().map(|b| b.array.len());
let len_albedo_texture_format = self.albedo_texture_format.as_ref().map(|b| b.array.len());
let len_class_ids = self.class_ids.as_ref().map(|b| b.array.len());
let len = None
.or(len_vertex_positions)
.or(len_triangle_indices)
.or(len_vertex_normals)
.or(len_vertex_colors)
.or(len_vertex_texcoords)
.or(len_albedo_factor)
.or(len_albedo_texture_buffer)
.or(len_albedo_texture_format)
.or(len_class_ids)
.unwrap_or(0);
self.columns(std::iter::repeat(1).take(len))
}
#[inline]
pub fn with_vertex_positions(
mut self,
vertex_positions: impl IntoIterator<Item = impl Into<crate::components::Position3D>>,
) -> Self {
self.vertex_positions =
try_serialize_field(Self::descriptor_vertex_positions(), vertex_positions);
self
}
#[inline]
pub fn with_triangle_indices(
mut self,
triangle_indices: impl IntoIterator<Item = impl Into<crate::components::TriangleIndices>>,
) -> Self {
self.triangle_indices =
try_serialize_field(Self::descriptor_triangle_indices(), triangle_indices);
self
}
#[inline]
pub fn with_vertex_normals(
mut self,
vertex_normals: impl IntoIterator<Item = impl Into<crate::components::Vector3D>>,
) -> Self {
self.vertex_normals =
try_serialize_field(Self::descriptor_vertex_normals(), vertex_normals);
self
}
#[inline]
pub fn with_vertex_colors(
mut self,
vertex_colors: impl IntoIterator<Item = impl Into<crate::components::Color>>,
) -> Self {
self.vertex_colors = try_serialize_field(Self::descriptor_vertex_colors(), vertex_colors);
self
}
#[inline]
pub fn with_vertex_texcoords(
mut self,
vertex_texcoords: impl IntoIterator<Item = impl Into<crate::components::Texcoord2D>>,
) -> Self {
self.vertex_texcoords =
try_serialize_field(Self::descriptor_vertex_texcoords(), vertex_texcoords);
self
}
#[inline]
pub fn with_albedo_factor(
mut self,
albedo_factor: impl Into<crate::components::AlbedoFactor>,
) -> Self {
self.albedo_factor = try_serialize_field(Self::descriptor_albedo_factor(), [albedo_factor]);
self
}
#[inline]
pub fn with_many_albedo_factor(
mut self,
albedo_factor: impl IntoIterator<Item = impl Into<crate::components::AlbedoFactor>>,
) -> Self {
self.albedo_factor = try_serialize_field(Self::descriptor_albedo_factor(), albedo_factor);
self
}
#[inline]
pub fn with_albedo_texture_buffer(
mut self,
albedo_texture_buffer: impl Into<crate::components::ImageBuffer>,
) -> Self {
self.albedo_texture_buffer = try_serialize_field(
Self::descriptor_albedo_texture_buffer(),
[albedo_texture_buffer],
);
self
}
#[inline]
pub fn with_many_albedo_texture_buffer(
mut self,
albedo_texture_buffer: impl IntoIterator<Item = impl Into<crate::components::ImageBuffer>>,
) -> Self {
self.albedo_texture_buffer = try_serialize_field(
Self::descriptor_albedo_texture_buffer(),
albedo_texture_buffer,
);
self
}
#[inline]
pub fn with_albedo_texture_format(
mut self,
albedo_texture_format: impl Into<crate::components::ImageFormat>,
) -> Self {
self.albedo_texture_format = try_serialize_field(
Self::descriptor_albedo_texture_format(),
[albedo_texture_format],
);
self
}
#[inline]
pub fn with_many_albedo_texture_format(
mut self,
albedo_texture_format: impl IntoIterator<Item = impl Into<crate::components::ImageFormat>>,
) -> Self {
self.albedo_texture_format = try_serialize_field(
Self::descriptor_albedo_texture_format(),
albedo_texture_format,
);
self
}
#[inline]
pub fn with_class_ids(
mut self,
class_ids: impl IntoIterator<Item = impl Into<crate::components::ClassId>>,
) -> Self {
self.class_ids = try_serialize_field(Self::descriptor_class_ids(), class_ids);
self
}
}
impl ::re_byte_size::SizeBytes for Mesh3D {
#[inline]
fn heap_size_bytes(&self) -> u64 {
self.vertex_positions.heap_size_bytes()
+ self.triangle_indices.heap_size_bytes()
+ self.vertex_normals.heap_size_bytes()
+ self.vertex_colors.heap_size_bytes()
+ self.vertex_texcoords.heap_size_bytes()
+ self.albedo_factor.heap_size_bytes()
+ self.albedo_texture_buffer.heap_size_bytes()
+ self.albedo_texture_format.heap_size_bytes()
+ self.class_ids.heap_size_bytes()
}
}