Our application is called "funanbulle". The goal of the application is to allow families to create their own micro virtual world and gather. We wanted to show what such virtual worlds would look like. The idea was to enable people to share and chat in real time with a fun and engaging user experience.

funanbulle, Aerys' #air24h challenge contribution

The application is nothing more than a proof of concept. If we had enough time, we would have added lots of feature like:

• Audio chat
• Photos and videos sharing
• Interactive objects to trigger applications (games, sharing applications, etc...)

In the end, we had just enough time to build a 3D chat. But I think it was a lot of fun and it looks really nice! Here is a quick video to show what funanbulle is about and how it works:

This video was made by Michael Chaize to show the 14 applications created during the contest.

To install the application, just click on the following picture to go to the install badge:

When the application starts, you will be asked to "join" or "create" a room:

• If you don't have a room number: select "create a room" to create a new room. When the room is created, you'll join in automatically join it. The room number will be visible in the top right corner. You can share it with your friends and family to enable them joining your room.
• If you have a room number (because a friend already created a room and gave you its number for example): select "join a room", type your room number and click "Go". And voilà!

You can use the bottom text input to chat with your friends. But you can also launch special actions by typping one of the following commands:

• /jump
• /wait
• /sit
• /use
• /wave

We hope you'll like it and have fun with it!

You can download it from the Adobe website: http://get.adobe.com/fr/flashplayer/.

In the meantime, we need you! YES, YOU! Our team needs supporters, and you can help up by simply clicking on the above picture or here. You will then be asked to log into your Facebook account to show just how much you love us and you want us to win!

Thank you all for your help. I just want you to know we are setting up for a great show!

In this post I will:

• Explain how any 3D scene is built when using Minko
• Explain how pixel shaders are integrated in the 3D scene
• Explain how pixel shaders are built using Pixel Bender
• Show you a very simple demo of the kind of effects pixel shaders will provide
• Explain how the demo was built

Here are a two screenshots to show the results:

Phong shading + spheric environment mapping on a 2700+ polygons Lamborghini

Phong shading + spheric environment mapping demo

The Scene Graph API

This API is used to build and manage the 3D scene. Scene graph is the most common data-structure used to build 3D scenes. It is simple to understand and both memory wise and CPU efficient. To explain what the scene graph is, start thinking about Flash's display list. In ActionScript 3.0, the display list is actually a tree. The root of the tree is the Stage and you can add multiple children to it. Each child can be a leaf, such as a Bitmap object, or a container such as a Sprite. One of the limitations of a tree is that every node can have multiple children but each child can have only one parent. This property is what makes it look like a tree: branches (and leaves for that matter...) have only one parent branch.

A direct consequence of that paradigm is that if you want 20 red circles, you will have to create 20 red circles and add them to the display tree. Despite the fact that those 20 red circles will be exactly the same you will still have to create and add all of them to the display tree. Thus, you will use 19 times more memory than what is actually needed. That's where the graph kicks in...

A graph is just like a tree except every node can have multiple parents. You can see graphs as a generalization of trees. But you can also say that trees are particular graphs where each node can have only one parent. Anyway, we can now create one red circle and use it as many times as we need! To understand how this apply to a 3D scene, lets consider the following rendering:

And here is the corresponding scene graph:

There are five things to notice:

1. The figure doesn't show the whole graph (I removed the camera and materials).
2. The Scene Graph API is all about interfaces. You can add new features to the API and still extend the classes you need/want (ie. EventDispatcher).
3. The CubeMesh.cubeMesh, SquareMesh.squareMesh and SphereMesh.sphereMesh nodes, which contain the primitives geometry, exist only once each but are used by many IDisplayObject3D. Therefore there is no useless memory consumption! The same can be done with any node in the graph: containers, display objects, materials, etc...
4. The orange circled nodes apply a (3D) transformation to their children, just like Flash containers apply (2D) transformations to their own children.
5. Z-Sorting is here enabled by two different technics: the drawing order (which is pretty much the same as in a classic-2D-Flash display tree) and the DepthSortContainer3D node. This node takes care of z-sorting by sorting its children using their average depth. This way, z-sorting occurs only when needed and only on relevant geometry.

