Search Unity

Creating a character with the help of Visual Effects Graph was an interesting challenge for the Unity Demo team. As someone who spent a lot of time in his career waiting for renders to finish, Demo team’s Technical Artist Adrian Lazar has appreciation for the creative options made possible by real-time authoring. Read the post below for his detailed breakdown of the process behind the character Morgan, as well as useful tips for anyone doing VFX in Unity.

My name is Adrian Lazar and I’ve been working in the computer-generated graphics industry for the last 18 years or so, starting with post-production in advertising and transitioning to real-time graphics with game development in 2009. I have a generalist background and in the last few years I’ve been taking more technical art tasks – this helped me ship my own indie title together with a small, but talented team.

When I joined Unity’s Demo Team in early 2019 as a technical artist, we were getting ready to release the first part of The Heretic so I helped with some finishing effects. Soon after that we started talking about Morgan, the god-like, VFX-driven character introduced in the short film 2nd part.

On the storytelling side, Vess (Veselin Efremov, writer, director and creative director of The Heretic) had some clear requirements: Morgan needed to morph between multiple states, calm and angry, female and male or a combination of these, grow in height multiple times over, crumble, catch fire, and more.

Regarding the appearance, on the other hand, Vess intentionally left it quite open for exploration and experimentation. We had some early concepts created by our former colleague Georgi Simeonov, but those didn’t get into the vfx and shape-shifting aspect of the character, both fundamental to the final look – this meant that I had a pretty blank slate to start which was challenging but fun!

Concept art

I started my initial tests in Houdini 3D, a tool I feel comfortable with from before and that gave me a good opportunity to explore and bounce some initial ideas with Vess. 

Of course, for the production of the real-time short film, we wanted the effects that build Morgan to be developed inside Unity, so that it would be easy to iterate on the character and make sure it reacts correctly to everything else that happens around it. Therefore I had to look for a different solution and move away from pre-simulating the effect in another software.

One thing that gives me joy as being part of Unity’s Demo Team is having the chance to stress test, improve, and sometimes develop tools and processes that our many users can make use of daily.

Early tests video

In Morgan’s case, the opportunity was two-fold: create a complex VFX-driven character that runs in real-time, and equally important, take a first step into real-time authoring of complex effects. This was very exciting for me.

Just think about it, being able to develop and iterate on the character look in the final environment, from the desired camera angle and with the final lighting, post-processing, and other VFX! This is a dream that would have been unthinkable only a few years back.

It was not a smooth ride, but with a good team effort, we achieved both.

And so, with a visual look open to experimentation and with real-time playback and real-time authoring being the two technical goals, I turned to a Unity tool still in its infancy back then: the Visual Effects Graph developed by Julien Fryer and the Paris team.

The VFX Graph was still quite new at the time, and had a long road ahead until you could really use it for true & deep real-time authoring. However, the benefits it promised were huge. I was excited about not having to wait for the effects to be simulated in DCC, exported & evaluated in Unity then back to DCC for tweaks.
As a team, we knew that we wanted to be able to do changes until the very end, sometimes hours before the final deadline, and why wouldn’t we – this is one of the promises of real-time graphics.

One of the earlier versions of Morgan with particles flowing across the body

What came first, the visual look or the tech?

It was a back-and-forth familiar to those working on both: first, you need to have an idea of what you want to achieve, then you need to build the tech for it, but, as with any other creative process, things are rarely straightforward. Ideas are changed and adapted in the process, sometimes due to creative direction, other times due to the tech restrictions. 

To complicate things even more, we were in uncharted waters with a tool that hadn’t been used at this scale before, working towards real-time authoring of a complex VFX-driven character. 

The second major version of the character

Second version morphing effect


So the tech and the look-dev closely followed each other and when I had both it was great, fast iterations, fast experimentation, and just overall lots of fun. This creative freedom was addictive, with the visuals changing direction in a manner that was closer to working on concept art rather than on a production.

