private void LightSettings()
{
Renderer [] renderers;
if (myRootObj == null)
{
renderers = GameObject.FindObjectsOfType <Renderer>();
}
else
{
myRootObj.isStatic = true;
renderers = myRootObj.GetComponentsInChildren <Renderer>();
}
foreach (Renderer renderer in renderers)
{
renderer.gameObject.isStatic = true;
}
Lightmapping.giWorkflowMode = Lightmapping.GIWorkflowMode.OnDemand;
LightmapEditorSettings.resolution = lightRealtimeResolution;
RenderSettings.ambientIntensity = lightAmbientIntensity;
RenderSettings.ambientMode = UnityEngine.Rendering.AmbientMode.Skybox;
RenderSettings.skybox = mySkybox;
myLightObj.GetComponent <Light>().intensity = lightDirectionalIntensity;
Lightmapping.BakeAsync();
}
void Update()
{
if (!_baking)
{
return;
}
if (!Lightmapping.isRunning)
{
_scenesBuilt.Add(_realPaths[_currentSceneBuildingIndex]);
EditorSceneManager.OpenScene(_realPaths[_currentSceneBuildingIndex]);
LightmapEditorSettings.maxAtlasSize = int.Parse(_lightmapResolution[_lightMapResIndex]);
LightmapEditorSettings.lightmapper = LightmapEditorSettings.Lightmapper.Enlighten;
LightmapEditorSettings.mixedBakeMode = MixedLightingMode.Shadowmask;
LightmapEditorSettings.lightmapsMode = LightmapsMode.NonDirectional;
LightmapEditorSettings.filteringMode = LightmapEditorSettings.FilterMode.Auto;
Lightmapping.realtimeGI = false;
Lightmapping.bakedGI = true;
Lightmapping.BakeAsync();
_currentSceneBuildingIndex++;
if (_realPaths.Length == _currentSceneBuildingIndex)
{
_baking = false;
}
}
}
private void OnGUI()
{
if (GUILayout.Button("BakeMain"))
{
worldState = WorldState.Main;
SetBakeDirectionLight(true);
Lightmapping.BakeAsync();
}
if (GUILayout.Button("BakeOther"))
{
worldState = WorldState.Other;
SetBakeDirectionLight(true);
Lightmapping.BakeAsync();
}
if (GUILayout.Button("ShowMain"))
{
worldState = WorldState.Main;
SetBakeDirectionLight(false);
LightMapTool.ApplyLightmaps(false);
}
if (GUILayout.Button("ShowOther"))
{
worldState = WorldState.Other;
SetBakeDirectionLight(false);
LightMapTool.ApplyLightmaps(true);
}
mainLight = EditorGUILayout.ObjectField("main light",
mainLight,
typeof(Light),
true) as Light;
otherLight = EditorGUILayout.ObjectField("other light",
otherLight,
typeof(Light),
true) as Light;
}
/**
* Builds lighting if auto-generate lightmaps is turned off.
*/
private static void BuildLighting()
{
if (Lightmapping.giWorkflowMode == Lightmapping.GIWorkflowMode.OnDemand)
{
Lightmapping.BakeAsync();
}
}
static void BakeLightmap()
{
// Lightmapping.ClearDiskCache();
// Lightmapping.Clear();
Caching.CleanCache();
startTime = Time.realtimeSinceStartup;
Lightmapping.BakeAsync();
}
//Bakes the lighting for your current open scene
public static void GX_Skies_BakeLighting()
{
if (!Lightmapping.isRunning)
{
UnityEngine.RenderSettings.ambientMode = AmbientMode.Skybox;
Lightmapping.BakeAsync();
}
}
/// <summary>
/// Bakes global lighting
/// </summary>
public static void BakeGlobalLighting()
{
//Bakes the lightmaps
if (!Application.isPlaying && !Lightmapping.isRunning)
{
Lightmapping.BakeAsync();
}
}
private void CreateSimulation()
{
if (string.IsNullOrEmpty(_simulationName))
{
EditorUtility.DisplayDialog("Error", "Insert a valid name for the new simulation", "Cancel");
return;
}
_simulationName = _simulationName.Trim();
var path = SimulationsBaseDir + _simulationName;
// Check if simulation name exist
if (Directory.Exists(path))
{
EditorUtility.DisplayDialog("Error", "Simulation " + _simulationName + " already Exist!", "Cancel");
return;
}
// Create simulation base folder
Directory.CreateDirectory(path);
// Create Simulation Environment Prefab
var newSimEnv = CreateInstance <SimulationEnvironment> ();
newSimEnv.problem = _problem;
newSimEnv.Initialize();
var newSimEnvPath = AssetDatabase.GenerateUniqueAssetPath(path + "/" + _simulationName + " Environment.asset");
AssetDatabase.CreateAsset(newSimEnv, newSimEnvPath);
// Create Folder for Types Models
Directory.CreateDirectory(path + "/Types Models");
// Create Folder for Predicates Behaviours
Directory.CreateDirectory(path + "/Predicates Behaviours");
var newScene = EditorSceneManager.NewScene(NewSceneSetup.EmptyScene, NewSceneMode.Single);
newScene.name = _simulationName;
var simulationManagerAsset = AssetDatabase.LoadAssetAtPath <GameObject>("Assets/Prefabs/SimulationManager.prefab");
var sceneElementsAsset = AssetDatabase.LoadAssetAtPath <GameObject>("Assets/Prefabs/Scene Elements.prefab");
Instantiate(sceneElementsAsset);
var simulationManager = Instantiate(simulationManagerAsset);
// Initialize simulation manager
simulationManager.GetComponent <SimulationManager>().domain = _domain;
simulationManager.GetComponent <SimulationManager>().simulationName = _simulationName;
simulationManager.GetComponent <SimulationManager>().Initialize();
simulationManager.GetComponent <SimulationManager>().simulationEnvironment = newSimEnv;
// Save changes
EditorSceneManager.SaveScene(newScene, "Assets/Scenes/" + _simulationName + ".unity");
AssetDatabase.SaveAssets();
AssetDatabase.Refresh();
Lightmapping.BakeAsync();
Close();
}
public static void BakeLights()
{
if (Lightmapping.isRunning)
{
return;
}
Lightmapping.BakeAsync();
}
private static void StartLightmapping(LightingSettings settings)
{
GenerateLightmapUVs();
Lightmapping.lightingSettings = settings;
if (Lightmapping.BakeAsync())
{
SceneView.duringSceneGui += SceneView_duringSceneGui;
}
}
public void GenerateLighting()
{
Ceiling.SetActive(true);
Lightmapping.BakeAsync();
Lightmapping.completed = () =>
{
Ceiling.SetActive(false);
};
}
public IEnumerator DefaultUnwrapParamsDoNotOverlap()
{
var lightmapMode = Lightmapping.giWorkflowMode;
try
{
Lightmapping.giWorkflowMode = Lightmapping.GIWorkflowMode.OnDemand;
Lightmapping.started += LightmappingStarted;
if (Lightmapping.completed == null)
{
Lightmapping.completed = LightmappingCompleted;
}
else
{
Lightmapping.completed += LightmappingCompleted;
}
Setup();
float x = -10f;
using (var shapes = new TestUtility.BuiltInPrimitives())
{
SceneModeUtility.SetStaticFlags(shapes.Select(it => it.gameObject).ToArray(), (int)StaticEditorFlags.LightmapStatic, true);
foreach (ProBuilderMesh mesh in shapes)
{
mesh.transform.position = new Vector3(x, 0f, 0f);
x += mesh.mesh.bounds.size.x + .5f;
mesh.Optimize(true);
}
Lightmapping.BakeAsync();
while (!s_FinishedBaking)
{
yield return(null);
}
LogAssert.NoUnexpectedReceived();
}
}
finally
{
Lightmapping.started -= LightmappingStarted;
Lightmapping.completed -= LightmappingCompleted;
Lightmapping.giWorkflowMode = lightmapMode;
Cleanup();
}
}
public IEnumerator ActivateDirectLighting_DuringABake_DoesNotFallback()
{
EditorSceneManager.OpenScene("Assets/Tests/Editor/Tests_Unit_Editmode/BakeRestartScene.unity", OpenSceneMode.Single);
yield return(null);
LightingSettings lightingSettings = null;
Lightmapping.TryGetLightingSettings(out lightingSettings);
Assert.That(lightingSettings, !Is.EqualTo(null), "LightingSettings is null");
lightingSettings.lightmapper = LightingSettings.Lightmapper.ProgressiveGPU;
lightingSettings.mixedBakeMode = MixedLightingMode.IndirectOnly;
lightingSettings.directionalityMode = LightmapsMode.NonDirectional;
GameObject dirLightGO = GameObject.FindGameObjectsWithTag("TheLight")[0];
dirLightGO.SetActive(false);
Light light = dirLightGO.GetComponent(typeof(Light)) as Light;
light.lightmapBakeType = LightmapBakeType.Baked;
Lightmapping.Clear();
Lightmapping.BakeAsync();
foreach (bool b in RunABake(0.2f))
{
yield return(null);
}
// Make sure it is still baking before we
// switch the light on and restart the bake
Assert.IsTrue(Lightmapping.isBaking);
// Activate the light, cause the bake to restart
dirLightGO.SetActive(true);
foreach (bool b in RunABake(0.2f))
{
yield return(null);
}
// Check that baking is still running
Assert.IsTrue(Lightmapping.isBaking);
// Check that we did not fallback to CPULM
Assert.AreEqual(lightingSettings.lightmapper, LightingSettings.Lightmapper.ProgressiveGPU);
Lightmapping.Cancel();
Lightmapping.Clear();
Lightmapping.ClearLightingDataAsset();
}
private IEnumerator BuildLightingAsync(string ScenarioName)
{
var newLightmapMode = new LightmapsMode();
newLightmapMode = LightmapSettings.lightmapsMode;
Lightmapping.BakeAsync();
while (Lightmapping.isRunning)
{
yield return(null);
}
Lightmapping.lightingDataAsset = null;
EditorSceneManager.SaveScene(EditorSceneManager.GetSceneByPath("Assets/Scenes/" + ScenarioName + ".unity"));
EditorSceneManager.CloseScene(EditorSceneManager.GetSceneByPath("Assets/Scenes/" + ScenarioName + ".unity"), true);
LightmapSettings.lightmapsMode = newLightmapMode;
}
void OpenBakeAndSave()
{
fileName = "Assets/Scenes/Levels/" + levelNames[levelIndex] + ".unity";
EditorSceneManager.OpenScene(fileName);
Lightmapping.Clear();
// LightmapEditorSettings.maxAtlasHeight = 4096;
// LightmapEditorSettings.maxAtlasWidth = 4096;
Lightmapping.BakeAsync();
startedBaking = true;
}
private IEnumerator BuildLightingAsync(string ScenarioName)
{
var newLightmapMode = new LightmapsMode();
newLightmapMode = LightmapSettings.lightmapsMode;
Lightmapping.BakeAsync();
while (Lightmapping.isRunning)
{
yield return(null);
}
Lightmapping.lightingDataAsset = null;
EditorSceneManager.SaveScene(EditorSceneManager.GetSceneByPath("Assets/Scenes/MapData_1212/UPBR_daytime001.unity"));
// EditorSceneManager.SaveScene(EditorSceneManager.GetSceneByPath("Assets/Scenes/MapData_1122/UPBR001.unity"));
LightmapSettings.lightmapsMode = newLightmapMode;
}
// Loop through scenes to bake and update on progress
private void BakeNewScene()
{
if (sceneIndex < scenes.Length)
{
EditorApplication.OpenScene(scenePath[sceneIndex]);
timeStamp = System.DateTime.Now;
Lightmapping.BakeAsync();
UpdateBakeProgress();
sceneIndex++;
}
else
{
DoneBaking("done");
}
}
private IEnumerator BuildLightingAsync(Scene lightingScene)
{
var newLightmapMode = new LightmapsMode();
newLightmapMode = LightmapSettings.lightmapsMode;
Lightmapping.BakeAsync();
while (Lightmapping.isRunning)
{
yield return(null);
}
//Lightmapping.lightingDataAsset = null;
EditorSceneManager.SaveScene(lightingScene);
EditorSceneManager.CloseScene(lightingScene, true);
LightmapSettings.lightmapsMode = newLightmapMode;
}
private void LevelSetup()
{
var Level = GameObject.Find("Level");
var oldl = Level.transform.Find("level");
if (oldl != null)
{
DestroyImmediate(oldl.gameObject);
}
string path = EditorApplication.currentScene.Split('.')[0] + "/";
path = path.Substring("Assets/".Length);
Debug.Log("setup level: " + path);
var nl = (GameObject)EditorUtility.InstantiatePrefab(GetAssets <GameObject>(path, "*.FBX").FirstOrDefault());
nl.transform.parent = Level.transform;
nl.name = "level";
Selection.activeGameObject = nl;
SetupLevel();
Inits(cspath);
_TimerA.AddMethod(delegate
{
if (bake)
{
var old = RenderSettings.ambientLight;
RenderSettings.ambientLight = Color.white * lfactor;
var en = new Queue <LightShadows>();
var q = new Queue <float>();
foreach (Light a in GameObject.FindObjectsOfType(typeof(Light)))
{
q.Enqueue(a.intensity);
en.Enqueue(a.shadows);
if (a.type == LightType.Directional)
{
a.intensity = dfactor;
}
a.shadows = LightShadows.Soft;
}
Lightmapping.BakeAsync();
foreach (Light a in GameObject.FindObjectsOfType(typeof(Light)))
{
a.intensity = q.Dequeue();
a.shadows = en.Dequeue();
}
RenderSettings.ambientLight = old;
}
});
}
private static void Bake()
{
if (currentSceneIndex >= stageData.param.Count)
{
return;
}
EditorApplication.SaveScene();
string path = GetBakeScenePath(currentSceneIndex, stageData);
EditorApplication.OpenScene(path);
Lightmapping.BakeAsync();
currentSceneIndex++;
Lightmapping.completed = Bake;
}
private IEnumerator BuildLightingAsync(LightingScenarioData scenarioData)
{
Scene lightingScene = SceneManager.GetSceneByName(scenarioData.lightingSceneName);
Scene geometryScene = SceneManager.GetSceneByName(scenarioData.geometrySceneName);
Lightmapping.BakeAsync();
while (Lightmapping.isRunning)
{
yield return(null);
}
EditorSceneManager.SaveScene(geometryScene);
EditorSceneManager.SaveScene(lightingScene);
StoreLightingData();
EditorSceneManager.CloseScene(lightingScene, true);
AssetDatabase.SaveAssets();
}
void DrawBakeButton()
{
GUILayout.FlexibleSpace();
EditorGUILayout.BeginHorizontal();
EditorGUI.BeginDisabledGroup(Lightmapping.isRunning);
if (GUILayout.Button("Load All Scenes In Set", GUILayout.ExpandWidth(true)))
{
LoadScenesInBakingSet(GetCurrentBakingSet());
}
if (GUILayout.Button("Clear Loaded Scenes Data"))
{
Lightmapping.Clear();
}
EditorGUI.EndDisabledGroup();
if (Lightmapping.isRunning)
{
if (GUILayout.Button("Cancel", GUILayout.ExpandWidth(true)))
{
Lightmapping.Cancel();
}
}
else
{
if (GUILayout.Button("Generate Lighting", "DropDownButton", GUILayout.ExpandWidth(true)))
{
var menu = new GenericMenu();
menu.AddItem(new GUIContent("Bake the set"), false, () =>
{
ProbeGIBaking.isBakingOnlyActiveScene = false;
BakeLightingForSet(GetCurrentBakingSet());
});
menu.AddItem(new GUIContent("Bake loaded scenes"), false, () =>
{
ProbeGIBaking.isBakingOnlyActiveScene = false;
Lightmapping.BakeAsync();
});
menu.AddItem(new GUIContent("Bake active scene"), false, () =>
{
ProbeGIBaking.isBakingOnlyActiveScene = true;
Lightmapping.BakeAsync();
});
menu.ShowAsContext();
}
}
EditorGUILayout.EndHorizontal();
}
static EditorHotkeysTracker()
{
SceneView.onSceneGUIDelegate += view =>
{
var e = Event.current;
if (e != null && e.keyCode != KeyCode.None)
{
if (e.keyCode == KeyCode.B && e.shift)
{
if (!Lightmapping.isRunning)
{
Lightmapping.BakeAsync();
}
}
if (e.keyCode == KeyCode.C && e.shift)
{
if (Lightmapping.isRunning)
{
Lightmapping.Cancel();
}
}
if (e.keyCode == KeyCode.E && e.shift)
{
if (!Lightmapping.isRunning)
{
Lightmapping.Clear();
}
}
if (e.keyCode == KeyCode.H && e.shift)
{
EditorPrefs.SetInt(PlayerSettings.productName + SceneManager.GetActiveScene().name + "FirstTime", 0);
}
if (e.keyCode == KeyCode.F && e.alt && e.control)
{
EditorApplication.ExecuteMenuItem("GameObject/Move To View");
}
if (e.keyCode == KeyCode.F && e.shift)
{
EditorApplication.ExecuteMenuItem("Window/Lighting/Settings");
}
if (e.keyCode == KeyCode.E && e.shift)
{
EditorApplication.ExecuteMenuItem("Lighting/Lighting Box");
}
}
};
}
public IEnumerator ActivateAO_DuringABake_DoesNotFallback()
{
EditorSceneManager.OpenScene("Assets/Tests/Editor/Tests_Unit_Editmode/BakeRestartScene.unity", OpenSceneMode.Single);
yield return(null);
LightingSettings lightingSettings = null;
Lightmapping.TryGetLightingSettings(out lightingSettings);
Assert.That(lightingSettings, !Is.EqualTo(null), "LightingSettings is null");
lightingSettings.lightmapper = LightingSettings.Lightmapper.ProgressiveGPU;
GameObject dirLightGO = GameObject.FindGameObjectsWithTag("TheLight")[0];
dirLightGO.SetActive(false);
lightingSettings.ao = false;
Lightmapping.Clear();
Lightmapping.BakeAsync();
foreach (bool b in RunABake(0.2f))
{
yield return(null);
}
// Make sure it is still baking before we
// switch the AO on and restart the bake
Assert.IsTrue(Lightmapping.isBaking);
// Switch AO on, cause the bake to restart
lightingSettings.ao = true;
foreach (bool b in RunABake(0.2f))
{
yield return(null);
}
// Check that baking is still running
Assert.IsTrue(Lightmapping.isBaking);
// Check that we did not fallback to CPULM
Assert.AreEqual(lightingSettings.lightmapper, LightingSettings.Lightmapper.ProgressiveGPU);
Lightmapping.Cancel();
Lightmapping.Clear();
Lightmapping.ClearLightingDataAsset();
}
// Loop through scenes to bake and update on progress
private void BakeNewScene()
{
if (sceneIndex < scenes.Length)
{
EditorSceneManager.OpenScene(scenePath[sceneIndex]);
EditorUtility.UnloadUnusedAssetsImmediate();
System.GC.Collect();
timeStamp = System.DateTime.Now;
Lightmapping.BakeAsync();
UpdateBakeProgress();
sceneIndex++;
}
else
{
DoneBaking("done");
}
}
void OnGUI()
{
GUILayout.Label("Base Settings", EditorStyles.boldLabel);
GUILayout.Label("", EditorStyles.boldLabel);
obj = GameObject.Find("specularDayLight");
obj = (GameObject)EditorGUI.ObjectField(new Rect(3, 24, position.width - 6, 20), "Light to Ignore", obj, typeof(GameObject), true);
if (GUILayout.Button("Build Lighting"))
{
Debug.Log("build lighting, ignore: " + obj);
obj.GetComponent <Light>().enabled = false;
myBool = Lightmapping.BakeAsync();
Lightmapping.completed += onFinishBake;
}
myBool = EditorGUILayout.Toggle("bakeAsync", myBool);
}
public static void ImportProbes()
{
try
{
EditorUtility.DisplayProgressBar("Importing external probe data", "Parsing data", 0);
DoImportProbePositions();
EditorUtility.DisplayProgressBar("Importing external probe data", "Dummy bake job", 0.25f);
Lightmapping.bakeCompleted -= OnBakeCompleted;
Lightmapping.bakeCompleted += OnBakeCompleted;
Lightmapping.BakeAsync();
}
catch
{
Debug.LogError("Light probe import failed");
EditorUtility.ClearProgressBar();
throw;
}
}
public override void OnInspectorGUI()
{
var holder = target as LightmapHolder;
if (holder.renderers != null && holder.scales != null)
{
EditorGUILayout.LabelField($"{holder.renderers.Length} renderers in {holder.scales.Length} indices");
}
if (GUILayout.Button("Clear Lightmaps"))
{
ClearHolder(holder);
Lightmapping.Clear();
}
if (Lightmapping.isRunning)
{
EditorGUILayout.LabelField("Baking...");
}
else
{
if (GUILayout.Button("Bake"))
{
ClearHolder(holder);
LightmapEditorSettings.maxAtlasSize = MAX_SIZE;
LightmapEditorSettings.filteringMode = LightmapEditorSettings.FilterMode.Auto;
LightmapEditorSettings.lightmapper = LightmapEditorSettings.Lightmapper.ProgressiveGPU;
Lightmapping.BakeAsync();
}
if (GUILayout.Button("Combine Lightmaps"))
{
ClearHolder(holder);
try
{
Combine(holder);
}
finally
{
EditorUtility.ClearProgressBar();
}
}
}
}
public static IEnumerator BakeCheckAndRun()
{
EditorUtility.DisplayProgressBar("Bake", "Baking...", 0);
bool bakeFlag = Lightmapping.BakeAsync();
if (!bakeFlag)
{
EditorUtility.DisplayDialog("Error", LocalizedMessage.Get("Main.Baker.LightBakeFailed"), "OK");
}
while (Lightmapping.isRunning)
{
EditorUtility.DisplayProgressBar("Bake", "Baking...", Lightmapping.buildProgress);
yield return(null);
}
EditorUtility.ClearProgressBar();
yield return(bakeFlag);
}
public static void Start()
{
Debug.ClearDeveloperConsole();
UpdateLightSettings( );
// 1. Prepare objects for bake
// Fetch PrefabVaker components from current active scene
EditorUtils.GetAllPrefabs( ).ForEach(x => {
// Set all nested object as static for bake
EditorUtils.LockForBake(x.gameObject);
});
// 2. Display progress dialog and await for bake complete in `BakeCompelte()`
BakeStart( );
// 3. Start baking
Lightmapping.BakeAsync( );
}
