Пример #1
0
        void DrawGizmoBezier(Vector3 p1, Vector3 p2)
        {
            var dir = p2 - p1;

            if (dir == Vector3.zero)
            {
                return;
            }

            var normal   = Vector3.Cross(Vector3.up, dir);
            var normalUp = Vector3.Cross(dir, normal);

            normalUp  = normalUp.normalized;
            normalUp *= dir.magnitude * 0.1f;

            var p1c = p1 + normalUp;
            var p2c = p2 + normalUp;

            var prev = p1;

            for (var i = 1; i <= 20; i++)
            {
                var t = i / 20.0f;
                var p = AstarMath.CubicBezier(p1, p1c, p2c, p2, t);
                Gizmos.DrawLine(prev, p);
                prev = p;
            }
        }
Пример #2
0
        public override Vector3 ClosestPointOnNodeXZ(Vector3 _p)
        {
            INavmeshHolder navmeshHolder = GetNavmeshHolder(base.DataGroupIndex, base.GraphIndex);
            VInt3          vertex        = navmeshHolder.GetVertex(this.v0);
            VInt3          lineEnd       = navmeshHolder.GetVertex(this.v1);
            VInt3          num3          = navmeshHolder.GetVertex(this.v2);
            VInt3          point         = (VInt3)_p;
            int            y             = point.y;

            vertex.y  = 0;
            lineEnd.y = 0;
            num3.y    = 0;
            point.y   = 0;
            if ((((lineEnd.x - vertex.x) * (point.z - vertex.z)) - ((point.x - vertex.x) * (lineEnd.z - vertex.z))) > 0L)
            {
                float num6 = Mathf.Clamp01(AstarMath.NearestPointFactorXZ(vertex, lineEnd, point));
                return((Vector3)(new Vector3(vertex.x + ((lineEnd.x - vertex.x) * num6), (float)y, vertex.z + ((lineEnd.z - vertex.z) * num6)) * 0.001f));
            }
            if ((((num3.x - lineEnd.x) * (point.z - lineEnd.z)) - ((point.x - lineEnd.x) * (num3.z - lineEnd.z))) > 0L)
            {
                float num7 = Mathf.Clamp01(AstarMath.NearestPointFactorXZ(lineEnd, num3, point));
                return((Vector3)(new Vector3(lineEnd.x + ((num3.x - lineEnd.x) * num7), (float)y, lineEnd.z + ((num3.z - lineEnd.z) * num7)) * 0.001f));
            }
            if ((((vertex.x - num3.x) * (point.z - num3.z)) - ((point.x - num3.x) * (vertex.z - num3.z))) > 0L)
            {
                float num8 = Mathf.Clamp01(AstarMath.NearestPointFactorXZ(num3, vertex, point));
                return((Vector3)(new Vector3(num3.x + ((vertex.x - num3.x) * num8), (float)y, num3.z + ((vertex.z - num3.z) * num8)) * 0.001f));
            }
            return(_p);
        }
Пример #3
0
        public Vector3 GetMovementVector(Vector3 point)
        {
            if (this.vectorPath == null || this.vectorPath.Count == 0)
            {
                return(Vector3.zero);
            }
            if (this.vectorPath.Count == 1)
            {
                return(this.vectorPath[0] - point);
            }
            float num  = float.PositiveInfinity;
            int   num2 = 0;

            for (int i = 0; i < this.vectorPath.Count - 1; i++)
            {
                Vector3 a            = AstarMath.NearestPointStrict(this.vectorPath[i], this.vectorPath[i + 1], point);
                float   sqrMagnitude = (a - point).sqrMagnitude;
                if (sqrMagnitude < num)
                {
                    num  = sqrMagnitude;
                    num2 = i;
                }
            }
            return(this.vectorPath[num2 + 1] - point);
        }
