Third person camera xna

Question

I'm trying to create a third person camera in my XNA game. I'm able to move the model I have and the camera at the same time, although the camera is not "following" the model. The model moves faster than the camera. Ultimately, I want the camera to rotate with the model with the left and right keys, and move the model with forward and back.

This is in my update method

    if (keyState.IsKeyDown(Keys.D))
        {
            camera.Rotation = MathHelper.WrapAngle(camera.Rotation - (rotateScale * elapsed));
        }

        if (keyState.IsKeyDown(Keys.A))
        {
            camera.Rotation = MathHelper.WrapAngle(camera.Rotation + (rotateScale * elapsed));
        }

        if (keyState.IsKeyDown(Keys.W))
        {
            camera.MoveForward(moveScale * elapsed);
            player.Position += new Vector3(0.1f, 0f, 0f);
        }

        if (keyState.IsKeyDown(Keys.S))
        {
            camera.MoveForward(-moveScale * elapsed);
            player.Position += new Vector3(-0.1f, 0f, 0f);
        }

player is the model I'm using. Currently the A and D keys don't do anything with the model.

    public class Camera
{
    private Vector3 position = Vector3.Zero;
    private Vector3 lookAt;
    private Vector3 baseCameraReference = new Vector3(0, 0, 1);

    private bool needViewResync = true;

    private float rotation;

    public Matrix Projection { get; protected set; }
    private Matrix cachedViewMatrix;

    public Vector3 Position
    {
        get
        {
            return position;
        }

        set
        {
            position = value;
            UpdateLookAt();
        }
    }

    public float Rotation
    {
        get
        {
            return rotation;
        }

        set
        {
            rotation = value;
            UpdateLookAt();
        }
    }

    public Matrix View
    {
        get
        {
            if (needViewResync)
                cachedViewMatrix = Matrix.CreateLookAt(Position, lookAt, Vector3.Up);

            return cachedViewMatrix;
        }
    }

    public Camera(Vector3 position, float rotation, float aspectRatio, float nearClip, float farClip)
    {
        Projection = Matrix.CreatePerspectiveFieldOfView(MathHelper.PiOver4, aspectRatio, nearClip, farClip);
        MoveTo(position, rotation);


    }

    private void UpdateLookAt()
    {
        Matrix rotationMatrix = Matrix.CreateRotationY(rotation);

        Vector3 lookAtOffset = Vector3.Transform(baseCameraReference, rotationMatrix);
        lookAt = position + lookAtOffset;
        needViewResync = true;
    }

    private void MoveTo(Vector3 position, float rotation)
    {
        this.position = position;
        this.rotation = rotation;
        UpdateLookAt();
    }

    public Vector3 PreviewMove(float scale)
    {
        Matrix rotate = Matrix.CreateRotationY(rotation);
        Vector3 forward = new Vector3(0, 0, scale);
        forward = Vector3.Transform(forward, rotate);
        return (position + forward);
    }

    public void MoveForward(float scale)
    {
        MoveTo(PreviewMove(scale), rotation);
    }
}

I also want to offset the camera for obvious reason, but changing the values in the variable baseCameraReference doesn't change what I want it to

Answer 1

If I understand your requirements, you want your camera to always be behind your player (but maybe offset slightly) and move and rotate with the player. The camera should stay in the same location and orientation (rotation) relative to the player.

Then all the rotation and movement code for updating your camera can be eliminated, it is just doing the same movement and rotation as you want the player to do anyway. Why do it twice? Spend all your coding effort moving and rotating the player only.

After that, simply send the updated players matrix to the camera update method after the player is moved and rotated and use the positional and rotational info from that player's matrix to build the camera.

Public void CameraUpdate(Matrix playerMatrix)
{
  camPosition = playerMatrix.Translation + (playerMatrix.Backward * trailingDistance);
  camTarget = playerMatrix.Translation;

  view = Matrix.CreateLookAt(camPosition, camTarget, Vector3.Up); 
}

That's all you need to update the camera. If you want to offset the camera's position (say, to position it over the player's shoulder or something), you can add more offsets when setting the position, like this:

camPosition = playerMatrix.Translation +
                (playerMatrix.Backward * trailingDistance) +
                (playerMatrix.Up  * verticalOffset) +
                (playerMatrix.Left * lateralOffset);

same with the target if you want it to seem as if it's looking past the player instead of at him:

camTarget = playerMatrix.Translation + (playerMatrix.Up * someOffset);

Answer 2

This is the part of my player class that I'm looking at

    public void Render(Matrix view, Matrix projection)
        {
            foreach (ModelMesh mesh in mymodel.Meshes)
            {
                foreach (BasicEffect effect in mesh.Effects)
                {
                    //effect.EnableDefaultLighting();
                    effect.World = transforms[mesh.ParentBone.Index]
                        * Matrix.CreateScale(Scale)
                        * Matrix.CreateRotationY(MathHelper.ToRadians(RotationY))
                        * Matrix.CreateRotationX(MathHelper.ToRadians(RotationX))
                        * Matrix.CreateTranslation(Position);

                    effect.View = view;
                    effect.Projection = projection;
                }
                mesh.Draw();
            }
        }

What you're saying is to use the matrix "transforms[]" while passing in the camera method?

    camera.CameraUpdate(player.transforms)

and then update that matrix based on input?