private void OnGestureTracked(object sender, GestureArgs args)
{
    // If it wasn't a swipe, we don't care!
    if (args.Gesture != Gesture.Swipe) return;
 
    // Get the direction of the swipe to determine what way
    // the menus should move
    if (args.Direction.X < 0)
    {
        // If we are capped at the right side of the menus, return
        if (current == menus.Length - 1) return;
 
        // Transition the menus
        menus[current].Transition(Menu.MoveDir.OffToLeft);
 
        current++;
 
        menus[current].Transition(Menu.MoveDir.OnFromRight);
    }
    else
    {
        if (current == 0) return;
 
        menus[current].Transition(Menu.MoveDir.OffToRight);
 
        current--;
 
        menus[current].Transition(Menu.MoveDir.OnFromLeft);
    }
}

public interface IModule
{
    event EventHandler DrawOrderChanged;
    event EventHandler UpdateOrderChanged;
 
    void Initialize(IGame game);
 
    void Draw(GameTime gameTime);
    void Update(GameTime gameTime);
 
    int DrawOrder { get; }
    int UpdateOrder { get; }
 
    bool IsVisible { get; set; }
    bool IsEnabled { get; set; }
    bool IsInitialized { get; set; }
 
    IModule Parent { get; set; }
    ModuleCollection Modules { get; }
}

public class ModuleCollection : Collection<IModule>
{
    private List<IModule> drawList = new List<IModule>();

    public T GetModule<T>() where T : class, IModule
    {
        for (int i = 0; i < Count; i++)
            if (this[i] is T)
                return this[i] as T;
 
        return default(T);
    }

    public void Initialize(IGame game)
    {
        if (IsInitialized) return;
 
        Game = game;
 
        for (int i = 0; i < Count; i++)
            if(!this[i].IsInitialized)
                this[i].Initialize(game);
 
        IsInitialized = true;
    }
 
    public void Draw(GameTime gameTime)
    {
        for (int i = 0; i < drawList.Count; i++)
            if(drawList[i].IsVisible)
                drawList[i].Draw(gameTime);
    }
 
    public void Update(GameTime gameTime)
    {
        for (int i = 0; i < Count; i++)
            if(this[i].IsEnabled)
                this[i].Update(gameTime);
    }

    protected override void OnItemAdded(object sender, CollectionChangedEventArgs args)
    {
        IModule module = args.Item as IModule;
 
        if (module == null) return;
 
        module.DrawOrderChanged += OnModuleDrawOrderChanged;
        module.UpdateOrderChanged += OnModuleUpdateOrderChanged;
 
        if (IsInitialized && !module.IsInitialized)
            module.Initialize(Game);
 
        drawList.Add(module);
        drawList.Sort(DrawOrderComparer.Default);
 
        Sort(UpdateOrderComparer.Default);
 
        base.OnItemAdded(sender, args);
    }
 
    protected virtual void OnModuleUpdateOrderChanged(object sender, EventArgs e)
    {
        Sort(UpdateOrderComparer.Default);
    }
 
    protected virtual void OnModuleDrawOrderChanged(object sender, EventArgs e)
    {
        drawList.Sort(DrawOrderComparer.Default);
    }

    protected override void OnItemRemoved(object sender, CollectionChangedEventArgs args)
    {
        IModule module = args.Item as IModule;
 
        if (module == null) return;
 
        module.DrawOrderChanged -= OnModuleDrawOrderChanged;
        module.UpdateOrderChanged -= OnModuleUpdateOrderChanged;
 
        drawList.Remove(module);
 
        base.OnItemRemoved(sender, args);
    }

    protected IGame Game { get; private set; }
    protected bool IsInitialized { get; private set; }
}

public class Module : NotifyPropertyChangedBase, IModule
{
    private int drawOrder = 0;
    private int updateOrder = 0;
 
    private bool isVisible = true;
    private bool isEnabled = true;
 
    private IModule parent = null;
 
    public event EventHandler DrawOrderChanged;
    public event EventHandler UpdateOrderChanged;
 
    public Module()
    {
        Modules = new ModuleCollection();
 
        Modules.ItemAdded += OnModuleAdded;
        Modules.ItemRemoved += OnModuleRemoved;
    }

    protected virtual void OnDrawOrderChanged(object sender, EventArgs args)
    {
        if (DrawOrderChanged != null) DrawOrderChanged.Invoke(sender, args);
    }
 
