Welcome to another release of MonoGame 2.1.  We have been hard at work trying to make MonoGame bigger and better.  We have some new functionality which includes our first steps to 3D support as well as bug fixes, optimizations and more XNA 4.0 support.

We have to give a big thank you to all the people that provided feedback, bug fixes and especially the people that wrote samples that allowed us to focus on specific bugs.

Dominique Louis does not have his name in the official press releases but he has been the coordinator of the project and doing one hell of job keeping us all working to our common goal.  Please give him a shout at https://twitter.com/#!/SoftSavage

Here is the official release:

MonoGame Takes Tentative Steps into 3D : MonoGame 2.1 Announced

MonoGame is an open source implementation of the XNA APIs that allows developers to build 2D  games that run on Android, iPhone, iPad, Mac, Linux and Windows using the same code base, or reusing existing XNA code that runs on Xbox 360 or Windows Phone 7.

The MonoGame 2.1 release is an update to fix bugs,  implement optimisations and to add key features. In this release GamePad support was added and so was DrawUserPrimitives. There were also several bug fixes across all platforms.

To show off the DrawUserPrimitives we ported an old XNA 2 demo called VectorRumble to MonoGame (http://www.youtube.com/watch?v=jrwrLca871c) and also created a demo that shows off the first tentative steps into 3D (http://www.youtube.com/watch?v=3HPIe76f-VQ).  The VectorRumble demo also shows off the improvements to the wavebank implementations.

The latest framework sources can be downloaded from : http://github.com/mono/MonoGame.

A group of multi-platform XNA Samples can be downloaded from : http://github.com/CartBlanche/MonoGame-Samples

ROADMAP

The 2.x series will be released frequently to provide bug fixes and performance optimisations.  

The 3.x series will extend MonoGame with support for the XNA 3D APIs as well as something we are working on, which we believe the whole MonoGame will love.

HOW YOU CAN HELP

Firstly, go over to github and register. Then fork the main repo found at https://github.com/mono/MonoGame

This will allow you to make changes to your own repo and send us patches and enhancements, thus benefiting everyone.

You can also join the active community of developers on IRC at irc.gnome.org on the #monogame channel, where the day-to-day improvements are being discussed in real time.

If you release a game using MonoGame, please let us know so we can update our released games page, and mention MonoGame in your tweet.

SPECIAL THANKS TO FOR THIS RELEASE

Jalfx (for starting this project in 2010, when it was called XNATouch)
kjpou1
technomage
slygamer
Clancey
Grapes
JorgeMagic
espes
Tapani

Team Xamarin for their support and continued great work on all things Mono and everyone else that submitted patches/fixes and enhancements. Without your contributions this release would not have been possible.

Fixes and Features

All Platforms:

• Content Manager rewritten to use partial classes and implementation of cached assets that are loaded.  Greatly improves memory footprint.
• Experimental support for GamePads and Joysticks.  Enhancements will be coming to integrate better for developers.
• ContentReader improvements across the board.
• Improved support for XACT audio.

iOS:

• Gesture support has been improved.
• Better support for portrait to landscape rotations
• Fixed a rendering bug related to upsidedown portrait mode
• Better WaveBank support
• StarterKits
• VectorRumble

Android:

• Updated to support Mono for Android 4.0.
• Improvements to the Orientation Support.
• Changed Sound system to use SoundPool.
• Added Tap and DoubleTap Gesture Support.
• StarterKits
• VectorRumble

MacOS X:

 

• A lot of enhancements and fixes for Full Screen and Windowed control.
• Cursor support fixed for IsMouseVisible.
• Implementation of IsActive property and the events Activated and Deactivated.
• First steps of DrawPrimitives, DrawUserPrimitives, DrawIndexedPrimitives
• Better WaveBank support
• Support for ApplyChanges() and setting the backbuffer and viewport sizes correctly.
• StarterKits
• VectorRumble

Linux :

• All new implementation which share quite a bit of code between MacOS X and Windows
• Added shader support via the Effects class
• StarterKits
• VectorRumble

 

Windows :

• All new implementation which shares quite a bit of code between MacOS  and Linux
• StarterKits
• VectorRumble

Known Issues

iOS

• The Guide functionality is only available in iOS, for this release.
• VectorRumble starter kit requires touch implementation

Android

• Accelerometer disabled for Android, due to memory leak (with Xamarin)
• The .xnb texture in the Render2Target demo is not loading correctly
• Sound now only plays wav or ogg files  ( help us make it better )
• Rendering textures to a Rectangle causes unexpected behavior (Issue 118)
• Resource problems after OnResume (Issue 165)

Linux

• Sound, using OpenAL, only plays MP3 files ( help us make it better )

Mac

• Problem with full screen in Lion with Macbook swiping and Spaces.
• Problems with sound playing simultaneously
• Problems with Panning on sound effects

I am pleased to be the one, on behalf of the MonoGame team, to announce to the world that MonoGame 2.0 has been released today. Here is the official release announcement below:

MonoGame is an open source implementation of the XNA APIs that allows developers to build 2D games that run on Android, iPhone, iPad, Mac, Linux and Windows using the same code base, or reusing existing XNA code that runs on Xbox 360 or Windows Phone 7.

MonoGame 2.0 release is a major evolution of the platform. We went from only supporting the iPhone to becoming a cross-platform stack that now also runs on Android, Mac, Linux and Windows. To help developers get started, more than twenty individual samples and more than five complete starter kits are shipped with this release.

On the iOS platform, MonoGame runs on top of MonoTouch and there are at least eighteen games published on Apple’s AppStore built using the technology. This new release opens the doors for developers to publish games to the Mac AppStore using MonoMac, to Android Market using Mono for Android, and also to Windows and Linux systems using Mono.

This major advance in the MonoGame platform was made possible by an exponential growth in the number of contributors to the project in the last seven months.   New contributors took over major components of the stack, tuned the performance, added new platforms, tuned the engine and fixed hundreds of bugs to turn MonoGame into a solid 2D gaming platform.

A new networking stack allows players on the same network to play with each other.   One player could be running the iOS client, while another one might be using a Mac and another one an Android device. All playing the same game.

The latest framework sources can be downloaded from : http://github.com/mono/MonoGame.

A group of multi-platform XNA Samples can be downloaded from : http://github.com/CartBlanche/MonoGame-Samples

ROADMAP

• The 2.x series will be released frequently to provide bug fixes and performance optimisations.
• The 3.x series will extend MonoGame with support for the XNA 3D APIs as well as something we are working on, which we believe the whole MonoGame will love.

HOW YOU CAN HELP

Firstly, go over to github and register. Then fork the main repo found at https://github.com/mono/MonoGame
This will allow you to make changes to your own repo and send us patches and enhancements, thus benefiting everyone.

You can also join the active community of developers on IRC at irc.gnome.org on the #monogame channel, where the day-to-day improvements are being discussed in real time.

If you release a game using MonoGame, please let us know so we can update our released games page, and mention MonoGame in your tweet.

SPECIAL THANKS TO

Jalfx (for starting this project in 2010, when it was called XNATouch)
kjpou1
technomage
slygamer
Clancey
kangaroo
Grapes
taskbit
jdindia
vchelaru
JorgeMagic
jordoh
_brain
kelthar
adreesteve
mgroves
espes
cschwarz
cadahl
CircleOf14
vostok4
viyano

Team Xamarin for their support and continued great work on all things Mono
and everyone else that submitted patches/fixes and enhancements. Without your contributions this release would not have been possible.

Fixes and Features

All Platforms:

• Greatly improved XNA 4.0 API for 2D support.
• Networking support added to all platforms.
• Support for compressed .xnb textures from XNA 4.x, as published by Microsoft
• Added support for reading .tga files.
• Added Blend,Depth and Sampler states
• RenderToTarget implemented across all supported platforms
• Fixed Memory Leaks: Texture2D, RenderTarget2D and Audio
• Several memory optimisations, especially the one affecting iOS
• New functions: Rectangle.Intersect,Color.FromNonPremultiplied,MathHelper.WrapAngle and lots more API compatibility
• SpriteBatch speed improvements
• Several XNA Samples and StarterKits, that share the same codebase. See list below.
• ContentReader improvements across the board.

iOS:

• Added multi threading to Sound and Music playback
• Additional multi tasking fixes to allow Resume/Pause for iOS 4+ (inherit from MonoGameProgram)
• GameCenter Support for Achievements and Leaderboards, via the Guide class
• PDF Vector Graphics support
• Handle Portrait to Landscape rotations
• Rudimentary WaveBank support

• Samples

• Aiming
• BatteryStatus
• BouncingBox
• ChaseAndEvade
• Draw2D
• GameComponents
• GameStateManagement
• MultiTouch
• ParticleSample
• Peer2Peer
• PerPixelCollision
• RectangleCollision
• RenderTarget2D
• RockRain
• SpriteFont
• Storage
• TiledSprites
• TransformedCollision
• VideoPlayer
• VirtualGamePad
• Waypoint

• StarterKits

• AlienGame
• Cards Framework showing BlackJack
• Marblets
• MemoryMadness
• Platformer

Android:

• All new implementation which share quite a bit of code with the iOS port.

• Samples

• ChaseAndEvade
• Draw2D
• Peer2Peer
• RenderTarget2D
• Sound
• VideoPlayer

• StarterKits

• Cards Framework showing BlackJack
• Marblets
• Platformer

MacOS X:

• All new implementation which share quite a bit of code between Windows and Linux
• Added shader support via the Effects class
• Rudimentary WaveBank support

• Samples

• XNA Game Development by Example Source Code
• BouncingBox
• ChaseAndEvade
• Draw2D
• GameStateManagement
• GooCursor
• HoneycombRush
• NetRumble
• NetworkPrediction
• NetworkStateManagement
• Particle3DSample
• ParticleSample
• ParticleSettingsMac
• Peer2Peer
• PerPixelCollision
• RectangleCollision
• RenderTarget2D
• RolePlayingGame
• SpriteEffects(Shader goodness)
• Tetris
• TiledSprites
• TransformedCollision
• VideoPlayer

• StarterKits

• Cards Framework showing BlackJack
• Marblets
• Platformer

Linux :

• All new implementation which share quite a bit of code between MacOS X and Windows
• Added shader support via the Effects class

• Samples

• XNA Game Development by Example Source Code
• ChaseAndEvade
• Draw2D
• GooCursor
• NetRumble
• NetworkStateManagement
• ParticleSample
• Peer2Peer
• RenderTarget2D
• Sound
• SpriteEffects(Shader goodness)
• Tetris
• TiledSprites

• StarterKits

• Cards Framework showing BlackJack

Windows :

• All new implementation which shares quite a bit of code between MacOS  and Linux

• Samples

• Draw2D
• NetRumble
• NetworkPrediction
• NetworkStateManagement
• Peer2Peer
• RenderTarget2D

• StarterKits

• Cards Framework showing BlackJack
• Platformer

Known Issues

iOS

• Gestures under iOS are not working correctly, but multi-touch should work.
• The Guide functionality is only available in iOS, for this release.

Android

• Accelerometer disabled for Android, due to memory leak (with Xamarin)
• The .xnb texture in the Render2Target demo is not loading correctly
• Sound, using OpenAL, only plays MP3 files ( help us make it better )

Linux

• Sound, using OpenAL, only plays MP3 files ( help us make it better )

Mac

• Problem with full screen to normal.  Viewport is not being set correctly.

Now you no longer have to learn XNA (2D only for now) programming on Windows.  Instead you can use your favorite operating system.

MonoGame is now available on 5 different platforms: Mac OSX, iPhone, Android, Linux and  MonoGame even offers a version for Windows as well.

Check out the samples that are available: Linux Samples

Multiplayer now works for Mac, Windows (MonoGame only), iOS and Android via local networking and we have successfully connected to peers using these different operating systems.  You can also test this out yourselves using the Peer2Peer sample code found in the git repository.

Now for the exciting part.  Myself and technomage have been working on getting multiplayer working over the internet.  Right now we are calling it MonoGame-Live (subject to change in the future) and it consists of an introduction Master/Server component that also supports NAT-Punch through using the Lidgren Network library.  Last night we have successfully connected multiple peers using the server from multiple operating systems.  There are still some glitches to workout but progress has been made.

The source is already in the git master and can be found here: Peer2PeerMasterServer

Your input would be greatly appreciated if you are interested in maybe hosting your own gaming server. 

You can join us on the MonoGame irc or the MonoGame discussion list.

I just wanted to let everyone know that we got the Framework.Net package usable in MonoGame and there are two samples out there.  We implemented the package using the Lidgren Network library.  There are still a few problems but we now have the Peer 2 Peer sample from Microsoft up and running across local lan networks.

What this means for you as game developers is that you can write your multi-player games on other platforms using the same code as you write now with XNA.

One caveat is Profiles.  I still have not figured out how to implement this yet.  Right now there is a hard coded Profile and no way to sign-in via the Guide but it is coming.  If any of you have any ideas to discuss on this please let us know.

You will still use SystemLink in your code for connection type but because the Window’s XNA implementation uses their own proprietary protocol this means that we still can not interact with a Window’s game.  That is unfortunate but unless they are willing to share their networking protocol we are stuck with connecting with all the other systems except for them. 

There is work being done on building the same functionality into the iOS and Android ports and should be available soon.  So that means you will be able to have multi-player games connecting from all the technologies that MonoGame supports.

We are looking for testers as well as people who are experienced with the networking side of things to help us implement the rest.  Since I only have one windows machine, running under parallels I can not test how a real XNA program interacts with SystemLink network due to the one user profile signed in restriction.

One thing in particular is the interaction when the Gamer is ready, for an example take a look at the NetworkStateManagement sample.  Not really sure how to implement that without being able to see a real session in action.  So if you have any ideas of how it should work give us a shout.

MonoGame

As per their project description from the MonoGame website at http://monogame.codeplex.com/ :

MonoGame is a free OpenGL implementation of the XNA Framework for MonoTouch, MonoDroid, Mac OS X & now Windows. Our goal is to allow XNA developers on Windows & Windows Phone 7 to port of their games to the iPhone / iPod / Android / Mac OS X (visa versa), with minimal hassle. 

MonoMacGameView

To implement the MacOS X side they used the MonoMacGameView which is MonoMac’s implementation of a NSView to allow you to animate and render OpenGL content.  The MonoMacGameView exposes several events that can be subscribed to or overridden to add custom animation logic.

Events that are exposed follow the OpenTK GameWindow events to allow easier integration with existing code:

• OnLoad: Occurs after creating the OpenGL context, but before entering the main loop. Override to load resources.
• OnUnload: Occurs after exiting the main loop, but before deleting the OpenGL context. Override to unload resources.
• OnResize: Occurs whenever GameWindow is resized. You should update the OpenGL Viewport and Projection Matrix here.
• OnUpdateFrame: Occurs at the specified frame render rate. Override to add your game logic.
• OnRenderFrame: Occurs at the specified frame render rate. Override to add your rendering code.

Call the Run() method to start the application’s main loop.  Run(double) takes a parameter that specifies the rendering update rate.

By default the Run() method or specifying 0.0 for update rate Run(0.0) method uses the CVDisplayLink which synchronizes buffer swaps with the vertical refresh rate (usually 60Hz or ~60 frames per second) and allows the machine to determine the best rate.

If you pass a value to the Run(double) method other than 0 then the updates are refreshed by a NSTimer update so you can control what the animation refresh rate or frames per second will be.

Sample Code

To see actual samples running you can access the github content at https://github.com/CartBlanche/MonoGame.  Once you have the repository you can open the MonoGame.Framework.MacOS.sln file to see the samples.

If you are interested in helping out let Dominique know or post a message on the codeplex discussion board here http://monogame.codeplex.com/discussions.

We now have a MonoMacGameView as part of the add-in which you can find as part of the MonoMac.OpenGL namespace.  You will have to compile from source to as it did not make it into the MonoMac 1.0 add-in.

I also wrote a sample using the MonoMacGameView called MonoMacGameWindow which you can find as part of the samples here.

Hope you find it useful and I can’t wait to see what everyone does with it.  If there are any questions on how it is used please let me know here or you can find me on the monomac irc list.

With this sample comes a lot of new support and fixes for drawing and switching to Fullscreen and Window.  One of the main enhancements is the support for CVDisplayLink to help in animating your OpenGL graphics.

You can access the new sample by obtaining the MonoMac source from github or downloading the supplied sample file here GLFullScreen.

Here are a couple of screen shots showing a rotating textured world map.

This shows the program at startup.

This shows the program with wireframe rendering turned on.

Enjoy the new sample.

If you are an OpenGL guru on Apple could you please weigh in with your thoughts either on the forum mailing list or here with your comments.

Here is the thread I started labeled [MonoMac] OpenGL, GLU and way forward.

Hello everyone

Geoff and I were discussing the use of GLU on the monomac irc this
morning and we both came to a stand still on the way forward.

These are some of the issues that came up.

#1 – Does it work in lion? (this can not be discussed because of NDA)
#2 – Does it work _accelerated_ in lion? (this can not be discussed
because of NDA)
#3 – Is it deprecated in lion (this can not be discussed because of NDA)
#4 – Can we just update the samples to work in 10.6 and not worry about
this?
#5 – Go ahead and include a GLU binding but mark it as [Obsolete] but
still usable.
#6 – All the reading I have done says most of Glu can be replaced with
OpenGL 3.x. Apple is still on 2.1 or something like that so that makes
it a little harder to replace some of the functionality.

