A lot has been written about this topic. Following advice from the last link, I eventually managed to build the library. To save you troubles going through all the steps, here it is for armeabi and armeabi-v7a.

You can check out my self-contained ActionScript 3 version put together using the links above. A couple of images it generated before the full source code.

package
{
	import flash.display.Bitmap;
	import flash.display.BitmapData;
	import flash.display.Sprite;
	import flash.events.Event;

	[SWF(backgroundColor="#000000", frameRate="60", width="800", height="600")]
	public class PathTracing extends Sprite
	{
		public static const AA:int = 1; // antialiasing
		public static const WIDTH:int = 320 * AA;
		public static const HEIGHT:int = 240 * AA;

		public static const CAM_NEAR:Number = 2;
		public static const CAM_FOV:Number = Math.PI * 0.3;		

		public static const MAX_DEPTH:int = 5;

		private var scene_:Array;

		private var bmd_:BitmapData;
		private var buffer_:Vector.<Vec3>;
		private var counts_:Vector.<int>;

		/**
		 *
		 *
		 */
		public function PathTracing()
		{
			var i:int;

			const camera:Vec3 = new Vec3(0, 0, 2);
			scene_ = Scenes.scene00;

			// add random spheres
			for (i = 0; i < 2; ++i)
			{
				scene_.push(new Sphere(0.1 + 0.5 * Math.random(), new Vec3(Math.random() * 2 - 1, Math.random() * 2 - 1, Math.random() * 2 - 1), new Vec3(Math.random(), Math.random(), Math.random()), new Vec3()));
			}

			// transform scene to camera space
			for (i = 0; i < scene_.length; ++i)
			{
				var sphere:Sphere = scene_[i];
				sphere.center.x -= camera.x;
				sphere.center.y -= camera.y;
				sphere.center.z -= camera.z;
			}

			// display
			bmd_ = new BitmapData(WIDTH, HEIGHT, false, 0);
			// holds accumulated color
			buffer_ = new Vector.<Vec3>(WIDTH * HEIGHT);
			// holds number of samples of that pixel
			counts_ = new Vector.<int>(WIDTH * HEIGHT);

			for (i = 0; i < WIDTH * HEIGHT; ++i)
			{
				buffer_[i] = new Vec3();
				counts_[i] = 0;
			}

			// upside down (we're using OpenGl style coordinate system)
			var b:Bitmap = new Bitmap(bmd_);
			b.smoothing = true;
			b.scaleY = -1;
			b.y = b.height;
			b.scaleX *= 1 / AA;
			b.scaleY *= 1 / AA;
			addChild(b);

			addEventListener(Event.ENTER_FRAME, onEnterFrame);
		}

		/**
		 *
		 * @param event
		 *
		 */
		private function onEnterFrame(event:Event):void
		{
			var x:int, y:int;
			var c:int = 2000;

			while (c--)
			{
				shootRay(Math.random() * WIDTH, Math.random() * HEIGHT);
			}

			bmd_.lock();

			for (y = 0; y < HEIGHT; ++y)
			{
				for (x = 0; x < WIDTH; ++x)
				{
					const i:int = y * WIDTH + x;

					if (counts_[i])
					{
						var color:Vec3 = buffer_[i];

						const r:int = Utils.clampi(color.x * 255 / counts_[i], 0, 0xff);
						const g:int = Utils.clampi(color.y * 255 / counts_[i], 0, 0xff);
						const b:int = Utils.clampi(color.z * 255 / counts_[i], 0, 0xff);

						bmd_.setPixel(x, y, (r << 16) | (g << 8) | b);
					}
				}
			}

			bmd_.unlock();
		}

		/**
		 *
		 * @param x
		 * @param y
		 *
		 */
		private function shootRay(x:Number, y:Number):void
		{
			var ray:Ray = new Ray();

			ray.o.x = 0;
			ray.o.y = 0;
			ray.o.z = 0;

			const nx:Number = (2 * (x / WIDTH) - 1) * WIDTH / HEIGHT;
			const ny:Number = 2 * (y / HEIGHT) - 1;

			ray.d.x = CAM_NEAR * Math.tan(CAM_FOV * 0.5) * nx;
			ray.d.y = CAM_NEAR * Math.tan(CAM_FOV * 0.5) * ny;
			ray.d.z = -CAM_NEAR; 

			ray.d = Utils.norm(ray.d);

			const i:int = int(y) * WIDTH + int(x);

			var c:Vec3 = radiance(ray, 0);

			buffer_[i].x += c.x;
			buffer_[i].y += c.y;
			buffer_[i].z += c.z;

			counts_[i]++;
		}

		/**
		 *
		 * @param ray
		 * @param depth
		 * @return
		 *
		 */
		private function radiance(ray:Ray, depth:int):Vec3
		{
			var i:int;
			var sphere:Sphere;
			var t:Number;

			if (depth > MAX_DEPTH)
				return new Vec3();

			var nearest:Number = Infinity;
			var collider:Sphere = null;

			for (i = 0; i < scene_.length; ++i)
			{
				sphere = scene_[i];

				t = sphere.intersect(ray);

				if (t > 0 && t < nearest)
				{
					nearest = t;
					collider = sphere;
				}
			}

			if (collider == null)
				return new Vec3();

			// compute new ray
			var out:Ray = new Ray();

			out.o.x = ray.o.x + nearest * ray.d.x;
			out.o.y = ray.o.y + nearest * ray.d.y;
			out.o.z = ray.o.z + nearest * ray.d.z;

			var normal:Vec3 = new Vec3();
			normal.x = out.o.x - collider.center.x;
			normal.y = out.o.y - collider.center.y;
			normal.z = out.o.z - collider.center.z;
			normal = Utils.norm(normal);

			var tangent:Vec3 = new Vec3();

			if (Math.abs(normal.x) < Utils.EPSILON)
			{
				tangent.x = 0;
				tangent.y = -normal.z;
				tangent.z = normal.y;
			}
			else
			{
				tangent.x = normal.y;
				tangent.y = -normal.x;
				tangent.z = 0;
			}

			tangent = Utils.norm(tangent);

			const bitangent:Vec3 = normal.cross(tangent);

			// random ray shooting from the normal hemisphere
			const angle:Number = Math.random() * Math.PI * 2;
			const radius2:Number = Math.random();
			const radius:Number = Math.sqrt(radius2);

			const cos:Number = Math.cos(angle) * radius;
			const sin:Number = Math.sin(angle) * radius;
			const sqrt:Number = Math.sqrt(1 - radius2);

			out.d.x = tangent.x * cos + bitangent.x * sin + normal.x * sqrt;
			out.d.y = tangent.y * cos + bitangent.y * sin + normal.y * sqrt;
			out.d.z = tangent.z * cos + bitangent.z * sin + normal.z * sqrt;

			out.d = Utils.norm(out.d);

			// compute new color
			var color:Vec3 = radiance(out, depth + 1);

			color.x *= collider.color.x;
			color.y *= collider.color.y;
			color.z *= collider.color.z;

			color.x += collider.emission.x;
			color.y += collider.emission.y;
			color.z += collider.emission.z;

			return color;
		}
	}
}

