private void OnMouseUp(object sender, MouseButtonsEventArgs evArgs)
    {
        if (!_traceMouse)
        {
            return;
        }

        if (evArgs != null)
        {
            if (evArgs.Button == KeyCode.Mouse0)
            {
                switch (EditorMode)
                {
                case EditorModes.Add:
                {
                    GameObject lastCube;
                    _grid.CreateCubeAt(_markerPosition, out lastCube);
                    break;
                }

                case EditorModes.Delete:
                {
                    _grid.DeleteCubeAt(_markerPosition);
                    break;
                }

                case EditorModes.Move:
                case EditorModes.Connect:
                {
                    _selectedObject = _grid.GetCubeAt(_markerPosition);
                    if (_selectedObject)
                    {
                        EditorMode = EditorModes.Target;
                    }
                    break;
                }

                case EditorModes.Target:
                {
                    ProcessTargetClick();
                    break;
                }
                }
            }
            else if (evArgs.Button == KeyCode.Mouse1)
            {
                switch (EditorMode)
                {
                case EditorModes.Target:
                {
                    EditorMode = PreviousEditorMode;
                    break;
                }
                }
            }
        }
    }
示例#2
0
 private void DeleteHidenObjects()
 {
     CubeTagBehavior[] GameObjects = GameObject.FindObjectsOfType <CubeTagBehavior>();
     foreach (CubeTagBehavior go in GameObjects)
     {
         m_Instance.DeleteCubeAt(go.transform.position);
         if (go != null)
         {
             DestroyImmediate(go.gameObject);
         }
         ;
     }
 }
示例#3
0
    void OnSceneGUI(SceneView _view)
    {
        // нет выделенного объекта - нет инспектора.
        if (!target)
        {
            return;
        }

        // Получаем указатель на выделенныйобъект.
        m_Instance = ((CubeGrid)target);

        if (!m_Instance)
        {
            return;
        }
        if (m_Instance.m_CubeLibrary == null)
        {
            return;
        }
        ;

        m_Library = m_Instance.m_CubeLibrary;

        if (!m_Instance.currentPrefab)
        {
            //Попытаемся получить первый куб из библиотеки, если он не выбран.
            m_Instance.currentPrefab = m_Library.GetGameObjectByIndex(0);
            if (!m_Instance.currentPrefab)
            {
                // Получить не удалось, в библиотеке нет элементов.
                return;
            }
        }
        ;

        if (processGUIMenus(_view))
        {
            return;
        }

        float blockSize = m_Instance.gridSize;
        //float halfBlockSize = blockSize / 2.0f;

        Quaternion noRotation = Quaternion.Euler(0, 0, 0);

        if (Event.current.type == EventType.layout)
        {
            if (!m_marker)
            {
                // Создаем маркер
                GameObject blockInst = AssetDatabase.LoadAssetAtPath <GameObject>("Assets/Tiles/pre_Cursor.prefab");

                blockInst.transform.localScale = new Vector3(blockSize, blockSize, blockSize);

                m_marker           = Instantiate(blockInst, intersectionPoint, noRotation) as GameObject;
                m_marker.name      = "MARKER";
                m_marker.hideFlags = HideFlags.HideAndDontSave | HideFlags.NotEditable | HideFlags.HideInInspector | HideFlags.HideInHierarchy;
                DestroyImmediate(m_marker.GetComponent <BoxCollider>());
                meshRenderer     = m_marker.GetComponent <MeshRenderer>();
                m_markerMaterial = new Material(meshRenderer.sharedMaterial);

                m_markerMaterial.color      = Color.Lerp(Color.green, meshRenderer.sharedMaterial.color, 0.85f);
                meshRenderer.sharedMaterial = m_markerMaterial;
            }

            // Запрещаем выделение других объектов.
            HandleUtility.AddDefaultControl(GUIUtility.GetControlID(GetHashCode(), FocusType.Passive));
        }

        // Обрабатываем события редактора.
        switch (Event.current.type)
        {
            #region MouseMove
        case EventType.mouseMove:
        {
            m_currentObject = null;

            switch (m_editMode)
            {
            case EditMode.addBlock:
            case EditMode.delBlock: {
                RaycastHit hitInfo = new RaycastHit();

                Ray ray = HandleUtility.GUIPointToWorldRay(Event.current.mousePosition);

                if (Physics.Raycast(ray, out hitInfo))
                {
                    if (m_editMode == EditMode.addBlock)
                    {
                        Vector3 pointOnCollider = hitInfo.transform.position + hitInfo.normal * blockSize;
                        intersectionPoint = pointOnCollider;
                    }
                    else
                    {
                        m_currentObject   = hitInfo.transform.gameObject;
                        intersectionPoint = hitInfo.transform.position;
                    }

                    intersectionPoint.x = intersectionPoint.x - intersectionPoint.x % blockSize;
                    intersectionPoint.y = intersectionPoint.y - intersectionPoint.y % blockSize;
                    intersectionPoint.z = intersectionPoint.z - intersectionPoint.z % blockSize;
                }
                else
                {
                    Plane hPlane   = new Plane(Vector3.up, Vector3.zero);
                    float distance = 0;

                    if (hPlane.Raycast(ray, out distance))
                    {
                        // make this local
                        pointOnXY = ray.GetPoint(distance);

                        intersectionPoint = new Vector3(pointOnXY.x, pointOnXY.y, pointOnXY.z);

                        intersectionPoint.x = intersectionPoint.x - intersectionPoint.x % blockSize;
                        intersectionPoint.y = intersectionPoint.y - intersectionPoint.y % blockSize;
                        intersectionPoint.z = intersectionPoint.z - intersectionPoint.z % blockSize;

                        if (Physics.Raycast(pointOnXY, intersectionPoint, out hitInfo, Vector3.Distance(pointOnXY, intersectionPoint)))
                        {
                            intersectionPoint = hitInfo.point;

                            intersectionPoint.x = intersectionPoint.x - intersectionPoint.x % blockSize;
                            intersectionPoint.y = intersectionPoint.y - intersectionPoint.y % blockSize;
                            intersectionPoint.z = intersectionPoint.z - intersectionPoint.z % blockSize;
                        }
                    }
                }

                Event.current.Use();
                break;
            }
            }
            break;
        }
            #endregion

            #region MouseUp
        case EventType.mouseUp: {
            if (Event.current.button == 0)
            {
                if (!(m_editMode == EditMode.addBlock ||
                      m_editMode == EditMode.delBlock))
                {
                    break;
                }

                switch (m_editMode)
                {
                case EditMode.addBlock: {
                    GameObject CreatedCube;
                    m_Instance.CreateCubeAt(intersectionPoint, out CreatedCube);

                    Event.current.Use(); break;
                }

                case EditMode.delBlock: {
                    if (m_currentObject)
                    {
                        m_Instance.DeleteCubeAt(m_currentObject.transform.position);
                    }

                    Event.current.Use(); break;
                }
                }
            }

            break;
        }
            #endregion

            #region KeyUp
        case EventType.keyUp:
        {
            switch (Event.current.keyCode)
            {
            case KeyCode.Escape: {
                DeselectThisGrid();

                Event.current.Use();
                break;
            }

            case KeyCode.Space: {
                SwitchState();

                Event.current.Use();
                break;
            }

            default: break;
            }


            break;
        }

        default: break;
        }
        #endregion
        DrawBlockMarker(blockSize, noRotation);
    }