Metaballs

Metaballs

Metaballs are nifty little blobby objects commonly used in 3D modelling to help getting an “organic look” or in demos as a cheap graphical effect.

They basically consist of a simple function which measures the distance of a certain point in space to the center of the metaball and assigns that point a potential. The potential of multiple metaballs add up, i.e. to get the total potential at a point in space, we calculate the metaball function for each metaball in the scene seperately and add up the returned values. This way we get a so-called “scalar field”.

To make things more interesting, we now define a threshold for this scalar field which determines the actual metaball shape. If the potential at a certain point exceeds the threshold, it is inside the metaball volume, and if it doesn’t, it is defined as outside of the metaball volume. Points that have a potential equal to the threshold lie on the surface of the metaball volume; these are the ones we’re interested in to render the metaballs.

It shows that if we choose an appropriate threshold and then render the surface of the metaballs, we can see that metaballs that get close enough begin to “attract” each other and start to merge. What’s useful about this is that even during merging, metaballs always keep a smooth and continuous surface without us having to explicitly model it. This makes it very handy for organic modelling, since organic models (e.g. plants, humans etc.) usually have no sharp edges and just smooth surfaces. This would be very difficult to model per hand.

Rendering the metaballs is a problem in itself, since there is no fast straightforward solution to render a scalar field. Volume raycasting is one possible solution, though it’s usually too hardware extensive for realtime use. In this implementation, I used the Marching Cubes algorithm, which allows the program to convert the surface of the metaballs into a polygonal mesh, which is then rendered using conventional rasterization.

Download the demo (*.exe & code): Metaballs

The ‘normal’ way to draw a Mandelbrot fractal is to take a point in the complex plane, apply the Mandelbrot function multiple times and see whether the point converges to a fixed value or diverges to infinity. The points that converge belong to the Mandelbrot set (and are usually colored black), however, we’re more interested in the points that diverge. The way divergence is determined is usually by measuring the distance of the complex point to the origin and see whether that distance exceeds a certain threshold. If not, we reapply the function and check for divergence again. If yes, then we assume the point is diverging and don’t need to apply the function anymore. Instead, we count how many times we applied the function so far and take that value as an index into a colour table of some sort to assign a colour to the corresponding pixel.

By choosing appropriate colour tables, it’s very easy to get good looking images that way. The problem is that they’ll all look similar to images others have made – even though you might use different colors, it’s still the exact same coloring method used on the same fractal. This is why nifty demo sceners developed a new coloring method using orbit traps to change the look of the fractal greatly without much additional complexity.

The way orbit traps work is, instead of counting the amount of iterations of the equation, we track the orbit (location after every iteration) of the point we’re looking at. For example, one could look at the distance of the point to the origin and record the lowest distance of the point on its course (the nearest point to the origin gets “trapped”) and then take that radius as an index into a colour table. This already yields a completely different looking fractal:

Point trapped Mandelbrot set

This is just one of many possibilities. One could also measure the distance of the point to one or multiple straight lines and record the lowest distance:

Line trapped Mandelbrot set

The possibilities are of course endless – instead of lines and points, one could also take circles, spirals, or any combination of them. Just as an example, this image uses two line traps and a point trap:

Mandelbrot set with various orbit traps

These images already look pretty good, but there’s another method available to achieve different coloring: Image traps. The principle behind them is similar to ordinary orbit traps: We track the point on its orbit, map the point position to a pixel of a picture we chose, and whenever the point is inside the image (and hits a non-transparent pixel), the corresponding color is assigned as the final color of the point. This way, the picture will get repeated over and over inside the fractal and naturally follows the shape of the set:

Image trapped Mandelbrot set

Simple cloth simulation

This was a very quick project I did a few years back.

It deals with the problem of simulating cloth, thin objects that are deformable and, in some cases, even tearable. These kind of simulations are usually too expensive for massive use in games or other real-time applications, but they provide a nice graphical effect.

My implementation is very basic and was hacked together within one evening, so it’s neither fast nor elegant. It works by dividing the cloth into a regular grid, placing particles at grid corners and then connecting particles using quasi-stiff springs. The particles are then moved using simple position verlet integration and then constrained by correcting the length of each spring to its original length. Combined with a simple raypicking function for cylinders, cubes and spheres, this gives some neat effects despite its simplicity.

Download (*.exe & code): Cloth Simulation

I’ll fiddle around with the settings a bit and see how this whole blogging thing works, but I’m surprised how easy all of this works. It’s really great that you don’t have to mess with HTML and CSS anymore to get a decent website.