void SetUpFileMenu() { m_FileMenu.menu.AppendAction("New", a => { NewDocument(); }); if (Unsupported.IsDeveloperMode()) { m_FileMenu.menu.AppendAction("New (Test)", a => { NewTestDocument(); }); } m_FileMenu.menu.AppendSeparator(); m_FileMenu.menu.AppendAction("Save", a => { PromptSaveDocumentDialog(); }); m_FileMenu.menu.AppendAction("Save As...", a => { PromptSaveAsDocumentDialog(); }); m_FileMenu.menu.AppendSeparator(); m_FileMenu.menu.AppendAction("Open...", a => { var path = OpenLoadFileDialog(BuilderConstants.ToolbarLoadUxmlDialogTitle, BuilderConstants.Uxml); if (string.IsNullOrEmpty(path)) { return; } var appPath = Application.dataPath; if (path.StartsWith(appPath)) { path = "Assets/" + path.Substring(appPath.Length); } else { Debug.LogError(BuilderConstants.ToolbarCannotLoadUxmlOutsideProjectMessage); return; } var asset = AssetDatabase.LoadAssetAtPath <VisualTreeAsset>(path); if (asset == null) { Debug.LogError(BuilderConstants.ToolbarSelectedAssetIsInvalidMessage); return; } LoadDocument(asset); }); }
public static void StorePanelPrefs() { if (Unsupported.IsDeveloperMode() || UnityConnect.preferencesEnabled) { foreach (KeyValuePair <string, UnityConnectPrefs.CloudPanelPref> current in UnityConnectPrefs.m_CloudPanelPref) { current.Value.StoreCloudServicePref(); } } }
void SetUpFileMenu() { m_FileMenu.menu.AppendAction("New", a => { NewDocument(); }); if (Unsupported.IsDeveloperMode()) { m_FileMenu.menu.AppendAction("New (Test)", a => { NewTestDocument(); }); m_FileMenu.menu.AppendAction("New (Test Variables)", a => { NewTestVariablesDocument(); }); } m_FileMenu.menu.AppendAction("Open...", a => { var path = OpenLoadFileDialog(BuilderConstants.ToolbarLoadUxmlDialogTitle, BuilderConstants.Uxml); if (string.IsNullOrEmpty(path)) { return; } var appPath = Application.dataPath; if (path.StartsWith(appPath)) { path = "Assets/" + path.Substring(appPath.Length); } else { Debug.LogError(BuilderConstants.ToolbarCannotLoadUxmlOutsideProjectMessage); return; } var asset = BuilderPackageUtilities.LoadAssetAtPath <VisualTreeAsset>(path); LoadDocument(asset, false, false, path); }); m_FileMenu.menu.AppendSeparator(); m_FileMenu.menu.AppendAction("Save", a => { SaveDocument(false); }); m_FileMenu.menu.AppendAction("Save As...", a => { SaveDocument(true); }); }
public static void StorePanelPrefs() { if (!Unsupported.IsDeveloperMode() && !UnityConnect.preferencesEnabled) { return; } foreach (KeyValuePair <string, CloudPanelPref> kvp in m_CloudPanelPref) { kvp.Value.StoreCloudServicePref(); } }
public override void OnActivate(string searchContext, VisualElement rootElement) { // TODO: Switch to use uxml/uss for this. var root = new VisualElement(); rootElement.Add(root); var title = new Label(Title); title.style.unityFontStyleAndWeight = FontStyle.Bold; title.style.marginTop = 1; title.style.fontSize = 19; title.style.unityTextAlign = TextAnchor.MiddleLeft; title.style.height = 26; root.Add(title); Resources.Templates.Settings.AddStyles(rootElement); foreach (var kvp in s_Settings) { if (kvp.Value.All(w => w.Internal) && !Unsupported.IsDeveloperMode()) { continue; } var label = new Label { text = kvp.Key }; label.style.unityFontStyleAndWeight = FontStyle.Bold; root.Add(label); foreach (var wrapper in kvp.Value) { if (wrapper.Internal && !Unsupported.IsDeveloperMode()) { continue; } var setting = wrapper.Setting; var element = new PropertyElement(); element.style.marginLeft = -3; element.SetAttributeFilter(AttributeFilter); element.SetTarget(setting); element.OnChanged += (propertyElement, path) => setting.OnSettingChanged(path); root.Add(element); element.RegisterCallback <GeometryChangedEvent>(evt => StylingUtility.AlignInspectorLabelWidth(element)); } } root.AddToClassList("unity-inspector-element"); root.style.paddingLeft = 10; base.OnActivate(searchContext, rootElement); }
public override IEnumerable <IPluginHandler> GetCompilationPluginHandlers(CompilationOptions getCompilationOptions) { foreach (var compilationPluginHandler in base.GetCompilationPluginHandlers(getCompilationOptions)) { yield return(compilationPluginHandler); } yield return(new DotsBoundObjectPlugin()); if (Unsupported.IsDeveloperMode()) { yield return(new GenerateNodeDocPlugin()); } }
public override void OnBeginSetting() { base.OnBeginSetting(); GameObject main = GameObject.Find("HTFramework"); if (main) { _main = main.GetComponent <Main>(); } _isDeveloperMode = Unsupported.IsDeveloperMode(); }
public override void OnBeginSetting() { base.OnBeginSetting(); GameObject main = GameObject.Find("HTFramework"); if (main) { _main = main.GetComponent <Main>(); } _isDeveloperMode = Unsupported.IsDeveloperMode(); _isEnableLnkTools = EditorPrefs.GetBool(EditorPrefsTable.LnkTools_Enable, true); }
public override void OnGUI(string searchContext) { EditorGUIUtility.labelWidth = 300; ProfilerUserSettings.frameCount = EditorGUILayout.IntSlider(Content.k_FrameCountText, ProfilerUserSettings.frameCount, ProfilerUserSettings.kMinFrameCount, ProfilerUserSettings.kMaxFrameCount); if (ProfilerUserSettings.frameCount > 600) { EditorGUILayout.HelpBox(Content.k_FrameCountWarningText); } if (Unsupported.IsDeveloperMode() || Unsupported.IsSourceBuild()) { ProfilerUserSettings.useOutOfProcessProfiler = EditorGUILayout.Toggle(Content.k_EnableOutOfProcessProfiler, ProfilerUserSettings.useOutOfProcessProfiler); } }
public void OnAdvancedMenuCreate(DropdownMenu menu) { if (!Unsupported.IsDeveloperMode()) { return; } menu.AppendSeparator(); menu.AppendAction("Internal/Always show development tools", a => { OnDevelopmentToolToggle(); }, a => !Unsupported.IsDeveloperMode() ? DropdownMenuAction.Status.Hidden : AlwaysShowDevTools?DropdownMenuAction.Status.Checked: DropdownMenuAction.Status.Normal); }
public void OnWindowCreated(WindowCreatedArgs args) { m_DevelopMenu = args.window.AddPackageActionMenu(); m_DevelopMenu.text = L10n.Tr("Develop"); m_DevelopMenu.visible = false; m_EmbedDropdown = m_DevelopMenu.AddDropdownItem(); m_EmbedDropdown.text = L10n.Tr("Copy to Packages folder"); m_EmbedDropdown.action = EmbedClicked; m_CloneDropdown = m_DevelopMenu.AddDropdownItem(); m_CloneDropdown.text = L10n.Tr("Clone from git repo"); m_CloneDropdown.action = CloneClicked; m_CloneDropdown.visible = Unsupported.IsDeveloperMode(); }
public static void AddCustomMenu(ITelemetry instance, GenericMenu menu) { if (!Unsupported.IsDeveloperMode()) { return; } menu.AddItem(new GUIContent($"Open {GetName(instance)}"), false, () => { var wnd = CreateWindow <TelemetryWindow>(); wnd.Initialize(instance); wnd.Show(); }); }
public AutomatedWindow(T windowToDrive) { m_EditorWindow = windowToDrive; //TODO: find a way to properly pass this data from the runner here. isAutomationVisible = EditorPrefs.GetBool("UnityEditor.PlaymodeTestsRunnerWindow" + ".visualizeUIAutomationEvents", false); //TODO: at the moment you can only debug one GUIView at a time, and nothing prevents from someone else to change who's being debugged. //figure out a way to handle this. GUIViewDebuggerHelper.DebugWindow(m_EditorWindow.m_Parent); GUIViewDebuggerHelper.onViewInstructionsChanged += m_Model.ViewContentsChanged; m_EditorWindow.RepaintImmediately(); //will create all the instructions, and will trigger onViewInstructionsChanged m_Disposed = false; m_DeveloperBuild = Unsupported.IsDeveloperMode(); }
static Texture2D LoadIcon(string resourcePath, bool autoScale = false) { if (string.IsNullOrEmpty(resourcePath)) { return(null); } if (EditorGUIUtility.isProSkin) { var dirName = Path.GetDirectoryName(resourcePath).Replace('\\', '/'); var fileName = Path.GetFileName(resourcePath); var darkSkinVariation = string.Format("{0}/d_{1}", dirName, fileName); if (File.Exists(darkSkinVariation)) { resourcePath = darkSkinVariation; } } float systemScale = EditorGUIUtility.pixelsPerPoint; if (autoScale && systemScale > 1f) { int scale = Mathf.RoundToInt(systemScale); string dirName = Path.GetDirectoryName(resourcePath).Replace('\\', '/'); string fileName = Path.GetFileNameWithoutExtension(resourcePath); string fileExt = Path.GetExtension(resourcePath); for (int s = scale; scale > 1; --scale) { string scaledResourcePath = string.Format("{0}/{1}@{2}x{3}", dirName, fileName, s, fileExt); var scaledResource = AssetDatabase.LoadAssetAtPath <Texture2D>(scaledResourcePath);// EditorResources.Load<Texture2D>(scaledResourcePath, Unsupported.IsDeveloperMode()); if (scaledResource != null) { return(scaledResource); } else if (Unsupported.IsDeveloperMode()) { Debug.LogWarningFormat("Couldn't load scaled Icon asset at path: {0}", scaledResourcePath); } } } var resource = AssetDatabase.LoadAssetAtPath <Texture2D>(resourcePath);//EditorResources.Load<Texture2D>(resourcePath, Unsupported.IsDeveloperMode()); if (Unsupported.IsDeveloperMode()) if (Unsupported.IsDeveloperMode() && resource == null) { Debug.LogErrorFormat("Couldn't load Icon asset at path: {0}", resourcePath); } return(resource); }
private static void CreateDynamicMenuItems() { if (Unsupported.IsDeveloperMode()) { Menu.AddMenuItem( "Jobs/Burst/Clear JIT Cache", "", false, 1001, // Add at bottom of Burst menu, below standard items which have default priority of 1000 () => { BurstEditorUtility.RequestClearJitCache(); EditorUtility.RequestScriptReload(); }, () => !EditorApplication.isPlayingOrWillChangePlaymode); } }
bool AudioDeepProfileToggle() { int toggleFlags = (int)ProfilerCaptureFlags.Channels; if (Unsupported.IsDeveloperMode()) { toggleFlags |= (int)ProfilerCaptureFlags.Clips | (int)ProfilerCaptureFlags.DSPNodes; } ProfilerAudioPopupItems oldShowDetailedAudioPane = (AudioSettings.profilerCaptureFlags & toggleFlags) != 0 ? ProfilerAudioPopupItems.Detailed : ProfilerAudioPopupItems.Simple; ProfilerAudioPopupItems newShowDetailedAudioPane = (ProfilerAudioPopupItems)EditorGUILayout.EnumPopup(oldShowDetailedAudioPane, EditorStyles.toolbarDropDownLeft, GUILayout.Width(70f)); if (oldShowDetailedAudioPane != newShowDetailedAudioPane) { ProfilerDriver.SetAudioCaptureFlags((AudioSettings.profilerCaptureFlags & ~toggleFlags) | (newShowDetailedAudioPane == ProfilerAudioPopupItems.Detailed ? toggleFlags : 0)); } return((AudioSettings.profilerCaptureFlags & toggleFlags) != 0); }
protected virtual void BuildOptionMenu(GenericMenu menu) { var prefs = m_CommandDispatcher.State.Preferences; if (prefs != null) { if (Unsupported.IsDeveloperMode()) { menu.AddItem(new GUIContent("Show Searcher in Regular Window"), prefs.GetBool(BoolPref.SearcherInRegularWindow), () => { prefs.ToggleBool(BoolPref.SearcherInRegularWindow); }); menu.AddSeparator(""); menu.AddItem(new GUIContent("Reload Graph"), false, () => { if (m_CommandDispatcher.State?.WindowState.GraphModel != null) { var openedGraph = m_CommandDispatcher.State.WindowState.CurrentGraph; Selection.activeObject = null; Resources.UnloadAsset((Object)m_CommandDispatcher.State.WindowState.AssetModel); m_CommandDispatcher.Dispatch( new LoadGraphAssetCommand(openedGraph.GetGraphAssetModelPath(), openedGraph.AssetLocalId, m_GraphView.Window.PluginRepository)); } }); menu.AddItem(new GUIContent("Rebuild GraphView"), false, () => { using (var updater = m_CommandDispatcher.State.GraphViewState.UpdateScope) { updater.ForceCompleteUpdate(); } }); menu.AddItem(new GUIContent("Rebuild Blackboard"), false, () => { m_GraphView.GetBlackboard()?.BuildUI(); m_GraphView.GetBlackboard()?.UpdateFromModel(); }); } } }
public static int GetServiceEnv(string serviceName) { if (Unsupported.IsDeveloperMode() || UnityConnect.preferencesEnabled) { return(EditorPrefs.GetInt(ServicePrefKey(kSvcEnvPref, serviceName))); } for (var i = 0; i < kEnvironmentFamilies.Length; i++) { var environmentName = kEnvironmentFamilies[i]; //By using the configuration it should default to production if there is no //-cloudEnvironment or to the switch value in case it is specified if (environmentName.Equals(UnityConnect.instance.configuration, StringComparison.InvariantCultureIgnoreCase)) { return(i); } } return(0); //Return production if there is an error }
static void DisplayPorts(Stencil stencil, IEnumerable <IPortModel> ports) { EditorGUI.indentLevel++; foreach (var port in ports) { string details = port.PortType + " ( " + port.DataType.GetMetadata(stencil).FriendlyName + " )"; EditorGUILayout.LabelField(port.UniqueId, details); if (Unsupported.IsDeveloperMode()) { EditorGUI.indentLevel++; foreach (IEdgeModel edgeModel in port.GraphModel.GetEdgesConnections(port)) { int edgeIndex = edgeModel.GraphModel.EdgeModels.IndexOf(edgeModel); EditorGUILayout.LabelField(edgeIndex.ToString(), edgeModel.OutputPortModel.ToString()); EditorGUILayout.LabelField("to", edgeModel.InputPortModel.ToString()); } EditorGUI.indentLevel--; } } EditorGUI.indentLevel--; }
public override void OnActivate(string searchContext, VisualElement rootElement) { var builderTemplate = BuilderPackageUtilities.LoadAssetAtPath <VisualTreeAsset>(BuilderConstants.SettingsUIPath + "/BuilderSettingsView.uxml"); builderTemplate.CloneTree(rootElement); var styleSheet = BuilderPackageUtilities.LoadAssetAtPath <StyleSheet>(BuilderConstants.SettingsUIPath + "/BuilderSettingsView.uss"); rootElement.styleSheets.Add(styleSheet); var editorExtensionsModeToggle = rootElement.Q <Toggle>(k_EditorExtensionsModeToggleName); editorExtensionsModeToggle.SetValueWithoutNotify(BuilderProjectSettings.enableEditorExtensionModeByDefault); editorExtensionsModeToggle.RegisterValueChangedCallback(e => { BuilderProjectSettings.enableEditorExtensionModeByDefault = e.newValue; }); var zoomToggle = rootElement.Q <Toggle>(k_DisableMouseWheelZoomingToggleName); zoomToggle.SetValueWithoutNotify(BuilderProjectSettings.disableMouseWheelZooming); zoomToggle.RegisterValueChangedCallback(e => { BuilderProjectSettings.disableMouseWheelZooming = e.newValue; }); var absolutePlacementToggle = rootElement.Q <Toggle>(k_EnableAbsolutePositionPlacementToggleName); absolutePlacementToggle.SetValueWithoutNotify(BuilderProjectSettings.enableAbsolutePositionPlacement); absolutePlacementToggle.RegisterValueChangedCallback(e => { BuilderProjectSettings.enableAbsolutePositionPlacement = e.newValue; }); if (!Unsupported.IsDeveloperMode()) { absolutePlacementToggle.style.display = DisplayStyle.None; } base.OnActivate(searchContext, rootElement); }
public override void BuildContextualMenu(ContextualMenuPopulateEvent evt) { if (evt.target is Node) { var canViewShader = node.hasPreview || node is IMasterNode; evt.menu.AppendAction("Copy Shader", CopyToClipboard, _ => canViewShader ? DropdownMenuAction.Status.Normal : DropdownMenuAction.Status.Hidden, GenerationMode.ForReals); evt.menu.AppendAction("Show Generated Code", ShowGeneratedCode, _ => canViewShader ? DropdownMenuAction.Status.Normal : DropdownMenuAction.Status.Hidden, GenerationMode.ForReals); if (Unsupported.IsDeveloperMode()) { evt.menu.AppendAction("Show Preview Code", ShowGeneratedCode, _ => canViewShader ? DropdownMenuAction.Status.Normal : DropdownMenuAction.Status.Hidden, GenerationMode.Preview); } } base.BuildContextualMenu(evt); }
private DocumentationPackageManagerUI(VisualTreeAsset asset) { #if UNITY_2019_1_OR_NEWER root = asset.CloneTree(); var resourcesRoot = "packages/com.unity.package-manager-doctools/Editor/Resources/"; string path = EditorGUIUtility.isProSkin ? resourcesRoot + "Styles/Dark.uss" : resourcesRoot + "Styles/Light.uss"; var styleSheet = EditorGUIUtility.Load(path) as StyleSheet; root.styleSheets.Add(styleSheet); #else root = asset.CloneTree(null); root.AddStyleSheetPath(EditorGUIUtility.isProSkin ? "Styles/Dark" : "Styles/Light"); #endif Add(root); if (!Unsupported.IsDeveloperMode()) { Verbose.visible = false; } GenerateButton.clickable.clicked += GenerateDocClick; Verbose.RegisterValueChangedCallback(evt => VerbosityToggle()); VerbosityToggle(); }
public static int GetServiceEnv(string serviceName) { int result; if (Unsupported.IsDeveloperMode() || UnityConnect.preferencesEnabled) { result = EditorPrefs.GetInt(UnityConnectPrefs.ServicePrefKey("CloudPanelServer", serviceName)); } else { for (int i = 0; i < UnityConnectPrefs.kEnvironmentFamilies.Length; i++) { string text = UnityConnectPrefs.kEnvironmentFamilies[i]; if (text.Equals(UnityConnect.instance.configuration, StringComparison.InvariantCultureIgnoreCase)) { result = i; return(result); } } result = 0; } return(result); }
public Object GetActualExportObject(Object obj) { if (!obj) { return(null); } var path = AssetDatabase.GetAssetPath(obj); if (path.StartsWith("Packages/", StringComparison.Ordinal)) { path = path.Substring("Packages/".Length); var indexOfSlash = path.IndexOf("/", StringComparison.Ordinal); var packageName = path.Substring(0, indexOfSlash); path = "Packages/" + packageName; if (!Unsupported.IsDeveloperMode()) { // sanitize: do not allow uploading packages that are in the Library var libraryRoot = Path.GetFullPath(Application.dataPath + "/../Library"); if (Path.GetFullPath(path).StartsWith(libraryRoot, StringComparison.Ordinal)) { return(null); } // sanitize: do not allow re-uploading of Unity-scoped packages if (packageName.StartsWith("com.unity.", StringComparison.OrdinalIgnoreCase)) { return(null); } } return(AssetDatabase.LoadAssetAtPath <DefaultAsset>(path)); } return(obj); }
static BuildAnalyticsTypes.ContextInfo CreateContextInfo(BuildResult result) { var ci = new BuildAnalyticsTypes.ContextInfo(); #if UNITY_INTERNAL ci.internal_build = true; #else ci.internal_build = Unsupported.IsDeveloperMode(); #endif if (result == null) { return(ci); } if (!result.BuildConfiguration.TryGetComponent <DotsRuntimeBuildProfile>(out var profile)) { return(ci); } ci.configuration = profile.Configuration.ToString(); ci.platform = profile.Target.UnityPlatformName; return(ci); }
internal void DoGUI() { if (m_State.Behavior == MemoryViewerBehavior.Hidden) { return; } var splitterRectVertical = GUILayoutUtility.GetRect(GUIContent.none, GUIStyle.none, GUILayout.ExpandWidth(true), GUILayout.Height(5)); var splitterRectHorizontal = new Rect(m_State.MemoryWindowWidth, splitterRectVertical.y, 5, m_State.MemoryWindowHeight); DoSplitter(splitterRectVertical, splitterRectHorizontal); GUILayout.BeginHorizontal(); GUILayout.BeginVertical(GUILayout.Width(m_State.MemoryWindowWidth), GUILayout.Height(m_State.MemoryWindowHeight)); GUILayout.Space(10); GUILayout.BeginHorizontal(); GUILayout.Label("Group:"); EditorGUI.BeginChangeCheck(); m_State.MemoryGroup = (MemoryGroup)EditorGUILayout.EnumPopup(m_State.MemoryGroup); if (EditorGUI.EndChangeCheck()) { UpdateGeneralStats(); } GUILayout.EndHorizontal(); foreach (var m in GetOrderMemoryTypes()) { DoMemoryToggle(m); } DoMemoryToggle(MemoryType.Total); if (m_State.Behavior == MemoryViewerBehavior.Manual) { GUILayout.Space(10); if (GUILayout.Button("Capture", EditorStyles.miniButton)) { QueueMemoryRequest(m_ExpectedDevice, m_ExpectedPackageFromRequest); } } if (Unsupported.IsDeveloperMode()) { DoDebuggingGUI(); } GUILayout.EndVertical(); var rc = GUILayoutUtility.GetLastRect(); GUILayout.BeginVertical(); // Note: GUILayoutUtility.GetRect must be called for Layout event always var size = GUILayoutUtility.GetRect(GUIContent.none, AndroidLogcatStyles.internalLogStyle, GUILayout.Height(m_State.MemoryWindowHeight)); size.height -= 4; if (m_EntryCount > 0) { DoEntriesGUI(size); } DoGuidelinesGUI(size, m_UpperMemoryBoundry); if (m_EntryCount > 0) { DoSelectedStatsGUI(size); } GUI.Box(new Rect(rc.x + 4, size.y, rc.width - 4, size.height + 1), GUIContent.none, EditorStyles.helpBox); GUI.Box(new Rect(size.x, size.y, size.width + 1, size.height + 1), GUIContent.none, EditorStyles.helpBox); if (m_ExpectedPackageFromRequest == null) { EditorGUI.HelpBox(size, "Select a package", MessageType.Info); } GUILayout.EndVertical(); GUILayout.EndHorizontal(); }
public override void DrawView(Rect position) { EditorGUILayout.BeginHorizontal(EditorStyles.toolbar); ProfilerAudioView newShowDetailedAudioPane = m_ShowDetailedAudioPane; if (AudioDeepProfileToggle()) { if (GUILayout.Toggle(newShowDetailedAudioPane == ProfilerAudioView.Channels, "Channels", EditorStyles.toolbarButton)) { newShowDetailedAudioPane = ProfilerAudioView.Channels; } if (GUILayout.Toggle(newShowDetailedAudioPane == ProfilerAudioView.Groups, "Groups", EditorStyles.toolbarButton)) { newShowDetailedAudioPane = ProfilerAudioView.Groups; } if (GUILayout.Toggle(newShowDetailedAudioPane == ProfilerAudioView.ChannelsAndGroups, "Channels and groups", EditorStyles.toolbarButton)) { newShowDetailedAudioPane = ProfilerAudioView.ChannelsAndGroups; } if (Unsupported.IsDeveloperMode() && GUILayout.Toggle(newShowDetailedAudioPane == ProfilerAudioView.DSPGraph, "DSP Graph", EditorStyles.toolbarButton)) { newShowDetailedAudioPane = ProfilerAudioView.DSPGraph; } if (Unsupported.IsDeveloperMode() && GUILayout.Toggle(newShowDetailedAudioPane == ProfilerAudioView.Clips, "Clips", EditorStyles.toolbarButton)) { newShowDetailedAudioPane = ProfilerAudioView.Clips; } if (newShowDetailedAudioPane != m_ShowDetailedAudioPane) { m_ShowDetailedAudioPane = newShowDetailedAudioPane; m_LastAudioProfilerFrame = -1; // force update } if (m_ShowDetailedAudioPane == ProfilerAudioView.DSPGraph) { m_ShowInactiveDSPChains = GUILayout.Toggle(m_ShowInactiveDSPChains, "Show inactive", EditorStyles.toolbarButton); if (m_ShowInactiveDSPChains) { m_HighlightAudibleDSPChains = GUILayout.Toggle(m_HighlightAudibleDSPChains, "Highlight audible", EditorStyles.toolbarButton); } GUILayout.FlexibleSpace(); EditorGUILayout.EndHorizontal(); var graphRect = DrawAudioStatsPane(ref m_PaneScroll_AudioDSPLeft); m_PaneScroll_AudioDSPRight = GUI.BeginScrollView(graphRect, m_PaneScroll_AudioDSPRight, new Rect(0, 0, 10000, 20000)); var clippingRect = new Rect(m_PaneScroll_AudioDSPRight.x, m_PaneScroll_AudioDSPRight.y, graphRect.width, graphRect.height); if (m_AudioProfilerDSPView == null) { m_AudioProfilerDSPView = new AudioProfilerDSPView(); } ProfilerProperty property = m_ProfilerWindow.CreateProperty(); if (CheckFrameData(property)) { m_AudioProfilerDSPView.OnGUI(clippingRect, property, m_ShowInactiveDSPChains, m_HighlightAudibleDSPChains, ref m_DSPGraphZoomFactor, ref m_PaneScroll_AudioDSPRight); } if (property != null) { property.Dispose(); } GUI.EndScrollView(); m_ProfilerWindow.Repaint(); } else if (m_ShowDetailedAudioPane == ProfilerAudioView.Clips) { GUILayout.FlexibleSpace(); EditorGUILayout.EndHorizontal(); var treeRect = DrawAudioStatsPane(ref m_PaneScroll_AudioClips); // TREE if (m_AudioProfilerClipTreeViewState == null) { m_AudioProfilerClipTreeViewState = new AudioProfilerClipTreeViewState(); } if (m_AudioProfilerClipViewBackend == null) { m_AudioProfilerClipViewBackend = new AudioProfilerClipViewBackend(m_AudioProfilerClipTreeViewState); } ProfilerProperty property = m_ProfilerWindow.CreateProperty(); if (CheckFrameData(property)) { var currentFrame = m_ProfilerWindow.GetActiveVisibleFrameIndex(); if (currentFrame == -1 || m_LastAudioProfilerFrame != currentFrame) { m_LastAudioProfilerFrame = currentFrame; var sourceItems = property.GetAudioProfilerClipInfo(); if (sourceItems != null && sourceItems.Length > 0) { var items = new List <AudioProfilerClipInfoWrapper>(); foreach (var s in sourceItems) { items.Add(new AudioProfilerClipInfoWrapper(s, property.GetAudioProfilerNameByOffset(s.assetNameOffset))); } m_AudioProfilerClipViewBackend.SetData(items); if (m_AudioProfilerClipView == null) { m_AudioProfilerClipView = new AudioProfilerClipView(m_ProfilerWindow as EditorWindow, m_AudioProfilerClipTreeViewState); m_AudioProfilerClipView.Init(treeRect, m_AudioProfilerClipViewBackend); } } } if (m_AudioProfilerClipView != null) { m_AudioProfilerClipView.OnGUI(treeRect); } } if (property != null) { property.Dispose(); } } else { bool resetAllAudioClipPlayCountsOnPlay = GUILayout.Toggle(AudioUtil.resetAllAudioClipPlayCountsOnPlay, "Reset play count on play", EditorStyles.toolbarButton); if (resetAllAudioClipPlayCountsOnPlay != AudioUtil.resetAllAudioClipPlayCountsOnPlay) { AudioUtil.resetAllAudioClipPlayCountsOnPlay = resetAllAudioClipPlayCountsOnPlay; } if (Unsupported.IsDeveloperMode()) { GUILayout.Space(5); bool showAllGroups = EditorPrefs.GetBool("AudioProfilerShowAllGroups"); bool newShowAllGroups = GUILayout.Toggle(showAllGroups, "Show all groups (dev mode only)", EditorStyles.toolbarButton); if (showAllGroups != newShowAllGroups) { EditorPrefs.SetBool("AudioProfilerShowAllGroups", newShowAllGroups); } } GUILayout.FlexibleSpace(); EditorGUILayout.EndHorizontal(); var treeRect = DrawAudioStatsPane(ref m_PaneScroll_AudioChannels); // TREE if (m_AudioProfilerGroupTreeViewState == null) { m_AudioProfilerGroupTreeViewState = new AudioProfilerGroupTreeViewState(); } if (m_AudioProfilerGroupViewBackend == null) { m_AudioProfilerGroupViewBackend = new AudioProfilerGroupViewBackend(m_AudioProfilerGroupTreeViewState); } ProfilerProperty property = m_ProfilerWindow.CreateProperty(); if (CheckFrameData(property)) { var currentFrame = m_ProfilerWindow.GetActiveVisibleFrameIndex(); if (currentFrame == -1 || m_LastAudioProfilerFrame != currentFrame) { m_LastAudioProfilerFrame = currentFrame; var sourceItems = property.GetAudioProfilerGroupInfo(); if (sourceItems != null && sourceItems.Length > 0) { var items = new List <AudioProfilerGroupInfoWrapper>(); foreach (var s in sourceItems) { bool isGroup = (s.flags & AudioProfilerGroupInfoHelper.AUDIOPROFILER_FLAGS_GROUP) != 0; if (m_ShowDetailedAudioPane == ProfilerAudioView.Channels && isGroup) { continue; } if (m_ShowDetailedAudioPane == ProfilerAudioView.Groups && !isGroup) { continue; } items.Add(new AudioProfilerGroupInfoWrapper(s, property.GetAudioProfilerNameByOffset(s.assetNameOffset), property.GetAudioProfilerNameByOffset(s.objectNameOffset), m_ShowDetailedAudioPane == ProfilerAudioView.Channels)); } m_AudioProfilerGroupViewBackend.SetData(items); if (m_AudioProfilerGroupView == null) { m_AudioProfilerGroupView = new AudioProfilerGroupView(m_ProfilerWindow as EditorWindow, m_AudioProfilerGroupTreeViewState); m_AudioProfilerGroupView.Init(treeRect, m_AudioProfilerGroupViewBackend); } } } if (m_AudioProfilerGroupView != null) { m_AudioProfilerGroupView.OnGUI(treeRect, m_ShowDetailedAudioPane == ProfilerAudioView.Channels); } } if (property != null) { property.Dispose(); } } } else { GUILayout.FlexibleSpace(); EditorGUILayout.EndHorizontal(); DrawOverviewText(ProfilerArea.Audio, position); } }
void DrawOptions() { if (currentMode.headerState.options == TimelineModeGUIState.Hidden || state.editSequence.asset == null) { return; } using (new EditorGUI.DisabledScope(currentMode.headerState.options == TimelineModeGUIState.Disabled)) { var rect = new Rect(position.width - WindowConstants.cogButtonWidth, 0, WindowConstants.cogButtonWidth, WindowConstants.timeAreaYPosition); if (EditorGUI.DropdownButton(rect, DirectorStyles.optionsCogIcon, FocusType.Keyboard, EditorStyles.toolbarButton)) { GenericMenu menu = new GenericMenu(); menu.AddItem(EditorGUIUtility.TrTextContent("Preferences Page..."), false, () => SettingsWindow.Show(SettingsScope.User, "Preferences/Timeline")); menu.AddSeparator(""); menu.AddItem(EditorGUIUtility.TrTextContent("Seconds"), !state.timeInFrames, ChangeTimeCode, "seconds"); menu.AddItem(EditorGUIUtility.TrTextContent("Frames"), state.timeInFrames, ChangeTimeCode, "frames"); menu.AddSeparator(""); TimeAreaContextMenu.AddTimeAreaMenuItems(menu, state); menu.AddSeparator(""); bool standardFrameRate = false; for (int i = 0; i < TimelineProjectSettings.framerateValues.Length; i++) { standardFrameRate |= AddStandardFrameRateMenu(menu, "Frame Rate/" + TimelineProjectSettings.framerateLabels[i], TimelineProjectSettings.framerateValues[i]); } if (standardFrameRate) { menu.AddDisabledItem(EditorGUIUtility.TrTextContent("Frame Rate/Custom")); } else { menu.AddItem(EditorGUIUtility.TrTextContent("Frame Rate/Custom (" + state.editSequence.frameRate + ")"), true, () => {}); } menu.AddSeparator(""); if (state.playRangeEnabled) { menu.AddItem(EditorGUIUtility.TrTextContent("Play Range Mode/Loop"), state.playRangeLoopMode, () => state.playRangeLoopMode = true); menu.AddItem(EditorGUIUtility.TrTextContent("Play Range Mode/Once"), !state.playRangeLoopMode, () => state.playRangeLoopMode = false); } else { menu.AddDisabledItem(EditorGUIUtility.TrTextContent("Play Range Mode")); } if (Unsupported.IsDeveloperMode()) { menu.AddSeparator(""); menu.AddItem(EditorGUIUtility.TrTextContent("Show Snapping Debug"), SnapEngine.displayDebugLayout, () => SnapEngine.displayDebugLayout = !SnapEngine.displayDebugLayout); menu.AddItem(EditorGUIUtility.TrTextContent("Debug TimeArea"), false, () => Debug.LogFormat("translation: {0} scale: {1} rect: {2} shownRange: {3}", m_TimeArea.translation, m_TimeArea.scale, m_TimeArea.rect, m_TimeArea.shownArea)); menu.AddItem(EditorGUIUtility.TrTextContent("Edit Skin"), false, () => Selection.activeObject = DirectorStyles.Instance.customSkin); menu.AddItem(EditorGUIUtility.TrTextContent("Show QuadTree Debugger"), state.showQuadTree, () => state.showQuadTree = !state.showQuadTree); } menu.DropDown(rect); } } }
void ImportFactoriesFromSource(LibraryTreeItem sourceCategory) { List <IUxmlFactory> deferredFactories = new List <IUxmlFactory>(); FactoryProcessingHelper processingData = new FactoryProcessingHelper(); foreach (var factories in VisualElementFactoryRegistry.factories) { if (factories.Value.Count == 0) { continue; } var factory = factories.Value[0]; if (!ProcessFactory(factory, processingData)) { // Could not process the factory now, because it depends on a yet unprocessed factory. // Defer its processing. deferredFactories.Add(factory); } } List <IUxmlFactory> deferredFactoriesCopy; do { deferredFactoriesCopy = new List <IUxmlFactory>(deferredFactories); foreach (var factory in deferredFactoriesCopy) { deferredFactories.Remove(factory); if (!ProcessFactory(factory, processingData)) { // Could not process the factory now, because it depends on a yet unprocessed factory. // Defer its processing again. deferredFactories.Add(factory); } } }while (deferredFactoriesCopy.Count > deferredFactories.Count); if (deferredFactories.Count > 0) { Debug.Log("Some factories could not be processed because their base type is missing."); } var categoryStack = new List <LibraryTreeItem>(); foreach (var known in processingData.knownTypes.Values) { var split = known.uxmlNamespace.Split('.'); // Avoid adding our own internal factories (like Package Manager templates). if (!Unsupported.IsDeveloperMode() && split.Count() > 0 && s_NameSpacesToAvoid.Contains(split[0])) { continue; } // Avoid adding UI Builder's own types, even in internal mode. if (split.Count() >= 3 && split[0] == "Unity" && split[1] == "UI" && split[2] == "Builder") { continue; } AddCategoriesToStack(sourceCategory, categoryStack, split); var asset = new VisualElementAsset(known.uxmlQualifiedName); var slots = new Dictionary <string, VisualElement>(); var overrides = new List <TemplateAsset.AttributeOverride>(); var vta = ScriptableObject.CreateInstance <VisualTreeAsset>(); var context = new CreationContext(slots, overrides, vta, null); var newItem = new LibraryTreeItem( known.uxmlName, () => known.Create(asset, context)); if (categoryStack.Count == 0) { sourceCategory.AddChild(newItem); } else { categoryStack.Last().AddChild(newItem); } } }
public void Analyze() { var doSourceCodeAnalysis = Unsupported.IsDeveloperMode(); var symbolArtifacts = GetSymbolArtifacts(); var moduleArtifacts = GetModuleArtifacts(); var assemblyArtifacts = GetIl2CPPAssemblyMapArtifacts("Temp/StagingArea/Data/il2cppOutput/Symbols/MethodMap.tsv"); int moduleAccounted = 0; var functionSizes = GetFunctionSizes(); foreach (var functionSize in functionSizes) { if (symbolArtifacts.ContainsKey(functionSize.Key)) { var objectFile = symbolArtifacts[functionSize.Key].Replace('\\', '/'); if (doSourceCodeAnalysis) { if (!objectSizes.ContainsKey(objectFile)) { objectSizes[objectFile] = 0; } objectSizes[objectFile] += functionSize.Value; } if (objectFile.LastIndexOf('/') != -1) { var objectFolder = objectFile.Substring(0, objectFile.LastIndexOf('/')); if (!folderSizes.ContainsKey(objectFolder)) { folderSizes[objectFolder] = 0; } folderSizes[objectFolder] += functionSize.Value; } } if (moduleArtifacts.ContainsKey(functionSize.Key)) { var objectFile = moduleArtifacts[functionSize.Key]; objectFile = objectFile.Substring(0, objectFile.Length - "Module_Dynamic.bc".Length); objectFile = StrippingInfo.ModuleName(objectFile); if (!moduleSizes.ContainsKey(objectFile)) { moduleSizes[objectFile] = 0; } moduleSizes[objectFile] += functionSize.Value; moduleAccounted += functionSize.Value; } if (assemblyArtifacts.ContainsKey(functionSize.Key)) { var assembly = assemblyArtifacts[functionSize.Key]; if (!assemblySizes.ContainsKey(assembly)) { assemblySizes[assembly] = 0; } assemblySizes[assembly] += functionSize.Value; } } AddPlatformSpecificCodeOutputModules(); int unaccounted = totalSize; foreach (var moduleSize in moduleSizes) { if (modules.Contains(moduleSize.Key)) { unaccounted -= moduleSize.Value; } } moduleSizes["Unaccounted"] = unaccounted; AddModule("Unaccounted", false); foreach (var moduleSize in moduleSizes) { AddModuleSize(moduleSize.Key, moduleSize.Value); } int totalAssemblySize = 0; foreach (var assemblySize in assemblySizes) { RegisterDependency("IL2CPP Generated", assemblySize.Key); sizes[assemblySize.Key] = assemblySize.Value; totalAssemblySize += assemblySize.Value; SetIcon(assemblySize.Key, "class/DefaultAsset"); } RegisterDependency("IL2CPP Generated", "IL2CPP Unaccounted"); sizes["IL2CPP Unaccounted"] = moduleSizes["IL2CPP Generated"] - totalAssemblySize; SetIcon("IL2CPP Unaccounted", "class/DefaultAsset"); if (doSourceCodeAnalysis) { System.Console.WriteLine("Code size per module: "); PrintSizesDictionary(moduleSizes); System.Console.WriteLine("\n\n"); System.Console.WriteLine("Code size per source folder: "); PrintSizesDictionary(folderSizes); System.Console.WriteLine("\n\n"); System.Console.WriteLine("Code size per object file: "); PrintSizesDictionary(objectSizes); System.Console.WriteLine("\n\n"); System.Console.WriteLine("Code size per function: "); PrintSizesDictionary(functionSizes); System.Console.WriteLine("\n\n"); } }