// WaterCausticsModules
// Copyright (c) 2021 Masataka Hakozaki

using System.Collections.Generic;
using MH.WaterCausticsModules.TexGen;
using UnityEngine;
using UnityEngine.Rendering;
using UnityEngine.Serialization;

#if UNITY_EDITOR
using UnityEditor;
#endif

namespace MH.WaterCausticsModules {
    namespace TexGen {
        // ----------------------------------------------------------- Enum
        public enum Style { StyleA, StyleB, StyleC, }
        public enum RefractedRay { Normalize, Extend, }
        public enum MSAASamples { None = 1, MSAA2x = 2, MSAA4x = 4, MSAA8x = 8 }
        public enum LightRay { Vector = 0, Transform, LitSettingSun, Auto, Direction, }
        public enum CalcRes { x64 = 64, x96 = 96, x128 = 128, x160 = 160, x256 = 256, x320 = 320, x512 = 512, }
    }

    [ExecuteAlways]
    [HelpURL (Constant.URL_MANUAL)]
    [AddComponentMenu ("WaterCausticsModules/WaterCausticsTexGenerator")]
    public class WaterCausticsTexGenerator : MonoBehaviour {

#if UNITY_2020_3_OR_NEWER
        // ----------------------------------------------------------- Constant
        private const int THREAD_SIZE = 16;
        internal const int WAVE_MAX_CNT = 4;
        readonly private string [] _lcStyleStr = { "STYLE_A", "STYLE_B", "STYLE_C", };
        readonly private float [] _lcStyleBright = { 1f, 1.3f, 1.3f };
        readonly private float [] _lcStyleGamma = { 1f, 1.25f, 1.02f };

        // ----------------------------------------------------------- SerializeField
        [SerializeField] private bool m_generateInEditMode = true;
        [SerializeField] private bool m_animateInEditMode = true;
        [SerializeField] private bool m_pause;
        [SerializeField, Range (0.1f, 3f)] private float m_density = 1f;
        [SerializeField, Range (0f, 4f)] private float m_height = 1f;
        [SerializeField, Range (0f, 4f)] private float m_speed = 1f;
        [SerializeField, Range (0f, 1.5f)] private float m_flow = 0f;
        [SerializeField, Range (-180f, 180f)] private float m_flowDirection = 0f;
        [SerializeField] private List<Wave> m_waves = new List<Wave> () {
            new Wave (7.3f, 0.55f, 0.85f, 0.11f, 100f),
            new Wave (3.7f, 0.4f, 0.55f, 0.2f, -60f)
        };
        [SerializeField] private CalcRes m_calcResolution = CalcRes.x160;
        [SerializeField] private RenderTexture m_renderTexture;
        [FormerlySerializedAs ("m_FillGapAmount")] [SerializeField, Range (0f, 0.5f)] private float m_FillGap = 0.08f;
        [FormerlySerializedAs ("m_lightDirectionType")] [SerializeField] private LightRay m_lightRay = LightRay.Direction;
        [SerializeField] private Transform m_lightTransform;
        [FormerlySerializedAs ("m_lightDir")] [SerializeField] private Vector3 m_lightVector = Vector3.down;
        [SerializeField, Range (-180f, 180f)] private float m_lightDirection = 0f;
        [SerializeField, Range (0f, 90f)] private float m_lightIncidentAngle = 0f;
        [FormerlySerializedAs ("m_lightCondensingStyle")] [SerializeField] private int m_version = Constant.WCE_VERSION_INT;
        [SerializeField] private Style m_style = Style.StyleA;
        [FormerlySerializedAs ("m_rayStyle")] [SerializeField] private RefractedRay m_refractedRay = RefractedRay.Normalize;
        [SerializeField, Range (0f, 3f)] private float m_brightness = 1f;
        [SerializeField, Range (0.0001f, 2f)] private float m_gamma = 1f;
        [SerializeField, Range (0f, 3f)] private float m_clamp = 1f;
        [Range (1f, 3f), SerializeField] private float m_refractionIndex = 1.33f;
        [SerializeField] private bool m_useChromaticAberration = false;
        [Range (0f, 0.3f), SerializeField] private float m_chromaticAberration = 0.005f;
        [SerializeField] private bool m_usePostProcessing = true;
        [SerializeField] private bool m_useBlur = true;
        [SerializeField, Range (1, 20)] private int m_blurIterations = 1;
        [SerializeField, Range (0f, 1f)] private float m_blurSpread = 0.5f;
        [SerializeField] private MSAASamples m_msaa = MSAASamples.MSAA8x;
        [SerializeField, Range (0f, 1f)] private float m_blurDirectional = 0f;
        [SerializeField, Range (-180f, 180f)] private float m_blurDirection = 0f;
        [SerializeField, Range (0f, 3f)] private float m_colorShift = 0f;
        [SerializeField, Range (-180f, 180f)] private float m_colorShiftDir = 0f;
        [SerializeField] private bool m_useSyncDirection = true;
        [SerializeField, Range (0f, 2f)] private float m_postBrightness = 1f;
        [SerializeField, Range (0.0001f, 2f)] private float m_postContrast = 1f;
        [SerializeField] private ComputeShader m_computeShader;
        [SerializeField] private Shader m_shader;
#if WCE_DEVELOPMENT
        [SerializeField] private bool m_useSpecifiedTime;
        [SerializeField] private float m_specifiedTime;
        [SerializeField, Range (0f, 1f)] private float m_specifiedTimeMultiplier = 0.05f;
#endif

