InstanceIDToObject() private méthode

private InstanceIDToObject ( int instanceID ) : Object
instanceID int
Résultat Object
Exemple #1
0
 private static void UpdateSchedulers()
 {
     Dictionary <int, Panel> .Enumerator panelsIterator = UIElementsUtility.GetPanelsIterator();
     while (panelsIterator.MoveNext())
     {
         KeyValuePair <int, Panel> current = panelsIterator.Current;
         Panel value = current.Value;
         if (value.contextType == ContextType.Editor)
         {
             IScheduler scheduler = value.scheduler;
             value.timerEventScheduler.UpdateScheduledEvents();
             DataWatchService dataWatchService = value.dataWatch as DataWatchService;
             dataWatchService.ProcessNotificationQueue();
             if (value.visualTree.IsDirty(ChangeType.Repaint))
             {
                 GUIView gUIView = EditorUtility.InstanceIDToObject(value.instanceID) as GUIView;
                 if (gUIView != null)
                 {
                     gUIView.Repaint();
                 }
             }
         }
     }
 }
Exemple #2
0
        public void SaveStateFromHierarchy(SceneHierarchyWindow hierarchy, StageNavigationItem stage)
        {
            var lastClickedGameObject = EditorUtility.InstanceIDToObject(hierarchy.sceneHierarchy.treeViewState.lastClickedID) as GameObject;

            if (stage.isMainStage)
            {
                m_LastClickedInstanceID = lastClickedGameObject != null?lastClickedGameObject.GetInstanceID() : 0;

                m_ExpandedSceneGameObjectInstanceIDs = hierarchy.sceneHierarchy.treeViewState.expandedIDs;
            }
            else
            {
                m_LastClickedFileID = lastClickedGameObject != null?GetOrGenerateFileID(lastClickedGameObject) : 0;

                m_ExpandedPrefabGameObjectFileIDs = GetExpandedGameObjectFileIDs(hierarchy);
            }

            m_ScrollY = hierarchy.sceneHierarchy.treeViewState.scrollPos.y;

            if (SceneHierarchy.s_DebugPersistingExpandedState)
            {
                DebugLog("Saving", stage);
            }
        }
        // Selection changes when calling BeginNewAsset if it succeeds
        public bool BeginNewAssetCreation(int instanceID, EndNameEditAction newAssetEndAction, string filePath, Texture2D icon, string newAssetResourceFile)
        {
            //Sanitize input
            string sanitizedFilePath = filePath != null?filePath.ConvertSeparatorsToUnity() : filePath;

            string sanitizedNewAssetResourceFile = newAssetResourceFile != null?newAssetResourceFile.ConvertSeparatorsToUnity() : newAssetResourceFile;

            string uniquePath;

            if (!sanitizedFilePath.StartsWith("assets/", System.StringComparison.CurrentCultureIgnoreCase) && !sanitizedFilePath.StartsWith("packages/", System.StringComparison.CurrentCultureIgnoreCase))
            {
                // If sanitizedFilePath is not already a full asset path, we need to get the full path
                uniquePath = AssetDatabase.GetUniquePathNameAtSelectedPath(sanitizedFilePath);
            }
            else
            {
                uniquePath = AssetDatabase.GenerateUniqueAssetPath(sanitizedFilePath);
            }

            if (!IsPathDataValid(uniquePath))
            {
                Debug.LogErrorFormat("Invalid generated unique path '{0}' (input path '{1}')", uniquePath, sanitizedFilePath);
                Clear();
                return(false);
            }

            m_InstanceID   = instanceID;
            m_Path         = uniquePath;
            m_Icon         = icon;
            m_EndAction    = newAssetEndAction;
            m_ResourceFile = sanitizedNewAssetResourceFile;

            // Change selection to none or instanceID
            Selection.activeObject = EditorUtility.InstanceIDToObject(instanceID);
            return(true);
        }
 public ComponentDropdownElement(string name, string menuPath, string command) : base(name)
 {
     this.m_MenuPath = menuPath;
     this.m_Command  = command;
     this.m_IsLegacy = menuPath.Contains("Legacy");
     if (command.StartsWith("SCRIPT"))
     {
         int instanceID                   = int.Parse(command.Substring(6));
         UnityEngine.Object obj           = EditorUtility.InstanceIDToObject(instanceID);
         Texture2D          miniThumbnail = AssetPreview.GetMiniThumbnail(obj);
         this.m_Content = new GUIContent(name, miniThumbnail);
     }
     else
     {
         int classID = int.Parse(command);
         this.m_Content = new GUIContent(name, AssetPreview.GetMiniTypeThumbnailFromClassID(classID));
     }
     this.m_ContentWhenSearching = new GUIContent(this.m_Content);
     if (this.m_IsLegacy)
     {
         GUIContent expr_A4 = this.m_ContentWhenSearching;
         expr_A4.text += " (Legacy)";
     }
 }
        public bool BeginNewAssetCreation(int instanceID, EndNameEditAction newAssetEndAction, string filePath, Texture2D icon, string newAssetResourceFile)
        {
            string text;

            if (!filePath.StartsWith("assets/", StringComparison.CurrentCultureIgnoreCase))
            {
                text = AssetDatabase.GetUniquePathNameAtSelectedPath(filePath);
            }
            else
            {
                text = AssetDatabase.GenerateUniqueAssetPath(filePath);
            }
            bool result;

            if (!CreateAssetUtility.IsPathDataValid(text))
            {
                Debug.LogErrorFormat("Invalid generated unique path '{0}' (input path '{1}')", new object[]
                {
                    text,
                    filePath
                });
                this.Clear();
                result = false;
            }
            else
            {
                this.m_InstanceID      = instanceID;
                this.m_Path            = text;
                this.m_Icon            = icon;
                this.m_EndAction       = newAssetEndAction;
                this.m_ResourceFile    = newAssetResourceFile;
                Selection.activeObject = EditorUtility.InstanceIDToObject(instanceID);
                result = true;
            }
            return(result);
        }
