package dam.test;

import java.nio.ByteBuffer;
import java.util.Random;

import org.lwjgl.BufferUtils;
import org.lwjgl.LWJGLException;
import org.lwjgl.opengl.Display;
import org.lwjgl.opengl.DisplayMode;
import org.lwjgl.opengl.PixelFormat;

import static org.lwjgl.opengl.GL11.*;
import static org.lwjgl.opengl.GL15.*;

public class VBOTest {
   
   private static final int WIDTH = 1600, HEIGHT = 900;
   private static final int POINTS_X = 400, POINTS_Y = 300;
   
   private static final int VERTEX_SIZE = 4*2 + 4; //12
   private static final int POSITION_OFFSET = 0;
   private static final int COLOR_OFFSET = 4*2;
   
   
   private ByteBuffer vertexData;
   
   private int vbo;
   private ByteBuffer reusableMappedBuffer;
   
   public VBOTest(){
      initDisplay();
      initPointData();
      initVBO();
   }

   private void initDisplay() {
      try {
         Display.setDisplayMode(new DisplayMode(WIDTH, HEIGHT));
         Display.create(new PixelFormat(24, 0, 0, 0, 0));
      } catch (LWJGLException e) {
         e.printStackTrace();
      }
   }
   
   private void initPointData() {
      vertexData = BufferUtils.createByteBuffer(POINTS_X * POINTS_Y * VERTEX_SIZE);
      System.out.println("Number of points: " + POINTS_X*POINTS_Y);
      
      Random r = new Random(); //Color randomizer.
      
      for(int y = 0; y < POINTS_Y; y++){
         for(int x = 0; x < POINTS_X; x++){
            vertexData.putFloat(x * 2f / POINTS_X - 1f); //Use the standard -1 to 1 coordinate system
            vertexData.putFloat(y * 2f / POINTS_Y - 1f);

            vertexData.put((byte)r.nextInt(256)); //Red
            vertexData.put((byte)r.nextInt(256)); //Green
            vertexData.put((byte)r.nextInt(256)); //Blue
            vertexData.put((byte)255); //Alpha = 1
         }
      }
      
      vertexData.flip();
   }

   private void initVBO() {
      vbo = glGenBuffers();
      //No need to do anything else, we'll do most of the VBO related stuff in updateVBO()
   }

   public void gameloop(){
      while(!Display.isCloseRequested()){
         
         glClearColor(0, 0, 0, 0);
         glClear(GL_COLOR_BUFFER_BIT);
         
         updateVBO();
         renderVBO();
         
         Display.update();
      }
   }

   private void updateVBO() {
      //Bind the VBO and create the data buffer
      glBindBuffer(GL_ARRAY_BUFFER, vbo);
      glBufferData(GL_ARRAY_BUFFER, vertexData.capacity(), GL_STREAM_DRAW);
      
      //Map the buffer
      reusableMappedBuffer = glMapBuffer(GL_ARRAY_BUFFER, GL_WRITE_ONLY, vertexData.capacity(), reusableMappedBuffer);
      
      //Copy the vertex data to the mapped buffer
      reusableMappedBuffer.put(vertexData);
      
      //Unmap the buffer
      glUnmapBuffer(GL_ARRAY_BUFFER);
      
      //Restore the position of both ByteBuffers
      reusableMappedBuffer.flip();
      vertexData.flip();
   }
   
   private void renderVBO() {
      //Bind the buffer (unnecessary, the buffer is already bound since updateVBO(), but...)
      glBindBuffer(GL_ARRAY_BUFFER, vbo);
      
      //Setup vertex attribute pointers
      glVertexPointer(2, GL_FLOAT, VERTEX_SIZE, POSITION_OFFSET);
      glColorPointer(4, GL_UNSIGNED_BYTE, VERTEX_SIZE, COLOR_OFFSET);

      glEnableClientState(GL_VERTEX_ARRAY);
      glEnableClientState(GL_COLOR_ARRAY);
      
      glPointSize(40);
      glDrawArrays(GL_POINTS, 0, POINTS_X*POINTS_Y);
   }

   public static void main(String[] args){
      new VBOTest().gameloop();
   }
}