• Animating the rotation of pieces when manipulated by the player
  
• Gradually fading out pieces of completed scoring chains
  
• Animating the falling of pieces into place on the board
  

Child classes
Child classes inherit all of their parent's members and methods. The RotatingPiece class can refer to the pieceType and suffix of the piece without recreating them within RotatingPiece itself. Additionally, child classes can extend the functionality of their base class, adding new methods and properties or overriding old ones. In fact, Game1 itself is a child of the Micrsoft.Xna.Game class, which is why all of the methods we use (Update(), Draw(), LoadContent(), and so on) are declared as "override".

public bool clockwise;

public static float rotationRate = (MathHelper.PiOver2 / 10);
private float rotationAmount = 0;
public int rotationTicksRemaining = 10;

public float RotationAmount
{
get
{
  if (clockwise)
	return rotationAmount;
  else
	return (MathHelper.Pi*2) - rotationAmount;
}
}

public RotatingPiece(string pieceType, bool clockwise)
	  : base(pieceType)
{
  this.clockwise = clockwise;
}

public void UpdatePiece()
{
   rotationAmount += rotationRate;
   rotationTicksRemaining = (int)MathHelper.Max(0,
							rotationTicksRemaining-1);
}

Working with radians
All angular math is handled in radians from XNA's point of view. A complete (360 degree) circle contains 2*pi radians. In other words, one radian is equal to about 57.29 degrees. We tend to relate to circles more often in terms of degrees (a right angle being 90 degrees, for example), so if you prefer to work with degrees, you can use the MathHelper.ToRadians() method to convert your values when supplying them to XNA classes and methods.

this notation
You can see that it is perfectly valid C# code to have method parameter names that match the names of class variables, thus potentially hiding the class variables from being used in the method (since referring to the name inside the method will be assumed to refer to the parameter). To ensure that you can always access your class variables even when a parameter name conflicts, you can preface the variable name with this. when referring to the class variable. this. indicates to C# that the variable you want to use is part of the class, and not a local method parameter.

public int VerticalOffset;
public static int fallRate = 5;

public FallingPiece(string pieceType, int verticalOffset)
	: base(pieceType)
{
  VerticalOffset = verticalOffset;
}

public void UpdatePiece()
{
   VerticalOffset = (int)MathHelper.Max(
			0,
			VerticalOffset - fallRate);
}

public float alphaLevel = 1.0f;
public static float alphaChangeRate = 0.02f;

public FadingPiece(string pieceType, string suffix)
	: base(pieceType, suffix)
{
}

public void UpdatePiece()
{
alphaLevel = MathHelper.Max(
	   0,
	   alphaLevel - alphaChangeRate);
}

public Dictionary<string, FallingPiece> fallingPieces =
new Dictionary<string, FallingPiece>();
public Dictionary<string, RotatingPiece> rotatingPieces =
new Dictionary<string, RotatingPiece>();
public Dictionary<string, FadingPiece> fadingPieces =
new Dictionary<string, FadingPiece>();

public void AddFallingPiece(int X, int Y,
  string PieceName, int VerticalOffset)
{
  fallingPieces[X.ToString() + "_" + Y.ToString()] = new
	   FallingPiece(PieceName, VerticalOffset);
}

public void AddRotatingPiece(int X, int Y,
string PieceName, bool Clockwise)
{
  rotatingPieces[X.ToString() + "_" + Y.ToString()] = new
	   RotatingPiece(PieceName, Clockwise);
}

public void AddFadingPiece(int X, int Y, string PieceName)
{
  fadingPieces[X.ToString() + "_" + Y.ToString()] = new
	   FadingPiece(PieceName,"W");
}

{
if ((fallingPieces.Count == 0) &&
	 (rotatingPieces.Count == 0) &&
	 (fadingPieces.Count == 0))
{
   return false;
}
else
{
   return true;
}
}

private void UpdateFadingPieces()
{
  Queue<string> RemoveKeys = new Queue<string>();

  foreach (string thisKey in fadingPieces.Keys)
  {
	fadingPieces[thisKey].UpdatePiece();
	if (fadingPieces[thisKey].alphaLevel == 0.0f)
		RemoveKeys.Enqueue(thisKey.ToString());
  }
  while (RemoveKeys.Count > 0)
	  fadingPieces.Remove(RemoveKeys.Dequeue());
}

private void UpdateFallingPieces()
{
  Queue<string> RemoveKeys = new Queue<string>();
  foreach (string thisKey in fallingPieces.Keys)
  {
   fallingPieces[thisKey].UpdatePiece();
   if (fallingPieces[thisKey].VerticalOffset == 0)
	   RemoveKeys.Enqueue(thisKey.ToString());
  }
  while (RemoveKeys.Count > 0)
	 fallingPieces.Remove(RemoveKeys.Dequeue());
}

private void UpdateRotatingPieces()
{
  Queue<string> RemoveKeys = new Queue<string>();
  foreach (string thisKey in rotatingPieces.Keys)
  {
   rotatingPieces[thisKey].UpdatePiece();
   if (rotatingPieces[thisKey].rotationTicksRemaining == 0)
	   RemoveKeys.Enqueue(thisKey.ToString());
  }
  while (RemoveKeys.Count > 0)
	   rotatingPieces.Remove(RemoveKeys.Dequeue());
}

public void UpdateAnimatedPieces()
{
  if (fadingPieces.Count == 0)
  {
	UpdateFallingPieces();
	UpdateRotatingPieces();
  }
  else
  {
	UpdateFadingPieces();
  }
}

gameBoard.AddFadingPiece(
(int)ScoringSquare.X,
(int)ScoringSquare.Y,
gameBoard.GetSquare(
  (int)ScoringSquare.X,
  (int)ScoringSquare.Y));

AddFallingPiece(x, y, GetSquare(x, y),
   GamePiece.PieceHeight *(y-rowLookup));

AddFallingPiece(x, y, GetSquare(x, y),
   GamePiece.PieceHeight * GameBoardHeight);

gameBoard.AddRotatingPiece(x, y,
	gameBoard.GetSquare(x, y), false);

gameBoard.AddRotatingPiece(x, y,
   gameBoard.GetSquare(x, y), true);

case GameStates.Playing:
  timeSinceLastInput +=
	(float)gameTime.ElapsedGameTime.TotalSeconds;
  if (gameBoard.ArePiecesAnimating())
  {
   gameBoard.UpdateAnimatedPieces();
  }
  else
  {
   gameBoard.ResetWater();

   for (int y = 0; y < GameBoard.GameBoardHeight; y++)
   {
	CheckScoringChain(gameBoard.GetWaterChain(y));
   }
   gameBoard.GenerateNewPieces(true);

   if (timeSinceLastInput >= MinTimeSinceLastInput)
   {
	HandleMouseInput(Mouse.GetState());
   }
  }
  break;

private void DrawEmptyPiece(int pixelX, int pixelY)
{
  spriteBatch.Draw(
   playingPieces,
   new Rectangle(pixelX, pixelY,
	GamePiece.PieceWidth, GamePiece.PieceHeight),
	EmptyPiece,
	Color.White);
}

private void DrawStandardPiece(int x, int y,
  int pixelX, int pixelY)
{
  spriteBatch.Draw(
   playingPieces, new Rectangle(pixelX, pixelY,
	 GamePiece.PieceWidth, GamePiece.PieceHeight),
   gameBoard.GetSourceRect(x, y),
   Color.White);
}

private void DrawFallingPiece(int pixelX, int pixelY,
	string positionName)
{
  spriteBatch.Draw(
   playingPieces,
   new Rectangle(pixelX, pixelY -
	 gameBoard.fallingPieces[positionName].VerticalOffset,
	  GamePiece.PieceWidth, GamePiece.PieceHeight),
	  gameBoard.fallingPieces[positionName].GetSourceRect(),
	 Color.White);
}

private void DrawFadingPiece(int pixelX, int pixelY,
   string positionName)
{
  spriteBatch.Draw(
   playingPieces,
   new Rectangle(pixelX, pixelY,
	GamePiece.PieceWidth, GamePiece.PieceHeight),
   gameBoard.fadingPieces[positionName].GetSourceRect(),
   Color.White *
	gameBoard.fadingPieces[positionName].alphaLevel);
}

private void DrawRotatingPiece(int pixelX, int pixelY,
   string positionName)
{
  spriteBatch.Draw(
   playingPieces,
   new Rectangle(pixelX + (GamePiece.PieceWidth / 2),
	   pixelY + (GamePiece.PieceHeight / 2),
	   GamePiece.PieceWidth,
	   GamePiece.PieceHeight),
   gameBoard.rotatingPieces[positionName].GetSourceRect(),
   Color.White,
   gameBoard.rotatingPieces[positionName].RotationAmount,
   new Vector2(GamePiece.PieceWidth / 2,
	 GamePiece.PieceHeight / 2),
   SpriteEffects.None, 0.0f);
}

for (int x = 0; x < GameBoard.GameBoardWidth; x++)
  for (int y = 0; y < GameBoard.GameBoardHeight; y++)
  {
   int pixelX = (int)gameBoardDisplayOrigin.X +
	   (x * GamePiece.PieceWidth);
   int pixelY = (int)gameBoardDisplayOrigin.Y +
	   (y * GamePiece.PieceHeight);

   DrawEmptyPiece(pixelX, pixelY);

   bool pieceDrawn = false;

   string positionName = x.ToString() + "_" + y.ToString();

   if (gameBoard.rotatingPieces.ContainsKey(positionName))
   {
	DrawRotatingPiece(pixelX, pixelY, positionName);
	pieceDrawn = true;
   }

   if (gameBoard.fadingPieces.ContainsKey(positionName))
   {
	DrawFadingPiece(pixelX, pixelY, positionName);
	pieceDrawn = true;
   }

   if (gameBoard.fallingPieces.ContainsKey(positionName))
   {
	DrawFallingPiece(pixelX, pixelY, positionName);
	pieceDrawn = true;
   }

   if (!pieceDrawn)
   {
	DrawStandardPiece(x, y, pixelX, pixelY);
   }
}

• Animating the rotation of pieces when manipulated by the player
  
• Gradually fading out pieces of completed scoring chains
  
• Animating the falling of pieces into place on the board
  

• Object animation
  
• Keyframed animation
  
• Curve interpolation
  

public class ObjectAnimation
{
  Vector3 startPosition, endPosition, startRotation, endRotation;
  TimeSpan duration;
  bool loop;
}

TimeSpan elapsedTime = TimeSpan.FromSeconds(0);

public Vector3 Position { get; private set; }
public Vector3 Rotation { get; private set; }

public ObjectAnimation(Vector3 StartPosition, Vector3 EndPosition,
  Vector3 StartRotation, Vector3 EndRotation, TimeSpan Duration,
  bool Loop)
{
  this.startPosition = StartPosition;
  this.endPosition = EndPosition;
  this.startRotation = StartRotation;
  this.endRotation = EndRotation;
  this.duration = Duration;
  this.loop = Loop;
  Position = startPosition;
  Rotation = startRotation;
}

public void Update(TimeSpan Elapsed)
{
  // Update the time
  this.elapsedTime += Elapsed;

  // Determine how far along the duration value we are (0 to 1)
  float amt = (float)elapsedTime.TotalSeconds / (float)duration.
TotalSeconds;

  if (loop)
	 while (amt > 1) // Wrap the time if we are looping
		   amt -= 1;
  else // Clamp to the end value if we are not
	 amt = MathHelper.Clamp(amt, 0, 1);

  // Update the current position and rotation
  Position = Vector3.Lerp(startPosition, endPosition, amt);
  Rotation = Vector3.Lerp(startRotation, endRotation, amt);
}

ObjectAnimation anim;

models.Add(new CModel(Content.Load("ship"),
  Vector3.Zero, Vector3.Zero, new Vector3(0.25f), GraphicsDevice));

