XNA 3.1 to XNA 4.0 CheatSheet

// apply effect XNA 3.1
blurEffect.CommitChanges();
blurEffect.Begin(SaveStateMode.SaveState);
blurEffect.CurrentTechnique.Passes[0].Begin();
GraphicsDevice.DrawPrimitives(PrimitiveType.TriangleList, 0, 2);
blurEffect.CurrentTechnique.Passes[0].End();
blurEffect.End();
// apply effect XNA 4.0
blurEffect.CurrentTechnique.Passes[0].Apply();
GraphicsDevice.DrawPrimitives(PrimitiveType.TriangleList, 0, 2);
//■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■

// XNA 3.1
// commit effect changes
effect.CommitChanges();
// XNA 4.0
// you will need to call EffectPass.Apply() if any of the effect properties change
// Otherwise Delete it.
//■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■

// XNA 3.1
// begin effect
effect.Begin(SaveStateMode.SaveState);
effect.CurrentTechnique.Passes[0].Begin();
// XNA 4.0
// begin effect
effect.CurrentTechnique.Passes[0].Apply();
//■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■

// XNA 3.1
// end effect
effect.CurrentTechnique.Passes[0].End();
effect.End();
// XNA 4.0
// Delete it. No longer needed.
//■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■

// XNA 3.1
// Make a clone of our replacement effect
Effect newEffect = replacementEffect.Clone(replacementEffect.GraphicsDevice);
// XNA 4.0
// Make a clone of our replacement effect. 3.1
Effect newEffect = replacementEffect.Clone();
//■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■

// XNA 3.1
// Activate the appropriate effect technique
postprocessEffect.CurrentTechnique = postprocessEffect.Techniques[effectTechniqueName];

// Draw a fullscreen sprite to apply the postprocessing effect.
spriteBatch.Begin(SpriteBlendMode.None,SpriteSortMode.Immediate, SaveStateMode.None);

postprocessEffect.Begin();
postprocessEffect.CurrentTechnique.Passes[0].Begin();

spriteBatch.Draw(sceneRenderTarget.GetTexture(), Vector2.Zero, Color.White);
spriteBatch.End();

postprocessEffect.CurrentTechnique.Passes[0].End();
postprocessEffect.End();
// XNA 4.0
// Activate the appropriate effect technique
postprocessEffect.CurrentTechnique = postprocessEffect.Techniques[effectTechniqueName];

// Draw a fullscreen sprite to apply the postprocessing effect.
spriteBatch.Begin(0, BlendState.Opaque, null, null, null, postprocessEffect);
spriteBatch.Draw(sceneRenderTarget, Vector2.Zero, Color.White);
spriteBatch.End();

// XNA 3.1
graphics.MinimumPixelShaderProfile = ShaderProfile.PS_3_0; //any PS number...
graphics.MinimumVertexShaderProfile = ShaderProfile.VS_3_0;//any VS number...
// XNA 4.0
// Delete it. No longer needed.
//■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■

// XNA 3.1
float myTime = (float)gameTime.TotalRealTime.TotalSeconds * 0.2f;
// XNA 4.0
float myTime = (float)gameTime.TotalGameTime.TotalSeconds * 0.2f;
//■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■

// XNA 3.1
GraphicsDevice.Clear(Color.TransparentBlack);
// XNA 4.0
GraphicsDevice.Clear(Color.Transparent);

// XNA 3.1
ResolveTexture2D sceneMap;
// XNA 4.0
RenderTarget2D sceneMap;
//■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■

// XNA 3.1
// Lookup the resolution and format of our main backbuffer.
PresentationParameters pp = GraphicsDevice.PresentationParameters;

// Create a texture for reading back the backbuffer contents.
sceneMap = new ResolveTexture2D(GraphicsDevice, pp.BackBufferWidth, pp.BackBufferHeight, 1, pp.BackBufferFormat);
// XNA 4.0
// Look up the resolution and format of our main backbuffer.
PresentationParameters pp = GraphicsDevice.PresentationParameters;

