protected override void UpdateOverride()
        {
            base.UpdateOverride();

            if (Editor.Tools.IsViewing)
            {
                SelectedAxis = RuntimeHandleAxis.None;
                return;
            }
            if (!IsWindowActive || !Window.IsPointerOver)
            {
                return;
            }
            if (!IsDragging /*&& !IsPointerDown*/)
            {
                if (HightlightOnHover)
                {
                    m_targetInverseMatrix = Matrix4x4.TRS(Target.position, Target.rotation * StartingRotationInv, Vector3.one).inverse;
                    SelectedAxis          = HitTester.GetSelectedAxis(this);
                }

                if (m_targetRotation != Target.rotation)
                {
                    m_startingRotation   = Target.rotation;
                    m_startinRotationInv = Quaternion.Inverse(m_startingRotation);
                    m_targetRotation     = Target.rotation;
                }
            }
        }
Пример #2
0
        protected override bool OnBeginDrag()
        {
            SelectedAxis      = HitTester.GetSelectedAxis(this);
            m_currentPosition = Position;
            m_cursorPosition  = Position;

            if ((IsInVertexSnappingMode || Editor.Tools.IsSnapping) && SelectedAxis != RuntimeHandleAxis.Snap)
            {
                return(HitSnapHandle());
            }

            if (SelectedAxis == RuntimeHandleAxis.XZ)
            {
                DragPlane = GetDragPlane(m_matrix, Vector3.up);
                return(GetPointOnDragPlane(Window.Pointer, out m_prevPoint));
            }

            if (SelectedAxis == RuntimeHandleAxis.YZ)
            {
                DragPlane = GetDragPlane(m_matrix, Vector3.right);
                return(GetPointOnDragPlane(Window.Pointer, out m_prevPoint));
            }

            if (SelectedAxis == RuntimeHandleAxis.XY)
            {
                DragPlane = GetDragPlane(m_matrix, Vector3.forward);
                return(GetPointOnDragPlane(Window.Pointer, out m_prevPoint));
            }

            if (SelectedAxis != RuntimeHandleAxis.None)
            {
                Vector3 axis = Vector3.zero;
                switch (SelectedAxis)
                {
                case RuntimeHandleAxis.X:
                    axis = Vector3.right;
                    break;

                case RuntimeHandleAxis.Y:
                    axis = Vector3.up;
                    break;

                case RuntimeHandleAxis.Z:
                    axis = Vector3.forward;
                    break;
                }


                DragPlane = GetDragPlane(axis);
                bool result = GetPointOnDragPlane(Window.Pointer, out m_prevPoint);
                if (!result)
                {
                    SelectedAxis = RuntimeHandleAxis.None;
                }
                return(result);
            }

            return(false);
        }
Пример #3
0
        public static void GenerateLightProbes(float gridSize, float height, float probeHeight)
        {
            if (gridSize < Mathf.Epsilon)
            {
                Debug.Log("间矩是个无效数值");
                return;
            }

            if (height < Mathf.Epsilon)
            {
                Debug.Log("碰撞高度是无效数值");
                return;
            }

            Bounds bounds = GetNavMeshBounds();

            if (bounds.extents.magnitude < Mathf.Epsilon)
            {
                Debug.Log("场景没有物件的layer属性设置为Terrain,请先完成相应设置.");
                return;
            }

            HitTester hitTester = new HitTester(bounds, gridSize, height, probeHeight);

            Vector3[] positions = hitTester.CalcProbes(bounds);

            // then set positions to component
            GameObject lightProbeHolder = GameObject.Find("LightProbeHolder");

            if (!lightProbeHolder)
            {
                lightProbeHolder = new GameObject("LightProbeHolder", typeof(LightProbeGroup));
            }

            if (!lightProbeHolder)
            {
                return;
            }
            LightProbeGroup lpg = lightProbeHolder.GetComponent <LightProbeGroup>();

            if (!lpg)
            {
                return;
            }

            lpg.probePositions = positions;
            Debug.Log("Generated " + lpg.probePositions.Length.ToString() + " probe points\n");

            HierarchyUtils.DestroyObjByName("LightProbeBox");

            //Lightmapping.Bake();
        }
