Java: Fast Integer Alpha Blending Revisited смотреть онлайн

Shown here is my new approach to the problem of slow floating point translucent pixel blending. Whereas my previous attempt at emulating the calculation yielded noticeable visual artifacts when blending certain colors (dependent upon the mask color; for instance, black produced red spikes on blue against green), this time around I've removed the bitwise-only restriction in favor of integer multiplication and division, producing a far more accurate approximation. The idea behind the new function was inspired by fixed-point arithmetic and as one might notice, it's way smoother than the old one: https://youtu.be/tvbmPSVQoOc .

This demo tested 2 cases. The first test utilizes a depth buffer-like implementation to reduce overdraw (obviously has it's disadvantages when dealing with translucent graphics, but useful in this case for more easily visualizing the smoothness and precision of the blending calculation over an even surface). The second test was run with the depth buffer disabled to show the composition quality of numerous nested blending operations.

The tests consisted of 2000 32x32 translucent sprites, 2 Mega Pixels worth, blitted to the screen each frame.

Now for the interesting stuff, here's the procedure:
-obtain rgb components for source and destination pixels.
-linearly interpolate from the destination to the source components, multiplying the alpha by the difference (dest - source) to produce the interpolant.
-normalize the result, dividing by 255 (or whatever your max component value may be).
-you could also normalize by 256 and optimize the division out in favor of an 8 bit shift to the right at the cost of some precision...
-combine each component and replace the destination pixel.

Hope you found this interesting!