/* Game.java */
public class Game
{
   private final int DEFAULT_FPS = 60;

   private int width;
   private int height;
   private String title;

   private boolean running;
   private int targetFPS;

   public static MatrixData matrixData;

   public Game(int width, int height, String title)
   {
      this.width = width;
      this.height = height;
      this.title = title;
   }

   private void start()
   {
      if (this.isRunning())
      {
         return;
      }

      this.initGL();
      this.initGame();
      this.run();
   }

   public void stop()
   {
      this.running = false;
   }

   private void initGL()
   {
      try
      {
         PixelFormat pixelFormat = new PixelFormat();
         ContextAttribs contextAttributes = new ContextAttribs(3, 2);
         contextAttributes.withForwardCompatible(true);
         contextAttributes.withProfileCore(true);

         Display.setDisplayMode(new DisplayMode(this.width, this.height));
         Display.setTitle(this.title);
         Display.create(pixelFormat, contextAttributes);

         GL11.glViewport(0, 0, this.width, this.height);
      } catch (LWJGLException e)
      {
         e.printStackTrace();
         System.exit(1);
      }

      GL11.glClearColor(0.1F, 0.1F, 0.15F, 1.0F);
      GL11.glViewport(0, 0, this.width, this.height);

      Game.matrixData = new MatrixData();
      Game.matrixData.setupMatrices(60F, ((float) width / (float) height), 0.1F, 100.0F);
      
      Game.exitOnGLError("InitGL");
   }

   private void initGame()
   {
      this.targetFPS = GraphicsEnvironment.getLocalGraphicsEnvironment().getDefaultScreenDevice().getDisplayMode().getRefreshRate();
      if (this.targetFPS == java.awt.DisplayMode.REFRESH_RATE_UNKNOWN)
      {
         this.targetFPS = this.DEFAULT_FPS;
      }

      Screen.screens.push(new GameScreen());

      this.running = true;
   }

   private void run()
   {
      while (this.isRunning())
      {
         this.update();
         this.render();

         Display.sync(this.targetFPS);
         Display.update();
      }

      this.cleanup();
   }

   private void update()
   {
      if (Display.isCloseRequested())
      {
         this.stop();
      }

      // -- Input processing
      float rotationDelta = 15f;
      float scaleDelta = 0.1f;
      float posDelta = 0.1f;
      Vector3f scaleAddResolution = new Vector3f(scaleDelta, scaleDelta, scaleDelta);
      Vector3f scaleMinusResolution = new Vector3f(-scaleDelta, -scaleDelta, -scaleDelta);

      Keyboard.poll();
      while (Keyboard.next())
      {
         // Only listen to events where the key was pressed (down event)
         if (!Keyboard.getEventKeyState())
            continue;

         // Change model scale, rotation and translation values
         switch (Keyboard.getEventKey())
         {
         // Move
         case Keyboard.KEY_UP:
            matrixData.modelPos.y += posDelta;
            break;
         case Keyboard.KEY_DOWN:
            matrixData.modelPos.y -= posDelta;
            break;
         // Scale
         case Keyboard.KEY_P:
            Vector3f.add(matrixData.modelScale, scaleAddResolution, matrixData.modelScale);
            break;
         case Keyboard.KEY_M:
            Vector3f.add(matrixData.modelScale, scaleMinusResolution, matrixData.modelScale);
            break;
         // Rotation
         case Keyboard.KEY_LEFT:
            matrixData.modelAngle.z += rotationDelta;
            break;
         case Keyboard.KEY_RIGHT:
            matrixData.modelAngle.z -= rotationDelta;
            break;
         }
      }

      Game.matrixData.updateMatrices();
      
      if (!Screen.screens.empty())
      {
         Iterator<Screen> itr = Screen.screens.iterator();
         while (itr.hasNext())
         {
            Screen screen = itr.next();
            if (!screen.isPaused())
            {
               screen.update();
            }
         }
      }
      
      Game.exitOnGLError("Update");
   }

   private void render()
   {
      GL11.glClear(GL11.GL_COLOR_BUFFER_BIT);

      if (!Screen.screens.empty())
      {
         Iterator<Screen> itr = Screen.screens.iterator();
         while (itr.hasNext())
         {
            Screen screen = itr.next();
            if (!screen.isHidden())
            {
               screen.render();
            }
         }
      }
      
      Game.exitOnGLError("Render");
   }

