FyroxEngine/Fyrox
1
0
Fork 0
mirror of https://github.com/FyroxEngine/Fyrox.git synced 2026-10-12 02:02:20 +00:00
Code Issues Packages Projects Releases Wiki Activity

renamed methods with confusing naming + docs

Browse Source
This commit is contained in:
Dmitry Stepanov
2026-05-16 19:31:41 +03:00
parent e96d96544f
commit 93d4920477
23 changed files with 191 additions and 188 deletions
Download Patch File Download Diff File Expand all files Collapse all files
editor/src/plugins/absm/mod.rs
+6 -6
View File
@@ -148,7 +148,7 @@ where
.try_get_node_mut(absm_handle)
.ok()
.and_then(|n| {
n.as_reflect_mut_direct()
n.inner_mut_direct()
.first_field_mut::<InheritableVariable<Machine<Handle<N>>>>()
})
.map(|v| v.get_value_mut_silent())
@@ -167,13 +167,13 @@ where
let absm = graph.try_get_node(absm_handle).ok()?;
let animation_player_handle = **absm
.as_reflect_direct()
.inner_ref_direct()
.first_field_ref::<InheritableVariable<Handle<AnimationPlayer>>>()?;
let animation_player = graph.try_get_mut(animation_player_handle).ok()?;
let container = animation_player
.as_reflect_mut_direct()
.inner_mut_direct()
.first_field_mut::<InheritableVariable<AnimationContainer<Handle<N>>>>()?;
Some((animation_player_handle, container.get_value_mut_silent()))
@@ -188,7 +188,7 @@ where
.try_get_node(absm_handle)
.ok()
.and_then(|n| {
n.as_reflect_direct()
n.inner_ref_direct()
.first_field_ref::<InheritableVariable<Machine<Handle<N>>>>()
})
.map(|v| v.get_value_ref())
@@ -207,13 +207,13 @@ where
let absm = graph.try_get_node(absm_handle).ok()?;
let animation_player_handle = **absm
.as_reflect_direct()
.inner_ref_direct()
.first_field_ref::<InheritableVariable<Handle<AnimationPlayer>>>()?;
let animation_player = graph.try_get(animation_player_handle).ok()?;
let container = animation_player
.as_reflect_direct()
.inner_ref_direct()
.first_field_ref::<InheritableVariable<AnimationContainer<Handle<N>>>>()?;
Some((animation_player_handle, &**container))
editor/src/plugins/animation/track.rs
+5 -5
View File
@@ -869,7 +869,7 @@ impl TrackList {
}
ValueBinding::Property { name, .. } => node_ref.find_field(name, &mut |value| {
if let Some(value) = value {
value.as_reflect(&mut |reflect| {
value.inner_ref(&mut |reflect| {
let curves = track.data_container().curves_ref();
if curves.len() == 1 {
if let Some(scalar) = any_scalar_to_f32(reflect) {
@@ -1105,7 +1105,7 @@ impl TrackList {
Ok(property) => {
let mut property_type = TypeId::of::<u32>();
property
.as_reflect(&mut |reflect| property_type = reflect.type_id());
.inner_ref(&mut |reflect| property_type = reflect.type_id());
let types = type_id_to_supported_type(property_type);
@@ -1279,7 +1279,7 @@ impl TrackList {
{
let mut descriptors = Vec::new();
if let Ok(node) = graph.try_get_node(node) {
node.as_reflect(&mut |node| {
node.inner_ref(&mut |node| {
descriptors = object_to_property_tree("", node, &mut |field: &FieldRef| {
let type_id = field.value.field_value_as_reflect().type_id();
type_id != TypeId::of::<TextureBytes>()
@@ -1411,7 +1411,7 @@ impl TrackList {
node.resolve_path(&desc.path, &mut |result| match result {
Ok(property) => {
let mut property_type = TypeId::of::<u32>();
property.as_reflect(&mut |reflect| property_type = reflect.type_id());
property.inner_ref(&mut |reflect| property_type = reflect.type_id());
let types = type_id_to_supported_type(property_type);
@@ -1714,7 +1714,7 @@ impl TrackList {
target.resolve_path(name, &mut |result| match result {
Ok(value) => {
let mut property_type = TypeId::of::<u32>();
value.as_reflect(&mut |reflect| property_type = reflect.type_id());
value.inner_ref(&mut |reflect| property_type = reflect.type_id());
if let Some((_, type_)) = type_id_to_supported_type(property_type) {
if *value_type != type_ {
editor/src/plugins/inspector/mod.rs
+2 -2
View File
@@ -494,8 +494,8 @@ impl EditorPlugin for InspectorPlugin {
can_clone = property.try_clone_box().is_some();
if let Some(value) = self.clipboard.as_ref() {
value.as_reflect(&mut |reflect| {
property.as_reflect(&mut |property| {
value.inner_ref(&mut |reflect| {
property.inner_ref(&mut |property| {
can_paste =
property.type_id() == reflect.type_id();
})
editor/src/scene/commands/mod.rs
+1 -1
View File
@@ -338,7 +338,7 @@ impl CommandTrait for RevertSceneNodePropertyCommand {
// If the property was modified, then simply set it to previous value to make it modified again.
if let Some(old_value) = self.value.take() {
let mut old_value = Some(old_value);
context.scene.graph[self.handle].as_reflect_mut(&mut |node| {
context.scene.graph[self.handle].inner_mut(&mut |node| {
node.set_field_by_path(&self.path, old_value.take().unwrap(), &mut |result| {
if result.is_err() {
Log::err(format!(
editor/src/ui_scene/commands/widget.rs
+1 -1
View File
@@ -108,7 +108,7 @@ impl CommandTrait for RevertWidgetPropertyCommand {
.get_mut::<UiSceneContext>()
.ui
.node_mut(self.handle)
.as_reflect_mut(&mut |node| {
.inner_mut(&mut |node| {
node.set_field_by_path(&self.path, old_value.take().unwrap(), &mut |result| {
if result.is_err() {
Log::err(format!(
fyrox-animation/src/value.rs
+2 -2
View File
@@ -405,11 +405,11 @@ impl BoundValue {
property_path: &str,
value_type: ValueType,
) {
object.as_reflect_mut(&mut |object_ref| {
object.inner_mut(&mut |object_ref| {
object_ref.resolve_path_mut(property_path, &mut |result| match result {
Ok(property) => {
let mut applied = false;
property.as_reflect_mut(&mut |reflect| {
property.inner_mut(&mut |reflect| {
applied = self.value.apply_to_any(reflect, value_type);
});
if applied {
fyrox-core-derive/src/reflect.rs
+5 -5
View File
@@ -477,7 +477,7 @@ fn gen_impl(
#metadata_mut
}
fn into_inner_reflect(self: Box<Self>) -> Box<dyn Reflect> {
fn into_inner(self: Box<Self>) -> Box<dyn Reflect> {
self
}
@@ -504,19 +504,19 @@ fn gen_impl(
#set_field
fn as_reflect_direct(&self) -> &dyn Reflect {
fn inner_ref_direct(&self) -> &dyn Reflect {
self
}
fn as_reflect(&self, func: &mut dyn FnMut(&dyn Reflect)) {
fn inner_ref(&self, func: &mut dyn FnMut(&dyn Reflect)) {
func(self as &dyn Reflect)
}
fn as_reflect_mut_direct(&mut self) -> &mut dyn Reflect {
fn inner_mut_direct(&mut self) -> &mut dyn Reflect {
self
}
fn as_reflect_mut(&mut self, func: &mut dyn FnMut(&mut dyn Reflect)) {
fn inner_mut(&mut self, func: &mut dyn FnMut(&mut dyn Reflect)) {
func(self as &mut dyn Reflect)
}
fyrox-core/src/dyntype.rs
+5 -5
View File
@@ -201,15 +201,15 @@ impl Reflect for DynTypeWrapper {
}])
}
fn into_inner_reflect(self: Box<Self>) -> Box<dyn Reflect> {
fn into_inner(self: Box<Self>) -> Box<dyn Reflect> {
self
}
fn as_reflect(&self, func: &mut dyn FnMut(&dyn Reflect)) {
fn inner_ref(&self, func: &mut dyn FnMut(&dyn Reflect)) {
func(self)
}
fn as_reflect_mut(&mut self, func: &mut dyn FnMut(&mut dyn Reflect)) {
fn inner_mut(&mut self, func: &mut dyn FnMut(&mut dyn Reflect)) {
func(self)
}
@@ -244,11 +244,11 @@ impl Reflect for DynTypeWrapper {
}
}
fn as_reflect_direct(&self) -> &dyn Reflect {
fn inner_ref_direct(&self) -> &dyn Reflect {
self
}
fn as_reflect_mut_direct(&mut self) -> &mut dyn Reflect {
fn inner_mut_direct(&mut self) -> &mut dyn Reflect {
self
}
}
fyrox-core/src/pool/handle.rs
+5 -5
View File
@@ -163,15 +163,15 @@ impl<T: Reflect> Reflect for Handle<T> {
])
}
fn into_inner_reflect(self: Box<Self>) -> Box<dyn Reflect> {
fn into_inner(self: Box<Self>) -> Box<dyn Reflect> {
self
}
fn as_reflect(&self, func: &mut dyn FnMut(&dyn Reflect)) {
fn inner_ref(&self, func: &mut dyn FnMut(&dyn Reflect)) {
func(self)
}
fn as_reflect_mut(&mut self, func: &mut dyn FnMut(&mut dyn Reflect)) {
fn inner_mut(&mut self, func: &mut dyn FnMut(&mut dyn Reflect)) {
func(self)
}
@@ -220,11 +220,11 @@ impl<T: Reflect> Reflect for Handle<T> {
}
}
fn as_reflect_direct(&self) -> &dyn Reflect {
fn inner_ref_direct(&self) -> &dyn Reflect {
self
}
fn as_reflect_mut_direct(&mut self) -> &mut dyn Reflect {
fn inner_mut_direct(&mut self) -> &mut dyn Reflect {
self
}
}
fyrox-core/src/pool/mod.rs
+5 -5
View File
@@ -177,25 +177,25 @@ where
}
#[inline]
fn into_inner_reflect(self: Box<Self>) -> Box<dyn Reflect> {
fn into_inner(self: Box<Self>) -> Box<dyn Reflect> {
self
}
fn as_reflect_direct(&self) -> &dyn Reflect {
fn inner_ref_direct(&self) -> &dyn Reflect {
self
}
fn as_reflect_mut_direct(&mut self) -> &mut dyn Reflect {
fn inner_mut_direct(&mut self) -> &mut dyn Reflect {
self
}
#[inline]
fn as_reflect(&self, func: &mut dyn FnMut(&dyn Reflect)) {
fn inner_ref(&self, func: &mut dyn FnMut(&dyn Reflect)) {
func(self)
}
#[inline]
fn as_reflect_mut(&mut self, func: &mut dyn FnMut(&mut dyn Reflect)) {
fn inner_mut(&mut self, func: &mut dyn FnMut(&mut dyn Reflect)) {
func(self)
}
fyrox-core/src/reflect/impls.rs
+16 -12
View File
@@ -163,27 +163,27 @@ macro_rules! impl_reflect_inner_mutability {
guard.fields_mut(func)
}
fn into_inner_reflect($self: Box<Self>) -> Box<dyn Reflect> {
fn into_inner($self: Box<Self>) -> Box<dyn Reflect> {
let inner = $into_inner;
Box::new(inner)
}
fn as_reflect(&$self, func: &mut dyn FnMut(&dyn Reflect)) {
fn inner_ref(&$self, func: &mut dyn FnMut(&dyn Reflect)) {
let guard = $acquire_lock_guard;
(*guard).as_reflect(func)
(*guard).inner_ref(func)
}
fn as_reflect_mut(&mut $self, func: &mut dyn FnMut(&mut dyn Reflect)) {
fn inner_mut(&mut $self, func: &mut dyn FnMut(&mut dyn Reflect)) {
let mut guard = $acquire_lock_guard;
(*guard).as_reflect_mut(func)
(*guard).inner_mut(func)
}
fn as_reflect_direct(&self) -> &dyn $crate::reflect::Reflect {
fn inner_ref_direct(&self) -> &dyn $crate::reflect::Reflect {
// xxx_direct methods cannot hold the lock, so return self here.
self
}
fn as_reflect_mut_direct(&mut self) -> &mut dyn $crate::reflect::Reflect {
fn inner_mut_direct(&mut self) -> &mut dyn $crate::reflect::Reflect {
// xxx_direct methods cannot hold the lock, so return self here.
self
}
@@ -270,23 +270,27 @@ macro_rules! impl_reflect_inner_mutability {
}
impl<T: Reflect + Clone> Reflect for parking_lot::Mutex<T> {
impl_reflect_inner_mutability!(self, { self.safe_lock() }, { self.into_inner() });
impl_reflect_inner_mutability!(self, { self.safe_lock() }, {
parking_lot::Mutex::into_inner(*self)
});
}
impl<T: Reflect + Clone> Reflect for parking_lot::RwLock<T> {
impl_reflect_inner_mutability!(self, { self.write() }, { self.into_inner() });
impl_reflect_inner_mutability!(self, { self.write() }, {
parking_lot::RwLock::into_inner(*self)
});
}
#[allow(clippy::mut_mutex_lock)]
impl<T: Reflect + Clone> Reflect for std::sync::Mutex<T> {
impl_reflect_inner_mutability!(self, { self.safe_lock().unwrap() }, {
self.into_inner().unwrap()
std::sync::Mutex::into_inner(*self).unwrap()
});
}
impl<T: Reflect + Clone> Reflect for std::sync::RwLock<T> {
impl_reflect_inner_mutability!(self, { self.write().unwrap() }, {
self.into_inner().unwrap()
std::sync::RwLock::into_inner(*self).unwrap()
});
}
@@ -325,7 +329,7 @@ impl<T: Reflect + Clone> Reflect for Arc<parking_lot::RwLock<T>> {
}
impl<T: Reflect + Clone> Reflect for RefCell<T> {
impl_reflect_inner_mutability!(self, { self.borrow_mut() }, { self.into_inner() });
impl_reflect_inner_mutability!(self, { self.borrow_mut() }, { RefCell::into_inner(*self) });
}
impl<T: Reflect + Clone> Reflect for Rc<RefCell<T>> {
fyrox-core/src/reflect/macros.rs
+24 -24
View File
@@ -45,12 +45,12 @@ macro_rules! newtype_reflect {
self.0.as_any_mut(func)
}
fn as_reflect(&self, func: &mut dyn FnMut(&dyn $crate::reflect::Reflect)) {
self.0.as_reflect(func)
fn inner_ref(&self, func: &mut dyn FnMut(&dyn $crate::reflect::Reflect)) {
self.0.inner_ref(func)
}
fn as_reflect_mut(&mut self, func: &mut dyn FnMut(&mut dyn $crate::reflect::Reflect)) {
self.0.as_reflect_mut(func)
fn inner_mut(&mut self, func: &mut dyn FnMut(&mut dyn $crate::reflect::Reflect)) {
self.0.inner_mut(func)
}
fn set(
@@ -173,24 +173,24 @@ macro_rules! delegate_reflect {
self.deref_mut().fields_mut(func)
}
fn into_inner_reflect(self: Box<Self>) -> Box<dyn Reflect> {
(*self).into_inner_reflect()
fn into_inner(self: Box<Self>) -> Box<dyn Reflect> {
(*self).into_inner()
}
fn as_reflect(&self, func: &mut dyn FnMut(&dyn $crate::reflect::Reflect)) {
self.deref().as_reflect(func)
fn inner_ref(&self, func: &mut dyn FnMut(&dyn $crate::reflect::Reflect)) {
self.deref().inner_ref(func)
}
fn as_reflect_mut(&mut self, func: &mut dyn FnMut(&mut dyn $crate::reflect::Reflect)) {
self.deref_mut().as_reflect_mut(func)
fn inner_mut(&mut self, func: &mut dyn FnMut(&mut dyn $crate::reflect::Reflect)) {
self.deref_mut().inner_mut(func)
}
fn as_reflect_direct(&self) -> &dyn $crate::reflect::Reflect {
self.deref().as_reflect_direct()
fn inner_ref_direct(&self) -> &dyn $crate::reflect::Reflect {
self.deref().inner_ref_direct()
}
fn as_reflect_mut_direct(&mut self) -> &mut dyn $crate::reflect::Reflect {
self.deref_mut().as_reflect_mut_direct()
fn inner_mut_direct(&mut self) -> &mut dyn $crate::reflect::Reflect {
self.deref_mut().inner_mut_direct()
}
fn field_direct_ref(&self, index: usize) -> Option<FieldRef> {
@@ -318,23 +318,23 @@ macro_rules! blank_reflect {
func(&mut [])
}
fn into_inner_reflect(self: Box<Self>) -> Box<dyn Reflect> {
fn into_inner(self: Box<Self>) -> Box<dyn Reflect> {
self
}
fn as_reflect(&self, func: &mut dyn FnMut(&dyn $crate::reflect::Reflect)) {
fn inner_ref(&self, func: &mut dyn FnMut(&dyn $crate::reflect::Reflect)) {
func(self)
}
fn as_reflect_mut(&mut self, func: &mut dyn FnMut(&mut dyn $crate::reflect::Reflect)) {
fn inner_mut(&mut self, func: &mut dyn FnMut(&mut dyn $crate::reflect::Reflect)) {
func(self)
}
fn as_reflect_direct(&self) -> &dyn $crate::reflect::Reflect {
fn inner_ref_direct(&self) -> &dyn $crate::reflect::Reflect {
self
}
fn as_reflect_mut_direct(&mut self) -> &mut dyn $crate::reflect::Reflect {
fn inner_mut_direct(&mut self) -> &mut dyn $crate::reflect::Reflect {
self
}
@@ -402,15 +402,15 @@ macro_rules! blank_reflect_ref {
func(&mut [])
}
fn into_inner_reflect(self: Box<Self>) -> Box<dyn Reflect> {
fn into_inner(self: Box<Self>) -> Box<dyn Reflect> {
self
}
fn as_reflect(&self, func: &mut dyn FnMut(&dyn $crate::reflect::Reflect)) {
fn inner_ref(&self, func: &mut dyn FnMut(&dyn $crate::reflect::Reflect)) {
func(self)
}
fn as_reflect_mut(&mut self, func: &mut dyn FnMut(&mut dyn $crate::reflect::Reflect)) {
fn inner_mut(&mut self, func: &mut dyn FnMut(&mut dyn $crate::reflect::Reflect)) {
func(self)
}
@@ -446,11 +446,11 @@ macro_rules! blank_reflect_ref {
Ok(Box::new(this))
}
fn as_reflect_direct(&self) -> &dyn $crate::reflect::Reflect {
fn inner_ref_direct(&self) -> &dyn $crate::reflect::Reflect {
self
}
fn as_reflect_mut_direct(&mut self) -> &mut dyn $crate::reflect::Reflect {
fn inner_mut_direct(&mut self) -> &mut dyn $crate::reflect::Reflect {
self
}
};
fyrox-core/src/reflect/mod.rs
+24 -19
View File
@@ -155,27 +155,34 @@ pub trait Reflect: Any + Debug {
Self: Sized;
/// Returns the info about the type that implements this trait. The result of the call of this
/// method can be different from the call of [`Self::type_info`].
/// method can be different from the call of [`Self::type_info`]. This may happen if the type
/// that implements the trait is a wrapper type.
fn type_info_ref(&self) -> TypeInfo;
/// Tries to clone the object and return it as a boxed trait object. This method can return
/// [`None`] for non-cloneable objects.
fn try_clone_box(&self) -> Option<Box<dyn Reflect>>;
/// Calls the given closure with the reference to a slice that contains description for all
/// fields in the object.
fn fields_ref(&self, func: &mut dyn FnMut(&[FieldRef]));
/// Calls the given closure with the reference to a slice that contains description for all
/// fields in the object.
fn fields_mut(&mut self, func: &mut dyn FnMut(&mut [FieldMut]));
/// Extracts the wrapped value as `Box<dyn Reflect>` and returns it to the caller. This method
/// is intended to be used for wrapper structures only. Any other type should return `self` as
/// usual.
fn into_inner_reflect(self: Box<Self>) -> Box<dyn Reflect>;
fn into_inner(self: Box<Self>) -> Box<dyn Reflect>;
fn as_reflect_direct(&self) -> &dyn Reflect;
fn inner_ref_direct(&self) -> &dyn Reflect;
fn as_reflect_mut_direct(&mut self) -> &mut dyn Reflect;
fn inner_mut_direct(&mut self) -> &mut dyn Reflect;
fn as_reflect(&self, func: &mut dyn FnMut(&dyn Reflect));
fn inner_ref(&self, func: &mut dyn FnMut(&dyn Reflect));
fn as_reflect_mut(&mut self, func: &mut dyn FnMut(&mut dyn Reflect));
fn inner_mut(&mut self, func: &mut dyn FnMut(&mut dyn Reflect));
fn set(&mut self, value: Box<dyn Reflect>) -> Result<Box<dyn Reflect>, Box<dyn Reflect>>;
@@ -304,9 +311,7 @@ pub trait Reflect: Any + Debug {
impl dyn Reflect {
pub fn downcast<T: Reflect>(self: Box<dyn Reflect>) -> Result<Box<T>, Box<dyn Reflect>> {
if self.is::<T>() {
Ok((self.into_inner_reflect() as Box<dyn Any>)
.downcast()
.unwrap())
Ok((self.into_inner() as Box<dyn Any>).downcast().unwrap())
} else {
Err(self)
}
@@ -323,22 +328,22 @@ impl dyn Reflect {
#[inline]
pub fn downcast_ref<T: Reflect>(&self, func: &mut dyn FnMut(Option<&T>)) {
self.as_reflect(&mut |reflect| func((reflect as &dyn Any).downcast_ref::<T>()))
self.inner_ref(&mut |reflect| func((reflect as &dyn Any).downcast_ref::<T>()))
}
#[inline]
pub fn downcast_mut<T: Reflect>(&mut self, func: &mut dyn FnMut(Option<&mut T>)) {
self.as_reflect_mut(&mut |reflect| func((reflect as &mut dyn Any).downcast_mut::<T>()))
self.inner_mut(&mut |reflect| func((reflect as &mut dyn Any).downcast_mut::<T>()))
}
/// Tries to find the first field of the given type. This method internally uses
/// [`Reflect::field_direct_ref`] with all of its limitations.
#[inline]
pub fn first_field_ref<T: Reflect>(&self) -> Option<&T> {
let count = self.as_reflect_direct().fields_count();
let count = self.inner_ref_direct().fields_count();
for i in 0..count {
if let Some(field) = self.as_reflect_direct().field_direct_ref(i) {
if let Some(field) = self.inner_ref_direct().field_direct_ref(i) {
if let Some(typed_field) = (field.value as &dyn Any).downcast_ref::<T>() {
return Some(typed_field);
}
@@ -352,7 +357,7 @@ impl dyn Reflect {
/// [`Reflect::field_direct_ref`] with all of its limitations.
#[inline]
pub fn first_field_mut<T: Reflect>(&mut self) -> Option<&mut T> {
let count = self.as_reflect_direct().fields_count();
let count = self.inner_ref_direct().fields_count();
for i in 0..count {
// SAFETY: Current implementation of borrow checker is just dumb. When a reborrow of self
@@ -360,7 +365,7 @@ impl dyn Reflect {
// This way the returned reference has a different lifetime than in the method definition.
// The following unsafe block reborrows self with the correct lifetime, while the initial
// reference is not used so this is absolutely safe.
let this = unsafe { &mut *(self as *mut Self) }.as_reflect_mut_direct();
let this = unsafe { &mut *(self as *mut Self) }.inner_mut_direct();
if let Some(field) = this.field_direct_mut(i) {
if let Some(typed_field) = (field.value as &mut dyn Any).downcast_mut::<T>() {
return Some(typed_field);
@@ -374,7 +379,7 @@ impl dyn Reflect {
/// Tries to downcast self to the specified type, or if it is not possible, tries to find a
/// field of the specified type.
pub fn self_or_field_ref<T: Reflect>(&self) -> Option<&T> {
if let Some(value) = (self.as_reflect_direct() as &dyn Any).downcast_ref::<T>() {
if let Some(value) = (self.inner_ref_direct() as &dyn Any).downcast_ref::<T>() {
Some(value)
} else {
self.first_field_ref()
@@ -386,7 +391,7 @@ impl dyn Reflect {
pub fn self_or_field_mut<T: Reflect>(&mut self) -> Option<&mut T> {
// SAFETY: See the comment in `first_field_mut_of_type` method.
let this = unsafe { &mut *(self as *mut Self) };
if let Some(value) = (self.as_reflect_mut_direct() as &mut dyn Any).downcast_mut::<T>() {
if let Some(value) = (self.inner_mut_direct() as &mut dyn Any).downcast_mut::<T>() {
Some(value)
} else {
this.first_field_mut()
@@ -792,7 +797,7 @@ impl<R: Reflect> GetField for R {
self.find_field(name, &mut |opt_field| match opt_field {
None => func(None),
Some(field) => {
field.as_reflect(&mut |reflect| func((reflect as &dyn Any).downcast_ref()))
field.inner_ref(&mut |reflect| func((reflect as &dyn Any).downcast_ref()))
}
})
}
@@ -801,7 +806,7 @@ impl<R: Reflect> GetField for R {
self.find_field_mut(name, &mut |opt_field| match opt_field {
None => func(None),
Some(field) => {
field.as_reflect_mut(&mut |reflect| func((reflect as &mut dyn Any).downcast_mut()))
field.inner_mut(&mut |reflect| func((reflect as &mut dyn Any).downcast_mut()))
}
})
}
fyrox-core/src/variable.rs
+11 -11
View File
@@ -439,18 +439,18 @@ where
}
#[inline]
fn into_inner_reflect(self: Box<Self>) -> Box<dyn Reflect> {
Box::new(self.value).into_inner_reflect()
fn into_inner(self: Box<Self>) -> Box<dyn Reflect> {
Box::new(self.value).into_inner()
}
#[inline]
fn as_reflect(&self, func: &mut dyn FnMut(&dyn Reflect)) {
self.value.as_reflect(func)
fn inner_ref(&self, func: &mut dyn FnMut(&dyn Reflect)) {
self.value.inner_ref(func)
}
#[inline]
fn as_reflect_mut(&mut self, func: &mut dyn FnMut(&mut dyn Reflect)) {
self.value.as_reflect_mut(func)
fn inner_mut(&mut self, func: &mut dyn FnMut(&mut dyn Reflect)) {
self.value.inner_mut(func)
}
#[inline]
@@ -535,15 +535,15 @@ where
}
#[inline]
fn as_reflect_direct(&self) -> &dyn Reflect {
self.value.as_reflect_direct()
fn inner_ref_direct(&self) -> &dyn Reflect {
self.value.inner_ref_direct()
}
#[inline]
fn as_reflect_mut_direct(&mut self) -> &mut dyn Reflect {
fn inner_mut_direct(&mut self) -> &mut dyn Reflect {
// Any modifications inside of inheritable lists must mark the variable as modified.
self.mark_modified_and_need_sync();
self.value.as_reflect_mut_direct()
self.value.inner_mut_direct()
}
}
@@ -608,7 +608,7 @@ where
#[inline]
fn value_equals(&self, other: &dyn ReflectInheritableVariable) -> bool {
let mut output_result = false;
other.as_reflect(&mut |reflect| {
other.inner_ref(&mut |reflect| {
reflect.downcast_ref::<T>(&mut |result| {
output_result = match result {
Some(other) => &self.value == other,
fyrox-graph/src/lib.rs
+22 -24
View File
@@ -202,7 +202,7 @@ where
#[inline]
pub fn remap_handles(&self, node: &mut N, ignored_types: &[TypeId]) {
let name = node.name().to_string();
node.as_reflect_mut(&mut |node| self.remap_handles_any(node, &name, ignored_types));
node.inner_mut(&mut |node| self.remap_handles_any(node, &name, ignored_types));
}
pub fn remap_handles_any(
@@ -309,9 +309,7 @@ where
field_info_mut
.value
.field_value_as_reflect_mut()
.as_reflect_mut(&mut |field| {
self.remap_handles_any(field, node_name, ignored_types)
})
.inner_mut(&mut |field| self.remap_handles_any(field, node_name, ignored_types))
}
})
}
@@ -319,7 +317,7 @@ where
#[inline]
pub fn remap_inheritable_handles(&self, node: &mut N, ignored_types: &[TypeId]) {
let name = node.name().to_string();
node.as_reflect_mut(&mut |node| {
node.inner_mut(&mut |node| {
self.remap_inheritable_handles_internal(node, &name, false, ignored_types)
});
}
@@ -463,7 +461,7 @@ where
}
fn reset_property_modified_flag(entity: &mut dyn Reflect, path: &str) {
entity.as_reflect_mut(&mut |entity| {
entity.inner_mut(&mut |entity| {
entity.resolve_path_mut(path, &mut |result| {
variable::mark_inheritable_properties_non_modified(
result.unwrap(),
@@ -566,7 +564,7 @@ pub trait SceneGraphNode: Reflect + NameProvider + Clone + 'static {
let mut parent_value = None;
// Find and clone parent's value first.
parent.as_reflect(&mut |parent| {
parent.inner_ref(&mut |parent| {
parent.resolve_path(path, &mut |result| match result {
Ok(parent_field) => parent_field.as_inheritable_variable(&mut |parent_field| {
if let Some(parent_inheritable) = parent_field {
@@ -582,7 +580,7 @@ pub trait SceneGraphNode: Reflect + NameProvider + Clone + 'static {
// Check whether the child's field is inheritable and modified.
let mut need_revert = false;
self.as_reflect_mut(&mut |child| {
self.inner_mut(&mut |child| {
child.resolve_path_mut(path, &mut |result| match result {
Ok(child_field) => {
child_field.as_inheritable_variable_mut(&mut |child_inheritable| {
@@ -605,7 +603,7 @@ pub trait SceneGraphNode: Reflect + NameProvider + Clone + 'static {
let mut was_set = false;
let mut parent_value = Some(parent_value);
self.as_reflect_mut(&mut |child| {
self.inner_mut(&mut |child| {
child.set_field_by_path(
path,
parent_value.take().unwrap(),
@@ -1389,8 +1387,8 @@ pub trait SceneGraph: 'static {
// Check if the actual node types (this and parent's) are equal, and if not - copy the
// node and replace its base.
let mut types_match = true;
node.as_reflect(&mut |node_reflect| {
resource_node.as_reflect(&mut |resource_node_reflect| {
node.inner_ref(&mut |node_reflect| {
resource_node.inner_ref(&mut |resource_node_reflect| {
types_match =
node_reflect.type_id() == resource_node_reflect.type_id();
@@ -1419,8 +1417,8 @@ pub trait SceneGraph: 'static {
}
// Then try to inherit properties.
node.as_reflect_mut(&mut |node_reflect| {
resource_node.as_reflect(&mut |resource_node_reflect| {
node.inner_mut(&mut |node_reflect| {
resource_node.inner_ref(&mut |resource_node_reflect| {
Log::verify(variable::try_inherit_properties(
node_reflect,
resource_node_reflect,
@@ -1754,16 +1752,16 @@ mod test {
self.0.deref_mut().fields_mut(func)
}
fn into_inner_reflect(self: Box<Self>) -> Box<dyn Reflect> {
Reflect::into_inner_reflect(self.0)
fn into_inner(self: Box<Self>) -> Box<dyn Reflect> {
Reflect::into_inner(self.0)
}
fn as_reflect(&self, func: &mut dyn FnMut(&dyn Reflect)) {
self.0.deref().as_reflect(func)
fn inner_ref(&self, func: &mut dyn FnMut(&dyn Reflect)) {
self.0.deref().inner_ref(func)
}
fn as_reflect_mut(&mut self, func: &mut dyn FnMut(&mut dyn Reflect)) {
self.0.deref_mut().as_reflect_mut(func)
fn inner_mut(&mut self, func: &mut dyn FnMut(&mut dyn Reflect)) {
self.0.deref_mut().inner_mut(func)
}
fn set(&mut self, value: Box<dyn Reflect>) -> Result<Box<dyn Reflect>, Box<dyn Reflect>> {
@@ -1803,12 +1801,12 @@ mod test {
self.0.fields_count()
}
fn as_reflect_direct(&self) -> &dyn Reflect {
self.0.as_reflect_direct()
fn inner_ref_direct(&self) -> &dyn Reflect {
self.0.inner_ref_direct()
}
fn as_reflect_mut_direct(&mut self) -> &mut dyn Reflect {
self.0.as_reflect_mut_direct()
fn inner_mut_direct(&mut self) -> &mut dyn Reflect {
self.0.inner_mut_direct()
}
}
@@ -2324,7 +2322,7 @@ mod test {
.unwrap()
.transmute::<RigidBody>();
let joint_copy = mapping.inner().get(&joint).cloned().unwrap();
scene_graph.nodes[joint_copy].as_reflect(&mut |reflect| {
scene_graph.nodes[joint_copy].inner_ref(&mut |reflect| {
let joint_copy_ref = (reflect as &dyn Any).downcast_ref::<Joint>().unwrap();
assert_eq!(joint_copy_ref.connected_body1, rigid_body_copy);
assert_eq!(joint_copy_ref.connected_body2, rigid_body2_copy);
fyrox-impl/src/engine/mod.rs
+1 -1
View File
@@ -2641,7 +2641,7 @@ impl Engine {
for resource in state.resources().iter() {
let data = resource.lock();
if let ResourceState::Ok { ref data, .. } = data.state {
data.as_reflect(&mut |reflect| {
data.inner_ref(&mut |reflect| {
if reflect.type_info_ref().assembly_name == plugin_assembly_name {
resources_to_reload.insert(resource.clone());
}
fyrox-impl/src/scene/graph/mod.rs
+1 -1
View File
@@ -538,7 +538,7 @@ impl Graph {
for (node_handle, node) in self.pair_iter() {
(node as &dyn Reflect).apply_recursively(
&mut |object| {
object.as_reflect(&mut |reflect| {
object.inner_ref(&mut |reflect| {
if let Some(handle) = (reflect as &dyn Any).downcast_ref::<Handle<Node>>() {
if *handle == target {
references.push(node_handle);
fyrox-impl/src/scene/node/mod.rs
+11 -11
View File
@@ -532,7 +532,7 @@ impl Node {
// Reset inheritable properties, so property inheritance system will take properties
// from parent objects on resolve stage.
self.as_reflect_mut(&mut |reflect| {
self.inner_mut(&mut |reflect| {
mark_inheritable_properties_non_modified(reflect, &[TypeId::of::<UntypedResource>()])
});
@@ -601,16 +601,16 @@ impl Reflect for Node {
self.0.deref_mut().fields_mut(func)
}
fn into_inner_reflect(self: Box<Self>) -> Box<dyn Reflect> {
Reflect::into_inner_reflect(self.0)
fn into_inner(self: Box<Self>) -> Box<dyn Reflect> {
Reflect::into_inner(self.0)
}
fn as_reflect(&self, func: &mut dyn FnMut(&dyn Reflect)) {
self.0.deref().as_reflect(func)
fn inner_ref(&self, func: &mut dyn FnMut(&dyn Reflect)) {
self.0.deref().inner_ref(func)
}
fn as_reflect_mut(&mut self, func: &mut dyn FnMut(&mut dyn Reflect)) {
self.0.deref_mut().as_reflect_mut(func)
fn inner_mut(&mut self, func: &mut dyn FnMut(&mut dyn Reflect)) {
self.0.deref_mut().inner_mut(func)
}
fn set(&mut self, value: Box<dyn Reflect>) -> Result<Box<dyn Reflect>, Box<dyn Reflect>> {
@@ -646,12 +646,12 @@ impl Reflect for Node {
self.0.deref_mut().field_direct_mut(index)
}
fn as_reflect_direct(&self) -> &dyn Reflect {
self.0.as_reflect_direct()
fn inner_ref_direct(&self) -> &dyn Reflect {
self.0.inner_ref_direct()
}
fn as_reflect_mut_direct(&mut self) -> &mut dyn Reflect {
self.0.as_reflect_mut_direct()
fn inner_mut_direct(&mut self) -> &mut dyn Reflect {
self.0.inner_mut_direct()
}
}
fyrox-impl/src/script/mod.rs
+16 -16
View File
@@ -754,16 +754,16 @@ impl Reflect for Script {
self.instance.fields_mut(func)
}
fn into_inner_reflect(self: Box<Self>) -> Box<dyn Reflect> {
self.instance.into_inner_reflect()
fn into_inner(self: Box<Self>) -> Box<dyn Reflect> {
self.instance.into_inner()
}
fn as_reflect(&self, func: &mut dyn FnMut(&dyn Reflect)) {
self.instance.deref().as_reflect(func)
fn inner_ref(&self, func: &mut dyn FnMut(&dyn Reflect)) {
self.instance.deref().inner_ref(func)
}
fn as_reflect_mut(&mut self, func: &mut dyn FnMut(&mut dyn Reflect)) {
self.instance.deref_mut().as_reflect_mut(func)
fn inner_mut(&mut self, func: &mut dyn FnMut(&mut dyn Reflect)) {
self.instance.deref_mut().inner_mut(func)
}
fn set(&mut self, value: Box<dyn Reflect>) -> Result<Box<dyn Reflect>, Box<dyn Reflect>> {
@@ -806,12 +806,12 @@ impl Reflect for Script {
self.instance.deref_mut().field_direct_mut(index)
}
fn as_reflect_direct(&self) -> &dyn Reflect {
self.instance.as_reflect_direct()
fn inner_ref_direct(&self) -> &dyn Reflect {
self.instance.inner_ref_direct()
}
fn as_reflect_mut_direct(&mut self) -> &mut dyn Reflect {
self.instance.as_reflect_mut_direct()
fn inner_mut_direct(&mut self) -> &mut dyn Reflect {
self.instance.inner_mut_direct()
}
}
@@ -958,8 +958,8 @@ mod test {
field: InheritableVariable::new_non_modified(3.21),
})));
child.as_reflect_mut(&mut |child| {
parent.as_reflect(&mut |parent| {
child.inner_mut(&mut |child| {
parent.inner_ref(&mut |parent| {
try_inherit_properties(child, parent, &[]).unwrap();
})
});
@@ -980,8 +980,8 @@ mod test {
field: InheritableVariable::new_non_modified(3.21),
});
child.as_reflect_mut(&mut |child| {
parent.as_reflect(&mut |parent| {
child.inner_mut(&mut |child| {
parent.inner_ref(&mut |parent| {
try_inherit_properties(child, parent, &[]).unwrap();
})
});
@@ -999,8 +999,8 @@ mod test {
field: InheritableVariable::new_non_modified(3.21),
}));
child.as_reflect_mut(&mut |child| {
parent.as_reflect(&mut |parent| {
child.inner_mut(&mut |child| {
parent.inner_ref(&mut |parent| {
try_inherit_properties(child, parent, &[]).unwrap();
})
});
fyrox-resource/src/graph.rs
+1 -1
View File
@@ -42,7 +42,7 @@ impl ResourceGraphNode {
let header = resource.lock();
if let ResourceState::Ok { ref data, .. } = header.state {
(**data).as_reflect(&mut |entity| {
(**data).inner_ref(&mut |entity| {
collect_used_resources(entity, &mut dependent_resources);
});
}
fyrox-resource/src/state.rs
+9 -9
View File
@@ -121,24 +121,24 @@ impl Reflect for ResourceDataWrapper {
self.deref_mut().fields_mut(func)
}
fn into_inner_reflect(self: Box<Self>) -> Box<dyn Reflect> {
fn into_inner(self: Box<Self>) -> Box<dyn Reflect> {
self
}
fn as_reflect_direct(&self) -> &dyn Reflect {
self.deref().as_reflect_direct()
fn inner_ref_direct(&self) -> &dyn Reflect {
self.deref().inner_ref_direct()
}
fn as_reflect_mut_direct(&mut self) -> &mut dyn Reflect {
self.deref_mut().as_reflect_mut_direct()
fn inner_mut_direct(&mut self) -> &mut dyn Reflect {
self.deref_mut().inner_mut_direct()
}
fn as_reflect(&self, func: &mut dyn FnMut(&dyn Reflect)) {
self.deref().as_reflect(func)
fn inner_ref(&self, func: &mut dyn FnMut(&dyn Reflect)) {
self.deref().inner_ref(func)
}
fn as_reflect_mut(&mut self, func: &mut dyn FnMut(&mut dyn Reflect)) {
self.deref_mut().as_reflect_mut(func)
fn inner_mut(&mut self, func: &mut dyn FnMut(&mut dyn Reflect)) {
self.deref_mut().inner_mut(func)
}
fn set(&mut self, value: Box<dyn Reflect>) -> Result<Box<dyn Reflect>, Box<dyn Reflect>> {
fyrox-ui/src/inspector/mod.rs
+7 -11
View File
@@ -260,11 +260,7 @@ where
}
fn into_box_reflect(self: Box<Self>) -> Box<dyn Reflect> {
Box::new(
*(self.into_inner_reflect() as Box<dyn Any>)
.downcast::<T>()
.unwrap(),
)
Box::new(*(self.into_inner() as Box<dyn Any>).downcast::<T>().unwrap())
}
}
@@ -295,17 +291,17 @@ impl PartialEq for ObjectValue {
impl ObjectValue {
pub fn cast_value<T: 'static>(&self, func: &mut dyn FnMut(Option<&T>)) {
(*self.value).as_reflect(&mut |reflect| func((reflect as &dyn Any).downcast_ref::<T>()))
(*self.value).inner_ref(&mut |reflect| func((reflect as &dyn Any).downcast_ref::<T>()))
}
pub fn cast_clone<T: Clone + 'static>(&self, func: &mut dyn FnMut(Option<T>)) {
(*self.value)
.as_reflect(&mut |reflect| func((reflect as &dyn Any).downcast_ref::<T>().cloned()))
.inner_ref(&mut |reflect| func((reflect as &dyn Any).downcast_ref::<T>().cloned()))
}
pub fn try_override<T: Clone + 'static>(&self, value: &mut T) -> bool {
let mut result = false;
(*self.value).as_reflect(&mut |reflect| {
(*self.value).inner_ref(&mut |reflect| {
if let Some(self_value) = (reflect as &dyn Any).downcast_ref::<T>() {
*value = self_value.clone();
result = true;
@@ -587,8 +583,8 @@ impl Inspector {
can_clone = field.try_clone_box().is_some();
if let Some(clipboard_value) = clipboard_value {
clipboard_value.as_reflect(&mut |clipboard_value| {
field.as_reflect(&mut |field| {
clipboard_value.inner_ref(&mut |clipboard_value| {
field.inner_ref(&mut |field| {
can_paste = field.type_id() == clipboard_value.type_id();
})
});
@@ -848,7 +844,7 @@ impl PartialEq for InspectorContext {
fn object_type_id(object: &dyn Reflect) -> TypeId {
let mut object_type_id = None;
object.as_reflect(&mut |reflect| object_type_id = Some(reflect.type_id()));
object.inner_ref(&mut |reflect| object_type_id = Some(reflect.type_id()));
object_type_id.unwrap()
}
fyrox-ui/src/node/mod.rs
+11 -11
View File
@@ -247,7 +247,7 @@ impl UiNode {
// Reset inheritable properties, so property inheritance system will take properties
// from parent objects on resolve stage.
self.as_reflect_mut(&mut |reflect| {
self.inner_mut(&mut |reflect| {
variable::mark_inheritable_properties_non_modified(
reflect,
&[TypeId::of::<UntypedResource>()],
@@ -299,24 +299,24 @@ impl Reflect for UiNode {
self.0.deref_mut().fields_mut(func)
}
fn into_inner_reflect(self: Box<Self>) -> Box<dyn Reflect> {
Reflect::into_inner_reflect(self.0)
fn into_inner(self: Box<Self>) -> Box<dyn Reflect> {
Reflect::into_inner(self.0)
}
fn as_reflect_direct(&self) -> &dyn Reflect {
self.0.deref().as_reflect_direct()
fn inner_ref_direct(&self) -> &dyn Reflect {
self.0.deref().inner_ref_direct()
}
fn as_reflect_mut_direct(&mut self) -> &mut dyn Reflect {
self.0.deref_mut().as_reflect_mut_direct()
fn inner_mut_direct(&mut self) -> &mut dyn Reflect {
self.0.deref_mut().inner_mut_direct()
}
fn as_reflect(&self, func: &mut dyn FnMut(&dyn Reflect)) {
self.0.deref().as_reflect(func)
fn inner_ref(&self, func: &mut dyn FnMut(&dyn Reflect)) {
self.0.deref().inner_ref(func)
}
fn as_reflect_mut(&mut self, func: &mut dyn FnMut(&mut dyn Reflect)) {
self.0.deref_mut().as_reflect_mut(func)
fn inner_mut(&mut self, func: &mut dyn FnMut(&mut dyn Reflect)) {
self.0.deref_mut().inner_mut(func)
}
fn set(&mut self, value: Box<dyn Reflect>) -> Result<Box<dyn Reflect>, Box<dyn Reflect>> {