More or less a note-to-self, this is how you configure a texture node in Cycles (I couldn’t really find this anywhere):

which results in:

When the context is lost, all the textures are deleted from memory. This is not something Rajawali inflicts upon you. This is the way OpenGL ES on Android works. So you always have to re-create your textures in the onSurfaceCreated() method.

Object instantiation however is something that needs to be done only once. So in onSurfaceCreated you could use the following code (make sure you set mClearChildren to false):

@Override
public void onSurfaceCreated(GL10 gl, EGLConfig config) {
	mClearChildren = false;

	if(sceneInitialized == false) {
		mLight= new DirectionalLight();
		mLight.setPosition(3, 5, -3);

		mSphere =  = new Sphere(1, 24, 24);
		mSphere.addLight(mLight);
		addChild(mSphere);
	}
	SimpleMaterial simple = new SimpleMaterial();
	mSphere.setMaterial(simple);
	Bitmap texture = BitmapFactory.decodeResource(mContext.getResources(), R.drawable.mytexture);
	mSphere.addTexture(mTextureManager.addTexture(texture));
}

This speeds things up significantly when the context has to be re-created, especially when you use large models.

There’s another optimisation you can use when large models are involved. It’s called serialization. This prevents you from having to load a .obj file and parse it every time the application starts up. It basically writes all the relevant data (vertices, indices, normal, texture coordinates and colors) to a binary file on disk.

So the .obj file has to be loaded only once during development. Once the file has loaded you can save it to the sdcard.
In order to do this you first have to set the permission in AndroidManifest.xml:

<uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE"/>

Then the .obj model can be loaded in and turned into a serialized file:

FileOutputStream fos;
try {
	// GET SDCARD PATH
	File sdcardStorage = Environment.getExternalStorageDirectory();
	String sdcardPath = sdcardStorage.getParent() + java.io.File.separator + sdcardStorage.getName();

    // CREATE A NEW FILE TO WRITE THE DATA TO
	File f = new File( sdcardPath+File.separator + "my_serialized_model.ser");
	fos = new FileOutputStream(f);
	ObjectOutputStream os = new ObjectOutputStream(fos);

	// GET THE .OBJ FILE AND PARSE IT
	ObjParser parser = new ObjParser(mContext.getResources(), mTextureManager, R.raw.my_model_obj);
	parser.parse();

	// WRITE THE OBJECT TO DISK USING BaseObject3D's toSerializedObject3D() METHOD
	os.writeObject(parser.getParsedObject().getChildByName("MyModelObjectName").toSerializedObject3D());
	os.close();
} catch (Exception e) {
	e.printStackTrace();
}

When this is done the code and the .obj file can be discarded. The serialized file is written to the sd card and should be copied into to your resources folder (res/raw). The serialized model is now ready to be loaded into your application:

try {
	ObjectInputStream ois;
	ois = new ObjectInputStream(mContext.getResources().openRawResource(R.raw.my_serialized_model));
	mMyModel = new BaseObject3D((SerializedObject3D)ois.readObject());
	addChild(mMyModel);
	ois.close();
} catch (Exception e) {
	e.printStackTrace();
}

WIN!

• Rajawali Tutorial 1: Basic Setup & a Sphere
• Rajawali Tutorial 2: Creating a live wallpaper and importing a model

Alright. Let’s create some materials

Simple Material

A basic material is just a color or a texture without any lighting enabled. This renders a green cube:

SimpleMaterial simple = new SimpleMaterial();
mCube.setMaterial(simple);
mCube.setColor(0xff009900);

This renders a textured cube:

SimpleMaterial simple = new SimpleMaterial();
mCube.setMaterial(simple);
Bitmap texture = BitmapFactory.decodeResource(mContext.getResources(), R.drawable.mytexture);
mCube.addTexture(mTextureManager.addTexture(texture));

Gouraud Material

This material can be used in combination with a light. For more info check out this Wikipedia article.

mLight = new DirectionalLight();
mLight.setPosition(0, 5, -3);

GouraudMaterial gouraud = new GouraudMaterial();
gouraud.setSpecularColor(0xffffff00); // yellow
mCube.setMaterial(gouraud);
mCube.setLight(mLight);

Phong Material

Use this material to get nice specular highlights. See this article on Wikipedia.

PhongMaterial phong = new PhongMaterial();
phong.setSpecularColor(0xffffffff); // white
phong.setAmbientcolor(0xffffff00); // yellow
phong.setShininess(0.5f);

