portals and dash. Also a bit of terrain building and level design

Assets/Polaris - Low Poly Ecosystem/Poseidon - Low Poly Water System/Runtime/Scripts/Effects/BuiltinRP.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: b57584cef44bfbe4dbdf385c1bc61f27
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Polaris - Low Poly Ecosystem/Poseidon - Low Poly Water System/Runtime/Scripts/Effects/BuiltinRP/PUnderwater.cs

@@ -0,0 +1,49 @@
+#if UNITY_POST_PROCESSING_STACK_V2
+using UnityEngine;
+using System.Collections;
+using System.Collections.Generic;
+using UnityEngine.Rendering.PostProcessing;
+
+namespace Pinwheel.Poseidon.FX.PostProcessing
+{
+    [System.Serializable]
+    [PostProcess(typeof(PUnderwaterRenderer), PostProcessEvent.BeforeStack, "Poseidon/Underwater", false)]
+    public sealed class PUnderwater : PostProcessEffectSettings
+    {
+        [Header("Water Body")]
+        public FloatParameter waterLevel = new FloatParameter();
+        public FloatParameter maxDepth = new FloatParameter() { value = 10 };
+        [Range(0f, 3f)]
+        public FloatParameter surfaceColorBoost = new FloatParameter() { value = 1 };
+
+        [Header("Fog")]
+        public ColorParameter shallowFogColor = new ColorParameter();
+        public ColorParameter deepFogColor = new ColorParameter();
+        public FloatParameter viewDistance = new FloatParameter() { value = 40 };
+
+        [Header("Caustic")]
+        public BoolParameter enableCaustic = new BoolParameter();
+        public TextureParameter causticTexture = new TextureParameter();
+        public FloatParameter causticSize = new FloatParameter();
+        [Range(0f, 1f)]
+        public FloatParameter causticStrength = new FloatParameter();
+
+        [Header("Distortion")]
+        public BoolParameter enableDistortion = new BoolParameter();
+        public TextureParameter distortionNormalMap = new TextureParameter();
+        public FloatParameter distortionStrength = new FloatParameter();
+        public FloatParameter waterFlowSpeed = new FloatParameter();
+
+        [Header("Internal")]
+        [Range(0f, 1f)]
+        public FloatParameter intensity = new FloatParameter();
+
+        public override bool IsEnabledAndSupported(PostProcessRenderContext context)
+        {
+            return enabled.value
+                && intensity.value > 0
+                && context.camera.transform.position.y <= waterLevel.value;
+        }
+    }
+}
+#endif

Assets/Polaris - Low Poly Ecosystem/Poseidon - Low Poly Water System/Runtime/Scripts/Effects/BuiltinRP/PUnderwater.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 82593716811bfb449b4a447ef9eb28b9
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Polaris - Low Poly Ecosystem/Poseidon - Low Poly Water System/Runtime/Scripts/Effects/BuiltinRP/PUnderwaterRenderer.cs

@@ -0,0 +1,62 @@
+#if UNITY_POST_PROCESSING_STACK_V2
+using UnityEngine;
+using System.Collections;
+using System.Collections.Generic;
+using UnityEngine.Rendering.PostProcessing;
+
+namespace Pinwheel.Poseidon.FX.PostProcessing
+{
+
+    public class PUnderwaterRenderer : PostProcessEffectRenderer<PUnderwater>
+    {
+        public override void Render(PostProcessRenderContext context)
+        {
+            PropertySheet sheet = context.propertySheets.Get(PPoseidonSettings.Instance.UnderwaterShader);
+            sheet.properties.SetFloat(PMat.PP_WATER_LEVEL, settings.waterLevel);
+            sheet.properties.SetFloat(PMat.PP_MAX_DEPTH, settings.maxDepth);
+            sheet.properties.SetFloat(PMat.PP_SURFACE_COLOR_BOOST, settings.surfaceColorBoost);
+
+            sheet.properties.SetColor(PMat.PP_SHALLOW_FOG_COLOR, settings.shallowFogColor);
+            sheet.properties.SetColor(PMat.PP_DEEP_FOG_COLOR, settings.deepFogColor);
+            sheet.properties.SetFloat(PMat.PP_VIEW_DISTANCE, settings.viewDistance);
+
+            if (settings.enableCaustic && settings.causticTexture.value != null)
+            {
+                sheet.EnableKeyword(PMat.KW_PP_CAUSTIC);
+                sheet.properties.SetTexture(PMat.PP_NOISE_TEX, PPoseidonSettings.Instance.NoiseTexture);
+                sheet.properties.SetTexture(PMat.PP_CAUSTIC_TEX, settings.causticTexture.value);
+                sheet.properties.SetFloat(PMat.PP_CAUSTIC_SIZE, settings.causticSize);
+                sheet.properties.SetFloat(PMat.PP_CAUSTIC_STRENGTH, settings.causticStrength);
+            }
+            else
+            {
+                sheet.DisableKeyword(PMat.KW_PP_CAUSTIC);
+            }
+
+            if (settings.enableDistortion && settings.distortionNormalMap.value != null)
+            {
+                sheet.EnableKeyword(PMat.KW_PP_DISTORTION);
+                sheet.properties.SetTexture(PMat.PP_DISTORTION_TEX, settings.distortionNormalMap.value);
+                sheet.properties.SetFloat(PMat.PP_DISTORTION_STRENGTH, settings.distortionStrength);
+                sheet.properties.SetFloat(PMat.PP_WATER_FLOW_SPEED, settings.waterFlowSpeed);
+            }
+            else
+            {
+                sheet.DisableKeyword(PMat.KW_PP_DISTORTION);
+            }
+
+            sheet.properties.SetVector(PMat.PP_CAMERA_VIEW_DIR, context.camera.transform.forward);
+            sheet.properties.SetFloat(PMat.PP_CAMERA_FOV, context.camera.fieldOfView);
+            sheet.properties.SetMatrix(PMat.PP_CAMERA_TO_WORLD_MATRIX, context.camera.cameraToWorldMatrix);
+            sheet.properties.SetFloat(PMat.PP_INTENSITY, settings.intensity);
+
+            context.command.BlitFullscreenTriangle(context.source, context.destination, sheet, 0);
+        }
+
+        public override DepthTextureMode GetCameraFlags()
+        {
+            return DepthTextureMode.Depth;
+        }
+    }
+}
+#endif