anim = new ObjectAnimation(new Vector3(0, -150, 0),
	   new Vector3(0, 150, 0),
	   Vector3.Zero, new Vector3(0, -MathHelper.TwoPi, 0),
	   TimeSpan.FromSeconds(10), true);

anim.Update(gameTime.ElapsedGameTime);

models[0].Position = anim.Position;
models[0].Rotation = anim.Rotation;

public class ObjectAnimationFrame
{
  public Vector3 Position { get; private set; }
  public Vector3 Rotation { get; private set; }
  public TimeSpan Time { get; private set; }

  public ObjectAnimationFrame(Vector3 Position, Vector3 Rotation,
   TimeSpan Time)
  {
	this.Position = Position;
	this.Rotation = Rotation;
	this.Time = Time;
  }
}

public class KeyframedObjectAnimation
{
List frames = new List();
bool loop;
TimeSpan elapsedTime = TimeSpan.FromSeconds(0);

public Vector3 Position { get; private set; }
public Vector3 Rotation { get; private set; }

public KeyframedObjectAnimation(List Frames,
  bool Loop)
{
  this.frames = Frames;
   this.loop = Loop;
  Position = Frames[0].Position;
  Rotation = Frames[0].Rotation;
}
}

public void Update(TimeSpan Elapsed)
{
  // Update the time
  this.elapsedTime += Elapsed;

  TimeSpan totalTime = elapsedTime;
  TimeSpan end = frames[frames.Count - 1].Time;

  if (loop) // Loop around the total time if necessary
	while (totalTime > end)
	   totalTime -= end;
  else // Otherwise, clamp to the end values
  {
	Position = frames[frames.Count - 1].Position;
	Rotation = frames[frames.Count - 1].Rotation;
	return;
  }

  int i = 0;
  // Find the index of the current frame
  while(frames[i + 1].Time	  i++;
  // Find the time since the beginning of this frame
  totalTime -= frames[i].Time;

  // Find how far we are between the current and next frame (0 to 1)
  float amt = (float)((totalTime.TotalSeconds) /
	 (frames[i + 1].Time - frames[i].Time).TotalSeconds);

  // Interpolate position and rotation values between frames
  Position = Vector3.Lerp(frames[i].Position, frames[i + 1].Position,
   amt);
  Rotation = Vector3.Lerp(frames[i].Rotation, frames[i + 1].Rotation,
   amt);
}

KeyframedObjectAnimation anim;

List frames = new List();

frames.Add(new ObjectAnimationFrame(new Vector3(-1000, 100, -1000),
  new Vector3(0, MathHelper.ToRadians(-90), 0),
  TimeSpan.FromSeconds(0)));
frames.Add(new ObjectAnimationFrame(new Vector3(1000, 100, -1000),
  new Vector3(0, MathHelper.ToRadians(-90), 0),
  TimeSpan.FromSeconds(3)));
frames.Add(new ObjectAnimationFrame(new Vector3(1000, 100, -1000),
  new Vector3(0, MathHelper.ToRadians(-180), 0),
  TimeSpan.FromSeconds(6)));
frames.Add(new ObjectAnimationFrame(new Vector3(1000, 100, 1000),
  new Vector3(0, MathHelper.ToRadians(-180), 0),
  TimeSpan.FromSeconds(9)));
frames.Add(new ObjectAnimationFrame(new Vector3(1000, 100, 1000),
  new Vector3(0, MathHelper.ToRadians(-270), 0),
  TimeSpan.FromSeconds(12)));
frames.Add(new ObjectAnimationFrame(new Vector3(-1000, 100, 1000),
  new Vector3(0, MathHelper.ToRadians(-270), 0),
  TimeSpan.FromSeconds(15)));
frames.Add(new ObjectAnimationFrame(new Vector3(-1000, 100, 1000),
  new Vector3(0, MathHelper.ToRadians(-360), 0),
  TimeSpan.FromSeconds(18)));
frames.Add(new ObjectAnimationFrame(new Vector3(-1000, 100, -1000),
  new Vector3(0, MathHelper.ToRadians(-360), 0),
  TimeSpan.FromSeconds(21)));
frames.Add(new ObjectAnimationFrame(new Vector3(-1000, 100, -1000),
  new Vector3(0, MathHelper.ToRadians(-450), 0),
  TimeSpan.FromSeconds(24)));

anim = new KeyframedObjectAnimation(frames, true);

Vector3 catmullRom3D(Vector3 v1, Vector3 v2, Vector3 v3,
Vector3 v4, float amt)
{
return new Vector3(
  MathHelper.CatmullRom(v1.X, v2.X, v3.X, v4.X, amt),
  MathHelper.CatmullRom(v1.Y, v2.Y, v3.Y, v4.Y, amt),
  MathHelper.CatmullRom(v1.Z, v2.Z, v3.Z, v4.Z, amt));
}

// Interpolate position and rotation values between frames
Position = catmullRom3D(frames[wrap(i - 1, frames.Count - 1)].
Position,
  frames[wrap(i, frames.Count - 1)].Position,
  frames[wrap(i + 1, frames.Count - 1)].Position,
  frames[wrap(i + 2, frames.Count - 1)].Position, amt);

// Wraps the "value" argument around [0, max]
int wrap(int value, int max)
{
  while (value > max)
	value -= max;

  while (value	 value += max;
  return value;
}

List frames = new List();

frames.Add(new ObjectAnimationFrame(new Vector3(-500, 100, 1000),
  new Vector3(0, MathHelper.ToRadians(0), 0),
  TimeSpan.FromSeconds(0)));
frames.Add(new ObjectAnimationFrame(new Vector3(500, 100, 500),
  new Vector3(0, MathHelper.ToRadians(0), 0),
  TimeSpan.FromSeconds(3)));
frames.Add(new ObjectAnimationFrame(new Vector3(-500, 100, 0),
  new Vector3(0, MathHelper.ToRadians(0), 0),
  TimeSpan.FromSeconds(6)));
frames.Add(new ObjectAnimationFrame(new Vector3(500, 100, -500),
  new Vector3(0, MathHelper.ToRadians(0), 0),
  TimeSpan.FromSeconds(9)));
frames.Add(new ObjectAnimationFrame(new Vector3(-500, 100, -1000),
  new Vector3(0, MathHelper.ToRadians(180), 0),
  TimeSpan.FromSeconds(12)));
frames.Add(new ObjectAnimationFrame(new Vector3(-500, 100, 1000),
  new Vector3(0, MathHelper.ToRadians(180), 0),
  TimeSpan.FromSeconds(15)));
frames.Add(new ObjectAnimationFrame(new Vector3(-500, 100, 1000),
  new Vector3(0, MathHelper.ToRadians(360), 0),
  TimeSpan.FromSeconds(18)));

anim = new KeyframedObjectAnimation(frames, true);

• Object animation
  
• Keyframed animation
  
• Curve interpolation
  

• Using the Content Pipeline to load textures from disk
  
• Creating classes to divide code into logical units
  
• Recursively evaluating the status of the game board to check for scoring chains
  
• Drawing textures using the SpriteBatch.Draw() method
  
• Managing simple game states
  

• Double-click on Game1.cs in Solution Explorer to open it or bring it to the front if it is already open.
  
• In the Class Declarations area of Game1 (right below SpriteBatch spriteBatch;), add:
  

  	
  Texture2D playingPieces;
  	Texture2D backgroundScreen;
  	Texture2D titleScreen;	
  	
  

  
  
• Add code to load each of the Texture2D objects at the end of LoadContent():
  

  	
  playingPieces = Content.Load(@"Textures\Tile_Sheet");
  	backgroundScreen = 
  		Content.Load(@"Textures\Background");
  	titleScreen = Content.Load(@"Textures\TitleScreen");	
  	
  

  
  

Sprites vs. Textures
XNA defines a "sprite" as a 2D bitmap that is drawn directly to the screen. While these bitmaps are stored in Texture2D objects, the term "texture" is used when a 2D image is mapped onto a 3D object, providing a visual representation of the surface of the object. In practice, all XNA graphics are actually performed in 3D, with 2D sprites being rendered via special configurations of the XNA rendering engine.

Overloads
When multiple versions of the same method are declared with either different parameters lists or different return values, each different declaration is called an "overload" of the method. Overloads allow methods to work with different types of data (for example, when setting a position you could accept two separate X and Y coordinates or a Vector2 value), or leave out parameters that can then be assigned default values.

Alpha blending
Each pixel in a sprite can be fully opaque, fully transparent, or partially transparent. Fully opaque pixels are drawn directly, while fully transparent pixels are not drawn at all, leaving whatever has already been drawn to that pixel on the screen unchanged. In 32-bit color mode, each channel of a color (Red, Green, Blue, and Alpha) are represented by 8 bits, meaning that there are 256 different degrees of transparency between fully opaque (255) and fully transparent (0). Partially transparent pixels are combined with the current pixel color at that location to create a mixed color as if the pixels below were being seen through the new color.

• Identify the sides of each piece that contain pipe connectors
  
• Differentiate between game pieces that are filled with water and that are empty
  
• Allow game pieces to be updated
  
• Automatically handle rotation by changing the piece type to the appropriate new piece type
  
• Given one side of a piece, provide the other sides of the piece in order to facilitate determining where water can flow through the game board
  
• Provide a Rectangle that will be used when the piece is drawn, to locate the graphic for the piece on the sprite sheet
  

• Switch back to your Visual C# window if you have your image editor open.
  
• Right-click on Flood Control in Solution Explorer and select Add | Class...
  
• Name the class GamePiece.cs and click on Add.
  
• At the top of the GamePiece.cs file, add the following to the using directives already in the class:
  

  	
  using Microsoft.Xna.Framework.Graphics;
  	using Microsoft.Xna.Framework;	
  	
  

  
  
• In the class declarations section, add the following:
  

  	
  public static string[] PieceTypes = 
  	{ 
  	  "Left,Right", 
  	  "Top,Bottom", 
  	  "Left,Top", 
  	  "Top,Right",
  	  "Right,Bottom", 
  	  "Bottom,Left",
  	  "Empty"
  	};
  	
  	public const int PieceHeight = 40;
  	public const int PieceWidth = 40;
  	
  	public const int MaxPlayablePieceIndex = 5;
  	public const int EmptyPieceIndex = 6;
  	
  	private const int textureOffsetX = 1;
  	private const int textureOffsetY = 1;
  	private const int texturePaddingX = 1;
  	private const int texturePaddingY = 1;
  	
  	private string pieceType = "";
  	private string pieceSuffix = "";	
  	
  

  
  
• Add two properties to retrieve information about the piece:
  

  	
  public string PieceType
  	{
  		get { return pieceType; }
  	}
  	
  	public string Suffix
  	{
  		get { return pieceSuffix; }
  	}	
  	
  

  
  

Using Directives
Adding the XNA Framework using directives at the top of the class file allows you to access classes like Rectangle and Vector2 without specifying their full assembly names. Without these statements, you would need Microsoft.Xna.Framework.Rectangle in your code every time you reference the type, instead of simply typing Rectangle.

Constants vs. Numeric literals
Why create constants for things like PieceWidth and PieceHeight and have to type them out when you could simply use the number 40 in their place? If you need to go back and resize your pieces later, you only need to change the size in one place instead of hoping that you find each place in the code where you entered 40 and change them all to something else. Even if you do not change the number in the game you are working on, you may reuse the code for something else later and having easily changeable parameters will make the job much easier.

• Add two constructors to your GamePiece.cs file after the declarations:
  

  	
  public GamePiece(string type, string suffix)
  	{
  		pieceType=type;
  		pieceSuffix=suffix;
  	}
  	
  	public GamePiece(string type)
  	{
  		pieceType=type;
  		pieceSuffix="";
  	}	
  	
  

  
  

• Add the following methods to the GamePiece class:
  

  	
  public void SetPiece(string type, string suffix)
  	{
  		pieceType = type;
  		pieceSuffix = suffix;
  	}
  	
  	public void SetPiece(string type)
  	{
  		  SetPiece(type,"");
  	}
  	
  	public void AddSuffix(string suffix)
  	{
  		if (!pieceSuffix.Contains(suffix))
  			pieceSuffix += suffix;
  	}
  	
  	public void RemoveSuffix(string suffix)
  	{
  		pieceSuffix = pieceSuffix.Replace(suffix, "");
  	}	
  	
  

  
  

• Add the RotatePiece() method to the GamePiece class:
  

  	
  public void RotatePiece(bool Clockwise)
  	{
  		 switch (pieceType)
  		{
  			case "Left,Right":
  				pieceType = "Top,Bottom";
  				break;
  			case "Top,Bottom":
  				pieceType = "Left,Right";
  				break;
  			case "Left,Top":
  				if (Clockwise)
  					pieceType = "Top,Right";
  				else
  					pieceType = "Bottom,Left";
  				break;
  			case "Top,Right":
  				if (Clockwise)
  					pieceType = "Right,Bottom";
  				else
  					pieceType = "Left,Top";
  				break;
  			case "Right,Bottom":
  				if (Clockwise)
  					pieceType = "Bottom,Left";
  				else
  					pieceType = "Top,Right";
  				break;
  			case "Bottom,Left":
  				if (Clockwise)
  					pieceType = "Left,Top";
  				else
  					pieceType = "Right,Bottom";
  				break;
  			case "Empty":
  				break;
  		}
  	}	
  	
  

  
  

Why all the strings?
It would certainly be reasonable to create constants that represent the various piece positions instead of fully spelling out things like Bottom,Left as strings. However, because the Flood Control game is not taxing on the system, the additional processing time required for string manipulation will not impact the game negatively and helps clarify how the logic works.

• Add the GetOtherEnds() method to the GamePiece class:
  

  	
  public string[] GetOtherEnds(string startingEnd)
  	{
  		List opposites = new List();
  	
  		foreach (string end in pieceType.Split(','))
  		{
  			if (end != startingEnd)
  				opposites.Add(end);
  		}
  		 return opposites.ToArray();
  	}	
  	
  

  
  
• Add the HasConnector() method to the GamePiece class:
  

  	
  public bool HasConnector(string direction)
  	{
  		return pieceType.Contains(direction);
  	}	
  	
  

  
  

• Add the GetSourceRect() method to the GamePiece class:
  

  	
  public Rectangle GetSourceRect()
  	{
  		int x = textureOffsetX;
  		int y = textureOffsetY;
  	
  		if (pieceSuffix.Contains("W"))
  			x += PieceWidth + texturePaddingX;
  	
  		y += (Array.IndexOf(PieceTypes, pieceType) * 
  			 (PieceHeight + texturePaddingY));
  	
  	
  		return new Rectangle(x, y, PieceWidth, PieceHeight);
  	}	
  	
  

  
  

• Store a GamePiece object for each square on the game board
  
• Provide methods for code using the GameBoard to update individual pieces by passing calls through to the underlying GamePiece instances
  
• Randomly assign a piece type to a GamePiece
  
• Set and clear the "Filled with water" flags on individual GamePieces
  
• Determine which pipes should be filled with water based on their position and orientation and mark them as filled
  
• Return lists of potentially scoring water chains to code using the GameBoard
  

• As you did to create the GamePiece class, right-click on Flood Control in Solution Explorer and select Add | Class... Name the new class file GameBoard.cs.
  
• Add the using directive for the XNA framework at the top of the file:
  

  	
  using Microsoft.Xna.Framework;	
  	
  

  
  
• Add the following declarations to the GameBoard class:
  

  	
  Random rand = new Random();
  	
  	public const int GameBoardWidth = 8;
  	public const int GameBoardHeight = 10;
  	
  	private GamePiece[,] boardSquares = 
  	  new GamePiece[GameBoardWidth, GameBoardHeight];
  	
  	private List WaterTracker = new List();	
  	
  

  
  

• Add a constructor to the GameBoard class:
  

  	
  public GameBoard()
  	{
  	  ClearBoard();
  	}	
  	
  

  
  
• Add the ClearBoard() helper method to the GameBoard class:
  

  	
  public void ClearBoard()
  	{
  		for (int x = 0; x		 for (int y = 0; y			 boardSquares[x, y] = new GamePiece("Empty");
  	}	
  	
  

  
  

Helper methods
Why not simply put the two for loops that clear the board into the GameBoard constructor? Splitting the work into methods that accomplish a single purpose greatly helps to keep your code both readable and maintainable. Additionally, by splitting ClearBoard() out as its own method we can call it separately from the constructor. When we add increasing difficulty levels, we make use of this call when a new level starts.

• Add public methods to the GameBoard class to interact with GamePiece:
  

  	
  public void RotatePiece(int x, int y, bool clockwise)
  	{
  		boardSquares[x, y].RotatePiece(clockwise);
  	}
  	
  	public Rectangle GetSourceRect(int x, int y)
  	{
  		return boardSquares[x, y].GetSourceRect();
  	}
  	
  	public string GetSquare(int x, int y)
  	{
  		return boardSquares[x, y].PieceType;
  	}
  	
  	public void SetSquare(int x, int y, string pieceName)
  	{
  		boardSquares[x, y].SetPiece(pieceName);
  	}
  	
  	public bool HasConnector(int x, int y, string direction)
  	{
  		return boardSquares[x, y].HasConnector(direction); 
  	}
  	
  	public void RandomPiece(int x, int y)
  	{
  	  boardSquares[x, y].SetPiece(GamePiece.PieceTypes[rand.Next(0, 
  		   GamePiece.MaxPlayablePieceIndex+1)]);
  	}	
  	
  

  
  

• Add the FillFromAbove() method to the GameBoard class.
  

  	
  public void FillFromAbove(int x, int y)
  	{
  		int rowLookup = y - 1;
  	
  		while (rowLookup >= 0)
  		{
  			if (GetSquare(x, rowLookup) != "Empty")
  			{
  				SetSquare(x, y,
  				  GetSquare(x, rowLookup));
  				SetSquare(x, rowLookup, "Empty");
  				rowLookup = -1;
  			}
  			rowLookup--;
  		}
  	}	
  	
  

  
  

• Add the GenerateNewPieces() method to the GameBoard class:
  

  	
  public void GenerateNewPieces(bool dropSquares)
  	{
  	
  		if (dropSquares)
  		{
  			for (int x = 0; x		 {
  				for (int y = GameBoard.GameBoardHeight - 1; y >= 0; y--)
  				{
  					if (GetSquare(x, y) == "Empty")
  					{
  						FillFromAbove(x, y);
  					}
  				}
  			}
  		}
  	
  		for (int y = 0; y		 for (int x = 0; x		 {
  				if (GetSquare(x, y) == "Empty")
  				{
  					RandomPiece(x, y);
  				}
  			}
  	}	
  	
  

  
  

• Add a method to the GameBoard class to clear the water marker from all pieces:
  

  	
  public void ResetWater()
  	{
  		for (int y = 0; y		 for (int x = 0; x			 boardSquares[x,y].RemoveSuffix("W");
  	}	
  	
  

  
  
• Add a method to the GameBoard class to fill an individual piece with water:
  

  	
  public void FillPiece(int X, int Y)
  	{
  		boardSquares[X,Y].AddSuffix("W");
  	}	
  	
  

  
  

• Add the PropagateWater() method to the GameBoard class:
  

  	
  public void PropagateWater(int x, int y, string fromDirection)
  	{
  		if ((y >= 0) && (y		 (x >= 0) && (x	 {
  			if (boardSquares[x,y].HasConnector(fromDirection) &&
  				!boardSquares[x,y].Suffix.Contains("W"))
  			{
  				FillPiece(x, y);
  				WaterTracker.Add(new Vector2(x, y));
  				foreach (string end in
  						 boardSquares[x,y].GetOtherEnds(fromDirection))
  					switch (end)
  						  {
  						case "Left": PropagateWater(x - 1, y, "Right");
  							break;
  						case "Right": PropagateWater(x + 1, y, "Left");
  							break;
  						case "Top": PropagateWater(x, y - 1, "Bottom");
  							break;
  						case "Bottom": PropagateWater(x, y + 1, "Top");
  							break;
  					}
  			}
  		}
  	}	
  	
  

  
  
• Add the GetWaterChain() method to the GameBoard class:
  

  	
  public List GetWaterChain(int y)
  	{
  		WaterTracker.Clear();
  		PropagateWater(0, y, "Left");
  		return WaterTracker;
  	}	
  	
  

  
  

• Double click on the Game1.cs file in Solution Explorer to reactivate the Game1.cs code file window.
  
• Add the following declarations to the Game1 class member declaration area:
  

  	
  GameBoard gameBoard;
  	
  	Vector2 gameBoardDisplayOrigin = new Vector2(70, 89);
  	
  	int playerScore = 0;
  	
  	enum GameStates { TitleScreen, Playing };
  	GameStates gameState = GameStates.TitleScreen;
  	
  	Rectangle EmptyPiece = new Rectangle(1, 247, 40, 40);
  	
  	const float MinTimeSinceLastInput = 0.25f;
  	float timeSinceLastInput = 0.0f;	
  	
  

  
  

• Update the Initialize() method to include the following:
  

  	
  this.IsMouseVisible = true;
  	graphics.PreferredBackBufferWidth = 800;
  	graphics.PreferredBackBufferHeight = 600;
  	graphics.ApplyChanges();
  	gameBoard = new GameBoard();	
  	
  

  
  

• Modify the Draw() method of Game1 to include the code necessary to draw the game's title screen after GraphicsDevice.Clear(Color.CornflowerBlue);
  

  	
  if (gameState == GameStates.TitleScreen)
  	{
  		spriteBatch.Begin();
  		spriteBatch.Draw(titleScreen,
  			new Rectangle(0, 0,
  				this.window.ClientBounds.Width,
  				this.window.ClientBounds.Height),
  			Color.White);
  		spriteBatch.End();
  	}	
  	
  

  
  
• Run the game and verify that the title screen is displayed. You will not be able to start the game however, as we haven't written the Update() method yet.
  
• Stop the game by pressing Alt + F4.
  

• Update the Draw() method of the Game1 class to add the code to draw the game board after the code that draws the title screen:
  

  	
  if (gameState == GameStates.Playing)
  	{
  		spriteBatch.Begin();
  	
  		spriteBatch.Draw(backgroundScreen,
  			new Rectangle(0, 0,
  				this.window.ClientBounds.Width,
  				this.window.ClientBounds.Height),
  			Color.White);
  	
  		for (int x = 0; x		 for (int y = 0; y		 {
  				int pixelX = (int)gameBoardDisplayOrigin.X + 
  					(x * GamePiece.PieceWidth);
  				int pixelY = (int)gameBoardDisplayOrigin.Y + 
  					(y * GamePiece.PieceHeight);
  	
  				spriteBatch.Draw(
  					playingPieces,
  					new Rectangle(
  					  pixelX, 
  					  pixelY, 
  					  GamePiece.PieceWidth, 
  					  GamePiece.PieceHeight),
  					EmptyPiece,
  					Color.White);
  	
  				spriteBatch.Draw(
  					playingPieces, new Rectangle(
  						pixelX, 
  						pixelY, 
  						GamePiece.PieceWidth, 
  						GamePiece.PieceHeight),
  					gameBoard.GetSourceRect(x, y),
  					Color.White);
  			}
  	
  		this.window.Title = playerScore.ToString();
  	
  		spriteBatch.End();
  	}	
  	
  

  
  

• Add a method to the Game1 class to calculate a score based on the number of pipes used:
  

  	
  private int DetermineScore(int SquareCount)
  	{
  		return (int)((Math.Pow((SquareCount/5), 2) + SquareCount)*10);
  	}	
  	
  

  
  
• Add a method to evaluate a chain to determine if it scores and process it:
  

  	
  private void CheckScoringChain(List WaterChain)
  	{
  	
  		if (WaterChain.Count > 0)
  		{
  			Vector2 LastPipe = WaterChain[WaterChain.Count - 1];
  	
  			if (LastPipe.X == GameBoard.GameBoardWidth - 1)
  			{
  				if (gameBoard.HasConnector(
  					(int)LastPipe.X, (int)LastPipe.Y, "Right"))
  				{
  					playerScore += DetermineScore(WaterChain.Count);
  	
  					foreach (Vector2 ScoringSquare in WaterChain)
  					{
  						gameBoard.SetSquare((int)ScoringSquare.X,
  							(int)ScoringSquare.Y, "Empty");
  					}
  				}
  			}
  		}
  	}	
  	
  

  
  

Score = (((Squares / 5) ^ 2) + Squares) * 10

• Add the HandleMouseInput() helper method to the Game1 class:
  

  	
  private void HandleMouseInput(MouseState mouseState)
  	{
  	
  		int x = ((mouseState.X -
  			(int)gameBoardDisplayOrigin.X) / GamePiece.PieceWidth);
  	
  		int y = ((mouseState.Y -
  			(int)gameBoardDisplayOrigin.Y) / GamePiece.PieceHeight);
  	
  		if ((x >= 0) && (x	   (y >= 0) && (y	 {
  			if (mouseState.LeftButton == ButtonState.Pressed)
  			{
  				gameBoard.RotatePiece(x, y, false);
  				timeSinceLastInput = 0.0f;
  			}
  	
  			if (mouseState.RightButton == ButtonState.Pressed)
  			{
  				gameBoard.RotatePiece(x, y, true);
  				timeSinceLastInput = 0.0f;
  			}
  		}
  	}	
  	
  

  
  

• Modify the Update() method of Game1.cs by adding the following before the call to base.Update(gameTime):
  

  	
  switch (gameState)
  	{
  		case GameStates.TitleScreen:
  			if (Keyboard.GetState().IsKeyDown(Keys.Space))
  			{
  				gameBoard.ClearBoard();
  				gameBoard.GenerateNewPieces(false);
  				playerScore = 0;
  				gameState = GameStates.Playing;
  			}
  			break;
  	
  		case GameStates.Playing:
  			timeSinceLastInput +=
  			  (float)gameTime.ElapsedGameTime.TotalSeconds;
  	
  			if (timeSinceLastInput >= MinTimeSinceLastInput)
  			{
  				HandleMouseInput(Mouse.GetState());
  			}
  	
  			gameBoard.ResetWater();
  	
  			for (int y = 0; y		 {
  				CheckScoringChain(gameBoard.GetWaterChain(y));		
  			}
  	
  			gameBoard.GenerateNewPieces(true);
  	
  			break;
  	}	
  	
  

  
  

• Adding content objects to your project and loading them into textures at runtime using an instance of the ContentManager class
  
• Dividing the code into classes that represent objects in the game
  
• Building a recursive method
  
• Use the SpriteBatch.Draw() method to display images
  
• Divide the Update() and Draw() code into different units based on the current game state
  

• Hard coding the offset of each vertex element can be quite unsafe. Providing the wrong value won’t be caught by the compiler, and will probably just cause your rendering to appear strange, making it a difficult bug to track down.
  
• In a more academic view, it’s wasteful to have to provide information in your code that already exists. Whenever you need to duplicate code, you increase your maintenance load and introduce the possibility that the two can become out-of-sync with each other.
  

[StructLayout(LayoutKind.Sequential)]
public struct VertexPositionColor
{
  public Vector3 Position;
  public Color Color;
  public static readonly VertexElement[] VertexElements;
  static VertexPositionColor()
  {
	VertexElements = new VertexElement[]
	{
	  new VertexElement(0, 0, VertexElementFormat.Vector3,
		VertexElementMethod.Default, VertexElementUsage.Position, 0), new
		VertexElement(0, 12, VertexElementFormat.Color,
		VertexElementMethod.Default, VertexElementUsage.Color, 0)
	};
  }
}

VertexDeclaration declaration = new VertexDeclaration(GraphicsDevice,
  VertexPositionColor.VertexElements);
Notice how we declare two vertex elements, one for each piece of data in our
  vertex structure(the position and color)
. Also, because we are hardcoding the byte offset for each data element, we
  need to apply the StructLayout attribute to the structure to ensure that its
  fields don ’t get moved around by the compiler. Now, we ’ll look at attribute
  version. struct VertexPositionColor
{
	[VertexElement(VertexElementUsage.Position)
	  public Vector3 Position;
  [VertexElement(VertexElementUsage.Color)]
  public Color Color;
} VertexDeclaration declaration = GraphicsDevice.CreateVertexDeclaration(typeof
  (VertexPositionColor));

[AttributeUsage(AttributeTargets.Field | AttributeTargets.Property)]
public sealed class VertexElementAttribute: Attribute
{
  public int Stream
  {
	get;
	set;
  }
  public VertexElementMethod Method
  {
	get;
	set;
  }
  public VertexElementFormat Format
  {
	get;
	set;
  }
  public VertexElementUsage Usage
  {
	get;
	private set;
  }
  internal int Offset
  {
	get;
	set;
  }
  public VertexElementAttribute(VertexElementUsage usage)
  {
	Usage = usage;
	Format = VertexElementFormat.Unused;
  }
  public VertexElementAttribute(VertexElementUsage usage, VertexElementFormat
	format)
  {
	Usage = usage;
	Format = format;
  }
}

	  public static class AttributeSystem
	  {
		static Dictionary cachedData = new Dictionary();
		public static VertexDeclaration CreateVertexDeclaration(this
		  GraphicsDevice device, Type vertexType)
		{
		  if (cachedData.ContainsKey(vertexType))
			return new VertexDeclaration(device, cachedData[vertexType]);
		  if (!vertexType.IsValueType)
			throw new InvalidOperationException(
			  "Vertex types must be value types.");
		  List objectAttributes = new List();
		  FieldInfo[] fields = vertexType.GetFields(BindingFlags.NonPublic |
			BindingFlags.Public | BindingFlags.Instance);
		  foreach (FieldInfo field in fields)
		  {
			VertexElementAttribute[] attributes = (VertexElementAttribute[])
			  field.GetCustomAttributes(typeof(VertexElementAttribute), false);
			if (field.Name.Contains("<") && field.Name.Contains(">"))
			{
			  int index1 = field.Name.IndexOf('<');
			  int index2 = field.Name.IndexOf('>');
			  string propertyName = field.Name.Substring(index1 + 1, index2 -
				index1 - 1);
			  PropertyInfo property = vertexType.GetProperty(propertyName,
				field.FieldType);
			  if (property != null)
				attributes = (VertexElementAttribute[])
				  property.GetCustomAttributes(typeof(VertexElementAttribute),
				  false);
			}
			if (attributes.Length == 1)
			{
			  if (attributes[0].Format == VertexElementFormat.Unused)
			  {
				if (field.FieldType == typeof(Vector2))
				  attributes[0].Format = VertexElementFormat.Vector2;
				else if (field.FieldType == typeof(Vector3))
				  attributes[0].Format = VertexElementFormat.Vector3;
				else if (field.FieldType == typeof(Vector4))
				  attributes[0].Format = VertexElementFormat.Vector4;
				else if (field.FieldType == typeof(Color))
				  attributes[0].Format = VertexElementFormat.Color;
			  }
			  attributes[0].Offset = Marshal.OffsetOf(vertexType, field.Name)
				.ToInt32();
			  objectAttributes.Add(attributes[0]);
			}
		  }
		  if (objectAttributes.Count < 1)
			throw new InvalidOperationException(
			  "The vertex type must have at least one field or property marked with the VertexElement attribute.");
		  List elements = new List();
		  Dictionary usages = new Dictionary();
		  foreach (VertexElementAttribute attribute in objectAttributes)
		  {
			if (!usages.ContainsKey(attribute.Usage))
			  usages.Add(attribute.Usage, 0);
			int index = usages[attribute.Usage];
			usages[attribute.Usage]++;
			elements.Add(new VertexElement((short)attribute.Stream, (short)
			  attribute.Offset, attribute.Format, attribute.Method,
			  attribute.Usage, (byte)index));
		  }
		  VertexElement[] elementArray = elements.ToArray();
		  cachedData.Add(vertexType, elementArray);
		  return new VertexDeclaration(device, elementArray);
		}
	  }

• I’ve placed the method in a static class and made it an extension method. This isn’t actually required for the method to be useful, but I like extension methods so that’s how I made it.
  
• Another feature I added that is entirely optional is the use of a dictionary to cache reflected data. This could save you some processing power if you are recreating vertex declarations all the time, but it isn’t strictly necessary for the system to work.
  
• Our method requires that the vertex type be a value type (struct keyword in C#). While this will be obvious to C# developers, it could end up being unintuitive for those coming over to XNA from C++. Suffice it to say, struct isn’t the same as class in C#. Read up on value types and reference types before working with C# further.
  
• While iterating over each field seems to be the logical way to handle things, I also wanted to support automatic properties, since I absolutely love them. To do this, you need to check the name of each field to see if it contains the ‘<’ and ‘>’ characters. As far as I’ve seen, this is only possible for backing store fields generated by the compiler for automatic properties, so I extract the actual property name and look for the attribute there.
  
• You can see that I only provide default support for four formats: Vector2, Vector3, Vector4, and Color. All others will need to be specified manually. I suppose providing automatic support for more would be possible. I’ll leave that as an exercise for the reader.
  
• That strange bit of code near the end is how I calculate usage indices for each data element. Basically, each occurrence of a particular usage is given an increasing usage index, starting from 0. While this seems correct to me and works fine, I’ve been told that it’s possible that this doesn’t always work. If you want, you could always add a UsageIndex property to the attribute and give the user the option of specifying the usage index manually.
  

• Artists can handle creation and importing of models without programmers getting involved
• Artists can get a real-time preview of the model in the modeling application, allowing them to get what they want quicker
• Every aspect of a modelÆs appearance is defined in the modeling tool, and completely contained in the model fileÆs data. If a consistent material parameter interface is used as well, this allows you to greatly simplify your rendering code as it wonÆt need to handle any special cases ù all models are treated the same (this is a benefit even if youÆre a one-man-band: simple code is always better).

• Creating a simple D3D management class
  
• Hooking an HWND for messages
  
• Application specific derived class
  
• Exposing the derived class in a Win32 DLL
  
• Creating a C++/CLI wrapper DLL
  
• Utilizing the wrapper in a C# application
  
• Extracting an HWND from a panel control
  
• Setting up an efficient render loop
  
• What about WPF???
  
• Conclusion
  

• OnInit: Called after the device has been initialized, a good place to load resources, and create objects
  
• OnShutdown: Called right before the device is about to be destroyed. Destroy or release what you created or loaded in OnInit
  
• OnUpdate: Update your simulation state
  
• OnRender: Render your frame
  
• OnMsg: Handle windows messages
  
• OnInitDeviceObjects: Handle initialization of device objects
  
• OnRestoreDeviceObjects: Handle restoration of device objects
  
• OnInvalidateDeviceObjects: Handle invalidation of device objects
  
• OnDestroyDeviceObjects: Handle destruction of device objects
  

• Placing a camera on the spot-light's position and rendering the scene depth from the spot light's point of view to a single component texture(preferably a floating point)
• Using the resulting depth texture(shadow map) for depth comparison by means of projective texturing

• Place a camera on the omni light's position and render the scene depth six times, storing depth values in six faces of a cube map. Each time the view vector of the camera should be toward one of these directions: positive X, negative X, positive Y, negative Y, positive Z and negative Z. This is almost identical to generating a cube map for environment mapping except that here we store depth values instead of color.
• Use the resulting cube texture (cubic shadow map) for depth comparison by means of environment mapping.

• Initialization
• Rendering scene depth to the cubic shadow map
• Rendering the Scene using the cubic shadow map

• Initialize Direct3D
• Create a cube texture to be used as cubic shadow map and retrieve all six surfaces of it
• Create a virtual camera (to be placed at the light's position for rendering the scene's depth)
• Load effects
• Load meshes

• Set up the camera looking at the positive X axis
• set the render target to the corresponding cube face acquired in the initialization step and clear it
• Render scene depth (just like rendering depth in spot-light shadow mapping)

• Set up the camera looking at the positive Y axis
• set the render target to the corresponding cube face acquired in the initialization step and clear it
• Render scene depth

• The first thing that comes to mind is frustum culling. Remember that we had to render the scene six times in order to fill our depth cube map. Thus, applying frustum culling will help a lot to reduce draw calls.
• The second is to reduce rendering passes of the first step as much as possible; In other words, not rendering the faces of the cubic shadow map. The depth rendering step requires six cameras, but what if the frusta of these cameras are not inside the frustum of our main camera or there are only three visible frusta, for instance. In these cases we can skip rendering, because if one of the light's frustums is not visible then the shadow it generates is not visible. This technique is easy to implement and has great impact on improving the rendering performance.
• The third is to cull shadow casting objects. For this, we should create a virtual cone covering both the light and the shadow caster with its narrow side based on the light's position. Then we can perform frustum culling on this cone and decide whether the shadow caster is visible or not. If you are wondering why we use a cone instead of simply culling casters against the frustum, it's because doing so will prevent popping shadows into view.
• The fourth is to define a scissor rectangle that represents the region of the screen affected by light and use the hardware's scissor test to reject any pixels that are not affected by light. This technique is also easy to implement and improves the performance vastly, for each omni-light that we place in our scene has a limited range and processing pixels beyond this range is vain.
• The fifth is to use hardware shadow mapping which has been available via NVidia GeForce3 and above. Using hardware shadow mapping has several benefits such as less memory bandwidth consumption, no color buffer writes and hardware accelerated depth-only writes. Using hardware shadow mapping for normal shadow mapping is trivial but since we are using a cube texture for our depth map we cannot directly implement this technique for omni-light shadow mapping. This is because shadow depth textures (D24, D16) do not support cube textures but that doesn't mean we cannot use hardware shadow mapping with cubic shadow mapping. The solution is to merge all six faces of the cube map in a large depth texture and use special addressing techniques to sample Texels from this texture. In other words, we treat this texture as a cube map by converting our three component texture coordinate vector to a two component one for sampling this texture which is called "VSDCT" or "Virtual Shadow Depth Cube Texture".

• The source code is NVidia PerfHUD ready. So feel free to explore the pipeline (if you have video card that is compatible with the program) and see the visualization of the algorithm in real-time. Also you can find performance intensive parts of the algorithm and maybe come up with new ideas.
• The source code is not optimized (neither the C++ nor the HLSL code) so you can add the code for optimization techniques described earlier.

• Gerasimov and Philipp. Omnidirectional Shadow Maps. In GPU Gems, Addison-Wesley. Pages 193-203, 2004.
• G king and W Newhall. Efficient Omnidirectional Shadow Maps. In ShaderX3: Advanced Rendering with DirectX and OpenGL, Charles River Media. Pages 435-448, 2004.

I turned to receive introductions and warm handshakes to Guennardi Rigeur, a Senior ISV Engineer, and Bob Drevin, who has the fascinating title "ATI Fellow," and who has the aura of an evangelist – which I quickly discover is about right. Bob explains that he helps craft ATI's technology directions and is a representative for the company to Microsoft's DirectX architectural group. Guennardi then tells me that he and other ISV Engineers often spend time with game developers on site at their studios, working on production code and helping them squeeze every last bit of performance out of the company's GPUs. Which provides the ideal segue into the substance of this session.

We begin with a discussion of the limitations inherent in DirectX 9, specifically in Direct3D. Guennardi explains that the API as it currently stands is "batch limited." "You can only perform so many operations within the allotted frame time, because of the amount of overhead inherent in state changes, texture unit access and so on, as well as the organization of the vertex and pixel shaders." By way of explanation, he shows me a slide in which the vertex shader is heavily loaded while performing geometry operations but the pixel shader is virtually idle, and then the load is inverted when framebuffer operations are being performed. The fundamental limitations in terms of access to computing resources, he explains, are limiting what developers can do – forcing them to continue to bring a "false reality" to life.

Guennardi is referring to the variety of mathematically inaccurate models for environmental effects and objects that are used as "good enough" approximations for the real thing, due to the inability of current hardware to keep up with full simulations. Or, at least, that's what I thought.

Bob takes over, talking about ATI's objective of eliminating the DX 9 constraints and solving the small batch problem – reducing the overhead associated with operations such that more operations can be performed in each batch, to the point where accurate mathematical models can power our simulations. The challenge, he explains, is balancing the diverse needs of vertex and pixel processing, which seem to be orthogonal at best, if not anti-parallel. In a sense, Bob expounds, "things are about to get worse… in the hopes of getting better."

And then he really gets into his element, letting out his inner technology evangelist, and before I know it I've drunk the Kool-Aid and I'm seeing happy-happy joy-joy images of developers frolicking in glorious rendered fields of Direct3D 10 goodness. Bob introduces me to the Unified Shader Architecture.

"Current shader architectures use fairly different approaches for the vertex and pixel shader units, and this is reflected in their supporting different operations and sometimes requiring different techniques to program. With Direct3D 10, all shader units support the same basic operations and use the same syntax." In addition, Guennardi chips in to tell me about optimizations to the low-level graphics driver such that shader development no longer necessitates the use of assembly language. "Everything can be done in HLSL," he gushes. "Almost everything," Bob corrects. I make the analogy to contemporary use of high(er)-level languages like C or C++ with only occasional use of assembly for machine-specific extensions (such as SSE3) and they both eagerly seize and run with it. The driver analyzes the bytecode produced by the runtime and generates optimized opcodes for the specific hardware, a process I compare to just-in-time (JIT) compilation and which Guennardi is quite pleased with.

Bob continues, "This is the Unified Shader Architecture, and it enables us to do a lot of really cool things that were just really difficult and tedious before, stuff that was either being bus-limited or CPU-limited but is now possible because of how we've been able to reorganize the GPU's internal architecture." Now all shader units can fetch textures or access vertex memory, and some operations can be shifted from one unit to another – some operations are, in essence, shader unit agnostic. As a consequence, an executive process running on the GPU known as Arbitration that decides what gets to execute next can avoid stalls by determining that the next several operations are not dependent on the result of a block unit, perhaps waiting on I/O. I say that it's like having a spare CPU, except that it's sort of running on the GPU.

Bob likes the analogy. "We actually have the unified shader architecture running on a production system already – in the Xbox 360, with the custom GPU we designed for that. It's allowed developed for the 360 to do all sorts of cool stuff, and we'll get into that in a minute." He takes a minute to point out, however, that the Unified Shader Architecture is not a requirement of the Direct3D 10 specification. Rather, "the specification is written in such a way that encourages and is compatible with the Unified Shader Architecture. This is just ATI's take – and just a first take at that, and you'll see some of the amazing stuff we've been able to do with it. Essentially, the Direct3D 10 'refresh' of the API presents an opportunity for a more natural mapping to the capabilities of the underlying hardware."

And now for some demos. Guennardi takes over the keyboard and mouse from Will and first tempers my expectations by reminding me that what I will be shown is actually running on current-generation hardware. "It's an X1900. What we've done is take the pixel shader unit and run everything in a Direct3D 10-like fashion on it – vertex shader, geometry shader, pixel shader."

"Essentially, you're emulating the Unified Shader Architecture on just the pixel shader?" I ask.

"Exactly."

Returning to a point made earlier, one of the real upsides to the D3D 10 API refresh, and to the Unified Shader Architecture, at least in Bob's and Guennardi's eyes, is that it offloads a number of tasks from the CPU, making more cycles available for artificial intelligence and to otherwise create more immersive, interactive worlds. "With the Unified Shader Architecture, and specifically with the geometry shader, we can do a lot of things purely on the GPU that used to require CPU involvement, like collision detection." I believe I took a minute here to gather my jaw from the floor. Collision detection on the GPU?! I am incredulous, and Guennardi clearly enjoys my enthusiasm, while I may remember Will and Bob high-fiving themselves in the background. Or not.

Guennardi shows me a prairie-like environment with shrubbery, a fire and smoke billowing and being blown about by the wind. He pans and zooms around, showing how the smoke particles interact with the polygons of the vegetation without experiencing planar clipping. The visual simulation is virtually seamless, and it's all running on the GPU.

Next, he shows a large space populated with a crowd of about 10,000 textured and animated characters milling about, performing somersaults and flying kicks, running around and generally getting their activity on. "Imagine, for example, the battles in Lord of the Rings," Guennardi says, "and being able to have thousands and thousands of individually articulated and driven characters on the field." "RTS programmers are going to love this!" is my only reply. "By the way, we're using only two meshes. With instancing, which is significantly improved, we scale them and apply different textures and animations to them, giving us a rich visual environment with very few resources."

Bob pipes up, reiterating a distinction we talked about earlier. "Essentially, we are moving from game rendering, again, to game computing." Guennardi takes control of a slider oriented vertically along the right side of the screen and drags it up and down, and I see the number of on-screen characters swell and shrink in relation. Around 100,000 characters, the simulation bogs down and the frame rate begins to stutter sharply. Pulling back to a comfortable number, he points out that the scene is fully interactive. "We can collide with each and every character," he says, as he drives the camera through the crowd with the mouse and characters go flying, bouncing off the collision volume created around the camera. "And all that code is running on the GPU, all done using shaders."

Switching demonstrations again, Guennardi shows me an undulating ocean and a beautifully rendered sky. The sky is a skybox, and is of no interest to us. Hitting a key, he shows me the wireframe mesh, and points out that the wave effects are being computed using the geometry shader – again, running on the GPU. Pointing to the distant areas of the ocean surface, where the mesh devolves into a sea of solid color, I recall another difference we touched on earlier. "Yes. In DirectX 9, that area would heavily load the vertex shader but underutilize the pixel shader because the mesh was resulting in very few pixels drawn. In Direct3D 10, and in particular with the Unified Shader Architecture, the arbitration balances the load and prevents stalling and other forms of performance degradation."

Grabbing yet another slider, he modifies the size of the waves by changing the velocity of the wind blowing over the ocean's surface. "All the physics behind the wave generation is being computed on the GPU, using the geometry shader." He then brings up a menu and enables CPU computation instead of using the GPU (remember, this is all being emulated using solely the pixel shader unit). The simulation goes choppy. The windspeed has to be brought way down before the simulation runs at all smoothly, and even then at framerates under 50. Switching off CPU computation, the framerate immediately jumps back over 97. "We're seeing nearly double the performance, even on current-generation hardware, using this approach."

"And the CPU isn't even loaded. Can I see the CPU utilization?" I ask. Guennardi points out that it'll be at 100%, simply because Direct3D and OpenGL both require that the application loop be within 3 frames of the video refresh. "The CPU is running an empty loop, basically, as fast as it can, which would result in 100% utilization. But it is by no means indicative of actual processing load or availability."

Giddy like a kid on a sugar high, I lean back as Guennardi ends the demonstrations. Asked what I think, I enthuse about getting back into graphics programming myself. Bob and Guennardi rattle off a list of tasks that are ideally suited for the sort of parallelization that the Unified Shader Architecture and the friendly Direct3D 10 API enable. I remark on the huge opportunity for PC developers of all stripes, from AAA to casual, given that Windows Vista will ship with Direct3D 10 included, and on PCs that can exploit all its basic features. As we wrap up the preview, we muse as to what creative uses developers will find for the capabilities made available to them.

"Basically," Bob concludes, "our objective is to eliminate some of the current constraints faced by developers and push them further back, so developers have more room to grow and explore." Yes, indeed.

• About Direct3D 10. For those who haven't been sucking up each and every piece of publicly available information, this section gives a brief introduction to the latest API revision.
• The Programmable Pipeline. Fixed function graphics are a thing of the past with Direct3D 10; this section explains what this means and why it's a good thing.
• Direct3D 10 Application Development. Some of the changes to the API will require software developers to modify the way they write applications. This section covers some of these modifications.
• HLSL and the Effects Framework. Both of these exist under Direct3D 9, but they've been vastly improved over what we currently have – and not just to take advantaged of the new API changes.
• Going Forward. What you need to think about if you want to write Direct3D 10 applications, if you want to convert from 9 to 10 and if you are unsure how to handle this new transition period.

• I often use Borland C++ 5.01 compiler. The dxguid.lib cannot simply be converted from COFF to OMF without losing much information and rendering the DirectX SDK almost useless.
• I wanted to be platform independent.
• I wanted to understand how DirectX was rendering meshes and what was hidden in the helper functions.

• MeshNormals: a list of normal vectors used in case the model is illuminated.
• MeshTextureCoords: Texture coordinates for each Material.
• MeshMaterialList: the list of Materials for the mesh. This block also associate a Material index to each face of the model.

• Recognise the type of the format of the file (text or binary),
• Extract all the meshes and their associated blocks into a model,
• Concatenate the meshes of a model to simplify the use of the model,
• Create a mesh subset for each material used,
• Calculate the bounding box coordinates of the mesh,
• Display the model mesh under OpenGL.

• DECLARE_TRACE: declares the tracing object.
• START_TRACE: initialises the tracing file in the directory Debug.
• END_TRACE: removes and deletes the tracing object.
• MYTRACE: prints the data in the Glut console window and in the tracing file.

• ProcessBlock: This function checks the current character to identify the start of a block name and avoid comments (which start by the characters # or //). If a valid character is detected, this function reads in the string until it finds a space, then calls the utility function Block. This second function will look up in the list of XOF_TEMPLATEID structure (this structure pairs a block name with a token identifier). If it recognises the string as a valid Block Name, it will return the corresponding Token Identifier else this function returns a X_UNKNOWN Token.
• AvoidTemplate: This function will avoid all the data enclosed between a matched pair of braces. It consumes an opening brace character then checks each successive character. If it finds another opening brace character, this function will call itself recursively. This function returns whenever it finds a closing brace.

• This simplifies the mesh maintenance (only one material list, one normal vectors list and one list of vertices and faces).
• This simplifies the drawing step further down the line: we remove a loop through a list of meshes and we only draw a single vertex array.

• To deduce the final size of the concatenated mesh.
• To increment all index references by their starting values to have a correctly displayed mesh.

• Frame: this block describes the bone. It names the bone. It contains one FrameTransformMatrix block describing the bone local matrix and other Frame blocks defining all the children bones. The frame also references the mesh it applies to either by name or by declaration of a Mesh Block. The children of a frame inherit the mesh reference if they do not define their own.
• SkinWeight: this block contains the bone name, the skin offset matrix, the list of vertices to apply this matrix on and the list of weights for these vertices. We find this block within the Mesh block.

• Extract the bone hierarchy with all its related matrices.
• Concatenate the meshes and update the bone references
• Calculate the character space matrices
• Display the skinned model.

• Instant 0: Jerry hides a hammer behind its back.
• Instant + 5 frames: Jerry brandishes the hammer over Tom's foot.
• Instant + 15 frames: Jerry hammers Tom's foot.

• a scaling vector,
• a translation vector,
• a quaternion rotation. A quaternion is a mathematical representation of a rotation around an axis as a 4 dimensional "vector".

• Extract all the animation sets.
• Map the animations to the model bones.
• Calculate the animation matrices.
• Display the animated model.
• Switch between animation sets.

• MapAnimationSet: there are two versions of that function. One uses a string as a parameter, the other an index number. This function will retrieve the animation set either by name or by index and map all the enclosed Animation instances to the ObjectBone hierarchy.
• SetAnimationStep: sets up the step increase for the animation. At each timer call (or user keypress like in the sample), the animation set will advance the main animation set time counter by this step.

• Render every object's bounding mesh
• For every object:
  • Begin query
  • Re-render the bounding mesh
  • End query
  • Retrieve occlusion query data. If the pixels visible are greater than zero, the object should be rendered. Otherwise, the object should be occluded from rendering.

• If frustum culling were to be implemented, the sectors and objects outside of the view volume could be thrown out from the start.
• The size of the occlusion texture and surface could be decreased, although smaller sizes tend to decrease the accuracy of the occlusion culling.

• WASD: Slide camera
• IJKL: Rotate camera
• M: Save bitmap of occlusion surface (saves to buffer.bmp)

I have noticed that many people would like to know how to use DirectX with Dev-C++ because the beta version of Dev-C++ does not seem to work with DirectX very well until you do some tweaking and the official Dev-C++ site itself does not provide much help. So, I will write about how to get the free Dev-C++ compiler to work with DirectX 8.1 and thus, provide the user with a major tool that is needed to code state-of-the-art games . Now, even my game engine (www.Sherman3D.net/download/files/VFVer1.zip) is fully compilable in Dev-C++ 4.9.8.1.

Want to know how? Then follow these easy steps (they might look simple now but it took a lot of trial and error):

1. Install Dev-C++
2. Use the "Check for Updates/Packages" option in the Tools menu.
3. Download the Direct9 package (which also includes DirectX 8.1)
4. Select the "Project Options" item from the Project menu. Click on the Parameters tab.
5. In the "Linker" section, click on "Add Library or Object" and add the necessary library files for DirectX. Here is what my list looks like:

   -lkernel32 -luser32 -lgdi32 -lwinspool -lcomdlg32 -ladvapi32 -lshell32 -lole32 -loleaut32 -luuid -lodbc32 -lodbccp32
   ../../../Dev-Cpp/lib/libdsound.a
   ../../../Dev-Cpp/lib/libdxguid.a
   ../../../Dev-Cpp/lib/libd3d8.a
   ../../../Dev-Cpp/lib/libd3dx8d.a
   ../../../Dev-Cpp/lib/libd3dxof.a
   ../../../Dev-Cpp/lib/libdplayx.a
   ../../../Dev-Cpp/lib/libwinmm.a
   ../../../Dev-Cpp/lib/libdxapi.a
   ../../../Dev-Cpp/lib/libwsock32.a
   ../../../Dev-Cpp/lib/libdinput8.a
   ../../../Dev-Cpp/lib/dinput.lib
   ../../../Dev-Cpp/lib/strmiids.lib
   

   As you can see, I am using Direct3D, DirectSound, DirectPlay, DirectInput and DirectShow. There are a few other necessary Windows libraries as well. I also added dinput.lib from the Microsoft DirectX 8.1 SDK (download it from Microsoft's site) because the one included with Dev-C++ (libdinput.a) seems to be missing some required data formats. The strmiids.lib, a DirectShow library for playing cutscenes, is not present in Dev-C++ so I added it from the DirectX 8.1 SDK as well.

6. You are bound to run into compile time errors as the *.a DirectX library files that come with Dev-C++ have some typo errors in them. They are usually quite easy to fix though. Here is an example:

   Error message: something or other already defined in example.h
   Reason: #ifdef _EXAMPLE_
   Correction: #ifdef _EXAMPLE_H
   

   I can't really remember the exact typos as I corrected all of them without keeping the original files.

   In dxfile.h, delete the last line.
   In dmdls.h, change #ifndef MAKE_FOURCC to #ifndef MAKEFOURCC
   In dmdls.h, change WLOOP[1] to Wloop[1];
   In strmif.h, change #ifndef _WINGDI_ to #ifndef _WINGDI_H

7. The biggest problem for me was getting DirectShow to work. First of all, comment out all the VMR stuff in strmif.h. I seem to get a GUID conflict if I don't. So just comment out lines 20551-20556, 28733-28759, 28759 till 28945. It is going to be a tedious process as there are many /**/ in between and you need to do a // for each line lest you miss out one of those #endif's like I originally did >_<.
8. Another DirectShow problem is that you need to include atlbase.h to for automatic conversions from char to wchar but Dev-C++ doesn't come with atlbase.h. I did the filename conversion manually using a Win32 function. Replace wcscpy(wFileName, lpszMedia); (the function that is used by the DirectShow examples in the SDK) with

      MultiByteToWideChar(CP_ACP    ,     // code page
                          MB_PRECOMPOSED, // character-type options
                          lpszMedia,      // address of string to map
                          -1,             // number of characters in string
                          wFileName,      // address of wide-character buffer
                          MAX_PATH        // size of buffer);
   

9. Dev-C++ doesn't seem to support the allocation of memory space with the "new" command using a variable for the size of memory to allocate. So, if you have something like this:

   m_Polygons = new sPolygon[m_NumPolygons]();

   Replace it with:

   (void*)m_Polygons = malloc(m_NumPolygons*sizeof(sPolygon));

10. Dev-C++ uses the debug libraries of DirectX so please put d3dx8d.dll (which can be found in the DLL subdirectory of Dev-C++) in your program's directory when you distribute it.
11. If you are using Windows resource files (*.rc), make sure to include "windows.h" in the resource file itself and remove any reference to "afxres.h". Open the resource header file, "resource.h" and write a definition for IDC_STATIC in the list.

There might be some other minor complications when using Dev-C++ with DirectX 8.1 so please post your questions at http://forum.Sherman3D.com and I will try to help the best I can.

• The concept
  
• The vertex format
  
• Initialization code
  
• Loading a texture
  
• Drawing a texture
  
• The CTexture class
  

const DWORD D3DFVF_TLVERTEX = D3DFVF_XYZRHW | D3DFVF_DIFFUSE | D3DFVF_TEX1;

//Custom vertex
struct TLVERTEX
{
	float x;
	float y;
	float z;
	float rhw;
	D3DCOLOR colour;
	float u;
	float v;
};

IDirect3DVertexBuffer9* vertexBuffer;

//Set vertex shader
DEVICE->SetVertexShader(NULL);
DEVICE->SetFVF(D3DFVF_TLVERTEX);

//Create vertex buffer
DEVICE->CreateVertexBuffer(sizeof(TLVERTEX) * 4, NULL,
	D3DFVF_TLVERTEX, D3DPOOL_MANAGED, &vertexBuffer, NULL);
DEVICE->SetStreamSource(0, vertexBuffer, 0, sizeof(TLVERTEX));

DEVICE->SetRenderState(D3DRS_LIGHTING, FALSE);
DEVICE->SetRenderState(D3DRS_ALPHABLENDENABLE, TRUE);
DEVICE->SetRenderState(D3DRS_SRCBLEND, D3DBLEND_SRCALPHA);
DEVICE->SetRenderState(D3DRS_DESTBLEND, D3DBLEND_INVSRCALPHA);
DEVICE->SetTextureStageState(0, D3DTSS_ALPHAOP, D3DTOP_MODULATE);

//Load texture from file with D3DX
//Supported formats: BMP, PPM, DDS, JPG, PNG, TGA, DIB
IDirect3DTexture9 *LoadTexture(char *fileName)
{
  IDirect3DTexture9 *d3dTexture;
  D3DXIMAGE_INFO SrcInfo;	  //Optional

  //Use a magenta colourkey
  D3DCOLOR colorkey = 0xFFFF00FF;

  // Load image from file
  if (FAILED(D3DXCreateTextureFromFileEx (DEVICE, fileName, 0, 0, 1, 0,
		D3DFMT_A8R8G8B8, D3DPOOL_MANAGED, D3DX_FILTER_NONE, D3DX_DEFAULT,
		colorkey, &SrcInfo, NULL, &d3dTexture)))
  {
	return NULL;
  }

  //Return the newly made texture
  return d3dTexture;
}

//Draw a textured quad on the back-buffer
void BlitD3D (IDirect3DTexture9 *texture, RECT *rDest,
    D3DCOLOR vertexColour, float rotate)
{
  TLVERTEX* vertices;

  //Lock the vertex buffer
  vertexBuffer->Lock(0, 0, (void**)&vertices, NULL);

  //Setup vertices
  //A -0.5f modifier is applied to vertex coordinates to match texture
  //and screen coords. Some drivers may compensate for this
  //automatically, but on others texture alignment errors are introduced
  //More information on this can be found in the Direct3D 9 documentation
  vertices[0].colour = vertexColour;
  vertices[0].x = (float) rDest->left - 0.5f;
  vertices[0].y = (float) rDest->top - 0.5f;
  vertices[0].z = 0.0f;
  vertices[0].rhw = 1.0f;
  vertices[0].u = 0.0f;
  vertices[0].v = 0.0f;

  vertices[1].colour = vertexColour;
  vertices[1].x = (float) rDest->right - 0.5f;
  vertices[1].y = (float) rDest->top - 0.5f;
  vertices[1].z = 0.0f;
  vertices[1].rhw = 1.0f;
  vertices[1].u = 1.0f;
  vertices[1].v = 0.0f;

  vertices[2].colour = vertexColour;
  vertices[2].x = (float) rDest->right - 0.5f;
  vertices[2].y = (float) rDest->bottom - 0.5f;
  vertices[2].z = 0.0f;
  vertices[2].rhw = 1.0f;
  vertices[2].u = 1.0f;
  vertices[2].v = 1.0f;

  vertices[3].colour = vertexColour;
  vertices[3].x = (float) rDest->left - 0.5f;
  vertices[3].y = (float) rDest->bottom - 0.5f;
  vertices[3].z = 0.0f;
  vertices[3].rhw = 1.0f;
  vertices[3].u = 0.0f;
  vertices[3].v = 1.0f;

  //Handle rotation
  if (rotate != 0)
  {
    RECT rOrigin;
    float centerX, centerY;

    //Find center of destination rectangle
    centerX = (float)(rDest->left + rDest->right) / 2;
    centerY = (float)(rDest->top + rDest->bottom) / 2;

    //Translate destination rect to be centered on the origin
    rOrigin.top = rDest->top - (int)(centerY);
    rOrigin.bottom = rDest->bottom - (int)(centerY);
    rOrigin.left = rDest->left - (int)(centerX);
    rOrigin.right = rDest->right - (int)(centerX);

    //Rotate vertices about the origin
    bufferVertices[index].x = rOrigin.left * cosf(rotate) -
							  rOrigin.top * sinf(rotate);
    bufferVertices[index].y = rOrigin.left * sinf(rotate) +
							  rOrigin.top * cosf(rotate);

    bufferVertices[index + 1].x = rOrigin.right * cosf(rotate) -
								  rOrigin.top * sinf(rotate);
    bufferVertices[index + 1].y = rOrigin.right * sinf(rotate) +
								  rOrigin.top * cosf(rotate);

    bufferVertices[index + 2].x = rOrigin.right * cosf(rotate) -
								  rOrigin.bottom * sinf(rotate);
    bufferVertices[index + 2].y = rOrigin.right * sinf(rotate) +
								  rOrigin.bottom * cosf(rotate);

    bufferVertices[index + 3].x = rOrigin.left * cosf(rotate) -
								  rOrigin.bottom * sinf(rotate);
    bufferVertices[index + 3].y = rOrigin.left * sinf(rotate) +
								  rOrigin.bottom * cosf(rotate);

    //Translate vertices to proper position
    bufferVertices[index].x += centerX;
    bufferVertices[index].y += centerY;
    bufferVertices[index + 1].x += centerX;
    bufferVertices[index + 1].y += centerY;
    bufferVertices[index + 2].x += centerX;
    bufferVertices[index + 2].y += centerY;
    bufferVertices[index + 3].x += centerX;
    bufferVertices[index + 3].y += centerY;
  }

  //Unlock the vertex buffer
  vertexBuffer->Unlock();

  //Set texture
  DEVICE->SetTexture (0, texture);

  //Draw image
  DEVICE->DrawPrimitive (D3DPT_TRIANGLEFAN, 0, 2);
}

//Draw a textured quad on the back-buffer
void BlitExD3D (IDirect3DTexture9 *texture, RECT *rDest,
    D3DCOLOR *vertexColours /* -> D3DCOLOR[4] */, float rotate)
{
  TLVERTEX* vertices;

  //Lock the vertex buffer
  vertexBuffer->Lock(0, 0, (void**)&vertices, NULL);

  //Setup vertices
  //A -0.5f modifier is applied to vertex coordinates to match texture
  //and screen coords. Some drivers may compensate for this
  //automatically, but on others texture alignment errors are introduced
  //More information on this can be found in the Direct3D 9 documentation
  vertices[0].colour = vertexColours[0];
  vertices[0].x = (float) rDest->left - 0.5f;
  vertices[0].y = (float) rDest->top - 0.5f;
  vertices[0].z = 0.0f;
  vertices[0].rhw = 1.0f;
  vertices[0].u = 0.0f;
  vertices[0].v = 0.0f;

  vertices[1].colour = vertexColours[1];
  vertices[1].x = (float) rDest->right - 0.5f;
  vertices[1].y = (float) rDest->top - 0.5f;
  vertices[1].z = 0.0f;
  vertices[1].rhw = 1.0f;
  vertices[1].u = 1.0f;
  vertices[1].v = 0.0f;

  vertices[2].colour = vertexColours[2];
  vertices[2].x = (float) rDest->right - 0.5f;
  vertices[2].y = (float) rDest->bottom - 0.5f;
  vertices[2].z = 0.0f;
  vertices[2].rhw = 1.0f;
  vertices[2].u = 1.0f;
  vertices[2].v = 1.0f;

  vertices[3].colour = vertexColours[3];
  vertices[3].x = (float) rDest->left - 0.5f;
  vertices[3].y = (float) rDest->bottom - 0.5f;
  vertices[3].z = 0.0f;
  vertices[3].rhw = 1.0f;
  vertices[3].u = 0.0f;
  vertices[3].v = 1.0f;

  //Handle rotation
  if (rotate != 0)
  {
    RECT rOrigin;
    float centerX, centerY;

    //Find center of destination rectangle
    centerX = (float)(rDest->left + rDest->right) / 2;
    centerY = (float)(rDest->top + rDest->bottom) / 2;

    //Translate destination rect to be centered on the origin
    rOrigin.top = rDest->top - (int)(centerY);
    rOrigin.bottom = rDest->bottom - (int)(centerY);
    rOrigin.left = rDest->left - (int)(centerX);
    rOrigin.right = rDest->right - (int)(centerX);

    //Rotate vertices about the origin
    bufferVertices[index].x = rOrigin.left * cosf(rotate) -
							  rOrigin.top * sinf(rotate);
    bufferVertices[index].y = rOrigin.left * sinf(rotate) +
							  rOrigin.top * cosf(rotate);

    bufferVertices[index + 1].x = rOrigin.right * cosf(rotate) -
								  rOrigin.top * sinf(rotate);
    bufferVertices[index + 1].y = rOrigin.right * sinf(rotate) +
								  rOrigin.top * cosf(rotate);

    bufferVertices[index + 2].x = rOrigin.right * cosf(rotate) -
								  rOrigin.bottom * sinf(rotate);
    bufferVertices[index + 2].y = rOrigin.right * sinf(rotate) +
								  rOrigin.bottom * cosf(rotate);

    bufferVertices[index + 3].x = rOrigin.left * cosf(rotate) -
								  rOrigin.bottom * sinf(rotate);
    bufferVertices[index + 3].y = rOrigin.left * sinf(rotate) +
								  rOrigin.bottom * cosf(rotate);

    //Translate vertices to proper position
    bufferVertices[index].x += centerX;
    bufferVertices[index].y += centerY;
    bufferVertices[index + 1].x += centerX;
    bufferVertices[index + 1].y += centerY;
    bufferVertices[index + 2].x += centerX;
    bufferVertices[index + 2].y += centerY;
    bufferVertices[index + 3].x += centerX;
    bufferVertices[index + 3].y += centerY;
  }

  //Unlock the vertex buffer
  vertexBuffer->Unlock();

  //Set texture
  DEVICE->SetTexture (0, texture);

  //Draw image
  DEVICE->DrawPrimitive (D3DPT_TRIANGLEFAN, 0, 2);
}

//Loaded texture struct
struct LOADEDTEXTURE
{
  int referenceCount;		 //# of CTexture instances containing this texture
  IDirect3DTexture9* texture; //The texture
  string sFilename;		   //The filename of the texture
  int width;				  //Width of the texture
  int height;				 //Height of the texture
};

//Linked list of all loaded textures
static list <LOADEDTEXTURE*> loadedTextures;

public:

  //Set default member values
  CTexture()
  {
    bLoaded = FALSE;
    texture = NULL;
  }

private:

  BOOL bLoaded;		   //Texture loaded flag
  LOADEDTEXTURE* texture; //The texture

//Load texture from file
int CTexture::Init (string sFilename)
{
  D3DSURFACE_DESC surfaceDesc;
  LOADEDTEXTURE* newTexture;
  list<LOADEDTEXTURE*>::iterator itTextures;

  //Make sure texture is not already loaded
  if (bLoaded)
    return FALSE;

  //Convert filename to lowercase letters
  sFilename = strlwr((char *)sFilename.c_str ());

  //Check if texture is in the loaded list
  for (itTextures = loadedTextures.begin ();
	   itTextures != loadedTextures.end ();
	   itTextures++)
    if ((*itTextures)->sFilename == sFilename)
    {   
	  //Get LOADEDTEXTURE object
	  texture = *itTextures;  

	  //Increment reference counter
	  (*itTextures)->referenceCount++;

	  //Set loaded flag
	  bLoaded = TRUE;

	  //Successfully found texture
	  return TRUE;
    }

  //Texture was not in the list, make a new texture
  newTexture = new LOADEDTEXTURE;

  //Load texture from file
  newTexture->texture = LoadTexture ((char*)sFilename.c_str());
    
  //Make sure texture was loaded
  if (!newTexture->texture)
    return FALSE;

  //Get texture dimensions
  newTexture->texture->GetLevelDesc(0, &surfaceDesc);

  //Set new texture parameters
  newTexture->referenceCount = 1;
  newTexture->sFilename = sFilename;
  newTexture->width = surfaceDesc.Width;
  newTexture->height = surfaceDesc.Height;

  //Push new texture onto list
  loadedTextures.push_back (newTexture);

  //Setup current texture instance
  texture = loadedTextures.back();
  bLoaded = TRUE;
 
  //Successfully loaded texture
  return TRUE;
}

//Unload a texture
int CTexture::Close()
{
  //Make sure texture is loaded
  if (!bLoaded)
    return FALSE;
    
  //Decrement reference counter and nullify pointer
  texture->referenceCount--;
  texture = NULL;

  //Clear loaded flag
  bLoaded = FALSE;

  //Successfully unloaded texture
  return TRUE;
}

//Release all unreferenced textures
static int GarbageCollect();

//Release all unreferenced textures
int CTexture::GarbageCollect()
{
  list<LOADEDTEXTURE*>::iterator it;
  list<LOADEDTEXTURE*>::iterator itNext;

  //Go through loaded texture list
  for (it = loadedTextures.begin(); it != loadedTextures.end ();)   
    if ((*it)->referenceCount <= 0)
    {
	  //Get next iterator
	  itNext = it;
	  itNext++;

	  //Release texture
	  if ((*it)->texture)
	    (*it)->texture->Release();
	  (*it)->texture = NULL;

	  //Delete LOADEDTEXTURE object
	  delete (*it);
	  loadedTextures.erase (it);

	  //Move to next element
	  it = itNext;
    } else it++; //Increment iterator

  //Successfully released unreferenced textures
  return TRUE;
}

//Release all unreferenced textures
static int CleanupTextures();

//Release all textures
int CTexture::CleanupTextures()
{
  list<LOADEDTEXTURE*>::iterator it;
 
  //Go through loaded texture list
  for (it = loadedTextures.begin(); it != loadedTextures.end (); it++)
  {
    //Release texture
    if ((*it)->texture)
	  (*it)->texture->Release();
    (*it)->texture = NULL;
	    
    //Delete LOADEDTEXTURE object
    delete (*it);
  }

  //Clear list
  loadedTextures.clear ();

  //Successfully released all textures
  return TRUE;
}

//Draw texture with limited colour modulation
void CTexture::Blit (int X, int Y, D3DCOLOR vertexColour, float rotate)
{
  RECT rDest;

  //Setup destination rectangle
  rDest.left = X;
  rDest.right = X + texture->width;
  rDest.top = Y;
  rDest.bottom = Y + texture->height;

  //Draw texture
  BlitD3D (texture->texture, &rDest, vertexColour, rotate);
}


//Draw texture with full colour modulation
void CTexture::BlitEx (int X, int Y, D3DCOLOR* vertexColours, float rotate)
{
  RECT rDest;

  //Setup destination rectangle
  rDest.left = X;
  rDest.right = X + texture->width;
  rDest.top = Y;
  rDest.bottom = Y + texture->height;

  //Draw texture
  BlitExD3D (texture->texture, &rDest, vertexColours, rotate);
}

//Clear stream source
DEVICE->SetStreamSource (0, NULL, 0, 0);

//Release vertex buffer
if (vertexBuffer)
   vertexBuffer->Release ();

RECT.bottom = RECT.top + height
RECT.right = RECT.left + width

//Custom vertex format
const DWORD D3DFVF_TLVERTEX = D3DFVF_XYZ | D3DFVF_DIFFUSE | D3DFVF_TEX1;

//Custom vertex
struct TLVERTEX
{
   float x;
   float y;
   float z;
   D3DCOLOR colour;
   float u;
   float v;
};

D3DXMATRIX matOrtho;
D3DXMATRIX matIdentity;

//Setup orthographic projection matrix
D3DXMatrixOrthoLH (&matOrtho, RESOLUTION_WIDTH, RESOLUTION_HEIGHT, 1.0f, 10.0f);
D3DXMatrixIdentity (&matIdentity);
DEVICE->SetTransform (D3DTS_PROJECTION, &matOrtho);
DEVICE->SetTransform (D3DTS_WORLD, &matIdentity);
DEVICE->SetTransform (D3DTS_VIEW, &matIdentity);

//Setup the quad
void SetupQuad ()
{

    TLVERTEX* vertices = NULL;
    vertexBuffer->Lock(0, 4 * sizeof(TLVERTEX), (VOID**)&vertices, 0);

    //Setup vertices
    vertices[0].colour = 0xffffffff;
    vertices[0].x = 0.0f;
    vertices[0].y = 0.0f;
    vertices[0].z = 1.0f;
    vertices[0].u = 0.0f;
    vertices[0].v = 0.0f;

    vertices[1].colour = 0xffffffff;
    vertices[1].x = 1.0f;
    vertices[1].y = 0.0f;
    vertices[1].z = 1.0f;
    vertices[1].u = 1.0f;
    vertices[1].v = 0.0f;

    vertices[2].colour = 0xffffffff;
    vertices[2].x = 1.0f;
    vertices[2].y = -1.0f;
    vertices[2].z = 1.0f;
    vertices[2].u = 1.0f;
    vertices[2].v = 1.0f;

    vertices[3].colour = 0xffffffff;
    vertices[3].x = 0.0f;
    vertices[3].y = -1.0f;
    vertices[3].z = 1.0f;
    vertices[3].u = 0.0f;
    vertices[3].v = 1.0f;

    vertexBuffer->Unlock();
}

//Draw a textured quad on the backbuffer
void Blit(IDirect3DTexture9* texture, RECT* rDest, float rotate)
{
    float X;
    float Y;
    D3DXMATRIX matTranslation;
    D3DXMATRIX matScaling;
    D3DXMATRIX matTransform;
    
    //Get coordinates
    X = rDest->left - (float)(RESOLUTION_WIDTH) / 2;
    Y = -rDest->top + (float)(RESOLUTION_HEIGHT) / 2;

    //Setup translation and scaling matrices
    D3DXMatrixScaling (&matScaling, (float)(rDest->right - rDest->left),
	    (float)(rDest->bottom - rDest->top), 1.0f);
    D3DXMatrixTranslation (&matTranslation, X, Y, 0.0f);
    matTransform = matScaling * matTranslation;

    //Check if quad is rotated
    if (rotate)
    {
	    D3DXMATRIX matRotate;

	    //Create rotation matrix about the z-axis
	    D3DXMatrixRotationZ (&matRotate, rotate);

	    //Multiply matrices together
	    matTransform *= matRotate;
    }

    //Draw the quad
    DEVICE->SetTransform (D3DTS_WORLD, &matTransform);
    DEVICE->SetTexture (0, texture);
    DEVICE->DrawPrimitive(D3DPT_TRIANGLEFAN, 0, 2);
}

//Vertex buffer and index buffer for batched drawing
IDirect3DVertexBuffer9* vertexBatchBuffer;
IDirect3DIndexBuffer9* indexBatchBuffer;

//Max amount of vertices that can be put in the batching buffer
const int BATCH_BUFFER_SIZE = 1000;

//Vertices currently in the batching buffer
int numBatchVertices;
TLVERTEX* batchVertices;

//Info on texture used for batched drawing
float batchTexWidth;
float batchTexHeight;

//Create batching vertex and index buffers
d3dDevice->CreateVertexBuffer(BATCH_BUFFER_SIZE * sizeof(TLVERTEX),
    D3DUSAGE_WRITEONLY, D3DFVF_TLVERTEX, D3DPOOL_MANAGED, &vertexBatchBuffer, NULL);
d3dDevice->CreateIndexBuffer (BATCH_BUFFER_SIZE * 3, D3DUSAGE_WRITEONLY,
    D3DFMT_INDEX16, D3DPOOL_MANAGED, &indexBatchBuffer, NULL);
numBatchVertices = 0;

//Release batching buffers
if (vertexBatchBuffer)
    vertexBatchBuffer->Release ();
if (indexBatchBuffer)
    indexBatchBuffer->Release ();

//Fill the index buffer
void FillIndexBuffer ()
{
    int index = 0;
    short* indices = NULL;

    //Lock index buffer
    indexBatchBuffer->Lock(0, BATCH_BUFFER_SIZE  * 3,
						   (void**) &indices, 0);

    for (int vertex = 0; vertex < BATCH_BUFFER_SIZE; vertex += 4)
    {
	    indices[index] = vertex;
	    indices[index + 1] = vertex + 2;
	    indices[index + 2] = vertex + 3;
	    indices[index + 3] = vertex;
	    indices[index + 4] = vertex + 1;
	    indices[index + 5] = vertex + 2;
	    index += 6;
    }

    //Unlock index buffer
    indexBatchBuffer->Unlock ();
}

//Get ready for batch drawing
void BeginBatchDrawing (IDirect3DTexture9* texture)
{
    D3DXMATRIX matIdentity;
    D3DSURFACE_DESC surfDesc;

    //Lock the batching vertex buffer
    numBatchVertices = 0;
    vertexBatchBuffer->Lock (0, BATCH_BUFFER_SIZE * sizeof(TLVERTEX),
							 (void **) &batchVertices, 0);

    //Get texture dimensions
    texture->GetLevelDesc (0, &surfDesc);
    batchTexWidth = (float) surfDesc.Width;
    batchTexHeight = (float) surfDesc.Height;

    //Set texture
    d3dDevice->SetTexture (0, texture);

    //Set world matrix to an identity matrix
    D3DXMatrixIdentity (&matIdentity);
    d3dDevice->SetTransform (D3DTS_WORLD, &matIdentity);

    //Set stream source to batch buffer
    d3dDevice->SetStreamSource (0, vertexBatchBuffer,
							    0, sizeof(TLVERTEX));
}

//Add a quad to the batching buffer
void AddQuad (RECT* rSource, RECT* rDest, D3DCOLOR colour)
{
    float X;
    float Y;
    float destWidth;
    float destHeight;

    //Calculate coordinates
    X = rDest->left - (float)(d3dPresent.BackBufferWidth) / 2;
    Y = -rDest->top + (float)(d3dPresent.BackBufferHeight) / 2;
    destWidth = (float)(rDest->right - rDest->left);
    destHeight = (float)(rDest->bottom - rDest->top);

    //Setup vertices in buffer
    batchVertices[numBatchVertices].colour = colour;
    batchVertices[numBatchVertices].x = X;
    batchVertices[numBatchVertices].y = Y;
    batchVertices[numBatchVertices].z = 1.0f;
    batchVertices[numBatchVertices].u = rSource->left / batchTexWidth;
    batchVertices[numBatchVertices].v = rSource->top / batchTexHeight;
   
    batchVertices[numBatchVertices + 1].colour = colour;
    batchVertices[numBatchVertices + 1].x = X + destWidth;
    batchVertices[numBatchVertices + 1].y = Y;
    batchVertices[numBatchVertices + 1].z = 1.0f;
    batchVertices[numBatchVertices + 1].u = rSource->right / batchTexWidth;
    batchVertices[numBatchVertices + 1].v = rSource->top / batchTexHeight;

    batchVertices[numBatchVertices + 2].colour = colour;
    batchVertices[numBatchVertices + 2].x = X + destWidth;
    batchVertices[numBatchVertices + 2].y = Y - destHeight;
    batchVertices[numBatchVertices + 2].z = 1.0f;
    batchVertices[numBatchVertices + 2].u = rSource->right / batchTexWidth;
    batchVertices[numBatchVertices + 2].v = rSource->bottom / batchTexHeight;

    batchVertices[numBatchVertices + 3].colour = colour;
    batchVertices[numBatchVertices + 3].x = X;
    batchVertices[numBatchVertices + 3].y = Y - destHeight;
    batchVertices[numBatchVertices + 3].z = 1.0f;
    batchVertices[numBatchVertices + 3].u = rSource->left / batchTexWidth;
    batchVertices[numBatchVertices + 3].v = rSource->bottom / batchTexHeight;

    //Increase vertex count
    numBatchVertices += 4;

    //Flush buffer if it's full
    if (numBatchVertices == BATCH_BUFFER_SIZE)
    {
	    //Unlock vertex buffer
	    vertexBatchBuffer->Unlock();
	   
	    //Draw quads in the buffer
	    d3dDevice->DrawIndexedPrimitive (D3DPT_TRIANGLELIST, 0, 0,
			  numBatchVertices, 0, numBatchVertices / 2);	   

	    //Reset vertex count	   
	    numBatchVertices = 0;	   

	    //Lock vertex buffer
	    vertexBatchBuffer->Lock (0, BATCH_BUFFER_SIZE * sizeof(TLVERTEX),
			  (void **) &batchVertices, 0);
    }

}

//Finish batch drawing
void EndBatchDrawing()
{
    //Unlock vertex buffer
    vertexBatchBuffer->Unlock();

    //Draw the quads in the buffer if it wasn't just flushed
    if (numBatchVertices)
	    d3dDevice->DrawIndexedPrimitive (D3DPT_TRIANGLELIST, 0, 0,
			  numBatchVertices, 0, numBatchVertices / 2);

    //Set stream source to regular buffer
    d3dDevice->SetStreamSource (0, vertexBuffer, 0, sizeof(TLVERTEX));

    //Reset vertex count	   
    numBatchVertices = 0;	   
}