Fusion Mask Bypass Bug

When bypassing a mask that is connected to a merge node in Fusion, the entire background is displayed instead of the entire foreground. The only way to bypass the mask properly is to disconnect it entirely from the merge, which is terrible for toggling the mask on/off to compare to the original and especially if the mask is connected to multiple other nodes (because every single line has to be disconnected and reconnected to toggle the mask on/off).

Bypassing the mask and disconnecting the mask should behave exactly the same.

Here is a quick test with a white foreground over a blue background.
- Disconnecting the rectangle mask shows the white foreground. (Desired result)
- Bypassing the rectangle mask shows the blue background. (NOT desired result)

Code: Select all

{
   Tools = ordered() {
      Rectangle1 = RectangleMask {
         CtrlWZoom = false,
         Inputs = {
            Filter = Input { Value = FuID { "Fast Gaussian" }, },
            MaskWidth = Input { Value = 1920, },
            MaskHeight = Input { Value = 1080, },
            PixelAspect = Input { Value = { 1, 1 }, },
            UseFrameFormatSettings = Input { Value = 1, },
            ClippingMode = Input { Value = FuID { "None" }, }
         },
         ViewInfo = OperatorInfo { Pos = { 660, 49.5 } },
      },
      white = Background {
         NameSet = true,
         Inputs = {
            GlobalOut = Input { Value = 25, },
            Width = Input { Value = 1920, },
            Height = Input { Value = 1080, },
            UseFrameFormatSettings = Input { Value = 1, },
            ["Gamut.SLogVersion"] = Input { Value = FuID { "SLog2" }, },
            TopLeftRed = Input { Value = 1, },
            TopLeftGreen = Input { Value = 1, },
            TopLeftBlue = Input { Value = 1, }
         },
         ViewInfo = OperatorInfo { Pos = { 495, 82.5 } },
      },
      Merge1 = Merge {
         Inputs = {
            Background = Input {
               SourceOp = "blue",
               Source = "Output",
            },
            Foreground = Input {
               SourceOp = "white",
               Source = "Output",
            },
            PerformDepthMerge = Input { Value = 0, },
            EffectMask = Input {
               SourceOp = "Rectangle1",
               Source = "Mask",
            }
         },
         ViewInfo = OperatorInfo { Pos = { 660, 115.5 } },
      },
      MediaOut1 = MediaOut {
         Inputs = {
            Index = Input { Value = "0", },
            Input = Input {
               SourceOp = "Merge1",
               Source = "Output",
            }
         },
         ViewInfo = OperatorInfo { Pos = { 825, 115.5 } },
      },
      blue = Background {
         NameSet = true,
         Inputs = {
            GlobalOut = Input { Value = 25, },
            Width = Input { Value = 1920, },
            Height = Input { Value = 1080, },
            UseFrameFormatSettings = Input { Value = 1, },
            ["Gamut.SLogVersion"] = Input { Value = FuID { "SLog2" }, },
            TopLeftGreen = Input { Value = 0.333333333333333, },
            TopLeftBlue = Input { Value = 0.498039215686275, }
         },
         ViewInfo = OperatorInfo { Pos = { 495, 115.5 } },
      }
   }
}

I reported this bug back when I switched to v19 (it did not used to behave like this in v18), but it seems to have flown under the radar as it is still persistent in the v20 beta. I'm reporting it again in the hopes that it'll get fixed. Thanks.

I checked again in v20b2 and this bug is still not fixed. It used to work in correctly up to v18.5 and I didn't update until the stable release of v19, which is when I encountered and first reported this bug.

The problem appears to be with the mask input of the Merge node. If you plug a mask into the mask input of a MediaIn node, or Background node, or an effect node like Blur, etc. these all behave as expected when the mask is disabled. So there is something wrong with the mask input on the Merge node.

I don't see anything unusual, myself. I don't recall fusion 18, but even in old eyeon tutorials in behaves as it does now, so I doubt your claim things were differnt before or that it is a bug. But if you can prove that in 18 or earlier version of fusion it worked differently, I'm willing to revise my statement.

FusionQuickStart 002 - Connecting Tools

You have made one wrong assumption in your test as far as I can see. Actually two.

a) you made foreground and background inputs not of the same size, but also you made foreground white, like the mask, making it not obvious.

b) you seem to have assumed that mask impacts merge node itself. This is partly true. Mask input affects foreground, it has no effect on the background, which in the case of merge node is critical for merge node to work. If there is no background valid input, merge node does not output anything. And in the order of things, background always wins. meaning it sets the resolution of the canvas, and bit depth. Mask works along with foreground to produce merge operation. And mask itself does not get visibly outputted from merge node until you multiply by mask and have alpha channel selected as output.

Make the foreground smaller than the background and make it different color, so its easier to see what it happening.

Something like this, so its easier to see.

Code: Select all

{
   Tools = ordered() {
      blue = Background {
         NameSet = true,
         Inputs = {
            GlobalOut = Input { Value = 500, },
            Width = Input { Value = 1920, },
            Height = Input { Value = 1080, },
            UseFrameFormatSettings = Input { Value = 1, },
            ["Gamut.SLogVersion"] = Input { Value = FuID { "SLog2" }, },
            TopLeftGreen = Input { Value = 0.333333333333333, },
            TopLeftBlue = Input { Value = 0.498039215686275, }
         },
         ViewInfo = OperatorInfo { Pos = { 223.667, 65.4848 } },
      },
      Ellipse1 = EllipseMask {
         Inputs = {
            Filter = Input { Value = FuID { "Fast Gaussian" }, },
            MaskWidth = Input { Value = 1920, },
            MaskHeight = Input { Value = 1080, },
            PixelAspect = Input { Value = { 1, 1 }, },
            ClippingMode = Input { Value = FuID { "None" }, }
         },
         ViewInfo = OperatorInfo { Pos = { 394.485, -31.7576 } },
      },
      Baige = Background {
         NameSet = true,
         Inputs = {
            GlobalOut = Input { Value = 500, },
            Width = Input { Value = 1280, },
            Height = Input { Value = 720, },
            ["Gamut.SLogVersion"] = Input { Value = FuID { "SLog2" }, },
            TopLeftRed = Input { Value = 1, },
            TopLeftGreen = Input { Value = 0.666666666666667, },
            TopLeftBlue = Input { Value = 0.498039215686275, }
         },
         ViewInfo = OperatorInfo { Pos = { 228.333, -3.87879 } },
      },
      Merge1 = Merge {
         CtrlWZoom = false,
         Inputs = {
            EffectMask = Input {
               SourceOp = "Ellipse1",
               Source = "Mask",
            },
            MaskChannel = Input { Value = 5, },
            Background = Input {
               SourceOp = "blue",
               Source = "Output",
            },
            Foreground = Input {
               SourceOp = "Baige",
               Source = "Output",
            },
            PerformDepthMerge = Input { Value = 0, }
         },
         ViewInfo = OperatorInfo { Pos = { 372.667, 65.4848 } },
      }
   }
}

