Tuesday, September 29, 2009

Fractal Rendering on the GPU - Mandelbrot and Julia Sets in an HLSL Shader

Julia Set Shader

I've been playing with HLSL shaders recently, and it occurred to me that the horsepower of the GPU could probably be harnessed to render fractals like the Mandelbrot Set. It turns out to be a perfect task for a shader, since it involves lots of completely localized calculations - exactly what graphics cards are good at.

A bit of web searching turned up the not surprising fact that I'm not the first person to have this realization. I found some nice code examples here and here. My version takes inspiration from both of these approaches, and adds a few tweaks of my own.

The image above is of the Julia set, rendered completely by the GPU. Below is, of course, the Mandelbrot Set.

Mandelbrot Set Shader

And another view of the Mandelbrot set zoomed in a bit:

Mandelbrot Set Shader

On my GeForce 8800GT, I can zoom and pan around at a rock-solid 60 frames per second. Here is a video exploring the Julia set. The warping you see is me transforming the seed used to render the set.



Here is the shader code I ended up with. It is pretty simple. I'm using the Normalized Iteration Count Algorithm to get nicely smoothed coloring. The parameters are set to sensible default values, but you will want to pass them in from your application and map them to some sort of input device. For rendering, simply draw a full screen quad using the shader. In my application I also gild the lily a bit and apply a bloom effect.

int Iterations = 128;
float2 Pan = float2(0.5, 0);
float Zoom = 3;
float Aspect = 1;
float2 JuliaSeed = float2(0.39, -0.2);
float3 ColorScale = float3(4, 5, 6);

float ComputeValue(float2 v, float2 offset)
{
float vxsquare = 0;
float vysquare = 0;

int iteration = 0;
int lastIteration = Iterations;

do
{
vxsquare = v.x * v.x;
vysquare = v.y * v.y;

v = float2(vxsquare - vysquare, v.x * v.y * 2) + offset;

iteration++;

if ((lastIteration == Iterations) && (vxsquare + vysquare) > 4.0)
{
lastIteration = iteration + 1;
}
}
while (iteration < lastIteration);

return (float(iteration) - (log(log(sqrt(vxsquare + vysquare))) / log(2.0))) / float(Iterations);
}

float4 Mandelbrot_PixelShader(float2 texCoord : TEXCOORD0) : COLOR0
{
float2 v = (texCoord - 0.5) * Zoom * float2(1, Aspect) - Pan;

float val = ComputeValue(v, v);

return float4(sin(val * ColorScale.x), sin(val * ColorScale.y), sin(val * ColorScale.z), 1);
}

float4 Julia_PixelShader(float2 texCoord : TEXCOORD0) : COLOR0
{
float2 v = (texCoord - 0.5) * Zoom * float2(1, Aspect) - Pan;

float val = ComputeValue(v, JuliaSeed);

return float4(sin(val * ColorScale.x), sin(val * ColorScale.y), sin(val * ColorScale.z), 1);
}

technique Mandelbrot
{
pass
{
PixelShader = compile ps_3_0 Mandelbrot_PixelShader();
}
}

technique Julia
{
pass
{
PixelShader = compile ps_3_0 Julia_PixelShader();
}
}

Tuesday, September 1, 2009

XNA BloomComponent and Multisampling

The Bloom Postprocess sample provided on the XNA website has issues if you use the component in a game that is using multisampling.

You'll get the following error:

"The active render target and depth stencil surface must have the same pixel size and multisampling type."

The issue is that the render targets created by the component do not respect the multisampling settings of the graphics device. This is easy to fix, however. In the LoadContent() method of BloomComponent.cs, find the code that is initializing renderTarget1 and renderTarget2.

Replace it with the following:

           renderTarget1 = new RenderTarget2D(GraphicsDevice, width, height, 1,
format, GraphicsDevice.DepthStencilBuffer.MultiSampleType, GraphicsDevice.PresentationParameters.MultiSampleQuality);
renderTarget2 = new RenderTarget2D(GraphicsDevice, width, height, 1,
format, GraphicsDevice.DepthStencilBuffer.MultiSampleType, GraphicsDevice.PresentationParameters.MultiSampleQuality);

Friday, August 21, 2009

Cybraphon



A friend I used to work with back in my Edinburgh days has been working on some pretty fantastic stuff recently. He and his collaborators have been using computer-orchestrated electronic actuators to control a variety of physical music-producing devices.