    protected virtual void OnUpdateOrderChanged(object sender, EventArgs args)
    {
        if (UpdateOrderChanged != null) UpdateOrderChanged.Invoke(sender, args);
    }

    protected virtual void OnModuleAdded(object sender, CollectionChangedEventArgs args)
    {
        IModule module = args.Item as IModule;
 
        if (module == null) return;
 
        module.Parent = this;
    }
 
    protected virtual void OnModuleRemoved(object sender, CollectionChangedEventArgs args)
    {
        IModule module = args.Item as IModule;
 
        if (module == null) return;
 
        // First we check to ensure that the developer
        // hasn't set the parent manually to some other
        // object before we remove ourselves as parent.
        if(module.Parent == this)
            module.Parent = null;
    }

    public virtual void Initialize(IGame game)
    {
        Game = game;
 
        Modules.Initialize(game);
 
        IsInitialized = true;
    }
 
    public virtual void Draw(GameTime gameTime)
    {
        Modules.Draw(gameTime);
    }
 
    public virtual void Update(GameTime gameTime)
    {
        Modules.Update(gameTime);
    }

    public int DrawOrder
    {
        get { return drawOrder; }
        set
        {
            drawOrder = value;
 
            OnDrawOrderChanged(this, EventArgs.Empty);
        }
    }
 
    public int UpdateOrder
    {
        get { return updateOrder; }
        set
        {
            updateOrder = value;
 
            OnUpdateOrderChanged(this, EventArgs.Empty);
        }
    }
 
    public bool IsVisible
    {
        get { return isVisible; }
        set { isVisible = value; }
    }
 
    public bool IsEnabled
    {
        get { return isEnabled; }
        set { isEnabled = value; }
    }
 
    public IModule Parent
    {
        get { return parent; }
        set { parent = value; }
    }
 
    public bool IsInitialized { get; protected set; }
 
    public ModuleCollection Modules { get; private set; }
 
    protected IGame Game { get; private set; }
}

DisplaySize = new Vector2(272, 480);
DisplayOrientation = DisplayOrientation.Rotated;
 
Console.WriteLine(OrientedDisplaySize.ToString());

public class Game1 : Application
{
    public Game1()
    {
        // Set the display size and the rotation
        DisplaySize = new Vector2(272, 480);
        DisplayOrientation = DisplayOrientation.Rotated;
    }
 
    // ...
}

using Microsoft.Xna.Framework;
 
namespace FocusedGames.Xna
{
    public interface IGame
    {
        void Run();
        void Exit();
 
        Vector2 ObjectToScreen(Vector2 objectVector);
        Vector2 ScreenToObject(Vector2 screenVector);
 
        GraphicsDeviceManager DeviceManager { get; }
 
        DisplayOrientation DisplayOrientation { get; set; }
        Vector2 DisplaySize { get; set; }
 
        bool IsLoaded { get; }
 
        float TargetFrameRate { get; set; }
 
        ModuleCollection Modules { get; }
    }
}

namespace FocusedGames.Xna
{
    /// <summary>
    /// Represents the orientation of the display.
    /// </summary>
    public enum DisplayOrientation : byte
    {
        /// <summary>
        /// Represents the standard orientation of the display. For Zune and Zune HD this is portrait mode.
        /// </summary>
        Standard = 0,
 
        /// <summary>
        /// Represents a 180 degree flip of the standard orientation.
        /// </summary>
        Flipped = 1,
 
        /// <summary>
        /// Represents a 90 degree rotation of the standard orientation. For the Zune and Zune HD this is landscape mode.
        /// </summary>
        Rotated = 2,
 
        /// <summary>
        /// Represents a -90 degree rotation of the standard orientation.
        /// </summary>
        ReverseRotated = 3
    }
}

namespace FocusedGames.Xna
{
    public class ModuleCollection
    {
    }
}

using System;
 
using Microsoft.Xna.Framework;
using Microsoft.Xna.Framework.Graphics;
 
namespace FocusedGames.Xna
{
    public class Application : Game, IGame
    {

        private DisplayOrientation displayOrientation;
        private float displayRotation = 0f;
        private SpriteEffects displaySpriteEffects = SpriteEffects.None;
 
        private Vector2 orientedDisplaySize = new Vector2(800, 600);
        private Vector2 displaySize = new Vector2(800, 600);
 
        private SpriteBatch spriteBatch;
        private RenderTarget2D renderTarget;

