Neogaf has gone bizarre over the footage. Underwhelming is what they are saying, thanks to Jaffe’s comment about art coming to life.
But I hope you guys will deliver it, no doubt.

unsigned int _max(unsigned int x, unsigned int y)
{
unsigned int r = x - ((x-y) & -(x

unsigned int _max(unsigned int x, unsigned int y)
{
unsigned int r = x - ((x - y) & -(x

const unsigned int uint_bit_mask = unsigned int(-1)/2;
uint first_bit_sign = sign( diff( r1 >> uint_bit_shift, r2 >> uint_bit_shift ) );
uint last_bits_sign = sign( diff( r1 & uint_bit_mask, r2 & uint_bit_mask ) );

If I can’t use 64 bits ints or 33 bits, in other words there’s no way to know if a subtraction did an overflow then I would consider splitting the 32 bits, check the first bit, then check the remaining bits, something like this :

const int uint_bit_shift = sizeof( uint )*8-1;
const unsigned int uint_bit_mask = ~(1 > uint_bit_shift, r2 >> uint_bit_shift ) );
uint last_bits_sign = sign( diff( r1 & uint_bit_mask, r2 & uint_bit_mask ) );

return branchless_sel(r1, r2, first_bit_sign | last_bits_sign );

May be not the best solution ever but it is still branchless!

I presume this is not the solution you are waiting for, perhaps you have a cool trick that you want to share?

In today’s applications, where would this trick find a use (apart from sprite code)?

I don’t see why it is limited to a specific range, the solution itself is just pseudocode, you can always adapt it to your needs

Here’s a c++ solution that is compatible with 32 bits unsigned int :

typedef long long int64;
typedef unsigned long long uint64;
typedef unsigned int uint;

int64 diff( uint a, uint b ) { return (int64( a ) - int64( b )); }
uint sign( int64 val ) { return uint( uint64( val ) >> ( (sizeof( uint64 ) * 8) -1 )); }
uint branchless_sel( uint r1, uint r2, uint val ) { return r1*(1-val) + r2*val; }
uint max_branchless( uint r1, uint r2 ) { return branchless_sel(r1, r2, sign(diff(r1, r2)) ); }