Bio IK Rig Control for Robot Puppeteering in Unity

Unity's core architecture consists of game objects (containers for components), components (functionality add-ons), and MonoBehaviors (C# scripts that add behavior). Game objects can be world objects (players, enemies) or UI objects (buttons, text). UI objects require a Canvas parent and use RectTransform for pixel-based positioning. Key components include Transform (position/rotation/scale), SpriteRenderer (2D rendering), and Collider2D (collision detection). The Inspector allows adding components via 'Add Component'. Understanding this hierarchy is essential for all Unity development.

Unity is the leading game engine with the highest market share, supporting both 2D and 3D game development using C# programming language. The Unity Hub manages multiple editor versions and installations, while the Unity Editor provides essential tools including the Hierarchy panel for managing game objects, Inspector for viewing and modifying object properties, and Scene/Game views for visual editing. Game objects are composed of components like Transform (position, rotation, scale), Camera, and Light. The Transform component enables precise object manipulation through position coordinates (X, Y, Z), rotation using Euler angles, and scaling. Parent-child relationships allow hierarchical organization where children inherit parent transformations. Materials define visual properties including color, texture, metallic, smoothness, and emission. C# programming fundamentals include variables (strings, integers, floats, booleans), data types, mathematical operators, and methods for creating interactive game logic.

Unity is a game engine that uses a component-based architecture where Game Objects serve as the fundamental building blocks, each containing Components (such as Transform for positioning, Mesh Renderer for visualization, Rigidbody for physics, and Collider for collision detection) that define how objects look and behave; the engine provides a customizable interface with views like Scene (for placing objects), Hierarchy (for managing objects in the scene), Inspector (for viewing and editing component properties), and Project Files (for accessing assets), along with tools for creating both 2D and 3D games through Scenes that organize different parts of a game into separate worlds.

In Unity C#, classes serve as blueprints that define the behavior and properties of game objects, allowing developers to create reusable components like enemy AI that can follow player characters; objects are instances of these classes that exist in the game scene, and the 'new' keyword is used to instantiate objects from classes, enabling the association of scripts with scene objects to implement behaviors such as enemy movement and player tracking.

This section covers C# scripting basics: create scripts in the Project window (C# Script); understand MonoDevelop editor; recognize comments (//) that developers ignore; understand void Start() (runs once at game start) and void Update() (runs every frame); define variables with types (int for whole numbers, float for decimals, Vector3 for 3D positions); use public/private modifiers for visibility; and use semicolons to end statements.

3D rigging consists of three components: skeleton (bones), skin (geometry), and controls. Bones are parented hierarchically, where parent movement affects children but children never influence parents. Forward Kinematics (FK) rotates bones from root outward, while Inverse Kinematics (IK) keeps the end effector fixed while adjusting the chain. Bone pivot points determine rotation centers; in edit mode, you can reposition bones to change where they rotate. Empty objects serve as invisible helpers to establish pivot points. Skinning evolved from manually animating each vertex frame-by-frame to associating vertices with bones. The Armature Deform modifier creates vertex groups that associate vertices with bones. Edit mode sets up the rig without deforming geometry, while pose mode animates and deforms the mesh. Vertex weights determine influence: 1.0 means 100% influence, 0.0 means none. Weight painting mode allows intuitive vertex weight assignment through color gradients (red = 100% influence, blue = 0%).

This comprehensive workflow covers character rigging and animation in Blender. Bones control mesh deformation by moving vertices; attach meshes using 'Parent with Automatic Weights'. For human mesh creation: start with a cube, add Subdivision Surface modifier, extrude body parts, use Mirror modifier for symmetry, add details with Ctrl+R. Create bone hierarchies using 'Parent Make Offsets', name bones with underscores for left-side mirroring. Apply transforms with Ctrl+A. Two animation methods: Forward Kinematics (FK) manually moves joints; Inverse Kinematics (IK) moves end effectors while Blender calculates intermediate joints. For running animation: set 40-frame timeline, use Auto IK for arms, tilt torso, bend legs, rotate torso on Z-axis. Set keyframes by selecting all bones and pressing I. Copy keyframes with Ctrl+C and paste with Ctrl+V. Rigify addon simplifies rigging: enable in Preferences, create Human Metarig, scale to mesh, align along X-axis, move bones in groups, apply transforms, generate rig. Assign weights by selecting mesh and rig, then 'Parent with Automatic Weights'.

