// whatever package
import static org.lwjgl.opengl.GL11.GL_MODELVIEW;
import static org.lwjgl.opengl.GL11.GL_PROJECTION;
import static org.lwjgl.opengl.GL11.glLoadIdentity;
import static org.lwjgl.opengl.GL11.glMatrixMode;
import static org.lwjgl.util.glu.GLU.gluPerspective;

import java.nio.FloatBuffer;

import org.lwjgl.BufferUtils;
import org.lwjgl.LWJGLException;
import org.lwjgl.opengl.Display;
import org.lwjgl.opengl.DisplayMode;
import org.lwjgl.opengl.GL11;
import org.lwjgl.opengl.GL15;
import org.lwjgl.opengl.GL20;
import org.lwjgl.opengl.GL30;

public class Test
{
   public static final int WIDTH = 800;
   public static final int HEIGHT = 600;

   public static final String TITLE = "Learning OpenGL";

   public static final boolean FULLSCREEN = false;
   public static final boolean RESIZABLE = false;
   public static final boolean VSYNC = false;

   public static final int TARGET_FPS = 60;

   private int program;

   private int vertexBuffer;
   private int vertexArray;

   private float[] vertexPositions = new float[] { 0.75f, 0.75f, -10f, 1.0f, 0.75f, -0.75f, -10f, 1.0f, -0.75f, -0.75f, -10f, 1.0f };

   // modern shaders
   // private String vertexShader = "#version 330\n" + "layout(location = 0) in vec4 position;\n" + "void main()\n" + "{\n" + "   gl_Position = position;\n" + "}\n";
   // private String fragmentShader = "#version 330\n" + "out vec4 outputColor;\n" + "void main()\n" + "{\n" + "   outputColor = vec4(1.0f, 1.0f, 1.0f, 1.0f);\n" + "}\n";

   /*
    * older shaders(they still work though)
    * gl_Vertex is a built in attribute for the actual vertex position.
    * gl_ModelViewProjection matrix is the built in matrix uniform(it is the product of the model view and projection matrices)
    */
   private String vertexShader2 = "#version 110\n" + "void main()\n" + "{\n" + "gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;\n" + "}\n";
   private String fragShader2 = "#version 110\n" + "void main()\n" + "{\n" + "gl_FragColor = vec4(1.0, 1.0, 1.0, 1.0);\n" + "}\n";

   private int createShader(int type, String code)
   {
      int shader;

      shader = GL20.glCreateShader(type);

      GL20.glShaderSource(shader, code);
      GL20.glCompileShader(shader);

      if (GL20.glGetShaderi(shader, GL20.GL_COMPILE_STATUS) == GL11.GL_FALSE)
      {
         System.out.println("Failed to compile a shader.");
         System.out.println(GL20.glGetShaderInfoLog(shader, 5000));
         System.exit(1);
      }

      return shader;
   }

   private int createShaderProgram(int[] shaders)
   {

      int program;

      program = GL20.glCreateProgram();

      for (int shader : shaders)
         GL20.glAttachShader(program, shader);

      GL20.glLinkProgram(program);

      if (GL20.glGetProgrami(program, GL20.GL_LINK_STATUS) == GL11.GL_FALSE)
      {
         System.out.println("Failed to link a program.");
         System.exit(1);
      }

      for (int shader : shaders)
         GL20.glDetachShader(program, shader);

      return program;
   }

   /*
    * Initialize the vertex buffer, that reads the vertex positions from the compiled shaders
    */
   public void initializeBuffer()
   {
      vertexBuffer = GL15.glGenBuffers();

      FloatBuffer vertexPositionsBuffer = BufferUtils.createFloatBuffer(vertexPositions.length);
      vertexPositionsBuffer.put(vertexPositions);

      // NEVER forget to flip your buffers for OpenGL!
      vertexPositionsBuffer.flip();

      GL15.glBindBuffer(GL15.GL_ARRAY_BUFFER, vertexBuffer);
      GL15.glBufferData(GL15.GL_ARRAY_BUFFER, vertexPositionsBuffer, GL15.GL_STATIC_DRAW);
      GL15.glBindBuffer(GL15.GL_ARRAY_BUFFER, 0);
   }

   /*
    * Initialize the program by compiling shaders and linking the shader program
    */
   public void initializeProgram()
   {
      int[] shaderList = new int[] { createShader(GL20.GL_VERTEX_SHADER, vertexShader2), createShader(GL20.GL_FRAGMENT_SHADER, fragShader2) };

      program = createShaderProgram(shaderList);

      vertexArray = GL30.glGenVertexArrays();
      GL30.glBindVertexArray(vertexArray);
   }

