Esempio n. 1
0
        protected override void Draw(Rect r)
        {
            var drawR = r;

            drawR.xMin -= 16f;
            asset.Draw(drawR, false, false);

            var bRect = r;

            bRect.xMin += bRect.width - 50f;
            if (GUI.Button(bRect, "Use", EditorStyles.miniButton))
            {
                EditorGUIUtility.systemCopyBuffer = asset.guid;
                Selection.objects = (parent as FR2_DuplicateFolder).children.Select(
                    a => FR2_Unity.LoadAssetAtPath <Object>(((FR2_DuplicateAsset)a).asset.assetPath)
                    ).ToArray();
                FR2_Export.MergeDuplicate();
            }

            //if (GUI.Button(bRect, "Remove Others", EditorStyles.miniButton))
            //{
            //    EditorGUIUtility.systemCopyBuffer = asset.guid;
            //    Selection.objects = (parent as FR2_DuplicateFolder).children.Select(
            //        a => FR2_Unity.LoadAssetAtPath<Object>(((FR2_DuplicateAsset)a).asset.assetPath)
            //    ).ToArray();
            //    FR2_Export.MergeDuplicate();
            //}
        }
Esempio n. 2
0
        internal void LoadBinaryAsset()
        {
            UseGUIDs.Clear();

            //var assets = AssetDatabase.LoadAllAssetsAtPath(assetPath);
            //for (var i = 0;i < assets.Length; i++){
            //	Debug.Log(i + " : "+ assets[i].name + ":" + assets[i].GetType() + "\n" +
            //		//EditorUtility.GetAssetPath(assets[i]) + "\n"
            //		assets[i].GetHashCode()
            //	);
            //}

            var assetData = AssetDatabase.LoadAssetAtPath(assetPath, typeof(Object));

            if (assetData is GameObject)
            {
                type = FR2_AssetType.MODEL;
                LoadGameObject(assetData as GameObject);
            }
            else if (assetData is TerrainData)
            {
                type = FR2_AssetType.TERRAIN;
                LoadTerrainData(assetData as TerrainData);
            }

            //Debug.Log("LoadBinaryAsset :: " + assetData + ":" + type);

            assetData = null;
            FR2_Unity.UnloadUnusedAssets();
        }
Esempio n. 3
0
        public FR2_SceneRef(int depth, Object target) : base(0, depth, null, null)
        {
            component  = target;
            this.depth = depth;
            isSceneRef = true;
            var obj = target as GameObject;

            if (obj == null)
            {
                var com = target as Component;
                if (com != null)
                {
                    obj = com.gameObject;
                }
            }

            scenePath = FR2_Unity.GetGameObjectPath(obj, false);
            if (component == null)
            {
                return;
            }

            sceneFullPath = scenePath + component.name;
            targetType    = component.GetType().Name;
        }
Esempio n. 4
0
        private static void ShowWindow()
        {
            var _window = CreateInstance <FR2_WindowAll>();

            _window.InitIfNeeded();
            FR2_Unity.SetWindowTitle(_window, "FR2");
            _window.Show();
        }
Esempio n. 5
0
        private void DrawGUIDs()
        {
            var ids  = FR2_Unity.Selection_AssetGUIDs;
            var objs = Selection.objects;

            GUILayout.Label("GUID to Object", EditorStyles.boldLabel);
            GUILayout.BeginHorizontal();
            {
                var guid = EditorGUILayout.TextField(tempGUID ?? string.Empty);
                EditorGUILayout.ObjectField(tempObject, typeof(Object), false, GUILayout.Width(120f));

                if (GUILayout.Button("Paste", EditorStyles.miniButton, GUILayout.Width(70f)))
                {
                    guid = EditorGUIUtility.systemCopyBuffer;
                }

                if (guid != tempGUID && !string.IsNullOrEmpty(guid))
                {
                    tempGUID = guid;

                    tempObject = FR2_Unity.LoadAssetAtPath <Object>
                                 (
                        AssetDatabase.GUIDToAssetPath(tempGUID)
                                 );
                }
            }
            GUILayout.EndHorizontal();
            GUILayout.Space(10f);
            //GUILayout.Label("Selection", EditorStyles.boldLabel);
            if (ids.Length == objs.Length)
            {
                scrollPos = GUILayout.BeginScrollView(scrollPos);
                {
                    for (var i = 0; i < ids.Length; i++)
                    {
                        GUILayout.BeginHorizontal();
                        {
                            EditorGUILayout.ObjectField(objs[i], typeof(Object), false);
                            var idi = ids[i];
                            GUILayout.TextField(idi, GUILayout.Width(240f));
                            if (GUILayout.Button("Copy", EditorStyles.miniButton, GUILayout.Width(50f)))
                            {
                                EditorGUIUtility.systemCopyBuffer = idi;
                                //Debug.Log(EditorGUIUtility.systemCopyBuffer);
                            }
                        }
                        GUILayout.EndHorizontal();
                    }
                }
                GUILayout.EndScrollView();
            }

            GUILayout.FlexibleSpace();
            if (GUILayout.Button("Merge Selection"))
            {
                FR2_Export.MergeDuplicate();
            }
        }