   private void cleanup()
   {
      /* Delete textures */
      for (Texture texture : Texture.toDelete)
      {
         GL11.glDeleteTextures(texture.getID());
      }

      /* Delete shader's */
      GL20.glUseProgram(0);
      for (ShaderProgram shader : ShaderProgram.toDelete)
      {
         GL20.glDetachShader(shader.getID(), shader.getVertexShader().getID());
         GL20.glDetachShader(shader.getID(), shader.getFragmentShader().getID());

         GL20.glDeleteShader(shader.getVertexShader().getID());
         GL20.glDeleteShader(shader.getFragmentShader().getID());
         GL20.glDeleteProgram(shader.getID());
      }
      ShaderProgram.toDelete.clear();

      /* Delete buffers and arrays */
      for (VertexArray vertexArray : VertexArray.toDelete)
      {
         GL30.glBindVertexArray(vertexArray.getID());
         boolean[] enabled = vertexArray.getAttributes();
         for (int i = 0; i < enabled.length; i++)
         {
            if (enabled[i])
            {
               GL20.glDisableVertexAttribArray(i);
            }
         }

         for (VertexBuffer buffer : vertexArray.getVertexBuffers())
         {
            GL15.glBindBuffer(GL15.GL_ARRAY_BUFFER, 0);
            GL15.glDeleteBuffers(buffer.getID());

            GL15.glBindBuffer(GL15.GL_ELEMENT_ARRAY_BUFFER, 0);
            GL15.glDeleteBuffers(buffer.getID());
         }

         GL30.glBindVertexArray(0);
         GL30.glDeleteVertexArrays(vertexArray.getID());
      }
      VertexArray.toDelete.clear();

      /* Destroy the Display */
      System.out.println("Closing...");
      Display.destroy();
   }

   public int getWidth()
   {
      return this.width;
   }

   public int getHeight()
   {
      return this.height;
   }

   public String getTitle()
   {
      return this.title;
   }

   public boolean isRunning()
   {
      return this.running;
   }

   public static MatrixData getMatrixData()
   {
      return Game.matrixData;
   }

   public static void exitOnGLError(String errorMessage) {
      int errorValue = GL11.glGetError();
      
      if (errorValue != GL11.GL_NO_ERROR) {
         String errorString = GLU.gluErrorString(errorValue);
         System.err.println("ERROR - " + errorMessage + ": " + errorString);
         
         if (Display.isCreated()) Display.destroy();
         System.exit(-1);
      }
   }
   
   public static void main(String[] args)
   {
      new Game(400, 400, "Game").start();
   }
}

/* MatrixData.java */
public class MatrixData
{
   private final double PI = 3.14159265358979323846;
   
   public int projectionMatrixLocation;
   public Matrix4f projectionMatrix;
   
   public int viewMatrixLocation;
   public Matrix4f viewMatrix;
   
   public int modelMatrixLocation;
   public Matrix4f modelMatrix;
   
   public Vector3f modelPos;
   public Vector3f modelAngle;
   public Vector3f modelScale;
   public Vector3f cameraPos;
   
   public FloatBuffer matrix44Buffer;
   
   public int shaderID;
   
   public MatrixData()
   {
   }
   
   public void setupMatrices(float fov, float aspectRatio, float zNear, float zFar)
   {
      System.out.println("FOV: " + fov + " AspectRatio: " + aspectRatio + " zNear: " + zNear + " zFar: " + zFar);
      
      this.projectionMatrix = new Matrix4f();
      
      float yScale = this.coTangent(this.degreesToRadians(fov / 2F));
      float xScale = yScale / aspectRatio;
      float frustumLength = zFar - zNear;
      
      this.projectionMatrix.m00 = xScale;
      this.projectionMatrix.m11 = yScale;
      this.projectionMatrix.m22 = -((zFar + zNear) / frustumLength);
      this.projectionMatrix.m23 = -1;
      this.projectionMatrix.m32 = ((2 * zNear * zFar) / frustumLength);
      
      this.viewMatrix = new Matrix4f();
      this.modelMatrix = new Matrix4f();
      
      this.matrix44Buffer = BufferUtils.createFloatBuffer(16);
      
      this.modelPos = new Vector3f(0.0F, 0.0F, 0.0F);
      this.modelAngle = new Vector3f(0.0F, 0.0F, 0.0F);
      this.modelScale = new Vector3f(1.0F, 1.0F, 1.0F);
      this.cameraPos = new Vector3f(0.0F, 0.0F, 0.0F);
   }
   