Assets/Polaris - Low Poly Ecosystem/Poseidon - Low Poly Water System/Runtime/Scripts/Effects/BuiltinRP/PUnderwaterRenderer.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 1232f4a297f2128449d5381cfd47cce0
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Polaris - Low Poly Ecosystem/Poseidon - Low Poly Water System/Runtime/Scripts/Effects/BuiltinRP/PWetLens.cs

@@ -0,0 +1,30 @@
+#if UNITY_POST_PROCESSING_STACK_V2
+using UnityEngine;
+using System.Collections;
+using System.Collections.Generic;
+using UnityEngine.Rendering.PostProcessing;
+
+namespace Pinwheel.Poseidon.FX.PostProcessing
+{
+    [System.Serializable]
+    [PostProcess(typeof(PWetLensRenderer), PostProcessEvent.BeforeStack, "Poseidon/Wet Lens", false)]
+    public sealed class PWetLens : PostProcessEffectSettings
+    {
+        [Header("Lens Distort")]
+        public TextureParameter normalMap = new TextureParameter();
+        [Range(0f, 1f)]
+        public FloatParameter strength = new FloatParameter();
+
+        [Header("Internal")]
+        [Range(0f, 1f)]
+        public FloatParameter intensity = new FloatParameter();
+
+        public override bool IsEnabledAndSupported(PostProcessRenderContext context)
+        {
+            return enabled.value
+                && normalMap.value != null
+                && intensity.value > 0;
+        }
+    }
+}
+#endif

Assets/Polaris - Low Poly Ecosystem/Poseidon - Low Poly Water System/Runtime/Scripts/Effects/BuiltinRP/PWetLens.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 2ea78e3311d3bc648ac0f3f022f2f307
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Polaris - Low Poly Ecosystem/Poseidon - Low Poly Water System/Runtime/Scripts/Effects/BuiltinRP/PWetLensRenderer.cs

@@ -0,0 +1,22 @@
+#if UNITY_POST_PROCESSING_STACK_V2
+using UnityEngine;
+using System.Collections;
+using System.Collections.Generic;
+using UnityEngine.Rendering.PostProcessing;
+
+namespace Pinwheel.Poseidon.FX.PostProcessing
+{
+    public class PWetLensRenderer : PostProcessEffectRenderer<PWetLens>
+    {
+        public override void Render(PostProcessRenderContext context)
+        {
+            PropertySheet sheet = context.propertySheets.Get(PPoseidonSettings.Instance.WetLensShader);
+            Texture normalMap = settings.normalMap.value ?? PPoseidonSettings.Instance.DefaultNormalMap;
+            sheet.properties.SetTexture(PMat.PP_WET_LENS_TEX, normalMap);
+            sheet.properties.SetFloat(PMat.PP_WET_LENS_STRENGTH, settings.strength * settings.intensity);
+
+            context.command.BlitFullscreenTriangle(context.source, context.destination, sheet, 0);
+        }
+    }
+}
+#endif

Assets/Polaris - Low Poly Ecosystem/Poseidon - Low Poly Water System/Runtime/Scripts/Effects/BuiltinRP/PWetLensRenderer.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 6475c569b1d701745953c7e26ea7d7f5
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Polaris - Low Poly Ecosystem/Poseidon - Low Poly Water System/Runtime/Scripts/Effects/PWaterFX.cs

