Splitting Floats To Texture Channels

Question

I know, this is a silly question, but since I need this so often, I just want to double check that I made no mistake.

Working with most shader languages, a texture can store $8$ bits per channels, which in the shader programm appear as value in the range range $r_8:=\{0, 1/255, 2/255,\dots,1\}$. What I want to do is to transform between a single $32$ bit floating point value in $(0, 1)$ (I don't care about the floating point specifics here and just think of it as real number) and a $4$-tuple of values in $r_8$, so $\text{split}:(0,1)\to r_8^4$ and $\text{comb}:r_8^4\to(0,1)$.

I specifically want that $\text{comb}(\text{split}(x))=\text{round}(256^4 x)/256^4$ for almost all $x$ (I don't care about the ones lying on boundaries between bins).

My implementation is the following:

• $\text{split}(x)_i := \text{floor}(256^ix)/(255\cdot 256^{i-1})$
• $\text{comb}(x_0,\dots,x_3):=255(x_0/256+\dots+x_3/256^4)+256^4/2$

Is this correct or did I overlook something?

Edit

I realized that the first part should be $$\text{split}(x)_i:=\lfloor(256(256^ix-\lfloor256^ix\rfloor)\rfloor/255$$

Answer 1

This will not work. The principle you are attempting to use would work (with some adjustment) if you were converting between a 32-bit unsigned integer representation and four 8-bit integers, because there are exactly enough bits to use. But the 32-bit “single precision” floating point format uses some of its bits to represent the exponent and the sign:

(Image by Wikipedia user Fresheneesz)

There are only 23 bits available (effectively 24) to represent an integer value. So, you cannot simply pack four 8-bit integers into an mathematically-integer value stored in a 32-bit float — you will run out of precision, and the component stored in the low bits will be corrupted.

However, it is possible to pack the amount of data you want into a float; the key is that you have to reinterpret the bits of the float as a 32-bit integer or vice versa. In GLSL, this is provided by the functions floatBitsToUint() and uintBitsToFloat(). Once you have the unsigned integer, you can proceed as you intended — but the produced float will not be in the range 0 to 1.