        public Application()
        {
            Modules = new ModuleCollection();
 
            DeviceManager = new GraphicsDeviceManager(this);
 
            ClearColor = Color.Black;
            DisplayOrientation = DisplayOrientation.Standard;
 
            Content.RootDirectory = "Content";
 
#if ZUNE
            // Frame rate is 30 fps by default for Zune.
            TargetElapsedTime = TimeSpan.FromSeconds(1 / 30.0);
#endif
        }

        protected override void LoadContent()
        {
            spriteBatch = new SpriteBatch(GraphicsDevice);
 
            SetDisplaySize(displaySize);
 
            ResetRenderTarget();
 
            base.LoadContent();
 
            IsLoaded = true;
        }
 
        protected override void UnloadContent()
        {
            if(spriteBatch != null && !spriteBatch.IsDisposed)
                spriteBatch.Dispose();
 
            base.UnloadContent();
 
            IsLoaded = false;
        }

        protected virtual void SetDisplayOrientation(DisplayOrientation newOrientation)
        {
            // Removed so this method can act as a reset as well
            // if (newOrientation == displayOrientation) return;
 
            displayOrientation = newOrientation;
 
            // TODO: Handle orientations
            switch (displayOrientation)
            {
                case DisplayOrientation.Standard:
                    orientedDisplaySize = displaySize;
                    displayRotation = 0;
                    displaySpriteEffects = SpriteEffects.None;
                    break;
                case DisplayOrientation.Flipped:
                    orientedDisplaySize = displaySize;
                    displayRotation = 0;
                    displaySpriteEffects = SpriteEffects.FlipVertically | SpriteEffects.FlipHorizontally;
                    break;
                case DisplayOrientation.Rotated:
                    orientedDisplaySize.X = displaySize.Y;
                    orientedDisplaySize.Y = displaySize.X;
                    displayRotation = MathHelper.PiOver2;
                    displaySpriteEffects = SpriteEffects.None;
                    break;
                case DisplayOrientation.ReverseRotated:
                    orientedDisplaySize.X = displaySize.Y;
                    orientedDisplaySize.Y = displaySize.X;
                    displayRotation = MathHelper.PiOver2;
                    displaySpriteEffects = SpriteEffects.FlipVertically | SpriteEffects.FlipHorizontally; //SpriteEffects.FlipHorizontally;
                    break;
            }
 
            if(IsLoaded)
                ResetRenderTarget();
        }

        protected virtual void SetDisplaySize(Vector2 newSize)
        {
            // Removed so this method can act as a reset as well
            // if (newSize == displaySize) return;
 
            displaySize = newSize;
            orientedDisplaySize = newSize;
 
            // Reset the backbuffer
            DeviceManager.PreferredBackBufferWidth = (int)displaySize.X;
            DeviceManager.PreferredBackBufferHeight = (int)displaySize.Y;
 
            // If we already loaded, apply the changed
            if (IsLoaded)
                DeviceManager.ApplyChanges();
 
            // Reset the orientation details
            SetDisplayOrientation(displayOrientation);
        }

        private void ResetRenderTarget()
        {
#if ZUNE
            if (renderTarget != null && !renderTarget.IsDisposed)
                renderTarget.Dispose();
 
            renderTarget = new RenderTarget2D(GraphicsDevice, (int)orientedDisplaySize.X, (int)orientedDisplaySize.Y, 1, SurfaceFormat.Color);
#else
            // TODO: Do some RT work here for Windows / Xbox 360
#endif
        }

        /// <summary>
        /// Clears the GraphicsDevice.
        /// </summary>
        protected virtual void ClearGraphicsDevice()
        {
            GraphicsDevice.Clear(ClearColor);
        }

        protected override bool BeginDraw()
        {
            if (base.BeginDraw())
            {
                if (DisplayOrientation == DisplayOrientation.Standard)
                {
                    ClearGraphicsDevice();
                    return true;
                }
 
                if (renderTarget == null || renderTarget.IsDisposed)
                {
                    ClearGraphicsDevice();
                    return false;
                }
 
                GraphicsDevice.SetRenderTarget(0, renderTarget);
 
                ClearGraphicsDevice();
 
                GraphicsDevice.Viewport = new Viewport
                {
                    X = 0,
                    Y = 0,
                    Width = (int)orientedDisplaySize.X,
                    Height = (int)orientedDisplaySize.Y,
                    MinDepth = GraphicsDevice.Viewport.MinDepth,
                    MaxDepth = GraphicsDevice.Viewport.MaxDepth
                };
 
                return true;
            }
 
            return false;
        }

