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 bool Select(Transform selection, bool forceSelection = false)
{
if (!selection)
{
Deselect();
return(true);
}
else
{
if (!forceSelection && selection == m_currentSelection)
{
return(true);
}
CurrentSelection = selection;
// Make sure that the contents of the hierarchy are up-to-date
Refresh();
Scene selectionScene = selection.gameObject.scene;
for (int i = 0; i < sceneData.Count; i++)
{
HierarchyDataRoot data = sceneData[i];
if ((data is HierarchyDataRootPseudoScene) || ((HierarchyDataRootScene)data).Scene == selectionScene)
{
HierarchyDataTransform selectionItem = sceneData[i].FindTransform(selection);
if (selectionItem != null)
{
RefreshListView();
// Focus on selected HierarchyItem
int itemIndex = selectionItem.AbsoluteIndex;
for (int j = 0; j < i; j++)
{
itemIndex += sceneData[i].Height;
}
LayoutRebuilder.ForceRebuildLayoutImmediate(drawArea);
scrollView.verticalNormalizedPosition = Mathf.Clamp01(1f - (float)itemIndex / totalItemCount);
return(true);
}
}
}
}
return(false);
}
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);
}
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 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 HierarchyDataTransform FindTransform(Transform target, Transform nextInPath = null)
{
bool isInitSearch = nextInPath == null;
if (isInitSearch)
{
nextInPath = target.root;
((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);
}
