XNA Game Engine Tutorial Series #6.5 – Engine Update

public static class GraphicsUtil
{
    // Creates a RenderTarget2D with the specified parameters
    public static RenderTarget2D CreateRenderTarget()
    {
        return CreateRenderTarget(Engine.GraphicsDevice.Viewport.Width,
            Engine.GraphicsDevice.Viewport.Height);
    }
 
    // Creates a RenderTarget2D with the specified parameters
    public static RenderTarget2D CreateRenderTarget(int Width, int Height)
    {
        return CreateRenderTarget(Width, Height,
            Engine.GraphicsDevice.DisplayMode.Format);
    }
 
    etc, etc...

public interface I2DComponent
{
    Rectangle Rectangle { get; set; }
}

// Converts a rotation vector into a rotation matrix
public static Matrix Vector3ToMatrix(Vector3 Rotation)
{
    return Matrix.CreateFromYawPitchRoll(Rotation.Y, Rotation.X, Rotation.Z);
}
 
// Converts a rotation matrix into a rotation vector
public static Vector3 MatrixToVector3(Matrix Rotation)
{
    Quaternion q = Quaternion.CreateFromRotationMatrix(Rotation);
    return new Vector3(q.X, q.Y, q.Z);
}

// Creates a world matrix
public static Matrix CreateWorldMatrix(Vector3 Translation)
{
    return CreateWorldMatrix(Translation, Matrix.Identity);
}
 
// Creates a world matrix
public static Matrix CreateWorldMatrix(Vector3 Translation,
    Matrix Rotation)
{
    return CreateWorldMatrix(Translation, Rotation, Vector3.One);
}
 
// Creates a world matrix
public static Matrix CreateWorldMatrix(Vector3 Translation,
    Matrix Rotation, Vector3 Scale)
{
    return Matrix.CreateScale(Scale) *
        Rotation *
        Matrix.CreateTranslation(Translation);
}

Projection = Engine.Math.CreateProjectionMatrix();
 
becomes
 
Projection = MathUtil.CreateProjectionMatrix();

Matrix world = Engine.Math.CreateWorldMatrix(Position, Rotation, Scale);
 
becomes
 
Matrix world = MathUtil.CreateWorldMatrix(Position, Rotation, Scale);

Rotation = Vector3.Zero;
 
becomes
 
EulerRotation = Vector3.Zero;

// Represents a 3D object. These objects will be drawn before 
// 2D objects, and will have modifiers automatically provided 
// in the editor.
public interface I3DComponent
{
    // Position in the Cartesian system (X, Y, Z)
    Vector3 Position { get; set; }
 
    // Rotation represented as a Vector3. This shouldn't
    // be used for calculations, it is left in so that
    // the rotation can be more easily modified by hand
    Vector3 EulerRotation { get; set; }
    // Rotation as a Matrix. This will give much smoother
    // and cleaner calculations that a Vector3
    Matrix Rotation { get; set; }
 
    // Scale for each axis (X, Y, Z)
    Vector3 Scale { get; set; }
 
    // BoundingBox to use for picking and pre-collision
    BoundingBox BoundingBox { get; }
}

// I3DComponent values
public virtual Vector3 Position { get; set; }
public Vector3 EulerRotation
{
    get { return MathUtil.MatrixToVector3(Rotation); }
    set { Rotation = MathUtil.Vector3ToMatrix(value); }
}
public virtual Matrix Rotation { get; set; }
public virtual Vector3 Scale { get; set; }
public virtual BoundingBox BoundingBox
{
    get
    {
        return new BoundingBox(
            Position - (Scale / 2),
            Position + (Scale / 2)
        );
    }
}

// Override the rotation of the base class to that
// of the physics object
public override Matrix Rotation
{
    get
    {
        if (PhysicsObject != null)
            return PhysicsObject.Rotation;
        else
            return Matrix.Identity;
    }
    set
    {
        if (PhysicsObject != null)
            PhysicsObject.Rotation = value;
    }
}

using Microsoft.Xna.Framework;
using System;
using System.Runtime.Serialization;
 
namespace Innovation
{
    // Basic Camera class
    public class Camera : Component, I3DComponent
    {
        // Internal values
        Vector3 position = Vector3.Zero;
        Matrix rotationMatrix = Matrix.Identity;
        Vector3 target = new Vector3(0, 0, -1);
        Vector3 up = Vector3.Up;
        Matrix view;
        Matrix projection;
 
        // The point the camera is looking at
        public virtual Vector3 Target
        { get { return target; } set { target = value; } }
 
        // The View and Projection matrices commonly used for rendering
        public virtual Matrix View
        { get { return view; } set { view = value; } }
        public virtual Matrix Projection
        { get { return projection; } set { projection = value; } }
 
        public virtual Vector3 Up
        { get { return up; } set { up = value; } }
 
        // Public I3DComponent values
        public virtual Vector3 Position { get { return position; } set { position = value; } }
        public virtual Vector3 Scale { get { return Vector3.One; } set { } }
        public Vector3 EulerRotation
        {
            get { return MathUtil.MatrixToVector3(Rotation); }
            set { Rotation = MathUtil.Vector3ToMatrix(value); }
        }
        // The rotation matrix used by the camera and the current up vector
        public virtual Matrix Rotation
        { get { return rotationMatrix; } set { rotationMatrix = value; } }
 
        public virtual BoundingBox BoundingBox
        { get { return new BoundingBox(Position - Vector3.One, Position + Vector3.One); } }
 
        // Constructors
        public Camera(GameScreen Parent) : base(Parent) { }
        public Camera() : base() { }
 
        // Update the camera
        public override void Update()
        {
            // Calculate the direction from the position to the target, and normalize
            Vector3 newForward = Target - Position;
            newForward.Normalize();
 
            // Set the rotation matrix's forward to this vector
            Matrix rotationMatrixCopy = this.Rotation;
            rotationMatrixCopy.Forward = newForward;
 
            // Save a copy of "Up" (0, 1, 0)
            Vector3 referenceVector = Vector3.Up;
 
            // On the slim chance that the camera is pointed perfectly parallel with
            // the Y Axis, we cannot use cross product with a parallel axis, so we
            // change the reference vector to the forward axis (Z).
            if (rotationMatrixCopy.Forward.Y == referenceVector.Y
                || rotationMatrixCopy.Forward.Y == -referenceVector.Y)
                referenceVector = Vector3.Backward;
 
            // Calculate the other parts of the rotation matrix
            rotationMatrixCopy.Right = Vector3.Cross(this.Rotation.Forward,
                referenceVector);
            rotationMatrixCopy.Up = Vector3.Cross(this.Rotation.Right,
                this.Rotation.Forward);
 
            this.Rotation = rotationMatrixCopy;
 
            // Use the rotation matrix to find the new up
            Up = Rotation.Up;
 
            // Recalculate View and Projection using the new Position, Target, and Up
            View = Matrix.CreateLookAt(Position, Target, Up);
            Projection = MathUtil.CreateProjectionMatrix();
        }
    }
}

// The PhysicsObject's rotation as a Matrix
public Matrix Rotation
{
    get { return Body.Orientation; }
    set { Body.MoveTo(Body.Position, value); }
}

// The PhysicsObject's rotation as a Euler Vector
public Vector3 EulerRotation
{
    get { return MathUtil.MatrixToVector3(Rotation); }
    set { Rotation = MathUtil.Vector3ToMatrix(value); }
}