@@ -0,0 +1,417 @@
+using UnityEngine;
+using System.Collections;
+using System.Collections.Generic;
+using UnityEngine.Rendering;
+using UnityEngine.Events;
+#if UNITY_POST_PROCESSING_STACK_V2
+using Pinwheel.Poseidon.FX.PostProcessing;
+using UnityEngine.Rendering.PostProcessing;
+#endif
+#if POSEIDON_URP
+using Pinwheel.Poseidon.FX.Universal;
+#endif
+
+namespace Pinwheel.Poseidon.FX
+{
+    [ExecuteInEditMode]
+    [RequireComponent(typeof(PWater))]
+    public class PWaterFX : MonoBehaviour
+    {
+        [SerializeField]
+        private PWater water;
+        public PWater Water
+        {
+            get
+            {
+                return water;
+            }
+            set
+            {
+                water = value;
+            }
+        }
+
+        [SerializeField]
+        private PWaterFXProfile profile;
+        public PWaterFXProfile Profile
+        {
+            get
+            {
+                return profile;
+            }
+            set
+            {
+                PWaterFXProfile oldProfile = profile;
+                PWaterFXProfile newProfile = value;
+                profile = newProfile;
+
+                if (oldProfile != newProfile && newProfile != null)
+                {
+                    UpdatePostProcessOrVolumeProfile();
+                }
+            }
+        }
+
+#if UNITY_POST_PROCESSING_STACK_V2
+        public PostProcessProfile PostProcessProfile { get; private set; }
+        public PostProcessVolume PostProcessVolume { get; private set; }
+#endif
+
+#if POSEIDON_URP
+        public VolumeProfile VolumeProfile { get; private set; }
+        public Volume Volume { get; private set; }
+#endif
+
+        [SerializeField]
+        private Vector3 volumeExtent;
+        public Vector3 VolumeExtent
+        {
+            get
+            {
+                return volumeExtent;
+            }
+            set
+            {
+                Vector3 v = value;
+                //v.x = Mathf.Max(0, v.x);
+                //v.y = Mathf.Max(0, v.y);
+                //v.z = Mathf.Max(0, v.z);
+                volumeExtent = v;
+            }
+        }
+
+        [SerializeField]
+        private LayerMask volumeLayer;
+        public LayerMask VolumeLayer
+        {
+            get
+            {
+                return volumeLayer;
+            }
+            set
+            {
+                volumeLayer = value;
+            }
+        }
+
+        private float lastDistanceToSurface;
+        private float wetLensTime;
+
+        [SerializeField]
+        private UnityEvent onEnterWater;
+        public UnityEvent OnEnterWater
+        {
+            get
+            {
+                return onEnterWater;
+            }
+            set
+            {
+                onEnterWater = value;
+            }
+        }
+
+        [SerializeField]
+        private UnityEvent onExitWater;
+        public UnityEvent OnExitWater
+        {
+            get
+            {
+                return onExitWater;
+            }
+            set
+            {
+                onExitWater = value;
+            }
+        }
+
+        private void Reset()
+        {
+            Water = GetComponent<PWater>();
+#if UNITY_POST_PROCESSING_STACK_V2
+            VolumeExtent = new Vector3(0, 100, 0);
+#endif
+        }
+
+        private void OnEnable()
+        {
+            Camera.onPreCull += OnCameraPreCull;
+            RenderPipelineManager.beginCameraRendering += OnBeginCameraRendering;
+
+            if (Camera.main != null)
+            {
+                float waterHeight = GetWaterHeight(Camera.main.transform.position);
+                lastDistanceToSurface = Camera.main.transform.position.y - waterHeight;
+            }
+
+            wetLensTime = Mathf.Infinity;
+
+            if (PUtilities.IsPlaying)
+            {
+                SetupQuickVolume();
+            }
+        }
+
+        private void OnDisable()
+        {
+            Camera.onPreCull -= OnCameraPreCull;
+            RenderPipelineManager.beginCameraRendering -= OnBeginCameraRendering;
+            CleanupQuickVolume();
+        }
+
+        private void OnBeginCameraRendering(ScriptableRenderContext context, Camera cam)
+        {
+            OnCameraPreCull(cam);
+        }
+
+        private void OnCameraPreCull(Camera cam)
+        {
+            UpdateEffects(cam);
+            if (cam == Camera.main && Water != null)
+            {
+                Vector3 cameraPos = cam.transform.position;
+                float waterHeight = GetWaterHeight(cam.transform.position);
+                float distanceToSuface = cam.transform.position.y - waterHeight;
+                if (distanceToSuface <= 0 && lastDistanceToSurface > 0)
+                {
+                    if (Water.CheckTilesContainPoint(cameraPos))
+                    {
+                        OnEnterWater.Invoke();
+                    }
+                }
+                if (distanceToSuface > 0 && lastDistanceToSurface <= 0)
+                {
+                    if (Water.CheckTilesContainPoint(cameraPos))
+                    {
+                        OnExitWater.Invoke();
+                    }
+                }
+                lastDistanceToSurface = cameraPos.y - waterHeight;
+            }
+        }
+
+        private void SetupQuickVolume()
+        {
+            if (Water == null || Profile == null)
+                return;
+
+            Water.ReCalculateBounds();
+            Bounds bounds = Water.Bounds;
+            GameObject volumeGO = null;
+
+#if UNITY_POST_PROCESSING_STACK_V2
+            if (PCommon.CurrentRenderPipeline == PRenderPipelineType.Builtin)
+            {
+                PostProcessEffectSettings[] settings = new PostProcessEffectSettings[0];
+                PostProcessVolume volume = PostProcessManager.instance.QuickVolume(VolumeLayer, 0, settings);
+                volume.isGlobal = false;
+                volumeGO = volume.gameObject;
+                PostProcessVolume = volume;
+                PostProcessProfile = volume.profile;
+                PostProcessProfile.name = "~TemporaryEffectProfile";
+                Profile.UpdatePostProcessingProfile(PostProcessProfile);
+            }
+#endif
+#if POSEIDON_URP
+            if (PCommon.CurrentRenderPipeline == PRenderPipelineType.Universal)
+            {
+                volumeGO = new GameObject();
+                volumeGO.layer = VolumeLayer;
+                Volume volume = volumeGO.AddComponent<Volume>();
+                volume.isGlobal = false;
+
+                VolumeProfile profile = ScriptableObject.CreateInstance<VolumeProfile>();
+                volume.profile = profile;
+
+                this.Volume = volume;
+                this.VolumeProfile = profile;
+                this.VolumeProfile.name = "~TemporaryEffectProfile";
+                Profile.UpdateVolumeProfile(VolumeProfile);
+            }
+#endif
+
+            volumeGO.hideFlags = HideFlags.DontSave;
+            volumeGO.transform.parent = transform;
+            volumeGO.transform.localPosition = bounds.center;
+            volumeGO.transform.localRotation = Quaternion.identity;
+            volumeGO.transform.localScale = Vector3.one;
+            volumeGO.name = "~WaterPostFXVolume";
+
+            BoxCollider b = volumeGO.AddComponent<BoxCollider>();
+            b.center = new Vector3(0, 0, 0);
+            b.size = bounds.size + VolumeExtent;
+            b.isTrigger = true;
+        }
+
+        private void CleanupQuickVolume()
+        {
+#if UNITY_POST_PROCESSING_STACK_V2
+            if (PostProcessProfile != null)
+            {
+                PUtilities.DestroyObject(PostProcessProfile);
+            }
+            if (PostProcessVolume != null)
+            {
+                PUtilities.DestroyGameobject(PostProcessVolume.gameObject);
+            }
+#endif
+#if POSEIDON_URP
+            if (VolumeProfile != null)
+            {
+                PUtilities.DestroyObject(VolumeProfile);
+            }
+            if (Volume != null)
+            {
+                PUtilities.DestroyGameobject(Volume.gameObject);
+            }
+#endif
+        }
+
+        private void UpdateEffects(Camera cam)
+        {
+            if (cam == null)
+                return;
+            if (cam != Camera.main)
+                return;
+            if (Profile == null)
+                return;
+
+            float waterHeight = GetWaterHeight(cam.transform.position);
+
+            if (Profile.EnableUnderwater)
+            {
+                float intensity = cam.transform.position.y < waterHeight ? 1 : 0;
+                UpdateUnderwaterIntensityAndWaterLevel(intensity, waterHeight);
+            }
+
+            float distanceToSurface = Camera.main.transform.position.y - waterHeight;
+            if (Profile.EnableWetLens)
+            {
+                if (distanceToSurface > 0 && lastDistanceToSurface <= 0)
+                {
+                    wetLensTime = 0;
+                }
+                float intensity;
+                if (distanceToSurface <= 0)
+                {
+                    intensity = 0;
+                }
+                else if (wetLensTime > Profile.WetLensDuration)
+                {
+                    intensity = 0;
+                }
+                else
+                {
+                    float f = Mathf.InverseLerp(0, Profile.WetLensDuration, wetLensTime);
+                    intensity = Profile.WetLensFadeCurve.Evaluate(f);
+                }
+                UpdateWetLensIntensity(intensity);
+            }
+            wetLensTime += PUtilities.DeltaTime;
+        }
+
+        private void UpdateUnderwaterIntensityAndWaterLevel(float intensity, float waterLevel)
+        {
+#if UNITY_POST_PROCESSING_STACK_V2
+            if (PCommon.CurrentRenderPipeline == PRenderPipelineType.Builtin)
+            {
+                if (PostProcessProfile == null)
+                    return;
+                PUnderwater underwaterSettings;
+                if (PostProcessProfile.TryGetSettings<PUnderwater>(out underwaterSettings))
+                {
+                    underwaterSettings.intensity.Override(intensity);
+                    underwaterSettings.waterLevel.Override(waterLevel);
+                }
+            }
+#endif
+
+#if POSEIDON_URP
+            if (PCommon.CurrentRenderPipeline == PRenderPipelineType.Universal)
+            {
+                if (VolumeProfile == null)
+                    return;
+                PUnderwaterOverride underwaterSettigns;
+                if (VolumeProfile.TryGet<PUnderwaterOverride>(out underwaterSettigns))
+                {
+                    underwaterSettigns.intensity.Override(intensity);
+                    underwaterSettigns.waterLevel.Override(waterLevel);
+                }
+            }
+#endif
+        }
+
+        private void UpdateWetLensIntensity(float intensity)
+        {
+#if UNITY_POST_PROCESSING_STACK_V2
+            if (PCommon.CurrentRenderPipeline == PRenderPipelineType.Builtin)
+            {
+                if (PostProcessProfile == null)
+                    return;
+                PWetLens wetlensSettings;
+                if (PostProcessProfile.TryGetSettings<PWetLens>(out wetlensSettings))
+                {
+                    wetlensSettings.intensity.Override(intensity);
+                }
+            }
+#endif
+
+#if POSEIDON_URP
+            if (PCommon.CurrentRenderPipeline == PRenderPipelineType.Universal)
+            {
+                if (VolumeProfile == null)
+                    return;
+                PWetLensOverride wetlensSettings;
+                if (VolumeProfile.TryGet<PWetLensOverride>(out wetlensSettings))
+                {
+                    wetlensSettings.intensity.Override(intensity);
+                }
+            }
+#endif
+        }
+
+        public void UpdatePostProcessOrVolumeProfile()
+        {
+            if (profile == null)
+                return;
+
+#if UNITY_POST_PROCESSING_STACK_V2
+            if (PCommon.CurrentRenderPipeline == PRenderPipelineType.Builtin)
+            {
+                if (PostProcessProfile != null)
+                {
+                    profile.UpdatePostProcessingProfile(PostProcessProfile);
+                }
+            }
+#endif
+#if POSEIDON_URP
+            if (PCommon.CurrentRenderPipeline == PRenderPipelineType.Universal)
+            {
+                if (VolumeProfile != null)
+                {
+                    profile.UpdateVolumeProfile(VolumeProfile);
+                }
+            }
+#endif
+        }
+
+        private float GetWaterHeight(Vector3 worldPos)
+        {
+            if (water == null)
+                return 0;
+            if (water.Profile.EnableWave)
+            {
+                Vector3 localPos = water.transform.InverseTransformPoint(worldPos);
+                localPos.y = 0;
+                localPos = water.GetLocalVertexPosition(localPos, false);
+
+                worldPos = water.transform.TransformPoint(localPos);
+                return worldPos.y;
+            }
+            else
+            {
+                return water.transform.position.y;
+            }
+        }
+    }
+}