// Create a texture for reading back the backbuffer contents.
sceneMap = new RenderTarget2D(GraphicsDevice, pp.BackBufferWidth, pp.BackBufferHeight, false, pp.BackBufferFormat,
pp.DepthStencilFormat);
//or

sceneMap = new RenderTarget2D(GraphicsDevice, pp.BackBufferWidth, pp.BackBufferHeight, false, pp.BackBufferFormat,
pp.DepthStencilFormat, pp.MultiSampleCount, RenderTargetUsage.DiscardContents);
//■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■

// XNA 3.1
GraphicsDevice.ResolveBackBuffer(sceneMap);
// XNA 4.0
GraphicsDevice.SetRenderTarget(sceneMap);
//■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■

// XNA 3.1
int width = GraphicsDevice.Viewport.Width;
int height = GraphicsDevice.Viewport.Height;

// create render target
myRenderTarget = new RenderTarget2D(GraphicsDevice, width, height, 1, SurfaceFormat.Color);
// XNA 4.0
int width = GraphicsDevice.Viewport.Width;
int height = GraphicsDevice.Viewport.Height;

// create render target
myRenderTarget = new RenderTarget2D(GraphicsDevice, width, height, true, SurfaceFormat.Color, DepthFormat.Depth24);
//■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■

// XNA 3.1
PresentationParameters pp = GraphicsDevice.PresentationParameters;

// Create custom rendertarget
sceneRenderTarget = new RenderTarget2D(GraphicsDevice, pp.BackBufferWidth, pp.BackBufferHeight, 1,
pp.BackBufferFormat, pp.MultiSampleType, pp.MultiSampleQuality)
// XNA 4.0
PresentationParameters pp = GraphicsDevice.PresentationParameters;

// Create custom rendertarget
sceneRenderTarget = new RenderTarget2D(GraphicsDevice, pp.BackBufferWidth, pp.BackBufferHeight, false,
pp.BackBufferFormat, pp.DepthStencilFormat, pp.MultiSampleCount,
RenderTargetUsage.DiscardContents);
//■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■

// XNA 3.1
PresentationParameters pp = GraphicsDevice.PresentationParameters;

// Setup a DepthBuffer
drawBuffer = new RenderTarget2D(GraphicsDevice, pp.BackBufferWidth, pp.BackBufferHeight, 1,
SurfaceFormat.Color, pp.MultiSampleType, pp.MultiSampleQuality);

drawDepthBuffer = new DepthStencilBuffer(GraphicsDevice, pp.AutoDepthStencilFormat,
pp.MultiSampleType, pp.MultiSampleQuality);
// XNA 4.0
PresentationParameters pp = GraphicsDevice.PresentationParameters;

// Setup a DepthBuffer
drawBuffer = new RenderTarget2D(GraphicsDevice, pp.BackBufferWidth, pp.BackBufferHeight, true,
SurfaceFormat.Color,DepthFormat.Depth24Stencil8,
pp.MultiSampleCount, RenderTargetUsage.DiscardContents);
//NOTE: DepthStencilBuffer class no longer exists
//■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■

// XNA 3.1
spriteBatch.Draw(myRenderTarget.GetTexture(), Vector2.Zero, Color.White);
// XNA 4.0
spriteBatch.Draw(myRenderTarget, Vector2.Zero, Color.White); // NOTE: ".GetTexure()" No longer needed
//■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■

// XNA 3.1
Texture2D myTexture = myRenderTarget.GetTexture();
// XNA 4.0
Texture2D myTexture = myRenderTarget; // NOTE: ".GetTexure()" No longer needed
//■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■

// XNA 3.1
GraphicsDevice.SetRenderTarget(0, myRenderTarget);
// XNA 4.0
GraphicsDevice.SetRenderTarget(myRenderTarget);
//■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■

// XNA 3.1
// Set the two render targets
GraphicsDevice.SetRenderTarget(0, colorRT);
GraphicsDevice.SetRenderTarget(1, depthRT);
// XNA 4.0
// Set the two render targets
GraphicsDevice.SetRenderTargets(colorRT, depthRT);
//■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■

// XNA 3.1
GraphicsDevice.SetRenderTarget(0, null);
// XNA 4.0
GraphicsDevice.SetRenderTarget(null);
//■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■

