Does GPU mipmapping assume the texture es gamma corrected?

Question

I have been reading the Real Time Rendering book and stumbled upon this paragraph:

For textures encoded in a nonlinear space (such as most color textures), ignoring gamma correction when filtering will modify the perceived bright- ness of the mipmap levels [121]. As you get farther away from the object and the uncorrected mipmaps get used, the object can look darker overall, and contrast and details can also be affected. For this reason, it is impor- tant to convert such textures into linear space, perform all mipmap filtering in that space, and convert the final results back into nonlinear space for storage.

I have never taken into account gamma correction for color textures using mipmapping.

For generating mipmaps I have always used the GPU-implementation (OpenGL):

glGenerateMipmap

In the resources I have learned from, gamma correction has not been mentioned as something that has to be taken into account for mipmapping.

I was wondering, since color textures that include gamma correction seem to be the norm, are the GPU-provided filtering functions already taking into account gamma correction?

Answer 1

Taking from the OpenGL 4.4 specification:

The contents of the derived arrays are computed by repeated, filtered reduction of the level_base array. For one- and two-dimensional array and cube map array textures, each layer is filtered independently. No particular filter algorithm is required, though a box filter is recommended as the default filter.

So we can see that this is farily weakly-specified, and details of how submips are filtered are left up to the implementation.

In other words: if you require gamma-correction you can't make any assumptions about how, or even if, your GL implementation will do it, so you will need to write your own miplevel reduction in software.

Answer 2

I wanted to share some tests I made.

So we have this image (800x600px):

And we are going to downscale it to 400x300px in 3 different ways

1. Simple box filter, in CPU

2. Undo gamma correction -> box filter -> redo gamma correction, in CPU:

3. Just use the second level of GPU mipmapping (OpenGL)

All the images look quite similar to me and, in fact, I can't really tell the difference when I switch between them.

So I made a little program to measure the difference between images. I just sum the absolute value difference for each pixel for each channel.

And these are the results:

1) - 2) : 516.270264
1) - 3) : 769.195129
2) - 3) : 336.302246

So, at least in my PC, the GPU mipmapping seems to be quite different from the "correct" box filter method. But that could be just because the GPU is using a completely different downsampling method.

Test specs: OpenGL 3.3, Ubuntu 18.04, Nvidia 960M

Test code in github repo