I'm just getting started in metaballs, and I understand the basics of how to create them. I made a program which creates metaballs and displays them, based on an example I found somewhere. But its definitely not working well.

Any applet over 100x100 in size will lock my computer up, and I've read that I need to 1) use a threshold constant and 2) avoid divisions and sqrt calls, as they are expensive. However, all the help I've been able to find through Google are made either created for C++/3D, in another language, or strictly mathematical. I get the basic math, but I'm having trouble making the system run well.

Does anyone have some simple code, or pointers or a good website link that I can use to soak up some more information about metaball execution? Thanks!

Thanks. I read another post here on the Processing Discourse mentioning both v3ga and someone named Koenie as inspirations.

Looks like v3ga's metaball code has been lost in the shuffle with his new site design. I'll msg him later today and see if he can help me out.

Seems like I keep hearing about these Processing all-stars from back when Processing was called Proce55ing. Now, they are all gone / private. We need some Processing heroes again! lol

Thanks! Well, I sort of got it working, however the Liquid Balls applet wasn't exactly what I'm looking for. The end effect I'm looking to achieve is more like this:

http://processing.org/discourse/yabb/YaBB.cgi?board=Contribution_Responsive;action=display;num=1068153198

The source code that was linked to by this guy is simple, but nearly indecipherable to me thanks to no documentation and poor variable naming.

Here is what I've managed to come up with so far. There is not as much "viscosity" as I was hoping for, and there is a problem with the equation...still trying to tweak the variables to work together. Anyway, this applet is lagging like crazy unless I turn down the strengths, but I think if the problem is pinned down, I can scale this up much higher strengths.

Main program code:
Code:

import processing.opengl.*;

int ballCount;
Metaball2D[] mbs;

void setup() {
  size(300,300,P3D);
  background(0);
  
  // initalize metaballs
  ballCount = 3;
  mbs = new Metaball2D[ballCount];
  
  mbs[0] = new Metaball2D(100,80,1000);
  mbs[1] = new Metaball2D(200,100,3000);
  mbs[2] = new Metaball2D(50,100,500);  
  
  //noLoop();
  frameRate(30);  
}

void draw() {
  background(0);
  
  // move each ball
  for(int m=0; m<ballCount; m++) { mbs[m].move(); }
  
  
  // main rendering
  for(int i=0; i<width; i++) {
    for(int j=0; j<height; j++) {
	float inf = 0.0f;
	for(int m=0; m<ballCount; m++) {
	  inf += mbs[m].getInfluence(i,j);
	}
	
	if(inf>.2) {
	  stroke(inf*75,inf*60,inf*50);
	  point(i,j);
	}
    }
  }
}
 

Metaball2D class code:
Code:

class Metaball2D {
  float x,y;
  float strength;
  float xspeed,yspeed;
  
  float dx,dy;
  
  Metaball2D( float _x, float _y, float _strength ) {
    x = _x;
    y = _y;
    strength = _strength;
    
    xspeed = random(1,2);
    yspeed = random(1,2);
  }
  
  void move() {
    x += xspeed;
    y += yspeed;
    
    if(x+xspeed>width || x-10<0) xspeed *= -1;
    if(y+yspeed>height || y-10<0) yspeed *= -1;
  } 
  
  // returns a "influence" value, given a single pixel coordinate
  float getInfluence(float px, float py) {
    dx = (x-px);
    dy = (y-py);
    
    return strength/(dx*dx + dy*dy+0.11f);
  }
}
 

So whats making this applet lag? Any help appreciated

You can also have a gander at some of my old metablobs experiments, which probably require some little tweaking in order to get them to work with recent versions of Processing (these were made 4-5 years ago)

http://toxi.co.uk/p5/blobsInterlace/
http://toxi.co.uk/p5/nodeSpace/
http://toxi.co.uk/p5/base26/

The latter 2 examples are using slices of 2D metaballs to create a 3D structure...

Hth!