Re: Optimization tips for alpha blending / rasterization loop

[Andrea Fontana]

On Friday, 22 November 2013 at 08:44:06 UTC, Andrea Fontana wrote:

On Friday, 22 November 2013 at 03:36:38 UTC, Craig Dillabaugh wrote:

On Friday, 22 November 2013 at 02:24:56 UTC, Mikko Ronkainen
wrote:

I'm trying to learn some software rasterization stuff. Here's what I'm doing:

32-bit DMD on 64-bit Windows

Framebuffer is an int[], each int is a pixel of format 0xAABBGGRR (this seems fastest to my CPU + GPU) Framebuffer is thrown as is to OpenGL, rendered as textured quad.

Here's a simple rectangle drawing algorithm that also does alpha blending. I tried quite a many variations (for example without the byte casting, using ints and shifting instead), but none was as fast as this:

class Framebuffer
{
int[] data;
int width;
int height;
}

void drawRectangle(Framebuffer framebuffer, int x, int y, int width, int height, int color)

{
foreach (i; y .. y + height)
{
  int start = x + i * framebuffer.width;

  foreach(j; 0 .. width)
  {
    byte* bg = cast(byte*)&framebuffer.data[start + j];
    byte* fg = cast(byte*)&color;

    int alpha = (fg[3] & 0xff) + 1;
    int inverseAlpha = 257 - alpha;

bg[0] = cast(byte)((alpha * (fg[0] & 0xff) + inverseAlpha * (bg[0] & 0xff)) >> 8); bg[1] = cast(byte)((alpha * (fg[1] & 0xff) + inverseAlpha * (bg[1] & 0xff)) >> 8); bg[2] = cast(byte)((alpha * (fg[2] & 0xff) + inverseAlpha * (bg[2] & 0xff)) >> 8);

    bg[3] = cast(byte)0xff;
  }
}
}

I would like to make this as fast as possible as it is done for almost every pixel every frame.

Am I doing something stupid that is slowing things down? Cache trashing, or even branch prediction errors? :) Is this kind of algorith + data even a candidate for SIMD usage? Even if fg is of type byte, fg[0] would return greater value than 0xff. It needs to be (fg[0] & 0xff) to make things work. I wonder why?

Do you want to use a ubyte instead of a byte here?

Also, for your alpha channel:

int alpha = (fg[3] & 0xff) + 1;
int inverseAlpha = 257 - alpha;

If fg[3] = 0 then inverseAlpha = 256, which is out of the range
that can be stored in a ubyte.

Craig

If I'm right all of these lines:

byte* fg = cast(byte*)&color;
int alpha = (fg[3] & 0xff) + 1;
int inverseAlpha = 257 - alpha;

are constant, and you put it outside the both foreach using an enum;

you can also pre-calculate this:
(alpha * (fg[0] & 0xff)

before foreach.

Of course I mean immutable, not enum :)