Problems with instantiating baked prefabs

Terrain renderer component is null? How is terrain supported, i can't understand the details? can you tell me, thanks very mach!

 

Hi guys. Those scripts are awesome, but what about Lightprobes? Prefab lightmaps are shown correctly, but lightprobes in prefab dont work. Are there way to make lightprobes work in prefabs?

 

I'm also having problems with lightprobes...I'm using realtime GI, is it even possible at all to make them work?

 

static void ApplyRendererInfo(RendererInfo[] infos, int[] arrayOffsetIndex)
{
for (int i = 0; i < infos.Length; i++)
{
var info = infos;
if(info.renderer == null)
{
Debug.Log("<color=red> ===ERROR NO RENDER</color>");
continue;
}
info.renderer.lightmapIndex = arrayOffsetIndex[info.lightmapIndex];
info.renderer.lightmapScaleOffset = info.lightmapOffsetScale;

// You have to release shaders.
Material[] mat = info.renderer.sharedMaterials;
for (int j = 0; j < mat.Length; j++)
{
if(mat[j] != null)
mat[j].shader = Shader.Find(mat[j].shader.name);
}
}
}


If you can't see fog on the assetbundle version. You can use this code. I think we have to reset shaders.

 

I found that when using this script, the lightmap would use a lot of memory. In my case there would be 104 lightmaps, resulting in 460MBs for lightmaps dropping the fps significantly. With my changes, the prefabs check the lightmap for matching hashcodes to determine if the lightmap already exists and can be shared with another prefab. Doing so means that I can have the same number of prefabs for a fraction of the memory. Only 2 lightmaps from 104.

Edit: probably needs updated to get the correct index of any lightmaps that were not found but I don't currently have any that do that so I wouldn't really be able to test it of I made the changes.

 

Hi,
Did anyone ever found a proper solution to the problem?
I'm using Unity 5.5.2f1 and still no built-in solution.
I'm using the original script provided @idurvesh with the Editor Extension and the PrefabLightmapData.cs.
This solution only works with 1 Prefab, but it doesn't work when you work with multiple prefabs. I've tried everything, all the settings suggested here, baked all prefabs on the scene,the lightmaps are always broken when the prefabs are instantiated.

After I baked my prefabs on the scene they look fine but once they are instantiated the Lightmaps are incorrect.

Does anyone have an updated version of these scripts that actually work. I've spend countless hours on this already and it's really frustrating. I don't understand how Unity Team, knowing that this is essential for mobile(btw my game is for Android) have not come up with a proper solution for this. I understand it was removed on Unity 5 for xyz reasons, but they should provide a working example.

Note to Unity Team: Please noticed that assigning lightmaps manually is not a doable solution when the Prefabs are to complex or multiple prefabs are used.

Any help, guide or direction is greatly appreciated. Thanks in advance.

 

I tried that one without success. There are many in this long forum with slight changes. What's currently working for me is the one I posted in post number 300. If that doesn't work for you then just have a read through and give some other ones a go.

I really wish Unity would implement this functionality properly, but for now the scripts in this forum seem to be the best option(s).

 

Thanks @Astiolo. I'll give it a try today afternoon and I'll report back. Do you have any specific settings on your Light baking settings that you suggest implementing with this script.

 

Hey @Astiolo. Anything special I need to do with script on post #300. It didn't work for me. After I created my list of pool objects my prefabs had no Lightmaps at all.

 

Hi Can you post screenshots on how is it looking? Also can you post video over how you doing that process?

**EDIT**
Plz try with this script,
https://forum.unity3d.com/threads/problems-with-instantiating-baked-prefabs.324514/#post-2229465

 

First of all - BIG THANKS to all of you.

Finally after a lot of trial and error I was able to use one of the scripts that worked, at least for me.

I've used the original PrefabLightmapData.cs from the project posted by the Unity Team in the post #6.

I've put together a little guide bellow for who may need help with this issue.
I've also attached all the details like the Lighting Settings, the screenshots of the Prefabs after the Lightmap was baked, etc.

Steps followed:
1 - Build your Prefabs with your lights on it (Tip: Used and empty GameObject to group all the lights under that Prefab - will turn the lights off later, but will keep them in case we want to change it later on)
2 - Set your Prefab as Static (apply to all children).
3 - Under Static drop down menu, be sure Batching Static is checked OFF, for all the children under the parent GameObject and the parent itself.
4 - Place the script PrefabLightmapData.cs on the parent GameObject of the Prefab.
5 - On the Main Menu click on Assets > Bake Prefabs Lightmap.
6 - When the Baking is completed, disable the GameObject with all the lights on the Prefab(s)
7 - Click Apply button on the Inspector to apply all the changes to you Prefab.

I'm using this script on my Prebafs that are part of random generated paths using pooling. I also tested this on Android 7.0 successfully, and Unity 5.5.2f1. Lightmaps are working as excepted.

What I did not tried was to use Light Probes.

Important note: If you try to use any of these scripts to generate Lightmaps for objects created with ProBuilder don't waste your time, it doesn't work. After baking, the Lightmaps looks fine on the scene, but when they are instantiated it doesn't display correctly.

 

I have a question regarding the prefab.
I've done everything its said in the steps and yet when i instantiate the prefab it loses its look.(I am not using ProBuilder)
Also for some reason when the baking is done the script is doubled.
Here is the example of the issue:

 

