Upload project file

Runtime/SceneToonEvAdjustment.cs

@@ -0,0 +1,205 @@
+using UnityEngine;
+#if UNITY_EDITOR
+using UnityEditor;
+#endif
+namespace Unity.Rendering.Toon
+{
+
+
+    [ExecuteAlways]
+    [DisallowMultipleComponent]
+    [UTSHelpURL("ToonEVAdjustment")]
+
+    internal class SceneToonEvAdjustment : MonoBehaviour
+    {
+        // flags
+        bool m_initialized = false;
+        bool m_srpCallbackInitialized = false;
+
+        const int kAdjustmentCurvePrecision = 128;
+
+        const string kCompensationPorpName = "_ToonEvAdjustmentCompensation";
+        const string kExposureAdjustmentPropName = "_ToonEvAdjustmentCurve";
+        const string kExposureArrayPropName = "_ToonEvAdjustmentValueArray";
+        const string kExposureMinPropName = "_ToonEvAdjustmentValueMin";
+        const string kExposureMaxPropName = "_ToonEvAdjustmentValueMax";
+        const string kToonLightFilterPropName = "_ToonLightHiCutFilter";
+        const string kIgonoreVolumeExposurePropName = "_ToonIgnoreExposureMultiplier";
+
+        internal bool m_ToonLightHiCutFilter = false;
+        internal bool m_ExposureAdjustmnt = false;
+        internal bool m_IgnorVolumeExposure = false;
+        internal AnimationCurve m_AnimationCurve = DefaultAnimationCurve();
+        internal float[] m_ExposureArray;
+        internal float m_Max, m_Min;
+        internal float m_Compensation;
+
+
+        private static SceneToonEvAdjustment instance;
+#if UNITY_EDITOR
+#pragma warning restore CS0414
+        bool m_isCompiling = false;
+#endif
+
+
+        void Awake()
+        {
+            if (instance == null)
+            {
+                instance = this as SceneToonEvAdjustment;
+                return;
+            }
+            else if (instance == this)
+            {
+                return;
+            }
+            Debug.LogError("There is ToonEvAdjustmentCurve instance in hierarchy.");
+#if UNITY_EDITOR
+            DestroyImmediate(this);
+            Selection.activeGameObject = instance.gameObject;
+#else
+            Destroy(this);
+#endif
+        }
+
+        void Reset()
+        {
+            OnDisable();
+            OnEnable();
+            DefaultAnimationCurve();
+        }
+
+        internal static AnimationCurve DefaultAnimationCurve()
+        {
+            return AnimationCurve.Linear(-10f, -10f, -1.32f, -1.32f);
+        }
+        void Update()
+        {
+
+            Initialize();
+
+            GetValues();
+
+
+            // Fail safe in case the curve is deleted / has 0 point
+            AnimationCurve curve = m_AnimationCurve;
+
+
+            if (curve == null || curve.length == 0)
+            {
+                m_Min = 0f;
+                m_Max = 0f;
+
+                for (int i = 0; i < kAdjustmentCurvePrecision; i++)
+                    m_ExposureArray[i] = 0.0f;
+            }
+            else
+            {
+                m_Min = curve[0].time;
+                m_Max = curve[curve.length - 1].time;
+                float step = (m_Max - m_Min) / (kAdjustmentCurvePrecision - 1f);
+
+                for (int i = 0; i < kAdjustmentCurvePrecision; i++)
+                    m_ExposureArray[i] = curve.Evaluate(m_Min + step * i);
+            }
+
+
+#if UNITY_EDITOR
+            // handle script recompile
+            if (EditorApplication.isCompiling && !m_isCompiling)
+            {
+                // on compile begin
+                m_isCompiling = true;
+                //                Release(); no need
+                return; // 
+            }
+            else if (!EditorApplication.isCompiling && m_isCompiling)
+            {
+                // on compile end
+                m_isCompiling = false;
+            }
+#endif
+            Shader.SetGlobalFloatArray(kExposureArrayPropName, m_ExposureArray);
+            Shader.SetGlobalFloat(kExposureMinPropName, m_Min);
+            Shader.SetGlobalFloat(kExposureMaxPropName, m_Max);
+            Shader.SetGlobalInt(kExposureAdjustmentPropName, m_ExposureAdjustmnt ? 1 : 0);
+            Shader.SetGlobalInt(kToonLightFilterPropName, m_ToonLightHiCutFilter ? 1 : 0);
+            Shader.SetGlobalInt(kIgonoreVolumeExposurePropName, m_IgnorVolumeExposure ? 1 : 0);
+            Shader.SetGlobalFloat(kCompensationPorpName, m_Compensation);
+        }
+
+        private void GetValues()
+        {
+
+        }
+
+        void EnableSrpCallbacks()
+        {
+
+            if (!m_srpCallbackInitialized)
+            {
+                m_srpCallbackInitialized = true;
+            }
+        }
+        void DisableSrpCallbacks()
+        {
+            if (m_srpCallbackInitialized)
+            {
+                m_srpCallbackInitialized = false;
+            }
+        }
+
+        void OnEnable()
+        {
+
+            Initialize();
+
+            EnableSrpCallbacks();
+
+        }
+
+        void OnDisable()
+        {
+            DisableSrpCallbacks();
+
+            Release();
+        }
+
+        void Initialize()
+        {
+            if (m_initialized)
+            {
+                return;
+            }
+#if UNITY_EDITOR
+            // initializing renderer can interfere GI baking. so wait until it is completed.
+
+            if (EditorApplication.isCompiling)
+                return;
+#endif
+
+            if (m_ExposureArray == null || m_ExposureArray.Length != kAdjustmentCurvePrecision)
+            {
+                m_ExposureArray = new float[kAdjustmentCurvePrecision];
+            }
+            m_initialized = true;
+        }
+
+
+        void Release()
+        {
+            if (m_initialized)
+            {
+                m_ExposureArray = null;
+                Shader.SetGlobalInt(kExposureAdjustmentPropName, 0);
+                Shader.SetGlobalInt(kToonLightFilterPropName, 0);
+            }
+
+            m_initialized = false;
+
+        }
+
+    }
+
+
+}