Space Runner Unity Demo - Click To Play

This demo is my first real attempt at making something in proper 3D using Unity and follows on from the 2D Asteroids style game I made back in January. As with that earlier demo, I used C# to write all the main game scripts, while the graphics and sound effects are from downloads available from the Unity Resources section of the Unity Technologies website.

My aim was to make something reminiscent of classic on rails shooters like Starfox, Afterburner, Rez and the Panzer Dragoon series. I spent quite a while looking at those games and trying to mimic the controls and camera behavior for this demo, and while it’s clearly not a patch on those games, I guess there are a few similarities in places. If you would like to play the demo please click the image above.

A bit about how this demo was put together

The game is split into two scenes, one for the title screen and one for the main gameplay, each scene has a controller script attached to it’s main camera which keeps an eye on everything in that scene. The game scene uses a number of prefabs for things like the starfield, the asteroids, lasers and explosions,  the controller then attaches these at runtime with a degree of randomness to make the game a bit different each time you play.

Space Runner - Click To Play

The player ship is made up of a number of nested GameObjects to allow it to move forwards along the Z axis, while also freely moving on the other two axis as well as tilt and rotate to follow the users mouse position for aiming. This was probably the most complex part of the game to work out and took a lot of tweaking to get it working just right, but the outcome adds a nice floaty yet responsive feel to the craft.

The game’s main camera has two different modes, each controlled by a different script. The gameplay mode uses a variation of the orbit camera that comes with Unity to loosely follow the player ship. The movie mode continues to target the player ship while rotating around it at varying speeds, this mode was used for the intro and game over sequences as well as the short intermissions between each wave.

The music is made up of a few loops assembled in Acid Xpress and then imported into Unity as separate layers. Each layer is then turned on or off by the main controller at runtime allowing the soundtrack to change dynamically at key points during the game.

Overall the structure of this demo is much improved over the code in my previous demo, with very few uses of the GameObject.Find and GameObject.GetComponent methods to communicate between classes and much more focus on event broadcasting instead. Sure, it’s not the greatest looking game, but I’m pretty pleased with with how it plays, and while there are still a few camera bugs here and there, for the most part it works quite well.

Frameworks, plugins and open source code

There is now a wide range of excellent open source code available for use in your Unity projects and this demo makes use of a few of them including: the Detonator Framework, iTween and a customised version of this Unity C# Messenger system.

Space Runner - Click To Play

I’ve written about Detonator before, so I won’t go into much detail here, but I have to say it still impresses me every time I use it. There is no easier or more flexible way to create fantastic looking explosion effects in Unity and it scales really well to run on a whole range of computers too.

iTween is a fairly recent addition to the Unity community and is basically Unity’s answer to TweenLite. In short it is brilliant. It makes simple bits of animation an absolute breeze and more complex animation sequences easy too thanks to a built in delay system. Currently you can animate a GameObject’s position, scale, rotation, colour and volume to or from a given value with a single line of code. Hopefully future releases will add functionality for animating coloured lighting and other non-standard GameObjects and components but for now this has to be one of the most useful Unity scripts out there.

I’ve been looking for a good events system for Unity for a while now a recently came across the C# Messenger System on the Unify Wiki. After a bit of cutomisation I now have a system that is much more like the ActionScript event model, so rather than passing in an event as a string, you pass in an instance of an event class, helping to keep everything type checked by the compiler and avoid runtime errors, it also helps with code completion in Visual Studio which is a nice bonus. Hopefully I will get some time soon to tidy up the code for this and submit my version to the Unify Wiki.

A few things I’ve learned while making this demo

Making games in 3D can be difficult, even with Unity. The maths and overall structure of even a simple 3D game project is many times more complex than what is required for a 2D game. Unity really does a great job of giving you all the tools you need to make your game, but I found that you still need to understand some 3D maths if you want to try something that’s not covered by the standard camera and character controller scripts that come with the IDE. I found it really helpful to read up on the basics of general 3D games development covered by the official Unity tutorials as well as resources aimed at other platforms like XNA, Torque and even Flash.

If you want to loop background music in your game, don’t use MP3′s. Apparently MP3 meta data often adds a short amount of silence to the end of the file, meaning that when you play it back in Unity on a loop you will hear a short pop or click where the join is. There are many ways around this, but the most reliable seems to be to export your audio to WAV format and then let Unity compress it internally.

