Independent sizing of elements?

SOoooo...having fun with Fusion, but run into an issue when elements are controlled by whatever BG size is in merging elements. I grasp the concept, but then how does one work with needing several merges to have several elements, some of which in the middle of that sandwich are temporarily the "background" and I want to scale and reposition them without affecting my scene. Or maybe I am attacking this completely wrong.

I have a near foreground, creature, main bg, mountain behind that, moving sky behind that.

Screen grab attached.

Thanks,
Rick

I think you'd help yourself if you better organized your Flow. Choose a direction, and assemble your comp in that direction, from background to foreground. Each element goes on top of the combined elements below it. What you've got going on, if I'm tracing your Flow correctly, is several items Merged together, then that sub-composite all Merged onto the sky background. So your canvas size is changing constantly, making it difficult for you to position your elements.

Here's an annotated sample tree. There's nothing in the Loaders, and most of the nodes are in their default state. It's just to show a good way to organize your tree so it's easier to manage.

Code: Select all

{
   Tools = ordered() {
      BGMountain = Loader {
         Clips = {
         },
         NameSet = true,
         Inputs = {
            ["Gamut.SLogVersion"] = Input { Value = FuID { "SLog2" }, },
         },
         ViewInfo = OperatorInfo { Pos = { 275, -610.5 } },
      },
      LumaKeyer1 = LumaKeyer {
         Inputs = {
            Input = Input {
               SourceOp = "ChangeDepth1",
               Source = "Output",
            },
         },
         ViewInfo = OperatorInfo { Pos = { 275, -445.5 } },
      },
      ChangeDepth1 = ChangeDepth {
         Inputs = {
            Depth = Input { Value = 3, },
            Input = Input {
               SourceOp = "BGMountain",
               Source = "Output",
            },
         },
         ViewInfo = OperatorInfo { Pos = { 275, -544.5 } },
      },
      Note4 = Note {
         Inputs = {
            Comments = Input { Value = "Keys should usually happen before color correction, as you have done in your screenshot, in order to preserve as much detail as possibel from the original image. When working in float, it doesn't matter so much, but I can see that your comp is in 8-bit, so you'll lose data with each color correct.", }
         },
         ViewInfo = StickyNoteInfo {
            Pos = { 55, -478.5 },
            Flags = {
               Expanded = true
            },
            Size = { 339, 115.3 }
         },
      },
      Note5 = Note {
         Inputs = {
            Comments = Input { Value = "Working in floating point space gives you much greater flexibility in all areas of your composite.", }
         },
         ViewInfo = StickyNoteInfo {
            Pos = { 239, -577.5 },
            Flags = {
               Expanded = true
            },
            Size = { 852, 76.3 }
         },
      },
      ChangeDepth1_1 = ChangeDepth {
         Inputs = {
            Depth = Input { Value = 3, },
            Input = Input {
               SourceOp = "Midground",
               Source = "Output",
            },
         },
         ViewInfo = OperatorInfo { Pos = { 495, -544.5 } },
      },
      Midground = Loader {
         Clips = {
         },
         NameSet = true,
         Inputs = {
            ["Gamut.SLogVersion"] = Input { Value = FuID { "SLog2" }, },
         },
         ViewInfo = OperatorInfo { Pos = { 495, -610.5 } },
      },
      Note6 = Note {
         Inputs = {
            Comments = Input { Value = "Most operations in a composite will work best in linear color. The Luma Keyer is an exception. The Ranges tab in the Color Corrector also works best in sRGB, but if you're not using that feature, it's better to correct in lin.\n\nTo view the image properly, though, you 'll need to turn on the LUT button in your Viewers. Set it to Gamut View LUT, then use edit... to set it up with No Change in the Source Space and sRGB in the Output Space.", }
         },
         ViewInfo = StickyNoteInfo {
            Pos = { 220, -313.5 },
            Flags = {
               Expanded = true
            },
            Size = { 897, 133.3 }
         },
      },
      Gamut1_1 = GamutConvert {
         CustomData = {
            Settings = {
               [1] = {
                  Tools = ordered() {
                     Gamut1_1 = GamutConvert {
                        CtrlWZoom = false,
                        CustomData = {
                        },
                        Inputs = {
                           OutputSpace = Input { Value = FuID { "sRGB" }, },
                           Input = Input {
                              SourceOp = "LumaKeyer1",
                              Source = "Output",
                           },
                        },
                        ViewInfo = OperatorInfo { Pos = { 275, -247.5 } },
                        Name = "Gamut1_1"
                     }
                  }
               },
               [2] = {
                  Tools = ordered() {
                     Gamut1_1 = GamutConvert {
                        CtrlWZoom = false,
                        CustomData = {
                        },
                        Inputs = {
                           OutputSpace = Input { Value = FuID { "sRGB" }, },
                           Input = Input {
                              SourceOp = "LumaKeyer1",
                              Source = "Output",
                           },
                        },
                        ViewInfo = OperatorInfo { Pos = { 275, -247.5 } },
                     }
                  }
               },
            }
         },
         Inputs = {
            SourceSpace = Input { Value = FuID { "sRGB" }, },
            Input = Input {
               SourceOp = "LumaKeyer1",
               Source = "Output",
            },
         },
         ViewInfo = OperatorInfo { Pos = { 275, -247.5 } },
      },
      Gamut1_1_1 = GamutConvert {
         CustomData = {
            Settings = {
               [1] = {
                  Tools = ordered() {
                     Gamut1_1 = GamutConvert {
                        CtrlWZoom = false,
                        CustomData = {
                        },
                        Inputs = {
                           OutputSpace = Input { Value = FuID { "sRGB" }, },
                           Input = Input {
                              SourceOp = "LumaKeyer1",
                              Source = "Output",
                           },
                        },
                        ViewInfo = OperatorInfo { Pos = { 275, -247.5 } },
                        Name = "Gamut1_1"
                     }
                  }
               },
               [2] = {
                  Tools = ordered() {
                     Gamut1_1 = GamutConvert {
                        CtrlWZoom = false,
                        CustomData = {
                        },
                        Inputs = {
                           OutputSpace = Input { Value = FuID { "sRGB" }, },
                           Input = Input {
                              SourceOp = "LumaKeyer1",
                              Source = "Output",
                           },
                        },
                        ViewInfo = OperatorInfo { Pos = { 275, -247.5 } },
                     }
                  }
               },
            }
         },
         Inputs = {
            SourceSpace = Input { Value = FuID { "sRGB" }, },
            Input = Input {
               SourceOp = "ChangeDepth1_1",
               Source = "Output",
            },
         },
         ViewInfo = OperatorInfo { Pos = { 495, -247.5 } },
      },
      Gamut1_1_2 = GamutConvert {
         CustomData = {
            Settings = {
               [1] = {
                  Tools = ordered() {
                     Gamut1_1 = GamutConvert {
                        CtrlWZoom = false,
                        CustomData = {
                        },
                        Inputs = {
                           OutputSpace = Input { Value = FuID { "sRGB" }, },
                           Input = Input {
                              SourceOp = "LumaKeyer1",
                              Source = "Output",
                           },
                        },
                        ViewInfo = OperatorInfo { Pos = { 275, -247.5 } },
                        Name = "Gamut1_1"
                     }
                  }
               },
               [2] = {
                  Tools = ordered() {
                     Gamut1_1 = GamutConvert {
                        CtrlWZoom = false,
                        CustomData = {
                        },
                        Inputs = {
                           OutputSpace = Input { Value = FuID { "sRGB" }, },
                           Input = Input {
                              SourceOp = "LumaKeyer1",
                              Source = "Output",
                           },
                        },
                        ViewInfo = OperatorInfo { Pos = { 275, -247.5 } },
                     }
                  }
               },
            }
         },
         Inputs = {
            SourceSpace = Input { Value = FuID { "sRGB" }, },
            Input = Input {
               SourceOp = "ChangeDepth1_2",
               Source = "Output",
            },
         },
         ViewInfo = OperatorInfo { Pos = { 770, -247.5 } },
      },
      ChangeDepth1_2 = ChangeDepth {
         Inputs = {
            Depth = Input { Value = 3, },
            Input = Input {
               SourceOp = "Rock",
               Source = "Output",
            },
         },
         ViewInfo = OperatorInfo { Pos = { 770, -544.5 } },
      },
      Rock = Loader {
         Clips = {
         },
         NameSet = true,
         Inputs = {
            ["Gamut.SLogVersion"] = Input { Value = FuID { "SLog2" }, },
         },
         ViewInfo = OperatorInfo { Pos = { 770, -610.5 } },
      },
      Gamut1_1_3 = GamutConvert {
         CustomData = {
            Settings = {
               [1] = {
                  Tools = ordered() {
                     Gamut1_1 = GamutConvert {
                        CtrlWZoom = false,
                        CustomData = {
                        },
                        Inputs = {
                           OutputSpace = Input { Value = FuID { "sRGB" }, },
                           Input = Input {
                              SourceOp = "LumaKeyer1",
                              Source = "Output",
                           },
                        },
                        ViewInfo = OperatorInfo { Pos = { 275, -247.5 } },
                        Name = "Gamut1_1"
                     }
                  }
               },
               [2] = {
                  Tools = ordered() {
                     Gamut1_1 = GamutConvert {
                        CtrlWZoom = false,
                        CustomData = {
                        },
                        Inputs = {
                           OutputSpace = Input { Value = FuID { "sRGB" }, },
                           Input = Input {
                              SourceOp = "LumaKeyer1",
                              Source = "Output",
                           },
                        },
                        ViewInfo = OperatorInfo { Pos = { 275, -247.5 } },
                     }
                  }
               },
            }
         },
         Inputs = {
            SourceSpace = Input { Value = FuID { "sRGB" }, },
            Input = Input {
               SourceOp = "ChangeDepth1_3",
               Source = "Output",
            },
         },
         ViewInfo = OperatorInfo { Pos = { 990, -247.5 } },
      },
      ChangeDepth1_3 = ChangeDepth {
         Inputs = {
            Depth = Input { Value = 3, },
            Input = Input {
               SourceOp = "FG_dirt",
               Source = "Output",
            },
         },
         ViewInfo = OperatorInfo { Pos = { 990, -544.5 } },
      },
      FG_dirt = Loader {
         Clips = {
         },
         NameSet = true,
         Inputs = {
            ["Gamut.SLogVersion"] = Input { Value = FuID { "SLog2" }, },
         },
         ViewInfo = OperatorInfo { Pos = { 990, -610.5 } },
      },
      ColorCorrector2 = ColorCorrector {
         Inputs = {
            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 = "Gamut1_1_1",
               Source = "Output",
            },
         },
         ViewInfo = OperatorInfo { Pos = { 495, -82.5 } },
      },
      ColorCorrector3 = ColorCorrector {
         Inputs = {
            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 = "Gamut1_1_2",
               Source = "Output",
            },
         },
         ViewInfo = OperatorInfo { Pos = { 770, -82.5 } },
      },
      ColorCorrector4 = ColorCorrector {
         Inputs = {
            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 = "Gamut1_1_3",
               Source = "Output",
            },
         },
         ViewInfo = OperatorInfo { Pos = { 990, -82.5 } },
      },
      ColorCorrector1 = ColorCorrector {
         Inputs = {
            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 = "Gamut1_1",
               Source = "Output",
            },
         },
         ViewInfo = OperatorInfo { Pos = { 275, -82.5 } },
      },
      Blur1 = Blur {
         Inputs = {
            Input = Input {
               SourceOp = "ColorCorrector1",
               Source = "Output",
            },
         },
         ViewInfo = OperatorInfo { Pos = { 275, -49.5 } },
      },
      Note2 = Note {
         Inputs = {
            Comments = Input { Value = "Transforms operate in the coordinate space of their own inputs, but as long as there are no nodes that restrict the Domain of Definition, you can recover the pixels from outside their own frame if you Merge onto a background that is larger.", }
         },
         ViewInfo = StickyNoteInfo {
            Pos = { 233, 16.5 },
            Flags = {
               Expanded = true
            },
            Size = { 924, 113.3 }
         },
      },
      Note7 = Note {
         Inputs = {
            Comments = Input { Value = "Back to sRGB before rendering.", }
         },
         ViewInfo = StickyNoteInfo {
            Pos = { 1265, 49.5 },
            Flags = {
               Expanded = true
            },
            Size = { 196, 179.3 }
         },
      },
      Transform3 = Transform {
         Inputs = {
            Input = Input {
               SourceOp = "ColorCorrector3",
               Source = "Output",
            },
         },
         ViewInfo = OperatorInfo { Pos = { 770, 82.5 } },
      },
      Transform2 = Transform {
         Inputs = {
            Input = Input {
               SourceOp = "ColorCorrector2",
               Source = "Output",
            },
         },
         ViewInfo = OperatorInfo { Pos = { 495, 82.5 } },
      },
      Transform1 = Transform {
         Inputs = {
            Input = Input {
               SourceOp = "Blur1",
               Source = "Output",
            },
         },
         ViewInfo = OperatorInfo { Pos = { 275, 82.5 } },
      },
      Transform4 = Transform {
         Inputs = {
            Input = Input {
               SourceOp = "ColorCorrector4",
               Source = "Output",
            },
         },
         ViewInfo = OperatorInfo { Pos = { 990, 82.5 } },
      },
      Merge4 = Merge {
         CtrlWZoom = false,
         Inputs = {
            Background = Input {
               SourceOp = "Merge3",
               Source = "Output",
            },
            Foreground = Input {
               SourceOp = "Transform4",
               Source = "Output",
            },
            PerformDepthMerge = Input { Value = 0, },
         },
         ViewInfo = OperatorInfo { Pos = { 990, 148.5 } },
      },
      Gamut1 = GamutConvert {
         Inputs = {
            OutputSpace = Input { Value = FuID { "sRGB" }, },
            Input = Input {
               SourceOp = "Merge4",
               Source = "Output",
            },
         },
         ViewInfo = OperatorInfo { Pos = { 1320, 148.5 } },
      },
      Gamut1_1_4 = GamutConvert {
         CustomData = {
            Settings = {
               [1] = {
                  Tools = ordered() {
                     Gamut1_1 = GamutConvert {
                        CtrlWZoom = false,
                        CustomData = {
                        },
                        Inputs = {
                           OutputSpace = Input { Value = FuID { "sRGB" }, },
                           Input = Input {
                              SourceOp = "LumaKeyer1",
                              Source = "Output",
                           },
                        },
                        ViewInfo = OperatorInfo { Pos = { 275, -247.5 } },
                        Name = "Gamut1_1"
                     }
                  }
               },
               [2] = {
                  Tools = ordered() {
                     Gamut1_1 = GamutConvert {
                        CtrlWZoom = false,
                        CustomData = {
                        },
                        Inputs = {
                           OutputSpace = Input { Value = FuID { "sRGB" }, },
                           Input = Input {
                              SourceOp = "LumaKeyer1",
                              Source = "Output",
                           },
                        },
                        ViewInfo = OperatorInfo { Pos = { 275, -247.5 } },
                     }
                  }
               },
            }
         },
         Inputs = {
            SourceSpace = Input { Value = FuID { "sRGB" }, },
            Input = Input {
               SourceOp = "ChangeDepth2",
               Source = "Output",
            },
         },
         ViewInfo = OperatorInfo { Pos = { 110, 148.5 } },
      },
      ChangeDepth2 = ChangeDepth {
         Inputs = {
            Input = Input {
               SourceOp = "TimeStretcher1",
               Source = "Output",
            },
         },
         ViewInfo = OperatorInfo { Pos = { 0, 148.5 } },
      },
      Merge1 = Merge {
         Inputs = {
            Background = Input {
               SourceOp = "Gamut1_1_4",
               Source = "Output",
            },
            Foreground = Input {
               SourceOp = "Transform1",
               Source = "Output",
            },
            PerformDepthMerge = Input { Value = 0, },
         },
         ViewInfo = OperatorInfo { Pos = { 275, 148.5 } },
      },
      TimeStretcher1 = TimeStretcher {
         Inputs = {
            SourceTime = Input {
               SourceOp = "TimeStretcher1SourceTime",
               Source = "Value",
            },
            Input = Input {
               SourceOp = "Sky",
               Source = "Output",
            },
         },
         ViewInfo = OperatorInfo { Pos = { -110, 148.5 } },
      },
      TimeStretcher1SourceTime = BezierSpline {
         SplineColor = { Red = 233, Green = 217, Blue = 243 },
         NameSet = true,
         KeyFrames = {
            [0] = { 0, Flags = { Linear = true } }
         }
      },
      Sky = Loader {
         Clips = {
         },
         NameSet = true,
         Inputs = {
            ["Gamut.SLogVersion"] = Input { Value = FuID { "SLog2" }, },
         },
         ViewInfo = OperatorInfo { Pos = { -220, 148.5 } },
      },
      Merge3 = Merge {
         Inputs = {
            Background = Input {
               SourceOp = "Merge2",
               Source = "Output",
            },
            Foreground = Input {
               SourceOp = "Transform3",
               Source = "Output",
            },
            PerformDepthMerge = Input { Value = 0, },
         },
         ViewInfo = OperatorInfo { Pos = { 770, 148.5 } },
      },
      Merge2 = Merge {
         Inputs = {
            Background = Input {
               SourceOp = "Merge1",
               Source = "Output",
            },
            Foreground = Input {
               SourceOp = "Transform2",
               Source = "Output",
            },
            PerformDepthMerge = Input { Value = 0, },
         },
         ViewInfo = OperatorInfo { Pos = { 495, 148.5 } },
      },
      Note3 = Note {
         Inputs = {
            Comments = Input { Value = "Transform operations, including those in the Merges, concatenate, which means that the aggregate Transform from several nodes is calculated before being applied so that filtering is only applied once. This preserves detail.  Try not to do any color operations, blurs, or the like between Transforms, and it's best to put the Xf right above the Merge unless there's a reason not to.", }
         },
         ViewInfo = StickyNoteInfo {
            Pos = { 275, 181.5 },
            Flags = {
               Expanded = true
            },
            Size = { 452, 179.3 }
         },
      },
      Note1 = Note {
         Inputs = {
            Comments = Input { Value = "Canvas dimensions are established here, and this format goes down through each Background input. ", }
         },
         ViewInfo = StickyNoteInfo {
            Pos = { -249, 181.5 },
            Flags = {
               Expanded = true
            },
            Size = { 141, 179.3 }
         },
      },
      Saver1 = Saver {
         Inputs = {
            ProcessWhenBlendIs00 = Input { Value = 0, },
            Clip = Input {
               Value = Clip {
                  Length = 0,
                  Saving = true,
                  TrimIn = 0,
                  ExtendFirst = 0,
                  ExtendLast = 0,
                  Loop = 1,
                  AspectMode = 0,
                  Depth = 0,
                  GlobalStart = -2000000000,
                  GlobalEnd = 0
               },
            },
            OutputFormat = Input { Value = FuID { "TargaFormat" }, },
            ["Gamut.SLogVersion"] = Input { Value = FuID { "SLog2" }, },
            Input = Input {
               SourceOp = "Gamut1",
               Source = "Output",
            },
         },
         ViewInfo = OperatorInfo { Pos = { 1595, 148.5 } },
      }
   }
}


