Fastest RGB 24bit color blend (and others...)

[DzzD]

yet an other fastest....

this is inlined in 3DzzD so I hope to hadn't made any typos' while typing this function


NB: I may have found a faster method while reviewing this one.... so I will keep this thread up shortly

/**
 * Blend two color
 *
 * blend two RGB colors using a blend factor
 *
 * 0 => return color 1
 * n => return color2*(n/256) + color1*(256-n)/256
 * 256 => return color 2
 *
 *
 * NB : should be inlined for better efficiency
 *
 * @param color1 RGB color input 1
 * @param color2 RGB color input 2
 * @param factor blending factor between color1 & color 2, must be 0>=factor<=256
 *
 * @return color1 blended with color2
 *
 * @see http://dzzd.net/
 * @author Bruno Augier - ( DzzD ) - 2009
 */
 


public int blend(int color1,int color2, int factor)
{
 int f1=256-factor;
 return (   (  ( (c1&0xFF00FF)*f1 + (c2&0xFF00FF)*factor )  &0xFF00FF00  )  | (   ( (c1&0x00FF00)*f1 + (c2&0x00FF00)*factor )  &0x00FF0000  )   ) >>>8;
}

EDIT : error on factor range (256 max rather thn 255)

Others :


50% blend :

Nice. =D

For 50% blending, I kinda like this:
res = ((c1&0xfefeff)+(c2&0xfefeff))>>1;

There's a slight error in the R and G channels, but it's very fast.

[Abuse]

As you are only using f1 twice, and it's such a simple expression I think you'll find it's faster with the '(256-factor)' inlined.

Neat way of doing it; probably an age old optimisation that has been forgotten (or never learnt) by most thanks to ghz processors & hardware pipelines.

[DzzD]

As you are only using f1 twice, and it's such a simple expression I think you'll find it's faster with the '(256-factor)' inlined.

ha yes probably right, I never thought to try that

also a faster way I use sometime is 255^factor but it introduce 1 bit error

Neat way of doing it; probably an age old optimisation that has been forgotten (or never learnt) by most thanks to ghz processors & hardware pipelines.

probably as in the ASM period programs was always full of such optimisation, but I am just big fan of playing with bits

Games published by our own members! Check 'em out!

[Markus_Persson]

Nice. =D

For 50% blending, I kinda like this:
res = ((c1&0xfefeff)+(c2&0xfefeff))>>1;

There's a slight error in the R and G channels, but it's very fast.

[DzzD]

Nice. =D

For 50% blending, I kinda like this:
res = ((c1&0xfefeff)+(c2&0xfefeff))>>1;

There's a slight error in the R and G channels, but it's very fast.

error is not really noticable,

look a little like this one http://www.java-gaming.org/topics/fastest-color-addition-with-clamp-0-255-of-rgb/18379/view.html ( damn.. I never thought of keeping the LSB of RED )

[Abuse]

( damn.. I never thought of keeping the LSB of RED )

I'm sure you meant to say the lsb (least significant bit) of blue, rather than the LSB (Least Significant Byte) of RED =)

[DzzD]

I'm sure you meant to say the lsb (least significant bit) of blue, rather than the LSB (Least Significant Byte) of RED =)

arg !

[DzzD]

just though that if anybody have some other nice bits tips as Markus post above, it would be nice to post it here, so we can have a referent thread of thoses, I have a cupple more that I will try to post here too rather than opening new thread each time

[Abuse]

just though that if anybody have some other nice bits trick as Markus post above, it would be nice to post it here, so we can have a referent thread of thoses, I have a cupple more that I will try to post here too rather than opening new thread each time

Open source library of one-liner methods 

[DzzD]

Open source library of one-liner methods 

yup usefull every time and in any language (maybe can also be usefull for 4k competitor)

Games published by our own members! Check 'em out!

[Abuse]

They arn't graphics related, and i'm sure they've been posted elsewhere, but here are a few I have lying around:

1   2   3   4   5   6   7   8   9   10   11   12   13   14   15   16   17   18   19   20   21   22   23   24   25   26   27   28   29   30   31   32   33

public static final int abs(int a) {       return (a ^ (a >> 31)) - (a >> 31);    }    public static final int min(int a, int b) {       final int signBits = (a - b) >> 31;       // if b > a, signBits==0xFFFFFFFF      // else, signBits==0x00000000       return (b & ~signBits) | (a & signBits);    }    public static final int max(int a, int b) {       final int signBits = (a - b) >> 31;       return (b & signBits) | (a & ~signBits);    }    /**     *     * Optimised method to cap a value in the range of 0 to max, Where max is a     * non-negative integer (aka >=0, or Z-*)     *     * @param value     *            The value to be capped     * @param max     *            the maximum value     * @return     */    public static final int cap(int value, int max) {       return value & ~(value >> 31) & ~((max - value) >> 31) | (((max - value) >> 31) & max);    }

Note.

They're unlikely to be the optimal solution (improvements welcome ofcourse!)
They also aren't guaranteed to be any faster than their respective conventional approaches. =)

[dishmoth]

If you don't know it, the book "Hacker's Delight" (by Henry S Warren) has lots of sneaky bit-twiddling tricks in it.
Simon

[pjt33]

yup usefull every time and in any language (maybe can also be usefull for 4k competitor)

Yes, I used this method for blending in my 4k entry last year.

[DzzD]

hehe nice one !  yes, maybe some are not the fatest but they are interresting anyway !  it seems that  "boolean / two possible value" ( min/max/abs ) are in fact not the best candidate for such optimisation  ( Riven posted about the last one, one or two weeks ago )

I will make a summary of them in the first post later when we will get some more

[Roquen]

Stuck some branch-removal versions here:  http://www.java-gaming.org/topics/bit-twiddle-amp-branch-removal/21443/view.html