public static void FrameworkEntry()
{
if (hasStarted)
{
return;
}
hasStarted = true;
ConsoleManager.CreateConsole();
for (int i = 0; i <= 31; i++) //user defined layers start with layer 8 and unity supports 31 layers
{
if (!SortingLayer.IsValid(i))
{
continue;
}
var layerN = SortingLayer.IDToName(i); //get the name of the layer
Debug.Log($"{i} - {layerN}");
}
var assembly = Assembly.GetCallingAssembly();
Console.WriteLine("Running on " + assembly.GetName());
harmony = new Harmony("johnnyjohnny.modloader");
harmony.PatchAll();
Console.WriteLine("Harmony patched");
}
public void Initialize(VolumetricLightBeam master, Shader shader)
{
HideFlags objectsHideFlags = Consts.ProceduralObjectsHideFlags;
this.m_Master = master;
((Component)this).get_transform().SetParent(((Component)master).get_transform(), false);
this.material = new Material(shader);
((Object)this.material).set_hideFlags(objectsHideFlags);
this.meshRenderer = ((Component)this).get_gameObject().GetOrAddComponent <MeshRenderer>();
((Object)this.meshRenderer).set_hideFlags(objectsHideFlags);
((Renderer)this.meshRenderer).set_material(this.material);
((Renderer)this.meshRenderer).set_shadowCastingMode((ShadowCastingMode)0);
((Renderer)this.meshRenderer).set_receiveShadows(false);
((Renderer)this.meshRenderer).set_lightProbeUsage((LightProbeUsage)0);
if (SortingLayer.IsValid(this.m_Master.sortingLayerID))
{
this.sortingLayerID = this.m_Master.sortingLayerID;
}
else
{
Debug.LogError((object)string.Format("Beam '{0}' has an invalid sortingLayerID ({1}). Please fix it by setting a valid layer.", (object)Utils.GetPath(((Component)this.m_Master).get_transform()), (object)this.m_Master.sortingLayerID));
}
this.sortingOrder = this.m_Master.sortingOrder;
this.meshFilter = ((Component)this).get_gameObject().GetOrAddComponent <MeshFilter>();
((Object)this.meshFilter).set_hideFlags(objectsHideFlags);
((Object)((Component)this).get_gameObject()).set_hideFlags(objectsHideFlags);
}
public void Initialize(VolumetricLightBeam master, Shader shader)
{
HideFlags proceduralObjectsHideFlags = Consts.ProceduralObjectsHideFlags;
this.m_Master = master;
base.transform.SetParent(master.transform, false);
this.material = new Material(shader)
{
hideFlags = proceduralObjectsHideFlags
};
this.meshRenderer = base.gameObject.GetOrAddComponent <MeshRenderer>();
this.meshRenderer.hideFlags = proceduralObjectsHideFlags;
this.meshRenderer.material = this.material;
this.meshRenderer.shadowCastingMode = ShadowCastingMode.Off;
this.meshRenderer.receiveShadows = false;
this.meshRenderer.lightProbeUsage = LightProbeUsage.Off;
if (!SortingLayer.IsValid(this.m_Master.sortingLayerID))
{
Debug.LogError(string.Format("Beam '{0}' has an invalid sortingLayerID ({1}). Please fix it by setting a valid layer.", Utils.GetPath(this.m_Master.transform), this.m_Master.sortingLayerID));
}
else
{
this.sortingLayerID = this.m_Master.sortingLayerID;
}
this.sortingOrder = this.m_Master.sortingOrder;
this.meshFilter = base.gameObject.GetOrAddComponent <MeshFilter>();
this.meshFilter.hideFlags = proceduralObjectsHideFlags;
base.gameObject.hideFlags = proceduralObjectsHideFlags;
}
public static void UpdateSortingLayers(ref int[] targetSortingLayers)
{
++s_NumLight;
var layers = SortingLayer.layers;
if (GetCachedSortingLayer().Length + 1 == layers.Length)
{
var sortingLayerList = targetSortingLayers.ToList();
// Remove any invalid layers
sortingLayerList.RemoveAll(id => !SortingLayer.IsValid(id));
// Add any new layers
var layer = layers.Except(s_SortingLayers).FirstOrDefault();
if (sortingLayerList.Count + 1 == layers.Length && !sortingLayerList.Contains(layer.id))
{
sortingLayerList.Add(layer.id);
}
targetSortingLayers = sortingLayerList.ToArray();
}
if (s_NumLight == lights.Count)
{
s_SortingLayers = layers;
s_NumLight = 0;
}
}
protected override void Awake()
{
base.Awake();
//DontDestroyOnLoad(gameObject);
SplitBackgroundCamera.enabled = false;
Enabled = false;
SplitLineImage.color = LineColor;
SplitLineImage.sprite = SplitLineSprite;
SplitLineBackground.sprite = BackgroundSprite;
var canvas = SplitLineImage.GetComponentInParent <Canvas>();
canvas.worldCamera = SplitScreenManager.MainCamera;
canvas.planeDistance = 0.1f;
if (!SplitScreenManager.Instance.Is3D && SortingLayer.IsValid(SortingLayer.NameToID("Foreground")))
{
canvas.sortingLayerName = "Foreground";
}
else if (!SplitScreenManager.Instance.Is3D)
{
Debug.LogWarning("'Foreground' layer wasn't found. Please read the README and create sorting layers called Foreground and Background.");
}
canvas.sortingOrder = SplitScreenManager.PLAYER_HUD_LAYER_ORDER;
SplitScreenManager.Instance.RegisterSplitLine();
SplitScreenManager.Instance.OnResolutionChanged += RescaleSplitLine;
}
/// <summary>
/// Draws a popup of the project's existing sorting layers.
/// </summary>
///<param name="layerID">The internal layer id, can be assigned to renderer.SortingLayerID to change sorting layers.</param>
/// <returns></returns>
public static int DrawSortingLayersPopup(string label, int layerID)
{
/*
* https://answers.unity.com/questions/585108/how-do-you-access-sorting-layers-via-scripting.html
*/
EditorGUILayout.BeginHorizontal();
if (!string.IsNullOrEmpty(label))
{
EditorGUILayout.LabelField(label);
}
var layers = SortingLayer.layers;
var names = layers.Select(l => l.name).ToArray();
if (!SortingLayer.IsValid(layerID))
{
layerID = layers[0].id;
}
var layerValue = SortingLayer.GetLayerValueFromID(layerID);
var newLayerValue = EditorGUILayout.Popup(layerValue, names);
EditorGUILayout.EndHorizontal();
SetSceneDirty(newLayerValue != layerValue);
return(layers[newLayerValue].id);
}
public void OnTargetSortingLayers(SerializedObject serializedObject, Object[] targets, GUIContent labelContent, System.Action <SerializedObject> selectionChangedCallback)
{
Rect totalPosition = EditorGUILayout.GetControlRect();
GUIContent actualLabel = EditorGUI.BeginProperty(totalPosition, labelContent, m_ApplyToSortingLayers);
Rect position = EditorGUI.PrefixLabel(totalPosition, actualLabel);
m_ApplyToSortingLayersList.Clear();
int applyToSortingLayersSize = m_ApplyToSortingLayers.arraySize;
for (int i = 0; i < applyToSortingLayersSize; ++i)
{
int layerID = m_ApplyToSortingLayers.GetArrayElementAtIndex(i).intValue;
if (SortingLayer.IsValid(layerID))
{
m_ApplyToSortingLayersList.Add(layerID);
}
}
GUIContent selectedLayers;
if (m_ApplyToSortingLayersList.Count == 1)
{
selectedLayers = new GUIContent(SortingLayer.IDToName(m_ApplyToSortingLayersList[0]));
}
else if (m_ApplyToSortingLayersList.Count == m_AllSortingLayers.Length)
{
selectedLayers = Styles.sortingLayerAll;
}
else if (m_ApplyToSortingLayersList.Count == 0)
{
selectedLayers = Styles.sortingLayerNone;
}
else
{
selectedLayers = Styles.sortingLayerMixed;
}
if (EditorGUI.DropdownButton(position, selectedLayers, FocusType.Keyboard, EditorStyles.popup))
{
GenericMenu menu = new GenericMenu();
menu.allowDuplicateNames = true;
LayerSelectionData layerSelectionData = new LayerSelectionData(serializedObject, 0, targets, selectionChangedCallback);
menu.AddItem(Styles.sortingLayerNone, m_ApplyToSortingLayersList.Count == 0, OnNoSortingLayerSelected, layerSelectionData);
menu.AddItem(Styles.sortingLayerAll, m_ApplyToSortingLayersList.Count == m_AllSortingLayers.Length, OnAllSortingLayersSelected, layerSelectionData);
menu.AddSeparator("");
for (int i = 0; i < m_AllSortingLayers.Length; ++i)
{
var sortingLayer = m_AllSortingLayers[i];
layerSelectionData = new LayerSelectionData(serializedObject, sortingLayer.id, targets, selectionChangedCallback);
menu.AddItem(m_AllSortingLayerNames[i], m_ApplyToSortingLayersList.Contains(sortingLayer.id), OnSortingLayerSelected, layerSelectionData);
}
menu.DropDown(position);
}
EditorGUI.EndProperty();
}
public void SyncSortingLayer()
{
if (false == EnableSyncLayer)
{
return;
}
if (InheritedLayer)
{
Canvas parentCanvas = this.GetComponentInParent <Canvas>();
OverrideSortingLayerId = null != parentCanvas ? parentCanvas.sortingLayerID : SortingLayer.NameToID("Default");
OverrideSortingLayerName = SortingLayer.IDToName(OverrideSortingLayerId);
}
int sortingOrderValue = SortingOrder;
if (SetSortingOrder && RelativeSortingOrder)
{
int baseSortingOrderValue = 0;
Canvas[] parentCanvas = this.GetComponentsInParent <Canvas>();
Canvas tempCanvas;
for (int i = 0, count = parentCanvas.Length; i < count; i++)
{
tempCanvas = parentCanvas[i];
if (tempCanvas.gameObject == this.gameObject)
{
continue;
}
if (false == tempCanvas.isRootCanvas && false == tempCanvas.overrideSorting)
{
continue;
}
if (false == tempCanvas.isRootCanvas && tempCanvas.sortingLayerID != OverrideSortingLayerId)
{
continue;
}
baseSortingOrderValue = tempCanvas.sortingOrder;
break;
}
sortingOrderValue = baseSortingOrderValue + SortingOrder;
}
if (false == SortingLayer.IsValid(OverrideSortingLayerId))
{
DYLogger.LogError("SyncSortingLayer fail, get unvalid sortinglayer " + OverrideSortingLayerName);
return;
}
Util.SetGameObjectSortingLayer(this.gameObject, OverrideSortingLayerId, IgnoreHigherLayer, SetSortingOrder, sortingOrderValue, RaycastTarget);
}
int DrawSortingLayersPopup(int layerID)
{
var layers = SortingLayer.layers;
var names = layers.Select(l => l.name).ToArray();
if (!SortingLayer.IsValid(layerID))
{
layerID = layers[0].id;
}
var layerValue = SortingLayer.GetLayerValueFromID(layerID);
var newLayerValue = EditorGUILayout.Popup("Sorting Layer", layerValue, names);
return(layers[newLayerValue].id);
}
public void Initialize(VolumetricLightBeam master)
{
Debug.Assert(master != null);
var customHideFlags = Consts.ProceduralObjectsHideFlags;
m_Master = master;
transform.SetParent(master.transform, false);
meshRenderer = gameObject.GetOrAddComponent <MeshRenderer>();
meshRenderer.hideFlags = customHideFlags;
meshRenderer.shadowCastingMode = UnityEngine.Rendering.ShadowCastingMode.Off;
meshRenderer.receiveShadows = false;
meshRenderer.reflectionProbeUsage = UnityEngine.Rendering.ReflectionProbeUsage.Off; // different reflection probes could break batching with GPU Instancing
#if UNITY_5_4_OR_NEWER
meshRenderer.lightProbeUsage = UnityEngine.Rendering.LightProbeUsage.Off;
#else
meshRenderer.useLightProbes = false;
#endif
if (!shouldUseGPUInstancedMaterial)
{
m_CustomMaterial = MaterialManager.NewMaterial(gpuInstanced: false);
ApplyMaterial();
}
if (SortingLayer.IsValid(m_Master.sortingLayerID))
{
sortingLayerID = m_Master.sortingLayerID;
}
else
{
Debug.LogError(string.Format("Beam '{0}' has an invalid sortingLayerID ({1}). Please fix it by setting a valid layer.", Utils.GetPath(m_Master.transform), m_Master.sortingLayerID));
}
sortingOrder = m_Master.sortingOrder;
meshFilter = gameObject.GetOrAddComponent <MeshFilter>();
meshFilter.hideFlags = customHideFlags;
gameObject.hideFlags = customHideFlags;
#if UNITY_EDITOR
UnityEditor.GameObjectUtility.SetStaticEditorFlags(gameObject, master.GetStaticEditorFlagsForSubObjects());
gameObject.SetSameSceneVisibilityStatesThan(master.gameObject);
#endif
RestartFadeOutCoroutine();
}
public void Initialize(VolumetricLightBeam master)
{
var hideFlags = Consts.ProceduralObjectsHideFlags;
m_Master = master;
transform.SetParent(master.transform, false);
meshRenderer = gameObject.GetOrAddComponent <MeshRenderer>();
meshRenderer.hideFlags = hideFlags;
meshRenderer.shadowCastingMode = UnityEngine.Rendering.ShadowCastingMode.Off;
meshRenderer.receiveShadows = false;
#if UNITY_5_4_OR_NEWER
meshRenderer.lightProbeUsage = UnityEngine.Rendering.LightProbeUsage.Off;
#else
meshRenderer.useLightProbes = false;
#endif
if (Config.Instance.actualRenderingMode != RenderingMode.GPUInstancing)
{
m_CustomMaterial = MaterialManager.NewMaterial(gpuInstanced: false);
ApplyMaterial();
}
if (SortingLayer.IsValid(m_Master.sortingLayerID))
{
sortingLayerID = m_Master.sortingLayerID;
}
else
{
Debug.LogError(string.Format("Beam '{0}' has an invalid sortingLayerID ({1}). Please fix it by setting a valid layer.", Utils.GetPath(m_Master.transform), m_Master.sortingLayerID));
}
sortingOrder = m_Master.sortingOrder;
meshFilter = gameObject.GetOrAddComponent <MeshFilter>();
meshFilter.hideFlags = hideFlags;
gameObject.hideFlags = hideFlags;
#if UNITY_EDITOR
// Apply the same static flags to the BeamGeometry than the VLB GAO
var flags = UnityEditor.GameObjectUtility.GetStaticEditorFlags(master.gameObject);
flags &= ~(UnityEditor.StaticEditorFlags.ContributeGI); // remove the Lightmap static flag since it will generate error messages when selecting the BeamGeometry GAO in the editor
UnityEditor.GameObjectUtility.SetStaticEditorFlags(gameObject, flags);
#endif
RestartFadeOutCoroutine();
}
public bool SetSortingLayer(int layerId)
{
if (SortingLayer.IsValid(layerId) == false)
{
// layerName invalid
return(false);
}
ParticleSystemRenderer[] particles;
particles = GetComponentsInChildren <ParticleSystemRenderer> ();
foreach (ParticleSystemRenderer particle in particles)
{
particle.sortingLayerID = layerId;
particle.sortingOrder += orderOffset;
}
return(true);
}
public static int IsValid_s(IntPtr l)
{
int result;
try
{
int id;
LuaObject.checkType(l, 1, out id);
bool b = SortingLayer.IsValid(id);
LuaObject.pushValue(l, true);
LuaObject.pushValue(l, b);
result = 2;
}
catch (Exception e)
{
result = LuaObject.error(l, e);
}
return(result);
}
public void Initialize(VolumetricLightBeam master)
{
var hideFlags = Consts.ProceduralObjectsHideFlags;
m_Master = master;
transform.SetParent(master.transform, false);
meshRenderer = gameObject.GetOrAddComponent <MeshRenderer>();
meshRenderer.hideFlags = hideFlags;
meshRenderer.shadowCastingMode = UnityEngine.Rendering.ShadowCastingMode.Off;
meshRenderer.receiveShadows = false;
#if UNITY_5_4_OR_NEWER
meshRenderer.lightProbeUsage = UnityEngine.Rendering.LightProbeUsage.Off;
#else
meshRenderer.useLightProbes = false;
#endif
if (Config.Instance.actualRenderingMode != RenderingMode.GPUInstancing)
{
m_CustomMaterial = MaterialManager.NewMaterial(gpuInstanced: false);
ApplyMaterial();
}
if (SortingLayer.IsValid(m_Master.sortingLayerID))
{
sortingLayerID = m_Master.sortingLayerID;
}
else
{
Debug.LogError(string.Format("Beam '{0}' has an invalid sortingLayerID ({1}). Please fix it by setting a valid layer.", Utils.GetPath(m_Master.transform), m_Master.sortingLayerID));
}
sortingOrder = m_Master.sortingOrder;
meshFilter = gameObject.GetOrAddComponent <MeshFilter>();
meshFilter.hideFlags = hideFlags;
gameObject.hideFlags = hideFlags;
RestartFadeOutCoroutine();
}
public void OnEnable(SerializedObject serializedObject, string propertyName)
{
m_ApplyToSortingLayers = serializedObject.FindProperty(propertyName);
m_AllSortingLayers = SortingLayer.layers;
m_AllSortingLayerNames = m_AllSortingLayers.Select(x => new GUIContent(x.name)).ToArray();
int applyToSortingLayersSize = m_ApplyToSortingLayers.arraySize;
m_ApplyToSortingLayersList = new List <int>(applyToSortingLayersSize);
for (int i = 0; i < applyToSortingLayersSize; ++i)
{
int layerID = m_ApplyToSortingLayers.GetArrayElementAtIndex(i).intValue;
if (SortingLayer.IsValid(layerID))
{
m_ApplyToSortingLayersList.Add(layerID);
}
}
}
private IEnumerator InitializeHUD()
{
yield return(null);
PlayerHUD.GetComponent <Canvas>().worldCamera = Camera;
PlayerHUD.GetComponent <Canvas>().planeDistance = 0.1f;
if (!SplitScreenManager.Instance.Is3D && SortingLayer.IsValid(SortingLayer.NameToID("Foreground")))
{
PlayerHUD.GetComponent <Canvas>().sortingLayerName = "Foreground";
}
else if (!SplitScreenManager.Instance.Is3D)
{
Debug.LogWarning("'Foreground' layer wasn't found. Please read the README and create sorting layers called Foreground and Background.");
}
PlayerHUD.GetComponent <Canvas>().sortingOrder = SplitScreenManager.PLAYER_HUD_LAYER_ORDER;
yield return(null);
FadeManager.BeginFadeFromColor(Camera, 1);
}
public void Initialize(VolumetricLightBeam master, Shader shader)
{
var hideFlags = Consts.ProceduralObjectsHideFlags;
m_Master = master;
transform.SetParent(master.transform, false);
material = new Material(shader);
material.hideFlags = hideFlags;
meshRenderer = gameObject.GetOrAddComponent <MeshRenderer>();
meshRenderer.hideFlags = hideFlags;
meshRenderer.material = material;
meshRenderer.shadowCastingMode = UnityEngine.Rendering.ShadowCastingMode.Off;
meshRenderer.receiveShadows = false;
#if UNITY_5_4_OR_NEWER
meshRenderer.lightProbeUsage = UnityEngine.Rendering.LightProbeUsage.Off;
#else
meshRenderer.useLightProbes = false;
#endif
if (SortingLayer.IsValid(m_Master.sortingLayerID))
{
sortingLayerID = m_Master.sortingLayerID;
}
else
{
Debug.LogError(string.Format("Beam '{0}' has an invalid sortingLayerID ({1}). Please fix it by setting a valid layer.", Utils.GetPath(m_Master.transform), m_Master.sortingLayerID));
}
sortingOrder = m_Master.sortingOrder;
meshFilter = gameObject.GetOrAddComponent <MeshFilter>();
meshFilter.hideFlags = hideFlags;
gameObject.hideFlags = hideFlags;
}
public override void OnInspectorGUI()
{
if (_target == null)
{
_target = (UIPage)target;
}
EditorGUILayout.BeginVertical();
//处理者
EditorGUILayout.BeginHorizontal();
EditorGUILayout.LabelField(new GUIContent(I18Ns.UIHandler, I18Ns.UIHandler_Tooltips), GUILayout.MaxWidth(100));
_target.UIMainHandler = EditorGUILayout.ObjectField(_target.UIMainHandler, typeof(UnityEngine.MonoBehaviour), true);
EditorGUILayout.EndHorizontal();
//处理者的奇怪判断
if (_target.UIMainHandler == null)
{
var xc = _target.gameObject.GetComponent <XComponentScriptBase>();
if (xc != null)
{
if (GUILayout.Button(string.Format(I18Ns.Btn_SetHandler, xc.GetType().Name)))
{
_target.UIMainHandler = xc;
}
}
}
else
{
if (!_target.UIMainHandler.GetType().IsSubclassOf(typeof(MonoBehaviour)))
{
//无效警告
EditorGUILayout.LabelField(I18Ns.UIHandlerInvalid, Styles.label_warning);
}
}
//全屏
GUILayout.Space(10);
EditorGUILayout.BeginHorizontal();
EditorGUILayout.LabelField(new GUIContent(I18Ns.FullScreenUI, I18Ns.FullScreenUI_ToolTips), GUILayout.MaxWidth(100));
_target.FullScreenUI = EditorGUILayout.Toggle(_target.FullScreenUI);
EditorGUILayout.EndHorizontal();
//Screen UI
EditorGUILayout.BeginHorizontal();
EditorGUILayout.LabelField("Screen UI", GUILayout.MaxWidth(100));
_target.ScreenUI = EditorGUILayout.Toggle(_target.ScreenUI);
EditorGUILayout.EndHorizontal();
//多开
EditorGUILayout.BeginHorizontal();
EditorGUILayout.LabelField(new GUIContent(I18Ns.MultipleUI, I18Ns.MultipleUI_Tooltips), GUILayout.MaxWidth(100));
_target.AllowMultiple = EditorGUILayout.Toggle(_target.AllowMultiple);
EditorGUILayout.EndHorizontal();
//SortingLayer
GUILayout.Space(10);
EditorGUILayout.BeginHorizontal();
EditorGUILayout.LabelField("SortingLayer", GUILayout.MaxWidth(100));
int sorting_layer_id = 0;
if (SortingLayer.IsValid(_target.SortingLayerID))
{
sorting_layer_id = _target.SortingLayerID;
}
var sorting_layers = SortingLayer.layers;
var sorting_layer_names = sorting_layers.Select(s => s.name).ToArray();
sorting_layer_id = EditorGUILayout.Popup(sorting_layer_id, sorting_layer_names);
EditorGUILayout.EndHorizontal();
//动画-----------------------------------------------------------------------
GUILayout.Space(10);
EditorGUILayout.LabelField("UI Animation", EditorStyles.largeLabel);
EditorGUILayout.BeginHorizontal();
EditorGUILayout.LabelField(new GUIContent(I18Ns.UIShow_Ani), GUILayout.MaxWidth(120));
_target.UIShowAni = (UIAnimationBase)EditorGUILayout.ObjectField(_target.UIShowAni, typeof(UIAnimationBase), true);
EditorGUILayout.EndHorizontal();
if (_target.UIShowAni != null)
{
_target.UIShowAni.playOnAwake = false;
}
EditorGUILayout.BeginHorizontal();
EditorGUILayout.LabelField(new GUIContent(I18Ns.UIExit_Ani), GUILayout.MaxWidth(120));
_target.UIExitAni = (UIAnimationBase)EditorGUILayout.ObjectField(_target.UIExitAni, typeof(UIAnimationBase), true);
EditorGUILayout.EndHorizontal();
if (_target.UIExitAni != null)
{
_target.UIExitAni.pingPong = false;
}
//音效
if (GUILayout.Button("Edit In Window"))
{
InspectorInWindow.ShowInspector(target);
}
EditorGUILayout.EndVertical();
}
void OnEnable()
{
m_LightType = serializedObject.FindProperty("m_LightType");
m_LightColor = serializedObject.FindProperty("m_Color");
m_LightIntensity = serializedObject.FindProperty("m_Intensity");
m_ApplyToSortingLayers = serializedObject.FindProperty("m_ApplyToSortingLayers");
m_VolumetricAlpha = serializedObject.FindProperty("m_LightVolumeOpacity");
m_LightOperation = serializedObject.FindProperty("m_LightOperationIndex");
m_FalloffCurve = serializedObject.FindProperty("m_FalloffCurve");
// Point Light
m_PointInnerAngle = serializedObject.FindProperty("m_PointLightInnerAngle");
m_PointOuterAngle = serializedObject.FindProperty("m_PointLightOuterAngle");
m_PointInnerRadius = serializedObject.FindProperty("m_PointLightInnerRadius");
m_PointOuterRadius = serializedObject.FindProperty("m_PointLightOuterRadius");
m_PointZDistance = serializedObject.FindProperty("m_PointLightDistance");
m_PointLightCookie = serializedObject.FindProperty("m_LightCookieSprite");
m_PointLightQuality = serializedObject.FindProperty("m_PointLightQuality");
// Shape Light
m_ShapeLightRadius = serializedObject.FindProperty("m_ShapeLightRadius");
m_ShapeLightFalloffSize = serializedObject.FindProperty("m_ShapeLightFalloffSize");
m_ShapeLightParametricSides = serializedObject.FindProperty("m_ShapeLightParametricSides");
m_ShapeLightParametricAngleOffset = serializedObject.FindProperty("m_ShapeLightParametricAngleOffset");
m_ShapeLightFalloffOffset = serializedObject.FindProperty("m_ShapeLightFalloffOffset");
m_ShapeLightSprite = serializedObject.FindProperty("m_LightCookieSprite");
m_ShapeLightOrder = serializedObject.FindProperty("m_ShapeLightOrder");
m_ShapeLightOverlapMode = serializedObject.FindProperty("m_ShapeLightOverlapMode");
m_AnyLightOperationEnabled = false;
var lightOperationIndices = new List <int>();
var lightOperationNames = new List <string>();
var pipelineAsset = UnityEngine.Rendering.GraphicsSettings.renderPipelineAsset as LightweightRenderPipelineAsset;
var rendererData = pipelineAsset != null ? pipelineAsset.scriptableRendererData as _2DRendererData : null;
if (rendererData != null)
{
for (int i = 0; i < rendererData.lightOperations.Length; ++i)
{
var lightOperation = rendererData.lightOperations[i];
if (lightOperation.enabled)
{
lightOperationIndices.Add(i);
lightOperationNames.Add(lightOperation.name);
}
}
m_AnyLightOperationEnabled = lightOperationIndices.Count != 0;
}
else
{
for (int i = 0; i < 4; ++i)
{
lightOperationIndices.Add(i);
lightOperationNames.Add("Operation" + i);
}
}
m_LightOperationIndices = lightOperationIndices.ToArray();
m_LightOperationNames = lightOperationNames.Select(x => new GUIContent(x)).ToArray();
m_AllSortingLayers = SortingLayer.layers;
m_AllSortingLayerNames = m_AllSortingLayers.Select(x => new GUIContent(x.name)).ToArray();
int applyToSortingLayersSize = m_ApplyToSortingLayers.arraySize;
m_ApplyToSortingLayersList = new List <int>(applyToSortingLayersSize);
for (int i = 0; i < applyToSortingLayersSize; ++i)
{
int layerID = m_ApplyToSortingLayers.GetArrayElementAtIndex(i).intValue;
if (SortingLayer.IsValid(layerID))
{
m_ApplyToSortingLayersList.Add(layerID);
}
}
}
