Processing 2.0 - 1,000,000 points in OpenGL using Vertex Arrays

Core Library Questions

mckennaps..

Processing 2.0 - 1,000,000 points in OpenGL using Vertex Arrays

in Core Library Questions • 1 year ago

I am attempting to implement the following example on the Processing wiki in the newest version of Processing 2.0b3 running on Ubuntu Linux 32-bit.

I am trying to run a 'stress test' in Processing 2.0 to see how many data points we can use in a 3D data visualization. Using just a PShape or a textured image has still been too slow. If this cannot work fast enough in Processing, we will likely have to turn to C and OpenGL.

The example here should simply draw a million randomly colored points on the screen using vertex arrays. All of the OpenGL examples on this site are for older versions of Processing, which is where I am struggling.

This post guided me how to properly set up the JOGL interface to call OpenGL2 commands. This correctly uses OpenGL2 commands to draw on the screen.

After making those adjustments in the code and removed unnecessary imports, I ran into an issue with the BufferUtil class not being found (or else invalid imports to it). I do not know enough about the changes to JOGL to ascertain a solution to this issue.

I tried removing the reference to the BufferUtil class, replacing it with what I thought was a proper implementation to create the FloatBuffer, which you can see in the code below, lines 35 - 45. While running, I was getting the following error in the Processing IDE:

Exception in thread "Animation Thread" java.lang.UnsupportedOperationException

at java.nio.FloatBuffer.array(FloatBuffer.java:940)

at java.nio.FloatBuffer.array(FloatBuffer.java:240)

at com.jogamp.common.nio.Buffers.getArray(Buffers.java:351)

at jogamp.opengl.gl4.GL4bcImpl.glVertexPointer(GL4bcImpl.java:33134)

at temp.setup(temp.java:91)

at processing.core.PApplet.handleDraw(PApplet.java:2103)

at processing.opengl.PGL$PGLListener.display(PGL.java:2593)

at jogamp.opengl.GLDrawableHelper.displayImpl(GLDrawableHelper.java:189)

at jogamp.opengl.GLDrawableHelper.display(GLDrawableHelper.java:177)

at javax.media.opengl.awt.GLCanvas$DisplayAction.run(GLCanvas.java:928)

at jogamp.opengl.GLDrawableHelper.invokeGLImpl(GLDrawableHelper.java:425)

at jogamp.opengl.GLDrawableHelper.invokeGL(GLDrawableHelper.java:364)

at javax.media.opengl.awt.GLCanvas$DisplayOnEventDispatchThreadAction.run(GLCanvas.java:945)

at java.awt.event.InvocationEvent.dispatch(InvocationEvent.java:199)

at java.awt.EventQueue.dispatchEventImpl(EventQueue.java:646)

at java.awt.EventQueue.access$000(EventQueue.java:84)

at java.awt.EventQueue$1.run(EventQueue.java:607)

at java.awt.EventQueue$1.run(EventQueue.java:605)

at java.security.AccessController.doPrivileged(Native Method)

at java.security.AccessControlContext$1.doIntersectionPrivilege(AccessControlContext.java:87)

at java.awt.EventQueue.dispatchEvent(EventQueue.java:616)

at java.awt.EventDispatchThread.pumpOneEventForFilters(EventDispatchThread.java:269)

at java.awt.EventDispatchThread.pumpEventsForFilter(EventDispatchThread.java:184)

at java.awt.EventDispatchThread.pumpEventsForHierarchy(EventDispatchThread.java:174)

at java.awt.EventDispatchThread.pumpEvents(EventDispatchThread.java:169)

at java.awt.EventDispatchThread.pumpEvents(EventDispatchThread.java:161)

at java.awt.EventDispatchThread.run(EventDispatchThread.java:122)

