Struct ComputedNode

Source

pub struct ComputedNode {
    pub stack_index: u32,
    pub size: Vec2,
    pub content_size: Vec2,
    pub outline_width: f32,
    pub outline_offset: f32,
    pub unrounded_size: Vec2,
    pub border: BorderRect,
    pub border_radius: ResolvedBorderRadius,
    pub padding: BorderRect,
    pub inverse_scale_factor: f32,
}

Expand description

Provides the computed size and layout properties of the node.

Fields in this struct are public but should not be modified under most circumstances. For example, in a scrollbar you may want to derive the handle’s size from the proportion of scrollable content in-view. You can directly modify ComputedNode after layout to set the handle size without any delays.

Fields§

§stack_index: u32

The order of the node in the UI layout. Nodes with a higher stack index are drawn on top of and receive interactions before nodes with lower stack indices.

Automatically calculated in super::UiSystem::Stack.

§size: Vec2

The size of the node as width and height in physical pixels.

Automatically calculated by super::layout::ui_layout_system.

§content_size: Vec2

Size of this node’s content.

Automatically calculated by super::layout::ui_layout_system.

§outline_width: f32

The width of this node’s outline. If this value is Auto, negative or 0. then no outline will be rendered. Outline updates bypass change detection.

Automatically calculated by super::layout::ui_layout_system.

§outline_offset: f32

The amount of space between the outline and the edge of the node. Outline updates bypass change detection.

Automatically calculated by super::layout::ui_layout_system.

§unrounded_size: Vec2

The unrounded size of the node as width and height in physical pixels.

Automatically calculated by super::layout::ui_layout_system.

§border: BorderRect

Resolved border values in physical pixels. Border updates bypass change detection.

Automatically calculated by super::layout::ui_layout_system.

§border_radius: ResolvedBorderRadius

Resolved border radius values in physical pixels. Border radius updates bypass change detection.

Automatically calculated by super::layout::ui_layout_system.

§padding: BorderRect

Resolved padding values in physical pixels. Padding updates bypass change detection.

Automatically calculated by super::layout::ui_layout_system.

§inverse_scale_factor: f32

Inverse scale factor for this Node. Multiply physical coordinates by the inverse scale factor to give logical coordinates.

Automatically calculated by super::layout::ui_layout_system.

Struct ComputedNode Copy item path

Fields§

Implementations§

impl ComputedNode

pub const fn size(&self) -> Vec2

pub const fn content_size(&self) -> Vec2

pub const fn is_empty(&self) -> bool

pub const fn stack_index(&self) -> u32

pub const fn unrounded_size(&self) -> Vec2

pub const fn outline_width(&self) -> f32

pub const fn outline_offset(&self) -> f32

pub const fn outlined_node_size(&self) -> Vec2

pub const fn outline_radius(&self) -> ResolvedBorderRadius

pub const fn border(&self) -> BorderRect

pub const fn border_radius(&self) -> ResolvedBorderRadius

pub fn inner_radius(&self) -> ResolvedBorderRadius

pub const fn padding(&self) -> BorderRect

pub const fn content_inset(&self) -> BorderRect

pub const fn inverse_scale_factor(&self) -> f32

impl ComputedNode

pub const DEFAULT: ComputedNode

Trait Implementations§

impl Clone for ComputedNode

fn clone(&self) -> ComputedNode

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

impl Component for ComputedNodewhere ComputedNode: Send + Sync + 'static,

const STORAGE_TYPE: StorageType = bevy_ecs::component::StorageType::Table

type Mutability = Mutable

fn register_required_components( requiree: ComponentId, components: &mut ComponentsRegistrator<'_>, required_components: &mut RequiredComponents, inheritance_depth: u16, recursion_check_stack: &mut Vec<ComponentId>, )

fn clone_behavior() -> ComponentCloneBehavior

fn register_component_hooks(hooks: &mut ComponentHooks)

fn on_add() -> Option<for<'w> fn(DeferredWorld<'w>, HookContext)>

fn on_insert() -> Option<for<'w> fn(DeferredWorld<'w>, HookContext)>

fn on_replace() -> Option<for<'w> fn(DeferredWorld<'w>, HookContext)>

fn on_remove() -> Option<for<'w> fn(DeferredWorld<'w>, HookContext)>

fn on_despawn() -> Option<for<'w> fn(DeferredWorld<'w>, HookContext)>