   public void updateMatrices()
   {
      this.viewMatrix = new Matrix4f();
      this.modelMatrix = new Matrix4f();
      
      Matrix4f.translate(this.cameraPos, this.viewMatrix, this.viewMatrix);
      
      Matrix4f.scale(this.modelScale, this.modelMatrix, this.modelMatrix);
      Matrix4f.translate(this.modelPos, this.modelMatrix, this.modelMatrix);
      Matrix4f.rotate(this.degreesToRadians(this.modelAngle.z), new Vector3f(0, 0, 1), this.modelMatrix, this.modelMatrix);
      Matrix4f.rotate(this.degreesToRadians(this.modelAngle.y), new Vector3f(0, 1, 0), this.modelMatrix, this.modelMatrix);
      Matrix4f.rotate(this.degreesToRadians(this.modelAngle.x), new Vector3f(1, 0, 0), this.modelMatrix, this.modelMatrix);
      
      GL20.glUseProgram(this.shaderID);

      projectionMatrix.store(matrix44Buffer);
      matrix44Buffer.flip();
      GL20.glUniformMatrix4(projectionMatrixLocation, false, matrix44Buffer);

      viewMatrix.store(matrix44Buffer);
      matrix44Buffer.flip();
      GL20.glUniformMatrix4(viewMatrixLocation, false, matrix44Buffer);

      modelMatrix.store(matrix44Buffer);
      matrix44Buffer.flip();
      GL20.glUniformMatrix4(modelMatrixLocation, false, matrix44Buffer);

      GL20.glUseProgram(0);
   }
   
   private float coTangent(float angle)
   {
      return (float) (1.0F / Math.tan(angle));
   }

   private float degreesToRadians(float degrees)
   {
      return degrees * (float) (PI / 180D);
   }
}

/* GameScreen.java */
public class GameScreen extends Screen
{
   public static final String name = "GameScreen";

   private VertexArray vao;
   private VertexBuffer vbo;
   private VertexBuffer vboI;

   private Quad quad;

   private ShaderProgram shaderProgram;
   private Texture texture;

   public GameScreen()
   {
      super(name);
   }

   @Override
   public void initialise()
   {
      this.quad = new Quad(new Vector3f(0, 0, 0), 1);
      this.quad.create();
      this.quad.setIndices(new byte[] { 0, 1, 2, 2, 3, 0 });
      this.vao = new VertexArray();

      GL30.glBindVertexArray(this.vao.getID());

      this.vbo = new VertexBuffer();
      GL15.glBindBuffer(GL15.GL_ARRAY_BUFFER, this.vbo.getID());
      GL15.glBufferData(GL15.GL_ARRAY_BUFFER, this.quad.getVerticesBuffer(), GL15.GL_STREAM_DRAW);

      GL20.glVertexAttribPointer(0, VertexData.positionElementCount, GL11.GL_FLOAT, false, VertexData.stride, VertexData.positionByteOffset);
      this.vao.setAttribute(0, true);

      GL20.glVertexAttribPointer(1, VertexData.colorElementCount, GL11.GL_FLOAT, false, VertexData.stride, VertexData.colorByteOffset);
      this.vao.setAttribute(1, true);

      GL20.glVertexAttribPointer(2, VertexData.textureElementCount, GL11.GL_FLOAT, false, VertexData.stride, VertexData.textureByteOffset);
      this.vao.setAttribute(2, true);

      GL15.glBindBuffer(GL15.GL_ARRAY_BUFFER, 0);
      GL30.glBindVertexArray(0);

      this.vboI = new VertexBuffer();
      GL15.glBindBuffer(GL15.GL_ELEMENT_ARRAY_BUFFER, this.vboI.getID());
      GL15.glBufferData(GL15.GL_ELEMENT_ARRAY_BUFFER, this.quad.getIndicesBuffer(), GL15.GL_STATIC_DRAW);
      GL15.glBindBuffer(GL15.GL_ELEMENT_ARRAY_BUFFER, 0);

      this.shaderProgram = new ShaderProgram();
      this.shaderProgram.setVertexShader(new VertexShader("/vertex.glsl"));
      this.shaderProgram.setFragmentShader(new FragmentShader("/fragment.glsl"));
      GL20.glLinkProgram(this.shaderProgram.getID());

      GL20.glBindAttribLocation(this.shaderProgram.getID(), 0, "in_Position");
      GL20.glBindAttribLocation(this.shaderProgram.getID(), 1, "in_Color");
      GL20.glBindAttribLocation(this.shaderProgram.getID(), 2, "in_TextureCoord");

      Game.matrixData.projectionMatrixLocation = GL20.glGetUniformLocation(this.shaderProgram.getID(), "projectionMatrix");
      Game.matrixData.viewMatrixLocation = GL20.glGetUniformLocation(this.shaderProgram.getID(), "viewMatrix");
      Game.matrixData.modelMatrixLocation = GL20.glGetUniformLocation(this.shaderProgram.getID(), "modelMatrix");

      GL20.glValidateProgram(this.shaderProgram.getID());

      Game.matrixData.shaderID = this.shaderProgram.getID();
      
      this.texture = TextureLoader.loadTexture("/texture.png", GL13.GL_TEXTURE0);
      
      Game.exitOnGLError("Initialise");
      
   }

