439 lines
23 KiB
C#
439 lines
23 KiB
C#
using System.IO;
|
|
using System.Collections.Generic;
|
|
using UnityEngine;
|
|
|
|
using UnityEngine.UIElements;
|
|
|
|
|
|
using Description = KWS.KWS_EditorTextDescription;
|
|
using link = KWS.KWS_EditorUrlLinks;
|
|
using static KWS.KWS_Settings;
|
|
using System;
|
|
using System.Linq;
|
|
using static KWS.KWS_EditorVideoTipsSettings;
|
|
|
|
#if UNITY_EDITOR
|
|
using UnityEditor;
|
|
using static KWS.KWS_EditorUtils;
|
|
#endif
|
|
|
|
|
|
namespace KWS
|
|
{
|
|
|
|
|
|
#if UNITY_EDITOR
|
|
|
|
|
|
class KWS_CustomSettingsProvider : SettingsProvider
|
|
{
|
|
|
|
|
|
internal static bool IsDecalFeatureUsed;
|
|
|
|
private KWS_CustomSettingsProvider(string path, SettingsScope scope = SettingsScope.Project) : base(path, scope) { }
|
|
|
|
[SettingsProvider]
|
|
public static SettingsProvider CreateMyCustomSettingsProvider()
|
|
{
|
|
return new KWS_CustomSettingsProvider("Project/KWS Water Settings", SettingsScope.Project);
|
|
}
|
|
|
|
|
|
public override void OnActivate(string searchContext, VisualElement rootElement)
|
|
{
|
|
KWS_WaterSettingsRuntimeLoader.GetSerializedSettings();
|
|
KWS_WaterSettingsRuntimeLoader.SyncWithUnityQualityLevels();
|
|
}
|
|
|
|
|
|
public override void OnGUI(string searchContext)
|
|
{
|
|
bool defaultVal = false;
|
|
|
|
var _settingsContainer = KWS_WaterSettingsRuntimeLoader._waterSystemQualitySettings;
|
|
|
|
Undo.RecordObject(_settingsContainer, "Changed water quality parameters");
|
|
|
|
EditorGUIUtility.labelWidth = 80;
|
|
GUILayout.Space(10);
|
|
UnityQualitySettings();
|
|
GUILayout.Space(15);
|
|
|
|
EditorGUI.BeginChangeCheck();
|
|
EditorGUIUtility.labelWidth = 220;
|
|
|
|
CheckWarnings();
|
|
|
|
var _settings = KWS_WaterSettingsRuntimeLoader._waterQualityLevelSettings;
|
|
|
|
KWS2_Tab(ref _settingsContainer.ShowReflectionSettings, "Reflection", ReflectionSettings, WaterSystem.WaterSettingsCategory.Reflection, VideoTips.Reflection);
|
|
KWS2_Tab(ref _settingsContainer.ShowRefractionSettings, "Refraction (View Through Water)", RefractionSetting, WaterSystem.WaterSettingsCategory.ColorRefraction, VideoTips.RefractionMode);
|
|
|
|
KWS2_TabWithEnabledToogle(ref _settings.UseDynamicWaves, ref _settingsContainer.ShowDynamicWavesSettings, "Dynamic Waves Simulation", DynamicWavesSettings, WaterSystem.WaterSettingsCategory.DynamicWaves, VideoTips.DynamicSimulation);
|
|
KWS2_TabWithEnabledToogle(ref _settings.UseOceanFoam, ref _settingsContainer.ShowFoamSettings, "Ocean Foam", FoamSetting, WaterSystem.WaterSettingsCategory.Foam, VideoTips.OceanFoam);
|
|
KWS2_TabWithEnabledToogle(ref _settings.UseWetEffect, ref _settingsContainer.ShowWetSettings, "Wet Effect", WetSetting, WaterSystem.WaterSettingsCategory.WetEffect, VideoTips.WetEffect);
|
|
KWS2_TabWithEnabledToogle(ref _settings.UseVolumetricLight, ref _settingsContainer.ShowVolumetricLightSettings, "Volumetric Lighting", VolumetricLightingSettings, WaterSystem.WaterSettingsCategory.VolumetricLighting, VideoTips.VolumetricLighting);
|
|
KWS2_TabWithEnabledToogle(ref _settings.UseCausticEffect, ref _settingsContainer.ShowCausticEffectSettings, "Caustic (Light Patterns on Surfaces)", CausticSettings, WaterSystem.WaterSettingsCategory.Caustic, VideoTips.Caustic);
|
|
KWS2_TabWithEnabledToogle(ref _settings.UseUnderwaterEffect, ref _settingsContainer.ShowUnderwaterEffectSettings, "Underwater Effects", UnderwaterSettings, WaterSystem.WaterSettingsCategory.Underwater, VideoTips.Underwater);
|
|
KWS2_Tab(ref _settingsContainer.ShowMeshSettings, "Mesh Settings", MeshSettings, WaterSystem.WaterSettingsCategory.Mesh, VideoTips.QuadTree);
|
|
KWS2_Tab(ref _settingsContainer.ShowRendering, "Rendering Settings", RenderingSetting, WaterSystem.WaterSettingsCategory.Rendering);
|
|
|
|
if (EditorGUI.EndChangeCheck())
|
|
{
|
|
EditorUtility.SetDirty(_settingsContainer);
|
|
// AssetDatabase.SaveAssets();
|
|
KWS_WaterSettingsRuntimeLoader.UpdateHash();
|
|
}
|
|
|
|
var _settingsObject = KWS_WaterSettingsRuntimeLoader._settingsObject;
|
|
if (_settingsObject != null && _settingsObject.targetObject)
|
|
{
|
|
_settingsObject.ApplyModifiedPropertiesWithoutUndo();
|
|
}
|
|
}
|
|
|
|
|
|
void CheckWarnings()
|
|
{
|
|
#if KWS_URP
|
|
//if (!IsDecalFeatureUsed)
|
|
{
|
|
EditorGUILayout.HelpBox("To make the \"Wet Effect\" work, you need to enable the URP Decal Rendering Feature." + Environment.NewLine +
|
|
"Check the documentation for how to set it up.", MessageType.Info);
|
|
}
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
|
void UnityQualitySettings()
|
|
{
|
|
EditorGUI.indentLevel++;
|
|
EditorGUILayout.BeginHorizontal();
|
|
GUILayout.Space(10);
|
|
GUILayout.Label("Unity Quality Levels", EditorStyles.boldLabel);
|
|
EditorGUILayout.EndHorizontal();
|
|
|
|
GUILayout.Space(3);
|
|
|
|
var qualityLevels = QualitySettings.names;
|
|
var currentQualityLevel = QualitySettings.GetQualityLevel();
|
|
var selectedLevel = currentQualityLevel;
|
|
|
|
for (int idx = 0; idx < qualityLevels.Length; idx++)
|
|
{
|
|
string level = qualityLevels[idx];
|
|
var newValue = Toggle(level, "", selectedLevel == idx);
|
|
if (newValue == true) selectedLevel = idx;
|
|
}
|
|
QualitySettings.SetQualityLevel(selectedLevel);
|
|
EditorGUI.indentLevel--;
|
|
|
|
var _settingsContainer = KWS_WaterSettingsRuntimeLoader._waterSystemQualitySettings;
|
|
var levelName = qualityLevels[selectedLevel];
|
|
var levelSettings = _settingsContainer.qualityLevelSettings.Find(x => x.levelName == levelName);
|
|
if (levelSettings == null)
|
|
{
|
|
levelSettings = new WaterQualityLevelSettings { levelName = levelName };
|
|
_settingsContainer.qualityLevelSettings.Add(levelSettings);
|
|
|
|
EditorUtility.SetDirty(_settingsContainer);
|
|
AssetDatabase.SaveAssets();
|
|
|
|
KWS_WaterSettingsRuntimeLoader.UpdateHash();
|
|
}
|
|
KWS_WaterSettingsRuntimeLoader._waterQualityLevelSettings = levelSettings;
|
|
|
|
if (currentQualityLevel != selectedLevel)
|
|
{
|
|
WaterSystem.OnAnyWaterSettingsChanged?.Invoke(WaterSystem.WaterSettingsCategory.All);
|
|
}
|
|
|
|
}
|
|
|
|
Dictionary<int, int> _actualLayers = new Dictionary<int, int>();
|
|
void ReflectionSettings()
|
|
{
|
|
//KWS_EditorProfiles.PerfomanceProfiles.Reflection.ReadDataFromProfile(_waterSystem);
|
|
var _settings = KWS_WaterSettingsRuntimeLoader._waterQualityLevelSettings;
|
|
var _settingsContainer = KWS_WaterSettingsRuntimeLoader._waterSystemQualitySettings;
|
|
_settings.UseScreenSpaceReflection = Toggle("Use Screen Space Reflection", Description.Reflection.UseScreenSpaceReflection, _settings.UseScreenSpaceReflection, VideoTips.ScreenSpaceReflection);
|
|
|
|
if (_settings.UseScreenSpaceReflection)
|
|
{
|
|
_settings.ScreenSpaceReflectionResolutionQuality = (WaterQualityLevelSettings.ScreenSpaceReflectionResolutionQualityEnum)EnumPopup("Screen Space Resolution Quality",
|
|
Description.Reflection.ScreenSpaceReflectionResolutionQuality, _settings.ScreenSpaceReflectionResolutionQuality, VideoTips.ReflectionResolutionQuality);
|
|
|
|
_settings.UseScreenSpaceReflectionSky = Toggle("Use Screen Space Skybox", "", _settings.UseScreenSpaceReflectionSky, VideoTips.ScreenSpaceReflectionSkybox);
|
|
_settings.ScreenSpaceBordersStretching = Slider("Borders Stretching", "", _settings.ScreenSpaceBordersStretching, 0f, 0.05f, VideoTips.ScreenSpaceReflectionBorderStretching);
|
|
Line();
|
|
}
|
|
|
|
|
|
|
|
_settings.UsePlanarReflection = Toggle("Use Planar Reflection", Description.Reflection.UsePlanarReflection, _settings.UsePlanarReflection, VideoTips.PlanarReflection);
|
|
if (_settings.UsePlanarReflection)
|
|
{
|
|
EditorGUILayout.HelpBox(Description.Warnings.PlanarReflectionUsed, MessageType.Warning);
|
|
_settings.RenderPlanarShadows = Toggle("Planar Shadows", "", _settings.RenderPlanarShadows, VideoTips.PlanarReflectionShadows);
|
|
|
|
if (Reflection.IsVolumetricsAndFogAvailable)
|
|
_settings.RenderPlanarVolumetricsAndFog = Toggle("Planar Volumetrics and Fog", "", _settings.RenderPlanarVolumetricsAndFog);
|
|
if (Reflection.IsCloudRenderingAvailable) _settings.RenderPlanarClouds = Toggle("Planar Clouds", "", _settings.RenderPlanarClouds);
|
|
|
|
_settings.PlanarReflectionResolutionQuality =
|
|
(WaterQualityLevelSettings.PlanarReflectionResolutionQualityEnum)EnumPopup("Planar Resolution Quality", Description.Reflection.PlanarReflectionResolutionQuality, _settings.PlanarReflectionResolutionQuality, VideoTips.ReflectionResolutionQuality);
|
|
|
|
var planarCullingMask = MaskField("Planar Layers Mask", Description.Reflection.PlanarCullingMask, _settings.PlanarCullingMask);
|
|
_settings.PlanarCullingMask = planarCullingMask & ~(1 << Water.WaterLayer);
|
|
|
|
}
|
|
|
|
if (_settings.UsePlanarReflection)
|
|
{
|
|
_settings.ReflectionClipPlaneOffset = Slider("Clip Plane Offset", Description.Reflection.ReflectionClipPlaneOffset, _settings.ReflectionClipPlaneOffset, 0, 0.07f, VideoTips.ClipPlaneOffset);
|
|
}
|
|
|
|
if (_settings.UseScreenSpaceReflection || _settings.UsePlanarReflection)
|
|
{
|
|
Line();
|
|
_settings.UseAnisotropicReflections = Toggle("Use Anisotropic Reflections", Description.Reflection.UseAnisotropicReflections, _settings.UseAnisotropicReflections, VideoTips.AnisotropicReflection);
|
|
|
|
if (_settings.UseAnisotropicReflections)
|
|
{
|
|
|
|
_settings.AnisotropicReflectionsHighQuality = Toggle("High Quality Anisotropic", Description.Reflection.AnisotropicReflectionsHighQuality, _settings.AnisotropicReflectionsHighQuality);
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
void RefractionSetting()
|
|
{
|
|
var _settings = KWS_WaterSettingsRuntimeLoader._waterQualityLevelSettings;
|
|
if (Refraction.IsRefractionDownsampleAvailable) _settings.RefractionResolution = (WaterQualityLevelSettings.RefractionResolutionEnum)EnumPopup("Resolution", "", _settings.RefractionResolution, VideoTips.RefractionMode);
|
|
_settings.UseRefractionDispersion = Toggle("Use Dispersion", Description.Refraction.UseRefractionDispersion, _settings.UseRefractionDispersion, VideoTips.Dispersion);
|
|
}
|
|
|
|
|
|
void DynamicWavesSettings()
|
|
{
|
|
var _settings = KWS_WaterSettingsRuntimeLoader._waterQualityLevelSettings;
|
|
//_settings.UseDetailedMeshAtDistance = Toggle("Use Detailed Mesh At Distance", "", _settings.UseDetailedMeshAtDistance, "");
|
|
}
|
|
|
|
void FoamSetting()
|
|
{
|
|
var _settings = KWS_WaterSettingsRuntimeLoader._waterQualityLevelSettings;
|
|
if (_settings.UseOceanFoam)
|
|
{
|
|
//if (_waterInstance.Settings.CurrentWindSpeed < 7.1f) EditorGUILayout.HelpBox("Foam appears during strong winds (from ~8 meters and above)", MessageType.Info);
|
|
}
|
|
|
|
}
|
|
|
|
void WetSetting()
|
|
{
|
|
#if KWS_URP
|
|
EditorGUILayout.HelpBox("To make the \"Wet Effect\" work, you need to enable the URP Decal Rendering Feature." + Environment.NewLine +
|
|
"Check the documentation for how to set it up.", MessageType.Info);
|
|
|
|
#endif
|
|
}
|
|
|
|
|
|
void VolumetricLightingSettings()
|
|
{
|
|
var _settings = KWS_WaterSettingsRuntimeLoader._waterQualityLevelSettings;
|
|
|
|
_settings.VolumetricLightResolutionQuality =
|
|
(WaterQualityLevelSettings.VolumetricLightResolutionQualityEnum)EnumPopup("Resolution Quality", Description.VolumetricLight.ResolutionQuality, _settings.VolumetricLightResolutionQuality, VideoTips.VolumetricLightingResolution);
|
|
_settings.VolumetricLightIteration = IntSlider("Iterations", Description.VolumetricLight.Iterations, _settings.VolumetricLightIteration, 2, KWS_Settings.VolumetricLighting.MaxIterations, VideoTips.VolumetricLightingIterations);
|
|
|
|
if ( _settings.VolumetricLightCausticMode == WaterQualityLevelSettings.VolumetricLightCausticModeEnum.AllLights) EditorGUILayout.HelpBox("Caustics from all lights can cause a performance drop.", MessageType.Warning);
|
|
_settings.VolumetricLightCausticMode = (WaterQualityLevelSettings.VolumetricLightCausticModeEnum)EnumPopup("Volumetric Caustic Mode", "", _settings.VolumetricLightCausticMode, VideoTips.VolumetricLightingFullCaustic);
|
|
}
|
|
|
|
void CausticSettings()
|
|
{
|
|
var _settings = KWS_WaterSettingsRuntimeLoader._waterQualityLevelSettings;
|
|
var size = (int)_settings.OceanCausticTextureResolutionQuality;
|
|
float currentRenderedPixels = size * size;
|
|
currentRenderedPixels *= _settings.UseOceanCausticHighQualityFiltering ? 2 : 1;
|
|
currentRenderedPixels = (currentRenderedPixels / 1000000f);
|
|
EditorGUILayout.LabelField("Simulation rendered pixels (less is better): " + currentRenderedPixels.ToString("0.0") + " millions", KWS_EditorUtils.NotesLabelStyleFade);
|
|
|
|
_settings.OceanCausticTextureResolutionQuality = (WaterQualityLevelSettings.CausticTextureResolutionQualityEnum)EnumPopup("Ocean Caustic Resolution", "", _settings.OceanCausticTextureResolutionQuality, VideoTips.CausticResolution);
|
|
_settings.UseOceanCausticHighQualityFiltering = Toggle("Ocean Caustic Filtering", "", _settings.UseOceanCausticHighQualityFiltering, VideoTips.CausticFiltering);
|
|
_settings.UseOceanCausticDispersion = Toggle("Ocean Caustic Dispersion", Description.Caustic.UseCausticDispersion, _settings.UseOceanCausticDispersion, VideoTips.CausticDispersion);
|
|
}
|
|
|
|
void UnderwaterSettings()
|
|
{
|
|
|
|
}
|
|
|
|
void MeshSettings()
|
|
{
|
|
var _settings = KWS_WaterSettingsRuntimeLoader._waterQualityLevelSettings;
|
|
_settings.WaterMeshDetailing = (WaterQualityLevelSettings.WaterMeshQualityEnum)EnumPopup("Mesh Detailing", "", _settings.WaterMeshDetailing, VideoTips.QuadTreeMeshDetailing);
|
|
_settings.MeshDetailingFarDistance = IntSlider("Mesh Detailing Far Distance", "", _settings.MeshDetailingFarDistance, 250, 10000, VideoTips.QuadTreeMeshDetailingFarDistance);
|
|
|
|
}
|
|
|
|
void RenderingSetting()
|
|
{
|
|
var _settings = KWS_WaterSettingsRuntimeLoader._waterQualityLevelSettings;
|
|
var _settingsContainer = KWS_WaterSettingsRuntimeLoader._waterSystemQualitySettings;
|
|
|
|
ReadSelectedThirdPartyFog();
|
|
var selectedThirdPartyFogMethod = WaterSystem.ThirdPartyFogAssetsDescriptions[_settingsContainer.SelectedThirdPartyFogMethod];
|
|
|
|
|
|
if (selectedThirdPartyFogMethod.CustomQueueOffset != 0)
|
|
{
|
|
EditorGUILayout.LabelField($"Min TransparentSortingPriority overrated by {selectedThirdPartyFogMethod.EditorName}", KWS_EditorUtils.NotesLabelStyleFade);
|
|
_settings.WaterTransparentSortingPriority = IntSlider("Transparent Sorting Priority", "", _settings.WaterTransparentSortingPriority, selectedThirdPartyFogMethod.CustomQueueOffset, 50, VideoTips.TransparentSortingPriority);
|
|
}
|
|
else
|
|
{
|
|
_settings.WaterTransparentSortingPriority = IntSlider("Transparent Sorting Priority", "", _settings.WaterTransparentSortingPriority, -50, 50, VideoTips.TransparentSortingPriority);
|
|
}
|
|
|
|
//_settings.EnabledMeshRendering = Toggle("Enabled Mesh Rendering", "", _settings.EnabledMeshRendering, link.EnabledMeshRendering), false);
|
|
|
|
if (selectedThirdPartyFogMethod.DrawToDepth)
|
|
{
|
|
EditorGUILayout.LabelField($"Draw To Depth override by {selectedThirdPartyFogMethod.EditorName}", KWS_EditorUtils.NotesLabelStyleFade);
|
|
GUI.enabled = false;
|
|
_settings.DrawToPosteffectsDepth = Toggle("Draw To Depth", Description.Rendering.DrawToPosteffectsDepth, true, VideoTips.DrawToDepth);
|
|
GUI.enabled = true;
|
|
}
|
|
else
|
|
{
|
|
_settings.DrawToPosteffectsDepth = Toggle("Draw To Depth", Description.Rendering.DrawToPosteffectsDepth, _settings.DrawToPosteffectsDepth, VideoTips.DrawToDepth);
|
|
}
|
|
|
|
|
|
_settings.WideAngleCameraRenderingMode = Toggle("Wide-Angle Camera Mode", "", _settings.WideAngleCameraRenderingMode, VideoTips.WideAngleCameraRenderingMode);
|
|
//if (_waterSystem.UseTesselation)
|
|
//{
|
|
// _waterSystem.WireframeMode = false;
|
|
// EditorGUILayout.LabelField($"Wireframe mode doesn't work with tesselation (water -> mesh -> use tesselation)", KWS_EditorUtils.NotesLabelStyleFade);
|
|
// GUI.enabled = false;
|
|
// _waterSystem.WireframeMode = Toggle("Wireframe Mode", "", _waterSystem.WireframeMode, nameof(_waterSystem.WireframeMode));
|
|
// GUI.enabled = _isActive;
|
|
//}
|
|
//else
|
|
//{
|
|
// _waterSystem.WireframeMode = Toggle("Wireframe Mode", "", _waterSystem.WireframeMode, nameof(_waterSystem.WireframeMode));
|
|
//}
|
|
|
|
var assets = WaterSystem.ThirdPartyFogAssetsDescriptions;
|
|
var fogDisplayedNames = new string[assets.Count + 1];
|
|
for (var i = 0; i < assets.Count; i++)
|
|
{
|
|
fogDisplayedNames[i] = assets[i].EditorName;
|
|
}
|
|
EditorGUI.BeginChangeCheck();
|
|
_settingsContainer.SelectedThirdPartyFogMethod = EditorGUILayout.Popup("Third-Party Fog Support", _settingsContainer.SelectedThirdPartyFogMethod, fogDisplayedNames);
|
|
if (EditorGUI.EndChangeCheck())
|
|
{
|
|
UpdateThirdPartyFog();
|
|
}
|
|
if (_settingsContainer.SelectedThirdPartyFogMethod != 0 && !_settingsContainer.IsThirdPartyFogAvailable)
|
|
{
|
|
EditorGUILayout.HelpBox($"Can't find the asset {WaterSystem.ThirdPartyFogAssetsDescriptions[_settingsContainer.SelectedThirdPartyFogMethod].EditorName}", MessageType.Error);
|
|
}
|
|
#if KWS_DEBUG
|
|
Line();
|
|
|
|
//if (_settings.WaterMeshType == WaterMeshTypeEnum.InfiniteOcean || _settings.WaterMeshType == WaterMeshTypeEnum.FiniteBox)
|
|
//{
|
|
// WaterSystem.DebugQuadtree = Toggle("Debug Quadtree", "", WaterSystem.DebugQuadtree, "");
|
|
//}
|
|
//_waterInstance.DebugAABB = Toggle("Debug AABB", "", _waterInstance.DebugAABB, "");
|
|
//_waterInstance.DebugFft = Toggle("Debug Fft", "", _waterInstance.DebugFft, "");
|
|
//_waterInstance.DebugDynamicWaves = Toggle("Debug Dynamic Waves", "", _waterInstance.DebugDynamicWaves, "");
|
|
//_waterInstance.DebugOrthoDepth = Toggle("Debug Ortho Depth", "", _waterInstance.DebugOrthoDepth, "");
|
|
//_waterInstance.DebugBuoyancy = Toggle("Debug Buoyancy", "", _waterInstance.DebugBuoyancy, "");
|
|
//WaterSystem.DebugUpdateManager = Toggle("Debug Update Manager", "", WaterSystem.DebugUpdateManager, "");
|
|
//Line();
|
|
#endif
|
|
|
|
}
|
|
|
|
void ReadSelectedThirdPartyFog()
|
|
{
|
|
var _settingsContainer = KWS_WaterSettingsRuntimeLoader._waterSystemQualitySettings;
|
|
//load enabled third-party asset for all water instances
|
|
if (_settingsContainer.SelectedThirdPartyFogMethod == -1)
|
|
{
|
|
var defines = WaterSystem.ThirdPartyFogAssetsDescriptions.Select(n => n.ShaderDefine).ToList<string>();
|
|
_settingsContainer.SelectedThirdPartyFogMethod = KWS_EditorUtils.GetEnabledDefineIndex(ShaderPaths.KWS_PlatformSpecificHelpers, defines);
|
|
}
|
|
|
|
}
|
|
|
|
|
|
void UpdateThirdPartyFog()
|
|
{
|
|
var _settings = KWS_WaterSettingsRuntimeLoader._waterQualityLevelSettings;
|
|
var _settingsContainer = KWS_WaterSettingsRuntimeLoader._waterSystemQualitySettings;
|
|
|
|
if (_settingsContainer.SelectedThirdPartyFogMethod > 0)
|
|
{
|
|
var selectedMethod = WaterSystem.ThirdPartyFogAssetsDescriptions[_settingsContainer.SelectedThirdPartyFogMethod];
|
|
if (!selectedMethod.IgnoreInclude)
|
|
{
|
|
var inlcudeFileName = KW_Extensions.GetAssetsRelativePathToFile(selectedMethod.ShaderInclude, selectedMethod.AssetNameSearchPattern);
|
|
if (String.IsNullOrEmpty(inlcudeFileName))
|
|
{
|
|
_settingsContainer.IsThirdPartyFogAvailable = false;
|
|
Debug.LogError($"Can't find the asset {WaterSystem.ThirdPartyFogAssetsDescriptions[_settingsContainer.SelectedThirdPartyFogMethod].EditorName}");
|
|
return;
|
|
}
|
|
else _settingsContainer.IsThirdPartyFogAvailable = true;
|
|
}
|
|
}
|
|
|
|
//replace defines
|
|
for (int i = 1; i < WaterSystem.ThirdPartyFogAssetsDescriptions.Count; i++)
|
|
{
|
|
var selectedMethod = WaterSystem.ThirdPartyFogAssetsDescriptions[i];
|
|
SetShaderTextDefine(ShaderPaths.KWS_PlatformSpecificHelpers, false, selectedMethod.ShaderDefine, _settingsContainer.SelectedThirdPartyFogMethod == i);
|
|
}
|
|
|
|
//replace paths to assets
|
|
if (_settingsContainer.SelectedThirdPartyFogMethod > 0)
|
|
{
|
|
var selectedMethod = WaterSystem.ThirdPartyFogAssetsDescriptions[_settingsContainer.SelectedThirdPartyFogMethod];
|
|
if (!selectedMethod.IgnoreInclude)
|
|
{
|
|
var inlcudeFileName = KW_Extensions.GetAssetsRelativePathToFile(selectedMethod.ShaderInclude, selectedMethod.AssetNameSearchPattern);
|
|
KWS_EditorUtils.ChangeShaderTextIncludePath(KWS_Settings.ShaderPaths.KWS_PlatformSpecificHelpers, selectedMethod.ShaderDefine, inlcudeFileName);
|
|
}
|
|
}
|
|
|
|
var thirdPartySelectedFog = WaterSystem.ThirdPartyFogAssetsDescriptions[_settingsContainer.SelectedThirdPartyFogMethod];
|
|
if (thirdPartySelectedFog.DrawToDepth) _settings.DrawToPosteffectsDepth = true;
|
|
|
|
AssetDatabase.Refresh();
|
|
|
|
var go = WaterSystem.Instance?.GetComponent<GameObject>();
|
|
if (go)
|
|
{
|
|
|
|
go.SetActive(false);
|
|
go.SetActive(true);
|
|
}
|
|
}
|
|
|
|
|
|
}
|
|
#endif
|
|
} |