        // ----------------------------------------------------------- private property
        private bool useChromAbe => (m_useChromaticAberration && m_chromaticAberration > 0f);
        private int bufSize3or1 => useChromAbe? 3 : 1;

        // ----------------------------------------------------------- Public property
        public bool generateInEditMode {
            get => m_generateInEditMode;
            set => m_generateInEditMode = value;
        }
        public bool animateInEditMode {
            get => m_animateInEditMode;
            set => m_animateInEditMode = value;
        }
        public bool pause {
            get => m_pause;
            set => m_pause = value;
        }
        public float density {
            get => m_density;
            set => m_density = Mathf.Clamp (value, 0.1f, 4f);
        }
        public float height {
            get => m_height;
            set => m_height = Mathf.Max (value, 0f);
        }
        public float speed {
            get => m_speed;
            set => m_speed = Mathf.Max (value, 0f);
        }
        public float flow {
            get => m_flow;
            set => m_flow = value;
        }
        public float flowDirection {
            get => m_flowDirection;
            set => m_flowDirection = wrapAngle180 (value);
        }
        public List<Wave> waves {
            get => m_waves;
        }
        public CalcRes calculateResolution {
            get => m_calcResolution;
            set => m_calcResolution = value;
        }
        public RenderTexture renderTexture {
            get => m_renderTexture;
            set => m_renderTexture = value;
        }
        public float fillGapAmount {
            get => m_FillGap;
            set => m_FillGap = Mathf.Clamp (value, 0f, 0.5f);
        }
        public LightRay lightRayType {
            get => m_lightRay;
            set => m_lightRay = value;
        }
        public Transform lightTransform {
            get => m_lightTransform;
            set => m_lightTransform = value;
        }
        public Vector3 lightVector {
            get => m_lightVector;
            set => m_lightVector = value;
        }
        public float lightDirection {
            get => m_lightDirection;
            set => syncDir (ref m_lightDirection, value);
        }
        public float lightIncidentAngle {
            get => m_lightIncidentAngle;
            set => m_lightIncidentAngle = Mathf.Clamp (value, 0f, 90f);
        }
        public Style style {
            get => m_style;
            set => m_style = value;
        }
        public RefractedRay refractedRayProcessing {
            get => m_refractedRay;
            set => m_refractedRay = value;
        }
        public float brightness {
            get => m_brightness;
            set => m_brightness = Mathf.Max (value, 0f);
        }
        public float gamma {
            get => m_gamma;
            set => m_gamma = Mathf.Max (value, 0.0001f);
        }
        public float clamp {
            get => m_clamp;
            set => m_clamp = Mathf.Max (value, 0f);
        }
        public float refractionIndex {
            get => m_refractionIndex;
            set => m_refractionIndex = Mathf.Clamp (value, 1f, 3f);
        }
        public bool useChromaticAberration {
            get => m_useChromaticAberration;
            set => m_useChromaticAberration = value;
        }
        public float chromaticAberration {
            get => m_chromaticAberration;
            set => m_chromaticAberration = Mathf.Clamp (value, 0f, 0.5f);
        }
        public bool usePostProcessing {
            get => m_usePostProcessing;
            set => m_usePostProcessing = value;
        }
        public bool useBlur {
            get => m_useBlur;
            set => m_useBlur = value;
        }
        public int blurIterations {
            get => m_blurIterations;
            set => m_blurIterations = Mathf.Clamp (value, 1, 10);
        }
        public float blurSpread {
            get => m_blurSpread;
            set => m_blurSpread = Mathf.Clamp (value, 0f, 1f);
        }
        public MSAASamples msaa {
            get => m_msaa;
            set => m_msaa = value;
        }
        public float blurDirectional {
            get => m_blurDirectional;
            set => m_blurDirectional = Mathf.Clamp (value, 0f, 1f);
        }
        public float blurDirection {
            get => m_blurDirection;
            set => syncDir (ref m_blurDirection, value);
        }
        public float colorShift {
            get => m_colorShift;
            set => m_colorShift = Mathf.Max (value, 0f);
        }
        public float colorShiftDirection {
            get => m_colorShiftDir;
            set => syncDir (ref m_colorShiftDir, value);
        }

