Entire CadetEditor Stack Open Sourced


  • Want to make visual editors for your games, similar to this https://www.youtube.com/watch?v=qDFWaaqtXF4 ?
  • Want to create a reusable set of components/behaviours that don’t tie you to any particular renderer or physics engine?
  • Cadet is for you!


Today we’re very pleased to announce a major milestone for the Cadet project – we have now open sourced the entire Cadet stack! This means that developers have full access to our editor code as seen in these videos http://vimeo.com/cadeteditor


Here are the main repositories, which can all be found on the CadetEditor GitHub page:


And here’s a quick explanation of each project:


A bare-bones application development framework which provides core functionality to CadetEngine and CoreEditor. CoreApp provides a FileSystemProvider abstraction layer, asynchronous and undoable Operations, a powerful Serialization library, Validators and many other tools which were key to building an application of this scale.


A lightweight alternative to Flex, CoreUI is a simple to use UI framework that powers all of the UI for CadetEditor.


The extensible editor development framework upon which CadetEditor is built. CoreEditor provides the foundations that are key to building sophisticated editor software, including: Command Handlers, Visual Contexts, Actions, Menu Bars, File System Tree views and much more. This project is a great place to start if you’d like to build your own custom editor.


A truly plug-and-play component-based scene engine. CadetEngine was designed from the ground up to be editable and can easily be extended by creating custom Behaviours, Processes, Skins and Renderers.


An editor built on top of the CoreEditor project which allows users to visually manipulate the CadetEngine scene graph.


Information Overload!

Don’t worry, because we’ve also released all of our documentation! If you’d like to learn how to build your own editors, we highly recommend completing the tutorials in the following order:

CoreEditor Tutorials
CadetEngine Tutorials
CadetEditor Tutorials

And if that’s not enough information for you… Let us know what you think’s missing and we’ll see what we can do 🙂

What’s Next

We’re big fans of Haxe and think that the project’s ideals are in-keeping with those of Cadet. We’re super excited about the potential to build open and reusable game components that will work on any platform.

As you can see, we’ve made a start on a Haxe port. We are doing this in our free time so any help is hugely appreciated!


Posted in Misc | 1 Comment

CadetEditor – Release 3 – Nested Transform2Ds

Introducing the third beta release of CadetEditor, version 0.4.2. This version introduces the ability for nested Transform2Ds within the CadetEngine scene graph to inherit transform information from their “parent” Transform2Ds. You can download the updated release versions here.


Previously, Rectangle_1_Transform2D (pictured) would not be affected by changes to the position, scale or rotation of Rectangle_0_Transform2D. This meant, for instance, that rotating the Rectangle_0 component would not rotate its child component, Rectangle_1. Łukasz Łazarecki of Big Daddy Creations felt that this was not the desired behaviour, and after some discussion convinced me he was right (on the proviso that he updated the transform code!).

After a disturbingly short amount of time, Łukasz had updated the code and demonstrated that this addition fit neatly with the existing examples, providing additional functionality without breaking anything. Confident in Łukasz’s ability, understanding and enthusiasm for the system, we have since happily added him as a member of the CadetEditor open source project. We look forward to further discussions and valuable contributions!

Posted in Misc | Leave a comment

CadetEditor – Release 2 – Box2D Upgrade

Introducing the second beta release of CadetEditor. This version adds a number of bug fixes and improvements to the initial release and can be downloaded here. The main improvements are as follows:

  • FileSystem browser issue fixed on Mac
  • GeometrySkin & TextureComponent performance increase (validation cycle bug fix)
  • Design time performance increase (view grid disabled at smaller grid sizes/zooms)
  • Fixed editor selection issues relating to Connections, Pins & Polygons
  • Fixed Box2D geometry rotation issue
  • Added Box2D DebugDrawProcess Overlay
  • Separated & improved motorbike game demo
  • fixed validateDisplay for Skins

This version also introduces the new open source project Cadet-Vehicles-Box2D. As per the Cadet-HungryHero project, this project demonstrates custom CadetEngine and CadetEditor extensions and AIR, web and mobile deployments. The purpose of this project is to share and test a number of different types of Box2D vehicles that can be created with CadetEditor. It’s very barebones at the moment, but if you’d like to add any cool demos, please get involved! Currently the main demo is the Vehicle (Side View) Behaviour. Here’s a quick video demonstrating it in action:

[vimeo 72425653]

As part of the Box2D improvements, I’ve also added the DebugDrawProcess. This process allows you to overlay a Box2D debug view on top of the Cadet scene to make sure the positions of the Cadet2D objects exactly match those of the Box2D versions. Here’s a video demonstrating that:

[vimeo 72477876]

Hope that helps, looking forward to hearing your thoughts! 🙂

Posted in Misc | Tagged , , | 5 Comments

CadetEngine Talk @ DotBrighton

A big thanks to everyone who attended my DotBrighton talk last night on CadetEngine and the future of Flash. As promised, here’s the slide deck. Enjoy!

Posted in Misc | Tagged , , , | Leave a comment

Cadet Engine Launch

Today we’re proud to announce the launch of CadetEngine, the engine behind CadetEditor. CadetEngine is an open source, component-based ActionScript3 scene engine, which has been designed from the ground up to be plug-and-play in order to support editability.