import javax.media.opengl.GL;
import javax.media.opengl.GL2;
import java.nio.*;
// let's try 1,000,000 points
int numPoints = 1000000;
// pan, zoom and rotate
float tx = 0, ty = 0;
float sc = 1;
float a = 0.0;
// you'd better leave these here
// otherwise they get garbage collected after setup
// and everything will crash
FloatBuffer vbuffer;
FloatBuffer cbuffer;
void setup() {
size(displayWidth/2, displayHeight/2, OPENGL);
smooth();
// JOGL for Processing 2.0
PGraphicsOpenGL pg = ((PGraphicsOpenGL)g);
PGL pgl = pg.beginPGL();
GL gl = pgl.gl;
GL2 gl2 = pgl.gl.getGL2();
// JOGL for Processing 1.5
//PGraphicsOpenGL pgl = (PGraphicsOpenGL) g; // g may change
//GL gl = pgl.beginGL(); // always use the GL object returned by beginGL
// Float Buffers for Processing 1.5
//vbuffer = BufferUtil.newFloatBuffer(numPoints * 2);
//cbuffer = BufferUtil.newFloatBuffer(numPoints * 3);
// Float Buffers for Processing 2.0
int vSize = (numPoints * 2);
int cSize = (numPoints * 3);
vSize = vSize << 2;
cSize = cSize << 2;
vbuffer = ByteBuffer.allocate(vSize).order(ByteOrder.nativeOrder()).asFloatBuffer();
cbuffer = ByteBuffer.allocate(cSize).order(ByteOrder.nativeOrder()).asFloatBuffer();
for (int i = 0; i < numPoints; i++) {
// random x,y
vbuffer.put(random(width));
vbuffer.put(random(height));
// random r,g,b
cbuffer.put(random(1.0));
cbuffer.put(random(1.0));
cbuffer.put(random(1.0));
}
vbuffer.rewind();
cbuffer.rewind();
gl2.glEnableClientState(GL2.GL_VERTEX_ARRAY);
gl2.glVertexPointer(2, GL2.GL_FLOAT, 0, vbuffer);
gl2.glEnableClientState(GL2.GL_COLOR_ARRAY);
gl2.glColorPointer(3, GL2.GL_FLOAT, 0, cbuffer);
// Close JOGL for Processing 1.5
//pgl.endGL();
// Close JGOGL for Processing 2.0
pg.endPGL();
}
void draw() {
// if (currentTime == startTime)
background(0);
// JOGL for Processing 2.0
PGraphicsOpenGL pg = ((PGraphicsOpenGL)g);
PGL pgl = pg.beginPGL();
GL gl = pgl.gl;
GL2 gl2 = pgl.gl.getGL2();
/// JOGL for Processing 1.5
//PGraphicsOpenGL pgl = (PGraphicsOpenGL) g; // g may change
//GL gl = pgl.beginGL(); // always use the GL object returned by beginGL
gl2.glPushMatrix();
gl2.glTranslatef(width/2, height/2, 0);
gl2.glScalef(sc,sc,sc);
gl2.glRotatef(a, 0.0, 0.0, 1.0);
gl2.glTranslatef(-width/2, -height/2, 0);
gl2.glTranslatef(tx,ty, 0);
gl2.glPointSize(2.0);
gl2.glDrawArrays(GL2.GL_POINTS, 0, numPoints);
gl2.glPopMatrix();
// Close JOGL for Processing 1.5
//pgl.endGL();
// Close JOGL for Processing 2.0
pg.endPGL();
if (keyPressed) {
if (key == CODED) {
if (keyCode == LEFT) {
a -= 1;
}
else if (keyCode == RIGHT) {
a += 1;
}
}
else if (key == '+' || key == '=') {
sc *= 1.05;
}
else if (key == '_' || key == '-' && sc > 0.1) {
sc *= 1.0/1.05;
}
else if (key == ' ') {
sc = 1.0;
tx = 0;
ty = 0;
a = 0;
}
}
}
void mouseDragged() {
float dx = (mouseX - pmouseX) / sc;
float dy = (mouseY - pmouseY) / sc;
float angle = radians(-a);
float rx = cos(angle)*dx - sin(angle)*dy;
float ry = sin(angle)*dx + cos(angle)*dy;
tx += rx;
ty += ry;
}

Any help or thoughts on this would be much appreciated. Thank you!

Peace.

Replies(14)

Jonsku

Re: Processing 2.0 - 1,000,000 points in OpenGL using Vertex Arrays

1 year ago

Hi,

I'm myself modifying some code to run with Processing 2.0. Not a walk in the park...

The replacement for BufferUtil is : com.jogamp.common.nio.Buffers

Here is some code I use to load image into texture :

IntBuffer buf = Buffers.newDirectIntBuffer(img.width * img.height);
buf.put(img.pixels);
buf.rewind();

