Partial ragdoll. Top of the robot's body bounces due to real-time spring physics; both halves still continue to play animation sequences.

This effect is automatically disabled while executing animations that need to explicitly animate the springs.

Full ragdoll, with some omitted constraints to allow it to fall apart.

Thankfully, our awesome artist already made the robot parts individually enclosed and only weight-painted to their inner bones, so there was no mesh stretching going on on separation.

Inverse kinematics for the robot's arms.
They can reach for given target in real-time, interpolating between left and right arm based on change of direction towards target.
We'll have more uses for it down the line.

While the artists were busy working on high-quality models, rigs, and animations, I put together a quick rig for our blockout model to be able to start testing gameplay mechanics with placeholder Mixamo animations.

I bound and weight-painted it to a skeleton from Mixamo to make sure it's compatible.
(Perhaps using their existing skeleton was unnecessary?.. Turns out Mixamo's auto-rigger is pretty smart)

During our graphics class, we were tasked with building a custom OpenGL renderer gradually throughout the semester. This is my version of the final project.

The models were made by me in Blender, I just needed to write a Python script to export the vertices and faces into the format used by our framework.

The project itself is written in C++ and uses OpenGL 4.3.

Active ragdoll (physical animation) in Unreal was somewhat straightforward to set up thanks to online tutorials, but trying to constrain body parts to environment initially caused the skeletal mesh to stretch excessively. No solutions found online.

The issue was eventually resolved by tweaking the physics substep settings. Look at him hang.

This is intended for my personal parkour game project.
(Which is currently on hold. Busy times...)

First project that we've had so far in our current "Curves and Surfaces" math class: rendering a polynomial curve using De Casteljau's algorithm.
Two alternative methods used for calculating the curve: recursive (Nested Linear Interpolation), and iterative (Bernstein Polynomial summation).

Made in Godot Engine.
While GDScript is not nearly as fast as C++, and initially caused stutter when used with recursive method, some simple memoization fixed that.
For the upcoming projects (first of which will be rendering of Bezier curves), I intend to use GDExtension to write the performance-critical parts in C++.

After messing around with active ragdoll on the default Manny rig, I wanted to see if I could apply similar physical animation techniques to some arbitrary skeletal mesh, made by me from scratch.

I ended up creating... whatever the hell that thing is.