[wish] linear gamma workflow improvements

Hi, and first of all: great to see Fusion getting the love and manpower it needs to regain a footing in the vfx industry. I think nobody expected it to go free but I like the decision very much.

Since this forum is the current place to post bug reports I though I'd also post my wishes here. A big issue I have with Fusion 7 is that it didn't really improve the linear gamma compositing workflow. I even think it did a step back compared to 6.4 because the gamma and gamut options have become more numerous and inconsistent. So this is a longer explanation of what I think would be great to see improved in that particular area.


But first things first... A huge part of this forum's user base (and Blackmagic's client base) is comprised of colorists and thus there will inevitably be a clash of preferred color workflows in Blackmagic's software portfolio now. It might very well be that there is a holy grail of how to design a color workflow that pleases compositing artists, colorists and newbies alike. It's going to be interesting to see how Fusion's handling of gamma/gamut and its color correction tools will evolve now. So please read this rather long post as a single compositor's point-of-view with no intention to step on the toes and needs of other artists


Here we go:

Nuke seems to have set a standard for a linear gamma compositing workflow. I think that's because of one thing that to me feels like the litmus test for a successfully-implemented linear workflow:

The user doesn't know that the image is actually not what it appears to be on screen. It's conveniently gamma-corrected under the hood.

Unless you poke deeper or change default settings, working in Nuke feels like working in any other application before the advent of linear gamma compositing. The color wheel looks familiar, imported footage looks like in editorial, solid colors or gradients visually match the colors that were picked and sliders like gain or contrast do what the users expects them to do. Under the hood, however, the values of pixels and colors are in linear gamma.

Fusion, on the other hand, handles the whole process much less consistent and automatic:

• By default it does no gamma correction on footage, this has to be enabled manually. The viewers have to be set up in a tedious fashion because Fusion doesn't even ship with an sRGB LUT. You need to build your own using the Gamut ViewerLUT (or use custom viewshaders - I wrote one). Or you need to place a gamma 2.2 setting into your LUTs folder... whatever you need to do this for the left and right viewers, for each viewer's A and B buffer and for all your floating views.
  
• Fusion constantly reminds you that what you see is not what you're working on: for one, thumbnails in the flow are not gamma-corrected like viewers are. Another instance would be the tracker tool which doesn't apply the viewer LUT on its magnified rectangle. A third example is the clunky default Windows color picker that Fusion uses which of course is oblivious to gamma or LUTs.
  
• Fusion 7 tried to "fix" the issue of a color in the color picker not looking the same as in a viewer by introducing the "gamma correct color controls" checkbox. It modifies the gradient/wheel of a background tool
  (and for no particular reason that of a CC tool as well) to make the picked color look the same in the viewers and the tool controls. But just under a narrow range of circumstances:
  
  - You're not using the other newly introduced gamma options in the BG tool
  - You're using a 2.2 gamma viewer LUT.
  - You don't look at the thumbnails in the flow view because they won't be gamma corrected.
  - You never pop up the Windows color picker.

• But it gets worse: gamma-correcting the gradient and color wheel is exactly the wrong way do it. It creates a weird, washed out gradient that makes it harder to pick colors. You're once again reminded by Fusion's GUI that you're using it in a non-standard way. It's basically constantly whispering into your ear "wouldn't you rather work in sRGB? See how confusing this linear business is". Nuke on the other hand gets it right (in this regard): the color controls look familiar from Photoshop, your operating system and the time before linear workflows. You can easily pick a nice saturated color without even knowing that you're working in linear since the values you pick have their gamma removed behind the scenes instead of the gradient having gamma added. Many of Nuke's sliders also use a non-linear scale that solves the problem that visually linear gradients are easier to handle for users while actually linear ones look "wrong" (dark).
  
• I have heard from eyeon's engineers that the color picker was actually always using a non-linear mapping behind the scenes to allow for a more pleasing color wheel and better precision towards the center. So I'm a bit confused as to why this usability bonus was thrown out of the window with the "gamma correct color controls" feature.
  
• Background and Gradient tools also have been given gamma/gamut options in Fusion 7. When you design a color or gradient and remove its gamma using these new options you can't tweak it by picking colors from a linear image in your viewer. If you did this, the gamma would get removed twice. You need to disable the gamma removal option again.
  
• With Fusion 7, the gamma/colorspace options in a Loader are now more powerful than the specialized gamut tool! You can mix&match gamuts and gamma curves in ways that were never supposed to go together like a logarithmic gradient that has NTSC gamut.
  
• The Loader gamma/colorspace options have become too numerous. I think most cases would be a task for the gamut tool. The read node in Nuke has a few gamma options only - those that are needed most and you can add your own if your pipeline requires so. In Fusion, linearizing an sRGB image that isn't detected automatically requires the user to scroll past all kinds of arcane gamma stuff (there are even two sRGB options!). Even if the footage's gamma value is detected automatically, Fusion requires a checkbox to be enabled in order to linearize the image.
  
