A few words about why did I bother in the first place? First, I wanted to control the main game loop by myself and don’t rely on GLSurfaceView’s callbacks. Doing it this way allowed me to have a much better code architecture and is more robust as I can *really* control when and what it does. My version does the same thing in 200 lines of code instead of 1350 and can actually be understood by human beings. That brings us to the second reason: I was experiencing weird bugs and had to debug my GL rendering code. Tracing the issue I ended up at EGL level. To this day I don’t know what was really the problem as GLSurfaceView is an abomination. It doesn’t have a proper separation of responsibilities in its thirteen internal classes, the logic is horribly convoluted… let’s say initially I started to refactor it into something understandable but after a few hours just gave up and wrote my own implementation. In a single class. Simple and working one. Nuff said

public class GLSurface extends SurfaceView implements SurfaceHolder.Callback {

	public GLSurface(Context context) {
		this(context, null);
	}
	public GLSurface(Context context, GLSurfaceListener listener) {
		this(context, null, listener, 5, 6, 5, 0, 16, 0);
	}
	public GLSurface(Context context, AttributeSet attrs, GLSurfaceListener listener,
			int rBits, int gBits, int bBits, int aBits, int dBits, int sBits) {
		super(context, attrs);
		this.rBits = rBits;
		this.gBits = gBits;
		this.bBits = bBits;
		this.aBits = aBits;
		this.dBits = dBits;
		this.sBits = sBits;
		getHolder().addCallback(this);
		this.listener = listener;
	}

	private GLSurfaceListener listener = null;
	public void setGLSurfaceListener(GLSurfaceListener listener) {
		this.listener = listener;
	}

	private boolean hasSurface;
	@Override
	public void surfaceCreated(SurfaceHolder holder) {
		hasSurface = true;
	}
	@Override
	public void surfaceDestroyed(SurfaceHolder holder) {
		hasSurface = false;
		while (gl != null) {
		}
	}

	private int width = 0;
	public int getGLWidth() {
		return width;
	}
	private int height = 0;
	public int getGLHeight() {
		return height;
	}

	private boolean surfaceChanged = false;
	@Override
	public void surfaceChanged(SurfaceHolder holder, int format, int w, int h) {
		width = w;
		height = h;
		surfaceChanged = true;
	}

	private boolean paused = false;
	public boolean isPaused() {
		return paused;
	}
	public void onPause() {
		paused = true;
		if (listener != null) {
			listener.onPause();
		}
	}
	public void onResume() {
		paused = false;
		if (listener != null) {
			listener.onResume();
		}
	}

	private boolean alive = true;
	public boolean isAlive() {
		return alive;
	}
	@Override
	protected void onDetachedFromWindow() {
		super.onDetachedFromWindow();
		alive = false;
	}