        protected override void EndDraw()
        {
            if (!IsLoaded)
                return;
 
            if (DisplayOrientation == DisplayOrientation.Standard ||
                (renderTarget == null || renderTarget.IsDisposed))
            {
                //base.EndDraw();
                FinalizeDraw();
 
                return;
            }
 
            GraphicsDevice.SetRenderTarget(0, null);
            GraphicsDevice.Viewport = new Viewport
            {
                X = 0,
                Y = 0,
                Width = (int)displaySize.X,
                Height = (int)displaySize.Y,
                MinDepth = GraphicsDevice.Viewport.MinDepth,
                MaxDepth = GraphicsDevice.Viewport.MaxDepth
            };
 
            spriteBatch.Begin(SpriteBlendMode.None, SpriteSortMode.Immediate, SaveStateMode.SaveState);
 
            spriteBatch.Draw(
                renderTarget.GetTexture(),
                displaySize / 2,
                null,
                Color.White,
                DisplayRotation,
                orientedDisplaySize / 2,
                1f,
                DisplaySpriteEffects,
                0
            );
 
            spriteBatch.End();
 
            //base.EndDraw();
            FinalizeDraw();
        }
 
        private void FinalizeDraw()
        {
            DrawOverlay();
 
            base.EndDraw();
        }
 
        /// <summary>
        /// Draw's unrotated graphics.
        /// </summary>
        protected virtual void DrawOverlay()
        {
        }

        /// <summary>
        /// Gets screen coordinates from object coordinates.
        /// </summary>
        /// <param name="objectVector">The object's coordinates.</param>
        /// <returns>Coordinates in screen space.</returns>
        public Vector2 ObjectToScreen(Vector2 objectVector)
        {
            return new Vector2(displaySize.X - objectVector.Y, objectVector.X);
        }
 
        /// <summary>
        /// Gets object coordinates from screen coordinates.
        /// </summary>
        /// <param name="screenVector">The coordinates in screen space.</param>
        /// <returns>Coordinates in object space.</returns>
        public Vector2 ScreenToObject(Vector2 screenVector)
        {
            return new Vector2(screenVector.Y, displaySize.X - screenVector.X);
        }
 
        public GraphicsDeviceManager DeviceManager { get; private set; }
 
        /// <summary>
        /// Gets or Sets the orientation of the display.
        /// </summary>
        public DisplayOrientation DisplayOrientation
        {
            get { return displayOrientation; }
            set { SetDisplayOrientation(value); }
        }
 
        /// <summary>
        /// Gets or Sets the size of the display.
        /// </summary>
        public Vector2 DisplaySize
        {
            get { return displaySize; }
            set { SetDisplaySize(value); }
        }
 
        /// <summary>
        /// Gets the rotation of the display.
        /// </summary>
        /// <seealso cref="DisplaySpriteEffects"/>
        public float DisplayRotation { get { return displayRotation; } }
 
        /// <summary>
        /// Gets the SpriteEffects for the display's render target.
        /// </summary>
        /// <seealso cref="DisplayRotation"/>
        public SpriteEffects DisplaySpriteEffects { get { return displaySpriteEffects; } }
 
        /// <summary>
        /// Gets whether or not the application has been loaded.
        /// </summary>
        public bool IsLoaded { get; private set; }
 
        /// <summary>
        /// Gets or Sets the clear color of the graphics device.
        /// </summary>
        protected Color ClearColor { get; set; }
 
        /// <summary>
        /// Gets the SpriteBatch used to draw the main render target.
        /// </summary>
        protected SpriteBatch SpriteBatch { get { return spriteBatch; } }
 
        /// <summary>
        /// Gets or Sets the target frame rate for the underlying loop code.
        /// </summary>
        public float TargetFrameRate
        {
            get { return 1 / (float)TargetElapsedTime.TotalSeconds; }
            set
            {
                TargetElapsedTime = TimeSpan.FromSeconds(1 / value);
            }
        }
 
        public ModuleCollection Modules { get; private set; }
    }
}

Texture2D lightTexture;
Texture2D backgroundTexture;
 
RenderTarget2D lightTarget;
RenderTarget2D mainTarget;
 
Effect basicFogOfWarEffect;