   /*
    * Display the triangle in the window
    */
   public void displayTriangle()
   {
      GL11.glClearColor(0.0f, 0.0f, 0.0f, 0.0f);
      GL11.glClear(GL11.GL_COLOR_BUFFER_BIT);

      GL20.glUseProgram(program);

      GL15.glBindBuffer(GL15.GL_ARRAY_BUFFER, vertexBuffer);
      GL20.glEnableVertexAttribArray(0);
      GL20.glVertexAttribPointer(0, 4, GL11.GL_FLOAT, false, 0, 0);

      GL11.glDrawArrays(GL11.GL_TRIANGLES, 0, 3);

      GL20.glDisableVertexAttribArray(0);
      GL20.glUseProgram(0);
   }

   public Test()
   {

      try
      {
         Display.setDisplayMode(new DisplayMode(WIDTH, HEIGHT));
         Display.setTitle(TITLE);
         Display.setFullscreen(FULLSCREEN);
         Display.setResizable(RESIZABLE);
         Display.setVSyncEnabled(VSYNC);

         Display.create();
      } catch (LWJGLException e)
      {
         System.out.println("Display initialization error.");
         System.exit(0);
      }

      /*
       * This is the main change. Define the projection matrix.
       */
      glMatrixMode(GL_PROJECTION);
      glLoadIdentity();
      gluPerspective(70, WIDTH / HEIGHT, 0.1f, 1000f);
      glMatrixMode(GL_MODELVIEW);

      initializeProgram();
      initializeBuffer();

      while (!Display.isCloseRequested())
      {
         displayTriangle();
         Display.update();
         Display.sync(TARGET_FPS);
      }
   }

   public static void main(String[] args)
   {
      new Test();
   }
}

package gel.engine.core;

import gel.engine.graphics.RenderingEngine;

import static org.lwjgl.opengl.GL11.*;
import gel.engine.input.Input;
import gel.engine.window.Window;

public abstract class Core
{

   private static Core instance;

   protected boolean running;
   protected int targetFps;
   protected int targetUps;
   protected ProfileTimer profileTimer;
   protected Window window;
   protected Input input;
   protected RenderingEngine renderingEngine;

   public Core()
   {
      if (instance == null)
      {

         instance = this;

         this.running = false;
         this.targetFps = -1;
         this.targetUps = 60;

         window = new Window();

      } else
      {
         throw new IllegalStateException("Can not make more than one instance of Core");
      }
   }

   public static Core getInstance()
   {
      return instance;
   }

   public static boolean created()
   {
      return (instance == null);
   }

   public boolean isRunning()
   {
      return running;
   }

   public int getTargetFps()
   {
      return targetFps;
   }

   public int getTargetUps()
   {
      return targetUps;
   }

   public ProfileTimer getProfileTimer()
   {
      return profileTimer;
   }

   public Window getWindow()
   {
      return window;
   }

   public Input getInput()
   {
      return input;
   }

   public RenderingEngine getRenderingEngine()
   {
      return renderingEngine;
   }

   public void setTargetFps(int target)
   {
      if (!running)
      {
         this.targetFps = target;
      }
   }

   public void setTargetUps(int target)
   {
      if (!running)
      {
         this.targetUps = target;
      }
   }

   public void start()
   {
      run();
   }

   public void stop()
   {
      running = false;
   }

   private void run()
   {

      // initialize the engine
      initEngine();

      running = true;

      long lastSecond = System.nanoTime();
      long thisFrame = System.nanoTime();
      long lastFrame = System.nanoTime();
      double updateTime = 1e9f / targetUps;
      double renderTime = 1e9f / targetFps;
      double accumulativeUpdateTime = 0;
      double accumulativeFrameTime = 0;
      long sleepTime = 0;
      int updateCount = 0;
      int frameCount = 0;

      while (running)
      {

         // Get the delta between this frame and last frame
         thisFrame = System.nanoTime();
         profileTimer.updateDelta(thisFrame, lastFrame);
         lastFrame = thisFrame;

         // Accumulate the delta in the update and render accumulate variables.
         accumulativeUpdateTime += profileTimer.getDelta();
         accumulativeFrameTime += profileTimer.getDelta();

         // Update and take into account any missed frames.
         if (targetUps != -1)
         {
            while (accumulativeUpdateTime >= updateTime)
            {
               updateGame();
               updateCount++;
               accumulativeUpdateTime -= updateTime;
            }
         } else
         {
            updateGame();
            updateCount++;
            accumulativeUpdateTime = 0;
         }

         // Render if possible.
         if (targetFps != -1)
         {
            if (accumulativeFrameTime >= renderTime)
            {
               renderGame();
               frameCount++;
               accumulativeFrameTime = 0;
            } else
            {

               // Calculate sleep time and sleep for that amount.

               sleepTime = Math.round((renderTime - accumulativeFrameTime) / (1024 * 1024));

               try
               {
                  Thread.sleep(sleepTime);
               } catch (InterruptedException e)
               {
                  e.printStackTrace();
               }

            }
         } else
         {
            renderGame();
            frameCount++;
            accumulativeFrameTime = 0;
         }

         // Check if a second has passed, and if so, update fps and ups.
         if (System.nanoTime() - lastSecond >= 1e9)
         {
            profileTimer.updateFps(frameCount);
            profileTimer.updateUps(updateCount);
            frameCount = 0;
            updateCount = 0;
            lastSecond = System.nanoTime();
         }

         // Check if the game needs to stop.
         if (window.isCloseRequested())
         {
            stop();
         }

      }

      // Unload the game content.
      unloadGame();

   }

