Mastering Unity: Baking Multiple Textures, One Easy Method

Baking multiple textures into one in Unity is a common technique in computer graphics. It involves transferring the details of your shader into a texture, which can be useful if your shader is computationally heavy. Unity offers in-built functionality to bake lightmaps, but only on a per-scene basis. To bake textures for multiple objects, you can use a third-party tool or bake them one by one. This process involves unwrapping a mesh, rendering it to a texture, and saving it to disk. Baking textures can help improve performance by reducing the time taken to bake data and decreasing the size of the generated data.

Bake lightmaps with multiple scenes

To bake lightmaps with multiple scenes in Unity, you can either automate the process or manually bake the lightmaps. Here is a step-by-step guide:

Automated Process:

Use the Lightmapping.BakeMultipleScenes function to automate lightmap builds for multiple scenes. This function will load all scenes, build lightmaps, and handle data splitting by scene. This ensures that light and shadows cast on objects in one scene can affect objects in another scene.

Manual Process:

• Open the desired scenes in the Unity Editor.
• Access the Lighting window and disable the Auto Generate option.
• Select the "Generate Lighting" option.

It's important to note that shadows and GI light bounces will work across all scenes. However, lightmaps and Realtime GI data will load and unload separately for each scene, ensuring that scenes do not share this data. This allows for safe unloading of scenes with lightmaps.

Additionally, all Light Probe data for scenes baked together will load simultaneously, enhancing lighting on moving objects and static LOD scenery.

Bake occlusion culling data with multiple scenes

Unity's built-in occlusion culling feature prevents the platform from performing rendering calculations for game objects that are completely hidden from view by other game objects. This feature is disabled by default, as it can be expensive, requires tweaking for each scene, and is not appropriate for all scene types.

To bake occlusion culling data with multiple scenes, you must first open all the scenes that you want to bake. Next, go to the Occlusion Culling window by selecting Window > Rendering > Occlusion Culling. Then, select the Bake button. Finally, save the baked scenes to make the scene-to-occlusion-data reference persistent. This will save the occlusion culling data into a single asset called OcclusionCullingData.asset in a folder matching the name of the current active scene.

If you load a scene additively and it has the same occlusion data reference as the active scene, the static renderers and portals that cull information for that scene will initialize from the occlusion data. This means the occlusion system will perform as if the static renderers and portals are baked into a single scene.

It is important to note that when you bake occlusion culling data, Unity divides the scene into cells and generates data that describes the geometry within the cells and the visibility between adjacent cells. Unity then merges cells, whenever possible, to reduce the size of the generated data. You can configure the baking process by changing parameters in the Occlusion Culling window and using Occlusion Areas in your scene.

Baking textures in Blender

To bake textures in Blender, follow these steps:

• Unwrap a mesh with a shader applied into UV coordinate space. This can be done by setting the x and y components of the vertex to its UV coordinates and setting the z component to 0, leaving you with an unwrapped mesh in the XY plane at z=0.
• Render the unwrapped mesh to a texture.
• Save the texture to disk.

Additionally, if you are baking textures for a Unity project, there are a few things to keep in mind:

• If you have a model in Blender with advanced materials or material networks, you must bake the model before importing it into Unity. Material networks, where a material is connected to many nodes to form a procedural texture, cannot be imported directly into Unity.
• Baking is also used to generate special maps like occlusion, normal, alpha, and emission maps that can be plugged into the Unity material.
• You can bake your Blender light into the texture to create realtime shadows and match the Cycles texture.
• When setting up your render settings, consider the texture size to ensure it does not look noisy when imported into Unity.

Baking a shader into a texture

Step 1: Unwrap a Mesh with Shader Applied

Start by unwrapping a mesh with the shader applied into UV coordinate space. This process involves mapping 3D vertex coordinates to their corresponding 2D UV coordinates. To do this in a vertex shader, set the x and y components of the vertex to be the UV coordinates, and set the z component to 0. This will result in an unwrapped mesh in the XY plane at z=0.