Пример #4
0
        public override Vector3 ClosestPointOnNodeXZ(Vector3 _p)
        {
            INavmeshHolder navmeshHolder = TriangleMeshNode.GetNavmeshHolder(base.GraphIndex);
            Int3           vertex        = navmeshHolder.GetVertex(this.v0);
            Int3           vertex2       = navmeshHolder.GetVertex(this.v1);
            Int3           vertex3       = navmeshHolder.GetVertex(this.v2);
            Int3           point         = (Int3)_p;
            int            y             = point.y;

            vertex.y  = 0;
            vertex2.y = 0;
            vertex3.y = 0;
            point.y   = 0;
            if ((long)(vertex2.x - vertex.x) * (long)(point.z - vertex.z) - (long)(point.x - vertex.x) * (long)(vertex2.z - vertex.z) > 0L)
            {
                float num = Mathf.Clamp01(AstarMath.NearestPointFactor(vertex, vertex2, point));
                return(new Vector3((float)vertex.x + (float)(vertex2.x - vertex.x) * num, (float)y, (float)vertex.z + (float)(vertex2.z - vertex.z) * num) * 0.001f);
            }
            if ((long)(vertex3.x - vertex2.x) * (long)(point.z - vertex2.z) - (long)(point.x - vertex2.x) * (long)(vertex3.z - vertex2.z) > 0L)
            {
                float num2 = Mathf.Clamp01(AstarMath.NearestPointFactor(vertex2, vertex3, point));
                return(new Vector3((float)vertex2.x + (float)(vertex3.x - vertex2.x) * num2, (float)y, (float)vertex2.z + (float)(vertex3.z - vertex2.z) * num2) * 0.001f);
            }
            if ((long)(vertex.x - vertex3.x) * (long)(point.z - vertex3.z) - (long)(point.x - vertex3.x) * (long)(vertex.z - vertex3.z) > 0L)
            {
                float num3 = Mathf.Clamp01(AstarMath.NearestPointFactor(vertex3, vertex, point));
                return(new Vector3((float)vertex3.x + (float)(vertex.x - vertex3.x) * num3, (float)y, (float)vertex3.z + (float)(vertex.z - vertex3.z) * num3) * 0.001f);
            }
            return(_p);
        }
Пример #5
0
        void OnDrawGizmos(int boxi, int depth)
        {
            BBTreeBox box = arr[boxi];

            var min = (Vector3) new Int3(box.rect.xmin, 0, box.rect.ymin);
            var max = (Vector3) new Int3(box.rect.xmax, 0, box.rect.ymax);

            Vector3 center = (min + max) * 0.5F;
            Vector3 size   = (max - center) * 2;

            size      = new Vector3(size.x, 1, size.z);
            center.y += depth * 2;

            Gizmos.color = AstarMath.IntToColor(depth, 1f);             //new Color (0,0,0,0.2F);
            Gizmos.DrawCube(center, size);

            if (box.node != null)
            {
            }
            else
            {
                OnDrawGizmos(box.left, depth + 1);
                OnDrawGizmos(box.right, depth + 1);
            }
        }
Пример #6
0
        public static void SimplifyPath2(IRaycastableGraph rcg, List <GraphNode> nodes, int start, int end, List <GraphNode> result, Vector3 startPoint, Vector3 endPoint)
        {
            int count = result.Count;

            if (end <= start + 1)
            {
                result.Add(nodes[start]);
                result.Add(nodes[end]);
                return;
            }
            GraphHitInfo graphHitInfo;

            if (rcg.Linecast(startPoint, endPoint, nodes[start], out graphHitInfo, result) || result[result.Count - 1] != nodes[end])
            {
                result.RemoveRange(count, result.Count - count);
                int   num  = -1;
                float num2 = float.PositiveInfinity;
                for (int i = start + 1; i < end; i++)
                {
                    float num3 = AstarMath.DistancePointSegmentStrict(startPoint, endPoint, (Vector3)nodes[i].position);
                    if (num == -1 || num3 < num2)
                    {
                        num  = i;
                        num2 = num3;
                    }
                }
                RichFunnel.SimplifyPath2(rcg, nodes, start, num, result, startPoint, (Vector3)nodes[num].position);
                result.RemoveAt(result.Count - 1);
                RichFunnel.SimplifyPath2(rcg, nodes, num, end, result, (Vector3)nodes[num].position, endPoint);
            }
        }