   private void initEngine()
   {

      // create gl context and initialize rendering engine

      window.create();

      renderingEngine = new RenderingEngine();
      profileTimer = new ProfileTimer();
      input = new Input();
      input.create();

      // load game content
      loadGame();
   }

   private void loadGame()
   {
      load();
   }

   private void updateGame()
   {
      input.update();
      update();
   }

   private void renderGame()
   {
      glClear(GL_COLOR_BUFFER_BIT);
      renderingEngine.update();
      render();
      window.update();
      
   }

   private void unloadGame()
   {
      unload();
   }

   public abstract void load();

   public abstract void update();

   public abstract void render();

   public abstract void unload();

}

package gel.engine.graphics;

import static org.lwjgl.opengl.GL11.*;
import static org.lwjgl.opengl.GL11.glDisable;
import gel.engine.core.Core;
import gel.engine.graphics.lighting.AmbientLight;
import gel.engine.graphics.lighting.PointLight;
import gel.engine.graphics.matrix.RotationMatrix;
import gel.engine.graphics.matrix.ScaleMatrix;
import gel.engine.graphics.matrix.TransformationMatrix;
import gel.engine.graphics.matrix.TranslationMatrix;
import gel.engine.math.Vector2f;

public class RenderingEngine
{

   public static final String UNIFORM_MODEL_MATRIX = "modelMatrix";
   public static final String UNIFORM_VIEW_MATRIX = "viewMatrix";
   public static final String UNIFORM_PROJECTION_MATRIX = "projectionMatrix";

   public static final String UNIFORM_AMBIENTCOLOR = "ambientColor";

   private static RenderingEngine instance;

   private VertexArray vertexArray;
   private OrthographicCamera camera;
   private ShaderProgram ambientShader;
   private ShaderProgram pointLightShader;

   private AmbientLight ambient;

   public RenderingEngine()
   {
      if (instance == null)
      {
         instance = this;

         vertexArray = new VertexArray();
         camera = new OrthographicCamera(0, Core.getInstance().getWindow().getWidth(), 0, Core.getInstance().getWindow().getHeight(), 1, -1);

         ambientShader = new ShaderProgram();
         ambientShader.createAndCompileVertexShader("res\\shaders\\ambientShader.vs");
         ambientShader.createAndCompileFragmentShader("res\\shaders\\ambientShader.fs");
         ambientShader.linkProgram();

         pointLightShader = new ShaderProgram();
         pointLightShader.createAndCompileVertexShader("res\\shaders\\pointLightShader.vs");
         pointLightShader.createAndCompileFragmentShader("res\\shaders\\pointLightShader.fs");
         pointLightShader.linkProgram();

         ambient = new AmbientLight(new Color(255, 255, 255));

      } else
      {
         throw new IllegalStateException("Can not make more than one instance of RenderingEngine");
      }
   }

   public static RenderingEngine getInstance()
   {
      return instance;
   }

   public OrthographicCamera getCamera()
   {
      return camera;
   }

   public AmbientLight getAmbientLight()
   {
      return ambient;
   }

   public void update()
   {
      camera.update();

      ambientShader.setMatrix4f(UNIFORM_VIEW_MATRIX, camera.getViewMatrix().getMatrix());
      ambientShader.setMatrix4f(UNIFORM_PROJECTION_MATRIX, camera.getProjectionMatrix().getMatrix());

      pointLightShader.setMatrix4f(UNIFORM_VIEW_MATRIX, camera.getViewMatrix().getMatrix());
      pointLightShader.setMatrix4f(UNIFORM_PROJECTION_MATRIX, camera.getProjectionMatrix().getMatrix());

   }

   // update uniforms for rendering passes

