/* * 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 creating a * mesh for each label * * 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);        }        Grid grid = new Grid(2, 2);        // Grid.set arguments: i, j, x, y, z, u, v        float texU = u * mTexelWidth;        float texU2 = u2 * mTexelWidth;        float texV = 1.0f - v * mTexelHeight;        float texV2 = 1.0f - v2 * mTexelHeight;        grid.set(0, 0,   0.0f,   0.0f, 0.0f, texU , texV2);        grid.set(1, 0,  width,   0.0f, 0.0f, texU2, texV2);        grid.set(0, 1,   0.0f, height, 0.0f, texU , texV );        grid.set(1, 1,  width, height, 0.0f, texU2, texV );        // We know there's enough space, so update the member variables        mU = u + width;        mV = v;        mLineHeight = lineHeight;        mLabels.add(new Label(grid, 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);        gl.glPushMatrix();        float snappedX = (float) Math.floor(x);        float snappedY = (float) Math.floor(y);        gl.glTranslatef(snappedX, snappedY, 0.0f);        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) snappedX, (int) snappedY, 0,                (int) label.width, (int) label.height);        gl.glPopMatrix();    }    /**     * 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(Grid grid, float width, float height, float baseLine,                int cropU, int cropV, int cropW, int cropH) {            this.grid = grid;            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 Grid grid;        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;}