but they are also function to create other flavors of buffers, such as char or float.

Hope this helps!

mckennaps..

Re: Processing 2.0 - 1,000,000 points in OpenGL using Vertex Arrays

1 year ago

Thanks for the input, definitely feels more like a hike up an uncharted mountain...

I checked out this import, but I get the following error in default Processing 2.0b3:

No library found for com.jogamp.common.nio

It still detects the class (Buffers) and runs the code, spitting out the following error:

Exception in thread "AWT-EventQueue-0" java.lang.UnsatisfiedLinkError: jogamp.opengl.gl4.GL4bcImpl.dispatch_glVertexPointer1(IIILjava/lang/Object;IZJ)V

at jogamp.opengl.gl4.GL4bcImpl.dispatch_glVertexPointer1(Native Method)

at jogamp.opengl.gl4.GL4bcImpl.glVertexPointer(GL4bcImpl.java:33134)

at example.setup(example.java:89)

at processing.core.PApplet.handleDraw(PApplet.java:2103)

at processing.opengl.PGL$PGLListener.display(PGL.java:2593)

at jogamp.opengl.GLDrawableHelper.displayImpl(GLDrawableHelper.java:189)

at jogamp.opengl.GLDrawableHelper.display(GLDrawableHelper.java:177)

at javax.media.opengl.awt.GLCanvas$DisplayAction.run(GLCanvas.java:928)

at jogamp.opengl.GLDrawableHelper.invokeGLImpl(GLDrawableHelper.java:425)

at jogamp.opengl.GLDrawableHelper.invokeGL(GLDrawableHelper.java:364)

at javax.media.opengl.awt.GLCanvas.maybeDoSingleThreadedWorkaround(GLCanvas.java:827)

at javax.media.opengl.awt.GLCanvas.display(GLCanvas.java:415)

at javax.media.opengl.awt.GLCanvas.paint(GLCanvas.java:515)

at sun.awt.RepaintArea.paintComponent(RepaintArea.java:248)

at sun.awt.X11.XRepaintArea.paintComponent(XRepaintArea.java:56)

at sun.awt.RepaintArea.paint(RepaintArea.java:224)

at sun.awt.X11.XComponentPeer.handleEvent(XComponentPeer.java:695)

at java.awt.Component.dispatchEventImpl(Component.java:4729)

at java.awt.Component.dispatchEvent(Component.java:4481)

at java.awt.EventQueue.dispatchEventImpl(EventQueue.java:648)

at java.awt.EventQueue.access$000(EventQueue.java:84)

at java.awt.EventQueue$1.run(EventQueue.java:607)

at java.awt.EventQueue$1.run(EventQueue.java:605)

at java.security.AccessController.doPrivileged(Native Method)

at java.security.AccessControlContext$1.doIntersectionPrivilege(AccessControlContext.java:87)

at java.security.AccessControlContext$1.doIntersectionPrivilege(AccessControlContext.java:98)

at java.awt.EventQueue$2.run(EventQueue.java:621)

at java.awt.EventQueue$2.run(EventQueue.java:619)

at java.security.AccessController.doPrivileged(Native Method)

at java.security.AccessControlContext$1.doIntersectionPrivilege(AccessControlContext.java:87)

at java.awt.EventQueue.dispatchEvent(EventQueue.java:618)

at java.awt.EventDispatchThread.pumpOneEventForFilters(EventDispatchThread.java:269)

at java.awt.EventDispatchThread.pumpEventsForFilter(EventDispatchThread.java:184)

at java.awt.EventDispatchThread.pumpEventsForHierarchy(EventDispatchThread.java:174)

at java.awt.EventDispatchThread.pumpEvents(EventDispatchThread.java:169)

at java.awt.EventDispatchThread.pumpEvents(EventDispatchThread.java:161)

at java.awt.EventDispatchThread.run(EventDispatchThread.java:122)

Already called beginDraw().

Here are the changes to the code above:

// new import for JOGL jogamp Buffers, top of the file
import com.jogamp.common.nio.Buffers;
// ... later in the code ... during setup ...
// Float Buffers for Processing 2.0
// commented out code:
//int vSize = (numPoints * 2);
//int cSize = (numPoints * 3);
//vSize = vSize << 2;
//cSize = cSize << 2;
//vbuffer = ByteBuffer.allocate(vSize).order(ByteOrder.nativeOrder()).asFloatBuffer();
//cbuffer = ByteBuffer.allocate(cSize).order(ByteOrder.nativeOrder()).asFloatBuffer();
// added code:
vbuffer = Buffers.newDirectFloatBuffer(numPoints * 2);
cbuffer = Buffers.newDirectFloatBuffer(numPoints * 3);

Peace.

andres

Re: Processing 2.0 - 1,000,000 points in OpenGL using Vertex Arrays

1 year ago

I think one problem is that you need to allocate the byte buffer as direct:

vbuffer = ByteBuffer.allocateDirect(vSize).order(ByteOrder.nativeOrder()).asFloatBuffer();
cbuffer = ByteBuffer.allocateDirect(cSize).order(ByteOrder.nativeOrder()).asFloatBuffer();

You mentioned that PShape and/or textured images are two slow. Is this with 1.x or 2.0? In 2.0, you should be able to create PShape objects that hold large geometries and still render fairly quickly.

mckennaps..

Re: Processing 2.0 - 1,000,000 points in OpenGL using Vertex Arrays

1 year ago

Thank you andres!

I have done all my testing on 2.0. I am trying to optimize the visualization to achieve a higher frame rate.

I am looking to code an interactive visualization tool that provides smooth animation of motion for a large number of data points, between 30,000 and 150,000. I am seeing if the new version of Processing can display this much data, otherwise I will have to look at programming the tool in a different language.

So for testing, I am just using Processing to display all of these data points and animate them as they move to different positions on the screen. I am using randomly generated locations for all the points, and they get randomized every time you press a key. The program interpolates between each point's pair of random locations, like Ben Fry's Integrator class. All of this works, but it is quite slow.

To optimize the code, I have tried using many rect() objects, a single PImage many times, a single PShape many times (retained, like the example in Processing), and generating OpenGL quads. Of these, the PShape (retained) & OpenGL quads have been the fastest methods on my machine. For 30,000 points, these methods only gave me 22 fps.

As such, I am trying other methods of optimization to see if I can achieve these motions at a better frame rate.

Changing the buffers to direct allocation from my original post results in the following error:

Exception in thread "Animation Thread" java.lang.RuntimeException: java.lang.UnsatisfiedLinkError: jogamp.opengl.gl4.GL4bcImpl.dispatch_glVertexPointer1(IIILjava/lang/Object;IZJ)V

at processing.opengl.PGL.requestDraw(PGL.java:1019)

at processing.opengl.PGraphicsOpenGL.requestDraw(PGraphicsOpenGL.java:1521)

at processing.core.PApplet.run(PApplet.java:2006)

at java.lang.Thread.run(Thread.java:662)

Caused by: java.lang.UnsatisfiedLinkError: jogamp.opengl.gl4.GL4bcImpl.dispatch_glVertexPointer1(IIILjava/lang/Object;IZJ)V

at jogamp.opengl.gl4.GL4bcImpl.dispatch_glVertexPointer1(Native Method)

at jogamp.opengl.gl4.GL4bcImpl.glVertexPointer(GL4bcImpl.java:33134)

at example.setup(example.java:83)

at processing.core.PApplet.handleDraw(PApplet.java:2103)

at processing.opengl.PGL$PGLListener.display(PGL.java:2593)

at jogamp.opengl.GLDrawableHelper.displayImpl(GLDrawableHelper.java:189)

at jogamp.opengl.GLDrawableHelper.display(GLDrawableHelper.java:177)

at javax.media.opengl.awt.GLCanvas$DisplayAction.run(GLCanvas.java:928)

at jogamp.opengl.GLDrawableHelper.invokeGLImpl(GLDrawableHelper.java:425)

at jogamp.opengl.GLDrawableHelper.invokeGL(GLDrawableHelper.java:364)

at javax.media.opengl.awt.GLCanvas$DisplayOnEventDispatchThreadAction.run(GLCanvas.java:945)

at java.awt.event.InvocationEvent.dispatch(InvocationEvent.java:199)

at java.awt.EventQueue.dispatchEventImpl(EventQueue.java:646)

at java.awt.EventQueue.access$000(EventQueue.java:84)

at java.awt.EventQueue$1.run(EventQueue.java:607)