        public bool useSyncDirection {
            get => m_useSyncDirection;
            set {
                m_useSyncDirection = value;
                if (value) m_blurDirection = m_colorShiftDir = m_lightDirection;
            }
        }
        public float postContrast {
            get => m_postContrast;
            set => m_postContrast = Mathf.Max (value, 0.0001f);
        }
        public float postBrightness {
            get => m_postBrightness;
            set => m_postBrightness = Mathf.Max (value, 0f);
        }

        // ----------------------------------------------------------- Tools
        private void syncDir (ref float prop, float dir) {
            if (m_useSyncDirection)
                m_lightDirection = m_blurDirection = m_colorShiftDir = wrapAngle180 (dir);
            else
                prop = wrapAngle180 (dir);
        }
        static private float round2Dec (float val) => (float) (System.Math.Round (val * 100f) * 0.01); // 小数点2位で丸め
        static private float round2Dec5 (float val) => (float) (System.Math.Round (val * 20f) * 0.05); // 小数点2位を0か5で丸め
        static private float wrapAngle180 (float angle) => Mathf.Repeat (angle + 180f, 360f) - 180f;
        static private Vector2 dirToVec (float dir) => new Vector2 (Mathf.Sin (dir * Mathf.Deg2Rad), Mathf.Cos (-dir * Mathf.Deg2Rad));
        static private float vecToDir (Vector2 v) => round2Dec5 (wrapAngle180 (Mathf.Atan2 (v.x, v.y) * Mathf.Rad2Deg));

        // ----------------------------------------------------------- MenuItem
#if UNITY_EDITOR
        [ContextMenu ("Apply Overall Wave Adjustment To Each Waves")]
        private void ApplyOverallWaveAdjustment () {
            Undo.RecordObject (this, "WCEffect Version Update");
            EditorUtility.SetDirty (this);
            foreach (var wave in m_waves) {
                wave.density = round2Dec5 (wave.density * m_density);
                wave.height = round2Dec5 (wave.height * m_height);
                wave.fluctuation = round2Dec5 (wave.fluctuation * m_speed);
                wave.flow = round2Dec (wave.flow / m_density * m_speed);
            }
            m_density = 1f;
            m_height = 1f;
            m_speed = 1f;
        }

        [ContextMenu ("Open Asset Manual")]
        private void OpenManualURL () {
            Application.OpenURL (Constant.URL_MANUAL);
        }
#endif

        // ----------------------------------------------------------- Init
        private void Reset () { }

        internal void VersionCheck () {
#if UNITY_EDITOR
            if (m_version < Constant.WCE_VERSION_INT) EditorUtility.SetDirty (this);
#endif
            const int VER_20000 = 20000;
            if (m_version < VER_20000) {
                // -- Ver1.2.2以前に作成されている場合、データをv2用にアップデート
                m_style = (Style) m_version; // m_version は元 m_lightCondensingStyle
                if (m_lightRay == LightRay.Vector && m_lightVector == Vector3.down) {
                    m_lightRay = LightRay.Direction;
                    m_lightIncidentAngle = 0f;
                }
                foreach (var w in m_waves)
                    w.renewFlowData (m_density);
                m_usePostProcessing = false;
                m_version = VER_20000; // ※最後に設定
            }
            if (m_version < Constant.WCE_VERSION_INT)
                m_version = Constant.WCE_VERSION_INT;
        }

#if UNITY_EDITOR
        internal void CheckRenderTex () {
            var rt = m_renderTexture;
            if (rt && rt.depth != 0) {
                if (rt.IsCreated ()) {
                    bool isActive = (RenderTexture.active == rt);
                    if (isActive) RenderTexture.active = null;
                    rt.Release ();
                    rt.depth = 0;
                    rt.anisoLevel = 4;
                    rt.Create ();
                    if (isActive) RenderTexture.active = rt;
                } else {
                    rt.depth = 0;
                    rt.anisoLevel = 4;
                }
                EditorUtility.SetDirty (rt);
                Debug.Log ($"DepthBuffer of RenderTexture ({rt.name}) in use in WaterCausticsTexGenerator has been removed as it is not used.");
            }
        }
#endif

        // -----------------------------------------------------------

        private void Awake () {
            VersionCheck ();
            storeSystemMaxMSAA ();
        }

        private void OnEnable () {
#if UNITY_EDITOR
            UnityEditor.EditorApplication.update -= constantUpdate;
            UnityEditor.EditorApplication.update += constantUpdate;
            CheckRenderTex ();
#endif
        }

        private void OnDisable () {
#if UNITY_EDITOR
            UnityEditor.EditorApplication.update -= constantUpdate;
#endif
            if (!Application.isPlaying)
                destroyAllBuffers ();
        }

        void OnDestroy () {
            destroyAllBuffers ();
        }

        private void destroyAllBuffers () {
            releaseGraphicsBuffers ();
            destroy (ref __mesh);
            destroy (ref __mat);
            destroy (ref __computeShader);
        }

        private void destroy<T> (ref T o) where T : Object {
            if (o == null) return;
            if (Application.isPlaying)
                Destroy (o);
            else
                DestroyImmediate (o);
            o = null;
        }

