コード例 #1
0
        public static bool ShiftCollision(Vector3 planeChange)
        {
            for (int i = 0; i < groundsArray.Length; i++)
            {
                groundBoundingBox = groundsArray[i].BoundingBox;
                var groundMin = groundBoundingBox.Center - new Vector3(groundBoundingBox.HalfWidth, groundBoundingBox.HalfHeight);
                var pBoundingBox = player.BoundingBox;
                var unitMax = pBoundingBox.Center + new Vector3(pBoundingBox.HalfWidth, pBoundingBox.HalfHeight) + pBoundingBox.Velocity * Time.deltaTime;
                if (groundMin.x > unitMax.x)
                {
                    break;
                }

                var BoundingBoxCenter = pBoundingBox.Center + planeChange;
                AABB3D checkBoundingBox = new AABB3D(BoundingBoxCenter, pBoundingBox.HalfWidth * 2,
                    pBoundingBox.HalfHeight * 2, pBoundingBox.HalfDepth * 2);
                if (aabbIntersection.Intersect(groundBoundingBox, checkBoundingBox))
                {
                    return false;
                }
                //if (Math.Abs(groundBoundingBox.Center.z - (playerBoundingBox.Center.z + planeChange.z))
                //	> (groundBoundingBox.HalfDepth + playerBoundingBox.HalfDepth))
                //	return false;
            }
            return true;
        }
コード例 #2
0
ファイル: Sweep.cs プロジェクト: Zerophase/DyMProject
        private void normalCollision(AABB3D movingBox, AABB3D b0, AABB3D b1)
        {
            resetNormals(b0);

            wy = (movingBox.HalfWidth * 2 + b1.HalfWidth * 2) * (movingBox.Center.y - b1.Center.y);
            hx = (movingBox.HalfHeight * 2 + b1.HalfHeight * 2) * (movingBox.Center.x - b1.Center.x);

            if (wy > hx)
            {
                if (wy > -hx && b1.IgnoreCollision != IgnoreCollision.Y_AXIS)
                {
                    b0.NormalCollision[1] = Vector3.down;
                }
                else if(b1.IgnoreCollision != IgnoreCollision.X_AXIS)
                {
                    b0.NormalCollision[0] = Vector3.right;
                }
            }
            else
            {
                if (wy > -hx && b1.IgnoreCollision != IgnoreCollision.X_AXIS)
                {
                    b0.NormalCollision[0] = Vector3.left;
                }
                else if(b1.IgnoreCollision != IgnoreCollision.Y_AXIS)
                {
                    b0.NormalCollision[1] = Vector3.up;
                }
            }
        }
コード例 #3
0
        protected override void Start()
        {
            // TODO remove player checks from this class once a better solution than flipping the elbo is found
            if (this is Player)
            {
                playerWrist = GameObject.FindGameObjectWithTag("GunRotator");
                gunFlip = playerWrist.GetComponent<Gun>();
            }

            var boxCollider = gameObject.GetComponent<BoxCollider>();
            rotationBox = new AABB3D(Vector3.zero,
                boxCollider.size.x * transform.lossyScale.x,
                boxCollider.size.y * transform.lossyScale.y,
                boxCollider.size.z * transform.lossyScale.z);
            if (transform.GetChild(preventDeformation).name == "PreventDeformedObject")
            {
                findModelWithDeformationProtection();
            }
            else
            {
                findModelWithoutDeformationProtection();
            }

            base.Start();
        }
コード例 #4
0
ファイル: Sweep.cs プロジェクト: Zerophase/DyMProject
        public bool TestMovingAABB(AABB3D b0, Vector3 d, float time0, float time1,
			AABB3D b1, ref float time)
        {
            float mid = (time0 + time1) * 0.5f;
            float midTest = mid - time0;
            Vector3 adjustedD = d * mid;
            //Debug.Log("Time tested: " + centerTest);
            b.Center = b0.Center + adjustedD;
            b.HalfWidths[0] = midTest * d.magnitude + b0.HalfWidth;
            b.HalfWidths[1] = midTest * d.magnitude + b0.HalfHeight;
            b.HalfWidths[2] = midTest * d.magnitude + b0.HalfDepth;
            //b = new AABB3D(b0.Center + adjustedD, midTest * d.magnitude
            //	+ (b0.HalfWidth * 2), midTest * d.magnitude
            //	+ (b0.HalfHeight * 2), midTest * d.magnitude
            //	+ (b0.HalfDepth * 2));
            //Debug.Log(b);

            //intervalHalvedRects.Add(b);
            //b0.DrawBoundingBox(Color.green);
            //foreach (var rects in intervalHalvedRects)
            //{
            //	rects.DrawBoundingBox(Color.red);
            //}
            if (!aabbIntersection.Intersect(b, b1))
                return false;

            if (time1 - time0 < 0.1f)
            {
                normalCollision(b, b0, b1);
                time = time0;
                return true;
            }

            if (TestMovingAABB(b0, d, time0, mid, b1, ref time))
                return true;

            return TestMovingAABB(b0, d, mid, time1, b1, ref time);
        }