When you connect the mask or any other form of node to blue mask input you are adding it to the mix of foreground. Bypassing CTRL + P either foreground or mask input that is connected will result in the same, which is showing only background. You can also have only mask input connected and not yet foreground and same things happen as if you keep the mask connected but bypass it.

Don't forget that alpha channel or mask can be sourced form other channels that are not alpha as well. Luminance, Red, green, blue, hue, saturation etc. Even other auxiliary channels like z-channel and coverage, object or material ID.

The mask input is effectively treated as third input or second foreground. When both mask and foreground are connected, bypassing either of them simply invalidates the other one.

Mask is not applied to the output of the merge node until you multiply by mask. Or apply mask as inverted. Otherwise mask impacts not merge node alpha channel, but interaction with the foreground input.

Mask can also be bypassed if its not the only thing that goes into blue input. For example you can have two masks or mask and something else, or multiple layers and you can bypass those upstream and you will get differnt mask result but not if its the only thing connected. This is how generally fusion works. Same is true with mask input.

Thanks for the reply Kruno. I think maybe there is a misunderstanding of my problem.

When I posted this bug originally after I switched to v19, you also responded in that thread and you agreed with me that it should behave the way I described and that this was probably a bug.

Fusion Mask Bypass Bug v19:
viewtopic.php?f=21&t=209854
-- "Yes, I'm seeing the same thing. I cannot recall if this was always like this or not, I haven't really paid attention, but I agree, it should show foreground as if the mask was detached. Possibly a bug."

This is still that same problem. I'm reposing it in the v20 beta forum because the problem is still here and it's possible my bug report was missed when I posted it before.

Thanks for the reply Kruno. I think maybe there is a misunderstanding of my problem.

When I posted this bug originally after I switched to v19, you also responded in that thread and you agreed with me that it should behave the way I described and that this was probably a bug.


Fusion Mask Bypass Bug v19:
viewtopic.php?f=21&t=209854
-- "Yes, I'm seeing the same thing. I cannot recall if this was always like this or not, I haven't really paid attention, but I agree, it should show foreground as if the mask was detached. Possibly a bug."

Maybe I didn't give it enough attention in that thread or misunderstood what you meant. Its been a while so I don't recall specifically other than reading what is written. I post a lot so its possible I overlooked something I assumed something.

On second examination and with more expriance. I can't say I see the problem with the post you made here. You have an expectation, but that is not enough to make it a bug.

This is still that same problem. I'm reposing it in the v20 beta forum because the problem is still here and it's possible my bug report was missed when I posted it before.

Why is it a problem? I use masks on merge nodes daily and pretty much all the time and never had a practical or workflow problem. So what specifically is the problem? You obviously have an expectation how it should work in your view, which is fine. But how does that turn into a problem for everyone else?

What specific operation are you doing that cannot be done in any other way and specifically demeans this feature you want? I'm curious. Since I 've not found a problem myself. And I use masks in merge nodes all the time. Very useful and powerful feature.

Maybe I didn't give it enough attention in that thread or misunderstood what you meant.

I think it's the other way around actually. Your response here seems like a misunderstanding of what I mean, but in your previous response you did understand what I meant when you said:
"....it should show foreground as if the mask was detached."

That's it exactly, that's what I mean.

At a conceptual level, bypassing any node should give the exact same result as disconnecting the node.
Bypass Node = Disconnect Node
If disconnecting a node and bypassing the node give different results, that's a problem. And yes, I call this a bug.

This is a fundamental principle I'm operating on, where "bypass" means it is completely removed from the system. Any other type of behavior is a bug.

At a practical level:
If you need to see only the background, bypass the Merge node
If you need to see only the foreground, bypass the Mask node

This is a practical reason why bypassing the mask should reveal the foreground, so you have both options available and you can choose which one you need for the task you are doing. Currently you cannot view the foreground without disconnecting the mask entirely (or doing some other hacky solution).

So both on a conceptual and a practical level, the mask input on the merge node should not behave the way it currently does.

You have an expectation, but that is not enough to make it a bug.

While I do have an expectation that bypassing a node should behave the same as disconnecting it (as I explained above), this was also a function I frequently used in v18 and then it stopped working in v19.

