Text Rendering issue code

package main;

import java.awt.Font;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.nio.FloatBuffer;
import java.nio.IntBuffer;
import java.util.ArrayList;

import org.lwjgl.BufferUtils;
import org.lwjgl.LWJGLException;
import org.lwjgl.Sys;
import org.lwjgl.input.Keyboard;
import org.lwjgl.input.Mouse;
import org.lwjgl.opengl.Display;
import org.lwjgl.opengl.DisplayMode;
import org.lwjgl.opengl.GL11;
import org.lwjgl.opengl.GL15;
import org.lwjgl.util.glu.GLU;
import org.newdawn.slick.Color;
import org.newdawn.slick.SlickException;
import org.newdawn.slick.TrueTypeFont;
import org.newdawn.slick.UnicodeFont;
import org.newdawn.slick.font.effects.ColorEffect;
import org.newdawn.slick.opengl.Texture;
import org.newdawn.slick.opengl.TextureLoader;

public class Window {

    int width = 800, height = 600;

    /** time at last frame */
    long lastFrame;

    /** frames per second */
    int fps;
    /** last fps time */
    long lastFPS;
    private Texture texture;
    private Vector position = new Vector(0, -1.8f, 0);
    private float yaw = 0;
    private float pitch = 0;
    private Model model;
    private Vector sector;

    private float[] cubeVerts;
    private int vHandle;
    private int tHandle;

    private Vector focusedBlock;

    private TrueTypeFont font;

    public void start()
    {

        try {
            Display.setDisplayMode(new DisplayMode(width, height));
            Display.create();
            Display.setLocation(500, 0);
        } catch (LWJGLException e) {
            e.printStackTrace();
            System.exit(0);
        }


        Mouse.setGrabbed(true);

        //load textures here and other things
        try {
            texture = TextureLoader.getTexture("PNG", new FileInputStream(new File("texture.png")));
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }

        Font awtFont = new Font("Times New Roman", Font.BOLD, 24);
        font = new TrueTypeFont(awtFont, false);


        model = new Model();
        texture.bind();

        setupBasicOpenGL();
        getDelta(); // call once before loop to initialise lastFrame
        lastFPS = getTime(); // call before loop to initialise fps timer

        GL11.glEnableClientState(GL11.GL_VERTEX_ARRAY);
        GL11.glEnableClientState(GL11.GL_TEXTURE_COORD_ARRAY);


        IntBuffer ib = BufferUtils.createIntBuffer(2);
        GL15.glGenBuffers(ib);
        vHandle = ib.get(0);
        tHandle = ib.get(1);


        while (!Display.isCloseRequested()) {
            set3DOpenGL();

            int delta = getDelta();
            focusedBlock = model.hitTest(position, pitch, yaw, 8);

            GL11.glLoadIdentity();
            lookThrough();

            update(delta);

            model.processQueue();
            Vector sector = Model.sectorize(position);
            if (sector != this.sector)
            {
                model.changeSectors(this.sector, sector);
                if (this.sector == null)
                {
                    model.processEntireQueue();

                    updateVBO(model.getShownBlocks());
                }
                this.sector = sector;
            }

            texture.bind();
            renderGL();
            drawFocusedBlock(focusedBlock);


            set2DOpenGL();
            drawReticle();
            Color.white.bind();
            font.drawString(100, 100, "TEST");

            Display.update();
            Display.sync(60); // cap fps to 60fps
        }

        GL11.glDisableClientState(GL11.GL_TEXTURE_COORD_ARRAY);
        GL11.glDisableClientState(GL11.GL_VERTEX_ARRAY);

        ib.put(0, vHandle);
        ib.put(1, tHandle);
        GL15.glDeleteBuffers(ib);

        Display.destroy();
    }

    public void renderGL()
    {
        GL11.glClear(GL11.GL_COLOR_BUFFER_BIT|GL11.GL_DEPTH_BUFFER_BIT);


        GL15.glBindBuffer(GL15.GL_ARRAY_BUFFER, 0);
        GL11.glDrawArrays(GL11.GL_QUADS, 0, cubeVerts.length / (3));
    }