	private GL10 gl = null;
	public GL10 gl() {
		return gl;
	}
	private final int rBits;
	private final int gBits;
	private final int bBits;
	private final int aBits;
	private final int dBits;
	private final int sBits;
	private EGL10 egl;
	private EGLDisplay eglDisplay;
	private EGLSurface eglSurface;
	private EGLConfig eglConfig;
	private EGLContext eglContext;
	private void createSurface(SurfaceHolder holder) {
		if (gl != null) {
			throw new RuntimeException("Surface already initialized");
		}

		egl = (EGL10) EGLContext.getEGL();
		eglDisplay = egl.eglGetDisplay(EGL10.EGL_DEFAULT_DISPLAY);
		egl.eglInitialize(eglDisplay, null);

		int[] numConfigs = new int[1];
		egl.eglChooseConfig(eglDisplay, new int[] { EGL10.EGL_NONE }, null, 0, numConfigs);
		EGLConfig[] configs = new EGLConfig[numConfigs[0]];
		egl.eglChooseConfig(eglDisplay, new int[] { EGL10.EGL_NONE }, configs, numConfigs[0], numConfigs);
		int bestDiff = Integer.MAX_VALUE;
		int[] v = new int[1];
		for (EGLConfig c : configs) {
			int diff = 0;
			egl.eglGetConfigAttrib(eglDisplay, c, EGL10.EGL_RED_SIZE,     v); diff += Math.abs(rBits - v[0]);
			egl.eglGetConfigAttrib(eglDisplay, c, EGL10.EGL_GREEN_SIZE,   v); diff += Math.abs(gBits - v[0]);
			egl.eglGetConfigAttrib(eglDisplay, c, EGL10.EGL_BLUE_SIZE,    v); diff += Math.abs(bBits - v[0]);
			egl.eglGetConfigAttrib(eglDisplay, c, EGL10.EGL_ALPHA_SIZE,   v); diff += Math.abs(aBits - v[0]);
			// depth and stencil values are more important than colour depth
			egl.eglGetConfigAttrib(eglDisplay, c, EGL10.EGL_DEPTH_SIZE,   v); diff += Math.abs(dBits - v[0]) * 10;
			egl.eglGetConfigAttrib(eglDisplay, c, EGL10.EGL_STENCIL_SIZE, v); diff += Math.abs(sBits - v[0]) * 100;
			if (diff < bestDiff) {
				bestDiff = diff;
				eglConfig = c;
			}
		}

		eglContext = egl.eglCreateContext(eglDisplay, eglConfig, EGL10.EGL_NO_CONTEXT, null);
		if (eglContext == null || eglContext == EGL10.EGL_NO_CONTEXT) {
			throw new RuntimeException("Unable to create EGL context");
		}

		eglSurface = egl.eglCreateWindowSurface(eglDisplay, eglConfig, holder, null);
		if (eglSurface == null || eglSurface == EGL10.EGL_NO_SURFACE) {
			throw new RuntimeException("Unable to create EGL surface");
		}
		if (!egl.eglMakeCurrent(eglDisplay, eglSurface, eglSurface, eglContext)) {
			throw new RuntimeException("Unable to make EGL current");
		}

		gl = (GL10)eglContext.getGL();
	}
	private  void destroySurface() {
		if (gl == null) {
			return;
		}

		if (eglSurface != null && eglSurface != EGL10.EGL_NO_SURFACE) {
			egl.eglMakeCurrent(eglDisplay, EGL10.EGL_NO_SURFACE, EGL10.EGL_NO_SURFACE, EGL10.EGL_NO_CONTEXT);
			egl.eglDestroySurface(eglDisplay, eglSurface);
			eglSurface = null;
		}
		if (eglContext != null) {
			egl.eglDestroyContext(eglDisplay, eglContext);
			eglContext = null;
		}
		if (eglDisplay != null) {
			egl.eglTerminate(eglDisplay);
			eglDisplay = null;
		}

		gl = null;
	}
	public boolean canDraw() {
		if (!alive || width <= 0 || height <= 0) {
			return false;
		}
		if (isPaused() || !hasSurface) {
			if (listener != null) {
				listener.onSurfaceDestroyed();
			}
			destroySurface();
			return false;
		}
		return true;
	}
	public boolean bind() {
		if (!canDraw()) {
			return false;
		}
		if (gl == null) {
			createSurface(getHolder());
			if (listener != null) {
				listener.onSurfaceCreated(width, height);
			}
		}
		if (surfaceChanged) {
			if (listener != null) {
				listener.onSurfaceChanged(width, height);
			}
			surfaceChanged = false;
		}

		return true;
	}
	public void release() {
		egl.eglSwapBuffers(eglDisplay, eglSurface);
	}
}

public interface GLSurfaceListener {
	void onSurfaceCreated(int width, int height);
	void onResume();
	void onSurfaceChanged(int width, int height);
	void onPause();
	void onSurfaceDestroyed();
}

That was my first thought when I saw this post and watched the video I just finished installing it on my iPhone, finally it’ll be put to some use

