All content in this course uses:

Optimize realtime lightmaps

In this tutorial, you will improve the auto-unwrapped UVs generated by Unity’s Precomputed Realtime GI.

Now that you have excluded suitable objects from the lighting precompute, you can begin the work of reducing the number of remaining Charts by optimizing UV unwrapping. 

Charts are created to encompass the UV lightmap coordinates of a Static Mesh Renderer. The number of Charts that an object requires is therefore largely determined by the number of 

 (pieces) needed to unwrap the object in question. Unwrapping is always a tradeoff between distortion of the texel distribution on geometry faces, and the number of shells required for sufficient texture coverage.

Overview

Unity’s sophisticated unwrapping algorithms will often achieve good results without your intervention; however, sometimes you need to provide a little guidance. It is therefore important that you understand the theory and process behind automatic unwrapping.

Let’s review three different examples of how the UVs on an object can be projected or 

In this first example, the result is largely free of distortion. The checker pattern used as a texture is mapped in such a way that each tile of the texture remains square in aspect. If you imagine that this checkerboard was a lightmap (an ‘image’ of the lighting applied to the object), you would get a result that looked visually correct and without distortion. 

However, you need to use six UV shells to get this coverage. As a result, you would get six Charts using Unity’s Precomputed Realtime GI system. Regardless of the size of the object, each Chart would require a minimum of 4x4 texels, meaning that this object would use at least 96 texels irrespective of resolution.

In the second image, there is a different problem. The object’s UV texture coordinates have been projected so that there is one complete UV shell covering all faces. 

While this would be optimal in terms of the number of Charts required to cover the object, the visual results would be unacceptably distorted. You would likely see ‘smearing’ of textures applied across the surface of the object. The faces of the object also overlap in UV texture space — meaning that if you were referencing a lightmap, the lighting from one side of the object would be displayed on opposing faces. This method of unwrapping the object will not give you an acceptable result.

The third image shows an example of an ideal unwrap. The result is free of distortion: the tiles of the checkerboard texture have remained square in aspect. We have also succeeded in covering all faces of the object while only outputting one UV shell. This has been achieved by joining, or 

, UV edges which correspond to contiguous geometry edges on the model. 

If you think about this programmatically, what did we do to achieve an ideal unwrap? 

First, we have made our UV projections orthographically onto the object in order to create our individual shells. 

We then evaluated these shells for edges which are shared in the geometry of the corresponding object. 

Where shared edges were found, we moved and stitched those shells to the partner edges of their neighboring shell. 

This is what Unity’s unwrapping algorithms attempt to do automatically with Static geometry. 


Understanding Unity’s unwrapping algorithms

Before working to optimize your unwrapping and lightmap Charts, you need a way to visualize them in the Editor. Charts are generated during the unwrapping stage of the mesh import pipeline. For Precomputed Realtime GI, these Charts are then packed into atlasses during the 

 stage of the precompute process. This is to ensure that they don’t overlap. 

You can only see a preview of your Charts once the Geometry stage of the precompute has completed and the visualisation data has been saved.

 If you are working with version control as part of a team, please be aware that this information is cached locally. This means that a precompute must be carried out on your local machine before the various diagnostic Draw Modes become available. 

There are two different approaches you can take to visualize the Charts.

One way to quickly visualize your Charts is to use the 

 Draw Mode in the Scene view. Using this mode, Charts can be seen as different-colored panels overlaid with a checkerboard texture representing the corresponding lightmap resolution. To use this mode:

In the top left of the Scene view, use the 

  If you have Auto Generate mode enabled (

), changes to unwrap parameters will be calculated automatically and the Scene view will be updated with the results.
 

Option 2: Use the Lighting window Preview pane

It can be easy to miss Charts in the Scene view when working with complex objects. By using the Preview pane in the Lighting window, you can view all the Charts used by an individual object. This can help you to more accurately assess the unwrapping of these objects, which will help you to reduce Chart counts in the scene. 

 In the Hierarchy, select the object that you wish to view.

foldout, and double-click the lightmap thumbnail.

  In the top right corner of the Preview pane, choose 

The number of Charts used by that object will be represented by colored squares overlaid with the corresponding UV coordinates in light blue.

Visualizing Charts

There are a number of settings that you can tweak to optimize UV unwrapping. All of these settings are per-object. You can access these settings in the Lighting window:

  Select the object that you wish to view in the Hierarchy window.