protected override void LoadContent()
{
    // Create a new SpriteBatch, which can be used to draw textures.
    spriteBatch = new SpriteBatch(GraphicsDevice);
 
    lightTexture = Content.Load<Texture2D>("Light");
    backgroundTexture = Content.Load<Texture2D>("Background");
    basicFogOfWarEffect = Content.Load<Effect>("Effects/BasicFogOfWar");
 
    mainTarget = CreateRenderTarget();
    lightTarget = CreateRenderTarget();
 
    base.LoadContent();
}
 
private RenderTarget2D CreateRenderTarget()
{
    return new RenderTarget2D(GraphicsDevice, GraphicsDevice.PresentationParameters.BackBufferWidth, GraphicsDevice.PresentationParameters.BackBufferHeight, 1, SurfaceFormat.Color);
}

private void DrawMain(GameTime gameTime)
{
    GraphicsDevice.SetRenderTarget(0, mainTarget);
    GraphicsDevice.Clear(Color.Black);
 
    // Draw the background
    spriteBatch.Begin(SpriteBlendMode.AlphaBlend, SpriteSortMode.Immediate, SaveStateMode.SaveState);
    spriteBatch.Draw(
        backgroundTexture,
        new Rectangle(0, 0, GraphicsDevice.PresentationParameters.BackBufferWidth, GraphicsDevice.PresentationParameters.BackBufferHeight),
        Color.White
    );
    spriteBatch.End();
 
    base.Draw(gameTime);
 
    GraphicsDevice.SetRenderTarget(0, null);
}

private void DrawLights(GameTime gameTime)
{
    GraphicsDevice.SetRenderTarget(0, lightTarget);
    GraphicsDevice.Clear(Color.Black);
 
    MouseState mouseState = Mouse.GetState();
 
    spriteBatch.Begin(SpriteBlendMode.AlphaBlend, SpriteSortMode.Immediate, SaveStateMode.SaveState);
    spriteBatch.Draw(
        lightTexture,
        new Vector2(mouseState.X, mouseState.Y),
        null,
        Color.White,
        0f,
        new Vector2(16, 16),
        Vector2.One * 16,
        SpriteEffects.None,
        1.0f
    );
    spriteBatch.End();
 
    GraphicsDevice.SetRenderTarget(0, null);
}

protected override void Draw(GameTime gameTime)
{
    DrawMain(gameTime);
 
    DrawLights(gameTime);
 
    GraphicsDevice.Clear(Color.Black);
 
    Texture2D mainTex = mainTarget.GetTexture();
    Texture2D lightTex = lightTarget.GetTexture();
 
    basicFogOfWarEffect.Parameters["LightsTexture"].SetValue(lightTex);
 
    spriteBatch.Begin(SpriteBlendMode.AlphaBlend, SpriteSortMode.Immediate, SaveStateMode.SaveState);
 
    basicFogOfWarEffect.Begin();
    basicFogOfWarEffect.CurrentTechnique.Passes[0].Begin();
 
    spriteBatch.Draw(
        mainTex,
        new Rectangle(0, 0, GraphicsDevice.PresentationParameters.BackBufferWidth, GraphicsDevice.PresentationParameters.BackBufferHeight),
        Color.White
    );
    spriteBatch.End();
 
    basicFogOfWarEffect.CurrentTechnique.Passes[0].End();
    basicFogOfWarEffect.End();
}

texture LightsTexture;
 
sampler  ColorSampler  : register(s0);
 
sampler LightsSampler = sampler_state{
	Texture = <LightsTexture>;
};
 
struct VertexShaderOutput
{
    float4 Position : POSITION0;
    float2 TexCoord : TEXCOORD0;
};
 
float4 PixelShaderFunction(VertexShaderOutput input) : COLOR0
{
	float2 tex = input.TexCoord;
 
    float4 color = tex2D(ColorSampler, tex);
    float4 alpha = tex2D(LightsSampler, tex);
 
    return float4(color.r, color.g, color.b, alpha.r);
}
 
technique Technique1
{
    pass Pass1
    {
        PixelShader = compile ps_2_0 PixelShaderFunction();
    }
}

TouchCollection touches = TouchPanel.GetState();
 
foreach (TouchLocation locale in touches)
{
    if (locale.State == TouchLocationState.Released && locale.Id == id1)
        id1 = -1;
    else if (locale.State == TouchLocationState.Pressed && id1 == -1)
        id1 = locale.Id;
    else if (locale.Id == id1)
        pos1 = locale.Position;
}
 
touches = TouchPanel.GetState();
 
