public void DrawDebugGUI() { string label = "Debug"; string id = "debug" + water.GetInstanceID().ToString(); PEditorCommon.Foldout(label, false, id, () => { Camera[] cams = water.GetComponentsInChildren <Camera>(); for (int i = 0; i < cams.Length; ++i) { if (!cams[i].name.StartsWith("~")) { continue; } if (cams[i].targetTexture == null) { continue; } EditorGUILayout.LabelField(cams[i].name); Rect r = GUILayoutUtility.GetAspectRect(1); EditorGUI.DrawPreviewTexture(r, cams[i].targetTexture); EditorGUILayout.Space(); } }); }
private void DrawMeshSettingsGUI() { string label = "Mesh"; string id = "water-profile-mesh"; GenericMenu menu = new GenericMenu(); menu.AddItem( new GUIContent("Generate"), false, () => { water.GenerateMesh(); }); PEditorCommon.Foldout(label, true, id, () => { if (water.MeshType == PWaterMeshType.TileablePlane) { DrawTilableMeshGUI(); } else if (water.MeshType == PWaterMeshType.Area) { DrawAreaMeshGUI(); } else if (water.MeshType == PWaterMeshType.Spline) { DrawSplineMeshGUI(); } else if (water.MeshType == PWaterMeshType.CustomMesh) { DrawCustomMeshGUI(); } }, menu); }
public static void ShowSupportEmailEditor() { PEditorCommon.OpenEmailEditor( PCommon.SUPPORT_EMAIL, "[Poseidon] SHORT_QUESTION_HERE", "YOUR_QUESTION_IN_DETAIL"); }
public static void ShowBusinessEmailEditor() { PEditorCommon.OpenEmailEditor( PCommon.BUSINESS_EMAIL, "[Poseidon] SHORT_MESSAGE_HERE", "YOUR_MESSAGE_IN_DETAIL"); }
public static void OpenSupportLink() { PEditorCommon.OpenEmailEditor( "*****@*****.**", "Griffin Extension - Poseidon", "YOUR_MESSAGE_HERE"); }
private void DrawSelectedSegmentGUI() { int segmentIndex = splineEditingGUIDrawer.selectedSegmentIndex; if (segmentIndex < 0 || segmentIndex >= water.Spline.Anchors.Count) { return; } string label = "Selected Segment"; string id = "poseidon-selected-segment"; PEditorCommon.Foldout(label, true, id, () => { EditorGUI.indentLevel -= 1; EditorGUI.BeginChangeCheck(); PSplineSegment s = water.Spline.Segments[segmentIndex]; GUI.enabled = !PSplineToolConfig.Instance.AutoTangent; s.StartTangent = PEditorCommon.InlineVector3Field("Start Tangent", s.StartTangent); s.EndTangent = PEditorCommon.InlineVector3Field("End Tangent", s.EndTangent); GUI.enabled = true; s.ResolutionMultiplierY = EditorGUILayout.Slider("Resolution Multiplier Y", s.ResolutionMultiplierY, 0f, 2f); water.Spline.Segments[segmentIndex] = s; if (EditorGUI.EndChangeCheck()) { water.GenerateSplineMeshAtSegment(segmentIndex); } EditorGUI.indentLevel += 1; }); }
private void DrawCausticSettings() { string label = "Caustic"; string id = "water-profile-caustic"; PEditorCommon.Foldout(label, true, id, () => { bool valid = profile.EnableLightAbsorption && (profile.EnableRefraction || water.MeshType == PWaterMeshType.Spline); if (!valid) { EditorGUILayout.LabelField("Requires Light Absorbtion and Refraction.", PEditorCommon.WordWrapItalicLabel); profile.EnableCaustic = false; } GUI.enabled = valid; profile.EnableCaustic = EditorGUILayout.Toggle("Enable", profile.EnableCaustic); if (profile.EnableCaustic) { profile.CausticTexture = PEditorCommon.InlineTextureField("Texture", profile.CausticTexture, -1); profile.CausticSize = EditorGUILayout.FloatField("Size", profile.CausticSize); profile.CausticStrength = EditorGUILayout.Slider("Strength", profile.CausticStrength, 0f, 5f); profile.CausticDistortionStrength = EditorGUILayout.FloatField("Distortion", profile.CausticDistortionStrength); } GUI.enabled = true; }); }
private void DrawEffectsGUI() { if (PCommon.CurrentRenderPipeline == PRenderPipelineType.Universal) { return; } PWaterFX fx = water.GetComponent <PWaterFX>(); if (fx != null) { return; } string label = "Effects"; string id = "effects" + water.GetInstanceID(); PEditorCommon.Foldout(label, false, id, () => { bool isStackV2Installed = false; #if UNITY_POST_PROCESSING_STACK_V2 isStackV2Installed = true; #endif if (!isStackV2Installed) { EditorGUILayout.LabelField("Water effect need the Post Processing Stack V2 to work. Please install it using the Package Manager", PEditorCommon.WordWrapItalicLabel); } GUI.enabled = isStackV2Installed; if (GUILayout.Button("Add Effects")) { fx = water.gameObject.AddComponent <PWaterFX>(); fx.Water = water; } GUI.enabled = true; }); }
public override void OnInspectorGUI() { if (water.transform.rotation != Quaternion.identity) { string warning = "The water object is designed to work without rotation. Some features may not work correctly."; EditorGUILayout.LabelField(warning, PEditorCommon.WarningLabel); } water.Profile = PEditorCommon.ScriptableObjectField <PWaterProfile>("Profile", water.Profile); profile = water.Profile; if (water.Profile == null) { return; } so = new SerializedObject(profile); reflectionLayersSO = so.FindProperty("reflectionLayers"); refractionLayersSO = so.FindProperty("refractionLayers"); EditorGUI.BeginChangeCheck(); DrawMeshSettingsGUI(); DrawRenderingSettingsGUI(); DrawColorsSettingsGUI(); DrawFresnelSettingsGUI(); DrawRippleSettingsGUI(); DrawWaveSettingsGUI(); DrawLightAbsorbtionSettingsGUI(); DrawFoamSettingsGUI(); DrawReflectionSettings(); DrawRefractionSettings(); DrawCausticSettings(); if (EditorGUI.EndChangeCheck()) { EditorUtility.SetDirty(profile); water.UpdateMaterial(); } DrawEffectsGUI(); if (willDrawDebugGUI) { DrawDebugGUI(); } if (so != null) { so.Dispose(); } if (reflectionLayersSO != null) { reflectionLayersSO.Dispose(); } if (refractionLayersSO != null) { refractionLayersSO.Dispose(); } }
public override void OnInspectorGUI() { bool willDrawGUI = false; string msg = null; if (PCommon.CurrentRenderPipeline == PRenderPipelineType.Builtin) { #if UNITY_POST_PROCESSING_STACK_V2 willDrawGUI = true; #else msg = "Please install Post Processing Stack V2 to setup water effect"; #endif } else if (PCommon.CurrentRenderPipeline == PRenderPipelineType.Universal) { #if POSEIDON_URP willDrawGUI = true; #endif } else { willDrawGUI = false; msg = "Water effect doesn't support custom render pipeline."; } if (!willDrawGUI) { EditorGUILayout.LabelField(msg, PEditorCommon.WordWrapItalicLabel); return; } #if POSEIDON_URP if (PCommon.CurrentRenderPipeline == PRenderPipelineType.Universal) { if (!CheckRendererFeatureConfig()) { EditorGUILayout.LabelField("Please add a Water Effect Renderer Feature to the current URP Asset to setup water effect.", PEditorCommon.WordWrapItalicLabel); return; } } #endif instance.Water = EditorGUILayout.ObjectField("Water", instance.Water, typeof(PWater), true) as PWater; instance.Profile = PEditorCommon.ScriptableObjectField <PWaterFXProfile>("Profile", instance.Profile); if (instance.Water == null || instance.Profile == null) { return; } DrawVolumesGUI(); EditorGUI.BeginChangeCheck(); PWaterFXProfileInspectorDrawer.Create(instance.Profile, instance.Water).DrawGUI(); if (EditorGUI.EndChangeCheck()) { instance.UpdatePostProcessOrVolumeProfile(); } DrawEventsGUI(); }
private void DrawTilableMeshGUI() { if (!isEditingTileIndices) { EditorGUI.BeginChangeCheck(); //water.MeshType = (PWaterMeshType)EditorGUILayout.EnumPopup("Mesh Type", water.MeshType); water.MeshType = (PWaterMeshType)EditorGUILayout.IntPopup("Mesh Type", (int)water.MeshType, meshTypeLabels, meshTypes); water.PlanePattern = (PPlaneMeshPattern)EditorGUILayout.EnumPopup("Pattern", water.PlanePattern); water.MeshResolution = EditorGUILayout.DelayedIntField("Resolution", water.MeshResolution); if (EditorGUI.EndChangeCheck()) { water.GenerateMesh(); water.ReCalculateBounds(); } water.MeshNoise = EditorGUILayout.FloatField("Noise", water.MeshNoise); EditorGUI.BeginChangeCheck(); water.TileSize = PEditorCommon.InlineVector2Field("Tile Size", water.TileSize); water.TilesFollowMainCamera = EditorGUILayout.Toggle("Follow Main Camera", water.TilesFollowMainCamera); SerializedObject so = new SerializedObject(water); SerializedProperty sp = so.FindProperty("tileIndices"); if (sp != null) { EditorGUI.BeginChangeCheck(); EditorGUILayout.PropertyField(sp, true); if (EditorGUI.EndChangeCheck()) { so.ApplyModifiedProperties(); } } sp.Dispose(); so.Dispose(); if (EditorGUI.EndChangeCheck()) { water.ReCalculateBounds(); } } if (!isEditingTileIndices) { if (GUILayout.Button("Edit Tiles")) { isEditingTileIndices = true; } } else { EditorGUILayout.LabelField("Edit water tiles in Scene View.", PEditorCommon.WordWrapItalicLabel); if (GUILayout.Button("End Editing Tiles")) { isEditingTileIndices = false; } } }
private void DrawVolumesGUI() { string label = "Volumes"; string id = "volumes" + instance.GetInstanceID(); PEditorCommon.Foldout(label, false, id, () => { instance.VolumeExtent = PEditorCommon.InlineVector3Field("Extent", instance.VolumeExtent); instance.VolumeLayer = EditorGUILayout.LayerField("Layer", instance.VolumeLayer); }); }
private void DrawFresnelSettingsGUI() { string label = "Fresnel"; string id = "water-profile-fresnel"; PEditorCommon.Foldout(label, true, id, () => { profile.FresnelStrength = EditorGUILayout.Slider("Strength", profile.FresnelStrength, 0f, 10f); profile.FresnelBias = EditorGUILayout.Slider("Bias", profile.FresnelBias, 0f, 1f); }); }
private void DrawLightAbsorbtionSettingsGUI() { string label = "Light Absorption"; string id = "water-profile-absorption"; PEditorCommon.Foldout(label, true, id, () => { profile.EnableLightAbsorption = EditorGUILayout.Toggle("Enable", profile.EnableLightAbsorption); if (profile.EnableLightAbsorption) { profile.DepthColor = EditorGUILayout.ColorField("Depth Color", profile.DepthColor); profile.MaxDepth = EditorGUILayout.FloatField("Max Depth", profile.MaxDepth); } }); }
private void DrawInstruction() { string s = string.Format( "{0}" + "{1}" + "{2}" + "{3}", "Click to select,", "\nShift+Click to add,", "\nCtrl+Click to remove anchor.", "\nClick End Editing Spline when done."); GUIContent mouseMessage = new GUIContent(s); PEditorCommon.SceneViewMouseMessage(mouseMessage); }
private void DrawRippleSettingsGUI() { string label = "Ripple"; string id = "water-profile-ripple"; PEditorCommon.Foldout(label, true, id, () => { //instance.EnableRipple = EditorGUILayout.Toggle("Enable", instance.EnableRipple); if (profile.EnableRipple) { profile.RippleHeight = EditorGUILayout.Slider("Height", profile.RippleHeight, 0f, 1f); profile.RippleNoiseScale = EditorGUILayout.FloatField("Scale", profile.RippleNoiseScale); profile.RippleSpeed = EditorGUILayout.FloatField("Speed", profile.RippleSpeed); } }); }
private void DrawRefractionSettings() { string label = "Refraction"; string id = "water-profile-refraction"; PEditorCommon.Foldout(label, true, id, () => { if (water.MeshType != PWaterMeshType.Spline) { profile.EnableRefraction = EditorGUILayout.Toggle("Enable", profile.EnableRefraction); } if (profile.EnableRefraction || water.MeshType == PWaterMeshType.Spline) { profile.RefractionDistortionStrength = EditorGUILayout.FloatField("Distortion", profile.RefractionDistortionStrength); } }); }
private void DrawWetLensGUI() { string label = "Wet Lens"; string id = "wet-lens" + instance.GetInstanceID(); PEditorCommon.Foldout(label, false, id, () => { instance.EnableWetLens = EditorGUILayout.Toggle("Enable", instance.EnableWetLens); if (instance.EnableWetLens) { instance.WetLensNormalMap = PEditorCommon.InlineTextureField("Normal Map", instance.WetLensNormalMap, -1); instance.WetLensStrength = EditorGUILayout.Slider("Strength", instance.WetLensStrength, 0f, 1f); instance.WetLensDuration = EditorGUILayout.FloatField("Duration", instance.WetLensDuration); instance.WetLensFadeCurve = EditorGUILayout.CurveField("Fade", instance.WetLensFadeCurve, Color.red, new Rect(0, 0, 1, 1)); } }); }
private void DrawRenderingSettingsGUI() { string label = "Rendering"; string id = "water-profile-general"; PEditorCommon.Foldout(label, true, id, () => { GUI.enabled = false; EditorGUILayout.ObjectField("Material", water.MaterialToRender, typeof(Material), false); if (water.MeshType == PWaterMeshType.TileablePlane && water.ShouldRenderBackface) { EditorGUILayout.ObjectField("Material Back Face", water.MaterialBackFace, typeof(Material), false); } GUI.enabled = true; if (PCommon.CurrentRenderPipeline == PRenderPipelineType.Builtin) { EditorGUILayout.BeginHorizontal(); EditorGUILayout.PrefixLabel("Light Model"); Rect r = EditorGUILayout.GetControlRect(); if (GUI.Button(r, "Physical Based", EditorStyles.popup)) { GenericMenu menu = new GenericMenu(); menu.AddItem(new GUIContent("Physical Based"), false, () => { }); menu.AddDisabledItem(new GUIContent("Blinn Phong (SRP)")); menu.AddDisabledItem(new GUIContent("Lambert (SRP)")); menu.DropDown(r); } EditorGUILayout.EndHorizontal(); profile.LightingModel = PLightingModel.PhysicalBased; } else { profile.LightingModel = (PLightingModel)EditorGUILayout.EnumPopup("Light Model", profile.LightingModel); } profile.RenderQueueIndex = EditorGUILayout.IntField("Queue Index", profile.RenderQueueIndex); if (water.MeshType == PWaterMeshType.TileablePlane) { water.ShouldRenderBackface = EditorGUILayout.Toggle("Render Back Face", water.ShouldRenderBackface); } }); }
private void DrawWaveSettingsGUI() { string label = "Wave"; string id = "water-profile-ripple"; PEditorCommon.Foldout(label, false, id, () => { profile.EnableWave = EditorGUILayout.Toggle("Enable", profile.EnableWave); if (profile.EnableWave) { profile.WaveDirection = EditorGUILayout.Slider("Direction", profile.WaveDirection, 0f, 360f); profile.WaveSpeed = EditorGUILayout.FloatField("Speed", profile.WaveSpeed); profile.WaveHeight = EditorGUILayout.FloatField("Height", profile.WaveHeight); profile.WaveLength = EditorGUILayout.FloatField("Length", profile.WaveLength); profile.WaveSteepness = EditorGUILayout.Slider("Steepness", profile.WaveSteepness, 0f, 1f); profile.WaveDeform = EditorGUILayout.Slider("Deform", profile.WaveDeform, 0f, 1f); } }); }
private void DrawColorsSettingsGUI() { string label = "Colors"; string id = "water-profile-colors"; PEditorCommon.Foldout(label, true, id, () => { profile.Color = EditorGUILayout.ColorField("Color", profile.Color); if (profile.EnableLightAbsorption) { profile.DepthColor = EditorGUILayout.ColorField("Depth Color", profile.DepthColor); } if (profile.LightingModel == PLightingModel.PhysicalBased || profile.LightingModel == PLightingModel.BlinnPhong) { //instance.SpecColor = EditorGUILayout.ColorField("Specular Color", instance.SpecColor); profile.SpecColor = EditorGUILayout.ColorField(new GUIContent("Specular Color"), profile.SpecColor, true, false, true); profile.Smoothness = EditorGUILayout.Slider("Smoothness", profile.Smoothness, 0f, 1f); } }); }
private void DrawEventsGUI() { string label = "Events"; string id = "events" + instance.GetInstanceID(); PEditorCommon.Foldout(label, false, id, () => { SerializedObject so = new SerializedObject(instance); SerializedProperty sp0 = so.FindProperty("onEnterWater"); if (sp0 != null) { EditorGUILayout.PropertyField(sp0); } SerializedProperty sp1 = so.FindProperty("onExitWater"); if (sp1 != null) { EditorGUILayout.PropertyField(sp1); } so.ApplyModifiedProperties(); }); }
private void DrawReflectionSettings() { if (water.MeshType == PWaterMeshType.Spline) { return; } bool stereoEnable = false; if (Camera.main != null) { stereoEnable = Camera.main.stereoEnabled; } string label = "Reflection" + (stereoEnable ? " (Not support for VR)" : ""); string id = "water-profile-reflection"; GUI.enabled = !stereoEnable; PEditorCommon.Foldout(label, true, id, () => { profile.EnableReflection = EditorGUILayout.Toggle("Enable", profile.EnableReflection); if (profile.EnableReflection) { profile.ReflectCustomSkybox = EditorGUILayout.Toggle("Custom Skybox", profile.ReflectCustomSkybox); profile.EnableReflectionPixelLight = EditorGUILayout.Toggle("Pixel Light", profile.EnableReflectionPixelLight); profile.ReflectionClipPlaneOffset = EditorGUILayout.FloatField("Clip Plane Offset", profile.ReflectionClipPlaneOffset); if (reflectionLayersSO != null) { EditorGUILayout.PropertyField(reflectionLayersSO); } so.ApplyModifiedProperties(); profile.ReflectionTextureResolution = EditorGUILayout.IntPopup("Resolution", profile.ReflectionTextureResolution, renderTextureSizeLabels, renderTextureSizes); profile.ReflectionDistortionStrength = EditorGUILayout.FloatField("Distortion", profile.ReflectionDistortionStrength); } }); GUI.enabled = true; }
private void DrawFoamSettingsGUI() { string label = "Foam"; string id = "water-profile-foam"; PEditorCommon.Foldout(label, true, id, () => { profile.EnableFoam = EditorGUILayout.Toggle("Enable", profile.EnableFoam); if (profile.EnableFoam) { profile.EnableFoamHQ = EditorGUILayout.Toggle("High Quality", profile.EnableFoamHQ); if (profile.EnableFoamHQ) { profile.FoamNoiseScaleHQ = EditorGUILayout.FloatField("Scale", profile.FoamNoiseScaleHQ); profile.FoamNoiseSpeedHQ = EditorGUILayout.FloatField("Speed", profile.FoamNoiseSpeedHQ); } profile.FoamColor = EditorGUILayout.ColorField(new GUIContent("Color"), profile.FoamColor, true, true, true); PEditorCommon.Header("Shoreline"); profile.FoamDistance = EditorGUILayout.FloatField("Distance", profile.FoamDistance); profile.ShorelineFoamStrength = EditorGUILayout.Slider("Strength", profile.ShorelineFoamStrength, 0f, 1f); if (profile.EnableWave) { PEditorCommon.Header("Crest"); profile.CrestMaxDepth = EditorGUILayout.FloatField("Max Depth", profile.CrestMaxDepth); profile.CrestFoamStrength = EditorGUILayout.Slider("Strength", profile.CrestFoamStrength, 0f, 1f); } if (water.MeshType == PWaterMeshType.Spline) { PEditorCommon.Header("Slope"); profile.SlopeFoamDistance = EditorGUILayout.FloatField("Distance", profile.SlopeFoamDistance); profile.SlopeFoamFlowSpeed = EditorGUILayout.FloatField("Flow Speed", profile.SlopeFoamFlowSpeed); profile.SlopeFoamStrength = EditorGUILayout.Slider("Strength", profile.SlopeFoamStrength, 0f, 1f); } } }); }
private void DrawSelectedAnchorGUI() { int anchorIndex = splineEditingGUIDrawer.selectedAnchorIndex; if (anchorIndex < 0 || anchorIndex >= water.Spline.Anchors.Count) { return; } string label = "Selected Anchor"; string id = "poseidon-selected-anchor"; PEditorCommon.Foldout(label, true, id, () => { EditorGUI.indentLevel -= 1; PSplineAnchor a = water.Spline.Anchors[anchorIndex]; EditorGUI.BeginChangeCheck(); a.Position = PEditorCommon.InlineVector3Field("Position", a.Position); a.Rotation = Quaternion.Euler(PEditorCommon.InlineVector3Field("Rotation", a.Rotation.eulerAngles)); a.Scale = PEditorCommon.InlineVector3Field("Scale", a.Scale); water.Spline.Anchors[anchorIndex] = a; if (EditorGUI.EndChangeCheck()) { if (PSplineToolConfig.Instance.AutoTangent) { int[] segmentIndices = water.Spline.SmoothTangents(anchorIndex); water.GenerateSplineMeshAtSegments(segmentIndices); } else { List <int> segmentIndices = water.Spline.FindSegments(anchorIndex); water.GenerateSplineMeshAtSegments(segmentIndices); } } EditorGUI.indentLevel += 1; }); }
private void HandleAddRemoveTiles() { Plane plane = new Plane(Vector3.up, water.transform.position); Ray r = HandleUtility.GUIPointToWorldRay(Event.current.mousePosition); float distance = -1; if (plane.Raycast(r, out distance)) { Vector3 hitWorldPos = r.origin + r.direction * distance; Vector3 hitLocalPos = water.transform.InverseTransformPoint(hitWorldPos); PIndex2D index = new PIndex2D( Mathf.FloorToInt(hitLocalPos.x / water.TileSize.x), Mathf.FloorToInt(hitLocalPos.z / water.TileSize.y)); Vector3 rectCenter = water.transform.TransformPoint(new Vector3( (index.X + 0.5f) * water.TileSize.x, hitLocalPos.y, (index.Z + 0.5f) * water.TileSize.y)); Vector3 rectSize = water.transform.TransformVector(new Vector3( water.TileSize.x, 0, water.TileSize.y)); if (Event.current.type == EventType.MouseDrag || Event.current.type == EventType.MouseUp) { if (Event.current.button != 0) { return; } if (Event.current.control) { water.TileIndices.Remove(index); water.ReCalculateBounds(); } else if (Event.current.shift) { if (!water.TileIndices.Contains(index)) { water.TileIndices.Add(index); water.ReCalculateBounds(); } } PUtilities.MarkCurrentSceneDirty(); EditorUtility.SetDirty(water); } Handles.color = Handles.selectedColor; Handles.DrawWireCube(rectCenter, rectSize); string s = string.Format( "{0}" + "{1}" + "{2}", index.ToString(), "\nShift+Click to pin, Ctrl+Click to unpin water planes.", "\nClick End Editing Tiles when done."); GUIContent mouseMessage = new GUIContent(s); PEditorCommon.SceneViewMouseMessage(mouseMessage); } }
private static void DrawWaterConfigGUI(PWater water) { DrawTemplateSelectionGUI(water); PWaterQuickSetupConfig config = PWaterQuickSetupConfig.Instance; bool changed = false; bool meshChanged = false; EditorGUI.BeginChangeCheck(); config.WaterLevel = EditorGUILayout.FloatField("Water Level", config.WaterLevel); if (EditorGUI.EndChangeCheck()) { changed = true; } EditorGUI.BeginChangeCheck(); config.MeshResolution = EditorGUILayout.DelayedIntField("Resolution", config.MeshResolution); if (EditorGUI.EndChangeCheck()) { meshChanged = true; } EditorGUI.BeginChangeCheck(); config.MeshNoise = EditorGUILayout.FloatField("Noise", config.MeshNoise); config.ApproximateSizeX = EditorGUILayout.FloatField("Approx. Size X", config.ApproximateSizeX); config.ApproximateSizeZ = EditorGUILayout.FloatField("Approx. Size Z", config.ApproximateSizeZ); config.TileSize = PEditorCommon.InlineVector2Field("Tile Size", config.TileSize); if (EditorGUI.EndChangeCheck()) { changed = true; } if (meshChanged) { water.GeneratePlaneMesh(); } if (changed || meshChanged) { water.MeshNoise = config.MeshNoise; water.TileSize = config.TileSize; water.UpdateMaterial(); MatchWaterLevel(water); MatchWaterSize(water); } EditorUtility.SetDirty(config); GEditorCommon.Separator(); if (GUILayout.Button("Center To Level Bounds")) { CenterToLevel(water); } if (GUILayout.Button("Fill Level Bounds")) { Bounds levelBounds = GCommon.GetLevelBounds(); config.ApproximateSizeX = levelBounds.size.x; config.ApproximateSizeZ = levelBounds.size.z; CenterToLevel(water); MatchWaterSize(water); } if (GUILayout.Button("Done")) { Done(water); } }
private void DrawUnderwaterGUI() { string label = "Underwater"; string id = "underwater" + instance.GetInstanceID(); PEditorCommon.Foldout(label, false, id, () => { instance.EnableUnderwater = EditorGUILayout.Toggle("Enable", instance.EnableUnderwater); if (instance.EnableUnderwater) { PEditorCommon.SpacePixel(0); EditorGUILayout.LabelField("Water Body", PEditorCommon.BoldHeader); instance.UnderwaterWaterLevel = EditorGUILayout.FloatField("Water Level", instance.UnderwaterWaterLevel); instance.UnderwaterMaxDepth = EditorGUILayout.FloatField("Max Depth", instance.UnderwaterMaxDepth); instance.UnderwaterSurfaceColorBoost = EditorGUILayout.Slider("Surface Color Boost", instance.UnderwaterSurfaceColorBoost, 1f, 3f); PEditorCommon.SpacePixel(0); EditorGUILayout.LabelField("Fog", PEditorCommon.BoldHeader); instance.UnderwaterShallowFogColor = EditorGUILayout.ColorField("Shallow Fog Color", instance.UnderwaterShallowFogColor); instance.UnderwaterDeepFogColor = EditorGUILayout.ColorField("Deep Fog Color", instance.UnderwaterDeepFogColor); instance.UnderwaterViewDistance = EditorGUILayout.FloatField("View Distance", instance.UnderwaterViewDistance); PEditorCommon.SpacePixel(0); EditorGUILayout.LabelField("Caustic", PEditorCommon.BoldHeader); instance.UnderwaterEnableCaustic = EditorGUILayout.Toggle("Enable", instance.UnderwaterEnableCaustic); if (instance.UnderwaterEnableCaustic) { instance.UnderwaterCausticTexture = PEditorCommon.InlineTextureField("Texture", instance.UnderwaterCausticTexture, -1); instance.UnderwaterCausticSize = EditorGUILayout.FloatField("Size", instance.UnderwaterCausticSize); instance.UnderwaterCausticStrength = EditorGUILayout.Slider("Strength", instance.UnderwaterCausticStrength, 0f, 1f); } PEditorCommon.SpacePixel(0); EditorGUILayout.LabelField("Distortion", PEditorCommon.BoldHeader); instance.UnderwaterEnableDistortion = EditorGUILayout.Toggle("Enable", instance.UnderwaterEnableDistortion); if (instance.UnderwaterEnableDistortion) { instance.UnderwaterDistortionTexture = PEditorCommon.InlineTextureField("Normal Map", instance.UnderwaterDistortionTexture, -1); instance.UnderwaterDistortionStrength = EditorGUILayout.FloatField("Strength", instance.UnderwaterDistortionStrength); instance.UnderwaterWaterFlowSpeed = EditorGUILayout.FloatField("Water Flow Speed", instance.UnderwaterWaterFlowSpeed); } PEditorCommon.Separator(); } if (water != null && instance.EnableUnderwater) { GUI.enabled = water.Profile != null; if (GUILayout.Button("Inherit Parameters")) { instance.UnderwaterWaterLevel = water.transform.position.y; instance.UnderwaterMaxDepth = water.Profile.MaxDepth; instance.UnderwaterShallowFogColor = water.Profile.Color; instance.UnderwaterDeepFogColor = water.Profile.DepthColor; instance.UnderwaterEnableCaustic = water.Profile.EnableCaustic; instance.UnderwaterCausticTexture = water.Profile.CausticTexture; instance.UnderwaterCausticSize = water.Profile.CausticSize; instance.UnderwaterCausticStrength = water.Profile.CausticStrength; } GUI.enabled = true; } }); }