Пример #1
0
    public static bool OverlapSphereBox(MySphereCollider sph, MyBoxCollider box)
    {
        Vector3 closestPointInAABB = Vector3.Min(Vector3.Max(sph.transform.position, box.Min), box.Max);
        float   distance           = Vector3.Distance(closestPointInAABB, sph.transform.position);

        return(distance < sph.Radius);
    }
Пример #2
0
    /// <summary>
    /// Check if the input body has corrected with a sphere
    /// </summary>
    /// <param name="body"></param>
    /// <param name="sphere"></param>
    /// <returns></returns>
    private MyCollision CollidedWithSphere(MyRigidBody body, MySphereCollider sphere)
    {
        // default to no collision
        MyCollision collision = null;

        // combined radius of both spheres
        float combinedRadius = this.distanceToSurface + ((MySphereCollider)sphere).radius;

        // the vector between the centres of the spheres
        Vector3 direction = sphere.transform.position - transform.position;

        // distance between centres
        float centreDistance = direction.magnitude;

        // normalise the direction
        direction /= centreDistance;

        // check interection
        if (centreDistance < combinedRadius)
        {
            // create a new collision object, containing the vector of the normal and the distance from the sphere
            collision = new MyCollision(this, sphere, new Vector3(transform.position.x, transform.position.y - ((MySphereCollider)body).radius, transform.position.z), direction, centreDistance);
        }

        return collision;
    }
    public override bool isColliding(MyCollider _other)
    {
        if (_other == null)
        {
            return(false);
        }
        if (_other is MySphereCollider)
        {
            MySphereCollider other    = (MySphereCollider)_other;
            float            distance = (this.Position - other.Position).sqrMagnitude;
            float            radii    = this.m_radius * transform.lossyScale.x + other.m_radius * other.transform.lossyScale.x;

            return(distance < (radii * radii));
        }
        else if (_other is MyBoxCollider)
        {
            MyBoxCollider other = (MyBoxCollider)_other;
            other.CalculateCubeCorners();
            Vector3 potentialAxis = this.Position - other.Position;
            potentialAxis = potentialAxis.normalized;

            float min1, max1, min2, max2;

            min1 = float.PositiveInfinity;
            max1 = float.NegativeInfinity;
            float tmp;
            for (int i = 0; i < other.CubeCorners.Length; i++)
            {
                tmp = Vector3.Dot(potentialAxis, other.cubeCorners[i]);
                if (tmp < min1)
                {
                    tmp = min1;
                }
                if (tmp > max1)
                {
                    max1 = tmp;
                }
            }

            min2 = float.PositiveInfinity;
            max2 = float.NegativeInfinity;

            tmp  = Vector3.Dot(potentialAxis, other.Position);
            min2 = tmp - this.ActualRadius;
            max2 = tmp + this.ActualRadius;

            if (min1 > min2 && min1 < max2)
            {
                return(true);
            }
            if (max1 > min2 && max1 < max2)
            {
                return(true);
            }
            return(false);
        }
        return(base.isColliding(_other));
    }
Пример #4
0
 /// <summary>
 /// Check for Sphere and Sphere
 /// </summary>
 /// <param name="_coll1"></param>
 /// <param name="_coll2"></param>
 /// <returns></returns>
 private MySphereCollider CheckForSph_Sph(MySphereCollider _coll1, MySphereCollider _coll2)
 {
     if (Collisions.SphereInSphere((Sphere)_coll1.Get(), (Sphere)_coll2.Get()))
     {
         return(_coll1);
     }
     else
     {
         return(null);
     }
 }
Пример #5
0
    private bool CheckForIntersectionBetweenSpherers(MySphereCollider s1, MySphereCollider s2)
    {
        float distance  = (s2.Center - s1.Center).magnitude;
        float radiusSum = s1.Radius + s2.Radius;

        if (distance < radiusSum)
        {
            return(true);
        }

        return(false);
    }
Пример #6
0
    void Start()
    {
        hasWon = false;

        hasDied = false;

        isInBlackHole = false;

        planetSphere = planetGO.GetComponentInChildren <MySphereCollider>().Sphere;

        collider = GetComponent <MySphereCollider>();

        scale = Helper.ConvertUnityVectorToMyVector(transform.localScale);

        rotation = Helper.ConvertUnityVectorToMyVector(transform.rotation.eulerAngles);

        center = Helper.ConvertUnityVectorToMyVector(transform.position);
    }
Пример #7
0
    private void ResolveCollisionForSphereres(MySphereCollider c1, MySphereCollider c2)
    {
        MyRigidbody r1 = c1.Rigidbody;
        MyRigidbody r2 = c2.Rigidbody;

        if (r1 != null && r2 != null)
        {
            Vector3 difference = c2.Center - c1.Center;
            Vector3 normal     = difference.normalized;

            Vector3 relativeVelocity = r2.Velocity - r1.Velocity;
            Vector3 normalVelocity   = normal * Vector3.Dot(normal, relativeVelocity);

            r1.Velocity += normalVelocity; //adapt force
            r2.Velocity -= normalVelocity;

            c2.Center = c1.Center + normal * (c1.Radius + c2.Radius); //separate by force, push c2 away from c1
        }
        else
        {
            throw new System.NotImplementedException("Resolution without 2 Rigidbodies is not implemented");
        }
    }