Пример #7
0
        public virtual Color NodeColor(GraphNode node, PathHandler data)
        {
            Color result = AstarColor.NodeConnection;
            bool  flag   = false;

            if (node == null)
            {
                return(AstarColor.NodeConnection);
            }
            GraphDebugMode debugMode = AstarPath.active.debugMode;

            switch (debugMode)
            {
            case GraphDebugMode.Penalty:
                result = Color.Lerp(AstarColor.ConnectionLowLerp, AstarColor.ConnectionHighLerp, (node.Penalty - AstarPath.active.debugFloor) / (AstarPath.active.debugRoof - AstarPath.active.debugFloor));
                flag   = true;
                goto IL_A9;

            case GraphDebugMode.Connections:
IL_33:
                if (debugMode != GraphDebugMode.Areas)
                {
                    goto IL_A9;
                }
                result = AstarColor.GetAreaColor(node.Area);
                flag   = true;
                goto IL_A9;

            case GraphDebugMode.Tags:
                result = AstarMath.IntToColor((int)node.Tag, 0.5f);
                flag   = true;
                goto IL_A9;
            }
            goto IL_33;
IL_A9:
            if (!flag)
            {
                if (data == null)
                {
                    return(AstarColor.NodeConnection);
                }
                PathNode pathNode = data.GetPathNode(node);
                switch (AstarPath.active.debugMode)
                {
                case GraphDebugMode.G:
                    result = Color.Lerp(AstarColor.ConnectionLowLerp, AstarColor.ConnectionHighLerp, (pathNode.G - AstarPath.active.debugFloor) / (AstarPath.active.debugRoof - AstarPath.active.debugFloor));
                    break;

                case GraphDebugMode.H:
                    result = Color.Lerp(AstarColor.ConnectionLowLerp, AstarColor.ConnectionHighLerp, (pathNode.H - AstarPath.active.debugFloor) / (AstarPath.active.debugRoof - AstarPath.active.debugFloor));
                    break;

                case GraphDebugMode.F:
                    result = Color.Lerp(AstarColor.ConnectionLowLerp, AstarColor.ConnectionHighLerp, (pathNode.F - AstarPath.active.debugFloor) / (AstarPath.active.debugRoof - AstarPath.active.debugFloor));
                    break;
                }
            }
            result.a *= 0.5f;
            return(result);
        }
Пример #8
0
 public Vector3 Raycast(Vector3 origin, out RaycastHit hit, out bool walkable)
 {
     walkable = true;
     if (!this.heightCheck || this.use2D)
     {
         hit = default(RaycastHit);
         return(origin - this.up * this.fromHeight);
     }
     if (this.thickRaycast)
     {
         Ray ray = new Ray(origin, -this.up);
         if (Physics.SphereCast(ray, this.finalRaycastRadius, out hit, this.fromHeight + 0.005f, this.heightMask))
         {
             return(AstarMath.NearestPoint(ray.origin, ray.origin + ray.direction, hit.point));
         }
         walkable &= !this.unwalkableWhenNoGround;
     }
     else
     {
         if (Physics.Raycast(origin, -this.up, out hit, this.fromHeight + 0.005f, this.heightMask))
         {
             return(hit.point);
         }
         walkable &= !this.unwalkableWhenNoGround;
     }
     return(origin - this.up * this.fromHeight);
 }
Пример #9
0
        private void DrawGizmoBezier(Vector3 p1, Vector3 p2)
        {
            Vector3 dir = p2 - p1;

            if (dir == Vector3.zero)
            {
                return;
            }

            Vector3 normal   = Vector3.Cross(Vector3.up, dir);
            Vector3 normalUp = Vector3.Cross(dir, normal);

            normalUp  = normalUp.normalized;
            normalUp *= dir.magnitude * 0.1f;

            Vector3 p1c = p1 + normalUp;
            Vector3 p2c = p2 + normalUp;

            Vector3 prev = p1;

            for (int i = 1; i <= 20; i++)
            {
                float   t = i / 20.0f;
                Vector3 p = AstarMath.CubicBezier(p1, p1c, p2c, p2, t);
                Gizmos.DrawLine(prev, p);
                prev = p;
            }
        }
Пример #10
0
        /** Returns the position with the correct height.
         * If #heightCheck is false, this will return \a position.\n
         * \a walkable will be set to false if nothing was hit.
         * The ray will check a tiny bit further than to the grids base to avoid floating point errors when the ground is exactly at the base of the grid */
        public Vector3 CheckHeight(Vector3 position, out RaycastHit hit, out bool walkable)
        {
            walkable = true;

            if (!heightCheck || use2D)
            {
                hit = new RaycastHit();
                return(position);
            }

            if (thickRaycast)
            {
                var ray = new Ray(position + up * fromHeight, -up);
                if (Physics.SphereCast(ray, finalRaycastRadius, out hit, fromHeight + 0.005F, heightMask))
                {
                    return(AstarMath.NearestPoint(ray.origin, ray.origin + ray.direction, hit.point));
                }

                walkable &= unwalkableWhenNoGround;
            }
            else
            {
                // Cast a ray from above downwards to try to find the ground
                if (Physics.Raycast(position + up * fromHeight, -up, out hit, fromHeight + 0.005F, heightMask))
                {
                    return(hit.point);
                }

                walkable &= unwalkableWhenNoGround;
            }
            return(position);
        }
