No tricks deployed this time to optimize Flash rendering. That’s a standard implementation.

[kml_flashembed movie="http://www.tweenpix.net/files/fire.swf" width="450" height="175"/]

Here’s the source code. Enjoy !

package
{
	import flash.display.Bitmap;
	import flash.display.BitmapData;
	import flash.display.Sprite;
	import flash.display.StageAlign;
	import flash.display.StageQuality;
	import flash.display.StageScaleMode;
	import flash.events.Event;
	import flash.filters.BlurFilter;
	import flash.geom.Point;
	import flash.geom.Rectangle;

	[SWF( width="450", height="175", frameRate="25" , backgroundColor="0x000000")]
	public class Fire
		extends Sprite
	{
		protected const w : int = 450;
		protected const h : int = 175;

		protected var bd : BitmapData;
		protected var p : Point;
		protected var rect : Rectangle;
		protected var blur : BlurFilter;

		protected var palette : Vector.;
		protected var fire : Array;

		public function Fire()
		{
			stage.scaleMode = StageScaleMode.NO_SCALE;
			stage.align = StageAlign.TOP_LEFT;
			stage.quality = StageQuality.LOW;

			p = new Point(0, 0);
			rect = new Rectangle( 0, 0, w, h );
			blur = new BlurFilter( 4, 4, 1 );
			bd = new BitmapData( w, h, false, 0xFFFFFF );
			addChild( new Bitmap( bd ) );

			var x : int, y : int;
			palette = new Vector.( 256, false );
			fire = [];
			for ( x = 0; x < w; x++ ) fire[x] = new Vector.( h, false );
		    for ( x = 0; x < w; x++ )
		    	for ( y = 0; y < h; y++ )
					fire[x][y] = 256;
			for ( x = 0; x < 256; x++ )
				palette[x++] = HSLtoRGB( x/(3 * 256), 1, Math.min( 256, x * 2 )/256 );

			addEventListener( Event.ENTER_FRAME, enterFrame );
		}

		protected function enterFrame( e : Event ) : void
		{
			bd.lock();
			var x : int, y : int;
		    for ( x = 0; x < w; x++ ) fire[x][h - 1] = Math.random()*32768 % 256;
		    for ( y = 0; y < h - 1; y++ )
    			for ( x = 0; x < w; x++ )
			      fire[x][y] = ((fire[(x - 1 + w) % w][(y + 1) % h]
					+ fire[(x) % w][(y + 1) % h]
			        + fire[(x + 1) % w][(y + 1) % h]
			        + fire[(x) % w][(y + 2) % h]) * 32) / 129;
		    for ( x = 0; x < w; x++ )
			    for ( y = 0; y < h-1; y++ )
			    	bd.setPixel( x, y, palette[fire[x][y]]);
			bd.applyFilter( bd, bd.rect, p, blur );
			bd.unlock();
		}

		public static function HSLtoRGB( h :Number, s : Number , l : Number ) : Number
		{
		    var r : Number = 0, g : Number = 0, b : Number = 0, v1 : Number, v2 : Number;
		    if ( s == 0 )
		    {
		       r = l * 255;
		       g = l * 255;
		       b = l * 255;

		    } else
		    {
		       v2 = ( l < .5 ) ? l * ( 1 + s ) : ( l + s ) - ( s * l );
		       v1 = 2 * l - v2;
		       r = 255 * HueToRGB( v1, v2, h + ( 1 / 3 ) );
		       g = 255 * HueToRGB( v1, v2, h );
		       b = 255 * HueToRGB( v1, v2, h - ( 1 / 3 ) );
		    }
		    return ((r << 16)|(g << 8)|b);
		}

		private static function HueToRGB( v1 : Number, v2 : Number, vH : Number ) : Number
	    {
		    if ( vH < 0 ) vH += 1;
		    if ( vH > 1 ) vH -= 1;
		    if ( ( 6 * vH ) < 1 ) return ( v1 + ( v2 - v1 ) * 6 * vH );
		    if ( ( 2 * vH ) < 1 ) return ( v2 );
		    if ( ( 3 * vH ) < 2 ) return ( v1 + ( v2 - v1 ) * ( ( 2 / 3 ) - vH ) * 6 );
	    	return ( v1 );
		}
	}
}

Inspiration finally came, and I had good time producing some little experiments to play with.
Here’s one of them that I’m glad to share with you.
That’s two animated plasmas mixed together using same color palette. Color palette is splitted in 3 collections, one for red channel, another for green. Blue is unused. The last one is for handling pixels transparency.

[kml_flashembed movie="http://www.tweenpix.net/files/plasma.swf" width="400" height="400"/]