Пример #8
0
 private void Awake()
 {
     sphereCollider = GetComponent <MySphereCollider>();
 }
    public override bool isColliding(MyCollider _other)
    {
        if (_other == null)
        {
            return(false);
        }
        if (_other is MyBoxCollider)
        {
            MyBoxCollider other = (MyBoxCollider)_other;

            Vector3[] mySegment = new Vector3[]
            {
                m_cubeCorners[4] - m_cubeCorners[0],
                m_cubeCorners[3] - m_cubeCorners[0],
                m_cubeCorners[1] - m_cubeCorners[0],
            };

            Vector3[] otherSegments = new Vector3[]
            {
                other.m_cubeCorners[4] - other.m_cubeCorners[0],
                other.m_cubeCorners[3] - other.m_cubeCorners[0],
                other.m_cubeCorners[1] - other.m_cubeCorners[0],
            };

            Vector3[] potentialSeperatingAxis = new Vector3[]
            {
                Vector3.Cross(mySegment[0], mySegment[1]),
                Vector3.Cross(mySegment[0], mySegment[2]),
                Vector3.Cross(mySegment[1], mySegment[2]),

                Vector3.Cross(mySegment[0], mySegment[1]),
                Vector3.Cross(mySegment[0], mySegment[2]),
                Vector3.Cross(mySegment[1], mySegment[2]),

                Vector3.Cross(mySegment[0], mySegment[0]),
                Vector3.Cross(mySegment[0], mySegment[1]),
                Vector3.Cross(mySegment[0], mySegment[2]),
                Vector3.Cross(mySegment[1], mySegment[0]),
                Vector3.Cross(mySegment[1], mySegment[1]),
                Vector3.Cross(mySegment[1], mySegment[2]),
                Vector3.Cross(mySegment[1], mySegment[0]),
                Vector3.Cross(mySegment[1], mySegment[1]),
                Vector3.Cross(mySegment[1], mySegment[2]),
            };

            Vector3 normalizedAxis;
            float   min1, max1, min2, max2;
            float   tmp;
            foreach (Vector3 axis in potentialSeperatingAxis)
            {
                if (axis.sqrMagnitude == 0)
                {
                    continue;
                }
                normalizedAxis = axis.normalized;

                min1 = float.PositiveInfinity;
                max1 = float.NegativeInfinity;

                for (int i = 0; i < this.m_cubeCorners.Length; i++)
                {
                    tmp = Vector3.Dot(normalizedAxis, this.m_cubeCorners[i]);
                    if (tmp < min1)
                    {
                        min1 = tmp;
                    }
                    if (tmp > max1)
                    {
                        max1 = tmp;
                    }
                }
                min2 = float.PositiveInfinity;
                max2 = float.NegativeInfinity;

                for (int i = 0; i < other.m_cubeCorners.Length; i++)
                {
                    tmp = Vector3.Dot(normalizedAxis, this.m_cubeCorners[i]);
                    if (tmp < min2)
                    {
                        min2 = tmp;
                    }
                    if (tmp > max2)
                    {
                        max2 = tmp;
                    }
                }

                if (min1 > min2 && min1 < max2)
                {
                    continue;
                }
                if (max1 > min1 && max1 < max2)
                {
                    continue;
                }

                return(false);
            }

            return(true);
        }
        else if (_other is MySphereCollider)
        {
            this.CalculateCubeCorners();
            MySphereCollider other         = (MySphereCollider)_other;
            Vector3          potentialAxis = this.Position - other.Position;
            potentialAxis = potentialAxis.normalized;

            float min1, max1, min2, max2;

            min1 = float.PositiveInfinity;
            max1 = float.NegativeInfinity;
            float tmp;
            for (int i = 0; i < cubeCorners.Length; i++)
            {
                tmp = Vector3.Dot(potentialAxis, this.m_cubeCorners[i]);
                if (tmp < min1)
                {
                    tmp = min1;
                }
                if (tmp > max1)
                {
                    max1 = tmp;
                }
            }

            min2 = float.PositiveInfinity;
            max2 = float.NegativeInfinity;

            tmp  = Vector3.Dot(potentialAxis, other.Position);
            min2 = tmp - other.ActualRadius;
            max2 = tmp + other.ActualRadius;
            if (min1 > min2 && min1 < max2)
            {
                return(true);
            }
            if (max1 > min2 && max1 < max2)
            {
                return(true);
            }
            return(false);
        }
        return(base.isColliding(_other));
    }
Пример #10
0
    public static bool OverlapSphereSphere(MySphereCollider sphA, MySphereCollider sphB)
    {
        float distance = Vector3.Distance(sphA.transform.position, sphB.transform.position);

        return(distance < sphA.Radius + sphB.Radius);
    }
Пример #11
0
 public void AddSphere(MySphereCollider sphere)
 {
     spheres.Add(sphere);
 }
Пример #12
0
 public MyCollision(MySphereCollider colliderA, MySphereCollider colliderB, float distance)
 {
     this.colliderA = colliderA;
     this.colliderB = colliderB;
     this.distance  = distance;
 }