Пример #1
0
    private void DoSearch()
    {
        var allComps = Resources.FindObjectsOfTypeAll <Component>();

        if (selection is GameObject)
        {
            var selectionComponents = (selection as GameObject).GetComponents <Component>().Cast <Object>().ToList();
            selectionComponents.Add(selection);
            var req = new SelectionSearchRequest
            {
                selectedObject = selection,
                targetObjects  = selectionComponents
            };

            lastResponse = RequestSearch(allComps, req);
        }
        else if (selection is Object)
        {
            var req = new SelectionSearchRequest
            {
                selectedObject = selection,
                targetObjects  = new List <Object>()
                {
                    selection
                }
            };

            lastResponse = RequestSearch(allComps, req);
        }
    }
Пример #2
0
    private static SelectionSearchResponse RequestSearch(Component[] allComps, SelectionSearchRequest req)
    {
        var resp = new SelectionSearchResponse
        {
            request        = req,
            referencePairs = new List <ReferencePair>()
        };

        var goType         = typeof(GameObject);
        var spriteType     = typeof(Sprite);
        var textureType    = typeof(Texture2D);
        var targetObjects  = req.targetObjects;
        var selectedObject = req.selectedObject;

        //All components in scene
        foreach (var sComp in allComps)
        {
            var type   = sComp.GetType();
            var fields = type.GetFields(System.Reflection.BindingFlags.Public | System.Reflection.BindingFlags.NonPublic | System.Reflection.BindingFlags.Instance);

            //All fields in that component
            foreach (var field in fields)
            {
                {
                    var fieldType    = field.FieldType;
                    var isFieldArray = fieldType.IsArray;


                    foreach (var targetObject in targetObjects)
                    {
                        System.Type targetType = targetObject.GetType();
                        if (isFieldArray && IsAssignableFrom(fieldType, targetType))
                        {
                            var array = field.GetValue(sComp) as IList;
                            if (array != null)
                            {
                                var index = 0;
                                foreach (Object fieldValue in array)
                                {
                                    if (AreEqual(fieldValue, targetObject))
                                    {
                                        var pair = new ReferencePair()
                                        {
                                            referenceOwnerObject = sComp,
                                            targetObject         = fieldValue,
                                            referenceFiledName   = field.Name,
                                            referenceArrayIndex  = index
                                        };
                                        resp.referencePairs.Add(pair);
                                    }
                                    index++;
                                }
                            }
                        }

                        if (IsAssignableFrom(fieldType, targetType))
                        {
                            var fieldValue = field.GetValue(sComp) as Object;
                            if (AreEqual(fieldValue, targetObject))
                            {
                                var pair = new ReferencePair()
                                {
                                    referenceOwnerObject = sComp,
                                    targetObject         = fieldValue,
                                    referenceFiledName   = field.Name,
                                };
                                resp.referencePairs.Add(pair);
                            }
                        }
                    }
                }
            }
        }

        string[] searchInFolders = new string[] { "Assets" };
        string   dataPath        = Application.dataPath.Replace("Assets", "");

        foreach (var item in resp.referencePairs)
        {
            if (item.referenceOwnerObject is Component)
            {
                var guids = AssetDatabase.FindAssets("t:Script " + item.referenceOwnerObject.GetType().Name, searchInFolders);
                if (guids.Length > 0)
                {
                    string assetPath = AssetDatabase.GUIDToAssetPath(guids[0]);
                    item.referenceOwnerScriptPath = assetPath;
                    string path = dataPath + assetPath;
                    item.scriptObject = AssetDatabase.LoadAssetAtPath <TextAsset>(assetPath);
                    if (item.scriptObject != null)
                    {
                        using (StreamReader sr = new StreamReader(path))
                        {
                            int linecount = 1;
                            while (!sr.EndOfStream)
                            {
                                var line = sr.ReadLine();
                                if (line.Contains(item.referenceFiledName))
                                {
                                    item.referenceFiledLineNumber = linecount;
                                    break;
                                }
                                linecount++;
                            }
                        }
                    }
                }
            }
        }

        return(resp);
    }