Hope this has been interesting reading, if you would like to try the demo, you can play it here.

Unity Astrospace Demo - Click to Play

This demo is my first project in Unity, and is my take on the Atari classic Asteroids. There’s a lot to learn when you first start out using Unity, so something simple, well known and in 2D seemed a good place to begin. If you’d like to play the demo, please click the image above.

Setting up a 2.5D game in Unity
While Unity is mainly a 3D game engine, using it for 2D games is just a case of adding a Configurable Joint component to each GameObject and Prefab that you want to restrict to only 2 axis and setting the corresponding X,Y or ZMotion properties to locked. This will stop those specific objects from being affected by the PhysX engine on the chosen axis while also leaving other game elements (including the Main Camera) free to move wherever you like in order to add depth the scene.

The best example of this I’ve seen so far is Paper Moon by Infinite Ammo, the “2D with depth” style of that game kind of reminds me of early 32bit era 2.5D platform games like Bug! and Clockwork Knight as well as more modern stuff like LittleBigPlanet and Viewtiful Joe. Overall, the effect is similar to what can be achieved using Box2D with Papervision3D in Flash, but using Unity gives you a bit more freedom to pile on the graphical effects without worrying so much about the frame rate.

Making the demo
I wrote the scripts for this project in C# rather than the standard Unity JavaScript. I chose to try and learn C# after reading this post on EverydayFlash which had recommended it. It took a little getting used to but it was definitely worth learning, especially now that Visual Studio C# syncs with your Unity projects, as you get the bonus of using one of the best code editors out there to write your game code as well.

While the code was all written from scratch by me, the graphics and sounds effects are mainly from asset packs and tutorials available from the Unity Technologies website, while the music was from an old Computer Arts CD. In addition to all this I used the excellent Detonator Framework by Ben Throop to create all the pretty explosions you see in the demo. Just like Flash, there are loads of open source frameworks and code libraries out there for Unity, and lots of great tutorials to help you get started making games.

Over all I’m quite pleased with how the demo turned out and very impressed with the Unity editor and how easy it is to use. I guess the one thing that can make Unity quite difficult is the need for some knowledge of a 3D modeling package, without that you kind of have to rely on ready made models as I did for this demo, this can be a bit limiting at times and does add an extra few degrees to Unity’s learning curve. Might be time to start learning Blender…

A few things I’ve learned about Unity while making this demo:

• Well structured code is more important than ever. At times, coding in Unity can seem a bit like Flash back in the days of AS1, you have the freedom to attach your code to almost any in game object and this can make it very easy to get in a muddle.
• Public properties are great. Making a property public in a Unity script means that you can then change its value through the editor’s inspector menu. This is useful as you can alter these values at any time without editing the script, even while the game is running in preview mode, this makes it very easy to tweak the gameplay until it’s just right.
• Preview mode doesn’t save your property settings. Following on from the previous point, be aware that when you close preview mode all those changes you just made to those public properties get reset. This can be a nightmare if you didn’t know in advance, or simply just forgot about it, thankfully there is a solution.
• Any script can access any other part of the current game scene. Using GameObject.Find() and GetComponent() methods can at times be Unity’s equivalent to using parent and root keywords  in Flash, with all the problems they can cause. You can end up writing very specific code when a good Event Messaging and Listener system is probably a much better option.
• The Unity GUI system is rather quirky. Perhaps I’m just too used to Flash and Creative Suite in general, but the way Unity handles User Interface programming and design really does take some getting used too.
• If you’re from a Flash background, you will miss tweening. There are a few tweening libraries out there for Unity, the most advanced seems to be AniMate which is written in Boo, but I couldn’t find anything that seemed to work well with C# just yet. One thing Unity really needs is a port of TweenMax for Flash.
• For all the similarities, Unity isn’t Flash in 3D. An obvious one I know, especially given everything I’ve written above, but there’s some things that Flash does that it’s very easy to take for granted. It took me ages to work out how to fade the alpha transparency of a 3D GameObject without a tweening library or a simple alpha property. Turns out fading a 2D texture was fairly simple, but a GameObject containing several 3D meshes requires you to target the alpha of the main colour of every texture within it, cue some boolean flags and a nested for loop just to make an object fade out.

Anyway, that is probably enough talk for now, if you haven’t played the demo yet please check it out at the link below.

Click to Play Unity Astrospace Demo