class Vec3
{
	public var x:Number;
	public var y:Number;
	public var z:Number;

	public function Vec3(x:Number = 0, y:Number = 0, z:Number = 0)
	{
		this.x = x;
		this.y = y;
		this.z = z;
	}

	public function cross(v:Vec3):Vec3
	{
		var o:Vec3 = new Vec3();

		o.x = y * v.z - z * v.y;
		o.y = z * v.x - x * v.z;
		o.z = x * v.y - y * v.x;

		return o;
	}
}

class Ray
{
	public var o:Vec3 = new Vec3();
	public var d:Vec3 = new Vec3();
}

class Sphere
{
	public var radius:Number;
	public var center:Vec3;
	public var color:Vec3;
	public var emission:Vec3;

	public function Sphere(radius:Number, center:Vec3, color:Vec3, emission:Vec3)
	{
		this.radius = radius;
		this.center = center;
		this.color = color;
		this.emission = emission;
	}

	/**
	 *
	 * @param ray
	 * @return
	 *
	 */
	public function intersect(ray:Ray):Number
	{
		const px:Number = ray.o.x - center.x;
		const py:Number = ray.o.y - center.y;
		const pz:Number = ray.o.z - center.z;

		const pp:Number = px * px + py * py + pz * pz;
		const pd:Number = px * ray.d.x + py * ray.d.y + pz * ray.d.z;

		const A:Number = 1;
		const B:Number = 2 * pd;
		const C:Number = pp - radius * radius;

		const det:Number = B * B - 4 * A * C;

		if (det < 0)
			return -1;

		const det2:Number = Math.sqrt(det);

		const sol:Number = (-B - det2) / (2 * A);

		if (sol < 0)
			return -1;

		return sol;
	}
}

