void UpdateStatusChecks(GameObject prefabInstanceRoot)
        {
            // Can't reset values inside this method, since it's called consecutively for each target.

            if (PrefabUtility.HasPrefabInstanceAnyOverrides(prefabInstanceRoot, false))
            {
                m_AnyOverrides = true;
            }
            if (PrefabUtility.IsDisconnectedFromPrefabAsset(prefabInstanceRoot))
            {
                m_Disconnected = true;
            }
            if (PrefabUtility.HasInvalidComponent(prefabInstanceRoot))
            {
                m_InvalidComponentOnInstance = true;
            }

            GameObject prefabAssetRoot = PrefabUtility.GetCorrespondingObjectFromSource(prefabInstanceRoot);

            if (PrefabUtility.IsPartOfModelPrefab(prefabAssetRoot))
            {
                m_ModelPrefab = true;
            }
            if (PrefabUtility.IsPartOfImmutablePrefab(prefabAssetRoot))
            {
                m_Immutable = true;
            }
            if (PrefabUtility.HasInvalidComponent(prefabAssetRoot))
            {
                m_InvalidComponentOnAsset = true;
            }
        }
Ejemplo n.º 2
0
        void UpdateStatusChecks(GameObject prefabInstanceRoot)
        {
            if (PrefabUtility.HasPrefabInstanceAnyOverrides(prefabInstanceRoot, false))
            {
                m_AnyOverrides = true;
            }
            if (PrefabUtility.IsDisconnectedFromPrefabAsset(prefabInstanceRoot))
            {
                m_Disconnected = true;
            }
            if (PrefabUtility.HasInvalidComponent(prefabInstanceRoot))
            {
                m_InvalidComponentOnInstance = true;
            }

            GameObject prefabAssetRoot = PrefabUtility.GetCorrespondingObjectFromSource(prefabInstanceRoot);

            if (PrefabUtility.IsPartOfModelPrefab(prefabAssetRoot))
            {
                m_ModelPrefab = true;
            }
            if (PrefabUtility.IsPartOfImmutablePrefab(prefabAssetRoot))
            {
                m_Immutable = true;
            }
            if (PrefabUtility.HasInvalidComponent(prefabAssetRoot))
            {
                m_InvalidComponentOnAsset = true;
            }
        }
        void UpdateStatusChecks(GameObject prefabInstanceRoot)
        {
            // Can't reset values inside this method, since it's called consecutively for each target.

            if (PrefabUtility.HasPrefabInstanceAnyOverrides(prefabInstanceRoot, false))
            {
                m_AnyOverrides = true;
            }
            if (PrefabUtility.HasInvalidComponent(prefabInstanceRoot))
            {
                m_InvalidComponentOnInstance = true;
            }

            GameObject prefabAssetRoot = PrefabUtility.GetCorrespondingObjectFromSource(prefabInstanceRoot);

            if (PrefabUtility.IsPartOfModelPrefab(prefabAssetRoot))
            {
                m_ModelPrefab = true;
            }
            if (PrefabUtility.IsPartOfImmutablePrefab(prefabAssetRoot))
            {
                m_Immutable = true;
            }
            if (PrefabUtility.HasInvalidComponent(prefabAssetRoot))
            {
                m_InvalidComponentOnAsset = true;
            }

            if (PrefabUtility.HasManagedReferencesWithMissingTypes(prefabAssetRoot))
            {
                m_HasManagedReferencesWithMissingTypesOnAsset = true;
            }

            m_HasApplicableOverrides = m_TreeView == null || m_TreeView.hasApplicableModifications;
        }
        void CalculatePrefabStatus()
        {
            m_PlayModeObjects               = false;
            m_IsAsset                       = false;
            m_ImmutableSelf                 = false;
            m_ImmutableSourceAsset          = false;
            m_IsDisconnected                = false;
            m_IsMissing                     = false;
            m_IsPrefabInstanceAnyRoot       = true;
            m_IsPrefabInstanceOutermostRoot = true;
            m_AllOfSamePrefabType           = true;
            PrefabAssetType      firstType   = PrefabUtility.GetPrefabAssetType(targets[0]);
            PrefabInstanceStatus firstStatus = PrefabUtility.GetPrefabInstanceStatus(targets[0]);

            foreach (var o in targets)
            {
                var                  go     = (GameObject)o;
                PrefabAssetType      type   = PrefabUtility.GetPrefabAssetType(go);
                PrefabInstanceStatus status = PrefabUtility.GetPrefabInstanceStatus(go);
                if (type != firstType || status != firstStatus)
                {
                    m_AllOfSamePrefabType = false;
                }

                if (Application.IsPlaying(go))
                {
                    m_PlayModeObjects = true;
                }
                if (!PrefabUtility.IsAnyPrefabInstanceRoot(go))
                {
                    m_IsPrefabInstanceAnyRoot = false; // Conservative is false if any is false
                }
                if (!m_IsPrefabInstanceAnyRoot || !PrefabUtility.IsOutermostPrefabInstanceRoot(go))
                {
                    m_IsPrefabInstanceOutermostRoot = false; // Conservative is false if any is false
                }
                if (PrefabUtility.IsPartOfPrefabAsset(go))
                {
                    m_IsAsset = true; // Conservative is true if any is true
                }
                if (m_IsAsset && PrefabUtility.IsPartOfImmutablePrefab(go))
                {
                    m_ImmutableSelf = true; // Conservative is true if any is true
                }
                GameObject originalSourceOrVariant = PrefabUtility.GetOriginalSourceOrVariantRoot(go);
                if (originalSourceOrVariant != null && PrefabUtility.IsPartOfImmutablePrefab(originalSourceOrVariant))
                {
                    m_ImmutableSourceAsset = true; // Conservative is true if any is true
                }
                if (PrefabUtility.IsDisconnectedFromPrefabAsset(go))
                {
                    m_IsDisconnected = true;
                }
                if (PrefabUtility.IsPrefabAssetMissing(go))
                {
                    m_IsMissing = true;
                }
            }
        }
        internal PrefabOverridesWindow(GameObject selectedGameObject)
        {
            m_SelectedGameObject = selectedGameObject;
            m_TreeViewState      = new TreeViewState();
            m_TreeView           = new PrefabOverridesTreeView(selectedGameObject, m_TreeViewState);

            GameObject prefabAssetRoot = PrefabUtility.GetCorrespondingObjectFromSource(m_SelectedGameObject);

            m_TreeView.SetApplyTarget(m_SelectedGameObject, prefabAssetRoot, AssetDatabase.GetAssetPath(prefabAssetRoot));

            UpdateText(prefabAssetRoot);

            m_Immutable = PrefabUtility.IsPartOfImmutablePrefab(prefabAssetRoot);
            m_InvalidComponentOnInstance = PrefabUtility.HasInvalidComponent(m_SelectedGameObject);
            m_InvalidComponentOnAsset    = PrefabUtility.HasInvalidComponent(prefabAssetRoot);
        }