Use the script attached below (it should be the same, but just in case). I think initially it duplicates, but I can really recall now. If that happens just remove the duplicate. Can you upload a small video to see the steps you followed. Also can you please provide the Unity version you are working with.

 

I am using Unity 5.5.2f1

 

5.5.2f1 is completely broken. It's has a lot of issues. I recommend you to use 5.2.1 instead. It'a more stable.

 

Hi @Shtrude1, I just watched you video. I must say, I'm doing my baking with actual lights, I have not tried using Emission Materials. Here's a small video demonstrating what I described above. Take a look:

 

I ran a test using Emission Materials and everything is working fine as well. Take a look:

I found that I get betters result when using textures instead of the plain color.

To bake multiple prefabs, just dump all your prefabs on your scene and separate them so the light don't bounce between prefabs, then apply the changes to the prefabs after the baking is completed.

 

Huh, well it works fine now , thx for the help tho.

 

I wrote a new simple script for my game :
* This needs baked prefab to be on the scene , you can not delete(you can disable mesh renderers)
* Tested in android build (i don't know anything about performance for now)

 

I have updated LightmapBase script to disable mesh renderers automatically in base baked prefab (In my case needs to be disabled for performance reasons , i just used instantiated prefabs)

How to disable mesh renderer on start :

Code (CSharp):

1.     void Start () {
2.  
3.         Renderer[] r = GetComponentsInChildren<Renderer>();
4.  
5.  
6.         foreach(Renderer rr in r)
7.             rr.enabled = false;
8.     }

 

Hey guys, getting stuck here...

So, I'm succesfully baking the lightmaps, adding the renderinfo to prefab and applying it to the prefab, making an asset bundle of it then loading it at runtime and applying the map..., BUT only when I do this in the scene in which I made prefab. If I choose to load prefab with lightmap data into a different scene (even without asset-bundling it), i lose everything...is there a way to use the prefab with ligthmap data attached in the scenes that it wasn't baked in? I saw a hint where you can "loading additive" the "level" with the prefab in it...seems messy.

Not sure why I can't use prefab with other scenes, it doesn't rely on location of the lightmaps, and it contains data about them...

Puzzling....

 

hey guys,new problem
sorry my english...

i bake succ and made it to prefab, and if drag prefab to scene and click play button(make it run-time) looks good ,but when i build to assetbundle and loaded it ,it was terrify,

load prefab :


load assetbundle:


dose anyone can solve it?

 

ok it was sovled... run on mobile is good , just pc is wrong.....

 

@idurvesh

Hi,

I have done some initial tests and things looks promising!

I re-created your script to set the Light.BakedIndex, but this has been made obsolete in Unity 5.6 (I'm using 5.6.0f2). It tells us to use Light.IsBaked instead, but this is read-only. Any ideas what we should be doing instead?

Cheers,

Niall

 

@racsoh

Hey there

Your instructions above, and accompanying youtube vids are much appreciated. However, I have been through the steps many times now with my prefabs and I'm still seeing the same issue every time. When the light maps have been built, the prefab immediately becomes very dark. I am using one directional light (for the shadows from the sun) and one point light around the blacksmith's furnace.

Here is the prefab whilst the script is running:



And here it is immediately after the script has run (even before I turn the lights off):



I can't help but think that this is something to do with my ambient lighting. I need some ambient light in the scene, otherwise it is all in shadow. When baking the light maps, should this ambient lighting be removed?

When this prefab is used in the scene with others that I have not yet baked the light maps into, you can see the difference in the lighting:



Here are my scene lighting settings:



Any advice would be much appreciated!

Thanks
--TJ

 

Hi @TJShae,

Sorry it took me so long to reply, I've been really disconnected due to a few projects.
Please be sure that you have Generate Lightmap UVs checkbox Checked ON for every model you imported (that's what seems to be causing that issue), and then re-bake using the script I uploaded:

 

Hiiii guys, for this topic We have an issue when we use one level to load different baked Prefab.

https://forum.unity3d.com/threads/problems-with-instantiating-baked-prefabs.324514/#post-2177524
this script is what we use in project.

The baked level looks like

Everything looks good.

Load baked prefab looks like
The lightmap is loaded correctly, but the prefab looks not good LOL....

And we use Unity 5.5.1f1 Pro.
We are confused by this issue, plz help us , thankssssssss

@Joachim_Ante
Would u plz give me some tips, I tried your sample project in 5.3.1 successed, but not good in 5.5.1 or 5.5.2. Thanks!

 

@Johnny-Ge 2d Texture is not formed when we bake scenes in 5.5 or 5.6. Did you get this to work ? I'm also using the same script as @Joachim_Ante but can't get it to work in 5.5 or 5.6.

@TJShae Did you find any solution for this ?

I'm also stuck with this. Help would be really appreciated.
http://answers.unity3d.com/questions/1342992/asset-bundle-lighting-problem-1.html

 

Hello, thank you for the script. I succeed to apply lightmaps in another scene.

But I have a problem with lightprobes. If position of prefab is different than the scene where you baked, it is impossible to have lightprobes correctly set. Informations of lightprobes (coefficients, number, positions, ...) are stored in LightingData and these information except for coefficients are read only.

Did anybody find a way to solve this ?

 

Hi Pysnoonh,

I don't even have light probes in my project. Just directional light and a point light. Also the example given by @Joachim_Ante has lightmaps in the form of 2d texture. This is not generated anymore in new versions 5.5/5.6 when we bake scene. Also I'm changing the transparency/alpha of some materials in runtime through scripts, even they are not working when instantiated through asset bundle. I would really appreciate some help in this. Thanks

 

What about 5.6? Looks like prefabs now stores their link to lightmap and you can create lightmapped objects inside one scene, but it still does not load lightmap asset to another scene.

 

I'm using 5.6 and it's not working

 

Has anyone found the alternative to using Light.bakedIndex? https://docs.unity3d.com/540/Documentation/ScriptReference/Light-bakedIndex.html

When using prefabs with Mixed lighting this was required to make sure a light does not light objects that already use a baked lightmaps. Otherwise static objects look overexposed.

In 5.6, it is made obsolete. Bringing forth the problem of "overexposure".

Video illustrates how static/baked objects are still being lit by the Directional Light, because it cannot be flagged using bakedIndex.

EDIT: Fixed this by adding a static object to our main scene (which handles all the loading and game states) and baking static lighting. This seemed to have flagged the directional light as baked. We only use that one directional light and change it's rotation according to the level loaded. So this works fine.

 

Hi there, me and my team could get the lightmap baking to work on prefabs using the package posted here.

Although we found out that if the scene where we instantiate the prefab along with its lightmaps doesn't have a lightmap on its own, the lightmap of the prefab rendered wrong.

So if anyone has the same problem in which the lightmap renders wrong (as in horribly black & white - only rendering), try baking a lightmap, even a simple one, on that scene first.

 

Hello, I hope I will be able to get an answer, I have used the script that has the editor made by @idurvesh

It works great, but I would like to be able to bake the lightmapping shadow mask, tried editing the script. but I really don't get it. I'm a bit of a noob any help please?

here is my try at chaging the script

Code (CSharp):

1. #if UNITY_EDITOR
2. using UnityEditor;
3. #endif
4. using UnityEngine;
5. using System.Collections.Generic;
6. using System.Linq;
7. public class PrefabLightmapData : MonoBehaviour
8. {
9.     [System.Serializable]
10.     struct RendererInfo
11.     {
12.         public List<Renderer> renderer;
13.         public int lightmapIndex;
14.         public Vector4 lightmapOffsetScale;
15.     }
16.     [SerializeField]
17.     List<RendererInfo> m_RendererInfo;
18.     [SerializeField]
19.     Texture2D[] m_Lightmaps;
20.     [SerializeField]
21.     Texture2D[] m_Lightmaps2;
22.     [SerializeField]
23.   public  static string LIGHTMAP_RESOURCE_PATH = "Assets/Resources/Lightmaps/";
24.     [System.Serializable]
25.     struct Texture2D_Remap
26.     {
27.         public int originalLightmapIndex;
28.         public Texture2D originalLightmap;
29.         public Texture2D lightmap;
30.         public Texture2D lightmap2;
31.     }
32.     static List<Texture2D_Remap> sceneLightmaps = new List<Texture2D_Remap>();
33.     void Awake()
34.     {
35.  
36.     }
37.     // Use this for initialization
38.     void Start()
39.     {
40.         ApplyLightmaps(m_RendererInfo, m_Lightmaps, m_Lightmaps2);
41.         //StaticBatchingUtility.Combine(this.gameObject);
42.     }
43.  
44.     static void ApplyLightmaps(List<RendererInfo> rendererInfo, Texture2D[] lightmaps, Texture2D[] lightmaps2)
45.     {
46.         bool existsAlready = false;
47.         int counter = 0;
48.         int[] lightmapArrayOffsetIndex;
49.         if (rendererInfo == null || rendererInfo.Count == 0)
50.             return;
51.         var settingslightmaps = LightmapSettings.lightmaps;
52.         var combinedLightmaps = new List<LightmapData>();
53.         lightmapArrayOffsetIndex = new int[lightmaps.Length];
54.         for (int i = 0; i < lightmaps.Length; i++)
55.         {
56.             existsAlready = false;
57.             for (int j = 0; j < settingslightmaps.Length; j++)
58.             {
59.                 if (lightmaps[i] == settingslightmaps[j].lightmapColor)
60.                 {
61.                     lightmapArrayOffsetIndex[i] = j;
62.                     existsAlready = true;
63.                 }
64.             }
65.             if (!existsAlready)
66.             {
67.                 lightmapArrayOffsetIndex[i] = counter + settingslightmaps.Length;
68.                 var newLightmapData = new LightmapData();
69.                 newLightmapData.lightmapColor = lightmaps[i];
70.                 newLightmapData.shadowMask = lightmaps2[i];
71.                 combinedLightmaps.Add(newLightmapData);
72.                 ++counter;
73.             }
74.         }
75.         var combinedLightmaps2 = new LightmapData[settingslightmaps.Length + combinedLightmaps.Count];
76.         settingslightmaps.CopyTo(combinedLightmaps2, 0);
77.         if (counter > 0)
78.         {
79.             for (int i = 0; i < combinedLightmaps.Count; i++)
80.             {
81.                 combinedLightmaps2[i + settingslightmaps.Length] = new LightmapData();
82.                 combinedLightmaps2[i + settingslightmaps.Length].lightmapColor = combinedLightmaps[i].lightmapColor;
83.                 combinedLightmaps2[i + settingslightmaps.Length].shadowMask = combinedLightmaps[i].shadowMask;
84.             }
85.         }
86.         ApplyRendererInfo(rendererInfo, lightmapArrayOffsetIndex);
87.         LightmapSettings.lightmaps = combinedLightmaps2;
88.     }
89.     static void ApplyRendererInfo(List<RendererInfo> infos, int[] arrayOffsetIndex)
90.     {
91.         for (int i = 0; i < infos.Count; i++)
92.         {
93.             var info = infos[i];
94.             foreach (Renderer rer in info.renderer)
95.             {
96.                 rer.lightmapIndex = arrayOffsetIndex[info.lightmapIndex];
97.                 rer.lightmapScaleOffset = info.lightmapOffsetScale;
98.             }
99.         }
100.     }
101. #if UNITY_EDITOR
102.    // [MenuItem("Assets/Assign lightmaps to LOD")]
103.    public static void UseMeBeforeUpdatint(string lightMapFix = "LOD")
104.     {
105.         PrefabLightmapData[] prefabs = FindObjectsOfType<PrefabLightmapData>();
106.         foreach (var instance in prefabs)
107.         {
108.             List<RendererInfo> tempListOfRender = instance.m_RendererInfo;
109.             foreach (RendererInfo ren in tempListOfRender)
110.             {
111.                 foreach (Renderer re in ren.renderer.ToList())
112.                 {
113.                     Transform myParentForSib = re.transform.parent;
114.                     foreach (var chil in myParentForSib.GetComponentsInChildren<Transform>())
115.                     {
116.                         if (chil != ren.renderer[0].transform)
117.                         {
118.                             if (chil.gameObject.name.Contains(lightMapFix))
119.                             {
120.                                 ren.renderer.Add(chil.GetComponent<MeshRenderer>());
121.                             }
122.                         }
123.                     }
124.                 }
125.             }
126.         }
127.     }
128.   //  [MenuItem("Assets/Update Scene with Prefab Lightmaps")]
129.   public  static void UpdateLightmaps()
130.     {
131.         PrefabLightmapData[] prefabs = FindObjectsOfType<PrefabLightmapData>();
132.         foreach (var instance in prefabs)
133.         {
134.             ApplyLightmaps(instance.m_RendererInfo, instance.m_Lightmaps, instance.m_Lightmaps2);
135.         }
136.         Debug.Log("Prefab lightmaps updated");
137.     }
138. //   [MenuItem("Assets/Bake Prefab Lightmaps")]
139.   public  static void GenerateLightmapInfo(string folderPath,TextureImporterFormat textureFormat,int textureMaxSize)
140.     {
141.         LIGHTMAP_RESOURCE_PATH = folderPath;
142.         tf = textureFormat;
143.         sizeOfTexture = textureMaxSize;
144.  
145.         Debug.ClearDeveloperConsole();
146.         if (Lightmapping.giWorkflowMode != Lightmapping.GIWorkflowMode.OnDemand)
147.         {
148.             Debug.LogError("ExtractLightmapData requires that you have baked you lightmaps and Auto mode is disabled.");
149.             return;
150.         }
151.         Lightmapping.Bake();
152.         sceneLightmaps = new List<Texture2D_Remap>();
153.         var scene = UnityEngine.SceneManagement.SceneManager.GetActiveScene();
154.        
155.  
156.         var resourcePath = LIGHTMAP_RESOURCE_PATH + scene.name;
157.         var scenePath = System.IO.Path.GetDirectoryName(scene.path) + "/" + scene.name + "/";
158.         PrefabLightmapData[] prefabs = FindObjectsOfType<PrefabLightmapData>();
159.         foreach (var instance in prefabs)
160.         {
161.             var gameObject = instance.gameObject;
162.             var rendererInfos = new List<RendererInfo>();
163.             var lightmaps = new List<Texture2D>();
164.             var lightmaps2 = new List<Texture2D>();
165.             GenerateLightmapInfo(scenePath, resourcePath, gameObject, rendererInfos, lightmaps, lightmaps2);
166.             instance.m_RendererInfo = rendererInfos;
167.             instance.m_Lightmaps = lightmaps.ToArray();
168.             instance.m_Lightmaps2 = lightmaps2.ToArray();
169.             var targetPrefab = PrefabUtility.GetPrefabParent(gameObject) as GameObject;
170.             if (targetPrefab != null)
171.             {
172.                 //Prefab
173.                 PrefabUtility.ReplacePrefab(gameObject, targetPrefab);
174.             }
175.             ApplyLightmaps(instance.m_RendererInfo, instance.m_Lightmaps, instance.m_Lightmaps2);
176.         }
177.         Debug.Log("Update to prefab lightmaps finished");
178.     }
179.     static void GenerateLightmapInfo(string scenePath, string resourcePath, GameObject root, List<RendererInfo> rendererInfos, List<Texture2D> lightmaps, List<Texture2D> lightmaps2)
180.     {
181.         var renderers = root.GetComponentsInChildren<MeshRenderer>();
182.         foreach (MeshRenderer renderer in renderers)
183.         {
184.             if (renderer.lightmapIndex != -1 && renderer.enabled)
185.             {
186.                 RendererInfo info = new RendererInfo();
187.                 info.renderer = new List<Renderer>();
188.                 info.renderer.Add(renderer);
189.                 info.lightmapOffsetScale = renderer.lightmapScaleOffset;
190.                 Texture2D lightmap = LightmapSettings.lightmaps[renderer.lightmapIndex].lightmapColor;
191.                 Texture2D lightmap2 = LightmapSettings.lightmaps[renderer.lightmapIndex].shadowMask;
192.                 int sceneLightmapIndex = AddLightmap(scenePath, resourcePath, renderer.lightmapIndex, lightmap, lightmap2);
193.                 info.lightmapIndex = lightmaps.IndexOf(sceneLightmaps[sceneLightmapIndex].lightmap);
194.                 if (info.lightmapIndex == -1)
195.                 {
196.                     info.lightmapIndex = lightmaps.Count;
197.                     lightmaps.Add(sceneLightmaps[sceneLightmapIndex].lightmap);
198.                     lightmaps2.Add(sceneLightmaps[sceneLightmapIndex].lightmap2);
199.                 }
200.                 rendererInfos.Add(info);
201.             }
202.         }
203.     }
204.     static int AddLightmap(string scenePath, string resourcePath, int originalLightmapIndex, Texture2D lightmap, Texture2D lightmap2)
205.     {
206.         int newIndex = -1;
207.         for (int i = 0; i < sceneLightmaps.Count; i++)
208.         {
209.             if (sceneLightmaps[i].originalLightmapIndex == originalLightmapIndex)
210.             {
211.                 return i;
212.             }
213.         }
214.         if (newIndex == -1)
215.         {
216.             var lightmap_Remap = new Texture2D_Remap();
217.             lightmap_Remap.originalLightmapIndex = originalLightmapIndex;
218.             lightmap_Remap.originalLightmap = lightmap;
219.             var filename = scenePath + "Lightmap-" + originalLightmapIndex;
220.             lightmap_Remap.lightmap = GetLightmapAsset(filename + "_comp_light.exr", resourcePath + "_light", originalLightmapIndex, lightmap);
221.             if (lightmap2 != null)
222.             {
223.                 lightmap_Remap.lightmap2 = GetLightmapAsset(filename + "_comp_shadowmask.png", resourcePath + "_shadowmask", originalLightmapIndex, lightmap2);
224.             }
225.             sceneLightmaps.Add(lightmap_Remap);
226.             newIndex = sceneLightmaps.Count - 1;
227.         }
228.         return newIndex;
229.     }
230.  
231.     public static int sizeOfTexture;
232.     public static TextureImporterFormat tf;
233.  
234.     static Texture2D GetLightmapAsset(string filename, string resourcePath, int originalLightmapIndex, Texture2D lightmap)
235.     {
236.         Debug.Log(filename);
237.         AssetDatabase.ImportAsset(filename, ImportAssetOptions.ForceUpdate);
238.         var importer = AssetImporter.GetAtPath(filename) as TextureImporter;
239.         importer.isReadable = true;
240.         importer.textureFormat = tf;
241.         importer.maxTextureSize = sizeOfTexture;
242.  
243.  
244.  
245.         AssetDatabase.ImportAsset(filename, ImportAssetOptions.ForceUpdate);
246.         var assetLightmap = AssetDatabase.LoadAssetAtPath<Texture2D>(filename);
247.         var assetPath = resourcePath + "-" + originalLightmapIndex + ".asset";
248.         var newLightmap = Instantiate<Texture2D>(assetLightmap);
249.         AssetDatabase.CreateAsset(newLightmap, assetPath);
250.         newLightmap = AssetDatabase.LoadAssetAtPath<Texture2D>(assetPath);
251.         importer.isReadable = false;
252.         AssetDatabase.ImportAsset(filename, ImportAssetOptions.ForceUpdate);
253.         return newLightmap;
254.     }
255. #endif
256. }

 

For those of you asking about loading lightmap data in different scenes, I found a GitHub project that touches on this topic a bit: https://github.com/laurenth-unity/lightmap-switching-tool

 

Can someone please give me an answer

1- Is there a way to use this script to also apply shadow mask to prefabs?

2-Is there a way to use this script with light probes for procedural content?

 

Could you please upload a video showing how to do this? I can't manage to do exactly what you said. I might be missing something. Thank you very much.

 

Hey folks; we also have issues with lightmaps after upgrading from unity 5.5 to 5.6(.1.p2).
Due to the upgrade we had to replace the deprecated "bakedIndex". With no replacement, everything (both static baked and dynamic non-baked) objects are lit, causing the baked objects to be overexposed.
If we tell the lightsource "alreadyLightmapped = true", the baked objects look fine - but all dynamic, non-baked objects are dark, as if the light source were disabled.

In the editor (not in playmode), all objects look fine, but once the playmode starts the above scenarios come into play.

As an additional layer of information, which does not apply to the example below, we usually have one scene in which we load a prefab via assetbundle which also contains lighting information that we previously baked and ripped and is used to overwrite the current scene lighting settings. This may or may not be relevant.

Below you can see a few screenshots demonstrating this issue (with 'alreadyLightmapped = true')

^ this is the non-playmode editor view of a non-lightmapped object on static, baked background. The object appears just fine in the baked environment


^ the 'baked lightmap' view verifies that the object has no lightmap and should be lit by a "mixed" lightsource


^ this is the setup of our lightsource and lighting. In a nutshell we have a single directional lightsource set to mixed and use only mixed lighting baked GI using the enlighten system


^ once in playmode, this is how the object appears, despite not having a lightmap



Am I right to assume that a "mixed lightsource" does NOT illuminate non-baked objects when it is told that things are already lightmapped?
How could we work around this? Suggestions are welcome

 

This is exact issue I'm having. I'm gonna have to do a new project and send it to Unity for testing. The fact that more than one person is getting this should be a red flag

 

We uploaded a bug report for it and it has been confirmed. Additionally, I told some guys at the Unite Europe about it and they confirmed that there are problems in 5.6 which they will investigate. The test project should help them.

 

Thank you. And I sent the team my entire project so far so they can test it. This issue only happens if I bake my scene using the prefab script for lightmaps. I had to do this because I use UFE and it uses prefabs for its level assets. So hopefully there is a fix

 

So, it seems to be working for me other than the fact that when I bake the lighting on the prefab it seems to lose quality. See below screenshots.


Before baking with one directional light on:


After baking with lights off:


Any idea what could be causing the quality loss? The lightmap parameters is set to "Default-HighResolution"

 

just wanted everyone to know, i just successfully tested with 2017.1.0f1, the script that i posted before about a year ago and a half ago. its great to see its still being modified and used, ofcourse the original came from this forum thread, i only added to it.

The test was built to WebGL 2.0 and works in chrome. Hopefully it still also works on android.
if you want to see it, i got it working on the "Paradise City" map, the rest arent updated for it.
http://realdefinition.net/play/

 

@B2F Well, I can hardly see those shadows and wouldn't say the two screenshots look the same (as I would expect if everything is working correctly). You're sure the restoration of lightmap textures is working correctly for you?

 

I̶s̶ ̶i̶t̶ ̶c̶o̶n̶f̶i̶r̶m̶e̶d̶ ̶t̶h̶a̶t̶ ̶t̶h̶e̶r̶e̶ ̶i̶s̶ ̶n̶o̶ ̶c̶u̶r̶r̶e̶n̶t̶ ̶s̶o̶l̶u̶t̶i̶o̶n̶ ̶f̶o̶r̶ ̶b̶a̶k̶i̶n̶g̶ ̶r̶e̶f̶l̶e̶c̶t̶i̶o̶n̶ ̶p̶r̶o̶b̶e̶ ̶d̶a̶t̶a̶ ̶i̶n̶t̶o̶ ̶p̶r̶e̶f̶a̶b̶s̶ ̶a̶s̶ ̶w̶e̶l̶l̶?̶

EDIT: set reflection probe to 'custom' (thank you @KRGraphics)

 

@B2F i have the same issue, whats missing is that without real times lights your not getting the the bump map raised look of your rocks, and your not getting the specular look of those rocks either.
So you're not getting bump or spec.

 

No dice for me, I just try with 2017 and I get an error, Null object on line 237 file: PrefabLightmapData.cs
I got the same error with unity 5.6

 

in 2017.1.0， I do everything what above said， and try every script above,while the result is that when I rebuild the lightmap and set the prefab， only black and white.
in lightmap setting windows,I could see the light texture,when I drag the lighting data file onto global maps,everything shows correct. while I saw that lightingdata.asset is just a editor file, if I want to run it in runtime,could't add it.

normally I notice one question that, when I generate lightmap, the lightmapDir always to be null,anything wrong?
even I run the demo preject,I need to drag the lightmapDir file to lightmap2 manually.

Code (CSharp):

1. #if UNITY_EDITOR
2. using UnityEditor;
3. #endif
4. using UnityEngine;
5. using System.Collections.Generic;
6. using System.Linq;
7.  
8. public class PrefabLightmapData : MonoBehaviour
9. {
10.     [System.Serializable]
11.     struct RendererInfo
12.     {
13.         public List<Renderer> renderer;
14.         public int lightmapIndex;
15.         public Vector4 lightmapOffsetScale;
16.     }
17.  
18.     [SerializeField]
19.     List<RendererInfo> m_RendererInfo;
20.     [SerializeField]
21.     Texture2D[] m_Lightmaps;
22.     [SerializeField]
23.     Texture2D[] m_Lightmaps2;
24.  
25.     const string LIGHTMAP_RESOURCE_PATH = "Assets/Resources/Lightmaps/";
26.  
27.     [System.Serializable]
28.     struct Texture2D_Remap
29.     {
30.         public int originalLightmapIndex;
31.         public Texture2D originalLightmap;
32.         public Texture2D lightmap;
33.         public Texture2D lightmap2;
34.     }
35.  
36.     static List<Texture2D_Remap> sceneLightmaps = new List<Texture2D_Remap>();
37.  
38.     void Awake()
39.     {
40.         ApplyLightmaps(m_RendererInfo, m_Lightmaps, m_Lightmaps2);
41.     }
42.  
43.     static void ApplyLightmaps(List<RendererInfo> rendererInfo, Texture2D[] lightmaps, Texture2D[] lightmaps2)
44.     {
45.         bool existsAlready = false;
46.         int counter = 0;
47.         int[] lightmapArrayOffsetIndex;
48.  
49.         if (rendererInfo == null || rendererInfo.Count == 0)
50.             return;
51.  
52.         var settingslightmaps = LightmapSettings.lightmaps;
53.         var combinedLightmaps = new List<LightmapData>();
54.         lightmapArrayOffsetIndex = new int[lightmaps.Length];
55.  
56.         for (int i = 0; i < lightmaps.Length; i++)
57.         {
58.             existsAlready = false;
59.             for (int j = 0; j < settingslightmaps.Length; j++)
60.             {
61.                 if (lightmaps[i] == settingslightmaps[j].lightmapColor)
62.                 {
63.                     lightmapArrayOffsetIndex[i] = j;
64.                     existsAlready = true;
65.                 }
66.             }
67.  
68.             if (!existsAlready)
69.             {
70.                 lightmapArrayOffsetIndex[i] = counter + settingslightmaps.Length;
71.                 var newLightmapData = new LightmapData();
72.                 newLightmapData.lightmapColor = lightmaps[i];
73.                 newLightmapData.lightmapDir = lightmaps2[i];
74.                 combinedLightmaps.Add(newLightmapData);
75.                 ++counter;
76.             }
77.         }
78.  
79.         var combinedLightmaps2 = new LightmapData[settingslightmaps.Length + combinedLightmaps.Count];
80.         settingslightmaps.CopyTo(combinedLightmaps2, 0);
81.  
82.         if (counter > 0)
83.         {
84.             for (int i = 0; i < combinedLightmaps.Count; i++)
85.             {
86.                 combinedLightmaps2[i + settingslightmaps.Length] = new LightmapData();
87.                 combinedLightmaps2[i + settingslightmaps.Length].lightmapColor = combinedLightmaps[i].lightmapColor;
88.                 combinedLightmaps2[i + settingslightmaps.Length].lightmapDir = combinedLightmaps[i].lightmapDir;
89.             }
90.         }
91.  
92.         ApplyRendererInfo(rendererInfo, lightmapArrayOffsetIndex);
93.  
94.         LightmapSettings.lightmaps = combinedLightmaps2;
95.     }
96.  
97.     static void ApplyRendererInfo(List<RendererInfo> infos, int[] arrayOffsetIndex)
98.     {
99.         for (int i = 0; i < infos.Count; i++)
100.         {
101.             var info = infos[i];
102.             foreach (Renderer rer in info.renderer)
103.             {
104.                 rer.lightmapIndex = arrayOffsetIndex[info.lightmapIndex];
105.                 rer.lightmapScaleOffset = info.lightmapOffsetScale;
106.             }
107.         }
108.     }
109.  
110. #if UNITY_EDITOR
111.     [MenuItem("Assets/Assign lightmaps to LOD")]
112.     static void UseMeBeforeUpdatint()
113.     {
114.         PrefabLightmapData[] prefabs = FindObjectsOfType<PrefabLightmapData>();
115.  
116.         foreach (var instance in prefabs)
117.         {
118.             List<RendererInfo> tempListOfRender = instance.m_RendererInfo;
119.  
120.             foreach (RendererInfo ren in tempListOfRender)
121.             {
122.                 foreach (Renderer re in ren.renderer.ToList())
123.                 {
124.                     Transform myParentForSib = re.transform.parent;
125.  
126.                     foreach (var chil in myParentForSib.GetComponentsInChildren<Transform>())
127.                     {
128.                         if (chil != ren.renderer[0].transform)
129.                         {
130.                             if (chil.gameObject.name.Contains("LOD"))
131.                             {
132.                                 ren.renderer.Add(chil.GetComponent<MeshRenderer>());
133.                             }
134.                         }
135.                     }
136.                 }
137.             }
138.         }
139.     }
140.  
141.     [MenuItem("Assets/Update Scene with Prefab Lightmaps")]
142.     static void UpdateLightmaps()
143.     {
144.         PrefabLightmapData[] prefabs = FindObjectsOfType<PrefabLightmapData>();
145.  
146.         foreach (var instance in prefabs)
147.         {
148.             ApplyLightmaps(instance.m_RendererInfo, instance.m_Lightmaps, instance.m_Lightmaps2);
149.         }
150.  
151.         Debug.Log("Prefab lightmaps updated");
152.     }
153.  
154.     [MenuItem("Assets/Bake Prefab Lightmaps")]
155.     static void GenerateLightmapInfo()
156.     {
157.         Debug.ClearDeveloperConsole();
158.  
159.         if (Lightmapping.giWorkflowMode != Lightmapping.GIWorkflowMode.OnDemand)
160.         {
161.             Debug.LogError("ExtractLightmapData requires that you have baked you lightmaps and Auto mode is disabled.");
162.             return;
163.         }
164.  
165.         Lightmapping.Bake();
166.  
167.         sceneLightmaps = new List<Texture2D_Remap>();
168.  
169.         var scene = UnityEngine.SceneManagement.SceneManager.GetActiveScene();
170.         var resourcePath = LIGHTMAP_RESOURCE_PATH + scene.name;
171.         var scenePath = System.IO.Path.GetDirectoryName(scene.path) + "/" + scene.name + "/";
172.  
173.         PrefabLightmapData[] prefabs = FindObjectsOfType<PrefabLightmapData>();
174.  
175.         foreach (var instance in prefabs)
176.         {
177.             var gameObject = instance.gameObject;
178.             var rendererInfos = new List<RendererInfo>();
179.             var lightmaps = new List<Texture2D>();
180.             var lightmaps2 = new List<Texture2D>();
181.             GenerateLightmapInfo(scenePath, resourcePath, gameObject, rendererInfos, lightmaps, lightmaps2);
182.  
183.             instance.m_RendererInfo = rendererInfos;
184.             instance.m_Lightmaps = lightmaps.ToArray();
185.             instance.m_Lightmaps2 = lightmaps2.ToArray();
186.  
187.             var targetPrefab = PrefabUtility.GetPrefabParent(gameObject) as GameObject;
188.             if (targetPrefab != null)
189.             {
190.                 //Prefab
191.                 PrefabUtility.ReplacePrefab(gameObject, targetPrefab);
192.             }
193.  
194.             ApplyLightmaps(instance.m_RendererInfo, instance.m_Lightmaps, instance.m_Lightmaps2);
195.         }
196.  
197.         Debug.Log("Update to prefab lightmaps finished");
198.     }
199.  
200.     static void GenerateLightmapInfo(string scenePath, string resourcePath, GameObject root, List<RendererInfo> rendererInfos, List<Texture2D> lightmaps, List<Texture2D> lightmaps2)
201.     {
202.         var renderers = root.GetComponentsInChildren<MeshRenderer>();
203.         foreach (MeshRenderer renderer in renderers)
204.         {
205.             if (renderer.lightmapIndex != -1 && renderer.enabled)
206.             {
207.                 RendererInfo info = new RendererInfo();
208.  
209.                 info.renderer = new List<Renderer>();
210.                 info.renderer.Add(renderer);
211.                 info.lightmapOffsetScale = renderer.lightmapScaleOffset;
212.  
213.                 Texture2D lightmap = LightmapSettings.lightmaps[renderer.lightmapIndex].lightmapColor;
214.                 Texture2D lightmap2 = LightmapSettings.lightmaps[renderer.lightmapIndex].lightmapDir;
215.                 int sceneLightmapIndex = AddLightmap(scenePath, resourcePath, renderer.lightmapIndex, lightmap, lightmap2);
216.  
217.                 info.lightmapIndex = lightmaps.IndexOf(sceneLightmaps[sceneLightmapIndex].lightmap);
218.                 if (info.lightmapIndex == -1)
219.                 {
220.                     info.lightmapIndex = lightmaps.Count;
221.                     lightmaps.Add(sceneLightmaps[sceneLightmapIndex].lightmap);
222.                     lightmaps2.Add(sceneLightmaps[sceneLightmapIndex].lightmap2);
223.                 }
224.  
225.                 rendererInfos.Add(info);
226.             }
227.         }
228.     }
229.  
230.     static int AddLightmap(string scenePath, string resourcePath, int originalLightmapIndex, Texture2D lightmap, Texture2D lightmap2)
231.     {
232.         int newIndex = -1;
233.  
234.         for (int i = 0; i < sceneLightmaps.Count; i++)
235.         {
236.             if (sceneLightmaps[i].originalLightmapIndex == originalLightmapIndex)
237.             {
238.                 return i;
239.             }
240.         }
241.  
242.         if (newIndex == -1)
243.         {
244.             var lightmap_Remap = new Texture2D_Remap();
245.             lightmap_Remap.originalLightmapIndex = originalLightmapIndex;
246.             lightmap_Remap.originalLightmap = lightmap;
247.  
248.             var filename = scenePath + "Lightmap-" + originalLightmapIndex;
249.  
250.             lightmap_Remap.lightmap = GetLightmapAsset(filename + "_comp_light.exr", resourcePath + "_light", originalLightmapIndex, lightmap);
251.             if (lightmap2 != null)
252.             {
253.                 lightmap_Remap.lightmap2 = GetLightmapAsset(filename + "_comp_dir.exr", resourcePath + "_dir", originalLightmapIndex, lightmap2);
254.             }
255.  
256.             sceneLightmaps.Add(lightmap_Remap);
257.             newIndex = sceneLightmaps.Count - 1;
258.         }
259.  
260.         return newIndex;
261.     }
262.  
263.     static Texture2D GetLightmapAsset(string filename, string resourcePath, int originalLightmapIndex, Texture2D lightmap)
264.     {
265.         AssetDatabase.ImportAsset(filename, ImportAssetOptions.ForceUpdate);
266.         var importer = AssetImporter.GetAtPath(filename) as TextureImporter;
267.         importer.isReadable = true;
268.         AssetDatabase.ImportAsset(filename, ImportAssetOptions.ForceUpdate);
269.  
270.         var assetLightmap = AssetDatabase.LoadAssetAtPath<Texture2D>(filename);
271.  
272.         var assetPath = resourcePath + "-" + originalLightmapIndex + ".asset";
273.         var newLightmap = Instantiate<Texture2D>(assetLightmap);
274.  
275.         AssetDatabase.CreateAsset(newLightmap, assetPath);
276.  
277.         newLightmap = AssetDatabase.LoadAssetAtPath<Texture2D>(assetPath);
278.  
279.         importer.isReadable = false;
280.         AssetDatabase.ImportAsset(filename, ImportAssetOptions.ForceUpdate);
281.  
282.         return newLightmap;
283.     }
284. #endif
285. }