1. import processing.opengl.*;
2. import javax.media.opengl.*;
4. PGraphicsOpenGL pgl;
5. GL              gl;
7. PGraphics   ecran1,ecran2,ecran3;
8. PImage      img1,img2,img3;
9. int         nbPoint   = 150;
10. float      speed      = 1.0;
11. Point3D[]   tabPoint = new Point3D[nbPoint];
13. void setup() {
14.   size(640,480,OPENGL);
15.   img1    = loadImage("data/glow1.png");
16.   img2    = loadImage("data/glow2.png");
17.   img3    = loadImage("data/glow3.png");
18.   ecran1 = createGraphics(img1.width,img1.height,P2D);
19.   ecran2 = createGraphics(img2.width,img2.height,P2D);
20.   ecran3 = createGraphics(img3.width,img3.height,P2D);
21.   ecran1.background(img1);
22.   ecran1.mask(img1);
23.   ecran2.background(img2);
24.   ecran2.mask(img2);
25.   ecran3.background(img3);
26.   ecran3.mask(img3);
27.   noStroke();
28.   textureMode(NORMALIZED);
29.   for(int nb=0; nb<nbPoint; nb++)
30.     tabPoint[nb] = new Point3D(random(width),
31.                                random(height),
32.                                0,
33.                                random(3));
34. }
35. void draw() {
36.   pgl = (PGraphicsOpenGL) g;
37.   gl = pgl.beginGL();
38.   gl.glDisable(GL.GL_DEPTH_TEST);
39.   gl.glEnable(GL.GL_BLEND);
40.   gl.glBlendFunc(GL.GL_ONE, GL.GL_ONE);  
41.   pgl.endGL();
42.   background(0);
43.   for(int nb=0; nb<nbPoint; nb++) {
44.     tabPoint[nb].anim();
45.     tabPoint[nb].drawP();
46.   }
47. }
49. class Point3D
50. {
51.   PVector point = new PVector();
52.   float dX,dY;
53.   int type;
54.   float angle = random(TWO_PI);
55.   float delta = TWO_PI/720;
56.   
      Point3D(float x,float y, float z,float type)
      {
57.     point.x    = x;
58.     point.y    = y;
59.     point.z    = z;
60.     dX        = random(-speed,speed);
61.     dY        = random(-speed,speed);
62.     this.type = int(type);
63.   }
64.   
65.   void drawP()  {
66.     PGraphics ecran = null;
67.     if(type==0)
68.       ecran = ecran1;
69.     if(type==1)
70.       ecran = ecran2;
71.     if(type==2)
72.       ecran = ecran3;
73.     beginShape(QUADS);
74.     texture(ecran);
75.     vertex(point.x-ecran.width/2,point.y-ecran.height/2,point.z,0,0);
76.     vertex(point.x+ecran.width/2,point.y-ecran.height/2,point.z,1,0);
77.     vertex(point.x+ecran.width/2,point.y+ecran.height/2,point.z,1,1);
78.     vertex(point.x-ecran.width/2,point.y+ecran.height/2,point.z,0,1);
79.     endShape(CLOSE);
80.   }
81.   
82.   void anim()  {
83.     point.x = (point.x+dX);
84.     point.y = (point.y+dY);
85.     if((point.x>width && dX>0)||(point.x<0 && dX<0))
86.       dX = -dX;
87.     if((point.y>height && dY>0)||(point.y<0 && dY<0))
88.       dY = -dY;
89.     point.z = 50*sin(angle)+100;   
90.     angle += delta;
91.   }
92. }
    

