import javax.swing.JFrame;
import javax.swing.SwingUtilities;

import javax.media.opengl.GL2;
import javax.media.opengl.GLAutoDrawable;
import javax.media.opengl.GLCapabilities;
import javax.media.opengl.GLDrawable;
import javax.media.opengl.GLEventListener;
import javax.media.opengl.GLProfile;
import javax.media.opengl.awt.GLCanvas;
import static javax.media.opengl.GL2.*;

public class test extends JFrame implements Runnable
{
  private GLCanvas canvas;

  public static long oldTime;

  public static long renderTime;

  private final int screenW = 800 , screenH = 600;

  /**
   * Serial version ID
   */
  static final long serialVersionUID = 20090529;

  public static final String[] fragShader = new String[] {
    "#version 330 core\n" +
    "in vec4 fragColor;\n" +
    "out vec4 color;\n" +
    "void main(void)\n" +
    "{\n" +
    "  color = fragColor;\n" +
    "}"};
  public static final String[] vertexShader = new String[] {
    "#version 330 core\n" +
    "layout (location = 0) in vec2 p0;\n" +
    "layout (location = 1) in vec2 p1;\n" +
    "layout (location = 2) in vec2 p2;\n" +
    "layout (location = 3) in vec4 color;\n" +
    "out vec4 fragColor;\n" +
    "void main(void)\n" +
    "{\n" +
    "  if(gl_VertexID == 0)\n" +
    "    gl_Position.xy = p0;\n" +
    "  else if(gl_VertexID == 1)\n" +
    "    gl_Position.xy = p1;\n" +
    "  else if(gl_VertexID == 2)\n" +
    "    gl_Position.xy = p2;\n" +
    "  gl_Position.z = 0;\n" +
    "  gl_Position.w = 1;\n" +
    "  fragColor = color;\n" +
    "}"};

  private int shader;

  public static void main(String[] args)
  {
    SwingUtilities.invokeLater(new test());
  }

  public test()
  {
    //init jogl
    this.canvas = new GLCanvas(new GLCapabilities(GLProfile.getDefault()));
    canvas.setIgnoreRepaint(true);
    canvas.addGLEventListener(new GLHandler());

    //system settings
    setIgnoreRepaint(true);
    setResizable(false);
    setSize(screenW , screenH);
    setUndecorated(true);
    setVisible(true);

    //customized initalization process and stuff
    add(canvas);
    validate();
    this.run();
  }

  public void run()
  {
    while(true)
    {
      canvas.display();
      try //Sleep a bit, let other threads do their stuff
      {
        Thread.sleep(1);
      }
      catch(InterruptedException ex)
      {
        ex.printStackTrace();
        System.exit(0);
      }
    }
  }

  private double fps;
  private long cycle;
  private class GLHandler implements GLEventListener
  {
    public void display(GLAutoDrawable drawable)
    {
      System.out.println("Fps: " + fps + " " + cycle);
      cycle++;
        renderTime = System.nanoTime();
        if(oldTime != 0 && renderTime != oldTime)
          fps = fps*0.9 + 100000000/(renderTime - oldTime);
        oldTime = renderTime;

      GL2 gl = drawable.getGL().getGL2();

      gl.glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

      gl.glDisable(GL_TEXTURE_2D);
      //test OpenGL responsiveness
      float[] color = new float[]{0.5f,0.25f +cycle%100/400f,0.25f+cycle%100/400f,1};
      gl.glClearBufferfv(GL_COLOR , 0 , color , 0);

      gl.glUseProgram(shader);

      gl.glVertexAttrib2fv(0, new float[]{0 , 0} , 0);
      gl.glVertexAttrib2fv(1, new float[]{0.25f + (cycle%2)*0.25f, 0} , 0);
      gl.glVertexAttrib2fv(2, new float[]{0 , 0.5f} , 0);
      gl.glVertexAttrib4fv(3, new float[]{0 , 1.0f*(cycle%128)/128f , 1.0f*(cycle%256)/256f , 1} , 0);

      // Draw one triangle
      gl.glDrawArrays(GL_TRIANGLES, 0, 3);
    }

    //Invoked when canvas is destroyed i.e. system exit. Nothing needing done.
    public void dispose(GLAutoDrawable drawable)
    {
      drawable.getGL().getGL2().glDeleteProgram(shader);
    }

    public void init(GLAutoDrawable drawable)
    {
      //Force v-sync.
      drawable.getGL().setSwapInterval(1);

      //disable 3D
      drawable.getGL().glDisable(GL_DEPTH_TEST);

      GL2 gl = drawable.getGL().getGL2();

      System.out.println(gl.glGetString(GL_SHADING_LANGUAGE_VERSION));

      //enable graphics space
      gl.glEnable(GL_BLEND);
      gl.glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);

      //set screen size
      gl.glViewport(0 , 0 , screenW , screenH);
      gl.glMatrixMode(GL_PROJECTION);
      gl.glLoadIdentity();

      //set ortho view
      gl.glOrtho(0 , screenW , 0 , screenH , -1 , 1);
      gl.glMatrixMode(GL_MODELVIEW);
      gl.glLoadIdentity();

      //set screen default color
      //gl.glClearColor(0.25f,0.25f,0.25f,1);

      int v = gl.glCreateShader(GL_VERTEX_SHADER);
      gl.glShaderSource(v , vertexShader.length , vertexShader , new int[] { vertexShader[0].length() } , 0);
      gl.glCompileShader(v);

      {
        int[] compiled = new int[1];
        gl.glGetShaderiv(v , GL_COMPILE_STATUS , compiled , 0);
        if(compiled[0]!=0)
          System.out.println("Horray! vertex shader compiled");
        else
        {
          int[] logLength = new int[1];
          gl.glGetShaderiv(v , GL_INFO_LOG_LENGTH, logLength , 0);

          byte[] log = new byte[logLength[0]];
          gl.glGetShaderInfoLog(v , logLength[0] , (int[])null , 0 , log , 0);

          System.err.println("Error compiling the vertex shader: " + new String(log));
          System.exit(1);
        }
      }

      int f = gl.glCreateShader(GL_FRAGMENT_SHADER);
      gl.glShaderSource(f , fragShader.length , fragShader , new int[] { fragShader[0].length() } , 0);
      gl.glCompileShader(f);

      {
        int[] compiled = new int[1];
        gl.glGetShaderiv(f , GL_COMPILE_STATUS , compiled , 0);
        if(compiled[0]!=0)
          System.out.println("Horray! frag shader compiled");
        else
        {
          int[] logLength = new int[1];
          gl.glGetShaderiv(f , GL_INFO_LOG_LENGTH, logLength , 0);

          byte[] log = new byte[logLength[0]];
          gl.glGetShaderInfoLog(f , logLength[0] , (int[])null , 0 , log , 0);

          System.err.println("Error compiling the vertex shader: " + new String(log));
          System.exit(1);
        }
      }


      shader = gl.glCreateProgram();
      gl.glAttachShader(shader , v);
      gl.glAttachShader(shader , f);

      gl.glLinkProgram(shader);
      gl.glValidateProgram(shader);

      gl.glDeleteShader(v);
      gl.glDeleteShader(f);
    }

    // called when user resizes the window. Never happen.
    public void reshape(GLAutoDrawable drawable , int x , int y ,
                        int width , int height) {}
  }
}