From Flash to Unity
Working with Unity is a lot like developing in the Flash IDE, in fact there are so many similarities that as a Flash developer it’s very easy to understand the basics. Lots of comparisons have been drawn between the basic building blocks in both environments: the Unity Project Panel is just like the Library in Flash, the Hierarchy is your Timeline, the Unity GameObject is a bit like the base DisplayObject in Flash, while Prefabs can be instantiated at runtime just like Linked MovieClips, even the default scripting language looks very familiar.

What quickly becomes apparent though, is that aside from the obvious performance advantage that Unity brings to 3D graphics, this is also an engine that was built mainly for making games with rather than a platform for everything from 2D vector animations to video playback. To make a game in Flash – even with something as advanced as the PushButtonEngine – is still a major piece of work, with Unity everything is there at your fingertips: 3D renderer, shaders, particle effects, a physics engine, standardized player input, an optimized game loop, sound management… the list goes on. All of this means that you can focus on creating the actual game itself, rather than trying to build an engine from scratch or spend ages working out how to combine some existing code libraries or  frameworks to make a game in Flash.

HelloRacer Demo

Some of the coolest games and demos
Right now there seems to be so many projects being made in Unity, with great new examples appearing almost daily on the web. Alongside Unity’s own impressive Far Cry style tech demo I would have to say that my favorite right now has to be the HelloRacer demo from Carlos Ulloa of HelloEnjoy and Papervision3D. The quality of the graphics and the realism and responsiveness of the handling is just amazing.

Another Unity project from people with a background in the Flash development scene is Infrared5′s Star Wars Trench Run game on the iPhone. This is one example that really shows what is possible with Unity on a mobile platform, the game runs blindingly fast and has great graphics and a cool tilt-based control system.

Blush

Another great Unity developer is Flashbang Studios, they have put out some really unique Unity powered games on their Blurst games site including the classic Off-Road Velociraptor Safari, but my favorite of theirs right now has to be Blush. With some great ambient music and lovely underwater graphics, it’s a chill out game that reminds me a lot of FlOw by thatgamecompany.

But Unity isn’t just for iPhone and the web, the engine’s flexibility when it comes to target platforms means that you can also publish for the desktop and even the Wii (although I think that’s only if you happen to be a registered Nintendo developer). With the company now hiring Xbox and PlayStation programmers there are even rumors that you will soon be able to publish to HD consoles too.

Max and the Magic Marker

So who’s using Unity for console game development right now? Well, Max and the Magic Marker from Press Play is one such game for the Wii, and for me it has to be the most impressive showcase of Unity I’ve seen so far, with a level of professional polish that easily puts it alongside Lostwinds and World of Goo as one of the best looking games on WiiWare. There is even a demo version on the game’s website that uses the Unity web player and is definitely worth checking out.

Beyond the core engine
The Unity website already does a great job of explaining the core features of the engine so I won’t repeat that here, but I would like to highlight two of my favorite extensions, both of which show how the core Unity engine can be built upon in very different ways.

Unity Locomotion System

The Locomotion system by Rune Skovbo Johansen adds high quality semi-procedural animation techniques to Unity. The framework blends your existing animation sequences and intelligently adjusts them to enable characters to convincingly navigate complex scenery such as stairs and uneven outdoor terrain. The results look very impressive and add a lot of depth and believability to the way your game characters interact with their environment.

The Detonator framework by Ben Throop allows you to easily create fantastic looking explosions, with particle effects, dynamic lighting and debris. All aspects of the explosions can be customised to create any number of unique effects and each one can be saved as a prefab for later use. Built on top of Unity’s standard particle system, these effects can even be plugged into your game’s physics engine so that they actually interact with other objects in the game environment.

Unity Detonator Framework

Both packages are free to download from the Unity website and show just what’s possible beyond the core engine. The quality and usefulness of these frameworks really highlights that despite already being much more of a ready made games engine than Flash, there is just as much potential for highly specialised 3rd party plugins and code libraries for Unity as there is for Flash.

Tech Resources
For what is still a relatively new platform, there are a lot of great resources out there to help you learn the engine. While Unity is often pitched as something that anyone can learn, I think any knowledge of Flash, or experience of other consumer focused game engines or level editors such as Torque, CryEngine, UnrealED or Hammer will give you a considerable advantage.

Unity Book