// XNA 3.1
// resolve the backbuffer as the depth map
GraphicsDevice.ResolveBackBuffer(depthMap);

// draw the scene image again, blur it with the depth map
GraphicsDevice.Textures[1] = depthMap;
Viewport viewport = GraphicsDevice.Viewport;
dofEffect.CurrentTechnique = depthBlurTechnique;
DrawFullscreenQuad(sceneMap, viewport.Width, viewport.Height, dofEffect);
// XNA 4.0
// resolve the backbuffer as the depth map
GraphicsDevice.SetRenderTarget(null);

// draw the scene image again, blur it with the depth map
GraphicsDevice.Textures[1] = depthMap;
GraphicsDevice.SamplerStates[1] = SamplerState.PointClamp;
Viewport viewport = GraphicsDevice.Viewport;
dofEffect.CurrentTechnique = depthBlurTechnique;
DrawFullscreenQuad(sceneMap, viewport.Width, viewport.Height, dofEffect);
//■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■

// XNA 3.1
ResolveTexture2D resolveTarget;
RenderTarget2D renderTarget1;
RenderTarget2D renderTarget2;

// Look up the resolution and format of our main backbuffer.
PresentationParameters pp = GraphicsDevice.PresentationParameters;

int width = pp.BackBufferWidth;
int height = pp.BackBufferHeight;
SurfaceFormat format = pp.BackBufferFormat;

// Create a texture for reading back the backbuffer contents.
resolveTarget = new ResolveTexture2D(GraphicsDevice, width, height, 1, format);

// Create two rendertargets half size for the bloom processing.
width /= 2;
height /= 2;

renderTarget1 = new RenderTarget2D(GraphicsDevice, width, height, 1,format);
renderTarget2 = new RenderTarget2D(GraphicsDevice, width, height, 1,format);

// ... In the Draw Method...
GraphicsDevice.ResolveBackBuffer(resolveTarget);
// ...apply effect and draw pass 1...
// XNA 4.0
RenderTarget2D sceneRenderTarget;
RenderTarget2D renderTarget1;
RenderTarget2D renderTarget2;

// Look up the resolution and format of our main backbuffer.
PresentationParameters pp = GraphicsDevice.PresentationParameters;

int width = pp.BackBufferWidth;
int height = pp.BackBufferHeight;
SurfaceFormat format = pp.BackBufferFormat;

// Create a texture for rendering the main scene, prior to applying bloom.
sceneRenderTarget = new RenderTarget2D(GraphicsDevice, width, height, false,
format, pp.DepthStencilFormat, pp.MultiSampleCount,
RenderTargetUsage.DiscardContents);

// Create two rendertargets half size for the bloom processing.
width /= 2;
height /= 2;

renderTarget1 = new RenderTarget2D(GraphicsDevice, width, height, false, format, DepthFormat.None);
renderTarget2 = new RenderTarget2D(GraphicsDevice, width, height, false, format, DepthFormat.None);

// ...In the Draw Method...
GraphicsDevice.SetRenderTarget(sceneRenderTarget);
GraphicsDevice.SamplerStates[1] = SamplerState.LinearClamp;
// ...apply effect and draw pass 1....

// XNA 3.1
// Vertex declaration for rendering our 3D model.
GraphicsDevice.VertexDeclaration = new VertexDeclaration(VertexPositionTexture.VertexElements);
// XNA 4.0
// Delete it. No longer needed.
//■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■

// XNA 3.1
// set vertex buffer and declaration
GraphicsDevice.VertexDeclaration = vertexDeclaration;
GraphicsDevice.Vertices[0].SetSource(vertexBuffer, 0, VertexPositionTexture.SizeInBytes);
// XNA 4.0
// set vertex buffer and declaration
GraphicsDevice.SetVertexBuffer(vertexBuffer);
//■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■

// XNA 3.1
// create vertex declaration
vertexDeclaration = new VertexDeclaration(GraphicsDevice, VertexPositionTexture.VertexElements);
// XNA 4.0
// create vertex declaration
vertexDeclaration = new VertexDeclaration(VertexPositionTexture.VertexDeclaration.GetVertexElements());
//■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■

