Shader test - manual

package p5.awt.papplet;

import java.applet.Applet;
import java.awt.BorderLayout;
import java.awt.Frame;
import java.awt.GraphicsDevice;
import java.awt.GraphicsEnvironment;
import java.awt.Insets;
import java.awt.event.WindowAdapter;
import java.awt.event.WindowEvent;
import java.nio.FloatBuffer;

import javax.media.opengl.*;
import javax.media.opengl.awt.GLCanvas;

import com.jogamp.opengl.util.GLArrayDataServer;
import com.jogamp.opengl.util.glsl.ShaderCode;
import com.jogamp.opengl.util.glsl.ShaderProgram;
import com.jogamp.opengl.util.glsl.ShaderState;

// Sample program that relies on JOGL's mechanism to handle the OpenGL context
// and rendering loop when using an AWT canvas attached to an Applet.
public class MiniPApplet extends Applet {
  private static final long serialVersionUID = 1L;

  /////////////////////////////////////////////////////////////
  //
  // Test parameters

  public int width               = 500;
  public int height              = 290;
  public int targetFrameRate     = 60;
  public int numSamples          = 2;

  /////////////////////////////////////////////////////////////
  //
  // Internal variables

  private Frame frame;
  private GLProfile profile;
  private GLCapabilities capabilities;
  private GLCanvas canvas;

  private SimpleListener listener;

  private long beforeTime;
  private long overSleepTime;
  private long frameRatePeriod = 1000000000L / targetFrameRate;

  private ShaderCode vertShader;
  private ShaderCode fragShader;
  private ShaderProgram shaderProg;
  private ShaderState shaderState;
  private GLUniformData resolution;
  private GLUniformData time;
  private GLArrayDataServer vertices;

  private float currentFrameRate;

  private boolean initialized = false;
  private long millisOffset;

  private boolean runSetup = false;

  private int fcount, lastm;
  private int fint = 3;

  void run() {
    Thread loop = new Thread("Animation Thread") {
      public void run() {
        while (true) {
          if (!initialized) {
            initialize();
          }
          canvas.display();
          clock();
        }
      }
    };
    loop.start();
  }

  void initialize() {
    millisOffset = System.currentTimeMillis();

    // Frame setup ----------------------------------------------------------
    GraphicsEnvironment environment =
      GraphicsEnvironment.getLocalGraphicsEnvironment();
    GraphicsDevice displayDevice = environment.getDefaultScreenDevice();
    frame = new Frame(displayDevice.getDefaultConfiguration());

    frame.setTitle("MiniPApplet");
    frame.setLayout(null);
    frame.add(this);
    frame.pack();

    Insets insets = frame.getInsets();

    int windowW = width + insets.left + insets.right;
    int windowH = height + insets.top + insets.bottom;
    int locationX = 100;
    int locationY = 100;

    frame.setSize(windowW, windowH);
    frame.setLocation(locationX, locationY);

    int usableWindowH = windowH - insets.top - insets.bottom;
    setBounds((windowW - width)/2, insets.top + (usableWindowH - height)/2, width, height);

    frame.add(this);
    frame.addWindowListener(new WindowAdapter() {
      public void windowClosing(WindowEvent e) {
          System.exit(0);
      }
    });

    frame.setVisible(true);

    // Canvas setup ----------------------------------------------------------

    profile = GLProfile.getDefault();
    capabilities = new GLCapabilities(profile);
    capabilities.setSampleBuffers(true);
    capabilities.setNumSamples(numSamples);
    capabilities.setDepthBits(24);
    capabilities.setStencilBits(8);
    capabilities.setAlphaBits(8);

    canvas = new GLCanvas(capabilities);
    canvas.setBounds(0, 0, width, height);

    this.setLayout(new BorderLayout());
    this.add(canvas, BorderLayout.CENTER);

    // Setting up animation
    listener = new SimpleListener();
    canvas.addGLEventListener(listener);

    initialized = true;
  }

