src/com/replica/replicaisland/BackgroundCollisionComponent.java - platform/external/replicaisland - Git at Google

 /*
  * Copyright (C) 2010 The Android Open Source Project
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
  *      http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */


 package com.replica.replicaisland;

 import java.util.Comparator;

 /**
  * Handles collision against the background.  Snaps colliding objects out of collision and reports
  * the hit to the parent game object.
  */
 public class BackgroundCollisionComponent extends GameComponent {
     private Vector2 mPreviousPosition;
     private int mWidth;
     private int mHeight;
     private int mHorizontalOffset;
     private int mVerticalOffset;

     // Workspace vectors.  Allocated up front for speed.
     private Vector2 mCurrentPosition;
     private Vector2 mPreviousCenter;
     private Vector2 mDelta;
     private Vector2 mFilterDirection;
     private Vector2 mHorizontalHitPoint;
     private Vector2 mHorizontalHitNormal;
     private Vector2 mVerticalHitPoint;
     private Vector2 mVerticalHitNormal;
     private Vector2 mRayStart;
     private Vector2 mRayEnd;
     private Vector2 mTestPointStart;
     private Vector2 mTestPointEnd;
     private Vector2 mMergedNormal;

     /**
      * Sets up the collision bounding box.  This box may be a different size than the bounds of the
      * sprite that this object controls.
      * @param width  The width of the collision box.
      * @param height  The height of the collision box.
      * @param horzOffset  The offset of the collision box from the object's origin in the x axis.
      * @param vertOffset  The offset of the collision box from the object's origin in the y axis.
      */
     public BackgroundCollisionComponent(int width, int height, int horzOffset, int vertOffset) {
         super();
         setPhase(ComponentPhases.COLLISION_RESPONSE.ordinal());
         mPreviousPosition = new Vector2();
         mWidth = width;
         mHeight = height;
         mHorizontalOffset = horzOffset;
         mVerticalOffset = vertOffset;

         mCurrentPosition = new Vector2();
         mPreviousCenter = new Vector2();
         mDelta = new Vector2();
         mFilterDirection = new Vector2();
         mHorizontalHitPoint = new Vector2();
         mHorizontalHitNormal = new Vector2();
         mVerticalHitPoint = new Vector2();
         mVerticalHitNormal = new Vector2();
         mRayStart = new Vector2();
         mRayEnd = new Vector2();
         mTestPointStart = new Vector2();
         mTestPointEnd = new Vector2();
         mMergedNormal = new Vector2();
     }

     public BackgroundCollisionComponent() {
         super();
         setPhase(ComponentPhases.COLLISION_RESPONSE.ordinal());
         mPreviousPosition = new Vector2();
         mCurrentPosition = new Vector2();
         mPreviousCenter = new Vector2();
         mDelta = new Vector2();
         mFilterDirection = new Vector2();
         mHorizontalHitPoint = new Vector2();
         mHorizontalHitNormal = new Vector2();
         mVerticalHitPoint = new Vector2();
         mVerticalHitNormal = new Vector2();
         mRayStart = new Vector2();
         mRayEnd = new Vector2();
         mTestPointStart = new Vector2();
         mTestPointEnd = new Vector2();
         mMergedNormal = new Vector2();
     }

     @Override
     public void reset() {
         mPreviousPosition.zero();
     }

     public void setSize(int width, int height) {
         mWidth = width;
         mHeight = height;
         // TODO: Resize might cause new collisions.
     }

     public void setOffset(int horzOffset, int vertOffset) {
         mHorizontalOffset = horzOffset;
         mVerticalOffset = vertOffset;
     }

     /**
      * This function is the meat of the collision response logic.  Our collision detection and
      * response must be capable of dealing with arbitrary surfaces and must be frame rate
      * independent (we must sweep the space in-between frames to find collisions reliably).  The
      * following algorithm is used to keep the collision box out of the collision world.
      *      1.  Cast a ray from the center point of the box at its position last frame to the edge
      *          of the box at its current position.  If the ray intersects anything, snap the box
      *          back to the point of intersection.
      *      2.  Perform Step 1 twice: once looking for surfaces opposing horizontal movement and
      *          again for surfaces opposing vertical movement.  These two ray tests approximate the
      *          movement of the box between the previous frame and this one.
      *      3.  Since most collisions are collisions with the ground, more precision is required for
      *          vertical intersections.  Perform another ray test, this time from the top of the
      *          box's position (after snapping in Step 2) to the bottom.  Snap out of any vertical
      *          surfaces that the ray encounters.  This will ensure consistent snapping behavior on
      *          incline surfaces.
      *      4.  Add the normals of the surfaces that were hit up and normalize the result to produce
      *          a direction describing the average slope of the surfaces that the box is resting on.
      *          Physics will use this value as a normal to resolve collisions with the background.
      */
     @Override
     public void update(float timeDelta, BaseObject parent) {
         GameObject parentObject = (GameObject) parent;
         parentObject.setBackgroundCollisionNormal(Vector2.ZERO);
         if (mPreviousPosition.length2() != 0) {
             CollisionSystem collision = sSystemRegistry.collisionSystem;
             if (collision != null) {
                 final int left = mHorizontalOffset;
                 final int bottom = mVerticalOffset;
                 final int right = left + mWidth;
                 final int top = bottom + mHeight;
                 final float centerOffsetX = ((mWidth) / 2.0f) + left;
                 final float centerOffsetY = ((mHeight) / 2.0f) + bottom;

                 mCurrentPosition.set(parentObject.getPosition());
                 mDelta.set(mCurrentPosition);
                 mDelta.subtract(mPreviousPosition);

                 mPreviousCenter.set(centerOffsetX, centerOffsetY);
                 mPreviousCenter.add(mPreviousPosition);

                 boolean horizontalHit = false;
                 boolean verticalHit = false;

                 mVerticalHitPoint.zero();
                 mVerticalHitNormal.zero();
                 mHorizontalHitPoint.zero();
                 mHorizontalHitNormal.zero();


                 // The order in which we sweep the horizontal and vertical space can affect the
                 // final result because we perform incremental snapping mid-sweep.  So it is
                 // necessary to sweep in the primary direction of movement first.
                 if (Math.abs(mDelta.x) > Math.abs(mDelta.y)) {
                     horizontalHit = sweepHorizontal(mPreviousCenter, mCurrentPosition, mDelta, left,
                             right, centerOffsetY, mHorizontalHitPoint, mHorizontalHitNormal,
                             parentObject);
                     verticalHit = sweepVertical(mPreviousCenter, mCurrentPosition, mDelta, bottom,
                             top, centerOffsetX, mVerticalHitPoint, mVerticalHitNormal,
                             parentObject);

                 } else {
                     verticalHit = sweepVertical(mPreviousCenter, mCurrentPosition, mDelta, bottom,
                             top, centerOffsetX, mVerticalHitPoint, mVerticalHitNormal,
                             parentObject);
                     horizontalHit = sweepHorizontal(mPreviousCenter, mCurrentPosition, mDelta, left,
                             right, centerOffsetY, mHorizontalHitPoint, mHorizontalHitNormal,
                             parentObject);
                 }

                 // force the collision volume to stay within the bounds of the world.
                 LevelSystem level = sSystemRegistry.levelSystem;
                 if (level != null) {
                     if (mCurrentPosition.x + left < 0.0f) {
                         mCurrentPosition.x = (-left + 1);
                         horizontalHit = true;
                         mHorizontalHitNormal.x = (mHorizontalHitNormal.x + 1.0f);
                         mHorizontalHitNormal.normalize();
                     } else if (mCurrentPosition.x + right > level.getLevelWidth()) {
                         mCurrentPosition.x = (level.getLevelWidth() - right - 1);
                         mHorizontalHitNormal.x = (mHorizontalHitNormal.x - 1.0f);
                         mHorizontalHitNormal.normalize();
                         horizontalHit = true;
                     }

                     /*if (mCurrentPosition.y + bottom < 0.0f) {
                         mCurrentPosition.y = (-bottom + 1);
                         verticalHit = true;
                         mVerticalHitNormal.y = (mVerticalHitNormal.y + 1.0f);
                         mVerticalHitNormal.normalize();
                     } else*/ if (mCurrentPosition.y + top > level.getLevelHeight()) {
                         mCurrentPosition.y = (level.getLevelHeight() - top - 1);
                         mVerticalHitNormal.y = (mVerticalHitNormal.y - 1.0f);
                         mVerticalHitNormal.normalize();
                         verticalHit = true;
                     }

                 }


                 // One more set of tests to make sure that we are aligned with the surface.
                 // This time we will just check the inside of the bounding box for intersections.
                 // The sweep tests above will keep us out of collision in most cases, but this
                 // test will ensure that we are aligned to incline surfaces correctly.

                 // Shoot a vertical line through the middle of the box.
                 if (mDelta.x != 0.0f && mDelta.y != 0.0f) {
                     float yStart = top;
                     float yEnd = bottom;


                     mRayStart.set(centerOffsetX, yStart);
                     mRayStart.add(mCurrentPosition);

                     mRayEnd.set(centerOffsetX, yEnd);
                     mRayEnd.add(mCurrentPosition);

                     mFilterDirection.set(mDelta);

                     if (collision.castRay(mRayStart, mRayEnd, mFilterDirection, mVerticalHitPoint,
                             mVerticalHitNormal, parentObject)) {

                         // If we found a collision, use this surface as our vertical intersection
                         // for this frame, even if the sweep above also found something.
                         verticalHit = true;
                         // snap
                         if (mVerticalHitNormal.y > 0.0f) {
                             mCurrentPosition.y = (mVerticalHitPoint.y - bottom);
                         } else if (mVerticalHitNormal.y < 0.0f) {
                             mCurrentPosition.y = (mVerticalHitPoint.y - top);
                         }
                     }


                     // Now the horizontal version of the same test
                     float xStart = left;
                     float xEnd = right;
                     if (mDelta.x < 0.0f) {
                     	xStart = right;
                     	xEnd = left;
                     }


                     mRayStart.set(xStart, centerOffsetY);
                     mRayStart.add(mCurrentPosition);

                     mRayEnd.set(xEnd, centerOffsetY);
                     mRayEnd.add(mCurrentPosition);

                     mFilterDirection.set(mDelta);

                     if (collision.castRay(mRayStart, mRayEnd, mFilterDirection, mHorizontalHitPoint,
                             mHorizontalHitNormal, parentObject)) {

                         // If we found a collision, use this surface as our horizontal intersection
                         // for this frame, even if the sweep above also found something.
                         horizontalHit = true;
                         // snap
                         if (mHorizontalHitNormal.x > 0.0f) {
                             mCurrentPosition.x = (mHorizontalHitPoint.x - left);
                         } else if (mHorizontalHitNormal.x < 0.0f) {
                             mCurrentPosition.x = (mHorizontalHitPoint.x - right);
                         }
                     }
                 }


                 // Record the intersection for other systems to use.
                 final TimeSystem timeSystem = sSystemRegistry.timeSystem;

                 if (timeSystem != null) {
                     float time = timeSystem.getGameTime();
                     if (horizontalHit) {
                         if (mHorizontalHitNormal.x > 0.0f) {
                             parentObject.setLastTouchedLeftWallTime(time);
                         } else {
                             parentObject.setLastTouchedRightWallTime(time);
                         }
                         //parentObject.setBackgroundCollisionNormal(mHorizontalHitNormal);
                     }

                     if (verticalHit) {
                         if (mVerticalHitNormal.y > 0.0f) {
                             parentObject.setLastTouchedFloorTime(time);
                         } else {
                             parentObject.setLastTouchedCeilingTime(time);
                         }
                         //parentObject.setBackgroundCollisionNormal(mVerticalHitNormal);
                     }


                     // If we hit multiple surfaces, merge their normals together to produce an
                     // average direction of obstruction.
                     if (true) { //(verticalHit && horizontalHit) {
                         mMergedNormal.set(mVerticalHitNormal);
                         mMergedNormal.add(mHorizontalHitNormal);
                         mMergedNormal.normalize();
                         parentObject.setBackgroundCollisionNormal(mMergedNormal);
                     }

                     parentObject.setPosition(mCurrentPosition);
                 }

             }
         }
         mPreviousPosition.set(parentObject.getPosition());
     }

     /* Sweeps the space between two points looking for surfaces that oppose horizontal movement. */
     protected boolean sweepHorizontal(Vector2 previousPosition, Vector2 currentPosition, Vector2 delta,
             int left, int right, float centerY, Vector2 hitPoint, Vector2 hitNormal,
             GameObject parentObject) {
         boolean hit = false;
         if (!Utils.close(delta.x, 0.0f)) {
             CollisionSystem collision = sSystemRegistry.collisionSystem;

             // Shoot a ray from the center of the previous frame's box to the edge (left or right,
             // depending on the direction of movement) of the current box.
             mTestPointStart.y = (centerY);
             mTestPointStart.x = (left);
             int offset = -left;
             if (delta.x > 0.0f) {
                 mTestPointStart.x = (right);
                 offset = -right;
             }

             // Filter out surfaces that do not oppose motion in the horizontal direction, or
             // push in the same direction as movement.
             mFilterDirection.set(delta);
             mFilterDirection.y = (0);

             mTestPointEnd.set(currentPosition);
             mTestPointEnd.add(mTestPointStart);
             if (collision.castRay(previousPosition, mTestPointEnd, mFilterDirection,
                     hitPoint, hitNormal, parentObject)) {
                 // snap
                 currentPosition.x = (hitPoint.x + offset);
                 hit = true;
             }
         }
         return hit;
     }

     /* Sweeps the space between two points looking for surfaces that oppose vertical movement. */
     protected boolean sweepVertical(Vector2 previousPosition, Vector2 currentPosition, Vector2 delta,
             int bottom, int top, float centerX, Vector2 hitPoint, Vector2 hitNormal,
             GameObject parentObject) {
         boolean hit = false;
         if (!Utils.close(delta.y, 0.0f)) {
             CollisionSystem collision = sSystemRegistry.collisionSystem;
             // Shoot a ray from the center of the previous frame's box to the edge (top or bottom,
             // depending on the direction of movement) of the current box.
             mTestPointStart.x = (centerX);
             mTestPointStart.y = (bottom);
             int offset = -bottom;
             if (delta.y > 0.0f) {
                 mTestPointStart.y = (top);
                 offset = -top;
             }

             mFilterDirection.set(delta);
             mFilterDirection.x = (0);

             mTestPointEnd.set(currentPosition);
             mTestPointEnd.add(mTestPointStart);
             if (collision.castRay(previousPosition, mTestPointEnd, mFilterDirection,
                     hitPoint, hitNormal, parentObject)) {
                 hit = true;
                 // snap
                 currentPosition.y = (hitPoint.y + offset);
             }

         }
         return hit;
     }

     /** Comparator for hit points. */
     private static class HitPointDistanceComparator implements Comparator<HitPoint>  {
         private Vector2 mOrigin;

         public HitPointDistanceComparator() {
             super();
             mOrigin = new Vector2();
         }

         public final void setOrigin(Vector2 origin) {
             mOrigin.set(origin);
         }

         public final void setOrigin(float x, float y) {
             mOrigin.set(x, y);
         }

         public int compare(HitPoint object1, HitPoint object2) {
             int result = 0;
             if (object1 != null && object2 != null) {
                 final float obj1Distance = object1.hitPoint.distance2(mOrigin);
                 final float obj2Distance = object2.hitPoint.distance2(mOrigin);
                 final float distanceDelta = obj1Distance - obj2Distance;
                 result = distanceDelta < 0.0f ? -1 : 1;
             } else if (object1 == null && object2 != null) {
                 result = 1;
             } else if (object2 == null && object1 != null) {
                 result = -1;
             }
             return result;
         }
     }
 }
	/*
	* Copyright (C) 2010 The Android Open Source Project
	*
	* Licensed under the Apache License, Version 2.0 (the "License");
	* you may not use this file except in compliance with the License.
	* You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing, software
	* distributed under the License is distributed on an "AS IS" BASIS,
	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	* See the License for the specific language governing permissions and
	* limitations under the License.
	*/


	package com.replica.replicaisland;

	import java.util.Comparator;

	/**
	* Handles collision against the background. Snaps colliding objects out of collision and reports
	* the hit to the parent game object.
	*/
	public class BackgroundCollisionComponent extends GameComponent {
	private Vector2 mPreviousPosition;
	private int mWidth;
	private int mHeight;
	private int mHorizontalOffset;
	private int mVerticalOffset;

	// Workspace vectors. Allocated up front for speed.
	private Vector2 mCurrentPosition;
	private Vector2 mPreviousCenter;
	private Vector2 mDelta;
	private Vector2 mFilterDirection;
	private Vector2 mHorizontalHitPoint;
	private Vector2 mHorizontalHitNormal;
	private Vector2 mVerticalHitPoint;
	private Vector2 mVerticalHitNormal;
	private Vector2 mRayStart;
	private Vector2 mRayEnd;
	private Vector2 mTestPointStart;
	private Vector2 mTestPointEnd;
	private Vector2 mMergedNormal;

	/**
	* Sets up the collision bounding box. This box may be a different size than the bounds of the
	* sprite that this object controls.
	* @param width The width of the collision box.
	* @param height The height of the collision box.
	* @param horzOffset The offset of the collision box from the object's origin in the x axis.
	* @param vertOffset The offset of the collision box from the object's origin in the y axis.
	*/
	public BackgroundCollisionComponent(int width, int height, int horzOffset, int vertOffset) {
	super();
	setPhase(ComponentPhases.COLLISION_RESPONSE.ordinal());
	mPreviousPosition = new Vector2();
	mWidth = width;
	mHeight = height;
	mHorizontalOffset = horzOffset;
	mVerticalOffset = vertOffset;

	mCurrentPosition = new Vector2();
	mPreviousCenter = new Vector2();
	mDelta = new Vector2();
	mFilterDirection = new Vector2();
	mHorizontalHitPoint = new Vector2();
	mHorizontalHitNormal = new Vector2();
	mVerticalHitPoint = new Vector2();
	mVerticalHitNormal = new Vector2();
	mRayStart = new Vector2();
	mRayEnd = new Vector2();
	mTestPointStart = new Vector2();
	mTestPointEnd = new Vector2();
	mMergedNormal = new Vector2();
	}

	public BackgroundCollisionComponent() {
	super();
	setPhase(ComponentPhases.COLLISION_RESPONSE.ordinal());
	mPreviousPosition = new Vector2();
	mCurrentPosition = new Vector2();
	mPreviousCenter = new Vector2();
	mDelta = new Vector2();
	mFilterDirection = new Vector2();
	mHorizontalHitPoint = new Vector2();
	mHorizontalHitNormal = new Vector2();
	mVerticalHitPoint = new Vector2();
	mVerticalHitNormal = new Vector2();
	mRayStart = new Vector2();
	mRayEnd = new Vector2();
	mTestPointStart = new Vector2();
	mTestPointEnd = new Vector2();
	mMergedNormal = new Vector2();
	}

	@Override
	public void reset() {
	mPreviousPosition.zero();
	}

	public void setSize(int width, int height) {
	mWidth = width;
	mHeight = height;
	// TODO: Resize might cause new collisions.
	}

	public void setOffset(int horzOffset, int vertOffset) {
	mHorizontalOffset = horzOffset;
	mVerticalOffset = vertOffset;
	}

	/**
	* This function is the meat of the collision response logic. Our collision detection and
	* response must be capable of dealing with arbitrary surfaces and must be frame rate
	* independent (we must sweep the space in-between frames to find collisions reliably). The
	* following algorithm is used to keep the collision box out of the collision world.
	* 1. Cast a ray from the center point of the box at its position last frame to the edge
	* of the box at its current position. If the ray intersects anything, snap the box
	* back to the point of intersection.
	* 2. Perform Step 1 twice: once looking for surfaces opposing horizontal movement and
	* again for surfaces opposing vertical movement. These two ray tests approximate the
	* movement of the box between the previous frame and this one.
	* 3. Since most collisions are collisions with the ground, more precision is required for
	* vertical intersections. Perform another ray test, this time from the top of the
	* box's position (after snapping in Step 2) to the bottom. Snap out of any vertical
	* surfaces that the ray encounters. This will ensure consistent snapping behavior on
	* incline surfaces.
	* 4. Add the normals of the surfaces that were hit up and normalize the result to produce
	* a direction describing the average slope of the surfaces that the box is resting on.
	* Physics will use this value as a normal to resolve collisions with the background.
	*/
	@Override
	public void update(float timeDelta, BaseObject parent) {
	GameObject parentObject = (GameObject) parent;
	parentObject.setBackgroundCollisionNormal(Vector2.ZERO);
	if (mPreviousPosition.length2() != 0) {
	CollisionSystem collision = sSystemRegistry.collisionSystem;
	if (collision != null) {
	final int left = mHorizontalOffset;
	final int bottom = mVerticalOffset;
	final int right = left + mWidth;
	final int top = bottom + mHeight;
	final float centerOffsetX = ((mWidth) / 2.0f) + left;
	final float centerOffsetY = ((mHeight) / 2.0f) + bottom;

	mCurrentPosition.set(parentObject.getPosition());
	mDelta.set(mCurrentPosition);
	mDelta.subtract(mPreviousPosition);

	mPreviousCenter.set(centerOffsetX, centerOffsetY);
	mPreviousCenter.add(mPreviousPosition);

	boolean horizontalHit = false;
	boolean verticalHit = false;

	mVerticalHitPoint.zero();
	mVerticalHitNormal.zero();
	mHorizontalHitPoint.zero();
	mHorizontalHitNormal.zero();


	// The order in which we sweep the horizontal and vertical space can affect the
	// final result because we perform incremental snapping mid-sweep. So it is
	// necessary to sweep in the primary direction of movement first.
	if (Math.abs(mDelta.x) > Math.abs(mDelta.y)) {
	horizontalHit = sweepHorizontal(mPreviousCenter, mCurrentPosition, mDelta, left,
	right, centerOffsetY, mHorizontalHitPoint, mHorizontalHitNormal,
	parentObject);
	verticalHit = sweepVertical(mPreviousCenter, mCurrentPosition, mDelta, bottom,
	top, centerOffsetX, mVerticalHitPoint, mVerticalHitNormal,
	parentObject);

	} else {
	verticalHit = sweepVertical(mPreviousCenter, mCurrentPosition, mDelta, bottom,
	top, centerOffsetX, mVerticalHitPoint, mVerticalHitNormal,
	parentObject);
	horizontalHit = sweepHorizontal(mPreviousCenter, mCurrentPosition, mDelta, left,
	right, centerOffsetY, mHorizontalHitPoint, mHorizontalHitNormal,
	parentObject);
	}

	// force the collision volume to stay within the bounds of the world.
	LevelSystem level = sSystemRegistry.levelSystem;
	if (level != null) {
	if (mCurrentPosition.x + left < 0.0f) {
	mCurrentPosition.x = (-left + 1);
	horizontalHit = true;
	mHorizontalHitNormal.x = (mHorizontalHitNormal.x + 1.0f);
	mHorizontalHitNormal.normalize();
	} else if (mCurrentPosition.x + right > level.getLevelWidth()) {
	mCurrentPosition.x = (level.getLevelWidth() - right - 1);
	mHorizontalHitNormal.x = (mHorizontalHitNormal.x - 1.0f);
	mHorizontalHitNormal.normalize();
	horizontalHit = true;
	}

	/*if (mCurrentPosition.y + bottom < 0.0f) {
	mCurrentPosition.y = (-bottom + 1);
	verticalHit = true;
	mVerticalHitNormal.y = (mVerticalHitNormal.y + 1.0f);
	mVerticalHitNormal.normalize();
	} else*/ if (mCurrentPosition.y + top > level.getLevelHeight()) {
	mCurrentPosition.y = (level.getLevelHeight() - top - 1);
	mVerticalHitNormal.y = (mVerticalHitNormal.y - 1.0f);
	mVerticalHitNormal.normalize();
	verticalHit = true;
	}

	}


	// One more set of tests to make sure that we are aligned with the surface.
	// This time we will just check the inside of the bounding box for intersections.
	// The sweep tests above will keep us out of collision in most cases, but this
	// test will ensure that we are aligned to incline surfaces correctly.

	// Shoot a vertical line through the middle of the box.
	if (mDelta.x != 0.0f && mDelta.y != 0.0f) {
	float yStart = top;
	float yEnd = bottom;


	mRayStart.set(centerOffsetX, yStart);
	mRayStart.add(mCurrentPosition);

	mRayEnd.set(centerOffsetX, yEnd);
	mRayEnd.add(mCurrentPosition);

	mFilterDirection.set(mDelta);

	if (collision.castRay(mRayStart, mRayEnd, mFilterDirection, mVerticalHitPoint,
	mVerticalHitNormal, parentObject)) {

	// If we found a collision, use this surface as our vertical intersection
	// for this frame, even if the sweep above also found something.
	verticalHit = true;
	// snap
	if (mVerticalHitNormal.y > 0.0f) {
	mCurrentPosition.y = (mVerticalHitPoint.y - bottom);
	} else if (mVerticalHitNormal.y < 0.0f) {
	mCurrentPosition.y = (mVerticalHitPoint.y - top);
	}
	}


	// Now the horizontal version of the same test
	float xStart = left;
	float xEnd = right;
	if (mDelta.x < 0.0f) {
	xStart = right;
	xEnd = left;
	}


	mRayStart.set(xStart, centerOffsetY);
	mRayStart.add(mCurrentPosition);

	mRayEnd.set(xEnd, centerOffsetY);
	mRayEnd.add(mCurrentPosition);

	mFilterDirection.set(mDelta);

	if (collision.castRay(mRayStart, mRayEnd, mFilterDirection, mHorizontalHitPoint,
	mHorizontalHitNormal, parentObject)) {

	// If we found a collision, use this surface as our horizontal intersection
	// for this frame, even if the sweep above also found something.
	horizontalHit = true;
	// snap
	if (mHorizontalHitNormal.x > 0.0f) {
	mCurrentPosition.x = (mHorizontalHitPoint.x - left);
	} else if (mHorizontalHitNormal.x < 0.0f) {
	mCurrentPosition.x = (mHorizontalHitPoint.x - right);
	}
	}
	}


	// Record the intersection for other systems to use.
	final TimeSystem timeSystem = sSystemRegistry.timeSystem;

	if (timeSystem != null) {
	float time = timeSystem.getGameTime();
	if (horizontalHit) {
	if (mHorizontalHitNormal.x > 0.0f) {
	parentObject.setLastTouchedLeftWallTime(time);
	} else {
	parentObject.setLastTouchedRightWallTime(time);
	}
	//parentObject.setBackgroundCollisionNormal(mHorizontalHitNormal);
	}

	if (verticalHit) {
	if (mVerticalHitNormal.y > 0.0f) {
	parentObject.setLastTouchedFloorTime(time);
	} else {
	parentObject.setLastTouchedCeilingTime(time);
	}
	//parentObject.setBackgroundCollisionNormal(mVerticalHitNormal);
	}


	// If we hit multiple surfaces, merge their normals together to produce an
	// average direction of obstruction.
	if (true) { //(verticalHit && horizontalHit) {
	mMergedNormal.set(mVerticalHitNormal);
	mMergedNormal.add(mHorizontalHitNormal);
	mMergedNormal.normalize();
	parentObject.setBackgroundCollisionNormal(mMergedNormal);
	}

	parentObject.setPosition(mCurrentPosition);
	}

	}
	}
	mPreviousPosition.set(parentObject.getPosition());
	}

	/* Sweeps the space between two points looking for surfaces that oppose horizontal movement. */
	protected boolean sweepHorizontal(Vector2 previousPosition, Vector2 currentPosition, Vector2 delta,
	int left, int right, float centerY, Vector2 hitPoint, Vector2 hitNormal,
	GameObject parentObject) {
	boolean hit = false;
	if (!Utils.close(delta.x, 0.0f)) {
	CollisionSystem collision = sSystemRegistry.collisionSystem;

	// Shoot a ray from the center of the previous frame's box to the edge (left or right,
	// depending on the direction of movement) of the current box.
	mTestPointStart.y = (centerY);
	mTestPointStart.x = (left);
	int offset = -left;
	if (delta.x > 0.0f) {
	mTestPointStart.x = (right);
	offset = -right;
	}

	// Filter out surfaces that do not oppose motion in the horizontal direction, or
	// push in the same direction as movement.
	mFilterDirection.set(delta);
	mFilterDirection.y = (0);

	mTestPointEnd.set(currentPosition);
	mTestPointEnd.add(mTestPointStart);
	if (collision.castRay(previousPosition, mTestPointEnd, mFilterDirection,
	hitPoint, hitNormal, parentObject)) {
	// snap
	currentPosition.x = (hitPoint.x + offset);
	hit = true;
	}
	}
	return hit;
	}

	/* Sweeps the space between two points looking for surfaces that oppose vertical movement. */
	protected boolean sweepVertical(Vector2 previousPosition, Vector2 currentPosition, Vector2 delta,
	int bottom, int top, float centerX, Vector2 hitPoint, Vector2 hitNormal,
	GameObject parentObject) {
	boolean hit = false;
	if (!Utils.close(delta.y, 0.0f)) {
	CollisionSystem collision = sSystemRegistry.collisionSystem;
	// Shoot a ray from the center of the previous frame's box to the edge (top or bottom,
	// depending on the direction of movement) of the current box.
	mTestPointStart.x = (centerX);
	mTestPointStart.y = (bottom);
	int offset = -bottom;
	if (delta.y > 0.0f) {
	mTestPointStart.y = (top);
	offset = -top;
	}

	mFilterDirection.set(delta);
	mFilterDirection.x = (0);

	mTestPointEnd.set(currentPosition);
	mTestPointEnd.add(mTestPointStart);
	if (collision.castRay(previousPosition, mTestPointEnd, mFilterDirection,
	hitPoint, hitNormal, parentObject)) {
	hit = true;
	// snap
	currentPosition.y = (hitPoint.y + offset);
	}

	}
	return hit;
	}

	/** Comparator for hit points. */
	private static class HitPointDistanceComparator implements Comparator<HitPoint> {
	private Vector2 mOrigin;

	public HitPointDistanceComparator() {
	super();
	mOrigin = new Vector2();
	}

	public final void setOrigin(Vector2 origin) {
	mOrigin.set(origin);
	}

	public final void setOrigin(float x, float y) {
	mOrigin.set(x, y);
	}

	public int compare(HitPoint object1, HitPoint object2) {
	int result = 0;
	if (object1 != null && object2 != null) {
	final float obj1Distance = object1.hitPoint.distance2(mOrigin);
	final float obj2Distance = object2.hitPoint.distance2(mOrigin);
	final float distanceDelta = obj1Distance - obj2Distance;
	result = distanceDelta < 0.0f ? -1 : 1;
	} else if (object1 == null && object2 != null) {
	result = 1;
	} else if (object2 == null && object1 != null) {
	result = -1;
	}
	return result;
	}
	}
	}