There a lot to explain about the Scene Graph API! But the main point is to understand how it compares to Flash's display tree and what benefits it provides: lower memory consumption and powerful scene building. You are likely to need to find a way to fit in the Scene Graph API anytime you want to extend Minko to add a new feature. In this precise case I will talk about how pixel shaders fits in.

Pixel shader integration

The first step is to find "where" in the graph your new feature will be used. Close to the scene "root" you will more likely find containers. And the "leaves" are often more tangible objects such as a materials or meshes. A pixel shader is some kind of a material so that's where we should start looking!

In the Scene Graph API, there is a special way to handle materials: the "material stack". It's a part of the graph - a subgraph really - that looks very much like a stack because every node uses an "underlaying" material node. Lets consider the orange box from the previous example:

This figure shows the orange cube subgraph. On this graph I added the material nodes to demonstrate how the material stack works. In this precise case, the stack is made of a WireframeMaterial node and a SolidMaterial node. The first one provides a wireframe rendering and the second one is a solid fill. When rendering, the resulting graphics operations will be the list of all the graphics instructions outputed by each node of the stack. Thus, we will here obtain an (orange) solid fill with a (purple) wireframe. So where does the pixel shader fits in the material stack? Well you might have noticed there are two different kinds of nodes in the material stack:

1. the bottom of the stack is more likely to be a "base material", like a solid fill or a texture
2. and the rest of the stack will be mainly "modifiers". In the case of the orange cube, the WireframeMaterial node acts as a modifier for the SolidMaterial node

Our pixel shader material will be a modifier because it will work on an underlaying texture. Now we know our pixel shader material should be on the top of the material stack we have to know what data it needs and how to provide it!

Pixel shader creation using Pixel Bender

A pixel shader works at the pixel level (true story). Therefore, we need per-pixel data. But because we use Flash's drawing API we don't have a direct access to the actual pixels (I'm oversimplifying but that's the idea). The trick is to work on the material BitmapData itself rather than the screen pixels. Thus, I will now talk about "texels" (texture pixels) rather than pixels (so I guess it should be called a "texel shader" then...). Anyway, our shader will then most certainly always need three inputs:

1. The color of each texel, also called a "diffuse map" or... a texture. Any material will do the trick (we can get a BitmapData out of any material).
2. The position of each texel, also called a "position map".
3. The normal of each texel, also called a "normal map".

The position map will be generated at runtime. It is mainly a BitmapData where each pixel stores the (x, y, z) values of the position of the corresponding texel instead of an (r, g, b) color value. The normal map can be generated at runtime. It can also be any material as long as it provides a relevant BitmapData. This BitmapData stores the (nx, ny, nz) values of the normal of the corresponding texel. Here is an example:

In this example both the normal and the position maps have been generated using Minko's NormalMap and PositionMap classes. This picture is actually a screenshot of a demo Flash application. I wont talk too much about this generation step for now, but its done using Pixel Bender and its lighting fast!

In order to make this data available to any pixel shader, the diffuse, normal and position maps are stored in a one-and-only scene graph node: the PixelMaterial. This node will then provide per-texel data access to its modifiers. We can now implement a real pixel shader on top of any PixelMaterial! Everything we need now is a Pixel Bender kernel that takes our 3 maps (diffuse, position and normal) in input.

The following Pixel Bender filter performs Phong shading:

void
evaluatePixel()
{
        float2 o = outCoord();
        float3 position = sampleNearest(positionMap, o);
        float3 normal = sampleNearest(normalMap, o) * 2. - ONE;
        float3 light = normalize(light - position);
 
        // ambient
        float l = ambient * intensity;
 
        // diffuse
        l += max(0., dot(light, normal)) * diffuse * intensity;
 
        dst = sampleNearest(diffuseMap, o) * float4(l, l, l, 1.);
}

