Great to now that the off-screen mode now works! Thanks a lot for your feedback and testing!

Regarding the particle systems, the solution to the compatibility problems with ATI is more involved, since I implemented those examples using an technique called Vertex Texture Fetch (VTF) which allows to modify vertex position using vales stored inside a floating-point texture. This technique works on NVidia since the geforces 6x00, but it is not supported on the R500 GPU (the one used in the 1x00 line). I think it is supported in the next generation of Radeons (2x00 and later) but I don't have any confirmation about this.

However, there is a workaround to this problem, which consists in using an alternative technique called Render to Vertex Buffer (R2VF). This works both on NVidia and ATI, but requires some additional coding in the library. My plan is to include R2VF in the 0.9 release of GLGraphics. But, it will take some time...

Wait... I understood that it wasn't working. Well, that is interesting! So you are running SimpleGPUParticleSystem on a X1900XT, right?

23fps is what I get on a nvidia geforce 8400. To tell you the truth, I don't know why it is working, as I said, the extension I'm using to render the particles in the correct position is supposedly not supported on ATI 1x00.

Hi Andres, I'm using the offscreen rendering now and works great. One question I have is though, how do I deal with raw opengl commands when dealing with GLGraphics? My situation is this:

I have a couple of different textures, and I don't want to draw them with the image command, but bind the texture once, and then draw a few thousand quads on one GLGraphics, and then bind another texture and draw another few thousand on another GLGraphics with a different texture etc. Also change blending functions to additive, normal, enable/disable etc. I guess I still need a global pgl and gl and do all opengl state changes on that? Can I draw raw gl commands to a GLGraphics?

cheers,

yes, you can just obtain the opengl id of the GLTexture with the getTextureID method, and then just use the opengl raw commands to texture geometric primitives with the texture. This requires defining the pgl, gl variables.

ok, I found out what I need to do. Hadn't seen GLGraphics was extending PGraphicsOpenGL working code is below.

Code:

import processing.opengl.*;
import javax.media.opengl.*;
import codeanticode.glgraphics.*;

GLGraphics glg1, glg2;

float mixFactor = 0.5;

PGraphicsOpenGL pgl; 
GL gl;
int dlQuad;	    // display list for quads

void setup() {
    size(640, 480, GLConstants.GLGRAPHICS);
    msaInitGL();
    glg1 = new GLGraphics(300, 300, this, true);
    glg2 = new GLGraphics(200, 100, this, true);
}

void draw() {
    background(0);

    glg1.beginDraw();
    gl = msaBeginGL(glg1);
    gl.glColor4f( 1, 0, 0, random(1));
    drawQuad(random(0, glg1.width), random(0, glg1.height), random(20));
    msaEndGL();
    glg1.ellipse(random(0, glg1.width), random(0, glg1.height), random(50), random(50));
    glg1.endDraw();
 
    glg2.beginDraw();
    gl = msaBeginGL(glg2);
    gl.glColor4f( 0, 1, 0, random(1));    
    drawQuad(random(0, glg2.width), random(0, glg2.height), random(20));
    msaEndGL();
    glg2.ellipse(random(0, glg2.width), random(0, glg2.height), random(50), random(50));
    glg2.endDraw();

    // We mix the images together and scale them so the occupy the entire screen.
    tint(1, 1 - mixFactor);
    image(glg1.getTexture(), 0, 0, width, height); 
    tint(1, mixFactor);
    image(glg2.getTexture(), 0, 0, width, height);

}

void mouseDragged() {
    mixFactor = float(mouseX) / width;
}


void msaInitGL() {
    colorMode( RGB, 1.0 );     // to make colors 0..1 (not 0..255)
    pgl = (PGraphicsOpenGL) g;	   // processings opengl graphics object
    gl = pgl.beginGL();		    // JOGL's GL object
    gl.setSwapInterval(1);
    msaCreateQuadDisplayList();	     // create a display list for drawing quads
    gl.glDisable(GL.GL_DEPTH_TEST);    // disable any use of zbuffer
    gl.glBlendFunc(GL.GL_SRC_ALPHA, GL.GL_ONE_MINUS_SRC_ALPHA);    // set blend mode to normal alpha
    gl.glEnable( GL.GL_TEXTURE_2D );					  // enable texturing    
    pgl.endGL();
}

// create quad display list
void msaCreateQuadDisplayList() {
    dlQuad = gl.glGenLists(1);
    gl.glNewList(dlQuad, GL.GL_COMPILE);
    gl.glBegin(GL.GL_QUADS);
    gl.glTexCoord2f(0, 0);    
    gl.glVertex2f( -1, -1);
    gl.glTexCoord2f(1, 0);    
    gl.glVertex2f( 1, -1);
    gl.glTexCoord2f(1, 1);    
    gl.glVertex2f( 1,  1);
    gl.glTexCoord2f(0, 1);    
    gl.glVertex2f(-1,  1);
    gl.glEnd();
    gl.glEndList();
}

GL msaBeginGL(GLGraphics glGraphics) {
    pgl = (PGraphicsOpenGL) glGraphics;
    gl = pgl.beginGL();
    return gl;
}

void msaEndGL() {
    pgl.endGL();
}

void drawQuad(float x, float y, float radius) {
    gl.glPushMatrix();
    gl.glTranslatef(x, y, 0);
    gl.glScalef( radius, radius, 1 );
    gl.glCallList( dlQuad );
    gl.glPopMatrix();
}