Question

I am confused as to how OpenGL stores single component textures(like GL_RED).

The GL converts it to floating point and assembles it into an RGBA element by attaching 0 for green and blue, and 1 for alpha.

Does this mean that my texture will take 32 bpp in graphic memory even though I only give 8 bpp?

Also I would like to know how OpenGL converts bytes to float for operations in the shader. It doesn’t seem logical to simply divide by 255..

Answer 1

You don’t know, and you have no way of knowing (ok ok, I kind of lied… there exists documentation which tells you those details for some particular hardware. But in general you have no way of knowing, because you don’t know in advance what hardware your program will run on).

OpenGL stores textures somewhat following your request, but it finally chooses something that the hardware supports. If that means that it converts your input data to something completely different, it does that silently.

For example, most implementations convert RGB to RGBA because that’s more convenient for memory accesses. The same goes for 5-5-5 data being converted to 8-8-8 and similar.

Usually, a 8 bpp texture will take only 1 byte per pixel nowadays (since pretty much every card supports that, and for software implementations it does not matter), though this is not something you can 100% rely on. You should not worry either, though… it will make sure that it somehow works.

Similar can happen with non-power-of-two textures too, by the way. On all modern versions of OpenGL, this is supported (beginning with 2.0 if I remember right). Though, at least in theory, some older cards might not support this feature.
In that case, OpenGL would just silently make the texture the next bigger power-of-two size and only use a part of it (without telling you!).