Even more interesting stuff (for XNA & MonoGame)

As the first article in series got quite popular, we decided to go for the second part.

UI

Progress bars are a common feature in game UI design when representing mechanics such as character interaction, weapon reloading, power meters, etc. A circular progress bar is simply one that fills/empties radially rather than linearly. They have become more popular recently as they are more appealing to the eye than the traditional straight progress bar.

Markup Text Rendering

The markup engine uses little strategies (I called them resolvers) to translate from an attribute string to whatever it needs to render the markup, e.g. the image resolver translates a string into a Texture2D. The source text is “compiled” into an representation that can be drawn repeatedly without generating garbage (at least this was my intention).

Mass-Effect Like Dialogue

The looks and behaviour of the dialogue system and dialogue wheel.

World of Goo like Cursor

The most important element of the sample is the Cursor class. This is a DrawableGameComponent the handles the updating and drawing of the cursor. To add a cursor to your game, you simply add a cursor instance to your Components list.

2D Pie Drawing

After I’ve seen some people asking how to do this on the forums, I decided to make a small class that allows us to draw Pies in 2D in XNA.

Particles

2D Particle Tutorial

Well now onto something I know even less about, 2D particles. As you may or may not have seen I have had a play with these in my GSM Library where I have put a star field in as an optional background, but I said I would post my current knowledge of particles both 3D and 2D so here is my tutorial on 2D particles.

Particle Systems

In this chapter, we will see how to implement a particle system with all the update and animation code running entirely on the GPU, inside some pixel shaders.

Post-Processing

Post-process Framework Sample - #2

Today I’m posting a post processing framework sample. For those that don’t know, post processing is any manipulation of the frame buffer after the scene has been rendered (but usually before the UI), hence the word “post” in the name. This process could be a simple blurring, or it could be a motion blur or depth of field technique. But what if you have many post processes? For instance, maybe we have bloom, motion blur, heat haze, depth of field, and other post processes that we need to apply after we render our scene. Connecting all these post processes together can get a little hairy, and that’s what this sample helps us do.

Post-process Effect: Pixelate

This one’s a quite easy one, and even with shaders the process would be similar. But when using shaders, this could just be one step towards more interesting effects, like Bloom.

Post-process Effect: Random Noise

My original inspiration for this was the subtle ‘film grain’ effect seen in the first Mass Effect, though by no means do I think my version is anywhere near in quality and subtleness. Actually, I kinda pushed it to be more visible for the sake of this article.

Post-process Effect: Negative Image, Color Boost

The purpose here is to achieve the negative of an image. In HLSL this is easily achieved by subtracting the original color from (1,1,1).

Rim Lighting

This time, we have a smaller sample. This sample shows the implementation of a “rim lighting” shader, customizable by a series of parameters.

XNA Effects – ASCII Art in 3D

The theme in November was “Text Based” and its rule was that you were only allowed to use text in the visuals of your game. I saw some of the cool stuff other developers were working on, including one that looked like it had text characters that could walk and talk, like people. But my mind immediately went to a different solution: I wanted to make a game that was fully 3D (effectively breaking the rule of rendering text), but then post-process the render into ASCII art, so it would look like it was text.

11 useful HLSL post effects

The demo consists of the 11 useful HLSL post effects. The parameters of the each effect can be changed at runtime to adjust the final result.

Easy multi-platform managment with MonoGame

8 Replies

So MonoGame is a great technology that allows us write common C# code and deploy our games to Windows-Desktop, Windows-Metro, Windows-Phone, MacOS, Linux, IOS, Android, Ouya and even more. Being able to write portable code is great for us indie developers, though still your code may need some platform specific parts.

With our latest game Frenzied (which can run on Windows, Windows-Metro, Windows Phone 7, Windows Phone 8, Android, MacOS and Linux atm), we introduced our in-house platform-managment concept which we decided to blog about, so that others can also utilize.

Here’s how we are managing multiple-platforms for Frenzied.

First of all we created per-platform solution files;

Each project defines it’s own conditional compilation symbols so we can distinguish them;

Then we defined some enums, the first one is Platforms;

    /// <summary>
    /// Platforms.
    /// </summary>
    public enum Platforms
    {
        Windows,
        WindowsMetro,
        WindowsPhone7,
        WindowsPhone8,
        Linux,
        MacOS,
        Android,
        IOS,
        PSP,
        Ouya,
    }

/// <summary>

/// Platforms.

/// </summary>

public enum Platforms

{

Windows,

WindowsMetro,

WindowsPhone7,

WindowsPhone8,

Linux,

MacOS,

Android,

IOS,

PSP,

Ouya,

}

GraphicsAPI enum;

    /// <summary>
    /// Graphics API's.
    /// </summary>
    public enum GraphicsAPI
    {
        DirectX9,
        DirectX11,
        OpenGL,
    }

/// <summary>

/// Graphics API's.

/// </summary>

public enum GraphicsAPI

{

DirectX9,

DirectX11,

OpenGL,

}

Frameworks enums;

    /// <summary>
    /// .Net frameworks.
    /// </summary>
    public enum NetFrameworks
    {
        DotNet,
        Mono
    }

    /// <summary>
    /// Game frameworks.
    /// </summary>
    public enum GameFrameworks
    {
        XNA,
        MonoGame
    }

/// <summary>

/// .Net frameworks.

/// </summary>

public enum NetFrameworks

{

DotNet,

Mono

}

/// <summary>

/// Game frameworks.

/// </summary>

public enum GameFrameworks

{

XNA,

MonoGame

}

Then we implemented our static PlatformManager class, that will be responsible for identifying current platform and running appropriate code.

using System;
using Microsoft.Xna.Framework;

namespace Frenzied.Platforms
{
    /// <summary>
    /// Platform Manager that identifies platforms & manages them.
    /// </summary>
    public static class PlatformManager
    {
        /// <summary>
        /// The current platform.
        /// </summary>
        public static Platforms Platform { get; private set; }

        /// <summary>
        /// Current .Net framework.
        /// </summary>
        public static NetFrameworks DotNetFramework { get; private set; }