// XNA 3.1
// reset vertex buffer declaration
GraphicsDevice.VertexDeclaration = null;
GraphicsDevice.Vertices[0].SetSource(null, 0, 0);
// XNA 4.0
// reset vertex buffer declaration
GraphicsDevice.SetVertexBuffer(null);
//■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■

// XNA 3.1
// the vertices array
VertexPositionNormalTexture[] vertices = new VertexPositionNormalTexture[100];

// set new particles to vertex buffer
vertexBuffer.SetData(VertexPositionNormalTexture.SizeInBytes * vertexCount,
vertices,vertexCount,count,VertexPositionNormalTexture.SizeInBytes);
// XNA 4.0
// the vertices array
VertexPositionNormalTexture[] vertices = new VertexPositionNormalTexture[100];

// set new particles to vertex buffer
vertexBuffer.SetData(vertices);

// XNA 3.1
// create the vertex buffer
vertexBuffer = new VertexBuffer(GraphicsDevice, typeof(VertexPositionNormalTexture),
250, BufferUsage.WriteOnly | BufferUsage.Points);
// XNA 4.0
// create the vertex buffer
vertexBuffer = new VertexBuffer(GraphicsDevice, typeof(VertexPositionNormalTexture),
250, BufferUsage.WriteOnly | BufferUsage.None);
//■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■

// XNA 3.1
// enable point sprite 3.1
GraphicsDevice.RenderState.PointSpriteEnable = true;
GraphicsDevice.RenderState.PointSizeMax = 128;
// XNA 4.0
// Delete it. No longer available.
//■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■

// XNA 3.1
// draw the point sprites
GraphicsDevice.DrawPrimitives(PrimitiveType.PointList, vertexPosition, numberVertices);
// XNA 4.0
// draw the point sprites
GraphicsDevice.DrawPrimitives(PrimitiveType.LineList, vertexPosition, numberVertices);

