添加debug工具

Assets/Plugins/RuntimeInspector/Scripts/RuntimeHierarchy/HierarchyData.cs

@@ -0,0 +1,441 @@
+using System.Collections.Generic;
+using UnityEngine;
+
+namespace RuntimeInspectorNamespace
+{
+	public abstract class HierarchyData
+	{
+		private static readonly List<HierarchyDataTransform> transformDataPool = new List<HierarchyDataTransform>( 32 );
+		private static readonly List<List<HierarchyDataTransform>> childrenListPool = new List<List<HierarchyDataTransform>>( 32 );
+
+		public abstract string Name { get; }
+		public abstract bool IsActive { get; }
+		public abstract int ChildCount { get; }
+		public abstract Transform BoundTransform { get; }
+
+		protected List<HierarchyDataTransform> children;
+		protected HierarchyData parent;
+		public HierarchyDataRoot Root
+		{
+			get
+			{
+				HierarchyData _parent = this;
+				while( _parent.parent != null )
+					_parent = _parent.parent;
+
+				return (HierarchyDataRoot) _parent;
+			}
+		}
+
+		protected int m_index;
+		public int Index { get { return m_index; } }
+		public int AbsoluteIndex
+		{
+			get
+			{
+				int result = m_index;
+				HierarchyData _parent = parent;
+				while( _parent != null )
+				{
+					result += _parent.m_index + 1;
+					_parent = _parent.parent;
+				}
+
+				return result;
+			}
+		}
+
+		protected int m_height = 1;
+		public int Height { get { return m_height; } }
+
+		protected int m_depth;
+		public int Depth { get { return m_depth; } }
+
+		public bool CanExpand { get { return ChildCount > 0; } }
+		public bool IsExpanded
+		{
+			get { return children != null; }
+			set
+			{
+				if( IsExpanded == value )
+					return;
+
+				if( value )
+				{
+					if( ChildCount == 0 )
+						return;
+
+					PopChildrenList();
+				}
+				else
+					PoolChildrenList();
+
+				int prevHeight = m_height;
+				Refresh();
+
+				int deltaHeight = m_height - prevHeight;
+				if( deltaHeight != 0 )
+				{
+					if( parent != null )
+					{
+						HierarchyData child = this;
+						HierarchyData _parent = parent;
+						while( _parent != null )
+						{
+							List<HierarchyDataTransform> children = _parent.children;
+							for( int i = children.IndexOf( (HierarchyDataTransform) child ) + 1, childCount = children.Count; i < childCount; i++ )
+								children[i].m_index += deltaHeight;
+
+							_parent.m_height += deltaHeight;
+
+							child = _parent;
+							_parent = _parent.parent;
+						}
+					}
+
+					HierarchyDataRoot root = Root;
+					if( root != null )
+						root.Hierarchy.SetListViewDirty();
+				}
+			}
+		}
+
+		public virtual bool Refresh()
+		{
+			if( m_depth < 0 ) // This object is hidden from Hierarchy
+				return false;
+
+			m_height = 1;
+			bool hasChanged = false;
+			int childCount = ChildCount;
+
+			if( IsExpanded )
+			{
+				if( childCount != children.Count )
+					hasChanged = true;
+
+				//if( childCount == 0 ) // Issue with IsExpanded's Refresh changing iteratedIndex
+				//	PoolChildrenList();
+				//else
+				{
+					RuntimeHierarchy hierarchy = null; // Root's RuntimeHierarchy will be fetched only once when it is needed
+					for( int i = 0; i < childCount; i++ )
+					{
+						Transform child = GetChild( i );
+						if( children.Count <= i )
+						{
+							if( hierarchy == null )
+								hierarchy = Root.Hierarchy;
+
+							GenerateChildItem( child, i, hierarchy );
+						}
+						else if( children[i].BoundTransform != child )
+						{
+							int childIndex;
+							for( childIndex = 0; childIndex < children.Count; childIndex++ )
+							{
+								if( children[childIndex].BoundTransform == child )
+									break;
+							}
+
+							if( childIndex == children.Count )
+							{
+								if( hierarchy == null )
+									hierarchy = Root.Hierarchy;
+
+								GenerateChildItem( child, i, hierarchy );
+							}
+							else
+							{
+								HierarchyDataTransform childItem = children[childIndex];
+								children.RemoveAt( childIndex );
+								children.Insert( i, childItem );
+							}
+
+							hasChanged = true;
+						}
+
+						hasChanged |= children[i].Refresh();
+						children[i].m_index = m_height - 1;
+						m_height += children[i].m_height;
+					}
+
+					for( int i = children.Count - 1; i >= childCount; i-- )
+						RemoveChildItem( i );
+				}
+			}
+
+			return hasChanged;
+		}
+
+		public HierarchyData FindDataAtIndex( int index )
+		{
+			int upperBound = children.Count - 1;
+			if( index <= upperBound && children[index].m_index == index )
+			{
+				int middle = index;
+				while( middle < upperBound && index == children[middle + 1].m_index )
+					middle++;
+
+				return children[middle];
+			}
+
+			// Binary search
+			int min = 0;
+			int max = upperBound;
+			while( min <= max )
+			{
+				int middle = ( min + max ) / 2;
+				int childIndex = children[middle].m_index;
+				if( index == childIndex )
+				{
+					// Items hidden from the Hierarchy have same indices with their adjacent items
+					while( middle < upperBound && index == children[middle + 1].m_index )
+						middle++;
+
+					return children[middle];
+				}
+
+				if( index < childIndex )
+					max = middle - 1;
+				else
+					min = middle + 1;
+			}
+
+			if( max < 0 )
+				max = 0;
+
+			while( max < upperBound && index >= children[max + 1].m_index )
+				max++;
+
+			return children[max].FindDataAtIndex( index - 1 - children[max].m_index );
+		}
+
+		public HierarchyDataTransform FindTransform( Transform target, Transform nextInPath = null )
+		{
+			if( m_depth < 0 ) // This object is hidden from Hierarchy
+				return null;
+
+			bool isInitSearch = nextInPath == null;
+			if( isInitSearch )
+			{
+				nextInPath = ( this is HierarchyDataRootSearch ) ? target : target.root;
+
+				// In the current implementation, FindTransform is only called from RuntimeHierarchy.Select which
+				// automatically calls RefreshContent prior to FindTransform
+				//( (HierarchyDataRoot) this ).RefreshContent();
+			}
+
+			int childIndex = IndexOf( nextInPath );
+			if( childIndex < 0 )
+			{
+				if( isInitSearch && this is HierarchyDataRootPseudoScene )
+				{
+					nextInPath = target;
+					childIndex = IndexOf( nextInPath );
+					while( childIndex < 0 && nextInPath != null )
+					{
+						nextInPath = nextInPath.parent;
+						childIndex = IndexOf( nextInPath );
+					}
+
+					if( childIndex < 0 )
+						return null;
+				}
+				else
+					return null;
+			}
+
+			if( !CanExpand )
+				return null;
+
+			bool wasExpanded = IsExpanded;
+			if( !wasExpanded )
+				IsExpanded = true;
+
+			HierarchyDataTransform childItem = children[childIndex];
+			if( childItem.BoundTransform == target )
+				return childItem;
+
+			HierarchyDataTransform result = null;
+			if( childItem.BoundTransform == nextInPath )
+			{
+				Transform next = target;
+				Transform parent = next.parent;
+				while( parent != null && parent != nextInPath )
+				{
+					next = parent;
+					parent = next.parent;
+				}
+
+				if( parent != null )
+					result = childItem.FindTransform( target, next );
+			}
+
+			if( result != null && result.m_depth < 0 )
+				result = null;
+
+			if( result == null && !wasExpanded )
+				IsExpanded = false;
+
+			return result;
+		}
+
+		public virtual HierarchyDataTransform FindTransformInVisibleChildren( Transform target, int targetDepth = -1 )
+		{
+			for( int i = 0; i < children.Count; i++ )
+			{
+				HierarchyDataTransform child = children[i];
+				if( child.m_depth < 0 )
+					continue;
+
+				if( ReferenceEquals( child.BoundTransform, target ) )
+				{
+					if( targetDepth <= 0 || child.m_depth == targetDepth )
+						return child;
+				}
+				else if( ( targetDepth <= 0 || child.m_depth < targetDepth ) && child.IsExpanded && child.BoundTransform && target.IsChildOf( child.BoundTransform ) )
+				{
+					child = child.FindTransformInVisibleChildren( target, targetDepth );
+					if( child != null )
+						return child;
+				}
+			}
+
+			return null;
+		}
+
+		public abstract Transform GetChild( int index );
+
+		public int IndexOf( Transform transform )
+		{
+			for( int i = ChildCount - 1; i >= 0; i-- )
+			{
+				if( ReferenceEquals( GetChild( i ), transform ) )
+					return i;
+			}
+
+			return -1;
+		}
+
+		public void GetSiblingIndexTraversalList( List<int> traversalList )
+		{
+			traversalList.Clear();
+
+			HierarchyData current = this;
+			while( current.parent != null )
+			{
+				traversalList.Add( current.parent.children.IndexOf( (HierarchyDataTransform) current ) );
+				current = current.parent;
+			}
+		}
+
+		public HierarchyData TraverseSiblingIndexList( List<int> traversalList )
+		{
+			HierarchyData current = this;
+			for( int i = traversalList.Count - 1; i >= 0; i-- )
+			{
+				int siblingIndex = traversalList[i];
+				if( current.children == null || siblingIndex >= current.children.Count )
+					return null;
+
+				current = current.children[siblingIndex];
+			}
+
+			return current;
+		}
+
+		private void GenerateChildItem( Transform child, int index, RuntimeHierarchy hierarchy )
+		{
+			bool isChildVisible = !RuntimeInspectorUtils.IgnoredTransformsInHierarchy.Contains( child );
+			if( isChildVisible && hierarchy.GameObjectFilter != null )
+				isChildVisible = hierarchy.GameObjectFilter( child );
+
+			HierarchyDataTransform childData;
+			int poolIndex = transformDataPool.Count - 1;
+			if( poolIndex >= 0 )
+			{
+				childData = transformDataPool[poolIndex];
+				transformDataPool.RemoveAt( poolIndex );
+			}
+			else
+				childData = new HierarchyDataTransform();
+
+			childData.Initialize( child, this is HierarchyDataRootSearch );
+			childData.parent = this;
+			if( isChildVisible )
+			{
+				childData.m_depth = m_depth + 1;
+				childData.m_height = 1;
+			}
+			else
+			{
+				childData.m_depth = -1;
+				childData.m_height = 0;
+			}
+
+			children.Insert( index, childData );
+		}
+
+		private void RemoveChildItem( int index )
+		{
+			children[index].PoolData();
+			transformDataPool.Add( children[index] );
+			children.RemoveAt( index );
+		}
+
+		protected void PoolChildrenList()
+		{
+			if( children != null )
+			{
+				for( int i = children.Count - 1; i >= 0; i-- )
+				{
+					children[i].PoolData();
+					transformDataPool.Add( children[i] );
+				}
+
+				children.Clear();
+				childrenListPool.Add( children );
+				children = null;
+			}
+		}
+
+		protected void PopChildrenList()
+		{
+			int desiredSize = ChildCount;
+			int bestFittingListIndex = -1;
+			int bestFittingListDeltaSize = int.MaxValue;
+			for( int i = childrenListPool.Count - 1; i >= 0; i-- )
+			{
+				int deltaSize = childrenListPool[i].Capacity - desiredSize;
+				if( deltaSize < 0 )
+					deltaSize = -deltaSize;
+
+				if( deltaSize < bestFittingListDeltaSize )
+				{
+					bestFittingListDeltaSize = deltaSize;
+					bestFittingListIndex = i;
+				}
+			}
+
+			if( bestFittingListIndex >= 0 )
+			{
+				children = childrenListPool[bestFittingListIndex];
+				childrenListPool.RemoveAt( bestFittingListIndex );
+			}
+			else
+				children = new List<HierarchyDataTransform>( ChildCount );
+		}
+
+		public static void ClearPool()
+		{
+			childrenListPool.Clear();
+			transformDataPool.Clear();
+
+			if( childrenListPool.Capacity > 128 )
+				childrenListPool.Capacity = 128;
+			if( transformDataPool.Capacity > 128 )
+				transformDataPool.Capacity = 128;
+		}
+	}
+}