gametel 0.1

data/ApiDemos/src/com/example/android/apis/graphics/kube/KubeRenderer.java

@@ -0,0 +1,116 @@
+/*
+ * Copyright (C) 2008 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.example.android.apis.graphics.kube;
+
+import android.opengl.GLSurfaceView;
+
+import javax.microedition.khronos.egl.EGLConfig;
+import javax.microedition.khronos.opengles.GL10;
+
+
+/**
+ * Example of how to use OpenGL|ES in a custom view
+ *
+ */
+class KubeRenderer implements GLSurfaceView.Renderer {
+    public interface AnimationCallback {
+        void animate();
+    }
+
+    public KubeRenderer(GLWorld world, AnimationCallback callback) {
+        mWorld = world;
+        mCallback = callback;
+    }
+
+    public void onDrawFrame(GL10 gl) {
+         if (mCallback != null) {
+             mCallback.animate();
+         }
+
+        /*
+         * Usually, the first thing one might want to do is to clear
+         * the screen. The most efficient way of doing this is to use
+         * glClear(). However we must make sure to set the scissor
+         * correctly first. The scissor is always specified in window
+         * coordinates:
+         */
+
+        gl.glClearColor(0.5f,0.5f,0.5f,1);
+        gl.glClear(GL10.GL_COLOR_BUFFER_BIT | GL10.GL_DEPTH_BUFFER_BIT);
+
+        /*
+         * Now we're ready to draw some 3D object
+         */
+
+        gl.glMatrixMode(GL10.GL_MODELVIEW);
+        gl.glLoadIdentity();
+        gl.glTranslatef(0, 0, -3.0f);
+        gl.glScalef(0.5f, 0.5f, 0.5f);
+        gl.glRotatef(mAngle,        0, 1, 0);
+        gl.glRotatef(mAngle*0.25f,  1, 0, 0);
+
+        gl.glColor4f(0.7f, 0.7f, 0.7f, 1.0f);
+        gl.glEnableClientState(GL10.GL_VERTEX_ARRAY);
+        gl.glEnableClientState(GL10.GL_COLOR_ARRAY);
+        gl.glEnable(GL10.GL_CULL_FACE);
+        gl.glShadeModel(GL10.GL_SMOOTH);
+        gl.glEnable(GL10.GL_DEPTH_TEST);
+
+        mWorld.draw(gl);
+    }
+
+    public void onSurfaceChanged(GL10 gl, int width, int height) {
+        gl.glViewport(0, 0, width, height);
+
+        /*
+         * Set our projection matrix. This doesn't have to be done
+         * each time we draw, but usually a new projection needs to be set
+         * when the viewport is resized.
+         */
+
+        float ratio = (float)width / height;
+        gl.glMatrixMode(GL10.GL_PROJECTION);
+        gl.glLoadIdentity();
+        gl.glFrustumf(-ratio, ratio, -1, 1, 2, 12);
+
+        /*
+         * By default, OpenGL enables features that improve quality
+         * but reduce performance. One might want to tweak that
+         * especially on software renderer.
+         */
+        gl.glDisable(GL10.GL_DITHER);
+        gl.glActiveTexture(GL10.GL_TEXTURE0);
+    }
+
+    public void onSurfaceCreated(GL10 gl, EGLConfig config) {
+        // Nothing special, don't have any textures we need to recreate.
+    }
+
+    public void setAngle(float angle) {
+        mAngle = angle;
+    }
+
+    public float getAngle() {
+        return mAngle;
+    }
+
+    private GLWorld mWorld;
+    private AnimationCallback mCallback;
+    private float mAngle;
+}
+
+

data/ApiDemos/src/com/example/android/apis/graphics/kube/Layer.java

