diff --git a/editor/src/plugins/animation/track.rs b/editor/src/plugins/animation/track.rs
index ede621199..c7439c8ff 100644
--- a/editor/src/plugins/animation/track.rs
+++ b/editor/src/plugins/animation/track.rs
@@ -868,7 +868,7 @@ impl TrackList {
                                 adder.add(values)
                             }
                         }
-                        ValueBinding::Property { name, .. } => node_ref.field(name, &mut |value| {
+                        ValueBinding::Property { name, .. } => node_ref.find_field(name, &mut |value| {
                             if let Some(value) = value {
                                 value.as_any(&mut |any| {
                                     let curves = track.data_container().curves_ref();
diff --git a/fyrox-core-derive/src/reflect.rs b/fyrox-core-derive/src/reflect.rs
index ad5b1f88d..aa4642d74 100644
--- a/fyrox-core-derive/src/reflect.rs
+++ b/fyrox-core-derive/src/reflect.rs
@@ -200,7 +200,7 @@ fn struct_set_field_body(ty_args: &args::TypeArgs) -> Option<TokenStream2> {
                 }
                 Err(current) => {
                     let mut field_type_name = "(none)";
-                    self.field_mut(name, &mut |field| { field_type_name = field.unwrap().type_name() });
+                    self.find_field_mut(name, &mut |field| { field_type_name = field.unwrap().type_name() });
                     Err(SetFieldError::InvalidValue{field_type_name, value: current})
                 }
             })
@@ -214,7 +214,7 @@ fn struct_set_field_body(ty_args: &args::TypeArgs) -> Option<TokenStream2> {
             )*
             _ => {
                 let mut opt_value = Some(value);
-                self.field_mut(name, &mut move |field| {
+                self.find_field_mut(name, &mut move |field| {
                     let value = opt_value.take().unwrap();
                     match field {
                         Some(f) => func(f.set(value).map_err(|value| SetFieldError::InvalidValue {
diff --git a/fyrox-core/src/reflect/impls.rs b/fyrox-core/src/reflect/impls.rs
index a89312a9a..c4480c429 100644
--- a/fyrox-core/src/reflect/impls.rs
+++ b/fyrox-core/src/reflect/impls.rs
@@ -220,14 +220,14 @@ macro_rules! impl_reflect_inner_mutability {
             guard.set_field(field, value, func)
         }
 
-        fn field(&$self, name: &str, func: &mut dyn FnMut(Option<&dyn Reflect>)) {
+        fn find_field(&$self, name: &str, func: &mut dyn FnMut(Option<&dyn Reflect>)) {
             let guard = $acquire_lock_guard;
-            guard.field(name, func)
+            guard.find_field(name, func)
         }
 
-        fn field_mut(&mut $self, name: &str, func: &mut dyn FnMut(Option<&mut dyn Reflect>)) {
+        fn find_field_mut(&mut $self, name: &str, func: &mut dyn FnMut(Option<&mut dyn Reflect>)) {
             let mut guard = $acquire_lock_guard;
-            guard.field_mut(name, func)
+            guard.find_field_mut(name, func)
         }
 
         fn as_array(&$self, func: &mut dyn FnMut(Option<&dyn ReflectArray>)) {
diff --git a/fyrox-core/src/reflect/macros.rs b/fyrox-core/src/reflect/macros.rs
index 0860544b9..3c0d35498 100644
--- a/fyrox-core/src/reflect/macros.rs
+++ b/fyrox-core/src/reflect/macros.rs
@@ -60,16 +60,20 @@ macro_rules! newtype_reflect {
             self.0.set(value)
         }
 
-        fn field(&self, name: &str, func: &mut dyn FnMut(Option<&dyn $crate::reflect::Reflect>)) {
-            self.0.field(name, func)
+        fn find_field(
+            &self,
+            name: &str,
+            func: &mut dyn FnMut(Option<&dyn $crate::reflect::Reflect>),
+        ) {
+            self.0.find_field(name, func)
         }
 
-        fn field_mut(
+        fn find_field_mut(
             &mut self,
             name: &str,
             func: &mut dyn FnMut(Option<&mut dyn $crate::reflect::Reflect>),
         ) {
-            self.0.field_mut(name, func)
+            self.0.find_field_mut(name, func)
         }
 
         fn as_array(&self, func: &mut dyn FnMut(Option<&dyn $crate::reflect::ReflectArray>)) {
@@ -203,16 +207,20 @@ macro_rules! delegate_reflect {
             self.deref_mut().set(value)
         }
 
-        fn field(&self, name: &str, func: &mut dyn FnMut(Option<&dyn $crate::reflect::Reflect>)) {
-            self.deref().field(name, func)
+        fn find_field(
+            &self,
+            name: &str,
+            func: &mut dyn FnMut(Option<&dyn $crate::reflect::Reflect>),
+        ) {
+            self.deref().find_field(name, func)
         }
 
-        fn field_mut(
+        fn find_field_mut(
             &mut self,
             name: &str,
             func: &mut dyn FnMut(Option<&mut dyn $crate::reflect::Reflect>),
         ) {
-            self.deref_mut().field_mut(name, func)
+            self.deref_mut().find_field_mut(name, func)
         }
 
         fn as_array(&self, func: &mut dyn FnMut(Option<&dyn $crate::reflect::ReflectArray>)) {
@@ -342,11 +350,15 @@ macro_rules! blank_reflect {
             func(self)
         }
 
-        fn field(&self, name: &str, func: &mut dyn FnMut(Option<&dyn $crate::reflect::Reflect>)) {
+        fn find_field(
+            &self,
+            name: &str,
+            func: &mut dyn FnMut(Option<&dyn $crate::reflect::Reflect>),
+        ) {
             func(if name == "self" { Some(self) } else { None })
         }
 
-        fn field_mut(
+        fn find_field_mut(
             &mut self,
             name: &str,
             func: &mut dyn FnMut(Option<&mut dyn $crate::reflect::Reflect>),
diff --git a/fyrox-core/src/reflect/mod.rs b/fyrox-core/src/reflect/mod.rs
index cc31f4c92..545aeeca4 100644
--- a/fyrox-core/src/reflect/mod.rs
+++ b/fyrox-core/src/reflect/mod.rs
@@ -158,7 +158,7 @@ pub trait Reflect: Any + Debug {
         Self: Sized;
 
     /// Calls user method specified with `#[reflect(setter = ..)]` or falls back to
-    /// [`Reflect::field_mut`]
+    /// [`Reflect::find_field_mut`]
     #[allow(clippy::type_complexity)]
     fn set_field(
         &mut self,
@@ -167,7 +167,7 @@ pub trait Reflect: Any + Debug {
         func: &mut dyn FnMut(Result<Box<dyn Reflect>, SetFieldError>),
     ) {
         let mut opt_value = Some(value);
-        self.field_mut(field_name, &mut move |field| {
+        self.find_field_mut(field_name, &mut move |field| {
             let value = opt_value.take().unwrap();
             match field {
                 Some(f) => func(f.set(value).map_err(|value| SetFieldError::InvalidValue {
@@ -182,7 +182,7 @@ pub trait Reflect: Any + Debug {
         });
     }
 
-    fn field(&self, name: &str, func: &mut dyn FnMut(Option<&dyn Reflect>)) {
+    fn find_field(&self, name: &str, func: &mut dyn FnMut(Option<&dyn Reflect>)) {
         self.fields_ref(&mut |fields| {
             func(
                 fields
@@ -193,7 +193,7 @@ pub trait Reflect: Any + Debug {
         });
     }
 
-    fn field_mut(&mut self, name: &str, func: &mut dyn FnMut(Option<&mut dyn Reflect>)) {
+    fn find_field_mut(&mut self, name: &str, func: &mut dyn FnMut(Option<&mut dyn Reflect>)) {
         self.fields_mut(&mut |fields| {
             func(
                 fields
@@ -676,14 +676,14 @@ pub trait GetField {
 
 impl<R: Reflect> GetField for R {
     fn get_field<T: 'static>(&self, name: &str, func: &mut dyn FnMut(Option<&T>)) {
-        self.field(name, &mut |field| match field {
+        self.find_field(name, &mut |field| match field {
             None => func(None),
             Some(reflect) => reflect.as_any(&mut |any| func(any.downcast_ref())),
         })
     }
 
     fn get_field_mut<T: 'static>(&mut self, name: &str, func: &mut dyn FnMut(Option<&mut T>)) {
-        self.field_mut(name, &mut |field| match field {
+        self.find_field_mut(name, &mut |field| match field {
             None => func(None),
             Some(reflect) => reflect.as_any_mut(&mut |any| func(any.downcast_mut())),
         })
@@ -788,7 +788,7 @@ impl<'p> Component<'p> {
         func: &mut dyn FnMut(Result<&dyn Reflect, ReflectPathError<'p>>),
     ) {
         match self {
-            Self::Field(path) => reflect.field(path, &mut |field| {
+            Self::Field(path) => reflect.find_field(path, &mut |field| {
                 func(field.ok_or(ReflectPathError::UnknownField { s: path }))
             }),
             Self::Index(path) => {
@@ -819,7 +819,7 @@ impl<'p> Component<'p> {
         func: &mut dyn FnMut(Result<&mut dyn Reflect, ReflectPathError<'p>>),
     ) {
         match self {
-            Self::Field(path) => reflect.field_mut(path, &mut |field| {
+            Self::Field(path) => reflect.find_field_mut(path, &mut |field| {
                 func(field.ok_or(ReflectPathError::UnknownField { s: path }))
             }),
             Self::Index(path) => {
diff --git a/fyrox-core/src/variable.rs b/fyrox-core/src/variable.rs
index 6034338b9..bac7aedcd 100644
--- a/fyrox-core/src/variable.rs
+++ b/fyrox-core/src/variable.rs
@@ -492,15 +492,15 @@ where
     }
 
     #[inline]
-    fn field(&self, name: &str, func: &mut dyn FnMut(Option<&dyn Reflect>)) {
-        self.value.field(name, func)
+    fn find_field(&self, name: &str, func: &mut dyn FnMut(Option<&dyn Reflect>)) {
+        self.value.find_field(name, func)
     }
 
     #[inline]
-    fn field_mut(&mut self, name: &str, func: &mut dyn FnMut(Option<&mut dyn Reflect>)) {
+    fn find_field_mut(&mut self, name: &str, func: &mut dyn FnMut(Option<&mut dyn Reflect>)) {
         // Any modifications inside of compound structs must mark the variable as modified.
         self.mark_modified_and_need_sync();
-        self.value.field_mut(name, func)
+        self.value.find_field_mut(name, func)
     }
 
     #[inline]
diff --git a/fyrox-graph/src/lib.rs b/fyrox-graph/src/lib.rs
index ed52b48c0..015309933 100644
--- a/fyrox-graph/src/lib.rs
+++ b/fyrox-graph/src/lib.rs
@@ -1795,12 +1795,12 @@ mod test {
             self.0.deref_mut().set_field(field, value, func)
         }
 
-        fn field(&self, name: &str, func: &mut dyn FnMut(Option<&dyn Reflect>)) {
-            self.0.deref().field(name, func)
+        fn find_field(&self, name: &str, func: &mut dyn FnMut(Option<&dyn Reflect>)) {
+            self.0.deref().find_field(name, func)
         }
 
-        fn field_mut(&mut self, name: &str, func: &mut dyn FnMut(Option<&mut dyn Reflect>)) {
-            self.0.deref_mut().field_mut(name, func)
+        fn find_field_mut(&mut self, name: &str, func: &mut dyn FnMut(Option<&mut dyn Reflect>)) {
+            self.0.deref_mut().find_field_mut(name, func)
         }
 
         fn derived_types() -> &'static [TypeId] {
diff --git a/fyrox-impl/src/scene/node/mod.rs b/fyrox-impl/src/scene/node/mod.rs
index 4aa865cbf..5beb32cbd 100644
--- a/fyrox-impl/src/scene/node/mod.rs
+++ b/fyrox-impl/src/scene/node/mod.rs
@@ -650,12 +650,12 @@ impl Reflect for Node {
         self.0.deref_mut().set_field(field, value, func)
     }
 
-    fn field(&self, name: &str, func: &mut dyn FnMut(Option<&dyn Reflect>)) {
-        self.0.deref().field(name, func)
+    fn find_field(&self, name: &str, func: &mut dyn FnMut(Option<&dyn Reflect>)) {
+        self.0.deref().find_field(name, func)
     }
 
-    fn field_mut(&mut self, name: &str, func: &mut dyn FnMut(Option<&mut dyn Reflect>)) {
-        self.0.deref_mut().field_mut(name, func)
+    fn find_field_mut(&mut self, name: &str, func: &mut dyn FnMut(Option<&mut dyn Reflect>)) {
+        self.0.deref_mut().find_field_mut(name, func)
     }
 
     fn try_clone_box(&self) -> Option<Box<dyn Reflect>> {
diff --git a/fyrox-impl/src/script/mod.rs b/fyrox-impl/src/script/mod.rs
index d99c11ab2..7541f15c3 100644
--- a/fyrox-impl/src/script/mod.rs
+++ b/fyrox-impl/src/script/mod.rs
@@ -784,12 +784,12 @@ impl Reflect for Script {
         self.instance.deref_mut().set(value)
     }
 
-    fn field(&self, name: &str, func: &mut dyn FnMut(Option<&dyn Reflect>)) {
-        self.instance.deref().field(name, func)
+    fn find_field(&self, name: &str, func: &mut dyn FnMut(Option<&dyn Reflect>)) {
+        self.instance.deref().find_field(name, func)
     }
 
-    fn field_mut(&mut self, name: &str, func: &mut dyn FnMut(Option<&mut dyn Reflect>)) {
-        self.instance.deref_mut().field_mut(name, func)
+    fn find_field_mut(&mut self, name: &str, func: &mut dyn FnMut(Option<&mut dyn Reflect>)) {
+        self.instance.deref_mut().find_field_mut(name, func)
     }
 
     fn as_array(&self, func: &mut dyn FnMut(Option<&dyn ReflectArray>)) {
diff --git a/fyrox-resource/src/state.rs b/fyrox-resource/src/state.rs
index babc0e2e1..958b0a9a1 100644
--- a/fyrox-resource/src/state.rs
+++ b/fyrox-resource/src/state.rs
@@ -170,12 +170,12 @@ impl Reflect for ResourceDataWrapper {
         self.deref_mut().set_field(field, value, func)
     }
 
-    fn field(&self, name: &str, func: &mut dyn FnMut(Option<&dyn Reflect>)) {
-        self.deref().field(name, func)
+    fn find_field(&self, name: &str, func: &mut dyn FnMut(Option<&dyn Reflect>)) {
+        self.deref().find_field(name, func)
     }
 
-    fn field_mut(&mut self, name: &str, func: &mut dyn FnMut(Option<&mut dyn Reflect>)) {
-        self.deref_mut().field_mut(name, func)
+    fn find_field_mut(&mut self, name: &str, func: &mut dyn FnMut(Option<&mut dyn Reflect>)) {
+        self.deref_mut().find_field_mut(name, func)
     }
 
     fn as_array(&self, func: &mut dyn FnMut(Option<&dyn ReflectArray>)) {
diff --git a/fyrox-ui/src/node/mod.rs b/fyrox-ui/src/node/mod.rs
index 42f4592a3..6ce204cc7 100644
--- a/fyrox-ui/src/node/mod.rs
+++ b/fyrox-ui/src/node/mod.rs
@@ -354,11 +354,11 @@ impl Reflect for UiNode {
         self.0.deref_mut().set_field(field, value, func)
     }
 
-    fn field(&self, name: &str, func: &mut dyn FnMut(Option<&dyn Reflect>)) {
-        self.0.deref().field(name, func)
+    fn find_field(&self, name: &str, func: &mut dyn FnMut(Option<&dyn Reflect>)) {
+        self.0.deref().find_field(name, func)
     }
 
-    fn field_mut(&mut self, name: &str, func: &mut dyn FnMut(Option<&mut dyn Reflect>)) {
-        self.0.deref_mut().field_mut(name, func)
+    fn find_field_mut(&mut self, name: &str, func: &mut dyn FnMut(Option<&mut dyn Reflect>)) {
+        self.0.deref_mut().find_field_mut(name, func)
     }
 }