private void GlobalPanel(bool helpEnabled)
{
EditorGUI.BeginChangeCheck();
m_editorUtils.Heading("GlobalSettings");
HDR = m_bufferManager.m_allowHDR;
HDR = m_editorUtils.Toggle("AllowHDR", HDR, helpEnabled);
RenderSize = m_bufferManager.m_renderSize;
RenderSize = (PW_RENDER_SIZE)m_editorUtils.EnumPopup("RenderResolution", RenderSize, helpEnabled);
EditorGUILayout.Space();
m_editorUtils.Heading("RefreactionSettings");
RefractionCameraEvent = m_bufferManager.m_cameraEventRefraction;
if (Application.isPlaying)
{
EditorGUILayout.HelpBox(m_editorUtils.GetTextValue("CantBeChangedAtRunTime"), MessageType.Info);
GUI.enabled = false;
}
RefractionCameraEvent = (CameraEvent)m_editorUtils.EnumPopup("RefractionCameraEvent", RefractionCameraEvent, helpEnabled);
GUI.enabled = true;
if (EditorGUI.EndChangeCheck())
{
if (ChangesMade())
{
m_bufferManager.ClearBuffers();
m_bufferManager.m_allowHDR = HDR;
m_bufferManager.m_renderSize = RenderSize;
m_bufferManager.m_cameraEventRefraction = RefractionCameraEvent;
m_bufferManager.RebuildBuffers(false);
EditorUtility.SetDirty(m_bufferManager);
}
}
}
private void Setup(bool helpEnabled)
{
m_profile.m_locationProfile = (LocationSystemScriptableObject)m_editorUtils.ObjectField("LocationProfile", m_profile.m_locationProfile, typeof(LocationSystemScriptableObject), false, helpEnabled);
if (m_profile.m_locationProfile == null)
{
m_profile.m_locationProfile = AssetDatabase.LoadAssetAtPath <LocationSystemScriptableObject>(GaiaUtils.GetAssetPath("Location Profile.asset"));
}
if (m_profile.m_camera == null)
{
EditorGUILayout.BeginHorizontal();
m_profile.m_camera = (Transform)m_editorUtils.ObjectField("Camera", m_profile.m_camera, typeof(Transform), true, helpEnabled);
if (m_editorUtils.Button("FindCamera", GUILayout.MaxWidth(50f)))
{
Camera locatedCam = GaiaUtils.GetCamera();
if (locatedCam != null)
{
m_profile.m_camera = locatedCam.transform;
}
else
{
Debug.LogWarning("No camera could be found in your scene please add one from the GameObject/Camera in the top toolbar.");
}
}
EditorGUILayout.EndHorizontal();
EditorGUILayout.HelpBox("A camera transform must be provided for Location Manager to work. You can press 'Find' button to quickly locate the camera in the scene.", MessageType.Warning);
}
else
{
m_profile.m_camera = (Transform)m_editorUtils.ObjectField("Camera", m_profile.m_camera, typeof(Transform), true, helpEnabled);
}
m_profile.m_player = (Transform)m_editorUtils.ObjectField("Player", m_profile.m_player, typeof(Transform), true, helpEnabled);
m_profile.m_trackPlayer = m_editorUtils.Toggle("TrackPlayer", m_profile.m_trackPlayer, helpEnabled);
}
private void GlobalPanel(bool helpEnabled)
{
EditorGUILayout.HelpBox(m_editorUtils.GetTextValue("WindManagerInfo"), MessageType.Info);
m_manager.windGlobalMaxDist = m_editorUtils.Slider("GlobalWindDistance", m_manager.windGlobalMaxDist, 100f, 10000f, helpEnabled);
EditorGUILayout.Space();
m_editorUtils.Heading("WindSettings");
m_manager.m_useWindAudio = m_editorUtils.Toggle("UseWindAudio", m_manager.m_useWindAudio, helpEnabled);
if (m_manager.m_useWindAudio)
{
EditorGUI.indentLevel++;
m_manager.m_windTransitionTime = m_editorUtils.FloatField("WindTransitionTime", m_manager.m_windTransitionTime, helpEnabled);
if (m_manager.m_windTransitionTime < 0.1f)
{
m_manager.m_windTransitionTime = 0.1f;
}
m_manager.m_windAudioClip = (AudioClip)m_editorUtils.ObjectField("WindAudioClip", m_manager.m_windAudioClip, typeof(AudioClip), false, helpEnabled);
EditorGUI.indentLevel--;
}
}
public override void OnInspectorGUI()
{
m_editorUtils.Initialize(); // Do not remove this!
m_orderBy = (GaiaStopwatchOrderBy)m_editorUtils.EnumPopup("OrderBy", m_orderBy);
m_orderbyDescending = m_editorUtils.Toggle("Descending", m_orderbyDescending);
switch (m_orderBy)
{
case GaiaStopwatchOrderBy.FirstStart:
m_orderByLambda = x => x.m_firstStartTimeStamp;
break;
case GaiaStopwatchOrderBy.Name:
m_orderByLambda = x => x.m_name;
break;
case GaiaStopwatchOrderBy.TotalDuration:
m_orderByLambda = x => x.m_accumulatedTime;
break;
}
List <GaiaStopWatchEvent> relevantEvents;
if (m_orderbyDescending)
{
relevantEvents = m_gaiastopwatchDataset.m_events.FindAll(x => x.m_parent == "" || x.m_parent == null).OrderByDescending(m_orderByLambda).ToList();
}
else
{
relevantEvents = m_gaiastopwatchDataset.m_events.FindAll(x => x.m_parent == "" || x.m_parent == null).OrderBy(m_orderByLambda).ToList();
}
foreach (GaiaStopWatchEvent stopWatchEvent in relevantEvents)
{
DrawStopwatchEvent(stopWatchEvent);
}
}
private void GlobalSettings(bool helpEnabled)
{
m_editorUtils.Heading("ScreenshotSetup");
EditorGUI.indentLevel++;
m_profile.m_mainCamera = (Camera)m_editorUtils.ObjectField("MainCamera", m_profile.m_mainCamera, typeof(Camera), true, helpEnabled);
m_profile.m_watermark = (Texture2D)m_editorUtils.ObjectField("Watermark", m_profile.m_watermark, typeof(Texture2D), true, helpEnabled, GUILayout.MaxHeight(16f));
m_profile.m_targetDirectory = m_editorUtils.TextField("TargetDirectory", m_profile.m_targetDirectory, helpEnabled);
m_profile.m_screenShotKey = (KeyCode)m_editorUtils.EnumPopup("ScreenshotKey", m_profile.m_screenShotKey, helpEnabled);
m_profile.m_imageFormat = (GaiaConstants.ImageFileType)m_editorUtils.EnumPopup("ImageFormat", m_profile.m_imageFormat, helpEnabled);
EditorGUI.indentLevel--;
EditorGUILayout.Space();
m_editorUtils.Heading("ScreenshotResolutionSetup");
EditorGUI.indentLevel++;
m_profile.m_useScreenSize = m_editorUtils.Toggle("UseScreenSize", m_profile.m_useScreenSize, helpEnabled);
if (!m_profile.m_useScreenSize)
{
GaiaConstants.ScreenshotResolution screenshotResolution = m_profile.m_screenshotResolution;
screenshotResolution = (GaiaConstants.ScreenshotResolution)m_editorUtils.EnumPopup("ScreenshotResolution", screenshotResolution, helpEnabled);
if (screenshotResolution != m_profile.m_screenshotResolution)
{
m_profile.m_screenshotResolution = screenshotResolution;
m_profile.UpdateScreenshotResolution(m_profile.m_screenshotResolution);
}
if (screenshotResolution == GaiaConstants.ScreenshotResolution.Custom)
{
EditorGUI.indentLevel++;
m_profile.m_targetWidth = m_editorUtils.IntField("TargetWidth", m_profile.m_targetWidth, helpEnabled);
m_profile.m_targetHeight = m_editorUtils.IntField("TargetHeight", m_profile.m_targetHeight, helpEnabled);
EditorGUI.indentLevel--;
}
}
EditorGUI.indentLevel--;
}
private void GlobalSettingsEnabled(bool helpEnabled)
{
if (PlayerSettings.colorSpace != ColorSpace.Linear)
{
GUI.backgroundColor = Color.yellow;
EditorGUILayout.HelpBox("Gaia lighting looks best in Linear Color Space. Go to Gaia standard tab and press Set Linear Deferred", MessageType.Warning);
}
GUI.backgroundColor = defaultBackground;
m_editorUtils.Heading("SetupSettings");
m_profile.m_multiSceneLightingSupport = m_editorUtils.Toggle("MultiSceneSupport", m_profile.m_multiSceneLightingSupport, helpEnabled);
if (m_renderPipeline != GaiaConstants.EnvironmentRenderer.HighDefinition)
{
m_profile.m_masterSkyboxMaterial = (Material)m_editorUtils.ObjectField("MasterSkyboxMaterial", m_profile.m_masterSkyboxMaterial, typeof(Material), false, GUILayout.Height(16f));
}
EditorGUILayout.Space();
m_editorUtils.Heading("LightmappingSettings");
m_profile.m_lightingBakeMode = (GaiaConstants.BakeMode)m_editorUtils.EnumPopup("LightmappingBakeMode", m_profile.m_lightingBakeMode, helpEnabled);
#if UNITY_2020_1_OR_NEWER
m_profile.m_lightmappingMode = (LightingSettings.Lightmapper)EditorGUILayout.EnumPopup("Lightmapping Mode", m_profile.m_lightmappingMode);
#else
m_profile.m_lightmappingMode = (LightmapEditorSettings.Lightmapper)EditorGUILayout.EnumPopup("Lightmapping Mode", m_profile.m_lightmappingMode);
#endif
EditorGUILayout.Space();
m_editorUtils.Heading("PostProcessingSettings");
m_profile.m_enablePostProcessing = m_editorUtils.ToggleLeft("EnablePostProcessing", m_profile.m_enablePostProcessing);
if (m_profile.m_enablePostProcessing)
{
m_profile.m_hideProcessVolume = m_editorUtils.ToggleLeft("HidePostProcessingVolumesInScene", m_profile.m_hideProcessVolume);
m_profile.m_antiAliasingMode = (GaiaConstants.GaiaProAntiAliasingMode)EditorGUILayout.EnumPopup("Anti-Aliasing Mode", m_profile.m_antiAliasingMode);
if (m_renderPipeline == GaiaConstants.EnvironmentRenderer.BuiltIn)
{
if (m_profile.m_antiAliasingMode == GaiaConstants.GaiaProAntiAliasingMode.TAA)
{
m_profile.m_AAJitterSpread = m_editorUtils.Slider("AAJitterSpread", m_profile.m_AAJitterSpread, 0f, 1f, helpEnabled);
m_profile.m_AAStationaryBlending = m_editorUtils.Slider("AAStationaryBlending", m_profile.m_AAStationaryBlending, 0f, 1f, helpEnabled);
m_profile.m_AAMotionBlending = m_editorUtils.Slider("AAMotionBlending", m_profile.m_AAMotionBlending, 0f, 1f, helpEnabled);
m_profile.m_AASharpness = m_editorUtils.Slider("AASharpness", m_profile.m_AASharpness, 0f, 1f, helpEnabled);
}
}
}
EditorGUILayout.Space();
m_editorUtils.Heading("CameraSettings");
m_profile.m_enableAutoDOF = m_editorUtils.Toggle("UseAutoDOF", m_profile.m_enableAutoDOF, helpEnabled);
if (m_profile.m_enableAutoDOF)
{
m_profile.m_dofLayerDetection = GaiaEditorUtils.LayerMaskField(new GUIContent(m_editorUtils.GetTextValue("DOFLayerDetection"), m_editorUtils.GetTooltip("DOFLayerDetection")), m_profile.m_dofLayerDetection);
}
EditorGUILayout.Space();
m_profile.m_usePhysicalCamera = m_editorUtils.Toggle("UsePhysicalCamera", m_profile.m_usePhysicalCamera, helpEnabled);
if (m_profile.m_usePhysicalCamera)
{
m_profile.m_cameraFocalLength = m_editorUtils.FloatField("CameraFocalLength", m_profile.m_cameraFocalLength, helpEnabled);
m_profile.m_cameraSensorSize = m_editorUtils.Vector2Field("CameraSensorSize", m_profile.m_cameraSensorSize, helpEnabled);
}
EditorGUILayout.Space();
m_editorUtils.Heading("MiscellaneousSettings");
m_profile.m_globalReflectionProbe = m_editorUtils.ToggleLeft("GlobalReflectionProbe", m_profile.m_globalReflectionProbe);
m_profile.m_parentObjects = m_editorUtils.ToggleLeft("ParentObjectsToGaia", m_profile.m_parentObjects);
m_profile.m_enableAmbientAudio = m_editorUtils.ToggleLeft("EnableAmbientAudio", m_profile.m_enableAmbientAudio);
if (m_renderPipeline != GaiaConstants.EnvironmentRenderer.HighDefinition)
{
m_profile.m_enableFog = m_editorUtils.ToggleLeft("EnableFog", m_profile.m_enableFog);
}
else
{
#if UNITY_2019_3_OR_NEWER
EditorGUILayout.Space();
m_editorUtils.Heading("HDRPSettings");
if (m_profile.m_antiAliasingMode == GaiaConstants.GaiaProAntiAliasingMode.TAA)
{
m_profile.m_antiAliasingTAAStrength = m_editorUtils.Slider("TAAStrength", m_profile.m_antiAliasingTAAStrength, 0f, 2f, helpEnabled);
}
m_profile.m_cameraDithering = m_editorUtils.Toggle("CameraDithering", m_profile.m_cameraDithering, helpEnabled);
m_profile.m_cameraAperture = m_editorUtils.Slider("CameraAperture", m_profile.m_cameraAperture, 1f, 32f, helpEnabled);
#endif
}
}
/// <summary>
/// Global settings
/// </summary>
/// <param name="helpEnabled"></param>
private void GlobalSettings(bool helpEnabled)
{
//m_profile.m_hideAllParentsInHierarchy = m_editorUtils.ToggleLeft("HideAllParentsInHierarchy", m_profile.m_hideAllParentsInHierarchy, helpEnabled);
if (m_profile.m_visibilityEntries != null)
{
int count = m_profile.m_visibilityEntries.Count;
if (count == 0)
{
EditorGUILayout.HelpBox("No Objects found below this object to use this system please spawn some game objects to use the hide system.", MessageType.Info);
}
else
{
GUI.backgroundColor = m_orangeGUI;
if (m_settingsChangedInfo)
{
if (m_editorUtils.Button("ApplyNow"))
{
ApplyNow();
}
}
GUI.backgroundColor = m_guiBackground;
GUIContent checkboxContent = m_editorUtils.GetContent("CheckboxTooltip");
foreach (GaiaHierarchyVisibility ghv in m_profile.m_visibilityEntries)
{
EditorGUILayout.BeginHorizontal();
ghv.m_isVisible = m_editorUtils.Toggle(ghv.m_isVisible, checkboxContent, GUILayout.Width(20));
GUILayout.Label(ghv.m_name);
EditorGUILayout.EndHorizontal();
}
GUI.backgroundColor = m_orangeGUI;
if (m_settingsChangedInfo)
{
if (m_editorUtils.Button("ApplyNow"))
{
ApplyNow();
}
}
GUI.backgroundColor = m_guiBackground;
GUI.backgroundColor = m_redGUI;
if (m_editorUtils.Button("HideAll"))
{
foreach (GaiaHierarchyVisibility ghv in m_profile.m_visibilityEntries)
{
ghv.m_isVisible = false;
}
m_profile.SetupHideInHierarchy();
}
GUI.backgroundColor = m_greenGUI;
if (m_editorUtils.Button("ShowAll"))
{
foreach (GaiaHierarchyVisibility ghv in m_profile.m_visibilityEntries)
{
ghv.m_isVisible = true;
}
m_profile.SetupHideInHierarchy();
}
//EditorGUILayout.LabelField("Object count in parent: " + count);
//if (m_profile.m_hideAllParentsInHierarchy)
//{
// GUI.backgroundColor = m_redGUI;
// if (m_editorUtils.Button("Show"))
// {
// m_profile.m_hideAllParentsInHierarchy = false;
// }
//}
//else
//{
//}
GUI.backgroundColor = m_guiBackground;
//m_editorUtils.InlineHelp("HideAllParentsInHierarchy", helpEnabled);
if (m_editorUtils.Button("ConfigureAllInScene"))
{
m_profile.SetupAllHideInHierarchy();
}
}
}
else
{
EditorGUILayout.LabelField("Object count in parent: 0");
}
}
private void GlobalPanel(bool helpEnabled)
{
//Text intro
GUILayout.BeginVertical("Gaia Scanner", m_boxStyle);
GUILayout.Space(20);
EditorGUILayout.LabelField("The Gaia Scanner allows you to create new stamps from Windows R16, Windows 16 bit RAW, Mac 16 bit RAW, Terrains, Textures or Meshes. Just drag and drop the file or object onto the area below to scan it.", m_wrapStyle);
GUILayout.EndVertical();
DropAreaGUI();
bool originalGUIState = GUI.enabled;
if (!m_scanner.m_objectScanned)
{
GUI.enabled = false;
}
//DrawDefaultInspector();
GUILayout.BeginVertical("Setup", m_boxStyle);
GUILayout.Space(20);
m_editorUtils.Heading("GlobalSettings");
m_scanner.m_previewMaterial = (Material)m_editorUtils.ObjectField("PreviewMaterial", m_scanner.m_previewMaterial, typeof(Material), false, helpEnabled);
EditorGUILayout.BeginHorizontal();
m_scanner.m_exportFolder = m_editorUtils.TextField("ExportPath", m_scanner.m_exportFolder);
if (m_editorUtils.Button("ExportDirectoryOpen", GUILayout.Width(80)))
{
string path = EditorUtility.SaveFolderPanel(m_editorUtils.GetTextValue("ExportDirectoryWindowTitle"), GaiaDirectories.GetUserStampDirectory(), GaiaDirectories.SCANNER_EXPORT_DIRECTORY.Replace("/", ""));
if (path.Contains(Application.dataPath))
{
m_scanner.m_exportFolder = GaiaDirectories.GetPathStartingAtAssetsFolder(path);
}
else
{
EditorUtility.DisplayDialog("Path outside the Assets folder", "The selected path needs to be inside the Assets folder of the project. Please select an appropiate path.", "OK");
m_scanner.m_exportFolder = GaiaDirectories.GetScannerExportDirectory();
}
}
EditorGUILayout.EndHorizontal();
m_editorUtils.InlineHelp("ExportPath", helpEnabled);
m_scanner.m_exportFileName = m_editorUtils.TextField("ExportFilename", m_scanner.m_exportFileName, helpEnabled);
float oldBaseLevel = m_scanner.m_baseLevel;
m_scanner.m_baseLevel = m_editorUtils.Slider("BaseLevel", m_scanner.m_baseLevel, 0f, 1f, helpEnabled);
if (oldBaseLevel != m_scanner.m_baseLevel)
{
SceneView.lastActiveSceneView.Repaint();
}
EditorGUILayout.Space(10f);
m_editorUtils.Heading("ObjectTypeSettings");
if (m_scanner.m_scannerObjectType == ScannerObjectType.Mesh)
{
m_scanner.m_scanResolution = m_editorUtils.Slider("ScanResolution", m_scanner.m_scanResolution, 0.0001f, 1f, helpEnabled);
if (m_scanner.m_lastScanResolution != m_scanner.m_scanResolution)
{
if (m_editorUtils.Button("RefreshScan"))
{
m_scanner.LoadGameObject(m_scanner.m_lastScannedMesh);
}
}
}
if (m_scanner.m_scannerObjectType == ScannerObjectType.Raw)
{
//Drop Options section
GUILayout.BeginHorizontal();
{
EditorGUILayout.PrefixLabel(BYTE_ORDER_LABEL);
EditorGUI.BeginChangeCheck();
{
m_rawByteOrder = (GaiaConstants.RawByteOrder)GUILayout.Toolbar((int)m_rawByteOrder, new string[] { "IBM PC", "Macintosh" });
}
if (EditorGUI.EndChangeCheck())
{
ReloadRawFile();
}
}
GUILayout.EndHorizontal();
m_editorUtils.InlineHelp("RawFileByteOrder", helpEnabled);
EditorGUI.BeginChangeCheck();
{
m_rawBitDepth = (GaiaConstants.RawBitDepth)EditorGUILayout.Popup(BIT_DEPTH_LABEL, (int)m_rawBitDepth, BIT_DEPTHS_LABELS);
m_editorUtils.InlineHelp("RawFileBitDepth", helpEnabled);
}
if (EditorGUI.EndChangeCheck())
{
ReloadRawFile();
}
GUILayout.BeginVertical();
if (m_showRawInfo)
{
EditorGUILayout.HelpBox("Assumed " + (m_rawBitDepth == GaiaConstants.RawBitDepth.Sixteen ? "16-bit" : "8-bit") + " RAW " + m_assumedRawRes + " x " + m_assumedRawRes, MessageType.Info);
}
if (m_showBitDepthWarning)
{
EditorGUILayout.HelpBox(m_editorUtils.GetTextValue("8BitWarning"), MessageType.Warning);
}
GUILayout.EndVertical();
}
EditorGUILayout.Space(10f);
m_editorUtils.Heading("ExportSettings");
//m_scanner.m_textureExportResolution = (GaiaConstants.GaiaProWaterReflectionsQuality) EditorGUILayout.EnumPopup(new GUIContent("Export Resolution", "Sets the export resolution of the texture generated"), m_scanner.m_textureExportResolution);
m_scanner.m_normalize = m_editorUtils.Toggle("Normalize", m_scanner.m_normalize, helpEnabled);
m_scanner.m_exportTextureAlso = m_editorUtils.Toggle("ExportPNG", m_scanner.m_exportTextureAlso, helpEnabled);
//m_scanner.m_exportBytesData = m_editorUtils.Toggle("ExportBytesData", m_scanner.m_exportBytesData, helpEnabled);
GUILayout.EndVertical();
//Terraform section
GUILayout.BeginVertical("Scanner Controller", m_boxStyle);
GUILayout.Space(20);
if (!string.IsNullOrEmpty(m_infoMessage))
{
EditorGUILayout.HelpBox(m_infoMessage, MessageType.Info);
}
if (m_scanner.m_scanMap == null)
{
EditorGUILayout.HelpBox(m_editorUtils.GetTextValue("NoScanDataInfo"), MessageType.Info);
GUI.enabled = false;
}
GUILayout.BeginHorizontal();
Color normalBGColor = GUI.backgroundColor;
if (m_settings == null)
{
m_settings = GaiaUtils.GetGaiaSettings();
}
GUI.backgroundColor = m_settings.GetActionButtonColor();
if (m_editorUtils.Button("SaveScan"))
{
string path = m_scanner.SaveScan();
AssetDatabase.Refresh();
path += ".exr";
Object exportedTexture = AssetDatabase.LoadAssetAtPath(path, typeof(Object));
if (exportedTexture != null)
{
m_infoMessage = "Scan exported to: " + path;
Debug.Log(m_infoMessage);
EditorGUIUtility.PingObject(exportedTexture);
}
}
GUI.backgroundColor = normalBGColor;
GUI.enabled = true;
if (m_editorUtils.Button("Clear"))
{
m_scanner.Clear();
}
GUILayout.EndHorizontal();
GUILayout.Space(5);
GUILayout.EndVertical();
GUILayout.Space(5f);
m_showRawInfo = m_assumedRawRes > 0;
m_showBitDepthWarning = m_rawBitDepth == GaiaConstants.RawBitDepth.Eight;
GUI.enabled = originalGUIState;
}
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();
}
private void DrawGeneralSettings(bool helpEnabled)
{
m_terrainLoaderManager.TerrainSceneStorage = (TerrainSceneStorage)m_editorUtils.ObjectField("TerrainSceneStorage", m_terrainLoaderManager.TerrainSceneStorage, typeof(TerrainSceneStorage), false, helpEnabled);
bool oldLoadingEnabled = m_terrainLoaderManager.TerrainSceneStorage.m_terrainLoadingEnabled;
m_terrainLoaderManager.TerrainSceneStorage.m_terrainLoadingEnabled = m_editorUtils.Toggle("TerrainLoadingEnabled", m_terrainLoaderManager.TerrainSceneStorage.m_terrainLoadingEnabled, helpEnabled);
if (!oldLoadingEnabled && m_terrainLoaderManager.TerrainSceneStorage.m_terrainLoadingEnabled)
{
//User re-enabled the loaders
m_terrainLoaderManager.UpdateTerrainLoadState();
}
if (oldLoadingEnabled != m_terrainLoaderManager.TerrainSceneStorage.m_terrainLoadingEnabled)
{
//Value was changed, dirty the object to make sure the value is being saved
EditorUtility.SetDirty(m_terrainLoaderManager.TerrainSceneStorage);
}
bool originalGUIState = GUI.enabled;
m_terrainLoaderManager.m_terrainLoadingTresholdMS = m_editorUtils.IntField("LoadingTimeTreshold", m_terrainLoaderManager.m_terrainLoadingTresholdMS, helpEnabled);
m_terrainLoaderManager.m_trackLoadingProgressTimeOut = m_editorUtils.LongField("LoadingProgressTimeout", m_terrainLoaderManager.m_trackLoadingProgressTimeOut, helpEnabled);
GUILayout.Space(10);
m_editorUtils.Heading("SceneViewLoading");
m_terrainLoaderManager.CenterSceneViewLoadingOn = (CenterSceneViewLoadingOn)m_editorUtils.EnumPopup("CenterSceneViewLoadingOn", m_terrainLoaderManager.CenterSceneViewLoadingOn, helpEnabled);
double loadingRange = m_editorUtils.DoubleField("SceneViewLoadingRange", m_terrainLoaderManager.GetLoadingRange(), helpEnabled);
double impostorLoadingRange = m_terrainLoaderManager.GetImpostorLoadingRange();
if (GaiaUtils.HasImpostorTerrains())
{
impostorLoadingRange = m_editorUtils.DoubleField("SceneViewImpostorLoadingRange", m_terrainLoaderManager.GetImpostorLoadingRange(), helpEnabled);
}
else
{
EditorGUILayout.BeginHorizontal();
m_editorUtils.Label("SceneViewImpostorLoadingRange");
//offer button to create impostors setup
if (m_editorUtils.Button("OpenTerrainMeshExporterForImpostors", GUILayout.Width(EditorGUIUtility.currentViewWidth - EditorGUIUtility.labelWidth - 38)))
{
ExportTerrain exportTerrainWindow = EditorWindow.GetWindow <ExportTerrain>();
exportTerrainWindow.FindAndSetPreset("Create Impostors");
exportTerrainWindow.m_settings.m_customSettingsFoldedOut = false;
}
EditorGUILayout.EndHorizontal();
}
if (loadingRange != m_terrainLoaderManager.GetLoadingRange() || impostorLoadingRange != m_terrainLoaderManager.GetImpostorLoadingRange())
{
m_terrainLoaderManager.SetLoadingRange(loadingRange, impostorLoadingRange);
}
GUILayout.Space(10);
m_editorUtils.Heading("CachingSettings");
m_editorUtils.InlineHelp("CachingSettings", helpEnabled);
EditorGUI.BeginChangeCheck();
m_terrainLoaderManager.m_cacheInRuntime = m_editorUtils.Toggle("CacheInRuntime", m_terrainLoaderManager.m_cacheInRuntime, helpEnabled);
m_terrainLoaderManager.m_cacheInEditor = m_editorUtils.Toggle("CacheInEditor", m_terrainLoaderManager.m_cacheInEditor, helpEnabled);
string allocatedMegabytes = (Math.Round(Profiler.GetTotalAllocatedMemoryLong() / Math.Pow(1024, 2))).ToString();
string availableMegabytes = SystemInfo.systemMemorySize.ToString();
allocatedMegabytes = allocatedMegabytes.PadLeft(allocatedMegabytes.Length + (availableMegabytes.Length - allocatedMegabytes.Length) * 3, ' ');
GUIStyle style = new GUIStyle(GUI.skin.label);
if (m_terrainLoaderManager.m_cacheMemoryThreshold < Profiler.GetTotalAllocatedMemoryLong())
{
style = redStyle;
}
else
{
style = greenStyle;
}
m_editorUtils.LabelField("MemoryAvailable", new GUIContent(availableMegabytes), helpEnabled);
m_editorUtils.LabelField("MemoryAllocated", new GUIContent(allocatedMegabytes), style, helpEnabled);
//GUI.color = originalGUIColor;
if (m_terrainLoaderManager.m_cacheInRuntime || m_terrainLoaderManager.m_cacheInEditor)
{
m_terrainLoaderManager.m_cacheMemoryThresholdPreset = (CacheSizePreset)m_editorUtils.EnumPopup("CacheMemoryThreshold", m_terrainLoaderManager.m_cacheMemoryThresholdPreset, helpEnabled);
if (m_terrainLoaderManager.m_cacheMemoryThresholdPreset == CacheSizePreset.Custom)
{
EditorGUI.indentLevel++;
m_terrainLoaderManager.m_cacheMemoryThreshold = m_editorUtils.LongField("ThresholdInBytes", m_terrainLoaderManager.m_cacheMemoryThreshold, helpEnabled);
EditorGUI.indentLevel--;
}
int cacheKeepAliveSeconds = (int)m_terrainLoaderManager.m_cacheKeepAliveTime / 1000;
cacheKeepAliveSeconds = m_editorUtils.IntField("CacheKeepAliveSeconds", cacheKeepAliveSeconds, helpEnabled);
m_terrainLoaderManager.m_cacheKeepAliveTime = cacheKeepAliveSeconds * 1000;
}
if (EditorGUI.EndChangeCheck())
{
if (m_terrainLoaderManager.m_cacheMemoryThresholdPreset != CacheSizePreset.Custom)
{
m_terrainLoaderManager.m_cacheMemoryThreshold = (long)((int)m_terrainLoaderManager.m_cacheMemoryThresholdPreset * Math.Pow(1024, 3));
}
m_terrainLoaderManager.UpdateCaching();
}
GUILayout.Space(10);
if (!GaiaUtils.HasColliderTerrains())
{
GUI.enabled = false;
}
m_editorUtils.Heading("ColliderOnlyLoadingHeader");
//This flag is special in so far as that when the user switches it, we must first perform a scene unload while the old value is still active
//then change the flag in the terrain scene storage and then do a refresh with the new setting applied.
bool colliderLoadingEnabled = m_terrainLoaderManager.TerrainSceneStorage.m_colliderOnlyLoading;
colliderLoadingEnabled = m_editorUtils.Toggle("ColliderOnlyLoadingEnabled", colliderLoadingEnabled, helpEnabled);
if (colliderLoadingEnabled != m_terrainLoaderManager.TerrainSceneStorage.m_colliderOnlyLoading)
{
//User changed the flag, do an unload with the old setting
m_terrainLoaderManager.UnloadAll(true);
//then change the actual flag in storage
m_terrainLoaderManager.TerrainSceneStorage.m_colliderOnlyLoading = colliderLoadingEnabled;
//now do a refresh under the new setting
m_terrainLoaderManager.RefreshSceneViewLoadingRange();
//Add the required scenes to build settings
if (colliderLoadingEnabled)
{
GaiaSessionManager.AddOnlyColliderScenesToBuildSettings(TerrainLoaderManager.TerrainScenes);
}
else
{
GaiaSessionManager.AddTerrainScenesToBuildSettings(TerrainLoaderManager.TerrainScenes);
}
}
GUI.enabled = originalGUIState;
if (colliderLoadingEnabled)
{
EditorGUILayout.HelpBox(m_editorUtils.GetTextValue("ColliderOnlyLoadingInfo"), MessageType.Info);
m_editorUtils.Heading("DeactivateRuntimeHeader");
EditorGUI.indentLevel++;
m_terrainLoaderManager.TerrainSceneStorage.m_deactivateRuntimePlayer = m_editorUtils.Toggle("DeactivateRuntimePlayer", m_terrainLoaderManager.TerrainSceneStorage.m_deactivateRuntimePlayer, helpEnabled);
m_terrainLoaderManager.TerrainSceneStorage.m_deactivateRuntimeLighting = m_editorUtils.Toggle("DeactivateRuntimeLighting", m_terrainLoaderManager.TerrainSceneStorage.m_deactivateRuntimeLighting, helpEnabled);
m_terrainLoaderManager.TerrainSceneStorage.m_deactivateRuntimeAudio = m_editorUtils.Toggle("DeactivateRuntimeAudio", m_terrainLoaderManager.TerrainSceneStorage.m_deactivateRuntimeAudio, helpEnabled);
m_terrainLoaderManager.TerrainSceneStorage.m_deactivateRuntimeWeather = m_editorUtils.Toggle("DeactivateRuntimeWeather", m_terrainLoaderManager.TerrainSceneStorage.m_deactivateRuntimeWeather, helpEnabled);
m_terrainLoaderManager.TerrainSceneStorage.m_deactivateRuntimeWater = m_editorUtils.Toggle("DeactivateRuntimeWater", m_terrainLoaderManager.TerrainSceneStorage.m_deactivateRuntimeWater, helpEnabled);
m_terrainLoaderManager.TerrainSceneStorage.m_deactivateRuntimeScreenShotter = m_editorUtils.Toggle("DeactivateRuntimeScreenShotter", m_terrainLoaderManager.TerrainSceneStorage.m_deactivateRuntimeScreenShotter, helpEnabled);
EditorGUI.indentLevel--;
}
else
{
//offer button to create collider setup
if (m_editorUtils.Button("OpenTerrainMeshExporterForColliders"))
{
ExportTerrain exportTerrainWindow = EditorWindow.GetWindow <ExportTerrain>();
exportTerrainWindow.FindAndSetPreset("Collider");
exportTerrainWindow.m_settings.m_customSettingsFoldedOut = 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);
}
}
private void DrawUserFiles(bool helpEnabled)
{
m_userFiles.m_autoAddNewFiles = m_editorUtils.Toggle("AutoAddNewFiles", m_userFiles.m_autoAddNewFiles, helpEnabled);
m_userFiles.m_updateFilesWithGaiaUpdate = m_editorUtils.Toggle("UpdateWithGaia", m_userFiles.m_updateFilesWithGaiaUpdate, helpEnabled);
GUILayout.Space(10);
if (m_editorUtils.Button("AddDefaults"))
{
if (EditorUtility.DisplayDialog("Add Gaia Default Biomes?", "This will add the default Biomes & Spawners of Gaia back to the lists in case they are missing. Continue?", "Add Defaults", "Cancel"))
{
GaiaUtils.ResetBiomePresets(true);
}
}
GUILayout.Space(10);
m_editorUtils.Heading("BiomePresetHeading");
m_editorUtils.InlineHelp("BiomePresetHeading", helpEnabled);
float deleteButtonWidth = 50;
for (int i = 0; i < m_userFiles.m_gaiaManagerBiomePresets.Count; i++)
{
GUILayout.BeginHorizontal();
{
m_userFiles.m_gaiaManagerBiomePresets[i] = (BiomePreset)EditorGUILayout.ObjectField(m_userFiles.m_gaiaManagerBiomePresets[i], typeof(BiomePreset), false);
if (m_editorUtils.Button("DeleteBiomePreset", GUILayout.Width(deleteButtonWidth)))
{
m_userFiles.m_gaiaManagerBiomePresets.RemoveAt(i);
}
}
GUILayout.EndHorizontal();
}
GUILayout.BeginHorizontal();
{
GUILayout.Space(EditorGUIUtility.labelWidth);
if (m_editorUtils.Button("AddBiomePreset"))
{
m_userFiles.m_gaiaManagerBiomePresets.Add(null);
}
}
GUILayout.EndHorizontal();
GUILayout.Space(10);
m_editorUtils.Heading("SpawnerSettingsHeading");
m_editorUtils.InlineHelp("SpawnerSettingsHeading", helpEnabled);
for (int i = 0; i < m_userFiles.m_gaiaManagerSpawnerSettings.Count; i++)
{
GUILayout.BeginHorizontal();
{
m_userFiles.m_gaiaManagerSpawnerSettings[i] = (SpawnerSettings)EditorGUILayout.ObjectField(m_userFiles.m_gaiaManagerSpawnerSettings[i], typeof(SpawnerSettings), false);
if (m_editorUtils.Button("DeleteSpawnerSettings", GUILayout.Width(deleteButtonWidth)))
{
m_userFiles.m_gaiaManagerSpawnerSettings.RemoveAt(i);
}
}
GUILayout.EndHorizontal();
}
GUILayout.BeginHorizontal();
{
GUILayout.Space(EditorGUIUtility.labelWidth);
if (m_editorUtils.Button("AddSpawnerSettings"))
{
m_userFiles.m_gaiaManagerSpawnerSettings.Add(null);
}
}
GUILayout.EndHorizontal();
GUILayout.Space(10);
m_editorUtils.Heading("ExportTerrainSettingsHeading");
m_editorUtils.InlineHelp("ExportTerrainSettingsHeading", helpEnabled);
for (int i = 0; i < m_userFiles.m_exportTerrainSettings.Count; i++)
{
GUILayout.BeginHorizontal();
{
m_userFiles.m_exportTerrainSettings[i] = (ExportTerrainSettings)EditorGUILayout.ObjectField(m_userFiles.m_exportTerrainSettings[i], typeof(ExportTerrainSettings), false);
if (m_editorUtils.Button("DeleteExportTerrainSettings", GUILayout.Width(deleteButtonWidth)))
{
m_userFiles.m_exportTerrainSettings.RemoveAt(i);
}
}
GUILayout.EndHorizontal();
}
GUILayout.BeginHorizontal();
{
GUILayout.Space(EditorGUIUtility.labelWidth);
if (m_editorUtils.Button("AddExportTerrainSettings"))
{
m_userFiles.m_exportTerrainSettings.Add(null);
}
}
GUILayout.EndHorizontal();
}
private void SimpleLayerCulling(bool helpEnabled)
{
EditorGUI.BeginChangeCheck();
m_simpleCameraLayerCulling.m_applyToGameCamera = m_editorUtils.Toggle("ApplyToGameCamera", m_simpleCameraLayerCulling.m_applyToGameCamera);
m_simpleCameraLayerCulling.m_applyToSceneCamera = m_editorUtils.Toggle("ApplyToSceneCamera", m_simpleCameraLayerCulling.m_applyToSceneCamera);
if (m_simpleCameraLayerCulling.m_profile != null)
{
EditorGUILayout.Space();
m_editorUtils.LabelField("ObjectCullingSettings", EditorStyles.boldLabel);
EditorGUI.indentLevel++;
m_editorUtils.InlineHelp("ObjectCullingSettings", helpEnabled);
for (int i = 0; i < m_simpleCameraLayerCulling.m_profile.m_layerDistances.Length; i++)
{
string layerName = LayerMask.LayerToName(i);
if (!string.IsNullOrEmpty(layerName))
{
m_simpleCameraLayerCulling.m_profile.m_layerDistances[i] = EditorGUILayout.FloatField(string.Format("[{0}] {1}", i, layerName), m_simpleCameraLayerCulling.m_profile.m_layerDistances[i]);
}
}
EditorGUI.indentLevel--;
if (m_editorUtils.Button("RevertCullingToDefaults"))
{
GaiaSettings gaiaSettings = GaiaUtils.GetGaiaSettings();
m_simpleCameraLayerCulling.m_profile.UpdateCulling(gaiaSettings);
EditorUtility.SetDirty(m_simpleCameraLayerCulling.m_profile);
}
EditorGUILayout.Space();
m_editorUtils.LabelField("ShadowCullingSettings", EditorStyles.boldLabel);
EditorGUI.indentLevel++;
m_editorUtils.InlineHelp("ShadowCullingSettings", helpEnabled);
for (int i = 0; i < m_simpleCameraLayerCulling.m_profile.m_shadowLayerDistances.Length; i++)
{
string layerName = LayerMask.LayerToName(i);
if (!string.IsNullOrEmpty(layerName))
{
m_simpleCameraLayerCulling.m_profile.m_shadowLayerDistances[i] = EditorGUILayout.FloatField(string.Format("[{0}] {1}", i, layerName), m_simpleCameraLayerCulling.m_profile.m_shadowLayerDistances[i]);
}
}
EditorGUI.indentLevel--;
if (m_editorUtils.Button("RevertShadowToDefaults"))
{
m_simpleCameraLayerCulling.m_profile.UpdateShadow();
EditorUtility.SetDirty(m_simpleCameraLayerCulling.m_profile);
}
EditorGUI.indentLevel--;
}
if (EditorGUI.EndChangeCheck())
{
EditorUtility.SetDirty(m_simpleCameraLayerCulling);
ApplyToSceneCamera();
m_simpleCameraLayerCulling.ApplyToGameCamera();
m_simpleCameraLayerCulling.ResetDirectionalLight();
SceneView.RepaintAll();
}
}
private void GlobalSettings(bool helpEnabled)
{
m_editorUtils.Heading("GlobalSettings");
m_profile.EnableUnderwaterEffects = m_editorUtils.Toggle("EnableUnderwaterEffects", m_profile.EnableUnderwaterEffects, helpEnabled);
m_profile.m_seaLevel = m_editorUtils.FloatField("SeaLevel", m_profile.m_seaLevel, helpEnabled);
m_profile.m_playerCamera = (Transform)m_editorUtils.ObjectField("PlayerCamera", m_profile.m_playerCamera, typeof(Transform), helpEnabled);
m_profile.m_startingUnderwater = m_editorUtils.Toggle("StartingUnderwater", m_profile.m_startingUnderwater, helpEnabled);
bool transitionEnabled = m_profile.m_enableTransitionFX;
transitionEnabled = m_editorUtils.Toggle("EnableTransitionFX", transitionEnabled, helpEnabled);
if (m_profile.m_enableTransitionFX != transitionEnabled)
{
m_profile.m_enableTransitionFX = transitionEnabled;
m_profile.SetupTransitionVFX(m_profile.m_enableTransitionFX);
}
EditorGUILayout.Space();
m_editorUtils.Heading("CausticSettings");
m_profile.m_useCaustics = m_editorUtils.Toggle("UseCaustics", m_profile.m_useCaustics, helpEnabled);
if (m_profile.m_useCaustics)
{
m_profile.m_mainLight = (Light)m_editorUtils.ObjectField("MainLight", m_profile.m_mainLight, typeof(Light), helpEnabled);
m_profile.m_framesPerSecond = m_editorUtils.IntField("FramesPerSecond", m_profile.m_framesPerSecond, helpEnabled);
m_profile.m_causticSize = m_editorUtils.Slider("CausticSize", m_profile.m_causticSize, 1f, 100f, helpEnabled);
m_profile.m_editCausticTextures = m_editorUtils.Toggle("EditCausticTextures", m_profile.m_editCausticTextures, helpEnabled);
if (m_profile.m_editCausticTextures)
{
for (int i = 0; i < m_profile.m_causticTextures.Count; i++)
{
EditorGUILayout.BeginHorizontal();
m_profile.m_causticTextures[i] = (Texture2D)EditorGUILayout.ObjectField(new GUIContent("[" + i + "]" + m_editorUtils.GetTextValue("CausticTexture"), m_editorUtils.GetTooltip("CausticTexture")), m_profile.m_causticTextures[i], typeof(Texture2D), false, GUILayout.MaxHeight(16f));
if (m_editorUtils.Button("Remove", GUILayout.MaxWidth(30f)))
{
m_profile.m_causticTextures.RemoveAt(i);
}
EditorGUILayout.EndHorizontal();
}
if (m_editorUtils.Button("Add"))
{
m_profile.m_causticTextures.Add(null);
}
}
}
EditorGUILayout.Space();
m_editorUtils.Heading("FogSettings");
m_profile.m_supportFog = m_editorUtils.Toggle("SupportFog", m_profile.m_supportFog, helpEnabled);
if (m_profile.m_supportFog)
{
m_profile.m_fogColorGradient = EditorGUILayout.GradientField(new GUIContent(m_editorUtils.GetTextValue("FogColor"), m_editorUtils.GetTooltip("FogColor")), m_profile.m_fogColorGradient);
m_editorUtils.InlineHelp("FogColor", helpEnabled);
if (m_renderPipeline != GaiaConstants.EnvironmentRenderer.HighDefinition)
{
if (RenderSettings.fogMode == FogMode.Linear)
{
m_profile.m_nearFogDistance = m_editorUtils.FloatField("FogStartDistance", m_profile.m_nearFogDistance, helpEnabled);
m_profile.m_fogDistance = m_editorUtils.FloatField("FogEndDistance", m_profile.m_fogDistance, helpEnabled);
}
else
{
m_profile.m_fogDensity = m_editorUtils.Slider("FogDensity", m_profile.m_fogDensity, 0f, 1f, helpEnabled);
}
}
else
{
m_profile.m_fogDistance = m_editorUtils.FloatField("FogEndDistance", m_profile.m_fogDistance, helpEnabled);
}
}
EditorGUILayout.Space();
m_editorUtils.Heading("AudioSettings");
m_profile.m_playbackVolume = m_editorUtils.Slider("PlaybackVolume", m_profile.m_playbackVolume, 0f, 1f, helpEnabled);
m_profile.m_submergeSoundFXDown = (AudioClip)m_editorUtils.ObjectField("SubmergeSoundFXDown", m_profile.m_submergeSoundFXDown, typeof(AudioClip), helpEnabled);
m_profile.m_submergeSoundFXUp = (AudioClip)m_editorUtils.ObjectField("SubmergeSoundFXUp", m_profile.m_submergeSoundFXUp, typeof(AudioClip), helpEnabled);
m_profile.m_underwaterSoundFX = (AudioClip)m_editorUtils.ObjectField("UnderwaterSoundFX", m_profile.m_underwaterSoundFX, typeof(AudioClip), helpEnabled);
}