internal override Rect GetBounds(GraphTransform inverseTransform) { if (this.verts == null) { this.RebuildMesh(); } Int3[] array = ArrayPool <Int3> .Claim((this.verts != null)?this.verts.Length : 0); int[] array2; this.GetMesh(ref array, out array2, inverseTransform); Rect result = default(Rect); for (int i = 0; i < array2.Length; i++) { Vector3 vector = (Vector3)array[array2[i]]; if (i == 0) { result = new Rect(vector.x, vector.z, 0f, 0f); } else { result.xMax = Math.Max(result.xMax, vector.x); result.yMax = Math.Max(result.yMax, vector.z); result.xMin = Math.Min(result.xMin, vector.x); result.yMin = Math.Min(result.yMin, vector.z); } } ArrayPool <Int3> .Release(ref array, false); return(result); }
// Token: 0x06002691 RID: 9873 RVA: 0x001A83A8 File Offset: 0x001A65A8 internal override Rect GetBounds(GraphTransform inverseTranform) { List <List <Vector3> > list = ListPool <List <Vector3> > .Claim(); this.GetContour(list); Rect result = default(Rect); for (int i = 0; i < list.Count; i++) { List <Vector3> list2 = list[i]; for (int j = 0; j < list2.Count; j++) { Vector3 vector = inverseTranform.InverseTransform(list2[j]); if (j == 0) { result = new Rect(vector.x, vector.z, 0f, 0f); } else { result.xMax = Math.Max(result.xMax, vector.x); result.yMax = Math.Max(result.yMax, vector.z); result.xMin = Math.Min(result.xMin, vector.x); result.yMin = Math.Min(result.yMin, vector.z); } } } ListPool <List <Vector3> > .Release(ref list); return(result); }
// Token: 0x06002696 RID: 9878 RVA: 0x001A8890 File Offset: 0x001A6A90 public void OnDrawGizmosSelected() { List <List <Vector3> > list = ListPool <List <Vector3> > .Claim(); this.GetContour(list); Color color = Color.Lerp(NavmeshCut.GizmoColor, Color.white, 0.5f); color.a *= 0.5f; Gizmos.color = color; NavmeshBase navmeshBase = (AstarPath.active != null) ? (AstarPath.active.data.recastGraph ?? AstarPath.active.data.navmesh) : null; GraphTransform graphTransform = (navmeshBase != null) ? navmeshBase.transform : GraphTransform.identityTransform; float y = this.GetY(graphTransform); float y2 = y - this.height * 0.5f; float y3 = y + this.height * 0.5f; for (int i = 0; i < list.Count; i++) { List <Vector3> list2 = list[i]; for (int j = 0; j < list2.Count; j++) { Vector3 vector = graphTransform.InverseTransform(list2[j]); Vector3 vector2 = graphTransform.InverseTransform(list2[(j + 1) % list2.Count]); Vector3 point = vector; Vector3 point2 = vector2; Vector3 point3 = vector; Vector3 point4 = vector2; point.y = (point2.y = y2); point3.y = (point4.y = y3); Gizmos.DrawLine(graphTransform.Transform(point), graphTransform.Transform(point2)); Gizmos.DrawLine(graphTransform.Transform(point3), graphTransform.Transform(point4)); Gizmos.DrawLine(graphTransform.Transform(point), graphTransform.Transform(point3)); } } ListPool <List <Vector3> > .Release(ref list); }
public static Bounds InverseTransform(this GraphTransform self, Bounds bounds) { if (self.onlyTranslational) { return(new Bounds(bounds.center - self.translation.ToUnityV3(), bounds.size)); } var corners = PF.ArrayPool <Vector3> .Claim(8); var extents = bounds.extents; corners[0] = self.InverseTransform(bounds.center + new Vector3(extents.x, extents.y, extents.z)); corners[1] = self.InverseTransform(bounds.center + new Vector3(extents.x, extents.y, -extents.z)); corners[2] = self.InverseTransform(bounds.center + new Vector3(extents.x, -extents.y, extents.z)); corners[3] = self.InverseTransform(bounds.center + new Vector3(extents.x, -extents.y, -extents.z)); corners[4] = self.InverseTransform(bounds.center + new Vector3(-extents.x, extents.y, extents.z)); corners[5] = self.InverseTransform(bounds.center + new Vector3(-extents.x, extents.y, -extents.z)); corners[6] = self.InverseTransform(bounds.center + new Vector3(-extents.x, -extents.y, extents.z)); corners[7] = self.InverseTransform(bounds.center + new Vector3(-extents.x, -extents.y, -extents.z)); var min = corners[0]; var max = corners[0]; for (int i = 1; i < 8; i++) { min = Vector3.Min(min, corners[i]); max = Vector3.Max(max, corners[i]); } PF.ArrayPool <Vector3> .Release(ref corners); return(new Bounds((min + max) * 0.5f, max - min)); }
// Token: 0x060024D3 RID: 9427 RVA: 0x0019D2FC File Offset: 0x0019B4FC public void Initialize(GraphTransform transform, float scale) { this.up = (transform.Transform(Vector3.up) - transform.Transform(Vector3.zero)).normalized; this.upheight = this.up * this.height; this.finalRadius = this.diameter * scale * 0.5f; this.finalRaycastRadius = this.thickRaycastDiameter * scale * 0.5f; }
/// <summary> /// Bounds in XZ space after transforming using the *inverse* transform of the inverseTransform parameter. /// The transformation will typically transform the vertices to graph space and this is used to /// figure out which tiles the cut intersects. /// </summary> public override Rect GetBounds(GraphTransform inverseTransform) { var buffers = ListPool <List <Vector3> > .Claim(); GetContour(buffers); Rect r = new Rect(); for (int i = 0; i < buffers.Count; i++) { var buffer = buffers[i]; for (int k = 0; k < buffer.Count; k++) { var p = inverseTransform.InverseTransform(buffer[k]); if (k == 0) { r = new Rect(p.x, p.z, 0, 0); } else { r.xMax = System.Math.Max(r.xMax, p.x); r.yMax = System.Math.Max(r.yMax, p.z); r.xMin = System.Math.Min(r.xMin, p.x); r.yMin = System.Math.Min(r.yMin, p.z); } } } ListPool <List <Vector3> > .Release(ref buffers); return(r); }
/** Sets up several variables using the specified matrix and scale. * \see GraphCollision.up * \see GraphCollision.upheight * \see GraphCollision.finalRadius * \see GraphCollision.finalRaycastRadius */ public void Initialize(GraphTransform transform, float scale) { up = (transform.Transform(Vector3.up) - transform.Transform(Vector3.zero)).normalized; upheight = up * height; finalRadius = diameter * scale * 0.5F; finalRaycastRadius = thickRaycastDiameter * scale * 0.5F; }
// Token: 0x06002435 RID: 9269 RVA: 0x001968A0 File Offset: 0x00194AA0 public void Refresh() { if (base.transform.hasChanged) { this.transformation = new GraphTransform(base.transform.localToWorldMatrix * this.originalMatrix); base.transform.hasChanged = false; } }
public void SetTransform(GraphTransform transform) { Transform tr = new TranslateTransform(transform.TranslateX, transform.TranslateY); Transform sc = new ScaleTransform(transform.ScaleX, transform.ScaleY); this.context.PushTransform(tr); this.context.PushTransform(sc); }
public void Refresh() { // Avoid updating the GraphTransform if the object has not moved if (transform.hasChanged) { transformation = new GraphTransform(transform.localToWorldMatrix * originalMatrix); transform.hasChanged = false; } }
/** Called when a requested path has finished calculation. * A path is first requested by #SearchPath, it is then calculated, probably in the same or the next frame. * Finally it is returned to the seeker which forwards it to this function.\n */ public virtual void OnPathComplete(Path _p) { ABPath p = _p as ABPath; if (p == null) { throw new System.Exception("This function only handles ABPaths, do not use special path types"); } canSearchAgain = true; // Claim the new path p.Claim(this); // Path couldn't be calculated of some reason. // More info in p.errorLog (debug string) if (p.error) { p.Release(this); return; } // Release the previous path if (path != null) { path.Release(this); } // Replace the old path path = p; // Make sure the path contains at least 2 points if (path.vectorPath.Count == 1) { path.vectorPath.Add(path.vectorPath[0]); } interpolator.SetPath(path.vectorPath); // REPLACEMENT // var graph = AstarData.GetGraph(path.path[0]) as ITransformedGraph; // movementPlane = graph != null ? graph.transform : GraphTransform.identityTransform; var graphRotation = new Vector3(-90, 0, 0); movementPlane = new GraphTransform(Matrix4x4.TRS(Vector3.zero, Quaternion.Euler(graphRotation), Vector3.one)); // Reset some variables TargetReached = false; // Simulate movement from the point where the path was requested // to where we are right now. This reduces the risk that the agent // gets confused because the first point in the path is far away // from the current position (possibly behind it which could cause // the agent to turn around, and that looks pretty bad). interpolator.MoveToLocallyClosestPoint((GetFeetPosition() + p.originalStartPoint) * 0.5f); interpolator.MoveToLocallyClosestPoint(GetFeetPosition()); }
/// <summary> /// Sets up several variables using the specified matrix and scale. /// See: GraphCollision.up /// See: GraphCollision.upheight /// See: GraphCollision.finalRadius /// See: GraphCollision.finalRaycastRadius /// </summary> public void Initialize(GraphTransform transform, float scale) { up = (transform.Transform(Vector3.up) - transform.Transform(Vector3.zero)).normalized; upheight = up * height; finalRadius = diameter * scale * 0.5F; finalRaycastRadius = thickRaycastDiameter * scale * 0.5F; contactFilter = new ContactFilter2D { layerMask = mask, useDepth = false, useLayerMask = true, useNormalAngle = false, useTriggers = false }; }
/** Draws some debug lines representing the rect */ public void DebugDraw(GraphTransform transform, Color color) { Vector3 p1 = transform.Transform(new Vector3(xmin, 0, ymin)); Vector3 p2 = transform.Transform(new Vector3(xmin, 0, ymax)); Vector3 p3 = transform.Transform(new Vector3(xmax, 0, ymax)); Vector3 p4 = transform.Transform(new Vector3(xmax, 0, ymin)); Debug.DrawLine(p1, p2, color); Debug.DrawLine(p2, p3, color); Debug.DrawLine(p3, p4, color); Debug.DrawLine(p4, p1, color); }
// Token: 0x0600246E RID: 9326 RVA: 0x0019C23C File Offset: 0x0019A43C public void DebugDraw(GraphTransform transform, Color color) { Vector3 vector = transform.Transform(new Vector3((float)this.xmin, 0f, (float)this.ymin)); Vector3 vector2 = transform.Transform(new Vector3((float)this.xmin, 0f, (float)this.ymax)); Vector3 vector3 = transform.Transform(new Vector3((float)this.xmax, 0f, (float)this.ymax)); Vector3 vector4 = transform.Transform(new Vector3((float)this.xmax, 0f, (float)this.ymin)); Debug.DrawLine(vector, vector2, color); Debug.DrawLine(vector2, vector3, color); Debug.DrawLine(vector3, vector4, color); Debug.DrawLine(vector4, vector, color); }
void ResizeAxis(Rectangle r) { //If the rectangle has zero width or zero height return if (r.Width == 0) { return; } if (r.Height == 0) { return; } //Get the points from the rectangle double x1 = r.X - this.CurveArea.X; double y1 = r.Y - this.CurveArea.Y; double x2 = x1 + r.Width; double y2 = y1 + r.Height; //Transform rectangle points into real values x1 = GraphTransform.InvTranslateX(x1); y1 = GraphTransform.InvTranslateY(y1); x2 = GraphTransform.InvTranslateX(x2); y2 = GraphTransform.InvTranslateY(y2); //If logarithmic x axis transform x values if (this.AxisTypeX == AxisType.LOG) { x1 = (double)Math.Pow(10, x1); x2 = (double)Math.Pow(10, x2); } //If logarithmic y axis transform y values if (this.AxisTypeY == AxisType.LOG) { y1 = (double)Math.Pow(10, y1); y2 = (double)Math.Pow(10, y2); } //If this chart has autoscale enabled disable it if (this.AutoScale) { this.AutoScale = false; } //Set the new axisrange this.AxisRangeX = new AxisData(x1, x2, Math.Abs(x2 - x1) / 5); this.AxisRangeY = new AxisData(y2, y1, Math.Abs(y1 - y2) / 5); //Redraw the control RedrawChart(); }
public void GetMesh(ref Int3[] vbuffer, out int[] tbuffer, GraphTransform inverseTransform = null) { if (this.verts == null) { this.RebuildMesh(); } if (this.verts == null) { tbuffer = ArrayPool <int> .Claim(0); return; } if (vbuffer == null || vbuffer.Length < this.verts.Length) { if (vbuffer != null) { ArrayPool <Int3> .Release(ref vbuffer, false); } vbuffer = ArrayPool <Int3> .Claim(this.verts.Length); } tbuffer = this.tris; if (this.useRotationAndScale) { Matrix4x4 matrix4x = Matrix4x4.TRS(this.tr.position + this.center, this.tr.rotation, this.tr.localScale * this.meshScale); for (int i = 0; i < this.verts.Length; i++) { Vector3 vector = matrix4x.MultiplyPoint3x4(this.verts[i]); if (inverseTransform != null) { vector = inverseTransform.InverseTransform(vector); } vbuffer[i] = (Int3)vector; } } else { Vector3 a = this.tr.position + this.center; for (int j = 0; j < this.verts.Length; j++) { Vector3 vector2 = a + this.verts[j] * this.meshScale; if (inverseTransform != null) { vector2 = inverseTransform.InverseTransform(vector2); } vbuffer[j] = (Int3)vector2; } } }
public void DrawTransformGizmos(GraphTransform t, Vector3 pivotPoint, Vector3 forward, Vector3 up) { Vector3 pivotWorld = t.Transform(pivotPoint); Vector3 xWorld = t.Transform(forward).normalized; Vector3 yWorld = t.Transform(up).normalized; Vector3 zWorld = Vector3.Cross(xWorld, yWorld); yWorld = Vector3.Cross(zWorld, xWorld); yWorld.Normalize(); xWorld.Normalize(); // Gizmos.color = Color.red; // Gizmos.DrawLine(pivotWorld, pivotWorld + xWorld); // Gizmos.color = Color.green; // Gizmos.DrawLine(pivotWorld, pivotWorld + yWorld); // Gizmos.color = Color.blue; // Gizmos.DrawLine(pivotWorld, pivotWorld + zWorld); }
private protected void MakeContent(TreeViewItem snd) { var elem = (snd.GetValue(ContentProperty) as Func <object>)(); GraphElement ge = null; if (elem is ATransformation t) { ge = new GraphTransform(t); } else if (elem is Renderable r) { ge = new GraphShape(r); } else if (elem is GraphParent gp) { ge = gp; } newElement = MakeContentSub(snd.Header as string, ge); }
public void DrawWireCube(GraphTransform tr, Bounds bounds, Color color) { var min = bounds.min; var max = bounds.max; DrawLine(tr.Transform(new Vector3(min.x, min.y, min.z)), tr.Transform(new Vector3(max.x, min.y, min.z)), color); DrawLine(tr.Transform(new Vector3(max.x, min.y, min.z)), tr.Transform(new Vector3(max.x, min.y, max.z)), color); DrawLine(tr.Transform(new Vector3(max.x, min.y, max.z)), tr.Transform(new Vector3(min.x, min.y, max.z)), color); DrawLine(tr.Transform(new Vector3(min.x, min.y, max.z)), tr.Transform(new Vector3(min.x, min.y, min.z)), color); DrawLine(tr.Transform(new Vector3(min.x, max.y, min.z)), tr.Transform(new Vector3(max.x, max.y, min.z)), color); DrawLine(tr.Transform(new Vector3(max.x, max.y, min.z)), tr.Transform(new Vector3(max.x, max.y, max.z)), color); DrawLine(tr.Transform(new Vector3(max.x, max.y, max.z)), tr.Transform(new Vector3(min.x, max.y, max.z)), color); DrawLine(tr.Transform(new Vector3(min.x, max.y, max.z)), tr.Transform(new Vector3(min.x, max.y, min.z)), color); DrawLine(tr.Transform(new Vector3(min.x, min.y, min.z)), tr.Transform(new Vector3(min.x, max.y, min.z)), color); DrawLine(tr.Transform(new Vector3(max.x, min.y, min.z)), tr.Transform(new Vector3(max.x, max.y, min.z)), color); DrawLine(tr.Transform(new Vector3(max.x, min.y, max.z)), tr.Transform(new Vector3(max.x, max.y, max.z)), color); DrawLine(tr.Transform(new Vector3(min.x, min.y, max.z)), tr.Transform(new Vector3(min.x, max.y, max.z)), color); }
private void ResizeAxis(Rectangle r) { if (r.Width == 0) { return; } if (r.Height == 0) { return; } double x1 = r.X - this.CurveArea.X; double y1 = r.Y - this.CurveArea.Y; double x2 = x1 + r.Width; double y2 = y1 + r.Height; x1 = GraphTransform.InvTranslateX(x1); y1 = GraphTransform.InvTranslateY(y1); x2 = GraphTransform.InvTranslateX(x2); y2 = GraphTransform.InvTranslateY(y2); if (this.AxisTypeX == AxisType.LOG) { x1 = Math.Pow(10, x1); x2 = Math.Pow(10, x2); } if (this.AxisTypeY == AxisType.LOG) { y1 = Math.Pow(10, y1); y2 = Math.Pow(10, y2); } this.AxisRangeX = new AxisData(x1, x2, Math.Abs(x2 - x1) / 5); this.AxisRangeY = new AxisData(y2, y1, Math.Abs(y1 - y2) / 5); Invalidate(); }
/// <summary>Y coordinate of the center of the bounding box in graph space</summary> internal float GetY(GraphTransform transform) { return(transform.InverseTransform(useRotationAndScale ? tr.TransformPoint(center) : tr.position + center).y); }
private static void FindAllContours(GridGraph grid, Action <Vector3[], bool> callback, GridNodeBase[] nodes = null) { if (grid is LayerGridGraph) { nodes = (nodes ?? (grid as LayerGridGraph).nodes); } nodes = (nodes ?? grid.nodes); int[] neighbourXOffsets = grid.neighbourXOffsets; int[] neighbourZOffsets = grid.neighbourZOffsets; int[] array; if (grid.neighbours == NumNeighbours.Six) { array = GridGraph.hexagonNeighbourIndices; } else { RuntimeHelpers.InitializeArray(array = new int[4], fieldof(< PrivateImplementationDetails >.$field - 02E4414E7DFA0F3AA2387EE8EA7AB31431CB406A).FieldHandle); } int[] array2 = array; float num = (grid.neighbours != NumNeighbours.Six) ? 0.5f : 0.333333343f; if (nodes != null) { Dictionary <Int3, int> dictionary = new Dictionary <Int3, int>(); Dictionary <int, int> dictionary2 = new Dictionary <int, int>(); HashSet <int> hashSet = new HashSet <int>(); List <Vector3> vertices = ListPool <Vector3> .Claim(); foreach (GridNodeBase gridNodeBase in nodes) { if (gridNodeBase != null && gridNodeBase.Walkable && !gridNodeBase.HasConnectionsToAllEightNeighbours) { for (int j = 0; j < array2.Length; j++) { int num2 = array2[j]; if (gridNodeBase.GetNeighbourAlongDirection(num2) == null) { int num3 = array2[(j - 1 + array2.Length) % array2.Length]; int num4 = array2[(j + 1) % array2.Length]; Vector3 vector = new Vector3((float)gridNodeBase.XCoordinateInGrid + 0.5f, 0f, (float)gridNodeBase.ZCoordinateInGrid + 0.5f); vector.x += (float)neighbourXOffsets[num2] * num; vector.z += (float)neighbourZOffsets[num2] * num; vector.y = grid.transform.InverseTransform((Vector3)gridNodeBase.position).y; Vector3 vector3; Vector3 vector2 = vector3 = vector; vector3.x += (float)neighbourXOffsets[num3] * num; vector3.z += (float)neighbourZOffsets[num3] * num; vector2.x += (float)neighbourXOffsets[num4] * num; vector2.z += (float)neighbourZOffsets[num4] * num; Int3 key = (Int3)vector3; Int3 key2 = (Int3)vector2; int key3; if (dictionary.TryGetValue(key, out key3)) { dictionary.Remove(key); } else { int count = vertices.Count; dictionary[key] = count; key3 = count; vertices.Add(vector3); } int num5; if (dictionary.TryGetValue(key2, out num5)) { dictionary.Remove(key2); } else { int count = vertices.Count; dictionary[key2] = count; num5 = count; vertices.Add(vector2); } dictionary2.Add(key3, num5); hashSet.Add(num5); } } } } GraphTransform transform = grid.transform; List <Vector3> vertexBuffer = ListPool <Vector3> .Claim(); RVONavmesh.CompressContour(dictionary2, hashSet, delegate(List <int> chain, bool cycle) { vertexBuffer.Clear(); Vector3 vector4 = vertices[chain[0]]; vertexBuffer.Add(vector4); for (int k = 1; k < chain.Count - 1; k++) { Vector3 vector5 = vertices[chain[k]]; Vector3 vector6 = vector5 - vector4; Vector3 vector7 = vertices[chain[k + 1]] - vector4; if (((Mathf.Abs(vector6.x) > 0.01f || Mathf.Abs(vector7.x) > 0.01f) && (Mathf.Abs(vector6.z) > 0.01f || Mathf.Abs(vector7.z) > 0.01f)) || Mathf.Abs(vector6.y) > 0.01f || Mathf.Abs(vector7.y) > 0.01f) { vertexBuffer.Add(vector5); } vector4 = vector5; } vertexBuffer.Add(vertices[chain[chain.Count - 1]]); Vector3[] array3 = vertexBuffer.ToArray(); transform.Transform(array3); callback(array3, cycle); }); ListPool <Vector3> .Release(vertexBuffer); ListPool <Vector3> .Release(vertices); } }
/// <summary> /// Applies transformation on the current pass. /// </summary> /// <param name="transform">The transform.</param> public void SetTransform(GraphTransform transform) { _g.TranslateTransform((float)transform.TranslateX, (float)transform.TranslateY); _g.ScaleTransform((float)transform.ScaleX, (float)transform.ScaleY); }
/// <summary> /// Set transform component from TRS matrix. /// </summary> /// <param name="transform">Transform component.</param> /// <param name="matrix">Transform matrix. This parameter is passed by reference /// to improve performance; no changes will be made to it.</param> public static void SetTransformFromMatrix(GraphTransform transform, ref Matrix4x4 matrix) { // transform.localPosition = ExtractTranslationFromMatrix(ref matrix); // transform.localRotation = ExtractRotationFromMatrix(ref matrix); // transform.localScale = ExtractScaleFromMatrix(ref matrix); }
// Token: 0x060026DC RID: 9948 internal abstract Rect GetBounds(GraphTransform transform);
public abstract Rect GetBounds(GraphTransform transform);
public override void OnSceneGUI(NavGraph target) { Event e = Event.current; var graph = target as GridGraph; graph.UpdateTransform(); var currentTransform = graph.transform * Matrix4x4.Scale(new Vector3(graph.width, 1, graph.depth)); if (e.type == EventType.MouseDown) { isMouseDown = true; } else if (e.type == EventType.MouseUp) { isMouseDown = false; } if (!isMouseDown) { savedTransform = currentTransform; savedDimensions = new Vector2(graph.width, graph.depth); savedNodeSize = graph.nodeSize; } Handles.matrix = Matrix4x4.identity; Handles.color = AstarColor.BoundsHandles; #if UNITY_5_5_OR_NEWER Handles.CapFunction cap = Handles.CylinderHandleCap; #else Handles.DrawCapFunction cap = Handles.CylinderCap; #endif var center = currentTransform.Transform(new Vector3(0.5f, 0, 0.5f)); if (Tools.current == Tool.Scale) { const float HandleScale = 0.1f; Vector3 mn = Vector3.zero; Vector3 mx = Vector3.zero; EditorGUI.BeginChangeCheck(); for (int i = 0; i < handlePoints.Length; i++) { var ps = currentTransform.Transform(handlePoints[i]); Vector3 p = savedTransform.InverseTransform(Handles.Slider(ps, ps - center, HandleScale * HandleUtility.GetHandleSize(ps), cap, 0)); // Snap to increments of whole nodes p.x = Mathf.Round(p.x * savedDimensions.x) / savedDimensions.x; p.z = Mathf.Round(p.z * savedDimensions.y) / savedDimensions.y; if (i == 0) { mn = mx = p; } else { mn = Vector3.Min(mn, p); mx = Vector3.Max(mx, p); } } if (EditorGUI.EndChangeCheck()) { graph.center = savedTransform.Transform((mn + mx) * 0.5f); graph.unclampedSize = Vector2.Scale(new Vector2(mx.x - mn.x, mx.z - mn.z), savedDimensions) * savedNodeSize; } } else if (Tools.current == Tool.Move) { EditorGUI.BeginChangeCheck(); center = Handles.PositionHandle(graph.center, Tools.pivotRotation == PivotRotation.Global ? Quaternion.identity : Quaternion.Euler(graph.rotation)); if (EditorGUI.EndChangeCheck() && Tools.viewTool != ViewTool.Orbit) { graph.center = center; } } else if (Tools.current == Tool.Rotate) { EditorGUI.BeginChangeCheck(); var rot = Handles.RotationHandle(Quaternion.Euler(graph.rotation), graph.center); if (EditorGUI.EndChangeCheck() && Tools.viewTool != ViewTool.Orbit) { graph.rotation = rot.eulerAngles; } } Handles.matrix = Matrix4x4.identity; }
/// <summary> /// Called when a requested path has been calculated. /// A path is first requested by <see cref="UpdatePath"/>, it is then calculated, probably in the same or the next frame. /// Finally it is returned to the seeker which forwards it to this function. /// </summary> protected override void OnPathComplete(Path newPath) { ABPath p = newPath as ABPath; if (p == null) { throw new System.Exception("This function only handles ABPaths, do not use special path types"); } waitingForPathCalculation = false; // Increase the reference count on the new path. // This is used for object pooling to reduce allocations. p.Claim(this); // Path couldn't be calculated of some reason. // More info in p.errorLog (debug string) if (p.error) { p.Release(this); return; } // Release the previous path. if (path != null) { path.Release(this); } // Replace the old path path = p; // Make sure the path contains at least 2 points if (path.vectorPath.Count == 1) { path.vectorPath.Add(path.vectorPath[0]); } interpolator.SetPath(path.vectorPath); var graph = path.path.Count > 0 ? AstarData.GetGraph(path.path[0]) as ITransformedGraph : null; var graphRotation = new Vector3(-90, 0, 0); movementPlane = new GraphTransform(Matrix4x4.TRS(Vector3.zero, Quaternion.Euler(graphRotation), Vector3.one)); // Reset some variables reachedEndOfPath = false; // Simulate movement from the point where the path was requested // to where we are right now. This reduces the risk that the agent // gets confused because the first point in the path is far away // from the current position (possibly behind it which could cause // the agent to turn around, and that looks pretty bad). interpolator.MoveToLocallyClosestPoint((GetFeetPosition() + p.originalStartPoint) * 0.5f); interpolator.MoveToLocallyClosestPoint(GetFeetPosition()); // Update which point we are moving towards. // Note that we need to do this here because otherwise the remainingDistance field might be incorrect for 1 frame. // (due to interpolator.remainingDistance being incorrect). interpolator.MoveToCircleIntersection2D(position, pickNextWaypointDist, movementPlane); var distanceToEnd = remainingDistance; if (distanceToEnd <= endReachedDistance) { reachedEndOfPath = true; OnTargetReached(); } }
// Token: 0x06002695 RID: 9877 RVA: 0x001A884F File Offset: 0x001A6A4F internal float GetY(GraphTransform transform) { return(transform.InverseTransform(this.useRotationAndScale ? this.tr.TransformPoint(this.center) : (this.tr.position + this.center)).y); }
/// <summary> /// Applies transformation on the current pass. /// </summary> /// <param name="transform">The transform.</param> public void SetTransform(GraphTransform transform) { _session.Transform = Matrix3x2.CreateTranslation(transform.TranslateX / transform.ScaleX, transform.TranslateY / transform.ScaleY) * Matrix3x2.CreateScale(transform.ScaleX, transform.ScaleY); }