        /// <summary>
        /// Current .Net framework's version.
        /// </summary>
        public static Version DotNetFrameworkVersion { get; private set; }

        /// <summary>
        /// Current game framework.
        /// </summary>
        public static GameFrameworks GameFramework { get; private set; }

        /// <summary>
        /// Current game framework's version.
        /// </summary>
        public static Version GameFrameworkVersion { get; private set; }

        /// <summary>
        /// Current graphics api.
        /// </summary>
        public static GraphicsAPI GraphicsApi { get; private set; }

        /// <summary>
        /// Handler for current platform.
        /// </summary>
        public static PlatformHandler PlatformHandler { get; private set; }

        /// <summary>
        /// Helper for current platform.
        /// </summary>
        public static PlatformHelper PlatformHelper { get; private set; }

        static PlatformManager()
        {
            IdentifyPlatform();
        }

        /// <summary>
        /// Should be called by platform-specific startup code.
        /// </summary>
        public static void Startup()
        {
            PlatformHandler.PlatformEntrance(); // run the appropriate platform entrace code.
        }

        /// <summary>
        /// Should be called by actual game code's Initialize() method.
        /// </summary>
        /// <param name="graphicsDeviceManager">The <see cref="GraphicsDeviceManager"/>.</param>
        public static void Initialize(GraphicsDeviceManager graphicsDeviceManager)
        {
            PlatformHandler.Initialize(graphicsDeviceManager); // rtun the appropriate platform initialization code.
        }

        /// <summary>
        /// Identifies the current platform and used frameworks.
        /// </summary>
        private static void IdentifyPlatform()
        {
            // find base platform.
            #if WINDOWS && DESKTOP
                Platform = Platforms.Windows;
                PlatformHandler = new Windows.WindowsPlatform();
                PlatformHelper = new Windows.WindowsHelper();
            #elif WINDOWS && METRO
                Platform = Platforms.WindowsMetro;
                PlatformHandler = new WindowsMetro.WindowsMetroPlatform();
                PlatformHelper = new WindowsMetro.WindowsMetroHelper();
			#elif LINUX && DESKTOP
				Platform = Platforms.Linux;
				PlatformHandler = new Linux.LinuxPlatform();
			#elif MACOS && DESKTOP
				Platform=Platforms.MacOS;
				PlatformHandler = new MacOS.MacOSPlatform();
            #elif WINPHONE7
                Platform = Platforms.WindowsPhone7;
                PlatformHandler = new WindowsPhone7.WindowsPhone7Platform();
            PlatformHelper = new WindowsPhone7.WindowsPhone7Helper();
            #elif WINPHONE8
                Platform = Platforms.WindowsPhone8;
                PlatformHandler = new WindowsPhone8.WindowsPhone8Platform();
                PlatformHelper = new WindowsPhone8.WindowsPhone8Helper();
            #elif ANDROID
                Platform = Platforms.Android;
                PlatformHandler = new Android.AndroidPlatform();
			#elif IOS
				Platform = Platforms.IOS;
				PlatformHandler = new IOS.IOSPlatform();
            #endif

            if (PlatformHandler == null)
                throw new Exception("Unsupported platform!");

            // find dot.net framework.
            DotNetFramework = IsRunningOnMono() ? NetFrameworks.Mono : NetFrameworks.DotNet;

            // find dot.net framework and game framework version.
            #if METRO
                DotNetFrameworkVersion = System.Reflection.IntrospectionExtensions.GetTypeInfo(typeof(Object)).Assembly.GetName().Version;
                GameFrameworkVersion = System.Reflection.IntrospectionExtensions.GetTypeInfo(typeof(Microsoft.Xna.Framework.Game)).Assembly.GetName().Version;
            #else
                DotNetFrameworkVersion = Environment.Version;
                #if WINPHONE7 || WINPHONE8
                    GameFrameworkVersion = new Version(typeof(Microsoft.Xna.Framework.Game).Assembly.FullName.Split(',')[1].Split('=')[1]);
                #else
                    GameFrameworkVersion = System.Reflection.Assembly.GetAssembly(typeof(Microsoft.Xna.Framework.Game)).GetName().Version;
                #endif
            #endif

            // find game framework & graphics-api.
            #if XNA
                GameFramework = GameFrameworks.XNA;
                GraphicsApi = GraphicsAPI.DirectX9;
            #elif MONOGAME
                GameFramework = GameFrameworks.MonoGame;
                #if DIRECTX11
                    GraphicsApi = GraphicsAPI.DirectX11;
                #elif OPENGL
                    GraphicsApi = GraphicsAPI.OpenGL;
                #endif
            #endif
        }

        /// <summary>
        /// Returns true if code runs over Mono framework.
        /// </summary>
        /// <returns>true if running over Mono, false otherwise.</returns>
        public static bool IsRunningOnMono()
        {
            return Type.GetType("Mono.Runtime") != null;
        }
    }
}

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

using System;

using Microsoft.Xna.Framework;

namespace Frenzied.Platforms

