Added shadow cascade settings to additional light data.

Assets/ScriptableRenderPipeline/Core/AdditionalLightData.cs

             public int[] data;
         };
 
+        [HideInInspector, SerializeField] private int           shadowCascadeCount = 4;
+        [HideInInspector, SerializeField] private float[]       shadowCascadeRatios = new float[3]{ 0.05f, 0.2f, 0.3f };
         [HideInInspector, SerializeField] private int           shadowAlgorithm;
         [HideInInspector, SerializeField] private int           shadowVariant;
         [HideInInspector, SerializeField] private int           shadowPrecision;
+        public void GetShadowCascades( out int cascadeCount, out float[] cascadeRatios ) { cascadeCount = shadowCascadeCount; cascadeRatios = shadowCascadeRatios; }
         public void GetShadowAlgorithm( out int algorithm, out int variant, out int precision )    { algorithm = shadowAlgorithm; variant = shadowVariant; precision = shadowPrecision; }
         public void SetShadowAlgorithm( int algorithm, int variant, int precision, int format, int[] data )
         {
         UnityEditor.SerializedProperty m_ShadowData;
         UnityEditor.SerializedProperty m_ShadowDatas;
 #pragma warning restore 414
+        UnityEditor.SerializedProperty m_ShadowCascadeCount;
+        UnityEditor.SerializedProperty m_ShadowCascadeRatios;
 
         public static void SetRegistry( ShadowRegistry registry ) { m_ShadowRegistry = registry; }
 
             m_ShadowVariant   = serializedObject.FindProperty( "shadowVariant" );
             m_ShadowData      = serializedObject.FindProperty( "shadowData" );
             m_ShadowDatas     = serializedObject.FindProperty( "shadowDatas" );
+            m_ShadowCascadeCount  = serializedObject.FindProperty( "shadowCascadeCount" );
+            m_ShadowCascadeRatios = serializedObject.FindProperty( "shadowCascadeRatios" );
         }
         public override void OnInspectorGUI()
         {
                 return;
 
             UnityEditor.EditorGUI.BeginChangeCheck();
+            
+
+            // cascade code
+            if( ald.gameObject.GetComponent<Light>().type == LightType.Directional )
+            {
+                UnityEditor.EditorGUI.BeginChangeCheck();
+                UnityEditor.EditorGUILayout.PropertyField( m_ShadowCascadeCount );
+                if( UnityEditor.EditorGUI.EndChangeCheck() )
+                {
+                    const int kMaxCascades = (int) ShadowAtlas.k_MaxCascadesInShader; // depending on where you look this is either 32 or 4, so we're limiting it to 4 for now
+                    int newcnt = m_ShadowCascadeCount.intValue <= 0 ? 1 : (m_ShadowCascadeCount.intValue > kMaxCascades ? kMaxCascades : m_ShadowCascadeCount.intValue);
+                    m_ShadowCascadeCount.intValue = newcnt;
+                    m_ShadowCascadeRatios.arraySize = newcnt-1;
+                }
+                UnityEditor.EditorGUI.indentLevel++;
+                for( int i = 0; i < m_ShadowCascadeRatios.arraySize; i++ )
+                {
+                    UnityEditor.EditorGUILayout.Slider( m_ShadowCascadeRatios.GetArrayElementAtIndex( i ), 0.0f, 1.0f, new GUIContent( "Cascade " + i ) );
+                }
+                UnityEditor.EditorGUI.indentLevel--;
+            }
+
             if( UnityEditor.EditorGUI.EndChangeCheck() )
             {
                 UnityEditor.EditorUtility.SetDirty( ald );
         }
     }
 #endif
-}
+            }

Assets/ScriptableRenderPipeline/Core/Shadow/Shadow.cs

 
             GPUShadowAlgorithm sanitizedAlgo = ShadowUtils.ClearPrecision( sr.shadowAlgorithm );
 
+            int     cascadeCnt = 0;
+            float[] cascadeRatios = null;
+            if( sr.shadowType == GPUShadowType.Directional )
+            {
+                AdditionalLightData ald = lights[sr.index].light.GetComponent<AdditionalLightData>();
+                if( !ald )
+                    return false;
+
+                ald.GetShadowCascades( out cascadeCnt, out cascadeRatios );
+            }
+
+
             if( multiFace )
             {
                 // For lights with multiple faces, the first shadow data contains
                         vp = ShadowUtils.ExtractSpotLightMatrix( lights[sr.index], out ce.current.view, out ce.current.proj, out ce.current.lightDir, out ce.current.splitData );
                     else if( sr.shadowType == GPUShadowType.Directional )
                     {
-                        vp = ShadowUtils.ExtractDirectionalLightMatrix( lights[sr.index], key.faceIdx, m_CascadeCount, m_CascadeRatios, nearPlaneOffset, width, height, out ce.current.view, out ce.current.proj, out ce.current.lightDir, out ce.current.splitData, m_CullResults, (int) sr.index );
+                        vp = ShadowUtils.ExtractDirectionalLightMatrix( lights[sr.index], key.faceIdx, cascadeCnt, cascadeRatios, nearPlaneOffset, width, height, out ce.current.view, out ce.current.proj, out ce.current.lightDir, out ce.current.splitData, m_CullResults, (int) sr.index );
                         m_TmpSplits[key.faceIdx]    = ce.current.splitData.cullingSphere;
                         if( ce.current.splitData.cullingSphere.w != float.NegativeInfinity )
                             m_TmpSplits[key.faceIdx].w *= ce.current.splitData.cullingSphere.w;

Assets/ScriptableRenderPipeline/Core/Shadow/ShadowUtilities.cs

             return proj * view;
         }
 
-        public static Matrix4x4 ExtractDirectionalLightMatrix( VisibleLight vl, uint cascadeIdx, int cascadeCount, Vector3 splitRatio, float nearPlaneOffset, uint width, uint height, out Matrix4x4 view, out Matrix4x4 proj, out Vector4 lightDir, out ShadowSplitData splitData, CullResults cullResults, int lightIndex )
+        public static Matrix4x4 ExtractDirectionalLightMatrix( VisibleLight vl, uint cascadeIdx, int cascadeCount, float[] splitRatio, float nearPlaneOffset, uint width, uint height, out Matrix4x4 view, out Matrix4x4 proj, out Vector4 lightDir, out ShadowSplitData splitData, CullResults cullResults, int lightIndex )
         {
             Debug.Assert( width == height, "Currently the cascaded shadow mapping code requires square cascades." );
             splitData = new ShadowSplitData();
             // TODO: At some point this logic should be moved to C#, then the parameters cullResults and lightIndex can be removed as well
             //       For directional lights shadow data is extracted from the cullResults, so that needs to be somehow provided here.
             //       Check ScriptableShadowsUtility.cpp ComputeDirectionalShadowMatricesAndCullingPrimitives(...) for details.
-            cullResults.ComputeDirectionalShadowMatricesAndCullingPrimitives( lightIndex, (int) cascadeIdx, cascadeCount, splitRatio, (int) width, nearPlaneOffset, out view, out proj, out splitData );
+            Vector3 ratios = new Vector3();
+            for( int i = 0, cnt = splitRatio.Length < 3 ? splitRatio.Length : 3; i < cnt; i++ )
+                ratios[i] = splitRatio[i];
+            cullResults.ComputeDirectionalShadowMatricesAndCullingPrimitives( lightIndex, (int) cascadeIdx, cascadeCount, ratios, (int) width, nearPlaneOffset, out view, out proj, out splitData );
             // and the compound
             return proj * view;
         }