JOCLSimpleGL3.java

/*
 * JOCL - Java bindings for OpenCL
 * 
 * Copyright 2009-2019 Marco Hutter - http://www.jocl.org/
 */
package org.jocl.samples;

import static com.jogamp.opengl.GL.*;
import static org.jocl.CL.*;

import java.awt.BorderLayout;
import java.awt.Dimension;
import java.awt.Frame;
import java.awt.Point;
import java.awt.event.KeyAdapter;
import java.awt.event.KeyEvent;
import java.awt.event.MouseEvent;
import java.awt.event.MouseMotionListener;
import java.awt.event.MouseWheelEvent;
import java.awt.event.MouseWheelListener;
import java.awt.event.WindowAdapter;
import java.awt.event.WindowEvent;
import java.io.BufferedReader;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.nio.ByteBuffer;
import java.nio.ByteOrder;
import java.nio.FloatBuffer;
import java.nio.IntBuffer;
import java.util.Arrays;

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

import org.jocl.*;

import jogamp.opengl.GLContextImpl;
import jogamp.opengl.GLDrawableImpl;
import jogamp.opengl.egl.EGLContext;
import jogamp.opengl.macosx.cgl.MacOSXCGLContext;
import jogamp.opengl.windows.wgl.WindowsWGLContext;
import jogamp.opengl.x11.glx.X11GLXContext;

import com.jogamp.nativewindow.NativeSurface;
import com.jogamp.opengl.GL;
import com.jogamp.opengl.GL3;
import com.jogamp.opengl.GLAutoDrawable;
import com.jogamp.opengl.GLCapabilities;
import com.jogamp.opengl.GLContext;
import com.jogamp.opengl.GLEventListener;
import com.jogamp.opengl.GLProfile;
import com.jogamp.opengl.awt.GLCanvas;
import com.jogamp.opengl.util.Animator;

/**
 * A small example demonstrating the JOCL/JOGL interoperability,
 * using the "simpleGL.cl" kernel from the NVIDIA "oclSimpleGL"
 * example. This example is intended to be used with JOGL 2, and
 * uses only the OpenGL 3.2 core profile and GLSL 1.5 
 */
public class JOCLSimpleGL3 implements GLEventListener
{
    /**
     * Entry point for this sample.
     * 
     * @param args not used
     */
    public static void main(String args[])
    {
        GLProfile profile = GLProfile.get(GLProfile.GL3);
        final GLCapabilities capabilities = new GLCapabilities(profile);
        SwingUtilities.invokeLater(new Runnable()
        {
            public void run()
            {
                new JOCLSimpleGL3(capabilities);
            }
        });
    }

    /**
     * Compile-time flag which indicates whether the real OpenCL/OpenGL 
     * interoperation should be used. If this flag is 'true', then the 
     * buffers should be shared between OpenCL and OpenGL. If it is 
     * 'false', then the buffer contents will be copied via the host.
     */
    private static final boolean GL_INTEROP = false;

    /**
     * The source code for the vertex shader
     */
    private static String vertexShaderSource = 
        "#version 150 core" + "\n" +
        "in  vec4 inVertex;" + "\n" +
        "in  vec3 inColor;" + "\n" +
        "uniform mat4 modelviewMatrix;" + "\n" +
        "uniform mat4 projectionMatrix;" + "\n" +
        "void main(void)" + "\n" +
        "{" + "\n" +
        "    gl_Position = " + "\n" +
        "        projectionMatrix * modelviewMatrix * inVertex;" + "\n" +
        "}";
    
    /**
     * The source code for the fragment shader
     */
    private static String fragmentShaderSource =
        "#version 150 core" + "\n" +
        "out vec4 outColor;" + "\n" +
        "void main(void)" + "\n" +
        "{" + "\n" +
        "    outColor = vec4(1.0,0.0,0.0,1.0);" + "\n" +
        "}";
    
    
    /**
     * Whether the initialization method of this GLEventListener has
     * already been called
     */
    private boolean initialized = false;

    /**
     * The width segments of the mesh to be displayed.
     */
    private static final int meshWidth = 8 * 64;

    /**
     * The height segments of the mesh to be displayed
     */
    private static final int meshHeight = 8 * 64;

    /**
     * The current animation state of the mesh
     */
    private float animationState = 0.0f;

    /**
     * The vertex array object (required as of GL3)
     */
    private int vertexArrayObject;
    