Пример #4
0
        protected override bool OnBeginDrag()
        {
            if (!base.OnBeginDrag())
            {
                return(false);
            }

            SelectedAxis = HitTester.GetSelectedAxis(this);

            if (SelectedAxis == RuntimeHandleAxis.Free)
            {
                DragPlane = GetDragPlane(Vector3.zero);
            }
            else if (SelectedAxis == RuntimeHandleAxis.None)
            {
                return(false);
            }

            m_refScales = new Vector3[ActiveTargets.Length];
            for (int i = 0; i < m_refScales.Length; ++i)
            {
                Quaternion rotation = Editor.Tools.PivotRotation == RuntimePivotRotation.Global ? ActiveTargets[i].rotation : Quaternion.identity;
                m_refScales[i] = rotation * ActiveTargets[i].localScale;
            }

            Vector3 axis = Vector3.zero;

            switch (SelectedAxis)
            {
            case RuntimeHandleAxis.X:
                axis = Vector3.right;
                break;

            case RuntimeHandleAxis.Y:
                axis = Vector3.up;
                break;

            case RuntimeHandleAxis.Z:
                axis = Vector3.forward;
                break;
            }

            DragPlane = GetDragPlane(axis);
            bool result = GetPointOnDragPlane(Window.Pointer, out m_prevPoint);

            if (!result)
            {
                SelectedAxis = RuntimeHandleAxis.None;
            }
            return(result);
        }
Пример #5
0
 protected override void UpdateOverride()
 {
     base.UpdateOverride();
     if (Editor.Tools.IsViewing)
     {
         SelectedAxis = RuntimeHandleAxis.None;
         return;
     }
     if (!IsWindowActive || !Window.IsPointerOver)
     {
         return;
     }
     if (HightlightOnHover && !IsDragging && !IsPointerDown)
     {
         SelectedAxis = HitTester.GetSelectedAxis(this);
     }
 }
