Smooth Collision (Wall sliding)

Question

I recently started learning XNA and C# because of a school project I am doing. I followed this tutorial on YouTube to learn how XNA works with 3D: http://www.youtube.com/watch?v=XkpZLzT5OV4

It works pretty well actually, and I already made some modification/added some features to my project. I recently started to implement the collision detection, which works well using BoundingBoxes, but the camera literally stops when it collides. I would like it to kinda slide on the wall, as every other first person games do. Basically, the camera stops if the movement is directed to the wall. I would like the camera to "slide" on the wall, removing the movement directed to the wall, and making it only going parallel to the wall. I hope that makes sense. This way, the player will be able to still move around while he's touching the wall. I looked at a lot of posts on google, and I saw that I needed to play with the player's velocity. However, I don't have any velocity implemented in my code, and I don't know how to add it.

Here are my main classes:

Here is my Camera class:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Diagnostics;
using Microsoft.Xna.Framework;
using Microsoft.Xna.Framework.Input;

namespace Deimos
{
class Camera : GameComponent
{
    // ...

    // Constructor
    public Camera(Game game, Vector3 position, Vector3 rotation, float speed)
        : base(game)
    {
        CameraSpeed = speed;

        // Setup projection matrix
        Projection = Matrix.CreatePerspectiveFieldOfView(
            MathHelper.PiOver4,
            Game.GraphicsDevice.Viewport.AspectRatio,
            0.05f,
            1000.0f // Draw distance
        );

        // Set the camera position and rotation
        moveTo(position, rotation);


        PreviousMouseState = Mouse.GetState();
    }





    // Set camera position and rotation
    private void moveTo(Vector3 position, Vector3 rotation)
    {
        // Thanks to the properties set at the beginning, setting up these values will execute 
        // the code inside the property (i.e update our vectors)
        Position = position;
        Rotation = rotation;
    }

    // Update the look at vector
    private void updateLookAt()
    {
        // Build a rotation matrix
        Matrix rotationMatrix = Matrix.CreateRotationX(CameraRotation.X) * Matrix.CreateRotationY(CameraRotation.Y);
        // Build look at offset vector
        Vector3 lookAtOffset = Vector3.Transform(Vector3.UnitZ, rotationMatrix);
        // Update our camera's look at vector
        CameraLookAt = CameraPosition + lookAtOffset;
    }

    // Methods that simulate movement
    private Vector3 previewMove(Vector3 amount)
    {
        // Create a rotate matrix
        Matrix rotate = Matrix.CreateRotationY(CameraRotation.Y);
        // Create a movement vector
        Vector3 movement = new Vector3(amount.X, amount.Y, amount.Z);
        movement = Vector3.Transform(movement, rotate);
        // Return the value of camera position + movement vector

        if (Collision.CheckCollision(CameraPosition + movement)) // Testing for the UPCOMING position
        {
            return CameraPosition;
        }
        else
        {
            return CameraPosition + movement;
        }
    }

    // Method that actually moves the camera
    private void move(Vector3 scale)
    {
        moveTo(previewMove(scale), Rotation);
    }

