public void Draw(Light l)
{
AdditionalShadowData asd = l.GetComponent <AdditionalShadowData>();
Debug.Assert(asd != null, "Light has no valid AdditionalShadowData component attached.");
GPUShadowType shadowType = GetShadowLightType(l);
// check if this has supported shadows
if ((int)shadowType >= ShadowConstants.Counts.k_GPUShadowType)
{
return;
}
int shadowAlgorithm;
int shadowVariant;
int shadowPrecision;
bool globalOverride = m_GlobalOverrides[(int)shadowType].enabled;
if (globalOverride)
{
shadowAlgorithm = (int)m_GlobalOverrides[(int)shadowType].algorithm;
shadowVariant = (int)m_GlobalOverrides[(int)shadowType].variant;
shadowPrecision = (int)m_GlobalOverrides[(int)shadowType].precision;
}
else
{
asd.GetShadowAlgorithm(out shadowAlgorithm, out shadowVariant, out shadowPrecision);
}
DrawWidgets(l, shadowType, (ShadowAlgorithm)shadowAlgorithm, (ShadowVariant)shadowVariant, (ShadowPrecision)shadowPrecision, globalOverride);
}
public void CopyTo(AdditionalShadowData data)
{
data.shadowResolution = shadowResolution;
data.shadowDimmer = shadowDimmer;
data.shadowFadeDistance = shadowFadeDistance;
data.contactShadows = contactShadows;
data.viewBiasMin = viewBiasMin;
data.viewBiasMax = viewBiasMax;
data.viewBiasScale = viewBiasScale;
data.normalBiasMin = normalBiasMin;
data.normalBiasMax = normalBiasMax;
data.normalBiasScale = normalBiasScale;
data.sampleBiasScale = sampleBiasScale;
data.edgeLeakFixup = edgeLeakFixup;
data.edgeToleranceNormal = edgeToleranceNormal;
data.edgeTolerance = edgeTolerance;
data.shadowCascadeCount = shadowCascadeCount;
data.shadowCascadeRatios = new float[shadowCascadeRatios.Length];
shadowCascadeRatios.CopyTo(data.shadowCascadeRatios, 0);
data.shadowCascadeBorders = new float[shadowCascadeBorders.Length];
shadowCascadeBorders.CopyTo(data.shadowCascadeBorders, 0);
data.shadowAlgorithm = shadowAlgorithm;
data.shadowVariant = shadowVariant;
data.shadowPrecision = shadowPrecision;
data.shadowData = shadowData;
data.shadowDatas = new ShadowData[shadowDatas.Length];
shadowDatas.CopyTo(data.shadowDatas, 0);
}
public override void OnInspectorGUI()
{
base.OnInspectorGUI();
if (m_ShadowRegistry == null)
{
return;
}
AdditionalShadowData asd = (AdditionalShadowData)target;
if (asd == null)
{
return;
}
UnityEditor.EditorGUI.BeginChangeCheck();
m_ShadowRegistry.Draw(asd.gameObject.GetComponent <Light>());
serializedObject.Update();
m_ShadowmapRenderFlags.enumValueIndex = (int)(ShadowmapRenderFlags)UnityEditor.EditorGUILayout.EnumFlagsField("Render Flags", (ShadowmapRenderFlags)m_ShadowmapRenderFlags.enumValueIndex);
// cascade code
if (asd.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;
m_ShadowCascadeBorders.arraySize = newcnt;
}
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));
}
for (int i = 0; i < m_ShadowCascadeBorders.arraySize; i++)
{
UnityEditor.EditorGUILayout.Slider(m_ShadowCascadeBorders.GetArrayElementAtIndex(i), 0.0f, 1.0f, new GUIContent("Transition " + i));
}
UnityEditor.EditorGUI.indentLevel--;
}
if (UnityEditor.EditorGUI.EndChangeCheck())
{
UnityEditor.EditorUtility.SetDirty(asd);
UnityEditor.SceneManagement.EditorSceneManager.MarkAllScenesDirty();
UnityEditor.SceneView.RepaintAll();
}
serializedObject.ApplyModifiedProperties();
}
public static int GetShadowResolution(AdditionalShadowData shadowData)
{
if (shadowData != null)
{
return(shadowData.shadowResolution);
}
else
{
return(DefaultShadowResolution);
}
}
void DrawWidgets(Light l, GPUShadowType shadowType, ShadowAlgorithm shadowAlgorithm, ShadowVariant shadowVariant, ShadowPrecision shadowPrecision, bool globalOverride)
{
#if UNITY_EDITOR
var dict = m_Entries[(int)shadowType];
int[] algoOptions = new int[dict.Count];
GUIContent[] algoDescs = new GUIContent[dict.Count];
int idx = 0;
foreach (var entry in dict)
{
algoOptions[idx] = (int)entry.Key;
algoDescs[idx] = new GUIContent(entry.Value.algorithmDesc);
idx++;
}
using (new UnityEditor.EditorGUI.DisabledGroupScope(globalOverride))
{
UnityEditor.EditorGUI.BeginChangeCheck();
shadowAlgorithm = (ShadowAlgorithm)UnityEditor.EditorGUILayout.IntPopup(new GUIContent("Shadow Algorithm"), (int)shadowAlgorithm, algoDescs, algoOptions);
if (UnityEditor.EditorGUI.EndChangeCheck())
{
shadowVariant = 0;
}
}
UnityEditor.EditorGUI.indentLevel++;
Entry e = dict[shadowAlgorithm];
int varsAvailable = e.variantsAvailable;
int[] varOptions = new int[varsAvailable];
GUIContent[] varDescs = new GUIContent[varsAvailable];
idx = 0;
for (int writeIdx = 0; writeIdx < varsAvailable; idx++)
{
if (e.variantDels[idx].low != null || e.variantDels[idx].high != null)
{
varOptions[writeIdx] = idx;
varDescs[writeIdx] = new GUIContent(e.variantDescs[idx]);
writeIdx++;
}
}
UnityEditor.EditorGUILayout.BeginHorizontal();
using (new UnityEditor.EditorGUI.DisabledGroupScope(globalOverride))
{
shadowVariant = (ShadowVariant)UnityEditor.EditorGUILayout.IntPopup(new GUIContent("Variant + Precision"), (int)shadowVariant, varDescs, varOptions);
if (e.variantDels[(int)shadowVariant].low != null && e.variantDels[(int)shadowVariant].high != null)
{
GUIContent[] precDescs = new GUIContent[] { new GUIContent("High"), new GUIContent("Low") };
int[] precOptions = new int[] { 0, 1 };
shadowPrecision = (ShadowPrecision)UnityEditor.EditorGUILayout.IntPopup((int)shadowPrecision, precDescs, precOptions, GUILayout.MaxWidth(65));
}
else
{
using (new UnityEditor.EditorGUI.DisabledScope())
{
GUIContent[] precDescs = new GUIContent[] { new GUIContent(e.variantDels[(int)shadowVariant].low == null ? "High" : "Low") };
int[] precOptions = new int[] { e.variantDels[(int)shadowVariant].low == null ? 0 : 1 };
UnityEditor.EditorGUILayout.IntPopup(precOptions[0], precDescs, precOptions, GUILayout.MaxWidth(65));
shadowPrecision = (ShadowPrecision)precOptions[0];
}
}
}
AdditionalShadowData asd = l.GetComponent <AdditionalShadowData>();
GPUShadowAlgorithm packedAlgo = ShadowUtils.Pack(shadowAlgorithm, shadowVariant, shadowPrecision);
int[] shadowData = null;
if (!GUILayout.Button("Reset", GUILayout.MaxWidth(80.0f)))
{
shadowData = asd.GetShadowData((int)packedAlgo);
}
UnityEditor.EditorGUILayout.EndHorizontal();
if (shadowPrecision == ShadowPrecision.Low)
{
e.variantDels[(int)shadowVariant].low(l, shadowAlgorithm, shadowVariant, shadowPrecision, ref shadowData);
}
else
{
e.variantDels[(int)shadowVariant].high(l, shadowAlgorithm, shadowVariant, shadowPrecision, ref shadowData);
}
asd.SetShadowAlgorithm((int)shadowAlgorithm, (int)shadowVariant, (int)shadowPrecision, (int)packedAlgo, shadowData);
UnityEditor.EditorGUI.indentLevel--;
#endif
}