        // ----------------------------------------------------------- PropertyToID
        private class pID {
            readonly internal static int _WaveCnt = Shader.PropertyToID ("_WaveCnt");
            readonly internal static int _WaveData = Shader.PropertyToID ("_WaveData");
            readonly internal static int _WaveUVShift = Shader.PropertyToID ("_WaveUVShift");
            readonly internal static int _WaveNoiseDir = Shader.PropertyToID ("_WaveNoiseDir");
            readonly internal static int _CalcResUI = Shader.PropertyToID ("_CalcResUI");
            readonly internal static int _CalcTexel = Shader.PropertyToID ("_CalcTexel");
            readonly internal static int _CalcTexelInv = Shader.PropertyToID ("_CalcTexelInv");
            readonly internal static int _LightDir = Shader.PropertyToID ("_LightDir");
            readonly internal static int _Eta = Shader.PropertyToID ("_Eta");
            readonly internal static int _Brightness = Shader.PropertyToID ("_Brightness");
            readonly internal static int _Gamma = Shader.PropertyToID ("_Gamma");
            readonly internal static int _Clamp = Shader.PropertyToID ("_Clamp");
            readonly internal static int _IdxStride = Shader.PropertyToID ("_IdxStride");
            readonly internal static int _DrawOffset = Shader.PropertyToID ("_DrawOffset");
            readonly internal static int _BufNoiseRW = Shader.PropertyToID ("_BufNoiseRW");
            readonly internal static int _BufNoise = Shader.PropertyToID ("_BufNoise");
            readonly internal static int _BufRefractRW = Shader.PropertyToID ("_BufRefractRW");
            readonly internal static int _BufRefract = Shader.PropertyToID ("_BufRefract");
            readonly internal static int _LightDirection = Shader.PropertyToID ("_LightDirection");
            readonly internal static int _Offset = Shader.PropertyToID ("_Offset");
            readonly internal static int _OffsetColor = Shader.PropertyToID ("_OffsetColor");
            readonly internal static int _SSLinearTex = Shader.PropertyToID ("_SSLinearTex");
        }

        // ----------------------------------------------------------- ComputeShader
        private ComputeShader __computeShader;
        private ComputeShader getComputeShader () {
            if (__computeShader != null)
                return __computeShader;

            if (m_computeShader == null) {
                Debug.LogError ("Compute Shader is null. " + this);
                return null;
            } else {
                __computeShader = (ComputeShader) Instantiate (m_computeShader);
                kID.setKernelID (__computeShader);
                return __computeShader;
            }
        }

        private class kID {
            internal static int NoiseCS;
            internal static int RefractCS;
            internal static int ColorCS;
            internal static void setKernelID (ComputeShader cs) {
                NoiseCS = cs.FindKernel ("NoiseCS");
                RefractCS = cs.FindKernel ("RefractCS");
                ColorCS = cs.FindKernel ("ColorCS");
            }
        }

        // ----------------------------------------------------------- Material
        private Material __mat;
        private Material getMat () {
            if (__mat != null) return __mat;
            if (m_shader == null) {
                Debug.LogError ("Shader is null. " + this);
                return null;
            } else {
                __mat = new Material (m_shader);
                __mat.hideFlags = HideFlags.HideAndDontSave;
                return __mat;
            }
        }

        private void setMaterialKeyword (Material mat, bool isEnable, string keyword) {
            if (isEnable)
                mat.EnableKeyword (keyword);
            else
                mat.DisableKeyword (keyword);
        }

        // ----------------------------------------------------------- Mesh
        private Mesh __mesh;
        private int _meshVertsCnt;
        private int calcVerticesCnt (int res) {
            int wholeWidth = (int) res + (int) ((float) res * m_FillGap) * 2;
            return (wholeWidth + 1) * (wholeWidth + 1) * bufSize3or1;
        }
        private Mesh getMesh () {
            if (!__mesh || _meshVertsCnt != calcVerticesCnt ((int) m_calcResolution))
                setupMesh ();
            return __mesh;
        }