Assets/Polaris - Low Poly Ecosystem/Poseidon - Low Poly Water System/Runtime/Scripts/Effects/PWaterFX.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 61bb74f3f8e394c4c93cc61a6c3221bd
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Polaris - Low Poly Ecosystem/Poseidon - Low Poly Water System/Runtime/Scripts/Effects/PWaterFXProfile.cs

@@ -0,0 +1,438 @@
+using UnityEngine;
+using System.Collections;
+using System.Collections.Generic;
+using UnityEngine.Rendering;
+#if UNITY_POST_PROCESSING_STACK_V2
+using Pinwheel.Poseidon.FX.PostProcessing;
+using UnityEngine.Rendering.PostProcessing;
+#endif
+#if UNITY_EDITOR
+using UnityEditor;
+#endif
+#if POSEIDON_URP
+using Pinwheel.Poseidon.FX.Universal;
+#endif
+
+namespace Pinwheel.Poseidon.FX
+{
+    [CreateAssetMenu(menuName = "Poseidon/Water FX Profile")]
+    public class PWaterFXProfile : ScriptableObject
+    {
+        [SerializeField]
+        private bool enableUnderwater;
+        public bool EnableUnderwater
+        {
+            get
+            {
+                return enableUnderwater;
+            }
+            set
+            {
+                enableUnderwater = value;
+            }
+        }
+
+        [SerializeField]
+        private float underwaterMaxDepth;
+        public float UnderwaterMaxDepth
+        {
+            get
+            {
+                return underwaterMaxDepth;
+            }
+            set
+            {
+                underwaterMaxDepth = Mathf.Max(0, value);
+            }
+        }
+
+        [SerializeField]
+        private float underwaterSurfaceColorBoost;
+        public float UnderwaterSurfaceColorBoost
+        {
+            get
+            {
+                return underwaterSurfaceColorBoost;
+            }
+            set
+            {
+                underwaterSurfaceColorBoost = Mathf.Max(0, value);
+            }
+        }
+
+        [SerializeField]
+        private Color underwaterShallowFogColor;
+        public Color UnderwaterShallowFogColor
+        {
+            get
+            {
+                return underwaterShallowFogColor;
+            }
+            set
+            {
+                underwaterShallowFogColor = value;
+            }
+        }
+
+        [SerializeField]
+        private Color underwaterDeepFogColor;
+        public Color UnderwaterDeepFogColor
+        {
+            get
+            {
+                return underwaterDeepFogColor;
+            }
+            set
+            {
+                underwaterDeepFogColor = value;
+            }
+        }
+
+        [SerializeField]
+        private float underwaterViewDistance;
+        public float UnderwaterViewDistance
+        {
+            get
+            {
+                return underwaterViewDistance;
+            }
+            set
+            {
+                underwaterViewDistance = Mathf.Max(0, value);
+            }
+        }
+
+        [SerializeField]
+        private bool underwaterEnableCaustic;
+        public bool UnderwaterEnableCaustic
+        {
+            get
+            {
+                return underwaterEnableCaustic;
+            }
+            set
+            {
+                underwaterEnableCaustic = value;
+            }
+        }
+
+        [SerializeField]
+        private Texture underwaterCausticTexture;
+        public Texture UnderwaterCausticTexture
+        {
+            get
+            {
+                return underwaterCausticTexture;
+            }
+            set
+            {
+                underwaterCausticTexture = value;
+            }
+        }
+
+        [SerializeField]
+        private float underwaterCausticSize;
+        public float UnderwaterCausticSize
+        {
+            get
+            {
+                return underwaterCausticSize;
+            }
+            set
+            {
+                underwaterCausticSize = value;
+            }
+        }
+
+        [SerializeField]
+        private float underwaterCausticStrength;
+        public float UnderwaterCausticStrength
+        {
+            get
+            {
+                return underwaterCausticStrength;
+            }
+            set
+            {
+                underwaterCausticStrength = Mathf.Clamp01(value);
+            }
+        }
+
+        [SerializeField]
+        private bool underwaterEnableDistortion;
+        public bool UnderwaterEnableDistortion
+        {
+            get
+            {
+                return underwaterEnableDistortion;
+            }
+            set
+            {
+                underwaterEnableDistortion = value;
+            }
+        }
+
+        [SerializeField]
+        private Texture underwaterDistortionTexture;
+        public Texture UnderwaterDistortionTexture
+        {
+            get
+            {
+                return underwaterDistortionTexture;
+            }
+            set
+            {
+                underwaterDistortionTexture = value;
+            }
+        }
+
+        [SerializeField]
+        private float underwaterDistortionStrength;
+        public float UnderwaterDistortionStrength
+        {
+            get
+            {
+                return underwaterDistortionStrength;
+            }
+            set
+            {
+                underwaterDistortionStrength = value;
+            }
+        }
+
+        [SerializeField]
+        private float underwaterWaterFlowSpeed;
+        public float UnderwaterWaterFlowSpeed
+        {
+            get
+            {
+                return underwaterWaterFlowSpeed;
+            }
+            set
+            {
+                underwaterWaterFlowSpeed = value;
+            }
+        }
+
+        private float underwaterIntensity;
+        public float UnderwaterIntensity
+        {
+            get
+            {
+                return underwaterIntensity;
+            }
+            set
+            {
+                underwaterIntensity = value;
+            }
+        }
+
+        [SerializeField]
+        private bool enableWetLens;
+        public bool EnableWetLens
+        {
+            get
+            {
+                return enableWetLens;
+            }
+            set
+            {
+                enableWetLens = value;
+            }
+        }
+
+        [SerializeField]
+        private Texture wetLensNormalMap;
+        public Texture WetLensNormalMap
+        {
+            get
+            {
+                return wetLensNormalMap;
+            }
+            set
+            {
+                wetLensNormalMap = value;
+            }
+        }
+
+        [SerializeField]
+        private float wetLensStrength;
+        public float WetLensStrength
+        {
+            get
+            {
+                return wetLensStrength;
+            }
+            set
+            {
+                wetLensStrength = Mathf.Clamp01(value);
+            }
+        }
+
+        private float wetLensIntensity;
+        public float WetLensIntensity
+        {
+            get
+            {
+                return wetLensIntensity;
+            }
+            set
+            {
+                wetLensIntensity = Mathf.Clamp01(value);
+            }
+        }
+
+        [SerializeField]
+        private float wetLensDuration;
+        public float WetLensDuration
+        {
+            get
+            {
+                return wetLensDuration;
+            }
+            set
+            {
+                wetLensDuration = Mathf.Max(0.01f, value);
+            }
+        }
+
+        [SerializeField]
+        private AnimationCurve wetLensFadeCurve;
+        public AnimationCurve WetLensFadeCurve
+        {
+            get
+            {
+                if (wetLensFadeCurve == null)
+                {
+                    wetLensFadeCurve = AnimationCurve.Linear(0, 1, 1, 0);
+                }
+                return wetLensFadeCurve;
+            }
+            set
+            {
+                wetLensFadeCurve = value;
+            }
+        }
+
+        public void Reset()
+        {
+            EnableUnderwater = true;
+            UnderwaterMaxDepth = 10;
+            UnderwaterShallowFogColor = new Color(0, 0, 0, 0.5f);
+            UnderwaterDeepFogColor = new Color(0, 0, 0, 0.95f);
+            UnderwaterViewDistance = 50;
+            UnderwaterEnableCaustic = false;
+            UnderwaterCausticTexture = null;
+            UnderwaterCausticSize = 10;
+            UnderwaterCausticStrength = 1;
+            UnderwaterEnableDistortion = true;
+            UnderwaterDistortionTexture = PPoseidonSettings.Instance.DefaultUnderwaterDistortionMap;
+            UnderwaterDistortionStrength = 0.5f;
+            UnderwaterWaterFlowSpeed = 1;
+
+            EnableWetLens = true;
+            WetLensNormalMap = PPoseidonSettings.Instance.DefaultWetLensDistortionMap;
+            WetLensStrength = 1;
+            WetLensDuration = 3;
+            WetLensFadeCurve = AnimationCurve.Linear(0, 1, 1, 0);
+        }
+
+#if UNITY_POST_PROCESSING_STACK_V2 
+        public void UpdatePostProcessingProfile(PostProcessProfile p)
+        {
+            if (!p.HasSettings<PUnderwater>())
+            {
+                p.AddSettings<PUnderwater>();
+            }
+
+            PUnderwater underwaterSettings = p.GetSetting<PUnderwater>();
+            underwaterSettings.active = EnableUnderwater;
+            underwaterSettings.enabled.Override(EnableUnderwater);
+            if (EnableUnderwater)
+            {
+                underwaterSettings.maxDepth.Override(UnderwaterMaxDepth);
+                underwaterSettings.surfaceColorBoost.Override(UnderwaterSurfaceColorBoost);
+
+                underwaterSettings.shallowFogColor.Override(UnderwaterShallowFogColor);
+                underwaterSettings.deepFogColor.Override(UnderwaterDeepFogColor);
+                underwaterSettings.viewDistance.Override(UnderwaterViewDistance);
+
+                underwaterSettings.enableCaustic.Override(UnderwaterEnableCaustic);
+                underwaterSettings.causticTexture.Override(UnderwaterCausticTexture);
+                underwaterSettings.causticSize.Override(UnderwaterCausticSize);
+                underwaterSettings.causticStrength.Override(UnderwaterCausticStrength);
+
+                underwaterSettings.enableDistortion.Override(UnderwaterEnableDistortion);
+                underwaterSettings.distortionNormalMap.Override(UnderwaterDistortionTexture);
+                underwaterSettings.distortionStrength.Override(UnderwaterDistortionStrength);
+                underwaterSettings.waterFlowSpeed.Override(UnderwaterWaterFlowSpeed);
+            }
+
+            if (!p.HasSettings<PWetLens>())
+            {
+                p.AddSettings<PWetLens>();
+            }
+
+            PWetLens wetLensSettings = p.GetSetting<PWetLens>();
+            wetLensSettings.active = EnableWetLens;
+            wetLensSettings.enabled.Override(EnableWetLens);
+            if (EnableWetLens)
+            {
+                wetLensSettings.normalMap.Override(WetLensNormalMap);
+                wetLensSettings.strength.Override(WetLensStrength);
+            }
+        }
+#endif
+
+#if POSEIDON_URP
+        public void UpdateVolumeProfile(VolumeProfile p)
+        {
+            if (!p.Has<PUnderwaterOverride>())
+            {
+                p.Add<PUnderwaterOverride>();
+            }
+
+            PUnderwaterOverride underwaterSettings;
+            if (p.TryGet<PUnderwaterOverride>(out underwaterSettings))
+            {
+                underwaterSettings.active = EnableUnderwater;
+                if (EnableUnderwater)
+                {
+                    underwaterSettings.maxDepth.Override(UnderwaterMaxDepth);
+                    underwaterSettings.surfaceColorBoost.Override(UnderwaterSurfaceColorBoost);
+
+                    underwaterSettings.shallowFogColor.Override(UnderwaterShallowFogColor);
+                    underwaterSettings.deepFogColor.Override(UnderwaterDeepFogColor);
+                    underwaterSettings.viewDistance.Override(UnderwaterViewDistance);
+
+                    underwaterSettings.enableCaustic.Override(UnderwaterEnableCaustic);
+                    underwaterSettings.causticTexture.Override(UnderwaterCausticTexture);
+                    underwaterSettings.causticSize.Override(UnderwaterCausticSize);
+                    underwaterSettings.causticStrength.Override(UnderwaterCausticStrength);
+
+                    underwaterSettings.enableDistortion.Override(UnderwaterEnableDistortion);
+                    underwaterSettings.distortionNormalMap.Override(UnderwaterDistortionTexture);
+                    underwaterSettings.distortionStrength.Override(UnderwaterDistortionStrength);
+                    underwaterSettings.waterFlowSpeed.Override(UnderwaterWaterFlowSpeed);
+                }
+            }
+
+            if (!p.Has<PWetLensOverride>())
+            {
+                p.Add<PWetLensOverride>();
+            }
+
+            PWetLensOverride wetLensSettings;
+            if (p.TryGet<PWetLensOverride>(out wetLensSettings))
+            {
+                wetLensSettings.active = EnableWetLens;
+                if (EnableWetLens)
+                {
+                    wetLensSettings.normalMap.Override(WetLensNormalMap);
+                    wetLensSettings.strength.Override(WetLensStrength);
+                }
+            }
+        }
+#endif
+    }
+}

