Exemple #1
0
 private static void PrefabStageOpen(PrefabStage prefabStage)
 {
     if (onOpenPrefabMode != null)
     {
         onOpenPrefabMode.OnNext(prefabStage);
     }
 }
Exemple #2
0
 void OnPrefabStageDirtinessChanged(PrefabStage prefabStage)
 {
     if (m_SceneView.customScene == prefabStage.scene)
     {
         m_SceneView.Repaint();
     }
 }
Exemple #3
0
        private static void OnPrefabStageOpened(PrefabStage stage)
        {
            Preview p = stage.prefabContentsRoot.GetComponentInChildren <Preview>();

            if (p)
            {
                p.GenerateIcon();

                Debug.Log("Creating preview for weapon " + stage.prefabContentsRoot.name);

                AddressableAssetSettings settings = AddressableAssetSettingsDefaultObject.Settings;

                if (settings != null)
                {
                    string prefabGuid = AssetDatabase.AssetPathToGUID(stage.prefabAssetPath);
                    AddressableAssetEntry prefabEntry = settings.FindAssetEntry(prefabGuid);

                    if (prefabEntry == null)
                    {
                        Debug.LogError("Prefab entry not found for prefab " + stage.prefabAssetPath);
                        return;
                    }
                }
            }
            else
            {
                Debug.LogError("Preview component not found on weapon " + stage.prefabContentsRoot.name + ". Please make sure your prefab contains a Preview Script on a children GameObject.");
            }

            stage.ClearDirtiness();
            PrefabStage.prefabStageOpened -= OnPrefabStageOpened;
        }