Exemple #6
0
 internal static IEnumerable <Object> DuplicateAssets(IEnumerable <int> instanceIDs)
 {
     return(DuplicateAssets(instanceIDs.Select(id => EditorUtility.InstanceIDToObject(id))));
 }
        private string GetItemcontent(RowGUIArgs args, int column)
        {
            if (m_AllCanvasesItem != null && args.item.id == m_AllCanvasesItem.id)
            {
                switch ((Column)column)
                {
                case Column.TotalBatchCount:
                    return(m_AllCanvasesItem.totalBatchCount.ToString());

                case Column.TotalVertexCount:
                    return(m_AllCanvasesItem.totalVertexCount.ToString());

                case Column.GameObjectCount:
                    return(m_AllCanvasesItem.gameObjectCount.ToString());

                default:
                    return(null);
                }
            }

            var batchItem = args.item as BatchTreeViewItem;

            if (batchItem != null)
            {
                var info = batchItem.info;
                switch ((Column)column)
                {
                case Column.VertexCount:
                    return(info.vertexCount.ToString());

                case Column.TotalVertexCount:
                    return(info.totalVertexCount.ToString());

                case Column.BatchBreakingReason:
                    if (info.batchBreakingReason != BatchBreakingReason.NoBreaking)
                    {
                        return(FormatBatchBreakingReason(info));
                    }
                    break;

                case Column.GameObjectCount:
                    return(info.instanceIDsCount.ToString());

                case Column.InstanceIds:
                    if (batchItem.instanceIDs.Length <= 5)
                    {
                        StringBuilder sb = new StringBuilder();
                        for (int i = 0; i < batchItem.instanceIDs.Length; i++)
                        {
                            if (i != 0)
                            {
                                sb.Append(", ");
                            }
                            int iid = batchItem.instanceIDs[i];
                            var o   = EditorUtility.InstanceIDToObject(iid);
                            if (o == null)
                            {
                                sb.Append(iid);
                            }
                            else
                            {
                                sb.Append(o.name);
                            }
                        }
                        return(sb.ToString());
                    }
                    return(string.Format("{0} objects", batchItem.instanceIDs.Length));

                case Column.Element:
                case Column.BatchCount:
                case Column.TotalBatchCount:
                    break;

                case Column.Rerender:
                    return(info.renderDataIndex.ToString());

                default:
                    return("Missing");
                }
                return(null);
            }

            var canvasItem = args.item as CanvasTreeViewItem;

            if (canvasItem != null)
            {
                UISystemProfilerInfo info = canvasItem.info;
                switch ((Column)column)
                {
                case Column.BatchCount:
                    return(info.batchCount.ToString());

                case Column.TotalBatchCount:
                    return(info.totalBatchCount.ToString());

                case Column.TotalVertexCount:
                    return(info.totalVertexCount.ToString());

                case Column.GameObjectCount:
                    return(info.instanceIDsCount.ToString());

                case Column.VertexCount:
                case Column.BatchBreakingReason:
                case Column.InstanceIds:
                case Column.Element:
                    break;

                case Column.Rerender:
                    return(info.renderDataIndex + " : " + info.renderDataCount);

                default:
                    return("Missing");
                }
                return(null);
            }
            return(null);
        }
 public static UnityObject GetCurrentObject()
 {
     return(EditorUtility.InstanceIDToObject(ObjectSelector.get.GetSelectedInstanceID()));
 }