Alongside the usual online manual and scripting references on the Unity website, there are a stack of excellent official tutorial videos and even some sample projects. But if you are looking for a really well written introduction to the engine, then Will Goldstone’s Unity Game Development Essentials is the place to start. This book takes the form of one long tutorial, introducing all the most important features of the engine while guiding you through the creation of something similar to the Unity Island Demo. While the book is actually quite light on scripting, it really does explain the process of making games in Unity very clearly, and for that reason alone it is highly recommended.

A couple of other great resources that are worth a mention are the Unify Community Wiki and Unity Answers message board. The Wiki is a great source of code examples and project tutorials to help with learning the engine, whereas Answers is a great place to start if you get stuck on something in the middle of a project.

Next Steps
So after all that, what would I recommend for a Flash developer looking to get started with Unity? How about the following steps…

• Install Unity and watch the official intro videos, they do a great job of introducing the Unity editor.
• Download one of the official sample projects and have a look at how a Unity game is actually structured.
• Watch these Flash to Unity migration videos from Richard Hart, they really are an excellent introduction.
• Read Will Goldstone’s Unity Game Development Essentials book.
• Install Visual Studio Express for C#, it’s free, it now works with Unity projects and it will help with the final step on this list.
• Have a look at learning C# for Unity. It’s not that different to AS3 really, and in many ways it’s much more powerful than the standard Unity JavaScript, so it will be very helpful in the long run.

Hopefully this has been interesting reading. I’ve been working on a few Unity demos recently, so I’ll try and post the results here soon.

The aim of this demo was to update John Grden’s legendary Papervision3D X-Wing model – as seen in this classic papervision demo – and really bring it to life with some nice animated 3D particle effects.

The demo combines Papervision3D and the Stardust Particle Engine to add particle effects to the existing 3D model. I used Stardust’s built in Papervision extension to add the classic red glow of the X-Wing engines and then animate those engines as the ship accelerates away from camera. It’s quite a subtle effect, but if you look closely you can see a kind of red heat haze, I also like the way the white flames fade in and out as the ship speeds up and slows down.

I know this kind of effect could easily be done in something like Unity but I think it’s pretty cool to see it done in real-time in Flash. The original Papervision3D X-Wing demos were a real inspiration to me, and it’s amazing just how much a little effect like this can add to what is already an amazing 3D model.

Click here to view the demo and source code.

This demo is another example of the cool effects that can be made in Flash and ActionScript 3 using the Stardust Particle Engine.

By combining a simple particle effect with lots of Flash filters and some BitmapData processing, it’s possible to create some pretty abstract looking flame effects. The initial idea was to make something similar to the neon particle systems seen in games like Geometry Wars and Grid Runner, but after playing around with the Flash bitmap filters for a while I ended up with this cool looking flame effect instead.

The code is actually fairly similar to my earlier tutorial on using the Stardust engine, but this time I’m setting the velocity of the particles based on the speed and direction of the spaceship to create a nice engine flame effect that reacts to the ship’s movement.

Click here to view the demo and download the source code.

Stardust has a lot of cool features, and much of its structure and functionality will be familiar to people who have already used the Flint particle effects library or the Box2DFlash physics engine.

What makes this engine different is the way it brings all these features together in a modular and well designed package. It supports 2D and 3D particle effects (via its own internal 3D engine and through plugins for Papervision3D, ZedBox or ND3D), particle masking to help create more complex logic, and even the option to configure your effects using external XML files.

In addition to this great list of features is an excellent set of documentation, a nice introductory user guide, lots of really good code examples and even some FlashDevelop class templates that make it much easier to extend the core classes for your own effects. All of these extras are available from the links on the Stardust project home page.

So anyway, on with the tutorial, what we’re going to do is create a very simple multi-coloured smoke effect that will follow the mouse around the screen. It’s nothing too amazing I guess, but hopefully it will work as an intro on how to get started using the Stardust particle effects engine.

After downloading the Stardust source code from Google Code, start a new project in your favorite Flash / ActionScript IDE, set the background colour to black, the frame rate to 30 fps and make sure the Stardust class package or SWC is added to your new project’s class path.

First off, open your project’s main document class and import the following classes, it may look like a lot of code, but this is mainly due to the object oriented structure that makes Stardust so great at creating complex effects.

