Blackmagic Forum

If you feed an animated input into an uImage Plane, it does not refresh the image each frame. You can refresh it by selecting "Rerender Current Frame" from the lower right or running fu:PurgeCache() on the uRenderer: Frame Render Script.

Code: Select all

{
   Tools = ordered() {
      uRenderer1 = uRenderer {
         Inputs = {
            GlobalOut = Input { Value = 119, },
            Width = Input { Value = 1920, },
            Height = Input { Value = 1080, },
            UseFrameFormatSettings = Input { Value = 1, },
            ["Gamut.SLogVersion"] = Input { Value = FuID { "SLog2" }, },
            SceneInput = Input {
               SourceOp = "uMerge1",
               Source = "Output",
            }
         },
         ViewInfo = OperatorInfo { Pos = { 330, 412.5 } },
      },
      uMerge1 = uMerge {
         Inputs = {
            SceneInput1 = Input {
               SourceOp = "uImagePlane1",
               Source = "Output",
            },
            SceneInput2 = Input {
               SourceOp = "uCamera1",
               Source = "Output",
            }
         },
         ViewInfo = OperatorInfo { Pos = { 330, 313.5 } },
      },
      uCamera1 = uCamera {
         Inputs = {
            ["USDXf.Translate.Z"] = Input { Value = 5.87037223031417, }
         },
         ViewInfo = OperatorInfo { Pos = { 165, 313.5 } },
      },
      uImagePlane1 = uImagePlane {
         Inputs = {
            Image = Input {
               SourceOp = "Merge1",
               Source = "Output",
            }
         },
         ViewInfo = OperatorInfo { Pos = { 330, 181.5 } },
      },
      Merge1 = Merge {
         Inputs = {
            Background = Input {
               SourceOp = "CustomTool1",
               Source = "Output",
            },
            Foreground = Input {
               SourceOp = "Text1",
               Source = "Output",
            },
            PerformDepthMerge = Input { Value = 0, }
         },
         ViewInfo = OperatorInfo { Pos = { 330, 82.5 } },
      },
      Checkerboard = MacroOperator {
         CustomData = {
            Path = {
               Map = {
                  ["Setting:"] = "Macros:/Creator/"
               }
            },
         },
         Inputs = ordered() {
            Comments = Input { Value = "Muse Tools Library\r\nby Joe Laude\r\nwww.musevfx.com", },
            Center = InstanceInput {
               SourceOp = "CustomTool1",
               Source = "PointIn1",
            },
            CheckerSize = InstanceInput {
               SourceOp = "CustomTool1",
               Source = "CheckerSize",
               Default = 64,
            },
            Width = InstanceInput {
               SourceOp = "Background1",
               Source = "Width",
               Default = 1920,
            },
            Height = InstanceInput {
               SourceOp = "Background1",
               Source = "Height",
               Default = 1080,
            }
         },
         Outputs = {
            Output = InstanceOutput {
               SourceOp = "CustomTool1",
               Source = "Output",
            }
         },
         ViewInfo = GroupInfo { Pos = { 165, 82.5 } },
         Tools = ordered() {
            Background1 = Background {
               CtrlWZoom = false,
               CtrlWShown = false,
               Inputs = {
                  GlobalOut = Input { Value = 119, },
                  Width = Input { Value = 1920, },
                  Height = Input { Value = 1080, },
                  ["Gamut.SLogVersion"] = Input { Value = FuID { "SLog2" }, }
               },
               ViewInfo = OperatorInfo { Pos = { 0, 8.25757 } },
            },
            CustomTool1 = Custom {
               CtrlWZoom = false,
               CtrlWShown = false,
               Inputs = {
                  NumberIn1 = Input {
                     Value = 64,
                     Expression = "CheckerSize",
                  },
                  LUTIn1 = Input {
                     SourceOp = "CustomTool1LUTIn1",
                     Source = "Value",
                  },
                  LUTIn2 = Input {
                     SourceOp = "CustomTool1LUTIn2",
                     Source = "Value",
                  },
                  LUTIn3 = Input {
                     SourceOp = "CustomTool1LUTIn3",
                     Source = "Value",
                  },
                  LUTIn4 = Input {
                     SourceOp = "CustomTool1LUTIn4",
                     Source = "Value",
                  },
                  Intermediate1 = Input { Value = "(abs(floor((x-p1x)*(w/n1)))%2)", },
                  Intermediate2 = Input { Value = "(abs(floor((y-p1y)*(h/n1)))%2)", },
                  RedExpression = Input { Value = "abs(i1-i2)", },
                  GreenExpression = Input { Value = "abs(i1-i2)", },
                  BlueExpression = Input { Value = "abs(i1-i2)", },
                  NumberControls = Input { Value = 1, },
                  NameforNumber1 = Input { Value = "SquareSize", },
                  ShowNumber2 = Input { Value = 0, },
                  ShowNumber3 = Input { Value = 0, },
                  ShowNumber4 = Input { Value = 0, },
                  ShowNumber5 = Input { Value = 0, },
                  ShowNumber6 = Input { Value = 0, },
                  ShowNumber7 = Input { Value = 0, },
                  ShowNumber8 = Input { Value = 0, },
                  PointControls = Input { Value = 1, },
                  NameforPoint1 = Input { Value = "Center", },
                  ShowPoint2 = Input { Value = 0, },
                  ShowPoint3 = Input { Value = 0, },
                  ShowPoint4 = Input { Value = 0, },
                  ShowLUT1 = Input { Value = 0, },
                  ShowLUT2 = Input { Value = 0, },
                  ShowLUT3 = Input { Value = 0, },
                  ShowLUT4 = Input { Value = 0, },
                  Image1 = Input {
                     SourceOp = "Background1",
                     Source = "Output",
                  }
               },
               ViewInfo = OperatorInfo { Pos = { 0, 41.2576 } },
               UserControls = ordered() {
                  CheckerSize = {
                     INP_MinScale = 0,
                     INP_Integer = true,
                     INP_MinAllowed = 0,
                     LINKID_DataType = "Number",
                     INPID_InputControl = "SliderControl",
                     IC_ControlPage = 0,
                     INP_MaxScale = 100,
                     INP_Default = 64,
                  }
               }
            },
            CustomTool1LUTIn1 = LUTBezier {
               KeyColorSplines = {
                  [0] = {
                     [0] = { 0, RH = { 0.333333333333333, 0.333333333333333 }, Flags = { Linear = true } },
                     [1] = { 1, LH = { 0.666666666666667, 0.666666666666667 }, Flags = { Linear = true } }
                  }
               },
               SplineColor = { Red = 204, Green = 0, Blue = 0 },
               CtrlWZoom = false,
            },
            CustomTool1LUTIn2 = LUTBezier {
               KeyColorSplines = {
                  [0] = {
                     [0] = { 0, RH = { 0.333333333333333, 0.333333333333333 }, Flags = { Linear = true } },
                     [1] = { 1, LH = { 0.666666666666667, 0.666666666666667 }, Flags = { Linear = true } }
                  }
               },
               SplineColor = { Red = 0, Green = 204, Blue = 0 },
               CtrlWZoom = false,
            },
            CustomTool1LUTIn3 = LUTBezier {
               KeyColorSplines = {
                  [0] = {
                     [0] = { 0, RH = { 0.333333333333333, 0.333333333333333 }, Flags = { Linear = true } },
                     [1] = { 1, LH = { 0.666666666666667, 0.666666666666667 }, Flags = { Linear = true } }
                  }
               },
               SplineColor = { Red = 0, Green = 0, Blue = 204 },
               CtrlWZoom = false,
            },
            CustomTool1LUTIn4 = LUTBezier {
               KeyColorSplines = {
                  [0] = {
                     [0] = { 0, RH = { 0.333333333333333, 0.333333333333333 }, Flags = { Linear = true } },
                     [1] = { 1, LH = { 0.666666666666667, 0.666666666666667 }, Flags = { Linear = true } }
                  }
               },
               SplineColor = { Red = 204, Green = 204, Blue = 204 },
               CtrlWZoom = false,
            }
         },
      },
      Text1 = TextPlus {
         CtrlWZoom = false,
         Inputs = {
            GlobalOut = Input { Value = 119, },
            Width = Input { Value = 1920, },
            Height = Input { Value = 1080, },
            UseFrameFormatSettings = Input { Value = 1, },
            ["Gamut.SLogVersion"] = Input { Value = FuID { "SLog2" }, },
            Center = Input { Value = { 0.504153134419029, 0.529632636492795 }, },
            LayoutRotation = Input { Value = 1, },
            TransformRotation = Input { Value = 1, },
            Green1 = Input { Value = 0, },
            Blue1 = Input { Value = 0.0156862745098039, },
            Softness1 = Input { Value = 1, },
            StyledText = Input {
               SourceOp = "TimeCode1",
               Source = "Time",
            },
            Font = Input { Value = "Open Sans", },
            Style = Input { Value = "Bold", },
            Size = Input { Value = 0.2012, },
            VerticalJustificationNew = Input { Value = 3, },
            HorizontalJustificationNew = Input { Value = 3, }
         },
         ViewInfo = OperatorInfo { Pos = { 330, 16.5 } },
      },
      TimeCode1 = TimeCode {
         CtrlWZoom = false,
      }
   }
}

