Comments on: Extremely Fast Line Algorithm AS3 Optimized

By: hugo

hugo — Thu, 06 Jan 2011 10:29:51 +0000

i get a syntax error in this line here?!:

if((shortLen ^ (shortLen >> 31)) – (shortLen >> 31) > (longLen ^ (longLen >> 31)) – (longLen >> 31))

why? thx!

By: simo

simo — Fri, 15 Oct 2010 06:37:18 +0000

Mads ny, thanks for sharing! Very useful stuff. I would merge them into new line method to get the performance to max. Respect.

By: Mads ny

Mads ny — Thu, 14 Oct 2010 18:40:54 +0000

GREAT GREAT line drawer funct, and great blog+work by the way.
If you like me, need transparenty with your like drawing, then here’s a great color blending function for ya.

private function blendColors(col1:uint, col2:uint):uint{
var aT:uint = col1 >>> 24;
var rT:uint = (col1 >>> 16 & 0xFF) * (aT/0xFF);
var gT:uint = (col1 >>> 8 & 0xFF) * (aT/0xFF);
var bT:uint = (col1 & 0xFF) * (aT/0xFF);
var aB:uint = col2 >>> 24;
var rB:uint = (col2 >>> 16 & 0xFF) * (aB/0xFF);
var gB:uint = (col2 >>> 8 & 0xFF) * (aB/0xFF);
var bB:uint = (col2 & 0xFF) * (aB /0xFF);
var alpValue:Number = (0xFF – aT)/0xFF;
var aN:uint = Math.min(aB + aT, 0xFF);
var rN:uint = Math.min(rB * alpValue + rT, 0xFF);
var gN:uint = Math.min(gB * alpValue + gT, 0xFF);
var bN:uint = Math.min(bB * alpValue + bT, 0xFF);
return(aN << 24 | rN << 16 | gN << 8 | bN);
}

To use. update the efla's pixel drawing section like this.

if (yLonger)
{
for (var i:int = 0; i != longLen; i += inc)
{
var tcol:uint = blendColors( color, bmd.getPixel32(x + i*multDiff, y+i));
bmd.setPixel32(x + i*multDiff, y+i, tcol)
}
}
else
{
for (i = 0; i != longLen; i += inc)
{
var tcol:uint = blendColors( color, bmd.getPixel32(x+i, y+i*multDiff));
bmd.setPixel32(x+i, y+i*multDiff, tcol);
}
}

and voila, pixels blend when they draw on top of each other with transparency, off remember to set you BitmapData object to transparency, i have mine like this
new BitmapData(X, Y, true);

Hope this could help anyone :)

By: Lauri V.

Lauri V. — Wed, 09 Jun 2010 19:27:41 +0000

Actually i spoke too soon again – i wonder if Michael Abrash’s “run-length sliced Bresenham’s line drawing algorithm” is even faster than fixed point DDA (Han-Po’s implementation). I was estimating the amount of CPU cycles per pixel for both methods and it might even be that mr. Abrash’s code runs 2/3 faster… I do not know though, i haven’t tested/measured it.

For details please see http://downloads.gamedev.net/pdf/gpbb/gpbb36.pdf .

By: simo

simo — Fri, 04 Jun 2010 10:35:08 +0000

ohh, shame :( Would have been nice to find even faster solution.

By: Lauri V.

Lauri V. — Wed, 02 Jun 2010 18:12:37 +0000

I’m sorry for my too fast judgement – Breseham’s line drawing algorithm isn’t fastest on modern 32-bit hardware. Fixed point DDA is the fastest and Han-Po’s algorithm is actually nothing more than a fixed point optimized DDA line drawing algorithm with a new, fancy name.

So, Simo, you’ve got the fastest algorithm already. :)

By: simo

simo — Tue, 01 Jun 2010 10:35:54 +0000

Good for you, Lauri.
How about sharing your method?

By: Lauri V.

Lauri V. — Sat, 29 May 2010 10:14:28 +0000

This agorithm is the naivest possible.
I brewed the same code back in 2003 when i was just starting graphics programming. I had no interests to do reserch on line drawing and thus i didn’t know any other ways to do it. I had no interests for benchmarking and thus i never knew it was so fast.

Basically Bresenham Line Algorithm could be optimized with nested loops to get rid of the inner branch. In the case where dx > dy the inner loop itself could be replaced with horizontal line drawing code i.e. memset() making it blazing fast!

I think the root of Han-Po’s results is unevenly distributed level optimizing among line drawing algorithms making his implemetation seem fastest.

By: simo

simo — Wed, 24 Mar 2010 12:45:10 +0000

auch dave! create a new Rectangle() object into class and use it on every loop cycle:

rect.x = x-(size/2) + i * multDiff;
rect.y = y-(size/2) + i;
rect.width = rect.height = size;
bitmapData.fillRect(rect,color);

much faster.

By: dave

dave — Sun, 21 Mar 2010 00:03:41 +0000

great thanks, worked perfectly for me:

bitmapData.fillRect(new Rectangle(x-(size/2) + i * multDiff, y-(size/2) + i, size, size),color);