Esempio n. 6
0
        private static void Initialize()
        {
            if (window == null)
            {
                window = GetWindow <FR2_Window>();
                window.Init();
            }

            FR2_Unity.SetWindowTitle(window, "FR2");
            window.Show();
        }
Esempio n. 7
0
        internal void AddToSelection()
        {
            var list = Selection.objects.ToList();
            var obj  = FR2_Unity.LoadAssetAtPath <Object>(assetPath);

            if (!list.Contains(obj))
            {
                list.Add(obj);
                Selection.objects = list.ToArray();
            }
        }
Esempio n. 8
0
        //-------------------------- UTILS ---------------------

        internal static void AddToDict(Dictionary <string, Object> dict, params FR2_Asset[] list)
        {
            for (var j = 0; j < list.Length; j++)
            {
                string guid = list[j].guid;
                if (!dict.ContainsKey(guid))
                {
                    string assetPath = AssetDatabase.GUIDToAssetPath(guid);
                    dict.Add(guid, FR2_Unity.LoadAssetAtPath <Object>(assetPath));
                }
            }
        }
Esempio n. 9
0
        internal void ReadFromProject(bool force)
        {
            var paths = AssetDatabase.GetAllAssetPaths().ToList();

            paths.RemoveAll(item => !item.StartsWith("Assets/"));
            var guids = paths.Select(item => AssetDatabase.AssetPathToGUID(item)).ToArray();

            cacheStamp++;

            // Check for new assets
            for (var i = 0; i < guids.Length; i++)
            {
                if (!FR2_Asset.IsValidGUID(guids[i]))
                {
                    continue;
                }

                FR2_Asset asset;

                if (AssetMap.TryGetValue(guids[i], out asset))
                {
                    asset.cacheStamp = cacheStamp;
                    continue;
                }

                ;

                // New asset
                AddAsset(guids[i]);
            }

            // Check for deleted assets
            for (var i = AssetList.Count - 1; i >= 0; i--)
            {
                if (AssetList[i].cacheStamp != cacheStamp)
                {
                    RemoveAsset(AssetList[i]);
                }
            }

            // Refresh definition list
            for (var i = 0; i < AssetList.Count; i++)
            {
                AddSymbols(AssetList[i]);
            }

            if (force)
            {
                timeStamp  = FR2_Unity.Epoch(DateTime.Now);
                workCount += AssetMap.Count;
                queueLoadContent.AddRange(AssetMap.Values.ToList());
            }
        }
Esempio n. 10
0
 private static bool RestoreCacheFromPath(string path, bool savePrefs, bool writeFile)
 {
     if (string.IsNullOrEmpty(path))
     {
         return(false);
     }
     _cache = FR2_Unity.LoadAssetAtPath <FR2_Cache>(path);
     if (_cache != null)
     {
         FoundCache(savePrefs, writeFile);
     }
     return(_cache != null);
 }
Esempio n. 11
0
        public override void OnSelectionChange()
        {
            isNoticeIgnore = false;
            if (!FR2_Cache.isReady)
            {
                return;
            }

            if (lockSelection)
            {
                return;
            }

            if (focusedWindow == null)
            {
                return;
            }

            if (SceneUsesDrawer == null)
            {
                InitIfNeeded();
            }

            ids = FR2_Unity.Selection_AssetGUIDs;

            //ignore selection on asset when selected any object in scene
            if (Selection.gameObjects.Length > 0 && !FR2_Unity.IsInAsset(Selection.gameObjects[0]))
            {
                ids = new string[0];
            }

            if (IsFocusingSceneInScene)
            {
                RefSceneInScene.ResetSceneInScene(Selection.gameObjects);
            }

            if (IsFocusingUses)
            {
                SceneUsesDrawer.ResetSceneUseSceneObjects(Selection.gameObjects);
            }

            if (IsFocusingFindInScene)
            {
                RefInScene.Reset(ids, this as IWindow);
            }

            level = 0;

            EditorApplication.delayCall += Repaint;
        }
Esempio n. 12
0
        private static void ExportAsset()
        {
            var list = GetSelectionDependencies();

            for (var i = list.Count - 1; i >= 0; i--)
            {
                if (list[i] is MonoScript)
                {
                    list.RemoveAt(i);
                }
                //Debug.Log(i + ":" + list[i] + ":" + list[i].GetType());
            }
            Selection.objects = list.ToArray();
            FR2_Unity.ExportSelection();
        }
Esempio n. 13
0
 private static List <Object> GetSelectionDependencies()
 {
     if (!FR2_Cache.isReady)
     {
         Debug.LogWarning("FR2 cache not yet ready, please open Window > FR2_Window !");
         return(null);
     }
     return(FR2_Cache.FindUsage(FR2_Unity.Selection_AssetGUIDs).Select(
                guid =>
     {
         var assetPath = AssetDatabase.GUIDToAssetPath(guid);
         return FR2_Unity.LoadAssetAtPath <Object>(assetPath);
     }
                ).ToList());
 }
