This release brings hundreds of updates for Unreal Engine 4, including 129 improvements submitted by the community of Unreal Engine developers on GitHub! Thanks to all of these contributors to Unreal Engine 4.9:
Andrew Zhilin (zoon), Artem V. Navrotskiy (bozaro), Artyom Sovetnikov, Ben Rog-Wilhelm(zorbathut), Ben Wiklund (bwiklund), Black Phoenix (PheonixBlack), Błażej Szczygieł (zaps166), Brad Grantham (bradgrantham), Brent Scriver (FineRedMist), Cengiz Terzibas (yaakuro), chipgw, Christian Radich (yoyohobo665), Christopher P. Yarger (cpyarger), Clay Chai (chaiyuntian), Cliff Jolly (ExpiredPopsicle), Dave Newson (dave-newson), Derek van Vliet (derekvanvliet), Dorgon Chang (dorgonman), ewirch, Felix Laurie von Massenbach (erbridge), Gabriel Hare (GabrielHare), gatools, Hakki Ozturk (ozturkhakki), HueyPark, JaredTherriault, Jason Spangler (Stormwind99), Javier Osset (Xaklse), Jeff Rous (JeffRous), JohnAlcatraz, Kitatus Studios (KitatusStudios), Konstantin Nosov (gildor2), korypostma, Lee Berger (MrCrowbar), Maarten Scholl (maartenscholl), Marat Radchenko (slonopotamus), marynate, Matthias Huerbe (MatzeOGH), Maxim (maxpestun), Michael Allar (Allar), Michael3DX, MiniTurtle, Moritz Wundke (moritz-wundke), Nako Sung (nakosung), Nari Demura (demuyan), Nastenko Michael (deM-on), Nathan Stocks (CleanCut), Niels Huylebroeck (red15), Pablo Zurita (pzurita), Patrick Flanagan (valtrain), Pedja Ljubomirovic (3dluvr), Philipp Smorygo (fsmorygo), Pierdek, Piotr Bąk (Pierdek), Quadtree, Rajko Stojadinovik (rajkosto), Rama (EverNewJoy), Rem (rveilleux), rlefebvre, Robert Khalikov (nbjk667), Russ Treadwell (trdwll), Salamanderrake, Sebastian Witkowski (witkowski-seb), Sébastien Rombauts (Srombauts), Simon Taylor (simontaylor81), Stephen Whittle (stephenwhittle), szyszq, TK-Master, Tobias Mollstam (mollstam), Tomasz Sterna (smokku), user37337, Victor Xie (FTPiano), Vladimir Ivanov (ArCorvus), Will Stahl (merlin91), yamashi, Zhi Kang Shao (zkshao)
Enhanced Support for Mobile Devices
We've been working to greatly improve support for mobile platforms, and this release contains many exciting rendering features to help you create leading-edge mobile titles. New additions include efficient dynamic shadows, movable lights and decals. Expect to see continued improvements to mobile and HTML5 rendering quality in the future. In this release, iOS In-App Purchase functionality has been improved, and we've added Remote Push Notifications and support for CloudKit. For Android, we've added OpenGL ES 3.1, Immersive Mode support, asynchronous audio decompression, and better orientation features. NVIDIA AndroidWorks is now also included to make it easy to get up and running on your device. UE4 now ships with a Flurry analytics plugin for iOS out of the box, too! Many of the new features for mobile devices are also available in your HTML5 games as well.
New: Dynamic Character Shadows for Mobile
Dynamic modulated character shadows from directional lights are now supported on mobile devices!
You can use dynamic modulated shadows even if your scene is statically lit.
To enable this feature, turn on the "Cast Modulated Shadows" option on a directional light!
New: Dynamic Point Lights for Mobile
Dynamic point lights are now supported on mobile devices and HTML5!
These can be used to enhance short-lived visual effects such as explosions, projectiles, particle effects, etc.
Up to four dynamic point lights are supported on each object being illuminated.
Note: Dynamic shadows cast from point lights are not yet supported.
New: Decals on Mobile
Decals are now supported by the mobile renderer!
Translucent, additive and modulated blend modes are supported.
Note: Only unlit decals are supported on mobile and web, currently.
New: Major VR Updates
Steam VR (HTC Vive)
Unreal Engine's SteamVR plugin includes many major fixes to make it easier to use, and more performant.
SteamVR improvements include:
Fix for latency issues that appeared in 4.8 Preview 2+
Support for the standard Motion Controller abstraction, so both Vive controllers can route to the same player
C++ projects are now cleanly supported by the plugin API
Various improvements and bug fixes
Gear VR Updated to Mobile SDK 0.6.0
This revision fixes several major Gear VR rendering bugs and issues present in the 0.5.0 release, as well as some hardware compatibility issues.
New: VR Motion Controller Support
Motion Controllers are now supported through a common abstraction layer in UE4!
This means that motion controller devices will now all be available through a common interface. The HTC Vive controller is currently supported, with more (such as the PlayStation Move) to come soon. Input button presses and triggers can now be routed to a single player from multiple controllers using the Motion Controller key abstraction. Additionally, you can add motion tracking to your project by simply adding a Motion Controller component to your character, which automatically updates anything attached to it to follow the position of your controllers! We recommend that all plugins for motion controllers move over to the new system, so that they can be part of the device-agnostic interface.
New: Experimental DirectX 12 Support
DirectX 12 is now supported as an experimental feature! If you are using Windows 10, try it out by running the engine with "-DX12" on the command line.
Microsoft's engineers added support for DirectX 12 to UE4, and we have worked with them to integrate their changes into 4.9. The feature is still new and is considered experimental. DirectX 12 offers a much lower-level rendering API that is more efficient and allows for rendering commands to be submitted in parallel across many threads, a feature inspired by console rendering APIs. Going forward, we'll continue to improve support for DirectX 12 and look for ways to leverage the new API in upcoming versions of the engine.
New: Full Scene Particle Collision with Mesh Distance Fields
Distance field GPU particle collision allows particles to efficiently collide with the entire scene.
This can be used for sparks colliding with surfaces.
It can also be used for various effects like and snow that accumulates on surfaces,
The Collision module on GPU particle emitters has a new property called 'Collision Mode' where you can specify 'Distance Field.'
In order for a particle to collide we need to have a colliding plane, and this can be extracted very efficiently from the distance field. A single sample of the distance field gives distance to the nearest colliding surface. Computing the gradient of the distance field provides the direction to that surface, and the surface's normal. Putting these together gives the collision plane.
Particle collision using this method is more reliable than the existing Scene Depth collision, which only collides against what's on your screen, restricting it to effects with short lifetimes. However, the global distance field is fairly low resolution so particles will pass through thin objects, and sharp corners are rounded.
As with all distance field features, this requires 'Generate Mesh Distance Fields' to be enabled in the Rendering Project settings. Distance field particle collision is a Shader Model 5 feature, on hardware that doesn't support SM5, the particles will fall back to scene depth collision instead.
Particle collision with distance fields is very efficient - it costs about the same as particle collision with scene depth.
New: Hierarchical LOD Fast Preview and Clustering
Hierarchical Level-of-Detail (HLOD) is a system introduced in 4.8 which allows many objects in your levels to be collapsed down to only a few objects when they are small on screen. This helps you achieve much higher quality levels when viewing objects up close, and faster overall performance for your level. We've made improvements to HLOD in 4.9 and will continue to in future releases.
Fast HLOD Preview
In order to allow for rapid iteration on Hierarchical LOD builds, you can now use the Preview HLOD option. This will create the HLOD Actors with only a visual representation of their bounds and objects without merging and creating the HLODs meshes themselves. Their bounds are rendered according to the Draw Distance setting inside the LOD System settings for the specific Hierarchical LOD Level.
The image above shows both the first and second Hierarchical LOD level clusters popping into view, this gives a clear indication how the level is clustered without having to go through the time-consuming process of merging and creating the Hierarchical LOD meshes. Be aware that this is an initial implementation of the preview system and may tend to change and improve over time.
Custom LOD Clustering (HLOD Volumes)
In order to allow for more granular control over the clustering process for the Hierarchical LODs, you can now place Hierarchical LOD Volumes which will define a cluster for the Actors it encapsulates. Use this to manually define which areas and objects within a level should be clustered together.
New: "Arch Vis" Character Controls
The new "ArchVisCharacter” plugin adds a character class that provides out-of-the-box controls appropriate for architectural visualization applications. It is intended to feel pleasant and natural to control at realistic world scales, and to enable smoother videos and live demos.
You can hook up ArchVisCharacter directly as your Pawn Class, or you can create custom blueprints from it to tweak the movement settings as you see fit.
New: Widget Depth Ordering
Widget Components in screen space now automatically sort based on distance from the viewer, ensuring the closest screen space widget component is always on top of the other components.
We now sort all widget components against one another based on distance to the camera. Previously it was based a manual Z Order, or whoever was added to the viewport first.
New: Area Shadows (for stationary lights)
You're no longer limited to sharp shadows with uniform penumbra sizes. The Lightmass ray-tracer now supports area shadows for stationary lights!
Turn on the "Use Area Shadows for Stationary Light" option to use this feature. The 'Light Source Angle' (or 'Source Radius' for a point light) controls how soft these shadows are.
Uniform penumbra shadows are still better at dealing with low lightmap resolutions, so those stay the default. Previously the uniform penumbra size was controlled with an obscure project setting; now it is controlled by the 'Light Source Angle' property, just like the area shadows are. Double the source angle to get twice as soft shadows, etc.
There's also a new optimization for areas of maps which are only affected by a single stationary light channel (e.g., one Stationary Directional light). Their shadow maps will be packed into a single channel texture instead of a four-channel texture, for 1/4th the memory cost.
New: Ambient Occlusion Material Mask
The new Ambient Occlusion Material Mask feature lets you access Lightmass calculated AO in your material, which can be useful for procedural texturing, for example to add in aging effects and dirt in areas where it would accumulate.
The above screenshot uses an AO mask to blend a dirt layer automatically into corners of the environment.
To use AO mask, you'll need to enable both 'Use Ambient Occlusion' and 'Generate Ambient Occlusion Material Mask' under World Settings -> Lightmass settings, and then build lighting. The other AO controls like Max Occlusion Distance can be useful to tweak the look. (Be sure to set Direct and Indirect Occlusion Fraction to 0, so that this AO will not be applied to the actual level lighting.)
Then, in your material you can access the AO as a 0-1 mask with the PrecomputedAOMask node. This node will provide 1 in occluded areas and 0 elsewhere.
Using the PrecomputedAOMask node is just a standard texture lookup. Enabling the feature adds half a byte per lightmap texel, where the default usage is about 4 bytes per lightmap texel.
AOMaterialMask texture memory can be inspected with the ‘ListTextures' console command.
New: Mesh Distance Field Materials
This feature allows your materials to cheaply determine the distance to the nearst solid from any point in space. There are two new nodes to access the global distance field properties within the material editor.
DistanceToNearestSurface returns signed distance in world space units. Note that the distance will always be near 0 on the surface of an opaque mesh. DistanceToNearestSurface can be used to have effects avoid occluders:
UE4 user Roel Bartstra has already found some interesting uses for this - one to get a soft body look, and another to create flow maps that automatically avoid surfaces.
As with all distance field features, this requires 'Generate Mesh Distance Fields' to be enabled in the Rendering Project settings. Distance field material access is a Shader Model 5 feature. Use a FeatureLevelSwitch material node to provide fallbacks for Shader Model 4 hardware.
New: Improved Distance Field Ambient Occlusion
Sky occlusion gives nice soft shadows around objects lit by the sky, especially important in overcast lighting scenarios, a use case traditionally hard to render at high quality without precomputed lighting. Distance Field Ambient Occlusion solves this for fully dynamic games where both the time of day and environment can change at any time. We've put a lot of effort into improving the quality and performance of the technology for 4.9 and believe that it is now a shippable feature on medium spec PC and PlayStation 4 level hardware with a total GPU cost of under 4ms for a typical game scene!
The previous method did adaptive sampling, so flat surfaces did less work, but this also caused a lot of splotchiness in clean environments.
The AO computations are now fast enough to get rid of the adaptive sampling, so occlusion is much smoother.
The catch is that the new method requires a longer history filter, which can contribute to ghosting, especially when shadow casters are moved. Hopefully this can be improved in the future.
Distance Field AO has been made much faster such that it can run on medium spec PC and PS4. It also has a much more reliable cost now, so that it's mostly constant, with a slight dependency on object density.
In cases with a static camera and mostly flat surfaces, the new method is 1.6x faster. In complex scenes with foliage and a fast moving camera, the new method is 5.5x faster. The cost of Distance Field AO on PS4 for a full game scene is 3.7ms.
The main optimization is the use of a global distance field, which follows the camera around. This is created by compositing all the usual per-object distance fields into a few volume textures centered around the camera, called clipmaps. Only newly visible areas or those affected by a scene modification need to be updated, so the composition doesn't cost much.
Visualization of the texel size of the clipmaps - each clipmap is a different color
The global distance field is lower resolution than the object distance fields, so it can't be used for everything. When computing cone traces for sky occlusion, the object distance fields are sampled near the point being shaded, while the much faster global distance field is sampled further away.
This is a visualization of ray tracing the global distance field vs object distance fields. Surfaces in the global distance field have become blobby and thin objects disappear.
New: Content Browser Advanced Search
The Content Browser now supports advanced search syntax. Unreal Engine 4 is used on many large projects, including some with teams comprising hundreds of developers, and content libraries with hundreds of thousands of assets! These new search features improve the workflow for finding your content on projects of any size.
This augments the existing simple search syntax by providing a way to match key->value pairs from the asset metadata, as well as the following special keys:
Name - Tests against the asset name.
Path - Tests against the asset path.
Class (alias: Type) - Tests against the asset class.
Collection (alias: Tag) - Tests against the names of any collections that contain the asset.
New: Collection Improvements
This release includes many changes to Collections that allow you to help you manage assets in your game such as collection nesting, smart collections and tagging functionality.
Your collections of assets can now be organized into a hierarchy.
Child collections can be created by choosing the "New…" option from a given collections context menu. Alternatively, collections can be parented via drag-and-drop.
Dynamic collections leverage the power of the Advanced Content Browser Search Syntax to allow you to create and share Content Browser filters.
Anything you can do with the Content Browser text search can be saved as a dynamic collection, including referencing other collections (both static and dynamic).
You can create a dynamic collection using the "Save" button to the right of the Content Browser text filter.
Quick Asset Management
You can now quickly add an asset to many collections at once using the new Quick Asset Management check boxes.
These are available within the collections view itself, or alternatively, via the context menu of any selected asset(s).
Collections will now automatically follow any redirectors that they contain, which avoids the issue of an asset seeming to vanish from a collection when it was renamed or moved. Additionally, collections are now considered when fixing up (and ultimately removing) redirectors via the Content Browser.
Improved Status Reporting
Each collection now has a little status indicator at the right hand side of its row item. This changes color depending on the current state of the collection, with each color meaning:
Red - The collection is in some kind of bad or read-only state. See the tooltip for how to resolve the issue.
Orange - The collection is not up-to-date with the latest version in source control.
Blue - The collection has local unsaved changes. This may happen if a save or auto-checkin fails, or if the collection had its redirectors followed.
Green - The collection is non-empty and up-to-date.
Grey - The collection is empty and up-to-date.
Improved Asset Tooltips
The static collections for a given object are now shown as part of its tooltip in the Content Browser.
New: Plugin Creation Wizard
Its now easy to create new C++ plugins for Unreal Engine 4! Check out or new plugin wizard.
The Plugins browser (accessible from the Window menu) now lets you create a new plugin!
You'll be able to give your new plugin a name and select from a few preset plugin types (Blank, Toolbar, Standalone Window).
This will create all of the initial files you need for your plugin to compile and be loaded into the editor
New: Enhanced Curve Editor
We've made many improvements to the Curve Editor to make it easier to manipulate curve keys and tangents.
Middle mouse now also moves selected keyframes or selected tangents
There's now support for selecting and manipulating multiple tangents
Selection now respects control (toggle) and shift (add to existing selection)
Holding down shift will restrict movement to one axis
Navigation: alt-middle mouse pans the view and alt-right mouse zooms the view
New tangent display options: Always show tangents, show tangents for selected points, never show tangents
New pre-post infinity extrapolation options for curves
Make adding keys more predictable
Keys are only added under the mouse when there is only one curve to edit
When multiple curves are available clicking on a curve will add a key inline on that curve, and clicking off of the curve will add keys to all curves
Changed the text of the menu item to make it clear what's going to happen
New: Multiple Return Nodes in Blueprints
A function can now have multiple return nodes. As soon as execution reaches a return the function's execution is terminated. This can be used to return early from a Blueprint function, or to branch and return differing values.
New: Construct Custom Objects in Blueprints
In Blueprints, you can now spawn baser object types (not just actors/components). The Construct Object From Class node takes a class and creates a new object of that type, similar to Spawn Actor From Class (except for types that are not an actor).
The "Outer" input will serve as the new object's owner, which controls the lifetime of the created object.
For actor classes, you'll still use the Spawn Actor From Class node. And for widgets, you'll use the Create Widget node. In a future release we may try to combine these different features.
New: Blueprint Class Defaults
In Blueprints, it is now possible to access a class's defaults through the new "Get Class Defaults" node. This can be helpful when working with data-only Blueprints, giving you access to those Blueprints' values without having to create an instance.
To keep the output pins from growing too unwieldy, use the node's details to show/hide specific defaults
New: Level Blueprint Communication
Level Blueprints can now be communicated with through interfaces. They can adopt and implement interface functions just as Class Blueprints can. After an interface has been added to a Level Blueprint, calls can be made through interface message nodes (using a streaming level as the target).
Use the "Get Streaming Level" node to get the level to communicate with
Since you have to use "Get Streaming Level" to target a specific level, this will only work for sub-levels
New: Optimized Math Expression
We've optimized the Math Expression node so that it is more performant than regular nodes. It is now roughly twice as fast to use a Math Expression node, when compared to a series of operation/function nodes representing the same expression.
New: Blueprint Asset IDs
We've made it possible for Blueprints to load assets on-demand instead of right away. There are two new data types exposed to Blueprints: "Asset ID" and “Class Asset ID”. An Asset ID represents a loaded or unloaded asset, and can be resolved into an object using the “Resolve Asset” node. If the asset was not loaded, then the “Resolve Asset” node returns an invalid object. You can load the asset using the “Load Asset” node. Similarly, a “Class Asset ID” will resolve into a class, and can be loaded with the “Load Asset Class” node.
New: Montage Element Timing Interface
We've added a new panel to the Montage editor to help you control the order that Montage events will fire when your animations execute at runtime.
New: Non-Linear Animation Blending
We now support many different blending functions between animation poses and transitions!
Previously, only linear or cubic blending was supported. Now you can select from many different blending functions: Linear, Cubic, Hermite Cubic, Sinusoidal, Quadratic, Circular, Exponential and Custom. For most types, you can separately control whether you want easing on either the "in" or the “out” of the curve.
The "Custom" option requires a “Curve Float” asset. After creating one, you can assign it in the details panel for the relevant nodes:
This will allow you to specify just about any blend you want to perform. The length of the curve will be normalized and scaled down to meet the specified blend time and any values that are outside of the range 0-1 are clamped back to fit (this limitation will hopefully be lifted soon, watch this space). If a custom curve is not specified the system will fall back to a linear blend.
New: Bone-driven Animation Controllers
This allows a "Driver" bone to dynamically affect the motion of one or more “Driven” bones. This is great for characters that have accessories attached! You can avoid geometry intersecting during an animation, even when a lot of blending is used.
In the above example, the attached accessory (green) has no authored animations, and is being driven in two axes as a function of the character's thigh bone. This is all calculated at runtime, so a blend of animations ends up working quite well here, even without hand-authored tweaking.
You can either set the "Driver" value directly with a multiplier, remap it into a whole new range, or just use a Curve Asset to drive the motion. Using a curve is usually the best approach as it lets you define the response naturally and interactively tweak points/tangents, seeing the changes in real-time.
Here are the new settings for bone-driven animation controllers:
New: Animation Transition Rules
This release contains improvements to animation blending trees, particularly to how transition rules work.
Better handling of animation Asset Overrides
Nodes like Time Remaining in transition rules now correctly respond to changes in animation length due to overriden animations in Child Animation Blueprints. This means that animations referenced by transition rules no longer have to be the same length in every child Animation Blueprint.
Referencing the most relevant animation player
In order to make state machines more maintainable, you can now use a new class of getter that always picks the highest weighted animation from the source state, rather than targeting a specific animation that might change in the future. The following nodes are now available:
Custom Blend Graph Improvements
Additional information is now exposed in Custom Blend graphs to allow them to be used for more than just a one-shot custom transition animation. The following nodes that provide information about the corresponding transition node and source/destination states are now available in custom blend graphs:
You can also use getter methods that reference the asset players, just like in a transition rule.
New: Animation Curve Evaluation Change
Animation Curve Evaluation used to happen in Update phase of animation, but now it is moved to Evaluate phase. This comes with following benefits.
The curve's weight is properly is evaluated with blended weights.
Additive Nodes: Additive nodes will apply the delta of additive curve data from base to the current pose as animation bone transform does
Layered Node: This was a bit more tricky to make it work properly as you don't know which curve is influencing which part of joint. Right now it does provide option of how to blend curves.
Max Weight: It choose the max weight of curves from blended poses
Normalize by Weight: It sums up all weights of blended poses for all curves and normalize to 1
Blend by Weight: It just sums up (weights * curve value)
Curve Evaluation has moved to multi-threading if you're using parallel evaluation
Eventually this will allow us to create a node that can drive curve from bone transform and vice v