    /**
     * The VBO identifier
     */
    private int vertexBufferObject;

    /**
     * The cl_mem that has the contents of the VBO,
     * namely the vertex positions
     */
    private cl_mem vboMem;

    /**
     * The OpenCL context
     */
    private cl_context context;

    /**
     * The OpenCL command queue
     */
    private cl_command_queue commandQueue;

    /**
     * The OpenCL kernel
     */
    private cl_kernel kernel;

    /**
     * Whether the computation should be performed with JOCL or
     * with Java. May be toggled by pressing the 't' key
     */
    private boolean useJOCL = true;

    /**
     * A flag indicating whether the VBO and the VBO memory object
     * have to be re-initialized due to a switch between Java and 
     * JOCL computing mode
     * To do: This should not be necessary. Find out why leaving  
     * this out results in an OUT_OF_HOST_MEMORY error.
     */
    private boolean reInitVBOData = true;
    
    /**
     * The ID of the OpenGL shader program
     */
    private int shaderProgramID;
    
    /**
     * The translation in X-direction
     */
    private float translationX = 0;

    /**
     * The translation in Y-direction
     */
    private float translationY = 0;

    /**
     * The translation in Z-direction
     */
    private float translationZ = -4;

    /**
     * The rotation about the X-axis, in degrees
     */
    private float rotationX = 40;

    /**
     * The rotation about the Y-axis, in degrees
     */
    private float rotationY = 30;

    /**
     * The current projection matrix
     */
    float projectionMatrix[] = new float[16];

    /**
     * The current projection matrix
     */
    float modelviewMatrix[] = new float[16];
    
    /**
     * The animator 
     */
    private Animator animator;
    
    /**
     * Step counter for FPS computation
     */
    private int step = 0;
    
    /**
     * Time stamp for FPS computation
     */
    private long prevTimeNS = -1;
    
    /**
     * The main frame of the application
     */
    private Frame frame;
    
    /**
     * Inner class encapsulating the MouseMotionListener and
     * MouseWheelListener for the interaction
     */
    class MouseControl implements MouseMotionListener, MouseWheelListener
    {
        private Point previousMousePosition = new Point();

        @Override
        public void mouseDragged(MouseEvent e)
        {
            int dx = e.getX() - previousMousePosition.x;
            int dy = e.getY() - previousMousePosition.y;

            // If the left button is held down, move the object
            if ((e.getModifiersEx() & MouseEvent.BUTTON1_DOWN_MASK) == 
                MouseEvent.BUTTON1_DOWN_MASK)
            {
                translationX += dx / 100.0f;
                translationY -= dy / 100.0f;
            }

            // If the right button is held down, rotate the object
            else if ((e.getModifiersEx() & MouseEvent.BUTTON3_DOWN_MASK) == 
                MouseEvent.BUTTON3_DOWN_MASK)
            {
                rotationX += dy;
                rotationY += dx;
            }
            previousMousePosition = e.getPoint();
            updateModelviewMatrix();
        }

        @Override
        public void mouseMoved(MouseEvent e)
        {
            previousMousePosition = e.getPoint();
        }

        @Override
        public void mouseWheelMoved(MouseWheelEvent e)
        {
            // Translate along the Z-axis
            translationZ += e.getWheelRotation() * 0.25f;
            previousMousePosition = e.getPoint();
            updateModelviewMatrix();
        }
    }

    /**
     * Inner class extending a KeyAdapter for the keyboard
     * interaction
     */
    class KeyboardControl extends KeyAdapter
    {
        @Override
        public void keyTyped(KeyEvent e)
        {
            char c = e.getKeyChar();
            if (c == 't')
            {
                useJOCL = !useJOCL;
                reInitVBOData = true;
                System.out.println("useJOCL is now "+useJOCL);
            }
        }
    }

    
    /**
     * Creates a new JOCLSimpleGL3 sample.
     * 
     * @param capabilities The GL capabilities 
     */
    public JOCLSimpleGL3(GLCapabilities capabilities)
    {
        // Initialize the GL component 
        final GLCanvas glComponent = new GLCanvas(capabilities);
        glComponent.setFocusable(true);
        glComponent.addGLEventListener(this);

        // Initialize the mouse and keyboard controls
        MouseControl mouseControl = new MouseControl();
        glComponent.addMouseMotionListener(mouseControl);
        glComponent.addMouseWheelListener(mouseControl);
        KeyboardControl keyboardControl = new KeyboardControl();
        glComponent.addKeyListener(keyboardControl);
        updateModelviewMatrix();        

        // Create and start an animator
        animator = new Animator(glComponent);
        animator.start();
        
        // Create the main frame 
        frame = new JFrame("JOCL / JOGL interaction sample");
        frame.addWindowListener(new WindowAdapter()
        {
            @Override
            public void windowClosing(WindowEvent e)
            {
                runExit();
            }
        });
        frame.setLayout(new BorderLayout());
        glComponent.setPreferredSize(new Dimension(800, 800));
        frame.add(glComponent, BorderLayout.CENTER);
        frame.pack();
        frame.setVisible(true);
        glComponent.requestFocus();
        
    }
    