Esempio n. 14
0
        internal void LoadAssetInfo()
        {
            assetPath = AssetDatabase.GUIDToAssetPath(guid);

            if (string.IsNullOrEmpty(assetPath))
            {
                state = FR2_AssetState.MISSING;
                return;
            }

            if (!assetPath.StartsWith("Assets/", StringComparison.Ordinal))
            {
#if FR2_DEBUG
                Debug.LogWarning("Something wrong ! Should never be here !\n" + assetPath + "\n" + guid);
#endif
                return;
            }

            var info = new FileInfo(assetPath);
            assetName   = info.Name;
            extension   = info.Extension.ToLower();
            assetFolder = assetPath.Substring(7, Mathf.Max(0, assetPath.Length - assetName.Length - 7));
            // 7 = "Assets/".Length
            loaded = stamp == FR2_Unity.Epoch(info.LastWriteTime);

            if (Directory.Exists(info.FullName))
            {
                type = FR2_AssetType.FOLDER;
            }
            else if (File.Exists(info.FullName))
            {
                if (type == FR2_AssetType.UNKNOWN)
                {
                    GuessAssetType();
                }

                fileSize         = info.Length;
                inEditor         = assetPath.Contains("/Editor/");
                inResources      = assetPath.Contains("/Resources/");
                inStreamingAsset = assetPath.Contains("/StreamingAsset/");
                inPlugins        = assetPath.StartsWith("Assets/Plugins/", StringComparison.Ordinal);
                fileInfoHash     = info.Length + info.Extension;
            }
            else
            {
                state = FR2_AssetState.MISSING;
            }
        }
Esempio n. 15
0
        private static void FoundCache(bool savePrefs, bool writeFile)
        {
            var elapseTime = FR2_Unity.Epoch(DateTime.Now) - _cache.timeStamp;

            _cache.Check4Changes(!EditorApplication.isPlaying, elapseTime > FORCE_REFRESH_DURATION);
            _cachePath = AssetDatabase.GetAssetPath(_cache);
            _cacheGUID = AssetDatabase.AssetPathToGUID(_cachePath);

            if (savePrefs)
            {
                EditorPrefs.SetString("fr2_cache.guid", _cacheGUID);
            }
            if (writeFile)
            {
                File.WriteAllText("Library/fr2_cache.guid", _cacheGUID);
            }
        }
Esempio n. 16
0
        // ------------------------- Scene use scene objects
        public static Dictionary <string, FR2_Ref> FindSceneUseSceneObjects(GameObject[] targets)
        {
            var results = new Dictionary <string, FR2_Ref>();

            GameObject[] objs = Selection.gameObjects;
            for (var i = 0; i < objs.Length; i++)
            {
                if (FR2_Unity.IsInAsset(objs[i]))
                {
                    continue;
                }

                string key = objs[i].GetInstanceID().ToString();
                if (!results.ContainsKey(key))
                {
                    results.Add(key, new FR2_SceneRef(0, objs[i]));
                }

                Component[] coms = objs[i].GetComponents <Component>();
                Dictionary <Component, HashSet <FR2_SceneCache.HashValue> > SceneCache = FR2_SceneCache.Api.cache;
                for (var j = 0; j < coms.Length; j++)
                {
                    HashSet <FR2_SceneCache.HashValue> hash = null;
                    if (SceneCache.TryGetValue(coms[j], out hash))
                    {
                        foreach (FR2_SceneCache.HashValue item in hash)
                        {
                            if (item.isSceneObject)
                            {
                                Object obj  = item.target;
                                string key1 = obj.GetInstanceID().ToString();
                                if (!results.ContainsKey(key1))
                                {
                                    results.Add(key1, new FR2_SceneRef(1, obj));
                                }
                            }
                        }
                    }
                }
            }

            return(results);
        }
Esempio n. 17
0
        public void DrawSettings()
        {
            if (FR2_Unity.DrawToggle(ref pingRow, "Full Row click to Ping"))
            {
                setDirty();
            }

            GUILayout.BeginHorizontal();
            {
                if (FR2_Unity.DrawToggle(ref alternateColor, "Alternate Odd & Even Row Color"))
                {
                    setDirty();
                    FR2_Unity.RepaintFR2Windows();
                }

                EditorGUI.BeginDisabledGroup(!alternateColor);
                {
                    var c = EditorGUILayout.ColorField(rowColor);
                    if (!c.Equals(rowColor))
                    {
                        rowColor = c;
                        setDirty();
                        FR2_Unity.RepaintFR2Windows();
                    }
                }
                EditorGUI.EndDisabledGroup();
            }
            GUILayout.EndHorizontal();

            if (FR2_Unity.DrawToggle(ref referenceCount, "Show Usage Count in Project panel"))
            {
                setDirty();
                FR2_Unity.RepaintProjectWindows();
            }

            if (FR2_Unity.DrawToggle(ref showSelection, "Show Selection"))
            {
                setDirty();
                FR2_Unity.RepaintFR2Windows();
            }
        }