@@ -0,0 +1,101 @@
+/*
+ * Copyright (C) 2008 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.example.android.apis.graphics.kube;
+
+public class Layer {
+	
+	public Layer(int axis) {
+		// start with identity matrix for transformation
+		mAxis = axis;
+		mTransform.setIdentity();
+	}
+	
+	public void startAnimation() {
+		for (int i = 0; i < mShapes.length; i++) {
+			GLShape shape = mShapes[i];
+			if (shape != null) {
+				shape.startAnimation();
+			}	
+		}
+	}
+
+	public void endAnimation() {
+		for (int i = 0; i < mShapes.length; i++) {
+			GLShape shape = mShapes[i];
+			if (shape != null) {
+				shape.endAnimation();
+			}	
+		}
+	}
+	
+	public void setAngle(float angle) {
+		// normalize the angle
+		float twopi = (float)Math.PI *2f;
+		while (angle >= twopi) angle -= twopi;
+		while (angle < 0f) angle += twopi;
+//		mAngle = angle;
+		
+		float sin = (float)Math.sin(angle);
+		float cos = (float)Math.cos(angle);
+		
+		float[][] m = mTransform.m;
+		switch (mAxis) {
+			case kAxisX:
+				m[1][1] = cos;
+				m[1][2] = sin;
+				m[2][1] = -sin;
+				m[2][2] = cos;
+				m[0][0] = 1f;
+				m[0][1] = m[0][2] = m[1][0] = m[2][0] = 0f;
+				break;
+			case kAxisY:
+				m[0][0] = cos;
+				m[0][2] = sin;
+				m[2][0] = -sin;
+				m[2][2] = cos;
+				m[1][1] = 1f;
+				m[0][1] = m[1][0] = m[1][2] = m[2][1] = 0f;
+				break;
+			case kAxisZ:
+				m[0][0] = cos;
+				m[0][1] = sin;
+				m[1][0] = -sin;
+				m[1][1] = cos;
+				m[2][2] = 1f;
+				m[2][0] = m[2][1] = m[0][2] = m[1][2] = 0f;
+				break;
+		}
+		
+		for (int i = 0; i < mShapes.length; i++) {
+			GLShape shape = mShapes[i];
+			if (shape != null) {
+				shape.animateTransform(mTransform);
+			}
+		}
+	}
+	
+	GLShape[] mShapes = new GLShape[9];
+	M4 mTransform = new M4();
+//	float mAngle;
+
+	// which axis do we rotate around?
+	// 0 for X, 1 for Y, 2 for Z
+	int mAxis;
+	static public final int kAxisX = 0;
+	static public final int kAxisY = 1;
+	static public final int kAxisZ = 2;	
+}

data/ApiDemos/src/com/example/android/apis/graphics/kube/M4.java

@@ -0,0 +1,80 @@
+/*
+ * Copyright (C) 2008 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.example.android.apis.graphics.kube;
+
+/** 
+ * 
+ * A 4x4 float matrix
+ *
+ */
+public class M4 {
+	public float[][] m = new float[4][4];
+	
+	public M4() {
+	}
+	
+	public M4(M4 other) {
+		for (int i = 0; i < 4; i++) {
+			for (int j = 0; j < 4; j++) {
+				m[i][j] = other.m[i][j];
+			}
+		}		
+	}
+
+	public void multiply(GLVertex src, GLVertex dest) {
+		dest.x = src.x * m[0][0] + src.y * m[1][0] + src.z * m[2][0] + m[3][0];
+		dest.y = src.x * m[0][1] + src.y * m[1][1] + src.z * m[2][1] + m[3][1];
+		dest.z = src.x * m[0][2] + src.y * m[1][2] + src.z * m[2][2] + m[3][2];
+	}
+	
+	public M4 multiply(M4 other) {
+		M4 result = new M4();
+		float[][] m1 = m;
+		float[][] m2 = other.m;
+		
+		for (int i = 0; i < 4; i++) {
+			for (int j = 0; j < 4; j++) {
+				result.m[i][j] = m1[i][0]*m2[0][j] + m1[i][1]*m2[1][j] + m1[i][2]*m2[2][j] + m1[i][3]*m2[3][j];
+			}
+		}
+		
+		return result;
+	}
+	
+	public void setIdentity() {
+		for (int i = 0; i < 4; i++) {
+			for (int j = 0; j < 4; j++) {
+				m[i][j] = (i == j ? 1f : 0f);
+			}
+		}
+	}
+	
+	@Override
+	public String toString() {
+		StringBuilder builder = new StringBuilder("[ ");
+		for (int i = 0; i < 4; i++) {
+			for (int j = 0; j < 4; j++) {
+				builder.append(m[i][j]);
+				builder.append(" ");
+			}
+			if (i < 2)
+				builder.append("\n  ");
+		}
+		builder.append(" ]");
+		return builder.toString();
+	}
+}