コード例 #5
0
ファイル: Sweep.cs プロジェクト: Zerophase/DyMProject
 private void resetNormals(AABB3D checkedObject)
 {
     for (int i = 0; i < checkedObject.NormalCollision.Length; i++)
     {
         checkedObject.NormalCollision[i] = Vector3.zero;
     }
 }
コード例 #6
0
ファイル: AABB3D.cs プロジェクト: Zerophase/DyMProject
        public void UpdateAABB(AABB3D a, float[][] m, Vector3 t, ref AABB3D b)
        {
            Vector3 modify = b.Center;
            modify.x = t.x;
            modify.y = t.y;
            modify.z = t.z;
            b.HalfHeight = 0.0f;
            b.HalfWidth = 0.0f;
            b.HalfDepth = 0.0f;
            for (int i = 0; i < 3; i++)
            {
                for (int j = 0; j < 3; j++)
                {
                    if (i == 0)
                    {
                        if(j == 0)
                        {
                            modify.x += m[i][j] * a.Center.x;
                            b.HalfWidth += Math.Abs(m[i][j]) * a.HalfWidth;
                        }
                        else if (j == 1)
                        {
                            modify.x += m[i][j]*a.center.y;
                            b.HalfWidth += Math.Abs(m[i][j]) * a.HalfHeight;
                        }
                        else if (j == 2)
                        {
                            modify.x += m[i][j]*a.center.z;
                            b.HalfWidth += Math.Abs(m[i][j])*a.HalfDepth;
                        }
                    }
                    else if (i == 1)
                    {
                        if(j == 0)
                        {
                            modify.y += m[i][j] * a.Center.x;
                            b.HalfHeight += Math.Abs(m[i][j]) * a.HalfWidth;
                        }
                        else if(j == 1)
                        {
                            modify.y += m[i][j] * a.Center.y;
                            b.HalfHeight += Math.Abs(m[i][j]) * a.HalfHeight;
                        }
                        else if (j == 2)
                        {
                            modify.y += m[i][j]*a.Center.z;
                            b.HalfHeight += Math.Abs(m[i][j])*a.HalfDepth;
                        }

                    }
                    else if (i == 2)
                    {
                        if (j == 0)
                        {
                            modify.z += m[i][j]*a.Center.x;
                            b.HalfDepth += Math.Abs(m[i][j])*a.HalfWidth;
                        }
                        else if (j == 1)
                        {
                            modify.z += m[i][j]*a.Center.y;
                            b.HalfDepth += Math.Abs(m[i][j])*a.HalfHeight;
                        }
                        else if (j == 2)
                        {
                            modify.z += m[i][j]*a.Center.z;
                            b.HalfDepth += Math.Abs(m[i][j])*a.HalfDepth;
                        }
                    }
                }
            }

            b.Center = modify;
        }
コード例 #7
0
ファイル: AABB3D.cs プロジェクト: Zerophase/DyMProject
 public void CLosestPointptAABB(Vector3 p, AABB3D b, ref Vector3 q)
 {
     for (int i = 0; i < 3; i++)
     {
         float v = p[i];
         if (v < b.HalfWidths[i]*2)
             v = b.Center[i] - b.HalfWidths[i];
         if (v > b.HalfWidths[i]*2)
             v = b.Center[i] + b.HalfWidths[i];
         q[i] = v;
     }
 }
コード例 #8
0
ファイル: AABB3D.cs プロジェクト: Zerophase/DyMProject
 public void CalculateNormal(AABB3D collided)
 {
 }
コード例 #9
0
ファイル: AABB3D.cs プロジェクト: Zerophase/DyMProject
        public AABB3D AdjustForHitTime(AABB3D movingBox, 
			Vector3 velocity, float hitTime)
        {
            //hitTime = 1.0f - clamp(hitTime - float.Epsilon, 0f, 1f);
            Vector3 adjustedCenter = movingBox.Center + (velocity*hitTime);
            float width = (movingBox.HalfWidth*2) + (velocity.x*hitTime);
            float height = (movingBox.HalfHeight * 2) + (velocity.y * hitTime);
            float depth = (movingBox.HalfDepth*2) + (velocity.z*hitTime);
            AABB3D test = new AABB3D(adjustedCenter, width,
                    height,
                    depth);
            //Vector3 direction = velocity;
            //direction.Normalize();
            //test.Center += new Vector3(direction.x * test.HalfWidth, direction.y * test.HalfHeight,
            //	direction.z * test.HalfDepth);
            if (hitTime < 1.0f)
            {
                Debug.Log("---------------" + hitTime);
            }
            test.DrawBoundingBox(Color.blue);
            //if (Velocity != Vector3.zero)
            //{
            //	Debug.Log("Center hit point: " + test.center.ToString());
            //	Debug.Log("Actual Center: " + center.ToString());
            //}

            return test;
        }