// XNA 3.1
// for each mesh part
foreach (ModelMeshPart meshPart in mesh.MeshParts)
{
// if primitives to render
if (meshPart.PrimitiveCount > 0)
{
// setup vertices and indices
GraphicsDevice.VertexDeclaration = meshPart.VertexDeclaration;
GraphicsDevice.Vertices[0].SetSource(mesh.VertexBuffer, meshPart.StreamOffset, meshPart.VertexStride);
GraphicsDevice.Indices = mesh.IndexBuffer;
...
// XNA 4.0
GraphicsDevice.SamplerStates[0] = SamplerState.LinearWrap; // may be needed in some cases...

// for each mesh part
foreach (ModelMeshPart meshPart in mesh.MeshParts)
{
// if primitives to render
if (meshPart.PrimitiveCount > 0)
{
// setup vertices and indices
GraphicsDevice.SetVertexBuffer(meshPart.VertexBuffer);
GraphicsDevice.Indices = meshPart.IndexBuffer;
...
//■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■

// XNA 3.1
// draw primitives
GraphicsDevice.DrawIndexedPrimitives(PrimitiveType.TriangleList,
meshPart.BaseVertex, 0, meshPart.NumVertices,
meshPart.StartIndex, meshPart.PrimitiveCount);
// XNA 4.0
// draw primitives
GraphicsDevice.DrawIndexedPrimitives(PrimitiveType.TriangleList, 0, 0,
meshPart.NumVertices, meshPart.StartIndex, meshPart.PrimitiveCount);

// XNA 3.1
// open the container
StorageContainer storageContainer = storageDevice.OpenContainer("YourGameName");
// XNA 4.0
//To make life easier simply create a method to replace the storageDevice.OpenContainer...

/// <summary>
/// Synchronously opens storage container
/// </summary>
private static StorageContainer OpenContainer(StorageDevice storageDevice, string saveGameName)
{
IAsyncResult result = storageDevice.BeginOpenContainer(saveGameName, null, null);

// Wait for the WaitHandle to become signaled.
result.AsyncWaitHandle.WaitOne();

StorageContainer container = storageDevice.EndOpenContainer(result);

// Close the wait handle.
result.AsyncWaitHandle.Close();

return container;
}

// open the container
StorageContainer storageContainer = OpenContainer(storageDevice, "YourGameName");
//■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■

// XNA 3.1
// retrieve the storage device
Guide.BeginShowStorageDeviceSelector(GetStorageDeviceResult, retrievalDelegate);
// XNA 4.0
// retrieve the storage device
if (!Guide.IsVisible)
{
StorageDevice.BeginShowSelector(GetStorageDeviceResult, retrievalDelegate);
}
//■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■

// XNA 3.1
// retrieve and store the storage device
storageDevice = Guide.EndShowStorageDeviceSelector(result);
// XNA 4.0
// retrieve and store the storage device
storageDevice = StorageDevice.EndShowSelector(result);
//■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■

// XNA 3.1
// get the level setup files
string[] filenames = Directory.GetFiles(storageContainer.Path, "LevelSetup*.xml");
// XNA 4.0
// get the level setup files
string[] filenames = storageContainer.GetFileNames("LevelSetup*.xml");
//■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■

// XNA 3.1
// save game level data
using (FileStream stream = new FileStream(Path.Combine(storageContainer.Path, levelFilename), FileMode.Create))
{
new XmlSerializer(typeof(SaveGameLevel)).Serialize(stream, levelData);
}
// XNA 4.0
// save game level data
using (Stream stream = storageContainer.OpenFile(levelFilename, FileMode.Create))
{
new XmlSerializer(typeof(SaveGameLevel)).Serialize(stream, levelData);
}
//■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■

// XNA 3.1
// Delete the saved game level data.
using (StorageContainer storageContainer = storageDevice.OpenContainer("saveGameName"))
{
File.Delete(Path.Combine(storageContainer.Path, saveGameLevel.FileName));

File.Delete(Path.Combine(storageContainer.Path, "SaveGameLevel" +
Path.GetFileNameWithoutExtension(saveGameLevel.FileName).Substring(8) +".xml"));
}
// XNA 4.0
// Delete the saved game level data. NOTE: using OpenContainer method created in previous example
using (StorageContainer storageContainer = OpenContainer(storageDevice, "saveGameName"))
{
storageContainer.DeleteFile(saveGameLevel.FileName);

storageContainer.DeleteFile("SaveGameLevel" +
Path.GetFileNameWithoutExtension(saveGameLevel.FileName).Substring(8) + ".xml");
}
//■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■

// XNA 3.1
//Load the Next Level...

// Find the path of the next level.
string levelPath;

// Loop here so we can try again when we can't find a level.
while (true)
{
// Try to find the next level. They are sequentially numbered txt files.
levelPath = String.Format("Levels/{0}.txt", ++levelIndex);
levelPath = Path.Combine(StorageContainer.TitleLocation, "Content/" + levelPath);
if (File.Exists(levelPath))
break;

// If there isn't even a level 0, something has gone wrong.
if (levelIndex == 0)
throw new Exception("No levels found.");

// Whenever we can't find a level, start over again at 0.
levelIndex = -1;
}

// Unloads the content for the current level before loading the next one.
if (level != null)
level.Dispose();

// Load the level.
level = new Level(Services, levelPath);
// XNA 4.0
// Load the Next Level...

// move to the next level
levelIndex = (levelIndex + 1) % numberOfLevels;

// Unloads the content for the current level before loading the next one.
if (level != null)
level.Dispose();

// Load the level.
string levelPath = string.Format("Content/Levels/{0}.txt", levelIndex);
using (Stream fileStream = TitleContainer.OpenStream(levelPath))
level = new Level(Services, fileStream, levelIndex);
//■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■

// XNA 3.1
//Save the current state of the session, with the given storage device.

// check the parameter
if ((storageDevice == null) || !storageDevice.IsConnected)
{
return;
}

// open the container
using (StorageContainer storageContainer = storageDevice.OpenContainer(Session.SaveGameContainerName))
{
string filename;
string descriptionFilename;

// get the filenames
if (overwriteDescription == null)
{
int saveGameIndex = 0;
string testFilename;
do
{
saveGameIndex++;
testFilename = Path.Combine(storageContainer.Path, "SaveGame" + saveGameIndex.ToString() + ".xml");
}
while (File.Exists(testFilename));
filename = testFilename;
descriptionFilename = "SaveGameDescription" + saveGameIndex.ToString() + ".xml";
}
else
{
filename = Path.Combine(storageContainer.Path, overwriteDescription.FileName);
descriptionFilename = "SaveGameDescription" +
Path.GetFileNameWithoutExtension(overwriteDescription.FileName).Substring(8) + ".xml";
}

using (FileStream stream = new FileStream(filename, FileMode.Create))
{
using (XmlWriter xmlWriter = XmlWriter.Create(stream))
{
//create and write xml data...
}
}

// create the save game description
SaveGameDescription description = new SaveGameDescription();
description.FileName = Path.GetFileName(filename);
description.ChapterName = IsQuestLineComplete ? "Quest Line Complete" : Quest.Name;
description.Description = DateTime.Now.ToString();

using (FileStream stream = new FileStream(Path.Combine(storageContainer.Path, descriptionFilename), FileMode.Create))
{
new XmlSerializer(typeof(SaveGameDescription)).Serialize(stream, description);
}
}
// XNA 4.0
//Save the current state of the session, with the given storage device.

// check the parameter
if ((storageDevice == null) || !storageDevice.IsConnected)
{
return;
}

// open the container Note: using OpenContainer method from previous examples
using (StorageContainer storageContainer = OpenContainer(storageDevice, Session.SaveGameContainerName))
{
string filename;
string descriptionFilename;
// get the filenames
if (overwriteDescription == null)
{
int saveGameIndex = 0;
string testFilename;
do
{
saveGameIndex++;
testFilename = "SaveGame" + saveGameIndex.ToString() + ".xml";
}
while (storageContainer.FileExists(testFilename));
filename = testFilename;
descriptionFilename = "SaveGameDescription" + saveGameIndex.ToString() + ".xml";
}
else
{
filename = overwriteDescription.FileName;
descriptionFilename = "SaveGameDescription" +
Path.GetFileNameWithoutExtension(overwriteDescription.FileName).Substring(8) + ".xml";
}

// Note: using Stream instead of FileStream...
using (Stream stream = storageContainer.OpenFile(filename, FileMode.Create))
{
using (XmlWriter xmlWriter = XmlWriter.Create(stream))
{
//create and write xml data...
}
}

// create the save game description
SaveGameDescription description = new SaveGameDescription();
description.FileName = Path.GetFileName(filename);
description.ChapterName = IsQuestLineComplete ? "Quest Line Complete" : Quest.Name;
description.Description = DateTime.Now.ToString();

// Note: using Stream instead of FileStream...
using (Stream stream = storageContainer.OpenFile(descriptionFilename, FileMode.Create))
{
new XmlSerializer(typeof(SaveGameDescription)).Serialize(stream, description);
}
}

// XNA 3.1
VertexShaderOutput VertexShader(...)
{
//some code
}
float4 PixelShader(...)
{
// some code
}
// XNA 4.0
// VertexShader can not be used
VertexShaderOutput VertexShaderFunction(...)
{
// some code
}
// PixelShader can not be used
float4 PixelShaderFunction(...)
{
// some code
}
//■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■

// XNA 3.1
technique
{
    pass
    {
     VertexShader = compile vs_1_1 VertexShader();
     PixelShader = compile ps_1_1 PixelShader();
    }
}
// XNA 4.0
technique
{
     pass
     {
     VertexShader = compile vs_2_0 VertexShaderFunction(); 
    //VertexShader can not be used & set vs higher than 1_1
     PixelShader = compile ps_2_0 PixelShaderFunction(); / 
    //PixelShader can not be used & set ps higher than 1_1
    }
}

//Add the following code before the XNA Model Draw code

// Set suitable renderstates for drawing a 3D model
GraphicsDevice.BlendState = BlendState.Opaque;
GraphicsDevice.DepthStencilState = DepthStencilState.Default;

// your model draw code starts here...