void OnEnable()
    {
        SceneObjectUtility.UpdateGlovalReferenceList();

        SceneView.onSceneGUIDelegate -= OnSceneGUI;
        SceneView.onSceneGUIDelegate += OnSceneGUI;
    }
    void OnSelectionChange()
    {
        referenceObjectList.Clear();
        SceneObjectUtility.Init();

        SceneObjectUtility.GetReferenceObject(Selection.activeGameObject, referenceObjectList);
    }
Beispiel #3
0
    void HideNoCommunication()
    {
        isHiding = true;


        UpdateAllObject();
        UpdateList();
        foreach (var obj in allObject)
        {
            obj.hideFlags = HideFlags.HideInHierarchy;
        }

        foreach (var item in refObjectList)
        {
            ParentShow(item.rootComponent.transform);
            if (item.value == null)
            {
                continue;
            }

            var obj = SceneObjectUtility.GetGameObject(item.value);

            if (obj != null)
            {
                ParentShow(obj.transform);
            }
        }
    }
    void Find()
    {
        var allObjects = SceneObjectUtility.GetAllObjectsInScene(false);

        layerWithObjectList.Clear();

        int defaultLayer = LayerMask.NameToLayer("Default");

        foreach (var obj in allObjects)
        {
            if (obj.layer == defaultLayer)
            {
                continue;
            }

            var layerWithObj = layerWithObjectList.Find((item) => item.layer == obj.layer);

            if (layerWithObj == null)
            {
                layerWithObj = new LayerWithObject()
                {
                    layer = obj.layer
                };
                layerWithObjectList.Add(layerWithObj);
            }

            layerWithObj.objectList.Add(obj);
        }
    }
    void Find()
    {
        var allObjects = SceneObjectUtility.GetAllObjectsInScene(false);

        tagWithObjectList.Clear();

        foreach (var obj in allObjects)
        {
            if (obj.CompareTag("Untagged"))
            {
                continue;
            }

            var tagWithObj = tagWithObjectList.Find((item) => item.tag == obj.tag);

            if (tagWithObj == null)
            {
                tagWithObj = new TagWithObjects()
                {
                    tag = obj.tag
                };
                tagWithObjectList.Add(tagWithObj);
            }

            tagWithObj.objectList.Add(obj);
        }
    }
    void OnSceneGUI(SceneView sceneView)
    {
        var selection = Selection.activeGameObject as GameObject;

        if (selection == null)
        {
            return;
        }


        var cameraTransform = SceneView.currentDrawingSceneView.camera.transform;
        var rotate          = cameraTransform.rotation;
        var cameraPos       = cameraTransform.position;

        Color shadowCol = new Color(0.5f, 0, 0, 0.06f);

        foreach (var target in referenceObjectList)
        {
            var obj = SceneObjectUtility.GetGameObject(target.value);
            if (obj == null)
            {
                continue;
            }
            if (obj == Selection.activeGameObject)
            {
                continue;
            }


            var startPosition = selection.transform.position;
            var endPosition   = obj.transform.position;

            var size = Vector3.Distance(endPosition, cameraPos) * 0.02f;

            if (startPosition == endPosition)
            {
                continue;
            }

            Handles.color = Color.red;

            var diffPos = startPosition - endPosition;
            var tan     = new Vector3(diffPos.y, diffPos.x, diffPos.z);


            var startTan = startPosition;
            var endTan   = endPosition + tan * 0.4f;

            Handles.CircleCap(1, endPosition, rotate, size);

            for (int i = 0; i < 3; i++)
            {
                Handles.DrawBezier(startPosition, endPosition, startTan, endTan, shadowCol, null, (i + 1) * 5);
            }
            Handles.DrawBezier(startPosition, endPosition, startTan, endTan, Color.red, null, 1);

            Handles.Label(endPosition, obj.name);
        }
    }
    void OnSelectionChange()
    {
        referenceObjectList.Clear();
        SceneObjectUtility.UpdateGlovalReferenceList();
        SceneObjectUtility.FindReferenceObject(Selection.activeGameObject, referenceObjectList);

        referenceObjectList.Sort((x, y) => GetObjectID(x.rootComponent) - GetObjectID(y.rootComponent));
    }
Beispiel #8
0
    void UpdateList()
    {
        refObjectList.Clear();

        foreach (var obj in allObject)
        {
            SceneObjectUtility.GetReferenceObject(obj, refObjectList);
        }
        refObjectList.Sort((x, y) => {
            return(x.rootComponent.GetInstanceID() - y.rootComponent.GetInstanceID());
        });
    }
 void OnHierarchyChange()
 {
     SceneObjectUtility.UpdateGlovalReferenceList();
 }
Beispiel #10
0
    /*
     * void OnSelectionChange ()
     * // void Update()
     * {
     *
     *      if (EditorApplication.isPaused || !EditorApplication.isPlaying) {
     *              UpdateAllObject ();
     *              UpdateList ();
     *      }
     * }
     */

    void UpdateAllObject()
    {
        allObject = SceneObjectUtility.GetAllObjectsInScene(false);
    }