Merge pull request #3 from Preliy/development

Development

Author: Preliy

README.md

@@ -6,7 +6,7 @@
 
 ## Key Features:
 + Kinematic Solver: Analytical forward and inverse kinematic solvers for different robot types
-+ Controller: The main script for robot control, managing kinematics, tool definitions, and reference frames.
++ Controller: The primary script for robot control, responsible for defining the robot's kinematics, tool configurations, and reference frames.
 
 > [!NOTE]  
 > This package does not include motion planning or trajectory generation functionality
@@ -33,12 +33,12 @@ For custom support or project-specific inquiries, contact us at `preliyex@gmail.
 # Sponsoring & Donations
 If you find Flange useful, consider supporting the project to help maintain development and improve features:
 + [GitHub Sponsors](https://github.com/sponsors/Preliy)
-+ [By Me a Coffee](buymeacoffee.com/preliy)
++ [Buy Me a Coffee](buymeacoffee.com/preliy)
 
 <br>
 
 # Key Components
-**Flange** is built on two primary kinematic components: `Frame.cs` and `Joint.cs`. TThese scripts define the kinematic chain and enforce movement constraints.
+**Flange** is built on two primary components: `Frame.cs` and `Joint.cs`. These scripts define the kinematic chain and enforce movement constraints.
 
 ## Frame
 ![InspectorFrame.PNG](Documentation/Resources/Images/InspectorFrame.PNG)
@@ -56,20 +56,20 @@ This approach uses [Modified Denavit–Hartenberg (DH)](https://en.wikipedia.org
 
 ![FrameJoint.drawio.png](Documentation/Resources/Images/FrameJoint.drawio.png)
 
-A `MechanicalUnit.cs` combines multiple Frames and Joints into a single assembly, such as an arm or external positioner. It provides essential functionality for configuring and controlling the unit:
-+ **Custom Control Panel:** Offers a dedicated interface within the Unity editor to configure and manipulate the unit.
-+ **Frame and Joint References:** Ensures that all Frames and Joints within the Mechanical Unit are properly referenced to form a complete kinematic chain.
-+ **External Control Access:** Includes public methods to control the unit from external scripts.
-+ **Save and Load Configurations:** Public methods to save and load configurations for Frames and Joints, enabling the sharing of kinematic chain parameters across different units.
-+ **Kinematic Chain Visualization:** When Gizmos are enabled, a visual representation of the kinematic chain is displayed, aiding in understanding and troubleshooting the mechanical structure.
+The `MechanicalUnit.cs` integrates multiple frames and joints into a single assembly, such as a robotic arm or an external positioner. It has key functions for configuring and controlling the unit, including:
++ **Custom Inspector:** A single joint value can be controlled using its corresponding slider field.
++ **Frame and Joint References:** All joints and frames must be assigned in sequential chain order.
++ **External Control:** Public methods to control the unit from another scripts.
++ **Save and Load Configurations:** Save and load configurations (Scriptable Object) for Frames and Joints, enabling the sharing of kinematic chain parameters across different prefabs.
++ **Kinematic Chain Visualization:** When Gizmos are enabled, a visual representation of the kinematic chain is displayed.
 
 > [!NOTE]  
 > Only serial (open chain) kinematic will supported by default
 
 ## Robots
 
-`Robot.cs` serves as an abstract base class for various robotic manipulators within the Flange framework. 
-It establishes a abstract methods for implementing forward (FK) and inverse kinematics (IK) specific to different robot types.
+`Robot.cs` serves as an abstract base class for various robotic manipulators within the Flange framework.
+It defines abstract methods for forward (FK) and inverse kinematics (IK) that must be implemented by specific robot types.
 
 + **Kinematics Implementation**:
 Forward and inverse kinematics calculations are defined in derived classes, allowing for flexibility in handling different robotic configurations.
@@ -109,20 +109,20 @@ You can find this Robot Prefab in Samples: `Assets/com.preliy.flange/Samples/Dem
 
 ## Controller
 
-`Controller.cs` serves as the virtual robot controller within the Flange package, orchestrating key calculations and configurations for robot motion and interaction.
-+ **Kinematics Management**: Manages forward and inverse kinematics calculations, accounting for the tool, frames, and robot-specific configuration.
-+ **External Unit Integration**: References external units and incorporates their positions into the TCP (Tool Center Point) calculations
+`Controller.cs` functions as the virtual robot controller within the Flange package, orchestrating calculations and configurations for robot motion and interaction.
++ **Kinematics Management**: Manages forward and inverse kinematics calculations, taking into account tool parameters, reference frames, and robot-specific configuration.
++ **External Unit Integration**: Includes external unit references and uses their position data for the Tool Center Point (TCP) calculations.
 
 ![Controller.PNG](Documentation%2FResources%2FImages%2FController.PNG)
 
-The `Controller.cs` component features a custom inspector UI, allowing users to control the robot through joint values or by directly moving the TCP. In the Cartesian section of the UI, users can view essential properties such as the current TCP position and rotation, the tool, frame, and robot configuration. Additionally, the configuration selection tool includes a "Select" button, enabling users to browse all possible configurations for a specific pose, with the `Show Turn` option providing further configurations that account for axis turns.
+The `Controller.cs` component provides a custom inspector that allows to control the robot either by adjusting the joint values or by directly manipulating the TCP.  Additionally, the configuration selection tool includes a "Select" button, enabling users to browse all possible configurations for a specific pose, with the `Show Turn` option providing further configurations that account for axis turns.
 
-To use the `Tool` and `Frame` properties, tools and frames must first be assigned in the corresponding lists within `Controller.cs`. The Tool and Frame property indices will reference these lists, allowing the user to select specific tools and frames based on their index values.
+To use the `Tool` and `Frame` properties, tools and frames must first be assigned in the corresponding lists within `Controller.cs`. The Tool and Frame property indices will reference these lists, allowing to select specific tools and frames based on their index values.
 
 For kinematic configuration, `Controller.cs` includes three main fields:
 + The **Robot** field, where the robot itself is assigned.
 + The **Base** field, which requires the assignment of a base mechanical unit. This unit acts as the base for the robot, allowing the robot’s reference frame to be moved—for example, along a linear axis.
-+ The **External** list, where external mechanical units, such as positioners or rotating tables, can be added to extend the robot’s operational capabilities and coordinate its movements with additional devices.
++ The **External** list, where external mechanical units, such as positioner or rotating table, can be added to extend the robot’s operational capabilities and coordinate its movements with additional devices.
 
 > [!NOTE]
 > If the mechanical configuration is modified, the inspector UI must be reloaded. Reselect the Controller GameObject to see the updated Joints Slider list in the inspector.

Runtime/Scripts/Animation/TargetFollower.cs

@@ -30,8 +30,6 @@ public class TargetFollower : MonoBehaviour
 
         [Header("Settings")]
         [SerializeField]
-        private bool _runInEditor;
-        [SerializeField]
         private bool _showErrorMassage;
 
         [HideInInspector]
@@ -44,23 +42,10 @@ private void OnEnable()
         }
 
         private void Update()
-        {
-            if (!Application.isPlaying && _runInEditor)
-            {
-                _target.Value = transform.GetMatrix();
-            }
-        }
-
-        private void OnAnimatorMove()
         {
             _target.Value = transform.GetMatrix();
         }
 
-        // private void OnValidate()
-        // {
-        //     _target.Value = transform.GetMatrix();
-        // }
-
         private void OnDisable()
         {
             _target.OnValueChanged -= JumpToTarget;