Unity’s automatic unwrapping algorithms allow users to author lightmap UVs within the Editor. You can use the 

 option to access these controls, which can be found under the Lightmapping foldout in the Mesh Renderer component. 

Enabling this option exposes two properties: 

.You will review these properties later in this tutorial.

In some cases it may be impossible to get an ideal unwrap using the auto unwrapper. You may end up with too many Charts or unacceptable distortion in the lightmaps (visualized as stretched checkering when in the 

Draw Mode). In these cases, it may be necessary to manually author UVs in the UV01 channel of your model file. This is work that needs to be done while in your chosen content creation package. 

 setting to force Unity’s unwrapping algorithms to preserve the shape of the UV shells defined in your model’s UV01 channel. 

It is important to note that these shells will always be repacked to save lightmap space. It is the manner in which the shells are unwrapped, individually, which will be preserved rather than the shell’s position within the lightmap.

You must be cautious when using this approach. In cases where your lightmap UVs contain a large number of UV shells, this option can actually increase precompute times. This is because the UV merging step offered by Unity’s auto unwrapper is bypassed and the manual UV layout is preserved. Remember that the desired outcome is as few UV shells — and therefore as few Charts — as possible, while keeping an acceptable level of distortion.

Unwrapping parameters: Optimize Realtime UVs

Unity’s unwrapping algorithms attempt to simplify lightmap UVs by moving shells and stitching UV edges together. UV shells will only be considered for this operation if shells are within the distance defined by 

. This range is defined in Unity’s world space units. Remember that in the example scene, we are assuming that a unit is 1 meter. 

In many cases, the default value of 0.5 units will give acceptable results. For particularly large objects with large faces, it may be necessary to increase this value. This is to prevent suitable candidate UVs from being excluded from selection by the stitching algorithm.

Increasing the Max Distance will often reduce the number of Charts required by the selected object. Decreasing this value is useful in situations where there is visible stretching of lightmap texels and we may actually need more Charts in order to get the required texel coverage. The results of these changes can be easily assessed using the checkerboard overlay in the UV Charts Scene view Draw Mode. Finding the right balance can often require a little experimentation.

Unwrapping parameters: Max Distance

Lighting UV shells are also evaluated for stitching based on the angle between neighbouring faces of the corresponding mesh. 

 defines the maximum angle permitted between faces sharing a UV edge and is calculated using the internal angle. If the angle between the backfaces is greater than this amount, these UV shells will not be considered for stitching. 

Increasing this value will make it more likely that lighting UVs will be combined by Unity’s unwrapping algorithm. Max Angle can therefore be a good way to reduce the number of Charts required by a selected object. However, sometimes stretched lightmaps can occur when this tolerance is too relaxed. Decreasing the Max Angle will make the unwrapper less likely to combine UV edges, which will result in more Charts but less distortion. 

Again, using the checkerboard overlay in the 

 Scene view Draw Mode is a good way of assessing the suitability of the values you are using.

Unwrapping parameters: Max Angle

In certain cases, the mesh importer may decide to split geometry. This will also affect Charts. For example, if a mesh has an extremely high triangle count it may be more performant for Unity to split it into separate sub-meshes. Often this is for hardware specific requirements, such as reducing the number of triangles in each draw call. Where these splits occur is decided based on areas where there is large variance in the normal angle between adjacent mesh faces, such as hard edges. 

Splitting meshes in this way happens during the mesh import process for your models. Charts can potentially be split during this process as edges that fall within a Chart may be separated, resulting in multiple shells which in turn will require additional Charts. 

Sometimes it is not desirable to split your Charts in this way. The resulting increase in the number of Charts may be detrimental to precompute times, and lighting seams can cause unwanted visual artefacts in the resulting lightmaps. In these cases, enabling the 

 property will prevent the Charts being split for Precomputed Realtime GI lighting. 

Only Precomputed Realtime GI is affected by this option. Splits in the selected meshes are still preserved for other uses in Unity.

Unwrapping parameters: Ignore Normals

Complex scenes can contain hundreds — even thousands — of Static objects. Generating the Chart atlases for all these objects can result in slow lighting precomputes and this can negatively affect the speed with which you are able to iterate on your scenes. 