Пример #11
0
        /** Same as #CheckHeight, except that the raycast will always start exactly at \a origin.
         * \a walkable will be set to false if nothing was hit.
         * The ray will check a tiny bit further than to the grids base to avoid floating point errors when the ground is exactly at the base of the grid */
        public Vector3 Raycast(Vector3 origin, out RaycastHit hit, out bool walkable)
        {
            walkable = true;

            if (!heightCheck || use2D)
            {
                hit = new RaycastHit();
                return(origin - up * fromHeight);
            }

            if (thickRaycast)
            {
                var ray = new Ray(origin, -up);
                if (Physics.SphereCast(ray, finalRaycastRadius, out hit, fromHeight + 0.005F, heightMask))
                {
                    return(AstarMath.NearestPoint(ray.origin, ray.origin + ray.direction, hit.point));
                }

                walkable &= unwalkableWhenNoGround;
            }
            else
            {
                if (Physics.Raycast(origin, -up, out hit, fromHeight + 0.005F, heightMask))
                {
                    return(hit.point);
                }

                walkable &= unwalkableWhenNoGround;
            }
            return(origin - up * fromHeight);
        }
Пример #12
0
        public static void PrintResults()
        {
            TimeSpan      timeSpan      = DateTime.UtcNow - AstarProfiler.startTime;
            StringBuilder stringBuilder = new StringBuilder();

            stringBuilder.Append("============================\n\t\t\t\tProfile results:\n============================\n");
            int num = 5;

            foreach (KeyValuePair <string, AstarProfiler.ProfilePoint> current in AstarProfiler.profiles)
            {
                num = Math.Max(current.Key.Length, num);
            }
            stringBuilder.Append(" Name ".PadRight(num)).Append("|").Append(" Total Time\t".PadRight(20)).Append("|").Append(" Total Calls ".PadRight(20)).Append("|").Append(" Avg/Call ".PadRight(20));
            foreach (KeyValuePair <string, AstarProfiler.ProfilePoint> current2 in AstarProfiler.profiles)
            {
                double totalMilliseconds = current2.Value.watch.Elapsed.TotalMilliseconds;
                int    totalCalls        = current2.Value.totalCalls;
                if (totalCalls >= 1)
                {
                    string key = current2.Key;
                    stringBuilder.Append("\n").Append(key.PadRight(num)).Append("| ");
                    stringBuilder.Append(totalMilliseconds.ToString("0.0").PadRight(20)).Append("| ");
                    stringBuilder.Append(totalCalls.ToString().PadRight(20)).Append("| ");
                    stringBuilder.Append((totalMilliseconds / (double)totalCalls).ToString("0.000").PadRight(20));
                    stringBuilder.Append(AstarMath.FormatBytesBinary((int)current2.Value.totalBytes).PadLeft(10));
                }
            }
            stringBuilder.Append("\n\n============================\n\t\tTotal runtime: ");
            stringBuilder.Append(timeSpan.TotalSeconds.ToString("F3"));
            stringBuilder.Append(" seconds\n============================");
            Debug.Log(stringBuilder.ToString());
        }
Пример #13
0
        //Movement stuff

        /** Returns in which direction to move from a point on the path.
         * A simple and quite slow (well, compared to more optimized algorithms) algorithm first finds the closest path segment (from #vectorPath) and then returns
         * the direction to the next point from there. The direction is not normalized.
         * \returns Direction to move from a \a point, returns Vector3.zero if #vectorPath is null or has a length of 0 */
        public Vector3 GetMovementVector(Vector3 point)
        {
            if (vectorPath == null || vectorPath.Count == 0)
            {
                return(Vector3.zero);
            }

            if (vectorPath.Count == 1)
            {
                return(vectorPath[0] - point);
            }

            float minDist    = float.PositiveInfinity;         //Mathf.Infinity;
            int   minSegment = 0;

            for (int i = 0; i < vectorPath.Count - 1; i++)
            {
                Vector3 closest = AstarMath.NearestPointStrict(vectorPath[i], vectorPath[i + 1], point);
                float   dist    = (closest - point).sqrMagnitude;
                if (dist < minDist)
                {
                    minDist    = dist;
                    minSegment = i;
                }
            }

            return(vectorPath[minSegment + 1] - point);
        }
Пример #14
0
 public Vector3 CheckHeight(Vector3 position, out RaycastHit hit, out bool walkable)
 {
     walkable = true;
     if (!this.heightCheck || this.use2D)
     {
         hit = default(RaycastHit);
         return(position);
     }
     if (this.thickRaycast)
     {
         Ray ray;
         ray..ctor(position + this.up * this.fromHeight, -this.up);
         if (Physics.SphereCast(ray, this.finalRaycastRadius, ref hit, this.fromHeight + 0.005f, this.heightMask))
         {
             return(AstarMath.NearestPoint(ray.origin, ray.origin + ray.direction, hit.point));
         }
         if (this.unwalkableWhenNoGround)
         {
             walkable = false;
         }
     }
     else
     {
         if (Physics.Raycast(position + this.up * this.fromHeight, -this.up, ref hit, this.fromHeight + 0.005f, this.heightMask))
         {
             return(hit.point);
         }
         if (this.unwalkableWhenNoGround)
         {
             walkable = false;
         }
     }
     return(position);
 }