Пример #6
0
        protected override void UpdateOverride()
        {
            base.UpdateOverride();
            if (Editor.Tools.IsViewing)
            {
                SelectedAxis = RuntimeHandleAxis.None;
                return;
            }

            if (!IsWindowActive || !Window.IsPointerOver)
            {
                return;
            }
            IRTE editor = Editor;

            if (IsDragging)
            {
                if (SnapToGround && SelectedAxis != RuntimeHandleAxis.Y)
                {
                    SnapActiveTargetsToGround(ActiveTargets, Window.Camera, true);
                    transform.position = Targets[0].position;
                }
            }

            if (HightlightOnHover && !IsDragging /*&& !IsPointerDown*/)
            {
                SelectedAxis = HitTester.GetSelectedAxis(this);
            }

            if (IsInVertexSnappingMode || Editor.Tools.IsSnapping)
            {
                Vector2 mousePosition;
                if (Window.Pointer.XY(Position, out mousePosition))
                {
                    if (editor.Tools.SnappingMode == SnappingMode.BoundingBox)
                    {
                        if (IsDragging)
                        {
                            SelectedAxis = RuntimeHandleAxis.Snap;
                            if (m_prevMousePosition != mousePosition)
                            {
                                m_prevMousePosition = mousePosition;
                                float   minDistance   = float.MaxValue;
                                Vector3 minPoint      = Vector3.zero;
                                bool    minPointFound = false;
                                for (int i = 0; i < m_allExposedToEditor.Length; ++i)
                                {
                                    ExposeToEditor exposeToEditor = m_allExposedToEditor[i];
                                    Bounds         bounds         = exposeToEditor.Bounds;
                                    m_boundingBoxCorners[0] = bounds.center + new Vector3(bounds.extents.x, bounds.extents.y, bounds.extents.z);
                                    m_boundingBoxCorners[1] = bounds.center + new Vector3(bounds.extents.x, bounds.extents.y, -bounds.extents.z);
                                    m_boundingBoxCorners[2] = bounds.center + new Vector3(bounds.extents.x, -bounds.extents.y, bounds.extents.z);
                                    m_boundingBoxCorners[3] = bounds.center + new Vector3(bounds.extents.x, -bounds.extents.y, -bounds.extents.z);
                                    m_boundingBoxCorners[4] = bounds.center + new Vector3(-bounds.extents.x, bounds.extents.y, bounds.extents.z);
                                    m_boundingBoxCorners[5] = bounds.center + new Vector3(-bounds.extents.x, bounds.extents.y, -bounds.extents.z);
                                    m_boundingBoxCorners[6] = bounds.center + new Vector3(-bounds.extents.x, -bounds.extents.y, bounds.extents.z);
                                    m_boundingBoxCorners[7] = bounds.center + new Vector3(-bounds.extents.x, -bounds.extents.y, -bounds.extents.z);
                                    GetMinPoint(ref minDistance, ref minPoint, ref minPointFound, exposeToEditor.BoundsObject.transform);
                                }

                                if (minPointFound)
                                {
                                    Position = minPoint;
                                }
                            }
                        }
                        else
                        {
                            SelectedAxis = RuntimeHandleAxis.None;
                            if (m_prevMousePosition != mousePosition)
                            {
                                m_prevMousePosition = mousePosition;

                                float   minDistance   = float.MaxValue;
                                Vector3 minPoint      = Vector3.zero;
                                bool    minPointFound = false;
                                for (int i = 0; i < m_snapTargets.Length; ++i)
                                {
                                    Transform snapTarget = m_snapTargets[i];
                                    Bounds    bounds     = m_snapTargetsBounds[i];

                                    m_boundingBoxCorners[0] = bounds.center + new Vector3(bounds.extents.x, bounds.extents.y, bounds.extents.z);
                                    m_boundingBoxCorners[1] = bounds.center + new Vector3(bounds.extents.x, bounds.extents.y, -bounds.extents.z);
                                    m_boundingBoxCorners[2] = bounds.center + new Vector3(bounds.extents.x, -bounds.extents.y, bounds.extents.z);
                                    m_boundingBoxCorners[3] = bounds.center + new Vector3(bounds.extents.x, -bounds.extents.y, -bounds.extents.z);
                                    m_boundingBoxCorners[4] = bounds.center + new Vector3(-bounds.extents.x, bounds.extents.y, bounds.extents.z);
                                    m_boundingBoxCorners[5] = bounds.center + new Vector3(-bounds.extents.x, bounds.extents.y, -bounds.extents.z);
                                    m_boundingBoxCorners[6] = bounds.center + new Vector3(-bounds.extents.x, -bounds.extents.y, bounds.extents.z);
                                    m_boundingBoxCorners[7] = bounds.center + new Vector3(-bounds.extents.x, -bounds.extents.y, -bounds.extents.z);
                                    if (Targets[i] != null)
                                    {
                                        GetMinPoint(ref minDistance, ref minPoint, ref minPointFound, snapTarget);
                                    }
                                }

                                if (minPointFound)
                                {
                                    m_handleOffset = minPoint - transform.position;
                                }
                            }
                        }
                    }
                    else
                    {
                        if (IsDragging)
                        {
                            SelectedAxis = RuntimeHandleAxis.Snap;
                            if (m_prevMousePosition != mousePosition)
                            {
                                m_prevMousePosition = mousePosition;

                                Ray        ray = Window.Pointer;
                                RaycastHit hitInfo;

                                LayerMask layerMask = (1 << Physics.IgnoreRaycastLayer);
                                layerMask  = ~layerMask;
                                layerMask &= Editor.CameraLayerSettings.RaycastMask;

                                for (int i = 0; i < m_snapTargets.Length; ++i)
                                {
                                    m_targetLayers[i] = m_snapTargets[i].gameObject.layer;
                                    m_snapTargets[i].gameObject.layer = Physics.IgnoreRaycastLayer;
                                }

                                GameObject closestObject = null;
                                if (Physics.Raycast(ray, out hitInfo, float.PositiveInfinity, layerMask))
                                {
                                    closestObject = hitInfo.collider.gameObject;
                                }
                                else
                                {
                                    float minDistance = float.MaxValue;
                                    for (int i = 0; i < m_allExposedToEditor.Length; ++i)
                                    {
                                        ExposeToEditor exposedToEditor = m_allExposedToEditor[i];
                                        Bounds         bounds          = exposedToEditor.Bounds;

                                        m_boundingBoxCorners[0] = bounds.center + new Vector3(bounds.extents.x, bounds.extents.y, bounds.extents.z);
                                        m_boundingBoxCorners[1] = bounds.center + new Vector3(bounds.extents.x, bounds.extents.y, -bounds.extents.z);
                                        m_boundingBoxCorners[2] = bounds.center + new Vector3(bounds.extents.x, -bounds.extents.y, bounds.extents.z);
                                        m_boundingBoxCorners[3] = bounds.center + new Vector3(bounds.extents.x, -bounds.extents.y, -bounds.extents.z);
                                        m_boundingBoxCorners[4] = bounds.center + new Vector3(-bounds.extents.x, bounds.extents.y, bounds.extents.z);
                                        m_boundingBoxCorners[5] = bounds.center + new Vector3(-bounds.extents.x, bounds.extents.y, -bounds.extents.z);
                                        m_boundingBoxCorners[6] = bounds.center + new Vector3(-bounds.extents.x, -bounds.extents.y, bounds.extents.z);
                                        m_boundingBoxCorners[7] = bounds.center + new Vector3(-bounds.extents.x, -bounds.extents.y, -bounds.extents.z);

                                        for (int j = 0; j < m_boundingBoxCorners.Length; ++j)
                                        {
                                            Vector2 screenPoint;
                                            if (Window.Pointer.WorldToScreenPoint(Position, exposedToEditor.BoundsObject.transform.TransformPoint(m_boundingBoxCorners[j]), out screenPoint))
                                            {
                                                float distance = (screenPoint - mousePosition).magnitude;
                                                if (distance < minDistance)
                                                {
                                                    closestObject = exposedToEditor.gameObject;
                                                    minDistance   = distance;
                                                }
                                            }
                                        }
                                    }
                                }

                                if (closestObject != null)
                                {
                                    float     minDistance   = float.MaxValue;
                                    Vector3   minPoint      = Vector3.zero;
                                    bool      minPointFound = false;
                                    Transform meshTransform;
                                    Mesh      mesh = GetMesh(closestObject, out meshTransform);
                                    GetMinPoint(meshTransform, ref minDistance, ref minPoint, ref minPointFound, mesh);

                                    if (minPointFound)
                                    {
                                        Position = minPoint;
                                    }
                                }

                                for (int i = 0; i < m_snapTargets.Length; ++i)
                                {
                                    m_snapTargets[i].gameObject.layer = m_targetLayers[i];
                                }
                            }
                        }
                        else
                        {
                            SelectedAxis = RuntimeHandleAxis.None;
                            if (m_prevMousePosition != mousePosition)
                            {
                                m_prevMousePosition = mousePosition;

                                float   minDistance   = float.MaxValue;
                                Vector3 minPoint      = Vector3.zero;
                                bool    minPointFound = false;
                                for (int i = 0; i < RealTargets.Length; ++i)
                                {
                                    Transform snapTarget = RealTargets[i];
                                    Transform meshTranform;
                                    Mesh      mesh = GetMesh(snapTarget.gameObject, out meshTranform);
                                    GetMinPoint(meshTranform, ref minDistance, ref minPoint, ref minPointFound, mesh);
                                }
                                if (minPointFound)
                                {
                                    m_handleOffset = minPoint - transform.position;
                                }
                            }
                        }
                    }
                }
            }
        }
