Struct bevy_transform::components::Transform
source · pub struct Transform {
pub translation: Vec3,
pub rotation: Quat,
pub scale: Vec3,
}
Expand description
Describe the position of an entity. If the entity has a parent, the position is relative to its parent position.
- To place or move an entity, you should set its
Transform
. - To get the global transform of an entity, you should get its
GlobalTransform
. - To be displayed, an entity must have both a
Transform
and aGlobalTransform
.- You may use the
TransformBundle
to guarantee this.
- You may use the
§Transform
and GlobalTransform
Transform
is the position of an entity relative to its parent position, or the reference
frame if it doesn’t have a Parent
.
GlobalTransform
is the position of an entity relative to the reference frame.
GlobalTransform
is updated from Transform
by systems in the system set
TransformPropagate
.
This system runs during PostUpdate
. If you
update the Transform
of an entity during this set or after, you will notice a 1 frame lag
before the GlobalTransform
is updated.
§Examples
Fields§
§translation: Vec3
Position of the entity. In 2d, the last value of the Vec3
is used for z-ordering.
See the translations
example for usage.
rotation: Quat
Rotation of the entity.
See the 3d_rotation
example for usage.
scale: Vec3
Scale of the entity.
See the scale
example for usage.
Implementations§
source§impl Transform
impl Transform
sourcepub const IDENTITY: Self = _
pub const IDENTITY: Self = _
An identity Transform
with no translation, rotation, and a scale of 1 on all axes.
sourcepub const fn from_xyz(x: f32, y: f32, z: f32) -> Self
pub const fn from_xyz(x: f32, y: f32, z: f32) -> Self
Creates a new Transform
at the position (x, y, z)
. In 2d, the z
component
is used for z-ordering elements: higher z
-value will be in front of lower
z
-value.
sourcepub fn from_matrix(world_from_local: Mat4) -> Self
pub fn from_matrix(world_from_local: Mat4) -> Self
Extracts the translation, rotation, and scale from matrix
. It must be a 3d affine
transformation matrix.
sourcepub const fn from_translation(translation: Vec3) -> Self
pub const fn from_translation(translation: Vec3) -> Self
Creates a new Transform
, with translation
. Rotation will be 0 and scale 1 on
all axes.
sourcepub const fn from_rotation(rotation: Quat) -> Self
pub const fn from_rotation(rotation: Quat) -> Self
Creates a new Transform
, with rotation
. Translation will be 0 and scale 1 on
all axes.
sourcepub const fn from_scale(scale: Vec3) -> Self
pub const fn from_scale(scale: Vec3) -> Self
Creates a new Transform
, with scale
. Translation will be 0 and rotation 0 on
all axes.
sourcepub fn looking_at(self, target: Vec3, up: impl TryInto<Dir3>) -> Self
pub fn looking_at(self, target: Vec3, up: impl TryInto<Dir3>) -> Self
Returns this Transform
with a new rotation so that Transform::forward
points towards the target
position and Transform::up
points towards up
.
In some cases it’s not possible to construct a rotation. Another axis will be picked in those cases:
- if
target
is the same as the transform translation,Vec3::Z
is used instead - if
up
fails converting toDir3
(e.g if it isVec3::ZERO
),Dir3::Y
is used instead - if the resulting forward direction is parallel with
up
, an orthogonal vector is used as the “right” direction
sourcepub fn looking_to(
self,
direction: impl TryInto<Dir3>,
up: impl TryInto<Dir3>
) -> Self
pub fn looking_to( self, direction: impl TryInto<Dir3>, up: impl TryInto<Dir3> ) -> Self
Returns this Transform
with a new rotation so that Transform::forward
points in the given direction
and Transform::up
points towards up
.
In some cases it’s not possible to construct a rotation. Another axis will be picked in those cases:
- if
direction
fails converting toDir3
(e.g if it isVec3::ZERO
),Dir3::Z
is used instead - if
up
fails converting toDir3
,Dir3::Y
is used instead - if
direction
is parallel withup
, an orthogonal vector is used as the “right” direction
sourcepub fn aligned_by(
self,
main_axis: impl TryInto<Dir3>,
main_direction: impl TryInto<Dir3>,
secondary_axis: impl TryInto<Dir3>,
secondary_direction: impl TryInto<Dir3>
) -> Self
pub fn aligned_by( self, main_axis: impl TryInto<Dir3>, main_direction: impl TryInto<Dir3>, secondary_axis: impl TryInto<Dir3>, secondary_direction: impl TryInto<Dir3> ) -> Self
Rotates this Transform
so that the main_axis
vector, reinterpreted in local coordinates, points
in the given main_direction
, while secondary_axis
points towards secondary_direction
.
For example, if a spaceship model has its nose pointing in the X-direction in its own local coordinates
and its dorsal fin pointing in the Y-direction, then align(Dir3::X, v, Dir3::Y, w)
will make the spaceship’s
nose point in the direction of v
, while the dorsal fin does its best to point in the direction w
.
In some cases a rotation cannot be constructed. Another axis will be picked in those cases:
- if
main_axis
ormain_direction
fail converting toDir3
(e.g are zero),Dir3::X
takes their place - if
secondary_axis
orsecondary_direction
fail converting,Dir3::Y
takes their place - if
main_axis
is parallel withsecondary_axis
ormain_direction
is parallel withsecondary_direction
, a rotation is constructed which takesmain_axis
tomain_direction
along a great circle, ignoring the secondary counterparts
See Transform::align
for additional details.
sourcepub const fn with_translation(self, translation: Vec3) -> Self
pub const fn with_translation(self, translation: Vec3) -> Self
Returns this Transform
with a new translation.
sourcepub const fn with_rotation(self, rotation: Quat) -> Self
pub const fn with_rotation(self, rotation: Quat) -> Self
Returns this Transform
with a new rotation.
sourcepub const fn with_scale(self, scale: Vec3) -> Self
pub const fn with_scale(self, scale: Vec3) -> Self
Returns this Transform
with a new scale.
sourcepub fn compute_matrix(&self) -> Mat4
pub fn compute_matrix(&self) -> Mat4
Returns the 3d affine transformation matrix from this transforms translation, rotation, and scale.
sourcepub fn compute_affine(&self) -> Affine3A
pub fn compute_affine(&self) -> Affine3A
Returns the 3d affine transformation matrix from this transforms translation, rotation, and scale.
sourcepub fn left(&self) -> Dir3
pub fn left(&self) -> Dir3
Equivalent to -local_x()
sourcepub fn down(&self) -> Dir3
pub fn down(&self) -> Dir3
Equivalent to -local_y()
sourcepub fn forward(&self) -> Dir3
pub fn forward(&self) -> Dir3
Equivalent to -local_z()
sourcepub fn rotate(&mut self, rotation: Quat)
pub fn rotate(&mut self, rotation: Quat)
sourcepub fn rotate_axis(&mut self, axis: Dir3, angle: f32)
pub fn rotate_axis(&mut self, axis: Dir3, angle: f32)
sourcepub fn rotate_local(&mut self, rotation: Quat)
pub fn rotate_local(&mut self, rotation: Quat)
sourcepub fn rotate_local_axis(&mut self, axis: Dir3, angle: f32)
pub fn rotate_local_axis(&mut self, axis: Dir3, angle: f32)
Rotates this Transform
around its local axis
by angle
(in radians).
sourcepub fn rotate_local_x(&mut self, angle: f32)
pub fn rotate_local_x(&mut self, angle: f32)
Rotates this Transform
around its local X
axis by angle
(in radians).
sourcepub fn rotate_local_y(&mut self, angle: f32)
pub fn rotate_local_y(&mut self, angle: f32)
Rotates this Transform
around its local Y
axis by angle
(in radians).
sourcepub fn rotate_local_z(&mut self, angle: f32)
pub fn rotate_local_z(&mut self, angle: f32)
Rotates this Transform
around its local Z
axis by angle
(in radians).
sourcepub fn translate_around(&mut self, point: Vec3, rotation: Quat)
pub fn translate_around(&mut self, point: Vec3, rotation: Quat)
sourcepub fn rotate_around(&mut self, point: Vec3, rotation: Quat)
pub fn rotate_around(&mut self, point: Vec3, rotation: Quat)
sourcepub fn look_at(&mut self, target: Vec3, up: impl TryInto<Dir3>)
pub fn look_at(&mut self, target: Vec3, up: impl TryInto<Dir3>)
Rotates this Transform
so that Transform::forward
points towards the target
position,
and Transform::up
points towards up
.
In some cases it’s not possible to construct a rotation. Another axis will be picked in those cases:
- if
target
is the same as the transform translation,Vec3::Z
is used instead - if
up
fails converting toDir3
(e.g if it isVec3::ZERO
),Dir3::Y
is used instead - if the resulting forward direction is parallel with
up
, an orthogonal vector is used as the “right” direction
sourcepub fn look_to(&mut self, direction: impl TryInto<Dir3>, up: impl TryInto<Dir3>)
pub fn look_to(&mut self, direction: impl TryInto<Dir3>, up: impl TryInto<Dir3>)
Rotates this Transform
so that Transform::forward
points in the given direction
and Transform::up
points towards up
.
In some cases it’s not possible to construct a rotation. Another axis will be picked in those cases:
- if
direction
fails converting toDir3
(e.g if it isVec3::ZERO
),Dir3::NEG_Z
is used instead - if
up
fails converting toDir3
,Dir3::Y
is used instead - if
direction
is parallel withup
, an orthogonal vector is used as the “right” direction
sourcepub fn align(
&mut self,
main_axis: impl TryInto<Dir3>,
main_direction: impl TryInto<Dir3>,
secondary_axis: impl TryInto<Dir3>,
secondary_direction: impl TryInto<Dir3>
)
pub fn align( &mut self, main_axis: impl TryInto<Dir3>, main_direction: impl TryInto<Dir3>, secondary_axis: impl TryInto<Dir3>, secondary_direction: impl TryInto<Dir3> )
Rotates this Transform
so that the main_axis
vector, reinterpreted in local coordinates, points
in the given main_direction
, while secondary_axis
points towards secondary_direction
.
For example, if a spaceship model has its nose pointing in the X-direction in its own local coordinates
and its dorsal fin pointing in the Y-direction, then align(Dir3::X, v, Dir3::Y, w)
will make the spaceship’s
nose point in the direction of v
, while the dorsal fin does its best to point in the direction w
.
More precisely, the Transform::rotation
produced will be such that:
- applying it to
main_axis
results inmain_direction
- applying it to
secondary_axis
produces a vector that lies in the half-plane generated bymain_direction
andsecondary_direction
(with positive contribution bysecondary_direction
)
Transform::look_to
is recovered, for instance, when main_axis
is Dir3::NEG_Z
(the Transform::forward
direction in the default orientation) and secondary_axis
is Dir3::Y
(the Transform::up
direction in the default
orientation). (Failure cases may differ somewhat.)
In some cases a rotation cannot be constructed. Another axis will be picked in those cases:
- if
main_axis
ormain_direction
fail converting toDir3
(e.g are zero),Dir3::X
takes their place - if
secondary_axis
orsecondary_direction
fail converting,Dir3::Y
takes their place - if
main_axis
is parallel withsecondary_axis
ormain_direction
is parallel withsecondary_direction
, a rotation is constructed which takesmain_axis
tomain_direction
along a great circle, ignoring the secondary counterparts
Example
t1.align(Dir3::X, Dir3::Y, Vec3::new(1., 1., 0.), Dir3::Z);
let main_axis_image = t1.rotation * Dir3::X;
let secondary_axis_image = t1.rotation * Vec3::new(1., 1., 0.);
assert!(main_axis_image.abs_diff_eq(Vec3::Y, 1e-5));
assert!(secondary_axis_image.abs_diff_eq(Vec3::new(0., 1., 1.), 1e-5));
t1.align(Vec3::ZERO, Dir3::Z, Vec3::ZERO, Dir3::X);
t2.align(Dir3::X, Dir3::Z, Dir3::Y, Dir3::X);
assert_eq!(t1.rotation, t2.rotation);
t1.align(Dir3::X, Dir3::Z, Dir3::X, Dir3::Y);
assert_eq!(t1.rotation, Quat::from_rotation_arc(Vec3::X, Vec3::Z));
sourcepub fn mul_transform(&self, transform: Transform) -> Self
pub fn mul_transform(&self, transform: Transform) -> Self
Multiplies self
with transform
component by component, returning the
resulting Transform
sourcepub fn transform_point(&self, point: Vec3) -> Vec3
pub fn transform_point(&self, point: Vec3) -> Vec3
Transforms the given point
, applying scale, rotation and translation.
If this Transform
has a parent, this will transform a point
that is
relative to the parent’s Transform
into one relative to this Transform
.
If this Transform
does not have a parent, this will transform a point
that is in global space into one relative to this Transform
.
If you want to transform a point
in global space to the local space of this Transform
,
consider using GlobalTransform::transform_point()
instead.
Trait Implementations§
source§impl Component for Transform
impl Component for Transform
source§const STORAGE_TYPE: StorageType = bevy_ecs::component::StorageType::Table
const STORAGE_TYPE: StorageType = bevy_ecs::component::StorageType::Table
source§fn register_component_hooks(_hooks: &mut ComponentHooks)
fn register_component_hooks(_hooks: &mut ComponentHooks)
ComponentHooks
.source§impl From<GlobalTransform> for Transform
impl From<GlobalTransform> for Transform
The transform is expected to be non-degenerate and without shearing, or the output will be invalid.
source§fn from(transform: GlobalTransform) -> Self
fn from(transform: GlobalTransform) -> Self
source§impl From<Transform> for GlobalTransform
impl From<Transform> for GlobalTransform
source§impl From<Transform> for TransformBundle
impl From<Transform> for TransformBundle
source§impl FromReflect for Transformwhere
Self: Any + Send + Sync,
Vec3: FromReflect + TypePath + RegisterForReflection,
Quat: FromReflect + TypePath + RegisterForReflection,
impl FromReflect for Transformwhere
Self: Any + Send + Sync,
Vec3: FromReflect + TypePath + RegisterForReflection,
Quat: FromReflect + TypePath + RegisterForReflection,
source§fn from_reflect(reflect: &dyn Reflect) -> Option<Self>
fn from_reflect(reflect: &dyn Reflect) -> Option<Self>
Self
from a reflected value.source§fn take_from_reflect(
reflect: Box<dyn Reflect>
) -> Result<Self, Box<dyn Reflect>>
fn take_from_reflect( reflect: Box<dyn Reflect> ) -> Result<Self, Box<dyn Reflect>>
Self
using,
constructing the value using from_reflect
if that fails. Read moresource§impl GetTypeRegistration for Transformwhere
Self: Any + Send + Sync,
Vec3: FromReflect + TypePath + RegisterForReflection,
Quat: FromReflect + TypePath + RegisterForReflection,
impl GetTypeRegistration for Transformwhere
Self: Any + Send + Sync,
Vec3: FromReflect + TypePath + RegisterForReflection,
Quat: FromReflect + TypePath + RegisterForReflection,
source§fn get_type_registration() -> TypeRegistration
fn get_type_registration() -> TypeRegistration
TypeRegistration
for this type.source§fn register_type_dependencies(registry: &mut TypeRegistry)
fn register_type_dependencies(registry: &mut TypeRegistry)
source§impl Mul<GlobalTransform> for Transform
impl Mul<GlobalTransform> for Transform
§type Output = GlobalTransform
type Output = GlobalTransform
*
operator.source§impl Mul<Transform> for GlobalTransform
impl Mul<Transform> for GlobalTransform
source§impl PartialEq for Transform
impl PartialEq for Transform
source§impl Reflect for Transformwhere
Self: Any + Send + Sync,
Vec3: FromReflect + TypePath + RegisterForReflection,
Quat: FromReflect + TypePath + RegisterForReflection,
impl Reflect for Transformwhere
Self: Any + Send + Sync,
Vec3: FromReflect + TypePath + RegisterForReflection,
Quat: FromReflect + TypePath + RegisterForReflection,
source§fn get_represented_type_info(&self) -> Option<&'static TypeInfo>
fn get_represented_type_info(&self) -> Option<&'static TypeInfo>
source§fn as_any_mut(&mut self) -> &mut dyn Any
fn as_any_mut(&mut self) -> &mut dyn Any
&mut dyn Any
.source§fn into_reflect(self: Box<Self>) -> Box<dyn Reflect>
fn into_reflect(self: Box<Self>) -> Box<dyn Reflect>
source§fn as_reflect(&self) -> &dyn Reflect
fn as_reflect(&self) -> &dyn Reflect
source§fn as_reflect_mut(&mut self) -> &mut dyn Reflect
fn as_reflect_mut(&mut self) -> &mut dyn Reflect
source§fn clone_value(&self) -> Box<dyn Reflect>
fn clone_value(&self) -> Box<dyn Reflect>
Reflect
trait object. Read moresource§fn set(&mut self, value: Box<dyn Reflect>) -> Result<(), Box<dyn Reflect>>
fn set(&mut self, value: Box<dyn Reflect>) -> Result<(), Box<dyn Reflect>>
source§fn reflect_kind(&self) -> ReflectKind
fn reflect_kind(&self) -> ReflectKind
source§fn reflect_ref(&self) -> ReflectRef<'_>
fn reflect_ref(&self) -> ReflectRef<'_>
source§fn reflect_mut(&mut self) -> ReflectMut<'_>
fn reflect_mut(&mut self) -> ReflectMut<'_>
source§fn reflect_owned(self: Box<Self>) -> ReflectOwned
fn reflect_owned(self: Box<Self>) -> ReflectOwned
source§fn reflect_partial_eq(&self, value: &dyn Reflect) -> Option<bool>
fn reflect_partial_eq(&self, value: &dyn Reflect) -> Option<bool>
source§fn apply(&mut self, value: &(dyn Reflect + 'static))
fn apply(&mut self, value: &(dyn Reflect + 'static))
source§fn reflect_hash(&self) -> Option<u64>
fn reflect_hash(&self) -> Option<u64>
source§fn debug(&self, f: &mut Formatter<'_>) -> Result<(), Error>
fn debug(&self, f: &mut Formatter<'_>) -> Result<(), Error>
source§fn serializable(&self) -> Option<Serializable<'_>>
fn serializable(&self) -> Option<Serializable<'_>>
source§fn is_dynamic(&self) -> bool
fn is_dynamic(&self) -> bool
source§impl Struct for Transformwhere
Self: Any + Send + Sync,
Vec3: FromReflect + TypePath + RegisterForReflection,
Quat: FromReflect + TypePath + RegisterForReflection,
impl Struct for Transformwhere
Self: Any + Send + Sync,
Vec3: FromReflect + TypePath + RegisterForReflection,
Quat: FromReflect + TypePath + RegisterForReflection,
source§fn field(&self, name: &str) -> Option<&dyn Reflect>
fn field(&self, name: &str) -> Option<&dyn Reflect>
name
as a &dyn Reflect
.source§fn field_mut(&mut self, name: &str) -> Option<&mut dyn Reflect>
fn field_mut(&mut self, name: &str) -> Option<&mut dyn Reflect>
name
as a
&mut dyn Reflect
.source§fn field_at(&self, index: usize) -> Option<&dyn Reflect>
fn field_at(&self, index: usize) -> Option<&dyn Reflect>
index
as a
&dyn Reflect
.source§fn field_at_mut(&mut self, index: usize) -> Option<&mut dyn Reflect>
fn field_at_mut(&mut self, index: usize) -> Option<&mut dyn Reflect>
index
as a &mut dyn Reflect
.source§fn name_at(&self, index: usize) -> Option<&str>
fn name_at(&self, index: usize) -> Option<&str>
index
.source§fn iter_fields(&self) -> FieldIter<'_>
fn iter_fields(&self) -> FieldIter<'_>
source§fn clone_dynamic(&self) -> DynamicStruct
fn clone_dynamic(&self) -> DynamicStruct
DynamicStruct
.source§impl TransformPoint for Transform
impl TransformPoint for Transform
source§impl TypePath for Transform
impl TypePath for Transform
source§fn type_path() -> &'static str
fn type_path() -> &'static str
source§fn short_type_path() -> &'static str
fn short_type_path() -> &'static str
source§fn type_ident() -> Option<&'static str>
fn type_ident() -> Option<&'static str>
source§fn crate_name() -> Option<&'static str>
fn crate_name() -> Option<&'static str>
source§impl Typed for Transformwhere
Self: Any + Send + Sync,
Vec3: FromReflect + TypePath + RegisterForReflection,
Quat: FromReflect + TypePath + RegisterForReflection,
impl Typed for Transformwhere
Self: Any + Send + Sync,
Vec3: FromReflect + TypePath + RegisterForReflection,
Quat: FromReflect + TypePath + RegisterForReflection,
impl Copy for Transform
impl StructuralPartialEq for Transform
Auto Trait Implementations§
impl Freeze for Transform
impl RefUnwindSafe for Transform
impl Send for Transform
impl Sync for Transform
impl Unpin for Transform
impl UnwindSafe for Transform
Blanket Implementations§
source§impl<T> BorrowMut<T> for Twhere
T: ?Sized,
impl<T> BorrowMut<T> for Twhere
T: ?Sized,
source§fn borrow_mut(&mut self) -> &mut T
fn borrow_mut(&mut self) -> &mut T
source§impl<C> Bundle for Cwhere
C: Component,
impl<C> Bundle for Cwhere
C: Component,
fn component_ids( components: &mut Components, storages: &mut Storages, ids: &mut impl FnMut(ComponentId) )
unsafe fn from_components<T, F>(ctx: &mut T, func: &mut F) -> C
source§fn get_component_ids(
components: &Components,
ids: &mut impl FnMut(Option<ComponentId>)
)
fn get_component_ids( components: &Components, ids: &mut impl FnMut(Option<ComponentId>) )
source§impl<T> Downcast for Twhere
T: Any,
impl<T> Downcast for Twhere
T: Any,
source§fn into_any(self: Box<T>) -> Box<dyn Any>
fn into_any(self: Box<T>) -> Box<dyn Any>
Box<dyn Trait>
(where Trait: Downcast
) to Box<dyn Any>
. Box<dyn Any>
can
then be further downcast
into Box<ConcreteType>
where ConcreteType
implements Trait
.source§fn into_any_rc(self: Rc<T>) -> Rc<dyn Any>
fn into_any_rc(self: Rc<T>) -> Rc<dyn Any>
Rc<Trait>
(where Trait: Downcast
) to Rc<Any>
. Rc<Any>
can then be
further downcast
into Rc<ConcreteType>
where ConcreteType
implements Trait
.source§fn as_any(&self) -> &(dyn Any + 'static)
fn as_any(&self) -> &(dyn Any + 'static)
&Trait
(where Trait: Downcast
) to &Any
. This is needed since Rust cannot
generate &Any
’s vtable from &Trait
’s.source§fn as_any_mut(&mut self) -> &mut (dyn Any + 'static)
fn as_any_mut(&mut self) -> &mut (dyn Any + 'static)
&mut Trait
(where Trait: Downcast
) to &Any
. This is needed since Rust cannot
generate &mut Any
’s vtable from &mut Trait
’s.source§impl<T> DowncastSync for T
impl<T> DowncastSync for T
source§impl<C> DynamicBundle for Cwhere
C: Component,
impl<C> DynamicBundle for Cwhere
C: Component,
fn get_components(self, func: &mut impl FnMut(StorageType, OwningPtr<'_>))
source§impl<T> DynamicTypePath for Twhere
T: TypePath,
impl<T> DynamicTypePath for Twhere
T: TypePath,
source§fn reflect_type_path(&self) -> &str
fn reflect_type_path(&self) -> &str
TypePath::type_path
.source§fn reflect_short_type_path(&self) -> &str
fn reflect_short_type_path(&self) -> &str
source§fn reflect_type_ident(&self) -> Option<&str>
fn reflect_type_ident(&self) -> Option<&str>
TypePath::type_ident
.source§fn reflect_crate_name(&self) -> Option<&str>
fn reflect_crate_name(&self) -> Option<&str>
TypePath::crate_name
.source§fn reflect_module_path(&self) -> Option<&str>
fn reflect_module_path(&self) -> Option<&str>
source§impl<T> FromWorld for Twhere
T: Default,
impl<T> FromWorld for Twhere
T: Default,
source§fn from_world(_world: &mut World) -> T
fn from_world(_world: &mut World) -> T
Self
using data from the given World
.source§impl<S> GetField for Swhere
S: Struct,
impl<S> GetField for Swhere
S: Struct,
source§impl<T> GetPath for T
impl<T> GetPath for T
source§fn reflect_path<'p>(
&self,
path: impl ReflectPath<'p>
) -> Result<&(dyn Reflect + 'static), ReflectPathError<'p>>
fn reflect_path<'p>( &self, path: impl ReflectPath<'p> ) -> Result<&(dyn Reflect + 'static), ReflectPathError<'p>>
path
. Read moresource§fn reflect_path_mut<'p>(
&mut self,
path: impl ReflectPath<'p>
) -> Result<&mut (dyn Reflect + 'static), ReflectPathError<'p>>
fn reflect_path_mut<'p>( &mut self, path: impl ReflectPath<'p> ) -> Result<&mut (dyn Reflect + 'static), ReflectPathError<'p>>
path
. Read moresource§fn path<'p, T>(
&self,
path: impl ReflectPath<'p>
) -> Result<&T, ReflectPathError<'p>>where
T: Reflect,
fn path<'p, T>(
&self,
path: impl ReflectPath<'p>
) -> Result<&T, ReflectPathError<'p>>where
T: Reflect,
path
. Read moresource§fn path_mut<'p, T>(
&mut self,
path: impl ReflectPath<'p>
) -> Result<&mut T, ReflectPathError<'p>>where
T: Reflect,
fn path_mut<'p, T>(
&mut self,
path: impl ReflectPath<'p>
) -> Result<&mut T, ReflectPathError<'p>>where
T: Reflect,
path
. Read more