One added benefit of fast experimentation is that you can quickly change directions and repurpose a test, as it was the case when I was working on some details across the face. It didn’t turn into anything that was useful for that purpose, but it inspired a new direction for the calm version of the hair. 

Hair evolution


But there were a few times when I got stuck because one part couldn’t advance without the other. If I didn’t know where to take the character creatively or I couldn’t find a way to do what I wanted with the tech I had, things couldn’t move forward.

Luckily my colleagues were there to help, so here’s a shout out to them:

  • Vlad Neykov (Lead Graphics Test Engineer) was a fantastic resource, answering patiently all my questions and contributing with ideas about how to solve different technical problems.
  • Julien Fryer (VFX Graph Lead Programmer) helped optimize Morgan for The Heretic. Stress testing our tools using internal productions like The Heretic allowed us to discover new opportunities for improvement. Morgan’s performance requirements led to the development of an LOD system by Julien which will be available soon to all of VFX Graph users.
  • Paco (Plamen Tamnev, 3D Artist in the Demo Team) provided a much needed visual pass over Morgan – working with him was a great experience.
  • Krasi (Krasimir Nechevski, our Animation Director), who led and supervised the rig and animation of the character, and even performed the motion capture, had invaluable feedback for how the effects in the meteorite and the impalement shots should behave.

After 3 major versions and countless smaller experiments, the final version of Morgan was finally emerging, just as we were getting close to the final deadline.

Final version of Morgan

Morgan’s main features

  • VFX Morphing: The effects covering Morgan can be morphed between a brighter version and a darker one. This is not (only) a color change. There are two separate sets of systems, each with its own geometry, density, color, effects etc. The idea was to make the effect similar to a skin layer being peeled or shed off but without making it look gross or graphic. During the morph particles are being expelled from the body and the face also has an emissive edge outlining the change. There are multiple options of customizing this effect in real-time, including changing the colors and meshes for the body, how many particles and being expelled, how those look, and more.
  • Body Morphing: Independent of the VFX morph, the body can be morphed as well using blend shapes, changing from female to male, with the effects adapting to the new shape.
  • Fire: While it looks more like ambers than proper fire, this highly customizable effect can be used to add an extra layer of intensity when required. It was the last effect built, just a few weeks before the final deadline.
    The contribution amount can be set for each body part (helmet, head, eyes, body & cloth), the direction and turbulence can be modified in real-time and you can also change the color gradient of the fire between the two states of the morph. You can also choose between three output modes, lit mesh (used in The Heretic), unlit (used in Morgan standalone package) and screen space blur/distort – an experimental mode that didn’t make it in the final video but is still available in the Morgan Asset Store package, under fire options. 

The fire effect started as some sort of energy burst

  • Crumble: As the name suggests, Morgan can crumble into pieces, with several options for how this can happen.
    The effect is using a starting point that the user can set (for The Heretic, it was the tip of the right index finger) and uses that origin position to create a radial gradient across the entire body. That gradient is being modulated by two noise masks and the final result is used to drive two sliders, Crumble A and Crumble B. The idea of having two sliders was to make the crumble effect a bit more controllable during animation, as Crumble A runs only across one of the noise patterns and doesn’t destroy the body completely. Crumble B can be animated with a small delay to make a complete destruction.
    After the crumbling effect is triggered, you need to use either the Reset or the Recompile VFX Graph option to bring the character back to its previous state. This is required because the crumbling activates a few physical forces under Update. That means that the previous state cannot be played back, only reset.

For The Heretic short film, we wanted a more physical destruction so we combined this crumble effect with a simulation exported from Houdini.

Early crumble tests

  • Debug: Being able to debug properties early on was crucial for being able to experiment with different versions of this character, for example, you can use the debug option to see the noise masks I was describing above. Debug options were built alongside each main feature.
  • Realtime Customization: Each of the features mentioned above has several customization options exposed in Morgan’s Inspector. In total, there are over 300 parameters that can be animated over time as you desire.
  • Other Related Effects: While most of the time was spent on Morgan’s character, there are also 2 other big effects: the meteorite when part of the arm moves towards Gawain and the spikes impaling him.

