Dark Genesis | Dark Genesis

MonoGame: Content Projects & Custom Model Types

Simon (darkside) Jackson — Fri, 17 May 2013 15:36:02 +0000

Are we sitting comfortably, then let us begin

In yet another one of my adventures with MonoGame and showing new an interesting ways you can take you old XNA code and move it forward on to the MonoGame platform (and still keep your sanity), I’ll go over one of those fringe / advanced options available to old XNA projects where you can effectively build your own content.

The reasons for doing this are quite simple:

    You want to add custom data at build time – e.g. bounding box information, scale, size and weight
    You would like to have XML config to change how your content is built like the particle pipeline sample (http://bit.ly/13suolj)
    You want to pre-pack your model’s effects at build time (Custom types / Skinned model examples)
    You want your cake and you darn well want to eat it too!

There are more but these are the highlights. Basically anywhere that you want to offload processing of your content from run time to build time (why wouldn’t you?), saving you endless amounts of spin cycles, which on some platforms can mean the difference between your game flying along at 30 – 60 fps and a slideshow.

First off – Content Please

Now one of the questions I get asked (or see asked) surround content projects themselves, they are only natively supported in Visual Studio 2010 and later some partial support was added to 2012 for Phone 7 support, this is great if like me you rock out Pro or Ultimate but not everyone has access to these. Sure you can use MonoGame from most of the express editions but, if you try and launch a Content project it just crashes and dies (usually)

To clear things up here are all the configuration in which content projects are definitely supported:

    Visual Studio C# 2010 express*
    Visual Studio Visual Basic 2010 express*
    Visual Studio 2010 express for Windows Phone
    Visual Studio Pro & Ultimate*
    Visual Studio 2012 Pro & Ultimate**
    Visual Studio Express 2012 for Windows Phone

* With XNA GS 4.0 / Windows Phone 7.1 SDK installed

** With the Windows Phone 8 SDK installed

And here are the editions where it is not supported:

    Visual Web developer express 2010*
    Visual Studio 2012 Express for Desktop
    Visual Studio 2012 Express for Windows 8
    Visual Studio 2012 Express for Web
    Xamarin Studio

* Unconfirmed

I highlighted one of the supported editions above specifically because everyone asks “How do I build my content on Windows 8” or “How do I build my content with 2012 if I don’t have pro / ultimate”. The usual answer that people come back with is “You can’t, just use 2010” which as you can see from above is wrong. Even if you don’t intend to deploy to Windows Phone you can still use the WP8SDK to install the express edition that comes with it to build your content in 2012.

One day I’d like MS to stop messing around with this project type support, there are good reasons for doing it but leaving out one or two platforms for no good reason is just daft /Rant.

Getting Started

First off if you haven’t started a MonoGame project before or are just starting a new one, I always recommend to start with the Content Project, get your content right first!

Later you can choose if you want your content project included in your game solution, I’d recommend not (unless it’s a small project) to avoid building it every time. Granted VS 2012 does a much better job at recognising if a project needs building again so you may choose to include it anyway.

For this example I’ll be using the content from the Microsoft Custom Types sample mentioned above, you can find the source sample for this here on my GitHub MonoGame Samples fork.

If you are having trouble locating VS2012 Express for Windows Phone, you can find it here after installing the WP8SDK

“C:\Program Files (x86)\Microsoft Visual Studio 11.0\Common7\IDE\VPDExpress” (drop the (x86) if you’re on a 32 bit machine

Prerequisites

First off make sure you got all the right bits: (you can install these on either Windows 7 or Windows 8)

Studio 2010

    Visual Studio 2010 Express and above (from the above list)
    XNA Game Studio 4.0 (or) – if installed on Windows 8 see this post
    Windows Phone SDK 7.1 + 7.1.1
    MonoGame V3+

    (optional) Zune – needed for VS2010 to deploy to device

Studio 2012

    Visual Studio 2012 Pro+ (or)
    Visual Studio 2012 Express for Windows Phone
    Windows Phone 8 SDK*
    MonoGame V3+

* If you are running on a machine that doesn’t support Hyper-V (SLAT) the emulator won’t install. You can still deploy to a device though.

*Note you will also need to download the Microsoft Content Types sample as we will re-use some of the files from that project in this tutorial.

Now there is one limitation which is pretty self-explanatory if you are using Visual Studio 2012 for Windows Phone edition to build your content project, in that it only knows how to build phone projects, so a fair few of the other project templates are not available. However it is still able to read the other project types (C# libraries for example) but you cannot create them in it (by default).

I’d recommend while you are following this tutorial and only have access to the express editions, to do your content project in 2012 Express for Windows Phone and build your game in 2012 Express for Windows Desktop or Windows 8. However a little trickery will be required to get there using this route.

Create the Content project

As has been shown a lot of times, even on my blog, once you have the above installed (whichever your flavour), you can start a new Content project using the MonoGame Templates

See told you Express 2012 for Windows Phone works

And yes if you are using 2012 like I am above you will likely see the following error, just ignore it, damned annoying if nothing else.

Now add your content to the project (I’m using the Tank model from the custom types sample and including the two textures but not referencing them in the solution or you will get duplicate build errors because they are mentioned in the model file) first to ensure everything builds ok before we start messing with the content project, here I’m selecting Windows as the build platform

Add a Platform for test

With the project built let’s just double check that the content is displaying correctly on its own, just add a MonoGame platform of your choosing to the project and lets display the model (I chose the WindowsGL project because it runs on just about anything*)

*Note, at the time of writing, the WindowsGL template has a slight bug, the reference to the SDL.dll library points to the wrong place, easily corrected, edit the game .csproj file and where it states:

Just remove the “Users\\AppData\” segment, then save and reload the project in Visual Studio.

With our project ready, build the content and then add a link to the built content files in your game project, ensuring you set the build action to “Content” and the CopyTo setting at “Copy if Newer” or “Copy Always”

Lastly some code to actually display the model as is, as follows: (the entire game class in one shot, basic model drawing stuff)

#region Using Statements
using Microsoft.Xna.Framework;
using Microsoft.Xna.Framework.Graphics;
using Microsoft.Xna.Framework.Input;

#endregion

namespace GameName1
{
    /// 
    /// This is the main type for your game
    /// 
    public class Game1 : Game
    {
        GraphicsDeviceManager graphics;
        SpriteBatch spriteBatch;

        Model model;

        Matrix world;
        Matrix view;
        Matrix projection;

        public Game1()
            : base()
        {
            graphics = new GraphicsDeviceManager(this);
            Content.RootDirectory = "Content";
        }

        /// 
        /// 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.
        /// 
        protected override void Initialize()
        {
            // TODO: Add your initialization logic here

            base.Initialize();
        }

        /// 
        /// LoadContent will be called once per game and is the place to load
        /// all of your content.
        /// 
        protected override void LoadContent()
        {
            // Create a new SpriteBatch, which can be used to draw textures.
            spriteBatch = new SpriteBatch(GraphicsDevice);

            // TODO: use this.Content to load your game content here
            model = Content.Load("tank");

            world = Matrix.Identity;

            // Calculate camera view and projection matrices.
            view = Matrix.CreateLookAt(new Vector3(1000, 500, 0),
                                       new Vector3(0, 150, 0), Vector3.Up);

            projection = Matrix.CreatePerspectiveFieldOfView(MathHelper.PiOver4,
                                                             GraphicsDevice.Viewport.AspectRatio, 10, 10000);
            foreach (ModelMesh mesh in model.Meshes)
            {
                foreach (BasicEffect effect in mesh.Effects)
                {
                    effect.EnableDefaultLighting();

                    effect.World = world;
                    effect.View = view;
                    effect.Projection = projection;
                }
            }
        }

        /// 
        /// UnloadContent will be called once per game and is the place to unload
        /// all content.
        /// 
        protected override void UnloadContent()
        {
            // TODO: Unload any non ContentManager content here
        }

        /// 
        /// Allows the game to run logic such as updating the world,
        /// checking for collisions, gathering input, and playing audio.
        /// 
        /// Provides a snapshot of timing values.
        protected override void Update(GameTime gameTime)
        {
            if (GamePad.GetState(PlayerIndex.One).Buttons.Back == ButtonState.Pressed || Keyboard.GetState().IsKeyDown(Keys.Escape))
                Exit();

            // TODO: Add your update logic here

            base.Update(gameTime);
        }

        /// 
        /// This is called when the game should draw itself.
        /// 
        /// Provides a snapshot of timing values.
        protected override void Draw(GameTime gameTime)
        {
            GraphicsDevice.Clear(Color.CornflowerBlue);

            // TODO: Add your drawing code here
            model.Draw(world, view, projection);

            base.Draw(gameTime);
        }
    }
}

Now if you run the solution you should get a model being drawn to the screen.

Getting the Custom Types in your Pipeline

Now there are two schools of thought with how to use custom content types in XNA and both will work with MonoGame itself, however only one way will work (as I found) on all platforms.

The two ways are:

By using the [ContentSerializerRuntimeType] attribute definitions

These are set within your content processor to identify your custom types by their reflection type name, then hosting the class definition for the type in your game project

By using a common library between the content processor and your game project effectively sharing the class definition between the projects

The second option which I’m going to show you here is the one that will work on all platforms, the first is fine for windows platforms but runs into issues with others (in my experience)

First up the Custom Type project

So first we need a class library to hold our custom types, so create a new C# class library for the solution, its namespace needs to be unique in your project to ensure its picked up by both the content processor and your game platform.

*Note as stated earlier, if you are using the 2012 Express editions, you’ll need to swap to VS 2012 Express for Windows Desktop / Windows 8 to create the class library and then switch back to the Phone Express to add the existing project to your content solution. A little tedious but it works (and it’s FREE). You will see (yet another) silly warning telling you the class library is targeting .NET 4.5 and that it needs to convert it to .NET 4.5 to read it (sheesh), just accept the default to update the project.

Once the Class Library is loaded, right-click and select properties on the Class Library project and in the Application tab change the “Target Framework” to .Net 4. XNA and MonoGame just work better that way.

Once the Class Library project is loaded we can setup our custom type we intend to use, you can copy the class over from the XNA sample or just replace the default Class.cs code with the following:

#region File Description
//-----------------------------------------------------------------------------
// CustomModel.cs
//
// Microsoft XNA Community Game Platform
// Copyright (C) Microsoft Corporation. All rights reserved.
//-----------------------------------------------------------------------------
#endregion

#region Using Statements
using System.Collections.Generic;
using Microsoft.Xna.Framework;
using Microsoft.Xna.Framework.Content;
using Microsoft.Xna.Framework.Graphics;
#endregion

namespace CustomContentTypes
{
    /// 
    /// Custom class that can be used as a replacement for the built-in Model type.
    /// This provides functionality roughly similar to Model, but simplified as far
    /// as possible while still being able to correctly render data from arbitrary
    /// X or FBX files. This can be used as a starting point for building up your
    /// own more sophisticated Model replacements.
    /// 
    public class CustomModel
    {
        #region Fields

        // Disable compiler warning that we never initialize these fields.
        // That's ok, because the XNB deserializer initialises them for us!
        #pragma warning disable 649

        // Internally our custom model is made up from a list of model parts.
        [ContentSerializer]
        public List modelParts  { get; private set; }

        // Each model part represents a piece of geometry that uses one
        // single effect. Multiple parts are needed for models that use
        // more than one effect.
        public class ModelPart
        {
            public int TriangleCount;
            public int VertexCount;

            public VertexBuffer VertexBuffer;
            public IndexBuffer IndexBuffer;

            [ContentSerializer(SharedResource = true)]
            public Effect Effect;
        }

        #pragma warning restore 649

        #endregion

        /// 
        /// Private constructor, for use by the XNB deserializer.
        /// 
        private CustomModel()
        {
        }

        /// 
        /// Draws the model using the specified camera matrices.
        /// 
        public void Draw(Matrix world, Matrix view, Matrix projection)
        {
            foreach (ModelPart modelPart in modelParts)
            {
                // Look up the effect, and set effect parameters on it. This sample
                // assumes the model will only be using BasicEffect, but a more robust
                // implementation would probably want to handle custom effects as well.
                BasicEffect effect = (BasicEffect)modelPart.Effect;

                effect.EnableDefaultLighting();

                effect.World = world;
                effect.View = view;
                effect.Projection = projection;

                // Set the graphics device to use our vertex declaration,
                // vertex buffer, and index buffer.
                GraphicsDevice device = effect.GraphicsDevice;

                device.SetVertexBuffer(modelPart.VertexBuffer);

                device.Indices = modelPart.IndexBuffer;

                // Loop over all the effect passes.
                foreach (EffectPass pass in effect.CurrentTechnique.Passes)
                {
                    pass.Apply();

                    // Draw the geometry.
                    device.DrawIndexedPrimitives(PrimitiveType.TriangleList,
                                                 0, 0, modelPart.VertexCount,
                                                 0, modelPart.TriangleCount);
                }
            }
        }
    }
}

There’s not too much fancy stuff here, the Custom Model type in the MS example just provides a more raw view for what goes on under the hood for drawing a model, it reads out the raw model data and stores it in it’s respective Index and Vertex buffers plus all the other necessary information for doing primitive drawing. It also delivers a custom Draw function for sending the Index/Vertex data to the graphics device. If you wished you could change the colour of random vertices / alter the normal mapping of certain elements or even deform the mesh on build, all stuff that would be very expensive to do at runtime.

If you wish you can also rename “class1.cs” to something more appropriate but it’s just for show (Still a good idea though )

The Content Pipeline project

Now we have our custom type, we need a way to tell the content pipeline to use it when loading our model. Open up your Content project again (if it’s separate) and add a new project to the solution, this time select the “Content Pipeline Extension Library” template in the “XNA Game Studio 4.0” branch. (there is a way to do the same thing with a class library but this is easier and safer for now)

Once it’s loaded you should get a default “ContentProcessor1.cs” class in the project, just a starter for 10.

*Note again if you are using 2012 Express for Windows Phone to create the content pipeline extension project, you will need to update the target framework to .NET 4.0 else the content project won’t recognise it

If you want to learn more about how content pipeline extensions work, check out the documentation on the Creators club website here, well worth a read if you want to do more advanced thins with your content before you import it into your game.

Now for simplicities sake (and to prevent this post from becoming miles longer), just copy over the “CustomModelContent.cs” and “CustomModelProcessor.cs” from the XNA sample into your Content Pipeline Extension project and then update the following to match what we are doing here (I always find it best implement these things yourself to ensure you understand what and why they work), then update the following:

Update the namespaces in the two new files to the new project namespace
In the “CustomModelContent.cs” class, update all references of “CustomModelTypes” to the assembly name of your ContentTypes project. e.g.:

Replace:
[ContentSerializerRuntimeType("CustomModelTypes.CustomModel, CustomModelTypes")]

[ContentSerializerRuntimeType("CustomModelTypes.CustomModel+ModelPart, CustomModelTypes")]
With:
[ContentSerializerRuntimeType("CustomContentTypes.CustomModel, CustomContentTypes")]

[ContentSerializerRuntimeType("CustomContentTypes.CustomModel+ModelPart, CustomContentTypes")]
    Add a reference to the Content Types project from the Pipeline Extension project
    Add a reference to the Pipeline extension project from the Content project (note the actual content project where the model is stored NOT the content builder project)

    Finally, add a reference to the Content Types project from the game project

With that in place you should be able to build the content project and now if you select the “Tank.fbx” you should be able to change the tanks content process from the default “Model – XNA Framework” to your new processor type “Custom Model” which uses your new content type class for storing the final built model in.

*Note if the new Processor type doesn’t show up, check you have built and referenced it correctly and that BOTH the Content Types project and the pipeline extension project are targeting .NET 4.0

If you’re really curious, just read through the content processor and content classes, the content class just describes the custom type and the processor does all the heavy lifting to populate the new custom model type with the information stored in the “Tank.fbx” model file.

There is an alternate way, the Skinned Model sample doesn’t even use the CustomModelContent definition, in some ways it’s a lot cleaner. Having the CustomModelContent class does mean you don’t have to reference the custom type from the content project but I prefer completeness. The final choice is down to you really.

Getting back in with the game

Now that we are finally hitting the home stretch to see what our labours have delivered, let’s just replace the game code one last time. So open up your game project and break out the Game class and replace it with the following:

#region Using Statements
using System;
using System.Collections.Generic;
using Microsoft.Xna.Framework;
using Microsoft.Xna.Framework.Content;
using Microsoft.Xna.Framework.Graphics;
using Microsoft.Xna.Framework.Input;
using Microsoft.Xna.Framework.Storage;
using Microsoft.Xna.Framework.GamerServices;
using CustomContentTypes;
#endregion

namespace GameName1
{
    /// 
    /// This is the main type for your game
    /// 
    public class Game1 : Game
    {
        GraphicsDeviceManager graphics;
        SpriteBatch spriteBatch;

        CustomModel model;

        Matrix world;
        Matrix view;
        Matrix projection;

        public Game1()
            : base()
        {
            graphics = new GraphicsDeviceManager(this);
            Content.RootDirectory = "Content";
        }

        /// 
        /// 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.
        /// 
        protected override void Initialize()
        {
            // TODO: Add your initialization logic here

            base.Initialize();
        }

        /// 
        /// LoadContent will be called once per game and is the place to load
        /// all of your content.
        /// 
        protected override void LoadContent()
        {
            // Create a new SpriteBatch, which can be used to draw textures.
            spriteBatch = new SpriteBatch(GraphicsDevice);

            // TODO: use this.Content to load your game content here
            model = Content.Load("tank");

            // Calculate camera view and projection matrices.
            view = Matrix.CreateLookAt(new Vector3(1000, 500, 0),
                                       new Vector3(0, 150, 0), Vector3.Up);

            projection = Matrix.CreatePerspectiveFieldOfView(MathHelper.PiOver4,
                                                             GraphicsDevice.Viewport.AspectRatio, 10, 10000);

        }

        /// 
        /// UnloadContent will be called once per game and is the place to unload
        /// all content.
        /// 
        protected override void UnloadContent()
        {
            // TODO: Unload any non ContentManager content here
        }

        /// 
        /// Allows the game to run logic such as updating the world,
        /// checking for collisions, gathering input, and playing audio.
        /// 
        /// Provides a snapshot of timing values.
        protected override void Update(GameTime gameTime)
        {
            if (GamePad.GetState(PlayerIndex.One).Buttons.Back == ButtonState.Pressed || Keyboard.GetState().IsKeyDown(Keys.Escape))
                Exit();

            // TODO: Add your update logic here
            HandleInput();

            // Update the world transform to make the model rotate.
            float time = (float)gameTime.TotalGameTime.TotalSeconds;

            world = Matrix.CreateRotationY(time * 0.1f);

            base.Update(gameTime);
        }

        /// 
        /// This is called when the game should draw itself.
        /// 
        /// Provides a snapshot of timing values.
        protected override void Draw(GameTime gameTime)
        {
            GraphicsDevice.Clear(Color.CornflowerBlue);

            // TODO: Add your drawing code here
            graphics.GraphicsDevice.Clear(Color.CornflowerBlue);

            model.Draw(world, view, projection);

            base.Draw(gameTime);
        }

        #region Handle Input

        /// 
        /// Handles input for quitting the game.
        /// 
        private void HandleInput()
        {
            KeyboardState currentKeyboardState = Keyboard.GetState();
            GamePadState currentGamePadState = GamePad.GetState(PlayerIndex.One);

            // Check for exit.
            if (currentKeyboardState.IsKeyDown(Keys.Escape) ||
                currentGamePadState.Buttons.Back == ButtonState.Pressed)
            {
                Exit();
            }
        }

        #endregion
    }
}

*Note, just remember to update any different using statements (different namespaces and all)

Walking through the code above all we have done is remove any model setup code because it’s all done in our custom content class, all we need to do is tell it where it is in the world (The world / view and projection matrices) and tell it to draw. For added effect the model now spins as well

Now I could go a lot further and tinker with both the content processor and the custom content type but I’ll let you play.

So what was all this about?

Well the main purpose of this article was to go over all the requirements of using custom types in your MonoGame projects and some pointers as to where you should look to improve your asset pipeline to try and do as much with your content up front at build time. This becomes crucial with platforms like iOS where every cycle counts (Don’t get me started on Android)

oh and to show you that it is possible to build a game using JUST the 2012 express editions, no longer are you chained to the 2010 versions (granted still nothing wrong with using 2010 )

This was a very technical article so if you have any comments / questions or queries please let me know below.

MonoGame: Using libraries with Windows Phone projects

Simon (darkside) Jackson — Tue, 30 Apr 2013 13:17:06 +0000

A challenge faced by the MonoGame team when they created Windows Phone 8 support was that XNA is actually included with the platform, this created a unique challenge because it was

a direct contradiction to the XNA support being provided by MonoGame itself, this caused no end of problems until a solution was found.

The answer was simple, ignore the XNA libs native to Windows Phone at build time.

The Problem

If you manually reference the MonoGame framework from any project and try to use XNA components you will likely run in to the following error:

Error 1:
    The type ‘Microsoft.Xna.Framework.Vector3′ exists in both
    ‘c:\Program Files (x86)\MonoGame\v3.0\Assemblies\WindowsPhone\x86\MonoGame.Framework.dll’ and
    ‘c:\Program Files (x86)\Reference Assemblies\Microsoft\Framework\WindowsPhone\v8.0\Microsoft.Xna.Framework.dll’

The compiler is basically stating there are two versions of the class used (in this case the Vector3 struct) and it cannot decide which one to use. Using an alias wouldn’t help because they have the same name, same namespace and so on.

Solving this

If you use the MonoGame Windows Phone 8 project template, the fix is automatically applied for you but if you create your own projects and / or create libraries / components to your project that require the “MonoGame.Framework” referenced assembly then you will need to apply the fix manually, read on.

1: Open the “.csproj” of the project you are adding the MonoGame reference to.

2: Add the following block after the section

All this does (as explained above) is tell the MSBuild task to ignore the Microsoft XNA reference libraries during the build so that only the MonoGame versions exist.

Ensure you do this for any project in your solution that references the MonoGame framework, not needed if the project isn’t.

One other thing

Another thing to note if you build your game project manually instead of using the MonoGame Windows Phone 8 template (some people just like it that way) is that there is some other additional configuration included you should be aware of, this revolves round the target platform used for builds.

If you are targeting the emulator, then the “x86” versions of the assemblies are used to build the project.

If you are targeting a device (or publishing to the store) then the “ARM” versions of the framework are used.

Be aware of this if you decide to go solo (see example below)

Final Example

Just to finish this post off and as a sanity check to ensure you got it right, here’s an example project file with the above section included:



  
    Debug
    ARM
    10.0.20506
    2.0
    {00F8D6E2-D182-451B-86A0-1905FD4F920F}
    {C089C8C0-30E0-4E22-80C0-CE093F111A43};{fae04ec0-301f-11d3-bf4b-00c04f79efbc}
    Library
    Properties
    GameName4
    GameName4
    WindowsPhone
    v8.0
    $(TargetFrameworkVersion)
    true
    
    
    true
    true
    GameName4_$(Configuration)_$(Platform).xap
    Properties\AppManifest.xml
    GameName4.App
    true
    11.0
    true
  
  
    true
    full
    false
    bin\WindowsPhone\x86\Debug
    DEBUG;TRACE;SILVERLIGHT;WINDOWS_PHONE
    true
    true
    prompt
    4
  
  
    pdbonly
    true
    bin\WindowsPhone\x86\Release
    TRACE;SILVERLIGHT;WINDOWS_PHONE
    true
    true
    prompt
    4
  
  
    true
    full
    false
    bin\WindowsPhone\ARM\Debug
    DEBUG;TRACE;SILVERLIGHT;WINDOWS_PHONE
    true
    true
    prompt
    4
  
  
    pdbonly
    true
    bin\WindowsPhone\ARM\Release
    TRACE;SILVERLIGHT;WINDOWS_PHONE
    true
    true
    prompt
    4
  
  
    
      App.xaml
    
    
    
      GamePage.xaml
    
    
    
    
      True
      True
      AppResources.resx
    
  
  
    
      Designer
      MSBuild:Compile
    
    
      Designer
      MSBuild:Compile
    
  
  
    
    
      Designer
    
  
  
    
    
      PreserveNewest
    
    
      PreserveNewest
    
    
      PreserveNewest
    
    
      PreserveNewest
    
    
      PreserveNewest
    
    
      PreserveNewest
    
  
  
    
      PublicResXFileCodeGenerator
      AppResources.Designer.cs
    
  
  
    
    
      $(MSBuildExtensionsPath)\..\MonoGame\v3.0\Assemblies\WindowsPhone\ARM\MonoGame.Framework.dll
    
    
      $(MSBuildExtensionsPath)\..\MonoGame\v3.0\Assemblies\WindowsPhone\x86\MonoGame.Framework.dll
    
  
  
    
      {924D5D26-7744-4FA3-A3F7-E5396CB4B7AF}
      PhoneClassLibrary1

Windows Server 2012 roundup–the return!–Part 1

Simon (darkside) Jackson — Mon, 22 Apr 2013 11:49:59 +0000

On the back of the #TechEdChallenge I downloaded all three of the evaluation products for review and decided to give them a whirl, the first up was Windows Server 2012.

As a bit of history I did spend a great deal of my tech career building / installing and maintaining at a very low level a lot of Microsoft servers and products running on them, it was always an interesting time and some of the best fun I’ve ever had involved unboxing a new piece of kit (several 10’s of boxes usually), putting it all together and getting the system up and running and integrated with our server environment (mind you this was before cloud and cloud based systems).

Since then I’ve been out of touch with server OS’s, mainly due to work commitments (even my old test lab was decommissioned, when our second child came along) but other stuff as well, server was no longer my focus, I had moved to the client and app world.

*Update, due to time restrictions I’m going to post about this in parts as I experience the full breadth of each product to get their full worth as I explore them to the full. Will post links to each update in all articles.

So it’s time to go back and see just what has changed with new eyes. This post is going to be written as I’m experiencing it, so instead of playing with everything first and then trying to remember I’m going to show you what I see when I see it.

Installation

Well first impressions are the ones that usually stick, heading into Hyper-V installs for the first time was a big eye opener (don’t have a spare box at the mo) but after a few wrong turns (and downloading the server iso image a couple of times) I got the Windows Server 2012 install going and…. it was a nice surprise.

Zero UI install option

The first thing I really noticed is that Microsoft has finally relented to the backwash of Unix based server installs and provides an install with no UI, it’s completely managed through a console screen and powershell scripts, very interesting. This was probably introduced with the DataCenter edition in the last release (unconfirmed) but is now available in Windows Server 2012 installs.

It’s FAST

The whole install even on a low spec VM on my machine took minutes, seriously, I must have blinked a few times and didn’t notice it was sat there waiting for me and I hadn’t even noticed. Was not expecting that.

Charmed Unsure

Well there’s always one curious one in the pot and this certainly falls into this category. Once the install was complete and the box was up and running I was greeted with the Windows 8 style experience, NOT the metro / modern look mind, but the charms bar and other features are fully enabled. Not sure if this really fits in the server world and I can understand Microsoft’s attempts to unify its user experience but the Admin community favour use over UX any day.

Did I say it was fast?

Granted there isn’t anything running on my VM yet but damn this thing is quick. It starts from cold in minutes and I can get back to trying stuff with almost no delay. This is a fantastic improvement from the old days where I was waiting minutes (if not longer) for the server to start, even on some really powerful kit. Microsoft has always aimed (especially since server 2008) to get the box up and running before starting components / services and “get you in quick” but in 2012 they really mean it. If you slapped an SSD in as the boot drive I’m sure this would even be an instant on system from cold. (for reference I timed it and it was 3 seconds to logon screen, 2 additional seconds to desktop and 5 seconds more to the welcome screen, up in less than 10 seconds)

**Even the shut down is fast

Engineers I salute you.

Into the quagmire

So my box is up and running, now what?

With the box started up from a fresh install you are greeted with a nice “Welcome to your server” screen

From here as you would expect you start adding services, components and other such bits to get your server up and running. From first glance, gone are the old search for which components you need to run things and everything is plain and right in front of you. It has brought along the server 2008 roles and features look and feel (a big bonus even back then) and even gives you a limited management option to include more servers in your little management group, gone are the days of requiring a dashboard or having to remote in to every server just to check it’s health, it’s all right in front of you. (In fact I think the “it’s right in front of you” is going the factor a lot in my view).

The help shows you straight away just how important Microsoft feel about managing your “Environment” instead of a collection of servers.

Add features remotely, I like the sound of that!!

Even the education tab leads (potentially even drawing you to) additional areas you should look to become a better server manager

Excited to see just how far this goes with this latest offering.

Switching to look at our starting point, Microsoft certainly have given you a very detailed overview of what each server is doing and what it has running on it:

My only complaint here is that the dashboard is fixed, I would have liked to have been able to arrange the dashboard to my liking and order and possibly even hide/add more views to it to meet my needs, a fairly simple thing I would have thought. Overall however this is light-years ahead from what I have experienced before, having such a performant global status screen for the server in one place (not like the old clunky Computer Management MMC view), it delights me that this one screen alone runs smoothly without affecting the performance of the server.

I also really like those hyperlinks all over the place, taking you straight to the configuration options without having to wade through pages of property screens

So what can it do?

“Lets stop talking about is and actually get on with it, show of hands!”

(*Click on images to view them full screen, !thanks Jetpack!)

Adding your first role(s)	Selecting your destination type	Where to put it
As you would expect when doing any new task with Microsoft these days, you are greeted with a nice “So what would you like to do and here’s what this does” wizard start page, no exception with the “New Role” wizard.

Nice and helpful here.Next up you need to decide how you want to deploy these new features, either as a separate virtual instance or on the server itself.

Running this already in a VM with no domain so only local works here for me.This screen did take me by surprise, obviously for supporting environments with SAN storage and multiple deployment options, you not only get to choose where to install features but also select if you want it encapsulated in a VHD!

Selecting the bits	Dependencies	Different roles, different dependencies
Once you figured out where it goes, the next obvious step to to add Roles for what you want the server to do. Nice clearly defined boundaries	If your selection has dependencies then they are added automatically for you, no more dropping out the install to find yet another “feature” you need to have preinstalled first.	Pretty obvious but worth pointing out that the system intelligently only installs those bits needed for each role, even if features are needed for multiple roles

Extra features	Ooops	Configuring roles
Once you’ve decided what you want the server to do, you can then also select any additional features you want enabled by default. Very useful if you intend to install “other” software.	Try to add a role or feature that your current environment cannot support (say trying to install Hyper-V in a Hyper-V image) and the install will just warn you. (As in not crap out the whole install)	With everything set you then get to customise the roles you have selected and customise how each role with operate

Would you like fries with that?	Everything set?	Off it goes
Configure it how you want when you want. Would you like Com+ with your app server sir/madam?	Review what you selected. What’s nice here is that there is even an option to automatically restart the server when needed during install, however many times that may be. Obviously not advised on a Live system	What is nice about the progress screen is that unlike other server installs, it can be closed. You can check on its status from the Notification pin in the Dashboard at any time. Acts more like Windows Update than an MSI install.

After all this it does give a refreshing view that Microsoft are serious about making administrators and engineers lives easier plus making maintenance a doddle.

There are a few things I could nit-pick at the process, like if an installation fails for whatever reason you are notified it and can review the error summary, however there is no way to re-submit or alter that installation to set it off going again, especially with lengthy configuration choices it forces you to start again. On the other hand such a system would force you to do smaller installs and in fact you can configure several simultaneously and each will kick off after the other has finished, so maybe smaller is better!

Overall it feels very smooth and well thought out, not having to keep jumping in and out to install this and that just to get the install moving is a real bonus (something I’ve don’t far too many times), plus it installs everything in one go at the end and in the correct order, saves you so much time, just click and go.

The Finish Line

After you’ve got the server up and running and installed your roles and features, as expected the dashboard is updated and new options become available to drill down to each feature of a role on its own rather than the big view dashboard look:

You can jump in and check out the events, service status and such for each role and server you wish without having to jump through hoops. Another +10 for Microsoft.

Time for a rest

Time as always eludes me so I must off, will put up part 2 when I get another free moment, for now I leave you with one parting gift:

Yes the Modern desktop interface does make an appearance in Server 2012 but it seems the “Boot to Desktop” feature has already shown it’s face

The #TechEdChallenge challenge–win a trip to TechEd and More

Simon (darkside) Jackson — Tue, 16 Apr 2013 14:00:02 +0000

It happens every so often, you open up your mail or twitter feed and there is a very welcome surprise waiting for you, the biggest one of late was the announcement of the TechEd Challenge (#TechEdChallenge)

The aim is simple, get more dev’s interested and excited for (and if possible working on / buying) Microsoft’s latest and greatest server and backend offerings, just what do you have to do to enter this challenge? simple, download and try out either Windows Server 2012, System Center 2012 SP1 or grab a FREE 90 day trial of Windows Azure and give them your honest opinion about it. That and / or just keep tweeting / re-tweeting about #TechEdChallenge.

The full details are here: http://www.microsoft.com/uk/techedchallenge but in brief, here’s the run down.

Download one (or more ) of the three following products:

Write a review of your experience with your downloaded product(s) and either email them to Microsoft or use the submission site below:

if you download and review all three, you will have tripled your chances of winning.

Each first place prize includes your ticket to TechEd Europe, flights, hotel and meals. Winners will also be part of the TechNet team at the hub of Microsoft’s European community.

On top of that while the competition is running you can keep tweeting / ReTweeting about #TechEdChallenge to be in with a chance to win some free goodies, from mugs to tee shirts and notebooks (of which kind of notebook, I’ll update the article when mine arrives but I suspect of the writing kind)

Well what are you waiting for?

I’ve had experience with most of them before but I’m still downloading all three and doing my own write up on them, so as a break from my normal schedule expect a few review articles coming very soon. In one way this has gotten me off the bench about Azure as I’ve been wanting to dig in to it for a while now and have a few projects that make a lot of use of their services but I’ve been preoccupied with other tasks, now I’ve got my trial and will get coding against it (may even blog about that experience as well on the side plus make use of Xamarin’s new Azure Mobile Services component plug-in for Xamarin solutions )

Laters

AdRotator V2 progress report

Simon (darkside) Jackson — Sun, 07 Apr 2013 13:22:32 +0000

Quite a few people have asked me of the last few weeks about what is happening with the AdRotator project, is it dead, are we on a permanent holiday (Vacation for our American chums) or did we just get board with the whole thing as we have been fairly quiet of late.

Let me put one ting to bed,

ADROTATOR IS NOT DEAD

(just resting )

Both Gergely and I had our work / family schedules ramp up quite a bit for the last few months ( by a few I really mean a lot) but this doesn’t mean we have lost interest in AdRotator, far from it our goals with the next version keep getting more and more ambitious and we have already done a fair bit of ground work already, such as:

The new XML configuration

One of the biggest pains in V1 was the XML config, it was either not configurable enough or was limiting in very annoying ways, you could just push ads but that was about it and you had no control over how they functioned. We added house ads to give you a bit more control and potentially sell ad space in your apps but again this was quite limiting as you could only have 1.

The new config XSD has been stable for a while now and had these goals:

Each config line is separate Ad space supporting any of the enabled Ad Providers (break the one line per provider in V1) – Allow multiple Ad Units to be used per provider

Add AdRotator features to XML config such as Sliding Ad, Refresh Rate, etc (per config / per provider?)

Compress XML config – (SHOULD)

Size of ad space – (MUST) – Will especially be important on Win8

Ad Order – Ability to specify an order of Ads, rotate in order

Ad Groups – With the addition of multiple ads per provider, should we also have the capability to group settings?

The new XSD looks like this (for you XML freaks out there ) – granted we’ve not actually gone to the level of having an actual XSD before but thought it pertinent for V2

Now this is just the initial cut and I expect this to evolve over time but with the flexibility included this shouldn’t break compatibility

More reflection support

In V1 we use reflection a little bit, mainly for the house Ads but big pains expressed regularly were:

    Why can I only have one of each provider (to support flip flop configuration between backend provider settings)
    Why do I have to have all provider DLL’s registered in my app, even if I don’t use some
    Why don’t you support provider x
    Where is my coffee, why doesn’t it make me coffee?

Ok the last was a reach but you get the point, the first also created a pain for House Ads, since you had to do careful trickery to get round the configuration limitation 9if at all you even did)

Adding new provider has always been a pain just because of the various ways each work, the network calls they have and the platform support they have, some even have WebAPI support for non-traditional platforms and why didn’t we support that (well in the XNA version we do to a level but it never got out of that box)

So in V2 we are breaking that mold and have already made strides on how to implement this, it’s far from ready but we have a god idea, in fact it was #1 on our bucket list but Gergely is our reflection expect (I’m still a noob there) and his time as been even more limited than mine. However we have made some progress towards that goal

PCL Support

If you have been following my blog I have become a bit of a PCL nut these days and shoving PCL projects into whichever situation is was most effective (PCL is not a 1 solution cures all , it has it’s uses like any other technology). With AdRotator this was no different. All code that we can put into a PCL we are doing so and abstracting where platform dependencies are to limit the level of rework necessary for additional client platforms. Even my recent experience with the MonoGame team has helped shape some of this vision.

With the WebAPI version we may even release a completely PCL version but we will have to see how easily that pans out with the ever increasing support for functions in PCL projects. Thanks to recent development we’ll be able to have the compression support in our core PCL project thanks to some recent developments, yay.

The Future

We are working as hard and as fast as we can with V2, support or V1 is limited at the moment but we still help out where we can but apart from emergency fixes it’s unlikely we’ll be releasing an updated version of that soon (apart from the current Alpha release which is awaiting community testing and any other patches required), our focus is on V2 with the limited time we have.

If you want to get involved then you can, the V2 site is a GIT site and you can fork away, make changes and send us a pull request. Keep changes small if you can to ease merging back into the main branch ( a lesson hard learnt on the MonoGame project ).

https://getadrotator.codeplex.com/

Another way to get involved is to vote on our AdRotator V2 backlog request voting page which you can find here: (any suggestions welcome but only those with the highest votes – or that we personally really like will get in)

https://www.voteit.com/v/HiHC8jq1MV8wxEW

Grindstone here I come

Kinect for Windows SDK Programming Guide–a review

Simon (darkside) Jackson — Sat, 06 Apr 2013 23:02:06 +0000

As I do from time to time, I get sent over a book or two to look over and give a review on which I’m more than happy to do especially if it’s along the lines of game development, x-platform or in this case new and exciting technology. I’m fair and upfront and don’t bow to publisher pressures, if it’s good I’ll say so but just as much if I don’t like it be prepared.

So far I’ve yet to review a stinker and in the case of Abhijit Jana’s book on the new Kinect SDK I was not disappointed.

You can find the book here on PacktPub and here on Amazon

What’s in store

The contents look like this:

Chapter 1: Understanding the Kinect Device

A through breakdown of what it took to make the Kinect device and how it works

Chapter 2: Getting Started

A simple run through the Kinect SDK and how to connect a device to your development machine, plus a few extra helpers to get you started.

Chapter 3: Starting to Build Kinect Applications

Goes through the Kinect SDK API and starts you off with your first app to wire up a sensor and monitor data.

Chapter 4: Getting the Most out of Kinect Camera

A nice leisurely introduction to the camera sensor, it’s capabilities and shows you how to build a simple yet effective video effects app (the techniques also stand well for understanding how cameras in general function, an added bonus)

Chapter 5: The Depth Data – Making Things Happen

This chapter happily woke up my 3D side of my brain and went deep in to the implementation surrounding the depth sensor (ban pun I know), it really shows you how the Kinect understands 3D data and how it recognises different players / characters. it reminded me of a demo that was shown where 3D depth data from a Kinect was used to create 3D printer models and their eventual printed result.

Chapter 6: Human Skeleton Tracking

If you have ever had any experience with animations and bones in 3D applications or games then this chapter will be right up your alley, if not then prepare for a basic anatomy lesson. Here Abhijit shows you all the magic that goes under the hood in the Kinect SDK and just how much power is leveled with the API to handle the complex nature of not just recognising poses in the environment the Kinect sees but also face recognition and for those fans of security, he walks through the creation of a intrusion detection app to warn you of unwanted guests need your favorite things, like your computer (waning also contains pictures of the author )

Chapter 7: Using Kinect’s Microphone Array

Here we are led through one of the Kinect less known features, the microphone sensor and API, it’s practically a whole audio studio crammed into that little Kinect box and very sophisticated (well at least to me and all audio uneducated people). With features like echo cancellation and noise suppression it shows Microsoft really wanted to get as much data out of the environment wit the Kinect as possible.

Chapter 8: Speech Recognition

Microsoft didn’t just stop with good input audio but also included a very powerful speech recognition system into the device and API, in this chapter we are show how to make the best use out of this and even extend it’s capabilities with our own vocabularies and grammar recognition through the extensibility built in to the Kinect API.

Chapter 9: Building Gesture-controlled Applications

For those of you already used to Microsoft’s two latest device offerings like Windows Phone and Windows 8, they will be familiar with gesture recognition. Here we are shown how this is implemented on a programmatic level through the Kinect, how to recognise the base gestures and how to implement our own. What I did find interesting is the way we can even do gesture blending / chaining to build new types of gestures to recognise, fun stuff.

Chapter 10: Developing Applications Using Multiple Kinects

Here we go through the requirements of setting up multiple Kinects and what to expect from doing so, for just those occasions where just one Kinect may not be enough, fair warning may need additional cash investment beyond the second Kinect device for optimum performance.

Chapter 11: Putting Things Together

The one chapter that really shocked me, just when you thought it was safe to come out of the cupboard, Abhijit unleashes the dogs of war with an onslaught of additional material including great additional frameworks to help you on your journey to AR, face tracking and even using XNA avatars with the Knect controller. be prepared, be very prepared.

Thoughts

My thoughts are varied on this book but still heavily weighted on the very good side, here’s a simple breakdown of my thoughts:

The Good

    Each chapter is very well through out and steps you through each component of the device / API including very detailed examples.
    the attention to in depth and detailed technical detail is very easy to understand, Abhijit has done a very good job of explaining technical subjects to even a basic programmer.
    Full working sample projects that are only a stones throw away from being something submittable to a marketplace
    Covers 3D application for the Kinect, not just theory
    The final chapter is a work of art and almost an entire book on it’s own. Showing how to use Azure with the Kinect is a stroke of genius

The Bad

    The highlights do become annoying switching from a good thought process to explaining things to a child. A bit OTT in areas but easily skipable if you don’t need it.
    Highlights some of the tricky areas for using the device / API but no real solutions, could have given some extensions with the code API instead of a fixed example.
    Some of the math concept seem forced in and don’t get explained enough or don’t really fit in with the area.

Conclusion

Overall I really enjoyed this book and it makes me want to pick up a device and actually start running with it, the samples / examples provide a really good base from where you can expand and put your own mark on the map. I struggled to come up with bad points about this book as it is well formed so they are really just nick picking at best (mild annoyances) as it was such a good read.

If you want to learn the Kinect and how to make the most of it then this book is a really good start and one worth having on the shelf.

You can find the book here on PacktPub and here on Amazon

PCL targets for Mono / MonoGame projects

Simon (darkside) Jackson — Sat, 30 Mar 2013 21:48:09 +0000

I’ll be blogging over the next few weeks about my involvement with the MonoGame project in the dark dark backgrounds, all around the area of PCL support within the project.

I’ve been focusing on two aspects:

Spiting up the MonoGame code base into two parts, the first part containing all code that will work on any platform without modification and the second part containing platform specific code that today is managed with #if statements to target each platform
Creating a full PCL MonoGame Project which can be used to build games against that will work on any platform without worrying about platform specifics. (my previous post about portable MonoGame gave an overview on this)

Now in order to use PCL projects in development you must enable your development environment to be able to target Mono platforms. For Windows based solutions, Visual Studio already enables you to target .NET / Silverlight environments, with the Phone SDK you can also include Windows Phone and with Win8 / VS2012 you get Store app support out of the box.

For Mono platforms such as iOS and Android however you need to enable these manually (at least until Xamarin studio comes out with official support)

*Note, yes you will need to install either Mono or Xamarin Studio to enable Mono platform targeting support

Worry not young padawan, this process is very easy!

The PCL target files

The first easy part is to create the PCL target files, one for each Mono platform, just open up notepad and create the following files:

MonoAndroid,Version=v1.6+.xml

MonoTouch,Version=v1.0+ .xml

Alternatively you can download the files from here – https://github.com/DDReaper/MonoGame/tree/developcore/PCL%20Targets

Installation

Now for the really tricky part, installation, this really challenging and hard to master process needs to be attempted many times before you can become proficient at it.

You need to COPY the files into a folder!, try not to be too daunted by this task

Take the above files you have created and copy them to the following folder

x64 development machine

C:\Program Files (x86)\Reference Assemblies\Microsoft\Framework\.NETPortable\v4.0\Profile\Profile2\SupportedFrameworks

x32 development machine

C:\Program Files\Reference Assemblies\Microsoft\Framework\.NETPortable\v4.0\Profile\Profile2\SupportedFrameworks

Now on some machines / environments you might also need to put the files into an additional / alternative folder. The reason being the profile that is used by PCL projects on your development machine, I’m sure there is a perfectly good reason for this yet the answer eludes me, so if the above doesn’t work then you need to copy the files into the folder for profile 104 instead of 2, as follows:

x64 development machine

C:\Program Files (x86)\Reference Assemblies\Microsoft\Framework\.NETPortable\v4.0\Profile\Profile104\SupportedFrameworks

x32 development machine

C:\Program Files\Reference Assemblies\Microsoft\Framework\.NETPortable\v4.0\Profile\Profile104\SupportedFrameworks

Done

You’re ready

Now your development environment is setup to work with PCL support for all of Mono / MonoGame’s supported platforms.

*Note

If you select XBOX360 as an additional framework to support due to it’s very restricted nature, you will now be able to enable Mono platforms. Also it renders the scope of what you can have in a PCL project to next to nothing. Best advise, keep XBOX projects separate and use “Copy” projects to support that platform.

Coming up next

I’ve taken my leave of work for the next few weeks (nice Easter break from work) and plan to re-up my blogging efforts with my activities of late with MonoGame and other projects, this includes:

    The splitting up of MonoGame
    How-to : Use MonoGame PCL to build games
    A book review of the excellent “Kinect for Windows SDK Programming Guide” by Abhijit Jana
    The AdRotator V2 roadmap & progress

All that as well as have a play around with the new Unity3D SDK’s for Windows Phone and Windows 8 plus many other personal projects, should be a fun holiday (provided I get permission from the Wife )

Oculus Rift 3D stereoscopic rendering support in SunBurn is here!

Simon (darkside) Jackson — Tue, 19 Mar 2013 12:00:48 +0000

A fantastic announcement over on the SunBurn community blogs has just surfaced which is just amazing. HolPhone3D ad already built an amazing plug-in for SunBurn to allow easy stereoscopic rendering with just a few lines of code, todays announcement goes above and beyond hat, read the except from the blog below:

Get ready for Oculus Rift ready titles powered by SunBurn

The wait is nearly over and dev kits are shipping this week! Lot’s of excitement is all over the web as people want to develop and experience new 3D games within the Oculus Rift. I’ll be getting mine as part of the first wave, so I’ve updated my Stereoscopic Renderer for Oculus Rift rendering support. Check out the video for what it looks like and how to use it. If you need a refresher on how easy it is to get Stereoscopic support in SunBurn check out my blog post here: Stereo3D in SunBurn

Start coding now: 3D StereoscopicRenderer Plugin

Adding OculusRift support to your game is still under 5 lines of code!

If you have a shipping title and you’re interested in adding support, it should be easy. All the samples in SunBurn are super simple to add support just by following the instructions in the plugin. If you run into a snag, just post or even better – crack open the source and fix it!

How can you help? Managed to Native driver interop anyone…

This plugin will handle all the heavy lifting for rendering to the Oculus Rift, but the first set of drivers for the sensor data from the SDK will be all native. Meaning, we won’t get out the box head tracking support until this is completed. I don’t have any practical experience doing interop to drivers from C# and I won’t know exactly what format the data is coming back in to update the orientation until the SDK is released. Any volunteers here would be greatly appreciated, please reply back here to let me know if you’re interested.

And last but certainly not least Stereoscopic OculusRift support is incoming on SunBurn 2.1!

That’s right folks, C# Win8 Modern RT apps running in stereo mode with Oculus Rift support is right around the corner with the upcoming public 2.1 Early Adopter release. I’ll be releasing the plugin updates for the 2.1 EA program starting soon. Below is a pic of the stereo renderer running on my SurfaceRT. And for those of you wondering, there were almost no changes to my sources to make this happen, 2.1 really is that close to 2.0!

Go forth and embrace the future of all things stereoscopic (and Oculus Rift) in SunBurn!

-Holophone3D

What’s even more mazing is that HoloPhoe3D ha already announced that his system is fully compatible with the upcoming SunBurn Platform API and enhanced engine so from day one I will have his great plugin available.

Top That!!!

MonoGame goes Portable

Simon (darkside) Jackson — Sat, 16 Feb 2013 00:24:39 +0000

While I was putting together the MonoGame solution for shocking effect you did seem to get the feeling you were building your game for several platforms, there’s a fair bit of too’ing and fro’ing, pulling parts of the project together and one of my least favorite porting practices, the COPY project.

Yes, having the exact same code files re-used on several projects sounds great until one of those projects needs a different using, or requires you to use the same parameter in a different way or god forbid, require additional parameters for certain functions.

Portable libraries are one of the saviors from this practice by constructing a project that can be consumed by several different project types or platforms with a single codebase, main difference is that it is one code base used in a single way, the portable framework does not let you exceed these boundaries and keeps you in check. Got something that is platform specific then keep it on that platform and not clutter up the central core of your app or game.

Main problem here with MonoGame as it wasn’t possible to do this, until now…

*update – Access the GitHub repo of MonoGame.Portable here

First a Warning!!

Please note that this is my own work and while based on the original MonoGame development branch and (as far as I can tell) is still completely compatible with the core of MonoGame, you should only use this as a Proof of concept in Live projects until such time as this or another approved solution by the MonoGame team comes along.

It’s not my ideal portable solution as MonoGame hasn’t been written to be portable at present, its core focus is to keep a familiar flexible code base, based on the aging XNA framework to allow to re-use your projects across multiple platforms (note I say re-use as effort is still required).

MonoGame is a fantastic achievement and if like me, you are passionate about such things (and can code as this will help) then get involved and see how you can benefit the platform!!.

Why be portable?

As the old saying goes, if it ain’t broke, why try to fix it?

Well, at present the MonoGame code base (and most likely any solution you build using MonoGame) is very singular for almost all platforms, they are very intertwined and components are swapped out, changed or just extended to try to provide flexibility to accommodate an ever changing directory of needs.

There’ nothing particularly wrong with this practice but, over time your code becomes very complex, trying to fix issues with one platform can severely impact another without knowing it (unless you test all builds on all platforms after every commit), basically having so many flavors of pie in one pan soon becomes very hard to differentiate which pie is which.

Portable libraries help with this by having the “core” of you’re project in one place that works one way and keep platform extensions with each platform and if your sensible about it, then the core never even knows this is going on.

Granted you could potentially create the same thing with multiple smaller projects and just keep swapping things out, except that if you add something another platform doesn’t like, you won’t know until you test on that platform. Portable libraries prevent this as then only allow functions that will work on ALL configured platforms, hence protecting you from yourself.

Want to know more then try out some of these resources:

How to Make Portable Class Libraries Work for You

Evolving the Reflection API

Using Portable Class Libraries with Windows 8 / Windows Phone 8 MVVM

Create Cross-platform Apps using Portable Class Libraries

Developing Mobile Solutions with Windows Azure Part II (also FYI check out Pt1!!)

The Collection of MvvmCross Presentations (fantastic Cross platform stuff using Mono/Xamarin)

Be aware though, a portable library enables you to develop a very simple and central shared project, you won’t however be able to actually run your project without at least one platform to run it on, the portable features just make enabling the project on other platforms a snap.

What we are aiming for with the use of a Portable Class Library is something like this:

Back to the show

So what difference does this really make, well let’s spell out the two main differences it makes with MonoGame projects

1. Project Make-up

The first main impact is how you layout or manage your multi-project solution (The MVVM cross presentations above do a much better job of explaining this, but here goes)

The Project Portfolio

With current practices you will most likely have something like this:

Depending on whether you Link the core files for your project or just copy them, you have several solutions for each platform with more code to manage / integrate when you are considering each platform. in its worst case scenario (Just copy projects), a single bug fix to core code has to be replicated across all platforms and if there are platform specific differences in that chain it becomes increasingly difficult.

Portable libraries ease this somewhat with their central nature.

The Portable Portfolio

The portable allows a single project to be associated to many others so long as you have the project targets loaded in the portable libraries (for more info on that read up on portable libraries!!)

2. The single source of truth

Portable libraries address one of the biggest headaches in multi-platform solutions because of the one simple truth, they are all different. Each platform has its own way of doing things that are generally incompatible with the next.

Now I will be completely honest, portable libraries alone will not save you here but what they can do is make the job a lot easier and how you exactly what is compatible between ALL of your supported platforms and more importantly what is NOT. Try and put in something or reference a library that isn’t compatible with all platforms and you will just get compilation errors.

This ensures you put platform specific code in with a platform and central stuff in one place.

There is a buyer beware sign if you read up on Portable class libraries, the more platforms you add generally reduces the scope of what is truly portable, so take care.

Like I also said it won’t solve ALL you problems, so watch a few of the videos above and read up on abstraction and lay the framework or a scalable solution. Centralise where you can but keep it SIMPLE!

Lightning pure and simple

So after cleaning everything up and now using a portable library for the core of the code from the previous demo’s I’m left with the following:

At present I’ve left the original drawing code as my initial portable experiments were only meant to enable basic features but I seem to have managed in a fairly short period of time to enable most features of the framework in a portable library, so at this point I could move just about all the demo code in to the portable library, therefore I only need a shim in each platform project to run it (plus an additional platform features I want to take advantage of like sharing / NFC / etc)

Source for the series can be found here on codeplex as well as the code drop for this stage here

*update – Access the GitHub repo of MonoGame.Portable here

Breaking the mold

Right, I’m taking a little break from MonoGame for a little while now and returning to SunBurn. Why you may ask, to which the obvious answer should be:

“There is something VERY interesting to see over there”

Will report back later and show you just how electrifying SunBurn can be (Sheesh that sounds like a bad episode of MisFits )

P.S. I’m knackered after spending a week Portablising MonoGame, lol

Android 4: New features for Application Development–PacktPub Book Review

Simon (darkside) Jackson — Tue, 05 Feb 2013 18:26:09 +0000

As a break from my normal programming schedule I was passed a new Android book for review, I ‘m always interested how the other side lives (before I come running back to C# and Windows), in many cases we can see similarity with platforms which seems to grow closer with each release as each learns from new developments in the other and tried to improve on them.

http://www.packtpub.com/android-4-new-features-for-application-development/book

So let’s see what we got.

This book is a practical and hands-on guide for developing Android applications using new features of Android Ice Cream Sandwich (Android 4.0), with a step-by-step approach and clearly explained sample codes. You will learn the new APIs in Android 4.0 with these sample codes.

It’s probably best that you have a good understanding of Android programming as this is not for the beginner, it contains a lot of easy to read code examples and layout code for building pages (and in some cases apps) but without the basics you would struggle.

You don’t need knowledge of older Android versions, just a beginners intro on how to build Android apps is sufficient, at least know what an Activity is and the basic layout language used by Android development.

Here’s a brief run through what all the chapters are and what to expect from them. The book is laid out like a cookbook of sorts focusing on each of the new areas covered with firm examples of each.

Chapter 1 “Action Bar for All”

Introduces the action bar and shows you how to use and configure it. Think menu bar.

Chapter 2 “A New Layout – GridLayout”

Introduces the GridLayout and shows you how to use and configure that. GridLayout is a new layout introduced with Android Ice Cream Sandwich which is an optimized layout and could be used instead of LinearLayout or RelativeLayout.

Chapter 3 “Social APIs”

Covers the Social APIs that were introduced with Android Ice Cream Sandwich. This API makes it easy to integrate social networks, furthermore, high resolution photos can now be used as a contact’s photo.

This chapter also shows Social API usage with examples.

Chapter 4 “Calendar APIs”

Covers the Calendar APIs which were introduced with Android Ice Cream Sandwich for managing calendars. Event, attendee, alert, and reminder databases can also be managed with these APIs, they also allow you to easily integrate calendars with Android applications.

This chapter also shows how to use Calendar APIs with examples.

Chapter 5 “Fragments”

Introduces the basics of fragments and how to use them.

They are basically the same as user components on Windows platforms.

Chapter 6 “Supporting Different Screen Sizes”

Introduces the best ways of designing user interfaces that support different screen sizes.

Knowing the increasing fragmentation of the Android platform this section goes a ways to suggest tips and tricks on how to plan for the multiple resolutions available.

Chapter 7 “Android Compatibility Package”

Introduces the Android Compatibility Package and shows you how to use it.

The Android Compatibility Package allows the porting of the new APIs for the older versions of the Android platform.

Chapter 8 “New Connectivity APIs” – Android Beam and Wi-Fi Direct”

Introduces us to Android Beam, which uses the NFC hardware of the device and Wi-Fi Direct which allows devices to connect to each other without using wireless access points. This chapter will teach us the usage of Android Beam and Wi-Fi Direct.

Chapter 9 “Multiple APK Support”

Introduces us to Multiple APK Support which is a new option in Google Play (Android Market) by which multiple versions of APKs could be uploaded for a single application.

Chapter 10 “APIs with Android Jelly Bean”

Covers Android Jelly Bean and the new APIs within it.

If you were looking for a cookbook to show you techniques for how to use some of the new features of Android V4 (Ice Cream Sandwich / Jelly Bean) then you will have an excellent reference for your shelf here, complete with prime examples for how to implement them.

It’s not a tutorial book or a beginners book so keep that in mind, as stated earlier there is an expectation that you have at least tried Android development before.

Pros:

Very Detailed Samples
The sections on Different Screen sizes and Compatibility packages were very enlightening
Full featured examples end to end (both UI and Backend code)

Cons:

Each section is isolated and doesn’t mesh (not exactly a bid thing) but there is no re-use between sections
Not much detail on the feature itself however does detail its implementation very well. Likely to need additional reading to understand the feature

There’s a lot say about this book, as a prime technical reference for the experienced Android developer it has a lot to offer, certainly if you have an existing app (or are planning what features to put in a new one) this book will give you a keen insight to where you could expand your capabilities.

The new backwards compatible ways for putting new features in old apps is certainly one I haven’t come across before.

However if you are new to Android development sadly this isn’t going to help you due to the expectation of knowledge on your part, saying that however if you just want to test and try features then the sample included are fully working and will show you what’s what, just don’t expect a fully fledged app by the end of it.

So if your after another reference for your shelf this is certainly one to pick up.

Dark Genesis | Dark Genesis

MonoGame: Content Projects & Custom Model Types

First off – Content Please

Getting Started

Prerequisites

Studio 2010

Studio 2012

*Note you will also need to download the Microsoft Content Types sample as we will re-use some of the files from that project in this tutorial.

Create the Content project

Add a Platform for test

Getting the Custom Types in your Pipeline

First up the Custom Type project

The Content Pipeline project

If you want to learn more about how content pipeline extensions work, check out the documentation on the Creators club website here, well worth a read if you want to do more advanced thins with your content before you import it into your game.

Getting back in with the game

So what was all this about?

MonoGame: Using libraries with Windows Phone projects

The Problem

Solving this

One other thing

Final Example

Windows Server 2012 roundup–the return!–Part 1

Installation

Zero UI install option

It’s FAST

Charmed Unsure

Did I say it was fast?

Into the quagmire

So what can it do?

Adding your first role(s)

Selecting your destination type

Where to put it

Selecting the bits

Dependencies

Different roles, different dependencies

Extra features

Ooops

Configuring roles

Would you like fries with that?

Everything set?

Off it goes

The Finish Line

Time for a rest

The #TechEdChallenge challenge–win a trip to TechEd and More

Well what are you waiting for?

AdRotator V2 progress report

The new XML configuration

More reflection support

PCL Support

The Future

Kinect for Windows SDK Programming Guide–a review

What’s in store

Thoughts

The Good

The Bad

Conclusion

PCL targets for Mono / MonoGame projects

The PCL target files

MonoAndroid,Version=v1.6+.xml

MonoTouch,Version=v1.0+ .xml

Installation

x64 development machine

x32 development machine

x64 development machine

x32 development machine

You’re ready

*Note

Coming up next

Oculus Rift 3D stereoscopic rendering support in SunBurn is here!

MonoGame goes Portable

*update – Access the GitHub repo of MonoGame.Portable here

First a Warning!!

Why be portable?

As the old saying goes, if it ain’t broke, why try to fix it?

Developing Mobile Solutions with Windows Azure Part II (also FYI check out Pt1!!)

The Collection of MvvmCross Presentations (fantastic Cross platform stuff using Mono/Xamarin)

Back to the show

1. Project Make-up

The Project Portfolio

The Portable Portfolio