It’s just the first alpha release so things are a bit dodgy but it’s fantastic news anyway and I bet it’ll be improved quickly now. The prebuilt binaries contain Android 1.6 but others built 2.0 and 2.1 working images as well.

Bootloader

OS booting, phase 1

OS booting, phase 2

Android on the iPhone!

Web browser

Two hints if you want to try it on your own. I found this tutorial for dummies very helpful. To easily extract firmware you may want to use commands from this page.

Then I bought a Dell XPS M1530 and was collided with harsh reality. Apparently not all laptop manufacturers make good hardware. After little more than a year its battery started to fail only to die a couple of months ago. Obviously battery life in all laptops goes down with age but I’ve never had a battery dying on me completely. Oh, well, bad luck I thought. Then a few weeks ago I started to have problems with its keyboard only to discover today that one of the keys stopped working completely. With a few others being really hard to operate (arrow keys, home/end/pgdn/pgup) I suspect it’s not an isolated case. I had to remove the failed key, cleaned its socket and am now trying to put it back in, hoping it would solve the issue. Oh, by the way, putting it back is a royal pain in the ass due to Dell’s super-clever key mounting mechanism.

Frankly, I’m very disappointed with the build quality of this laptop and, no surprise, will definitely NOT buy any other Dell laptops in the future.

Perilith Knight

Recently I was busy modeling and animating a lower-poly replacement for Perilith Knight meant to be used with JME game I’m working on. All was dandy as long as I was working inside Blender. I exported the model a few times and it was all looking fine as a static mesh. Animated model was a whole different story…

I ran into all kinds of issues from animation not being played at all, being played at the wrong speed, wrong vertices being animated… long story short I needed a tool to preview model from all angles, at different animation steps, scaled, rotated, mashed… I needed a M3G model viewer.

Monster download of Wizzer Works’ M3G Viewer didn’t really bring the expected benefits as it refused to import any of my models. Nifty A desktop application would be nice but at the end of the day what really counts is how a model looks on an actual device so a simple J2ME M3G viewer was the way to go.

If you think the left guy seems familiar you may be right. Although the model is different the texture is the same Actually I think I messed up with texturing of the knight too.

J2ME M3G model viewer

Looks like Eclipse folks made it again Galileo release with Eclipse 3.5 and MTJ 1.0 is included. Yes, I did say ‘MTJ 1.0′! After years of trouble and uncertainity about project’s future Eclipse Mobile Tools for Java project actually saw its release 1.0! I have to admit I’ve never been a huge fan of Java ME tools integrated with various IDEs and instead developed BitCruncher but it’s such an important milestone that I just have to try it out

There’s a video available — check it out at Java ME SDK Team Blog.

Aren’t they cute?

Background video is Dr Motte & Westbam – Lovparade 2000.

I’ve just had a big LOL at myself today. I bought a small Bamboo Wacom tablet, brought it home and plugged into my Linux box. First impression: it’s good. Tablet was recognized as a mouse, I could move cursor and click things but, well, GIMP didn’t like it as a damn tablet. Taught by years of hacking Linux I fired up Firefox, googled for “linux wacom tablet”, found excellent Linux Wacom Project and started debugging/configuring/messing around with system settings. The problem was that everything seemed to work as expected but damn GIMP refused to treat stupid tablet as a, well, tablet. Half hour later I read about disabling something when RedHat is booted with tablet plugged in as it differently autoconfigures tablet when it’s connected before system start and when system is running. *DING!* Maybe my old habits just don’t apply to modern Linux times when things Just Work? Automagically? I rebooted (I know, I could’ve just killed X) with tablet connected and voila! everything Just Works.

Shit!

LOL!

Happiness

That happens when you’re just so used to manually configuring things that you just don’t think that free software is up to the task of applying AutoMagic(tm) and everything Just Works

UPDATE (2010.05.01): Since Ubuntu 9.4 (or possibly earlier version, can’t remember) it’s not even necessary to have it connected at boot time, just Plug’n'Draw baby, anytime