The worst thing about that example is that I put the channels in order to make it easy to fill it. What if these were from say, network packets. The channel then would represent 16 players with 28 bits for, say things like firing, crouching, an animation number, anything.
When you use 32-bits to convey 32 pieces of information that you are currently using to carry one, or two, you gain alot. For one thing, you can test 32 states in any combination in one statement. That would take 32 'if a = b's', or one selected mask operation. Let's say you have 8 conditions you want to test for in your hypothetical logic. Now, there are different ways to do this, and you will end up using most of them, because your game is going to be all over the place as far as the logic of the individual subsystems. At some point, you will get deep into the logic, and it will cost you a frame, or you will arrive there to find that you needed to run some code prior to arriving at this condition. This method can test for those unique conditions earlier in the code without using 8 boolean style logic operations; it uses 1.
As far as the snippet, here is what is going on there:
Hex is actually clearer in the end, but I understand your confusion. Decimal is not a good way to look at it, it will confuse you more. It helps to use binary at first sometimes, but that takes up alot of room if you bother to show the entire dword:
+ Code Snippet#constant ONE_OF_SIXTEEN = 0x00000000 [00000000b]
#constant TWO_OF_SIXTEEN = 0x00000001 [00000001b]
#constant THREE_OF_SIXTEEN = 0x00000002 [00000010b]
#constant FOUR_OF_SIXTEEN = 0x00000003 [00000011b]
#constant FIVE_OF_SIXTEEN = 0x00000004 [00000100b]
#constant SIX_OF_SIXTEEN = 0x00000005 [00000101b]
#constant SEVEN_OF_SIXTEEN = 0x00000006 [00000110b]
#constant EIGHT_OF_SIXTEEN = 0x00000007 [00000111b]
#constant NINE_OF_SIXTEEN = 0x00000008 [00001000b]
#constant TEN_OF_SIXTEEN = 0x00000009 [00001001b]
#constant ELEVEN_OF_SIXTEEN = 0x0000000a [00001010b]
#constant TWELVE_OF_SIXTEEN = 0x0000000b [00001011b]
#constant THIRTEEN_OF_SIXTEEN = 0x0000000c [00001100b]
#constant FOURTEEN_OF_SIXTEEN = 0x0000000d [00001101b]
#constant FIFTEEN_OF_SIXTEEN = 0x0000000e [00001110b]
#constant SIXTEEN_OF_SIXTEEN = 0x0000000f [00001111b]
Notice here two things. First, like I said, one hex place = 4 bits
See how the binary bits count? It helps enormously to be able to visualize to some extent what is happening in code. If it looks foreign, it is, just try to get accustomed to it. That is not my code, however. It is not obfuscated, and it flows well to my eyes, but why wouldn't it?
CHANNEL_MASK is any easy way to retrieve only the channel ID. By setting only channel bits in the mask, the && (bitwise AND) will only pick off channel ID bits. The same goes for the data, except that if you are using it as a single 28-bit value, it is shifted left 4 bit positions to make room for the ID in the 4 least significant bits. So, it is effectively multiplied by 16, as you pointed out, but do not use any maths at all on these packed values. First, you need to do the voodoo and get it into its actual type.
Next, the hand magic to fill the array, I should have simply filled it with random values to show that the channels do not need to be in order when evaluated, and in fact, you can force it to sort itself in place if that is what you want. This is actually how multi-channel data acquisition systems stream say 16 channels of 16 bit data with 12 digital bits (16 + 12 + 4 = 32). It keeps the channels' ID with its data, and all is accessible from a single 32-bit value. The same 4 bits could indicate 16 different kinds of anything.
I deliberately chose this example because it is pretty simple, but all that did was underplay its flexibility and still not manage to convey its utility. Sorry.