   public void renderTexture(Texture t, float x, float y, float rotation)
   {
      if (x + t.getWidth() >= 0 && x < Core.getInstance().getWindow().getWidth() + t.getWidth() && y + t.getHeight() >= 0 && y < Core.getInstance().getWindow().getHeight() + t.getHeight())
      {
         ambientShader.bind();
         vertexArray.clear();
         
         vertexArray.addVertex(new Vertex(new Vector2f(-t.getWidth() / 2, -t.getHeight() / 2), new Color(0), new Vector2f(1, 1)));
         vertexArray.addVertex(new Vertex(new Vector2f(-t.getWidth() / 2, t.getHeight() / 2), new Color(0), new Vector2f(1, 0)));
         vertexArray.addVertex(new Vertex(new Vector2f(t.getWidth() / 2, t.getHeight() / 2), new Color(0), new Vector2f(0, 0)));
         vertexArray.addVertex(new Vertex(new Vector2f(t.getWidth() / 2, -t.getHeight() / 2), new Color(0), new Vector2f(0, 1)));
         
         ambientShader.setMatrix4f(UNIFORM_MODEL_MATRIX, new TransformationMatrix(new TranslationMatrix(x + t.getWidth() / 2, y + t.getHeight() / 2), new RotationMatrix(rotation), new ScaleMatrix(1, 1)).getMatrix());
         ambientShader.setVector3f(UNIFORM_AMBIENTCOLOR, ambient.getColor().toVector3f());
         
         vertexArray.render();
      }
   }

   public void renderPointLight(PointLight light)
   {
      glEnable(GL_BLEND);
      glBlendFunc(GL_ONE, GL_ONE);
      if (light.getPosition().getX() + light.getRadius() >= 0 && light.getPosition().getX() < Core.getInstance().getWindow().getWidth() && light.getPosition().getY() + light.getRadius() >= 0 && light.getPosition().getY() < Core.getInstance().getWindow().getHeight())
      {
         pointLightShader.bind();
         vertexArray.clear();
         vertexArray.addVertex(new Vertex(new Vector2f(-light.getRadius(), -light.getRadius())));
         vertexArray.addVertex(new Vertex(new Vector2f(-light.getRadius(), light.getRadius())));
         vertexArray.addVertex(new Vertex(new Vector2f(light.getRadius(), light.getRadius())));
         vertexArray.addVertex(new Vertex(new Vector2f(light.getRadius(), -light.getRadius())));
         pointLightShader.setMatrix4f(UNIFORM_MODEL_MATRIX, new TransformationMatrix(new TranslationMatrix(light.getPosition().getX(), light.getPosition().getY()), new RotationMatrix(0), new ScaleMatrix(1, 1)).getMatrix());
         pointLightShader.setVector2f("pos", light.getPosition());
         pointLightShader.setVector3f("color", light.getColor().toVector3f());
         pointLightShader.setFloat("radius", light.getRadius());
         pointLightShader.setFloat("constant", light.getConstAtten());
         pointLightShader.setFloat("linear", light.getLinearAtten());
         pointLightShader.setFloat("quadratic", light.getQuadAtten());
         vertexArray.render();
      }
      glDisable(GL_BLEND);
   }

}

package game;

import static org.lwjgl.opengl.GL11.*;
import gel.engine.core.Core;
import gel.engine.graphics.Bitmap;
import gel.engine.graphics.Color;
import gel.engine.graphics.Texture;
import gel.engine.graphics.lighting.PointLight;
import gel.engine.math.Vector2f;

public class Game extends Core
{

   private Texture grass;
   private PointLight light;

   public static void main(String[] args)
   {
      Game g = new Game();
      g.getWindow().setTitle("Gel Engine");
      g.getWindow().setSize(16 * 60, 9 * 60);
      g.getWindow().setResizable(false);
      g.start();
   }

   @Override
   public void load()
   {
      grass = new Texture(new Bitmap("res\\grass.png"));
      light = new PointLight(new Vector2f(400, 400), new Color(255, 127, 0), 200, 0, 0, 0.01f); // pos, color, range, const, linear, quadratic attenuation
   }

   @Override
   public void update()
   {

   }

   @Override
   public void render()
   {
      renderingEngine.renderTexture(grass, 400, 400, 0);
      renderingEngine.renderPointLight(light);
   }

   @Override
   public void unload()
   {

   }

}

#version 110

uniform mat4 modelMatrix;
uniform mat4 viewMatrix;
uniform mat4 projectionMatrix;

void main()
{
   gl_Position = projectionMatrix * viewMatrix * modelMatrix * gl_Vertex;
   gl_TexCoord[0] = gl_MultiTexCoord0;
}

#version 110

uniform sampler2D textureSampler;
uniform vec3 ambientColor;

void main()
{
   gl_FragColor = vec4(ambientColor, 1.0) * texture2D(textureSampler, gl_TexCoord[0].st);
}

#version 110

uniform vec2 pos;
uniform vec3 color;
uniform float radius;
uniform float constant;
uniform float linear;
uniform float quadratic;

void main()
{

   float dist = distance(gl_FragCoord.xy, pos);
   float atten = 1.0 / (quadratic * dist * dist + linear * dist + constant);
   gl_FragColor = vec4(atten, atten, atten, 1.0) * vec4(color, 1.0);
}