Assets/Polaris - Low Poly Ecosystem/Poseidon - Low Poly Water System/Runtime/Scripts/Effects/PWaterFXProfile.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 1198c0a6311ad44408a8d6bd3161243c
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Polaris - Low Poly Ecosystem/Poseidon - Low Poly Water System/Runtime/Scripts/Effects/UniversalRP.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 74b436c737d963648b2e6896d0332e79
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Polaris - Low Poly Ecosystem/Poseidon - Low Poly Water System/Runtime/Scripts/Effects/UniversalRP/PUnderwaterOverride.cs

@@ -0,0 +1,42 @@
+#if POSEIDON_URP
+using UnityEngine;
+using System.Collections;
+using System.Collections.Generic;
+using UnityEngine.Rendering;
+
+namespace Pinwheel.Poseidon.FX.Universal
+{
+    [System.Serializable]
+    [VolumeComponentMenu("Poseidon/Underwater")]
+    public class PUnderwaterOverride : VolumeComponent
+    {
+        [Header("Water Body")]
+        public FloatParameter waterLevel = new FloatParameter(0);
+        public FloatParameter maxDepth = new FloatParameter(10);
+        [Range(0f, 3f)]
+        public FloatParameter surfaceColorBoost = new FloatParameter(1);
+
+        [Header("Fog")]
+        public ColorParameter shallowFogColor = new ColorParameter(new Color(0,0,1,0.5f));
+        public ColorParameter deepFogColor = new ColorParameter(new Color(0,0,1,1));
+        public FloatParameter viewDistance = new FloatParameter(40);
+
+        [Header("Caustic")]
+        public BoolParameter enableCaustic = new BoolParameter(false);
+        public TextureParameter causticTexture = new TextureParameter(null);
+        public FloatParameter causticSize = new FloatParameter(10);
+        [Range(0f, 1f)]
+        public FloatParameter causticStrength = new FloatParameter(1);
+
+        [Header("Distortion")]
+        public BoolParameter enableDistortion = new BoolParameter(false);
+        public TextureParameter distortionNormalMap = new TextureParameter(null);
+        public FloatParameter distortionStrength = new FloatParameter(1);
+        public FloatParameter waterFlowSpeed = new FloatParameter(1);
+
+        [Header("Internal")]
+        [Range(0f, 1f)]
+        public FloatParameter intensity = new FloatParameter(0);
+    }
+}
+#endif