Step 2: Duplicate and Adjust the Shader

Duplicate the shader you want to bake and adjust the vertex positions using the following line of code:

V.vertex = float4(v.uv.xy, 0.0, 1.0);

Applying this new shader to your original mesh will display the unwrapped mesh.

Step 3: Render the Unwrapped Mesh to a Texture

To render the unwrapped mesh to a texture, you can use orthographic cameras. Orthographic projection ensures that there are no depth cues, and the size of an object in the rendered image remains constant regardless of its distance from the camera. This allows for drawing a perfect 2D UV grid without any distortion.

Step 4: Attach a Script to the Camera

To initiate the baking process, attach a script to the camera that will handle the baking logic. This is done because you want to draw your mesh using Graphics.DrawMeshNow after rendering the scene. Access to the OnPostRender function is required for this step.

Step 5: Create a New Render Texture

Create a new render texture by using the following code:

Mesh M = objectToBake.GetComponent().mesh;

RenderTexture rt = RenderTexture.GetTemporary(width, height);

Step 6: Set the Active Render Target

Set the active render target by using the following line:

Graphics.SetRenderTarget(rt);

Step 7: Save the Last Camera State

Save the last camera state by using the GL.PushMatrix() function.

Step 8: Load an Orthographic Camera

Load an orthographic camera using the GL.LoadOrtho() function.

Step 9: Set the Active Material

Set the active material to the unwrapping material you created earlier by using the following line:

UvMaterial.SetPass(0);

Step 10: Draw the Mesh

Draw the mesh using the Graphics.DrawMeshNow function. The matrix does not matter in this case, as you are not using it for any projection in the shader:

Graphics.DrawMeshNow(M, Matrix4x4.identity);

Step 11: Save the Texture to Disk

At this point, you should have the baked shader texture map in the render texture. Convert the RenderTexture to a Texture2D and then encode the result to a PNG format. You can then save the texture to disk.

Step 12: Address Artifacts

When using your new texture as _MainTex on a default Unity material, you may encounter black artifacts around the edges of the UV islands. This issue arises due to the texture being baked using exact UV coordinates, without considering the sampling variances that occur during texture sampling at the edges.

To resolve this problem, implement an "island border expansion" technique, which involves blending operations to expand the border. One approach is to perform a second dilation pass on the output texture, which will help expand the textures smoothly.

Step 13: Consider Other Improvements

While the above steps cover the basic process of baking a shader into a texture, there are always opportunities for further improvements and optimizations. For example, you can explore using 3D textures or improving the user interface and functionality of your editor.

Baking lightmaps for prefabs

Firstly, it's important to note that lightmaps are scene-based in Unity, which means lightmaps will only build and load with scene asset bundles. This doesn't mean prefabs can't have lightmaps, but they will likely depend on the scene asset bundle.

One method to bake lightmaps for prefabs is to use a script, such as the "Prefab Baker" script provided by GitHub user nukadelic. This script can be added to any game object or prefab, and it will store lightmap references relative to each rendered component inside the prefab. To use this script, open the baker window (Window -> Prefab Baker), and Unity will bake lightmaps for the current active scene. The resulting image files will be moved to the target prefab folder.

Another script-based method is the "PrefabLightmapping" script by GitHub user Ayfel. This script is used through the Assets tab in Unity. Place your prefabs in the scene with this script at the root, set up your lighting, and then go to Assets -> Bake Prefab Lightmaps. After the bake is processed, you can spawn your prefabs in different scenes, and they will use the lightmapping data from the original scene.

When baking lightmaps for prefabs, it's important to ensure that the lighting settings of your bake scene match your level scene. This includes matching the skybox light source and directional lights. Additionally, when baking multiple prefabs, it's recommended to bake one prefab at a time or place them far away from each other, as closely spaced prefabs may affect each other's lightmaps.

By following these steps and considerations, you can successfully bake lightmaps for prefabs in Unity, allowing you to add lighting details to your game objects and enhance the visual quality of your scenes.

Frequently asked questions