Struct Attribute 

pub struct Attribute { /* private fields */ }

The attribute data model: a vertex attribute and the enums describing it. Represents an attribute in a mesh. An attribute can be an array of values representing potisions of vertices, or it can be an array of values representing normals of vertices or corners, or faces. Note that the struct does not have the static type information, so the attribute value can be a vector of any type of any dimension, as long as it implements the Vector trait. The information about the type of the attribute, component type, and the number of components is stored in dynamically.

Implementations

impl Attribute

pub fn new<Data, const N: usize>( data: Vec<Data>, att_type: AttributeType, domain: AttributeDomain, parents: Vec<AttributeId>, ) -> Attribute

where Data: Vector<N>,

Creates an attribute from a vector of values with a placeholder id, removing duplicate values and recording the point-to-value map.

pub fn new_empty( id: AttributeId, att_type: AttributeType, domain: AttributeDomain, component_type: ComponentDataType, num_components: usize, ) -> Attribute

Creates an attribute with no values, with the given type, domain, and component layout.

pub fn from<Data, const N: usize>( id: AttributeId, data: Vec<Data>, att_type: AttributeType, domain: AttributeDomain, parents: Vec<AttributeId>, ) -> Attribute

where Data: Vector<N>,

Creates an attribute from a vector of values with the given id, removing duplicate values and recording the point-to-value map.

pub fn from_without_removing_duplicates<Data, const N: usize>( id: AttributeId, data: Vec<Data>, att_type: AttributeType, domain: AttributeDomain, parents: Vec<AttributeId>, ) -> Attribute

where Data: Vector<N>,

Creates an attribute from a vector of values with the given id, keeping the values as-is on the implicit identity point-to-value map.

pub fn get<Data, const N: usize>(&self, p_idx: PointIdx) -> Data

where Data: Vector<N>, <Data as Vector<N>>::Component: DataValue,

Returns the value attached to the given point.

pub fn get_unique_val<Data, const N: usize>( &self, val_idx: AttributeValueIdx, ) -> Data

where Data: Vector<N>, <Data as Vector<N>>::Component: DataValue,

Returns the unique value at the given value index.

pub fn get_component_type(&self) -> ComponentDataType

Returns the component data type of the values.

pub fn get_data_as_bytes(&self) -> &[u8]

Returns the unique values as raw bytes.

pub fn set_point_to_att_val_map( &mut self, point_to_att_val_map: Option<VecPointIdx<AttributeValueIdx>>, )

Replaces the point-to-value map. None means the identity mapping.

pub fn take_point_to_att_val_map(self) -> Option<VecPointIdx<AttributeValueIdx>>

Consumes the attribute and returns its point-to-value map, if any.

pub fn point_map_as_slice(&self) -> Option<&[AttributeValueIdx]>

The point-to-value map as a plain slice, if the attribute has one.

pub fn set_point_att_val(&mut self, p_idx: PointIdx, val_idx: AttributeValueIdx)

Assigns the attribute-value index of a single point. The point-to-value map must already be present (see Self::set_point_to_att_val_map); this fills it entry by entry as a traversal visits each point.

pub unsafe fn set_point_att_val_unchecked( &mut self, p_idx: PointIdx, val_idx: AttributeValueIdx, )

Self::set_point_att_val without the presence and bound checks.

Safety

The point-to-value map must be present and p_idx must be less than its length.

pub fn get_id(&self) -> AttributeId

Returns the id of the attribute.

pub fn get_num_components(&self) -> usize

Returns the number of components per value.

pub fn get_attribute_type(&self) -> AttributeType

Returns the semantic type of the attribute.

pub fn get_domain(&self) -> AttributeDomain

Returns the domain the attribute is defined on.

pub fn get_parents(&self) -> &Vec<AttributeId>

Returns the ids of the attributes this attribute depends on.

pub fn len(&self) -> usize

The number of points the attribute covers. Points sharing a value are counted individually; see Self::num_unique_values for the stored value count.

pub fn is_empty(&self) -> bool

Returns true if the attribute has no values.

pub fn num_unique_values(&self) -> usize

The number of unique values stored in the buffer.

pub fn mint(&mut self, src: PointIdx) -> PointIdx

Appends a new point whose attribute value aliases that of src, and returns its index. No new unique value is stored; the new point reuses the source’s AttributeValueIdx. If the attribute is still on the implicit identity point -> value map, that map is materialized first so the appended entry can diverge from identity.

This is how the encoder splits a non-manifold point, calling mint on every attribute in lockstep so the point spaces stay equal.

pub fn get_unique_val_idx(&self, idx: PointIdx) -> AttributeValueIdx

Returns the index of the unique value attached to the given point. Panics if the point index is out of bounds.

pub fn set_name(&mut self, name: String)

Sets the name of the attribute.

pub fn get_name(&self) -> Option<&String>

Returns the name of the attribute, if any.

pub fn unique_vals_as_slice<Data>(&self) -> &[Data]

Returns the unique values as a slice of Data. Panics unless the size of Data equals the byte size of one value (component size times component count).

pub fn unique_vals_as_slice_mut<Data>(&mut self) -> &mut [Data]

Returns the unique values as a mutable slice of Data. Panics unless the size of Data equals the byte size of one value (component size times component count).

pub unsafe fn unique_vals_as_slice_unchecked<Data>(&self) -> &[Data]

Returns the unique values as a slice of Data without checking the size.

Safety

The buffer’s data must be properly aligned for Data and the size of Data must equal the byte size of one value.

pub unsafe fn unique_vals_as_slice_unchecked_mut<Data>(&mut self) -> &mut [Data]

Returns the unique values as a mutable slice of Data without checking the size.

Safety

The buffer’s data must be properly aligned for Data and the size of Data must equal the byte size of one value.

pub fn permute(&mut self, indices: &[usize])

permutes the data in the buffer according to the given indices, i.e. i-th element in the buffer will be moved to indices[i]-th position.

pub fn permute_unchecked(&mut self, indices: &[usize])

permutes the data in the buffer according to the given indices, i.e. i-th element in the buffer will be moved to indices[i]-th position.

Safety:

This function assumes that the indices are valid, i.e. they are within the bounds of the buffer.

pub fn swap(&mut self, i: usize, j: usize)

swaps the elements at indices i and j in the buffer.

pub fn take_values<Data, const N: usize>(self) -> Vec<Data>

where Data: Vector<N>,

Consumes the attribute and returns its unique values. Panics unless Data matches the attribute’s component type and count.

pub fn into_parts<Data, const N: usize>( self, ) -> (Vec<Data>, Option<VecPointIdx<AttributeValueIdx>>, Attribute)

where Data: Vector<N>,

Splits the attribute into its unique values, its point-to-value map, and the emptied attribute carrying the remaining metadata. Panics unless Data matches the attribute’s component type and count.

pub fn set_values<Data, const N: usize>(&mut self, data: Vec<Data>)

where Data: Vector<N>,

Sets the values of an empty attribute. Panics if the attribute already has values or Data does not match its component type and count.

pub fn remove_duplicate_values<Data, const N: usize>(&mut self)

where Data: Vector<N>,

Deduplicates equal values, compacting the buffer and recording the point-to-value map.

pub fn remove_unique_val_dyn(&mut self, val_idx: usize)

pub fn retain_points_dyn(&mut self, keep_point_indices: &[usize])

Retains only points at the given sorted indices. O(n) instead of O(n^2). keep_point_indices must be sorted in ascending order.

Trait Implementations

impl Clone for Attribute

fn clone(&self) -> Attribute

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Attribute

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

Formats the value using the given formatter.