public static void SetReorderButtonVisibility(VisualElement itemSection, bool enableReorderingOption)
{
if (!enableReorderingOption)
{
itemSection?.AddToClassList(UxmlClassNames.HideReorderButtons);
}
}
public static void SetAddSectionVisibility(VisualElement addSection, bool enableAddSectionOption)
{
if (!enableAddSectionOption)
{
addSection?.AddToClassList(UxmlClassNames.HideAddSection);
}
}
public static void SetRemoveButtonVisibility(VisualElement listElement, bool enableDeletionsOption)
{
if (!enableDeletionsOption)
{
listElement?.AddToClassList(UxmlClassNames.HideRemoveButtons);
}
}
public static void SetAddFieldVisibility(
VisualElement itemSection, Type type, bool enableObjectField)
{
if (!enableObjectField)
{
return;
}
if (type.IsSubclassOf(typeof(Object)))
{
itemSection?.AddToClassList(UxmlClassNames.UseObjectField);
}
}
public EventTypeSearchField()
{
m_Choices = new List <EventTypeChoice>();
m_State = new Dictionary <long, bool>();
m_GroupedEvents = new Dictionary <string, List <long> >();
AppDomain currentDomain = AppDomain.CurrentDomain;
HashSet <string> userAssemblies = new HashSet <string>(ScriptingRuntime.GetAllUserAssemblies());
foreach (Assembly assembly in currentDomain.GetAssemblies())
{
if (userAssemblies.Contains(assembly.GetName().Name + ".dll"))
{
continue;
}
try
{
foreach (var type in assembly.GetTypes().Where(t => typeof(EventBase).IsAssignableFrom(t) && !t.ContainsGenericParameters))
{
// Only select Pointer events on startup
AddType(type, IsGenericTypeOf(type, typeof(PointerEventBase <>)));
}
// Special case for ChangeEvent<>.
var implementingTypes = GetAllTypesImplementingOpenGenericType(typeof(INotifyValueChanged <>), assembly).ToList();
foreach (var valueChangedType in implementingTypes)
{
var baseType = valueChangedType.BaseType;
if (baseType == null || baseType.GetGenericArguments().Length <= 0)
{
continue;
}
var argumentType = baseType.GetGenericArguments()[0];
if (!argumentType.IsGenericParameter)
{
AddType(typeof(ChangeEvent <>).MakeGenericType(argumentType), false);
}
}
}
catch (TypeLoadException e)
{
Debug.LogWarningFormat("Error while loading types from assembly {0}: {1}", assembly.FullName, e);
}
catch (ReflectionTypeLoadException e)
{
for (var i = 0; i < e.LoaderExceptions.Length; i++)
{
if (e.LoaderExceptions[i] != null)
{
Debug.LogError(e.Types[i] + ": " + e.LoaderExceptions[i].Message);
}
}
}
}
m_State.Add(0, false);
// Add groups, with negative ids.
var keyIndex = -1;
foreach (var key in m_GroupedEvents.Keys.OrderBy(k => k))
{
m_Choices.Add(new EventTypeChoice()
{
Name = key, Group = key, TypeId = keyIndex
});
m_State.Add(keyIndex--, key.Contains("IPointerEvent"));
}
m_Choices.Sort();
m_Choices.Insert(0, new EventTypeChoice()
{
Name = "IAll", Group = "IAll", TypeId = 0
});
m_FilteredChoices = m_Choices.ToList();
m_MenuContainer = new VisualElement();
m_MenuContainer.AddToClassList(ussClassName);
m_OuterContainer = new VisualElement();
m_OuterContainer.AddToClassList(ussContainerClassName);
m_MenuContainer.Add(m_OuterContainer);
m_ListView = new ListView();
m_ListView.AddToClassList(ussListViewClassName);
m_ListView.pickingMode = PickingMode.Position;
m_ListView.showBoundCollectionSize = false;
m_ListView.fixedItemHeight = 20;
m_ListView.selectionType = SelectionType.None;
m_ListView.showAlternatingRowBackgrounds = AlternatingRowBackground.All;
m_ListView.makeItem = () =>
{
var container = new VisualElement();
container.AddToClassList(ussItemContainerClassName);
var toggle = new Toggle();
toggle.labelElement.AddToClassList(ussItemLabelClassName);
toggle.visualInput.AddToClassList(ussItemToggleClassName);
toggle.RegisterValueChangedCallback(OnToggleValueChanged);
container.Add(toggle);
var label = new Label();
label.AddToClassList(ussItemCountClassName);
label.pickingMode = PickingMode.Ignore;
container.Add(label);
return(container);
};
m_ListView.bindItem = (element, i) =>
{
var toggle = element[0] as Toggle;
var countLabel = element[1] as Label;
var choice = m_FilteredChoices[i];
toggle.SetValueWithoutNotify(m_State[choice.TypeId]);
var isGroup = choice.Name == choice.Group;
toggle.label = isGroup ? $"{choice.Group.Substring(1).Replace("Event", "")} Events" : choice.Name;
toggle.labelElement.RemoveFromClassList(isGroup ? ussItemLabelClassName : ussGroupLabelClassName);
toggle.labelElement.AddToClassList(isGroup ? ussGroupLabelClassName : ussItemLabelClassName);
toggle.userData = i;
if (m_EventCountLog != null && m_EventCountLog.ContainsKey(choice.TypeId))
{
countLabel.style.display = DisplayStyle.Flex;
countLabel.text = m_EventCountLog[choice.TypeId].ToString();
}
else
{
countLabel.text = "";
countLabel.style.display = DisplayStyle.None;
}
};
m_ListView.itemsSource = m_FilteredChoices;
m_OuterContainer.Add(m_ListView);
UpdateTextHint();
m_MenuContainer.RegisterCallback <AttachToPanelEvent>(OnAttachToPanel);
m_MenuContainer.RegisterCallback <DetachFromPanelEvent>(OnDetachFromPanel);
textInputField.RegisterValueChangedCallback(OnValueChanged);
RegisterCallback <FocusInEvent>(OnFocusIn);
RegisterCallback <FocusEvent>(OnFocus);
RegisterCallback <FocusOutEvent>(OnFocusOut);
}
public void OnEnable()
{
var root = rootVisualElement;
var styleSheet = EditorGUIUtility.Load(s_StyleSheetPath) as StyleSheet;
root.styleSheets.Add(styleSheet);
var themedStyleSheet = EditorGUIUtility.isProSkin
? EditorGUIUtility.Load(s_DarkStyleSheetPath) as StyleSheet
: EditorGUIUtility.Load(s_LightStyleSheetPath) as StyleSheet;
root.styleSheets.Add(themedStyleSheet);
SampleTreeItem.ResetNextId();
var items = new List <ITreeViewItem>()
{
new SampleTreeItem("Styles", StylesExplorer.Create),
new SampleTreeItem("Button", ButtonSnippet.Create),
new SampleTreeItem("Scroller", ScrollerSnippet.Create),
new SampleTreeItem("Toggle", ToggleSnippet.Create),
new SampleTreeItem("Label", LabelSnippet.Create),
new SampleTreeItem("Text Field", TextFieldSnippet.Create),
new SampleTreeItem("Object Field", ObjectFieldSnippet.Create),
new SampleTreeItem("List View", ListViewSnippet.Create),
new SampleTreeItem("Numeric Fields", MakeNumericFieldsPanel, new List <TreeViewItem <string> >()
{
new SampleTreeItem("Integer", IntegerFieldSnippet.Create),
new SampleTreeItem("Float", FloatFieldSnippet.Create),
new SampleTreeItem("Long", LongFieldSnippet.Create),
new SampleTreeItem("MinMaxSlider", MinMaxSliderSnippet.Create),
new SampleTreeItem("Slider", SliderSnippet.Create),
new SampleTreeItem("Vector2", Vector2FieldSnippet.Create),
new SampleTreeItem("Vector3", Vector3FieldSnippet.Create),
new SampleTreeItem("Vector4", Vector4FieldSnippet.Create),
new SampleTreeItem("Rect", RectFieldSnippet.Create),
new SampleTreeItem("Bounds", BoundsFieldSnippet.Create),
new SampleTreeItem("SliderInt", SliderIntSnippet.Create),
new SampleTreeItem("Vector2Int", Vector2IntFieldSnippet.Create),
new SampleTreeItem("Vector3Int", Vector3IntFieldSnippet.Create),
new SampleTreeItem("RectInt", RectIntFieldSnippet.Create),
new SampleTreeItem("BoundsInt", BoundsIntFieldSnippet.Create)
}),
new SampleTreeItem("Value Fields", MakeValueFieldsPanel, new List <TreeViewItem <string> >()
{
new SampleTreeItem("Color", ColorFieldSnippet.Create),
new SampleTreeItem("Curve", CurveFieldSnippet.Create),
new SampleTreeItem("Gradient", GradientFieldSnippet.Create)
}),
new SampleTreeItem("Choice Fields", MakeChoiceFieldsPanel, new List <TreeViewItem <string> >()
{
new SampleTreeItem("Enum", EnumFieldSnippet.Create),
new SampleTreeItem("EnumFlags", EnumFlagsFieldSnippet.Create),
new SampleTreeItem("Popup", PopupFieldSnippet.Create),
new SampleTreeItem("Tag", TagFieldSnippet.Create),
new SampleTreeItem("Mask", MaskFieldSnippet.Create),
new SampleTreeItem("Layer", LayerFieldSnippet.Create),
new SampleTreeItem("LayerMask", LayerMaskFieldSnippet.Create)
}),
};
Func <VisualElement> makeItem = () =>
{
var box = new VisualElement();
box.AddToClassList(k_TreeItemClassName);
var label = new Label();
label.AddToClassList(k_TreeItemLabelClassName);
box.Add(label);
return(box);
};
Action <VisualElement, ITreeViewItem> bindItem = (element, item) =>
{
(element.ElementAt(0) as Label).text = (item as SampleTreeItem).data;
element.userData = item;
};
Action <IEnumerable <ITreeViewItem> > onSelectionChanged = (selectedItems) =>
{
if (selectedItems.Any())
{
return;
}
var item = selectedItems.First() as SampleTreeItem;
m_ContentPanel.Clear();
m_ContentPanel.Add(item.makeItem(item));
};
var treeView = new TreeView()
{
name = k_TreeViewName
};
treeView.AddToClassList(k_TreeViewClassName);
m_ContentPanel = new VisualElement()
{
name = k_ContentPanelName
};
m_ContentPanel.AddToClassList(k_ContentPanelClassName);
var splitter = new DebuggerSplitter();
splitter.AddToClassList(k_SplitterClassName);
splitter.leftPane.style.width = k_SplitterLeftPaneStartingWidth;
root.Add(splitter);
splitter.leftPane.Add(treeView);
splitter.rightPane.Add(m_ContentPanel);
treeView.viewDataKey = "samples-tree";
treeView.itemHeight = 20;
treeView.rootItems = items;
treeView.makeItem = makeItem;
treeView.bindItem = bindItem;
treeView.onSelectionChange += onSelectionChanged;
treeView.Refresh();
// Force TreeView to call onSelectionChanged when it restores its own selection from view data.
treeView.schedule.Execute(() =>
{
onSelectionChanged(treeView.selectedItems);
}).StartingIn(k_TreeViewSelectionRestoreDelay);
// Force TreeView to select something if nothing is selected.
treeView.schedule.Execute(() =>
{
if (treeView.selectedItems.Count() > 0)
{
return;
}
treeView.SetSelection(0);
// Auto-expand all items on load.
foreach (var item in treeView.rootItems)
{
treeView.ExpandItem(item.id);
}
}).StartingIn(k_TreeViewInitialSelectionDelay);
}
private void BuildUI()
{
// Keyboard events need a focusable element to trigger
rootVisualElement.focusable = true;
rootVisualElement.RegisterCallback <KeyUpEvent>(e =>
{
switch (e.keyCode)
{
case KeyCode.Escape when !docked:
Close();
break;
}
});
// Load stylesheets
rootVisualElement.AddToClassList(Styles.unityThemeVariables);
rootVisualElement.AddToClassList(Styles.sceneTemplateThemeVariables);
rootVisualElement.AddStyleSheetPath(Styles.k_CommonStyleSheetPath);
rootVisualElement.AddStyleSheetPath(Styles.variableStyleSheet);
// Create a container to offset everything nicely inside the window
{
var offsetContainer = new VisualElement();
offsetContainer.AddToClassList(Styles.classOffsetContainer);
rootVisualElement.Add(offsetContainer);
// Create a container for the scene templates and description
{
var mainContainer = new VisualElement();
mainContainer.style.flexDirection = FlexDirection.Row;
mainContainer.AddToClassList(Styles.classMainContainer);
offsetContainer.Add(mainContainer);
{
// Create a container for the scene templates lists(left side)
var sceneTemplatesContainer = new VisualElement();
sceneTemplatesContainer.AddToClassList(Styles.classTemplatesContainer);
sceneTemplatesContainer.AddToClassList(Styles.sceneTemplateDialogBorder);
// mainContainer.Add(sceneTemplatesContainer);
CreateAllSceneTemplateListsUI(sceneTemplatesContainer);
// Create a container for the template description (right side)
var descriptionContainer = new VisualElement();
descriptionContainer.AddToClassList(Styles.classDescriptionContainer);
descriptionContainer.AddToClassList(Styles.classBorder);
// mainContainer.Add(descriptionContainer);
CreateTemplateDescriptionUI(descriptionContainer);
if (EditorPrefs.HasKey(GetKeyName(nameof(m_Splitter))))
{
var splitterPosition = EditorPrefs.GetFloat(GetKeyName(nameof(m_Splitter)));
sceneTemplatesContainer.style.width = splitterPosition;
}
else
{
EditorApplication.delayCall += () =>
{
sceneTemplatesContainer.style.width = position.width * 0.60f;
};
}
m_Splitter = new VisualSplitter(sceneTemplatesContainer, descriptionContainer, FlexDirection.Row);
mainContainer.Add(m_Splitter);
}
}
// Create the button row
{
var buttonRow = new VisualElement();
buttonRow.AddToClassList(Styles.sceneTemplateDialogFooter);
offsetContainer.Add(buttonRow);
buttonRow.style.flexDirection = FlexDirection.Row;
var loadAdditiveToggle = new Toggle()
{
name = k_SceneTemplateCreateAdditiveButtonName, text = L10n.Tr("Load additively"), tooltip = k_LoadAdditivelyToolTip
};
if (SceneTemplateUtils.HasSceneUntitled())
{
loadAdditiveToggle.SetEnabled(false);
loadAdditiveToggle.tooltip = k_LoadAdditivelyToolTipDisabledHasUnsavedUntitled;
}
buttonRow.Add(loadAdditiveToggle);
{
// The buttons need to be right-aligned
var buttonSection = new VisualElement();
buttonSection.style.flexDirection = FlexDirection.RowReverse;
buttonSection.AddToClassList(Styles.classButtons);
buttonRow.Add(buttonSection);
var createSceneButton = new Button(() =>
{
if (m_LastSelectedTemplate == null)
{
return;
}
OnCreateNewScene(m_LastSelectedTemplate);
})
{
text = L10n.Tr("Create"), tooltip = L10n.Tr("Instantiate a new scene from a template")
};
createSceneButton.AddToClassList(Styles.classButton);
var cancelButton = new Button(Close)
{
text = L10n.Tr("Cancel"), tooltip = L10n.Tr("Close scene template dialog without instantiating a new scene.")
};
cancelButton.AddToClassList(Styles.classButton);
buttonSection.Add(cancelButton);
buttonSection.Add(createSceneButton);
m_Buttons = new List <ButtonInfo>
{
new ButtonInfo {
button = createSceneButton, callback = OnCreateNewScene
},
new ButtonInfo {
button = cancelButton, callback = info => Close()
}
};
m_SelectedButtonIndex = m_Buttons.FindIndex(bi => bi.button == createSceneButton);
UpdateSelectedButton();
}
}
SetAllElementSequentiallyFocusable(rootVisualElement, false);
}
if (m_LastSelectedTemplate != null)
{
UpdateTemplateDescriptionUI(m_LastSelectedTemplate);
}
}
public void Initialize(AbstractMaterialNode inNode, PreviewManager previewManager, IEdgeConnectorListener connectorListener, GraphView graphView)
{
styleSheets.Add(Resources.Load <StyleSheet>("Styles/MaterialNodeView"));
styleSheets.Add(Resources.Load <StyleSheet>($"Styles/ColorMode"));
AddToClassList("MaterialNode");
if (inNode == null)
{
return;
}
var contents = this.Q("contents");
m_GraphView = graphView;
m_ConnectorListener = connectorListener;
node = inNode;
viewDataKey = node.guid.ToString();
UpdateTitle();
// Add controls container
var controlsContainer = new VisualElement {
name = "controls"
};
{
m_ControlsDivider = new VisualElement {
name = "divider"
};
m_ControlsDivider.AddToClassList("horizontal");
controlsContainer.Add(m_ControlsDivider);
m_ControlItems = new VisualElement {
name = "items"
};
controlsContainer.Add(m_ControlItems);
// Instantiate control views from node
foreach (var propertyInfo in node.GetType().GetProperties(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic))
{
foreach (IControlAttribute attribute in propertyInfo.GetCustomAttributes(typeof(IControlAttribute), false))
{
m_ControlItems.Add(attribute.InstantiateControl(node, propertyInfo));
}
}
}
if (m_ControlItems.childCount > 0)
{
contents.Add(controlsContainer);
}
// Node Base class toggles the 'expanded' variable already, this is on top of that call
m_CollapseButton.RegisterCallback <MouseUpEvent>(SetNodeExpandedStateOnSelection);
if (node.hasPreview)
{
// Add actual preview which floats on top of the node
m_PreviewContainer = new VisualElement
{
name = "previewContainer",
style = { overflow = Overflow.Hidden },
pickingMode = PickingMode.Ignore
};
m_PreviewImage = new Image
{
name = "preview",
pickingMode = PickingMode.Ignore,
image = Texture2D.whiteTexture,
};
{
// Add preview collapse button on top of preview
var collapsePreviewButton = new VisualElement {
name = "collapse"
};
collapsePreviewButton.Add(new VisualElement {
name = "icon"
});
collapsePreviewButton.AddManipulator(new Clickable(() =>
{
node.owner.owner.RegisterCompleteObjectUndo("Collapse Preview");
SetPreviewExpandedStateOnSelection(false);
}));
m_PreviewImage.Add(collapsePreviewButton);
}
m_PreviewContainer.Add(m_PreviewImage);
// Hook up preview image to preview manager
m_PreviewRenderData = previewManager.GetPreview(inNode);
m_PreviewRenderData.onPreviewChanged += UpdatePreviewTexture;
UpdatePreviewTexture();
// Add fake preview which pads out the node to provide space for the floating preview
m_PreviewFiller = new VisualElement {
name = "previewFiller"
};
m_PreviewFiller.AddToClassList("expanded");
{
var previewDivider = new VisualElement {
name = "divider"
};
previewDivider.AddToClassList("horizontal");
m_PreviewFiller.Add(previewDivider);
var expandPreviewButton = new VisualElement {
name = "expand"
};
expandPreviewButton.Add(new VisualElement {
name = "icon"
});
expandPreviewButton.AddManipulator(new Clickable(() =>
{
node.owner.owner.RegisterCompleteObjectUndo("Expand Preview");
SetPreviewExpandedStateOnSelection(true);
}));
m_PreviewFiller.Add(expandPreviewButton);
}
contents.Add(m_PreviewFiller);
SetPreviewExpandedStateOnSelection(node.previewExpanded);
}
// Add port input container, which acts as a pixel cache for all port inputs
m_PortInputContainer = new VisualElement
{
name = "portInputContainer",
style = { overflow = Overflow.Hidden },
pickingMode = PickingMode.Ignore
};
Add(m_PortInputContainer);
AddSlots(node.GetSlots <MaterialSlot>());
UpdatePortInputs();
base.expanded = node.drawState.expanded;
RefreshExpandedState(); //This should not be needed. GraphView needs to improve the extension api here
UpdatePortInputVisibilities();
SetPosition(new Rect(node.drawState.position.x, node.drawState.position.y, 0, 0));
if (node is SubGraphNode)
{
RegisterCallback <MouseDownEvent>(OnSubGraphDoubleClick);
}
m_PortInputContainer.SendToBack();
m_TitleContainer = this.Q("title");
var masterNode = node as IMasterNode;
if (masterNode != null)
{
AddToClassList("master");
if (!masterNode.IsPipelineCompatible(GraphicsSettings.renderPipelineAsset))
{
AttachMessage("The current render pipeline is not compatible with this master node.", ShaderCompilerMessageSeverity.Error);
}
}
m_NodeSettingsView = new NodeSettingsView();
m_NodeSettingsView.visible = false;
Add(m_NodeSettingsView);
m_SettingsButton = new VisualElement {
name = "settings-button"
};
m_SettingsButton.Add(new VisualElement {
name = "icon"
});
m_Settings = new VisualElement();
AddDefaultSettings();
// Add Node type specific settings
var nodeTypeSettings = node as IHasSettings;
if (nodeTypeSettings != null)
{
m_Settings.Add(nodeTypeSettings.CreateSettingsElement());
}
// Add manipulators
m_SettingsButton.AddManipulator(new Clickable(() =>
{
UpdateSettingsExpandedState();
}));
if (m_Settings.childCount > 0)
{
m_ButtonContainer = new VisualElement {
name = "button-container"
};
m_ButtonContainer.style.flexDirection = FlexDirection.Row;
m_ButtonContainer.Add(m_SettingsButton);
m_ButtonContainer.Add(m_CollapseButton);
m_TitleContainer.Add(m_ButtonContainer);
}
// Register OnMouseHover callbacks for node highlighting
RegisterCallback <MouseEnterEvent>(OnMouseHover);
RegisterCallback <MouseLeaveEvent>(OnMouseHover);
}
public NoiseEditorView(NoiseSettings _noiseUpdateTarget_ = null, NoiseSettings _sourceAsset_ = null)
{
// create temp noisesettings asset and the IMGUI view for this window
m_noiseUpdateTarget = _noiseUpdateTarget_ == null?ScriptableObject.CreateInstance <NoiseSettings>() : _noiseUpdateTarget_;
m_serializedNoiseProfile = new SerializedObject(m_noiseUpdateTarget);
m_noiseGUI = new NoiseSettingsGUI();
m_noiseGUI.Init(m_noiseUpdateTarget);
m_noiseSourceAsset = _sourceAsset_;
var stylesheet = Resources.Load <StyleSheet>("Styles/Noise");
var settingsScrollView = new ScrollView()
{
name = Styles.settingsScrollViewName
};
///////////////////////////////////////////////////////////////////////////////
// settings buttons
///////////////////////////////////////////////////////////////////////////////
var noiseGUIContainer = new IMGUIContainer()
{
name = Styles.noiseGUIContainerName
};
noiseGUIContainer.onGUIHandler = () =>
{
EditorGUI.BeginChangeCheck();
{
m_noiseGUI.OnGUI(NoiseSettingsGUIFlags.All & (~NoiseSettingsGUIFlags.Preview));
}
bool changed = EditorGUI.EndChangeCheck();
if (changed)
{
INTERNAL_OnSettingsChanged();
}
};
settingsScrollView.Add(noiseGUIContainer);
///////////////////////////////////////////////////////////////////////////////
// settings buttons
///////////////////////////////////////////////////////////////////////////////
filePanelContainer = new VisualElement()
{
name = Styles.saveButtonsContainer,
style =
{
flexDirection = FlexDirection.Row
}
};
filePanelContainer.AddToClassList(Styles.filePanelContainer);
saveAsButton = new Button(SaveAsCallback)
{
name = Styles.saveAsButtonName,
text = "Save As",
tooltip = Styles.saveasTooltip
};
saveAsButton.AddToClassList(Styles.filePanelButton);
revertButton = new Button(ResetRevertCallback)
{
name = Styles.resetButtonName,
text = "Reset",
tooltip = Styles.resetTooltip
};
revertButton.AddToClassList(Styles.filePanelButton);
applyButton = new Button(() => { Undo.RecordObject(m_noiseSourceAsset, "NoiseWindow - Apply Settings"); m_noiseSourceAsset.CopySerialized(m_noiseUpdateTarget); })
{
name = Styles.applyButtonName,
text = "Apply",
tooltip = Styles.applyTooltip
};
applyButton.AddToClassList(Styles.filePanelButton);
applyButton.AddToClassList(Styles.filePanelButton);
///////////////////////////////////////////////////////////////////////////////
// noise settings object field
///////////////////////////////////////////////////////////////////////////////
var objectFieldContainer = new VisualElement()
{
name = Styles.objectFieldContainer
};
objectFieldContainer.AddToClassList(Styles.objectFieldContainer);
objectField = new ObjectField()
{
name = Styles.noiseAssetFieldName,
allowSceneObjects = false,
objectType = typeof(NoiseSettings),
label = Styles.noiseAssetFieldLabel,
tooltip = Styles.noiseAssetFieldTooltip //,
// viewDataKey = Styles.noiseAssetFieldName
};
objectField.AddToClassList(Styles.noiseAssetFieldName);
objectField.RegisterCallback <ChangeEvent <UnityEngine.Object> >(OnSourceProfileChanged);
objectFieldContainer.Add(objectField);
///////////////////////////////////////////////////////////////////////////////
// export settings
///////////////////////////////////////////////////////////////////////////////
var flexArea = new VisualElement()
{
name = Styles.flexArea
};
flexArea.AddToClassList(Styles.flexArea);
var exportContainer = new VisualElement()
{
name = Styles.exportContainer
};
exportContainer.AddToClassList(Styles.exportContainer);
var exportHeader = new Foldout()
{
name = Styles.exportHeader,
text = "Export Settings",
tooltip = Styles.exportTooltip,
viewDataKey = Styles.exportHeader
};
exportHeader.RegisterCallback <ChangeEvent <bool> >(
(evt) =>
{
if (evt.newValue)
{
m_exportContainer.Add(m_exportSettings);
m_exportContainer.Add(m_exportButton);
}
else
{
m_exportContainer.Remove(m_exportSettings);
m_exportContainer.Remove(m_exportButton);
}
}
);
exportHeader.AddToClassList(Styles.foldoutContainer);
var exportSettings = CreateExportSettingsView();
var exportButton = new Button(
() =>
{
if (m_exportType.value == ExportTextureType.Texture2D)
{
Export2D();
}
else if (m_exportType.value == ExportTextureType.Texture3D)
{
Export3D();
}
}
)
{
name = Styles.exportButton,
text = "Export To Texture"
};
exportButton.AddToClassList(Styles.exportButton);
m_exportButton = exportButton;
exportContainer.Add(exportHeader);
// exportContainer.Add( exportSettings );
// exportContainer.Add( exportButton );
m_exportContainer = exportContainer;
exportHeader.value = false;
// container for the settings panel
var settingsContainer = new VisualElement()
{
name = Styles.settingsContainerName
};
settingsContainer.AddToClassList(Styles.settingsContainerName);
settingsContainer.Add(objectFieldContainer);
settingsContainer.Add(filePanelContainer);
settingsContainer.Add(settingsScrollView);
settingsContainer.Add(flexArea); // add this so the export stuff stays at the bottom of the settings container
settingsContainer.Add(exportContainer);
settingsContainer.Bind(m_serializedNoiseProfile);
///////////////////////////////////////////////////////////////////////////////
// settings buttons
///////////////////////////////////////////////////////////////////////////////
var previewContainer = new VisualElement()
{
name = Styles.noisePreviewContainerName
};
previewContainer.AddToClassList(Styles.noisePreviewContainerName);
var previewLabel = new Label()
{
name = Styles.noisePreviewLabelName,
text = Styles.previewLabel,
tooltip = Styles.previewLabelTooltip
};
previewLabel.AddToClassList(Styles.noisePreviewLabelName);
previewContainer.Add(previewLabel);
m_noiseFieldView = new NoiseFieldView(m_serializedNoiseProfile)
{
name = Styles.noisePreviewTextureName
};
m_noiseFieldView.onGUIHandler += () =>
{
INTERNAL_OnSettingsChanged();
};
m_noiseFieldView.AddToClassList(Styles.noisePreviewTextureName);
previewContainer.Add(m_noiseFieldView);
///////////////////////////////////////////////////////////////////////////////
// wrap it all up
///////////////////////////////////////////////////////////////////////////////
styleSheets.Add(stylesheet);
AddToClassList(Styles.noiseWindowName);
Add(settingsContainer);
Add(previewContainer);
this.Bind(m_serializedNoiseProfile);
m_settingsContainer = settingsContainer;
INTERNAL_OnSourceProfileChanged(_sourceAsset_);
this.viewDataKey = Styles.noiseWindowName;
}
public override void Enable(bool fromInspector)
{
var stylesheet = Resources.Load <StyleSheet>(stylesheetName);
if (!styleSheets.Contains(stylesheet))
{
styleSheets.Add(stylesheet);
}
nodeTarget.onProcessed += UpdateTexturePreview;
// Fix the size of the node
style.width = nodeTarget.nodeWidth;
controlsContainer.AddToClassList("ControlsContainer");
if (!String.IsNullOrEmpty(header))
{
var title = new Label(header);
title.AddToClassList("PropertyEditorTitle");
controlsContainer.Add(title);
}
// No preview in the inspector, we display it in the preview
if (!fromInspector)
{
pinIcon = new Image {
image = MixtureEditorUtils.pinIcon, scaleMode = ScaleMode.ScaleToFit
};
var pinButton = new Button(() => {
if (nodeTarget.isPinned)
{
UnpinView();
}
else
{
PinView();
}
});
pinButton.Add(pinIcon);
if (nodeTarget.isPinned)
{
PinView();
}
pinButton.AddToClassList("PinButton");
rightTitleContainer.Add(pinButton);
previewContainer = new VisualElement();
previewContainer.AddToClassList("Preview");
controlsContainer.Add(previewContainer);
UpdateTexturePreview();
}
InitProcessingTimeLabel();
if (nodeTarget.showDefaultInspector)
{
DrawDefaultInspector(fromInspector);
}
}
public void Initialize(AbstractMaterialNode inNode, PreviewManager previewManager, IEdgeConnectorListener connectorListener)
{
AddStyleSheetPath("Styles/MaterialNodeView");
AddToClassList("MaterialNode");
if (inNode == null)
{
return;
}
var contents = this.Q("contents");
m_ConnectorListener = connectorListener;
node = inNode;
persistenceKey = node.guid.ToString();
UpdateTitle();
// Add controls container
var controlsContainer = new VisualElement {
name = "controls"
};
{
m_ControlsDivider = new VisualElement {
name = "divider"
};
m_ControlsDivider.AddToClassList("horizontal");
controlsContainer.Add(m_ControlsDivider);
m_ControlItems = new VisualElement {
name = "items"
};
controlsContainer.Add(m_ControlItems);
// Instantiate control views from node
foreach (var propertyInfo in node.GetType().GetProperties(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic))
{
foreach (IControlAttribute attribute in propertyInfo.GetCustomAttributes(typeof(IControlAttribute), false))
{
m_ControlItems.Add(attribute.InstantiateControl(node, propertyInfo));
}
}
}
if (m_ControlItems.childCount > 0)
{
contents.Add(controlsContainer);
}
if (node.hasPreview)
{
// Add actual preview which floats on top of the node
m_PreviewContainer = new VisualElement
{
name = "previewContainer",
clippingOptions = ClippingOptions.ClipAndCacheContents,
pickingMode = PickingMode.Ignore
};
m_PreviewImage = new Image
{
name = "preview",
pickingMode = PickingMode.Ignore,
image = Texture2D.whiteTexture,
};
{
// Add preview collapse button on top of preview
var collapsePreviewButton = new VisualElement {
name = "collapse"
};
collapsePreviewButton.Add(new VisualElement {
name = "icon"
});
collapsePreviewButton.AddManipulator(new Clickable(() =>
{
node.owner.owner.RegisterCompleteObjectUndo("Collapse Preview");
UpdatePreviewExpandedState(false);
}));
m_PreviewImage.Add(collapsePreviewButton);
}
m_PreviewContainer.Add(m_PreviewImage);
// Hook up preview image to preview manager
m_PreviewRenderData = previewManager.GetPreview(inNode);
m_PreviewRenderData.onPreviewChanged += UpdatePreviewTexture;
UpdatePreviewTexture();
// Add fake preview which pads out the node to provide space for the floating preview
m_PreviewFiller = new VisualElement {
name = "previewFiller"
};
m_PreviewFiller.AddToClassList("expanded");
{
var previewDivider = new VisualElement {
name = "divider"
};
previewDivider.AddToClassList("horizontal");
m_PreviewFiller.Add(previewDivider);
var expandPreviewButton = new VisualElement {
name = "expand"
};
expandPreviewButton.Add(new VisualElement {
name = "icon"
});
expandPreviewButton.AddManipulator(new Clickable(() =>
{
node.owner.owner.RegisterCompleteObjectUndo("Expand Preview");
UpdatePreviewExpandedState(true);
}));
m_PreviewFiller.Add(expandPreviewButton);
}
contents.Add(m_PreviewFiller);
UpdatePreviewExpandedState(node.previewExpanded);
}
// Add port input container, which acts as a pixel cache for all port inputs
m_PortInputContainer = new VisualElement
{
name = "portInputContainer",
clippingOptions = ClippingOptions.ClipAndCacheContents,
pickingMode = PickingMode.Ignore
};
Add(m_PortInputContainer);
AddSlots(node.GetSlots <MaterialSlot>());
UpdatePortInputs();
base.expanded = node.drawState.expanded;
RefreshExpandedState(); //This should not be needed. GraphView needs to improve the extension api here
UpdatePortInputVisibilities();
SetPosition(new Rect(node.drawState.position.x, node.drawState.position.y, 0, 0));
if (node is SubGraphNode)
{
RegisterCallback <MouseDownEvent>(OnSubGraphDoubleClick);
}
var masterNode = node as IMasterNode;
if (masterNode != null)
{
if (!masterNode.IsPipelineCompatible(RenderPipelineManager.currentPipeline))
{
IconBadge wrongPipeline = IconBadge.CreateError("The current render pipeline is not compatible with this node preview.");
Add(wrongPipeline);
VisualElement title = this.Q("title");
wrongPipeline.AttachTo(title, SpriteAlignment.LeftCenter);
}
}
m_PortInputContainer.SendToBack();
// Remove this after updated to the correct API call has landed in trunk. ------------
VisualElement m_TitleContainer;
VisualElement m_ButtonContainer;
m_TitleContainer = this.Q("title");
// -----------------------------------------------------------------------------------
var settings = node as IHasSettings;
if (settings != null)
{
m_NodeSettingsView = new NodeSettingsView();
m_NodeSettingsView.visible = false;
Add(m_NodeSettingsView);
m_SettingsButton = new VisualElement {
name = "settings-button"
};
m_SettingsButton.Add(new VisualElement {
name = "icon"
});
m_Settings = settings.CreateSettingsElement();
m_SettingsButton.AddManipulator(new Clickable(() =>
{
UpdateSettingsExpandedState();
}));
// Remove this after updated to the correct API call has landed in trunk. ------------
m_ButtonContainer = new VisualElement {
name = "button-container"
};
m_ButtonContainer.style.flexDirection = StyleValue <FlexDirection> .Create(FlexDirection.Row);
m_ButtonContainer.Add(m_SettingsButton);
m_ButtonContainer.Add(m_CollapseButton);
m_TitleContainer.Add(m_ButtonContainer);
// -----------------------------------------------------------------------------------
//titleButtonContainer.Add(m_SettingsButton);
//titleButtonContainer.Add(m_CollapseButton);
RegisterCallback <GeometryChangedEvent>(OnGeometryChanged);
}
}
public void Initialize(AbstractMaterialNode inNode, PreviewManager previewManager, IEdgeConnectorListener connectorListener, MaterialGraphView graphView)
{
styleSheets.Add(Resources.Load <StyleSheet>("Styles/MaterialNodeView"));
styleSheets.Add(Resources.Load <StyleSheet>($"Styles/ColorMode"));
AddToClassList("MaterialNode");
if (inNode == null)
{
return;
}
var contents = this.Q("contents");
m_GraphView = graphView;
mainContainer.style.overflow = StyleKeyword.None; // Override explicit style set in base class
m_ConnectorListener = connectorListener;
node = inNode;
viewDataKey = node.objectId;
UpdateTitle();
// Add disabled overlay
Add(new VisualElement()
{
name = "disabledOverlay", pickingMode = PickingMode.Ignore
});
// Add controls container
var controlsContainer = new VisualElement {
name = "controls"
};
{
m_ControlsDivider = new VisualElement {
name = "divider"
};
m_ControlsDivider.AddToClassList("horizontal");
controlsContainer.Add(m_ControlsDivider);
m_ControlItems = new VisualElement {
name = "items"
};
controlsContainer.Add(m_ControlItems);
// Instantiate control views from node
foreach (var propertyInfo in node.GetType().GetProperties(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic))
{
foreach (IControlAttribute attribute in propertyInfo.GetCustomAttributes(typeof(IControlAttribute), false))
{
m_ControlItems.Add(attribute.InstantiateControl(node, propertyInfo));
}
}
}
if (m_ControlItems.childCount > 0)
{
contents.Add(controlsContainer);
}
if (node.hasPreview)
{
// Add actual preview which floats on top of the node
m_PreviewContainer = new VisualElement
{
name = "previewContainer",
style = { overflow = Overflow.Hidden },
pickingMode = PickingMode.Ignore
};
m_PreviewImage = new Image
{
name = "preview",
pickingMode = PickingMode.Ignore,
image = Texture2D.whiteTexture,
};
{
// Add preview collapse button on top of preview
var collapsePreviewButton = new VisualElement {
name = "collapse"
};
collapsePreviewButton.Add(new VisualElement {
name = "icon"
});
collapsePreviewButton.AddManipulator(new Clickable(() =>
{
SetPreviewExpandedStateOnSelection(false);
}));
m_PreviewImage.Add(collapsePreviewButton);
}
m_PreviewContainer.Add(m_PreviewImage);
// Hook up preview image to preview manager
m_PreviewRenderData = previewManager.GetPreviewRenderData(inNode);
m_PreviewRenderData.onPreviewChanged += UpdatePreviewTexture;
UpdatePreviewTexture();
// Add fake preview which pads out the node to provide space for the floating preview
m_PreviewFiller = new VisualElement {
name = "previewFiller"
};
m_PreviewFiller.AddToClassList("expanded");
{
var previewDivider = new VisualElement {
name = "divider"
};
previewDivider.AddToClassList("horizontal");
m_PreviewFiller.Add(previewDivider);
var expandPreviewButton = new VisualElement {
name = "expand"
};
expandPreviewButton.Add(new VisualElement {
name = "icon"
});
expandPreviewButton.AddManipulator(new Clickable(() =>
{
SetPreviewExpandedStateOnSelection(true);
}));
m_PreviewFiller.Add(expandPreviewButton);
}
contents.Add(m_PreviewFiller);
UpdatePreviewExpandedState(node.previewExpanded);
}
base.expanded = node.drawState.expanded;
AddSlots(node.GetSlots <MaterialSlot>());
if (node is SubGraphNode)
{
RegisterCallback <MouseDownEvent>(OnSubGraphDoubleClick);
}
m_TitleContainer = this.Q("title");
if (node is BlockNode blockData)
{
AddToClassList("blockData");
m_TitleContainer.RemoveFromHierarchy();
}
else
{
SetPosition(new Rect(node.drawState.position.x, node.drawState.position.y, 0, 0));
}
// Update active state
SetActive(node.isActive);
// Register OnMouseHover callbacks for node highlighting
RegisterCallback <MouseEnterEvent>(OnMouseHover);
RegisterCallback <MouseLeaveEvent>(OnMouseHover);
ShaderGraphPreferences.onAllowDeprecatedChanged += UpdateTitle;
}
public void Initialize(AbstractMaterialNode inNode, PreviewManager previewManager, IEdgeConnectorListener connectorListener)
{
AddToClassList("MaterialNode");
if (inNode == null)
{
return;
}
m_ConnectorListener = connectorListener;
node = inNode;
persistenceKey = node.guid.ToString();
UpdateTitle();
m_ControlsContainer = new VisualElement
{
name = "controls"
};
extensionContainer.Add(m_ControlsContainer);
m_ControlsDivider = new VisualElement {
name = "divider"
};
m_ControlsDivider.AddToClassList("horizontal");
if (node.hasPreview)
{
m_PreviewContainer = new VisualElement {
name = "previewContainer"
};
m_PreviewContainer.AddToClassList("expanded");
{
m_PreviewTextureView = new PreviewTextureView
{
name = "preview",
pickingMode = PickingMode.Ignore,
image = Texture2D.whiteTexture
};
m_PreviewRenderData = previewManager.GetPreview(inNode);
m_PreviewRenderData.onPreviewChanged += UpdatePreviewTexture;
UpdatePreviewTexture();
var collapsePreviewButton = new VisualElement {
name = "collapse"
};
collapsePreviewButton.Add(new VisualElement {
name = "icon"
});
collapsePreviewButton.AddManipulator(new Clickable(() =>
{
node.owner.owner.RegisterCompleteObjectUndo("Collapse Preview");
UpdatePreviewExpandedState(false);
}));
UpdatePreviewExpandedState(node.previewExpanded);
m_PreviewTextureView.Add(collapsePreviewButton);
var expandPreviewButton = new VisualElement {
name = "expand"
};
expandPreviewButton.Add(new VisualElement {
name = "icon"
});
expandPreviewButton.AddManipulator(new Clickable(() =>
{
node.owner.owner.RegisterCompleteObjectUndo("Expand Preview");
UpdatePreviewExpandedState(true);
}));
m_PreviewContainer.Add(expandPreviewButton);
}
extensionContainer.Add(m_PreviewContainer);
}
m_ControlViews = new List <VisualElement>();
foreach (var propertyInfo in node.GetType().GetProperties(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic))
{
foreach (IControlAttribute attribute in propertyInfo.GetCustomAttributes(typeof(IControlAttribute), false))
{
m_ControlViews.Add(attribute.InstantiateControl(node, propertyInfo));
}
}
m_Attachers = new List <Attacher>(node.GetInputSlots <MaterialSlot>().Count());
AddSlots(node.GetSlots <MaterialSlot>());
UpdateSlotAttachers();
base.expanded = node.drawState.expanded;
RefreshExpandedState(); //This should not be needed. GraphView needs to improve the extension api here
UpdatePortInputVisibilities();
SetPosition(new Rect(node.drawState.position.x, node.drawState.position.y, 0, 0));
UpdateControls();
if (node is PreviewNode)
{
var resizeHandle = new Label {
name = "resize", text = ""
};
resizeHandle.AddManipulator(new Draggable(OnResize));
Add(resizeHandle);
UpdateSize();
}
}
private void AddConversationPort(bool create, int index = -1)
{
var conversationContainer = new VisualElement {
name = "conversation-container"
};
lineLabel.AddToClassList("visible");
if (create)
{
Owner.EditorView.DlogObject.RegisterCompleteObjectUndo("Created Dialogue Line");
index = Lines.Count;
Lines.Add(new LineDataSelf {
Line = ""
});
}
var message = UIElementsFactory.TextField("conversation-item", "Line", new[] { "message" }, null, null, true);
if (!create)
{
message.SetValueWithoutNotify(Lines[index].Line);
}
var branchPort = DlogPort.Create("Branch", Orientation.Horizontal, Direction.Output, Port.Capacity.Single, PortType.Branch, true, EdgeConnectorListener);
branchPort.name = "conversation-item";
branchPort.AddToClassList("branch-port");
var triggerPort = DlogPort.Create("Trigger", Orientation.Horizontal, Direction.Output, Port.Capacity.Multi, PortType.Trigger, false, EdgeConnectorListener);
triggerPort.name = "conversation-item";
triggerPort.AddToClassList("trigger-port");
var flexBreak = UIElementsFactory.FlexBreaker();
if (create)
{
Lines[index].PortGuidA = branchPort.viewDataKey;
Lines[index].PortGuidB = triggerPort.viewDataKey;
}
else
{
branchPort.viewDataKey = Lines[index].PortGuidA;
triggerPort.viewDataKey = Lines[index].PortGuidB;
}
message.RegisterCallback <FocusOutEvent>(evt => {
var lineIndex = Lines.FindIndex(data => data.PortGuidA == branchPort.viewDataKey);
if (message.value != Lines[lineIndex].Line)
{
Owner.EditorView.DlogObject.RegisterCompleteObjectUndo("Changed Dialogue Line");
Lines[lineIndex].Line = message.value;
}
});
var removeButton = UIElementsFactory.Button("x", "conversation-item", "Remove line", new[] { "remove-button" }, () => { RemoveLine(Lines.FindIndex(data => data.PortGuidA == branchPort.viewDataKey)); });
conversationContainer.Add(message);
conversationContainer.Add(branchPort);
conversationContainer.Add(flexBreak);
conversationContainer.Add(removeButton);
conversationContainer.Add(triggerPort);
var separator = new VisualElement {
name = "divider"
};
separator.AddToClassList("horizontal");
separator.AddToClassList("horizontal-divider");
outputContainer.Add(separator);
outputContainer.Add(conversationContainer);
Ports.Add(branchPort);
Ports.Add(triggerPort);
if (create)
{
Owner.PortData.Add(branchPort.viewDataKey);
Owner.PortData.Add(triggerPort.viewDataKey);
Owner.GuidPortDictionary.Add(branchPort.viewDataKey, branchPort);
Owner.GuidPortDictionary.Add(triggerPort.viewDataKey, triggerPort);
}
Refresh();
}
/// <summary>
/// Based on the menu's checkboxes, shows or hide the tiles applicable to walls or slabs.
/// </summary>
IEnumerator UpdateDisplay()
{
List <VisualElement> veToRemove = new List <VisualElement>();
foreach (VisualElement ve in myBox.Children())
{
veToRemove.Add(ve);
}
foreach (VisualElement ve in veToRemove)
{
myBox.Remove(ve);
}
var webScript = GameObject.Find("Root").GetComponent <Web>();
if (wallToggle.value == true)
{
foreach (string tileName in wallTileNames)
{
string texturePath;
yield return(StartCoroutine(webScript.GetTexturePathFromName(tileName)));
texturePath = webScript.texturePath;
//texturePath = webScript.GetTexturePathFromName(tileName);
var myVE = new VisualElement();
myVE.styleSheets.Add(Resources.Load <StyleSheet>("USS/testVE"));
myVE.AddToClassList("medaillon");
myVE.name = tileName;
myVE.style.backgroundImage = webScript.LoadTextureFromDisk(tilePicturesFolder + texturePath);
myBox.Add(myVE);
myVE.RegisterCallback <ClickEvent>(ev => UpdateSelection(tileName));
}
}
if (slabToggle.value == true)
{
foreach (string tileName in slabTileNames)
{
string texturePath;
yield return(StartCoroutine(webScript.GetTexturePathFromName(tileName)));
texturePath = webScript.texturePath;
var myVE = new VisualElement();
myVE.styleSheets.Add(Resources.Load <StyleSheet>("USS/testVE"));
myVE.AddToClassList("medaillon");
myVE.name = tileName;
myVE.style.backgroundImage = webScript.LoadTextureFromDisk(tilePicturesFolder + texturePath);
myBox.Add(myVE);
myVE.RegisterCallback <ClickEvent>(ev => UpdateSelection(tileName));
}
}
//Apply style to tiles already preselected
IEnumerable <VisualElement> tiles = myBox.Children();
foreach (VisualElement tile in tiles)
{
if (localSelectedTiles.Contains(tile.name))
{
tile.RemoveFromClassList("medaillon");
tile.AddToClassList("selected-medaillon");
}
}
}
public static void BuildInspectorPropertiesElement(string elementPath, IEditorContainer editor, System.Collections.Generic.HashSet <System.Type> usedComponents, SerializedProperty obj, UnityEngine.UIElements.VisualElement container, bool noFields, System.Action <int, PropertyField> onBuild = null)
{
obj = obj.Copy();
container.Clear();
var source = obj.Copy();
SerializedProperty iterator = obj;
if (iterator.NextVisible(true) == false)
{
return;
}
if (iterator.NextVisible(true) == false)
{
return;
}
var depth = iterator.depth;
var i = 0;
var iteratorNext = iterator.Copy();
do
{
if (string.IsNullOrEmpty(elementPath) == false)
{
iterator = iteratorNext.FindPropertyRelative(elementPath);
}
else
{
iterator = iteratorNext;
}
if (iterator.propertyType != SerializedPropertyType.ManagedReference)
{
continue;
}
var element = new VisualElement();
element.AddToClassList("element");
var itCopy = iterator.Copy();
GetTypeFromManagedReferenceFullTypeName(iterator.managedReferenceFullTypename, out var type);
element.AddToClassList(i % 2 == 0 ? "even" : "odd");
element.RegisterCallback <UnityEngine.UIElements.ContextClickEvent, int>((evt, idx) => {
var menu = new GenericMenu();
if (usedComponents != null)
{
menu.AddItem(new GUIContent("Delete"), false, () => {
RemoveComponent((DataConfigEditor)editor, usedComponents, source, type, noFields);
editor.Save();
BuildInspectorProperties(editor, usedComponents, source, container, noFields);
});
menu.AddItem(new GUIContent("Copy JSON"), false, () => {
var instance = itCopy.GetValue();
var json = JsonUtility.ToJson(instance, true);
EditorGUIUtility.systemCopyBuffer = json;
});
}
editor.OnComponentMenu(menu, idx);
menu.ShowAsContext();
}, i);
if (type != null && usedComponents?.Contains(type) == false)
{
usedComponents?.Add(type);
}
if (type == null)
{
var label = new UnityEngine.UIElements.Label("MISSING: " + iterator.managedReferenceFullTypename);
element.name = "missing";
label.AddToClassList("inner-element");
label.AddToClassList("missing-label");
element.Add(label);
}
else if (iterator.hasVisibleChildren == false || noFields == true)
{
var horizontal = new UnityEngine.UIElements.VisualElement();
horizontal.AddToClassList("inner-element");
horizontal.AddToClassList("no-fields-container");
element.name = type.Name;
var toggle = new UnityEngine.UIElements.Toggle();
toggle.AddToClassList("no-fields-toggle");
toggle.SetEnabled(false);
toggle.SetValueWithoutNotify(true);
horizontal.Add(toggle);
var label = new UnityEngine.UIElements.Label(GUILayoutExt.GetStringCamelCaseSpace(type.Name));
label.AddToClassList("no-fields-label");
horizontal.Add(label);
element.Add(horizontal);
}
else
{
var label = GUILayoutExt.GetStringCamelCaseSpace(type.Name);
if (iterator.hasVisibleChildren == true)
{
var childs = iterator.Copy();
//var height = EditorUtilities.GetPropertyHeight(childs, true, new GUIContent(label));
var cnt = EditorUtilities.GetPropertyChildCount(childs);
if (cnt == 1 /*&& height <= 22f*/)
{
iterator.NextVisible(true);
}
}
var propertyField = new PropertyField(iterator.Copy(), label);
propertyField.BindProperty(iterator);
onBuild?.Invoke(i, propertyField);
propertyField.AddToClassList("property-field");
propertyField.AddToClassList("inner-element");
element.name = type.Name;
element.Add(propertyField);
}
if (type != null)
{
var helps = type.GetCustomAttributes(typeof(ComponentHelpAttribute), false);
if (helps.Length > 0)
{
var label = new UnityEngine.UIElements.Label(((ComponentHelpAttribute)helps[0]).comment);
label.AddToClassList("comment");
element.Add(label);
}
if (typeof(IComponentStatic).IsAssignableFrom(type) == true)
{
var label = new UnityEngine.UIElements.Label("Static");
label.AddToClassList("static-component");
element.AddToClassList("has-static-component");
element.Add(label);
}
if (typeof(IComponentShared).IsAssignableFrom(type) == true)
{
var label = new UnityEngine.UIElements.Label("Shared");
label.AddToClassList("shared-component");
element.AddToClassList("has-shared-component");
element.Add(label);
}
}
container.Add(element);
++i;
} while (iteratorNext.NextVisible(false) == true && depth <= iteratorNext.depth);
}
private void Initialize(AttachToPanelEvent evt)
{
// switch event to do some UI updates instead of initialization from here on out
UnregisterCallback <AttachToPanelEvent>(Initialize);
// Add Header
Add(new TextElement()
{
name = "intro",
text = "Udon Graph",
});
Add(new TextElement()
{
name = "header-message",
text =
"The Udon Graph is your gateway to creating amazing things in VRChat.\nCheck out the Readme and UdonExampleScene in the VRChat Examples folder to get started."
});
var mainContainer = new VisualElement()
{
name = "main",
};
Add(mainContainer);
var template = Resources.Load <VisualTreeAsset>("UdonChangelog") as VisualTreeAsset;
#if UNITY_2019_3_OR_NEWER
var changelog = template.CloneTree((string)null);
#else
var changelog = template.CloneTree(null);
#endif
changelog.name = "changelog";
mainContainer.Add(changelog);
var column2 = new VisualElement()
{
name = "column-2"
};
mainContainer.Add(column2);
// Add Button for Last Graph
if (!string.IsNullOrEmpty(Settings.LastGraphGuid))
{
_openLastGraphButton = new Button(() =>
{
var assetPath = AssetDatabase.GUIDToAssetPath(Settings.LastGraphGuid);
var graphName = assetPath.Substring(assetPath.LastIndexOf("/") + 1).Replace(".asset", "");
// Find actual asset from guid
var asset = AssetDatabase.LoadAssetAtPath <UdonGraphProgramAsset>(assetPath);
if (asset != null)
{
var w = EditorWindow.GetWindow <UdonGraphWindow>("Udon Graph", true, typeof(SceneView));
// get reference to saved UdonBehaviour if possible
UdonBehaviour udonBehaviour = null;
string gPath = Settings.LastUdonBehaviourPath;
string sPath = Settings.LastUdonBehaviourScenePath;
if (!string.IsNullOrEmpty(gPath) && !string.IsNullOrEmpty(sPath))
{
var targetScene = EditorSceneManager.GetSceneByPath(sPath);
if (targetScene != null && targetScene.isLoaded && targetScene.IsValid())
{
var targetObject = GameObject.Find(gPath);
if (targetObject != null)
{
udonBehaviour = targetObject.GetComponent <UdonBehaviour>();
}
}
}
// Initialize graph with restored udonBehaviour or null if not found / not saved
w.InitializeGraph(asset, udonBehaviour);
}
});
UpdateLastGraphButtonLabel();
column2.Add(_openLastGraphButton);
}
var settingsTemplate =
Resources.Load <VisualTreeAsset>("UdonSettings") as VisualTreeAsset;
#if UNITY_2019_3_OR_NEWER
var settings = settingsTemplate.CloneTree((string)null);
#else
var settings = settingsTemplate.CloneTree(null);
#endif
settings.name = "settings";
column2.Add(settings);
// get reference to first settings section
var section = settings.Q("section");
// Add Grid Snap setting
var gridSnapContainer = new VisualElement();
gridSnapContainer.AddToClassList("settings-item-container");
var gridSnapField = new IntegerField(3)
{
value = Settings.GridSnapSize
};
#if UNITY_2019_3_OR_NEWER
gridSnapField.RegisterValueChangedCallback(
#else
gridSnapField.OnValueChanged(
#endif
e => { Settings.GridSnapSize = e.newValue; });
gridSnapContainer.Add(new Label("Grid Snap Size"));
gridSnapContainer.Add(gridSnapField);
section.Add(gridSnapContainer);
var gridSnapLabel = new Label("Snap elements to a grid as you move them. 0 for No Snapping.");
gridSnapLabel.AddToClassList("settings-label");
section.Add(gridSnapLabel);
// Add Search On Selected Node settings
var searchOnSelectedNode = (new Toggle()
{
text = "Focus Search On Selected Node",
value = Settings.SearchOnSelectedNodeRegistry,
});
#if UNITY_2019_3_OR_NEWER
searchOnSelectedNode.RegisterValueChangedCallback(
#else
searchOnSelectedNode.OnValueChanged(
#endif
(toggleEvent) => { Settings.SearchOnSelectedNodeRegistry = toggleEvent.newValue; });
section.Add(searchOnSelectedNode);
var searchOnLabel =
new Label(
"Highlight a node and press Spacebar to open a Search Window focused on nodes for that type. ");
searchOnLabel.AddToClassList("settings-label");
section.Add(searchOnLabel);
// Add Search On Noodle Drop settings
var searchOnNoodleDrop = (new Toggle()
{
text = "Search On Noodle Drop",
value = Settings.SearchOnNoodleDrop,
});
#if UNITY_2019_3_OR_NEWER
searchOnNoodleDrop.RegisterValueChangedCallback(
#else
searchOnNoodleDrop.OnValueChanged(
#endif
(toggleEvent) => { Settings.SearchOnNoodleDrop = toggleEvent.newValue; });
section.Add(searchOnNoodleDrop);
var searchOnDropLabel =
new Label("Drop a noodle into empty space to search for anything that can be connected.");
searchOnDropLabel.AddToClassList("settings-label");
section.Add(searchOnDropLabel);
// Add UseNeonStyle setting
var useNeonStyle = (new Toggle()
{
text = "Use Neon Style",
value = Settings.UseNeonStyle,
});
#if UNITY_2019_3_OR_NEWER
useNeonStyle.RegisterValueChangedCallback(
#else
useNeonStyle.OnValueChanged(
#endif
(toggleEvent) => { Settings.UseNeonStyle = toggleEvent.newValue; });
section.Add(useNeonStyle);
var useNeonStyleLabel =
new Label("Try out an experimental Neon Style. We will support User Styles in an upcoming version.");
useNeonStyleLabel.AddToClassList("settings-label");
section.Add(useNeonStyleLabel);
}
private VisualElement CreateExportSettingsView()
{
var settingsContainer = new VisualElement()
{
name = Styles.exportSettings
};
settingsContainer.AddToClassList(Styles.exportSettings);
var exportTypes = new List <ExportTextureType>()
{
ExportTextureType.Texture2D,
ExportTextureType.Texture3D
};
var exportType = new PopupField <ExportTextureType>(exportTypes, exportTypes[0])
{
name = Styles.exportType,
label = "Type"
};
exportType.RegisterCallback <ChangeEvent <ExportTextureType> >(
(evt) =>
{
if (evt.newValue == ExportTextureType.Texture2D)
{
m_exportSettings.Remove(m_exportDims3D);
m_exportSettings.Insert(1, m_exportDims2D);
}
else if (evt.newValue == ExportTextureType.Texture3D)
{
m_exportSettings.Remove(m_exportDims2D);
m_exportSettings.Insert(1, m_exportDims3D);
}
}
);
var dimensionsField2D = new Vector2IntField()
{
name = Styles.exportDims2D,
label = "Dimensions",
value = new Vector2Int(512, 512)
};
var dimensionsField3D = new Vector3IntField()
{
name = Styles.exportDims3D,
label = "Dimensions",
value = new Vector3Int(64, 64, 64)
};
var m_listOfFormats = new List <GraphicsFormat>()
{
// GraphicsFormat.R8_UNorm,
// GraphicsFormat.R8_SNorm,
GraphicsFormat.R16_UNorm,
// GraphicsFormat.R16_SNorm,
GraphicsFormat.R16_SFloat,
// GraphicsFormat.R32_SFloat,
};
var exportFormat = new PopupField <GraphicsFormat>(m_listOfFormats, GraphicsFormat.R16_UNorm)
{
name = Styles.exportFormat,
label = "Format"
};
settingsContainer.Add(exportType);
settingsContainer.Add(dimensionsField2D);
settingsContainer.Add(exportFormat);
m_exportSettings = settingsContainer;
m_exportType = exportType;
m_exportDims2D = dimensionsField2D;
m_exportDims3D = dimensionsField3D;
m_exportFormat = exportFormat;
exportType.value = ExportTextureType.Texture2D;
return(settingsContainer);
}
public void SelectElement(VisualElement element, string query, SearchHighlight searchHighlight)
{
ClearSearchResults();
var item = FindElement(m_TreeRootItems, element);
if (item == null)
{
return;
}
m_TreeView.SelectItem(item.id);
if (string.IsNullOrEmpty(query))
{
return;
}
var selected = m_TreeView.Q(className: "unity-list-view__item--selected");
if (selected == null || searchHighlight == SearchHighlight.None)
{
return;
}
var content = selected.Q("unity-treeview-item-content");
var labelContainers = content.Query(classes: "unity-debugger-tree-item-label-cont").ToList();
foreach (var labelContainer in labelContainers)
{
var label = labelContainer.Q <Label>();
if (label.ClassListContains("unity-debugger-tree-item-type") && searchHighlight != SearchHighlight.Type)
{
continue;
}
if (label.ClassListContains("unity-debugger-tree-item-name") && searchHighlight != SearchHighlight.Name)
{
continue;
}
if (label.ClassListContains("unity-debugger-tree-item-classlist") && searchHighlight != SearchHighlight.Class)
{
continue;
}
var text = label.text;
var indexOf = text.IndexOf(query, StringComparison.OrdinalIgnoreCase);
if (indexOf < 0)
{
continue;
}
var highlight = new VisualElement();
m_SearchResultsHightlights.Add(highlight);
highlight.AddToClassList("unity-debugger-highlight");
int letterSize = 8;
highlight.style.width = query.Length * letterSize;
highlight.style.left = indexOf * letterSize;
labelContainer.Insert(0, highlight);
break;
}
}
bool TryToPickInHierarchy(Vector2 mousePosition)
{
if (builderHierarchyRoot == null)
{
return(false);
}
var localMouse = builderHierarchyRoot.WorldToLocal(mousePosition);
if (!builderHierarchyRoot.ContainsPoint(localMouse))
{
return(false);
}
// Pick element under mouse.
var pickedElement = Panel.PickAllWithoutValidatingLayout(builderHierarchyRoot, mousePosition);
// Pick the first valid element by walking up the tree.
VisualElement pickedDocumentElement = null;
VisualElement explorerItemReorderZone = null;
while (true)
{
if (pickedElement == null)
{
break;
}
if (IsElementTheScrollView(pickedElement))
{
break;
}
if (pickedElement.ClassListContains(BuilderConstants.ExplorerItemReorderZoneClassName))
{
explorerItemReorderZone = pickedElement;
}
pickedDocumentElement = pickedElement.GetProperty(BuilderConstants.ExplorerItemElementLinkVEPropertyName) as VisualElement;
if (pickedDocumentElement != null)
{
break;
}
pickedElement = pickedElement.parent;
}
// Check if reordering on top of current pickedElement is supported.
var supportsDragBetweenElements = false;
if (explorerItemReorderZone != null && SupportsDragBetweenElements(pickedDocumentElement))
{
pickedElement = explorerItemReorderZone;
supportsDragBetweenElements = true;
}
// Don't allow selection of elements inside template instances.
VisualElement linkedCanvasPickedElement = null;
if (pickedElement != null && pickedElement.ClassListContains(BuilderConstants.ExplorerItemReorderZoneClassName))
{
linkedCanvasPickedElement = GetLinkedElementFromReorderZone(pickedElement);
}
else if (pickedElement != null)
{
linkedCanvasPickedElement = pickedElement.GetProperty(BuilderConstants.ExplorerItemElementLinkVEPropertyName) as VisualElement;
}
// Validate element with implementation.
var hoverElementIsValid = pickedElement != null && (IsElementTheScrollView(pickedElement) || IsPickedElementValid(linkedCanvasPickedElement));
if (!hoverElementIsValid && !supportsDragBetweenElements)
{
pickedElement = null;
}
m_LastHoverElement = pickedElement;
if (pickedElement == null)
{
m_LastRowHoverElement = null;
return(false);
}
// The hover style class may not be applied to the hover element itself. We need
// to find the correct parent.
m_LastRowHoverElement = m_LastHoverElement;
if (!IsElementTheScrollView(pickedElement))
{
while (m_LastRowHoverElement != null && m_LastRowHoverElement.name != s_TreeViewItemName)
{
m_LastRowHoverElement = m_LastRowHoverElement.parent;
}
}
if (hoverElementIsValid)
{
m_LastRowHoverElement.AddToClassList(s_TreeItemHoverHoverClassName);
}
if (supportsDragBetweenElements)
{
m_LastRowHoverElement.AddToClassList(s_TreeItemHoverWithDragBetweenElementsSupportClassName);
}
return(true);
}
void ResetSection(VisualElement section)
{
section.AddToClassList(BuilderConstants.HiddenStyleClassName);
}
void InitializeView()
{
controlsContainer = new VisualElement {
name = "controls"
};
controlsContainer.AddToClassList("NodeControls");
mainContainer.Add(controlsContainer);
rightTitleContainer = new VisualElement {
name = "RightTitleContainer"
};
titleContainer.Add(rightTitleContainer);
topPortContainer = new VisualElement {
name = "TopPortContainer"
};
this.Insert(0, topPortContainer);
bottomPortContainer = new VisualElement {
name = "BottomPortContainer"
};
this.Add(bottomPortContainer);
if (nodeTarget.showControlsOnHover)
{
bool mouseOverControls = false;
controlsContainer.style.display = DisplayStyle.None;
RegisterCallback <MouseOverEvent>(e => {
controlsContainer.style.display = DisplayStyle.Flex;
mouseOverControls = true;
});
RegisterCallback <MouseOutEvent>(e => {
var rect = GetPosition();
var graphMousePosition = owner.contentViewContainer.WorldToLocal(e.mousePosition);
if (rect.Contains(graphMousePosition) || !nodeTarget.showControlsOnHover)
{
return;
}
mouseOverControls = false;
schedule.Execute(_ => {
if (!mouseOverControls)
{
controlsContainer.style.display = DisplayStyle.None;
}
}).ExecuteLater(500);
});
}
Undo.undoRedoPerformed += UpdateFieldValues;
debugContainer = new VisualElement {
name = "debug"
};
if (nodeTarget.debug)
{
mainContainer.Add(debugContainer);
}
title = (string.IsNullOrEmpty(nodeTarget.name)) ? nodeTarget.GetType().Name : nodeTarget.name;
initializing = true;
SetPosition(nodeTarget.position);
SetNodeColor(nodeTarget.color);
AddInputContainer();
}
public void MarkFixed()
{
_root.AddToClassList("-fixed");
}
public void OnEnable()
{
// Each editor window contains a root VisualElement object
VisualElement root = rootVisualElement;
// VisualElements objects can contain other VisualElement following a tree hierarchy.
VisualElement label = new Label("Hello World! From C#");
root.Add(label);
Label label2 = new Label();
label2.text = "Hello World! From C#";
root.Add(label2);
var boxes = new VisualElement
{
name = "boxesContainer"
};
var boxes2 = new VisualElement()
{
name = "boxes2Container"
};
//横並びにする。
boxes.AddToClassList("horizontalContainer");
boxes.Add(new VisualElement {
style = { backgroundColor = Color.blue }
});
boxes.Add(new VisualElement {
style = { backgroundColor = Color.yellow }
});
boxes.Add(new VisualElement {
style = { backgroundColor = Color.green }
});
//縦並びを行う
boxes2.AddToClassList("verticalContainer");
boxes2.Add(new VisualElement {
style = { backgroundColor = Color.red }
});
boxes2.Add(new VisualElement {
style = { backgroundColor = Color.yellow }
});
boxes2.Add(new VisualElement {
style = { backgroundColor = Color.green }
});
//boxes.Add(boxes2);
root.Add(boxes);
root.Add(boxes2);
// A stylesheet can be added to a VisualElement.
// The style will be applied to the VisualElement and all of its children.
var styleSheet = AssetDatabase.LoadAssetAtPath <StyleSheet>("Assets/Editor/Resources/samples.uss");
VisualElement labelWithStyle = new Label("Hello World! With Style");
labelWithStyle.styleSheets.Add(styleSheet);
root.Add(labelWithStyle);
root.styleSheets.Add(styleSheet);
var button = new Button();
button.text = "aaaa";
button.styleSheets.Add(styleSheet);
root.Add(button);
ScrollView scroll = new ScrollView(ScrollViewMode.Vertical);
}
public static void SetDefaultStyle(VisualElement element)
{
element?.AddToClassList(UxmlClassNames.DefaultStyle);
}
public BoxModelView()
{
AddToClassList("box-model-view");
visible = false;
m_OverlayPainter = new HighlightOverlayPainter();
m_Container = new VisualElement();
m_Container.AddToClassList("box-model-view-container");
m_Layer1 = new VisualElement()
{
name = "BoxModelViewLayer1"
};
m_Layer2 = new VisualElement()
{
name = "BoxModelViewLayer2"
};
m_Layer2.style.position = Position.Absolute;
m_Layer2.pickingMode = PickingMode.Ignore;
m_Layer2.StretchToParentSize();
m_TopTextFieldMarginContainer.pickingMode = PickingMode.Ignore;
m_TopTextFieldMarginContainer.AddToClassList("box-model-textfield-top-bottom-spacer");
m_BottomTextFieldMarginContainer.pickingMode = PickingMode.Ignore;
m_BottomTextFieldMarginContainer.AddToClassList("box-model-textfield-top-bottom-spacer");
m_TopTextFieldBorderContainer.pickingMode = PickingMode.Ignore;
m_TopTextFieldBorderContainer.AddToClassList("box-model-textfield-top-bottom-spacer");
m_BottomTextFieldBorderContainer.pickingMode = PickingMode.Ignore;
m_BottomTextFieldBorderContainer.AddToClassList("box-model-textfield-top-bottom-spacer");
m_TopTextFieldPaddingContainer.pickingMode = PickingMode.Ignore;
m_TopTextFieldPaddingContainer.AddToClassList("box-model-textfield-top-bottom-spacer");
m_BottomTextFieldPaddingContainer.pickingMode = PickingMode.Ignore;
m_BottomTextFieldPaddingContainer.AddToClassList("box-model-textfield-top-bottom-spacer");
m_ContentSpacer.pickingMode = PickingMode.Ignore;
m_ContentSpacer.AddToClassList("box-model-textfield-top-bottom-spacer");
m_Layer2.Add(m_TopTextFieldMarginContainer);
m_Layer2.Add(m_TopTextFieldBorderContainer);
m_Layer2.Add(m_TopTextFieldPaddingContainer);
m_Layer2.Add(m_ContentSpacer);
m_Layer2.Add(m_BottomTextFieldPaddingContainer);
m_Layer2.Add(m_BottomTextFieldBorderContainer);
m_Layer2.Add(m_BottomTextFieldMarginContainer);
m_ContentBox = new ContentBox();
m_ContentBox.AddToClassList("box-model");
m_ContentBox.AddToClassList("box-model-container-content");
m_ContentBox.RegisterCallback <MouseOverEvent, BoxType>(OnMouseOver, BoxType.Content);
m_PaddingBox = new BoxModelElement(BoxType.Padding, m_ContentBox,
m_TopTextFieldPaddingContainer, m_BottomTextFieldPaddingContainer);
m_PaddingBox.AddToClassList("box-model");
m_PaddingBox.AddToClassList("box-model-container-padding");
m_PaddingBox.RegisterCallback <MouseOverEvent, BoxType>(OnMouseOver, BoxType.Padding);
m_BorderBox = new BoxModelElement(BoxType.Border, m_PaddingBox,
m_TopTextFieldBorderContainer, m_BottomTextFieldBorderContainer);
m_BorderBox.AddToClassList("box-model");
m_BorderBox.AddToClassList("box-model-container-border");
m_BorderBox.RegisterCallback <MouseOverEvent, BoxType>(OnMouseOver, BoxType.Border);
m_MarginBox = new BoxModelElement(BoxType.Margin, m_BorderBox,
m_TopTextFieldMarginContainer, m_BottomTextFieldMarginContainer);
m_MarginBox.AddToClassList("box-model");
m_MarginBox.AddToClassList("box-model-container-margin");
m_MarginBox.RegisterCallback <MouseOverEvent, BoxType>(OnMouseOver, BoxType.Margin);
m_Layer1.Add(m_MarginBox);
m_Container.Add(m_Layer1);
m_Container.Add(m_Layer2);
var spacerLeft = new VisualElement()
{
style = { flexGrow = 1 }
};
var spacerRight = new VisualElement()
{
style = { flexGrow = 1 }
};
Add(spacerLeft);
Add(m_Container);
Add(spacerRight);
RegisterCallback <MouseOutEvent>(OnMouseOut);
}
// ######################## INITS ######################## //
#region CONSTRUCTORS
public ColorSlider()
{
// load styles
styleSheets.Add(Resources.Load <StyleSheet>("ColorSlider_styles"));
styleSheets.Add(Resources.Load <StyleSheet>("Styles"));
// create and initialize gradient texture
_gradientTexture = new Texture2D(2, 1, TextureFormat.RGBA32, false, QualitySettings.activeColorSpace == ColorSpace.Gamma)
{
hideFlags = HideFlags.HideAndDontSave,
wrapMode = TextureWrapMode.Clamp,
filterMode = FilterMode.Bilinear,
alphaIsTransparency = true
};
_gradientTexture.SetPixel(0, 0, Color.clear);
_gradientTexture.SetPixel(1, 0, Color.clear);
_gradientTexture.Apply();
// set up alpha background
TiledImage background = TiledImage.CreateBackground(Resources.Load <Texture2D>("Images/AlphaCheckerboard"));
background.AddToClassList("unity-base-slider--horizontal");
background.AddToClassList("unity-base-slider__tracker");
background.style.backgroundColor = Color.clear;
// set as child of the first element in the hierarchy of the slider
IEnumerator <VisualElement> children = Children().GetEnumerator();
children.MoveNext();
children.Current.Add(background);
children.Dispose();
background.SendToBack();
// add a field for the value to be displayed
IntegerField valueField = new IntegerField();
valueField.AddToClassList(UssClasses.FILL_HEIGHT);
valueField.AddToClassList("color-slider-value-field");
Add(valueField);
// set up the background of the slider (unity calls this the tracker). This is what holds the gradient texture
VisualElement tracker = this.Q("unity-tracker");
tracker.AddToClassList(UssClasses.FULL);
tracker.AddToClassList(UssClasses.NO_SLICE);
tracker.style.backgroundImage = _gradientTexture;
// set up the handle
VisualElement handle = this.Q("unity-dragger");
handle.AddToClassList("color-slider-handle");
handle.AddToClassList(UssClasses.FILL_HEIGHT);
handle.style.position = Position.Absolute;
#if UNITY_2019_3_OR_NEWER
// remove handle border
VisualElement handleBorder = this.Q("unity-dragger-border");
handleBorder.visible = false;
#endif
// set up the label
labelElement.AddToClassList("color-slider-label");
labelElement.AddToClassList(UssClasses.FILL_HEIGHT);
// register callbacks
this.RegisterValueChangedCallback(evt => valueField.SetValueWithoutNotify((int)evt.newValue));
valueField.RegisterValueChangedCallback(evt =>
{
float clampedValue = Mathf.Clamp(evt.newValue, lowValue, highValue);
valueField.SetValueWithoutNotify((int)clampedValue);
value = clampedValue;
});
}
private void AddMainUI(VisualElement mainView)
{
var visualTree = EditorGUIUtility.Load("UXML/SpriteEditor/SpriteFrameModuleInspector.uxml") as VisualTreeAsset;
m_SelectedFrameInspector = visualTree.CloneTree(null).Q("spriteFrameModuleInspector");
m_NameElement = m_SelectedFrameInspector.Q("name");
m_NameField = m_SelectedFrameInspector.Q <PropertyControl <string> >("spriteName");
m_NameField.OnValueChanged((evt) =>
{
if (hasSelected)
{
selectedSpriteName = evt.newValue;
}
});
m_NameField.RegisterCallback <FocusOutEvent>((focus) =>
{
if (hasSelected)
{
m_NameField.SetValueWithoutNotify(selectedSpriteName);
}
});
m_PositionElement = m_SelectedFrameInspector.Q("position");
m_PositionFieldX = m_PositionElement.Q <PropertyControl <long> >("positionX");
m_PositionFieldX.OnValueChanged((evt) =>
{
if (hasSelected)
{
var rect = selectedSpriteRect;
rect.x = evt.newValue;
selectedSpriteRect = rect;
m_PositionFieldX.SetValueWithoutNotify((long)selectedSpriteRect.x);
}
});
m_PositionFieldY = m_PositionElement.Q <PropertyControl <long> >("positionY");
m_PositionFieldY.OnValueChanged((evt) =>
{
if (hasSelected)
{
var rect = selectedSpriteRect;
rect.y = evt.newValue;
selectedSpriteRect = rect;
m_PositionFieldY.SetValueWithoutNotify((long)selectedSpriteRect.y);
}
});
m_PositionFieldW = m_PositionElement.Q <PropertyControl <long> >("positionW");
m_PositionFieldW.OnValueChanged((evt) =>
{
if (hasSelected)
{
var rect = selectedSpriteRect;
rect.width = evt.newValue;
selectedSpriteRect = rect;
m_PositionFieldW.SetValueWithoutNotify((long)selectedSpriteRect.width);
}
});
m_PositionFieldH = m_PositionElement.Q <PropertyControl <long> >("positionH");
m_PositionFieldH.OnValueChanged((evt) =>
{
if (hasSelected)
{
var rect = selectedSpriteRect;
rect.height = evt.newValue;
selectedSpriteRect = rect;
m_PositionFieldH.SetValueWithoutNotify((long)selectedSpriteRect.height);
}
});
var borderElement = m_SelectedFrameInspector.Q("border");
m_BorderFieldL = borderElement.Q <PropertyControl <long> >("borderL");
m_BorderFieldL.OnValueChanged((evt) =>
{
if (hasSelected)
{
var border = selectedSpriteBorder;
border.x = evt.newValue;
selectedSpriteBorder = border;
m_BorderFieldL.SetValueWithoutNotify((long)selectedSpriteBorder.x);
}
});
m_BorderFieldT = borderElement.Q <PropertyControl <long> >("borderT");
m_BorderFieldT.OnValueChanged((evt) =>
{
if (hasSelected)
{
var border = selectedSpriteBorder;
border.w = evt.newValue;
selectedSpriteBorder = border;
m_BorderFieldT.SetValueWithoutNotify((long)selectedSpriteBorder.w);
evt.StopPropagation();
}
});
m_BorderFieldR = borderElement.Q <PropertyControl <long> >("borderR");
m_BorderFieldR.OnValueChanged((evt) =>
{
if (hasSelected)
{
var border = selectedSpriteBorder;
border.z = evt.newValue;
selectedSpriteBorder = border;
m_BorderFieldR.SetValueWithoutNotify((long)selectedSpriteBorder.z);
}
});
m_BorderFieldB = borderElement.Q <PropertyControl <long> >("borderB");
m_BorderFieldB.OnValueChanged((evt) =>
{
if (hasSelected)
{
var border = selectedSpriteBorder;
border.y = evt.newValue;
selectedSpriteBorder = border;
m_BorderFieldB.SetValueWithoutNotify((long)selectedSpriteBorder.y);
}
});
m_PivotField = m_SelectedFrameInspector.Q <EnumField>("pivotField");
m_PivotField.Init(SpriteAlignment.Center);
m_PivotField.OnValueChanged((evt) =>
{
if (hasSelected)
{
SpriteAlignment alignment = (SpriteAlignment)evt.newValue;
SetSpritePivotAndAlignment(selectedSpritePivot, alignment);
m_CustomPivotElement.SetEnabled(selectedSpriteAlignment == SpriteAlignment.Custom);
Vector2 pivot = selectedSpritePivotInCurUnitMode;
m_CustomPivotFieldX.SetValueWithoutNotify(pivot.x);
m_CustomPivotFieldY.SetValueWithoutNotify(pivot.y);
}
});
m_PivotUnitModeField = m_SelectedFrameInspector.Q <EnumField>("pivotUnitModeField");
m_PivotUnitModeField.Init(PivotUnitMode.Normalized);
m_PivotUnitModeField.OnValueChanged((evt) =>
{
if (hasSelected)
{
m_PivotUnitMode = (PivotUnitMode)evt.newValue;
Vector2 pivot = selectedSpritePivotInCurUnitMode;
m_CustomPivotFieldX.SetValueWithoutNotify(pivot.x);
m_CustomPivotFieldY.SetValueWithoutNotify(pivot.y);
}
});
m_CustomPivotElement = m_SelectedFrameInspector.Q("customPivot");
m_CustomPivotFieldX = m_CustomPivotElement.Q <PropertyControl <double> >("customPivotX");
m_CustomPivotFieldX.OnValueChanged((evt) =>
{
if (hasSelected)
{
float newValue = (float)evt.newValue;
float pivotX = m_PivotUnitMode == PivotUnitMode.Pixels
? ConvertFromRectToNormalizedSpace(new Vector2(newValue, 0.0f), selectedSpriteRect).x
: newValue;
var pivot = selectedSpritePivot;
pivot.x = pivotX;
SetSpritePivotAndAlignment(pivot, selectedSpriteAlignment);
}
});
m_CustomPivotFieldY = m_CustomPivotElement.Q <PropertyControl <double> >("customPivotY");
m_CustomPivotFieldY.OnValueChanged((evt) =>
{
if (hasSelected)
{
float newValue = (float)evt.newValue;
float pivotY = m_PivotUnitMode == PivotUnitMode.Pixels
? ConvertFromRectToNormalizedSpace(new Vector2(0.0f, newValue), selectedSpriteRect).y
: newValue;
var pivot = selectedSpritePivot;
pivot.y = pivotY;
SetSpritePivotAndAlignment(pivot, selectedSpriteAlignment);
}
});
//// Force an update of all the fields.
PopulateSpriteFrameInspectorField();
mainView.RegisterCallback <SpriteSelectionChangeEvent>(SelectionChange);
// Stop mouse events from reaching the main view.
m_SelectedFrameInspector.pickingMode = PickingMode.Ignore;
m_SelectedFrameInspector.RegisterCallback <MouseDownEvent>((e) => { e.StopPropagation(); });
m_SelectedFrameInspector.RegisterCallback <MouseUpEvent>((e) => { e.StopPropagation(); });
m_SelectedFrameInspector.AddToClassList("moduleWindow");
m_SelectedFrameInspector.AddToClassList("bottomRightFloating");
mainView.Add(m_SelectedFrameInspector);
}
public BoxModelElement(BoxType boxType, VisualElement content,
VisualElement topTextFieldContainer, VisualElement bottomTextFieldContainer)
{
string title = "";
switch (boxType)
{
case BoxType.Margin:
title = "margin";
break;
case BoxType.Border:
title = "border";
break;
case BoxType.Padding:
title = "padding";
break;
}
this.boxType = boxType;
m_Title = new Label(title);
m_Title.AddToClassList("box-model-title");
m_CenterContent = content;
m_CenterContent.AddToClassList("box-model-center-content");
m_LeftTextField = new IntegerField();
m_LeftTextField.AddToClassList("box-model-textfield");
m_LeftTextField.RegisterValueChangedCallback(e => OnTextFieldValueChanged(e, SideChanged.Left));
m_RightTextField = new IntegerField();
m_RightTextField.AddToClassList("box-model-textfield");
m_RightTextField.RegisterValueChangedCallback(e => OnTextFieldValueChanged(e, SideChanged.Right));
m_TopTextField = new IntegerField();
m_TopTextField.AddToClassList("box-model-textfield");
m_TopTextField.RegisterValueChangedCallback(e => OnTextFieldValueChanged(e, SideChanged.Top));
m_FakeTopTextField = new IntegerField();
m_FakeTopTextField.AddToClassList("box-model-textfield");
m_FakeTopTextField.visible = false;
m_BottomTextField = new IntegerField();
m_BottomTextField.AddToClassList("box-model-textfield");
m_BottomTextField.RegisterValueChangedCallback(e => OnTextFieldValueChanged(e, SideChanged.Bottom));
m_FakeBottomTextField = new IntegerField();
m_FakeBottomTextField.AddToClassList("box-model-textfield");
m_FakeBottomTextField.visible = false;
m_Left = new VisualElement();
m_Left.AddToClassList("box-model-side");
m_Left.Add(m_LeftTextField);
m_Right = new VisualElement();
m_Right.AddToClassList("box-model-side");
m_Right.Add(m_RightTextField);
m_Center = new VisualElement();
m_Center.AddToClassList("box-model-center");
m_CenterTop = new VisualElement();
m_CenterTop.AddToClassList("box-model-center-top");
m_CenterTop.Add(m_FakeTopTextField);
topTextFieldContainer.Add(m_TopTextField);
m_CenterBottom = new VisualElement();
m_CenterBottom.AddToClassList("box-model-center-bottom");
m_CenterBottom.Add(m_FakeBottomTextField);
bottomTextFieldContainer.Add(m_BottomTextField);
m_Center.Add(m_CenterTop);
m_Center.Add(m_CenterContent);
m_Center.Add(m_CenterBottom);
Add(m_Title);
Add(m_Left);
Add(m_Center);
Add(m_Right);
// Sync styles values
schedule.Execute(SyncValues).Every(100);
}
public MasterPreviewView(string assetName, PreviewManager previewManager, AbstractMaterialGraph graph)
{
this.clippingOptions = ClippingOptions.ClipAndCacheContents;
m_PreviewManager = previewManager;
m_Graph = graph;
AddStyleSheetPath("Styles/MasterPreviewView");
m_PreviewRenderHandle = previewManager.masterRenderData;
var topContainer = new VisualElement()
{
name = "top"
};
{
var title = new Label(assetName.Split('/').Last())
{
name = "title"
};
// Add preview collapse button on top of preview
m_CollapsePreviewContainer = new VisualElement {
name = "collapse-container"
};
m_CollapsePreviewContainer.AddToClassList("collapse-container");
m_CollapsePreviewButton = new VisualElement {
name = "icon"
};
m_CollapsePreviewButton.AddToClassList("icon");
m_CollapsePreviewContainer.Add(m_CollapsePreviewButton);
m_CollapsePreviewContainer.AddManipulator(new Clickable(() =>
{
m_Graph.owner.RegisterCompleteObjectUndo("Collapse Preview");
m_Expanded ^= true;
UpdateExpandedButtonState();
UpdatePreviewVisibility();
}));
topContainer.Add(title);
topContainer.Add(m_CollapsePreviewContainer);
}
Add(topContainer);
m_Preview = new VisualElement {
name = "middle"
};
{
m_PreviewTextureView = CreatePreview(Texture2D.blackTexture);
m_PreviewScrollPosition = new Vector2(0f, 0f);
preview.Add(m_PreviewTextureView);
preview.AddManipulator(new Scrollable(OnScroll));
}
m_PreviewRenderHandle.onPreviewChanged += OnPreviewChanged;
Add(preview);
m_PreviewResizeBorderFrame = new ResizeBorderFrame(previewTextureView, this)
{
name = "resizeBorderFrame"
};
m_PreviewResizeBorderFrame.maintainAspectRatio = true;
Add(m_PreviewResizeBorderFrame);
m_ExpandedPreviewSize = new Vector2(256f, 256f);
m_RecalculateLayout = false;
previewTextureView.RegisterCallback <GeometryChangedEvent>(OnGeometryChanged);
}