• The Loader gamma/colorspace options also offer logarithmic curves! So if you have a dpx file in your loader you now have TWO places where you can linearize the image. Both have slightly different controls.
  
• The gamut controls in a loader or BG tool add metadata. What irks me about it is that this data doesn't have any effect whatsoever. The merge tool works by looking at the pixel values alone, it doesn't matter which gamut you've set the foreground and background to. You need to do the conversion yourself before the merge. And since the gamut tool doesn't act on the metadata by default you need to do even more thinking and manual labor for a process that should be handled automatically.
  
• Many of Fusion's tool controls are ill-suited for a linear workflow: the color corrector's highlight ranges can't be moved beyond 1.0. Neither can the color wheel's luminance slider. At least you can type in values larger than 1 into the number field but tweaking them requires constant typing and re-typing of numbers since the convenient slider is only available between 0 and 1.
  
• Those sliders that can be moved beyond 1.0 are also weird to use on linear gamma images. They seem to be made for being moved by rule of thumb (until the image looks right) but in linear workflows they lack the precision for tiny steps and small values. There ARE ways to nudge a slider by a tiny amount (ctrl-left/right cursor keys) but in order to do this you must first click onto a slider which might inadvertently move it and you can't use the Tab key to move between sliders.
  
• The contrast operation in Fusion scales values around a pivot of 0.5. Even if this pivot was moved to 0.18 (mid-gray in linear gamma) it wouldn't be of much use since the contrast formula will crush your blacks pretty much immediately. Photoshop has been calling this formula "legacy" contrast for a while now and Nuke's contrast operation - while of course not being overly scientific either - works much better in linear gamma.

This list is based on a post I made on pigsfly. I don't want the list above to come across as a rant. I'm interested in a discussion about the treatment of color and gamma in Fusion since (as I've said in the
beginning) I think that now Fusion needs to reconcile the needs of different crafts much more than before.

And I'm eager to learn how gamma/gamut is currently handled in other parts of Blackmagic's portfolio.

I think that the difference is that Nuke does color space workflow management while Fusion (and AE) does not.

In Nuke if you know the color space and you flag the clip appropriately all will work in linear photometrical light as it should....

So, Fusion should implement OCIO under the hood and it will fix the issue...

In Nuke if you know the color space and you flag the clip appropriately all will work in linear photometrical light as it should....

The same goes for Fusion. OCIO is supported as well. It just takes a bit more effort, as Fusion doesn't make any guesses as to what your colour space might be, and there are workflow issues as illustrated above.

In Nuke if you know the color space and you flag the clip appropriately all will work in linear photometrical light as it should....

The same goes for Fusion. OCIO is supported as well. It just takes a bit more effort, as Fusion doesn't make any guesses as to what your colour space might be, and there are workflow issues as illustrated above.

Even Nuke does not make assumptions (it cannot): is the operator that need to know which color space is the clip... there is then not much differences...

In Nuke if you know the color space and you flag the clip appropriately all will work in linear photometrical light as it should....

The same goes for Fusion. OCIO is supported as well. It just takes a bit more effort, as Fusion doesn't make any guesses as to what your colour space might be, and there are workflow issues as illustrated above.

Even Nuke does not make assumptions (it cannot): is the operator that need to know which color space is the clip... there is then not much differences...

Nuke does make assumptions based on bit depth (although you can change its assumptions in the script settings). OCIO isn't the issue (Nuke didn't have it initially and Fusion supports it by now). It's just that linear light compositing needs a proper GUI built around it. Nuke has always had one but Fusion still has one leg in a time where floating point processing wasn't feasible due to RAM requirements. Even 7.5 defaults to 8 bit integer processing for new comps.

The same goes for Fusion. OCIO is supported as well. It just takes a bit more effort, as Fusion doesn't make any guesses as to what your colour space might be, and there are workflow issues as illustrated above.

Even Nuke does not make assumptions (it cannot): is the operator that need to know which color space is the clip... there is then not much differences...

Nuke does make assumptions based on bit depth (although you can change its assumptions in the script settings). OCIO isn't the issue (Nuke didn't have it initially and Fusion supports it by now). It's just that linear light compositing needs a proper GUI built around it. Nuke has always had one but Fusion still has one leg in a time where floating point processing wasn't feasible due to RAM requirements. Even 7.5 defaults to 8 bit integer processing for new comps.

I see...

Is there a good guide somewhere to linear workflow as it currently is in Fusion?

http://www.comp-fu.com/2012/02/linear-g ... in-fusion/ (some things have changed, but its still valide)