Exemple #9
0
        private string GetItemcontent(TreeView.RowGUIArgs args, int column)
        {
            string result;

            if (this.m_AllCanvasesItem != null && args.item.id == this.m_AllCanvasesItem.id)
            {
                switch (column)
                {
                case 2:
                    result = this.m_AllCanvasesItem.totalBatchCount.ToString();
                    return(result);

                case 4:
                    result = this.m_AllCanvasesItem.totalVertexCount.ToString();
                    return(result);

                case 6:
                    result = this.m_AllCanvasesItem.gameObjectCount.ToString();
                    return(result);
                }
                result = null;
            }
            else
            {
                UISystemProfilerTreeView.BatchTreeViewItem batchTreeViewItem = args.item as UISystemProfilerTreeView.BatchTreeViewItem;
                if (batchTreeViewItem != null)
                {
                    UISystemProfilerInfo info = batchTreeViewItem.info;
                    switch (column)
                    {
                    case 0:
                    case 1:
                    case 2:
                        break;

                    case 3:
                        result = info.vertexCount.ToString();
                        return(result);

                    case 4:
                        result = info.totalVertexCount.ToString();
                        return(result);

                    case 5:
                        if (info.batchBreakingReason != BatchBreakingReason.NoBreaking)
                        {
                            result = UISystemProfilerTreeView.FormatBatchBreakingReason(info);
                            return(result);
                        }
                        break;

                    case 6:
                        result = info.instanceIDsCount.ToString();
                        return(result);

                    case 7:
                        if (batchTreeViewItem.instanceIDs.Length <= 5)
                        {
                            StringBuilder stringBuilder = new StringBuilder();
                            for (int i = 0; i < batchTreeViewItem.instanceIDs.Length; i++)
                            {
                                if (i != 0)
                                {
                                    stringBuilder.Append(", ");
                                }
                                int num = batchTreeViewItem.instanceIDs[i];
                                UnityEngine.Object @object = EditorUtility.InstanceIDToObject(num);
                                if (@object == null)
                                {
                                    stringBuilder.Append(num);
                                }
                                else
                                {
                                    stringBuilder.Append(@object.name);
                                }
                            }
                            result = stringBuilder.ToString();
                            return(result);
                        }
                        result = string.Format("{0} objects", batchTreeViewItem.instanceIDs.Length);
                        return(result);

                    case 8:
                        result = info.renderDataIndex.ToString();
                        return(result);

                    default:
                        result = "Missing";
                        return(result);
                    }
                    result = null;
                }
                else
                {
                    UISystemProfilerTreeView.CanvasTreeViewItem canvasTreeViewItem = args.item as UISystemProfilerTreeView.CanvasTreeViewItem;
                    if (canvasTreeViewItem != null)
                    {
                        UISystemProfilerInfo info2 = canvasTreeViewItem.info;
                        switch (column)
                        {
                        case 0:
                        case 3:
                        case 5:
                        case 7:
                            result = null;
                            break;

                        case 1:
                            result = info2.batchCount.ToString();
                            break;

                        case 2:
                            result = info2.totalBatchCount.ToString();
                            break;

                        case 4:
                            result = info2.totalVertexCount.ToString();
                            break;

                        case 6:
                            result = info2.instanceIDsCount.ToString();
                            break;

                        case 8:
                            result = info2.renderDataIndex + " : " + info2.renderDataCount;
                            break;

                        default:
                            result = "Missing";
                            break;
                        }
                    }
                    else
                    {
                        result = null;
                    }
                }
            }
            return(result);
        }