at java.awt.EventQueue$1.run(EventQueue.java:605)

at java.security.AccessController.doPrivileged(Native Method)

at java.security.AccessControlContext$1.doIntersectionPrivilege(AccessControlContext.java:87)

at java.awt.EventQueue.dispatchEvent(EventQueue.java:616)

at java.awt.EventDispatchThread.pumpOneEventForFilters(EventDispatchThread.java:269)

at java.awt.EventDispatchThread.pumpEventsForFilter(EventDispatchThread.java:184)

at java.awt.EventDispatchThread.pumpEventsForHierarchy(EventDispatchThread.java:174)

at java.awt.EventDispatchThread.pumpEvents(EventDispatchThread.java:169)

at java.awt.EventDispatchThread.pumpEvents(EventDispatchThread.java:161)

at java.awt.EventDispatchThread.run(EventDispatchThread.java:122)

Peace.

andres

Re: Processing 2.0 - 1,000,000 points in OpenGL using Vertex Arrays

1 year ago

This is the code I'm running w/out any problems, based on the first post:

import javax.media.opengl.GL;
import javax.media.opengl.GL2;
import java.nio.*;
// let's try 1,000,000 points
int numPoints = 1000000;
// pan, zoom and rotate
float tx = 0, ty = 0;
float sc = 1;
float a = 0.0;
FloatBuffer vbuffer;
FloatBuffer cbuffer;
void setup() {
size(displayWidth/2, displayHeight/2, OPENGL);
smooth();
PGraphicsOpenGL pg = ((PGraphicsOpenGL)g);
PGL pgl = pg.beginPGL();
GL gl = pgl.gl;
GL2 gl2 = pgl.gl.getGL2();
int vSize = (numPoints * 2);
int cSize = (numPoints * 3);
vSize = vSize << 2;
cSize = cSize << 2;
vbuffer = ByteBuffer.allocateDirect(vSize).order(ByteOrder.nativeOrder()).asFloatBuffer();
cbuffer = ByteBuffer.allocateDirect(cSize).order(ByteOrder.nativeOrder()).asFloatBuffer();
for (int i = 0; i < numPoints; i++) {
// random x,y
vbuffer.put(random(width));
vbuffer.put(random(height));
// random r,g,b
cbuffer.put(random(1.0));
cbuffer.put(random(1.0));
cbuffer.put(random(1.0));
}
vbuffer.rewind();
cbuffer.rewind();
gl2.glEnableClientState(GL2.GL_VERTEX_ARRAY);
gl2.glVertexPointer(2, GL2.GL_FLOAT, 0, vbuffer);
gl2.glEnableClientState(GL2.GL_COLOR_ARRAY);
gl2.glColorPointer(3, GL2.GL_FLOAT, 0, cbuffer);
pg.endPGL();
}
void draw() {
background(0);
PGraphicsOpenGL pg = ((PGraphicsOpenGL)g);
PGL pgl = pg.beginPGL();
GL gl = pgl.gl;
GL2 gl2 = pgl.gl.getGL2();
gl2.glPushMatrix();
gl2.glTranslatef(width/2, height/2, 0);
gl2.glScalef(sc,sc,sc);
gl2.glRotatef(a, 0.0, 0.0, 1.0);
gl2.glTranslatef(-width/2, -height/2, 0);
gl2.glTranslatef(tx,ty, 0);
gl2.glPointSize(2.0);
gl2.glDrawArrays(GL2.GL_POINTS, 0, numPoints);
gl2.glPopMatrix();
pg.endPGL();
}
void mouseDragged() {
float dx = (mouseX - pmouseX) / sc;
float dy = (mouseY - pmouseY) / sc;
float angle = radians(-a);
float rx = cos(angle)*dx - sin(angle)*dy;
float ry = sin(angle)*dx + cos(angle)*dy;
tx += rx;
ty += ry;
}

does it crash on your machine?

mckennaps..

Re: Processing 2.0 - 1,000,000 points in OpenGL using Vertex Arrays

1 year ago

I received that same error as in my previous post running both 32-bit Ubuntu 12.04 and 64-bit Windows 7. On Windows 7, I tried both the 32 and 64 bit Processing versions. All Processing v.2.0b3.