Wow. As a long time Fusion guy who switched to Nuke about 5 years ago, I couldn't agree more with Stefan's assessment. The linear workflow in Fusion really does feel like a pasted on ammendment to the GUI as opposed to the core integration that Nuke implements. I know software devs hate hearing about other competing programs (which to this day I don't understand), but I really do hope BlackMagic is listening and takes the issues Stefan pointed out to heart. I would like add some commentary of my own...

By default [Fusion] does no gamma correction on footage, this has to be enabled manually. The viewers have to be set up in a tedious fashion because Fusion doesn't even ship with an sRGB LUT. You need to build your own using the Gamut ViewerLUT (or use custom viewshaders). Or you need to place a gamma 2.2 setting into your LUTs folder... whatever you need to do this for the left and right viewers, for each viewer's A and B buffer and for all your floating views.

Agreed. This is sloppy, cumbersome, and confusing as it is currently implemented. It would be nice to have this streamlined from the beginning for linear gamma workflow. At the very least maybe when starting a new comp there can be a prompt for how one wants to work: 8-bit sRGB, or floating linear gamma and then the new 'empty' comp script is setup for that workflow.

Fusion 7 tried to "fix" the issue of a color in the color picker not looking the same as in a viewer by introducing the "gamma correct color controls" checkbox. It modifies the gradient/wheel of a background tool (and for no particular reason that of a CC tool as well) to make the picked color look the same in the viewers and the tool controls...

...But it gets worse: gamma-correcting the gradient and color wheel is exactly the wrong way do it. It creates a weird, washed out gradient that makes it harder to pick colors... Nuke on the other hand gets it right (in this regard): the color controls look familiar from Photoshop, your operating system and the time before linear workflows. You can easily pick a nice saturated color without even knowing that you're working in linear since the values you pick have their gamma removed behind the scenes instead of the gradient having gamma added. Many of Nuke's sliders also use a non-linear scale that solves the problem that visually linear gradients are easier to handle for users while actually linear ones look "wrong" (dark).

I was unaware of this (having just recently started playing with Fusion again), but it does pretty much sound like a disaster. And speaking of disasters, don't get me started on the color corrector node. Oy! I do believe non-linear sliders would be essential for gamma workflow, where tiny adjustments go a long way on the bottom end and larger adjustments are needed as you scale up.

The Loader gamma/colorspace options have become too numerous. I think most cases would be a task for the gamut tool. The read node in Nuke has a few gamma options only - those that are needed most and you can add your own if your pipeline requires so. In Fusion, linearizing an sRGB image that isn't detected automatically requires the user to scroll past all kinds of arcane gamma stuff (there are even two sRGB options!). Even if the footage's gamma value is detected automatically, Fusion requires a checkbox to be enabled in order to linearize the image.

The Loader gamma/colorspace options also offer logarithmic curves! So if you have a dpx file in your loader you now have TWO places where you can linearize the image. Both have slightly different controls.

Yes, this really feels like a "kitchen sink" approach. Just throw everything in there and let the user sort it out. Fusion is actually very artist friendly for the most part, but the loader gamma/colorspace options really feel just tacked on without much thought as to it being friendly and usable.

Many of Fusion's tool controls are ill-suited for a linear workflow: the color corrector's highlight ranges can't be moved beyond 1.0. Neither can the color wheel's luminance slider. At least you can type in values larger than 1 into the number field but tweaking them requires constant typing and re-typing of numbers since the convenient slider is only available between 0 and 1.

Just as you have done a whole post on how broken the gamma workflow is in Fusion, I could do one for the color corrector. I'm really hoping this is where BlackMagic's experience with Resolve kicks in. It is a nodal color grading program after all...

Those sliders that can be moved beyond 1.0 are also weird to use on linear gamma images. They seem to be made for being moved by rule of thumb (until the image looks right) but in linear workflows they lack the precision for tiny steps and small values. There ARE ways to nudge a slider by a tiny amount (ctrl-left/right cursor keys) but in order to do this you must first click onto a slider which might inadvertently move it and you can't use the Tab key to move between sliders.

Yes, another case for non-linear sliders. And better precision adjustment capabilities!

I'm really hoping good things come of BM's Fusion acquisition. Unfortunately Fusion is not really taken all that seriously in the world of feature film VFX. One of the top reasons stated for this is the implementation of an essential professional feature like linear gamma workflow. You never get a second chance to make a first impression. And if a bigger effects house is evaluating Fusion, this gamma workflow issue needs to work flawlessly out of the box.

I can only add to how awkward and error prone the current "linear workflow" in Fusion 7.5 is!

At first I was shocked at what I saw but decided to give it some weeks of experimentation to give Fusion a chance. But in the end I'm even more shocked than before about how anyone could work in proper linear space without wasting time or going crazy.

The main problem is that noone I watched using Fusion (i.e. a freelancer we hired for a 3D job here who is an old school Fusion user plus several tutorials I watched all over the web) ever even seems to touch or use the LUT button in the viewer. This means that most people view uncorrected linear colors on their (most likely) sRGB monitors and think that what they're seeing is what they're working on.

The freelance guy started using Fusion in the good old days where noone used linear EXRs but just sRGB sources like TGA and 8-bit TIF. This means, he loaded his images and they looked proper in the viewer, just like they would in Nuke. But as soon as he started doing any compositing work, he applied linear math in sRGB space, which of course lead to all kinds of problems.
In Nuke you're working in linear space without even noticing it. You have to put some effort into breaking things!

And the problem goes deeper. I noticed he rendered linear EXRs out of the 3D DCC. The first thing he did inside Fusion was: convert them to sRGB space so they looked correctly in the viewer. And afterwards he jumped through several hoops and dirty tricks to get rid of black or white fringes around his properly rendered elements. I couldn't believe what I saw.
I showed him that in Nuke I could slap together and color correct / blur his elements on whatever background I wanted without even the slightest fringe.
This is not because Nuke is doing anything better or more correctly than Fusion, but just because Fusion kind of lures you into doing everything wrong!

We then did it the correct way: leave the linear footage untouched, remove sRGB curves from 8-bit sources and most importantly apply a proper sRGB viewer LUT. And all of a sudden even Fusion behaved like it should. A true WOW moment! He has been fighting ghosts for the last 10 years!

Today I gave the 3D tools a try and the renderer output sRGB images by default! WTF?!
Add to this a whole GUI, sliders, color selectors etc. that aren't ready for linear workflow.

I hope Blackmagic wipes up this mess before doing anything else. Fusion itself feels really fast and never crashed once, which is a breath of fresh air when coming from Nuke. But I don't dare giving it to our artists as a new option because I see all kinds of hell breaking loose, when they think it's just some sort of "Nuke for free".

Well, I'll just go and disagree here.
Not up for a lengthy post about what Nuke does wrong and how errors can cost a lot due to its automated color management where Fusion rules, but just for a comparison - my first steps in Fusion were taken in a VFX studio where proper color space knowledge was teached.
A linear workflow in Fusion is natural and easy for a properly taught artist.

There is really no substitute for being educated about color space and workflow. An automate color management and/or lack of knowledge can lead to avalanche-like mistakes and nothing can help you if you don't know what are you doing.

No one has said you can't do proper color/gamma management in Fusion. But nearly everyone agrees that there's lots of room for improvement. I'm sure that you can think of some improvements can be made. Or are actually saying Fusion's gamma workflow is perfect as is?

Hi,

I would like to say +1 to all the points Stefan mentioned. At the University I teach compositing with both Fusion and Nuke. There is a lot I love in Fusion and I use it for many years now. But the linear gamma workflow should be better implemented.
@Stefan: Regarding the gamut metadata you get from the loader: You can use it in the gamut node if you set Source Space to "From Image". The same for the Gamut LUT in the viewer.

Cheers

Peter

No one has said you can't do proper color/gamma management in Fusion. But nearly everyone agrees that there's lots of room for improvement. I'm sure that you can think of some improvements can be made. Or are actually saying Fusion's gamma workflow is perfect as is?

There is always a room for improvement, but I find it hard to agree on "lots" and would most certainly not advocate for a Nuke-like auto management based on the extension to be implemented.

I agree on several points from the OP,but just can't get the confusion, Fusion (no pun intended here) gives to majority of its (new?)users when it comes to linear. It feels pretty straightforward and efficient to me,but then again Fusion was the first software I learned,I've never used layer based apps and hated Nuke from first sight(still do),so maybe I'm a bit biased.

I agree with what Steffen said. Fusion lures you into the wrong workflow - well said.

By the way, Fusion's Renderer3D doesn't render sRGB. It just renders the textures and colors the way they are. The lighting math is linear.

The problem is that by using linearized textures and colors the material viewer and 3D space will be too dark (if you don't set up a buffer LUT) and that the color sliders of 3D materials make choosing a color with linear gamma difficult.

You should give buffer LUTs a try though. They can't be switched on and off easily and they make the gray background of your viewers awkwardly bright. In the olden days you could work against that by modifying your skin but Fusion 7.5 has removed that section of the preferences...

By the way, Fusion's Renderer3D doesn't render sRGB. It just renders the textures and colors the way they are. The lighting math is linear.

In the tests I created, I didn't even use a texture, just a pure white material and a point light.
Here's a screenshot:



On the left you can see an sRGB viewer LUT applied, on the right no LUT = viewing the uncorrected linear render. The lighting gradient on the right side looks correct, although I'm viewing uncorrected linear color space. If the renderer really output linear colors, the left image should look OK, while the image on the right should be too dark.

I have to either use a gamut tool or use the Renderer's image tab / source gamma space to remove the sRGB curve. So the Renderer's default is set to give correctly looking results without a viewer LUT, which I fear is what most Fusion users work in
This IMHO is another case where Fusion gives you the impression you're doing everything right, while you're in reality just waiting for hell to break loose!

The left image image looks wrong because it's an artificial scene. If you rendered that in a 3D app (just a single light with a Phong shader) wouldn't it look the same?

In real life, there's no such thing as a phong-shaded object that is lit by a single light source with an infinitely small radius. To get the soft fall-off you want after applying an sRGB LUT you would need to use an area light, global illumination and so on... This can be faked in Fusion to some extend by using Duplicate3D on your light sources.

The left image image looks wrong because it's an artificial scene. If you rendered that in a 3D app (just a single light with a Phong shader) wouldn't it look the same?

In real life, there's no such thing as a phong-shaded object that is lit by a single light source with an infinitely small radius. To get the soft fall-off you want after applying an sRGB LUT you would need to use an area light, global illumination and so on... This can be faked in Fusion to some extend by using Duplicate3D on your light sources.

I'm not sure that is the issue here, you seem to be talking about the lack of secondary illumination, which is true. But the issue lies here in the gamma curve in the gradient from lit to dark. You can see clearly in those images they both fall off to black (as expected with no fill, or secondary illumination) but the falloff for a phong shader should look like the right hand side image. I just did a quick test in 3DS Max, and a linear render, shown with a SRGB LUT should look like the Right hand image, not the left hand one...

the left image definitely looks like an sRGB image with an sRGB LUT applied to me

To me it looks like a linear image with an sRGB LUT applied, as you would expect. Can I assume your point light has no falloff?

In your setup, with a point light having no falloff shining on a white phong shaded sphere, you would expect a gradient going from 1 to 0, with the 0.5 value pretty much halfway inbetween, using linear math. That's what you see in the render. In a viewer with no LUT applied this would equally be perceived as a linear gradient.

It's when you start dealing with quadratic fallofs that linear rendering should look "correct" under an sRGB LUT.

Just put a texture on something and render that using either an ambient light with a value of 1 or render with no lighting at all. If Fusion's renderer adds sRGB gamma somewhere, you would notice straight away.

Check this out:

The 3D scene renders a rotating plane with a phong shader (no specular component) that is lit from behind the camera by a directional light. The intensity of the center pixel is sampled and compared to a regular sine wave. They both match up so there must be a linear relation between angle of view and intensity.

Code: Select all

{
   Tools = ordered() {
      Camera3D1 = Camera3D {
         CtrlWZoom = false,
         Inputs = {
            AoV = Input { Value = 24.3265863475745, },
            ["Stereo.Mode"] = Input { Value = FuID { "OffAxis", }, },
            ["SurfacePlaneInputs.ObjectID.ObjectID"] = Input { Value = 2, },
            ["MtlStdInputs.MaterialID"] = Input { Value = 2, },
         },
         ViewInfo = OperatorInfo { Pos = { 614.397, 8.97056, }, },
      },
      DirectionalLight1 = LightDirectional {
         CtrlWZoom = false,
         ViewInfo = OperatorInfo { Pos = { 739, 16, }, },
      },
      Shape3D1 = Shape3D {
         CtrlWZoom = false,
         Inputs = {
            ["Transform3DOp.Translate.Z"] = Input { Value = -4, },
            ["Transform3DOp.Rotate.Y"] = Input {
               SourceOp = "Shape3D1YRotation",
               Source = "Value",
            },
            MaterialInput = Input {
               SourceOp = "Phong1",
               Source = "MaterialOutput",
            },
            ["MtlStdInputs.MaterialID"] = Input { Value = 1, },
            ["SurfacePlaneInputs.ObjectID.ObjectID"] = Input { Value = 1, },
         },
         ViewInfo = OperatorInfo { Pos = { 897, -1, }, },
      },
      Shape3D1YRotation = BezierSpline {
         SplineColor = { Red = 128, Green = 255, Blue = 128, },
         NameSet = true,
         KeyFrames = {
            [1] = { -90, RH = { 34, -30, }, Flags = { Linear = true, }, },
            [100] = { 90, LH = { 67, 30, }, Flags = { Linear = true, }, },
         },
      },
      Merge3D1 = Merge3D {
         CtrlWZoom = false,
         Inputs = {
            SceneInput1 = Input {
               SourceOp = "Camera3D1",
               Source = "Output",
            },
            SceneInput2 = Input {
               SourceOp = "Shape3D1",
               Source = "Output",
            },
            SceneInput3 = Input {
               SourceOp = "DirectionalLight1",
               Source = "Output",
            },
         },
         ViewInfo = OperatorInfo { Pos = { 739, 192, }, },
      },
      Background = Background {
         CtrlWZoom = false,
         NameSet = true,
         CustomData = {
            Settings = {
               [1] = {
                  Tools = ordered() {
                     Background = Background {
                        ViewInfo = OperatorInfo {
                           Pos = { 55, 17.05, },
                        },
                        ExtentSet = false,
                        CtrlWZoom = false,
                        NameSet = true,
                        Name = "Background",
                        Inputs = {
                           GlobalIn = Input {
                              Value = 1,
                           },
                           TopLeftAlpha = Input {
                              Value = 0,
                           },
                           Height = Input {
                              Value = 1556,
                           },
                           Gradient = Input {
                              Value = Gradient {
                                 Colors = {
                                    [0] = { 0, 0, 0, 1, },
                                    [1] = { 1, 1, 1, 1, },
                                 },
                              },
                           },
                           UseFrameFormatSettings = Input {
                              Value = 1,
                           },
                           Width = Input {
                              Value = 2048,
                           },
                        },
                        CustomData = {
                        },
                        CurrentSettings = 2,
                     },
                  },
               },
               [2] = {
                  Tools = ordered() {
                     Background = Background {
                        CustomData = {
                        },
                        Inputs = {
                           GlobalIn = Input {
                              Value = 1,
                           },
                           Height = Input {
                              Value = 1556,
                           },
                           Gradient = Input {
                              Value = Gradient {
                                 Colors = {
                                    [0] = { 0, 0, 0, 1, },
                                    [1] = { 1, 1, 1, 1, },
                                 },
                              },
                           },
                           UseFrameFormatSettings = Input {
                              Value = 1,
                           },
                           Width = Input {
                              Value = 2048,
                           },
                        },
                        ExtentSet = false,
                        CtrlWZoom = false,
                        NameSet = true,
                        ViewInfo = OperatorInfo {
                           Pos = { 55, 17.05, },
                        },
                        CurrentSettings = 3,
                     },
                  },
               },
               [3] = {
                  Tools = ordered() {
                     Background = Background {
                        CustomData = {
                        },
                        Inputs = {
                           Start = Input {
                              Value = { 0.5, 0, },
                           },
                           Type = Input {
                              Value = FuID { "Gradient", },
                           },
                           GlobalIn = Input {
                              Value = 1,
                           },
                           End = Input {
                              Value = { 0.5, 1, },
                           },
                           Height = Input {
                              Value = 1556,
                           },
                           Gradient = Input {
                              Value = Gradient {
                                 Colors = {
                                    [0] = { 0, 0, 0, 1, },
                                    [1] = { 1, 1, 1, 1, },
                                 },
                              },
                           },
                           UseFrameFormatSettings = Input {
                              Value = 1,
                           },
                           Width = Input {
                              Value = 2048,
                           },
                        },
                        ExtentSet = false,
                        CtrlWZoom = false,
                        NameSet = true,
                        ViewInfo = OperatorInfo {
                           Pos = { 55, 17.05, },
                        },
                        CurrentSettings = 4,
                     },
                  },
               },
               [4] = {
                  Tools = ordered() {
                     Background = Background {
                        Inputs = {
                           Type = Input {
                              Value = FuID { "Gradient", },
                           },
                           GradientType = Input {
                              Value = FuID { "Radial", },
                           },
                           Width = Input {
                              Value = 2048,
                           },
                           GlobalIn = Input {
                              Value = 1,
                           },
                           End = Input {
                              Value = { 0.5, 1, },
                           },
                           Height = Input {
                              Value = 1556,
                           },
                           Gradient = Input {
                              Value = Gradient {
                                 Colors = {
                                    [0] = { 1, 1, 1, 1, },
                                    [1] = { 0, 0, 0, 1, },
                                 },
                              },
                           },
                           UseFrameFormatSettings = Input {
                              Value = 1,
                           },
                           Start = Input {
                              Value = { 0.5, 0.5, },
                           },
                        },
                        ExtentSet = false,
                        CtrlWZoom = false,
                        NameSet = true,
                        ViewInfo = OperatorInfo {
                           Pos = { 55, 17.05, },
                        },
                        CustomData = {
                        },
                     },
                  },
               },
            },
         },
         Inputs = {
            GlobalIn = Input { Value = 1, },
            GlobalOut = Input { Value = 100, },
            UseFrameFormatSettings = Input { Value = 1, },
            Width = Input { Value = 1280, },
            Height = Input { Value = 720, },
            TopLeftRed = Input { Value = 0.149038461538462, },
            TopLeftGreen = Input { Value = 0.596153846153846, },
            TopLeftBlue = Input { Value = 1, },
            Gradient = Input {
               Value = Gradient {
                  Colors = {
                     [0] = { 0, 0, 0, 1, },
                     [1] = { 1, 1, 1, 1, },
                  },
               },
            },
            EffectMask = Input {
               SourceOp = "Probe",
               Source = "Mask",
            },
         },
         ViewInfo = OperatorInfo { Pos = { 935, 163, }, },
      },
      Phong1 = MtlPhong {
         CtrlWZoom = false,
         Inputs = {
            ["Specular.Nest"] = Input { Value = 1, },
            ["Specular.Intensity"] = Input { Value = 0, },
            UseTwoSidedLighting = Input { Value = 1, },
            MaterialID = Input { Value = 3, },
         },
         ViewInfo = OperatorInfo { Pos = { 897, -33, }, },
      },
      Probe = EllipseMask {
         CtrlWZoom = false,
         NameSet = true,
         Inputs = {
            MaskWidth = Input { Value = 1280, },
            MaskHeight = Input { Value = 720, },
            PixelAspect = Input { Value = { 1, 1, }, },
            ClippingMode = Input { Value = FuID { "None", }, },
            Center = Input {
               SourceOp = "Expression1",
               Source = "PointResult",
            },
            Width = Input { Value = 0.00906514044932339, },
            Height = Input { Value = 0.00906514044932339, },
         },
         ViewInfo = OperatorInfo { Pos = { 935, 121, }, },
      },
      Expression1 = Expression {
         CtrlWZoom = false,
         Inputs = {
            n1 = Input {
               SourceOp = "Probe1",
               Source = "Result",
            },
            PointExpressionX = Input { Value = "time/100", },
            PointExpressionY = Input { Value = "n1", },
         },
      },
      Probe1 = Probe {
         CtrlWZoom = false,
         Inputs = {
            ImageToProbe = Input {
               SourceOp = "Renderer3D1",
               Source = "Output",
            },
            Channel = Input { Value = 4, },
            Width = Input { Value = 0.00675675675675671, },
            Height = Input { Value = 0.0856115107913668, },
         },
      },
      Background_1 = Background {
         CtrlWZoom = false,
         NameSet = true,
         CustomData = {
            Settings = {
               [1] = {
                  Tools = ordered() {
                     Background = Background {
                        ViewInfo = OperatorInfo {
                           Pos = { 55, 17.05, },
                        },
                        ExtentSet = false,
                        CtrlWZoom = false,
                        NameSet = true,
                        Name = "Background",
                        Inputs = {
                           GlobalIn = Input {
                              Value = 1,
                           },
                           TopLeftAlpha = Input {
                              Value = 0,
                           },
                           Height = Input {
                              Value = 1556,
                           },
                           Gradient = Input {
                              Value = Gradient {
                                 Colors = {
                                    [0] = { 0, 0, 0, 1, },
                                    [1] = { 1, 1, 1, 1, },
                                 },
                              },
                           },
                           UseFrameFormatSettings = Input {
                              Value = 1,
                           },
                           Width = Input {
                              Value = 2048,
                           },
                        },
                        CustomData = {
                        },
                        CurrentSettings = 2,
                     },
                  },
               },
               [2] = {
                  Tools = ordered() {
                     Background = Background {
                        CustomData = {
                        },
                        Inputs = {
                           GlobalIn = Input {
                              Value = 1,
                           },
                           Height = Input {
                              Value = 1556,
                           },
                           Gradient = Input {
                              Value = Gradient {
                                 Colors = {
                                    [0] = { 0, 0, 0, 1, },
                                    [1] = { 1, 1, 1, 1, },
                                 },
                              },
                           },
                           UseFrameFormatSettings = Input {
                              Value = 1,
                           },
                           Width = Input {
                              Value = 2048,
                           },
                        },
                        ExtentSet = false,
                        CtrlWZoom = false,
                        NameSet = true,
                        ViewInfo = OperatorInfo {
                           Pos = { 55, 17.05, },
                        },
                        CurrentSettings = 3,
                     },
                  },
               },
               [3] = {
                  Tools = ordered() {
                     Background = Background {
                        CustomData = {
                        },
                        Inputs = {
                           Start = Input {
                              Value = { 0.5, 0, },
                           },
                           Type = Input {
                              Value = FuID { "Gradient", },
                           },
                           GlobalIn = Input {
                              Value = 1,
                           },
                           End = Input {
                              Value = { 0.5, 1, },
                           },
                           Height = Input {
                              Value = 1556,
                           },
                           Gradient = Input {
                              Value = Gradient {
                                 Colors = {
                                    [0] = { 0, 0, 0, 1, },
                                    [1] = { 1, 1, 1, 1, },
                                 },
                              },
                           },
                           UseFrameFormatSettings = Input {
                              Value = 1,
                           },
                           Width = Input {
                              Value = 2048,
                           },
                        },
                        ExtentSet = false,
                        CtrlWZoom = false,
                        NameSet = true,
                        ViewInfo = OperatorInfo {
                           Pos = { 55, 17.05, },
                        },
                        CurrentSettings = 4,
                     },
                  },
               },
               [4] = {
                  Tools = ordered() {
                     Background = Background {
                        Inputs = {
                           Type = Input {
                              Value = FuID { "Gradient", },
                           },
                           GradientType = Input {
                              Value = FuID { "Radial", },
                           },
                           Width = Input {
                              Value = 2048,
                           },
                           GlobalIn = Input {
                              Value = 1,
                           },
                           End = Input {
                              Value = { 0.5, 1, },
                           },
                           Height = Input {
                              Value = 1556,
                           },
                           Gradient = Input {
                              Value = Gradient {
                                 Colors = {
                                    [0] = { 1, 1, 1, 1, },
                                    [1] = { 0, 0, 0, 1, },
                                 },
                              },
                           },
                           UseFrameFormatSettings = Input {
                              Value = 1,
                           },
                           Start = Input {
                              Value = { 0.5, 0.5, },
                           },
                        },
                        ExtentSet = false,
                        CtrlWZoom = false,
                        NameSet = true,
                        ViewInfo = OperatorInfo {
                           Pos = { 55, 17.05, },
                        },
                        CustomData = {
                        },
                     },
                  },
               },
            },
         },
         Inputs = {
            GlobalIn = Input { Value = 1, },
            GlobalOut = Input { Value = 100, },
            UseFrameFormatSettings = Input { Value = 1, },
            Width = Input { Value = 1280, },
            Height = Input { Value = 720, },
            TopLeftRed = Input { Value = 1, },
            TopLeftGreen = Input { Value = 1, },
            TopLeftBlue = Input { Value = 1, },
            Gradient = Input {
               Value = Gradient {
                  Colors = {
                     [0] = { 0, 0, 0, 1, },
                     [1] = { 1, 1, 1, 1, },
                  },
               },
            },
            EffectMask = Input {
               SourceOp = "Sinus",
               Source = "Mask",
            },
         },
         ViewInfo = OperatorInfo { Pos = { 1062, 158, }, },
      },
      Merge1 = Merge {
         CtrlWZoom = false,
         Inputs = {
            Background = Input {
               SourceOp = "Background",
               Source = "Output",
            },
            Foreground = Input {
               SourceOp = "Background_1",
               Source = "Output",
            },
            PerformDepthMerge = Input { Value = 0, },
         },
         ViewInfo = OperatorInfo { Pos = { 935, 262, }, },
      },
      Sinus = EllipseMask {
         CtrlWZoom = false,
         NameSet = true,
         Inputs = {
            MaskWidth = Input { Value = 1280, },
            MaskHeight = Input { Value = 720, },
            PixelAspect = Input { Value = { 1, 1, }, },
            ClippingMode = Input { Value = FuID { "None", }, },
            Center = Input {
               SourceOp = "Expression1_1",
               Source = "PointResult",
            },
            Width = Input { Value = 0.00906514044932339, },
            Height = Input { Value = 0.00906514044932339, },
         },
         ViewInfo = OperatorInfo { Pos = { 1062, 121, }, },
      },
      Expression1_1 = Expression {
         CtrlWZoom = false,
         Inputs = {
            n1 = Input {
               Value = 0.968583161128631,
               Expression = "math.sin(time/100*math.pi)",
            },
            PointExpressionX = Input { Value = "time/100", },
            PointExpressionY = Input { Value = "n1", },
         },
      },
      Renderer3D1 = Renderer3D {
         CtrlWZoom = false,
         Inputs = {
            GlobalIn = Input { Value = 1, },
            GlobalOut = Input { Value = 100, },
            Width = Input { Value = 1280, },
            Height = Input { Value = 720, },
            ["Gamut.SLogVersion"] = Input { Value = FuID { "SLog2", }, },
            SceneInput = Input {
               SourceOp = "Merge3D1",
               Source = "Output",
            },
            ["RendererSoftware.LightingEnabled"] = Input { Value = 1, },
         },
         ViewInfo = OperatorInfo { Pos = { 739, 297, }, },
      },
      Trails1 = Trails {
         CtrlWZoom = false,
         Inputs = {
            Input = Input {
               SourceOp = "Merge1",
               Source = "Output",
            },
         },
         ViewInfo = OperatorInfo { Pos = { 935, 300, }, },
      },
      Note1 = Note {
         Inputs = {
            Comments = Input { Value = "The 3D scene renders a rotating plane with a phong shader that is lit from behind the camera by a directional light.\r\n\r\nView the trails tool in the 2nd viewer.\r\n\r\nwhite = intensity of center pixel from Renderer3D\r\nblue = sine curve\r\n", },
         },
         ViewInfo = StickyNoteInfo {
            Pos = { 1186, 144, },
            Flags = {
               Expanded = true,
            },
            Size = { 196, 179.3, },
         },
      },
   },
}

I just noticed a new option. I don't know how long it's been there...

gamma_aware_color_wheels.PNG (83 KiB) Viewed 13964 times

Thank you, devs!

I just noticed a new option. I don't know how long it's been there...

Thank you, devs!

Whoa, pretty sneaky. You'd think someone from BM would have said something. I take it the gamma control should be set to 2.2 when working in linear gamma in sRGB viewspace.

I just noticed a new option. I don't know how long it's been there...

Thank you, devs!

Whoa, pretty sneaky. You'd think someone from BM would have said something. I take it the gamma control should be set to 2.2 when working in linear gamma in sRGB viewspace.

I would think so, too. Don't know why 2 is the default value. However, the difference isn't that severe. It doesn't really matter which value gets chosen when I drag a slider exactly into the middle (0.21 or 0.26). The gamma-awareness alone makes using the color controls in a linear workflow so much more comfortable

Guys, thank you so much for this thread. I'm switching from AE to Fusion for a telemovie next month and this has helped me sooo much.