pretty nice, i like the jellyfish look at the beginning.
As it is for live visuals, i guess it runs in realtime, right?

Sure!
Everything is controlled live, or else, it would stay static. The shape, the particles, the camera, eveything is manipulated by the one who's controlling the keyboard ;)

This "vj instrument" allow sooo many possibilities that the interactor can creates his visual like he wants to. Someway, that was the goal.

Yes, everything is made with Processing's openGL commands except for the blending (that is made with 'real' openGL).
I would give you the code if i wasnt restricted by some confidentiality rules.
anyways, ask me any questions, don't hesitate :) i just cannot give you the source. sry

:)

Really nice! Like cedrickiefer said, the jellyfish look in the beginning looks really sweet

Wow, that's amazing!  I sooo want to know how you did those visuals.  They look fantastic.   Really liked 26sec - 1:10sec

Could you give an example of the texture and how you blended it?  And those trails... sweet!  Nice work

really really great!

@jeff_g: to learn more about blending methods, i recommand you to look at the code below.

1. /**
    * Space Junk 
    * By Ira Greenberg
    * zoom suggestion
    * By Danny Greenberg
    *
    * Rotating cubes in space using
    * a custom Cube class. Color controlled
    * by light sources.
    *
    *
    * modified to test opengl blending
    *
    *
    * animation pause,switch background color, blend mode textual output
    * added by Claudio Midolo
    */
   
   /*need to import opengl library to use OPENGL
    rendering mode for hardware acceleration*/
   import processing.opengl.*;
   import javax.media.opengl.*;
   import java.util.*;
   
   //used for oveall rotation
   float ang;
   
   //cube count-lower/raise to test P3D/OPENGL performance
   int limit = 300;
   
   //array for all cubes
   Cube[]cubes = new Cube[limit];
   PGraphicsOpenGL pgl;
   GL gl;
   
   nvArray GLblendL = new nvArray();
   nvArray GLblendR = new nvArray();
   boolean blnDisableZTest = true;
   
   boolean blackBackground,pause,help;
   
   PFont font;
   
   void setup(){
     //try substituting P3D for OPENGL
     //argument to test performance
     size(400, 400, OPENGL);
     //hint(ENABLE_OPENGL_4X_SMOOTH) ;
     background(0);
     frameRate(40);
     noStroke();
     //instantiate cubes, passing in random vals for size and postion
    
     color _col=color(90);
    
    
     for (int i = 0; i< cubes.length; i++){
      
       int rndmColIndex= int(random(0,3));
    
     if(rndmColIndex==0){
      
       _col=color(255,255,0);
    
     }else if(rndmColIndex==1){
      
       _col=color(255,0,255);
    
     }else if(rndmColIndex==2){
      
       _col=color(0,255,255);
    
     }
      
      
       cubes[i] = new Cube(int(random(-10, 10)), int(random(-10, 10)),
       int(random(-10, 10)), int(random(-140, 140)), int(random(-140, 140)),
       int(random(-140, 140)),
       _col
       );
     }
   
     /* setup the openGL blend enum into a name-value pair array
      ** so that we can keep track of what we are doing         */
     GLblendL.add("GL_ZERO",GL.GL_ZERO);    
     GLblendL.add("GL_ONE",GL.GL_ONE);    
     GLblendL.add("GL_SRC_COLOR",GL.GL_SRC_COLOR    );
     GLblendL.add("GL_ONE_MINUS_SRC_COLOR",GL.GL_ONE_MINUS_SRC_COLOR);
     GLblendL.add("GL_DST_COLOR",GL.GL_DST_COLOR    );
     GLblendL.add("GL_ONE_MINUS_DST_COLOR",GL.GL_ONE_MINUS_DST_COLOR);    
     GLblendL.add("GL_SRC_ALPHA",GL.GL_SRC_ALPHA    );
     GLblendL.add("GL_ONE_MINUS_SRC_ALPHA",GL.GL_ONE_MINUS_SRC_ALPHA);    
     GLblendL.add("GL_DST_ALPHA",GL.GL_DST_ALPHA    );
     GLblendL.add("GL_ONE_MINUS_DST_ALPHA",GL.GL_ONE_MINUS_DST_ALPHA);    
     GLblendL.add("GL_SRC_ALPHA_SATURATE",GL.GL_SRC_ALPHA_SATURATE);  //invalid enum... wtf?   
     GLblendL.add("GL_CONSTANT_COLOR",GL.GL_CONSTANT_COLOR    );
     GLblendL.add("GL_ONE_MINUS_CONSTANT_COLOR",GL.GL_ONE_MINUS_CONSTANT_COLOR );
     GLblendL.add("GL_CONSTANT_ALPHA",GL.GL_CONSTANT_ALPHA );
     GLblendL.add("GL_ONE_MINUS_CONSTANT_ALPHA",GL.GL_ONE_MINUS_CONSTANT_ALPHA );
     GLblendR.add("GL_ZERO",GL.GL_ZERO);    
     GLblendR.add("GL_ONE",GL.GL_ONE);    
     GLblendR.add("GL_SRC_COLOR",GL.GL_SRC_COLOR    );
     GLblendR.add("GL_ONE_MINUS_SRC_COLOR",GL.GL_ONE_MINUS_SRC_COLOR);
     GLblendR.add("GL_DST_COLOR",GL.GL_DST_COLOR    );
     GLblendR.add("GL_ONE_MINUS_DST_COLOR",GL.GL_ONE_MINUS_DST_COLOR);    
     GLblendR.add("GL_SRC_ALPHA",GL.GL_SRC_ALPHA    );
     GLblendR.add("GL_ONE_MINUS_SRC_ALPHA",GL.GL_ONE_MINUS_SRC_ALPHA);    
     GLblendR.add("GL_DST_ALPHA",GL.GL_DST_ALPHA    );
     GLblendR.add("GL_ONE_MINUS_DST_ALPHA",GL.GL_ONE_MINUS_DST_ALPHA);
     GLblendR.add("GL_CONSTANT_COLOR",GL.GL_CONSTANT_COLOR    );
     GLblendR.add("GL_ONE_MINUS_CONSTANT_COLOR",GL.GL_ONE_MINUS_CONSTANT_COLOR );
     GLblendR.add("GL_CONSTANT_ALPHA",GL.GL_CONSTANT_ALPHA );
     GLblendR.add("GL_ONE_MINUS_CONSTANT_ALPHA",GL.GL_ONE_MINUS_CONSTANT_ALPHA );
     println( "Blend mode : glBlendFunc( "+GLblendL.getCurrentName() +" , "+ GLblendR.getCurrentName() + " )");
    
     //Blend mode : glBlendFunc( GL_ZERO , GL_SRC_COLOR ) is multiply
     //Blend mode : glBlendFunc( GL_DST_COLOR , GL_ZERO ) is multiply check
     //https://developer.playfirst.com/node/300
    
     //set to multiply
     GLblendL.pos=0;
     GLblendR.pos=2;
    
     //
   
     blackBackground=false;
     pause=false;
     help=true;
    
     font=loadFont("f.vlw");
     textFont(font,10);
   
   }
   
   void draw(){
     // *** blending setup *** //
     pgl = (PGraphicsOpenGL) g;
     gl = pgl.beginGL();
     if( blnDisableZTest )
       gl.glDisable(GL.GL_DEPTH_TEST);
     gl.glEnable(GL.GL_BLEND);
     gl.glBlendFunc( GLblendL.getCurrent(), GLblendR.getCurrent() );
     pgl.endGL();
     // ***  end blending setup *** //
   
     if(blackBackground){
       background(0);
     }
     else{
       background(255);
     }
   
     //fill(200);
     //set up some different colored lights
     pointLight(255, 255, 255, 65, 60, 100);
     pointLight(255, 255, 255, -65, -60, -150);
   
     //raise overall light in scene
     ambientLight(255, 255, 255);
    
     pushMatrix();
   
     /*center geometry in display windwow.
      you can change 3rd argument ('0')
      to move block group closer(+)/further(-)*/
     translate(width/2, height/2, -200+mouseX);
   
     //rotate around y and x axes
     rotateY(radians(ang));
     rotateX(radians(ang));
   
     //draw cubes
     for (int i = 0; i< cubes.length; i++){
       cubes[i].drawCube();
     }
    
     popMatrix();
    
     if(!pause){
       //used in rotate function calls above
       ang++;
     }
    
     if(blackBackground){
       fill(255);
       gl.glBlendFunc(GLblendL.getByIndex(6), GLblendL.getByIndex(0) );
     }else{
       fill(0);
       gl.glBlendFunc(GLblendL.getByIndex(10), GLblendL.getByIndex(7) );
     }
    
    
     text("Blend mode : glBlendFunc( "+GLblendL.getCurrentName() +" , "+ GLblendR.getCurrentName() + " )",10,10);
     if(help){
       text("e,d to cycle sfactor \nr,f for dfactor\nb to toggle background color\nz toggles Depth testing "+!blnDisableZTest+"\nspace toggles animation\nh toggle this help",10,height-70);
     }
    
   }
   
   void keyPressed(){
     switch( key ){
     case 'e':
       GLblendL.next();
       println( "Blend mode : glBlendFunc( "+GLblendL.getCurrentName() +" , "+ GLblendR.getCurrentName() + " )");
       break;
     case 'd':
       GLblendL.prev();
       println( "Blend mode : glBlendFunc( "+GLblendL.getCurrentName() +" , "+ GLblendR.getCurrentName() + " )");
       break;
     case 'r':
       GLblendR.next();
       println( "Blend mode : glBlendFunc( "+GLblendL.getCurrentName() +" , "+ GLblendR.getCurrentName() + " )");
       break;
     case 'f':
       GLblendR.prev();
       println( "Blend mode : glBlendFunc( "+GLblendL.getCurrentName() +" , "+ GLblendR.getCurrentName() + " )");
       break;
     case 'z':
       blnDisableZTest =!blnDisableZTest;
       if(blnDisableZTest)
         println( "Depth Testing Disable");
       else
         println( "Depth Testing Enabled");
       break; 
     case 'b':
       blackBackground=!blackBackground;
       break;
      case ' ':
       pause=!pause;
       break;
      case 'h':
       help=!help;
      break;
     }
   
   }
   
   
   //simple Cube class, based on Quads
   class Cube {
   
     //properties
     int w, h, d;
     int shiftX, shiftY, shiftZ;
    
     color col;
   
     //constructor
     Cube(int w, int h, int d, int shiftX, int shiftY, int shiftZ, color _col){
       this.w = w;
       this.h = h;
       this.d = d;
       this.shiftX = shiftX;
       this.shiftY = shiftY;
       this.shiftZ = shiftZ;
      
       col=_col;
     }
   
     /*main cube drawing method, which looks
      more confusing than it really is. It's
      just a bunch of rectangles drawn for
      each cube face*/
     void drawCube(){
      
       fill(col);
      
       beginShape(QUADS);
       //front face
       vertex(-w/2 + shiftX, -h/2 + shiftY, -d/2 + shiftZ);
       vertex(w + shiftX, -h/2 + shiftY, -d/2 + shiftZ);
       vertex(w + shiftX, h + shiftY, -d/2 + shiftZ);
       vertex(-w/2 + shiftX, h + shiftY, -d/2 + shiftZ);
   
       //back face
       vertex(-w/2 + shiftX, -h/2 + shiftY, d + shiftZ);
       vertex(w + shiftX, -h/2 + shiftY, d + shiftZ);
       vertex(w + shiftX, h + shiftY, d + shiftZ);
       vertex(-w/2 + shiftX, h + shiftY, d + shiftZ);
   
       //left face
       vertex(-w/2 + shiftX, -h/2 + shiftY, -d/2 + shiftZ);
       vertex(-w/2 + shiftX, -h/2 + shiftY, d + shiftZ);
       vertex(-w/2 + shiftX, h + shiftY, d + shiftZ);
       vertex(-w/2 + shiftX, h + shiftY, -d/2 + shiftZ);
   
       //right face
       vertex(w + shiftX, -h/2 + shiftY, -d/2 + shiftZ);
       vertex(w + shiftX, -h/2 + shiftY, d + shiftZ);
       vertex(w + shiftX, h + shiftY, d + shiftZ);
       vertex(w + shiftX, h + shiftY, -d/2 + shiftZ);
   
       //top face
       vertex(-w/2 + shiftX, -h/2 + shiftY, -d/2 + shiftZ);
       vertex(w + shiftX, -h/2 + shiftY, -d/2 + shiftZ);
       vertex(w + shiftX, -h/2 + shiftY, d + shiftZ);
       vertex(-w/2 + shiftX, -h/2 + shiftY, d + shiftZ);
   
       //bottom face
       vertex(-w/2 + shiftX, h + shiftY, -d/2 + shiftZ);
       vertex(w + shiftX, h + shiftY, -d/2 + shiftZ);
       vertex(w + shiftX, h + shiftY, d + shiftZ);
       vertex(-w/2 + shiftX, h + shiftY, d + shiftZ);
   
       endShape();
   
       //add some rotation to each box for pizazz.
       rotateY(radians(1));
       rotateX(radians(1));
       rotateZ(radians(1));
     }
   }
   
   //this is just an int name-value pair array I wrote a while back..
   //i've gutted it down to the few functions i am using in this sketch
   //for the sake of minimal code. however the full version is awesome.
   class nvArray {
     ArrayList name = new ArrayList();
     ArrayList val = new ArrayList();
     int length;
     int pos;
   
     nvArray(){
       length = 0;
       pos = 0;
     }
   
     void add(String l_name, int l_val){
       length++;
       name.add( l_name );
       val.add( new Integer(l_val) );
     }
   
     void next(){
       pos = (pos+1 == length)? 0 : pos+1;
     }
   
     void prev(){
       pos = (pos-1 <0)? length-1 : pos-1;
     }
   
     int getCurrent(){
       return ( (Integer)val.get( pos ) ).intValue();
     }
    
     int getByIndex(int _index){
       return ( (Integer)val.get( _index ) ).intValue();
     }
   
     String getCurrentName(){
       return( (String)name.get( pos ) );
     }
   }

