902 lines
35 KiB
C#
902 lines
35 KiB
C#
using System;
|
|
using UnityEditor;
|
|
using UnityEngine;
|
|
using UnityEngine.Rendering;
|
|
#if UPPipeline
|
|
using UnityEngine.Rendering.Universal;
|
|
#endif
|
|
using System.Collections;
|
|
using UnityEditor.SceneManagement;
|
|
using ProcedualWorlds.WaterSystem;
|
|
#if UNITY_POST_PROCESSING_STACK_V2
|
|
using UnityEngine.Rendering.PostProcessing;
|
|
#endif
|
|
using System.Collections.Generic;
|
|
using Object = UnityEngine.Object;
|
|
|
|
namespace Gaia.Pipeline.URP
|
|
{
|
|
/// <summary>
|
|
/// Static class that handles all the LWRP setup in Gaia
|
|
/// </summary>
|
|
public static class GaiaURPPipelineUtils
|
|
{
|
|
public static float m_waitTimer1 = 1f;
|
|
public static float m_waitTimer2 = 3f;
|
|
|
|
/// <summary>
|
|
/// Configures project for LWRP
|
|
/// </summary>
|
|
/// <param name="profile"></param>
|
|
private static void ConfigureSceneToURP(UnityPipelineProfile profile)
|
|
{
|
|
try
|
|
{
|
|
GaiaSettings gaiaSettings = GaiaUtils.GetGaiaSettings();
|
|
if (gaiaSettings.m_currentRenderer != GaiaConstants.EnvironmentRenderer.Universal)
|
|
{
|
|
Debug.LogError("Unable to configure your scene/project to URP as the current render inside of gaia does not equal Universal as it's active render pipeline. This process [GaiaLWRPPipelineUtils.ConfigureSceneToURP()] will now exit.");
|
|
return;
|
|
}
|
|
|
|
if (profile.m_setUPPipelineProfile)
|
|
{
|
|
SetPipelineAsset(profile);
|
|
}
|
|
|
|
if (profile.m_UPAutoConfigureCamera)
|
|
{
|
|
ConfigureCamera();
|
|
}
|
|
|
|
if (gaiaSettings.m_gaiaLightingProfile.m_enablePostProcessing)
|
|
{
|
|
if (GaiaGlobal.Instance != null)
|
|
{
|
|
ApplyURPPostProcessing(gaiaSettings.m_gaiaLightingProfile.m_lightingProfiles[gaiaSettings.m_gaiaLightingProfile.m_selectedLightingProfileValuesIndex], GaiaGlobal.Instance.SceneProfile);
|
|
}
|
|
}
|
|
|
|
if (profile.m_UPAutoConfigureLighting)
|
|
{
|
|
ConfigureLighting();
|
|
}
|
|
|
|
if (profile.m_UPAutoConfigureWater)
|
|
{
|
|
ConfigureWater(profile, gaiaSettings);
|
|
}
|
|
|
|
if (profile.m_UPAutoConfigureProbes)
|
|
{
|
|
GaiaURPRuntimeUtils.ConfigureReflectionProbes();
|
|
}
|
|
|
|
if (profile.m_UPAutoConfigureTerrain)
|
|
{
|
|
GaiaURPRuntimeUtils.ConfigureTerrain(profile);
|
|
}
|
|
|
|
if (profile.m_UPAutoConfigureBiomePostFX)
|
|
{
|
|
UpdateBiomePostFX();
|
|
}
|
|
|
|
FinalizeURP(profile);
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
Console.WriteLine(e);
|
|
throw;
|
|
}
|
|
}
|
|
/// <summary>
|
|
/// Configures scripting defines in the project
|
|
/// </summary>
|
|
public static void SetScriptingDefines(UnityPipelineProfile profile)
|
|
{
|
|
bool isChanged = false;
|
|
string currBuildSettings = PlayerSettings.GetScriptingDefineSymbolsForGroup(EditorUserBuildSettings.selectedBuildTargetGroup);
|
|
if (!currBuildSettings.Contains("UPPipeline"))
|
|
{
|
|
if (string.IsNullOrEmpty(currBuildSettings))
|
|
{
|
|
currBuildSettings = "UPPipeline";
|
|
}
|
|
else
|
|
{
|
|
currBuildSettings += ";UPPipeline";
|
|
}
|
|
isChanged = true;
|
|
}
|
|
|
|
if (currBuildSettings.Contains("HDPipeline"))
|
|
{
|
|
currBuildSettings = currBuildSettings.Replace("HDPipeline;", "");
|
|
currBuildSettings = currBuildSettings.Replace("HDPipeline", "");
|
|
isChanged = true;
|
|
}
|
|
|
|
if (currBuildSettings.Contains("LWPipeline"))
|
|
{
|
|
currBuildSettings = currBuildSettings.Replace("LWPipeline;", "");
|
|
currBuildSettings = currBuildSettings.Replace("LWPipeline", "");
|
|
isChanged = true;
|
|
}
|
|
|
|
if (isChanged)
|
|
{
|
|
PlayerSettings.SetScriptingDefineSymbolsForGroup(EditorUserBuildSettings.selectedBuildTargetGroup, currBuildSettings);
|
|
}
|
|
}
|
|
/// <summary>
|
|
/// Sets the pipeline asset to the procedural worlds asset if the profile is set yo change it
|
|
/// </summary>
|
|
/// <param name="profile"></param>
|
|
public static void SetPipelineAsset(UnityPipelineProfile profile)
|
|
{
|
|
try
|
|
{
|
|
GaiaPackageVersion unityVersion = GaiaPackageVersion.Unity2019_1;
|
|
//Installation setup
|
|
if (Application.unityVersion.Contains("2019.2"))
|
|
{
|
|
unityVersion = GaiaPackageVersion.Unity2019_2;
|
|
}
|
|
else if (Application.unityVersion.Contains("2019.3"))
|
|
{
|
|
unityVersion = GaiaPackageVersion.Unity2019_3;
|
|
}
|
|
else if (Application.unityVersion.Contains("2019.4"))
|
|
{
|
|
unityVersion = GaiaPackageVersion.Unity2019_4;
|
|
}
|
|
else if (Application.unityVersion.Contains("2020.1"))
|
|
{
|
|
unityVersion = GaiaPackageVersion.Unity2020_1;
|
|
}
|
|
|
|
UnityVersionPipelineAsset mapping = profile.m_universalPipelineProfiles.Find(x => x.m_unityVersion == unityVersion);
|
|
string pipelineAssetName = "";
|
|
if (mapping != null)
|
|
{
|
|
pipelineAssetName = mapping.m_pipelineAssetName;
|
|
}
|
|
else
|
|
{
|
|
Debug.LogError("Could not determine the correct render pipeline settings asset for this unity version / rendering pipeline!");
|
|
return;
|
|
}
|
|
|
|
GraphicsSettings.defaultRenderPipeline = AssetDatabase.LoadAssetAtPath<RenderPipelineAsset>(GaiaUtils.GetAssetPath(pipelineAssetName + GaiaConstants.gaiaFileFormatAsset));
|
|
profile.m_pipelineSwitchUpdates = true;
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
Console.WriteLine(e);
|
|
throw;
|
|
}
|
|
}
|
|
/// <summary>
|
|
/// Updates the pipeline asset depth/opaque settings
|
|
/// </summary>
|
|
/// <param name="updateDepth"></param>
|
|
/// <param name="updateOpaque"></param>
|
|
public static void UpdateURPPipelineSettings(bool updateDepth, bool updateOpaque)
|
|
{
|
|
#if UPPipeline
|
|
UniversalRenderPipelineAsset pipelineAsset = GraphicsSettings.defaultRenderPipeline as UniversalRenderPipelineAsset;
|
|
if (pipelineAsset != null)
|
|
{
|
|
if (updateDepth)
|
|
{
|
|
pipelineAsset.supportsCameraDepthTexture = false;
|
|
pipelineAsset.supportsCameraDepthTexture = true;
|
|
}
|
|
|
|
if (updateOpaque)
|
|
{
|
|
pipelineAsset.supportsCameraOpaqueTexture = false;
|
|
pipelineAsset.supportsCameraOpaqueTexture = true;
|
|
}
|
|
|
|
QualitySettings.renderPipeline = pipelineAsset;
|
|
pipelineAsset.OnAfterDeserialize();
|
|
EditorUtility.SetDirty(pipelineAsset);
|
|
AssetDatabase.SaveAssets();
|
|
}
|
|
#endif
|
|
}
|
|
/// <summary>
|
|
/// Configures camera to LWRP
|
|
/// </summary>
|
|
private static void ConfigureCamera()
|
|
{
|
|
try
|
|
{
|
|
Camera camera = GaiaUtils.GetCamera();
|
|
if (camera == null)
|
|
{
|
|
Debug.LogWarning("[GaiaUPRPPipelineUtils.ConfigureCamera()] A camera could not be found to upgrade in your scene.");
|
|
}
|
|
else
|
|
{
|
|
#if UPPipeline
|
|
UniversalAdditionalCameraData cameraData = GaiaURPRuntimeUtils.GetUPCameraData(camera);
|
|
cameraData.renderShadows = true;
|
|
#endif
|
|
}
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
Console.WriteLine(e);
|
|
throw;
|
|
}
|
|
}
|
|
/// <summary>
|
|
/// Configures lighting to LWRP
|
|
/// </summary>
|
|
private static void ConfigureLighting()
|
|
{
|
|
try
|
|
{
|
|
#if UPPipeline
|
|
Light[] lights = Object.FindObjectsOfType<Light>();
|
|
if (lights.Length > 0)
|
|
{
|
|
foreach (Light data in lights)
|
|
{
|
|
GaiaURPRuntimeUtils.GetUPLightData(data);
|
|
}
|
|
}
|
|
#endif
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
Console.WriteLine(e);
|
|
throw;
|
|
}
|
|
}
|
|
/// <summary>
|
|
/// Sets the sun intensity
|
|
/// </summary>
|
|
/// <param name="profile"></param>
|
|
/// <param name="volumeProfile"></param>
|
|
public static void SetSunSettings(GaiaLightingProfileValues profile)
|
|
{
|
|
try
|
|
{
|
|
Light light = GaiaUtils.GetMainDirectionalLight();
|
|
if (light != null)
|
|
{
|
|
light.color = profile.m_lWSunColor;
|
|
light.intensity = profile.m_lWSunIntensity;
|
|
}
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
Console.WriteLine(e);
|
|
throw;
|
|
}
|
|
}
|
|
/// <summary>
|
|
/// Configures water to URP
|
|
/// </summary>
|
|
/// <param name="profile"></param>
|
|
private static void ConfigureWater(UnityPipelineProfile profile, GaiaSettings gaiaSettings)
|
|
{
|
|
try
|
|
{
|
|
if (gaiaSettings == null)
|
|
{
|
|
Debug.LogError("Gaia settings could not be found. Please make sure gaia settings is import into your project");
|
|
}
|
|
else
|
|
{
|
|
if (profile.m_underwaterHorizonMaterial != null)
|
|
{
|
|
profile.m_underwaterHorizonMaterial.shader = Shader.Find(profile.m_universalHorizonObjectShader);
|
|
}
|
|
|
|
GameObject waterObject = GameObject.Find(gaiaSettings.m_gaiaWaterProfile.m_waterPrefab.name);
|
|
if (waterObject != 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");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
Console.WriteLine(e);
|
|
throw;
|
|
}
|
|
}
|
|
/// <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.m_antiAliasingMode, 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;
|
|
}
|
|
}
|
|
/// <summary>
|
|
/// Crate post processing instance profile
|
|
/// </summary>
|
|
/// <param name="sceneProfile"></param>
|
|
public static void CreatePostFXProfileInstance(SceneProfile sceneProfile, GaiaLightingProfileValues profile)
|
|
{
|
|
try
|
|
{
|
|
if (sceneProfile == null)
|
|
{
|
|
return;
|
|
}
|
|
|
|
#if UPPipeline
|
|
VolumeProfile volumeProfile = AssetDatabase.LoadAssetAtPath<VolumeProfile>(GaiaUtils.GetAssetPath("URP Global Post Processing Profile.asset"));
|
|
if (profile.PostProcessProfileURP != null)
|
|
{
|
|
volumeProfile = profile.PostProcessProfileURP;
|
|
}
|
|
if (volumeProfile == null)
|
|
{
|
|
return;
|
|
}
|
|
|
|
GaiaSessionManager session = GaiaSessionManager.GetSessionManager();
|
|
if (session != null)
|
|
{
|
|
string path = GaiaDirectories.GetSceneProfilesFolderPath(session.m_session);
|
|
if (!string.IsNullOrEmpty(path))
|
|
{
|
|
if (EditorSceneManager.GetActiveScene() != null)
|
|
{
|
|
if (!string.IsNullOrEmpty(EditorSceneManager.GetActiveScene().path))
|
|
{
|
|
path = path + "/" + EditorSceneManager.GetActiveScene().name + " " + volumeProfile.name + " Profile.asset";
|
|
}
|
|
else
|
|
{
|
|
path = path + "/" + volumeProfile.name + " HDRP Post FX Profile.asset";
|
|
}
|
|
}
|
|
else
|
|
{
|
|
path = path + "/" + volumeProfile.name + " HDRP Post FX Profile.asset";
|
|
}
|
|
|
|
if (sceneProfile.m_universalPostFXProfile != null)
|
|
{
|
|
if (!sceneProfile.m_isUserProfileSet)
|
|
{
|
|
if (!sceneProfile.m_universalPostFXProfile.name.Contains(volumeProfile.name))
|
|
{
|
|
AssetDatabase.DeleteAsset(AssetDatabase.GetAssetPath(sceneProfile.m_universalPostFXProfile));
|
|
sceneProfile.m_universalPostFXProfile = null;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (AssetDatabase.LoadAssetAtPath<VolumeProfile>(path) == null)
|
|
{
|
|
FileUtil.CopyFileOrDirectory(AssetDatabase.GetAssetPath(volumeProfile), path);
|
|
AssetDatabase.ImportAsset(path);
|
|
}
|
|
|
|
sceneProfile.m_universalPostFXProfile = AssetDatabase.LoadAssetAtPath<VolumeProfile>(path);
|
|
}
|
|
}
|
|
#endif
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
Console.WriteLine(e);
|
|
throw;
|
|
}
|
|
}
|
|
/// <summary>
|
|
/// Finalizes the LWRP setup for your project
|
|
/// </summary>
|
|
/// <param name="profile"></param>
|
|
private static void FinalizeURP(UnityPipelineProfile profile)
|
|
{
|
|
try
|
|
{
|
|
MarkSceneDirty(true);
|
|
EditorUtility.SetDirty(profile);
|
|
profile.m_activePipelineInstalled = GaiaConstants.EnvironmentRenderer.Universal;
|
|
UpdateURPPipelineSettings(true, true);
|
|
|
|
Debug.Log("Finalized URP");
|
|
|
|
GaiaManagerEditor manager = EditorWindow.GetWindow<Gaia.GaiaManagerEditor>(false, "Gaia Manager");
|
|
if (manager != null)
|
|
{
|
|
manager.GaiaManagerStatusCheck(true);
|
|
manager.CheckForSetupIssues();
|
|
}
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
Console.WriteLine(e);
|
|
throw;
|
|
}
|
|
}
|
|
/// <summary>
|
|
/// Updates the biome post fx to SRP volume profile
|
|
/// </summary>
|
|
private static void UpdateBiomePostFX()
|
|
{
|
|
try
|
|
{
|
|
GaiaPostProcessBiome[] gaiaPostProcessBiomes = GameObject.FindObjectsOfType<GaiaPostProcessBiome>();
|
|
if (gaiaPostProcessBiomes.Length > 0)
|
|
{
|
|
foreach (GaiaPostProcessBiome biome in gaiaPostProcessBiomes)
|
|
{
|
|
#if UNITY_POST_PROCESSING_STACK_V2
|
|
PostProcessVolume processVolume = biome.GetComponent<PostProcessVolume>();
|
|
if (processVolume != null)
|
|
{
|
|
GameObject.DestroyImmediate(processVolume);
|
|
}
|
|
#endif
|
|
|
|
#if UPPipeline
|
|
Volume volumeComp = biome.GetComponent<Volume>();
|
|
if (volumeComp == null)
|
|
{
|
|
volumeComp = biome.gameObject.AddComponent<Volume>();
|
|
volumeComp.sharedProfile = AssetDatabase.LoadAssetAtPath<VolumeProfile>(GaiaUtils.GetAssetPath("UP " + biome.PostProcessingFileName + ".asset"));
|
|
}
|
|
#endif
|
|
}
|
|
}
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
Console.WriteLine(e);
|
|
throw;
|
|
}
|
|
}
|
|
/// <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.defaultRenderPipeline = 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>
|
|
/// Enables or disables motion blur
|
|
/// </summary>
|
|
/// <param name="enabled"></param>
|
|
private static void SetMotionBlurPostFX(bool enabled)
|
|
{
|
|
try
|
|
{
|
|
#if UNITY_POST_PROCESSING_STACK_V2
|
|
//Create profile list
|
|
List<PostProcessProfile> postProcessProfiles = new List<PostProcessProfile>();
|
|
//Clear List
|
|
postProcessProfiles.Clear();
|
|
|
|
//All volumes in scene
|
|
PostProcessVolume[] postProcessVolumes = Object.FindObjectsOfType<PostProcessVolume>();
|
|
if (postProcessVolumes != null)
|
|
{
|
|
foreach(PostProcessVolume volume in postProcessVolumes)
|
|
{
|
|
//Check it has a profile
|
|
if (volume.sharedProfile != null)
|
|
{
|
|
//Add the profile to array
|
|
postProcessProfiles.Add(volume.sharedProfile);
|
|
}
|
|
}
|
|
}
|
|
|
|
if (postProcessProfiles != null)
|
|
{
|
|
//Motion blur
|
|
foreach (PostProcessProfile profile in postProcessProfiles)
|
|
{
|
|
//Check if profile has setting
|
|
if (profile.TryGetSettings(out UnityEngine.Rendering.PostProcessing.MotionBlur motionBlur))
|
|
{
|
|
|
|
EditorUtility.SetDirty(profile);
|
|
//Set ture/false based on input
|
|
motionBlur.active = enabled;
|
|
motionBlur.enabled.value = enabled;
|
|
|
|
Debug.Log(profile.name + ": Motion blur has been disabled in this profile");
|
|
}
|
|
}
|
|
}
|
|
#endif
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
Console.WriteLine(e);
|
|
throw;
|
|
}
|
|
}
|
|
/// <summary>
|
|
/// Sets the AA mode ont he camera
|
|
/// </summary>
|
|
/// <param name="antiAliasingMode"></param>
|
|
private static void SetAntiAliasingMode(GaiaConstants.GaiaProAntiAliasingMode antiAliasingMode)
|
|
{
|
|
try
|
|
{
|
|
#if UNITY_POST_PROCESSING_STACK_V2
|
|
PostProcessLayer processLayer = Object.FindObjectOfType<PostProcessLayer>();
|
|
if (processLayer != null)
|
|
{
|
|
Camera camera = Camera.main;
|
|
switch (antiAliasingMode)
|
|
{
|
|
case GaiaConstants.GaiaProAntiAliasingMode.None:
|
|
processLayer.antialiasingMode = PostProcessLayer.Antialiasing.None;
|
|
camera.allowMSAA = false;
|
|
break;
|
|
case GaiaConstants.GaiaProAntiAliasingMode.FXAA:
|
|
processLayer.antialiasingMode = PostProcessLayer.Antialiasing.FastApproximateAntialiasing;
|
|
camera.allowMSAA = false;
|
|
break;
|
|
case GaiaConstants.GaiaProAntiAliasingMode.MSAA:
|
|
processLayer.antialiasingMode = PostProcessLayer.Antialiasing.None;
|
|
camera.allowMSAA = true;
|
|
break;
|
|
case GaiaConstants.GaiaProAntiAliasingMode.SMAA:
|
|
processLayer.antialiasingMode = PostProcessLayer.Antialiasing.SubpixelMorphologicalAntialiasing;
|
|
camera.allowMSAA = false;
|
|
break;
|
|
case GaiaConstants.GaiaProAntiAliasingMode.TAA:
|
|
processLayer.antialiasingMode = PostProcessLayer.Antialiasing.TemporalAntialiasing;
|
|
camera.allowMSAA = false;
|
|
break;
|
|
}
|
|
}
|
|
#endif
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
Console.WriteLine(e);
|
|
throw;
|
|
}
|
|
}
|
|
/// <summary>
|
|
/// Starts the LWRP Setup
|
|
/// </summary>
|
|
/// <param name="profile"></param>
|
|
/// <returns></returns>
|
|
public static IEnumerator StartURPSetup(UnityPipelineProfile profile)
|
|
{
|
|
if (profile == null)
|
|
{
|
|
Debug.LogError("UnityPipelineProfile is empty");
|
|
yield return null;
|
|
}
|
|
else
|
|
{
|
|
EditorUtility.DisplayProgressBar("Installing Universal", "Updating scripting defines", 0.5f);
|
|
m_waitTimer1 -= Time.deltaTime;
|
|
if (m_waitTimer1 < 0)
|
|
{
|
|
SetScriptingDefines(profile);
|
|
}
|
|
else
|
|
{
|
|
yield return null;
|
|
}
|
|
|
|
while (EditorApplication.isCompiling)
|
|
{
|
|
yield return null;
|
|
}
|
|
|
|
EditorUtility.DisplayProgressBar("Installing Universal", "Updating scene to Universal", 0.75f);
|
|
m_waitTimer2 -= Time.deltaTime;
|
|
if (m_waitTimer2 < 0)
|
|
{
|
|
ConfigureSceneToURP(profile);
|
|
profile.m_pipelineSwitchUpdates = false;
|
|
EditorUtility.ClearProgressBar();
|
|
}
|
|
else
|
|
{
|
|
yield return null;
|
|
}
|
|
}
|
|
}
|
|
/// <summary>
|
|
/// Save the assets and marks scene as dirty
|
|
/// </summary>
|
|
/// <param name="saveAlso"></param>
|
|
private static void MarkSceneDirty(bool saveAlso)
|
|
{
|
|
EditorSceneManager.MarkSceneDirty(EditorSceneManager.GetActiveScene());
|
|
if (saveAlso)
|
|
{
|
|
if (EditorSceneManager.GetActiveScene().isDirty)
|
|
{
|
|
EditorSceneManager.SaveOpenScenes();
|
|
AssetDatabase.SaveAssets();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
} |