    public void updateVBO(ArrayList<Block> blocks)
    {
        ArrayList<Float> cubeVertList = new ArrayList<Float>();
        ArrayList<Float> texCoordList = new ArrayList<Float>();

        for (Block block : blocks)
        {
            for (float f : block.getCubeVerts())
                cubeVertList.add(f);
            for (float f : block.getTexCoords())
                texCoordList.add(f);
        }

        cubeVerts = new float[cubeVertList.size()];
        for (int i = 0; i < cubeVertList.size(); i++)
            cubeVerts[i] = cubeVertList.get(i);

        FloatBuffer vertBuffer = BufferUtils.createFloatBuffer(cubeVerts.length);
        vertBuffer.put(cubeVerts);
        vertBuffer.flip();

        float[] textures = new float[texCoordList.size()];
        for (int i = 0; i < texCoordList.size(); i++)
            textures[i] = texCoordList.get(i);


        FloatBuffer texBuffer = BufferUtils.createFloatBuffer(textures.length);
        texBuffer.put(textures);
        texBuffer.flip();





        GL15.glBindBuffer(GL15.GL_ARRAY_BUFFER, vHandle);
        GL15.glBufferData(GL15.GL_ARRAY_BUFFER, vertBuffer, GL15.GL_STATIC_DRAW);
        GL11.glVertexPointer(3, GL11.GL_FLOAT, 0, 0L);


        GL15.glBindBuffer(GL15.GL_ARRAY_BUFFER, tHandle);
        GL15.glBufferData(GL15.GL_ARRAY_BUFFER, texBuffer, GL15.GL_STATIC_DRAW);
        GL11.glTexCoordPointer(2, GL11.GL_FLOAT, 0, 0L);
    }

    public void update(int delta)
    {
        float mouseSensitivity = .15f;
        float movementSpeed = 5 * (float)delta / 1000.0f;

        if (Mouse.isButtonDown(0))
            model.removeBlock(focusedBlock, true);


        float dx = Mouse.getDX();
        //distance in mouse movement from the last getDY() call.
        float dy = Mouse.getDY();

        if (Mouse.isGrabbed())
        {
            if (pitch - dy * mouseSensitivity < 85 && pitch - dy * mouseSensitivity > -85)
                pitch -= dy * mouseSensitivity;
            yaw += dx * mouseSensitivity;
        }

        if (Keyboard.isKeyDown(Keyboard.KEY_W))
        {
            position.x -= movementSpeed * (float)Math.sin(Math.toRadians(yaw));
            position.z += movementSpeed * (float)Math.cos(Math.toRadians(yaw));
        }

        //moves the camera backward relitive to its current rotation (yaw)
        if (Keyboard.isKeyDown(Keyboard.KEY_S))
        {
            position.x += movementSpeed * (float)Math.sin(Math.toRadians(yaw));
            position.z -= movementSpeed * (float)Math.cos(Math.toRadians(yaw));
        }

        //strafes the camera left relitive to its current rotation (yaw)
        if (Keyboard.isKeyDown(Keyboard.KEY_A))
        {
            position.x -= movementSpeed * (float)Math.sin(Math.toRadians(yaw-90));
            position.z += movementSpeed * (float)Math.cos(Math.toRadians(yaw-90));
        }

        //strafes the camera right relitive to its current rotation (yaw)
        if (Keyboard.isKeyDown(Keyboard.KEY_D))
        {
            position.x -= movementSpeed * (float)Math.sin(Math.toRadians(yaw+90));
            position.z += movementSpeed * (float)Math.cos(Math.toRadians(yaw+90));
        }

        if (Keyboard.isKeyDown(Keyboard.KEY_SPACE))
            position.y -= movementSpeed * 2;
        if (Keyboard.isKeyDown(Keyboard.KEY_LSHIFT))
            position.y += movementSpeed * 2;

        if (Keyboard.isKeyDown(Keyboard.KEY_ESCAPE))
        {
            Mouse.setGrabbed(!Mouse.isGrabbed());
        }

        updateFPS(); // update FPS Counter
    }


    /**
     * Calculate how many milliseconds have passed
     * since last frame.
     *
     * @return milliseconds passed since last frame
     */
    public int getDelta()
    {
        long time = getTime();
        int delta = (int) (time - lastFrame);
        lastFrame = time;

        return delta;
    }

    /**
     * Get the accurate system time
     *
     * @return The system time in milliseconds
     */
    public static long getTime()
    {
        return (Sys.getTime() * 1000) / Sys.getTimerResolution();
    }

    /**
     * Calculate the FPS and set it in the title bar
     */
    public void updateFPS()
    {
        if (getTime() - lastFPS > 1000)
        {
            Display.setTitle("FPS: " + fps);
            fps = 0;
            lastFPS += 1000;
        }
        fps++;
    }

    public void lookThrough()
    {
        //roatate the pitch around the X axis
        GL11.glRotatef(pitch, 1.0f, 0.0f, 0.0f);
        //roatate the yaw around the Y axis
        GL11.glRotatef(yaw, 0.0f, 1.0f, 0.0f);
        //translate to the position vector's location
        GL11.glTranslatef(position .x, position.y, position.z);
    }