fn map_entities<E>(_this: &mut Self, _mapper: &mut E)where E: EntityMapper,

impl Debug for ComputedNode

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

impl Default for ComputedNode

fn default() -> ComputedNode

fn from_reflect( reflect: &(dyn PartialReflect + 'static), ) -> Option<ComputedNode>

fn take_from_reflect( reflect: Box<dyn PartialReflect>, ) -> Result<Self, Box<dyn PartialReflect>>

fn get_type_registration() -> TypeRegistration

fn register_type_dependencies(registry: &mut TypeRegistry)

impl PartialEq for ComputedNode

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

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

fn get_represented_type_info(&self) -> Option<&'static TypeInfo>

fn try_apply( &mut self, value: &(dyn PartialReflect + 'static), ) -> Result<(), ApplyError>

fn reflect_kind(&self) -> ReflectKind

fn reflect_ref(&self) -> ReflectRef<'_>

fn reflect_mut(&mut self) -> ReflectMut<'_>

fn reflect_owned(self: Box<ComputedNode>) -> ReflectOwned

fn try_into_reflect( self: Box<ComputedNode>, ) -> Result<Box<dyn Reflect>, Box<dyn PartialReflect>>

fn try_as_reflect(&self) -> Option<&(dyn Reflect + 'static)>

fn try_as_reflect_mut(&mut self) -> Option<&mut (dyn Reflect + 'static)>

fn into_partial_reflect(self: Box<ComputedNode>) -> Box<dyn PartialReflect>

fn as_partial_reflect(&self) -> &(dyn PartialReflect + 'static)

fn as_partial_reflect_mut(&mut self) -> &mut (dyn PartialReflect + 'static)

fn reflect_partial_eq( &self, value: &(dyn PartialReflect + 'static), ) -> Option<bool>

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

fn reflect_clone(&self) -> Result<Box<dyn Reflect>, ReflectCloneError>

fn apply(&mut self, value: &(dyn PartialReflect + 'static))

fn clone_value(&self) -> Box<dyn PartialReflect>

fn to_dynamic(&self) -> Box<dyn PartialReflect>

fn reflect_hash(&self) -> Option<u64>

fn is_dynamic(&self) -> bool

fn into_any(self: Box<ComputedNode>) -> Box<dyn Any>

fn as_any(&self) -> &(dyn Any + 'static)

fn as_any_mut(&mut self) -> &mut (dyn Any + 'static)

fn into_reflect(self: Box<ComputedNode>) -> Box<dyn Reflect>

fn as_reflect(&self) -> &(dyn Reflect + 'static)

fn as_reflect_mut(&mut self) -> &mut (dyn Reflect + 'static)

fn set(&mut self, value: Box<dyn Reflect>) -> Result<(), Box<dyn Reflect>>

fn field(&self, name: &str) -> Option<&(dyn PartialReflect + 'static)>

fn field_mut( &mut self, name: &str, ) -> Option<&mut (dyn PartialReflect + 'static)>

fn field_at(&self, index: usize) -> Option<&(dyn PartialReflect + 'static)>

fn field_at_mut( &mut self, index: usize, ) -> Option<&mut (dyn PartialReflect + 'static)>

fn name_at(&self, index: usize) -> Option<&str>

Struct ComputedNode

impl Component for ComputedNode
where ComputedNode: Send + Sync + 'static,

fn map_entities<E>(_this: &mut Self, _mapper: &mut E)
where E: EntityMapper,

impl TypePath for ComputedNode
where ComputedNode: Any + Send + Sync,

impl<T> Any for T
where T: 'static + ?Sized,

impl<T, U> AsBindGroupShaderType<U> for T
where U: ShaderType, &'a T: for<'a> Into<U>,

impl<T> Borrow<T> for T
where T: ?Sized,

impl<T> BorrowMut<T> for T
where T: ?Sized,

impl<C> Bundle for C
where C: Component,

impl<C> BundleFromComponents for C
where C: Component,

unsafe fn from_components<T, F>(ctx: &mut T, func: &mut F) -> C
where F: for<'a> FnMut(&'a mut T) -> OwningPtr<'a>,

impl<T> CloneToUninit for T
where T: Clone,

impl<T> Downcast for T
where T: Any,

impl<T> DowncastSend for T
where T: Any + Send,

impl<C> DynamicBundle for C
where C: Component,

impl<T> DynamicTypePath for T
where T: TypePath,