P.S. Please make sure this works on the uTexture as well. We need to use inputs to load texture so we can run color corrects to compensate for the Storm renderer with our comps.

+1

Unfortunately, the usd tools are not yet in a place in which most people can seriously consider to use them for comp projects.

Of course I am not assuming the new usd tools will have feature parity with Fusions old 3D system in two years, but so far I wasn't able to actually use it in my projects at all because of the limitations.

Despite the fact that I would prefer to export 3D scenes as USD and benefit from importing the whole scene with a uLoader instead of having to use the abc/fbx import dialogue each time for a new 3D scene export.

Especially because if I'm creating a scene in Houdini I will export them to USD anyway before rendering so I have the file available.

Features like dynamic textures from inside of Fusion, being able to change parameters of everything in the scene (like Houdini does it, so the overrides exist as nodes), (Camera) UV projections, and of course a more capable render engine.

I personally am not talking about a ray tracing engine, I think that could be covered by eventually having more established engines inside of Fusion, but a render engine that is made for compositing.

Similar to the Software renderer that deals well with blending modes, Matte Objects, Anti Aliasing, Particles etc.

I was actually hoping Blackmagic would create a fork of AMDs Open source ProRenderer. That already has a USD Plugin, renders with Material X and has several render engines inside that do a mix of full Ray tracing to some shortcuts that only trace shadows etc. and renders on all GPUs.