When experimenting with unwrap settings for objects, sometimes it can be useful to isolate an object of interest in an empty scene where you can iterate quickly with minimal precompute times. The unwrap settings you determine can then be taken back and applied to other objects of that type in the original scene. Working in this way can add up to big time savings when you are preparing scenes for lighting.

Let’s isolate a house object as an object of interest:

Open the LightingTutorialStart scene included in the example project.

  In the Hierarchy, select one of the GameObjects called HouseBig02. These are grouped under Environment > Structures > Houses.

  Copy this object to the clipboard by selecting 

  If prompted to save your changes, select 

 if you are happy with your current scene progress or 

 In the newly created scene, paste HouseBig02 from the clipboard by selecting 

 property to turn on Auto precompute mode. 

Optimize precompute time: Isolate objects of interest

When configuring unwrap parameters, the ideal outcome is to find a combination of values that results in the 

. Remember that distortion is visualized as stretching of the checkerboard texture applied to objects in the Scene view when UV Charts Draw Mode is enabled.

The checkerboard pattern can be used to visualize lightmap texel distribution. Notice in the example below that the checkerboard is relatively consistent across the model — meaning that there is little lightmap distortion.

In this second example, the next example the stretching and warping of the checkerboard indicates that there is some inconsistency in the distribution of lightmap texels. 

Let’s apply what you have learned about UV unwrapping to optimize precompute times on an object in the tutorial project:

In the Hierarchy, select the HouseBig02 GameObject.

 from the dropdown menu to review how the object is unwrapped.  

HouseBig02 is a fairly complex object within our scene, which may justify the use of multiple Charts. However, we may still be able to reduce this number by modifying our unwrap settings. 

Optimize precompute time: Review the object’s UV unwrap settings

There is no one-size fits all solution for unwrapping objects. Unity’s unwrapping algorithms attempt to make sensible decisions based on appropriate defaults, but with some user guidance, it may be able to achieve a more optimal result. 

Let’s start by decreasing the Max Distance:

The precompute process will begin. Following a brief calculation, you’ll see in the Preview area of the Lighting window that the number of Charts has noticeably increased. Checking the Scene view there seems to be little distortion, which is good. Unfortunately, however, this many Charts for an object of this complexity is unacceptable. Remember that more Charts means longer precompute times and reduced performance at run time.

Let’s try increasing the Max Distance value:

In the Hierarchy, select the HouseBig02 GameObject if it’s not already selected.

You now have the opposite problem. The number of Charts has decreased, but at the cost of introducing unacceptable distortion to the lightmaps. You can observe this distortion in the UV Charts Scene view Draw Mode. The distortion appears as streaking or stretching of the checkerboard overlay.

You now know that Unity’s unwrapping algorithm attempts to minimise the number of Charts by merging UV shells together. The 

setting specifies the maximum distance, in worldspace, permitted between UV shells when they are considered for merging. If the shells are further apart than this value, they will not be combined. 

When you decreased the Max Distance, fewer UV shells were eligible for merging. This meant that more individual Charts remained at the end of the process. 

When you increased the Max Distance, UV shells that were very far apart in worldspace were then able to be merged. This resulted in fewer Charts, but this aggressive merging also caused warped lightmap UVs and therefore more distortion in the lightmap output. 

Note that with large objects it can sometimes be necessary to increase the Max Distance in order to accommodate the size of faces within the mesh. Conversely, with smaller objects decreasing the Max Distance might yield better results.

 value of 0.8 gives a good compromise between Chart count and distortion:

 However, there are still some further improvements which can be made.

Optimize precompute time: Adjust the Max Distance

 parameter. Like Max Distance, this value affects the UV merging step of Unity’s unwrapping algorithms. In addition to being tested for distance before UV shells are combined, the unwrapper also tests the angle between adjacent mesh faces. Only edges with an angle below this value will be considered for merging. 

A smaller Max Angle means that fewer edges will pass the test. As a result, fewer UV shells will be merged and the number of Charts will increase. Conversely, a larger Max Angle means that the merging algorithm will be more tolerant of angles between faces. More UV shells are likely to be merged, the result of which will likely be fewer UV shells and therefore fewer Charts. As with the Max Distance, if unsuitable edges are combined due to overly wide tolerances, distortion may occur in the final lightmaps UVs.

When you review the Preview area of the Lighting window, we’ll notice that the number of Charts created is unacceptably high. This is because you are only allowing a deviation of 

 between faces before they are considered for merging. This almost certainly means that no UV shells will pass the test and therefore many Charts will remain following this merging process.

