diff options
Diffstat (limited to 'src/demos/vertexBufferObject/VertexBufferObject.java')
| -rw-r--r-- | src/demos/vertexBufferObject/VertexBufferObject.java | 782 |
1 files changed, 782 insertions, 0 deletions
diff --git a/src/demos/vertexBufferObject/VertexBufferObject.java b/src/demos/vertexBufferObject/VertexBufferObject.java new file mode 100644 index 0000000..0bc8b10 --- /dev/null +++ b/src/demos/vertexBufferObject/VertexBufferObject.java @@ -0,0 +1,782 @@ +/* + * Portions Copyright (C) 2003 Sun Microsystems, Inc. + * All rights reserved. + */ + +/* + * + * COPYRIGHT NVIDIA CORPORATION 2003. ALL RIGHTS RESERVED. + * BY ACCESSING OR USING THIS SOFTWARE, YOU AGREE TO: + * + * 1) ACKNOWLEDGE NVIDIA'S EXCLUSIVE OWNERSHIP OF ALL RIGHTS + * IN AND TO THE SOFTWARE; + * + * 2) NOT MAKE OR DISTRIBUTE COPIES OF THE SOFTWARE WITHOUT + * INCLUDING THIS NOTICE AND AGREEMENT; + * + * 3) ACKNOWLEDGE THAT TO THE MAXIMUM EXTENT PERMITTED BY + * APPLICABLE LAW, THIS SOFTWARE IS PROVIDED *AS IS* AND + * THAT NVIDIA AND ITS SUPPLIERS DISCLAIM ALL WARRANTIES, + * EITHER EXPRESS OR IMPLIED, INCLUDING, BUT NOT LIMITED + * TO, IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS + * FOR A PARTICULAR PURPOSE. + * + * IN NO EVENT SHALL NVIDIA OR ITS SUPPLIERS BE LIABLE FOR ANY + * SPECIAL, INCIDENTAL, INDIRECT, OR CONSEQUENTIAL DAMAGES + * WHATSOEVER (INCLUDING, WITHOUT LIMITATION, DAMAGES FOR LOSS + * OF BUSINESS PROFITS, BUSINESS INTERRUPTION, LOSS OF BUSINESS + * INFORMATION, OR ANY OTHER PECUNIARY LOSS), INCLUDING ATTORNEYS' + * FEES, RELATING TO THE USE OF OR INABILITY TO USE THIS SOFTWARE, + * EVEN IF NVIDIA HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES. + * + */ + +package demos.vertexBufferObject; + +import demos.common.Demo; +import demos.common.DemoListener; +import java.awt.BorderLayout; +import java.awt.Frame; +import java.awt.event.KeyAdapter; +import java.awt.event.KeyEvent; +import java.awt.event.WindowAdapter; +import java.awt.event.WindowEvent; +import java.nio.Buffer; +import java.nio.ByteBuffer; +import java.nio.ByteOrder; +import java.nio.FloatBuffer; +import java.nio.IntBuffer; +import javax.media.opengl.GL; +import javax.media.opengl.GLCapabilities; +import javax.media.opengl.GLProfile; +import javax.media.opengl.GL2ES1; +import javax.media.opengl.GL2; +import javax.media.opengl.GLAutoDrawable; +import javax.media.opengl.GLProfile; +import javax.media.opengl.awt.AWTGLAutoDrawable; +import javax.media.opengl.awt.GLCanvas; +import javax.media.opengl.glu.GLU; +import com.sun.opengl.util.Animator; +import com.sun.opengl.util.BufferUtil; +import javax.swing.JOptionPane; + + + +/** <P> A port of NVidia's [tm] Vertex Array Range demonstration to + OpenGL[tm] for Java[tm], the Java programming language, and the + vendor-neutral Vertex Buffer Object extension. The current web + site for the demo is <a href = + "http://developer.nvidia.com/object/vardemo.html">here</a>. </P> + + <P> This demonstration requires the following: + + <ul> + <li> A JDK 1.4 implementation + <li> A card supporting the GL_ARB_vertex_buffer_object extension + (only in recent drivers) + </ul> + + </P> + + <P> This demonstration illustrates the use of the java.nio direct + buffer classes in JDK 1.4 to access memory outside of the Java + garbage-collected heap, in particular that returned from the call + glMapBuffer, to achieve higher performance than accessing the + same data in system memory allows. </P> +*/ + +public class VertexBufferObject extends Demo { + + public static void main(String[] args) { + + boolean vboEnabled = true; + + if (args.length > 1) { + usage(); + } + + if (args.length == 1) { + if (args[0].equals("-slow")) { + vboEnabled = false; + } else { + usage(); + } + } + GLCapabilities caps = new GLCapabilities(GLProfile.get(GLProfile.GL2)); + GLCanvas canvas = new GLCanvas(caps); + VertexBufferObject demo = new VertexBufferObject(); + demo.vboEnabled = vboEnabled; + canvas.addGLEventListener(demo); + + final Animator animator = new Animator(canvas); + animator.setRunAsFastAsPossible(true); + demo.setDemoListener(new DemoListener() { + public void shutdownDemo() { + runExit(animator); + } + public void repaint() {} + }); + + Frame frame = new Frame("Very Simple vertex_buffer_object demo"); + frame.addWindowListener(new WindowAdapter() { + public void windowClosing(WindowEvent e) { + runExit(animator); + } + }); + frame.setLayout(new BorderLayout()); + canvas.setSize(800, 800); + frame.add(canvas, BorderLayout.CENTER); + frame.pack(); + frame.setVisible(true); + canvas.requestFocus(); + + animator.start(); + } + + private static void usage() { + System.out.println("usage: java VertexBufferObject [-slow]"); + System.out.println("-slow flag starts up using data in the Java heap"); + System.exit(0); + } + + public VertexBufferObject() { + setFlag(' ', true); // animation on + setFlag('i', true); // infinite viewer and light + } + + //---------------------------------------------------------------------- + // Internals only below this point + // + + private GLU glu = new GLU(); + private boolean initComplete; + private boolean[] b = new boolean[256]; + private static final int SIZEOF_FLOAT = 4; + // private static final int STRIP_SIZE = 48; + private static final int STRIP_SIZE = 144; + // private int tileSize = 9 * STRIP_SIZE; + private int tileSize = 3 * STRIP_SIZE; + private int numBuffers = 1; + private int bufferLength = 1000000; + private int bufferSize = bufferLength * SIZEOF_FLOAT; + private static final int SIN_ARRAY_SIZE = 1024; + + private int bigBufferObject; + private boolean vboEnabled = true; + private ByteBuffer bigArrayVBOBytes; + private FloatBuffer bigArrayVBO; + private FloatBuffer bigArraySystem; + private FloatBuffer bigArray; + private IntBuffer[] elements; + private int elementBufferObject; + private float[] xyArray; + + static class VBOBuffer { + public FloatBuffer vertices; + public FloatBuffer normals; + public int vertexOffset; + public int normalOffset; + } + private VBOBuffer[] buffers; + + private float[] sinArray; + private float[] cosArray; + + // Primitive: GL_QUAD_STRIP, GL_LINE_STRIP, or GL_POINTS + private int primitive = GL2.GL_QUAD_STRIP; + + // Animation parameters + private float hicoef = .06f; + private float locoef = .10f; + private float hifreq = 6.1f; + private float lofreq = 2.5f; + private float phaseRate = .02f; + private float phase2Rate = -0.12f; + private float phase = 0; + private float phase2 = 0; + + // Temporaries for computation + float[] ysinlo = new float[STRIP_SIZE]; + float[] ycoslo = new float[STRIP_SIZE]; + float[] ysinhi = new float[STRIP_SIZE]; + float[] ycoshi = new float[STRIP_SIZE]; + + // For thread-safety when dealing with keypresses + private volatile boolean toggleVBO = false; + private volatile boolean toggleLighting = false; + private volatile boolean toggleLightingModel = false; + private volatile boolean recomputeElements = false; + + // Frames-per-second computation + private boolean firstProfiledFrame; + private int profiledFrameCount; + private int numDrawElementsCalls; + private long startTimeMillis; + + static class PeriodicIterator { + public PeriodicIterator(int arraySize, + float period, + float initialOffset, + float delta) { + float arrayDelta = arraySize * (delta / period); // floating-point steps-per-increment + increment = (int)(arrayDelta * (1<<16)); // fixed-point steps-per-increment + + float offset = arraySize * (initialOffset / period); // floating-point initial index + initOffset = (int)(offset * (1<<16)); // fixed-point initial index + + arraySizeMask = 0; + int i = 20; // array should be reasonably sized... + while((arraySize & (1<<i)) == 0) { + i--; + } + arraySizeMask = (1<<i)-1; + index = initOffset; + } + + public PeriodicIterator(PeriodicIterator arg) { + this.arraySizeMask = arg.arraySizeMask; + this.increment = arg.increment; + this.initOffset = arg.initOffset; + this.index = arg.index; + } + + public int getIndex() { + return (index >> 16) & arraySizeMask; + } + + public void incr() { + index += increment; + } + + public void decr() { + index -= increment; + } + + public void reset() { + index = initOffset; + } + + //---------------------------------------------------------------------- + // Internals only below this point + // + + private int arraySizeMask; + // fraction bits == 16 + private int increment; + private int initOffset; + private int index; + } + + private void setFlag(char key, boolean val) { + b[((int) key) & 0xFF] = val; + } + + private boolean getFlag(char key) { + return b[((int) key) & 0xFF]; + } + + private void initExtension(GL gl, String glExtensionName) { + if (!gl.isExtensionAvailable(glExtensionName)) { + final String message = "OpenGL extension \"" + glExtensionName + "\" not available"; + new Thread(new Runnable() { + public void run() { + JOptionPane.showMessageDialog(null, message, "Unavailable extension", JOptionPane.ERROR_MESSAGE); + shutdownDemo(); + } + }).start(); + throw new RuntimeException(message); + } + } + + public void init(GLAutoDrawable drawable) { + initComplete = false; + // drawable.setGL(new TraceGL(drawable.getGL(), System.err)); + // drawable.setGL(new DebugGL(drawable.getGL())); + + GL2 gl = drawable.getGL().getGL2(); + + // Try and disable synch-to-retrace for fastest framerate + gl.setSwapInterval(0); + + try { + initExtension(gl, "GL_ARB_vertex_buffer_object"); + } catch (RuntimeException e) { + throw (e); + } + + gl.glEnable(GL.GL_DEPTH_TEST); + + gl.glClearColor(0, 0, 0, 0); + + gl.glEnable(GL2ES1.GL_LIGHT0); + gl.glEnable(GL2ES1.GL_LIGHTING); + gl.glEnable(GL2ES1.GL_NORMALIZE); + gl.glMaterialfv(GL.GL_FRONT_AND_BACK, GL2ES1.GL_AMBIENT, new float[] {.1f, .1f, 0, 1}, 0); + gl.glMaterialfv(GL.GL_FRONT_AND_BACK, GL2ES1.GL_DIFFUSE, new float[] {.6f, .6f, .1f, 1}, 0); + gl.glMaterialfv(GL.GL_FRONT_AND_BACK, GL2ES1.GL_SPECULAR, new float[] { 1, 1, .75f, 1}, 0); + gl.glMaterialf(GL.GL_FRONT_AND_BACK, GL2ES1.GL_SHININESS, 128.f); + + gl.glLightfv(GL2ES1.GL_LIGHT0, GL2ES1.GL_POSITION, new float[] { .5f, 0, .5f, 0}, 0); + gl.glLightModeli(GL2.GL_LIGHT_MODEL_LOCAL_VIEWER, 0); + + // NOTE: it looks like GLUT (or something else) sets up the + // projection matrix in the C version of this demo. + gl.glMatrixMode(GL2ES1.GL_PROJECTION); + gl.glLoadIdentity(); + glu.gluPerspective(60, 1.0, 0.1, 100); + gl.glMatrixMode(GL2ES1.GL_MODELVIEW); + + allocateBigArray(gl); + allocateBuffers(gl); + + sinArray = new float[SIN_ARRAY_SIZE]; + cosArray = new float[SIN_ARRAY_SIZE]; + + for (int i = 0; i < SIN_ARRAY_SIZE; i++) { + double step = i * 2 * Math.PI / SIN_ARRAY_SIZE; + sinArray[i] = (float) Math.sin(step); + cosArray[i] = (float) Math.cos(step); + } + + if (vboEnabled) { + bigArray = bigArrayVBO; + } else { + bigArray = bigArraySystem; + } + setupBuffers(); + gl.glEnableClientState(GL2ES1.GL_VERTEX_ARRAY); + gl.glEnableClientState(GL2ES1.GL_NORMAL_ARRAY); + + computeElements(gl); + + if (drawable instanceof AWTGLAutoDrawable) { + ((AWTGLAutoDrawable) drawable).addKeyListener(new KeyAdapter() { + public void keyTyped(KeyEvent e) { + dispatchKey(e.getKeyChar()); + } + }); + } + + initComplete = true; + } + + private void allocateBuffers(GL gl) { + buffers = new VBOBuffer[numBuffers]; + for (int i = 0; i < numBuffers; i++) { + buffers[i] = new VBOBuffer(); + } + } + + private void setupBuffers() { + int sliceSize = bufferLength / numBuffers; + for (int i = 0; i < numBuffers; i++) { + int startIndex = i * sliceSize; + buffers[i].vertices = sliceBuffer(bigArray, startIndex, sliceSize); + buffers[i].normals = sliceBuffer(buffers[i].vertices, 3, + buffers[i].vertices.limit() - 3); + buffers[i].vertexOffset = startIndex * BufferUtil.SIZEOF_FLOAT; + buffers[i].normalOffset = (startIndex + 3) * BufferUtil.SIZEOF_FLOAT; + } + } + + private void dispatchKey(char k) { + setFlag(k, !getFlag(k)); + // Quit on escape or 'q' + if ((k == (char) 27) || (k == 'q')) { + shutdownDemo(); + return; + } + + if (k == 'r') { + if (getFlag(k)) { + profiledFrameCount = 0; + numDrawElementsCalls = 0; + firstProfiledFrame = true; + } + } + + if (k == 'w') { + if (getFlag(k)) { + primitive = GL.GL_LINE_STRIP; + } else { + primitive = GL2.GL_QUAD_STRIP; + } + } + + if (k == 'p') { + if (getFlag(k)) { + primitive = GL.GL_POINTS; + } else { + primitive = GL2.GL_QUAD_STRIP; + } + } + + if (k == 'v') { + toggleVBO = true; + } + + if (k == 'd') { + toggleLighting = true; + } + + if (k == 'i') { + toggleLightingModel = true; + } + + if('h'==k) + hicoef += .005; + if('H'==k) + hicoef -= .005; + if('l'==k) + locoef += .005; + if('L'==k) + locoef -= .005; + if('1'==k) + lofreq += .1f; + if('2'==k) + lofreq -= .1f; + if('3'==k) + hifreq += .1f; + if('4'==k) + hifreq -= .1f; + if('5'==k) + phaseRate += .01f; + if('6'==k) + phaseRate -= .01f; + if('7'==k) + phase2Rate += .01f; + if('8'==k) + phase2Rate -= .01f; + + if('t'==k) { + if(tileSize < 864) { + tileSize += STRIP_SIZE; + recomputeElements = true; + System.err.println("tileSize = " + tileSize); + } + } + + if('T'==k) { + if(tileSize > STRIP_SIZE) { + tileSize -= STRIP_SIZE; + recomputeElements = true; + System.err.println("tileSize = " + tileSize); + } + } + } + + public void dispose(GLAutoDrawable drawable) { + } + + public void display(GLAutoDrawable drawable) { + if (!initComplete) { + return; + } + + GL2 gl = drawable.getGL().getGL2(); + + // Check to see whether to animate + if (getFlag(' ')) { + phase += phaseRate; + phase2 += phase2Rate; + + if (phase > (float) (20 * Math.PI)) { + phase = 0; + } + + if (phase2 < (float) (-20 * Math.PI)) { + phase2 = 0; + } + } + + PeriodicIterator loX = + new PeriodicIterator(SIN_ARRAY_SIZE, (float) (2 * Math.PI), phase, (float) ((1.f/tileSize)*lofreq*Math.PI)); + PeriodicIterator loY = new PeriodicIterator(loX); + PeriodicIterator hiX = + new PeriodicIterator(SIN_ARRAY_SIZE, (float) (2 * Math.PI), phase2, (float) ((1.f/tileSize)*hifreq*Math.PI)); + PeriodicIterator hiY = new PeriodicIterator(hiX); + + if (toggleVBO) { + vboEnabled = !vboEnabled; + if (!vboEnabled) { + bigArray = bigArraySystem; + setupBuffers(); + } + toggleVBO = false; + } + + if (toggleLighting) { + if (getFlag('d')) { + gl.glDisable(GL2ES1.GL_LIGHTING); + } else { + gl.glEnable(GL2ES1.GL_LIGHTING); + } + toggleLighting = false; + } + + if (toggleLightingModel) { + if(getFlag('i')) { + // infinite light + gl.glLightfv(GL2ES1.GL_LIGHT0, GL2ES1.GL_POSITION, new float[] { .5f, 0, .5f, 0 }, 0); + gl.glLightModeli(GL2.GL_LIGHT_MODEL_LOCAL_VIEWER, 0); + } else { + gl.glLightfv(GL2ES1.GL_LIGHT0, GL2ES1.GL_POSITION, new float[] { .5f, 0, -.5f,1 }, 0); + gl.glLightModeli(GL2.GL_LIGHT_MODEL_LOCAL_VIEWER, 1); + } + toggleLightingModel = false; + } + + if (recomputeElements) { + computeElements(gl); + recomputeElements = false; + } + + gl.glClear(GL.GL_COLOR_BUFFER_BIT | GL.GL_DEPTH_BUFFER_BIT); + + gl.glPushMatrix(); + + final float[] modelViewMatrix = new float[] { + 1, 0, 0, 0, + 0, 1, 0, 0, + 0, 0, 1, 0, + 0, 0, -1, 1 + }; + gl.glLoadMatrixf(modelViewMatrix, 0); + + // FIXME: add mouse interaction + // camera.apply_inverse_transform(); + // object.apply_transform(); + + int cur = 0; + int numSlabs = tileSize / STRIP_SIZE; + + if (vboEnabled) { + gl.glBindBuffer(GL.GL_ARRAY_BUFFER, bigBufferObject); + } else { + gl.glBindBuffer(GL.GL_ARRAY_BUFFER, 0); + } + + for(int slab = numSlabs; --slab>=0; ) { + cur = slab % numBuffers; + + if (vboEnabled) { + ByteBuffer tmp = gl.glMapBuffer(GL.GL_ARRAY_BUFFER, GL2.GL_WRITE_ONLY); + if (tmp == null) { + throw new RuntimeException("Unable to map vertex buffer object"); + } + if (tmp != bigArrayVBOBytes) { + bigArrayVBOBytes = tmp; + bigArrayVBO = setupBuffer(tmp); + } + if (bigArray != bigArrayVBO) { + bigArray = bigArrayVBO; + setupBuffers(); + } + } + + FloatBuffer v = buffers[cur].vertices; + int vertexIndex = 0; + + if (vboEnabled) { + gl.glVertexPointer(3, GL.GL_FLOAT, 6 * SIZEOF_FLOAT, buffers[cur].vertexOffset); + gl.glNormalPointer( GL.GL_FLOAT, 6 * SIZEOF_FLOAT, buffers[cur].normalOffset); + } else { + gl.glVertexPointer(3, GL.GL_FLOAT, 6 * SIZEOF_FLOAT, v); + gl.glNormalPointer( GL.GL_FLOAT, 6 * SIZEOF_FLOAT, buffers[cur].normals); + } + + for(int jj=STRIP_SIZE; --jj>=0; ) { + ysinlo[jj] = sinArray[loY.getIndex()]; + ycoslo[jj] = cosArray[loY.getIndex()]; loY.incr(); + ysinhi[jj] = sinArray[hiY.getIndex()]; + ycoshi[jj] = cosArray[hiY.getIndex()]; hiY.incr(); + } + loY.decr(); + hiY.decr(); + + for(int i = tileSize; --i>=0; ) { + float x = xyArray[i]; + int loXIndex = loX.getIndex(); + int hiXIndex = hiX.getIndex(); + + int jOffset = (STRIP_SIZE-1)*slab; + float nx = locoef * -cosArray[loXIndex] + hicoef * -cosArray[hiXIndex]; + + // Help the HotSpot Client Compiler by hoisting loop + // invariant variables into locals. Note that this may be + // good practice for innermost loops anyway since under + // the new memory model operations like accidental + // synchronization may force any compiler to reload these + // fields from memory, destroying their ability to + // optimize. + float locoef_tmp = locoef; + float hicoef_tmp = hicoef; + float[] ysinlo_tmp = ysinlo; + float[] ysinhi_tmp = ysinhi; + float[] ycoslo_tmp = ycoslo; + float[] ycoshi_tmp = ycoshi; + float[] sinArray_tmp = sinArray; + float[] xyArray_tmp = xyArray; + + for(int j = STRIP_SIZE; --j>=0; ) { + float y; + + y = xyArray_tmp[j + jOffset]; + + float ny; + + v.put(vertexIndex, x); + v.put(vertexIndex + 1, y); + v.put(vertexIndex + 2, (locoef_tmp * (sinArray_tmp[loXIndex] + ysinlo_tmp[j]) + + hicoef_tmp * (sinArray_tmp[hiXIndex] + ysinhi_tmp[j]))); + v.put(vertexIndex + 3, nx); + ny = locoef_tmp * -ycoslo_tmp[j] + hicoef_tmp * -ycoshi_tmp[j]; + v.put(vertexIndex + 4, ny); + v.put(vertexIndex + 5, .15f); //.15f * (1.f - sqrt(nx * nx + ny * ny)); + vertexIndex += 6; + } + loX.incr(); + hiX.incr(); + } + loX.reset(); + hiX.reset(); + + if (vboEnabled) { + gl.glUnmapBuffer(GL.GL_ARRAY_BUFFER); + } + + if (getFlag('m')) { + // Elements merged into buffer object (doesn't seem to improve performance) + + int len = tileSize - 1; + gl.glBindBuffer(GL.GL_ELEMENT_ARRAY_BUFFER, elementBufferObject); + for (int i = 0; i < len; i++) { + ++numDrawElementsCalls; + gl.glDrawElements(primitive, 2 * STRIP_SIZE, GL2.GL_UNSIGNED_INT, + i * 2 * STRIP_SIZE * BufferUtil.SIZEOF_INT); + if(getFlag('f')) { + gl.glFlush(); + } + } + gl.glBindBuffer(GL.GL_ELEMENT_ARRAY_BUFFER, 0); + } else { + for (int i = 0; i < elements.length; i++) { + ++numDrawElementsCalls; + gl.glDrawElements(primitive, elements[i].remaining(), GL2.GL_UNSIGNED_INT, elements[i]); + if(getFlag('f')) { + gl.glFlush(); + } + } + } + } + + gl.glPopMatrix(); + + if (getFlag('r')) { + if (!firstProfiledFrame) { + if (++profiledFrameCount == 30) { + long endTimeMillis = System.currentTimeMillis(); + double secs = (endTimeMillis - startTimeMillis) / 1000.0; + double fps = 30.0 / secs; + double ppf = tileSize * tileSize * 2; + double mpps = ppf * fps / 1000000.0; + System.err.println("fps: " + fps + " polys/frame: " + ppf + " million polys/sec: " + mpps + + " DrawElements calls/frame: " + (numDrawElementsCalls / 30)); + profiledFrameCount = 0; + numDrawElementsCalls = 0; + startTimeMillis = System.currentTimeMillis(); + } + } else { + startTimeMillis = System.currentTimeMillis(); + firstProfiledFrame = false; + } + } + } + + public void reshape(GLAutoDrawable drawable, int x, int y, int width, int height) {} + + // Unused routines + public void displayChanged(GLAutoDrawable drawable, boolean modeChanged, boolean deviceChanged) {} + + private void allocateBigArray(GL2 gl) { + bigArraySystem = setupBuffer(ByteBuffer.allocateDirect(bufferSize)); + + int[] tmp = new int[1]; + gl.glGenBuffers(1, tmp, 0); + bigBufferObject = tmp[0]; + gl.glBindBuffer(GL.GL_ARRAY_BUFFER, bigBufferObject); + // Initialize data store of buffer object + gl.glBufferData(GL.GL_ARRAY_BUFFER, bufferSize, (Buffer) null, GL.GL_DYNAMIC_DRAW); + bigArrayVBOBytes = gl.glMapBuffer(GL.GL_ARRAY_BUFFER, GL2.GL_WRITE_ONLY); + bigArrayVBO = setupBuffer(bigArrayVBOBytes); + gl.glUnmapBuffer(GL.GL_ARRAY_BUFFER); + // Unbind buffer; will be bound again in main loop + gl.glBindBuffer(GL.GL_ARRAY_BUFFER, 0); + + float megabytes = (bufferSize / 1000000.f); + System.err.println("Allocated " + megabytes + " megabytes of fast memory"); + } + + private FloatBuffer setupBuffer(ByteBuffer buf) { + buf.order(ByteOrder.nativeOrder()); + return buf.asFloatBuffer(); + } + + private FloatBuffer sliceBuffer(FloatBuffer array, + int sliceStartIndex, int sliceLength) { + array.position(sliceStartIndex); + FloatBuffer ret = array.slice(); + array.position(0); + ret.limit(sliceLength); + return ret; + } + + private void computeElements(GL2 gl) { + xyArray = new float[tileSize]; + for (int i = 0; i < tileSize; i++) { + xyArray[i] = i / (tileSize - 1.0f) - 0.5f; + } + + elements = new IntBuffer[tileSize - 1]; + for (int i = 0; i < tileSize - 1; i++) { + elements[i] = IntBuffer.allocate(2 * STRIP_SIZE); + for (int j = 0; j < 2 * STRIP_SIZE; j += 2) { + elements[i].put(j, i * STRIP_SIZE + (j / 2)); + elements[i].put(j+1, (i + 1) * STRIP_SIZE + (j / 2)); + } + } + + // Create element array buffer + IntBuffer linearElements = IntBuffer.allocate((tileSize - 1) * (2 * STRIP_SIZE)); + int idx = 0; + for (int i = 0; i < tileSize - 1; i++) { + for (int j = 0; j < 2 * STRIP_SIZE; j += 2) { + linearElements.put(idx++, i * STRIP_SIZE + (j / 2)); + linearElements.put(idx++, (i + 1) * STRIP_SIZE + (j / 2)); + } + } + int[] tmp = new int[1]; + gl.glGenBuffers(1, tmp, 0); + elementBufferObject = tmp[0]; + gl.glBindBuffer(GL.GL_ELEMENT_ARRAY_BUFFER, elementBufferObject); + gl.glBufferData(GL.GL_ELEMENT_ARRAY_BUFFER, + linearElements.remaining() * BufferUtil.SIZEOF_INT, + linearElements, + GL.GL_STATIC_DRAW); + gl.glBindBuffer(GL.GL_ELEMENT_ARRAY_BUFFER, 0); + } + + private static void runExit(final Animator animator) { + // Note: calling System.exit() synchronously inside the draw, + // reshape or init callbacks can lead to deadlocks on certain + // platforms (in particular, X11) because the JAWT's locking + // routines cause a global AWT lock to be grabbed. Run the + // exit routine in another thread. + new Thread(new Runnable() { + public void run() { + animator.stop(); + System.exit(0); + } + }).start(); + } +} |