protected override void RowGUI(RowGUIArgs args)
{
base.RowGUI(args);
}
private void CellGUI(Rect cellRect, AssetBundleModel.AssetTreeItem item, int column, ref RowGUIArgs args)
{
Color oldColor = GUI.color;
CenterRectUsingSingleLineHeight(ref cellRect);
if (column != 3)
{
GUI.color = item.itemColor;
}
switch (column)
{
case 0:
{
var iconRect = new Rect(cellRect.x + 1, cellRect.y + 1, cellRect.height - 2, cellRect.height - 2);
if (item.icon != null)
{
GUI.DrawTexture(iconRect, item.icon, ScaleMode.ScaleToFit);
}
DefaultGUI.Label(
new Rect(cellRect.x + iconRect.xMax + 1, cellRect.y, cellRect.width - iconRect.width, cellRect.height),
item.displayName,
args.selected,
args.focused);
}
break;
case 1:
DefaultGUI.Label(cellRect, item.AssetInfo.bundleName, args.selected, args.focused);
break;
case 2:
DefaultGUI.Label(cellRect, item.AssetInfo.GetSizeString(), args.selected, args.focused);
break;
case 3:
var icon = item.MessageIcon;
if (icon != null)
{
var iconRect = new Rect(cellRect.x, cellRect.y, cellRect.height, cellRect.height);
GUI.DrawTexture(iconRect, icon, ScaleMode.ScaleToFit);
}
break;
}
GUI.color = oldColor;
}
/// <summary>
/// TreeViewの列の描画
/// </summary>
protected override void RowGUI(RowGUIArgs args)
{
var item = args.item as TreeViewItem;
for (var visibleColumnIndex = 0; visibleColumnIndex < args.GetNumVisibleColumns(); visibleColumnIndex++)
{
var rect = args.GetCellRect(visibleColumnIndex);
rect.y += 1f;
rect.height -= 2f;
var columnIndex = args.GetColumn(visibleColumnIndex);
var labelStyle = args.selected ? EditorStyles.whiteLabel : EditorStyles.label;
labelStyle.alignment = TextAnchor.MiddleCenter;
var element = baseElements[args.item.id];
bool changeValue1 = false;
bool changeValue2 = false;
bool changeValue3 = false;
bool changeValue4 = false;
switch (columnIndex)
{
case 0: // 備考
rect.x += 2f;
rect.width -= 4f;
element.Name = EditorGUI.TextField(rect, element.Name);
break;
case 1: // 数値1:数値2
rect.width -= valueFieldSpace + valueFieldMarginLeft + valueFieldMarginRight;
rect.width /= 2f;
EditorGUI.BeginChangeCheck();
rect.x += valueFieldMarginLeft;
element.Value1 = EditorGUI.FloatField(rect, element.Value1);
changeValue1 = EditorGUI.EndChangeCheck();
rect.x += rect.width + valueFieldSpace;
EditorGUI.BeginChangeCheck();
element.Value2 = EditorGUI.FloatField(rect, element.Value2);
changeValue2 = EditorGUI.EndChangeCheck();
break;
case 2: // 数値3:数値4
rect.width -= valueFieldSpace + valueFieldMarginLeft + valueFieldMarginRight;
rect.width /= 2f;
rect.x += valueFieldMarginLeft;
EditorGUI.BeginChangeCheck();
element.Value3 = EditorGUI.FloatField(rect, element.Value3);
changeValue3 = EditorGUI.EndChangeCheck();
rect.x += rect.width + valueFieldSpace;
EditorGUI.BeginChangeCheck();
element.Value4 = EditorGUI.FloatField(rect, element.Value4);
changeValue4 = EditorGUI.EndChangeCheck();
break;
case 3: // ボタン表示
rect.width /= 2;
if (GUI.Button(rect, "+"))
{
// 要素を複製して追加
baseElements.Insert(element.Id, new TreeElement
{
Name = element.Name,
TemplateIndex = element.TemplateIndex,
Value1 = element.Value1,
Value2 = element.Value2,
Value3 = element.Value3,
Value4 = element.Value4,
});
Update();
Reload();
}
;
rect.x += rect.width;
EditorGUI.BeginDisabledGroup(this.baseElements.Count <= 1);
if (GUI.Button(rect, "-"))
{
baseElements.RemoveAt(element.Id);
Update();
Reload();
}
;
EditorGUI.EndDisabledGroup();
break;
}
if (changeValue1)
{
element.UpdateValue4();
}
if (changeValue2)
{
element.UpdateValue3();
}
if (changeValue3)
{
element.UpdateValue4();
}
if (changeValue4)
{
element.UpdateValue3();
}
}
}
protected override void RowGUI(RowGUIArgs args)
{
var item = (LuaProfilerTreeViewItem)args.item;
if (m_gs == null)
{
m_gs = new GUIStyle(GUI.skin.label);
m_gs.alignment = TextAnchor.MiddleCenter;
}
var color = m_gs.normal.textColor;
if (!this.IsSelected(item.id))
{
if (item.isLua)
{
m_gs.normal.textColor = m_luaColor;
}
else if (item.isError)
{
m_gs.normal.textColor = m_errorColor;
}
else
{
m_gs.normal.textColor = m_monoColor;
}
}
else
{
m_gs.normal.textColor = m_selectColor;
}
Rect r = args.GetCellRect(0);
args.rowRect = r;
base.RowGUI(args);
r = args.GetCellRect(1);
GUI.Label(r, GetMemoryString(item.totalLuaMemory), m_gs);
r = args.GetCellRect(2);
GUI.Label(r, GetMemoryString(item.selfLuaMemory), m_gs);
r = args.GetCellRect(3);
GUI.Label(r, GetMemoryString(item.totalMonoMemory), m_gs);
r = args.GetCellRect(4);
GUI.Label(r, GetMemoryString(item.selfMonoMemory), m_gs);
r = args.GetCellRect(5);
GUI.Label(r, GetMemoryString(item.showLuaGC), m_gs);
r = args.GetCellRect(6);
GUI.Label(r, GetMemoryString(item.showMonoGC), m_gs);
r = args.GetCellRect(7);
GUI.Label(r, ((float)item.currentTime / 10000).ToString("f2") + "ms", m_gs);
r = args.GetCellRect(8);
GUI.Label(r, ((float)item.selfCostTime / 10000).ToString("f2") + "ms", m_gs);
r = args.GetCellRect(9);
GUI.Label(r, ((float)item.averageTime / 10000).ToString("f2") + "ms", m_gs);
r = args.GetCellRect(10);
GUI.Label(r, ((float)item.totalTime / 10000000).ToString("f6") + "s", m_gs);
r = args.GetCellRect(11);
GUI.Label(r, GetMemoryString(item.totalCallTime, ""), m_gs);
r = args.GetCellRect(12);
GUI.Label(r, item.frameCalls.ToString(), m_gs);
m_gs.normal.textColor = color;
}
protected void DrawToggle(Rect rect, TreeViewItem <TreeElementType> item, ref bool toggle, ref RowGUIArgs args)
{
Rect toggleRect = rect;
toggleRect.x = GetContentIndent(item);
toggleRect.width = toggleWidth;
// Hide when outside cell rect
if (toggleRect.xMax < rect.xMax)
{
toggle = EditorGUI.Toggle(toggleRect, toggle);
}
args.rowRect = rect;
base.RowGUI(args);
}
private void CellGUI(Rect cellRect, TreeViewItem item, ColumnType columnType, ref RowGUIArgs args)
{
CenterRectUsingSingleLineHeight(ref cellRect);
if (columnType != ColumnType.Name)
{
return;
}
args.rowRect = cellRect;
base.RowGUI(args);
}
void CellGUI(Rect cellRect, TreeViewItem <MyTreeElement> item, MyColumns column, ref RowGUIArgs args)
{
// Center cell rect vertically (makes it easier to place controls, icons etc in the cells)
CenterRectUsingSingleLineHeight(ref cellRect);
switch (column)
{
case MyColumns.Name:
{
// Do toggle
Rect toggleRect = cellRect;
toggleRect.x += GetContentIndent(item);
toggleRect.width = kToggleWidth;
if (toggleRect.xMax < cellRect.xMax)
{
// item.data.enabled = EditorGUI.Toggle(toggleRect, item.data.enabled); // hide when outside cell rect
// Default icon and label
args.rowRect = cellRect;
}
base.RowGUI(args);
}
break;
case MyColumns.Value1:
case MyColumns.Value2:
{
if (showControls)
{
cellRect.xMin += 5f; // When showing controls make some extra spacing
if (column == MyColumns.Value2)
{
item.data.eObject = (UnityEngine.Object)EditorGUI.ObjectField(cellRect, GUIContent.none, item.data.eObject, typeof(UnityEngine.Object), true);
}
if (column == MyColumns.Value1)
{
GUI.Label(cellRect, item.data.path);
}
}
}
break;
}
}
void CellGUI(Rect cellRect, TreeViewItem <CustomPackageManagerScopedRegistry> item, PackageColumn column, ref RowGUIArgs args)
{
CenterRectUsingSingleLineHeight(ref cellRect);
switch (column)
{
case PackageColumn.RegistryName:
{
GUI.Label(cellRect, item.data.RegistryName);
}
break;
case PackageColumn.URL:
{
GUI.Label(cellRect, item.data.URL);
}
break;
case PackageColumn.Scopes:
{
GUI.Label(cellRect, item.data.Scopes);
}
break;
}
}
protected override void RowGUI(RowGUIArgs args)
{
TreeNode node = treeQuery[args.item.id];
RowState state;
if (node.IsNull)
{
state = RowState.Error;
}
else if (node.IsPseudo)
{
state = RowState.Pseudo;
}
else
{
state = RowState.Normal;
}
GUIStyle style = GetStateGUIStyle(state, args.item);
bool hasIcon = node.icon != null;
if (OnionDataEditor.Setting.isRowGUIActive)
{
DrawNodeRowGUI();
}
DrawIcon();
DrawTitle();
DrawRightSideInfo();
DrawTagColor();
//Line
Rect lineRect = args.rowRect
.ExtendLeft(-GetContentIndent(args.item))
.ExtendUpToFit(1);
EditorGUI.DrawRect(lineRect, new Color(0.5f, 0.5f, 0.5f, 0.05F)); //線
void DrawNodeRowGUI()
{
const float leftSpace = 200F;
const float rightSpace = 40F;
if (Event.current.type == EventType.Repaint &&
args.rowRect.width < leftSpace + rightSpace)
{
return;
}
Rect rect = args.rowRect
.ExtendLeft(-leftSpace)
.ExtendRight(-rightSpace);
//EditorGUI.DrawRect(rect, new Color(1, 1, 1, 0.3F)); //For Debug
node.OnRowGUI?.Invoke(rect);
}
void DrawIcon()
{
const float padding = 1F;
if (hasIcon)
{
float iconHeight = args.rowRect.height - padding * 2;
Rect iconRect = new Rect(args.rowRect)
.ExtendLeft(-GetContentIndent(args.item))
.SetSize(iconHeight, iconHeight);
GUI.Label(iconRect, node.icon);
}
}
void DrawTitle()
{
Rect labelRect = new Rect(args.rowRect)
.ExtendLeft(-GetContentIndent(args.item))
.ExtendLeft(-(hasIcon ? (args.rowRect.height + 4F) : 2F));
GUI.Label(labelRect, node.displayName, style);
}
void DrawRightSideInfo()
{
bool isHideElementNodes = node.Flag.HasFlag(TreeNode.NodeFlag.HideElementNodes);
if (treeQuery[args.item.id].ChildCount > 0 || isHideElementNodes)
{
const float tagWidth = 40F;
Rect rightRect = new Rect(args.rowRect)
.ExtendLeft(-args.rowRect.width)
.ExtendLeft(tagWidth);
GUIStyle labelStyle = new GUIStyle(GUI.skin.label)
{
normal =
{
textColor = new Color(0.5F, 0.5F, 0.5F, 0.5F),
},
alignment = TextAnchor.MiddleCenter,
fontSize = 10,
padding = new RectOffset(0, 0, 0, 0),
border = new RectOffset(16, 16, 16, 16),
};
if (isHideElementNodes)
{
var icon = OnionDataEditor.GetIconTexture("HideElement");
GUI.color = new Color(1, 1, 1, 0.5F);
GUI.Label(
rightRect.ExtendLeft(-rightRect.width + rightRect.height).MoveLeft(8),
new GUIContent(icon, "Hide Elements"));
GUI.color = Color.white;
}
else
{
string displayTag = treeQuery[args.item.id].ChildCount.ToString();
GUI.Label(rightRect.ExtendHorizontal(-5).ExtendVertical(-2), $"[ {displayTag} ]", labelStyle);
}
}
}
void DrawTagColor()
{
if (node.tagColor.a > 0F)
{
const float colorTagWidth = 3F;
Rect colorTagRect = new Rect(args.rowRect)
.ExtendLeft(-args.rowRect.width)
.ExtendLeft(colorTagWidth)
.ExtendDown(-1);
EditorGUI.DrawRect(colorTagRect, node.tagColor);
}
}
}
private void CellGUI(Rect cellRect, UTinyEntityGroupTreeViewItem item, ColumnType columnType, ref RowGUIArgs args)
{
// Center cell rect vertically (makes it easier to place controls, icons etc in the cells)
CenterRectUsingSingleLineHeight(ref cellRect);
var entityGroup = item.EntityGroup.Dereference(Model.Registry);
using (new GUIEnabledScope(item.Editable))
{
switch (columnType)
{
case ColumnType.Icon:
{
GUI.DrawTexture(cellRect, null == entityGroup ? UTinyIcons.Warning : UTinyIcons.EntityGroup,
ScaleMode.ScaleToFit);
}
break;
case ColumnType.Name:
{
args.rowRect = cellRect;
using (new GUIColorScope(null == entityGroup ? Color.red : Color.white))
{
base.RowGUI(args);
}
}
break;
case ColumnType.Startup:
{
var mainModule = Model.MainModule.Dereference(Model.Registry);
if (entityGroup != null && mainModule.StartupEntityGroup.Equals(item.EntityGroup))
{
GUI.Label(cellRect, "X");
}
}
break;
case ColumnType.Module:
{
GUI.Label(cellRect, item.Module.Name);
}
break;
}
}
}
void CellGUI(Rect cellRect, TreeViewItem <PrefabsListElement> item, Columns column, ref RowGUIArgs args)
{
CenterRectUsingSingleLineHeight(ref cellRect);
Rect textRect = cellRect;
textRect.x += GetContentIndent(item);
textRect.xMax = cellRect.xMax - textRect.x;
switch (column)
{
case Columns.Name:
GUI.Label(textRect, item.data.prefabName);
break;
case Columns.ID:
if (item.data.rustID != 0)
{
GUI.Label(cellRect, item.data.rustID.ToString());
}
break;
}
}
void CellGUI(Rect cellRect, TreeViewItem <PrefabHierarchyElement> item, Columns column, ref RowGUIArgs args)
{
CenterRectUsingSingleLineHeight(ref cellRect);
switch (column)
{
case Columns.Name:
Rect textRect = cellRect;
textRect.x += GetContentIndent(item);
textRect.xMax = cellRect.xMax - textRect.x;
GUI.Label(cellRect, item.data.prefabName);
break;
case Columns.Type:
GUI.Label(cellRect, item.data.type);
break;
case Columns.Category:
GUI.Label(cellRect, item.data.category);
break;
case Columns.RustID:
GUI.Label(cellRect, item.data.rustID.ToString());
break;
}
}
private void CellGUI(Rect cellRect, BundleBuilderTreeViewItem item, int column, ref RowGUIArgs args)
{
// Center cell rect vertically (makes it easier to place controls, icons etc in the cells)
CenterRectUsingSingleLineHeight(ref cellRect);
switch (column)
{
case 0:
if (item.depth == 0)
{
var bundleInfo = (item as BundleBuilderTreeViewBundle).bundleInfo;
if (bundleInfo.type == Manifest.BundleType.AssetBundle)
{
GUI.DrawTexture(cellRect, kIconFavorite, ScaleMode.ScaleToFit);
}
else
{
GUI.DrawTexture(cellRect, kIconZipArchive, ScaleMode.ScaleToFit);
}
}
break;
case 1:
// Do toggle
var toggleRect = cellRect;
var indent = GetContentIndent(item);
toggleRect.x += indent;
toggleRect.width = kToggleWidth;
if (toggleRect.xMax < cellRect.xMax)
{
item.enabled = EditorGUI.Toggle(toggleRect, item.enabled); // hide when outside cell rect
}
// Default icon and label
args.rowRect = cellRect;
cellRect.xMin += indent + kToggleWidth + 2f;
if (item.depth == 0)
{
var bundleInfo = (item as BundleBuilderTreeViewBundle).bundleInfo;
if (string.IsNullOrEmpty(bundleInfo.note))
{
EditorGUI.LabelField(cellRect, bundleInfo.name);
}
else
{
EditorGUI.LabelField(cellRect, string.Format("{0} ({1})", bundleInfo.note, bundleInfo.name));
}
}
else if (item.depth == 1)
{
var target = (item as BundleBuilderTreeViewTarget).assetTarget;
if (target.targetPath.StartsWith("Assets/"))
{
var assetObject = AssetDatabase.LoadMainAssetAtPath(target.targetPath);
var newAssetObject = EditorGUI.ObjectField(cellRect, GUIContent.none, assetObject, typeof(Object), false);
if (newAssetObject != assetObject)
{
target.targetPath = newAssetObject != null?AssetDatabase.GetAssetPath(newAssetObject) : string.Empty;
_data.MarkAsDirty();
}
}
else
{
var oldColor = GUI.color;
var bundleInfo = (item.parent as BundleBuilderTreeViewBundle).bundleInfo;
if (bundleInfo.type == Manifest.BundleType.ZipArchive)
{
if (Directory.Exists(target.targetPath) || File.Exists(target.targetPath))
{
GUI.color = Color.yellow;
GUI.Label(cellRect, "<External>");
}
else
{
GUI.color = Color.red;
GUI.Label(cellRect, "<Invalid>");
}
}
else
{
GUI.color = Color.red;
GUI.Label(cellRect, "<Not Supported>");
}
GUI.color = oldColor;
}
}
else
{
base.RowGUI(args);
}
break;
case 2:
if (item.depth == 1)
{
var target = (item as BundleBuilderTreeViewTarget).assetTarget;
var newTargetPath = GUI.TextField(cellRect, target.targetPath);
if (newTargetPath != target.targetPath)
{
target.targetPath = newTargetPath;
_data.MarkAsDirty();
}
}
break;
case 3:
if (item.depth == 0)
{
var bundleInfo = (item as BundleBuilderTreeViewBundle).bundleInfo;
var popupWidth = (cellRect.width - 20f) * 0.5f;
cellRect.width = 20f;
var streamingAssets = EditorGUI.Toggle(cellRect, bundleInfo.streamingAssets);
if (streamingAssets != bundleInfo.streamingAssets)
{
bundleInfo.streamingAssets = streamingAssets;
_data.MarkAsDirty();
}
cellRect.x += cellRect.width;
cellRect.width = popupWidth;
var load = (Manifest.BundleLoad)EditorGUI.EnumPopup(cellRect, bundleInfo.load);
if (load != bundleInfo.load)
{
bundleInfo.load = load;
_data.MarkAsDirty();
}
cellRect.x += cellRect.width;
cellRect.width = popupWidth;
var type = (Manifest.BundleType)EditorGUI.EnumPopup(cellRect, bundleInfo.type);
if (type != bundleInfo.type)
{
bundleInfo.type = type;
_data.MarkAsDirty();
Reload();
}
}
else if (item.depth == 1)
{
}
break;
case 4:
if (item.depth == 0)
{
var bundleInfo = (item as BundleBuilderTreeViewBundle).bundleInfo;
var priority = EditorGUI.IntSlider(cellRect, bundleInfo.priority, 0, _data.priorityMax);
if (priority != bundleInfo.priority)
{
bundleInfo.priority = priority;
_data.MarkAsDirty();
}
}
else if (item.depth == 1)
{
}
break;
case 5:
if (item.depth == 0)
{
var bundleInfo = (item as BundleBuilderTreeViewBundle).bundleInfo;
var buildOrder = EditorGUI.IntField(cellRect, bundleInfo.buildOrder);
if (buildOrder != bundleInfo.buildOrder)
{
bundleInfo.buildOrder = buildOrder;
_data.MarkAsDirty();
}
}
break;
}
}
void CellGUI(Rect cellRect, TreeViewItem <MyTreeElement> item, MyColumns column, ref RowGUIArgs args)
{
// Center cell rect vertically (makes it easier to place controls, icons etc in the cells)
CenterRectUsingSingleLineHeight(ref cellRect);
switch (column)
{
case MyColumns.Icon1:
{
GUI.DrawTexture(cellRect, s_TestIcons[GetIcon1Index(item)], ScaleMode.ScaleToFit);
}
break;
case MyColumns.Icon2:
{
GUI.DrawTexture(cellRect, s_TestIcons[GetIcon2Index(item)], ScaleMode.ScaleToFit);
}
break;
case MyColumns.Name:
{
// Do toggle
Rect toggleRect = cellRect;
toggleRect.x += GetContentIndent(item);
toggleRect.width = kToggleWidth;
if (toggleRect.xMax < cellRect.xMax)
{
item.data.enabled = EditorGUI.Toggle(toggleRect, item.data.enabled); // hide when outside cell rect
}
// Default icon and label
args.rowRect = cellRect;
base.RowGUI(args);
}
break;
case MyColumns.Value1:
case MyColumns.Value2:
case MyColumns.Value3:
{
if (showControls)
{
cellRect.xMin += 5f; // When showing controls make some extra spacing
if (column == MyColumns.Value1)
{
item.data.floatValue1 = EditorGUI.Slider(cellRect, GUIContent.none, item.data.floatValue1, 0f, 1f);
}
if (column == MyColumns.Value2)
{
item.data.material = (Material)EditorGUI.ObjectField(cellRect, GUIContent.none, item.data.material, typeof(Material), false);
}
if (column == MyColumns.Value3)
{
item.data.text = GUI.TextField(cellRect, item.data.text);
}
}
else
{
string value = "Missing";
if (column == MyColumns.Value1)
{
value = item.data.floatValue1.ToString("f5");
}
if (column == MyColumns.Value2)
{
value = item.data.floatValue2.ToString("f5");
}
if (column == MyColumns.Value3)
{
value = item.data.floatValue3.ToString("f5");
}
DefaultGUI.LabelRightAligned(cellRect, value, args.selected, args.focused);
}
}
break;
case MyColumns.Button:
if (GUI.Button(cellRect, "Open"))
{
OpenProperties(item);
}
break;
}
}
void CellGUI(Rect cellRect, TreeViewItem <FeatureTreeElement> item, FeatureSubLayerColumns column, ref RowGUIArgs args)
{
// Center cell rect vertically (makes it easier to place controls, icons etc in the cells)
if (Layers == null || Layers.arraySize == 0)
{
return;
}
if (Layers.arraySize <= args.item.id - uniqueId)
{
return;
}
var layer = Layers.GetArrayElementAtIndex(args.item.id - uniqueId);
CenterRectUsingSingleLineHeight(ref cellRect);
if (column == FeatureSubLayerColumns.Name)
{
Rect toggleRect = cellRect;
toggleRect.x += GetContentIndent(item);
toggleRect.width = kToggleWidth;
EditorGUI.BeginChangeCheck();
item.data.isActive = layer.FindPropertyRelative("coreOptions.isActive").boolValue;
if (toggleRect.xMax < cellRect.xMax)
{
item.data.isActive = EditorGUI.Toggle(toggleRect, item.data.isActive); // hide when outside cell rect
}
layer.FindPropertyRelative("coreOptions.isActive").boolValue = item.data.isActive;
if (EditorGUI.EndChangeCheck())
{
VectorSubLayerProperties vectorSubLayerProperties = (VectorSubLayerProperties)EditorHelper.GetTargetObjectOfProperty(layer);
EditorHelper.CheckForModifiedProperty(layer, vectorSubLayerProperties.coreOptions);
}
cellRect.xMin += nameOffset; // Adding some gap between the checkbox and the name
args.rowRect = cellRect;
layer.FindPropertyRelative("coreOptions.sublayerName").stringValue = item.data.Name;
//This draws the name property
base.RowGUI(args);
}
if (column == FeatureSubLayerColumns.Type)
{
cellRect.xMin += 15f; // Adding some gap between the checkbox and the name
var typeString = ((PresetFeatureType)layer.FindPropertyRelative("presetFeatureType").intValue).ToString();
item.data.Type = typeString;
EditorGUI.LabelField(cellRect, item.data.Type, columnStyle);
}
}
protected override void RowGUI(RowGUIArgs args)
{
GameObject go = GetGameObjectFromInstanceID(args.item.id);
if (!go)
{
base.RowGUI(args);
return;
}
bool goActive = go.activeInHierarchy;
GUIStyle style;
if (goActive)
{
#if UNITY_2018_3_OR_NEWER
switch (PrefabUtility.GetPrefabInstanceStatus(go))
{
case PrefabInstanceStatus.MissingAsset: style = GameObjectStyles.brokenPrefabLabel; break;
case PrefabInstanceStatus.Connected: style = GameObjectStyles.prefabLabel; break;
default: style = DefaultStyles.foldoutLabel; break;
}
#else
switch (PrefabUtility.GetPrefabType(go))
{
case PrefabType.MissingPrefabInstance: style = GameObjectStyles.brokenPrefabLabel; break;
case PrefabType.ModelPrefabInstance:
case PrefabType.PrefabInstance: style = GameObjectStyles.prefabLabel; break;
default: style = DefaultStyles.foldoutLabel; break;
}
#endif
}
else
{
#if UNITY_2018_3_OR_NEWER
switch (PrefabUtility.GetPrefabInstanceStatus(go))
{
case PrefabInstanceStatus.MissingAsset: style = GameObjectStyles.disabledBrokenPrefabLabel; break;
case PrefabInstanceStatus.Connected: style = GameObjectStyles.disabledPrefabLabel; break;
default: style = GameObjectStyles.disabledLabel; break;
}
#else
switch (PrefabUtility.GetPrefabType(go))
{
case PrefabType.MissingPrefabInstance: style = GameObjectStyles.disabledBrokenPrefabLabel; break;
case PrefabType.ModelPrefabInstance:
case PrefabType.PrefabInstance: style = GameObjectStyles.disabledPrefabLabel; break;
default: style = GameObjectStyles.disabledLabel; break;
}
#endif
}
Rect rect = args.rowRect;
rect.x += GetContentIndent(args.item);
#if UNITY_2018_3_OR_NEWER
Texture2D icon = args.item.icon;
if (icon)
{
Color iconTint = goActive ? Color.white : new Color(1f, 1f, 1f, 0.5f);
Rect iconRect = rect;
iconRect.width = 16f;
#if UNITY_2019_3_OR_NEWER
if (args.selected && args.focused && selectedIconGetter != null)
{
icon = selectedIconGetter.Invoke(null, new object[] { icon }) as Texture2D;
if (!icon)
{
icon = args.item.icon;
}
}
#endif
GUI.DrawTexture(iconRect, icon, ScaleMode.ScaleToFit, true, 0f, iconTint, 0f, 0f);
if (PrefabUtility.IsAddedGameObjectOverride(go))
{
GUI.DrawTexture(iconRect, EditorGUIUtility.Load("PrefabOverlayAdded Icon") as Texture, ScaleMode.ScaleToFit, true, 0f, iconTint, 0f, 0f);
}
rect.x += iconRect.width + 2f;
}
#endif
if (Event.current.type == EventType.Repaint)
{
style.Draw(rect, args.label, false, false, args.selected, args.focused);
}
}
private void CellGUI(Rect cellRect, UTinyModuleTreeViewItem item, ColumnType columnType, ref RowGUIArgs args)
{
// Center cell rect vertically (makes it easier to place controls, icons etc in the cells)
CenterRectUsingSingleLineHeight(ref cellRect);
using (new GUIEnabledScope(item.Status != UTinyModuleTreeViewItem.StatusType.Self &&
(item.Status != UTinyModuleTreeViewItem.StatusType.IncludedRequired)))
{
var moduleReference = item.Module;
var module = item.Module.Dereference(Model.Registry);
switch (columnType)
{
case ColumnType.Icon:
{
GUI.DrawTexture(cellRect, null == module ? UTinyIcons.Warning : UTinyIcons.Module,
ScaleMode.ScaleToFit);
}
break;
case ColumnType.Name:
{
var toggleRect = cellRect;
toggleRect.x += GetContentIndent(item);
toggleRect.width = 18;
EditorGUI.BeginChangeCheck();
item.Included = EditorGUI.Toggle(toggleRect, item.Included);
if (EditorGUI.EndChangeCheck())
{
ShowConfigurationInspector();
Reload();
}
args.rowRect = cellRect;
using (new GUIColorScope(null == module ? Color.red : Color.white))
{
base.RowGUI(args);
}
}
break;
case ColumnType.Status:
{
string status;
switch (item.Status)
{
case UTinyModuleTreeViewItem.StatusType.Self:
status = "";
break;
case UTinyModuleTreeViewItem.StatusType.Excluded:
status = "Excluded";
break;
case UTinyModuleTreeViewItem.StatusType.IncludedRequired:
status = "Included (Required)";
break;
case UTinyModuleTreeViewItem.StatusType.IncludedExplicit:
status = "Included (Explicit)";
break;
case UTinyModuleTreeViewItem.StatusType.IncludedImplicit:
status = "Included (Implicit)";
break;
default:
throw new ArgumentOutOfRangeException();
}
using (new GUIColorScope(item.Status != UTinyModuleTreeViewItem.StatusType.Excluded
? item.Status != UTinyModuleTreeViewItem.StatusType.IncludedImplicit ?
Color.green
: Color.cyan
: Color.white))
{
GUI.Label(cellRect, status);
}
}
break;
case ColumnType.Dependencies:
{
var @string = "";
if (module != null)
{
for (var i = 0; i < module.Dependencies.Count; i++)
{
var @ref = module.Dependencies[i];
var m = @ref.Dereference(Model.Registry);
if (i > 0)
{
@string += ", ";
}
if (null == m)
{
@string += $"{@ref.Name} (missing)";
}
else
{
@string += m.Name;
}
}
}
GUI.Label(cellRect, @string);
}
break;
case ColumnType.ReferencedBy:
{
var modules = UTinyModule.GetExplicitDependantModules(Model.Registry, moduleReference).Where(m => !m.IsProjectModule);
var @string = string.Join(", ", modules.Select(m => m.Name).ToArray());
GUI.Label(cellRect, @string);
}
break;
case ColumnType.Description:
{
if (module != null)
{
EditorGUI.LabelField(cellRect, module.Documentation.Summary);
}
}
break;
}
}
}
// Custom GUI
protected virtual void RowGUI(RowGUIArgs args)
{
m_GUI.DefaultRowGUI(args);
}
private string GetItemcontent(RowGUIArgs args, int column)
{
if (m_AllCanvasesItem != null && args.item.id == m_AllCanvasesItem.id)
{
switch ((Column)column)
{
case Column.TotalBatchCount:
return(m_AllCanvasesItem.totalBatchCount.ToString());
case Column.TotalVertexCount:
return(m_AllCanvasesItem.totalVertexCount.ToString());
case Column.GameObjectCount:
return(m_AllCanvasesItem.gameObjectCount.ToString());
default:
return(null);
}
}
var batchItem = args.item as BatchTreeViewItem;
if (batchItem != null)
{
var info = batchItem.info;
switch ((Column)column)
{
case Column.VertexCount:
return(info.vertexCount.ToString());
case Column.TotalVertexCount:
return(info.totalVertexCount.ToString());
case Column.BatchBreakingReason:
if (info.batchBreakingReason != BatchBreakingReason.NoBreaking)
{
return(FormatBatchBreakingReason(info));
}
break;
case Column.GameObjectCount:
return(info.instanceIDsCount.ToString());
case Column.InstanceIds:
if (batchItem.instanceIDs.Length <= 5)
{
StringBuilder sb = new StringBuilder();
for (int i = 0; i < batchItem.instanceIDs.Length; i++)
{
if (i != 0)
{
sb.Append(", ");
}
int iid = batchItem.instanceIDs[i];
var o = EditorUtility.InstanceIDToObject(iid);
if (o == null)
{
sb.Append(iid);
}
else
{
sb.Append(o.name);
}
}
return(sb.ToString());
}
return(string.Format("{0} objects", batchItem.instanceIDs.Length));
case Column.Element:
case Column.BatchCount:
case Column.TotalBatchCount:
break;
case Column.Rerender:
return(info.renderDataIndex.ToString());
default:
return("Missing");
}
return(null);
}
var canvasItem = args.item as CanvasTreeViewItem;
if (canvasItem != null)
{
UISystemProfilerInfo info = canvasItem.info;
switch ((Column)column)
{
case Column.BatchCount:
return(info.batchCount.ToString());
case Column.TotalBatchCount:
return(info.totalBatchCount.ToString());
case Column.TotalVertexCount:
return(info.totalVertexCount.ToString());
case Column.GameObjectCount:
return(info.instanceIDsCount.ToString());
case Column.VertexCount:
case Column.BatchBreakingReason:
case Column.InstanceIds:
case Column.Element:
break;
case Column.Rerender:
return(info.renderDataIndex + " : " + info.renderDataCount);
default:
return("Missing");
}
return(null);
}
return(null);
}
void CellGUI(Rect cellRect, TreeViewItem <SaveEditorTreeElement> item, MyColumns column, ref RowGUIArgs args)
{
// Center cell rect vertically (makes it easier to place controls, icons etc in the cells)
CenterRectUsingSingleLineHeight(ref cellRect);
switch (column)
{
case MyColumns.Name:
{
// Default icon and label
args.rowRect = cellRect;
if (item.data.setName != null && showControls)
{
var offset = 25 * item.depth;
var fieldRect = new Rect(offset, cellRect.y, cellRect.width - offset, cellRect.height);
try{
DrawGuiForValues(
fieldRect,
item.data.nameValue.GetType(),
ref item.data.nameValue,
ref item.data.originalNameValue,
ref item.data.m_Name,
ref item.data.isValidNameValue,
item.data.setName,
item.data
);
}catch (Exception e) {
Debug.LogError(e);
}
}
else
{
base.RowGUI(args);
}
}
break;
case MyColumns.Value:
{
if (!showControls)
{
string value = "";
if (item.data.valueType.IsGenericType)
{
value = GetCSharpRepresentation(item.data.valueType, true);
}
else
{
value = item.data.value.ToString();
}
GUI.Label(cellRect, value);
}
else
{
cellRect.xMin += 5f; // When showing controls make some extra spacing
if (item.data == null)
{
Debug.LogWarning("Item with null data: " + item.displayName);
return;
}
DrawGuiForValues(
cellRect,
item.data.valueType,
ref item.data.value,
ref item.data.originalValue,
ref item.data.editorStrValue,
ref item.data.isValidValue,
item.data.setValue,
item.data
);
}
}
break;
case MyColumns.Controls:
{
var buttonStyle = new GUIStyle("miniButton");
buttonStyle.fixedWidth = 20f;
const float buttonMargin = 5f;
int numButtons = 0;
Rect NextButton()
{
var mv = buttonStyle.fixedWidth + buttonMargin;
var ret = new Rect(cellRect.x + (mv * numButtons), cellRect.y, buttonStyle.fixedWidth, cellRect.height);
numButtons++;
return(ret);
}
if (GUI.Button(NextButton(), new GUIContent("x", "Set to default"), buttonStyle))
{
RemoveItemsChildrenFromTree(item);
var def = GetDefault(item.data.valueType);
item.data.setValue(item.data.value, def, item.data);
item.data.value = def;
item.data.editorStrValue = item.data.value == null ? "null" : item.data.value.ToString();
}
//remove from array/list
// var parentType = item.data.parent != null ? ((SaveEditorTreeElement)item.data.parent).valueType : null;
if (item.data.removeValueFromParent != null)
{
if (GUI.Button(NextButton(), new GUIContent("-", "Remove from collection"), buttonStyle))
{
item.data.removeValueFromParent(item.data);
RemoveItemsChildrenFromTree(item);
RemoveItemFromTree(item);
if (item.data.needsSiblingRename)
{
RenameChildren(item.parent as TreeViewItem <SaveEditorTreeElement>);
}
Reload();
}
}
//Add new element to collection
if (item.data.addToCollection != null)
{
if (GUI.Button(NextButton(), new GUIContent("+", "Add item to collection"), buttonStyle))
{
AddItemToCollection(item);
}
}
}
break;
}
}
void CellGUI(Rect cellRect, AssetEntryTreeViewItem item, int column, ref RowGUIArgs args)
{
CenterRectUsingSingleLineHeight(ref cellRect);
switch ((ColumnId)column)
{
case ColumnId.Id:
{
// The rect is assumed indented and sized after the content when pinging
float indent = GetContentIndent(item) + extraSpaceBeforeIconAndLabel;
cellRect.xMin += indent;
if (Event.current.type == EventType.Repaint)
{
m_LabelStyle.Draw(cellRect, item.entry.address, false, false, args.selected, args.focused);
}
}
break;
case ColumnId.Path:
if (Event.current.type == EventType.Repaint)
{
var path = item.entry.AssetPath;
if (string.IsNullOrEmpty(path))
{
path = "Missing File";
}
m_LabelStyle.Draw(cellRect, path, false, false, args.selected, args.focused);
}
break;
case ColumnId.Type:
if (item.assetIcon != null)
{
UnityEngine.GUI.DrawTexture(cellRect, item.assetIcon, ScaleMode.ScaleToFit, true);
}
break;
case ColumnId.Labels:
if (EditorGUI.DropdownButton(cellRect, new GUIContent(m_Editor.settings.labelTable.GetString(item.entry.labels, cellRect.width)), FocusType.Passive))
{
var selection = GetItemsForContext(args.item.id);
Dictionary <string, int> labelCounts = new Dictionary <string, int>();
List <AddressableAssetEntry> entries = new List <AddressableAssetEntry>();
var newSelection = new List <int>();
foreach (var s in selection)
{
var aeItem = FindItem(s, rootItem) as AssetEntryTreeViewItem;
if (aeItem == null || aeItem.entry == null)
{
continue;
}
entries.Add(aeItem.entry);
newSelection.Add(s);
foreach (var label in aeItem.entry.labels)
{
int count;
labelCounts.TryGetValue(label, out count);
count++;
labelCounts[label] = count;
}
}
SetSelection(newSelection);
PopupWindow.Show(cellRect, new LabelMaskPopupContent(m_Editor.settings, entries, labelCounts));
}
break;
}
}
private void DrawNameCell(Rect cellRect, TreeViewItem item, ref RowGUIArgs args)
{
CenterRectUsingSingleLineHeight(ref cellRect);
args.rowRect = cellRect;
base.RowGUI(args);
}
private void CellGUI(Rect cellRect, AssetProcessEventListTreeItem item, int column, ref RowGUIArgs args)
{
Color oldColor = GUI.color;
CenterRectUsingSingleLineHeight(ref cellRect);
var assetGuid = item.Event.AssetGuid;
var assetPath = AssetDatabase.GUIDToAssetPath(assetGuid);
var isAssetAvailable = string.IsNullOrEmpty(assetPath);
var graphGuid = item.Event.GraphGuid;
var graphPath = AssetDatabase.GUIDToAssetPath(graphGuid);
var hasGraph = !string.IsNullOrEmpty(graphPath);
var isError = item.Event.Kind == AssetProcessEvent.EventKind.Error;
switch (column)
{
case 0://Error?
{
var iconRect = new Rect(cellRect.x, cellRect.y - 6, 32, 32);
GUI.DrawTexture(iconRect, ((isError)? m_errorIcon:m_infoIcon));
}
break;
case 1://Asset
{
Texture2D icon = null;
if (!isAssetAvailable)
{
icon = AssetDatabase.GetCachedIcon(assetPath) as Texture2D;
}
var iconRect = new Rect(cellRect.x + 1, cellRect.y + 1, cellRect.height - 2, cellRect.height - 2);
if (icon != null)
{
GUI.DrawTexture(iconRect, icon, ScaleMode.ScaleToFit);
}
DefaultGUI.Label(
new Rect(cellRect.x + iconRect.width + 4, cellRect.y, cellRect.width - iconRect.width, cellRect.height),
(!isAssetAvailable)? Path.GetFileName(assetPath) : $"{item.Event.AssetName} (Removed)",
args.selected,
args.focused);
}
break;
case 2://Graph
if (hasGraph)
{
DefaultGUI.Label(cellRect, $"{Path.GetFileNameWithoutExtension(graphPath)}.{item.Event.NodeName}", args.selected, args.focused);
}
break;
}
GUI.color = oldColor;
}
protected override void DrawCell(ref Rect cellRect, MaintainerTreeViewItem <T> genericItem, int columnValue, RowGUIArgs args)
{
base.DrawCell(ref cellRect, genericItem, columnValue, args);
var column = (Columns)columnValue;
var item = (HierarchyReferencesTreeViewItem <T>)genericItem;
switch (column)
{
case Columns.Icon:
if (item.depth == 0)
{
if (item.icon != null)
{
var iconRect = cellRect;
iconRect.width = IconWidth;
iconRect.height = EditorGUIUtility.singleLineHeight;
GUI.DrawTexture(iconRect, item.icon, ScaleMode.ScaleToFit);
}
}
break;
case Columns.GameObject:
var entryRect = cellRect;
entryRect.xMin += baseIndent + UIHelpers.EyeButtonPadding;
if (item.depth == 1)
{
if (item.icon != null)
{
var iconRect = entryRect;
iconRect.xMin -= UIHelpers.EyeButtonSize - UIHelpers.EyeButtonPadding;
iconRect.width = IconWidth;
iconRect.x += IconPadding;
iconRect.height = EditorGUIUtility.singleLineHeight;
GUI.DrawTexture(iconRect, item.icon, ScaleMode.ScaleToFit);
}
}
else
{
/*entryRect.xMin += baseIndent + UIHelpers.EyeButtonPadding;*/
}
Rect lastRect;
var eyeButtonRect = entryRect;
eyeButtonRect.xMin += IconPadding;
eyeButtonRect.width = UIHelpers.EyeButtonSize;
eyeButtonRect.height = UIHelpers.EyeButtonSize;
eyeButtonRect.x += UIHelpers.EyeButtonPadding;
lastRect = eyeButtonRect;
if (UIHelpers.IconButton(eyeButtonRect, CSIcons.Show))
{
ShowItem(item);
}
var labelRect = entryRect;
labelRect.xMin = lastRect.xMax + UIHelpers.EyeButtonPadding;
if (item.data.depth == 0 && !item.data.HasChildren)
{
GUI.contentColor = CSColors.labelDimmedColor;
}
DefaultGUI.Label(labelRect, args.label, args.selected, args.focused);
GUI.contentColor = Color.white;
break;
case Columns.Component:
var componentName = item.data.reference.componentName;
if (!string.IsNullOrEmpty(componentName))
{
DefaultGUI.Label(cellRect, componentName, args.selected, args.focused);
}
break;
case Columns.Property:
var propertyPath = item.data.reference.propertyPath;
if (!string.IsNullOrEmpty(propertyPath))
{
DefaultGUI.Label(cellRect, propertyPath, args.selected, args.focused);
}
break;
case Columns.ReferencesCount:
if (item.depth == 0)
{
DefaultGUI.Label(cellRect, item.data.ChildrenCount.ToString(), args.selected, args.focused);
}
break;
default:
throw new ArgumentOutOfRangeException("column", column, null);
}
}
protected abstract void DrawColumn(Rect cellRect, TreeViewItem <TreeElementType> item, ColumnType column, ref RowGUIArgs args);
private void CellGUI(Rect cellRect, UTinyAssetTreeViewItem item, ColumnType columnType, ref RowGUIArgs args)
{
// Center cell rect vertically (makes it easier to place controls, icons etc in the cells)
CenterRectUsingSingleLineHeight(ref cellRect);
var @object = item.AssetInfo.Object;
var name = item.AssetInfo.Name;
var isUnique = m_AssetNames.Count(s => string.Equals(s, name)) <= 1;
using (new GUIColorScope(isUnique ? Color.white : Color.red))
using (new GUIEnabledScope(item.Editable))
{
var content = EditorGUIUtility.ObjectContent(null, @object.GetType());
switch (columnType)
{
case ColumnType.Icon:
{
if (item.AssetInfo.Parent == null)
{
GUI.DrawTexture(cellRect, content.image, ScaleMode.ScaleToFit);
}
}
break;
case ColumnType.Name:
{
args.rowRect = cellRect;
base.RowGUI(args);
}
break;
case ColumnType.Path:
{
GUI.Label(cellRect, item.AssetInfo.AssetPath);
}
break;
case ColumnType.Type:
{
GUI.Label(cellRect, @object.GetType().Name);
}
break;
case ColumnType.Status:
{
var status = item.AssetInfo.IncludedExplicitly ? "Explicit" : "Implicit";
using (new GUIColorScope(item.AssetInfo.IncludedExplicitly ? Color.green : Color.white))
{
GUI.Label(cellRect, status);
}
}
break;
case ColumnType.References:
{
GUI.Label(cellRect, item.AssetInfo.ImplicitReferences.Count.ToString());
}
break;
}
}
if (Event.current.type == EventType.MouseDrag && cellRect.Contains(Event.current.mousePosition))
{
DragAndDrop.PrepareStartDrag();
DragAndDrop.objectReferences = new[] { item.AssetInfo.Object };
DragAndDrop.StartDrag("Dragging sprite");
Event.current.Use();
}
}
void DrawNameCell(Rect cellRect, TreeViewItem item, ref RowGUIArgs args)
{
args.rowRect = cellRect;
base.RowGUI(args);
}
void CellGUI(Rect cellRect, FrameDataTreeViewItem item, bool needsIndent, int column, ref RowGUIArgs args)
{
if (needsIndent)
{
var indent = GetContentIndent(item) + extraSpaceBeforeIconAndLabel;
cellRect.xMin += indent;
}
CenterRectUsingSingleLineHeight(ref cellRect);
var content = GUIContent.Temp(item.columnStrings[column], string.Empty);
DefaultStyles.label.Draw(cellRect, content, false, false, args.selected, args.focused);
}
protected override void EnabledGUI(Rect cellRect, SerializedNodeInfo node, ref RowGUIArgs args)
{
var serializedNode = node;
EditorGUI.BeginDisabled(serializedNode.m_State == SerializedNodeInfo.State.Disabled);
base.EnabledGUI(cellRect, node, ref args);
EditorGUI.EndDisabled();
}
protected virtual void NameGUI(Rect position, T node, ref RowGUIArgs args)
{
args.rowRect = position;
base.RowGUI(args);
}