import flash.display.Sprite;
import flash.events.Event;
import idv.cjcat.stardust.twoD.initializers.DisplayObjectClass;
import idv.cjcat.stardust.twoD.initializers.Position;
import idv.cjcat.stardust.twoD.initializers.Velocity;
import idv.cjcat.stardust.twoD.renderers.DisplayObjectRenderer;
import idv.cjcat.stardust.twoD.emitters.Emitter2D;
import idv.cjcat.stardust.twoD.actions.Move;
import idv.cjcat.stardust.twoD.zones.CircleZone;
import idv.cjcat.stardust.twoD.zones.SinglePoint;
import idv.cjcat.stardust.common.clocks.SteadyClock;
import idv.cjcat.stardust.common.actions.Age;
import idv.cjcat.stardust.common.actions.DeathLife;
import idv.cjcat.stardust.common.initializers.Life;
import idv.cjcat.stardust.common.math.UniformRandom;

Next we need to add a few class properties to the document class. First is the emitter, this is the part of the particle engine that creates the particles, next is the renderer which actually draws the particles on to the display list, lastly there is an instance of SinglePoint, which is just a reference that we will be using to determine where the particles should appear on screen.

private var emitter:Emitter2D;
private var renderer:DisplayObjectRenderer;
private var point:SinglePoint;

Next in the document class constructor add the following lines of code, we will go through them a couple of lines at a time.

emitter = new Emitter2D(new SteadyClock(4));

This creates a new particle emitter and tells it to add new particles to the system at a steady rate of 4 particles each time the emitter.step() method is called.

emitter.addInitializer(new DisplayObjectClass(DemoParticle));
emitter.addInitializer(new Velocity(new CircleZone(0,0,4)));
emitter.addInitializer(new Life(new UniformRandom(20,60)));

These lines add some initial settings that will be applied to every particle that is created by the  emitter. The first line sets what graphics to use for the particles, in this case it is a class called DemoParticle which we will look at a bit later on towards the end of this tutorial.

The next line sets the starting velocity of each particle and the third line sets the life time that each particle will have. It’s important to note here that the two classes used for the Velocity and Life settings (CircleZone and UniformRandom respectively), are actually ways of describing a range of possible values rather than one specific value. This is a core part of how this particle system works, building up complex effects using random values chosen from within a specified range.

point = new SinglePoint(mouseX, mouseY);
emitter.addInitializer(new Position(point));

Here we create an instance of the SinglePoint class and use it to store a reference to the location of the particle emitter. We will update this value later on every frame to make the particle effect follow the mouse.

Now we add some actions. While the initializers above declared the initial settings that each particle will use when first created, these actions will determine how those initial settings are changed over time.

emitter.addAction(new Age());
emitter.addAction(new Move());
emitter.addAction(new DeathLife());

The Age action reduces the life of the particle over time, the Move action makes the particle move based on its velocity and the DeathLife action tells the engine to remove each particle from the display list after its lifetime has completed.

Next we create a renderer, then add the emitter to it and tell it to draw the graphics for the particle effect into a container DisplayObject. In this case we are using the document class as the container but you could use any Sprite or MovieClip you like.

renderer = new DisplayObjectRenderer(this);
renderer.addEmitter(emitter);

Finally we need to add a listener for the ENTER_FRAME event and create a function to handle the event called renderLoop.

addEventListener(Event.ENTER_FRAME, renderLoop);

Inside the renderLoop function we add the following code.

point.x = mouseX;
point.y = mouseY;
emitter.step();

This code does two things, first it sets the x and y properties of the SinglePoint instance to match the current mouse position, this will automatically update the position of the particle effect. Then it tells the engine to update the particle effect based on all the settings we set up in the code above by calling the step() method.

Now that’s all the code needed for this class, but there is one last thing we need to do, if you remember earlier on we told the particle system to use a class called DemoParticle to draw the graphics of each particle, so now we have to write that class.

Add a new ActionScript file to the same directory as your document class, save it as DemoParticle.as and paste the following code into it. This class simply draws a small blurred circle using a random colour and size. This will be used to provide the graphics for each new particle that is drawn by the particle engine.

package
{
  import flash.display.Sprite;
  import flash.events.Event;
  import flash.filters.BlurFilter;
  public class DemoParticle extends Sprite
  {
    private static const COLOURS:Array = [0x9F67FE, 0x6B6BFE, 0x5BBAFF];
    public function DemoParticle()
    {
      this.filters = [new BlurFilter(32,32,3)];
      graphics.beginFill(COLOURS[Math.floor(Math.random()*COLOURS.length)]);
      graphics.drawCircle(0, 0, 8 + Math.floor(8*Math.random()));
      graphics.endFill();
    }
  }
}