Пример #7
0
 public void SetTarget(HitTester target)
 {
     this.target = target;
     Debug.Log(target);
 }
        protected override bool OnBeginDrag()
        {
            if (!base.OnBeginDrag())
            {
                return(false);
            }

            m_targetRotation      = Target.rotation;
            m_targetInverseMatrix = Matrix4x4.TRS(Target.position, Target.rotation * StartingRotationInv, Vector3.one).inverse;
            SelectedAxis          = HitTester.GetSelectedAxis(this);
            m_deltaX = 0.0f;
            m_deltaY = 0.0f;

            Vector2 point;

            if (Window.Pointer.XY(Target.position, out point))
            {
                m_prevPointer = point;
            }
            else
            {
                SelectedAxis = RuntimeHandleAxis.None;
            }

            m_forceScreenRotationMode = ForceScreenRotationMode();
            if (SelectedAxis == RuntimeHandleAxis.Screen || m_forceScreenRotationMode)
            {
                Vector2 center;

                if (Window.Pointer.WorldToScreenPoint(Target.position, Target.position, out center))
                {
                    if (Window.Pointer.XY(Target.position, out point))
                    {
                        float angle = Mathf.Atan2(point.y - center.y, point.x - center.x);
                        m_targetInverse       = Quaternion.Inverse(Quaternion.AngleAxis(Mathf.Rad2Deg * angle, Vector3.forward));
                        m_targetInverseMatrix = Matrix4x4.TRS(Target.position, Target.rotation, Vector3.one).inverse;
                        m_prevPointer         = point;
                    }
                    else
                    {
                        SelectedAxis = RuntimeHandleAxis.None;
                    }
                }
                else
                {
                    SelectedAxis = RuntimeHandleAxis.None;
                }
            }
            else
            {
                if (SelectedAxis == RuntimeHandleAxis.X)
                {
                    m_startingRotationAxis = (Target.rotation * Quaternion.Inverse(StartingRotation)) * Vector3.right;
                }
                else if (SelectedAxis == RuntimeHandleAxis.Y)
                {
                    m_startingRotationAxis = (Target.rotation * Quaternion.Inverse(StartingRotation)) * Vector3.up;
                }
                else if (SelectedAxis == RuntimeHandleAxis.Z)
                {
                    m_startingRotationAxis = (Target.rotation * Quaternion.Inverse(StartingRotation)) * Vector3.forward;
                }

                m_targetInverse = Quaternion.Inverse(Target.rotation);
            }

            return(SelectedAxis != RuntimeHandleAxis.None);
        }