mCube.setMaterial(phong);
mCube.setLight(mLight);

Environment map material

This is a reflective material. It requires 6 textures. Check this Wikipedia article for more information.

Bitmap[] textures = new Bitmap[6];

String ns = "com.mynamespace.myapp:drawable/";
String dns = "com.mynamespace.myapp";
String prefix = "";

textures[0] = BitmapFactory.decodeResource(mContext.getResources(), mContext.getResources().getIdentifier(ns + prefix + "_posx", null, dns));
textures[1] = BitmapFactory.decodeResource(mContext.getResources(), mContext.getResources().getIdentifier(ns + prefix + "_negx", null, dns));
textures[2] = BitmapFactory.decodeResource(mContext.getResources(), mContext.getResources().getIdentifier(ns + prefix + "_posy", null, dns));
textures[3] = BitmapFactory.decodeResource(mContext.getResources(), mContext.getResources().getIdentifier(ns + prefix + "_negy", null, dns));
textures[4] = BitmapFactory.decodeResource(mContext.getResources(), mContext.getResources().getIdentifier(ns + prefix + "_posz", null, dns));
textures[5] = BitmapFactory.decodeResource(mContext.getResources(), mContext.getResources().getIdentifier(ns + prefix + "_negz", null, dns));

TextureInfo tInfo = mTextureManager.addCubemapTextures(textures);

CubeMapMaterial mat = new CubeMapMaterial();
mat.addTexture(tInfo);
mCube.setMaterial(mat);
DirectionalLight light = new DirectionalLight();
light.setPosition(3, 5, -3);
mCube.setLight(light);

More materials will be added soon. If you have a specific request, just ping me an email

The basics of Android live wallpapers are well documented so I won’t go over that. I suggest you take a look at AndroidManifest.xml, /res/xml/preferencescreen.xml, /res/xml/settings.xml and com.rajawali.tutorials.WallpaperSettings for wallpaper specific stuff.

Here are the specifics for Rajawali.

The RajawaliTutorial2Wallpaper class which extends rajawali.wallpaper.Wallpaper. In this class an instance of the renderer is created and a new WallpaperEngine is returned.
RajawaliTutorial2Renderer is where the fun stuff happens. Here we import an .obj model and apply a texture:

ObjParser parser = new ObjParser(mContext.getResources(), mTextureManager, R.raw.cube);
parser.parse();
mCube = parser.getParsedObject().getChildByName("Cube");
addChild(mCube);

mCamera.setZ(-4.2f);

Bitmap texture = BitmapFactory.decodeResource(mContext.getResources(), R.drawable.cubetexture);
mCube.addTexture(mTextureManager.addTexture(texture));
mCube.setRotation(45, 0, 45);
mCube.setScale(.5f);

startRendering();

Obj files are text files which are compressed in the final .apk file. Parsing the whole obj file can take some time. I’ve added an optimisation which I will cover in the next tutorial (this uses serialized objects and speeds up things significantly).

Continue to Rajawali Tutorial 3: Materials

Create a new project in Eclipse (Right-click in Package Explorer and choose New > Project … Android Project). Use these values in the configuration screen:

• project name: RajawaliTutorial1
• the “Build Target” should be at least “2.2″
• application name: RajawaliTutorial1
• package name: rajawali.tutorials
• create activity: RajawaliTutorial1Activity

Press “Finish”

Hit the download button on https://github.com/MasDennis/Rajawali and extract the contents of the “src” folder into the project’s “src” folder.

Open the RajawaliTutorial1Activity class and change this line:

extends Activity

into

extends RajawaliActivity

Right click on the rajawali.tutorials package in the package explorer and choose “New > Class”. Name the class RajawaliTutorial1Renderer and choose RajawaliRenderer as the Superclass. Hit “Finish”.

Add the constructor and set the frame rate:

public RajawaliTutorial1Renderer(Context context) {
	super(context);
	setFrameRate(30);
}

Override the onSurfaceCreated() method. This is where we’ll set up our 3D scene.

@Override
public void onSurfaceCreated(GL10 gl, EGLConfig config) {
	super.onSurfaceCreated(gl, config);
}

Add a new class variable called mLight and add the following code to the onSurfaceCreated() method:

mLight = new DirectionalLight(0.1f, 0.2f, -1.0f); // set the direction
mLight.setColor(0, 0, 1.0f);
mLight.setPosition(.5f, 0, -2);

Create a new folder under /res/ called drawable-nodpi and download and save this image.

