• Many texture manipulations need to be done in linear space, e.g. anti aliasing and light manipulations.
  
• Many tools, like Photoshop, save pictures in non-linear format by default.
  
• You can specify SRGB as a bitmap format (e.g. GL_SRGB in OpenGL to glTexImage2D), and the graphic drivers (or the hardware?) will automatically transform the bitmap you sample from non-linear to linear.
  
• If you transform it yourself, you do that by setting each color component to c^2.2. This would be an approximation of the SRGB.
  
• You can transform each color channel independently on the others.
  
• As a last step, outputting the pixels to the screen, you need to transform it back into non-linear space, using c^(1/2.2) for each channel.
  
• The value 2.2 depends on the display you use. It looks like Apple use 1.8.
  

In most example and tutorials "out there", you don't find any gamma correction being done. So either I don't understand this, or there is a general lack of understanding elsewhere

I am trying to learn about when to use, and when to not use, linear and non-linear color space[/quote]You can think of sRGB as a "compression" format for the number of bits required to store an image without colour banding. Humans are good at differentiating between different colours, especially dark colours. The sRGB curve allocates "more bits" to representing darker colours, which means it allows 8-bit images to have less noticeable colour-banding in dark areas.
I've seen it stated that to get the same precision in dark areas, a linear image would need 10-16 bits.
The bad thing is that doing math in curved spaces is difficult -- we're used to flat spaces, like the number-line, or the cartesian plane, but "gamma spaces" (like sRGB, or "gamma 2.2") aren't flat, they're curved.

I am not sure about the glGenerateMipmap() function. Will it take the linear/non-linear attribute (SRGB) into account when applying the filter functions?[/quote]OpenGL and Dx10/11 should do this correctly (convert to linear, downsample, convert to sRGB), but DX9 does not.

You can specify SRGB as a bitmap format (e.g. GL_SRGB in OpenGL to glTexImage2D), and the graphic drivers (or the hardware?) will automatically transform the bitmap you sample from non-linear to linear.[/quote]When you sample from the texture, the texture-fetch hardware will apply the inverse sRGB curve to convert it from 8-bit sRGB to floating-point linear.

As a last step, outputting the pixels to the screen, you need to transform it back into non-linear space, using c^(1/2.2) for each channel.[/quote]If your render-target is created as an sRGB texture, then when you write to it, the hardware will perform the linear->sRGB conversion when writing values from your pixel shader automatically.
It's common to just assume that the user's monitor is an sRGB monitor (because, it's pretty much *the* standard), but yes, a lot of monitors aren't actually sRGB -- I've seen gamma 2.4 and gamma 1.8 monitors before. To get the correct appearance on these monitors, it would be better to manually convert to e.g. gamma 1.8 rather than to convert to sRGB.

Many tools, like Photoshop, save pictures in non-linear format by default[/quote]If you're painting a picture in an application that doesn't do any "gamma correction", then the data in your file is in the same "gamma space" as your monitor.
That is to say -- the image will only look the way that I saw it (while painting it), if it's displayed on another monitor with the same gamma-curve. If I paint my artwork on a gamma-1.8 screen, and then view it on an sRGB screen, it will look different (because the original data was painted in the "gamma 1.8 space").
For this reason, it's common for games studios to buy expensive calibration equipment to make sure that all of their artists monitors are correctly calibrated to the sRGB curve.

Just wanted to clarify this one. For some reason, they have used "sRGB" to denote "linear color space" in DirectX and OpenGL, which are just two separate things.

So, you've repeated what I've said, then added phrase "as an intermediate step" (to what, by the way?) and now you are saying that
...
Nonsense. sRGB is just a color space, nothing more. It's not "gamma correction of 2.2",

while in reality RGB and sRGB may actually be the same thing[/quote]Yes, RGB is a loose term so it could mean anything.
But in rendering we deal with linear-RGB spaces, and non-linear RGB spaces (such as "gamma 2.2" and sRGB).
I posted the equations to transform between "linear RGB" and sRGB above, so when we talk about them in rendering they're definitely not the same - one is mathematically linear and one is not!

Have you read the article yourself? The article you provided can be used as an exercise to find out logical fallacies. Begging the question and fallacy of composition are amongst the first ones visible.[/quote]Wow. That article describes the basics for achieving physically correct math in a renderer. What is your problem with it?

you cannot convert between the two using gamma correction, so this SDK article, for instance, is misleading
[/quote]What's your problem with that article?
Maybe if you're disagreeing with nVidia, Microsoft, Kronos, and the GL ARB (3Dlabs, Apple, ATI, Dell, IBM, Intel, SGI, Sun), the problem is actually that they know what they're doing and you're refusing to read wikipedia to catch up? (the argumentum ad verecundiam fallacy, I know -- but while I'm here, what does make you an expert over them?)

Yes, sRGB is a standard and popular color space. But starting from "display performs sRGB gamma correction" - just a senseless manipulation of words.[/quote]The display has to calibrate it's internal voltages so that when it receives a value of 255 it outputs at maxium luminosity, at 187 it outputs half-maximum luminosity, and at 127 it outputs at 21% maximum luminosity. That's the sRGB correction that the monitor must perform.