Some optimizations tricks deployed to get display smoothness:
- Plasmas are mixed together without blending. I’m drawing one pixel of each (with boolean checker) while generation.
- I use ByteArray (as video ram like low-level languages do) with BitmapData.setPixels for rendering. I discover it’s faster to not compute each channel if you don’t need it.
- As often, few as3 optimizations tips (Vector collections, int indexes, binary shifting for arithmetical operations, while loop without coordinates…)

Here’s the source code. Enjoy !

package
{
	import flash.display.Bitmap;
	import flash.display.BitmapData;
	import flash.display.Sprite;
	import flash.display.StageAlign;
	import flash.display.StageQuality;
	import flash.display.StageScaleMode;
	import flash.events.Event;
	import flash.filters.BlurFilter;
	import flash.geom.Point;
	import flash.geom.Rectangle;
	import flash.utils.ByteArray;

	[SWF( width="400", height="400", frameRate="25" , backgroundColor="0x000000")]
	public class Plasma
		extends Sprite
	{
		protected const w : int = 400;
		protected const h : int = 400;

		protected var bd : BitmapData;
		protected var ba : ByteArray;
		protected var position : uint;
		protected var p : Point;
		protected var rect : Rectangle;
		protected var shifter : int;
		protected var blur : BlurFilter;

		protected const A : Vector. = new Vector.( 256, true );
		protected const R : Vector. = new Vector.( 256, true );
		protected const G : Vector. = new Vector.( 256, true );
		protected var plasma : Vector.;

		public function Plasma()
		{
			stage.scaleMode = StageScaleMode.NO_SCALE;
			stage.align = StageAlign.TOP_LEFT;
			stage.quality = StageQuality.LOW;

			ba = new ByteArray();
			p = new Point(0, 0);
			rect = new Rectangle( 0, 0, w, h );
			bd = new BitmapData( w, h, true, 0 );
			blur = new BlurFilter( 4, 4, 1 );
			addChild( new Bitmap( bd ) );

			// generate palette
			var i : int = 256;
			while( --i > - 1 )
    		{
    			A[i] = int(128 + 128 * Math.sin( 3.1415 * i / 32));
        		R[i] = int(128 + 128 * Math.sin( 3.1415 * i / 16));
        		G[i] = int(128 + 128 * Math.sin( 3.1415 * i / 64));
    		}

    		// generate plasma
    		var x : int, y : int, l : int = w*h, b : Boolean = true;
    		plasma = new Vector.( l, false );

			while(  --l > - 1 )
			{
  				x = l % w;
				y = (l - x) / w;
				var color : Number;

				if ( b )
					color = (128+(128*Math.sin(x/128))+128
					+(128*Math.sin(y/128)))/2;
				else
					color = (128+(128*Math.sin(x/16))+128
					+(128*Math.sin(y/8))+128
					+(128*Math.sin((x+y)/16))+128
					+(128*Math.sin(Math.sqrt(x*x+y*y)/8)))/4;

        		plasma[l] = color;
        		b = !b;
    		}

			// init screen
			for( x = 0; x < w; x++ )
			{
				for( y = 0; y < h; y++ )
				{
					var pos : Number = (x+(y*w))*4;
					ba[pos] = 255;
					ba[pos+1] = 0;
					ba[pos+2] = 0;
					ba[pos+3] = 0;
				}
			}

			addEventListener( Event.ENTER_FRAME, enterFrame );
		}

		protected function enterFrame( e : Event ) : void
		{
			bd.lock();
			var t : int = ++shifter, pos : int = w*h, palID : int, ID : int;
			while ( --pos > - 1 )
			{
					palID = int((plasma[pos] + t) % 255);
					// to process ARGB channels, same as pos *= 4;
					ID = int(pos << 2);
					ba[ID]	= A[palID];
					ba[ID+1]= R[palID];
					ba[ID+2]= G[palID];
        	}
			ba.position = 0;
			bd.setPixels( rect, ba );
			bd.applyFilter( bd, bd.rect, p, blur );
			bd.unlock();
		}
	}
}

Quoting the official announcement: Alchemy is a research project that allows users to compile C and C++ code that is targeted to run on the open source ActionScript Virtual Machine (AVM2).

I decided to provide an example of double-buffering beetween C code and ActionScript code for people who need it.

There are few traps to avoid.

Documentation on Adobe labs says to use GLEByteArrayProvider to get the ByteArray used as RAM by your C library directly. I tried it, but this class wasn’t public with my configuration.
If you experience the same, you have to reference it dynamically as shown below (like you did with Dictionary class during AS3 beta 2).

	var ns : Namespace = new Namespace( "cmodule.MyModule" );
	var ba : ByteArray = (ns::gstate).ds;