        private void setupMesh () {
            int width = (int) m_calcResolution;
            float widthF = (float) width;
            int bufArea = width * width;
            float cellSz = 1f / widthF;
            int over = (int) (widthF * m_FillGap);
            int wholeWidth = width + over * 2;
            int bufSz3or1 = bufSize3or1;
            int verticesCnt = (wholeWidth + 1) * (wholeWidth + 1) * bufSz3or1;
            Vector3 [] vertices = new Vector3 [verticesCnt];
            for (int vi = 0, i = 0; i < bufSz3or1; i++) {
                for (int y = 0; y <= wholeWidth; y++) {
                    for (int x = 0; x <= wholeWidth; x++, vi++) {
                        int pX = x - over;
                        int pY = y - over;
                        float vX = (float) pX * cellSz;
                        float vY = (float) pY * cellSz;
                        int idx = ((pY + width * 10) % width) * width + ((pX + width * 10) % width);
                        float vZ = (float) (i * bufArea + idx) + 0.1f;
                        vertices [vi] = new Vector3 (vX * 2f - 1f, vY * 2f - 1f, vZ);
                    }
                }
            }
            int [] triangles = new int [wholeWidth * wholeWidth * 6 * bufSz3or1];
            for (int ti = 0, vi = 0, i = 0; i < bufSz3or1; i++, vi += wholeWidth + 1) {
                for (int y = 0; y < wholeWidth; y++, vi++) {
                    for (int x = 0; x < wholeWidth; x++, ti += 6, vi++) {
                        triangles [ti] = vi;
                        triangles [ti + 2] = triangles [ti + 3] = vi + 1;
                        triangles [ti + 1] = triangles [ti + 4] = vi + wholeWidth + 1;
                        triangles [ti + 5] = vi + wholeWidth + 2;
                    }
                }
            }
            if (__mesh == null)
                __mesh = new Mesh ();
            __mesh.Clear ();
            __mesh.indexFormat = (verticesCnt >= 65536) ? IndexFormat.UInt32 : IndexFormat.UInt16;
            __mesh.vertices = vertices;
            __mesh.triangles = triangles;
            __mesh.name = "WaterCausticsTexGen";
            _meshVertsCnt = verticesCnt;
        }

        // ----------------------------------------------------------- GraphicsBuffer
        private GraphicsBuffer _bufNoise;
        private GraphicsBuffer _bufRefract;
        void prepGraphicsBuffers () {
            int res = (int) m_calcResolution;
            int resSq = res * res;
            checkAndRemakeCBuffer (ref _bufNoise, resSq, 1);
            checkAndRemakeCBuffer (ref _bufRefract, resSq * bufSize3or1, 5);
        }

        private void checkAndRemakeCBuffer (ref GraphicsBuffer buf, int count, int stride) {
            if (buf == null || buf.count != count) {
                if (buf != null) buf.Release ();
                buf = new GraphicsBuffer (GraphicsBuffer.Target.Structured, count, sizeof (float) * stride);
            }
        }

        private void releaseGraphicsBuffers () {
            release (ref _bufNoise);
            release (ref _bufRefract);
        }

        private void release (ref GraphicsBuffer cb) {
            if (cb == null) return;
            cb.Release ();
            cb = null;
        }

        // ----------------------------------------------------------- Preview
#if UNITY_EDITOR
        private bool _isPreviewTarget;
        internal void Preview (float deltaTime, RenderTexture rt) {
            _isPreviewTarget = true;
            if (isActiveAndEnabled && isDrawer (this))
                Graphics.Blit (m_renderTexture, rt);
            else {
                generate (deltaTime, rt);
            }
        }

        internal void FinishPreview () {
            _isPreviewTarget = false;
            if (!isActiveAndEnabled)
                destroyAllBuffers ();
        }
#endif

        // ----------------------------------------------------------- Update
        static private Dictionary<RenderTexture, WaterCausticsTexGenerator> s_drawer = new Dictionary<RenderTexture, WaterCausticsTexGenerator> ();
        static private bool isDrawer (WaterCausticsTexGenerator texGen) {
            var rt = texGen.m_renderTexture;
            return (rt != null && s_drawer.ContainsKey (rt) && s_drawer [rt] == texGen);
        }


#if UNITY_EDITOR
        private bool needAnimInEditMode => ((m_animateInEditMode && m_generateInEditMode) || _isPreviewTarget);
        private void constantUpdate () {
            if (!UnityEditorInternal.InternalEditorUtility.isApplicationActive) return;
            if (Application.isPlaying) return;
            if (needAnimInEditMode) {
                EditorApplication.QueuePlayerLoopUpdate ();
                // UnityEditorInternal.InternalEditorUtility.RepaintAllViews ();
            }
        }
#endif


        void Update () {
#if UNITY_EDITOR
            if (!Application.isPlaying && !m_generateInEditMode && !_isPreviewTarget) return;
#endif
            if (m_renderTexture)
                s_drawer [m_renderTexture] = this;
        }


        private void LateUpdate () {
            if (!isDrawer (this)) return;
#if UNITY_EDITOR
            float deltaTime = (Application.isPlaying || needAnimInEditMode) ? Time.deltaTime : 0f;
            generate (deltaTime, m_renderTexture);
#else
            generate (Time.deltaTime, m_renderTexture);
#endif         
        }


        private void generate (float deltaTime, RenderTexture rt) {
            if (rt == null) return;

            // Prepare
            prepGraphicsBuffers ();

            // Set data for compute shader 
            setConstantBuffer (deltaTime);

            // Compute shader
            calcComputeShader ();

            // Draw mesh
            if (m_usePostProcessing) {
                var baseRT = getPPTmpRT (rt, useMSAA : true);
                drawMesh (baseRT);
                postProcessing (baseRT, rt);
            } else {
                drawMesh (rt);
            }

            // MipMap
            if (rt.useMipMap && rt.antiAliasing == 1 && !rt.autoGenerateMips)
                rt.GenerateMips ();
        }