Пример #15
0
        public static void PrintResults()
        {
            TimeSpan      span    = (TimeSpan)(DateTime.UtcNow - startTime);
            StringBuilder builder = new StringBuilder();

            builder.Append("============================\n\t\t\t\tProfile results:\n============================\n");
            int num = 5;

            foreach (KeyValuePair <string, ProfilePoint> pair in profiles)
            {
                num = Math.Max(pair.Key.Length, num);
            }
            builder.Append(" Name ".PadRight(num)).Append("|").Append(" Total Time\t".PadRight(20)).Append("|").Append(" Total Calls ".PadRight(20)).Append("|").Append(" Avg/Call ".PadRight(20));
            foreach (KeyValuePair <string, ProfilePoint> pair2 in profiles)
            {
                double totalMilliseconds = pair2.Value.watch.Elapsed.TotalMilliseconds;
                int    totalCalls        = pair2.Value.totalCalls;
                if (totalCalls >= 1)
                {
                    string key = pair2.Key;
                    builder.Append("\n").Append(key.PadRight(num)).Append("| ");
                    builder.Append(totalMilliseconds.ToString("0.0").PadRight(20)).Append("| ");
                    builder.Append(totalCalls.ToString().PadRight(20)).Append("| ");
                    double num4 = totalMilliseconds / ((double)totalCalls);
                    builder.Append(num4.ToString("0.000").PadRight(20));
                    builder.Append(AstarMath.FormatBytesBinary((int)pair2.Value.totalBytes).PadLeft(10));
                }
            }
            builder.Append("\n\n============================\n\t\tTotal runtime: ");
            builder.Append(span.TotalSeconds.ToString("F3"));
            builder.Append(" seconds\n============================");
            UnityEngine.Debug.Log(builder.ToString());
        }
Пример #16
0
 public static Color GetAreaColor(uint area)
 {
     if (AstarColor.AreaColors == null || (ulong)area >= (ulong)((long)AstarColor.AreaColors.Length))
     {
         return(AstarMath.IntToColor((int)area, 1f));
     }
     return(AstarColor.AreaColors[(int)area]);
 }
Пример #17
0
 public static Color GetAreaColor(uint area)
 {
     if ((AreaColors != null) && (area < AreaColors.Length))
     {
         return(AreaColors[area]);
     }
     return(AstarMath.IntToColor((int)area, 1f));
 }
Пример #18
0
 /** Returns an color for an area, uses both user set ones and calculated.
  * If the user has set a color for the area, it is used, but otherwise the color is calculated using Mathfx.IntToColor
  * \see #AreaColors */
 public static Color GetAreaColor(uint area)
 {
     if (AreaColors == null || area >= AreaColors.Length)
     {
         return(AstarMath.IntToColor((int)area, 1F));
     }
     return(AreaColors[(int)area]);
 }
Пример #19
0
        public static Color IntToColor(int i, float a)
        {
            int num  = AstarMath.Bit(i, 1) + AstarMath.Bit(i, 3) * 2 + 1;
            int num2 = AstarMath.Bit(i, 2) + AstarMath.Bit(i, 4) * 2 + 1;
            int num3 = AstarMath.Bit(i, 0) + AstarMath.Bit(i, 5) * 2 + 1;

            return(new Color((float)num * 0.25f, (float)num2 * 0.25f, (float)num3 * 0.25f, a));
        }
Пример #20
0
        public static float DistancePointSegment2(int x, int z, int px, int pz, int qx, int qz)
        {
            Vector3 p = new Vector3((float)x, 0f, (float)z);
            Vector3 a = new Vector3((float)px, 0f, (float)pz);
            Vector3 b = new Vector3((float)qx, 0f, (float)qz);

            return(AstarMath.DistancePointSegment2(a, b, p));
        }
