C# Vector2.Max方法代码示例

        //Calculate bounds, and reset indices
        internal void Prepare()
        {
            Vector2 left, right;
            _boxMin = new Vector2(0);
            _boxMax = new Vector2(0);

            foreach (CollisionPlane plane in _planes)
            {
                //Normalize plane direction

                //Get bounds
                left = plane.PointLeft;
                right = plane.PointRight;

                _boxMin.Min(left);
                _boxMin.Min(right);
                _boxMax.Max(left);
                _boxMax.Max(right);

                //Reset encode indices
                plane._encodeIndex = -1;
                if (plane._linkLeft != null)
                    plane._linkLeft._encodeIndex = -1;
                if (plane._linkRight != null)
                    plane._linkRight._encodeIndex = -1;
            }
        }

        /// <summary>
        /// Return the closest point to 'point' that lies on the surface of the primitive.
        /// If that point is inside the primitive, sign is negative.
        /// </summary>
        public void ClosestSurfacePoint( Vector2 point, out Vector2 ret, out float sign )
        {
            Vector2 closest = point.Max( Min ).Min( Max );

            if ( closest != point )
            {
                ret = closest;
                sign = 1.0f;
                return;
            }

            Vector2 l = closest; l.X = Min.X; float dl = closest.X - Min.X;
            Vector2 r = closest; r.X = Max.X; float dr = Max.X - closest.X;
            Vector2 t = closest; t.Y = Min.Y; float dt = closest.Y - Min.Y;
            Vector2 b = closest; b.Y = Max.Y; float db = Max.Y - closest.Y;

            ret = l;
            float d = dl;

            if ( d > dr )
            {
                ret = r;
                d = dr;
            }

            if ( d > dt )
            {
                ret = t;
                d = dt;
            }

            if ( d > db )
            {
                ret = b;
                d = db;
            }

            sign = -1.0f;
        }

 /// <summary>
 /// Return true if 'point' is inside the primitive (in its negative space).
 /// </summary>
 public bool IsInside( Vector2 point )
 {
     return point == point.Max( Min ).Min( Max );
 }

 /// <summary>
 /// Create a Bounds2 that goes through 2 points, the min and max are recalculated.
 /// </summary>
 /// <param name="min">First point.</param>
 /// <param name="max">Second point.</param>
 public static Bounds2 SafeBounds( Vector2 min, Vector2 max )
 {
     return new Bounds2( min.Min( max ), min.Max( max ) );
 }