!7

// seems to run only when cd'ing to program dir first

lib 1400432 // jogl-all
lib 1400430 // jogl-win64
lib 1400433 // jogl gluegen
lib 1400434 // gluegen-rt-natives-windows-amd64

!include once #1029753 // JOGL framework.Semantic

import com.jogamp.newt.event.*;
import com.jogamp.newt.event.KeyEvent;
import com.jogamp.newt.event.KeyListener;
import com.jogamp.newt.event.WindowAdapter;
import com.jogamp.newt.event.WindowEvent;
import com.jogamp.newt.opengl.GLWindow;
import com.jogamp.opengl.*;
import com.jogamp.opengl.math.FloatUtil;
import com.jogamp.opengl.util.Animator;
import com.jogamp.opengl.util.GLBuffers;
import com.jogamp.opengl.util.glsl.ShaderCode;
import com.jogamp.opengl.util.glsl.ShaderProgram;

import java.nio.ByteBuffer;
import java.nio.FloatBuffer;
replace IntBuffer with java.nio.IntBuffer.
import java.nio.ShortBuffer;

import static com.jogamp.opengl.GL.*;
replace GL_FLOAT with com.jogamp.opengl.GL.GL_FLOAT.
replace GL_TRIANGLES with com.jogamp.opengl.GL.GL_TRIANGLES.
replace GL_UNSIGNED_SHORT with com.jogamp.opengl.GL.GL_UNSIGNED_SHORT.
replace GL_DEBUG_SEVERITY_HIGH with com.jogamp.opengl.GL2ES2.GL_DEBUG_SEVERITY_HIGH.
replace GL_DEBUG_SEVERITY_MEDIUM with com.jogamp.opengl.GL2ES2.GL_DEBUG_SEVERITY_MEDIUM.
import static com.jogamp.opengl.GL2ES3.*;
replace GL_UNIFORM_BUFFER with com.jogamp.opengl.GL2ES3.GL_UNIFORM_BUFFER.
replace GL_MAP_COHERENT_BIT with com.jogamp.opengl.GL4.GL_MAP_COHERENT_BIT.
replace GL_MAP_PERSISTENT_BIT with com.jogamp.opengl.GL4.GL_MAP_PERSISTENT_BIT.

/**
 * Created by GBarbieri on 16.03.2017.
 */
 
p/*-exp*/ {
  fixContextClassLoader();
  if (isWindows()) {
    extractResourceWithPath("natives/windows-amd64/gluegen-rt.dll", programDir());
    extractResourceWithPath("natives/windows-amd64/nativewindow_awt.dll", programDir());
    extractResourceWithPath("natives/windows-amd64/nativewindow_win32.dll", programDir());
    //loadNativeLibrary();
    addToNativeLibraryPath(programDir());
  }
  
  new HelloTriangleSimple().setup();
}