Esempio n. 18
0
        public static Dictionary <string, FR2_Ref> FindUsageScene(GameObject[] objs, bool depth)
        {
            var dict = new Dictionary <string, FR2_Ref>();

            // var list = new List<FR2_Ref>();

            for (var i = 0; i < objs.Length; i++)
            {
                if (FR2_Unity.IsInAsset(objs[i]))
                {
                    continue;                     //only get in scene
                }

                //add selection
                if (!dict.ContainsKey(objs[i].GetInstanceID().ToString()))
                {
                    dict.Add(objs[i].GetInstanceID().ToString(), new FR2_SceneRef(0, objs[i]));
                }

                foreach (Object item in FR2_Unity.GetAllRefObjects(objs[i]))
                {
                    AppendUsageScene(dict, item);
                }

                if (depth)
                {
                    foreach (GameObject child in FR2_Unity.getAllChild(objs[i]))
                    {
                        foreach (Object item2 in FR2_Unity.GetAllRefObjects(child))
                        {
                            AppendUsageScene(dict, item2);
                        }
                    }
                }
            }

            return(dict);
        }
Esempio n. 19
0
        internal void LoadContent(bool force)
        {
            if (state == FR2_AssetState.NEW)
            {
                LoadAssetInfo();
            }

            if (IsMissing || type == FR2_AssetType.NON_READABLE)
            {
                return;
            }

            if (type == FR2_AssetType.DLL)
            {
#if FR2_DEBUG
                Debug.LogWarning("Parsing DLL not yet supportted ");
#endif
                return;
            }

            if (loaded && !force)
            {
                return;
            }

            // Check for file / folder changes & validate if file / folder exist
            var newStamp = stamp;
            var exist    = true;

            if (IsFolder)
            {
                var info = new DirectoryInfo(assetPath);
                exist    = info.Exists;
                newStamp = FR2_Unity.Epoch(info.LastWriteTime);
            }
            else
            {
                var info = new FileInfo(assetPath);
                exist    = info.Exists;
                newStamp = FR2_Unity.Epoch(info.LastWriteTime);
            }

            if (!exist)
            {
                state = FR2_AssetState.MISSING;
                return;
            }

            loaded = true;
            if (newStamp == stamp && !force)
            {
#if FR2_DEBUG
                Debug.Log("Unchanged : " + stamp + ":" + assetName + ":" + type);
#endif
                return; // nothing changed
            }

            stamp = newStamp;

            UseGUIDs.Clear();

            if (IsFolder)
            {
                LoadFolder();
            }
            else if (IsReferencable)
            {
                LoadYAML();
            }
            else if (IsBinaryAsset)
            {
                LoadBinaryAsset();
            }
            else if (IsScript)
            {
                LoadScript();
            }
        }
Esempio n. 20
0
        private void ApplyFilter()
        {
            dirty = false;

            if (refs == null)
            {
                return;
            }

            if (list == null)
            {
                list = new List <FR2_Ref>();
            }
            else
            {
                list.Clear();
            }

            int minScore = searchTerm.Length;

            string term1 = searchTerm;

            if (!caseSensitive)
            {
                term1 = term1.ToLower();
            }

            string term2 = term1.Replace(" ", string.Empty);

            excludeCount = 0;

            foreach (KeyValuePair <string, FR2_Ref> item in refs)
            {
                FR2_Ref r = item.Value;

                if (r.depth == 0 && !FR2_Setting.ShowSelection)
                {
                    continue;
                }

                if (FR2_Setting.IsTypeExcluded(r.type))
                {
                    excludeCount++;
                    continue;                     //skip this one
                }

                if (!showSearch || string.IsNullOrEmpty(searchTerm))
                {
                    r.matchingScore = 0;
                    list.Add(r);
                    continue;
                }

                //calculate matching score
                string name1 = r.isSceneRef ? (r as FR2_SceneRef).sceneFullPath : r.asset.assetName;
                if (!caseSensitive)
                {
                    name1 = name1.ToLower();
                }

                string name2 = name1.Replace(" ", string.Empty);

                int score1 = FR2_Unity.StringMatch(term1, name1);
                int score2 = FR2_Unity.StringMatch(term2, name2);

                r.matchingScore = Mathf.Max(score1, score2);
                if (r.matchingScore > minScore)
                {
                    list.Add(r);
                }
            }

            RefreshSort();
        }