{

/// <summary>

/// Platform Manager that identifies platforms & manages them.

/// </summary>

public static class PlatformManager

{

/// <summary>

/// The current platform.

/// </summary>

public static Platforms Platform { get; private set; }

/// <summary>

/// Current .Net framework.

/// </summary>

public static NetFrameworks DotNetFramework { get; private set; }

/// <summary>

/// Current .Net framework's version.

/// </summary>

public static Version DotNetFrameworkVersion { get; private set; }

/// <summary>

/// Current game framework.

/// </summary>

public static GameFrameworks GameFramework { get; private set; }

/// <summary>

/// Current game framework's version.

/// </summary>

public static Version GameFrameworkVersion { get; private set; }

/// <summary>

/// Current graphics api.

/// </summary>

public static GraphicsAPI GraphicsApi { get; private set; }

/// <summary>

/// Handler for current platform.

/// </summary>

public static PlatformHandler PlatformHandler { get; private set; }

/// <summary>

/// Helper for current platform.

/// </summary>

public static PlatformHelper PlatformHelper { get; private set; }

static PlatformManager()

{

IdentifyPlatform();

}

/// <summary>

/// Should be called by platform-specific startup code.

/// </summary>

public static void Startup()

{

PlatformHandler.PlatformEntrance(); // run the appropriate platform entrace code.

}

/// <summary>

/// Should be called by actual game code's Initialize() method.

/// </summary>

/// <param name="graphicsDeviceManager">The <see cref="GraphicsDeviceManager"/>.</param>

public static void Initialize(GraphicsDeviceManager graphicsDeviceManager)

{

PlatformHandler.Initialize(graphicsDeviceManager); // rtun the appropriate platform initialization code.

}

/// <summary>

/// Identifies the current platform and used frameworks.

/// </summary>

private static void IdentifyPlatform()

{

// find base platform.

#if WINDOWS && DESKTOP

Platform = Platforms.Windows;

PlatformHandler = new Windows.WindowsPlatform();

PlatformHelper = new Windows.WindowsHelper();

#elif WINDOWS && METRO

Platform = Platforms.WindowsMetro;

PlatformHandler = new WindowsMetro.WindowsMetroPlatform();

PlatformHelper = new WindowsMetro.WindowsMetroHelper();

#elif LINUX && DESKTOP

Platform = Platforms.Linux;

PlatformHandler = new Linux.LinuxPlatform();

#elif MACOS && DESKTOP

Platform=Platforms.MacOS;

PlatformHandler = new MacOS.MacOSPlatform();

#elif WINPHONE7

Platform = Platforms.WindowsPhone7;

PlatformHandler = new WindowsPhone7.WindowsPhone7Platform();

PlatformHelper = new WindowsPhone7.WindowsPhone7Helper();

#elif WINPHONE8

Platform = Platforms.WindowsPhone8;

PlatformHandler = new WindowsPhone8.WindowsPhone8Platform();

PlatformHelper = new WindowsPhone8.WindowsPhone8Helper();

#elif ANDROID

Platform = Platforms.Android;

PlatformHandler = new Android.AndroidPlatform();

#elif IOS

Platform = Platforms.IOS;

PlatformHandler = new IOS.IOSPlatform();

#endif

if (PlatformHandler == null)

throw new Exception("Unsupported platform!");

// find dot.net framework.

DotNetFramework = IsRunningOnMono() ? NetFrameworks.Mono : NetFrameworks.DotNet;

// find dot.net framework and game framework version.

#if METRO

DotNetFrameworkVersion = System.Reflection.IntrospectionExtensions.GetTypeInfo(typeof(Object)).Assembly.GetName().Version;

GameFrameworkVersion = System.Reflection.IntrospectionExtensions.GetTypeInfo(typeof(Microsoft.Xna.Framework.Game)).Assembly.GetName().Version;

#else

DotNetFrameworkVersion = Environment.Version;

#if WINPHONE7 || WINPHONE8

GameFrameworkVersion = new Version(typeof(Microsoft.Xna.Framework.Game).Assembly.FullName.Split(',')[1].Split('=')[1]);

#else

GameFrameworkVersion = System.Reflection.Assembly.GetAssembly(typeof(Microsoft.Xna.Framework.Game)).GetName().Version;

#endif

// find game framework & graphics-api.

#if XNA

GameFramework = GameFrameworks.XNA;

GraphicsApi = GraphicsAPI.DirectX9;

#elif MONOGAME

GameFramework = GameFrameworks.MonoGame;

#if DIRECTX11

GraphicsApi = GraphicsAPI.DirectX11;

#elif OPENGL

GraphicsApi = GraphicsAPI.OpenGL;

#endif

}

/// <summary>

/// Returns true if code runs over Mono framework.

/// </summary>

/// <returns>true if running over Mono, false otherwise.</returns>

public static bool IsRunningOnMono()

{

return Type.GetType("Mono.Runtime") != null;

}

To get PlatformManager working we have to make two basic calls, the PlatformManager.Startup() and PlatformManager.Initialize(). Startup() call should be made from Program.cs for platforms that have a Main() entrance point where you run the game.

using Frenzied.Platforms;

namespace Frenzied
{
    /// <summary>
    /// The main class.
    /// </summary>
    public static class Program
    {
        /// <summary>
        /// The main entry point for the application.
        /// </summary>
		static void Main()
        {
            PlatformManager.Startup();
        }
    }
}

using Frenzied.Platforms;

namespace Frenzied

{

/// <summary>

/// The main class.

/// </summary>

public static class Program

{

/// <summary>

/// The main entry point for the application.

/// </summary>

static void Main()

{

PlatformManager.Startup();

}

And in Game.cs (or what-ever you call the Game class) within Initialize() function you have to call PlatformManager.Initialize().

namespace Frenzied
{
    /// <summary>
    /// This is the main type for your game
    /// </summary>
    public class FrenziedGame : Game
    {        
        /// <summary>
        /// Allows the game to perform any initialization it needs to before starting to run.
        /// This is where it can query for any required services and load any non-graphic
        /// related content.  Calling base.Initialize will enumerate through any components
        /// and initialize them as well.
        /// </summary>
        protected override void Initialize()
        {
            ...

            PlatformManager.Initialize(this._graphicsDeviceManager);       

            ...

            base.Initialize();
        }
    }
}

namespace Frenzied

{

/// <summary>

/// This is the main type for your game

/// </summary>

public class FrenziedGame : Game

{

/// <summary>

/// Allows the game to perform any initialization it needs to before starting to run.

/// This is where it can query for any required services and load any non-graphic

/// related content. Calling base.Initialize will enumerate through any components

/// and initialize them as well.

/// </summary>

protected override void Initialize()

{

...

PlatformManager.Initialize(this._graphicsDeviceManager);

...

base.Initialize();

}

So PlatformManager will be doing all the hard-work for us. Note that how we handle it specific PlatformHandler and PlatformHelpers instances for each platform.

PlatformHandler is the base class that we can extend to implement our platform specific initialization code and so;

using Microsoft.Xna.Framework;

namespace Frenzied.Platforms
{
    public class PlatformHandler
    {
        protected GraphicsDeviceManager GraphicsDeviceManager;