Most Fusion users build from left to right. Nuke users tend to go top down.

Thanks, Bryan....I will load that up when I get started today. I actually have ALL elements converted to the same size. I guess it hadn't occurred to me that I needed to start my flow from back to front elements since it was node based. But it seems like sizing an element early in the chain when it was a foreground element affects everything in that merge as it later becomes used as a bg element. So, hopefully the sample scene will help me here.

Or should I be putting all these onto image planes and make a 3d setup, like a multiplane camera? I would guess anything I would do to each plane would then be independent since the comping/merging is happening via the camera.

Thanks very much for your help,
Rick

In Fusion there is no need to resize your elements beforehand, you can do all of this in the flow of things if you need to. You can use transforms and/or merges for this.
There is no need to start your flow back to front, but it helps you if you arrange things in a way that is logical to you. Try to think of it as a road map: you start here, then you go here, then these two roads come together (merge) and then they go there. If you need to add something in between, just insert a merge in a logical place and put your stuff in there.

Or should I be putting all these onto image planes and make a 3d setup, like a multiplane camera? I would guess anything I would do to each plane would then be independent since the comping/merging is happening via the camera.

I'd start by getting a solid grasp of the 2d side before diving into a 3d setup. This is certainly a good scene to experiment with when it comes to that, though. With some displacement mapping on your cards, you could get a nice-looking camera move with a small perspective shift.