Esempio n. 21
0
        // ----------------------------- REPLACE GUIDS ---------------------------------------

        internal bool ReplaceReference(string fromGUID, string toGUID)
        {
            if (IsMissing)
            {
                return(false);
            }

            if (IsReferencable)
            {
                var text = string.Empty;

                if (!File.Exists(assetPath))
                {
                    state = FR2_AssetState.MISSING;
                    return(false);
                }

                try
                {
                    text = File.ReadAllText(assetPath).Replace("\r", "\n");
                    File.WriteAllText(assetPath, text.Replace(fromGUID, toGUID));
                    return(true);
                }
                catch (Exception e)
                {
                    state = FR2_AssetState.MISSING;
//#if FR2_DEBUG
                    Debug.LogWarning("Replace Reference error :: " + e + "\n" + assetPath);
//#endif
                }

                return(false);
            }

            if (type == FR2_AssetType.TERRAIN)
            {
                var fromObj = FR2_Unity.LoadAssetWithGUID <Object>(fromGUID);
                var toObj   = FR2_Unity.LoadAssetWithGUID <Object>(toGUID);
                var found   = 0;
                var terrain = AssetDatabase.LoadAssetAtPath(assetPath, typeof(Object)) as TerrainData;

                if (fromObj is Texture2D)
                {
                    var arr = terrain.detailPrototypes;
                    for (var i = 0; i < arr.Length; i++)
                    {
                        if (arr[i].prototypeTexture == (Texture2D)fromObj)
                        {
                            found++;
                            arr[i].prototypeTexture = (Texture2D)toObj;
                        }
                    }

                    terrain.detailPrototypes = arr;

                    var arr3 = terrain.splatPrototypes;
                    for (var i = 0; i < arr3.Length; i++)
                    {
                        if (arr3[i].texture == (Texture2D)fromObj)
                        {
                            found++;
                            arr3[i].texture = (Texture2D)toObj;
                        }

                        if (arr3[i].normalMap == (Texture2D)fromObj)
                        {
                            found++;
                            arr3[i].normalMap = (Texture2D)toObj;
                        }
                    }

                    terrain.splatPrototypes = arr3;
                }

                if (fromObj is GameObject)
                {
                    var arr2 = terrain.treePrototypes;
                    for (var i = 0; i < arr2.Length; i++)
                    {
                        if (arr2[i].prefab == (GameObject)fromObj)
                        {
                            found++;
                            arr2[i].prefab = (GameObject)toObj;
                        }
                    }

                    terrain.treePrototypes = arr2;
                }

                EditorUtility.SetDirty(terrain);
                AssetDatabase.SaveAssets();

                fromObj = null;
                toObj   = null;
                terrain = null;
                FR2_Unity.UnloadUnusedAssets();

                return(found > 0);
            }

            Debug.LogWarning("Something wrong, should never be here - Ignored <" + assetPath +
                             "> : not a readable type, can not replace ! " + type);
            return(false);
        }
Esempio n. 22
0
        // ------------------------- Scene in scene
        public static Dictionary <string, FR2_Ref> FindSceneInScene(GameObject[] targets)
        {
            var results = new Dictionary <string, FR2_Ref>();

            GameObject[] objs = Selection.gameObjects;
            for (var i = 0; i < objs.Length; i++)
            {
                if (FR2_Unity.IsInAsset(objs[i]))
                {
                    continue;
                }

                string key = objs[i].GetInstanceID().ToString();
                if (!results.ContainsKey(key))
                {
                    results.Add(key, new FR2_SceneRef(0, objs[i]));
                }


                foreach (KeyValuePair <Component, HashSet <FR2_SceneCache.HashValue> > item in FR2_SceneCache.Api.cache)
                {
                    foreach (FR2_SceneCache.HashValue item1 in item.Value)
                    {
                        // if(item.Key.gameObject.name == "ScenesManager")
                        // Debug.Log(item1.objectReferenceValue);
                        GameObject ob = null;
                        if (item1.target is GameObject)
                        {
                            ob = item1.target as GameObject;
                        }
                        else
                        {
                            var com = item1.target as Component;
                            if (com == null)
                            {
                                continue;
                            }

                            ob = com.gameObject;
                        }

                        if (ob == null)
                        {
                            continue;
                        }

                        if (ob != objs[i])
                        {
                            continue;
                        }

                        key = item.Key.GetInstanceID().ToString();
                        if (!results.ContainsKey(key))
                        {
                            results.Add(key, new FR2_SceneRef(1, item.Key));
                        }

                        (results[key] as FR2_SceneRef).usingType.Add(item1.target.GetType().FullName);
                    }
                }
            }

            return(results);
        }
Esempio n. 23
0
        public FR2_RefDrawer Reset(GameObject[] objs, bool findDept, bool findPrefabInAsset)
        {
            refs = FR2_Ref.FindUsageScene(objs, findDept);

            var guidss = new List <string>();
            Dictionary <GameObject, HashSet <string> > dependent = FR2_SceneCache.Api.prefabDependencies;

            foreach (GameObject gameObject in objs)
            {
                HashSet <string> hash;
                if (!dependent.TryGetValue(gameObject, out hash))
                {
                    continue;
                }

                foreach (string guid in hash)
                {
                    guidss.Add(guid);
                }
            }

            Dictionary <string, FR2_Ref> usageRefs1 = FR2_Ref.FindUsage(guidss.ToArray());

            foreach (KeyValuePair <string, FR2_Ref> kvp in usageRefs1)
            {
                if (refs.ContainsKey(kvp.Key))
                {
                    continue;
                }

                if (guidss.Contains(kvp.Key))
                {
                    kvp.Value.depth = 1;
                }

                refs.Add(kvp.Key, kvp.Value);
            }


            if (findPrefabInAsset)
            {
                var guids = new List <string>();
                for (var i = 0; i < objs.Length; i++)
                {
                    string guid = FR2_Unity.GetPrefabParent(objs[i]);
                    if (string.IsNullOrEmpty(guid))
                    {
                        continue;
                    }

                    guids.Add(guid);
                }

                Dictionary <string, FR2_Ref> usageRefs = FR2_Ref.FindUsage(guids.ToArray());
                foreach (KeyValuePair <string, FR2_Ref> kvp in usageRefs)
                {
                    if (refs.ContainsKey(kvp.Key))
                    {
                        continue;
                    }

                    if (guids.Contains(kvp.Key))
                    {
                        kvp.Value.depth = 1;
                    }

                    refs.Add(kvp.Key, kvp.Value);
                }
            }

            dirty = true;
            if (list != null)
            {
                list.Clear();
            }

            return(this);
        }