1. import processing.opengl.*;
   import javax.media.opengl.*;
   PGraphicsOpenGL pgl;
   GL              gl;
   public float rr,gg,bb;
   public float [] cc;
   public int gain = 4;
   PGraphics   ecran1,ecran2,ecran3;
   PImage      img1,img2,img3,img4,_img1,_img2,_img3;
   int         nbPoint   = 150;
   float      speed      = 1.0;
   Point3D[]   tabPoint = new Point3D[nbPoint];
   void setup() {
   //  size(640,480,OPENGL);
   size(screen.width,screen.height,OPENGL);
     frameRate(3000);
     cc = new float[3];
     for (int x = 0;x<3;x++){
      cc[x]=random(40)+random(40)+random(40)+random(40)+random(40);
   
     }
     //img1    = loadImage("data/glow1.png");
    // img2    = loadImage("data/glow2.png");
     //img3    = loadImage("data/glow3.png");
     _img1 = createImage(128*1,128*1,ARGB);
     _img2 = createImage(128*1,128*1,ARGB);
     _img3 = createImage(128*1,128*1,ARGB);
     img4= loadImage("glow1.png");
     int vx = 128/2;
     int vy = 128/2;
     for (int x=0;x<_img1.width;x++){
       for (int y=0;y<_img1.height;y++){
         float dis = dist(vx,vy,x,y)/2;
        // img1.pixels[x+img1.width*y]=color(1);
         color c = _img1.pixels[x+_img1.width*y];
           color paw = color(_img1.height-x,y,x-y);
           color pi = img4.pixels[x+_img1.width*y];
              rr += cc[0]/dis-gain;
             gg += cc[1]/dis-gain;
             bb += cc[2]/dis-gain;
   
         _img1.pixels[x+_img1.width*y] =paw;
          _img2.pixels[x+_img1.width*y] =paw;
           _img3.pixels[x+_img1.width*y] =paw;
       }
     }
    
     //img1.mask(img4);
    // img2.mask(img4);
   //  img3.mask(img4);
     img1=loadImage("glow1.png");
     img2=loadImage("glow1.png");
     img3=loadImage("glow1.png");
   mask1(img1,_img2);
   mask1(img2,_img2);
   mask1(img3,_img3);
    // img3.filter(INVERT);
     ecran1 = createGraphics(img1.width,img1.height,P2D);
     ecran2 = createGraphics(img2.width,img2.height,P2D);
     ecran3 = createGraphics(img3.width,img3.height,P2D);
     ecran1.background(img1);
     ecran1.mask(img1);
     ecran2.background(img2);
     ecran2.mask(img2);
     ecran3.background(img3);
     ecran3.mask(img3);
     noStroke();
     textureMode(NORMALIZED);
     for(int nb=0; nb<nbPoint; nb++)
       tabPoint[nb] = new Point3D(random(width),
                                  random(height),
                                  0,
                                  random(3));
   }
   void draw() {
     pgl = (PGraphicsOpenGL) g;
     gl = pgl.beginGL();
     gl.glDisable(GL.GL_DEPTH_TEST);
     gl.glEnable(GL.GL_BLEND);
     gl.glBlendFunc(GL.GL_ONE, GL.GL_ONE); 
     pgl.endGL();
    background(0);
     for(int nb=0; nb<nbPoint; nb++) {
       tabPoint[nb].anim();
       tabPoint[nb].drawP();
     }
   }
   
   void mask1(PImage a, PImage b){
    
    a.blend(b,0,0,a.width,a.height,0,0,a.width,a.height,DARKEST);
   }
   class Point3D
   {
     PVector point = new PVector();
     float dX,dY;
     int type;
     float angle = random(TWO_PI);
     float delta = TWO_PI/720;
    
     Point3D(float x,float y, float z,float type)
     {
       point.x    = x;
       point.y    = y;
       point.z    = z;
       dX        = random(-speed,speed);
       dY        = random(-speed,speed);
       this.type = int(type);
     }
    
     void drawP()  {
       PGraphics ecran = null;
       if(type==0)
         ecran = ecran1;
       if(type==1)
         ecran = ecran2;
       if(type==2)
         ecran = ecran3;
       beginShape(QUADS);
       texture(ecran);
       vertex(point.x-ecran.width/2,point.y-ecran.height/2,point.z,0,0);
       vertex(point.x+ecran.width/2,point.y-ecran.height/2,point.z,1,0);
       vertex(point.x+ecran.width/2,point.y+ecran.height/2,point.z,1,1);
       vertex(point.x-ecran.width/2,point.y+ecran.height/2,point.z,0,1);
       endShape(CLOSE);
     }
    
     void anim()  {
       point.x = (point.x+dX);
       point.y = (point.y+dY);
       if((point.x>width && dX>0)||(point.x<0 && dX<0))
         dX = -dX;
       if((point.y>height && dY>0)||(point.y<0 && dY<0))
         dY = -dY;
       point.z = 50*sin(angle)+100;  
       angle += delta;
     }
   }

You can probably accelerate it a lot if you compute sq(x-xpos)+sq(y-ypos) in a separate method of the metaball (eg. meta[i].update(x, y), storing the result in a field (class variable) then just call meta[i].retriever(), meta[i].retrieveg() and meta[i].retrieveb(). (just return rs/square, gs/square, bs/square).

1. class metaball{
2.   float xpos,ypos,xcc,ycc;
3.   int rs,gs,bs;
4.   float square;
5.  
6.   metaball(int xp,int yp, int xc,int yc,float stre,int r,int g,int b,int ne){
7.     xpos = xp;//10
8.     ypos = yp;//10
9.     xcc = xc;
10.     ycc =yc;
11.     rs = round(ne*r*stre);
12.     gs = round(ne*g*stre);
13.     bs = round(ne*b*stre);
14.   }
15.   void update(){
16.     xpos += xcc;
17.     ypos += ycc;
18.     if (ypos >= height){
19.       ycc = -ycc;
20.       ypos = height;
21.     }
22.     if (ypos <= 0){
23.       ycc = -ycc;
24.       ypos = 0;
25.     }
26.     if (xpos >= width){
27.       xcc = -xcc;
28.       xpos = width;
29.     }
30.     if (xpos <= 0){
31.       xcc = -xcc;
32.       xpos = 0;
33.     }
34.     square = 0;
35.   }
36.   void update(float x, float y) {
37.     square = sq(x - xpos) + sq(y - ypos);
38.     if (square == 0) square = 1E-10; // Avoid exception
39.   }
40.   float retreiver(){
41.     return rs / square;
42.   }
43.   float retreiveg(){
44.     return gs / square;
45.   }
46.   float retreiveb(){
47.     return bs / square;
48.   }
49. }  

1.       for (int i = 0; i< meta.length; i++){
2.         meta[i].update(x, y);
3.         colr += meta[i].retreiver();
4.         colg += meta[i].retreiveg();
5.         colb += meta[i].retreiveb();
6.       }