I dunno if this is a good idea or not, but I was just fiddling around with poser and decided to see what happened if I added a gamma correction shader to a light instead of to viki or some other object.  I probably messed something up but this is the version with "GC".

I know this is unnecessary with VSS, but it was just a little experiment I tried... because I'm lazy and still trying to figure out adding rules and all that.

And this is the version without "GC".  Same settings but no nodes attached.  Notice it is much darker overall. 

I'm not sure there is much value in this, but adding the "correction" to the lights might be an easier way to get people into GC and the proper light levels or to let them turn up the brightness without mucking around with intensity or adding more lights.

Here's VSS on an un-"GC"ed light.

And for a final comparison, here's VSS and the GCed lights.  It looks like some color got washed out as well as getting brighter.

Your "GC Light" is nothing more than an ordinary light with an intensity of 50%.

You can't GC a light. All you did was making it stronger, via some very complicated math resulting in a constant.

The Simple_Color with the white chip is a 1.

The next node, Math:Pow (2.2), has no effect on the number 1. 1 to any power is still 1.

Then you multiply it with .8, giving .8.

Color_Math_3:Add is adding white to that, producing 1.8.

Next is Color_Math_2:Pow (1/2.2) producing the number .818181.

You're running that into the Color chip (white). White being equal to 1, the color is .818181.

The intensity is .6, so the resulting luminance of the whole chain is .490909, or roughly 50%.

After all is said and done, the light is a white 50% intensity.

Then you disconnect it all and changed intensity to 20%. Of couse it looks darker.

Change to 50% on the ordinary light shader and it will be the same.

Actually the intensity was .60 on light 1 (infinite), and .20 on light 2 (diffuse) those never changed.  I just didn't switch back to the infinite's light materials in the second shot.

But it's good to see the math and that I did effecitvely nada.  So this is a dumb question: if my values got multipled by .8, thus reducing them/making them darker, why were they brighter when the nodes were plugged in?  Shouldn't the ones not plugged in be brighter if they were .6 and .2 instead of .5 and .16?

I don't understand what you're saying now.

The first screen shot, the intensity was .6 times the nodes which were .818181, giving .491 or about .5.

The second screen shot the intensity is .2.

.5 is brighter than .2

AAAAAH dang it. I forgot some parentheses when I typed things into the calculator.

The nodes produced 1.306, not .818181.

So the node network intensity was .6 * 1.306 = .784.

Now, I'm confused. I thought we're meant to GC lights. What happened to that? Not white light: for the reasons given above, but any other, including shades of grey?

Or do we linearise only, as I do with IBL? (Still using Poser 7)

You are, but all that means is that you anti-GC the desired color if you've chosen it by color picking based on what you see in the color chip. Since most people don't have a desired color, but rather they just eye-ball a test render, it's not that important. For example, if you're trying to get a nice orange firelight glow from a light, you choose an orange, see that it doesn't do what you want, and you choose a richer shade. In effect, this is manual anti-GC.

If, however, you wanted precisely 100% red and 50% green, to make a rich orange without even bothering to look at how it renders, then the color you want is RGB 255, 128, 0, by definition. Those are the linear numbers for a 100% red and 50% green. 

linearize only.  all light is only seen when it interacts with something.  any time there are going to be more (linear) calculations, you don't want to correct.  if you correct the light, it won't be the right color when it becomes part of a (for instance) a diffuse calculation.

In the real world, you can't gamma correct light, so it seems a strange idea to do it in Poser.

Gamma correction is what you apply to the output of a light sensitive device (light being the input) to correct for its non-linear response. A non-linear response means, in a nutshell, that if you double the light intensity you won't double the strength of the signal produced by the device.

Gamma correction is also required for light-emitting devices, such as monitors, which also have a non-linear response. This time, the device does not (for example) emit twice the light if you double the input signal. The correction has to be applied to the input (the signal) because it can not be applied to the output (light).

In Poser, the light(s) in your scene are the input. The shaders applied to objects in the scene are the 'device' - what the light interacts with. The 'device' produces the signal for output - what you see on your monitor. So it only makes sense to gamma correct shaders for lit objects in the scene.

Anything you do to the lights can only affect their intensity or color, no matter how complex the math.