What’s special about CadetEngine? Unlike many other game engines available in Flash, CadetEngine is fully supported by an extensible editor tool, namely CadetEditor. Generally, building an editor for a custom game would be a task too large to contemplate on most indie game development timelines. However, when using CadetEngine, the process of editor creation is almost entirely automatic.

CadetEngine code is organised into Components, everything within the CadetScene (itself a component) must be a Component. Components tasked with displaying things are called Skins, Components tasked with executing custom code are named Behaviours or Processes, depending on whether they’re local to an entity or scene-wide.

In order to demonstrate how games can be built in CadetEngine, we’ve ported the open source HungryHero game from the original AIR gaming SDK. The CadetEngine version can be found here. We’ve tried to keep the code as similar to the original as possible to make things easier to understand, but the main difference is that the code has been organised into Cadet Components.

The key trick to getting your custom code to play well with the editor is using the [Serializable] and [Inspectable] metadata tags. [Serializable] means that the Serializer will store the state of this property when saving the scene to XML, [Inspectable] means that the editor’s property inspector will provide an editor for the property. Take the following code example from hungryHero.components.behaviours.ParallaxBehaviour:

[Serializable][Inspectable( editor="Slider", min="0", max="1", snapInterval="0.05" )]
public function set depth( value:Number ):void
	_depth = value;
public function get depth():Number { return _depth; }

public function set speed( value:Number ):void
	_speed = value;
public function get speed():Number { return _speed; }

The inclusion of the [Inspectable] metadata above causes the editor to display the following interface in the properties inspector when the ParallaxBehaviour Component is selected. The inclusion of the [Serializable] metadata ensures that the state of these properties will be saved when the user saves the scene.


Hopefully that gives a reasonably quick overview of how to build editable games with CadetEngine, please check the website and the wiki for more videos and tutorials. We hope this helps you with your game projects! 🙂

Posted in Misc | 4 Comments

Cadet Editor Launch

After much tinkering, testing, re-factoring and playing, the team at Unwrong are proud to announce the launch of cadeteditor.github.io, the demo site for our new app. Cadet is a general-purpose editor framework for the Flash platform. To demo Cadet we decided to build a Box2D physics editor and an Away3D scene editor, though if an engine has a Scene Graph, we could probably write an editor for it using Cadet. We’ve also published a few videos to help give an idea of the various features in each editor. For instance… This video demonstrates how easy it is to create a simple physics scene in the Box2D editor:

This video introduces Joints, a more advanced Box2D concept:

This video demonstrates the ActionScript and three.js exporters (I mentioned in my previous post) in action in the Away3D editor:

And this video demonstrates importing and texturing a custom model in the 3D editor:

If you feel like watching any more, the rest can be found on our Vimeo page.

If you’d like to keep up-to-date with the latest features and fixes, please subscribe to our Facebook or Twitter.

We hope you enjoy playing with the editors and if you have any feedback, let us know! 🙂

Posted in Apps, Away3D, Bones, Editor, Flash | 8 Comments

Away3D 4.0 Gold: AS3 and three.js exporters

Last year I began messing around with the AS3 exporter for Away3D 3.6.0. After writing a few test scenes and resolving a few issues with it, I went on to see whether I could write a three.js exporter, and experienced some positive results.

Lots of things have changed since last September, the biggest of those being the complete rewrite of the Away3D engine to support the Stage3D APIs. One thing that hasn’t changed though is my particular interest in writing exporters for Away3D. The current “Gold” release of Away3D doesn’t yet support serialization; the old code obviously became defunct with the rewrite, and the Away team have no doubt been focused on code which is more pivotal to the engine’s success over recent months.

It just so happened that I needed at least a basic working Away3D exporter for a project I’m working on, so I decided to write a new one. If you’d like to see what I’ve added here are the commit details to my fork of away3d-core-fp11. If you’d like to run the few simple tests I’ve create for yourself, you can download them from my blog repo on github. Note: To run the experiments, you’ll also need a copy of my away3d-core-fp11 fork which contains the Away3D updates. Alternatively, you can view the same examples in your browser here.

As per the Away3D 3.6.0 -> three.js exporter, you’ll notice in the examples that the X-Axis is inverted. Other than this though, the results are pretty similar. I’ve decided not to try and rectify the differences below between the Away3D and three.js scenes, as they are all a result of how the engines “naturally” render their primitives and scene. For instance, I could have flipped the three.js Wireframe Plane and Torus primitives to match their Away3D counterparts, though this added code could cause confusion later if the developer expected the transform of the object to be the same as it was in ActionScript.


I’ve also tried to make the ActionScript and JavaScript outputted by the Serializer as neat and as similar to one another as possible. Here’s an excerpt from the ActionScript and JavaScript output created by the Primitives scene:


As you can see, three.js needs to use a slightly different geometry and material in this instance, but the resultant meshes both access these objects using their position in an array, which contains only that type of object.

Hopefully that gives a reasonable overview of the Serializer code as it stands, I’ll submit it to the Away team and keep my fingers crossed that it’ll be accepted..! 🙂

Posted in Away3D, Flash, HTML5, Three JS | Tagged , , , , | 3 Comments