class Utils
{
	public static const EPSILON:Number = 0.0001;

	public static function clamp(v:Number, min:Number, max:Number):Number
	{
		return Math.max(Math.min(v, max), min);
	}

	public static function clampi(v:int, min:int, max:int):int
	{
		return Math.max(Math.min(v, max), min);
	}

	public static function norm(v:Vec3):Vec3
	{
		var o:Vec3 = new Vec3(v.x, v.y, v.z);

		const dd:Number = v.x * v.x + v.y * v.y + v.z * v.z;
		if (dd == 0) return o;

		const invd:Number = 1 / Math.sqrt(dd);
		o.x *= invd;
		o.y *= invd;
		o.z *= invd;		

		return o;
	}
}

class Scenes
{
	public static const R:Number = 1e5;
	public static const G:Number = 0.5;

	public static const scene00:Array =
		[
			new Sphere(R, new Vec3(-R-1, 0, 0), new Vec3(G, G, G), new Vec3()),//left
			new Sphere(R, new Vec3(R+1, 0, 0), new Vec3(G, G, G), new Vec3()),//right
			new Sphere(R, new Vec3(0, 0, R+1), new Vec3(G, G, G), new Vec3()),//front
			new Sphere(R, new Vec3(0, 0, -R-1), new Vec3(G, G, G), new Vec3()),//back
			new Sphere(R, new Vec3(0, R+1, 0), new Vec3(G, G, G), new Vec3()),//top
			new Sphere(R, new Vec3(0, -R-1, 0), new Vec3(G, G, G), new Vec3()),//bottom
			new Sphere(0.5, new Vec3(0, 1+0.25, 0), new Vec3(), new Vec3(12,12,12))//light
		];
}

Without looking at the shoulders of giants, I implemented a simple scratching demo. Basically, whenever the scratching is initiated, I pause the source stream and start playing a stream which has a “fill-audio-buffer” callback attached to it. That is, the audio is generated dynamically by filling a small playback buffer in the callback function. In the callback, a simple linear interpolation between the previous position in the scratch buffer and the current position is performed.

for (int i = 0; i < buffer_length; ++i) output[i] = input[F(i)];

where F is a piecewise linear function interpolating between [prev_sample_index, C * prev_pos_screen] and [curr_sample_index, C * curr_pos_screen]. The C multiplier corresponds to a relationship between a finger position (whether it’s a translational or a rotational motion) and the position in the source buffer. It turns out that the sound this method produces is too “digital”. It is far from a smooth vinyl scratching emulation. Consulting with our audio (and graphics) designer revealed that it is caused by abrupt changes in the playback frequency (= dF/dt). Thus started a few days of figuring out/tweaking parameters of various interpolation methods that would ensure smooth frequency slides during scratching.