Пример #21
0
        public static void PrintResults()
        {
            TimeSpan endTime = DateTime.UtcNow - startTime;
            var      output  = new System.Text.StringBuilder();

            output.Append("============================\n\t\t\t\tProfile results:\n============================\n");

            int maxLength = 5;

            foreach (KeyValuePair <string, ProfilePoint> pair in profiles)
            {
                maxLength = Math.Max(pair.Key.Length, maxLength);
            }

            output.Append(" Name ".PadRight(maxLength)).
            Append("|").Append(" Total Time	".PadRight(20)).
            Append("|").Append(" Total Calls ".PadRight(20)).
            Append("|").Append(" Avg/Call ".PadRight(20));



            foreach (var pair in profiles)
            {
                double totalTime  = pair.Value.watch.Elapsed.TotalMilliseconds;
                int    totalCalls = pair.Value.totalCalls;
                if (totalCalls < 1)
                {
                    continue;
                }

                string name = pair.Key;

                output.Append("\n").Append(name.PadRight(maxLength)).Append("| ");
                output.Append(totalTime.ToString("0.0").PadRight(20)).Append("| ");
                output.Append(totalCalls.ToString().PadRight(20)).Append("| ");
                output.Append((totalTime / totalCalls).ToString("0.000").PadRight(20));
                output.Append(AstarMath.FormatBytesBinary((int)pair.Value.totalBytes).PadLeft(10));

                /*output.Append("\nProfile ");
                 * output.Append(pair.Key);
                 * output.Append(" took ");
                 * output.Append(totalTime.ToString("0"));
                 * output.Append(" ms to complete over ");
                 * output.Append(totalCalls);
                 * output.Append(" iteration");
                 * if (totalCalls != 1) output.Append("s");
                 * output.Append(", averaging ");
                 * output.Append((totalTime / totalCalls).ToString("0.0"));
                 * output.Append(" ms per call");*/
            }
            output.Append("\n\n============================\n\t\tTotal runtime: ");
            output.Append(endTime.TotalSeconds.ToString("F3"));
            output.Append(" seconds\n============================");
            Debug.Log(output.ToString());
        }
Пример #22
0
        public List <Vector3> SmoothBezier(List <Vector3> path)
        {
            if (subdivisions < 0)
            {
                subdivisions = 0;
            }

            int            subMult    = 1 << subdivisions;
            List <Vector3> subdivided = ListPool <Vector3> .Claim();

            //new Vector3[(path.Length-1)*(int)subMult+1];

            for (int i = 0; i < path.Count - 1; i++)
            {
                Vector3 tangent1 = Vector3.zero;
                Vector3 tangent2 = Vector3.zero;
                if (i == 0)
                {
                    tangent1 = path[i + 1] - path[i];
                }
                else
                {
                    tangent1 = path[i + 1] - path[i - 1];
                }

                if (i == path.Count - 2)
                {
                    tangent2 = path[i] - path[i + 1];
                }
                else
                {
                    tangent2 = path[i] - path[i + 2];
                }

                tangent1 *= bezierTangentLength;
                tangent2 *= bezierTangentLength;

                Vector3 v1 = path[i];
                Vector3 v2 = v1 + tangent1;
                Vector3 v4 = path[i + 1];
                Vector3 v3 = v4 + tangent2;


                for (int j = 0; j < subMult; j++)
                {
                    subdivided.Add(AstarMath.CubicBezier(v1, v2, v3, v4, (float)j / subMult));
                }
            }

            //Assign the last point
            subdivided.Add(path[path.Count - 1]);

            return(subdivided);
        }
Пример #23
0
        public virtual Color NodeColor(GraphNode node, PathHandler data)
        {
            Color          result    = AstarColor.NodeConnection;
            GraphDebugMode debugMode = AstarPath.active.debugMode;

            switch (debugMode)
            {
            case GraphDebugMode.Penalty:
                result = Color.Lerp(AstarColor.ConnectionLowLerp, AstarColor.ConnectionHighLerp, (node.Penalty - AstarPath.active.debugFloor) / (AstarPath.active.debugRoof - AstarPath.active.debugFloor));
                goto IL_18C;

            case GraphDebugMode.Connections:
            {
IL_25:
                if (debugMode == GraphDebugMode.Areas)
                {
                    result = AstarColor.GetAreaColor(node.Area);
                    goto IL_18C;
                }
                if (data == null)
                {
                    return(AstarColor.NodeConnection);
                }
                PathNode pathNode = data.GetPathNode(node);
                switch (AstarPath.active.debugMode)
                {
                case GraphDebugMode.G:
                    result = Color.Lerp(AstarColor.ConnectionLowLerp, AstarColor.ConnectionHighLerp, (pathNode.G - AstarPath.active.debugFloor) / (AstarPath.active.debugRoof - AstarPath.active.debugFloor));
                    break;

                case GraphDebugMode.H:
                    result = Color.Lerp(AstarColor.ConnectionLowLerp, AstarColor.ConnectionHighLerp, (pathNode.H - AstarPath.active.debugFloor) / (AstarPath.active.debugRoof - AstarPath.active.debugFloor));
                    break;

                case GraphDebugMode.F:
                    result = Color.Lerp(AstarColor.ConnectionLowLerp, AstarColor.ConnectionHighLerp, (pathNode.F - AstarPath.active.debugFloor) / (AstarPath.active.debugRoof - AstarPath.active.debugFloor));
                    break;
                }
                goto IL_18C;
            }

            case GraphDebugMode.Tags:
                result = AstarMath.IntToColor((int)node.Tag, 0.5f);
                goto IL_18C;
            }
            goto IL_25;
IL_18C:
            result.a *= 0.5f;
            return(result);
        }