    /**
     * Update the modelview matrix depending on the
     * current translation and rotation
     */
    private void updateModelviewMatrix()
    {
        float m0[] = translation(translationX, translationY, translationZ);
        float m1[] = rotationX(rotationX);
        float m2[] = rotationY(rotationY);
        modelviewMatrix = multiply(multiply(m1,m2), m0);
    }
    

    /**
     * Implementation of GLEventListener: Called to initialize the 
     * GLAutoDrawable
     */
    @Override
    public void init(GLAutoDrawable drawable)
    {
        // Perform the default GL initialization 
        GL3 gl = drawable.getGL().getGL3();
        
        gl.setSwapInterval(0);

        gl.glEnable(GL.GL_DEPTH_TEST);
        gl.glClearColor(0.0f, 0.0f, 0.0f, 1.0f);

        // Initialize the shaders
        initShaders(gl);
        
        // Set up the viewport and projection matrix
        setupView(drawable);

        // Initialize the GL_ARB_vertex_buffer_object extension
        if (!gl.isExtensionAvailable("GL_ARB_vertex_buffer_object"))
        {
            new Thread(new Runnable()
            {
                @Override
                public void run()
                {
                    JOptionPane.showMessageDialog(null, 
                        "GL_ARB_vertex_buffer_object extension not available", 
                        "Unavailable extension", JOptionPane.ERROR_MESSAGE);
                    runExit();
                }
            }).start();
        }
        
        // Initialize OpenCL, creating a context for the given GL object 
        initCL(gl);

        // Initialize the OpenGL VBO and the OpenCL VBO memory object
        initVBOData(gl);
        
        initialized = true;
    }