Might be a good starting point.

Enabling Inputs for texturing is priority one. Once you can actually use it with the rest of Fusion in the way that compositors use 3D, I'll feel a lot better about the whole thing. The other thing that has me worried is the ability to EXPORT USD from Fusion. I use Fusion now to block out my shots, then export FBXs to Houdini or Maya and get into it. Saving USD is really important for the ability to create and update camera movements and overall frame counts in shots that might be updated or changed by a client in a rough edit. Having the ability to export new scene data saves a lot of time and possibilities for errors.

I've wondered about which renderers would be good for Fusion and I might have come across why nothing plugs into USD.

How are you going to have a GPU renderer compute free VRAM per frame if GPU enabled tools load and hold onto VRAM while processing a texture. Imagine making a highly processed texture that eats all your VRAM and THEN Redshift comes along and looks at what's left. You'd have 500Mb available for rendering. This could be a major issue. Would they have to rewrite the way Fusion handles per frame VRAM releases? Are they even going to acknowledge this problem with Hydra delegates?

Yikes...

+1 Still an issue

Support for animation is definitely needed to even come close to functionality of classic 3D system in fusion. +1 on adding ability to have same level of input support as previous system and for transparency so we can have shadows rendered with GPU. And of course ability to render various aux channels for compositing. So far no animation support and only z-depth aux channel is supported, so I hope we see more updates in the near future.

As far as I can see uImagePlane Input only accepts static image. We need animation support of all formats that can be added as media. Just like classic 3D system.