SnapEnabled() public static méthode

If ProGrids is open and snap enabled, return true. False otherwise.
public static SnapEnabled ( ) : bool
Résultat bool
Exemple #1
0
        void SetupInputPlane(Vector2 mousePosition)
        {
            m_Plane = EditorHandleUtility.FindBestPlane(mousePosition);

            if (ProGridsInterface.SnapEnabled())
            {
                m_Plane.SetNormalAndPosition(
                    m_Plane.normal,
                    ProGridsInterface.ProGridsSnap(m_Plane.normal * -m_Plane.distance));
            }

            var planeNormal = m_Plane.normal;
            var planeCenter = m_Plane.normal * -m_Plane.distance;

            // if hit point on plane is cardinal axis and on grid, snap to grid.
            if (Math.IsCardinalAxis(planeNormal))
            {
                const float epsilon = .00001f;
                float       snapVal = Mathf.Abs(ProGridsInterface.SnapValue());
                float       rem     = Mathf.Abs(snapVal - (Vector3.Scale(planeNormal, planeCenter).magnitude % snapVal));
                polygon.isOnGrid = (rem < epsilon || Mathf.Abs(snapVal - rem) < epsilon);
            }
            else
            {
                polygon.isOnGrid = false;
            }
        }
        /// <summary>
        /// Snap a Vector3 to the nearest point on the current ProGrids grid if ProGrids is enabled, with mask.
        /// </summary>
        /// <param name="point"></param>
        /// <param name="mask"></param>
        /// <returns></returns>
        public static Vector3 ProGridsSnap(Vector3 point, Vector3 mask)
        {
            if (GetProGridsType() == null)
                return point;

            if (ProGridsInterface.SnapEnabled())
            {
                float snap = ProGridsInterface.SnapValue();
                return Snapping.SnapValue(point, mask * snap);
            }

            return point;
        }
        public static Vector3 ProGridsSnap(Vector3 point, Vector3 mask)
        {
            if (GetProGridsType() == null)
            {
                return(point);
            }

            if (ProGridsInterface.SnapEnabled())
            {
                float snap = ProGridsInterface.SnapValue();
                return(ProBuilderSnapping.Snap(point, mask * snap));
            }

            return(point);
        }
        internal static void SetPivotLocationAndSnap(ProBuilderMesh mesh)
        {
            if (ProGridsInterface.SnapEnabled())
            {
                mesh.transform.position = Snapping.SnapValue(mesh.transform.position, ProGridsInterface.SnapValue());
            }
            else if (s_SnapNewShapesToGrid)
            {
                mesh.transform.position = Snapping.SnapValue(mesh.transform.position, new Vector3(
                                                                 EditorPrefs.GetFloat("MoveSnapX"),
                                                                 EditorPrefs.GetFloat("MoveSnapY"),
                                                                 EditorPrefs.GetFloat("MoveSnapZ")));
            }

            mesh.Optimize();
        }
        protected void BeginEdit(string undoMessage)
        {
            if (m_IsEditing)
            {
                return;
            }

            // Disable iterative lightmapping
            Lightmapping.PushGIWorkflowMode();

            var selection = MeshSelection.topInternal.ToArray();

            UndoUtility.RegisterCompleteObjectUndo(selection, string.IsNullOrEmpty(undoMessage) ? "Modify Vertices" : undoMessage);

            if (beforeMeshModification != null)
            {
                beforeMeshModification(selection);
            }

            if (currentEvent.shift)
            {
                Extrude();
            }

            m_IsEditing = true;

            m_ProgridsSnapEnabled = ProGridsInterface.SnapEnabled();
            m_ProgridsSnapValue   = ProGridsInterface.SnapValue();
            m_SnapAxisConstraint  = ProGridsInterface.UseAxisConstraints();

            foreach (var mesh in selection)
            {
                mesh.ToMesh();
                mesh.Refresh();
            }

            OnToolEngaged();
        }