As you can see its really straight forward. This is due to the Scene Graph API which makes it possible to do every computation in local space. Therefore we don't have to care about where those computations happen in the 3D scene.

Demo

Phong shading or reflection mapping are great examples of pixel shaders. The following demo uses both (the white diamond stands for the light source):

Phong shading + spheric environment mapping demo

Phong shading + spheric environment mapping scene graph

And to put it in a nutshell, a few performances considerations:

• Everything is done in real time.
• Thanks to the Scene Graph API, every computation is done in local space. It avoids matrix multiplications by the thousand and gives a significant performance boost.
• The application takes less than 20Mb of memory and weights less than 100Kb.
• There are a total of 6 pixel shaders run at each frame (only the visible faces materials are computed and there are 2 shaders per face).
• Those shaders work on 128*128 pixels diffuse/normal/position maps
• That's a total of 98,304 pixels per frame
• Each frame is "processed" in an average of 10ms. (Core2 Duo U9400 @ 1.4Ghz, Flash 10.1 RC7, Chrome 5)
• That's 9,830,400 pixels per second!
• There is a ~30% performance boost with Flash 10.1 RC7
• The number of triangles does not impact the performances
• Do not hesitate to post your own results (with your configuration of course)!

]]> http://blog.promethe.net/2010/06/09/pixel-shader-demo-using-flash-10-pixel-bender-and-minko/feed/ 11 http://blog.promethe.net/2010/06/04/aerys-joins-the-24h-adobe-air-challenge/?utm_source=rss&utm_medium=rss&utm_campaign=aerys-joins-the-24h-adobe-air-challenge http://blog.promethe.net/2010/06/04/aerys-joins-the-24h-adobe-air-challenge/#comments Fri, 04 Jun 2010 11:42:25 +0000 Promethe http://blog.promethe.net/?p=751

The 24H Adobe AIR Challenge is a 24 hours long contest that will take place the 18th of June in Paris, France.

During this coding challenge, 15 teams of two people will have to build the best AIR application regarding a precise subject. This very subject will be unveiled as the competition starts.

The challenge will be broadcasted live from http://www.adobeairchallenge.com/.

Aerys is very proud to join the competition and we hope to see you there!

And here are a few useful links (in French) :

• Code Moi Un Mouton - Candidat pour 24h de coding ?
• Official 24H Adobe AIR Challenge twitter

This video was shot the 23rd of March by the people from BAAO. A very big thank you to Yann Chevalier, who's leading the TTFX effort, Michael Chaize, our awesome french Flash platform evangelist and Olivier from BAAO who gave me the link to the video.

You can find the slides here.

"We look forward to delivering Flash Player 10.1 for Android smartphones as a public preview at Google I/O in May, and then a general release in June. From that point on, an ever increasing number and variety of powerful, Flash-enabled devices will be arriving which we hope will provide a great landscape of choice."

You can read is full post here : Moving Forward.

From what I'e heard from Adobe so far, Flash 10.1 for the desktop should be released before the Android version. Meaning we can expect Flash 10.1 desktop to be released in May...

Update: In the following Wall Street Journal interview, Shantanu Narayen - Adobe's CEO - also comments Steve Jobs declarations and says Flash 10.1 will be released June 17th (3'10):

http://labs.adobe.com/downloads/flashplayer10.html

Anyway, as the whole HTML5 versus Flash battle is raging, it appears Flash relatively poor performances are indeed criticizable at best. Beside poor developers, the Flash Platform suffers from a very very slow software renderer. Or at least much slower than the rest of the platform. It's no secret: hardware acceleration is a key feature for the future of the Flash Player. It's even hard to believe it is not available yet!

