Since the beginning of this year I got in touch with Robotlegs thanks to Erik van Nieuwburg. In case you have’t heard of Robotlegs or haven’t used it, you should really check it out sometime soon. It is a micro framework that helps separating your application tiers in a very elegant way. I’ve developed a couple of projects myself using Robotlegs and I really have to say that I’m loving it. Once you know the trick, it seems like a natural way develop your applications like this. It makes your life as a developer a lot easier.

Once I got this into my fingers I suddenly realized that how Robotlegs handles views with mediators is somehow similar to how Unity works with game objects (models aka views in Robotlegs) and components (scripts/predefined functionality aka mediators in Robotlegs). The big difference between Unity components and mediators in Robotlegs is that Unity can work with multiple components on an object and Robotlegs doesn’t.

With the recent public beta release of Flash Player 11 (Incubator) and SDK with the Molehill functionality (native 3D), the alpha release of Away3D 4 “Broomstick” and the announcement by Unity regarding Flash publishing, it became time to get started with this experiment.

Basically I wanted to achieve two seperate things:

1. Marrying Robotlegs to Away3D
2. Add multiple mediators to 3D objects similar to script components in Unity3D

In order to achieve this I had to make small adjustments to Away3D in order te get an event dispatched as soon as a model is added to the scene. By default no event is fired once a model is added to the Context3D (Aka 3D stage). This is because the 3D stage doesn’t have a display list. So I forked Away3D on GitHub and applied the needed changes and send out a pull request so that these changes could be implemented by the Away3D team. At time of writing this request is still pending, but I’m sure the Away3D team will merge this into their code anytime soon.

A new GitHub repository has been created under the name of “Robotlegs-Away3D-Extension“, which introduces several new classes. The most important once are

• Context3D (not to be confused with native Flash 11 Context3D)
  You need to extend this class and use it as the context of your application
• Mediator3D
  Similar to a mediator as we normally use in Robotlegs, only this type is for 3D objects and not for view components.
• Mediator3DMap
  As you probably have guessed it, this is similar to the MediatorMap, but maps zer0, one or multiple Mediator3D instances to a 3D object that is present in a scene.

So with this available you can do things in your context like:

threeDeeMap.mapObject3D(Car3D, [BoxCollider, SimpleSteerBehaviour]);

Which says in fact that whenever a Car3D is added to the scene, we need to create an accompanying BoxCollider and a SimpleSteerBehaviour. The latter two are extended Mediator3D classes and are connected to the Car3D. This separates views from functionality and goes even a step further than Robotlegs does by default, as we can have multiple mediators for one single thing we want to display and is consistant with the “Single Responsibility Principle (SRP)” where one class is only responsible for doing one type of actions. In this case functionality of steering has nothing to do with detecting collisions. Although you possibly want to use both, they both do other types of operations and should not be merged into a single class. As this will make classes longer and harder to understand.

As I mentioned earlier, this work is available on GitHub, as well as an example project on how you could use this. The work is far from being perfect and should be improved when I decide to further develop on this (or when someone forks it and continues development ). What interests me the most at this stage is to hear from others whether this approach would make any sense or not and how it could be improved concept wise.
Besides, and here comes an extra wink at Unity, I hope that Unity gets inspired by this approach and possibly even adopt the use of Robotlegs. As if Unity publishing to Flash isn’t awesome enough, I think such approach has the potential to become a mind blowing awesome combination. This also means that I am voting for creating a code based build instead of just compiling a SWF file. With code publishing you leave so much more power in the hands of the developers to integrate the 3D content with 2D content. Also integrating external tools such as FDT, Flash Builder or Flex builder and the Flash IDE itself would an interesting approach.

So lets finally sum up some relevant links:

• Robotlegs Away3D Extension on GitHub
• Away3D Broomstick fork on GitHub (as long as my pull request isn’t implemented by the Away3D team)
• CarExample source on GitHub
• CarExample as included in the examples on GitHub (requires Flash Player 11 Incubator)
• CarExample screen-cast (for those without the beta player installed)

And again please, if you have any thoughts on this that you’d like to share. Please let me know. I think it would be good to get the debate going and find out what would be a powerful and elegant way to manage your 3D content with Robotlegs.

{
  "book":[
    {
      "id":"1",
      "title":"Papervision3D Essentials",
      "image":"http:\/\/paultondeur.com\/files\/2010\/UnityExternalJSONXML\/Papervision3DEssentials.jpg",
      "authors":
      {
        "author":[
          {"id":"1","name":"Paul Tondeur"},
          {"id":"2","name":"Jeff Winder"}
        ]
      },
      "description":"<p>Create interactive <b>Papervision3D<\/b> applications with stunning effects and powerful animations<\/p>"
    },
    {
      "id":"2",
      "title":"Unity Game Development Essentials",
      "image":"http:\/\/paultondeur.com\/files\/2010\/UnityExternalJSONXML\/UnityGameDevelopmentEssentials.jpg",
      "authors":
      {
        "author":[
          {"id":"3","name":"Will Goldstone"}
        ]
      },
      "description":"<p>Build fully functional, professional 3D games with realistic environments, sound, <i>dynamic effects<\/i>, and more!<\/p>"
    }
  ]
}

This file can also be found on http://paultondeur.com/files/2010/UnityExternalJSONXML/books.json and will be used later on in this tutorial.

JSON isn’t as integrated in C# development as XML is. Furtunatly the JSON documentation website lists external libraries that are available for a variety of languages. Including a couple C# projects. After having a glance at all, I found out that I liked LitJSON the most. It’s usage is quite straight forward. The source of this project can be found on found on SVN. After checking this project out from SVN, you’ll end up with a couple of classes and make files. From these files, a dll should be created for use in Unity. This might sound a bit frightening when you’re new to C Sharp development. Therefore I’ve already created this dll for you (also included in the download at the end of this article). You just need to copy this into the asset folder of your Unity project and from then on you’ll have access to all classes inside of this dll. In order to use them in your scripts, you need to set the using directive on top of your class to:

using UnityEngine;

Just like with XML, we can load the JSON file by using the WWW class.

WWW www = new WWW("http://paultondeur.com/files/2010/UnityExternalJSONXML/books.json");

Once the data is loaded from the provided URL, we need to convert the loaded string into an object of the JsonData type. We can use a static method of the JsonMapper class to achieve this:

JsonData jsonBooks = JsonMapper.ToObject(jsonString);

Now we have the string converted into an object, we can easily access the objects that have been defined in the JSON file. So let’s say we want access the book object and show how many books are nested:

Debug.Log(jsonBooks["book"].Count);

That looks easy, right? jsonBooks["book"] holds an array of books, so in order to loop through all books, we can use a simple for loop:

for(int i = 0; i<jsonBooks["book"].Count; i++)
{
  ......
}

In this example, it will loop through the two books. While looping through them, we can print the book title on the screen:

Debug.Log(jsonBooks["book"][i]["title"].ToString());

Notice the ToString() method call at the end of the selected object. This will convert the object into a string. C# is more strict with this as compared to ActionScript, so never forget to call this to prevent errors.

Now let’s say you want to access the book ID and treat it as in integer. You first need to convert the object to a string and then convert it to an integer.

Debug.Log(Convert.ToInt16(jsonBooks["book"][i]["id"].ToString()));

Nested inside an book object are the authors. Looping through them is quite easy, as we can you access these nested elements. Look at how to loop through the authors and print their names on the screen:

for(int j = 0; j<jsonBooks["book"][i]["authors"]["author"].Count; j++)
{
  Debug.Log(jsonBooks["book"][i]["authors"]["author"][j]["name"].ToString());
}

I’ve recreated the same example as used in part 1 of this tutorial, only this time with a JSON file as the data source. The complete source can be found in the download, however have a look at the following code to see how LitJSON could be used in production:

using UnityEngine;
using LitJson;
using System;
using System.Collections;

public class LoadJSON : MonoBehaviour
{
  IEnumerator Start()
  {
    //Load JSON data from a URL
    string url = "http://paultondeur.com/files/2010/UnityExternalJSONXML/books.json";
    WWW www = new WWW(url);

    //Load the data and yield (wait) till it's ready before we continue executing the rest of this method.
    yield return www;
    if (www.error == null)
    {
      //Sucessfully loaded the JSON string
      Debug.Log("Loaded following JSON string" + www.data);

      //Process books found in JSON file
      ProcessBooks(www.data);
    }
    else
    {
      Debug.Log("ERROR: " + www.error);
    }

  }

  //Converts a JSON string into Book objects and shows a book out of it on the screen
  private void ProcessBooks(string jsonString)
  {
    JsonData jsonBooks = JsonMapper.ToObject(jsonString);
    Book book;

    for(int i = 0; i<jsonBooks["book"].Count; i++)
    {
      book = new Book();
      book.id = Convert.ToInt16(jsonBooks["book"][i]["id"].ToString());
      book.title = jsonBooks["book"][i]["title"].ToString();
      book.image = jsonBooks["book"][i]["image"].ToString();
      book.description = jsonBooks["book"][i]["description"].ToString();
      book.authors = new ArrayList();

      for(int j = 0; j<jsonBooks["book"][i]["authors"]["author"].Count; j++)
      {
        book.authors.Add(jsonBooks["book"][i]["authors"]["author"][j]["name"].ToString());
      }

      LoadBook(book);
    }
  }

  //Finds book object in application and send the Book as parameter.
  //Currently only works with two books
  private void LoadBook(Book book)
  {
    GameObject bookGameObject = GameObject.Find("Book" + book.id.ToString());
    bookGameObject.SendMessage("LoadBook", book);
  }

}

This gives an idea how to handle JSON files in Unity. Just like with XML this comes with a disadvantage in terms of filesize. It’s size footprint to the Unity file is about equal to XML: +/- 850kb. A live example of this can be viewed here.

Conclusion
I think it’s quite hard to say which file format is better. Both XML and JSON add about the same amount of kilobytes to the Unity file. I’ve not tested which of these is more efficient performance wise. It might be worth checking that out before you’ll be working with large amounts of data. In case that doesn’t matter, I think it’s just a matter of personal taste. I think I kind of prefer to use JSON, as this reminds me of handling XML files with ActionScript in the AS2 days.
But give it a try yourself and see what works best for you.

Downloads / Examples

• Download XML and JSON example files
• Download LitJSON dll file
• View XML Example
• View JSON Example
• Go to part 1 of this tutorial

<?xml version="1.0"?>
<books>
  <book id="1">
    <title>Papervision3D Essentials</title>
    <image>http://paultondeur.com/files/2010/UnityExternalJSONXML/Papervision3DEssentials.jpg</image>
    <authors>
      <author id="1">Paul Tondeur</author>
      <author id="2">Jeff Winder</author>
    </authors>
    <description>
      <![CDATA[<p>Create interactive <b>Papervision3D</b> applications with stunning effects and powerful animations</p>]]>
    </description>
  </book>
  <book id="2">
    <title>Unity Game Development Essentials</title>
    <image>http://paultondeur.com/files/2010/UnityExternalJSONXML/UnityGameDevelopmentEssentials.jpg</image>
    <authors>
      <author id="3">Will Goldstone</author>
    </authors>
    <description>
      <![CDATA[<p>Build fully functional, professional 3D games with realistic environments, sound, <i>dynamic effects</i>, and more!</p>]]>
    </description>
  </book>
</books>

This file can also be found on: http://paultondeur.com/files/2010/UnityExternalJSONXML/books.xml and will be loaded later on in this tutorial.

XML is not new to C#. In fact, it’s quite integrated within the language. When you create a new application in Visual Studio, you have access to the System.Xml namespace by default. Within this namespace, lots of classes can be found for creating, reading and modifying XML documents. Accessing these classes in Unity however, doesn’t work out of the box. This is because this namespace isn’t available within Unity. The solution for this is relatively simple; We just need to reference the System.Xml dll in Unity. As Unity is build upon the Mono Framework, this file is provided with your local Unity install. You can find these files at the following locations, depending on the machine you’re running on:

• MAC: Go to /Applications/Unity/ and right-click on Unity.app -> Show Package Contents. Then browse to “Contents/Frameworks/Mono.framework/”. In this folder you’ll find lot’s of dll files. In this case, just copy System.Xml.dll
• Windows: Go to C:\Program Files\Unity\Editor\Data\Frameworks\Mono.framework and copy System.Xml.dll from here.

The next thing to do is paste the dll into your assets folder of a Unity project. Next time you compile this project, the System.Xml namespace is available to you from within the Unity player.

To load any external content from a webserver with Unity, we can use the WWW class. (can be compared to a URLRequest in Flash).

WWW www = new WWW("http://paultondeur.com/files/2010/UnityExternalJSONXML/books.xml");

Once the data is loaded we can instantiate a new XML document and load the XML by the data that has returned from the www class request.

XmlDocument xmlDoc = new XmlDocument();
xmlDoc.LoadXml(www.data);

Instead of using E4X (as in Flash) to select childnodes inside the XML document, we have to make use of an XPath expression. In our case we want to select all books, which are nested inside the books element. Selecting nodes returns an XmlNodeList, which will be used to loop through all results. Take a look at how to select all book nodes and loop through them:

foreach (XmlNode node in xmlDoc.SelectNodes("books/book") )
{
  .....
}

Inside the loop we have access to the value “node“, which contains information of the selected book. Let’s say we want to access the title node value of the book and show it on the screen:

Debug.Log(node.SelectSingleNode("title").InnerText);

Accessing the description (which contains a CDATA block) is no different from selecting the title node:

Debug.Log(node.SelectSingleNode("description").InnerText);

Selecting an attribute of a node works of course a bit different. When we want to access the book id attribute we do this as follows:

Debug.Log(node.Attributes.GetNamedItem("id").Value);

All values in an XML are of a String type by default. In this case the id attribute is clearly of an integer type. Although it wouldn’t make any sense in this case, casting it to an int can be achieved by using the Convert utils class:

Debug.Log(Convert.ToInt16(node.Attributes.GetNamedItem("id").Value));

Inside a book node, we can find an authors node, which contains nested author nodes inside. In order to loop through these, we can again use an XPath expression, only this time on the current selected node.

foreach (XmlNode author in node.SelectNodes("authors/author"))
{
  Debug.Log(author.InnerText);
}

Around this concept of loading and parsing an XML file I’ve created a very small Unity application, which shows the two book covers on screen and calls a Debug.Log() on the author name on click on the book. The complete code can be found in the download at the bottom of this article. But the class that handles loading and parsing the XML looks as follows:

using UnityEngine;
using System.Collections;
using System.Xml;
using System;

public class LoadXML : MonoBehaviour
{
  IEnumerator Start()
  {
    //Load XML data from a URL
    string url = "http://paultondeur.com/files/2010/UnityExternalJSONXML/books.xml";
    WWW www = new WWW(url);

    //Load the data and yield (wait) till it's ready before we continue executing the rest of this method.
    yield return www;
    if (www.error == null)
    {
      //Sucessfully loaded the XML
      Debug.Log("Loaded following XML " + www.data);

      //Create a new XML document out of the loaded data
      XmlDocument xmlDoc = new XmlDocument();
      xmlDoc.LoadXml(www.data);

      //Point to the book nodes and process them
      ProcessBooks(xmlDoc.SelectNodes("books/book"));
    }
    else
    {
      Debug.Log("ERROR: " + www.error);
    }

  }

  //Converts an XmlNodeList into Book objects and shows a book out of it on the screen
  private void ProcessBooks(XmlNodeList nodes)
  {
    Book book;

    foreach (XmlNode node in nodes)
    {
      book = new Book();
      book.id = Convert.ToInt16(node.Attributes.GetNamedItem("id").Value);
      book.title = node.SelectSingleNode("title").InnerText;
      book.image = node.SelectSingleNode("image").InnerText;
      book.description = node.SelectSingleNode("description").InnerText;
      book.authors = new ArrayList();

      //Loop the authors
      foreach (XmlNode author in node.SelectNodes("authors/author"))
      {
        book.authors.Add(author.InnerText);
      }

      LoadBook(book);
    }
  }

  //Finds book object in application and send the Book as parameter.
  //Currently only works with two books
  private void LoadBook(Book book)
  {
    GameObject bookGameObject = GameObject.Find("Book" + book.id.ToString());
    bookGameObject.SendMessage("LoadBook", book);
  }
}

With this example you should be able to load and parse your own XML files. Before doing this, I need to point you to the fact that using the System.Xml dll results in quite a large footprint to your application. In my tests it turned out that it was about an 850kb difference between having an empty Unity application and an application that is using the System.Xml dll.

In the next part of this tutorial I’ll demonstrate how you could achieve the same results with a JSON file as data container.

• Download the source files for this complete tutorial (part1 and part2) here.
• A working demonstration of this example with XML can be found here.
• Continue reading this tutorial in part 2 about loading and parsing a JSON file.

Besides my workshop, there will be lots of other interesting presentations and workshops during the day. You should keep an eye on the website of the usergroup for updates about all sessions and speakers. So far the other confirmed speakers are:  Pascal Leroy, Dave August, Zender, Tobias Mannewitz, De Monsters, Rufus Deuchler, Champagne Valentine, Serge Jespers, Hanazuki, Jason Levine, Ralph Hauwert, Dirk Groten, Paul Burnett.

I think the day provided the visitors with a lot of essential information in order to get started with Unity. The feedback I received on my talk was very good, so hopefully I contributed to new Unity users getting started with Unity.

As promised in my presentation, I’ve posted my presentation online, which you’ll find at the end of this post. In the next weeks when I’ve returned and recoverd from this conference, I’ll start posting some of the examples as mentioned in my presentation. So you can expect the JSON, Google Analytics, XML loading and Parsing, image loading and posting variables examples on this page.