And that’s it, this is all that is needed to make a simple particle effect using the Stardust engine. Sure this is a very simple effect, but the aim of this tutorial is to understand the basics of how the engine works, from there you can start to create more complex effects using the whole range of complex actions and initializers available in Stardust combined with the built in filters and effects of the Flash Player.

To see the finished particle effect click on the link below, it doesn’t look all that much in the static screen shot below (these kind of effects rarely do), but it is actually a pretty cool smoke effect when you see it in motion. The full source code for this tutorial is also available to download from the demo page at the link below.

Click here to view the demo and download source code.

If you’ve ever tried developing a website completely in Flash then you will know just how much work it can take to setup the initial project structure and make Flash behave in a similar way to a standard HTML website. From asset loading and memory management to deep linking and browser history support, chances are that there is a site framework or code toolkit that makes building websites in AS3 that little bit easier.

Gaia Flash Framework – http://www.gaiaflashframework.com/
This is an excellent framework for Flash that really does make developing websites a breeze. It’s an open source ActionScript framework that comes with a Flash IDE component panel that helps you quickly setup a project automatically creating the files you need for each page of your site.  This automated ‘scaffolding’ provides a solid foundation from which to build a ‘traditional’ page based website in Flash, and ensures that all Gaia projects include browser back / forward button support and deep linking (thanks to built in SWFaddress integration), as well as a standardized page and asset loading system.

Once you have planned out the overall structure of your site, splitting it into a number of distinct sections or pages, you write this structure into Gaia’s site.xml config file, pass it to the scaffolding engine in the Gaia component panel and let the framework do the rest. Beyond this initial scaffolding and the common page based structure, it’s completely up to you what you do and how you code it, and that really is the best part of Gaia. It is a framework that gives you a fantastic set of tools as the starting point for every project, but then lets you do your own thing, because that freedom is what makes Flash sites so unique.

All that and I haven’t even mentioned the great level of support or the incredibly well written and regularly updated documentation. If you want to find out more, I’d recommend taking a look at some of the sites featured in the gallery on the project’s home page as well as this demo website which offers a good example of to how build a site using the framework.

CasaLib – http://casalib.org/
Perhaps you don’t need a full framework that structures a whole website for you, maybe all you need is an excellent set of classes that streamline the kind of common tasks required in most AS3 projects, if so then CasaLib is just what you need. From helping you load lots of external assets at once, to solving memory management issues or calculating the scaling ratios required for full screen websites, this library seems to have everything covered.

The toolkit is well documented with many examples in the main class documentation as well as on the project’s blog. The only real problem is remembering all the things it can help with, quite a few times I’ve been working on a project using CasaLib and written lots of code myself only to find out later on that the toolkit already has a class to do just what I needed, oh well never mind.

Polygonal Labs Data Structures – http://lab.polygonal.de/ds/
A great set of utility classes that build extra functionality on top of the existing core ActionScript data classes. I think these ‘data structures’ were originally intended for use in Flash games, but I’ve found them very helpful for all sorts of projects.

For an example of the library’s effectiveness, see this post by John Lindquist where an iTunes style cover flow effect is put together with only a few lines of code. I remember writing a similar effect a while ago for work using a much earlier version of Papervision3D, and can definitely say it took a lot more code than that, if only I’d known about these AS3 data structures back then.

PureMVC – http://trac.puremvc.org/PureMVC_AS3/
Described as a lightweight framework for structuring your projects using the classic Model View Controller design pattern, PureMVC looks to be a great way to ensure that your code remains modular and reusable. Those of us who have tried to code within the MVC pattern before will know know that despite the best of intentions things can often go astray, this framework aims to address that issue by providing a great standardized structure to work within.

I haven’t used PureMVC on a project yet, but there seems to be two main points of view about it. One argues that it can be quite restrictive, forcing you to work within a strict MVC design pattern for even the most simple of tasks. The other view notes that this focus on structure does ensure that you code is far more stable, logical and reusable than is usually the case. For me, as someone who is always trying to write more elegant and reusable code, it may well be worth a try.