Assets/Polaris - Low Poly Ecosystem/Poseidon - Low Poly Water System/Runtime/Scripts/Effects/UniversalRP/PUnderwaterOverride.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 737bb5c030cbe824a900bc5999ac94f9
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Polaris - Low Poly Ecosystem/Poseidon - Low Poly Water System/Runtime/Scripts/Effects/UniversalRP/PWaterEffectRendererFeature.cs

@@ -0,0 +1,143 @@
+#if POSEIDON_URP
+using UnityEngine;
+using UnityEngine.Rendering;
+using UnityEngine.Rendering.Universal;
+
+namespace Pinwheel.Poseidon.FX.Universal
+{
+    public class PWaterEffectRendererFeature : ScriptableRendererFeature
+    {
+        public class PWaterEffectPass : ScriptableRenderPass
+        {
+            public const string PROFILER_TAG = "Water FX";
+
+            private Material underwaterMaterial;
+            private Material wetLensMaterial;
+
+            private RenderTargetIdentifier cameraTarget;
+            private RenderTargetHandle temporaryRenderTexture;
+
+            public PWaterEffectPass(RenderTargetIdentifier cameraTarget)
+            {
+                this.cameraTarget = cameraTarget;
+                renderPassEvent = RenderPassEvent.AfterRenderingTransparents;
+            }
+
+            public override void Configure(CommandBuffer cmd, RenderTextureDescriptor cameraTextureDescriptor)
+            {
+
+            }
+
+            private void ConfigureMaterial(ref RenderingData renderingData, PUnderwaterOverride underwater, PWetLensOverride wetLens)
+            {
+                if (underwater.intensity.value > 0)
+                {
+                    if (underwaterMaterial == null)
+                    {
+                        Shader shader = PPoseidonSettings.Instance.UnderwaterShaderURP;
+                        underwaterMaterial = CoreUtils.CreateEngineMaterial(shader);
+                    }
+
+                    underwaterMaterial.SetFloat(PMat.PP_WATER_LEVEL, underwater.waterLevel.value);
+                    underwaterMaterial.SetFloat(PMat.PP_MAX_DEPTH, underwater.maxDepth.value);
+                    underwaterMaterial.SetFloat(PMat.PP_SURFACE_COLOR_BOOST, underwater.surfaceColorBoost.value);
+
+                    underwaterMaterial.SetColor(PMat.PP_SHALLOW_FOG_COLOR, underwater.shallowFogColor.value);
+                    underwaterMaterial.SetColor(PMat.PP_DEEP_FOG_COLOR, underwater.deepFogColor.value);
+                    underwaterMaterial.SetFloat(PMat.PP_VIEW_DISTANCE, underwater.viewDistance.value);
+
+                    if (underwater.enableCaustic.value == true)
+                    {
+                        underwaterMaterial.EnableKeyword(PMat.KW_PP_CAUSTIC);
+                        underwaterMaterial.SetTexture(PMat.PP_CAUSTIC_TEX, underwater.causticTexture.value);
+                        underwaterMaterial.SetFloat(PMat.PP_CAUSTIC_SIZE, underwater.causticSize.value);
+                        underwaterMaterial.SetFloat(PMat.PP_CAUSTIC_STRENGTH, underwater.causticStrength.value);
+                    }
+                    else
+                    {
+                        underwaterMaterial.DisableKeyword(PMat.KW_PP_CAUSTIC);
+                    }
+
+                    if (underwater.enableDistortion.value == true)
+                    {
+                        underwaterMaterial.EnableKeyword(PMat.KW_PP_DISTORTION);
+                        underwaterMaterial.SetTexture(PMat.PP_DISTORTION_TEX, underwater.distortionNormalMap.value);
+                        underwaterMaterial.SetFloat(PMat.PP_DISTORTION_STRENGTH, underwater.distortionStrength.value);
+                        underwaterMaterial.SetFloat(PMat.PP_WATER_FLOW_SPEED, underwater.waterFlowSpeed.value);
+                    }
+                    else
+                    {
+                        underwaterMaterial.DisableKeyword(PMat.KW_PP_DISTORTION);
+                    }
+
+                    underwaterMaterial.SetTexture(PMat.PP_NOISE_TEX, PPoseidonSettings.Instance.NoiseTexture);
+                    underwaterMaterial.SetVector(PMat.PP_CAMERA_VIEW_DIR, renderingData.cameraData.camera.transform.forward);
+                    underwaterMaterial.SetFloat(PMat.PP_CAMERA_FOV, renderingData.cameraData.camera.fieldOfView);
+                    underwaterMaterial.SetMatrix(PMat.PP_CAMERA_TO_WORLD_MATRIX, renderingData.cameraData.camera.cameraToWorldMatrix);
+                    underwaterMaterial.SetFloat(PMat.PP_INTENSITY, underwater.intensity.value);
+                }
+
+                if (wetLens.strength.value * wetLens.intensity.value > 0)
+                {
+                    if (wetLensMaterial == null)
+                    {
+                        Shader shader = PPoseidonSettings.Instance.WetLensShaderURP;
+                        wetLensMaterial = CoreUtils.CreateEngineMaterial(shader);
+                    }
+
+                    Texture normalMap = wetLens.normalMap.value ?? PPoseidonSettings.Instance.DefaultNormalMap;
+                    wetLensMaterial.SetTexture(PMat.PP_WET_LENS_TEX, normalMap);
+                    wetLensMaterial.SetFloat(PMat.PP_WET_LENS_STRENGTH, wetLens.strength.value * wetLens.intensity.value);
+                }
+            }
+
+            public override void Execute(ScriptableRenderContext context, ref RenderingData renderingData)
+            {
+                if (renderingData.cameraData.camera != Camera.main)
+                    return;
+
+                VolumeStack stack = VolumeManager.instance.stack;
+                PUnderwaterOverride underwater = stack.GetComponent<PUnderwaterOverride>();
+                PWetLensOverride wetLens = stack.GetComponent<PWetLensOverride>();
+
+                bool willRenderUnderwater = underwater.intensity.value > 0;
+                bool willRenderWetLens = wetLens.strength.value * wetLens.intensity.value > 0;
+                if (!willRenderUnderwater && !willRenderWetLens)
+                    return;
+
+                ConfigureMaterial(ref renderingData, underwater, wetLens);
+
+                CommandBuffer cmd = CommandBufferPool.Get(PROFILER_TAG);
+                RenderTextureDescriptor cameraTargetDescriptor = renderingData.cameraData.cameraTargetDescriptor;
+                cameraTargetDescriptor.depthBufferBits = 0;
+                cmd.GetTemporaryRT(temporaryRenderTexture.id, cameraTargetDescriptor);
+
+                Material material = willRenderUnderwater ? underwaterMaterial : wetLensMaterial;
+                Blit(cmd, cameraTarget, temporaryRenderTexture.Identifier(), material, 0);
+                Blit(cmd, temporaryRenderTexture.Identifier(), cameraTarget);
+
+                context.ExecuteCommandBuffer(cmd);
+                CommandBufferPool.Release(cmd);
+            }
+
+            public override void FrameCleanup(CommandBuffer cmd)
+            {
+                cmd.ReleaseTemporaryRT(temporaryRenderTexture.id);
+            }
+        }
+
+        private PWaterEffectPass waterEffectPass;
+
+        public override void Create()
+        {
+        }
+
+        public override void AddRenderPasses(ScriptableRenderer renderer, ref RenderingData renderingData)
+        {
+            waterEffectPass = new PWaterEffectPass(renderer.cameraColorTarget);
+            renderer.EnqueuePass(waterEffectPass);
+        }
+
+    }
+}
+#endif