Meteorite effect WIP

Creating the final version of Morgan

Morgan is made of 17 visual effect graphs each covering a different part. We did this so that it would be easier to manage them.

First, we needed the particles to spawn on the skinned mesh and follow it during character animation. As skinned meshes aren’t yet supported by default in the VFX Graph, we had to find another way around it. 

The position, normals and tangents for the base meshes are rendered in UV space, which are then set as texture parameters in the VFX graphs – this allows us to position and orient the particles correctly on the character.
The vertex color and the albedo texture are also rendered in UV space – these textures are used to manipules certain properties like size, scale, angle and pivot.For the Morgan package, the process of generating the textures was greatly improved by my colleagues Robert Cupiz (tech and rendering lead for The Heretic) and Torbjorn Laedre (principal engineer at Unity Demo Team).

A custom editor centralizes all the graphs making up Morgan – this makes it easy to update shared properties fast. There are about 300 parameters exposed but there’s no real limit for how many can be added, however having too many parameters in the interface can make it less practical to work with.

One of the 17 graphs making Morgan

Unity VFX Graphs tips to keep in mind

  • Using animation curve samplers is a quick way to add different kinds of ease in and out for animations, but also delays. They are very versatile and I have used them a lot, usually to drive a lerp between two values, being floats, vectors, colors etc.
  • Tying multiple properties and actions to a single parameter is really powerful. For example, the fire intensity slider drives multiple properties related to the fire. Again, it’s a matter of balancing convenience and speed vs granularity of what gets exposed in the end.

Fire effect evolution

  • Subgraphs are great for reusing the same nodes across multiple graphs, but be careful at what point in development you add them. The way they’re currently implemented, each time you update and compile a subgraph, all the graphs using it get recompiled. Depending on how many and how heavy the main graphs are, it can take a long time for them to recompile. My suggestion is to add subgraphs when you have tested the logic in one graph and if it happens that you need to do frequent updates to the sugraphs, it might be faster to copy-paste the nodes on one of the main graphs, do the changes, and then copy-paste them back in. Not that convenient, but I had to do it on several occasions because the compilation time across all the graphs for each tweak was too long.
  • For most instances, I find the sliders for exposed parameters to be more user friendly than regular numerical inputs. They feel more fluid and natural during tweaking and you can use the range to keep the user between some values that are safe not to break the effect.
  • Every parameter of a graph can be exposed so that the user can change it from the Inspector but that doesn’t mean it should be done. Be careful not to drown yourself or the person who will use the effect in too many options. With Morgan, I went through many changes over what was exposed, searching for a good balance between accessibility and power.
  • Although not a technical tip, something that I underestimated was that solving both the technical and the artistic challenge was more difficult than the sum of the two combined because of how interlocked these two were in this case.

Download Morgan asset

The best way to learn more about Morgan is to download the standalone package and play with it. You can find more blog posts and videos about the creation process behind this project on The Heretic landing page.

For someone who has spent a long time waiting for simulations and renders to finish, this realtime revolution that is reshaping so many industries is a dream come true. I’m looking forward to the next challenge we’ll pick up.

5 replies on “Making of The Heretic: The VFX-driven character Morgan”

Awesome post and information, thanks for that!
One point that clearly comes out: Unity has so much potential that could be used, if the demo team wasn’t only a demo team, but a game team, building actual released games.
Every experience and improvement you get/inject on the way of development, the Unity users would benefit from that.

Maybe you positions allows yout to push internally towards that goal…

Thank you for the detailed breakdown! Love all the little tips and tricks you mentioned. I’m excited to download the sample and pick it all apart myself 😄

Deja una respuesta

Tu dirección de correo electrónico no será publicada. Los campos obligatorios están marcados con *