    // Update method, overriding the original one
    public override void Update(GameTime gameTime)
    {
        float dt = (float)gameTime.ElapsedGameTime.TotalSeconds;

        CurrentMouseState = Mouse.GetState();

        // Let's get user inputs
        KeyboardState ks = Keyboard.GetState();

        // Handle basic key movement
        Vector3 moveVector = Vector3.Zero;
        if (ks.IsKeyDown(ForwardKey))
        {
            moveVector.Z = 1;
        }
        if (ks.IsKeyDown(BackKey))
        {
            moveVector.Z = -1;
        }

        if (ks.IsKeyDown(LeftKey))
        {
            moveVector.X = 1;
        }
        if (ks.IsKeyDown(RightKey))
        {
            moveVector.X = -1;
        }

        if (ks.IsKeyDown(Keys.Up))
        {
            moveVector.Y = 1;
        }
        if (ks.IsKeyDown(Keys.Down))
        {
            moveVector.Y = -1;
        }

        if (moveVector != Vector3.Zero) // If we are actually moving (if the vector changed depending on the ifs)
        {
            // Normalize that vector so that we don't move faster diagonally
            moveVector.Normalize();

            // Now we add in move factor and speed
            moveVector *= dt * CameraSpeed;

            DebugScreen.Log(moveVector.ToString());

            // Move camera!
            move(moveVector);
        }


        // Handle mouse movement
        float deltaX;
        float deltaY;
        if (CurrentMouseState != PreviousMouseState)
        {
            // Cache mouse location
            deltaX = CurrentMouseState.X - (Game.GraphicsDevice.Viewport.Width / 2); // We devide by 2 because mouse will be in the center
            deltaY = CurrentMouseState.Y - (Game.GraphicsDevice.Viewport.Height / 2);

            MouseRotationBuffer.X -= MouseSpeed * deltaX * dt;
            MouseRotationBuffer.Y -= MouseSpeed * deltaY * dt;

            // Limit the user so he can't do an unlimited movement with his mouse (like a 7683°)
            if(MouseRotationBuffer.Y < MathHelper.ToRadians(-75.0f))
                MouseRotationBuffer.Y = MouseRotationBuffer.Y - (MouseRotationBuffer.Y - MathHelper.ToRadians(-75.0f));
            if(MouseRotationBuffer.Y > MathHelper.ToRadians(75.0f))
                MouseRotationBuffer.Y = MouseRotationBuffer.Y - (MouseRotationBuffer.Y - MathHelper.ToRadians(75.0f));

            float mouseInverted = (MouseInverted == true) ? 1 : -1;

            Rotation = new Vector3(
                mouseInverted * MathHelper.Clamp(
                    MouseRotationBuffer.Y,
                    MathHelper.ToRadians(-75.0f),
                    MathHelper.ToRadians(75.0f)
                ),
                MathHelper.WrapAngle(MouseRotationBuffer.X), 
                                     // This is so the camera isn't going really fast after some time 
                                     // (as we are increasing the speed with time)
                                     0
                                     );

            // Resetting them
            deltaX = 0;
            deltaY = 0;

        }

        // Putting the cursor in the middle of the screen
        Mouse.SetPosition(Game.GraphicsDevice.Viewport.Width / 2, Game.GraphicsDevice.Viewport.Height / 2);

        PreviousMouseState = CurrentMouseState;

        base.Update(gameTime);

    }
}
}

And here is my Collision class:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using Microsoft.Xna.Framework;
using Microsoft.Xna.Framework.Graphics;


namespace Deimos
{
class Collision
{
    // ...
    public Boolean CheckCollision(Vector3 cameraPosition)
    {
        // Creating the sphere of the camera for later collisions checks
        BoundingBox cameraBox = new BoundingBox(
            new Vector3(
                cameraPosition.X - (PlayerDimention.X / 2),
                cameraPosition.Y - (PlayerDimention.Y),
                cameraPosition.Z - (PlayerDimention.Z / 2)
            ),
            new Vector3(
                cameraPosition.X + (PlayerDimention.X / 2),
                cameraPosition.Y,
                cameraPosition.Z + (PlayerDimention.Z / 2)
            )
        );

        // Let's check for collision with our boxes
        if (CollisionBoxesArray != null)
        {
            for (int i = 0; i < CollisionBoxesArray.Length; i++)
            {
                if (CollisionBoxesArray[i].Contains(cameraBox) != ContainmentType.Disjoint) // If our player is inside the collision region
                    return true;
            }
        }
        if (CollisionSpheresArray != null)
        {
            // And with our spheres
            for (int i = 0; i < CollisionSpheresArray.Length; i++)
            {
                if (CollisionSpheresArray[i].Contains(cameraBox) != ContainmentType.Disjoint)
                    return true;
            }
        }

        return false;

    }

}
}

I really don't know what to do. Thanks a lot.

EDIT: I updated my post removing some unnecessary code so it's more readable for you. I also explained better my problem.

Answer 1

I think something like this might work. This is basically the same thing you did, except the previewMove returns a Vector3 that should allow you to slide along the wall. What the function does now is returns a value that checks to see if the camera can move in any of the X, Y, or Z directions of the movement vector, and if the camera can move in the X, Y, and/or Z, it adds that(those) value(s) to the CameraPosition.

private Vector3 previewMove(Vector3 amount)
{
    // Create a rotate matrix
    Matrix rotate = Matrix.CreateRotationY(CameraRotation.Y);
    // Create a movement vector
    Vector3 movement = new Vector3(amount.X, amount.Y, amount.Z);
    movement = Vector3.Transform(movement, rotate);
    // Return the value of camera position + movement vector

    return CameraPosition + new Vector3(
        Collision.CheckCollision(CameraPosition + new Vector3(movement.X, 0, 0)) ? 0 : movement.X,
        Collision.CheckCollision(CameraPosition + new Vector3(0, movement.Y, 0)) ? 0 : movement.Y,
        Collision.CheckCollision(CameraPosition + new Vector3(0, 0, movement.Z)) ? 0 : movement.Z);

}

I haven't tried the code, so I don't know how well this will work. But hopefully it will help.