I had a colleague run the program on his 17" MacBook Pro running Mac OS X (Snow Leopard or newer), and he did not receive errors. However, it should display a screen full of randomly-colored pixels, but it only displays a black screen.

It did not run on Mac OS X Snow Leopard on an old MacBook, appearing not to support OpenGL 2.

Definitely some compatibility issues, possibly just with which operating systems come with Jogamp JOGL support?

Peace.

jeff_g

Re: Processing 2.0 - 1,000,000 points in OpenGL using Vertex Arrays

10 months ago

I've also been unable to get Andres's example code to work. Tested on Max OSX 10.8.2 and 10.6.8. Maybe it is the same issue affecting this example, which I think the 2.x code I posted should work.
http://wiki.processing.org/w/Advanced_OpenGL

mckennaps..

Re: Processing 2.0 - 1,000,000 points in OpenGL using Vertex Arrays

10 months ago

jeff_g, I tried that same code for 2.0b7 on Windows, and it rendered a plain white screen, nothing more. That is not what the 1.5.1 code shows (rotating planes). So there are no errors and it runs, but the output is not the same.

The code that andres posted above runs and produces no errors for me now in the latest version of Processing (2.0b7) for both Windows & Linux. However, it also does not have the desired output. The screen should be full of randomly colored squares, and instead it just outputs a plain, black screen. I am unclear why this is.

Peace.

andres

Re: Processing 2.0 - 1,000,000 points in OpenGL using Vertex Arrays

10 months ago

What was missing in the code I posted before is the copy of the Processing projection and modelview matrices to the corresponding matrices in OpenGL:

import javax.media.opengl.GL;
import javax.media.opengl.GL2;
import java.nio.*;
// let's try 1,000,000 points
int numPoints = 1000000;
// pan, zoom and rotate
float tx = 0, ty = 0;
float sc = 1;
float a = 0.0;
FloatBuffer vbuffer;
FloatBuffer cbuffer;
float[] projMatrix;
float[] mvMatrix;
void setup() {
size(displayWidth/2, displayHeight/2, OPENGL);
smooth();
PGraphicsOpenGL pg = ((PGraphicsOpenGL)g);
PGL pgl = pg.beginPGL();
GL gl = pgl.gl;
GL2 gl2 = pgl.gl.getGL2();
int vSize = (numPoints * 2);
int cSize = (numPoints * 3);
vSize = vSize << 2;
cSize = cSize << 2;
vbuffer = ByteBuffer.allocateDirect(vSize).order(ByteOrder.nativeOrder()).asFloatBuffer();
cbuffer = ByteBuffer.allocateDirect(cSize).order(ByteOrder.nativeOrder()).asFloatBuffer();
for (int i = 0; i < numPoints; i++) {
// random x,y
vbuffer.put(random(width));
vbuffer.put(random(height));
// random r,g,b
cbuffer.put(random(1.0));
cbuffer.put(random(1.0));
cbuffer.put(random(1.0));
}
vbuffer.rewind();
cbuffer.rewind();
gl2.glEnableClientState(GL2.GL_VERTEX_ARRAY);
gl2.glVertexPointer(2, GL2.GL_FLOAT, 0, vbuffer);
gl2.glEnableClientState(GL2.GL_COLOR_ARRAY);
gl2.glColorPointer(3, GL2.GL_FLOAT, 0, cbuffer);
pg.endPGL();
projMatrix = new float[16];
mvMatrix = new float[16];
}
void draw() {
background(0);
PGraphicsOpenGL pg = ((PGraphicsOpenGL)g);
PGL pgl = pg.beginPGL();
GL gl = pgl.gl;
GL2 gl2 = pgl.gl.getGL2();
gl2.glMatrixMode(GL2.GL_PROJECTION);
projMatrix[0] = pg.projection.m00;
projMatrix[1] = pg.projection.m10;
projMatrix[2] = pg.projection.m20;
projMatrix[3] = pg.projection.m30;
projMatrix[4] = pg.projection.m01;
projMatrix[5] = pg.projection.m11;
projMatrix[6] = pg.projection.m21;
projMatrix[7] = pg.projection.m31;
projMatrix[8] = pg.projection.m02;
projMatrix[9] = pg.projection.m12;
projMatrix[10] = pg.projection.m22;
projMatrix[11] = pg.projection.m32;
projMatrix[12] = pg.projection.m03;
projMatrix[13] = pg.projection.m13;
projMatrix[14] = pg.projection.m23;
projMatrix[15] = pg.projection.m33;
gl2.glLoadMatrixf(projMatrix, 0);
gl2.glMatrixMode(GL2.GL_MODELVIEW);
mvMatrix[0] = pg.modelview.m00;
mvMatrix[1] = pg.modelview.m10;
mvMatrix[2] = pg.modelview.m20;
mvMatrix[3] = pg.modelview.m30;
mvMatrix[4] = pg.modelview.m01;
mvMatrix[5] = pg.modelview.m11;
mvMatrix[6] = pg.modelview.m21;
mvMatrix[7] = pg.modelview.m31;
mvMatrix[8] = pg.modelview.m02;
mvMatrix[9] = pg.modelview.m12;
mvMatrix[10] = pg.modelview.m22;
mvMatrix[11] = pg.modelview.m32;
mvMatrix[12] = pg.modelview.m03;
mvMatrix[13] = pg.modelview.m13;
mvMatrix[14] = pg.modelview.m23;
mvMatrix[15] = pg.modelview.m33;
gl2.glLoadMatrixf(mvMatrix, 0);
gl2.glPushMatrix();
gl2.glTranslatef(width/2, height/2, 0);
gl2.glScalef(sc,sc,sc);
gl2.glRotatef(a, 0.0, 0.0, 1.0);
gl2.glTranslatef(-width/2, -height/2, 0);
gl2.glTranslatef(tx,ty, 0);
gl2.glPointSize(2.0);
gl2.glDrawArrays(GL2.GL_POINTS, 0, numPoints);
gl2.glPopMatrix();
pg.endPGL();
}
void mouseDragged() {
float dx = (mouseX - pmouseX) / sc;
float dy = (mouseY - pmouseY) / sc;
float angle = radians(-a);
float rx = cos(angle)*dx - sin(angle)*dy;
float ry = sin(angle)*dx + cos(angle)*dy;
tx += rx;
ty += ry;
}

