Struct rerun::external::re_entity_db::EntityProperties

pub struct EntityProperties {
    pub interactive: bool,
    pub color_mapper: EditableAutoValue<ColorMapper>,
    pub pinhole_image_plane_distance: EditableAutoValue<f32>,
    pub backproject_depth: EditableAutoValue<bool>,
    pub depth_from_world_scale: EditableAutoValue<f32>,
    pub backproject_radius_scale: EditableAutoValue<f32>,
    pub transform_3d_visible: EditableAutoValue<bool>,
    pub transform_3d_size: EditableAutoValue<f32>,
    pub show_legend: EditableAutoValue<bool>,
    pub legend_location: Option<LegendCorner>,
    pub time_series_aggregator: EditableAutoValue<TimeSeriesAggregator>,
}

Fields

interactive: bool

color_mapper: EditableAutoValue<ColorMapper>

What kind of color mapping should be applied (none, map, texture, transfer..)?

pinhole_image_plane_distance: EditableAutoValue<f32>

Distance of the projection plane (frustum far plane).

Only applies to pinhole cameras when in a spatial view, using 3D navigation.

backproject_depth: EditableAutoValue<bool>

Should the depth texture be backprojected into a point cloud?

Only applies to tensors with meaning=depth that are affected by a pinhole transform.

The default for 3D views is true, but for 2D views it is false.

depth_from_world_scale: EditableAutoValue<f32>

How many depth units per world-space unit. e.g. 1000 for millimeters.

This corresponds to re_components::Tensor::meter.

backproject_radius_scale: EditableAutoValue<f32>

Used to scale the radii of the points in the resulting point cloud.

transform_3d_visible: EditableAutoValue<bool>

Whether to show the 3D transform visualization at all.

transform_3d_size: EditableAutoValue<f32>

The length of the arrows in the entity’s own coordinate system (space).

show_legend: EditableAutoValue<bool>

Should the legend be shown (for plot space views).

legend_location: Option<LegendCorner>

The location of the legend (for plot space views).

This is an Option instead of an EditableAutoValue to let each space view class decide on what’s the best default.

time_series_aggregator: EditableAutoValue<TimeSeriesAggregator>

What kind of data aggregation to perform (for plot space views).

Implementations

impl EntityProperties

pub fn with_child(&self, child: &EntityProperties) -> EntityProperties

Multiply/and these together.

pub fn merge_with(&self, other: &EntityProperties) -> EntityProperties

Merge this EntityProperty with the values from another EntityProperty.

When merging, other values are preferred over self values unless they are auto values, in which case self values are preferred.

This is important to combine the base-layer of up-to-date auto-values with values loaded from the Blueprint store where the Auto values are not up-to-date.

pub fn has_edits(&self, other: &EntityProperties) -> bool

Determine whether this EntityProperty has user-edits relative to another EntityProperty

Trait Implementations

impl Clone for EntityProperties

fn clone(&self) -> EntityProperties

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for EntityProperties

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

Formats the value using the given formatter.

impl Default for EntityProperties

fn default() -> EntityProperties

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for EntityProperties

where EntityProperties: Default,

fn deserialize<__D>( __deserializer: __D ) -> Result<EntityProperties, <__D as Deserializer<'de>>::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl From<EntityProperties> for EntityPropertiesComponent

fn from(props: EntityProperties) -> EntityPropertiesComponent

Converts to this type from the input type.

impl From<EntityPropertiesComponent> for EntityProperties

fn from(value: EntityPropertiesComponent) -> EntityProperties

Converts to this type from the input type.

impl PartialEq for EntityProperties

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

This method tests for self and other values to be equal, and is used by ==.

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

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

impl Serialize for EntityProperties

fn serialize<__S>( &self, __serializer: __S ) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for EntityProperties