Esempio n. 24
0
 //[MenuItem("Assets/FR2/Export Selection", false, 21)]
 private static void ExportSelection()
 {
     FR2_Unity.ExportSelection();
 }
Esempio n. 25
0
        public void Draw(Rect r, IWindow window)
        {
            bool selected = isSelected();
            var  margin   = 2;
            var  left     = new Rect(r);

            left.width = r.width / 3f;
            var right = new Rect(r);

            right.x    += left.width + margin;
            right.width = r.width * 2f / 3 - margin;

            if (/* FR2_Setting.PingRow && */ Event.current.type == EventType.MouseDown && Event.current.button == 0)
            {
                Rect pingRect = FR2_Setting.PingRow
                                        ? new Rect(0, r.y, r.x + r.width, r.height)
                                        : left;
                if (pingRect.Contains(Event.current.mousePosition))
                {
                    if (Event.current.control || Event.current.command)
                    {
                        if (selected)
                        {
                            FR2_Selection.RemoveSelection(this);
                        }
                        else
                        {
                            FR2_Selection.AppendSelection(this);
                        }

                        if (window != null)
                        {
                            window.Repaint();
                        }
                    }

                    EditorGUIUtility.PingObject(component);
                    //Event.current.Use();
                }
            }


            EditorGUI.ObjectField(left, GUIContent.none, component, typeof(GameObject), true);


            bool   drawPath  = FR2_Setting.GroupMode != FR2_RefDrawer.Mode.Folder;
            float  pathW     = drawPath ? EditorStyles.miniLabel.CalcSize(new GUIContent(scenePath)).x : 0;
            string assetName = component.name;
            // if(usingType!= null && usingType.Count > 0)
            // {
            //  assetName += " -> ";
            //  foreach(var item in usingType)
            //  {
            //      assetName += item + " - ";
            //  }
            //  assetName = assetName.Substring(0, assetName.Length - 3);
            // }
            Color cc = FR2_Cache.Api.setting.SelectedColor;

            var lableRect = new Rect(
                right.x,
                right.y,
                pathW + EditorStyles.boldLabel.CalcSize(new GUIContent(assetName)).x,
                right.height);

            if (selected)
            {
                Color c = GUI.color;
                GUI.color = cc;
                GUI.DrawTexture(lableRect, EditorGUIUtility.whiteTexture);
                GUI.color = c;
            }

            if (drawPath)
            {
                GUI.Label(LeftRect(pathW, ref right), scenePath, EditorStyles.miniLabel);
                right.xMin -= 4f;
                GUI.Label(right, assetName, EditorStyles.boldLabel);
            }
            else
            {
                GUI.Label(right, assetName);
            }


            if (!FR2_Setting.ShowUsedByClassed || usingType == null)
            {
                return;
            }

            float sub = 10;
            var   re  = new Rect(r.x + r.width - sub, r.y, 20, r.height);
            Type  t   = null;

            foreach (string item in usingType)
            {
                string name = item;
                if (!CacheType.TryGetValue(item, out t))
                {
                    t = FR2_Unity.GetType(name);
                    // if (t == null)
                    // {
                    //  continue;
                    // }
                    CacheType.Add(item, t);
                }

                GUIContent content;
                var        width = 0.0f;
                if (!FR2_Asset.cacheImage.TryGetValue(name, out content))
                {
                    if (t == null)
                    {
                        content = new GUIContent(name);
                    }
                    else
                    {
                        Texture text = EditorGUIUtility.ObjectContent(null, t).image;
                        if (text == null)
                        {
                            content = new GUIContent(name);
                        }
                        else
                        {
                            content = new GUIContent(text, name);
                        }
                    }


                    FR2_Asset.cacheImage.Add(name, content);
                }

                if (content.image == null)
                {
                    width = EditorStyles.label.CalcSize(content).x;
                }
                else
                {
                    width = 20;
                }

                re.x    -= width;
                re.width = width;

                GUI.Label(re, content);
                re.x -= margin;                 // margin;
            }


            // var nameW = EditorStyles.boldLabel.CalcSize(new GUIContent(assetName)).x;
        }