When you're ready to take that step, look for the Mountain Scene example comp in Reactor. It just went in there this week, so that's good timing.

As Sander said, it's not actually necessary to comp back-to-front as I suggested, but I like to do it that way because it helps me stay better organized and read my composite later. Your mileage may vary.

Bryan,

So, as I am back at that scene, there must be something elemental I am not understanding. And it always turns out to be something that makes one feel really stupid, lol.

Anyway after looking through the scene format you generously put together for me, I still find that if I setup up even the minimal first merge as you have, any transform I make on the first foreground object reduces the object but also the matte area leaving me with a black surround/framing inside my main/first background image. Shouldn't anything "beyond" be matted?

Thanks again for your patience and help.

Best,
Rick

Did you do a Luma key and then invert it? That will also invert the canvas alpha outside the frame. A quick way to prevent that from happening is to feed the same image to both the Input and the Effect Mask on the Luma Key. That way, the invert will only happen inside the frame, leaving the rest of the canvas alone.

Bryan,

Thanks..that was it!

I also have been setting it up as a 3d scene.....took a bit of figuring out since it is "different" than doing normal 3D setups in a 3D program. I do have a question about the camera. How does one set the output dimensions? I first thought it might be determined by the farthest (BG) plane, similar to 2d comping but that doesn't seem to be true.

Here's a shot of my attempt at a 3D layout as well....

Thanks again,
Rick

the render3d node sets the output image size. by default it will use the format settings of your composition

you can also use a "set canvas color" node to "reset" the color outside of the key.

Thanks, Michael!