Ejemplo n.º 6
0
        void CalculatePrefabStatus()
        {
            m_IsPrefabInstanceAnyRoot = false;
            m_IsAsset             = false;
            m_AllOfSamePrefabType = true;
            PrefabAssetType      firstType   = PrefabUtility.GetPrefabAssetType(targets[0]);
            PrefabInstanceStatus firstStatus = PrefabUtility.GetPrefabInstanceStatus(targets[0]);

            foreach (GameObject go in targets)
            {
                PrefabAssetType      type   = PrefabUtility.GetPrefabAssetType(go);
                PrefabInstanceStatus status = PrefabUtility.GetPrefabInstanceStatus(go);
                if (type != firstType || status != firstStatus)
                {
                    m_AllOfSamePrefabType = false;
                }

                if (PrefabUtility.IsAnyPrefabInstanceRoot(go))
                {
                    m_IsPrefabInstanceAnyRoot = true;
                }
                if (m_IsPrefabInstanceAnyRoot)
                {
                    m_IsPrefabInstanceOutermostRoot = PrefabUtility.IsOutermostPrefabInstanceRoot(go);
                }
                if (PrefabUtility.IsPartOfPrefabAsset(go))
                {
                    m_IsAsset = true;
                }
                if (m_IsAsset && PrefabUtility.IsPartOfImmutablePrefab(go))
                {
                    m_ImmutableSelf = true;
                }
                GameObject originalSourceOrVariant = PrefabUtility.GetOriginalSourceOrVariantRoot(go);
                if (originalSourceOrVariant != null && PrefabUtility.IsPartOfImmutablePrefab(originalSourceOrVariant))
                {
                    m_ImmutableSourceAsset = true;
                }
            }
        }
        void SetPrefabModeButtonVisibility(GameObjectTreeViewItem item)
        {
            item.showPrefabModeButton = false;

            GameObject go = item.objectPPTR as GameObject;

            if (go == null)
            {
                return;
            }

            if (!PrefabUtility.IsPartOfAnyPrefab(go))
            {
                return;
            }

            if (!PrefabUtility.IsAnyPrefabInstanceRoot(go))
            {
                return;
            }

            // Don't show button for disconnected prefab instances and if prefab asset is missing
            if (PrefabUtility.GetPrefabInstanceStatus(go) != PrefabInstanceStatus.Connected)
            {
                return;
            }

            // We can't simply check if the go is part of an immutable prefab, since that would check the asset of the
            // outermost prefab this go is part of. Instead we have to check original source or variant root
            // - the same one that would get opened if clicking the arrow.
            var source = PrefabUtility.GetOriginalSourceOrVariantRoot(go);

            if (source == null || PrefabUtility.IsPartOfImmutablePrefab(source))
            {
                return;
            }

            item.showPrefabModeButton = true;
        }
Ejemplo n.º 8
0
 //@TODO This really should be a helper utility somewhere else
 static bool IsUserModifiable(UnityEngine.Object o)
 {
     if (o == null)
     {
         return(false);
     }
     if ((o.hideFlags & HideFlags.NotEditable) != 0)
     {
         return(false);
     }
     if (EditorUtility.IsPersistent(o))
     {
         if (PrefabUtility.IsPartOfImmutablePrefab(o))
         {
             return(false);
         }
         if (!Editor.IsAppropriateFileOpenForEdit(o))
         {
             return(false);
         }
     }
     return(true);
 }