Exemple #4
0
    // --------------------------------------------------------------------

    private bool GetRaycastedPoint(Vector3 from, Vector3 to, out Vector3 hitPos, out Vector3 hitNormal, out Transform hitObj, Transform filterTransform = null)
    {
        hitObj    = null;
        hitNormal = Vector3.up;
        hitPos    = to;

        Vector3 dir = (to - from).normalized;

        PrefabStage prefabStage = PrefabStageUtility.GetCurrentPrefabStage();

        if (prefabStage != null)
        {
            Scene        scene       = prefabStage.scene;
            PhysicsScene physicScene = scene.GetPhysicsScene();
            if (physicScene.Raycast(from, dir, out RaycastHit hit, 100, ~0, QueryTriggerInteraction.Ignore))
            {
                hitPos    = hit.point;
                hitObj    = hit.transform;
                hitNormal = hit.normal;

                return(!filterTransform || filterTransform && hitObj == filterTransform);
            }
            else
            {
                return(false);
            }
        }
Exemple #5
0
    private bool CheckIfIsPrefab()
    {
        PrefabStage prefabStage = PrefabStageUtility.GetPrefabStage(gameObject);

        //Debug.Log("IsPrefabSource: " + gameObject + " : " + prefabStage+", "+ (prefabStage != null));
        return(IsPrefab = (prefabStage != null));
    }
Exemple #6
0
        static public GameObject CreateNewUI()
        {
            var root = new GameObject("Canvas");

            root.layer = LayerMask.NameToLayer("UI");
            Canvas canvas = root.AddComponent <Canvas>();

            canvas.renderMode = RenderMode.ScreenSpaceOverlay;
            root.AddComponent <CanvasScaler>();
            root.AddComponent <GraphicRaycaster>();

            StageUtility.PlaceGameObjectInCurrentStage(root);
            bool        customScene = false;
            PrefabStage prefabStage = PrefabStageUtility.GetCurrentPrefabStage();

            if (prefabStage != null)
            {
                root.transform.SetParent(prefabStage.prefabContentsRoot.transform, false);
                customScene = true;
            }

            Undo.RegisterCreatedObjectUndo(root, "Create " + root.name);

            if (!customScene)
            {
                CreateEventSystem(false);
            }
            return(root);
        }
 void PrefabStageOpened(PrefabStage stage)
 {
     if (m_PreviewObject != null)
     {
         EditorUtility.MoveToActiveScene(m_PreviewObject);
     }
 }
Exemple #8
0
    private static bool BelongsToCurrentStage(this GameObject go, PrefabStage prefabStage, StageHandle stageHandleMain)
    {
        var  stageHandleFromObject = StageUtility.GetStageHandle(go);
        bool result = prefabStage != null ? (stageHandleFromObject == prefabStage.stageHandle) : (stageHandleFromObject == stageHandleMain);

        return(result);
    }
 public bool GetAutoSave(PrefabStage instance)
 {
     if (instance == null) return false;
     if (dg_get_autoSave == null || dg_get_autoSave.Target != (object)instance)
         dg_get_autoSave = (Func<bool>)Delegate.CreateDelegate(typeof(Func<bool>), instance, instance.GetType().GetProperty("autoSave", BindingFlags.Instance | BindingFlags.NonPublic).GetGetMethod(true));
     return dg_get_autoSave();
 }
        void DisplayPrefab()
        {
            if (prefab == null)
            {
                return;
            }

            stage = PrefabStageUtility.GetCurrentPrefabStage();

            if (stage == null || !stage.IsPartOfPrefabContents(prefab))
            {
                if (!AssetDatabase.OpenAsset(prefab))
                {
                    throw new Exception("Cant open prefab!");
                }
                stage = PrefabStageUtility.GetCurrentPrefabStage();
            }

            //stage = PrefabStageUtility.GetPrefabStage(prefab);


//             if(stage == null || !stage.IsPartOfPrefabContents(prefab))
//             {
//                 throw new Exception("Cant enter prefab stage!");
//             }

            tabs.ActivateTab(1);
        }
Exemple #11
0
    private static void OnPrefabStageClosed(PrefabStage prefabStage)
    {
        if (log)
        {
            Debug.LogWarning(string.Format("Prefab stage closed, checking NGUI objects | Cameras: {0} | Panels: {1} | Drawcalls: {2}/{3}",
                                           UICamera.list.size, UIPanel.list.Count, UIDrawCall.activeList.size, UIDrawCall.inactiveList.size));
        }
        CheckNGUIObjects();

        // Since no events happened from standpoint of main stage objects, we have force them to update
        var stageHandleMain = StageUtility.GetMainStageHandle();

        for (int s = 0; s < SceneManager.sceneCount; s++)
        {
            var sceneFromList = SceneManager.GetSceneAt(s);
            if (!sceneFromList.isLoaded)
            {
                continue;
            }

            var stageHandleFromList = StageUtility.GetStageHandle(sceneFromList);
            if (stageHandleFromList != stageHandleMain)
            {
                continue;
            }

            var sceneRootObjects = sceneFromList.GetRootGameObjects();
            for (int i = 0; i < sceneRootObjects.Length; i++)
            {
                FindAndRefreshPanels(sceneRootObjects[i].transform);
            }
        }
    }
Exemple #12
0
            public bool IsOpened(bool selectionMode)
            {
                if (!IsValid)
                {
                    return(false);
                }
                if (_type == ItemType.Scene)
                {
                    return(SceneManager.GetActiveScene().path == _assetPath);
                }

                if (_type == ItemType.Prefab)
                {
                    PrefabStage stage = PrefabStageUtility.GetCurrentPrefabStage();

                    if (stage == null)
                    {
                        return(Selection.activeObject == GetObject());
                    }
                    if (stage.prefabAssetPath != _assetPath)
                    {
                        return(false);
                    }

                    return(!selectionMode || Selection.activeGameObject == stage.prefabContentsRoot);
                }

                return(Selection.activeObject == GetObject());
            }
Exemple #13
0
 public Item(Object obj)
 {
     if (obj is GameObject go)
     {
         if (!go.scene.IsValid())
         {
             _object    = obj;
             _assetPath = AssetDatabase.GetAssetPath(obj);
             _type      = ItemType.Prefab;
         }
         else
         {
             PrefabStage stage = PrefabStageUtility.GetPrefabStage(go);
             if (stage != null && stage.prefabContentsRoot == go)
             {
                 _object    = stage.prefabContentsRoot;
                 _assetPath = stage.prefabAssetPath;
                 _type      = ItemType.Prefab;
             }
             else
             {
                 _object     = obj;
                 _assetPath  = go.scene.path;
                 _instanceID = go.GetInstanceID();
                 _type       = ItemType.HierachyObject;
             }
         }
     }
     else
     {
         _object    = obj;
         _assetPath = AssetDatabase.GetAssetPath(obj);
         _type      = ItemType.Asset;
     }
 }
Exemple #14
0
 private static void PrefabStageClose(PrefabStage prefabStage)
 {
     if (onClosePrefabMode != null)
     {
         onClosePrefabMode.OnNext(prefabStage);
     }
 }
 /// <summary>
 /// プレハブステージが閉じる時
 /// </summary>
 /// <param name="obj"></param>
 static void OnPrefabStageClosing(PrefabStage pstage)
 {
     if (prefabInstanceList.Count > 0)
     {
         DelaySavePrefabAndConnect();
     }
 }
    // UnityEditor.UI.MenuOptions
    public static GameObject CreateNewUI()
    {
        GameObject gameObject = new GameObject("Canvas");

        gameObject.layer = LayerMask.NameToLayer("UI");
        Canvas canvas = gameObject.AddComponent <Canvas>();

        canvas.renderMode = RenderMode.ScreenSpaceOverlay;
        gameObject.AddComponent <CanvasScaler>();
        gameObject.AddComponent <GraphicRaycaster>();
        StageUtility.PlaceGameObjectInCurrentStage(gameObject);
        bool        flag = false;
        PrefabStage currentPrefabStage = PrefabStageUtility.GetCurrentPrefabStage();

        if (currentPrefabStage != null)
        {
            gameObject.transform.SetParent(currentPrefabStage.prefabContentsRoot.transform, false);
            flag = true;
        }
        Undo.RegisterCreatedObjectUndo(gameObject, "Create " + gameObject.name);
        if (!flag)
        {
            SpringGUIMenuOptions.CreateEventSystem(false);
        }
        return(gameObject);
    }
        public static void Button(UnityEngine.Object target, MethodInfo methodInfo)
        {
            if (methodInfo.GetParameters().Length == 0)
            {
                ButtonAttribute buttonAttribute = (ButtonAttribute)methodInfo.GetCustomAttributes(typeof(ButtonAttribute), true)[0];
                string          buttonText      = string.IsNullOrEmpty(buttonAttribute.Text) ? methodInfo.Name : buttonAttribute.Text;

                if (GUILayout.Button(buttonText))
                {
                    methodInfo.Invoke(target, null);

                    // Set target object and scene dirty to serialize changes to disk
                    EditorUtility.SetDirty(target);

                    PrefabStage stage = PrefabStageUtility.GetCurrentPrefabStage();
                    if (stage != null)
                    {
                        // Prefab mode
                        EditorSceneManager.MarkSceneDirty(stage.scene);
                    }
                    else
                    {
                        // Normal scene
                        EditorSceneManager.MarkSceneDirty(EditorSceneManager.GetActiveScene());
                    }
                }
            }
            else
            {
                string warning = typeof(ButtonAttribute).Name + " works only on methods with no parameters";
                HelpBox_Layout(warning, MessageType.Warning, context: target, logToConsole: true);
            }
        }
    static GameObject CreateNewUI()
    {
        // Root for the UI
        var root = new GameObject("Canvas");

        root.layer = LayerMask.NameToLayer("UI");
        Canvas canvas = root.AddComponent <Canvas>();

        canvas.renderMode = RenderMode.ScreenSpaceOverlay;
        root.AddComponent <CanvasScaler>();
        root.AddComponent <GraphicRaycaster>();

        // Works for all stages.
        StageUtility.PlaceGameObjectInCurrentStage(root);
        bool        customScene = false;
        PrefabStage prefabStage = PrefabStageUtility.GetCurrentPrefabStage();

        if (prefabStage != null)
        {
            root.transform.SetParent(prefabStage.prefabContentsRoot.transform, false);
            customScene = true;
        }

        Undo.RegisterCreatedObjectUndo(root, "Create " + root.name);

        // If there is no event system add one...
        // No need to place event system in custom scene as these are temporary anyway.
        // It can be argued for or against placing it in the user scenes,
        // but let's not modify scene user is not currently looking at.
        if (!customScene)
        {
            CreateEventSystem(false, null);
        }
        return(root);
    }
Exemple #19
0
        /// <summary>
        /// Get all <see cref="INotchSimulatorTarget"> and update them.
        /// </summary>
        internal static void UpdateSimulatorTargets()
        {
            var simulatedRectRelative    = NotchSimulatorUtility.enableSimulation ? NotchSimulatorUtility.CalculateSimulatorSafeAreaRelative() : new Rect(0, 0, 1, 1);
            var simulatedCutoutsRelative = NotchSimulatorUtility.enableSimulation ? NotchSimulatorUtility.CalculateSimulatorCutoutsRelative() : new Rect[0];

            //This value could be used by the component statically.
            NotchSolutionUtility.SimulatedSafeAreaRelative = simulatedRectRelative;
#if UNITY_2019_2_OR_NEWER
            NotchSolutionUtility.SimulatedCutoutsRelative = simulatedCutoutsRelative;
#endif

            var normalSceneSimTargets = GameObject.FindObjectsOfType <UIBehaviour>().OfType <INotchSimulatorTarget>();
            foreach (var nst in normalSceneSimTargets)
            {
                nst.SimulatorUpdate(simulatedRectRelative, simulatedCutoutsRelative);
            }

            //Now find one in the prefab mode scene as well
            PrefabStage prefabStage = PrefabStageUtility.GetCurrentPrefabStage();
            if (prefabStage != null)
            {
                var prefabSceneSimTargets = prefabStage.stageHandle.FindComponentsOfType <UIBehaviour>().OfType <INotchSimulatorTarget>();
                foreach (var nst in prefabSceneSimTargets)
                {
                    nst.SimulatorUpdate(simulatedRectRelative, simulatedCutoutsRelative);
                }
            }
        }
Exemple #20
0
        public static List <T> FindInAllScenes <T>()
        {
            List <T> interfaces = new List <T>();

            PrefabStage prefabStage = PrefabStageUtility.GetCurrentPrefabStage();

            if (prefabStage != null)
            {
                TryAddToList(prefabStage.prefabContentsRoot, interfaces);
            }
            else
            {
                for (int i = 0; i < SceneManager.sceneCount; i++)
                {
                    Scene scene = SceneManager.GetSceneAt(i);
                    if (!scene.isLoaded)
                    {
                        continue;
                    }

                    List <T> inScene = FindInScene <T>(scene);
                    foreach (T obj in inScene)
                    {
                        interfaces.Add(obj);
                    }
                }
            }

            return(interfaces);
        }
Exemple #21
0
        /// <summary>
        /// TODO: now only called when hierarchy changes, not when a new prefab is dragged into the scene.
        /// </summary>
        private void UpdateAvailableMenuControllers()
        {
            EnsureSettingsObject();
            // TODO: support MenuControllers in prefabs?
            _availableMenuControllers = HierarchyHelper.GetObjectsOfType <MenuController>();

#if UNITY_2018_3_OR_NEWER
            // Add the open prefab to the list.
            PrefabStage currentPrefabStage = PrefabStageUtility.GetCurrentPrefabStage();
            if (currentPrefabStage != null)
            {
                AddPrefabStageMenuControllers(currentPrefabStage);
            }
#endif
            int labelSize = _availableMenuControllers.Length;
            _availableMenuControllersLabels = new string[labelSize];
            for (int i = 0; i < _availableMenuControllers.Length; i++)
            {
                _availableMenuControllersLabels[i] = _availableMenuControllers[i].name;
                if (_editorMenuCreatorSettings.MenuController == _availableMenuControllers[i])
                {
                    _selectedMenuController = i;
                }
            }
            if (_selectedMenuController >= _availableMenuControllers.Length)
            {
                _selectedMenuController = -1;
            }
        }
Exemple #22
0
        protected virtual void OnValidate()
        {
#if UNITY_EDITOR
            PrefabStage s = PrefabStageUtility.GetCurrentPrefabStage();
            UTDevModeManagment.SetDevMode(_editMode || s != null, transform, _hiddenSiblings);
#endif
        }
Exemple #23
0
        public static bool IsMissingNestPrefab(string assetPath)
        {
            if (!IsPrefab(assetPath))
            {
                return(false);
            }

            OpenPrefabStage(assetPath);

            PrefabStage stage  = PrefabStageUtility.GetCurrentPrefabStage();
            GameObject  rootGO = stage.prefabContentsRoot;

            Transform[] transforms = rootGO.GetComponentsInChildren <Transform>();
            foreach (var t in transforms)
            {
                if (t.name.IndexOf("Missing Prefab") >= 0)
                {
                    return(true);
                }
            }

            ClosePrefabStage();

            return(false);
        }
Exemple #24
0
        static void OnPrefabStageClosing(PrefabStage stage)
        {
            // When closing, we want the bricks that are in the scene
            var bricks = StageUtility.GetMainStageHandle().FindComponentsOfType <Brick>();

            SetShowBricks(showAllBricks, bricks);
        }
Exemple #25
0
        static public GameObject CreateNewUI()
        {
            // Root for the UI
            var root = ObjectFactory.CreateGameObject("Canvas", typeof(Canvas), typeof(CanvasScaler), typeof(GraphicRaycaster));

            root.layer = LayerMask.NameToLayer(kUILayerName);
            Canvas canvas = root.GetComponent <Canvas>();

            canvas.renderMode = RenderMode.ScreenSpaceOverlay;

            // Works for all stages.
            StageUtility.PlaceGameObjectInCurrentStage(root);
            bool        customScene = false;
            PrefabStage prefabStage = PrefabStageUtility.GetCurrentPrefabStage();

            if (prefabStage != null)
            {
                Undo.SetTransformParent(root.transform, prefabStage.prefabContentsRoot.transform, "");
                customScene = true;
            }

            Undo.SetCurrentGroupName("Create " + root.name);

            // If there is no event system add one...
            // No need to place event system in custom scene as these are temporary anyway.
            // It can be argued for or against placing it in the user scenes,
            // but let's not modify scene user is not currently looking at.
            if (!customScene)
            {
                CreateEventSystem(false);
            }
            return(root);
        }
        public static void MethodButton(UnityEngine.Object target, MethodInfo methodInfo)
        {
            ButtonAttribute buttonAttribute = (ButtonAttribute)methodInfo.GetCustomAttributes(typeof(ButtonAttribute), true)[0];
            string          buttonName      = string.IsNullOrEmpty(buttonAttribute.buttonName) ? ObjectNames.NicifyVariableName(methodInfo.Name) : buttonAttribute.buttonName;

            if (GUILayout.Button(buttonName))
            {
                object[]    defaultParams = methodInfo.GetParameters().Select(p => p.DefaultValue).ToArray();
                IEnumerator methodResult  = methodInfo.Invoke(target, defaultParams) as IEnumerator;
                if (!Application.isPlaying)
                {
                    // Set target object and scene dirty to serialize changes to disk
                    EditorUtility.SetDirty(target);

                    PrefabStage stage = PrefabStageUtility.GetCurrentPrefabStage();
                    // Prefab mode
                    if (stage != null)
                    {
                        EditorSceneManager.MarkSceneDirty(stage.scene);
                    }
                    // Normal scene
                    else
                    {
                        EditorSceneManager.MarkSceneDirty(EditorSceneManager.GetActiveScene());
                    }
                }
                else if (methodResult != null && target is MonoBehaviour behaviour)
                {
                    behaviour.StartCoroutine(methodResult);
                }
            }
        }
Exemple #27
0
 void OnPrefabStageIconChanged(PrefabStage prefabStage)
 {
     if (m_PrefabHeaderContent != null)
     {
         m_PrefabHeaderContent.image = prefabStage.prefabFileIcon;
     }
 }
Exemple #28
0
        // TODO: finish
        void OnGUI()
        {
            EditorGUILayout.Space();
            EditorGUILayout.LabelField($"Current profile:");
            EditorGUILayout.BeginVertical();

            selectedFontAsset = (TMP_FontAsset)EditorGUILayout.ObjectField("Select font:", selectedFontAsset, typeof(TMP_FontAsset), false);

            if (GUILayout.Button($"b1"))
            {
                Scene       curScene;
                PrefabStage stage = PrefabStageUtility.GetCurrentPrefabStage();
                if (stage != null)
                {
                    curScene = stage.scene;
                    List <GameObject> roots = new List <GameObject>(curScene.rootCount);
                    curScene.GetRootGameObjects(roots);
                }
                else
                {
                    curScene = SceneManager.GetActiveScene();
                    List <GameObject> roots = new List <GameObject>(curScene.rootCount);
                    curScene.GetRootGameObjects(roots);
                }
            }

            if (GUILayout.Button($"b2"))
            {
                Debug.Log($"b2 pressed");
            }

            EditorGUILayout.EndVertical();
        }
Exemple #29
0
        /// <summary>
        /// Get all <see cref="INotchSimulatorTarget"/> and update them.
        /// </summary>
        internal static void UpdateSimulatorTargets()
        {
            var enableSimulation = Settings.Instance.EnableSimulation;
            var selectedDevice   = SimulationDatabase.ByIndex(Settings.Instance.ActiveConfiguration.DeviceIndex);

            var simulatedRectRelative = enableSimulation && selectedDevice != null?NotchSimulatorUtility.CalculateSimulatorSafeAreaRelative(selectedDevice) : NotchSolutionUtility.defaultSafeArea;

            var simulatedCutoutsRelative = enableSimulation && selectedDevice != null?NotchSimulatorUtility.CalculateSimulatorCutoutsRelative(selectedDevice) : NotchSolutionUtility.defaultCutouts;

            var normalSceneSimTargets = GameObject.FindObjectsOfType <MonoBehaviour>().OfType <INotchSimulatorTarget>();

            foreach (var nst in normalSceneSimTargets)
            {
                nst.SimulatorUpdate(simulatedRectRelative, simulatedCutoutsRelative);
            }

            //Now find one in the prefab mode scene as well
            PrefabStage prefabStage = PrefabStageUtility.GetCurrentPrefabStage();

            if (prefabStage != null)
            {
                var prefabSceneSimTargets = prefabStage.stageHandle.FindComponentsOfType <MonoBehaviour>().OfType <INotchSimulatorTarget>();
                foreach (var nst in prefabSceneSimTargets)
                {
                    nst.SimulatorUpdate(simulatedRectRelative, simulatedCutoutsRelative);
                }
            }
        }
Exemple #30
0
        public override void ProcessAsset(SearchJob job)
        {
#if UNITY_2018_3_OR_NEWER
            PrefabStage stage = PrefabStageUtility.GetPrefabStage(sceneObjects[0]);
            if (stage != null)
            {
                isInPrefabStage = true;
            }
#endif

            roots = sceneObjects.ToArray();

            job.OnAssetSearchBegin();
            foreach (GameObject root in roots)
            {
                job.searchGameObject(root);
            }

#if UNITY_2018_3_OR_NEWER
            if (assetIsDirty && isInPrefabStage)
            {
                EditorSceneManager.MarkSceneDirty(stage.scene);
            }
#endif
        }