Esempio n. 26
0
        private static void ApplicationUpdate()
        {
            bool notComplete = listReplace.Where(x => x.Value.processIndex >= 0).Count() > 0;

            if (lstThreads.Count <= 0 && notComplete)
            {
                foreach (KeyValuePair <string, ProcessReplaceData> item in listReplace)
                {
                    if (item.Value.processIndex >= 0)
                    {
                        ReplaceData a = item.Value.datas[item.Value.processIndex--];
                        a.isTerrian = a.asset.type == FR2_AssetType.TERRAIN;
                        if (a.isTerrian)
                        {
                            a.terrainData =
                                AssetDatabase.LoadAssetAtPath(a.asset.assetPath, typeof(Object)) as TerrainData;
                        }

                        var thread = new Thread(
                            delegate()
                        {
                            lock (a)
                            {
                                a.isSucess = a.asset.ReplaceReference(a.from, a.to, a.terrainData);
                                // Debug.Log(a.asset.assetPath+" "+ a.isSucess);
                            }
                        });
                        lstThreads.Add(thread);
                        thread.Start();
                    }
                }
            }

            for (int i = lstThreads.Count - 1; i >= 0; i--)
            {
                if (!lstThreads[i].IsAlive)
                {
                    lstThreads.RemoveAt(i);
                }
            }

            foreach (KeyValuePair <string, ProcessReplaceData> item in listReplace)
            {
                List <ReplaceData> lst = item.Value.datas;
                for (var i = 0; i < lst.Count; i++)
                {
                    ReplaceData data = lst[i];
                    if (!data.isUpdated && data.isSucess)
                    {
                        data.isUpdated = true;
                        if (data.isTerrian)
                        {
                            EditorUtility.SetDirty(data.terrainData);
                            AssetDatabase.SaveAssets();
                            data.terrainData = null;
                            FR2_Unity.UnloadUnusedAssets();
                        }
                        else
                        {
                            AssetDatabase.ImportAsset(data.asset.assetPath, ImportAssetOptions.Default);
                        }
                    }
                }
            }


            if (lstThreads.Count <= 0 && !notComplete)             //complete
            {
                var guidsRefreshed = new HashSet <string>();
                EditorApplication.update -= ApplicationUpdate;
                foreach (KeyValuePair <string, ProcessReplaceData> item in listReplace)
                {
                    List <ReplaceData> lst = item.Value.datas;
                    for (var i = 0; i < lst.Count; i++)
                    {
                        ReplaceData data = lst[i];
                        if (data.isSucess && !guidsRefreshed.Contains(data.asset.guid))
                        {
                            guidsRefreshed.Add(data.asset.guid);
                            FR2_Cache.Api.RefreshAsset(data.asset.guid, true);
                        }
                    }
                }

                lstThreads  = null;
                listReplace = null;
                FR2_Cache.Api.RefreshSelection();
                FR2_Cache.Api.Check4Usage();
                // EditorUtility.SetDirty(FR2_Cache.Api);
                AssetDatabase.Refresh();
                IsMergeProcessing = false;
            }
        }
Esempio n. 27
0
        public override void OnSelectionChange()
        {
            Repaint();

            isNoticeIgnore = false;
            if (!FR2_Cache.isReady)
            {
                return;
            }

            if (lockSelection)
            {
                return;
            }

            if (focusedWindow == null)
            {
                return;
            }

            if (SceneUsesDrawer == null)
            {
                InitIfNeeded();
            }

            if (UsesDrawer == null)
            {
                InitIfNeeded();
            }

            ids = FR2_Unity.Selection_AssetGUIDs;

            //ignore selection on asset when selected any object in scene
            if (Selection.gameObjects.Length > 0 && !FR2_Unity.IsInAsset(Selection.gameObjects[0]))
            {
                ids = new string[0];
            }

            level = 0;
            if (IsFocusingSceneToAsset)
            {
                SceneToAssetDrawer.Reset(Selection.gameObjects, true, true);
            }

            if (IsFocusingUses)
            {
                UsesDrawer.Reset(ids, true);
            }

            if (IsFocusingUsedBy)
            {
                UsedByDrawer.Reset(ids, false);
            }

            if (IsFocusingSceneInScene)
            {
                RefSceneInScene.ResetSceneInScene(Selection.gameObjects);
            }

            if (IsFocusingUses)
            {
                SceneUsesDrawer.ResetSceneUseSceneObjects(Selection.gameObjects);
            }

            if (IsFocusingFindInScene)
            {
                RefInScene.Reset(ids, this as IWindow);
            }

            if (IsFocusingGUIDs)
            {
                objs = new Object[ids.Length];
                for (var i = 0; i < ids.Length; i++)
                {
                    objs[i] = FR2_Unity.LoadAssetAtPath <Object>
                              (
                        AssetDatabase.GUIDToAssetPath(ids[i])
                              );
                }
            }


            if (FR2_SceneCache.Api.Dirty && !Application.isPlaying)
            {
                FR2_SceneCache.Api.refreshCache(this);
            }

            EditorApplication.delayCall -= Repaint;
            EditorApplication.delayCall += Repaint;
        }