    /**
     * Initialize OpenCL. This will create the CL context for the GL 
     * context of the given GL, as well as the command queue and
     * kernel.
     *  
     * @param gl The GL object
     */
    private void initCL(GL3 gl)
    {
        // The platform, device type and device number
        // that will be used
        final int platformIndex = 0;
        final long deviceType = CL_DEVICE_TYPE_GPU;
        final int deviceIndex = 0;

        // Enable exceptions and subsequently omit error checks in this sample
        CL.setExceptionsEnabled(true);

        // Obtain the number of platforms
        int numPlatformsArray[] = new int[1];
        clGetPlatformIDs(0, null, numPlatformsArray);
        int numPlatforms = numPlatformsArray[0];

        // Obtain a platform ID
        cl_platform_id platforms[] = new cl_platform_id[numPlatforms];
        clGetPlatformIDs(platforms.length, platforms, null);
        cl_platform_id platform = platforms[platformIndex];

        // Initialize the context properties
        cl_context_properties contextProperties = new cl_context_properties();
        contextProperties.addProperty(CL_CONTEXT_PLATFORM, platform);
        initContextProperties(contextProperties, gl);
        
        // Obtain the number of devices for the platform
        int numDevicesArray[] = new int[1];
        clGetDeviceIDs(platform, deviceType, 0, null, numDevicesArray);
        int numDevices = numDevicesArray[0];
        
        // Obtain a device ID 
        cl_device_id devices[] = new cl_device_id[numDevices];
        clGetDeviceIDs(platform, deviceType, numDevices, devices, null);
        cl_device_id device = devices[deviceIndex];

        // Create a context for the selected device
        context = clCreateContext(
            contextProperties, 1, new cl_device_id[]{device}, 
            null, null, null);
        
        // Create a command-queue for the selected device
        cl_queue_properties properties = new cl_queue_properties();
        commandQueue = clCreateCommandQueueWithProperties(
            context, device, properties, null);

        // Read the program source code and create the program
        String source = readFile("src/main/resources/kernels/simpleGL.cl");
        cl_program program = clCreateProgramWithSource(context, 1, 
            new String[]{ source }, null, null);
        clBuildProgram(program, 0, null, "-cl-mad-enable", null, null);

        // Create the kernel which computes the sine wave pattern
        kernel = clCreateKernel(program, "sine_wave", null);
        
        // Set the constant kernel arguments 
        clSetKernelArg(kernel, 1, Sizeof.cl_uint, 
            Pointer.to(new int[]{ meshWidth }));
        clSetKernelArg(kernel, 2, Sizeof.cl_uint, 
            Pointer.to(new int[]{ meshHeight }));
    }

    
    /**
     * Initializes the given context properties so that they may be
     * used to create an OpenCL context for the given GL object.
     *  
     * @param contextProperties The context properties
     * @param gl The GL object
     */
    private void initContextProperties(cl_context_properties contextProperties, GL gl)
    {
        // Adapted from http://jogamp.org/jocl/www/
        
        GLContext glContext = gl.getContext();
        if(!glContext.isCurrent()) 
        {
            throw new IllegalArgumentException(
                "OpenGL context is not current. This method should be called " +
                "from the OpenGL rendering thread, when the context is current.");
        }

        long glContextHandle = glContext.getHandle();
        GLContextImpl glContextImpl = (GLContextImpl)glContext;
        GLDrawableImpl glDrawableImpl = glContextImpl.getDrawableImpl();
        NativeSurface nativeSurface = glDrawableImpl.getNativeSurface();

        if (glContext instanceof X11GLXContext)
        {
            long displayHandle = nativeSurface.getDisplayHandle();
            contextProperties.addProperty(CL_GL_CONTEXT_KHR, glContextHandle);
            contextProperties.addProperty(CL_GLX_DISPLAY_KHR, displayHandle);
        }
        else if (glContext instanceof WindowsWGLContext)
        {
            long surfaceHandle = nativeSurface.getSurfaceHandle();
            contextProperties.addProperty(CL_GL_CONTEXT_KHR, glContextHandle);
            contextProperties.addProperty(CL_WGL_HDC_KHR, surfaceHandle);
        }
        else if (glContext instanceof MacOSXCGLContext)
        {
            contextProperties.addProperty(CL_CGL_SHAREGROUP_KHR, glContextHandle);
        }
        else if (glContext instanceof EGLContext)
        {
            long displayHandle = nativeSurface.getDisplayHandle();
            contextProperties.addProperty(CL_GL_CONTEXT_KHR, glContextHandle);
            contextProperties.addProperty(CL_EGL_DISPLAY_KHR, displayHandle);
        }
        else
        {
            throw new RuntimeException("unsupported GLContext: " + glContext);
        }
    }

    
    
    /**
     * Helper function which reads the file with the given name and returns 
     * the contents of this file as a String. Will exit the application
     * if the file can not be read.
     * 
     * @param fileName The name of the file to read.
     * @return The contents of the file
     */
    private String readFile(String fileName)
    {
        try
        {
            BufferedReader br = new BufferedReader(
                new InputStreamReader(new FileInputStream(fileName)));
            StringBuffer sb = new StringBuffer();
            String line = null;
            while (true)
            {
                line = br.readLine();
                if (line == null)
                {
                    break;
                }
                sb.append(line).append("\n");
            }
            br.close();
            return sb.toString();
        }
        catch (IOException e)
        {
            e.printStackTrace();
            runExit();
            return null;
        }
    }
    
    
    /**
     * Initialize the shaders and the shader program
     * 
     * @param gl The GL context
     */
    private void initShaders(GL3 gl)
    {
        int vertexShaderID = gl.glCreateShader(GL3.GL_VERTEX_SHADER);
        gl.glShaderSource(vertexShaderID, 1, 
            new String[]{vertexShaderSource}, null);
        gl.glCompileShader(vertexShaderID);

        int fragmentShaderID = gl.glCreateShader(GL3.GL_FRAGMENT_SHADER);
        gl.glShaderSource(fragmentShaderID, 1, 
            new String[]{fragmentShaderSource}, null);
        gl.glCompileShader(fragmentShaderID);
        
        shaderProgramID = gl.glCreateProgram();
        gl.glAttachShader(shaderProgramID, vertexShaderID);
        gl.glAttachShader(shaderProgramID, fragmentShaderID);
        gl.glLinkProgram(shaderProgramID);
    }

