LWJGL 碰撞 3D OpenGL

Question

Currently, I'm working on Collision Detection system for my engine. My Code works very fine but how can I prevent the player from passing through an object?

My code:

public void isCollide(Player player, Entity entity) {

    if ( 
        ( player.getPosition().x <= entity.getScale() + entity.getPosition().x && player.getScale() + player.getPosition().x >= entity.getPosition().x ) &&
        ( player.getPosition().y <= entity.getScale() + entity.getPosition().y && player.getScale() + player.getPosition().y >= entity.getPosition().y ) &&
        ( player.getPosition().z <= entity.getScale() + entity.getPosition().z && player.getScale() + player.getPosition().z >= entity.getPosition().z ) 
       ) 
    {
        System.out.println("Player is colliding!!!");
    }

}

Answer 1

Collision detection can be quite complicated to implement and getting collisions to look physically correct is part of what makes collisions difficult.

However from the code you've provided it looks like you are asking about axis aligned bounding box (AABB) collisions which is not so complicated at all.

AABB collisions is a very simple way of approximating collisions. The general idea is very simple; take each object in the game and create a bounding box for the object. For axis aligned bounding box collisions this means that the bounding boxes you create are aligned with the world axes and each collision box is represented with six numbers; min x and max x, min y and max y, and min z and max z.

For performing a collision check you can take any two of these boxes and simply check if they overlap on each axis. If they overlap on the x, y and z axis then these objects are colliding.

To specifically address this question:

How can I prevent the player from passing through an object?

This is actually fairly straightforward as well when you are doing AABB collisions. The answer here is to simply reverse the movement that created the collision in the first place. So you have a player and an AABB for the player. When updating the players position you translate your players bounding box by some fixed amount. When the translation is done you perform your collision check. If you find that the player is colliding with something then you undo the translation that you just performed, moving the player out of the object it was colliding with.

When you finally draw your scene, what you see is the player not colliding anymore because each time you moved the player in to a collision, you undo the movement.

Of course this method is not without issues, as it's a basic technique. For example if the players speed is too high it can cause the player to phase through objects. You can also get in to situations where undoing the players movement is not enough to undo the collision especially if there are many objects in the scene. There is also plenty of issues with using AABB's, take the following image for example;

If you assume that the black line is some object in your game then the red box is the AABB that you create to do collision checks with. For this object clearly there is a way for other bounding boxes to intersect with this box which will register a collisions but most of the box is filled with empty space.

These two AABBs will register a collision even though the objects contained within them aren't colliding.

To fix these issues you need something more clever such as oriented bounding boxes and a method for checking collisions between oriented bounding boxes.