  void setup(GL2ES2 gl) {
    vertShader = ShaderCode.create(gl, GL2ES2.GL_VERTEX_SHADER, this.getClass(), "shaders",
        "shaders/bin", "landscape", true);
    fragShader = ShaderCode.create(gl, GL2ES2.GL_FRAGMENT_SHADER, this.getClass(), "shaders",
        "shaders/bin", "landscape", true);
    shaderProg = new ShaderProgram();
    shaderProg.add(gl, vertShader, System.err);
    shaderProg.add(gl, fragShader, System.err);

    shaderState = new ShaderState();
    shaderState.attachShaderProgram(gl, shaderProg, true);

    resolution = new GLUniformData("iResolution", 3, FloatBuffer.wrap(new float[] {width, height, 0}));
    shaderState.ownUniform(resolution);
    shaderState.uniform(gl, resolution);

    time = new GLUniformData("iGlobalTime", 0.0f);
    shaderState.ownUniform(time);

    vertices = GLArrayDataServer.createGLSL("inVertex", 2, GL.GL_FLOAT, false, 4, GL.GL_STATIC_DRAW);
    vertices.putf(-1.0f); vertices.putf(-1.0f);
    vertices.putf(+1.0f); vertices.putf(-1.0f);
    vertices.putf(-1.0f); vertices.putf(+1.0f);
    vertices.putf(+1.0f); vertices.putf(+1.0f);
    vertices.seal(gl, true);
    shaderState.ownAttribute(vertices, true);

    runSetup = true;
  }

  void draw(GL2ES2 gl) {
    frame.setTitle("MiniPApplet - fps: " + currentFrameRate);

    gl.glClearColor(0, 0, 0, 1);
    gl.glClear(GL2ES2.GL_COLOR_BUFFER_BIT);

    shaderState.useProgram(gl, true);

    time.setData((System.currentTimeMillis() - millisOffset) / 1000.0f);
    shaderState.uniform(gl, time);
    vertices.enableBuffer(gl, true);
    gl.glDrawArrays(GL2ES2.GL_TRIANGLE_STRIP, 0, 4);
    vertices.enableBuffer(gl, false);

    shaderState.useProgram(gl, false);

    fcount += 1;
    int m = (int) (System.currentTimeMillis() - millisOffset);
    if (m - lastm > 1000 * fint) {
      currentFrameRate = (float)(fcount) / fint;
      fcount = 0;
      lastm = m;
    }
  }

  void clock() {
    long afterTime = System.nanoTime();
    long timeDiff = afterTime - beforeTime;
    long sleepTime = (frameRatePeriod - timeDiff) - overSleepTime;

    if (sleepTime > 0) {  // some time left in this cycle
      try {
        Thread.sleep(sleepTime / 1000000L, (int) (sleepTime % 1000000L));
      } catch (InterruptedException ex) { }

      overSleepTime = (System.nanoTime() - afterTime) - sleepTime;

    } else {    // sleepTime <= 0; the frame took longer than the period
      overSleepTime = 0L;
    }

    beforeTime = System.nanoTime();
  }

  class SimpleListener implements GLEventListener {
    @Override
    public void display(GLAutoDrawable drawable) {
      if (runSetup) {
        draw(drawable.getGL().getGL2ES2());
      } else {
        setup(drawable.getGL().getGL2ES2());
      }
    }

    @Override
    public void dispose(GLAutoDrawable drawable) { }

    @Override
    public void init(GLAutoDrawable drawable) { }

    @Override
    public void reshape(GLAutoDrawable drawable, int x, int y, int w, int h) { }
  }

  public static void main(String[] args) {
    MiniPApplet mini;
    try {
      Class<?> c = Thread.currentThread().getContextClassLoader().loadClass(MiniPApplet.class.getName());
      mini = (MiniPApplet) c.newInstance();
    } catch (Exception e) {
      throw new RuntimeException(e);
    }
    if (mini != null) {
      mini.run();
    }
  }
}