   @Override
   public void update()
   {
      Game.exitOnGLError("Update");
   }

   @Override
   public void render()
   {
      GL20.glUseProgram(shaderProgram.getID());

      GL13.glActiveTexture(GL13.GL_TEXTURE0);
      GL11.glBindTexture(GL11.GL_TEXTURE_2D, this.texture.getID());

      GL30.glBindVertexArray(this.vao.getID());
      GL20.glEnableVertexAttribArray(0);
      GL20.glEnableVertexAttribArray(1);
      GL20.glEnableVertexAttribArray(2);

      GL15.glBindBuffer(GL15.GL_ELEMENT_ARRAY_BUFFER, this.vbo.getID());

      GL11.glDrawElements(GL11.GL_TRIANGLES, this.quad.getIndices().length, GL11.GL_UNSIGNED_BYTE, 0);

      GL15.glBindBuffer(GL15.GL_ELEMENT_ARRAY_BUFFER, 0);
      GL20.glDisableVertexAttribArray(0);
      GL20.glDisableVertexAttribArray(1);
      GL20.glDisableVertexAttribArray(2);
      GL30.glBindVertexArray(0);

      GL20.glUseProgram(0);

      Game.exitOnGLError("Render");
   }
}

/* Quad */
public class Quad
{

   private VertexData[] vertices;
   private byte[] indices;
   
   private Vector3f position;
   private int size;
   
   public Quad(Vector3f position, int size)
   {
      this.position = position;
      this.size = size;
   }
   
   public void create()
   {
      float x = this.position.x;
      float y = this.position.y;
      float z = this.position.z;
      
      VertexData v0 = new VertexData();
      VertexData v1 = new VertexData();
      VertexData v2 = new VertexData();
      VertexData v3 = new VertexData();

      v0.setXYZ(x, y, z);
      v1.setXYZ(x, y + size, z);
      v2.setXYZ(x + size, y + size, z);
      v3.setXYZ(x + size, y, z);
      
      v0.setRGB(1.0F, 0.0F, 0.0F);
      v1.setRGB(1.0F, 0.0F, 0.0F);
      v2.setRGB(1.0F, 0.0F, 0.0F);
      v3.setRGB(1.0F, 0.0F, 0.0F);
      
      v0.setST(0, 0);
      v0.setST(0, 1);
      v0.setST(1, 1);
      v0.setST(1, 0);
      
      this.vertices = new VertexData[] { v0, v1, v2, v3 };
   }
   
   public VertexData[] getVertices()
   {
      return this.vertices;
   }
   
   public byte[] getIndices()
   {
      return this.indices;
   }
   
   public void setIndices(byte[] indices)
   {
      this.indices = indices;
   }
   