Assets/Polaris - Low Poly Ecosystem/Poseidon - Low Poly Water System/Runtime/Scripts/Effects/UniversalRP/PWaterEffectRendererFeature.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 52820e82bff58474cbdc4c685df7f99a
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Polaris - Low Poly Ecosystem/Poseidon - Low Poly Water System/Runtime/Scripts/Effects/UniversalRP/PWetLensOverride.cs

@@ -0,0 +1,23 @@
+#if POSEIDON_URP
+using UnityEngine;
+using System.Collections;
+using System.Collections.Generic;
+using UnityEngine.Rendering;
+
+namespace Pinwheel.Poseidon.FX.Universal
+{
+    [System.Serializable]
+    [VolumeComponentMenu("Poseidon/Wet Lens")]
+    public class PWetLensOverride : VolumeComponent
+    {
+        [Header("Lens Distort")]
+        public TextureParameter normalMap = new TextureParameter(null);
+        [Range(0f, 1f)]
+        public FloatParameter strength = new FloatParameter(1);
+
+        [Header("Internal")]
+        [Range(0f, 1f)]
+        public FloatParameter intensity = new FloatParameter(0);
+    }
+}
+#endif

Assets/Polaris - Low Poly Ecosystem/Poseidon - Low Poly Water System/Runtime/Scripts/Effects/UniversalRP/PWetLensOverride.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 720855a007109dd4190a93defd8e3bb9
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: