Look what I’ve found on my hard drive – AI battle simulator! This was AS2 ExternalInterface-powered thing, that allowed anyone to program blue and teal balls to move around simple maze, pick up green balls and throw into each other. Unfortunately, only three people actually wrote scripts for this thing.

Today, I ported it in AS3 and made it load SWFs that contain “bot” code, instead of relying on JavaScript. Thanks to wonderfl, however, you can still program “bots” in the browser. The sad fact is, wonderfl is the only flash community in the world where experiments like this can prompt any interest, so naturally I am taking it there.

The rules are simple: write an SWF having behavior() method in its main class, battle script will load your SWF and call this method every frame. It will set these input variables:

• inColors and inDistances – arrays of 36 numbers representing things your “bot” can see at 10 degrees intervals: colors are 0 for wall, 1 for enemy, 2 for bullets and 3 for bullets heading your way, distances are in pixels;
• inHasBullet is Boolean value indicating that you have a bullet;
• inMaxSpeed is max speed that you can move at;

In behavior() method you set following output variables:

• outMoveSpeed – how fast you want to go;
• outMoveAngle – where you want to go (a number from 0 to 35);
• outThrowBullet – Boolean value indicating that you want to throw bullet (if you have one);
• outThrowAngle defines the target direction.

I will soon post to wonderfl all three codes submitted back in 2007.

This is basically proof-of-concept that this is already possible in flash, today. What you do is take saqoosha’s FLARToolKit, add keno’s QR code reader, and load results into 3d engine (in this case, kiroukou’s sandy).

It doesn’t require webcam, just click to upload your test image. It also makes use of saqoosha’s PixelBender homography transform filter, since keno’s reader apparently doesn’t do that on its own (and generally is very sensitive to input bitmap, I must add). Default image comes from here.

Those of you who still watch sandy engine, know that there is pending maintenance release with almost no new features (unless they finally backport MD2+MD3 support from haXe branch). However, sometimes new features do get added; for example… BSP sorting in single container mode.

Ever since Thomas added Renderer class a year ago it was possible to implement dynamic BSP sorting for whole scene (just like Infinity3D did), but noone working on sandy seem to have time or skills, and this never happened. On the other hand, an opportunity to implement simpler static BSP sorting existed ever since single container mode was introduced (which was, I believe, well over two years ago). As some people noticed, I did just that this weekend, in a matter of hours. Check it out – here. On the left, you can see good old average Z sorting, on the right – BSP. Well, if that was so easy, why noone did it for “over two years”, huh?

Of course. There is a catch. This code does not modify geometry at all, no polygons are split and no complicated geometry analysis is done. Why? Simply because sandy is not friendly enough to do this within maintenace relese. You might remember that sandy was first 3D engine to implement frustum clipping; this algorithm already provides us with all the means to split face by plane (remember this), but you can store just one result of this operation per face (when we need many of them obviously) or, alternatively, you have to modify underlying geometry itself. The latter option would not be that bad, if not for the magnitude of hack it takes to get it done. I tried it last January and gave up on that, but for the purpose of this post I have done this PoC. Just so you know that I am not talking entirely out of my ass.

Okay, so here comes the million dollars question: who the hell needs BSP that does not split polygons? I don’t know, probably poor people with no cash for Alternativa3D license :) It is true that new BSP sorting mode will not display your model correctly, unless it is carefully designed to work in this mode. It is exactly the same way it was before, when you had to carefully design your models to work in average Z sorting mode. In this demo above, click anywhere to display models ”optimized” for corresponding sorting modes, to see what am I talking about. On the bright side, BSP feature will be open for scripting, so that anyone can write BSP importer from GtkRadiant, or clever Blender script to help modellers.

Yes! After 2 months of playing with Alternativa3D 7.0 WIP version I’ve finally got NDA exception to share my experience with you. And there you go, some juicy details to whet your appetite.

What’s new?

Perhaps the most important change from 5.x versions is a number of object container classes. If you have seen this post from February, you should already know that Alternativa3D 7.0 will support good old average Z sorting in addition to BSP. What you probably don’t know is that there’s much more to that – apart from 3 sorting options (unsorted, average Z and BSP) on mesh level, there are 5 more sorting options on container level! With this kind of arsenal you can probably solve any kind of sorting problem in existence, or vastly improve performance if you do not have any sorting problems to begin with. And this is not the end of the story – I was told that sorting issue is still in focus of ongoing Alternativa3D development. To sum this point up, this engine is going to seriously kick some ass -)

All right, but it is not all about sorting, is it? Of course it’s not. The other important feature that somehow have not been demo-ed anywhere is Reference class. That’s right, Object3D.clone() is gone. As the name implies, Reference will cause referenced object (or container) rendered in its place using its alpha, blending mode, color transformation and filters. This is very simple idea that can save you lots of memory wasted with other engines. It has been around for years but, until now, nobody in flash 3D scene bothered to actually implement it.

Wait, did I just said, “its alpha, blending mode, color transformation and filters”? Weren’t alpha and blending mode in Material class? Yes, they were. However, in Alternativa3D 7.0 there is no any Material class. Instead, Mesh and Sprite3D classes now simply have BitmapData ”texture” property, and all of you who want some fancy materials will have to extend these classes or design Pixel Bender filters and hook them via ”filters” property. Yep, so much for materials.

Next in list of awesome features is LOD support. Yes, finally Alternativa3D has it too. Yes, you have seen it here. But I just had to mention it, because it’s awesome. With LOD, you can create really huge scenes, that would not be otherwise possible due to flash CPU throttling. In this regard, a combination of LOD and Reference is interesting subject to explore. For example, this little demo below is actually made of just one 5K 3DS model with ~100 triangles, 4 planes and 1 box. The rest is smoke and mirrors LOD and Reference at work.

This demo also demonstrates how several sorting algorithms work together in one scene (as if this wasn’t enouh). Press space to see new debug features at work: at the moment, you can display bounding boxes, edges, vertices or normals for individual objects or any instances of certain class, and this list is growing.

There’s more features to cover, but this post is already getting long - maybe next time ;)

So when will this awesome engine be actually released?

That’s a good question. Official ETAs are useless, they just keep postponing it again and again, working on Tanki game updates instead. My personal feeling is that perhaps 80% of engine are complete atm. With all these advanced features, the engine lacks some basic and familiar stuff like .x or .rotationY properties, and you have to manually modify transformation matrices (да, да, русские программисты настолько суровы, что работают с матрицами напрямую). Also, documentation is pretty poor so far. My bet is that we will not see this engine released this fall (if not this year).

Some of you might already know the news, but: there is another commercial 3D engine from Russia, called Infinity3D. This engine licensing policy and API are very similar to those of Alternativa3D 5.x, so natural question is, how is it different? Well, one thing where the engines are different is their approach to sorting: in Infinity3D, sorting is done by renderer classes (much like in Away3D, for example). So, unlike Alternativa3D, Infinity3D does not build BSP tree for whole scene at once, but instead re-builds it for all objects visible on screen all the time. The question is, therefore, how does this difference affect actual performance? Both engine blogs had previously published “dynamic BSP” demos (here and here), but those were of little use for any meaningful comparison… until yesterday, when Infinity3D released this new demo:

With this demo, it is finally possible to verify two performance claims made by Infinity3D author, namely:

1. Infinity3D BSP performance for dynamic scenes is better;
2. Infinity3D BSP performance for static scenes is not worse.

For this purpose, I have made similar Alternativa3D demo using their latest released version. Controls are alternativa’s default W/A/S/D/Z/Space, mouse drag and Enter to toggle animation (note: fps counter insists on going off-stage for some reason, so make sure your browser window width is around 800 pixels).

To test claim 1, you just need to make sure animation is on, and whole scene is in view. I have low-end machine, so results are very unambiguous in this case: 10-12 fps for Infinity3D vs 3-4 fps for Alternativa3D. That’s 3 times faster! Resolution: the claim is true.

For the claim 2, it is not that straight-forward: once you stop animation, both demos run at full 60 fps, so you also need to move around constantly. The results in this case are: same 10-12 fps for Infinity3D vs 9-14 fps for Alternativa3D. Resolution: the claim is true.

Congratulations to Romanov Alexey for his great work on Infinity3D, and looking forward for 1.4 release.

Until v5.6 is out, at least, we have no means to make real skybox in Alternativa3D. We can fake it by placing very large static box around our scene. The problem with this solution is that there are many ways to unwrap the box and, correspondingly, there are many incompatible skybox textures. Changing box UVs by hand every time you replace skybox texture in your project is getting boring at some point, and when they want you to support multiple textures originating from all kinds of different sources, it gets nearly impossible. And then you write this thing:

What we have here is three incompatible cubic panoramas loaded with the same SkyBox class. Additionally, there is simple class loading textures in background that may come in handy to some. Check out full source, if you wish.

As cool as it is, adaptive thresholding generates too much redundant data. The only alternative implemented before seems to be the method called automatic thresholding, suggested by ARToolKitPlus folks:

ARToolKitPlus can do dynamic thresholding by looking at the marker content (pattern) and taking the average between the darkest and brightest pixels. If no marker is found the threshold value is randomized.

From this description alone, it is clear that there will be frames with marker undetected even though it is clearly visible in the image, so I thought, until now, that this method has to be quite bad. It turns out, however, that this method actually works very well and the number of lost frames is very small. In practice, you don’t even have to find pixel values range, it suffices to assume that current good threshold value lies close to last known one.

On code side, you no longer need to write or import some fancy filter classes, all you have to do is to modify your fixed thresholding main loop just a bit:

private var threshold:Number = 0.5;
private var confidence:Number = 0, confidenceThreshold:Number = 0.5;
private function onEnterFrame (e:Event):void {
	videoSnapshot.draw (video);

	if (confidence < confidenceThreshold) {
		// randomize threshold
		threshold *= 0.8;
		threshold += 0.2 * Math.random ();
	}

	confidence = 0;
	if (detector.detectMarkerLite (raster, 255 * threshold)) {
		confidence = detector.getConfidence ();

		detector.getTransformMatrix (result);
		stuff.setTransformMatrix (result);
	}

	scene.render ();
}

If you’re sandy fan, you can play with this method using this stub code.

It’s long time no post now, so I thought why not post something :) So, here goes this little augmented reality experiment. Let me warn you first, it is not impressive at all, nothing fancy on 3D side, and tracking – to be fair – sucks. This is in part because it does not use any solid technology such as FLARToolKit, just something hastily hacked in haXe, for a change. In other part, it uses very simple fixed threshold filter, that can (and does) harm tracking. To save me some typing, I have made this short video explaining what this experiment is about:

If you have seen how bad it is in the video, but still want to play with it, here you go. The code uses slightly modified blob detection code by Tomek and sandy for 3D part. Make sure you have a webcam, piece of paper, and red, green and blue marken pens.

For those who asked about sources of my little experiment from last week, here they are. Make sure you are using FLARToolKit revision 2570 with these.

If you wasnt reading FLARToolKit mailing list, here is short summary: FLARToolKit converts color image to ”binary” image before doing any magic on it, using fixed threshold filter. In fact, this threshold is simply hard-coded to be 80 in many examples, and you will need to write more code to detect good values for threshold if you want your application to run regardless of lighting settings. The filter in this experiment avoids the problem by using local average brightness as a threshold for every pixel; the downside is that it enables FLARToolKit to “see” far more details, thus wasting even more CPU time. As a work-around, I tried to narrow down search area in the image using last detected square, but this only helps when marker motion is limited.

Well, check it out, play with it, and let me know what you think.

Shortly after FLARToolkit was married to Sandy, I arranged it a secret date with Alternativa3D. The date was quite fruitful, and in a week this baby was born:

This is modified ”Ballance” game released by Alternativa3D team in november, with FLARToolkit used to control camera instead of mouse. Unfortunately, due to GPL2 section 2 clause B I cannot distribute stuff including both FLARToolkit and Alternativa3D for free, so no SWF for you to play with atm, sorry. But, if anyone is interested in sponsorship to enable this thing to go online, contact me.

On the technical side (aka “how the hell was it done”), bad news are that neither object transformation matrix nor camera projection matrix cannot be directly set in Alternativa3D, so we have to resort to mind-f@#king tricks to get it working, and the result is only approximate match. Good news are that this approximation is, obviously, good enough and useable. An example of what has to be done to make it work can be found here (I believe my single AS file does not contain FLARToolkit, and so I can distribute it, under whatever license I want).