private void RealtimeUpdateEnabled(bool helpEnabled)
{
m_profile.m_updateInRealtime = m_editorUtils.ToggleLeft("UpdateChangesInRealtime", m_profile.m_updateInRealtime, helpEnabled);
if (m_profile.m_updateInRealtime)
{
EditorGUILayout.HelpBox("Update In Realtime is enabled this will allow profiles to be endited inside the editor and automatically apply changes every frame. This feature can be expensive and should not be left enabled in testing and builds", MessageType.Warning);
}
else
{
if (m_editorUtils.Button("UpdateToScene"))
{
if (m_profile.m_selectedLightingProfileValuesIndex != -99)
{
GaiaUtils.GetRuntimeSceneObject();
if (GaiaGlobal.Instance != null)
{
//GaiaLighting.GetProfile(m_profile, m_gaiaSettings.m_pipelineProfile, m_gaiaSettings.m_pipelineProfile.m_activePipelineInstalled);
EditorUtility.SetDirty(m_profile);
}
}
}
m_editorUtils.InlineHelp("UpdateToScene", helpEnabled);
if (m_editorUtils.Button("UpdateDynamicGI"))
{
GaiaLighting.UpdateAmbientEnvironment();
}
m_editorUtils.InlineHelp("UpdateDynamicGI", helpEnabled);
}
}
/// <summary>
/// Adds a new user profile
/// </summary>
private void AddNewCustomProfile()
{
//GaiaLightingProfileValues selectdValues = m_savedSettings.LoadSettings(m_profile, true);
GaiaLightingProfileValues selectdValues = m_profileValues;
GaiaLightingProfileValues newProfile = new GaiaLightingProfileValues();
GaiaUtils.CopyFields(selectdValues, newProfile);
int count = m_profile.m_lightingProfiles.Count + 1;
newProfile.m_typeOfLighting = "New User Profile " + count;
newProfile.m_userCustomProfile = true;
m_profile.m_lightingProfiles.Add(newProfile);
m_profile.m_selectedLightingProfileValuesIndex = m_profile.m_lightingProfiles.Count - 1;
if (m_profile.m_selectedLightingProfileValuesIndex != -99)
{
GaiaUtils.GetRuntimeSceneObject();
if (GaiaGlobal.Instance != null)
{
GaiaLighting.GetProfile(m_profile, m_gaiaSettings.m_pipelineProfile, m_gaiaSettings.m_pipelineProfile.m_activePipelineInstalled);
}
}
EditorUtility.SetDirty(m_profile);
}
private static void RemoveOverCloud()
{
GameObject overCloudPrefab = GameObject.Find("OverCloud");
if (overCloudPrefab != null)
{
GameObject.DestroyImmediate(overCloudPrefab);
}
Camera mainCamera = GaiaUtils.GetCamera();
if (mainCamera != null)
{
OverCloudCamera ocCamera = mainCamera.gameObject.GetComponent <OverCloudCamera>();
if (ocCamera != null)
{
GameObject.DestroyImmediate(ocCamera);
}
}
if (GaiaUtils.CheckIfSceneProfileExists())
{
GaiaGlobal.Instance.SceneProfile.m_waterSystemMode = GaiaConstants.GlobalSystemMode.Gaia;
GaiaSettings gaiaSettings = GaiaUtils.GetGaiaSettings();
if (gaiaSettings != null)
{
UnityPipelineProfile pipelineProfile = gaiaSettings.m_pipelineProfile;
if (pipelineProfile != null)
{
GaiaLighting.GetProfile(GaiaGlobal.Instance.SceneProfile, pipelineProfile, GaiaUtils.GetActivePipeline());
}
}
}
}
/// <summary>
/// Does a quick optimize to your scene/project settings
/// </summary>
public static void GX_Optimization_QuickOptimize()
{
GaiaSettings gaiaSettings = GaiaUtils.GetGaiaSettings();
if (gaiaSettings != null)
{
GaiaLighting.QuickOptimize(gaiaSettings);
}
}
/// <summary>
/// Bakes lightmapping
/// </summary>
public static void GX_Lightmaps_BakeLighting()
{
GaiaSettings settings = GaiaUtils.GetGaiaSettings();
if (settings != null)
{
if (GaiaUtils.CheckIfSceneProfileExists())
{
GaiaLighting.BakeLighting(GaiaGlobal.Instance.SceneProfile.m_lightingBakeMode, GaiaGlobal.Instance.SceneProfile.m_lightingProfiles[GaiaGlobal.Instance.SceneProfile.m_selectedLightingProfileValuesIndex]);
}
}
}
private void UpdateLighting(bool process, bool applyProfile = false)
{
if (process)
{
if (GaiaGlobal.Instance != null)
{
GaiaUtils.GetRuntimeSceneObject();
GaiaLighting.GetProfile(GaiaGlobal.Instance.SceneProfile, m_gaiaSettings.m_pipelineProfile, m_gaiaSettings.m_pipelineProfile.m_activePipelineInstalled, applyProfile);
}
EditorUtility.SetDirty(m_profile.SceneProfile);
}
}
private void SetPostProcessing(GaiaLightingProfileValues profile)
{
if (m_gaiaSettings.m_currentRenderer == GaiaConstants.EnvironmentRenderer.BuiltIn)
{
if (m_profile.m_setupPostFX)
{
if (profile != null)
{
GaiaLighting.SetupPostProcessing(profile, m_profile, GaiaUtils.GetActivePipeline(), true);
}
}
}
}
private static void LoadWaterAndLighting(GaiaSettings settings, bool showDebug = false)
{
if (settings == null)
{
Debug.LogError("Gaia settings was not found.");
return;
}
if (settings.m_gaiaWaterProfile == null)
{
Debug.LogError("Water Profile was not found!");
return;
}
else
{
Material waterMat = GaiaWater.GetGaiaOceanMaterial();
if (waterMat != null)
{
GameObject waterObject = GameObject.Find(GaiaConstants.waterSurfaceObject);
if (waterObject != null)
{
GaiaUtils.GetRuntimeSceneObject();
if (GaiaGlobal.Instance != null)
{
GaiaWater.GetProfile(GaiaGlobal.Instance.SceneProfile.m_selectedWaterProfileValuesIndex, waterMat, GaiaGlobal.Instance.SceneProfile, true, false);
}
}
}
}
if (settings.m_gaiaLightingProfile == null)
{
Debug.LogError("Lighting Profile was not found!");
return;
}
else
{
GameObject lightObject = GameObject.Find(GaiaConstants.gaiaLightingObject);
if (lightObject != null)
{
if (GaiaGlobal.Instance != null)
{
GaiaUtils.GetRuntimeSceneObject();
GaiaLighting.GetProfile(GaiaGlobal.Instance.SceneProfile, settings.m_pipelineProfile, settings.m_pipelineProfile.m_activePipelineInstalled);
}
}
}
if (showDebug)
{
Debug.Log("Loading up profile settings successfully");
}
}
void OnEnable()
{
m_manager = (GaiaSessionManager)target;
//Init editor utils
if (m_editorUtils == null)
{
// Get editor utils for this
m_editorUtils = PWApp.GetEditorUtils(this);
}
GaiaLighting.SetPostProcessingStatus(false);
}
private void Lighting()
{
EditorGUI.BeginChangeCheck();
EditorGUILayout.BeginHorizontal();
EditorGUILayout.LabelField("Lighting Preset", EditorStyles.boldLabel, GUILayout.Width(105f));
m_lightingProfile.m_selectedLightingProfileValuesIndex = EditorGUILayout.Popup(m_lightingProfile.m_selectedLightingProfileValuesIndex, LightingList.ToArray());
if (GUILayout.Button("Edit"))
{
GaiaLighting.FocusGaiaLightingProfile();
}
EditorGUILayout.EndHorizontal();
if (EditorGUI.EndChangeCheck())
{
if (GaiaGlobal.Instance != null)
{
GaiaUtils.GetRuntimeSceneObject();
GaiaLighting.GetProfile(GaiaGlobal.Instance.SceneProfile, m_gaiaSettings.m_pipelineProfile, m_gaiaSettings.m_pipelineProfile.m_activePipelineInstalled);
}
}
}
public static void GX_WaterSetup_SelectLightingAndWaterProfile()
{
GaiaLighting.OpenProfileSelection();
}
/// <summary>
/// Clear lightmapping data on disk
/// </summary>
public static void GX_Lightmaps_ClearBakedLightmapDataOnDisk()
{
GaiaLighting.ClearLightmapDataOnDisk();
}
/// <summary>
/// Clear baked lightmapping
/// </summary>
public static void GX_Lightmaps_ClearBakedLightmaps()
{
GaiaLighting.ClearBakedLightmaps();
}
/// <summary>
/// Cancels lightmapping
/// </summary>
public static void GX_Lightmaps_CancelLightmapBaking()
{
GaiaLighting.CancelLightmapBaking();
}
public override void OnInspectorGUI()
{
//Get our resource
m_session = (GaiaSession)target;
//Set up the box style
if (m_boxStyle == null)
{
m_boxStyle = new GUIStyle(GUI.skin.box);
m_boxStyle.normal.textColor = GUI.skin.label.normal.textColor;
m_boxStyle.fontStyle = FontStyle.Bold;
m_boxStyle.alignment = TextAnchor.UpperLeft;
}
//Setup the wrap style
if (m_wrapStyle == null)
{
m_wrapStyle = new GUIStyle(GUI.skin.label);
m_wrapStyle.wordWrap = true;
}
//Set up the description wrap style
if (m_descWrapStyle == null)
{
m_descWrapStyle = new GUIStyle(GUI.skin.textArea);
m_descWrapStyle.wordWrap = true;
}
//Create a nice text intro
GUILayout.BeginVertical("Gaia Session", m_boxStyle);
GUILayout.Space(20);
EditorGUILayout.LabelField("Contains the data used to backup, share and play back sessions. Use the session manager to view, edit or play back sessions.", m_wrapStyle);
GUILayout.Space(4);
GUILayout.EndVertical();
//Make some space
GUILayout.Space(4);
//Wrap it up in a box
GUILayout.BeginVertical(m_boxStyle);
GUILayout.BeginVertical("Summary:", m_boxStyle);
GUILayout.Space(20);
//Display the basic details
EditorGUILayout.LabelField("Name", m_session.m_name);
EditorGUILayout.LabelField("Description", m_session.m_description, m_wrapStyle);
EditorGUILayout.LabelField("Created", m_session.m_dateCreated);
EditorGUILayout.LabelField("Dimensions", string.Format("w{0} d{1} h{2} meters", m_session.m_terrainWidth, m_session.m_terrainDepth, m_session.m_terrainHeight));
EditorGUILayout.LabelField("Sea Level", string.Format("{0} meters", m_session.m_seaLevel));
EditorGUILayout.LabelField("Locked", m_session.m_isLocked.ToString());
Texture2D previewImage = m_session.m_previewImage;
if (previewImage != null)
{
//Get aspect ratio and available space and display the image
float width = Screen.width - 43f;
float height = previewImage.height * (width / previewImage.width);
GUILayout.Label(previewImage, GUILayout.MaxWidth(width), GUILayout.MaxHeight(height));
}
GUILayout.EndVertical();
//Iterate through the operations
GUILayout.BeginVertical("Operations:", m_boxStyle);
GUILayout.Space(20);
if (m_session.m_operations.Count == 0)
{
GUILayout.Space(5);
GUILayout.Label("No operations yet...");
GUILayout.Space(5);
}
else
{
GaiaOperation op;
EditorGUI.indentLevel++;
for (int opIdx = 0; opIdx < m_session.m_operations.Count; opIdx++)
{
op = m_session.m_operations[opIdx];
if (op.m_isActive)
{
op.m_isFoldedOut = EditorGUILayout.Foldout(op.m_isFoldedOut, op.m_description, true);
}
else
{
op.m_isFoldedOut = EditorGUILayout.Foldout(op.m_isFoldedOut, op.m_description + " [inactive]", true);
}
if (op.m_isFoldedOut)
{
EditorGUI.indentLevel++;
EditorGUILayout.LabelField("Description", op.m_description, m_wrapStyle);
EditorGUILayout.LabelField("Created", op.m_operationDateTime);
EditorGUILayout.LabelField("Active", op.m_isActive.ToString());
EditorGUI.indentLevel--;
}
}
EditorGUI.indentLevel--;
}
GUILayout.EndVertical();
GUILayout.EndVertical();
if (GUILayout.Button("Play Session"))
{
GaiaSessionManager gsm = GaiaSessionManager.GetSessionManager(false, false);
if (gsm == null)
{
GameObject gaiaObj = GaiaUtils.GetGaiaGameObject();
GameObject mgrObj = new GameObject("Session Manager");
gsm = mgrObj.AddComponent <GaiaSessionManager>();
mgrObj.transform.parent = gaiaObj.transform;
}
GaiaLighting.SetDefaultAmbientLight(GaiaUtils.GetGaiaSettings().m_gaiaLightingProfile);
//make a copy of the session - otherwise there is the danger of conflicting with the old session data while playing back the session
GaiaSession sessionCopy = Instantiate(m_session);
sessionCopy.m_name = GaiaSessionManager.GetNewSessionName();
sessionCopy.name = sessionCopy.m_name;
gsm.m_session = sessionCopy;
string path = GaiaDirectories.GetSessionDirectory();
AssetDatabase.CreateAsset(sessionCopy, path + "/" + sessionCopy.m_name + ".asset");
AssetDatabase.SaveAssets();
GaiaSessionManager.PlaySession(sessionCopy);
}
if (GUILayout.Button("Open Session in Manager"))
{
GaiaSessionManager.LoadSession(m_session);
}
}
/// <summary>
/// Bakes and adds occlusion volume
/// </summary>
public static void GX_OcclusionCulling_BakeOcclusionCulling()
{
GaiaLighting.BakeOcclusionCulling(true, true, false);
}
private void GlobalSettings(bool helpEnabled)
{
if (GaiaGlobal.Instance.SceneProfile.m_lightingProfiles.Count > 0)
{
if (m_profile.m_selectedLightingProfileValuesIndex != -99)
{
profile = GaiaGlobal.Instance.SceneProfile.m_lightingProfiles[m_profile.m_selectedLightingProfileValuesIndex];
}
}
if (m_gaiaSettings.m_currentRenderer == GaiaConstants.EnvironmentRenderer.BuiltIn)
{
bool postfx = m_profile.m_setupPostFX;
m_profile.m_setupPostFX = m_editorUtils.Toggle("SetupPostFX", m_profile.m_setupPostFX, helpEnabled);
if (postfx != m_profile.m_setupPostFX)
{
if (m_profile.m_setupPostFX)
{
if (profile != null)
{
GaiaLighting.SetupPostProcessing(profile, m_profile, GaiaUtils.GetActivePipeline(), true);
}
}
else
{
GaiaLighting.RemoveAllPostProcessV2CameraLayer();
}
}
}
m_profile.m_spawnPlayerAtCurrentLocation = m_editorUtils.Toggle("SpawnPlayerAtCurrentLocation", m_profile.m_spawnPlayerAtCurrentLocation, helpEnabled);
GaiaConstants.EnvironmentControllerType controller = m_profile.m_controllerType;
controller = (GaiaConstants.EnvironmentControllerType)m_editorUtils.EnumPopup("ControllerType", controller, helpEnabled);
if (controller != m_profile.m_controllerType)
{
m_gaiaSettings.m_currentController = controller;
switch (controller)
{
case GaiaConstants.EnvironmentControllerType.FirstPerson:
GaiaSceneManagement.CreatePlayer(m_gaiaSettings, GaiaConstants.playerFirstPersonName, m_profile.m_spawnPlayerAtCurrentLocation, null, null, true);
break;
case GaiaConstants.EnvironmentControllerType.FlyingCamera:
GaiaSceneManagement.CreatePlayer(m_gaiaSettings, GaiaConstants.playerFlyCamName, m_profile.m_spawnPlayerAtCurrentLocation, null, null, true);
break;
case GaiaConstants.EnvironmentControllerType.ThirdPerson:
GaiaSceneManagement.CreatePlayer(m_gaiaSettings, GaiaConstants.playerThirdPersonName, m_profile.m_spawnPlayerAtCurrentLocation, null, null, true);
break;
case GaiaConstants.EnvironmentControllerType.Car:
GaiaSceneManagement.CreatePlayer(m_gaiaSettings, GaiaConstants.m_carPlayerPrefabName, m_profile.m_spawnPlayerAtCurrentLocation, null, null, true);
break;
case GaiaConstants.EnvironmentControllerType.XRController:
#if GAIA_XR
GaiaSceneManagement.CreatePlayer(m_gaiaSettings, "XRController", m_profile.m_spawnPlayerAtCurrentLocation);
#else
EditorUtility.DisplayDialog("XR Support not enabled", "The XR Controller is a default player for Virtual / Augmented Reality projects. Please open the Setup Panel in the Gaia Manager Standard Tab to enable XR Support in order to use the XR Player Controller. Please also make sure you have the Unity XR Interaction Toolkit package installed before doing so.", "OK");
controller = GaiaConstants.EnvironmentControllerType.FlyingCamera;
m_gaiaSettings.m_currentController = GaiaConstants.EnvironmentControllerType.FlyingCamera;
#endif
break;
}
SetPostProcessing(profile);
#if GAIA_PRO_PRESENT
if (GaiaUtils.HasDynamicLoadedTerrains())
{
TerrainLoader tl = ((GaiaScenePlayer)target).GetComponentInChildren <TerrainLoader>();
if (tl != null)
{
m_profile.UpdateTerrainLoaderFromProfile(ref tl);
}
}
#endif
m_profile.m_controllerType = controller;
}
if (controller == GaiaConstants.EnvironmentControllerType.Custom)
{
m_profile.m_customPlayer = (GameObject)m_editorUtils.ObjectField("MainPlayer", m_profile.m_customPlayer, typeof(GameObject), true, helpEnabled);
m_profile.m_customCamera = (Camera)m_editorUtils.ObjectField("MainCamera", m_profile.m_customCamera, typeof(Camera), true, helpEnabled);
if (m_editorUtils.Button("ApplySetup"))
{
GaiaSceneManagement.CreatePlayer(m_gaiaSettings, "Custom", m_profile.m_spawnPlayerAtCurrentLocation, m_profile.m_customPlayer, m_profile.m_customCamera, true);
SetPostProcessing(profile);
#if GAIA_PRO_PRESENT
if (GaiaUtils.HasDynamicLoadedTerrains())
{
TerrainLoader tl = ((GaiaScenePlayer)target).GetComponentInChildren <TerrainLoader>();
if (tl != null)
{
m_profile.UpdateTerrainLoaderFromProfile(ref tl);
}
}
#endif
}
}
EditorGUILayout.BeginHorizontal();
if (m_editorUtils.Button("MoveCameraToPlayer"))
{
GaiaSceneManagement.MoveCameraToPlayer(m_gaiaSettings);
}
if (m_editorUtils.Button("MovePlayerToCamera"))
{
GaiaSceneManagement.MovePlayerToCamera(m_gaiaSettings);
}
EditorGUILayout.EndHorizontal();
EditorGUILayout.Space();
m_editorUtils.Panel("AutoDepthOfFieldSettings", AutoDepthOfField);
m_editorUtils.Panel("LocationManagerSettings", LocationManagerSettings);
m_editorUtils.Panel("PlayerCameraCullingSettings", CameraCullingSettings);
if (GaiaUtils.HasDynamicLoadedTerrains())
{
m_editorUtils.Panel("TerrainLoadingSettings", TerrainLoadingSettings);
}
}
/// <summary>
/// Apply URP post fx
/// </summary>
/// <param name="profile"></param>
/// <param name="lightingProfile"></param>
public static GameObject ApplyURPPostProcessing(GaiaLightingProfileValues profile, SceneProfile lightingProfile)
{
try
{
GameObject volumeObject = null;
#if UPPipeline
if (lightingProfile.m_enablePostProcessing)
{
volumeObject = GameObject.Find("Global Post Processing");
if (volumeObject == null)
{
volumeObject = new GameObject("Global Post Processing");
}
GameObject parentObject = GaiaLighting.GetOrCreateParentObject(GaiaConstants.gaiaLightingObject, true);
if (parentObject != null)
{
volumeObject.transform.SetParent(parentObject.transform);
}
volumeObject.layer = 0;
Volume volume = volumeObject.GetComponent <Volume>();
if (volume == null)
{
volume = volumeObject.AddComponent <Volume>();
}
if (GaiaGlobal.Instance != null)
{
SceneProfile sceneProfile = GaiaGlobal.Instance.SceneProfile;
if (sceneProfile != null)
{
if (sceneProfile.m_lightingEditSettings || profile.m_userCustomProfile)
{
sceneProfile.m_universalPostFXProfile = profile.PostProcessProfileURP;
}
else
{
CreatePostFXProfileInstance(sceneProfile, profile);
}
volume.sharedProfile = sceneProfile.m_universalPostFXProfile;
Camera camera = GaiaUtils.GetCamera();
if (camera != null)
{
UniversalAdditionalCameraData cameraData = camera.GetComponent <UniversalAdditionalCameraData>();
if (cameraData == null)
{
cameraData = camera.gameObject.AddComponent <UniversalAdditionalCameraData>();
}
cameraData.renderPostProcessing = true;
GaiaLighting.ConfigureAntiAliasing(sceneProfile, GaiaConstants.EnvironmentRenderer.Universal);
}
}
}
}
else
{
volumeObject = GameObject.Find("Global Post Processing");
if (volumeObject != null)
{
GameObject.DestroyImmediate(volumeObject);
}
Camera camera = GaiaUtils.GetCamera();
if (camera != null)
{
UniversalAdditionalCameraData cameraData = camera.GetComponent <UniversalAdditionalCameraData>();
if (cameraData == null)
{
cameraData = camera.gameObject.AddComponent <UniversalAdditionalCameraData>();
}
cameraData.renderPostProcessing = false;
}
}
#endif
#if UNITY_POST_PROCESSING_STACK_V2
PostProcessLayer postProcessLayer = GameObject.FindObjectOfType <PostProcessLayer>();
if (postProcessLayer != null)
{
GameObject.DestroyImmediate(postProcessLayer);
}
PostProcessVolume postProcessVolume = GameObject.FindObjectOfType <PostProcessVolume>();
if (postProcessVolume != null)
{
GameObject.DestroyImmediate(postProcessVolume);
}
#endif
return(volumeObject);
}
catch (Exception e)
{
Console.WriteLine(e);
throw;
}
}
public static void GX_TimeOfDay_RemoveGaiaLighting()
{
GaiaLighting.RemoveGaiaLighting();
}
/// <summary>
/// Sets the time of day to morning
/// </summary>
//public static void GX_TimeOfDay_Morning()
//{
// GaiaLightingProfile lightingProfile = AssetDatabase.LoadAssetAtPath<GaiaLightingProfile>(GetAssetPath("Gaia Lighting System Profile"));
// GaiaSettings gaiaSettings = GaiaUtils.GetGaiaSettings();
// GaiaLighting.GetProfile(GaiaConstants.GaiaLightingProfileType.Morning, lightingProfile, gaiaSettings.m_pipelineProfile, gaiaSettings.m_currentRenderer);
//}
///// <summary>
///// Sets the time of day to day
///// </summary>
//public static void GX_TimeOfDay_Day()
//{
// GaiaLightingProfile lightingProfile = AssetDatabase.LoadAssetAtPath<GaiaLightingProfile>(GetAssetPath("Gaia Lighting System Profile"));
// GaiaSettings gaiaSettings = GaiaUtils.GetGaiaSettings();
// GaiaLighting.GetProfile(GaiaConstants.GaiaLightingProfileType.Day, lightingProfile, gaiaSettings.m_pipelineProfile, gaiaSettings.m_currentRenderer);
//}
///// <summary>
///// Sets the time of day to evening
///// </summary>
//public static void GX_TimeOfDay_Evening()
//{
// GaiaLightingProfile lightingProfile = AssetDatabase.LoadAssetAtPath<GaiaLightingProfile>(GetAssetPath("Gaia Lighting System Profile"));
// GaiaSettings gaiaSettings = GaiaUtils.GetGaiaSettings();
// GaiaLighting.GetProfile(GaiaConstants.GaiaLightingProfileType.Evening, lightingProfile, gaiaSettings.m_pipelineProfile, gaiaSettings.m_currentRenderer);
//}
///// <summary>
///// Sets the time of day to night
///// </summary>
//public static void GX_TimeOfDay_Night()
//{
// GaiaLightingProfile lightingProfile = AssetDatabase.LoadAssetAtPath<GaiaLightingProfile>(GetAssetPath("Gaia Lighting System Profile"));
// GaiaSettings gaiaSettings = GaiaUtils.GetGaiaSettings();
// GaiaLighting.GetProfile(GaiaConstants.GaiaLightingProfileType.Night, lightingProfile, gaiaSettings.m_pipelineProfile, gaiaSettings.m_currentRenderer);
//}
///// <summary>
///// Sets the time of day to default procedural
///// </summary>
//public static void GX_TimeOfDay_DefaultProcedural()
//{
// GaiaLightingProfile lightingProfile = AssetDatabase.LoadAssetAtPath<GaiaLightingProfile>(GetAssetPath("Gaia Lighting System Profile"));
// GaiaSettings gaiaSettings = GaiaUtils.GetGaiaSettings();
// GaiaLighting.GetProfile(GaiaConstants.GaiaLightingProfileType.Default, lightingProfile, gaiaSettings.m_pipelineProfile, gaiaSettings.m_currentRenderer);
//}
/// <summary>
/// Removes gaia lighting from the scene
/// </summary>
///
public static void GX_TimeOfDay_SelectLightingAndWaterProfile()
{
GaiaLighting.OpenProfileSelection();
}
private void OnDisable()
{
GaiaLighting.SetPostProcessingStatus(true);
}
private void DrawSummary(bool helpEnabled)
{
m_manager.m_session = (GaiaSession)m_editorUtils.ObjectField("SessionData", m_manager.m_session, typeof(GaiaSession), helpEnabled);
m_editorUtils.InlineHelp("SessionData", helpEnabled);
if (m_manager.m_session == null)
{
if (m_editorUtils.Button("CreateSessionButton"))
{
m_manager.CreateSession();
}
}
if (m_manager.m_session == null)
{
return;
}
EditorGUI.BeginChangeCheck();
m_manager.m_session.m_name = m_editorUtils.DelayedTextField("Name", m_manager.m_session.m_name, helpEnabled);
if (EditorGUI.EndChangeCheck())
{
//Get the old path
string oldSessionDataPath = GaiaDirectories.GetSessionSubFolderPath(m_manager.m_session);
//Rename the session asset
AssetDatabase.RenameAsset(AssetDatabase.GetAssetPath(m_manager.m_session), m_manager.m_session.m_name + ".asset");
//rename the session data path as well
string newSessionDataPath = GaiaDirectories.GetSessionSubFolderPath(m_manager.m_session, false);
AssetDatabase.MoveAsset(oldSessionDataPath, newSessionDataPath);
//if we have terrain scenes stored in the Terrain Loader, we need to update the paths in there as well
foreach (TerrainScene terrainScene in TerrainLoaderManager.TerrainScenes)
{
terrainScene.m_scenePath = terrainScene.m_scenePath.Replace(oldSessionDataPath, newSessionDataPath);
terrainScene.m_impostorScenePath = terrainScene.m_impostorScenePath.Replace(oldSessionDataPath, newSessionDataPath);
terrainScene.m_backupScenePath = terrainScene.m_backupScenePath.Replace(oldSessionDataPath, newSessionDataPath);
terrainScene.m_colliderScenePath = terrainScene.m_colliderScenePath.Replace(oldSessionDataPath, newSessionDataPath);
}
TerrainLoaderManager.Instance.SaveStorageData();
AssetDatabase.DeleteAsset(oldSessionDataPath);
AssetDatabase.SaveAssets();
}
EditorGUILayout.BeginHorizontal();
EditorGUILayout.LabelField(m_editorUtils.GetContent("Description"), GUILayout.MaxWidth(EditorGUIUtility.labelWidth));
m_manager.m_session.m_description = EditorGUILayout.TextArea(m_manager.m_session.m_description, GUILayout.MinHeight(100));
EditorGUILayout.EndHorizontal();
m_editorUtils.InlineHelp("Description", helpEnabled);
m_manager.m_session.m_previewImage = (Texture2D)m_editorUtils.ObjectField("PreviewImage", m_manager.m_session.m_previewImage, typeof(Texture2D), helpEnabled);
GUILayout.BeginHorizontal();
Rect rect = EditorGUILayout.GetControlRect();
GUILayout.Space(rect.width - 20);
if (GUILayout.Button("Generate Image"))
{
string textureFileName = GaiaDirectories.GetSessionSubFolderPath(m_manager.m_session) + Path.DirectorySeparatorChar + m_manager.m_session + "_Preview";
var originalLODBias = QualitySettings.lodBias;
QualitySettings.lodBias = 100;
OrthographicBake.BakeTerrain(Terrain.activeTerrain, 2048, 2048, Camera.main.cullingMask, textureFileName);
OrthographicBake.RemoveOrthoCam();
QualitySettings.lodBias = originalLODBias;
textureFileName += ".png";
AssetDatabase.ImportAsset(textureFileName);
var importer = AssetImporter.GetAtPath(textureFileName) as TextureImporter;
if (importer != null)
{
importer.sRGBTexture = false;
importer.alphaIsTransparency = false;
importer.alphaSource = TextureImporterAlphaSource.None;
importer.mipmapEnabled = false;
}
AssetDatabase.ImportAsset(textureFileName);
m_manager.m_session.m_previewImage = (Texture2D)AssetDatabase.LoadAssetAtPath(textureFileName, typeof(Texture2D));
}
GUILayout.EndHorizontal();
m_editorUtils.InlineHelp("PreviewImage", helpEnabled);
m_editorUtils.LabelField("Created", new GUIContent(m_manager.m_session.m_dateCreated), helpEnabled);
m_manager.m_session.m_isLocked = m_editorUtils.Toggle("Locked", m_manager.m_session.m_isLocked, helpEnabled);
float maxSeaLevel = 2000f;
if (Terrain.activeTerrain != null)
{
maxSeaLevel = Terrain.activeTerrain.terrainData.size.y + Terrain.activeTerrain.transform.position.y;
}
else
{
maxSeaLevel = m_manager.GetSeaLevel(false) + 500f;
}
float oldSeaLevel = m_manager.GetSeaLevel(false);
float newSeaLEvel = oldSeaLevel;
newSeaLEvel = m_editorUtils.Slider("SeaLevel", newSeaLEvel, 0, maxSeaLevel, helpEnabled);
if (newSeaLEvel != oldSeaLevel)
{
//Do we have a water instance? If yes, update it & it will update the sea level in the session as well
if (PWS_WaterSystem.Instance != null)
{
PWS_WaterSystem.Instance.SeaLevel = newSeaLEvel;
}
else
{
//no water instance yet, just update the sea level in the session
m_manager.SetSeaLevel(newSeaLEvel, false);
SceneView.RepaintAll();
}
}
m_manager.m_session.m_spawnDensity = m_editorUtils.FloatField("SpawnDensity", Mathf.Max(0.01f, m_manager.m_session.m_spawnDensity), helpEnabled);
GUILayout.BeginHorizontal();
if (m_editorUtils.Button("DeleteAllOperations"))
{
if (EditorUtility.DisplayDialog(m_editorUtils.GetTextValue("PopupDeleteAllTitle"), m_editorUtils.GetTextValue("PopupDeleteAllMessage"), m_editorUtils.GetTextValue("Continue"), m_editorUtils.GetTextValue("Cancel")))
{
foreach (GaiaOperation op in m_manager.m_session.m_operations)
{
try
{
if (!String.IsNullOrEmpty(op.scriptableObjectAssetGUID))
{
AssetDatabase.DeleteAsset(AssetDatabase.GUIDToAssetPath(op.scriptableObjectAssetGUID));
}
}
catch (Exception ex)
{
Debug.LogError("Error while deleting one of the operation data files: " + ex.Message + " Stack Trace:" + ex.StackTrace);
}
}
m_manager.m_session.m_operations.Clear();
}
}
if (m_editorUtils.Button("PlaySession"))
{
GaiaLighting.SetDefaultAmbientLight(GaiaUtils.GetGaiaSettings().m_gaiaLightingProfile);
GaiaSessionManager.PlaySession();
}
GUILayout.EndHorizontal();
}
/// <summary>
/// Cancels occlusion bake
/// </summary>
public static void GX_OcclusionCulling_CancelOcclusionCulling()
{
GaiaLighting.CancelOcclusionCulling(true, false, false);
}
private void GlobalSettingsPanel(bool helpEnabled)
{
if (Application.isPlaying)
{
LoadFromApplicationPlaying();
}
m_editorUtils.Text("GaiaRuntimeInfo");
EditorGUILayout.Space();
m_profile.m_mainCamera = (Camera)m_editorUtils.ObjectField("MainCamera", m_profile.m_mainCamera, typeof(Camera), true, helpEnabled);
if (m_profile.SceneProfile != null)
{
EditorGUI.BeginChangeCheck();
EditorGUILayout.BeginHorizontal();
m_profile.SceneProfile.m_lightSystemMode = (GaiaConstants.GlobalSystemMode)m_editorUtils.EnumPopup("LightingSystemMode", m_profile.SceneProfile.m_lightSystemMode);
if (m_profile.SceneProfile.m_lightSystemMode == GaiaConstants.GlobalSystemMode.Gaia)
{
if (m_profile.SceneProfile.m_lightingProfiles.Count > 0)
{
if (m_editorUtils.Button("AdvancedLightingSettings", GUILayout.MaxWidth(170f)))
{
GaiaLighting.FocusGaiaLightingProfile();
}
}
}
else if (m_profile.SceneProfile.m_lightSystemMode == GaiaConstants.GlobalSystemMode.ThirdParty)
{
if (m_editorUtils.Button("AdvancedLightingSettings", GUILayout.MaxWidth(170f)))
{
GaiaLighting.FocusGaiaLightingProfile();
}
/*if (m_profile.SceneProfile.m_thirdPartyLightObject != null)
* {
* if (m_editorUtils.Button("EditThirdParty", GUILayout.MaxWidth(170f)))
* {
* Selection.activeObject = m_profile.SceneProfile.m_thirdPartyLightObject;
* }
* }
* else
* {
* if (m_editorUtils.Button("AdvancedLightingSettings", GUILayout.MaxWidth(170f)))
* {
* GaiaLighting.FocusGaiaLightingProfile();
* }
* }*/
}
EditorGUILayout.EndHorizontal();
m_editorUtils.InlineHelp("LightingSystemMode", helpEnabled);
if (m_profile.SceneProfile.m_lightSystemMode == GaiaConstants.GlobalSystemMode.Gaia)
{
if (m_profile.SceneProfile.m_lightingProfiles.Count < 1)
{
EditorGUILayout.HelpBox("No lighting data has been set you can go to Gaia Manager and click step 2 to create skies and water or you can go to Save and Load and click Revert To Defaults to load the skies and water data.", MessageType.Info);
}
}
else if (m_profile.SceneProfile.m_lightSystemMode == GaiaConstants.GlobalSystemMode.ThirdParty)
{
if (m_profile.SceneProfile.m_thirdPartyLightObject == null)
{
EditorGUILayout.HelpBox("No Lighting System has been set, open 'Advanced Lighting Settings' to setup", MessageType.Info);
}
}
else
{
EditorGUILayout.HelpBox("Lighting System Mode is set to 'None' to use light set the mode to 'Gaia or ThirdParty'", MessageType.Info);
}
EditorGUILayout.BeginHorizontal();
m_profile.SceneProfile.m_waterSystemMode = (GaiaConstants.GlobalSystemMode)m_editorUtils.EnumPopup("WaterSystemMode", m_profile.SceneProfile.m_waterSystemMode);
if (m_profile.SceneProfile.m_waterSystemMode == GaiaConstants.GlobalSystemMode.Gaia)
{
if (m_profile.SceneProfile.m_waterProfiles.Count > 0)
{
if (m_editorUtils.Button("AdvancedWaterSettings", GUILayout.MaxWidth(170f)))
{
GaiaUtils.FocusWaterProfile();
}
}
}
else if (m_profile.SceneProfile.m_waterSystemMode == GaiaConstants.GlobalSystemMode.ThirdParty)
{
if (m_editorUtils.Button("AdvancedWaterSettings", GUILayout.MaxWidth(170f)))
{
GaiaUtils.FocusWaterProfile();
}
/*if (m_profile.SceneProfile.m_thirdPartyWaterObject != null)
* {
* if (m_editorUtils.Button("EditThirdParty", GUILayout.MaxWidth(170f)))
* {
* Selection.activeObject = m_profile.SceneProfile.m_thirdPartyLightObject;
* }
* }
* else
* {
* if (m_editorUtils.Button("AdvancedWaterSettings", GUILayout.MaxWidth(170f)))
* {
* GaiaUtils.FocusWaterProfile();
* }
* }*/
}
EditorGUILayout.EndHorizontal();
m_editorUtils.InlineHelp("WaterSystemMode", helpEnabled);
if (m_profile.SceneProfile.m_waterSystemMode == GaiaConstants.GlobalSystemMode.Gaia)
{
if (m_profile.SceneProfile.m_lightingProfiles.Count < 1)
{
EditorGUILayout.HelpBox("No lighting data has been set you can go to Gaia Manager and click step 2 to create skies and water or you can go to Save and Load and click Revert To Defaults to load the skies and water data.", MessageType.Info);
}
}
else if (m_profile.SceneProfile.m_waterSystemMode == GaiaConstants.GlobalSystemMode.ThirdParty)
{
if (m_profile.SceneProfile.m_thirdPartyWaterObject == null)
{
EditorGUILayout.HelpBox("No Water System has been set, open 'Advanced Water Settings' to setup", MessageType.Info);
}
}
else
{
EditorGUILayout.HelpBox("Water System Mode is set to 'None' to use light set the mode to 'Gaia or ThirdParty'", MessageType.Info);
}
if (EditorGUI.EndChangeCheck())
{
EditorUtility.SetDirty(m_profile);
Undo.RecordObject(m_profile, "Changes Made");
m_profile.UpdateGaiaTimeOfDay(false);
m_profile.UpdateGaiaWeather();
}
m_editorUtils.Panel("SaveAndLoad", SaveAndLoad);
}
}
/// <summary>
/// Clears occlusion data
/// </summary>
public static void GX_OcclusionCulling_ClearOcclusionCulling()
{
GaiaLighting.ClearOcclusionCulling(true, false, true);
}
/// <summary>
/// Adds occlusion culling volume
/// </summary>
public static void GX_OcclusionCulling_AddOcclusionCullingVolume()
{
GaiaLighting.AddOcclusionCulling(true, false, false);
}
/// <summary>
/// Cleans up LWRP components in the scene
/// </summary>
public static void CleanUpLWRP(UnityPipelineProfile profile, GaiaSettings gaiaSettings)
{
#if LWPipeline
LWRPAdditionalCameraData[] camerasData = Object.FindObjectsOfType <LWRPAdditionalCameraData>();
if (camerasData != null)
{
foreach (LWRPAdditionalCameraData data in camerasData)
{
Object.DestroyImmediate(data);
}
}
LWRPAdditionalLightData[] lightsData = Object.FindObjectsOfType <LWRPAdditionalLightData>();
if (lightsData != null)
{
foreach (LWRPAdditionalLightData data in lightsData)
{
Object.DestroyImmediate(data);
}
}
#endif
if (profile.m_underwaterHorizonMaterial != null)
{
profile.m_underwaterHorizonMaterial.shader = Shader.Find(profile.m_builtInHorizonObjectShader);
}
//reverting default water mesh quality
gaiaSettings.m_gaiaWaterProfile.m_customMeshQuality = 2;
if (GaiaGlobal.Instance != null)
{
GaiaWater.UpdateWaterMeshQuality(GaiaGlobal.Instance.SceneProfile, gaiaSettings.m_gaiaWaterProfile.m_waterPrefab);
}
GameObject waterPrefab = GameObject.Find(gaiaSettings.m_gaiaWaterProfile.m_waterPrefab.name);
if (waterPrefab != null)
{
PWS_WaterSystem reflection = waterPrefab.GetComponent <PWS_WaterSystem>();
if (reflection == null)
{
reflection = waterPrefab.AddComponent <PWS_WaterSystem>();
}
}
Terrain[] terrains = Terrain.activeTerrains;
if (terrains != null)
{
foreach (Terrain terrain in terrains)
{
#if !UNITY_2019_2_OR_NEWER
terrain.materialType = Terrain.MaterialType.BuiltInStandard;
#else
terrain.materialTemplate = profile.m_builtInTerrainMaterial;
#endif
}
}
Terrain terrainDetail = Terrain.activeTerrain;
if (terrainDetail != null)
{
if (terrainDetail.detailObjectDensity == 0f)
{
if (EditorUtility.DisplayDialog("Detail Density Disabled!", "Details density is disabled on your terrain would you like to activate it?", "Yes", "No"))
{
terrainDetail.detailObjectDensity = 0.3f;
}
}
}
GameObject LWRPReflections = GameObject.Find("LWRP Water Reflection Probe");
if (LWRPReflections != null)
{
Object.DestroyImmediate(LWRPReflections);
}
GraphicsSettings.renderPipelineAsset = null;
if (GaiaGlobal.Instance != null)
{
GaiaUtils.GetRuntimeSceneObject();
GaiaLighting.GetProfile(GaiaGlobal.Instance.SceneProfile, gaiaSettings.m_pipelineProfile, GaiaConstants.EnvironmentRenderer.BuiltIn);
}
if (waterPrefab != null)
{
Material waterMat = GaiaWater.GetGaiaOceanMaterial();
if (waterMat != null)
{
if (GaiaGlobal.Instance != null)
{
GaiaWater.GetProfile(0, waterMat, GaiaGlobal.Instance.SceneProfile, true, false);
}
}
else
{
Debug.Log("Material could not be found");
}
}
MarkSceneDirty(false);
EditorUtility.SetDirty(profile);
profile.m_activePipelineInstalled = GaiaConstants.EnvironmentRenderer.BuiltIn;
GaiaManagerEditor manager = EditorWindow.GetWindow <Gaia.GaiaManagerEditor>(false, "Gaia Manager");
if (manager != null)
{
manager.GaiaManagerStatusCheck(true);
}
bool isChanged = false;
string currBuildSettings = PlayerSettings.GetScriptingDefineSymbolsForGroup(EditorUserBuildSettings.selectedBuildTargetGroup);
if (currBuildSettings.Contains("LWPipeline"))
{
currBuildSettings = currBuildSettings.Replace("LWPipeline;", "");
currBuildSettings = currBuildSettings.Replace("LWPipeline", "");
isChanged = true;
}
if (isChanged)
{
PlayerSettings.SetScriptingDefineSymbolsForGroup(EditorUserBuildSettings.selectedBuildTargetGroup, currBuildSettings);
}
}
/// <summary>
/// Cleans up LWRP components in the scene
/// </summary>
public static void CleanUpURP(UnityPipelineProfile profile, GaiaSettings gaiaSettings)
{
try
{
#if UPPipeline
UniversalAdditionalCameraData[] camerasData = GameObject.FindObjectsOfType <UniversalAdditionalCameraData>();
GaiaURPRuntimeUtils.ClearUPCameraData(camerasData);
UniversalAdditionalLightData[] lightsData = GameObject.FindObjectsOfType <UniversalAdditionalLightData>();
GaiaURPRuntimeUtils.ClearUPLightData(lightsData);
GameObject volumeObject = GameObject.Find("Global Post Processing");
if (volumeObject != null)
{
GameObject.DestroyImmediate(volumeObject);
}
Camera camera = GaiaUtils.GetCamera();
if (camera != null)
{
UniversalAdditionalCameraData cameraData = camera.GetComponent <UniversalAdditionalCameraData>();
if (cameraData == null)
{
cameraData = camera.gameObject.AddComponent <UniversalAdditionalCameraData>();
}
cameraData.renderPostProcessing = false;
}
#endif
if (profile.m_underwaterHorizonMaterial != null)
{
profile.m_underwaterHorizonMaterial.shader = Shader.Find(profile.m_builtInHorizonObjectShader);
}
GameObject waterPrefab = GameObject.Find(gaiaSettings.m_gaiaWaterProfile.m_waterPrefab.name);
if (waterPrefab != null)
{
//reverting default water mesh quality
gaiaSettings.m_gaiaWaterProfile.m_customMeshQuality = 2;
if (GaiaGlobal.Instance != null)
{
GaiaWater.UpdateWaterMeshQuality(GaiaGlobal.Instance.SceneProfile, gaiaSettings.m_gaiaWaterProfile.m_waterPrefab);
}
PWS_WaterSystem reflection = waterPrefab.GetComponent <PWS_WaterSystem>();
if (reflection == null)
{
reflection = waterPrefab.AddComponent <PWS_WaterSystem>();
}
}
Terrain[] terrains = Terrain.activeTerrains;
if (terrains != null)
{
foreach (Terrain terrain in terrains)
{
#if !UNITY_2019_2_OR_NEWER
terrain.materialType = Terrain.MaterialType.BuiltInStandard;
#else
terrain.materialTemplate = profile.m_builtInTerrainMaterial;
#endif
}
}
Terrain terrainDetail = Terrain.activeTerrain;
if (terrainDetail != null)
{
if (terrainDetail.detailObjectDensity == 0f)
{
if (EditorUtility.DisplayDialog("Detail Density Disabled!", "Details density is disabled on your terrain would you like to activate it?", "Yes", "No"))
{
terrainDetail.detailObjectDensity = 0.3f;
}
}
}
GameObject LWRPReflections = GameObject.Find("URP Water Reflection Probe");
if (LWRPReflections != null)
{
Object.DestroyImmediate(LWRPReflections);
}
GraphicsSettings.renderPipelineAsset = null;
QualitySettings.renderPipeline = null;
if (GaiaGlobal.Instance != null)
{
//GaiaUtils.GetRuntimeSceneObject();
if (GaiaGlobal.Instance.SceneProfile != null && GaiaGlobal.Instance.SceneProfile.m_lightingProfiles.Count > 0)
{
GaiaLighting.GetProfile(GaiaGlobal.Instance.SceneProfile, gaiaSettings.m_pipelineProfile, GaiaConstants.EnvironmentRenderer.BuiltIn);
}
}
//Clean up the UPR post processing objects in the underwater effects
//We need to look for transform instead of GameObjects, since the GOs can be disabled and won't be found then
GameObject uwe = GameObject.Find(GaiaConstants.underwaterEffectsName);
if (uwe != null)
{
Transform utoTransform = uwe.transform.Find(GaiaConstants.underwaterTransitionObjectName);
if (utoTransform != null)
{
Object.DestroyImmediate(utoTransform.gameObject);
}
Transform uppTransform = uwe.transform.Find(GaiaConstants.underwaterPostProcessingName);
if (uppTransform != null)
{
Object.DestroyImmediate(uppTransform.gameObject);
}
Transform horizonTransform = uwe.transform.Find(GaiaConstants.underwaterHorizonName);
if (horizonTransform != null)
{
Object.DestroyImmediate(horizonTransform.gameObject);
}
}
if (waterPrefab != null)
{
Material waterMat = GaiaWater.GetGaiaOceanMaterial();
if (waterMat != null)
{
if (GaiaGlobal.Instance != null)
{
GaiaWater.GetProfile(gaiaSettings.m_gaiaWaterProfile.m_selectedWaterProfileValuesIndex, waterMat, GaiaGlobal.Instance.SceneProfile, true, false);
}
}
else
{
Debug.Log("Material could not be found");
}
}
MarkSceneDirty(false);
EditorUtility.SetDirty(profile);
profile.m_activePipelineInstalled = GaiaConstants.EnvironmentRenderer.BuiltIn;
GaiaManagerEditor manager = EditorWindow.GetWindow <Gaia.GaiaManagerEditor>(false, "Gaia Manager");
if (manager != null)
{
manager.GaiaManagerStatusCheck(true);
}
bool isChanged = false;
string currBuildSettings = PlayerSettings.GetScriptingDefineSymbolsForGroup(EditorUserBuildSettings.selectedBuildTargetGroup);
if (currBuildSettings.Contains("UPPipeline"))
{
currBuildSettings = currBuildSettings.Replace("UPPipeline;", "");
currBuildSettings = currBuildSettings.Replace("UPPipeline", "");
isChanged = true;
}
if (isChanged)
{
PlayerSettings.SetScriptingDefineSymbolsForGroup(EditorUserBuildSettings.selectedBuildTargetGroup, currBuildSettings);
}
}
catch (Exception e)
{
Console.WriteLine(e);
throw;
}
}
/// <summary>
/// Removes occlusion volume
/// </summary>
public static void GX_OcclusionCulling_RemoveOcclusionCullingVolume()
{
GaiaLighting.RemoveOcclusionCulling(false, false, false);
}