        Vector3 refract (Vector3 I, float eta) {
            float dot = -I.z;
            float k = 1f - eta * eta * (1f - dot * dot);
            return (k < 0f) ? Vector3.zero : eta * I + Vector3.forward * (eta * dot + Mathf.Sqrt (k));
        }


        private Vector4 [] _tmpDataAry = new Vector4 [WAVE_MAX_CNT];
        private Vector4 [] _tmpUVAry = new Vector4 [WAVE_MAX_CNT];
        private Vector4 [] _tmpDirAry = new Vector4 [WAVE_MAX_CNT];


        private float getDecimal (float v) {
            return v - Mathf.Floor (v);
        }

        const float NOISE_RADIUS = 100f;
        const float NOISE_CIRCUMFERENCE_INV = 1f / (NOISE_RADIUS * 2f * Mathf.PI);

        private void setConstantBuffer (float delteTime) {
            var cs = getComputeShader ();
            if (cs == null) return;

            // Waves
            int waveIdx = 0;
            float delta = delteTime * m_speed * (m_pause? 0f : 1f);
#if WCE_DEVELOPMENT
            if (m_useSpecifiedTime) {
                foreach (Wave w in m_waves)
                    w.pos = Vector3.zero;
                delta = m_specifiedTime * m_specifiedTimeMultiplier;
            }
#endif
            Vector2 overallFlow = dirToVec (m_flowDirection) * m_flow * delta;
            for (int i = 0; i < m_waves.Count; i++) {
                Wave w = m_waves [i];
                if (!w.active) continue;
                Vector2 flowV = dirToVec (w.direction) * w.flow * delta / m_density + overallFlow;
                w.pos.x = getDecimal (w.pos.x - flowV.x);
                w.pos.y = getDecimal (w.pos.y - flowV.y);
                w.pos.z = getDecimal (w.pos.z + w.fluctuation * NOISE_CIRCUMFERENCE_INV * delta);
                float rad = w.pos.z * Mathf.PI * 2f;
                float cos = Mathf.Cos (rad);
                float sin = Mathf.Sin (rad);
                _tmpDirAry [waveIdx] = new Vector2 (cos, sin);
                _tmpUVAry [waveIdx] = new Vector2 (w.pos.x, w.pos.y);
                _tmpDataAry [waveIdx] = w.getData (m_density, m_height, i);
                if (++waveIdx >= WAVE_MAX_CNT) break;
            }
            cs.SetInt (pID._WaveCnt, waveIdx);
            cs.SetVectorArray (pID._WaveData, _tmpDataAry);
            cs.SetVectorArray (pID._WaveUVShift, _tmpUVAry);
            cs.SetVectorArray (pID._WaveNoiseDir, _tmpDirAry);

            // Resolution
            int calcRes = (int) m_calcResolution;
            float texel = 1f / (float) calcRes;
            cs.SetFloat (pID._CalcTexel, texel);
            cs.SetFloat (pID._CalcTexelInv, (float) calcRes);
            cs.SetInt (pID._CalcResUI, calcRes);
            cs.SetInt (pID._IdxStride, calcRes * calcRes);

            // light Direction
            Vector3 litDir;
            switch (m_lightRay) {
                case LightRay.Vector:
                    litDir = (m_lightVector != Vector3.zero) ? m_lightVector.normalized : Vector3.down;
                    break;
                case LightRay.Transform:
                    litDir = (m_lightTransform != null) ? m_lightTransform.forward : Vector3.down;
                    break;
                case LightRay.LitSettingSun:
                    litDir = (RenderSettings.sun != null) ? RenderSettings.sun.transform.forward : Vector3.down;
                    break;
                case LightRay.Auto:
                    litDir = -Shader.GetGlobalVector (pID._LightDirection);
                    break;
                case LightRay.Direction:
                default:
                    if (m_lightIncidentAngle == 0f) {
                        litDir = Vector3.down;
                    } else {
                        Vector2 dirV = dirToVec (m_lightDirection);
                        litDir = Vector3.Slerp (Vector3.down, new Vector3 (dirV.x, 0f, dirV.y), m_lightIncidentAngle / 90f);
                    }
                    break;
            }
            if (litDir.y >= 0f) {
                litDir.y = -0.01f;
                litDir = litDir.normalized;
            }
            litDir = new Vector3 (litDir.x, litDir.z, -litDir.y);
            cs.SetVector (pID._LightDir, litDir);

            // Brightness
            cs.SetFloat (pID._Brightness, m_brightness * _lcStyleBright [(int) m_style] * 0.1f);
            cs.SetFloat (pID._Gamma, m_gamma * _lcStyleGamma [(int) m_style]);
            cs.SetFloat (pID._Clamp, m_clamp);

            // Refraction index
            float eta = 1f / m_refractionIndex;
            float chrAb = 1f + m_chromaticAberration;
            Vector3 refractIdx = new Vector3 (eta * chrAb, eta, eta / chrAb);
            cs.SetVector (pID._Eta, refractIdx);

            // Offset drawing position
            Vector3 refractG = refract (litDir, eta);
            if (m_refractedRay == RefractedRay.Normalize) {
                cs.DisableKeyword ("EXTEND_RAY");
                cs.SetVector (pID._DrawOffset, -(Vector2) refractG);
            } else {
                cs.EnableKeyword ("EXTEND_RAY");
                cs.SetVector (pID._DrawOffset, -(Vector2) refractG / refractG.z);
            }
        }