foreach (TouchLocation locale in touches)
{
    // Can fail if the first time through it was Pressed.
    if (locale.Id == id1 && locale.State == TouchLocationState.Pressed)
    {
        // Do something important
    }
}

private struct TouchSpot
{
    public Vector2 Position;
    public float Life, MaxLife;
    public bool IsActive;
}

private Texture2D texture;
private TouchSpot[] spots = new TouchSpot[2048];

texture = Content.Load<Texture2D>("Touch");

float et = (float)gameTime.ElapsedGameTime.TotalSeconds;
 
for (int i = 0; i < spots.Length; i++)
{
    if (!spots[i].IsActive) continue;
 
    spots[i].Life -= (et * 10);
 
    if (spots[i].Life <= 0)
        spots[i].IsActive = false;
}

TouchCollection touchPoints = TouchPanel.GetState();
 
foreach (TouchLocation location in touchPoints)
{
    int index = FindInactiveSpot();
 
    if (index == -1) break;
 
    spots[index].Position = location.Position;
    spots[index].Life = location.Pressure * 1000;
    spots[index].MaxLife = location.Pressure * 1000;
    spots[index].IsActive = true;
}

private int FindInactiveSpot()
{
    for (int i = 0; i < spots.Length; i++)
    {
        if (!spots[i].IsActive)
            return i;
    }
 
    return -1;
}

spriteBatch.Begin(SpriteBlendMode.AlphaBlend);
for (int i = 0; i < spots.Length; i++)
{
    if (!spots[i].IsActive) continue;
 
    spriteBatch.Draw(
        texture,
        spots[i].Position,
        null,
        new Color(1f, 1f, 1f, spots[i].Life / spots[i].MaxLife),
        0f,
        new Vector2(16, 16),
        spots[i].Life / spots[i].MaxLife * 1.5f,
        SpriteEffects.None,
        1f
    );
}
spriteBatch.End();

<PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|x86' ">
  <DebugSymbols>true</DebugSymbols>
  <DebugType>full</DebugType>
  <Optimize>false</Optimize>
  <OutputPath>..\Bin\x86\Debug\</OutputPath>
  <DefineConstants>DEBUG;TRACE;WINDOWS</DefineConstants>
  <ErrorReport>prompt</ErrorReport>
  <WarningLevel>4</WarningLevel>
  <NoStdLib>true</NoStdLib>
  <UseVSHostingProcess>false</UseVSHostingProcess>
  <PlatformTarget>x86</PlatformTarget>
  <XnaCompressContent>false</XnaCompressContent>
</PropertyGroup>
<PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|x86' ">
  <DebugType>pdbonly</DebugType>
  <Optimize>true</Optimize>
  <OutputPath>..\Bin\x86\Release\</OutputPath>
  <DefineConstants>TRACE;WINDOWS</DefineConstants>
  <ErrorReport>prompt</ErrorReport>
  <WarningLevel>4</WarningLevel>
  <NoStdLib>true</NoStdLib>
  <UseVSHostingProcess>false</UseVSHostingProcess>
  <PlatformTarget>x86</PlatformTarget>
  <XnaCompressContent>true</XnaCompressContent>
</PropertyGroup>

<PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|x64' ">
  <DebugSymbols>true</DebugSymbols>
  <DebugType>full</DebugType>
  <Optimize>false</Optimize>
  <OutputPath>..\Bin\x64\Debug\</OutputPath>
  <DefineConstants>DEBUG;TRACE;WINDOWS</DefineConstants>
  <ErrorReport>prompt</ErrorReport>
  <WarningLevel>4</WarningLevel>
  <NoStdLib>true</NoStdLib>
  <UseVSHostingProcess>false</UseVSHostingProcess>
  <PlatformTarget>x64</PlatformTarget>
  <XnaCompressContent>false</XnaCompressContent>
</PropertyGroup>
<PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|x64' ">
  <DebugType>pdbonly</DebugType>
  <Optimize>true</Optimize>
  <OutputPath>..\Bin\x64\Release\</OutputPath>
  <DefineConstants>TRACE;WINDOWS</DefineConstants>
  <ErrorReport>prompt</ErrorReport>
  <WarningLevel>4</WarningLevel>
  <NoStdLib>true</NoStdLib>
  <UseVSHostingProcess>false</UseVSHostingProcess>
  <PlatformTarget>x64</PlatformTarget>
  <XnaCompressContent>true</XnaCompressContent>
</PropertyGroup>