As you must already know, Flash 10.1 will support OpenGL ES 2 on mobile devices to leverage the lack of CPU horsepower. While hardware HD video decoding will be available on the desktop too, the drawing API will only be accelerated on mobile devices.

Anyone knowing a bit about OpenGL ES knows it is a subset of OpenGL. Thus if it works with OpenGL ES, it should work with OpenGL. With this in mind, a few questions:

1. Why isn't Flash 10.1 drawing API hardware accelerated on any OpenGL capable platform, including the desktop?
2. How will it work?
3. Will Pixel Bender be hardware accelerated?

1. Hardware Accelerated Desktop Flash Player

Let's face it: there must be an hardware accelerated desktop Flash Player in the works. As I said previously, OpenGL supports all features of OpenGL ES so this is not far fetched at all. Yet, it is neither released nor announced. Why?

My first guess is OpenGL provides with a lot of features that would make the desktop experience a lot smoother than just using what offers its little brother OpenGL ES. So at some point Adobe had to make a choice :

• release a fully hardware accelerated Flash 10.1 on both mobile and desktop platforms, with the last one being very far from what desktop hardware is actually capable to handle
• or release Flash 10.1 focusing on mobile devices and announce hardware acceleration for the desktop just after its the final release... and I'm guessing it might be a key feature of Flash 11

When I was at the French Flash User Group (TTFX - les TonTons FleXeurs) a few months ago, I spoke with Lee Brimelow and Mike Chambers about the just announced microphone raw-data access. I asked them why it was announced only for AIR 2.0 and not Flash 10.1. The answer was something about the "quality guys" making sure the feature was well suited on both the roadmap and the logic of the incoming updates. And this feature eventually made its way into the Flash Player! I think that's what is happening with hardware acceleration on the desktop.

But if you don't believe me, you don't have to take my word for it! What about Adobe's word? Cnuuja, one of the engineer working on the Flash Player, posted this very message on the Flash 10.1 Forum:

Can OpenGL 3.3/4.0 improve Flash 10.x ?

"Yes....  with a lot of work.   We have spent the last year writing new code which allows OpenGLES2 to render flash content on mobile devices.  Performance varies significantly from one gpu to the next, with some gpus being slower than the software renderer.   What Flash does is significantly different from the 3d triangles+shaders GPUs were designed to support. Its a lot of work to make OGL/D3D usable as our renderer, but we're working on it 

-chris"

2. How will it work?

Just like in Flash 10.1 for mobile devices. But much faster thanks to OpenGL and Direct3D.

The internals of such feature is very important: developers must know and understand how it works to make the best out of it. Adobe already talked about how the drawing API is accelerated in Flash 10.1 on mobile devices:

"When a GPU renders vector graphics, it breaks them up into meshes made of small triangles before drawing them, a process called tesselating. There is a small cost to doing this, which increases as the complexity of the shape increases. To minimize performance impact, avoid morph shapes, which must be retesselated on every frame."

It's straight forward and I think it's actually the best (and only...) way to do it. Tesselation will create triangles by computing sets of vertices/indices (also called Vertex and Index Buffers) and push them to the graphics hardware. The end of the quote suggests such data is cached and should not be recomputed if no redraw occurs.

Something very important though: z-sorting. People might think hardware acceleration implies z-sorting. But it doesn't. When you know how 3D hardware and APIs work, you know it will be very tricky to make it work with something as general purpose as Flash. If Adobe wants to use the z-buffer, they will have to cut the compatibility with the software renderer. And I don't think this will happen anytime soon.

3. Hardware Accelerated Pixel Bender

Pixel Bender is already hardware accelerated pretty much everywhere except the Flash Platform. I'm not sure why. Still, it's hardware accelerated in other products of the Creative Suite so I guess that an OpenGL/Direct3D shader languages compliant intermediate represenation of Pixel Bender kernels does exist.

This said, it's just a matter of how to make it work with the very general purpose Flash Player. Considering Flash 10.1 is using tesselation, my guess is pixel shader should follow quite easily.