Rigging in 3D animation involves creating a skeleton (armature) connected to a mesh, where bones control deformation through skinning and weight painting; animators use forward kinematics (rotating individual joints) or inverse kinematics (moving end joints with pole vectors) to animate, while controllers simplify manipulation, and advanced techniques like blend shapes, corrective shapes, and drivers enable complex facial expressions and mechanical behaviors, with automatic rigging tools like Rigify and retargeting facilitating cross-platform animation transfer.

The motion bone is a superimposed skeletal structure used for retargeting calculations, with purple end effectors at the extremities driving character animation by constraining feet and hands to specific areas. The motion bone's scale is directly proportional to the distance between a character's feet and hips—characters with longer leg-to-hip ratios possess larger motion bones. This structural relationship explains why different characters display varying motion bone sizes even when using identical animations. The 'align to motion bone pose' option ensures character positions align correctly with motion data, preventing unnatural movements like wildly swinging arms during walking animations.

Rigging creates a skeleton for 3D models to enable animation. The hierarchy follows: Model (geometry) → Mover (overall positioning) → Root (central anchor at pelvis) → Pelvis (leg connection) → Spine (back structure) → Rib bones (chest) → Clavicle bones (shoulder connection) → Arm bones (limbs). Controllers are direct descendants of the Mover bone, allowing independent movement. The head controller handles orientation only. Clavicle bones enable shoulder movement but require constraints to prevent elbow issues. Pole vectors provide reference points for IK stability. Inverse Kinematics (IK) allows moving end effectors while the system calculates bone positions, while Forward Kinematics (FK) involves manual bone rotation. Weight maps determine bone influence on geometry, and support bones prevent unwanted deformations.

Robot kinematics describes the motion capabilities of robot manipulators. Degrees of freedom (DOF) represents the number of independent movements a robot can perform, typically 6 DOF for full 3D motion (3 translational + 3 rotational). Each joint contributes to the total DOF, with rotary joints providing rotational movement and linear joints providing translational movement. The DOF determines the robot's workspace and reachability. Rotational travel limits define the angular range each joint can move, which collectively determines the robot's operational envelope and task capabilities.

The degrees of freedom of a robot equals total body freedoms minus motion constraints. Revolute joints impose 5 constraints, leaving 1 DOF (rotational angle). Prismatic joints provide 1 translational DOF. Universal joints offer 2 DOF, spherical joints provide 3 DOF. Using these joint properties, Grubler's formula calculates DOF for mechanisms: DOF = m(N-1) - Σ(m - fi), where m=3 for planar and m=6 for spatial motion. This formula assumes independent joint constraints.

Degrees of freedom (DOF) define the independent movements a mechanical system can perform. In three-dimensional space, any free object has six DOF: three linear movements along x, y, and z axes, and three rotational movements (yaw, pitch, roll). Linear movements include forward/backward, left/right, and up/down motions. Rotational movements are named from aviation: yaw (rotation about z-axis), pitch (rotation about x-axis), and roll (rotation about y-axis). Different joint types constrain motion differently: revolute joints allow rotation about one axis (1 DOF), prismatic joints permit linear movement along one axis (1 DOF), cylindrical joints combine rotation and translation along the same axis (2 DOF), spherical joints enable rotation about all three axes (3 DOF), and universal joints allow rotation about two perpendicular axes (2 DOF). Grubler's criterion calculates DOF using the formula: DOF = 6n - (j + 1) + Σf_i for 3D mechanisms, or DOF = 3n - (j + 1) + Σf_i for planar mechanisms, where n is the number of links, j is the number of joints, and Σf_i is the sum of DOF permitted by each joint.

The Baxter robot uses modified DH parameters for both arms, which are identical except for reference points. Fixed link lengths (L0-L6) and joint angles (theta1-theta7) define the kinematics. Joint limits prevent collisions: joint 4 can only rotate ~150 degrees, while joints 5 and 7 can almost complete a full rotation (~350 degrees). Forward kinematics calculates end-effector position by multiplying homogeneous transformation matrices: A_7/0 = A_1/0 × A_2/1 × ... × A_7/6. Each A matrix is derived from DH parameters. Additional transformations reach the world frame: A_0/world and A_7/world. The left and right arms have identical DH parameters except for the shoulder-to-world transformation, where three signs differ.

Kinematics studies mechanical linkages and their movements. Joints have different degrees of freedom: pin joints allow single-axis rotation (like door hinges), while ball-and-socket joints provide three rotational axes. To describe an object's position in 3D space, six parameters are needed: three for translation (x, y, z) and three for rotation (pitch, yaw, roll). Forward kinematics calculates Cartesian position from joint angles, while inverse kinematics determines joint angles needed to reach a desired position. These concepts form the mathematical foundation for all robotic motion control.