data/ApiDemos/src/com/example/android/apis/graphics/spritetext/Grid.java

@@ -0,0 +1,140 @@
+/*
+ * Copyright (C) 2007 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.example.android.apis.graphics.spritetext;
+
+import java.nio.ByteBuffer;
+import java.nio.ByteOrder;
+import java.nio.CharBuffer;
+import java.nio.FloatBuffer;
+
+import javax.microedition.khronos.opengles.GL10;
+
+/**
+ * A 2D rectangular mesh. Can be drawn textured or untextured.
+ *
+ */
+class Grid {
+
+    public Grid(int w, int h) {
+        if (w < 0 || w >= 65536) {
+            throw new IllegalArgumentException("w");
+        }
+        if (h < 0 || h >= 65536) {
+            throw new IllegalArgumentException("h");
+        }
+        if (w * h >= 65536) {
+            throw new IllegalArgumentException("w * h >= 65536");
+        }
+
+        mW = w;
+        mH = h;
+        int size = w * h;
+        final int FLOAT_SIZE = 4;
+        final int CHAR_SIZE = 2;
+        mVertexBuffer = ByteBuffer.allocateDirect(FLOAT_SIZE * size * 3)
+            .order(ByteOrder.nativeOrder()).asFloatBuffer();
+        mTexCoordBuffer = ByteBuffer.allocateDirect(FLOAT_SIZE * size * 2)
+            .order(ByteOrder.nativeOrder()).asFloatBuffer();
+
+        int quadW = mW - 1;
+        int quadH = mH - 1;
+        int quadCount = quadW * quadH;
+        int indexCount = quadCount * 6;
+        mIndexCount = indexCount;
+        mIndexBuffer = ByteBuffer.allocateDirect(CHAR_SIZE * indexCount)
+            .order(ByteOrder.nativeOrder()).asCharBuffer();
+
+        /*
+         * Initialize triangle list mesh.
+         *
+         *     [0]-----[  1] ...
+         *      |    /   |
+         *      |   /    |
+         *      |  /     |
+         *     [w]-----[w+1] ...
+         *      |       |
+         *
+         */
+
+        {
+            int i = 0;
+            for (int y = 0; y < quadH; y++) {
+                for (int x = 0; x < quadW; x++) {
+                    char a = (char) (y * mW + x);
+                    char b = (char) (y * mW + x + 1);
+                    char c = (char) ((y + 1) * mW + x);
+                    char d = (char) ((y + 1) * mW + x + 1);
+
+                    mIndexBuffer.put(i++, a);
+                    mIndexBuffer.put(i++, b);
+                    mIndexBuffer.put(i++, c);
+
+                    mIndexBuffer.put(i++, b);
+                    mIndexBuffer.put(i++, c);
+                    mIndexBuffer.put(i++, d);
+                }
+            }
+        }
+
+    }
+
+    void set(int i, int j, float x, float y, float z, float u, float v) {
+        if (i < 0 || i >= mW) {
+            throw new IllegalArgumentException("i");
+        }
+        if (j < 0 || j >= mH) {
+            throw new IllegalArgumentException("j");
+        }
+
+        int index = mW * j + i;
+
+        int posIndex = index * 3;
+        mVertexBuffer.put(posIndex, x);
+        mVertexBuffer.put(posIndex + 1, y);
+        mVertexBuffer.put(posIndex + 2, z);
+
+        int texIndex = index * 2;
+        mTexCoordBuffer.put(texIndex, u);
+        mTexCoordBuffer.put(texIndex + 1, v);
+    }
+
+    public void draw(GL10 gl, boolean useTexture) {
+        gl.glEnableClientState(GL10.GL_VERTEX_ARRAY);
+        gl.glVertexPointer(3, GL10.GL_FLOAT, 0, mVertexBuffer);
+
+        if (useTexture) {
+            gl.glEnableClientState(GL10.GL_TEXTURE_COORD_ARRAY);
+            gl.glTexCoordPointer(2, GL10.GL_FLOAT, 0, mTexCoordBuffer);
+            gl.glEnable(GL10.GL_TEXTURE_2D);
+        } else {
+            gl.glDisableClientState(GL10.GL_TEXTURE_COORD_ARRAY);
+            gl.glDisable(GL10.GL_TEXTURE_2D);
+        }
+
+        gl.glDrawElements(GL10.GL_TRIANGLES, mIndexCount,
+                GL10.GL_UNSIGNED_SHORT, mIndexBuffer);
+        gl.glDisableClientState(GL10.GL_VERTEX_ARRAY);
+    }
+
+    private FloatBuffer mVertexBuffer;
+    private FloatBuffer mTexCoordBuffer;
+    private CharBuffer mIndexBuffer;
+
+    private int mW;
+    private int mH;
+    private int mIndexCount;
+}