    /**
     * Initialize the OpenGL VBO and the OpenCL VBO memory object
     * 
     * @param gl The current GL object
     */
    private void initVBOData(GL3 gl)
    {
        initVBO(gl);
        initVBOMem(gl);
        reInitVBOData = false;
    }
    
    
    /**
     * Create the GL vertex buffer object (VBO) that stores the
     * vertex positions.
     * 
     * @param gl The GL context
     */
    private void initVBO(GL3 gl)
    {
        if (vertexBufferObject != 0)
        {
            gl.glDeleteBuffers(1, new int[]{ vertexBufferObject }, 0);
            vertexBufferObject = 0;
        }
        if (vertexArrayObject != 0)
        {
            gl.glDeleteVertexArrays(1, new int[] { vertexArrayObject }, 0);
            vertexArrayObject = 0;
        }
        int tempArray[] = new int[1];
        
        // Create the vertex array object 
        gl.glGenVertexArrays(1, IntBuffer.wrap(tempArray));
        vertexArrayObject = tempArray[0];
        gl.glBindVertexArray(vertexArrayObject);
        
        // Create the vertex buffer object
        gl.glGenBuffers(1, IntBuffer.wrap(tempArray));
        vertexBufferObject = tempArray[0];

        // Initialize the vertex buffer object
        gl.glBindBuffer(GL_ARRAY_BUFFER, vertexBufferObject);
        int size = meshWidth * meshHeight * 4 * Sizeof.cl_float;
        gl.glBufferData(GL_ARRAY_BUFFER, size, null, 
            GL_DYNAMIC_DRAW);
        
        // Initialize the attribute location of the input
        // vertices for the shader program
        int location = gl.glGetAttribLocation(shaderProgramID, "inVertex");
        gl.glVertexAttribPointer(location, 4, GL3.GL_FLOAT, false, 0, 0);
        gl.glEnableVertexAttribArray(location);
        
    }

    /**
     * Initialize the OpenCL VBO memory object which corresponds to
     * the OpenGL VBO that stores the vertex positions
     * 
     * @param gl The current GL object
     */
    private void initVBOMem(GL3 gl)
    {
        if (vboMem != null)
        {
            clReleaseMemObject(vboMem);
            vboMem = null;
        }
        if (GL_INTEROP)
        {
            // Create an OpenCL buffer for the VBO
            gl.glBindBuffer(GL_ARRAY_BUFFER, vertexBufferObject);
            vboMem = clCreateFromGLBuffer(context, CL_MEM_WRITE_ONLY, 
                vertexBufferObject, null);
        }
        else
        {
            // Create an empty OpenCL buffer
            int size = meshWidth * meshHeight * 4 * Sizeof.cl_float;
            vboMem = clCreateBuffer(context, CL_MEM_WRITE_ONLY, size, 
                null, null);
        }
        clSetKernelArg(kernel, 0, Sizeof.cl_mem, Pointer.to(vboMem));
    }
    
    /**
     * Implementation of GLEventListener: Called when the given GLAutoDrawable
     * is to be displayed.
     */
    @Override
    public void display(GLAutoDrawable drawable)
    {
        if (!initialized)
        {
            return;
        }
        GL3 gl = (GL3)drawable.getGL();
        
        if (reInitVBOData)
        {
            initVBOData(gl);
        }

        if (useJOCL)
        {
            // Run the JOCL kernel to generate new vertex positions.
            runJOCL(gl);
        }
        else
        {
            // Run the Java method to generate new vertex positions.
            runJava(gl);
        }
        
        animationState += 0.01f;

        gl.glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

        // Activate the shader program
        gl.glUseProgram(shaderProgramID);
        
        // Set the current projection matrix
        int projectionMatrixLocation = 
            gl.glGetUniformLocation(shaderProgramID, "projectionMatrix");
        gl.glUniformMatrix4fv(
            projectionMatrixLocation, 1, false, projectionMatrix, 0);

        // Set the current modelview matrix
        int modelviewMatrixLocation = 
            gl.glGetUniformLocation(shaderProgramID, "modelviewMatrix");
        gl.glUniformMatrix4fv(
            modelviewMatrixLocation, 1, false, modelviewMatrix, 0);
        
        // Render the VBO
        gl.glBindBuffer(GL_ARRAY_BUFFER, vertexBufferObject);
        gl.glDrawArrays(GL_POINTS, 0, meshWidth * meshHeight);


        // Update FPS information in main frame title
        step++;
        long currentTime = System.nanoTime();
        if (prevTimeNS == -1)
        {
            prevTimeNS = currentTime;
        }
        long diff = currentTime - prevTimeNS;
        if (diff > 1e9)
        {
            double fps = (diff / 1e9) * step;
            String t = "JOCL / JOGL interaction sample - ";
            t += useJOCL?"JOCL":"Java";
            t += " mode: "+String.format("%.2f", fps)+" FPS";
            frame.setTitle(t);
            prevTimeNS = currentTime;
            step = 0;
        }
    }