in my code, i was using those lines

1.   gl.glClear( GL.GL_DEPTH_BUFFER_BIT ) ;
     gl.glEnable( GL.GL_DEPTH_TEST );
     gl.glDepthMask(false);
     gl.glEnable(GL.GL_BLEND);
     gl.glBlendFunc(GL.GL_SRC_ALPHA, GL.GL_ONE);

And for the particles textures, i simply used :

1. beginShape(TRIANGLE_STRIP);
2. tint(_tintValue);
3. texture(some pImage);
4. vertex(-1, -1, 0, 0);
5. vertex( 1, -1, 64, 0);
6. vertex(-1,  1, 0, 64);
7. vertex( 1,  1, 64, 64);   
   
8. endShape();

Finally, about trails... i don't really understand what you're saying.... i mean, these are simply bezier curves.
Anyways, if you want to make some trails.... real trails, you need a buffer and working with it. If you need more info, ask

Voilà

Excellent - any chance of linking to that pimage?  It's a nice looking particle.

I'm sorry, I cannot give you that. Like I said before, I got some restrictions ;)

Hi there, 

@ventai

did you look at http://processing.org/learning/3d/?
If you want to know more about opengl stuff, (advanced or not) goto : http://nehe.gamedev.net/ and follow the tutorials, they're great.