        public PlatformConfig PlatformConfig;

        public virtual void PlatformEntrance() 
        { }

        public virtual void Initialize(GraphicsDeviceManager graphicsDeviceManager)
        { }
    }
}

using Microsoft.Xna.Framework;

namespace Frenzied.Platforms

{

public class PlatformHandler

{

protected GraphicsDeviceManager GraphicsDeviceManager;

public PlatformConfig PlatformConfig;

public virtual void PlatformEntrance()

{ }

public virtual void Initialize(GraphicsDeviceManager graphicsDeviceManager)

{ }

}

Note the PlatformConfig field that allows us to use platform-specific configuration. So you can for example enable mouse for a platform and disable it for mobiles.

namespace Frenzied.Platforms
{
    public class PlatformConfig
    {
        /// <summary>
        /// Gets or sets if mouse is visible for the platform.
        /// </summary>
        public bool IsMouseVisible { get; set; }

        /// <summary>
        /// Gets or sets a value indicating whether to use fixed time steps.
        /// </summary>
        public bool IsFixedTimeStep { get; set; }

        public GraphicsConfig Graphics { get; private set; }

        /// <summary>
        /// Creates a new instance of platform-config.
        /// </summary>
        public PlatformConfig()
        {
            // init. sub-configs.
            this.Graphics = new GraphicsConfig();

            // set the defaults.
            this.IsMouseVisible = false;
            this.IsFixedTimeStep = false;
        }
    }
}

namespace Frenzied.Platforms

{

public class PlatformConfig

{

/// <summary>

/// Gets or sets if mouse is visible for the platform.

/// </summary>

public bool IsMouseVisible { get; set; }

/// <summary>

/// Gets or sets a value indicating whether to use fixed time steps.

/// </summary>

public bool IsFixedTimeStep { get; set; }

public GraphicsConfig Graphics { get; private set; }

/// <summary>

/// Creates a new instance of platform-config.

/// </summary>

public PlatformConfig()

{

// init. sub-configs.

this.Graphics = new GraphicsConfig();

// set the defaults.

this.IsMouseVisible = false;

this.IsFixedTimeStep = false;

}

PlatformHelper is the base class that we can extend to implement common functionality that needs platform specific code. The best example that comes our mind probably is launching default web-browser.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace Frenzied.Platforms
{
    public class PlatformHelper
    {
        public virtual void LaunchURI(string url)
        { }
    }
}

using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

namespace Frenzied.Platforms

{

public class PlatformHelper

{

public virtual void LaunchURI(string url)

{ }

}

Let’s start implementing our handlers and helpers for each platforms;

Windows-Desktop

using Microsoft.Xna.Framework;

namespace Frenzied.Platforms.Windows
{
    public class WindowsPlatform : PlatformHandler
    {
        public WindowsPlatform()
        {
            this.PlatformConfig = new PlatformConfig()
                {
                    IsMouseVisible = true,
                    IsFixedTimeStep = false,
                    Graphics = {ExtendedEffects = true},
                };
        }

        public override void PlatformEntrance()
        {
            using (var game = new FrenziedGame())
            {
                game.Run();
            }
        }