You don't have either to defend something blindly just because I've pointed out to a misconception in Microsoft manual.

So you are saying that the companies you have randomly selected and mentioned have something to do in decision-making regarding misleading usage of sRGB term? With this, you automatically decide that I'm wrong and you are right?

You are moderator, so you are always right and if there is something you don't like, you rather attack the person[/quote]Moderators always being right is a ridiculous appeal to authority. We generally don't moderate threads that we've participated in either, so my ability to lock/hide abusive content is irrelevant.

I've explained where and why you were wrong, which you've brushed off as nonsense, gibberish and senseless words. I think I've been quite polite regarding such condescension.
Despite 'appeal to popularity' being a fallacy, you do have to consider that perhaps you're just wrong and you should go and re-read the sRGB wikipedia page -- Occam's razor and all that... but take it as a personal slight instead of reflecting on it if you must, or explain to me the flaw in the above math.

You are wrong. sRGB is an application of standardization to RGB color space and it is defined by three primaries in CIE XYZ color space. The transformation between linear and non-linear color spaces is entirely different topic. I've already said this before.

In fact, I think mentioning gamma in sRGB discussion is not relevant.[/quote]The fact is that in OpenGL and D3D sRGB and gamma are related concepts, because as described in the above specification, sRGB is similar to a gamma 2.2 curve...

When I read a texel from an OpenGL sRGB texture, a non-linear transform described on the wikipedia page (which can be approximated as x[sup]^2.2[/sup]) is applied to it automatically.
When I write a pixel to an OpenGL sRGB render-target, a non-linear transform described on the wikipedia page (which can be approximated as x[sup]^(1/2.2)[/sup]) is applied to it automatically.

So if I assume that my input textures were authored in the sRGB space (or on a CRT and are happy that CRT's are close enough to sRGB displays) and assume that the user's output display is an sRGB device, then by using sRGB textures an render-targets, I can perform all of my fragment-shading math in a linear colour space automatically (but still have non-linear inputs and outputs), thanks to GL natively supporting these transforms.

This is the purpose of sRGB formats in OpenGL, as shown by the above OpenGL specifications.

you feel that you are right because you are moderator[/quote]No, that's insulting. I'm quoting the sRGB standard, and you're saying I'm wrong, the standard is wrong, and nVidia, ATI and Microsoft are wrong too. That's pretty simple. Why are you so opposed to learning about sRGB?

P.S. you might want to read some earlier versions of Wikipedia sRGB entry.[/quote]That old version still describes the exact same linear transformation from XYZ followed by a non-linear transformation!!! How can you post this stuff up, and still argue that it's a linear space? Now I think you're just trolling...

You have said that I'm wrong and failed to give any reasonable evidence to support your points[/quote]The wikipedia page that I linked to contains proper references, shown above. Where is your evidence that sRGB is just a linear transform from XYZ with no non-linear part to it?
As well as this obviously false claim, you've attacked an nVidia and microsoft article without actually stating any actual points against them or providing evidence.
You've made claims about the purpose/usefulness of sRGB resources in GL/D3D without providing any evidence to back them up too.
Read the sRGB specification already.

The end result is that when sRGB is viewed on CRT, the viewed gamma appears as 2.2,[/quote]The display has nothing to do with it -- arguing about what a signal looks like when plugged into a display of a different colour space is irrelevant.
e.g. oh I sent the HSV bytes of [0,0,100] on my RGB CRT and it came out Blue!
Yes, CRT's often work in a vague "RGB gamma 2.2" colour space -- however, this is actually a good approximation of sRGB colour space (sRGB was inspired by CRT's), so sRGB images look almost correct when viewed on these displays... However, to display it correctly in theory you should correctly decode the sRGB signal and re-encode it in the monitor's colour space (but in practice with 8-bit inputs, this will do more harm than good), but I assume you already know this - e.g.
if(srgb < 0.04045)
linear = srgb / 12.92;
else
linear = pow( ((srgb + 0.055)/1.055), 2.4 );
CRT = pow(linear, 1/2.2);


If you still don't believe that you can't do math in curved spaces, and that sRGB is a curved space, despite the specification saying so, try it for yourself:
* Pick any two XYZ colours, A[sub]xyz[/sub] and B[sub]xyz[/sub].
* Convert them to "linear RGB" (as defined in the first part of sRGB specification) to get A[sub]linear[/sub] and B[sub]linear[/sub].
* Compute their average C[sub]linear[/sub].
* Convert A[sub]linear[/sub] and B[sub]linear[/sub]. to sRGB following the full sRGB specification to get A[sub]srgb[/sub] and B[sub]srgb[/sub].
* Compute their average C[sub]srgb[/sub].
* Convert C[sub]srgb[/sub] back into "linear RGB" and compare against C[sub]linear[/sub] -- It will be very wrong in most cases.

The reason the GPU hardware supports sRGB as a native colour space now, is so we can use sRGB data for storage and display, while performing our math in a linear colour space, without having the pay the cost of transforming back and forth between the two colour spaces constantly (the hardware makes the conversion 'free'). This is a huge deal, because as the checkerboard image from earlier shows -- math in sRGB space makes no sense.