Next we are going to create a simple sphere and a texture.
First add a class variable called mSphere< of type Sphere and add this code to the onSurfaceCreated() method:

Bitmap bg = BitmapFactory.decodeResource(mContext.getResources(), R.drawable.selera_sari);
mSphere = new Sphere(1, 12, 12);
mSphere.setLight(mLight);
mSphere.addTexture(mTextureManager.addTexture(bg));
addChild(mSphere);

Also add a camera and start rendering:

mCamera.setZ(-4.2f);
startRendering();

The last thing to do is create an instance of this renderer in our main activity. Open the RajawaliTutorial1Activity class and add the mRenderer class variable:

private RajawaliTutorial1Renderer mRenderer;

And finally, change the onCreate() method to:

@Override
public void onCreate(Bundle savedInstanceState) {
	super.onCreate(savedInstanceState);
	mRenderer = new RajawaliTutorial1Renderer(this);
	mRenderer.setSurfaceView(mSurfaceView);
	super.setRenderer(mRenderer);
}

Build and launch and behold the sphere!

Let’s make this a bit less boring and add some animation.
Go back to the RajawaliTutorial1Renderer and override the onDrawFrame() method and add y-axis rotation:

@Override
public void onDrawFrame(GL10 glUnused) {
	super.onDrawFrame(glUnused);
	mSphere.setRotY(mSphere.getRotY() + 1);
}

That’s it. Very basic tutorial here.
If you’re lazy you can download the Eclipse project here.

Go to tutorial 2, “Rajawali Tutorial 2: Creating a live wallpaper and importing a model“.

I’ve been working on this on and off for the last couple of months. It is by no means a fully-featured 3D engine. It has some nice features and I figured I might as well move it to a public repository so other people can use it as well.

The other 3D engine for Android I’ve worked on, Min3D, was based on OpenGL ES 1.1. Rajawali uses OpenGL ES 2.0 which makes a huge difference. 1.1 uses the Fixed Function Pipeline while 2.0 gives us the power of shaders. This means a lot of cool things can be done with vertex transformations and materials.

So what does Rajawali have that Min3D hasn’t?

• easily create live wallpapers
• phong shading
• environment mapping
• a quicker way to load models

On the other hand, Rajawali still misses things such as:

• animation (vertex and bone)
• fog
• object picking
• and many other things

So for now the big plus of Rajawali is the ability to easily create live wallpapers and use some nice materials.

New features will be added soon, depending on how many people are actually interested in this framework. If you want to contribute to this project, you’re more than welcome of course!

I’ll post some tutorials on this blog in the coming weeks. Your feedback is much appreciated.

The name “Rajawali” comes from the Indonesian language. It means “eagle”. It is also the name of a kampung on the island of Banda Neira. Banda Neira is part of the Banda Islands group. Another island from this group is called Pulau Hatta, which used to be called Rozengain. See the connection??

All the files can be found on Github: https://github.com/MasDennis/Rajawali

UPDATE: I’ve posted a few tutorials:

• Rajawali Tutorial 1: Basic Setup & a Sphere
• Rajawali Tutorial 2: Creating a live wallpaper and importing a model
• Rajawali Tutorial 3: Materials

I haven’t done anything with Min3D for while. I know people have logged some bugs on Google Code but I haven’t had the time to look at them yet. Shame on me.

Seeing the awesomeness of OpenGL ES 2.0 and GLSL I’m not sure if I want to keep maintaining Min3D. I might start a new engine from scratch. Then again, Molehill (hardware accelerated 3D Flash) is coming to Android so why bother. Well, we’ll see. I’d love to hear your comments on this.

I did find time to create a new demo that uses the accelerometer to control the camera. It creates a very nice depth effect. Have a look at the video:

Here’s the code. Should explain itself . You can download the Eclipse project archive here.

package com.rozengain.min3d.accelerometer;

import min3d.core.Object3dContainer;
import min3d.core.RendererActivity;
import min3d.objectPrimitives.SkyBox;
import min3d.parser.IParser;
import min3d.parser.Parser;
import min3d.vos.Light;
import min3d.vos.Number3d;
import android.hardware.Sensor;
import android.hardware.SensorEvent;
import android.hardware.SensorEventListener;
import android.hardware.SensorManager;
import android.os.Bundle;

public class Min3DAccelerometerActivity extends RendererActivity implements SensorEventListener {
	private final float FILTERING_FACTOR = .3f;