Their latest creation (shown in the video above) is Cybraphon, a one-"man" wardrobe band.

I really like it.

Wednesday, August 19, 2009

SubMariner



I really should be working on Saucer Pilots, but as I've said before, I'm much better at starting projects than finishing them...

Thursday, August 13, 2009

XNA Force Feedback Helper Class

This is a little helper class I whipped up to manage force feedback vibrations in XNA. The XNA libraries themselves just have a method you call to set the instantaneous left/right vibration force. In games, however, you generally want the feedback to last over a period of time, and you may have more than one force feedback event happening at the same time.

This code provides a "fire-and-forget" interface for triggering vibrations. Add a call to update the ForceFeedbackManager in your game's update code. Call AddVibration whenever you want to trigger force feedback.

Note: this code is not threadsafe - you must be triggering feedback from the same thread you call Update from.


public class Vibration
{
float leftMotor;
float rightMotor;
float msLeft;

public float LeftMotor
{
get { return leftMotor; }
set { leftMotor = value; }
}

public float RightMotor
{
get { return rightMotor; }
set { rightMotor = value; }
}

public float MSLeft
{
get { return msLeft; }
set { msLeft = value; }
}

public Vibration(float leftMotor, float rightMotor, float durationMS)
{
this.leftMotor = leftMotor;
this.rightMotor = rightMotor;
this.msLeft = durationMS;
}
}

public class ForceFeedbackManager
{
private PlayerIndex playerIndex;
List<Vibration> vibrations = new List<Vibration>();

public ForceFeedbackManager(PlayerIndex playerIndex)
{
this.playerIndex = playerIndex;
}

public void AddVibration(float leftMotor, float rightMotor, float durationMS)
{
vibrations.Add(new Vibration(leftMotor, rightMotor, durationMS));
}

public void Update(float msElapsed)
{
List<Vibration> toDelete = new List<Vibration>();

foreach (Vibration vibration in vibrations)
{
vibration.MSLeft -= msElapsed;

if (vibration.MSLeft < 0.0f)
{
toDelete.Add(vibration);
}
}

foreach (Vibration vibration in toDelete)
{
vibrations.Remove(vibration);
}

float leftMotor;
float rightMotor;

GetVibration(out leftMotor, out rightMotor);

GamePad.SetVibration(playerIndex, leftMotor, rightMotor);
}

public void GetVibration(out float leftMotor, out float rightMotor)
{
leftMotor = 0.0f;
rightMotor = 0.0f;

foreach (Vibration vibration in vibrations)
{
leftMotor = Math.Max(leftMotor, vibration.LeftMotor);
rightMotor = Math.Max(rightMotor, vibration.RightMotor);
}
}
}

Tuesday, August 11, 2009

sfxr - A Great Free Sound Effect Generator



One of the problems I always have when I'm working on a game project is sourcing sound effects. Recently, I came across sfxr, a very nice program for creating sound effects. It was a great help when I was working on Saucer Pilots.

It is basically a little software synth with a bunch of variables you can tweak to generate a wide variety of sounds. A helpful set of presets are provided for generating commonly needed classes of video game sounds.

Once you find something you like, export it to a WAV file and you are good to go. Very handy little utility.

Thursday, August 6, 2009

Saucer Pilots - XNA Dream Build Play 2009



Whew! I just squeaked an entry in under tonight's deadline for the 2009 XNA Dream Build Play competition.

Last Monday, I was messing around with a new "flying saucer" game prototype idea. It seemed like it had promise, so I kicked into high gear to try to get something submittable for the competition. I initially got the submission date wrong, and thought I had until this Sunday. A few days ago, I realized my error and really had to step things up.

The competition was a good impetus to get me to actually finish something. I'm generally much more fond of starting things than completing them...

Anyway, the game is "Saucer Pilots" - a 1-4 player saucer flying game with five different gameplay modes. Xbox LIVE avatars are used for saucer pilot models (avatars do not appear in this video, as they are not visible on the PC). The physics implementation I'm using is Farseer.

Overall, I think it turned out pretty well for a week-and-a-half effort. The only thing that made that timeline possible was the framework on top of XNA that I've developed over the past year. And help from Sherry.

Oh, and did I mention that it has fishing?