Next, let’s try increasing the Max Angle:

 value and observe the effects of each change in the Preview pane of the Lighting window. 

You should notice that the number of Charts decreases as the value goes up. This is because the angle permitted between mesh faces considered for merging is more tolerant. More UV shells pass the test and will be merged. Consequently, the number of lightmap UV shells is reduced and the number of corresponding Charts decreases. This approach is particularly helpful for reducing Charts on objects with rounded surfaces.

Notice how the number of Charts is reduced in the Preview area of the Lighting window following a brief precompute. 

Optimize precompute time: Adjust the Max Angle

At this stage, your optimized unwrap settings can be taken back into the working scene: 

  In the Inspector window, locate the Mesh Renderer component and select 

  In the Hierarchy, find all the objects named HouseBig02.

 on macOS) and select each of the HouseBig02 GameObjects in the Hierarchy window.

 In the Inspector, locate the Mesh Renderer component.

 (⋮) in the top right of the component.

 to apply the settings you previously copied. 

The modest savings these settings give you can add up to much more significant optimisations when applied across a scene of several hundred objects.

Optimize precompute time: Return to the working scene

Unwrap settings can be stored in a Prefab by applying them to any Static MeshRenderer component that lives within that Prefab’s hierarchy. Alternatively, unwrap settings can also be applied to individual GameObjects within the scene. Unwrap settings applied to an instance of a Prefab in a scene will override the settings stored within the Prefab. This way of working offers you some useful approaches to setting up scene lighting. 

It is often useful to configure a default unwrapping and lighting setup for your Prefabs. If the Prefabs are to be instantiated numerous times, it can save effort to have the unwrapping for that object preconfigured rather than having to specify this repeatedly throughout the scene. 

As a part of the nested Prefabs feature introduced in the Unity 2018.3 release, it is now possible to create 

. A Prefab Variant inherits properties from the Prefab that it is a variant of (which is called the base Prefab). You can override these properties for each prefab Variant created from a base. This can be a very useful way to configure default settings that are suitable for most scenarios and then override these settings in special situations.

For example, if a Prefab Variant will be seen up close within the playable area then it makes sense to use a higher fidelity setting on that Variant. If the Prefab Variant is far away, then it would not make sense to use your lighting budget maintaining the same resource-intensive settings. In that case, a better approach for you to take would likely be to lower the quality of the lightmaps and use more aggressive stitching parameters in the unwrap.

Unwrap settings and Prefabs

It is time to start applying what you have learned about Unity’s automatic unwrapping algorithm to the remaining Static geometry within the LightingTutorialStart scene. Working systematically, it should not take long to set up the scene for significantly improved precompute times:

  Open the LightingTutorialStart scene included in the example project.

  In the Hierarchy window, select the top GameObject found under Environment > Structures.

At this point, you should apply what you have learned about the unwrap parameters and feel free to experiment with different values. Remember to use the UV Charts Scene view Draw Mode in combination with the Charting mode of the Preview area of the Lighting window. This will enable you to find the right balance between lightmap distortion and the number of Charts required. 

The LightingTutorialOptimal scene can be used as a reference in cases where you are unsure. Note that in some cases it may even be unnecessary to change the default unwrap values at all. The default values may actually provide the best outcome.

  Experiment with different values for the unwrap parameters until a balance is reached between number of Charts and lightmap distortion.

  Copy the settings, return to the LightingTutorialStart scene and paste them into all other instances of the same GameObject. Multi-selecting all the corresponding objects in the hierarchy will enable you to use 

 to quickly apply the settings across multiple objects.

  Repeat this process for every uniquely named GameObject in the Hierarchy view.

  Once all of the GameObjects under the Structures group have been optimized, move onto the remaining Static geometry under the Rocks group. 

Working methodically in this way, it should take you no longer than a few minutes to set the unwrap values for all of the Static geometry within your scene. The outcome of this manual preparation will be faster iteration when lighting the scene and better performance at run time.

Apply unwrap settings throughout the scene

In this tutorial, you explored the role of unwrapping in reducing the number of Charts in your project, which can have a significant impact on lighting optimization. 

Next, you’ll complete this learning experience by fine-tuning Lightmap Parameters in the Unity project.

Unity Version 2019.4