Esempio n. 28
0
        private void OnUpdate()
        {
            for (var i = 0; i < 5 * FR2_Cache.Api.priority; i++)
            {
                if (listGO == null || listGO.Count <= 0)
                {
                    //done
                    // Debug.Log("done");
                    EditorApplication.update -= OnUpdate;
                    ready  = true;
                    Dirty  = false;
                    listGO = null;
                    if (onReady != null)
                    {
                        onReady();
                    }

                    if (window != null)
                    {
                        window.OnSelectionChange();
                    }

                    return;
                }

                int index = listGO.Count - 1;

                GameObject go = listGO[index];
                if (go == null)
                {
                    continue;
                }

                string prefabGUID = FR2_Unity.GetPrefabParent(go);
                if (!string.IsNullOrEmpty(prefabGUID))
                {
                    Transform parent = go.transform.parent;
                    while (parent != null)
                    {
                        GameObject g = parent.gameObject;
                        if (!prefabDependencies.ContainsKey(g))
                        {
                            prefabDependencies.Add(g, new HashSet <string>());
                        }

                        prefabDependencies[g].Add(prefabGUID);
                        parent = parent.parent;
                    }
                }

                Component[] components = go.GetComponents <Component>();

                foreach (Component com in components)
                {
                    if (com == null)
                    {
                        continue;
                    }

                    var serialized        = new SerializedObject(com);
                    SerializedProperty it = serialized.GetIterator().Copy();
                    while (it.NextVisible(true))
                    {
                        if (it.propertyType != SerializedPropertyType.ObjectReference)
                        {
                            continue;
                        }

                        if (it.objectReferenceValue == null)
                        {
                            continue;
                        }

                        var    isSceneObject = true;
                        string path          = AssetDatabase.GetAssetPath(it.objectReferenceValue);
                        if (!string.IsNullOrEmpty(path))
                        {
                            string dir = Path.GetDirectoryName(path);
                            if (!string.IsNullOrEmpty(dir))
                            {
                                isSceneObject = false;
                                if (!folderCache.ContainsKey(dir))
                                {
                                    folderCache.Add(dir, new HashSet <Component>());
                                }

                                if (!folderCache[dir].Contains(com))
                                {
                                    folderCache[dir].Add(com);
                                }
                            }
                        }

                        if (!_cache.ContainsKey(com))
                        {
                            _cache.Add(com, new HashSet <HashValue>());
                        }

                        _cache[com].Add(new HashValue
                        {
                            target = it.objectReferenceValue, isSceneObject = isSceneObject
                        });

                        // if (!_cache.ContainsKey(com)) _cache.Add(com, new HashSet<SerializedProperty>());
                        // if (!_cache[com].Contains(it))
                        //     _cache[com].Add(it.Copy());
                        // string path = AssetDatabase.GetAssetPath(it.objectReferenceValue);

                        // if (string.IsNullOrEmpty(path)) continue;
                        // string dir = System.IO.Path.GetDirectoryName(path);
                        // if (string.IsNullOrEmpty(dir)) continue;
                        // if (!folderCache.ContainsKey(dir)) folderCache.Add(dir, new HashSet<Component>());
                        // if (!folderCache[dir].Contains(com))
                        //     folderCache[dir].Add(com);
                    }
                }

                listGO.RemoveAt(index);
                current++;
            }
        }
Esempio n. 29
0
        private static void ApplyFilter(Dictionary <string, FR2_Ref> refs, FR2_Asset asset)
        {
            string targetPath = AssetDatabase.GUIDToAssetPath(asset.guid);

            if (string.IsNullOrEmpty(targetPath))
            {
                return;                 // asset not found - might be deleted!
            }

            //asset being moved!
            if (targetPath != asset.assetPath)
            {
                asset.LoadAssetInfo();
            }

            Object target = AssetDatabase.LoadAssetAtPath(targetPath, typeof(Object));

            if (target == null)
            {
                Debug.LogWarning("target is null");
                return;
            }

            bool targetIsGameobject = target is GameObject;

            if (targetIsGameobject)
            {
                foreach (GameObject item in FR2_Unity.getAllObjsInCurScene())
                {
                    if (FR2_Unity.CheckIsPrefab(item))
                    {
                        string itemGUID = FR2_Unity.GetPrefabParent(item);
                        // Debug.Log(item.name + " itemGUID: " + itemGUID);
                        // Debug.Log(target.name + " asset.guid: " + asset.guid);
                        if (itemGUID == asset.guid)
                        {
                            Add(refs, item, 1);
                        }
                    }
                }
            }

            string dir = Path.GetDirectoryName(targetPath);

            if (FR2_SceneCache.Api.folderCache.ContainsKey(dir))
            {
                foreach (Component item in FR2_SceneCache.Api.folderCache[dir])
                {
                    if (FR2_SceneCache.Api.cache.ContainsKey(item))
                    {
                        foreach (FR2_SceneCache.HashValue item1 in FR2_SceneCache.Api.cache[item])
                        {
                            if (targetPath == AssetDatabase.GetAssetPath(item1.target))
                            {
                                Add(refs, item, 1);
                            }
                        }
                    }
                }
            }
        }
Esempio n. 30
0
 //[MenuItem("Assets/FR2/Export Dependencies", false, 40)]
 private static void ExportDependencies()
 {
     Selection.objects = GetSelectionDependencies().ToArray();
     FR2_Unity.ExportSelection();
 }