Hierarchical & Skeletal Animation in C++
Overview
Hierarchical Animation is a C++ and DirectX 11 project that demonstrates two animation approaches commonly used in game development: hierarchical rigid-body animation and skeletal joint-based animation. The project includes a modular plane built from parent-child components and a robot driven by a joint hierarchy, showcasing transform propagation, animation state switching, and reusable animation architecture.
The project was developed to explore how local and world transformations can be combined to create complex animated motion, while keeping gameplay, rendering, and animation logic cleanly separated.
My Role
I implemented the animation subsystem for hierarchical and skeletal motion, including parent-child transform relationships for modular animated objects. I also developed animation state logic to control robot behaviours and integrated socket-based firing from animated components. The animation code was structured separately from the shared rendering framework, improving maintainability and keeping gameplay-specific animation logic independent from the core rendering systems.
Key Engineering Features
- Hierarchical transformation system using local and world matrices
- Plane model built from rigid parent-child components
- Robot model using an unskinned skeletal joint hierarchy
- Forward kinematics for per-frame bone and component updates
- Animation state switching for idle, attack, and death states
- Lightweight animation blending for smoother transitions
- Socket-based gameplay interactions such as barrel-accurate firing
- Multiple camera modes and interactive scene controls
- Debug-friendly structure for visualising transform behaviour
Technical Highlights
The plane demonstrates hierarchical rigid animation by linking individual components such as the fuselage, propeller, turret, and gun barrel through a parent-child transform tree. Each child inherits movement from its parent while still applying its own local animation, allowing complex object motion to be built from simple component relationships.
The robot demonstrates skeletal animation without mesh skinning. Rigid body parts are driven by a joint-based hierarchy, with forward kinematics used to evaluate poses across the bone graph each frame. The animation system supports state changes and simple blending to avoid abrupt motion changes.
A key focus of the project is the separation of animation logic from the provided DirectX runtime. This makes the hierarchy and animation systems easier to understand, test, and potentially reuse in other engine projects.
Development Goals
The project was developed to strengthen my understanding of hierarchical animation, skeletal motion, and transform propagation in real-time game systems. A key goal was to explore how local and world transformations work together to create complex animated behaviour from modular components. The project also focused on building clean, reusable animation logic that remains separate from the shared rendering framework, making the system easier to maintain, debug, and adapt for future engine or gameplay projects.
Tools and Technologies
C++, DirectX 11, Visual Studio, skeletal animation, hierarchical animation, forward kinematics, component-based modelling, transform matrices, quaternion rotation