	private SkyBox mSkyBox;
	private SensorManager mSensorManager;
	private Sensor mAccelerometer;
	private Number3d mAccVals;
	private Object3dContainer mMonster;

	@Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        mSensorManager = (SensorManager) getSystemService(SENSOR_SERVICE);
        mAccelerometer = mSensorManager.getDefaultSensor(Sensor.TYPE_ACCELEROMETER);
        mAccVals = new Number3d();
	}

	public void initScene()
	{
		scene.lights().add(new Light());

		mSkyBox = new SkyBox(5.0f, 2);
		mSkyBox.addTexture(SkyBox.Face.North, 	R.drawable.wood_back, 	"north");
		mSkyBox.addTexture(SkyBox.Face.East, 	R.drawable.wood_right, 	"east");
		mSkyBox.addTexture(SkyBox.Face.South, 	R.drawable.wood_back, 	"south");
		mSkyBox.addTexture(SkyBox.Face.West, 	R.drawable.wood_left, 	"west");
		mSkyBox.addTexture(SkyBox.Face.Up,		R.drawable.ceiling, 	"up");
		mSkyBox.addTexture(SkyBox.Face.Down, 	R.drawable.floor, 		"down");
		mSkyBox.scale().y = 0.8f;
		mSkyBox.scale().z = 2.0f;
		scene.addChild(mSkyBox);

		IParser parser = Parser.createParser(Parser.Type.MAX_3DS,
				getResources(), "com.rozengain.min3d.accelerometer:raw/monster_high", true);
		parser.parse();

		mMonster = parser.getParsedObject();
		mMonster.scale().x = mMonster.scale().y = mMonster.scale().z  = .1f;
		mMonster.position().y = -2.5f;
		mMonster.position().z = -3;
		scene.addChild(mMonster);

		mSensorManager.registerListener(this, mAccelerometer, SensorManager.SENSOR_DELAY_UI);
	}

	@Override
	public void onAccuracyChanged(Sensor sensor, int accuracy) {
		// TODO Auto-generated method stub
	}

	@Override
	public void onSensorChanged(SensorEvent event) {
		if (event.sensor.getType() != Sensor.TYPE_ACCELEROMETER)
            return;

		// low-pass filter to make the movement more stable
		mAccVals.x = (float) (-event.values[1] * FILTERING_FACTOR + mAccVals.x * (1.0 - FILTERING_FACTOR));
		mAccVals.y = (float) (event.values[0] * FILTERING_FACTOR + mAccVals.y * (1.0 - FILTERING_FACTOR));

		scene.camera().position.x = mAccVals.x * .2f;
        scene.camera().position.y = mAccVals.y * .2f;

        scene.camera().target.x = -scene.camera().position.x;
        scene.camera().target.y = -scene.camera().position.y;
	}
}

OSG has a very convenient way of using an optimisation technique called Level of Detail management. Simply said: when an object is far away from the camera a copy of the original object is used with a reduced number of faces. Because the object is far away you don’t need a mesh that is as detailed as the original one. Check the Wikipedia article for a visual explanation.

The mesh simplifier class does all the hard work and is based on the visitor design pattern. The Node is the host that accepts the visitor. The host and the visitor communicate with each other via their public interfaces. This allows us to separate the algorithmic complexity from the data structure. Other visitor classes that can be accepted by a Node are IntersectionVisitor (testing intersections within the scene), CollectOccludersVisitor (cluster culling to cull back facing drawables), ComputeBoundsVisitor, RemoveEmptyNodesVisitor and a lot more.

There are some C++ specifics in this bit of code that might seem a little crazy if you’re used to ActionScript. In native C++ there is no garbage collection, you have to do all that yourself. In OSG there is something called a smart pointer that can help you with this.
Also there is a dynamic_cast. More info on the different types of casting in C++ can be found here.

Here’s the bit of code that does all the magic:

#include <osg/LOD>
#include <osgDB/ReadFile>
#include <osgUtil/Simplifier>
#include <osgViewer/Viewer>

using namespace osg;
using namespace osgDB;
using namespace osgUtil;
using namespace osgViewer;