        private void calcComputeShader () {
            var cs = getComputeShader ();
            if (cs == null) return;

            cs.EnableKeyword (_lcStyleStr [(int) m_style]);

            int kernel;
            int sc = (int) m_calcResolution / THREAD_SIZE;
            int shift = useChromAbe ? 1 : 0;

            cs.SetBuffer (kID.NoiseCS, pID._BufNoiseRW, _bufNoise);
            cs.Dispatch (kID.NoiseCS, sc, sc, 1);

            kernel = kID.RefractCS + shift;
            cs.SetBuffer (kernel, pID._BufNoise, _bufNoise);
            cs.SetBuffer (kernel, pID._BufRefractRW, _bufRefract);
            cs.Dispatch (kernel, sc, sc, 1);

            kernel = kID.ColorCS + shift;
            cs.SetBuffer (kernel, pID._BufRefractRW, _bufRefract);
            cs.Dispatch (kernel, sc, sc, 1);

            // // ---- for Debug
            // cs.SetBuffer (kID.ColorCS + 2, pID._BufNoise, _bufNoise);
            // cs.SetBuffer (kID.ColorCS + 2, pID._BufRefractRW, _bufRefract);
            // cs.Dispatch (kID.ColorCS + 2, sc, sc, 1);
            // // ----

            // Keywords
            cs.DisableKeyword (_lcStyleStr [(int) m_style]);
        }


        private void drawMesh (RenderTexture rt) {
            var mat = getMat ();
            if (mat == null) return;

            var temp = RenderTexture.active;
            RenderTexture.active = rt;
            rt.DiscardContents ();
            GL.Clear (false, true, Color.clear);
            setMaterialKeyword (mat, useChromAbe, "_USE_RGB");
            mat.SetBuffer (pID._BufRefract, _bufRefract);
            mat.SetPass (0);
            Graphics.DrawMeshNow (getMesh (), Matrix4x4.identity);
            RenderTexture.active = temp;

            rt.IncrementUpdateCount ();
        }


        // ----------------------------------------------------------- PostProcessing
        private int _sysMaxMSAA = 8;
        private void storeSystemMaxMSAA () {
            var desc = new RenderTextureDescriptor (128, 128);
            desc.msaaSamples = 8;
            _sysMaxMSAA = SystemInfo.GetRenderTextureSupportedMSAASampleCount (desc);
        }

        private RenderTexture getPPTmpRT (RenderTexture rt, bool useMSAA) {
            var desc = new RenderTextureDescriptor (rt.width, rt.height, rt.graphicsFormat, 0); // rt.formatだとSNORMテクスチャでエラー
            desc.useDynamicScale = rt.useDynamicScale;
            desc.msaaSamples = useMSAA ? Mathf.Min ((int) m_msaa, _sysMaxMSAA) : 1;
            return RenderTexture.GetTemporary (desc);
        }