AS Hive – http://code.google.com/p/as-hive/
AS-Hive is a state based framework which seems to share a very similar approach to website development as the Gaia Framework, sitting in the background, part way between something that determines the structure of your application and a toolbox you can dip into as and when you need.

Both of these frameworks have a similar focus on application flow, in particular they are structured around managing transitions between the different states of you application by creating sequences of animation and asset loading to move from one screen to the next. This kind of thing is so intrinsic to projects built in Flash which often have a strong focus on animation, but is too often overlooked by frameworks and design patterns based on code from other languages.

I have yet to work on a project using Hive, but it does look very promising and could be a very good alternative to the Gaia Framework, especially if you’re working on an AS3 only project using the Flex SDK rather than the Flash IDE. In fact, while Gaia may remain the best solution for page based websites in Flash, Hive might provide a bit more freedom in the way it can be used for a much wider variety of projects such as games and social media tools.

While much of what is covered will probably be familiar ground to many ActionScript developers, for Flash newbies these guides will hopefully offer a good introduction to the code libraries available for use in your projects. This one will focus on the range of 3D engines that are now available for Flash, highlighting the key features of each engine and hopefully help make it a little bit easier to choose one to use.

Papervision3D – http://blog.papervision3d.org/
The most popular and widely used of the current 3D engines for Flash is also the first one to have a book released about it. I’ve used it on a couple of projects now, and have always found it very simple and easy to use. It may not have all the advanced features and effects of some of the other engines featured here, but it does provide a smoother learning curve for those that are new to 3D, with a logical and well structured API, excellent documentation and an abundance of tutorials. Papervision also has a great development community, with a real focus on helping those who are just starting out with 3D in Flash. To see the range of projects that already use this engine take a look at the Papervision Showcase site, for some great demos and tutorials check out pv3d.org.

Away3D – http://away3d.com/
Some would say that Away3D has a better feature set and is much more powerful than any other open source AS3 3D engine currently available, and that may well be the case judging by the amazing demos that get featured on the project’s home page. Another plus is it’s great level of Flash Player 10 support, which not only provides a major speed increase but also some new features like Pixel Shader support and HDR lighting. However, with all these extra features comes larger file sizes, a more complex API, and a much steeper learning curve, although some of this is now being addressed by the very impressive Away3DLite project.

Sandy3D – http://www.flashsandy.org/
Another great 3D engine for Flash, this time with added support for both AS2 and AS3, as well as a HaXe version. It also offers unique features like integration with the WOW physics engine and some rather nice colored lighting effects that remind me of Quake 2 and the early days of 3DFX video cards.

Alternativa3D - http://alternativaplatform.com/en/alternativa3d/
This engine looks to be very much geared towards high quality visuals and seems to have been heavily optimized for use as a first person perspective engine. It has some truly amazing first person demos which showcase its advanced rendering features, but until recently I’d only seen the demos rather than finished sites. However this stunning new Golf GTI racing game really proves Alternativa3D to be an excellent platform for 3D Flash development.

Five3D – http://five3d.mathieu-badimon.com/
An excellent lightweight vector based alternative to the 3D engines above. I’ve used it on a couple of projects at work and have found it very easy to use as it builds upon existing AS3 classes like Sprite in much the same way as the new 3D API does in Flash Player 10. If you just want to add some 3D perspective and animation to shapes created with the 2D drawing API then this is the 3D library to use.

ND3D – http://www.nulldesign.de/projects/nd3d-as3-3d-engine/
With a compiled size of around 10k, this engine is aimed at speed and simplicity in a similar way to Five3D and Away3DLite. It also has some great built in features that you can use straight out of the box including: depth of field effects, additive blending and interactive meshes. Check out the demos on the project home page to see what it can do, this is definitely one to watch in the near future.

ZedBox – http://code.google.com/p/zedbox/
This new engine addresses the limitations of Flash Player 10′s native 3D rendering -mainly the pixel aliasing issues caused by bitmap caching when 3D transforms are used – by offering a lightweight alternative. It only features flat ‘billboard’ style graphics, but it runs fast and appears to be very easy to use.

Yogurt3D – http://www.yogurt3d.com
Yogurt3D is a new engine primarily aimed at making 3D games in Flash. Not that much is known about the engine right now, but the website says that it will which feature a core API named ‘SwiftGL’ that should be familiar to developers who already know OpenGL.