Exemple #10
0
 internal static IEnumerable <UnityEngine.Object> DuplicateAssets(IEnumerable <int> instanceIDs)
 {
     return(ProjectWindowUtil.DuplicateAssets(from id in instanceIDs
                                              select EditorUtility.InstanceIDToObject(id)));
 }
 public static UnityEngine.Object GetCurrentObject() =>
 EditorUtility.InstanceIDToObject(get.GetSelectedInstanceID());
        public override void OnGUI(Rect rect)
        {
            if (editorWindow.position.y != targetPositionY)
            {
                editorWindow.position = new Rect(editorWindow.position)
                {
                    y = targetPositionY
                }
            }
            ;

            // Escape closes the window
            if (Event.current.type == EventType.KeyDown && Event.current.keyCode == KeyCode.Escape)
            {
                editorWindow.Close();
                GUIUtility.ExitGUI();
            }

            if (!DrawHeader())
            {
                return;
            }

            float height = k_HeaderHeight;

            if (target.isVariant)
            {
                height += DrawVariantHierarchy();
            }

            height += DrawChildrenLabel(height);

            if (displayChildren)
            {
                DrawChildren(height);
            }

            if (materialEditor.convertState == ConvertAction.Flatten)
            {
                materialEditor.convertState = ConvertAction.None;
                Undo.RecordObject(target, "Flatten Material Variant");
                target.parent = null;
                Init();
            }
        }

        bool DrawHeader()
        {
            Rect headerRect = GUILayoutUtility.GetRect(20, windowWidth, k_HeaderHeight, k_HeaderHeight);

            EditorGUI.DrawRect(headerRect, Colors.headerBackground);

            var   headerLabel = target.isVariant ? Styles.variantLabel : Styles.instanceLabel;
            float labelSize   = Styles.boldRightAligned.CalcSize(headerLabel).x;

            Rect labelRect   = new Rect(k_OffsetX, headerRect.y + k_Padding, labelSize, EditorGUIUtility.singleLineHeight);
            Rect contentRect = new Rect(labelRect.x + labelRect.width + k_Padding, labelRect.y, windowWidth, labelRect.height);

            GUI.Label(labelRect, headerLabel, Styles.boldRightAligned);
            DoObjectLabel(contentRect, target, EditorStyles.boldLabel);

            labelRect.y = labelRect.height + 2 * k_Padding;
            if (materialEditor.convertState == ConvertAction.None)
            {
                int result;
                labelRect.width = k_ConvertLabelWidth;
                using (new EditorGUI.DisabledScope(!enabled))
                    result = EditorGUI.Popup(labelRect, target.isVariant ? 1 : 0, Styles.headerPopupOptions);
                if (result == 0 && target.isVariant)
                {
                    materialEditor.convertState = ConvertAction.Flatten;
                    targetPositionY             = singleLinePositionY;
                }
                if (result == 1 && !target.isVariant)
                {
                    materialEditor.convertState = ConvertAction.Convert;
                    targetPositionY             = singleLinePositionY + k_PositionShiftY;
                }
            }
            else if (materialEditor.convertState == ConvertAction.Convert)
            {
                GUI.enabled     = false;
                labelRect.width = 200f;
                EditorGUI.Button(labelRect, Styles.convertingLabel);
                GUI.enabled = true;

                // Conversion helper
                labelRect.y     = k_HeaderHeight;
                labelRect.width = windowWidth;
                EditorGUI.LabelField(labelRect, Styles.conversionHelpLabel);

                labelRect.x = windowWidth - 14;
                if (GUI.Button(labelRect, GUIContent.none, EditorStyles.toolbarSearchFieldCancelButton))
                {
                    materialEditor.convertState = ConvertAction.None;
                    targetPositionY             = singleLinePositionY;
                    materialEditor.Repaint();
                }

                labelRect.x = k_OffsetX;
                var oldLabelWidth = EditorGUIUtility.labelWidth;
                EditorGUIUtility.labelWidth = 70;
                EditorGUI.BeginChangeCheck();
                var parent = target.parent;
                materialEditor.ParentField(new Rect(k_OffsetX, labelRect.yMax + k_Padding, windowWidth - 2 * k_OffsetX, k_EntryHeight));
                if (EditorGUI.EndChangeCheck() && parent != target.parent)
                {
                    materialEditor.convertState = ConvertAction.None;
                    Init();
                }
                EditorGUIUtility.labelWidth = oldLabelWidth;
                return(false);
            }

            return(true);
        }

        float DrawVariantHierarchy()
        {
            // Draw table header
            Rect entryRect = new Rect(0, k_HeaderHeight, windowWidth, k_EntryHeight);

            EditorGUI.DrawRect(entryRect, Colors.rowBackground(0));

            var labelRect = entryRect;

            labelRect.x = k_TitleWidth;
            GUI.Label(labelRect, Styles.ancestorLabel, EditorStyles.miniLabel);

            labelRect.x = overridesX + k_Padding;
            GUI.Label(labelRect, Styles.overridesLabel, EditorStyles.miniLabel);

            labelRect.x = locksX + k_Padding;
            GUI.Label(labelRect, Styles.locksLabel, EditorStyles.miniLabel);

            float tableHeight = Mathf.Min(numRows, k_MaxTableRows) * k_EntryHeight + (namesWidth > maxNameWidth ? k_ScrollbarHeight : 0);
            float realHeight  = numRows * k_EntryHeight + (namesWidth > maxNameWidth ? k_ScrollbarHeight : 0);
            var   tableRect   = new Rect(0, k_HeaderHeight + k_EntryHeight, windowWidth - 1, tableHeight);

            scroll.y = GUI.BeginScrollView(tableRect, scroll, new Rect(tableRect)
            {
                width = tableRect.width - k_ScrollbarWidth, height = realHeight
            }).y;

            // Draw overrides and locks table
            int      i       = numRows;
            Material current = target;

            while (current != null)
            {
                entryRect.y = k_HeaderHeight + i * k_EntryHeight;
                EditorGUI.DrawRect(entryRect, Colors.rowBackground(i--));

                DisplayOverridesAndLocks(entryRect, current);
                current = current.parent;
            }

            var scrollRect = new Rect(k_TitleWidth, k_HeaderHeight + k_EntryHeight, Mathf.Min(namesWidth, maxNameWidth), numRows * k_EntryHeight);

            scroll.x = GUI.BeginScrollView(new Rect(scrollRect)
            {
                height = scrollRect.height + k_ScrollbarHeight
            }, scroll, new Rect(scrollRect)
            {
                width = namesWidth
            }).x;

            // Draw scrollable table
            i           = numRows;
            current     = target;
            entryRect.x = k_TitleWidth;
            while (i != 0)
            {
                entryRect.y = k_HeaderHeight + i-- *k_EntryHeight;

                if (current == null)
                {
                    GUI.Label(entryRect, EditorGUIUtility.TempContent("Missing (Material)"));
                    break;
                }
                DoObjectLabel(entryRect, current);
                current = current.parent;
            }

            GUI.EndScrollView();

            float height = tableHeight + k_EntryHeight;

            // Draw selected label
            labelRect.x     = k_OffsetX;
            labelRect.y     = k_HeaderHeight + numRows * k_EntryHeight;
            labelRect.width = k_TitleWidth - labelRect.x;
            GUI.Label(labelRect, Styles.selectedLabel);

            // Draw parent label
            labelRect.y = k_HeaderHeight + (numRows - 1) * k_EntryHeight;
            GUI.Label(labelRect, Styles.parentLabel);

            // Draw root label
            if (labelRect.y != k_HeaderHeight + k_EntryHeight)
            {
                labelRect.y = k_HeaderHeight + k_EntryHeight;
                GUI.Label(labelRect, Styles.rootLabel);
            }

            // Draw vertical splits
            Rect splitBar = new Rect(overridesX - k_SplitWidth, k_HeaderHeight, k_SplitWidth, (numRows + 1) * k_EntryHeight);

            EditorGUI.DrawRect(splitBar, Colors.headerBackground);
            splitBar.x = locksX - k_SplitWidth;
            EditorGUI.DrawRect(splitBar, Colors.headerBackground);

            GUI.EndScrollView();

            return(height);
        }

        float DrawChildrenLabel(float yMin)
        {
            var labelRect = new Rect(k_OffsetX, yMin, 100, k_EntryHeight);

            if (target.isVariant)
            {
                displayChildren = EditorGUI.Foldout(labelRect, displayChildren, Styles.childrenLabel, true);
            }
            else
            {
                EditorGUI.LabelField(labelRect, Styles.childrenLabel);
            }

            if (displayChildren)
            {
                if (listArea == null)
                {
                    InitListArea();
                }

                labelRect = new Rect(labelRect.x + 58 + (target.isVariant ? 12 : 0), labelRect.y + 2, k_SliderWidth, EditorGUI.kSingleLineHeight);
                if (results.Length != 0)
                {
                    EditorGUI.LabelField(labelRect, results.Length.ToString(), Styles.boldNumber);
                }

                EditorGUI.BeginChangeCheck();
                labelRect.x = windowWidth - k_OffsetX - k_SliderWidth;
                var newGridSize = (int)GUI.HorizontalSlider(labelRect, listArea.gridSize, listArea.minGridSize, listArea.maxGridSize);
                if (EditorGUI.EndChangeCheck())
                {
                    listArea.gridSize = newGridSize;
                }
            }

            return(k_EntryHeight);
        }

        void DrawChildren(float yMin)
        {
            var backgroundRect = new Rect(0, yMin, windowWidth, k_SearchHeight);

            GUI.Label(backgroundRect, GUIContent.none, Styles.searchBackground);

            EditorGUI.BeginChangeCheck();
            var searchRect = new Rect(k_OffsetX + k_Padding, backgroundRect.y + k_Padding, windowWidth - 2 * k_OffsetX - k_Padding, Styles.searchFieldStyle.fixedHeight);

            searchFilterString = EditorGUI.ToolbarSearchField(searchRect, searchFilterString, false);
            if (EditorGUI.EndChangeCheck())
            {
                debounce.Execute();
            }

            if (enumerator != null)
            {
                Search();
            }

            yMin = searchRect.height + (listArea.gridSize < k_MinIconSize ? 11f : 0f);
            var listRect = new Rect(k_Padding, searchRect.y + yMin, windowWidth - 2 * k_Padding, k_SearchHeight - yMin - k_Padding);

            int listKeyboardControlID = GUIUtility.GetControlID(FocusType.Keyboard);

            listArea.OnGUI(listRect, listKeyboardControlID);

            if (enumerator == null && results.Length == 0)
            {
                var labelRect = new Rect(noResultsX, backgroundRect.y + 69f, windowWidth, EditorGUI.kSingleLineHeight);
                EditorGUI.LabelField(backgroundRect, searchFilter.nameFilter.Length == 0 ? Styles.noChildrenLabel : Styles.noResultsLabel, Styles.centered);
            }
        }

        void InitListArea()
        {
            listArea = new ObjectListArea(s_ListAreaState, editorWindow, false)
            {
                allowDeselection      = true,
                allowMultiSelect      = false,
                allowRenaming         = false,
                allowBuiltinResources = true,
            };

            listArea.itemSelectedCallback += (bool doubleClicked) =>
            {
                if (listArea.GetSelection().Length == 0)
                {
                    return;
                }
                var selection = listArea.GetSelection()[0];
                GUIUtility.keyboardControl = GUIUtility.GetControlID(FocusType.Keyboard);
                if (doubleClicked)
                {
                    Selection.SetActiveObjectWithContext(EditorUtility.InstanceIDToObject(selection), null);
                    Event.current.Use();
                    editorWindow.Close();
                    GUIUtility.ExitGUI();
                }
                else
                {
                    EditorGUIUtility.PingObject(selection);
                    Event.current.Use();
                }
            };

            SearchFilterChanged();
        }