AND, if you cannot run Processing's OpenGL properly (that is in fact, JOGL [java opengl]), you should try to do it in C++ (ie: OpenFramework), but you need to know more about programming... ;)

Did i answered your question?

Thanks for the nehe link (i'm not ventai but i 'm interrested in too)

I have a need in my project to create some random paths around a line and a central object.  Essentially, I have a spring graph and I want to do a couple things. 

Some edges between two nodes have a frequency (meaning more than one connection - an increased weight).  I'd like to indicate this some how, by perhaps having particles (based on frequency) flow randomly along the line's path (constrained of course within a certain boundary of that line).

Some nodes have an importance (a weight), but I don't want to represent this in node "size".  I'd like to use colored particles circling the node in some random way.

I'm confident I can handle all the OpenGL stuff, textures, blending, etc - I have experience with that.  What I'm stuck on is how to create the paths in the first place.  I know the point of the node, and I know the end points of the lines, but I'm not sure how to create the paths for my particles to circle the node, and flow around the line.  And what would be the best method for animating this movement (Tween library, Animate library), and how best to update the positions (refill VBO vertex buffer - how best to cycle through)?

Thanks, Jeff

you link is broken ;)

Bezier:
to understand the bezier curves, take a look at wikipedia
And about processing, The way to creat bezier is ( here)
Maybe you know all about this, but i just wanted to make sure that you got every tools in your hands.
Now, after you've set up your bezier, if you need to "follow the path", you must take a look at bezierPoint.