Пример #24
0
        /* Color to use for gizmos.
         * Returns a color to be used for the specified node with the current debug settings (editor only).
         *
         * \version Since 3.6.1 this method will not handle null nodes
         */
        public virtual Color NodeColor(GraphNode node, PathHandler data)
        {
        #if !PhotonImplementation
            Color c = AstarColor.NodeConnection;

            switch (AstarPath.active.debugMode)
            {
            case GraphDebugMode.Areas:
                c = AstarColor.GetAreaColor(node.Area);
                break;

            case GraphDebugMode.Penalty:
                c = Color.Lerp(AstarColor.ConnectionLowLerp, AstarColor.ConnectionHighLerp, ((float)node.Penalty - AstarPath.active.debugFloor) / (AstarPath.active.debugRoof - AstarPath.active.debugFloor));
                break;

            case GraphDebugMode.Tags:
                c = AstarMath.IntToColor((int)node.Tag, 0.5F);
                break;

            default:
                if (data == null)
                {
                    return(AstarColor.NodeConnection);
                }

                PathNode nodeR = data.GetPathNode(node);

                switch (AstarPath.active.debugMode)
                {
                case GraphDebugMode.G:
                    c = Color.Lerp(AstarColor.ConnectionLowLerp, AstarColor.ConnectionHighLerp, ((float)nodeR.G - AstarPath.active.debugFloor) / (AstarPath.active.debugRoof - AstarPath.active.debugFloor));
                    break;

                case GraphDebugMode.H:
                    c = Color.Lerp(AstarColor.ConnectionLowLerp, AstarColor.ConnectionHighLerp, ((float)nodeR.H - AstarPath.active.debugFloor) / (AstarPath.active.debugRoof - AstarPath.active.debugFloor));
                    break;

                case GraphDebugMode.F:
                    c = Color.Lerp(AstarColor.ConnectionLowLerp, AstarColor.ConnectionHighLerp, ((float)nodeR.F - AstarPath.active.debugFloor) / (AstarPath.active.debugRoof - AstarPath.active.debugFloor));
                    break;
                }
                break;
            }

            c.a *= 0.5F;
            return(c);
        #else
            return(new Color(1, 1, 1));
        #endif
        }
Пример #25
0
 public static void Log()
 {
     System.Text.StringBuilder output = new System.Text.StringBuilder();
     output.Append("============================\n\t\t\t\tSize Profile results:\n============================\n");
     //foreach(KeyValuePair<string, ProfilePoint> pair in profiles)
     foreach (KeyValuePair <string, ProfileSizePoint> pair in profiles)
     {
         output.Append(pair.Key);
         output.Append("	used	");
         output.Append(AstarMath.FormatBytes((int)pair.Value.totalSize));
         output.Append("\n");
     }
     Debug.Log(output.ToString());
 }
Пример #26
0
        public static void SimplifyPath3(IRaycastableGraph rcg, List <GraphNode> nodes, int start, int end, List <GraphNode> result, Vector3 startPoint, Vector3 endPoint, int depth = 0)
        {
            if (start == end)
            {
                result.Add(nodes[start]);
                return;
            }
            if (start + 1 == end)
            {
                result.Add(nodes[start]);
                result.Add(nodes[end]);
                return;
            }
            int          count = result.Count;
            GraphHitInfo graphHitInfo;

            if (rcg.Linecast(startPoint, endPoint, nodes[start], out graphHitInfo, result) || result[result.Count - 1] != nodes[end])
            {
                result.RemoveRange(count, result.Count - count);
                int   num  = 0;
                float num2 = 0f;
                for (int i = start + 1; i < end - 1; i++)
                {
                    float num3 = AstarMath.DistancePointSegmentStrict(startPoint, endPoint, (Vector3)nodes[i].position);
                    if (num3 > num2)
                    {
                        num  = i;
                        num2 = num3;
                    }
                }
                int num4 = (num + start) / 2;
                int num5 = (num + end) / 2;
                if (num4 == num5)
                {
                    RichFunnel.SimplifyPath3(rcg, nodes, start, num4, result, startPoint, (Vector3)nodes[num4].position, 0);
                    result.RemoveAt(result.Count - 1);
                    RichFunnel.SimplifyPath3(rcg, nodes, num4, end, result, (Vector3)nodes[num4].position, endPoint, depth + 1);
                }
                else
                {
                    RichFunnel.SimplifyPath3(rcg, nodes, start, num4, result, startPoint, (Vector3)nodes[num4].position, depth + 1);
                    result.RemoveAt(result.Count - 1);
                    RichFunnel.SimplifyPath3(rcg, nodes, num4, num5, result, (Vector3)nodes[num4].position, (Vector3)nodes[num5].position, depth + 1);
                    result.RemoveAt(result.Count - 1);
                    RichFunnel.SimplifyPath3(rcg, nodes, num5, end, result, (Vector3)nodes[num5].position, endPoint, depth + 1);
                }
            }
        }
