When I saw there was a “Unity Authorized Course” on cinematography, it immediately caught my interest. As a huge fan of Timeline and Cinemachine, this course looked to be a worthwhile investment of my time. This new course makes a grand promise of showing you how to make cutscenes, how to make a stealth game, and finally, how to blend the two into one cohesive game. The author Jonathan Weinberger is a self-taught software engineer and has developed many games with Unity. Weinberger was kind enough to provide me with access to this course. Here are my thoughts.
Unity’s Timeline feature allows you to create a sequence of events that can be played back. This has a variety of uses such as creating cutscenes or an instant replay mode. Timeline was added as a feature for Unity 2017.1. Cinemachine, on the other hand, must be downloaded from the Unity Asset Store (although it looks like they are adding it to the Package Manager). Cinemachine allows you to change camera behavior. It comes with a variety of features that bring you one step closer to being a filmmaker such as adding Perlin noise to the camera to give it a natural shake or the “Free Look” feature which creates an orbital guide to which the main camera follows around an object (perfect for a racing game or third-person shooter). To get a better understanding of just what exactly these features are capable of, here is a short film, ADAM, made using Timeline and Cinemachine (Unity has released some of these assets for free on the Asset Store).
On the surface, this course seems to offer everything and more: meticulously crafting cutscenes frame-by-frame, making a stealth game from scratch, and then incorporating those cutscenes into the game. During the first couple of sections, it does seem to be heading in the right direction. The course gets off to a good start: walking through creating materials with a before-and-after already placed in a pre-made scene (included with the course). The author asks you to follow along as he analyzes a set of materials on a door or pillar and then tries to re-create the look on a neighboring object from scratch. There is also a brief introduction to lighting, going over reflection probes and different ways to build scene lighting. Along with this is some basic coverage of the comparative performance of using reflection probes vs. Screen Space Reflection. The issue is that there is no further coverage, and that’s a massive shame because lighting is such a big part of cinematography. Included with the project files is a finished scene (minus the actors, which you must place). For a course on cinematography, it seems like a tragedy to have included all of the finished lighting and to have the post-processing already complete. If you’re going to call a course “The Ultimate Guide to Cinematography with Unity” then you must give a comprehensive curriculum that includes the relevant parts of cinematography in Unity: lighting and post-processing with adequate depth at the very least.
Once the course dives into cutscene making, things start to take shape. The course provides Director’s notes, which are professional drawings that act as a reference for how the shot should play out (angles, panning, etc.). I do feel like this part took an intermediate-first approach, as the pace moves quickly; however, there’s so much practice in making cutscenes that beginners should eventually feel like they’re starting to grasp concepts. Creating cutscenes is a very meticulous process, and while the author could have shown the process only once and then omitted parts for repeated work, he goes the extra mile by painstakingly showing every tiny detail he put into bringing the Director’s notes to life. This section has this re-occurring workflow: analyze director’s notes, block out the scene, establish the cinematography, and finally playback the scene to confirm accuracy.
While the coverage of Timeline is good overall, the Cinemachine coverage is very lacking (basically no features are covered). I could see an argument being made that not all features fit for this specific game, but at the very least, there should have been some examples shown (this is an “ultimate guide” after all). One Cinemachine feature that definitely should have made its way into the course was Clearshot. The author builds a complex system of camera switches as the player walks through invisible trigger colliders; however, this could have easily been replaced with the Clearshot feature. This is a dynamic feature that switches to give you the best view of the player, which is essentially the goal of that section of the course. By comparing these two methods, some insight could have been provided by showing the efficient workflow of Cinemachine.
There’s such a rushed feeling throughout most of the course. The pacing itself is not what feels rushed, but the lack of time taken by the author to plan things out, execute, refactor, and explain everything well enough to have any substantial learning going on. This is especially the case for most of the coding sections. Brief videos and some pseudo-code do a good job at giving a rough outline for what’s to be done with code; however, it isn’t enough. The author frequently codes without adequate planning, which results in numerous issues including bugs, very poor readability, and the constant need to overhaul the code (which tends to be done haphazardly here). There is also a complete lack of refactoring, which could have drastically improved code readability and prevented such rigid and fragile code. This spaghetti code is more what I would expect from something made for a 48-hour gamejam. At one point, I counted five nested if-statements. The author makes no point of bringing up why this is bad (and unnecessary), and he also makes no effort to improve things.
His API research has its heart in the right place. He explains what he wants to do, does a Google search, and walks through the Unity Docs. There are some occasional hiccups (e.g., not noticing the namespace required, which is displayed at the top of the page he is on, and then spending some time looking elsewhere for it), but he did an overall good job. One final thing I will say about the coding sections is that the author did a good job at covering a couple of design patterns (Singleton and Observer). Here, lectures are kept brief and to the point. Asynchronous events also receive good coverage during the loading-bar progress lecture.
Too often, instructions are given in the least efficient way possible. For example, the stealth game requires guards that must be avoided. All of the guards share the same behavior and therefore all share the same prefab; however, the author places 3 instances of the prefab in the scene and then edits one of them doing things, such as adding components. He then repeats all of those steps for the other two guards. The more efficient solution was either to make those changes to the prefab or make the changes to the first instance and then apply changes to the prefab so the other guard objects would automatically inherit those components. This is only one example of a lack of prefab coverage. On top of doing things inefficiently, the author also sets himself up for many problems. In order to create navigation points for the guards during the AI section, here is the author’s workflow: duplicate a guard object, move it to the position to be navigated, and then remove components one-by-one. Just when the author thinks everything is working, he forgets to realize the new nav points inherited the guard tag and thus are causing issues. This is probably the least efficient way to create what is essentially an empty game object. When creating “eyes” for the guards (box trigger colliders), the author creates the first as you’d normally expect, but then oddly copy-pastes the collider object and moves the transform to be on the next guard. This is not only extremely inefficient, but the vision colliders are then not even consistent between guards unless placed in precisely the same location for each guard. This process is setting beginners up for disaster. Once again, just applying changes to the first instance changed will solve this issue.
“Too often, instructions are given in the least efficient way possible.”
Other concepts such as animation are covered well. Instructions don’t get too much depth and so if you’re actually interested in becoming competent in cinematography I seriously suggest you find a learning resource that focuses on animation (for example, root motion is important to know). The author does a good job at actually blocking out scenes for the most part. Cutscenes are staged by blocking out the scene with animated character models, which the author then covers how to get the animations running.
While seeing someone make mistakes can be a valuable lesson, I found the author made way too many. This resulted in him often getting confused or backpedaling, which also has the effect of confusing the viewer. There is also a lack of adequate follow-up by the author to acknowledge the mistakes he made and how he might prevent them in the future.
Beyond the course content, the editing is good; however, the course only comes in 720p, which feels a bit below the current standard. Videos are broken down into much smaller sections than I usually see. The major benefit is that each video has more of a sole focus and so I can skip something if I know how to do that step. For example, say I know how to set up an animation controller. I could then skip this video and start on the next one. Most courses tend to have longer videos which cover several topics. If I only want to see one of those topics then I would have to scrub through the video to find them, which can get frustrating.
“Beyond the course content, the editing is good.”
A small note for any authors reading this: please stop referring to things in the Unity interface as “this”, “here”, or “it”. For example, don’t say “OK we’re going to click this and drag it here. Drop down that and place it there.” This is extremely frustrating for two major reasons. One: if I’m following along visually but you do something quickly I might miss something and your description told me nothing. Problem two: if I’m not following visually because I know the interface like the back of my hand then I have no clue what you’re doing. Call out parts of the interface appropriately and again with each repeated instruction. I don’t want to re-watch parts of a video multiple times because of these reasons.
While I would have loved to see way more actual cinematography discussion (color, aspect ratio, shot composition), I understand that this isn’t film studies 101 and that was not promised by the curriculum so I can’t necessarily take points off. The Rule of Thirds is touched at a surface level, however, which was a nice touch that introduces the Cinemachine guidelines (a grid that helps with planning camera angles).
The official Unity Learn tutorials eclipse this course in terms of teaching Cinemachine. The course, on the other hand, does a good job at showcasing how to put everything together into a full game. Going in, I knew Timeline and Cinemachine, but this course showed me how to better incorporate my cutscenes into actual game-play.
The Ultimate Guide to Cinematography with Unity isn’t exceptional at teaching any of its numerous topics, but rather it succeeds in joining techniques that will help you incorporate cutscenes into actual game-play. Where the course falls apart is with how frequently things are taught in the least efficient way possible to the point where it’s harmful to beginners. If you are a Unity veteran, this course might serve as inspiration for how to put all of the pieces together; however, I predict it will frustrate more than it inspires as those with experience will probably see how often concepts are executed poorly. Does everything work in the end? Yes. At a surface level. The issue is that the journey to get there is a rough one, and it will form so many bad habits in beginners while misleading them into believing they are doing things the right way. It’s not all bad here, but the bad parts hold the course back from greatness.
- Depth is added at the right timing (i.e., once the basics are down)
- e.g., adding Perlin noise after some practice creating shots
- Good video editing
- High-quality assets created specifically for this course (available on the Asset Store)
- Adequate Timeline coverage
- Meticulous cutscene practice
- Director’s notes
- Up-to-date (Unity 2017.3)
- Team Collab coverage
- Most Cinemachine features are not even brought up, let alone taught (Freelook, Clearshot, etc.)
- Much content related to actual cinematography provided in the starter files rather than being taught (Post-processing, lighting)
- Weak C# coverage
- Entire course felt rushed
- Instructions occasionally lacking in explanation
- Lack of planning results in many issues during coding section including:
- More than an acceptable amount of bugs
- Poor code readability (e.g., 5 nested ifs)
- Haphazardly cut-pasting sections of code until something works
- No follow-up to show where things went wrong and how to do it better/correctly
- Lack of refactoring
- Frequently shows the least efficient way to do things in Unity (e.g., doing the exact same thing to three instances of a prefab. This occurs more than once.)
- Poor video quality (720p)
- For such a complex project, the source should have been provided
Get the Course – Course Link
More from Unity – Link