    /**
     * Run the JOCL computation to create new vertex positions
     * inside the vertexBufferObject.
     * 
     * @param gl The current GL
     */
    private void runJOCL(GL3 gl)
    {
        if (GL_INTEROP)
        {
            // Map OpenGL buffer object for writing from OpenCL
            gl.glFinish();
            clEnqueueAcquireGLObjects(commandQueue, 1, 
                new cl_mem[]{ vboMem }, 0, null, null);
        }

        // Set work size and arguments, and execute the kernel
        long globalWorkSize[] = new long[2];
        globalWorkSize[0] = meshWidth;
        globalWorkSize[1] = meshHeight;
        clSetKernelArg(kernel, 3, Sizeof.cl_float, 
            Pointer.to(new float[]{ animationState }));
        clEnqueueNDRangeKernel(commandQueue, kernel, 2, null, 
            globalWorkSize, null, 0, null, null);

        if (GL_INTEROP)
        {
            // Unmap the buffer object
            clEnqueueReleaseGLObjects(commandQueue, 1, 
                new cl_mem[]{ vboMem }, 0, null, null);
            clFinish(commandQueue);
        }
        else
        {
            // Map the VBO to copy data from the CL buffer to the GL buffer,
            // copy the data from CL to GL, and unmap the buffer
            gl.glBindBuffer(GL_ARRAY_BUFFER, vertexBufferObject);
            ByteBuffer pointer = gl.glMapBuffer(
                GL_ARRAY_BUFFER, GL_WRITE_ONLY);
            clEnqueueReadBuffer(commandQueue, vboMem, CL_TRUE, 0, 
                Sizeof.cl_float * 4 * meshHeight * meshWidth, 
                Pointer.to(pointer), 0, null, null);
            gl.glUnmapBuffer(GL_ARRAY_BUFFER);
        }
    }

    /**
     * Run the Java computation to create new vertex positions
     * inside the vertexBufferObject.
     * 
     * @param gl The current GL.
     */
    private void runJava(GL3 gl)
    {
        float currentAnimationState = animationState;
        
        gl.glBindBuffer(GL_ARRAY_BUFFER, vertexBufferObject);
        
        ByteBuffer byteBuffer = gl.glMapBuffer(
            GL_ARRAY_BUFFER, GL_WRITE_ONLY);
        FloatBuffer vertices = byteBuffer.order(
            ByteOrder.nativeOrder()).asFloatBuffer();
        
        for (int x = 0; x < meshWidth; x++)
        {
            for (int y = 0; y < meshHeight; y++)
            {
                // Calculate u/v coordinates
                float u = x / (float) meshWidth;
                float v = y / (float) meshHeight;

                u = u * 2.0f - 1.0f;
                v = v * 2.0f - 1.0f;

                // Calculate simple sine wave pattern
                float freq = 4.0f;
                float w = 
                    (float) Math.sin(u * freq + currentAnimationState) * 
                    (float) Math.cos(v * freq + currentAnimationState) * 0.5f;

                // Write output vertex
                int index = 4 * (y * meshWidth + x);
                vertices.put(index + 0, u);
                vertices.put(index + 1, w);
                vertices.put(index + 2, v);
                vertices.put(index + 3, 1);
            }
        }
        gl.glUnmapBuffer(GL_ARRAY_BUFFER);
    }

    /**
     * Implementation of GLEventListener: Called then the 
     * GLAutoDrawable was reshaped
     */
    @Override
    public void reshape(GLAutoDrawable drawable, int x, int y, 
                    int width, int height)
    {
        setupView(drawable);
    }