You have to do the glLoadMatrixf() call manually because the OpenGL renderer only uses functions available in the GLES2 API, and all the matrix-related functions are gone in GLES2 (and GL 3.2+).

jeff_g

Re: Processing 2.0 - 1,000,000 points in OpenGL using Vertex Arrays

10 months ago

Thanks Andres, this looks like it fixed a few sketches for me. Is there anything we can do to simplify this - a new call to load this that is compatible? Does the matrix need to be loaded once, or is it in each draw cycle? If the matrix-related functions are gone, what is the replacement in GLES2 and GL 3.2+?

Maybe the matrix could automatically be loaded for the GL if it is compatible... ?

Thanks, Jeff

andres

Re: Processing 2.0 - 1,000,000 points in OpenGL using Vertex Arrays

10 months ago

You should load the matrices every time you change them: for example, if you call perspective() or ortho(), then you have to load the projection matrix. If you use camera() or any geometric transformation (translate, rotate, scale), then you need to load the modelview.

There is no replacement for those functions in GLES2, GL3+, you have to take care of the projection/modelview matrices all by yourself and then pass the corresponding arrays to the shaders.

jeff_g

Re: Processing 2.0 - 1,000,000 points in OpenGL using Vertex Arrays

10 months ago

Ok, so has a shader already been written for Processing that is called when these are used? If so, is it public where I could call it as oppose to doing my own. If not, doesn't Processing need it? Thanks :)

jeff_g

Re: Processing 2.0 - 1,000,000 points in OpenGL using Vertex Arrays

10 months ago

Andres, I see that you added this to the beginPGL() in r10729 - awesome.

That will fix tons of issues I was dealing with. Do you foresee changing this into a shader? I expect it would be backward compatible, as well as forward compatible.

In any case, I'm glad to see it tied directly into the beginPGL().

andres

Re: Processing 2.0 - 1,000,000 points in OpenGL using Vertex Arrays

10 months ago

Processing automatically sends all the required matrices to the shaders, provided that they define the appropriate uniform variables. See how it is done in the Demos|Graphics|LowLevelGL example. This example assumes no fixed-function pipeline, so the GL matrix-related functions (glMatrixMode, glLoadMatrix, etc) are not used at all.

Top Reply