Пример #27
0
        private void OnDrawGizmos(int boxi, int depth)
        {
            BBTree.BBTreeBox bBTreeBox = this.arr[boxi];
            Vector3          a         = new Vector3(bBTreeBox.rect.xMin, 0f, bBTreeBox.rect.yMin);
            Vector3          vector    = new Vector3(bBTreeBox.rect.xMax, 0f, bBTreeBox.rect.yMax);
            Vector3          vector2   = (a + vector) * 0.5f;
            Vector3          size      = (vector - vector2) * 2f;

            vector2.y   += (float)depth * 0.2f;
            Gizmos.color = AstarMath.IntToColor(depth, 0.05f);
            Gizmos.DrawCube(vector2, size);
            if (bBTreeBox.node == null)
            {
                this.OnDrawGizmos(bBTreeBox.left, depth + 1);
                this.OnDrawGizmos(bBTreeBox.right, depth + 1);
            }
        }
Пример #28
0
        private void OnDrawGizmos(int boxi, int depth)
        {
            BBTreeBox box     = this.arr[boxi];
            Vector3   vector  = new Vector3(box.rect.xMin, 0f, box.rect.yMin);
            Vector3   vector2 = new Vector3(box.rect.xMax, 0f, box.rect.yMax);
            Vector3   center  = (Vector3)((vector + vector2) * 0.5f);
            Vector3   size    = (Vector3)((vector2 - center) * 2f);

            center.y    += depth * 0.2f;
            Gizmos.color = AstarMath.IntToColor(depth, 0.05f);
            Gizmos.DrawCube(center, size);
            if (box.node == null)
            {
                this.OnDrawGizmos(box.left, depth + 1);
                this.OnDrawGizmos(box.right, depth + 1);
            }
        }
Пример #29
0
        private void OnDrawGizmos(int boxi, int depth)
        {
            BBTree.BBTreeBox bbtreeBox = this.tree[boxi];
            Vector3          a         = (Vector3) new Int3(bbtreeBox.rect.xmin, 0, bbtreeBox.rect.ymin);
            Vector3          vector    = (Vector3) new Int3(bbtreeBox.rect.xmax, 0, bbtreeBox.rect.ymax);
            Vector3          vector2   = (a + vector) * 0.5f;
            Vector3          size      = (vector - vector2) * 2f;

            size         = new Vector3(size.x, 1f, size.z);
            vector2.y   += (float)(depth * 2);
            Gizmos.color = AstarMath.IntToColor(depth, 1f);
            Gizmos.DrawCube(vector2, size);
            if (!bbtreeBox.IsLeaf)
            {
                this.OnDrawGizmos(bbtreeBox.left, depth + 1);
                this.OnDrawGizmos(bbtreeBox.right, depth + 1);
            }
        }
Пример #30
0
        private void OnDrawGizmos(int boxi, int depth)
        {
            BBTreeBox box     = this.arr[boxi];
            Vector3   vector  = (Vector3) new Int3(box.rect.xmin, 0, box.rect.ymin);
            Vector3   vector2 = (Vector3) new Int3(box.rect.xmax, 0, box.rect.ymax);
            Vector3   center  = (Vector3)((vector + vector2) * 0.5f);
            Vector3   size    = (Vector3)((vector2 - center) * 2f);

            size         = new Vector3(size.x, 1f, size.z);
            center.y    += depth * 2;
            Gizmos.color = AstarMath.IntToColor(depth, 1f);
            Gizmos.DrawCube(center, size);
            if (box.node == null)
            {
                this.OnDrawGizmos(box.left, depth + 1);
                this.OnDrawGizmos(box.right, depth + 1);
            }
        }