VisClient/org/dronus/gl/GLFont.java

Go to the documentation of this file.

package org.dronus.gl;

import java.awt.Color;
import java.awt.Font;
import java.awt.FontMetrics;
import java.awt.Graphics2D;
import java.awt.RenderingHints;
import java.awt.image.BufferedImage;

import org.hfbk.vis.Prefs;
import org.lwjgl.opengl.GL11;

public class GLFont {
        private static GLFont def;

        String fontName;
        
        final int N = 16, NUM_LETTERS = 256;
        
        int resolution = 64;
        
        int     chars; // Base Display List For The Font Set
        float[] charwidth = new float[NUM_LETTERS]; 

        Texture texture;
        
        static final Color OPAQUE_WHITE = Color.WHITE, TRANSPARENT_WHITE = new Color(1, 1, 1, 0);

        
        public static GLFont getDefault() {
                if (def==null || def.fontName!=Prefs.current.font)
                        def = new GLFont(Prefs.current.font);
                return def;
        }

        public void render() {
                texture.render();
        }

        public void print(String msg) {
                float carriage = 0;
                if (msg != null) {
                        for (int i = 0; i < msg.length(); i++) {
                                char c = msg.charAt(i);
                                if (c > 255)
                                        continue;
                                if (c == '\n') {
                                        GL11.glTranslatef(-carriage, 2, 0);
                                        carriage = 0;
                                }

                                GL11.glCallList(chars + c);
                                GL11.glTranslatef(charwidth[c], 0, 0);
                                carriage += charwidth[c];
                        }
                }
        }

        public GLFont(String fontName) 
        {
                this.fontName=fontName;
                texture = new Texture(buildBitmap(fontName));           
                chars  =buildChars();           
        }
                
        BufferedImage buildBitmap(String fontName){ 
                
                int size = N * resolution; // set the size for the bitmap
                
                //image for creating the texture
                BufferedImage bitmap = new BufferedImage(size, size,    BufferedImage.TYPE_4BYTE_ABGR);  
                Graphics2D g = (Graphics2D) bitmap.getGraphics();               
                        
                //get the required font size by checking the official size
                //against the real size of largest letter W
                Font font = new Font(fontName, Font.BOLD, resolution);
                g.setFont(font);
                FontMetrics fm = g.getFontMetrics();
                
                int rowColSize = N*Math.max(fm.stringWidth("W"), fm.getHeight());
                
                //calculate the corrected font size
                int fontSize=(int)(resolution*size/(float)rowColSize);
                
                //build font with actual size 
                font = font.deriveFont((float)fontSize);
                g.setFont(font);
                fm = g.getFontMetrics();
                
                rowColSize = N*Math.max(fm.stringWidth("W"), fm.getHeight());
                
                
                /*
                 * Now that a font size has been determined,
                 * draw the standard/extended ASCII character set for that
                 * font.
                 */
                
                g.setColor(TRANSPARENT_WHITE);
                g.fillRect(0, 0, size, size);

                g.setColor(OPAQUE_WHITE);
                // g.setBackground(TRANSPARENT_WHITE);
                g.setRenderingHint(RenderingHints.KEY_TEXT_ANTIALIASING,
                                RenderingHints.VALUE_TEXT_ANTIALIAS_ON);
                fm = g.getFontMetrics();

                for (int i = 0; i < 256; i++) {
                        int x = i % N;
                        int y = i / N;
                        char ch[] = { (char) i };
                        String temp = new String(ch);
                        charwidth[i] = fm.charWidth((char) i) * 2f / resolution;
                        // fm.stringWidth(temp)/(float)lettersize;
                        // float dx=(lettersize-fm.stringWidth(temp))/2f;
                        g.drawString(temp, (x * resolution) + 1, (y * resolution) + fm.getAscent());
                }
                
                return bitmap;
        }

        int buildChars(){
                int dl= GL11.glGenLists(NUM_LETTERS); // lists For NUM_LETTERS Characters

                float textureDelta = 1.0f / N;
                
                for (int i = 0; i < NUM_LETTERS; i++) {
                        float u = ((float) (i % N)) / N;
                        float v = ((float) (i / N)) / N;
                        GL11.glNewList(dl + i, GL11.GL_COMPILE);
                        GL11.glBegin(GL11.GL_QUADS);
                        GL11.glTexCoord2f(u, v);
                        GL11.glVertex3f(0, 1, 0.0f);
                        GL11.glTexCoord2f((u + textureDelta * charwidth[i] / 2), v);
                        GL11.glVertex3f(charwidth[i], 1, 0.0f);
                        GL11.glTexCoord2f((u + textureDelta * charwidth[i] / 2), v+ textureDelta);
                        GL11.glVertex3f(charwidth[i], -1, 0.0f);
                        GL11.glTexCoord2f(u, v + textureDelta);
                        GL11.glVertex3f(0, -1, 0.0f);
                        GL11.glEnd();
                        GL11.glEndList();
                }
                return dl;
        }
        
        
        public float getLineLength(String text) {
                float l = 0;
                for (int i = 0; i < text.length(); i++) {
                        char c = text.charAt(i);
                        if (c <= 255)
                                l += charwidth[c];
                }
                return l;
        }

        public void finalize() throws Throwable {
                // DEBUG System.out.println("Freed DisplayLists "+base+" "+NUM_LETTERS);
                GL11.glDeleteLists(chars, NUM_LETTERS);
                super.finalize();
        }
}

---