int main(int argc, char** argv)
{
// load the .osg model
ref_ptr<Node> cowLevel3 = readNodeFile( "cow.osg" );
// clone the model
ref_ptr<Node> cowLevel2 = dynamic_cast<Node*>( cowLevel3->clone( CopyOp::DEEP_COPY_ALL ) );
// make another copy
ref_ptr<Node> cowLevel1 = dynamic_cast<Node*>( cowLevel3->clone( CopyOp::DEEP_COPY_ALL ) );

// create an instance of the mesh simplifier
Simplifier simplifier;
// reduce the number of vertices and faces
simplifier.setSampleRatio( 0.5 );
cowLevel2->accept( simplifier );

// reduce the number of vertices and faces even more

simplifier.setSampleRatio( 0.1 );
// this node should accept the simplifier node visitor
cowLevel3->accept( simplifier );

// create a new level of detail node
ref_ptr<LOD> lodNode = new LOD();
// add the meshes
lodNode->addChild( cowLevel1.get(), 200.0f, FLT_MAX );
lodNode->addChild( cowLevel2.get(), 50.0f, 200.0f );
lodNode->addChild( cowLevel3.get(), 0.0f, 50.0f );

Viewer viewer;
viewer.setSceneData( lodNode.get() );
return viewer.run();
}

Packt Publishing sent me this OpenSceneGraph 3.0 beginner’s guide for review. I have worked with 3D engines like Irrlicht and Ogre but I never had the chance to properly look at OpenSceneGraph. The latter is apparently used a lot in scientific visualisation & simulation while Irrlicht and Ogre are mostly used for games & entertainment.

All these three engines are open source, free to use and target multiple platforms. Irrlicht can use DirectX, OpenGL and software rendering. Ogre uses either OpenGL or DirectX and OpenSceneGraph uses OpenGL exclusively.

I’ve reviewed Packt books before and while all the books have quality content I never liked the print quality and the typesetting. The images look washed out and sometimes it’s a bit hard to see what’s in the image. Hopefully they can improve this in future releases.

But of course, content is king. So what does this beginner’s guide have to offer?

First of all, this is not a guide for people who aren’t familiar with 3D programming. This book assumes you have basic knowledge of 3D concepts, C++, design patterns and OpenGL. This means it’s a beginner’s guide for people unfamiliar with OpenSceneGraph. A good thing because the focus is on the engine itself and not the basics that most readers know anyway.

The approach behind this book is “learn by doing: less theory, more results”. I have to say that the authors (Rui Wang and Xuelei Qian) did a tremendous job. There’s a good balance between theory, code samples and explanation. After the obligatory introduction and compilation & installation chapters they’re diving straight into the code. Basics like memory management, reference pointers and logging are explained and then they move on to building geometry models, managing the scene graph, rendering effects, animation, interaction and storage. The book ends with a very useful chapter about rendering efficiency that deals with multi threading, culling, quad trees and data paging.

By reading this book you really get to know OpenSceneGraph very well. You’ll not only learn about 3D but also about things like smart pointers and design patterns. Some things I really like about OpenSceneGraph are the way you can use polygonal techniques (simplifier, smoothing, tesselator, etc), functors and level-of-detail management. By using the polygon reduction class called “Simplifier” you can auto-generate low-polygon models that you attach to an LOD node. Extremely powerful stuff.

This book is available from Packt Publishing for $31.19/$50.99/€39.75. Highly recommended. https://www.packtpub.com/openscenegraph-3-0-beginners-guide/book

Disclaimer: I’ve kept the session descriptions short. I recommend keeping an eye on the video site on which the session videos will be published.

The rural village of Stechelberg in Switzerland was the setting of the second edition of the gotoAndSki() conference. Skiing in the Alps is always a great experience and combining this with networking, fun and presentations is a terrific concept.
This edition was organized by Fernando Colaço and David Almeida. They chose the picturesque village of Stechelberg as the conference location. Stechelberg is a beautiful little village situated in between the mountains and close to the skiing areas.
After being picked up from Geneva airport by Fernando we headed off to Stechelberg. It was already dark so we didn’t see much of the Swiss alps.
When we arrived at the hotel most of the attendees were already present and quenching their thirst with Swiss beers. After eating röstis and drinking beers we were invited to drink some Polish wodka which Maciek brought with him. It ended up being a very fun night.

The next day we went out to explore the skiing area. It was very quiet on the slopes because it was off-season. The more space the better because I’m a bit of a clumsy skier. I got through the day without breaking anything or hitting someone so this could be considered a very good day.
After a quick nap and shower it was time for the sessions to start.

The conference was kicked off by Adobe’s Mihai Corlan. He talked about building mobile apps with AIR, Flash Builder & Flex hero. He showed off some new features and also showed how you  can use AIR on the Blackberry Playbook. Very interesting session.