    /**
     * Set up a default view for the given GLAutoDrawable
     * 
     * @param drawable The GLAutoDrawable to set the view for
     */
    private void setupView(GLAutoDrawable drawable)
    {
        GL3 gl = (GL3)drawable.getGL();

        gl.glViewport(0, 0, 
            drawable.getSurfaceWidth(), 
            drawable.getSurfaceHeight());

        float aspect = (float) drawable.getSurfaceWidth() / 
            drawable.getSurfaceHeight();
        projectionMatrix = perspective(50, aspect, 0.1f, 100.0f);
    }
    
    /**
     * Implementation of GLEventListener - not used
     */
    @Override
    public void dispose(GLAutoDrawable drawable)
    {
    }
    
    /**
     * Calls System.exit() in a new Thread. It may not be called 
     * synchronously inside one of the JOGL callbacks.
     * 
     * @param Animator the animator to stop
     */
    private void runExit()
    {
        new Thread(new Runnable()
        {
            @Override
            public void run()
            {
                animator.stop();
                System.exit(0);
            }
        }).start();
    }
    

    
    //=== Helper functions for matrix operations ==============================

    /**
     * Helper method that creates a perspective matrix
     * @param fovy The fov in y-direction, in degrees
     * 
     * @param aspect The aspect ratio
     * @param zNear The near clipping plane
     * @param zFar The far clipping plane
     * @return A perspective matrix
     */
    private static float[] perspective(
        float fovy, float aspect, float zNear, float zFar)
    {
        float radians = (float)Math.toRadians(fovy / 2);
        float deltaZ = zFar - zNear;
        float sine = (float)Math.sin(radians);
        if ((deltaZ == 0) || (sine == 0) || (aspect == 0)) 
        {
            return identity();
        }
        float cotangent = (float)Math.cos(radians) / sine;
        float m[] = identity();
        m[0*4+0] = cotangent / aspect;
        m[1*4+1] = cotangent;
        m[2*4+2] = -(zFar + zNear) / deltaZ;
        m[2*4+3] = -1;
        m[3*4+2] = -2 * zNear * zFar / deltaZ;
        m[3*4+3] = 0;
        return m;
    }
    
    /**
     * Creates an identity matrix
     * 
     * @return An identity matrix 
     */
    private static float[] identity()
    {
        float m[] = new float[16];
        Arrays.fill(m, 0);
        m[0] = m[5] = m[10] = m[15] = 1.0f;
        return m;
    }
    
    /**
     * Multiplies the given matrices and returns the result
     * 
     * @param m0 The first matrix
     * @param m1 The second matrix
     * @return The product m0*m1
     */
    private static float[] multiply(float m0[], float m1[])
    {
        float m[] = new float[16];
        for (int x=0; x < 4; x++)
        {
            for(int y=0; y < 4; y++)
            {
                m[x*4 + y] = 
                    m0[x*4+0] * m1[y+ 0] +
                    m0[x*4+1] * m1[y+ 4] +
                    m0[x*4+2] * m1[y+ 8] +
                    m0[x*4+3] * m1[y+12];
            }
        }
        return m;
    }
    
    /**
     * Creates a translation matrix
     * 
     * @param x The x translation
     * @param y The y translation
     * @param z The z translation
     * @return A translation matrix
     */
    private static float[] translation(float x, float y, float z)
    {
        float m[] = identity();
        m[12] = x;
        m[13] = y;
        m[14] = z;
        return m;
    }

    /**
     * Creates a matrix describing a rotation around the x-axis
     * 
     * @param angleDeg The rotation angle, in degrees
     * @return The rotation matrix
     */
    private static float[] rotationX(float angleDeg)
    {
        float m[] = identity();
        float angleRad = (float)Math.toRadians(angleDeg);
        float ca = (float)Math.cos(angleRad);
        float sa = (float)Math.sin(angleRad);
        m[ 5] =  ca;
        m[ 6] =  sa;
        m[ 9] = -sa;
        m[10] =  ca;
        return m;
    }

    /**
     * Creates a matrix describing a rotation around the y-axis
     * 
     * @param angleDeg The rotation angle, in degrees
     * @return The rotation matrix
     */
    private static float[] rotationY(float angleDeg)
    {
        float m[] = identity();
        float angleRad = (float)Math.toRadians(angleDeg);
        float ca = (float)Math.cos(angleRad);
        float sa = (float)Math.sin(angleRad);
        m[ 0] =  ca;
        m[ 2] = -sa;
        m[ 8] =  sa;
        m[10] =  ca;
        return m;
    }
    
}