/// <summary> /// OnGUI implementation for ValueTuple DebugUIDrawer. /// </summary> /// <param name="widget">DebugUI Widget.</param> /// <param name="state">Debug State associated with the Debug Item.</param> /// <returns>The state of the widget.</returns> public override bool OnGUI(DebugUI.Widget widget, DebugState state) { var w = Cast <DebugUI.ValueTuple>(widget); var labelRect = PrepareControlRect(); EditorGUI.PrefixLabel(labelRect, EditorGUIUtility.TrTextContent(w.displayName)); // Following layout should match DebugUIDrawerFoldout to make column labels align Rect drawRect = GUILayoutUtility.GetLastRect(); int indent = EditorGUI.indentLevel; EditorGUI.indentLevel = 0; //be at left of rects for (int i = 0; i < w.numElements; i++) { var columnRect = drawRect; columnRect.x += EditorGUIUtility.labelWidth + i * DebugWindow.Styles.foldoutColumnWidth; columnRect.width = DebugWindow.Styles.foldoutColumnWidth; var value = w.values[i].GetValue(); EditorGUI.LabelField(columnRect, w.values[i].FormatString(value)); } EditorGUI.indentLevel = indent; return(true); }
/// <summary> /// OnGUI implementation for ObjectPopup DebugUIDrawer. /// </summary> /// <param name="widget">DebugUI Widget.</param> /// <param name="state">Debug State associated with the Debug Item.</param> /// <returns>If the UI can be drawn</returns> public override bool OnGUI(DebugUI.Widget widget, DebugState state) { var w = Cast <DebugUI.ObjectPopupField>(widget); var s = Cast <DebugStateObject>(state); var rect = PrepareControlRect(); rect = EditorGUI.PrefixLabel(rect, EditorGUIUtility.TrTextContent(widget.displayName, w.tooltip)); var elements = w.getObjects(); if (elements?.Any() ?? false) { var selectedValue = w.GetValue(); var elementsArrayNames = elements.Select(e => e.name).ToArray(); var elementsArrayIndices = Enumerable.Range(0, elementsArrayNames.Length).ToArray(); var selectedIndex = selectedValue != null?Array.IndexOf(elementsArrayNames, selectedValue.name) : 0; var newSelectedIndex = EditorGUI.IntPopup(rect, selectedIndex, elementsArrayNames, elementsArrayIndices); if (selectedIndex != newSelectedIndex) { Apply(w, s, elements.ElementAt(newSelectedIndex)); } } else { EditorGUI.LabelField(rect, "Can't draw an empty enumeration."); } return(true); }
internal override void SetWidget(DebugUI.Widget widget) { base.SetWidget(widget); m_Field = CastWidget <DebugUI.ColorField>(); m_Container = GetComponent <DebugUIHandlerContainer>(); nameLabel.text = m_Field.displayName; fieldR.getter = () => m_Field.GetValue().r; fieldR.setter = x => SetValue(x, r: true); fieldR.nextUIHandler = fieldG; SetupSettings(fieldR); fieldG.getter = () => m_Field.GetValue().g; fieldG.setter = x => SetValue(x, g: true); fieldG.previousUIHandler = fieldR; fieldG.nextUIHandler = fieldB; SetupSettings(fieldG); fieldB.getter = () => m_Field.GetValue().b; fieldB.setter = x => SetValue(x, b: true); fieldB.previousUIHandler = fieldG; fieldB.nextUIHandler = m_Field.showAlpha ? fieldA : null; SetupSettings(fieldB); fieldA.gameObject.SetActive(m_Field.showAlpha); fieldA.getter = () => m_Field.GetValue().a; fieldA.setter = x => SetValue(x, a: true); fieldA.previousUIHandler = fieldB; SetupSettings(fieldA); UpdateColor(); }
internal override void SetWidget(DebugUI.Widget widget) { base.SetWidget(widget); m_Field = CastWidget <DebugUI.BitField>(); m_Container = GetComponent <DebugUIHandlerContainer>(); nameLabel.text = m_Field.displayName; int toggleIndex = 0; foreach (var enumName in m_Field.enumNames) { if (toggleIndex >= toggles.Count) { continue; } var toggle = toggles[toggleIndex]; toggle.getter = GetValue; toggle.setter = SetValue; toggle.nextUIHandler = toggleIndex < (m_Field.enumNames.Length - 1) ? toggles[toggleIndex + 1] : null; toggle.previousUIHandler = toggleIndex > 0 ? toggles[toggleIndex - 1] : null; toggle.parentUIHandler = this; toggle.index = toggleIndex; toggle.nameLabel.text = enumName.text; toggle.Init(); toggleIndex++; } ; for (; toggleIndex < toggles.Count; ++toggleIndex) { toggles[toggleIndex].transform.SetParent(null); } }
internal override void SetWidget(DebugUI.Widget widget) { m_Widget = widget; m_Field = CastWidget <DebugUI.ValueTuple>(); nameLabel.text = m_Field.displayName; Debug.Assert(m_Field.numElements > 0); int numElements = m_Field.numElements; valueElements = new Text[numElements]; valueElements[0] = valueLabel; float columnOffset = k_XOffset / (float)numElements; for (int index = 1; index < numElements; ++index) { var valueElement = Instantiate(valueLabel.gameObject, transform); valueElement.AddComponent <LayoutElement>().ignoreLayout = true; var rectTransform = valueElement.transform as RectTransform; var originalTransform = nameLabel.transform as RectTransform; rectTransform.anchorMax = rectTransform.anchorMin = new Vector2(0, 1); rectTransform.sizeDelta = new Vector2(100, 26); Vector3 pos = originalTransform.anchoredPosition; pos.x += (index + 1) * columnOffset + 200f; rectTransform.anchoredPosition = pos; rectTransform.pivot = new Vector2(0, 1); valueElements[index] = valueElement.GetComponent <Text>(); } }
internal override void SetWidget(DebugUI.Widget widget) { base.SetWidget(widget); m_Value = CastWidget <DebugUI.ProgressBarValue>(); nameLabel.text = m_Value.displayName; UpdateValue(); }
internal override void SetWidget(DebugUI.Widget widget) { base.SetWidget(widget); m_Field = CastWidget <DebugUI.Vector4Field>(); m_Container = GetComponent <DebugUIHandlerContainer>(); nameLabel.text = m_Field.displayName; fieldX.getter = () => m_Field.GetValue().x; fieldX.setter = x => SetValue(x, x: true); fieldX.nextUIHandler = fieldY; SetupSettings(fieldX); fieldY.getter = () => m_Field.GetValue().y; fieldY.setter = x => SetValue(x, y: true); fieldY.previousUIHandler = fieldX; fieldY.nextUIHandler = fieldZ; SetupSettings(fieldY); fieldZ.getter = () => m_Field.GetValue().z; fieldZ.setter = x => SetValue(x, z: true); fieldZ.previousUIHandler = fieldY; fieldZ.nextUIHandler = fieldW; SetupSettings(fieldZ); fieldW.getter = () => m_Field.GetValue().w; fieldW.setter = x => SetValue(x, w: true); fieldW.previousUIHandler = fieldZ; SetupSettings(fieldW); }
void OnWidgetGUI(DebugUI.Widget widget) { if (widget.isRuntimeOnly) { return; } DebugState state; // State will be null for stateless widget m_WidgetStates.TryGetValue(widget.queryPath, out state); DebugUIDrawer drawer; if (!s_WidgetDrawerMap.TryGetValue(widget.GetType(), out drawer)) { EditorGUILayout.LabelField("Drawer not found (" + widget.GetType() + ")."); } else { drawer.Begin(widget, state); if (drawer.OnGUI(widget, state)) { var container = widget as DebugUI.IContainer; if (container != null) { TraverseContainerGUI(container); } } drawer.End(widget, state); } }
public override void Begin(DebugUI.Widget widget, DebugState state) { var w = Cast <DebugUI.Foldout>(widget); var s = Cast <DebugStateBool>(state); EditorGUI.BeginChangeCheck(); Rect rect = PrepareControlRect(); bool value = EditorGUI.Foldout(rect, w.GetValue(), EditorGUIUtility.TrTextContent(w.displayName), true); Rect drawRect = GUILayoutUtility.GetLastRect(); if (w.columnLabels != null && value) { const int oneColumnWidth = 60; int indent = EditorGUI.indentLevel; EditorGUI.indentLevel = 0; //be at left of rects for (int i = 0; i < w.columnLabels.Length; i++) { var columnRect = drawRect; columnRect.x += EditorGUIUtility.labelWidth + i * oneColumnWidth; columnRect.width = oneColumnWidth; EditorGUI.LabelField(columnRect, w.columnLabels[i] ?? "", EditorStyles.miniBoldLabel); } EditorGUI.indentLevel = indent; } if (EditorGUI.EndChangeCheck()) { Apply(w, s, value); } EditorGUI.indentLevel++; }
internal override void SetWidget(DebugUI.Widget widget) { base.SetWidget(widget); m_Field = CastWidget <DebugUI.BitField>(); m_Container = GetComponent <DebugUIHandlerContainer>(); nameLabel.text = m_Field.displayName; int toggleIndex = 0; foreach (var enumName in m_Field.enumNames) { if (toggleIndex >= toggles.Count) { continue; } var toggle = toggles[toggleIndex]; toggle.getter = GetValue; toggle.setter = SetValue; toggle.nextUIHandler = toggleIndex < (m_Field.enumNames.Length - 1) ? toggles[toggleIndex + 1] : null; toggle.previousUIHandler = toggleIndex > 0 ? toggles[toggleIndex - 1] : null; toggle.parentUIHandler = this; toggle.index = toggleIndex; toggle.nameLabel.text = enumName.text; toggle.Init(); toggleIndex++; } // Destroy the remaining toggles outside of the range of the displayed enum. for (; toggleIndex < toggles.Count; ++toggleIndex) { CoreUtils.Destroy(toggles[toggleIndex].gameObject); toggles[toggleIndex] = null; } }
public override bool OnGUI(DebugUI.Widget widget, DebugState state) { var w = Cast <DebugUI.EnumField>(widget); var s = Cast <DebugStateInt>(state); EditorGUI.BeginChangeCheck(); int value = w.GetValue(); if (w.enumNames == null || w.enumValues == null) { EditorGUILayout.LabelField("Can't draw an empty enumeration."); } else { var rect = PrepareControlRect(); int index = Array.IndexOf(w.enumValues, w.GetValue()); // Fallback just in case, we may be handling sub/sectionned enums here if (index < 0) { value = w.enumValues[0]; } value = EditorGUI.IntPopup(rect, CoreEditorUtils.GetContent(w.displayName), value, w.enumNames, w.enumValues); } if (EditorGUI.EndChangeCheck()) { Apply(w, s, value); } return(true); }
internal override void SetWidget(DebugUI.Widget widget) { base.SetWidget(widget); m_Field = CastWidget <DebugUI.EnumField>(); nameLabel.text = m_Field.displayName; UpdateValueLabel(); }
public override bool OnGUI(DebugUI.Widget widget, DebugState state) { var w = Cast <DebugUI.EnumField>(widget); var s = Cast <DebugStateInt>(state); EditorGUI.BeginChangeCheck(); int value = s.value; if (w.enumNames == null || w.enumValues == null) { EditorGUILayout.LabelField("Can't draw an empty enumeration."); } else { var rect = PrepareControlRect(); value = EditorGUI.IntPopup(rect, CoreEditorUtils.GetContent(w.displayName), s.value, w.enumNames, w.enumValues); } if (EditorGUI.EndChangeCheck()) { Apply(w, s, value); } return(true); }
/// <summary> /// OnGUI implementation for Bitfield DebugUIDrawer. /// </summary> /// <param name="widget">DebugUI Widget.</param> /// <param name="state">Debug State associated with the Debug Item.</param> /// <returns>The state of the widget.</returns> public override bool OnGUI(DebugUI.Widget widget, DebugState state) { var w = Cast <DebugUI.BitField>(widget); var s = Cast <DebugStateFlags>(state); EditorGUI.BeginChangeCheck(); Enum value = w.GetValue(); var rect = PrepareControlRect(); // Skip first element (with value 0) because EditorGUI.MaskField adds a 'Nothing' field anyway var enumNames = new string[w.enumNames.Length - 1]; for (int i = 0; i < enumNames.Length; i++) { enumNames[i] = w.enumNames[i + 1].text; } var index = EditorGUI.MaskField(rect, EditorGUIUtility.TrTextContent(w.displayName, w.tooltip), (int)Convert.ToInt32(value), enumNames); value = Enum.Parse(value.GetType(), index.ToString()) as Enum; if (EditorGUI.EndChangeCheck()) { Apply(w, s, value); } return(true); }
internal override void SetWidget(DebugUI.Widget widget) { base.SetWidget(widget); m_Field = CastWidget <DebugUI.Foldout>(); m_Container = GetComponent <DebugUIHandlerContainer>(); nameLabel.text = m_Field.displayName; int columnNumber = m_Field.columnLabels?.Length ?? 0; for (int index = 0; index < columnNumber; ++index) { var column = Instantiate(nameLabel.gameObject, GetComponent <DebugUIHandlerContainer>().contentHolder); column.AddComponent <LayoutElement>().ignoreLayout = true; var rectTransform = column.transform as RectTransform; var originalTransform = nameLabel.transform as RectTransform; rectTransform.anchorMax = rectTransform.anchorMin = new Vector2(0, 1); rectTransform.sizeDelta = new Vector2(100, 26); Vector3 pos = originalTransform.anchoredPosition; pos.x += (index + 1) * xDecal + xDecalInit; rectTransform.anchoredPosition = pos; rectTransform.pivot = new Vector2(0, 0.5f); rectTransform.eulerAngles = new Vector3(0, 0, 13); var text = column.GetComponent <Text>(); text.fontSize = 15; text.text = m_Field.columnLabels[index]; } UpdateValue(); }
/// <summary> /// Begin implementation for Foldout DebugUIDrawer. /// </summary> /// <param name="widget">DebugUI Widget.</param> /// <param name="state">Debug State associated with the Debug Item.</param> public override void Begin(DebugUI.Widget widget, DebugState state) { var w = Cast <DebugUI.Foldout>(widget); var s = Cast <DebugStateBool>(state); EditorGUI.BeginChangeCheck(); GUIStyle style = w.isHeader ? DebugWindow.Styles.foldoutHeaderStyle : EditorStyles.foldout; Rect rect = PrepareControlRect(w.isHeader ? style.fixedHeight : -1, w.isHeader); if (w.isHeader) { GUILayout.Space(k_HeaderVerticalMargin); } bool value = EditorGUI.Foldout(rect, w.GetValue(), EditorGUIUtility.TrTextContent(w.displayName, w.tooltip), false, style); if (EditorGUI.EndChangeCheck()) { Apply(w, s, value); } if (w.contextMenuItems != null) { float contextMenuButtonSize = style.fixedHeight; var labelRect = EditorGUI.IndentedRect(GUILayoutUtility.GetRect(0f, /*17f*/ 0f)); labelRect.xMax -= 20f + 16 + 5; var contextMenuRect = new Rect(labelRect.xMax + 3f + 16, labelRect.y - contextMenuButtonSize, contextMenuButtonSize, contextMenuButtonSize); if (GUI.Button(contextMenuRect, CoreEditorStyles.contextMenuIcon, CoreEditorStyles.contextMenuStyle)) { var menu = new GenericMenu(); foreach (var item in w.contextMenuItems) { menu.AddItem(EditorGUIUtility.TrTextContent(item.displayName), false, () => item.action.Invoke()); } menu.DropDown(new Rect(new Vector2(contextMenuRect.x, contextMenuRect.yMax), Vector2.zero)); } } Rect drawRect = GUILayoutUtility.GetLastRect(); if (w.columnLabels != null && value) { const int oneColumnWidth = 70; int indent = EditorGUI.indentLevel; EditorGUI.indentLevel = 0; //be at left of rects for (int i = 0; i < w.columnLabels.Length; i++) { var columnRect = drawRect; columnRect.x += EditorGUIUtility.labelWidth + i * oneColumnWidth; columnRect.width = oneColumnWidth; string label = w.columnLabels[i] ?? ""; string tooltip = w.columnTooltips?.ElementAtOrDefault(i) ?? ""; EditorGUI.LabelField(columnRect, EditorGUIUtility.TrTextContent(label, tooltip), EditorStyles.miniBoldLabel); } EditorGUI.indentLevel = indent; } EditorGUI.indentLevel++; }
internal override void SetWidget(DebugUI.Widget widget) { base.SetWidget(widget); m_Field = CastWidget <DebugUI.Foldout>(); m_Container = GetComponent <DebugUIHandlerContainer>(); nameLabel.text = m_Field.displayName; UpdateValue(); }
public override bool OnGUI(DebugUI.Widget widget, DebugState state) { var w = Cast <DebugUI.Value>(widget); var rect = PrepareControlRect(); EditorGUI.LabelField(rect, CoreEditorUtils.GetContent(w.displayName), CoreEditorUtils.GetContent(w.GetValue().ToString())); return(true); }
internal override void SetWidget(DebugUI.Widget widget) { base.SetWidget(widget); var field = CastWidget <DebugUI.ObjectField>(); nameLabel.text = field.displayName; valueLabel.text = field.GetValue().name; }
/// <summary> /// OnGUI implementation for Value DebugUIDrawer. /// </summary> /// <param name="widget">DebugUI Widget.</param> /// <param name="state">Debug State associated with the Debug Item.</param> /// <returns>The state of the widget.</returns> public override bool OnGUI(DebugUI.Widget widget, DebugState state) { var w = Cast <DebugUI.Value>(widget); var rect = PrepareControlRect(); var value = w.GetValue(); EditorGUI.LabelField(rect, EditorGUIUtility.TrTextContent(w.displayName), EditorGUIUtility.TrTextContent(w.FormatString(value))); return(true); }
internal override void SetWidget(DebugUI.Widget widget) { base.SetWidget(widget); m_Field = CastWidget <DebugUI.BoolField>(); nameLabel.text = m_Field.displayName; UpdateValueLabel(); valueToggle.onValueChanged.AddListener(OnToggleValueChanged); }
/// <summary> /// Implement this to execute processing after UI rendering. /// </summary> /// <param name="widget">Widget that is going to be rendered.</param> /// <param name="state">Debug State associated with the Debug Item.</param> public override void End(DebugUI.Widget widget, DebugState state) { if (EditorGUI.EndChangeCheck()) { var w = Cast <TField>(widget); var s = Cast <TState>(state); Apply(w, s, value); } }
public override void Begin(DebugUI.Widget widget, DebugState state) { if (!string.IsNullOrEmpty(widget.displayName)) { EditorGUILayout.LabelField(widget.displayName, EditorStyles.boldLabel); } EditorGUI.indentLevel++; }
/// <summary> /// End implementation for Foldout DebugUIDrawer. /// </summary> /// <param name="widget">DebugUI Widget.</param> /// <param name="state">Debug State associated with the Debug Item.</param> public override void End(DebugUI.Widget widget, DebugState state) { EditorGUI.indentLevel--; var w = Cast <DebugUI.Foldout>(widget); if (w.isHeader) { GUILayout.Space(k_HeaderVerticalMargin); } }
static DebugUI.Widget[] GenerateFrameSettingsPanelContent(HDRenderPipelineAsset defaultHdrpAsset, ref FrameSettingsHistory frameSettings) { var panelContent = new DebugUI.Widget[foldoutNames.Length]; for (int index = 0; index < foldoutNames.Length; ++index) { panelContent[index] = new DebugUI.Foldout(foldoutNames[index], GenerateHistoryArea(defaultHdrpAsset, ref frameSettings, index), columnNames); } return(panelContent); }
/// <summary> /// Implement this to execute UI rendering. /// </summary> /// <param name="widget">Widget that is going to be rendered.</param> /// <param name="state">Debug State associated with the Debug Item.</param> /// <returns>Returns the state of the widget.</returns> public override bool OnGUI(DebugUI.Widget widget, DebugState state) { DoGUI( PrepareControlRect(), EditorGUIUtility.TrTextContent(widget.displayName, widget.tooltip), Cast <TWidget>(widget) ); return(true); }
/// <summary> /// OnGUI implementation for Table DebugUIDrawer. /// </summary> /// <param name="widget">DebugUI Widget.</param> /// <param name="state">Debug State associated with the Debug Item.</param> /// <returns>The state of the widget.</returns> public override bool OnGUI(DebugUI.Widget widget, DebugState state) { var w = Cast <DebugUI.Table>(widget); var header = w.Header; // Put some space before the array PrepareControlRect(EditorGUIUtility.singleLineHeight * 0.5f); // Draw an outline around the table var rect = EditorGUI.IndentedRect(PrepareControlRect(header.height + (w.children.Count + 1) * EditorGUIUtility.singleLineHeight)); rect = DrawOutline(rect); // Compute rects var headerRect = new Rect(rect.x, rect.y, rect.width, header.height); var contentRect = new Rect(rect.x, headerRect.yMax, rect.width, rect.height - headerRect.height); var viewRect = new Rect(contentRect.x, contentRect.y, header.state.widthOfAllVisibleColumns, contentRect.height); var rowRect = contentRect; rowRect.height = EditorGUIUtility.singleLineHeight; viewRect.height -= EditorGUIUtility.singleLineHeight; // Show header header.OnGUI(headerRect, Mathf.Max(w.scroll.x, 0f)); // Show array content w.scroll = GUI.BeginScrollView(contentRect, w.scroll, viewRect); { var columns = header.state.columns; var visible = header.state.visibleColumns; for (int r = 0; r < w.children.Count; r++) { var row = Cast <DebugUI.Container>(w.children[r]); rowRect.x = contentRect.x; rowRect.width = columns[0].width; rowRect.xMin += 2; rowRect.xMax -= 2; EditorGUI.LabelField(rowRect, GUIContent.none, EditorGUIUtility.TrTextContent(row.displayName)); rowRect.xMin -= 2; rowRect.xMax += 2; for (int c = 1; c < visible.Length; c++) { rowRect.x += rowRect.width; rowRect.width = columns[visible[c]].width; DisplayChild(rowRect, row.children[visible[c] - 1], w.isReadOnly); } rowRect.y += rowRect.height; } } GUI.EndScrollView(false); return(false); }
/// <summary> /// Implement this to execute processing before UI rendering. /// </summary> /// <param name="widget">Widget that is going to be rendered.</param> /// <param name="state">Debug State associated with the Debug Item.</param> public override void Begin(DebugUI.Widget widget, DebugState state) { var w = Cast <DebugUI.Container>(widget); if (!w.hideDisplayName) { EditorGUILayout.LabelField(EditorGUIUtility.TrTextContent(widget.displayName, widget.tooltip), EditorStyles.boldLabel); } EditorGUI.indentLevel++; }
/// <summary> /// OnGUI implementation for Value DebugUIDrawer. /// </summary> /// <param name="widget">DebugUI Widget.</param> /// <param name="state">Debug State associated with the Debug Item.</param> /// <returns>The state of the widget.</returns> public override bool OnGUI(DebugUI.Widget widget, DebugState state) { var w = Cast <DebugUI.ProgressBarValue>(widget); var labelRect = PrepareControlRect(); var progressBarRect = EditorGUI.PrefixLabel(labelRect, EditorGUIUtility.TrTextContent(w.displayName)); float value = (float)w.GetValue(); EditorGUI.ProgressBar(progressBarRect, value, w.FormatString(value)); return(true); }
internal override void SetWidget(DebugUI.Widget widget) { base.SetWidget(widget); m_Field = CastWidget <DebugUI.Container>(); m_Container = GetComponent <DebugUIHandlerContainer>(); if (string.IsNullOrEmpty(m_Field.displayName)) { header.gameObject.SetActive(false); } else { nameLabel.text = m_Field.displayName; } }