        private void postProcessing (RenderTexture src, RenderTexture dst) {
#if !UNITY_EDITOR // GLES3でアーティファクトが発生するので対応
            if (dst.antiAliasing > 1) {
                dst.Release ();
                dst.antiAliasing = 1;
            }
#endif
            Vector4 offsetBaseV;
            int iteration = m_useBlur ? m_blurIterations : 1;
            float spread = m_useBlur ? m_blurSpread : 0f;
            bool useBlur = m_useBlur && (iteration > 1 || spread > 0f);
            if (useBlur && m_blurDirectional > 0f) {
                var rot = Quaternion.Euler (0f, 0f, m_blurDirection - 90f);
                var rotInv = Quaternion.Inverse (rot);
                Vector2 offA = rot * Vector2.one;
                Vector2 offB = rot * new Vector2 (1f, -1f);
                float oblateness = 1f - m_blurDirectional;
                offA.y *= oblateness;
                offB.y *= oblateness;
                offA = rotInv * offA;
                offB = rotInv * offB;
                offsetBaseV = new Vector4 (offA.x, offA.y, offB.x, offB.y);
            } else {
                offsetBaseV = new Vector4 (1f, 1f, 1f, -1f);
            }

            var mat = getMat ();
            setMaterialKeyword (mat, useChromAbe, "_USE_RGB");
            mat.SetVector (pID._OffsetColor, Vector2.zero);
            float colShift = 1f;
            bool useColAdjust = (m_postContrast != 1f || m_postBrightness != 1f || QualitySettings.activeColorSpace != ColorSpace.Linear);
            setMaterialKeyword (mat, false, "_BRIGHTNESS_ADJ");

            var temp = RenderTexture.active;
            RenderTexture.active = dst; // ← エディタでGLES3使用時 DstがMSAA使用の場合必須
            RenderTexture buf = src;

            void sampling (RenderTexture src, RenderTexture dst, Vector4 offV, bool useColorShift = false) {
                bool canDiv (float v) { return 0.5f - Mathf.Abs (v - Mathf.Floor (v) - 0.5f) <= 0.001f; }
                src.filterMode = (!useColorShift && canDiv (offV.x) && canDiv (offV.y) && canDiv (offV.z) && canDiv (offV.w)) ? FilterMode.Point : FilterMode.Bilinear;
                src.wrapMode = TextureWrapMode.Repeat;
                mat.SetVector (pID._Offset, offV);
                Graphics.Blit (src, dst, mat, 1);
            }

            for (int i = 0; i < Mathf.Max (1, iteration); i++) {
                bool isLast = (i == iteration - 1);
                RenderTexture buf2 = isLast ? dst : getPPTmpRT (dst, useMSAA : false);
                float off = (iteration == 1) ? spread : 0.5f + i * spread;
                colShift += off * 0.25f;
                setMaterialKeyword (mat, off != 0f, "_SAMPLE4");
                if (isLast && useColAdjust) {
                    setMaterialKeyword (mat, true, "_BRIGHTNESS_ADJ");
                    mat.SetFloat (pID._Gamma, m_postContrast * (QualitySettings.activeColorSpace == ColorSpace.Gamma ? 1f / 2.2f : 1f));
                    mat.SetFloat (pID._Brightness, m_postBrightness * m_postContrast);
                }
                if (isLast && m_colorShift > 0f) {
                    Vector2 offCol = dirToVec (m_colorShiftDir) * (m_colorShift * colShift);
                    setMaterialKeyword (mat, true, "_USE_RGB");
                    mat.SetVector (pID._OffsetColor, offCol * 0.01f);
                    sampling (buf, buf2, offsetBaseV * off, true);
                } else {
                    sampling (buf, buf2, offsetBaseV * off);
                }
                RenderTexture.ReleaseTemporary (buf);
                buf = buf2;
            }

            dst.IncrementUpdateCount ();
            RenderTexture.active = temp;
        }


        // ----------------------------------------------------------- Wave class
        [System.Serializable]
        public class Wave {
            [SerializeField, FormerlySerializedAs ("Active")] private bool m_active = true;
            [SerializeField, Range (1f, 20f)] private float m_density = 3f;
            [SerializeField, Range (0f, 1f)] private float m_height = 0.5f;
            [SerializeField, Range (0f, 4f)] private float m_fluctuation = 0.6f;
            [SerializeField, Range (0f, 1.5f)] private float m_flow;
            [SerializeField, Range (-180f, 180f)] private float m_direction;
            [SerializeField, HideInInspector] private bool Pause; // Legacy
            [SerializeField, HideInInspector] private float m_flowU; // Legacy
            [SerializeField, HideInInspector] private float m_flowV; // Legacy

            public bool active {
                get => m_active;
                set => m_active = value;
            }
            public float density {
                get => m_density;
                set => m_density = Mathf.Clamp (value, 1f, 20f);
            }
            public float height {
                get => m_height;
                set => m_height = Mathf.Clamp (value, 0f, 1f);
            }
            public float fluctuation {
                get => m_fluctuation;
                set => m_fluctuation = Mathf.Clamp (value, 0f, 4f);
            }
            public float flow {
                get => m_flow;
                set => m_flow = value;
            }
            public float direction {
                get => m_direction;
                set => m_direction = wrapAngle180 (value);
            }

            [System.NonSerialized] internal Vector3 pos;

            public Wave (float density, float height, float fluct, float flow, float dir) {
                m_density = density;
                m_height = height;
                m_fluctuation = fluct;
                m_flow = flow;
                m_direction = dir;
            }

            internal Vector3 getData (float adjustDensity, float adjustHeight, int idx) {
                float d = m_density * adjustDensity;
                return new Vector3 (d, m_height * adjustHeight / (d * d) * 0.5f, idx);
            }

            internal void renewFlowData (float scale) {
                Vector2 v = new Vector2 (m_flowU, m_flowV) * scale / m_density;
                float dir = Mathf.Atan2 (-v.y, v.x) * Mathf.Rad2Deg;
                m_flow = round2Dec (v.magnitude);
                m_direction = vecToDir (v);
            }

        }

        // -----------------------------------------------------------
#endif // End of UNITY_2020_3_OR_NEWER
    }
}