コード例 #10
0
        private void GroundCollision()
        {
            quicksort(unitPhysicsMediators, 0, unitPhysicsMediators.Length - 1);

            float hitTime = 0f;

            for (int k = 0; k < unitPhysicsMediators.Length; k++)
            {
                try
                {
                    unitPhysicsMediators[k].UpdateVelocity(gravity);
                    playerBoundingBox = unitPhysicsMediators[k].BoundingBox;
                }
                catch (MissingReferenceException e)
                {
                    Debug.Log("Test");
                    throw e;
                }

                for (int i = 0; i < groundsArray.Length; i++)
                {
                    groundBoundingBox = groundsArray[i].BoundingBox;
                    var groundMin = groundBoundingBox.Center - new Vector3(groundBoundingBox.HalfWidth, groundBoundingBox.HalfHeight);
                    var unitMax = playerBoundingBox.Center + new Vector3(playerBoundingBox.HalfWidth, playerBoundingBox.HalfHeight) + playerBoundingBox.Velocity * Time.deltaTime;
                    if (groundMin.x > unitMax.x)
                    {
                        break;
                    }

                    if (aabbIntersection.Intersect(playerBoundingBox, groundBoundingBox))
                    {
                        var penetrationVector = playerBoundingBox.Center - groundBoundingBox.Center;
                        unitPhysicsMediators[k].UpdateVelocity(Vector3.up * penetrationVector.y - gravity);
                    }
                    else if (sweep.TestMovingAABB(playerBoundingBox,
                        playerBoundingBox.Velocity * Time.deltaTime, 0f, 1f,
                        groundBoundingBox, ref hitTime))
                    {
                        float actualHittime = 1.0f - hitTime;
                        if (playerBoundingBox.NormalCollision[0].x > 0.0f)
                        {
                            velocity.x = playerBoundingBox.Velocity.x;
                            velocity.y = 0.0f;
                            velocity.z = 0.0f;
                            unitPhysicsMediators[k].UpdateVelocity(-velocity * actualHittime);
                        }
                        else if (playerBoundingBox.NormalCollision[0].x < 0.0f)
                        {
                            velocity.x = playerBoundingBox.Velocity.x;
                            velocity.y = 0.0f;
                            velocity.z = 0.0f;
                            unitPhysicsMediators[k].UpdateVelocity(-velocity * actualHittime);
                        }
                        // TODO find out if better way for avoiding getting caught in platforms
                        if (playerBoundingBox.NormalCollision[1].y < 0.0f && playerBoundingBox.Velocity.y < 0.0f)
                        {

                            velocity.x = 0.0f;
                            velocity.y = playerBoundingBox.Velocity.y;
                            velocity.z = 0.0f;
                            unitPhysicsMediators[k].UpdateVelocity(-velocity * actualHittime);
                        }
                    }
                    else if (unitPhysicsMediators[k] is Player && unitPhysicsMediators[k].velocity.y < Vector3.zero.y &&
                        (unitPhysicsMediators[k] as Player).TouchGroundFrameCount > 2)
                    {
                        (unitPhysicsMediators[k] as Player).TouchGroundFrameCount = 0;
                    }
                }

                try
                {
                    unitPhysicsMediators[k].UpdatePosition();
                    unitPhysicsMediators[k].ResetVelocity();
                }
                catch (MissingReferenceException e)
                {
                    throw e;
                }
            }
        }
コード例 #11
0
 private int findPosition(PhysicsMediator[] ground, AABB3D movable)
 {
     for (int i = 0; i < ground.Length; i++)
     {
         if (ground[i].BoundingBox.Center.x  > movable.Center.x)
         {
             Debug.Log(i);
             return i;
         }
     }
     Debug.Log(0);
     return 0;
 }
コード例 #12
0
        private int compareAABBS(PhysicsMediator left, PhysicsMediator right)
        {
            float leftMin = 0f;
            float rightMin = 0f;
            if(left == null)
            {
                return 1;
            }
            else if( right == null)
            {
                return -1;
            }
            else
            {
                a = left.BoundingBox;
                b = right.BoundingBox;
                leftMin = a.Center.x - a.HalfWidth;
                rightMin = b.Center.x - b.HalfWidth;
            }

            if (leftMin < rightMin)
                return -1;
            if (leftMin > rightMin)
                return 1;
            return 0;
        }