I am not an OpenGL person at all and as a matter of fact this is my
first introduction to it nor is Geoff an OpenGL-ist so we are going to
have to rely on everyone’s opinion here.

Just as an exercise I went out to good ‘ole google and tried searching
for some replacements for Glu in the GLFullScreen example.

Glu.Perspective:
I found a replacement for Perspective and that is Frustrum. Ok that was
fine and even tested that out with success.

Sphere drawing with gluSphere and Quadratic
The only thing I found were discussions that said use gluSphere or write
your own.

Should it be necessary to have everyone write their own when it already
exists and is riddled throughout sample after sample including OpenGL
site samples?

All you OpenGL people please weight in and give your thoughts to this
subject so that we can continue in the most direct and proficient way
that will benefit you.

Kenneth

Here is the blurb from the MonoMac team explaining what was done to accomplish this.

MonoMac provides an API compatible interface to the OpenTK GL.* functions. This is accomplished by forking a few files from OpenTK and removing their delegate / context infrastructure and just doing direct pinvokes to OpenGL.framework.

Unsupported extensions and methods have been commented out to avoid runtime exceptions.

With the exception of OpenTK/Graphics/OpenGL/* the rest of the files are a direct copy from OpenTK with the namespaces changed.

This was forked from OpenTK r3066, by Kenneth Pouncey.

What this basically means is that if you have used OpenTK in your project the commands to call the OpenGL routines will remain the same because it is compatible with the OpenTK API. 

For example take the following snippet:

        GL.ClearColor (NSColor.Clear.UsingColorSpace (NSColorSpace.CalibratedRGB));
        GL.Clear (ClearBufferMask.ColorBufferBit | ClearBufferMask.DepthBufferBit);
        GL.Enable (EnableCap.DepthTest);
        GL.Hint (HintTarget.LineSmoothHint, HintMode.Nicest);
        GL.Hint (HintTarget.PolygonSmoothHint, HintMode.Nicest);
        if (previousTime == 0)
                previousTime = timeInterval;
        rotation += 15.0 * (timeInterval - previousTime);
        GL.LoadIdentity ();
        double comp = 1 / Math.Sqrt (3.0);
        GL.Rotate (rotation, comp, comp, comp);
 
        drawCube ();
 
        GL.Flush ();
        previousTime = timeInterval;
        GL.Disable (EnableCap.DepthTest);
        GL.Hint (HintTarget.LineSmoothHint, HintMode.DontCare);
        GL.Hint (HintTarget.PolygonSmoothHint, HintMode.DontCare);

There have also been some helper methods added to support NSColor so you can use Cocoa-isms as well.  You can see an example of this in the code snippet above.

Getting Started

To get started you will need to compile the MonoMac add-in from source which you can find instructions on doing that here Exploring Cocoa with MonoMac and C# – Chapter 1 – Getting Started – Part 2.  this is only until the monomac team update the monomac add-in.

You will then need to add a reference to MonoMac.OpenGL in your source code.

using MonoMac.OpenGL;

You would then setup your application like any other Cocoa application using your choice of NSOpenGLView, creating your own NSOpenGLContext manually or CAOpenGLLayer.

You can find more information about apple’s implementation of opengl at the following locations.

• http://developer.apple.com/graphicsimaging/opengl/
• OpenGL Programming Guide for Mac OS X

Example Code

I have written a sample program that was used in testing which you can find here in zip form. Download the file OpenGLLayer.zip and open the OpenGLLayer.sln solution provided. Build and run the solution.

You can also access the code from the sample from MonoMac if you have setup your system to compile the MonoMac add-in from source.

There should be more samples soon.