private bool CollectStaticShadowmaps()
{
int shadowWidth = m_staticShadowMapResolution.value.vector2IntValue.x;
int shadowHeight = m_staticShadowMapResolution.value.vector2IntValue.y;
allCachedShadowInfos.Clear();
csdIndex.Clear();
for (int i = 0; i < allCachedShadows.Count; i++)
{
var csd = allCachedShadows[i];
Light l = csd.GetComponent <Light>();
AdditionalShadowData asd = csd.GetComponent <AdditionalShadowData>();
if (l != null && l.shadows != LightShadows.None && (csd.shadowUpdateType == ShadowUpdateType.Static || (l.type == LightType.Directional && csd.UseStaticShadowmapForLastCascade)))
{
CachedShadowInfo info = new CachedShadowInfo();
uint staticShadowmapRes = l.type == LightType.Directional ? csd.StaticShadowResolution : (uint)asd.shadowResolution;
info.viewport = new Rect(0, 0, staticShadowmapRes, staticShadowmapRes);
allCachedShadowInfos.Add(info);
csdIndex.Add(i);
}
}
return(Layout(shadowWidth, shadowHeight));
}
public void CopyTo(AdditionalShadowData data)
{
data.shadowResolution = shadowResolution;
data.shadowDimmer = shadowDimmer;
data.volumetricShadowDimmer = volumetricShadowDimmer;
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 LightData(HDAdditionalLightData hdAdditionalLightData, AdditionalShadowData additionalShadowData, bool isPrefab, Object prefabRoot)
{
this.hdAdditionalLightData = hdAdditionalLightData;
this.additionalShadowData = additionalShadowData;
this.isPrefab = isPrefab;
this.prefabRoot = prefabRoot;
}
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();
// 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);
}
}
public static void InitDefaultHDAdditionalShadowData(AdditionalShadowData shadowData)
{
// Update bias control for HD
// bias control default value based on empirical experiment
shadowData.viewBiasMin = 0.2f;
shadowData.viewBiasMax = 100.0f; // Not used, high value to have no effect
shadowData.viewBiasScale = 1.0f;
shadowData.normalBiasMin = 0.5f;
shadowData.normalBiasMax = 0.5f;
shadowData.normalBiasScale = 1.0f;
shadowData.sampleBiasScale = false;
shadowData.edgeLeakFixup = true;
shadowData.edgeToleranceNormal = true;
shadowData.edgeTolerance = 1.0f;
}
static void AddAdditionalLightData()
{
var lights = UnityObject.FindObjectsOfType(typeof(Light)) as Light[];
foreach (var light in lights)
{
// Do not add a component if there already is one.
if (light.GetComponent <HDAdditionalLightData>() == null)
{
light.gameObject.AddComponent <HDAdditionalLightData>();
}
if (light.GetComponent <AdditionalShadowData>() == null)
{
AdditionalShadowData shadowData = light.gameObject.AddComponent <AdditionalShadowData>();
HDAdditionalShadowData.InitDefaultHDAdditionalShadowData(shadowData);
}
}
}
void CreateSunlight()
{
if (sunlight == null)
{
sunlight = new GameObject("DirectionalLight");
//Init defaults
sunlightParameters = new SunlightParameters();
sunlightParameters.lightParameters.type = LightType.Directional;
}
sunlight.transform.parent = sunlightTimeofdayDummy.transform;
sunlight.transform.localPosition = -Vector3.forward * gizmoSize;
directionalLight = sunlight.GetComponent <Light>() ?? sunlight.AddComponent <Light>();
additionalLightData = sunlight.GetComponent <HDAdditionalLightData>() ?? sunlight.AddComponent <HDAdditionalLightData>();
shadowData = sunlight.GetComponent <AdditionalShadowData>() ?? sunlight.AddComponent <AdditionalShadowData>();
directionalLight.type = LightType.Directional;
}
static void ResetLight(MenuCommand menuCommand)
{
GameObject go = ((Light)menuCommand.context).gameObject;
Assert.IsNotNull(go);
Light light = go.GetComponent <Light>();
HDAdditionalLightData lightAdditionalData = go.GetComponent <HDAdditionalLightData>();
AdditionalShadowData shadowAdditionalData = go.GetComponent <AdditionalShadowData>();
Assert.IsNotNull(light);
Assert.IsNotNull(lightAdditionalData);
Assert.IsNotNull(shadowAdditionalData);
Undo.RecordObjects(new UnityEngine.Object[] { light, lightAdditionalData, shadowAdditionalData }, "Reset HD Light");
light.Reset();
// To avoid duplicating init code we copy default settings to Reset additional data
// Note: we can't call this code inside the HDAdditionalLightData, thus why we don't wrap it in a Reset() function
HDUtils.s_DefaultHDAdditionalLightData.CopyTo(lightAdditionalData);
HDUtils.s_DefaultAdditionalShadowData.CopyTo(shadowAdditionalData);
}
private static void UpdateUnityHdData(HDAdditionalLightData unityHdData, AdditionalShadowData unityShadowData, HDLightData hdData)
{
unityHdData.lightTypeExtent = hdData.lightTypeExtent;
unityHdData.lightDimmer = hdData.lightDimmer;
unityHdData.fadeDistance = hdData.fadeDistance;
unityHdData.affectDiffuse = hdData.affectDiffuse;
unityHdData.affectSpecular = hdData.affectSpecular;
unityHdData.shapeWidth = hdData.shapeWidth;
unityHdData.shapeHeight = hdData.shapeHeight;
unityHdData.aspectRatio = hdData.aspectRatio;
unityHdData.shapeRadius = hdData.shapeRadius;
unityHdData.maxSmoothness = hdData.maxSmoothness;
unityHdData.applyRangeAttenuation = hdData.applyRangeAttenuation;
// Spot light specific
// NOTE: Can't add branch here, because HD light doesn't itself know whether it's a spot. That's stored in Unity.Light.
unityHdData.enableSpotReflector = hdData.enableSpotReflector;
unityHdData.m_InnerSpotPercent = hdData.innerSpotPercent;
unityHdData.spotLightShape = hdData.spotLightShape;
// Intensity is a property. It setups lots of things and assumes data is already set. Must be called last!
unityHdData.intensity = hdData.intensity;
// HDShadowData
unityShadowData.shadowResolution = hdData.shadowResolution;
unityShadowData.shadowDimmer = hdData.shadowDimmer;
unityShadowData.volumetricShadowDimmer = hdData.volumetricShadowDimmer;
unityShadowData.shadowFadeDistance = hdData.shadowFadeDistance;
unityShadowData.contactShadows = hdData.contactShadows;
unityShadowData.viewBiasMin = hdData.viewBiasMin;
unityShadowData.viewBiasMax = hdData.viewBiasMax;
unityShadowData.viewBiasScale = hdData.viewBiasScale;
unityShadowData.normalBiasMin = hdData.normalBiasMin;
unityShadowData.normalBiasMax = hdData.normalBiasMax;
unityShadowData.normalBiasScale = hdData.normalBiasScale;
unityShadowData.sampleBiasScale = hdData.sampleBiasScale;
unityShadowData.edgeLeakFixup = hdData.edgeLeakFixup;
unityShadowData.edgeToleranceNormal = hdData.edgeToleranceNormal;
unityShadowData.edgeTolerance = hdData.edgeTolerance;
}