Without uninstalling v20 and re-installing v18, I cannot provide visual proof that it used to work. However, if anyone who still has v18.5 or older installed (I'm not sure when it broke, it could have broken in 18.6 but I skipped that update) could verify the change, that would be great.

What specific operation are you doing that cannot be done in any other way and specifically demeans this feature you want?

As I said before, it "can" be done by disconnecting the mask entirely from the merge, but that is terrible for quickly toggling the mask on and off while doing A/B comparisons, especially if the same mask is used in multiple places because every connection has to be disconnected and reconnected to toggle it.

One example I used it for is custom vignette effects which I make using various effects (ColorCorrection, FilmLookCreator, Blurs, etc). Bypassing the mask let me see the effect over the entire screen and bypassing the merge let me see the original video with no effects. I used both options for A/B comparisons while dialing in my settings for the effects and the vignette setting (size, positing, corner radius, soft edge, etc).

Actually I don't see a conceptual or practical problem. Merge node and masks are more a matter of connivance as is transform controls and few other features of merge nodes. But they are not dedicated tools like for example matter control or transform tools, which expand on the merge node functions or rather are dedicated tools which merge node replicates for connivance.

As for disconnecting the mask for merge node. Its really not a problem when you need to do it, and if you need to do it all the time, like I said there are dedicated tools and workflows. You could use the mask on the source, you could do switches, you could do instances, you could do it in whole bunch of differnt ways before you ever get to merge. And if you need to animate it, same thing applies, plus there is a dedicated tool for that. Matte Control. I see no problem. Its a workflow adjustment.

You viggente example could have been done with a simple matte control tool. No problem. After all much like merge tool is primerally a merge tool with some extra fusions, so is matte control as the name suggest controller and combiner of masks, with merge functionality. But if you want more than each offer you sue the appropriate tool in the appropriate place in the flow and or you combine them. Nothing you describe sounds like a problem to me.

In fusion with the combination of blend modes and masks, you can probably cure cancer or disprove gravity.

Jokes aside. My point is that there are more than dozen ways to go about what you described. And that is a workflow choice. As for my original comment. I probably either misunderstood your original post or I made a wrong assumption and didn't spend enough time on it. But if you really bealive that its a bug and not a feature, someone can post an example from previous versions of fusion to prove behavior has change. if that is the case than something else is at play here. But if its the same, than my advice is to adjust your workflow to your needs.

P.S.

I forgot to mention. Mask input for merge node can be from both foreground and background itself. Think about that. Once useful scenario is DOD constraint when it comes from for example background.

sshot-1200.jpg (42.89 KiB) Viewed 1332 times

sshot-1201.jpg (39.46 KiB) Viewed 1332 times

Or this kind of set up.... and many others.

sshot-1202.jpg (55.23 KiB) Viewed 1332 times

Based on your description of the vignette situation. Matte control sounds like a far more appropriate tool.

I think the point of the post was that it used to work the way it was expected to work and doesn't do that now...
And I have just tested it in 18.6.6 build 4 and it is true . If you turn off the poly node , the white FG is displayed , as you would expect.
It is a bug.

Yep, It's worked that way for 20 years. It should behave as expected. Disabling the mask means the foreground it's not masked. Not that it's completely masked.

Here's 18 next to 19.

18 vs.19

Screenshot 2025-04-27 215317.png (268.91 KiB) Viewed 1233 times

Thank you goohoobler1 and bentheanimator for testing it and providing the images. I think that settles the issue that this is indeed a bug, which was broken in v19 and still remains broken in v20.

I see you both are using Fusion Studio, I'm using the Fusion page in Resolve and I hadn't even thought about installing v18 of Fusion Studio to test this. That would be way easier than uninstalling Resolve to roll it back. I'll have to keep that in mind if this comes up again for issues with Fusion.

Thank you goohoobler1 and bentheanimator for testing it and providing the images. I think that settles the issue that this is indeed a bug, which was broken in v19 and still remains broken in v20.

If its proven to b a bug. I stand corrected.

If its proven to b a bug. I stand corrected.

Thank you Kruno.

You viggente example could have been done with a simple matte control tool.

I'm still trying to figure out a better way to set this up temporarily while I wait for this bug to get fixed (hopefully it will fixed ), because having to disconnect/reconnect masks does not work well for A/B comparisons. Based on what you said before by using the matte control, do you mean to use the matte control to combine an additional mask to it in order to fill out the entire mask? Or is there a way to do this only using one matte control by itself?

I tweaked my original example to make a simple vignette effect with blue as the background and white as the vignette. What is the easiest way to set this up with the matte control so that I could toggle between viewing the white vignette over the blue background and only the white foreground? Thanks.

Code: Select all

{
   Tools = ordered() {
      Rectangle1 = RectangleMask {
         CtrlWZoom = false,
         Inputs = {
            Filter = Input { Value = FuID { "Fast Gaussian" }, },
            SoftEdge = Input { Value = 0.2, },
            Invert = Input { Value = 1, },
            MaskWidth = Input { Value = 1920, },
            MaskHeight = Input { Value = 1080, },
            PixelAspect = Input { Value = { 1, 1 }, },
            UseFrameFormatSettings = Input { Value = 1, },
            ClippingMode = Input { Value = FuID { "None" }, },
            Width = Input { Value = 0.9, },
            Height = Input { Value = 0.9, },
            CornerRadius = Input { Value = 0.4, }
         },
         ViewInfo = OperatorInfo { Pos = { 385, -16.5 } },
      },
      white = Background {
         NameSet = true,
         Inputs = {
            GlobalOut = Input { Value = 114, },
            Width = Input { Value = 1920, },
            Height = Input { Value = 1080, },
            UseFrameFormatSettings = Input { Value = 1, },
            ["Gamut.SLogVersion"] = Input { Value = FuID { "SLog2" }, },
            TopLeftRed = Input { Value = 1, },
            TopLeftGreen = Input { Value = 1, },
            TopLeftBlue = Input { Value = 1, }
         },
         ViewInfo = OperatorInfo { Pos = { 165, 49.5 } },
      },
      Merge1 = Merge {
         Inputs = {
            EffectMask = Input {
               SourceOp = "Rectangle1",
               Source = "Mask",
            },
            Background = Input {
               SourceOp = "blue",
               Source = "Output",
            },
            Foreground = Input {
               SourceOp = "white",
               Source = "Output",
            },
            PerformDepthMerge = Input { Value = 0, }
         },
         ViewInfo = OperatorInfo { Pos = { 385, 82.5 } },
      },
      MediaOut1 = MediaOut {
         Inputs = {
            Index = Input { Value = "0", },
            Input = Input {
               SourceOp = "Merge1",
               Source = "Output",
            }
         },
         ViewInfo = OperatorInfo { Pos = { 605, 82.5 } },
      },
      blue = Background {
         NameSet = true,
         Inputs = {
            GlobalOut = Input { Value = 114, },
            Width = Input { Value = 1920, },
            Height = Input { Value = 1080, },
            UseFrameFormatSettings = Input { Value = 1, },
            ["Gamut.SLogVersion"] = Input { Value = FuID { "SLog2" }, },
            TopLeftGreen = Input { Value = 0.333333333333333, },
            TopLeftBlue = Input { Value = 0.498039215686275, }
         },
         ViewInfo = OperatorInfo { Pos = { 165, 82.5 } },
      }
   }
}

Well, your example is a bit abstract, so its hard to contextualize it as an actual vignette. I suggested matte control as a dedicated node to controlling mattes, if you need to combine multiple mattes or if you need to do extra operations on the mattes. Something you can't do in merge node and can be useful.

Like I said, its hard to contextualize in practical term, your very much abstract example. But if I was sticking to abstract, I would connect it like this. Now you can simple bypass mask and see before and after.

sshot-1224.jpg (13.99 KiB) Viewed 878 times

Code: Select all

{
   Tools = ordered() {
      blue_1 = Background {
         NameSet = true,
         Inputs = {
            GlobalOut = Input { Value = 500, },
            Width = Input { Value = 1920, },
            Height = Input { Value = 1080, },
            UseFrameFormatSettings = Input { Value = 1, },
            ["Gamut.SLogVersion"] = Input { Value = FuID { "SLog2" }, },
            TopLeftGreen = Input { Value = 0.333333333333333, },
            TopLeftBlue = Input { Value = 0.498039215686275, }
         },
         ViewInfo = OperatorInfo { Pos = { 1617.37, 354.829 } },
      },
      Rectangle1_1 = RectangleMask {
         Inputs = {
            Filter = Input { Value = FuID { "Fast Gaussian" }, },
            SoftEdge = Input { Value = 0.2, },
            Invert = Input { Value = 1, },
            MaskWidth = Input { Value = 1920, },
            MaskHeight = Input { Value = 1080, },
            PixelAspect = Input { Value = { 1, 1 }, },
            UseFrameFormatSettings = Input { Value = 1, },
            ClippingMode = Input { Value = FuID { "None" }, },
            Width = Input { Value = 0.9, },
            Height = Input { Value = 0.9, },
            CornerRadius = Input { Value = 0.4, }
         },
         ViewInfo = OperatorInfo { Pos = { 1613.85, 266.071 } },
      },
      white_1 = Background {
         NameSet = true,
         Inputs = {
            GlobalOut = Input { Value = 500, },
            Width = Input { Value = 1920, },
            Height = Input { Value = 1080, },
            UseFrameFormatSettings = Input { Value = 1, },
            ["Gamut.SLogVersion"] = Input { Value = FuID { "SLog2" }, },
            TopLeftRed = Input { Value = 1, },
            TopLeftGreen = Input { Value = 1, },
            TopLeftBlue = Input { Value = 1, },
            EffectMask = Input {
               SourceOp = "Rectangle1_1",
               Source = "Mask",
            }
         },
         ViewInfo = OperatorInfo { Pos = { 1773.37, 266.071 } },
      },
      Merge1_2 = Merge {
         Inputs = {
            Background = Input {
               SourceOp = "blue_1",
               Source = "Output",
            },
            Foreground = Input {
               SourceOp = "white_1",
               Source = "Output",
            },
            PerformDepthMerge = Input { Value = 0, }
         },
         ViewInfo = OperatorInfo { Pos = { 1933.37, 354.829 } },
      }
   }
}

......................................

If I were working on actual images and vignette effect I would likley do it like this....

sshot-1225.jpg (79.22 KiB) Viewed 878 times

Now I can in this simple example deactivate, merge6 node and see before and after easily.

And this approach is very flexible since I can continue building as complex masks as I want to and in the end I can just deactivate the merge node for before and after.

sshot-1226.jpg (200.31 KiB) Viewed 878 times

Matte control has bunch in inputs, and sliders and tabs and options to refine or combine masks. Including de-spill. I usually use it for any kind of mask combo that doesn't invole simple operations like merging multiple masks or applying it to merge node. Speaking of masks and merge nodes. They have many use cases and are convenient, but I would use them when its appropriate, not as default method. For something like this effect, I would use them to merge all the other mask type operations rather than as only one mask input.

Like I mentioned earlier, they (mask input for merge node) can be useful for self operations or for limiting DoD or domain of definition. Or when you just need a simple way to limit merge node alpha output.

Or I might use it like this to further limit or expand or change mask. But since its on its own merge after original main parts of the image, its easy to baypass it and see before and after.

sshot-1227.jpg (191.78 KiB) Viewed 858 times

sshot-1228.jpg (188.5 KiB) Viewed 858 times

While I started using fusion more seriously at version 18, to be honest I don't think I've ever really encounters a problem with the bug you mentioned. There are so many possibilities to work the way I illustrated here, that such things are just not something I really encountered. My masking is done after main image components, not on its merge, so they remain separate and easy to control.

Here is an example of an outline. Done with all sorts of masking. But this is the kind of stuff I do all the time and how flexible connections are with no issues. By working in these types of ways, I can easily swap out any part of the composition and replace it with another and not break anything, while keeping control over parameters of individual components. This set up easily lets me change inner or outer outline, color, only outline, full composite etc and still leaves empty input for mask of the merge in case I want to limit the whole thing in the end. I just cooked this up, but its to illustrate how I would go about these things.

sshot-1229.jpg (196.63 KiB) Viewed 858 times

Code: Select all

{
   Tools = ordered() {
      Text = TextPlus {
         NameSet = true,
         Inputs = {
            Softness4 = Input {
               Value = Number {
                  Value = 1
               },
            },
            Softness3 = Input {
               Value = Number {
                  Value = 1
               },
            },
            Softness2 = Input {
               Value = Number {
                  Value = 1
               },
            },
            ExtendHorizontal4 = Input {
               Value = Number {
                  Value = 2
               },
            },
            Thickness2 = Input {
               Value = Number {
                  Value = 0.05
               },
            },
            Alpha4 = Input {
               Value = Number {
                  Value = 0.5
               },
            },
            Opacity3 = Input {
               Value = Number {
                  Value = 0.5
               },
            },
            JoinStyle2 = Input {
               Value = Number {
                  Value = 3
               },
            },
            GlobalOut = Input { Value = 500, },
            Width = Input { Value = 1920, },
            Height = Input { Value = 1080, },
            Depth = Input { Value = 1, },
            ["Gamut.SLogVersion"] = Input { Value = FuID { "SLog2" }, },
            LayoutRotation = Input { Value = 1, },
            TransformRotation = Input { Value = 1, },
            SelectElement = Input { Value = 3, },
            Select = Input { Value = 3, },
            Name2 = Input { Value = "Black Outline", },
            Name4 = Input { Value = "Black Border", },
            Softness1 = Input { Value = 1, },
            StyledText = Input { Value = "TEXT", },
            Font = Input { Value = "Open Sans", },
            Style = Input { Value = "Bold", },
            Size = Input { Value = 0.4606, },
            VerticalJustificationNew = Input { Value = 3, },
            HorizontalJustificationNew = Input { Value = 3, }
         },
         ViewInfo = OperatorInfo { Pos = { 1391.62, -110.478 } },
      },
      Ellipse2 = EllipseMask {
         Inputs = {
            Filter = Input { Value = FuID { "Fast Gaussian" }, },
            MaskWidth = Input { Value = 1920, },
            MaskHeight = Input { Value = 1080, },
            PixelAspect = Input { Value = { 1, 1 }, },
            ClippingMode = Input { Value = FuID { "None" }, }
         },
         ViewInfo = OperatorInfo { Pos = { 1540.29, -191.695 } },
      },
      MatteControl2_4 = MatteControl {
         Inputs = {
            MatteCombine = Input { Value = 4, },
            CombineOp = Input { Value = 1, },
            Filter = Input { Value = FuID { "Fast Gaussian" }, },
            PostMultiplyImage = Input { Value = 1, },
            Background = Input {
               SourceOp = "Text",
               Source = "Output",
            },
            Foreground = Input {
               SourceOp = "Ellipse2",
               Source = "Mask",
            }
         },
         ViewInfo = OperatorInfo { Pos = { 1518.96, -110.478 } },
      },
      Background4_1 = Background {
         Inputs = {
            GlobalOut = Input { Value = 500, },
            Width = Input { Value = 1920, },
            Height = Input { Value = 1080, },
            ["Gamut.SLogVersion"] = Input { Value = FuID { "SLog2" }, },
            TopLeftRed = Input { Value = 0.666666666666667, },
            TopLeftGreen = Input { Value = 0.666666666666667, },
            TopLeftBlue = Input { Value = 1, },
            GradientType = Input { Value = FuID { "Radial" }, },
            Start = Input { Value = { 0.5, 0.5 }, },
            Gradient = Input {
               Value = Gradient {
                  Colors = {
                     [0] = { 1, 1, 1, 1 },
                     [1] = { 0, 0, 0, 1 }
                  }
               },
            },
            EffectMask = Input {
               SourceOp = "MatteControl2_4",
               Source = "Output",
            }
         },
         ViewInfo = OperatorInfo { Pos = { 1776.43, -182.449 } },
      },
      ErodeDilate1 = ErodeDilate {
         Inputs = {
            ApplyMaskInverted = Input { Value = 1, },
            MultiplyByMask = Input { Value = 1, },
            XAmount = Input { Value = 0.01, },
            Input = Input {
               SourceOp = "Background4_1",
               Source = "Output",
            },
            EffectMask = Input {
               SourceOp = "Background4_1",
               Source = "Output",
            }
         },
         ViewInfo = OperatorInfo { Pos = { 1950.15, -197.421 } },
      },
      Merge2 = Merge {
         CtrlWZoom = false,
         Inputs = {
            Background = Input {
               SourceOp = "MatteControl2_4",
               Source = "Output",
            },
            Foreground = Input {
               SourceOp = "ErodeDilate1",
               Source = "Output",
            },
            PerformDepthMerge = Input { Value = 0, }
         },
         ViewInfo = OperatorInfo { Pos = { 1970.93, -110.478 } },
      }
   }
}

Thanks Kruno! Yeah, I see the confusion with my last example. I was trying to reuse the original example I posted with the blue and white backgrounds, but I think that caused some confusion...

Here is a better example to contextualize my vignette process:

Code: Select all

{
   Tools = ordered() {
      ColorCorrector1 = ColorCorrector {
         Inputs = {
            WheelTintLength1 = Input { Value = 1, },
            MasterRGBGain = Input { Value = 0.75, },
            MasterRGBGamma = Input { Value = 0.75, },
            ColorRanges = Input {
               Value = ColorCurves {
                  Curves = {
                     {
                        Points = {
                           { 0, 1 },
                           { 0.4, 0.2 },
                           { 0.6, 0 },
                           { 1, 0 }
                        }
                     },
                     {
                        Points = {
                           { 0, 0 },
                           { 0.4, 0 },
                           { 0.6, 0.2 },
                           { 1, 1 }
                        }
                     }
                  }
               },
            },
            HistogramIgnoreTransparent = Input { Value = 1, },
            Input = Input {
               SourceOp = "blue",
               Source = "Output",
            }
         },
         ViewInfo = OperatorInfo { Pos = { 550, -82.5 } },
      },
      Merge1 = Merge {
         Inputs = {
            EffectMask = Input {
               SourceOp = "Rectangle1",
               Source = "Mask",
            },
            Background = Input {
               SourceOp = "blue",
               Source = "Output",
            },
            Foreground = Input {
               SourceOp = "Grain1",
               Source = "Output",
            },
            PerformDepthMerge = Input { Value = 0, }
         },
         ViewInfo = OperatorInfo { Pos = { 660, -16.5 } },
      },
      Grain1 = Grain {
         Inputs = {
            Power = Input { Value = 10, },
            Red = Input {
               SourceOp = "Grain1Red",
               Source = "Value",
            },
            Green = Input {
               SourceOp = "Grain1Green",
               Source = "Value",
            },
            Blue = Input {
               SourceOp = "Grain1Blue",
               Source = "Value",
            },
            Input = Input {
               SourceOp = "ColorCorrector1",
               Source = "Output",
            }
         },
         ViewInfo = OperatorInfo { Pos = { 660, -82.5 } },
      },
      Grain1Red = LUTBezier {
         KeyColorSplines = {
            [0] = {
               [0] = { 1, RH = { 0.3, 1 }, Flags = { Linear = true } },
               [1] = { 1, LH = { 0.7, 1 }, Flags = { Linear = true } }
            }
         },
         SplineColor = { Red = 0, Green = 0, Blue = 0 },
         NameSet = true,
      },
      Grain1Green = LUTBezier {
         KeyColorSplines = {
            [0] = {
               [0] = { 1, RH = { 0.3, 1 }, Flags = { Linear = true } },
               [1] = { 1, LH = { 0.7, 1 }, Flags = { Linear = true } }
            }
         },
         SplineColor = { Red = 0, Green = 0, Blue = 0 },
         NameSet = true,
      },
      Grain1Blue = LUTBezier {
         KeyColorSplines = {
            [0] = {
               [0] = { 1, RH = { 0.3, 1 }, Flags = { Linear = true } },
               [1] = { 1, LH = { 0.7, 1 }, Flags = { Linear = true } }
            }
         },
         SplineColor = { Red = 0, Green = 0, Blue = 0 },
         CtrlWZoom = false,
         NameSet = true,
      },
      blue = Background {
         NameSet = true,
         Inputs = {
            GlobalOut = Input { Value = 114, },
            Width = Input { Value = 1920, },
            Height = Input { Value = 1080, },
            UseFrameFormatSettings = Input { Value = 1, },
            ["Gamut.SLogVersion"] = Input { Value = FuID { "SLog2" }, },
            TopLeftGreen = Input { Value = 0.333333333333333, },
            TopLeftBlue = Input { Value = 0.498039215686275, }
         },
         ViewInfo = OperatorInfo { Pos = { 385, -16.5 } },
      },
      MediaOut1 = MediaOut {
         CtrlWZoom = false,
         Inputs = {
            Index = Input { Value = "0", },
            Input = Input {
               SourceOp = "Merge1",
               Source = "Output",
            }
         },
         ViewInfo = OperatorInfo { Pos = { 825, -16.5 } },
      },
      Rectangle1 = RectangleMask {
         Inputs = {
            Filter = Input { Value = FuID { "Fast Gaussian" }, },
            SoftEdge = Input { Value = 0.2, },
            Invert = Input { Value = 1, },
            MaskWidth = Input { Value = 1920, },
            MaskHeight = Input { Value = 1080, },
            PixelAspect = Input { Value = { 1, 1 }, },
            UseFrameFormatSettings = Input { Value = 1, },
            ClippingMode = Input { Value = FuID { "None" }, },
            Width = Input { Value = 0.9, },
            Height = Input { Value = 0.9, },
            CornerRadius = Input { Value = 0.5, }
         },
         ViewInfo = OperatorInfo { Pos = { 660, 49.5 } },
      }
   }
}

Generally my process for the vignette is to add effects to the video (in this example I'm color correcting it to red and adding grain) and then merge it back over itself using the mask to create the vignette by putting the effects only on the outer edges. Hopefully this example is more clear.

In my example, if you disconnect the mask completely it will show only the red color with the grain. That is the view I want to be able to toggle on/off. The kind of toggle switch I want to have is between the blue background with the red/grain vignette and only the red color with the grain over the entire screen.

Merge Mask Bug.png (806.52 KiB) Viewed 818 times

While I started using fusion more seriously at version 18, to be honest I don't think I've ever really encounters a problem with the bug you mentioned.

Sure, I understand that not everyone is using Resolve/Fusion in the same way because everyone does different types of projects and has different needs. I'm sure people are encountering problems that will never impact me, but I still say those problems should be fixed. For example, I use very little of the Color page, but if there was an effect in the Color page where bypassing it did the opposite of what the bypass was expected to do, I'd say that's a bug and it should definitely be fixed for those who do use it.

In my example, if you disconnect the mask completely it will show only the red color with the grain. That is the view I want to be able to toggle on/off. The kind of toggle switch I want to have is between the blue background with the red/grain vignette and only the red color with the grain over the entire screen.

My first instinct would be to do this.

sshot-1231.jpg (23.57 KiB) Viewed 743 times

Code: Select all

{
   Tools = ordered() {
      blue_1 = Background {
         NameSet = true,
         Inputs = {
            GlobalOut = Input { Value = 500, },
            Width = Input { Value = 1920, },
            Height = Input { Value = 1080, },
            UseFrameFormatSettings = Input { Value = 1, },
            ["Gamut.SLogVersion"] = Input { Value = FuID { "SLog2" }, },
            TopLeftGreen = Input { Value = 0.333333333333333, },
            TopLeftBlue = Input { Value = 0.498039215686275, }
         },
         ViewInfo = OperatorInfo { Pos = { 758.333, 206.091 } },
      },
      Rectangle1_1 = RectangleMask {
         CtrlWZoom = false,
         Inputs = {
            Filter = Input { Value = FuID { "Fast Gaussian" }, },
            SoftEdge = Input { Value = 0.2, },
            MaskWidth = Input { Value = 1920, },
            MaskHeight = Input { Value = 1080, },
            PixelAspect = Input { Value = { 1, 1 }, },
            UseFrameFormatSettings = Input { Value = 1, },
            ClippingMode = Input { Value = FuID { "None" }, },
            Width = Input { Value = 0.9, },
            Height = Input { Value = 0.9, },
            CornerRadius = Input { Value = 0.5, }
         },
         ViewInfo = OperatorInfo { Pos = { 908.248, 256.663 } },
      },
      ColorCorrector1 = ColorCorrector {
         Inputs = {
            ApplyMaskInverted = Input { Value = 1, },
            WheelTintLength1 = Input { Value = 1, },
            MasterRGBGain = Input { Value = 0.75, },
            MasterRGBGamma = Input { Value = 0.75, },
            ColorRanges = Input {
               Value = ColorCurves {
                  Curves = {
                     {
                        Points = {
                           { 0, 1 },
                           { 0.4, 0.2 },
                           { 0.6, 0 },
                           { 1, 0 }
                        }
                     },
                     {
                        Points = {
                           { 0, 0 },
                           { 0.4, 0 },
                           { 0.6, 0.2 },
                           { 1, 1 }
                        }
                     }
                  }
               },
            },
            HistogramIgnoreTransparent = Input { Value = 1, },
            Input = Input {
               SourceOp = "blue_1",
               Source = "Output",
            },
            EffectMask = Input {
               SourceOp = "Rectangle1_1",
               Source = "Mask",
            }
         },
         ViewInfo = OperatorInfo { Pos = { 908.248, 140.091 } },
      },
      Grain1 = Grain {
         Inputs = {
            Power = Input { Value = 10, },
            Red = Input {
               SourceOp = "Grain1Red",
               Source = "Value",
            },
            Green = Input {
               SourceOp = "Grain1Green",
               Source = "Value",
            },
            Blue = Input {
               SourceOp = "Grain1Blue",
               Source = "Value",
            },
            Input = Input {
               SourceOp = "ColorCorrector1",
               Source = "Output",
            }
         },
         ViewInfo = OperatorInfo { Pos = { 1033.33, 140.091 } },
      },
      Grain1Red = LUTBezier {
         KeyColorSplines = {
            [0] = {
               [0] = { 1, RH = { 0.333333333333333, 1 }, Flags = { Linear = true } },
               [1] = { 1, LH = { 0.666666666666667, 1 }, Flags = { Linear = true } }
            }
         },
         SplineColor = { Red = 0, Green = 0, Blue = 0 },
         CtrlWZoom = false,
      },
      Grain1Green = LUTBezier {
         KeyColorSplines = {
            [0] = {
               [0] = { 1, RH = { 0.333333333333333, 1 }, Flags = { Linear = true } },
               [1] = { 1, LH = { 0.666666666666667, 1 }, Flags = { Linear = true } }
            }
         },
         SplineColor = { Red = 0, Green = 0, Blue = 0 },
         CtrlWZoom = false,
      },
      Grain1Blue = LUTBezier {
         KeyColorSplines = {
            [0] = {
               [0] = { 1, RH = { 0.333333333333333, 1 }, Flags = { Linear = true } },
               [1] = { 1, LH = { 0.666666666666667, 1 }, Flags = { Linear = true } }
            }
         },
         SplineColor = { Red = 0, Green = 0, Blue = 0 },
         CtrlWZoom = false,
      },
      Merge1_1 = Merge {
         Inputs = {
            Background = Input {
               SourceOp = "blue_1",
               Source = "Output",
            },
            Foreground = Input {
               SourceOp = "Grain1",
               Source = "Output",
            },
            PerformDepthMerge = Input { Value = 0, }
         },
         ViewInfo = OperatorInfo { Pos = { 1033.33, 206.091 } },
      }
   }
}

.................................................................

Sure, I understand that not everyone is using Resolve/Fusion in the same way because everyone does different types of projects and has different needs. I'm sure people are encountering problems that will never impact me, but I still say those problems should be fixed. For example, I use very little of the Color page, but if there was an effect in the Color page where bypassing it did the opposite of what the bypass was expected to do, I'd say that's a bug and it should definitely be fixed for those who do use it.

I can't speak of the color bug myself. I'm not sure which one you mean or does it impact me at all. But as a general principle, my approach is that there should be happy compromise. Developers should be more diligent in fixing bugs and not introducing new ones and users should meet them half way somewhere. About 80% of bug complaints on this forum on further examination turned out to be user errors. Or problem of exceptions. Which is probably why I approached your report skeptically.

Resolve and fusion in particular is a complex piece of software. Most of the time things that work the way they do are there for a good reason. And my first instinct is to assume that is the case and than go about figuring out how it actually work. If I fail than I ask others, and if they don't know I ask to replicate the bug and only than I would go about reporting it.

.....................................................................

By the way, It has occurred to me that going back to your original situation. Or node set up, if you really wanted to deactivate the mask in that situation, you could add an in-between connection. Between the mask and merge node so the disconnection doesn't fully happen. The easiest and quickest way if you really wanted or needed that, is to use pipe router. ALT mouse click on the connection line.

Something like this.

sshot-1230.jpg (15.72 KiB) Viewed 743 times

Code: Select all

{
   Tools = ordered() {
      Rectangle1 = RectangleMask {
         CtrlWZoom = false,
         Inputs = {
            Filter = Input { Value = FuID { "Fast Gaussian" }, },
            MaskWidth = Input { Value = 1920, },
            MaskHeight = Input { Value = 1080, },
            PixelAspect = Input { Value = { 1, 1 }, },
            UseFrameFormatSettings = Input { Value = 1, },
            ClippingMode = Input { Value = FuID { "None" }, }
         },
         ViewInfo = OperatorInfo { Pos = { 569.333, -0.515162 } },
      },
      PipeRouter1 = PipeRouter {
         Inputs = {
            Input = Input {
               SourceOp = "Rectangle1",
               Source = "Mask",
            }
         },
         ViewInfo = PipeRouterInfo { Pos = { 569.333, 74.6364 } },
      },
      blue = Background {
         NameSet = true,
         Inputs = {
            GlobalOut = Input { Value = 500, },
            Width = Input { Value = 1920, },
            Height = Input { Value = 1080, },
            UseFrameFormatSettings = Input { Value = 1, },
            ["Gamut.SLogVersion"] = Input { Value = FuID { "SLog2" }, },
            TopLeftGreen = Input { Value = 0.333333333333333, },
            TopLeftBlue = Input { Value = 0.498039215686275, }
         },
         ViewInfo = OperatorInfo { Pos = { 381, 109.121 } },
      },
      white = Background {
         NameSet = true,
         Inputs = {
            GlobalOut = Input { Value = 500, },
            Width = Input { Value = 1920, },
            Height = Input { Value = 1080, },
            UseFrameFormatSettings = Input { Value = 1, },
            ["Gamut.SLogVersion"] = Input { Value = FuID { "SLog2" }, },
            TopLeftRed = Input { Value = 1, },
            TopLeftGreen = Input { Value = 1, },
            TopLeftBlue = Input { Value = 1, }
         },
         ViewInfo = OperatorInfo { Pos = { 381, 76.1212 } },
      },
      Merge1 = Merge {
         Inputs = {
            EffectMask = Input {
               SourceOp = "PipeRouter1",
               Source = "Output",
            },
            Background = Input {
               SourceOp = "blue",
               Source = "Output",
            },
            Foreground = Input {
               SourceOp = "white",
               Source = "Output",
            },
            PerformDepthMerge = Input { Value = 0, }
         },
         ViewInfo = OperatorInfo { Pos = { 548.667, 109.121 } },
      }
   }
}

.................................

Personally I think adding such effects as vignette downstream of the main background elements makes it easy to add as much complexity as you like and leave it easy to toggle on or off, with no complicated extra steps, once its set up.

Thanks again Kruno.

My first instinct would be to do this.

The first example only masks the first red color correction effect, but the grain effect is still over the entire video. The mask would need to be connected to every single effect in the chain instead of only once at the merge node. So again, I come back to my earlier statement that at a practical level, the merge bypass option should be fixed. No matter how many effects you add, you only need one mask connection at the merge instead of on every single effect. This solution doesn't scale.

I can't speak of the color bug myself. I'm not sure which one you mean or does it impact me at all.

That color bug was a hypothetical example. In other words, IF there was an effect on the color page that didn't bypass correctly, I would still agree that is a problem that should be fixed even if I never noticed it, or it didn't impact me, or if there are other hacky workarounds to kind of make it work, etc. Something as fundamental as "bypass" should always work as you expect it to. The merge bypass in Fusion is the only instance I'm aware of where "bypass" is broken.

About 80% of bug complaints on this forum on further examination turned out to be user errors. Or problem of exceptions. Which is probably why I approached your report skeptically.

Sure I understand that, however I present my case as to why the merge bypass was not working correctly including examples that clearly demonstrated the problem.

In every single situation bypassing a node should do exactly the same thing as disconnecting the node or deleting it. This goes for everything, audio effects, color page nodes, fusion nodes, edit page effects, etc. it doesn't matter what it is.
Bypass = Disconnect = Delete = It's not in the system
Period. No exceptions.

If bypass does something different, then that is definitively a bug and it should be fixed.

By the way, It has occurred to me that going back to your original situation. Or node set up, if you really wanted to deactivate the mask in that situation, you could add an in-between connection. Between the mask and merge node so the disconnection doesn't fully happen. The easiest and quickest way if you really wanted or needed that, is to use pipe router. ALT mouse click on the connection line.

The pipe router node still doesn't allow me to bypass the mask to show the effects on the full screen. Toggling on/off the mask and the piperouter node produces the same wrong result (shows only the background) as before when bypassing the mask.

Personally I think adding such effects as vignette downstream of the main background elements makes it easy to add as much complexity as you like and leave it easy to toggle on or off, with no complicated extra steps, once its set up.

What need is a way to toggle the mask off so I can put the effects over the full screen. All of the examples you posted have the same problem that I'm dealing with. There is no way to toggle the mask off to see the effects full screen.

This is exactly the dilemma I've been talking about and why the merge bypass should be fixed. Simply bypassing a mask should not be this frustrating or tedious. Bypassing the mask was so simple before.

The "simple " fix is to add a MatteControl set to Combine - Solid.
Then (somewhat counterintuitively) Turning the MatteControl Off displays the vignette and turning it On , displays the full FG...

Code: Select all

{
   Tools = ordered() {
      ColorCorrector1_1_1 = ColorCorrector {
         Inputs = {
            WheelTintLength1 = Input { Value = 1, },
            MasterRGBGain = Input { Value = 0.75, },
            MasterRGBGamma = Input { Value = 0.75, },
            ColorRanges = Input {
               Value = ColorCurves {
                  Curves = {
                     {
                        Points = {
                           { 0, 1 },
                           { 0.4, 0.2 },
                           { 0.6, 0 },
                           { 1, 0 }
                        }
                     },
                     {
                        Points = {
                           { 0, 0 },
                           { 0.4, 0 },
                           { 0.6, 0.2 },
                           { 1, 1 }
                        }
                     }
                  }
               },
            },
            HistogramIgnoreTransparent = Input { Value = 1, },
            Input = Input {
               SourceOp = "blue_2_1_1",
               Source = "Output",
            }
         },
         ViewInfo = OperatorInfo { Pos = { 4675, 676.5 } },
      },
      blue_2_1_1 = Background {
         NameSet = true,
         Inputs = {
            Width = Input { Value = 4608, },
            Height = Input { Value = 3164, },
            UseFrameFormatSettings = Input { Value = 1, },
            ["Gamut.SLogVersion"] = Input { Value = FuID { "SLog2" }, },
            TopLeftGreen = Input { Value = 0.333333333333333, },
            TopLeftBlue = Input { Value = 0.498039215686275, }
         },
         ViewInfo = OperatorInfo { Pos = { 4620, 742.5 } },
      },
      Grain1_1_1 = Grain {
         Inputs = {
            Power = Input { Value = 10, },
            Red = Input {
               SourceOp = "Grain1Red_1_1",
               Source = "Value",
            },
            Green = Input {
               SourceOp = "Grain1Green_1_1",
               Source = "Value",
            },
            Blue = Input {
               SourceOp = "Grain1Blue_1_1",
               Source = "Value",
            },
            Input = Input {
               SourceOp = "ColorCorrector1_1_1",
               Source = "Output",
            }
         },
         ViewInfo = OperatorInfo { Pos = { 4785, 676.5 } },
      },
      Grain1Red_1_1 = LUTBezier {
         KeyColorSplines = {
            [0] = {
               [0] = { 1, RH = { 0.333333333333333, 1 }, Flags = { Linear = true } },
               [1] = { 1, LH = { 0.666666666666667, 1 }, Flags = { Linear = true } }
            }
         },
         SplineColor = { Red = 0, Green = 0, Blue = 0 },
         CtrlWZoom = false,
      },
      Grain1Green_1_1 = LUTBezier {
         KeyColorSplines = {
            [0] = {
               [0] = { 1, RH = { 0.333333333333333, 1 }, Flags = { Linear = true } },
               [1] = { 1, LH = { 0.666666666666667, 1 }, Flags = { Linear = true } }
            }
         },
         SplineColor = { Red = 0, Green = 0, Blue = 0 },
         CtrlWZoom = false,
      },
      Grain1Blue_1_1 = LUTBezier {
         KeyColorSplines = {
            [0] = {
               [0] = { 1, RH = { 0.333333333333333, 1 }, Flags = { Linear = true } },
               [1] = { 1, LH = { 0.666666666666667, 1 }, Flags = { Linear = true } }
            }
         },
         SplineColor = { Red = 0, Green = 0, Blue = 0 },
         CtrlWZoom = false,
      },
      MatteControl4 = MatteControl {
         CtrlWZoom = false,
         Inputs = {
            MatteCombine = Input { Value = 5, },
            Filter = Input { Value = FuID { "Fast Gaussian" }, },
            Background = Input {
               SourceOp = "Rectangle1_3_1_1",
               Source = "Mask",
            }
         },
         ViewInfo = OperatorInfo { Pos = { 4785, 808.5 } },
      },
      Merge1_11_1_1 = Merge {
         Inputs = {
            EffectMask = Input {
               SourceOp = "MatteControl4",
               Source = "Output",
            },
            Background = Input {
               SourceOp = "blue_2_1_1",
               Source = "Output",
            },
            Foreground = Input {
               SourceOp = "Grain1_1_1",
               Source = "Output",
            },
            PerformDepthMerge = Input { Value = 0, }
         },
         ViewInfo = OperatorInfo { Pos = { 4785, 742.5 } },
      },
      Rectangle1_3_1_1 = RectangleMask {
         Inputs = {
            Filter = Input { Value = FuID { "Fast Gaussian" }, },
            SoftEdge = Input { Value = 0.2, },
            Invert = Input { Value = 1, },
            MaskWidth = Input { Value = 4608, },
            MaskHeight = Input { Value = 3164, },
            PixelAspect = Input { Value = { 1, 1 }, },
            UseFrameFormatSettings = Input { Value = 1, },
            ClippingMode = Input { Value = FuID { "None" }, },
            Width = Input { Value = 0.9, },
            Height = Input { Value = 0.9, },
            CornerRadius = Input { Value = 0.5, }
         },
         ViewInfo = OperatorInfo { Pos = { 4785, 874.5 } },
      },
      MediaOut1_1_1 = MediaOut {
         Inputs = {
            Index = Input { Value = "0" },
            Input = Input {
               SourceOp = "Merge1",
               Source = "Output"
            }
         },
         ViewInfo = OperatorInfo { Pos = { 4950, 742.5 } },
         CtrlWZoom = false,
      }
   },
   ActiveTool = "MatteControl4"
}

The "simple " fix is to add a MatteControl set to Combine - Solid.
Then (somewhat counterintuitively) Turning the MatteControl Off displays the vignette and turning it On , displays the full FG...

Thanks George. Yes, that one provides the type of toggle switch that I want.

One thought I had was to put a rectangle mask as the last mask which is full screen so that toggling it "on" would go full screen effect... but that doesn't work if my mask is more complicated and I have already used a MatteControl. The MatteControl will not run into a general mask, so I'd have to use another MatteControl to be able to combine them again and then toggle on/off the last MatteControl.

While this method is better than disconnecting/reconnecting the mask for toggling, it's certainly not ideal. I hope this bug will be fixed soon so bypassing the mask on a merge node will simply bypass the mask.

Also, one more thing I tested is setting the size of the mask to 0 and this does work correctly.
Delete mask = works correctly
Disconnect mask = works correctly
Set mask size to 0 = works correctly
Bypass mask = does not work correctly

All of these should produce identical results. There is something wrong on the mask input of the merge node that only inverts the result input when the mask is bypassed. Every other example works correctly.

I tested Beta 3 and this bug still has not been fixed.

From the info I provided before, the problem appears to be with the Mask Input on the Merge Node. Bypassing the mask works correctly everywhere else, but not with the Mask Input of the Merge Node. This is where it gets flipped.

Can Blackmagic please go back to the code from v18 and copy-paste it back into v20? Or look at the two for a comparison in case some other stuff has changed too? It shouldn't be too difficult to compare them, figure out what went wrong and fix it.

I tested Beta 4 and this bug has still not been fixed.