    public void drawFocusedBlock(Vector focusedBlock)
    {
        if (focusedBlock != null)
        {
            float[] vertexData = Block.cubeVertices(focusedBlock.x,
                                                    focusedBlock.y,
                                                    focusedBlock.z, .51f);
            GL11.glColor3d(0, 0, 0);
            GL11.glPolygonMode(GL11.GL_FRONT_AND_BACK, GL11.GL_LINE);

            GL11.glBegin(GL11.GL_QUADS);
            for (int i = 0; i < vertexData.length; i += 3)
            {
                GL11.glVertex3f(vertexData[i],
                        vertexData[i + 1],
                        vertexData[i + 2]);
            }
            GL11.glEnd();

            GL11.glPolygonMode(GL11.GL_FRONT_AND_BACK, GL11.GL_FILL);
            GL11.glColor3d(1, 1, 1);
        }
    }

    public void setupBasicOpenGL()
    {
        GL11.glEnable(GL11.GL_CULL_FACE);
        GL11.glTexParameteri(GL11.GL_TEXTURE_2D, GL11.GL_TEXTURE_MIN_FILTER, GL11.GL_NEAREST);
        GL11.glTexParameteri(GL11.GL_TEXTURE_2D, GL11.GL_TEXTURE_MAG_FILTER, GL11.GL_NEAREST);

        setupFog();
    }

    private void setupFog()
    {
        float r = (float)(44.0 / 255);
        float g = (float)(12.0 / 255);
        float b = (float)(12.0 / 255);
        GL11.glClearColor(r, g, b, 1f);

        FloatBuffer fogColor = BufferUtils.createFloatBuffer(4);
        fogColor.put(r).put(g).put(b).put(1f).flip();

        GL11.glEnable(GL11.GL_DEPTH_TEST);
        GL11.glEnable(GL11.GL_FOG);
        GL11.glFog(GL11.GL_FOG_COLOR, fogColor);
        GL11.glHint(GL11.GL_FOG_HINT, GL11.GL_DONT_CARE);
        GL11.glFogf(GL11.GL_FOG_DENSITY, 0.15f);
        GL11.glFogf(GL11.GL_FOG_START, 10.0f);
        GL11.glFogf(GL11.GL_FOG_END, 60.0f);
    }

    private void set3DOpenGL()
    {
        GL11.glMatrixMode(GL11.GL_PROJECTION);
        GL11.glLoadIdentity();
        GLU.gluPerspective(45.0f,((float)width)/((float)height),0.1f,100.0f);
        GL11.glMatrixMode(GL11.GL_MODELVIEW);
        GL11.glLoadIdentity();
        GL11.glEnable(GL11.GL_TEXTURE_2D);
        GL11.glShadeModel(GL11.GL_SMOOTH);
        GL11.glClearDepth(1.0f);
        GL11.glEnable(GL11.GL_DEPTH_TEST);
        GL11.glDepthFunc(GL11.GL_LEQUAL);
        GL11.glHint(GL11.GL_PERSPECTIVE_CORRECTION_HINT, GL11.GL_NICEST);
        GL11.glTexParameteri(GL11.GL_TEXTURE_2D, GL11.GL_TEXTURE_WRAP_S, GL11.GL_CLAMP);
    }

    private void set2DOpenGL()
    {
        GL11.glEnable(GL11.GL_TEXTURE_2D);
        GL11.glShadeModel(GL11.GL_SMOOTH);
        GL11.glDisable(GL11.GL_DEPTH_TEST);
        GL11.glDisable(GL11.GL_LIGHTING);

        GL11.glClearDepth(1);

        GL11.glEnable(GL11.GL_BLEND);
        GL11.glBlendFunc(GL11.GL_SRC_ALPHA, GL11.GL_ONE_MINUS_SRC_ALPHA);

        GL11.glViewport(0,0,width,height);
        GL11.glMatrixMode(GL11.GL_MODELVIEW);

        GL11.glMatrixMode(GL11.GL_PROJECTION);
        GL11.glLoadIdentity();
        GL11.glOrtho(0, width, height, 0, 1, -1);
        GL11.glMatrixMode(GL11.GL_MODELVIEW);
    }

    private void drawReticle()
    {
        GL11.glColor3d(0, 0, 0);
        GL11.glBegin(GL11.GL_LINES);
        float x = width / 2;
        float y = height / 2;
        float size = 10;

        GL11.glVertex2f(x - size, y);
        GL11.glVertex2f(x + size, y);
        GL11.glVertex2f(x, y - size);
        GL11.glVertex2f(x, y + size);

        GL11.glEnd();
        GL11.glColor3d(1, 1, 1);
    }

    public static void main(String[] argv)
    {
        Window timerExample = new Window();
        timerExample.start();
    }
}