Other Options
So apart from using one of these excellent open source libraries, what else could you do to get 3D graphics running in your Flash websites and games? Well there’s always Flash Player 10 and it’s built in 3D support. I’ve recently been trying out Flex 4 and had a go at using the new 3D features  such as drawTriangles, and while it is definitely simple and easy to, requiring very little maths, the visual quality wasn’t quite what I’d hoped for when compared to Papervision3D and Five3D. Saying that, the real potential of native 3D in Flash Player 10 is in the new 3D utility classes, which along with pixel bender and alchemy are being used to improve many of the current Flash 9 3D engines.

Of course, there’s always the option of making your own 3D engine using the standard drawing API and a bit of maths, or even trying something a bit more ambitious like ray tracing or voxels, it’s all possible in AS3. One great example of this ‘home made’ approach is the incredibly fast Sharikura3D engine by Roxik. This engine was used for Eco Zoo, which won the FWA 2008 Site of the Year award, and has some of the best graphics and the smoothest frame rate I’ve seen in any 3D Flash website.

Next Steps
If any of this has inspired you to find out more about writing your own 3D engine in AS3, then Keith Peters legendary book -  Foundation AS3 Animation: Making Things Move – is definitely the place to start. The book covers the basics of setting up a vector based 3D engine in AS3 and includes shading, backface culling and 3D meshes, along with loads of other graphics and animation concepts. In fact, even if you’ve no intention of writing a 3D engine from scratch, it is still well worth a read as it really helps you understand the basics of how 3D in Flash actually works.

This demo was my attempt at creating a version of Soulwire’s Papervision3D Ribbon class using native Flash Player 10 code, and while the demo doesn’t support the more advanced features of the Papervision version, the final result does look quite similar. In fact, if you take a look at the code you’ll see just how simple 3D can be when using Flash 10.

Using drawTriangles to render 3D graphics is fairly straight forward, requiring you to pass in a number of different Vectors to describe the geometry of a 3D mesh. A Vector is Flash 10′s new typed array class, and is very useful for making sure that an array contains only one type of data. The drawTriangles method accepts four parameters, three of them Vectors, but I won’t go into this in detail here as there are many good articles that explain it far better than I can, such as this excellent introduction to drawTriangles by Ryan Taylor.

What I will note is that from my tests and what what I have read, it seems that drawTriangles (while very useful) is best suited to quick and simple 3D effects. If you’re looking to render light sourced materials with proper z-sorting, or more than one texture map per object, then you will probably need to write your own classes to do just that, much as this post by Neuro Productions explains.

In fact, what really makes 3D in Flash 10 shine are the new utility classes such as Matrix3D, Vector3D and Utils3D. If you look at the code for the demo below you will see that there is really not much complex maths being used, instead it is mostly taken care of with these new classes.  And it is these classes which new engines like PapervisionX or Away3DLite will most likely be using to boost speed and improve visual quality in Flash Player 10.

Click here to view the demo and source code

Setting up Flex 4 turned out to be much easier than I expected (was just a case of swapping it for Flex 3 in the FlashDevelop compile settings), and while you don’t get code completion for the new Flash 10 classes everything else runs fine.

While there’s lots of great new features in Flash 10, the one thing I wanted to try out was the new built in 3D transforms and drawing API. So I set about trying to make some kind of 3D sound tunnel, the aim was to get something that looked like an old Llamasoft game, although I’m not sure quite how successful that was.

Anyway, the code turned out to be surprisingly easy to write, it seems that Adobe have gone to some real effort to make sure that the new 3D effects in Flash 10 are as easy to use as possible. In many ways it’s actually quite similar to how Five3D works, you can rotate any display object on any axis, move the vanishing point of the scene and even adjust things like camera focus and field of view, although as far as I know you cannot actually move the camera itself.

While this is all great, there are a few limitations to these new 3D effects as Keith Peters has pointed out in his posts about the visual quality of 3D in Flash 10 and the effect this has on nested display objects with 3D transforms. Some of this, such as the lack of anti-aliasing, you will be able to see in the demo below.

Despite these issues, I think the Flash 10 3D effects will come in very useful on some future project where low file sizes and simple code might be more important than higher visual quality.

Check out the demo and source code below, as usual the music (or you could just call it noise) was made using the Hobnox AudioTool ToneMatrix, which is their version of the Yamaha Tenori-On.

Click here for demo and source code