sclass HelloTriangleSimple implements GLEventListener, KeyListener {
  private static GLWindow window;
  private static Animator animator;

  private float[] vertexData = {
          -1, -1, 1, 0, 0,
          +0, +2, 0, 0, 1,
          +1, -1, 0, 1, 0};

  private short[] elementData = {0, 2, 1};

  private interface Buffer {

      int VERTEX = 0;
      int ELEMENT = 1;
      int GLOBAL_MATRICES = 2;
      int MODEL_MATRIX = 3;
      int MAX = 4;
  }

  private IntBuffer bufferName = GLBuffers.newDirectIntBuffer(Buffer.MAX);
  private IntBuffer vertexArrayName = GLBuffers.newDirectIntBuffer(1);

  private FloatBuffer clearColor = GLBuffers.newDirectFloatBuffer(4);
  private FloatBuffer clearDepth = GLBuffers.newDirectFloatBuffer(1);

  private FloatBuffer matBuffer = GLBuffers.newDirectFloatBuffer(16);

  private ByteBuffer globalMatricesPointer, modelMatrixPointer;
  // https://jogamp.org/bugzilla/show_bug.cgi?id=1287
  private boolean bug1287 = true;

  private Program program;

  private long start;


  private void setup() {

      GLProfile glProfile = GLProfile.get(GLProfile.GL3);
      GLCapabilities glCapabilities = new GLCapabilities(glProfile);

      window = GLWindow.create(glCapabilities);

      window.setTitle("Hello Triangle (enhanced)");
      window.setSize(1024, 768);

      window.setContextCreationFlags(GLContext.CTX_OPTION_DEBUG);
      window.setVisible(true);

      window.addGLEventListener(this);
      window.addKeyListener(this);

      animator = new Animator(window);
      animator.start();

      window.addWindowListener(new WindowAdapter() {
          @Override
          public void windowDestroyed(WindowEvent e) {
              animator.stop();
              System.exit(1);
          }
      });
  }


  @Override
  public void init(GLAutoDrawable drawable) {

      GL4 gl = drawable.getGL().getGL4();

      initDebug(gl);

      initBuffers(gl);

      initVertexArray(gl);

      program = new Program(gl, "shaders/gl4", "hello-triangle", "hello-triangle");

      gl.glEnable(GL_DEPTH_TEST);

      start = System.currentTimeMillis();
  }

  private void initDebug(GL4 gl) {

      window.getContext().addGLDebugListener(new GLDebugListener() {
          @Override
          public void messageSent(GLDebugMessage event) {
              System.out.println(event);
          }
      });

      gl.glDebugMessageControl(
              GL_DONT_CARE,
              GL_DONT_CARE,
              GL_DONT_CARE,
              0,
              null,
              false);

      gl.glDebugMessageControl(
              GL_DONT_CARE,
              GL_DONT_CARE,
              GL_DEBUG_SEVERITY_HIGH,
              0,
              null,
              true);

      gl.glDebugMessageControl(
              GL_DONT_CARE,
              GL_DONT_CARE,
              GL_DEBUG_SEVERITY_MEDIUM,
              0,
              null,
              true);
  }

  private void initBuffers(GL4 gl) {

      FloatBuffer vertexBuffer = GLBuffers.newDirectFloatBuffer(vertexData);
      ShortBuffer elementBuffer = GLBuffers.newDirectShortBuffer(elementData);

      gl.glCreateBuffers(Buffer.MAX, bufferName);

      if (!bug1287) {

          gl.glNamedBufferStorage(bufferName.get(Buffer.VERTEX), vertexBuffer.capacity() * Float.BYTES, vertexBuffer,
                  GL_STATIC_DRAW);
          gl.glNamedBufferStorage(bufferName.get(Buffer.ELEMENT), elementBuffer.capacity() * Short.BYTES,
                  elementBuffer, GL_STATIC_DRAW);

          gl.glNamedBufferStorage(bufferName.get(Buffer.GLOBAL_MATRICES), 16 * 4 * 2, null, GL_MAP_WRITE_BIT);
          gl.glNamedBufferStorage(bufferName.get(Buffer.MODEL_MATRIX), 16 * 4, null, GL_MAP_WRITE_BIT);

      } else {

          gl.glBindBuffer(GL_ARRAY_BUFFER, bufferName.get(Buffer.VERTEX));
          gl.glBufferStorage(GL_ARRAY_BUFFER, vertexBuffer.capacity() * Float.BYTES, vertexBuffer, 0);
          gl.glBindBuffer(GL_ARRAY_BUFFER, 0);

          gl.glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, bufferName.get(Buffer.ELEMENT));
          gl.glBufferStorage(GL_ELEMENT_ARRAY_BUFFER, elementBuffer.capacity() * Short.BYTES, elementBuffer, 0);
          gl.glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);


          IntBuffer uniformBufferOffset = GLBuffers.newDirectIntBuffer(1);
          gl.glGetIntegerv(GL_UNIFORM_BUFFER_OFFSET_ALIGNMENT, uniformBufferOffset);
          int globalBlockSize = Math.max(16 * 4 * 2, uniformBufferOffset.get(0));
          int modelBlockSize = Math.max(16 * 4, uniformBufferOffset.get(0));

          gl.glBindBuffer(GL_UNIFORM_BUFFER, bufferName.get(Buffer.GLOBAL_MATRICES));
          gl.glBufferStorage(GL_UNIFORM_BUFFER, globalBlockSize, null, GL_MAP_WRITE_BIT | GL_MAP_PERSISTENT_BIT | GL_MAP_COHERENT_BIT);
          gl.glBindBuffer(GL_UNIFORM_BUFFER, 0);

          gl.glBindBuffer(GL_UNIFORM_BUFFER, bufferName.get(Buffer.MODEL_MATRIX));
          gl.glBufferStorage(GL_UNIFORM_BUFFER, modelBlockSize, null, GL_MAP_WRITE_BIT | GL_MAP_PERSISTENT_BIT | GL_MAP_COHERENT_BIT);
          gl.glBindBuffer(GL_UNIFORM_BUFFER, 0);
      }

      // map the transform buffers and keep them mapped
      globalMatricesPointer = gl.glMapNamedBufferRange(
              bufferName.get(Buffer.GLOBAL_MATRICES),
              0,
              16 * 4 * 2,
              GL_MAP_WRITE_BIT | GL_MAP_PERSISTENT_BIT | GL_MAP_COHERENT_BIT | GL_MAP_INVALIDATE_BUFFER_BIT); // flags

      modelMatrixPointer = gl.glMapNamedBufferRange(
              bufferName.get(Buffer.MODEL_MATRIX),
              0,
              16 * 4,
              GL_MAP_WRITE_BIT | GL_MAP_PERSISTENT_BIT | GL_MAP_COHERENT_BIT | GL_MAP_INVALIDATE_BUFFER_BIT);
  }

  private void initVertexArray(GL4 gl) {

      gl.glCreateVertexArrays(1, vertexArrayName);

      gl.glVertexArrayAttribBinding(vertexArrayName.get(0), Semantic.Attr.POSITION, Semantic.Stream.A);
      gl.glVertexArrayAttribBinding(vertexArrayName.get(0), Semantic.Attr.COLOR, Semantic.Stream.A);

      gl.glVertexArrayAttribFormat(vertexArrayName.get(0), Semantic.Attr.POSITION, 2, GL_FLOAT, false, 0);
      gl.glVertexArrayAttribFormat(vertexArrayName.get(0), Semantic.Attr.COLOR, 3, GL_FLOAT, false, 2 * 4);

      gl.glEnableVertexArrayAttrib(vertexArrayName.get(0), Semantic.Attr.POSITION);
      gl.glEnableVertexArrayAttrib(vertexArrayName.get(0), Semantic.Attr.COLOR);

      gl.glVertexArrayElementBuffer(vertexArrayName.get(0), bufferName.get(Buffer.ELEMENT));
      gl.glVertexArrayVertexBuffer(vertexArrayName.get(0), Semantic.Stream.A, bufferName.get(Buffer.VERTEX), 0, (2 + 3) * 4);
  }

  @Override
  public void display(GLAutoDrawable drawable) {

      GL4 gl = drawable.getGL().getGL4();


      // view matrix
      {
          float[] view = FloatUtil.makeIdentity(new float[16]);
          for (int i = 0; i < 16; i++)
              globalMatricesPointer.putFloat(16 * 4 + i * 4, view[i]);
      }


      gl.glClearBufferfv(GL_COLOR, 0, clearColor.put(0, 1f).put(1, .5f).put(2, 0f).put(3, 1f));
      gl.glClearBufferfv(GL_DEPTH, 0, clearDepth.put(0, 1f));

      // model matrix
      {
          long now = System.currentTimeMillis();
          float diff = (float) (now - start) / 1_000;

          float[] scale = FloatUtil.makeScale(new float[16], true, 0.5f, 0.5f, 0.5f);
          float[] rotateZ = FloatUtil.makeRotationAxis(new float[16], 0, diff, 0f, 0f, 1f, new float[3]);
          float[] model = FloatUtil.multMatrix(scale, rotateZ);
          modelMatrixPointer.asFloatBuffer().put(model);
      }

      gl.glUseProgram(program.name);
      gl.glBindVertexArray(vertexArrayName.get(0));

      gl.glBindBufferBase(
              GL_UNIFORM_BUFFER,
              Semantic.Uniform.TRANSFORM0,
              bufferName.get(Buffer.GLOBAL_MATRICES));

      gl.glBindBufferBase(
              GL_UNIFORM_BUFFER,
              Semantic.Uniform.TRANSFORM1,
              bufferName.get(Buffer.MODEL_MATRIX));

      gl.glDrawElements(
              GL_TRIANGLES,
              elementData.length,
              GL_UNSIGNED_SHORT,
              0);

      gl.glUseProgram(0);
      gl.glBindVertexArray(0);
  }

  @Override
  public void reshape(GLAutoDrawable drawable, int x, int y, int width, int height) {

      GL4 gl = drawable.getGL().getGL4();

      // ortho matrix
      float[] ortho = FloatUtil.makeOrtho(new float[16], 0, false, -1f, 1f, -1f, 1f, 1f, -1f);
      globalMatricesPointer.asFloatBuffer().put(ortho);

      gl.glViewport(x, y, width, height);
  }

  @Override
  public void dispose(GLAutoDrawable drawable) {

      GL4 gl = drawable.getGL().getGL4();

      gl.glUnmapNamedBuffer(bufferName.get(Buffer.GLOBAL_MATRICES));
      gl.glUnmapNamedBuffer(bufferName.get(Buffer.MODEL_MATRIX));

      gl.glDeleteProgram(program.name);
      gl.glDeleteVertexArrays(1, vertexArrayName);
      gl.glDeleteBuffers(Buffer.MAX, bufferName);
  }

  @Override
  public void keyPressed(KeyEvent e) {
      if (e.getKeyCode() == KeyEvent.VK_ESCAPE) {
          new Thread(() -> {
              window.destroy();
          }).start();
      }
  }

  @Override
  public void keyReleased(KeyEvent e) {
  }

  private class Program {

      public int name = 0;

      public Program(GL4 gl, String root, String vertex, String fragment) {

          ShaderCode vertShader = ShaderCode.create(gl, GL_VERTEX_SHADER, this.getClass(), root, null, vertex,
                  "vert", null, true);
          ShaderCode fragShader = ShaderCode.create(gl, GL_FRAGMENT_SHADER, this.getClass(), root, null, fragment,
                  "frag", null, true);

          ShaderProgram shaderProgram = new ShaderProgram();

          shaderProgram.add(vertShader);
          shaderProgram.add(fragShader);

          shaderProgram.init(gl);

          name = shaderProgram.program();

          shaderProgram.link(gl, System.err);
      }
  }

  private class GlDebugOutput implements GLDebugListener {

      private int source = 0;
      private int type = 0;
      private int id = 0;
      private int severity = 0;
      private int length = 0;
      private String message = null;
      private boolean received = false;

      public GlDebugOutput() {
      }

      public GlDebugOutput(int source, int type, int severity) {
          this.source = source;
          this.type = type;
          this.severity = severity;
          this.message = null;
          this.id = -1;
      }

      public GlDebugOutput(String message, int id) {
          this.source = -1;
          this.type = -1;
          this.severity = -1;
          this.message = message;
          this.id = id;
      }

      @Override
      public void messageSent(GLDebugMessage event) {

          if (event.getDbgSeverity() == GL_DEBUG_SEVERITY_LOW || event.getDbgSeverity() == GL_DEBUG_SEVERITY_NOTIFICATION)
              System.out.println("GlDebugOutput.messageSent(): " + event);
          else
              System.err.println("GlDebugOutput.messageSent(): " + event);

          if (null != message && message == event.getDbgMsg() && id == event.getDbgId())
              received = true;
          else if (0 <= source && source == event.getDbgSource() && type == event.getDbgType() && severity == event.getDbgSeverity())
              received = true;
      }
  }
}