/// <summary> /// Called from ProGrids. /// </summary> /// <param name="snapVal"></param> void PushToGrid(float snapVal) { UndoUtility.RecordSelection(selection.ToArray(), "Push elements to Grid"); if (selectMode == SelectMode.Object || selectMode == SelectMode.None) { return; } for (int i = 0, c = MeshSelection.selectedObjectCount; i < c; i++) { ProBuilderMesh mesh = selection[i]; if (mesh.selectedVertexCount < 1) { continue; } var indexes = mesh.GetCoincidentVertices(mesh.selectedIndexesInternal); Snapping.SnapVertices(mesh, indexes, Vector3.one * snapVal); mesh.ToMesh(); mesh.Refresh(); mesh.Optimize(); } UpdateSelection(); }
protected async void SetSnapping() { var myMap = MapView.Active.Map; //using ArcGIS.Desktop.Mapping //enable snapping Snapping.IsEnabled = true; //enable a snap mode, others are not changed. Snapping.SetSnapMode(SnapMode.Point, true); //set multiple snap modes exclusively. All others will be disabled. Snapping.SetSnapModes(SnapMode.Edge, SnapMode.Point); await QueuedTask.Run(() => { //set snapping options via get/set options var snapOptions = Snapping.GetOptions(myMap); snapOptions.SnapToSketchEnabled = true; snapOptions.XYTolerance = 100; Snapping.SetOptions(myMap, snapOptions); }); var myFeatureLayer = MapView.Active.GetSelectedLayers().First() as FeatureLayer; //read snapping availability for a layer var canSnap = myFeatureLayer.IsSnappable; //set snapping availability for a layer var featLayerDef = myFeatureLayer.GetDefinition() as ArcGIS.Core.CIM.CIMGeoFeatureLayerBase; featLayerDef.Snappable = true; myFeatureLayer.SetDefinition(featLayerDef); }
protected virtual void update_value(double newValue, bool bSendEvent) { double prev = current_value; current_value = newValue; snapped_value = current_value; if (TickSnapMode != TickSnapModes.NoSnapping && TickCount > 0) { if (TickSnapMode == TickSnapModes.AlwaysSnapToNearest) { double fTickSpan = 1.0 / (TickCount - 1); double fSnapped = Snapping.SnapToIncrement(snapped_value, fTickSpan); fSnapped = MathUtil.Clamp(fSnapped, 0, 1); snapped_value = fSnapped; } else { double fTickSpan = 1.0 / (TickCount - 1); double fSnapped = Snapping.SnapToIncrement(snapped_value, fTickSpan); if (Math.Abs(fSnapped - snapped_value) < TickSnapThreshold) { snapped_value = fSnapped; } } } update_handle_position(); if (bSendEvent) { FUtil.SafeSendEvent(OnValueChanged, this, prev, snapped_value); } }
public void ResetToggles() { Snapping.Reset(); FineSnapping.Reset(); FineRotation.Reset(); ToggleRotation.Reset(); }
internal static async Task ConfigureSnappingAsync() { //General Snapping Snapping.IsEnabled = true; Snapping.SetSnapMode(SnapMode.Edge, true); Snapping.SetSnapMode(SnapMode.End, true); Snapping.SetSnapMode(SnapMode.Intersection, true); //Snapping on any line Feature Layers var flayers = MapView.Active.Map.GetLayersAsFlattenedList().OfType <FeatureLayer>().Where( l => l.ShapeType == esriGeometryType.esriGeometryPolyline).ToList(); if (flayers.Count() > 0) { //GetDefinition and SetDefinition must be called inside QueuedTask await QueuedTask.Run(() => { foreach (var fl in flayers) { var layerDef = fl.GetDefinition() as CIMGeoFeatureLayerBase; if (!layerDef.Snappable) { layerDef.Snappable = true; fl.SetDefinition(layerDef); } } }); } }
protected virtual void update_value(double newValue, bool bSendEvent) { double prev = current_value; current_value = newValue; snapped_value = current_value; if (EnableSnapToTicks && TickCount > 0) { double fTickSpan = 1.0 / (TickCount - 1); double fSnapped = Snapping.SnapToIncrement(snapped_value, fTickSpan); fSnapped = MathUtil.Clamp(fSnapped, 0, 1); // [RMS] only snap when close enough to tick? //double fSnapT = fTickSpan * 0.25; //if (Math.Abs(fSnapped - snapped_value) < fSnapT) snapped_value = fSnapped; } update_handle_position(); if (bSendEvent) { FUtil.SafeSendEvent(OnValueChanged, this, prev, snapped_value); } }
// This is called for each window that your tool is active in. Put the functionality of your tool here. public override void OnToolGUI(EditorWindow window) { EditorGUI.BeginChangeCheck(); Vector3 position = Tools.handlePosition; using (new Handles.DrawingScope()) { float handleSize = HandleUtility.GetHandleSize(position); Handles.color = Handles.xAxisColor; position = Handles.Slider(position, Vector3.right); Handles.color = Handles.zAxisColor; position = Handles.Slider(position, Vector3.forward); Handles.color = Handles.yAxisColor; position = Handles.Slider2D(position + new Vector3(1, 0, 1) * handleSize * slide2DSize, Vector3.up, Vector3.right, Vector3.forward, handleSize * slide2DSize, Handles.RectangleHandleCap, 0); } if (EditorGUI.EndChangeCheck()) { Vector3 delta = Snapping.Snap(position - Tools.handlePosition, EditorSnapSettings.move); Undo.RecordObjects(Selection.transforms, "Move Platform"); foreach (var transform in Selection.transforms) { transform.position += delta; } } }
/// <summary> /// Sets playback position to the time of first snap point holding the specified data. /// </summary> /// <param name="data">Data of a snap point to move to.</param> /// <returns><c>true</c> if playback position successfully changed to the time of first snap point /// with the specified data; otherwise, <c>false</c>.</returns> /// <exception cref="ObjectDisposedException">The current <see cref="Playback"/> is disposed.</exception> /// <exception cref="MidiDeviceException">An error occurred on device.</exception> public bool MoveToFirstSnapPoint <TData>(TData data) { EnsureIsNotDisposed(); var snapPoint = Snapping.GetNextSnapPoint(TimeSpan.Zero, data); return(TryToMoveToSnapPoint(snapPoint)); }
/// <summary> /// Sets playback position to the time of previous snap point (relative to the current /// time of playback). /// </summary> /// <returns><c>true</c> if playback position successfully changed to the time of a previous snap point; /// otherwise, <c>false</c>.</returns> /// <exception cref="ObjectDisposedException">The current <see cref="Playback"/> is disposed.</exception> /// <exception cref="MidiDeviceException">An error occurred on device.</exception> public bool MoveToPreviousSnapPoint() { EnsureIsNotDisposed(); var snapPoint = Snapping.GetPreviousSnapPoint(_clock.CurrentTime); return(TryToMoveToSnapPoint(snapPoint)); }
/// <summary> /// Sets playback position to the time of next snap point (relative to the current /// time of playback) holding the specified data. /// </summary> /// <returns><c>true</c> if playback position successfully changed to the time of a next snap point /// with the specified data; otherwise, <c>false</c>.</returns> /// <exception cref="ObjectDisposedException">The current <see cref="Playback"/> is disposed.</exception> /// <exception cref="MidiDeviceException">An error occurred on device.</exception> public bool MoveToNextSnapPoint <TData>(TData data) { EnsureIsNotDisposed(); var snapPoint = Snapping.GetNextSnapPoint(_clock.CurrentTime, data); return(TryToMoveToSnapPoint(snapPoint)); }
protected override void OnEnable() { base.OnEnable(); var mainTemplate = EditorGUIUtility.Load(k_GridSettingsWindowUxmlPath) as VisualTreeAsset; mainTemplate.CloneTree(rootVisualElement); rootVisualElement.Q <TextElement>("PaneTitle").text = L10n.Tr("Grid Visual"); rootVisualElement.Q <Button>("PaneOption").clicked += PaneOptionMenu; m_GridPlane = rootVisualElement.Q <ButtonStripField>("GridPlane"); foreach (var axis in m_Axes) { m_GridPlane.AddButton(axis.ToString()); } m_GridPlane.label = L10n.Tr("Grid Plane"); m_GridPlane.RegisterValueChangedCallback((evt) => { m_SceneView.sceneViewGrids.gridAxis = m_Axes[evt.newValue]; SceneView.RepaintAll(); }); m_GridOpacity = rootVisualElement.Q <Slider>("Opacity"); m_GridOpacity.label = L10n.Tr("Opacity"); m_GridOpacity.RegisterValueChangedCallback(evt => { m_SceneView.sceneViewGrids.gridOpacity = evt.newValue; SceneView.RepaintAll(); }); var toHandle = rootVisualElement.Q <Button>("ToHandle"); toHandle.text = L10n.Tr("To Handle"); toHandle.clicked += () => { foreach (var view in SceneView.sceneViews) { ((SceneView)view).sceneViewGrids.SetAllGridsPivot(Snapping.Snap(Tools.handlePosition, GridSettings.size)); } SceneView.RepaintAll(); }; var toOrigin = rootVisualElement.Q <Button>("ToOrigin"); toOrigin.text = L10n.Tr("To Origin"); toOrigin.clicked += () => { foreach (var view in SceneView.sceneViews) { ((SceneView)view).sceneViewGrids.ResetPivot(SceneViewGrid.GridRenderAxis.All); } SceneView.RepaintAll(); }; }
public override bool UpdateCapture(ITransformable target, Ray3f worldRay) { // ray-hit with plane perpendicular to rotateAxisW Vector3f planeHitW = raycastFrame.RayPlaneIntersection(worldRay.Origin, worldRay.Direction, 2); // find angle of hitpos in 2D plane perp to rotateAxis, and compute delta-angle Vector3f dv = planeHitW - rotateFrameW.Origin; int iX = (nRotationAxis + 1) % 3; int iY = (nRotationAxis + 2) % 3; float fX = Vector3.Dot(dv, rotateFrameW.GetAxis(iX)); float fY = Vector3.Dot(dv, rotateFrameW.GetAxis(iY)); float fNewAngle = (float)Math.Atan2(fY, fX); if (AbsoluteAngleConstraintF != null) { fNewAngle = AbsoluteAngleConstraintF(rotateFrameL, nRotationAxis, fNewAngle); } float fDeltaAngle = (fNewAngle - fRotateStartAngle); if (DeltaAngleConstraintF != null) { fDeltaAngle = DeltaAngleConstraintF(rotateFrameL, nRotationAxis, fDeltaAngle); } bool on_snap = false; if (EnableSnapping) { double dist = (planeHitW - rotateFrameW.Origin).Length; on_snap = Math.Abs(dist - gizmoRadiusW) < gizmoRadiusW * 0.15f; if (on_snap) { fDeltaAngle = (float)Snapping.SnapToIncrement(fDeltaAngle, SnapIncrementDeg * MathUtil.Deg2Radf); } enable_snap_indicator(true); update_snap_indicator(-fDeltaAngle, on_snap); } // construct new frame for target that is rotated around axis Vector3f rotateAxisL = rotateFrameL.GetAxis(nRotationAxis); Quaternionf q = Quaternion.AngleAxis(fDeltaAngle * Mathf.Rad2Deg, rotateAxisL); Frame3f newFrame = rotateFrameL; newFrame.Rotation = q * newFrame.Rotation; // order matters here! // update target target.SetLocalFrame(newFrame, CoordSpace.ObjectCoords); if (EnableSnapping) { update_circle_indicator(on_snap); } return(true); }
/// <summary> /// Sets playback position to the time of next snap point (relative to the current /// time of playback) that belongs to the specified <see cref="SnapPointsGroup"/>. /// </summary> /// <param name="snapPointsGroup"><see cref="SnapPointsGroup"/> that defines snap points to /// select the one from.</param> /// <returns><c>true</c> if playback position successfully changed to the time of a next snap point /// within <paramref name="snapPointsGroup"/>; otherwise, <c>false</c>.</returns> /// <exception cref="ArgumentNullException"><paramref name="snapPointsGroup"/> is <c>null</c>.</exception> /// <exception cref="ObjectDisposedException">The current <see cref="Playback"/> is disposed.</exception> /// <exception cref="MidiDeviceException">An error occurred on device.</exception> public bool MoveToNextSnapPoint(SnapPointsGroup snapPointsGroup) { ThrowIfArgument.IsNull(nameof(snapPointsGroup), snapPointsGroup); EnsureIsNotDisposed(); var snapPoint = Snapping.GetNextSnapPoint(_clock.CurrentTime, snapPointsGroup); return(TryToMoveToSnapPoint(snapPoint)); }
/// <summary> /// Snap a Vector3 to the nearest point on the current ProGrids grid if ProGrids is enabled. /// </summary> /// <param name="point"></param> /// <returns></returns> public static float ProGridsSnap(float point) { if (GetProGridsType() == null) return point; if (SnapEnabled()) return Snapping.SnapValue(point, ProGridsInterface.SnapValue()); return point; }
/// <summary> /// Sets playback position to the time of the next snap point (relative to the current /// time of playback). /// </summary> /// <exception cref="ObjectDisposedException">The current <see cref="Playback"/> is disposed.</exception> /// <exception cref="MidiDeviceException">An error occurred on device.</exception> public void MoveToNextSnapPoint() { EnsureIsNotDisposed(); var snapPoint = Snapping.GetNextSnapPoint(_clock.CurrentTime); if (snapPoint != null) { MoveToTime((MetricTimeSpan)snapPoint.Time); } }
public void TranslateSnapsAllAxes() { var cur = new Vector3(.15f, .28f, .15f); Assert.AreEqual(Snapping.Round(cur, .5f), new Vector3(0f, .5f, 0f)); cur = new Vector3(.15f, .15f, .9f); Assert.AreEqual(Snapping.Round(cur, .5f), new Vector3(0f, 0f, 1f)); cur = new Vector3(.15f, .3f, .9f); Assert.AreEqual(Snapping.Round(cur, .5f), new Vector3(0f, .5f, 1f)); }
/// <summary> /// Sets playback position to the time of the next snap point (relative to the current /// time of playback) that belongs to the specified <see cref="SnapPointsGroup"/>. /// </summary> /// <param name="snapPointsGroup"><see cref="SnapPointsGroup"/> that defines snap points to /// select the one from.</param> /// <exception cref="ArgumentNullException"><paramref name="snapPointsGroup"/> is null.</exception> /// <exception cref="ObjectDisposedException">The current <see cref="Playback"/> is disposed.</exception> /// <exception cref="MidiDeviceException">An error occurred on device.</exception> public void MoveToNextSnapPoint(SnapPointsGroup snapPointsGroup) { ThrowIfArgument.IsNull(nameof(snapPointsGroup), snapPointsGroup); EnsureIsNotDisposed(); var snapPoint = Snapping.GetNextSnapPoint(_clock.CurrentTime, snapPointsGroup); if (snapPoint != null) { MoveToTime((MetricTimeSpan)snapPoint.Time); } }
/// <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 void TranslateOnlySnapsChangedAxis() { var old = new Vector3(.15f, .15f, .15f); var cur = new Vector3(.15f, .28f, .15f); Assert.AreEqual(Snapping.Round(cur, cur - old, .5f), new Vector3(.15f, .5f, .15f)); cur = new Vector3(.15f, .15f, .9f); Assert.AreEqual(Snapping.Round(cur, cur - old, .5f), new Vector3(.15f, .15f, 1f)); cur = new Vector3(.15f, .3f, .9f); Assert.AreEqual(Snapping.Round(cur, cur - old, .5f), new Vector3(.15f, .5f, 1f)); }
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(); }
void Update() { if (Context == null) { return; } // [TODO] need to consider camera distane here? Frame3f sceneFrameW = Context.Scene.SceneFrame; if (sceneFrameW.EpsilonEqual(lastSceneFrameW, 0.001f)) { return; } lastSceneFrameW = sceneFrameW; if (AdjustShadowDistance) { // use vertical height of light to figure out appropriate shadow distance. // distance changes if we scale scene, and if we don't do this, shadow // map res gets very blurry. Vector3f thisW = lights[0].transform.position; float fHeight = Vector3f.Dot((thisW - sceneFrameW.Origin), sceneFrameW.Y); float fShadowDist = fHeight * 1.5f; // lights need to be in-range if (fShadowDist < LightDistance) { fShadowDist = LightDistance * 1.5f; } // need to be a multiple of eye distance float fEyeDist = sceneFrameW.Origin.Distance(Camera.main.transform.position); fShadowDist = Mathf.Max(fShadowDist, 1.5f * fEyeDist); int nShadowDist = (int)Snapping.SnapToIncrement(fShadowDist, 50); if (cur_shadow_dist != nShadowDist) { QualitySettings.shadowDistance = nShadowDist; cur_shadow_dist = nShadowDist; } } }
// Update is called once per frame void Update() { if (!health.IsAlive()) { if (currentEvolution == lastEvolution) { StartCoroutine(OnDeath()); } else { switch (currentEvolution) { case TowerEvolutions.Evolution1: StartCoroutine(EvolveTower(TowerEvolutions.Evolution2)); break; case TowerEvolutions.Evolution2: StartCoroutine(EvolveTower(TowerEvolutions.Evolution3)); break; } } } else { Transform target = CheckTarget(); if (target) { Vector2 direction = target.position - transform.position; targetAngle = Mathf.Atan2(direction.y, direction.x) * Mathf.Rad2Deg; targetAngle = Snapping.Snap(targetAngle, 45f); targetX = Mathf.Cos(targetAngle * Mathf.Deg2Rad); targetY = Mathf.Sin(targetAngle * Mathf.Deg2Rad); if (timerActive) { shootTimer -= Time.deltaTime; } if (shootTimer < 0) { shootTimer = 0; } Shoot(); } } }
/// <summary> /// Return the last known grid pivot point. /// </summary> /// <param name="pivot"></param> /// <returns></returns> public static bool GetPivot(out Vector3 pivot) { pivot = Vector3.zero; if (s_GetPivotDelegate == null) s_GetPivotDelegate = (Func<Vector3>)ReflectionUtility.GetOpenDelegate<Func<Vector3>>(GetProGridsType(), "GetPivot"); if (s_GetPivotDelegate != null) { pivot = s_GetPivotDelegate(); // earlier version of progrids return a non-snapped pivot point pivot = Snapping.SnapValue(pivot, SnapValue()); return true; } return false; }
void Update() { if (!health.IsAlive()) { StartCoroutine(OnDeath()); return; } movement.x = Input.GetAxisRaw("Horizontal"); movement.y = Input.GetAxisRaw("Vertical"); mousePos = cam.ScreenToWorldPoint(Input.mousePosition); Vector2 characterDirection = mousePos - body.position; relativeAngle = Mathf.Atan2(characterDirection.y, characterDirection.x) * Mathf.Rad2Deg; relativeAngle = Snapping.Snap(relativeAngle, 45f); relativeMouseX = Mathf.Cos(relativeAngle * Mathf.Deg2Rad); relativeMouseY = Mathf.Sin(relativeAngle * Mathf.Deg2Rad); if ((relativeMouseX > 0) && !isFacingRight) { Flip(); } else if ((relativeMouseX < 0) && isFacingRight) { Flip(); } if (timerActive) { shootTimer -= Time.deltaTime; } if (shootTimer < 0) { shootTimer = 0; } if (Input.GetButtonDown("Fire1") && !EventSystem.current.IsPointerOverGameObject()) { Shoot(); } }
#pragma warning disable 618 public static Vector3 Do( int id, Vector3 handlePos, Vector3 offset, Vector3 handleDir, Vector3 slideDir1, Vector3 slideDir2, float handleSize, Handles.DrawCapFunction drawFunc, Vector2 snap, bool drawHelper) #pragma warning restore 618 { bool orgGuiChanged = GUI.changed; GUI.changed = false; Vector2 delta = CalcDeltaAlongDirections(id, handlePos, offset, handleDir, slideDir1, slideDir2, handleSize, drawFunc, snap, drawHelper); if (GUI.changed) { handlePos = s_StartPosition + slideDir1 * delta.x + slideDir2 * delta.y; if (EditorSnapSettings.gridSnapActive) { var normal = Vector3.Cross(slideDir1, slideDir2); if (Snapping.IsCardinalDirection(normal)) { var worldSpace = Handles.matrix.MultiplyPoint(handlePos); worldSpace = Snapping.Snap(worldSpace, GridSettings.size, (SnapAxis) ~new SnapAxisFilter(normal)); handlePos = Handles.inverseMatrix.MultiplyPoint(worldSpace); } } } GUI.changed |= orgGuiChanged; return(handlePos); }
void DoGridVisualSettings() { Vector3 grid = GridSettings.size; bool linked = gridValueLinked; EditorGUI.BeginChangeCheck(); grid = EditorGUILayout.LinkedVector3Field(Contents.gridSize, grid, ref linked); if (EditorGUI.EndChangeCheck()) { gridValueLinked = linked; GridSettings.size = grid; SceneView.RepaintAll(); } EditorGUI.BeginChangeCheck(); GUILayout.BeginHorizontal(); EditorGUILayout.PrefixLabel(Contents.movePivot); if (GUILayout.Button("Handle")) { foreach (var view in SceneView.sceneViews) { ((SceneView)view).sceneViewGrids.SetAllGridsPivot(Snapping.Snap(Tools.handlePosition, GridSettings.size)); } } if (GUILayout.Button("Reset")) { foreach (var view in SceneView.sceneViews) { ((SceneView)view).sceneViewGrids.ResetPivot(SceneViewGrid.GridRenderAxis.All); } } GUILayout.EndHorizontal(); if (EditorGUI.EndChangeCheck()) { SceneView.RepaintAll(); } }
// Returns the new handlePos public static Vector3 Do( int id, Vector3 handlePos, Vector3 offset, Vector3 handleDir, Vector3 slideDir1, Vector3 slideDir2, float handleSize, Handles.CapFunction capFunction, Vector2 snap, bool drawHelper) { bool orgGuiChanged = GUI.changed; GUI.changed = false; Vector2 delta = CalcDeltaAlongDirections(id, handlePos, offset, handleDir, slideDir1, slideDir2, handleSize, capFunction, snap, drawHelper); if (GUI.changed) { handlePos = s_StartPosition + slideDir1 * delta.x + slideDir2 * delta.y; if (EditorSnapSettings.active && EditorSnapSettings.preferGrid) { var normal = Vector3.Cross(slideDir1, slideDir2); if (Snapping.IsCardinalDirection(normal)) { var worldSpace = Handles.matrix.MultiplyPoint(handlePos); worldSpace = Handles.SnapValue(worldSpace, (~new SnapAxisFilter(normal)) * snap); handlePos = Handles.inverseMatrix.MultiplyPoint(worldSpace); } } } GUI.changed |= orgGuiChanged; return(handlePos); }
void DoExistingPointsGUI() { Transform trs = polygon.transform; int len = polygon.m_Points.Count; Vector3 up = polygon.transform.up; Vector3 right = polygon.transform.right; Vector3 forward = polygon.transform.forward; Vector3 center = Vector3.zero; Event evt = Event.current; bool used = evt.type == EventType.Used; if (!used && (evt.type == EventType.MouseDown && evt.button == 0 && !EditorHandleUtility.IsAppendModifier(evt.modifiers))) { m_SelectedIndex = -1; Repaint(); } if (polygon.polyEditMode == PolyShape.PolyEditMode.Height) { if (!used && evt.type == EventType.MouseUp && evt.button == 0 && !EditorHandleUtility.IsAppendModifier(evt.modifiers)) { evt.Use(); SetPolyEditMode(PolyShape.PolyEditMode.Edit); } bool sceneInUse = EditorHandleUtility.SceneViewInUse(evt); Ray r = HandleUtility.GUIPointToWorldRay(evt.mousePosition); Vector3 origin = polygon.transform.TransformPoint(Math.Average(polygon.m_Points)); float extrude = polygon.extrude; if (evt.type == EventType.MouseMove && !sceneInUse) { Vector3 p = Math.GetNearestPointRayRay(origin, up, r.origin, r.direction); extrude = ProGridsInterface.ProGridsSnap(s_HeightMouseOffset + Vector3.Distance(origin, p) * Mathf.Sign(Vector3.Dot(p - origin, up))); } Vector3 extrudePoint = origin + (extrude * up); Handles.color = k_HandleColor; Handles.DotHandleCap(-1, origin, Quaternion.identity, HandleUtility.GetHandleSize(origin) * k_HandleSize, evt.type); Handles.color = k_HandleColorGreen; Handles.DrawLine(origin, extrudePoint); Handles.DotHandleCap(-1, extrudePoint, Quaternion.identity, HandleUtility.GetHandleSize(extrudePoint) * k_HandleSize, evt.type); Handles.color = Color.white; if (!sceneInUse && polygon.extrude != extrude) { OnBeginVertexMovement(); polygon.extrude = extrude; RebuildPolyShapeMesh(false); } } else { // vertex dots for (int ii = 0; ii < len; ii++) { Vector3 point = trs.TransformPoint(polygon.m_Points[ii]); center.x += point.x; center.y += point.y; center.z += point.z; float size = HandleUtility.GetHandleSize(point) * k_HandleSize; Handles.color = ii == m_SelectedIndex ? k_HandleSelectedColor : k_HandleColor; EditorGUI.BeginChangeCheck(); point = Handles.Slider2D(point, up, right, forward, size, Handles.DotHandleCap, Vector2.zero, true); if (EditorGUI.EndChangeCheck()) { UndoUtility.RecordObject(polygon, "Move Polygon Shape Point"); Vector3 snapMask = Snapping.GetSnappingMaskBasedOnNormalVector(m_Plane.normal); polygon.m_Points[ii] = ProGridsInterface.ProGridsSnap(trs.InverseTransformPoint(point), snapMask); OnBeginVertexMovement(); RebuildPolyShapeMesh(false); } // "clicked" a button if (!used && evt.type == EventType.Used) { if (ii == 0 && polygon.m_Points.Count > 2 && polygon.polyEditMode == PolyShape.PolyEditMode.Path) { m_NextMouseUpAdvancesMode = true; return; } else { used = true; m_SelectedIndex = ii; } } } Handles.color = Color.white; // height setting if (polygon.polyEditMode != PolyShape.PolyEditMode.Path && polygon.m_Points.Count > 2) { center.x /= (float)len; center.y /= (float)len; center.z /= (float)len; Vector3 extrude = center + (up * polygon.extrude); m_DistanceFromHeightHandle = Vector2.Distance(HandleUtility.WorldToGUIPoint(extrude), evt.mousePosition); EditorGUI.BeginChangeCheck(); Handles.color = k_HandleColor; Handles.DotHandleCap(-1, center, Quaternion.identity, HandleUtility.GetHandleSize(center) * k_HandleSize, evt.type); Handles.DrawLine(center, extrude); Handles.color = k_HandleColorGreen; extrude = Handles.Slider(extrude, up, HandleUtility.GetHandleSize(extrude) * k_HandleSize, Handles.DotHandleCap, 0f); Handles.color = Color.white; if (EditorGUI.EndChangeCheck()) { UndoUtility.RecordObject(polygon, "Set Polygon Shape Height"); polygon.extrude = ProGridsInterface.ProGridsSnap(Vector3.Distance(extrude, center) * Mathf.Sign(Vector3.Dot(up, extrude - center))); OnBeginVertexMovement(); RebuildPolyShapeMesh(false); } } } }
protected override void DoTool(Vector3 handlePosition, Quaternion handleRotation) { if (!isEditing) { m_Rotation = 0f; } EditorGUI.BeginChangeCheck(); var size = HandleUtility.GetHandleSize(handlePosition); EditorHandleUtility.PushMatrix(); Handles.matrix = Matrix4x4.TRS(handlePosition, handleRotation, Vector3.one); Handles.color = Color.blue; m_Euler.z = m_Rotation; m_Quaternion = Quaternion.Euler(m_Euler); m_Quaternion = Handles.Disc(m_Quaternion, Vector3.zero, Vector3.forward, size, relativeSnapEnabled, relativeSnapRotation); m_Euler = m_Quaternion.eulerAngles; m_Rotation = m_Euler.z; EditorHandleUtility.PopMatrix(); if (EditorGUI.EndChangeCheck()) { if (!isEditing) { BeginEdit("Rotate Textures"); } if (relativeSnapEnabled) { m_Rotation = Snapping.SnapValue(m_Rotation, relativeSnapX); } else if (progridsSnapEnabled) { m_Rotation = Snapping.SnapValue(m_Rotation, progridsSnapValue); } foreach (var mesh in elementSelection) { if (!(mesh is MeshAndTextures)) { continue; } var mat = (MeshAndTextures)mesh; var origins = mat.origins; var positions = mat.textures; foreach (var group in mat.elementGroups) { foreach (var index in group.indices) { positions[index] = mat.postApplyMatrix.MultiplyPoint( Math.RotateAroundPoint( mat.preApplyMatrix.MultiplyPoint3x4(origins[index]), Vector2.zero, -m_Rotation)); } } mesh.mesh.mesh.SetUVs(k_TextureChannel, positions); } } }
public void ScrollTo(int index, Snapping snap = Snapping.SnapLeft) { Initialize(); // nothing to do if (Items.Count == 0) return; // animate to new position this.ScrollStart(index, snap, AnimationDuration); }
private void ScrollStart(int index, Snapping snap, double milliseconds = 0) { Initialize(); // positions double offsetBackground = 0.0; double offsetTitle = 0.0; double offsetItems = 0.0; // // adjust destination item positions // int index0 = 0; int indexN = Items.Count - 1; // scroll from first to last if (index < index0) { if (snap == Snapping.SnapLeft) offsetItems = Items.GetItemPosition(index0) - Items.GetItemWidth(indexN); else offsetItems = Items.GetItemPosition(index0) - Parent.DefaultItemWidth; } // scroll from last to first else if (index > indexN) { // since we're moving left to right, and only a item at a time // we can only snap to left here... offsetItems = Items.GetItemPosition(indexN) + Items.GetItemWidth(indexN); } // normal scroll else { if (snap == Snapping.SnapLeft) offsetItems = Items.GetItemPosition(index); else offsetItems = Items.GetItemPosition(index) + Items.GetItemWidth(index) - Parent.DefaultItemWidth; } // // adjust animation speed // double offset = Math.Abs(offsetItems - Position); if (offset < LayoutRoot.ActualWidth) { milliseconds *= offset / LayoutRoot.ActualWidth; } // // adjust positions // offsetBackground = offsetItems * BackgroundHost.Speed; offsetTitle = offsetItems * TitleHost.Speed; offsetItems = offsetItems * ItemsHost.Speed; // back to last if (offsetItems < 0) { offsetBackground = Items.GetLastItemPosition() - ItemsHost.Width; offsetTitle = offsetBackground * TitleHost.Speed - TitleHost.Padding; if (Items.Count == 1) { // only 1 item : scroll the entire background offsetBackground = -BackgroundHost.Width; } } // back to first else if (offsetItems >= Items.GetTotalWidth()) { offsetBackground = BackgroundHost.Width; offsetTitle = TitleHost.Width + TitleHost.Padding; } // // start storyboard // Storyboard = new Storyboard(); Storyboard.Completed += new EventHandler(Storyboard_Completed); Storyboard.Children.Add(CreateAnimation(BackgroundHost.Transform, TranslateTransform.XProperty,- offsetBackground, milliseconds)); Storyboard.Children.Add(CreateAnimation(TitleHost.Transform, TranslateTransform.XProperty, -offsetTitle, milliseconds)); Storyboard.Children.Add(CreateAnimation(ItemsHost.Transform, TranslateTransform.XProperty, -offsetItems, milliseconds)); Storyboard.Begin(); }
static void SnapGridIntersection(UVSnapSettings snapSettings, SurfaceReference surfaceReference, Vector3 intersectionPoint, float preferenceFactor, ref Vector3 snappedPoint, ref float bestDist) { if ((snapSettings & UVSnapSettings.GeometryGrid) == UVSnapSettings.None) { return; } var grid = UnitySceneExtensions.Grid.defaultGrid; var gridSnappedPoint = Snapping.SnapPoint(intersectionPoint, grid); var worldPlane = surfaceReference.WorldPlane.Value; var xAxis = grid.Right; var yAxis = grid.Up; var zAxis = grid.Forward; var snapAxis = Axis.X | Axis.Y | Axis.Z; if (Mathf.Abs(Vector3.Dot(xAxis, worldPlane.normal)) >= kAlignmentEpsilon) { snapAxis &= ~Axis.X; } if (Mathf.Abs(Vector3.Dot(yAxis, worldPlane.normal)) >= kAlignmentEpsilon) { snapAxis &= ~Axis.Y; } if (Mathf.Abs(Vector3.Dot(zAxis, worldPlane.normal)) >= kAlignmentEpsilon) { snapAxis &= ~Axis.Z; } if (Mathf.Abs(worldPlane.GetDistanceToPoint(gridSnappedPoint)) < kDistanceEpsilon) { bestDist = (gridSnappedPoint - intersectionPoint).magnitude * preferenceFactor; snappedPoint = gridSnappedPoint; } else { float dist; var ray = new Ray(gridSnappedPoint, xAxis); if ((snapAxis & Axis.X) != Axis.None && worldPlane.UnsignedRaycast(ray, out dist)) { var planePoint = ray.GetPoint(dist); var abs_dist = (planePoint - intersectionPoint).magnitude * preferenceFactor; if (abs_dist < bestDist) { bestDist = abs_dist; snappedPoint = planePoint; } } ray.direction = yAxis; if ((snapAxis & Axis.Y) != Axis.None && worldPlane.UnsignedRaycast(ray, out dist)) { var planePoint = ray.GetPoint(dist); var abs_dist = (planePoint - intersectionPoint).magnitude * preferenceFactor; if (abs_dist < bestDist) { bestDist = abs_dist; snappedPoint = planePoint; } } ray.direction = zAxis; if ((snapAxis & Axis.Z) != Axis.None && worldPlane.UnsignedRaycast(ray, out dist)) { var planePoint = ray.GetPoint(dist); var abs_dist = (planePoint - intersectionPoint).magnitude * preferenceFactor; if (abs_dist < bestDist) { bestDist = abs_dist; snappedPoint = planePoint; } } } }
public NoteRoll() { InitializeComponent(); ImageBrush brush = new ImageBrush(); brush.ImageSource = new BitmapImage(new Uri(System.AppDomain.CurrentDomain.BaseDirectory + "\\res\\01.PNG")); brush.TileMode = TileMode.Tile; brush.ViewportUnits = BrushMappingMode.Absolute; brush.Viewport = new Rect(0, 0, brush.ImageSource.Width, brush.ImageSource.Height); brush.Stretch = Stretch.None; bkgCanvas.Background = brush; otoRead = new OtoReader(); wavMod = new wavmod.WavMod(); setDefaultColors(); PaintPianoKeys(); scroller.ScrollToVerticalOffset(560); NoteSnapping = Snapping.Sixteenth; RollSnapping = Snapping.Sixteenth; }