With this workaround, it works like a charm, except GLEByteArrayProvider.get() returns a byte array with a little endian sealed.

This code gives me an error:

var ns:Namespace = new Namespace("cmodule.CGraphicFilter");
baMem = (ns::gstate).ds;
baMem.endian = Endian.BIG_ENDIAN;
lib = (new CLibInit()).init();

LEByteArray endian set attempted
at LEByteArray/set endian()[56201.achacks.as:50]
at AlchemyTest()

You can use an intermediate byte array with big indian to get data as expected by Flash API (as shown below):

protected function enterFrame( e : Event ) : void
{
baMem.position = position;
var ba : ByteArray = new ByteArray();
baMem.readBytes( ba, 0, size );
bd.setPixels( rect, ba );
}

Finally, I felt more comfortable to hack endianness during ram writing on c side . I’m writing bytes values in reverse order (bgra instead of argb).

Here’s C code:

#include 
#include 
#include

#include 
#include "AS3.h"

AS3_Val initVideoData( void* self, AS3_Val args );
AS3_Val update( void* self, AS3_Val args );

int v;
unsigned char* rawImageData;

AS3_Val init( void* self, AS3_Val args )
{
	// malloc (width * height * 4 channels) size
	rawImageData = malloc( 800 * 600 * 4 );
	// fill with black
	memset( rawImageData, 0, sizeof( rawImageData ) );
	// return pointer position
	return AS3_Ptr( rawImageData );
}

AS3_Val update( void* self, AS3_Val args )
{
	int x, y, pos;
	v++;
	v%=16;

	for( x = 0; x < 800; x++ )
	{
		for( y = 0; y < 600; y++ )
		{
			pos = (x+y*800)*4;
			// stub code on red channel. I use BGRA order to simulate big endianness
			rawImageData[ pos +2 ] = 128 + 128 * sin( x / v );
		}
	}

	return 0;
}

int main()
{
	AS3_Val initMethod = AS3_Function( NULL, init );
	AS3_Val updateMethod = AS3_Function( NULL, update );

	AS3_Val result = AS3_Object("init: AS3ValType,update: AS3ValType",initMethod,updateMethod);

	AS3_Release( initMethod );
	AS3_Release( updateMethod );

	AS3_LibInit( result );

	return 0;
}

Here's Flash code to work with C code to update screen.

package
{
	import cmodule.DoubleBuffering.CLibInit;

	import flash.display.Bitmap;
	import flash.display.BitmapData;
	import flash.display.Sprite;
	import flash.display.StageAlign;
	import flash.display.StageQuality;
	import flash.display.StageScaleMode;
	import flash.events.Event;
	import flash.geom.Rectangle;
	import flash.utils.ByteArray;

	[SWF( width="800", height="600", frameRate="25" , backgroundColor="0x000000")]
	public class AlchemyDoubleBuffering
		extends Sprite
	{
		protected const w 			: int = 800;
		protected const h 			: int = 600;
		protected const lib 		: Object = (new CLibInit()).init();
		protected const ba 			: ByteArray = new ByteArray();

		protected var rect 			: Rectangle;
		protected var bd 			: BitmapData;

		protected var baAlchemyRAM 	: ByteArray;
		protected var videoPointer 	: uint;

		public function AlchemyDoubleBuffering()
		{
			stage.scaleMode = StageScaleMode.NO_SCALE;
			stage.align = StageAlign.TOP_LEFT;
			stage.quality = StageQuality.LOW;

			rect = new Rectangle( 0, 0, w, h );
			bd = new BitmapData( w, h, false, 0 );
			addChild( new Bitmap( bd ) );

			// get Alchemy RAM
			var ns : Namespace = new Namespace( "cmodule.DoubleBuffering" );
			baAlchemyRAM = (ns::gstate).ds;

			// call C code to init RAM and store video position
			videoPointer = lib.init();

			addEventListener( Event.ENTER_FRAME, enterFrame );
		}

		protected function enterFrame( e : Event ) : void
		{
			// call C code to update RAM data
			lib.update();

			// update screen with RAM data from stored position
			baAlchemyRAM.position = videoPointer;
			bd.setPixels( rect, baAlchemyRAM );
		}
	}
}

I had a conversation with Mario, and like him, I felt really disappointed with Alchemy graphical performances (BitmapData).

I tried to play with some plasma algorithms and color palettes, and despite of what has been publicised by Adobe I could not create any demo where Alchemy code runs faster than optimized Actionscript.

At this time, the only benefit we see is that you can reuse existing C libraries.