At that point I started looking for other people trying to do the same. It turns out that although a lot of people claim/show they know how to achieve the effect, only a few share some code. Since my result seems to be satisfactory to our team, let me describe my approach and share the full source code.

There are two basic problems to deal with. The first one is how to interpolate the source wave to find intermediate values when F is a general function. The other one is to have smooth frequency changes.

1. Sound wave interpolation

This was the easier problem. A quick search revealed a Stack Overflow discussion and a useful article by Olli Niemitalo. Using the “6-point, 5th-order optimal 32x z-form implementation” interpolator seemed to have done the trick (maybe even a simpler interpolator would suffice).

2. Frequency interpolation

I was mainly looking at two features of the interpolation function (see curve fitting, smoothing) which seem to be on the opposite sides of a balance scale. One is smoothness of the function, the other one is fitness, that is, how close the function is to the recorded (interpolated) values.

Our approach is to get a nice smooth function without trying to achieve precision first and then apply tricks to push it closer to the recorded values. We discovered that a simple moving average of the scratching velocity (averaged over 3000 audio samples) and integrating the result works well. As expected, it quickly drifts away from the target position C * curr_pos_screen. To remedy this problem we chose to adjust the velocity to point in the direction towards the target position. And the further the target is (that is, the bigger the error), the larger the adjustment is. (Note: another approach would be to base the adjustment magnitude on the current scratching speed or acceleration rather than error.)

Feel free to look at the source code, use your own music, play around with the interpolation functions or change the input method.

[UPDATE]

Now using mmap to allow for scratching the whole length of the track. Download the source code.

The demo shows 100 random (intersecting) triangles textured with a Lena image and is rendering at about 30FPS on my Windows 7/Intel Xeon 5160.

Grab the source code!

A quick demo showed that I would need a lot of line segments. It turned out that Graphics‘ moveTo and lineTo is too slow for that amount of lines. So I started looking for an Alchemy implementation of a line drawing algorithm, specifically Bresenham’s line algorithm. The search was not successful so I rolled up my sleeves and started coding it myself – with help of existing Alchemy demos and a C implementation of the algorithm. Here’s the result. Click it to switch between Alchemy rendering and Graphics rendering.

Source code here.

Attempt #1 – drawing on top of previous frames – rejected

Very simple but occasionally powerful effect of blending with the previous frame (looks like what’s going on when you get hit in Call of Duty 4). It works for slow motion, but as soon as the globe starts spinning quickly, you can see the individual frames.

Attempt #2 – accumulation buffer using FBO -  rejected

Also simple to implement. Basically it’s simulating the accumulation buffer (which is not available on the iPhone). I wasn’t able to find a sweet spot between a nice-looking motion blur and maintaining high fps (even if the rendering is performed at a much lower resolution).

Attempt #3 – screen space blurring – rejected

Originally sounded like a good idea – thought no one would be able to tell that it’s only a 2d blur. Not true. Rejected.

Attempt #4 – pre-blurred texture maps – used

Main idea: if the globe is spinning along its “main” axis (south pole to north pole), the motion blur can be simulated by just blurring the texture horizontally. How about generating a couple of pre-blurred texture maps corresponding to different rotations axes.

Before I get into details I must say that it works really well. I only use 32 different versions (making the amount of rotation axes 64) and it’s really hard to tell that it’s blurred along an axis that’s slightly off (in the actual iPhone application that this was developed for I am actually snapping to the correct axis which is impossible to notice).

The next disadvantage is also obvious: I only have a limited amount of blur values. In the application I work around that by accelerating and decelerating rapidly.

Step 1

How to find the best distribution of 32 points on a sphere (actually 64, but the other 32 are just opposite versions of the first 32)? I wrote a Flash application that does it for me. It runs a simulation of the following algorithm. Thirty two points are randomly positioned in space, each has a positive charge and is restricted to the unit sphere. The purpose of the positive charge is that the points are repulsed from each other, eventually ending up in an even distribution.

