Encoding 2 integers into RGBA without bitwise

Question

I'm using Processing(Java) to write shaders that do lots of fancy code art. In my shader code I'm trying to get 2 integers (x,y positions) into an RGBA so I can send this colored pixel back to my Java program - and from there decode this color to get back the original integers. As far a I know, I cant use bitwise operations in GLSL, or least I'd have to re-write a lot of code. So I need to get 2 numbers into an RGBA, or 1 number into 2 bytes (RG) and the other in another 2 bytes (BA) - something like that.. without bitwise.. Help!!

Answer 1

First we must take into account the MSB/LSB order on CPU side and internal format of GPU render buffer. The simplest way to check the order is to set color in GLSL with different channels and read it on CPU side as hex number so:

1. in GLSL set color to vec4(0.1,0.2,0.3,0.4); (r,g,b,a)

2. read the color on CPU side and print it as HEX

   the channels are:

   chn  float             BYTE
        [dec]             [hex]
   r =  0.1 -> 255*0.1 -> 19h
   g =  0.2 -> 255*0.1 -> 33h
   b =  0.3 -> 255*0.1 -> 4Ch
   a =  0.4 -> 255*0.1 -> 66h
   

   Your output was 0x6619334C which identifies the order of r,g,b,a as:

   MSB ....... LSB
   66  19  33  4C  hex (4xBYTE)
   0.4 0.1 0.2 0.3 dec (4xfloat)
   a   r   g   b
   

   so we can encode x,y for example like this:

   MSB ....... LSB
   a   r   g   b
   Yh  Yl  Xh  Xl  
   

   In case your a channel is not correct check if your render buffer has allocated 8 bits for alpha channel during OpenGL context creation (look for pixel format descriptor) and repair if not.

   In case you are using this for different render targets each can have different internal format so you need to check this for each separately.

Another problem is that your color on GLSL side is most likely a vec4 and not integer type so you need to use floats ... Also % requires extention so to avoid that compute it by / like this:

unsigned int x,y; // 2x16 bit integer
vec4 xy;          // 4xfloat (32 bit color)
unsigned int h,l; // temp

h=x/256u; l=x-(256u*h);
xy.b=float(l)/255.0;
xy.g=float(h)/255.0;
h=y/256u; l=y-(256u*h);
xy.r=float(l)/255.0;
xy.a=float(h)/255.0;

Now the extraction of x,y back on CPU side:

unsigned int rgba; // input 32 bit color
unsigned int x,y;  // output 16 bit x,y
y=(rgba>>16)&0x0000FFFF;
x=(rgba    )&0x0000FFFF;