The interlude was used to fill our stomachs with quality Swiss food. Fernando had a nice surprise for us because he invited the local yodelling choir to come and sing for us. I was only familiar with the fast-paced eccentric yodelling but this version was much more refined and slower than that. It gave the evening a true Alpine atmosphere.

The second session was done by Peter Maseide. Peter is a Game designer & developer for Agens. He showed us some very nice game examples and he explained which techniques they used to make their games truly engaging. He also announced the release of Fungrid, an open source Flash Game API for 2D/parallax scrolling games. The framework looked very easy to use and flexible. An inspiring session by someone with a lot of passion for game development.

The last session of the evening was done by Mihai Corlan again. This time he talked about optimising Flash & AIR applications. Very handy tips & tricks that are always useful to have in your toolbox. A good ending to a great night.

The second day we went to the skiing area on the other side of the mountains. We had a pretty intense day of skiing because we were trying to keep up with Maciek, the human cannonball who disregards human life. Ricardo suffered especially because he never had an intense skiing session like this. But he managed to stay on his feet until the very last end. Respect! The day ended with me being in a rush to get in time for my session, running out of the restaurant and forgetting to pay for my beer (thanks guys for paying for that one ). Although I ran to the bus stop to be on time I ended up in the same bus as them. Pretty useless exercise.

After the quickest shower ever it was time for my session. It went well except for the fact that my system crashed (Murphy’s law was proven several times this evening). After a quick reboot I was able to show my demos (I will put these on youtube later) and they were received well.

Dinner time after that. Swiss cheese fondue with white wine. Absolutely delicious. This time not accompanied by yodellers unfortunately. You can’t have it all

It was Michel Wacker’s turn to entertain an audience that were half human, half cheese. Not an easy task but he managed to pull it off brilliantly. His talk was called “Hot Wireless Data Fudge” and dealt with the exchange of data over wireless LAN between an AIR application running on a desktop and one running on a mobile device. He showed us how he found the optimal solution by trial & error. I’m definitely going to play around with this. Fortunately he is going to release his source code so keep an eye on his blog.

Last session of the evening. Tiago Dias talking about “Developing AIR for TV”. Very interesting because this was something I absolutely didn’t know anything about. He showed some demos using StageVideo, a P2P multiplayer game and using an Android phone as a remote controller. Learned a lot from this one!

After the sessions there were more beers and some really tasty Portuguese drinks (thanks to Hugo the Swiss cheese killer & Ricardo for that!).

The last day was an early one. We decided to beat the crowds because it was a Saturday and a lot of Swiss went out to the slopes as well.
During lunchtime we went up to the “James Bond” restaurant to have some food, some more beers and a power nap.

Then it was time to kick off the last three sessions. First up was Trine Falbe. Her talk was about cognitive psychology. A lot different from all the other sessions and refreshing because of that. She explained some of the theories behind interaction design. Lots of very good & useful insights and a very professional presentation.

Next up was a proper geeky session. “Flash + Arduino: A Connection With Feelings” by Ricardo Castelhano. A very inspiring session showcasing some awesome interactive installation work & interesting demos. I wasn’t the only one being inspired by this & I think most of the attendees are going to order an Arduino kit now! It was Ricardo’s first presentation in English and he did a great job at it.

Then some more food, more beers, interesting chats and an ice & chocolate dessert.

Time for the last session on the last day. Not an easy job for Sandro Ducceschi. His talk was about accessibility and he jokingly called it the “awesomest accessibility talk ever”. Accessibility is never an easy topic to bring to an audience but he mixed it with jokes & games which made the talk quite entertaining. He talked about the cons of the current accessibility options in Flash & Flex and he showed us how he managed to simplify his way of working. He also proved how irritating Jaws can be because Jaws just doesn’t shut up!
He announced the release of his open-source accessibility framework called JAcc. It makes it a lot easier to make Flash & Flex sites more accessible. A highly recommended framework!

gotoAndSki() was an amazing experience. Because the conference is smaller in size than other conferences you really get to know most of the people who are attending. It is the best networking event that I’ve been to. It goes beyond superficial contact and you actually make new friends! I’m sure you’ll hear that from everyone who was attending. Fernando said he will be organising gotoAndSki(“Switzerland”) again next year. Fortunately you won’t have to wait that long. Jens & Thomas told us that they will be organising another gotoAndSki(“Norway”) in June. So if you’re up for networking, fun, great sessions, eating, drinking, etc …. go there!!!