/*
* 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 java.awt.*;
import java.awt.event.*;
import java.nio.*;
import java.util.*;
import javax.swing.*;
import net.java.games.jogl.*;
import net.java.games.jogl.util.*;
/** <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
glMapBufferARB, to achieve higher performance than accessing the
same data in system memory allows. </P>
*/
public class VertexBufferObject {
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 int[][] 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 = GL.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;
private volatile boolean quit = false;
// Frames-per-second computation
private boolean firstProfiledFrame;
private int profiledFrameCount;
private int numDrawElementsCalls;
private long startTimeMillis;
private GLCanvas canvas = null;
private Animator animator;
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;
}
public static void usage(String className) {
System.out.println("usage: java " + className + " [-slow]");
System.out.println("-slow flag starts up using data in the Java heap");
System.exit(0);
}
public static void main(String[] args) {
new VertexBufferObject().run(args);
}
public void run(String[] args) {
if (args.length > 1) {
usage(getClass().getName());
}
if (args.length == 1) {
if (args[0].equals("-slow")) {
vboEnabled = false;
} else {
usage(getClass().getName());
}
}
setFlag(' ', true); // animation on
setFlag('i', true); // infinite viewer and light
canvas = GLDrawableFactory.getFactory().createGLCanvas(new GLCapabilities());
// canvas.setGL(new TraceGL(canvas.getGL(), System.err));
// canvas.setGL(new DebugGL(canvas.getGL()));
VBOListener listener = new VBOListener();
canvas.addGLEventListener(listener);
animator = new Animator(canvas);
Frame frame = new Frame("Very Simple NV_vertex_array_range demo");
frame.setLayout(new BorderLayout());
canvas.setSize(800, 800);
frame.add(canvas, BorderLayout.CENTER);
frame.pack();
frame.show();
canvas.requestFocus();
frame.addWindowListener(new WindowAdapter() {
public void windowClosing(WindowEvent e) {
// Run this on another thread than the AWT event queue to
// make sure the call to Animator.stop() completes before
// exiting
new Thread(new Runnable() {
public void run() {
animator.stop();
System.exit(0);
}
}).start();
}
});
animator.start();
}
//----------------------------------------------------------------------
// Internals only below this point
//
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);
runExit();
}
}).start();
throw new RuntimeException(message);
}
}
class VBOListener implements GLEventListener {
boolean exiting = false;
public void init(GLDrawable drawable) {
GL gl = drawable.getGL();
GLU glu = drawable.getGLU();
// Try and disable synch-to-retrace for fastest framerate
if (gl.isFunctionAvailable("wglSwapIntervalEXT")) {
System.err.println("wglSwapIntervalEXT available; disabling sync-to-refresh for best framerate");
gl.wglSwapIntervalEXT(0);
}
else {
System.err.println("wglSwapIntervalEXT not available; cannot disable sync-to-refresh");
}
try {
initExtension(gl, "GL_ARB_vertex_buffer_object");
} catch (RuntimeException e) {
quit = true;
throw (e);
}
gl.glEnable(GL.GL_DEPTH_TEST);
gl.glClearColor(0, 0, 0, 0);
gl.glEnable(GL.GL_LIGHT0);
gl.glEnable(GL.GL_LIGHTING);
gl.glEnable(GL.GL_NORMALIZE);
gl.glMaterialfv(GL.GL_FRONT_AND_BACK, GL.GL_AMBIENT, new float[] {.1f, .1f, 0, 1});
gl.glMaterialfv(GL.GL_FRONT_AND_BACK, GL.GL_DIFFUSE, new float[] {.6f, .6f, .1f, 1});
gl.glMaterialfv(GL.GL_FRONT_AND_BACK, GL.GL_SPECULAR, new float[] { 1, 1, .75f, 1});
gl.glMaterialf(GL.GL_FRONT_AND_BACK, GL.GL_SHININESS, 128.f);
gl.glLightfv(GL.GL_LIGHT0, GL.GL_POSITION, new float[] { .5f, 0, .5f, 0});
gl.glLightModeli(GL.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(GL.GL_PROJECTION);
gl.glLoadIdentity();
glu.gluPerspective(60, 1.0, 0.1, 100);
gl.glMatrixMode(GL.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(GL.GL_VERTEX_ARRAY);
gl.glEnableClientState(GL.GL_NORMAL_ARRAY);
computeElements(gl);
drawable.addKeyListener(new KeyAdapter() {
public void keyTyped(KeyEvent e) {
dispatchKey(e.getKeyChar());
}
});
}
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 * BufferUtils.SIZEOF_FLOAT;
buffers[i].normalOffset = (startIndex + 3) * BufferUtils.SIZEOF_FLOAT;
}
}
private void dispatchKey(char k) {
setFlag(k, !getFlag(k));
// Quit on escape or 'q'
if ((k == (char) 27) || (k == 'q')) {
runExit();
}
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 = GL.GL_QUAD_STRIP;
}
}
if (k == 'p') {
if (getFlag(k)) {
primitive = GL.GL_POINTS;
} else {
primitive = GL.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 display(GLDrawable drawable) {
// Don't try to do OpenGL operations if we're tearing things down
if (quit) {
return;
}
GL gl = drawable.getGL();
GLU glu = drawable.getGLU();
// 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(GL.GL_LIGHTING);
} else {
gl.glEnable(GL.GL_LIGHTING);
}
toggleLighting = false;
}
if (toggleLightingModel) {
if(getFlag('i')) {
// infinite light
gl.glLightfv(GL.GL_LIGHT0, GL.GL_POSITION, new float[] { .5f, 0, .5f, 0 });
gl.glLightModeli(GL.GL_LIGHT_MODEL_LOCAL_VIEWER, 0);
} else {
gl.glLightfv(GL.GL_LIGHT0, GL.GL_POSITION, new float[] { .5f, 0, -.5f,1 });
gl.glLightModeli(GL.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);
// FIXME: add mouse interaction
// camera.apply_inverse_transform();
// object.apply_transform();
int cur = 0;
int numSlabs = tileSize / STRIP_SIZE;
if (vboEnabled) {
gl.glBindBufferARB(GL.GL_ARRAY_BUFFER_ARB, bigBufferObject);
} else {
gl.glBindBufferARB(GL.GL_ARRAY_BUFFER_ARB, 0);
}
for(int slab = numSlabs; --slab>=0; ) {
cur = slab % numBuffers;
if (vboEnabled) {
ByteBuffer tmp = gl.glMapBufferARB(GL.GL_ARRAY_BUFFER_ARB, GL.GL_WRITE_ONLY_ARB);
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, BufferUtils.bufferOffset(buffers[cur].vertexOffset));
gl.glNormalPointer( GL.GL_FLOAT, 6 * SIZEOF_FLOAT, BufferUtils.bufferOffset(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.glUnmapBufferARB(GL.GL_ARRAY_BUFFER_ARB);
}
if (getFlag('m')) {
// Elements merged into buffer object (doesn't seem to improve performance)
int len = tileSize - 1;
gl.glBindBufferARB(GL.GL_ELEMENT_ARRAY_BUFFER_ARB, elementBufferObject);
for (int i = 0; i < len; i++) {
++numDrawElementsCalls;
gl.glDrawElements(primitive, 2 * STRIP_SIZE, GL.GL_UNSIGNED_INT,
BufferUtils.bufferOffset(i * 2 * STRIP_SIZE * BufferUtils.SIZEOF_INT));
if(getFlag('f')) {
gl.glFlush();
}
}
gl.glBindBufferARB(GL.GL_ELEMENT_ARRAY_BUFFER_ARB, 0);
} else {
for (int i = 0; i < elements.length; i++) {
++numDrawElementsCalls;
gl.glDrawElements(primitive, elements[i].length, GL.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(GLDrawable drawable, int x, int y, int width, int height) {}
// Unused routines
public void displayChanged(GLDrawable drawable, boolean modeChanged, boolean deviceChanged) {}
} // end class VBOListener
private void allocateBigArray(GL gl) {
bigArraySystem = setupBuffer(ByteBuffer.allocateDirect(bufferSize));
int[] tmp = new int[1];
gl.glGenBuffersARB(1, tmp);
bigBufferObject = tmp[0];
gl.glBindBufferARB(GL.GL_ARRAY_BUFFER_ARB, bigBufferObject);
// Initialize data store of buffer object
gl.glBufferDataARB(GL.GL_ARRAY_BUFFER_ARB, bufferSize, (Buffer) null, GL.GL_DYNAMIC_DRAW_ARB);
bigArrayVBOBytes = gl.glMapBufferARB(GL.GL_ARRAY_BUFFER_ARB, GL.GL_WRITE_ONLY_ARB);
bigArrayVBO = setupBuffer(bigArrayVBOBytes);
gl.glUnmapBufferARB(GL.GL_ARRAY_BUFFER_ARB);
// Unbind buffer; will be bound again in main loop
gl.glBindBufferARB(GL.GL_ARRAY_BUFFER_ARB, 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(GL gl) {
xyArray = new float[tileSize];
for (int i = 0; i < tileSize; i++) {
xyArray[i] = i / (tileSize - 1.0f) - 0.5f;
}
elements = new int[tileSize - 1][];
for (int i = 0; i < tileSize - 1; i++) {
elements[i] = new int[2 * STRIP_SIZE];
for (int j = 0; j < 2 * STRIP_SIZE; j += 2) {
elements[i][j] = i * STRIP_SIZE + (j / 2);
elements[i][j+1] = (i + 1) * STRIP_SIZE + (j / 2);
}
}
// Create element array buffer
int[] linearElements = new int[(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[idx++] = i * STRIP_SIZE + (j / 2);
linearElements[idx++] = (i + 1) * STRIP_SIZE + (j / 2);
}
}
int[] tmp = new int[1];
gl.glGenBuffersARB(1, tmp);
elementBufferObject = tmp[0];
gl.glBindBufferARB(GL.GL_ELEMENT_ARRAY_BUFFER_ARB, elementBufferObject);
gl.glBufferDataARB(GL.GL_ELEMENT_ARRAY_BUFFER_ARB,
linearElements.length * BufferUtils.SIZEOF_INT,
linearElements,
GL.GL_STATIC_DRAW_ARB);
gl.glBindBufferARB(GL.GL_ELEMENT_ARRAY_BUFFER_ARB, 0);
}
private void runExit() {
quit = true;
// 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 and cause this one to
// terminate by throwing an exception out of it.
new Thread(new Runnable() {
public void run() {
animator.stop();
System.exit(0);
}
}).start();
}
}