This video provides a quick overview to what we'll be doing in Maya, outlining our basic workflow for getting assets into Unity.
Here we cover some of the basics of going between Maya and Unity, and the things you'll need to keep in mind concerning our workflow.
In this video we focus on some scaling concerns that you should be aware of with our workflow going between Maya and Unity with skinned characters.
This video is dedicated to discussing the problem of construction history and how important it is to know when it should be deleted from your Maya models.
Frame rate is a critical concern for animation, as using a film framerate can cause unsightly jitter in your models during gameplay.
As a way to streamline the workflow, we use referencing in our Maya files to allow for edits to both the model and the rig if necessary without having to re-rig, reanimate, or reskin.
The Trax Editor will allow us to break our animation cycles up into clips which can be strung together one after the other to create our final FBX file.
This video overviews the character we'll be using for our controller, discussing how it was modeled and textured. Please note that this just discusses the process. There isn't any onscreen modeling.
In this video we go over each of the animation cycles used with our character, showing how each one works and will be used in the system.
Here we show how to convert each animation cycle into a trax clip, get those strung together, and then reapplied to our model
As one of the final steps, we bake our entire animation directly into the skeleton of our character, allowing us to remove the rig entirely and leave only a skeleton and bound geometry.
Our character done, it is now time to export her into Unity, which we do in this video.
With our FBX now completed from Maya, we can now take a look at creating our Unity prefab with the new file.
We need for the character to be able to swap out for a ragdoll version upon death. In this video we set up the ragdoll version prefab.
The TP_Animator class will be responsible for handling the various animations we'll need for our character. Here we overview the class.
With an understanding of what the TP_Animator class is responsible for in our character, we now go about implementing the basic code.
Of course we want the character's animations to be able to run more than once, and in this video we show
In this video we focus on setting up the behavior to utilize the Use animation on our character, for when she pushes buttons in our upcoming game.
The first part of our jump will be to set up the force that will get our character off the ground, which we take care of in this video.
Now that our character jumps up into the air, the next logical step is to establish the behavior that will pull her back down to the ground, which we establish here.
Gravity can't only be experienced during jumps; our character needs to be able to walk off ledges and fall down as well. In this video, we set up this behavior.
What happens when the character hits the ground? In this video we add in the necessary behavior for landing, so that our characer can properly deal with ground impact.
We now bring in our character's simple sliding behavior. This is a very rudimentary slide, and one should note that there is room for improvement in the behavior.
In this video we take a look at what goes into making our character climb, along with a few of the assumptions we're going to use to make the climb happen.
The climb itself is a multi-stage process. In this video, we go through each of the section of the climb and show how we handle each one.
For this video, we take a look at some of the underlying game objects that will need to be created including the climbing volume, which will be used to control where the character can and cannot climb.
With our setup out of the way, we can begin the coding process of our climb. In this video we handle that implementation.
Our code is now complete, and in this video we take a moment to test out the climbing behavior and check for any potential bugs or problems.
The next thing we need to look at is character death. In this video we handle the initial setup for what happens when our character does something that proves lethal, such as a fall.
We want our character to convert over to a ragdoll at death. in this video we handle the initial portion of the ragdoll setup.
We now finish up our ragdoll setup, placing in the appropriate code to handle the transition from animated model to ragdoll game object.
We now test out the ragdoll system, making sure that everything is working properly and that the transition is nice and smooth when death occurs.
Our next video covers the process of killing the player when she's fallen from too far a height. This will allow us to have a challenge element to gameplay.
In this video we make some adjustments to the input system of our controller, allowing us to better control our character's behavior.
Just to wrap up a few final things, we run some basic tests and make bug fixes on some last minute errors before moving on to wrapping the character up into a package.
In this video we wrap everything up and get our 3rd person character controller into its own Unity package that can be distributed to other people.