Question:
are you working in 3d or 2d?

Im not 100% sure of what you really need, can you provide a picture or something?

I'm working in 3d ( something like this but way cooler).  In familiar with creating a bezier curve, if I know the points.  Problem is, what is the math to determine those points for a randomly orbiting particle.  Essentially, I want several particles to orbit a point (node).  I'd also like some particles to orbit a line and flow along its length (but not sure if that is the best way to approach this problem - something else may prove better as an indicator of "frequency").

As for the node, maybe picture something like this (around time marker 1:10), but less objects and more centered around the point.

look at this code found on the internet

1. //http://www.flong.com/storage/experience/newyear/newyear09/
   import javax.media.opengl.*;
   import processing.opengl.*;
   
   PFont font;
   PImage spot;
   SphericalDistanceCalculator SDC;
   PointOnUnitSphere pous[];
   
   
   int nPous;
   int maxNPous;
   float mx = 0;
   float my = 0;
   
   void setup(){
     size(400,440,OPENGL);
     hint(ENABLE_OPENGL_4X_SMOOTH);
   
     spot = loadImage("particle.png");
     font = loadFont("Palatino-Bold-16.vlw");
   
     nPous = 1;
     maxNPous = 1;
     pous = new PointOnUnitSphere[maxNPous];
     for (int i=0; i<maxNPous; i++){
       float lat = acos(random(-1,1)) - HALF_PI;
       float lon = random(0, TWO_PI);
       pous[i] = new PointOnUnitSphere(i);
       pous[i].setPositionFromCorrectLatLon(lat, lon);
     }
   
     SDC = new SphericalDistanceCalculator();
   }
   
   
   
   
   long lastFrameTime = 0;
   long lastAddTime = 0;
   float mspf = 16.6666;
   //--------------------------------------------
   void draw(){
    
     long now = millis();
     updateEu();
   
     background(0,15,45);
     noStroke();
   
     fill(26,46,106);
     textFont(font);
     textAlign(CENTER);
     text("Wishing you interesting new connections in 2009 From Golan, Andrea and Zenon", width/2,height-44);
   
   
     // Hold the framerate constant by adjusting the number of points we see.
     float A = 0.95;
     float B = 1.0-A;
     mspf = A*mspf + B*(now - lastFrameTime);
     lastFrameTime = now;
     if (mspf > 60){
       nPous = max(20, nPous-4);
     }
     if (frameCount % 10 == 0){
       if ((mspf < 16.66666) || (millis()<5000)) {
         nPous = min(maxNPous, nPous+1);
         lastAddTime = now;
       }
       else if (mspf > 17.66666){
         if (millis()>5000){
           nPous = max(20, nPous-1);
         }
       }
     }
   
   
     // Choose the right blend function.
     fill(255);
     int a,b;
     PGraphicsOpenGL pgl = (PGraphicsOpenGL) g;  // g may change
     GL gl = pgl.beginGL();
     gl.glDisable(gl.GL_DEPTH_TEST);
     gl.glEnable(gl.GL_BLEND);
     int sfact[] = {
       gl.GL_ZERO, gl.GL_ONE, gl.GL_SRC_COLOR, gl.GL_ONE_MINUS_SRC_COLOR, gl.GL_DST_COLOR,
       gl.GL_ONE_MINUS_DST_COLOR, gl.GL_SRC_ALPHA, gl.GL_ONE_MINUS_SRC_ALPHA, gl.GL_DST_ALPHA,
       gl.GL_ONE_MINUS_DST_ALPHA, gl.GL_CONSTANT_COLOR, gl.GL_ONE_MINUS_CONSTANT_COLOR,
       gl.GL_CONSTANT_ALPHA, gl.GL_ONE_MINUS_CONSTANT_ALPHA, gl.GL_SRC_ALPHA_SATURATE                                                                                };
     int dfact[] = {
       gl.GL_ZERO, gl.GL_ONE, gl.GL_SRC_COLOR, gl.GL_ONE_MINUS_SRC_COLOR, gl.GL_DST_COLOR,
       gl.GL_ONE_MINUS_DST_COLOR, gl.GL_SRC_ALPHA, gl.GL_ONE_MINUS_SRC_ALPHA, gl.GL_DST_ALPHA,
       gl.GL_ONE_MINUS_DST_ALPHA, gl.GL_CONSTANT_COLOR, gl.GL_ONE_MINUS_CONSTANT_COLOR,
       gl.GL_CONSTANT_ALPHA, gl.GL_ONE_MINUS_CONSTANT_ALPHA                                                                                };
     a = 2;
     b = 8;
     gl.glBlendFunc (sfact[a], dfact[b]);
    
    
     // Rotate and draw the points.
     float R = 300;
     mx = 0.99*mx + 0.01*(mouseX-width/2);
     my = 0.99*my + 0.01*(mouseY);
    
     pushMatrix();
     translate(width/1, 400, 0);
     rotateY(millis()/5000.0);
     rotateY(mx/50.0);
     rotateX(HALF_PI);
     rotateX(0-my/50.0);
   
     for (int i=0; i<nPous; i++){
       float d = 140 + 30*noise(i+millis()/(i+147.0));
       float r = 120 + 60*noise((i+millis())/1003.0);
       float g = 150 + 50*noise(i+millis()/ 777.0);
   
       tint(r,g,255);
       pous[i].draw(R,d);
   
       tint(220,255,255);
       pous[i].draw(R+3,d*0.50);
   
     }
   
     // Draw the connections between the points.
     a = 4;//(mouseX/10)%sfact.length; //4
     b = 5;//(mouseY/10)ßact.length; //14;//(millis()/600)ßact.length; //5
     gl.glBlendFunc (sfact[a], dfact[b]);
     smooth();
     stroke(255,255,255,10);
     float M = 0.45;
     for (int i=0; i<nPous; i++){
       PointOnUnitSphere S = pous[i];
       for (int j=0; j<i; j++){
         PointOnUnitSphere F = pous[j];
         float distance = SDC.getSphericalAngleArccos (S, F);
         if (distance < M){
           SDC.drawArcBetweenTwoPointsOnUnitSphere (S, F, R, distance);
         }
       }
     }
   
   
     popMatrix();
   
     // Draw a highlight that sweeps across the text
     tint(180,220,255);
     a = 14;
     b = 13;
     gl.glBlendFunc (sfact[a], dfact[b]);
     float t = ((millis()-1500)/3)`00;
     image(spot,t-200, 810-50,400,100);
    
     pgl.endGL();
   }
   
   
   
   
   //--------------------------------------------
   // Update the forces on the points,
   // so that they mutually repel or attract.
   //
   void updateEu(){
   
     float sub = 0.47;
     float C =  0.00002 * (noise(millis()/200.0)-sub);
     if (mousePressed){
       C = -0.00001;
     }
   
     for (int i=0; i<nPous; i++){
       PointOnUnitSphere S = pous[i];
       for (int j=0; j<i; j++){
         PointOnUnitSphere F = pous[j];
   
         float dx = S.x - F.x;
         float dy = S.y - F.y;
         float dz = S.z - F.z;
         float dh2 = (dx*dx + dy*dy + dz*dz);
   
         float fx = C * dx/dh2;
         float fy = C * dy/dh2;
         float fz = C * dz/dh2;
   
         S.accumulateEuclideanForce ( fx, fy, fz);
         F.accumulateEuclideanForce (-fx,-fy,-fz);
   
       }
     }
   
   
     for (int i=0; i<nPous; i++){
       pous[i].updateEuclideanForces();
     }
   }
2. class SphericalDistanceCalculator {
     // http://en.wikipedia.org/wiki/Great_circle_distance
     // http://williams.best.vwh.net/avform.htm#Crs
   
     LatLonPair pair;
     SphericalDistanceCalculator (){
       pair = new LatLonPair();
     }
   
     float getSphericalAngleArccos (PointOnUnitSphere S, PointOnUnitSphere F){
       // Inaccurate for small distances.
       float Flat = F.lat;
       float Slat = S.lat;
       float A = cos(Slat) * cos(Flat) * cos(S.lon - F.lon);
       float B = sin(Slat) * sin(Flat);
       return (acos (A + B));
     }
   
     float getSphericalAngleArcsin (PointOnUnitSphere S, PointOnUnitSphere F){
       // Inaccurate for antipodal points.
       float dLat = S.lat - F.lat;
       float dLon = S.lon - F.lon;
       float A = sq(sin(dLat/2.0));
       float B = cos(S.lat) * cos(F.lat) * sq(sin(dLon/2.0));
       float dang = 2 * asin (sqrt(A + B));
       return (dang);
     }
   
     float getSphericalAngleArctan (PointOnUnitSphere S, PointOnUnitSphere F){
       // accurate for all cases, but CPU-heavy.
       float cLatF = cos(F.lat);
       float sLatF = sin(F.lat);
       float cLatS = cos(S.lat);
       float sLatS = sin(S.lat);
       float dLon  = S.lon - F.lon;
       float sdLon = sin(dLon);
       float cdLon = cos(dLon);
   
       float A = cLatF * sdLon;
       float B = cLatS * sLatF - sLatS * cLatF * cdLon;
       float C = sLatS * sLatF;
       float D = cLatS * cLatF * cdLon;
   
       float top = sqrt(A*A + B*B);
       float bot = C + D;
       float dang = atan2(top,bot);
       return (dang);
     }
   
   
     LatLonPair getPointOnGreatCircle (PointOnUnitSphere S, PointOnUnitSphere F, float distance, float frac){
       float A = sin((1.0-frac)*distance)/sin(distance);
       float B = sin(frac*distance)/sin(distance);
       float acsl = A*cos(S.lat);
       float bcfl = B*cos(F.lat);
   
       float x = acsl*cos(S.lon) +  bcfl*cos(F.lon);
       float y = acsl*sin(S.lon) +  bcfl*sin(F.lon);
       float z = A*sin(S.lat)    +  B*sin(F.lat);
       pair.lat = atan2(z,sqrt(x*x+y*y));
       pair.lon = atan2(y,x);
       return pair;
     }
   
   
     LatLonPair getPointOnGreatCircle (float Slat, float Slon, float Flat, float Flon, float distance, float frac){
       float sind = sin(distance);
       float A = sin((1.0-frac)*distance)/sind;
       float B = sin(frac*distance)      /sind;
       float acsl = A*cos(Slat);
       float bcfl = B*cos(Flat);
   
       float x = acsl*cos(Slon) +  bcfl*cos(Flon);
       float y = acsl*sin(Slon) +  bcfl*sin(Flon);
       float z = A*sin(Slat)    +  B*sin(Flat);
       pair.lat = atan2(z,sqrt(x*x+y*y));
       pair.lon = atan2(y,x);
       return pair;
     }
   
     // This doesn't just draw any old arc; it draws a pair of wiggly arcs....
     void drawArcBetweenTwoPointsOnUnitSphere (PointOnUnitSphere P0, PointOnUnitSphere P1, float R, float distance){
       noFill();
       int np = (int)(degrees(distance)/1.0) +1;
   
       float Slat = P0.lat;
       float Slon = P0.lon;
       float Flat = P1.lat;
       float Flon = P1.lon;
       float p0id = P0.id ;
       float mils = millis();
      
       pushMatrix();
       scale(R,R,R);
       for (int k=0; k<2; k++){
         float mlat = k + p0id + mils/(p0id+500.0);
         float mlon = k + p0id + mils/(p0id+437.0);
         float npm1 = (float)(np-1);
   
         beginShape();
         for (int i=0; i<np; i++){
           float frac = (float)i/npm1;
           LatLonPair P = getPointOnGreatCircle (Slat, Slon, Flat, Flon, distance, frac);
          
           float f = sin(frac*PI);
           P.lat +=  f * 0.10*(noise(frac + mlat)-0.5);
           P.lon +=  f * 0.10*(noise(frac + mlon)-0.5);
          
           float eulat = HALF_PI - P.lat;
           float slat = sin(eulat);
           float x = cos(P.lon) * slat;
           float y = sin(P.lon) * slat;
           float z = cos(eulat);
           vertex(x,y,z); 
         }
         endShape();
       }
       popMatrix();
     }
   
   
   
   }
   
   // A handy data class
   class LatLonPair {
     float lat;
     float lon;
   }
   
   
   //---------------------------------------
   class PointOnUnitSphere {
     int id;
     float eulat;
     float lat,lon;
   
     float x,y,z;
     float vx,vy,vz,vh;
     float ax,ay,az;
     float mass;
     float damp;
   
     PointOnUnitSphere (int i){
       id = i;
       mass = random(0.90,1.05);
       damp = random(0.93,0.98);
   
       setLat(0);
       setLon(0);
       vh=vx=vy=vz=0;
       ax=ay=az=0;
       eulat = 0;
       computeEuclidean();
     }
   
     //---------------------------------------------
     void setLatLon (float latitude, float longitude){
       // assumes inputs are radians
       setLat(latitude);
       setLon(longitude);
     }
     void setLon (float longitude){
       // assumes inputs are radians
       lon = longitude % TWO_PI;
     }
     void setLat (float latitude){
       // assumes inputs are radians
       lat = (latitude % PI);
       eulat = HALF_PI - lat;
     }
   
     void setPositionFromCorrectLatLon (float correctLatitude, float correctLongitude){
       lon = correctLongitude;
       lat = correctLatitude;
       eulat = HALF_PI - correctLatitude;
       float slat = sin(eulat);
       x = cos(correctLongitude) * slat;
       y = sin(correctLongitude) * slat;
       z = cos(eulat);
   
     }
   
   
   
     //---------------------------------------------
     void computeSpherical(){
       lat = HALF_PI - acos(z) ;     // phi
       lon = atan2(y,x);  // theta
       eulat = HALF_PI - lat;
     }
    
     void computeEuclidean(){
       float slat = sin(eulat);
       x = cos(lon) * slat;
       y = sin(lon) * slat;
       z = cos(eulat);
     }
   
   
   
     //------------------------------------------------------------
     void accumulateEuclideanForce (float fx, float fy, float fz){
       ax += fx/mass;
       ay += fy/mass;
       az += fz/mass;
     }
   
     void updateEuclideanForces(){
       vx += ax;
       vy += ay;
       vz += az;
       vx *= damp;
       vy *= damp;
       vz *= damp;
   
       float px = x + vx;
       float py = y + vy;
       float pz = z + vz;
       float pr = sqrt(px*px + py*py + pz*pz);
   
       float lat2 = HALF_PI - acos(pz/pr);   // phi
       float lon2 = atan2(py,px);  // theta
       lat  = lat2;
       lon  = lon2;
       eulat = HALF_PI- lat;
   
       float slat = sin(eulat);
       x = (cos(lon) * slat);
       y = (sin(lon) * slat);
       z = (cos(eulat));
     }
   
   
     void drawEllipse (float sphereR, float ellipseD){
       pushMatrix();
       translate(x*sphereR,y*sphereR,z*sphereR);
       rotateZ(lon);
       rotateY(eulat);
   
       ellipse(0,0,ellipseD,ellipseD);
       popMatrix();
     }
   
   
     void draw (float R, float D){
       pushMatrix();
       translate(x*R,y*R,z*R);
       rotateZ(  lon);
       rotateY(eulat);
       image(spot,-D/2,-D/2,D,D);
       popMatrix();
     }
   }

And around a line, thats a little more complicated because you need at least 2 reference points to know the orientation. Anyways, look at this post.

is everything ok?

That code is awesome! That should work out well. :-)  I do have the 2 reference points on the line (beginning and end).  I thought about doing some "electricity" type effect, flowing particles, pulses.. not sure what would look coolest and apply to a wide range of measures.  For example, one line could have a frequency of 5000 or 5.  I probably wouldn't want to try and represent 5000 flowing particles, but some level of normalized magnitude.

i made some code for you that is based on my last post:

1. //http://www.flong.com/storage/experience/newyear/newyear09/
   import processing.opengl.*;
   
   SphericalDistanceCalculator sdc;
   SphereCoords startPos;
   SphereCoords endPos;
   
   float sphereRadius = 300.0;
   float inc = 0.0;
   
   void setup(){
     size(400,440,OPENGL);
     hint(ENABLE_OPENGL_4X_SMOOTH);
     initCoords();
   }
   
   void initCoords(){
     startPos = new SphereCoords();
     float lat = acos(random(-1,1)) - HALF_PI;
     float lon = random(0, TWO_PI);
     startPos.setVars(lat, lon);
   
     endPos = new SphereCoords();
     lat = acos(random(-1,1)) - HALF_PI;
     lon = random(0, TWO_PI);
     endPos.setVars(lat, lon);
   
     sdc = new SphericalDistanceCalculator();
     sphereDetail(20);
   }
   
   
   //--------------------------------------------
   void draw(){
     background(0,15,45);
     noStroke();
   
     // Choose the right blend function.
     fill(255);
   
     // Rotate and draw the points.
     pushMatrix();
     translate(width/2, height/2, -400);
     rotateY(millis()/5000.0);
     rotateX(HALF_PI);
   
     startPos.draw();
     endPos.draw();
   
     float distance = sdc.getSphericalAngleArccos(startPos, endPos);
     float[] position = sdc.drawArcBetweenTwoPointsOnUnitSphere(startPos, endPos, sphereRadius, distance, inc);
   
     fill(255);
     pushMatrix();
     translate(position[0], position[1], position[2]);
     box(20);
     popMatrix(); 
   
     noFill();
     stroke(255, 20);
     sphere(sphereRadius);
   
     popMatrix();
   
     inc += 0.01;
     if(inc > 1.0){
       inc = 1.0;
     }
   }
   
   void keyPressed(){
     LatLon t = sdc.getCurrentGeoposition();
     startPos.setVars(t.lat, t.lon);
     float lat = acos(random(-1,1)) - HALF_PI;
     float lon = random(0, TWO_PI);
     endPos.setVars(lat, lon);
     inc = 0.0;
   }
2. // http://en.wikipedia.org/wiki/Great_circle_distance
   // http://williams.best.vwh.net/avform.htm#Crs
   class SphericalDistanceCalculator {
   
     LatLon current;
   
     SphericalDistanceCalculator (){
       current = new LatLon();
     }
   
     float getSphericalAngleArccos (SphereCoords _firstPoint, SphereCoords _lastPoint){
       return acos((cos(_firstPoint.lat) * cos(_lastPoint.lat) * cos(_firstPoint.lon - _lastPoint.lon)) + (sin(_firstPoint.lat) * sin(_lastPoint.lat)));
     }
    
     LatLon getPointOnGreatCircle (SphereCoords _firstPoint, SphereCoords _lastPoint, float _distance, float _frac){
       float sind = sin(_distance);
       float a1 = sin((1.0 - _frac) * _distance) / sind;
       float a2 = sin(_frac * _distance) / sind;
       float a1cos = a1 * cos(_firstPoint.lat);
       float a2cos = a2 * cos(_lastPoint.lat);
   
       float x = a1cos * cos(_firstPoint.lon) + a2cos * cos(_lastPoint.lon);
       float y = a1cos * sin(_firstPoint.lon) + a2cos * sin(_lastPoint.lon);
       float z = a1 * sin(_firstPoint.lat) + a2 * sin(_lastPoint.lat);
      
       LatLon ll = new LatLon();
       ll.lat = atan2(z, sqrt(x * x + y * y));
       ll.lon = atan2(y, x);
       return ll;
     }
   
     float[] drawArcBetweenTwoPointsOnUnitSphere (SphereCoords _pointA, SphereCoords _pointB, float _radius, float _distance, float _inc){
       float np = degrees(_distance);   
       current = getPointOnGreatCircle(_pointA, _pointB, _distance, _inc * (np+1.0) / np);
       float eulat = HALF_PI - current.lat;
       float slat = sin(eulat);
       //new camera position
       float[] coords = {_radius * cos(current.lon) * slat, _radius * sin(current.lon) * slat, _radius * cos(eulat)};
       return coords;   
     }
   
     LatLon getCurrentGeoposition(){
       return current;
     }
   
   }
   
   class LatLon {
     float lat;
     float lon;
   }
   
   class SphereCoords {
     float eulat; //euclidean latitude
     float lat,lon;
     float x,y,z;
    
     SphereCoords(){
       setVars(0,0);
     }
   
     void setVars (float _latitude, float _longitude){
       // assumes inputs are radians
       lon = _longitude % TWO_PI;
       lat = _latitude % PI;
       eulat = HALF_PI - lat;
       //computeEuclidean
       float slat = sin(eulat);
       x = cos(lon) * slat;
       y = sin(lon) * slat;
       z = cos(eulat);
     }
    
     void draw(){
       pushMatrix();
       translate(x*sphereRadius, y*sphereRadius, z*sphereRadius);
       box(20);
       popMatrix();
     }
    
   }
   

hope it'll help

This piece of code does the arc lines between the objects on the sphere - very cool, but I"d like to do something like this without the sphere curvature.  So I just want these wiggly arcs to connect to two points in 3d space.  Thoughts on the required modification.

1.   void drawArcBetweenTwoPointsOnUnitSphere (PointOnUnitSphere P0, PointOnUnitSphere P1, float R, float distance){
2.     noFill();
3.     int np = (int)(degrees(distance)/1.0) +1;
4.     float Slat = P0.lat;
5.     float Slon = P0.lon;
6.     float Flat = P1.lat;
7.     float Flon = P1.lon;
8.     float p0id = P0.id ;
9.     float mils = millis();
10.    
11.     pushMatrix();
12.     scale(R,R,R);
13.     for (int k=0; k<2; k++){
14.       float mlat = k + p0id + mils/(p0id+500.0);
15.       float mlon = k + p0id + mils/(p0id+437.0);
16.       float npm1 = (float)(np-1);
17.       beginShape();
18.       for (int i=0; i<np; i++){
19.         float frac = (float)i/npm1;
20.         LatLonPair P = getPointOnGreatCircle (Slat, Slon, Flat, Flon, distance, frac);
21.        
22.         float f = sin(frac*PI);
23.         P.lat +=  f * 0.10*(noise(frac + mlat)-0.5);
24.         P.lon +=  f * 0.10*(noise(frac + mlon)-0.5);
25.        
26.         float eulat = HALF_PI - P.lat;
27.         float slat = sin(eulat);
28.         float x = cos(P.lon) * slat;
29.         float y = sin(P.lon) * slat;
30.         float z = cos(eulat);
31.         vertex(x,y,z); 
32.       }
33.       endShape();
34.     }
35.     popMatrix();
36.   }