private static void AddComponentSyncSettingFields(VisualElement parent, GUIContent content,
ComponentSyncSettings componentSyncSettings)
{
VisualTreeAsset template = UIElementsEditorUtility.LoadVisualTreeAsset(
Constants.COMPONENT_SYNC_FIELDS_TEMPLATE_PATH);
TemplateContainer templateInstance = template.CloneTree();
VisualElement fieldContainer = templateInstance.Query <VisualElement>("FieldContainer").First();
Label label = templateInstance.Query <Label>().First();
label.text = content.text;
label.tooltip = content.tooltip;
Toggle createToggle = templateInstance.Query <Toggle>("CreateToggle").First();
Assert.IsNotNull(createToggle);
createToggle.SetValueWithoutNotify(componentSyncSettings.CanCreate);
createToggle.RegisterValueChangedCallback((ChangeEvent <bool> changeEvent) => {
componentSyncSettings.CanCreate = changeEvent.newValue;
});
Toggle updateToggle = templateInstance.Query <Toggle>("UpdateToggle").First();
Assert.IsNotNull(updateToggle);
updateToggle.SetValueWithoutNotify(componentSyncSettings.CanUpdate);
updateToggle.RegisterValueChangedCallback((ChangeEvent <bool> changeEvent) => {
componentSyncSettings.CanUpdate = changeEvent.newValue;
});
parent.Add(fieldContainer);
}
internal static VisualElement Create(UIElementsSamples.SampleTreeItem item)
{
var panelContainer = new ScrollView();
panelContainer.name = s_StylesExplorerName;
panelContainer.AddToClassList(s_StylesExplorerClassName);
var innerContainer = new VisualElement();
panelContainer.Add(innerContainer);
innerContainer.AddToClassList(s_ScrollViewContainerClassName);
innerContainer.RegisterCallback <GeometryChangedEvent>(ContainerGeometryChange);
ContainerSetColumnCount(innerContainer);
var leftPanel = CreatePanel();
var rightPanel = CreatePanel();
leftPanel.AddToClassList(s_StylePanelDarkClassName);
rightPanel.AddToClassList(s_StylePanelLightClassName);
leftPanel.styleSheets.Add(UIElementsEditorUtility.GetCommonDarkStyleSheet());
rightPanel.styleSheets.Add(UIElementsEditorUtility.GetCommonLightStyleSheet());
innerContainer.Add(leftPanel);
innerContainer.Add(rightPanel);
return(panelContainer);
}
protected void OnEnterPanel()
{
var p = panel as BaseVisualElementPanel;
if (p != null)
{
if (graphViewShader == null)
{
graphViewShader = EditorGUIUtility.LoadRequired("GraphView/GraphViewUIE.shader") as Shader;
}
p.standardShader = graphViewShader;
HostView ownerView = p.ownerObject as HostView;
if (ownerView != null && ownerView.actualView != null)
{
ownerView.actualView.antiAliasing = 4;
}
// Changing the updaters is assumed not to be a normal use case, except maybe for Unity debugging
// purposes. For that reason, we don't track updater changes.
Panel.BeforeUpdaterChange += OnBeforeUpdaterChange;
Panel.AfterUpdaterChange += OnAfterUpdaterChange;
UpdateDrawChainRegistration(true);
}
// Force DefaultCommonDark.uss since GraphView only has a dark style at the moment
UIElementsEditorUtility.ForceDarkStyleSheet(this);
}
//----------------------------------------------------------------------------------------------------------------------
private MeshSyncUserSettingsProvider() : base(USER_SETTINGS_MENU_PATH, SettingsScope.User)
{
//activateHandler is called when the user clicks on the Settings item in the Settings window.
activateHandler = (string searchContext, VisualElement root) => {
m_dccToolsSettingsTab = new DCCToolsSettingsTab();
//Main Tree
VisualTreeAsset main = UIElementsEditorUtility.LoadVisualTreeAsset(MeshSyncEditorConstants.MAIN_USER_SETTINGS_PATH);
Assert.IsNotNull(main);
main.CloneTree(root);
//Style
UIElementsEditorUtility.LoadAndAddStyle(root.styleSheets, MeshSyncEditorConstants.USER_SETTINGS_STYLE_PATH);
VisualElement content = root.Query <VisualElement>("Content");
if (null == content)
{
Debug.LogError("MeshSync: Can't create User Settings");
return;
}
m_dccToolsSettingsTab.Setup(content);
};
deactivateHandler = () => {
};
//keywords
HashSet <string> meshSyncKeywords = new HashSet <string>(new[] { "MeshSync", });
keywords = meshSyncKeywords;
}
public static void FlagStyleSheetChange()
{
// clear caches that depend on loaded style sheets
UnityEngine.UIElements.StyleSheets.StyleSheetCache.ClearCaches();
// for now we don't bother tracking which panel depends on which style sheet
var iterator = UIElementsUtility.GetPanelsIterator();
while (iterator.MoveNext())
{
var panel = iterator.Current.Value;
// In-game doesn't support styling
if (panel.contextType != ContextType.Editor)
{
continue;
}
// Reload default style sheets to resolve variables if they changed
UIElementsEditorUtility.ReloadDefaultEditorStyleSheets();
panel.DirtyStyleSheets();
var guiView = panel.ownerObject as GUIView;
if (guiView != null)
{
guiView.Repaint();
}
}
}
//----------------------------------------------------------------------------------------------------------------------
public void Setup(VisualElement root)
{
VisualTreeAsset tab = UIElementsEditorUtility.LoadVisualTreeAsset(Constants.SCENE_CACHE_PLAYER_SETTINGS_TAB_PATH);
TemplateContainer tabInstance = tab.CloneTree();
VisualElement content = tabInstance.Query <VisualElement>("Content").First();
m_generatedSCResPathTextField = tabInstance.Query <TextField>("GeneratedSCResPathText").First();
m_generatedSCResPathTextField.RegisterValueChangedCallback((ChangeEvent <string> changeEvent) => {
MeshSyncRuntimeSettings settings = MeshSyncRuntimeSettings.GetOrCreateSettings();
settings.SetSceneCacheOutputPath(changeEvent.newValue);
settings.SaveSettings();
});
m_outputPathSelectButton = tabInstance.Query <Button>("OutputPathSelectButton").First();
m_outputPathSelectButton.clicked += OnOutputPathSelectButtonClicked;
RefreshSettings();
//MeshSyncPlayerConfig
MeshSyncPlayerConfigSection section = new MeshSyncPlayerConfigSection(MeshSyncPlayerType.CACHE_PLAYER);
section.Setup(content);
root.Add(tabInstance);
}
private static StyleSheet LoadAndResolveStyleSheet(bool isDarkTheme)
{
var styleSheet = ScriptableObject.CreateInstance <StyleSheet>();
styleSheet.hideFlags = HideFlags.HideAndDontSave;
styleSheet.isUnityStyleSheet = true;
var packageManagerThemeVariablesSheetPath = isDarkTheme ? k_PackageManagerDarkVariablesSheetPath : k_PackageManagerLightVariablesSheetPath;
var variablesThemeStyleSheetPath = isDarkTheme ? UIElementsEditorUtility.s_DefaultCommonDarkStyleSheetPath : UIElementsEditorUtility.s_DefaultCommonLightStyleSheetPath;
var extensionThemeStyleSheetPath = isDarkTheme ? k_ExtensionDarkVariablesSheetPath : k_ExtensionLightVariablesSheetPath;
var packageManagerCommon = EditorGUIUtility.Load(k_PackageManagerCommonStyleSheetPath) as StyleSheet;
var packageManagerTheme = EditorGUIUtility.Load(packageManagerThemeVariablesSheetPath) as StyleSheet;
var packageManagerStyles = k_PackageManagerStyleSheetPaths.Select(p => EditorGUIUtility.Load(p) as StyleSheet).ToArray();
var variableThemeSheet = EditorGUIUtility.Load(UIElementsEditorUtility.GetStyleSheetPathForCurrentFont(variablesThemeStyleSheetPath)) as StyleSheet;
var extensionThemeStyleSheet = EditorGUIUtility.Load(extensionThemeStyleSheetPath) as StyleSheet;
var resolver = new StyleSheets.StyleSheetResolver();
resolver.AddStyleSheets(variableThemeSheet, extensionThemeStyleSheet, packageManagerCommon, packageManagerTheme);
resolver.AddStyleSheets(packageManagerStyles);
resolver.ResolveTo(styleSheet);
return(styleSheet);
}
public void CheckUserSettingUIElements()
{
Assert.IsNotNull(UIElementsEditorUtility.LoadVisualTreeAsset(Constants.MAIN_USER_SETTINGS_PATH));
Assert.IsNotNull(UIElementsEditorUtility.LoadVisualTreeAsset(Constants.DCC_TOOLS_SETTINGS_CONTAINER_PATH));
Assert.IsNotNull(UIElementsEditorUtility.LoadVisualTreeAsset(Constants.DCC_TOOL_INFO_TEMPLATE_PATH));
Assert.IsNotNull(LoadStyleSheet(Constants.USER_SETTINGS_STYLE_PATH));
}
public static bool IsUnityEditorStyleSheet(this StyleSheet styleSheet)
{
if ((UIElementsEditorUtility.IsCommonDarkStyleSheetLoaded() && styleSheet == UIElementsEditorUtility.GetCommonDarkStyleSheet()) ||
(UIElementsEditorUtility.IsCommonLightStyleSheetLoaded() && styleSheet == UIElementsEditorUtility.GetCommonLightStyleSheet()))
{
return(true);
}
return(false);
}
void OnEnterPanel(AttachToPanelEvent e)
{
// Force DefaultCommonDark.uss since GraphView only has a dark style at the moment
UIElementsEditorUtility.ForceDarkStyleSheet(this);
if (isReframable)
{
panel.visualTree.RegisterCallback <KeyDownEvent>(OnKeyDownShortcut);
}
}
//----------------------------------------------------------------------------------------------------------------------
MeshSyncSettingsProvider() : base(PROJECT_SETTINGS_MENU_PATH, SettingsScope.Project)
{
m_tabs = new IMeshSyncSettingsTab[MeshSyncEditorConstants.MAX_SETTINGS_TAB];
Button[] tabButtons = new Button[MeshSyncEditorConstants.MAX_SETTINGS_TAB];
m_tabs[MeshSyncEditorConstants.GENERAL_SETTINGS_TAB] = new GeneralSettingsTab();
m_tabs[MeshSyncEditorConstants.DCC_TOOLS_SETTINGS_TAB] = new DCCToolsSettingsTab();
//activateHandler is called when the user clicks on the Settings item in the Settings window.
activateHandler = (string searchContext, VisualElement root) => {
//Main Tree
VisualTreeAsset main = UIElementsEditorUtility.LoadVisualTreeAsset(
Path.Combine(MeshSyncEditorConstants.PROJECT_SETTINGS_UIELEMENTS_PATH, "ProjectSettings_Main")
);
main.CloneTree(root);
//Tab Buttons
VisualElement tabsContainer = root.Query <VisualElement>("TabsContainer");
VisualTreeAsset tabButtonTemplate = UIElementsEditorUtility.LoadVisualTreeAsset(
Path.Combine(MeshSyncEditorConstants.PROJECT_SETTINGS_UIELEMENTS_PATH, "TabButtonTemplate")
);
tabButtons[0] = CreateButton(tabButtonTemplate, Contents.GeneralSettings, OnGeneralSettingsTabClicked);
tabButtons[1] = CreateButton(tabButtonTemplate, Contents.DCCTools, OnDCCToolsTabClicked);
foreach (Button tabButton in tabButtons)
{
tabsContainer.Add(tabButton);
}
//Style
UIElementsEditorUtility.LoadAndAddStyle(
root.styleSheets,
Path.Combine(MeshSyncEditorConstants.PROJECT_SETTINGS_UIELEMENTS_PATH, "ProjectSettings_Style")
);
m_content = root.Query <VisualElement>("Content");
UpdateSelectedTabButton(tabButtons[0]);
SetupTab(MeshSyncEditorConstants.GENERAL_SETTINGS_TAB);
};
deactivateHandler = () => {
SetupTab(MeshSyncEditorConstants.UNINITIALIZED_TAB);
};
//keywords
HashSet <string> meshSyncKeywords = new HashSet <string>(new[] { "MeshSync", });
meshSyncKeywords.UnionWith(GetSearchKeywordsFromGUIContentProperties <MeshSyncSettingsProvider.Contents>());
meshSyncKeywords.UnionWith(GetSearchKeywordsFromGUIContentProperties <GeneralSettingsTab.Contents>());
keywords = meshSyncKeywords;
}
public void VerifyUIElementsResources()
{
VisualTreeAsset main = UIElementsEditorUtility.LoadVisualTreeAsset(SISEditorConstants.MAIN_USER_SETTINGS_PATH);
Assert.IsNotNull(main);
//Style
StyleSheet styleSheet = AssetDatabase.LoadAssetAtPath <StyleSheet>(SISEditorConstants.USER_SETTINGS_STYLE_PATH + ".uss");
Assert.IsNotNull(styleSheet);
}
//----------------------------------------------------------------------------------------------------------------------
//Support Toggle, FloatField, etc
private F AddField <F, V>(VisualElement parent, GUIContent content,
V initialValue, Action <V> onValueChanged) where F : VisualElement, INotifyValueChanged <V>, new()
{
F field = UIElementsEditorUtility.AddField <F, V>(parent, content, initialValue, (ChangeEvent <V> changeEvent) => {
onValueChanged(changeEvent.newValue);
MeshSyncProjectSettings.GetOrCreateInstance().SaveInEditor();
});
field.AddToClassList("project-settings-field");
return(field);
}
public void CheckProjectSettingUIElements()
{
Assert.IsNotNull(UIElementsEditorUtility.LoadVisualTreeAsset(Constants.MAIN_PROJECT_SETTINGS_PATH));
Assert.IsNotNull(UIElementsEditorUtility.LoadVisualTreeAsset(Constants.SERVER_SETTINGS_TAB_PATH));
Assert.IsNotNull(UIElementsEditorUtility.LoadVisualTreeAsset(Constants.SCENE_CACHE_PLAYER_SETTINGS_TAB_PATH));
Assert.IsNotNull(UIElementsEditorUtility.LoadVisualTreeAsset(Constants.TAB_BUTTON_TEMPLATE_PATH));
Assert.IsNotNull(UIElementsEditorUtility.LoadVisualTreeAsset(Constants.PROJECT_SETTINGS_FIELD_TEMPLATE_PATH));
Assert.IsNotNull(UIElementsEditorUtility.LoadVisualTreeAsset(Constants.MESHSYNC_PLAYER_CONFIG_CONTAINER_PATH));
Assert.IsNotNull(LoadStyleSheet(Constants.PROJECT_SETTINGS_STYLE_PATH));
}
public PanelSplitter(VisualElement affectedElement)
{
m_AffectedElement = affectedElement;
style.cursor = UIElementsEditorUtility.CreateDefaultCursorStyle(MouseCursor.ResizeHorizontal);
style.width = k_SplitterWidth;
style.minWidth = k_SplitterWidth;
style.maxWidth = k_SplitterWidth;
RegisterCallback <MouseDownEvent>(OnMouseDown, Capture.Capture);
RegisterCallback <MouseMoveEvent>(OnMouseMove, Capture.Capture);
RegisterCallback <MouseUpEvent>(OnMouseUp, Capture.Capture);
}
public void AddFields()
{
VisualElement parent = new VisualElement();
GUIContent content = new GUIContent("My field");
IntegerField intField = UIElementsEditorUtility.AddField <IntegerField, int>(parent, content, 100, null);
Assert.IsNotNull(intField);
PopupField <int> popupField = UIElementsEditorUtility.AddPopupField(parent, content, new List <int> {
0, 1, 2, 3, 4
}, 0, null);
Assert.IsNotNull(popupField);
}
//----------------------------------------------------------------------------------------------------------------------
MeshSyncProjectSettingsProvider() : base(PROJECT_SETTINGS_MENU_PATH, SettingsScope.Project)
{
m_tabs = new IMeshSyncSettingsTab[MeshSyncEditorConstants.MAX_SETTINGS_TAB];
Button[] tabButtons = new Button[MeshSyncEditorConstants.MAX_SETTINGS_TAB];
m_tabs[MeshSyncEditorConstants.SERVER_SETTINGS_TAB] = new ServerSettingsTab();
m_tabs[MeshSyncEditorConstants.SCENE_CACHE_PLAYER_SETTINGS_TAB] = new SceneCachePlayerSettingsTab();
//activateHandler is called when the user clicks on the Settings item in the Settings window.
activateHandler = (string searchContext, VisualElement root) => {
//Main Tree
VisualTreeAsset main = UIElementsEditorUtility.LoadVisualTreeAsset(Constants.MAIN_PROJECT_SETTINGS_PATH);
main.CloneTree(root);
//Tab Buttons
VisualElement tabsContainer = root.Query <VisualElement>("TabsContainer");
VisualTreeAsset btnTemplate = UIElementsEditorUtility.LoadVisualTreeAsset(Constants.TAB_BUTTON_TEMPLATE_PATH);
tabButtons[0] = CreateButton(btnTemplate, Contents.Server, OnServerSettingsTabClicked);
tabButtons[1] = CreateButton(btnTemplate, Contents.SceneCachePlayer, OnSceneCachePlayerTabClicked);
foreach (Button tabButton in tabButtons)
{
tabsContainer.Add(tabButton);
}
//Style
UIElementsEditorUtility.LoadAndAddStyle(root.styleSheets, Constants.PROJECT_SETTINGS_STYLE_PATH);
m_content = root.Query <VisualElement>("Content");
UpdateSelectedTabButton(tabButtons[0]);
SetupTab(MeshSyncEditorConstants.SERVER_SETTINGS_TAB);
};
deactivateHandler = () => {
SetupTab(MeshSyncEditorConstants.UNINITIALIZED_TAB);
};
//keywords
HashSet <string> meshSyncKeywords = new HashSet <string>(new[] { "MeshSync", });
meshSyncKeywords.UnionWith(GetSearchKeywordsFromGUIContentProperties <MeshSyncProjectSettingsProvider.Contents>());
meshSyncKeywords.UnionWith(GetSearchKeywordsFromGUIContentProperties <ServerSettingsTab.Contents>());
meshSyncKeywords.UnionWith(GetSearchKeywordsFromGUIContentProperties <SceneCachePlayerSettingsTab.Contents>());
meshSyncKeywords.UnionWith(GetSearchKeywordsFromGUIContentProperties <MeshSyncPlayerConfigSection.Contents>());
keywords = meshSyncKeywords;
}
private VisualElement CreateRoot <TMode>() where TMode : EditorMode
{
var type = typeof(TMode);
var namePostfix = type == typeof(DefaultEditorMode) ? "" : "-" + type.Name;
var name = "rootVisualContainer" + namePostfix;
var root = new VisualElement()
{
name = VisualElementUtils.GetUniqueName(name),
pickingMode = PickingMode.Ignore, // do not eat events so IMGUI gets them
persistenceKey = name
};
UIElementsEditorUtility.AddDefaultEditorStyleSheets(root);
return(root);
}
private static VisualElement CreateRoot()
{
var name = "rootVisualContainer";
var root = new VisualElement()
{
name = VisualElementUtils.GetUniqueName(name),
pickingMode = PickingMode.Ignore, // do not eat events so IMGUI gets them
viewDataKey = name,
renderHints = RenderHints.ClipWithScissors
};
root.pseudoStates |= PseudoStates.Root;
UIElementsEditorUtility.AddDefaultEditorStyleSheets(root);
root.style.overflow = UnityEngine.UIElements.Overflow.Hidden;
return(root);
}
void OnAddDCCToolButtonClicked(EventBase evt)
{
string path = null;
if (Application.platform == RuntimePlatform.OSXEditor)
{
path = OpenFilePanel();
}
else
{
path = OpenFolderPanel();
}
if (string.IsNullOrEmpty(path))
{
return;
}
//Find the path to the actual app
DCCToolType lastDCCToolType = DCCToolType.AUTODESK_MAYA;
DCCToolInfo dccToolInfo = null;
for (int i = 0; i < (int)(DCCToolType.NUM_DCC_TOOL_TYPES) && null == dccToolInfo; ++i)
{
lastDCCToolType = (DCCToolType)(i);
dccToolInfo = DCCFinderUtility.FindDCCToolInDirectory(lastDCCToolType, null, path);
}
if (null == dccToolInfo)
{
EditorUtility.DisplayDialog("MeshSync Project Settings", "No DCC Tool is detected", "Ok");
return;
}
MeshSyncEditorSettings settings = MeshSyncEditorSettings.GetOrCreateSettings();
if (settings.AddDCCTool(dccToolInfo))
{
//Add to ScrollView
VisualTreeAsset dccToolInfoTemplate = UIElementsEditorUtility.LoadVisualTreeAsset(
MeshSyncEditorConstants.DCC_TOOL_INFO_TEMPLATE_PATH
);
ScrollView scrollView = GetEventButtonUserDataAs <ScrollView>(evt.target);
Assert.IsNotNull(scrollView);
AddDCCToolSettingsContainer(dccToolInfo, scrollView, dccToolInfoTemplate);
}
}
//----------------------------------------------------------------------------------------------------------------------
private void SetupInternal(VisualElement root)
{
m_dccStatusLabels.Clear();
m_dccContainers.Clear();
m_root = root;
m_root.Clear();
m_installPluginButtons.Clear();
VisualTreeAsset container = UIElementsEditorUtility.LoadVisualTreeAsset(
MeshSyncEditorConstants.DCC_TOOLS_SETTINGS_CONTAINER_PATH
);
VisualTreeAsset dccToolInfoTemplate = UIElementsEditorUtility.LoadVisualTreeAsset(
MeshSyncEditorConstants.DCC_TOOL_INFO_TEMPLATE_PATH
);
TemplateContainer containerInstance = container.CloneTree();
ScrollView scrollView = containerInstance.Query <ScrollView>().First();
//Buttons
Button autoDetectDCCButton = containerInstance.Query <Button>("AutoDetectDCCButton").First();
autoDetectDCCButton.clickable.clicked += OnAutoDetectDCCButtonClicked;
m_checkPluginUpdatesButton = containerInstance.Query <Button>("ChecksPluginUpdatesButton").First();
m_checkPluginUpdatesButton.clickable.clicked += OnCheckPluginUpdatesButtonClicked;
Button addDCCToolButton = containerInstance.Query <Button>("AddDCCToolButton").First();
addDCCToolButton.userData = scrollView;
addDCCToolButton.clickable.clickedWithEventInfo += OnAddDCCToolButtonClicked;
//Label
m_footerStatusLabel = containerInstance.Query <Label>("FooterStatusLabel").First();
//Add detected DCCTools to ScrollView
MeshSyncEditorSettings settings = MeshSyncEditorSettings.GetOrCreateSettings();
foreach (KeyValuePair <string, DCCToolInfo> dccToolInfo in settings.GetDCCToolInfos())
{
AddDCCToolSettingsContainer(dccToolInfo.Value, scrollView, dccToolInfoTemplate);
}
//Add the container of this tab to root
root.Add(containerInstance);
}
//----------------------------------------------------------------------------------------------------------------------
private SISUserSettingsProvider() : base(USER_SETTINGS_MENU_PATH, SettingsScope.User)
{
//activateHandler is called when the user clicks on the Settings item in the Settings window.
activateHandler = (string searchContext, VisualElement root) => {
//Main Tree
VisualTreeAsset main = UIElementsEditorUtility.LoadVisualTreeAsset(SISEditorConstants.MAIN_USER_SETTINGS_PATH);
Assert.IsNotNull(main);
main.CloneTree(root);
//Style
UIElementsEditorUtility.LoadAndAddStyle(root.styleSheets, SISEditorConstants.USER_SETTINGS_STYLE_PATH);
VisualElement content = root.Query <VisualElement>("Content");
Assert.IsNotNull(content);
//Fields
InitMaxMemoryForImagesField(content);
InitDefaultSISPlayableAssetFPSField(content);
m_activated = true;
};
deactivateHandler = () => {
if (m_activated)
{
m_maxMemoryForImagesSliderInt.Unbind();
m_maxMemoryForImagesIntField.Unbind();
Object.DestroyImmediate(m_maxMemoryForImagesScriptableObject);
m_maxMemoryForImagesScriptableObject = null;
m_activated = false;
}
};
//keywords
HashSet <string> sisKeywords = new HashSet <string>(new[] { "StreamingImageSequence", });
sisKeywords.UnionWith(GetSearchKeywordsFromGUIContentProperties <SISUserSettingsProvider.Contents>());
keywords = sisKeywords;
}
//----------------------------------------------------------------------------------------------------------------------
private static TemplateContainer InstantiateContainer(MeshSyncPlayerType playerType)
{
VisualTreeAsset container = null;
switch (playerType)
{
case MeshSyncPlayerType.SERVER:
container = UIElementsEditorUtility.LoadVisualTreeAsset(Constants.SERVER_CONFIG_CONTAINER_PATH);
break;
case MeshSyncPlayerType.CACHE_PLAYER:
container = UIElementsEditorUtility.LoadVisualTreeAsset(Constants.SCENE_CACHE_PLAYER_CONFIG_CONTAINER_PATH);
break;
default:
Assert.Fail();
break;
}
return(container.CloneTree());
}
//----------------------------------------------------------------------------------------------------------------------
public void Setup(VisualElement root)
{
VisualTreeAsset tab = UIElementsEditorUtility.LoadVisualTreeAsset(Constants.SERVER_SETTINGS_TAB_PATH);
TemplateContainer tabInstance = tab.CloneTree();
VisualElement content = tabInstance.Query <VisualElement>("Content").First();
//Templates
VisualTreeAsset fieldTemplate = LoadVisualTreeAsset(Constants.PROJECT_SETTINGS_FIELD_TEMPLATE_PATH);
MeshSyncRuntimeSettings runtimeSettings = MeshSyncRuntimeSettings.GetOrCreateSettings();
//Add server port
m_serverPortField = AddField <IntegerField, int>(fieldTemplate, content, Contents.ServerPort,
runtimeSettings.GetDefaultServerPort(),
(int newValue) => {
MeshSyncRuntimeSettings settings = MeshSyncRuntimeSettings.GetOrCreateSettings();
settings.SetDefaultServerPort((ushort)newValue);
}
);
m_allowPublicAccessToggle = AddField <Toggle, bool>(fieldTemplate, content, Contents.AllowPublicAccess,
runtimeSettings.GetServerPublicAccess(),
(bool newValue) => {
MeshSyncRuntimeSettings settings = MeshSyncRuntimeSettings.GetOrCreateSettings();
settings.SetServerPublicAccess(newValue);
}
);
//MeshSyncPlayerConfig section
MeshSyncPlayerConfigSection section = new MeshSyncPlayerConfigSection(MeshSyncPlayerType.SERVER);
section.Setup(content);
root.Add(tabInstance);
}
//----------------------------------------------------------------------------------------------------------------------
public void Setup(VisualElement root)
{
Assert.IsNotNull(root);
root.Clear();
VisualTreeAsset tab = UIElementsEditorUtility.LoadVisualTreeAsset(Constants.SERVER_SETTINGS_TAB_PATH);
TemplateContainer tabInstance = tab.CloneTree();
VisualElement content = tabInstance.Query <VisualElement>("Content").First();
MeshSyncProjectSettings projectSettings = MeshSyncProjectSettings.GetOrCreateInstance();
//Add server port
m_serverPortField = AddField <IntegerField, int>(content, Contents.ServerPort,
projectSettings.GetDefaultServerPort(),
(int newValue) => { projectSettings.SetDefaultServerPort((ushort)newValue); }
);
m_allowPublicAccessToggle = AddField <Toggle, bool>(content, Contents.AllowPublicAccess,
projectSettings.GetServerPublicAccess(),
(bool newValue) => { projectSettings.SetServerPublicAccess(newValue); }
);
//MeshSyncPlayerConfig section
MeshSyncPlayerConfigSection section = new MeshSyncPlayerConfigSection(MeshSyncPlayerType.SERVER);
section.Setup(content);
Button resetButton = tabInstance.Query <Button>("ResetButton").First();
resetButton.clicked += () => {
projectSettings.ResetDefaultServerConfig();
projectSettings.SaveInEditor();
Setup(root);
};
root.Add(tabInstance);
}
//----------------------------------------------------------------------------------------------------------------------
//Support Toggle, FloatField, etc
private F AddPlayerConfigField <F, V>(VisualElement parent, GUIContent content, V initialValue,
Action <V> onValueChanged, string containerClass = null) where F : VisualElement, INotifyValueChanged <V>, new()
{
F field = UIElementsEditorUtility.AddField <F, V>(parent, content, initialValue, (ChangeEvent <V> changeEvent) => {
F targetField = (changeEvent.target) as F;
if (null == targetField)
{
return;
}
onValueChanged(changeEvent.newValue);
MeshSyncProjectSettings.GetOrCreateInstance().SaveInEditor();
});
field.AddToClassList("general-settings-field");
if (!string.IsNullOrEmpty(containerClass))
{
field.parent.AddToClassList(containerClass);
}
return(field);
}
//----------------------------------------------------------------------------------------------------------------------
public void Setup(VisualElement root)
{
m_dccStatusLabels.Clear();
m_dccContainers.Clear();
m_root = root;
m_root.Clear();
VisualTreeAsset container = UIElementsEditorUtility.LoadVisualTreeAsset(
MeshSyncEditorConstants.DCC_TOOLS_SETTINGS_CONTAINER_PATH
);
VisualTreeAsset dccToolInfoTemplate = UIElementsEditorUtility.LoadVisualTreeAsset(
MeshSyncEditorConstants.DCC_TOOL_INFO_TEMPLATE_PATH
);
TemplateContainer containerInstance = container.CloneTree();
ScrollView scrollView = containerInstance.Query <ScrollView>().First();
//[TODO-sin: 2020-4-24] Auto detect installed DCC tools + check MeshSync status
MeshSyncEditorSettings settings = MeshSyncEditorSettings.GetOrCreateSettings();
foreach (var dccToolInfo in settings.GetDCCToolInfos())
{
AddDCCToolSettingsContainer(dccToolInfo.Value, scrollView, dccToolInfoTemplate);
}
//Buttons
Button autoDetectButton = containerInstance.Query <Button>("AutoDetectButton").First();
autoDetectButton.clickable.clicked += OnAutoDetectButtonClicked;
Button addDCCToolButton = containerInstance.Query <Button>("AddDCCToolButton").First();
addDCCToolButton.clickable.clicked += OnAddDCCToolButtonClicked;
//Add the container of this tab to root
root.Add(containerInstance);
}
// VLadN: Use our own ForceDarkStyleSheet as UIToolkit version also affects parent elements
// (UIElementsEditorUtility.ForceDarkStyleSheet)
// This makes it that panels outside of graphview like node inspector and toolbar are also forced in dark incorrectly
private static void ForceDarkStyleSheet(VisualElement ele)
{
if (EditorGUIUtility.isProSkin)
{
return;
}
#if UNITY_2020_3_OR_NEWER
StyleSheet commonLightStyleSheet = UIElementsEditorUtility.GetCommonLightStyleSheet();
StyleSheet commonDarkStyleSheet = UIElementsEditorUtility.GetCommonDarkStyleSheet();
#else
StyleSheet commonLightStyleSheet = UIElementsEditorUtility.s_DefaultCommonLightStyleSheet;
StyleSheet commonDarkStyleSheet = UIElementsEditorUtility.s_DefaultCommonDarkStyleSheet;
#endif
VisualElement visualElement = ele;
{
VisualElementStyleSheetSet styleSheets = visualElement.styleSheets;
if (styleSheets.Contains(commonLightStyleSheet))
{
styleSheets = visualElement.styleSheets;
styleSheets.Swap(commonLightStyleSheet, commonDarkStyleSheet);
}
}
}
void SetupLabel()
{
if (typeof(IValueField <U>).IsAssignableFrom(typeof(T)))
{
if (typeof(U) == typeof(float))
{
var dragger = new VFXFieldMouseDragger <float>((IValueField <float>)m_Control, DragValueFinished);
dragger.SetDragZone(m_Label);
m_Label.style.cursor = UIElementsEditorUtility.CreateDefaultCursorStyle(MouseCursor.SlideArrow);
}
else if (typeof(U) == typeof(double))
{
var dragger = new VFXFieldMouseDragger <double>((IValueField <double>)m_Control, DragValueFinished);
dragger.SetDragZone(m_Label);
m_Label.style.cursor = UIElementsEditorUtility.CreateDefaultCursorStyle(MouseCursor.SlideArrow);
}
else if (typeof(U) == typeof(long))
{
var dragger = new VFXFieldMouseDragger <long>((IValueField <long>)m_Control, DragValueFinished);
dragger.SetDragZone(m_Label);
m_Label.style.cursor = UIElementsEditorUtility.CreateDefaultCursorStyle(MouseCursor.SlideArrow);
}
else if (typeof(U) == typeof(int))
{
var dragger = new VFXFieldMouseDragger <int>((IValueField <int>)m_Control, DragValueFinished);
dragger.SetDragZone(m_Label);
m_Label.style.cursor = UIElementsEditorUtility.CreateDefaultCursorStyle(MouseCursor.SlideArrow);
}
}
m_IndeterminateLabel = new Label()
{
name = "indeterminate",
text = VFXControlConstants.indeterminateText
};
m_IndeterminateLabel.SetEnabled(false);
}
//----------------------------------------------------------------------------------------------------------------------
private PopupField <T> AddPlayerConfigPopupField <T>(VisualElement parent, GUIContent content,
List <T> options, T initialValue, Action <int> onValueChanged,
string containerClass = null)
{
PopupField <T> popupField = UIElementsEditorUtility.AddPopupField <T>(parent, content, options, initialValue,
(ChangeEvent <T> changeEvent) => {
PopupField <T> targetField = (changeEvent.target) as PopupField <T>;
if (null == targetField)
{
return;
}
onValueChanged(targetField.index);
MeshSyncProjectSettings.GetOrCreateInstance().SaveInEditor();
}
);
popupField.AddToClassList("general-settings-field");
if (!string.IsNullOrEmpty(containerClass))
{
popupField.parent.AddToClassList(containerClass);
}
return(popupField);
}