Step 2

Blurring the original texture by a general axis is just a matter of writing down a couple of equations and hoping that you haven’t made a typo.

Step 3

Using the pre-blurred textures is now a piece of cake. Just find the nearest axis and use the corresponding texture.

Attempt #5 – am I missing something obvious here?

Let me know if I am.

Get the source code (contains the walking creatures, too).

PS: Again, if you happen to evolve an interesting locomotion, send me your code/swf and I’ll post it here.

Preparation

Here is the first demo.

The task is to teach an ant to get to the end of the L-shaped corridor as fast as possible. All an ant is allowed to do (every frame) is rotate freely and turn on its forward thrust (acceleration). Ant’s behavior is encoded in its DNA consisting of several genes. Every gene prescribes what an ant does in the frame that corresponds to the index of the gene in the DNA. Specifically, each gene is a 3-bit number encoding the ant’s possible behavior:

var gene:int = dna[simulationStep];
var acceleration:Boolean = gene & 1;
var turnPositive:Boolean = gene & 2;
var turnNegative:Boolean = gene & 4;

The genetic operators used are not tuned for this particular application. What you see on the screen is one population of 100 individuals. It takes time but if you let them learn you’ll see that in the end they achieve the goal in the most optimal way.

Evolution

Encouraged by the result (also, it only took about 2 hours to code) I wanted more. Without further ado I present the walking creatures (after 300 generations).

The task here is to give physics-based (thank you, Box2D!) ragdoll figures brains to be able to move a certain distance. Following Ngo and Marks’ paper Spacetime Constrains Revisited I set out to make my own creatures in Flash. In short, I am using a genetic algorithm to train a neural network that controls motors in the creature’s joints. The fitness function is plainly how far a creature can get within a certain amount of time. The neural network used is very simple – it’s a single layer feed-forward neural network with the inputs being the angles at every joint, vertical velocity and horizontal distance traveled and the outputs the speed of the motor and the target angle of every joint.

Results

I was really happy to see results only after about 300 generations (it took a night though): a frog. Excited, I ran it again and again and interestingly, I only got frogs. I tried to change the fitness function a bit so that the creatures that touch the ground are penalized but didn’t get anything interesting. Also tried to make the torso a bit heavier and an inchworm-like creature evolved. If you like, you can try to evolve your own creatures, here’s the link to first generation (with a little bit of creativistic randomization to start with). At the end of every generation, the best DNA is traced so if you happen to get some interesting locomotion, please send it to me and I’ll post it here. (Source code to follow after a brief clean-up.)

Edit: Get the source code in the next GA post.

What’s Next

My plan is to try what behaviors will emerge with different shapes, physics set up, fitness functions or selection algorithms.

I decided to work on a little bit more, but as it turned out really soon, I needed some open format model files that would serve as demos. As a fan of the original Quake, and everything around it, and having a feeling that the original levels could run easily on present hardware minus Flash, I started working on a Quake BSP parser. See the result for yourself. Use mouse (with left button down) for mouselook, ASDW to move horizontally, RF to move up/down.  (It’s intentionally running fullscreen, just maximize your window.)

I would like to point out that it is Flash 9, i.e. no Alchemy involved!

Conclusion: the demo is running just fine to create a true 3D environment for a Flash game!

I recently noticed this little function in the BitmapData class.

public function paletteMap (sourceBitmapData:BitmapData, sourceRect:Rectangle, destPoint:Point, redArray:Array = null, greenArray:Array = null, blueArray:Array = null, alphaArray:Array = null):void

var shininess:Number = 50;

for (var j:int = 0; j < 256; j++)
{
	var alpha:Number = j / 255;
	newPalette[j] = Math.floor(Math.pow(alpha, shininess) * 255);
}