data/ApiDemos/src/com/example/android/apis/graphics/spritetext/LabelMaker.java

@@ -0,0 +1,411 @@
+/*
+ * Copyright (C) 2007 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.example.android.apis.graphics.spritetext;
+
+import android.graphics.Bitmap;
+import android.graphics.Canvas;
+import android.graphics.Paint;
+import android.graphics.Rect;
+import android.graphics.Paint.Style;
+import android.graphics.drawable.Drawable;
+import android.opengl.GLUtils;
+
+import java.util.ArrayList;
+
+import javax.microedition.khronos.opengles.GL10;
+import javax.microedition.khronos.opengles.GL11;
+import javax.microedition.khronos.opengles.GL11Ext;
+
+/**
+ * An OpenGL text label maker.
+ *
+ *
+ * OpenGL labels are implemented by creating a Bitmap, drawing all the labels
+ * into the Bitmap, converting the Bitmap into an Alpha texture, and drawing
+ * portions of the texture using glDrawTexiOES.
+ *
+ * The benefits of this approach are that the labels are drawn using the high
+ * quality anti-aliased font rasterizer, full character set support, and all the
+ * text labels are stored on a single texture, which makes it faster to use.
+ *
+ * The drawbacks are that you can only have as many labels as will fit onto one
+ * texture, and you have to recreate the whole texture if any label text
+ * changes.
+ *
+ */
+public class LabelMaker {
+    /**
+     * Create a label maker
+     * or maximum compatibility with various OpenGL ES implementations,
+     * the strike width and height must be powers of two,
+     * We want the strike width to be at least as wide as the widest window.
+     *
+     * @param fullColor true if we want a full color backing store (4444),
+     * otherwise we generate a grey L8 backing store.
+     * @param strikeWidth width of strike
+     * @param strikeHeight height of strike
+     */
+    public LabelMaker(boolean fullColor, int strikeWidth, int strikeHeight) {
+        mFullColor = fullColor;
+        mStrikeWidth = strikeWidth;
+        mStrikeHeight = strikeHeight;
+        mTexelWidth = (float) (1.0 / mStrikeWidth);
+        mTexelHeight = (float) (1.0 / mStrikeHeight);
+        mClearPaint = new Paint();
+        mClearPaint.setARGB(0, 0, 0, 0);
+        mClearPaint.setStyle(Style.FILL);
+        mState = STATE_NEW;
+    }
+
+    /**
+     * Call to initialize the class.
+     * Call whenever the surface has been created.
+     *
+     * @param gl
+     */
+    public void initialize(GL10 gl) {
+        mState = STATE_INITIALIZED;
+        int[] textures = new int[1];
+        gl.glGenTextures(1, textures, 0);
+        mTextureID = textures[0];
+        gl.glBindTexture(GL10.GL_TEXTURE_2D, mTextureID);
+
+        // Use Nearest for performance.
+        gl.glTexParameterf(GL10.GL_TEXTURE_2D, GL10.GL_TEXTURE_MIN_FILTER,
+                GL10.GL_NEAREST);
+        gl.glTexParameterf(GL10.GL_TEXTURE_2D, GL10.GL_TEXTURE_MAG_FILTER,
+                GL10.GL_NEAREST);
+
+        gl.glTexParameterf(GL10.GL_TEXTURE_2D, GL10.GL_TEXTURE_WRAP_S,
+                GL10.GL_CLAMP_TO_EDGE);
+        gl.glTexParameterf(GL10.GL_TEXTURE_2D, GL10.GL_TEXTURE_WRAP_T,
+                GL10.GL_CLAMP_TO_EDGE);
+
+        gl.glTexEnvf(GL10.GL_TEXTURE_ENV, GL10.GL_TEXTURE_ENV_MODE,
+                GL10.GL_REPLACE);
+    }
+
+    /**
+     * Call when the surface has been destroyed
+     */
+    public void shutdown(GL10 gl) {
+        if ( gl != null) {
+            if (mState > STATE_NEW) {
+                int[] textures = new int[1];
+                textures[0] = mTextureID;
+                gl.glDeleteTextures(1, textures, 0);
+                mState = STATE_NEW;
+            }
+        }
+    }
+
+    /**
+     * Call before adding labels. Clears out any existing labels.
+     *
+     * @param gl
+     */
+    public void beginAdding(GL10 gl) {
+        checkState(STATE_INITIALIZED, STATE_ADDING);
+        mLabels.clear();
+        mU = 0;
+        mV = 0;
+        mLineHeight = 0;
+        Bitmap.Config config = mFullColor ?
+                Bitmap.Config.ARGB_4444 : Bitmap.Config.ALPHA_8;
+        mBitmap = Bitmap.createBitmap(mStrikeWidth, mStrikeHeight, config);
+        mCanvas = new Canvas(mBitmap);
+        mBitmap.eraseColor(0);
+    }
+
+    /**
+     * Call to add a label
+     *
+     * @param gl
+     * @param text the text of the label
+     * @param textPaint the paint of the label
+     * @return the id of the label, used to measure and draw the label
+     */
+    public int add(GL10 gl, String text, Paint textPaint) {
+        return add(gl, null, text, textPaint);
+    }
+
+    /**
+     * Call to add a label
+     *
+     * @param gl
+     * @param text the text of the label
+     * @param textPaint the paint of the label
+     * @return the id of the label, used to measure and draw the label
+     */
+    public int add(GL10 gl, Drawable background, String text, Paint textPaint) {
+        return add(gl, background, text, textPaint, 0, 0);
+    }
+
+    /**
+     * Call to add a label
+     * @return the id of the label, used to measure and draw the label
+     */
+    public int add(GL10 gl, Drawable drawable, int minWidth, int minHeight) {
+        return add(gl, drawable, null, null, minWidth, minHeight);
+    }
+
+    /**
+     * Call to add a label
+     *
+     * @param gl
+     * @param text the text of the label
+     * @param textPaint the paint of the label
+     * @return the id of the label, used to measure and draw the label
+     */
+    public int add(GL10 gl, Drawable background, String text, Paint textPaint,
+            int minWidth, int minHeight) {
+        checkState(STATE_ADDING, STATE_ADDING);
+        boolean drawBackground = background != null;
+        boolean drawText = (text != null) && (textPaint != null);
+
+        Rect padding = new Rect();
+        if (drawBackground) {
+            background.getPadding(padding);
+            minWidth = Math.max(minWidth, background.getMinimumWidth());
+            minHeight = Math.max(minHeight, background.getMinimumHeight());
+        }
+
+        int ascent = 0;
+        int descent = 0;
+        int measuredTextWidth = 0;
+        if (drawText) {
+            // Paint.ascent is negative, so negate it.
+            ascent = (int) Math.ceil(-textPaint.ascent());
+            descent = (int) Math.ceil(textPaint.descent());
+            measuredTextWidth = (int) Math.ceil(textPaint.measureText(text));
+        }
+        int textHeight = ascent + descent;
+        int textWidth = Math.min(mStrikeWidth,measuredTextWidth);
+
+        int padHeight = padding.top + padding.bottom;
+        int padWidth = padding.left + padding.right;
+        int height = Math.max(minHeight, textHeight + padHeight);
+        int width = Math.max(minWidth, textWidth + padWidth);
+        int effectiveTextHeight = height - padHeight;
+        int effectiveTextWidth = width - padWidth;
+
+        int centerOffsetHeight = (effectiveTextHeight - textHeight) / 2;
+        int centerOffsetWidth = (effectiveTextWidth - textWidth) / 2;
+
+        // Make changes to the local variables, only commit them
+        // to the member variables after we've decided not to throw
+        // any exceptions.
+
+        int u = mU;
+        int v = mV;
+        int lineHeight = mLineHeight;
+
+        if (width > mStrikeWidth) {
+            width = mStrikeWidth;
+        }
+
+        // Is there room for this string on the current line?
+        if (u + width > mStrikeWidth) {
+            // No room, go to the next line:
+            u = 0;
+            v += lineHeight;
+            lineHeight = 0;
+        }
+        lineHeight = Math.max(lineHeight, height);
+        if (v + lineHeight > mStrikeHeight) {
+            throw new IllegalArgumentException("Out of texture space.");
+        }
+
+        int u2 = u + width;
+        int vBase = v + ascent;
+        int v2 = v + height;
+
+        if (drawBackground) {
+            background.setBounds(u, v, u + width, v + height);
+            background.draw(mCanvas);
+        }
+
+        if (drawText) {
+            mCanvas.drawText(text,
+                    u + padding.left + centerOffsetWidth,
+                    vBase + padding.top + centerOffsetHeight,
+                    textPaint);
+        }
+
+        // We know there's enough space, so update the member variables
+        mU = u + width;
+        mV = v;
+        mLineHeight = lineHeight;
+        mLabels.add(new Label(width, height, ascent,
+                u, v + height, width, -height));
+        return mLabels.size() - 1;
+    }
+
+    /**
+     * Call to end adding labels. Must be called before drawing starts.
+     *
+     * @param gl
+     */
+    public void endAdding(GL10 gl) {
+        checkState(STATE_ADDING, STATE_INITIALIZED);
+        gl.glBindTexture(GL10.GL_TEXTURE_2D, mTextureID);
+        GLUtils.texImage2D(GL10.GL_TEXTURE_2D, 0, mBitmap, 0);
+        // Reclaim storage used by bitmap and canvas.
+        mBitmap.recycle();
+        mBitmap = null;
+        mCanvas = null;
+    }
+
+    /**
+     * Get the width in pixels of a given label.
+     *
+     * @param labelID
+     * @return the width in pixels
+     */
+    public float getWidth(int labelID) {
+        return mLabels.get(labelID).width;
+    }
+
+    /**
+     * Get the height in pixels of a given label.
+     *
+     * @param labelID
+     * @return the height in pixels
+     */
+    public float getHeight(int labelID) {
+        return mLabels.get(labelID).height;
+    }
+
+    /**
+     * Get the baseline of a given label. That's how many pixels from the top of
+     * the label to the text baseline. (This is equivalent to the negative of
+     * the label's paint's ascent.)
+     *
+     * @param labelID
+     * @return the baseline in pixels.
+     */
+    public float getBaseline(int labelID) {
+        return mLabels.get(labelID).baseline;
+    }
+
+    /**
+     * Begin drawing labels. Sets the OpenGL state for rapid drawing.
+     *
+     * @param gl
+     * @param viewWidth
+     * @param viewHeight
+     */
+    public void beginDrawing(GL10 gl, float viewWidth, float viewHeight) {
+        checkState(STATE_INITIALIZED, STATE_DRAWING);
+        gl.glBindTexture(GL10.GL_TEXTURE_2D, mTextureID);
+        gl.glShadeModel(GL10.GL_FLAT);
+        gl.glEnable(GL10.GL_BLEND);
+        gl.glBlendFunc(GL10.GL_SRC_ALPHA, GL10.GL_ONE_MINUS_SRC_ALPHA);
+        gl.glColor4x(0x10000, 0x10000, 0x10000, 0x10000);
+        gl.glMatrixMode(GL10.GL_PROJECTION);
+        gl.glPushMatrix();
+        gl.glLoadIdentity();
+        gl.glOrthof(0.0f, viewWidth, 0.0f, viewHeight, 0.0f, 1.0f);
+        gl.glMatrixMode(GL10.GL_MODELVIEW);
+        gl.glPushMatrix();
+        gl.glLoadIdentity();
+        // Magic offsets to promote consistent rasterization.
+        gl.glTranslatef(0.375f, 0.375f, 0.0f);
+    }
+
+    /**
+     * Draw a given label at a given x,y position, expressed in pixels, with the
+     * lower-left-hand-corner of the view being (0,0).
+     *
+     * @param gl
+     * @param x
+     * @param y
+     * @param labelID
+     */
+    public void draw(GL10 gl, float x, float y, int labelID) {
+        checkState(STATE_DRAWING, STATE_DRAWING);
+        Label label = mLabels.get(labelID);
+        gl.glEnable(GL10.GL_TEXTURE_2D);
+        ((GL11)gl).glTexParameteriv(GL10.GL_TEXTURE_2D,
+                GL11Ext.GL_TEXTURE_CROP_RECT_OES, label.mCrop, 0);
+        ((GL11Ext)gl).glDrawTexiOES((int) x, (int) y, 0,
+                (int) label.width, (int) label.height);
+    }
+
+    /**
+     * Ends the drawing and restores the OpenGL state.
+     *
+     * @param gl
+     */
+    public void endDrawing(GL10 gl) {
+        checkState(STATE_DRAWING, STATE_INITIALIZED);
+        gl.glDisable(GL10.GL_BLEND);
+        gl.glMatrixMode(GL10.GL_PROJECTION);
+        gl.glPopMatrix();
+        gl.glMatrixMode(GL10.GL_MODELVIEW);
+        gl.glPopMatrix();
+    }
+
+    private void checkState(int oldState, int newState) {
+        if (mState != oldState) {
+            throw new IllegalArgumentException("Can't call this method now.");
+        }
+        mState = newState;
+    }
+
+    private static class Label {
+        public Label(float width, float height, float baseLine,
+                int cropU, int cropV, int cropW, int cropH) {
+            this.width = width;
+            this.height = height;
+            this.baseline = baseLine;
+            int[] crop = new int[4];
+            crop[0] = cropU;
+            crop[1] = cropV;
+            crop[2] = cropW;
+            crop[3] = cropH;
+            mCrop = crop;
+        }
+
+        public float width;
+        public float height;
+        public float baseline;
+        public int[] mCrop;
+    }
+
+    private int mStrikeWidth;
+    private int mStrikeHeight;
+    private boolean mFullColor;
+    private Bitmap mBitmap;
+    private Canvas mCanvas;
+    private Paint mClearPaint;
+
+    private int mTextureID;
+
+    private float mTexelWidth;  // Convert texel to U
+    private float mTexelHeight; // Convert texel to V
+    private int mU;
+    private int mV;
+    private int mLineHeight;
+    private ArrayList<Label> mLabels = new ArrayList<Label>();
+
+    private static final int STATE_NEW = 0;
+    private static final int STATE_INITIALIZED = 1;
+    private static final int STATE_ADDING = 2;
+    private static final int STATE_DRAWING = 3;
+    private int mState;
+}