        public override void Initialize(GraphicsDeviceManager graphicsDeviceManager)
        {
            this.GraphicsDeviceManager = graphicsDeviceManager;

            this.GraphicsDeviceManager.PreferredBackBufferWidth = 1280;
            this.GraphicsDeviceManager.PreferredBackBufferHeight = 720;
            this.GraphicsDeviceManager.ApplyChanges();
        }
    }
}

using Microsoft.Xna.Framework;

namespace Frenzied.Platforms.Windows

{

public class WindowsPlatform : PlatformHandler

{

public WindowsPlatform()

{

this.PlatformConfig = new PlatformConfig()

{

IsMouseVisible = true,

IsFixedTimeStep = false,

Graphics = {ExtendedEffects = true},

};

}

public override void PlatformEntrance()

{

using (var game = new FrenziedGame())

{

game.Run();

}

public override void Initialize(GraphicsDeviceManager graphicsDeviceManager)

{

this.GraphicsDeviceManager = graphicsDeviceManager;

this.GraphicsDeviceManager.PreferredBackBufferWidth = 1280;

this.GraphicsDeviceManager.PreferredBackBufferHeight = 720;

this.GraphicsDeviceManager.ApplyChanges();

}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace Frenzied.Platforms.Windows
{
    public class WindowsHelper : PlatformHelper
    {
        public override void LaunchURI(string url)
        {
            System.Diagnostics.Process.Start(url);
        }
    }
}

using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

namespace Frenzied.Platforms.Windows

{

public class WindowsHelper : PlatformHelper

{

public override void LaunchURI(string url)

{

System.Diagnostics.Process.Start(url);

}

Windows-Metro

using Microsoft.Xna.Framework;

namespace Frenzied.Platforms.WindowsMetro
{
    public class WindowsMetroPlatform : PlatformHandler
    {
        public WindowsMetroPlatform()
        {
            this.PlatformConfig = new PlatformConfig()
            {
                IsMouseVisible = true,
                IsFixedTimeStep = false,
                Graphics = { ExtendedEffects = true },
            };
        }

        public override void PlatformEntrance()
        {
            var factory = new MonoGame.Framework.GameFrameworkViewSource<FrenziedGame>();
            Windows.ApplicationModel.Core.CoreApplication.Run(factory);
        }

        public override void Initialize(GraphicsDeviceManager graphicsDeviceManager)
        {
            this.GraphicsDeviceManager = graphicsDeviceManager;
        }
    }
}

using Microsoft.Xna.Framework;

namespace Frenzied.Platforms.WindowsMetro

{

public class WindowsMetroPlatform : PlatformHandler

{

public WindowsMetroPlatform()

{

this.PlatformConfig = new PlatformConfig()

{

IsMouseVisible = true,

IsFixedTimeStep = false,

Graphics = { ExtendedEffects = true },

};

}

public override void PlatformEntrance()

{

var factory = new MonoGame.Framework.GameFrameworkViewSource<FrenziedGame>();

Windows.ApplicationModel.Core.CoreApplication.Run(factory);

}

public override void Initialize(GraphicsDeviceManager graphicsDeviceManager)

{

this.GraphicsDeviceManager = graphicsDeviceManager;

}

using System;
using Windows.System;

namespace Frenzied.Platforms.WindowsMetro
{
    public class WindowsMetroHelper : PlatformHelper
    {
        public async override void LaunchURI(string url)
        {
            await Launcher.LaunchUriAsync(new Uri(url));
        }
    }
}

using System;

using Windows.System;

namespace Frenzied.Platforms.WindowsMetro

{

public class WindowsMetroHelper : PlatformHelper

{

public async override void LaunchURI(string url)

{

await Launcher.LaunchUriAsync(new Uri(url));

}

Windows Phone 7

using Microsoft.Xna.Framework;

namespace Frenzied.Platforms.WindowsPhone7
{
    public class WindowsPhone7Platform : PlatformHandler
    {
        public WindowsPhone7Platform()
        {
            this.PlatformConfig = new PlatformConfig
                {
                    IsMouseVisible = false,
                    IsFixedTimeStep = false,
                    Graphics = {ExtendedEffects = false},
                };
        }

        public override void PlatformEntrance()
        {
            using (var game = new FrenziedGame())
            {
                game.Run();
            }
        }

        public override void Initialize(GraphicsDeviceManager graphicsDeviceManager)
        {
            this.GraphicsDeviceManager = graphicsDeviceManager;

            this.GraphicsDeviceManager.SupportedOrientations = DisplayOrientation.LandscapeLeft | DisplayOrientation.LandscapeRight;
            this.GraphicsDeviceManager.PreferredBackBufferWidth = 800;
            this.GraphicsDeviceManager.PreferredBackBufferHeight = 480;
            this.GraphicsDeviceManager.IsFullScreen = true;
            this.GraphicsDeviceManager.ApplyChanges();
        }
    }
}

using Microsoft.Xna.Framework;

namespace Frenzied.Platforms.WindowsPhone7

{

public class WindowsPhone7Platform : PlatformHandler

{

public WindowsPhone7Platform()

{

this.PlatformConfig = new PlatformConfig

{

IsMouseVisible = false,

IsFixedTimeStep = false,

Graphics = {ExtendedEffects = false},

};

}

public override void PlatformEntrance()

{

using (var game = new FrenziedGame())

{

game.Run();

}

public override void Initialize(GraphicsDeviceManager graphicsDeviceManager)

{

this.GraphicsDeviceManager = graphicsDeviceManager;

this.GraphicsDeviceManager.SupportedOrientations = DisplayOrientation.LandscapeLeft | DisplayOrientation.LandscapeRight;

this.GraphicsDeviceManager.PreferredBackBufferWidth = 800;

this.GraphicsDeviceManager.PreferredBackBufferHeight = 480;

this.GraphicsDeviceManager.IsFullScreen = true;

this.GraphicsDeviceManager.ApplyChanges();

}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using Microsoft.Phone.Tasks;

namespace Frenzied.Platforms.WindowsPhone7
{
    public class WindowsPhone7Helper : PlatformHelper
    {
        public override void LaunchURI(string url)
        {
            var task = new WebBrowserTask {Uri = new Uri(url)};
            task.Show();
        }
    }
}

using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

using Microsoft.Phone.Tasks;

namespace Frenzied.Platforms.WindowsPhone7

{

public class WindowsPhone7Helper : PlatformHelper

{

public override void LaunchURI(string url)

{

var task = new WebBrowserTask {Uri = new Uri(url)};

task.Show();

}

Windows Phone 8

using Microsoft.Xna.Framework;

namespace Frenzied.Platforms.WindowsPhone8
{
    public class WindowsPhone8Platform : PlatformHandler
    {
        public WindowsPhone8Platform()
        {
            this.PlatformConfig = new PlatformConfig()
            {
                IsMouseVisible = false,
                IsFixedTimeStep = false,
                Graphics = { ExtendedEffects = true },
            };
        }

        public override void Initialize(GraphicsDeviceManager graphicsDeviceManager)
        {
            this.GraphicsDeviceManager = graphicsDeviceManager;

            this.GraphicsDeviceManager.IsFullScreen = true;
            this.GraphicsDeviceManager.SupportedOrientations = DisplayOrientation.LandscapeLeft | DisplayOrientation.LandscapeRight;            
            this.GraphicsDeviceManager.PreferredBackBufferWidth = 1280;
            this.GraphicsDeviceManager.PreferredBackBufferHeight = 720;
            this.GraphicsDeviceManager.ApplyChanges();
        }
    }
}

using Microsoft.Xna.Framework;

namespace Frenzied.Platforms.WindowsPhone8

{

public class WindowsPhone8Platform : PlatformHandler

{

public WindowsPhone8Platform()

{

this.PlatformConfig = new PlatformConfig()

{

IsMouseVisible = false,

IsFixedTimeStep = false,

Graphics = { ExtendedEffects = true },

};

}

public override void Initialize(GraphicsDeviceManager graphicsDeviceManager)

{

this.GraphicsDeviceManager = graphicsDeviceManager;

this.GraphicsDeviceManager.IsFullScreen = true;

this.GraphicsDeviceManager.SupportedOrientations = DisplayOrientation.LandscapeLeft | DisplayOrientation.LandscapeRight;

this.GraphicsDeviceManager.PreferredBackBufferWidth = 1280;

this.GraphicsDeviceManager.PreferredBackBufferHeight = 720;

this.GraphicsDeviceManager.ApplyChanges();

}

using System;
using Windows.System;

namespace Frenzied.Platforms.WindowsPhone8
{
    public class WindowsPhone8Helper : PlatformHelper
    {
        public async override void LaunchURI(string url)
        {
            await Launcher.LaunchUriAsync(new Uri(url));
        }
    }
}

using System;

using Windows.System;

namespace Frenzied.Platforms.WindowsPhone8

{

public class WindowsPhone8Helper : PlatformHelper

{

public async override void LaunchURI(string url)

{

await Launcher.LaunchUriAsync(new Uri(url));

}

Android

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

using Android.App;
using Android.Content;
using Android.OS;
using Android.Runtime;
using Android.Views;
using Android.Widget;
using Microsoft.Xna.Framework;

namespace Frenzied.Platforms.Android
{
    public class AndroidPlatform : PlatformHandler
    {
        public AndroidPlatform()
        {
            this.PlatformConfig = new PlatformConfig()
                {
                    IsMouseVisible = false,
                    IsFixedTimeStep = false,
                };
        }

        public override void Initialize(GraphicsDeviceManager graphicsDeviceManager)
        {
            this.GraphicsDeviceManager = graphicsDeviceManager;

            this.GraphicsDeviceManager.PreferredBackBufferWidth = 800;
            this.GraphicsDeviceManager.PreferredBackBufferHeight = 480;
            this.GraphicsDeviceManager.SupportedOrientations = DisplayOrientation.LandscapeLeft | DisplayOrientation.LandscapeRight;
            this.GraphicsDeviceManager.ApplyChanges();
        }
    }
}

using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

using Android.App;

using Android.Content;

using Android.OS;

using Android.Runtime;

using Android.Views;

using Android.Widget;

using Microsoft.Xna.Framework;

namespace Frenzied.Platforms.Android

{

public class AndroidPlatform : PlatformHandler

{

public AndroidPlatform()

{

this.PlatformConfig = new PlatformConfig()

{

IsMouseVisible = false,

IsFixedTimeStep = false,

};

}

public override void Initialize(GraphicsDeviceManager graphicsDeviceManager)

{

this.GraphicsDeviceManager = graphicsDeviceManager;

this.GraphicsDeviceManager.PreferredBackBufferWidth = 800;

this.GraphicsDeviceManager.PreferredBackBufferHeight = 480;

this.GraphicsDeviceManager.SupportedOrientations = DisplayOrientation.LandscapeLeft | DisplayOrientation.LandscapeRight;

this.GraphicsDeviceManager.ApplyChanges();

}

IOS

using System;
using Microsoft.Xna.Framework;

namespace Frenzied.Platforms.IOS
{
	public class IOSPlatform : PlatformHandler 
	{
		public IOSPlatform()
		{
			this.PlatformConfig = new PlatformConfig()
			{
				IsMouseVisible = false,
				IsFixedTimeStep = false,
			};
		}

		public override void PlatformEntrance()
		{
			FrenziedGame game;

			game = new FrenziedGame ();
			game.Run ();
		}

		public override void Initialize(GraphicsDeviceManager graphicsDeviceManager)
		{
			this.GraphicsDeviceManager = graphicsDeviceManager;

			this.GraphicsDeviceManager.PreferredBackBufferWidth = 1280;
			this.GraphicsDeviceManager.PreferredBackBufferHeight = 720;
			this.GraphicsDeviceManager.ApplyChanges();
		}
	}
}

using System;

using Microsoft.Xna.Framework;

namespace Frenzied.Platforms.IOS

{

public class IOSPlatform : PlatformHandler

{

public IOSPlatform()

{

this.PlatformConfig = new PlatformConfig()

{

IsMouseVisible = false,

IsFixedTimeStep = false,

};

}

public override void PlatformEntrance()

{

FrenziedGame game;

game = new FrenziedGame ();

game.Run ();

}

public override void Initialize(GraphicsDeviceManager graphicsDeviceManager)

{

this.GraphicsDeviceManager = graphicsDeviceManager;

this.GraphicsDeviceManager.PreferredBackBufferWidth = 1280;

this.GraphicsDeviceManager.PreferredBackBufferHeight = 720;

this.GraphicsDeviceManager.ApplyChanges();

}

Linux

using System;
using Microsoft.Xna.Framework;

namespace Frenzied.Platforms.Linux
{
	public class LinuxPlatform : PlatformHandler 
	{
        public LinuxPlatform()
        {
            this.PlatformConfig = new PlatformConfig()
                {
                    IsMouseVisible = true,
                    IsFixedTimeStep = false,
                };
        }

        public override void PlatformEntrance()
        {
            using (var game = new FrenziedGame())
            {
                game.Run();
            }
        }

        public override void Initialize(GraphicsDeviceManager graphicsDeviceManager)
        {
            this.GraphicsDeviceManager = graphicsDeviceManager;

            this.GraphicsDeviceManager.PreferredBackBufferWidth = 1280;
            this.GraphicsDeviceManager.PreferredBackBufferHeight = 720;
            this.GraphicsDeviceManager.ApplyChanges();
        }
	}
}

using System;

using Microsoft.Xna.Framework;

namespace Frenzied.Platforms.Linux

{

public class LinuxPlatform : PlatformHandler

{

public LinuxPlatform()

{

this.PlatformConfig = new PlatformConfig()

{

IsMouseVisible = true,

IsFixedTimeStep = false,

};

}

public override void PlatformEntrance()

{

using (var game = new FrenziedGame())

{

game.Run();

}

public override void Initialize(GraphicsDeviceManager graphicsDeviceManager)

{

this.GraphicsDeviceManager = graphicsDeviceManager;

this.GraphicsDeviceManager.PreferredBackBufferWidth = 1280;

this.GraphicsDeviceManager.PreferredBackBufferHeight = 720;

this.GraphicsDeviceManager.ApplyChanges();

}

MacOS

using System;
using Microsoft.Xna.Framework;
using MonoMac.AppKit;
using MonoMac.Foundation;

namespace Frenzied.Platforms.MacOS
{
	public class MacOSPlatform : PlatformHandler 
	{
		public MacOSPlatform()
		{
			this.PlatformConfig = new PlatformConfig()
			{
				IsMouseVisible = true,
				IsFixedTimeStep = false,
			};
		}

		public override void PlatformEntrance()
		{
			NSApplication.Init ();

			using (var p = new NSAutoreleasePool ()) {
				NSApplication.SharedApplication.Delegate = new AppDelegate ();
				NSApplication.Main (null);
			}
		}

		public override void Initialize(GraphicsDeviceManager graphicsDeviceManager)
		{
			this.GraphicsDeviceManager = graphicsDeviceManager;

			this.GraphicsDeviceManager.PreferredBackBufferWidth = 1280;
			this.GraphicsDeviceManager.PreferredBackBufferHeight = 720;
			this.GraphicsDeviceManager.ApplyChanges();
		}
	}

	class AppDelegate : NSApplicationDelegate
	{
		FrenziedGame game;

		public override void FinishedLaunching (MonoMac.Foundation.NSObject notification)
		{
			game = new FrenziedGame ();
			game.Run ();
		}

		public override bool ApplicationShouldTerminateAfterLastWindowClosed (NSApplication sender)
		{
			return true;
		}
	}  
}

using System;

using Microsoft.Xna.Framework;

using MonoMac.AppKit;

using MonoMac.Foundation;

namespace Frenzied.Platforms.MacOS

{

public class MacOSPlatform : PlatformHandler

{

public MacOSPlatform()

{

this.PlatformConfig = new PlatformConfig()

{

IsMouseVisible = true,

IsFixedTimeStep = false,

};

}

public override void PlatformEntrance()

{

NSApplication.Init ();

using (var p = new NSAutoreleasePool ()) {

NSApplication.SharedApplication.Delegate = new AppDelegate ();

NSApplication.Main (null);

}

public override void Initialize(GraphicsDeviceManager graphicsDeviceManager)

{

this.GraphicsDeviceManager = graphicsDeviceManager;

this.GraphicsDeviceManager.PreferredBackBufferWidth = 1280;

this.GraphicsDeviceManager.PreferredBackBufferHeight = 720;

this.GraphicsDeviceManager.ApplyChanges();

}

class AppDelegate : NSApplicationDelegate

{

FrenziedGame game;

public override void FinishedLaunching (MonoMac.Foundation.NSObject notification)

{

game = new FrenziedGame ();

game.Run ();

}

public override bool ApplicationShouldTerminateAfterLastWindowClosed (NSApplication sender)

{

return true;

}

That’s all! Now we can;

Manage our target platforms all together and have seperate platform specific code.
Have platform specific configuration (ie, hiding the mouse for specific platforms).
Have platform specific code to run behind scenes to implement common functionality (like opening a given URI in default web-browser).

I hope you enjoyed the article, if so please spread/tweet the word If you have any questions please don’t hesitate to send a comment!

Note: I did not implement PlatformHelpers for IOS, Android, MacOS, Linux yet but should be pretty easy to do so!

Frenzied Devlog III – Main Menu

Leave a reply

So development continues on — gameplay is quite complete and we have started committing in the graphics assets starting with the main – menu;

Expect more updates soon!

MonoGame Git Visualization

1 Reply

We have decided to use the awesome gource to visualize the history of MonoGame‘s github repository and the output is fascinating!

So here is how we did;

Step 1 – fetching avatars

To download available avatars for commiters, we used the gravatar script provided in gource’s related wiki page.

#!/usr/bin/perl
#fetch Gravatars

use strict;
use warnings;

use LWP::Simple;
use Digest::MD5 qw(md5_hex);
use Thread::Pool::Simple;

my $size       = 90;
my $output_dir = '.git/avatar';

system("no .git/ directory found in current path\n") unless -d '.git';

mkdir($output_dir) unless -d $output_dir;

open(GITLOG, q/git log --pretty=format:"%ae|%an" |/) or die("failed to read git-log: $!\n");

my %processed_authors;

sub fetch
{
    #try and fetch image
    my ($name, $email, $author_image_file) = @_;
    my $grav_url = "http://www.gravatar.com/avatar/".md5_hex(lc $email)."?d=404&s=".$size;

    warn "fetching image for '$name' $email ($grav_url)...\n";

    my $rc = getstore($grav_url, $author_image_file);
    if($rc != 200) {
        unlink($author_image_file);
    }
}

my $pool = Thread::Pool::Simple->new(min => 10, max => 20, do => [\&fetch]);

while() {
    chomp;
    my($email, $author) = split(/\|/, $_);

    next if $processed_authors{$author}++;

    my $author_image_file = $output_dir . '/' . $author . '.png';
    #skip images we have
    next if -e $author_image_file;

    $pool->add(($author, $email, $author_image_file));
}
$pool->join();

close GITLOG;

#!/usr/bin/perl

#fetch Gravatars

use strict;

use warnings;

use LWP::Simple;

use Digest::MD5 qw(md5_hex);

use Thread::Pool::Simple;

my $size = 90;

my $output_dir = '.git/avatar';

system("no .git/ directory found in current path\n") unless -d '.git';

mkdir($output_dir) unless -d $output_dir;

open(GITLOG, q/git log --pretty=format:"%ae|%an" |/) or die("failed to read git-log: $!\n");

my %processed_authors;

sub fetch

{

#try and fetch image

my ($name, $email, $author_image_file) = @_;

my $grav_url = "http://www.gravatar.com/avatar/".md5_hex(lc $email)."?d=404&s=".$size;

warn "fetching image for '$name' $email ($grav_url)...\n";

my $rc = getstore($grav_url, $author_image_file);

if($rc != 200) {

unlink($author_image_file);

}

my $pool = Thread::Pool::Simple->new(min => 10, max => 20, do => [\&fetch]);

while() {

chomp;

my($email, $author) = split(/\|/, $_);

next if $processed_authors{$author}++;

my $author_image_file = $output_dir . '/' . $author . '.png';

#skip images we have

next if -e $author_image_file;

$pool->add(($author, $email, $author_image_file));

}

$pool->join();

close GITLOG;

Step 2 – run the gource over git repository

E:\dev-software\gource\gource --hide filenames --title "MonoGame Git Visualization" --user-image-dir E:\Source\MonoGame@mono\.git\avatar --logo logo.png --seconds-per-day 0.01 -1280x720 -e 0.5 -o monogame.ppm E:\Source\MonoGame@mono

1	E:\dev-software\gource\gource --hide filenames --title "MonoGame Git Visualization" --user-image-dir E:\Source\MonoGame@mono\.git\avatar --logo logo.png --seconds-per-day 0.01 -1280x720 -e 0.5 -o monogame.ppm E:\Source\MonoGame@mono

Step 3 – render the video with ffmpeg

E:\dev-software\gource\ffmpeg\bin\ffmpeg -y -r 60 -f image2pipe -vcodec ppm -i monogame.ppm -vcodec libx264 -preset ultrafast -crf 18 -pix_fmt yuv420p -threads 0 -bf 0 monogame.avi

1	E:\dev-software\gource\ffmpeg\bin\ffmpeg -y -r 60 -f image2pipe -vcodec ppm -i monogame.ppm -vcodec libx264 -preset ultrafast -crf 18 -pix_fmt yuv420p -threads 0 -bf 0 monogame.avi

Bingo!

Sharp Watch #4

Leave a reply

Welcome to Sharp Watch #4!

Community Watch

Debate of the week – XNA is dead, long live MonoGame!

MonoGame watch

Branch Housekeeping

This video shows off the work the MonoGame team are doing to bring the content pipeline to Mac and Linux. The Content Pipeline will allow developers to optimize their game assets for a particular platform. In this example the .png file is converted to an optimized .xnb file, which is then loaded by MonoGame at runtime.

Listen to Lee Stott (Microsoft UK Evangelist) talk about what options you have when developing for Windows 8 and Windows Phone 8. MonoGame is mentioned quite a few times. This presentation took place at part of the recent Cambridge Game developers meetup.

Cool Effects (for XNA & MonoGame)

1 Reply

Here is a list of cool effects we have found over web that can be used with XNA / MonoGame;

Misc Effects;

Particle Text

The basic technique is the same in both XNA and JavaScript. We draw some text to a render target or canvas and read back its pixels. Then, create one particle for each pixel that makes up the text on our canvas. Finally, place all the particles randomly and have them fly towards their proper position in the text.

2D Metaballs

Metaballs are organic-looking balls that deform as they merge or split, as shown in the picture below. It’s a neat little effect, often used to render liquids or gels. This is a tutorial on how to produce 2D metaballs in XNA. As a bonus, the code requires no custom shaders, and therefore works equally well on Windows Phone, Xbox, and PC.

2D Crepuscular (God) Rays

If you refer back to my post on this for 3D you will see all the same shaders, the difference in this 2D sample is the way the light mask is built. Effectively you need to render your light source, over that render the elements in your scene that are obscuring that source over the top in black to create the light mask, then apply the Crepuscular post processing effect. Then render the scene as you would normaly and then using an additive blend apply the god ray’s over the top.

MonoGame gets Shocked!

We left off just porting Michael Hoffman’s excellent article showing us how to generate lightning effects almost effortlessly using XNA over to MonoGame in minutes, however (as I usually do) I felt it didn’t just go far enough, sure Windows desktop is fine but MonoGame V3 now gives us entry to Windows 8 / RT and Windows Phone for FREE with paid options for other platforms.

Particle Systems;

Particle Sample

This sample introduces the concept of a particle system, and shows how to draw particle effects by using SpriteBatch. Two particle effects are demonstrated: an explosion and a rising plume of smoke.

XML particles

This tutorial teaches you how to extend the Particle 3D sample so the particle systems are defined by XML files loaded with the XNA Content Pipeline.

XNA 2D Particle Engine

XNA 2D Particle Engine is a flexible, extensible particle engine written in XNA Game Studio 4.0. The engine can emit texture-based particles in almost anyway you like and can easily be integrated as a (drawable) Game component in your XNA Game Studio 4.0 projects.

Simple Particle Emitter in XNA 4.0

The particle emitter that I made produces approximately the number of particles specified per second. In most cases, such as producing 100 particles or more a second, it is pretty accurate. It is mainly when the number of particles per second is below the frame rate is when the system is not as accurate, but still it is close enough for a particle emitter, in my opinion.

XNA Particle Systems (Xen)

Xen is a framework for rapidly developing high performance 3D Games for Xbox 360 and PC

Stateful Particle Engine

Deferred Rendering in XNA4.0

Catalin has an excellent tutorial on deferred rendering, unfortunately some of the code no longer works, because it was written for XNA2.0. Fortunately (for you) I’ve converted the entire code base to XNA4.0 as a learning exercise.

Non-Realistic Rendering

This sample shows how to implement stylized, non-photorealistic rendering techniques, such as cartoon shading, edge detection, and a pencil sketch effect.

Frenzied Devlog II – Pie Mode

Leave a reply

Here’s a quick preview video from Frenzied’s Pie Mode;

As you may know the popular gaming stream service own3d.tv decided to cease it’s operations.

So we have just released v0.51 update for eggrr which removes the own3d.tv support completely. It was also a good opportunity to push the favorites feature that was waiting in source repository.

As you can see in the screenshot below, you can now mark games & streams as featured.

Here’s the full change-log of the update;

0.51.0

Added support for favorites feature – you can favorite games & streams!
Favorites feature will use roaming profile so your favorites will be available on your all computers.
Improved visual styles & look.
Removed own3d.tv support as the service is closed. RIP own3d.tv!
Improved app-bar button’s styles.

Go grab eggrr from Windows 8 app-store.

Thanks to monogame, we can target Frenzied to multiple-platforms;

Windows 8 Store
Windows Phone 7
Windows Phone 8
Android
Windows Desktop

and even more these are the future possible platforms we like to release;

IOS
MacOS
Linux
Ouya

Frenzied Devlog I

Leave a reply

We are still working on Frenzied and atm, targeting it to release first for Windows Store and then Android Store. Here is a quick sneak peak video from Frenzied development-build running over android;

Int6 Studios

Invalid opcode for the win!

Even more interesting stuff (for XNA & MonoGame)

UI

Particles

Post-Processing

Easy multi-platform managment with MonoGame

Frenzied Devlog III – Main Menu

MonoGame Git Visualization

Sharp Watch #4

Cool Effects (for XNA & MonoGame)

Frenzied Devlog II – Pie Mode

Frenzied Devlog I