[RuneLancer]

We've all heard of this, I'm quite sure. Mostly chaos theory and the likes; fractals, attractors, iterative systems...

So, who's into this stuff? Has anyone written their own attempts at modifying one of the more basic systems?

I used to be a big fractal buff, but eventually took interest in attractors. The basic code behind an attractor is REAL simple...

[Ninkazu]

I've wanted to learn how to do this stuff. Any tips?

[RuneLancer]

Just let your imagination run wild, lol.

There's two things to know about this stuff.

1- Being able to scale things properly is important. Usually, you work with values between -1 and 1. This can easily equate to a color if you know how, or a position, or whatever.

2- Understanding what an iterative process is. The first image, the attractor, is drawn by iterating over an equation which moves a "dot" around and mapping its position every time it moves. The second one iterates over the same equation, but for every possible position (and not as often), mapping a pixel colored based on how far away it has moved.

The easiest way to write something like this is to have a loop going over every pixel. Then, you just fill in the actual loop, figuring out something to do with the position you have. For instance, R could be the X, G the Y, and B (X + Y) / 2. This gives a nice gradiant, but it's nothing too impressive.

More complex stuff could involve, say, applying a formula over and over on the position and counting how many times it must be done before your pixel exits the screen, and using that as a color.
_________________
Endless Saga
An OpenGL RPG in the making. Now with new hosting!

[Ninkazu]

Have any example source?

[RuneLancer]

I never give out source. Personal beleif that I don't wish to argue. ;) But I can give you some pretty easy to follow pseudocode.

[Nephilim]

Well, the big one is the Mandelbrot set. There's plenty of places out on the 'net that describe how to draw it, and the set is pretty famous nowadays. But I tend to like the related, but lesser-known, Julia sets (which are derived off of the Mandelbrot set, or rather, the Mandelbrot set is a mapping of all Julia sets) because they have a wide variety of small, interesting shapes. Here's a site with a lot of info on the Mandelbrot set, Julia sets, and how to compute them, but a little Googling will find you plenty more.

Of course, one big benefit of fractals for RPG purposes (and game programming in general) is for the computational generation of natural-looking landscapes. When you zoom in to the Mandelbrot set, or look at some of the Julia sets, you get shapes that look like inlets and seashores. If you were to height-map a Julia set instead of using colors for the different thresholds, you'd have an entire (nearly) resolution-independent island topography that could be stored with only a few bytes.

One objection people might have to using fractal landscapes is that they're too "regular" - for instance, Julia sets are often symmetrical about an axis - or too "defined" - for instance, you might not want to be bound by the features of the landscape a fractal generates. One thing I've thought about doing to resolve this would be to have a fractal landscape explorer that would allow you to select multiple Julia sets and overlay them on top of each other additively, with scaling, rotation, offset, and heightmap scaling. That would still give you the interesting shorelines and terrain, but you could also map out generally how you want your shorelines and mountain ranges to be laid out to serve your story and world design. Not sure how well it would work though, and I haven't had much of an opportunity to play with the idea. But it might be fun to tinker with it.
_________________
Visit the Sacraments web site to play the game and read articles about its development.

[RuneLancer]

I find that fractals are a pretty bad idea for landscapes, personally. They're great to explore, but... just not up to snuff when it comes to landscape generation. There are far better methods. (Although they DO provide very intriguing masses of land :P )

- The easiest one is just to draw noise, smoothen it out, normalise it, and make a heightmap out of it. Perlin noise is pretty much the undisputed king of natural effects, such as landscapes and clouds, but other forms of noise can generate very nice landscapes.

- An easier but less interesting method is to generate a random number of shapes. For instance, overlaying 'x' circles with a gradient (dark on the outside, light in the center) can create a nice set of rolling hills. Not very good for a world map though.

- Faulting is a great way to generate landscapes both as a 2D grid and 3D sphere (but tends to generate symmetrical landscapes for the latter...) Basically, you generate a random vector. The land on one side gets raised by 1 unit, the land on the other gets lowered by 1. Repeat.

- There's also the classical midpoint displacement (ie, "Fractal cloud") which involves recursively averaging the four corners of a box, varying it by a small random value, splitting the box into 4 more boxes, and starting over. Looks pretty good but gives smooth, uninteresting landscapes...

A bunch of effects can be applied afterwards. Erosion comes to mind, but that's pretty computational intensive. Adding water's pretty important too. You can just create a plane at an arbitrary height and have everything under it be water, but there are better methods. I have a test program which generates land and "drops" pixels of water down slopes. It takes ages to get reasonable lakes, but they look quite realistic (and it's real easy to add erosion to it.)

Then comes the rendering phase... Voxels are a cool way to render land. Personally, I usually raytrace it; the results are pretty cool but it takes a while. :P

Particle systems; anyone working on those? :D
_________________
Endless Saga
An OpenGL RPG in the making. Now with new hosting!

[Nephilim]

Well, the nice thing about fractally-generated landscapes, as I mentioned, is the amount of compression you can get on them. The same would apply for those other techniques, if you store the random seed.

The way I see it, the fractal method and other methods you mentioned is a way to quickly define and store a large wilderness area or land mass. For most purposes, though, you'd still want to heavily manipulate the "interesting" places, such as towns, castles, ports, etc.

Anyway, your post prompted me to play a bit with fractals, so I just wrote a quick Mandelbrot/Julia renderer for fun. Here's some sample renders (Mandelbrot on the left, a Julia on the right):


...and here's the two above images composed and dropped into a quick and dirty mesh generator I wrote a while back:

_________________
Visit the Sacraments web site to play the game and read articles about its development.

[tcaudilllg]

That mesh is BEAUTIFUL.

[RuneLancer]

Very nice mesh; I love the way the edges form fjords. I've always found fractals to be pretty unnatural in shape to use for landscapes, but combining a number of them together and averaging them out could/should give a nice result... :o

Figured I'd post some pseudocode to illustrate how I did the rain fill type of effect I mentionned in my previous post. Really basic stuff...