I'm testing using a Display List right now and it is very fast, but I'd like to try a VBO as I'm probably going to want to update the data.

And if you know the magic on how to turn those four vertex's into point sprites, I would sure like to know.  I keep trying but am not having much luck with displaying it.  I have current mac hardware so I wouldn't think my video card would be an issue.  I think I'm just doing it wrong.. though I can't figure out why.

I've noticed a really weird bug. When you call perspective(), it seems to flip the Y-axis of anything rendered with SuperPoint/SuperTri.

Code:

import com.hardcorepawn.*;
import processing.opengl.*;

SuperPoint p;

void setup() {
  size(512, 512, OPENGL);
  p=new SuperPoint(this);
  for(int i = 0; i < 100000; i++) {
    p.addPoint(
	random(-100,100), random(-100,100), random(-100,100),
	random(1), random(1), random(1), random(1));
  }
}

void draw() {
  background(0);
  if(mousePressed) {
    float cameraZ = (height / 2.0) / tan(PI * 60.0 / 360.0);
    perspective(PI / 3.0, (float) width / (float) height, cameraZ / 10.0, cameraZ * 10.0);
  }
  translate(mouseX, mouseY, -512);
  box(200);
  p.draw(3);
}

 

If you run this sketch and alternate holding the mouse down, you'll notice the box() and the SuperPoint cloud either being in the same space or mirroring each other.

Any ideas?

Thanks for the idea -- but I've tried that already and it just inverts everything (i.e., the box and the cloud just exchange positions).

I think it's something more insidious that has to do with the OpenGL projection matrix not being reset immediately when you call perspective().

If I simplify the code a bit:

Code:

if(mousePressed)
 perspective();
 

It still doesn't work... but strangely, if I move that call to another thread:

Code:

void mouseMoved() {
  perspective();
}
 

There is no issue.

That's what makes me think it's a problem with calling perspective() every frame... I just don't understand what the difference is between the way box() is drawn and the way a SuperPoint is drawn.

Ah, I see -- that doesn't really work either, though, as I want to apply the same series of rotations/translations to both objects:

Code:

  background(0);
  if(mousePressed)
    perspective();
  
  translate(mouseX, mouseY, -512);
  
  pushMatrix();
  if(mousePressed)
    scale(1, -1, 1);
  box(200);
  popMatrix();
  
  p.draw(3);
 

(scale() would have to be before the first translate().)

In this simple case, I could always just use two separate translates... but the actual usage is more complicated, and I have a bunch of translates/rotates/etc. that are applied to SuperPoint and non-SuperPoint objects...

Is there maybe some way of forcing SuperPoint to use the same modelview matrix as Processing? All it's doing is basically:

Code:

    gl = ((PGraphicsOpenGL)p.g).beginGL();
    ...
    gl.glDrawArrays(GL.GL_TRIANGLES, 0, numTris * 3);
    ((PGraphicsOpenGL)p.g).endGL();
 

So maybe the Processing matrix just hasn't been "applied" to the GL context yet?

Hey Victor -- just want to say thanks so much for all your help so far

It's not that I'm worried about the complexity of the transform. Just that the order is important. If both the box() and the SuperPoint need to move mouseY distance vertically, but one in the positive direction and the other in the negative direction, then I need to call scale() before I call translate() -- but have it only apply in one case and not the other (which doesn't really make sense).

Furthermore, I think it's more than just a scale(1, -1, 1) difference between the two cases. Here's a sketch that calls perspective() every frame so long as you're holding the mouse down:

Code:

import com.hardcorepawn.*;
import processing.opengl.*;

SuperPoint p;

void setup() {
  size(640, 480, OPENGL);
  p=new SuperPoint(this);
  for(int i = 0; i < 100000; i++) {
    p.addPoint(
      random(-100,100), random(-100,100), random(-100,100),
      random(1), random(1), random(1), random(1));
  }
}

void draw() {
  background(0);
  if(mousePressed)
    perspective();
  
  pushMatrix();
  translate(mouseX, mouseY, -512);
  rotateX(radians(mouseY));
  rotateY(radians(mouseX));
  rotateZ(radians(mouseX));
  box(200);
  popMatrix();
  
  pushMatrix();
  if(mousePressed) {
    if(keyPressed) {
      translate(0, height, 0);
      scale(1, -1, 1);
      translate(mouseX, mouseY, -512);
      rotateX(radians(mouseY));
      rotateY(radians(mouseX));
      rotateZ(radians(mouseX));
    } else {
      translate(mouseX, height - mouseY, -512);
      rotateX(-radians(mouseY));
      rotateY(radians(mouseX));
      rotateZ(-radians(mouseX));
    }
  } else {
    translate(mouseX, mouseY, -512);
    rotateX(radians(mouseY));
    rotateY(radians(mouseX));
    rotateZ(radians(mouseX));
  }
  p.draw(3);
  popMatrix();
}
 

You can see that the corollary of:

Code:

translate(mouseX, mouseY, -512);
rotateX(radians(mouseY));
rotateY(radians(mouseX));
rotateZ(radians(mouseX));
 

Can't be accomplished by simply preceding it with a scale(1, -1, 1), but has to be done:

Code:

translate(mouseX, height - mouseY, -512);
rotateX(-radians(mouseY));
rotateY(radians(mouseX));
rotateZ(-radians(mouseX));
 

If you have an idea of something I can tell OpenGL that will effectively accomplish this same thing (negative scale with height offset, negative x and z rotations)... that would be super helpful!

i've tested your example and here it is working.

Code:

import com.hardcorepawn.*;
import processing.opengl.*;

SuperPoint p;

void setup() 
{
  size(640, 480, OPENGL);
  p=new SuperPoint(this);
  for(int i = 0; i < 100000; i++) {
    p.addPoint(
	random(-100,100), random(-100,100), random(-100,100),
	random(1), random(1), random(1), random(1));
  }
}

void draw() 
{
  background(0);
  
  perspective();// PI*0.25, 4.0/3.0, 1, 2000 );
  
  pushMatrix();
  translate( width*0.5, height*0.5 );    // processing likes top-left as center.. i don't like that neither does opengl in perspective mode
  translate( mouseX-(width*0.5), mouseY-(height*0.5), -512);
  rotateX(radians(mouseY));
  rotateY(radians(mouseX));
  rotateZ(radians(mouseX));
  box(200);
  popMatrix();

  pushMatrix();
  translate( width*0.5, height*0.5 );    // processing likes top-left as center.. i don't like that neither does opengl in perspective mode
  translate( mouseX-(width*0.5), (HEIGHT-mouseY)+(height*0.5), -512); // invert y. the offset is just to get the mouse motion/anim as you had before
  rotateX(-radians(mouseY)); // rotations also play different 
  rotateY(radians(mouseX));
  rotateZ(-radians(mouseX));
  p.draw(3);
  popMatrix();
}