I already twittered this while being on vacation, however I thought it would be nice to give this some extra attention, since I think the conference is going to rock. After investing a lot of time since last years Unite conference in Copenhagen, it would be very interesting to see where other developers have been into and join the very promising sessions that are scheduled (http://unity3d.com/unite/agenda).

If you don’t have a ticket yet, you should really rush, as the conference already starts in a little more than 2 weeks on the 27th of October.

In my point of view, Unity made a very wise decision this year by organizing a special day for Flash developers. This day will give the conference a kick-start for Flash developers who want to get into Unity, as they will be introduced to everything they need to know to get along with the rest of the conference (and start themselves with some Unity development afterwards). I would have been so grateful when such conference day was available at the time I got into Unity.

I feel very honored that ‘m invited by the people of Unity to come over and do a session for Flash developers. My talk will be about using best of both worlds and how to interact between the two. Unity for 3D content and Flash elements for 2D content. I have some very interesting cases in mind, which I’ll work out in the next two weeks and present at my session.

John Grden from the Papervision3D team will host another session, as well as Mauricio Longoni who created u3dobject.

So to conclude this and be honest; if this is within your field of interest you just need to be there! So get your tickets today and see you in San Fransisco!

With this book we had the goal to write a book for beginners. A book which we would like to read when we were starting with Papervision3D. Taking nothing for granted and gradually work to more advanced topics. Hopefully we have achieved that goal, which will become clear once the copies are sold and we will get feedback from our readers. Now the book is on sale we can finally get feedback from more people other than the very valuable reviewers Trevor Burton, Stuart Caunt and Patrick Rushton.

The book covers many topics in detail, which results to that the book could be used as a reference guide. More than once I’ve looked back to the chapters that we’ve written and see how things work. We have chapters dedicated to the following topics:

• Setting up
• Building your first application
• Primitives
• Materials
• Cameras
• Moving things around
• Shading
• External models
• Z-sorting
• Particles
• Filters and effects
• 3D Vector drawing and text
• Optimizing performance

Together with releasing this book, our publisher posted an example chapter on their website. Which is chapter 8 about modeling. I think this chapter gives a good impression on how thouroughly we tried to explain certain topics.

More information about the topics of our book can be found on the website of our publisher. Make sure you’ll check out:

• Table of contents
• 3D Vector Drawing and Text with Papervision3D: Part 1
• 3D Vector Drawing and Text with Papervision3D: Part 2 

In the next couple of weeks you can expect some articles here on my blog about subjects that have not made it to the book. So keep an eye on this blog.

But for now, I’m going to enjoy my vacation first and I want to say a big THANK YOU!, to those who have supported us during the writing. Our reviewers Trevor, Patrick and Stuart. The Flash community for posting valuable articles and last but not least the Papervision3D team for their help and answers while writing the book.

I’m very delighted to finally announce that I have been working on the first Papervision3D book that will be released ever. The book is in cooperation with my good friend and co-author Jeff Winder and will be published by Packt Publishing. Since the beginning of this year we have been working extremely hard on the writing of this book. We are ready with the writing of all chapters and are preparing all final drafts right now. So you can expect this book to be published really soon.

The result of our hard work is that we have a book that will be useful for both experienced as non-experienced Papervision3D users. The first few chapters take no knowledge for granted and guides the reader through all steps for getting started with Papervision3D. It describes how to get Flash CS3, Flash CS4, Flex Builder and Flash Builder correctly configured for running Papervision3D code. This includes downloading Papervision3D (SWC, ZIP and a step-by-step guide for downloading from SVN). Once an example project has been compiled, a short introduction to OOP and classes is given for those who have no experience in this. From there the reader book gradually works through more advanced topics, such as loading external models, shading, z-sorting, viewport layers, particles, filters and effects, vector drawing and performance optimizations.

As the book contains much information on a variety of topics it is also interesting for those who already have experience in Papervision3D, but want to extend their knowledge and understanding. It was not aimed to be a reference guide, however it turns out that many topics are thoroughly described and can be used for this purpose as well. (I personally already did this while working on commercial projects that make use of Papervision3D)

Today the book has been announced on the website of our publisher, Packt Publishing and will soon be announced on other websites, like Amazon for example. For both Jeff and myself this is the first book we have ever written. Seeing our book and names listed is already very exciting.

We can’t wait to have our book finished and hold the final copy in our hands. We did our best (and still do) to make this a very good book and we are looking forward to hear responses from our readers.  But for now we will continue writing on the last bits. Once there’s more news about the exact release date I will post it here on my blog.

[Update 2009-07-29] Papervision3D Essentials – Now listed on Amazon

Last Thursday a new campaign for Volkswagen went live, which makes use of mobile streaming. I did some work for this in cooperation with Achtung!, before looking at what I developed for this campaign let me first give a nutshell introduction.

A new Volkswagen Polo is driving around in the Netherlands. When you see the car passing by, you can wave at the car, so the current driver has to stop and the new driver can continue the ride. Each day winner who drove the longest distance gets a ticket for the finale that takes place after the campaign. The one who wins the finale will win the car.

Visitors of the website www.pakdepolo.nl can see where the car is at this moment through several video streams and live GPS. You can leave your zip code on the website in to vote for your neighborhood, which could result in sending the car in that direction. The car is equipped with an custom written navigation system making use of Google maps and is in connection with the website. New routes can be pushed to the car. It is also possible to leave your mobile phone number or e-mail, in order to get a warning when the car is will cross your neighborhood.
I was asked to equip the car with all the technical stuff, as I have quite some experience with mobile streaming and equipping cars with it.

I had to:

• Recreate and assemble the camera system.
• Set up streaming to a Wowza server.
• Real-time push GPS positions from the car to all clients over a RTMP (Red5) connection
• Track distance per driver. (This was a real hassle, as the GPS devices which I’ve used gave unreliable positions once in a while)
• Create a LED display showing a driven distance per driver. (This was custom made. A Phidget has been used as the interface between a laptop and the LED display).
• Set up a local in-car network to set up a remote desktop between the laptop in front of the car, with laptops in the trunk.
• Custom build all hardware in the car.

The following images show some parts of my work:

It was a lot of fun to create all this. It was also a pleasure to work with Achtung! and their very talented creative developer Patrick Pietens who did the front-end. The fun continues now the campaign is started and you can see who “hijacks” the car at this moment.
Take a look yourself at www.pakdepolo.nl

Update July 21st: There is also an English version of the website available www.pakdepolo.nl/en/