   public FloatBuffer getVerticesBuffer()
   {
      ByteBuffer byteBuffer = BufferUtils.createByteBuffer(this.vertices.length * VertexData.stride);
      FloatBuffer floatBuffer = byteBuffer.asFloatBuffer();
      for (int i = 0; i < this.vertices.length; i++)
      {
         floatBuffer.put(vertices[i].getElements());
      }
      floatBuffer.flip();
      
      return floatBuffer;
   }
   
   public ByteBuffer getIndicesBuffer()
   {
      ByteBuffer buffer = BufferUtils.createByteBuffer(this.indices.length);
      buffer.put(this.indices);
      buffer.flip();
      return buffer;
   }
}

/* VertexArray.java */
public class VertexArray
{
   public static Set<VertexArray> toDelete = new HashSet<VertexArray>();

   private int id;
   
   private Set<VertexBuffer> buffers;
   private boolean[] attributes;
   
   public VertexArray()
   {
      this.buffers = new HashSet<VertexBuffer>();
      this.attributes = new boolean[16];
      this.id = GL30.glGenVertexArrays();
      
      VertexArray.toDelete.add(this);
   }
   
   public int getID()
   {
      return this.id;
   }
   
   public Set<VertexBuffer> getVertexBuffers()
   {
      return this.buffers;
   }
   
   public boolean[] getAttributes()
   {
      return this.attributes;
   }
   
   public void setAttribute(int index, boolean bool)
   {
      this.attributes[index] = bool;
   }
}

/* VertexBuffer.java */
public class VertexBuffer
{
   public static final Set<VertexBuffer> toDelete = new HashSet<VertexBuffer>();
   
   private int id;
   
   public VertexBuffer()
   {
      this.id = GL15.glGenBuffers();
      VertexBuffer.toDelete.add(this);
   }
   
   public int getID()
   {
      return this.id;
   }
}

/* ShaderProgram.java */
public class ShaderProgram
{
   public static final Set<ShaderProgram> toDelete = new HashSet<ShaderProgram>();
   
   private int programID;

   private VertexShader vertexShader;
   private FragmentShader fragmentShader;

   public ShaderProgram()
   {
      this.programID = GL20.glCreateProgram();
      ShaderProgram.toDelete.add(this);
   }
   
   public int getID()
   {
      return this.programID;
   }

   public VertexShader getVertexShader()
   {
      return this.vertexShader;
   }

   public void setVertexShader(VertexShader vertexShader)
   {
      if (this.vertexShader != null)
      {
         GL20.glDetachShader(this.programID, this.vertexShader.getID());
         GL20.glDeleteShader(this.vertexShader.getID());
      }
      
      this.vertexShader = vertexShader;
      GL20.glAttachShader(this.programID, this.vertexShader.getID());
   }

   public FragmentShader getFragmentShader()
   {
      return this.fragmentShader;
   }

   public void setFragmentShader(FragmentShader fragmentShader)
   {
      if (this.fragmentShader != null)
      {
         GL20.glDetachShader(this.programID, this.fragmentShader.getID());
         GL20.glDeleteShader(this.fragmentShader.getID());
      }
      
      this.fragmentShader = fragmentShader;
      GL20.glAttachShader(this.programID, this.fragmentShader.getID());
   }

   @SuppressWarnings("deprecation")
   public static int loadShader(String filepath, int type)
   {
      StringBuilder sb = new StringBuilder();
      int shaderID = 0;
      
      try
      {
         BufferedReader reader = new BufferedReader(new InputStreamReader(ShaderProgram.class.getResourceAsStream(filepath)));
         String line;
         while ((line = reader.readLine()) != null)
         {
            sb.append(line).append("\n");
         }
         reader.close();
         
      } catch (IOException e)
      {
         e.printStackTrace();
         System.exit(1);
      }
      
      shaderID = GL20.glCreateShader(type);
      GL20.glShaderSource(shaderID, sb.toString());
      GL20.glCompileShader(shaderID);
      
      if (GL20.glGetShader(shaderID, GL20.GL_COMPILE_STATUS) == GL11.GL_FALSE)
      {
         System.err.println("Shader could not be compiled.  " + filepath);
         System.exit(1);
      }
      
      return shaderID;
   }
}